Spostato EgtClamp della massima velocità pinze (MaxFeedPinze) nell'mlde. Aumentato il massimo da 102000 a 155000

Cambio versione
Deselezione motosega in caso di movimento in home (DA SISTEMARE)
2026-05-08 16:41:38 +02:00 · 2026-05-08 08:17:44 +02:00 · 2026-05-07 17:02:20 +02:00 · 2026-05-07 10:51:13 +02:00 · 2026-04-23 12:25:31 +02:00 · 2026-04-23 12:24:08 +02:00
13 changed files with 1755 additions and 1916 deletions
@@ -8,6 +8,7 @@ local BeamData = {
   RIGHT_LOAD = false,                      -- flag carico da destra
   SIMUL_VIEW_DIR = 2,                      -- direzione di vista predefinita per la simulazione (1=NW, 2=SW, 3=NE, 4=SE)
   ROT90 = false,                           -- flag abilitazione rotazione 90 gradi
+   ROT180 = true,                           -- flag abilitazione rotazione 180 gradi
   MIN_WIDTH = 40,                          -- larghezza minima del grezzo
   MIN_HEIGHT = 40,                         -- altezza minima del grezzo
   MAX_WIDTH = 400,                         -- larghezza massima del grezzo
@@ -41,6 +42,7 @@ local BeamData = {
   DRILL_TOL = 0.2,                         -- tolleranza tra diametro foro e diametro punta
   DRILL_VZ_MIN = - 0.51,                   -- componente limite in Z del versore di un foro
   DRILL_VX_MAX = 0.867,                    -- componente limite in X del versore di un foro sulle facce laterali
+   MAX_ANGLE_DRILL_CUT = 15,                -- delta angolo massimo tra foro e taglio che lo attraversa
   DRILL_OVERLAP = 5,                       -- sovrapposizione tra due mezze forature
   MILL_OVERLAP = 5,                        -- sovrapposizione tra due mezze fresature
   MAX_DIST_HTFEA = 50.0,                   -- massima distanza di feature da testa o coda per essere considerata tale
@@ -66,6 +68,8 @@ local BeamData = {
   KIOTP = 6,                               -- coefficiente moltiplicativo per attacco/uscita lama tangente anzichè perpendicolare
   MAXDIAM_POCK_CORNER = 31,                -- diametro massimo utensile ammesso per tasche con angoli interni
   USE_LONGCUT = false,                     -- per i tagli longitudinali usare solo la lavorazione di lama LongCut
+   PRECUT_HEAD = true,                      -- flag abilitazione pretaglio grezzo a zero in testa
+   PRECUT_TAIL = true,                      -- flag abilitazione pretaglio grezzo a zero in coda
   ADVANCE_TAIL_CUT = true,                 -- per spostare prima del taglio di separazione il taglio di coda su pezzi corti con robabile caduta
   ADVANCE_TAIL_OFFS = 1,                   -- accorciamento taglio di coda avanzato (minimo 1)
   CLAMP5 = false                           -- presenza pinza speciale per pezzi piccoli
@@ -95,6 +99,19 @@ if EgtExistsFile( sData) then
         BeamData.DIM_STRIP_SMALL = Machine.Offsets.DIM_STRIP_SMALL or BeamData.DIM_STRIP_SMALL
         BeamData.DIM_TO_CENTER_STRIP = Machine.Offsets.DIM_TO_CENTER_STRIP or BeamData.DIM_TO_CENTER_STRIP
         BeamData.MAXDIAM_POCK_CORNER = Machine.Offsets.MAXDIAM_POCK_CORNER or BeamData.MAXDIAM_POCK_CORNER
+         if Machine.Offsets.PRECUT_HEAD_DISABLE then BeamData.PRECUT_HEAD = ( Machine.Offsets.PRECUT_HEAD_DISABLE == 0) end
+         if Machine.Offsets.PRECUT_TAIL_DISABLE then BeamData.PRECUT_TAIL = ( Machine.Offsets.PRECUT_TAIL_DISABLE == 0) end
+         BeamData.LONGCUT_ENDLEN = Machine.Offsets.LONGCUT_ENDLEN or BeamData.LONGCUT_ENDLEN
+         BeamData.LONGCUT_MAXLEN = Machine.Offsets.LONGCUT_MAXLEN or BeamData.LONGCUT_MAXLEN
+         BeamData.ADVANCE_TAIL_OFFS = Machine.Offsets.ADVANCE_TAIL_OFFS or BeamData.ADVANCE_TAIL_OFFS
+         BeamData.LEN_VERY_SHORT_PART = Machine.Offsets.LEN_VERY_SHORT_PART or BeamData.LEN_VERY_SHORT_PART
+         BeamData.LEN_SHORT_PART = Machine.Offsets.LEN_SHORT_PART or BeamData.LEN_SHORT_PART
+         BeamData.OVM_MID = Machine.Offsets.OVM_MID or BeamData.OVM_MID
+         if Machine.Offsets.MAX_ANGLE_DRILL_CUT then BeamData.MAX_ANGLE_DRILL_CUT = EgtClamp( Machine.Offsets.MAX_ANGLE_DRILL_CUT, 1, 89) end
+         if Machine.Offsets.ROT90 ~= nil then BeamData.ROT90 = ( Machine.Offsets.ROT90 == 1) end
+         if Machine.Offsets.CUT_SIC then BeamData.CUT_SIC = EgtClamp( Machine.Offsets.CUT_SIC, 15, 50) end
+         if Machine.Offsets.MIN_JOIN_S then BeamData.MIN_JOIN_S = EgtClamp( Machine.Offsets.MIN_JOIN_S, 80, 150) end
+         if Machine.Offsets.MIN_JOIN_L then BeamData.MIN_JOIN_L = EgtClamp( Machine.Offsets.MIN_JOIN_L, 300, 450) end
      end
      if Machine.Trave then
         BeamData.MIN_WIDTH = Machine.Trave.XMIN or BeamData.MIN_WIDTH
@@ -28,6 +28,8 @@
 17=ProfTCone
 18=SmallToolContour
 19=AntiSplintMillCut
+20=SideMillAsBlade
+21=Prof_end

 [Pocketing]
 1=Pocket
@@ -7,211 +7,410 @@ EgtEnableDebug( false)
 -- Carico libreria
 local BD = require( 'BeamData')

---------------------- 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)
+-- *** Generic Machinings ***
+---------------------------------------------------------------------
+require( 'EmtGenMachining')
+
+---------------------------------------------------------------------
+-- *** Special GetPrevMachiningOffset ***
+---------------------------------------------------------------------
+-----------------------------------------------------------------------------------------
+function OnSpecialGetPrevMachiningOffset()
+   -- Aggiorno posizione della testa della trave a seguito di movimenti delle pinze non previsti tra le fasi
+   local function TPosUpdate()
+      local nClId = EgtGetFirstNameInGroup( EMC.CURRMCHID, 'CL') -- recupero Id del gruppo CL della lavorazione corrente
+      local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1)
+      if not nPathId then
+         EMC.ERR = 12
+         EMC.MSG = '  Error : CL group path not found'
+         return
+      end
+      local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari 
+      local dTRepos = nil
+      -- controlla ogni gruppo di movimenti ausiliari
+      for i = 1, dAuxMoveCount do
+         local aAuxMove = EgtGetInfo( nPathId, 'AS' .. tostring( i), 'vs') or {} -- array contenete i parametri di ogni gruppo
+         -- controlla solo i movimenti della testa trave e salva l'ultimo
+         if aAuxMove[1] == '2' or aAuxMove[1] == '3' then
+            for j = 2, #aAuxMove do
+               if aAuxMove[j] == 'T' then
+                  dTRepos = aAuxMove[j+1]
+                  break
+               end
+            end
+         end
+      end
+      return dTRepos
+   end
+
+   -- default
+   EMC.ERR = 0
+   EMC.PREVOFFSX = 0
+   -- se c'è cambio di fase tra le lavorazioni (quindi la precedente è l'ultima della sua fase e la corrente la prima)
+   if EMC.PREVPHASE ~= EMC.CURRPHASE then
+      -- se la fase corrente è di inizio lavorazione di nuova trave
+      if IsStartOrRestPhase( EMC.CURRPHASE) then
+         -- recupero la posizione finale della lavorazione precedente
+         local vPrevAx = EmtGetFinalAxesPos( EMC.PREVMCHID)
+         -- ricava se e quanto la trave viene spostata tra le due fasi dai movimenti ausiliari e corregge l'offset di fine fase
+         local dNewTPos = TPosUpdate()
+         -- se ci sono dei movimenti della testa trave tra le due fasi ricava il delta tra la vecchia e la nuova posizione
+         if dNewTPos then
+            EMC.PREVOFFSX = dNewTPos - vPrevAx[1]
+         -- oppure la X (L1) di questa corrisponde alla posizione iniziale della nuova trave, se ne deduce l'offset
+         else
+            EMC.PREVOFFSX = ParkV1 - vPrevAx[1]
+         end
      end
   end
-   -- sotto il minimo
-   return 0
 end

 ---------------------------------------------------------------------
-function OnSpecialGetMaxZ()
-   -- Inizializzazioni
-   EMC.ERR = 0
-
-   -- 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
+-- *** 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
+   return ( sPrevUserNotes:find( 'Split;', 1, true) ~= nil)
+end

-   -- 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
+-----------------------------------------------------------------------------------------
+local function IsLinkSafety( vtFinal, vtInit)
+   local bSafeMove = true
+   local DirectionsToTest = { {vtInit[3],vtInit[4], vtInit[5]}, {vtFinal[3],vtFinal[4], vtFinal[5]}}
+
+   -- aggiungo anche il punto medio
+   table.insert( DirectionsToTest, {(vtInit[3]+vtFinal[3])/2,(vtInit[4]+vtFinal[4])/2,(vtInit[5]+vtFinal[5])/2})
+
+   for t=1, #DirectionsToTest do
+      local vtToolDir = EgtGetCalcToolDirFromAngles( DirectionsToTest[t][2], DirectionsToTest[t][3])
+      -- se lama su aggregato
+      if 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][3]) + dToolRadius * abs( sin( DirectionsToTest[t][3]))) - 275
+            local dMaxZ = ParkZ1 - dNewOffZ
+            if dMaxZ < DirectionsToTest[t][1] 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' and sHead_TC == 'Head1_TC1' then
-      if vtTp:getX() > 0.3 and vtT:getX() > 0.3 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
+         -- 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;')
+         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, 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 > 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.3 and vtT:getX() > 0.3 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
+         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 = ParkZ1 + 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 = 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)
+         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 vLFiAx = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+         local vLInAx = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false)
+         -- se superata quota massima ammessa
+         if max( vLFiAx[3], vLInAx[3]) > ParkZ1 + 1 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;')
+         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 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;', ''))
+         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 vtFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+         local vtInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false)
+         local bSafeMove = IsLinkSafety( vtFinalAxLink, vtInitAxLink)
+         -- se gli assi rotanti sono cambiati
+         if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
+            -- se superata quota massima ammessa
+            if not bSafeMove then
+               -- retrazione
+               EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+               if abs( EMC.R2) > 91 then
+                  EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1p, EMC.L2p, ParkZ1, EMC.R1p, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 2)
+               end
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 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;')
+               -- 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
+      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.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3}, 30, 2, 2, 'FirstClimb=1;')
+         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;')
+
+      -- 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)
+         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
+      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.3 and vtT:getX() > 0.3 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;')
+         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, 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 vLFiAx = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+         local vLInAx = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false)
+         -- se superata quota massima ammessa
+         if max( vLFiAx[3], vLInAx[3]) > ParkZ1 + 1 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;')
+         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)
+         -- altrimenti discesa diretta
+         if abs( EMC.R1 - EMC.R1p) < 10 and abs( EMC.R2 - EMC.R2p) < 90 then
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;')
+         -- se assi cambiano di molto
+         else
+            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)
+         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;', ''))
+         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 vtFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+         local vtInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false)
+         local bSafeMove = IsLinkSafety( vtFinalAxLink, vtInitAxLink)
+         -- se superata quota massima ammessa
+         if not bSafeMove then
+            -- retrazione
+            EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+            if abs( EMC.R2) > 91 then
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1p, EMC.L2p, ParkZ1, EMC.R1p, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 2)
+            end
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 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;')
+            -- 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.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3}, 30, 2, 2, 'FirstClimb=1;')
+         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;')
+
+      -- 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)
+         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' 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
-   end
 end

-
 ---------- OnSpecialApplyDisposition & OnPostApplyMachining ---------
 ----------------------- Costanti ------------------------------------
 local DELTA_SIC = 1
@@ -223,7 +422,7 @@ local MIN_BACK_ENG_V = 115       -- ingombro asse Z a sinistra
 local AGG_V = MinDeltaYV         -- ingombro rulli pressori + sicurezza
 local MIN_CLAMP_5 = 150          -- minima presa con la pinza speciale (pinza 5)
 local SIC_CLAMP_5 = 50           -- sicurezza testa da pinza speciale
-local MAX_BACK_CLAMP_5 = 320     -- massima sporgenza posteriore del pezzo da pinza speciale
+local MAX_BACK_CLAMP_5 = EgtClamp( MaxBackClamp5 or 320, 200, 380)   -- massima sporgenza posteriore del pezzo da pinza speciale

 ----------------------- Variabili -----------------------------------
 local Test = false
@@ -654,11 +853,43 @@ end

 ---------------------------------------------------------------------
 function OnPostApplyMachining()
+   -- Inizializzo codice di errore
+   EMC.ERR = 0
+   -- Verifico se ultima lavorazione della fase
+   local nNextOpeId = EgtGetNextActiveOperation( EMC.MCHID)
+   local bMchLast = ( not nNextOpeId  or  EgtGetOperationPhase( nNextOpeId) ~= EMC.PHASE)   -- Agisco sui diversi percorsi della lavorazione
+   local nPathId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( EMC.MCHID, 'CL') or GDB_ID.NULL)
+   while nPathId do
+      -- recupero id del successivo
+      nPathId = EgtGetNext( nPathId)
+      -- verifico se ultimo percorso di ultima lavorazione della fase
+      local bLast = ( bMchLast and ( not nPathId))
+      -- se ultimo, elimino ritorno in home
+      if bLast then EgtRemoveOperationHome( EMC.MCHID) end
+   end
+end
+
+---------------------------------------------------------------------
+function OnSpecialApplyMachining()

   EgtOutLog( ' Lavorazione : ' .. EgtGetName( EMC.MCHID), 1)

   -- Inizializzo codice di errore
   EMC.ERR = 0
+   EMC.ZMAX = false
+   EMC.ENDZMAX = false
+
+   -- 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)
@@ -734,6 +965,18 @@ function OnPostApplyMachining()
      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
@@ -744,7 +987,6 @@ function OnPostApplyMachining()
   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)
@@ -761,7 +1003,7 @@ function OnPostApplyMachining()
      -- verifico se ultimo percorso di ultima lavorazione della fase
      local bLast = ( bMchLast and ( not nPathId))
      -- se ultimo, elimino ritorno in home
-      if bLast then EgtRemoveOperationHome( EMC.MCHID) end
+      -- if bLast then EgtRemoveOperationHome( EMC.MCHID) end
      -- salvo lo stato dei carrelli
      local OriTPos = EMC.TPOS
      local OriY1Delta = EMC.Y1DELTA
@@ -818,8 +1060,30 @@ function OnPostApplyMachining()
      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

 ---------------------------------------------------------------------
@@ -1097,29 +1361,33 @@ function SpecialCalcMachiningEncumbrance( nMchId, bPreCut)
   end
   -- Recupero testa
   local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-   -- 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 sHead ~= 'H21' and sHead ~= 'H22' and sHead ~= 'H23' then
-      EgtSetAxisPos( 'C1', vAxes[4])
-      EgtSetAxisPos( 'B1', vAxes[5])
+      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
@@ -1132,7 +1400,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()
@@ -1423,7 +1691,14 @@ function SpecCalcSplit( dLenRaw, dMaxLenLeft)
   local vCmd = {}
   EgtOutLog( '  *[S]', 1)
   local bSplit = ( EMC.Y2DELTA ~= nil or EMC.W2DELTA ~= nil)
-   local ParkT = EgtIf( bSplit and dMaxLenLeft > ParkV1 - 50, LoadT, ParkV1)
+   local ParkT = ParkV1
+   if bSplit then
+      if dMaxLenLeft + 100 > LoadT then
+         ParkT = dMaxLenLeft + 300
+      elseif dMaxLenLeft + 100 > ParkV1 then
+         ParkT = LoadT
+      end
+   end
   local sType = EgtIf( EMC.Y2DELTA, 'Split', EgtIf( EMC.W2DELTA, 'SpecSplit', 'Fall'))
   table.insert( vCmd, { 0, sType})
   if not bSplit then EnsureZmax( false, vCmd) end
@@ -1546,8 +1821,11 @@ function SpecCalcUnload()
      EgtOutLog( '  *[U1]', 1)
   end
   local vCmd = {}
+   -- Tipo di scarico
+   local bStdUl = ( not MaxUnloadLen or MaxUnloadLen < 1 or EMC.LB - EMC.HOVM < MaxUnloadLen + 1)
+
   -- Commento
-   table.insert( vCmd, { 0, 'Unloading'})
+   table.insert( vCmd, { 0, 'Unloading', EgtIf( bStdUl, 'Unloading', 'Manual Unloading')})
   -- posizionamento sicuro teste e rulli (non serve ?)
   --table.insert( vCmd, { 4, 0})
   -- Se pinza Y chiusa, la apro
@@ -1555,11 +1833,15 @@ function SpecCalcUnload()
      table.insert( vCmd, { 11, 0})
      EMC.CNT = nil
   end
-   -- Sposto il pezzo in posizione di scarico
-   local dFinT = UnloadT - EMC.LB
-   local dFinY2 = dFinT + EMC.Y2DELTA
-   table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2})
-   EgtOutLog( '  Y2PosF=' .. EgtNumToString( dFinY2), 1)
+   -- Se non supero la lunghezza massima di scarico, sposto il pezzo in posizione di scarico
+   if bStdUl then
+      local dFinT = UnloadT - EMC.LB
+      local dFinY2 = dFinT + EMC.Y2DELTA
+      table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2})
+      EgtOutLog( '  Y2PosF=' .. EgtNumToString( dFinY2), 1)
+   else
+      table.insert( vCmd, { 1, 'Y2', MaxY2})
+   end
   -- apro la morsa
   table.insert( vCmd, { 12, 0})
   -- riporto il carrello in home
@@ -2746,6 +3028,12 @@ 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 bEnd then
+            EMC.ENDZMAX = true
+         else
+            EMC.ZMAX = true
+         end
      -- apertura/chiusura morsa Y
      elseif Cmd[1] == 11 then
         local sInfo = '11,'..EgtNumToString( Cmd[2],0)
@@ -2821,8 +3109,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

 ---------------------------------------------------------------------
@@ -24,62 +24,18 @@
 -- 2022/10/24 ver 2.4j1 Correzione gestione Z di primo movimento di prima lavorazione come primo movimento di lavorazioni successive.
 -- 2022/11/10 ver 2.4k1 Riportate modifiche PF.
 -- 2023/02/18 ver 2.5b2 Riportato da PF gestione speciale movimento in rapido solo a inizio lavorazione (corr. #817). Aggiunto solido collisione per eventuale segacatena sotto trave.
-- 2023/03/31 ver 2.5c5 Correzione per allontanamento trave di testa/coda con paratie (ParkRoller). Aggiornamenti vari come PF.
-- 2023/04/05 ver 2.5d1 Migliorato calcolo Zextra. Migliorata simulazione split con caduta pezzo. Eliminata testa dummy 'H14'.
-- 2023/04/28 ver 2.5d2 In OnSetHead si riassegna ad H3 (sega a catena ) la corretta direzione dell'asse B1.
-- 2023/06/12 ver 2.5f2 Corretta distanza Back per aggiuntivo al carico prima di scambi carrelli.
-- 2023/07/31 ver 2.5g1 Tolte da testa per lama forzatura risalite in Z.In generaz. CN aggiunto M05 su ultima lavorazione prima di Fall.
--                      Aggiunta apertura V1 allo scarico finale di barra con uso di entrambe Y1 e Y2 (#1399).
-- 2023/08/07 ver 2.5h1 In split prima di rotazione migliorato controllo spazio dietro per scambio carrelli. Modificato approccio/retrazione sega a catena.
--                      Ripristinata forzatura risalita in Z per lame se DeltaAng > 210 e HzPezzo > 610. Modificata notifica utensile su T201.
-- 2023/09/29 ver 2.5i1 In BeamData e mlde aggiunta la lettura di alcuni parametri da Ts3Data.
-- 2023/11/03 ver 2.5k1 Dopo rotazione, nuovo comando Aux per dichiarare morse non in presa su pezzo.
--                      In simulazione : gestione corretta motosega in caso prima lavorazione della fase.
-- 2023/11/28 ver 2.6a1 Prima versione con utilizzo post-processore standard per macchine ONE e PF
-- 2024/01/17 ver 2.6a2 Allineamento con Common ver. 2.6a2
-- 2024/01/23 ver 2.6a3 Allineamento con Common ver. 2.6a3
-- 2024/01/23 ver 2.6a4 Allineamento con Common ver. 2.6a5
-- 2024/02/07 ver 2.6a5 Allineamento con Common ver. 2.6a6
-- 2024/02/19 ver 2.6b1 In BeamData aggiunta funzione GetBlockedAxis che sostituisce la GetChainSawBlockedAxis.
-- 2024/02/23 ver 2.6b2 Allineamento con common ver. 2.6b2; in mlde aggiunte chiamate EgtAddToPackagePath
-- 2024/02/29 ver 2.6c1 Allineamento con common ver. 2.6c1
-- 2024/03/04 ver 2.6c2 Modificato log con nome macchina
--                      Allineamento con common ver. 2.6c2
-- 2024/03/06 ver 2.6c3 Allineamento con common ver. 2.6c4
-- 2024/03/06 ver 2.6c4 Allineamento con common ver. 2.6c5
-- 2024/03/08 ver 2.6c5 Allineamento con common ver. 2.6c6
-- 2024/03/11 ver 2.6c6 Allineamento con common ver. 2.6c7
-- 2024/03/26 ver 2.6c7 Con aggregati, non viene più aggiunto il gruippo SOLID (in MLDE)
-- 2024/03/28 ver 2.6d1 Allineamento con common ver. 2.6d1
-- 2024/04/12 ver 2.6d2 Allineamento con common ver. 2.6d2
--                      Aggiunto parametro ForceToCloseRollersGate
-- 2024/04/30 ver 2.6e1 Allineamento con common ver. 2.6e1
--                      Aggiunta variabile WoodDensity per gestione WOOD_DENSITY
-- 2024/06/03 ver 2.6f1 Aggiunta funzione GetSetupInfo a BeamData per nuovo automatismo
--                      Allineamento con common ver. 2.6f1
-- 2024/07/10 ver 2.6g1 Allineamento con common ver. 2.6g1
-- 2024/07/16 ver 2.6g2 Allineamento con common ver. 2.6g2
-- 2024/07/17 ver 2.6g3 Allineamento con common ver. 2.6g3
-- 2024/07/22 ver 2.6g4 Gestione pezzi fino a 30 metri
--                      Allineamento con common ver. 2.6g4
-- 2024/07/31 ver 2.6g5 Allineamento con common ver. 2.6g5
--                      Aggiunta file note tool e machining
-- 2024/08/01 ver 2.6h1 Allineamento con common ver. 2.6h1
-- 2024/08/07 ver 2.6h2 Allineamento con common ver. 2.6h2
-- 2024/09/02 ver 2.6i1 Allineamento con common ver. 2.6i1
-- 2024/09/13 ver 2.6i2 Allineamento con common ver. 2.6i2
--                      Inseriti in NGE solidi collisione TC, Aggiunta avriabile LimX1RotSawTC2
-- 2024/09/18 ver 2.6i3 Modificato YAML per comunicazione versioni a LiMan. Aggiunta PP_NVER, versione in formato numerico.
-- 2024/09/27 ver 2.6i4 Quota parcheggio ParkFrnX1 portato a 300mm
+-------------------------------------
+-- NOTE VERSIONI SUCCESSIVE IN GIT --
+-------------------------------------

 -- Intestazioni
 require( 'EmtGenerator')
 EgtEnableDebug( false)

-PP_VER = '2.6i4_DEV2'
-PP_NVER = '2.6.9.4'
+PP_VER = '3.1e1_NL1'
+PP_NVER = '3.1.3.2'
 MIN_MACH_VER = '2.5k1'
-MACH_NAME = 'Essetre-ONE'
+MACH_NAME = EgtGetCurrMachineName()

 -- Carico i dati globali
 local sMachDir = EgtGetCurrMachineDir()
@@ -143,6 +99,7 @@ MinX1 = 0
 MaxX1 = 2735
 MinZ1 = -1550
 MaxZ1 = -20                    -- per evitare problemi con striscia led
+MaxZ1Blade = 0
 MinC1 = -275
 MaxC1 = 275
 MinB1 = -127
@@ -159,7 +116,6 @@ ParkFrnB1 = -90
 LimX1RotSaw = 800
 LimX1PlRotSaw = 1970
 LimX1RotSawTC2 = 800
-SafeCSaw0X1 = 1350
 ParkCSawX1 = 1350
 ParkCSawX1S = MinX1
 ParkCSawZ1 = -50
@@ -180,8 +136,11 @@ DimTabX = 30000
 AutomaticRotation = true
 AutoRotMinLen = 0
 DefTcPos1 = 'T3'
-CoeffVM = 0.5
+EstimationRapidMultiplier = 1
 ForceToCloseRollersGate = false
+SecondToolChanger = 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

 -- Aggiornamento con dati da TechnoEssetre7
 local sTs3Data = EgtGetStringFromIni( 'Beam', 'DATA_DIR', "C:\\TechnoEssetre7\\EgtData", EgtGetIniFile()).."\\Essetre-ONE.data"
@@ -205,8 +164,10 @@ if EgtExistsFile( sData) then
         end
         if Machine.Offsets.X1_POS then MinX1 = -Machine.Offsets.X1_POS end
         if Machine.Offsets.X1_NEG then MaxX1 = -Machine.Offsets.X1_NEG end
+         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
@@ -225,6 +186,8 @@ if EgtExistsFile( sData) then
         if Machine.Offsets.MIN_V2 then MinV2 = Machine.Offsets.MIN_V2 end
         if Machine.Offsets.MAX_V2 then MaxV2 = Machine.Offsets.MAX_V2 end
         if Machine.Offsets.CLAMP5 then Clamp5 = ( Machine.Offsets.CLAMP5 == 1) end
+         if Machine.Offsets.MIN_W then MinW = Machine.Offsets.MIN_W end
+         if Machine.Offsets.MAX_W then MaxW = Machine.Offsets.MAX_W end
         if Machine.Offsets.MINWOPEN then MinWOpen = Machine.Offsets.MINWOPEN end
         if Machine.Offsets.MAXWOPEN then MaxWOpen = Machine.Offsets.MAXWOPEN end
         if Machine.Offsets.MAXWHEIGHT then MaxWHeight = Machine.Offsets.MAXWHEIGHT end
@@ -245,22 +208,32 @@ if EgtExistsFile( sData) then
         if Machine.Offsets.SAWOFFSX then SawOffsX = Machine.Offsets.SAWOFFSX end
         if Machine.Offsets.SAWOFFSZ then SawOffsZ = Machine.Offsets.SAWOFFSZ end
         if Machine.Offsets.DEFTCPOS1 then DefTcPos1 = ( 'T' .. Machine.Offsets.DEFTCPOS1) end
+         if Machine.Offsets.NOULOAD then MaxUnloadLen = Machine.Offsets.NOULOAD end
+         if Machine.Offsets.MAXFEEDPINZE then MaxFeedPinze = EgtClamp( Machine.Offsets.MAXFEEDPINZE, 155000, 20000) 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.MAX_BACK_CLAMP_5 then MaxBackClamp5 = Machine.Offsets.MAX_BACK_CLAMP_5 end
+         if Machine.Offsets.SEC_TC then SecondToolChanger = ( Machine.Offsets.SEC_TC == 1) end
+         if Machine.Offsets.COEFF_CLAMP_CHECK then ClampingCoeffMin = Machine.Offsets.COEFF_CLAMP_CHECK end
+
         -- aggiustamenti
         MinY1 = MinV1 + MinDeltaYV
         MaxY1 = MaxMchY1
+         ParkV1 = MaxV1 
         ParkY1 = ParkV1 + MinDeltaYV
         MinY2 = MinMchY2
         MaxY2 = MaxV2 - MinDeltaYV
+         ParkV2 = MinV2
         ParkY2 = ParkV2 - MinDeltaYV
-         ParkV1 = min( ParkV1, MaxV1, abs( MinV2))
-         ParkV2 = -ParkV1
-         ParkX1 = MaxX1
-         --ParkFrnX1 = MinX1
+         ParkX1 = min( ParkX1, MaxX1)
+         MaxZ1Blade = min( MaxZ1Blade, MaxZ1)
         ParkCSawZ1 = min( ParkCSawZ1, MaxZ1)
         ParkCSaw0Z1 = min( ParkCSaw0Z1, MaxZ1)
         Mortiser = ( Mortiser and not Progress)
+         SecondToolChanger = ( SecondToolChanger and not Progress)
      end
   end
 end
@@ -273,6 +246,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'}
@@ -280,6 +255,10 @@ if Progress then
   table.insert( sBaseAux, 'BASE/TC1S')
   table.insert( sBaseAux, 'BASE/TC2')
   table.insert( sBaseAux, 'BASE/TC3')
+elseif SecondToolChanger then
+   table.insert( sBaseAux, 'BASE/TC2')
+   table.insert( sBaseAux, 'BASE/TC2S')
+   table.insert( sBaseAux, 'BASE/TC3')
 else
   table.insert( sBaseAux, 'BASE/MTC')
   if Mortiser then table.insert( sBaseAux, 'BASE/TC3') end
@@ -299,7 +278,7 @@ local X1Id = EmtAxis {
      Home = ParkX1,
      Invert = true,
      Geo = 'X1_AXIS/GEO',
-      Aux = 'X1_AXIS/SOLID'}
+      Aux = {'X1_AXIS/SOLID', 'X1_AXIS/COLLISION'}}
 --  *** Testa 1 ***
 EmtAxis {
      Name = 'Z1',
@@ -373,7 +352,7 @@ EmtAxis {
      Home = 0,
      Geo = 'A1_AXIS/GEO'}
 local H13Id
-if Progress then
+if Progress or SecondToolChanger then
   H13Id = EmtHead {
         Name = 'H13',
         Parent = 'A',
@@ -404,9 +383,9 @@ else
 end
 EgtSetInfo( H13Id, 'ZSAFEDELTA', '60')
 EgtSetInfo( H13Id, 'ZMAXONROT', '1,80')
-- Mortasatrice sotto la traversa (solo per One)
+-- Mortasatrice sotto la traversa (solo per One base con un solo cambio utensile)
 local H15Id
-if not Progress and Mortiser then
+if not Progress and Mortiser and not SecondToolChanger then
   H15Id = EmtHead {
         Name = 'H15',
         Parent = 'A',
@@ -444,7 +423,7 @@ local PY1Id = EmtAxis {
      Stroke = {0, MaxHoOpen},
      Home = MaxHoOpen,
      Geo = 'PY1_AXIS/GEO',
-      Aux = 'PY1_AXIS/SOLID'}
+      Aux = {'PY1_AXIS/SOLID', 'PY1_AXIS/CLAMP_CHECK'}}
 local Y2Id = EmtAxis {
      Name = 'Y2',
      Parent = 'Base',
@@ -464,7 +443,7 @@ local PY2Id = EmtAxis {
      Stroke = {0, MaxHoOpen},
      Home = MaxHoOpen,
      Geo = 'PY2_AXIS/GEO',
-      Aux = 'PY2_AXIS/SOLID'}
+      Aux = {'PY2_AXIS/SOLID', 'PY2_AXIS/CLAMP_CHECK'}}
 -- Rulli
 local V1Id = EmtAxis {
      Name = 'V1',
@@ -575,6 +554,7 @@ EmtTable {
      Parent = 'T',
      Type = MCH_TT.FLAT,
      Ref1 = Point3d( - DimTabX, DeltaTabY - DimTabY, DeltaTabZ),
+      Coll = 'Base/BELT',
      Geo = 'TABLE/GEO',
      Aux = 'TABLE/SOLID'}
 -- *** ToolChanger ***
@@ -660,16 +640,33 @@ EmtTcPos {
      TDir = -Y_AX(),
      ADir = -X_AX(),
      Geo = 'BASE/T10'}
-if Progress then
+if Progress or SecondToolChanger then
   local ptTc2 = Point3d( 150, -170, -217 + ( DeltaTabZ + DeltaRulliTraveZ + 29))
   local vtDt2 = Vector3d( 0, 0, - 102.5)
+   if SecondToolChanger then
   EmtTcPos {
         Name = 'T11',
         Parent = 'Base',
-         Pos = ptTc2 + Vector3d( SawOffsX, SawOffsZ, 0),
+         Pos = ptTc2,
         TDir = Y_AX(),
         ADir = -X_AX(),
-         Geo = 'BASE/T11'}
+         Geo = 'BASE/T11b'}
+   EmtTcPos {
+         Name = 'T12',
+         Parent = 'Base',
+         Pos = ptTc2 + 1 * vtDt1,
+         TDir = Y_AX(),
+         ADir = -X_AX(),
+         Geo = 'BASE/T12'}
+   else
+      EmtTcPos {
+            Name = 'T11',
+            Parent = 'Base',
+            Pos = ptTc2 + Vector3d( SawOffsX, SawOffsZ, 0),
+            TDir = Y_AX(),
+            ADir = -X_AX(),
+            Geo = 'BASE/T11'}
+   end
   EmtTcPos {
         Name = 'T13',
         Parent = 'Base',
@@ -744,9 +741,9 @@ else
         ADir = X_AX(),
         Geo = 'BASE/T201'}
 end
-if Progress or Mortiser then 
+if Progress or Mortiser or SecondToolChanger then 
   local ptTc3 = Point3d( 480, 506.1, -200.8 + ( DeltaTabZ + DeltaRulliTraveZ + 29))
-   local sName = EgtIf( Progress, 'T101', 'T301')
+   local sName = EgtIf( Progress or SecondToolChanger, 'T101', 'T301')
   EmtTcPos {
         Name = sName,
         Parent = 'Base',
@@ -767,14 +764,17 @@ EgtMove( EgtGetFirstNameInGroup( BaseId, 'TC2') or GDB_ID.NULL, vtMovB, GDB_RT.G
 EgtMove( EgtGetFirstNameInGroup( BaseId, 'TC3') or GDB_ID.NULL, vtMovB, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( BaseId, 'MTC') or GDB_ID.NULL, vtMovB, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( X1Id, 'SOLID'), vtMovB, GDB_RT.GLOB)
+EgtMove( EgtGetFirstNameInGroup( X1Id, 'COLLISION'), vtMovB, GDB_RT.GLOB)
 local vtMovC = Vector3d( 0, 0, ( DeltaTabZ + DeltaRulliTappetoZ + 1545))      -- -( -1060 - 485)
 EgtMove( EgtGetFirstNameInGroup( BaseId, 'BELT'), vtMovC, GDB_RT.GLOB)
 local vtMove = Vector3d( 0, ( DeltaTabY - 1550.0), ( DeltaTabZ + 1060.0))
 EgtMove( EgtGetFirstNameInGroup( BaseId, 'CONVOYER'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( Y1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( PY1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
+EgtMove( EgtGetFirstNameInGroup( PY1Id, 'CLAMP_CHECK'), vtMove + Vector3d(0,0,DistZClampToTable), GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( Y2Id, 'SOLID'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( PY2Id, 'SOLID'), vtMove, GDB_RT.GLOB)
+EgtMove( EgtGetFirstNameInGroup( PY2Id, 'CLAMP_CHECK'), vtMove + Vector3d(0,0,DistZClampToTable), GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( V1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( PV1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( QV1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
@@ -805,10 +805,10 @@ function OnSetHead()
   if EMC.HEAD == 'H11' or EMC.HEAD == 'H12' then
      if EMC.HEAD == 'H11' then
         local dRawH = GetRawHeight()
-         EmtModifyAxisHome( 'Z1', ParkZ1 + EgtIf( dRawH > 650, EgtIf( EMC.TOTDIAM < 61, 235, 165), 0))
+         EmtModifyAxisHome( 'Z1', MaxZ1)
         EmtModifyAxisDirection( 'B1', X_AX())
      else
-         EmtModifyAxisHome( 'Z1', ParkZ1)
+         EmtModifyAxisHome( 'Z1', MaxZ1Blade)
         EmtModifyAxisDirection( 'B1', Vector3d( cos( SawC1Offs), -sin( SawC1Offs), 0))
      end
      local nPos = tonumber( string.sub( EMC.TCPOS, 2)) or 0
@@ -817,9 +817,20 @@ function OnSetHead()
         EmtModifyAxisHome( 'C1', ParkC1)
         EmtModifyAxisHome( 'B1', ParkB1)
      else
+         local MyHomeB1, MyHomeC1
+         -- se cambio utensile verticale
+         if EgtGetHeadId( 'H21') or Progress or SecondToolChanger then
+            MyHomeB1 = ParkFrnB1
+            MyHomeC1 = ParkFrnC1
+         -- altrimenti su one CU speciale motosega-utensile lungo
+         else
+            MyHomeB1 = ParkLongToolB1
+            MyHomeC1 = ParkLongToolC1
+         end
+
         EmtModifyAxisHome( 'X1', ParkFrnX1)
-         EmtModifyAxisHome( 'C1', ParkFrnC1)
-         EmtModifyAxisHome( 'B1', ParkFrnB1)
+         EmtModifyAxisHome( 'C1', MyHomeC1)
+         EmtModifyAxisHome( 'B1', MyHomeB1)
      end
   -- se testa H13 (sega a catena)
   elseif EMC.HEAD == 'H13' then
@@ -935,7 +946,7 @@ function GetZExtra( sHead, dAngV)
      elseif abs( dAngV) < 60.1 then
         return 200
      elseif abs( dAngV) < 90.1 then
-         return 10
+         return 1
      else
         return 0
      end
@@ -947,7 +958,9 @@ function GetZExtra( sHead, dAngV)
      elseif abs( dAngV) < 60.1 then
         return 200
      elseif abs( dAngV) < 90.1 then
-         return 10
+         return 1
+      elseif abs( dAngV) < 120 then
+         return -100
      else
         return 0
      end
@@ -7,18 +7,20 @@
 [Sawing]

 [Milling]
-0=d,MaxElev,0
+0=l,MaxElev,0
 1=d,OutRaw,0
-2=d,SideElev,0
+2=l,SideElev,0
 3=d,TrimExt,0
-4=sr,VtFaceUse,0,0,0
+4=s,VtFaceUse,0,0,0
+5=s,EdgesFaceUse,0

 [Pocketing]
-0=d,MaxElev,0
+0=l,MaxElev,0
 1=b,Open,0
-2=d,OpenMinSave,0
+2=d,OpenMinSafe,0
 3=d,OpenOutRaw,0
-4=d,MaxOptSize,0
+4=l,MaxOptSize,0
+5=b,AdjustFeed,1

 [Mortising]
 0=d,MaxElev,0
@@ -30,21 +32,28 @@
 [SawFinishing]

 [GenMachining]
-0=l,LinTol,0.1
-1=l,MaxLen,2
-2=s,Type,ZigZag
-3=d,SideAng,90
-4=l,Step,10
-5=l,OffsProj,0
-6=l,LiTang,0
-7=l,LiOrth,0
-8=l,LiElev,0
-9=l,LoTang,0
-10=l,LoOrth,0
-11=l,LoElev,0
-12=b,DirFromGuide,1

 [SurfRoughing]
+0=l,MaxElev,1000
+1=b,PlaneZ,0

 [SurfFinishing]
 0=b,SkipMaxDown,1
+
+[5AxMilling]
+0=l,LinTol,0.01
+1=l,MaxLen,10
+2=s,Type,ZigZag
+3=d,SideAng,90
+4=l,Step,10
+5=d,AngIni,-90
+6=d,AngFin,90
+7=l,LiTang,0
+8=l,LiOrth,0
+9=l,LiElev,0
+10=l,LoTang,0
+11=l,LoOrth,0
+12=l,LoElev,0
+13=b,DirFromGuide,0
+14=b,SurfAvoid,0
+
@@ -29,8 +29,30 @@ local GS = {}

 -- Configurazione posizioni (con o senza TC2)
 local PositionTable = {}
+-- se secondo toolchanger
+if EgtGetTcPosId( 'T12') then
+   PositionTable = {{Pos = "Pos1",  TcPos = "T1",  Head = "H12", Group = "G1"},
+                    {Pos = "Pos2",  TcPos = "T3",  Head = "H11", Group = "G1"},
+                    {Pos = "Pos3",  TcPos = "T4",  Head = "H11", Group = "G1"},
+                    {Pos = "Pos4",  TcPos = "T5",  Head = "H11", Group = "G1"},
+                    {Pos = "Pos5",  TcPos = "T6",  Head = "H11", Group = "G1"},
+                    {Pos = "Pos6",  TcPos = "T7",  Head = "H11", Group = "G1"},
+                    {Pos = "Pos7",  TcPos = "T8",  Head = "H11", Group = "G1"},
+                    {Pos = "Pos8",  TcPos = "T9",  Head = "H11", Group = "G1"},
+                    {Pos = "Pos9",  TcPos = "T10", Head = "H11", Group = "G1"},
+                    {Pos = "Pos10", TcPos = "T11", Head = "H11", Group = "G2"},
+                    {Pos = "Pos11", TcPos = "T12",  Head = "H11", Group = "G2"},
+                    {Pos = "Pos12", TcPos = "T13", Head = "H11", Group = "G2"},
+                    {Pos = "Pos13", TcPos = "T14", Head = "H11", Group = "G2"},
+                    {Pos = "Pos14", TcPos = "T15", Head = "H11", Group = "G2"},
+                    {Pos = "Pos15", TcPos = "T16", Head = "H11", Group = "G2"},
+                    {Pos = "Pos16", TcPos = "T17", Head = "H11", Group = "G2"},
+                    {Pos = "Pos17", TcPos = "T18", Head = "H11", Group = "G2"},
+                    {Pos = "Pos18", TcPos = "T19", Head = "H11", Group = "G2"},
+                    {Pos = "Pos19", TcPos = "T20", Head = "H11", Group = "G2"},
+                    {Pos = "Pos20", TcPos = "T101", Head = "H13", Group = "G3"}}
 -- se Progress
-if EgtGetTcPosId( 'T11') then
+elseif EgtGetTcPosId( 'T11') then
   PositionTable = {{Pos = "Pos1",  TcPos = "T1",  Head = "H11", Group = "G1"},
                    {Pos = "Pos2",  TcPos = "T2",  Head = "H11", Group = "G1"},
                    {Pos = "Pos3",  TcPos = "T3",  Head = "H11", Group = "G1"},
@@ -8,6 +8,7 @@
 0=th,TH,
 1=d,STEP
 2=s,DOUBLE
+3=d,SECDIST

 [SAW_STD]
 0=th,TH,
@@ -1,5 +1,131 @@
           ==== Common_ONE-PF Update Log ====

+Versione 3.1c2 (17/03/2026)
+- (SIM-GEN) Aggiunta OnSpecialApplyMachining per calcolare i carrelli da subito
+-           Aggiungendo OnSpecialApplyMachining, ora la OnSpecialGetPrevMachiningOffset lavora correttamente. ATT: MIN_MACH -> 3.1b2
+
+
+Versione 3.1c1 (04/03/2026)
+- (GEN) Corretta chiamata di una variabile insesistente in caso di ONE
+- (SIM) Allineata simulazione a generazione
+
+Versione 3.1b1 (20/02/2026)
+- (GEN) Aggiunta funzione ToolPreSelection() per la preselezione utensile. Ticket#2789
+- (GEN) Funzione rinominata in ToolPreSelectionSingleHead(), ora utilizza funzione in MLDE per capire se è motosega
+
+Versione 3.1a1 (16/01/2026)
+- (SIM-GEN) Aggiunto controllo che evita collisioni durante lo svincolo in Z della sega a catena nelle funzioni ExecMoveZMax() e EmitZMax(). Ticket#2767
+- (SIM-GEN) Piccola correzione modifiche fatte in precedenza
+
+Versione 2.7l1 (18/12/2025)
+- (SIM-GEN) Aggiunto controllo post movimenti ausiliari dell' EMC.PREVOFFSX nella funzione OnSpecialGetPrevMachiningOffset(). Ticket#2727
+- (SIM-GEN) Divisione movimento B in approccio se > 90°. Ticket#2754
+- (SIM) Aggiunta funzione CheckClamping
+
+Versione 2.7k3 (28/11/2025)
+- (GEN) Prima di andare allo scarico, si aggiunge movimento intermedio dove si aspetta che rulli scarico siano arrivati in posizione. Ticket#2716
+
+Versione 2.7k2 (20/11/2025)
+- (SIM) Aggiornata risoluzione VMillTol in funzione dello spessore lama
+
+Versione 2.7k1 (05/11/2025)
+- (SIM-GEN) Corretto calcolo per decidere se serve aprire i rulli
+- (GEN) Aggiunta tolleranza in creazione piano di lavoro inclinato
+- (SIM) Allo scarico si resetta Y2DELTA. Ticket#2687
+
+Versione 2.7j3 (23/10/2025)
+- (SIM) Corretta posizione parcheggio in caso di testa 1 su magazzino 2. Ticket#2660
+
+Versione 2.7j2 (21/10/2025)
+- (GEN) Se SPLIT con pinza 5, corretto salvataggio posizione pinza 2. Ticket#2654
+
+Versione 2.7j1 (08/10/2025)
+- (GEN) Salvataggio posizione Z su lavorazione precedente, sbagliava in caso di separazione. Ticket#2637
+
+Versione 2.7i1 (10/09/2025)
+- (SIM-GEN) Piccole correzioni per gestire secondo TC su ONE. Ticket#2563
+- (SIM-GEN) Gestione aggregato BH completato. Ticket#2482
+- (EST) Stima tempi considerando accelerazioni
+- (SIM-GEN) Se fase start o restart, si aggiorna la posizione in X dell'asse per calcolare il link corretto
+- (GEN) Piccola correzione risalita ZMAX dopo RELOAD del pezzo. Generazione allineata a simulazione.
+
+Versione 2.7h2 (28/08/2025)
+- (GEN) Migliorata gestione spegnimento utensile e disattivazione piano
+- (SIM-GEN) Corretto nome variabile e altre piccole modifiche per Progress
+
+Versione 2.7h1 (20/08/2025)
+- (SIM-GEN) Non si chiudono i rulli se tagli o pretagli di testa e coda
+- (SIM) Corretto movimento pinza 5 in caso di riposizionamento pinza 1
+- (GEN) Corretta quota assoluta posizione testa trave in caso di pinza 5 e testa rimasta bassa
+- (GEN) Se ultima lavorazione pezzo precedente ha stesso utensile della prima lavorazione pezzo successivo, la speed resta accesa
+
+Versione 2.7g4 (23/07/2025)
+- (SIM-GEN) Aggiunto parametro configurabile da TS3 per massima sporgenza trave in coda per pinza 5. Ticket#2538
+
+Versione 2.7g3 (22/07/2025)
+- (SIM) Corretto lettura angolo di presa della motosega
+
+Versione 2.7g2 (08/07/2025)
+ - (SIM) Corretto movimento a parcheggio sega a catena. Ticket#2517
+
+Versione 2.7g1 (01/07/2025)
+- (GEN) Rimossa gestione PROBE inserita per sbaglio
+- (GEN) Corretto gestione accelerazioni
+- (SIM-GEN) Aggiunta gestione massima lunghezza scarico
+
+Versione 2.7f1 (04/06/2025)
+- (SIM) Aggiunta gestione qualità VMILL da impostazioni macchina. Tolto parametro 'CoeffVM'.
+- (GEN) Aggiunti parametri FMAXPINZE, MAXACC, MINACC configurabili da TS3. Ticket#2052
+
+Versione 2.7e1 (28/05/2025)
+- (SIM-GEN) Alla separazione si spostano i carrelli di 30mm aprendo il taglio. Ticket#2259,Ticket#2328
+
+Versione 2.7d1 (16/04/2025)
+- (SIM) Distanza di collisione portata a 3mm, qualità VMILL ridotta a 4mm. Ticket#2395
+
+Versione 2.7c3 (25/03/2025)
+- (GEN) Corretto movimento approccio alla lavorazione se utensile lama montata su magazzino 2. Ticket#2361
+
+Versione 2.7c2 (12/03/2025)
+- (SIM-GEN) Migliorato calcolo posizione barra dopo split. Tiene in considerazione ingombro lavorazioni pezzo. Ticket#2321
+- (GEN) Aggiunta commenti HEADER e FOOTER per comunicazione con linea o altre macchine, da parte di Essetre.
+- (SIm-GEN) Migliorato movimento approccio al pezzo con lama. Allineamento simulazione-generazione che facevano due movimenti leggermente diversi. Ticket#2335
+
+Versione 2.7c1 (05/03/2025)
+- (GEN) Corretto movimento in home utensile precedente. Ticket#2324
+
+Versione 2.7b1 (07/02/2025)
+- (SIM-GEN) In caso di Progress, alla deselezione utensile testa 1 su TC2 si fa movimento Z raddrizzando asse B. Ticket#2247
+- (SIM-GEN) Estensione soluzione Ticket#2206. Ora si aprono di 5mm extra anche se solo una morsa resta in posizione. Ticket#2259
+- (SIM) Migliorato controllo collisioni con traversa. Ora si considera asse X. Serve modifica NGE! Ticket#2257
+
+Versione 2.7a2 (15/01/2024)
+- (SIM-GEN) In caso di testa 1 su TC2 (ONE), si ruota prima la C e poi la B. Ticket#2247
+
+Versione 2.7a1 (07/01/2024)
+- (GEN) In separazione, quando si porta indietro il restante, si aprono le paratie rulli subito. Ticket#2214
+- (SIM-GEN) Se entrambe le morse sono restate in posizione, le sposto comunque di 5mm per distanziare i pezzi separati. Ticket#2206
+
+Versione 2.6l2 (09/12/2024)
+- (SIM-GEN) Corretto problema introdotto in 2.6l1 per risolvere #2198. Ticket#2203
+- (SIM-GEN) In MLSE modificato controllo direzione utensile per determinare Z massima. Ticket#2204
+
+Versione 2.6l1 (02/12/2024)
+- (SIM) Dopo scarico pezzo per ribaltamento, si aprono sempre i rulli. Ticket#2192
+- (SIM-GEN) Nei movimenti si ricalcola la Z solo se la quota di lavoro è più in alta della posizione a ZHOME della testa. Ticket#2198
+- (GEN) Se bisogna andare in home, ma la testa lo è già, non si scrive nulla
+
+Versione 2.6j3 (21/10/2024)
+- (GEN) Se richiesto movimento in home, si scrive sempre parcheggio in home dell'utensile precedente. Prima si scriveva solo per lama.
+
+Versione 2.6j2 (17/10/2024)
+- (SIM-GEN) Se motosega prelevata con A=0, alla fine la si porta sempre alla quota ZMAX, indipendentemente dall'altezza trave che era fissata a 650mm. Ora lo fa sempre.
+
+Versione 2.6j1 (08/10/2024)
+- (SIM-GEN) Corretto primo movimento di approccio al pezzo. Ticket#2093
+- (SIM-GEN) Corretto movimento in Home in caso di lama e movimento rulliera di carico. Ticket#2054
+- (GEN) In caso di movimento in Home non si fa più preselezione ma si tiene utensile vecchio. Ticket#1926
+
 Versione 2.6i2 (13/09/2024)
 - (GEN) Migliorato calcolo chiusura paratia rulli con aggiornamento lunghezza della barra in caso di ultimo taglio e grezzo residuo in coda. Ticket#2017
 - (NGE-MLDE-GEN-SIM) Aggiunto solidi collisione TC.  Corretto movimento a Y di sicurezza con lama. Ticket#2042
@@ -3,8 +3,8 @@

 local InfoCommon_STD_PP = {
   NAME = 'Common_ONE-PF',            -- nome script PP standard
-   VERSION = '2.6i2',                 -- versione script
-   MIN_MACH_VER_PP_COMMON = '2.5k1'   -- versione minima kernel
+   VERSION = '3.1c2',                 -- versione script
+   MIN_MACH_VER_PP_COMMON = '3.1b2'   -- versione minima kernel
 }

 return InfoCommon_STD_PP
Author	SHA1	Message	Date
daniele.nicoli	c2fbbfd6d9	Spostato EgtClamp della massima velocità pinze (MaxFeedPinze) nell'mlde. Aumentato il massimo da 102000 a 155000	2026-05-08 16:41:38 +02:00
andrea.villa	4f7b11c715	Cambio versione	2026-05-08 08:17:44 +02:00
andrea.villa	804002fc6e	Deselezione motosega in caso di movimento in home (DA SISTEMARE)	2026-05-07 17:02:20 +02:00
andrea.villa	dae3b89b4d	Prima versione nuovi link	2026-05-07 10:51:13 +02:00
daniele.nicoli	caeed11218	Aggiunto Clamp di sicurezza per lettura dei parametri MinJoin da Ts3Data	2026-04-23 12:25:31 +02:00
daniele.nicoli	9beb1ecb41	Merge branch 'master' into develop	2026-04-23 12:24:08 +02:00
andrea.villa	3092966bff	Merge remote-tracking branch 'origin/develop'	2026-03-17 15:16:56 +01:00
andrea.villa	e5715f3808	Allineamento a common ver. 3.1c2	2026-03-17 15:16:43 +01:00
daniele.nicoli	bd02e140d2	Aggiunto info "PreviewShow" per anteprima utensile/testa nel MACH	2026-03-09 08:29:05 +01:00
daniele.nicoli	777bda68ff	Aggiunti parametri di lettura da TS3Data.lua: MIN_JOIN_S, MIN_JOIN_L e MAX_ANGLE_DRILL_CUT	2026-03-05 14:44:08 +01:00
daniele.nicoli	fe6f9d4523	Merge remote-tracking branch 'origin/HEAD' into develop	2026-03-05 14:42:32 +01:00
andrea.villa	5fa0594754	Allineamento con common ver. 3.1c1	2026-03-04 10:32:16 +01:00
andrea.villa	8bc06dbb15	Merge remote-tracking branch 'origin/develop'	2026-02-20 09:00:35 +01:00
andrea.villa	d9308f4c7e	Allineamento con common ver. 3.1b1	2026-02-20 09:00:19 +01:00
daniele.nicoli	0262c1241f	Aggiunta la lettura da TS3Data.lua delle corse dell'asse W (MIN_W e MAX_W)	2026-02-03 10:48:53 +01:00
daniele.nicoli	dac8bb129d	Merge branch 'master' into develop	2026-02-03 10:47:24 +01:00
andrea.villa	3a67314ccd	Allineamento con common ver. 3.1a1	2026-01-16 15:40:06 +01:00
andrea.villa	b2ce5e69a0	Merge remote-tracking branch 'origin/develop'	2025-12-18 16:05:13 +01:00
andrea.villa	6a9b2b5f58	- Allineamento a common ver. 2.7l1 - Aggiunto parametro MAX_ANGLE_DRILL_CUT a BeamData - Recupero nome macchina da funzione EGT	2025-12-18 16:05:00 +01:00
andrea.villa	ed4a3db13b	Merge remote-tracking branch 'origin/TestCheckPinzaggioVMILL' into develop	2025-12-18 16:02:25 +01:00
daniele.nicoli	0825eb8227	Modificata versione in 2.7l1_DEV1	2025-12-15 09:50:42 +01:00
daniele.nicoli	51a27d960b	Versione con aggiornamento di test a Common.mlpe: - mlpe, aggiunta funzione ClampCheck - nge, aggiunta geometria - mlde, aggiunte variabili, geometria e spostamento. Il coefficente è impostato a nil e modificabile da TS3Data.	2025-12-15 09:49:07 +01:00
daniele.nicoli	5c27dca65c	Merge branch 'master' into develop	2025-12-15 09:00:04 +01:00
andrea.villa	8df0b7b47e	Corretto disegno porta utensile	2025-12-11 09:20:57 +01:00
andrea.villa	7d0f491909	- Nuovo ToolHolder - Allineamento con common ver. 2.7k3	2025-11-28 15:40:49 +01:00
andrea.villa	4165843cf9	Merge remote-tracking branch 'origin/develop'	2025-11-20 16:58:22 +01:00
andrea.villa	61bb0aa701	- Allineamento a common ver. 2.7k2 - Cambio versione per rilascio a cliente	2025-11-20 16:58:00 +01:00
daniele.nicoli	f3f9f38c84	Aggiunta gestione CUT_SIC impostabile da TS3Data.lua	2025-11-13 11:23:32 +01:00
daniele.nicoli	4b12300100	Merge branch 'master' into develop	2025-11-13 10:55:48 +01:00
andrea.villa	1f93f2f45a	Allineamento con common ver. 2.7k1	2025-11-05 13:22:45 +01:00
andrea.villa	718d2ceee3	Allineamento con common ver. 2.7j3	2025-10-23 07:48:09 +02:00
andrea.villa	d85a6e3ba3	#critical# Allineamento con common ver. 2.7j2	2025-10-21 10:47:03 +02:00
andrea.villa	605400d40c	Allineamento con common ver. 2.7j1	2025-10-08 13:12:51 +02:00
andrea.villa	3576c6ac11	Allineamento con common ver. 2.7i1, HOTFIX	2025-09-10 12:10:26 +02:00
andrea.villa	dc43388def	- Allineamento common ver. 2.71 - Aggiunto solido collisione per tappeto	2025-09-10 10:35:22 +02:00
andrea.villa	3102d381ed	Piccole correzioni per gestire secondo TC su ONE	2025-08-29 16:52:09 +02:00
andrea.villa	3e80505457	- Sistemato script per setup - Rimosso frame copiato per sbaglio	2025-08-28 14:50:25 +02:00
andrea.villa	7d1749c9ab	- Allinemento con common ver. 2.7h2 - Aggiunto secondo cambio utensile	2025-08-28 13:06:28 +02:00
andrea.villa	900cc65fb0	Merge remote-tracking branch 'origin/develop'	2025-08-20 14:31:12 +02:00
andrea.villa	7850144992	Allineamento con common ver. 2.7h1	2025-08-20 14:30:55 +02:00
andrea.villa	d6c384d159	Merge remote-tracking branch 'origin/V1OpenOnTailCut' into develop	2025-08-20 14:28:59 +02:00
luca.mazzoleni	b314c701fb	V1OpenOnTailCut	2025-08-06 10:30:40 +02:00
luca.mazzoleni	1c731d2f51	Merge branch 'master' into develop	2025-08-06 10:21:17 +02:00
andrea.villa	9da267149a	- Allineamento con common ver. 2.7g4 - Aggiunto parametro MaxBackClamp5	2025-07-23 12:15:47 +02:00
andrea.villa	ee7db694e6	Allineamento con common ver. 2.7g3	2025-07-22 11:17:55 +02:00
andrea.villa	b66f238ca5	Alineamento con common ver. 2.7g1	2025-07-01 10:07:32 +02:00
andrea.villa	edd07a5bc5	- Allineamento con Common ver. 2.7e1 - Aggiornamento versione	2025-05-28 12:39:28 +02:00
andrea.villa	5825c0f292	Merge commit '8307af3165c0a7129705f4c27387d0bfac7a1190'	2025-05-21 08:33:03 +02:00
andrea.villa	7e5738ffa9	Cambio versione	2025-04-28 13:38:47 +02:00
andrea.villa	947a2c27ae	- Allineamento con common ver. 2.7d1 - Aggiornamento MachNotes - Lettura PRECUT per automatismo	2025-04-16 13:43:07 +02:00
andrea.villa	b6f4304daa	#critical# Allineamento con common 2.7c3	2025-03-26 07:59:49 +01:00
andrea.villa	4cb36a2899	Allineamento con common ver. 2.7c2	2025-03-12 08:30:20 +01:00
andrea.villa	8307af3165	Alla separazione si aprono le pinze di 30mm per evitare che pezzo torni indietro dell'offset compensato con misurazione laser. E' un test, non siamo sicuri che sia questo il problema.	2025-03-10 12:30:03 +01:00
andrea.villa	3c31786eae	Merge remote-tracking branch 'origin/master' into develop	2025-03-10 12:26:50 +01:00
andrea.villa	0097239f56	Merge remote-tracking branch 'origin/develop'	2025-03-05 11:50:17 +01:00
andrea.villa	6b40c6e9f0	Allineamento con common ver. 2.7c1	2025-03-05 11:50:06 +01:00
andrea.villa	82dfa8fa65	Merge branch 'master' into develop	2025-02-07 12:48:23 +01:00
andrea.villa	906fd1ae7c	Merge remote-tracking branch 'origin/develop'	2025-02-07 12:48:08 +01:00
andrea.villa	6e490a1675	- Allineamento con common ver. 2.7b1 - Modifica NGE per collisioni con traversa	2025-02-07 12:47:53 +01:00
andrea.villa	333b64981b	Estensione soluzione Ticket#2206. Ora si aprono di 5mm extra anche se solo una morsa resta in posizione.	2025-01-23 09:06:07 +01:00
andrea.villa	7f63045fef	In caso di Progress, alla deselezione utensile testa 1 su TC2 si fa movimento Z raddrizzando asse B.	2025-01-16 09:21:40 +01:00
andrea.villa	cb04bbfe11	Merge remote-tracking branch 'origin/master' into develop	2025-01-16 09:21:04 +01:00
andrea.villa	83f8b80aa3	Aggiunta nota utensile	2025-01-15 12:06:30 +01:00
andrea.villa	f97836f1d3	- Allineamento con common ver. 2.7a1 - In MLDE si legge il parcheggio della punta lunga su utensile standard ONE	2025-01-15 12:01:54 +01:00
andrea.villa	6a798bf431	Allineamento con common ver. 2.7a1	2025-01-07 16:31:09 +01:00
andrea.villa	0754284247	- Allineamento con common vr. 2.6l2 - In GetZExtra contemplato anche casi sotto-squadra	2024-12-09 12:40:30 +01:00
andrea.villa	2a6edc5bdd	- Allineamento con common ver. 2.6l1 - Aggiunta variabile ROT180 per rotazioni nuovo automatismo	2024-12-02 08:35:40 +01:00
andrea.villa	32fcb2d854	Allineamento con common ver. 2.6j2	2024-10-21 16:56:53 +02:00
andrea.villa	32df68c419	- Allineamento con common ver. 2.6j2 - Tolti i commenti iniziali da quando è stato creato progetto GIT	2024-10-17 12:28:11 +02:00
andrea.villa	970bed202e	Corretto calcolo posizione parcheggio V1 e V2	2024-10-09 14:24:19 +02:00
andrea.villa	a7cf030659	Merge remote-tracking branch 'origin/develop'	2024-10-08 11:45:29 +02:00
andrea.villa	70f9b6b596	- Allineamento con common ver. 2.6j1	2024-10-08 11:45:16 +02:00
andrea.villa	01f223f690	Migliorie movimento in ZMAX leggendo quota X precedente	2024-10-03 10:10:16 +02:00