Apertura pinze anche in LOAD

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
 
@@ -523,7 +530,7 @@ function OnMachiningEnd()
       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
@@ -697,9 +704,7 @@ end
 
 ---------------------------------------------------------------------
 function OnPathEnd()
-   if not EMT.ZMAX then
+
-      -- EmitResetMachining( true)
-   end
 
    -- salvo dati precedenti
    EMT.L2pp = EMT.L2o
@@ -821,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")
@@ -853,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..' *** )')
 
@@ -864,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
+         -- controllo se ci sono spostamenti dei carrelli programmati
-         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
+         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)
@@ -903,7 +942,7 @@ function OnRapid()
             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
 
@@ -915,6 +954,11 @@ function OnRapid()
             -- 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
@@ -950,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
+            if bParkV or bNlhParkV then
-               local bMchSplit = bNlhParkV and bSplitMach
+               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
@@ -965,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()
+      -- se non ho ancora impostato il piano, movimenti in assoluto
-      EmtAdjustRotaryAxes()
+      if not EMT.PLANEACTIVE then
-      local dTRad, dTLen = GetToolRadLen()
+         MyAdjustLinearAxes()
-      EmitMoveDataHead( nHSet, { X=EMT.L2, Z=EMT.L3, C=EMT.R1, B=EMT.R2, TRad=dTRad, TLen=dTLen, S=CalcRealSpeed( EMT.S)})
+         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
@@ -996,11 +1066,13 @@ function OnRapid()
          EmitMoveStartHead( nHSet)
          -- se lavorazione in doppio
          if nHSet == 1 and EMT.DOU_TYPE == 2 then
-            for i = 1, #EMT.APPROACH.DBLRISES do
+            if EMT.APPROACH.DBLRISES and #EMT.APPROACH.DBLRISES > 0 then
-               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})
+               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
@@ -1022,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
+         if EMT.APPROACH.DBLCLIMBS and #EMT.APPROACH.DBLCLIMBS > 0 then
-            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})
+            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)
@@ -1141,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
@@ -1258,14 +1333,16 @@ function OnLinear()
    MyAdjustLinearAxes()
    EmtAdjustRotaryAxes()
 
-      -- se lavorazione in doppio e fondo foro, inverto movimento punta doppia
+   -- se lavorazione in doppio, da questo movimento bisogna passare ad accoppiamento in parallelo
-   if EMT.MCHTYPE == MCH_MY.DRILLING and not EMT.DBLHEADPARA and EMT.DOU_TYPE == 2 and EMT.FLAG == 105 then
+   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
+   -- se testa accoppiata in parallelo, in uscita si disaccoppia per tornare ad accoppiamento speculare
-   if EMT.DBLHEADPARA and EMT.FLAG == 104 then
+   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
@@ -1341,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')
@@ -2044,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
@@ -2310,14 +2394,14 @@ function EmitResetMachining( bNextTool)
 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 dY1Delta = EMT.Y1DELTA
-   local dY2Delta = EgtIf( bUsePrevDelta, EMT.Y2PREVDELTA, EMT.Y2DELTA)
+   local dY2Delta = EMT.Y2DELTA
    -- Parcheggi pinze
-   local MyParkY1 = ParkY1 + AggLoad
+   local MyParkY1 = ParkY1 + EgtIf( bAgg, AggLoad, 0)
    local MyParkY2 = ParkY2
    -- le parcheggio
    local MDChar = {}
@@ -2328,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
+         local dAddMoveY1 = ParkV1 + ( -dPosT - EMT.LT)
-         if DiffY1 > 0.1  then
+         local dAddMoveY2 = ParkV2 + ( -dPosT - EMT.LT)
-            bYNoMove = false
+         local MoveY1 = max( DiffY1, dAddMoveY1, 30.0)
-            MDChar.Y1 = dPosY1 + DiffY1
+         local MoveY2 = min( DiffY2, dAddMoveY2, -30.0)
-         else
+         MDChar.Y1 = dPosY1 + MoveY1
-            bYNoMove = true
+         MDChar.Y2 = dPosY2 + MoveY2
-            MDChar.Y1 = dPosY1
+         dPosT = dPosT + MoveY2
-         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 + 150
-            MDChar.Y2 = MDChar.Y2 - 150
-         end
       elseif DiffY1 > 0.1 and DiffY2 < -0.1 then
          EmtSetLastError( 1201, 'Error Collision in ParkRoller')
       elseif DiffY1 > 0.1  then
@@ -2403,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)
@@ -2414,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
+   -- se macchina con due teste, devo preselezionare stessa testa quando ho motosega, altrimenti già fatta
-   if EgtGetHeadId( 'H21') then
+   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
@@ -2431,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 sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-                  local nClId = EgtGetFirstNameInGroup( nNextMchId, 'CL') -- recupero Id del gruppo CL della lavorazione corrente
+               local nNextHSet = GetHeadSet( sNextHead)
-                  local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1)
+               -- se stessa testa
-                  local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari 
+               if nNextHSet == nHSet then
-                  if dAuxMoveCount > 3 then
+                  if EMT.TOOL ~= sNextTool then
-                     bCarrMove = true
+                     local nClId = EgtGetFirstNameInGroup( nNextMchId, 'CL') -- recupero Id del gruppo CL della lavorazione corrente
-                  end
+                     local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1)
-                  local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+                     local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari 
-                  -- motosega non può essere preselezionata
+                     if dAuxMoveCount > 3 then
-                  if not HeadIsChainSaw( sNextHead) then
+                        bCarrMove = true
-                     sToolChange = sNextTool
+                     end
-                     sToolChangePos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
+                     local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-                     sToolChangeHead = sNextHead
+                     -- 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
@@ -2457,29 +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, MyParkB1, MyParkC1
+         local MyParkX, MyParkB, MyParkC
-         if GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head1_TC2' then
+         if GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head2_TC2' then
-            MyParkX1 = ParkFrnX1
+            MyParkX = ParkX2
-            MyParkB1 = ParkFrnB1
+            MyParkZ = MaxZ2
-            MyParkC1 = ParkFrnC1
+            MyParkB = ParkB2
+            MyParkC = ParkC2
+         elseif GetHeadTCSet( sToolChangeHead, sToolChangePos) == 'Head1_TC2' then
+            MyParkX = ParkFrnX1
+            MyParkZ = MaxZ1
+            MyParkB = ParkFrnB1
+            MyParkC = ParkFrnC1
          else
-            MyParkX1 = ParkX1
+            MyParkX = ParkX1
-            MyParkB1 = ParkB1
+            MyParkZ = MaxZ1
-            MyParkC1 = ParkC1
+            MyParkB = ParkB1
+            MyParkC = ParkC1
          end
 
          EmtOutput( '( *** TOOL PRE-SEL *** )')
-         EmitMoveDataHead( 1, { X=-MyParkX1, Z=MaxZ1, B=MyParkB1, C=MyParkC1, 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
@@ -2487,8 +2576,8 @@ function ToolPreSelectionSingleHead( nMchId)
          EmitUnmountChainSaw()
       end
    else
-      -- se ultima lavorazione e ho motosega, scarico
+      -- se ho motosega, scarico
-      if not nNextMchId and HeadIsChainSaw( EMT.HEAD) then
+      if HeadIsChainSaw( EMT.HEAD) then
          EmtOutput( '( *** UNMOUNT CHAIN-SAW *** )')
          EmitUnmountChainSaw()
       end
@@ -2504,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 bDoubleTool = false
-   local nNextMchId = EgtGetNextActiveOperation( nMchId)
+   local sDoubleTool = ''
-   while nNextMchId do
+
-      if EgtGetOperationType( nNextMchId) ~= MCH_OY.DISP then
+   if bVerifyPresel then
-         if EgtSetCurrMachining( nNextMchId) then
+      -- recupero lavorazione successiva
-            local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
+      local nNextMchId = EgtGetNextActiveOperation( nMchId)
-            if EgtTdbSetCurrTool( sNextTool) then
+      while nNextMchId do
-               local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+         if EgtGetOperationType( nNextMchId) ~= MCH_OY.DISP then
-               local nNextHSet = GetHeadSet( sNextHead)
+            if EgtSetCurrMachining( nNextMchId) then
-               if nNextHSet ~= nHSet then
+               local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
-                  break
+               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
+   -- se non eseguita preselezione
-   if nNextMchId and EgtSetCurrMachining( nNextMchId) then
+   if not bPresel then
-      local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
+      -- se era stato preselezionato un utensile e adesso non posso preselezionare, attendo la testa
-      if EgtTdbSetCurrTool( sNextTool) then
+      if EMT.PRESEL_H2 then
-         local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+         EmitMoveWaitHead( 2)
-         local nNextHSet = GetHeadSet( sNextHead)
+         EMT.PRESEL_H2 = nil
-         if nNextHSet ~= nHSet then
+      elseif EMT.PRESEL_H1 then
-            local sNextTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
+         EmitMoveWaitHead( 1)
-            -- se testa attuale da caricare è sega a catena, mando l'altra prima in HomeX (per evitare possibili collisioni) e poi lancio preselezione
+         EMT.PRESEL_H1 = nil
-            if sHead == 'H13' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H1) then
+      -- 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)
+            end
-            elseif sHead == 'H23' and nHSet ~= GetHeadSet( EMT.PREVHEAD_H2) then
+         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
+   else
-   -- 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
       if nHSet == 1 then
-         -- non può essere la sega a catena
+         EMT.PRESEL_H2 = true
-         if EMT.PREVHEAD_H2 ~= 'H23' then
+      elseif nHSet == 1 then
-            EmitMoveDataHead( 2, { X=-ParkX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)})
+         EMT.PRESEL_H2 = true
-            EmitMoveStartHead( 2)
-         end
-      else
-         -- non può essere la sega a catena
-         if EMT.PREVHEAD_H1 ~= 'H13' and EMT.PREVHEAD_H1 ~= 'H15' then
-            EmitMoveDataHead( 1, { X=-ParkX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)})
-            EmitMoveStartHead( 1)
-         end
       end
    end
 end

Common_ONE-PF.mlpe

@@ -537,14 +537,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 +553,9 @@ function OnSimulToolSelect( dPosA)
          EgtSetAxisPos( 'B1', ParkCSawB1)
          EgtSetAxisPos( 'X1', ParkCSawX1)
          -- l'utensile viene caricato qui, quindi setto come già cambiato
+         EMT.PREVTOOL_H1 = EMT.TOOL
          EMT.PREVHEAD_H1 = EMT.HEAD
+         EMT.PREVTCPOS_H1 = EMT.TCPOS
       else
          -- imposto home dell'asse C2 (A=0 -> T111, A=-90 -> T112)
          local MyParkCSawC2 = GetChainSawCHomeFromVirtualAxis( dPosA)
@@ -570,7 +564,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 +616,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( 'C1', dHomeC1)
-         EgtSetAxisPos( 'B1', ParkB1)
+         EgtSetAxisPos( 'B1', dHomeB1)
          EgtSetAxisPos( 'Z1', MaxZ1)
-         SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID)
+         SimulMoveAxis( 'X1', dHomeX1, MCH_SIM_STEP.RAPID)
-         local sTool, sHead, sTcPos = FindNextToolOnHeadSet( 1, false)
          if sTcPos then
             LoadNextTool( 1, DefTcPos1)
          end
@@ -638,13 +643,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
@@ -659,6 +668,16 @@ function OnSimulToolDeselect( dPrevA)
    -- 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 +862,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 +999,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 +1027,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 +1038,41 @@ function OnSimulMoveStart()
 
       -- movimento di approccio o retrazione
       else
-         -- incremento indice approccio
+         local bFirstMoveOnlyH1 = sHeadToMoveFirst and sHeadToMoveFirst == 'H1'
-         EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1
+         local bFirstMoveOnlyH2 = sHeadToMoveFirst and sHeadToMoveFirst == 'H2'
-         -- se non esiste movimento sulla testa due, significa che gli approcci della testa 1 sono in maggior numero
+         -- se bisogna muovere prima la testa 2, si esegue subito il primo movimento della testa, priam di muovere la testa 1
-         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
+         if bFirstMoveOnlyH2 then
-            EMT.AuxAxes = 4 + 4
+            if #EMT.APPROACH.DBLCLIMBS > 0 then
-            EMT.A5n = 'X2'
+               EMT.INDEX_APPROACH_MOVE = EMT.INDEX_APPROACH_MOVE + 1
-            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
+               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)
-               EMT.A5 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L2
+            end
-               EMT.A6 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].L3
+         -- se bisogna muovere prima la testa 1, il movimento della testa 2 non si esegue adesso
-               EMT.A7 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R1
+         elseif not bFirstMoveOnlyH1 then
-               EMT.A8 = EMT.APPROACH.DBLRISES[EMT.INDEX_APPROACH_MOVE].R2
+            -- 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 +1104,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 +1117,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 +1148,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 +1705,10 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg)
       local DiffY2 = MyParkY2 - PosY2
       -- se appena eseguito taglio di separazione
       if bSpliCut then
-         local dAddMove
+         local dAddMoveY1 = ParkV1 + ( -PosT - EMT.LR)
-         -- se entrambe le morse si spostano vado in posizione calcolata
+         local dAddMoveY2 = ParkV2 + ( -PosT - EMT.LR)
-         if DiffY1 > 0.1 and DiffY2 < -0.1 then
+         local MoveY1 = max( DiffY1, dAddMoveY1, 30.0)
-            dAddMove = 0
+         local MoveY2 = min( DiffY2, dAddMoveY2, -30.0)
-         -- se almeno una è rimasta ferma in posizione, allontano comunque di 30mm ulteriori
-         else
-            dAddMove = 150
-         end
-         local MoveY1 = max( DiffY1, 0.0)
-         local MoveY2 = min( DiffY2, 0.0)
-
-         MoveY1 = MoveY1 + dAddMove
-         MoveY2 = MoveY2 - dAddMove
 
          -- aggancio i pezzi rimanenti all'asse Y1
          LinkRemainingPartsToY1()
@@ -2592,9 +2627,10 @@ function FindNextToolOnHeadSet( nHSet, bFirst)
          if EgtSetCurrMachining( OpId) then
             local sNextTool = EgtGetMachiningParam( MCH_MP.TOOL)
             if EgtTdbSetCurrTool( sNextTool) then
-               sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
+               local sNextHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
-               if GetHeadSet( sHead) == nHSet and EMT.TOOL ~= sNextTool then
+               if GetHeadSet( sNextHead) == nHSet and EMT.TOOL ~= sNextTool then
-                  if not HeadIsChainSaw( sHead) then
+                  if not HeadIsChainSaw( sNextHead) then
+                     sHead = sNextHead
                      sTool = sNextTool
                      sTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
                   end

Common_ONE-PF.mlse

@@ -125,9 +125,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
@@ -175,6 +180,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
 
@@ -189,9 +206,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
+         -- se asse B cambia di molto
-         if abs( EMC.R1 - EMC.R1p) > 10 or abs( EMC.R2 - EMC.R2p) > 90 then
+         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
 
@@ -206,7 +226,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;')
@@ -230,7 +253,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;')
@@ -267,7 +290,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
@@ -336,10 +358,17 @@ function OnSpecialLink()
       -- altrimenti collegamento tra due lavorazioni (3)
       else
          -- recupero quota massima di collegamento
-         local vLFiAx = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
+         local vFinalAxLink = EmtGetFinalAxesPos( EMC.PREVMCHID, EMC.PREVMAIN, false)
-         local vLInAx = EmtGetInitialAxesPos( EMC.NEXTMCHID, EMC.NEXTMAIN, 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;')
@@ -347,6 +376,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
 
@@ -415,7 +452,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;')
@@ -440,7 +477,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
@@ -451,7 +488,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
@@ -3159,7 +3195,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,8 +32,8 @@
 require( 'EmtGenerator')
 EgtEnableDebug( false)
 
-PP_VER = '3.1e1_NL9_DEV1'
+PP_VER = '3.1f1_RC10'
-PP_NVER = '3.1.3.2'
+PP_NVER = '3.1.6.1'
 MIN_MACH_VER = '2.5k1'
 MACH_NAME = EgtGetCurrMachineName()
 
@@ -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
@@ -230,6 +231,7 @@ if EgtExistsFile( sData) then
          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
@@ -909,6 +909,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)