From f5e67a1aaf9735da47e2bc682f8057289bb22a14 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Wed, 3 Jun 2026 11:52:29 +0200 Subject: [PATCH 1/7] HOTFIX problema simulazione --- Common_ONE-PF.mlpe | 3 --- 1 file changed, 3 deletions(-) diff --git a/Common_ONE-PF.mlpe b/Common_ONE-PF.mlpe index cb66da4..28588a0 100644 --- a/Common_ONE-PF.mlpe +++ b/Common_ONE-PF.mlpe @@ -1922,9 +1922,6 @@ function ExecMoveZmax( bMchSplit, btoXHome) ShowToolInTcPos( EMT.TCPOS, true) -- nascondo l'utensile sulla testa EgtSetMode( EgtGetHeadId( EMT.HEAD or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - EMT.PREVTOOL_H1 = nil - EMT.PREVHEAD_H1 = nil - EMT.PREVTCPOS_H1 = nil EMT.CHSAW_OUT = true EMT.XHOME = true end From c25fc2d1b838440d6b43d49805ea47918197dce3 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Fri, 5 Jun 2026 12:09:48 +0200 Subject: [PATCH 2/7] Allineamento con common ver. 3.1f2 --- Common_ONE-PF.NUM.mlpe | 121 +++++++++++++++++++++++------------------ Essetre-PFMAXrl.mlde | 6 +- UpdateLog.txt | 3 + Version.lua | 2 +- 4 files changed, 76 insertions(+), 56 deletions(-) diff --git a/Common_ONE-PF.NUM.mlpe b/Common_ONE-PF.NUM.mlpe index 11b28b5..0e981de 100644 --- a/Common_ONE-PF.NUM.mlpe +++ b/Common_ONE-PF.NUM.mlpe @@ -3380,67 +3380,80 @@ function PreselectNextDiffHead( nMchId, sHead) -- gruppo della testa local nHSet = GetHeadSet( sHead) + + local bVerifyPresel = true + -- se lavorazione con testa 1 e sotto al limite massimo di preselezione della testa 2, allora non si fa preselezione + if nHSet == 1 and Limit_T1_Presel_T2 and EMT.MAXMIN[2] < Limit_T1_Presel_T2 then + bVerifyPresel = false + -- se lavorazione con testa 1 e sopra al limite minimo di preselezione della testa 1, allora non si fa preselezione + elseif nHSet == 2 and Limit_T2_Presel_T1 and EMT.MAXMIN[2] > Limit_T2_Presel_T1 then + bVerifyPresel = false + end + -- 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 + + if bVerifyPresel then + -- 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 nHSet ~= GetHeadSet( EMT.PREVHEAD_H1) then + EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)}) + EmitMoveStartHead( 2) + EmitMoveWaitHead( 2) + elseif sHead == 'H23' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H2) then + EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)}) + EmitMoveStartHead( 1) + EmitMoveWaitHead( 1) + end + -- Emetto preselezione (non ammessa per sega a catena H13 e H23 e aggregato BlockHaus H17) + 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 - nNextMchId = EgtGetNextActiveOperation( nNextMchId) + -- ripristino stato corrente + EgtSetCurrMachining( EMT.MCHID) + EgtTdbSetCurrTool( EMT.TOOL) 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 nHSet ~= GetHeadSet( EMT.PREVHEAD_H1) then - EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)}) - EmitMoveStartHead( 2) - EmitMoveWaitHead( 2) - elseif sHead == 'H23' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H2) then - EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)}) - EmitMoveStartHead( 1) - EmitMoveWaitHead( 1) - end - -- Emetto preselezione (non ammessa per sega a catena H13 e H23 e aggregato BlockHaus H17) - 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 diff --git a/Essetre-PFMAXrl.mlde b/Essetre-PFMAXrl.mlde index 2b16d9c..1f9fda7 100644 --- a/Essetre-PFMAXrl.mlde +++ b/Essetre-PFMAXrl.mlde @@ -8,7 +8,7 @@ require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '3.1f1' +PP_VER = '3.1f2' PP_NVER = '3.1.6.1' MIN_MACH_VER = '2.5k1' MACH_NAME = EgtGetCurrMachineName() @@ -79,6 +79,7 @@ SawC2Offs = 0 SawB2Offs = 0 MinX1 = 700 MaxX1 = 2735 +Limit_T1_Presel_T2 = MinX1 MinZ1 = -1850 MaxZ1 = 0 MinC1 = -275 @@ -105,6 +106,7 @@ ParkCSaw0C1 = 0 ParkCSawB1 = 0 MinX2 = 0 MaxX2 = 2035 +Limit_T2_Presel_T1 = MaxX2 MinZ2 = -1850 MaxZ2 = 0 MinC2 = -275 @@ -227,6 +229,8 @@ if EgtExistsFile( sData) then if Machine.Offsets.SAW2OFFSZ then Saw2OffsZ = Machine.Offsets.SAW2OFFSZ end if Machine.Offsets.DEFTCPOS1 then DefTcPos1 = ( 'T' .. Machine.Offsets.DEFTCPOS1) end if Machine.Offsets.DEFTCPOS2 then DefTcPos2 = ( 'T' .. Machine.Offsets.DEFTCPOS2) end + if Machine.Offsets.LIMIT_T1_PRESEL_T2 then Limit_T1_Presel_T2 = Machine.Offsets.LIMIT_T1_PRESEL_T2 end + if Machine.Offsets.LIMIT_T2_PRESEL_T1 then Limit_T2_Presel_T1 = Machine.Offsets.LIMIT_T2_PRESEL_T1 end if Machine.Offsets.NOULOAD then MaxUnloadLen = Machine.Offsets.NOULOAD end if Machine.Offsets.MAXFEEDPINZE then MaxFeedPinze = Machine.Offsets.MAXFEEDPINZE end if Machine.Offsets.MAXACC then MaxAcc = Machine.Offsets.MAXACC end diff --git a/UpdateLog.txt b/UpdateLog.txt index 2c6c4ae..a3cc700 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,8 @@ ==== Common_ONE-PF Update Log ==== +Versione 3.1f2 (05/06/2026) +- (MLDE-GEN) Aggiunti parametri di limite asse X per decidere se fare preselezione su altra testa. Serve modifica MLDE + Versione 3.1f1 (03/06/2026) - (NGE-MLDE-GEN-SIM) Versione unificata con predisposizione per gestione tastatori. Serve modificare anche la macchina, per ora gestione completa solo su PFrl. diff --git a/Version.lua b/Version.lua index 2dcf74e..f94beaa 100644 --- a/Version.lua +++ b/Version.lua @@ -3,7 +3,7 @@ local InfoCommon_STD_PP = { NAME = 'Common_ONE-PF', -- nome script PP standard - VERSION = '3.1f1', -- versione script + VERSION = '3.1f2', -- versione script MIN_MACH_VER_PP_COMMON = '3.1b2' -- versione minima kernel } From fede797f91802c588f6cbfca8e699e9fe122475f Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Mon, 8 Jun 2026 14:43:31 +0200 Subject: [PATCH 3/7] Allineamento a common ver. 3.1f3 --- Common_ONE-PF.NUM.mlpe | 2 +- Essetre-PFMAXrl.mlde | 4 ++-- UpdateLog.txt | 3 +++ Version.lua | 2 +- 4 files changed, 7 insertions(+), 4 deletions(-) diff --git a/Common_ONE-PF.NUM.mlpe b/Common_ONE-PF.NUM.mlpe index 0e981de..dceac1c 100644 --- a/Common_ONE-PF.NUM.mlpe +++ b/Common_ONE-PF.NUM.mlpe @@ -597,7 +597,7 @@ function OnMachiningEnd() EmtOutput( sOut) end elseif not EMT.PREROT then - EmtOutput( '(M77)') + EmtOutput( 'M77') end end end diff --git a/Essetre-PFMAXrl.mlde b/Essetre-PFMAXrl.mlde index 1f9fda7..c43371f 100644 --- a/Essetre-PFMAXrl.mlde +++ b/Essetre-PFMAXrl.mlde @@ -8,8 +8,8 @@ require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '3.1f2' -PP_NVER = '3.1.6.1' +PP_VER = '3.1f3' +PP_NVER = '3.1.6.3' MIN_MACH_VER = '2.5k1' MACH_NAME = EgtGetCurrMachineName() diff --git a/UpdateLog.txt b/UpdateLog.txt index a3cc700..786ad53 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,8 @@ ==== Common_ONE-PF Update Log ==== +Versione 3.1f3 (08/06/2026) +- (GEN) M77 viene ora eseguita, prima era commentata. + Versione 3.1f2 (05/06/2026) - (MLDE-GEN) Aggiunti parametri di limite asse X per decidere se fare preselezione su altra testa. Serve modifica MLDE diff --git a/Version.lua b/Version.lua index f94beaa..480e487 100644 --- a/Version.lua +++ b/Version.lua @@ -3,7 +3,7 @@ local InfoCommon_STD_PP = { NAME = 'Common_ONE-PF', -- nome script PP standard - VERSION = '3.1f2', -- versione script + VERSION = '3.1f3', -- versione script MIN_MACH_VER_PP_COMMON = '3.1b2' -- versione minima kernel } From 73789b501c8efd00ae059193d9506c5b130f9ee8 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Wed, 17 Jun 2026 09:03:49 +0200 Subject: [PATCH 4/7] Allineamento con comon ver. 3.1f4 --- Common_ONE-PF.NUM.mlpe | 60 ++++++++++++++++++++++++++++++------------ Essetre-PFMAXrl.mlde | 4 +-- UpdateLog.txt | 3 +++ Version.lua | 2 +- 4 files changed, 49 insertions(+), 20 deletions(-) diff --git a/Common_ONE-PF.NUM.mlpe b/Common_ONE-PF.NUM.mlpe index dceac1c..f10efcc 100644 --- a/Common_ONE-PF.NUM.mlpe +++ b/Common_ONE-PF.NUM.mlpe @@ -422,6 +422,14 @@ function OnToolSelect() if EMT.TDIST and abs( EMT.TDIST) < 0.1 then EMT.TDIST = nil end EMT.TUSERNOTES = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES) EMT.ISPROBING = HeadIsProbe( EMT.HEAD) + + -- gruppo della testa + local nHSet = GetHeadSet( EMT.HEAD) + if nHSet == 1 and EMT.PRESEL_H1 then + EMT.PRESEL_H1 = nil + elseif nHSet == 2 and EMT.PRESEL_H2 then + EMT.PRESEL_H2 = nil + end end end @@ -3382,12 +3390,14 @@ function PreselectNextDiffHead( nMchId, sHead) local nHSet = GetHeadSet( sHead) local bVerifyPresel = true - -- se lavorazione con testa 1 e sotto al limite massimo di preselezione della testa 2, allora non si fa preselezione - if nHSet == 1 and Limit_T1_Presel_T2 and EMT.MAXMIN[2] < Limit_T1_Presel_T2 then - bVerifyPresel = false - -- se lavorazione con testa 1 e sopra al limite minimo di preselezione della testa 1, allora non si fa preselezione - elseif nHSet == 2 and Limit_T2_Presel_T1 and EMT.MAXMIN[2] > Limit_T2_Presel_T1 then - bVerifyPresel = false + if not EMT.LOAD then + -- se lavorazione con testa 1 e sotto al limite massimo di preselezione della testa 2, allora non si fa preselezione + if nHSet == 1 and Limit_T1_Presel_T2 and EMT.MAXMIN[2] < Limit_T1_Presel_T2 then + bVerifyPresel = false + -- se lavorazione con testa 1 e sopra al limite minimo di preselezione della testa 1, allora non si fa preselezione + elseif nHSet == 2 and Limit_T2_Presel_T1 and EMT.MAXMIN[2] > Limit_T2_Presel_T1 then + bVerifyPresel = false + end end -- flag preselezione eseguita @@ -3456,20 +3466,36 @@ function PreselectNextDiffHead( nMchId, sHead) end -- 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 - if EMT.PREVHEAD_H2 ~= 'H23' then - EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)}) - EmitMoveStartHead( 2) - end + -- se era stato preselezionato un utensile e adesso non posso preselezionare, attendo la testa + if EMT.PRESEL_H2 then + EmitMoveWaitHead( 2) + EMT.PRESEL_H2 = nil + elseif EMT.PRESEL_H1 then + EmitMoveWaitHead( 1) + EMT.PRESEL_H1 = nil + -- se non era stato preselezionato nulla else - -- non può essere la sega a catena - if EMT.PREVHEAD_H1 ~= 'H13' and EMT.PREVHEAD_H1 ~= 'H15' then - EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)}) - EmitMoveStartHead( 1) + -- mi assicuro che l'altra testa sia in parcheggio + if nHSet == 1 then + -- non può essere la sega a catena + if EMT.PREVHEAD_H2 ~= 'H23' then + EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)}) + EmitMoveStartHead( 2) + end + else + -- non può essere la sega a catena + if EMT.PREVHEAD_H1 ~= 'H13' and EMT.PREVHEAD_H1 ~= 'H15' then + EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)}) + EmitMoveStartHead( 1) + end end end + else + if nHSet == 1 then + EMT.PRESEL_H2 = true + elseif nHSet == 1 then + EMT.PRESEL_H2 = true + end end end diff --git a/Essetre-PFMAXrl.mlde b/Essetre-PFMAXrl.mlde index c43371f..349cb3a 100644 --- a/Essetre-PFMAXrl.mlde +++ b/Essetre-PFMAXrl.mlde @@ -8,8 +8,8 @@ require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '3.1f3' -PP_NVER = '3.1.6.3' +PP_VER = '3.1f4' +PP_NVER = '3.1.6.4' MIN_MACH_VER = '2.5k1' MACH_NAME = EgtGetCurrMachineName() diff --git a/UpdateLog.txt b/UpdateLog.txt index 786ad53..4758a8e 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,8 @@ ==== Common_ONE-PF Update Log ==== +Versione 3.1f4 (17/06/2026) +- (MLDE-GEN) Corretta preselezione in caso di testa in lavoro troppo vicina a quella che sta preselezionando. Da aggiungere in MLDE parametri 'Limit_T1_Presel_T2' e 'Limit_T2_Presel_T1' + Versione 3.1f3 (08/06/2026) - (GEN) M77 viene ora eseguita, prima era commentata. diff --git a/Version.lua b/Version.lua index 480e487..72474b2 100644 --- a/Version.lua +++ b/Version.lua @@ -3,7 +3,7 @@ local InfoCommon_STD_PP = { NAME = 'Common_ONE-PF', -- nome script PP standard - VERSION = '3.1f3', -- versione script + VERSION = '3.1f4', -- versione script MIN_MACH_VER_PP_COMMON = '3.1b2' -- versione minima kernel } From a515b51daca171493998c33c69645707d28974f7 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Tue, 7 Jul 2026 14:34:47 +0200 Subject: [PATCH 5/7] - Prima versione nuovi link - Allineamento con common ver. 3.1g2 --- Common_ONE-PF.NUM.mlpe | 2011 ++++++++++++---------------------------- Common_ONE-PF.mlpe | 1406 +++++++++------------------- Common_ONE-PF.mlse | 793 ++++++++++------ Essetre-PFMAXrl.ini | 2 + Essetre-PFMAXrl.mlde | 79 +- UpdateLog.txt | 12 + Version.lua | 4 +- 7 files changed, 1682 insertions(+), 2625 deletions(-) diff --git a/Common_ONE-PF.NUM.mlpe b/Common_ONE-PF.NUM.mlpe index f10efcc..332cd19 100644 --- a/Common_ONE-PF.NUM.mlpe +++ b/Common_ONE-PF.NUM.mlpe @@ -27,7 +27,7 @@ function OnStart() --EMT.LINEINC = 1 -- incremento numerazione linee --EMT.Ft = 'F' -- token per feed --EMT.St = 'S' -- token per speed - EMT.FMAXPINZE = EgtClamp( MaxFeedPinze or 102000, 20000, 155000) -- feed massima pinze + EMT.FMAXPINZE = MaxFeedPinze -- feed massima pinze EMT.MAXACC = MaxAcc or ( EMT.FMAXPINZE / ( 60 * 0.3)) -- accelerazione massima pinze EMT.MINACC = MinAcc or ( EMT.FMAXPINZE / ( 60 * 4)) -- accelerazione minima pinze @@ -315,7 +315,7 @@ function OnDispositionEnd() if #EMT.MDCHAR > 0 then MyOutputNoNum( '(PART UNLOAD)') -- movimento intermedio di apertura pinza-rulli per evitare di trovare delle collisioni - EmitParkRoller( EMT.TPOS, false, false) + EmitParkRoller( EMT.TPOS, false) for i = 1, #EMT.MDCHAR do EmitMoveDataChars( EMT.MDCHAR[i]) if EMT.MDCHAR[i].V1 then EMT.V1POS = EMT.MDCHAR[i].V1 end @@ -326,7 +326,8 @@ function OnDispositionEnd() if IsRestPhase( EMT.PHASE + 1) then EmitMoveWaitChars( 2) else - EmitMoveWaitChars( 2, TEST_USE) + -- posticipo attesa fine scarico alla lavorazione successiva + EMT.LASTOPEISUNLOAD = true end -- emissione conclusione pezzo precedente if not TEST_USE and EMT.PRODID then @@ -421,7 +422,6 @@ function OnToolSelect() 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) - EMT.ISPROBING = HeadIsProbe( EMT.HEAD) -- gruppo della testa local nHSet = GetHeadSet( EMT.HEAD) @@ -463,10 +463,9 @@ function OnMachiningStart() 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 + if nDouType == 2 then local sDouTool = EgtGetValInNotes( EMT.MCHUSERNOTES, 'TOOLDOUBLE', 's') or EgtGetValInNotes( EMT.TUSERNOTES, 'DOUBLE', 's') or '' local sOldTool = EgtTdbGetCurrToolParam( MCH_TP.NAME) if EgtTdbSetCurrTool( sDouTool) and EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then @@ -483,28 +482,22 @@ function OnMachiningStart() 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') + local bMoveBothClampsOnSplit = false if #EMT.MDCHAR > 0 then -- Emissione split if EMT.AUXTYPE == 'S' then + -- se c'è uno split, resetto piano + EmitResetMachining( false) 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) @@ -518,38 +511,34 @@ function OnMachiningEnd() ' EP' .. EmtLenToString( 0, 3) EmtOutput( sOut) EMT.LB = EMT.LT + + -- Se la prossima fase non ha lavorazioni, posso andare già allo scarico aprendo li rulli + -- se c'è un solo movimento, aggiunto il posizionamento della pinza 2 già allo scarico + if #EMT.MDCHAR == 1 and ( IsEnd2Phase( EMT.PHASE+1) or IsEndPhase( EMT.PHASE+1)) then + -- se la prima operazione attiva dopo la fase END è una disposizione, significa che la fase non ha lavorazioni e posso andare allo scarico direttamente + if EgtGetOperationType( EgtGetNextActiveOperation( EgtGetPhaseDisposition( EMT.PHASE+1))) == MCH_OY.DISP then + EMT.MDCHAR[1].IniStatV2 = 3 + EMT.MDCHAR[1].IniStatY2 = -1 + EMT.MDCHAR[1].FinStatY2 = -1 + EMT.MDCHAR[1].MovType = nil + EMT.MDCHAR[1].Y2 = ParkV2 - EMT.LT + EMT.Y2DELTA + EMT.MDCHAR[1].V2 = ParkV2 + bMoveBothClampsOnSplit = true + end + end + 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) + EmitParkRoller( EMT.TPOS, 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)') @@ -578,8 +567,13 @@ function OnMachiningEnd() end if #EMT.MDCHAR > 0 then if EMT.AUXTYPE == 'S' then - EmitMoveStartChars( 1) - EmitMoveWaitChars( 1) + if bMoveBothClampsOnSplit then + EmitMoveStartChars( 3) + EmitMoveWaitChars( 3) + else + EmitMoveStartChars( 1) + EmitMoveWaitChars( 1) + end elseif EMT.AUXTYPE == 'U' then local nMoveType = EgtIf( EMT.CHY_ON, 3, 2) EmitMoveStartChars( nMoveType) @@ -588,6 +582,7 @@ function OnMachiningEnd() EmitMoveWaitChars( nMoveType) else EmitMoveWaitChars( nMoveType, EMT.CHY_ON or TEST_USE) + EMT.LASTOPEISUNLOAD = true end -- emissione conclusione pezzo precedente (se non in modalità test) if not TEST_USE and EMT.PRODID then @@ -604,7 +599,7 @@ function OnMachiningEnd() local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2' EmtOutput( sOut) end - elseif not EMT.PREROT then + elseif not EMT.PREROT and not EMT.SPECSPLIT then EmtOutput( 'M77') end end @@ -622,8 +617,6 @@ function OnMachiningEnd() 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 @@ -650,7 +643,6 @@ function OnMachiningEnd() EMT.PREVHOMEC_H2 = EgtGetAxisHomePos( 'C2') end - if EMT.DOU_TYPE and not EMT.ZMAX then EMT.DOU_TO_ZMAX = true end EMT.DOU_TYPE = nil end @@ -660,8 +652,12 @@ function OnPathStart() 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 + if not HeadIsChainSaw( EMT.HEAD) then + vtExtr = Vector3d( EMT.EXTR) + else + vtExtr = EgtGetCalcAuxDirFromAngles( EMT.R1, EMT.R2, EMT.R3) + end + if EMT.REFLOC and AreSameVectorApprox( vtExtr, EMT.IPLGLFR:getVersZ()) then ; -- altrimenti primo posizionamento sempre in globale else @@ -688,31 +684,27 @@ function OnPathStart() 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 or EMT.L3pp - EMT.R1pp = EMT.R1p or EMT.R1pp - EMT.R2pp = EMT.R2p or EMT.R2pp - 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 = {} + + -- si salvano gli approcci e retrazioni della lavorazione + EMT.APPROACH = {} + EMT.APPROACH.CLIMBS = EmtGetClimbs( EMT.PATHID) + EMT.APPROACH.RISES = EmtGetRises( EMT.PATHID) + if EMT.DBLPATHID then + EMT.APPROACH.DBLCLIMBS = EmtGetClimbs( EMT.DBLPATHID) + EMT.APPROACH.DBLRISES = EmtGetRises( EMT.DBLPATHID) + if not EMT.APPROACH.DBLCLIMBS or not EMT.APPROACH.DBLRISES then + EmtSetLastError( 1212, "UNEXPECTED ERROR on movements other head") + end + end end --------------------------------------------------------------------- function OnPathEnd() - if not EMT.ZMAX then - EmitResetMachining() - end + -- salvo dati precedenti EMT.L2pp = EMT.L2o @@ -735,14 +727,6 @@ 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 --------------------------------------------------------------------- @@ -823,127 +807,48 @@ end --------------------------------------------------------------------- function OnRapid() + if EMT.OPEISDISP then + return + end + + local bFirstClimb = EgtGetInfo( EMT.MOVEID, 'FirstClimb', 'b') + local bLastClimb = EgtGetInfo( EMT.MOVEID, 'LastClimb', 'b') + local bFirstRise = EgtGetInfo( EMT.MOVEID, 'FirstRise', 'b') + local bLastRise = EgtGetInfo( EMT.MOVEID, 'LastRise', 'b') + local bUniqueClimb = EgtGetInfo( EMT.MOVEID, 'UniqueClimb', 'b') + local bUniqueRise = EgtGetInfo( EMT.MOVEID, 'UniqueRise', 'b') + -- se il link non arriva dalla OnSpecial, non ha nessuna nota + local bStdClimb = ( EMT.FLAG2 ~= 2 and EMT.FLAG == 2) + local bStdRise = ( EMT.FLAG2 ~= 2 and EMT.FLAG == 3) + local bStdMachRapid = ( EMT.FLAG2 == 0 and ( EMT.FLAG == 0 or EMT.FLAG == 1)) + + -- se Split e non Caduta lascio agganciata solo la pinza Y2 alla fine dei movimenti + local bSplitMach = ( EMT.MCHUSERNOTES:find( 'Split', 1, true) ~= nil) + local sPostMove = '' + + local sHeadToMoveFirst = EgtGetInfo( EMT.MOVEID, 'HeadToMoveFirst', 's') or false + local bFirstMoveOnlyH1 = sHeadToMoveFirst and sHeadToMoveFirst == 'H1' + local bFirstMoveOnlyH2 = sHeadToMoveFirst and sHeadToMoveFirst == 'H2' + + -- tutte le teste devono passare dalla gestione nuovi link, altrimenti errore + if not IsNewLinkHead( EMT.HEAD) then + EmtSetLastError( 1211, "UNEXPECTED ERROR on links") + end + -- 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 or nHSet == 11, 'C1', 'C2')) - local HomeR2 = EgtGetAxisHomePos( EgtIf( nHSet == 1 or nHSet == 11, 'B1', 'B2')) - local PrevR1 = EMT.R1p or EMT.R1pp or HomeR1 - local PrevR2 = EMT.R2p or EMT.R2pp or HomeR2 - EmtResetPrev() - -- gestione speciale per pezzi molto alti. Se il movimento successivo è più alto del precedente, allora prendo il successivo - if EMT.L3s then - if EMT.L3s > EMT.L3 then - EMT.L3 = EMT.L3s - end - end - - -- se tastatore - if EMT.ISPROBING then - local nSetHead = GetHeadSet( EMT.HEAD) - local bIsFirstHead = ( nSetHead == 1 or nSetHead == 11) - local idProbeMachining = EMT.MCHID - local bFound = false - local nProbeHead = GetHeadSet( EMT.HEAD) - local idProbeNextMachining = EgtGetNextActiveOperation( idProbeMachining) - while not bFound do - if idProbeNextMachining then - EgtSetCurrMachining( idProbeNextMachining) - local sToolNameNextProbe = EgtGetMachiningParam( MCH_MP.TOOL) - if sToolNameNextProbe then - local sToolHeadNextProbe, sToolTcPosNextProbe = GetToolHead( sToolNameNextProbe) - local nToolHead = GetHeadSet( sToolHeadNextProbe) - -- se sono sulla stessa testa - if bIsFirstHead and nProbeHead == 11 then - EMT.PROBENEXTTOOL_H1 = sToolNameNextProbe - EMT.PROBENEXTHEAD_H1 = sToolHeadNextProbe - EMT.PROBENEXTTCPOS_H1 = sToolTcPosNextProbe - bFound = true - elseif not bIsFirstHead and nProbeHead == 21 then - EMT.PROBENEXTTOOL_H2 = sToolNameNextProbe - EMT.PROBENEXTHEAD_H2 = sToolHeadNextProbe - EMT.PROBENEXTTCPOS_H2 = sToolTcPosNextProbe - bFound = true - end - end - else - break - end - idProbeNextMachining = EgtGetNextActiveOperation( idProbeNextMachining) - end - -- ripristino lavorazione corrente - EgtSetCurrMachining( EMT.MCHID) - - local bChanged = true - if bIsFirstHead then - -- se prossimo utensile compatibile, lo prelevo - if IsToolCompatibleWithProbe( EMT.PROBENEXTTOOL_H1, EMT.TOOL) then - EMT.TCPOS = EMT.PROBENEXTTCPOS_H1 - EMT.HEAD = EMT.PROBENEXTHEAD_H1 - EMT.TOOL = EMT.PROBENEXTTOOL_H1 - else - -- se vecchio utensile compatibile, tengo quello caricato - if IsToolCompatibleWithProbe( EMT.PREVTOOL_H1, EMT.TOOL) then - bChanged = false - EMT.TCPOS = EMT.PREVTCPOS_H1 - EMT.HEAD = EMT.PREVHEAD_H1 - EMT.TOOL = EMT.PREVTOOL_H1 - -- altrimenti si seleziona utensile di default - else - ExecMoveZmax( EMT.MCHSPLIT, true) - EMT.TCPOS = DefTcPos1 - EMT.TOOL = GetToolNameFromTcPos( DefTcPos1) - EMT.HEAD, _ = GetToolHead( EMT.TOOL) - end - end - -- se cambiato utensile, si setta subito nome precedente - if bChanged then - EMT.PREVTOOL_H1 = EMT.TOOL - EMT.PREVHEAD_H1 = EMT.HEAD - EMT.PREVTCPOS_H1 = EMT.TCPOS - end - else - -- se prossimo utensile compatibile, lo prelevo - if IsToolCompatibleWithProbe( EMT.PROBENEXTTOOL_H2, EMT.TOOL) then - EMT.TCPOS = EMT.PROBENEXTTCPOS_H2 - EMT.HEAD = EMT.PROBENEXTHEAD_H2 - EMT.TOOL = EMT.PROBENEXTTOOL_H2 - else - -- se vecchio utensile compatibile, tengo quello caricato - if IsToolCompatibleWithProbe( EMT.PREVTOOL_H2, EMT.TOOL) then - bChanged = false - EMT.TCPOS = EMT.PREVTCPOS_H2 - EMT.HEAD = EMT.PREVHEAD_H2 - EMT.TOOL = EMT.PREVTOOL_H2 - -- altrimenti si seleziona utensile di default - else - ExecMoveZmax( EMT.MCHSPLIT, true) - EMT.TCPOS = DefTcPos2 - EMT.TOOL = GetToolNameFromTcPos( DefTcPos2) - EMT.HEAD, _ = GetToolHead( EMT.TOOL) - end - end - -- se cambiato utensile, si setta subito nome precedente - if bChanged then - EMT.PREVTOOL_H2 = EMT.TOOL - EMT.PREVHEAD_H2 = EMT.HEAD - EMT.PREVTCPOS_H2 = EMT.TCPOS - end - end - end - - -- se prima lavorazione + if EMT.MCHFIRST then + -- se carico trave if EMT.LOAD then + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + EmtResetPrev() + 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 @@ -957,281 +862,254 @@ function OnRapid() 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 bParkV = false + + -- verifica se serve aprire i carrelli + local bCondBase = EMT.MCHFIRST or EMT.MOVE == 0 + local bCondPosition = EMT.V1POS < EMT.V1NEXTPOS - 1 or + EMT.V2POS > EMT.V2NEXTPOS + 1 or + RollerParkingNeeded( EMT.HEAD, EMT.R1, EMT.R2, EMT.R1, EMT.R2) + + if bCondBase and bCondPosition then + bParkV = true + end + + local bNlhParkV = ( EMT.MOVE == 0 and ( EMT.FLAG2 == 1 or EMT.FLAG2 == 2)) + if bNlhParkV then + bParkV = ( EMT.FLAG == 2 and bParkV) or ( not EMT.MCHSPLIT or bSplit) + end + + if bParkV or bNlhParkV then + local bMchSplit = ( bNlhParkV and EMT.MCHSPLIT and bSplit) + local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT') + if EMT.SPLIT_Y1DELTA and not EMT.MCHSPLIT then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end local dPosT = EMT.TPOS or EMT.L1op - EmitParkRoller( dPosT, EMT.MCHSPLIT) + EmitParkRoller( dPosT, bMchSplit, bAgg) 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() - -- se fresa o lama - if not HeadIsChainSaw( EMT.HEAD) then - EmitMoveDataHead( 1, { X=-ParkX1, Z=MyMaxZ1, B=ParkB1, C=ParkC1, TRad=dTRad, TLen=dTLen, S=Speed}) - EmitMoveStartHead( 1) - EmitMoveWaitHead( 1) - EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3)) - local bMoveZbeforeX = false - 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( 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 - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end + if EMT.SPLIT_Y1DELTA then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end - -- se vado in posizione speciale rotazione assi, poi devo ritornare alla X vera di lavoro - local dMoveXtoFinalPosition = false - local dXref = EMT.L2 - if EMT.HEAD == 'H12' and EMT.L2 < -LimX1PlRotSaw then - dXref = -LimX1PlRotSaw - EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=ParkB1, C=ParkC1, S=Speed}) - dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2)) - dMoveXtoFinalPosition = true - elseif not bMoveZbeforeX then - EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=ParkB1, C=ParkC1, S=Speed}) - else - EmitMoveDataHead( 1, { X=-LimX1PlRotSaw, Z=MyMaxZ1, B=ParkB1, C=ParkC1, S=Speed}) - dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2)) - dMoveXtoFinalPosition = true - 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}) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - EmitMoveDataHead( 1, { Z=dZref, B=dBref, S=Speed}) - EmitMoveDataHead( 1, { B=EMT.R2, S=Speed}) - else - EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed}) - end + EmitMoveStartChars( EgtIf( bOnlyCharY, 1, 3)) + EmtOutput( '( *** '..EMT.MCHNAME..'/'..EMT.TOOL..' *** )') - if bMoveZbeforeX then - EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed}) - end - if dMoveXtoFinalPosition then - EmitMoveDataHead( 1, { X=EMT.L2, S=Speed}) - end - -- 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 + local dTRad, dTLen = GetToolRadLen() + -- emissione primo movimento, in home + EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, C=EMT.R1, B=EMT.R2, TRad=dTRad, TLen=dTLen, S=CalcRealSpeed( EMT.S)}) + EmitMoveStartHead( nHSet) + EmitMoveWaitHead( nHSet) + + EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3)) + else + -- controllo se ci sono spostamenti dei carrelli programmati + local bChangeCarriageClamping = GetMovesInAuxCmd( EMT.AUXCMD) + local bRotAxChanged = ( abs( EMT.R1prec - EMT.R1) > GEO.EPS_SMALL or abs( EMT.R2prec - EMT.R2) > GEO.EPS_SMALL) + -- se non ci sono riposizionamenti dei carrelli, se stesso utensile, e c'è ancora piano attivo dalla lavorazione precedente, allora questo è un climb + if EMT.PLANEACTIVE and EMT.TOOL == EMT.PREVTOOL and not bChangeCarriageClamping and not bRotAxChanged then + -- dichiaro finita lavorazione precedente + local sOut = 'G157 EA1' + EmtOutput( sOut) + 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 - 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, Z=ParkCSawZ1, B=ParkCSawB1, C=EMT.R1, S=Speed}) - EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed}) - -- se circa verticale - else - EmitMoveDataHead( 1, { X=EMT.L2, Z=ParkCSawZ1, B=ParkCSawB1, C=EMT.R1, S=Speed}) - EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed}) - end + sPreMove = ' EC3' 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) + if GetV2ToCloseNum( true) then + sPostMove = sPostMove .. ' ED-3' + else + sPreMove = sPreMove .. ' ED3' end - -- aspetto termine esecuzione movimenti testa 1 - EmitMoveWaitHead( 1) - -- altrimenti testa 2 + -- 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 + EMT.PLANEACTIVE = true + -- dichiaro che è un movimento standard + bStdMachRapid = true 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( 'Z1') - 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=-ParkFrnX1, Z=MyMaxZ1, B=HomeB1, C=HomeC1, TRad=dTRad, TLen=dTLen, S=Speed}) - EmitMoveStartHead( 1) - EmitMoveWaitHead( 1) - EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3)) - local bMoveZbeforeX = false + if bStdMachRapid then + bStdMachRapid = false + bStdClimb = true + end - local dZref = EMT.L3 - if EMT.HEAD == 'H12' and ( EgtIf( 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 - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - if not bMoveZbeforeX then - EmitMoveDataHead( 1, { X=EMT.L2, Z=MyMaxZ1, B=HomeB1, C=HomeC1, S=Speed}) - else - EmitMoveDataHead( 1, { X=-LimX1RotSawTC2, Z=MyMaxZ1, B=HomeB1, C=HomeC1, S=Speed}) - 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}) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - EmitMoveDataHead( 1, { Z=dZref, B=dBref, S=Speed}) - EmitMoveDataHead( 1, { B=EMT.R2, S=Speed}) - else - EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed}) - end - if bMoveZbeforeX then - EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed}) - end - -- altrimenti caso standard - else - EmitMoveDataHead( 1, { Z=dZref, S=Speed}) - EmitMoveDataHead( 1, { C=EMT.R1, S=Speed}) - EmitMoveDataHead( 1, { B=EMT.R2, 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)) + -- si disattiva piano a meno che non sia lavorazione con stesso utensile e stesso orientamento assi + if EMT.PLANEACTIVE then + EmitResetMachining( false) + end - -- se motosega configurata per lavorazioni di fianco o circa orizzontale - if dPosA == 0 or abs( EMT.R2) < 10 then - EmitMoveDataHead( 1, { X=EMT.L2, Z=ParkCSawZ1, B=ParkCSawB1, C=EMT.R1, S=Speed}) - EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed}) - -- se circa verticale - else - EmitMoveDataHead( 1, { X=EMT.L2, Z=ParkCSawZ1, B=ParkCSawB1, C=EMT.R1, S=Speed}) - EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed}) - end + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + EmtResetPrev() + EmtOutput( '( *** '..EMT.MCHNAME..'/'..EMT.TOOL..' *** )') + -- eventuale movimento carrelli + for i = 1, #EMT.AUXCMD do + ProcessPathStartAux( EMT.AUXCMD[i], i) + -- se ultimo comando e lavorazione di split, sgancio il carro Y1 + if i == #EMT.AUXCMD and EMT.MCHSPLIT and not EMT.TO_SPECSPLIT and not EMT.TO_FALL then + EMT.SPLIT_Y1DELTA = EMT.Y1DELTA + EMT.Y1DELTA = nil end - EmitMoveDataHead( 1, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=Speed}) + 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 + -- se è appena stato lanciato lo scarico, si aspetta la fine + if EMT.LASTOPEISUNLOAD then + EMT.LASTOPEISUNLOAD = nil + EmitMoveWaitChars( 2) + end + 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 = {} + + local bParkV = false + + -- verifica se serve aprire i carrelli + local bCondBase = EMT.MCHFIRST or EMT.MOVE == 0 + local bCondPosition = EMT.V1POS < EMT.V1NEXTPOS - 1 or + EMT.V2POS > EMT.V2NEXTPOS + 1 or + RollerParkingNeeded( EMT.HEAD, EMT.R1prec, EMT.R2prec, EMT.R1, EMT.R2) + + if bCondBase and bCondPosition then + bParkV = true + end + + local bNlhParkV = ( EMT.MOVE == 0 and ( EMT.FLAG2 == 1 or EMT.FLAG2 == 2)) + if bNlhParkV then + bParkV = ( EMT.FLAG == 2 and bParkV) or ( not EMT.MCHSPLIT or bSplit) + end + + if bParkV or bNlhParkV then + local bMchSplit = ( bNlhParkV and EMT.MCHSPLIT and bSplit) + local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT') + if EMT.SPLIT_Y1DELTA and not EMT.MCHSPLIT then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end + local dPosT = EMT.TPOS or EMT.L1op + EmitParkRoller( dPosT, bMchSplit, bAgg) + end + if EMT.SPLIT_Y1DELTA then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end + + -- se era stato lanciata la preselezione di un utensile, prima di muovere la testa asopetto che sia finito + if EMT.START_PRESEL then + EmitMoveWaitHead( EMT.START_PRESEL) + EMT.START_PRESEL = nil + end + + + -- se la testa 1 deve andare per prima in posizione, start e attesa movimento + if bFirstMoveOnlyH2 then + if EMT.APPROACH.DBLCLIMBS and #EMT.APPROACH.DBLCLIMBS > 0 then + EmitMoveDataHead( 2, { X=-EMT.APPROACH.DBLCLIMBS[1].L2, Z=EMT.APPROACH.DBLCLIMBS[1].L3, C=EMT.APPROACH.DBLCLIMBS[1].R1, B=EMT.APPROACH.DBLCLIMBS[1].R2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED}) + EmitMoveStartHead( 2) + EmitMoveWaitHead( 2) + -- si rimuove il primo movimento + table.remove( EMT.APPROACH.DBLCLIMBS, 1) + end + end + + local dTRad, dTLen = GetToolRadLen() + EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=CalcRealSpeed( EMT.S)}) + -- se la testa 1 deve andare per prima in posizione, start e attesa movimento + if bFirstMoveOnlyH1 then EmitMoveStartHead( 1) - -- aspetto termine esecuzione movimenti testa 2 EmitMoveWaitHead( 1) + end + end + end - -- 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=-ParkX2, Z=MyMaxZ2, B=HomeB2, C=HomeC2, TRad=dTRad, TLen=dTLen, S=Speed}) - EmitMoveStartHead( 2) - EmitMoveWaitHead( 2) - EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3)) - local bMoveZbeforeX = false - local dZref = EMT.L3 - if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then - dZref = min( dSafeZ2 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ2) - end - - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - if not bMoveZbeforeX then - EmitMoveDataHead( 2, { X=EMT.L2, Z=MyMaxZ2, B=HomeB2, C=HomeC2, S=Speed}) - else - EmitMoveDataHead( 2, { X=-LimX2RotSaw, Z=MyMaxZ2, B=HomeB2, C=HomeC2, S=Speed}) - end - - -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379") - if abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC2 - EMT.R1) > 30.1 or abs( HomeB2 - EMT.R2) > 30.1) then - if EMT.HEAD == 'H22' then - EmitMoveDataHead( 2, { B=0, S=Speed}) - EmitMoveDataHead( 2, { C=EMT.R1, S=Speed}) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - EmitMoveDataHead( 2, { Z=dZref, B=dBref, S=Speed}) - EmitMoveDataHead( 2, { B=EMT.R2, S=Speed}) - else - EmitMoveDataHead( 2, { Z=dZref, B=EMT.R2, S=Speed}) - end - if bMoveZbeforeX then - EmitMoveDataHead( 2, { Z=EMT.L3, S=Speed}) - end - -- altrimenti caso standard - else - EmitMoveDataHead( 2, { Z=dZref, S=Speed}) - EmitMoveDataHead( 2, { B=EMT.R2, S=Speed}) - EmitMoveDataHead( 2, { C=EMT.R1, S=Speed}) - if bMoveZbeforeX then - EmitMoveDataHead( 2, { Z=EMT.L3, S=Speed}) - end - end - end - -- altrimenti sega a catena - else - EmitMoveDataHead( 2, { X=-ParkCSawX2, Z=ParkCSawZ2, B=ParkCSawB2, C=ParkCSawC2, TRad=dTRad, TLen=dTLen, S=Speed}) - EmitMoveStartHead( 2) - EmitMoveWaitHead( 2) - EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3)) - - -- se motosega configurata per lavorazioni di fianco o circa orizzontale. Dopo attesa movimento carrelli si devono scrivere tutti gli assi. - if dPosA == 0 or abs( EMT.R2) < 10 then - EmitMoveDataHead( 2, { X=EMT.L2, Z=ParkCSawZ2, B=ParkCSawB2, C=EMT.R1, S=Speed}) - EmitMoveDataHead( 2, { Z=EMT.L3, B=EMT.R2, S=Speed}) - -- se circa verticale - else - EmitMoveDataHead( 2, { X=EMT.L2, Z=ParkCSawZ2, B=ParkCSawB2, C=EMT.R1, S=Speed}) - EmitMoveDataHead( 2, { Z=EMT.L3, B=EMT.R2, S=Speed}) - end + EMT.MCHFIRST = false + -- movimento standard CLIMB + elseif EMT.FLAG == 2 then + -- se non ho ancora impostato il piano, movimenti in assoluto + if not EMT.PLANEACTIVE then + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + local dTRad, dTLen = GetToolRadLen() + EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, C=EMT.R1, B=EMT.R2, TRad=dTRad, TLen=dTLen, S=CalcRealSpeed( EMT.S)}) + -- altrimenti è un rapido standard + else + bStdMachRapid = true + end + -- movimento standard RISE + elseif EMT.FLAG == 3 then + EMT.REFLOC = nil + EMT.IPLGL = false + -- al primo movimento di risalita, si disattiva piano generico + if bFirstRise or bUniqueRise or bStdRise then + EmitResetMachining( true) + local dPosT = EMT.TPOS or EMT.L1op + EmitParkRoller( dPosT, bSplitMach) + end + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + + EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, C=EMT.R1, B=EMT.R2}) + -- su ultimo rapido in uscita, comandi di attesa movimenti + if bLastRise or bUniqueRise or bStdRise then + EmitMoveStartHead( nHSet) + -- se lavorazione in doppio + if nHSet == 1 and EMT.DOU_TYPE == 2 then + if EMT.APPROACH.DBLRISES and #EMT.APPROACH.DBLRISES > 0 then + for i = 1, #EMT.APPROACH.DBLRISES do + EmitMoveDataHead( 2, { X=-EMT.APPROACH.DBLRISES[i].L2, Z=EMT.APPROACH.DBLRISES[i].L3, C=EMT.APPROACH.DBLRISES[i].R1, B=EMT.APPROACH.DBLRISES[i].R2, TPos=EMT.DOU_TPOS}) 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 + EmitMoveWaitHead( nHSet) + EMT.ZMAX = true + ToolPreSelectionSingleHead( EMT.MCHID) + end + -- se altrimenti movimento in Home + elseif EMT.FLAG == 4 then + -- non previsto + -- altrimenti errore + else + + end + + -- se ultimo, oppure unico, movimento in discesa sul pezzo, attivo piano generico. Se già attivo siginifica che è seconda lavorazione compatibile + if not EMT.PLANEACTIVE and ( bLastClimb or bUniqueClimb or bStdClimb) then + EMT.ZMAX = false + -- movimenti testa + -- scrittura comando start movimenti testa + EmitMoveStartHead( nHSet) + -- se lavorazione in doppio + if nHSet == 1 and EMT.DOU_TYPE == 2 then + if EMT.APPROACH.DBLCLIMBS and #EMT.APPROACH.DBLCLIMBS > 0 then + for i = 1, #EMT.APPROACH.DBLCLIMBS do + EmitMoveDataHead( 2, { X=-EMT.APPROACH.DBLCLIMBS[i].L2, Z=EMT.APPROACH.DBLCLIMBS[i].L3, C=EMT.APPROACH.DBLCLIMBS[i].R1, B=EMT.APPROACH.DBLCLIMBS[i].R2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED}) + end + EmitMoveStartHead( 2) + EmitMoveWaitHead( 2) + end + -- altrimenti preselezione su altra testa + else + PreselectNextDiffHead( EMT.MCHID, EMT.HEAD) + end + -- aspetto esecuzione movimento testa 2 + EmitMoveWaitHead( nHSet) + + -- movimenti carrelli + if EMT.LOAD then -- se pezzo a destra, dichiaro cabina sinistra da parcheggiare if not EMT.Y1DELTA then EMT.V1NEXTPOS = ParkV1 @@ -1277,356 +1155,8 @@ function OnRapid() 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.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, nil, true) - EMT.ZMAX = true - EMT.TO_ZMAX = nil - EMT.TO_XHOME = nil - EMT.L1pp = nil - EMT.L3pp = nil - PrevR1 = EgtGetAxisHomePos( EgtIf( nHSet == 1 or nHSet == 11, 'C1', 'C2')) - PrevR2 = EgtGetAxisHomePos( EgtIf( nHSet == 1 or nHSet == 11, '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 devo andare in home, ma lo sono già, non faccio nulla - if not EMT.XHOME then - local nHSet = GetHeadSet( EMT.HEAD) - local nPrevHSet = GetHeadSet( EMT.PREVHEAD) - -- vado in parcheggio sempre con utensile precedente - if not HeadIsChainSaw( EMT.PREVHEAD) then - if nPrevHSet == 1 or nPrevHSet == 11 then - local HomeX1 = EgtGetAxisHomePos( 'X1') - EmitMoveDataHead( 1, { X=-EMT.PREVHOMEX_H1, Z=MaxZ1, B=EMT.PREVHOMEB_H1, C=EMT.PREVHOMEC_H1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)}) - EmitMoveStartHead( 1, 'EA1') - EmitMoveWaitHead( 1) - else - local HomeX2 = EgtGetAxisHomePos( 'X2') - EmitMoveDataHead( 2, { X=-EMT.PREVHOMEX_H2, Z=MaxZ2, B=EMT.PREVHOMEB_H2, C=EMT.PREVHOMEC_H2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)}) - EmitMoveStartHead( 2, 'EA1') - EmitMoveWaitHead( 2) - end - else - if GetHeadTCSet( EMT.PREVHEAD, EMT.PREVTCPOS) == 'Head1_TC1' or GetHeadTCSet( EMT.PREVHEAD, EMT.PREVTCPOS) == 'Head1_TC2' then - EmitMoveDataHead( 1, { X=-ParkCSawX1S, Z=MaxZ1, B=HomeR2, C=HomeR1, TPos='50'}) - EmitMoveStartHead( 1, 'EA1') - --EmitMoveWaitHead( 1) - else - EmitMoveDataHead( 2, { X=-ParkCSawX2S, Z=MaxZ2, B=HomeR2, C=HomeR1, TPos='50'}) - EmitMoveStartHead( 2, 'EA1') - --EmitMoveWaitHead( 2) - end - end - end - - EMT.TO_XHOME = nil - EMT.L1pp = 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.TOOL ~= EMT.PREVTOOL 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 CurrX1 = EMT.L1pp or ( -LimX1PlRotSaw) - local CurrZ1 = EMT.L3pp or MyMaxZ1 - local CurrB1 = PrevR2 - local CurrC1 = PrevR1 - - local bMoveZbeforeX = false - local dZref = EMT.L3 - if EMT.HEAD == 'H12' and ( EgtIf( 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 - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - - -- se vado in posizione speciale rotazione assi, poi devo ritornare alla X vera di lavoro - local dMoveXtoFinalPosition = false - local dXref = EMT.L2 - if EMT.HEAD == 'H12' and EMT.L2 < -LimX1PlRotSaw then - dXref = -LimX1PlRotSaw - EmitMoveDataHead( 1, { X=dXref, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed}) - dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2)) - dMoveXtoFinalPosition = true - elseif not bMoveZbeforeX then - EmitMoveDataHead( 1, { X=dXref, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed}) - else - EmitMoveDataHead( 1, { X=CurrX1, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed}) - dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2)) - dMoveXtoFinalPosition = true - 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}) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - EmitMoveDataHead( 1, { Z=dZref, B=dBref, S=Speed}) - EmitMoveDataHead( 1, { B=EMT.R2, S=Speed}) - else - EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed}) - end - if bMoveZbeforeX then - EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed}) - end - if dMoveXtoFinalPosition then - EmitMoveDataHead( 1, { X=EMT.L2, S=Speed}) - end - -- 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 CurrX1 = EMT.L1pp or ( -LimX1PlRotSaw) - local CurrZ1 = EMT.L3pp or MyMaxZ1 - local CurrB1 = PrevR2 - local CurrC1 = PrevR1 - - local bMoveZbeforeX = false - local dZref = EMT.L3 - if EMT.HEAD == 'H12' and ( EgtIf( 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 - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - - if not bMoveZbeforeX then - EmitMoveDataHead( 1, { X=EMT.L2, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed}) - else - EmitMoveDataHead( 1, { X=CurrX1, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed}) - 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}) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - EmitMoveDataHead( 1, { Z=dZref, B=dBref, S=Speed}) - EmitMoveDataHead( 1, { B=EMT.R2, S=Speed}) - else - EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed}) - end - if bMoveZbeforeX then - EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed}) - end - -- altrimenti caso standard - else - EmitMoveDataHead( 1, { Z=dZref, S=Speed}) - EmitMoveDataHead( 1, { C=EMT.R1, S=Speed}) - EmitMoveDataHead( 1, { B=EMT.R2, 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 CurrX2 = EMT.L1pp or ( -LimX2RotSaw) - local CurrZ2 = EMT.L3pp or MyMaxZ2 - local CurrB2 = PrevR2 - local CurrC2 = PrevR1 - - local bMoveZbeforeX = false - 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 - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - - if not bMoveZbeforeX then - EmitMoveDataHead( 2, { X=EMT.L2, Z=CurrZ2, B=CurrB2, C=CurrC2, TRad=dTRad, TLen=dTLen, S=Speed}) - else - EmitMoveDataHead( 2, { X=CurrX2, Z=CurrZ2, B=CurrB2, C=CurrC2, TRad=dTRad, TLen=dTLen, S=Speed}) - end - - -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379") - if abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC2 - EMT.R1) > 30.1 or abs( HomeB2 - EMT.R2) > 30.1) then - if EMT.HEAD == 'H22' then - EmitMoveDataHead( 2, { B=0, S=Speed}) - EmitMoveDataHead( 2, { C=EMT.R1, S=Speed}) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - EmitMoveDataHead( 2, { Z=dZref, B=dBref, S=Speed}) - EmitMoveDataHead( 2, { B=EMT.R2, S=Speed}) - else - EmitMoveDataHead( 2, { Z=dZref, B=EMT.R2, S=Speed}) - end - if bMoveZbeforeX then - EmitMoveDataHead( 2, { Z=EMT.L3, S=Speed}) - end - -- altrimenti caso standard - else - EmitMoveDataHead( 2, { Z=dZref, S=Speed}) - EmitMoveDataHead( 2, { B=EMT.R2, S=Speed}) - EmitMoveDataHead( 2, { C=EMT.R1, S=Speed}) - if bMoveZbeforeX then - EmitMoveDataHead( 2, { Z=EMT.L3, S=Speed}) - end - end - end - -- altrimenti sega a catena - else - EmitMoveDataHead( 2, { X=-ParkCSawX2, Z=ParkCSawZ2, B=ParkCSawB2, C=ParkCSawC2, 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) @@ -1642,8 +1172,10 @@ function OnRapid() BhData.Y2 = EMT.L1 + EMT.Y2DELTA - ( EMT.X_OFF or 0) BhData.ViseY2 = 1 else - BhData.Y2 = ParkY2 - BhData.ViseY2 = 2 + if not EMT.LASTOPEISUNLOAD or GetV2ToCloseNum() then + BhData.Y2 = ParkY2 + BhData.ViseY2 = 2 + end end if GetV1ToCloseNum() then BhData.FinStatV1 = -3 @@ -1659,9 +1191,11 @@ function OnRapid() 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 + if not EMT.LASTOPEISUNLOAD then + BhData.IniStatV2 = 3 + EMT.V2POS = ParkV2 + BhData.V2 = EMT.V2POS + end end if EMT.W2DELTA then if EMT.TO_SPECSPLIT then @@ -1670,258 +1204,100 @@ function OnRapid() BhData.Pz5 = 1 end end + + -- se si è lanciato la scarico mascherato, ma devo muovere pinza o paratia lato scarico, aspetto i movimenti + if EMT.LASTOPEISUNLOAD and ( BhData.Y2 or BhData.IniStatV2) then + EMT.LASTOPEISUNLOAD = nil + EmitMoveWaitChars( 2) + end + EmitBeamHeadData( BhData) EMT.POSTROT = false EMT.RELOAD = false EMT.RELOAD2 = nil + EMT.SPLIT_Y1DELTA = 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.PLANEACTIVE = true - EMT.ZMAX = false - -- se standard - elseif EMT.FLAG == 0 or EMT.FLAG == 1 or EMT.FLAG == 2 then - if EMT.ISPROBING then - -- emetto movimenti in Zero macchina - EmitMoveDataHead( GetHeadSet( EMT.HEAD), { X=-EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, S=Speed}) - EmitMoveStartHead( GetHeadSet( EMT.HEAD)) - EmitMoveWaitHead( GetHeadSet( EMT.HEAD)) - else - 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 - EMT.PLANEACTIVE = true - 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 and nHSet~=22, ' 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 - end - -- se altrimenti risalita a Z max a fine lavorazione - elseif EMT.FLAG == 3 then - EMT.REFLOC = nil - EMT.IPLGL = false + + -- aggiusto assi + EMT.L2 = -EMT.L2 + + -- calcolo per piano generico + CalcInterpPlane() + EMT.REFLOC = true + -- trasformo i punti nel piano MyAdjustLinearAxes() EmtAdjustRotaryAxes() - -- se Split o Presplit lascio agganciata solo la pinza Y2 alla fine dei movimenti - local sNextTool = GetNextTool( EMT.MCHID, true) - -- 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' and EMT.TOOL ~= sNextTool ) or ( EMT.HEAD == 'H22' and EMT.TOOL ~= sNextTool) or EMT.MCHSPLIT - local CurrL3o = EMT.L3o - EMT.L3o = EMT.L3op - local bZMax = EmitZmax( true, true, bToXhome, EMT.R1p, EMT.R2p, EMT.MCHSPLIT) - EMT.L3o = CurrL3o - -- aggiorno quota finale trave dopo Zmax - EMT.L1o = EMT.TPOS - if bZMax then - EMT.ZMAX = true - ToolPreSelectionSingleHead( EMT.MCHID) - end + -- annullo precedenti per forzare scrittura + 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()) - -- se altrimenti movimento in Home - elseif EMT.FLAG == 4 then - -- non previsto - -- altrimenti errore - else - error( "Unknown Rapid flag") + EMT.PLANEACTIVE = true + + -- annullo precedenti per forzare scrittura + EMT.R1p = nil + EMT.R2p = nil + + -- emissione movimento + local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3').. + EmtGetAxis('R2')..EmtGetAxis('R1') + if #sAxes > 0 then + if EmitRapidInG1 then + local sFeed = ' F30000' + EmtOutput( 'G1' .. sAxes .. sFeed) + else + EmtOutput( 'G0' .. sAxes) + end + end end + + if bStdMachRapid then + -- trasformo i punti nel piano + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + -- emissione movimento + local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3').. + EmtGetAxis('R2')..EmtGetAxis('R1') + if #sAxes > 0 then + if EmitRapidInG1 then + local sFeed = ' F30000' + EmtOutput( 'G1' .. sAxes .. sFeed) + else + EmtOutput( 'G0' .. sAxes) + end + end + -- info da scrivere solo se lavorazione con piano di lavoro mantenuto da precedente + if #sPostMove > 0 then + EmtOutput( 'G157 EA2' .. sPostMove) + end + end + -- aggiorno valori come precedenti EMT.TPOS = EMT.L1o EmtUpdatePrev() + + -- si salva posizione assi rotanti + EMT.R1prec = EMT.R1 + EMT.R2prec = EMT.R2 + end --------------------------------------------------------------------- function OnLinear() - -- se tastatore - if EMT.ISPROBING then - if not EMT.PROBE then - local p3FirstPoint = Point3d( EMT.L1, EMT.L2, EMT.L3) - local p3SecondPoint = Point3d( EMT.L1p, EMT.L2p, EMT.L3p) - local dProbingDist = dist( p3FirstPoint, p3SecondPoint) * 2 - local vtE = Vector3d( EMT.EXTR) - local sFace, ProbePosZ - if AreSameVectorApprox( vtE, Y_AX()) then - sFace = EgtIf( BD.RIGHT_LOAD, 4, 2) - elseif AreSameVectorApprox( vtE, -Y_AX()) then - sFace = EgtIf( BD.RIGHT_LOAD, 2, 4) - elseif AreSameVectorApprox( vtE, Z_AX()) then - sFace = 3 - else - error( "PROBING DIRECTION NOT MANAGED") - end - local sProbeHead = ' ET' .. GetHeadSet( EMT.HEAD) - EmtOutput( 'G145 Z-'.. EgtNumToString( dProbingDist).. ' EF'..sFace..sProbeHead) - - -- tastatura attivata - EMT.PROBE = true - end - else - -- 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 and nHSet~=22, ' EU1', ' EU2')..sDouFlag..' EF'..GetFmaxClamp()) - EMT.PLANEACTIVE = true - -- 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 -end - ---------------------------------------------------------------------- -function OnArc() -- se necessario, impostazione riferimento locale - if EMT.REFLOC == 0 then + if not EMT.REFLOC then -- gruppo della testa local nHSet = GetHeadSet( EMT.HEAD) -- calcolo per piano generico CalcInterpPlane() - EMT.REFLOC = 1 + EMT.REFLOC = true -- salvo posizione attuale local OldL1 = EMT.L1 local OldL2 = EMT.L2 @@ -1937,8 +1313,89 @@ function OnArc() 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 and nHSet~=22, ' EU1', ' EU2')..sDouFlag..' EF'..GetFmaxClamp()) + EmtOutput( 'G142'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..EMT.IPLGLSTR..EgtIf( nHSet~=2, ' EU1', ' EU2')..sDouFlag..' EF'..GetFmaxClamp()) + EMT.PLANEACTIVE = true + -- 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, da questo movimento bisogna passare ad accoppiamento in parallelo + if not EMT.DBLHEADPARA and EMT.DOU_TYPE == 2 and + ( ( EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 105) or ( EMT.MCHTYPE == MCH_MY.POCKETING and EMT.FLAG == 405))then + EmtOutput( "G157 EE-1") + EMT.DBLHEADPARA = true + end + + -- se testa accoppiata in parallelo, in uscita si disaccoppia per tornare ad accoppiamento speculare + if EMT.DBLHEADPARA and + ( ( EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 104) or ( EMT.MCHTYPE == MCH_MY.POCKETING and EMT.FLAG == 404)) then + EmtOutput( "G157 EE1") + EMT.DBLHEADPARA = nil + 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) + + -- aggiorno valori come precedenti + EMT.TPOS = EMT.L1o + EmtUpdatePrev() +end + +--------------------------------------------------------------------- +function OnArc() + -- se necessario, impostazione riferimento locale + if not EMT.REFLOC then + -- gruppo della testa + local nHSet = GetHeadSet( EMT.HEAD) + -- calcolo per piano generico + CalcInterpPlane() + EMT.REFLOC = true + -- 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()) EMT.PLANEACTIVE = true -- emissione movimento local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3').. @@ -1961,6 +1418,13 @@ function OnArc() MyAdjustLinearAxes() EmtAdjustRotaryAxes() + -- se lavorazione in doppio, da questo movimento bisogna passare ad accoppiamento in parallelo + if not EMT.DBLHEADPARA and EMT.DOU_TYPE == 2 and + ( ( EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 105) or ( EMT.MCHTYPE == MCH_MY.POCKETING and EMT.FLAG == 405))then + EmtOutput( "G157 EE-1") + EMT.DBLHEADPARA = true + end + -- valori degli assi local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3').. EmtGetAxis('R1')..EmtGetAxis('R2') @@ -2163,9 +1627,6 @@ function PrepareMoveChar( sCmd, nInd) table.insert( EMT.MDCHAR, MDChar) EMT.Y1POS = MoveY1 or EMT.Y1POS EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS - if EMT.V1POS < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then - EMT.TO_XHOME = true - end end elseif Cmd[1] == '2' then local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV} @@ -2193,9 +1654,6 @@ function PrepareMoveChar( sCmd, nInd) end table.insert( EMT.MDCHAR, MDChar) EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS - if EMT.V1POS < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then - EMT.TO_XHOME = true - end 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') @@ -2222,9 +1680,6 @@ function PrepareMoveChar( sCmd, nInd) end table.insert( EMT.MDCHAR, MDChar) EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS - if EMT.V1POS < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then - EMT.TO_XHOME = true - end elseif Cmd[1] == '4' then -- richiesta movimento a ZMAX già gestita if Cmd[2] == '1' then @@ -2263,6 +1718,8 @@ function PrepareMoveChar( sCmd, nInd) EMT.V2NEXTPOS = tonumber( Cmd[3]) elseif Cmd[1] == '23' then EMT.W2DELTA = tonumber( Cmd[2]) + elseif Cmd[1] == '24' then + EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS end end @@ -2324,9 +1781,7 @@ function PrepareResidue( sCmd, nInd) 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 @@ -2498,9 +1953,7 @@ function PreparePreRotation( sCmd, nInd) 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 @@ -2657,22 +2110,6 @@ function GetMovesInAuxCmd( vAuxCmd) return false end ---------------------------------------------------------------------- -function GetDiffRotAxAtStart( R1, R2) - local nHSet = GetHeadSet( EMT.HEAD) - local HomeR1 = EgtGetAxisHomePos( EgtIf( nHSet == 1 or nHSet == 11, '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 or nHSet == 11, '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 @@ -2691,11 +2128,11 @@ function MyAdjustLinearAxes() local Len = EMT.TLEN + dAddLen + Mill2Offs local LenRef = Mill2Offs vtE = Vector3d( EMT.TDIR) * Len - Z_AX() * LenRef - elseif EMT.HEAD == 'H13' then + elseif EMT.HEAD == 'H13' or EMT.HEAD == 'H15' 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 + elseif EMT.HEAD == 'H23' then local Len = ( EMT.TDIST or ChSawLen) + Mill2Offs local LenRef = Mill2Offs vtE = Vector3d( EMT.ADIR) * Len - Z_AX() * LenRef @@ -2912,329 +2349,59 @@ function VerifyEmitRotation() end --------------------------------------------------------------------- -function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelta) - if bReset then - EmitResetMachining() - end - - if EMT.ISPROBING then - -- se lavorazione successiva con stessa testa non si va a Z massima - local nSetHead = GetHeadSet( EMT.HEAD) - local bIsFirstHead = ( nSetHead == 1 or nSetHead == 11) - local sToolNameNextProbe - local idProbeNextMachining = EgtGetNextActiveOperation( EMT.MCHID) - if idProbeNextMachining then - EgtSetCurrMachining( idProbeNextMachining) - sToolNameNextProbe = EgtGetMachiningParam( MCH_MP.TOOL) - EgtSetCurrMachining( EMT.MCHID) - end - if sToolNameNextProbe and bIsFirstHead and EMT.PREVTOOL_H1 == sToolNameNextProbe then - return false - elseif sToolNameNextProbe and not bIsFirstHead and EMT.PREVTOOL_H2 == sToolNameNextProbe then - return false - end - end - - -- se tastatura attiva, si disabilita la tastatura - -- gestione eventuale tastatura - local bStopProbing = EgtGetValInNotes( EMT.MCHUSERNOTES, 'PROBE', 'b') or EgtGetValInNotes( EMT.MCHUSERNOTES, 'END-PROBE', 'b') - if EMT.PROBE and bStopProbing then - EmtOutput( 'G145 Z-10 EF0') - EMT.PROBE = nil - end - - -- gruppo della testa - local nHSet = GetHeadSet( EMT.HEAD) - local dXPos = EgtIf( bUsePrevDelta, EMT.L2pp or EMT.L2o, EMT.L2o) - -- reset stato di testa in home - EMT.XHOME = nil - -- se testa 1 - if nHSet == 1 or nHSet == 11 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, EgtClamp( PrevR2, -90, 90)) - if EgtIf( BD.RIGHT_LOAD, -dXPos < -LimX1RotSaw, -dXPos > -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 = -dXPos ; 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 = -dXPos ; MovH.B = PrevR2 ; MovH.C = PrevR1 ; - EmitMoveDataHead( 1, MovH) - end - if bXhome then - EMT.XHOME = true - 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 - -- ribadisco movimento perchè in G141 si aspetta sempre tutti i valori - local MovH = { X = -dXPos, Z = EMT.L3o, B = PrevR2, C = PrevR1} - EmitMoveDataHead( 1, MovH) - EmitMoveDataHead( 1, { Z=dSafeZ1, B=dSafeB1}) - if EMT.R3 and abs( EMT.R3) < 0.1 then - EmitMoveDataHead( 1, { Z=ParkCSawZ1}) - end - EmitMoveDataHead( 1, { X=-dSafeX1, C=dSafeC1}) - if bXhome then - EMT.XHOME = true - 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 = -dXPos ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ; - EmitMoveDataHead( 1, MovH) - EmitMoveDataHead( 1, { Z=dMaxZ1, B=0}) - EmitMoveDataHead( 1, { C=dSafeC1}) - EmitMoveDataHead( 1, { B=dSafeB1}) - EmitMoveDataHead( 1, { Z=dMaxZ1}) - else - local MovH = { Z = dMaxZ1} - MovH.X = -dXPos ; MovH.B = PrevR2 ; MovH.C = PrevR1 ; - EmitMoveDataHead( 1, MovH) - end - if bXhome then - EMT.XHOME = true - EmitMoveDataHead( 1, { X=-dSafeX1}) - end - EmitMoveStartHead( 1) - EmitMoveWaitHead( 1) - -- altrimenti sega a catena - else - -- ribadisco movimento perchè in G141 si aspetta sempre tutti i valori - local MovH = { X = -dXPos, Z = EMT.L3o, B = PrevR2, C = PrevR1} - EmitMoveDataHead( 1, MovH) - -- controlla che l'ingombro della sega a catena non possa collidere durante il suo riposizionamento - local dChSawEncumbrance = sqrt( pow( EMT.TTOTLEN, 2) + pow( ChSawLen + MillOffs, 2)) - if EMT.ADIR and EMT.TDIR then - -- direzione versore sega a catena X- (copre anche eventuali inclinazioni in Y) - if EMT.TDIR[1] <= 0 then - -- ingombro massimo di quota Z (senza pivot) + ingombro massimo sega + altezza pezzo + altezza sicurezza - local dEncumbranceTot = EMT.L3o + MillOffs - dChSawEncumbrance - EMT.SB - 30 - -- nuova quota Z intermedia - local dZUp = EMT.L3o + ( DeltaTabZ - dEncumbranceTot) - -- se la nuova quota è minore della quota di parcheggio - if dZUp <= ParkCSawZ1 then - -- se B è oltre il punto di massimo ingombro (con l'inclinazione attuale non ha il massimo ingombro) - if asin( EMT.TDIR[3] / 1) > asin( EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) / dChSawEncumbrance) and ( dEncumbranceTot < DeltaTabZ) then - EmitMoveDataHead( 1, { Z=dZUp}) - end - end - end - end - EmitMoveDataHead( 1, { Z=dSafeZ1, B=dSafeB1}) - if EMT.R3 and abs( EMT.R3) < 0.1 then - EmitMoveDataHead( 1, { Z=ParkCSawZ1}) - end - EmitMoveDataHead( 1, { X=-dSafeX1, C=dSafeC1}) - if bXhome then - EMT.XHOME = true - 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 = -dXPos ; 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 = -dXPos ; MovH.B = PrevR2 ; MovH.C = PrevR1 ; - EmitMoveDataHead( 2, MovH) - end - if bXhome then - EMT.XHOME = true - EmitMoveDataHead( 2, { X=-dSafeX2}) - end - EmitMoveStartHead( 2) - EmitMoveWaitHead( 2) - -- altrimenti sega a catena - else - -- ribadisco movimento perchè in G141 si aspetta sempre tutti i valori - local MovH = { X = -dXPos, Z = EMT.L3o, B = PrevR2, C = PrevR1} - EmitMoveDataHead( 2, MovH) - -- controlla che l'ingombro della sega a catena non possa collidere durante il suo riposizionamento - local dChSawEncumbrance = sqrt( pow( EMT.TTOTLEN, 2) + pow( ChSawLen + Mill2Offs, 2)) - if EMT.ADIR and EMT.TDIR then - -- direzione versore sega a catena X- (copre anche eventuali inclinazioni in Y) - if EMT.TDIR[1] <= 0 then - -- ingombro massimo di quota Z (senza pivot) + ingombro massimo sega + altezza pezzo + altezza sicurezza - local dEncumbranceTot = EMT.L3o + Mill2Offs - dChSawEncumbrance - EMT.SB - 30 - -- nuova quota Z intermedia - local dZUp = EMT.L3o + ( DeltaTabZ - dEncumbranceTot) - -- se la nuova quota è minore della quota di parcheggio - if dZUp <= ParkCSawZ2 then - -- se B è oltre il punto di massimo ingombro (con l'inclinazione attuale non ha il massimo ingombro) - if asin( EMT.TDIR[3] / 1) > asin( EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) / dChSawEncumbrance) and ( dEncumbranceTot < DeltaTabZ) then - EmitMoveDataHead( 2, { Z=dZUp}) - end - end - end - end - EmitMoveDataHead( 2, { Z=dSafeZ2, B=dSafeB2}) - if EMT.R3 and abs( EMT.R3) < 0.1 then - EmitMoveDataHead( 2, { Z=ParkCSawZ2}) - end - EmitMoveDataHead( 2, { X=-dSafeX2, C=dSafeC2}) - if bXhome then - EMT.XHOME = true - EmitMoveDataHead( 2, { X=-ParkX2, Z=ParkCSawZ2, B=ParkB2, C=ParkC2, TPos=50}) - end - EmitMoveStartHead( 2) - EmitMoveWaitHead( 2) - end - end - return true -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() +function EmitUnmountChainSaw() -- gruppo della testa local nHSet = GetHeadSet( EMT.HEAD) -- se testa 1 - if nHSet == 1 or nHSet == 11 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 + if nHSet == 1 then + EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=50}) 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 + EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ1, B=ParkB2, C=ParkC2, TPos=50}) EmitMoveStartHead( 2) EmitMoveWaitHead( 2) end end --------------------------------------------------------------------- -function EmitResetMachining() - if EMT.PLANEACTIVE and not EMT.ISPROBING then - -- se non sono a Z massima e operatore deve entrare in cabina spango sempre +function CalcRealSpeed( dSpeed) + -- in caso di aggregato lama, si aumenta speed perchè c'è un riduttore di giri + if EMT.HEAD == 'H12' or EMT.HEAD == 'H22' then + dSpeed = dSpeed * 1.65 + end + return dSpeed +end + +--------------------------------------------------------------------- +function EmitResetMachining( bNextTool) + if EMT.PLANEACTIVE then + local bChangeTool = ( bNextTool and EMT.TOOL ~= GetNextTool( EMT.MCHID)) or ( not bNextTool and EMT.TOOL ~= EMT.PREVTOOL) + -- se non sono a Z massima e operatore deve entrare in cabina spengo sempre if not EMT.ZMAX and ( GetSpecUnloading( EMT.PATHID) or GetFall( EMT.PATHID)) then EmtOutput( 'M05') -- altrimenti spegnimento dipende da parametro - elseif ( EMT.TOOL ~= GetNextTool( EMT.MCHID, false) and IsLastPath( EMT.PATHID)) or GetSpecUnloading( EMT.PATHID) or GetFall( EMT.PATHID) then + elseif ( bChangeTool and IsLastPath( EMT.PATHID)) or GetSpecUnloading( EMT.PATHID) or GetFall( EMT.PATHID) then EmtOutput( 'M05') end - local sOut = 'G157 EA1' - EmtOutput( sOut) + EmtOutput( 'G157 EA1') -- piano non più attivo EMT.PLANEACTIVE = false + EMT.REFLOC = nil + EMT.IPLGL = false end end --------------------------------------------------------------------- -function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta) +function EmitParkRoller( dPosT, bSplitCut, bAgg) -- 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) + local dY1Delta = EMT.Y1DELTA + local dY2Delta = EMT.Y2DELTA -- Parcheggi pinze - local MyParkY1 = ParkY1 + AggLoad + local MyParkY1 = ParkY1 + EgtIf( bAgg, AggLoad, 0) local MyParkY2 = ParkY2 -- le parcheggio local MDChar = {} @@ -3245,27 +2412,14 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta) local DiffY2 = MyParkY2 - dPosY2 --EmtOutput( string.format( 'PosT=%.3f DiffY1=%.3f DiffY2=%.3f', dPosT, DiffY1, DiffY2)) if bSplitCut then - local bYNoMove, bVNoMove - if DiffY1 > 0.1 then - bYNoMove = false - MDChar.Y1 = dPosY1 + DiffY1 - else - bYNoMove = true - MDChar.Y1 = dPosY1 - end - if DiffY2 < -0.1 then - bVNoMove = false - MDChar.Y2 = dPosY2 + DiffY2 - dPosT = dPosT + DiffY2 - else - bVNoMove = true - MDChar.Y2 = dPosY2 - end - -- se anche solo una morsa è restata in posizione, le sposto comunque entrambe di 5mm per distanziare i pezzi separati - if bYNoMove or bVNoMove then - MDChar.Y1 = MDChar.Y1 + 30 - MDChar.Y2 = MDChar.Y2 - 30 - end + local dAddMoveY1 = ParkV1 + ( -dPosT - EMT.LT) + local dAddMoveY2 = ParkV2 + ( -dPosT - EMT.LT) + local MoveY1 = max( DiffY1, dAddMoveY1, 30.0) + local MoveY2 = min( DiffY2, dAddMoveY2, -30.0) + MDChar.Y1 = dPosY1 + MoveY1 + MDChar.Y2 = dPosY2 + MoveY2 + dPosT = dPosT + MoveY2 + elseif DiffY1 > 0.1 and DiffY2 < -0.1 then EmtSetLastError( 1201, 'Error Collision in ParkRoller') elseif DiffY1 > 0.1 then @@ -3320,6 +2474,9 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta) MDChar.IniStatV2 = 3 MDChar.MovType = MDChar.MovType | 2 end + if EMT.SPLIT_Y1DELTA and EMT.SPLIT_Y1DELTA + dPosT < MyParkY1 then + MDChar.Y1 = MyParkY1 + end EmitMoveDataChars( MDChar) EmitMoveStartChars( MDChar.MovType) EmitMoveWaitChars( MDChar.MovType) @@ -3329,17 +2486,21 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta) end --------------------------------------------------------------------- --- Se la lavorazione segue una disposizione ha un utensile diverso da quello attuale lo cambia durante la disposizione +-- preselezione utensile su stessa testa (per C.U. mascherato in caso di cambio morse) function ToolPreSelectionSingleHead( nMchId) - -- Se non sono nell'ultima lavorazione della fase o se è una macchina a doppia testa ritorna senza fare nulla - local bIsPhaseEnd = ( EgtGetNextActiveOperation( nMchId) and EgtGetInfo( EgtGetNextActiveOperation( nMchId), 'TYPE') == 'END') - if not bIsPhaseEnd or EgtGetHeadId( 'H21') then + -- se macchina con due teste, devo preselezionare stessa testa quando ho motosega, altrimenti già fatta + if EgtGetHeadId( 'H21') and not HeadIsChainSaw( EMT.HEAD) then return end + + -- gruppo della testa + local nHSet = GetHeadSet( EMT.HEAD) + -- nome utensile - local sToolChange - local sToolChangePos - local sToolChangeHead + local sToolChange = nil + local sToolChangePos = nil + local sToolChangeHead = nil + local bCarrMove = false -- recupero lavorazione successiva e se contiene un utensile diverso salva utensile e posizione utensile local nNextMchId = EgtGetNextActiveOperation( nMchId) while nNextMchId do @@ -3347,34 +2508,78 @@ function ToolPreSelectionSingleHead( nMchId) if EgtSetCurrMachining( nNextMchId) then local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL) if EgtTdbSetCurrTool( sNextTool) then - if EMT.TOOL ~= sNextTool then - local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) - if not HeadIsChainSaw( sNextHead) then - sToolChange = sNextTool - sToolChangePos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS) - sToolChangeHead = sNextHead + local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) + local nNextHSet = GetHeadSet( sNextHead) + -- se stessa testa + if nNextHSet == nHSet then + if EMT.TOOL ~= sNextTool then + local nClId = EgtGetFirstNameInGroup( nNextMchId, 'CL') -- recupero Id del gruppo CL della lavorazione corrente + local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1) + local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari + if dAuxMoveCount > 3 then + bCarrMove = true + end + local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) + -- motosega non può essere preselezionata + if not HeadIsChainSaw( sNextHead) then + sToolChange = sNextTool + sToolChangePos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS) + sToolChangeHead = sNextHead + end end + break end - break end end end nNextMchId = EgtGetNextActiveOperation( nNextMchId) end + -- ripristino stato corrente EgtSetCurrMachining( EMT.MCHID) EgtTdbSetCurrTool( EMT.TOOL) - -- controlla se l'operazione successiva e quella ancora dopo esistono e sono disposizioni - local bNextOpIsDisp = ( EgtGetNextActiveOperation( nMchId) - and ( EgtGetOperationType( EgtGetNextActiveOperation( nMchId)) == MCH_OY.DISP) - and ( EgtGetNextActiveOperation( EgtGetNextActiveOperation( nMchId))) - and ( EgtGetOperationType( EgtGetNextActiveOperation( EgtGetNextActiveOperation( nMchId))) == MCH_OY.DISP)) - -- emetto preselezione utensile - if bIsPhaseEnd and bNextOpIsDisp then - if ( EMT.TOOL and sToolChangePos and sToolChange and sToolChangeHead) and EMT.TOOL ~= sToolChangePos and not HeadIsChainSaw( sToolChangeHead) then - local MyParkX1 = EgtIf( GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head1_TC2', ParkFrnX1, ParkX1) - EmitMoveDataHead( 1, { X=-MyParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sToolChangePos)}) - EmitMoveStartHead( 1) + + if bCarrMove or EgtGetHeadId( 'H21') then + -- se è stato trovato utensile, emetto preselezione + if sToolChangePos and sToolChange and sToolChangeHead then + local MyParkX, MyParkB, MyParkC + if GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head2_TC2' then + MyParkX = ParkX2 + MyParkZ = MaxZ2 + MyParkB = ParkB2 + MyParkC = ParkC2 + elseif GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head1_TC2' then + MyParkX = ParkFrnX1 + MyParkZ = MaxZ1 + MyParkB = ParkFrnB1 + MyParkC = ParkFrnC1 + else + MyParkX = ParkX1 + MyParkZ = MaxZ1 + MyParkB = ParkB1 + MyParkC = ParkC1 + end + + EmtOutput( '( *** TOOL PRE-SEL *** )') + EmitMoveDataHead( nHSet, { X=-MyParkX, Z=MyParkZ, B=MyParkB, C=MyParkC, TPos=AdjustTcPos( false, sToolChangePos)}) + -- comincio i movimenti di preselezione + EmitMoveStartHead( nHSet) + -- se preselezione e c'era montata motosega, si aspetta fine della preselezione prima di andare avanti + if HeadIsChainSaw( EMT.HEAD) then + EmitMoveWaitHead( nHSet) + else + EMT.START_PRESEL = nHSet + end + -- se non ho trovato utensile da preselezionare, e c'è motosetga montata, si scarica + elseif HeadIsChainSaw( EMT.HEAD) then + EmtOutput( '( *** UNMOUNT CHAIN-SAW *** )') + EmitUnmountChainSaw() + end + else + -- se ho motosega, scarico + if HeadIsChainSaw( EMT.HEAD) then + EmtOutput( '( *** UNMOUNT CHAIN-SAW *** )') + EmitUnmountChainSaw() end end end @@ -3402,6 +2607,8 @@ function PreselectNextDiffHead( nMchId, sHead) -- flag preselezione eseguita local bPresel = false + local bDoubleTool = false + local sDoubleTool = '' if bVerifyPresel then -- recupero lavorazione successiva @@ -3415,6 +2622,20 @@ function PreselectNextDiffHead( nMchId, sHead) local nNextHSet = GetHeadSet( sNextHead) if nNextHSet ~= nHSet then break + else + local sMachUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) + local nDouType = EgtGetValInNotes( sMachUserNotes, 'DOUBLE', 'i') + if nDouType == 2 then + local sToolUserNotes = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES) + local sOtherTool = EgtGetValInNotes( sMachUserNotes, 'TOOLDOUBLE', 's') or EgtGetValInNotes( sToolUserNotes, 'DOUBLE', 's') or '' + local sOldTool = EgtTdbGetCurrToolParam( MCH_TP.NAME) + if EgtTdbSetCurrTool( sOtherTool) and EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then + sDoubleTool = sOtherTool + bDoubleTool = true + end + EgtTdbSetCurrTool( sOldTool) + break + end end end end @@ -3424,6 +2645,10 @@ function PreselectNextDiffHead( nMchId, sHead) -- se esiste ed appartiene a gruppo diverso if nNextMchId and EgtSetCurrMachining( nNextMchId) then local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL) + -- se è una lavorazione in doppio, selezione altro utensile + if bDoubleTool then + sNextTool = sDoubleTool + end if EgtTdbSetCurrTool( sNextTool) then local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) local nNextHSet = GetHeadSet( sNextHead) diff --git a/Common_ONE-PF.mlpe b/Common_ONE-PF.mlpe index 28588a0..5048d2e 100644 --- a/Common_ONE-PF.mlpe +++ b/Common_ONE-PF.mlpe @@ -96,10 +96,6 @@ function OnSimulStart() if DefTcPos2 then LoadFirstTool( 2, DefTcPos2) end - - -- se presenti, nascondo i tastatori - DeactivateProbeTool() - ExecStartHome() -- Se reset o home, esco if EMT.SIM1ST then return end @@ -134,8 +130,7 @@ function OnSimulStart() { Grp = 'Base', Sub = 'COLLISION', Name = 'TC1'}, { Grp = 'Base', Sub = 'COLLISION', Name = 'TC2'}, { Grp = 'Base', Sub = 'BELT', Name = 'COLLISION'}, - { Grp = 'X1', Sub = 'COLLISION', Name = 'STM'}, - { Grp = 'X1', Sub = 'COLLISION', Name = 'STM2'}} + { Grp = 'X1', Sub = 'COLLISION', Name = 'STM'}} if EgtGetHeadId( 'H21') then table.insert( McdData, { Grp = 'X2', Sub = 'COLLISION', Name = 'STM'}) @@ -511,23 +506,37 @@ end --------------------------------------------------------------------- function OnSimulToolSelect( dPosA) + -- se utensile non definito, è disposizione ed esco + if EMT.TOOL == '' then return end + + -- recupero il gruppo + local nSetHead = GetHeadSet( EMT.HEAD) + + local bToolIsChanged = false + if ( nSetHead == 1 and EMT.TOOL ~= EMT.PREVTOOL_H1) or ( nSetHead == 2 and EMT.TOOL ~= EMT.PREVTOOL_H2) or dPosA then + bToolIsChanged = true + end + -- recupero dati utensile EMT.TOOLTYPE = EgtTdbGetCurrToolParam( MCH_TP.TYPE) EMT.TLEN = EgtTdbGetCurrToolParam( MCH_TP.LEN) EMT.TTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) EMT.TDIAM = EgtTdbGetCurrToolParam( MCH_TP.DIAM) EMT.TUSERNOTES = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES) - local nSetHead = GetHeadSet( EMT.HEAD) - local bIsFirstHead = ( nSetHead == 1 or nSetHead == 11) - EMT.ISPROBING = HeadIsProbe( EMT.HEAD) - -- se ho due teste, verifico che l'altra sia dalla parte opposta - if EgtGetHeadId( 'H21') then - if bIsFirstHead then - EgtSetAxisPos( 'X2', MinX2) - else - EgtSetAxisPos( 'X1', MaxX1) + + if bToolIsChanged then + -- disabilito la testa + EgtSetMode( EgtGetHeadId( EMT.HEAD) or GDB_ID.NULL, GDB_MD.HIDDEN) + -- vado a quota home testa attuale + if nSetHead == 1 then + SimulMoveAxes( 'X1', EgtGetAxisHomePos( 'X1'), MCH_SIM_STEP.RAPID, 'Z1', EgtGetAxisHomePos( 'Z1'), MCH_SIM_STEP.RAPID, + 'B1', EgtGetAxisHomePos( 'B1'), MCH_SIM_STEP.COLLROT, 'C1', EgtGetAxisHomePos( 'C1'), MCH_SIM_STEP.COLLROT) + elseif nSetHead == 2 then + SimulMoveAxes( 'X2', EgtGetAxisHomePos( 'X2'), MCH_SIM_STEP.RAPID, 'Z2', EgtGetAxisHomePos( 'Z2'), MCH_SIM_STEP.RAPID, + 'B2', EgtGetAxisHomePos( 'B2'), MCH_SIM_STEP.COLLROT, 'C2', EgtGetAxisHomePos( 'C2'), MCH_SIM_STEP.COLLROT) end end + -- se sega a catena, imposto subito angolo scelto per asse virtuale A if HeadIsChainSaw( EMT.HEAD) then -- apro le paratie @@ -544,7 +553,9 @@ function OnSimulToolSelect( dPosA) EgtSetAxisPos( 'B1', ParkCSawB1) EgtSetAxisPos( 'X1', ParkCSawX1) -- l'utensile viene caricato qui, quindi setto come già cambiato + EMT.PREVTOOL_H1 = EMT.TOOL EMT.PREVHEAD_H1 = EMT.HEAD + EMT.PREVTCPOS_H1 = EMT.TCPOS else -- imposto home dell'asse C2 (A=0 -> T111, A=-90 -> T112) local MyParkCSawC2 = GetChainSawCHomeFromVirtualAxis( dPosA) @@ -553,80 +564,17 @@ function OnSimulToolSelect( dPosA) EgtSetAxisPos( 'B2', ParkCSawB2) EgtSetAxisPos( 'X2', ParkCSawX2) -- l'utensile viene caricato qui, quindi setto come già cambiato + EMT.PREVTOOL_H2 = EMT.TOOL EMT.PREVHEAD_H2 = EMT.HEAD + EMT.PREVTCPOS_H2 = EMT.TCPOS end + end + + if bToolIsChanged then -- Imposto visualizzazione EgtSetMode( EgtGetHeadId( EMT.HEAD) or GDB_ID.NULL, GDB_MD.STD) end - -- se tastatore - if HeadIsProbe( EMT.HEAD) then - local bChanged = true - if bIsFirstHead then - -- se prossimo utensile compatibile, lo prelevo - if IsToolCompatibleWithProbe( EMT.PROBENEXTTOOL_H1, EMT.TOOL) then - ShowToolInTcPos( EMT.PREVTCPOS_H1, true) - EgtLoadTool( EMT.PROBENEXTHEAD_H1, 1, EMT.PROBENEXTTOOL_H1) - EMT.TCPOS = EMT.PROBENEXTTCPOS_H1 - EMT.HEAD = EMT.PROBENEXTHEAD_H1 - EMT.TOOL = EMT.PROBENEXTTOOL_H1 - else - -- se vecchio utensile compatibile, tengo quello caricato - if IsToolCompatibleWithProbe( EMT.PREVTOOL_H1, EMT.TOOL) then - bChanged = false - EMT.TCPOS = EMT.PREVTCPOS_H1 - EMT.TOOL = EMT.PREVTOOL_H1 - EMT.HEAD = EMT.PREVHEAD_H1 - -- altrimenti si seleziona utensile di default - else - ExecMoveZmax( EMT.MCHSPLIT, true) - EMT.TCPOS = DefTcPos1 - EMT.TOOL = GetToolNameFromTcPos( DefTcPos1) - EMT.HEAD, _ = GetToolHead( EMT.TOOL) - ShowToolInTcPos( EMT.PREVTCPOS_H1, true) - EgtLoadTool( EMT.HEAD, 1, EMT.TOOL) - end - end - -- se cambiato utensile, si setta subito nome precedente - if bChanged then - EMT.PREVTOOL_H1 = EMT.TOOL - EMT.PREVHEAD_H1 = EMT.HEAD - EMT.PREVTCPOS_H1 = EMT.TCPOS - end - else - -- se prossimo utensile compatibile, lo prelevo - if IsToolCompatibleWithProbe( EMT.PROBENEXTTOOL_H2, EMT.TOOL) then - ShowToolInTcPos( EMT.PREVTCPOS_H2, true) - EgtLoadTool( EMT.PROBENEXTHEAD_H2, 1, EMT.PROBENEXTTOOL_H2) - EMT.TCPOS = EMT.PROBENEXTTCPOS_H2 - EMT.HEAD = EMT.PROBENEXTHEAD_H2 - EMT.TOOL = EMT.PROBENEXTTOOL_H2 - else - -- se vecchio utensile compatibile, tengo quello caricato - if IsToolCompatibleWithProbe( EMT.PREVTOOL_H2, EMT.TOOL) then - bChanged = false - EMT.TCPOS = EMT.PREVTCPOS_H2 - EMT.TOOL = EMT.PREVTOOL_H2 - EMT.HEAD = EMT.PREVHEAD_H2 - -- altrimenti si seleziona utensile di default - else - ExecMoveZmax( EMT.MCHSPLIT, true) - EMT.TCPOS = DefTcPos2 - EMT.TOOL = GetToolNameFromTcPos( DefTcPos2) - EMT.HEAD, _ = GetToolHead( EMT.TOOL) - ShowToolInTcPos( EMT.PREVTCPOS_H2, true) - EgtLoadTool( EMT.HEAD, 1, EMT.TOOL) - end - end - -- se cambiato utensile, si setta subito nome precedente - if bChanged then - EMT.PREVTOOL_H2 = EMT.TOOL - EMT.PREVHEAD_H2 = EMT.HEAD - EMT.PREVTCPOS_H2 = EMT.TCPOS - end - end - end - -- carico utensile, con breve pausa EgtPause( 100) EgtOutText( '') @@ -638,260 +586,136 @@ function OnSimulToolSelect( dPosA) EMT.A2n = 'Y2' EMT.A3n = 'V1' EMT.A4n = 'V2' - -- se attivo Vmill - SetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL) + + -- se utensile non flottante, abilito per Vmill + if not EMT.TFLOAT then + EmtSetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL) + end -- se attivo Collision Check EMT.SAFEDIST = COLL_SAFE_DIST if EMT.COLLOBJ then - local nInd = EgtIf( EMT.HEAD ~= 'H21', 1001, 1011) - AddToolToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd) - AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd + 1) + local nInd = 1000 + tonumber( string.sub( EMT.HEAD, 2)) + AddToolToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd, true) + AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd + 100) for i, Coll in ipairs( EMT.COLLOBJ or {}) do EmtAddCollisionObjEx( i, Coll.Fr, Coll.Ty, Coll.Mv, Coll.P1, Coll.P2, Coll.P3) end end - -- salvataggio dati utensile rimandato a OnMachiningStart + + -- riabilito la testa + EgtSetMode( EgtGetHeadId( EMT.HEAD) or GDB_ID.NULL, GDB_MD.STD) + end --------------------------------------------------------------------- function OnSimulToolDeselect( dPrevA) - -- se utensile corrente è sega a catena, devo depositarla - if HeadIsChainSaw( EMT.PREVHEAD_H1) then - -- simulo movimento - SimulMoveAxis( 'X1', ParkCSawX1, MCH_SIM_STEP.RAPID) - local dMyParkC = EgtGetAxisHomePos( 'C1') - if dPrevA then dMyParkC = GetChainSawCHomeFromVirtualAxis( dPrevA) end - SimulMoveAxes( 'B1', ParkCSawB1, MCH_SIM_STEP.RAPROT, 'C1', dMyParkC, MCH_SIM_STEP.RAPROT) - -- visualizzo utensile su TcPos - ShowToolInTcPos( EMT.PREVTCPOS_H1, true) - -- nascondo l'utensile sulla testa - EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H1 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - -- se non è chiamata per cambio angolo di presa della sega a catena - if not dPrevA then - -- cambio utensile - EgtSetAxisPos( 'C1', ParkC1) - EgtSetAxisPos( 'B1', ParkB1) - EgtSetAxisPos( 'Z1', MaxZ1) - SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID) - LoadNextTool( 1, DefTcPos1) - end - elseif HeadIsChainSaw( EMT.PREVHEAD_H2) then - -- simulo movimento - SimulMoveAxis( 'X2', ParkCSawX2, MCH_SIM_STEP.RAPID) - local dMyParkC = EgtGetAxisHomePos( 'C2') - if dPrevA then dMyParkC = GetChainSawCHomeFromVirtualAxis( dPrevA) end - SimulMoveAxes( 'B2', ParkCSawB2, MCH_SIM_STEP.RAPROT, 'C2', dMyParkC, MCH_SIM_STEP.RAPROT) - -- visualizzo utensile su TcPos - ShowToolInTcPos( EMT.PREVTCPOS_H2, true) - -- nascondo l'utensile sulla testa - EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H2 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - -- se non è chiamata per cambio angolo di presa della sega a catena - if not dPrevA then - -- cambio utensile - EgtSetAxisPos( 'C2', ParkC2) - EgtSetAxisPos( 'B2', ParkB2) - EgtSetAxisPos( 'Z2', MaxZ2) - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - LoadNextTool( 2, DefTcPos2) - end - end - -- se presenti, nascondo i tastatori - DeactivateProbeTool() - local bSkipToolChange = false - -- se prossima lavorazione è tastatura, si controlla compatibilità con utensile successivo - if HeadIsProbe( EMT.NEXTHEAD) then - local idProbeMachining = EgtGetNextActiveOperation( EMT.MCHID) - local bFound = false - local nProbeHead = GetHeadSet( EMT.NEXTHEAD) - local idProbeNextMachining = EgtGetNextActiveOperation( idProbeMachining) - while not bFound do - if idProbeNextMachining then - EgtSetCurrMachining( idProbeNextMachining) - local sToolNameNextProbe = EgtGetMachiningParam( MCH_MP.TOOL) - if sToolNameNextProbe then - local sToolHeadNextProbe, sToolTcPosNextProbe = GetToolHead( sToolNameNextProbe) - local nToolHead = GetHeadSet( sToolHeadNextProbe) - -- se sono sulla stessa testa - if nToolHead == 1 and nProbeHead == 11 then - EMT.PROBENEXTTOOL_H1 = sToolNameNextProbe - EMT.PROBENEXTHEAD_H1 = sToolHeadNextProbe - EMT.PROBENEXTTCPOS_H1 = sToolTcPosNextProbe - bFound = true - elseif nToolHead == 2 and nProbeHead == 21 then - EMT.PROBENEXTTOOL_H2 = sToolNameNextProbe - EMT.PROBENEXTHEAD_H2 = sToolHeadNextProbe - EMT.PROBENEXTTCPOS_H2 = sToolTcPosNextProbe - bFound = true - end + -- se ToolDeselect chiamata da MLPE, bisogna scaricare perchè è ultimo movimento di rise e poi si cambia utensile + if dPrevA then + local dHeadSet = GetHeadSet( EMT.HEAD) + -- se utensile corrente è sega a catena, devo depositarla + if dHeadSet == 1 and HeadIsChainSaw( EMT.HEAD) then + -- visualizzo utensile su TcPos + ShowToolInTcPos( EMT.PREVTCPOS_H1, true) + -- nascondo l'utensile sulla testa + EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H1 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) + -- si cerca prossimo utensile + local sTool, sHead, sTcPos, bCarrMove = FindNextToolOnHeadSet( 1, false) + -- imposto correttamente i dati di testa + local OrigEMC = EMC + EMC = { HEAD = sHead or 'H11', TOOL = sTool, TCPOS = sTcPos, TOTDIAM = 0} + OnSetHead() + EMC = OrigEMC + -- se c'è prossimo utensile, oppure se non c'è e c'è un movimento carrelli + if sTool or ( not sTool and bCarrMove) then + + local dHomeX1 = EgtGetAxisHomePos( 'X1') + local dHomeC1 = EgtGetAxisHomePos( 'C1') + local dHomeB1 = EgtGetAxisHomePos( 'B1') + + -- cambio utensile + EgtSetAxisPos( 'C1', dHomeC1) + EgtSetAxisPos( 'B1', dHomeB1) + EgtSetAxisPos( 'Z1', MaxZ1) + SimulMoveAxis( 'X1', dHomeX1, MCH_SIM_STEP.RAPID) + if sTcPos then + LoadNextTool( 1, sTcPos) end - else - break end - idProbeNextMachining = EgtGetNextActiveOperation( idProbeNextMachining) - end - -- ripristino lavorazione corrente - EgtSetCurrMachining( EMT.MCHID) + elseif dHeadSet == 2 and HeadIsChainSaw( EMT.HEAD) then + -- visualizzo utensile su TcPos + ShowToolInTcPos( EMT.PREVTCPOS_H2, true) + -- nascondo l'utensile sulla testa + EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H2 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) + -- imposto correttamente i dati di testa + local sTool, sHead, sTcPos, bCarrMove = FindNextToolOnHeadSet( 2, false) + local OrigEMC = EMC + EMC = { HEAD = sHead or 'H21', TOOL = sTool, TCPOS = sTcPos, TOTDIAM = 0} + OnSetHead() + EMC = OrigEMC + -- se c'è prossimo utensile, oppure se non c'è e c'è un movimento carrelli + if sTool or ( not sTool and bCarrMove) then - if nProbeHead == 11 and not( IsToolCompatibleWithProbe( EMT.PREVTOOL_H1, EMT.TOOL)) then - ; - elseif nProbeHead == 21 and not( IsToolCompatibleWithProbe( EMT.PREVTOOL_H2, EMT.TOOL)) then - ; - else - bSkipToolChange = true + local dHomeX2 = EgtGetAxisHomePos( 'X2') + local dHomeC2 = EgtGetAxisHomePos( 'C2') + local dHomeB2 = EgtGetAxisHomePos( 'B2') + + -- cambio utensile + EgtSetAxisPos( 'C2', dHomeC2) + EgtSetAxisPos( 'B2', dHomeB2) + EgtSetAxisPos( 'Z2', MaxZ2) + SimulMoveAxis( 'X2', dHomeX2, MCH_SIM_STEP.RAPID) + if sTcPos then + LoadNextTool( 2, sTcPos) + end + end end + return end - -- reset flag sega a catena già depositata - EMT.CHSAW_OUT = nil + EMT.CHSAW_OUT = nil + -- se utensile non cambia e non è sega a catena, esco - if bSkipToolChange or ( ( EMT.NEXTTOOL == EMT.PREVTOOL_H1 or EMT.NEXTTOOL == EMT.PREVTOOL_H2) and not HeadIsChainSaw( EMT.NEXTHEAD)) then return end + if ( EMT.NEXTTOOL == EMT.PREVTOOL_H1 or EMT.NEXTTOOL == EMT.PREVTOOL_H2) and not HeadIsChainSaw( EMT.NEXTHEAD) then return end -- deposito utensile EgtOutText( 'Tool change in progress...') - -- se prossimo utensile sega a catena, devo mettere in home testa 1 e depositare l'utensile sulla testa 2 o viceversa - if HeadIsChainSaw( EMT.NEXTHEAD) then - -- salvo dati utensile - -- se ci sono due teste - if EgtGetHeadId( 'H21') then - local nSetHead = GetHeadSet( EMT.NEXTHEAD) - if nSetHead == 1 or nSetHead == 11 then - -- porto in home testa 1 - SimulMoveAxis( 'X1', MaxX1, MCH_SIM_STEP.RAPID) - -- deposito utensile fresa - if EMT.PREVHEAD_H2 == 'H21' then - -- simulo movimento - SimulMoveAxes( 'B2', ParkB2, MCH_SIM_STEP.RAPROT, 'C2', ParkC2, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - -- deposito utensile lama - elseif EMT.PREVHEAD_H1 == 'H22' then - -- simulo movimento - SimulMoveAxes( 'B2', ParkB2, MCH_SIM_STEP.RAPROT, 'C2', ParkC2, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - -- deposito utensile sega a catena - elseif HeadIsChainSaw( EMT.PREVHEAD_H2) then - ; -- già depositata - end - else - SimulMoveAxis( 'X2', MinX2, MCH_SIM_STEP.RAPID) - -- deposito utensile fresa - if EMT.PREVHEAD_H1 == 'H11' then - -- simulo movimento - SimulMoveAxes( 'B1', ParkB1, MCH_SIM_STEP.RAPROT, 'C1', ParkC1, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID) - -- deposito utensile lama - elseif EMT.PREVHEAD_H1 == 'H12' or EMT.PREVHEAD_H1 == 'H17' then - -- simulo movimento - SimulMoveAxes( 'B1', ParkB1, MCH_SIM_STEP.RAPROT, 'C1', ParkC1, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID) - -- deposito utensile sega a catena - elseif HeadIsChainSaw( EMT.PREVHEAD_H1) then - ; -- già depositata - end - end - -- altrimenti mi avvicino a CU dell'utensile che ho montato - else - local nSetHead = GetHeadSet( EMT.HEAD) - if nSetHead == 1 then - local MyParkX1 = EgtIf( GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1', ParkX1, ParkFrnX1) - SimulMoveAxis( 'X1', MyParkX1, MCH_SIM_STEP.RAPID) - else - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - end - end + + local dHeadSet = GetHeadSet( EMT.PREVHEAD) + + -- vado a quota home testa attuale + if dHeadSet == 1 then + SimulMoveAxes( 'X1', EgtGetAxisHomePos( 'X1'), MCH_SIM_STEP.RAPID, 'Z1', EgtGetAxisHomePos( 'Z1'), MCH_SIM_STEP.RAPID, + 'B1', EgtGetAxisHomePos( 'B1'), MCH_SIM_STEP.COLLROT, 'C1', EgtGetAxisHomePos( 'C1'), MCH_SIM_STEP.COLLROT) + elseif dHeadSet == 2 then + SimulMoveAxes( 'X2', EgtGetAxisHomePos( 'X2'), MCH_SIM_STEP.RAPID, 'Z2', EgtGetAxisHomePos( 'Z2'), MCH_SIM_STEP.RAPID, + 'B2', EgtGetAxisHomePos( 'B2'), MCH_SIM_STEP.COLLROT, 'C2', EgtGetAxisHomePos( 'C2'), MCH_SIM_STEP.COLLROT) + end + + local dNextHeadSet = GetHeadSet( EMT.NEXTHEAD) + + if dNextHeadSet == 1 then -- visualizzo utensile su TcPos ShowToolInTcPos( EMT.PREVTCPOS_H1, true) -- nascondo l'utensile sulla testa EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H1 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - -- breve pausa - EgtPause( 100) - -- se devo scaricare un utensile normale - else - local nSetHead = GetHeadSet( EMT.HEAD) - if nSetHead == 1 and EMT.PREVHEAD_H1 then - local MyParkX1 = EgtIf( GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1', ParkX1, ParkFrnX1) - SimulMoveAxis( 'X1', MyParkX1, MCH_SIM_STEP.RAPID) - elseif nSetHead == 2 and EMT.PREVHEAD_H2 then - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - end - end - -- recupero il prossimo gruppo - local nNextSetHead = GetHeadSet( EMT.NEXTHEAD) - -- per prossima testa gruppo 2 - if nNextSetHead == 2 then + elseif dNextHeadSet == 2 then -- visualizzo utensile su TcPos ShowToolInTcPos( EMT.PREVTCPOS_H2, true) -- nascondo l'utensile sulla testa EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H2 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - -- prendo utensile fresa - if EMT.NEXTHEAD == 'H21' then - -- simulo movimento - SimulMoveAxes( 'B2', ParkB2, MCH_SIM_STEP.RAPROT, 'C2', ParkC2, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID) - -- prendo utensile lama - elseif EMT.NEXTHEAD == 'H22' then - -- simulo movimento - SimulMoveAxes( 'B2', ParkB2, MCH_SIM_STEP.RAPROT, 'C2', ParkC2, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID) - -- prendo utensile sega a catena - elseif HeadIsChainSaw( EMT.NEXTHEAD) then - -- simulo movimento - SimulMoveAxes( 'B2', ParkCSawB2, MCH_SIM_STEP.RAPROT, 'C2', ParkCSawC2, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'Z2', ParkCSawZ2, MCH_SIM_STEP.RAPID) - end - -- per prossima testa gruppo 1 - elseif nNextSetHead == 1 then - -- visualizzo utensile su TcPos - ShowToolInTcPos( EMT.PREVTCPOS_H1, true) - -- nascondo l'utensile sulla testa - EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H1 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - -- prendo utensile fresa o lama - if EMT.NEXTHEAD == 'H11' or EMT.NEXTHEAD == 'H12' or EMT.NEXTHEAD == 'H17' then - local MyParkX1 = EgtIf( GetHeadTCSet( EMT.NEXTHEAD, EMT.NEXTTCPOS) == 'Head1_TC1', ParkX1, ParkFrnX1) - local MyParkB1 = ParkB1 - local MyParkC1 = ParkC1 - -- se ho due teste oppure è progress, significa che ho CU verticale - if EgtGetHeadId('H21') or Progress or SecondToolChanger then - MyParkB1 = EgtIf( GetHeadTCSet( EMT.NEXTHEAD, EMT.NEXTTCPOS) == 'Head1_TC1', ParkB1, ParkFrnB1) - MyParkC1 = EgtIf( GetHeadTCSet( EMT.NEXTHEAD, EMT.NEXTTCPOS) == 'Head1_TC1', ParkC1, ParkFrnC1) - -- altrimenti su one CU speciale motosega-utensile lungo - else - MyParkB1 = EgtIf( GetHeadTCSet( EMT.NEXTHEAD, EMT.NEXTTCPOS) == 'Head1_TC1', ParkB1, ParkLongToolB1) - MyParkC1 = EgtIf( GetHeadTCSet( EMT.NEXTHEAD, EMT.NEXTTCPOS) == 'Head1_TC1', ParkC1, ParkLongToolC1) - end - -- simulo movimento - SimulMoveAxes( 'B1', MyParkB1, MCH_SIM_STEP.RAPROT, 'C1', MyParkC1, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X1', MyParkX1, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID) - -- prendo utensile sega a catena - elseif HeadIsChainSaw( EMT.NEXTHEAD) then - -- simulo movimento - SimulMoveAxes( 'B1', ParkCSawB1, MCH_SIM_STEP.RAPROT, 'C1', ParkCSawC1, MCH_SIM_STEP.RAPROT) - SimulMoveAxis( 'X1', ParkCSawX1, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'Z1', ParkCSawZ1, MCH_SIM_STEP.RAPID) - end end + -- breve pausa + EgtPause( 100) + end --------------------------------------------------------------------- function OnSimulMachiningStart() -- se lavorazione attuale e precedente con sega a catena con angolo A diverso, devo scaricare e ricaricare if HeadIsChainSaw( EMT.HEAD) then - -- se anche precedente con sega a catena ma depositata, devo riprenderla + -- se la precedente ha rimosso la motosega, devo disattivarla, verrà riattivata dopo il movimento dei carrelli if EMT.CHSAW_OUT then - local dPosA = GetCurrChainSawingVirtualAxis() EgtSetMode( EgtGetHeadId( EMT.HEAD), GDB_MD.HIDDEN) - OnSimulToolDeselect() - OnSimulToolSelect( dPosA) - elseif ( EMT.HEAD == EMT.PREVHEAD_H2 and EMT.TCPOS == EMT.PREVTCPOS_H2) or EMT.HEAD == EMT.PREVHEAD_H1 then - local dPrevA = EgtGetAxisPos( 'A') - local dPosA = GetCurrChainSawingVirtualAxis() - if abs( dPosA - dPrevA) > 1 then - OnSimulToolDeselect( dPrevA) - EgtSetStatus( EgtGetHeadId( EMT.HEAD), GDB_ST.ON) - OnSimulToolSelect( dPosA) - end end end -- salvo dati utensile @@ -934,25 +758,11 @@ function OnSimulMachiningStart() EMT.DOU_TTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) EMT.DOU_TYPE = nDouType EMT.DOU_TOOL = sDouTool - -- reset necessità movimento in sicurezza sola testa in doppio - EMT.DOU_TO_ZMAX = nil else EmtSetLastError( 1211, 'Missing or not active double tool of '..sOldTool) end EgtTdbSetCurrTool( sOldTool) end - -- se precedente in doppio ma ora solo testa 1 e non in sicurezza - if EMT.DOU_TO_ZMAX then - -- parcheggio i rulli - local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT') - ExecParkRoller( nil, nil, nil, nil, false, bAgg) - -- eseguo - SimulMoveAxis( 'Z2', ParkZ2, MCH_SIM_STEP.RAPID) - SimulMoveAxes( 'B2', ParkB2, MCH_SIM_STEP.COLLROT, 'C2', ParkC2, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - EMT.DOU_TO_ZMAX = nil - end -- non ancora iniziata la lavorazione EMT.MCHFIRST = true end @@ -969,24 +779,31 @@ function OnSimulMachiningEnd() EMT.SPLIT = nil EMT.SPECSPLIT = nil EMT.TO_SPECSPLIT = nil - if EMT.DOU_TYPE and not EMT.ZMAX then EMT.DOU_TO_ZMAX = true end EMT.DOU_TYPE = nil EMT.DOU_TOOL = nil -- salvo dati utensile local nSetHead = GetHeadSet( EMT.HEAD) + + EMT.PREVTOOL = EMT.TOOL + EMT.PREVHEAD = EMT.HEAD + EMT.PREVTCPOS = EMT.TCPOS -- se non ho già tolto la sega a catena, aggiorno valori if not EMT.CHSAW_OUT then - -- per gruppo testa 1 + -- per gruppo testa 1 if nSetHead == 1 then EMT.PREVTOOL_H1 = EMT.TOOL EMT.PREVHEAD_H1 = EMT.HEAD EMT.PREVTCPOS_H1 = EMT.TCPOS + EMT.PREVTTOTLEN_H1 = EMT.TTOTLEN + EMT.PREVTCPOSREAL_H1 = EMT.TCPOSREAL -- per gruppo testa 2 elseif nSetHead == 2 then EMT.PREVTOOL_H2 = EMT.TOOL EMT.PREVHEAD_H2 = EMT.HEAD EMT.PREVTCPOS_H2 = EMT.TCPOS + EMT.PREVTTOTLEN_H2 = EMT.TTOTLEN + EMT.PREVTCPOSREAL_H2 = EMT.TCPOSREAL end end @@ -1010,6 +827,18 @@ function OnSimulPathStart() EMT.DELTA_LT = max( EMT.XMINT - Point3d( EMT.MMAX):getX() - dCosA * EMT.TDIAM / 2, 0) EgtOutLog( 'PreCutDeltaLT='..EgtNumToString( EMT.DELTA_LT, 3), 5) end + + -- si salvano gli approcci e retrazioni della lavorazione + EMT.APPROACH = {} + EMT.APPROACH.CLIMBS = EmtGetClimbs( EMT.PATHID) + EMT.APPROACH.RISES = EmtGetRises( EMT.PATHID) + if EMT.DBLPATHID then + EMT.APPROACH.DBLCLIMBS = EmtGetClimbs( EMT.DBLPATHID) + EMT.APPROACH.DBLRISES = EmtGetRises( EMT.DBLPATHID) + if not EMT.APPROACH.DBLCLIMBS or not EMT.APPROACH.DBLRISES then + EmtSetLastError( 1212, "UNEXPECTED ERROR on movements other head") + end + end end --------------------------------------------------------------------- @@ -1017,14 +846,12 @@ function OnSimulPathEnd() -- rimozione sfridi ExecRemoveScraps() -- se non ci sono comandi ausiliari associati e richiesta risalita a Zmax - if EMT.AUXTOT == 0 and EMT.TO_ZMAX then + if EMT.AUXTOT == 0 then if EMT.MCHSPLIT and not EMT.TO_FALL and not EMT.TO_SPECSPLIT then EMT.SPLIT_Y1DELTA = EMT.Y1DELTA EMT.Y1DELTA = nil ExecMovePY1( false) end - ExecMoveZmax( EMT.MCHSPLIT, false) - EMT.TO_ZMAX = nil end end @@ -1044,16 +871,31 @@ end function OnSimulPathEndAux() -- eseguo il comando ExecAuxCmd( EMT.AUX, false) - -- se ultimo comando e richiesta risalita a Zmax - if EMT.AUXIND == EMT.AUXTOT and EMT.TO_ZMAX then - ExecMoveZmax( EMT.MCHSPLIT, false) - EMT.TO_ZMAX = nil - end end --------------------------------------------------------------------- function OnSimulMoveStart() + + -- tipo di movimento + local bFirstClimb = EgtGetInfo( EMT.MOVEID, 'FirstClimb', 'b') + local bLastClimb = EgtGetInfo( EMT.MOVEID, 'LastClimb', 'b') + local bFirstRise = EgtGetInfo( EMT.MOVEID, 'FirstRise', 'b') + local bLastRise = EgtGetInfo( EMT.MOVEID, 'LastRise', 'b') + local bUniqueClimb = EgtGetInfo( EMT.MOVEID, 'UniqueClimb', 'b') + local bUniqueRise = EgtGetInfo( EMT.MOVEID, 'UniqueRise', 'b') + -- se il link non arriva dalla OnSpecial, non ha nessuna nota + local bStdClimb = ( EMT.FLAG2 ~= 2 and EMT.FLAG == 2) + local bStdRise = ( EMT.FLAG2 ~= 2 and EMT.FLAG == 3) + local bStdMachRapid = ( EMT.FLAG2 == 0 and ( EMT.FLAG == 0 or EMT.FLAG == 1)) + local sHeadToMoveFirst = EgtGetInfo( EMT.MOVEID, 'HeadToMoveFirst', 's') + + -- se primo rapido della lavorazione è un movimento standard, allora questo è l'ultimo climb + if bStdMachRapid and EMT.MCHFIRST then + bStdClimb = true + end if EMT.MCHFIRST then EgtOutText( '') end + -- recupero eventuali flag da Info del movimento + local bSplit = EgtGetInfo( EMT.MOVEID, 'Split', 'b') -- set della testa local nSetHead = GetHeadSet( EMT.HEAD) -- Posizioni correnti @@ -1070,7 +912,7 @@ function OnSimulMoveStart() EMT.A1 = EMT.L1 + EMT.Y1DELTA else EMT.A1m = nil - EMT.A1 = EgtIf( EMT.Y1SPEC, Y1Pos, ParkY1) + EMT.A1 = EgtIf( EMT.Y1SPEC or Y1Pos > ParkY1, Y1Pos, ParkY1) end EMT.A2n = 'Y2' if EMT.Y2DELTA then @@ -1080,21 +922,51 @@ function OnSimulMoveStart() EMT.A2m = nil EMT.A2 = ParkY2 end + + -- Controllo scorrimento pinze chiuse Y1 e Y2 + if EMT.Y1DELTA and ( EMT.MOVE ~= 0 or ( EMT.MASK & 1) == 1) then + local dY1DeltaP = Y1Pos - EMT.L1p + if abs( EMT.Y1DELTA - dY1DeltaP) > 0.1 then + EMT.ERR = 2 + local sErr = 'Y1 slide : ' .. EmtLenToString( dY1DeltaP, 3) .. ' -> ' .. EmtLenToString( EMT.Y1DELTA, 3) + EmtSetLastError( 1202, sErr) + end + end + if EMT.Y2DELTA and ( EMT.MOVE ~= 0 or ( EMT.MASK & 1) == 1) then + local dY2DeltaP = Y2Pos - EMT.L1p + if abs( EMT.Y2DELTA - dY2DeltaP) > 0.1 then + EMT.ERR = 2 + local sErr = 'Y2 slide : ' .. EgtNumToString( dY2DeltaP, 3) .. ' -> ' .. EgtNumToString( EMT.Y2DELTA, 3) + EmtSetLastError( 1202, sErr) + end + end + -- rulli EMT.A3n = 'V1' EMT.A3 = EgtIf( GetV1ToClose(), EMT.V1NEXTPOS, ParkV1) EMT.A4n = 'V2' EMT.A4 = EgtIf( GetV2ToClose(), EMT.V2NEXTPOS, ParkV2) local bParkV = false - if EMT.MCHFIRST then - -- se rulli più chiusi del richiesto o cambio direzione utensile (tranne solo asse B con C0 o equivalenti) devo mettere i rulli in parcheggio - if V1Pos < EMT.V1NEXTPOS - 1 or V2Pos > EMT.V2NEXTPOS + 1 or RollerParkingNeeded( EMT.HEAD, EMT.R1p, EMT.R2p, EMT.R1, EMT.R2) or - ( EMT.TOOL ~= EMT.PREVTOOL_H1 and EMT.TOOL ~= EMT.PREVTOOL_H2) then - bParkV = true - EMT.A3 = ParkV1 - EMT.A4 = ParkV2 - end + -- verifica se serve aprire i carrelli + local bCondBase = EMT.MCHFIRST or EMT.MOVE == 0 + local bCondPosition = V1Pos < EMT.V1NEXTPOS - 1 or + V2Pos > EMT.V2NEXTPOS + 1 or + RollerParkingNeeded( EMT.HEAD, EMT.R1p, EMT.R2p, EMT.R1, EMT.R2) + + if bCondBase and bCondPosition then + bParkV = true end + + local bNlhParkV = ( EMT.MOVE == 0 and (EMT.FLAG2 == 1 or EMT.FLAG2 == 2)) + if bNlhParkV then + bParkV = ( EMT.FLAG == 2 and bParkV) or ( not EMT.MCHSPLIT or bSplit) + end + + if bParkV or bNlhParkV then + EMT.A3 = ParkV1 + EMT.A4 = ParkV2 + end + -- pinza 5 if EMT.W2DELTA then EMT.A5n = 'W' @@ -1107,352 +979,196 @@ function OnSimulMoveStart() EMT.A5 = EMT.L1 + EMT.W2DELTA - EMT.A4 VerifyWStroke( EMT.A5) end + -- Controllo corse assi ausiliari VerifyY1Stroke( EMT.A1) VerifyY2Stroke( EMT.A2) VerifyV1Stroke( EMT.A3) VerifyV2Stroke( EMT.A4) - + -- se devo subito parcheggiare i rulli local nRes = 0 - if bParkV then - local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT') + if bParkV or bNlhParkV then + local bMchSplit = ( bNlhParkV and EMT.MCHSPLIT and bSplit) + local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT') -- se la lavorazione è un taglio di separazione, se necessario, ripristino posizione di Y1DELTA prima di aprire i rulli if EMT.SPLIT_Y1DELTA and not EMT.MCHSPLIT then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end - nRes = ExecParkRoller( Y1Pos, Y2Pos, V1Pos, V2Pos, false, bAgg) + nRes = ExecParkRoller( Y1Pos, Y2Pos, V1Pos, V2Pos, bMchSplit, bAgg) if EMT.SPLIT_Y1DELTA then EMT.Y1DELTA = nil end end - -- se movimento in rapido ad inizio lavorazione - if EMT.MOVE == 0 and EMT.MOVEIND <= 3 then - -- gestione speciale per pezzi molto alti. Se il movimento successivo è più alto del precedente, allora prendo il successivo - if EMT.L3s then - if EMT.L3s > EMT.L3 then - EMT.L3 = EMT.L3s - end - end - -- Dati - local B1Pos = EgtGetAxisPos( 'B1') - local B1Home = EgtGetAxisHomePos( 'B1') - local C1Pos = EgtGetAxisPos( 'C1') - local C1Home = EgtGetAxisHomePos( 'C1') - local Z1Pos = EgtGetAxisPos( 'Z1') - local Z1Home = EgtGetAxisHomePos( 'Z1') - -- se testa 1 - if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' then - -- se fresa o lama ('H11' o 'H12') - if not HeadIsChainSaw( EMT.HEAD) then - -- se movimento iniziale da Zmax con lama o fresa - if EMT.ZMAX or EMT.FLAG == 1 or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then - --EgtOutBox( 'Flag 2,1', 'Info Rapid') - local bMoveZbeforeX = false - - local dZref = EMT.L3 - if EMT.HEAD == 'H12' and ( EgtIf( BD.RIGHT_LOAD, -EMT.L2 < -LimX1RotSaw, -EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then - dZref = Z1Home + GetZExtra( EMT.HEAD, EMT.R2) - 100 - end - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - -- se vado in posizione speciale rotazione assi, poi devo ritornare alla X vera di lavoro - local dMoveXtoFinalPosition = false - local dXref = EMT.L2 - if EMT.HEAD == 'H12' and -EMT.L2 < -LimX1PlRotSaw then - dXref = LimX1PlRotSaw - SimulMoveAxis( 'X1', dXref, MCH_SIM_STEP.RAPID) - dZref = max( EMT.L3, Z1Home + GetZExtra( EMT.HEAD, EMT.R2)) - dMoveXtoFinalPosition = true - elseif not bMoveZbeforeX then - SimulMoveAxis( 'X1', dXref, MCH_SIM_STEP.RAPID) - else - SimulMoveAxis( 'X1', LimX1PlRotSaw, MCH_SIM_STEP.RAPID) - dZref = max( EMT.L3, Z1Home + GetZExtra( EMT.HEAD, EMT.R2)) - dMoveXtoFinalPosition = true - end - - -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379") - if EMT.HEAD == 'H12' and abs( C1Pos - EMT.R1) > 1 and ( abs( C1Home - EMT.R1) > 30.1 or abs(B1Home - EMT.R2) > 30.1) then - SimulMoveAxis( 'B1', 0, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - SimulMoveAxes( 'Z1', dZref, MCH_SIM_STEP.RAPID, 'B1', dBref, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - else - SimulMoveAxes( 'Z1', dZref, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - end - if bMoveZbeforeX then - SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID) - end - if dMoveXtoFinalPosition then - SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID) - end - -- caso standard - else - SimulMoveAxis( 'Z1', dZref, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - end - end - -- altrimenti sega a catena - else - local dPosA = GetCurrChainSawingVirtualAxis() - -- se anche precedente con sega a catena ma depositata, devo riprenderla - if EMT.CHSAW_OUT then - EgtSetMode( EgtGetHeadId( EMT.HEAD), GDB_MD.HIDDEN) - OnSimulToolDeselect() - EgtLoadTool( EMT.HEAD, 1, EMT.TOOL) - ShowToolInTcPos( EMT.TCPOS, false) - OnSimulToolSelect( dPosA) - -- recupero i dati dato che ho scaricato motosega e preso quelli dell'utensile di default - EmtModifyAxisHome( 'Z1', GetChainSawZHomeFromVirtualAxis( dPosA)) - EmtModifyAxisHome( 'C1', GetChainSawCHomeFromVirtualAxis( dPosA)) - EmtModifyAxisHome( 'B1', ParkCSawB1) - B1Home = EgtGetAxisHomePos( 'B1') - C1Home = EgtGetAxisHomePos( 'C1') - Z1Home = EgtGetAxisHomePos( 'Z1') - EMT.CHSAW_OUT = nil - end - -- se motosega configurata per lavorazioni di fianco o circa orizzontale - if dPosA == 0 or abs( EMT.R2) < 10 then - SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - -- se circa verticale - else - SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - end - end - -- altrimenti testa 2 - else - if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC2' then - -- se movimento iniziale da Zmax con lama o fresa - if EMT.HEAD == 'H11' or EMT.HEAD == 'H12' or EMT.HEAD == 'H17' then - if EMT.ZMAX or EMT.FLAG == 1 or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then - --EgtOutBox( 'Flag 2,1', 'Info Rapid') - local bMoveZbeforeX = false - - local dZref = EMT.L3 - if EMT.HEAD == 'H12' and ( EgtIf( BD.RIGHT_LOAD, -EMT.L2 < -LimX1RotSaw, -EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then - dZref = Z1Home + GetZExtra( EMT.HEAD, EMT.R2) - 100 - end - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - if not bMoveZbeforeX then - SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID) - else - SimulMoveAxis( 'X1', LimX1RotSawTC2, MCH_SIM_STEP.RAPID) - end - -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 400") - if EMT.HEAD == 'H12' and abs( C1Pos - EMT.R1) > 1 and ( abs( C1Home - EMT.R1) > 30.1 or abs(B1Home - EMT.R2) > 30.1) then - SimulMoveAxis( 'B1', 0, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - SimulMoveAxes( 'Z1', dZref, MCH_SIM_STEP.RAPID, 'B1', dBref, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - else - SimulMoveAxes( 'Z1', dZref, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - end - if bMoveZbeforeX then - SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID) - end - -- caso standard - else - SimulMoveAxis( 'Z1', dZref, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - end - end - -- altrimenti sega a catena (H13 o H15) - else - local dPosA = GetCurrChainSawingVirtualAxis() - -- se anche precedente con sega a catena ma depositata, devo riprenderla - if EMT.CHSAW_OUT then - EgtSetMode( EgtGetHeadId( EMT.HEAD), GDB_MD.HIDDEN) - OnSimulToolDeselect() - EgtLoadTool( EMT.HEAD, 1, EMT.TOOL) - ShowToolInTcPos( EMT.TCPOS, false) - OnSimulToolSelect( dPosA) - -- recupero i dati dato che ho scaricato motosega e preso quelli dell'utensile di default - EmtModifyAxisHome( 'Z1', GetChainSawZHomeFromVirtualAxis( dPosA)) - EmtModifyAxisHome( 'C1', GetChainSawCHomeFromVirtualAxis( dPosA)) - EmtModifyAxisHome( 'B1', ParkCSawB1) - B1Home = EgtGetAxisHomePos( 'B1') - C1Home = EgtGetAxisHomePos( 'C1') - Z1Home = EgtGetAxisHomePos( 'Z1') - EMT.CHSAW_OUT = nil - end - -- se motosega configurata per lavorazioni di fianco o circa orizzontale - if dPosA == 0 or abs( EMT.R2) < 10 then - SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - -- se circa verticale - else - SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - end - end - else - -- Dati - local B2Pos = EgtGetAxisPos( 'B2') - local B2Home = EgtGetAxisHomePos( 'B2') - local C2Pos = EgtGetAxisPos( 'C2') - local C2Home = EgtGetAxisHomePos( 'C2') - local Z2Pos = EgtGetAxisPos( 'Z2') - local Z2Home = EgtGetAxisHomePos( 'Z2') - -- se fresa o lama ('H21' o 'H22') - if not HeadIsChainSaw( EMT.HEAD) then - -- se movimento iniziale da Zmax con lama o fresa - if EMT.ZMAX or EMT.FLAG == 1 or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then - --EgtOutBox( 'Flag 2,1', 'Info Rapid') - local bMoveZbeforeX = false - local dZref = EMT.L3 - if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, -EMT.L2 < -LimX1RotSaw, -EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then - dZref = Z2Home + GetZExtra( EMT.HEAD, EMT.R2) - 100 - end - -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo - if EMT.L3 > dZref then - bMoveZbeforeX = true - end - if not bMoveZbeforeX then - SimulMoveAxis( 'X2', EMT.L2, MCH_SIM_STEP.RAPID) - else - SimulMoveAxis( 'X2', LimX2RotSaw, MCH_SIM_STEP.RAPID) - end - -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379") - if abs( C2Pos - EMT.R1) > 1 and ( abs( C2Home - EMT.R1) > 30.1 or abs( B2Home - EMT.R2) > 30.1) then - if EMT.HEAD == 'H22' then - SimulMoveAxis( 'B2', 0, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'C2', EMT.R1, MCH_SIM_STEP.COLLROT) - -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento - -- evita collisione con carro X - if EMT.R2 > 91 or EMT.R2 < -91 then - local dBref = EgtClamp( EMT.R2, -91, 91) - SimulMoveAxes( 'Z2', dZref, MCH_SIM_STEP.RAPID, 'B2', dBref, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'B2', EMT.R2, MCH_SIM_STEP.COLLROT) - else - SimulMoveAxes( 'Z2', dZref, MCH_SIM_STEP.RAPID, 'B2', EMT.R2, MCH_SIM_STEP.COLLROT) - end - if bMoveZbeforeX then - SimulMoveAxis( 'Z2', EMT.L3, MCH_SIM_STEP.RAPID) - end - -- caso standard - else - SimulMoveAxis( 'Z2', dZref, MCH_SIM_STEP.RAPID) - SimulMoveAxis( 'B2', EMT.R2, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'C2', EMT.R1, MCH_SIM_STEP.COLLROT) - if bMoveZbeforeX then - SimulMoveAxis( 'Z2', EMT.L3, MCH_SIM_STEP.RAPID) - end - end - end - end - -- altrimenti sega a catena - else - local dPosA = GetCurrChainSawingVirtualAxis() - -- se anche precedente con sega a catena ma depositata, devo riprenderla - if EMT.CHSAW_OUT then - EgtSetMode( EgtGetHeadId( EMT.HEAD), GDB_MD.HIDDEN) - OnSimulToolDeselect() - EgtLoadTool( EMT.HEAD, 1, EMT.TOOL) - ShowToolInTcPos( EMT.TCPOS, false) - OnSimulToolSelect( dPosA) - -- recupero i dati dato che ho scaricato motosega e preso quelli dell'utensile di default - EmtModifyAxisHome( 'Z2', GetChainSawZHomeFromVirtualAxis( dPosA)) - EmtModifyAxisHome( 'C2', GetChainSawCHomeFromVirtualAxis( dPosA)) - EmtModifyAxisHome( 'B2', ParkCSawB2) - B2Home = EgtGetAxisHomePos( 'B2') - C2Home = EgtGetAxisHomePos( 'C2') - Z2Home = EgtGetAxisHomePos( 'Z2') - EMT.CHSAW_OUT = nil - end - -- se motosega configurata per lavorazioni di fianco o circa orizzontale - if dPosA == 0 or abs( EMT.R2) < 10 then - SimulMoveAxes( 'X2', EMT.L2, MCH_SIM_STEP.RAPID, 'C2', EMT.R1, MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'Z2', EMT.L3, MCH_SIM_STEP.RAPID, 'B2', EMT.R2, MCH_SIM_STEP.COLLROT) - -- se circa verticale - else - SimulMoveAxes( 'X2', EMT.L2, MCH_SIM_STEP.RAPID, 'C2', EMT.R1, MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'Z2', EMT.L3, MCH_SIM_STEP.RAPID, 'B2', EMT.R2, MCH_SIM_STEP.COLLROT) - end - end - end - end + -- se anche precedente con sega a catena ma depositata, devo riprenderla + if EMT.CHSAW_OUT then + EgtLoadTool( EMT.HEAD, 1, EMT.TOOL) + ShowToolInTcPos( EMT.TCPOS, false) + local dPosA = GetCurrChainSawingVirtualAxis() + OnSimulToolSelect( dPosA) + EMT.CHSAW_OUT = nil end + -- se lavorazione split, muovo per riaggancio del carro Y1 - if EMT.SPLIT_Y1DELTA then + if EMT.SPLIT_Y1DELTA and ( EMT.MASK & 1) == 1 then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA EMT.A1 = EMT.L1 + EMT.Y1DELTA end - -- se Zmax dopo fine lavorazione - if EMT.MOVE == 0 and EMT.FLAG == 3 then - -- demando movimento completo a MoveEnd - EMT.EnabAxes = false - EMT.ShowAxes = true - end + -- se lavorazione in doppio - if EMT.DOU_TYPE == 2 and not ( EMT.MOVE == 0 and EMT.FLAG == 3) then - EMT.AuxAxes = 4 + 4 - EMT.A5n = 'X2' - local X2 = Delta2TabY - EMT.DOU_TLEN - ( -DeltaTabY + EMT.L2 - EMT.TLEN + EgtIf( BD.RIGHT_LOAD, -EMT.HB, EMT.HB)) - if EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 101 then - EMT.DOU_DRILL_END = EMT.L2p - EMT.L2 - X2 = X2 - 2 * EMT.DOU_DRILL_END + if EMT.DOU_TYPE then + if bFirstClimb or bUniqueClimb or bStdClimb then + EMT.IS_CLIMB = true + EMT.IS_RISE = false + EMT.INDEX_APPROACH_MOVE = 0 + elseif bFirstRise or bUniqueRise or bStdRise then + EMT.IS_CLIMB = false + EMT.IS_RISE = true + EMT.INDEX_APPROACH_MOVE = 0 end - EMT.A5 = X2 - EMT.A5m = nil - EMT.A6n = 'Z2' - local Z2 = -Head2Z + MillOffs - Mill2Offs + EMT.L3 - if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then - Z2 = MaxZ2 - end - EMT.A6 = min( Z2, MaxZ2) - EMT.A6m = EgtIf( ( EMT.MOVE == 2 or EMT.MOVE == 3), 'Z1', nil) - EMT.A7n = 'C2' - EMT.A7 = -EMT.R1 - EMT.A8n = 'B2' - EMT.A8 = -EMT.R2 - -- controllo minimo interasse tra X1 e X2 - local dDeltaX1X2 = EMT.L2 - EMT.A5 - Head2Y - if dDeltaX1X2 < MinDeltaX1X2 then - local sErr = 'X1 X2 charriots in collision (distance=' .. EgtNumToString( dDeltaX1X2, 1) .. ')' - EmtSetLastError( 1208, sErr) - end - -- controllo minima distanza tra utensili di X1 e X2 - local dDistToolX1X2 = dDeltaX1X2 - MillOffs - EMT.TTOTLEN - Mill2Offs - EMT.DOU_TTOTLEN - if dDistToolX1X2 < MinDistToolX1X2 then - local sErr = 'X1 X2 tools in collision (distance=' .. EgtNumToString( dDistToolX1X2, 1) .. ')' - EmtSetLastError( 1208, sErr) + + -- movimento con duplicato esatto + local nDblEntId = EgtGetInfo( EMT.MOVEID, 'Double', 'i') + if nDblEntId then + local vDblAx = EgtGetClEntAxesVal( nDblEntId) + EMT.AuxAxes = 4 + 4 + EMT.A5n = 'X2' + EMT.A5 = vDblAx[2] + EMT.A6n = 'Z2' + EMT.A6 = vDblAx[3] + EMT.A7n = 'C2' + EMT.A7 = vDblAx[4] + EMT.A8n = 'B2' + EMT.A8 = vDblAx[5] + -- controllo collisione tra utensili in doppio + -- doppio in orizzontale + if EMT.DOU_TYPE == 2 then + -- controllo minima distanza tra utensili di X1 e X2 + local dDeltaX1X2 = EMT.L2 - EMT.A5 - Head2Y + local dDistToolX1X2 = dDeltaX1X2 - MillOffs - EMT.TTOTLEN - Mill2Offs - EMT.DOU_TTOTLEN + if dDistToolX1X2 < MinDistToolX1X2 and EMT.MCHNAME ~= EMT.DOUBLECOLLMACH then + EMT.DOUBLECOLLMACH = EMT.MCHNAME + local sErr = 'X1 X2 tools in collision (distance=' .. EgtNumToString( dDistToolX1X2, 1) .. ')' + EmtSetLastError( 1208, sErr, true) + EgtOutBox( sErr, 'Double Machining', 'ERROR', 'OK') + end + end + + -- movimento di approccio o retrazione + else + local bFirstMoveOnlyH1 = sHeadToMoveFirst and sHeadToMoveFirst == 'H1' + local bFirstMoveOnlyH2 = sHeadToMoveFirst and sHeadToMoveFirst == 'H2' + -- se bisogna muovere prima la testa 2, si esegue subito il primo movimento della testa, priam di muovere la testa 1 + if bFirstMoveOnlyH2 then + if #EMT.APPROACH.DBLCLIMBS > 0 then + EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1 + EMT.A5 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L2 + EMT.A6 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L3 + EMT.A7 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R1 + EMT.A8 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R2 + SimulMoveAxes( 'X2', EMT.A5, MCH_SIM_STEP.RAPID, 'Z2', EMT.A6, MCH_SIM_STEP.RAPID, 'C2', EMT.A7, MCH_SIM_STEP.COLLROT, 'B2', EMT.A8, MCH_SIM_STEP.COLLROT) + end + -- se bisogna muovere prima la testa 1, il movimento della testa 2 non si esegue adesso + elseif not bFirstMoveOnlyH1 then + -- incremento indice approccio + EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1 + -- se non esiste movimento sulla testa due, significa che gli approcci della testa 1 sono in maggior numero + if ( EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE] and EMT.IS_CLIMB) or ( EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE] and EMT.IS_RISE) then + EMT.AuxAxes = 4 + 4 + EMT.A5n = 'X2' + EMT.A6n = 'Z2' + EMT.A7n = 'C2' + EMT.A8n = 'B2' + + if EMT.IS_CLIMB then + EMT.A5 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L2 + EMT.A6 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L3 + EMT.A7 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R1 + EMT.A8 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R2 + elseif EMT.IS_RISE then + EMT.A5 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L2 + EMT.A6 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L3 + EMT.A7 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R1 + EMT.A8 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R2 + end + end + end end end + -- se necessario ... - if EMT.MCHFIRST and bParkV then + if ( EMT.MCHFIRST or EMT.MOVE == 0) and EMT.EnabAxes ~= false then if nSetHead == 1 then - SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, - 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, - 'C1', EMT.R1, MCH_SIM_STEP.COLLROT, - 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) - else + if EMT.DOU_TYPE and EMT.AuxAxes == 8 then + SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, + 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, + 'C1', EMT.R1, MCH_SIM_STEP.COLLROT, + 'B1', EMT.R2, MCH_SIM_STEP.COLLROT, + 'X2', EMT.A5, MCH_SIM_STEP.RAPID, + 'Z2', EMT.A6, MCH_SIM_STEP.RAPID, + 'C2', EMT.A7, MCH_SIM_STEP.COLLROT, + 'B2', EMT.A8, MCH_SIM_STEP.COLLROT) + else + SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, + 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, + 'C1', EMT.R1, MCH_SIM_STEP.COLLROT, + 'B1', EMT.R2, MCH_SIM_STEP.COLLROT) + end + elseif nSetHead == 2 then SimulMoveAxes( 'X2', EMT.L2, MCH_SIM_STEP.RAPID, 'Z2', EMT.L3, MCH_SIM_STEP.RAPID, 'C2', EMT.R1, MCH_SIM_STEP.COLLROT, 'B2', EMT.R2, MCH_SIM_STEP.COLLROT) end end - if nRes ~= 0 then + + if EMT.DOU_TYPE then + -- se testa 2 ha più movimenti della testa 1, eseguo tutti i movimenti della testa due che mancano + if bLastClimb or bUniqueClimb then + if #EMT.APPROACH.DBLCLIMBS > #EMT.APPROACH.CLIMBS then + while EMT.INDEX_APPROACH_MOVE < #EMT.APPROACH.DBLCLIMBS do + EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1 + EMT.A5 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L2 + EMT.A6 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L3 + EMT.A7 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R1 + EMT.A8 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R2 + SimulMoveAxes( 'X2', EMT.A5, MCH_SIM_STEP.RAPID, 'Z2', EMT.A6, MCH_SIM_STEP.RAPID, 'C2', EMT.A7, MCH_SIM_STEP.COLLROT, 'B2', EMT.A8, MCH_SIM_STEP.COLLROT) + end + end + elseif bLastRise or bUniqueRise then + if #EMT.APPROACH.DBLRISES > #EMT.APPROACH.RISES then + while EMT.INDEX_APPROACH_MOVE < #EMT.APPROACH.DBLRISES do + EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1 + EMT.A5 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L2 + EMT.A6 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L3 + EMT.A7 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R1 + EMT.A8 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R2 + SimulMoveAxes( 'X2', EMT.A5, MCH_SIM_STEP.RAPID, 'Z2', EMT.A6, MCH_SIM_STEP.RAPID, 'C2', EMT.A7, MCH_SIM_STEP.COLLROT, 'B2', EMT.A8, MCH_SIM_STEP.COLLROT) + end + end + end + end + + if nRes ~= 0 and not bNlhParkV then EMT.A3 = EgtIf( GetV1ToClose(), EMT.V1NEXTPOS, ParkV1) EMT.A4 = EgtIf( GetV2ToClose(), EMT.V2NEXTPOS, ParkV2) end - EMT.ZMAX = nil - EMT.XHOME = nil + + -- se aggregato flottante su inizio attacco va compresso + if EMT.TFLOAT and not EMT.TFLOAT_CMP and EMT.MOVE == 1 and EgtGetName( EMT.MOVEID) == 'LI' then + -- recupero lunghezza + local dOffsL = - EgtGetMachiningParam( MCH_MP.OFFSL) + -- imposto compressione della parte flottante + SetFloatPos( EMT.HEAD, dOffsL) + -- imposto dati utensile in posizione compressa + EmtSetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL, 2, -dOffsL) + -- dichiaro che è compresso (assegnando Id entità di movimento) + EMT.TFLOAT_CMP = EMT.MOVEID + end + + -- reset movimenti + if EMT.IS_CLIMB and EMT.APPROACH.DBLCLIMBS and #EMT.APPROACH.DBLCLIMBS == EMT.INDEX_APPROACH_MOVE then + EMT.APPROACH.DBLCLIMBS = {} + elseif EMT.IS_RISE and EMT.APPROACH.DBLRISES and #EMT.APPROACH.DBLRISES == EMT.INDEX_APPROACH_MOVE then + EMT.APPROACH.DBLRISES = {} + end end --------------------------------------------------------------------- @@ -1462,8 +1178,8 @@ function OnSimulMoveEnd() ExecRemoveScraps() end - -- se primo rapido della lavorazione - if EMT.MCHFIRST and EMT.MOVE == 0 then + -- se rapido + if EMT.MOVE == 0 and ( EMT.MASK & 1) == 1 then -- se lavorazione split, dichiaro carro Y1 riagganciato if EMT.SPLIT_Y1DELTA then EMT.SPLIT_Y1DELTA = nil @@ -1493,25 +1209,32 @@ function OnSimulMoveEnd() EMT.MCHFIRST = false EgtOutText( '') end - -- se movimento finale di foratura in doppio in Z - if EMT.DOU_TYPE == 2 and EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 101 then - SimulMoveAxes( 1, 'X1', EMT.L2 + 2 * EMT.DOU_DRILL_END, MCH_SIM_STEP.FEED, - 'X2', EMT.A5 + 2 * EMT.DOU_DRILL_END, MCH_SIM_STEP.FEED) - SimulMoveAxes( 1, 'X1', EMT.L2 + EMT.DOU_DRILL_END, MCH_SIM_STEP.FEED, - 'X2', EMT.A5 + EMT.DOU_DRILL_END, MCH_SIM_STEP.FEED) + + -- se utensile flottante e movimento di compressione + if EMT.TFLOAT and EMT.MOVEID == EMT.TFLOAT_CMP then + -- verifico ci sia stata collisione tra ghiera flottante (portautensile e pezzo) + if not EMT.TFLOAT_TH_COMPR_COLL then + local sErr = 'CUTID='..tostring( EMT.CUTID)..'; TASKID='..tostring( EMT.TASKID)..'; Mach='..EMT.MCHNAME..'; Floating Ring not compressed on approach' + EmtSetLastError( 1222, sErr) + EgtOutLog( 'Error : ' .. sErr, 1) + else + EgtOutLog( 'Floating Ring compressed on approach (MOVEID='..EgtNumToString( EMT.MOVEID)..')', 1) + end + EMT.TFLOAT_TH_COMPR_COLL = nil end - -- se Zmax dopo fine lavorazione - if EMT.MOVE == 0 and EMT.FLAG == 3 then - -- eventuale rimozione sfridi - ExecRemoveScraps() - -- se Split o Presplit lascio agganciata solo la pinza Y2 alla fine dei movimenti - local sNextTool = GetNextTool( EMT.MCHID, true) - -- 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' and EMT.TOOL ~= sNextTool ) or ( EMT.HEAD == 'H22' and EMT.TOOL ~= sNextTool) or EMT.MCHSPLIT - -- eseguo - ExecMoveZmax( EMT.MCHSPLIT, bToXhome) - EMT.TO_ZMAX = nil + -- se aggregato flottante su fine uscita va rilasciato + if EMT.TFLOAT and EMT.TFLOAT_CMP and EMT.MOVE == 1 and EgtGetName( EMT.MOVEID) == 'LO' and EgtGetName( EgtGetNext( EMT.MOVEID) or GDB_ID.NULL) ~= 'LO' then + -- reset compressione della parte flottante + SetFloatPos( EMT.HEAD, 0) + -- dichiaro che è rilasciato + EMT.TFLOAT_CMP = nil + end + + local bLastRise = EgtGetInfo( EMT.MOVEID, 'LastRise', 'b') + -- se ultimo rapido e motosega, si va in home + if bLastRise and HeadIsChainSaw( EMT.HEAD) then + OnSimulToolDeselect( EMT.R3) + EMT.CHSAW_OUT = true end end @@ -1519,11 +1242,18 @@ end function OnSimulCollision() -- se prima collisione della lavorazione, la segnalo if EMT.MCHNAME ~= EMT.LAST_MCHNAME_COLLIDE then + -- speciale per utensile flottante (suo holder contro il grezzo) + if EMT.TFLOAT and EMT.TFLOAT_CMP and EMT.SIMCOBIND == 1002 and EMT.SIMVMID == EMT.VMILL[1] then + if EMT.MOVEID == EMT.TFLOAT_CMP then + EMT.TFLOAT_TH_COMPR_COLL = true + end + return + end local Class = '' - if EMT.SIMCOBIND == 1001 or EMT.SIMCOBIND == 1011 then - Class = 'T_'..EMT.HEAD - elseif EMT.SIMCOBIND == 1002 or EMT.SIMCOBIND == 1012 then - Class = 'TH_'..EMT.HEAD + if EMT.SIMCOBIND > 1000 and EMT.SIMCOBIND < 1099 then + Class = 'T_H'.. tostring( EMT.SIMCOBIND - 1000) + elseif EMT.SIMCOBIND > 1100 and EMT.SIMCOBIND < 1199 then + Class = 'TH_H'..tostring( EMT.SIMCOBIND - 1100) else Class = EMT.COLLOBJ[EMT.SIMCOBIND].Cl end @@ -1561,10 +1291,6 @@ function ExecAuxCmd( sCmd, bPathStart) ExecOpenRoller( 1) ExecOpenRoller( 2) local sV1, MoveV1, sV2, MoveV2 = CalcMoveV1V2ForAuxCmd( Cmd) - -- se stringo i rulli e ho lama, verifico che sia in home - if MoveV1 and MoveV1 < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then - ExecMoveZmax( false, true) - end local bOk, bOk1, bOk2, bOk3 = SimulMoveAxes( Cmd[2], tonumber( Cmd[3]), MCH_SIM_STEP.RAPID, sV1, MoveV1, MCH_SIM_STEP.RAPID, sV2, MoveV2, MCH_SIM_STEP.RAPID) @@ -1580,17 +1306,13 @@ function ExecAuxCmd( sCmd, bPathStart) end end end - elseif Cmd[1] == '2' then + elseif Cmd[1] == '2' or Cmd[1] == '24' then -- Verifico movimento carrello con trave agganciata VerifyOneChariotSlide( Cmd[2], Cmd[3], Cmd[4], Cmd[5]) -- Eseguo i movimenti necessari ExecOpenRoller( 1) ExecOpenRoller( 2) local sV1, MoveV1, sV2, MoveV2 = CalcMoveV1V2ForAuxCmd( Cmd) - -- se stringo i rulli e ho lama, verifico che sia in home - if MoveV1 and MoveV1 < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then - ExecMoveZmax( false, true) - end local bOk, bOk1, bOk2, bOk3, bOk4 = SimulMoveAxes( Cmd[2], tonumber( Cmd[3]), MCH_SIM_STEP.RAPID, Cmd[4], tonumber( Cmd[5]), MCH_SIM_STEP.RAPID, sV1, MoveV1, MCH_SIM_STEP.RAPID, @@ -1614,10 +1336,6 @@ function ExecAuxCmd( sCmd, bPathStart) ExecOpenRoller( 1) ExecOpenRoller( 2) local sV1, MoveV1, sV2, MoveV2 = CalcMoveV1V2ForAuxCmd( Cmd) - -- se stringo i rulli e ho lama, verifico che sia in home - if MoveV1 and MoveV1 < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then - ExecMoveZmax( false, true) - end local bOk, bOk1, bOk2, bOk3, bOk4, bOk5 = SimulMoveAxes( Cmd[2], tonumber( Cmd[3]), MCH_SIM_STEP.RAPID, Cmd[4], tonumber( Cmd[5]), MCH_SIM_STEP.RAPID, Cmd[6], tonumber( Cmd[7]), MCH_SIM_STEP.RAPID, @@ -1636,7 +1354,7 @@ function ExecAuxCmd( sCmd, bPathStart) end end elseif Cmd[1] == '4' then - ExecMoveHome( Cmd[2] == '1', EgtIf( bPathStart, false, EMT.MCHSPLIT)) + ExecMoveHome( Cmd[2] == '1') elseif Cmd[1] == '11' then local bClose = Cmd[2] ~= '0' if bPathStart and EMT.MCHSPLIT and not ( EMT.FALL or EMT.TO_FALL) and GetPY2Light() then bClose = false end @@ -1721,51 +1439,9 @@ function ExecStartHome() end --------------------------------------------------------------------- -function ExecMoveHome( bNearV, bMchSplit) - -- risalita a Zmax - ExecMoveZmax( bMchSplit, true) - EMT.TO_ZMAX = nil +function ExecMoveHome( bNearV) -- se richiesto, avvicino i rulli if bNearV then - -- se sega a catena su testa 1 devo prima depositarla - if HeadIsChainSaw( EMT.PREVHEAD_H1) then - -- visualizzo utensile su TcPos - ShowToolInTcPos( EMT.PREVTCPOS_H1, true) - -- nascondo l'utensile sulla testa - EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H1 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - -- cambio utensile - EgtSetAxisPos( 'C1', ParkC1) - EgtSetAxisPos( 'B1', ParkB1) - EgtSetAxisPos( 'Z1', MaxZ1) - SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID) - LoadNextTool( 1, DefTcPos1) - -- dichiaro sega a catena depositata - EMT.CHSAW_OUT = true - -- se sega a catena su testa 2 devo prima depositarla - elseif HeadIsChainSaw( EMT.PREVHEAD_H2) then - -- visualizzo utensile su TcPos - ShowToolInTcPos( EMT.PREVTCPOS_H2, true) - -- nascondo l'utensile sulla testa - EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H2 or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - -- cambio utensile - EgtSetAxisPos( 'C2', ParkC2) - EgtSetAxisPos( 'B2', ParkB2) - EgtSetAxisPos( 'Z2', MaxZ2) - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - LoadNextTool( 2, DefTcPos2) - -- dichiaro sega a catena depositata - EMT.CHSAW_OUT = true - end - -- porto le teste in home - if EgtGetHeadId( 'H21') then - SimulMoveAxes( 'X1', ParkX1, MCH_SIM_STEP.RAPID, 'X2', ParkX2, MCH_SIM_STEP.RAPID) - else - if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' then - SimulMoveAxes( 'X1', ParkX1, MCH_SIM_STEP.RAPID) - else - SimulMoveAxes( 'X1', ParkFrnX1, MCH_SIM_STEP.RAPID) - end - end -- sistemo i rulli ExecOpenRoller( 1) ExecOpenRoller( 2) @@ -1776,207 +1452,6 @@ function ExecMoveHome( bNearV, bMchSplit) end end ---------------------------------------------------------------------- -function ExecMoveZmax( bMchSplit, btoXHome) - -- set della testa - local nSetHead = GetHeadSet( EMT.HEAD) - if nSetHead == 0 then return end - local bIsFirstHead = ( nSetHead == 1 or nSetHead == 11) - - if EMT.ISPROBING then - -- se lavorazione successiva con stessa testa non si va a Z massima - local sToolNameNextProbe - local idProbeNextMachining = EgtGetNextActiveOperation( EMT.MCHID) - if idProbeNextMachining then - EgtSetCurrMachining( idProbeNextMachining) - sToolNameNextProbe = EgtGetMachiningParam( MCH_MP.TOOL) - EgtSetCurrMachining( EMT.MCHID) - end - local bMoveToZMax = true - if sToolNameNextProbe and bIsFirstHead and EMT.PREVTOOL_H1 == sToolNameNextProbe then - bMoveToZMax = false - elseif sToolNameNextProbe and not bIsFirstHead and EMT.PREVTOOL_H2 == sToolNameNextProbe then - bMoveToZMax = false - end - -- se non serve alzarsi - if not bMoveToZMax then - local vtE = Vector3d( EMT.EXTR) - local ProbePosZ - -- ci si riporta in posizione fuori ingombro pezzo - if AreSameVectorApprox( vtE, Y_AX()) or AreSameVectorApprox( vtE, -Y_AX()) then - ProbePosZ = EMT.TABORI1[3] + EMT.SB - if nSetHead == 1 then - SimulMoveAxis( 'Z1', ProbePosZ, MCH_SIM_STEP.RAPID) - else - SimulMoveAxis( 'Z2', ProbePosZ, MCH_SIM_STEP.RAPID) - end - end - return - end - end - - -- posizioni correnti degli assi testa - local CurrX = EgtGetAxisPos( EgtIf( bIsFirstHead, 'X1', 'X2')) - local CurrZ = EgtGetAxisPos( EgtIf( bIsFirstHead, 'Z1', 'Z2')) - local CurrC = EgtGetAxisPos( EgtIf( bIsFirstHead, 'C1', 'C2')) - local CurrB = EgtGetAxisPos( EgtIf( bIsFirstHead, 'B1', 'B2')) - -- posizioni home degli assi testa - local HomeX = EgtGetAxisHomePos( EgtIf( bIsFirstHead, 'X1', 'X2')) - local HomeZ = EgtGetAxisHomePos( EgtIf( bIsFirstHead, 'Z1', 'Z2')) - local HomeC = EgtGetAxisHomePos( EgtIf( bIsFirstHead, 'C1', 'C2')) - local HomeB = EgtGetAxisHomePos( EgtIf( bIsFirstHead, 'B1', 'B2')) - -- verifico se necessario ruotare la testa - local bRot = ( abs( HomeC - CurrC) > 1 or abs( HomeB - CurrB) > 1) - -- se necessario ruotare la testa, allargo i carrelli - if RollerParkingNeeded( EMT.HEAD, CurrC, CurrB, HomeC, HomeB) then - ExecOpenRoller( 1) - ExecOpenRoller( 2) - local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT') - ExecParkRoller( nil, nil, nil, nil, bMchSplit, bAgg) - end - -- se testa 1 - if bIsFirstHead then - -- se fresa o lama - if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' then - if not HeadIsChainSaw( EMT.HEAD) then - if abs( HomeC - CurrC) > 0.1 or abs( HomeB - CurrB) > 0.1 then - local dZref = HomeZ + GetZExtra( EMT.HEAD, EgtClamp( CurrB, -90, 90)) - if EgtIf( BD.RIGHT_LOAD, -CurrX < -LimX1RotSaw, -CurrX > -LimX1RotSaw) then - dZref = dZref - EgtIf( not Mortiser, 100, 370) - end - SimulMoveAxes( 'Z1', EgtIf( dZref > CurrZ, dZref, CurrZ), MCH_SIM_STEP.RAPID, 'B1', EgtClamp( CurrB, -90, 90), MCH_SIM_STEP.COLLROT) - if EMT.HEAD == 'H12' and ( abs( HomeC - CurrC) > 30.1 or abs( HomeB - CurrB) > 30.1) then - SimulMoveAxes( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID, 'B1', 0, MCH_SIM_STEP.COLLROT) - end - SimulMoveAxis( 'C1', HomeC, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'B1', HomeB, MCH_SIM_STEP.COLLROT) - end - SimulMoveAxis( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID) - if btoXHome then - EMT.XHOME = true - SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID) - end - -- se lavorazione in doppio - if EMT.DOU_TYPE == 2 then - local CurrZ2 = EgtGetAxisPos( 'Z2') - if CurrZ2 < ParkZ2 then - SimulMoveAxis( 'Z2', ParkZ2, MCH_SIM_STEP.RAPID) - end - SimulMoveAxes( 'B2', ParkB2, MCH_SIM_STEP.COLLROT, 'C2', ParkC2, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID) - if bToXHome then - EMT.XHOME = true - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - end - EMT.DOU_TO_ZMAX = nil - end - -- altrimenti sega a catena - else - SimulMoveAxes( 'Z1', HomeZ, MCH_SIM_STEP.RAPID, 'B1', HomeB, MCH_SIM_STEP.COLLROT) - if EMT.R3 and abs( EMT.R3) < 0.1 then - SimulMoveAxis( 'Z1', ParkCSawZ1, MCH_SIM_STEP.RAPID) - end - SimulMoveAxes( 'X1', HomeX, MCH_SIM_STEP.RAPID, 'C1', HomeC, MCH_SIM_STEP.COLLROT) - end - else - -- se fresa o lama - if not HeadIsChainSaw( EMT.HEAD) then - if abs( HomeC - CurrC) > 0.1 or abs( HomeB - CurrB) > 0.1 then - local dZref = HomeZ + GetZExtra( EMT.HEAD, CurrB) - SimulMoveAxes( 'Z1', EgtIf( dZref > CurrZ, dZref, CurrZ), MCH_SIM_STEP.RAPID, 'B1', EgtClamp( CurrB, -90, 90), MCH_SIM_STEP.COLLROT) - SimulMoveAxes( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID, 'B1', 0, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'C1', HomeC, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'B1', HomeB, MCH_SIM_STEP.COLLROT) - end - SimulMoveAxis( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID) - if btoXHome then - EMT.XHOME = true - SimulMoveAxis( 'X1', HomeX, MCH_SIM_STEP.RAPID) - end - -- altrimenti sega a catena - else - -- controlla che l'ingombro della sega a catena non possa collidere durante il suo riposizionamento - local dChSawEncumbrance = sqrt( pow( EgtTdbGetCurrToolParam( MCH_TP.TOTLEN), 2) + pow( ChSawLen + MillOffs, 2)) - if EMT.ADIR and EMT.TDIR then - -- direzione versore sega a catena X- (copre anche eventuali inclinazioni in Y) - if EMT.TDIR[1] <= 0 then - -- ingombro massimo di quota Z (senza pivot) + ingombro massimo sega + altezza pezzo + altezza sicurezza - local dEncumbranceTot = EMT.L3p + MillOffs - dChSawEncumbrance - EMT.SB - 30 - -- nuova quota Z intermedia - local dZUp = EMT.L3p + ( DeltaTabZ - dEncumbranceTot) - -- se la nuova quota è minore della quota di parcheggio - if dZUp <= ParkCSawZ1 then - -- se B è oltre il punto di massimo ingombro (con l'inclinazione attuale non ha il massimo ingombro) - if asin( EMT.TDIR[3] / 1) > asin( EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) / dChSawEncumbrance) and ( dEncumbranceTot < DeltaTabZ) then - SimulMoveAxis( 'Z1', dZUp, MCH_SIM_STEP.RAPID) - end - end - end - end - SimulMoveAxes( 'Z1', HomeZ, MCH_SIM_STEP.RAPID, 'B1', HomeB, MCH_SIM_STEP.COLLROT) - if EMT.R3 and abs( EMT.R3) < 0.1 then - SimulMoveAxis( 'Z1', ParkCSawZ1, MCH_SIM_STEP.RAPID) - end - if btoXHome then - EgtUnloadTool( EMT.HEAD, 1) - ShowToolInTcPos( EMT.TCPOS, true) - -- nascondo l'utensile sulla testa - EgtSetMode( EgtGetHeadId( EMT.HEAD or '') or GDB_ID.NULL, GDB_MD.HIDDEN) - EMT.CHSAW_OUT = true - EMT.XHOME = true - end - SimulMoveAxes( 'X1', HomeX, MCH_SIM_STEP.RAPID, 'C1', HomeC, MCH_SIM_STEP.COLLROT) - end - - end - -- altrimenti testa 2 - else - -- se fresa o lama - if not HeadIsChainSaw( EMT.HEAD) then - if abs( HomeC - CurrC) > 0.1 or abs( HomeB - CurrB) > 0.1 then - local dZref = HomeZ + GetZExtra( EMT.HEAD, CurrB) - SimulMoveAxes( 'Z2', EgtIf( dZref > CurrZ, dZref, CurrZ), MCH_SIM_STEP.RAPID, 'B2', EgtClamp( CurrB, -90, 90), MCH_SIM_STEP.COLLROT) - if EMT.HEAD == 'H22' and ( abs( HomeC - CurrC) > 30.1 or abs( HomeB - CurrB) > 30.1) then - SimulMoveAxes( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID, 'B2', 0, MCH_SIM_STEP.COLLROT) - end - SimulMoveAxis( 'C2', HomeC, MCH_SIM_STEP.COLLROT) - SimulMoveAxis( 'B2', HomeB, MCH_SIM_STEP.COLLROT) - end - SimulMoveAxis( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID) - if btoXHome then - EMT.XHOME = true - SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID) - end - -- altrimenti sega a catena - else - -- controlla che l'ingombro della sega a catena non possa collidere durante il suo riposizionamento - local dChSawEncumbrance = sqrt( pow( EgtTdbGetCurrToolParam( MCH_TP.TOTLEN), 2) + pow( ChSawLen + Mill2Offs, 2)) - if EMT.ADIR and EMT.TDIR then - -- direzione versore sega a catena X- (copre anche eventuali inclinazioni in Y) - if EMT.TDIR[1] <= 0 then - -- ingombro massimo di quota Z (senza pivot) + ingombro massimo sega + altezza pezzo + altezza sicurezza - local dEncumbranceTot = EMT.L3p + Mill2Offs - dChSawEncumbrance - EMT.SB - 30 - -- nuova quota Z intermedia - local dZUp = EMT.L3p + ( DeltaTabZ - dEncumbranceTot) - -- se la nuova quota è minore della quota di parcheggio - if dZUp <= ParkCSawZ2 then - -- se B è oltre il punto di massimo ingombro (con l'inclinazione attuale non ha il massimo ingombro) - if asin( EMT.TDIR[3] / 1) > asin( EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) / dChSawEncumbrance) and ( dEncumbranceTot < DeltaTabZ) then - SimulMoveAxis( 'Z2', dZUp, MCH_SIM_STEP.RAPID) - end - end - end - end - SimulMoveAxes( 'Z2', HomeZ, MCH_SIM_STEP.RAPID, 'B2', HomeB, MCH_SIM_STEP.COLLROT) - if EMT.R3 and abs( EMT.R3) < 0.1 then - SimulMoveAxis( 'Z2', ParkCSawZ2, MCH_SIM_STEP.RAPID) - end - SimulMoveAxes( 'X2', ParkCSawX2, MCH_SIM_STEP.RAPID, 'C2', HomeC, MCH_SIM_STEP.COLLROT) - end - end - EMT.ZMAX = true -end - --------------------------------------------------------------------- function ExecUnloading() if EMT.VMILL and #EMT.VMILL > 0 then @@ -2245,19 +1720,10 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg) local DiffY2 = MyParkY2 - PosY2 -- se appena eseguito taglio di separazione if bSpliCut then - local dAddMove - -- se entrambe le morse si spostano vado in posizione calcolata - if DiffY1 > 0.1 and DiffY2 < -0.1 then - dAddMove = 0 - -- se almeno una è rimasta ferma in posizione, allontano comunque di 30mm ulteriori - else - dAddMove = 30 - end - local MoveY1 = max( DiffY1, 0.0) - local MoveY2 = min( DiffY2, 0.0) - - MoveY1 = MoveY1 + dAddMove - MoveY2 = MoveY2 - dAddMove + local dAddMoveY1 = ParkV1 + ( -PosT - EMT.LR) + local dAddMoveY2 = ParkV2 + ( -PosT - EMT.LR) + local MoveY1 = max( DiffY1, dAddMoveY1, 30.0) + local MoveY2 = min( DiffY2, dAddMoveY2, -30.0) -- aggancio i pezzi rimanenti all'asse Y1 LinkRemainingPartsToY1() @@ -2270,6 +1736,8 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg) EMT.ERR = 2 EmtSetLastError( 1202, 'Error on MoveAxes in ParkRoller (12A)') end + EMT.Y1DELTA = nil + EMT.Y1SPEC = true return 32 elseif DiffY1 > 0.1 and DiffY2 < -0.1 then EMT.ERR = 2 @@ -2676,11 +2144,14 @@ function LoadNextTool( nHSet, sTcPosDef, bFirst) end --------------------------------------------------------------------- -function DeactivateProbeTool() - if Probe then - EgtSetMode( EgtGetHeadId( 'H19') or GDB_ID.NULL, GDB_MD.HIDDEN) - EgtSetMode( EgtGetHeadId( 'H29') or GDB_ID.NULL, GDB_MD.HIDDEN) - end +function IsNewLinkHead( sHead) + return ( sHead == 'H11' or sHead == 'H12' or sHead == 'H13' or sHead == 'H15' or sHead == 'H17' or sHead == 'H19' or + sHead == 'H21' or sHead == 'H22' or sHead == 'H23' or sHead == 'H29') +end + +--------------------------------------------------------------------- +function IsL1Enabled( nMask) + return ( ( nMask & 1) ~= 0) end --------------------------------------------------------------------- @@ -2703,7 +2174,7 @@ local FALL_T = 2 * ESTIMATION_RAPID_COEFF -- s --------------------------------------------------------------------- function OnEstimStart() EMT.INCHES = not EgtUiUnitsAreMM() -- unità di misura mm/inches - EMT.FMAXPINZE = EgtClamp( MaxFeedPinze or 102000, 20000, 102000) -- feed massima pinze + EMT.FMAXPINZE = MaxFeedPinze -- feed massima pinze EMT.MAXACC = MaxAcc or ( EMT.FMAXPINZE / ( 60 * 0.3)) -- accelerazione massima pinze EMT.MINACC = MinAcc or ( EMT.FMAXPINZE / ( 60 * 4)) -- accelerazione minima pinze end @@ -3068,6 +2539,12 @@ function IsMid2Phase( nPhase) return ( sVal == 'MID2') end +--------------------------------------------------------------------- +function IsEndPhase( nPhase) + local sVal = GetPhaseType( nPhase) + return ( sVal == 'END') +end + --------------------------------------------------------------------- function IsEnd2Phase( nPhase) local sVal = GetPhaseType( nPhase) @@ -3107,7 +2584,7 @@ function GetHeadSetFromTcPos( sTcPos) local TCPOS_2A = {} local TCPOS_2B = {} if EgtGetHeadId( 'H21') then - TCPOS_1A = { 'T1', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9', 'T10', '501'} + TCPOS_1A = { 'T1', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9', 'T10'} TCPOS_1B = { 'T101'} TCPOS_2A = { 'T11', 'T12', 'T13', 'T14', 'T15', 'T16', 'T17', 'T18', 'T19', 'T20'} TCPOS_2B = { 'T111'} @@ -3115,7 +2592,7 @@ function GetHeadSetFromTcPos( sTcPos) TCPOS_1A = { 'T1', 'T2', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9', 'T10'} TCPOS_1B = { 'T101', 'T201'} TCPOS_1C = { 'T301'} - TCPOS_2A = { 'T11', 'T12', 'T13', 'T14', 'T15', 'T16', 'T17', 'T18', 'T19', 'T20', '502'} + TCPOS_2A = { 'T11', 'T12', 'T13', 'T14', 'T15', 'T16', 'T17', 'T18', 'T19', 'T20'} end for _, sVal in ipairs( TCPOS_1A) do if sVal == sTcPos then return 1, 1 end @@ -3152,7 +2629,7 @@ function FindNextToolOnHeadSet( nHSet, bFirst) local CurrMachId = EgtGetCurrMachining() local CurrTool = EgtTdbGetCurrToolParam( MCH_TP.NAME) -- cerco lavorazione con utensile su gruppo testa indicato - local sTool, sHead, sTcPos + local sTool, sHead, sTcPos, bCarrMove local OpId if bFirst then OpId = EgtGetFirstActiveOperation() @@ -3163,12 +2640,23 @@ function FindNextToolOnHeadSet( nHSet, bFirst) local nType = EgtGetOperationType( OpId) if nType ~= MCH_OY.NONE and nType ~= MCH_OY.DISP then if EgtSetCurrMachining( OpId) then - local sTest = EgtGetMachiningParam( MCH_MP.TOOL) - if EgtTdbSetCurrTool( sTest) then - sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) - if GetHeadSet( sHead) == nHSet then - sTool = sTest - sTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS) + local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL) + if EgtTdbSetCurrTool( sNextTool) then + local nClId = EgtGetFirstNameInGroup( OpId, 'CL') -- recupero Id del gruppo CL della lavorazione corrente + local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1) + local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari + if dAuxMoveCount > 3 then + bCarrMove = true + end + local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) + if GetHeadSet( sNextHead) == nHSet then + if EMT.TOOL ~= sNextTool then + if not HeadIsChainSaw( sNextHead) then + sHead = sNextHead + sTool = sNextTool + sTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS) + end + end break end end @@ -3176,11 +2664,15 @@ function FindNextToolOnHeadSet( nHSet, bFirst) end OpId = EgtGetNextActiveOperation( OpId) end + -- se non c'è un operazione, significa che è fine pezzo, quindi si forza movimento carrelli perchè avverrà uno scarico + if not OpId then + bCarrMove = true + end -- ripristino stato iniziale EgtSetCurrMachining( CurrMachId or GDB_ID.NULL) EgtTdbSetCurrTool( CurrTool or '') -- restituisco risultato - return sTool, sHead, sTcPos + return sTool, sHead, sTcPos, bCarrMove end --------------------------------------------------------------------- diff --git a/Common_ONE-PF.mlse b/Common_ONE-PF.mlse index 07d954a..7b93c39 100644 --- a/Common_ONE-PF.mlse +++ b/Common_ONE-PF.mlse @@ -4,12 +4,6 @@ require( 'EmtGenerator') EgtEnableDebug( false) ---------------------------------------------------------------------- --- *** Generic Machinings *** ---------------------------------------------------------------------- -require( 'EmtGenMachining') ---------------------------------------------------------------------- - -- Carico libreria local BD = require( 'BeamData') @@ -72,218 +66,426 @@ function OnSpecialGetPrevMachiningOffset() end end ----------------------- OnSpecialGetMaxZ ----------------------------- --------------------------------------------------------------------- -local function CalcExtraZ( vtTp, vtT, vMZ) - -- la tabella deve esistere ed essere non vuota - if not vMZ or #vMZ == 0 then return 0 end - -- componente Z di riferimento è la minima - local vtTz = min( vtTp:getZ(), vtT:getZ()) - -- se oltre il massimo - if vtTz > vMZ[1].Tz then return vMZ[1].Ez end - -- interpolo - for i = 2, #vMZ do - if vtTz > vMZ[i].Tz then - local dCoeff = ( vtTz - vMZ[i-1].Tz) / ( vMZ[i].Tz - vMZ[i-1].Tz) - return (( 1 - dCoeff) * vMZ[i-1].Ez + dCoeff * vMZ[i].Ez) - end +-- *** Special Link moves *** +--------------------------------------------------------------------- +----------------------------------------------------------------------------------------- +local function IsPrevSplit() + local sPrevUserNotes = '' + if EMC.LINKTYPE == 2 then + sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) + elseif EMC.LINKTYPE == 3 then + EgtSetCurrMachining( EMC.PREVMCHID) + sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) + EgtSetCurrMachining( EMC.NEXTMCHID) end - -- sotto il minimo - return 0 + return ( sPrevUserNotes:find( 'Split;', 1, true) ~= nil) end ---------------------------------------------------------------------- -function OnSpecialGetMaxZ() - -- Inizializzazioni - EMC.ERR = 0 +----------------------------------------------------------------------------------------- +local function IsLinkSafe( vPrec, vNext) + local bSafeMove = true + local DirectionsToTest = { { Z=vPrec[3], C=vPrec[4], B=vPrec[5]}, { Z=vNext[3], C=vNext[4], B=vNext[5]}} - -- Gestione speciale per sega a catena su utesta 1 - if EMC.HEAD == 'H13' or EMC.HEAD == 'H15' then - EMC.MAXZ = EgtGetAxisHomePos( 'Z1') - return - -- Gestione speciale per sega a catena su testa 2 - elseif EMC.HEAD == 'H23' then - EMC.MAXZ = EgtGetAxisHomePos( 'Z2') - return - end + -- aggiungo anche il punto medio + table.insert( DirectionsToTest, { Z=( vNext[3] + vPrec[3]) / 2, C=( vNext[4] + vPrec[4]) / 2, B=( vNext[5] + vPrec[5]) / 2}) - -- Sistemazione dati di input - local vtTp = Vector3d( EMC.TDIRp) - local sHead_TC = GetHeadTCSet( EMC.HEAD, EMC.TCPOS) - local bFromZmax = false - if vtTp:isSmall() then - vtTp = X_AX() - bFromZmax = true - if sHead_TC == 'Head1_TC1' then - EMC.R1p = ParkC1 - EMC.R2p = ParkB1 - elseif sHead_TC == 'Head2_TC2' then - EMC.R1p = ParkC2 - EMC.R2p = ParkB2 - elseif sHead_TC == 'Head1_TC2' then - EMC.R1p = ParkFrnC1 - EMC.R2p = ParkFrnB1 + for t=1, #DirectionsToTest do + local vtToolDir = EgtGetCalcToolDirFromAngles( DirectionsToTest[t].C, DirectionsToTest[t].B) + -- se testa standard + if EMC.HEAD == 'H11' then + -- TODO considerare caso sotto la traversa + -- se sotto la traversa + if vtToolDir:getX() > -0.1 then + bSafeMove = true + end + -- se lama su aggregato + elseif EMC.HEAD == 'H12' then + -- se sotto la traversa + if vtToolDir:getX() < 0.342 then + local dLen = SawOffsZ - MillOffs + local dToolRadius = 275 -- leggere dall'utensile!! + local dNewOffZ = ( dLen * cos( DirectionsToTest[t].B) + dToolRadius * abs( sin( DirectionsToTest[t].B))) - dToolRadius + local dMaxZ = ParkZ1 - dNewOffZ + if dMaxZ < DirectionsToTest[t].Z then + bSafeMove = false + break + end + end end end - local vtT = Vector3d( EMC.TDIR) - local vtTpZm = EgtIf( bFromZmax, vtT, vtTp) - local bBSameSign = (( EMC.R2p < 10 and EMC.R2 < 10) or ( EMC.R2p > -10 and EMC.R2 > -10)) - -- Calcolo in funzione della testa e dei parametri + return bSafeMove +end + +----------------------------------------------------------------------------------------- +function OnSpecialLink() + + -- se fresa su testa 1 if EMC.HEAD == 'H11' then - if bBSameSign and vtTp:getX() > -0.1 and vtT:getX() > -0.1 then - EMC.MAXZ = MaxZ1 - else - local vMZ = {{ Tz=0.85, Ez=390}, { Tz=0.5, Ez=280}, { Tz=-0.01, Ez=160}, { Tz=-0.5, Ez=1}, { Tz=-0.61, Ez=1}} - EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ) - end - elseif ( EMC.HEAD == 'H12' or EMC.HEAD == 'H17') and sHead_TC == 'Head1_TC1' then - if vtTp:getX() > 0.4 and vtT:getX() > 0.4 then - if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then - EMC.MAXZ = MaxZ1 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130) - elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then - EMC.MAXZ = ParkZ1 + 200 - else - EMC.MAXZ = ParkZ1 + 1 + -- se inizio lavorazione con prelievo utensile + if EMC.LINKTYPE == 1 then + -- se lavorazione in doppio e altra ha collegamento diretto, si muove prima l'altra + local sHeadToMoveFirst = '' + if EMC.OTHERLINKTYPE == 3 then + sHeadToMoveFirst = 'HeadToMoveFirst=H2;' end - elseif bBSameSign and - (( EMC.R1p > 29.9 and EMC.R1p < 180.1 and EMC.R1 > 29.9 and EMC.R1 < 180.1 and EMC.R2p > -10 and EMC.R2 > -10) or - ( EMC.R1p > 179.9 and EMC.R1p < 330.1 and EMC.R1 > 179.9 and EMC.R1 < 330.1 and EMC.R2p < 10 and EMC.R2 < 10)) then - EMC.MAXZ = MaxZ1 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130) - elseif bBSameSign and - (( EMC.R1p > -0.1 and EMC.R1p < 180.1 and EMC.R1 > -0.1 and EMC.R1 < 180.1 and EMC.R2p > -10 and EMC.R2 > -10) or - ( EMC.R1p > 179.9 and EMC.R1p < 360.1 and EMC.R1 > 179.9 and EMC.R1 < 360.1 and EMC.R2p < 10 and EMC.R2 < 10)) then - local vMZ = {{ Tz=0.85, Ez=440}, { Tz=0.5, Ez=200}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}} - EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ) - else - local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=70}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}} - EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ) - end - elseif EMC.HEAD == 'H12' and sHead_TC == 'Head1_TC2' then - if vtTp:getX() > 0.4 and vtT:getX() > 0.4 then - if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then - EMC.MAXZ = MaxZ1 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130) - elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then - EMC.MAXZ = ParkZ1 + 200 - else - EMC.MAXZ = ParkZ1 + 1 + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;'..sHeadToMoveFirst) + -- se asse B resta girato verso home e C resta vicino alla home + if abs( EMC.R2 - EMC.R2p) < 90 and abs( EMC.R1 - EMC.R1p) < 5 then + ; -- discesa diretta + elseif abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2) + if abs( EMC.R1 - EMC.R1p) > 1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2) + end end - elseif bBSameSign and - (( EMC.R1p > -180.1 and EMC.R1p < -29.9 and EMC.R1 > -180.1 and EMC.R1 < -29.9 and EMC.R2p < 10 and EMC.R2 < 10) or - ( EMC.R1p > -330.1 and EMC.R1p < -179.9 and EMC.R1 > -330.1 and EMC.R1 < -179.9 and EMC.R2p > -10 and EMC.R2 > -10)) then - EMC.MAXZ = MaxZ1 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130) - elseif bBSameSign and - (( EMC.R1p > -180.1 and EMC.R1p < 0.1 and EMC.R1 > -180.1 and EMC.R1 < 0.1 and EMC.R2p < 10 and EMC.R2 < 10) or - ( EMC.R1p > -360.1 and EMC.R1p < -179.9 and EMC.R1 > -360.1 and EMC.R1 < -179.9 and EMC.R2p > -10 and EMC.R2 > -10)) then - local vMZ = {{ Tz=0.85, Ez=440}, { Tz=0.5, Ez=200}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}} - EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + + -- se fine lavorazione con deposito utensile + elseif EMC.LINKTYPE == 2 then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, 'FirstRise=1;') + if abs( EMC.R1 - EMC.R1p) > 1 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2) + end + else + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, 'FirstRise=1;') + end + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2, 'LastRise=1;') + + -- altrimenti collegamento tra due lavorazioni (3) else - local vMZ = {{ Tz=0.85, Ez=380}, { Tz=0.7, Ez=280}, { Tz=0.5, Ez=180}, { Tz=0.15, Ez=60}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}} - EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ) + -- recupero quota massima di collegamento + local vFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false) + local vInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false) + local bSafeMove = IsLinkSafe( vFinalAxLink, vInitAxLink) + + -- se gli assi rotanti non sono cambiati e il collegamento è come ultimo punto della lavorazione + if abs( EMC.R1 - EMC.R1p) < 1 and abs( EMC.R2 - EMC.R2p) < 1 and abs( EMC.L3p - vFinalAxLink[3]) < 1 and abs( EMC.L3 - vInitAxLink[3]) < 1 then + bSafeMove = true + end + + -- se superata quota massima ammessa + if not bSafeMove then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1, EMC.R1p, 0}, 30, 3, 2, 'UniqueRise=1;') + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + else + -- GESTIONE PER DOPPIO + -- se altra testa arriva da home, devo per forza avere un CLIMB, creo il punto + if EMC.OTHERLINKTYPE == 1 then + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, vInitAxLink, 30, 2, 2, 'FirstClimb=1;HeadToMoveFirst=H1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + -- se altra testa deve andare in home, devo per forza avere un RISE, creo il punto + elseif EMC.OTHERLINKTYPE == 2 then + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, vFinalAxLink, 30, 3, 2, 'UniqueRise=1;') + end + end end + + -- se lama su rinvio standard o opposto di testa 1 + elseif EMC.HEAD == 'H12' then + -- recupero se split da note utente di lavorazione precedente + local bSplit = IsPrevSplit() + + -- se inizio lavorazione con prelievo utensile + if EMC.LINKTYPE == 1 then + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2) + -- se asse B cambia di molto + if abs( 0 - EMC.R2p) > 1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2) + end + -- se assi cambiano di molto + if abs( EMC.R1 - EMC.R1p) > 10 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2) + end + + if abs( EMC.R2) > 75 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkZ1, EMC.R1, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 2) + end + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + + -- se fine lavorazione con deposito utensile + elseif EMC.LINKTYPE == 2 then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + -- se assi cambiano di molto + if abs( EMC.R1 - EMC.R1p) > 10 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2) + end + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2) + else + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + end + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2, 'LastRise=1;') + + -- altrimenti collegamento tra due lavorazioni (3) + else + -- recupero quota massima di collegamento + local vFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false) + local vInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false) + local bSafeMove = IsLinkSafe( vFinalAxLink, vInitAxLink) + + -- se gli assi rotanti non sono cambiati e il collegamento è come ultimo punto della lavorazione + if abs( EMC.R1 - EMC.R1p) < 1 and abs( EMC.R2 - EMC.R2p) < 1 and abs( EMC.L3p - vFinalAxLink[3]) < 1 and abs( EMC.L3 - vInitAxLink[3]) < 1 then + bSafeMove = true + end + + -- se superata quota massima ammessa + if not bSafeMove then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + if abs( EMC.R2) > 91 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, ParkZ1, EMC.R1p, EgtClamp( EMC.R2p, -90, 90)}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'LastRise=1;') + else + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'UniqueRise=1;') + end + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1Blade, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;') + if abs( EMC.R2) > 91 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkZ1, EMC.R1, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 2) + end + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + end + end + + -- se sega a catena su testa 1 + elseif EMC.HEAD == 'H13' or EMC.HEAD == 'H15' then + -- recupero se split da note utente di lavorazione precedente + local bSplit = IsPrevSplit() + -- se inizio lavorazione con prelievo utensile + if EMC.LINKTYPE == 1 then + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p, EMC.R3}, 30, 2, 2, 'FirstClimb=1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3}, 30, 2, 2) + if abs( EMC.R3) < 0.1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z1, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + else + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + end + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') + + -- se fine lavorazione con deposito utensile + elseif EMC.LINKTYPE == 2 then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2, EMC.R3p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3p}, 30, 3, 2, 'LastRise=1;') + -- altrimenti collegamento tra due lavorazioni (3) + else + end + + -- se aggregato foratore multiplo su testa 1 + elseif EMC.HEAD == 'H17' then + -- se inizio lavorazione con prelievo utensile + if EMC.LINKTYPE == 1 then + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2, 'LastClimb=1;') + else + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'UniqueClimb=1;') + end + + -- se fine lavorazione con deposito utensile + elseif EMC.LINKTYPE == 2 then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0, EMC.R3}, 30, 3, 2, 'FirstRise=1;') + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0, EMC.R3}, 30, 3, 2) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 30, 3, 2, 'LastRise=1;') + else + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 30, 3, 2, 'UniqueRise=1;') + end + -- altrimenti collegamento tra due lavorazioni (3) + else + end + + -- se fresa su testa 2 elseif EMC.HEAD == 'H21' then - if bBSameSign and vtTp:getX() > -0.1 and vtT:getX() > -0.1 then - EMC.MAXZ = MaxZ2 - else - local vMZ = {{ Tz=0.85, Ez=390}, { Tz=0.5, Ez=280}, { Tz=-0.01, Ez=160}, { Tz=-0.5, Ez=1}, { Tz=-0.61, Ez=1}} - EMC.MAXZ = ParkZ2 + CalcExtraZ( vtTpZm, vtT, vMZ) - end - elseif EMC.HEAD == 'H22' then - if vtTp:getX() > 0.4 and vtT:getX() > 0.4 then - if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then - EMC.MAXZ = MaxZ2 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130) - elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then - EMC.MAXZ = ParkZ2 + 200 + -- se inizio lavorazione con prelievo utensile + if EMC.LINKTYPE == 1 then + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;') + -- se asse B resta girato verso home e C resta vicino alla home + if abs( EMC.R2 - EMC.R2p) < 90 and abs( EMC.R1 - EMC.R1p) < 5 then + ; -- discesa diretta + elseif abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2) + if abs( EMC.R1 - EMC.R1p) > 1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2) + end + end + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + + -- se fine lavorazione con deposito utensile + elseif EMC.LINKTYPE == 2 then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, 'FirstRise=1;') + if abs( EMC.R1 - EMC.R1p) > 1 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2) + end else - EMC.MAXZ = ParkZ2 + 1 + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, 'FirstRise=1;') end - elseif bBSameSign and - (( EMC.R1p > -180.1 and EMC.R1p < -29.9 and EMC.R1 > -180.1 and EMC.R1 < -29.9 and EMC.R2p < 10 and EMC.R2 < 10) or - ( EMC.R1p > -330.1 and EMC.R1p < -179.9 and EMC.R1 > -330.1 and EMC.R1 < -179.9 and EMC.R2p > -10 and EMC.R2 > -10)) then - EMC.MAXZ = MaxZ2 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130) - elseif bBSameSign and - (( EMC.R1p > -180.1 and EMC.R1p < 0.1 and EMC.R1 > -180.1 and EMC.R1 < 0.1 and EMC.R2p < 10 and EMC.R2 < 10) or - ( EMC.R1p > -360.1 and EMC.R1p < -179.9 and EMC.R1 > -360.1 and EMC.R1 < -179.9 and EMC.R2p > -10 and EMC.R2 > -10)) then - local vMZ = {{ Tz=0.85, Ez=440}, { Tz=0.5, Ez=200}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}} - EMC.MAXZ = ParkZ2 + CalcExtraZ( vtTpZm, vtT, vMZ) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2, 'LastRise=1;') + + -- altrimenti collegamento tra due lavorazioni (3) + else + -- recupero quota massima di collegamento + local vFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false) + local vInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false) + local bSafeMove = IsLinkSafe( vFinalAxLink, vInitAxLink) + + -- se gli assi rotanti non sono cambiati e il collegamento è come ultimo punto della lavorazione + if abs( EMC.R1 - EMC.R1p) < 1 and abs( EMC.R2 - EMC.R2p) < 1 and abs( EMC.L3p - vFinalAxLink[3]) < 1 and abs( EMC.L3 - vInitAxLink[3]) < 1 then + bSafeMove = true + end + + -- se superata quota massima ammessa + if not bSafeMove then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1, EMC.R1p, 0}, 30, 3, 2, 'UniqueRise=1;') + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + else + -- GESTIONE PER DOPPIO + -- se altra testa arriva da home, devo per forza avere un CLIMB, creo il punto + if EMC.OTHERLINKTYPE == 1 then + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, vInitAxLink, 30, 2, 2, 'FirstClimb=1;HeadToMoveFirst=H2;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + end + end + end + + -- se lama su testa 2 + elseif EMC.HEAD == 'H22' then + -- recupero se split da note utente di lavorazione precedente + local bSplit = IsPrevSplit() + + -- se inizio lavorazione con prelievo utensile + if EMC.LINKTYPE == 1 then + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2) + -- se assi cambiano di molto + if abs( EMC.R1 - EMC.R1p) > 10 or abs( EMC.R2 - EMC.R2p) > 90 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2) + end + + if abs( EMC.R2) > 75 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkZ1, EMC.R1, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 2) + end + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + + -- se fine lavorazione con deposito utensile + elseif EMC.LINKTYPE == 2 then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2) + else + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + end + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2, 'LastRise=1;') + + -- altrimenti collegamento tra due lavorazioni (3) + else + -- recupero quota massima di collegamento + local vFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false) + local vInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false) + local bSafeMove = IsLinkSafe( vFinalAxLink, vInitAxLink) + + -- se gli assi rotanti non sono cambiati e il collegamento è come ultimo punto della lavorazione + if abs( EMC.R1 - EMC.R1p) < 1 and abs( EMC.R2 - EMC.R2p) < 1 and abs( EMC.L3p - vFinalAxLink[3]) < 1 and abs( EMC.L3 - vInitAxLink[3]) < 1 then + bSafeMove = true + end + + -- se superata quota massima ammessa + if not bSafeMove then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + if abs( EMC.R2) > 91 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, ParkZ1, EMC.R1p, EgtClamp( EMC.R2p, -90, 90)}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'LastRise=1;') + else + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'UniqueRise=1;') + end + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1Blade, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;') + if abs( EMC.R2) > 91 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkZ1, EMC.R1, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 2) + end + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') + end + end + -- se sega a catena su testa 2 + elseif EMC.HEAD == 'H23' then + -- recupero se split da note utente di lavorazione precedente + local bSplit = IsPrevSplit() + -- se inizio lavorazione con prelievo utensile + if EMC.LINKTYPE == 1 then + -- approccio + EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p, EMC.R3}, 30, 2, 2, 'FirstClimb=1;') + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3}, 30, 2, 2) + if abs( EMC.R3) < 0.1 then + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z2, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + else + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + end + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') + + -- se fine lavorazione con deposito utensile + elseif EMC.LINKTYPE == 2 then + -- retrazione + EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2, EMC.R3p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3p}, 30, 3, 2, 'LastRise=1;') + -- altrimenti collegamento tra due lavorazioni (3) else - local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=70}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}} - EMC.MAXZ = ParkZ2 + CalcExtraZ( vtTpZm, vtT, vMZ) end end -end - ----------------------- OnSpecialMoveZup ----------------------------- ---------------------------------------------------------------------- -function OnSpecialMoveZup() - - --EgtOutLog( 'OnSpecialMoveZup : ' .. EMC.HEAD .. '.' .. tostring( EMC.EXIT)) - - -- Inizializzazioni EMC.ERR = 0 - EMC.MODIF = false - - -- Direzione utensile - local vtT = Vector3d( EMC.TDIR) - - -- Posizione nel TC - local sHead_TC = GetHeadTCSet( EMC.HEAD, EMC.TCPOS) - - -- recupero Z1 home - local nHeadSet = GetHeadSet( EMC.HEAD) - local dZmax = EgtGetAxisHomePos( EgtIf( nHeadSet ~= 2, 'Z1', 'Z2')) - - -- se fresa su testa1 o su testa 2 - if EMC.HEAD == 'H11' or EMC.HEAD == 'H21' then - ; - -- se lama posizionata su CU prossimo a testa 1 - elseif ( EMC.HEAD == 'H12' or EMC.HEAD == 'H17') and sHead_TC == 'Head1_TC1' then - -- se inclinata oltre 90 gradi e interferisce con la trave - if ( EMC.R2 > 87.9 and ( EMC.R1 < 15.0 or EMC.R1 > 180.0)) or ( EMC.R2 < -87.9 and ( EMC.R1 > -15.0 and EMC.R1 < 180.0)) then - local dZref = dZmax + min( 330 * vtT:getZ(), 0) + 260 * ( 1 - sqrt( 1- vtT:getZ() * vtT:getZ())) - -- se troppo in alto - if EMC.L3 > dZref + 1 then - ---- sistemo asse rotante - --EMC.R2 = EgtIf( ( EMC.R2 > 0), 90, -90) - ---- ricalcolo versore utensile - --EMC.TDIR = EgtGetCalcToolDirFromAngles( EMC.R1, EMC.R2) - ---- porto alla giusta quota - --EMC.L3 = dZmax - EMC.L3 = dZref - -- dichiaro modificato - EMC.MODIF = true - end - end - -- se lama posizionata su CU prossimo a testa 2 - elseif ( EMC.HEAD == 'H12' and sHead_TC == 'Head1_TC2') or ( EMC.HEAD == 'H22' and sHead_TC == 'Head2_TC2') then - -- se inclinata oltre 90 gradi e interferisce con la trave - if ( EMC.R2 < -87.9 and ( EMC.R1 < -180.0 or EMC.R1 > -15.0)) or ( EMC.R2 > 87.9 and ( EMC.R1 < 15.0 and EMC.R1 > 180.0)) then - local dZref = dZmax + min( 330 * vtT:getZ(), 0) + 260 * ( 1 - sqrt( 1- vtT:getZ() * vtT:getZ())) - -- se troppo in alto - if EMC.L3 > dZref + 1 then - ---- sistemo asse rotante - --EMC.R2 = EgtIf( ( EMC.R2 > 0), 90, -90) - ---- ricalcolo versore utensile - --EMC.TDIR = EgtGetCalcToolDirFromAngles( EMC.R1, EMC.R2) - ---- porto alla giusta quota - --EMC.L3 = dZmax - EMC.L3 = dZref - -- dichiaro modificato - EMC.MODIF = true - end - end - elseif HeadIsChainSaw( EMC.HEAD) then - EMC.TTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - if EMC.TDIR[3] < -0.15 and EMC.L3 > - EMC.TTOTLEN then - EMC.L3 = EMC.TTOTLEN * EMC.TDIR[3] - -- dichiaro modificato - EMC.MODIF = true - end - end end - ---------- OnSpecialApplyDisposition & OnPostApplyMachining --------- ----------------------- Costanti ------------------------------------ local DELTA_SIC = 1 @@ -749,49 +951,23 @@ function OnSpecialApplyMachining() -- Inizializzo codice di errore EMC.ERR = 0 - - -- Recupero la precedente operazione - local nPrevOpeId = EgtGetPrevActiveOperation( EMC.MCHID) + EMC.ZMAX = false + EMC.ENDZMAX = false - -- Se esiste lavorazione precedente ed è una tastatura - if nPrevOpeId and EgtGetOperationType( nPrevOpeId) == MCH_OY.PROBING then - -- se stessa testa e montato già utensile corretto - -- recupero valori assi alla fine della lavorazione precedente e all'inizio della corrente - local vPrevAxes = EmtGetFinalAxesPos( nPrevOpeId, true) - local vCurrAxes = EmtGetInitialAxesPos( EMC.MCHID, true) - -- info lavorazione precedente - EgtSetCurrMachining( nPrevOpeId) - local sPrevTool = EgtGetMachiningParam( MCH_MP.TOOL) - local sPrevHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) - local nSetHead = GetHeadSet( sPrevHead) - local bPrevIsFirstHead = ( nSetHead == 1 or nSetHead == 11) - -- info lavorazione corrente - EgtSetCurrMachining( EMC.MCHID) - local sCurrTool = EgtGetMachiningParam( MCH_MP.TOOL) - local sCurrHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) - nSetHead = GetHeadSet( sCurrHead) - local bCurrIsFirstHead = ( nSetHead == 1 or nSetHead == 11) - - -- se utensile corrente è compatibile (significa che è già stato precaricato) se stessa testa e con stessa configurazioen assi rotanti, annullo risalita - if IsToolCompatibleWithProbe( sCurrTool, sPrevTool) and bPrevIsFirstHead == bCurrIsFirstHead and abs( vCurrAxes[4] - vPrevAxes[4]) < 1 and abs( vCurrAxes[5] - vPrevAxes[5]) < 1 then - -- in lavorazione precedente elimino eventuale retrazione a Zmax - EmtRemoveRise( nPrevOpeId) - -- in lavorazione corrente elimino eventuale approccio da Zmax - EmtRemoveClimb( EMC.MCHID) - -- prendo sempre la Z massima tra le due - local vClimbPoint - if vCurrAxes[3] - 1.0 < vPrevAxes[3] then - vClimbPoint = vCurrAxes - vCurrAxes[3] = vPrevAxes[3] - elseif vPrevAxes[3] - 1.0 < vCurrAxes[3] then - vClimbPoint = vPrevAxes - vPrevAxes[3] = vCurrAxes[3] - end - EmtAddClimb( EMC.MCHID, vClimbPoint, 4, 1, 0) - end + -- Verifico flag di separazione e fase di scarico + local sNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) + local bZMaxForced = false + if EgtGetValInNotes( sNotes, 'StartZmax', 's') == 'FORCED' then + bZMaxForced = true end + -- si cancella eventuale flag per risalita in ZMAX + sNotes = EgtSetValInNotes( sNotes, 'StartZmax') + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + + local sPrevTool, dPrevValR3 -- Recupero la posizione della trave e dei carrelli al termine della precedente operazione + local nPrevOpeId = EgtGetPrevActiveOperation( EMC.MCHID) -- se precedente operazione non esiste, errore if not nPrevOpeId then EMC.ERR = 1 @@ -864,6 +1040,18 @@ function OnSpecialApplyMachining() EMC.V1POS = EgtIf( bAtZMax, ParkV1, EgtGetInfo( nLastPathId, 'V1POS', 'd') or ParkV1) EMC.V2POS = EgtIf( bAtZMax, ParkV2, EgtGetInfo( nLastPathId, 'V2POS', 'd') or ParkV2) EMC.CNT = SpecGetCNT( EMC.MCHID) + if vAxes[6] then + -- imposto lavorazione e utensile correnti + EgtSetCurrMachining( nPrevOpeId) + dPrevValR3 = vAxes[6] + local sTool = EgtGetMachiningParam( MCH_MP.TOOL) + if not sTool then + local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID) + sTool = EgtTdbGetToolFromUUID( sTuuid) or '' + end + sPrevTool = sTool + EgtSetCurrMachining( EMC.MCHID) + end end -- Verifico se ultima lavorazione della fase @@ -874,7 +1062,6 @@ function OnSpecialApplyMachining() local bPreRotMch = IsLastOperationBeforeRotation( EMC.MCHID) -- Verifico flag di separazione e fase di scarico - local sNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) local bPreSplit = ( false and sNotes:find( 'Presplit', 1, true) ~= nil) local bSplitting = ( sNotes:find( 'Split', 1, true) ~= nil) local bPreCut = ( sNotes:find( 'Precut', 1, true) ~= nil) @@ -948,6 +1135,29 @@ function OnSpecialApplyMachining() local nLastEntId = EgtGetLastInGroup( EMC.PATHID) local vAxes = EmtGetAxesPos( nLastEntId) if #vAxes > 0 then EMC.TPOS = vAxes[1] end + -- controllo se serve cambiare la presa + if vAxes[6] and dPrevValR3 then + local sTool = EgtGetMachiningParam( MCH_MP.TOOL) + if not sTool then + local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID) + sTool = EgtTdbGetToolFromUUID( sTuuid) or '' + end + -- se stesso utensile ma cambia la presa dell'aggregato + if sTool == sPrevTool and abs( dPrevValR3 - vAxes[6]) > 10 * GEO.EPS_SMALL then + EMC.CHANGETAKE = true + end + end + end + + -- Se richiesto movimento preliminare della testa a Zmax perchè c'è stato un riposizionamento delle pinze + if EMC.ZMAX or bZMaxForced then + sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 11) + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + end + + if EMC.CHANGETAKE then + sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 12) + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) end end @@ -1071,8 +1281,17 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload, bPreR -- Se altrimenti carri entrambi diponibili, eseguo calcoli per carrelli elseif not IsEndPhase( EMC.PHASE) then local vCmd = SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1DeltaMaxSP, dY2DeltaMinUL, nChar, AuxInfoMach) + -- se fase iniziale e ci sono stati movimenti di carrelli + if IsStartPhase( EMC.PHASE) and #vCmd > 0 and IsFirstMachiningOfStart( EMC.MCHID) and + not bPreSplit and not bSplitting and not bPreCut and not bCutting then + local dLastTPos, dLastY1Delta = GetLastTPos( vCmd) + -- se testa oltre lo zero + if dLastTPos and dLastTPos < 0 then + -- si sposta testa in posizione carico + table.insert( vCmd, { 24, 'T', ParkV1, 'Y1', ParkV1 + dLastY1Delta}) + end -- Se non ci sono spostamenti, confermo i parametri di aggancio e di posizione roller - if SpecTestOnlyRemarkInCmds( vCmd) then + elseif SpecTestOnlyRemarkInCmds( vCmd) then table.insert( vCmd, { 21, EgtIf( EMC.Y1DELTA, EMC.Y1DELTA, 0), EgtIf( EMC.Y2DELTA, EMC.Y2DELTA, 0)}) table.insert( vCmd, { 22, dRollBack, -dRollFront}) end @@ -1226,40 +1445,33 @@ function SpecialCalcMachiningEncumbrance( nMchId, bPreCut) end -- Recupero testa local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) - local sToolName = EgtTdbGetCurrToolParam( MCH_TP.NAME) - local nSetHead = GetHeadSet( sHead) - local bIsFirstHead = ( nSetHead == 1 or nSetHead == 11) - - -- se lavorazione di tastatura, si considera montato utensile di default - if HeadIsProbe( sHead) then - local sOtherToolName = GetToolNameFromTcPos( EgtIf( bIsFirstHead, DefTcPos1, DefTcPos2)) - local sOtherHeadTool, _ = GetToolHead( sOtherToolName) - EgtLoadTool( sOtherHeadTool, 1, sOtherToolName) - end - - -- Recupero valore assi macchina - local nSecId = EgtGetNext( EgtGetFirstInGroup( nPathId)) - local vAxes = EmtGetAxesPos( nSecId) - if not vAxes or #vAxes < 5 or (( sHead == 'H13' or sHead == 'H15' or sHead == 'H23') and #vAxes < 6) then + -- Recupero minimi e massimi degli assi macchina della lavorazione + local vAxMin = EgtGetInfo( nClId, 'MAXMIN', 'vd') + local vAxMax = EgtGetInfo( nClId, 'MAXMAX', 'vd') + if not vAxMin or not vAxMax or #vAxMin < 5 or ( ( sHead == 'H13' or sHead == 'H15' or sHead == 'H23') and #vAxMin < 6) then EMC.ERR = 15 - EMC.MSG = ' Error : machine axes values not found' + EMC.MSG = ' Error : machine axes Min or Max not found' return end + local vAxMid = {} + for i = 1, #vAxMin do + vAxMid[i] = ( vAxMin[i] + vAxMax[i]) / 2 + end -- Calcolo dell'ingombro della testa rispetto allo Zero Macchina local b3Enc - - if bIsFirstHead then - EgtSetAxisPos( 'C1', vAxes[4]) - EgtSetAxisPos( 'B1', vAxes[5]) + + if sHead ~= 'H21' and sHead ~= 'H22' and sHead ~= 'H23' then + EgtSetAxisPos( 'C1', vAxMid[4]) + EgtSetAxisPos( 'B1', vAxMid[5]) if sHead == 'H13' or sHead == 'H15' then - EgtSetAxisPos( 'A', vAxes[6]) + EgtSetAxisPos( 'A', vAxMid[6]) end b3Enc = EgtGetBBoxGlob( EgtGetAxisId( 'C1'), GDB_BB.ONLY_VISIBLE) else - EgtSetAxisPos( 'C2', vAxes[4]) - EgtSetAxisPos( 'B2', vAxes[5]) + EgtSetAxisPos( 'C2', vAxMid[4]) + EgtSetAxisPos( 'B2', vAxMid[5]) if sHead == 'H23' then - EgtSetAxisPos( 'A', vAxes[6]) + EgtSetAxisPos( 'A', vAxMid[6]) end b3Enc = EgtGetBBoxGlob( EgtGetAxisId( 'C2'), GDB_BB.ONLY_VISIBLE) end @@ -1272,7 +1484,7 @@ function SpecialCalcMachiningEncumbrance( nMchId, bPreCut) EgtOutLog( ' RollFront = ' .. EgtNumToString( dRollFront, 1) .. ' RollBack = ' .. EgtNumToString( dRollBack, 1), 3) -- Calcolo della posizione della Punta Utensile rispetto allo Zero Macchina local ptTip - ptTip = EgtGetCalcTipFromPositions( 0, 0, 0, vAxes[4], vAxes[5], vAxes[6] or 0, false) + ptTip = EgtGetCalcTipFromPositions( 0, 0, 0, vAxMid[4], vAxMid[5], vAxMid[6] or 0, false) EgtOutLog( ' ToolTip = ' .. tostring( ptTip), 5) -- Calcolo dell'ingombro della testa rispetto alla Punta Utensile local dHeadFront = dRollFront + AGG_V - ptTip:getX() @@ -1282,7 +1494,6 @@ function SpecialCalcMachiningEncumbrance( nMchId, bPreCut) local dDistFront = - ptMax:getX() - LoadT - dHeadFront local dDistBack = ptMin:getX() + LoadT + EMC.LB - dHeadBack EgtOutLog( ' DistFront = ' .. EgtNumToString( dDistFront, 1) .. ' DistBack = ' .. EgtNumToString( dDistBack, 1), 3) - return dDistFront, dDistBack, dRollFront, dRollBack end @@ -1359,6 +1570,34 @@ function VerifyPartLength() return true end +--------------------------------------------------------------------- +function GetLastTPos( vCmd) + -- se esiste tabella comandi, si cerca l'ultima posizione della trave + if vCmd and #vCmd > 0 then + local dTRepos = nil + local dLastY1Delta = nil + -- controlla ogni gruppo di movimenti ausiliari + for i = 1, #vCmd do + local Command = vCmd[i] + -- controlla solo i movimenti della testa trave e salva l'ultimo + if Command[1] == 2 or Command[1] == 3 then + for j = 2, #Command-1 do + if Command[j] == 'T' then + dTRepos = Command[j+1] + break + end + end + elseif Command[1] == 21 then + dLastY1Delta = Command[2] + end + end + return dTRepos, dLastY1Delta + + else + return nil, nil + end +end + --------------------------------------------------------------------- function SpecCalcLoad( dPosT, dDistFront, dDistBack) --[L] @@ -2901,6 +3140,14 @@ function SpecOutputCmds( vCmd, bEnd) elseif Cmd[1] == 4 then local sInfo = '4,'..EgtNumToString( Cmd[2],0) EgtSetInfo( EMC.PATHID, sKey, sInfo) + -- se chiusura rulli + if Cmd[2] == 1 then + if bEnd then + EMC.ENDZMAX = true + else + EMC.ZMAX = true + end + end -- apertura/chiusura morsa Y elseif Cmd[1] == 11 then local sInfo = '11,'..EgtNumToString( Cmd[2],0) @@ -2937,6 +3184,10 @@ function SpecOutputCmds( vCmd, bEnd) local sInfo = '23,'..EgtNumToString( Cmd[2],3) EgtSetInfo( EMC.PATHID, sKey, sInfo) EMC.W2DELTA = Cmd[2] + -- riporta trave in zona carico dopo una fase start partita con un riposizionamento + elseif Cmd[1] == 24 then + local sInfo = '24,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..EgtIf( Cmd[6], ',*', '') + EgtSetInfo( EMC.PATHID, sKey, sInfo) -- aggancio grezzo a carrello elseif Cmd[1] == 31 then local sInfo = '31,'..EgtNumToString( Cmd[2],0)..','..Cmd[3] @@ -2976,8 +3227,26 @@ function SpecOutputCmds( vCmd, bEnd) EgtSetInfo( NextDispId, 'V1POS', EMC.V1POS) EgtSetInfo( NextDispId, 'V2POS', EMC.V2POS) end + -- se bisogna andare a ZMAX alla fine, si setta il parametro sulla lavorazione successiva in modo che la corrente vada in home + if EMC.ENDZMAX and EMC.MCHID then + -- recupero lavorazione successiva + local nNextMchId = EgtGetNextActiveOperation( EMC.MCHID, true) + while nNextMchId do + if EgtGetOperationType( nNextMchId) ~= MCH_OY.DISP then + if EgtSetCurrMachining( nNextMchId) then + -- Verifico flag di separazione e fase di scarico + local sNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) + -- si cancella eventuale flag per risalita in ZMAX + sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 'FORCED') + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + EgtSetCurrMachining( EMC.MCHID) + break + end + end + nNextMchId = EgtGetNextActiveOperation( nNextMchId, true) + end + end end - end --------------------------------------------------------------------- diff --git a/Essetre-PFMAXrl.ini b/Essetre-PFMAXrl.ini index cb7f9fe..1e20090 100644 --- a/Essetre-PFMAXrl.ini +++ b/Essetre-PFMAXrl.ini @@ -121,6 +121,8 @@ Mortising=1 Chiseling=0 SawRoughing=0 SawFinishing=0 +DrillingDoubleNT=1 +PocketingDoubleNT=1 [Machining] InitScript=InitMach.lua diff --git a/Essetre-PFMAXrl.mlde b/Essetre-PFMAXrl.mlde index 349cb3a..71d45fe 100644 --- a/Essetre-PFMAXrl.mlde +++ b/Essetre-PFMAXrl.mlde @@ -6,11 +6,11 @@ -- Intestazioni require( 'EmtGenerator') -EgtEnableDebug( false) +EgtEnableDebug( true) -PP_VER = '3.1f4' -PP_NVER = '3.1.6.4' -MIN_MACH_VER = '2.5k1' +PP_VER = '3.1g1' +PP_NVER = '3.1.7.1' +MIN_MACH_VER = '3.1f1' MACH_NAME = EgtGetCurrMachineName() -- Carico i dati globali @@ -82,6 +82,7 @@ MaxX1 = 2735 Limit_T1_Presel_T2 = MinX1 MinZ1 = -1850 MaxZ1 = 0 +MaxZ1Blade = 0 MinC1 = -275 MaxC1 = 275 MinB1 = -127 @@ -109,6 +110,7 @@ MaxX2 = 2035 Limit_T2_Presel_T1 = MaxX2 MinZ2 = -1850 MaxZ2 = 0 +MaxZ2Blade = 0 MinC2 = -275 MaxC2 = 275 MinB2 = -127 @@ -120,7 +122,7 @@ ParkZ2 = -535 ParkC2 = -90 ParkB2 = -90 MinDeltaX1X2 = 650 -MinDistToolX1X2 = 40 +MinDistToolX1X2 = 20 LimX2RotSaw = 800 TurnerOffs = 120.0 AggLoad = 50 @@ -141,9 +143,13 @@ SecondSaw = true AutomaticRotation = true OptimizedLoadBeam = true AutoRotMinLen = 0 +EstimationRapidMultiplier = 1 ForceToCloseRollersGate = false +Probe = nil +AggreBlockHaus = false DistZClampToTable = 5 -- distanza tra la tavola e il punto più basso della morsa ClampingCoeffMin = nil -- coefficiente di fissaggio, se 0 o nil non fa controllo, per il momento da inizializzare da Ts3Data +MaxFeedPinze = 102000 -- Aggiornamento con dati da TechnoEssetre7 local sTs3Data = EgtGetStringFromIni( 'Beam', 'DATA_DIR', "C:\\TechnoEssetre7\\EgtData", EgtGetIniFile()).."\\Essetre-PFMAXrl.data" @@ -170,6 +176,7 @@ if EgtExistsFile( sData) then if Machine.Offsets.PARK_X1 then ParkX1 = -Machine.Offsets.PARK_X1 end if Machine.Offsets.Z1_NEG then MinZ1 = Machine.Offsets.Z1_NEG end if Machine.Offsets.Z1_POS then MaxZ1 = min( MaxZ1, Machine.Offsets.Z1_POS) end + if Machine.Offsets.Z1_POS_LAMA then MaxZ1Blade = min( MaxZ1Blade, Machine.Offsets.Z1_POS_LAMA) end if Machine.Offsets.PARK_Z1 then ParkZ1 = Machine.Offsets.PARK_Z1 end if Machine.Offsets.C1_NEG then MinC1 = Machine.Offsets.C1_NEG end if Machine.Offsets.C1_POS then MaxC1 = Machine.Offsets.C1_POS end @@ -182,6 +189,7 @@ if EgtExistsFile( sData) then if Machine.Offsets.PARK_X2 then ParkX2 = -Machine.Offsets.PARK_X2 end if Machine.Offsets.Z2_NEG then MinZ2 = Machine.Offsets.Z2_NEG end if Machine.Offsets.Z2_POS then MaxZ2 = Machine.Offsets.Z2_POS end + if Machine.Offsets.Z2_POS_LAMA then MaxZ2Blade = min( MaxZ2Blade, Machine.Offsets.Z2_POS_LAMA) end if Machine.Offsets.PARK_Z2 then ParkZ2 = Machine.Offsets.PARK_Z2 end if Machine.Offsets.C2_NEG then MinC2 = Machine.Offsets.C2_NEG end if Machine.Offsets.C2_POS then MaxC2 = Machine.Offsets.C2_POS end @@ -232,11 +240,13 @@ if EgtExistsFile( sData) then if Machine.Offsets.LIMIT_T1_PRESEL_T2 then Limit_T1_Presel_T2 = Machine.Offsets.LIMIT_T1_PRESEL_T2 end if Machine.Offsets.LIMIT_T2_PRESEL_T1 then Limit_T2_Presel_T1 = Machine.Offsets.LIMIT_T2_PRESEL_T1 end if Machine.Offsets.NOULOAD then MaxUnloadLen = Machine.Offsets.NOULOAD end - if Machine.Offsets.MAXFEEDPINZE then MaxFeedPinze = Machine.Offsets.MAXFEEDPINZE end + if Machine.Offsets.MAXFEEDPINZE then MaxFeedPinze = EgtClamp( Machine.Offsets.MAXFEEDPINZE, 20000, 155000) end if Machine.Offsets.MAXACC then MaxAcc = Machine.Offsets.MAXACC end if Machine.Offsets.MINACC then MinAcc = Machine.Offsets.MINACC end + if Machine.Offsets.COEFF_STIMATEMPI and Machine.Offsets.COEFF_STIMATEMPI > 0 then EstimationRapidMultiplier = Machine.Offsets.COEFF_STIMATEMPI end if Machine.Offsets.CHIUDI_PINZE_2_3_SCAMBIO then ForceToCloseRollersGate = Machine.Offsets.CHIUDI_PINZE_2_3_SCAMBIO == 1 end if Machine.Offsets.WOOD_DENSITY then WoodDensity = Machine.Offsets.WOOD_DENSITY end + if Machine.Offsets.PROBE then Probe = Machine.Offsets.PROBE end -- Tastatore su entrembe le teste. 1 = solo testa 1, 2 = solo testa 2, 3 = entrambe le teste if Machine.Offsets.MAX_BACK_CLAMP_5 then MaxBackClamp5 = Machine.Offsets.MAX_BACK_CLAMP_5 end if Machine.Offsets.COEFF_CLAMP_CHECK then ClampingCoeffMin = Machine.Offsets.COEFF_CLAMP_CHECK end -- aggiustamenti @@ -250,6 +260,8 @@ if EgtExistsFile( sData) then ParkY2 = ParkV2 - MinDeltaYV ParkX1 = min( ParkX1, MaxX1) ParkX2 = max( ParkX2, MinX2) + MaxZ1Blade = min( MaxZ1Blade, MaxZ1) + MaxZ2Blade = min( MaxZ2Blade, MaxZ2) Head2Y = DeltaTabY - Delta2TabY Head2Z = DeltaTabZ - Delta2TabZ ParkCSawX1S = ParkX1 @@ -267,6 +279,8 @@ EmtGeneral { ExitMaxAdjust = 300, ExitMaxRotAdj = 0.5, AngDeltaMinForHome = 80, + LinkAxesMoveOrder = MCH_LKAMO.HEAD_BEFORE_IF_SAME_ANG, + NewLinkMgr = 1, Special = 'Common_ONE-PF.mlse', Processor = 'Common_ONE-PF.mlpe'} local sBaseAux = {'BASE/SOLID', 'BASE/SIGN', 'BASE/CONVOYER', 'BASE/BELT', 'BASE/COLLISION', 'BASE/TC1', 'BASE/TC2', 'BASE/TC3', 'BASE/TC4', 'BASE/TC5'} @@ -833,14 +847,14 @@ function OnSetHead() if EMC.HEAD == 'H11' then local dRawH = GetRawHeight() EmtModifyAxisHome( 'X1', ParkX1) - EmtModifyAxisHome( 'Z1', ParkZ1 + EgtIf( dRawH > 650, EgtIf( EMC.TOTDIAM < 61, 235, 165), 0)) + EmtModifyAxisHome( 'Z1', MaxZ1) EmtModifyAxisHome( 'C1', ParkC1) EmtModifyAxisHome( 'B1', ParkB1) EmtModifyAxisDirection( 'B1', X_AX()) -- se testa H12 (lama) elseif EMC.HEAD == 'H12' then EmtModifyAxisHome( 'X1', ParkX1) - EmtModifyAxisHome( 'Z1', ParkZ1) + EmtModifyAxisHome( 'Z1', MaxZ1Blade) EmtModifyAxisHome( 'C1', ParkC1) EmtModifyAxisHome( 'B1', ParkB1) EmtModifyAxisDirection( 'B1', VectorFromRotated( X_AX(), Z_AX(), -SawC1Offs)) @@ -864,14 +878,14 @@ function OnSetHead() elseif EMC.HEAD == 'H21' then local dRawH = GetRawHeight() EmtModifyAxisHome( 'X2', ParkX2) - EmtModifyAxisHome( 'Z2', ParkZ2 + EgtIf( dRawH > 650, EgtIf( EMC.TOTDIAM < 61, 235, 165), 0)) + EmtModifyAxisHome( 'Z2', MaxZ2) EmtModifyAxisHome( 'C2', ParkC2) EmtModifyAxisHome( 'B2', ParkB2) EmtModifyAxisDirection( 'B2', X_AX()) -- se testa H22 (lama) elseif EMC.HEAD == 'H22' then EmtModifyAxisHome( 'X2', ParkX2) - EmtModifyAxisHome( 'Z2', ParkZ2) + EmtModifyAxisHome( 'Z2', MaxZ2Blade) EmtModifyAxisHome( 'C2', ParkC2) EmtModifyAxisHome( 'B2', ParkB2) EmtModifyAxisDirection( 'B2', VectorFromRotated( X_AX(), Z_AX(), -SawC2Offs)) @@ -934,12 +948,54 @@ function HeadIsProbe( sHead) return ( sHead == 'H19' or sHead == 'H29') end +--------------------------------------------------------------------- +function IsToolCompatibleWithProbe( sToolName, sCurrTool) + local bToolIsCompatible = false + if sToolName then + EgtTdbSetCurrTool( sToolName) + local dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) + local dToolLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) + if dToolDiam < 100 and dToolLen < 160 then + bToolIsCompatible = true + end + EgtTdbSetCurrTool( sCurrTool) + end + return bToolIsCompatible +end + +--------------------------------------------------------------------- +function GetToolNameFromTcPos( sTcPos) + local sToolName + -- Carico gli utensili sulle barre portautensili + local vTcPos = EgtGetAllTcPosNames() + if vTcPos then + for i = 1, #vTcPos do + if vTcPos[i] == sTcPos then + local sToolsName = EgtGetToolsInCurrSetupPos( vTcPos[i]) + sToolName = sToolsName[1] + end + end + end + return sToolName +end + +--------------------------------------------------------------------- +function GetToolHead( sToolName) + local sHead + local sCurrTool = EgtTdbGetCurrToolParam( MCH_TP.NAME) + EgtTdbSetCurrTool( sToolName) + sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) + sTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS) + EgtTdbSetCurrTool( sCurrTool) + return sHead, sTcPos +end + --------------------------------------------------------------------- -- Funzione che calcola la posizione Home di Z per la sega a catena dal valore dell'asse virtuale function GetChainSawZHomeFromVirtualAxis( dPosA) -- se A=0 -> T101 -> HomeZ = -400 if abs( dPosA) < 0.1 then - return ParkCSaw0Z1 + return ParkCSawZ1 -- altrimenti A=-90 -> T102 o A=90 -> T104 -> HomeZ = -100 else return ParkCSawZ1 @@ -988,6 +1044,7 @@ function GetZExtra( sHead, dAngV) return 0 end end + return 0 end --------------------------------------------------------------------- diff --git a/UpdateLog.txt b/UpdateLog.txt index 4758a8e..e5c057f 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,17 @@ ==== Common_ONE-PF Update Log ==== +Versione 3.1g2 (07/07/2026) +- (SIM) Corretta gestione cambio utensile con motosega + +Versione 3.1g1 (07/07/2026) +- (ALL) Prima versione con gestione nuovi link (no tastatore) +- Gestione lavorazioni in doppio +- Preselezione utensile gestibile da parametri TS3 +- Gestione Drilling e Pocketing NT + +Versione 3.1f5 (26/06/2026) +- (SIM-GEN) Se tasca con motosega in faccia sopra e pezzo alto, si ruota in sicurezza. + Versione 3.1f4 (17/06/2026) - (MLDE-GEN) Corretta preselezione in caso di testa in lavoro troppo vicina a quella che sta preselezionando. Da aggiungere in MLDE parametri 'Limit_T1_Presel_T2' e 'Limit_T2_Presel_T1' diff --git a/Version.lua b/Version.lua index 72474b2..e8c48a4 100644 --- a/Version.lua +++ b/Version.lua @@ -3,8 +3,8 @@ local InfoCommon_STD_PP = { NAME = 'Common_ONE-PF', -- nome script PP standard - VERSION = '3.1f4', -- versione script - MIN_MACH_VER_PP_COMMON = '3.1b2' -- versione minima kernel + VERSION = '3.1g2', -- versione script + MIN_MACH_VER_PP_COMMON = '3.1f1' -- versione minima kernel } return InfoCommon_STD_PP From 74c78b22d7dfcd95d111ca51421de75f09d5c20f Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Tue, 14 Jul 2026 10:45:09 +0200 Subject: [PATCH 6/7] Versione minima portato a 3.1f4 --- Essetre-PFMAXrl.mlde | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Essetre-PFMAXrl.mlde b/Essetre-PFMAXrl.mlde index 71d45fe..2b3f772 100644 --- a/Essetre-PFMAXrl.mlde +++ b/Essetre-PFMAXrl.mlde @@ -10,7 +10,7 @@ EgtEnableDebug( true) PP_VER = '3.1g1' PP_NVER = '3.1.7.1' -MIN_MACH_VER = '3.1f1' +MIN_MACH_VER = '3.1f4' MACH_NAME = EgtGetCurrMachineName() -- Carico i dati globali From 19d609fa3a3f82820d4db5819341a203e9282d51 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Fri, 24 Jul 2026 16:25:26 +0200 Subject: [PATCH 7/7] Allineamento con comon ver. 3.1g3 --- Common_ONE-PF.NUM.mlpe | 12 ++++++++---- Common_ONE-PF.mlpe | 17 ++++++++++++----- Common_ONE-PF.mlse | 23 ++++++++++++++--------- Essetre-PFMAXrl.mlde | 4 ++-- UpdateLog.txt | 6 ++++++ Version.lua | 2 +- 6 files changed, 43 insertions(+), 21 deletions(-) diff --git a/Common_ONE-PF.NUM.mlpe b/Common_ONE-PF.NUM.mlpe index 332cd19..7675dce 100644 --- a/Common_ONE-PF.NUM.mlpe +++ b/Common_ONE-PF.NUM.mlpe @@ -1229,6 +1229,14 @@ function OnRapid() -- calcolo per piano generico CalcInterpPlane() EMT.REFLOC = true + -- 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() @@ -1241,10 +1249,6 @@ function OnRapid() EMT.PLANEACTIVE = true - -- annullo precedenti per forzare scrittura - EMT.R1p = nil - EMT.R2p = nil - -- emissione movimento local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3').. EmtGetAxis('R2')..EmtGetAxis('R1') diff --git a/Common_ONE-PF.mlpe b/Common_ONE-PF.mlpe index 5048d2e..a41815e 100644 --- a/Common_ONE-PF.mlpe +++ b/Common_ONE-PF.mlpe @@ -608,7 +608,7 @@ function OnSimulToolSelect( dPosA) end --------------------------------------------------------------------- -function OnSimulToolDeselect( dPrevA) +function OnSimulToolDeselect( dPrevA, bLastRise) -- se ToolDeselect chiamata da MLPE, bisogna scaricare perchè è ultimo movimento di rise e poi si cambia utensile if dPrevA then @@ -627,7 +627,7 @@ function OnSimulToolDeselect( dPrevA) OnSetHead() EMC = OrigEMC -- se c'è prossimo utensile, oppure se non c'è e c'è un movimento carrelli - if sTool or ( not sTool and bCarrMove) then + if sTool or ( not sTool and bCarrMove) or not bLastRise then local dHomeX1 = EgtGetAxisHomePos( 'X1') local dHomeC1 = EgtGetAxisHomePos( 'C1') @@ -654,7 +654,7 @@ function OnSimulToolDeselect( dPrevA) OnSetHead() EMC = OrigEMC -- se c'è prossimo utensile, oppure se non c'è e c'è un movimento carrelli - if sTool or ( not sTool and bCarrMove) then + if sTool or ( not sTool and bCarrMove) or not bLastRise then local dHomeX2 = EgtGetAxisHomePos( 'X2') local dHomeC2 = EgtGetAxisHomePos( 'C2') @@ -1233,7 +1233,7 @@ function OnSimulMoveEnd() local bLastRise = EgtGetInfo( EMT.MOVEID, 'LastRise', 'b') -- se ultimo rapido e motosega, si va in home if bLastRise and HeadIsChainSaw( EMT.HEAD) then - OnSimulToolDeselect( EMT.R3) + OnSimulToolDeselect( EMT.R3, true) EMT.CHSAW_OUT = true end end @@ -1442,6 +1442,13 @@ end function ExecMoveHome( bNearV) -- se richiesto, avvicino i rulli if bNearV then + -- se ho motosega, devo scaricare + if HeadIsChainSaw( EMT.HEAD) then + -- recupero il valore dell'asse virtuale bloccato A + local dPosA = GetCurrChainSawingVirtualAxis() + OnSimulToolDeselect( dPosA) + EMT.CHSAW_OUT = true + end -- sistemo i rulli ExecOpenRoller( 1) ExecOpenRoller( 2) @@ -2650,7 +2657,7 @@ function FindNextToolOnHeadSet( nHSet, bFirst) end local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) if GetHeadSet( sNextHead) == nHSet then - if EMT.TOOL ~= sNextTool then + if CurrTool ~= sNextTool then if not HeadIsChainSaw( sNextHead) then sHead = sNextHead sTool = sNextTool diff --git a/Common_ONE-PF.mlse b/Common_ONE-PF.mlse index 7b93c39..fcb331c 100644 --- a/Common_ONE-PF.mlse +++ b/Common_ONE-PF.mlse @@ -279,11 +279,10 @@ function OnSpecialLink() EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p, EMC.R3}, 30, 2, 2, 'FirstClimb=1;') EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3}, 30, 2, 2) if abs( EMC.R3) < 0.1 then - EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z1, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z1, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') else - EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') end - EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') -- se fine lavorazione con deposito utensile elseif EMC.LINKTYPE == 2 then @@ -400,9 +399,12 @@ function OnSpecialLink() EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN) EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;') EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2) - -- se assi cambiano di molto - if abs( EMC.R1 - EMC.R1p) > 10 or abs( EMC.R2 - EMC.R2p) > 90 then + -- se asse B cambia di molto + if abs( 0 - EMC.R2p) > 1 then EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2) + end + -- se assi cambiano di molto + if abs( EMC.R1 - EMC.R1p) > 10 then EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2) end @@ -417,7 +419,10 @@ function OnSpecialLink() EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN) if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') - EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2) + -- se assi cambiano di molto + if abs( EMC.R1 - EMC.R1p) > 10 then + EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2) + end EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2) else EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;') @@ -455,6 +460,7 @@ function OnSpecialLink() EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;') end end + -- se sega a catena su testa 2 elseif EMC.HEAD == 'H23' then -- recupero se split da note utente di lavorazione precedente @@ -466,11 +472,10 @@ function OnSpecialLink() EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p, EMC.R3}, 30, 2, 2, 'FirstClimb=1;') EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3}, 30, 2, 2) if abs( EMC.R3) < 0.1 then - EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z2, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z2, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') else - EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2) + EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') end - EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;') -- se fine lavorazione con deposito utensile elseif EMC.LINKTYPE == 2 then diff --git a/Essetre-PFMAXrl.mlde b/Essetre-PFMAXrl.mlde index 2b3f772..fcc039d 100644 --- a/Essetre-PFMAXrl.mlde +++ b/Essetre-PFMAXrl.mlde @@ -8,8 +8,8 @@ require( 'EmtGenerator') EgtEnableDebug( true) -PP_VER = '3.1g1' -PP_NVER = '3.1.7.1' +PP_VER = '3.1g3' +PP_NVER = '3.1.7.3' MIN_MACH_VER = '3.1f4' MACH_NAME = EgtGetCurrMachineName() diff --git a/UpdateLog.txt b/UpdateLog.txt index e5c057f..258a710 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,11 @@ ==== Common_ONE-PF Update Log ==== +Versione 3.1g3 (24/07/2026) +- (SIM) Non si legge il nome utensile da tabella EMT, ma si utilizza quello corrente salvato in precedenza +- (SIM) Corretta gestione scarico motosega in caso di cambio pinze dopo che utensile già caricato. In generazione era corretto perchè selezione utensile avviene già dopo posizionamento carrelli +- (SIM-GEN) Migliorati movimenti lama e motosega. Ultimo punto climb motosega è in alto in quota parcheggio. +- (GEN) Corretta scrittura piano lavorazione in caso di rotazione con pezzo con sovramateriale in testa. Ticket#3092 + Versione 3.1g2 (07/07/2026) - (SIM) Corretta gestione cambio utensile con motosega diff --git a/Version.lua b/Version.lua index e8c48a4..0813529 100644 --- a/Version.lua +++ b/Version.lua @@ -3,7 +3,7 @@ local InfoCommon_STD_PP = { NAME = 'Common_ONE-PF', -- nome script PP standard - VERSION = '3.1g2', -- versione script + VERSION = '3.1g3', -- versione script MIN_MACH_VER_PP_COMMON = '3.1f1' -- versione minima kernel }