In caso di Progress, alla deselezione utensile testa 1 su TC2 si fa movimento Z raddrizzando asse B.

- In MLDE si legge il parcheggio della punta lunga su utensile standard ONE

.gitignore

@@ -15,4 +15,3 @@
 /Wall/PocketingData.lua
 /Wall/SawingData.lua
 /Wall/Ts3Data.lua
-.vscode/settings.json

.gitlab-ci.yml

@@ -2,19 +2,27 @@ variables:
  VERS_MAIN: '1.0'
  MACH_NAME: ''
  MACH_NAME_TEST: ''
+ MANUFACTURER: ''
  NEW_REL: ''
  NET_SHARE_X: '\\10.74.82.201\EgwTech'
  NET_SHARE_Z: '\\10.74.82.201\Artifacts'
  NET_SHARE_S: '\\10.74.82.201\Scambio'
  NET_SHARE_R: '\\10.74.82.201\EgwTech'
+ NET_SHARE_H: '\\10.74.82.252\team drives'
  NET_USERQ: 'steamw\egalware'
+ NET_USER_SERVICES: 'steamw\services'
  MACH_VERS: '0.0.0.0'
  TEMP_PATH: 'C:\MachinesDeploy'
- MACHINES_PATH_R: 'R:\EgtData\Machines'
- DEST_MACHINES_PATH_R: 'R:\EgtData\Machines\zTestYAML'
+ MACHINES_PATH_R: 'R:\EgtData\Machines_GIT'
+ DEST_MACHINES_PATH_H: 'H:'
  SRC_PATH: ''
  BASE_PATH: ''
  TEST_PATH: ''
+ URL_VERSIONS_LOG: "https://liman.egalware.com/ELM.API/api/release/save"
+ MACH_VERS_NUM: '0.0.0.0'
+ CRITICAL_STRING: "#critical#"
+ TOOLS_MACHINE_PATH: ""
+
 
 #Note compilazione LUA:
 # lua54 -o bin\$FileName -s $FileName: -o = output, -s = NON include i debug symbols
@@ -38,12 +46,29 @@ variables:
       echo "-----------------------"
       echo "   Copia macchina su R"
       echo "-----------------------"
-      ROBOCOPY /MIR "$env:SRC_PATH" "$env:DEST_MACHINES_PATH_R\$env:MACH_NAME\" /XD "bin"
-      ROBOCOPY "$env:TEST_PATH" "$env:DEST_MACHINES_PATH_R\$env:MACH_NAME_TEST\" /E /XD "bin"
-      ROBOCOPY /MIR "$env:BASE_PATH" "$env:DEST_MACHINES_PATH_R\Deploy\$env:MACH_NAME\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST"
+      $customerPathR = $env:MACHINES_PATH_R + "\" + $env:MANUFACTURER
+      ROBOCOPY /MIR "$env:SRC_PATH" "$customerPathR\$env:MACH_NAME\" /XD "bin"
+      ROBOCOPY "$env:TEST_PATH" "$customerPathR\_TestMachines\$env:MACH_NAME_TEST\" /E /XD "bin"
+      ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\_Deploy\$env:MACH_NAME\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST"
       SLEEP 2
       net use R: /delete
 
+# helper copia script verso drive condiviso
+.ReplicaStor01: &ReplicaStor01
+   - |
+      net use H: /delete
+      SLEEP 2
+      net use H: $env:NET_SHARE_H /u:$env:NET_USER_SERVICES $SRVCS_PASSWD
+      echo "-----------------------"
+      echo "   Copia macchina su stor01"
+      echo "-----------------------"
+      SLEEP 2
+      $customerPathH = $env:DEST_MACHINES_PATH_H + "\" + $env:MANUFACTURER + "\test"
+      $destinationPath = "$customerPathH\$env:MACH_NAME" + "\"
+      ROBOCOPY "$env:BASE_PATH" "$destinationPath\" *.zip
+      SLEEP 2
+      net use H: /delete
+
 # helper copia script verso cartella di rete R:\ per develop
 .ReplicaR_DEV: &ReplicaR_DEV
    - |
@@ -53,7 +78,8 @@ variables:
       echo "-----------------------"
       echo "   Copia macchina su R - DEV"
       echo "-----------------------"
-      ROBOCOPY /MIR "$env:BASE_PATH" "$env:DEST_MACHINES_PATH_R\Deploy\$env:MACH_NAME\_DEV\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST"
+      $customerPathR = $env:MACHINES_PATH_R + "\" + $env:MANUFACTURER
+      ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\_Deploy\$env:MACH_NAME\_DEV\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST"
       SLEEP 2
       net use R: /delete
 
@@ -66,8 +92,15 @@ variables:
       echo "-----------------------"
       echo "   Recupero file non git da R e copia su macchina virtuale"
       echo "-----------------------"
-      ROBOCOPY "$env:LAST_MACHINE_PATH" "$env:SRC_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode"
-      ROBOCOPY "$env:LAST_MACHINE_PATH" "$env:SRC_PATH\bin\$env:MACH_NAME\" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode"
+      # test se la cartella con gli utensili esiste per questa macchina
+      if (!(Test-Path -Path $env:TOOLS_MACHINE_PATH)) {
+      echo "-----------------------"
+      echo "CANNOT FIND TOOLS FOR THIS MACHINE!!"
+      echo "-----------------------"
+      Exit 1}
+      ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:SRC_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode"
+      ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:TEST_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode"
+      ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:SRC_PATH\bin\$env:MACH_NAME\" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode"
       SLEEP 2
       net use R: /delete
 
@@ -86,22 +119,25 @@ variables:
      echo "-----------------------"
      echo "   Compilazione file *.lua 32/64bit"
      echo "-----------------------"
-     $FileList = Get-ChildItem("Common-*")
+     $FileList = Get-ChildItem * -Include( "*.mlpe", "*.mlse")
      ForEach ($File in $FileList) {
        $FileName = Split-Path $File -leaf
        lua54 -o $env:SRC_PATH\bin\$env:MACH_NAME\$FileName -s $FileName
        echo "lua54 -o bin\$FileName -s $FileName"
      }
 
-# helper recupero nome macchina
+# helper recupero nome macchina e costruttore
 .machName-fix: &machName-fix
    - |
       echo "-----------------------"
-      echo "   Recupero nome macchina"
+      echo "   Recupero nome macchina e costruttore"
       echo "-----------------------"
       $fileName = dir *.mlde
       $env:MACH_NAME = $fileName.BaseName
       $env:MACH_NAME_TEST = $env:MACH_NAME + ".TEST"
+      $comp = $fileName.BaseName -split "-"
+      $env:MANUFACTURER = $comp[0]
+      Write-Output $env:MANUFACTURER 
 
 # helper calcolo versione
 .version-fix: &version-fix
@@ -109,12 +145,22 @@ variables:
       echo "-----------------------"
       echo "   Calcolo versione"
       echo "-----------------------"
+
+      # calcolo versione formato stringa
       $fPath = "$env:MACH_NAME.mlde";
-      $vLine = Select-String -path $fPath -Pattern 'PP_VER';
+      $vLine = Select-String -path $fPath -Pattern '^PP_VER';
       $comp = $vLine -split "=";
       $env:MACH_VERS = $comp[1].Replace("'","").Trim()
-      # display versione
-      Write-Output $env:MACH_VERS;
+      # display versione formato stringa
+      Write-Output $env:MACH_VERS
+
+      # calcolo versione formato numerico
+      $fPath = "$env:MACH_NAME.mlde";
+      $vLine = Select-String -path $fPath -Pattern '^PP_NVER';
+      $comp = $vLine -split "=";
+      $env:MACH_VERS_NUM = $comp[1].Replace("'","").Trim()
+      # display versione formato numerico
+      Write-Output $env:MACH_VERS_NUM
 
 # helper calcolo versione se develop
 .version-fix_DEV: &version-fix_DEV
@@ -126,7 +172,7 @@ variables:
       $commitAuthor = $commitAuthor[0].Trim()
       $env:MACH_VERS = $commitAuthor
       # display versione
-      Write-Output $env:MACH_VERS;
+      Write-Output $env:MACH_VERS
 
 # helper creazione folders 
 .folder-fix: &folder-fix
@@ -134,8 +180,8 @@ variables:
       echo "-----------------------"
       echo "   Creazione cartelle su macchina virtuale"
       echo "-----------------------"
-      $env:LAST_MACHINE_PATH = "$env:MACHINES_PATH_R\$env:MACH_NAME";
-      Write-Output  $env:LAST_MACHINE_PATH;
+      $env:TOOLS_MACHINE_PATH = "$env:MACHINES_PATH_R\$env:MANUFACTURER\_DefaultMachineSetup\$env:MACH_NAME"
+      Write-Output  $env:TOOLS_MACHINE_PATH
       $env:SRC_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS\$env:MACH_NAME";
       $env:BASE_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS";
       $env:TEST_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS\$env:MACH_NAME_TEST";
@@ -158,6 +204,39 @@ variables:
       7zip a -tzip $Target $Source  
       Write-Output "called ZIP $Source --> $Target"
 
+# helper invio notifica a log versioni online (LiMan)
+.SendToVersionsLog: &SendToVersionsLog
+   - |
+      echo "-----------------------"
+      echo "   Invio versione a log online"
+      echo "-----------------------"
+      $tags = ""
+      $date = ""
+      # se critico scrive tag
+      if ( $CI_COMMIT_MESSAGE | Select-String -Pattern $env:CRITICAL_STRING) {
+         $tags = "CRITICAL"
+         $date = (Get-Date).AddDays(1).toString("yyyy-MM-ddTHH:mm:ss.fffZ")
+      }
+      else
+      {
+         $date = (Get-Date).AddDays(3).toString("yyyy-MM-ddTHH:mm:ss.fffZ")
+      }
+      $body =
+      @{
+            codInst = "EgalWare"
+            codApp = $env:MACH_NAME
+            uplAppId = "UpdateManager"
+            masterKey = $LiMan_Key
+            tipo = "Machine"
+            versNum = $env:MACH_VERS_NUM
+            versText = $env:MACH_VERS
+            releaseDate = $date
+            relTags = $tags
+      }
+      $jsonBody = ConvertTo-Json -InputObject $body
+      echo $jsonBody
+      Invoke-WebRequest -Method Post -URI $env:URL_VERSIONS_LOG -ContentType "application/json" -Body $jsonBody -UseBasicParsing
+
 
 # helper esecuzione test 
 .RunTest: &RunTest
@@ -186,6 +265,8 @@ LuaCompile:build:
    - *LuaCompile
    - *ZipClean
    - *ReplicaR
+   - *ReplicaStor01
+   - *SendToVersionsLog
 
 LuaCompileDev:build:
  stage: build
@@ -233,4 +314,5 @@ LuaCompileDev:build:
 #  script:    
 #    - *LuaCompile
 #    - *ZipClean
-#    - *ReplicaR
+#    - *ReplicaR
+

Beam/BeamData.lua

@@ -8,13 +8,14 @@ local BeamData = {
    RIGHT_LOAD = false,                      -- flag carico da destra
    SIMUL_VIEW_DIR = 2,                      -- direzione di vista predefinita per la simulazione (1=NW, 2=SW, 3=NE, 4=SE)
    ROT90 = false,                           -- flag abilitazione rotazione 90 gradi
+   ROT180 = true,                           -- flag abilitazione rotazione 180 gradi
    MIN_WIDTH = 40,                          -- larghezza minima del grezzo
    MIN_HEIGHT = 40,                         -- altezza minima del grezzo
    MAX_WIDTH = 400,                         -- larghezza massima del grezzo
    MAX_HEIGHT = 800,                        -- altezza massima del grezzo
    LEN_SHORT_PART = 1200,                   -- lunghezza massima pezzo piccolo
    LEN_VERY_SHORT_PART = 700,               -- lunghezza massima pezzo molto corto (molto probabile lo scarico a caduta)
-   MAX_RAW = 20000,                         -- massima lunghezza grezzo (deve essere minore di LenTable - RAW_OFFSET)
+   MAX_RAW = 30000,                         -- 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.0,                           -- sovramateriale intermedio (spessore lama)

Common_ONE-PF.NUM.mlpe

@@ -424,6 +424,7 @@ function OnMachiningStart()
    EMT.MCHUSERNOTES = EgtGetMachiningParam( MCH_MP.USERNOTES)
    EMT.MCHSPLIT = ( EMT.MCHUSERNOTES:find( 'Split;', 1, true) ~= nil)
    EMT.MCHPRECUT = ( EMT.MCHUSERNOTES:find( 'Precut;', 1, true) ~= nil)
+   EMT.MCHCUT = ( EMT.MCHUSERNOTES:find( 'Cut;', 1, true) ~= nil)
 
    -- se sega a catena, aggiusto subito angolo scelto per asse virtuale A
    if EMT.HEAD == 'H13' or EMT.HEAD == 'H15' then
@@ -602,16 +603,22 @@ function OnMachiningEnd()
    EMT.PREVTOOL = EMT.TOOL
    EMT.PREVHEAD = EMT.HEAD
    EMT.PREVTCPOS = EMT.TCPOS
+   -- se taglio finale, aggiorno lunghezza barra
+   if EMT.MCHCUT then
+      EMT.LB = EMT.LT + ( EMT.X_OFF or 0)
+   end
    -- salvo anche utlimo utensile su testa
    local nHSet = GetHeadSet( EMT.HEAD)
    if nHSet == 1 then
       EMT.PREVTOOL_H1 = EMT.TOOL
       EMT.PREVHEAD_H1 = EMT.HEAD
       EMT.PREVTCPOS_H1 = EMT.TCPOS
+      EMT.PREVHOMEX_H1 = EgtGetAxisHomePos( 'X1')
    elseif nHSet == 2 then
       EMT.PREVTOOL_H2 = EMT.TOOL
       EMT.PREVHEAD_H2 = EMT.HEAD
       EMT.PREVTCPOS_H2 = EMT.TCPOS
+      EMT.PREVHOMEX_H2 = EgtGetAxisHomePos( 'X2')
    end
 
    if EMT.DOU_TYPE and not EMT.ZMAX then EMT.DOU_TO_ZMAX = true end
@@ -677,6 +684,10 @@ function OnPathEnd()
    if not EMT.ZMAX then
       EmitResetMachining()
    end
+
+   -- salvo dati precedenti
+   EMT.L2pp = EMT.L2o
+
    EMT.AUXTYPE = nil
    EMT.UNL = nil
    EMT.PREROT = nil
@@ -796,6 +807,12 @@ function OnRapid()
       local PrevR1 = EMT.R1p or EMT.R1pp or HomeR1
       local PrevR2 = EMT.R2p or EMT.R2pp or HomeR2
       EmtResetPrev()
+      -- gestione speciale per pezzi molto alti. Se il movimento successivo è più alto del precedente, allora prendo il successivo
+      if EMT.L3s then
+         if EMT.L3s > EMT.L3 then
+            EMT.L3 = EMT.L3s
+         end
+      end
       -- se prima lavorazione
       if EMT.LOAD then
          EMT.V2POS = ParkV2
@@ -838,26 +855,50 @@ function OnRapid()
             local HomeB1 = EgtGetAxisHomePos( 'B1')
             local HomeC1 = EgtGetAxisHomePos( 'C1')
             local dTRad, dTLen = GetToolRadLen()
-            local dXref = EMT.L2
-            if  EMT.HEAD == 'H12'  and  EMT.L2 < -LimX1PlRotSaw  then
-               dXref = -LimX1PlRotSaw
-            end
             -- se fresa o lama
             if not HeadIsChainSaw( EMT.HEAD) then
-               EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=ParkB1, C=ParkC1, TRad=dTRad, TLen=dTLen, S=Speed})
+               EmitMoveDataHead( 1, { X=-ParkX1, Z=MyMaxZ1, B=ParkB1, C=ParkC1, TRad=dTRad, TLen=dTLen, S=Speed})
                EmitMoveStartHead( 1)
                EmitMoveWaitHead( 1)
                EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
+               local bMoveZbeforeX = false
                local dZref = EMT.L3
                -- se carico destro e ho due teste, altrimenti in caso abbia una testa , tipo ONE, il controlo è invertito
-               if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or  BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
+               if EMT.HEAD == 'H12' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
                   dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
                end
+               -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+               if EMT.L3 > dZref then
+                  bMoveZbeforeX = true
+               end
+
+               -- se vado in posizione speciale rotazione assi, poi devo ritornare alla X vera di lavoro
+               local dMoveXtoFinalPosition = false
+               local dXref = EMT.L2
+               if  EMT.HEAD == 'H12'  and  EMT.L2 < -LimX1PlRotSaw  then
+                  dXref = -LimX1PlRotSaw
+                  EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=ParkB1, C=ParkC1, S=Speed})
+                  dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2))
+                  dMoveXtoFinalPosition = true
+               elseif not bMoveZbeforeX then
+                  EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=ParkB1, C=ParkC1, S=Speed})
+               else
+                  EmitMoveDataHead( 1, { X=-LimX1PlRotSaw, Z=MyMaxZ1, B=ParkB1, C=ParkC1, S=Speed})
+                  dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2))
+                  dMoveXtoFinalPosition = true
+               end
+   
                -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
-                  EmitMoveDataHead( 1, { X=dXref, Z=MyMaxZ1, B=0, C=ParkC1, S=Speed})
+                  EmitMoveDataHead( 1, { B=0, S=Speed})
                   EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
                   EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
+                  if bMoveZbeforeX then
+                     EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed})
+                  end
+                  if dMoveXtoFinalPosition then
+                     EmitMoveDataHead( 1, { X=EMT.L2, S=Speed})
+                  end
                -- caso standard
                else
                   EmitMoveDataHead( 1, { X=dXref, Z=dZref, B=ParkB1, C=ParkC1, S=Speed})
@@ -905,31 +946,45 @@ function OnRapid()
                -- allontanamento o eventuale preselezione successiva testa 1
                PreselectNextDiffHead( EMT.MCHID, EMT.HEAD)
                -- movimento testa
-               local dSafeZ1 = EgtGetAxisHomePos( 'Z21')
+               local dSafeZ1 = EgtGetAxisHomePos( 'Z1')
                local MyMaxZ1 = EgtGetAxisMax( 'Z1')
                local HomeC1 = EgtGetAxisHomePos( 'C1')
                local HomeB1 = EgtGetAxisHomePos( 'B1')
                local dTRad, dTLen = GetToolRadLen()
                -- se fresa o lama
                if not HeadIsChainSaw( EMT.HEAD) then
-                  EmitMoveDataHead( 1, { X=EMT.L2, Z=MyMaxZ1, B=HomeB1, C=HomeC1, TRad=dTRad, TLen=dTLen, S=Speed})
+                  EmitMoveDataHead( 1, { X=-ParkX2, Z=MyMaxZ1, B=HomeB1, C=HomeC1, TRad=dTRad, TLen=dTLen, S=Speed})
                   EmitMoveStartHead( 1)
                   EmitMoveWaitHead( 1)
                   EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
+                  local bMoveZbeforeX = false
+
                   local dZref = EMT.L3
-                  if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or  BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then
+                  if EMT.HEAD == 'H12' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then
                      dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
                   end
+                  -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+                  if EMT.L3 > dZref then
+                     bMoveZbeforeX = true
+                  end
+                  if not bMoveZbeforeX then
+                     EmitMoveDataHead( 1, { X=EMT.L2, Z=MyMaxZ1, B=HomeB1, C=HomeC1, S=Speed})
+                  else
+                     EmitMoveDataHead( 1, { X=-LimX1RotSawTC2, Z=MyMaxZ1, B=HomeB1, C=HomeC1, S=Speed})
+                  end
                   -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                   if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
-                     EmitMoveDataHead( 1, { X=EMT.L2, Z=MyMaxZ1, B=0, C=HomeC1, S=Speed})
+                     EmitMoveDataHead( 1, { B=0, S=Speed})
                      EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
                      EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
+                     if bMoveZbeforeX then
+                        EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed})
+                     end
                   -- altrimenti caso standard
                   else
-                     EmitMoveDataHead( 1, { X=EMT.L2, Z=dZref, B=HomeB1, C=HomeC1, S=Speed})
-                     EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
+                     EmitMoveDataHead( 1, { Z=dZref, S=Speed})
                      EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
+                     EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
                   end
                -- altrimenti sega a catena
                else
@@ -966,22 +1021,37 @@ function OnRapid()
                local dTRad, dTLen = GetToolRadLen()
                -- se fresa o lama
                if not HeadIsChainSaw( EMT.HEAD) then
-                  EmitMoveDataHead( 2, { X=EMT.L2, Z=MyMaxZ2, B=HomeB2, C=HomeC2, TRad=dTRad, TLen=dTLen, S=Speed})
+                  EmitMoveDataHead( 2, { X=-ParkX2, Z=MyMaxZ2, B=HomeB2, C=HomeC2, TRad=dTRad, TLen=dTLen, S=Speed})
                   EmitMoveStartHead( 2)
                   EmitMoveWaitHead( 2)
                   EmitMoveWaitChars( EgtIf( bOnlyCharY, 1, 3))
+                  local bMoveZbeforeX = false
                   local dZref = EMT.L3
                   if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX2RotSaw, EMT.L2 > -LimX2RotSaw) or EMT.R2 > 91) then
                      dZref = min( dSafeZ2 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ2)
                   end
+
+                  -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+                  if EMT.L3 > dZref then
+                     bMoveZbeforeX = true
+                  end
+                  if not bMoveZbeforeX then
+                     EmitMoveDataHead( 2, { X=EMT.L2, Z=MyMaxZ2, B=HomeB2, C=HomeC2, S=Speed})
+                  else
+                     EmitMoveDataHead( 2, { X=-LimX2RotSaw, Z=MyMaxZ2, B=HomeB2, C=HomeC2, S=Speed})
+                  end
+
                   -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                   if EMT.HEAD == 'H22' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC2 - EMT.R1) > 30.1 or abs( HomeB2 - EMT.R2) > 30.1) then
-                     EmitMoveDataHead( 2, { X=EMT.L2, Z=MyMaxZ2, B=0, C=HomeC2, S=Speed})
+                     EmitMoveDataHead( 2, { B=0, S=Speed})
                      EmitMoveDataHead( 2, { C=EMT.R1, S=Speed})
                      EmitMoveDataHead( 2, { Z=dZref, B=EMT.R2, S=Speed})
+                     if bMoveZbeforeX then
+                        EmitMoveDataHead( 2, { Z=EMT.L3, S=Speed})
+                     end
                   -- altrimenti caso standard
                   else
-                     EmitMoveDataHead( 2, { X=EMT.L2, Z=dZref, B=HomeB2, C=HomeC2, S=Speed})
+                     EmitMoveDataHead( 2, { Z=dZref, S=Speed})
                      EmitMoveDataHead( 2, { B=EMT.R2, S=Speed})
                      EmitMoveDataHead( 2, { C=EMT.R1, S=Speed})
                   end
@@ -1064,10 +1134,11 @@ function OnRapid()
             end
             bToPresel = false
             -- risalita a Zmax
-            EmitZmax( false, false, EMT.TO_XHOME, PrevR1, PrevR2)
+            EmitZmax( false, false, EMT.TO_XHOME, PrevR1, PrevR2, nil, true)
             EMT.ZMAX = true
             EMT.TO_ZMAX = nil
             EMT.TO_XHOME = nil
+            EMT.L1pp = nil
             EMT.L3pp = nil
             PrevR1 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'C1', 'C2'))
             PrevR2 = EgtGetAxisHomePos( EgtIf( nHSet == 1, 'B1', 'B2'))
@@ -1079,43 +1150,38 @@ function OnRapid()
          EMT.AUXCMD = {}
          -- se necessario posizionamento in home (sono sicuramente già a Zmax)
          if EMT.TO_XHOME then
-            local nHSet = GetHeadSet( EMT.HEAD)
-            local nPrevHSet = GetHeadSet( EMT.PREVHEAD)
-
-            -- se successivo non è sega a catena e la testa è la stessa, vado in home con utensile successivo
-            if not HeadIsChainSaw( EMT.HEAD) and nHSet == nPrevHSet then
-               if nHSet == 1 then
-                  local HomeX1 = EgtGetAxisHomePos( 'X1')
-                  EmitMoveDataHead( 1, { X=-HomeX1, Z=MaxZ1, B=ParkB1, C=ParkC1})
-                  EmitMoveStartHead( 1, 'EA1')
-               else
-                  local HomeX2 = EgtGetAxisHomePos( 'X2')
-                  EmitMoveDataHead( 2, { X=-HomeX2, Z=MaxZ2, B=ParkB2, C=ParkC2})
-                  EmitMoveStartHead( 2, 'EA1')
-               end
-            else
+            -- se devo andare in home, ma lo sono già, non faccio nulla
+            if not EMT.XHOME then
+               local nHSet = GetHeadSet( EMT.HEAD)
+               local nPrevHSet = GetHeadSet( EMT.PREVHEAD)
+               -- vado in parcheggio sempre con utensile precedente
                if not HeadIsChainSaw( EMT.PREVHEAD) then
                   if nPrevHSet == 1 then
                      local HomeX1 = EgtGetAxisHomePos( 'X1')
-                     EmitMoveDataHead( 1, { X=-HomeX1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)})
+                     EmitMoveDataHead( 1, { X=-EMT.PREVHOMEX_H1, Z=MaxZ1, B=ParkB1, C=ParkC1, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H1)})
                      EmitMoveStartHead( 1, 'EA1')
+                     EmitMoveWaitHead( 1)
                   else
                      local HomeX2 = EgtGetAxisHomePos( 'X2')
-                     EmitMoveDataHead( 2, { X=-HomeX2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)})
+                     EmitMoveDataHead( 2, { X=-EMT.PREVHOMEX_H2, Z=MaxZ2, B=ParkB2, C=ParkC2, TPos=AdjustTcPos( false, EMT.PREVTCPOS_H2)})
                      EmitMoveStartHead( 2, 'EA1')
+                     EmitMoveWaitHead( 2)
                   end
                else
                   if GetHeadTCSet( EMT.PREVHEAD, EMT.PREVTCPOS) == 'Head1_TC1' or GetHeadTCSet( EMT.PREVHEAD, EMT.PREVTCPOS) == 'Head1_TC2' then
                      EmitMoveDataHead( 1, { X=-ParkCSawX1S, Z=MaxZ1, B=HomeR2, C=HomeR1, TPos='50'})
                      EmitMoveStartHead( 1, 'EA1')
+                     --EmitMoveWaitHead( 1)
                   else
                      EmitMoveDataHead( 2, { X=-ParkCSawX2S, Z=MaxZ2, B=HomeR2, C=HomeR1, TPos='50'})
                      EmitMoveStartHead( 2, 'EA1')
+                     --EmitMoveWaitHead( 2)
                   end
                end
             end
 
             EMT.TO_XHOME = nil
+            EMT.L1pp = nil
             EMT.L3pp = nil
             PrevR1 = HomeR1
             PrevR2 = HomeR2
@@ -1160,23 +1226,48 @@ function OnRapid()
             if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
                -- se fresa o lama
                if not HeadIsChainSaw( EMT.HEAD) then
+                  local CurrX1 = EMT.L1pp or ( -LimX1PlRotSaw)
                   local CurrZ1 = EMT.L3pp or MyMaxZ1
                   local CurrB1 = PrevR2
                   local CurrC1 = PrevR1
+
+                  local bMoveZbeforeX = false
+                  local dZref = EMT.L3
+                  if EMT.HEAD == 'H12' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
+                     dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
+                  end
+                  -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+                  if EMT.L3 > dZref then
+                     bMoveZbeforeX = true
+                  end
+
+               -- se vado in posizione speciale rotazione assi, poi devo ritornare alla X vera di lavoro
+                  local dMoveXtoFinalPosition = false
                   local dXref = EMT.L2
                   if  EMT.HEAD == 'H12'  and  EMT.L2 < -LimX1PlRotSaw  then
                      dXref = -LimX1PlRotSaw
+                     EmitMoveDataHead( 1, { X=dXref, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
+                     dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2))
+                     dMoveXtoFinalPosition = true
+                  elseif not bMoveZbeforeX then
+                     EmitMoveDataHead( 1, { X=dXref, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
+                  else
+                     EmitMoveDataHead( 1, { X=CurrX1, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
+                     dZref = max( EMT.L3, dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2))
+                     dMoveXtoFinalPosition = true
                   end
-                  EmitMoveDataHead( 1, { X=dXref, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
-                  local dZref = EMT.L3
-                  if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or  BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
-                     dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
-                  end
+
                   -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                   if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
                      EmitMoveDataHead( 1, { B=0, S=Speed})
                      EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
                      EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
+                     if bMoveZbeforeX then
+                        EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed})
+                     end
+                     if dMoveXtoFinalPosition then
+                        EmitMoveDataHead( 1, { X=EMT.L2, S=Speed})
+                     end
                   -- altrimenti caso standard
                   else
                      EmitMoveDataHead( 1, { Z=dZref, S=Speed})
@@ -1234,24 +1325,40 @@ function OnRapid()
                if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
                   -- se fresa o lama
                   if not HeadIsChainSaw( EMT.HEAD) then
+                     local CurrX1 = EMT.L1pp or ( -LimX1PlRotSaw)
                      local CurrZ1 = EMT.L3pp or MyMaxZ1
                      local CurrB1 = PrevR2
                      local CurrC1 = PrevR1
-                     EmitMoveDataHead( 1, { X=EMT.L2, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
+
+                     local bMoveZbeforeX = false
                      local dZref = EMT.L3
-                     if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or  BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 > 91) then
+                     if EMT.HEAD == 'H12' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX1RotSaw, EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
                         dZref = min( dSafeZ1 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ1)
                      end
+                     -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+                     if EMT.L3 > dZref then
+                        bMoveZbeforeX = true
+                     end
+
+                     if not bMoveZbeforeX then
+                        EmitMoveDataHead( 1, { X=EMT.L2, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
+                     else
+                        EmitMoveDataHead( 1, { X=CurrX1, Z=CurrZ1, B=CurrB1, C=CurrC1, TRad=dTRad, TLen=dTLen, S=Speed})
+                     end
+
                      -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                      if EMT.HEAD == 'H12' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC1 - EMT.R1) > 30.1 or abs( HomeB1 - EMT.R2) > 30.1) then
                         EmitMoveDataHead( 1, { B=0, S=Speed})
                         EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
                         EmitMoveDataHead( 1, { Z=dZref, B=EMT.R2, S=Speed})
-                     -- altrimenti caso standard
+                        if bMoveZbeforeX then
+                           EmitMoveDataHead( 1, { Z=EMT.L3, S=Speed})
+                        end
+                        -- altrimenti caso standard
                      else
                         EmitMoveDataHead( 1, { Z=dZref, S=Speed})
-                        EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
                         EmitMoveDataHead( 1, { C=EMT.R1, S=Speed})
+                        EmitMoveDataHead( 1, { B=EMT.R2, S=Speed})
                      end
                   -- altrimenti sega a catena
                   else
@@ -1282,19 +1389,35 @@ function OnRapid()
                if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
                   -- se fresa o lama
                   if not HeadIsChainSaw( EMT.HEAD) then
+                     local CurrX2 = EMT.L1pp or ( -LimX2RotSaw)
                      local CurrZ2 = EMT.L3pp or MyMaxZ2
                      local CurrB2 = PrevR2
                      local CurrC2 = PrevR1
-                     EmitMoveDataHead( 2, { X=EMT.L2, Z=CurrZ2, B=CurrB2, C=CurrC2, TRad=dTRad, TLen=dTLen, S=Speed})
+
+                     local bMoveZbeforeX = false
                      local dZref = EMT.L3
-                     if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX2RotSaw, EMT.L2 > -LimX2RotSaw) or EMT.R2 > 91) then
+                     if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 > -LimX2RotSaw, EMT.L2 < -LimX2RotSaw) or EMT.R2 < -91) then
                         dZref = min( dSafeZ2 + GetZExtra( EMT.HEAD, EMT.R2) - 100, MyMaxZ2)
                      end
+                     -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+                     if EMT.L3 > dZref then
+                        bMoveZbeforeX = true
+                     end
+
+                     if not bMoveZbeforeX then
+                        EmitMoveDataHead( 2, { X=EMT.L2, Z=CurrZ2, B=CurrB2, C=CurrC2, TRad=dTRad, TLen=dTLen, S=Speed})
+                     else
+                        EmitMoveDataHead( 2, { X=CurrX2, Z=CurrZ2, B=CurrB2, C=CurrC2, TRad=dTRad, TLen=dTLen, S=Speed})
+                     end
+
                      -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                      if EMT.HEAD == 'H22' and abs( PrevR1 - EMT.R1) > 1 and ( abs( HomeC2 - EMT.R1) > 30.1 or abs( HomeB2 - EMT.R2) > 30.1) then
                         EmitMoveDataHead( 2, { B=0, S=Speed})
                         EmitMoveDataHead( 2, { C=EMT.R1, S=Speed})
                         EmitMoveDataHead( 2, { Z=dZref, B=EMT.R2, S=Speed})
+                        if bMoveZbeforeX then
+                           EmitMoveDataHead( 2, { Z=EMT.L3, S=Speed})
+                        end
                      -- altrimenti caso standard
                      else
                         EmitMoveDataHead( 2, { Z=dZref, S=Speed})
@@ -1568,6 +1691,44 @@ end
 
 ---------------------------------------------------------------------
 function OnArc()
+   -- se necessario, impostazione riferimento locale
+   if EMT.REFLOC == 0 then
+      -- gruppo della testa
+      local nHSet = GetHeadSet( EMT.HEAD)
+      -- calcolo per piano generico
+      CalcInterpPlane()
+      EMT.REFLOC = 1
+      -- salvo posizione attuale
+      local OldL1 = EMT.L1
+      local OldL2 = EMT.L2
+      local OldL3 = EMT.L3
+      -- imposto posizione precedente (non contiene l'offset in X per sovramateriale di testa EMT.X_OFF)
+      EMT.L1 = EMT.L1o
+      EMT.L2 = EMT.L2o
+      EMT.L3 = EMT.L3o
+      -- trasformo i punti nel piano
+      MyAdjustLinearAxes()
+      EmtAdjustRotaryAxes()
+      EMT.L1p = nil
+      EMT.L2p = nil
+      EMT.L3p = nil
+      local sDouFlag = EgtIf( EMT.DOU_TYPE, ' EE1', '')
+      EmtOutput( 'G142'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..EMT.IPLGLSTR..EgtIf( nHSet~=2, ' EU1', ' EU2')..sDouFlag..' EF'..GetFmaxClamp())
+      -- emissione movimento
+      local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
+                   EmtGetAxis('R2')..EmtGetAxis('R1')
+      EmtOutput( sOut)
+      -- aggiorno precedenti
+      local nOriginalMove = EMT.MOVE
+      EMT.MOVE = 0
+      EmtUpdatePrev()
+      EMT.MOVE = nOriginalMove
+      -- ripristino posizione attuale
+      EMT.L1 = OldL1
+      EMT.L2 = OldL2
+      EMT.L3 = OldL3
+   end
+
    -- non modale su archi
    EmtResetPrevLinear()
    -- aggiustamento valori
@@ -1798,6 +1959,9 @@ function PrepareMoveChar( sCmd, nInd)
          table.insert( EMT.MDCHAR, MDChar)
          EMT.Y1POS = MoveY1 or EMT.Y1POS
          EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
+         if EMT.V1POS < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then
+            EMT.TO_XHOME = true
+         end
       end
    elseif Cmd[1] == '2' then
       local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
@@ -1825,6 +1989,9 @@ function PrepareMoveChar( sCmd, nInd)
       end
       table.insert( EMT.MDCHAR, MDChar)
       EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
+      if EMT.V1POS < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then
+         EMT.TO_XHOME = true
+      end
    elseif Cmd[1] == '3' then
       local MDChar = { IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, BeamVise=EMT.BV}
       local MoveY1 = GetCmdAxMove( Cmd, 'Y1')
@@ -1851,6 +2018,9 @@ function PrepareMoveChar( sCmd, nInd)
       end
       table.insert( EMT.MDCHAR, MDChar)
       EMT.TPOS = GetCmdAxMove( Cmd, 'T') or EMT.TPOS
+      if EMT.V1POS < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then
+         EMT.TO_XHOME = true
+      end
    elseif Cmd[1] == '4' then
       -- richiesta movimento a ZMAX già gestita
       if Cmd[2] == '1' then
@@ -2085,8 +2255,11 @@ function PreparePreRotation( sCmd, nInd)
       if Cmd[2] ~= 'Z' then
          local MDChar
          if EMT.PREROT then
-            MDChar = { [Cmd[2]]=tonumber(Cmd[3]), IniStatY1=86, FinStatY1=87, IniStatY2=1, BeamVise=0}
-         elseif EMT.SPECSPLIT then
+            -- parcheggio per sicurezza morsa e paratia lato scarico
+            MDChar = { Y2=ParkY2, V2=ParkV2, IniStatY2=1, FinStatY2=1, BeamVise=0}
+            table.insert( EMT.MDCHAR, MDChar)
+            MDChar = { [Cmd[2]]=tonumber(Cmd[3]), IniStatY1=86, FinStatY1=87, BeamVise=0}
+         elseif EMT.SPECSPLIT or EMT.SPLITROT then
             MDChar = { [Cmd[2]]=tonumber(Cmd[3]), V1=ParkV1, IniStatY1=EMT.ISY1, FinStatY1=EMT.FSY1, IniStatY2=EMT.ISY2, FinStatY2=EMT.FSY2, IniStatV1=3, BeamVise=EMT.BV}
             EMT.V1POS = MDChar.V1
          else
@@ -2184,10 +2357,9 @@ function PreparePostRotation( sCmd, nInd)
    elseif Cmd[1] == '2' then
       if Cmd[2] == 'Y1' then
          -- tolgo eventuale sovramateriale presente sul pezzo in posizione iniziale (la misura laser è ora col finito)
-         local MDChar = { Y1=tonumber(Cmd[3])-EMT.HOVM, IniStatY1=75, V1=ParkV1, V2=ParkV2, FinStatY1=-1, BeamVise=0, Aux=' (E80058=0)', MovType=1}
+         local MDChar = { Y1=tonumber(Cmd[3])-EMT.HOVM, IniStatY1=75, V1=ParkV1, FinStatY1=-1, BeamVise=0, Aux=' (E80058=0)', MovType=1}
          table.insert( EMT.MDCHAR, MDChar)
          EMT.V1POS = ParkV1
-         EMT.V2POS = ParkV2
       elseif Cmd[2] == 'T' then
          local MDChar = { Y1=tonumber(Cmd[3]), IniStatY1=76, FinStatY1=EMT.FSY1, BeamVise=0, MovType=1}
          table.insert( EMT.MDCHAR, MDChar)
@@ -2530,6 +2702,9 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
    end
    -- gruppo della testa
    local nHSet = GetHeadSet( EMT.HEAD)
+   local dXPos = EgtIf( bUsePrevDelta, EMT.L2pp or EMT.L2o, EMT.L2o)
+   -- reset stato di testa in home
+   EMT.XHOME = nil
    -- se testa 1
    if nHSet == 1 then
       -- posizioni sicure
@@ -2548,13 +2723,13 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
          if not HeadIsChainSaw( EMT.HEAD) then
             -- eseguo la salita a Z1max (oriento solo se assi rotanti non già a posto)
             if abs( dSafeC1 - PrevR1) > 0.1 or abs( dSafeB1 - PrevR2) > 0.1 then
-               local dZref = dSafeZ1 + GetZExtra( EMT.HEAD, PrevR2)
-               if EgtIf( not EgtGetHeadId( 'H21') or  BD.RIGHT_LOAD, -EMT.L2o < -LimX1RotSaw, -EMT.L2o > -LimX1RotSaw) then
+               local dZref = dSafeZ1 + GetZExtra( EMT.HEAD, EgtClamp( PrevR2, -90, 90))
+               if EgtIf( BD.RIGHT_LOAD, -dXPos < -LimX1RotSaw, -dXPos > -LimX1RotSaw) then
                   dZref = dZref - EgtIf( not Mortiser, 100, 370)
                end
                dZref = min( dZref, dMaxZ1)
                local MovH = { Z = EgtIf( dZref > EMT.L3o, dZref, EMT.L3o)}
-               MovH.X = -EMT.L2o ; MovH.B = EgtClamp( PrevR2, -90, 90) ;  MovH.C = PrevR1 ;
+               MovH.X = -dXPos ; MovH.B = EgtClamp( PrevR2, -90, 90) ;  MovH.C = PrevR1 ;
                EmitMoveDataHead( 1, MovH)
                if EMT.HEAD == 'H12' and ( abs( dSafeC1 - PrevR1) > 30.1 or abs( dSafeB1 - PrevR2) > 30.1) then
                   EmitMoveDataHead( 1, { Z=dMaxZ1, B=0})
@@ -2564,10 +2739,13 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
                EmitMoveDataHead( 1, { Z=dMaxZ1})
             else
                local MovH = { Z = dMaxZ1}
-               MovH.X = -EMT.L2o ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
+               MovH.X = -dXPos ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
                EmitMoveDataHead( 1, MovH)
             end
-            if bXhome then EmitMoveDataHead( 1, { X=-dSafeX1}) end
+            if bXhome then 
+               EMT.XHOME = true
+               EmitMoveDataHead( 1, { X=-dSafeX1})
+            end
             EmitMoveStartHead( 1)
             -- se lavorazione in doppio
             if EMT.DOU_TYPE == 2 then
@@ -2577,14 +2755,15 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
          -- altrimenti sega a catena
          else
             -- ribadisco movimento perchè in G141 si aspetta sempre tutti i valori
-            local MovH = { X = -EMT.L2o, Z = EMT.L3o, B = PrevR2, C = PrevR1}
+            local MovH = { X = -dXPos, Z = EMT.L3o, B = PrevR2, C = PrevR1}
             EmitMoveDataHead( 1, MovH)
             EmitMoveDataHead( 1, { Z=dSafeZ1, B=dSafeB1})
-            if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
-               EmitMoveDataHead( 1, { Z=ParkCSawZ1, B=ParkB1})
+            if EMT.R3 and abs( EMT.R3) < 0.1 then
+               EmitMoveDataHead( 1, { Z=ParkCSawZ1})
             end
             EmitMoveDataHead( 1, { X=-dSafeX1, C=dSafeC1})
             if bXhome then
+               EMT.XHOME = true
                EmitMoveDataHead( 1, { X=-ParkX1, Z=ParkCSawZ1, B=ParkB1, C=ParkC1, TPos=50})
             end
             EmitMoveStartHead( 1)
@@ -2599,9 +2778,9 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
                local dZref = dSafeZ1 + GetZExtra( EMT.HEAD, PrevR2)
                dZref = min( dZref, dMaxZ1)
                local MovH = { Z = EgtIf( dZref > EMT.L3o, dZref, EMT.L3o)}
-               MovH.X = -EMT.L2o ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ;
+               MovH.X = -dXPos ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ;
                EmitMoveDataHead( 1, MovH)
-               if EMT.HEAD == 'H12' and ( abs( dSafeC1 - PrevR1) > 30.1 or abs( dSafeB1 - PrevR2) > 30.1) then
+               if EMT.HEAD == 'H12' and ( abs( dSafeC1 - PrevR1) > 30.1 or abs( dSafeB1 - PrevR2) > 30.1) or not( bProgress) then
                   EmitMoveDataHead( 1, { Z=dMaxZ1, B=0})
                end
                EmitMoveDataHead( 1, { C=dSafeC1})
@@ -2609,23 +2788,27 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
                EmitMoveDataHead( 1, { Z=dMaxZ1})
             else
                local MovH = { Z = dMaxZ1}
-               MovH.X = -EMT.L2o ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
+               MovH.X = -dXPos ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
                EmitMoveDataHead( 1, MovH)
             end
-            if bXhome then EmitMoveDataHead( 1, { X=-dSafeX1}) end
+            if bXhome then
+               EMT.XHOME = true
+               EmitMoveDataHead( 1, { X=-dSafeX1})
+            end
             EmitMoveStartHead( 1)
             EmitMoveWaitHead( 1)
          -- altrimenti sega a catena
          else
             -- ribadisco movimento perchè in G141 si aspetta sempre tutti i valori
-            local MovH = { X = -EMT.L2o, Z = EMT.L3o, B = PrevR2, C = PrevR1}
+            local MovH = { X = -dXPos, Z = EMT.L3o, B = PrevR2, C = PrevR1}
             EmitMoveDataHead( 1, MovH)
             EmitMoveDataHead( 1, { Z=dSafeZ1, B=dSafeB1})
-            if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
-               EmitMoveDataHead( 1, { Z=ParkCSawZ1, B=ParkB1})
+            if EMT.R3 and abs( EMT.R3) < 0.1 then
+               EmitMoveDataHead( 1, { Z=ParkCSawZ1})
             end
             EmitMoveDataHead( 1, { X=-dSafeX1, C=dSafeC1})
             if bXhome then
+               EMT.XHOME = true
                EmitMoveDataHead( 1, { X=-ParkX1, Z=ParkCSawZ1, B=ParkB1, C=ParkC1, TPos=50})
             end
             EmitMoveStartHead( 1)
@@ -2652,7 +2835,7 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
             local dZref = dSafeZ2 + GetZExtra( EMT.HEAD, PrevR2)
             dZref = min( dZref, dMaxZ2)
             local MovH = { Z = EgtIf( dZref > EMT.L3o, dZref, EMT.L3o)}
-            MovH.X = -EMT.L2o ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ;
+            MovH.X = -dXPos ; MovH.B = EgtClamp( PrevR2, -90, 90) ; MovH.C = PrevR1 ;
             EmitMoveDataHead( 2, MovH)
             if EMT.HEAD == 'H22' and ( abs( dSafeC2 - PrevR1) > 30.1 or abs( dSafeB2 - PrevR2) > 30.1) then
                EmitMoveDataHead( 2, { Z=dMaxZ2, B=0})
@@ -2662,23 +2845,27 @@ function EmitZmax( bReset, bEnd, bXhome, PrevR1, PrevR2, bSplitCut, bUsePrevDelt
             EmitMoveDataHead( 2, { Z=dMaxZ2})
          else
             local MovH = { Z = dMaxZ2}
-            MovH.X = -EMT.L2o ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
+            MovH.X = -dXPos ; MovH.B = PrevR2 ; MovH.C = PrevR1 ;
             EmitMoveDataHead( 2, MovH)
          end
-         if bXhome then EmitMoveDataHead( 2, { X=-dSafeX2}) end
+         if bXhome then
+            EMT.XHOME = true
+            EmitMoveDataHead( 2, { X=-dSafeX2})
+         end
          EmitMoveStartHead( 2)
          EmitMoveWaitHead( 2)
       -- altrimenti sega a catena
       else
          -- ribadisco movimento perchè in G141 si aspetta sempre tutti i valori
-         local MovH = { X = -EMT.L2o, Z = EMT.L3o, B = PrevR2, C = PrevR1}
+         local MovH = { X = -dXPos, Z = EMT.L3o, B = PrevR2, C = PrevR1}
          EmitMoveDataHead( 2, MovH)
          EmitMoveDataHead( 2, { Z=dSafeZ2, B=dSafeB2})
-         if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
-            EmitMoveDataHead( 2, { Z=ParkCSawZ2, B=ParkB2})
+         if EMT.R3 and abs( EMT.R3) < 0.1 then
+            EmitMoveDataHead( 2, { Z=ParkCSawZ2})
          end
          EmitMoveDataHead( 2, { X=-dSafeX2, C=dSafeC2})
          if bXhome then
+            EMT.XHOME = true
             EmitMoveDataHead( 2, { X=-ParkX2, Z=ParkCSawZ2, B=ParkB2, C=ParkC2, TPos=50})
          end
          EmitMoveStartHead( 2)
@@ -2775,12 +2962,26 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
       local DiffY2 = MyParkY2 - dPosY2
       --EmtOutput( string.format( 'PosT=%.3f DiffY1=%.3f DiffY2=%.3f', dPosT, DiffY1, DiffY2))
       if bSplitCut then
+         local bYNoMove, bVNoMove
          if DiffY1 > 0.1  then
+            bYNoMove = false
             MDChar.Y1 = dPosY1 + DiffY1
+         else
+            bYNoMove = true
+            MDChar.Y1 = dPosY1
          end
          if DiffY2 < -0.1 then
+            bVNoMove = false
             MDChar.Y2 = dPosY2 + DiffY2
             dPosT = dPosT + DiffY2
+         else
+            bVNoMove = true
+            MDChar.Y2 = dPosY2
+         end
+         -- se entrambe le morse sono restate in posizione, le sposto comunque di 5mm per distanziare i pezzi separati
+         if bYNoMove and bVNoMove then
+            MDChar.Y1 = MDChar.Y1 + 5
+            MDChar.Y2 = MDChar.Y2 - 5
          end
       elseif DiffY1 > 0.1 and DiffY2 < -0.1 then
          EmtSetLastError( 1201, 'Error Collision in ParkRoller')
@@ -2808,7 +3009,7 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
       local dPosY1 = dPosT + dY1Delta
       local DiffY1 = MyParkY1 - dPosY1
       local dMoveY1 = EgtIf( DiffY1 > 0.1, dMoveV1, 0)
-      local dTryMoveY1 = ParkV1 - dPosT - EgtIf( bSplitCut or EMT.FALL, EMT.LT, 0)
+      local dTryMoveY1 = min( ParkV1 - dPosT - EgtIf( bSplitCut or EMT.FALL, EMT.LT, 0), MaxY1 - dPosY1 - 10)
       if ( dPosT > ParkV2 - ExtraParkV and dPosT < ParkV1 and dPosY1 + dTryMoveY1 < MaxY1) then dMoveY1 = max( dMoveY1, dTryMoveY1) end
       MDChar.Y1 = dPosY1 + dMoveY1
       MDChar.MovType = 1
@@ -2819,7 +3020,7 @@ function EmitParkRoller( dPosT, bSplitCut, bUsePrevDelta)
       local dPosY2 = dPosT + dY2Delta
       local DiffY2 = MyParkY2 - dPosY2
       local dMoveY2 = EgtIf( DiffY2 < -0.1, dMoveV2, 0)
-      local dTryMoveY2 = ParkV2 - dPosT - EMT.LT - EMT.DELTA_LT - EMT.HOVM
+      local dTryMoveY2 = max( ParkV2 - dPosT - EMT.LT - EMT.DELTA_LT - EMT.HOVM, MinY2 - dPosY2 + 10)
       if ( dPosT + EMT.LT + EMT.DELTA_LT + EMT.HOVM < ParkV1 + ExtraParkV and dPosT + EMT.LT + EMT.DELTA_LT  + EMT.HOVM > ParkV2 and dPosY2 + dTryMoveY2 > MinY2) then dMoveY2 = min( dMoveY2, dTryMoveY2) end
       MDChar.Y2 = dPosY2 + dMoveY2
       MDChar.MovType = 2
@@ -2881,11 +3082,11 @@ function PreselectNextDiffHead( nMchId, sHead)
          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 EMT.PREVHEAD ~= 'H13' then
+            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 EMT.PREVHEAD ~= 'H23' then
+            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)
@@ -3085,12 +3286,12 @@ end
 function EmitBeamHeadData( BhData)
    if not BhData.Pz5 then
    local sOut = 'G152'
-   if BhData.T then sOut = sOut .. ' Y' .. EmtLenToString( BhData.T, 3) end
-   if BhData.Y1 then sOut = sOut .. ' EY' .. EmtLenToString( BhData.Y1, 3) end
-   if BhData.Y2 then sOut = sOut .. ' EV' .. EmtLenToString( BhData.Y2, 3) end
-   if BhData.V1 then sOut = sOut .. ' B' .. EmtLenToString( BhData.V1, 3) end
-   if BhData.V2 then sOut = sOut .. ' C' .. EmtLenToString( BhData.V2, 3) end
-         if BhData.W then sOut = sOut .. ' EW' .. EmtLenToString( BhData.W, 3) end
+      if BhData.T then sOut = sOut .. ' Y' .. EmtLenToString( BhData.T, 3) end
+      if BhData.Y1 then sOut = sOut .. ' EY' .. EmtLenToString( BhData.Y1, 3) end
+      if BhData.Y2 then sOut = sOut .. ' EV' .. EmtLenToString( BhData.Y2, 3) end
+      if BhData.V1 then sOut = sOut .. ' B' .. EmtLenToString( BhData.V1, 3) end
+      if BhData.V2 then sOut = sOut .. ' C' .. EmtLenToString( BhData.V2, 3) end
+      if BhData.W then sOut = sOut .. ' EW' .. EmtLenToString( BhData.W, 3) end
       if BhData.ViseY1 then sOut = sOut .. ' EA' .. EgtNumToString( BhData.ViseY1, 0) end
       if BhData.ViseY2 then sOut = sOut .. ' EB' .. EgtNumToString( BhData.ViseY2, 0) end
       if BhData.SetHead then sOut = sOut .. ' EC' .. EgtNumToString( BhData.SetHead, 0) end

Common_ONE-PF.mlpe

@@ -119,6 +119,8 @@ function OnSimulStart()
                      { Grp = 'Base', Sub = 'COLLISION', Name = 'TRAV'},
                      { Grp = 'Base', Sub = 'COLLISION', Name = 'COL1'},
                      { Grp = 'Base', Sub = 'COLLISION', Name = 'COL2'},
+                     { Grp = 'Base', Sub = 'COLLISION', Name = 'TC1'},
+                     { Grp = 'Base', Sub = 'COLLISION', Name = 'TC2'},
                      { Grp = 'Base', Sub = 'BELT', Name = 'COLLISION'}}
    -- gruppo CHSAW si attiva solo se progress, one con BIT mortiser o PF
    if Progress or Mortiser or EgtGetHeadId( 'H21') then
@@ -132,6 +134,10 @@ function OnSimulStart()
    if Progress and EgtGetHeadId( 'H21') then
       table.insert( McdData, { Grp = 'Base', Sub = 'COLLISION', Name = 'SAW1'})
    end
+   -- se non è Progress ed è una ONE, aggiungo collisioni magazzino speciale
+   if not Progress and not EgtGetHeadId( 'H21') then
+      table.insert( McdData, { Grp = 'Base', Sub = 'COLLISION', Name = 'MTC'})
+   end
 
    if Clamp5 then
       table.insert( McdData, { Grp = 'W', Sub = 'COLLISION', Name = 'STM1'})
@@ -345,6 +351,8 @@ function OnSimulDispositionStart()
          else
             EgtOutText( 'Barra non ruotata')
          end
+         -- forzo apertura rulli in caso fossero chiusi. Altrimenti all'apertura nell OnSimulMoveStart sposterebbe anche la trave
+         ExecParkRoller( nil, nil, nil, nil, nil, nil)
       end
       -- eseguo aggancio
       local nRawId = EgtGetFirstRawPart()
@@ -954,6 +962,7 @@ function OnSimulMoveStart()
    VerifyY2Stroke( EMT.A2)
    VerifyV1Stroke( EMT.A3)
    VerifyV2Stroke( EMT.A4)
+   
    -- se devo subito parcheggiare i rulli
    local nRes = 0
    if bParkV then
@@ -965,6 +974,12 @@ function OnSimulMoveStart()
    end
    -- se movimento in rapido ad inizio lavorazione
    if EMT.MOVE == 0 and EMT.MOVEIND <= 3 then
+      -- gestione speciale per pezzi molto alti. Se il movimento successivo è più alto del precedente, allora prendo il successivo
+      if EMT.L3s then
+         if EMT.L3s > EMT.L3 then
+            EMT.L3 = EMT.L3s
+         end
+      end
       -- Dati
       local B1Pos = EgtGetAxisPos( 'B1')
       local B1Home = EgtGetAxisHomePos( 'B1')
@@ -979,20 +994,44 @@ function OnSimulMoveStart()
             -- se movimento iniziale da Zmax con lama o fresa
             if EMT.ZMAX or EMT.FLAG == 1 or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
                --EgtOutBox( 'Flag 2,1', 'Info Rapid')
+               local bMoveZbeforeX = false
+               
+               local dZref = EMT.L3
+               if EMT.HEAD == 'H12' and ( EgtIf( BD.RIGHT_LOAD, -EMT.L2 < -LimX1RotSaw, -EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
+                  dZref = Z1Home + GetZExtra( EMT.HEAD, EMT.R2) - 100
+               end
+               -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+               if EMT.L3 > dZref then
+                  bMoveZbeforeX = true
+               end
+
+               -- se vado in posizione speciale rotazione assi, poi devo ritornare alla X vera di lavoro
+               local dMoveXtoFinalPosition = false
                local dXref = EMT.L2
                if  EMT.HEAD == 'H12' and  -EMT.L2 < -LimX1PlRotSaw  then
                   dXref = LimX1PlRotSaw
+                  SimulMoveAxis( 'X1', dXref, MCH_SIM_STEP.RAPID)
+                  dZref = max( EMT.L3, Z1Home + GetZExtra( EMT.HEAD, EMT.R2))
+                  dMoveXtoFinalPosition = true
+               elseif not bMoveZbeforeX then
+                  SimulMoveAxis( 'X1', dXref, MCH_SIM_STEP.RAPID)
+               else
+                  SimulMoveAxis( 'X1', LimX1PlRotSaw, MCH_SIM_STEP.RAPID)
+                  dZref = max( EMT.L3, Z1Home + GetZExtra( EMT.HEAD, EMT.R2))
+                  dMoveXtoFinalPosition = true
                end
-               SimulMoveAxis( 'X1', dXref, MCH_SIM_STEP.RAPID)
-               local dZref = EMT.L3
-               if EMT.HEAD == 'H12' and ( EgtIf( not EgtGetHeadId( 'H21') or  BD.RIGHT_LOAD, -EMT.L2 < -LimX1RotSaw, -EMT.L2 > -LimX1RotSaw) or EMT.R2 < -91) then
-                  dZref = Z1Home + GetZExtra( EMT.HEAD, EMT.R2) - 100
-               end
+
                -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                if EMT.HEAD == 'H12' and abs( C1Pos - EMT.R1) > 1 and ( abs( C1Home - EMT.R1) > 30.1 or abs(B1Home - EMT.R2) > 30.1) then
                   SimulMoveAxis( 'B1', 0, MCH_SIM_STEP.COLLROT)
                   SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
                   SimulMoveAxes( 'Z1', dZref, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+                  if bMoveZbeforeX then
+                     SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID)
+                  end
+                  if dMoveXtoFinalPosition then
+                     SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
+                  end
                -- caso standard
                else
                   SimulMoveAxis( 'Z1', dZref, MCH_SIM_STEP.RAPID)
@@ -1036,21 +1075,34 @@ function OnSimulMoveStart()
             if EMT.HEAD == 'H11' or EMT.HEAD == 'H12' then
                if EMT.ZMAX or EMT.FLAG == 1 or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
                   --EgtOutBox( 'Flag 2,1', 'Info Rapid')
-                  SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
+                  local bMoveZbeforeX = false
+
                   local dZref = EMT.L3
                   if EMT.HEAD == 'H12' and ( -EMT.L2 < -LimX1RotSaw or EMT.R2 > 91) then
                      dZref = Z1Home + GetZExtra( EMT.HEAD, EMT.R2) - 100
                   end
+                  -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+                  if EMT.L3 > dZref then
+                     bMoveZbeforeX = true
+                  end
+                  if not bMoveZbeforeX then
+                     SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
+                  else
+                     SimulMoveAxis( 'X1', LimX1RotSawTC2, MCH_SIM_STEP.RAPID)
+                  end
                   -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 400")
                   if EMT.HEAD == 'H12' and abs( C1Pos - EMT.R1) > 1 and ( abs( C1Home - EMT.R1) > 30.1 or abs(B1Home - EMT.R2) > 30.1) then
                      SimulMoveAxis( 'B1', 0, MCH_SIM_STEP.COLLROT)
                      SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
                      SimulMoveAxes( 'Z1', dZref, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
+                     if bMoveZbeforeX then
+                        SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID)
+                     end
                   -- caso standard
                   else
                      SimulMoveAxis( 'Z1', dZref, MCH_SIM_STEP.RAPID)
-                     SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
                      SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
+                     SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
                   end
                end
             -- altrimenti sega a catena (H13 o H15)
@@ -1095,16 +1147,28 @@ function OnSimulMoveStart()
                -- se movimento iniziale da Zmax con lama o fresa
                if EMT.ZMAX or EMT.FLAG == 1 or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
                   --EgtOutBox( 'Flag 2,1', 'Info Rapid')
-                  SimulMoveAxis( 'X2', EMT.L2, MCH_SIM_STEP.RAPID)
+                  local bMoveZbeforeX = false
                   local dZref = EMT.L3
                   if EMT.HEAD == 'H22' and ( EgtIf( BD.RIGHT_LOAD, EMT.L2 < -LimX2RotSaw, EMT.L2 > -LimX2RotSaw) or EMT.R2 > 91) then
                      dZref = Z2Home + GetZExtra( EMT.HEAD, EMT.R2) - 100
+                  end                  
+                  -- se la quota di lavoro è più in alta della posizione a ZHOME della testa, prima si va alla Z di lavoro e poi si approccia il pezzo
+                  if EMT.L3 > dZref then
+                     bMoveZbeforeX = true
+                  end
+                  if not bMoveZbeforeX then
+                     SimulMoveAxis( 'X2', EMT.L2, MCH_SIM_STEP.RAPID)
+                  else
+                     SimulMoveAxis( 'X2', LimX2RotSaw, MCH_SIM_STEP.RAPID)
                   end
                   -- caso speciale per trave alta con rotazione lama pericolosa (tolto "and EMT.SB > 379")
                   if EMT.HEAD == 'H22' and abs( C2Pos - EMT.R1) > 1 and ( abs( C2Home - EMT.R1) > 30.1 or abs(B2Home - EMT.R2) > 30.1) then
                      SimulMoveAxis( 'B2', 0, MCH_SIM_STEP.COLLROT)
                      SimulMoveAxis( 'C2', EMT.R1, MCH_SIM_STEP.COLLROT)
                      SimulMoveAxes( 'Z2', dZref, MCH_SIM_STEP.RAPID, 'B2', EMT.R2, MCH_SIM_STEP.COLLROT)
+                     if bMoveZbeforeX then
+                        SimulMoveAxis( 'Z2', EMT.L3, MCH_SIM_STEP.RAPID)
+                     end
                   -- caso standard
                   else
                      SimulMoveAxis( 'Z2', dZref, MCH_SIM_STEP.RAPID)
@@ -1209,6 +1273,7 @@ function OnSimulMoveStart()
       EMT.A4 = EgtIf( GetV2ToClose(), EMT.V2NEXTPOS, ParkV2)
    end
    EMT.ZMAX = nil
+   EMT.XHOME = nil
 end
 
 ---------------------------------------------------------------------
@@ -1317,6 +1382,10 @@ function ExecAuxCmd( sCmd, bPathStart)
          ExecOpenRoller( 1)
          ExecOpenRoller( 2)
          local sV1, MoveV1, sV2, MoveV2 = CalcMoveV1V2ForAuxCmd( Cmd)
+         -- se stringo i rulli e ho lama, verifico che sia in home
+         if MoveV1 and MoveV1 < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then
+            ExecMoveZmax( false, true)
+         end
          local bOk, bOk1, bOk2, bOk3 = SimulMoveAxes( Cmd[2], tonumber( Cmd[3]), MCH_SIM_STEP.RAPID,
                                                       sV1, MoveV1, MCH_SIM_STEP.RAPID,
                                                       sV2, MoveV2, MCH_SIM_STEP.RAPID)
@@ -1339,6 +1408,10 @@ function ExecAuxCmd( sCmd, bPathStart)
       ExecOpenRoller( 1)
       ExecOpenRoller( 2)
       local sV1, MoveV1, sV2, MoveV2 = CalcMoveV1V2ForAuxCmd( Cmd)
+      -- se stringo i rulli e ho lama, verifico che sia in home
+      if MoveV1 and MoveV1 < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then
+         ExecMoveZmax( false, true)
+      end
       local bOk, bOk1, bOk2, bOk3, bOk4 =  SimulMoveAxes( Cmd[2], tonumber( Cmd[3]), MCH_SIM_STEP.RAPID,
                                                           Cmd[4], tonumber( Cmd[5]), MCH_SIM_STEP.RAPID,
                                                           sV1, MoveV1, MCH_SIM_STEP.RAPID,
@@ -1362,6 +1435,10 @@ function ExecAuxCmd( sCmd, bPathStart)
       ExecOpenRoller( 1)
       ExecOpenRoller( 2)
       local sV1, MoveV1, sV2, MoveV2 = CalcMoveV1V2ForAuxCmd( Cmd)
+      -- se stringo i rulli e ho lama, verifico che sia in home
+      if MoveV1 and MoveV1 < 400 and ( EMT.HEAD == 'H12' or EMT.HEAD == 'H22') and EMT.ZMAX and not EMT.XHOME then
+         ExecMoveZmax( false, true)
+      end
       local bOk, bOk1, bOk2, bOk3, bOk4, bOk5 = SimulMoveAxes( Cmd[2], tonumber( Cmd[3]), MCH_SIM_STEP.RAPID,
                                                                Cmd[4], tonumber( Cmd[5]), MCH_SIM_STEP.RAPID,
                                                                Cmd[6], tonumber( Cmd[7]), MCH_SIM_STEP.RAPID,
@@ -1542,8 +1619,8 @@ function ExecMoveZmax( bMchSplit, btoXHome)
       if GetHeadTCSet( EMT.HEAD, EMT.TCPOS) == 'Head1_TC1' then
          if not HeadIsChainSaw( EMT.HEAD) then
             if abs( HomeC - CurrC) > 0.1 or abs( HomeB - CurrB) > 0.1 then
-               local dZref = HomeZ + GetZExtra( EMT.HEAD, CurrB)
-               if EgtIf( not EgtGetHeadId( 'H21') or  BD.RIGHT_LOAD, -CurrX < -LimX1RotSaw, -CurrX > -LimX1RotSaw) then
+               local dZref = HomeZ + GetZExtra( EMT.HEAD, EgtClamp( CurrB, -90, 90))
+               if EgtIf( BD.RIGHT_LOAD, -CurrX < -LimX1RotSaw, -CurrX > -LimX1RotSaw) then
                   dZref = dZref - EgtIf( not Mortiser, 100, 370)
                end
                SimulMoveAxes( 'Z1', EgtIf( dZref > CurrZ, dZref, CurrZ), MCH_SIM_STEP.RAPID, 'B1', EgtClamp( CurrB, -90, 90), MCH_SIM_STEP.COLLROT)
@@ -1555,6 +1632,7 @@ function ExecMoveZmax( bMchSplit, btoXHome)
             end
             SimulMoveAxis( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID)
             if btoXHome then
+               EMT.XHOME = true
                SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID)
             end
             -- se lavorazione in doppio
@@ -1566,6 +1644,7 @@ function ExecMoveZmax( bMchSplit, btoXHome)
                SimulMoveAxes( 'B2', ParkB2, MCH_SIM_STEP.COLLROT, 'C2', ParkC2, MCH_SIM_STEP.COLLROT)
                SimulMoveAxis( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID)
                if bToXHome then 
+                  EMT.XHOME = true
                   SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID)
                end
                EMT.DOU_TO_ZMAX = nil
@@ -1573,8 +1652,8 @@ function ExecMoveZmax( bMchSplit, btoXHome)
          -- altrimenti sega a catena
          else
             SimulMoveAxes( 'Z1', HomeZ, MCH_SIM_STEP.RAPID, 'B1', HomeB, MCH_SIM_STEP.COLLROT)
-            if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
-               SimulMoveAxes( 'Z1', ParkCSawZ1, MCH_SIM_STEP.RAPID, 'B1', ParkB1, MCH_SIM_STEP.COLLROT)
+            if EMT.R3 and abs( EMT.R3) < 0.1 then
+               SimulMoveAxis( 'Z1', ParkCSawZ1, MCH_SIM_STEP.RAPID)
             end
             SimulMoveAxes( 'X1', HomeX, MCH_SIM_STEP.RAPID, 'C1', HomeC, MCH_SIM_STEP.COLLROT)
          end
@@ -1584,7 +1663,7 @@ function ExecMoveZmax( bMchSplit, btoXHome)
             if abs( HomeC - CurrC) > 0.1 or abs( HomeB - CurrB) > 0.1 then
                local dZref = HomeZ + GetZExtra( EMT.HEAD, CurrB)
                SimulMoveAxes( 'Z1', EgtIf( dZref > CurrZ, dZref, CurrZ), MCH_SIM_STEP.RAPID, 'B1', EgtClamp( CurrB, -90, 90), MCH_SIM_STEP.COLLROT)
-               if EMT.HEAD == 'H12' and ( abs( HomeC - CurrC) > 30.1 or abs( HomeB - CurrB) > 30.1) then
+               if EMT.HEAD == 'H12' and ( abs( HomeC - CurrC) > 30.1 or abs( HomeB - CurrB) > 30.1) or not( bProgress) then
                   SimulMoveAxes( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID, 'B1', 0, MCH_SIM_STEP.COLLROT)
                end
                SimulMoveAxis( 'C1', HomeC, MCH_SIM_STEP.COLLROT)
@@ -1592,13 +1671,14 @@ function ExecMoveZmax( bMchSplit, btoXHome)
             end
             SimulMoveAxis( 'Z1', MaxZ1, MCH_SIM_STEP.RAPID)
             if btoXHome then
+               EMT.XHOME = true
                SimulMoveAxis( 'X1', ParkX1, MCH_SIM_STEP.RAPID)
             end
          -- altrimenti sega a catena
          else
             SimulMoveAxes( 'Z1', HomeZ, MCH_SIM_STEP.RAPID, 'B1', HomeB, MCH_SIM_STEP.COLLROT)
-            if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
-               SimulMoveAxes( 'Z1', ParkCSawZ1, MCH_SIM_STEP.RAPID, 'B1', ParkB1, MCH_SIM_STEP.COLLROT)
+            if EMT.R3 and abs( EMT.R3) < 0.1 then
+               SimulMoveAxis( 'Z1', ParkCSawZ1, MCH_SIM_STEP.RAPID)
             end
             if btoXHome then
                EgtUnloadTool( EMT.HEAD, 1)
@@ -1607,6 +1687,7 @@ function ExecMoveZmax( bMchSplit, btoXHome)
                EMT.PREVHEAD_H1 = nil
                EMT.PREVTCPOS_H1 = nil
                EMT.CHSAW_OUT = true
+               EMT.XHOME = true
             end
             SimulMoveAxes( 'X1', HomeX, MCH_SIM_STEP.RAPID, 'C1', HomeC, MCH_SIM_STEP.COLLROT)
          end
@@ -1627,13 +1708,14 @@ function ExecMoveZmax( bMchSplit, btoXHome)
          end
          SimulMoveAxis( 'Z2', MaxZ2, MCH_SIM_STEP.RAPID)
          if btoXHome then
+            EMT.XHOME = true
             SimulMoveAxis( 'X2', ParkX2, MCH_SIM_STEP.RAPID)
          end
    -- altrimenti sega a catena
       else
          SimulMoveAxes( 'Z2', HomeZ, MCH_SIM_STEP.RAPID, 'B2', HomeB, MCH_SIM_STEP.COLLROT)
-         if EMT.SB > 650 and abs( EMT.R3) < 0.1 then
-            SimulMoveAxes( 'Z2', ParkCSawZ2, MCH_SIM_STEP.RAPID, 'B2', ParkB2, MCH_SIM_STEP.COLLROT)
+         if EMT.R3 and abs( EMT.R3) < 0.1 then
+            SimulMoveAxis( 'Z2', ParkCSawZ2, MCH_SIM_STEP.RAPID)
          end
          SimulMoveAxes( 'X2', HomeX, MCH_SIM_STEP.RAPID, 'C2', HomeC, MCH_SIM_STEP.COLLROT)
       end
@@ -1762,8 +1844,16 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg)
       local DiffY2 = MyParkY2 - PosY2
       -- se appena eseguito taglio di separazione
       if bSpliCut then
-         local MoveY1 = max( DiffY1, 0.0)
-         local MoveY2 = min( DiffY2, 0.0)
+         -- se entrambe le morse sono restate in posizione, le sposto comunque di 5mm per distanziare i pezzi separati
+         local dAddMove
+         if DiffY1 > 0.1 and DiffY2 < -0.1 then
+            dAddMove = 0
+         else
+            dAddMove = 5
+         end
+         local MoveY1 = max( DiffY1, 0.0 + dAddMove)
+         local MoveY2 = min( DiffY2, 0.0 - dAddMove)
+
          -- aggancio i pezzi rimanenti all'asse Y1
          LinkRemainingPartsToY1()
          -- eseguo i movimenti
@@ -1811,7 +1901,7 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg)
       local MoveV1 = ParkV1 - PosV1
       local DiffY1 = MyParkY1 - PosY1
       local MoveY1 = EgtIf( DiffY1 > 0.1, MoveV1, 0)
-      local TryMoveY1 = ParkV1 - PosT - EgtIf( bSpliCut or EMT.FALL, EMT.LT, 0) - EMT.HOVM
+      local TryMoveY1 = min( ParkV1 - PosT - EgtIf( bSpliCut or EMT.FALL, EMT.LT, 0) - EMT.HOVM, MaxY1 - PosY1 - 10)
       if ( PosT > ParkV2 - ExtraParkV and PosT < ParkV1 and PosY1 + TryMoveY1 < MaxY1 and not EMT.W2DELTA) then MoveY1 = max( MoveY1, TryMoveY1) end
       -- se appena eseguito taglio di separazione
       if bSpliCut then
@@ -1841,7 +1931,7 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg)
       local MoveV2 = ParkV2 - PosV2
       local DiffY2 = MyParkY2 - PosY2
       local MoveY2 = EgtIf( DiffY2 < -0.1, MoveV2, 0)
-      local TryMoveY2 = ParkV2 - PosT - EMT.LT - EMT.DELTA_LT - EMT.HOVM
+      local TryMoveY2 = max( ParkV2 - PosT - EMT.LT - EMT.DELTA_LT - EMT.HOVM, MinY2 - PosY2 + 10)
       if ( PosT + EMT.LT + EMT.DELTA_LT + EMT.HOVM < ParkV1 + ExtraParkV and PosT + EMT.LT + EMT.DELTA_LT + EMT.HOVM > ParkV2 and PosY2 + TryMoveY2 > MinY2) then MoveY2 = min( MoveY2, TryMoveY2) end
       if not SimulMoveAxes( 'T',  PosT + MoveY2, MCH_SIM_STEP.RAPID,
                             'V1', ParkV1, MCH_SIM_STEP.RAPID,

Common_ONE-PF.mlse

@@ -73,7 +73,7 @@ function OnSpecialGetMaxZ()
          EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
       end
    elseif EMC.HEAD == 'H12' and sHead_TC == 'Head1_TC1' then
-      if vtTp:getX() > 0.3 and vtT:getX() > 0.3 then
+      if vtTp:getX() > 0.4 and vtT:getX() > 0.4 then
          if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then
             EMC.MAXZ = MaxZ1 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130)
          elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then
@@ -95,7 +95,7 @@ function OnSpecialGetMaxZ()
          EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
       end
    elseif EMC.HEAD == 'H12' and sHead_TC == 'Head1_TC2' then
-      if vtTp:getX() > 0.3 and vtT:getX() > 0.3 then
+      if vtTp:getX() > 0.4 and vtT:getX() > 0.4 then
          if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then
             EMC.MAXZ = MaxZ1 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130)
          elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then
@@ -124,7 +124,7 @@ function OnSpecialGetMaxZ()
          EMC.MAXZ = ParkZ2 + CalcExtraZ( vtTpZm, vtT, vMZ)
       end
    elseif EMC.HEAD == 'H22' then
-      if vtTp:getX() > 0.3 and vtT:getX() > 0.3 then
+      if vtTp:getX() > 0.4 and vtT:getX() > 0.4 then
          if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then
             EMC.MAXZ = MaxZ2 - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130)
          elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then
@@ -824,6 +824,13 @@ end
 
 ---------------------------------------------------------------------
 function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload, bPreRotMch)
+   -- mi salvo info lavorazione su una lista
+   local AuxInfoMach = {}
+   AuxInfoMach.bPreSplit = bPreSplit
+   AuxInfoMach.bSplitting = bSplitting
+   AuxInfoMach.bPreCut = bPreCut
+   AuxInfoMach.bCutting = bCutting
+   AuxInfoMach.bUnload = bUnload
 
    -- Assegno flag di pezzo separato dal resto del grezzo
    SPLIT = IsEndPhase( EMC.PHASE) or IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE)
@@ -921,7 +928,7 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload, bPreR
       local dPosT = LoadT
       if IsFirstMachiningAfterRotation( EMC.MCHID) then dPosT = dPosT + TurnerOffs end
       local vCmd = SpecCalcLoad( dPosT, dDistFront, max( dDistBack, MinJoin + EgtIf( SPLIT, EMC.TCING, 0), EMC.LB - ( MaxY1 - MinY1) + 6))
-      local vCmd2 = SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1DeltaMaxSP, dY2DeltaMinUL, nChar)
+      local vCmd2 = SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1DeltaMaxSP, dY2DeltaMinUL, nChar, AuxInfoMach)
       if bSplitting and EMC.ERR == 18 then
          table.insert( vCmd, { 22, dRollBack, -dRollFront})
       end
@@ -934,7 +941,7 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload, bPreR
 
    -- Se altrimenti carri entrambi diponibili, eseguo calcoli per carrelli
    elseif not IsEndPhase( EMC.PHASE) then
-      local vCmd = SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1DeltaMaxSP, dY2DeltaMinUL, nChar)
+      local vCmd = SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1DeltaMaxSP, dY2DeltaMinUL, nChar, AuxInfoMach)
       -- Se non ci sono spostamenti, confermo i parametri di aggancio e di posizione roller
       if SpecTestOnlyRemarkInCmds( vCmd) then
          table.insert( vCmd, { 21, EgtIf( EMC.Y1DELTA, EMC.Y1DELTA, 0), EgtIf( EMC.Y2DELTA, EMC.Y2DELTA, 0)})
@@ -1262,7 +1269,7 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack)
 end -- SpecAdjustLoad [L]
 
 ---------------------------------------------------------------------
-function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1DeltaMaxSP, dY2DeltaMinUL, nChar)
+function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1DeltaMaxSP, dY2DeltaMinUL, nChar, AuxInfoMach)
 
    local MinFrontJoin = MinJoin + EMC.HCING + EMC.HOVM
    local MyMinOther = MinOther + EgtIf( EMC.CNT == 1, AggLoad, 0) 
@@ -1301,13 +1308,11 @@ function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1Del
       WorkTab.dV2PosF = -dRollFront
       WorkTab.bV2CloseF = false
 
-      -- aggiuntivo per non avere problemi con pezzi a caduta
-      if WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 5 * BD.CHAR_EXTRA_DIST then
-         WorkTab.dY1DeltaMinF = WorkTab.dY1DeltaMinF + 4 * BD.CHAR_EXTRA_DIST
-      elseif WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 2.5 * BD.CHAR_EXTRA_DIST then
-         WorkTab.dY1DeltaMinF = WorkTab.dY1DeltaMinF + 2 * BD.CHAR_EXTRA_DIST
-      elseif WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 1.5 * BD.CHAR_EXTRA_DIST then
-         WorkTab.dY1DeltaMinF = WorkTab.dY1DeltaMinF + BD.CHAR_EXTRA_DIST
+      -- 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)
+         end
       end
 
       -- verifico validità intervallo ammesso per Y1
@@ -1346,13 +1351,11 @@ function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1Del
       WorkTab.dV2PosF = -dRollFront
       WorkTab.bV2CloseF = false
 
-      -- aggiuntivo per minimizzare scambi carrelli
-      if WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 5 * BD.CHAR_EXTRA_DIST then
-         WorkTab.dY1DeltaMinF = WorkTab.dY1DeltaMinF + 4 * BD.CHAR_EXTRA_DIST
-      elseif WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 2.5 * BD.CHAR_EXTRA_DIST then
-         WorkTab.dY1DeltaMinF = WorkTab.dY1DeltaMinF + 2 * BD.CHAR_EXTRA_DIST
-      elseif WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 1.5 * BD.CHAR_EXTRA_DIST then
-         WorkTab.dY1DeltaMinF = WorkTab.dY1DeltaMinF + BD.CHAR_EXTRA_DIST
+      -- 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)
+         end
       end
 
       -- verifico validità intervallo ammesso per Y1
@@ -1829,7 +1832,7 @@ local function MaxDispl( TabI, vCmd, sType)
      -- allontano (Y1+T) e (Y2)
       dY1a = MaxY1
       dY2a = MinY2
-      dTa = ( MaxY1 - TabI.dY1PosI) + dTa 
+      dTa = ( dY1a - TabI.dY1PosI) + dTa 
    -- **[M2]** = allontanamento dei trascinatori con Y2 in presa
    elseif sType == 'M2'   then
       EmitComment( vCmd, '[M2]')
@@ -1840,7 +1843,7 @@ local function MaxDispl( TabI, vCmd, sType)
       -- allontano (Y2+T) e (Y1)
       dY1a = MaxY1
       dY2a = MinY2
-      dTa = ( MinY2 - TabI.dY2PosI) + dTa 
+      dTa = ( dY2a - TabI.dY2PosI) + dTa 
    -- **[M3]** = accentramento dei trascinatori con Y1 in presa
    elseif sType == 'M3' then
       EmitComment( vCmd, '[M3]')
@@ -1850,7 +1853,7 @@ local function MaxDispl( TabI, vCmd, sType)
       -- accentro (Y1+T) e (Y2)
       dY1a = TabI.MyMinY1V1
       dY2a = TabI.MaxY2V2
-      dTa = ( TabI.MyMinY1V1 - TabI.dY1PosI) + dTa 
+      dTa = ( dY1a - TabI.dY1PosI) + dTa 
    -- **[M4]** = accentramento dei trascinatori con Y2 in presa
    elseif sType == 'M4' then
       EmitComment( vCmd, '[M4]')
@@ -1861,7 +1864,7 @@ local function MaxDispl( TabI, vCmd, sType)
       -- accentro (Y2+T) e (Y1)
       dY1a = TabI.MyMinY1V1
       dY2a = TabI.MaxY2V2
-      dTa = ( TabI.MaxY2V2 - TabI.dY2PosI) + dTa 
+      dTa = ( dY2a - TabI.dY2PosI) + dTa 
    end
    --
    table.insert( vCmd, { 3, 'Y1', dY1a,  'Y2', dY2a, 'T', dTa, EMC.CNT})
@@ -2187,7 +2190,7 @@ local function PosY1Y2B( TabI, vCmd)
          end 
       end
       nCnt = nCnt + 1
-      if nCnt > 5 then return end
+      if nCnt > 10 then return end
    until ( not bXW)
       -- chiusura/parcheggio dei trascinatori in funzioni chiamanti
    local dY1Delta = TabI.dY1PosI - TabI.dTPosI
@@ -2326,7 +2329,7 @@ local function PosY2Y1B( TabI, vCmd)
          end 
       end
       nCnt = nCnt + 1
-      if nCnt > 5 then return end
+      if nCnt > 10 then return end
    until ( not bXW)
    -- la chiusura delle morse è fatta sopra
    local dY1Delta = TabI.dY1PosI - TabI.dTPosI
@@ -2398,7 +2401,7 @@ function SpecAdjustCarrA( WorkTab)
          dY1DeltaF = PosY1Y2B( TabValI, vCmd)
       else
          --[A(1)A]  **ALLONTANAMENTO** (dall'origine) del trascinatore Y1
-         EmitComment( vCmd, '[AY1A]')
+         EmitComment( vCmd, '[A-Y1A]')
          dY1DeltaF = PosY1Y2A( TabValI, vCmd)
       end
       -- chiudo Y1

Essetre-ONE.mlde

@@ -24,47 +24,16 @@
 -- 2022/10/24 ver 2.4j1 Correzione gestione Z di primo movimento di prima lavorazione come primo movimento di lavorazioni successive.
 -- 2022/11/10 ver 2.4k1 Riportate modifiche PF.
 -- 2023/02/18 ver 2.5b2 Riportato da PF gestione speciale movimento in rapido solo a inizio lavorazione (corr. #817). Aggiunto solido collisione per eventuale segacatena sotto trave.
--- 2023/03/31 ver 2.5c5 Correzione per allontanamento trave di testa/coda con paratie (ParkRoller). Aggiornamenti vari come PF.
--- 2023/04/05 ver 2.5d1 Migliorato calcolo Zextra. Migliorata simulazione split con caduta pezzo. Eliminata testa dummy 'H14'.
--- 2023/04/28 ver 2.5d2 In OnSetHead si riassegna ad H3 (sega a catena ) la corretta direzione dell'asse B1.
--- 2023/06/12 ver 2.5f2 Corretta distanza Back per aggiuntivo al carico prima di scambi carrelli.
--- 2023/07/31 ver 2.5g1 Tolte da testa per lama forzatura risalite in Z.In generaz. CN aggiunto M05 su ultima lavorazione prima di Fall.
---                      Aggiunta apertura V1 allo scarico finale di barra con uso di entrambe Y1 e Y2 (#1399).
--- 2023/08/07 ver 2.5h1 In split prima di rotazione migliorato controllo spazio dietro per scambio carrelli. Modificato approccio/retrazione sega a catena.
---                      Ripristinata forzatura risalita in Z per lame se DeltaAng > 210 e HzPezzo > 610. Modificata notifica utensile su T201.
--- 2023/09/29 ver 2.5i1 In BeamData e mlde aggiunta la lettura di alcuni parametri da Ts3Data.
--- 2023/11/03 ver 2.5k1 Dopo rotazione, nuovo comando Aux per dichiarare morse non in presa su pezzo.
---                      In simulazione : gestione corretta motosega in caso prima lavorazione della fase.
--- 2023/11/28 ver 2.6a1 Prima versione con utilizzo post-processore standard per macchine ONE e PF
--- 2024/01/17 ver 2.6a2 Allineamento con Common ver. 2.6a2
--- 2024/01/23 ver 2.6a3 Allineamento con Common ver. 2.6a3
--- 2024/01/23 ver 2.6a4 Allineamento con Common ver. 2.6a5
--- 2024/02/07 ver 2.6a5 Allineamento con Common ver. 2.6a6
--- 2024/02/19 ver 2.6b1 In BeamData aggiunta funzione GetBlockedAxis che sostituisce la GetChainSawBlockedAxis.
--- 2024/02/23 ver 2.6b2 Allineamento con common ver. 2.6b2; in mlde aggiunte chiamate EgtAddToPackagePath
--- 2024/02/29 ver 2.6c1 Allineamento con common ver. 2.6c1
--- 2024/03/04 ver 2.6c2 Modificato log con nome macchina
---                      Allineamento con common ver. 2.6c2
--- 2024/03/06 ver 2.6c3 Allineamento con common ver. 2.6c4
--- 2024/03/06 ver 2.6c4 Allineamento con common ver. 2.6c5
--- 2024/03/08 ver 2.6c5 Allineamento con common ver. 2.6c6
--- 2024/03/11 ver 2.6c6 Allineamento con common ver. 2.6c7
--- 2024/03/26 ver 2.6c7 Con aggregati, non viene più aggiunto il gruippo SOLID (in MLDE)
--- 2024/03/28 ver 2.6d1 Allineamento con common ver. 2.6d1
--- 2024/04/12 ver 2.6d2 Allineamento con common ver. 2.6d2
---                      Aggiunto parametro ForceToCloseRollersGate
--- 2024/04/30 ver 2.6e1 Allineamento con common ver. 2.6e1
---                      Aggiunta variabile WoodDensity per gestione WOOD_DENSITY
--- 2024/06/03 ver 2.6f1 Aggiunta funzione GetSetupInfo a BeamData per nuovo automatismo
---                      Allineamento con common ver. 2.6f1
--- 2024/07/10 ver 2.6g1 Allineamento con common ver. 2.6g1
--- 2024/07/16 ver 2.6g2 Allineamento con common ver. 2.6g2
+-------------------------------------
+-- NOTE VERSIONI SUCCESSIVE IN GIT --
+-------------------------------------
 
 -- Intestazioni
 require( 'EmtGenerator')
 EgtEnableDebug( false)
 
-PP_VER = '2.6g2'
+PP_VER = '2.7a2_DEV1'
+PP_NVER = '2.7.1.2'
 MIN_MACH_VER = '2.5k1'
 MACH_NAME = 'Essetre-ONE'
 
@@ -137,15 +106,15 @@ MaxB1 = 127
 MinB1b = -119
 MaxB1b = 119
 ParkX1 = MaxX1
-ParkFrnX1 = 200
+ParkFrnX1 = 300
 ParkZ1 = -535
 ParkC1 = 90
 ParkFrnC1 = -90
 ParkB1 = 90
 ParkFrnB1 = -90
-LimX1RotSaw = 2900
+LimX1RotSaw = 800
 LimX1PlRotSaw = 1970
-SafeCSaw0X1 = 1350
+LimX1RotSawTC2 = 800
 ParkCSawX1 = 1350
 ParkCSawX1S = MinX1
 ParkCSawZ1 = -50
@@ -162,11 +131,12 @@ DeltaTabZ = -1060.0            -- per TPA la quota è dal centro di rotazione (v
 DeltaRulliTraveZ = 980
 DeltaRulliTappetoZ = -485
 DimTabY = 500
-DimTabX = 24000
+DimTabX = 30000
 AutomaticRotation = true
 AutoRotMinLen = 0
 DefTcPos1 = 'T3'
 CoeffVM = 0.5
+EstimationRapidMultiplier = 1
 ForceToCloseRollersGate = false
 
 -- Aggiornamento con dati da TechnoEssetre7
@@ -191,6 +161,7 @@ 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.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.PARK_Z1 then ParkZ1 = Machine.Offsets.PARK_Z1 end
@@ -231,19 +202,19 @@ if EgtExistsFile( sData) then
          if Machine.Offsets.SAWOFFSX then SawOffsX = Machine.Offsets.SAWOFFSX end
          if Machine.Offsets.SAWOFFSZ then SawOffsZ = Machine.Offsets.SAWOFFSZ end
          if Machine.Offsets.DEFTCPOS1 then DefTcPos1 = ( 'T' .. Machine.Offsets.DEFTCPOS1) 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
          -- aggiustamenti
          MinY1 = MinV1 + MinDeltaYV
          MaxY1 = MaxMchY1
+         ParkV1 = MaxV1 
          ParkY1 = ParkV1 + MinDeltaYV
          MinY2 = MinMchY2
          MaxY2 = MaxV2 - MinDeltaYV
+         ParkV2 = MinV2
          ParkY2 = ParkV2 - MinDeltaYV
-         ParkV1 = min( ParkV1, MaxV1, abs( MinV2))
-         ParkV2 = -ParkV1
-         ParkX1 = MaxX1
-         --ParkFrnX1 = MinX1
+         ParkX1 = min( ParkX1, MaxX1)
          ParkCSawZ1 = min( ParkCSawZ1, MaxZ1)
          ParkCSaw0Z1 = min( ParkCSaw0Z1, MaxZ1)
          Mortiser = ( Mortiser and not Progress)
@@ -553,7 +524,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 {
@@ -803,9 +774,20 @@ function OnSetHead()
          EmtModifyAxisHome( 'C1', ParkC1)
          EmtModifyAxisHome( 'B1', ParkB1)
       else
+         local MyHomeB1, MyHomeC1
+         -- se cambio utensile verticale
+         if EgtGetHeadId('H21') or bProgress then
+            MyHomeB1 = ParkFrnB1
+            MyHomeC1 = ParkFrnC1
+         -- altrimenti su one CU speciale motosega-utensile lungo
+         else
+            MyHomeB1 = ParkLongToolB1
+            MyHomeC1 = ParkLongToolC1
+         end
+
          EmtModifyAxisHome( 'X1', ParkFrnX1)
-         EmtModifyAxisHome( 'C1', ParkFrnC1)
-         EmtModifyAxisHome( 'B1', ParkFrnB1)
+         EmtModifyAxisHome( 'C1', MyHomeC1)
+         EmtModifyAxisHome( 'B1', MyHomeB1)
       end
    -- se testa H13 (sega a catena)
    elseif EMC.HEAD == 'H13' then
@@ -921,7 +903,7 @@ function GetZExtra( sHead, dAngV)
       elseif abs( dAngV) < 60.1 then
          return 200
       elseif abs( dAngV) < 90.1 then
-         return 10
+         return 1
       else
          return 0
       end
@@ -933,7 +915,9 @@ function GetZExtra( sHead, dAngV)
       elseif abs( dAngV) < 60.1 then
          return 200
       elseif abs( dAngV) < 90.1 then
-         return 10
+         return 1
+      elseif abs( dAngV) < 120 then
+         return -100
       else
          return 0
       end

MachNotes.ini

@@ -0,0 +1,50 @@
+; Commento per evitare BOM con UTF-8
+;Index = Type, Description, Default Value
+; Type : b=boolean, d=double, l=lenght, s=string
+
+[Drilling]
+
+[Sawing]
+
+[Milling]
+0=d,MaxElev,0
+1=d,OutRaw,0
+2=d,SideElev,0
+3=d,TrimExt,0
+4=sr,VtFaceUse,0,0,0
+
+[Pocketing]
+0=d,MaxElev,0
+1=b,Open,0
+2=d,OpenMinSave,0
+3=d,OpenOutRaw,0
+4=d,MaxOptSize,0
+
+[Mortising]
+0=d,MaxElev,0
+
+[Chiseling]
+
+[SawRoughing]
+
+[SawFinishing]
+
+[GenMachining]
+0=l,LinTol,0.1
+1=l,MaxLen,2
+2=s,Type,ZigZag
+3=d,SideAng,90
+4=l,Step,10
+5=l,OffsProj,0
+6=l,LiTang,0
+7=l,LiOrth,0
+8=l,LiElev,0
+9=l,LoTang,0
+10=l,LoOrth,0
+11=l,LoElev,0
+12=b,DirFromGuide,1
+
+[SurfRoughing]
+
+[SurfFinishing]
+0=b,SkipMaxDown,1

ToolNotes.ini

@@ -0,0 +1,42 @@
+; Commento per evitare BOM con UTF-8
+; Index, Type, Description, Value
+; Index = 0,1,..,n
+; Type : d=double, l=lenght, s=string, b=boolean, dr=double recalc, sr= string recalc, lr=lenght recalc, br=boolean recalc, th=toolholder
+; Description : STEP, SIDESTEP, ...
+
+[DRILL_STD]
+0=th,TH,
+1=d,STEP
+2=s,DOUBLE
+3=d,SECDIST
+
+[SAW_STD]
+0=th,TH,
+1=d,STEP
+2=d,SIDESTEP
+3=b,LONGCUT
+
+[SAW_FLAT]
+0=th,TH,
+1=d,STEP
+2=d,SIDESTEP
+3=b,LONGCUT
+
+[MILL_STD]
+0=th,TH,
+1=d,STEP
+2=d,SIDESTEP
+3=d,SIDEDEPTH
+4=s,DOUBLE
+
+[MILL_NOTIP]
+0=th,TH,
+1=d,STEP
+2=d,SIDESTEP
+3=d,SIDEDEPTH
+4=s,DOUBLE
+
+[MORTISE_STD]
+0=b,MORTISE
+1=d,STEP
+2=d,SIDESTEP

UpdateLog.txt

@@ -1,5 +1,63 @@
            ==== Common_ONE-PF Update Log ====
 
+Versione 2.7-- (--/--/2024)
+- (SIM-GEN) In caso di Progress, alla deselezione utensile testa 1 su TC2 si fa movimento Z raddrizzando asse B. Ticket#2247
+
+Versione 2.7a2 (15/01/2024)
+- (SIM-GEN) In caso di testa 1 su TC2 (ONE), si ruota prima la C e poi la B. Ticket#2247
+
+Versione 2.7a1 (07/01/2024)
+- (GEN) In separazione, quando si porta indietro il restante, si aprono le paratie rulli subito. Ticket#2214
+- (SIM-GEN) Se entrambe le morse sono restate in posizione, le sposto comunque di 5mm per distanziare i pezzi separati. Ticket#2206
+
+Versione 2.6l2 (09/12/2024)
+- (SIM-GEN) Corretto problema introdotto in 2.6l1 per risolvere #2198. Ticket#2203
+- (SIM-GEN) In MLSE modificato controllo direzione utensile per determinare Z massima. Ticket#2204
+
+Versione 2.6l1 (02/12/2024)
+- (SIM) Dopo scarico pezzo per ribaltamento, si aprono sempre i rulli. Ticket#2192
+- (SIM-GEN) Nei movimenti si ricalcola la Z solo se la quota di lavoro è più in alta della posizione a ZHOME della testa. Ticket#2198
+- (GEN) Se bisogna andare in home, ma la testa lo è già, non si scrive nulla
+
+Versione 2.6j3 (21/10/2024)
+- (GEN) Se richiesto movimento in home, si scrive sempre parcheggio in home dell'utensile precedente. Prima si scriveva solo per lama.
+
+Versione 2.6j2 (17/10/2024)
+- (SIM-GEN) Se motosega prelevata con A=0, alla fine la si porta sempre alla quota ZMAX, indipendentemente dall'altezza trave che era fissata a 650mm. Ora lo fa sempre.
+
+Versione 2.6j1 (08/10/2024)
+- (SIM-GEN) Corretto primo movimento di approccio al pezzo. Ticket#2093
+- (SIM-GEN) Corretto movimento in Home in caso di lama e movimento rulliera di carico. Ticket#2054
+- (GEN) In caso di movimento in Home non si fa più preselezione ma si tiene utensile vecchio. Ticket#1926
+
+Versione 2.6i2 (13/09/2024)
+- (GEN) Migliorato calcolo chiusura paratia rulli con aggiornamento lunghezza della barra in caso di ultimo taglio e grezzo residuo in coda. Ticket#2017
+- (NGE-MLDE-GEN-SIM) Aggiunto solidi collisione TC.  Corretto movimento a Y di sicurezza con lama. Ticket#2042
+- (NGE-SIM) Aggiunta collisione magazzino motosega ONE
+
+Versione 2.6i1 (02/09/2024)
+- (SIM-GEN) Quando si aprono i rulli, se la trave non può seguire i rulli perchè la pinza andrebbe in extra-corsa, si sposta comunque la pinza fino al massimo della sua corsa. Ticket#1949
+- (GEN) In preselezione. Se lavorazione motosega, non mando a parcheggio altra testa con utensile precedente, perchè subito dopo viene chiamata preselezione. Ticket#1961 
+
+Versione 2.6h2 (07/08/2024)
+- (SIM) Allineata simulazione a generazione in primo movimento rapido approccio al pezzo.
+
+Versione 2.6h1 (01/08/2024)
+- (GEN) Corretto segno posizione X di sicurezza per rotazione assi rotanti.
+
+Versione 2.6g5 (31/07/2024)
+- (SIM-GEN) Se motosega allineata ad asse B per tagli di fianco, corretto movimento che manda testa a parcheggio. Pezzi più alti di 650 va solo in Zmax. Ticket#1943
+- (SIM-GEN) Gestione movimenti speciali per pezzi molto alti. Se HomeZ < primo punto lavorazione, allora vado al punto Z lavorazione prima di approcciare il pezzo in X. Ticket#1943
+- (GEN) Gestione creazione piano generico in caso il primo movimento della lavorazione sia un arco. Ticket#1891
+- (SIM-GEN) Modifica limite inferirore intervallo di pinzaggio per garantire, se possibile, il passaggio pezzo a pinza 2. Da Common-PF1250.
+- (GEN) Corretta scrittura ISO per parcheggiare morsa 3 dopo ribaltamento. Ticket#1922,#1733
+
+Versione 2.6g4 (19/07/2024)
+- (SIM-GEN) Aumentato numero iterazioni per scambio carrelli (da 5 a 10), per pezzi lunghi 30m.
+
+Versione 2.6g3 (17/07/2024)
+- (GEN) Correzione modifica precedente (2.6g2). Con lama precedente e motosega successiva, andava a parcheggio con lama alla quota della motosega. Ticket#1880
+
 Versione 2.6g2 (16/07/2024)
 - (GEN) Per preselezione o movimenti in home, non si scrive più 'ET0' perchè non è più supportato. Ticket#1926
 

Version.lua

@@ -3,7 +3,7 @@
 
 local InfoCommon_STD_PP = {
    NAME = 'Common_ONE-PF',            -- nome script PP standard
-   VERSION = '2.6g2',                 -- versione script
+   VERSION = '2.7--',                 -- versione script
    MIN_MACH_VER_PP_COMMON = '2.5k1'   -- versione minima kernel
 }