andrea.villa
3051 lines
124 KiB
Plaintext
3051 lines
124 KiB
Plaintext
-- Processore standard macchine ONE e PF by EgalWare s.r.l. 2023/11/24
|
|
-- Con controllo numerico NUM
|
|
|
|
-- Carico i dati globali
|
|
local sBaseDir = EgtGetSourceDir()
|
|
local BD = dofile( sBaseDir .. 'Beam\\BeamData.lua')
|
|
|
|
-- Variabili di modulo
|
|
local CSP_INFO = INFO_STD_PP.NAME..' ver.'..INFO_STD_PP.VERSION..' by EgalWare s.r.l.'
|
|
local MACHINE_INFO = 'PP_VER 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 = 102000 -- feed massima 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 nPattId = EgtGetInfo( BtlInfoId, 'PATTID', 'i') or 40
|
|
EmtOutput( '%' .. EgtNumToString( nPattId,-1))
|
|
if EMT.INFO then
|
|
EmtOutput( '('..EMT.INFO..')')
|
|
else
|
|
EmtOutput( '(Program Start)')
|
|
end
|
|
EmtOutput( '('.. CSP_INFO..')')
|
|
EmtOutput( '('.. MACHINE_INFO..')\n')
|
|
-- Se modalità test, aggiungo linee per muovere tappeto e alzare la testa (in automatico viene fatto dal main residente)
|
|
if TEST_USE then
|
|
EmitTestProgramStart()
|
|
end
|
|
-- Dichiaro inizio
|
|
EMT.FIRST = true
|
|
-- Dichiaro cabine con rulli in posizione di parcheggio
|
|
EMT.V1POS = ParkV1
|
|
EMT.V2POS = ParkV2
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnProgramEnd()
|
|
-- Arresto mandrino
|
|
--EmtOutput( 'M05')
|
|
-- Emissione scarico
|
|
for i = 1, #EMT.MDCHAR do
|
|
EmitMoveDataChars( EMT.MDCHAR[i])
|
|
end
|
|
if #EMT.MDCHAR > 0 then
|
|
if EMT.AUXTYPE == 'S' then
|
|
EmitMoveStartChars( 1)
|
|
EmitMoveWaitChars( 1)
|
|
elseif EMT.AUXTYPE == 'R' then
|
|
--EmitMoveDataChars( { Y1=ParkY1, Y2=ParkY2, V1=ParkV1, V2=ParkV2, BeamVise=0, MoveType=3, F=GetFmaxClamp()})
|
|
EmitMoveStartChars( 3)
|
|
EmitMoveWaitChars( 3)
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
EmitMoveStartChars( EgtIf( EMT.CHY_ON, 3, 2))
|
|
EmitMoveWaitChars( EgtIf( EMT.CHY_ON, 3, 2), EMT.CHY_ON or TEST_USE)
|
|
-- emissione conclusione pezzo precedente
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sOut)
|
|
end
|
|
end
|
|
end
|
|
EMT.MDCHAR = {}
|
|
EMT.AUXTYPE = nil
|
|
EMT.UNL = nil
|
|
EMT.PREROT = nil
|
|
EMT.SPLITROT = nil
|
|
EMT.CHY_ON = nil
|
|
EMT.FALL = nil
|
|
EMT.SPECSPLIT = nil
|
|
EMT.RELOAD = nil
|
|
EMT.RELOAD2 = nil
|
|
-- Se modalità test, termino il programma
|
|
if TEST_USE then
|
|
EmtOutput( 'M02')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnToolData()
|
|
|
|
-- emissione dati sega a catena
|
|
if EMT.HEAD == 'H13' 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)
|
|
sOut = sOut .. EgtIf( EMT.TCPOS == 'T101', ' G76H9998.2N401N404', ' G76H9998.2N501N504')
|
|
EmtOutput( '('..sOut..')')
|
|
-- emissione dati sega a catena o mortasatrice
|
|
elseif EMT.HEAD == 'H15' or EMT.HEAD == 'H23' 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)
|
|
sOut = sOut .. EgtIf( EMT.TCPOS == 'T111', ' G76H9998.2N411N414', ' G76H9998.2N511N514')
|
|
EmtOutput( '('..sOut..')')
|
|
-- emissione dati utensile (esclusa sega a catena)
|
|
else
|
|
-- output info
|
|
local dAddLen = 0
|
|
if EMT.HEAD == 'H12' then
|
|
dAddLen = -SawOffsZ
|
|
elseif EMT.HEAD == 'H22' then
|
|
dAddLen = -Saw2OffsZ
|
|
end
|
|
local sPos
|
|
if EMT.TCPOS == 'T201' then
|
|
sPos = 'N411'
|
|
else
|
|
|
|
sPos = EgtIf( #EMT.TCPOS == 2, EMT.TCPOS:gsub( 'T', 'N30'), EMT.TCPOS:gsub( 'T', 'N3'))
|
|
end
|
|
local sOut = 'L1='..EgtNumToString( EMT.SMAX, 0)..' L2='..EmtLenToString( dAddLen + EMT.TTOTLEN, 1)..' G76H9998.2'..sPos..sPos
|
|
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') or EMT.TPOS
|
|
EMT.Y1POS = EgtGetInfo( EMT.DISPID, 'Y1POS', 'd')
|
|
-- Se prima disposizione
|
|
if EMT.PHASE == 1 then
|
|
-- variabile appoggio perchè se non definita non posso trasformarla negativa
|
|
local nAppoDelta2TabY
|
|
if EgtGetHeadId( 'H21') and Delta2TabY then
|
|
nAppoDelta2TabY = -Delta2TabY
|
|
else
|
|
nAppoDelta2TabY = 0
|
|
end
|
|
|
|
|
|
-- emissione dati di macchina
|
|
local sOut = 'G154'..' EA'..EmtLenToString( LoadT, 2)..' EB'..EmtLenToString( MinMchY1, 2)..' EC'..EmtLenToString( MaxY1, 2)..
|
|
' ED'..EmtLenToString( MinY2, 2)..' EE'..EmtLenToString( MaxMchY2, 2)..' EF'..EmtLenToString( MillOffs, 2)..
|
|
' EG'..EmtLenToString( EgtIf( EgtGetHeadId( 'H21'), Mill2Offs, 0), 2)..' EH'..EmtLenToString( ParkMchY1, 2)..' EI'..EmtLenToString( ParkMchY2, 2)..
|
|
' EJ'..EmtLenToString( TurnerOffs, 2)..' EK'..EmtLenToString( MinV1, 2)..' EL'..EmtLenToString( MaxV1, 2)..
|
|
' EM'..EmtLenToString( MinV2, 2)..' EN'..EmtLenToString( MaxV2, 2)..
|
|
' EO'..EmtLenToString( -DeltaTabY, 2)..' EP'..EmtLenToString( DeltaTabZ, 2)..
|
|
' EQ'..EmtLenToString( nAppoDelta2TabY, 2)..' ER'..EmtLenToString( EgtIf( EgtGetHeadId( 'H21'), Delta2TabZ, 0), 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
|
|
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
|
|
-- gruppo con info da BTL
|
|
local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or EgtGetCurrMachGroup() or GDB_ID.NULL
|
|
-- dati del grezzo
|
|
local LBarra = EMT.LB
|
|
local HBarra = EMT.HB
|
|
local SBarra = EMT.SB
|
|
-- 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 AccPinze, AccMaxPinze, RidFeed = CalcDinamicaPinze( HTrave, STrave, LBarra)
|
|
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='..EgtNumToString( AccPinze, 0)..' AccMax='..EgtNumToString( AccMaxPinze, 0)..
|
|
' RidFeed='..EgtNumToString( RidFeed, 0)..' FeedMax='..EgtNumToString( EMT.FMAXPINZE / 100 * RidFeed, 3)..' )'
|
|
MyOutputNoNum( sOut)
|
|
-- parametri dinamici carrelli
|
|
sOut = 'G155 EA' .. EgtNumToString( AccPinze, 0) .. ' EB' .. EgtNumToString( AccMaxPinze, 0) ..
|
|
' EC' .. EgtNumToString( AccPinze, 0) .. ' ED' .. EgtNumToString( AccMaxPinze, 0) ..
|
|
' EE' .. EgtNumToString( AccPinze, 0) ..
|
|
' EF' .. EgtNumToString( RidFeed, 0) .. ' EG' .. EgtNumToString( RidFeed, 0) .. ' EH1 EI1' ..
|
|
' EL' .. EmtLenToString( LBarra, 3) .. ' EM' .. EmtLenToString( HTrave, 3) ..
|
|
' EN' .. EmtLenToString( STrave, 3) .. ' EO' .. EmtLenToString( LTrave, 3) ..
|
|
' EP' .. EmtLenToString( HOverM, 3)
|
|
EmtOutput( sOut)
|
|
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
|
|
-- se modalità produzione
|
|
if not TEST_USE then
|
|
-- emissione inizio lavorazione pezzo
|
|
local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED1'
|
|
EmtOutput( sOut)
|
|
-- salto per ottimizzazione carico
|
|
if EMT.LOAD and OptimizedLoadBeam then
|
|
if NumericalControl == 'NUM' then
|
|
EmtOutput( 'G79 E80050<>0 N4 E10015=0')
|
|
else -- NUM_FLEX
|
|
EmtOutput( 'G79 E80060<>0 N4 E10015=0')
|
|
end
|
|
end
|
|
end
|
|
else
|
|
MyOutputNoNum( '(REMAIN UNLOAD)')
|
|
-- parametri dinamici carrelli
|
|
sOut = 'G155 EA' .. EgtNumToString( AccPinze, 0) .. ' EB' .. EgtNumToString( AccMaxPinze, 0) ..
|
|
' EC' .. EgtNumToString( AccPinze, 0) .. ' ED' .. EgtNumToString( AccMaxPinze, 0) ..
|
|
' EE' .. EgtNumToString( AccPinze, 0) ..
|
|
' EF' .. EgtNumToString( RidFeed, 0) .. ' EG' .. EgtNumToString( RidFeed, 0) .. ' EH1 EI1' ..
|
|
' EL' .. EmtLenToString( LBarra, 3) .. ' EM' .. EmtLenToString( HTrave, 3) ..
|
|
' EN' .. EmtLenToString( STrave, 3) .. ' EO' .. EmtLenToString( LBarra, 3) ..
|
|
' EP' .. EmtLenToString( 0, 3)
|
|
EmtOutput( sOut)
|
|
EMT.PRODID = nil
|
|
EMT.PATTID = nil
|
|
EMT.CUTID = nil
|
|
end
|
|
-- se carico barra
|
|
if EMT.LOAD then
|
|
-- ora abilito numerazione linee
|
|
EMT.NUM = true
|
|
EMT.LINENBR = 0
|
|
-- se altrimenti ricarico barra dopo rotazione speciale
|
|
elseif EMT.RELOAD then
|
|
;
|
|
-- altrimenti recupero rimanenza
|
|
else
|
|
-- determino la quota di parcheggio della trave
|
|
local ParkT = GetParkT()
|
|
-- aggiorno dati aggancio carrelli alla trave
|
|
EMT.Y1DELTA = EMT.Y1POS - ParkT
|
|
EMT.Y2DELTA = nil
|
|
if not EMT.Y1DELTA then EMT.V1NEXTPOS = ParkV1 end
|
|
-- emetto comando posizione trave
|
|
EmitBeamHeadData( { T=ParkT, Y1=EMT.Y1POS, SetHead=1, IniStatV1=3, IniStatV2=3})
|
|
end
|
|
-- se altrimenti disposizione intermedia, eventuale rotazione
|
|
elseif IsMidPhase( EMT.PHASE) or IsEnd2Phase( EMT.PHASE) then
|
|
-- recupero le rotazioni delle fasi corrente e precedente
|
|
local nRot = GetPhaseRot( EMT.PHASE)
|
|
local nPrevRot = GetPhaseRot( EMT.PHASE - 1)
|
|
-- verifico se sono diverse
|
|
if nRot ~= nPrevRot then
|
|
local nDeltaRot = nRot - nPrevRot
|
|
-- rotazione automatica o manuale (sempre con il medesimo comando)
|
|
local sOut = 'M180 L0=' .. tostring( nDeltaRot)
|
|
EmtOutput( sOut)
|
|
-- 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
|
|
if #EMT.MDCHAR > 0 then
|
|
MyOutputNoNum( '(PART UNLOAD)')
|
|
for i = 1, #EMT.MDCHAR do
|
|
EmitMoveDataChars( EMT.MDCHAR[i])
|
|
end
|
|
EmitMoveStartChars( 2)
|
|
-- se dopo c'è scarico spezzone devo mettere attesa termine esecuzione
|
|
if IsRestPhase( EMT.PHASE + 1) then
|
|
EmitMoveWaitChars( 2)
|
|
else
|
|
EmitMoveWaitChars( 2, TEST_USE)
|
|
end
|
|
-- emissione conclusione pezzo precedente
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sOut)
|
|
end
|
|
elseif EMT.SPECUNLOADING then
|
|
EmtOutput( '(PART SPEC UNLOADING)')
|
|
EmitBeamHeadData( { T=EMT.L1, Pz5=2})
|
|
EMT.SPECUNLOADING = nil
|
|
EMT.W2DELTA = nil
|
|
-- emissione conclusione pezzo precedente
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sOut)
|
|
end
|
|
end
|
|
EMT.MDCHAR = {}
|
|
EMT.AUXTYPE = 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
|
|
EMT.HB = 0
|
|
EMT.SB = 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
|
|
local HBarra = b3Raw:getDimY()
|
|
EMT.HB = max( EMT.HB, HBarra)
|
|
local SBarra = b3Raw:getDimZ()
|
|
EMT.SB = max( EMT.SB, SBarra)
|
|
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
|
|
EMT.XMINT = b3Part:getMin():getX()
|
|
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
|
|
EMT.TUSERNOTES = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnToolDeselect()
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
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)
|
|
EMT.MCHSPLIT = ( EMT.MCHUSERNOTES:find( 'Split;', 1, true) ~= nil)
|
|
EMT.MCHPRECUT = ( EMT.MCHUSERNOTES:find( 'Precut;', 1, true) ~= nil)
|
|
|
|
-- se sega a catena, aggiusto subito angolo scelto per asse virtuale A
|
|
if EMT.HEAD == 'H13' or EMT.HEAD == 'H15' then
|
|
-- valore dell'asse virtuale
|
|
dPosA = GetCurrChainSawingVirtualAxis()
|
|
-- imposto home dell'asse C1 (A=0 -> T101, A=-90 -> T104)
|
|
local MyParkCSawC1 = GetChainSawCHomeFromVirtualAxis( dPosA)
|
|
EmtModifyAxisHome( 'C1', MyParkCSawC1)
|
|
elseif EMT.HEAD == 'H23' then
|
|
-- valore dell'asse virtuale
|
|
dPosA = GetCurrChainSawingVirtualAxis()
|
|
-- imposto home dell'asse C2 (A=0 -> T111, A=-90 -> T112)
|
|
local MyParkCSawC2 = GetChainSawCHomeFromVirtualAxis( dPosA)
|
|
EmtModifyAxisHome( 'C2', MyParkCSawC2)
|
|
end
|
|
-- gestione eventuale lavorazione in doppio
|
|
local nDouType = EgtGetValInNotes( EMT.MCHUSERNOTES, 'DOUBLE', 'i')
|
|
if nDouType == 2 or nDouType == 3 then
|
|
local sDouTool = EgtGetValInNotes( EMT.TUSERNOTES, 'DOUBLE', 's') or ''
|
|
local sOldTool = EgtTdbGetCurrToolParam( MCH_TP.NAME)
|
|
if EgtTdbSetCurrTool( sDouTool) and EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then
|
|
-- salvo dati
|
|
EMT.DOU_TLEN = EgtTdbGetCurrToolParam( MCH_TP.LEN)
|
|
EMT.DOU_TYPE = nDouType
|
|
EMT.DOU_TOOL = sDouTool
|
|
EMT.DOU_HEAD = 'H21'
|
|
EMT.DOU_EXIT = 1
|
|
EMT.DOU_TPOS = AdjustTcPos( false, EgtTdbGetCurrToolParam( MCH_TP.TCPOS))
|
|
EMT.DOU_SPEED = EgtTdbGetCurrToolParam( MCH_TP.SPEED)
|
|
-- imposto correttamente i dati della testa 2
|
|
local OrigEMC = EMC
|
|
EMC = { HEAD = EMT.DOU_HEAD, TOTDIAM = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM)}
|
|
OnSetHead()
|
|
EMC = OrigEMC
|
|
-- non va in sicurezza testa in doppio
|
|
EMT.DOU_TO_ZMAX = nil
|
|
else
|
|
EmtSetLastError( 1211, 'Missing or not active double tool of '..sOldTool)
|
|
end
|
|
EgtTdbSetCurrTool( sOldTool)
|
|
end
|
|
-- se testa in doppio ancora da rimettere in sicurezza
|
|
if EMT.DOU_TO_ZMAX then
|
|
local dPosT = EMT.TPOS or EMT.L1op
|
|
EmitParkRoller( dPosT, false)
|
|
EmitDouZMax()
|
|
EMT.REFLOC = nil
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnMachiningEnd()
|
|
--EmtOutput( ';Mach End')
|
|
if #EMT.MDCHAR > 0 then
|
|
-- Emissione split
|
|
if EMT.AUXTYPE == 'S' then
|
|
EmtOutput( '(PART SPLIT)')
|
|
local AccPinz1, AccMaxPinz1, RidFeed1 = CalcDinamicaPinze( EMT.HT, EMT.ST, EMT.LB - EMT.LT)
|
|
local AccPinz2, AccMaxPinz2, RidFeed2 = CalcDinamicaPinze( EMT.HT, EMT.ST, EMT.LT)
|
|
-- parametri dinamici carrelli
|
|
local sOut = 'G155 EA' .. EgtNumToString( AccPinz1, 0) .. ' EB' .. EgtNumToString( AccMaxPinz1, 0) ..
|
|
' EC' .. EgtNumToString( AccPinz2, 0) .. ' ED' .. EgtNumToString( AccMaxPinz2, 0) ..
|
|
' EE' .. EgtNumToString( AccPinz2, 0) ..
|
|
' EF' .. EgtNumToString( RidFeed1, 0) .. ' EG' .. EgtNumToString( RidFeed2, 0) .. ' EH1 EI1' ..
|
|
' EL' .. EmtLenToString( EMT.LB - EMT.LT, 3) .. ' EM' .. EmtLenToString( EMT.HT, 3) ..
|
|
' EN' .. EmtLenToString( EMT.ST, 3) .. ' EO' .. EmtLenToString( EMT.LT, 3) ..
|
|
' EP' .. EmtLenToString( 0, 3)
|
|
EmtOutput( sOut)
|
|
EMT.LB = EMT.LT
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
EmtOutput( '(PART UNLOAD)')
|
|
-- movimento intermedio di apertura pinza-rulli per evitare di trovare delle collisioni
|
|
EmitParkRoller( EMT.TPOS, false, false)
|
|
EMT.V1POS = EMT.V1NEXTPOS
|
|
EMT.V2POS = EMT.V2NEXTPOS
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
if EMT.PREROT then
|
|
if not EMT.ZMAX then
|
|
EmitZmax( false, true, true, EMT.R1, EMT.R2, false, ( #EMT.MDCHAR > 0))
|
|
EMT.ZMAX = true
|
|
EMT.TO_ZMAX = nil
|
|
else
|
|
EmitXhome()
|
|
end
|
|
EMT.TO_XHOME = nil
|
|
EmtOutput( '(PART ROTATION)')
|
|
elseif EMT.FALL then
|
|
if EMT.TO_ZMAX and not EMT.ZMAX then
|
|
EmitZmax( false, true, true, EMT.R1, EMT.R2, false, ( #EMT.MDCHAR > 0))
|
|
EMT.ZMAX = true
|
|
EMT.TO_ZMAX = nil
|
|
EMT.TO_XHOME = nil
|
|
end
|
|
EmtOutput( '(PART FALL)')
|
|
elseif EMT.SPECSPLIT then
|
|
if EMT.TO_ZMAX and not EMT.ZMAX then
|
|
EmitZmax( false, true, true, EMT.R1, EMT.R2, false, ( #EMT.MDCHAR > 0))
|
|
EMT.ZMAX = true
|
|
EMT.TO_ZMAX = nil
|
|
EMT.TO_XHOME = nil
|
|
end
|
|
EmtOutput( '(PART SPEC SPLIT)')
|
|
else
|
|
EmtOutput( '(PART SPLIT 2)')
|
|
local AccPinz1, AccMaxPinz1, RidFeed1 = CalcDinamicaPinze( EMT.HT, EMT.ST, EMT.LB - EMT.LT)
|
|
local AccPinz2, AccMaxPinz2, RidFeed2 = CalcDinamicaPinze( EMT.HT, EMT.ST, EMT.LT)
|
|
-- parametri dinamici carrelli
|
|
local sOut = 'G155 EA' .. EgtNumToString( AccPinz1, 0) .. ' EB' .. EgtNumToString( AccMaxPinz1, 0) ..
|
|
' EC' .. EgtNumToString( AccPinz2, 0) .. ' ED' .. EgtNumToString( AccMaxPinz2, 0) ..
|
|
' EE' .. EgtNumToString( AccPinz2, 0) ..
|
|
' EF' .. EgtNumToString( RidFeed1, 0) .. ' EG' .. EgtNumToString( RidFeed2, 0) .. ' EH1 EI1' ..
|
|
' EL' .. EmtLenToString( EMT.LB, 3) .. ' EM' .. EmtLenToString( EMT.HT, 3) ..
|
|
' EN' .. EmtLenToString( EMT.ST, 3) .. ' EO' .. EmtLenToString( EMT.LT, 3) ..
|
|
' EP' .. EmtLenToString( 0, 3)
|
|
EmtOutput( sOut)
|
|
EMT.LB = EMT.LT
|
|
end
|
|
end
|
|
-- forzo reset piano locale
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
end
|
|
for i = 1, #EMT.MDCHAR do
|
|
EmitMoveDataChars( EMT.MDCHAR[i])
|
|
if EMT.MDCHAR[i].V1 then EMT.V1POS = EMT.MDCHAR[i].V1 end
|
|
if EMT.MDCHAR[i].V2 then EMT.V2POS = EMT.MDCHAR[i].V2 end
|
|
end
|
|
if #EMT.MDCHAR > 0 then
|
|
if EMT.AUXTYPE == 'S' then
|
|
EmitMoveStartChars( 1)
|
|
EmitMoveWaitChars( 1)
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
local nMoveType = EgtIf( EMT.CHY_ON, 3, 2)
|
|
EmitMoveStartChars( nMoveType)
|
|
-- se dopo cè scarico spezzone devo mettere attesa termine esecuzione
|
|
if IsRestPhase( EMT.PHASE + 1) then
|
|
EmitMoveWaitChars( nMoveType)
|
|
else
|
|
EmitMoveWaitChars( nMoveType, EMT.CHY_ON or TEST_USE)
|
|
end
|
|
-- emissione conclusione pezzo precedente (se non in modalità test)
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sOut)
|
|
end
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
EmitMoveStartChars( 3)
|
|
EmitMoveWaitChars( 3)
|
|
if EMT.FALL then
|
|
EmtOutput( 'G157 EB1')
|
|
-- emissione conclusione pezzo (se non in modalità test)
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sOut)
|
|
end
|
|
elseif not EMT.PREROT then
|
|
EmtOutput( '(M77)')
|
|
end
|
|
end
|
|
end
|
|
if EMT.SPECUNLOADING then
|
|
EmtOutput( '(PART SPEC UNLOADING)')
|
|
EmitBeamHeadData( { T=EMT.L1, Pz5=2})
|
|
EMT.SPECUNLOADING = nil
|
|
EMT.W2DELTA = nil
|
|
-- emissione conclusione pezzo (se non in modalità test)
|
|
if not TEST_USE and EMT.PRODID then
|
|
local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
|
|
EmtOutput( sOut)
|
|
end
|
|
end
|
|
EMT.MDCHAR = {}
|
|
EMT.AUXTYPE = nil
|
|
EMT.TO_ZMAX = nil
|
|
EMT.TO_XHOME = nil
|
|
EMT.PREVTOOL = EMT.TOOL
|
|
EMT.PREVHEAD = EMT.HEAD
|
|
EMT.PREVTCPOS = EMT.TCPOS
|
|
if EMT.DOU_TYPE and not EMT.ZMAX then EMT.DOU_TO_ZMAX = true end
|
|
EMT.DOU_TYPE = nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathStart()
|
|
-- non ancora iniziata la lavorazione
|
|
EMT.MCHFIRST = true
|
|
EMT.MCHFIRSTFEED = true
|
|
-- se piano locale compatibile
|
|
local vtExtr = Vector3d( EMT.EXTR)
|
|
if EMT.REFLOC == 1 and AreSameVectorApprox( vtExtr, EMT.IPLGLFR:getVersZ()) then
|
|
;
|
|
-- altrimenti primo posizionamento sempre in globale
|
|
else
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
end
|
|
-- leggo se ancora presa iniziale carrello
|
|
--EMT.CNT = EgtGetInfo( EMT.PATHID, 'CNT', 'i')
|
|
--EmtOutput( 'CNT='.. tostring( EMT.CNT or 0))
|
|
-- se taglio di separazione, verifico se ci sarà caduta
|
|
if EMT.MCHSPLIT then
|
|
local sCmd = EgtGetInfo( EMT.PATHID, 'AE1') or ''
|
|
if sCmd:find( 'Fall', 1, true) then
|
|
EMT.TO_FALL = true
|
|
elseif sCmd:find( 'SpecSplit', 1, true) then
|
|
EMT.TO_SPECSPLIT = true
|
|
end
|
|
end
|
|
|
|
-- se taglio di precut verifico quanto è più lungo il grezzo rispetto al pezzo (non tiene conto dell'ultimo cubetto)
|
|
EMT.DELTA_LT = 0
|
|
if EMT.MCHPRECUT then
|
|
local dCosA = sqrt( max( 1 - EMT.EXTR[1] * EMT.EXTR[1], 0))
|
|
EMT.DELTA_LT = max( EMT.XMINT - Point3d( EMT.MMAX):getX() - dCosA * EMT.TDIAM / 2, 0)
|
|
end
|
|
|
|
-- se utensile non cambiato, salvo eventuali precedenti lineari e rotanti
|
|
if EMT.TOOL == EMT.PREVTOOL and not EMT.ZMAX then
|
|
EMT.L1pp = EMT.L1op
|
|
EMT.L2pp = EMT.L2op
|
|
EMT.L3pp = EMT.L3op
|
|
EMT.R1pp = EMT.R1p
|
|
EMT.R2pp = EMT.R2p
|
|
else
|
|
EMT.L1pp = nil
|
|
EMT.L2pp = nil
|
|
EMT.L3pp = nil
|
|
EMT.R1pp = nil
|
|
EMT.R2pp = nil
|
|
end
|
|
-- reset valori precedenti (per forzare emissione di tutti gli assi del 1° movimento)
|
|
EmtResetPrev()
|
|
EMT.AUXCMD = {}
|
|
EMT.MDCHAR = {}
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathEnd()
|
|
if not EMT.ZMAX then
|
|
EmitResetMachining()
|
|
end
|
|
EMT.AUXTYPE = nil
|
|
EMT.UNL = nil
|
|
EMT.PREROT = nil
|
|
EMT.SPLITROT = nil
|
|
EMT.CHY_ON = nil
|
|
EMT.FALL = nil
|
|
EMT.TO_FALL = nil
|
|
EMT.SPECSPLIT = nil
|
|
EMT.TO_SPECSPLIT = nil
|
|
EMT.MDCHAR = {}
|
|
EMT.PREVTOOL = EMT.TOOL
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPathStartAux()
|
|
--EgtOutLog( 'OnPathStartAux - ' .. EgtNumToString( EMT.AUXIND, 0) .. ' - ' .. EMT.AUX)
|
|
-- salvo il comando per processarlo successivamente
|
|
table.insert( EMT.AUXCMD, EMT.AUX)
|
|
-- gestione speciale per richiesta di movimento a ZMAX
|
|
local Cmd = EgtSplitString( EMT.AUX)
|
|
if Cmd[1] == '4' then
|
|
EMT.TO_ZMAX = true
|
|
if Cmd[2] == '1' then
|
|
EMT.TO_XHOME = true
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function ProcessPathStartAux( sCmd, nInd)
|
|
-- se richiesto, preparo il carico barra
|
|
if EMT.LOAD or EMT.RELOAD then
|
|
PrepareLoad( sCmd, nInd, true)
|
|
-- se altrimenti carico dopo rotazione
|
|
elseif EMT.POSTROT then
|
|
PreparePostRotation( sCmd, nInd)
|
|
-- altrimenti, preparo lo spostamento carrelli
|
|
else
|
|
PrepareMoveChar( sCmd, nInd)
|
|
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 Cmd[1] == '0' and Cmd[2] == 'Unloading SpecSplit' then
|
|
EMT.AUXTYPE = 'P'
|
|
EMT.SPECUNLOADING = true
|
|
else
|
|
EMT.AUXTYPE = 'R'
|
|
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
|
|
elseif Cmd[1] == '0' and Cmd[2] == 'SpecSplit' then
|
|
EMT.SPECSPLIT = true
|
|
elseif Cmd[1] == '0' and Cmd[2] == 'Unloading SpecSplit' then
|
|
EMT.SPECUNLOADING = 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, EMT.AUXIND, false)
|
|
-- per lo scarico della rimanenza
|
|
else
|
|
PrepareResidue( EMT.AUX, EMT.AUXIND)
|
|
end
|
|
elseif EMT.AUXTYPE == 'S' then
|
|
-- per lo split
|
|
PrepareSplit( EMT.AUX, EMT.AUXIND)
|
|
elseif EMT.AUXTYPE == 'U' then
|
|
-- per lo scarico
|
|
PrepareUnload( EMT.AUX, EMT.AUXIND)
|
|
elseif EMT.AUXTYPE == 'P' then
|
|
-- per la pre-rotazione
|
|
PreparePreRotation( EMT.AUX, EMT.AUXIND)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnRapid()
|
|
-- gruppo della testa
|
|
local nHSet = GetHeadSet( EMT.HEAD)
|
|
-- se primo movimento della lavorazione, gestione speciale
|
|
if EMT.MCHFIRST and not EMT.OPEISDISP and ( EMT.REFLOC ~= 1 or GetDiffRotAxAtStart( EMT.R1, EMT.R2) or GetMovesInAuxCmd( EMT.AUXCMD)) then
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
local HomeR1 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'C1', 'C2'))
|
|
local HomeR2 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'B1', 'B2'))
|
|
local PrevR1 = EMT.R1p or EMT.R1pp or HomeR1
|
|
local PrevR2 = EMT.R2p or EMT.R2pp or HomeR2
|
|
EmtResetPrev()
|
|
-- se prima lavorazione
|
|
if EMT.LOAD then
|
|
EMT.V2POS = ParkV2
|
|
-- primo posizionamento
|
|
local Speed = EMT.S * EgtIf( EMT.HEAD ~= 'H12' and EMT.HEAD ~= 'H22', 1, 1.65)
|
|
local bOnlyCharY = true
|
|
-- eventuale Movimento Pinze
|
|
for i = 1, #EMT.AUXCMD do
|
|
ProcessPathStartAux( EMT.AUXCMD[i], i)
|
|
end
|
|
EMT.AUXCMD = {}
|
|
-- se Split lascio agganciata solo la pinza Y2 alla fine dei movimenti
|
|
if EMT.MCHSPLIT and #EMT.MDCHAR > 0 and not EMT.TO_FALL and not EMT.TO_SPECSPLIT then
|
|
EMT.MDCHAR[#EMT.MDCHAR].FinStatY1 = 1
|
|
end
|
|
for i = 1, #EMT.MDCHAR do
|
|
EmitMoveDataChars( EMT.MDCHAR[i])
|
|
if EMT.MDCHAR[i].MovType ~= 1 then bOnlyCharY = false end
|
|
end
|
|
EMT.MDCHAR = {}
|
|
EmitMoveStartChars( EgtIf( bOnlyCharY, 1, 3))
|
|
sOut = string.gsub( string.gsub( EMT.MCHNAME..'/'..EMT.TOOL, '%(', '['), '%)', ']')
|
|
if EMT.DOU_TYPE then sOut = sOut .. ' Double' end
|
|
EmtOutput( '( *** '..sOut..' *** )')
|
|
-- se necessario allargo le cabine
|
|
if RollerParkingNeeded( EMT.HEAD, PrevR1, PrevR2, EMT.R1, EMT.R2) or
|
|
EMT.V1POS < EMT.V1NEXTPOS - 1 or EMT.V2POS > EMT.V2NEXTPOS + 1 then
|
|
local dPosT = EMT.TPOS or EMT.L1op
|
|
EmitParkRoller( dPosT, EMT.MCHSPLIT)
|
|
end
|
|
-- se testa 1 e CU 1
|
|
if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' then
|
|
-- allontanamento o eventuale preselezione successiva testa 2
|
|
if not EMT.DOU_TYPE then
|
|
PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
|
|
end
|
|
-- movimento testa
|
|
local dSafeZ1 = EgtGetAxisHomePos( 'Z1')
|
|
local MyMaxZ1 = EgtGetAxisMax( 'Z1')
|
|
local HomeB1 = EgtGetAxisHomePos( 'B1')
|
|
local HomeC1 = EgtGetAxisHomePos( 'C1')
|
|
local dTRad, dTLen = GetToolRadLen()
|
|
local dXref = EMT.L2
|
|
if EMT.HEAD == 'H12' and EMT.L2 < -LimX1PlRotSaw then
|
|
dXref = -LimX1PlRotSaw
|
|
end
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=ParkB1, C=ParkC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
|
|
local dZref = EMT.L3
|
|
-- se carico destro e ho due teste, altrimenti in caso abbia una testa , tipo ONE, il controlo è invertito
|
|
if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
|
|
dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
|
|
end
|
|
-- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
|
|
if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
|
|
EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=0, C=ParkC1, S=Speed})
|
|
EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
|
|
-- caso standard
|
|
else
|
|
EmitMoveDataHead( 1, { X=dXref, Z=dZref, B=ParkB1, C=ParkC1, S=Speed})
|
|
EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
end
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 1, { X=-ParkCSawX1, Z=ParkCSawZ1, B=ParkCSawB1, C=ParkCSawC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
|
|
|
|
-- se motosega configurata per lavorazioni di fianco o circa orizzontale
|
|
if dPosA == 0 or abs( EMT.R2) < 10 then
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
-- se circa verticale
|
|
else
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
end
|
|
end
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
-- se lavorazione in doppio
|
|
if EMT.DOU_TYPE == 2 then
|
|
local dX2 = - ( Delta2TabY - EMT.DOU_TLEN - ( -DeltaTabY - EMT.L2 - EMT.TLEN + EgtIf( BD.RIGHT_LOAD, -EMT.HB, EMT.HB)))
|
|
local dZ2 = -Head2Z + MillOffs - Mill2Offs + EMT.L3
|
|
dZ2 = max( dZ2, MaxZ2)
|
|
local dC2 = -EMT.R1
|
|
local dB2 = -EMT.R2
|
|
EmitMoveDataHead( 2, { X=dX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
|
|
EmitMoveDataHead( 2, { Z=dZ2, B=dB2, C=dC2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
|
|
EmitMoveStartHead( 2)
|
|
-- aspetto esecuzione movimento testa 2
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
-- aspetto termine esecuzione movimenti testa 1
|
|
EmitMoveWaitHead( 1)
|
|
-- altrimenti testa 2
|
|
else
|
|
-- se testa 1 su CU 2
|
|
if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC2' then
|
|
-- allontanamento o eventuale preselezione successiva testa 1
|
|
PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
|
|
-- movimento testa
|
|
local dSafeZ1 = EgtGetAxisHomePos( 'Z21')
|
|
local MyMaxZ1 = EgtGetAxisMax( 'Z1')
|
|
local HomeC1 = EgtGetAxisHomePos( 'C1')
|
|
local HomeB1 = EgtGetAxisHomePos( 'B1')
|
|
local dTRad, dTLen = GetToolRadLen()
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=MyMaxZ1, B=HomeB1, C=HomeC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
|
|
local dZref = EMT.L3
|
|
if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then
|
|
dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
|
|
end
|
|
-- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
|
|
if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=MyMaxZ1, B=0, C=HomeC1, S=Speed})
|
|
EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
|
|
-- altrimenti caso standard
|
|
else
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=dZref, B=HomeB1, C=HomeC1, S=Speed})
|
|
EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
|
|
EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
|
|
end
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 1, { X=-ParkCSawX1, Z=ParkCSawZ1, B=ParkCSawB1, C=ParkCSawC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
|
|
|
|
-- se motosega configurata per lavorazioni di fianco o circa orizzontale
|
|
if dPosA == 0 or abs( EMT.R2) < 10 then
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
-- se circa verticale
|
|
else
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
end
|
|
|
|
end
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
-- aspetto termine esecuzione movimenti testa 2
|
|
EmitMoveWaitHead( 1)
|
|
|
|
-- altrimenti testa 2 su CU 2
|
|
else
|
|
-- allontanamento o eventuale preselezione successiva testa 1
|
|
PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
|
|
-- movimento testa
|
|
local dSafeZ2 = EgtGetAxisHomePos( 'Z2')
|
|
local MyMaxZ2 = EgtGetAxisMax( 'Z2')
|
|
local HomeC2 = EgtGetAxisHomePos( 'C2')
|
|
local HomeB2 = EgtGetAxisHomePos( 'B2')
|
|
local dTRad, dTLen = GetToolRadLen()
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
EmitMoveDataHead( 2, { X=EMT.L2, Z=MyMaxZ2, B=HomeB2, C=HomeC2, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 2)
|
|
EmitMoveWaitHead( 2)
|
|
EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
|
|
local dZref = EMT.L3
|
|
if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX2RotSaw, EMT.L2 > -LimX2RotSaw) or EMT.R2 > 91) then
|
|
dZref = min( dSafeZ2 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ2)
|
|
end
|
|
-- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
|
|
if EMT.HEAD == 'H22' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC2 - EMT.R1) > 30.1 or abs( HomeB2 - EMT.R2) > 30.1) then
|
|
EmitMoveDataHead( 2, { X=EMT.L2, Z=MyMaxZ2, B=0, C=HomeC2, S=Speed})
|
|
EmitMoveDataHead( 2, { C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 2, { Z=dZref, B=EMT.R2, S=Speed})
|
|
-- altrimenti caso standard
|
|
else
|
|
EmitMoveDataHead( 2, { X=EMT.L2, Z=dZref, B=HomeB2, C=HomeC2, S=Speed})
|
|
EmitMoveDataHead( 2, { B=EMT.R2, S=Speed})
|
|
EmitMoveDataHead( 2, { C=EMT.R1, S=Speed})
|
|
end
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 1, { X=-ParkCSawX1, Z=ParkCSawZ1, B=ParkCSawB1, C=ParkCSawC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
|
|
|
|
-- se motosega configurata per lavorazioni di fianco o circa orizzontale
|
|
if dPosA == 0 or abs( EMT.R2) < 10 then
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
-- se circa verticale
|
|
else
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
end
|
|
end
|
|
EmitMoveDataHead( 2, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 2)
|
|
-- aspetto termine esecuzione movimenti testa 2
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
end
|
|
-- se pezzo a destra, dichiaro cabina sinistra da parcheggiare
|
|
if not EMT.Y1DELTA then
|
|
EMT.V1NEXTPOS = ParkV1
|
|
end
|
|
local BhData = { T=EMT.L1}
|
|
if EMT.Y1DELTA then
|
|
BhData.Y1 = EMT.L1 + EMT.Y1DELTA
|
|
BhData.ViseY1 = 1
|
|
else
|
|
BhData.Y1 = ParkY1
|
|
BhData.ViseY1 = 2
|
|
end
|
|
if EMT.MCHSPLIT and EMT.Y2DELTA then
|
|
BhData.ViseY1 = 3
|
|
end
|
|
if EMT.Y2DELTA then
|
|
BhData.Y2 = EMT.L1 + EMT.Y2DELTA
|
|
BhData.ViseY2 = 1
|
|
else
|
|
BhData.Y2 = EmtLenToString( ParkY2)
|
|
BhData.ViseY2 = 2
|
|
end
|
|
if GetV1ToCloseNum() then
|
|
BhData.FinStatV1 = -3
|
|
EMT.V1POS = EMT.V1NEXTPOS
|
|
BhData.V1 = EMT.V1POS
|
|
else
|
|
BhData.IniStatV1 = 3
|
|
EMT.V1POS = ParkV1
|
|
BhData.V1 = EMT.V1POS
|
|
end
|
|
if GetV2ToCloseNum() then
|
|
BhData.FinStatV2 = -3
|
|
EMT.V2POS = EMT.V2NEXTPOS
|
|
BhData.V2 = EMT.V2POS
|
|
else
|
|
BhData.IniStatV2 = 3
|
|
EMT.V2POS = ParkV2
|
|
BhData.V2 = EMT.V2POS
|
|
end
|
|
if EMT.W2DELTA then
|
|
BhData.W = EMT.L1 + EMT.W2DELTA
|
|
end
|
|
EmitBeamHeadData( BhData)
|
|
EMT.LOAD = false
|
|
-- altrimenti lavorazione successiva
|
|
else
|
|
--EmtOutput( string.format( 'V1Pos=%.3f V2Pos=%.3f', EMT.V1POS, EMT.V2POS))
|
|
local bToPresel = true
|
|
if not EMT.RELOAD and not EMT.ZMAX and #EMT.AUXCMD > 0 and EMT.TO_ZMAX then
|
|
-- allontanamento o eventuale preselezione successiva testa differente
|
|
if not EMT.DOU_TYPE then
|
|
PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
|
|
end
|
|
bToPresel = false
|
|
-- risalita a Zmax
|
|
EmitZmax( false, false, EMT.TO_XHOME, PrevR1, PrevR2)
|
|
EMT.ZMAX = true
|
|
EMT.TO_ZMAX = nil
|
|
EMT.TO_XHOME = nil
|
|
EMT.L3pp = nil
|
|
PrevR1 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'C1', 'C2'))
|
|
PrevR2 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'B1', 'B2'))
|
|
end
|
|
-- calcolo Movimento Pinze (potrebbe richiedere movimento testa in Home)
|
|
for i = 1, #EMT.AUXCMD do
|
|
ProcessPathStartAux( EMT.AUXCMD[i], i)
|
|
end
|
|
EMT.AUXCMD = {}
|
|
-- se necessario posizionamento in home (sono sicuramente già a Zmax)
|
|
if EMT.TO_XHOME then
|
|
-- se precedente non era sega a catena, vado in home con quella
|
|
if not HeadIsChainSaw( EMT.PREVHEAD) then
|
|
local nPrevHSet = GetHeadSet( EMT.PREVHEAD)
|
|
if nPrevHSet == 1 then
|
|
local HomeX1 = EgtGetAxisHomePos( 'X1')
|
|
EmitMoveDataHead( 1, { X=-HomeX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos='0'})
|
|
EmitMoveStartHead( 1, 'EA1')
|
|
else
|
|
local HomeX2 = EgtGetAxisHomePos( 'X2')
|
|
EmitMoveDataHead( 2, { X=-HomeX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos='0'})
|
|
EmitMoveStartHead( 2, 'EA1')
|
|
end
|
|
-- altrimenti la deposito e vado in home speciale
|
|
else
|
|
-- se successivo non è sega a catena, ne lancio il carico
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
if nHSet == 1 then
|
|
local HomeX1 = EgtGetAxisHomePos( 'X1')
|
|
EmitMoveDataHead( 1, { X=-HomeX1, Z=MaxZ1, B=HomeR2, C=HomeR1})
|
|
EmitMoveStartHead( 1, 'EA1')
|
|
else
|
|
local HomeX2 = EgtGetAxisHomePos( 'X2')
|
|
EmitMoveDataHead( 2, { X=-HomeX2, Z=MaxZ2, B=HomeR2, C=HomeR1})
|
|
EmitMoveStartHead( 2, 'EA1')
|
|
end
|
|
-- altrimenti deposito e mi metto in posizione sicura
|
|
else
|
|
if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' or GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC2' then
|
|
EmitMoveDataHead( 1, { X=-ParkCSawX1S, Z=MaxZ1, B=HomeR2, C=HomeR1, TPos='0'})
|
|
EmitMoveStartHead( 1, 'EA1')
|
|
else
|
|
EmitMoveDataHead( 2, { X=-ParkCSawX2S, Z=MaxZ2, B=HomeR2, C=HomeR1, TPos='0'})
|
|
EmitMoveStartHead( 2, 'EA1')
|
|
end
|
|
end
|
|
end
|
|
EMT.TO_XHOME = nil
|
|
EMT.L3pp = nil
|
|
PrevR1 = HomeR1
|
|
PrevR2 = HomeR2
|
|
elseif bToPresel then
|
|
-- allontanamento o eventuale preselezione successiva testa differente
|
|
if not EMT.DOU_TYPE then
|
|
PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
|
|
end
|
|
bToPresel = false
|
|
end
|
|
sOut = string.gsub( string.gsub( EMT.MCHNAME..'/'..EMT.TOOL, '%(', '['), '%)', ']')
|
|
if EMT.DOU_TYPE then sOut = sOut .. ' Double' end
|
|
EmtOutput( '( *** '..sOut..' *** )')
|
|
-- se Split lascio agganciata solo la pinza Y2 alla fine dei movimenti
|
|
if EMT.MCHSPLIT and #EMT.MDCHAR > 0 and not EMT.TO_FALL and not EMT.TO_SPECSPLIT then
|
|
EMT.MDCHAR[#EMT.MDCHAR].FinStatY1 = 1
|
|
end
|
|
for i = 1, #EMT.MDCHAR do
|
|
EmitMoveDataChars( EMT.MDCHAR[i])
|
|
end
|
|
if #EMT.MDCHAR > 0 then
|
|
local nMoveType = EgtIf( EMT.POSTROT or EMT.RELOAD, 1, 3)
|
|
EmitMoveStartChars( nMoveType)
|
|
EmitMoveWaitChars( nMoveType)
|
|
end
|
|
EMT.MDCHAR = {}
|
|
-- se necessario allargo le cabine
|
|
if RollerParkingNeeded( EMT.HEAD, PrevR1, PrevR2, EMT.R1, EMT.R2) or
|
|
EMT.V1POS < EMT.V1NEXTPOS - 1 or EMT.V2POS > EMT.V2NEXTPOS + 1 then
|
|
local dPosT = EMT.TPOS or EMT.L1op
|
|
EmitParkRoller( dPosT, EMT.MCHSPLIT)
|
|
end
|
|
-- se testa 1
|
|
if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' then
|
|
-- movimento testa
|
|
local dSafeZ1 = EgtGetAxisHomePos( 'Z1')
|
|
local MyMaxZ1 = EgtGetAxisMax( 'Z1')
|
|
local HomeC1 = EgtGetAxisHomePos( 'C1')
|
|
local HomeB1 = EgtGetAxisHomePos( 'B1')
|
|
local dTRad, dTLen = GetToolRadLen()
|
|
local Speed = EMT.S * EgtIf( EMT.HEAD ~= 'H12' and EMT.HEAD ~= 'H22', 1, 1.65)
|
|
if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
local CurrZ1 = EMT.L3pp or MyMaxZ1
|
|
local CurrB1 = PrevR2
|
|
local CurrC1 = PrevR1
|
|
local dXref = EMT.L2
|
|
if EMT.HEAD == 'H12' and EMT.L2 < -LimX1PlRotSaw then
|
|
dXref = -LimX1PlRotSaw
|
|
end
|
|
EmitMoveDataHead( 1, { X=dXref, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
local dZref = EMT.L3
|
|
if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
|
|
dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
|
|
end
|
|
-- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
|
|
if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
|
|
EmitMoveDataHead( 1, { B=0, S=Speed})
|
|
EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
|
|
-- altrimenti caso standard
|
|
else
|
|
EmitMoveDataHead( 1, { Z=dZref, S=Speed})
|
|
EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
|
|
EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
|
|
end
|
|
-- altrimenti sega a catena 'H13'
|
|
else
|
|
EmitMoveDataHead( 1, { X=-ParkCSawX1, Z=ParkCSawZ1, B=ParkCSawB1, C=ParkCSawC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
-- se motosega configurata per lavorazioni di fianco o circa orizzontale
|
|
if dPosA == 0 or abs( EMT.R2) < 10 then
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
-- se circa verticale
|
|
else
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
end
|
|
end
|
|
end
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
-- se lavorazione in doppio
|
|
if EMT.DOU_TYPE == 2 then
|
|
local dX2 = - ( Delta2TabY - EMT.DOU_TLEN - ( -DeltaTabY - EMT.L2 - EMT.TLEN + EgtIf( BD.RIGHT_LOAD, -EMT.HB, EMT.HB)))
|
|
local dZ2 = -Head2Z + MillOffs - Mill2Offs + EMT.L3
|
|
if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
|
|
dZ2 = MaxZ2
|
|
end
|
|
dZ2 = min( dZ2, MaxZ2)
|
|
local dC2 = -EMT.R1
|
|
local dB2 = -EMT.R2
|
|
if EMT.ZMAX then
|
|
local dSafeZ2 = EgtGetAxisHomePos( 'Z2')
|
|
EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
|
|
EmitMoveDataHead( 2, { X=dX2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
|
|
end
|
|
EmitMoveDataHead( 2, { X=dX2, Z=dZ2, B=dB2, C=dC2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
|
|
EmitMoveStartHead( 2)
|
|
-- aspetto esecuzione movimento testa 2
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
-- aspetto esecuzione movimento testa 1
|
|
EmitMoveWaitHead( 1)
|
|
-- altrimenti testa 2
|
|
else
|
|
if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC2' then
|
|
-- movimento testa
|
|
local dSafeZ1 = EgtGetAxisHomePos( 'Z1')
|
|
local MyMaxZ1 = EgtGetAxisMax( 'Z1')
|
|
local HomeC1 = EgtGetAxisHomePos( 'C1')
|
|
local HomeB1 = EgtGetAxisHomePos( 'B1')
|
|
local dTRad, dTLen = GetToolRadLen()
|
|
local Speed = EMT.S * EgtIf( EMT.HEAD ~= 'H12' and EMT.HEAD ~= 'H22', 1, 1.65)
|
|
if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
local CurrZ1 = EMT.L3pp or MyMaxZ1
|
|
local CurrB1 = PrevR2
|
|
local CurrC1 = PrevR1
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
local dZref = EMT.L3
|
|
if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then
|
|
dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
|
|
end
|
|
-- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
|
|
if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
|
|
EmitMoveDataHead( 1, { B=0, S=Speed})
|
|
EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
|
|
-- altrimenti caso standard
|
|
else
|
|
EmitMoveDataHead( 1, { Z=dZref, S=Speed})
|
|
EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
|
|
EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
|
|
end
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 1, { X=-ParkCSawX1, Z=ParkCSawZ1, B=ParkCSawB1, C=ParkCSawC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
-- se motosega configurata per lavorazioni di fianco o circa orizzontale
|
|
if dPosA == 0 or abs( EMT.R2) < 10 then
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
-- se circa verticale
|
|
else
|
|
EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
end
|
|
end
|
|
end
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
-- aspetto esecuzione movimento testa 1
|
|
EmitMoveWaitHead( 1)
|
|
else
|
|
-- movimento testa
|
|
local dSafeZ2 = EgtGetAxisHomePos( 'Z2')
|
|
local MyMaxZ2 = EgtGetAxisMax( 'Z2')
|
|
local HomeC2 = EgtGetAxisHomePos( 'C2')
|
|
local HomeB2 = EgtGetAxisHomePos( 'B2')
|
|
local dTRad, dTLen = GetToolRadLen()
|
|
local Speed = EMT.S * EgtIf( EMT.HEAD ~= 'H12' and EMT.HEAD ~= 'H22', 1, 1.65)
|
|
if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
local CurrZ2 = EMT.L3pp or MyMaxZ2
|
|
local CurrB2 = PrevR2
|
|
local CurrC2 = PrevR1
|
|
EmitMoveDataHead( 2, { X=EMT.L2, Z=CurrZ2, B=CurrB2, C=CurrC2, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
local dZref = EMT.L3
|
|
if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX2RotSaw, EMT.L2 > -LimX2RotSaw) or EMT.R2 > 91) then
|
|
dZref = min( dSafeZ2 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ2)
|
|
end
|
|
-- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
|
|
if EMT.HEAD == 'H22' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC2 - EMT.R1) > 30.1 or abs( HomeB2 - EMT.R2) > 30.1) then
|
|
EmitMoveDataHead( 2, { B=0, S=Speed})
|
|
EmitMoveDataHead( 2, { C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 2, { Z=dZref, B=EMT.R2, S=Speed})
|
|
-- altrimenti caso standard
|
|
else
|
|
EmitMoveDataHead( 2, { Z=dZref, S=Speed})
|
|
EmitMoveDataHead( 2, { B=EMT.R2, S=Speed})
|
|
EmitMoveDataHead( 2, { C=EMT.R1, S=Speed})
|
|
end
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 2, { X=-ParkCSawX1, Z=ParkCSawZ1, B=ParkCSawB1, C=ParkCSawC1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
-- se motosega configurata per lavorazioni di fianco o circa orizzontale
|
|
if dPosA == 0 or abs( EMT.R2) < 10 then
|
|
EmitMoveDataHead( 2, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 2, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
-- se circa verticale
|
|
else
|
|
EmitMoveDataHead( 2, { X=EMT.L2, C=EMT.R1, S=Speed})
|
|
EmitMoveDataHead( 2, { Z=EMT.L3, B=EMT.R2, S=Speed})
|
|
end
|
|
end
|
|
end
|
|
EmitMoveDataHead( 2, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=Speed})
|
|
EmitMoveStartHead( 2)
|
|
-- aspetto esecuzione movimento testa 2
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
end
|
|
local BhData = { T=EMT.L1}
|
|
if EMT.Y1DELTA then
|
|
BhData.Y1 = EMT.L1 + EMT.Y1DELTA - ( EMT.X_OFF or 0)
|
|
BhData.ViseY1 = 1
|
|
else
|
|
BhData.Y1 = EgtIf( EMT.Y1POS, EMT.Y1POS, ParkY1)
|
|
BhData.ViseY1 = 2
|
|
end
|
|
if EMT.MCHSPLIT and EMT.Y2DELTA then
|
|
BhData.ViseY1 = 3
|
|
end
|
|
if EMT.Y2DELTA then
|
|
BhData.Y2 = EMT.L1 + EMT.Y2DELTA - ( EMT.X_OFF or 0)
|
|
BhData.ViseY2 = 1
|
|
else
|
|
BhData.Y2 = ParkY2
|
|
BhData.ViseY2 = 2
|
|
end
|
|
if GetV1ToCloseNum() then
|
|
BhData.FinStatV1 = -3
|
|
EMT.V1POS = EMT.V1NEXTPOS
|
|
BhData.V1 = EMT.V1POS
|
|
elseif abs( EMT.V1POS - ParkV1) > 0.1 then
|
|
BhData.IniStatV1 = 3
|
|
EMT.V1POS = ParkV1
|
|
BhData.V1 = EMT.V1POS
|
|
end
|
|
if GetV2ToCloseNum() then
|
|
BhData.FinStatV2 = -3
|
|
EMT.V2POS = EMT.V2NEXTPOS
|
|
BhData.V2 = EMT.V2POS
|
|
elseif abs( EMT.V2POS - ParkV2) > 0.1 or EMT.W2DELTA then
|
|
BhData.IniStatV2 = 3
|
|
EMT.V2POS = ParkV2
|
|
BhData.V2 = EMT.V2POS
|
|
end
|
|
if EMT.W2DELTA then
|
|
if EMT.TO_SPECSPLIT then
|
|
BhData.W = EMT.L1 + EMT.W2DELTA
|
|
else
|
|
BhData.Pz5 = 1
|
|
end
|
|
end
|
|
EmitBeamHeadData( BhData)
|
|
EMT.POSTROT = false
|
|
EMT.RELOAD = false
|
|
EMT.RELOAD2 = nil
|
|
end
|
|
-- se taglio di coda senza residuo da scaricare, emetto M175 per accelerare il carico della barra successiva
|
|
if EMT.MCHUSERNOTES and EMT.MCHUSERNOTES:find( 'Cut', 1, true) then
|
|
EmtOutput( 'M175')
|
|
end
|
|
EMT.REFLOC = 0
|
|
EMT.MCHFIRST = false
|
|
EMT.ZMAX = false
|
|
-- se standard
|
|
elseif EMT.FLAG == 0 or EMT.FLAG == 1 or EMT.FLAG == 2 then
|
|
local sPostMove = ''
|
|
if EMT.MCHFIRST then
|
|
local sOut = string.gsub( string.gsub( EMT.MCHNAME..'/'..EMT.TOOL, '%(', '['), '%)', ']')
|
|
if EMT.DOU_TYPE then sOut = sOut .. ' Double' end
|
|
EmtOutput( '( *** '..sOut..' *** )')
|
|
-- gestione comandi rulli
|
|
local sPreMove = ''
|
|
if GetV1ToCloseNum( true) then
|
|
sPostMove = ' EC-3'
|
|
else
|
|
sPreMove = ' EC3'
|
|
end
|
|
if GetV2ToCloseNum( true) then
|
|
sPostMove = sPostMove .. ' ED-3'
|
|
else
|
|
sPreMove = sPreMove .. ' ED3'
|
|
end
|
|
-- comandi rulli prima di movimento (aperture)
|
|
if #sPreMove > 0 then
|
|
EmtOutput( 'G157 EA2' .. sPreMove)
|
|
end
|
|
-- se taglio di coda senza residuo da scaricare, emetto M175 per accelerare il carico della barra successiva
|
|
if EMT.MCHUSERNOTES and EMT.MCHUSERNOTES:find( 'Cut', 1, true) then
|
|
EmtOutput( 'M175')
|
|
end
|
|
EMT.MCHFIRST = false
|
|
end
|
|
-- se necessario, impostazione riferimento locale
|
|
if EMT.REFLOC == 0 then
|
|
-- se lavorazione in doppio
|
|
if EMT.DOU_TYPE == 2 then
|
|
-- aggiusto assi
|
|
EMT.L2 = -EMT.L2
|
|
-- emetto movimenti in Zero macchina
|
|
local Speed = EMT.S * EgtIf( EMT.HEAD ~= 'H12', 1, 1.65)
|
|
EmitMoveDataHead( 1, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, S=Speed})
|
|
EmitMoveStartHead( 1)
|
|
local dX2 = - ( Delta2TabY - EMT.DOU_TLEN - ( -DeltaTabY - EMT.L2 - EMT.TLEN + EgtIf( BD.RIGHT_LOAD, -EMT.HB, EMT.HB)))
|
|
local dZ2 = -Head2Z + MillOffs - Mill2Offs + EMT.L3
|
|
local dC2 = -EMT.R1
|
|
local dB2 = -EMT.R2
|
|
EmitMoveDataHead( 2, { X=dX2, Z=dZ2, B=dB2, C=dC2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
|
|
EmitMoveStartHead( 2)
|
|
-- aspetto esecuzione movimento testa 2 e 1
|
|
EmitMoveWaitHead( 2)
|
|
EmitMoveWaitHead( 1)
|
|
-- ripristino assi
|
|
EMT.L2 = -EMT.L2
|
|
end
|
|
-- calcolo per piano generico
|
|
CalcInterpPlane()
|
|
EMT.REFLOC = 1
|
|
-- trasformo i punti nel piano
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
EMT.L1p = nil
|
|
EMT.L2p = nil
|
|
EMT.L3p = nil
|
|
local sDouFlag = EgtIf( EMT.DOU_TYPE, ' EE1', '')
|
|
EmtOutput( 'G142'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..EMT.IPLGLSTR..EgtIf( nHSet~=2, ' EU1', ' EU2')..sDouFlag..' EF'..GetFmaxClamp())
|
|
-- forzo successiva emissione assi rotanti
|
|
EMT.R1p = nil
|
|
EMT.R2p = nil
|
|
else
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
end
|
|
-- emissione movimento
|
|
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
|
EmtGetAxis('R2')..EmtGetAxis('R1')
|
|
-- comandi rulli dopo movimento (chiusure)
|
|
EmtOutput( sOut)
|
|
if #sPostMove > 0 then
|
|
EmtOutput( 'G157 EA2' .. sPostMove)
|
|
end
|
|
-- se altrimenti risalita a Z max a fine lavorazione
|
|
elseif EMT.FLAG == 3 then
|
|
EMT.REFLOC = nil
|
|
EMT.IPLGL = false
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
-- se Split o Presplit lascio agganciata solo la pinza Y2 alla fine dei movimenti
|
|
local sNextTool = GetNextTool( EMT.MCHID)
|
|
-- vado in home se è ultimo movimento ed è ultima lavorazione, se sono con motosega e devo cambiare utensile, oppure se ho la lama
|
|
local bToXhome = ( IsLastPath( EMT.PATHID) and not sNextTool) or ( EMT.HEAD == 'H23' and EMT.TOOL ~= sNextTool) or ( EMT.HEAD == 'H13' and EMT.TOOL ~= sNextTool) or EMT.HEAD == 'H12' or EMT.HEAD == 'H22'
|
|
local CurrL3o = EMT.L3o
|
|
EMT.L3o = EMT.L3op
|
|
EmitZmax( true, true, bToXhome, EMT.R1p, EMT.R2p, EMT.MCHSPLIT)
|
|
EMT.L3o = CurrL3o
|
|
-- aggiorno quota finale trave dopo Zmax
|
|
EMT.L1o = EMT.TPOS
|
|
EMT.ZMAX = true
|
|
-- se altrimenti movimento in Home
|
|
elseif EMT.FLAG == 4 then
|
|
-- non previsto
|
|
-- altrimenti errore
|
|
else
|
|
error( "Unknown Rapid flag")
|
|
end
|
|
-- aggiorno valori come precedenti
|
|
EMT.TPOS = EMT.L1o
|
|
EmtUpdatePrev()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnLinear()
|
|
-- se necessario, impostazione riferimento locale
|
|
if EMT.REFLOC == 0 then
|
|
-- gruppo della testa
|
|
local nHSet = GetHeadSet( EMT.HEAD)
|
|
-- 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
|
|
local sDouFlag = EgtIf( EMT.DOU_TYPE, ' EE1', '')
|
|
EmtOutput( 'G142'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..EMT.IPLGLSTR..EgtIf( nHSet~=2, ' EU1', ' EU2')..sDouFlag..' EF'..GetFmaxClamp())
|
|
-- emissione movimento
|
|
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
|
EmtGetAxis('R2')..EmtGetAxis('R1')
|
|
EmtOutput( sOut)
|
|
-- aggiorno precedenti
|
|
EMT.MOVE = 0
|
|
EmtUpdatePrev()
|
|
EMT.MOVE = 1
|
|
-- ripristino posizione attuale
|
|
EMT.L1 = OldL1
|
|
EMT.L2 = OldL2
|
|
EMT.L3 = OldL3
|
|
end
|
|
|
|
-- aggiustamento valori
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
|
|
-- se lavorazione in doppio e fondo foro, inverto movimento punta doppia
|
|
local bDouHoleBott = ( EMT.MCHTYPE == MCH_MY.DRILLING and EMT.DOU_TYPE == 2 and EMT.FLAG == 101)
|
|
if bDouHoleBott then
|
|
EmtOutput( "G157 EE-1")
|
|
end
|
|
|
|
-- valori degli assi
|
|
local sL1, bL1 = EmtGetAxis( 'L1')
|
|
local sL2, bL2 = EmtGetAxis( 'L2')
|
|
local sL3, bL3 = EmtGetAxis( 'L3')
|
|
local sR1, bR1 = EmtGetAxis( 'R1')
|
|
local sR2, bR2 = EmtGetAxis( 'R2')
|
|
local sAxes = sL1 .. sL2 .. sL3 .. sR2 .. sR1
|
|
-- se nulla da emettere, esco
|
|
if #sAxes == 0 then return end
|
|
-- arresto preciso in angoli di fresature per utensili (non penne) di piccolo diametro
|
|
local sSlowDown = ''
|
|
if EMT.MCHTYPE == MCH_MY.MILLING and EMT.TTOTDIAM < 15 and abs( EMT.S) > 1000 and ( bL1 or bL2) and not bL3 then
|
|
sSlowDown = ' G9'
|
|
end
|
|
-- aggiungo feed
|
|
local sFeed = EmtGetFeed()
|
|
-- emetto linea
|
|
EmtOutput( "G1"..sSlowDown..sAxes..sFeed)
|
|
|
|
-- se lavorazione in doppio e fondo foro, muovo punta 2 e poi ripristino movimento standard punta doppia
|
|
if bDouHoleBott then
|
|
if EMT.DOU_TYPE == 2 or EMT.DOU_TYPE == 3 then
|
|
local dZ = 2 * EMT.L3p - EMT.L3
|
|
EmtOutput( "G1 Z" .. EgtNumToString( dZ, 3))
|
|
EmtOutput( "G1 Z" .. EgtNumToString( EMT.L3p, 3))
|
|
end
|
|
EmtOutput( "G157 EE1")
|
|
end
|
|
|
|
-- aggiorno valori come precedenti
|
|
EMT.TPOS = EMT.L1o
|
|
EmtUpdatePrev()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnArc()
|
|
-- non modale su archi
|
|
EmtResetPrevLinear()
|
|
-- aggiustamento valori
|
|
MyAdjustLinearAxes()
|
|
EmtAdjustRotaryAxes()
|
|
|
|
-- valori degli assi
|
|
local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
|
EmtGetAxis('R1')..EmtGetAxis('R2')
|
|
-- 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)
|
|
-- emetto arco
|
|
EmtOutput( sArc..sAxes..sRad..sFeed)
|
|
|
|
-- aggiorno valori come precedenti
|
|
EMT.TPOS = EMT.L1o
|
|
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
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function CalcCharStatusN( sCmd)
|
|
-- aperto
|
|
if sCmd == '0' then
|
|
return 1
|
|
-- chiuso
|
|
elseif sCmd == '1' then
|
|
return -1
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareLoad( sCmd, nInd, bStart)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio
|
|
if nInd == 1 then
|
|
-- imposto stato pinze
|
|
EMT.ISY1 = 1
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.ISY2 = 1
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = 0
|
|
end
|
|
-- se dichiarazione inizio riposizionamento carrelli
|
|
if Cmd[2] == 'CARR_MOVE' then
|
|
if bStart then
|
|
EMT.RELOAD = false
|
|
else
|
|
EMT.RELOAD2 = true
|
|
end
|
|
table.insert( EMT.MDCHAR, { Start=1})
|
|
table.insert( EMT.MDCHAR, { Wait=1})
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
if Cmd[2] ~= 'Z' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
local MoveY1 = GetCmdAxMove( Cmd, 'Y1')
|
|
local MoveY2 = GetCmdAxMove( Cmd, 'Y2')
|
|
if MoveY1 then MDChar.Y1 = MoveY1 end
|
|
if MoveY2 then MDChar.Y2 = MoveY2 end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.Y1POS = MoveY1 or EMT.Y1POS
|
|
EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
-- se in riposizionamento carrelli
|
|
if #EMT.MDCHAR > 0 and EMT.MDCHAR[1].MovType == 3 then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
local MoveY1 = GetCmdAxMove( Cmd, 'Y1')
|
|
local MoveY2 = GetCmdAxMove( Cmd, 'Y2')
|
|
if MoveY1 then MDChar.Y1 = MoveY1 end
|
|
if MoveY2 then MDChar.Y2 = MoveY2 end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
elseif Cmd[2] == 'Y1' then
|
|
local sBeamRot = '0'
|
|
local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or EgtGetCurrMachGroup() or GDB_ID.NULL
|
|
local nLoad90 = EgtGetInfo( BtlInfoId, 'LOAD90', 'i') or 0
|
|
sBeamRot = tostring( nLoad90) or '0'
|
|
local sAux = ' EL'..sBeamRot
|
|
-- local sAux = ' (E80057='..sBeamRot..' E80058=0)' vecchio comando utilizzato su ONE
|
|
local MoveY1 = tonumber( Cmd[3]) + TurnerOffs
|
|
local MDChar = { Y1=MoveY1, V1=ParkV1, IniStatY1=75, FinStatY1=-1, BeamVise=0, MovType=1, Aux=sAux}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.V1POS = ParkV1
|
|
elseif Cmd[2] == 'T' then
|
|
local MDChar = { Y1=tonumber(Cmd[3]), IniStatY1=76, FinStatY1=EMT.FSY1, BeamVise=0, MovType=1}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
end
|
|
EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
|
|
elseif Cmd[1] == '3' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
local MoveY1 = GetCmdAxMove( Cmd, 'Y1')
|
|
local MoveY2 = GetCmdAxMove( Cmd, 'Y2')
|
|
if MoveY1 then MDChar.Y1 = MoveY1 end
|
|
if MoveY2 then MDChar.Y2 = MoveY2 end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
|
|
elseif Cmd[1] == '4' then
|
|
-- richiesta movimento a ZMAX già gestita
|
|
if Cmd[2] == '1' then
|
|
EMT.ROLL_IN = true
|
|
end
|
|
elseif Cmd[1] == '11' then
|
|
EMT.ISY1 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 1, 2)
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY1 = EMT.FSY1 end
|
|
elseif Cmd[1] == '12' then
|
|
EMT.ISY2 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 2, 1)
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY2 = EMT.FSY2 end
|
|
elseif Cmd[1] == '21' then
|
|
EMT.Y1PREVDELTA = EMT.Y1DELTA
|
|
EMT.Y2PREVDELTA = EMT.Y2DELTA
|
|
local nY1Delta = tonumber( Cmd[2])
|
|
local nY2Delta = tonumber( Cmd[3])
|
|
if nY1Delta > 0 and nY2Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nY2Delta
|
|
elseif nY1Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nil
|
|
elseif nY2Delta > 0 then
|
|
EMT.Y1DELTA = nil
|
|
EMT.Y2DELTA = nY2Delta
|
|
end
|
|
if not FindReadHeadWithLaser( EMT.MDCHAR) then
|
|
local MDChar = { Y1=LoadT, IniStatY1=76, FinStatY1=EMT.FSY1, FinStatV1=-1, BeamVise=0, MovType=1}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
end
|
|
elseif Cmd[1] == '22' then
|
|
EMT.V1NEXTPOS = tonumber( Cmd[2])
|
|
EMT.V2NEXTPOS = tonumber( Cmd[3])
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareMoveChar( sCmd, nInd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio
|
|
if nInd == 1 then
|
|
-- imposto stato pinze
|
|
EMT.ISY1 = EgtIf( EMT.Y1DELTA, -1, 1)
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.ISY2 = EgtIf( EMT.Y2DELTA, -1, 1)
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = EgtIf( EMT.Y1DELTA, 1, 2)
|
|
EMT.ROLL_IN = nil
|
|
EMT.ROLL_OPEN = true
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
if Cmd[2] ~= 'Z' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
local MoveY1 = GetCmdAxMove( Cmd, 'Y1')
|
|
local MoveY2 = GetCmdAxMove( Cmd, 'Y2')
|
|
if MoveY1 then MDChar.Y1 = MoveY1 end
|
|
if MoveY2 then MDChar.Y2 = MoveY2 end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
else
|
|
local MinDeltaY1V1 = MinDeltaYV + EgtIf( ( Cmd and #Cmd > 0 and Cmd[#Cmd] == '*'), AggLoad, 0)
|
|
if MoveY1 and EMT.V1POS > MoveY1 - MinDeltaY1V1 - 0.1 then
|
|
MDChar.V1 = min( MoveY1 - MinDeltaY1V1, ParkV1) ; EMT.V1POS = MDChar.V1
|
|
end
|
|
if MoveY2 and EMT.V2POS < MoveY2 + MinDeltaYV + 0.1 then
|
|
MDChar.V2 = max( MoveY2 + MinDeltaYV, ParkV2) ; EMT.V2POS = MDChar.V2
|
|
end
|
|
end
|
|
if EMT.ROLL_OPEN then
|
|
MDChar.IniStatV1 = 3 ; MDChar.FinStatV1 = 3
|
|
MDChar.IniStatV2 = 3 ; MDChar.FinStatV2 = 3
|
|
EMT.ROLL_OPEN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.Y1POS = MoveY1 or EMT.Y1POS
|
|
EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
local MoveY1 = GetCmdAxMove( Cmd, 'Y1')
|
|
local MoveY2 = GetCmdAxMove( Cmd, 'Y2')
|
|
if MoveY1 then MDChar.Y1 = MoveY1 end
|
|
if MoveY2 then MDChar.Y2 = MoveY2 end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
else
|
|
local MinDeltaY1V1 = MinDeltaYV + EgtIf( ( Cmd and #Cmd > 0 and Cmd[#Cmd] == '*'), AggLoad, 0)
|
|
if MoveY1 and EMT.V1POS > MoveY1 - MinDeltaY1V1 - 0.1 then
|
|
MDChar.V1 = min( MoveY1 - MinDeltaY1V1, ParkV1) ; EMT.V1POS = MDChar.V1
|
|
end
|
|
if MoveY2 and EMT.V2POS < MoveY2 + MinDeltaYV + 0.1 then
|
|
MDChar.V2 = max( MoveY2 + MinDeltaYV, ParkV2) ; EMT.V2POS = MDChar.V2
|
|
end
|
|
end
|
|
if EMT.ROLL_OPEN then
|
|
MDChar.IniStatV1 = 3 ; MDChar.FinStatV1 = 3
|
|
MDChar.IniStatV2 = 3 ; MDChar.FinStatV2 = 3
|
|
EMT.ROLL_OPEN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
|
|
elseif Cmd[1] == '3' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
local MoveY1 = GetCmdAxMove( Cmd, 'Y1')
|
|
local MoveY2 = GetCmdAxMove( Cmd, 'Y2')
|
|
if MoveY1 then MDChar.Y1 = MoveY1 end
|
|
if MoveY2 then MDChar.Y2 = MoveY2 end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
else
|
|
local MinDeltaY1V1 = MinDeltaYV + EgtIf( ( Cmd and #Cmd > 0 and Cmd[#Cmd] == '*'), AggLoad, 0)
|
|
if MoveY1 and EMT.V1POS > MoveY1 - MinDeltaY1V1 - 0.1 then
|
|
MDChar.V1 = min( MoveY1 - MinDeltaY1V1, ParkV1) ; EMT.V1POS = MDChar.V1
|
|
end
|
|
if MoveY2 and EMT.V2POS < MoveY2 + MinDeltaYV + 0.1 then
|
|
MDChar.V2 = max( MoveY2 + MinDeltaYV, ParkV2) ; EMT.V2POS = MDChar.V2
|
|
end
|
|
end
|
|
if EMT.ROLL_OPEN then
|
|
MDChar.IniStatV1 = 3 ; MDChar.FinStatV1 = 3
|
|
MDChar.IniStatV2 = 3 ; MDChar.FinStatV2 = 3
|
|
EMT.ROLL_OPEN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
|
|
elseif Cmd[1] == '4' then
|
|
-- richiesta movimento a ZMAX già gestita
|
|
if Cmd[2] == '1' then
|
|
EMT.ROLL_IN = true
|
|
end
|
|
elseif Cmd[1] == '11' then
|
|
EMT.ISY1 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY1 = EMT.ISY1
|
|
-- se pinza due in presa, non attivo la 1
|
|
if EMT.BV ~= 2 then
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 1, 2)
|
|
end
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY1 = EMT.FSY1 end
|
|
elseif Cmd[1] == '12' then
|
|
EMT.ISY2 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 2, 1)
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY2 = EMT.FSY2 end
|
|
elseif Cmd[1] == '21' then
|
|
EMT.Y1PREVDELTA = EMT.Y1DELTA
|
|
EMT.Y2PREVDELTA = EMT.Y2DELTA
|
|
local nY1Delta = tonumber( Cmd[2])
|
|
local nY2Delta = tonumber( Cmd[3])
|
|
if nY1Delta > 0 and nY2Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nY2Delta
|
|
elseif nY1Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nil
|
|
elseif nY2Delta > 0 then
|
|
EMT.Y1DELTA = nil
|
|
EMT.Y2DELTA = nY2Delta
|
|
end
|
|
elseif Cmd[1] == '22' then
|
|
EMT.V1NEXTPOS = tonumber( Cmd[2])
|
|
EMT.V2NEXTPOS = tonumber( Cmd[3])
|
|
elseif Cmd[1] == '23' then
|
|
EMT.W2DELTA = tonumber( Cmd[2])
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareResidue( sCmd, nInd)
|
|
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 nInd <= 2 then
|
|
EMT.ISY1 = EgtIf( EMT.Y1DELTA, -1, 1)
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.ISY2 = EgtIf( EMT.Y2DELTA, -1, 1)
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = EgtIf( EMT.Y1DELTA, 1, 2)
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
else
|
|
EMT.UNL = true
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
if Cmd[2] ~= 'Z' then
|
|
local MDChar
|
|
if not EMT.UNL then
|
|
MDChar = { [Cmd[2]]=tonumber(Cmd[3]), IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
else
|
|
MDChar = { [Cmd[2]]=tonumber(Cmd[3]), IniStatY2=2, FinStatY2=85, BeamVise=0}
|
|
end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
elseif EMT.UNL then
|
|
MDChar.V1 = ParkV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = ParkV2 ; EMT.V2POS = MDChar.V2
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, IniStatV2=3, BeamVise=EMT.BV}
|
|
if Cmd[2] ~= 'T' then MDChar[Cmd[2]] = tonumber( Cmd[3]) end
|
|
if Cmd[4] ~= 'T' then MDChar[Cmd[4]] = tonumber( Cmd[5]) end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
elseif Cmd[1] == '3' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, IniStatV1=3, IniStatV2=3, BeamVise=EMT.BV}
|
|
if Cmd[2] ~= 'T' then MDChar[Cmd[2]] = tonumber( Cmd[3]) end
|
|
if Cmd[4] ~= 'T' then MDChar[Cmd[4]] = tonumber( Cmd[5]) end
|
|
if Cmd[6] ~= 'T' then MDChar[Cmd[6]] = tonumber( Cmd[7]) end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1POS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2POS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
elseif Cmd[1] == '4' then
|
|
EMT.TO_ZMAX = true
|
|
if Cmd[2] == '1' then
|
|
EMT.TO_XHOME = true
|
|
EMT.ROLL_IN = true
|
|
end
|
|
elseif Cmd[1] == '11' then
|
|
EMT.ISY1 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 1, 2)
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY1 = EMT.FSY1 end
|
|
elseif Cmd[1] == '12' then
|
|
EMT.ISY2 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 2, 1)
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY2 = EMT.FSY2 end
|
|
elseif Cmd[1] == '21' then
|
|
EMT.Y1PREVDELTA = EMT.Y1DELTA
|
|
EMT.Y2PREVDELTA = EMT.Y2DELTA
|
|
local nY1Delta = tonumber( Cmd[2])
|
|
local nY2Delta = tonumber( Cmd[3])
|
|
if nY1Delta > 0 and nY2Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nY2Delta
|
|
elseif nY1Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nil
|
|
elseif nY2Delta > 0 then
|
|
EMT.Y1DELTA = nil
|
|
EMT.Y2DELTA = nY2Delta
|
|
end
|
|
elseif Cmd[1] == '22' then
|
|
EMT.V1NEXTPOS = tonumber( Cmd[2])
|
|
EMT.V2NEXTPOS = tonumber( Cmd[3])
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareSplit( sCmd, nInd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '1' then
|
|
if Cmd[2] == 'Y1' then
|
|
local MDChar = { Y1=tonumber(Cmd[3]), V1=ParkV1, IniStatY1=-1, IniStatY2=-1, IniStatV1=3, BeamVise=2, MovType=1}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.Y1POS = tonumber( Cmd[3])
|
|
EMT.V1POS = ParkV1
|
|
end
|
|
elseif Cmd[1] == '21' then
|
|
EMT.Y1PREVDELTA = EMT.Y1DELTA
|
|
EMT.Y2PREVDELTA = EMT.Y2DELTA
|
|
local nY1Delta = tonumber( Cmd[2])
|
|
local nY2Delta = tonumber( Cmd[3])
|
|
if nY1Delta > 0 and nY2Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nY2Delta
|
|
elseif nY1Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nil
|
|
elseif nY2Delta > 0 then
|
|
EMT.Y1DELTA = nil
|
|
EMT.Y2DELTA = nY2Delta
|
|
end
|
|
elseif Cmd[1] == '22' then
|
|
EMT.V1NEXTPOS = tonumber( Cmd[2])
|
|
EMT.V2NEXTPOS = tonumber( Cmd[3])
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PrepareUnload( sCmd, nInd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '1' then
|
|
if Cmd[2] == 'Y2' then
|
|
-- se non è ultima fase c'è una barra sulla pinza Y (1)
|
|
local bBarOnY = ( EMT.PHASE < EgtGetPhaseCount() and not IsEnd2Phase( EMT.PHASE))
|
|
local MDChar = { Y2=tonumber(Cmd[3]), IniStatY2=2, FinStatY2=85, BeamVise=EgtIf( bBarOnY, 1, 0), MovType=EgtIf( EMT.CHY_ON, 3, 2)}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
if Cmd[4] == 'Y2' then
|
|
-- se non è ultima fase c'è una barra sulla pinza Y (1)
|
|
local bBarOnY = ( EMT.PHASE < EgtGetPhaseCount() and not IsEnd2Phase( EMT.PHASE))
|
|
local nISY1 = EgtIf( bBarOnY, -1, 1)
|
|
local MDChar = { Y2=tonumber(Cmd[5]), V2=ParkV2, IniStatY1=nISY1, FinStatY1=nISY1, IniStatY2=-1, FinStatY2=1, IniStatV2=3, BeamVise=2, MovType=EgtIf( EMT.CHY_ON, 3, 2)}
|
|
EMT.V2NEXTPOS = ParkV2
|
|
-- se ultimo pezzo e mossa anche Y1, devo garantire parcheggio di V1 (per barra successiva)
|
|
if EMT.PHASE == EgtGetPhaseCount() and EMT.CHY_ON then
|
|
MDChar.V1 = ParkV1
|
|
EMT.V1NEXTPOS = ParkV1
|
|
else
|
|
EMT.V1NEXTPOS = EMT.V1POS
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
end
|
|
elseif Cmd[1] == '3' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '4' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '11' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '12' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '21' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '22' then
|
|
-- non interessa ??
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PreparePreRotation( sCmd, nInd)
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio o subito dopo, imposto stato iniziale pinze
|
|
if nInd <= 2 then
|
|
EMT.ISY1 = EgtIf( EMT.Y1DELTA, -1, 1)
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.ISY2 = EgtIf( EMT.Y2DELTA, -1, 1)
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = EgtIf( EMT.Y1DELTA and not EMT.SPECSPLIT, 1, 2)
|
|
EMT.ROLL_IN = nil
|
|
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
|
|
if Cmd[2] ~= 'Z' then
|
|
local MDChar
|
|
if EMT.PREROT then
|
|
MDChar = { [Cmd[2]]=tonumber(Cmd[3]), IniStatY1=86, FinStatY1=87, IniStatY2=1, BeamVise=0}
|
|
elseif EMT.SPECSPLIT then
|
|
MDChar = { [Cmd[2]]=tonumber(Cmd[3]), V1=ParkV1, IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, IniStatV1=3, BeamVise=EMT.BV}
|
|
EMT.V1POS = MDChar.V1
|
|
else
|
|
MDChar = { [Cmd[2]]=tonumber(Cmd[3]), IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1NEXTPOS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2NEXTPOS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
end
|
|
elseif Cmd[1] == '2' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
if Cmd[2] ~= 'T' then MDChar[Cmd[2]] = tonumber( Cmd[3]) end
|
|
if Cmd[4] ~= 'T' then MDChar[Cmd[4]] = tonumber( Cmd[5]) end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1NEXTPOS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2NEXTPOS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
elseif Cmd[1] == '3' then
|
|
local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
|
|
if Cmd[2] ~= 'T' then MDChar[Cmd[2]] = tonumber( Cmd[3]) end
|
|
if Cmd[4] ~= 'T' then MDChar[Cmd[4]] = tonumber( Cmd[5]) end
|
|
if Cmd[6] ~= 'T' then MDChar[Cmd[6]] = tonumber( Cmd[7]) end
|
|
if EMT.ROLL_IN then
|
|
MDChar.V1 = MinV1 ; EMT.V1NEXTPOS = MDChar.V1
|
|
MDChar.V2 = MaxV2 ; EMT.V2NEXTPOS = MDChar.V2
|
|
EMT.ROLL_IN = nil
|
|
end
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
elseif Cmd[1] == '4' then
|
|
EMT.TO_ZMAX = true
|
|
if Cmd[2] == '1' then
|
|
EMT.TO_XHOME = true
|
|
EMT.ROLL_IN = true
|
|
end
|
|
elseif Cmd[1] == '11' then
|
|
if EMT.SPLITROT then
|
|
EMT.ISY1 = EgtIf( Cmd[2] ~= '0', CalcCharStatusN( Cmd[2]), 86)
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 1, 2)
|
|
else
|
|
EMT.ISY1 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY1 = EMT.ISY1
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 1, 2)
|
|
end
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY1 = CalcCharStatusN( Cmd[2]) end
|
|
elseif Cmd[1] == '12' then
|
|
EMT.ISY2 = CalcCharStatusN( Cmd[2])
|
|
EMT.FSY2 = EMT.ISY2
|
|
EMT.BV = EgtIf( Cmd[2] ~= '0', 2, 1)
|
|
if #EMT.MDCHAR > 0 then EMT.MDCHAR[#EMT.MDCHAR].FinStatY2 = EMT.FSY2 end
|
|
elseif Cmd[1] == '21' then
|
|
local nY1Delta = tonumber( Cmd[2])
|
|
local nY2Delta = tonumber( Cmd[3])
|
|
EMT.Y1PREVDELTA = EMT.Y1DELTA
|
|
EMT.Y2PREVDELTA = EMT.Y2DELTA
|
|
if nY1Delta > 0 and nY2Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nY2Delta
|
|
elseif nY1Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nil
|
|
elseif nY2Delta > 0 then
|
|
EMT.Y1DELTA = nil
|
|
EMT.Y2DELTA = nY2Delta
|
|
end
|
|
elseif Cmd[1] == '22' then
|
|
EMT.V1NEXTPOS = tonumber( Cmd[2])
|
|
EMT.V2NEXTPOS = tonumber( Cmd[3])
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PreparePostRotation( sCmd, nInd)
|
|
-- è sostanzialmente un carico
|
|
local Cmd = EgtSplitString( sCmd)
|
|
if Cmd[1] == '0' then
|
|
-- se inizio
|
|
if nInd == 1 then
|
|
-- imposto stato pinze
|
|
EMT.FSY1 = -1
|
|
end
|
|
-- se dichiarazione inizio riposizionamento carrelli
|
|
if Cmd[2] == 'CARR_MOVE' then
|
|
EMT.POSTROT = false
|
|
table.insert( EMT.MDCHAR, { Start=1})
|
|
table.insert( EMT.MDCHAR, { Wait=1})
|
|
end
|
|
elseif Cmd[1] == '1' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '2' then
|
|
if Cmd[2] == 'Y1' then
|
|
-- tolgo eventuale sovramateriale presente sul pezzo in posizione iniziale (la misura laser è ora col finito)
|
|
local MDChar = { Y1=tonumber(Cmd[3])-EMT.HOVM, IniStatY1=75, V1=ParkV1, FinStatY1=-1, BeamVise=0, Aux=' (E80058=0)', MovType=1}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.V1POS = ParkV1
|
|
elseif Cmd[2] == 'T' then
|
|
local MDChar = { Y1=tonumber(Cmd[3]), IniStatY1=76, FinStatY1=EMT.FSY1, BeamVise=0, MovType=1}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.TPOS = tonumber(Cmd[3])
|
|
end
|
|
elseif Cmd[1] == '3' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '11' then
|
|
EMT.FSY1 = CalcCharStatusN( Cmd[2])
|
|
elseif Cmd[1] == '12' then
|
|
-- non interessa
|
|
elseif Cmd[1] == '21' then
|
|
EMT.Y1PREVDELTA = EMT.Y1DELTA
|
|
EMT.Y2PREVDELTA = EMT.Y2DELTA
|
|
local nY1Delta = tonumber( Cmd[2])
|
|
local nY2Delta = tonumber( Cmd[3])
|
|
if nY1Delta > 0 and nY2Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nY2Delta
|
|
elseif nY1Delta > 0 then
|
|
EMT.Y1DELTA = nY1Delta
|
|
EMT.Y2DELTA = nil
|
|
elseif nY2Delta > 0 then
|
|
EMT.Y1DELTA = nil
|
|
EMT.Y2DELTA = nY2Delta
|
|
end
|
|
if not FindReadHeadWithLaser( EMT.MDCHAR) then
|
|
local MDChar = { Y1=LoadT, IniStatY1=76, FinStatY1=EMT.FSY1, BeamVise=0, MovType=1}
|
|
table.insert( EMT.MDCHAR, MDChar)
|
|
EMT.TPOS = LoadT
|
|
end
|
|
elseif Cmd[1] == '22' then
|
|
EMT.V1NEXTPOS = tonumber( Cmd[2])
|
|
EMT.V2NEXTPOS = tonumber( Cmd[3])
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetV1ToCloseNum( UseCurrV1)
|
|
--EmtOutput( string.format( 'L1m=%.3f L1M=%.3f', EMT.MAXMIN[1], EMT.MAXMAX[1]))
|
|
--EmtOutput( string.format( 'LB=%.3f LT=%.3f', EMT.LB, EMT.LT))
|
|
local dV1Pos
|
|
if not UseCurrV1 or UseCurrV1 == false then
|
|
dV1Pos = EMT.V1NEXTPOS
|
|
elseif UseCurrV1 == true then
|
|
dV1Pos = EMT.V1POS
|
|
else
|
|
dV1Pos = UseCurrV1
|
|
end
|
|
return ( ( not EMT.W2DELTA or EMT.TO_SPECSPLIT) and EMT.MAXMAX[1] <= dV1Pos + RollCageMin and EMT.MAXMIN[1] + EMT.LB >= dV1Pos + RollCageMax)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetV2ToCloseNum( UseCurrV2)
|
|
--EmtOutput( string.format( 'L1m=%.3f L1M=%.3f', EMT.MAXMIN[1], EMT.MAXMAX[1]))
|
|
--EmtOutput( string.format( 'LB=%.3f LT=%.3f', EMT.LB, EMT.LT))
|
|
local dV2Pos
|
|
if not UseCurrV2 or UseCurrV2 == false then
|
|
dV2Pos = EMT.V2NEXTPOS
|
|
elseif UseCurrV2 == true then
|
|
dV2Pos = EMT.V2POS
|
|
else
|
|
dV2Pos = UseCurrV2
|
|
end
|
|
return ( not EMT.W2DELTA and EMT.MAXMAX[1] <= dV2Pos - RollCageMax and EMT.MAXMIN[1] + EMT.LB + ( EMT.HOVM or 0) - ( EMT.X_OFF or 0) >= dV2Pos - RollCageMin)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetMovesInAuxCmd( vAuxCmd)
|
|
for i = 1, #( vAuxCmd or {}) do
|
|
local Cmd = EgtSplitString( vAuxCmd[i])
|
|
if Cmd[1] == '1' or Cmd[1] == '2' or Cmd[1] == '3' then
|
|
return true
|
|
elseif Cmd[1] == '22' then
|
|
local dV1NextPos = EgtIf( EMT.Y1DELTA, tonumber( Cmd[2]), ParkV1)
|
|
if not GetV1ToCloseNum( dV1NextPos) then
|
|
dV1NextPos = ParkV1
|
|
end
|
|
local dV2NextPos = tonumber( Cmd[3])
|
|
if not GetV2ToCloseNum( dV2NextPos) then
|
|
dV2NextPos = ParkV2
|
|
end
|
|
if ( abs( dV1NextPos - EMT.V1POS) > 1 or abs( dV2NextPos - EMT.V2POS) > 1) then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetDiffRotAxAtStart( R1, R2)
|
|
local HomeR1 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'C1', 'C2'))
|
|
local PrevR1 = EMT.R1p or EMT.R1pp or HomeR1
|
|
if not R1 or not PrevR1 or abs( R1 - PrevR1) > 0.1 then
|
|
return true
|
|
end
|
|
local HomeR2 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'B1', 'B2'))
|
|
local PrevR2 = EMT.R2p or EMT.R2pp or HomeR2
|
|
if not R2 or not PrevR2 or abs( R2 - PrevR2) > 0.1 then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MyAdjustLinearAxes()
|
|
local MyL1o = EMT.L1
|
|
local MyL2o = EMT.L2
|
|
local MyL3o = EMT.L3
|
|
|
|
if EMT.REFLOC then
|
|
local vtE
|
|
if EMT.HEAD == 'H11' or EMT.HEAD == 'H12' then
|
|
local dAddLen = EgtIf( EMT.HEAD == 'H12', -SawOffsZ, 0)
|
|
local Len = EMT.TLEN + dAddLen + MillOffs
|
|
local LenRef = MillOffs
|
|
vtE = Vector3d( EMT.TDIR) * Len - Z_AX() * LenRef
|
|
elseif EMT.HEAD == 'H21' or EMT.HEAD == 'H22' then
|
|
local dAddLen = EgtIf( EMT.HEAD == 'H22', -Saw2OffsZ, 0)
|
|
local Len = EMT.TLEN + dAddLen + Mill2Offs
|
|
local LenRef = Mill2Offs
|
|
vtE = Vector3d( EMT.TDIR) * Len - Z_AX() * LenRef
|
|
elseif EMT.HEAD == 'H13' then
|
|
local Len = ( EMT.TDIST or ChSawLen) + MillOffs
|
|
local LenRef = MillOffs
|
|
vtE = Vector3d( EMT.ADIR) * Len - Z_AX() * LenRef
|
|
elseif EMT.HEAD == 'H15' or EMT.HEAD == 'H23' then
|
|
local Len = ( EMT.TDIST or ChSawLen) + Mill2Offs
|
|
local LenRef = Mill2Offs
|
|
vtE = Vector3d( EMT.ADIR) * Len - Z_AX() * LenRef
|
|
else
|
|
EmtSetLastError( 1211, 'Head not defined ' .. ( EMT.HEAD or ''))
|
|
end
|
|
if EMT.HEAD == 'H11' or EMT.HEAD == 'H12' or EMT.HEAD == 'H13' or EMT.HEAD == 'H15' then
|
|
EMT.L1 = EMT.L1 - vtE:getX()
|
|
EMT.L2 = EMT.L2 - DeltaTabY - vtE:getY()
|
|
EMT.L3 = EMT.L3 - DeltaTabZ - vtE:getZ()
|
|
else
|
|
EMT.L1 = EMT.L1 - vtE:getX()
|
|
EMT.L2 = EMT.L2 - Delta2TabY - vtE:getY()
|
|
EMT.L3 = EMT.L3 - Delta2TabZ - vtE:getZ()
|
|
end
|
|
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 AdjustTcPos( bLen3, sTcPos, dAxR3)
|
|
if not sTcPos then sTcPos = EMT.TCPOS end
|
|
local sPos = sTcPos:gsub( 'T', '')
|
|
if bLen3 then
|
|
if #sPos == 1 then
|
|
sPos = '00' .. sPos
|
|
elseif #sPos == 2 then
|
|
sPos = '0' .. sPos
|
|
end
|
|
end
|
|
if sPos == '101' then
|
|
if not dAxR3 then dAxR3 = EMT.R3 end
|
|
if abs( dAxR3 - 0) < 0.1 then
|
|
sPos = '101'
|
|
elseif abs( dAxR3 - 90) < 0.1 then
|
|
sPos = '104'
|
|
elseif abs( dAxR3 + 90) < 0.1 then
|
|
sPos = '102'
|
|
else
|
|
EmtSetLastError( 1210, 'Chain saw orientation not allowed')
|
|
end
|
|
elseif sPos == '111' then
|
|
if not dAxR3 then dAxR3 = EMT.R3 end
|
|
if abs( dAxR3 - 0) < 0.1 then
|
|
sPos = '111'
|
|
elseif abs( dAxR3 - 90) < 0.1 then
|
|
sPos = '114'
|
|
elseif abs( dAxR3 + 90) < 0.1 then
|
|
sPos = '112'
|
|
else
|
|
EmtSetLastError( 1210, 'Chain saw orientation not allowed')
|
|
end
|
|
elseif sPos == '201' then
|
|
if not dAxR3 then dAxR3 = EMT.R3 end
|
|
-- se non ancora settato, è la posizione per punta lunga su ONE (quindi non ha asse R3). Altrimenti è mortasatrice su PF.
|
|
if dAxR3 then
|
|
if abs( dAxR3 - 0) < 0.1 then
|
|
sPos = '201'
|
|
elseif abs( dAxR3 - 90) < 0.1 then
|
|
sPos = '204'
|
|
elseif abs( dAxR3 + 90) < 0.1 then
|
|
sPos = '202'
|
|
else
|
|
EmtSetLastError( 1210, 'Mortiser orientation not allowed')
|
|
end
|
|
end
|
|
elseif sPos == '211' then
|
|
if not dAxR3 then dAxR3 = EMT.R3 end
|
|
if abs( dAxR3 - 0) < 0.1 then
|
|
sPos = '211'
|
|
elseif abs( dAxR3 - 90) < 0.1 then
|
|
sPos = '214'
|
|
elseif abs( dAxR3 + 90) < 0.1 then
|
|
sPos = '212'
|
|
else
|
|
EmtSetLastError( 1210, 'Mortiser orientation not allowed')
|
|
end
|
|
end
|
|
return sPos
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetToolRadLen()
|
|
-- se utensile standard
|
|
if EMT.HEAD == 'H11' or EMT.HEAD == 'H21' then
|
|
return EMT.TDIAM / 2, EMT.TLEN
|
|
-- se lama su testa 1
|
|
elseif EMT.HEAD == 'H12' then
|
|
return EMT.TDIAM / 2, -SawOffsZ + EMT.TLEN
|
|
-- se lama su testa 2
|
|
elseif EMT.HEAD == 'H22' then
|
|
return EMT.TDIAM / 2, -Saw2OffsZ + EMT.TLEN
|
|
-- se sega a catena
|
|
elseif HeadIsChainSaw( EMT.HEAD) then
|
|
return EMT.TLEN, ( EMT.TDIST or ChSawLen)
|
|
end
|
|
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 not HeadIsChainSaw( EMT.HEAD) 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 GetFmaxClamp()
|
|
return EmtLenToString( EMT.FMAXPINZE, 0)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetFall( nPathId)
|
|
local sVal = EgtGetInfo( nPathId, 'AE1')
|
|
return ( sVal == '0,Fall')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetSpecUnloading( nPathId)
|
|
local sVal = EgtGetInfo( nPathId, 'AE1')
|
|
return ( sVal == '0,Unloading SpecSplit')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelta)
|
|
if bReset then
|
|
EmitResetMachining()
|
|
end
|
|
-- gruppo della testa
|
|
local nHSet = GetHeadSet( EMT.HEAD)
|
|
-- se testa 1
|
|
if nHSet == 1 then
|
|
-- posizioni sicure
|
|
local dMaxZ1 = EgtGetAxisMax( 'Z1')
|
|
local dSafeX1 = EgtGetAxisHomePos( 'X1')
|
|
local dSafeZ1 = EgtGetAxisHomePos( 'Z1')
|
|
local dSafeB1 = EgtGetAxisHomePos( 'B1')
|
|
local dSafeC1 = EgtGetAxisHomePos( 'C1')
|
|
-- se necessario allargo le cabine
|
|
if RollerParkingNeeded( EMT.HEAD, PrevR1, PrevR2, dSafeC1, dSafeB1) then
|
|
local dPosT = EgtIf( bEnd, EMT.L1o, EMT.TPOS or EMT.L1op)
|
|
EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
|
|
end
|
|
-- se fresa o lama
|
|
if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' then
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
-- eseguo la salita a Z1max (oriento solo se assi rotanti non già a posto)
|
|
if abs( dSafeC1 - PrevR1) > 0.1 or abs( dSafeB1 - PrevR2) > 0.1 then
|
|
local dZref = dSafeZ1 + GetZExtra( EMT.HEAD, PrevR2)
|
|
if EgtIf( not EgtGetHeadId( 'H21') or BD.RIGHT_LOAD, -EMT.L2o < -LimX1RotSaw, -EMT.L2o > -LimX1RotSaw) then
|
|
dZref = dZref - EgtIf( not Mortiser, 100, 370)
|
|
end
|
|
dZref = min( dZref, dMaxZ1)
|
|
local MovH = { Z = EgtIf( dZref > EMT.L3o, dZref, EMT.L3o)}
|
|
MovH.X = -EMT.L2o ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ;
|
|
EmitMoveDataHead( 1, MovH)
|
|
if EMT.HEAD == 'H12' and ( abs( dSafeC1 - PrevR1) > 30.1 or abs( dSafeB1 - PrevR2) > 30.1) then
|
|
EmitMoveDataHead( 1, { Z=dMaxZ1, B=0})
|
|
end
|
|
EmitMoveDataHead( 1, { C=dSafeC1})
|
|
EmitMoveDataHead( 1, { B=dSafeB1})
|
|
EmitMoveDataHead( 1, { Z=dMaxZ1})
|
|
else
|
|
local MovH = { Z = dMaxZ1}
|
|
MovH.X = -EMT.L2o ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
|
|
EmitMoveDataHead( 1, MovH)
|
|
end
|
|
if bXhome then EmitMoveDataHead( 1, { X=-dSafeX1}) end
|
|
EmitMoveStartHead( 1)
|
|
-- se lavorazione in doppio
|
|
if EMT.DOU_TYPE == 2 then
|
|
EmitDouZMax()
|
|
end
|
|
EmitMoveWaitHead( 1)
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 1, { Z=dSafeZ1, B=dSafeB1})
|
|
if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
|
|
EmitMoveDataHead( 1, { Z=ParkCSawZ1, B=ParkB1})
|
|
end
|
|
EmitMoveDataHead( 1, { X=-dSafeX1, C=dSafeC1})
|
|
if bXhome then
|
|
EmitMoveDataHead( 1, { X=-ParkX1, Z=ParkCSawZ1, B=ParkB1, C=ParkC1, TPos=50})
|
|
end
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
end
|
|
-- se altrimenti fresa o lama su TC frontale
|
|
else
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
-- eseguo la salita a Z1max (oriento solo se assi rotanti non già a posto)
|
|
if abs( dSafeC1 - PrevR1) > 0.1 or abs( dSafeB1 - PrevR2) > 0.1 then
|
|
local dZref = dSafeZ1 + GetZExtra( EMT.HEAD, PrevR2)
|
|
dZref = min( dZref, dMaxZ1)
|
|
local MovH = { Z = EgtIf( dZref > EMT.L3o, dZref, EMT.L3o)}
|
|
MovH.X = -EMT.L2o ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ;
|
|
EmitMoveDataHead( 1, MovH)
|
|
if EMT.HEAD == 'H12' and ( abs( dSafeC1 - PrevR1) > 30.1 or abs( dSafeB1 - PrevR2) > 30.1) then
|
|
EmitMoveDataHead( 1, { Z=dMaxZ1, B=0})
|
|
end
|
|
EmitMoveDataHead( 1, { C=dSafeC1})
|
|
EmitMoveDataHead( 1, { B=dSafeB1})
|
|
EmitMoveDataHead( 1, { Z=dMaxZ1})
|
|
else
|
|
local MovH = { Z = dMaxZ1}
|
|
MovH.X = -EMT.L2o ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
|
|
EmitMoveDataHead( 1, MovH)
|
|
end
|
|
if bXhome then EmitMoveDataHead( 1, { X=-dSafeX1}) end
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 1, { Z=dSafeZ1, B=dSafeB1})
|
|
if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
|
|
EmitMoveDataHead( 1, { Z=ParkCSawZ1, B=ParkB1})
|
|
end
|
|
EmitMoveDataHead( 1, { X=-dSafeX1, C=dSafeC1})
|
|
if bXhome then
|
|
EmitMoveDataHead( 1, { X=-ParkX1, Z=ParkCSawZ1, B=ParkB1, C=ParkC1, TPos=50})
|
|
end
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
end
|
|
end
|
|
-- altrimenti testa 2
|
|
else
|
|
-- posizioni sicure
|
|
local dMaxZ2 = EgtGetAxisMax( 'Z2')
|
|
local dSafeX2 = EgtGetAxisHomePos( 'X2')
|
|
local dSafeZ2 = EgtGetAxisHomePos( 'Z2')
|
|
local dSafeB2 = EgtGetAxisHomePos( 'B2')
|
|
local dSafeC2 = EgtGetAxisHomePos( 'C2')
|
|
-- se necessario allargo le cabine
|
|
if RollerParkingNeeded( EMT.HEAD, PrevR1, PrevR2, dSafeC2, dSafeB2) then
|
|
local dPosT = EgtIf( bEnd, EMT.L1o, EMT.TPOS or EMT.L1op)
|
|
EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
|
|
end
|
|
-- se fresa o lama
|
|
if not HeadIsChainSaw( EMT.HEAD) then
|
|
-- eseguo la salita a Z2max (oriento solo se assi rotanti non già a posto)
|
|
if abs( dSafeC2 - PrevR1) > 0.1 or abs( dSafeB2 - PrevR2) > 0.1 then
|
|
local dZref = dSafeZ2 + GetZExtra( EMT.HEAD, PrevR2)
|
|
dZref = min( dZref, dMaxZ2)
|
|
local MovH = { Z = EgtIf( dZref > EMT.L3o, dZref, EMT.L3o)}
|
|
MovH.X = -EMT.L2o ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ;
|
|
EmitMoveDataHead( 2, MovH)
|
|
if EMT.HEAD == 'H22' and ( abs( dSafeC2 - PrevR1) > 30.1 or abs( dSafeB2 - PrevR2) > 30.1) then
|
|
EmitMoveDataHead( 2, { Z=dMaxZ2, B=0})
|
|
end
|
|
EmitMoveDataHead( 2, { C=dSafeC2})
|
|
EmitMoveDataHead( 2, { B=dSafeB2})
|
|
EmitMoveDataHead( 2, { Z=dMaxZ2})
|
|
else
|
|
local MovH = { Z = dMaxZ2}
|
|
MovH.X = -EMT.L2o ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
|
|
EmitMoveDataHead( 2, MovH)
|
|
end
|
|
if bXhome then EmitMoveDataHead( 2, { X=-dSafeX2}) end
|
|
EmitMoveStartHead( 2)
|
|
EmitMoveWaitHead( 2)
|
|
-- altrimenti sega a catena
|
|
else
|
|
EmitMoveDataHead( 1, { Z=dSafeZ2, B=dSafeB2})
|
|
if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
|
|
EmitMoveDataHead( 1, { Z=ParkCSawZ2, B=ParkB2})
|
|
end
|
|
EmitMoveDataHead( 1, { X=-dSafeX2, C=dSafeC2})
|
|
if bXhome then
|
|
EmitMoveDataHead( 2, { X=-ParkX2, Z=ParkCSawZ2, B=ParkB2, C=ParkC2, TPos=50})
|
|
end
|
|
EmitMoveStartHead( 2)
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitDouZMax()
|
|
-- posizioni sicure
|
|
local dMaxZ2 = EgtGetAxisMax( 'Z2')
|
|
local dSafeX2 = EgtGetAxisHomePos( 'X2')
|
|
local dSafeZ2 = EgtGetAxisHomePos( 'Z2')
|
|
local dSafeB2 = EgtGetAxisHomePos( 'B2')
|
|
local dSafeC2 = EgtGetAxisHomePos( 'C2')
|
|
-- eseguo la salita a Z2max
|
|
local MovH = { Z = dSafeZ2, TPos=EMT.DOU_TPOS}
|
|
MovH.X = - ( Delta2TabY - EMT.DOU_TLEN - ( -DeltaTabY + EMT.L2o - EMT.TLEN + EgtIf( BD.RIGHT_LOAD, -EMT.HB, EMT.HB))) ;
|
|
MovH.B = -90 ; MovH.C = -180 ;
|
|
EmitMoveDataHead( 2, MovH)
|
|
EmitMoveDataHead( 2, { B=dSafeB2, C=dSafeC2, TPos=EMT.DOU_TPOS})
|
|
EmitMoveDataHead( 2, { Z=dMaxZ2, TPos=EMT.DOU_TPOS})
|
|
EmitMoveDataHead( 2, { X=-dSafeX2, TPos=EMT.DOU_TPOS})
|
|
EmitMoveStartHead( 2)
|
|
EmitMoveWaitHead( 2)
|
|
-- dichiaro eseguito
|
|
EMT.DOU_TO_ZMAX = nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitXhome()
|
|
-- gruppo della testa
|
|
local nHSet = GetHeadSet( EMT.HEAD)
|
|
-- se testa 1
|
|
if nHSet == 1 then
|
|
local dMaxZ1 = EgtGetAxisMax( 'Z1')
|
|
local dSafeX1 = EgtGetAxisHomePos( 'X1')
|
|
local dSafeZ1 = EgtGetAxisHomePos( 'Z1')
|
|
local dSafeB1 = EgtGetAxisHomePos( 'B1')
|
|
local dSafeC1 = EgtGetAxisHomePos( 'C1')
|
|
if EMT.HEAD ~= 'H13' then
|
|
EmitMoveDataHead( 1, { X=-dSafeX1, Z=dMaxZ1, B=dSafeB1, C=dSafeC1})
|
|
else
|
|
EmitMoveDataHead( 1, { X=-ParkX1, Z=ParkCSawZ1, B=ParkB1, C=ParkC1, TPos=50})
|
|
end
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
-- altrimenti testa 2
|
|
else
|
|
local dMaxZ2 = EgtGetAxisMax( 'Z2')
|
|
local dSafeX2 = EgtGetAxisHomePos( 'X2')
|
|
local dSafeZ2 = EgtGetAxisHomePos( 'Z2')
|
|
local dSafeB2 = EgtGetAxisHomePos( 'B2')
|
|
local dSafeC2 = EgtGetAxisHomePos( 'C2')
|
|
if EMT.HEAD ~= 'H23' then
|
|
EmitMoveDataHead( 2, { X=-dSafeX2, Z=dMaxZ2, B=dSafeB2, C=dSafeC2})
|
|
else
|
|
EmitMoveDataHead( 2, { X=-ParkX2, Z=ParkCSawZ2, B=ParkB2, C=ParkC2, TPos=50})
|
|
end
|
|
EmitMoveStartHead( 2)
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitResetMachining()
|
|
if ( EMT.TOOL ~= GetNextTool( EMT.MCHID) and IsLastPath( EMT.PATHID)) or GetSpecUnloading( EMT.PATHID) or GetFall( EMT.PATHID) then
|
|
EmtOutput( 'M05')
|
|
end
|
|
local sOut = 'G157 EA1'
|
|
EmtOutput( sOut)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
|
|
-- se entrambe già parcheggiate, non devo fare alcunché
|
|
if ( EMT.V1POS - ParkV1) > -0.1 and ( EMT.V2POS - ParkV2) < 0.1 then return end
|
|
-- Assegno quote pinze correnti
|
|
local dY1Delta = EgtIf( bUsePrevDelta, EMT.Y1PREVDELTA, EMT.Y1DELTA)
|
|
local dY2Delta = EgtIf( bUsePrevDelta, EMT.Y2PREVDELTA, EMT.Y2DELTA)
|
|
-- Parcheggi pinze
|
|
local MyParkY1 = ParkY1 + AggLoad
|
|
local MyParkY2 = ParkY2
|
|
-- le parcheggio
|
|
local MDChar = {}
|
|
if dY1Delta and dY2Delta then
|
|
local dPosY1 = dPosT + dY1Delta
|
|
local dPosY2 = dPosT + dY2Delta
|
|
local DiffY1 = MyParkY1 - dPosY1
|
|
local DiffY2 = MyParkY2 - dPosY2
|
|
--EmtOutput( string.format( 'PosT=%.3f DiffY1=%.3f DiffY2=%.3f', dPosT, DiffY1, DiffY2))
|
|
if bSplitCut then
|
|
if DiffY1 > 0.1 then
|
|
MDChar.Y1 = dPosY1 + DiffY1
|
|
end
|
|
if DiffY2 < -0.1 then
|
|
MDChar.Y2 = dPosY2 + DiffY2
|
|
dPosT = dPosT + DiffY2
|
|
end
|
|
elseif DiffY1 > 0.1 and DiffY2 < -0.1 then
|
|
EmtSetLastError( 1201, 'Error Collision in ParkRoller')
|
|
elseif DiffY1 > 0.1 then
|
|
if dPosY2 + DiffY1 > MyParkY2 + 0.1 then
|
|
EmtSetLastError( 1201, 'Error Collision Y2 in ParkRoller')
|
|
else
|
|
MDChar.Y1 = dPosY1 + DiffY1
|
|
MDChar.Y2 = dPosY2 + DiffY1
|
|
dPosT = dPosT + DiffY1
|
|
end
|
|
elseif DiffY2 < -0.1 then
|
|
if dPosY1 + DiffY2 < MyParkY1 - 0.1 then
|
|
EmtSetLastError( 1201, 'Error Collision Y1 in ParkRoller')
|
|
else
|
|
MDChar.Y1 = dPosY1 + DiffY2
|
|
MDChar.Y2 = dPosY2 + DiffY2
|
|
dPosT = dPosT + DiffY2
|
|
end
|
|
end
|
|
MDChar.MovType = 3
|
|
MDChar.BeamVise = ( EMT.BV or 1)
|
|
elseif dY1Delta then
|
|
local dMoveV1 = ParkV1 - EMT.V1POS
|
|
local dPosY1 = dPosT + dY1Delta
|
|
local DiffY1 = MyParkY1 - dPosY1
|
|
local dMoveY1 = EgtIf( DiffY1 > 0.1, dMoveV1, 0)
|
|
local dTryMoveY1 = ParkV1 - dPosT - EgtIf( bSplitCut or EMT.FALL, EMT.LT, 0)
|
|
if ( dPosT > ParkV2 - ExtraParkV and dPosT < ParkV1 and dPosY1 + dTryMoveY1 < MaxY1) then dMoveY1 = max( dMoveY1, dTryMoveY1) end
|
|
MDChar.Y1 = dPosY1 + dMoveY1
|
|
MDChar.MovType = 1
|
|
MDChar.BeamVise = 1
|
|
dPosT = dPosT + dMoveY1
|
|
elseif dY2Delta then
|
|
local dMoveV2 = ParkV2 - EMT.V2POS
|
|
local dPosY2 = dPosT + dY2Delta
|
|
local DiffY2 = MyParkY2 - dPosY2
|
|
local dMoveY2 = EgtIf( DiffY2 < -0.1, dMoveV2, 0)
|
|
local dTryMoveY2 = ParkV2 - dPosT - EMT.LT - EMT.DELTA_LT - EMT.HOVM
|
|
if ( dPosT + EMT.LT + EMT.DELTA_LT + EMT.HOVM < ParkV1 + ExtraParkV and dPosT + EMT.LT + EMT.DELTA_LT + EMT.HOVM > ParkV2 and dPosY2 + dTryMoveY2 > MinY2) then dMoveY2 = min( dMoveY2, dTryMoveY2) end
|
|
MDChar.Y2 = dPosY2 + dMoveY2
|
|
MDChar.MovType = 2
|
|
MDChar.BeamVise = 2
|
|
dPosT = dPosT + dMoveY2
|
|
end
|
|
if abs( ParkV1 - EMT.V1POS) > 0.1 then
|
|
MDChar.V1 = ParkV1
|
|
MDChar.IniStatV1 = 3
|
|
MDChar.MovType = MDChar.MovType | 1
|
|
end
|
|
if abs( ParkV2 - EMT.V2POS) > 0.1 then
|
|
MDChar.V2 = ParkV2
|
|
MDChar.IniStatV2 = 3
|
|
MDChar.MovType = MDChar.MovType | 2
|
|
end
|
|
EmitMoveDataChars( MDChar)
|
|
EmitMoveStartChars( MDChar.MovType)
|
|
EmitMoveWaitChars( MDChar.MovType)
|
|
EMT.V1POS = ParkV1
|
|
EMT.V2POS = ParkV2
|
|
EMT.TPOS = dPosT
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetNextTool( nMchId)
|
|
-- inizializzo prossimo utensile
|
|
local sNextTool
|
|
-- recupero lavorazione successiva
|
|
local nNextMchId = EgtGetNextActiveOperation( nMchId)
|
|
while nNextMchId do
|
|
if EgtGetOperationType( nNextMchId) ~= MCH_OY.DISP then
|
|
break
|
|
end
|
|
nNextMchId = EgtGetNextActiveOperation( nNextMchId)
|
|
end
|
|
-- se trovata
|
|
if nNextMchId and EgtSetCurrMachining( nNextMchId) then
|
|
sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
|
|
end
|
|
-- ripristino stato corrente
|
|
EgtSetCurrMachining( EMT.MCHID)
|
|
EgtTdbSetCurrTool( EMT.TOOL)
|
|
return sNextTool
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function PreselectNextDiffHead( nMchId, sHead)
|
|
-- se non ho due teste, esco subito
|
|
if not EgtGetHeadId( 'H21') then
|
|
return
|
|
end
|
|
|
|
-- gruppo della testa
|
|
local nHSet = GetHeadSet( sHead)
|
|
-- flag preselezione eseguita
|
|
local bPresel = false
|
|
-- recupero lavorazione successiva
|
|
local nNextMchId = EgtGetNextActiveOperation( nMchId)
|
|
while nNextMchId do
|
|
if EgtGetOperationType( nNextMchId) ~= MCH_OY.DISP then
|
|
if EgtSetCurrMachining( nNextMchId) then
|
|
local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
|
|
if EgtTdbSetCurrTool( sNextTool) then
|
|
local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
local nNextHSet = GetHeadSet( sNextHead)
|
|
if nNextHSet ~= nHSet then
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
nNextMchId = EgtGetNextActiveOperation( nNextMchId)
|
|
end
|
|
-- se esiste ed appartiene a gruppo diverso
|
|
if nNextMchId and EgtSetCurrMachining( nNextMchId) then
|
|
local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
|
|
if EgtTdbSetCurrTool( sNextTool) then
|
|
local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
local nNextHSet = GetHeadSet( sNextHead)
|
|
if nNextHSet ~= nHSet then
|
|
local sNextTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
|
|
-- se testa attuale da caricare è sega a catena, mando l'altra prima in HomeX (per evitare possibili collisioni) e poi lancio preselezione
|
|
if sHead == 'H13' and EMT.PREVHEAD ~= 'H13' then
|
|
EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos='0'})
|
|
EmitMoveStartHead( 2)
|
|
EmitMoveWaitHead( 2)
|
|
elseif sHead == 'H23' and EMT.PREVHEAD ~= 'H23' then
|
|
EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos='0'})
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
end
|
|
-- Emetto preselezione (non ammessa per sega a catena H13 e H23)
|
|
if sNextHead == 'H11' then
|
|
EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sNextTcPos)})
|
|
EmitMoveStartHead( 1)
|
|
bPresel = true
|
|
elseif sNextHead == 'H12' then
|
|
EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sNextTcPos)})
|
|
EmitMoveStartHead( 1)
|
|
bPresel = true
|
|
elseif sNextHead == 'H21' then
|
|
EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, sNextTcPos)})
|
|
EmitMoveStartHead( 2)
|
|
bPresel = true
|
|
elseif sNextHead == 'H22' then
|
|
EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, sNextTcPos)})
|
|
EmitMoveStartHead( 2)
|
|
bPresel = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- ripristino stato corrente
|
|
EgtSetCurrMachining( EMT.MCHID)
|
|
EgtTdbSetCurrTool( EMT.TOOL)
|
|
-- se non eseguita preselezione
|
|
if not bPresel then
|
|
-- mi assicuro che l'altra testa sia in parcheggio
|
|
if nHSet == 1 then
|
|
-- non può essere la sega a catena
|
|
EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos='0'})
|
|
EmitMoveStartHead( 2)
|
|
if EMT.PREVHEAD == 'H23' and EMT.PREVHEAD ~= EMT.HEAD then
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
else
|
|
-- va bene per frese e lama
|
|
EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos='0'})
|
|
EmitMoveStartHead( 1)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function FindReadHeadWithLaser( vMDChar)
|
|
for i = 1, #vMDChar do
|
|
if vMDChar[i].IniStatY1 == 76 then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitTestProgramStart()
|
|
EmtOutput( '(APERTURA INIZIALE PINZE)')
|
|
EmtOutput( 'M111')
|
|
EmtOutput( 'M131 E30012=1')
|
|
EmtOutput( 'M125')
|
|
EmtOutput( 'M151 E30013=1')
|
|
EmtOutput( 'M145')
|
|
EmtOutput( 'M171')
|
|
if Clamp5 then
|
|
EmtOutput( 'M153')
|
|
EmtOutput( 'M155')
|
|
end
|
|
EmtOutput( 'M12 $RIMUOVERE LA TRAVE')
|
|
EmitMoveDataChars( { Y1=1400, Y2=-1400, V1=MaxV1, V2=MinV2, IniStatY1=2, IniStatY2=2, IniStatV1=3, IniStatV2=3})
|
|
EmitMoveStartChars( 3)
|
|
EmitMoveWaitChars( 3)
|
|
if Clamp5 then
|
|
EmtOutput( 'E75005=-1')
|
|
EmtOutput( 'E75005=12')
|
|
EmtOutput( 'G1G52WE75002 F5000')
|
|
EmtOutput( 'E75005=-1')
|
|
end
|
|
EmtOutput( 'M12 $START PER SVINCOLO TESTE')
|
|
EmtOutput( '(SVINCOLO TESTA 1)')
|
|
EmitMoveDataHead( 1, {Z=ParkZ1-100, TPos=0})
|
|
if Progress then
|
|
EmtOutput( 'IF E80001<=10 THEN')
|
|
EmitMoveDataHead( 1, {C=ParkC1, TPos=0})
|
|
EmitMoveDataHead( 1, {Z=-150, B=ParkB1, TPos=0})
|
|
EmitMoveDataHead( 1, {Z=0, X=-ParkX1})
|
|
EmtOutput( 'ELSE')
|
|
EmitMoveDataHead( 1, {C=ParkFrnC1, TPos=0})
|
|
EmitMoveDataHead( 1, {Z=-150, B=ParkFrnB1, TPos=0})
|
|
EmitMoveDataHead( 1, {Z=0, X=-ParkFrnX1})
|
|
EmtOutput( 'ENDI')
|
|
else
|
|
EmitMoveDataHead( 1, {C=ParkC1, TPos=0})
|
|
EmitMoveDataHead( 1, {Z=-150, B=ParkB1, TPos=0})
|
|
EmitMoveDataHead( 1, {Z=0, X=-ParkX1})
|
|
end
|
|
EmitMoveStartHead( 1)
|
|
EmitMoveWaitHead( 1)
|
|
-- se esiste la testa 2
|
|
if EgtGetHeadId( 'H21') then
|
|
EmtOutput( '(SVINCOLO TESTA 2)')
|
|
EmitMoveDataHead( 2, {C=ParkC2, TPos=0})
|
|
EmitMoveDataHead( 2, {Z=-150, B=ParkB2, TPos=0})
|
|
EmitMoveDataHead( 2, {Z=0, X=-ParkX2})
|
|
EmitMoveStartHead( 2)
|
|
EmitMoveWaitHead( 2)
|
|
end
|
|
EmtOutput( 'M28')
|
|
EmtOutput( '')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitMoveDataHead( nHead, MoData)
|
|
local sOut = 'G141'
|
|
if MoData.X then sOut = sOut .. ' X' .. EmtLenToString( MoData.X, 3) end
|
|
if MoData.Z then sOut = sOut .. ' Z' .. EmtLenToString( MoData.Z, 3) end
|
|
if MoData.B then sOut = sOut .. ' B' .. EmtLenToString( MoData.B, 3) end
|
|
if MoData.C then sOut = sOut .. ' C' .. EmtLenToString( MoData.C, 3) end
|
|
if MoData.TRad then sOut = sOut .. ' ER' .. EmtLenToString( MoData.TRad, 3) end
|
|
if MoData.TLen then sOut = sOut .. ' EL' .. EmtLenToString( MoData.TLen, 3) end
|
|
if MoData.TPos then sOut = sOut .. ' ET' .. MoData.TPos elseif EMT.TCPOS then sOut = sOut .. ' ET' .. AdjustTcPos( false) end
|
|
if MoData.S then sOut = sOut .. ' ES' .. EgtNumToString( MoData.S, 0) end
|
|
if MoData.F then sOut = sOut .. ' EF' .. EmtLenToString( MoData.F, 0) end
|
|
if MoData.Aux then sOut = sOut .. MoData.Aux end
|
|
sOut = sOut .. EgtIf( nHead == 1, ' EU1', ' EU2')
|
|
EmtOutput( sOut)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitMoveStartHead( nHead, sAux)
|
|
EmtOutput( 'G141 ET1001' .. EgtIf( nHead == 1, ' EU1', ' EU2') .. EgtIf( sAux, ' '..(sAux or ''), ''))
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitMoveWaitHead( nHead)
|
|
EmtOutput( 'G141 ET2001' .. EgtIf( nHead == 1, ' EU1', ' EU2'))
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitMoveDataChars( MoData)
|
|
if MoData.Start then
|
|
EmitMoveStartChars( MoData.Start)
|
|
return
|
|
elseif MoData.Wait then
|
|
EmitMoveWaitChars( MoData.Wait)
|
|
return
|
|
end
|
|
local sOut = 'G151'
|
|
if MoData.Y1 then sOut = sOut .. ' Y' .. EmtLenToString( MoData.Y1, 3) end
|
|
if MoData.Y2 then sOut = sOut .. ' V' .. EmtLenToString( MoData.Y2, 3) end
|
|
if MoData.V1 then sOut = sOut .. ' B' .. EmtLenToString( MoData.V1, 3) end
|
|
if MoData.V2 then sOut = sOut .. ' C' .. EmtLenToString( MoData.V2, 3) end
|
|
if MoData.IniStatY1 then sOut = sOut .. ' EA' .. EgtNumToString( MoData.IniStatY1, 0) end
|
|
if MoData.FinStatY1 then sOut = sOut .. ' EB' .. EgtNumToString( MoData.FinStatY1, 0) end
|
|
if MoData.IniStatY2 then sOut = sOut .. ' EC' .. EgtNumToString( MoData.IniStatY2, 0) end
|
|
if MoData.FinStatY2 then sOut = sOut .. ' ED' .. EgtNumToString( MoData.FinStatY2, 0) end
|
|
if MoData.IniStatV1 then sOut = sOut .. ' EH' .. EgtNumToString( MoData.IniStatV1, 0) end
|
|
if MoData.FinStatV1 then sOut = sOut .. ' EI' .. EgtNumToString( MoData.FinStatV1, 0) end
|
|
if MoData.IniStatV2 then sOut = sOut .. ' EJ' .. EgtNumToString( MoData.IniStatV2, 0) end
|
|
if MoData.FinStatV2 then sOut = sOut .. ' EK' .. EgtNumToString( MoData.FinStatV2, 0) end
|
|
if MoData.BeamVise then sOut = sOut .. ' EE' .. EgtNumToString( MoData.BeamVise, 0) end
|
|
if MoData.F then sOut = sOut .. ' EF' .. EmtLenToString( MoData.F, 0) else sOut = sOut .. ' EF' .. GetFmaxClamp() end
|
|
if MoData.MovType == 1 then sOut = sOut .. ' ET1' elseif MoData.MovType == 2 then sOut = sOut .. ' ET2' else sOut = sOut .. ' ET0' end
|
|
if MoData.Aux then sOut = sOut .. MoData.Aux end
|
|
EmtOutput( sOut)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitMoveStartChars( MovType)
|
|
local sMovType = 'ET1004'
|
|
if MovType == 1 then
|
|
sMovType = 'ET1001'
|
|
elseif MovType == 2 then
|
|
sMovType = 'ET1002'
|
|
end
|
|
EmtOutput( 'G151 ' .. sMovType)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitMoveWaitChars( MovType, bRun)
|
|
local sMovType = 'ET2004'
|
|
if MovType == 1 then
|
|
sMovType = 'ET2001'
|
|
elseif MovType == 2 then
|
|
sMovType = 'ET2002'
|
|
end
|
|
if bRun == nil or bRun then
|
|
EmtOutput( 'G151 ' .. sMovType)
|
|
else
|
|
EmtOutput( '(G151 ' .. sMovType .. ')')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function EmitBeamHeadData( BhData)
|
|
if not BhData.Pz5 then
|
|
local sOut = 'G152'
|
|
if BhData.T then sOut = sOut .. ' Y' .. EmtLenToString( BhData.T, 3) end
|
|
if BhData.Y1 then sOut = sOut .. ' EY' .. EmtLenToString( BhData.Y1, 3) end
|
|
if BhData.Y2 then sOut = sOut .. ' EV' .. EmtLenToString( BhData.Y2, 3) end
|
|
if BhData.V1 then sOut = sOut .. ' B' .. EmtLenToString( BhData.V1, 3) end
|
|
if BhData.V2 then sOut = sOut .. ' C' .. EmtLenToString( BhData.V2, 3) end
|
|
if BhData.W then sOut = sOut .. ' EW' .. EmtLenToString( BhData.W, 3) end
|
|
if BhData.ViseY1 then sOut = sOut .. ' EA' .. EgtNumToString( BhData.ViseY1, 0) end
|
|
if BhData.ViseY2 then sOut = sOut .. ' EB' .. EgtNumToString( BhData.ViseY2, 0) end
|
|
if BhData.SetHead then sOut = sOut .. ' EC' .. EgtNumToString( BhData.SetHead, 0) end
|
|
if BhData.IniStatV1 then sOut = sOut .. ' EH' .. EgtNumToString( BhData.IniStatV1, 0) end
|
|
if BhData.FinStatV1 then sOut = sOut .. ' EI' .. EgtNumToString( BhData.FinStatV1, 0) end
|
|
if BhData.IniStatV2 then sOut = sOut .. ' EJ' .. EgtNumToString( BhData.IniStatV2, 0) end
|
|
if BhData.FinStatV2 then sOut = sOut .. ' EK' .. EgtNumToString( BhData.FinStatV2, 0) end
|
|
if BhData.F then sOut = sOut .. ' EF' .. EmtLenToString( BhData.F, 0) else sOut = sOut .. ' EF' .. GetFmaxClamp() end
|
|
if BhData.ViseY1 == 3 then sOut = sOut .. ' EL1' end
|
|
if BhData.ViseY2 == 3 then sOut = sOut .. ' EM1' end
|
|
EmtOutput( sOut)
|
|
else
|
|
local sOut = 'G153'
|
|
if BhData.T then sOut = sOut .. ' Y' .. EmtLenToString( BhData.T, 3) end
|
|
if BhData.Pz5 == 1 then
|
|
sOut = sOut .. ' EA1'
|
|
else
|
|
sOut = sOut .. ' EA2'
|
|
end
|
|
EmtOutput( sOut)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** END GENERATION ***
|
|
---------------------------------------------------------------------
|