diff --git a/.gitignore b/.gitignore
index 196fc23..1017e67 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,12 @@
 /Wall/PocketingData.lua
 /Wall/SawingData.lua
 /Wall/Ts3Data.lua
+/.vscode
+/MachNotes.ini
+/ToolNotes.ini
+
+# ignoro file bak nella cartella principale e nelle sottocartelle al primo livello
+*.bak
+/*/*.bak
+
+Wall/SurfacingData.lua
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index d3c4a56..b6ec408 100644
--- a/.gitlab-ci.yml
+++ b/.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\$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
\ No newline at end of file
+#    - *ReplicaR
+
diff --git a/Beam/BeamData.lua b/Beam/BeamData.lua
index 4c5ac8e..544a09e 100644
--- a/Beam/BeamData.lua
+++ b/Beam/BeamData.lua
@@ -8,6 +8,8 @@ local BeamData = {
    GO_FAST = 0,                             -- flag abilitazione modalità veloce (0=no, 1=carrelli, 2=anche cambio utensili)
    RIGHT_LOAD = false,                      -- flag carico da destra
    ROT90 = false,                           -- flag abilitazione rotazione 90 gradi
+   NEWCLAMPING = false,                     -- flag abilitazione nuovo metodo riposizionamento carrelli
+   FASTCLAMPING= true,                     -- flag abilitazione riduzione numero riposizionamenti al carico e durante grande trascinamento
    MIN_WIDTH = 40,                          -- larghezza minima del grezzo
    MIN_HEIGHT = 40,                         -- altezza minima del grezzo
    MAX_WIDTH = 240,                         -- larghezza massima del grezzo
@@ -69,9 +71,10 @@ local BeamData = {
    MAX_DIST_BH_FROM_BOTTOM = 395,           -- massima distanza tra naso mandrino e sopra della trave senza collisione
    BH_MACHINE = false,                      -- flag che indica la tipologia di macchina configurata BlockHaus
    ANG_TRASM = false,                       -- presenza rinvio angolare per lavorazioni da sotto
-   MIN_HEIGHT_ADDED_CUTS = 199,             -- altezza minima pezzo per effettuare tagli orizzontali aggiuntivi in testa e coda
    PRECUT_HEAD = true,                      -- flag abilitazione pretaglio grezzo a zero in testa
-   PRECUT_TAIL = true                       -- flag abilitazione pretaglio grezzo a zero in coda
+   PRECUT_TAIL = true,                      -- flag abilitazione pretaglio grezzo a zero in coda
+   MIN_HEIGHT_ADDED_CUTS = 400,             -- altezza minima pezzo per effettuare tagli orizzontali aggiuntivi in testa e coda
+   GAIN_RECLAMPING = 1000                   -- in caso di scarso pinzaggio, mm da recuperare con pinzaggio ulteriore prima di spostare
 }
 
 -- Aggiornamento con dati da TechnoEssetre7
@@ -96,6 +99,11 @@ if EgtExistsFile( sData) then
         BeamData.DIM_STRIP_SMALL = Machine.Offsets.DIM_STRIP_SMALL or BeamData.DIM_STRIP_SMALL
         BeamData.DIM_TO_CENTER_STRIP = Machine.Offsets.DIM_TO_CENTER_STRIP or BeamData.DIM_TO_CENTER_STRIP
         BeamData.MAXDIAM_POCK_CORNER = Machine.Offsets.MAXDIAM_POCK_CORNER or BeamData.MAXDIAM_POCK_CORNER
+        if Machine.Offsets.PRECUT_HEAD_DISABLE then BeamData.PRECUT_HEAD = ( Machine.Offsets.PRECUT_HEAD_DISABLE == 0) end
+        if Machine.Offsets.PRECUT_TAIL_DISABLE then BeamData.PRECUT_TAIL = ( Machine.Offsets.PRECUT_TAIL_DISABLE == 0) end
+        if Machine.Offsets.MIN_HEIGHT_ADDED_CUTS then BeamData.MIN_HEIGHT_ADDED_CUTS = min( Machine.Offsets.MIN_HEIGHT_ADDED_CUTS, BeamData.MIN_HEIGHT_ADDED_CUTS) end
+        if Machine.Offsets.NEWCLAMPING ~= nil then BeamData.NEWCLAMPING = Machine.Offsets.NEWCLAMPING end
+        if Machine.Offsets.FASTCLAMPING ~= nil then BeamData.FASTCLAMPING = Machine.Offsets.FASTCLAMPING end
       end
       if Machine.Trave then
          BeamData.MIN_WIDTH = Machine.Trave.XMIN or BeamData.MIN_WIDTH
diff --git a/Common_FAST.NUM.mlpe b/Common_FAST.NUM.mlpe
index 8737654..07d2cf4 100644
--- a/Common_FAST.NUM.mlpe
+++ b/Common_FAST.NUM.mlpe
@@ -649,7 +649,7 @@ function OnRapid()
       local sES = ' ES'..EgtNumToString( EMT.S, 0)
 
       -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione
-      if EMT.HEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then
+      if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TTOTLEN > 200)) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then
          local sEEPreMove = ' EE' .. EgtIf( bZmax, '3', '4')
          local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
                                        EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES
@@ -836,9 +836,24 @@ function OnRapid()
    -- se altrimenti movimento in Home
    elseif EMT.FLAG == 4 then
       -- non previsto
-   -- se altrimenti rotazione a Z max
+   -- se altrimenti rotazione a Z max per lavorazione successiva
    elseif EMT.FLAG == 5 then
-      -- viene gestito all'inizio della lavorazione successiva
+      EMT.REFLOC = nil
+      EMT.IPLGL = false
+      MyAdjustLinearAxes()
+      EmtAdjustRotaryAxes()
+      EmtResetPrev()
+      -- ricavo i dati per la lavorazione
+      local sEE = ' EE3'
+      local sEL = ' EL' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TLEN, ( EMT.TDIST or ChSawLen)), 3)
+      local sER = ' ER' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TDIAM / 2, EMT.TLEN), 3)
+      local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3)
+      local sES = ' ES'..EgtNumToString( EMT.S, 0)
+      local sOut = 'G101' .. EmtGetAxis( 'L2') .. EmtGetAxis( 'L3') ..
+                             EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES
+      EmtOutput( sOut)
+      EmtOutput( 'G101 ET1001')
+      EmtOutput( 'G101 ET2001')            
    -- altrimenti errore
    else
       EmtSetLastError( 1212, "Unknown Rapid flag")
diff --git a/Common_FAST.NUM_PLUS.mlpe b/Common_FAST.NUM_PLUS.mlpe
index 89d04f3..205957f 100644
--- a/Common_FAST.NUM_PLUS.mlpe
+++ b/Common_FAST.NUM_PLUS.mlpe
@@ -713,7 +713,7 @@ function OnRapid()
       local sES = ' ES'..EgtNumToString( EMT.S, 0)
 
       -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione
-      if EMT.HEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then
+      if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TTOTLEN > 200)) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then
          local sEEPreMove = ' EE' .. EgtIf( bZmax, '3', '4')
          local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) ..
                                        EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES
@@ -910,9 +910,24 @@ function OnRapid()
    -- se altrimenti movimento in Home
    elseif EMT.FLAG == 4 then
       -- non previsto
-   -- se altrimenti rotazione a Z max
+   -- se altrimenti rotazione a Z max per lavorazione successiva
    elseif EMT.FLAG == 5 then
-      -- viene gestito all'inizio della lavorazione successiva
+      EMT.REFLOC = nil
+      EMT.IPLGL = false
+      MyAdjustLinearAxes()
+      EmtAdjustRotaryAxes()
+      EmtResetPrev()
+      -- ricavo i dati per la lavorazione
+      local sEE = ' EE3'
+      local sEL = ' EL' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TLEN, ( EMT.TDIST or ChSawLen)), 3)
+      local sER = ' ER' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TDIAM / 2, EMT.TLEN), 3)
+      local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3)
+      local sES = ' ES'..EgtNumToString( EMT.S, 0)
+      local sOut = 'G101' .. EmtGetAxis( 'L2') .. EmtGetAxis( 'L3') ..
+                             EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES
+      EmtOutput( sOut)
+      EmtOutput( 'G101 ET1001')
+      EmtOutput( 'G101 ET2001')
    -- altrimenti errore
    else
       EmtSetLastError( 1212, "Unknown Rapid flag")
diff --git a/Common_FAST.TPA.mlpe b/Common_FAST.TPA.mlpe
index f147571..e683a67 100644
--- a/Common_FAST.TPA.mlpe
+++ b/Common_FAST.TPA.mlpe
@@ -663,7 +663,7 @@ function OnRapid()
       end
 
       -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione
-      if EMT.HEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then
+      if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TTOTLEN > 200)) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then
          local sOutPreMove = 'M101 P1=1' .. ' P2=' .. EmtLenToString( -SafeXRotAxes, 3) .. ' P3=' .. EmtLenToString( MyZHome, 3) ..
                                  ' P4=' .. EgtNumToString( EMT.R2, 3) .. ' P5=' .. EgtNumToString( EMT.R1, 3) .. 
                                  ' P6=' .. AdjustTcPos( false) .. ' P7=' .. EgtNumToString( EMT.S, 0) ..
@@ -852,9 +852,20 @@ function OnRapid()
    -- se altrimenti movimento in Home
    elseif EMT.FLAG == 4 then
       -- non previsto
-   -- se altrimenti rotazione a Z max
+   -- se altrimenti rotazione a Z max per lavorazione successiva
    elseif EMT.FLAG == 5 then
-      -- viene gestito all'inizio della lavorazione successiva
+      EMT.REFLOC = nil
+      EMT.IPLGL = false
+      MyAdjustLinearAxes()
+      EmtAdjustRotaryAxes()
+      EmtResetPrev()
+      local sOut = 'M101 P1=1' .. ' P2=' .. EmtLenToString( EMT.L2, 3) .. ' P3=' .. EmtLenToString( EMT.L3, 3) ..
+                   ' P4=' .. EgtNumToString( EMT.R2, 3) .. ' P5=' .. EgtNumToString( EMT.R1, 3) .. 
+                   ' P6=' .. AdjustTcPos( false) .. ' P7=' .. EgtNumToString( EMT.S, 0) ..
+                   ' P8=0' .. ' P9=0' .. ' P10=3'
+      EmtOutput( sOut)
+      EmtOutput( 'M101 P1=2')
+      EmtOutput( 'M101 P1=3')
    -- altrimenti errore
    else
       error( "Unknown Rapid flag")
diff --git a/Common_FAST.mlpe b/Common_FAST.mlpe
index 20e370c..ecfeee3 100644
--- a/Common_FAST.mlpe
+++ b/Common_FAST.mlpe
@@ -662,6 +662,7 @@ function OnSimulMachiningEnd()
       EMT.FALL = false
    end
    EMT.PREVHEAD = EMT.HEAD
+   EMT.PREVTOOL = EMT.TOOL
    EMT.PREVEXIT = EMT.EXIT
 end
 
@@ -749,10 +750,12 @@ function OnSimulMoveStart()
    if EMT.MCHFIRST then
       EgtOutText( '')
       EMT.MCHFIRST = false
+      local bZmax = ( EMT.TOOL ~= EMT.PREVTOOL  or EMT.L3 > -1)
+
       -- con pezzi alti aggiorno gli assi rotanti prima di muovermi sopra il pezzo
       if not EMT.LOAD and EMT.MOVE == 0 and EMT.HB > BeamHeightForFixRot and EMT.FLAG2 == 1 then
          -- se motosega mi muovo a X di sicurezza per ruotare
-         if EMT.HEAD == 'H3'then
+         if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TOTLEN > 200)) then
             SimulMoveAxes( 'X', SafeXRotAxes, MCH_SIM_STEP.RAPID, 'C', EMT.R1, MCH_SIM_STEP.COLLROT, 'B', EMT.R2, MCH_SIM_STEP.COLLROT)
          end
       end
diff --git a/Common_FAST.mlse b/Common_FAST.mlse
index d001976..fba0a4c 100644
--- a/Common_FAST.mlse
+++ b/Common_FAST.mlse
@@ -917,7 +917,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, ptMin, ptMax, bSaw, bChain, dTLen,
          elseif vtTool:getX() > -0.8667 then
             dHeadBack = 450
          else
-            dHeadBack = 650
+            dHeadBack = 660
          end
       else
          dHeadBack = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
@@ -1008,7 +1008,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, ptMin, ptMax, bSaw, bChain, dTLen,
          elseif vtTool:getX() < 0.8667 then
             dHeadFront = 450
          else
-            dHeadFront = 650
+            dHeadFront = 660
          end
       else
          dHeadFront = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
@@ -1097,16 +1097,24 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack)
    local dNewVDelta = nil
    local dNewY = dPosT + TurnerOffs + dNewYDelta
    local vCmd = {}
-   EgtOutLog( '  *[L]', 1)
-   -- [L-1]
-   if  dNewY - MaxY > 0   then
-      dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs)
-      EgtOutLog( '  *[L1]', 1)
-   end --[L-2]
-   if EMC.LB - dNewYDelta <  MinJoin then
-      dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs)
-      EgtOutLog( '  *[L2]', 1)
+
+   -- se flag attivo, vado a pinzare al massimo della corsa
+   if BD.FASTCLAMPING then
+      EgtOutLog( '  *[L]', 1)
+      -- [L-1]
+      if  dNewY - MaxY > 0   then
+         dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs)
+         EgtOutLog( '  *[L1]', 1)
+      end --[L-2]
+      if EMC.LB - dNewYDelta <  MinJoin then
+         dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs)
+         EgtOutLog( '  *[L2]', 1)
+      end
+   else
+   -- altrimenti si pinza sempre a massimo 1000mm
+      dNewYDelta = min( dNewYDelta, 1000)
    end
+
    -- Commento
    table.insert( vCmd, { 0, 'Loading'})
    -- risalita testa a Zmax
@@ -1131,9 +1139,71 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack)
    return vCmd
 end -- SpecAdjustLoad [L]
 
+
+---------------------------------------------------------------------
+function GetMachiningStartingPoint( idPath)
+   local idFirstObj = EgtGetFirstInGroup( idPath)
+   -- se esiste l'oggetto, recupero la coordinata del primo punto
+   if idFirstObj then
+      local vAxes = EmtGetAxesPos( idFirstObj)
+      if #vAxes > 0 then 
+         return vAxes[1] 
+      end
+   end
+   return nil
+end
+
+---------------------------------------------------------------------
+local function AdjustPositionsForB( dNewYDelta, dNewVDelta, TCING, HCING, HOVM, bFixedDelta)
+   local REF_DIST = 1400
+   local dYDelta = 0
+   local dVDelta = 0
+   -- incremento se possibile la distanza tra le due posizioni
+   if not bFixedDelta and ( dNewYDelta - dNewVDelta) < REF_DIST then
+      local dEffAddDist = ( REF_DIST - ( dNewYDelta - dNewVDelta)) / 2
+      dYDelta = max( min( dEffAddDist, EMC.LB - dNewYDelta - MinJoin - TCING), 0)
+      dVDelta = max( min( dEffAddDist, dNewVDelta - MinJoin - HOVM - HCING), 0)
+   end
+   return dYDelta, dVDelta
+end
+
+---------------------------------------------------------------------
+local function GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta)
+   local dDeltaTolEff = DELTA_SIC
+   if Carr == 'Y' then
+      local dLenPreEff = dLenPresa - TCING
+      if dLenPreEff < MinJoin + DeltaTol then
+         dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL)
+      else
+         if BD.GO_FAST and BD.GO_FAST ~= 0 then
+            if bFixedDelta == false then
+               dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200)
+            else
+               dDeltaTolEff = 900
+            end
+         else
+            dDeltaTolEff = DeltaTol
+         end
+      end
+   elseif Carr == 'V' then
+      local dLenPreEff = dLenPresa - HCING - HOVM
+      if dLenPreEff < MinJoin + DeltaTol then
+         dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL)
+      else
+         dDeltaTolEff = DeltaTol
+      end
+   end
+   return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff)
+end
+
 ---------------------------------------------------------------------
 function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
 
+   -- Abilitazione gestione vecchia dei riposizionamenti
+   if not BD.NEWCLAMPING then
+      return SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos)
+   end
+
    local MinFrontJoin = MinJoin + EMC.HCING + EMC.HOVM
    local MinBackJoin = MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0)
    local MyMinOther = MinOther + EgtIf( EMC.CNT == 1, AGG_LOAD, 0) 
@@ -1148,46 +1218,85 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
               ' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1) ..
               '  Fixed : Delta=' .. EgtIf( bFixedDelta, 'T', 'F') .. ' Pos=' .. EgtIf( bFixedPos, 'T', 'F'), 3)
 
+   local dPosT = EMC.TPOS
+   local dYDelta = EMC.YDELTA
+   local dVDelta = EMC.VDELTA
+   local dNewPosT
+   -- se sono già settati, non calcolo posizione finale
+   if not EMC.YDELTANEXT and not EMC.VDELTANEXT then
+      dNewPosT = GetMachiningStartingPoint( EMC.PATHID)
+   end
+   local dNewYDelta = nil
+   local dNewVDelta = nil
+
    -- [A] se posso mettere solo carrello Y
    if dDistFrontEff < MinFrontJoin  and  dDistBackEff > MinBackJoin - GEO.EPS_SMALL then
+      -- se Y non era in presa, mi ricalcolo la posizione
+      if not dYDelta then
+         dYDelta = dVDelta + ( MinY - MaxV)
+      end
+      dNewYDelta = EMC.LB - dDistBackEff
+      -- verifico se posso lasciare la morsa in posizione
+      local dYDeltaTol = GetDeltaTol( EMC.LB - dNewYDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y')
+      local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC)
+      if bYDeltaS then
+         dNewYDelta = dNewYDelta + dYDeltaTol/2
+      else
+         dNewYDelta = dYDelta
+      end
 
-      local dPosT = EMC.TPOS
-      local dYDelta = EMC.YDELTA
-      local dVDelta = EMC.VDELTA
-
-      local dNewPosT = nil
-      local dNewYDelta = EMC.LB - dDistBackEff
-      local dNewVDelta = nil
-
-      return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
-
+      dNewVDelta = nil
    -- [B] se altrimenti posso mettere entrambi i carrelli Y e V
-   elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL  and
-          dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then
-
-      local dPosT = EMC.TPOS
-      local dYDelta = EMC.YDELTA
-      local dVDelta = EMC.VDELTA
-
-      local dNewPosT = nil
-      local dNewYDelta = EMC.LB - dDistBackEff
-      local dNewVDelta = dDistFrontEff
-
-      return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
+   elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL  and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then
+      -- se Y non era in presa, mi ricalcolo la posizione
+      if not dYDelta then
+         dYDelta = dVDelta + ( MinY - MaxV)
+      end
+      -- se V non era in presa, mi ricalcolo la posizione
+      if not dVDelta then
+         dVDelta = dYDelta - ( MinY - MaxV)
+      end
+      
+      dNewYDelta = EMC.LB - dDistBackEff
+      dNewVDelta = dDistFrontEff
+      
+      -- incremento la distanza tra le due posizioni ( se abilitato e possibile)
+      local dYDeltaAgg, dVDeltaAgg = AdjustPositionsForB( dNewYDelta, dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta)
+      -- tolleranze
+      local dYDeltaTol = dYDeltaAgg + GetDeltaTol( EMC.LB - dNewYDelta - dYDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y', bFixedDelta)
+      local dVDeltaTol = dVDeltaAgg + GetDeltaTol( dNewVDelta - dVDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta)
+      -- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze
+      local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC)
+      local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or dNewVDelta < dVDelta - DELTA_SIC)
+      -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze
+      if bYDeltaS then 
+         dNewYDelta = dNewYDelta + dYDeltaTol / 2
+      else
+         dNewYDelta = dYDelta
+      end
+      if bVDeltaS then
+         dNewVDelta = dNewVDelta - dVDeltaTol / 2
+      else
+         dNewVDelta = dVDelta
+      end
 
    -- [C] se altrimenti posso mettere solo carrello V
    elseif dDistBackEff < MinBackJoin  and  dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then
-
-      local dPosT = EMC.TPOS
-      local dYDelta = EMC.YDELTA
-      local dVDelta = EMC.VDELTA
-
-      local dNewPosT = nil
-      local dNewYDelta = nil
-      local dNewVDelta = dDistFrontEff
-
-      return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
-
+      -- se V non era in presa, mi ricalcolo la posizione
+      if not dVDelta then
+         dVDelta = dYDelta - ( MinY - MaxV)
+      end
+      dNewVDelta = dDistFrontEff
+      -- verifico se posso lasciare la morsa in posizione
+      local dVDeltaTol = GetDeltaTol( dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta)
+      local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or  dNewVDelta < dVDelta - DELTA_SIC)
+      -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze
+      if bVDeltaS then 
+         dNewVDelta = dNewVDelta - dVDeltaTol/2
+      else
+         dNewVDelta = dVDelta
+      end
+      dNewYDelta = nil
    -- altrimenti errore
    else
       if EgtGetDebugLevel() < 3 then
@@ -1199,6 +1308,16 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
       return {}
    end
 
+   -- salvo valori finali
+   EMC.YDELTANEXT = dNewYDelta
+   EMC.VDELTANEXT = dNewVDelta
+
+   local vCmd = {}
+   SpecAdjustCarriages( vCmd, dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
+
+   SpecOutputCNT()
+   return vCmd
+
 end
 
 ---------------------------------------------------------------------
@@ -1371,8 +1490,746 @@ function SpecCalcPreRot()
 end
 
 ---------------------------------------------------------------------
-function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
+function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
+   local dYPosA, dVPosA, dTPosA
+   local dGainOnReclamping = BD.GAIN_RECLAMPING or 1000
 
+   -- se primo scambio
+   local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY)
+
+   -- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando
+   if not dYDeltaI then
+      dYDeltaI = dVDeltaI + ( MyMinY - MaxV)
+   end
+   if not dVDeltaI then
+      dVDeltaI = dYDeltaI - ( MyMinY - MaxV)
+   end
+   if not dYDeltaF then
+      dYDeltaF = dVDeltaF + ( MyMinY - MaxV)
+   end
+   if not dVDeltaF then
+      dVDeltaF = dYDeltaF - ( MyMinY - MaxV)
+   end
+
+   -- se non c'è posizione finale, è lo scarico. Allora setto al minimo della morsa allo scarico.
+   if not dTPosF then
+      dTPosF = MaxV - dVDeltaF
+   end
+
+   -- verifico che le morse non sono in posizione
+   if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL  or  abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL or 
+      EMC.YDELTA ~= EMC.YDELTANEXT or EMC.VDELTA ~= EMC.VDELTANEXT then
+      if #vCmd == 0 then
+         table.insert( vCmd, { 0, 'Clamp repositioning'})
+         -- risalita testa a Zmax
+         local bZmaxOk = EnsureZmax( bZmaxOk, vCmd)
+      end
+
+      -- reset contatore primo riposizionamento con compensazione lettura laser
+      EMC.CNT = nil
+
+      -- ricavo posizione delle morse nelle corse
+      local dYPosI = max( MyMinY, dTPosI + dYDeltaI)
+      local dVPosI = min( MaxV, dTPosI + dVDeltaI)
+
+      -- calcolo eventuale massimo riposizionamento con passo del pellegrino.
+      --    al primo step si calcolano posizioni attuali delle morse
+      --    al secondo step si considerano le corse massime
+      local dMaxMovePilgrimStepDoubleClamp, dMaxMovePilgrimStepSingleClampY, dMaxMovePilgrimStepSingleClampV
+      if not EMC.PILGRIMSTEP then
+         dMaxMovePilgrimStepDoubleClamp = MaxY - dYPosI - MinV + dVPosI
+         dMaxMovePilgrimStepSingleClampY = MaxY - dYPosI
+         dMaxMovePilgrimStepSingleClampV = - MinV + dVPosI
+      else
+         dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV
+         dMaxMovePilgrimStepSingleClampY = MaxY - MinY
+         dMaxMovePilgrimStepSingleClampV = - MinV + MaxV
+      end
+
+      -- calcolo delta spostamento trave
+      local dDeltaBeam = dTPosI - dTPosF  -- se positivo, la trave si sposta dal carico allo scarico
+      local dBeamMove = 0
+
+      -- PRIMO CASO ->  SCAMBIO DIRETTO : V IN POSIZIONE FINALE
+      -- V può andare in posizione direttamente se :
+      --    * rispetta interasse minimo con Y
+      --    * deve effettivamente spostarsi
+      --    * non si arriva da gestione passo del pellegrino
+      --    * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente
+      if ( dYDeltaI - dVDeltaF) >= MyMinY - MaxV and abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL and  not EMC.PILGRIMSTEP and
+         ( dVDeltaF - dVDeltaI > MinV - dVPosI + MyMinY - dYPosI) then
+         table.insert( vCmd, { 0, 'Direct-V-Y'})
+         -- se l'altra morsa non era in presa, vado a pinzare il pezzo
+         if not EMC.YDELTA then
+            dYPosA = MyMinY
+            dTPosA = MyMinY - dYDeltaI
+            dVPosA = dTPosA + dVDeltaI
+            table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+            dTPosI = dTPosA
+            dVPosI = dVPosA
+            table.insert( vCmd, { 11, 1})
+         end
+
+         -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo
+         -- se non era ingaggiata, vado al suo minimo
+         if not EMC.VDELTA then
+            dBeamMove = -( MaxV - dVDeltaF - dTPosI)
+         -- se spostamento verso lo scarico
+         elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) < MinV then
+            dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MinV
+         -- se spostamento verso il carico
+         elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) > MaxV then
+            dBeamMove =  dVPosI + ( dVDeltaF - dVDeltaI) - MaxV
+         end
+
+         -- se serve un grande spostamento e si sta pinzando poco. Y trascinatore pinza poco e V si sposta per prima per recuperare
+         if not BD.FASTCLAMPING and abs( dBeamMove) > 2000 and dDeltaBeam < 0 and EMC.LB - dYDeltaI < max( 550, (MinJoin * 2)) then
+            table.insert( vCmd, { 12, 0})
+            dVPosA = dVPosI - dGainOnReclamping
+            -- sposto il carrello V di 1000mm
+            table.insert( vCmd, { 1, 'V', dVPosA})
+            table.insert( vCmd, { 12, 1})
+            -- apro morsa Y e recupero i 1000mm
+            table.insert( vCmd, { 11, 0})
+            dVPosA = dVPosI
+            dYPosA = dYPosI 
+            dTPosA = dTPosI + dGainOnReclamping
+            table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+            dTPosI = dTPosA
+            dVPosI = dVPosA
+            dVDeltaI = dVDeltaI - dGainOnReclamping
+            dYDeltaI = dYDeltaI - dGainOnReclamping
+            table.insert( vCmd, { 11, 1})
+            dBeamMove = dBeamMove + dGainOnReclamping
+         end
+
+         table.insert( vCmd, { 12, 0})
+
+         dTPosA = dTPosI - dBeamMove
+         dYPosA = dTPosA + dYDeltaI
+         dVPosA = dTPosA + dVDeltaF
+         table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+
+        -- la morsa allo scarico è adesso in posizione
+         dVDeltaI = dVDeltaF
+         dTPosI = dTPosA
+
+        -- blocco la morsa
+         table.insert( vCmd, { 12, 1})
+
+         -- imposto i nuovi parametri di aggancio
+         if EMC.YDELTANEXT and EMC.VDELTANEXT  then
+            -- porto assi alla loro posizione finale
+            if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then
+               table.insert( vCmd, { 11, 0})
+               dTPosA = dTPosF
+               dYPosA = dTPosF + dYDeltaF
+               dVPosA = dTPosF + dVDeltaF
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 11, 1})
+               -- la morsa al carico è adesso in posizione
+               dYDeltaI = dYDeltaF
+            end
+            table.insert( vCmd, { 21, dYDeltaF, dVDeltaF})
+         elseif EMC.YDELTANEXT then
+            if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then
+               table.insert( vCmd, { 11, 0})
+               dYPosA = max( MyMinY, dTPosI + dYDeltaF)
+               dTPosA = -( dYPosA + dVDeltaF)
+               dVPosA = dTPosA + dVDeltaF
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 11, 1})
+               -- la morsa al carico è adesso in posizione
+               dYDeltaI = dYDeltaF
+            end
+            table.insert( vCmd, { 12, 0})
+            -- sposto il carrello V in parcheggio
+            table.insert( vCmd, { 1, 'V', ParkV})
+            table.insert( vCmd, { 21, dYDeltaF, 0})
+         else
+            table.insert( vCmd, { 11, 0})
+            table.insert( vCmd, { 1, 'Y', ParkY})
+            table.insert( vCmd, { 21, 0, dVDeltaF})
+         end
+
+         -- movimento terminato
+         dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF
+
+      -- SECONDO CASO ->  SCAMBIO DIRETTO : Y IN POSIZIONE FINALE
+      -- Y può andare in posizione direttamente se :
+      --    * rispetta interasse minimo con Y
+      --    * deve effettivamente spostarsi
+      --    * non si arriva da gestione passo del pellegrino
+      --    * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente
+      elseif ( dYDeltaF - dVDeltaI) >= MyMinY - MaxV and abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL and  not EMC.PILGRIMSTEP and
+             ( dYDeltaF - dYDeltaI < MaxY - dYPosI + MaxV - dVPosI) then
+         table.insert( vCmd, { 0, 'Direct-Y-V'})
+         -- se l'altra morsa non era in presa, vado a pinzare il pezzo
+         if not EMC.VDELTA then
+            dVPosA = MaxV
+            dTPosA = MaxV - dVDeltaI
+            dYPosA = dTPosA + dYDeltaI
+            table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+            dTPosI = dTPosA
+            dYPosI = dYPosA
+            table.insert( vCmd, { 12, 1})
+         else
+            -- compenso delta errore misurazione laser
+            dVDeltaI = dVDeltaI - EgtIf( EMC.CNT == 1, AGG_LOAD, 0)
+         end
+
+         -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo
+         -- se non era ingaggiata, vado al suo minimo
+         if not EMC.YDELTA then
+            dBeamMove = - ( dYDeltaF - MyMinY + dTPosI)
+         -- se spostamento verso lo scarico
+         elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) < MyMinY then
+            dBeamMove = -( dYPosI + ( dYDeltaF - dYDeltaI) - MyMinY)
+         -- se spostamento verso il carico
+         elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) > MaxY then
+            dBeamMove =  dYPosI + ( dYDeltaF - dYDeltaI) - MaxY
+         end
+
+         -- se serve un grande spostamento e si sta pinzando poco. V trascinatore pinza poco e Y si sposta per prima per recuperare
+         if not BD.FASTCLAMPING and abs( dBeamMove) > 2000 and dDeltaBeam > 0 and dVDeltaI < max( 550, (MinJoin * 2)) then
+            table.insert( vCmd, { 11, 0})
+            dYPosA = dYPosI + dGainOnReclamping
+            -- sposto il carrello V di 1000mm
+            table.insert( vCmd, { 1, 'Y', dYPosA})
+            table.insert( vCmd, { 11, 1})
+            -- apro morsa Y e recupero i 1000mm
+            table.insert( vCmd, { 12, 0})
+            dVPosA = dVPosI
+            dYPosA = dYPosI 
+            dTPosA = dTPosI - dGainOnReclamping
+            table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+            dTPosI = dTPosA
+            dVPosI = dVPosA
+            dVDeltaI = dVDeltaI + dGainOnReclamping
+            dYDeltaI = dYDeltaI + dGainOnReclamping
+            table.insert( vCmd, { 12, 1})
+            dBeamMove = dBeamMove - dGainOnReclamping
+         end
+
+         table.insert( vCmd, { 11, 0})
+
+         dTPosA = dTPosI + dBeamMove
+         dYPosA = dTPosA + dYDeltaF
+         dVPosA = dTPosA + dVDeltaI
+         table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+
+        -- la morsa allo scarico è adesso in posizione
+         dYDeltaI = dYDeltaF
+         dTPosI = dTPosA
+
+        -- blocco la morsa
+         table.insert( vCmd, { 11, 1})
+
+         -- imposto i nuovi parametri di aggancio
+         if EMC.YDELTANEXT and EMC.VDELTANEXT  then
+            if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then
+               table.insert( vCmd, { 12, 0})
+               dTPosA = dTPosF
+               dYPosA = dTPosF + dYDeltaF
+               dVPosA = dTPosF + dVDeltaF
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 12, 1})
+               -- la morsa al carico è adesso in posizione
+               dVDeltaI = dVDeltaF
+            end
+            table.insert( vCmd, { 21, dYDeltaF, dVDeltaF})
+         elseif EMC.VDELTANEXT then
+            if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then
+               table.insert( vCmd, { 12, 0})
+               dVPosA = min( MaxV, dTPosI + dVDeltaF)
+               dTPosA = dVPosA - dVDeltaF
+               dYPosA = dTPosA + dYDeltaF
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 12, 1})
+               -- la morsa al carico è adesso in posizione
+               dVDeltaI = dVDeltaF
+            end
+            table.insert( vCmd, { 11, 0})
+            -- sposto il carrello Y in parcheggio
+            table.insert( vCmd, { 1, 'Y', ParkY})
+            table.insert( vCmd, { 21, 0, dVDeltaF})
+         else
+            table.insert( vCmd, { 12, 0})
+            -- sposto il carrello V in parcheggio
+            table.insert( vCmd, { 1, 'V', ParkV})
+            table.insert( vCmd, { 21, dYDeltaF, 0})
+         end
+         -- movimento terminato
+         dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF
+
+      -- TERZO CASO -> PASSO DEL PELLEGRINO
+      -- non è possibile fare scambio diretto.
+      -- le morse vengono compattate e allargate sfruttando tutta la corsa X, massimizzando spostamento trave 
+      else
+         EMC.PILGRIMSTEP = false
+         local bUpdateValues = false
+         table.insert( vCmd, { 0, 'Pilgrim Cycle'})
+         -- compatto al centro
+         if not EMC.YDELTA then
+            table.insert( vCmd, { 0, 'Compact Y'})
+            table.insert( vCmd, { 11, 0})
+            dTPosA = MaxV - dVDeltaI
+            dVPosA = MaxV
+            dYPosA = MyMinY
+            table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+            table.insert( vCmd, { 11, 1})
+            dYDeltaI = dVDeltaI - MaxV + MyMinY
+            EMC.YDELTA = dYDeltaI
+            bUpdateValues = true
+         end
+         if not EMC.VDELTA then
+            table.insert( vCmd, { 0, 'Compact V'})
+            table.insert( vCmd, { 12, 0})
+            dTPosA = MyMinY - dYDeltaI
+            dVPosA = MaxV
+            dYPosA = MyMinY
+            table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+            table.insert( vCmd, { 12, 1})
+            dVDeltaI = dYDeltaI + MaxV - MyMinY
+            EMC.VDELTA = dVDeltaI
+            bUpdateValues = true
+         end
+
+         -- se si sono compattate le morse, bisogna aggiornare le posizioni e i massimi recuperi
+         if bUpdateValues then
+            dTPosI = dTPosA
+            dYPosI = dYPosA
+            dVPosI = dVPosA
+            dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV
+            dMaxMovePilgrimStepSingleClampY = MaxY - MinY
+            dMaxMovePilgrimStepSingleClampV = - MinV + MaxV
+         end
+
+         -- aggiorno delta mancante
+         dDeltaBeam = dTPosI - dTPosF
+
+         -- a questo punto entrambe le pinze sono in presa sul pezzo.
+         -- Il trascinatore si decide in base alla direzione di movimento trave
+         -- trascino con morsa allo scarico. Obiettivo mandare Y in posizione per prima
+         if dDeltaBeam > 0 then
+            -- se serve un grande spostamento e si sta pinzando poco. Y trascinatore pinza poco e V si sposta per prima per recuperare
+            if not BD.FASTCLAMPING and abs( dDeltaBeam) > 2000 and dVDeltaI < max( 550, (MinJoin * 2)) then
+               table.insert( vCmd, { 11, 0})
+               dYPosA = dYPosI + dGainOnReclamping
+               -- sposto il carrello V di 1000mm
+               table.insert( vCmd, { 1, 'Y', dYPosA})
+               table.insert( vCmd, { 11, 1})
+               -- apro morsa Y e recupero i 1000mm
+               table.insert( vCmd, { 12, 0})
+               dVPosA = dVPosI
+               dYPosA = dYPosI 
+               dTPosA = dTPosI - dGainOnReclamping
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               dTPosI = dTPosA
+               dVPosI = dVPosA
+               dVDeltaI = dVDeltaI + dGainOnReclamping
+               dYDeltaI = dYDeltaI + dGainOnReclamping
+               table.insert( vCmd, { 12, 1})
+            end
+
+            -- apro morsa al carico
+            table.insert( vCmd, { 11, 0})
+            -- devo recuperare più delle corse disponibili di entrambi i carrelli
+            if abs( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepDoubleClamp then
+               dYPosA = MaxY
+               dVPosA = MinV
+               dTPosA = dTPosI - dVPosI + MinV
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 11, 1})
+               table.insert( vCmd, { 12, 0})
+               -- nuova posizione della morsa al carico dopo riposizionamento
+               dYDeltaI = MaxY - dTPosA
+               dTPosI = dTPosA
+               EMC.YDELTA = dYDeltaI
+               EMC.VDELTA = nil
+               EMC.PILGRIMSTEP = true
+               -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
+               SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
+            -- recupero una corsa massima e l'altra solo di quello che serve
+            elseif abs( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepSingleClampY then
+               -- morsa Y arriva in posizione finale
+               dYDeltaI = dYDeltaF
+               dVPosA = MinV
+               dTPosA = dTPosI - MaxV + MinV
+               dYPosA = dYDeltaF + dTPosA
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 11, 1})
+               table.insert( vCmd, { 12, 0})
+               dTPosI = dTPosA
+               EMC.YDELTA = dYDeltaF
+               EMC.VDELTA = dVDeltaI
+               -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
+               SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
+            -- non serve recuperare al massimo della corsa, suddivido movimento in due
+            else
+               -- suddivido il movimento su entrambe le morse
+               local dTotMove = ( dYDeltaF - dYDeltaI) / 2
+
+               if abs( dTotMove) > 10 * GEO.EPS_SMALL then
+                  dYPosA = dTPosI + dYDeltaI + dTotMove
+                  dVPosA = dTPosI + dVDeltaI - dTotMove
+                  dTPosA = dTPosI - dTotMove
+                  table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+                  table.insert( vCmd, { 11, 1})
+                  table.insert( vCmd, { 12, 0})
+
+                  -- aggiorno nuova posizione della morsa al carico dopo riposizionamento
+                  dYDeltaI = dYDeltaF ;
+
+                  if not EMC.VDELTANEXT then
+                     dTPosA = dTPosF
+                     dYPosA = dTPosF + dYDeltaF
+                     dVPosA = ParkV
+                  elseif EMC.YDELTANEXT then
+                     dTPosA = dTPosF
+                     dYPosA = dTPosF + dYDeltaF
+                     dVPosA = dTPosF + dVDeltaF
+                  else
+                     dYPosA = MyMinY
+                     dTPosA = MyMinY - dYDeltaF
+                     dVPosA = dTPosA + dVDeltaF
+                  end
+                  table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+                  dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF
+
+                 -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento
+                  dVDeltaI = dVDeltaF
+               end
+
+               -- imposto i nuovi parametri di aggancio
+               if EMC.YDELTANEXT and EMC.VDELTANEXT  then
+                  table.insert( vCmd, { 12, 1})
+                  table.insert( vCmd, { 21, dYDeltaF, dVDeltaF})
+               elseif EMC.YDELTANEXT then
+                  table.insert( vCmd, { 21, dYDeltaF, 0})
+               else
+                  table.insert( vCmd, { 12, 1})
+                  table.insert( vCmd, { 11, 0})
+                  -- sposto il carrello Y in parcheggio
+                  table.insert( vCmd, { 1, 'Y', ParkY})
+                  table.insert( vCmd, { 21, 0, dVDeltaF})
+               end
+            end
+         -- trave si muove dallo scarico verso il carico. Obiettivo mandare V in posizione per prima
+         else
+            -- se serve un grande spostamento e si sta pinzando poco. Y trascinatore pinza poco e V si sposta per prima per recuperare
+            if not BD.FASTCLAMPING and abs( dDeltaBeam) > 2000 and EMC.LB - dYDeltaI < max( 550, (MinJoin * 2)) then
+               table.insert( vCmd, { 12, 0})
+               dVPosA = dVPosI - dGainOnReclamping
+               -- sposto il carrello V di 1000mm
+               table.insert( vCmd, { 1, 'V', dVPosA})
+               table.insert( vCmd, { 12, 1})
+               -- apro morsa Y e recupero i 1000mm
+               table.insert( vCmd, { 11, 0})
+               dVPosA = dVPosI
+               dYPosA = dYPosI 
+               dTPosA = dTPosI + dGainOnReclamping
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               dTPosI = dTPosA
+               dVPosI = dVPosA
+               dVDeltaI = dVDeltaI - dGainOnReclamping
+               dYDeltaI = dYDeltaI - dGainOnReclamping
+               table.insert( vCmd, { 11, 1})
+            end
+
+            -- apro morsa allo scarico
+            table.insert( vCmd, { 12, 0})
+            -- devo recuperare più del doppio delle corse
+            local dMaxMoveFirst
+            if abs( dVDeltaI - dVDeltaF) > dMaxMovePilgrimStepDoubleClamp then
+               dYPosA = MaxY
+               dVPosA = MinV
+               dTPosA = dTPosI + ( MaxY - dYPosI)
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 12, 1})
+               table.insert( vCmd, { 11, 0})
+               -- nuova posizione della morsa allo scarico dopo riposizionamento
+               dVDeltaI = MinV - dTPosA
+               dTPosI = dTPosA
+               EMC.YDELTA = nil
+               EMC.VDELTA = dVDeltaI
+               EMC.PILGRIMSTEP = true
+               -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
+               SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
+            -- recupero una corsa massima e l'altra solo di quello che serve
+            elseif abs( dVDeltaI - dVDeltaF) > dMaxMovePilgrimStepSingleClampV then
+               -- aggiorno nuova posizione della morsa al carico dopo riposizionamento
+               local dTotMove = MaxY - dTPosI - dYDeltaI
+               dVDeltaI = dVDeltaF
+               dYPosA = MaxY
+               dTPosA = dTPosI + dTotMove
+               dVPosA = dVDeltaF + dTPosA
+               table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+               table.insert( vCmd, { 12, 1})
+               table.insert( vCmd, { 11, 0})
+               dTPosI = dTPosA
+               EMC.YDELTA = dYDeltaI
+               EMC.VDELTA = dVDeltaF
+               -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
+               SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
+            -- non serve recuperare al massimo della corsa, suddivido movimento in due
+            else
+               -- suddivido il movimento su entrambe le morse
+               local dTotMove = ( dVDeltaI - dVDeltaF) / 2
+
+               if abs( dTotMove) > 10 * GEO.EPS_SMALL then
+                  dYPosA = dTPosI + dYDeltaI + dTotMove
+                  dVPosA = dTPosI + dVDeltaI - dTotMove
+                  dTPosA = dTPosI + dTotMove
+                  table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+                  table.insert( vCmd, { 12, 1})
+                  table.insert( vCmd, { 11, 0})
+
+                  -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento
+                  dVDeltaI = dVDeltaF ;
+
+                  if not EMC.YDELTANEXT then
+                     dTPosA = dTPosF
+                     dVPosA = dTPosF + dVDeltaF
+                     dYPosA = ParkY
+                  elseif EMC.VDELTANEXT then
+                     dTPosA = dTPosF
+                     dYPosA = dTPosF + dYDeltaF
+                     dVPosA = dTPosF + dVDeltaF
+                  else
+                     dVPosA = MaxV
+                     dTPosA = MaxV - dVDeltaF
+                     dYPosA = dTPosA + dYDeltaF
+                  end
+                  table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
+                  dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF
+
+                  -- aggiorno nuova posizione della morsa al carico dopo riposizionamento
+                  dYDeltaI = dYDeltaF
+               end
+
+              -- sistemo apertura morse
+               if EMC.YDELTANEXT then
+                  table.insert( vCmd, { 11, 1})
+               end
+               if not EMC.VDELTANEXT then
+                  table.insert( vCmd, { 12, 0})
+                  -- sposto il carrello Y in parcheggio
+                  table.insert( vCmd, { 1, 'V', ParkV})
+               end
+
+               -- imposto i nuovi parametri di aggancio
+               if EMC.YDELTANEXT and EMC.VDELTANEXT  then
+                  table.insert( vCmd, { 11, 1})
+                  table.insert( vCmd, { 21, dYDeltaF, dVDeltaF})
+               elseif EMC.YDELTANEXT then
+                  table.insert( vCmd, { 11, 1})
+                  -- sposto il carrello Y in parcheggio
+                  table.insert( vCmd, { 12, 0})
+                  table.insert( vCmd, { 1, 'V', ParkV})
+                  table.insert( vCmd, { 21, dYDeltaF, 0})
+               else
+                  table.insert( vCmd, { 21, 0, dVDeltaF})
+               end
+            end
+         end
+      end
+   end
+end
+
+---------------------------------------------------------------------
+function SpecOutputCNT()
+   if EMC.CNT == 1 then
+      EgtSetInfo( EMC.PATHID, 'CNT', 1)
+   else
+      EgtRemoveInfo( EMC.PATHID, 'CNT')
+   end
+end
+
+---------------------------------------------------------------------
+function SpecOutputCmds( vCmd, bEnd)
+
+   local sRoot = EgtIf( not bEnd, 'AS', 'AE')
+
+   -- Registro il numero di comandi
+   if #vCmd > 0 then
+      EgtSetInfo( EMC.PATHID, sRoot..'#', #vCmd)
+   else
+      EgtRemoveInfo( EMC.PATHID, sRoot..'#')
+   end
+   -- Registro i comandi
+   for i = 1, #vCmd do
+      local Cmd = vCmd[i]
+      local sKey = sRoot..tostring( i)
+      -- commento
+      if Cmd[1] == 0 then
+         local sInfo = '0,'..Cmd[2]
+         if Cmd[3] then sInfo = sInfo..','..Cmd[3] end
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+      -- movimento di 1 asse
+      elseif Cmd[1] == 1 then
+         local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+      -- movimento di 2 assi
+      elseif Cmd[1] == 2 then
+         local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+      -- movimento di 3 assi
+      elseif Cmd[1] == 3 then
+         local sInfo = '3,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..','..
+                             Cmd[6]..','..EgtNumToString( Cmd[7],3)
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+      -- apertura/chiusura morsa Y
+      elseif Cmd[1] == 11 then
+         local sInfo = '11,'..EgtNumToString( Cmd[2],0)
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+         if Cmd[2] == 0 then EMC.YDELTA = nil end
+      -- apertura/chiusura morsa V
+      elseif Cmd[1] == 12 then
+         local sInfo = '12,'..EgtNumToString( Cmd[2],0)
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+         if Cmd[2] == 0 then EMC.VDELTA = nil end
+      -- impostazione nuovo stato dei carrelli
+      elseif Cmd[1] == 21 then
+         local sInfo = '21,'..EgtNumToString( Cmd[2],3)..','..EgtNumToString( Cmd[3],3)
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+         if Cmd[2] > 0 and Cmd[3] > 0 then
+            EMC.YDELTA = Cmd[2]
+            EMC.VDELTA = Cmd[3]
+         elseif Cmd[2] > 0 then
+            EMC.YDELTA = Cmd[2]
+            EMC.VDELTA = nil
+         elseif Cmd[3] > 0 then
+            EMC.YDELTA = nil
+            EMC.VDELTA = Cmd[3]
+         end
+      -- aggancio grezzo a carrello
+      elseif Cmd[1] == 31 then
+         local sInfo = '31,'..EgtNumToString( Cmd[2],0)..','..Cmd[3]
+         EgtSetInfo( EMC.PATHID, sKey, sInfo)
+      end
+   end
+
+   -- Salvo i nuovi delta dei carrelli
+   if EMC.YDELTA then
+      EgtSetInfo( EMC.PATHID, 'YDELTA', EMC.YDELTA)
+   else
+      EgtRemoveInfo( EMC.PATHID, 'YDELTA')
+   end
+   if EMC.VDELTA then
+      EgtSetInfo( EMC.PATHID, 'VDELTA', EMC.VDELTA)
+   else
+      EgtRemoveInfo( EMC.PATHID, 'VDELTA')
+   end
+
+end
+
+---------------------------------------------------------------------
+function SpecSetCarrPosFromCmds( vCmd)
+   -- recupero nuova posizione carrelli
+   for i = 1, #vCmd do
+      local Cmd = vCmd[i]
+      if Cmd[1] == 21 then
+         if Cmd[2] > 0 and Cmd[3] > 0 then
+            EMC.YDELTA = Cmd[2]
+            EMC.VDELTA = Cmd[3]
+         elseif Cmd[2] > 0 then
+            EMC.YDELTA = Cmd[2]
+            EMC.VDELTA = nil
+         elseif Cmd[3] > 0 then
+            EMC.YDELTA = nil
+            EMC.VDELTA = Cmd[3]
+         end
+      end
+   end
+end
+
+---------------------------------------------------------------------
+function SpecTestOnlyRemarkInCmds( vCmd)
+   if not vCmd then return true end
+   -- verifico se nella lista dei comandi ci sono solo commenti
+   for i = 1, #vCmd do
+      if vCmd[i][1] ~= 0 then
+         return false
+      end
+   end
+   return true
+end
+
+---------------------------------------------------------------------
+--XXXXX  XXXXX  XXXXX ---  TO REMOVE  --- XXXXX  XXXXX  XXXXX XXXXX--
+---------------------------------------------------------------------
+---------------------------------------------------------------------
+function SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos)
+
+   local MinFrontJoin = MinJoin + EMC.HCING + EMC.HOVM
+   local MinBackJoin = MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0)
+   local MyMinOther = MinOther + EgtIf( EMC.CNT == 1, AGG_LOAD, 0) 
+
+   local dDistFrontEff = min( dDistFront, EMC.LB - MyMinOther - EMC.TCING)
+   if bFixedDelta and IsMid2Phase( EMC.PHASE + 1) then
+      dDistFrontEff = min( dDistFrontEff, EMC.LR - MinOther - EMC.TCING)
+   end
+   local dDistBackEff = min( dDistBack, EMC.LB - MyMinOther - EMC.HCING - EMC.HOVM)
+
+   EgtOutLog( '  Dist/Min : Back=' .. EgtNumToString( dDistBackEff, 1) .. '/' .. EgtNumToString( MinBackJoin, 1) ..
+              ' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1) ..
+              '  Fixed : Delta=' .. EgtIf( bFixedDelta, 'T', 'F') .. ' Pos=' .. EgtIf( bFixedPos, 'T', 'F'), 3)
+
+   -- [A] se posso mettere solo carrello Y
+   if dDistFrontEff < MinFrontJoin  and  dDistBackEff > MinBackJoin - GEO.EPS_SMALL then
+
+      local dPosT = EMC.TPOS
+      local dYDelta = EMC.YDELTA
+      local dVDelta = EMC.VDELTA
+
+      local dNewPosT = nil
+      local dNewYDelta = EMC.LB - dDistBackEff
+      local dNewVDelta = nil
+
+      return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
+
+   -- [B] se altrimenti posso mettere entrambi i carrelli Y e V
+   elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL  and
+          dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then
+
+      local dPosT = EMC.TPOS
+      local dYDelta = EMC.YDELTA
+      local dVDelta = EMC.VDELTA
+
+      local dNewPosT = nil
+      local dNewYDelta = EMC.LB - dDistBackEff
+      local dNewVDelta = dDistFrontEff
+
+      return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
+
+   -- [C] se altrimenti posso mettere solo carrello V
+   elseif dDistBackEff < MinBackJoin  and  dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then
+
+      local dPosT = EMC.TPOS
+      local dYDelta = EMC.YDELTA
+      local dVDelta = EMC.VDELTA
+
+      local dNewPosT = nil
+      local dNewYDelta = nil
+      local dNewVDelta = dDistFrontEff
+
+      return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
+
+   -- altrimenti errore
+   else
+      if EgtGetDebugLevel() < 3 then
+         EgtOutLog( '  Dist/Min : Back=' .. EgtNumToString( dDistBackEff, 1) .. '/' .. EgtNumToString( MinBackJoin, 1) ..
+                    ' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1))
+      end
+      EgtOutLog( '  Error CLAMP impossible')
+      EMC.ERR = 18
+      return {}
+   end
+end
+
+---------------------------------------------------------------------
+function SpecAdjustCarriagesOLD( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
    -- [A] richiesto solo carrello Y
    if dYDeltaF and  ( not dVDeltaF) then
       -- [A1] rimango sul carrello Y
@@ -1388,7 +2245,6 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe
          EgtOutLog( '  Error CLAMP NULL-> Y impossibile')
          error( 'Error CLAMP NULL-> Y impossibile')
       end
-
    -- (B) richiesti entrambi i carrelli
    elseif dYDeltaF and dVDeltaF then
       -- [B1] passo da carrello Y a entrambi
@@ -1404,7 +2260,6 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe
          EgtOutLog( '  Error CLAMP NULL-> Y+V impossibile')
          error( 'Error CLAMP NULL-> Y+V impossibile')
       end
-
    -- [C] richiesto solo carrello V
    elseif ( not dYDeltaF) and dVDeltaF then
       -- [C1] provengo da solo carrello Y
@@ -1420,9 +2275,7 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe
          EgtOutLog( '  Error CLAMP NULL-> V impossibile')
          error( 'Error CLAMP NULL-> V impossibile')
       end
-
    end
-
 end
 
 ---------------------------------------------------------------------
@@ -1436,35 +2289,6 @@ local function CalcCharStatus( sType, dDelta)
    end
 end
 
----------------------------------------------------------------------
-local function GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta)
-   local dDeltaTolEff = DELTA_SIC
-   if Carr == 'Y' then
-      local dLenPreEff = dLenPresa - TCING
-      if dLenPreEff < MinJoin + DeltaTol then
-         dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL)
-      else
-         if BD.GO_FAST and BD.GO_FAST ~= 0 then
-            if bFixedDelta == false then
-               dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200)
-            else
-               dDeltaTolEff = 900
-            end
-         else
-            dDeltaTolEff = DeltaTol
-         end
-      end
-   elseif Carr == 'V' then
-      local dLenPreEff = dLenPresa - HCING - HOVM
-      if dLenPreEff < MinJoin + DeltaTol then
-         dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL)
-      else
-         dDeltaTolEff = DeltaTol
-      end
-   end
-   return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff)
-end
-
 ---------------------------------------------------------------------
 local function GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistN, sSide)
    local dRecTotn = min( dDistN, dCorsaYfc+ dCorsaVfc) -- recupero possibile al netto di dCorsa..TrA)
@@ -3734,122 +4558,3 @@ function SpecAdjustCarrC3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDelta
    SpecOutputCNT()
    return vCmd
 end --SpecAdjustCarrC3
-
----------------------------------------------------------------------
-function SpecOutputCNT()
-   if EMC.CNT == 1 then
-      EgtSetInfo( EMC.PATHID, 'CNT', 1)
-   else
-      EgtRemoveInfo( EMC.PATHID, 'CNT')
-   end
-end
-
----------------------------------------------------------------------
-function SpecOutputCmds( vCmd, bEnd)
-
-   local sRoot = EgtIf( not bEnd, 'AS', 'AE')
-
-   -- Registro il numero di comandi
-   if #vCmd > 0 then
-      EgtSetInfo( EMC.PATHID, sRoot..'#', #vCmd)
-   else
-      EgtRemoveInfo( EMC.PATHID, sRoot..'#')
-   end
-   -- Registro i comandi
-   for i = 1, #vCmd do
-      local Cmd = vCmd[i]
-      local sKey = sRoot..tostring( i)
-      -- commento
-      if Cmd[1] == 0 then
-         local sInfo = '0,'..Cmd[2]
-         if Cmd[3] then sInfo = sInfo..','..Cmd[3] end
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-      -- movimento di 1 asse
-      elseif Cmd[1] == 1 then
-         local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-      -- movimento di 2 assi
-      elseif Cmd[1] == 2 then
-         local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-      -- movimento di 3 assi
-      elseif Cmd[1] == 3 then
-         local sInfo = '3,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..','..
-                             Cmd[6]..','..EgtNumToString( Cmd[7],3)
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-      -- apertura/chiusura morsa Y
-      elseif Cmd[1] == 11 then
-         local sInfo = '11,'..EgtNumToString( Cmd[2],0)
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-         if Cmd[2] == 0 then EMC.YDELTA = nil end
-      -- apertura/chiusura morsa V
-      elseif Cmd[1] == 12 then
-         local sInfo = '12,'..EgtNumToString( Cmd[2],0)
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-         if Cmd[2] == 0 then EMC.VDELTA = nil end
-      -- impostazione nuovo stato dei carrelli
-      elseif Cmd[1] == 21 then
-         local sInfo = '21,'..EgtNumToString( Cmd[2],3)..','..EgtNumToString( Cmd[3],3)
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-         if Cmd[2] > 0 and Cmd[3] > 0 then
-            EMC.YDELTA = Cmd[2]
-            EMC.VDELTA = Cmd[3]
-         elseif Cmd[2] > 0 then
-            EMC.YDELTA = Cmd[2]
-            EMC.VDELTA = nil
-         elseif Cmd[3] > 0 then
-            EMC.YDELTA = nil
-            EMC.VDELTA = Cmd[3]
-         end
-      -- aggancio grezzo a carrello
-      elseif Cmd[1] == 31 then
-         local sInfo = '31,'..EgtNumToString( Cmd[2],0)..','..Cmd[3]
-         EgtSetInfo( EMC.PATHID, sKey, sInfo)
-      end
-   end
-
-   -- Salvo i nuovi delta dei carrelli
-   if EMC.YDELTA then
-      EgtSetInfo( EMC.PATHID, 'YDELTA', EMC.YDELTA)
-   else
-      EgtRemoveInfo( EMC.PATHID, 'YDELTA')
-   end
-   if EMC.VDELTA then
-      EgtSetInfo( EMC.PATHID, 'VDELTA', EMC.VDELTA)
-   else
-      EgtRemoveInfo( EMC.PATHID, 'VDELTA')
-   end
-
-end
-
----------------------------------------------------------------------
-function SpecSetCarrPosFromCmds( vCmd)
-   -- recupero nuova posizione carrelli
-   for i = 1, #vCmd do
-      local Cmd = vCmd[i]
-      if Cmd[1] == 21 then
-         if Cmd[2] > 0 and Cmd[3] > 0 then
-            EMC.YDELTA = Cmd[2]
-            EMC.VDELTA = Cmd[3]
-         elseif Cmd[2] > 0 then
-            EMC.YDELTA = Cmd[2]
-            EMC.VDELTA = nil
-         elseif Cmd[3] > 0 then
-            EMC.YDELTA = nil
-            EMC.VDELTA = Cmd[3]
-         end
-      end
-   end
-end
-
----------------------------------------------------------------------
-function SpecTestOnlyRemarkInCmds( vCmd)
-   if not vCmd then return true end
-   -- verifico se nella lista dei comandi ci sono solo commenti   
-   for i = 1, #vCmd do
-      if vCmd[i][1] ~= 0 then
-         return false
-      end   
-   end 
-   return true
-end
diff --git a/Essetre-FAST.mlde b/Essetre-FAST.mlde
index 2bd5f99..031b68b 100644
--- a/Essetre-FAST.mlde
+++ b/Essetre-FAST.mlde
@@ -62,11 +62,18 @@
 -- 2024/09/02 AV ver 2.6i1 Allineamento con common ver. 2.6i1, Rimossi file "Common-"
 -- 2024/09/02 AV ver 2.6i2 Corretto file YML per compilare file "Common_"
 -- 2024/09/05 LM ver 2.6i3 In BeamData aggiunte costanti MIN_HEIGHT_ADDED_CUTS, PRECUT_HEAD, PRECUT_TAIL
+-- 2024/09/06 LM ver 2.6i4 In BeamData le costanti sopra sono configurabili anche da offsets Ts3v7
+-- 2024/09/16 AV ver 2.6i5 Allineamento con common ver. 2.6i2
+-- 2024/09/18 LM ver 2.6i6 Modificato YAML per comunicazione versioni a LiMan. Aggiunta PP_NVER, versione in formato numerico.
+-- 2024/09/23 AV ver 2.6i7 Allineamento con common ver. 2.6i3
+-- 2024/09/24 AV ver 2.6i8 Allineamento con common ver. 2.6i4
+-- 2024/09/24 AV ver 2.6i9 Allineamento con common ver. 2.6i5
 
 require( 'EmtGenerator')
 EgtEnableDebug( false)
 
-PP_VER = '2.6i3'
+PP_VER = '2.6i9'
+PP_NVER = '2.6.9.9'
 MIN_MACH_VER = '2.5k1'
 MACH_NAME = 'Essetre-FAST'
 
diff --git a/UpdateLog.txt b/UpdateLog.txt
index 8de1215..c167a31 100644
--- a/UpdateLog.txt
+++ b/UpdateLog.txt
@@ -1,5 +1,22 @@
            ==== Common_FAST Update Log ====
 
+Versione 2.6i5 (24/09/2024)
+- (SIM-GEN) Tolto controllo su lunghezza maggiore di 200mm introdotto con 2.6i2 perchè non completamente funzionante
+- (GEN) Gestione in OnRapid() di EMT.FLAG=5 (rotazione a Z max per lavorazione successiva). Ora allineata alla simulazione
+
+Versione 2.6i4 (24/09/2024)
+- (SIM-GEN) Aggiunto ripinzaggio extra in caso servisse un grande spostamento e si sta pinzando poco.
+            L'aggiunta del ripinzaggio dipende da FASTCLAMPING (che deve essere disattiva). Viene aggiunta GAIN_RECLAMPING per decidere il guadagno in mm del ripinzaggio.
+
+Versione 2.6i3 (23/09/2024)
+- (SIM-GEN) Aggiunta nuova strategia riposizionamento morse
+- (SIM-GEN) Aggiunta lettura flag NEWCLAMPING in BeamData, per abilitare nuova strategia riposizionamento. Se false o nil, funziona con metodo vecchio.
+- (SIM-GEN) Aggiunta lettura flag FASTCLAMPING. Se false, al carico prende al massimo 1000mm, per evitare collisioni durante ciclo di lettura laser e prima lavorazione.
+
+Versione 2.6i2 (16/09/2024)
+- (SIM-GEN) Se utensili più lunghi di 200mm, si ruota in home e poi si approccia il pezzo.  Ticket#2038
+- (SIM-GEN) Aumentata distanza ingombro da 650mm a 660mm. In casi di utensile abbastanza lungo poteva andare in colisione. Ticket#2041
+
 Versione 2.6i1 (02/09/2024)
 - (MLDE-SIM-GEN) Rinominato file da "Common-" a "Common_" per uniformità con i file common delle altre macchine. Serve modifica a MLDE macchina.
 
diff --git a/Version.lua b/Version.lua
index 3596be2..8ee9825 100644
--- a/Version.lua
+++ b/Version.lua
@@ -3,7 +3,7 @@
 
 local InfoCommon_STD_PP = {
    NAME = 'Common_FAST',            -- nome script PP standard
-   VERSION = '2.6i1',                 -- versione script
+   VERSION = '2.6i5',                 -- versione script
    MIN_MACH_VER_PP_COMMON = '2.5k1'   -- versione minima kernel
 }