andrea.villa
1739 lines
64 KiB
Plaintext
1739 lines
64 KiB
Plaintext
-- Processore standard macchine FAST by EgalWare s.r.l. 2024/02/23
|
|
-- Con controllo numerico NUM
|
|
|
|
-- carico librerie
|
|
local INFO_STD_PP = require( 'Version')
|
|
local BD = require( 'BeamData')
|
|
|
|
-- Variabili di modulo
|
|
local CSP_INFO = INFO_STD_PP.NAME..'_'..NumericalControl..' ver.'..INFO_STD_PP.VERSION..' by EgalWare s.r.l.'
|
|
local MACHINE_INFO = MACH_NAME..' ver.'..PP_VER
|
|
local TEST_USE = false
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** GENERATION ***
|
|
---------------------------------------------------------------------
|
|
function OnStart()
|
|
-- controllo versione programma
|
|
if not EMT.VER or EMT.VER < MIN_MACH_VER then
|
|
EmtSetLastError( 1200, 'A newer version of the program is required (minimum EgtMachKernel '..MIN_MACH_VER..')')
|
|
end
|
|
EMT.USETO1 = false -- abilitazione uso origine tavola
|
|
EMT.MODAL = true -- abilitazione emissione modale
|
|
EMT.INCHES = false -- unità di misura mm/inches
|
|
EMT.NUM = false -- abilitazione numerazione linee
|
|
--EMT.Nt = 'N' -- token per la numerazione di linea
|
|
--EMT.LINENBR = 0 -- numero di linea
|
|
--EMT.LINEINC = 1 -- incremento numerazione linee
|
|
--EMT.Ft = 'F' -- token per feed
|
|
--EMT.St = 'S' -- token per speed
|
|
EMT.FMAXPINZE = EgtClamp( MaxFeedPinze or 154000, 20000, 160000) -- feed massima pinze
|
|
EMT.MAXACC = MaxAcc or ( EMT.FMAXPINZE / ( 60 * 0.3)) -- accelerazione massima pinze
|
|
EMT.MINACC = MinAcc or ( EMT.FMAXPINZE / ( 60 * 4)) -- accelerazione minima pinze
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnEnd()
|
|
-- Ripristino fase iniziale come corrente
|
|
EgtSetCurrPhase( 1)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnProgramStart()
|
|
-- Intestazioni
|
|
local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or EgtGetCurrMachGroup() or GDB_ID.NULL
|
|
local nPatt = EgtGetInfo( BtlInfoId, 'PATTID', 'i') or 40
|
|
EmtOutput( '%'..EgtNumToString( nPatt, 0)..'.0')
|
|
|
|
-- aggiungo prefisso per commentae commenti iniziali se la macchina è utilizzata per fare i test
|
|
local sPrefixCommentLine = '' ; if IS_TEST_MACHINE or EgtEndsWith( EgtGetCurrMachineDir(), '.TEST') then sPrefixCommentLine = '//' end
|
|
|
|
if EMT.INFO then
|
|
EmtOutput( sPrefixCommentLine..'('..EMT.INFO..')')
|
|
else
|
|
EmtOutput( '(Program Start)')
|
|
end
|
|
EmtOutput( sPrefixCommentLine..'('.. CSP_INFO..')')
|
|
EmtOutput( sPrefixCommentLine..'('.. MACHINE_INFO..')\n')
|
|
EmtOutput( '(HEADER)')
|
|
-- Se modalità test, aggiungo linee per muovere tappeto e alzare la testa (in automatico viene fatto dal main residente)
|
|
if TEST_USE then
|
|
EmtOutput( 'M28')
|
|
EmtOutput( 'N1 G101 Z-100 L0=0')
|
|
EmtOutput( 'N1 G101 ET1001')
|
|
EmtOutput( 'N1 G101 ET2001\n')
|
|
end
|
|
-- Cerco primo utensile su testa 1
|
|
EMT.TOOL_1, EMT.TLEN_1 = FindFirstToolOnHead( 'H1')
|
|
-- Dichiaro inizio
|
|
EMT.FIRST = true
|
|
EMT.TLAST = nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnProgramEnd()
|
|
-- Arresto mandrino
|
|
EmtOutput( 'M05')
|
|
-- Emissione scarico
|
|
--for i = 1, #EMT.AUXCMD do
|
|
-- EmtOutput( '( ' .. EMT.AUXCMD[i] .. ' )')
|
|
--end
|
|
EMT.AUXCMD = {}
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
if #EMT.AUXSTR > 0 then
|
|
if EMT.AUXTYPE == 'S' or EMT.AUXTYPE == 'R' then
|
|
EmtOutput( 'G111 ET1004')
|
|
EmtOutput( 'G111 ET2004')
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
local sP1x = EgtIf( EMT.CHY_ON, '4', '2')
|
|
EmtOutput( 'G111 ET100'..sP1x)
|
|
EmtOutput( 'G111 ET200'..sP1x)
|
|
-- emissione conclusione pezzo precedente (se non si è in test)
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sEnd= 'G113 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sEnd)
|
|
end
|
|
end
|
|
end
|
|
EMT.AUXSTR = {}
|
|
EMT.AUXTYPE = nil
|
|
EMT.U_STD = nil
|
|
EMT.UNL = nil
|
|
EMT.PREROT = nil
|
|
EMT.SPLITROT = nil
|
|
EMT.CHY_ON = nil
|
|
EMT.FALL = nil
|
|
EMT.RELOAD = nil
|
|
EMT.RELOAD2 = nil
|
|
EmtOutput( '(FOOTER)')
|
|
-- Se modalità test, termino il programma
|
|
if TEST_USE then
|
|
EmtOutput( 'M02')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnToolData()
|
|
-- emissione dati utensile (esclusa lama)
|
|
if EMT.HEAD == 'H1' then
|
|
-- output info
|
|
local sPos
|
|
if #EMT.TCPOS == 2 then
|
|
sPos = EMT.TCPOS:gsub( 'T', 'N30')
|
|
elseif #EMT.TCPOS == 3 then
|
|
sPos = EMT.TCPOS:gsub( 'T', 'N3')
|
|
else
|
|
sPos = EMT.TCPOS:gsub( 'T1', 'N4')
|
|
end
|
|
local sOut = 'L1='..EgtNumToString( EMT.SMAX, 0)..' L2='..EmtLenToString( EMT.TTOTLEN, 1)..' G76H9998.2'..sPos..sPos
|
|
EmtOutput( sOut)
|
|
-- cerco posizione di attrezzaggio del primo utensile di lavorazione
|
|
if EMT.TOOL == EMT.TOOL_1 and EMT.TLEN_1 < 215.5 then
|
|
EMT.TCPOS_1 = EMT.TCPOS
|
|
end
|
|
-- emissione dati sega a catena
|
|
elseif EMT.HEAD == 'H3' then
|
|
if EMT.TDIST and abs( EMT.TDIST) < 0.1 then EMT.TDIST = nil end
|
|
local sOut = 'L1='..EgtNumToString( EMT.SMAX, 0)..' L2='..EmtLenToString( ( EMT.TDIST or ChSawLen), 1)..' G76H9998.2N401N404'
|
|
EmtOutput( sOut)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnDispositionStart()
|
|
--EmtOutput( '(Disposition '..EMT.DISPIND..' = '..EMT.DISPID..')')
|
|
EMT.OPEISDISP = true
|
|
-- Assegnazione parametri disposizione
|
|
EMT.TPOS = EgtGetInfo( EMT.DISPID, 'TPOS', 'd')
|
|
EMT.YPOS = EgtGetInfo( EMT.DISPID, 'YPOS', 'd')
|
|
-- Se prima disposizione
|
|
if EMT.PHASE == 1 then
|
|
-- emissione dati di macchina
|
|
local sOut = 'G114 EA'..EmtLenToString( LoadT, 2)..' EB'..EmtLenToString( MinY, 2)..' EC'..EmtLenToString( MaxY, 2)..
|
|
' ED'..EmtLenToString( MinV, 2)..' EE'..EmtLenToString( MaxV, 2)..' EF'..EmtLenToString( MillOffs, 2)..
|
|
' EG'..EmtLenToString( SawOffs, 2)..' EI'..EmtLenToString( ParkY, 2)..' EL'..EmtLenToString( ParkV, 2)..
|
|
' EM'..EmtLenToString( TurnerOffs, 2)
|
|
EmtOutput( '\n' .. sOut .. '\n')
|
|
-- carico barra
|
|
EMT.LOAD = true
|
|
else
|
|
EMT.LOAD = false
|
|
if IsEnd2Phase( EMT.PHASE - 1) then
|
|
EMT.RELOAD = true
|
|
EMT.RELOAD2 = false
|
|
elseif IsStartPhase( EMT.PHASE) then
|
|
EMT.YDELTA = EMT.YPOS - LoadT
|
|
EMT.VDELTA = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnDispositionEnd()
|
|
-- Se disposizione inizio o rimanenza
|
|
if IsStartOrRestPhase( EMT.PHASE) then
|
|
-- reset recupero sovramateriale in X non più presente
|
|
EMT.X_OFF = nil
|
|
-- dati del grezzo
|
|
local LBarra = EMT.LB
|
|
-- dati del pezzo
|
|
local IdTrave = EMT.IT
|
|
local LTrave = EMT.LT
|
|
local HTrave = EMT.HT
|
|
local STrave = EMT.ST
|
|
local HOverM = EMT.HOVM
|
|
-- calcolo dati pinze
|
|
local KgMtCubo= WoodDensity or 550 -- densità legno in Kg / metro cubo
|
|
local Massa = ( HTrave * STrave * LBarra * KgMtCubo ) / 1000000000
|
|
local FMaxPinze = EMT.FMAXPINZE
|
|
local ForzaAtrito = 700 / 2 -- Serve per regolare P32 (700 valore reale pistone)
|
|
local TempoAcc = ( ( Massa * FMaxPinze) / ( 60 * ForzaAtrito) / 1000)
|
|
local AccPinze = EgtClamp( FMaxPinze / ( 60 * TempoAcc), EMT.MINACC, EMT.MAXACC)
|
|
local RidFeed = 100 / Massa * 100
|
|
if ( RidFeed > 100) then RidFeed = 100 end
|
|
if IdTrave >= 0 then
|
|
local sOut = '( SN='..IdTrave..' LBarra='..EmtLenToString(LBarra,3)..' L='..EmtLenToString(LTrave,3)..
|
|
' H='..EmtLenToString(HTrave,3)..' S='..EmtLenToString(STrave,3)..' Acc='..EmtLenToString(TempoAcc,1)..
|
|
' RidFeed='..EmtLenToString(RidFeed,3)..' FeedMax='..EmtLenToString(FMaxPinze / 100 * RidFeed,3)..' )'
|
|
MyOutputNoNum( sOut)
|
|
sOut = 'E30049='..EmtLenToString(AccPinze,0)..' E30050=8555 E30051='..EmtLenToString(AccPinze,0)..
|
|
' E30052=8555'..' E30054='..EmtLenToString(AccPinze,0)..' E30039='..EmtLenToString(RidFeed*1000,0)..
|
|
' E30040='..EmtLenToString(RidFeed*1000,0)..' E30017=E80017'..' E30018=E80018'..' E10012=1'
|
|
MyOutputNoNum( sOut)
|
|
local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or EgtGetCurrMachGroup() or GDB_ID.NULL
|
|
EMT.PRODID = EgtGetInfo( BtlInfoId, 'PRODID', 'i') or 0
|
|
EMT.PATTID = EgtGetInfo( BtlInfoId, 'PATTID', 'i') or 0
|
|
EMT.CUTID = EgtGetInfo( EMT.IDT, 'CUTID', 'i') or 0
|
|
local sStart = '(G113 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED1)'
|
|
-- da emettere solo se aggiorna PLC
|
|
EmtOutput( sStart)
|
|
else
|
|
MyOutputNoNum( '(REMAIN UNLOAD)')
|
|
EMT.PRODID = nil
|
|
EMT.PATTID = nil
|
|
EMT.CUTID = nil
|
|
end
|
|
-- se carico barra
|
|
if EMT.LOAD then
|
|
-- verifico se sezione già caricata
|
|
local sOut = 'IF E30036<'..EmtLenToString(HTrave*1000,0)..' OR E30033<'..EmtLenToString(STrave*1000,0)..' THEN'
|
|
EmtOutput( sOut)
|
|
sOut = 'M119'
|
|
EmtOutput( sOut)
|
|
sOut = 'M149'
|
|
EmtOutput( sOut)
|
|
sOut = 'ENDI'
|
|
EmtOutput( sOut)
|
|
-- assegnazione dati trave e barra
|
|
sOut = 'E30036='..EmtLenToString(HTrave*1000,0)..' E30033='..EmtLenToString(STrave*1000,0)..
|
|
' E30069='..EmtLenToString(LBarra*1000,0)
|
|
EmtOutput( sOut)
|
|
-- preselezione prima fresa (della testa 1)
|
|
sOut = 'IF E30001=0 THEN'
|
|
EmtOutput( sOut)
|
|
sOut = 'M6' .. ( EMT.TCPOS_1 or 'T1')
|
|
-- va scritto 2 volte
|
|
EmtOutput( sOut)
|
|
EmtOutput( sOut)
|
|
sOut = 'ENDI'
|
|
EmtOutput( sOut)
|
|
-- ora abilito numerazione linee
|
|
EMT.NUM = true
|
|
EMT.LINENBR = 0
|
|
-- se altrimenti ricarico barra dopo rotazione speciale
|
|
elseif EMT.RELOAD then
|
|
-- assegnazione dati trave e barra
|
|
sOut = 'E30036='..EmtLenToString(HTrave*1000,0)..' E30033='..EmtLenToString(STrave*1000,0)..
|
|
' E30069='..EmtLenToString(LBarra*1000,0)
|
|
EmtOutput( sOut)
|
|
-- altrimenti recupero rimanenza
|
|
else
|
|
EmtOutput( 'G112 EC1'..' Y'..EmtLenToString( EMT.TPOS, 3).. ' EY'..EmtLenToString( EMT.YPOS, 3)..' EV'..EmtLenToString( ParkV, 3) ..' EF'..GetFmaxClamp())
|
|
-- aggiorno dati aggancio carrelli alla trave
|
|
EMT.YDELTA = EMT.YPOS - EMT.TPOS
|
|
EMT.VDELTA = nil
|
|
end
|
|
-- eventuale preparazione per rotazione immediata
|
|
if IsStartPhase( EMT.PHASE) and EMT.AUXSTR then
|
|
-- emissione movimento carrelli per rotazione
|
|
EMT.AUXCMD = {}
|
|
if #EMT.AUXSTR > 0 then
|
|
EmtOutput( '(ROTATION)')
|
|
end
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
if #EMT.AUXSTR > 0 then
|
|
EmtOutput( 'G111 ET1004')
|
|
EmtOutput( 'G111 ET2004')
|
|
end
|
|
EMT.AUXSTR = {}
|
|
EMT.AUXTYPE = nil
|
|
end
|
|
-- se altrimenti disposizione intermedia, eventuale rotazione
|
|
elseif IsMidPhase( EMT.PHASE) or IsEnd2Phase( EMT.PHASE) then
|
|
-- se rotazioni diverse, emetto il comando e aggiorno lo stato
|
|
if VerifyEmitRotation() then
|
|
-- imposto stato post-rotazione
|
|
EMT.POSTROT = true
|
|
-- imposto recupero sovramateriale in X non più presente
|
|
EMT.X_OFF = EMT.HOVM
|
|
end
|
|
-- se altrimenti disposizione intermedia speciale con eventuale rotazione
|
|
elseif IsMid2Phase( EMT.PHASE) then
|
|
-- emissione movimento carrelli
|
|
EMT.AUXCMD = {}
|
|
if #EMT.AUXSTR > 0 then
|
|
EmtOutput( '(ROTATION)')
|
|
end
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
if #EMT.AUXSTR > 0 then
|
|
EmtOutput( 'G111 ET1004')
|
|
EmtOutput( 'G111 ET2004')
|
|
end
|
|
EMT.AUXSTR = {}
|
|
EMT.AUXTYPE = nil
|
|
-- se rotazioni diverse, emetto il comando e aggiorno lo stato
|
|
if VerifyEmitRotation() then
|
|
-- imposto stato post-rotazione
|
|
EMT.POSTROT = true
|
|
-- imposto recupero sovramateriale in X non più presente
|
|
EMT.X_OFF = EMT.HOVM
|
|
end
|
|
-- altrimenti disposizione finale, eventuale scarico pezzo lavorato se non ci sono lavorazioni
|
|
else
|
|
EMT.AUXCMD = {}
|
|
if #EMT.AUXSTR > 0 then
|
|
MyOutputNoNum( '(PART UNLOAD)')
|
|
end
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
if #EMT.AUXSTR > 0 then
|
|
EmtOutput( 'G111 ET1002')
|
|
EmtOutput( 'G111 ET2002')
|
|
-- emissione conclusione pezzo precedente
|
|
if EMT.PRODID then
|
|
local sEnd= 'G113 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sEnd)
|
|
end
|
|
end
|
|
EMT.AUXSTR = {}
|
|
EMT.AUXTYPE = nil
|
|
EMT.U_STD = nil
|
|
end
|
|
|
|
EMT.OPEISDISP = false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnTableData()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnFixtureData()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnRawMoveData()
|
|
-- Se disposizione inizio o rimanenza
|
|
if IsStartOrRestPhase( EMT.PHASE) then
|
|
-- se primo grezzo, reset lunghezza barra
|
|
if EMT.RAWIND == 1 then EMT.LB = 0 end
|
|
-- aggiungo la lunghezza del grezzo (solo se movimento in corner)
|
|
if EMT.RAWTYPE == 1 then
|
|
local b3Raw = EgtGetBBoxGlob( EgtGetFirstNameInGroup( EMT.RAWID, 'RawSolid'), GDB_BB.STANDARD)
|
|
local LBarra = b3Raw:getDimX()
|
|
EMT.LB = EMT.LB + LBarra
|
|
end
|
|
-- se primo grezzo, calcolo dati del pezzo
|
|
if EMT.RAWIND == 1 then
|
|
local PartId = EgtGetFirstPartInRawPart( EMT.RAWID)
|
|
if PartId then
|
|
EMT.IDT = PartId
|
|
EMT.IT = EgtGetInfo( PartId, 'PDN', 'i') or 0
|
|
local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PartId, 'Box'), GDB_BB.STANDARD)
|
|
EMT.LT = b3Part:getDimX()
|
|
EMT.HT = b3Part:getDimY()
|
|
EMT.ST = b3Part:getDimZ()
|
|
EMT.HOVM = EgtGetInfo( EMT.RAWID, 'HOVM', 'd') or 0
|
|
else
|
|
EMT.IDT = GDB_ID.NULL
|
|
EMT.IT = -1
|
|
EMT.LT = 0
|
|
EMT.HT = EMT.HT or 0
|
|
EMT.ST = EMT.ST or 0
|
|
EMT.HOVM = 0
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnToolSelect()
|
|
-- se utensile definito (non definito per disposizioni con movimento)
|
|
if EMT.TOOL ~= '' then
|
|
-- verifiche su utensile
|
|
local sTool = EgtTdbGetToolFromUUID( EgtGetMachiningParam( MCH_MP.TUUID) or "")
|
|
if sTool ~= EMT.TOOL then error( "Tool name mismatch") end
|
|
-- predefinite EMT.TCPOS EMT.HEAD EMT.EXIT
|
|
EMT.TOOLTYPE = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
|
|
EMT.TOOLSEL = EMT.TCPOS..' M06'
|
|
EMT.TDIAM = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
|
EMT.TTOTDIAM = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM)
|
|
EMT.TLEN = EgtTdbGetCurrToolParam( MCH_TP.LEN)
|
|
EMT.TTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
|
if MCH_TP.DIST then EMT.TDIST = EgtTdbGetCurrToolParam( MCH_TP.DIST) end
|
|
if EMT.TDIST and abs( EMT.TDIST) < 0.1 then EMT.TDIST = nil end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnToolDeselect()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnMachiningStart()
|
|
--EMT.MCHNAME = EgtGetMachiningParam(MCH_MP.NAME)
|
|
EMT.MCHNAME = EgtGetOperationName( EMT.MCHID)
|
|
EMT.MCHTYPE = EgtGetMachiningParam(MCH_MP.TYPE)
|
|
EMT.MCHUSERNOTES = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
-- non ancora iniziata la lavorazione
|
|
EMT.MCHFIRST = true
|
|
-- sistemazione speed
|
|
if EMT.HEAD == 'H2' then
|
|
EMT.S = EMT.S * 6
|
|
end
|
|
-- determino subito se taglio di separazione di pezzo a caduta
|
|
EMT.PREFALLCUT = nil
|
|
if EMT.MCHUSERNOTES and EMT.MCHUSERNOTES:find( 'Split') then
|
|
local ClId = EgtGetFirstNameInGroup( EMT.MCHID, 'CL')
|
|
local P1Id = EgtGetFirstNameInGroup( ClId or GDB_ID.NULL, 'P1')
|
|
local sAE1 = EgtGetInfo( P1Id or GDB_ID.NULL, 'AE1') or ''
|
|
if sAE1 == '0,Fall' then
|
|
EMT.PREFALLCUT = true
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnMachiningEnd()
|
|
--EmtOutput( ';Mach End')
|
|
-- Emissione split
|
|
--for i = 1, #EMT.AUXCMD do
|
|
-- EmtOutput( '( ' .. EMT.AUXCMD[i] .. ' )')
|
|
--end
|
|
EMT.AUXCMD = {}
|
|
if #EMT.AUXSTR > 0 then
|
|
if EMT.AUXTYPE == 'S' then
|
|
MyOutputNoNum( '(PART SPLIT)')
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
if not EMT.ZMAX then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
end
|
|
MyOutputNoNum( '(PART UNLOAD)')
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
if EMT.PREROT then
|
|
if not EMT.ZMAX then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
end
|
|
MyOutputNoNum( '(PART ROTATION)')
|
|
elseif EMT.FALL then
|
|
if not EMT.ZMAX then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
end
|
|
EmtOutput( '(FALL)')
|
|
else
|
|
if not EMT.ZMAX then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
end
|
|
EmtOutput( '(SPLIT 2)')
|
|
end
|
|
end
|
|
end
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
if #EMT.AUXSTR > 0 then
|
|
if EMT.AUXTYPE == 'S' then
|
|
EmtOutput( 'G111 ET1004')
|
|
EmtOutput( 'G111 ET2004')
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
local sP1x = EgtIf( EMT.CHY_ON, '4', '2')
|
|
EmtOutput( 'G111 ET100'..sP1x)
|
|
EmtOutput( 'G111 ET200'..sP1x)
|
|
-- emissione conclusione pezzo precedente
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sEnd= 'G113 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sEnd)
|
|
end
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
EmtOutput( 'G111 ET1004')
|
|
EmtOutput( 'G111 ET2004')
|
|
if EMT.FALL then
|
|
EmtOutput( 'M155')
|
|
EmtOutput( 'M28')
|
|
-- emissione conclusione pezzo (se non in modalità test)
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sEnd= 'G113 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sEnd)
|
|
end
|
|
elseif not EMT.PREROT then
|
|
EmtOutput( 'M77')
|
|
end
|
|
end
|
|
end
|
|
EMT.AUXSTR = {}
|
|
EMT.AUXTYPE = nil
|
|
EMT.U_STD = nil
|
|
EMT.PREVTOOL = EMT.TOOL
|
|
EMT.PREVHEAD = EMT.HEAD
|
|
EMT.PREVET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathStart()
|
|
-- non ancora iniziata la lavorazione
|
|
EMT.MCHFIRST = true
|
|
-- primo posizionamento sempre in globale
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
|
|
-- salvo precedenti rotanti
|
|
EMT.R1pp = EMT.R1p
|
|
EMT.R2pp = EMT.R2p
|
|
EMT.R3pp = EMT.R3p
|
|
|
|
-- reset valori precedenti (per forzare emissione di tutti gli assi del 1° movimento)
|
|
EmtResetPrev()
|
|
EMT.AUXCMD = {}
|
|
EMT.AUXSTR = {}
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathEnd()
|
|
EMT.AUXTYPE = nil
|
|
EMT.UNL = nil
|
|
EMT.PREROT = nil
|
|
EMT.SPLITROT = nil
|
|
EMT.CHY_ON = nil
|
|
EMT.FALL = nil
|
|
EMT.AUXCMD = {}
|
|
EMT.AUXSTR = {}
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathStartAux()
|
|
--EgtOutLog( 'OnPathStartAux - ' .. EgtNumToString( EMT.AUXIND, 0) .. ' - ' .. EMT.AUX)
|
|
|
|
-- se richiesto, preparo il carico barra
|
|
if EMT.LOAD or EMT.RELOAD then
|
|
PrepareLoad( EMT.AUX, true)
|
|
-- se altrimenti carico dopo rotazione
|
|
elseif EMT.POSTROT then
|
|
PreparePostRotation( EMT.AUX)
|
|
-- altrimenti, preparo lo spostamento carrelli
|
|
else
|
|
PrepareMoveChar( EMT.AUX)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathEndAux()
|
|
--EgtOutLog( 'OnPathEndAux - ' .. EgtNumToString( EMT.AUXIND, 0) .. ' - ' .. EMT.AUX)
|
|
-- verifico tipo di emissione
|
|
if EMT.OPEISDISP then
|
|
if not EMT.AUXTYPE then
|
|
local Cmd = EgtSplitString( EMT.AUX)
|
|
if Cmd[1] == '0' and Cmd[2] == 'Unloading' then
|
|
EMT.AUXTYPE = 'U'
|
|
elseif EgtGetInfo( EMT.DISPID, 'TYPE') == 'REST' then
|
|
EMT.AUXTYPE = 'R'
|
|
else
|
|
EMT.AUXTYPE = 'P'
|
|
end
|
|
end
|
|
else
|
|
if not EMT.AUXTYPE then
|
|
local Cmd = EgtSplitString( EMT.AUX)
|
|
if Cmd[1] == '0' and Cmd[2] == 'Split' then
|
|
EMT.AUXTYPE = 'S'
|
|
elseif Cmd[1] == '0' and Cmd[2] == 'Unloading' then
|
|
EMT.AUXTYPE = 'U'
|
|
else
|
|
EMT.AUXTYPE = 'P'
|
|
if Cmd[1] == '0' and Cmd[2] == 'Fall' then
|
|
EMT.FALL = true
|
|
end
|
|
end
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
local Cmd = EgtSplitString( EMT.AUX)
|
|
if Cmd[1] == '0' and Cmd[2] == 'Unloading' then
|
|
EMT.CHY_ON = true
|
|
EMT.AUXTYPE = 'U'
|
|
end
|
|
end
|
|
end
|
|
-- preparo a seconda del tipo
|
|
if EMT.AUXTYPE == 'R' then
|
|
-- per il carico della rimanenza dopo rotazione speciale
|
|
if EMT.RELOAD and not EMT.RELOAD2 then
|
|
PrepareLoad( EMT.AUX, false)
|
|
-- per lo scarico della rimanenza
|
|
else
|
|
PrepareResidue( EMT.AUX)
|
|
end
|
|
elseif EMT.AUXTYPE == 'S' then
|
|
-- per lo split
|
|
PrepareSplit( EMT.AUX)
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
-- per lo scarico
|
|
PrepareUnload( EMT.AUX)
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
-- per la pre-rotazione
|
|
PreparePreRotation( EMT.AUX)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnRapid()
|
|
-- recupero prossimo utensile
|
|
EMT.NEXTTOOL, EMT.NEXTHEAD, EMT.NEXTTCPOS = FindNextTool()
|
|
MyBackupAxes()
|
|
-- se primo movimento della lavorazione, gestione speciale
|
|
if EMT.MCHFIRST and not EMT.OPEISDISP then
|
|
-- primo posizionamento
|
|
local MyZHome = EgtGetAxisHomePos( 'Z')
|
|
local bZmax = ( #EMT.AUXSTR > 0 or EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1)
|
|
-- decido se muovere prima testa o carrelli (standard prima testa)
|
|
local bHeadFirst = true
|
|
local sLateG101
|
|
if not ( EMT.LOAD or EMT.RELOAD) and not EMT.ZMAX then
|
|
local DeltaT = EMT.L1 - EMT.TLAST
|
|
if ( DeltaT < -GEO.EPS_SMALL and EMT.VDELTA) or ( DeltaT > GEO.EPS_SMALL and EMT.YDELTA) then bHeadFirst = false end
|
|
end
|
|
-- sistemo movimenti
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
if not ( EMT.LOAD or EMT.RELOAD) then
|
|
if not EMT.ZMAX and #EMT.AUXSTR > 0 then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
bHeadFirst = false
|
|
end
|
|
end
|
|
|
|
local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3)
|
|
|
|
local bGoToHome = false
|
|
-- se gli assi rotanti cambiano parecchio, con motosega si va in parcheggio
|
|
if EMT.PREVHEAD == 'H3' and EMT.HEAD == 'H3' and ( sET ~= EMT.PREVET or abs( EMT.R2pp - EMT.R2) > 25 or abs( EMT.R1pp - EMT.R1) > 25) then
|
|
bGoToHome = true
|
|
end
|
|
|
|
-- ricavo i dati per la lavorazione
|
|
local sEE = ' EE' .. EgtIf( bZmax, '3', '4')
|
|
local sEL = ' EL' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TLEN, ( EMT.TDIST or ChSawLen)), 3)
|
|
local sER = ' ER' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TDIAM / 2, EMT.TLEN), 3)
|
|
local sES = ' ES'..EgtNumToString( EMT.S, 0)
|
|
|
|
-- se avevo motosega, torno in zona sicura senza ruotare assi rotanti
|
|
if not EMT.LOAD and EMT.PREVHEAD == 'H3' and EMT.FLAG2 == 1 then
|
|
-- se ho ancora motosega, si setta già asse C, altrimenti asse C per andare in home
|
|
local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
|
|
' B' .. EmtLenToString( EMT.R2pp, 3) .. ' C' .. EmtLenToString( EMT.R1pp, 3) ..
|
|
' EE' .. EgtIf( bZmax, '3', '4') .. EMT.PREVsEL .. EMT.PREVsER .. EMT.PREVsET .. EMT.PREVsES
|
|
EmtOutput( sOutPreMove)
|
|
sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
|
|
' B' .. EmtLenToString( 0, 3) .. ' C' .. EmtLenToString( EMT.R1pp, 3) ..
|
|
' EE' .. EgtIf( bZmax, '3', '4') .. EMT.PREVsEL .. EMT.PREVsER .. EMT.PREVsET .. EMT.PREVsES
|
|
EmtOutput( sOutPreMove)
|
|
EmtOutput( 'G101 ET1001')
|
|
EmtOutput( 'G101 ET2001')
|
|
end
|
|
|
|
if not EMT.LOAD then
|
|
local sOut = string.gsub( string.gsub( EMT.MCHNAME..'/'..EMT.TOOL, '%(', '-'), '%)', '-')
|
|
EmtOutput( '( *** ' .. sOut .. ' *** )')
|
|
end
|
|
|
|
-- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione
|
|
if EMT.HEAD == 'H3' and EMT.PREVHEAD ~= 'H3' then
|
|
local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
|
|
' B' .. EgtNumToString( 0, 3) .. ' C' .. EgtNumToString( EMT.R1, 3) .. sEE .. sEL .. sER .. sET .. sES
|
|
EmtOutput( sOutPreMove)
|
|
sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
|
|
' B' .. EgtNumToString( EMT.R2, 3) .. ' C' .. EgtNumToString( EMT.R1, 3) .. sEE .. sEL .. sER .. sET .. sES
|
|
EmtOutput( sOutPreMove)
|
|
EmtOutput( 'G101 ET1001')
|
|
EmtOutput( 'G101 ET2001')
|
|
-- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione
|
|
elseif not EMT.LOAD and ( EMT.HEAD == 'H3' or ( bZmax and EMT.TTOTLEN > 200)) and
|
|
( EMT.ST > BeamHeightForFixRot or ( EMT.HEAD == 'H1' and EMT.TTOTLEN > 350) or bGoToHome) and EMT.FLAG2 == 1 then
|
|
local sOutPreMove
|
|
if EMT.HEAD == 'H3' and bGoToHome then
|
|
sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
|
|
' B' .. EgtNumToString( 0, 3) .. ' C' .. EgtNumToString( EMT.R1, 3) .. sEE .. sEL .. sER .. sET .. sES
|
|
EmtOutput( sOutPreMove)
|
|
end
|
|
sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
|
|
' B' .. EgtNumToString( EMT.R2, 3) .. ' C' .. EgtNumToString( EMT.R1, 3) .. sEE .. sEL .. sER .. sET .. sES
|
|
EmtOutput( sOutPreMove)
|
|
EmtOutput( 'G101 ET1001')
|
|
EmtOutput( 'G101 ET2001')
|
|
end
|
|
EmtResetPrev()
|
|
-- se sono su pezzi alti e movimento da emettere, per sicurezza a Z massima
|
|
local MyZPos = EMT.L3
|
|
if EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then
|
|
MyZPos = MyZHome
|
|
end
|
|
local sOut = 'G101' .. EmtGetAxis( 'L2') .. ' Z' .. EmtLenToString( MyZPos, 3) ..
|
|
EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES
|
|
-- faccio backup dati in caso mi servano per lavorazione successiva
|
|
EMT.PREVsEE = sEE ; EMT.PREVsEL = sEL ; EMT.PREVsER = sER ; EMT.PREVsET = sET ; EMT.PREVsES = sES
|
|
|
|
if EMT.LOAD or bHeadFirst then
|
|
sOut = sOut..' L0=0'
|
|
EmtOutput( sOut)
|
|
sOut = 'G101 ET1001'
|
|
EmtOutput( sOut)
|
|
else
|
|
-- va ritardata anche l'emissione del comando
|
|
sLateG101 = sOut..' L0=0'
|
|
end
|
|
-- se prima lavorazione
|
|
if EMT.LOAD then
|
|
local nJump = 9
|
|
sOut = 'G79 E80060<>0 N' .. EgtNumToString( nJump, 0) .. ' E10015=0'
|
|
EmtOutput( sOut)
|
|
--for i = 1, #EMT.AUXCMD do
|
|
-- EmtOutput( '( ' .. EMT.AUXCMD[i] .. ' )')
|
|
--end
|
|
EMT.AUXCMD = {}
|
|
if #EMT.AUXSTR > 2 then
|
|
EmtOutput( EMT.AUXSTR[1] .. ' ET1')
|
|
EmtOutput( EMT.AUXSTR[2] .. 'ET1')
|
|
EmtOutput( 'G111 ET1001')
|
|
EmtOutput( 'G79 N' .. EgtNumToString( nJump, 0))
|
|
EmtOutput( 'E80060=1')
|
|
EmtOutput( 'G111 ET2001')
|
|
for i = 3, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
EmtOutput( 'G111 ET1004')
|
|
EmtOutput( 'G111 ET2004')
|
|
else
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
EmtOutput( 'G111 ET1001')
|
|
EmtOutput( 'G79 N' .. EgtNumToString( nJump, 0))
|
|
EmtOutput( 'E80060=1')
|
|
EmtOutput( 'G111 ET2001')
|
|
end
|
|
EMT.AUXSTR = {}
|
|
sOut = string.gsub( string.gsub( EMT.MCHNAME..'/'..EMT.TOOL, '%(', '-'), '%)', '-')
|
|
EmtOutput( '( *** ' .. sOut .. ' *** )')
|
|
sOut = 'G101 ET2001'
|
|
EmtOutput( sOut)
|
|
local sY, sA
|
|
if EMT.YDELTA then
|
|
sY = EmtLenToString( EMT.L1 + EMT.YDELTA)
|
|
sA = '1'
|
|
else
|
|
sY = EmtLenToString( ParkY)
|
|
sA = '2'
|
|
end
|
|
local sV, sB
|
|
if EMT.VDELTA then
|
|
sV = EmtLenToString( EMT.L1 + EMT.VDELTA)
|
|
sB = '1'
|
|
else
|
|
sV = EmtLenToString( ParkV)
|
|
sB = '2'
|
|
end
|
|
sOut = 'G112 EA'..sA..' EB'..sB..''..EmtGetAxis('L1')..' EY'..sY..' EV'..sV..' EF'..GetFmaxClamp()
|
|
EmtOutput( sOut)
|
|
EMT.LOAD = false
|
|
-- altrimenti lavorazione successiva
|
|
else
|
|
-- eventuale G111
|
|
--for i = 1, #EMT.AUXCMD do
|
|
-- EmtOutput( '( ' .. EMT.AUXCMD[i] .. ' )')
|
|
--end
|
|
EMT.AUXCMD = {}
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
if #EMT.AUXSTR > 0 then
|
|
if not ( EMT.POSTROT or EMT.RELOAD) then
|
|
EmtOutput( 'G111 ET1004')
|
|
EmtOutput( 'G111 ET2004')
|
|
else
|
|
EmtOutput( 'G111 ET1001')
|
|
EmtOutput( 'G111 ET2001')
|
|
end
|
|
end
|
|
EMT.AUXSTR = {}
|
|
local sY, sA
|
|
if EMT.YDELTA then
|
|
sY = EmtLenToString( EMT.L1 + EMT.YDELTA - ( EMT.X_OFF or 0))
|
|
sA = '1'
|
|
else
|
|
sY = EmtLenToString( EgtIf( EMT.YPOS, EMT.YPOS, ParkY))
|
|
sA = '2'
|
|
end
|
|
local sV, sB
|
|
if EMT.VDELTA then
|
|
sV = EmtLenToString( EMT.L1 + EMT.VDELTA - ( EMT.X_OFF or 0))
|
|
sB = '1'
|
|
else
|
|
sV = EmtLenToString( ParkV)
|
|
sB = '2'
|
|
end
|
|
if bHeadFirst then
|
|
sOut = 'G101 ET2001'
|
|
EmtOutput( sOut)
|
|
end
|
|
sOut = 'G112 EA'..sA..' EB'..sB..EmtGetAxis('L1')..' EY'..sY..' EV'..sV..' EF'..GetFmaxClamp()
|
|
EmtOutput( sOut)
|
|
if not bHeadFirst then
|
|
EmtOutput( sLateG101)
|
|
sOut = 'G101 ET1001'
|
|
EmtOutput( sOut)
|
|
sOut = 'G101 ET2001'
|
|
EmtOutput( sOut)
|
|
end
|
|
EMT.POSTROT = false
|
|
EMT.RELOAD = false
|
|
EMT.RELOAD2 = nil
|
|
end
|
|
-- se taglio di separazione prima di scarico a caduta, emissione stop tappeto scarico trucioli
|
|
if EMT.PREFALLCUT then
|
|
EmtOutput( 'M29')
|
|
EMT.PREFALLCUT = nil
|
|
end
|
|
EMT.REFLOC = 0
|
|
EMT.MCHFIRST = false
|
|
EMT.ZMAX = false
|
|
-- se alto in Z (non serve l'avvicinamento finale)
|
|
if EMT.FLAG == 2 then
|
|
-- aggiorno valori come precedenti
|
|
EMT.TLAST = EMT.L1b
|
|
EmtUpdatePrev()
|
|
return
|
|
-- altrimenti ripristino i valori originali degli assi
|
|
else
|
|
MyRestoreAxes()
|
|
end
|
|
end
|
|
-- se standard
|
|
if EMT.FLAG == 0 or EMT.FLAG == 1 or EMT.FLAG == 2 then
|
|
-- se necessario, impostazione riferimento locale
|
|
if EMT.REFLOC == 0 then
|
|
-- calcolo per piano generico
|
|
CalcInterpPlane()
|
|
EMT.REFLOC = 1
|
|
-- trasformo i punti nel piano
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
EMT.L1p = nil
|
|
EMT.L2p = nil
|
|
EMT.L3p = nil
|
|
EmtOutput( 'G102'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..EMT.IPLGLSTR)
|
|
else
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
end
|
|
-- emissione movimento
|
|
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')
|
|
if EMT.HEAD ~= 'H2' then sOut = sOut..EmtGetAxis('R2')..EmtGetAxis('R1') end
|
|
EmtOutput( sOut)
|
|
-- se altrimenti risalita a Z max a fine lavorazione
|
|
elseif EMT.FLAG == 3 then
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
-- se pezzi alti e devo cambiare utensile su testa con CU, porto la testa vicino al cambio utensile
|
|
if EMT.ST > BeamHeightForFixRot and EMT.HEAD == 'H1' and EMT.TOOL ~= EMT.NEXTTOOL and EMT.NEXTHEAD ~= 'H2' then
|
|
local dBAxis = 90
|
|
local dCAxis = EgtIf( BD.RIGHT_LOAD, 90, -90)
|
|
local sEE = ' EE3'
|
|
local sEL = ' EL' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TLEN, ( EMT.TDIST or ChSawLen)), 3)
|
|
local sER = ' ER' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TDIAM / 2, EMT.TLEN), 3)
|
|
local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3)
|
|
local sES = ' ES'..EgtNumToString( EMT.S, 0)
|
|
local sOut = 'G101' .. EmtGetAxis( 'L2') .. EmtGetAxis( 'L3') ..' B' .. EgtNumToString( dBAxis, 3) ..
|
|
' C' .. EgtNumToString( dCAxis, 3) .. sEE .. sEL .. sER .. sET .. sES
|
|
EmtOutput( sOut)
|
|
EmtOutput( 'G101 ET1001')
|
|
EmtOutput( 'G101 ET2001')
|
|
sOut = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. EmtGetAxis( 'L3') ..' B' .. EgtNumToString( dBAxis, 3) ..
|
|
' C' .. EgtNumToString( dCAxis, 3) .. sEE .. sEL .. sER .. sET .. sES
|
|
EmtOutput( sOut)
|
|
EmtOutput( 'G101 ET1001')
|
|
EmtOutput( 'G101 ET2001')
|
|
end
|
|
-- se altrimenti movimento in Home
|
|
elseif EMT.FLAG == 4 then
|
|
-- non previsto
|
|
-- se altrimenti rotazione a Z max per lavorazione successiva
|
|
elseif EMT.FLAG == 5 then
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
EmtResetPrev()
|
|
-- ricavo i dati per la lavorazione
|
|
local sEE = ' EE3'
|
|
local sEL = ' EL' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TLEN, ( EMT.TDIST or ChSawLen)), 3)
|
|
local sER = ' ER' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TDIAM / 2, EMT.TLEN), 3)
|
|
local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3)
|
|
local sES = ' ES'..EgtNumToString( EMT.S, 0)
|
|
local sOut = 'G101' .. EmtGetAxis( 'L2') .. EmtGetAxis( 'L3') ..
|
|
EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES
|
|
EmtOutput( sOut)
|
|
EmtOutput( 'G101 ET1001')
|
|
EmtOutput( 'G101 ET2001')
|
|
-- altrimenti errore
|
|
else
|
|
EmtSetLastError( 1212, "Unknown Rapid flag")
|
|
end
|
|
-- aggiorno valori come precedenti
|
|
EMT.TLAST = EMT.L1b
|
|
EmtUpdatePrev()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnLinear()
|
|
MyBackupAxes()
|
|
EMT.TLAST = EMT.L1
|
|
-- se necessario, impostazione riferimento locale
|
|
if EMT.REFLOC == 0 then
|
|
-- calcolo per piano generico
|
|
CalcInterpPlane()
|
|
EMT.REFLOC = 1
|
|
-- salvo posizione attuale
|
|
local OldL1 = EMT.L1
|
|
local OldL2 = EMT.L2
|
|
local OldL3 = EMT.L3
|
|
-- imposto posizione precedente (non contiene l'offset in X per sovramateriale di testa EMT.X_OFF)
|
|
EMT.L1 = EMT.L1o
|
|
EMT.L2 = EMT.L2o
|
|
EMT.L3 = EMT.L3o
|
|
-- trasformo i punti nel piano
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
EMT.L1p = nil
|
|
EMT.L2p = nil
|
|
EMT.L3p = nil
|
|
EmtOutput( 'G102'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..EMT.IPLGLSTR)
|
|
-- emissione movimento
|
|
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')
|
|
if EMT.HEAD ~= 'H2' then sOut = sOut..EmtGetAxis('R2')..EmtGetAxis('R1') end
|
|
EmtOutput( sOut)
|
|
-- ripristino posizione attuale
|
|
EMT.L1 = OldL1
|
|
EMT.L2 = OldL2
|
|
EMT.L3 = OldL3
|
|
end
|
|
|
|
-- aggiustamento valori
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
|
|
-- valori degli assi
|
|
local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')
|
|
if EMT.HEAD ~= 'H2' then sAxes = sAxes..EmtGetAxis('R2')..EmtGetAxis('R1') end
|
|
-- se nulla da emettere, esco
|
|
if string.len( sAxes) == 0 then
|
|
return
|
|
end
|
|
-- aggiungo feed
|
|
local sFeed = EmtGetFeed()
|
|
-- emetto linea
|
|
EmtOutput( "G1"..sAxes..sFeed)
|
|
|
|
-- aggiorno valori come precedenti
|
|
EmtUpdatePrev()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnArc()
|
|
MyBackupAxes()
|
|
EMT.TLAST = EMT.L1
|
|
-- non modale su archi
|
|
EmtResetPrevLinear()
|
|
-- aggiustamento valori
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
|
|
-- valori degli assi
|
|
local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')
|
|
if EMT.HEAD ~= 'H2' then sAxes = sAxes..EmtGetAxis('R2')..EmtGetAxis('R1') end
|
|
-- se nulla da emettere, esco
|
|
if string.len( sAxes) == 0 then
|
|
return
|
|
end
|
|
-- valori delle coordinate del centro
|
|
EmtAdjustCenterAxes()
|
|
-- coordinate centro (per ora solo archi nel piano XY)
|
|
--local sCen = ' ' .. EMT.C1t .. EmtLenToString(EMT.C1,3) ..
|
|
-- ' ' .. EMT.C2t .. EmtLenToString(EMT.C2,3)
|
|
-- raggio
|
|
local sRad = ' ' .. EMT.RRt .. EmtLenToString(EMT.RR,3)
|
|
-- aggiungo feed
|
|
local sFeed = EmtGetFeed()
|
|
-- tipo arco
|
|
local sArc = 'G' .. EgtNumToString(EMT.MOVE,0)
|
|
-- se arco molto grande, approssimo con una retta
|
|
if EMT.RR > 99999 then
|
|
EmtOutput( "G1"..sAxes..sFeed)
|
|
else
|
|
EmtOutput( sArc..sAxes..sRad..sFeed)
|
|
end
|
|
|
|
-- aggiorno valori come precedenti
|
|
EmtUpdatePrev()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function FindNextTool()
|
|
-- salvo stato iniziale
|
|
local CurrMachId = EgtGetCurrMachining()
|
|
local CurrTool = EgtTdbGetCurrToolParam( MCH_TP.NAME)
|
|
-- cerco lavorazione con utensile su gruppo testa indicato
|
|
local sTool, sHead, sTcPos
|
|
local OpId = EgtGetNextActiveOperation( CurrMachId or EMT.MCHID)
|
|
while OpId do
|
|
local nType = EgtGetOperationType( OpId)
|
|
if nType ~= MCH_OY.NONE and nType ~= MCH_OY.DISP then
|
|
if EgtSetCurrMachining( OpId) then
|
|
sTool = EgtGetMachiningParam( MCH_MP.TOOL)
|
|
if EgtTdbSetCurrTool( sTool) then
|
|
sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
sTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
OpId = EgtGetNextActiveOperation( OpId)
|
|
end
|
|
-- ripristino stato iniziale
|
|
EgtSetCurrMachining( CurrMachId or GDB_ID.NULL)
|
|
EgtTdbSetCurrTool( CurrTool or '')
|
|
-- restituisco risultato
|
|
return sTool, sHead, sTcPos
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function CalcCharStatus( sCmd, bSkipPress)
|
|
-- aperto
|
|
if sCmd == '0' then
|
|
return '1'
|
|
-- chiuso
|
|
elseif sCmd == '1' then
|
|
return '2'
|
|
-- chiuso con pressore attivato
|
|
elseif sCmd == '2' then
|
|
return EgtIf( bSkipPress, '2', '0')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareLoad( sCmd, bStart)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio
|
|
if EMT.AUXIND == 1 then
|
|
-- imposto stato pinze
|
|
EMT.SA = ' EA111'
|
|
EMT.SB = ' EB111'
|
|
EMT.SC = ' EC141'
|
|
EMT.SD = ' ED141'
|
|
EMT.SE = ' EE0'
|
|
end
|
|
-- se dichiarazione inizio riposizionamento carrelli
|
|
if Cmd[2] == 'CARR_MOVE' then
|
|
if bStart then
|
|
EMT.RELOAD = false
|
|
else
|
|
EMT.RELOAD2 = true
|
|
end
|
|
for i = 1, #EMT.AUXSTR do
|
|
EMT.AUXSTR[i] = string.gsub( EMT.AUXSTR[i], 'ET1', '')
|
|
end
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
local sMsg = Cmd[2] .. Cmd[3]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] ~= 'Z' then
|
|
local sOut = 'G111 '..Cmd[2]..Cmd[3]..EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
if Cmd[2] == 'Y' then EMT.YPOS = tonumber( Cmd[3]) end
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] == 'Y' then
|
|
local sYTaking = ' Y'..EmtLenToString( Cmd[3] + TurnerOffs)
|
|
local sBeamRot = '0'
|
|
if StartRotation and EMT.LB >= AutoRotMinLen then
|
|
local nRot = GetPhaseRot( EMT.PHASE)
|
|
local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or EgtGetCurrMachGroup() or GDB_ID.NULL
|
|
local nLoad90 = EgtGetInfo( BtlInfoId, 'LOAD90', 'i') or 0
|
|
sBeamRot = tostring( nLoad90)
|
|
end
|
|
local sOut = 'G111'..sYTaking..' EA75'..EMT.SB..' EE0 EF'..EmtLenToString(EMT.FMAXPINZE,0)..' ET1 E80057='..sBeamRot..' E80058=0'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
end
|
|
elseif Cmd[1] == '3' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5] ..' '.. Cmd[6] .. Cmd[7]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local sOut = 'G111'..(EgtIf( Cmd[2] ~= 'T', ' '..Cmd[2]..Cmd[3], ''))..
|
|
(EgtIf( Cmd[4] ~= 'T', ' '..Cmd[4]..Cmd[5], ''))..
|
|
(EgtIf( Cmd[6] ~= 'T', ' '..Cmd[6]..Cmd[7], ''))..
|
|
EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif Cmd[1] == '11' then
|
|
local sMsg = 'PY' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local bPrevEA76 = ( #EMT.AUXSTR > 0 and EMT.AUXSTR[#EMT.AUXSTR]:find( 'EA76', 1, true))
|
|
if #EMT.AUXSTR > 0 and not bPrevEA76 then
|
|
local sVal = ' EB11' .. CalcCharStatus( Cmd[2])
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SB, sVal)
|
|
end
|
|
if not bPrevEA76 then
|
|
EMT.SA = ' EA11' .. CalcCharStatus( Cmd[2])
|
|
end
|
|
EMT.SB = ' EB11' .. CalcCharStatus( Cmd[2])
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE1', ' EE2')
|
|
elseif Cmd[1] == '12' then
|
|
local sMsg = 'PV' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if #EMT.AUXSTR > 0 then
|
|
local sVal = ' ED14' .. CalcCharStatus( Cmd[2])
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SD, sVal)
|
|
end
|
|
EMT.SC = ' EC14' .. CalcCharStatus( Cmd[2])
|
|
EMT.SD = ' ED14' .. CalcCharStatus( Cmd[2])
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE2', ' EE1')
|
|
elseif Cmd[1] == '21' then
|
|
local nYDelta = tonumber( Cmd[2])
|
|
local nVDelta = tonumber( Cmd[3])
|
|
if nYDelta > 0 and nVDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nVDelta
|
|
elseif nYDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nil
|
|
elseif nVDelta > 0 then
|
|
EMT.YDELTA = nil
|
|
EMT.VDELTA = nVDelta
|
|
end
|
|
if not FindG111EA76( EMT.AUXSTR) then
|
|
local sYLoad = ' Y'..EmtLenToString( LoadT)
|
|
local sOut = 'G111'..sYLoad..' EA76'..EMT.SB..' EE0 EF'..EmtLenToString( EMT.FMAXPINZE, 0)..' ET1'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareMoveChar( sCmd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio
|
|
if EMT.AUXIND == 1 then
|
|
-- imposto stato pinze
|
|
EMT.SA = EgtIf( EMT.YDELTA, ' EA112', ' EA111')
|
|
EMT.SB = EgtIf( EMT.YDELTA, ' EB112', ' EB111')
|
|
EMT.SC = EgtIf( EMT.VDELTA, ' EC142', ' EC141')
|
|
EMT.SD = EgtIf( EMT.VDELTA, ' ED142', ' ED141')
|
|
EMT.SE = EgtIf( EMT.YDELTA, ' EE1', ' EE2')
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
local sMsg = Cmd[2] .. Cmd[3]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] ~= 'Z' then
|
|
local sOut = 'G111 '..Cmd[2]..Cmd[3]..EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
if Cmd[2] == 'Y' then EMT.YPOS = tonumber( Cmd[3]) end
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local sOut = 'G111'..(EgtIf( Cmd[2] ~= 'T', ' '..Cmd[2]..Cmd[3], ''))..
|
|
(EgtIf( Cmd[4] ~= 'T', ' '..Cmd[4]..Cmd[5], ''))..
|
|
EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..'EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif Cmd[1] == '3' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5] ..' '.. Cmd[6] .. Cmd[7]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local sOut = 'G111'..(EgtIf( Cmd[2] ~= 'T', ' '..Cmd[2]..Cmd[3], ''))..
|
|
(EgtIf( Cmd[4] ~= 'T', ' '..Cmd[4]..Cmd[5], ''))..
|
|
(EgtIf( Cmd[6] ~= 'T', ' '..Cmd[6]..Cmd[7], ''))..
|
|
EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif Cmd[1] == '11' then
|
|
local sMsg = 'PY' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if #EMT.AUXSTR > 0 then
|
|
local sVal = ' EB11' .. CalcCharStatus( Cmd[2])
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SB, sVal)
|
|
end
|
|
EMT.SA = ' EA11' .. CalcCharStatus( Cmd[2])
|
|
EMT.SB = ' EB11' .. CalcCharStatus( Cmd[2])
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE1', ' EE2')
|
|
elseif Cmd[1] == '12' then
|
|
local sMsg = 'PV' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if #EMT.AUXSTR > 0 then
|
|
local sVal = ' ED14' .. CalcCharStatus( Cmd[2])
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SD, sVal)
|
|
end
|
|
EMT.SC = ' EC14' .. CalcCharStatus( Cmd[2])
|
|
EMT.SD = ' ED14' .. CalcCharStatus( Cmd[2])
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE2', ' EE1')
|
|
elseif Cmd[1] == '21' then
|
|
local nYDelta = tonumber( Cmd[2])
|
|
local nVDelta = tonumber( Cmd[3])
|
|
if nYDelta > 0 and nVDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nVDelta
|
|
elseif nYDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nil
|
|
elseif nVDelta > 0 then
|
|
EMT.YDELTA = nil
|
|
EMT.VDELTA = nVDelta
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareResidue( sCmd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se non è scarico
|
|
if Cmd[2] ~= 'Unloading' then
|
|
-- se inizio o subito dopo, imposto stato iniziale pinze
|
|
if EMT.AUXIND <= 2 then
|
|
EMT.SA = EgtIf( EMT.YDELTA, ' EA112', ' EA111')
|
|
EMT.SB = EgtIf( EMT.YDELTA, ' EB112', ' EB111')
|
|
EMT.SC = EgtIf( EMT.VDELTA, ' EC142', ' EC141')
|
|
EMT.SD = EgtIf( EMT.VDELTA, ' ED142', ' ED141')
|
|
EMT.SE = EgtIf( EMT.YDELTA, ' EE1', ' EE2')
|
|
end
|
|
else
|
|
EMT.UNL = true
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
local sMsg = Cmd[2] .. Cmd[3]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] ~= 'Z' then
|
|
local sOut
|
|
if not EMT.UNL then
|
|
sOut = 'G111 '..Cmd[2]..Cmd[3]..EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
else
|
|
sOut = 'G111 '..Cmd[2]..Cmd[3]..' EC141 ED83 EE0 EF'..GetFmaxClamp()
|
|
end
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local sOut = 'G111'..(EgtIf( Cmd[2] ~= 'T', ' '..Cmd[2]..Cmd[3], ''))..
|
|
(EgtIf( Cmd[4] ~= 'T', ' '..Cmd[4]..Cmd[5], ''))..
|
|
EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif Cmd[1] == '3' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5] ..' '.. Cmd[6] .. Cmd[7]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local sOut = 'G111'..(EgtIf( Cmd[2] ~= 'T', ' '..Cmd[2]..Cmd[3], ''))..
|
|
(EgtIf( Cmd[4] ~= 'T', ' '..Cmd[4]..Cmd[5], ''))..
|
|
(EgtIf( Cmd[6] ~= 'T', ' '..Cmd[6]..Cmd[7], ''))..
|
|
EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif Cmd[1] == '11' then
|
|
local sMsg = 'PY' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if #EMT.AUXSTR > 0 then
|
|
local sVal = ' EB11' .. CalcCharStatus( Cmd[2], true)
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SB, sVal)
|
|
end
|
|
EMT.SA = ' EA11' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SB = ' EB11' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE1', ' EE2')
|
|
elseif Cmd[1] == '12' then
|
|
local sMsg = 'PV' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if #EMT.AUXSTR > 0 then
|
|
local sVal = ' ED14' .. CalcCharStatus( Cmd[2], true)
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SD, sVal)
|
|
end
|
|
EMT.SC = ' EC14' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SD = ' ED14' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE2', ' EE1')
|
|
elseif Cmd[1] == '21' then
|
|
local nYDelta = tonumber( Cmd[2])
|
|
local nVDelta = tonumber( Cmd[3])
|
|
if nYDelta > 0 and nVDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nVDelta
|
|
elseif nYDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nil
|
|
elseif nVDelta > 0 then
|
|
EMT.YDELTA = nil
|
|
EMT.VDELTA = nVDelta
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareSplit( sCmd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '1' then
|
|
local sMsg = Cmd[2] .. Cmd[3]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] == 'Y' then
|
|
local sOut = 'G111 '..Cmd[2]..Cmd[3]..' EA110 EB110 EC142 ED142 EE2 EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
EMT.YPOS = tonumber( Cmd[3])
|
|
end
|
|
elseif Cmd[1] == '21' then
|
|
local nYDelta = tonumber( Cmd[2])
|
|
local nVDelta = tonumber( Cmd[3])
|
|
if nYDelta > 0 and nVDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nVDelta
|
|
elseif nYDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nil
|
|
elseif nVDelta > 0 then
|
|
EMT.YDELTA = nil
|
|
EMT.VDELTA = nVDelta
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareUnload( sCmd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '1' then
|
|
local sMsg = Cmd[2] .. Cmd[3]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] == 'V' then
|
|
-- se non è ultima fase c'è una barra sulla pinza Y (1)
|
|
local sEE = EgtIf( EMT.PHASE == EgtGetPhaseCount() or IsEnd2Phase( EMT.PHASE), '0', '1')
|
|
local sOut = 'G111 '..Cmd[2]..Cmd[3]..' EC141 ED83 EE'..sEE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[4] == 'V' then
|
|
-- se non è ultima fase c'è una barra sulla pinza Y (1)
|
|
local sEAB = EgtIf( EMT.PHASE == EgtGetPhaseCount() or IsEnd2Phase( EMT.PHASE), '111', '112')
|
|
local sOut = 'G111 '..Cmd[4]..Cmd[5]..' EA'..sEAB..' EB'..sEAB..' EC142 ED141 EE2 EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
EMT.U_STD = true
|
|
end
|
|
elseif Cmd[1] == '3' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5] ..' '.. Cmd[6] .. Cmd[7]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
elseif Cmd[1] == '11' then
|
|
local sMsg = 'PY' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
elseif Cmd[1] == '12' then
|
|
local sMsg = 'PV' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
elseif Cmd[1] == '21' then
|
|
-- non interessa
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PreparePreRotation( sCmd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio o subito dopo, imposto stato iniziale pinze
|
|
if EMT.AUXIND <= 2 then
|
|
EMT.SA = EgtIf( EMT.YDELTA, ' EA112', ' EA111')
|
|
EMT.SB = EgtIf( EMT.YDELTA, ' EB112', ' EB111')
|
|
EMT.SC = EgtIf( EMT.VDELTA, ' EC142', ' EC141')
|
|
EMT.SD = EgtIf( EMT.VDELTA, ' ED142', ' ED141')
|
|
EMT.SE = EgtIf( EMT.YDELTA, ' EE1', ' EE2')
|
|
end
|
|
-- se è pre-rotazione
|
|
if Cmd[2] == 'Pre-Rotation' then
|
|
EMT.PREROT = true
|
|
elseif Cmd[2] == 'SplitRot' then
|
|
EMT.SPLITROT = true
|
|
EMT.SE = ' EE2'
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
local sMsg = Cmd[2] .. Cmd[3]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] ~= 'Z' then
|
|
local sOut
|
|
if not EMT.PREROT then
|
|
sOut = 'G111 '..Cmd[2]..Cmd[3]..EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
else
|
|
sOut = 'G111 '..Cmd[2]..Cmd[3]..' EA86 EB87 EC141 EE0 EF'..GetFmaxClamp()
|
|
end
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local sOut = 'G111'..(EgtIf( Cmd[2] ~= 'T', ' '..Cmd[2]..Cmd[3], ''))..
|
|
(EgtIf( Cmd[4] ~= 'T', ' '..Cmd[4]..Cmd[5], ''))..
|
|
EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif Cmd[1] == '3' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5] ..' '.. Cmd[6] .. Cmd[7]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
local sOut = 'G111'..(EgtIf( Cmd[2] ~= 'T', ' '..Cmd[2]..Cmd[3], ''))..
|
|
(EgtIf( Cmd[4] ~= 'T', ' '..Cmd[4]..Cmd[5], ''))..
|
|
(EgtIf( Cmd[6] ~= 'T', ' '..Cmd[6]..Cmd[7], ''))..
|
|
EMT.SA..EMT.SB..EMT.SC..EMT.SD..EMT.SE..' EF'..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif Cmd[1] == '11' then
|
|
local sMsg = 'PY' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if #EMT.AUXSTR > 0 then
|
|
local sVal = ' EB11' .. CalcCharStatus( Cmd[2], true)
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SB, sVal)
|
|
end
|
|
if EMT.SPLITROT then
|
|
EMT.SA = EgtIf( Cmd[2] ~= '0', ' EA11' .. CalcCharStatus( Cmd[2], true), ' EA86')
|
|
EMT.SB = EgtIf( Cmd[2] ~= '0', ' EB11' .. CalcCharStatus( Cmd[2], true), ' EB87')
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE1', ' EE2')
|
|
else
|
|
EMT.SA = ' EA11' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SB = ' EB11' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE1', ' EE2')
|
|
end
|
|
elseif Cmd[1] == '12' then
|
|
local sMsg = 'PV' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if #EMT.AUXSTR > 0 then
|
|
local sVal = ' ED14' .. CalcCharStatus( Cmd[2], true)
|
|
local sOut = EMT.AUXSTR[#EMT.AUXSTR]
|
|
EMT.AUXSTR[#EMT.AUXSTR] = sOut:gsub( EMT.SD, sVal)
|
|
end
|
|
EMT.SC = ' EC14' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SD = ' ED14' .. CalcCharStatus( Cmd[2], true)
|
|
EMT.SE = EgtIf( Cmd[2] ~= '0', ' EE2', ' EE1')
|
|
elseif Cmd[1] == '21' then
|
|
local nYDelta = tonumber( Cmd[2])
|
|
local nVDelta = tonumber( Cmd[3])
|
|
if nYDelta > 0 and nVDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nVDelta
|
|
elseif nYDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nil
|
|
elseif nVDelta > 0 then
|
|
EMT.YDELTA = nil
|
|
EMT.VDELTA = nVDelta
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PreparePostRotation( sCmd)
|
|
-- è sostanzialmente un carico
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio
|
|
if EMT.AUXIND == 1 then
|
|
-- imposto stato pinze
|
|
EMT.SB = ' EB112'
|
|
end
|
|
-- se dichiarazione inizio riposizionamento carrelli
|
|
if Cmd[2] == 'CARR_MOVE' then
|
|
EMT.POSTROT = false
|
|
for i = 1, #EMT.AUXSTR do
|
|
EMT.AUXSTR[i] = string.gsub( EMT.AUXSTR[i], 'ET1', '')
|
|
end
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
local sMsg = Cmd[2] .. Cmd[3]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
elseif Cmd[1] == '2' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
if Cmd[2] == 'Y' then
|
|
-- tolgo eventuale sovramateriale presente sul pezzo in posizione iniziale (la misura laser è ora col finito)
|
|
local sYTaking = ' Y'..EmtLenToString( Cmd[3] - EMT.HOVM)
|
|
local sOut = 'G111'..sYTaking..' EA75 EB110 EE0 EF'..EmtLenToString(EMT.FMAXPINZE,0)..' ET1 E80058=0'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
end
|
|
elseif Cmd[1] == '3' then
|
|
local sMsg = Cmd[2] .. Cmd[3] ..' '.. Cmd[4] .. Cmd[5] ..' '.. Cmd[6] .. Cmd[7]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
elseif Cmd[1] == '11' then
|
|
local sMsg = 'PY' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
EMT.SB = ' EB11' .. CalcCharStatus( Cmd[2])
|
|
elseif Cmd[1] == '12' then
|
|
local sMsg = 'PV' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
elseif Cmd[1] == '21' then
|
|
local nYDelta = tonumber( Cmd[2])
|
|
local nVDelta = tonumber( Cmd[3])
|
|
if nYDelta > 0 and nVDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nVDelta
|
|
elseif nYDelta > 0 then
|
|
EMT.YDELTA = nYDelta
|
|
EMT.VDELTA = nil
|
|
elseif nVDelta > 0 then
|
|
EMT.YDELTA = nil
|
|
EMT.VDELTA = nVDelta
|
|
end
|
|
local sYLoad = ' Y'..EmtLenToString( LoadT)
|
|
local sOut = 'G111'..sYLoad..' EA76'..EMT.SB..' EE0 EF'..EmtLenToString( EMT.FMAXPINZE,0)..' ET1'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
-- setto parametri di pinzaggio reali
|
|
EMT.SA = ' EA110'
|
|
EMT.SE = ' EE1'
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MyBackupAxes()
|
|
EMT.L1b = EMT.L1
|
|
EMT.L2b = EMT.L2
|
|
EMT.L3b = EMT.L3
|
|
EMT.R1b = EMT.R1
|
|
EMT.R2b = EMT.R2
|
|
EMT.R3b = EMT.R3
|
|
EMT.R4b = EMT.R4
|
|
EMT.RRb = EMT.RR
|
|
EMT.C1b = EMT.C1
|
|
EMT.C2b = EMT.C2
|
|
EMT.C3b = EMT.C3
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MyRestoreAxes()
|
|
EMT.L1 = EMT.L1b
|
|
EMT.L2 = EMT.L2b
|
|
EMT.L3 = EMT.L3b
|
|
EMT.R1 = EMT.R1b
|
|
EMT.R2 = EMT.R2b
|
|
EMT.R3 = EMT.R3b
|
|
EMT.R4 = EMT.R4b
|
|
EMT.RR = EMT.RRb
|
|
EMT.C1 = EMT.C1b
|
|
EMT.C2 = EMT.C2b
|
|
EMT.C3 = EMT.C3b
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MyAdjustLinearAxes()
|
|
local MyL1o = EMT.L1
|
|
local MyL2o = EMT.L2
|
|
local MyL3o = EMT.L3
|
|
|
|
if EMT.REFLOC then
|
|
local vtE
|
|
-- su NUM aggregati non gestiti
|
|
if EMT.HEAD == 'H5' or EMT.HEAD == 'H6' or EMT.HEAD == 'H7' then
|
|
EmtSetLastError( 1211, "Aggregates not managed")
|
|
elseif EMT.HEAD ~= 'H3' then
|
|
local Len = EMT.TLEN + EgtIf( EMT.HEAD == 'H1', MillOffs, abs( SawOffs))
|
|
local LenRef = MillOffs
|
|
vtE = Vector3d( EMT.TDIR) * Len - Z_AX() * LenRef
|
|
else
|
|
local LenAux = ( EMT.TDIST or ChSawLen) + MillOffs
|
|
local LenRef = MillOffs
|
|
local vtAux = EgtGetCalcAuxDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
|
|
vtE = vtAux * LenAux - Z_AX() * LenRef
|
|
end
|
|
EMT.L1 = EMT.L1 - vtE:getX()
|
|
EMT.L2 = EMT.L2 - DeltaTabY - vtE:getY()
|
|
EMT.L3 = EMT.L3 - DeltaTabZ - vtE:getZ()
|
|
end
|
|
|
|
if EMT.X_OFF then EMT.L1 = EMT.L1 + EMT.X_OFF end
|
|
|
|
EmtAdjustLinearAxes()
|
|
|
|
EMT.L1o = MyL1o
|
|
EMT.L2o = MyL2o
|
|
EMT.L3o = MyL3o
|
|
|
|
if not EMT.REFLOC then
|
|
EMT.L2 = - EMT.L2
|
|
EMT.L1t = 'Y'
|
|
EMT.L2t = 'X'
|
|
else
|
|
EMT.L1t = 'X'
|
|
EMT.L2t = 'Y'
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MyOutputNoNum( sOut)
|
|
local bNum = EMT.NUM
|
|
EMT.NUM = false
|
|
EmtOutput( sOut)
|
|
EMT.NUM = bNum
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function CalcInterpPlane()
|
|
-- origine del piano
|
|
local xS = EMT.START[1] + LoadT
|
|
if EMT.X_OFF then xS = xS + EMT.X_OFF end
|
|
local ptS = Point3d( xS, 0, 0)
|
|
-- calcolo per piano generico
|
|
local vtE
|
|
if EMT.HEAD ~= 'H3' then
|
|
vtE = Vector3d( EMT.EXTR)
|
|
else
|
|
vtE = EgtGetCalcAuxDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
|
|
end
|
|
EMT.IPLGLFR = Frame3d( ptS, vtE)
|
|
--EmtOutput( 'IPLGLFR='..tostring(EMT.IPLGLFR))
|
|
local _, dAngV, dAngO = SphericalFromVector( vtE)
|
|
local dAngO2 = EmtGetAngO2( EMT.IPLGLFR:getVersZ(), EMT.IPLGLFR:getVersX(), dAngV, dAngO)
|
|
dAngO = dAngO + 90
|
|
while dAngO >= 360 do
|
|
dAngO = dAngO - 360
|
|
end
|
|
EMT.IPLGLSTR = ' EX0 EY'..EmtLenToString( xS)..' EZ0'..
|
|
' EA0'..' EB'..EgtNumToString(dAngV)..' EC'..EgtNumToString(dAngO)..' ED'..EgtNumToString(dAngO2)
|
|
EMT.IPLGL = true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyEmitRotation()
|
|
-- recupero le rotazioni delle fasi corrente e precedente
|
|
local nRot = GetPhaseRot( EMT.PHASE)
|
|
local nPrevRot = GetPhaseRot( EMT.PHASE - 1)
|
|
-- se sono uguali non devo fare alcunchè
|
|
if nRot == nPrevRot then
|
|
return false
|
|
end
|
|
-- determino quanto ruotare
|
|
local nDeltaRot = nRot - nPrevRot
|
|
-- se rotazione automatica richiesta e possibile
|
|
local dRefLen = EgtIf( IsMid2Phase( EMT.PHASE) or IsEnd2Phase( EMT.PHASE), EMT.LT, EMT.LB)
|
|
if AutomaticRotation and dRefLen >= AutoRotMinLen then
|
|
local sOut = 'M180 L0=' .. tostring( nDeltaRot)
|
|
EmtOutput( sOut)
|
|
else
|
|
local sOut
|
|
if nDeltaRot == 1 then
|
|
sOut = 'M151'
|
|
elseif nDeltaRot == 2 then
|
|
sOut = 'M152'
|
|
elseif nDeltaRot == 3 then
|
|
sOut = 'M153'
|
|
end
|
|
EmtOutput( sOut)
|
|
EmtOutput( 'M86')
|
|
EmtOutput( 'G4F.5')
|
|
end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitZmax()
|
|
local sEE = ' EE4'
|
|
local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3)
|
|
local sES = ' ES'..EgtNumToString( EMT.S, 0)
|
|
local sOut = 'G101 X'..EmtLenToString( -EMT.L2o, 3)..' Z'..EgtGetAxisHomePos( 'Z')..
|
|
' B'..EmtLenToString( EMT.R2o, 3)..' C'..EmtLenToString( EMT.R1o, 3)..sEE..sET..sES..' L0=0'
|
|
EmtOutput( sOut)
|
|
sOut = 'G101 ET1001'
|
|
EmtOutput( sOut)
|
|
sOut = 'G101 ET2001'
|
|
EmtOutput( sOut)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetET( sHead, sTcPos, dAxR3)
|
|
if sHead == 'H1' or sHead == 'H5' or sHead == 'H6' or sHead == 'H7' then
|
|
return ' E'..sTcPos
|
|
elseif sHead == 'H2' then
|
|
return ' ET42'
|
|
elseif sHead == 'H3' then
|
|
if sTcPos ~= 'T111' then
|
|
if dAxR3 and abs( dAxR3 - 0) < 0.1 then
|
|
return ' ET101'
|
|
elseif dAxR3 and abs( dAxR3 - 270) < 0.1 then
|
|
return ' ET102'
|
|
elseif dAxR3 and abs( dAxR3 - 180) < 0.1 then
|
|
return ' ET103'
|
|
elseif dAxR3 and abs( dAxR3 - 90) < 0.1 then
|
|
return ' ET104'
|
|
else
|
|
EmtSetLastError( 1210, 'Chain saw orientation not allowed')
|
|
end
|
|
else
|
|
if dAxR3 and abs( dAxR3 - 0) < 0.1 then
|
|
return ' ET111'
|
|
elseif dAxR3 and abs( dAxR3 - 270) < 0.1 then
|
|
return ' ET112'
|
|
elseif dAxR3 and abs( dAxR3 - 180) < 0.1 then
|
|
return ' ET113'
|
|
elseif dAxR3 and abs( dAxR3 - 90) < 0.1 then
|
|
return ' ET114'
|
|
else
|
|
EmtSetLastError( 1210, 'Mortiser orientation not allowed')
|
|
end
|
|
end
|
|
else
|
|
EmtSetLastError( 1211, "Unknown Head")
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetFmaxClamp()
|
|
return EmtLenToString( EMT.FMAXPINZE, 0)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function FindG111EA76( vStr)
|
|
for i = 1, #vStr do
|
|
if vStr[i]:find( 'G111', 1, true) and vStr[i]:find( 'EA76', 1, true) then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** END GENERATION ***
|
|
---------------------------------------------------------------------
|