andrea.villa
1781 lines
67 KiB
Plaintext
1781 lines
67 KiB
Plaintext
-- Processore macchina Saomad-KAIROS by EgalTech s.r.l. 2023/12/06
|
|
-- Con controllo numerico Siemens
|
|
|
|
-- Variabili di modulo
|
|
local MLE_INFO = 'Saomad-KAIROS-MK1.SIEMENS.mlpe ver.'..PP_VER..' by EgalWare s.r.l.'
|
|
local TEST_USE = false
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** GENERATION ***
|
|
---------------------------------------------------------------------
|
|
function OnStart()
|
|
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.C1t = 'I=AC(' -- X centro arco, dopo valore chiudere la tonda
|
|
EMT.C2t = 'J=AC(' -- Y centro arco, dopo valore chiudere la tonda
|
|
EMT.C3t = 'K=AC(' -- Z centro arco, dopo valore chiudere la tonda
|
|
EMT.RRt = 'CR=' -- raggio per arco
|
|
EMT.FMAXPINZE = 45000 -- feed massima pinze
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnEnd()
|
|
-- Ripristino fase iniziale come corrente
|
|
EgtSetCurrPhase( 1)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnProgramStart()
|
|
-- Intestazioni
|
|
if EMT.INFO then
|
|
EmtOutput( ';'..EMT.INFO)
|
|
else
|
|
EmtOutput( ';Program Start')
|
|
end
|
|
EmtOutput( ';'.. MLE_INFO..'\n')
|
|
-- Cerco primo utensile su testa 1
|
|
EMT.TOOL_1, EMT.TLEN_1 = FindFirstToolOnHead( 'H1')
|
|
-- Dichiaro inizio
|
|
EMT.FIRST = true
|
|
EMT.TLAST = nil
|
|
EMT.NSTEP = 0
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnProgramEnd()
|
|
-- 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
|
|
;
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
-- emissione conclusione pezzo precedente
|
|
if EMT.PRODID then
|
|
local sOut = ';Part End'
|
|
EmtOutput( sOut)
|
|
sOut= 'PRODUCTION('..tostring( EMT.PRODID)..','..tostring( EMT.PATTID)..','..tostring( EMT.CUTID)..',2)'
|
|
EmtOutput( sOut)
|
|
end
|
|
end
|
|
end
|
|
EmtOutput( 'STOPRE')
|
|
EmtOutput( '_STEP=0')
|
|
EmtOutput( 'M30')
|
|
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
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnToolData()
|
|
-- tabella codice -> nome tipo utensile
|
|
local tToolType = { [256] = 'DRILL', [257] = 'DRILL_L', [512] = 'SAW', [513] = 'SAW_F', [1024] = 'MILL', [1025] = 'MILL_NT',
|
|
[1026] = 'POLISHING', [2048] = 'CHAINSAW', [4096] = 'CHISEL'}
|
|
-- emissione dati utensile
|
|
--local sOut = ';'..EMT.TCPOS..' L='..EmtLenToString( EMT.TLEN, 3)..' D='..EmtLenToString( EMT.TDIAM, 3)..' A='..EgtIf( EMT.TUSED, '1', '0')..' '..( tToolType[EMT.TTYPE] or 'NONE')
|
|
local sOut = ';'..EMT.TCPOS..' L='..EmtLenToString( EMT.TLEN, 3)..' D='..EmtLenToString( EMT.TDIAM, 3)..' A='..EgtIf( EMT.TUSED, '1', '0')..' '..EMT.TOOL
|
|
EmtOutput( sOut)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnDispositionStart()
|
|
--EmtOutput( '(Disposition '..EMT.DISPIND..' = '..EMT.DISPID..')')
|
|
EMT.OPEISDISP = true
|
|
-- Assegnazione parametri disposizione
|
|
EMT.TPOS = EgtGetInfo( EMT.DISPID, 'TPOS', 'd')
|
|
EMT.X1POS = EgtGetInfo( EMT.DISPID, 'YPOS', 'd')
|
|
-- Se prima disposizione
|
|
if EMT.PHASE == 1 then
|
|
-- inizio programma
|
|
EmtOutput( '\nRESTART')
|
|
EmtOutput( 'STOPRE')
|
|
EmtOutput( '_STEP=0')
|
|
-- 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.X1DELTA = EMT.X1POS - LoadT
|
|
EMT.X2DELTA = 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 della barra
|
|
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
|
|
-- se carico barra
|
|
if EMT.LOAD then
|
|
-- assegnazione dati barra
|
|
local sOut = ';Bar Dimensions'
|
|
EmtOutput( sOut)
|
|
sOut = 'C_WIDTH='..EmtLenToString( HTrave, 3)
|
|
EmtOutput( sOut)
|
|
sOut = 'C_HEIGHT='..EmtLenToString( STrave, 3)
|
|
EmtOutput( sOut)
|
|
sOut = 'C_LENGTH='..EmtLenToString( LBarra, 3)
|
|
EmtOutput( sOut)
|
|
-- se altrimenti ricarico barra dopo rotazione speciale
|
|
elseif EMT.RELOAD then
|
|
local sOut = ';Bar Dimensions'
|
|
EmtOutput( sOut)
|
|
sOut = 'C_WIDTH='..EmtLenToString( HTrave, 3)
|
|
EmtOutput( sOut)
|
|
sOut = 'C_HEIGHT='..EmtLenToString( STrave, 3)
|
|
EmtOutput( sOut)
|
|
sOut = 'C_LENGTH='..EmtLenToString( LBarra, 3)
|
|
EmtOutput( sOut)
|
|
-- altrimenti recupero rimanenza
|
|
else
|
|
-- aggiorno dati aggancio carrelli alla trave
|
|
EMT.X1DELTA = EMT.X1POS - LoadT
|
|
EMT.X2DELTA = nil
|
|
end
|
|
-- Inizio produzione trave
|
|
if IdTrave >= 0 then
|
|
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 sOut = ';Part Start'
|
|
EmtOutput( sOut)
|
|
sOut= 'PRODUCTION('..tostring( EMT.PRODID)..','..tostring( EMT.PATTID)..','..tostring( EMT.CUTID)..',1)'
|
|
EmtOutput( sOut)
|
|
else
|
|
EmtOutput( '')
|
|
EmtOutput( ';REMAIN UNLOAD')
|
|
EMT.PRODID = nil
|
|
EMT.PATTID = nil
|
|
EMT.CUTID = 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 EMT.CHAN2 = true 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 EMT.CHAN2 = true 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
|
|
EmitSpeedOff()
|
|
EmtOutput( '')
|
|
EmtOutput( ';PART UNLOAD')
|
|
end
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
if #EMT.AUXSTR > 0 then
|
|
EMT.CHAN2 = true
|
|
-- emissione conclusione pezzo precedente
|
|
if EMT.PRODID then
|
|
local sOut = ';Part End'
|
|
EmtOutput( sOut)
|
|
sOut= 'PRODUCTION('..tostring( EMT.PRODID)..','..tostring( EMT.PATTID)..','..tostring( EMT.CUTID)..',2)'
|
|
EmtOutput( sOut)
|
|
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
|
|
-- dichiaro utensile appena selezionato
|
|
EMT.TSELECT = true
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnToolDeselect()
|
|
EmitSpeedOff()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnMachiningStart()
|
|
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
|
|
EMT.FEEDFIRST = true
|
|
-- 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
|
|
EmitSpeedOff()
|
|
EmtOutput( ';PART SPLIT')
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
if not EMT.ZMAX then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
end
|
|
if IsLastMachining( EMT.MCHID) then
|
|
EmitSpeedOff()
|
|
end
|
|
EmtOutput( ';PART UNLOAD')
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
if EMT.PREROT then
|
|
if not EMT.ZMAX then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
end
|
|
EmtOutput( ';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
|
|
EMT.CHAN2 = true
|
|
if EMT.AUXTYPE == 'S' then
|
|
;
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
-- emissione conclusione pezzo precedente
|
|
if EMT.PRODID then
|
|
local sOut = ';Part End'
|
|
EmtOutput( sOut)
|
|
sOut= 'PRODUCTION('..tostring( EMT.PRODID)..','..tostring( EMT.PATTID)..','..tostring( EMT.CUTID)..',2)'
|
|
EmtOutput( sOut)
|
|
end
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
if EMT.FALL then
|
|
-- emissione conclusione pezzo precedente
|
|
if EMT.PRODID then
|
|
local sOut = ';Part End'
|
|
EmtOutput( sOut)
|
|
sOut= 'PRODUCTION('..tostring( EMT.PRODID)..','..tostring( EMT.PATTID)..','..tostring( EMT.CUTID)..',2)'
|
|
EmtOutput( sOut)
|
|
end
|
|
elseif not EMT.PREROT then
|
|
;
|
|
end
|
|
end
|
|
end
|
|
EMT.AUXSTR = {}
|
|
EMT.AUXTYPE = nil
|
|
EMT.U_STD = nil
|
|
EMT.PREVTOOL = EMT.TOOL
|
|
EMT.PREVR3 = EMT.R3
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathStart()
|
|
-- non ancora iniziata la lavorazione
|
|
EMT.MCHFIRST = true
|
|
-- primo posizionamento sempre in globale
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
-- reset valori precedenti (per forzare emissione di tutti gli assi del 1° movimento)
|
|
EMT.L1opp = EMT.L1op
|
|
EMT.L2opp = EgtIf( EMT.TSELECT, ParkY, EMT.L2op)
|
|
EMT.L3opp = EgtIf( EMT.TSELECT, ParkZ, EMT.L3op)
|
|
EMT.R1pp = EgtIf( EMT.TSELECT, ParkC, EMT.R1p)
|
|
EMT.R2pp = EgtIf( EMT.TSELECT, ParkA, EMT.R2p)
|
|
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()
|
|
MyBackupAxes()
|
|
-- se primo movimento della lavorazione, gestione speciale
|
|
if EMT.MCHFIRST and not EMT.OPEISDISP then
|
|
-- 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.X2DELTA) or ( DeltaT > GEO.EPS_SMALL and EMT.X1DELTA) then bHeadFirst = false end
|
|
end
|
|
-- sistemo movimenti
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
-- verifico presenza movimento carrelli
|
|
local bMoveChar = ( #EMT.AUXSTR > 0)
|
|
-- carico
|
|
if EMT.LOAD then
|
|
EmtOutput( 'STOPRE')
|
|
EMT.NSTEP = EMT.NSTEP + 10
|
|
local sStep = EgtNumToString( EMT.NSTEP, 0)
|
|
EmtOutput( '_STEP='..sStep)
|
|
-- eseguo carico
|
|
EMT.AUXCMD = {}
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
EMT.AUXSTR = {}
|
|
-- supporti in posizione intermedia
|
|
sOut = 'SUPPORT(1,1)'
|
|
EmtOutput( sOut)
|
|
-- prima lavorazione
|
|
sOut = EMT.MCHNAME..'/'..EMT.TOOL
|
|
EmtOutput( '; *** ' .. sOut .. ' ***')
|
|
EMT.LOAD = false
|
|
-- altri casi
|
|
else
|
|
if not EMT.RELOAD and not EMT.ZMAX and #EMT.AUXSTR > 0 then
|
|
EmitZmax()
|
|
EMT.ZMAX = true
|
|
EMT.PREVTOOL = EMT.TOOL
|
|
end
|
|
if bMoveChar then
|
|
local bStoPre
|
|
if EMT.CHAN2 then
|
|
EmtOutput( 'WAIT_CHAN(2)')
|
|
EmtOutput( 'STOPRE')
|
|
bStoPre = true
|
|
EMT.CHAN2 = nil
|
|
end
|
|
if EMT.TRAILON then
|
|
EmtOutput( 'TRAILOF(X2,X1)')
|
|
EmtOutput( 'TRANS')
|
|
EmtOutput( 'STOPRE')
|
|
bStoPre = true
|
|
EMT.TRAILON = nil
|
|
end
|
|
if not bStoPre then EmtOutput( 'STOPRE') end
|
|
EmtOutput( '')
|
|
EMT.NSTEP = EMT.NSTEP + 10
|
|
local sStep = EgtNumToString( EMT.NSTEP, 0)
|
|
EmtOutput( '_STEP='..sStep)
|
|
end
|
|
local sOut = EMT.MCHNAME..'/'..EMT.TOOL
|
|
EmtOutput( '; *** ' .. sOut .. ' ***')
|
|
-- movimento carrelli
|
|
EMT.AUXCMD = {}
|
|
for i = 1, #EMT.AUXSTR do
|
|
EmtOutput( EMT.AUXSTR[i])
|
|
end
|
|
EMT.AUXSTR = {}
|
|
EMT.POSTROT = false
|
|
EMT.RELOAD = false
|
|
EMT.RELOAD2 = nil
|
|
EMT.CHAN2 = bMoveChar
|
|
end
|
|
-- se utensile appena selezionato, lo devo dichiarare
|
|
if EMT.TSELECT then
|
|
EMT.TSELECT = nil
|
|
if bMoveChar then
|
|
local sStep = EgtNumToString( EMT.NSTEP, 0)
|
|
EmtOutput( '_N'..sStep..':STOPRE')
|
|
end
|
|
local nTool = 100 + tonumber( string.sub( EMT.TCPOS, 2))
|
|
local sOut = 'PRE_WORK(1,1,' .. EgtNumToString( nTool, 0) .. ','..EgtNumToString( EMT.S, 0) ..',,,,)'
|
|
EmtOutput( sOut)
|
|
EMT.SPEED_ON = true
|
|
-- eventuali emissioni per ripartenza successiva al carico
|
|
elseif bMoveChar then
|
|
local sStep1 = EgtNumToString( EMT.NSTEP + 1, 0)
|
|
EmtOutput( 'GOTOF '..'_N'..sStep1)
|
|
local sStep = EgtNumToString( EMT.NSTEP, 0)
|
|
EmtOutput( '_N'..sStep..':STOPRE')
|
|
local nTool = 100 + tonumber( string.sub( EMT.TCPOS, 2))
|
|
local sOut = 'PRE_WORK(1,1,' .. EgtNumToString( nTool, 0) .. ','..EgtNumToString( EMT.S, 0) ..',,,,)'
|
|
EmtOutput( sOut)
|
|
EMT.SPEED_ON = true
|
|
EmtOutput( '_N'..sStep1..':STOPRE')
|
|
end
|
|
-- eventuale avvio mandrino (se non già avviato)
|
|
EmitSpeedOn( EMT.S)
|
|
-- primo posizionamento testa rispetto a 0M
|
|
EmtResetPrev()
|
|
if EMT.ZMAX then
|
|
sOut = 'SUPA G0 D0 Z'..EgtNumToString( ParkZ, 3)
|
|
else
|
|
sOut = 'SUPA G0 D0' .. EmtGetAxis( 'L3')
|
|
end
|
|
EmtOutput( sOut)
|
|
-- movimento YAC con interpolazione approssimata tramite F opportune per ogni asse
|
|
--EmtOutput( string.format( '; Y:%.3f->%.3f A:%.3f->%.3f C::%.3f->%.3f', EMT.L2opp, EMT.L2, EMT.R2pp, EMT.R2, EMT.R1pp, EMT.R1))
|
|
local dFeedY, dFeedA, dFeedC = CalcFeedYAC( EMT.L2opp - EMT.L2, EMT.R2pp - EMT.R2, EMT.R1pp - EMT.R1)
|
|
sOut = '_POSIZ_YAC('..EgtNumToString( EMT.L2, 3)..','..EgtNumToString( EMT.R2, 3)..','..EgtNumToString( EMT.R1, 3)..','..
|
|
EgtNumToString( dFeedY, 0)..','..EgtNumToString( dFeedA, 0)..','..EgtNumToString( dFeedC, 0)..')'
|
|
EmtOutput( sOut)
|
|
-- se necessario, attesa fine movimenti carrelli e presa assi relativi
|
|
if bMoveChar then
|
|
sOut = 'WAIT_CHAN(2)'
|
|
EmtOutput( sOut)
|
|
EMT.CHAN2 = nil
|
|
if EMT.X1DELTA and EMT.X2DELTA then
|
|
EmtOutput( 'GET(X1,X2)')
|
|
EmtOutput( 'STOPRE')
|
|
EmtOutput( 'TRAILON(X2,X1)')
|
|
EMT.TRAILON = true
|
|
elseif EMT.X1DELTA then
|
|
EmtOutput( 'GET(X1)')
|
|
elseif EMT.X2DELTA then
|
|
EmtOutput( 'GET(X2)')
|
|
end
|
|
end
|
|
if EMT.ZMAX and EMT.L3 < ParkZ - 10 then
|
|
sOut = 'SUPA G0 D0' .. EmtGetAxis( 'L3')
|
|
EmtOutput( sOut)
|
|
end
|
|
-- assegnazione assi geometrici (GEOMAX)
|
|
EmtOutput( 'TRANS')
|
|
if EMT.X1DELTA then
|
|
sOut = 'GEOAX(1,X1,2,Y1,3,Z1)'
|
|
else
|
|
sOut = 'GEOAX(1,X2,2,Y1,3,Z1)'
|
|
end
|
|
EmtOutput( sOut)
|
|
EmtOutput( 'G90 G17')
|
|
-- primo posizionamento carrello rispetto a 0M
|
|
if EMT.X1DELTA then
|
|
local dPosX1 = EMT.L1 + EMT.X1DELTA
|
|
sOut = 'G1 X' .. EmtLenToString( dPosX1, 3) .. ' F' .. GetClampFeed( EMT.LB)
|
|
EmtOutput( sOut)
|
|
elseif EMT.X2DELTA then
|
|
local dPosX2 = EMT.L1 + EMT.X2DELTA
|
|
sOut = 'G1 X' .. EmtLenToString( dPosX2, 3) .. ' F' .. GetClampFeed( EMT.LB)
|
|
EmtOutput( sOut)
|
|
else
|
|
EmtSetLastError( 1213, "Part to machine without charriots")
|
|
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 del piano generico
|
|
CalcInterpPlane()
|
|
EMT.REFLOC = 1
|
|
-- emissione del piano generico
|
|
EmtOutput( EMT.IPLGLSTR)
|
|
end
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
-- emissione movimento
|
|
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')
|
|
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 altrimenti movimento in Home
|
|
elseif EMT.FLAG == 4 then
|
|
-- non previsto
|
|
-- se altrimenti rotazione a Z max
|
|
elseif EMT.FLAG == 5 then
|
|
-- viene gestito all'inizio della lavorazione successiva
|
|
-- 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 del piano generico
|
|
CalcInterpPlane()
|
|
EMT.REFLOC = 1
|
|
-- emissione del piano generico
|
|
EmtOutput( EMT.IPLGLSTR)
|
|
-- 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
|
|
-- emissione movimento
|
|
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')
|
|
EmtOutput( sOut)
|
|
-- ripristino posizione attuale
|
|
EMT.L1 = OldL1
|
|
EMT.L2 = OldL2
|
|
EMT.L3 = OldL3
|
|
end
|
|
|
|
if EMT.FEEDFIRST then
|
|
local sOut = 'M_OK(1,'..EgtNumToString( EMT.S, 0)..')'
|
|
EmtOutput( sOut)
|
|
EMT.FEEDFIRST = false
|
|
end
|
|
|
|
-- aggiustamento valori
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
|
|
-- valori degli assi
|
|
local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')
|
|
-- se nulla da emettere, esco
|
|
if #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
|
|
|
|
if EMT.FEEDFIRST then
|
|
local sOut = 'M_OK(1,'..EgtNumToString( EMT.S, 0)..')'
|
|
EmtOutput( sOut)
|
|
EMT.FEEDFIRST = false
|
|
end
|
|
|
|
-- non modale su archi
|
|
EmtResetPrevLinear()
|
|
-- aggiustamento valori
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
|
|
-- valori degli assi
|
|
local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
|
EmtGetAxis('R2')..EmtGetAxis('R1')
|
|
-- se nulla da emettere, esco
|
|
if #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)
|
|
-- emetto arco
|
|
EmtOutput( sArc..sAxes..sRad..sFeed)
|
|
|
|
-- aggiorno valori come precedenti
|
|
EmtUpdatePrev()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function CalcDinamicaPinze( dH, dS, dL)
|
|
local MinTempoAcc = 0.3 -- [s]
|
|
local MaxTempoAcc = 4.0 -- [s]
|
|
local KgMtCubo= 550 -- densità legno [Kg / metro cubo]
|
|
local Massa = ( dH * dS * dL * KgMtCubo ) / 1e9 -- massa [Kg]
|
|
local FMaxPinze = EMT.FMAXPINZE -- Feed massima pinze [mm/min]
|
|
local ForzaAttrito = 350 * 9.8 * 0.2 -- Forza chiusura pinze [Kgf] * g * Coeff_Attrito -> [N]
|
|
local TempoAcc = ( ( Massa * FMaxPinze) / ( 60 * ForzaAttrito) / 1000)
|
|
if ( TempoAcc < MinTempoAcc) then TempoAcc = MinTempoAcc end
|
|
if ( TempoAcc > MaxTempoAcc) then TempoAcc = MaxTempoAcc end
|
|
local AccMaxPinze = FMaxPinze / ( 60 * MinTempoAcc)
|
|
local AccPinze = FMaxPinze / ( 60 * TempoAcc)
|
|
local RidFeed = 100 / Massa * 100
|
|
if RidFeed > 100 then
|
|
RidFeed = 100
|
|
elseif RidFeed < 10 then
|
|
RidFeed = 10
|
|
end
|
|
return AccPinze, AccMaxPinze, RidFeed, TempoAcc
|
|
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 CalcFeedYAC( dDeltaY, dDeltaA, dDeltaC)
|
|
local dTY = abs( dDeltaY) / FmaxY
|
|
local dTA = abs( dDeltaA) / FmaxA
|
|
local dTC = abs( dDeltaC) / FmaxC
|
|
local dT = max( dTY, dTA, dTC)
|
|
local dFeedY = FmaxY
|
|
if dTY > 0.001 then dFeedY = FmaxY * dTY / dT end
|
|
local dFeedA = FmaxA
|
|
if dTA > 0.001 then dFeedA = FmaxA * dTA / dT end
|
|
local dFeedC = FmaxC
|
|
if dTC > 0.001 then dFeedC = FmaxC * dTC / dT end
|
|
return dFeedY, dFeedA, dFeedC
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareLoad( sCmd, bStart)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio
|
|
if EMT.AUXIND == 1 then
|
|
-- reset stato pinze
|
|
EMT.X1STAT = 0
|
|
EMT.X2STAT = 0
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
elseif Cmd[1] == '2' then
|
|
elseif Cmd[1] == '3' then
|
|
elseif Cmd[1] == '11' then
|
|
EMT.X1STAT = tonumber( Cmd[2])
|
|
elseif Cmd[1] == '12' then
|
|
EMT.X2STAT = tonumber( Cmd[2])
|
|
elseif Cmd[1] == '21' then
|
|
local dX1Delta = tonumber( Cmd[2])
|
|
local dX2Delta = tonumber( Cmd[3])
|
|
if dX1Delta > 0 and dX2Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = dX2Delta
|
|
elseif dX1Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = nil
|
|
elseif dX2Delta > 0 then
|
|
EMT.X1DELTA = nil
|
|
EMT.X2DELTA = dX2Delta
|
|
end
|
|
if EMT.X1DELTA and not EMT.X2DELTA then
|
|
local sInfo = string.format( ';LOAD D1=%.1f', EMT.X1DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 1
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 0
|
|
local sRef1 = EmtLenToString( EMT.X1DELTA, 3)
|
|
local sRef2 = EmtLenToString( ParkX1 + EMT.X1DELTA, 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
|
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
|
|
-- reset stato
|
|
EMT.MCIND = 0
|
|
EMT.X1DLTP = EMT.X1DELTA
|
|
EMT.X2DLTP = EMT.X2DELTA
|
|
EMT.X1STAP = EgtIf( EMT.X1DELTA, 1, 0)
|
|
EMT.X2STAP = EgtIf( EMT.X2DELTA, 1, 0)
|
|
EMT.X1STAI = EMT.X1STAP
|
|
EMT.X2STAI = EMT.X2STAP
|
|
EMT.X1STAT = 0
|
|
EMT.X2STAT = 0
|
|
EMT.MCX1 = {}
|
|
EMT.MCX2 = {}
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
if Cmd[2] ~= 'Z' then
|
|
EMT.MCIND = EMT.MCIND + 1
|
|
if Cmd[2] == 'X1' then
|
|
EMT.MCX1[EMT.MCIND] = tonumber( Cmd[3])
|
|
EMT.MCX2[EMT.MCIND] = 0
|
|
elseif Cmd[2] == 'X2' then
|
|
EMT.MCX1[EMT.MCIND] = 0
|
|
EMT.MCX2[EMT.MCIND] = tonumber( Cmd[3])
|
|
end
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
EMT.MCIND = EMT.MCIND + 1
|
|
for i = 2, 4, 2 do
|
|
if Cmd[i] == 'X1' then
|
|
EMT.MCX1[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
elseif Cmd[i] == 'X2' then
|
|
EMT.MCX2[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
end
|
|
end
|
|
if not EMT.MCX1[EMT.MCIND] then EMT.MCX1[EMT.MCIND] = 0 end
|
|
if not EMT.MCX2[EMT.MCIND] then EMT.MCX2[EMT.MCIND] = 0 end
|
|
elseif Cmd[1] == '3' then
|
|
EMT.MCIND = EMT.MCIND + 1
|
|
for i = 2, 6, 2 do
|
|
if Cmd[i] == 'X1' then
|
|
EMT.MCX1[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
elseif Cmd[i] == 'X2' then
|
|
EMT.MCX2[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
end
|
|
end
|
|
elseif Cmd[1] == '11' then
|
|
EMT.X1STAT = tonumber( Cmd[2])
|
|
if EMT.MCIND == 0 then EMT.X1STAI = EMT.X1STAT end
|
|
elseif Cmd[1] == '12' then
|
|
EMT.X2STAT = tonumber( Cmd[2])
|
|
if EMT.MCIND == 0 then EMT.X2STAI = EMT.X2STAT end
|
|
elseif Cmd[1] == '21' then
|
|
local dX1Delta = tonumber( Cmd[2])
|
|
local dX2Delta = tonumber( Cmd[3])
|
|
if dX1Delta > 0 and dX2Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = dX2Delta
|
|
elseif dX1Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = nil
|
|
elseif dX2Delta > 0 then
|
|
EMT.X1DELTA = nil
|
|
EMT.X2DELTA = dX2Delta
|
|
end
|
|
if EMT.X1STAP ~= 0 and EMT.X2STAP ~= 0 and EMT.X1STAI == 0 and EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 1 then
|
|
local sInfo = string.format( ';X1+X2->X1+X2 D12=%.1f', EMT.X1DELTA - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 11
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 0
|
|
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X2STAP ~= 0 and EMT.X2STAI == 0 and EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 1 then
|
|
local sInfo = string.format( ';X1+X2->X1+X2 D12=%.1f', EMT.X1DELTA - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 12
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 0
|
|
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X2STAP ~= 0 and EMT.X1DELTA and not EMT.X2DELTA and EMT.MCIND == 1 then
|
|
local sInfo = string.format( ';X1+X2->X1 D1=%.1f', EMT.X1DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 12
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X2STAP ~= 0 and EMT.X1DELTA and not EMT.X2DELTA and EMT.MCIND == 2 then
|
|
local sInfo = string.format( ';%sX2->X1 D1=%.1f', EgtIf( EMT.X1STAP > 0, 'X1+', ''), EMT.X1DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 32
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EgtIf( EMT.MCX2[1] == 0, EMT.L1opp + EMT.X2DLTP, EMT.MCX2[1]), 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX2[2], 3)
|
|
local sRef4 = EmtLenToString( EgtIf( EMT.MCX1[2] == 0, EMT.MCX1[1], EMT.MCX1[2]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X2STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 1 then
|
|
local sInfo = string.format( ';X1+X2->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 21
|
|
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 0
|
|
local sRef1 = EmtLenToString( EMT.L1opp + EMT.X1DLTP, 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X2STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND >= 3 then
|
|
local sInfo = string.format( ';X1+X2->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 34
|
|
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = EgtIf( EMT.MCIND >= 4, 2, 1)
|
|
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX2[2], 3)
|
|
local sRef4 = EmtLenToString( EMT.MCX1[2], 3)
|
|
local sRef5 = EmtLenToString( EgtIf( EMT.MCX2[3] == 0, EMT.MCX2[2], EMT.MCX2[3]), 3)
|
|
local sRef6 = EmtLenToString( EgtIf( EMT.MCX1[3] == 0, EMT.MCX1[2], EMT.MCX1[3]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4, sRef5, sRef6)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X2STAP == 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 1 then
|
|
local sInfo = string.format( ';X1->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 31
|
|
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EMT.L1opp + EMT.X1DLTP, 3)
|
|
local sRef2 = EmtLenToString( ParkX2, 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef4 = EmtLenToString( ParkX2, 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 2 then
|
|
local sInfo = string.format( ';X1%s->X2 D2=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.LB - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 31
|
|
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EgtIf( EMT.MCX1[1] == 0, EMT.L1opp + EMT.X1DLTP, EMT.MCX1[1]), 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX1[2], 3)
|
|
local sRef4 = EmtLenToString( EgtIf( EMT.MCX2[2] == 0, EMT.MCX2[1], EMT.MCX2[2]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND >= 3 then
|
|
local sInfo = string.format( ';X1%s->X2 D2=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.LB - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local sGet = 'GET(X1,X2)'
|
|
table.insert( EMT.AUXSTR, sGet)
|
|
local sReset = 'TRANS'
|
|
table.insert( EMT.AUXSTR, sReset)
|
|
local sFeed = 'FA[X1]='..GetFmaxClamp()..' FA[X2]='..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sFeed)
|
|
local sMove = 'POS[X1]='..EmtLenToString( EMT.MCX1[1], 3)..' POS[X2]='..EmtLenToString( EMT.MCX2[1], 3)
|
|
table.insert( EMT.AUXSTR, sMove)
|
|
local nFunz = 34
|
|
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = EgtIf( EMT.MCIND >= 5, 2, 1)
|
|
local sRef1 = EmtLenToString( EMT.MCX2[2], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[2], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX2[3], 3)
|
|
local sRef4 = EmtLenToString( EMT.MCX1[3], 3)
|
|
local sRef5 = EmtLenToString( EgtIf( EMT.MCX2[4] == 0, EMT.MCX2[3], EMT.MCX2[4]), 3)
|
|
local sRef6 = EmtLenToString( EgtIf( EMT.MCX1[4] == 0, EMT.MCX1[3], EMT.MCX1[4]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4, sRef5, sRef6)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X1STAI ~= 0 and EMT.X1DELTA and EMT.X2DELTA and ( EMT.MCIND == 1 or EMT.MCIND == 2) then
|
|
local sInfo = string.format( ';X1%s->X1+X2 D12=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.X1DELTA - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 41
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EgtIf( EMT.MCX1[1] == 0, EMT.L1opp + EMT.X1DLTP, EMT.MCX1[1]), 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef3 = EmtLenToString( EgtIf( not EMT.MCX1[2] or EMT.MCX1[2] == 0, EMT.MCX1[1], EMT.MCX1[2]), 3)
|
|
local sRef4 = EmtLenToString( EgtIf( not EMT.MCX2[2] or EMT.MCX2[2] == 0, EMT.MCX2[1], EMT.MCX2[2]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X1STAI == 0 and EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 2 then
|
|
local sInfo = string.format( ';X1%s->X1+X2 D12=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.X1DELTA - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 42
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef3 = EmtLenToString( EgtIf( EMT.MCX2[2] == 0, EMT.MCX2[1], EMT.MCX2[2]), 3)
|
|
local sRef4 = EmtLenToString( EgtIf( EMT.MCX1[2] == 0, EMT.MCX1[1], EMT.MCX1[2]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND >= 3 then
|
|
local sInfo = string.format( ';X1%s->X1+X2 D12=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.X1DELTA - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 43
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = EgtIf( EMT.MCIND >= 4, 2, 1)
|
|
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX1[2], 3)
|
|
local sRef4 = EmtLenToString( EMT.MCX2[2], 3)
|
|
local sRef5 = EmtLenToString( EgtIf( EMT.MCX1[3] == 0, EMT.MCX1[2], EMT.MCX1[3]), 3)
|
|
local sRef6 = EmtLenToString( EgtIf( EMT.MCX2[3] == 0, EMT.MCX2[2], EMT.MCX2[3]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4, sRef5, sRef6)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP ~= 0 and EMT.X1DELTA and not EMT.X2DELTA and EMT.MCIND >= 3 then
|
|
local sInfo = string.format( ';X1->X1 D1=%.1f', EMT.X1DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 33
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = EgtIf( EMT.MCIND >= 4, 2, 1)
|
|
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX1[2], 3)
|
|
local sRef4 = EmtLenToString( EgtIf( EMT.MCX2[2] == 0, EMT.MCX2[1], EMT.MCX2[2]), 3)
|
|
local sRef5 = EmtLenToString( EgtIf( EMT.MCX1[3] == 0, EMT.MCX1[2], EMT.MCX1[3]), 3)
|
|
local sRef6 = EmtLenToString( EgtIf( EMT.MCX2[3] == 0, EgtIf( EMT.MCX2[2] == 0, EMT.MCX2[1], EMT.MCX2[2]), EMT.MCX2[3]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4, sRef5, sRef6)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP == 0 and EMT.X1DELTA and EMT.X2DELTA and ( EMT.MCIND == 1 or EMT.MCIND == 2) then
|
|
local sInfo = string.format( ';X2->X1+X2 D12=%.1f', EMT.X1DELTA - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 42
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef3 = EmtLenToString( EgtIf( not EMT.MCX2[2] or EMT.MCX2[2] == 0, EMT.MCX2[1], EMT.MCX2[2]), 3)
|
|
local sRef4 = EmtLenToString( EgtIf( not EMT.MCX1[2] or EMT.MCX1[2] == 0, EMT.MCX1[1], EMT.MCX1[2]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP == 0 and EMT.X1STAI == 0 and EMT.X2STAP ~= 0 and EMT.X2STAI ~= 0 and EMT.X1DELTA and not EMT.X2DELTA and EMT.MCIND == 4 then
|
|
local sInfo = string.format( ';X2->X1 D1=%.1f', EMT.X1DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local sGet = 'GET(X1,X2)'
|
|
table.insert( EMT.AUXSTR, sGet)
|
|
local sReset = 'TRANS'
|
|
table.insert( EMT.AUXSTR, sReset)
|
|
local sFeed = 'FA[X1]='..GetFmaxClamp()..' FA[X2]='..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sFeed)
|
|
local sMove = 'POS[X1]='..EmtLenToString( EMT.MCX1[1], 3)..' POS[X2]='..EmtLenToString( EMT.MCX2[1], 3)
|
|
table.insert( EMT.AUXSTR, sMove)
|
|
local nFunz = 33
|
|
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EMT.MCX1[2], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[2], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX1[3], 3)
|
|
local sRef4 = EmtLenToString( EgtIf( EMT.MCX2[3] == 0, EMT.MCX2[2], EMT.MCX2[3]), 3)
|
|
local sRef5 = EmtLenToString( EgtIf( EMT.MCX1[4] == 0, EMT.MCX1[3], EMT.MCX1[4]), 3)
|
|
local sRef6 = EmtLenToString( EgtIf( EMT.MCX2[4] == 0, EMT.MCX2[3], EMT.MCX2[4]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4, sRef5, sRef6)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.X1STAP == 0 and EMT.X1STAI == 0 and EMT.X2STAP ~= 0 and EMT.X2STAI ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 3 then
|
|
local sInfo = string.format( ';X2->X2 D2=%.1f', EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local nFunz = 34
|
|
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = 1
|
|
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX2[2], 3)
|
|
local sRef4 = EmtLenToString( EgtIf( EMT.MCX1[2] == 0, EMT.MCX1[1], EMT.MCX1[2]), 3)
|
|
local sRef5 = EmtLenToString( EgtIf( EMT.MCX2[3] == 0, EMT.MCX2[2], EMT.MCX2[3]), 3)
|
|
local sRef6 = EmtLenToString( EgtIf( EMT.MCX1[3] == 0, EMT.MCX1[2], EMT.MCX1[3]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4, sRef5, sRef6)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
elseif EMT.MCIND > 0 then
|
|
EmtSetLastError( 1215, "Charriot move : unmanaged case ("..EMT.MCHNAME..')')
|
|
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
|
|
if EMT.AUXIND <= 2 then
|
|
-- reset stato
|
|
EMT.MCIND = 0
|
|
EMT.X1STAT = 0
|
|
EMT.X2STAT = 0
|
|
EMT.MCX1 = {}
|
|
EMT.MCX2 = {}
|
|
end
|
|
else
|
|
EMT.UNL = true
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
if Cmd[2] ~= 'Z' then
|
|
EMT.MCIND = EMT.MCIND + 1
|
|
if Cmd[2] == 'X1' then
|
|
EMT.MCX1[EMT.MCIND] = tonumber( Cmd[3])
|
|
EMT.MCX2[EMT.MCIND] = 0
|
|
elseif Cmd[2] == 'X2' then
|
|
EMT.MCX1[EMT.MCIND] = 0
|
|
EMT.MCX2[EMT.MCIND] = tonumber( Cmd[3])
|
|
end
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
EMT.MCIND = EMT.MCIND + 1
|
|
for i = 2, 4, 2 do
|
|
if Cmd[i] == 'X1' then
|
|
EMT.MCX1[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
elseif Cmd[i] == 'X2' then
|
|
EMT.MCX2[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
end
|
|
end
|
|
if not EMT.MCX1[EMT.MCIND] then EMT.MCX1[EMT.MCIND] = 0 end
|
|
if not EMT.MCX2[EMT.MCIND] then EMT.MCX2[EMT.MCIND] = 0 end
|
|
elseif Cmd[1] == '3' then
|
|
EMT.MCIND = EMT.MCIND + 1
|
|
for i = 2, 6, 2 do
|
|
if Cmd[i] == 'X1' then
|
|
EMT.MCX1[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
elseif Cmd[i] == 'X2' then
|
|
EMT.MCX2[EMT.MCIND] = tonumber( Cmd[i+1])
|
|
end
|
|
end
|
|
elseif Cmd[1] == '11' then
|
|
EMT.X1STAT = tonumber( Cmd[2])
|
|
elseif Cmd[1] == '12' then
|
|
EMT.X2STAT = tonumber( Cmd[2])
|
|
if EMT.UNL and EMT.X2STAT == 0 then
|
|
local sWait = 'WAIT_CHAN(2)'
|
|
table.insert( EMT.AUXSTR, sWait)
|
|
local sSync = 'STOPRE'
|
|
table.insert( EMT.AUXSTR, sSync)
|
|
local nFunz = 6
|
|
local nVertClamp = 0
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LT)
|
|
local dAcc = 4
|
|
local nOpt = 0
|
|
local sRef1 = EMT.MCX2[#EMT.MCX2]
|
|
local sRef2 = EmtLenToString( ParkX2 - ( EMT.LB - EMT.X2DELTA), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
end
|
|
elseif Cmd[1] == '21' then
|
|
local dX1Delta = tonumber( Cmd[2])
|
|
local dX2Delta = tonumber( Cmd[3])
|
|
if dX1Delta > 0 and dX2Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = dX2Delta
|
|
elseif dX1Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = nil
|
|
elseif dX2Delta > 0 then
|
|
EMT.X1DELTA = nil
|
|
EMT.X2DELTA = dX2Delta
|
|
end
|
|
if EMT.AUXIND > 1 then
|
|
local sInfo = string.format( ';X1->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
|
table.insert( EMT.AUXSTR, sInfo)
|
|
local sWait = 'WAIT_CHAN(2)'
|
|
table.insert( EMT.AUXSTR, sWait)
|
|
local sSync = 'STOPRE'
|
|
table.insert( EMT.AUXSTR, sSync)
|
|
local nFunz = 31
|
|
local nVertClamp = 0
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LB)
|
|
local dAcc = 4
|
|
local nOpt = EgtIf( EMT.MCIND >= 3, 2, 1)
|
|
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
|
local sRef2 = EmtLenToString( EMT.MCX2[1], 3)
|
|
local sRef3 = EmtLenToString( EMT.MCX1[2], 3)
|
|
local sRef4 = EmtLenToString( EgtIf( EMT.MCX2[2] == 0, EMT.MCX2[1], EMT.MCX2[2]), 3)
|
|
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
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] == 'X1' then
|
|
local sOut = 'STOPRE'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
EMT.NSTEP = EMT.NSTEP + 10
|
|
local sStep = EgtNumToString( EMT.NSTEP, 0)
|
|
sOut = '_STEP='..sStep
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
sOut = 'TRAILOF(X2,X1)'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
sOut = '_N'..sStep..':STOPRE'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
sOut = 'TRANS'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
sOut = 'STOPRE'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
EMT.TRAILON = nil
|
|
sOut = 'POS[X1]='..Cmd[3]..' FA[X1]='..GetFmaxClamp()
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
EMT.X1POS = tonumber( Cmd[3])
|
|
end
|
|
elseif Cmd[1] == '21' then
|
|
local dX1Delta = tonumber( Cmd[2])
|
|
local dX2Delta = tonumber( Cmd[3])
|
|
if dX1Delta > 0 and dX2Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = dX2Delta
|
|
elseif dX1Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = nil
|
|
elseif dX2Delta > 0 then
|
|
EMT.X1DELTA = nil
|
|
EMT.X2DELTA = dX2Delta
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareUnload( sCmd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '1' then
|
|
;
|
|
elseif Cmd[1] == '2' then
|
|
local sOut = 'STOPRE'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
EMT.NSTEP = EMT.NSTEP + 10
|
|
local sStep = EgtNumToString( EMT.NSTEP, 0)
|
|
sOut = '_STEP='..sStep
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
local nFunz = 6
|
|
local nVertClamp = 0
|
|
local dPress = 2.5
|
|
local dFeed = GetClampFeed( EMT.LT)
|
|
local dAcc = 4
|
|
local nOpt = 0
|
|
local sRef1 = Cmd[5]
|
|
local sRef2 = EmtLenToString( ParkX2 - ( EMT.LT - EMT.X2DELTA), 3)
|
|
sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
sOut = '_N'..sStep..':STOPRE'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
EMT.U_STD = true
|
|
elseif Cmd[1] == '3' then
|
|
;
|
|
elseif Cmd[1] == '11' then
|
|
;
|
|
elseif Cmd[1] == '12' then
|
|
;
|
|
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.X1DELTA, ' EA112', ' EA111')
|
|
EMT.SB = EgtIf( EMT.X1DELTA, ' EB112', ' EB111')
|
|
EMT.SC = EgtIf( EMT.X2DELTA, ' EC142', ' EC141')
|
|
EMT.SD = EgtIf( EMT.X2DELTA, ' ED142', ' ED141')
|
|
EMT.SE = EgtIf( EMT.X1DELTA, ' EE1', ' EE2')
|
|
end
|
|
-- se è pre-rotazione
|
|
if Cmd[2] == 'Pre-Rotation' then
|
|
EMT.PREROT = true
|
|
elseif Cmd[2] == 'SplitRot' then
|
|
EMT.SPLITROT = 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.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 = 'PX1=' .. ' ' .. 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 = 'PX2=' .. ' ' .. 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 dX1Delta = tonumber( Cmd[2])
|
|
local dX2Delta = tonumber( Cmd[3])
|
|
if dX1Delta > 0 and dX2Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = dX2Delta
|
|
elseif dX1Delta > 0 then
|
|
EMT.X1DELTA = dX1Delta
|
|
EMT.X2DELTA = nil
|
|
elseif dX2Delta > 0 then
|
|
EMT.X1DELTA = nil
|
|
EMT.X2DELTA = dX2Delta
|
|
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] == 'X1' then
|
|
-- tolgo eventuale sovramateriale presente sul pezzo in posizione iniziale (la misura laser è ora col finito)
|
|
local sX1Taking = ' X1='..EmtLenToString( Cmd[3] - EMT.HOVM)
|
|
local sOut = 'G111'..sX1Taking..' 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 = 'PX1=' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
EMT.SB = ' EB11' .. CalcCharStatus( Cmd[2])
|
|
elseif Cmd[1] == '12' then
|
|
local sMsg = 'PX2=' .. ' ' .. Cmd[2]
|
|
table.insert( EMT.AUXCMD, sMsg)
|
|
elseif Cmd[1] == '21' then
|
|
local dX1YDelta = tonumber( Cmd[2])
|
|
local dX2Delta = tonumber( Cmd[3])
|
|
if dX1YDelta > 0 and dX2Delta > 0 then
|
|
EMT.X1DELTA = dX1YDelta
|
|
EMT.X2DELTA = dX2Delta
|
|
elseif dX1YDelta > 0 then
|
|
EMT.X1DELTA = dX1YDelta
|
|
EMT.X2DELTA = nil
|
|
elseif dX2Delta > 0 then
|
|
EMT.X1DELTA = nil
|
|
EMT.X2DELTA = dX2Delta
|
|
end
|
|
local sX1Load = ' X1='..EmtLenToString( LoadT)
|
|
local sOut = 'G111'..sX1Load..' EA76'..EMT.SB..' EE0 EF'..EmtLenToString( EMT.FMAXPINZE,0)..' ET1'
|
|
table.insert( EMT.AUXSTR, sOut)
|
|
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
|
|
-- if EMT.HEAD ~= 'H3' then
|
|
-- local Len = EMT.TLEN + EgtIf( EMT.HEAD == 'H1', MillOffs, abs( 0))
|
|
-- local LenRef = MillOffs
|
|
-- vtE = Vector3d( EMT.EXTR) * 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 - vtE:getY()
|
|
-- EMT.L3 = EMT.L3 - 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
|
|
|
|
-- Assi geometrici sempre XYZ (indipendentemente dal nome assi fisici)
|
|
EMT.L1t = 'X'
|
|
EMT.L2t = 'Y'
|
|
EMT.L3t = 'Z'
|
|
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, DeltaTabY, DeltaTabZ)
|
|
-- 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)
|
|
local sXout, sYout, sZout
|
|
if EMT.X1DELTA then
|
|
sXout = ' X='..EmtLenToString( xS + EMT.X1DELTA)..'+OFS_T5_X1[0]'
|
|
sYout = ' Y=OFS_T5_X1[1]'
|
|
sZout = ' Z=OFS_T5_X1[2]'
|
|
elseif EMT.X2DELTA then
|
|
sXout = ' X='..EmtLenToString( xS + EMT.X2DELTA)..'+OFS_T5_X2[0]'
|
|
sYout = ' Y=OFS_T5_X2[1]'
|
|
sZout = ' Z=OFS_T5_X2[2]'
|
|
else
|
|
EmtSetLastError( 1214, "Part to machine without charriots")
|
|
end
|
|
EMT.IPLGLSTR = 'TRANS'..sXout..sYout..sZout..
|
|
'\nAROT Z'..EgtNumToString( dAngO)..'\nAROT Y'..EgtNumToString( dAngV)..'\nAROT Z'..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
|
|
if AutomaticRotation and EMT.LB >= 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 sOut = 'SUPA G0 D0 Z'..EgtNumToString( ParkZ, 3)
|
|
EmtOutput( sOut)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitSpeedOn( nSpeed)
|
|
if not EMT.SPEED_ON then
|
|
EmtOutput( 'M_ON(1,'..EgtNumToString( nSpeed, 0) ..')')
|
|
EMT.SPEED_ON = true
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitSpeedOff()
|
|
if EMT.SPEED_ON then
|
|
EmtOutput( 'M_OFF(1)')
|
|
EMT.SPEED_ON = nil
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetFmaxClamp()
|
|
return EmtLenToString( EMT.FMAXPINZE, 0)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetClampFeed( dLen)
|
|
local KgMtCubo= 550 -- densità legno [Kg / metro cubo]
|
|
local Massa = ( EMT.HT * EMT.ST * dLen * KgMtCubo ) / 1e9 -- massa [Kg]
|
|
local RefMassa = 100 -- massa di riferimento con massima feed
|
|
local dCoeff = EgtClamp( RefMassa / Massa, 0.1, 1)
|
|
return EmtLenToString( dCoeff * EMT.FMAXPINZE, 0)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** END GENERATION ***
|
|
---------------------------------------------------------------------
|