Merge branch 'develop'

sistemato errore in MLDE

Common_ONE-PF.NUM.mlpe

@@ -315,7 +315,7 @@ function OnDispositionEnd()
       if #EMT.MDCHAR > 0 then
          MyOutputNoNum( '(PART UNLOAD)')
          -- movimento intermedio di apertura pinza-rulli per evitare di trovare delle collisioni
-         EmitParkRoller( EMT.TPOS, false, false)
+         EmitParkRoller( EMT.TPOS, false)
          for i = 1, #EMT.MDCHAR do
             EmitMoveDataChars( EMT.MDCHAR[i])
             if EMT.MDCHAR[i].V1 then EMT.V1POS = EMT.MDCHAR[i].V1 end
@@ -326,7 +326,6 @@ function OnDispositionEnd()
          if IsRestPhase( EMT.PHASE + 1) then
             EmitMoveWaitChars( 2)
          else
-            -- EmitMoveWaitChars( 2, TEST_USE)
             -- posticipo attesa fine scarico alla lavorazione successiva
             EMT.LASTOPEISUNLOAD = true
          end
@@ -423,6 +422,14 @@ function OnToolSelect()
       if MCH_TP.DIST then EMT.TDIST = EgtTdbGetCurrToolParam( MCH_TP.DIST) end
       if EMT.TDIST and abs( EMT.TDIST) < 0.1 then EMT.TDIST = nil end
       EMT.TUSERNOTES = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES)
+
+      -- gruppo della testa
+      local nHSet = GetHeadSet( EMT.HEAD)
+      if nHSet == 1 and EMT.PRESEL_H1 then
+         EMT.PRESEL_H1 = nil
+      elseif nHSet == 2 and EMT.PRESEL_H2 then
+         EMT.PRESEL_H2 = nil
+      end
    end
 end
 
@@ -485,6 +492,7 @@ end
 ---------------------------------------------------------------------
 function OnMachiningEnd()
    --EmtOutput( ';Mach End')
+   local bMoveBothClampsOnSplit = false
    if #EMT.MDCHAR > 0 then
       -- Emissione split
       if EMT.AUXTYPE == 'S' then
@@ -515,13 +523,14 @@ function OnMachiningEnd()
                EMT.MDCHAR[1].MovType = nil
                EMT.MDCHAR[1].Y2 = ParkV2 - EMT.LT + EMT.Y2DELTA
                EMT.MDCHAR[1].V2 = ParkV2
+               bMoveBothClampsOnSplit = true
             end
          end
 
       elseif EMT.AUXTYPE == 'U' then
          EmtOutput( '(PART UNLOAD)')
          -- movimento intermedio di apertura pinza-rulli per evitare di trovare delle collisioni
-         EmitParkRoller( EMT.TPOS, false, false)
+         EmitParkRoller( EMT.TPOS, false)
          EMT.V1POS = EMT.V1NEXTPOS
          EMT.V2POS = EMT.V2NEXTPOS
       elseif EMT.AUXTYPE == 'P' then
@@ -558,8 +567,13 @@ function OnMachiningEnd()
    end
    if #EMT.MDCHAR > 0 then
       if EMT.AUXTYPE == 'S' then
-         EmitMoveStartChars( 1)
-         EmitMoveWaitChars( 1)
+         if bMoveBothClampsOnSplit then
+            EmitMoveStartChars( 3)
+            EmitMoveWaitChars( 3)
+         else
+            EmitMoveStartChars( 1)
+            EmitMoveWaitChars( 1)
+         end
       elseif EMT.AUXTYPE == 'U' then
          local nMoveType = EgtIf( EMT.CHY_ON, 3, 2)
          EmitMoveStartChars( nMoveType)
@@ -568,6 +582,7 @@ function OnMachiningEnd()
             EmitMoveWaitChars( nMoveType)
          else
             EmitMoveWaitChars( nMoveType, EMT.CHY_ON or TEST_USE)
+            EMT.LASTOPEISUNLOAD = true
          end
          -- emissione conclusione pezzo precedente (se non in modalità test)
          if not TEST_USE and EMT.PRODID then
@@ -584,8 +599,8 @@ function OnMachiningEnd()
                local sOut = 'G156 EA'..tostring( EMT.PRODID)..' EB'..tostring( EMT.PATTID)..' EC'..tostring( EMT.CUTID)..' ED2'
                EmtOutput( sOut)
             end
-         elseif not EMT.PREROT then
-            EmtOutput( '(M77)')
+         elseif not EMT.PREROT and not EMT.SPECSPLIT then
+            EmtOutput( 'M77')
          end
       end
    end
@@ -637,7 +652,11 @@ function OnPathStart()
    EMT.MCHFIRST = true
    EMT.MCHFIRSTFEED = true
    -- se piano locale compatibile
-   local vtExtr = Vector3d( EMT.EXTR)
+   if not HeadIsChainSaw( EMT.HEAD) then
+      vtExtr = Vector3d( EMT.EXTR)
+   else
+      vtExtr = EgtGetCalcAuxDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
+   end
    if EMT.REFLOC and AreSameVectorApprox( vtExtr, EMT.IPLGLFR:getVersZ()) then
       ;
    -- altrimenti primo posizionamento sempre in globale
@@ -685,9 +704,7 @@ end
 
 ---------------------------------------------------------------------
 function OnPathEnd()
-   if not EMT.ZMAX then
-      -- EmitResetMachining( true)
-   end
+
 
    -- salvo dati precedenti
    EMT.L2pp = EMT.L2o
@@ -809,6 +826,10 @@ function OnRapid()
    local bSplitMach = ( EMT.MCHUSERNOTES:find( 'Split', 1, true) ~= nil)
    local sPostMove = ''
 
+   local sHeadToMoveFirst = EgtGetInfo( EMT.MOVEID, 'HeadToMoveFirst', 's') or false
+   local bFirstMoveOnlyH1 = sHeadToMoveFirst and sHeadToMoveFirst == 'H1'
+   local bFirstMoveOnlyH2 = sHeadToMoveFirst and sHeadToMoveFirst == 'H2'
+
    -- tutte le teste devono passare dalla gestione nuovi link, altrimenti errore
    if not IsNewLinkHead( EMT.HEAD) then
       EmtSetLastError( 1211, "UNEXPECTED ERROR on links")
@@ -841,6 +862,33 @@ function OnRapid()
             if EMT.MDCHAR[i].MovType ~= 1 then bOnlyCharY = false end
          end
          EMT.MDCHAR = {}
+
+         local bParkV = false
+
+         -- verifica se serve aprire i carrelli
+         local bCondBase = EMT.MCHFIRST or EMT.MOVE == 0
+         local bCondPosition = EMT.V1POS < EMT.V1NEXTPOS - 1 or
+                              EMT.V2POS > EMT.V2NEXTPOS + 1 or
+                              RollerParkingNeeded( EMT.HEAD, EMT.R1, EMT.R2, EMT.R1, EMT.R2)
+
+         if bCondBase and bCondPosition then
+            bParkV = true
+         end
+
+         local bNlhParkV = ( EMT.MOVE == 0 and ( EMT.FLAG2 == 1 or EMT.FLAG2 == 2))
+         if bNlhParkV then
+            bParkV = ( EMT.FLAG == 2 and bParkV) or ( not EMT.MCHSPLIT or bSplit)
+         end
+
+         if bParkV or bNlhParkV then
+            local bMchSplit = ( bNlhParkV and EMT.MCHSPLIT and bSplit)
+            local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT')
+            if EMT.SPLIT_Y1DELTA and not EMT.MCHSPLIT then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end
+            local dPosT = EMT.TPOS or EMT.L1op
+            EmitParkRoller( dPosT, bMchSplit, bAgg)
+         end
+         if EMT.SPLIT_Y1DELTA then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end
+
          EmitMoveStartChars( EgtIf( bOnlyCharY, 1, 3))
          EmtOutput( '( *** '..EMT.MCHNAME..'/'..EMT.TOOL..' *** )')
 
@@ -852,8 +900,11 @@ function OnRapid()
 
          EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
       else
-         -- se stesso utensile, e c'è ancora piano attivo dalla lavorazione precedente, allora questo è un climb
-         if EMT.TOOL == EMT.PREVTOOL and EMT.PLANEACTIVE and ( abs( EMT.R1prec - EMT.R1) < 0.1 and abs( EMT.R2prec - EMT.R2) < 0.1) then
+         -- controllo se ci sono spostamenti dei carrelli programmati
+         local bChangeCarriageClamping = GetMovesInAuxCmd( EMT.AUXCMD)
+         local bRotAxChanged = ( abs( EMT.R1prec - EMT.R1) > GEO.EPS_SMALL or abs( EMT.R2prec - EMT.R2) > GEO.EPS_SMALL)
+         -- se non ci sono riposizionamenti dei carrelli, se stesso utensile, e c'è ancora piano attivo dalla lavorazione precedente, allora questo è un climb
+         if EMT.PLANEACTIVE and EMT.TOOL == EMT.PREVTOOL and not bChangeCarriageClamping and not bRotAxChanged then
             -- dichiaro finita lavorazione precedente
             local sOut = 'G157 EA1'
             EmtOutput( sOut)
@@ -885,24 +936,29 @@ function OnRapid()
             -- dichiaro che è un movimento standard
             bStdMachRapid = true
          else
-            
-            MyAdjustLinearAxes()
-            EmtAdjustRotaryAxes()
-            EmtResetPrev()
-
             if bStdMachRapid then
                bStdMachRapid = false
                bStdClimb = true
             end
 
             -- si disattiva piano a meno che non sia lavorazione con stesso utensile e stesso orientamento assi
-            if EMT.PLANEACTIVE  then
+            if EMT.PLANEACTIVE then
                EmitResetMachining( false)
             end
+
+            MyAdjustLinearAxes()
+            EmtAdjustRotaryAxes()
+            EmtResetPrev()
+
             EmtOutput( '( *** '..EMT.MCHNAME..'/'..EMT.TOOL..' *** )')
             -- eventuale movimento carrelli
             for i = 1, #EMT.AUXCMD do
                ProcessPathStartAux( EMT.AUXCMD[i], i)
+               -- se ultimo comando e lavorazione di split, sgancio il carro Y1
+               if i == #EMT.AUXCMD and EMT.MCHSPLIT and not EMT.TO_SPECSPLIT and not EMT.TO_FALL then
+                  EMT.SPLIT_Y1DELTA = EMT.Y1DELTA
+                  EMT.Y1DELTA = nil
+               end
             end
             EMT.AUXCMD = {}
             -- se Split lascio agganciata solo la pinza Y2 alla fine dei movimenti
@@ -938,14 +994,17 @@ function OnRapid()
 
             local bNlhParkV = ( EMT.MOVE == 0 and ( EMT.FLAG2 == 1 or EMT.FLAG2 == 2))
             if bNlhParkV then
-               bParkV = ( EMT.FLAG == 2 and bParkV) or not bSplitMach
+               bParkV = ( EMT.FLAG == 2 and bParkV) or ( not EMT.MCHSPLIT or bSplit)
             end
 
-            if bParkV then
-               local bMchSplit = bNlhParkV and bSplitMach
+            if bParkV or bNlhParkV then
+               local bMchSplit = ( bNlhParkV and EMT.MCHSPLIT and bSplit)
+               local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT')
+               if EMT.SPLIT_Y1DELTA and not EMT.MCHSPLIT then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end
                local dPosT = EMT.TPOS or EMT.L1op
-               EmitParkRoller( dPosT, bMchSplit)
+               EmitParkRoller( dPosT, bMchSplit, bAgg)
             end
+            if EMT.SPLIT_Y1DELTA then EMT.Y1DELTA = EMT.SPLIT_Y1DELTA end
 
             -- se era stato lanciata la preselezione di un utensile, prima di muovere la testa asopetto che sia finito
             if EMT.START_PRESEL then
@@ -953,18 +1012,41 @@ function OnRapid()
                EMT.START_PRESEL = nil
             end
 
+
+            -- se la testa 1 deve andare per prima in posizione, start e attesa movimento
+            if bFirstMoveOnlyH2 then
+               if EMT.APPROACH.DBLCLIMBS and #EMT.APPROACH.DBLCLIMBS > 0 then
+                  EmitMoveDataHead( 2, { X=-EMT.APPROACH.DBLCLIMBS[1].L2, Z=EMT.APPROACH.DBLCLIMBS[1].L3, C=EMT.APPROACH.DBLCLIMBS[1].R1, B=EMT.APPROACH.DBLCLIMBS[1].R2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
+                  EmitMoveStartHead( 2)
+                  EmitMoveWaitHead( 2)
+                  -- si rimuove il primo movimento
+                  table.remove( EMT.APPROACH.DBLCLIMBS, 1)
+               end
+            end
+
             local dTRad, dTLen = GetToolRadLen()
             EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, TRad=dTRad, TLen=dTLen, S=CalcRealSpeed( EMT.S)})
+            -- se la testa 1 deve andare per prima in posizione, start e attesa movimento
+            if bFirstMoveOnlyH1 then
+               EmitMoveStartHead( 1)
+               EmitMoveWaitHead( 1)
+            end
          end
       end
 
       EMT.MCHFIRST = false
    -- movimento standard CLIMB
    elseif EMT.FLAG == 2 then
-      MyAdjustLinearAxes()
-      EmtAdjustRotaryAxes()
-      local dTRad, dTLen = GetToolRadLen()
-      EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, C=EMT.R1, B=EMT.R2, TRad=dTRad, TLen=dTLen, S=CalcRealSpeed( EMT.S)})
+      -- se non ho ancora impostato il piano, movimenti in assoluto
+      if not EMT.PLANEACTIVE then
+         MyAdjustLinearAxes()
+         EmtAdjustRotaryAxes()
+         local dTRad, dTLen = GetToolRadLen()
+         EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, C=EMT.R1, B=EMT.R2, TRad=dTRad, TLen=dTLen, S=CalcRealSpeed( EMT.S)})
+      -- altrimenti è un rapido standard
+      else
+         bStdMachRapid = true
+      end
    -- movimento standard RISE
    elseif EMT.FLAG == 3 then
       EMT.REFLOC = nil
@@ -977,18 +1059,20 @@ function OnRapid()
       end
       MyAdjustLinearAxes()
       EmtAdjustRotaryAxes()
-      -- se ultimo rapido e motosega, si va in home
+      
       EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, C=EMT.R1, B=EMT.R2})
       -- su ultimo rapido in uscita, comandi di attesa movimenti
-      if bLastRise or bStdRise then
+      if bLastRise or bUniqueRise or bStdRise then
          EmitMoveStartHead( nHSet)
          -- se lavorazione in doppio
          if nHSet == 1 and EMT.DOU_TYPE == 2 then
-            for i = 1, #EMT.APPROACH.DBLRISES do
-               EmitMoveDataHead( 2, { X=EMT.APPROACH.DBLRISES[i].L2, Z=EMT.APPROACH.DBLRISES[i].L3, C=EMT.APPROACH.DBLRISES[i].R1, B=EMT.APPROACH.DBLRISES[i].R2})
+            if EMT.APPROACH.DBLRISES and #EMT.APPROACH.DBLRISES > 0 then
+               for i = 1, #EMT.APPROACH.DBLRISES do
+                  EmitMoveDataHead( 2, { X=-EMT.APPROACH.DBLRISES[i].L2, Z=EMT.APPROACH.DBLRISES[i].L3, C=EMT.APPROACH.DBLRISES[i].R1, B=EMT.APPROACH.DBLRISES[i].R2, TPos=EMT.DOU_TPOS})
+               end
+               EmitMoveStartHead( 2)
+               EmitMoveWaitHead( 2)
             end
-            EmitMoveStartHead( 2)
-            EmitMoveWaitHead( 2)
          end
          EmitMoveWaitHead( nHSet)
          EMT.ZMAX = true
@@ -1010,11 +1094,13 @@ function OnRapid()
       EmitMoveStartHead( nHSet)
       -- se lavorazione in doppio
       if nHSet == 1 and EMT.DOU_TYPE == 2 then
-         for i = 1, #EMT.APPROACH.DBLCLIMBS do
-            EmitMoveDataHead( 2, { X=EMT.APPROACH.DBLCLIMBS[i].L2, Z=EMT.APPROACH.DBLCLIMBS[i].L3, C=EMT.APPROACH.DBLCLIMBS[i].R1, B=EMT.APPROACH.DBLCLIMBS[i].R2})
+         if EMT.APPROACH.DBLCLIMBS and #EMT.APPROACH.DBLCLIMBS > 0 then
+            for i = 1, #EMT.APPROACH.DBLCLIMBS do
+               EmitMoveDataHead( 2, { X=-EMT.APPROACH.DBLCLIMBS[i].L2, Z=EMT.APPROACH.DBLCLIMBS[i].L3, C=EMT.APPROACH.DBLCLIMBS[i].R1, B=EMT.APPROACH.DBLCLIMBS[i].R2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
+            end
+            EmitMoveStartHead( 2)
+            EmitMoveWaitHead( 2)    
          end
-         EmitMoveStartHead( 2)
-         EmitMoveWaitHead( 2)         
       -- altrimenti preselezione su altra testa
       else
          PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
@@ -1129,6 +1215,7 @@ function OnRapid()
          EMT.POSTROT = false
          EMT.RELOAD = false
          EMT.RELOAD2 = nil
+         EMT.SPLIT_Y1DELTA = nil
       end
 
       -- se taglio di coda senza residuo da scaricare, emetto M175 per accelerare il carico della barra successiva
@@ -1145,14 +1232,15 @@ function OnRapid()
       -- trasformo i punti nel piano
       MyAdjustLinearAxes()
       EmtAdjustRotaryAxes()
+      -- annullo precedenti per forzare scrittura
+      EMT.L1p = nil
+      EMT.L2p = nil
+      EMT.L3p = nil
       local sDouFlag = EgtIf( EMT.DOU_TYPE, ' EE1', '')
       EmtOutput( 'G142'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..EMT.IPLGLSTR..EgtIf( nHSet~=2, ' EU1', ' EU2')..sDouFlag..' EF'..GetFmaxClamp())
 
       EMT.PLANEACTIVE = true
 
-      -- EMT.L1p = nil
-      -- EMT.L2p = nil
-      -- EMT.L3p = nil
       -- annullo precedenti per forzare scrittura
       EMT.R1p = nil
       EMT.R2p = nil
@@ -1245,14 +1333,16 @@ function OnLinear()
    MyAdjustLinearAxes()
    EmtAdjustRotaryAxes()
 
-      -- se lavorazione in doppio e fondo foro, inverto movimento punta doppia
-   if EMT.MCHTYPE == MCH_MY.DRILLING and not EMT.DBLHEADPARA and EMT.DOU_TYPE == 2 and EMT.FLAG == 105 then
+   -- se lavorazione in doppio, da questo movimento bisogna passare ad accoppiamento in parallelo
+   if not EMT.DBLHEADPARA and EMT.DOU_TYPE == 2 and
+      ( ( EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 105) or ( EMT.MCHTYPE == MCH_MY.POCKETING and EMT.FLAG == 405))then
       EmtOutput( "G157 EE-1")
       EMT.DBLHEADPARA = true
    end
 
-   -- se lavorazione in doppio e fondo foro, muovo punta 2 e poi ripristino movimento standard punta doppia
-   if EMT.DBLHEADPARA and EMT.FLAG == 104 then
+   -- se testa accoppiata in parallelo, in uscita si disaccoppia per tornare ad accoppiamento speculare
+   if EMT.DBLHEADPARA and
+      ( ( EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 104) or ( EMT.MCHTYPE == MCH_MY.POCKETING and EMT.FLAG == 404)) then
       EmtOutput( "G157 EE1")
       EMT.DBLHEADPARA = nil
    end
@@ -1328,6 +1418,13 @@ function OnArc()
    MyAdjustLinearAxes()
    EmtAdjustRotaryAxes()
 
+   -- se lavorazione in doppio, da questo movimento bisogna passare ad accoppiamento in parallelo
+   if not EMT.DBLHEADPARA and EMT.DOU_TYPE == 2 and
+      ( ( EMT.MCHTYPE == MCH_MY.DRILLING and EMT.FLAG == 105) or ( EMT.MCHTYPE == MCH_MY.POCKETING and EMT.FLAG == 405))then
+      EmtOutput( "G157 EE-1")
+      EMT.DBLHEADPARA = true
+   end
+
    -- valori degli assi
    local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
                  EmtGetAxis('R1')..EmtGetAxis('R2')
@@ -2031,11 +2128,11 @@ function MyAdjustLinearAxes()
          local Len = EMT.TLEN + dAddLen + Mill2Offs
          local LenRef = Mill2Offs
          vtE = Vector3d( EMT.TDIR) * Len - Z_AX() * LenRef
-      elseif EMT.HEAD == 'H13' then
+      elseif EMT.HEAD == 'H13' or EMT.HEAD == 'H15' then
          local Len = ( EMT.TDIST or ChSawLen) + MillOffs
          local LenRef = MillOffs
          vtE = Vector3d( EMT.ADIR) * Len - Z_AX() * LenRef
-      elseif EMT.HEAD == 'H15' or EMT.HEAD == 'H23' then
+      elseif EMT.HEAD == 'H23' then
          local Len = ( EMT.TDIST or ChSawLen) + Mill2Offs
          local LenRef = Mill2Offs
          vtE = Vector3d( EMT.ADIR) * Len - Z_AX() * LenRef
@@ -2291,18 +2388,20 @@ function EmitResetMachining( bNextTool)
       EmtOutput( 'G157 EA1')
       -- piano non più attivo
       EMT.PLANEACTIVE = false
+      EMT.REFLOC = nil
+      EMT.IPLGL = false
    end
 end
 
 ---------------------------------------------------------------------
-function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
+function EmitParkRoller( dPosT, bSplitCut, bAgg)
    -- se entrambe già parcheggiate, non devo fare alcunché
    if ( EMT.V1POS - ParkV1) > -0.1 and ( EMT.V2POS - ParkV2) < 0.1 then return end
    -- Assegno quote pinze correnti
-   local dY1Delta = EgtIf( bUsePrevDelta, EMT.Y1PREVDELTA, EMT.Y1DELTA)
-   local dY2Delta = EgtIf( bUsePrevDelta, EMT.Y2PREVDELTA, EMT.Y2DELTA)
+   local dY1Delta = EMT.Y1DELTA
+   local dY2Delta = EMT.Y2DELTA
    -- Parcheggi pinze
-   local MyParkY1 = ParkY1 + AggLoad
+   local MyParkY1 = ParkY1 + EgtIf( bAgg, AggLoad, 0)
    local MyParkY2 = ParkY2
    -- le parcheggio
    local MDChar = {}
@@ -2313,27 +2412,14 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
       local DiffY2 = MyParkY2 - dPosY2
       --EmtOutput( string.format( 'PosT=%.3f DiffY1=%.3f DiffY2=%.3f', dPosT, DiffY1, DiffY2))
       if bSplitCut then
-         local bYNoMove, bVNoMove
-         if DiffY1 > 0.1  then
-            bYNoMove = false
-            MDChar.Y1 = dPosY1 + DiffY1
-         else
-            bYNoMove = true
-            MDChar.Y1 = dPosY1
-         end
-         if DiffY2 < -0.1 then
-            bVNoMove = false
-            MDChar.Y2 = dPosY2 + DiffY2
-            dPosT = dPosT + DiffY2
-         else
-            bVNoMove = true
-            MDChar.Y2 = dPosY2
-         end
-         -- se anche solo una morsa è restata in posizione, le sposto comunque entrambe di 5mm per distanziare i pezzi separati
-         if bYNoMove or bVNoMove then
-            MDChar.Y1 = MDChar.Y1 + 30
-            MDChar.Y2 = MDChar.Y2 - 30
-         end
+         local dAddMoveY1 = ParkV1 + ( -dPosT - EMT.LT)
+         local dAddMoveY2 = ParkV2 + ( -dPosT - EMT.LT)
+         local MoveY1 = max( DiffY1, dAddMoveY1, 30.0)
+         local MoveY2 = min( DiffY2, dAddMoveY2, -30.0)
+         MDChar.Y1 = dPosY1 + MoveY1
+         MDChar.Y2 = dPosY2 + MoveY2
+         dPosT = dPosT + MoveY2
+    
       elseif DiffY1 > 0.1 and DiffY2 < -0.1 then
          EmtSetLastError( 1201, 'Error Collision in ParkRoller')
       elseif DiffY1 > 0.1  then
@@ -2388,6 +2474,9 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
       MDChar.IniStatV2 = 3
       MDChar.MovType = MDChar.MovType | 2
    end
+   if EMT.SPLIT_Y1DELTA and EMT.SPLIT_Y1DELTA + dPosT < MyParkY1 then
+      MDChar.Y1 = MyParkY1
+   end
    EmitMoveDataChars( MDChar)
    EmitMoveStartChars( MDChar.MovType)
    EmitMoveWaitChars( MDChar.MovType)
@@ -2399,11 +2488,14 @@ end
 ---------------------------------------------------------------------
 -- preselezione utensile su stessa testa (per C.U. mascherato in caso di cambio morse)
 function ToolPreSelectionSingleHead( nMchId)
-   -- se macchina con due teste, preselezione già fatta
-   if EgtGetHeadId( 'H21') then
+   -- se macchina con due teste, devo preselezionare stessa testa quando ho motosega, altrimenti già fatta
+   if EgtGetHeadId( 'H21') and not HeadIsChainSaw( EMT.HEAD) then
       return
    end
 
+   -- gruppo della testa
+   local nHSet = GetHeadSet( EMT.HEAD)
+
    -- nome utensile
    local sToolChange = nil
    local sToolChangePos = nil
@@ -2416,22 +2508,27 @@ function ToolPreSelectionSingleHead( nMchId)
          if EgtSetCurrMachining( nNextMchId) then
             local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
             if EgtTdbSetCurrTool( sNextTool) then
-               if EMT.TOOL ~= sNextTool then
-                  local nClId = EgtGetFirstNameInGroup( nNextMchId, 'CL') -- recupero Id del gruppo CL della lavorazione corrente
-                  local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1)
-                  local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari 
-                  if dAuxMoveCount > 3 then
-                     bCarrMove = true
-                  end
-                  local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-                  -- motosega non può essere preselezionata
-                  if not HeadIsChainSaw( sNextHead) then
-                     sToolChange = sNextTool
-                     sToolChangePos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
-                     sToolChangeHead = sNextHead
+               local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+               local nNextHSet = GetHeadSet( sNextHead)
+               -- se stessa testa
+               if nNextHSet == nHSet then
+                  if EMT.TOOL ~= sNextTool then
+                     local nClId = EgtGetFirstNameInGroup( nNextMchId, 'CL') -- recupero Id del gruppo CL della lavorazione corrente
+                     local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1)
+                     local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari 
+                     if dAuxMoveCount > 3 then
+                        bCarrMove = true
+                     end
+                     local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+                     -- motosega non può essere preselezionata
+                     if not HeadIsChainSaw( sNextHead) then
+                        sToolChange = sNextTool
+                        sToolChangePos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
+                        sToolChangeHead = sNextHead
+                     end
                   end
+                  break
                end
-               break
             end
          end
       end
@@ -2442,19 +2539,36 @@ function ToolPreSelectionSingleHead( nMchId)
    EgtSetCurrMachining( EMT.MCHID)
    EgtTdbSetCurrTool( EMT.TOOL)
 
-   if bCarrMove then
+   if bCarrMove or EgtGetHeadId( 'H21') then
       -- se è stato trovato utensile, emetto preselezione
       if sToolChangePos and sToolChange and sToolChangeHead then
-         local MyParkX1 = EgtIf( GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head1_TC2', ParkFrnX1, ParkX1)
+         local MyParkX, MyParkB, MyParkC
+         if GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head2_TC2' then
+            MyParkX = ParkX2
+            MyParkZ = MaxZ2
+            MyParkB = ParkB2
+            MyParkC = ParkC2
+         elseif GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head1_TC2' then
+            MyParkX = ParkFrnX1
+            MyParkZ = MaxZ1
+            MyParkB = ParkFrnB1
+            MyParkC = ParkFrnC1
+         else
+            MyParkX = ParkX1
+            MyParkZ = MaxZ1
+            MyParkB = ParkB1
+            MyParkC = ParkC1
+         end
+
          EmtOutput( '( *** TOOL PRE-SEL *** )')
-         EmitMoveDataHead( 1, { X=-MyParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sToolChangePos)})
+         EmitMoveDataHead( nHSet, { X=-MyParkX, Z=MyParkZ, B=MyParkB, C=MyParkC, TPos=AdjustTcPos( false, sToolChangePos)})
          -- comincio i movimenti di preselezione
-         EmitMoveStartHead( 1)
+         EmitMoveStartHead( nHSet)
          -- se preselezione e c'era montata motosega, si aspetta fine della preselezione prima di andare avanti
          if HeadIsChainSaw( EMT.HEAD) then
-            EmitMoveWaitHead( 1)
+            EmitMoveWaitHead( nHSet)
          else
-            EMT.START_PRESEL = 1
+            EMT.START_PRESEL = nHSet
          end
       -- se non ho trovato utensile da preselezionare, e c'è motosetga montata, si scarica
       elseif HeadIsChainSaw( EMT.HEAD) then
@@ -2462,8 +2576,8 @@ function ToolPreSelectionSingleHead( nMchId)
          EmitUnmountChainSaw()
       end
    else
-      -- se ultima lavorazione e ho motosega, scarico
-      if not nNextMchId and HeadIsChainSaw( EMT.HEAD) then
+      -- se ho motosega, scarico
+      if HeadIsChainSaw( EMT.HEAD) then
          EmtOutput( '( *** UNMOUNT CHAIN-SAW *** )')
          EmitUnmountChainSaw()
       end
@@ -2479,82 +2593,133 @@ function PreselectNextDiffHead( nMchId, sHead)
 
    -- gruppo della testa
    local nHSet = GetHeadSet( sHead)
+
+   local bVerifyPresel = true
+   if not EMT.LOAD then
+      -- se lavorazione con testa 1 e sotto al limite massimo di preselezione della testa 2, allora non si fa preselezione
+      if nHSet == 1 and Limit_T1_Presel_T2 and EMT.MAXMIN[2] < Limit_T1_Presel_T2 then
+         bVerifyPresel = false
+      -- se lavorazione con testa 1 e sopra al limite minimo di preselezione della testa 1, allora non si fa preselezione
+      elseif nHSet == 2 and Limit_T2_Presel_T1 and EMT.MAXMIN[2] > Limit_T2_Presel_T1 then
+         bVerifyPresel = false
+      end
+   end
+
    -- flag preselezione eseguita
    local bPresel = false
-   -- recupero lavorazione successiva
-   local nNextMchId = EgtGetNextActiveOperation( nMchId)
-   while nNextMchId do
-      if EgtGetOperationType( nNextMchId) ~= MCH_OY.DISP then
-         if EgtSetCurrMachining( nNextMchId) then
-            local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
-            if EgtTdbSetCurrTool( sNextTool) then
-               local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-               local nNextHSet = GetHeadSet( sNextHead)
-               if nNextHSet ~= nHSet then
-                  break
+   local bDoubleTool = false
+   local sDoubleTool = ''
+
+   if bVerifyPresel then
+      -- recupero lavorazione successiva
+      local nNextMchId = EgtGetNextActiveOperation( nMchId)
+      while nNextMchId do
+         if EgtGetOperationType( nNextMchId) ~= MCH_OY.DISP then
+            if EgtSetCurrMachining( nNextMchId) then
+               local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
+               if EgtTdbSetCurrTool( sNextTool) then
+                  local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+                  local nNextHSet = GetHeadSet( sNextHead)
+                  if nNextHSet ~= nHSet then
+                     break
+                  else
+                     local sMachUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) 
+                     local nDouType = EgtGetValInNotes( sMachUserNotes, 'DOUBLE', 'i')
+                     if nDouType == 2 then
+                        local sToolUserNotes = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES)
+                        local sOtherTool = EgtGetValInNotes( sMachUserNotes, 'TOOLDOUBLE', 's') or EgtGetValInNotes( sToolUserNotes, 'DOUBLE', 's') or ''
+                        local sOldTool = EgtTdbGetCurrToolParam( MCH_TP.NAME)
+                        if EgtTdbSetCurrTool( sOtherTool) and EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then
+                           sDoubleTool = sOtherTool
+                           bDoubleTool = true
+                        end
+                        EgtTdbSetCurrTool( sOldTool)
+                        break
+                     end
+                  end
+               end
+            end
+         end
+         nNextMchId = EgtGetNextActiveOperation( nNextMchId)
+      end
+      -- se esiste ed appartiene a gruppo diverso
+      if nNextMchId and EgtSetCurrMachining( nNextMchId) then
+         local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
+         -- se è una lavorazione in doppio, selezione altro utensile
+         if bDoubleTool then
+            sNextTool = sDoubleTool
+         end
+         if EgtTdbSetCurrTool( sNextTool) then
+            local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+            local nNextHSet = GetHeadSet( sNextHead)
+            if nNextHSet ~= nHSet then
+               local sNextTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
+               -- se testa attuale da caricare è sega a catena, mando l'altra prima in HomeX (per evitare possibili collisioni) e poi lancio preselezione
+               if sHead == 'H13' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H1) then
+                  EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)})
+                  EmitMoveStartHead( 2)
+                  EmitMoveWaitHead( 2)
+               elseif sHead == 'H23' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H2) then
+                  EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)})
+                  EmitMoveStartHead( 1)
+                  EmitMoveWaitHead( 1)
+               end
+               -- Emetto preselezione (non ammessa per sega a catena H13 e H23 e aggregato BlockHaus H17)
+               if sNextHead == 'H11' then
+                  EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sNextTcPos)})
+                  EmitMoveStartHead( 1)
+                  bPresel = true
+               elseif sNextHead == 'H12' then
+                  EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sNextTcPos)})
+                  EmitMoveStartHead( 1)
+                  bPresel = true
+               elseif sNextHead == 'H21' then
+                  EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, sNextTcPos)})
+                  EmitMoveStartHead( 2)
+                  bPresel = true
+               elseif sNextHead == 'H22' then
+                  EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, sNextTcPos)})
+                  EmitMoveStartHead( 2)
+                  bPresel = true
                end
             end
          end
       end
-      nNextMchId = EgtGetNextActiveOperation( nNextMchId)
+      -- ripristino stato corrente
+      EgtSetCurrMachining( EMT.MCHID)
+      EgtTdbSetCurrTool( EMT.TOOL)
    end
-   -- se esiste ed appartiene a gruppo diverso
-   if nNextMchId and EgtSetCurrMachining( nNextMchId) then
-      local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
-      if EgtTdbSetCurrTool( sNextTool) then
-         local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-         local nNextHSet = GetHeadSet( sNextHead)
-         if nNextHSet ~= nHSet then
-            local sNextTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
-            -- se testa attuale da caricare è sega a catena, mando l'altra prima in HomeX (per evitare possibili collisioni) e poi lancio preselezione
-            if sHead == 'H13' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H1) then
+   -- se non eseguita preselezione
+   if not bPresel then
+      -- se era stato preselezionato un utensile e adesso non posso preselezionare, attendo la testa
+      if EMT.PRESEL_H2 then
+         EmitMoveWaitHead( 2)
+         EMT.PRESEL_H2 = nil
+      elseif EMT.PRESEL_H1 then
+         EmitMoveWaitHead( 1)
+         EMT.PRESEL_H1 = nil
+      -- se non era stato preselezionato nulla
+      else
+         -- mi assicuro che l'altra testa sia in parcheggio
+         if nHSet == 1 then
+            -- non può essere la sega a catena
+            if EMT.PREVHEAD_H2 ~= 'H23' then
                EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)})
                EmitMoveStartHead( 2)
-               EmitMoveWaitHead( 2)
-            elseif sHead == 'H23' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H2) then
+            end
+         else
+            -- non può essere la sega a catena
+            if EMT.PREVHEAD_H1 ~= 'H13' and EMT.PREVHEAD_H1 ~= 'H15' then
                EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)})
                EmitMoveStartHead( 1)
-               EmitMoveWaitHead( 1)
-            end
-            -- Emetto preselezione (non ammessa per sega a catena H13 e H23 e aggregato BlockHaus H17)
-            if sNextHead == 'H11' then
-               EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sNextTcPos)})
-               EmitMoveStartHead( 1)
-               bPresel = true
-            elseif sNextHead == 'H12' then
-               EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, sNextTcPos)})
-               EmitMoveStartHead( 1)
-               bPresel = true
-            elseif sNextHead == 'H21' then
-               EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, sNextTcPos)})
-               EmitMoveStartHead( 2)
-               bPresel = true
-            elseif sNextHead == 'H22' then
-               EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, sNextTcPos)})
-               EmitMoveStartHead( 2)
-               bPresel = true
             end
          end
       end
-   end
-   -- ripristino stato corrente
-   EgtSetCurrMachining( EMT.MCHID)
-   EgtTdbSetCurrTool( EMT.TOOL)
-   -- se non eseguita preselezione
-   if not bPresel then
-      -- mi assicuro che l'altra testa sia in parcheggio
+   else
       if nHSet == 1 then
-         -- non può essere la sega a catena
-         if EMT.PREVHEAD_H2 ~= 'H23' then
-            EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)})
-            EmitMoveStartHead( 2)
-         end
-      else
-         -- non può essere la sega a catena
-         if EMT.PREVHEAD_H1 ~= 'H13' and EMT.PREVHEAD_H1 ~= 'H15' then
-            EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)})
-            EmitMoveStartHead( 1)
-         end
+         EMT.PRESEL_H2 = true
+      elseif nHSet == 1 then
+         EMT.PRESEL_H2 = true
       end
    end
 end

Common_ONE-PF.mlpe

@@ -96,6 +96,10 @@ function OnSimulStart()
    if DefTcPos2 then
       LoadFirstTool( 2, DefTcPos2)
    end
+
+   -- se presenti, nascondo i tastatori
+   DeactivateProbeTool()
+
    ExecStartHome()
    -- Se reset o home, esco
    if EMT.SIM1ST then return end
@@ -130,7 +134,8 @@ function OnSimulStart()
                      { Grp = 'Base', Sub = 'COLLISION', Name = 'TC1'},
                      { Grp = 'Base', Sub = 'COLLISION', Name = 'TC2'},
                      { Grp = 'Base', Sub = 'BELT', Name = 'COLLISION'},
-                     { Grp = 'X1', Sub = 'COLLISION', Name = 'STM'}}
+                     { Grp = 'X1', Sub = 'COLLISION', Name = 'STM'},
+                     { Grp = 'X1', Sub = 'COLLISION', Name = 'STM2'}}
    
    if EgtGetHeadId( 'H21') then
       table.insert( McdData, { Grp = 'X2', Sub = 'COLLISION', Name = 'STM'})
@@ -537,14 +542,6 @@ function OnSimulToolSelect( dPosA)
       end
    end
 
-   -- se ho due teste, verifico che l'altra sia dalla parte opposta
-   if EgtGetHeadId( 'H21') then
-      if nSetHead == 1 then
-         EgtSetAxisPos( 'X2', MinX2)
-      else
-         EgtSetAxisPos( 'X1', MaxX1)
-      end
-   end
    -- se sega a catena, imposto subito angolo scelto per asse virtuale A
    if HeadIsChainSaw( EMT.HEAD) then
       -- apro le paratie
@@ -561,7 +558,9 @@ function OnSimulToolSelect( dPosA)
          EgtSetAxisPos( 'B1', ParkCSawB1)
          EgtSetAxisPos( 'X1', ParkCSawX1)
          -- l'utensile viene caricato qui, quindi setto come già cambiato
+         EMT.PREVTOOL_H1 = EMT.TOOL
          EMT.PREVHEAD_H1 = EMT.HEAD
+         EMT.PREVTCPOS_H1 = EMT.TCPOS
       else
          -- imposto home dell'asse C2 (A=0 -> T111, A=-90 -> T112)
          local MyParkCSawC2 = GetChainSawCHomeFromVirtualAxis( dPosA)
@@ -570,7 +569,9 @@ function OnSimulToolSelect( dPosA)
          EgtSetAxisPos( 'B2', ParkCSawB2)
          EgtSetAxisPos( 'X2', ParkCSawX2)
          -- l'utensile viene caricato qui, quindi setto come già cambiato
+         EMT.PREVTOOL_H2 = EMT.TOOL
          EMT.PREVHEAD_H2 = EMT.HEAD
+         EMT.PREVTCPOS_H2 = EMT.TCPOS
       end
    end
 
@@ -620,13 +621,22 @@ function OnSimulToolDeselect( dPrevA)
       -- nascondo l'utensile sulla testa
       EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H1 or '') or GDB_ID.NULL, GDB_MD.HIDDEN)
       -- se non è chiamata per cambio angolo di presa della sega a catena
-      if not dPrevA then
+      local sTool, sHead, sTcPos = FindNextToolOnHeadSet( 1, false)
+      if not dPrevA or not sTool then
+         -- imposto correttamente i dati di testa
+         local OrigEMC = EMC
+         EMC = { HEAD = sHead, TOOL = sTool, TCPOS = sTcPos, TOTDIAM = 0}
+         OnSetHead()
+         EMC = OrigEMC
+         local dHomeX1 = EgtGetAxisHomePos( 'X1')
+         local dHomeC1 = EgtGetAxisHomePos( 'C1')
+         local dHomeB1 = EgtGetAxisHomePos( 'B1')
+
          -- cambio utensile
-         EgtSetAxisPos( 'C1', ParkC1)
-         EgtSetAxisPos( 'B1', ParkB1)
+         EgtSetAxisPos( 'C1', dHomeC1)
+         EgtSetAxisPos( 'B1', dHomeB1)
          EgtSetAxisPos( 'Z1', MaxZ1)
-         SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID)
-         local sTool, sHead, sTcPos = FindNextToolOnHeadSet( 1, false)
+         SimulMoveAxis( 'X1', dHomeX1, MCH_SIM_STEP.RAPID)
          if sTcPos then
             LoadNextTool( 1, DefTcPos1)
          end
@@ -638,13 +648,17 @@ function OnSimulToolDeselect( dPrevA)
       -- nascondo l'utensile sulla testa
       EgtSetMode( EgtGetHeadId( EMT.PREVHEAD_H2 or '') or GDB_ID.NULL, GDB_MD.HIDDEN)
       -- se non è chiamata per cambio angolo di presa della sega a catena
-      if not dPrevA then
+      local sTool, sHead, sTcPos = FindNextToolOnHeadSet( 2, false)
+      if not dPrevA or not sTool then
          -- cambio utensile
          EgtSetAxisPos( 'C2', ParkC2)
          EgtSetAxisPos( 'B2', ParkB2)
          EgtSetAxisPos( 'Z2', MaxZ2)
          SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID)
-         local sTool, sHead, sTcPos = FindNextToolOnHeadSet( 2, false)
+         local OrigEMC = EMC
+         EMC = { HEAD = sHead or 'H21', TOOL = sTool, TCPOS = sTcPos, TOTDIAM = 0}
+         OnSetHead()
+         EMC = OrigEMC
          if sTcPos then
             LoadNextTool( 2, DefTcPos2)
          end
@@ -653,12 +667,22 @@ function OnSimulToolDeselect( dPrevA)
    end
 
    -- se utensile non cambia e non è sega a catena, esco
-   if ( EMT.NEXTTOOL == EMT.PREVTOOL_H1 or EMT.NEXTTOOL == EMT.PREVTOOL_H2) and not HeadIsChainSaw( EMT.NEXTHEAD) then return end
+   if bSkipToolChange or ( ( EMT.NEXTTOOL == EMT.PREVTOOL_H1 or EMT.NEXTTOOL == EMT.PREVTOOL_H2) and not HeadIsChainSaw( EMT.NEXTHEAD)) then return end
    -- deposito utensile
    EgtOutText( 'Tool change in progress...')
    -- se prossimo utensile sega a catena, devo mettere in home testa 1 e depositare l'utensile sulla testa 2 o viceversa
 
    local dHeadSet = GetHeadSet( EMT.PREVHEAD)
+
+   -- vado a quota home testa attuale
+   if dHeadSet == 1 then
+      SimulMoveAxes( 'X1', EgtGetAxisHomePos( 'X1'), MCH_SIM_STEP.RAPID, 'Z1', EgtGetAxisHomePos( 'Z1'), MCH_SIM_STEP.RAPID,
+                     'B1', EgtGetAxisHomePos( 'B1'), MCH_SIM_STEP.COLLROT, 'C1', EgtGetAxisHomePos( 'C1'), MCH_SIM_STEP.COLLROT)
+   elseif dHeadSet == 2 then
+      SimulMoveAxes( 'X2', EgtGetAxisHomePos( 'X2'), MCH_SIM_STEP.RAPID, 'Z2', EgtGetAxisHomePos( 'Z2'), MCH_SIM_STEP.RAPID,
+                     'B2', EgtGetAxisHomePos( 'B2'), MCH_SIM_STEP.COLLROT, 'C2', EgtGetAxisHomePos( 'C2'), MCH_SIM_STEP.COLLROT)
+   end
+
    if dHeadSet == 1 then
       -- visualizzo utensile su TcPos
       ShowToolInTcPos( EMT.PREVTCPOS_H1, true)
@@ -843,11 +867,17 @@ end
 function OnSimulMoveStart()
 
    -- tipo di movimento
+   local bFirstClimb = EgtGetInfo( EMT.MOVEID, 'FirstClimb', 'b')
    local bLastClimb = EgtGetInfo( EMT.MOVEID, 'LastClimb', 'b')
+   local bFirstRise = EgtGetInfo( EMT.MOVEID, 'FirstRise', 'b')
+   local bLastRise = EgtGetInfo( EMT.MOVEID, 'LastRise', 'b')
    local bUniqueClimb = EgtGetInfo( EMT.MOVEID, 'UniqueClimb', 'b')
+   local bUniqueRise = EgtGetInfo( EMT.MOVEID, 'UniqueRise', 'b')
    -- se il link non arriva dalla OnSpecial, non ha nessuna nota
    local bStdClimb = ( EMT.FLAG2 ~= 2 and EMT.FLAG == 2)
+   local bStdRise = ( EMT.FLAG2 ~= 2 and EMT.FLAG == 3)
    local bStdMachRapid = ( EMT.FLAG2 == 0 and ( EMT.FLAG == 0 or EMT.FLAG == 1))
+   local sHeadToMoveFirst = EgtGetInfo( EMT.MOVEID, 'HeadToMoveFirst', 's')
 
    -- se primo rapido della lavorazione è un movimento standard, allora questo è l'ultimo climb
    if bStdMachRapid and EMT.MCHFIRST then
@@ -974,11 +1004,11 @@ function OnSimulMoveStart()
 
    -- se lavorazione in doppio
    if EMT.DOU_TYPE then
-      if EgtGetInfo( EMT.MOVEID, 'FirstClimb', 'b') or EgtGetInfo( EMT.MOVEID, 'UniqueClimb', 'b') then
+      if bFirstClimb or bUniqueClimb or bStdClimb then
          EMT.IS_CLIMB = true
          EMT.IS_RISE = false
          EMT.INDEX_APPROACH_MOVE = 0
-      elseif EgtGetInfo( EMT.MOVEID, 'FirstRise', 'b')  or EgtGetInfo( EMT.MOVEID, 'UniqueRise', 'b') then
+      elseif bFirstRise or bUniqueRise or bStdRise then
          EMT.IS_CLIMB = false
          EMT.IS_RISE = true
          EMT.INDEX_APPROACH_MOVE = 0
@@ -1002,7 +1032,7 @@ function OnSimulMoveStart()
          if EMT.DOU_TYPE == 2 then
             -- controllo minima distanza tra utensili di X1 e X2
             local dDeltaX1X2 = EMT.L2 - EMT.A5 - Head2Y
-            local dDistToolX1X2 = -dDeltaX1X2 - MillOffs - EMT.TTOTLEN - Mill2Offs - EMT.DOU_TTOTLEN
+            local dDistToolX1X2 = dDeltaX1X2 - MillOffs - EMT.TTOTLEN - Mill2Offs - EMT.DOU_TTOTLEN
             if dDistToolX1X2 < MinDistToolX1X2 and EMT.MCHNAME ~= EMT.DOUBLECOLLMACH then
                EMT.DOUBLECOLLMACH = EMT.MCHNAME
                local sErr = 'X1 X2 tools in collision (distance=' .. EgtNumToString( dDistToolX1X2, 1) .. ')'
@@ -1013,26 +1043,41 @@ function OnSimulMoveStart()
 
       -- movimento di approccio o retrazione
       else
-         -- incremento indice approccio
-         EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1
-         -- se non esiste movimento sulla testa due, significa che gli approcci della testa 1 sono in maggior numero
-         if ( EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE] and EMT.IS_CLIMB) or ( EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE] and EMT.IS_RISE) then
-            EMT.AuxAxes = 4 + 4
-            EMT.A5n = 'X2'
-            EMT.A6n = 'Z2'
-            EMT.A7n = 'C2'
-            EMT.A8n = 'B2'
-
-            if EMT.IS_CLIMB then
+         local bFirstMoveOnlyH1 = sHeadToMoveFirst and sHeadToMoveFirst == 'H1'
+         local bFirstMoveOnlyH2 = sHeadToMoveFirst and sHeadToMoveFirst == 'H2'
+         -- se bisogna muovere prima la testa 2, si esegue subito il primo movimento della testa, priam di muovere la testa 1
+         if bFirstMoveOnlyH2 then
+            if #EMT.APPROACH.DBLCLIMBS > 0 then
+               EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1
                EMT.A5 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L2
                EMT.A6 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L3
                EMT.A7 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R1
                EMT.A8 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R2
-            elseif EMT.IS_RISE then
-               EMT.A5 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L2
-               EMT.A6 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L3
-               EMT.A7 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R1
-               EMT.A8 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R2
+               SimulMoveAxes( 'X2', EMT.A5, MCH_SIM_STEP.RAPID, 'Z2', EMT.A6, MCH_SIM_STEP.RAPID, 'C2', EMT.A7, MCH_SIM_STEP.COLLROT, 'B2', EMT.A8, MCH_SIM_STEP.COLLROT)
+            end
+         -- se bisogna muovere prima la testa 1, il movimento della testa 2 non si esegue adesso
+         elseif not bFirstMoveOnlyH1 then
+            -- incremento indice approccio
+            EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1
+            -- se non esiste movimento sulla testa due, significa che gli approcci della testa 1 sono in maggior numero
+            if ( EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE] and EMT.IS_CLIMB) or ( EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE] and EMT.IS_RISE) then
+               EMT.AuxAxes = 4 + 4
+               EMT.A5n = 'X2'
+               EMT.A6n = 'Z2'
+               EMT.A7n = 'C2'
+               EMT.A8n = 'B2'
+
+               if EMT.IS_CLIMB then
+                  EMT.A5 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L2
+                  EMT.A6 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].L3
+                  EMT.A7 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R1
+                  EMT.A8 = EMT.APPROACH.DBLCLIMBS[EMT.INDEX_APPROACH_MOVE].R2
+               elseif EMT.IS_RISE then
+                  EMT.A5 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L2
+                  EMT.A6 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L3
+                  EMT.A7 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R1
+                  EMT.A8 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R2
+               end
             end
          end
       end
@@ -1064,11 +1109,9 @@ function OnSimulMoveStart()
       end
    end
 
-
-
    if EMT.DOU_TYPE then
       -- se testa 2 ha più movimenti della testa 1, eseguo tutti i movimenti della testa due che mancano
-      if EgtGetInfo( EMT.MOVEID, 'LastClimb', 'b') or EgtGetInfo( EMT.MOVEID, 'UniqueClimb', 'b') then
+      if bLastClimb or bUniqueClimb then
          if #EMT.APPROACH.DBLCLIMBS > #EMT.APPROACH.CLIMBS then
             while EMT.INDEX_APPROACH_MOVE < #EMT.APPROACH.DBLCLIMBS do
                EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1
@@ -1079,7 +1122,7 @@ function OnSimulMoveStart()
                SimulMoveAxes( 'X2', EMT.A5, MCH_SIM_STEP.RAPID, 'Z2', EMT.A6, MCH_SIM_STEP.RAPID, 'C2', EMT.A7, MCH_SIM_STEP.COLLROT, 'B2', EMT.A8, MCH_SIM_STEP.COLLROT)
             end
          end
-      elseif EgtGetInfo( EMT.MOVEID, 'LastRise', 'b')  or EgtGetInfo( EMT.MOVEID, 'UniqueRise', 'b') then
+      elseif bLastRise or bUniqueRise then
          if #EMT.APPROACH.DBLRISES > #EMT.APPROACH.RISES then
             while EMT.INDEX_APPROACH_MOVE < #EMT.APPROACH.DBLRISES do
                EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1
@@ -1110,6 +1153,12 @@ function OnSimulMoveStart()
       EMT.TFLOAT_CMP = EMT.MOVEID
    end
 
+   -- reset movimenti
+   if EMT.IS_CLIMB and EMT.APPROACH.DBLCLIMBS and #EMT.APPROACH.DBLCLIMBS == EMT.INDEX_APPROACH_MOVE then
+      EMT.APPROACH.DBLCLIMBS = {}
+   elseif EMT.IS_RISE and EMT.APPROACH.DBLRISES and #EMT.APPROACH.DBLRISES == EMT.INDEX_APPROACH_MOVE then
+      EMT.APPROACH.DBLRISES = {}
+   end
 end
 
 ---------------------------------------------------------------------
@@ -1661,19 +1710,10 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg)
       local DiffY2 = MyParkY2 - PosY2
       -- se appena eseguito taglio di separazione
       if bSpliCut then
-         local dAddMove
-         -- se entrambe le morse si spostano vado in posizione calcolata
-         if DiffY1 > 0.1 and DiffY2 < -0.1 then
-            dAddMove = 0
-         -- se almeno una è rimasta ferma in posizione, allontano comunque di 30mm ulteriori
-         else
-            dAddMove = 30
-         end
-         local MoveY1 = max( DiffY1, 0.0)
-         local MoveY2 = min( DiffY2, 0.0)
-
-         MoveY1 = MoveY1 + dAddMove
-         MoveY2 = MoveY2 - dAddMove
+         local dAddMoveY1 = ParkV1 + ( -PosT - EMT.LR)
+         local dAddMoveY2 = ParkV2 + ( -PosT - EMT.LR)
+         local MoveY1 = max( DiffY1, dAddMoveY1, 30.0)
+         local MoveY2 = min( DiffY2, dAddMoveY2, -30.0)
 
          -- aggancio i pezzi rimanenti all'asse Y1
          LinkRemainingPartsToY1()
@@ -2534,7 +2574,7 @@ function GetHeadSetFromTcPos( sTcPos)
    local TCPOS_2A = {}
    local TCPOS_2B = {}
    if EgtGetHeadId( 'H21') then
-      TCPOS_1A = { 'T1', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9', 'T10'}
+      TCPOS_1A = { 'T1', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9', 'T10', '501'}
       TCPOS_1B = { 'T101'}
       TCPOS_2A = { 'T11', 'T12', 'T13', 'T14', 'T15', 'T16', 'T17', 'T18', 'T19', 'T20'}
       TCPOS_2B = { 'T111'}
@@ -2542,7 +2582,7 @@ function GetHeadSetFromTcPos( sTcPos)
       TCPOS_1A = { 'T1', 'T2', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9', 'T10'}
       TCPOS_1B = { 'T101', 'T201'}
       TCPOS_1C = { 'T301'}
-      TCPOS_2A = { 'T11', 'T12', 'T13', 'T14', 'T15', 'T16', 'T17', 'T18', 'T19', 'T20'}
+      TCPOS_2A = { 'T11', 'T12', 'T13', 'T14', 'T15', 'T16', 'T17', 'T18', 'T19', 'T20', '502'}
    end
    for _, sVal in ipairs( TCPOS_1A) do
       if sVal == sTcPos then return 1, 1 end
@@ -2592,9 +2632,10 @@ function FindNextToolOnHeadSet( nHSet, bFirst)
          if EgtSetCurrMachining( OpId) then
             local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
             if EgtTdbSetCurrTool( sNextTool) then
-               sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-               if GetHeadSet( sHead) == nHSet and EMT.TOOL ~= sNextTool then
-                  if not HeadIsChainSaw( sHead) then
+               local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+               if GetHeadSet( sNextHead) == nHSet and EMT.TOOL ~= sNextTool then
+                  if not HeadIsChainSaw( sNextHead) then
+                     sHead = sNextHead
                      sTool = sNextTool
                      sTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
                   end

Common_ONE-PF.mlse

@@ -4,6 +4,12 @@
 require( 'EmtGenerator')
 EgtEnableDebug( false)
 
+---------------------------------------------------------------------
+-- *** Generic Machinings ***
+---------------------------------------------------------------------
+require( 'EmtGenMachining')
+---------------------------------------------------------------------
+
 -- Carico libreria
 local BD = require( 'BeamData')
 
@@ -92,8 +98,15 @@ local function IsLinkSafe( vPrec, vNext)
 
    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
-      if EMC.HEAD == 'H12' then
+      elseif EMC.HEAD == 'H12' then
          -- se sotto la traversa
          if vtToolDir:getX() < 0.342 then
             local dLen = SawOffsZ - MillOffs
@@ -118,9 +131,14 @@ function OnSpecialLink()
    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;')
+         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
@@ -150,10 +168,17 @@ function OnSpecialLink()
       -- 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)
+         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 max( vLFiAx[3], vLInAx[3]) > ParkZ1 + 1 then
+         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;')
@@ -161,6 +186,18 @@ function OnSpecialLink()
             EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
             EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;')
             EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+         else
+            -- GESTIONE PER DOPPIO
+            -- se altra testa arriva da home, devo per forza avere un CLIMB, creo il punto
+            if EMC.OTHERLINKTYPE == 1 then
+               EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, vInitAxLink, 30, 2, 2, 'FirstClimb=1;HeadToMoveFirst=H1;')
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+            -- se altra testa deve andare in home, devo per forza avere un RISE, creo il punto
+            elseif EMC.OTHERLINKTYPE == 2 then
+               EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, vFinalAxLink, 30, 3, 2, 'UniqueRise=1;')
+            end
          end
       end
 
@@ -175,9 +212,12 @@ function OnSpecialLink()
          EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
          EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2, 'FirstClimb=1;')
          EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 2)
-         -- se assi cambiano di molto
-         if abs( EMC.R1 - EMC.R1p) > 10 or abs( EMC.R2 - EMC.R2p) > 90 then
+         -- se asse B cambia di molto
+         if abs( 0 - EMC.R2p) > 1 then
             EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2)
+         end
+         -- se assi cambiano di molto
+         if abs( EMC.R1 - EMC.R1p) > 10 then
             EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2)
          end
 
@@ -192,7 +232,10 @@ function OnSpecialLink()
          EmtRemoveRise( EMC.PREVMCHID, EMC.PREVMAIN)
          if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
             EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;')
-            EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2)
+            -- se assi cambiano di molto
+            if abs( EMC.R1 - EMC.R1p) > 10 then
+               EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2)
+            end
             EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 2)
          else
             EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', '')..'FirstRise=1;')
@@ -216,7 +259,7 @@ function OnSpecialLink()
             -- 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, 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;')
@@ -253,7 +296,6 @@ function OnSpecialLink()
          -- 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
@@ -284,6 +326,8 @@ function OnSpecialLink()
          else
             EmtAddRise( EMC.PREVMCHID, EMC.PREVMAIN, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 30, 3, 2, 'UniqueRise=1;')
          end
+      -- altrimenti collegamento tra due lavorazioni (3)
+      else
       end
 
    -- se fresa su testa 2
@@ -322,10 +366,17 @@ function OnSpecialLink()
       -- 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)
+         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 max( vLFiAx[3], vLInAx[3]) > ParkZ1 + 1 then
+         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;')
@@ -333,6 +384,14 @@ function OnSpecialLink()
             EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
             EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, MaxZ1, EMC.R1, 0}, 30, 2, 2, 'FirstClimb=1;')
             EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+         else
+            -- GESTIONE PER DOPPIO
+            -- se altra testa arriva da home, devo per forza avere un CLIMB, creo il punto
+            if EMC.OTHERLINKTYPE == 1 then
+               EmtRemoveClimb( EMC.NEXTMCHID, EMC.NEXTMAIN)
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, vInitAxLink, 30, 2, 2, 'FirstClimb=1;HeadToMoveFirst=H2;')
+               EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 2, 2, 'LastClimb=1;')
+            end
          end
       end
 
@@ -371,19 +430,6 @@ function OnSpecialLink()
          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
@@ -401,7 +447,7 @@ function OnSpecialLink()
             -- 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, 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;')
@@ -426,7 +472,7 @@ function OnSpecialLink()
          EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2p, EMC.L3p, EMC.R1p, EMC.R2p, EMC.R3}, 30, 2, 2, 'FirstClimb=1;')
          EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3}, 30, 2, 2)
          if abs( EMC.R3) < 0.1 then
-            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z1, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2)
+            EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, ParkCSaw0Z2, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2)
          else
             EmtAddClimb( EMC.NEXTMCHID, EMC.NEXTMAIN, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3}, 30, 2, 2)
          end
@@ -437,7 +483,6 @@ function OnSpecialLink()
          -- 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
@@ -929,6 +974,46 @@ function OnSpecialApplyMachining()
 
    -- Recupero la posizione della trave e dei carrelli al termine della precedente operazione
    local nPrevOpeId = EgtGetPrevActiveOperation( EMC.MCHID)
+
+   -- Se esiste lavorazione precedente ed è una tastatura
+   if nPrevOpeId and EgtGetOperationType( nPrevOpeId) == MCH_OY.PROBING then
+      -- se stessa testa e montato già utensile corretto
+      -- recupero valori assi alla fine della lavorazione precedente e all'inizio della corrente
+      local vPrevAxes = EmtGetFinalAxesPos( nPrevOpeId, true)
+      local vCurrAxes = EmtGetInitialAxesPos( EMC.MCHID, true)
+      -- info lavorazione precedente
+      EgtSetCurrMachining( nPrevOpeId)
+      local sPrevTool = EgtGetMachiningParam( MCH_MP.TOOL)
+      local sPrevHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+      local nSetHead = GetHeadSet( sPrevHead)
+      local bPrevIsFirstHead = ( nSetHead == 1 or nSetHead == 11)
+      -- info lavorazione corrente
+      EgtSetCurrMachining( EMC.MCHID)
+      local sCurrTool = EgtGetMachiningParam( MCH_MP.TOOL)
+      local sCurrHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+      nSetHead = GetHeadSet( sCurrHead)
+      local bCurrIsFirstHead = ( nSetHead == 1 or nSetHead == 11)
+
+      -- se utensile corrente è compatibile (significa che è già stato precaricato) se stessa testa e con stessa configurazioen assi rotanti, annullo risalita
+      if IsToolCompatibleWithProbe( sCurrTool, sPrevTool) and bPrevIsFirstHead == bCurrIsFirstHead and abs( vCurrAxes[4] - vPrevAxes[4]) < 1 and abs( vCurrAxes[5] - vPrevAxes[5]) < 1 then
+         -- in lavorazione precedente elimino eventuale retrazione a Zmax
+         EmtRemoveRise( nPrevOpeId)
+         -- in lavorazione corrente elimino eventuale approccio da Zmax
+         EmtRemoveClimb( EMC.MCHID)
+         -- prendo sempre la Z massima tra le due
+         local vClimbPoint
+         if vCurrAxes[3] - 1.0 < vPrevAxes[3] then
+            vClimbPoint = vCurrAxes
+            vCurrAxes[3] = vPrevAxes[3]
+         elseif vPrevAxes[3] - 1.0 < vCurrAxes[3] then
+            vClimbPoint = vPrevAxes
+            vPrevAxes[3] = vCurrAxes[3]
+         end
+         EmtAddClimb( EMC.MCHID, vClimbPoint, 4, 1, 0)
+      end
+   end
+
+   -- Recupero la posizione della trave e dei carrelli al termine della precedente operazione
    -- se precedente operazione non esiste, errore
    if not nPrevOpeId then
       EMC.ERR = 1
@@ -1455,6 +1540,7 @@ function SpecialCalcMachiningEncumbrance( nMchId, bPreCut)
    local dDistFront = - ptMax:getX() - LoadT - dHeadFront
    local dDistBack = ptMin:getX() + LoadT + EMC.LB - dHeadBack
    EgtOutLog( '  DistFront = ' .. EgtNumToString( dDistFront, 1) .. ' DistBack = ' .. EgtNumToString( dDistBack, 1), 3)
+
    return dDistFront, dDistBack, dRollFront, dRollBack
 end
 
@@ -3145,7 +3231,7 @@ 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
+      -- riporta trave in zona carico dopo una fase start partita con un riposizionamento
       elseif Cmd[1] == 24 then
          local sInfo = '24,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..EgtIf( Cmd[6], ',*', '')
          EgtSetInfo( EMC.PATHID, sKey, sInfo)

Essetre-ONE.mlde

@@ -32,9 +32,9 @@
 require( 'EmtGenerator')
 EgtEnableDebug( false)
 
-PP_VER = '3.1e1_NL3'
-PP_NVER = '3.1.3.2'
-MIN_MACH_VER = '2.5k1'
+PP_VER = '3.1g1'
+PP_NVER = '3.1.7.1'
+MIN_MACH_VER = '3.1f1'
 MACH_NAME = EgtGetCurrMachineName()
 
 -- Carico i dati globali
@@ -165,7 +165,8 @@ if EgtExistsFile( sData) then
          end
          if Machine.Offsets.X1_POS then MinX1 = -Machine.Offsets.X1_POS end
          if Machine.Offsets.X1_NEG then MaxX1 = -Machine.Offsets.X1_NEG end
-         if Machine.Offsets.PARK_X1 then ParkX1 = -Machine.Offsets.PARK_X1 end
+         if Machine.Offsets.PARK_X1POS then ParkFrnX1 = -Machine.Offsets.PARK_X1POS end
+         if Machine.Offsets.PARK_X1NEG then ParkX1 = -Machine.Offsets.PARK_X1NEG end
          if Machine.Offsets.Z1_NEG then MinZ1 = Machine.Offsets.Z1_NEG end
          if Machine.Offsets.Z1_POS then MaxZ1 = min( MaxZ1, Machine.Offsets.Z1_POS) end
          if Machine.Offsets.Z1_POS_LAMA then MaxZ1Blade = min( MaxZ1Blade, Machine.Offsets.Z1_POS_LAMA) end
@@ -223,13 +224,14 @@ if EgtExistsFile( sData) then
          -- aggiustamenti
          MinY1 = MinV1 + MinDeltaYV
          MaxY1 = MaxMchY1
-         ParkV1 = MaxV1 
+         ParkV1 = MaxV1
          ParkY1 = ParkV1 + MinDeltaYV
          MinY2 = MinMchY2
          MaxY2 = MaxV2 - MinDeltaYV
          ParkV2 = MinV2
          ParkY2 = ParkV2 - MinDeltaYV
          ParkX1 = min( ParkX1, MaxX1)
+         ParkFrnX1 = max( ParkFrnX1, MinX1)
          MaxZ1Blade = min( MaxZ1Blade, MaxZ1)
          ParkCSawZ1 = min( ParkCSawZ1, MaxZ1)
          ParkCSaw0Z1 = min( ParkCSaw0Z1, MaxZ1)
@@ -834,13 +836,10 @@ function OnSetHead()
          EmtModifyAxisHome( 'B1', MyHomeB1)
       end
    -- se testa H13 (sega a catena)
-   elseif EMC.HEAD == 'H13' then
+   elseif EMC.HEAD == 'H13' or EMC.HEAD == 'H15' then
       -- aggiustamenti per distanza
       local dDist = EgtIf( EMC.DIST and abs( EMC.DIST) > 1, EMC.DIST, ChSawLen)
       EmtModifyExitPosition( EMC.HEAD, EMC.EXIT, Point3d( 0, 0, -dDist))
-      local vtMove = Point3d( 0, 0, -dDist) - Point3d( EMC.EXITPOS)
-      local ExitId = EgtGetFirstNameInGroup( EgtGetHeadId( EMC.HEAD), 'T'..tostring( EMC.EXIT))
-      EgtMove( ExitId, vtMove)
       -- recupero valore asse A bloccato
       local sVal = EgtGetMachiningParam( MCH_MP.BLOCKEDAXIS)
       local CSawPosA = tonumber( sVal:sub( 3) or '')
@@ -849,19 +848,20 @@ function OnSetHead()
       EmtModifyAxisHome( 'C1', GetChainSawCHomeFromVirtualAxis( CSawPosA))
       EmtModifyAxisHome( 'B1', ParkCSawB1)
       EmtModifyAxisDirection( 'B1', X_AX())
-   -- se testa H15 (mortasatrice di One) 
-   elseif EMC.HEAD == 'H15' then
-      error( 'Error : Mortiser not yet managed')
    end
 end
 
 ---------------------------------------------------------------------
 -------------------------- Testa utilizzata -------------------------
 function GetHeadSet( sHead)
-   if sHead == 'H11' or sHead == 'H12' or sHead == 'H13' or sHead == 'H15' then
+   if sHead == 'H11' or sHead == 'H12' or sHead == 'H13' or sHead == 'H15' or sHead == 'H17' then
       return 1
+   elseif sHead == 'H19' then
+      return 11
    elseif sHead == 'H21' or sHead == 'H22' or sHead == 'H23' then
       return 2
+   elseif sHead == 'H29' then
+      return 21
    else
       return 0
    end
@@ -890,6 +890,7 @@ function GetHeadTCSet( sHead, sTcPos)
       return 0
    end
 end
+
 ---------------------------------------------------------------------
 -- Funzione che restituisce l'altezza del pezzo in lavorazione
    function GetRawHeight()
@@ -909,6 +910,12 @@ function HeadIsChainSaw( sHead)
    return ( sHead == 'H13' or sHead == 'H15')
 end
 
+---------------------------------------------------------------------
+-- Funzione che riconosce testa per tastatore
+function HeadIsProbe( sHead)
+   return ( sHead == 'H19' or sHead == 'H29')
+end
+
 ---------------------------------------------------------------------
 -- Funzione che calcola la posizione Home di Z per la sega a catena dal valore dell'asse virtuale
 function GetChainSawZHomeFromVirtualAxis( dPosA)
@@ -972,7 +979,7 @@ end
 -- Funzione per impostare spia stato morsa carrello Y1
 function SetPY1Light( bClosed)
    if not PY1LightId then return end
-   EgtSetColor( PY1LightId, EgtIf( bClosed, 'RED', 'LIME')) 
+   EgtSetColor( PY1LightId, EgtIf( bClosed, 'RED', 'LIME'))
    if bClosed then
       EgtSetInfo( PY1LightId, 'On', '1')
    else

UpdateLog.txt

@@ -1,10 +1,30 @@
            ==== Common_ONE-PF Update Log ====
 
+Versione 3.1g1 (07/07/2026)
+- (ALL) Prima versione con gestione nuovi link (no tastatore)
+-       Gestione lavorazioni in doppio
+-       Preselezione utensile gestibile da parametri TS3
+-       Gestione Drilling e Pocketing NT
+
+Versione 3.1f5 (26/06/2026)
+- (SIM-GEN) Se tasca con motosega in faccia sopra e pezzo alto, si ruota in sicurezza.
+
+Versione 3.1f4 (17/06/2026)
+- (MLDE-GEN) Corretta preselezione in caso di testa in lavoro troppo vicina a quella che sta preselezionando. Da aggiungere in MLDE parametri 'Limit_T1_Presel_T2' e 'Limit_T2_Presel_T1'
+
+Versione 3.1f3 (08/06/2026)
+- (GEN) M77 viene ora eseguita, prima era commentata.
+
+Versione 3.1f2 (05/06/2026)
+- (MLDE-GEN) Aggiunti parametri di limite asse X per decidere se fare preselezione su altra testa. Serve modifica MLDE
+
+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

Version.lua

@@ -3,8 +3,8 @@
 
 local InfoCommon_STD_PP = {
    NAME = 'Common_ONE-PF',            -- nome script PP standard
-   VERSION = '3.1c2',                 -- versione script
-   MIN_MACH_VER_PP_COMMON = '3.1b2'   -- versione minima kernel
+   VERSION = '3.1g1',                 -- versione script
+   MIN_MACH_VER_PP_COMMON = '3.1f1'   -- versione minima kernel
 }
 
 return InfoCommon_STD_PP