Cambio nome nota per decidere se scarico pezzo lato scarico o lato carico

- Corretta generazione con M77.

Beam/BeamData.lua

@@ -41,6 +41,7 @@ local BeamData = {
    DRILL_TOL = 0.2,                         -- tolleranza tra diametro foro e diametro punta
    DRILL_VZ_MIN = - 0.51,                   -- componente limite in Z del versore di un foro
    DRILL_VX_MAX = 0.867,                    -- componente limite in X del versore di un foro sulle facce laterali
+   MAX_ANGLE_DRILL_CUT = 15,                -- delta angolo massimo tra foro e taglio che lo attraversa
    DRILL_OVERLAP = 5,                       -- sovrapposizione tra due mezze forature
    MILL_OVERLAP = 5,                        -- sovrapposizione tra due mezze fresature
    MAX_DIST_HTFEA = 50.0,                   -- massima distanza di feature da testa o coda per essere considerata tale
@@ -72,10 +73,11 @@ local BeamData = {
    PRECUT_HEAD = true,                      -- flag abilitazione pretaglio grezzo a zero in testa
    PRECUT_TAIL = true,                      -- flag abilitazione pretaglio grezzo a zero in coda
    ADVANCE_TAIL_CUT = true,                 -- per spostare prima del taglio di separazione il taglio di coda su pezzi corti con robabile caduta
-   ADVANCE_TAIL_OFFS = 5,                    -- accorciamento taglio di coda avanzato (minimo 1)
+   ADVANCE_TAIL_OFFS = 5,                   -- accorciamento taglio di coda avanzato (minimo 1)
    DOUBLE_HEAD_DOVETAIL = true,             -- flag abilitazione lavorazione mortase a coda di rondine in doppio
    DOUBLE_HEAD_MORTISE = true,              -- flag abilitazione lavorazione mortase in doppio
-   DOUBLE_HEAD_DRILLING = true              -- flag abilitazione forature in doppio
+   DOUBLE_HEAD_DRILLING = true,             -- flag abilitazione forature in doppio
+   USE_PART_OFFSET = false                  -- flag abilitazione lettura PART_OFFSET da btl
 }
 
 ---------------------------------------------------------------------
@@ -108,12 +110,14 @@ if EgtExistsFile( sDataBeam) then
          BeamData.LEN_VERY_SHORT_PART = Machine.Offsets.LEN_VERY_SHORT_PART or BeamData.LEN_VERY_SHORT_PART
          BeamData.LEN_SHORT_PART = Machine.Offsets.LEN_SHORT_PART or BeamData.LEN_SHORT_PART
          BeamData.OVM_MID = Machine.Offsets.OVM_MID or BeamData.OVM_MID
+         BeamData.MAX_ANGLE_DRILL_CUT = Machine.Offsets.MAX_ANGLE_DRILL_CUT or BeamData.MAX_ANGLE_DRILL_CUT
          if Machine.Offsets.PRECUT_HEAD_DISABLE then BeamData.PRECUT_HEAD = ( Machine.Offsets.PRECUT_HEAD_DISABLE == 0) end
          if Machine.Offsets.PRECUT_TAIL_DISABLE then BeamData.PRECUT_TAIL = ( Machine.Offsets.PRECUT_TAIL_DISABLE == 0) end
          -- per tagli con lama longitudinale si può attivare oppure si prende in automatico in caso di presenza della seconda lama
          if Machine.Offsets.SECONDSAW then SecondSaw = ( Machine.Offsets.SECONDSAW == 1) end
          BeamData.USE_LONGCUT = SecondSaw or BeamData.USE_LONGCUT
          if Machine.Offsets.CUT_SIC then BeamData.CUT_SIC = EgtClamp( Machine.Offsets.CUT_SIC, 15, 50) end
+         if Machine.Offsets.USE_PART_OFFSET then BeamData.USE_PART_OFFSET = ( Machine.Offsets.USE_PART_OFFSET == 1) end
       end
       if Machine.Trave then
          BeamData.MIN_WIDTH = Machine.Trave.XMIN or BeamData.MIN_WIDTH

Common_PF1250.TPA.mlpe

@@ -289,13 +289,22 @@ function OnDispositionEnd()
    -- altrimenti disposizione finale, eventuale scarico pezzo lavorato se non ci sono lavorazioni
    else   
       if #EMT.MDCHAR > 0 then
-         EmitRemark( 'PART UNLOAD')
+         if EMT.AUXTYPE == 'R' and UnloadOnLoadPos then
+            EmitRemark( 'PART UNLOAD ON LOAD POSITION')
+         else
+            EmitRemark( 'PART UNLOAD')
+         end
       end
       for i = 1, #EMT.MDCHAR do
-         EmitMoveDataChars( EMT.MDCHAR[i])
-         if EMT.MDCHAR[i].Y1 then EMT.CHY_ON = true end
-         if EMT.MDCHAR[i].V1 then EMT.V1POS = EMT.MDCHAR[i].V1 end
-         if EMT.MDCHAR[i].V2 then EMT.V2POS = EMT.MDCHAR[i].V2 end
+         -- Se è un'istruzione del piano ferma pezzo
+         if EMT.MDCHAR[i].StopBeamStat then
+            EmitStopBeam( EMT.MDCHAR[i])
+         else
+            EmitMoveDataChars( EMT.MDCHAR[i])
+            if EMT.MDCHAR[i].Y1 then EMT.CHY_ON = true end
+            if EMT.MDCHAR[i].V1 then EMT.V1POS = EMT.MDCHAR[i].V1 end
+            if EMT.MDCHAR[i].V2 then EMT.V2POS = EMT.MDCHAR[i].V2 end
+         end
       end
       if #EMT.MDCHAR > 0 then
          local nMoveType = EgtIf( EMT.CHY_ON, 3, 2)
@@ -311,6 +320,9 @@ function OnDispositionEnd()
             local sEnd= 'M113 P1='..tostring( EMT.PRODID)..' P2='..tostring( EMT.PATTID)..' P3='..tostring( EMT.CUTID)..' P4=2' 
             MyOutput( sEnd)
          end
+         if UnloadOnLoadPos then
+            MyOutput('M77')
+         end
       end
       EMT.MDCHAR = {}
       EMT.AUXTYPE = nil
@@ -489,6 +501,10 @@ function OnMachiningEnd()
       elseif EMT.AUXTYPE == 'U' then
          EmitRemark( 'PART UNLOAD')
       elseif EMT.AUXTYPE == 'P' then
+         local nNextPathId
+         local nNextMchId
+         if EMT.PATHID then nNextPathId = EgtGetNextActiveOperation( EMT.PATHID) end
+         if EMT.MCHID then nNextMchId = EgtGetNextActiveOperation( EMT.MCHID) end
          if EMT.PREROT then
             EmitZmax( false, true, EMT.R1, EMT.R2, false, false, false)
             EMT.ZMAX = true
@@ -500,6 +516,10 @@ function OnMachiningEnd()
                EMT.TO_ZMAX = nil
             end
             EmitRemark( 'PART FALL')
+         elseif UnloadOnLoadPos and not nNextPathId and not nNextMchId then
+            EmitZmax( false, true, EMT.R1, EMT.R2, false, false, false)
+            EMT.ZMAX = true
+            EmitRemark( 'PART UNLOAD ON LOAD POSITION')
          else
             EmitZmax( false, true, EMT.R1, EMT.R2, false, false, false)
             EMT.ZMAX = true
@@ -508,7 +528,12 @@ function OnMachiningEnd()
       end
    end
    for i = 1, #EMT.MDCHAR do
-      EmitMoveDataChars( EMT.MDCHAR[i])
+      -- Se è un'istruzione del piano ferma pezzo
+      if EMT.MDCHAR[i].StopBeamStat then
+         EmitStopBeam( EMT.MDCHAR[i])
+      else
+         EmitMoveDataChars( EMT.MDCHAR[i])
+      end
    end
    if #EMT.MDCHAR > 0 then
       if EMT.AUXTYPE == 'S' then
@@ -538,6 +563,7 @@ function OnMachiningEnd()
                local sEnd= 'M113 P1='..tostring( EMT.PRODID)..' P2='..tostring( EMT.PATTID)..' P3='..tostring( EMT.CUTID)..' P4=2' 
                MyOutput( sEnd)
             end
+            EMT.FALL = nil
          elseif not EMT.PREROT then
             MyOutput( 'M77')
          end
@@ -628,6 +654,9 @@ function OnPathStartAux()
    local Cmd = EgtSplitString( EMT.AUX)
    if Cmd[1] == '4' then
       EMT.TO_ZMAX = true
+      if Cmd[2] == '1' then
+         EMT.ROLL_IN = true
+      end
    end
 end
 
@@ -767,7 +796,15 @@ function OnRapid()
                EmitMoveDataHead( 1, { B=0, S=Speed})
                EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
                EmitMoveDataHead( 1, { X=EMT.L2, S=Speed})
-               EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
+               -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento
+               -- evita collisione con carro X
+               if EMT.R2 > 91 or EMT.R2 < -91 then
+                  local dBref = EgtClamp( EMT.R2, -91, 91)
+                  EmitMoveDataHead( 1, { Z=EMT.L3, B=dBref, S=Speed})
+                  EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
+               else
+                  EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
+               end
             -- caso standard
             else
                -- se bisogna scrivere tutti gli assi
@@ -907,6 +944,8 @@ function OnRapid()
                local dPosT = EMT.TPOS or EMT.L1op
                EmitParkRoller( dPosT, bSplitCut)
             end
+            -- eventuale preselezione successiva testa 2
+            PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
             -- eseguo movimenti
             local Speed = EMT.S
             -- se è macchina a 3 teste con gruppo truciolatore 4 assi
@@ -914,10 +953,6 @@ function OnRapid()
                EmitMoveDataHead( 3, { Z=EMT.L3, S=Speed})
                EmitMoveDataHead( 3, { B=EMT.R2, C=EMT.R1, S=Speed})
                EmitMoveStartHead( 3)
-               -- eventuale preselezione successiva testa 2
-               PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
-               -- aspetto esecuzione movimento testa 3
-               EmitMoveWaitHead( 3)
             -- se gruppo lama dedicato, senza cambio utensile
             elseif EgtGetHeadId( 'H38') then
                local B3Home = EgtGetAxisHomePos( 'B3')
@@ -935,16 +970,14 @@ function OnRapid()
                end
                -- muovo in posizione finale
                EmitMoveDataHead( 3, { X=EMT.L2, Z=EMT.L3, B=EMT.R2, C=EMT.R1, S=Speed})
-
-               EmitMoveStartHead( 3)
-               -- eventuale preselezione successiva testa 2
-               PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
-               -- aspetto esecuzione movimento testa 3
-               EmitMoveWaitHead( 3)
-            -- errore, testa non gestita
             else
                EmtSetLastError( 1212, "HEAD not managed")
             end
+
+            EmitMoveStartHead( 3)
+            -- aspetto esecuzione movimento testa 3
+            EmitMoveWaitHead( 3)
+            -- errore, testa non gestita
          end
          -- dati aggancio a trave
          local BhData = { T=EMT.L1, SetHead=0}
@@ -998,17 +1031,18 @@ function OnRapid()
       else
          --MyOutput( string.format( 'V1Pos=%.3f V2Pos=%.3f', EMT.V1POS, EMT.V2POS))
          if not EMT.RELOAD and not EMT.ZMAX and #EMT.AUXCMD > 0 and EMT.TO_ZMAX then
+            local bGotoHome = EMT.HEAD == 'H38' and EMT.ROLL_IN
             -- caso speciale in cui bisogna solo cambiare presa aggregato lama sotto
             if EMT.R3_CHANGED then
                -- EmitZmax è fatta per essere chiamata con utensile attuale. In questo caso l'attuale è già quello con nuova rotazione
                -- Allora salvo l'attuale e imposto il vecchio solo momentanemente, per poi ripristinarlo
                local sBckTcPos = EMT.TCPOS
                EMT.TCPOS = EMT.PREVTCPOSREAL_H2
-               EmitZmax( false, false, PrevR1, PrevR2, false, false, true)
+               EmitZmax( false, false, PrevR1, PrevR2, false, bGotoHome, true)
                EMT.TCPOS = sBckTcPos
                EMT.R3_CHANGED = nil
             else
-               EmitZmax( false, false, PrevR1, PrevR2, false, false, true)
+               EmitZmax( false, false, PrevR1, PrevR2, false, bGotoHome, true)
             end
             EMT.ZMAX = true
             EMT.TO_ZMAX = nil
@@ -1084,7 +1118,15 @@ function OnRapid()
                      EmitMoveDataHead( 1, { Z=MyMaxZ1, B=0, S=Speed})
                      EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
                      EmitMoveDataHead( 1, { X=EMT.L2, S=Speed})
-                     EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
+                     -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento
+                     -- evita collisione con carro X
+                     if EMT.R2 > 91 or EMT.R2 < -91 then
+                        local dBref = EgtClamp( EMT.R2, -91, 91)
+                        EmitMoveDataHead( 1, { Z=EMT.L3, B=dBref, S=Speed})
+                        EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
+                     else
+                        EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
+                     end
                   -- caso standard
                   else
                      -- se ero in posizione speciale, prima ruoto poi scendo
@@ -1105,16 +1147,24 @@ function OnRapid()
                -- altrimenti sega a catena
                else
                   -- se bisogna scrivere tutti gli assi
+                  local dSafeZ1 = EgtIf( EMT.TTOTLEN < MinLengthLongCSaw, ParkCSawZ1, ParkLongCSawZ1)
                   if WriteAllCoordsOnFirstM101 then
-                     local dSafeZ1 = EgtIf( EMT.TTOTLEN < MinLengthLongCSaw, ParkCSawZ1, ParkLongCSawZ1)
                      EmitMoveDataHead( 1, { X=-ParkCSawX1, Z=dSafeZ1, B=HomeB1, C=HomeC1, TRad=dTRad, TLen=dTLen, S=Speed})
                   end
                   -- Porto la Z alla giusta quota
-                  if EMT.L3 > HomeZ1 + 1 and abs( EMT.R2) > 89.9 then
+                  if EMT.L3 > dSafeZ1 + 1 and abs( EMT.R2) > 89.9 then
                      EmitMoveDataHead( 1, { X=EMT.L2, S=Speed})
-                     EmitMoveDataHead( 1, { Z=HomeZ1, S=Speed})
+                     EmitMoveDataHead( 1, { Z=dSafeZ1, S=Speed})
+                  end
+                  local dChSawEncumbrance = EMT.L3 + MillOffs - ( ( ChSawLen + MillOffs) * EMT.ADIR[3]) - ( EMT.TTOTLEN * EMT.TDIR[3])
+                  local dBeamQuote = DeltaTabZ + EMT.SB + 30
+                  if dChSawEncumbrance < dBeamQuote then
+                     EmitMoveDataHead( 1, { Z=dSafeZ1, B=EMT.R2, S=Speed})
+                     EmitMoveDataHead( 1, { X=EMT.L2, C=EMT.R1, S=Speed})
+                     EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed})
+                  else
+                     EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
                   end
-                  EmitMoveDataHead( 1, { Z=EMT.L3, B=EMT.R2, S=Speed})
                   -- se motosega molto lunga, ruoto prima di muovermi in X
                   if EMT.TTOTLEN >= MinLengthLongCSaw then
                      EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
@@ -1238,6 +1288,8 @@ function OnRapid()
             EmitMoveWaitHead( 2)
          -- altrimenti testa 3
          else
+            -- eventuale preselezione successiva testa 2
+            PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
             -- selezione testa (posso muovere X solo a Zmax)
             local MyMaxZ3 = EgtGetAxisMax( 'Z3')
             local dSafeZ3 = EgtGetAxisHomePos( 'Z3')
@@ -1284,8 +1336,6 @@ function OnRapid()
             end
             
             EmitMoveStartHead( 3)
-            -- eventuale preselezione successiva testa 2
-            PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
             -- aspetto esecuzione movimento testa 3
             EmitMoveWaitHead( 3)
          end
@@ -1369,10 +1419,6 @@ function OnRapid()
             EmitMoveStartHead( 1)
             local dX2 = -Head2Y - EMT.L2
             local dZ2 = Delta2TabZ - EMT.DOU_TLEN - ( -DeltaTabZ + EMT.L3 - EMT.TLEN - EMT.SB)
-            -- dato che la testa 2 è slave, bisogna controllare eventuale extra-corsa da post
-            if dZ2 < MinZ2 then
-               EmtSetLastError( 1220, EMT.MCHNAME..'  ==>  Out of Stroke: Z2 : '.. EgtNumToString( MinZ2-dZ2, 2))
-            end
             local dC2 = EMT.R1
             local dB2 = EMT.R2
             EmitMoveDataHead( 2, { X=dX2, Z=-dZ2, B=dB2, C=dC2, TPos=EMT.DOU_TPOS, S=EMT.DOU_SPEED})
@@ -1435,7 +1481,7 @@ function OnRapid()
       local nNextTopHSet = GetNextTopHSet( EMT.MCHID)
       -- ricavo prossimo utensile
       local sNextTool = GetNextTool( EMT.MCHID)
-      local bTopGoHome = ( IsLastPath( EMT.PATHID) and not sNextTool and nHSet == 3) or ( nHSet ~= 2 and nNextTopHSet ~= 0 and nHSet ~= nNextTopHSet) or ( nHSet == 1 and EMT.TTOTLEN > LongTool)
+      local bTopGoHome = ( IsLastPath( EMT.PATHID) and not sNextTool and nHSet == 3)  or EMT.HEAD == 'H38' or ( nHSet ~= 2 and nNextTopHSet ~= 0 and nHSet ~= nNextTopHSet) or ( nHSet == 1 and EMT.TTOTLEN > LongTool)
       EmitZmax( true, true, EMT.R1p, EMT.R2p, bSplitCut, bTopGoHome, false)
       -- aggiorno quota finale trave dopo Zmax
       EMT.L1o = EMT.TPOS
@@ -2043,17 +2089,41 @@ function PrepareUnload( sCmd, nInd)
       -- non interessa
    elseif Cmd[1] == '1' then
       if Cmd[2] == 'Y2' then
-         -- se non è ultima fase e non è fase successiva a scarico su carico c'è una barra sulla pinza Y1
          local bBarOnY = ( EMT.PHASE < EgtGetPhaseCount() and not IsEnd2Phase( EMT.PHASE))
-         local MDChar = { Y2=tonumber(Cmd[3]), V2=ParkV2, IniStatY2=1, FinStatY2=-84, BeamVise=EgtIf( bBarOnY, 1, 0), MovType=EgtIf( EMT.CHY_ON, 3, 2)}
-         table.insert( EMT.MDCHAR, MDChar)
+         -- Se scarico in linea con abbassamento piano ferma pezzo allo scarico
+         if Cmd[4] == 'UnBrakeBeam' then
+            -- Muove carrello aperto e lo chiude
+            local MDChar = { Y2=tonumber(Cmd[3]), V2=ParkV2, IniStatY2=1, FinStatY2=-1, BeamVise=EgtIf( bBarOnY, 1, 0), MovType=EgtIf( EMT.CHY_ON, 3, 2)}
+            table.insert( EMT.MDCHAR, MDChar)
+            -- Abbassa ferma pezzo
+            local MDStopBeam = { StopBeamStat=2}
+            table.insert( EMT.MDCHAR, MDStopBeam)
+         -- Se non è ultima fase e non è fase successiva a scarico su carico c'è una barra sulla pinza Y1
+         else
+            local nFinStatY2 = EgtIf( Cmd[4] == 'NoWaitUnload', -84, -1)
+            local MDChar = { Y2=tonumber(Cmd[3]), V2=ParkV2, IniStatY2=1, FinStatY2=nFinStatY2, BeamVise=EgtIf( bBarOnY, 1, 0), MovType=EgtIf( EMT.CHY_ON, 3, 2)}
+            table.insert( EMT.MDCHAR, MDChar)
+         end
       end
    elseif Cmd[1] == '2' then
       if Cmd[4] == 'Y2' then
-          -- se non è ultima fase c'è una barra sulla pinza Y1
          local bBarOnY = ( EMT.PHASE < EgtGetPhaseCount() and not IsEnd2Phase( EMT.PHASE))
-         local MDChar = { Y2=tonumber(Cmd[5]), IniStatY1=EgtIf( bBarOnY, -1, 1), FinStatY1=EgtIf( bBarOnY, -1, 1), IniStatY2=-1, FinStatY2=1, IniStatV2=1, BeamVise=2, MovType=EgtIf( EMT.CHY_ON, 3, 2)}
-         table.insert( EMT.MDCHAR, MDChar)
+         -- Se scarico in linea con alzata piano ferma pezzo allo scarico
+         if Cmd[6] == 'BrakeBeam' then
+            -- Muove carrello e lo mantiene in presa
+            local MDChar = { Y2=tonumber(Cmd[5]), IniStatY1=EgtIf( bBarOnY, -1, 1), FinStatY1=EgtIf( bBarOnY, -1, 1), IniStatY2=-1, FinStatY2=-1, IniStatV2=1, BeamVise=2, MovType=EgtIf( EMT.CHY_ON, 3, 2)}
+            table.insert( EMT.MDCHAR, MDChar)
+            -- Alza ferma pezzo
+            local MDStopBeam = { StopBeamStat=1}
+            table.insert( EMT.MDCHAR, MDStopBeam)
+            -- Ribadisce le quote del carrello appena mosso e Apre la pinza
+            MDChar = { Y2=tonumber(Cmd[5]), IniStatY1=EgtIf( bBarOnY, -1, 1), FinStatY1=EgtIf( bBarOnY, -1, 1), IniStatY2=-1, FinStatY2=1, IniStatV2=1, BeamVise=2, MovType=EgtIf( EMT.CHY_ON, 3, 2)}
+            table.insert( EMT.MDCHAR, MDChar)
+         -- se non è ultima fase c'è una barra sulla pinza Y1
+         else
+            local MDChar = { Y2=tonumber(Cmd[5]), IniStatY1=EgtIf( bBarOnY, -1, 1), FinStatY1=EgtIf( bBarOnY, -1, 1), IniStatY2=-1, FinStatY2=1, IniStatV2=1, BeamVise=2, MovType=EgtIf( EMT.CHY_ON, 3, 2)}
+            table.insert( EMT.MDCHAR, MDChar)
+         end
       end
    elseif Cmd[1] == '3' then
       -- non interessa
@@ -3005,6 +3075,15 @@ function EmitMoveWaitHead( nHead)
    MyOutput( sOut)
 end
 
+---------------------------------------------------------------------
+-- Emette i movimenti di esecuzione movimenti trave e alzata o discesa del piano ferma pezzo
+function EmitStopBeam( MoData)
+   EmitMoveStartChars(2)
+   EmitMoveWaitChars(2)
+   if MoData.StopBeamStat then sOut = 'M125 P2=' .. EgtNumToString( MoData.StopBeamStat, 0) end
+   MyOutput( sOut)
+end
+
 ---------------------------------------------------------------------
 function EmitMoveDataChars( MoData)
    local sOut = 'M111'

Common_PF1250.mlpe

@@ -79,6 +79,14 @@ function OnSimulStart()
          for j = 1, #( vTools or {}) do
             if vTools[j] ~= '' then
                EgtLoadTool( vTcPos[i], j, vTools[j])
+               -- Aggiunto controllo lunghezza lama minima * 0.9 per ricavare la tolleranza del VMILL
+               if EgtTdbSetCurrTool(vTools[j]) then -- set utensile corrente
+                  if EgtTdbGetCurrToolParam( MCH_TP.TYPE) == MCH_TY.SAW_STD or EgtTdbGetCurrToolParam( MCH_TP.TYPE) == MCH_TY.SAW_FLAT then -- controllo tipo utensile sega
+                     local dCurrSawLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) * 0.9
+                     -- se non definito o minore del valore precedente aggiorna la tolleranza
+                     EMT.VMILLTOL = EgtIf( not EMT.VMILLTOL or dCurrSawLen < EMT.VMILLTOL, dCurrSawLen, EMT.VMILLTOL) 
+                  end
+               end
             end
          end
          ShowToolInTcPos( vTcPos[i], true)
@@ -163,6 +171,29 @@ function OnSimulStart()
    end
    -- Preparo lista collisioni vuota
    EMT.COLLIDE = {}
+
+   -- si crea gruppo temporaneo appoggio controllo clamping
+   CLAMP_CHECK_GROUP = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'CLAMP_CHECK')
+   CLAMP_CHECK_INTERS = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'CLAMP_INTERS')
+
+   if CLAMP_CHECK_GROUP then
+      EgtEmptyGroup( CLAMP_CHECK_GROUP)
+   else
+      local frClampCheckGroup = Frame3d( ORIG(), GDB_FR.FRONT)
+      CLAMP_CHECK_GROUP = EgtGroup( GDB_ID.ROOT, frClampCheckGroup)
+      EgtSetName( CLAMP_CHECK_GROUP, 'CLAMP_CHECK')
+      EgtSetLevel( CLAMP_CHECK_GROUP, GDB_LV.TEMP)
+      EgtSetStatus( CLAMP_CHECK_GROUP, GDB_ST.OFF)
+   end
+   
+   if CLAMP_CHECK_INTERS then
+      EgtEmptyGroup( CLAMP_CHECK_INTERS)
+   else
+      CLAMP_CHECK_INTERS = EgtGroup( GDB_ID.ROOT)
+      EgtSetName( CLAMP_CHECK_INTERS, 'CLAMP_INTERS')
+      EgtSetLevel( CLAMP_CHECK_INTERS, GDB_LV.TEMP)
+      EgtSetStatus( CLAMP_CHECK_INTERS, GDB_ST.OFF)
+   end
 end
 
 ---------------------------------------------------------------------
@@ -226,7 +257,7 @@ function OnSimulDispositionStart()
             -- determino la risoluzione dello Zmap
             local dTol = 4.71
             if EmtGetVMillStep then
-               dTol = EmtGetVMillStep( b3Raw:getDimX(), b3Raw:getDimY(), b3Raw:getDimZ(), 4.71)
+               dTol = EmtGetVMillStep( b3Raw:getDimX(), b3Raw:getDimY(), b3Raw:getDimZ(), dTol)
             else
                local dArea = b3Raw:getDimX() * b3Raw:getDimY() + b3Raw:getDimX() * b3Raw:getDimZ() + b3Raw:getDimY() * b3Raw:getDimZ()
                if dArea < 0.075e6 then
@@ -243,6 +274,7 @@ function OnSimulDispositionStart()
                   dTol = 3.77
                end
             end
+            dTol = min( dTol, EMT.VMILLTOL or dTol) -- imposto dTol al valore minore tra quello per volume e quello per spessore lama
             -- creo lo Zmap
             local VMillId = EgtVolZmapBox( nPartRawId, b3Raw:getMin(), b3Raw:getDimX(), b3Raw:getDimY(), b3Raw:getDimZ(), dTol, true, GDB_RT.GLOB)
             if VMillId then
@@ -1036,7 +1068,15 @@ function OnSimulMoveStart()
                   SimulMoveAxes( 'Z1', MyMaxZ1, MCH_SIM_STEP.RAPID, 'B1', 0, MCH_SIM_STEP.COLLROT)
                   SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
                   SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
-                  SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+                  -- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento
+                  -- evita collisione con carro X
+                  if EMT.R2 > 91 or EMT.R2 < -91 then
+                     local dBref = EgtClamp( EMT.R2, -91, 91)
+                     SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', dBref, MCH_SIM_STEP.COLLROT)
+                     SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+                  else
+                     SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+                  end
                -- caso standard
                else
                   -- se bisogna scrivere tutti gli assi
@@ -1062,14 +1102,24 @@ function OnSimulMoveStart()
             end
          -- altrimenti sega a catena
          else
+            local dSafeZ1 = EgtIf( EMT.TTOTLEN < MinLengthLongCSaw, ParkCSawZ1, ParkLongCSawZ1)
             -- Porto la Z alla giusta quota
-            if Z1Pos > Z1Home + 1 and abs( B1Pos) > 89.9  then
+            if Z1Pos > dSafeZ1 + 1 and abs( B1Pos) > 89.9  then
                SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
-               SimulMoveAxis( 'Z1', Z1Home, MCH_SIM_STEP.RAPID)
+               SimulMoveAxis( 'Z1', dSafeZ1, MCH_SIM_STEP.RAPID)
             end
+               
             -- se movimento iniziale da Zmax
             if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
-               SimulMoveAxes( 'Z1', Z1Home, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+               local dChSawEncumbrance = EMT.L3 + MillOffs - ( ( ChSawLen + MillOffs) * EMT.ADIR[3]) - ( EMT.TTOTLEN * EMT.TDIR[3])
+               local dBeamQuote = DeltaTabZ + EMT.SB + 30
+               if dChSawEncumbrance < dBeamQuote then
+                  SimulMoveAxes( 'Z1', dSafeZ1, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+                  SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
+                  SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID)
+               else
+                  SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+               end
                -- se motosega molto lunga, ruoto prima di muovermi in X
                if EMT.TTOTLEN >= MinLengthLongCSaw then
                   SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
@@ -1197,6 +1247,12 @@ function OnSimulMoveStart()
             EMT.A6n = 'Z2'
             local Z2 = -Head2Z + MillOffs + Mill2Offs + EMT.L3
             EMT.A6 = EgtClamp( Z2, MinZ2, MaxZ2)
+            -- dato che la testa 2 è slave, bisogna controllare eventuale extra-corsa da post
+            if not( EMT.MOVE == 0 and EMT.FLAG == 2) and Z2 > MaxZ2 then
+               local sErr = EMT.MCHNAME..'  ==>  Out of Stroke: Z2 : '.. EgtNumToString( dZ2-MaxZ2, 2)
+               EmtSetLastError( 1220, sErr, true)
+               EgtOutBox( sErr, 'ERROR')
+            end
             EMT.A6m = EgtIf( ( EMT.MOVE == 2 or EMT.MOVE == 3), 'Z1', nil)
             EMT.A7n = 'C2'
             EMT.A7 = EMT.R1
@@ -1227,6 +1283,12 @@ function OnSimulMoveStart()
             EMT.DOU_DRILL_END = EMT.L3p - EMT.L3
             Z2 = Z2 - 2 * EMT.DOU_DRILL_END
          end
+         -- dato che la testa 2 è slave, bisogna controllare eventuale extra-corsa da post
+         if not( EMT.MOVE == 0 and EMT.FLAG == 2) and Z2 < MinZ2 then
+            local sErr = EMT.MCHNAME..'  ==>  Out of Stroke: Z2 : '.. EgtNumToString( MinZ2-Z2, 2)
+            EmtSetLastError( 1220, sErr, true)
+            EgtOutBox( sErr, 'ERROR')
+         end
          EMT.A6 = EgtClamp( Z2, MinZ2, MaxZ2)
          EMT.A6m = nil
          EMT.A7n = 'C2'
@@ -1240,6 +1302,12 @@ function OnSimulMoveStart()
             local sErr = 'Z1 Z2 tools in collision (distance=' .. EgtNumToString( dDistToolZ1Z2, 1) .. ')'
             EmtSetLastError( 1208, sErr)
          end
+         if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
+            local B2Home = EgtGetAxisHomePos( 'B2')
+            local C2Home = EgtGetAxisHomePos( 'C2')
+            SimulMoveAxes( 'X2', SafeX2, MCH_SIM_STEP.RAPID, 'C2', C2Home, MCH_SIM_STEP.RAPROT, 'B2', B2Home, MCH_SIM_STEP.RAPROT)
+            SimulMoveAxis( 'X2', X2, MCH_SIM_STEP.RAPID)
+         end
       end
    end
    -- se necessario ...
@@ -1338,7 +1406,7 @@ function OnSimulMoveEnd()
       -- ricavo prossimo utensile
       local sNextTool = GetNextTool( EMT.MCHID)
       -- vado in home se è ultimo movimento ed è ultima lavorazione
-      local bToXhome = ( IsLastPath( EMT.PATHID) and not sNextTool and nHSet == 3) or ( nHSet == 1 and EMT.TTOTLEN > LongTool)
+      local bToXhome = ( IsLastPath( EMT.PATHID) and not sNextTool and nHSet == 3) or EMT.HEAD == 'H38' or ( nHSet == 1 and EMT.TTOTLEN > LongTool) 
       -- eseguo
       ExecMoveZmax( EMT.MCHSPLIT, bToXhome)
       EMT.TO_ZMAX = nil
@@ -1679,17 +1747,36 @@ function ExecUnloading()
       local vMillId = EMT.VMILL[1]
       -- gruppo dei Vmill
       local nVmGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'VMill')
+      local sUnloadType = ''
+      local sUnloadTypeOld = ''
+      local vtMove = Vector3d( 0, 0, 0)
+      local vtMoveOldElements = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, ( EMT.HB + 50.0), -( EMT.HB + 50.0)), 0)
+      -- Se scarico in linea
+      if MinBeamLenUnloadInLine and EMT.LT >= MinBeamLenUnloadInLine then
+         sUnloadType = 'LINE'
+         vtMove = Vector3d( EgtIf( BD.RIGHT_LOAD, -MinBeamLenUnloadInLine, MinBeamLenUnloadInLine), EgtIf( BD.RIGHT_LOAD, ( EMT.HB + 50.0), -( EMT.HB + 50.0)), 0)
+      else
+         if EMT.FALL then
+            sUnloadType = 'FALL'
+            vtMove = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, 3200, -2600), -1150)
+         else
+            sUnloadType = 'STD'
+            vtMove = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, 1600, -1600), 0)
+         end
+      end
       -- li sposto per lasciare spazio al nuovo pezzo
       local nId = EgtGetFirstInGroup( nVmGrpId)
       while nId do
-         EgtMove( nId, Vector3d( 0, EgtIf( BD.RIGHT_LOAD, ( EMT.HB + 50.0), -( EMT.HB + 50.0)), 0), GDB_RT.GLOB)
+         sUnloadTypeOld = EgtGetInfo( nId, 'UNLOAD_TYPE')
+         if sUnloadTypeOld == sUnloadType then
+            EgtMove( nId, vtMoveOldElements, GDB_RT.GLOB)
+         end
          nId = EgtGetNext( nId)
       end
       -- creo un nuovo layer e vi inserisco il nuovo pezzo
       local nLayId = EgtGroup( nVmGrpId, EgtGetGlobFrame( vMillId))
       EgtRelocate( vMillId, nLayId)
-      local vtMove = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, 1600, -1600), 0)
-      if EMT.FALL then vtMove = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, 3200, -2600), -1150) end
+      EgtSetInfo( nLayId, 'UNLOAD_TYPE', sUnloadType)
       EgtMove( nLayId, vtMove, GDB_RT.GLOB)
       EgtSetLevel( vMillId, GDB_LV.USER)
       -- aggiungo gli spigoli
@@ -1725,16 +1812,163 @@ function ExecUnloading()
    end
 end
 
+---------------------------------------------------------------------
+function CheckClamping( sClampName)
+   nIndexClamp = EgtGetAxisId( sClampName)
+   local idClampPath = EgtGetFirstInGroup( EgtGetFirstNameInGroup( nIndexClamp, 'CLAMP_CHECK') or GDB_ID.NULL)
+   local b3ClampingArea = EgtGetBBoxGlob( idClampPath or GDB_ID.NULL, GDB_BB.STANDARD)
+   -- se non trovo percorso area di clamping, esco subito
+   if not idClampPath or not EMT.VMILL or not ClampingCoeffMin then
+      return
+   end
+
+   local function GetCurveListFromIntersection( sPosIntersPlane, sIntersPlane, dDepth)
+      local idCurveList = {}
+      local vtIntersPlane
+      -- piano di interpolazione 
+      if sIntersPlane == 'X' then
+         vtIntersPlane = X_AX()
+      elseif sIntersPlane == 'Y' then
+         vtIntersPlane = Y_AX()
+      elseif sIntersPlane == 'Z' then
+         vtIntersPlane = Z_AX()
+      end
+
+      for i = 1, #EMT.VMILL do
+         local b3VMill = EgtGetBBoxGlob( EMT.VMILL[i], GDB_BB.EXACT)
+         local ptPosIntersPlane
+         if sPosIntersPlane == 'MIN' then
+            ptPosIntersPlane = b3VMill:getMin() + dDepth * vtIntersPlane
+         elseif sPosIntersPlane == 'MAX' then
+            ptPosIntersPlane = b3VMill:getMax() - dDepth * vtIntersPlane
+         end
+
+         local idLoop, nLoopCnt = EgtPlaneVolZmapInters( ptPosIntersPlane, vtIntersPlane, EMT.VMILL[i], CLAMP_CHECK_INTERS, GDB_RT.GLOB)
+         -- se c'è almeno una curva
+         if idLoop then
+            for j = 1, nLoopCnt do
+               local idLoopTemp = idLoop + j - 1
+               table.insert( idCurveList, idLoopTemp)
+            end
+         end
+      end
+      return idCurveList
+   end
+
+   local function CalculateIntersectionArea( sPosIntersPlane, sIntersPlane, dDepth)
+      -- test piano frontale
+      local idCurveList = GetCurveListFromIntersection( sPosIntersPlane, sIntersPlane, dDepth)
+
+      -- si copia curva intersezione e curva pinza in gruppo di confronto
+      local idFlatSurf, nFlatSurfCnt = EgtSurfFlatRegion( CLAMP_CHECK_GROUP, idCurveList)
+      local idClampSurf = EgtSurfFlatRegion( CLAMP_CHECK_GROUP, idClampPath)
+
+      if idFlatSurf then
+         local dTotalArea = 0
+         local dTotalXLenght = 0
+         for k = 1, nFlatSurfCnt do
+            local idTempSurf = idFlatSurf + k - 1
+            EgtSurfFrIntersect( idTempSurf, idClampSurf)
+            if idTempSurf then
+               dTotalArea = dTotalArea + ceil( EgtSurfArea( idTempSurf) or 0)
+               local b3BoxIntersectionBox = EgtGetBBoxGlob( idTempSurf, GDB_BB.STANDARD)
+               if b3BoxIntersectionBox then
+                  dTotalXLenght = dTotalXLenght + ceil( b3BoxIntersectionBox:getDimX()) -- somma lunghezze (x) delle aree pinzate
+               end
+            end
+         end
+         return dTotalArea, dTotalXLenght
+      end
+      return 0
+   end
+
+   -- minima area considerata per un corretto pinzaggio
+   DistZClampToTable = DistZClampToTable or 0
+   local MinJoin = BD.GetMinJoin( EMT.HB, EMT.SB, EgtIf( EMT.SPLIT, EMT.LT, EMT.LB))
+   local MinZClamping =  min( b3ClampingArea:getDimZ() + DistZClampToTable, EMT.SB) - DistZClampToTable
+   -- si moltiplica per un coefficiente minimo sotto al quale si da l'errore di pinzaggio
+   ClampingCoeffMin = EgtClamp( ClampingCoeffMin, 0.01, 1)
+   local dMinClampingAreaWarn = ( MinJoin * MinZClamping) * ClampingCoeffMin
+   local dMinClampingAreaErr = ( MinJoin * MinZClamping) * ( ClampingCoeffMin / 3)
+
+   local bError = true
+   local sWrn, sErr
+   local bWriteWarnMessage = false
+   local bWriteErrMessage = false
+   -- controllo faccia frontale
+   local dArea, dXClampedLenght = CalculateIntersectionArea( 'MIN', 'Y', 3)
+   -- ERRORE: pinza troppo poco (meno di 1/3 del minimo richiesto)
+   if dArea and dArea < dMinClampingAreaErr then
+      -- solo se pinza almeno 1cm2, e la somma della lunghezza pinzata è maggiore della lunghezza minima pinzabile da Warning e non errore
+      if dXClampedLenght >= MinJoin * ClampingCoeffMin and dArea > 1000 then 
+         bError = false
+      end
+      -- pinzaggio non fattibile, errore
+      if bError then
+         sErr = 'ERROR CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
+         bWriteErrMessage = true
+      end
+   end
+   -- WARNING: pinza meno del minimo richiesto
+   if dArea and dArea < dMinClampingAreaWarn and not bWriteErrMessage then
+      sWrn = 'WARNING CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
+      bWriteWarnMessage = true
+   end
+   EgtEmptyGroup( CLAMP_CHECK_GROUP)
+   EgtEmptyGroup( CLAMP_CHECK_INTERS)
+
+   -- controllo altro lato solo se non sono già in errore
+   if not bWriteErrMessage then
+      -- controllo faccia posteriore
+      dArea = CalculateIntersectionArea( 'MAX', 'Y', 3)
+      -- ERRORE: pinza troppo poco (meno di 1/3 del minimo richiesto)
+      if dArea and dArea < dMinClampingAreaErr then   
+         -- solo se pinza almeno 1cm2, e la somma della lunghezza pinzata è maggiore della lunghezza minima pinzabile da Warning e non errore
+         if dXClampedLenght >= MinJoin * ClampingCoeffMin and dArea > 1000 then 
+         bError = false
+      end
+         -- pinzaggio non fattibile, errore
+         if bError then
+            sErr = 'ERROR CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
+            bWriteErrMessage = true
+         end
+      end
+      -- WARNING: pinza meno del minimo richiesto
+      if dArea and dArea < dMinClampingAreaWarn and not bWriteWarnMessage and not bWriteErrMessage then
+         sWrn = 'WARNING CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
+         bWriteWarnMessage = true
+      end
+      EgtEmptyGroup( CLAMP_CHECK_GROUP)
+      EgtEmptyGroup( CLAMP_CHECK_INTERS)
+   end
+
+   if bWriteErrMessage then
+      EmtSetLastError( 1213, sErr, EgtGetEnableUI())
+      EgtOutBox( sErr, 'CLAMPING', 'ERROR', 'OK')
+      EmtSetSimulPause()
+   elseif bWriteWarnMessage then
+      EgtOutLog( sWrn)
+      EgtOutBox( sWrn, 'CLAMPING', 'WARNING', 'OK')
+      EmtSetSimulPause()
+   end
+end
+
 ---------------------------------------------------------------------
 function ExecMovePY1( bClose)
    SimulMoveAxes( 'PY1', EgtIf( not bClose, MaxHoOpen, EMT.HB), MCH_SIM_STEP.RAPID)
    SetPY1Light( bClose)
+   if bClose then
+      CheckClamping( 'PY1')
+   end
 end
 
 ---------------------------------------------------------------------
 function ExecMovePY2( bClose)
    SimulMoveAxes( 'PY2', EgtIf( not bClose, MaxHoOpen, EMT.HB), MCH_SIM_STEP.RAPID)
    SetPY2Light( bClose)
+   if bClose then
+      CheckClamping( 'PY2')
+   end
 end
 
 ---------------------------------------------------------------------
@@ -2755,9 +2989,9 @@ end
 ---------------------------------------------------------------------
 function RollerParkingNeeded( sHead, dAng1p, dAng2p, dAng1, dAng2)
    if sHead == 'H11' or sHead == 'H12' or sHead == 'H13' or sHead == 'H16' then
-      return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1 % 180.0) > 1))
+      return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1) % 180.0 > 1))
    elseif sHead == 'H21' or sHead == 'H22' then
-      return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1 % 180.0) > 1))
+      return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1) % 180.0 > 1))
    elseif sHead == 'H38' then
       return ( abs( dAng1 - dAng1p) > 1 or  abs( dAng2 - dAng2p) > 1)
    end

Common_PF1250.mlse

@@ -17,6 +17,33 @@ require( 'EmtGenMachining')
 ---------------------------------------------------------------------
 -----------------------------------------------------------------------------------------
 function OnSpecialGetPrevMachiningOffset()
+   -- Aggiorno posizione della testa della trave a seguito di movimenti delle pinze non previsti tra le fasi
+   local function TPosUpdate()
+      local nClId = EgtGetFirstNameInGroup( EMC.CURRMCHID, 'CL') -- recupero Id del gruppo CL della lavorazione corrente
+      local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1)
+      if not nPathId then
+         EMC.ERR = 12
+         EMC.MSG = '  Error : CL group path not found'
+         return
+      end
+      local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari 
+      local dTRepos = nil
+      -- controlla ogni gruppo di movimenti ausiliari
+      for i = 1, dAuxMoveCount do
+         local aAuxMove = EgtGetInfo( nPathId, 'AS' .. tostring( i), 'vs') or {} -- array contenete i parametri di ogni gruppo
+         -- controlla solo i movimenti della testa trave e salva l'ultimo
+         if aAuxMove[1] == '2' or aAuxMove[1] == '3' then
+            for j = 2, #aAuxMove do
+               if aAuxMove[j] == 'T' then
+                  dTRepos = aAuxMove[j+1]
+                  break
+               end
+            end
+         end
+      end
+      return dTRepos
+   end
+
    -- default
    EMC.ERR = 0
    EMC.PREVOFFSX = 0
@@ -26,8 +53,15 @@ function OnSpecialGetPrevMachiningOffset()
       if IsStartOrRestPhase( EMC.CURRPHASE) then
          -- recupero la posizione finale della lavorazione precedente
          local vPrevAx = EmtGetFinalAxesPos( EMC.PREVMCHID)
-         -- la X (L1) di questa corrisponde alla posizione iniziale della nuova trave, se ne deduce l'offset
-         EMC.PREVOFFSX = ParkV1 - vPrevAx[1]
+         -- ricava se e quanto la trave viene spostata tra le due fasi dai movimenti ausiliari e corregge l'offset di fine fase
+         local dNewTPos = TPosUpdate()
+         -- se ci sono dei movimenti della testa trave tra le due fasi ricava il delta tra la vecchia e la nuova posizione
+         if dNewTPos then
+            EMC.PREVOFFSX = dNewTPos - vPrevAx[1]
+         -- oppure la X (L1) di questa corrisponde alla posizione iniziale della nuova trave, se ne deduce l'offset
+         else
+            EMC.PREVOFFSX = ParkV1 - vPrevAx[1]
+         end
       end
    end
 end
@@ -113,7 +147,7 @@ function OnSpecialGetMaxZ()
          local vMZ = {{ Tz=0.85, Ez=440}, { Tz=0.5, Ez=200}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
          EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
       else
-         local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=70}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
+         local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=60}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
          EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
       end
    elseif EMC.HEAD == 'H16' then
@@ -133,7 +167,7 @@ function OnSpecialGetMaxZ()
          local vMZ = {{ Tz=0.85, Ez=440}, { Tz=0.5, Ez=200}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
          EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
       else
-         local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=70}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
+         local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=60}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
          EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
       end
    elseif EMC.HEAD == 'H21' then
@@ -242,6 +276,7 @@ local DIST_Y1MAX_LOAD = 100        -- distanza carrello Y1 da massimo asse al ca
 ----------------------- Variabili -----------------------------------
 local Test = false
 local SPLIT
+UnloadOnLoadPos = EgtGetInfo( EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo'), 'UNLOAD', 'b') == 1 -- se il pezzo dev'essere scaricato al carico
 
 ---------------------------------------------------------------------
 local function PrepareClGroup( nParentId)
@@ -533,6 +568,10 @@ function OnSpecialApplyDisposition()
    end
    -- eseguo scarico
    SpecSetCarrPosFromCmds( vCmd2)
+   -- determino posizione testa trave
+   local nLastEntId = EgtGetLastInGroup( EgtGetLastInGroup( EgtGetFirstNameInGroup( EgtGetPrev( EMC.DISPID), 'CL')))
+   local vAxes = EmtGetAxesPos( nLastEntId)
+   if #vAxes > 0 then EMC.TPOS = vAxes[1] end
    local vCmd3 = SpecCalcUnload()
    -- unisco ed emetto i comandi
    vCmd = EgtJoinTables( vCmd, vCmd2)
@@ -698,7 +737,7 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload)
 
    -- Verifico se lavorazione pareti
    local bWall = ( EgtGetInfo( EgtGetCurrMachGroup() or GDB_ID.NULL, 'Wall', 'd') == 1)
-   
+
    -- mi salvo info lavorazione su una lista
    local AuxInfoMach = {}
    AuxInfoMach.bPreSplit = bPreSplit
@@ -706,7 +745,7 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload)
    AuxInfoMach.bPreCut = bPreCut
    AuxInfoMach.bCutting = bCutting
    AuxInfoMach.bUnload = bUnload
-   
+
    -- Assegno flag di pezzo separato dal resto del grezzo
    SPLIT = IsEndPhase( EMC.PHASE)
 
@@ -714,6 +753,8 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload)
    local b3Tot = BBox3d()
    local b3Raw = BBox3d()
    local nNextOddPhase = GetNextStartOrRestPhase( EMC.PHASE)
+   -- se esistono più grezzi toglie l'impostazione di scarico al carico
+   if UnloadOnLoadPos and ( nNextOddPhase and nNextOddPhase <= EgtGetPhaseCount()) then UnloadOnLoadPos = false end
    local nRawId = EgtGetFirstRawPart()
    local nCurrRawId = GDB_ID.NULL
    while nRawId do
@@ -764,6 +805,10 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload)
    elseif bPreCut  or  bCutting then
       local dDistF, dDistB, dRollF, dRollB = SpecialCalcPhaseEncumbrance( EMC.PHASE + 1)
       dDistFront = min( dDistFront, dDistF)
+      -- Se è previsto lo scarico al carico aumenta l'ingombro dell'area di lavoro
+      if UnloadOnLoadPos then
+         dDistFront = dDistFront -( MinDeltaYV*2 + AGG_V)
+      end
       dDistBack = min( dDistBack, dDistB)
    end
 
@@ -862,11 +907,10 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload)
          EgtSetInfo( NextDispId, 'V1POS', EMC.V1POS)
          EgtSetInfo( NextDispId, 'V2POS', EMC.V2POS)
       end
-   end   
+   end
 
    -- Se previsto scarico, lo eseguo
    if bUnload then
-      EMC.LB = b3Raw:getDimX()
       local vCmdTmp = SpecCalcUnload()
       vCmd = EgtJoinTables( vCmd, vCmdTmp)
    end
@@ -1134,7 +1178,7 @@ function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1Del
       -- dopo che si è calcolato il minimo e massimo dell'intervallo, verifico che in testa rimanga almeno il minimo per poter fare passaggio pinze e scaricare
       if AuxInfoMach and ( AuxInfoMach.bSplitting or AuxInfoMach.bCutting) then
          if WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 1.5 * BD.CHAR_EXTRA_DIST and WorkTab.dY1DeltaMaxF > EMC.LT + BD.MINRAW_S + BD.CHAR_EXTRA_DIST then
-            WorkTab.dY1DeltaMinF = max( min( EMC.LT + BD.MINRAW_S, WorkTab.dY1DeltaMaxF - 1), WorkTab.dY1DeltaMinF)
+            WorkTab.dY1DeltaMinF = max( min( EMC.LT + BD.MINRAW_S, WorkTab.dY1DeltaMaxF - 1), WorkTab.dY1DeltaMinF + EMC.LT)
          end
       end
 
@@ -1292,8 +1336,66 @@ function SpecCalcSplit( dLenRaw, dMaxLenLeft)
    return vCmd
 end
 
+---------------------------------------------------------------------
+-- Scarica il pezzo in zona di carico
+function SpecCalcUnloadOnLoadPos()
+   local vCmdPre = {}
+   EgtOutLog( ' *[UL]', 1)
+   -- Se pinza Y2 chiusa, devo effettuare uno scambio
+   local dY1DeltaMaxSP = MaxY1 - LoadT - TurnerOffs - 10 * GEO.EPS_SMALL
+   if EMC.Y2DELTA or EMC.Y1DELTA > dY1DeltaMaxSP then
+      -- imposto quote aggancio per avere solo pinza Y
+      local dDistFront = 0
+      local dDistBack = EMC.LB - MinOther - EMC.HOVM + 10 * GEO.EPS_SMALL
+      -- effettuo scambio
+      vCmdPre = SpecCalcCarriages( dDistFront, dDistBack, 0, 0, dY1DeltaMaxSP)
+      -- recupero nuova posizione carrelli
+      SpecSetCarrPosFromCmds( vCmdPre)
+      EgtOutLog( '  [UL1]', 1)
+   end
+   -- porto il pezzo alla zona di rotazione con il carro Y1
+   local vCmd = {}
+   -- Commento
+   table.insert( vCmd, { 0, 'Unload-On-Load'})
+   -- posizionamento sicuro teste e rulli
+   if #vCmdPre > 0 then
+      EnsureZmax( true, vCmdPre, 2)
+   else
+      EnsureZmax( true, vCmd)
+   end
+   -- Se pinza V chiusa, la apro
+   if EMC.Y2DELTA then
+      table.insert( vCmd, { 12, 0})
+   end
+   -- riporto la trave al carico
+   local dRotT = LoadT + TurnerOffs
+   table.insert( vCmd, { 2, 'Y1', dRotT + EMC.Y1DELTA, 'T', dRotT})
+   -- apro la morsa
+   table.insert( vCmd, { 11, 0})
+   EMC.CNT = nil
+   -- riporto il carrello in home
+   table.insert( vCmd, { 1, 'Y1', ParkY1})
+
+   -- eventuale unione tabelle
+   if #vCmdPre > 0 then
+      vCmd = EgtJoinTables( vCmdPre, vCmd)
+   end
+
+   return vCmd
+end
+
 ---------------------------------------------------------------------
 function SpecCalcUnload()
+   -- In caso di condizioni rispettate richiama lo scarico al carico e ritorna
+   local nNextPathId
+   local nNextMchId
+   if EMC.PATHID then nNextPathId = EgtGetNextActiveOperation( EMC.PATHID) end
+   if EMC.MCHID then nNextMchId = EgtGetNextActiveOperation( EMC.MCHID) end
+   -- Opzione attiva, è l'ultimo path, è l'ultima lavorazione e non c'è rimanenza
+   if UnloadOnLoadPos and not nNextPathId and not nNextMchId and not IsStartOrRestPhase(EMC.PHASE) then
+      local vCmd = SpecCalcUnloadOnLoadPos()
+      return vCmd
+   end
    local vCmdPre = {}
    EgtOutLog( '  *[U]', 1)
    if not EMC.Y1DELTA and not EMC.Y2DELTA then
@@ -1342,15 +1444,37 @@ function SpecCalcUnload()
    if bStdUl then
       local dFinT = EgtIf( EMC.LB < MaxLenSmT, UnloadSmT, UnloadT) - EMC.LB
       local dFinY2 = dFinT + EMC.Y2DELTA
-      table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2})
+      local dBeamTailY2 = dFinY2 + ( EMC.LB - EMC.Y2DELTA) - ( EMC.TCING or 0)
+      -- Se scarico in linea scrivo una nota in più per l'attivazione del piano ferma pezzo (M125)
+      if MinBeamLenUnloadInLine and EMC.LB >= MinBeamLenUnloadInLine then
+         table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2, 'BrakeBeam'})
+      else
+         table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2})
+      end
       EgtOutLog( '  Y2PosF=' .. EgtNumToString( dFinY2), 1)
+      -- Se scarico in "linea"
+      if MinBeamLenUnloadInLine and EMC.LB >= MinBeamLenUnloadInLine then
+         -- apro la morsa
+         table.insert( vCmd, { 12, 0})
+         local dY2MoveMax = MinY2
+         if dBeamTailY2 >= ( dY2MoveMax + ( EMC.TCING or 0)) then
+            local dTMove = dY2MoveMax - EMC.LB + ( EMC.TCING or 0)
+            -- riporto il carrello in fondo alla trave
+            table.insert( vCmd, { 1, 'Y2', dBeamTailY2, 'UnBrakeBeam'})
+            -- chiudo la morsa
+            table.insert( vCmd, { 12, 1})
+            -- finisco scarico trave
+            table.insert( vCmd, { 2, 'T', dTMove, 'Y2', dY2MoveMax})
+            EgtOutLog( '  Y2PosF=' .. EgtNumToString( dY2MoveMax), 1)
+         end
+      end
    else
       table.insert( vCmd, { 1, 'Y2', MaxY2})
    end
    -- apro la morsa
    table.insert( vCmd, { 12, 0})
    -- riporto il carrello in home
-   table.insert( vCmd, { 1, 'Y2', ParkY2})
+   table.insert( vCmd, { 1, 'Y2', ParkY2, 'NoWaitUnload'})
 
    -- eventuale unione tabelle
    if #vCmdPre > 0 then
@@ -1577,7 +1701,7 @@ local function MaxDispl( TabI, vCmd, sType)
      -- allontano (Y1+T) e (Y2)
       dY1a = MaxY1
       dY2a = MinY2
-      dTa = ( dY1a - TabI.dY1PosI) + dTa 
+      dTa = ( dY1a - TabI.dY1PosI) + dTa
    -- **[M2]** = allontanamento dei trascinatori con Y2 in presa
    elseif sType == 'M2'   then
       EmitComment( vCmd, '[M2]')
@@ -1588,7 +1712,7 @@ local function MaxDispl( TabI, vCmd, sType)
       -- allontano (Y2+T) e (Y1)
       dY1a = MaxY1
       dY2a = MinY2
-      dTa = ( dY2a - TabI.dY2PosI) + dTa 
+      dTa = ( dY2a - TabI.dY2PosI) + dTa
    -- **[M3]** = accentramento dei trascinatori con Y1 in presa
    elseif sType == 'M3' then
       EmitComment( vCmd, '[M3]')
@@ -1598,7 +1722,7 @@ local function MaxDispl( TabI, vCmd, sType)
       -- accentro (Y1+T) e (Y2)
       dY1a = TabI.MyMinY1V1
       dY2a = TabI.MaxY2V2
-      dTa = ( dY1a - TabI.dY1PosI) + dTa 
+      dTa = ( dY1a - TabI.dY1PosI) + dTa
    -- **[M4]** = accentramento dei trascinatori con Y2 in presa
    elseif sType == 'M4' then
       EmitComment( vCmd, '[M4]')
@@ -1609,7 +1733,7 @@ local function MaxDispl( TabI, vCmd, sType)
       -- accentro (Y2+T) e (Y1)
       dY1a = TabI.MyMinY1V1
       dY2a = TabI.MaxY2V2
-      dTa = ( dY2a - TabI.dY2PosI) + dTa 
+      dTa = ( dY2a - TabI.dY2PosI) + dTa
    end
    --
    table.insert( vCmd, { 3, 'Y1', dY1a,  'Y2', dY2a, 'T', dTa, EMC.CNT})
@@ -1897,7 +2021,7 @@ local function PosY1Y2B( TabI, vCmd)
                PosY2FromY1B( TabI, vCmd)
             end
          end
-         bXW = false      
+         bXW = false
       -- se posso posizionare 'direttamente' Y2 all'interno dell'intervallo I2 (casi [rp] o [ri])
       else
          -- |POSIZIONO MORSA 2| e poi MORSA 1
@@ -1908,7 +2032,7 @@ local function PosY1Y2B( TabI, vCmd)
                TabI.dY1PosI < TabI.dTPosI + EMC.LB - MinJoin - EgtIf( SPLIT, EMC.TCING, 0) + 10 * GEO.EPS_SMALL then
                PosY2FromY1A( TabI, vCmd)
                PosY1FromY2B( TabI, vCmd)
-               bXW = false   
+               bXW = false
             end
          -- in **accentramento** 
          else
@@ -1917,9 +2041,9 @@ local function PosY1Y2B( TabI, vCmd)
                TabI.dY1PosI <= TabI.dTPosI + EMC.LB - MinJoin - EgtIf( SPLIT, EMC.TCING, 0) + 10 * GEO.EPS_SMALL then
                PosY2FromY1B( TabI, vCmd)
                PosY1FromY2B( TabI, vCmd)
-               bXW = false   
-            end   
-         end 
+               bXW = false
+            end
+         end
       end
       if bXW then
          -- Massimo trascinamento della trave in direzione positiva (casi  **[xw]** )
@@ -1929,10 +2053,10 @@ local function PosY1Y2B( TabI, vCmd)
             TabI.dY1PosI < TabI.dTPosI + EMC.LB - MinJoin - EgtIf( SPLIT, EMC.TCING, 0) + 10 * GEO.EPS_SMALL then
          -- allontanamento morse, trascinamento trave con Y1
             MaxDispl( TabI, vCmd, 'M1')
-         else 
+         else
          -- accentramento morse, trascinamento trave con Y2
             MaxDispl( TabI, vCmd, 'M4')
-         end 
+         end
       end
       nCnt = nCnt + 1
       if nCnt > 10 then return end
@@ -2475,11 +2599,11 @@ function SpecOutputCmds( vCmd, bEnd)
          EgtSetInfo( EMC.PATHID, sKey, sInfo)
       -- movimento di 1 asse
       elseif Cmd[1] == 1 then
-         local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..EgtIf( Cmd[4], ',*', '')
+         local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..EgtIf( Cmd[4], ','..tostring(Cmd[4]), '')
          EgtSetInfo( EMC.PATHID, sKey, sInfo)
       -- movimento di 2 assi
       elseif Cmd[1] == 2 then
-         local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..EgtIf( Cmd[6], ',*', '')
+         local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..EgtIf( Cmd[6], ','..tostring(Cmd[6]), '')
          EgtSetInfo( EMC.PATHID, sKey, sInfo)
       -- movimento di 3 assi
       elseif Cmd[1] == 3 then

Essetre-PF1250-3T_5Ax.mlde

@@ -5,10 +5,10 @@
 require( 'EmtGenerator')
 EgtEnableDebug( false)
 
-PP_VER = '2.7k1_DEV4'
-PP_NVER = '2.7.11.1'
+PP_VER = '3.1a2_DEV5'
+PP_NVER = '3.1.1.2'
 MIN_MACH_VER = '2.7d2'
-MACH_NAME = string.match( EgtGetCurrMachineDir(), "[^\\]+$")  -- si ricava il nome della macchina dal direttorio
+MACH_NAME = EgtGetCurrMachineName()
 
 -- Carico i dati globali
 local sMachDir = EgtGetCurrMachineDir()
@@ -68,7 +68,7 @@ ChSawLen = 91.0
 Mill2Offs = 170.0
 SawC2Offs = 0
 SawB2Offs = 0
-Mill3Offs = 163.0
+Mill3Offs = 219 -- 163.0
 MinX1 = 0
 MaxX1 = 3300
 MinZ1 = -1550
@@ -170,6 +170,10 @@ WriteAllCoordsOnFirstM101 = true
 ForceToCloseRollersGate = false
 Motors23KW = true
 EstimationRapidMultiplier = 1
+DistZClampToTable = 5                             -- distanza tra la tavola e il punto più basso della morsa
+ClampingCoeffMin = nil                             -- coefficiente di fissaggio, se 0 o nil non fa controllo, per il momento da inizializzare da Ts3Data
+MinBeamLenUnloadInLine = 2400             -- se lo scarico è su una linea deve scaricare il pezzo al massimo e deve essere maggiore del valore della variabile
+UnloadOnLoadPos = nil
 
 -- Aggiornamento con dati da TechnoEssetre7
 local sTs3Data = EgtGetStringFromIni( 'Beam', 'DATA_DIR', "C:\\TechnoEssetre7\\EgtData", EgtGetIniFile()).."\\Essetre-PF1250-3T_5Ax.data"
@@ -267,6 +271,8 @@ if EgtExistsFile( sDataBeam) then
          if Machine.Offsets.WOOD_DENSITY then WoodDensity = Machine.Offsets.WOOD_DENSITY end
          if Machine.Offsets.MOTORS23KW then Motors23KW = Machine.Offsets.MOTORS23KW == 1 end
          if Machine.Offsets.LEN_STEM_H2 then LenStemH2 = Machine.Offsets.LEN_STEM_H2 end
+         if Machine.Offsets.COEFF_CLAMP_CHECK then ClampingCoeffMin = Machine.Offsets.COEFF_CLAMP_CHECK end
+         if Machine.Offsets.MIN_BEAM_LEN_UNLOAD_IN_LINE then MinBeamLenUnloadInLine = Machine.Offsets.MIN_BEAM_LEN_UNLOAD_IN_LINE end
 
          -- aggiustamenti
          MinY1 = MinV1 + MinDeltaYV
@@ -486,7 +492,7 @@ local B3Id = EmtAxis {
       Aux = {'B3_AXIS/SOLID', 'B3_AXIS/COLLISION'}}
 local vtMoveX3 = Vector3d( 0, Head3Y, 0)
 EgtMove( EgtGetFirstNameInGroup( X3Id, 'SOLID'), vtMoveX3, GDB_RT.GLOB)
-local vtMoveZ3 = Vector3d( Head3X, Head3Y, Head3Z + 54)
+local vtMoveZ3 = Vector3d( Head3X, Head3Y, Head3Z + 110)    -- 110 : distanza tra naso mandrino testa 1 e naso mandrino testa 3
 EgtMove( EgtGetFirstNameInGroup( Z3Id, 'SOLID'), vtMoveZ3, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( Z3Id, 'COLLISION'), vtMoveZ3, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( C3Id, 'SOLID'), vtMoveZ3, GDB_RT.GLOB)
@@ -604,7 +610,7 @@ local PY1Id = EmtAxis {
       Stroke = {0, MaxHoOpen},
       Home = MaxHoOpen,
       Geo = 'PY1_AXIS/GEO',
-      Aux = 'PY1_AXIS/SOLID'}
+      Aux = {'PY1_AXIS/SOLID', 'PY1_AXIS/CLAMP_CHECK'}}
 local Y2Id = EmtAxis {
       Name = 'Y2',
       Parent = 'Base',
@@ -624,7 +630,7 @@ local PY2Id = EmtAxis {
       Stroke = {0, MaxHoOpen},
       Home = MaxHoOpen,
       Geo = 'PY2_AXIS/GEO',
-      Aux = 'PY2_AXIS/SOLID'}
+      Aux = {'PY2_AXIS/SOLID', 'PY2_AXIS/CLAMP_CHECK'}}
 -- Rulli
 local V1Id = EmtAxis {
       Name = 'V1',
@@ -922,8 +928,10 @@ local vtMove = Vector3d( 0, ( DeltaTabY - 3050.0), ( DeltaTabZ + 1124.0))
 EgtMove( EgtGetFirstNameInGroup( BaseId, 'CONVOYER'..sGeomConvoyer), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( Y1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( PY1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
+EgtMove( EgtGetFirstNameInGroup( PY1Id, 'CLAMP_CHECK'), vtMove + Vector3d(0,0,DistZClampToTable), GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( Y2Id, 'SOLID'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( PY2Id, 'SOLID'), vtMove, GDB_RT.GLOB)
+EgtMove( EgtGetFirstNameInGroup( PY2Id, 'CLAMP_CHECK'), vtMove + Vector3d(0,0,DistZClampToTable), GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( V1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( V1Id, 'COLLISION'), vtMove, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( PV1Id, 'SOLID'), vtMove, GDB_RT.GLOB)

UpdateLog.txt

@@ -1,5 +1,37 @@
            ==== Common_PF1250 Update Log ====
 
+Versione 3.1a2 (30/01/2026)
+- (SIM) Allineato approccio simulazione a generazione in caso di lavorazione in doppio verticale. Ticket#2781
+- (GEN) Simulazione non allineata a generazione. Mancava reset flag di pezzo a caduta. Ticket#2798
+
+Versione 3.1a1 (16/01/2026)
+- (SIM-GEN) Corretto movimento di approccio con sega a catena e allineati Simulazione e Generazione. Ticket#2771
+
+Versione 2.7l1 (18/12/2025)
+- (SIM-GEN) Aggiunto controllo post movimenti ausiliari dell' EMC.PREVOFFSX nella funzione OnSpecialGetPrevMachiningOffset() come su ONE-PF. Ticket#2727
+- (SIM-GEN) Cambiato delta di correzione Z per lama con inclinazione >= 81° da 70 a 60 mm. Risoluzione Ticket#2210
+- (SIM-GEN) Divisione movimento B in approccio se > 90°.
+
+Versione 2.7k5 (26/11/2025)
+- (SIM) Migliorata funzione CheckClamping, ora il controllo di warning si basa sulla somma delle lunghezze delle aree pinzate
+
+Versione 2.7k4 (25/11/2025)
+- (SIM) Migliorata funzione CheckClamping, ora la sezione rientra di 3 mm
+
+Versione 2.7k3 (21/11/2025)
+- (SIM-GEN) Corretto problema riposizionamento carrelli. Ticket#2704
+- (SIM) Aggiornata risoluzione VMillTol in funzione dello spessore lama
+
+Versione 2.7k2 (19/11/2025)
+- (SIM-GEN) Con testa H38 si va in home quando testa viene comandata a Zmassima. Ticket#2703_b
+
+Versione 2.7k1 (19/11/2025)
+- (GEN) Preselzione testa 1 spostata prima della selezione testa 3. Ticket#2513
+- (SIM-GEN) Corretto calcolo per decidere se serve aprire i rulli
+- (SIM) Aggiunto controllo Extra-Corsa testa 2 in caso di lavorazione in doppio. Ticket#2201
+- (SIM) Prima versione controllo pinzaggio su VMILL. Per attivarlo serve modifica della macchina a MLDE e NGE.
+- (GEN) Simulazione non allineata a generazione. Se testa H38 e si chiudono i rulli, si deve andare in home. Ticket#2703
+
 Versione 2.7i1 (08/09/2025)
 - (GEN) Se fase start o restart, si aggiorna la posizione in X dell'asse per calcolare il link corretto. Serve CAM5 2.7h1 (facoltativo)
 - (EST) La stima tempi considera ora le accelerazoni degli assi

Version.lua

@@ -3,8 +3,8 @@
 
 local InfoCommon_STD_PP = {
    NAME = 'Common_PF1250',            -- nome script PP standard
-   VERSION = '2.7i1',                 -- versione script
-   MIN_MACH_VER_PP_COMMON = '2.5k1'   -- versione minima kernel
+   VERSION = '3.1a2',                 -- versione script
+   MIN_MACH_VER_PP_COMMON = '2.7k1'   -- versione minima kernel
 }
 
 return InfoCommon_STD_PP