diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index d0b37fc..87f00e1 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/Head.cpp b/Head.cpp
index 3e9abae..0d1f37e 100644
--- a/Head.cpp
+++ b/Head.cpp
@@ -49,6 +49,7 @@ Head::Clone( void) const
             pHead->m_vsHSet = m_vsHSet ;
             pHead->m_vtADir = m_vtADir ;
             pHead->m_dRot1W = m_dRot1W ;
+            pHead->m_bMaxDeltaR2On1 = m_bMaxDeltaR2On1 ;
             pHead->m_Rot2Stroke = m_Rot2Stroke ;
             pHead->m_nSolCh = m_nSolCh ;
       }
@@ -102,7 +103,7 @@ Head::GetGeomDB( void) const
 //----------------------------------------------------------------------------
 Head::Head( void)
    : m_nOwnerId( GDB_ID_NULL), m_pGeomDB( nullptr), m_nType( MCH_HT_NONE), m_nExitCount( 0), 
-     m_dRot1W( 1), m_nSolCh( MCH_SCC_NONE)
+     m_dRot1W( 1), m_bMaxDeltaR2On1( true), m_nSolCh( MCH_SCC_NONE)
 {
    m_Rot2Stroke.Min = - INFINITO ;
    m_Rot2Stroke.Max = INFINITO ;
@@ -111,7 +112,7 @@ Head::Head( void)
 //----------------------------------------------------------------------------
 bool
 Head::Set( const string& sName, int nType, int nExitCount, const string& sHSet, const Vector3d& vtADir,
-           double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl)
+           double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl)
 {
    m_sName = sName ;
    m_nType = nType ;
@@ -124,6 +125,7 @@ Head::Set( const string& sName, int nType, int nExitCount, const string& sHSet,
    m_vtADir = vtADir ;
    m_vtADir.Normalize() ;
    m_dRot1W = dRot1W ;
+   m_bMaxDeltaR2On1 = bMaxDeltaR2On1 ;
    m_Rot2Stroke = Rot2Stroke ;
    if ( IsValidHeadScc( nSolCh))
       m_nSolCh = nSolCh ;
diff --git a/Head.h b/Head.h
index 72ff153..072027a 100644
--- a/Head.h
+++ b/Head.h
@@ -31,7 +31,7 @@ class Head : public IUserObj
    public :
       Head( void) ;
       bool Set( const std::string& sName, int nType, int nExitCount, const std::string& sHSet,
-                const Vector3d& vtADir, double dRot1W, const STROKE& Rot2Stroke, int nSolCh,
+                const Vector3d& vtADir, double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh,
                 const STRVECTOR& vsOthColl) ;
       bool AddHeadToHSet( const std::string& sHead) ;
       bool ModifyHeadAuxDirection( const Vector3d& vtADir) ;
@@ -47,6 +47,8 @@ class Head : public IUserObj
                { return m_vtADir ; }
       double GetRot1W( void) const
                { return m_dRot1W ; }
+      bool GetMaxDeltaR2On1( void) const
+               { return m_bMaxDeltaR2On1 ; }
       const STROKE& GetRot2Stroke( void) const
                { return m_Rot2Stroke ; }
       int GetSolCh( void) const
@@ -63,6 +65,7 @@ class Head : public IUserObj
       STRVECTOR   m_vsHSet ;
       Vector3d    m_vtADir ;
       double      m_dRot1W ;
+      bool        m_bMaxDeltaR2On1 ;
       STROKE      m_Rot2Stroke ;
       int         m_nSolCh ;
       STRVECTOR   m_vsOtherColl ;
diff --git a/MachMgr.h b/MachMgr.h
index c4c6915..e4c1909 100644
--- a/MachMgr.h
+++ b/MachMgr.h
@@ -442,6 +442,7 @@ class MachMgr : public IMachMgr
       int  GetCalcHead( void) const ;
       int  GetCalcExit( void) const ;
       double GetCalcRot1W( void) const ;
+      bool GetCalcMaxDeltaR2OnFirst( void) const ;
       bool GetCalcPartDirFromAngles( const Vector3d& vtPart, const DBLVECTOR& vAng, Vector3d& vtDir) const ;
       bool SetCalcSolCh( int nScc, bool bExact) ;
       bool VerifyAngleOutstroke( int nInd, double dAng) const ;
diff --git a/MachMgrMachines.cpp b/MachMgrMachines.cpp
index 9fd6a88..c2f2682 100644
--- a/MachMgrMachines.cpp
+++ b/MachMgrMachines.cpp
@@ -584,7 +584,15 @@ double
 MachMgr::GetCalcRot1W( void) const
 {
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetCurrRot1W() : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetCurrRot1W() : 1) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetCalcMaxDeltaR2OnFirst( void) const
+{
+   Machine* pMch = GetCurrMachine() ;
+   return ( ( pMch != nullptr) ? pMch->GetCurrMaxDeltaR2OnFirst() : true) ;
 }
 
 //----------------------------------------------------------------------------
diff --git a/Machine.cpp b/Machine.cpp
index 4cea9f3..b81fa02 100644
--- a/Machine.cpp
+++ b/Machine.cpp
@@ -46,6 +46,7 @@ Machine::Machine( void)
    m_nCalcExitId = GDB_ID_NULL ;
    m_nCalcToolId = GDB_ID_NULL ;
    m_dCalcRot1W = 1 ;
+   m_bCalcMaxDeltaR2On1 = true ;
    m_nCalcSolCh = MCH_SCC_NONE ;
    m_dCalcTLen = 0 ;
    m_dCalcTRad = 0 ;
@@ -499,7 +500,7 @@ Machine::ModifyMachineAxisHome( const string& sName, double dHome)
 bool
 Machine::LoadMachineStdHead( const string& sName, const string& sParent, const string& sHSet,
                              const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
-                             double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
+                             double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                              const string& sGeo, const STRVECTOR& vsAux)
 {
   // recupero pezzo e layer della geometria originale della testa
@@ -527,7 +528,7 @@ Machine::LoadMachineStdHead( const string& sName, const string& sParent, const s
    Head* pHead = new(nothrow) Head ;
    if ( pHead == nullptr)
       return false ;
-   pHead->Set( sName, MCH_HT_STD, 1, sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh, vsOthColl) ;
+   pHead->Set( sName, MCH_HT_STD, 1, sHSet, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
    m_pGeomDB->SetUserObj( nLay, pHead) ;
   // aggiorno la testa capostipite
    if ( ! AddHeadToSet( sHSet, sName))
@@ -548,7 +549,7 @@ Machine::LoadMachineStdHead( const string& sName, const string& sParent, const s
 bool
 Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const string& sHSet,
                                const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
-                               double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
+                               double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                const string& sGeo, const STRVECTOR& vsAux)
 {
   // recupero pezzo e layer della geometria originale della testa
@@ -576,7 +577,7 @@ Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const
    Head* pHead = new(nothrow) Head ;
    if ( pHead == nullptr)
       return false ;
-   pHead->Set( sName, MCH_HT_MULTI, int( vMuExit.size()), sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh, vsOthColl) ;
+   pHead->Set( sName, MCH_HT_MULTI, int( vMuExit.size()), sHSet, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
    m_pGeomDB->SetUserObj( nLay, pHead) ;
   // aggiorno la testa capostipite
    if ( ! AddHeadToSet( sHSet, sName))
@@ -595,7 +596,7 @@ Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const
 bool
 Machine::LoadMachineSpecialHead( const string& sName, const string& sParent, const string& sHSet,
                                  const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
-                                 double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
+                                 double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                  const string& sGeo, const STRVECTOR& vsAux)
 {
   // recupero pezzo e layer della geometria originale della testa
@@ -623,7 +624,7 @@ Machine::LoadMachineSpecialHead( const string& sName, const string& sParent, con
    Head* pHead = new(nothrow) Head ;
    if ( pHead == nullptr)
       return false ;
-   pHead->Set( sName, MCH_HT_SPECIAL, 1, sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh, vsOthColl) ;
+   pHead->Set( sName, MCH_HT_SPECIAL, 1, sHSet, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
    m_pGeomDB->SetUserObj( nLay, pHead) ;
   // aggiorno la testa capostipite
    if ( ! AddHeadToSet( sHSet, sName))
diff --git a/Machine.h b/Machine.h
index f47cbe4..3574343 100644
--- a/Machine.h
+++ b/Machine.h
@@ -101,7 +101,10 @@ class Machine
       int  GetCurrExit( void) const ;
       bool GetCurrExit( int& nExit) const ;
       bool GetCurrHeadCollGroups( INTVECTOR& vIds) const ;
-      double GetCurrRot1W( void) const ;
+      double GetCurrRot1W( void) const
+                { return m_dCalcRot1W ; }
+      bool GetCurrMaxDeltaR2OnFirst( void) const
+                { return m_bCalcMaxDeltaR2On1 ; }
       std::string GetKinematicAxis( int nInd) const ;
       bool BlockKinematicRotAxis( const std::string& sName, double dVal) ;
       bool BlockKinematicRotAxis( int nId, double dVal) ;
@@ -196,15 +199,15 @@ class Machine
       bool ModifyMachineAxisHome( const std::string& sName, double dHome) ;
       bool LoadMachineStdHead( const std::string& sName, const std::string& sParent, const std::string& sHSet,
                                const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
-                               double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
+                               double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                const std::string& sGeo, const STRVECTOR& vsAux) ;
       bool LoadMachineMultiHead( const std::string& sName, const std::string& sParent, const std::string& sHSet,
                                  const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
-                                 double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
+                                 double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                  const std::string& sGeo, const STRVECTOR& vsAux) ;
       bool LoadMachineSpecialHead( const std::string& sName, const std::string& sParent, const std::string& sHSet,
                                    const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
-                                   double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
+                                   double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                    const std::string& sGeo, const STRVECTOR& vsAux) ;
       bool LoadMachineTcPos( const std::string& sName, const std::string& sParent,
                              const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
@@ -280,6 +283,7 @@ class Machine
       int           m_nCalcExitId ;          // uscita corrente per calcoli
       int           m_nCalcToolId ;          // utensile corrente per calcoli
       double        m_dCalcRot1W ;           // peso del primo asse rotante per i confronti
+      bool          m_bCalcMaxDeltaR2On1 ;   // flag utilizzo controllo massimo delta secondo asse rotante su inizio lavorazione
       int           m_nCalcSolCh ;           // criterio di scelta della soluzione
       bool          m_bSolChExact ;          // flag per scelta soluzione da soddisfare esattamente
       Point3d       m_ptCalcPos ;            // posizione utensile a riposo per calcoli
diff --git a/MachineCalc.cpp b/MachineCalc.cpp
index cd1044c..6b949aa 100644
--- a/MachineCalc.cpp
+++ b/MachineCalc.cpp
@@ -281,6 +281,7 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
    m_nCalcExitId = nExitId ;
    m_nCalcToolId = nToolId ;
    m_dCalcRot1W = pHead->GetRot1W() ;
+   m_bCalcMaxDeltaR2On1 = pHead->GetMaxDeltaR2On1() ;
    m_nCalcSolCh = pHead->GetSolCh() ;
    m_ptCalcPos = pExit->GetPos() ;
    m_vtCalcDir = pExit->GetTDir() ;
@@ -435,14 +436,6 @@ Machine::GetCurrHeadCollGroups( INTVECTOR& vIds) const
    return true ;
 }
 
-//----------------------------------------------------------------------------
-double
-Machine::GetCurrRot1W( void) const
-{
-  // restituisco il peso del primo asse rotante nei confronti di movimento
-   return m_dCalcRot1W ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Machine::CalculateKinematicChain( void)
diff --git a/MachineLua.cpp b/MachineLua.cpp
index cf0fa71..a55e676 100644
--- a/MachineLua.cpp
+++ b/MachineLua.cpp
@@ -53,6 +53,7 @@ static const string FLD_HSET = "HSet" ;
 static const string FLD_TDIR = "TDir" ;
 static const string FLD_ADIR = "ADir" ;
 static const string FLD_ROT1W = "Rot1W" ;
+static const string FLD_MAXDELTAR2ON1 = "MaxDeltaR2OnFirst" ;
 static const string FLD_ROT2STROKE = "Rot2Stroke" ;
 static const string FLD_SOLCH = "SolCh" ;
 static const string FLD_OTHCOLL = "OthColl" ;
@@ -594,6 +595,9 @@ Machine::LuaEmtStdHead( lua_State* L)
   // lettura eventuale campo 'Rot1W' dalla tabella (default 1)
    double dRot1W = 1 ;
    LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
+  // lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
+   bool bMaxDeltaR2On1 = true ;
+   LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
   // lettura eventuale campo 'Rot2Stroke' dalla tabella
    STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
    LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
@@ -621,7 +625,7 @@ Machine::LuaEmtStdHead( lua_State* L)
 
   // carico i dati della testa standard
    if ( ! m_pMchLua->LoadMachineStdHead( sName, sParent, sHSet, ptPos, vtTDir, vtADir,
-                                         dRot1W, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
+                                         dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
       return luaL_error( L, " Load Machine Standard Head failed") ;
 
   // restituisco l'indice della testa
@@ -672,6 +676,9 @@ Machine::LuaEmtMultiHead( lua_State* L)
   // lettura eventuale campo 'Rot1W' dalla tabella (default 1)
    double dRot1W = 1 ;
    LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
+  // lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
+   bool bMaxDeltaR2On1 = true ;
+   LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
   // lettura eventuale campo 'Rot2Stroke' dalla tabella
    STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
    LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
@@ -699,7 +706,7 @@ Machine::LuaEmtMultiHead( lua_State* L)
 
   // carico i dati della testa multipla
    if ( ! m_pMchLua->LoadMachineMultiHead( sName, sParent, sHSet, vMuExit, vtADir,
-                                           dRot1W, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
+                                           dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
       return luaL_error( L, " Load Machine Standard Head failed") ;
 
   // restituisco l'indice della testa
@@ -739,6 +746,9 @@ Machine::LuaEmtSpecialHead( lua_State* L)
   // lettura eventuale campo 'Rot1W' dalla tabella (default 1)
    double dRot1W = 1 ;
    LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
+  // lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
+   bool bMaxDeltaR2On1 = true ;
+   LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
   // lettura eventuale campo 'Rot2Stroke' dalla tabella
    STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
    LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
@@ -766,7 +776,7 @@ Machine::LuaEmtSpecialHead( lua_State* L)
 
   // carico i dati della testa standard
    if ( ! m_pMchLua->LoadMachineSpecialHead( sName, sParent, sHSet, ptPos, vtTDir, vtADir,
-                                             dRot1W, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
+                                             dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
       return luaL_error( L, " Load Machine Special Head failed") ;
 
   // restituisco l'indice della testa
diff --git a/Operation.cpp b/Operation.cpp
index ae981e1..5532177 100644
--- a/Operation.cpp
+++ b/Operation.cpp
@@ -1470,6 +1470,9 @@ Operation::CalculateAxesValues( const string& sHint, bool bSolChExact)
   // recupero peso primo asse rotante di testa
    double dRot1W = m_pMchMgr->GetCalcRot1W() ;
 
+  // recupero flag controllo delta massimo secondo asse rotante anche su primo movimento di lavorazione
+   bool bMaxDeltaR2OnFirst = m_pMchMgr->GetCalcMaxDeltaR2OnFirst() ;
+
   // recupero la minima differenza angolare da posizione precedente per stare vicino a posizione home
    double dAngDeltaMinForHome = m_pMchMgr->GetAngDeltaMinForHome() ;
 
@@ -1490,18 +1493,21 @@ Operation::CalculateAxesValues( const string& sHint, bool bSolChExact)
    while ( nClPathId != GDB_ID_NULL) {
       DBLVECTOR vAxRotPrecOri = vAxRotPrec ;
       int nOutStrC = 0 ;
-      if ( ! CalculateClPathAxesValues( nClPathId, nLinAxes, nRotAxes, dRot1W, dAngDeltaMinForHome, vAxRotHome, vAxRotPrec, nOutStrC)) {
+      if ( ! CalculateClPathAxesValues( nClPathId, nLinAxes, nRotAxes, dRot1W, bMaxDeltaR2OnFirst,
+                                        dAngDeltaMinForHome, vAxRotHome, vAxRotPrec, nOutStrC)) {
         // se attivata scelta angolo iniziale vicino ad home ed extra corsa C, provo a rifarlo disattivando
          if ( dAngDeltaMinForHome < ANG_FULL  &&  nOutStrC != 0) {
             m_pMchMgr->GetCurrMachine()->ResetOutstrokeInfo() ;
-            CalculateClPathAxesValues( nClPathId, nLinAxes, nRotAxes, dRot1W, INFINITO, vAxRotHome, vAxRotPrec, nOutStrC) ;
+            CalculateClPathAxesValues( nClPathId, nLinAxes, nRotAxes, dRot1W, bMaxDeltaR2OnFirst,
+                                       INFINITO, vAxRotHome, vAxRotPrec, nOutStrC) ;
          }
         // se extracorsa dell'asse C, provo a precaricarlo al contrario
          if ( nOutStrC != 0) {
             vAxRotPrec[0] = vAxRotPrecOri[0] + ( nOutStrC > 0 ? - ANG_FULL : ANG_FULL) ;
             vAxRotPrec[1] = vAxRotPrecOri[1] ;
             m_pMchMgr->GetCurrMachine()->ResetOutstrokeInfo() ;
-            if ( ! CalculateClPathAxesValues( nClPathId, nLinAxes, nRotAxes, dRot1W, INFINITO, vAxRotHome, vAxRotPrec, nOutStrC))
+            if ( ! CalculateClPathAxesValues( nClPathId, nLinAxes, nRotAxes, dRot1W, bMaxDeltaR2OnFirst,
+                                              INFINITO, vAxRotHome, vAxRotPrec, nOutStrC))
                bOk = false ;    
          }
          else
@@ -1515,13 +1521,13 @@ Operation::CalculateAxesValues( const string& sHint, bool bSolChExact)
 
 //----------------------------------------------------------------------------
 bool
-Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W,
+Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W, bool bMaxDeltaR2OnFirst,
                                       double dAngDeltaMinForHome, const DBLVECTOR& vAxRotHome, DBLVECTOR& vAxRotPrec, int& nOutStrC)
 {
    if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
       return false ;
   // massima variazione secondo asse rotante per continuitą
-   double dDeltaR2Max = 30 ;
+   double dMaxDeltaR2 = 30 ;
   // predispongo variabile per valori assi
    DBLVECTOR vAxVal ;
    vAxVal.reserve( 8) ;
@@ -1669,10 +1675,10 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
          if ( bAng2  &&  ( dDelta2 < dDelta1 - EPS_ANG_SMALL  ||  ! bAng1))
             swap( vAng1, vAng2) ;
         // se imposto limite su variazione di secondo asse rotante
-         if ( dDeltaR2Max > EPS_ANG_SMALL  &&  vAng1.size() >= 2) {
+         if ( ( bMaxDeltaR2OnFirst  ||  ! bFirst)  &&  dMaxDeltaR2 > EPS_ANG_SMALL  &&  vAng1.size() >= 2) {
             double dR2Diff1 = vAng1[1] - vAxRotPrec[1] ;
             double dR2Diff2 = vAng2[1] - vAxRotPrec[1] ;
-            if ( abs( dR2Diff1) > abs( dR2Diff2)  &&  abs( dR2Diff1) > dDeltaR2Max)
+            if ( abs( dR2Diff1) > abs( dR2Diff2)  &&  abs( dR2Diff1) > dMaxDeltaR2)
                swap( vAng1, vAng2) ;
          }
       }
diff --git a/Operation.h b/Operation.h
index 906e882..ea7dd7c 100644
--- a/Operation.h
+++ b/Operation.h
@@ -111,7 +111,7 @@ class Operation : public IUserObj
       std::string ExtractHint( const std::string& sNotes) const ;
       bool   SetBlockedRotAxis( const std::string& sBlockedAxis) const ;
       bool   CalculateAxesValues( const std::string& sHint, bool bSolChExact = false) ;
-      bool   CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W,
+      bool   CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W, bool bMaxDeltaR2OnFirst,
                                         double dAngDeltaMinForHome, const DBLVECTOR& vAxRotHome, DBLVECTOR& vAxRotPrec, int& nOutStrC) ;
       bool   AdjustStartEndMovements( bool bVerifyPreviousLink = true) ;
       bool   AdjustOneStartMovement( int nClPathId, int nPrevClPathId, Operation* pPrevOp, const DBLVECTOR& vAxPrev, bool bMaxZ) ;
diff --git a/Simulator.cpp b/Simulator.cpp
index 6b77772..a4a1bac 100644
--- a/Simulator.cpp
+++ b/Simulator.cpp
@@ -1511,8 +1511,9 @@ Simulator::OnToolSelect( const string& sTool, const string& sHead, int nExit, co
    bool bOk = m_pMachine->LuaCallFunction( ON_SIMUL_TOOL_SELECT) ;
   // forzo aggiornamento posizione assi (possono essere stati mossi nello script)
    UpdateAxesPos() ;
-  // recupero distanza di sicurezza per verifica collisione
+  // recupero dati per verifica collisione 
    m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_SAFEDIST, m_dSafeDist) ;
+   m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_CODET, m_CdId) ;
   // verifico codice di errore
    bOk = bOk && m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_ERR, nErr) ;
   // recupero i dati di ritorno per assi ausiliari