Manca gestione, ParkInLavZ2. Per ora messo un messaggio di errore.

- Allineata generazione a simulazione in ParkRoller
- Corretti movimenti in MLSE per lavorazioni in doppio
- Aggiunto STARTMAX=33 in caso di passaggio tra due lav. in doppio che richiede un movimento extra per evitare collisione. Caso tipico passaggio da sopra a sotto del pezzo.
- Piccole migliorie in simulazione

Common_PF1250.mlse

@@ -1,4 +1,4 @@
--- Special Operations macchina Essetre-PF1250 by Egalware s.r.l.  2024/04/09
+-- Special Operations macchina Essetre-PF1250 by Egalware s.r.l.  2025/08/25
 -- Intestazioni
 
 require( 'EmtGenerator')
@@ -7,6 +7,9 @@ EgtEnableDebug( false)
 -- Carico libreria
 local BD = require( 'BeamData')
 
+-- sicurezza aggiuntiva
+local SAFE_DIST = 50
+
 ---------------------------------------------------------------------
 -- *** Generic Machinings ***
 ---------------------------------------------------------------------
@@ -47,6 +50,7 @@ function OnSpecialGetPrevMachiningOffset()
    -- 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
@@ -67,194 +71,486 @@ function OnSpecialGetPrevMachiningOffset()
 end
 
 ---------------------------------------------------------------------
--- *** Special Z moves ***
+-- *** Special Link moves ***
 ---------------------------------------------------------------------
----------------------- OnSpecialGetMaxZ -----------------------------
+-----------------------------------------------------------------------------------------
-local function CalcExtraZ( vtTp, vtT, vMZ)
+local function GetActiveRawBBox()
-   -- la tabella deve esistere ed essere non vuota
+   local b3Raw = BBox3d()
-   if not vMZ or #vMZ == 0 then return 0 end
+   local nRawId = EgtGetFirstRawPart()
-   -- componente Z di riferimento è la minima
+   while nRawId do
-   local vtTz = min( vtTp:getZ(), vtT:getZ())
+      if EgtVerifyRawPartPhase( nRawId, EMC.PHASE) then
-   -- se oltre il massimo
+         b3Raw = EgtGetRawPartBBox( nRawId)
-   if vtTz > vMZ[1].Tz then return vMZ[1].Ez end
+         break
-   -- interpolo
-   for i = 2, #vMZ do
-      if vtTz > vMZ[i].Tz then
-         local dCoeff = ( vtTz - vMZ[i-1].Tz) / ( vMZ[i].Tz - vMZ[i-1].Tz) 
-         return (( 1 - dCoeff) * vMZ[i-1].Ez + dCoeff * vMZ[i].Ez)
       end
+      nRawId = EgtGetNextRawPart( nRawId)
    end
-   -- sotto il minimo
+   return b3Raw
-   return 0
 end
 
----------------------------------------------------------------------
+-----------------------------------------------------------------------------------------
-function OnSpecialGetMaxZ()
+local function IsPrevSplit()
-   -- Inizializzazioni
+   local sPrevUserNotes = ''
-   EMC.ERR = 0
+   if EMC.LINKTYPE == 2 then
-
+      sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
-   -- Gestione speciale per sega a catena
+   elseif EMC.LINKTYPE == 3 then
-   if EMC.HEAD == 'H13' then
+      EgtSetCurrMachining( EMC.PREVMCHID)
-      EMC.MAXZ = EgtGetAxisHomePos( 'Z1')
+      sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
-      return
+      EgtSetCurrMachining( EMC.NEXTMCHID)
-   end
-
-   -- Sistemazione dati di input
-   local vtTp = Vector3d( EMC.TDIRp)
-   local bFromZmax = false
-   -- recupero il gruppo
-   local nSetHead = GetHeadSet( EMC.HEAD)
-   if vtTp:isSmall() then
-      vtTp = X_AX()
-      bFromZmax = true
-      if nSetHead == 1 then
-         EMC.R1p = ParkC1
-         EMC.R2p = ParkB1
-      elseif nSetHead == 2 then
-         EMC.R1p = ParkC2
-         EMC.R2p = ParkB2
-      elseif nSetHead == 3 then
-         EMC.R1p = ParkC3
-         EMC.R2p = ParkB3
-      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
-   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}}
-         EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
-      end
-   elseif EMC.HEAD == 'H12' then
-      if vtTp:getX() > 0.3 and vtT:getX() > 0.3 then
-         if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then
-            EMC.MAXZ = MaxZ1Blade - 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
-         elseif vtTp:getZ() > 0.5 or vtT:getZ() > 0.5 then
-            EMC.MAXZ = ParkZ1 + 100
-         else
-            EMC.MAXZ = ParkZ1 + 1
-         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 then
-         EMC.MAXZ = MaxZ1Blade - 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 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=60}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
-         EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
-      end
-   elseif EMC.HEAD == 'H16' then
-      if vtTp:getX() > 0.3 and vtT:getX() > 0.3 then
-         if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then
-            EMC.MAXZ = MaxZ1Blade - 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
-         elseif vtTp:getZ() > 0.5 or vtT:getZ() > 0.5 then
-            EMC.MAXZ = ParkZ1 + 100
-         else
-            EMC.MAXZ = ParkZ1 + 1
-         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 then
-         EMC.MAXZ = MaxZ1Blade - 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 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=60}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
-         EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
-      end
-   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}}
-         EMC.MAXZ = ParkZ2 + CalcExtraZ( vtTpZm, vtT, vMZ)
-      end
-   elseif EMC.HEAD == 'H38' then
-      EMC.MAXZ = SafeZ3RotAxis
    end
+   return ( sPrevUserNotes:find( 'Split;', 1, true) ~= nil)
 end
 
----------------------- OnSpecialMoveZup -----------------------------
+-----------------------------------------------------------------------------------------
-function OnSpecialMoveZup()
+local function IsMachDoubleHoriz( bOther, nMchIdOther)
-
+   local sPrevUserNotes = ''
-   --EgtOutLog( 'OnSpecialMoveZup : ' .. EMC.HEAD .. '.' .. tostring( EMC.EXIT))
+   if bOther then
-
+      local nCurrMchId = EgtGetCurrMachining()
-   -- Inizializzazioni
+      EgtSetCurrMachining( nMchIdOther)
-   EMC.ERR = 0
+      sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
-   EMC.MODIF = false
+      EgtSetCurrMachining( nCurrMchId)
-
-   -- Direzione utensile
-   local vtT = Vector3d( EMC.TDIR)
-
-   -- recupero Z1 home
-   local nHeadSet = GetHeadSet( EMC.HEAD)
-   local dZmax = EgtGetAxisHomePos( EgtIf( nHeadSet ~= 2, 'Z1', 'Z2'))
-
-
-   -- se fresa su testa1 o testa 2
-   if EMC.HEAD == 'H11' or EMC.HEAD == 'H21' or EMC.HEAD == 'H22' then
-      ;
-   -- se lama
-   elseif EMC.HEAD == 'H12' or EMC.HEAD == 'H16' then
-      -- riporto i valori tra -179 e + 180
-      local dCheckAxR1 = EMC.R1
-      if dCheckAxR1 < -180 then
-         dCheckAxR1 = dCheckAxR1 + 360
-      elseif dCheckAxR1 > 180 then
-         dCheckAxR1 = dCheckAxR1 - 360
-      end
-      -- se lama su testa1
-      if EMC.HEAD == 'H12' then
-         -- se inclinata oltre 90 gradi e interferisce con la trave
-         if ( EMC.R2 > 87.9 and ( dCheckAxR1 < 15.0 or dCheckAxR1 > 180.0)) or ( EMC.R2 < -87.9 and ( dCheckAxR1 > -15.0 and dCheckAxR1 < 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 seconda lama su testa1
-      elseif EMC.HEAD == 'H16' then
-         -- se inclinata oltre 90 gradi e interferisce con la trave
-         if ( EMC.R2 > 87.9 and ( dCheckAxR1 < 15.0 or dCheckAxR1 > 180.0)) or ( EMC.R2 < -87.9 and ( dCheckAxR1 > -15.0 and dCheckAxR1< 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
-   elseif EMC.HEAD == 'H38' then
-      EMC.L3 = SafeZ3RotAxis
-      -- dichiaro modificato
-      EMC.MODIF = true
    else
-      ; -- non si fa nulla
+      sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
    end
+   return EgtGetValInNotes( sPrevUserNotes, 'DOUBLE', 'i') == 2
+end
+
+-----------------------------------------------------------------------------------------
+local function GetHeadDeltaYApproachOnDouble( bPrev)
+   local dDeltaY = false
+   -- recupero ingombro del primo grezzo in lavoro
+   local b3Raw = GetActiveRawBBox()
+   local dMinRawX2 = b3Raw:getMin():getY() - Head2Y
+   local dMaxRawX2 = b3Raw:getMax():getY() - Head2Y
+   local vtToolDir = EgtGetCalcToolDirFromAngles( EgtIf( bPrev, EMC.R1p, EMC.R1), EgtIf( bPrev, EMC.R2p, EMC.R2))
+   local dCurrY = EgtIf( bPrev, EMC.L2p, EMC.L2)
+   local dToolTipY = dCurrY - ( ( EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) + Mill2Offs) * vtToolDir:getY())
+   -- se la punta dell'utensile si trova all'interno del pezzo
+   if dToolTipY > dMinRawX2 and  dToolTipY < dMaxRawX2 then
+      if vtToolDir:getY() > 0 then
+         dDeltaY = dMaxRawX2 - dToolTipY + SAFE_DIST
+      else
+         dDeltaY = dMinRawX2 - dToolTipY - SAFE_DIST
+      end
+   end
+   return dDeltaY
+end
+
+-----------------------------------------------------------------------------------------
+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
+
+   return bSafeMove
+end
+
+-----------------------------------------------------------------------------------------
+function OnSpecialLink()
+
+   -- se fresa su testa 1
+   if EMC.HEAD == 'H11' then
+      -- se inizio lavorazione con prelievo utensile
+      if EMC.LINKTYPE == 1 then
+         -- se lavorazione in doppio e altra ha collegamento diretto, si muove prima l'altra
+         local sHeadToMoveFirst = ''
+         if EMC.OTHERLINKTYPE == 3 then
+            sHeadToMoveFirst = 'HeadToMoveFirst=H2;'
+         end
+         -- approccio
+         EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+         EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;'..sHeadToMoveFirst)
+         -- se asse B resta girato verso home e C resta vicino alla home
+         if abs( EMC.R2 - EMC.R2p) < 90 and abs( EMC.R1 - EMC.R1p) < 5 then
+            ; -- discesa diretta
+         elseif abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2)
+            if abs( EMC.R1 - EMC.R1p) > 1 then
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2)
+            end
+         end
+         EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+
+      -- se fine lavorazione con deposito utensile
+      elseif EMC.LINKTYPE == 2 then
+         -- retrazione
+         EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+         if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, 'FirstRise=1;')
+            if abs( EMC.R1 - EMC.R1p) > 1 then
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2)
+            end
+         else
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, 'FirstRise=1;')
+         end
+         EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2, 'LastRise=1;')
+
+      -- altrimenti collegamento tra due lavorazioni (3)
+      else
+         -- recupero quota massima di collegamento
+         local vFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+         local vInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false)
+         local bSafeMove = IsLinkSafe( vFinalAxLink, vInitAxLink)
+
+         -- se gli assi rotanti non sono cambiati e il collegamento è come ultimo punto della lavorazione
+         if abs( EMC.R1 - EMC.R1p) < 1 and abs( EMC.R2 - EMC.R2p) < 1  and abs( EMC.L3p - vFinalAxLink[3]) < 1 and  abs( EMC.L3 - vInitAxLink[3]) < 1 then
+            bSafeMove = true
+         end
+
+         -- se superata quota massima ammessa
+         if not bSafeMove then
+            -- retrazione
+            EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1, EMC.R1p, 0}, 30, 3, 2, 'UniqueRise=1;')
+            -- approccio
+            EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;')
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+         else
+            -- GESTIONE PER DOPPIO
+            -- se altra testa arriva da home o diretta, devo per forza avere un CLIMB, creo il punto
+            if EMC.OTHERLINKTYPE == 1 then
+               EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, vInitAxLink, 30, 2, 2, 'FirstClimb=1;HeadToMoveFirst=H1;')
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+            -- se altra testa deve andare in home, devo per forza avere un RISE, creo il punto
+            elseif EMC.OTHERLINKTYPE == 2 then
+               EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, vFinalAxLink, 30, 3, 2, 'UniqueRise=1;')
+            end
+         end
+      end
+
+   -- se lama su rinvio standard o opposto di testa 1
+   elseif EMC.HEAD == 'H12' or EMC.HEAD == 'H16' 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)
+         -- se approccio dopo un cambio pinze
+         if EMC.STARTZMAX == 11 then
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;')
+         -- se approccio da home
+         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, EMC.R2p}, 30, 2, 2)
+            -- se asse B cambia di molto
+            if abs( 0 - EMC.R2p) > 1 then
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2)
+            end
+            -- se assi cambiano di molto
+            if abs( EMC.R1 - EMC.R1p) > 10 then
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2)
+            end
+         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)
+         -- se risalita solo per cambio pinze
+         if EMC.STARTZMAX == 11 then
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'UniqueRise=1;')
+         -- se risalita per andare in home
+         else
+            if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;')
+               -- se assi cambiano di molto
+               if abs( EMC.R1 - EMC.R1p) > 10 then
+                  EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2)
+               end
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2, 'LastRise=1;')
+            else
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, 'UniqueRise=1;')
+            end
+         end
+
+      -- altrimenti collegamento tra due lavorazioni (3)
+      else
+         -- recupero quota massima di collegamento
+         local vFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+         local vInitAxLink = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false)
+         local bSafeMove = IsLinkSafe( vFinalAxLink, vInitAxLink)
+
+         -- se gli assi rotanti non sono cambiati e il collegamento è come ultimo punto della lavorazione
+         if abs( EMC.R1 - EMC.R1p) < 1 and abs( EMC.R2 - EMC.R2p) < 1  and abs( EMC.L3p - vFinalAxLink[3]) < 1 and  abs( EMC.L3 - vInitAxLink[3]) < 1 then
+            bSafeMove = true
+         end
+
+         -- se superata quota massima ammessa
+         if not bSafeMove then
+            -- retrazione
+            EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+            if abs( EMC.R2) > 91 then
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, ParkZ1, EMC.R1p, EgtClamp( EMC.R2p, -90, 90)}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;')
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'LastRise=1;')
+            else
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'UniqueRise=1;')
+            end
+            -- approccio
+            EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1Blade, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;')
+            if abs( EMC.R2) > 91 then
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkZ1, EMC.R1, EgtClamp( EMC.R2, -90, 90)}, 30, 2, 2)
+            end
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+         end
+      end
+
+   -- se sega a catena su testa 1
+   elseif EMC.HEAD == 'H13' 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)
+         -- si muove trave mentre si è ancora a Z massima
+         if abs( EMC.R3) < 0.1 then
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z1, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2)
+         else
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2)
+         end
+         EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 31, 2, 2, 'LastClimb=1;')
+
+      -- se fine lavorazione con deposito utensile
+      elseif EMC.LINKTYPE == 2 then
+         -- retrazione
+         EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+         EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2, EMC.R3p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;')
+         EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3p}, 30, 3, 2, 'LastRise=1;')
+      -- altrimenti collegamento tra due lavorazioni (3)
+      else
+      end
+
+   -- se aggregato foratore multiplo su testa 1
+   elseif EMC.HEAD == 'H14' 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
+      -- se inizio lavorazione con prelievo utensile
+      if EMC.LINKTYPE == 1 then
+         -- approccio
+         EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+         -- se doppia orizzontale mi serve movimento extra in Y per svincolo testa 2
+         -- Il movimento è calcolato sulla testa 1 e se entra da sopra, non c'è svincolo in Y e la testa 2 scende diretta entrando nel pezzo
+         local dDeltaYApproach = nil
+         if IsMachDoubleHoriz( false) then
+            dDeltaYApproach = GetHeadDeltaYApproachOnDouble( false)
+         end
+         -- se serve un approccio diverso
+         if dDeltaYApproach then
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2 + dDeltaYApproach, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;')
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2 + dDeltaYApproach, EMC.L3p, EMC.R1, EMC.R2}, 30, 2, 2)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2 + dDeltaYApproach, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+         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.R1, EMC.R2}, 30, 2, 2)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+         end
+
+      -- se fine lavorazione con deposito utensile
+      elseif EMC.LINKTYPE == 2 then
+         -- retrazione
+         EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+          -- se doppia orizzontale mi serve movimento extra in Y per svincolo testa 2
+         -- Il movimento è calcolato sulla testa 1 e se entra da sopra, non c'è svincolo in Y e la testa 2 scende diretta entrando nel pezzo
+         local dDeltaYApproach = nil
+         if IsMachDoubleHoriz( true, EMC.PREVMCHID) then
+            dDeltaYApproach = GetHeadDeltaYApproachOnDouble( true)
+         end
+         -- se serve un approccio diverso
+         if dDeltaYApproach then
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p + dDeltaYApproach, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 3, 2, 'FirstRise=1;')
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p + dDeltaYApproach, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2)
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p + dDeltaYApproach, 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, 'FirstRise=1;')
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2)
+         end
+         -- se 33 c'è stato un collegamento tra due lavorazioni doppie che passano da sopra il pezzo a sotto che avrebbe mandato teta 2 in collisione
+         if EMC.STARTZMAX ~= 33 then
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2, 'LastRise=1;')
+         end
+
+      -- altrimenti collegamento tra due lavorazioni (3)
+      else
+         -- se doppia orizzontale mi serve movimento extra in Y per svincolo testa 2
+         -- Il movimento è calcolato sulla testa 1 e se entra da sopra, non c'è svincolo in Y e la testa 2 scende diretta entrando nel pezzo
+         if EMC.OTHERLINKTYPE ~= 3 and ( IsMachDoubleHoriz( true, EMC.PREVMCHID) or IsMachDoubleHoriz( false)) then
+            local dDeltaYApproach = nil
+            dDeltaYApproach = GetHeadDeltaYApproachOnDouble( true)
+            -- se serve un approccio diverso
+            if dDeltaYApproach then
+               -- retrazione
+               EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+               -- recupero quota massima di collegamento
+               local vLInAx = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, false)
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p + dDeltaYApproach, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 3, 2, 'FirstRise=1;')
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p + dDeltaYApproach, vLInAx[3], EMC.R1p, EMC.R2p}, 30, 3, 2, 'LastRise=1;')
+            end
+
+            dDeltaYApproach = nil
+            dDeltaYApproach = GetHeadDeltaYApproachOnDouble( false)
+            -- se serve un approccio diverso
+            if dDeltaYApproach then
+               -- approccio
+               EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+               -- recupero quota massima di collegamento
+               local vLFiAx = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2 + dDeltaYApproach, vLFiAx[3], EMC.R1, EMC.R2}, 30, 2, 2, 'FirstClimb=1;')
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2 + dDeltaYApproach, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2)
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+            end
+         elseif EMC.OTHERLINKTYPE == 3 then
+            -- approccio
+            EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 1)
+         end
+      end
+
+   -- se lama su testa 2
+   elseif EMC.HEAD == 'H22' then
+      -- 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;')
+         EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, 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)
+         EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, 'FirstRise=1;')
+         EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, SafeX2, 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;')
+      end
+
+   -- se lama su testa 3
+   elseif EMC.HEAD == 'H38' then
+      local dExtraDist = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) / 2 + SAFE_DIST
+      -- recupero se split da note utente di lavorazione precedente
+      local bSplit = IsPrevSplit()
+      -- recupero ingombro del primo grezzo in lavoro
+      local b3Raw = GetActiveRawBBox()
+      local dMinRawX3 = b3Raw:getMin():getY() - Head3Y
+      local dMaxRawX3 = b3Raw:getMax():getY() - Head3Y
+      local dMidRawX3 = ( dMinRawX3 + dMaxRawX3) / 2
+
+      -- se inizio lavorazione con prelievo utensile
+      if EMC.LINKTYPE == 1 then
+         -- approccio
+         EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+         local dSafeX3 = EgtIf( EMC.L2 < dMidRawX3, dMinRawX3 - dExtraDist, dMaxRawX3 + dExtraDist)
+         if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, dSafeX3, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;')
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, dSafeX3, SafeZ3RotAxis, EMC.R1p, EMC.R2p}, 30, 2, 2)
+            -- deve muoversi anche la trave (la lama non è abbastanza alta in Z) quindi Mask = 31
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, dSafeX3, SafeZ3RotAxis, EMC.R1, EMC.R2}, 31, 2, 2, 'LastClimb=1;')
+         else
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, dSafeX3, 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)
+         local dSafeX3 = EgtIf( EMC.L2p < dMidRawX3, dMinRawX3 - dExtraDist, dMaxRawX3 + dExtraDist)
+         EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, dSafeX3, SafeZ3RotAxis, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..' FirstRise=1;')
+         if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, dSafeX3, SafeZ3RotAxis, EMC.R1, EMC.R2}, 30, 3, 2)
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, dSafeX3, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2)
+         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 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]) > SafeZ3RotAxis + 1 then
+            -- retrazione
+            EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, SafeZ3RotAxis, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..' FirstRise=1;')
+            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, SafeZ3RotAxis, EMC.R1p, 0}, 30, 3, 2, 'LastRise=1;')
+            -- approccio
+            EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, SafeZ3RotAxis, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;')
+            -- se non split deve muoversi anche la trave (la lama non è abbastanza alta in Z) quindi Mask = 31
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, SafeZ3RotAxis, EMC.R1, EMC.R2}, EgtIf( bSplit, 30, 31), 2, 2, 'LastClimb=1;')
+         end
+      end
+   -- testa con truciolatore su testa 3
+   elseif EMC.HEAD == 'H39' then
+      error( ' GESTIRE MOVIMENTO : ParkInLavZ2')
+      ;
+   end
+
+   EMC.ERR = 0
 end
 
 ---------------------------------------------------------------------
@@ -612,6 +908,21 @@ function OnSpecialApplyMachining()
    -- 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)
    -- se precedente operazione non esiste, errore
@@ -670,15 +981,24 @@ function OnSpecialApplyMachining()
       EMC.V1POS = EgtIf( bAtZMax, ParkV1, EgtGetInfo( nLastPathId, 'V1POS', 'd') or ParkV1)
       EMC.V2POS = EgtIf( bAtZMax, ParkV2, EgtGetInfo( nLastPathId, 'V2POS', 'd') or ParkV2)
       EMC.CNT = SpecGetCNT( EMC.MCHID)
+      if vAxes[6] then
+         -- imposto lavorazione e utensile correnti
+         EgtSetCurrMachining( nPrevOpeId)
+         dPrevValR3 = vAxes[6]
+         local sTool = EgtGetMachiningParam( MCH_MP.TOOL)
+         if not sTool then
+            local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID)
+            sTool = EgtTdbGetToolFromUUID( sTuuid) or ''
+         end
+         sPrevTool = sTool
+         EgtSetCurrMachining( EMC.MCHID)
+      end
    end
 
    -- Verifico se ultima lavorazione della fase
    local nNextOpeId = EgtGetNextActiveOperation( EMC.MCHID)
    local bMchLast = ( not nNextOpeId  or  EgtGetOperationPhase( nNextOpeId) ~= EMC.PHASE)
 
-   -- Verifico flag di separazione e fase di scarico
-   local sNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
-
    -- bPreSplit sempre a falso per obbligare a pinzare il pezzo con 1 morsa anche se iniziato il taglio che dividerà grezzo e finito (in genere per sezioni grandi con 2 tagli di lama)
    -- Tra un taglio e l'altro infatti c'e' inversione del braccio e quindi un'apertura delle rulliere. Se pinzano entrambe le pinze, potrebbero esserci problemi di collisone rulli-morse
    local bPreSplit = false --( sNotes:find( 'Presplit', 1, true) ~= nil)
@@ -753,8 +1073,53 @@ function OnSpecialApplyMachining()
       local nLastEntId = EgtGetLastInGroup( EMC.PATHID)
       local vAxes = EmtGetAxesPos( nLastEntId)
       if #vAxes > 0 then EMC.TPOS = vAxes[1] end
+      -- controllo se serve cambiare la presa
+      if vAxes[6] and dPrevValR3 then
+         local sTool = EgtGetMachiningParam( MCH_MP.TOOL)
+         if not sTool then
+            local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID)
+            sTool = EgtTdbGetToolFromUUID( sTuuid) or ''
+         end
+         -- se stesso utensile ma cambia la presa dell'aggregato
+         if sTool == sPrevTool and  abs( dPrevValR3 - vAxes[6]) > 10 * GEO.EPS_SMALL then
+            EMC.CHANGETAKE = true
+         end
+      end
    end
 
+   -- Se richiesto movimento preliminare della testa a Zmax perchè c'è stato un riposizionamento delle pinze
+   if EMC.ZMAX or bZMaxForced then
+      sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 11)
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+   end
+
+   if EMC.CHANGETAKE then
+      sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 12)
+      EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+   end
+
+   -- se due lavorazioni in doppio e si cambia lato, si forza a Z massima per essere sicuri di fare approccio corretto
+   if IsMachDoubleHoriz( false) then
+      local bPrevMachId = EgtGetPrevActiveOperation( EMC.MCHID)
+      if bPrevMachId and IsMachDoubleHoriz( true, bPrevMachId) and EgtGetOperationType( nPrevOpeId) ~= MCH_OY.DISP then
+         -- recupero ptMin ptMax della lavorazione corrente
+         local nClId2Curr = EgtGetFirstNameInGroup( EMC.MCHID, 'CL')
+         local ptMinCurr = EgtGetInfo( nClId2Curr, 'MMIN', 'p')
+         local ptMaxCurr = EgtGetInfo( nClId2Curr, 'MMAX', 'p')
+         -- recupero ptMin ptMax della lavorazione precedente
+         local nClIdPrev = EgtGetFirstNameInGroup( bPrevMachId, 'CL') or GDB_ID.NULL
+         local ptMinPrev = EgtGetInfo( nClIdPrev, 'MMIN', 'p')
+         local ptMaxPrev = EgtGetInfo( nClIdPrev, 'MMAX', 'p')
+
+         -- controlo se si passa da una lavorazione sopra ad una sotto
+         if ( ptMaxPrev:getZ() > EMC.RAWBOX:getMax():getZ() and ptMinCurr:getZ() < EMC.RAWBOX:getMin():getZ()) or
+            ( ptMinPrev:getZ() < EMC.RAWBOX:getMin():getZ() and ptMaxCurr:getZ() > EMC.RAWBOX:getMax():getZ()) then
+
+            sNotes = EgtSetValInNotes( sNotes, 'StartZmax', 33)
+            EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
+         end
+      end
+   end
 end
 
 ---------------------------------------------------------------------
@@ -810,6 +1175,7 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload)
    EMC.SB = b3Tot:getDimY()
    EMC.HB = b3Tot:getDimZ()
    EMC.LT = b3Raw:getDimX()
+   EMC.RAWBOX = b3Raw
    EgtOutLog( '  BarLen='..EgtNumToString( EMC.LB, 1), 3)
 
    -- Aggiorno limiti di presa
@@ -1203,9 +1569,7 @@ function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1Del
       WorkTab.dY1DeltaMaxF = min( EMC.LB - MinJoin, MaxY1 + dDistFront + dRollFront + AGG_V)
       WorkTab.dY2DeltaMinF = nil
       WorkTab.dY2DeltaMaxF = nil
-      if dY1DeltaMaxSP and dY1DeltaMaxSP > WorkTab.dY1DeltaMinF then
+      if dY1DeltaMaxSP then WorkTab.dY1DeltaMaxF = min( WorkTab.dY1DeltaMaxF, dY1DeltaMaxSP) end
-         WorkTab.dY1DeltaMaxF = min( WorkTab.dY1DeltaMaxF, dY1DeltaMaxSP)
-      end
       WorkTab.dV1PosF = dRollBack
       WorkTab.bV1CloseF = false
       WorkTab.dV2PosF = -dRollFront
@@ -1430,12 +1794,6 @@ function SpecCalcUnloadOnLoadPos()
          table.insert( vCmd, { 11, 1})
       end
    end
-   -- se l'ultima posizione di Y1 (calcolata in modo che PosT sia nella posizione di scarico) è fuori dalla corsa massima ricalcola le due quote alla quota massima raggiungibile
-   if dY1Move > MaxY1 then
-      dRotT = dRotT - ( dY1Move - MaxY1)
-      dY1Move = MaxY1
-      EgtOutLog( '  Warning : Impossible to Reach Unloading on Load Position')
-   end
    table.insert( vCmd, { 2, 'Y1', dY1Move, 'T', dRotT, 'BrakeBeam'})
    -- apro la morsa
    table.insert( vCmd, { 11, 0})
@@ -2697,6 +3055,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)
@@ -2759,8 +3125,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,11 @@
            ==== Common_PF1250 Update Log ====
 
+Versione 3.1-- (--/--/2026)
+- (ALL) Prima versione NEW LINK. Serve attivazione in MLDE
+- (SIM-INI) Con CAM5 v.3.1h2 è possibile abilitare/disabilitare VMILL durante lavorazione. Serve Modifica INI macchina "Enable=2" in sezione "[VMill]".
+            Il flag non è più di creazione, ma di visualizzazione, e il controllo collisioni è comunque garantito.
+- (SIM) Corretta gestione collisione con utensile flottante
+
 Versione 3.1h1 (07/08/2026)
 - (SIM-GEN) Se pezzo a caduta con rulliera V2 attiva (pinza 3), prima muove la rulliera e poi la apre. Ticket#3116
 

Version.lua

@@ -3,7 +3,7 @@
 
 local InfoCommon_STD_PP = {
    NAME = 'Common_PF1250',            -- nome script PP standard
-   VERSION = '3.1h1',                 -- versione script
+   VERSION = '3.1--',                 -- versione script
    MIN_MACH_VER_PP_COMMON = '3.1b2'   -- versione minima kernel
 }