Allineamento con common ver. 2.7i1

- Dimensione tavola portata a 34m
- Aggiunto lettura coefficiente stima tempi

Beam/BeamData.lua

@@ -12,7 +12,8 @@ local BeamData = {
    MAX_WIDTH = 1250,                        -- larghezza massima del grezzo
    MAX_HEIGHT = 400,                        -- altezza massima del grezzo
    LEN_SHORT_PART = 1200,                   -- lunghezza massima pezzo piccolo
-   MAX_RAW = 20000,                         -- massima lunghezza grezzo (deve essere minore di LenTable - RAW_OFFSET)
+   LEN_VERY_SHORT_PART = 800,               -- lunghezza massima pezzo molto corto (molto probabile lo scarico a caduta)
+   MAX_RAW = 26000,                         -- massima lunghezza grezzo (deve essere minore di LenTable - RAW_OFFSET)
    STD_RAW = 14000,                         -- lunghezza standard della barra di grezzo
    OVM_HEAD = 10,                           -- sovramateriale testa
    OVM_MID = 5.4,                           -- sovramateriale intermedio (spessore lama)
@@ -101,8 +102,17 @@ if EgtExistsFile( sDataBeam) then
          BeamData.DIM_STRIP_SMALL = Machine.Offsets.DIM_STRIP_SMALL or BeamData.DIM_STRIP_SMALL
          BeamData.DIM_TO_CENTER_STRIP = Machine.Offsets.DIM_TO_CENTER_STRIP or BeamData.DIM_TO_CENTER_STRIP
          BeamData.MAXDIAM_POCK_CORNER = Machine.Offsets.MAXDIAM_POCK_CORNER or BeamData.MAXDIAM_POCK_CORNER
+         BeamData.LONGCUT_ENDLEN = Machine.Offsets.LONGCUT_ENDLEN or BeamData.LONGCUT_ENDLEN
+         BeamData.LONGCUT_MAXLEN = Machine.Offsets.LONGCUT_MAXLEN or BeamData.LONGCUT_MAXLEN
+         BeamData.ADVANCE_TAIL_OFFS = Machine.Offsets.ADVANCE_TAIL_OFFS or BeamData.ADVANCE_TAIL_OFFS
+         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
          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
       end
       if Machine.Trave then
          BeamData.MIN_WIDTH = Machine.Trave.XMIN or BeamData.MIN_WIDTH

Beam/MachiningTypes.ini

@@ -49,6 +49,7 @@
 33=AntiSplintMillCut_H2
 34=SideMillAsBlade
 35=SideMillAsBlade_H2
+36=Prof_end
 
 [Pocketing]
 1=Pocket

Common_PF1250.TPA.mlpe

@@ -28,7 +28,9 @@ function OnStart()
    --EMT.LINEINC = 1        -- incremento numerazione linee
    --EMT.Ft = 'F'           -- token per feed
    --EMT.St = 'S'           -- token per speed
-   EMT.FMAXPINZE = EgtClamp( MaxFeedPinze or 116000, 20000, 116000)  -- feed massima pinze
+   EMT.FMAXPINZE = EgtClamp( MaxFeedPinze or 116000, 20000, 130000)  -- feed massima pinze
+   EMT.MAXACC = MaxAcc or 6000    -- accelerazione massima pinze. In realtà è il tempo in millisecondi, quindi MAXACC corrisponde al tempo massimo per raggiungere la velocità desiderata
+   EMT.MINACC = MinAcc or 600     -- accelerazione minima pinze. In realtà è il tempo in millisecondi, quindi MINACC corrisponde al tempo massimo per raggiungere la velocità desiderata
    SetToParkLine()        -- si inizia con linee da parcheggiare su stack
 end
 
@@ -292,6 +294,8 @@ function OnDispositionEnd()
       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
       end
       if #EMT.MDCHAR > 0 then
          local nMoveType = EgtIf( EMT.CHY_ON, 3, 2)
@@ -582,8 +586,8 @@ function OnPathStart()
    if EMT.TOOL == EMT.PREVTOOL and not EMT.ZMAX then
       EMT.L2pp = EMT.L2op
       EMT.L3pp = EMT.L3op
-      EMT.R1pp = EMT.R1p
-      EMT.R2pp = EMT.R2p
+      EMT.R1pp = EMT.R1p or EMT.R1pp
+      EMT.R2pp = EMT.R2p or EMT.R2pp
    else
       EMT.L2pp = nil
       EMT.L3pp = nil
@@ -1388,6 +1392,7 @@ function OnRapid()
          MyOutput( 'M98')
          MyOutput( 'M6 ' .. GetHeadToolCode() .. AdjustTcPos( true))
          MyOutput( 'G24' .. EMT.IPLGLSTR)
+         EMT.PLANEACTIVE = true
          -- forzo successiva emissione assi rotanti
          EMT.R1p = nil
          EMT.R2p = nil
@@ -1469,6 +1474,7 @@ function OnLinear()
       MyOutput( 'M98')
       MyOutput( 'M6 ' .. GetHeadToolCode() .. AdjustTcPos( true))
       MyOutput( 'G24' .. EMT.IPLGLSTR)
+      EMT.PLANEACTIVE = true
       -- emissione movimento
       EMT.R1p = nil
       EMT.R2p = nil
@@ -1559,6 +1565,7 @@ function OnArc()
       MyOutput( 'M98')
       MyOutput( 'M6 ' .. GetHeadToolCode() .. AdjustTcPos( true))
       MyOutput( 'G24' .. EMT.IPLGLSTR)
+      EMT.PLANEACTIVE = true
       -- emissione movimento
       EMT.R1p = nil
       EMT.R2p = nil
@@ -1621,28 +1628,6 @@ function OnArc()
    EmtUpdatePrev()
 end
 
----------------------------------------------------------------------
-function CalcDinamicaPinze( dH, dS, dL)
-   local MinTempoAcc = 0.6                         -- [s]
-   local MaxTempoAcc = 6.0                         -- [s]
-   local KgMtCubo= WoodDensity or 550             -- densità legno [Kg / metro cubo]
-   local Massa = ( dH * dS * dL * KgMtCubo ) / 1e9 -- massa [Kg]
-   local FMaxPinze = EMT.FMAXPINZE                 -- Feed massima pinze [mm/min]
-   local ForzaAttrito = 350 * 9.8 * 0.2            -- Forza chiusura pinze [Kgf] * g * Coeff_Attrito -> [N]
-   local TempoAcc = ( ( Massa * FMaxPinze) / ( 60 * ForzaAttrito) / 1000)
-   if ( TempoAcc < MinTempoAcc) then TempoAcc = MinTempoAcc end
-   if ( TempoAcc > MaxTempoAcc) then TempoAcc = MaxTempoAcc end
-   local AccMaxPinze = FMaxPinze / ( 60 * MinTempoAcc)
-   local AccPinze = FMaxPinze / ( 60 * TempoAcc)
-   local RidFeed = 100 / Massa * 100
-   if RidFeed > 100 then
-      RidFeed = 100
-   elseif RidFeed < 10 then
-      RidFeed = 10
-   end
-   return TempoAcc * 1000, MinTempoAcc * 1000, RidFeed
-end
-
 ---------------------------------------------------------------------
 function CalcForzaPinze( dH, dS, dL, dT)
    local MassaRef = 1500                              -- [Kg]
@@ -2325,7 +2310,7 @@ function AdjustTcPos( bLen3, sTcPos, dAxR3)
       end
    end
    if sPos == '111' then
-      if not dAxR3 then dAxR3 = EMT.R3 end
+      if not dAxR3 then dAxR3 = EMT.R3 or 0 end
       -- controllo che il valore esista. Altrimenti è una testa senza asse ausiliario
       if dAxR3 then
          if abs( dAxR3 - 0) < 0.1 then
@@ -2342,7 +2327,7 @@ function AdjustTcPos( bLen3, sTcPos, dAxR3)
       end
    end
    if sPos == '121' then
-      if not dAxR3 then dAxR3 = EMT.R3 end
+      if not dAxR3 then dAxR3 = EMT.R3 or 0 end
       -- controllo che il valore esista. Altrimenti è una testa senza asse ausiliario
       if dAxR3 then
          if abs( dAxR3 - 0) < 0.1 then
@@ -2576,9 +2561,9 @@ function EmitZmax( bReset, bEnd, PrevR1, PrevR2, bSplitCut, bTopGoHome, bUsePrev
             local dPosT = EgtIf( bEnd, EMT.L1o, EMT.TPOS or EMT.L1op)
             EmitParkRoller( dPosT, bSplitCut)
          end
-         -- se non sono esattamente in home, devo ruotare in zona sicura
+         -- se non sono esattamente in home, ruoto dove sono
          if abs( dHomeC3 - PrevR1) > 1 or abs( dHomeB3 - PrevR2) > 1 then
-            EmitMoveDataHead( 3, { X=-SafeX3RotAxis, Fmt=1})
+            --EmitMoveDataHead( 3, { X=-SafeX3RotAxis, Fmt=1})
             EmitMoveDataHead( 3, { Z=SafeZ3RotAxis, Fmt=1})
             EmitMoveDataHead( 3, { B=dHomeB3, C=dHomeC3, Fmt=1})
          end
@@ -2624,15 +2609,19 @@ end
 
 ---------------------------------------------------------------------
 function EmitResetMachining()
-   MyOutput( 'G27')
-   if EMT.PREFALLCUT then
-      MyOutput( 'M29')
-      EMT.PREFALLCUT = nil
+   if EMT.PLANEACTIVE then
+      MyOutput( 'G27')
+      if EMT.PREFALLCUT then
+         MyOutput( 'M29')
+         EMT.PREFALLCUT = nil
+      end
+      local sP12 = ''
+      if EMT.TOOL ~= GetNextTool( EMT.MCHID) then sP12 = EgtIf( EMT.HEAD ~= 'H21', ' P1=0'..EgtIf( EMT.DOU_TYPE, ' P2=0', ''), ' P2=0') end
+      local sP4 = EgtIf( EMT.MCHUSERNOTES:find( 'Split', 1, true), ' P4=1', '')
+      MyOutput( 'M99'..sP12..sP4)
+      -- piano non più attivo
+      EMT.PLANEACTIVE = false
    end
-   local sP12 = ''
-   if EMT.TOOL ~= GetNextTool( EMT.MCHID) then sP12 = EgtIf( EMT.HEAD ~= 'H21', ' P1=0'..EgtIf( EMT.DOU_TYPE, ' P2=0', ''), ' P2=0') end
-   local sP4 = EgtIf( EMT.MCHUSERNOTES:find( 'Split', 1, true), ' P4=1', '')
-   MyOutput( 'M99'..sP12..sP4)
 end
 
 ---------------------------------------------------------------------

Common_PF1250.mlpe

@@ -646,7 +646,7 @@ function OnSimulToolDeselect( dPrevA)
    -- se passo da testa 1 a 3 scarico aggregato
    if nNextSetHead == 3 then
       -- deposito utensile prelevato da posizioni speciali
-      if EMT.TCPOS == 'T101' or EMT.TCPOS == 'T111' or EMT.TCPOS == 'T121' then
+      if EMT.PREVTCPOS_H1 == 'T101' or EMT.PREVTCPOS_H1 == 'T111' or EMT.PREVTCPOS_H1 == 'T121' then
          -- visualizzo utensile su TcPos
          ShowToolInTcPos( EMT.PREVTCPOS_H1, true)
          -- nascondo l'utensile sulla testa
@@ -1656,9 +1656,9 @@ function ExecMoveZmax( bMchSplit, bGoToHome)
          SimulMoveAxes( 'B3', ParkB3, MCH_SIM_STEP.COLLROT)
       elseif EgtGetHeadId( 'H38') then
          local MyMaxZ3 = EgtGetAxisMax( 'Z3')
-         -- se non sono esattamente in home, devo ruotare in zona sicura
+         -- se non sono esattamente in home, ruoto dove sono
          if abs( HomeC - CurrC) > 1 or abs( HomeB - CurrB) > 1 then
-            SimulMoveAxis( 'X3', SafeX3RotAxis, MCH_SIM_STEP.RAPID)
+            -- SimulMoveAxis( 'X3', SafeX3RotAxis, MCH_SIM_STEP.RAPID)
             SimulMoveAxis( 'Z3', SafeZ3RotAxis, MCH_SIM_STEP.RAPID)
             SimulMoveAxes( 'C3', HomeC, MCH_SIM_STEP.COLLROT, 'B3', HomeB, MCH_SIM_STEP.COLLROT)
          end
@@ -2170,22 +2170,26 @@ end
 ---------------------------------------------------------------------
 --   *** ESTIMATION T&L ***
 ---------------------------------------------------------------------
-local RAPID_X_FEED =  70000    -- mm/min
-local RAPID_Y_FEED = 100000    -- mm/min
-local RAPID_Z_FEED =  32000    -- mm/min
-local RAPID_C_FEED =  15000    -- deg/min
-local RAPID_B_FEED =  15000    -- deg/min
-local RAPID_MIN_T = 0.1        -- s
-local LOAD_T = 2               -- s
-local CHAR_ONE_MOVE_T = 1      -- s
-local ROTATION_T = 40          -- s
-local SPLIT_T = 6              -- s
-local UNLOAD_T = 4             -- s
-local FALL_T = 2               -- s
+local ESTIMATION_RAPID_COEFF = EstimationRapidMultiplier or 1
+local RAPID_X_FEED =  70000 / ESTIMATION_RAPID_COEFF    -- mm/min
+local RAPID_Y_FEED = 100000 / ESTIMATION_RAPID_COEFF    -- mm/min
+local RAPID_Z_FEED =  32000 / ESTIMATION_RAPID_COEFF    -- mm/min
+local RAPID_C_FEED =  15000 / ESTIMATION_RAPID_COEFF    -- deg/min
+local RAPID_B_FEED =  15000 / ESTIMATION_RAPID_COEFF    -- deg/min
+local RAPID_MIN_T = 0.1 * ESTIMATION_RAPID_COEFF        -- s
+local LOAD_T = 2 * ESTIMATION_RAPID_COEFF               -- s
+local CHAR_ONE_MOVE_T = 1 * ESTIMATION_RAPID_COEFF      -- s
+local ROTATION_T = 40 * ESTIMATION_RAPID_COEFF          -- s
+local SPLIT_T = 6 * ESTIMATION_RAPID_COEFF              -- s
+local UNLOAD_T = 4 * ESTIMATION_RAPID_COEFF             -- s
+local FALL_T = 2 * ESTIMATION_RAPID_COEFF               -- s
 
 ---------------------------------------------------------------------
 function OnEstimStart()
    EMT.INCHES = not EgtUiUnitsAreMM()      -- unità di misura mm/inches
+   EMT.FMAXPINZE = EgtClamp( MaxFeedPinze or 116000, 20000, 130000)  -- feed massima pinze
+   EMT.MAXACC = MaxAcc or 6000    -- accelerazione massima pinze. In realtà è il tempo in millisecondi, quindi MAXACC corrisponde al tempo massimo per raggiungere la velocità desiderata
+   EMT.MINACC = MinAcc or 600     -- accelerazione minima pinze. In realtà è il tempo in millisecondi, quindi MINACC corrisponde al tempo massimo per raggiungere la velocità desiderata
 end
 
 ---------------------------------------------------------------------
@@ -2271,6 +2275,15 @@ function OnEstimDispositionEnd()
    EMT.OPEISDISP = false
 end
 
+---------------------------------------------------------------------
+function OnEstimRawMoveData()
+   -- se start del pezzo
+   if IsStartOrRestPhase( EMT.PHASE) then
+      EMT.SPLIT = false
+   end
+   OnRawMoveData()
+end
+
 ---------------------------------------------------------------------
 function OnEstimToolSelect()
    -- reset indice utensile in tabella lunghezze
@@ -2327,6 +2340,12 @@ function OnEstimMachiningEnd()
       EMT.TLE_NAME = nil
       EMT.TLE_TIME = nil
    end
+
+   EMT.MCHUSERNOTES = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
+   EMT.MCHSPLIT = ( EMT.MCHUSERNOTES:find( 'Split;', 1, true) ~= nil)
+   if EMT.MCHSPLIT then
+      EMT.SPLIT = true
+   end
 end
 
 ---------------------------------------------------------------------
@@ -2452,17 +2471,20 @@ function OnEstimRapid()
    EMT.MCHEXTLEN = EMT.MCHEXTLEN + dLen
    -- calcolo tempo
    local dTime = RAPID_MIN_T
-   local dT1 = abs( dL1) / RAPID_X_FEED * 60
+   
+   local dT1 = CalcMoveTime( abs( dL1), RAPID_X_FEED, EMT.SPLIT)
    if dT1 > dTime then dTime = dT1 end
-   local dT2 = abs( dL2) / RAPID_Y_FEED * 60
+   local dT2 = CalcMoveTime( abs( dL2), EMT.FMAXPINZE, EMT.SPLIT)
    if dT2 > dTime then dTime = dT2 end
-   local dT3 = abs( dL3) / RAPID_Z_FEED * 60
+   local dT3 = CalcMoveTime( abs( dL3), RAPID_Z_FEED, EMT.SPLIT)
    if dT3 > dTime then dTime = dT3 end
    local dT4 = abs( dR1) / RAPID_C_FEED * 60
    if dT4 > dTime then dTime = dT4 end
    local dT5 = abs( dR2) / RAPID_B_FEED * 60
    if dT5 > dTime then dTime = dT5 end
+   
    EMT.MCHEXTTIME = EMT.MCHEXTTIME + dTime
+
    EgtOutLog( string.format( '  G0 Len=%.0f Rot=%.0f° Time=%.2f', dLen, abs( dR1) + abs( dR2), dTime), 5)
    -- aggiorno valori come precedenti
    EmtUpdatePrev()
@@ -2478,7 +2500,7 @@ function OnEstimLinear()
    local dLen = sqrt( dL1 * dL1 + dL2 * dL2 + dL3 * dL3)
    EMT.MCHCUTLEN = EMT.MCHCUTLEN + dLen
    -- calcolo tempo
-   local dTime = dLen / EMT.F * 60
+   local dTime = CalcMoveTime( dLen, EMT.F, EMT.SPLIT)
    EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
    EgtOutLog( string.format( '  G1 Len=%.0f Time=%.2f', dLen, dTime), 5)
    -- aggiorno valori come precedenti
@@ -2752,5 +2774,38 @@ function GetCmdAxMove( Cmd, sAx)
    end
 end
 
+---------------------------------------------------------------------
+function CalcDinamicaPinze( dH, dS, dL)
+   local MinTempoAcc = EMT.MINACC        -- [ms] ~600
+   local MaxTempoAcc = EMT.MAXACC        -- [ms] ~6000
+   local KgMtCubo= WoodDensity or 550              -- densità legno [Kg / metro cubo]
+   local Massa = ( dH * dS * dL * KgMtCubo ) / 1e9 -- massa [Kg]
+   local FMaxPinze = EMT.FMAXPINZE                 -- Feed massima pinze [mm/min]
+   local ForzaAttrito = 350 * 9.8 * 0.2            -- Forza chiusura pinze [Kgf] * g * Coeff_Attrito -> [N]
+   local TempoAcc = EgtClamp( ( Massa * FMaxPinze) / ( 60 * ForzaAttrito), MinTempoAcc, MaxTempoAcc)
+   local RidFeed = 100 / Massa * 100
+   if RidFeed > 100 then
+      RidFeed = 100
+   elseif RidFeed < 10 then
+      RidFeed = 10
+   end
+   return TempoAcc, MinTempoAcc, RidFeed
+end
+
+---------------------------------------------------------------------
+function CalcMoveTime( dPathLen, dFeed, bIsSplitted)
+   local dTime
+   local dFeedInSec = dFeed / 60
+   local dTempoAcc, _, _ = CalcDinamicaPinze( EMT.HB, EMT.SB, EgtIf( bIsSplitted, EMT.LT, EMT.LB))
+   dTempoAcc = dTempoAcc / 1000
+   -- se si raggiunge la velocità massima
+   if dPathLen >= dFeedInSec * dTempoAcc then
+      dTime = dTempoAcc * 2 + ( ( dPathLen - dFeedInSec * dTempoAcc) / dFeedInSec)
+   else
+      dTime = 2 * sqrt( (dPathLen * dTempoAcc) / dFeedInSec)
+   end
+   return dTime
+end
+
 ---------------------------------------------------------------------
 -- *** END GENERAL ***

Common_PF1250.mlse

@@ -7,6 +7,31 @@ EgtEnableDebug( false)
 -- Carico libreria
 local BD = require( 'BeamData')
 
+---------------------------------------------------------------------
+-- *** Generic Machinings ***
+---------------------------------------------------------------------
+require( 'EmtGenMachining')
+
+---------------------------------------------------------------------
+-- *** Special GetPrevMachiningOffset ***
+---------------------------------------------------------------------
+-----------------------------------------------------------------------------------------
+function OnSpecialGetPrevMachiningOffset()
+   -- default
+   EMC.ERR = 0
+   EMC.PREVOFFSX = 0
+   -- se c'è cambio di fase tra le lavorazioni (quindi la precedente è l'ultima della sua fase e la corrente la prima)
+   if EMC.PREVPHASE ~= EMC.CURRPHASE then
+      -- se la fase corrente è di inizio lavorazione di nuova trave
+      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]
+      end
+   end
+end
+
 ---------------------------------------------------------------------
 -- *** Special Z moves ***
 ---------------------------------------------------------------------
@@ -1301,8 +1326,11 @@ function SpecCalcUnload()
       EgtOutLog( '  *[U1]', 1)
    end
    local vCmd = {}
+   -- Tipo di scarico
+   local bStdUl = ( not MaxUnloadLen or MaxUnloadLen < 1 or EMC.LB - EMC.HOVM < MaxUnloadLen + 1)
+
    -- Commento
-   table.insert( vCmd, { 0, 'Unloading'})
+   table.insert( vCmd, { 0, 'Unloading', EgtIf( bStdUl, 'Unloading', 'Manual Unloading')})
    -- posizionamento sicuro teste e rulli (non serve ?)
    --table.insert( vCmd, { 4, 0})
    -- Se pinza Y chiusa, la apro
@@ -1310,11 +1338,15 @@ function SpecCalcUnload()
       table.insert( vCmd, { 11, 0})
       EMC.CNT = nil
    end
-   -- Sposto il pezzo in posizione di scarico
-   local dFinT = EgtIf( EMC.LB < MaxLenSmT, UnloadSmT, UnloadT) - EMC.LB
-   local dFinY2 = dFinT + EMC.Y2DELTA
-   table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2})
-   EgtOutLog( '  Y2PosF=' .. EgtNumToString( dFinY2), 1)
+   -- Se non supero la lunghezza massima di scarico, sposto il pezzo in posizione di scarico
+   if bStdUl then
+      local dFinT = EgtIf( EMC.LB < MaxLenSmT, UnloadSmT, UnloadT) - EMC.LB
+      local dFinY2 = dFinT + EMC.Y2DELTA
+      table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2})
+      EgtOutLog( '  Y2PosF=' .. EgtNumToString( dFinY2), 1)
+   else
+      table.insert( vCmd, { 1, 'Y2', MaxY2})
+   end
    -- apro la morsa
    table.insert( vCmd, { 12, 0})
    -- riporto il carrello in home

Essetre-PF1250.mlde

@@ -30,10 +30,10 @@
 require( 'EmtGenerator')
 EgtEnableDebug( false)
 
-PP_VER = '2.7d2'
-PP_NVER = '2.7.4.2'
+PP_VER = '2.7i2'
+PP_NVER = '2.7.9.2'
 MIN_MACH_VER = '2.7d2'
-MACH_NAME = 'Essetre-PF1250'
+MACH_NAME = string.match( EgtGetCurrMachineDir(), "[^\\]+$")  -- si ricava il nome della macchina dal direttorio
 
 -- Carico i dati globali
 local sMachDir = EgtGetCurrMachineDir()
@@ -148,12 +148,13 @@ DeltaTabY = 2467.0
 DeltaTabZ = -1128 + MillOffs                                -- per TPA : -1128.0 + MillOffs    -- per NUM : -958.0
 DeltaRulliTraveZ = -903
 DimTabY = 1400
-DimTabX = 24000
+DimTabX = 34000
 Delta2TabY = -1185.9
 Delta2TabZ = 693 - Mill2Offs                                -- per TPA : 378.0 - Mill2Offs      -- per NUM : 208.0
 Head2X = 0
 Head2Y = DeltaTabY - Delta2TabY
 Head2Z = DeltaTabZ - Delta2TabZ
+LenStemH2 = 154
 DefTcPos1 = 'T1'
 DefTcPos2 = 'T30'
 MinForzaPinze = 400                              -- [Kgf]
@@ -167,6 +168,7 @@ EmitAccClamps = true
 WriteAllCoordsOnFirstM101 = true
 ForceToCloseRollersGate = false
 Motors23KW = false
+EstimationRapidMultiplier = 1
 
 -- Aggiornamento con dati da TechnoEssetre7
 local sTs3Data = EgtGetStringFromIni( 'Beam', 'DATA_DIR', "C:\\TechnoEssetre7\\EgtData", EgtGetIniFile()).."\\Essetre-PF1250.data"
@@ -244,10 +246,15 @@ if EgtExistsFile( sDataBeam) then
          if Machine.Offsets.DEFTCPOS2 then DefTcPos2 = ( 'T' .. Machine.Offsets.DEFTCPOS2) end
          if Machine.Offsets.MINPRESS then MinForzaPinze = Machine.Offsets.MINPRESS end
          if Machine.Offsets.MAXPRESS then MaxForzaPinze = Machine.Offsets.MAXPRESS end
+         if Machine.Offsets.NOULOAD then MaxUnloadLen = Machine.Offsets.NOULOAD end
          if Machine.Offsets.MAXFEEDPINZE then MaxFeedPinze = Machine.Offsets.MAXFEEDPINZE end
+         if Machine.Offsets.MAXACC then MaxAcc = Machine.Offsets.MAXACC end
+         if Machine.Offsets.MINACC then MinAcc = Machine.Offsets.MINACC end
+         if Machine.Offsets.COEFF_STIMATEMPI and Machine.Offsets.COEFF_STIMATEMPI > 0 then EstimationRapidMultiplier = Machine.Offsets.COEFF_STIMATEMPI end
          if Machine.Offsets.CHIUDI_PINZE_2_3_SCAMBIO then ForceToCloseRollersGate = Machine.Offsets.CHIUDI_PINZE_2_3_SCAMBIO == 1 end
          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
 
          -- aggiustamenti
          MinY1 = MinV1 + MinDeltaYV
@@ -454,12 +461,18 @@ local B2Id = EmtAxis {
       Geo = EgtIf( Motors23KW, 'B2_AXIS_23KW/GEO', 'B2_AXIS/GEO'),
       Aux = {EgtIf( Motors23KW, 'B2_AXIS_23KW/SOLID', 'B2_AXIS/SOLID'), EgtIf( Motors23KW, 'B2_AXIS_23KW/COLLISION', 'B2_AXIS/COLLISION')}}
 
-local vtMoveZ2 = Vector3d( 0, 0, Head2Z + 1481.0)
-EgtMove( EgtGetFirstNameInGroup( Z2Id, 'SOLID'), vtMoveZ2 - vtOffset23KW, GDB_RT.GLOB)
-EgtMove( EgtGetFirstNameInGroup( Z2Id, 'COLLISION'), vtMoveZ2 - vtOffset23KW, GDB_RT.GLOB)
-local vtMoveX2 = Vector3d( 0, Head2Y - 3635.9, Head2Z + 1481.0)
-EgtMove( EgtGetFirstNameInGroup( X2Id, 'SOLID'), vtMoveX2 - vtOffset23KW, GDB_RT.GLOB)
-EgtMove( EgtGetFirstNameInGroup( X2Id, 'COLLISION'), vtMoveX2 - vtOffset23KW, GDB_RT.GLOB)
+-- si sistema lunghezza stelo testa 2
+local LenStemH2Offset = Vector3d( 0, 0, 154 - LenStemH2)
+local SolidArmId = EgtGetFirstNameInGroup( ( EgtGetFirstNameInGroup( X2Id, 'SOLID')), 'STEM')
+EgtSurfTmMoveFacet( SolidArmId, 106, -LenStemH2Offset, GDB_RT.GLOB)
+
+local vtMoveZ2 = Vector3d( 0, 0, Head2Z + 1381.0)
+EgtMove( EgtGetFirstNameInGroup( Z2Id, 'SOLID'), vtMoveZ2 - vtOffset23KW + LenStemH2Offset, GDB_RT.GLOB)
+EgtMove( EgtGetFirstNameInGroup( Z2Id, 'COLLISION'), vtMoveZ2 - vtOffset23KW + LenStemH2Offset, GDB_RT.GLOB)
+local vtMoveX2 = Vector3d( 0, Head2Y - 3635.9, Head2Z + 1381.0)
+EgtMove( EgtGetFirstNameInGroup( X2Id, 'SOLID'), vtMoveX2 - vtOffset23KW + LenStemH2Offset, GDB_RT.GLOB)
+EgtMove( EgtGetFirstNameInGroup( X2Id, 'COLLISION'), vtMoveX2 - vtOffset23KW + LenStemH2Offset, GDB_RT.GLOB)
+
 EgtMove( EgtGetFirstNameInGroup( C2Id, 'SOLID'), vtMoveX2, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( C2Id, 'COLLISION'), vtMoveX2, GDB_RT.GLOB)
 EgtMove( EgtGetFirstNameInGroup( B2Id, 'SOLID'), vtMoveX2, GDB_RT.GLOB)
@@ -589,7 +602,7 @@ EmtAxis {
       Type = MCH_AT.LINEAR,
       Dir = - X_AX(),
       Pos = Point3d(0.0,2450.0,-958.0),
-      Stroke = {-20000, 20000},
+      Stroke = {-30000, 30000},
       Home = LoadT,
       Geo = 'T_AXIS/GEO'}
 EmtTable {

UpdateLog.txt

@@ -1,5 +1,23 @@
            ==== Common_PF1250 Update Log ====
 
+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
+- (SIM) Corretto controllo ultimo utensile utilizzato su testa 1, prima si controllava il precedente, ma poteva essere la testa 2
+- (SIM-GEN) Se testa 3 deve salire a ZMAX, sale alla X dove si trova e non torna in home
+
+Versione 2.7h2 (21/08/2025)
+- (GEN) Se la testa rimane bassa, corretto caso di reset del piano generico a fine lavorazione
+- (GEN) Corretto movimento in Z massima dopo scarico pezzo
+
+Versione 2.7h1 (20/08/2025)
+- (GEN) Per posizione T111 e T121, se non è presente asse rotante per presa aggregato (es. se si mette una fresa normale) viene settato a zero.
+- (MLDE-SIM) Aggiunta variabile FACOLTATIVA 'EstimationRapidMultiplier' in mlde per regolare il tempo stimato di rapido su macchine vecchie. Se non presente default 1.
+
+Versione 2.7g1 (01/07/2025)
+- (GEN) Lettura parametri accelerazioni da TS3. Ticket#2052
+- (SIM-GEN) Aggiunta gestione massima lunghezza scarico
+
 Versione 2.7d2 (24/04/2025)
 - (SIM) Modifica qualità VMILL. Da ora si può impostare da impostazioni CAM5
 

Version.lua

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