Prima versione con gestione nuovi link

- Aggiungendo OnSpecialApplyMachining, ora la OnSpecialGetPrevMachiningOffset lavora correttamente. ATT: MIN_MACH -> 3.1b2

Common_ONE-PF.mlse

@@ -7,211 +7,460 @@ 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 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]}}
+
+   -- 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})
+
+   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' 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;')
+         -- 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 > 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 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;')
+         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;', '')..'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.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1p, EMC.L2p, ParkZ1, EMC.R1p, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 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)
+         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;')
+         -- 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 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)
+         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;')
+
+      -- 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 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.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1p, EMC.L2p, ParkZ1, EMC.R1p, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 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, 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)
+         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 +472,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 +903,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 +1015,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 +1037,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 +1053,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 +1110,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
 
 ---------------------------------------------------------------------
@@ -942,8 +1256,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
@@ -1097,29 +1420,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 +1459,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()
@@ -1218,6 +1545,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]
@@ -1423,7 +1778,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 +1908,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 +1920,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 +3115,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)
@@ -2782,6 +3159,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 riposizionam,ento
+      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]
@@ -2821,8 +3202,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
 
 ---------------------------------------------------------------------

UpdateLog.txt

@@ -1,5 +1,154 @@
            ==== Common_ONE-PF Update Log ====
 
+Versione 3.1-- (--/--/2026)
+- (ALL) Prima versione con gestione nuovi link (no tastatore)
+
+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.
+
+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
+- (NGE-SIM) Aggiunta collisione magazzino motosega ONE
+
+Versione 2.6i1 (02/09/2024)
+- (SIM-GEN) Quando si aprono i rulli, se la trave non può seguire i rulli perchè la pinza andrebbe in extra-corsa, si sposta comunque la pinza fino al massimo della sua corsa. Ticket#1949
+- (GEN) In preselezione. Se lavorazione motosega, non mando a parcheggio altra testa con utensile precedente, perchè subito dopo viene chiamata preselezione. Ticket#1961 
+
+Versione 2.6h2 (07/08/2024)
+- (SIM) Allineata simulazione a generazione in primo movimento rapido approccio al pezzo.
+
+Versione 2.6h1 (01/08/2024)
+- (GEN) Corretto segno posizione X di sicurezza per rotazione assi rotanti.
+
 Versione 2.6g5 (31/07/2024)
 - (SIM-GEN) Se motosega allineata ad asse B per tagli di fianco, corretto movimento che manda testa a parcheggio. Pezzi più alti di 650 va solo in Zmax. Ticket#1943
 - (SIM-GEN) Gestione movimenti speciali per pezzi molto alti. Se HomeZ < primo punto lavorazione, allora vado al punto Z lavorazione prima di approcciare il pezzo in X. Ticket#1943

Version.lua

@@ -3,8 +3,8 @@
 
 local InfoCommon_STD_PP = {
    NAME = 'Common_ONE-PF',            -- nome script PP standard
-   VERSION = '2.6g5',                 -- versione script
-   MIN_MACH_VER_PP_COMMON = '2.5k1'   -- versione minima kernel
+   VERSION = '3.1--',                 -- versione script
+   MIN_MACH_VER_PP_COMMON = '3.1b2'   -- versione minima kernel
 }
 
 return InfoCommon_STD_PP