diff --git a/Chiseling.cpp b/Chiseling.cpp index f2c309d..c2a509d 100644 --- a/Chiseling.cpp +++ b/Chiseling.cpp @@ -39,6 +39,9 @@ using namespace std ; // 2905 = "Error in Chiseling : machining depth (xxx) bigger than MaxMaterial (yyy)" // 2906 = "Error in Chiseling : Entity GetElevation" // 2907 = "Error in Chiseling : Chaining failed" +// 2908 = "Error in Chiseling : axes values not calculable" +// 2909 = "Error in Chiseling : link movements not calculable" +// 2910 = "Error in Chiseling : post apply not calculable" //---------------------------------------------------------------------------- struct SqHole @@ -219,6 +222,9 @@ Chiseling::SetParam( int nType, bool bVal) case MPA_INVERT : m_Params.m_bInvert = bVal ; return true ; + case MPA_TOOLINVERT : + m_Params.m_bToolInvert = bVal ; + return true ; } return false ; } @@ -318,6 +324,12 @@ Chiseling::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; default : return false ; } @@ -481,18 +493,36 @@ Chiseling::Apply( bool bRecalc) return true ; } + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2908, "Error in Chiseling : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2909, "Error in Chiseling : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2910, "Error in Chiseling : post apply not calculable") ; return false ; + } return true ; } @@ -505,6 +535,9 @@ Chiseling::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; + case MPA_TOOLINVERT : + bVal = m_Params.m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -595,6 +628,12 @@ Chiseling::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; @@ -811,8 +850,6 @@ bool Chiseling::Chain( int nGrpDestId) { // vettore puntatori alle curve - typedef PtrOwner POWNCURVE ; - typedef std::vector POCRVVECTOR ; POCRVVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; // recupero tutte le curve e le porto in globale @@ -957,6 +994,14 @@ Chiseling::ProcessPath( int nPathId, int nPvId, int nClId) double dThick ; pCompo->GetThickness( dThick) ; + // eventuale inversione direzione utensile + if ( m_Params.m_bToolInvert) { + vtExtr.Invert() ; + pCompo->SetExtrusion( vtExtr) ; + dThick = - dThick ; + pCompo->SetThickness( dThick) ; + } + // se richiesto offset double dOffs = GetOffsR() ; if ( abs( dOffs) > EPS_SMALL) { diff --git a/ChiselingData.cpp b/ChiselingData.cpp index ca77c7f..3398abf 100644 --- a/ChiselingData.cpp +++ b/ChiselingData.cpp @@ -26,7 +26,9 @@ using namespace std ; //---------------------------------------------------------------------------- enum nChiselingKey { - KEY_DH = 0, + KEY_AB = 0, + KEY_AI, + KEY_DH, KEY_EAL, KEY_F, KEY_FE, @@ -41,6 +43,7 @@ enum nChiselingKey { KEY_PS, KEY_SCC, KEY_ST, + KEY_TI, KEY_TNAME, KEY_TUUID, KEY_UUID, @@ -48,6 +51,8 @@ enum nChiselingKey { KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sChiselingKey = { + "AB", + "AI", "DH", "EAL", "F", @@ -63,6 +68,7 @@ static const std::array sChiselingKey = { "PS", "SCC", "ST", + "TI", "TN", "TU", "UUID", @@ -101,15 +107,18 @@ ChiselingData::CopyFrom( const MachiningData* pMdata) // eseguo copia m_Uuid = pDdata->m_Uuid ; m_sName = pDdata->m_sName ; - m_nSolCh = pDdata->m_nSolCh ; m_ToolUuid = pDdata->m_ToolUuid ; m_sToolName = pDdata->m_sToolName ; + m_sBlockedAxis = pDdata->m_sBlockedAxis ; + m_sInitAngs = pDdata->m_sInitAngs ; + m_nSolCh = pDdata->m_nSolCh ; m_dFeed = pDdata->m_dFeed ; m_dEndFeed = pDdata->m_dEndFeed ; m_dTipFeed = pDdata->m_dTipFeed ; m_dOffsL = pDdata->m_dOffsL ; m_dOffsR = pDdata->m_dOffsR ; m_nWorkSide = pDdata->m_nWorkSide ; + m_bToolInvert = pDdata->m_bToolInvert ; m_bInvert = pDdata->m_bInvert ; m_sDepth = pDdata->m_sDepth ; m_dStartPos = pDdata->m_dStartPos ; @@ -137,6 +146,8 @@ ChiselingData::SameAs(const MachiningData* pMdata) const m_sName == pDdata->m_sName && m_ToolUuid == pDdata->m_ToolUuid && m_sToolName == pDdata->m_sToolName && + m_sBlockedAxis == pDdata->m_sBlockedAxis && + m_sInitAngs == pDdata->m_sInitAngs && m_nSolCh == pDdata->m_nSolCh && abs( m_dFeed - pDdata->m_dFeed) < EPS_MACH_LEN_PAR && abs( m_dEndFeed - pDdata->m_dEndFeed) < EPS_MACH_LEN_PAR && @@ -144,6 +155,7 @@ ChiselingData::SameAs(const MachiningData* pMdata) const abs( m_dOffsL - pDdata->m_dOffsL) < EPS_MACH_LEN_PAR && abs( m_dOffsR - pDdata->m_dOffsR) < EPS_MACH_LEN_PAR && m_nWorkSide == pDdata->m_nWorkSide && + m_bToolInvert == pDdata->m_bToolInvert && m_bInvert == pDdata->m_bInvert && m_sDepth == pDdata->m_sDepth && abs( m_dStartPos - pDdata->m_dStartPos) < EPS_MACH_LEN_PAR && @@ -190,6 +202,12 @@ ChiselingData::FromString( const string& sString, int& nKey) nKey = FindChiselingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) @@ -238,6 +256,9 @@ ChiselingData::FromString( const string& sString, int& nKey) case KEY_ST : bOk = ::FromString( sVal, m_dStep) ; break ; + case KEY_TI : + bOk = ::FromString( sVal, m_bToolInvert) ; + break ; case KEY_TNAME : m_sToolName = sVal ; break ; @@ -262,6 +283,8 @@ string ChiselingData::ToString( int nKey) const { switch ( nKey) { + case KEY_AB : return ( sChiselingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sChiselingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_DH : return ( sChiselingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_EAL : return ( sChiselingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; case KEY_F : return ( sChiselingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; @@ -277,6 +300,7 @@ ChiselingData::ToString( int nKey) const case KEY_PS : return ( sChiselingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ; case KEY_SCC : return ( sChiselingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; case KEY_ST : return ( sChiselingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ; + case KEY_TI : return ( sChiselingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ; case KEY_TNAME : return ( sChiselingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sChiselingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sChiselingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; @@ -289,7 +313,7 @@ ChiselingData::ToString( int nKey) const bool ChiselingData::IsOptional( int nKey) const { - return false ; + return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_TI) ; } //---------------------------------------------------------------------------- @@ -338,6 +362,9 @@ ChiselingData::SetParam( int nType, bool bVal) case MPA_INVERT : m_bInvert = bVal ; return true ; + case MPA_TOOLINVERT : + m_bToolInvert = bVal ; + return true ; } return false ; } @@ -424,6 +451,12 @@ ChiselingData::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -445,6 +478,9 @@ ChiselingData::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_bInvert ; return true ; + case MPA_TOOLINVERT : + bVal = m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -532,6 +568,12 @@ ChiselingData::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/ChiselingData.h b/ChiselingData.h index ba9ee04..fc48d40 100644 --- a/ChiselingData.h +++ b/ChiselingData.h @@ -20,12 +20,15 @@ struct ChiselingData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) double m_dEndFeed ; // velocità di lavorazione finale ( se 0 da utensile) double m_dTipFeed ; // velocità di lavorazione di sfondamento ( se 0 da utensile) double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile) double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile) + bool m_bToolInvert ; // flag per inversione direzione utensile da geometria bool m_bInvert ; // flag di inversione direzione lavorazione per casi passanti int m_nWorkSide ; // lato di lavoro (destra, sinistra) std::string m_sDepth ; // affondamento (espressione numerica) @@ -38,7 +41,8 @@ struct ChiselingData : public MachiningData ChiselingData( void) : m_ToolUuid(), m_nSolCh( 0), m_dFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0), - m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), m_bInvert( false), m_nWorkSide( 2), m_dStartPos( 0), + m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), + m_bToolInvert( false), m_bInvert( false), m_nWorkSide( 2), m_dStartPos( 0), m_dStep( 0), m_dReturnPos( 0), m_dEndAddLen( 0) {} ChiselingData* Clone( void) const override ; bool CopyFrom( const MachiningData* pMdata) override ; diff --git a/Disposition.cpp b/Disposition.cpp index c5e4314..e5e2dcf 100644 --- a/Disposition.cpp +++ b/Disposition.cpp @@ -31,6 +31,9 @@ using namespace std ; // 2003 = "Error in MoveToCornerRawPart xx" // 2004 = "Error in MoveToCenterRawPart xx" // 2005 = "Error in ApplyRotationToRawPart xx" +// 2006 = "Error in OnSpecialApplyDisposition (xxx)" +// 2007 = "Error in Disposition : axes values not calculable" +// 2008 = "Error in Disposition : link movements not calculable" //---------------------------------------------------------------------------- static std::string DIS_TABLE = "Tab" ; @@ -1080,17 +1083,22 @@ Disposition::SpecialApply( bool bRecalc) bOk = false ; m_nShifts = - 1 ; string sOut = " Error in " + ON_SPECIAL_APPLY + " (" + ToString( nErr) + ")" ; - LOG_INFO( GetEMkLogger(), sOut.c_str()) + m_pMchMgr->SetLastError( 2006, sOut) ; } - // se disposizione vuota, esco - if ( m_nShifts <= 0) + // se disposizione vuota o errore, esco + if ( m_nShifts <= 0 || ! bOk) return bOk ; // calcolo assi macchina - string sHint = "" ; - bOk = bOk && CalculateAxesValues( sHint) ; + if ( ! CalculateAxesValues( "")) { + m_pMchMgr->SetLastError( 2007, "Error in Disposition : axes values not calculable") ; + return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine di tutti - bOk = bOk && AdjustStartEndMovements() ; - return bOk ; + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2008, "Error in Disposition : link movements not calculable") ; + return false ; + } + return true ; } else return true ; diff --git a/Drilling.cpp b/Drilling.cpp index 80b351c..d465a22 100644 --- a/Drilling.cpp +++ b/Drilling.cpp @@ -39,6 +39,9 @@ using namespace std ; // 2106 = "Error in Drilling : Entity xx skipped because missing aggregate from bottom" // 2107 = "Error in Drilling : Entity xx skipped because too far from part sides" // 2108 = "Error in Drilling : Chaining failed" +// 2109 = "Error in Drilling : axes values not calculable" +// 2110 = "Error in Drilling : link movements not calculable" +// 2111 = "Error in Drilling : post apply not calculable" //---------------------------------------------------------------------------- struct Hole @@ -344,6 +347,12 @@ Drilling::SetParam( int nType, const string& sVal) case MPA_OFFSET_STR : m_Params.m_sOffset = sVal ; return true ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; } return false ; } @@ -478,18 +487,36 @@ Drilling::Apply( bool bRecalc) if ( m_nDrillings == 0) return true ; + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2109, "Error in Drilling : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2110, "Error in Drilling : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2111, "Error in Drilling : post apply not calculable") ; return false ; + } return true ; } @@ -1091,6 +1118,12 @@ Drilling::GetParam( int nType, string& sVal) const case MPA_OFFSET_STR : sVal = m_Params.m_sOffset ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; @@ -1269,10 +1302,12 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId) SetToolDir( hole.vtDir) ; // 1 -> punto approccio (se con aggregato da sotto è una sequenza di approccio) SetFlag( 1) ; - double dAppr = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; + double dAppr = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; Point3d ptP1 = hole.ptIni + hole.vtDir * ( dAppr + dTExtrLen) ; if ( m_bAggrBottom) { - Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dAppr) ; + Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dSafeZ) ; Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ; Vector3d vtAux = m_vtAux ; vtAux.Rotate( Z_AX, 90) ; @@ -1336,7 +1371,7 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId) // 7 -> punto fuori (se uso aggregato da sotto) if ( m_bAggrBottom) { SetFlag( 0) ; - Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dAppr) ; + Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dSafeZ) ; Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ; if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL) return false ; @@ -1388,10 +1423,12 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId) SetToolDir( hole.vtDir) ; // 1 -> punto approccio SetFlag( 1) ; - double dAppr = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; + double dAppr = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; Point3d ptP1 = hole.ptIni + hole.vtDir * ( dAppr + dTExtrLen) ; if ( m_bAggrBottom) { - Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dAppr) ; + Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dSafeZ) ; Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ; Vector3d vtAux = m_vtAux ; vtAux.Rotate( Z_AX, 90) ; @@ -1528,7 +1565,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId) // 7 -> punto fuori (se uso aggregato da sotto) if ( m_bAggrBottom) { SetFlag( 0) ; - Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dAppr) ; + Point3d ptP0 = ptP1 + m_vtAux * ( m_dDistBottom + dAgbEncH + dSafeZ) ; Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ; if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL) return false ; diff --git a/DrillingData.cpp b/DrillingData.cpp index 3cf1ada..042c8a0 100644 --- a/DrillingData.cpp +++ b/DrillingData.cpp @@ -26,7 +26,9 @@ using namespace std ; //---------------------------------------------------------------------------- enum nDrillingKey { - KEY_DH = 0, + KEY_AB = 0, + KEY_AI, + KEY_DH, KEY_EAL, KEY_F, KEY_FE, @@ -54,6 +56,8 @@ enum nDrillingKey { KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sDrillingKey = { + "AB", + "AI", "DH", "EAL", "F", @@ -113,9 +117,11 @@ DrillingData::CopyFrom( const MachiningData* pMdata) // eseguo copia m_Uuid = pDdata->m_Uuid ; m_sName = pDdata->m_sName ; - m_nSolCh = pDdata->m_nSolCh ; m_ToolUuid = pDdata->m_ToolUuid ; m_sToolName = pDdata->m_sToolName ; + m_sBlockedAxis = pDdata->m_sBlockedAxis ; + m_sInitAngs = pDdata->m_sInitAngs ; + m_nSolCh = pDdata->m_nSolCh ; m_dSpeed = pDdata->m_dSpeed ; m_dFeed = pDdata->m_dFeed ; m_dEndFeed = pDdata->m_dEndFeed ; @@ -155,6 +161,8 @@ DrillingData::SameAs(const MachiningData* pMdata) const m_sName == pDdata->m_sName && m_ToolUuid == pDdata->m_ToolUuid && m_sToolName == pDdata->m_sToolName && + m_sBlockedAxis == pDdata->m_sBlockedAxis && + m_sInitAngs == pDdata->m_sInitAngs && m_nSolCh == pDdata->m_nSolCh && abs( m_dSpeed - pDdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pDdata->m_dFeed) < EPS_MACH_LEN_PAR && @@ -214,6 +222,12 @@ DrillingData::FromString( const string& sString, int& nKey) nKey = FindDrillingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) @@ -308,6 +322,8 @@ string DrillingData::ToString( int nKey) const { switch ( nKey) { + case KEY_AB : return ( sDrillingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sDrillingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_DH : return ( sDrillingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_EAL : return ( sDrillingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; case KEY_F : return ( sDrillingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; @@ -341,7 +357,8 @@ DrillingData::ToString( int nKey) const bool DrillingData::IsOptional( int nKey) const { - return ( nKey == KEY_EAL || nKey == KEY_F || nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || + return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_EAL || nKey == KEY_F || + nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || nKey == KEY_NNS || nKey == KEY_NNU || nKey == KEY_S || nKey == KEY_SAL || nKey == KEY_SUBTYPE || nKey == KEY_OFF || nKey == KEY_OVL || nKey == KEY_SCC) ; } @@ -494,6 +511,12 @@ DrillingData::SetParam( int nType, const string& sVal) case MPA_OFFSET_STR : m_sOffset = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -620,6 +643,12 @@ DrillingData::GetParam( int nType, string& sVal) const case MPA_OFFSET_STR : sVal = m_sOffset ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/DrillingData.h b/DrillingData.h index a46a820..179a872 100644 --- a/DrillingData.h +++ b/DrillingData.h @@ -20,6 +20,8 @@ struct DrillingData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 656f779..b2571a7 100644 Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ diff --git a/GenMachining.cpp b/GenMachining.cpp index 0c55502..eb7867c 100644 --- a/GenMachining.cpp +++ b/GenMachining.cpp @@ -35,6 +35,9 @@ using namespace std ; // 2801 = "Error in GenMachining : UpdateToolData failed" // 2802 = "Error in GenMachining : missing Script (xxx)" // 2803 = "Error in GenMachining : Error in xxx (nnn)" +// 2804 = "Error in GenMachining : axes values not calculable" +// 2805 = "Error in GenMachining : link movements not calculable" +// 2806 = "Error in GenMachining : post apply not calculable" //---------------------------------------------------------------------------- USEROBJ_REGISTER( "EMkGenMachining", GenMachining) ; @@ -201,6 +204,9 @@ GenMachining::SetParam( int nType, bool bVal) case MPA_INVERT : m_Params.m_bInvert = bVal ; return true ; + case MPA_TOOLINVERT : + m_Params.m_bToolInvert = bVal ; + return true ; } return false ; } @@ -303,6 +309,12 @@ GenMachining::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; default : return false ; } @@ -432,6 +444,7 @@ GenMachining::Apply( bool bRecalc) static const string EVAR_MACHID = ".MACHID" ; // IN (int) identificativo della lavorazione static const string EVAR_GEOM = ".GEOM" ; // IN (table) tabella delle entità da lavorare static const string EVAR_DEPTH = ".DEPTH" ; // IN (string) affondamento (espressione numerica) + static const string EVAR_TINVERT = ".TOOLINVERT" ; // IN (bool) flag di inversione direzione utensile static const string EVAR_INVERT = ".INVERT" ; // IN (bool) flag di inversione direzione lavorazione static const string EVAR_STARTPOS = ".STARTPOS" ; // IN (num) quota di inizio lavorazione (sempre >= 0) static const string EVAR_OFFSR = ".OFFSR" ; // IN (num) offset radiale @@ -473,6 +486,7 @@ GenMachining::Apply( bool bRecalc) bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MACHID, m_nOwnerId) ; bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_GEOM, m_vId) ; bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_DEPTH, m_Params.m_sDepth) ; + bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TINVERT, m_Params.m_bToolInvert) ; bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_INVERT, m_Params.m_bInvert) ; bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTPOS, m_Params.m_dStartPos) ; bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSR, GetOffsR()) ; @@ -503,18 +517,36 @@ GenMachining::Apply( bool bRecalc) if ( m_nMills == 0) return true ; + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2804, "Error in GenMachining : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2805, "Error in GenMachining : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2806, "Error in GenMachining : post apply not calculable") ; return false ; + } return true ; } @@ -527,6 +559,9 @@ GenMachining::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; + case MPA_TOOLINVERT : + bVal = m_Params.m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -611,6 +646,12 @@ GenMachining::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; @@ -868,8 +909,6 @@ bool GenMachining::Chain( int nGrpDestId) { // vettore puntatori alle curve - typedef PtrOwner POWNCURVE ; - typedef std::vector POCRVVECTOR ; POCRVVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; // recupero tutte le curve e le porto in globale diff --git a/GenMachiningData.cpp b/GenMachiningData.cpp index 221c8f6..1eb4850 100644 --- a/GenMachiningData.cpp +++ b/GenMachiningData.cpp @@ -26,7 +26,9 @@ using namespace std ; //---------------------------------------------------------------------------- enum nGenMachiningKey { - KEY_DH = 0, + KEY_AB = 0, + KEY_AI, + KEY_DH, KEY_F, KEY_FE, KEY_FS, @@ -41,12 +43,15 @@ enum nGenMachiningKey { KEY_S, KEY_SCC, KEY_SUBTYPE, + KEY_TI, KEY_TNAME, KEY_TUUID, KEY_UUID, KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sGenMachiningKey = { + "AB", + "AI", "DH", "F", "FE", @@ -62,6 +67,7 @@ static const std::array sGenMachiningKey = { "S", "SCC", "SUB", + "TI", "TN", "TU", "UUID"} ; @@ -99,9 +105,11 @@ GenMachiningData::CopyFrom( const MachiningData* pMdata) // eseguo copia m_Uuid = pGdata->m_Uuid ; m_sName = pGdata->m_sName ; - m_nSolCh = pGdata->m_nSolCh ; m_ToolUuid = pGdata->m_ToolUuid ; m_sToolName = pGdata->m_sToolName ; + m_sBlockedAxis = pGdata->m_sBlockedAxis ; + m_sInitAngs = pGdata->m_sInitAngs ; + m_nSolCh = pGdata->m_nSolCh ; m_dSpeed = pGdata->m_dSpeed ; m_dFeed = pGdata->m_dFeed ; m_dEndFeed = pGdata->m_dEndFeed ; @@ -109,6 +117,7 @@ GenMachiningData::CopyFrom( const MachiningData* pMdata) m_dTipFeed = pGdata->m_dTipFeed ; m_dOffsL = pGdata->m_dOffsL ; m_dOffsR = pGdata->m_dOffsR ; + m_bToolInvert = pGdata->m_bToolInvert ; m_bInvert = pGdata->m_bInvert ; m_sDepth = pGdata->m_sDepth ; m_dStartPos = pGdata->m_dStartPos ; @@ -134,6 +143,8 @@ GenMachiningData::SameAs(const MachiningData* pMdata) const m_sName == pGdata->m_sName && m_ToolUuid == pGdata->m_ToolUuid && m_sToolName == pGdata->m_sToolName && + m_sBlockedAxis == pGdata->m_sBlockedAxis && + m_sInitAngs == pGdata->m_sInitAngs && m_nSolCh == pGdata->m_nSolCh && abs( m_dSpeed - pGdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pGdata->m_dFeed) < EPS_MACH_LEN_PAR && @@ -142,6 +153,7 @@ GenMachiningData::SameAs(const MachiningData* pMdata) const abs( m_dTipFeed - pGdata->m_dTipFeed) < EPS_MACH_LEN_PAR && abs( m_dOffsL - pGdata->m_dOffsL) < EPS_MACH_LEN_PAR && abs( m_dOffsR - pGdata->m_dOffsR) < EPS_MACH_LEN_PAR && + m_bToolInvert == pGdata->m_bToolInvert && m_bInvert == pGdata->m_bInvert && m_sDepth == pGdata->m_sDepth && abs( m_dStartPos - pGdata->m_dStartPos) < EPS_MACH_LEN_PAR && @@ -186,6 +198,12 @@ GenMachiningData::FromString( const string& sString, int& nKey) nKey = FindGenMachiningKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) @@ -237,6 +255,9 @@ GenMachiningData::FromString( const string& sString, int& nKey) case KEY_TNAME : m_sToolName = sVal ; break ; + case KEY_TI : + bOk = ::FromString( sVal, m_bToolInvert) ; + break ; case KEY_TUUID : bOk = ::FromString( sVal, m_ToolUuid) ; break ; @@ -255,6 +276,8 @@ string GenMachiningData::ToString( int nKey) const { switch ( nKey) { + case KEY_AB : return ( sGenMachiningKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sGenMachiningKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_DH : return ( sGenMachiningKey[KEY_DH] + "=" + m_sDepth) ; case KEY_F : return ( sGenMachiningKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; case KEY_FE : return ( sGenMachiningKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; @@ -270,6 +293,7 @@ GenMachiningData::ToString( int nKey) const case KEY_S : return ( sGenMachiningKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ; case KEY_SCC : return ( sGenMachiningKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; case KEY_SUBTYPE : return ( sGenMachiningKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ; + case KEY_TI : return ( sGenMachiningKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ; case KEY_TNAME : return ( sGenMachiningKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sGenMachiningKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sGenMachiningKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; @@ -281,7 +305,7 @@ GenMachiningData::ToString( int nKey) const bool GenMachiningData::IsOptional( int nKey) const { - return false ; + return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_TI) ; } //---------------------------------------------------------------------------- @@ -324,6 +348,9 @@ GenMachiningData::SetParam( int nType, bool bVal) case MPA_INVERT : m_bInvert = bVal ; return true ; + case MPA_TOOLINVERT : + m_bToolInvert = bVal ; + return true ; } return false ; } @@ -405,6 +432,12 @@ GenMachiningData::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -426,6 +459,9 @@ GenMachiningData::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_bInvert ; return true ; + case MPA_TOOLINVERT : + bVal = m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -510,6 +546,12 @@ GenMachiningData::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/GenMachiningData.h b/GenMachiningData.h index 3299b01..3af6e7f 100644 --- a/GenMachiningData.h +++ b/GenMachiningData.h @@ -20,6 +20,8 @@ struct GenMachiningData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) @@ -28,6 +30,7 @@ struct GenMachiningData : public MachiningData double m_dTipFeed ; // velocità di lavorazione di sfondamento ( se 0 da utensile) double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile) double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile) + bool m_bToolInvert ; // flag per inversione direzione utensile da geometria bool m_bInvert ; // flag di inversione direzione lavorazione std::string m_sDepth ; // affondamento (espressione numerica) double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0) @@ -37,7 +40,7 @@ struct GenMachiningData : public MachiningData GenMachiningData( void) : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0), - m_dOffsR( 0), m_dOffsL( 0), m_bInvert( false), m_dStartPos( 0), m_nSubType( 0) {} + m_dOffsR( 0), m_dOffsL( 0), m_bToolInvert( false), m_bInvert( false), m_dStartPos( 0), m_nSubType( 0) {} GenMachiningData* Clone( void) const override ; bool CopyFrom( const MachiningData* pMdata) override ; bool SameAs(const MachiningData* pMdata) const override ; diff --git a/Generator.cpp b/Generator.cpp index beb971a..a629824 100644 --- a/Generator.cpp +++ b/Generator.cpp @@ -28,6 +28,10 @@ using namespace std ; +//------------------------------ Errors -------------------------------------- +// 1001 = "Error with setup : xxx" +// 1002 = "Error opening Cnc file" + //---------------------------------------------------------------------------- static const string ERR_EXT = ".err" ; @@ -81,9 +85,12 @@ Generator::Run( const string& sCncFile, const std::string& sInfo) if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr || m_pMachine == nullptr || m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL) return false ; + m_pMchMgr->ResetLastError() ; - // recupero eventuale attrezzaggio della macchinata + // forzo aggiornamento attrezzaggio della macchinata m_pMchMgr->UpdateSetup() ; + if ( ! VerifySetup()) + return false ; // evento inizio esecuzione bool bOk = true ; @@ -152,6 +159,27 @@ Generator::Run( const string& sCncFile, const std::string& sInfo) return bOk ; } +//---------------------------------------------------------------------------- +bool +Generator::VerifySetup( void) +{ + // se attrezzaggio non definito, nulla da verificare + if ( ! m_pMchMgr->GetCurrSetupMgr().Exists()) + return true ; + + // lancio la verifica + STRVECTOR vsErr ; + if ( m_pMchMgr->VerifyCurrSetup( vsErr)) + return true ; + + // gestisco errore + string sErr = "Error with setup :" ; + for each( const auto& sTmp in vsErr) + sErr += " " + sTmp ; + m_pMchMgr->SetLastError( 1001, sErr) ; + return false ; +} + //---------------------------------------------------------------------------- bool Generator::ProcessDisposition( int nOpId, int nOpInd) @@ -525,7 +553,7 @@ Generator::OnProgramStart( const string& sMachName, const string& sCncFile, cons // apro il file di output bool bOk = m_pMachine->WriterOpen( sCncFile) ; if ( ! bOk) - LOG_INFO( GetEMkLogger(), "Error opening Cnc file") ; + m_pMchMgr->SetLastError( 1002, "Error opening Cnc file") ; // assegno nome macchina bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MACHNAME, sMachName) ; // assegno nome file diff --git a/Generator.h b/Generator.h index 6232896..fc1b6ef 100644 --- a/Generator.h +++ b/Generator.h @@ -29,6 +29,7 @@ class Generator bool Run( const std::string& sCncFile, const std::string& sInfo) ; private : + bool VerifySetup( void) ; bool ProcessDisposition( int nOpId, int nOpInd) ; bool ProcessMachining( int nOpId, int nOpInd) ; bool ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd) ; diff --git a/Head.cpp b/Head.cpp index e8448bf..0000ee6 100644 --- a/Head.cpp +++ b/Head.cpp @@ -15,7 +15,7 @@ #include "stdafx.h" #include "Head.h" #include "MachConst.h" -#include "/EgtDev/Include/EMkSimuGenConst.h" +#include "/EgtDev/Include/EMkMachiningConst.h" #include "/EgtDev/Include/EGkGdbConst.h" #include "/EgtDev/Include/EGkUserObjFactory.h" #include "/EgtDev/Include/EGkStringUtils3d.h" @@ -111,7 +111,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) + double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl) { m_sName = sName ; m_nType = nType ; @@ -128,6 +128,7 @@ Head::Set( const string& sName, int nType, int nExitCount, const string& sHSet, m_nSolCh = nSolCh ; else m_nSolCh = MCH_SCC_NONE ; + m_vsOtherColl = vsOthColl ; return true ; } @@ -141,4 +142,3 @@ Head::AddHeadToHSet( const string& sHead) m_vsHSet.emplace_back( sHead) ; return true ; } - diff --git a/Head.h b/Head.h index 8f4a075..dc64eda 100644 --- a/Head.h +++ b/Head.h @@ -31,24 +31,27 @@ 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, const STROKE& Rot2Stroke, int nSolCh, + const STRVECTOR& vsOthColl) ; bool AddHeadToHSet( const std::string& sHead) ; - const std::string& GetName( void) + const std::string& GetName( void) const { return m_sName ; } - int GetType( void) + int GetType( void) const { return m_nType ; } - int GetExitCount( void) + int GetExitCount( void) const { return m_nExitCount ; } - const STRVECTOR& GetHSet(void) + const STRVECTOR& GetHSet(void) const { return m_vsHSet ; } - const Vector3d& GetADir( void) + const Vector3d& GetADir( void) const { return m_vtADir ; } - double GetRot1W( void) + double GetRot1W( void) const { return m_dRot1W ; } - const STROKE& GetRot2Stroke( void) + const STROKE& GetRot2Stroke( void) const { return m_Rot2Stroke ; } - int GetSolCh( void) + int GetSolCh( void) const { return m_nSolCh ; } + const STRVECTOR& GetOtherCollGroups( void) const + { return m_vsOtherColl ; } private : int m_nOwnerId ; @@ -61,4 +64,5 @@ class Head : public IUserObj double m_dRot1W ; STROKE m_Rot2Stroke ; int m_nSolCh ; + STRVECTOR m_vsOtherColl ; } ; \ No newline at end of file diff --git a/MachMgr.h b/MachMgr.h index 3285115..62fc687 100644 --- a/MachMgr.h +++ b/MachMgr.h @@ -324,6 +324,8 @@ class MachMgr : public IMachMgr std::string GetLuaLastRequire( void) const { return m_sLuaLastRequire ; } bool SetLastError( int nErr, const std::string& sErr) ; + void ResetLastError( void) + { m_nLastError = 0 ; m_sLastError.clear() ; } // Current Machine std::string GetCurrSetupDir( void) const { Machine* pMch = GetCurrMachine() ; @@ -364,6 +366,8 @@ class MachMgr : public IMachMgr bool GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const ; bool GetCurrAxisHomePos( int nInd, double& dHome) const ; bool ApplyRotAxisBlock( void) ; + void ClearRotAxisBlock( void) + { m_vAxisBlock.clear() ; } bool IsKinematicRotAxisBlocked( int nInd) const ; double GetCalcRot1W( void) const ; bool SetCalcSolCh( int nScc) ; diff --git a/MachMgrDBMachinings.cpp b/MachMgrDBMachinings.cpp index 0d6a99a..0ca0c55 100644 --- a/MachMgrDBMachinings.cpp +++ b/MachMgrDBMachinings.cpp @@ -299,6 +299,8 @@ MachMgr::MdbSetGeneralParam( int nType, double dVal) return pMsMgr->SetExtSawArcMinRad( dVal) ; case MGP_INTSAWARCMAXSIDEANG : return pMsMgr->SetIntSawArcMaxSideAng( dVal) ; + case MGP_SAFEAGGRBOTTZ : + return pMsMgr->SetSafeAggrBottZ( dVal) ; } return false ; } @@ -368,6 +370,9 @@ MachMgr::MdbGetGeneralParam( int nType, double& dVal) const case MGP_INTSAWARCMAXSIDEANG : dVal = pMsMgr->GetIntSawArcMaxSideAng() ; return true ; + case MGP_SAFEAGGRBOTTZ : + dVal = pMsMgr->GetSafeAggrBottZ() ; + return true ; } return false ; } diff --git a/MachMgrMachGroups.cpp b/MachMgrMachGroups.cpp index ff04dd1..eb33df3 100644 --- a/MachMgrMachGroups.cpp +++ b/MachMgrMachGroups.cpp @@ -138,6 +138,8 @@ MachMgr::AddMachGroup( const string& sName, const string& sMachineName) m_pGeomDB->Erase( nNewId) ; return GDB_ID_NULL ; } + // aggiorno attrezzaggio attivo + UpdateSetup() ; // nascondo i pezzi rimasti sotto la radice ShowRootParts( false) ; // rendo visibile il nuovo gruppo corrente e la relativa macchina @@ -290,6 +292,8 @@ MachMgr::SetCurrMachGroup( int nId) // predispongo e verifico impostazioni if ( ! PrepareCurrMachGroup( nId)) return false ; + // aggiorno attrezzaggio attivo + UpdateSetup() ; // imposto la prima fase come corrente if ( ! SetCurrPhase( 1)) return false ; diff --git a/MachMgrOperations.cpp b/MachMgrOperations.cpp index bdf1d51..f52f180 100644 --- a/MachMgrOperations.cpp +++ b/MachMgrOperations.cpp @@ -591,6 +591,7 @@ MachMgr::GetPhaseDisposition( int nPhase) const bool MachMgr::DispositionSpecialApply( int nId, bool bRecalc) { + ResetLastError() ; // verifico sia attiva bool bActive ; if ( ! GetOperationMode( nId, bActive)) @@ -842,6 +843,7 @@ MachMgr::SetMachiningParam( int nType, const string& sVal, bool* pbChanged) bool MachMgr::SetMachiningGeometry( const SELVECTOR& vIds) { + ResetLastError() ; // recupero la lavorazione corrente int nCurrMchId = GetCurrMachining() ; if ( nCurrMchId == GDB_ID_NULL) @@ -860,6 +862,7 @@ MachMgr::SetMachiningGeometry( const SELVECTOR& vIds) bool MachMgr::MachiningPreview( bool bRecalc) { + ResetLastError() ; // recupero la lavorazione corrente int nCurrMchId = GetCurrMachining() ; if ( nCurrMchId == GDB_ID_NULL) @@ -908,6 +911,7 @@ MachMgr::RemoveMachiningPreview( void) bool MachMgr::MachiningApply( bool bRecalc) { + ResetLastError() ; // recupero la lavorazione corrente int nCurrMchId = GetCurrMachining() ; if ( nCurrMchId == GDB_ID_NULL) diff --git a/MachMgrSetup.cpp b/MachMgrSetup.cpp index 62f1cd3..a5d19e0 100644 --- a/MachMgrSetup.cpp +++ b/MachMgrSetup.cpp @@ -116,5 +116,12 @@ MachMgr::VerifyCurrSetup( STRVECTOR& vsErrors) bool MachMgr::UpdateSetup( void) { - return m_stuMgr.Load() ; + // aggiorno attrezzaggio + if ( ! m_stuMgr.Load()) + return false ; + // carico utensili relativi + Machine* pMch = GetCurrMachine() ; + if ( pMch == nullptr) + return false ; + return pMch->LoadAllTools() ; } diff --git a/Machine.cpp b/Machine.cpp index 91f655e..e74119d 100644 --- a/Machine.cpp +++ b/Machine.cpp @@ -441,9 +441,9 @@ Machine::ModifyMachineAxisHome( const string& sName, double dHome) //---------------------------------------------------------------------------- bool -Machine::LoadMachineStdHead( const string& sName, const string& sParent, const std::string& sHSet, +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, + double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl, const string& sGeo, const STRVECTOR& vsAux) { // recupero pezzo e layer della geometria originale della testa @@ -471,7 +471,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) ; + pHead->Set( sName, MCH_HT_STD, 1, sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh, vsOthColl) ; m_pGeomDB->SetUserObj( nLay, pHead) ; // aggiorno la testa capostipite if ( ! AddHeadToSet( sHSet, sName)) @@ -490,9 +490,9 @@ Machine::LoadMachineStdHead( const string& sName, const string& sParent, const s //---------------------------------------------------------------------------- bool -Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const std::string& sHSet, +Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const string& sHSet, const MUEXITVECTOR& vMuExit, const Vector3d& vtADir, - double dRot1W, const STROKE& Rot2Stroke, int nSolCh, + double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl, const string& sGeo, const STRVECTOR& vsAux) { // recupero pezzo e layer della geometria originale della testa @@ -520,7 +520,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) ; + pHead->Set( sName, MCH_HT_MULTI, int( vMuExit.size()), sHSet, vtADir, dRot1W, Rot2Stroke, nSolCh, vsOthColl) ; m_pGeomDB->SetUserObj( nLay, pHead) ; // aggiorno la testa capostipite if ( ! AddHeadToSet( sHSet, sName)) @@ -537,9 +537,9 @@ Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const //---------------------------------------------------------------------------- bool -Machine::LoadMachineSpecialHead( const string& sName, const string& sParent, const std::string& sHSet, +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, + double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl, const string& sGeo, const STRVECTOR& vsAux) { // recupero pezzo e layer della geometria originale della testa @@ -567,7 +567,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) ; + pHead->Set( sName, MCH_HT_SPECIAL, 1, sHSet, vtADir, dRot1W, 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 351f44a..611f986 100644 --- a/Machine.h +++ b/Machine.h @@ -58,8 +58,9 @@ class Machine bool LoadTool( const std::string& sHead, int nExit, const std::string& sTool) ; bool GetLoadedTool( const std::string& sHead, int nExit, std::string& sTool) const ; bool UnloadTool( const std::string& sHead, int nExit) ; - bool LoadTools( const std::string& sHead) ; + bool LoadTools( const std::string& sHead, int* pnCount = nullptr) ; bool UnloadTools( const std::string& sHead) ; + bool LoadAllTools( void) ; bool UnloadAllTools( void) ; bool ResetHeadSet( const std::string& sHead) ; bool GetAxisToken( const std::string& sAxis, std::string& sToken) const ; @@ -82,6 +83,7 @@ class Machine bool GetCurrTool( std::string& sTool) const ; int GetCurrHead( void) const ; bool GetCurrHead( std::string& sHead) const ; + bool GetCurrHeadCollGroups( INTVECTOR& vIds) const ; double GetCurrRot1W( void) const ; std::string GetKinematicAxis( int nInd) const ; bool BlockKinematicRotAxis( const std::string& sName, double dVal) ; @@ -162,15 +164,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, + double dRot1W, 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, + double dRot1W, 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, + double dRot1W, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl, const std::string& sGeo, const STRVECTOR& vsAux) ; int GetGroup( const std::string& sGroup) const ; bool IsBaseGroup( int nGroup) const ; diff --git a/MachineCalc.cpp b/MachineCalc.cpp index 281cb61..a2ef9aa 100644 --- a/MachineCalc.cpp +++ b/MachineCalc.cpp @@ -319,6 +319,32 @@ Machine::GetCurrHead( std::string& sHead) const return m_pGeomDB->GetName( m_nCalcHeadId, sHead) ; } +//---------------------------------------------------------------------------- +bool +Machine::GetCurrHeadCollGroups( INTVECTOR& vIds) const +{ + // controllo GeomDB + if ( m_pGeomDB == nullptr) + return false ; + // recupero la testa corrente + Head* pHead = GetHead( m_nCalcHeadId) ; + if ( pHead == nullptr) + return false ; + vIds.push_back( m_nCalcHeadId) ; + // recupero stringhe con gruppi ausiliari di collisione + const STRVECTOR& vsOthColl = pHead->GetOtherCollGroups() ; + for each ( const auto& sOthColl in vsOthColl) { + string sGrp, sSub ; + Split( sOthColl, "/", true, sGrp, sSub) ; + int nId = GetGroup( sGrp) ; + if ( ! sSub.empty() && nId != GDB_ID_NULL) + nId = m_pGeomDB->GetFirstNameInGroup( nId, sSub) ; + if ( nId != GDB_ID_NULL) + vIds.push_back( nId) ; + } + return true ; +} + //---------------------------------------------------------------------------- double Machine::GetCurrRot1W( void) const diff --git a/MachineHeads.cpp b/MachineHeads.cpp index 50464c5..ee9a18b 100644 --- a/MachineHeads.cpp +++ b/MachineHeads.cpp @@ -164,8 +164,11 @@ Machine::UnloadTool( const string& sHead, int nExit) //---------------------------------------------------------------------------- bool -Machine::LoadTools( const string& sHead) +Machine::LoadTools( const string& sHead, int* pnCount) { + // annullo eventuale parametro di conteggio + if ( pnCount != nullptr) + *pnCount = 0 ; // controllo GeomDB e MachMgr if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr) return false ; @@ -188,7 +191,9 @@ Machine::LoadTools( const string& sHead) // recupero l'utensile da attrezzare sull'uscita string sTool ; if ( m_pMchMgr->GetCurrSetupMgr().GetToolName( sHead, nExit, sTool) && ! sTool.empty()) { - LoadTool( pExit, sTool) ; + bool bOk = LoadTool( pExit, sTool) ; + if ( bOk && pnCount != nullptr) + ++ ( *pnCount) ; } // se nessun utensile, allora pulisco il gruppo dell'uscita else { @@ -201,6 +206,35 @@ Machine::LoadTools( const string& sHead) return EnableHeadInSet( sHead) ; } +//---------------------------------------------------------------------------- +bool +Machine::LoadAllTools( void) +{ + // controllo GeomDB e MachMgr + if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr) + return false ; + // verifico che l'attrezzaggio contenga qualcosa + if ( ! m_pMchMgr->GetCurrSetupMgr().Exists()) + return true ; + // ciclo su tutte le teste + for each ( const auto& snGro in m_mapGroups) { + if ( IsHeadGroup( snGro.second)) { + // recupero l'insieme di appartenenza della testa + const STRVECTOR& vsHSet = GetHSet( snGro.first) ; + if ( vsHSet.empty()) + continue ; + // se testa capofila dell'insieme + if ( vsHSet.front() == snGro.first) { + // carico prima testa con utensili dell'insieme + for ( int i = 0, nTools = 0 ; i < int( vsHSet.size()) && nTools == 0 ; ++ i) { + LoadTools( vsHSet[i], &nTools) ; + } + } + } + } + return true ; +} + //---------------------------------------------------------------------------- bool Machine::UnloadTools( const string& sHead) diff --git a/MachineLua.cpp b/MachineLua.cpp index 8fcf54f..a083f74 100644 --- a/MachineLua.cpp +++ b/MachineLua.cpp @@ -51,6 +51,7 @@ static const string FLD_ADIR = "ADir" ; static const string FLD_ROT1W = "Rot1W" ; static const string FLD_ROT2STROKE = "Rot2Stroke" ; static const string FLD_SOLCH = "SolCh" ; +static const string FLD_OTHCOLL = "OthColl" ; //---------------------------------------------------------------------------- Machine* Machine::m_pMchLua = nullptr ; @@ -530,6 +531,9 @@ Machine::LuaEmtStdHead( lua_State* L) // lettura eventuale campo 'SolCh' dalla tabella int nSolCh = MCH_SCC_NONE ; LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ; + // lettura eventuale campo 'OthColl' dalla tabella + STRVECTOR vsOthColl ; + LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ; // lettura campo 'Geo' dalla tabella string sGeo ; LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo) @@ -548,7 +552,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, sGeo, vsAux)) + dRot1W, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux)) return luaL_error( L, " Load Machine Standard Head failed") ; // restituisco l'indice della testa @@ -605,6 +609,9 @@ Machine::LuaEmtMultiHead( lua_State* L) // lettura eventuale campo 'SolCh' dalla tabella int nSolCh = MCH_SCC_NONE ; LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ; + // lettura eventuale campo 'OthColl' dalla tabella + STRVECTOR vsOthColl ; + LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ; // lettura campo 'Geo' dalla tabella string sGeo ; LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo) @@ -623,7 +630,7 @@ Machine::LuaEmtMultiHead( lua_State* L) // carico i dati della testa multipla if ( ! m_pMchLua->LoadMachineMultiHead( sName, sParent, sHSet, vMuExit, vtADir, - dRot1W, Rot2Stroke, nSolCh, sGeo, vsAux)) + dRot1W, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux)) return luaL_error( L, " Load Machine Standard Head failed") ; // restituisco l'indice della testa @@ -669,6 +676,9 @@ Machine::LuaEmtSpecialHead( lua_State* L) // lettura eventuale campo 'SolCh' dalla tabella int nSolCh = MCH_SCC_NONE ; LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ; + // lettura eventuale campo 'OthColl' dalla tabella + STRVECTOR vsOthColl ; + LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ; // lettura campo 'Geo' dalla tabella string sGeo ; LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo) @@ -687,7 +697,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, sGeo, vsAux)) + dRot1W, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux)) return luaL_error( L, " Load Machine Special Head failed") ; // restituisco l'indice della testa diff --git a/MachiningsMgr.cpp b/MachiningsMgr.cpp index e9852d2..189ff33 100644 --- a/MachiningsMgr.cpp +++ b/MachiningsMgr.cpp @@ -45,6 +45,8 @@ const string MF_5AXCOMP = "5AXCOMP" ; const bool MF_CURR_5AXCOMP = false ; const string MF_SAFEZ = "SAFEZ" ; const double MF_CURR_SAFEZ = 100 ; +const string MF_SAFEAGGRBOTTZ = "SAFEAGGRBOTTZ" ; +const double MF_CURR_SAFEAGGRBOTTZ = 10 ; const string MF_EXTRALCR = "EXTRALCR" ; const double MF_CURR_EXTRALCR = 0 ; const string MF_EXTRARDR = "EXTRARDR" ; @@ -67,6 +69,7 @@ MachiningsMgr::MachiningsMgr( void) m_pCurrMach = nullptr ; m_bModified = false ; m_dSafeZ = MF_CURR_SAFEZ ; + m_dSafeAggrBottZ = MF_CURR_SAFEAGGRBOTTZ ; m_b3AxComp = MF_CURR_3AXCOMP ; m_b5AxComp = MF_CURR_5AXCOMP ; m_dExtraLOnCutRegion = MF_CURR_EXTRALCR ; @@ -246,6 +249,7 @@ MachiningsMgr::LoadGeneral( Scanner& TheScanner, bool& bEnd) if ( sLine != MF_GENERAL) return false ; bool bOk = true ; + bool bSafeAggrBottZ = false ; // leggo le linee successive bEnd = true ; while ( bOk && TheScanner.GetLine( sLine)) { @@ -265,6 +269,10 @@ MachiningsMgr::LoadGeneral( Scanner& TheScanner, bool& bEnd) bOk = FromString( sVal, m_b5AxComp) ; else if ( ToUpper( sKey) == MF_SAFEZ) bOk = FromString( sVal, m_dSafeZ) ; + else if ( ToUpper( sKey) == MF_SAFEAGGRBOTTZ) { + bSafeAggrBottZ = true ; + bOk = FromString( sVal, m_dSafeAggrBottZ) ; + } else if ( ToUpper( sKey) == MF_EXTRALCR) bOk = FromString( sVal, m_dExtraLOnCutRegion) ; else if ( ToUpper( sKey) == MF_EXTRARDR) @@ -280,6 +288,9 @@ MachiningsMgr::LoadGeneral( Scanner& TheScanner, bool& bEnd) else bOk = false ; } + if ( ! bSafeAggrBottZ) + m_dSafeAggrBottZ = m_dSafeZ ; + return bOk ; } @@ -441,6 +452,8 @@ MachiningsMgr::SaveGeneral( Writer& TheWriter) const bOk = bOk && TheWriter.OutText( sOut) ; sOut = MF_SAFEZ + "=" + ToString( m_dSafeZ) ; bOk = bOk && TheWriter.OutText( sOut) ; + sOut = MF_SAFEAGGRBOTTZ + "=" + ToString( m_dSafeAggrBottZ) ; + bOk = bOk && TheWriter.OutText( sOut) ; sOut = MF_EXTRALCR + "=" + ToString( m_dExtraLOnCutRegion) ; bOk = bOk && TheWriter.OutText( sOut) ; sOut = MF_EXTRARDR + "=" + ToString( m_dExtraROnDrillRegion) ; @@ -960,6 +973,21 @@ MachiningsMgr::SetSafeZ( double dSafeZ) return true ; } +//---------------------------------------------------------------------------- +bool +MachiningsMgr::SetSafeAggrBottZ( double dSafeAggrBottZ) +{ + // deve essere un valore positivo o nullo + if ( dSafeAggrBottZ < - EPS_SMALL) + return false ; + // se cambiato, salvo e setto modifica + if ( fabs( dSafeAggrBottZ - m_dSafeAggrBottZ) > EPS_SMALL) { + m_dSafeAggrBottZ = dSafeAggrBottZ ; + m_bModified = true ; + } + return true ; +} + //---------------------------------------------------------------------------- bool MachiningsMgr::SetExtraLOnCutRegion( double dExtraL) diff --git a/MachiningsMgr.h b/MachiningsMgr.h index 5d0763b..5a472d0 100644 --- a/MachiningsMgr.h +++ b/MachiningsMgr.h @@ -57,6 +57,9 @@ class MachiningsMgr bool SetSafeZ( double dSafeZ) ; double GetSafeZ( void) const { return m_dSafeZ ; } + bool SetSafeAggrBottZ( double dSafeAggrBottZ) ; + double GetSafeAggrBottZ( void) const + { return m_dSafeAggrBottZ ; } bool SetExtraLOnCutRegion( double dExtraL) ; double GetExtraLOnCutRegion( void) { return m_dExtraLOnCutRegion ; } @@ -109,6 +112,7 @@ class MachiningsMgr bool m_b3AxComp ; bool m_b5AxComp ; double m_dSafeZ ; + double m_dSafeAggrBottZ ; double m_dExtraLOnCutRegion ; double m_dExtraROnDrillRegion ; double m_dHoleDiamToler ; diff --git a/Milling.cpp b/Milling.cpp index c6f51ec..b711901 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -47,6 +47,9 @@ using namespace std ; // 2312 = "Error in Milling : LeadIn must be out of rawpart" // 2313 = "Error in Milling : Chaining failed" // 2314 = "Error in Milling : Tool MaxMaterial too small (xx)" +// 2315 = "Error in Milling : axes values not calculable" +// 2316 = "Error in Milling : link movements not calculable" +// 2317 = "Error in Milling : post apply not calculable" //---------------------------------------------------------------------------- USEROBJ_REGISTER( "EMkMilling", Milling) ; @@ -216,6 +219,9 @@ Milling::SetParam( int nType, bool bVal) case MPA_LEAVETAB : m_Params.m_bLeaveTab = bVal ; return true ; + case MPA_TOOLINVERT : + m_Params.m_bToolInvert = bVal ; + return true ; } return false ; } @@ -250,6 +256,11 @@ Milling::SetParam( int nType, int nVal) return false ; m_Params.m_nSolCh = nVal ; return true ; + case MPA_FACEUSE : + if ( ! m_Params.VerifyFaceUse( nVal)) + return false ; + m_Params.m_nFaceUse = nVal ; + return true ; } return false ; } @@ -371,6 +382,12 @@ Milling::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; default : return false ; } @@ -535,18 +552,36 @@ Milling::Apply( bool bRecalc) return true ; } + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2315, "Error in Milling : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2316, "Error in Milling : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2317, "Error in Milling : post apply not calculable") ; return false ; + } return true ; } @@ -562,6 +597,9 @@ Milling::GetParam( int nType, bool& bVal) const case MPA_LEAVETAB : bVal = m_Params.m_bLeaveTab ; return true ; + case MPA_TOOLINVERT : + bVal = m_Params.m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -590,6 +628,9 @@ Milling::GetParam( int nType, int& nVal) const case MPA_SCC : nVal = m_Params.m_nSolCh ; return true ; + case MPA_FACEUSE : + nVal = m_Params.m_nFaceUse ; + return true ; } nVal = 0 ; return false ; @@ -691,6 +732,12 @@ Milling::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; @@ -882,25 +929,24 @@ Milling::GetCurve( SelData Id) bool Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo) { - // tipo di utilizzo contorno superficie - enum { SURF_CONT = 0, SURF_TOP = 1, SURF_BOTTOM = 2} ; - int nSurf ; - // se fresa, lo recupero dalle note utente - if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { - string sSurf = ExtractSurf( m_Params.m_sUserNotes) ; - if ( sSurf == "C") - nSurf = SURF_CONT ; - else if ( sSurf == "T") - nSurf = SURF_TOP ; - else - nSurf = SURF_BOTTOM ; - } - // altrimenti lama, sempre bottom + // tipo posizione utensile + enum { TOOL_PARAL = 1, TOOL_ORTHO = 2, TOOL_ORTUP = 3} ; + int nToolDir ; + if ( ( m_Params.m_nFaceUse & 64) != 0) + nToolDir = TOOL_ORTUP ; + else if ( ( m_Params.m_nFaceUse & 32) != 0) + nToolDir = TOOL_ORTHO ; else - nSurf = SURF_BOTTOM ; + nToolDir = TOOL_PARAL ; + // tipo di utilizzo contorno faccia + enum { FACE_DOWN = 1, FACE_TOP = 2, FACE_FRONT = 3, FACE_BACK = 4, FACE_LEFT = 5, FACE_RIGHT = 6, FACE_CONT = 7} ; + int nFace = ( m_Params.m_nFaceUse & 31) ; + + // copia della curva originale + PtrOwner pCopy( pCrvCompo->Clone()) ; // se richiesto contorno - if ( nSurf == SURF_CONT) { + if ( nFace == FACE_CONT) { // cerco l'estremo più alto e lo imposto come inizio double dU = 0 ; double dUmax = 0 ; @@ -921,16 +967,44 @@ Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo) // ingombro BBox3d b3Box ; pCrvCompo->GetLocalBBox( b3Box) ; - double dZmin = b3Box.GetMin().z ; - double dZmax = b3Box.GetMax().z ; - double dZtol = min( ( dZmax - dZmin) / 4., 20.) ; - // elimino le linee troppo sopra il minimo dall'inizio e poi dalla fine + double dMin = b3Box.GetMin().z ; + double dMax = b3Box.GetMax().z ; + if ( nFace == FACE_FRONT || nFace == FACE_BACK) { + dMin = b3Box.GetMin().y ; + dMax = b3Box.GetMax().y ; + } + else if ( nFace == FACE_RIGHT || nFace == FACE_LEFT) { + dMin = b3Box.GetMin().x ; + dMax = b3Box.GetMax().x ; + } + double dTol = min( ( dMax - dMin) / 4., 20.) ; + // cerco il punto medio delle curve più vicino all'estremo desiderato + double dRef = dMin ; + if ( nFace == FACE_DOWN || nFace == FACE_FRONT || nFace == FACE_LEFT) + dRef = dMax ; const ICurve* pCrv = pCrvCompo->GetFirstCurve() ; while ( pCrv != nullptr) { Point3d ptMid ; pCrv->GetMidPoint( ptMid) ; - Vector3d vtDir ; pCrv->GetMidDir( vtDir) ; - if ( ( nSurf == SURF_BOTTOM && ptMid.z > dZmin + dZtol) || - ( nSurf == SURF_TOP && ptMid.z < dZmax - dZtol)) { + switch ( nFace) { + case FACE_DOWN : dRef = min( dRef, ptMid.z) ; break ; + case FACE_TOP : dRef = max( dRef, ptMid.z) ; break ; + case FACE_FRONT : dRef = min( dRef, ptMid.y) ; break ; + case FACE_BACK : dRef = max( dRef, ptMid.y) ; break ; + case FACE_LEFT : dRef = min( dRef, ptMid.x) ; break ; + case FACE_RIGHT : dRef = max( dRef, ptMid.x) ; break ; + } + pCrv = pCrvCompo->GetNextCurve() ; + } + // elimino le linee troppo discoste dal riferimento dall'inizio e poi dalla fine + pCrv = pCrvCompo->GetFirstCurve() ; + while ( pCrv != nullptr) { + Point3d ptMid ; pCrv->GetMidPoint( ptMid) ; + if ( ( nFace == FACE_DOWN && ptMid.z > dRef + dTol) || + ( nFace == FACE_TOP && ptMid.z < dRef - dTol) || + ( nFace == FACE_FRONT && ptMid.y > dRef + dTol) || + ( nFace == FACE_BACK && ptMid.y < dRef - dTol) || + ( nFace == FACE_LEFT && ptMid.x > dRef + dTol) || + ( nFace == FACE_RIGHT && ptMid.x < dRef - dTol)) { ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( false) ; delete( pErase) ; pCrv = pCrvCompo->GetFirstCurve() ; @@ -941,9 +1015,12 @@ Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo) pCrv = pCrvCompo->GetLastCurve() ; while ( pCrv != nullptr) { Point3d ptMid ; pCrv->GetMidPoint( ptMid) ; - Vector3d vtDir ; pCrv->GetMidDir( vtDir) ; - if ( ( nSurf == SURF_BOTTOM && ptMid.z > dZmin + dZtol) || - ( nSurf == SURF_TOP && ptMid.z < dZmax - dZtol)) { + if ( ( nFace == FACE_DOWN && ptMid.z > dRef + dTol) || + ( nFace == FACE_TOP && ptMid.z < dRef - dTol) || + ( nFace == FACE_FRONT && ptMid.y > dRef + dTol) || + ( nFace == FACE_BACK && ptMid.y < dRef - dTol) || + ( nFace == FACE_LEFT && ptMid.x > dRef + dTol) || + ( nFace == FACE_RIGHT && ptMid.x < dRef - dTol)) { ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( true) ; delete( pErase) ; pCrv = pCrvCompo->GetLastCurve() ; @@ -951,14 +1028,64 @@ Milling::AdjustCurveFromSurf( ICurveComposite* pCrvCompo) else break ; } - // verifico il versore estrusione + } + // determino il versore estrusione (utensile) + if ( nToolDir == TOOL_ORTHO) + pCrvCompo->SetThickness( 0) ; + else if ( nToolDir == TOOL_ORTUP) { Vector3d vtN ; pCrvCompo->GetExtrusion( vtN) ; if ( vtN.z < - sin( 2 * DEGTORAD)) { - pCrvCompo->Invert() ; + // pCrvCompo->Invert() ; pCrvCompo->Translate( vtN * m_TParams.m_dThick) ; pCrvCompo->SetExtrusion( - vtN) ; } + pCrvCompo->SetThickness( 0) ; + } + else { // nToolDir == TOOL_PARAL + // sistemo versore + Vector3d vtN ; + pCrvCompo->GetExtrusion( vtN) ; + Point3d ptStart, ptEnd ; + pCrvCompo->GetStartPoint( ptStart) ; + pCrvCompo->GetEndPoint( ptEnd) ; + Vector3d vtT = ptEnd - ptStart ; + Vector3d vtExtr = vtN ^ vtT ; + if ( ! vtExtr.Normalize()) + return false ; + pCrvCompo->SetExtrusion( vtExtr) ; + // elimino eventuali parti iniziali e/o finali dirette circa come il versore + const double MAX_ALL_COS = cos( 25 * DEGTORAD) ; + const ICurve* pCrv = pCrvCompo->GetFirstCurve() ; + while ( pCrv != nullptr) { + Vector3d vtDir ; pCrv->GetStartDir( vtDir) ; + if ( abs( vtDir * vtExtr) > MAX_ALL_COS) { + ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( false) ; + delete( pErase) ; + pCrv = pCrvCompo->GetFirstCurve() ; + } + else + break ; + } + pCrv = pCrvCompo->GetLastCurve() ; + while ( pCrv != nullptr) { + Vector3d vtDir ; pCrv->GetStartDir( vtDir) ; + if ( abs( vtDir * vtExtr) > MAX_ALL_COS) { + ICurve* pErase = pCrvCompo->RemoveFirstOrLastCurve( true) ; + delete( pErase) ; + pCrv = pCrvCompo->GetLastCurve() ; + } + else + break ; + } + // determino lo spessore misurato lungo la direzione + if ( ! IsNull( pCopy)) { + Frame3d frOcs ; frOcs.Set( ORIG, vtExtr) ; + Frame3d frExtr ; frExtr.ToLoc( frOcs) ; + BBox3d b3Extr ; pCopy->GetBBox( frExtr, b3Extr) ; + if ( ! b3Extr.IsEmpty()) + pCrvCompo->SetThickness( b3Extr.GetMax().z - b3Extr.GetMin().z) ; + } } return true ; } @@ -968,8 +1095,6 @@ bool Milling::Chain( int nGrpDestId) { // vettore puntatori alle curve - typedef PtrOwner POWNCURVE ; - typedef std::vector POCRVVECTOR ; POCRVVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; // recupero tutte le curve e le porto in globale @@ -1117,6 +1242,14 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId) double dThick ; pCompo->GetThickness( dThick) ; + // eventuale inversione direzione utensile + if ( m_Params.m_bToolInvert) { + vtExtr.Invert() ; + pCompo->SetExtrusion( vtExtr) ; + dThick = - dThick ; + pCompo->SetThickness( dThick) ; + } + // eventuali allungamenti/accorciamenti per percorso aperto o chiuso senza sovrapposizione if ( ! pCompo->IsClosed() || m_Params.m_dOverlap < EPS_SMALL) { // verifico che il percorso sia abbastanza lungo @@ -1574,8 +1707,9 @@ bool Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, bool bSplitArcs) { - // recupero distanza di sicurezza + // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; @@ -1608,6 +1742,8 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; + // determino se l'inizio dell'attacco è sopra il grezzo + bool bAboveStart = GetPointAboveRaw( ptP1) ; // aggiungo approccio per frese normali con spazio sopra attacco if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale con punto inizio attacco @@ -1618,7 +1754,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo dStElev = - LIO_ELEV_TOL ; } // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart)) + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) return false ; } // altrimenti, approccio per lame o diretto @@ -1681,8 +1817,10 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione finale con punto fine uscita dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // determino se la fine dell'uscita è sopra il grezzo + bool bAboveEnd = GetPointAboveRaw( ptP1) ; // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) return false ; } // per lame non è necessario @@ -1696,8 +1834,9 @@ bool Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { - // recupero distanza di sicurezza + // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; @@ -1745,12 +1884,14 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; + // determino se l'inizio dell'attacco è sopra il grezzo + bool bAboveStart = GetPointAboveRaw( ptP1) ; // se primo step aggiungo approccio per frese normali if ( j == 1 && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale con punto inizio attacco dStElev -= ( ptP1 - ptStart) * vtExtr ; // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart)) + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) return false ; } // altrimenti, affondo al punto iniziale @@ -1832,8 +1973,10 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( j == nStep && ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione finale con punto fine uscita dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // determino se la fine dell'uscita è sopra il grezzo + bool bAboveEnd = GetPointAboveRaw( ptP1) ; // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) return false ; } // per lame non è necessario @@ -1848,8 +1991,9 @@ bool Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { - // recupero distanza di sicurezza + // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; @@ -1897,6 +2041,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; + // determino se l'inizio dell'attacco è sopra il grezzo + bool bAboveStart = GetPointAboveRaw( ptP1) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale con punto inizio attacco @@ -1907,7 +2053,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dStElev = ( j - 1) * dStep ; } // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart)) + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) return false ; } // altrimenti, approccio per lame @@ -1974,8 +2120,10 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione finale con punto fine uscita dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // determino se la fine dell'uscita è sopra il grezzo + bool bAboveEnd = GetPointAboveRaw( ptP1) ; // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) return false ; } // per lame non è necessario @@ -1990,8 +2138,9 @@ bool Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { - // recupero distanza di sicurezza + // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; // se attacco ad inseguimento (per ora nullo), parto sopra di elevazione in attacco @@ -2041,12 +2190,14 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool return false ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; + // determino se l'inizio dell'attacco è sopra il grezzo + bool bAboveStart = GetPointAboveRaw( ptP1) ; // aggiungo approccio per frese normali if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione iniziale con punto inizio attacco dStElev -= ( ptP1 - ptStart) * vtExtr ; // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart)) + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) return false ; } // altrimenti, affondo al punto iniziale per lame @@ -2113,8 +2264,10 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione finale con punto fine uscita dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // determino se la fine dell'uscita è sopra il grezzo + bool bAboveEnd = GetPointAboveRaw( ptP1) ; // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) return false ; } // per lame non è necessario @@ -2167,8 +2320,10 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool dStElev -= ( ptP1 - ptStart) * vtExtr ; // determino se l'inizio dell'attacco è fuori dal grezzo bool bOutStart = GetPointOutOfRaw( ptP1, vtTool) ; + // determino se l'inizio dell'attacco è sopra il grezzo + bool bAboveStart = GetPointAboveRaw( ptP1) ; // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutStart)) + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) return false ; } // altrimenti, affondo per lame @@ -2229,8 +2384,10 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) { // correggo elevazione finale con punto fine uscita dEndElev -= ( ptP1 - ptEnd) * vtExtr ; + // determino se la fine dell'uscita è sopra il grezzo + bool bAboveEnd = GetPointAboveRaw( ptP1) ; // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bAboveEnd)) return false ; } // per lame non è necessario @@ -2243,7 +2400,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool //---------------------------------------------------------------------------- bool -Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr, bool bOutStart) +Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr, bool bOutStart, bool bAboveStart) { SetFlag( 1) ; // se con aggregato da sotto @@ -2254,14 +2412,14 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ; m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ; // aggiuntivo in Z - double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ; + double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ; // distanza dal bordo del pezzo double dDistBottom ; if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom)) dDistBottom = 0 ; // pre-approccio - Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ; - Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ; + Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dSafeZ) ; + Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ - dElev) ; Vector3d vtAux = m_vtAux ; vtAux.Rotate( Z_AX, 90) ; SetAuxDir( vtAux) ; @@ -2273,10 +2431,11 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, if ( AddRapidMove( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL) return false ; } - // se sopra attacco c'è spazio per sicurezza o approccio - if ( dElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { + // se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio + double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; + if ( ! bAboveStart && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { // se distanza di sicurezza minore di distanza di inizio - if ( dSafeZ < dAppr + 10 * EPS_SMALL) { + if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 1 -> punto sopra inizio Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1) == GDB_ID_NULL) || @@ -2286,7 +2445,7 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, else { // 1a -> punto sopra inizio Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ; - Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - dAppr) ; + Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1a) == GDB_ID_NULL) || ( m_bAggrBottom && AddRapidMove( ptP1a) == GDB_ID_NULL)) return false ; @@ -2315,11 +2474,13 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, //---------------------------------------------------------------------------- bool -Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) +Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr, bool bAboveEnd) { - // se sopra uscita c'è spazio per sicurezza o approccio - if ( dElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { - if ( dSafeZ < dAppr + 10 * EPS_SMALL) { + // se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio + double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; + if ( ! bAboveEnd && dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { + if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 4 -> movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ; @@ -2335,7 +2496,7 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, return false ; } // 4b -> movimento di risalita sopra il punto finale - Point3d ptP4b = ptP4a + vtTool * ( dSafeZ - dAppr) ; + Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } @@ -2348,14 +2509,14 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ; m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ; // aggiuntivo in Z - double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ; + double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ; // distanza dal bordo del pezzo double dDistBottom ; if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom)) dDistBottom = 0 ; // post-retract - Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ; - Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ; + Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dSafeZ) ; + Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ - dElev) ; if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL) return false ; Vector3d vtAux = m_vtAux ; @@ -2713,7 +2874,7 @@ double Milling::GetRadiusForStartEndElevation( void) { const double DELTA_ELEV_RAD = 20.0 ; - double dDeltaRad = DELTA_ELEV_RAD + max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen) ; + double dDeltaRad = DELTA_ELEV_RAD + max( max( m_Params.m_dStartAddLen, m_Params.m_dEndAddLen), 0.0) ; return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ; } @@ -2727,3 +2888,24 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool) return false ; return ( dTemp < 10 * EPS_SMALL) ; } + +//---------------------------------------------------------------------------- +bool +Milling::GetPointAboveRaw( const Point3d& ptP) +{ + // determino la posizione del punto rispetto al grezzo + // ciclo sui grezzi + int nRawId = m_pMchMgr->GetFirstRawPart() ; + while ( nRawId != GDB_ID_NULL) { + // se il grezzo compare nella fase + if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) { + int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; + BBox3d b3Raw ; + m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ; + if ( ! b3Raw.IsEmpty() && ptP.z < b3Raw.GetMax().z - 10 * EPS_SMALL) + return false ; + } + nRawId = m_pMchMgr->GetNextRawPart( nRawId) ; + } + return true ; +} diff --git a/Milling.h b/Milling.h index 5c79a71..845ac47 100644 --- a/Milling.h +++ b/Milling.h @@ -78,8 +78,10 @@ class Milling : public Machining double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; bool AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; - bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr, bool bOutStart) ; - bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; + bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr, bool bOutStart, bool bAboveStart) ; + bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr, bool bAboveEnd) ; bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) ; bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, @@ -88,6 +90,7 @@ class Milling : public Machining bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1) ; double GetRadiusForStartEndElevation( void) ; bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool) ; + bool GetPointAboveRaw( const Point3d& ptP) ; private : double GetSpeed() const diff --git a/MillingData.cpp b/MillingData.cpp index 7b0981c..c0acc53 100644 --- a/MillingData.cpp +++ b/MillingData.cpp @@ -26,12 +26,15 @@ using namespace std ; //---------------------------------------------------------------------------- enum nMillingKey { - KEY_DH = 0, + KEY_AB = 0, + KEY_AI, + KEY_DH, KEY_EAL, KEY_F, KEY_FE, KEY_FS, KEY_FT, + KEY_FU, KEY_INV, KEY_LICL, KEY_LIEL, @@ -60,6 +63,7 @@ enum nMillingKey { KEY_TA, KEY_TD, KEY_TH, + KEY_TI, KEY_TL, KEY_TNAME, KEY_TUUID, @@ -68,12 +72,15 @@ enum nMillingKey { KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sMillingKey = { + "AB", + "AI", "DH", "EAL", "F", "FE", "FS", "FT", + "FU", "INV", "LICL", "LIEL", @@ -102,6 +109,7 @@ static const std::array sMillingKey = { "TA", "TD", "TH", + "TI", "TL", "TN", "TU", @@ -143,6 +151,8 @@ MillingData::CopyFrom( const MachiningData* pMdata) m_sName = pSdata->m_sName ; m_ToolUuid = pSdata->m_ToolUuid ; m_sToolName = pSdata->m_sToolName ; + m_sBlockedAxis = pSdata->m_sBlockedAxis ; + m_sInitAngs = pSdata->m_sInitAngs ; m_nSolCh = pSdata->m_nSolCh ; m_dSpeed = pSdata->m_dSpeed ; m_dFeed = pSdata->m_dFeed ; @@ -151,6 +161,8 @@ MillingData::CopyFrom( const MachiningData* pMdata) m_dTipFeed = pSdata->m_dTipFeed ; m_dOffsL = pSdata->m_dOffsL ; m_dOffsR = pSdata->m_dOffsR ; + m_bToolInvert = pSdata->m_bToolInvert ; + m_nFaceUse = pSdata->m_nFaceUse ; m_bInvert = pSdata->m_bInvert ; m_nWorkSide = pSdata->m_nWorkSide ; m_sDepth = pSdata->m_sDepth ; @@ -197,6 +209,8 @@ MillingData::SameAs(const MachiningData* pMdata) const m_sName == pSdata->m_sName && m_ToolUuid == pSdata->m_ToolUuid && m_sToolName == pSdata->m_sToolName && + m_sBlockedAxis == pSdata->m_sBlockedAxis && + m_sInitAngs == pSdata->m_sInitAngs && m_nSolCh == pSdata->m_nSolCh && abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR && @@ -205,6 +219,8 @@ MillingData::SameAs(const MachiningData* pMdata) const abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR && abs( m_dOffsL - pSdata->m_dOffsL) < EPS_MACH_LEN_PAR && abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR && + m_bToolInvert == pSdata->m_bToolInvert && + m_nFaceUse == pSdata->m_nFaceUse && m_bInvert == pSdata->m_bInvert && m_nWorkSide == pSdata->m_nWorkSide && m_sDepth == pSdata->m_sDepth && @@ -270,6 +286,12 @@ MillingData::FromString( const string& sString, int& nKey) nKey = FindMillingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) @@ -290,6 +312,9 @@ MillingData::FromString( const string& sString, int& nKey) case KEY_FT : bOk = ::FromString( sVal, m_dTipFeed) ; break ; + case KEY_FU : + bOk = ::FromString( sVal, m_nFaceUse) ; + break ; case KEY_INV : bOk = ::FromString( sVal, m_bInvert) ; break ; @@ -375,6 +400,9 @@ MillingData::FromString( const string& sString, int& nKey) case KEY_TH : bOk = ::FromString( sVal, m_dTabHeight) ; break ; + case KEY_TI : + bOk = ::FromString( sVal, m_bToolInvert) ; + break ; case KEY_TL : bOk = ::FromString( sVal, m_dTabLen) ; break ; @@ -402,12 +430,15 @@ string MillingData::ToString( int nInd) const { switch ( nInd) { + case KEY_AB : return ( sMillingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sMillingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_DH : return ( sMillingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_EAL : return ( sMillingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; case KEY_F : return ( sMillingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; case KEY_FE : return ( sMillingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; case KEY_FS : return ( sMillingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ; case KEY_FT : return ( sMillingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; + case KEY_FU : return ( sMillingKey[KEY_FU] + "=" + ::ToString( m_nFaceUse)) ; case KEY_INV : return ( sMillingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; case KEY_LICL : return ( sMillingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ; case KEY_LIEL : return ( sMillingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ; @@ -436,6 +467,7 @@ MillingData::ToString( int nInd) const case KEY_TA : return ( sMillingKey[KEY_TA] + "=" + ::ToString( m_dTabAngle)) ; case KEY_TD : return ( sMillingKey[KEY_TD] + "=" + ::ToString( m_dTabDist)) ; case KEY_TH : return ( sMillingKey[KEY_TH] + "=" + ::ToString( m_dTabHeight)) ; + case KEY_TI : return ( sMillingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ; case KEY_TL : return ( sMillingKey[KEY_TL] + "=" + ::ToString( m_dTabLen)) ; case KEY_TNAME : return ( sMillingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sMillingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; @@ -449,9 +481,10 @@ MillingData::ToString( int nInd) const bool MillingData::IsOptional( int nKey) const { - return ( nKey == KEY_EAL || nKey == KEY_F || nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || - nKey == KEY_NNS || nKey == KEY_NNU || nKey == KEY_OL || nKey == KEY_OR || nKey == KEY_S || - nKey == KEY_SAL || nKey == KEY_SCC) ; + return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_EAL || nKey == KEY_F || + nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || nKey == KEY_FU || + nKey == KEY_NNS || nKey == KEY_NNU || nKey == KEY_OL || nKey == KEY_OR || + nKey == KEY_S || nKey == KEY_SAL || nKey == KEY_SCC || nKey == KEY_TI) ; } //---------------------------------------------------------------------------- @@ -461,6 +494,16 @@ MillingData::VerifySolCh( int nVal) const return IsValidOperationScc( nVal) ; } +//---------------------------------------------------------------------------- +bool +MillingData::VerifyFaceUse( int nVal) const +{ + return ( nVal == MILL_FU_NONE || + ( nVal >= MILL_FU_PARAL_DOWN && nVal <= MILL_FU_PARAL_RIGHT) || + ( nVal >= MILL_FU_ORTHO_DOWN && nVal <= MILL_FU_ORTHO_CONT) || + ( nVal >= MILL_FU_ORTUP_DOWN && nVal <= MILL_FU_ORTUP_CONT)) ; +} + //---------------------------------------------------------------------------- bool MillingData::VerifyWorkSide( int nVal) const @@ -532,9 +575,12 @@ MillingData::SetParam( int nType, bool bVal) case MPA_INVERT : m_bInvert = bVal ; return true ; - case MPA_LEAVETAB : + case MPA_LEAVETAB : m_bLeaveTab = bVal ; return true ; + case MPA_TOOLINVERT : + m_bToolInvert = bVal ; + return true ; } return false ; } @@ -569,6 +615,11 @@ MillingData::SetParam( int nType, int nVal) return false ; m_nSolCh = nVal ; return true ; + case MPA_FACEUSE : + if ( ! VerifyFaceUse( nVal)) + return false ; + m_nFaceUse = nVal ; + return true ; } return false ; } @@ -686,6 +737,12 @@ MillingData::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -710,6 +767,9 @@ MillingData::GetParam( int nType, bool& bVal) const case MPA_LEAVETAB : bVal = m_bLeaveTab ; return true ; + case MPA_TOOLINVERT : + bVal = m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -738,6 +798,9 @@ MillingData::GetParam( int nType, int& nVal) const case MPA_SCC : nVal = m_nSolCh ; return true ; + case MPA_FACEUSE : + nVal = m_nFaceUse ; + return true ; } nVal = 0 ; return false ; @@ -854,6 +917,12 @@ MillingData::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/MillingData.h b/MillingData.h index f19daaa..411b856 100644 --- a/MillingData.h +++ b/MillingData.h @@ -20,6 +20,8 @@ struct MillingData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) @@ -28,6 +30,8 @@ struct MillingData : public MachiningData double m_dTipFeed ; // velocità di lavorazione di testa ( se 0 da utensile) double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile) double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile) + bool m_bToolInvert ; // flag per inversione direzione utensile da geometria + int m_nFaceUse ; // metodo di utilizzo della faccia per lavorare bool m_bInvert ; // flag di inversione direzione lavorazione int m_nWorkSide ; // lato di lavoro (destra, sinistra, centro) std::string m_sDepth ; // affondamento (espressione numerica) @@ -58,7 +62,8 @@ struct MillingData : public MachiningData MillingData( void) : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0), - m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), m_bInvert( false), m_nWorkSide( 0), + m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), + m_bToolInvert( false), m_nFaceUse( 0), m_bInvert( false), m_nWorkSide( 0), m_dStartPos( 0), m_dOverlap( 0), m_dStep( 0), m_nStepType( 0), m_dSideAngle( 0), m_dStartAddLen( 0), m_dEndAddLen( 0), m_bLeaveTab( false), m_dTabLen( 0), m_dTabDist( 0), m_dTabHeight( 0), m_dTabAngle( 0), @@ -86,6 +91,7 @@ struct MillingData : public MachiningData bool GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const override ; bool VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const override ; bool VerifySolCh( int nVal) const ; + bool VerifyFaceUse( int nVal) const ; bool VerifyWorkSide( int nVal) const ; bool VerifyStepType( int nVal) const ; bool VerifyLeadInType( int nVal) const ; diff --git a/Operation.cpp b/Operation.cpp index b76b94f..59c5e22 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -270,11 +270,12 @@ Operation::GetDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3 BBox3d b3Raw ; int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; if ( m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw) && b3Pnt.OverlapsXY( b3Raw)) { - // porto il punto nel riferimento del grezzo + // porto il punto nel riferimento del grezzo (a Z=0 perchè ivi è il contorno) Frame3d frRaw ; m_pGeomDB->GetGroupGlobFrame( nRawId, frRaw) ; Point3d ptPL = ptP ; ptPL.ToLoc( frRaw) ; + ptPL.z = 0 ; // verifica con il contorno int nOutCrvId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_OUTLINE) ; const ICurve* pCurve = GetCurve( m_pGeomDB->GetGeoObj( nOutCrvId)) ; @@ -338,11 +339,12 @@ Operation::GetMinDistanceFromRawSide( int nPhase, const Point3d& ptP, double& dD BBox3d b3Raw ; int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ; if ( m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw) && b3Pnt.OverlapsXY( b3Raw)) { - // porto il punto nel riferimento del grezzo + // porto il punto nel riferimento del grezzo (a Z=0 perchè ivi è il contorno) Frame3d frRaw ; m_pGeomDB->GetGroupGlobFrame( nRawId, frRaw) ; Point3d ptPL = ptP ; ptPL.ToLoc( frRaw) ; + ptPL.z = 0 ; // verifica con il contorno int nOutCrvId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_OUTLINE) ; const ICurve* pCurve = GetCurve( m_pGeomDB->GetGeoObj( nOutCrvId)) ; @@ -626,25 +628,6 @@ Operation::ExtractHint( const std::string& sNotes) return sHint ; } -//---------------------------------------------------------------------------- -string -Operation::ExtractSurf( const std::string& sNotes) -{ - const string KEY_SURF = "Surf:" ; - string sHint ; - STRVECTOR vsCmd ; - Tokenize( sNotes, ";", vsCmd) ; - for each (const auto& sCmd in vsCmd) { - // se per assi rotanti - if ( sCmd.find( KEY_SURF) != string::npos) { - sHint = sCmd ; - ReplaceString( sHint, KEY_SURF, "") ; - break ; - } - } - return sHint ; -} - //---------------------------------------------------------------------------- bool Operation::CalculateAxesValues( const string& sHint) @@ -1672,6 +1655,8 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn // Aggancio bloccaggi alla tavola corrente for ( const auto nFxtId : vFxtId) pMch->LinkFixtureToGroup( nFxtId, sTable) ; + // distanza di sicurezza + double dSafeDist = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() - 10 * EPS_SMALL ; // Vado nelle posizioni da controllare const int COLL_STEP = 16 ; bool bCollide = false ; @@ -1682,16 +1667,23 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn double dPos = ( 1 - dCoeff) * vAxStart[j] + dCoeff * vAxEnd[j] ; pMch->SetAxisPos( vAxName[j], dPos) ; } - // Determino sottobox e box della testa + // Determino sottobox e box della testa e degli altri oggetti da considerare per la collisione BOXIVECTOR vbiSH ; BBox3d b3Head ; - int nHId = m_pGeomDB->GetFirstGroupInGroup( pMch->GetCurrHead()) ; - while ( nHId != GDB_ID_NULL) { - BBox3d b3Tmp ; - m_pGeomDB->GetGlobalBBox( nHId, b3Tmp, BBF_ONLY_VISIBLE) ; - b3Head.Add( b3Tmp) ; - vbiSH.emplace_back( b3Tmp, nHId) ; - nHId = m_pGeomDB->GetNextGroup( nHId) ; + INTVECTOR vCollId ; + pMch->GetCurrHeadCollGroups( vCollId) ; + for each ( int nCId in vCollId) { + int nHId = m_pGeomDB->GetFirstInGroup( nCId) ; + while ( nHId != GDB_ID_NULL) { + BBox3d b3Tmp ; + m_pGeomDB->GetGlobalBBox( nHId, b3Tmp, BBF_ONLY_VISIBLE) ; + if ( ! b3Tmp.IsEmpty()) { + b3Tmp.Expand( dSafeDist) ; + b3Head.Add( b3Tmp) ; + vbiSH.emplace_back( b3Tmp, nHId) ; + } + nHId = m_pGeomDB->GetNext( nHId) ; + } } // Li confronto con i grezzi for ( const auto nRawId : vRawId) { @@ -1708,6 +1700,7 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn // sottobox testa nel riferimento del solido BBox3d b3Hsol ; m_pGeomDB->GetRefBBox( biSH.second, frSolid, b3Hsol) ; + b3Hsol.Expand( dSafeDist) ; // solido const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nRawSolidId)) ; // verifica di collisione tra sottobox e solido @@ -1721,6 +1714,7 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn break ; } } + // Se non trovata collisione, li confronto con i bloccaggi if ( ! bCollide) { for ( const auto nFxtId : vFxtId) { // verifico i box diff --git a/Operation.h b/Operation.h index 8e40e81..d35dbc9 100644 --- a/Operation.h +++ b/Operation.h @@ -79,7 +79,6 @@ class Operation : public IUserObj bool GetFinalAxesValues( DBLVECTOR& vAxVal) ; bool GetClPathFinalAxesValues( int nClPathId, DBLVECTOR& vAxVal) ; std::string ExtractHint( const std::string& sNotes) ; - std::string ExtractSurf( const std::string& sNotes) ; bool CalculateAxesValues( const std::string& sHint) ; bool CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W, DBLVECTOR& vAxRotPrec, int& nOutStrC) ; diff --git a/Pocketing.cpp b/Pocketing.cpp index 10ef80d..3bccc7d 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -54,6 +54,9 @@ using namespace std ; // 2418 = "Error in Pocketing : Return toolpath not computable" // 2419 = "Error in Pocketing : Chaining failed" // 2420 = "Error in Pocketing : Tool MaxMaterial too small (xxx)" +// 2421 = "Error in Pocketing : axes values not calculable" +// 2422 = "Error in Pocketing : link movements not calculable" +// 2423 = "Error in Pocketing : post apply not calculable" //---------------------------------------------------------------------------- USEROBJ_REGISTER( "EMkPocketing", Pocketing) ; @@ -220,6 +223,9 @@ Pocketing::SetParam( int nType, bool bVal) case MPA_INVERT : m_Params.m_bInvert = bVal ; return true ; + case MPA_TOOLINVERT : + m_Params.m_bToolInvert = bVal ; + return true ; } return false ; } @@ -349,6 +355,12 @@ Pocketing::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; default : return false ; } @@ -516,18 +528,36 @@ Pocketing::Apply( bool bRecalc) return true ; } + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2421, "Error in Pocketing : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2422, "Error in Pocketing : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2423, "Error in Pocketing : post apply not calculable") ; return false ; + } return true ; } @@ -540,6 +570,9 @@ Pocketing::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; + case MPA_TOOLINVERT : + bVal = m_Params.m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -645,6 +678,12 @@ Pocketing::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; @@ -861,8 +900,6 @@ bool Pocketing::Chain( int nGrpDestId) { // vettore puntatori alle curve - typedef PtrOwner POWNCURVE ; - typedef std::vector POCRVVECTOR ; POCRVVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; // recupero tutte le curve e le porto in globale @@ -1013,6 +1050,14 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId) double dThick ; pCompo->GetThickness( dThick) ; + // eventuale inversione direzione utensile + if ( m_Params.m_bToolInvert) { + vtExtr.Invert() ; + pCompo->SetExtrusion( vtExtr) ; + dThick = - dThick ; + pCompo->SetThickness( dThick) ; + } + // verifico sia piana e sistemo senso antiorario visto dalla direzione di estrusione Plane3d plPlane ; double dArea ; if ( ! pCompo->GetArea( plPlane, dArea)) { @@ -1402,8 +1447,9 @@ bool Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { - // recupero distanza di sicurezza + // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; @@ -1463,7 +1509,7 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c dStElev = 0 ; } // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr)) return false ; // aggiungo attacco SetFeed( GetStartFeed()) ; @@ -1543,7 +1589,7 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c return false ; } // aggiungo retrazione - if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) + if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) return false ; } } @@ -1557,8 +1603,9 @@ bool Pocketing::AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) { - // recupero distanza di sicurezza + // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; + double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; // lunghezza di approccio/retrazione double dAppr = m_Params.m_dStartPos ; @@ -1622,7 +1669,7 @@ Pocketing::AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, dStElev = 0 ; } // approccio al punto iniziale - if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) + if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr)) return false ; // aggiungo attacco SetFeed( GetStartFeed()) ; @@ -1702,7 +1749,7 @@ Pocketing::AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, return false ; } // aggiungo retrazione - if ( ! AddRetract( ptQ, vtTool, dSafeZ, dEndElev, dAppr)) + if ( ! AddRetract( ptQ, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr)) return false ; } } @@ -1872,7 +1919,8 @@ Pocketing::CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double d //---------------------------------------------------------------------------- bool -Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) +Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr) { SetFlag( 1) ; // se con aggregato da sotto @@ -1883,14 +1931,14 @@ Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafe m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ; m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ; // aggiuntivo in Z - double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ; + double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ; // distanza dal bordo del pezzo double dDistBottom ; if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom)) dDistBottom = 0 ; // pre-approccio - Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ; - Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ; + Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dSafeZ) ; + Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ - dElev) ; Vector3d vtAux = m_vtAux ; vtAux.Rotate( Z_AX, 90) ; SetAuxDir( vtAux) ; @@ -1903,9 +1951,10 @@ Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafe return false ; } // se sopra attacco c'è spazio per sicurezza o approccio - if ( dElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { + double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; + if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { // se distanza di sicurezza minore di distanza di inizio - if ( dSafeZ < dAppr + 10 * EPS_SMALL) { + if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 1 -> punto sopra inizio Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1) == GDB_ID_NULL) || @@ -1915,7 +1964,7 @@ Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafe else { // 1a -> punto sopra inizio Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ; - Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - dAppr) ; + Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ; if ( ( ! m_bAggrBottom && AddRapidStart( ptP1a) == GDB_ID_NULL) || ( m_bAggrBottom && AddRapidMove( ptP1a) == GDB_ID_NULL)) return false ; @@ -1944,11 +1993,13 @@ Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafe //---------------------------------------------------------------------------- bool -Pocketing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) +Pocketing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr) { // se sopra uscita c'è spazio per sicurezza o approccio - if ( dElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) { - if ( dSafeZ < dAppr + 10 * EPS_SMALL) { + double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ; + if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) { + if ( dSafeDist < dAppr + 10 * EPS_SMALL) { // 4 -> movimento di risalita sopra il punto finale SetFeed( GetEndFeed()) ; Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ; @@ -1964,7 +2015,7 @@ Pocketing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ return false ; } // 4b -> movimento di risalita sopra il punto finale - Point3d ptP4b = ptP4a + vtTool * ( dSafeZ - dAppr) ; + Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ; if ( AddRapidMove( ptP4b) == GDB_ID_NULL) return false ; } @@ -1977,14 +2028,14 @@ Pocketing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ; m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ; // aggiuntivo in Z - double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ; + double dAggZ = max( dElev + max( dSafeAggrBottZ, dAppr), 0.) ; // distanza dal bordo del pezzo double dDistBottom ; if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom)) dDistBottom = 0 ; // post-retract - Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ; - Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ; + Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dSafeZ) ; + Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ - dElev) ; if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL) return false ; Vector3d vtAux = m_vtAux ; diff --git a/Pocketing.h b/Pocketing.h index afbc311..9c1e614 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -79,8 +79,10 @@ class Pocketing : public Machining ICurveComposite* pMCrv, ICurveComposite* pRCrv) ; bool CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double dOutRad, double dIntRad, bool bSplitArcs, ICurveComposite* pMCrv, ICurveComposite* pRCrv) ; - bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; - bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ; + bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr) ; + bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ, + double dElev, double dAppr) ; bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, const ICurveComposite* pRCrv, Point3d& ptP1) ; bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, diff --git a/PocketingData.cpp b/PocketingData.cpp index 8b95934..6518cfe 100644 --- a/PocketingData.cpp +++ b/PocketingData.cpp @@ -26,7 +26,9 @@ using namespace std ; //---------------------------------------------------------------------------- enum nPocketingKey { - KEY_DH = 0, + KEY_AB = 0, + KEY_AI, + KEY_DH, KEY_F, KEY_FE, KEY_FS, @@ -49,12 +51,15 @@ enum nPocketingKey { KEY_SS, KEY_ST, KEY_SUBTYPE, + KEY_TI, KEY_TNAME, KEY_TUUID, KEY_UUID, KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sPocketingKey = { + "AB", + "AI", "DH", "F", "FE", @@ -78,6 +83,7 @@ static const std::array sPocketingKey = { "SS", "ST", "SUB", + "TI", "TN", "TU", "UUID"} ; @@ -117,6 +123,8 @@ PocketingData::CopyFrom( const MachiningData* pMdata) m_sName = pSdata->m_sName ; m_ToolUuid = pSdata->m_ToolUuid ; m_sToolName = pSdata->m_sToolName ; + m_sBlockedAxis = pSdata->m_sBlockedAxis ; + m_sInitAngs = pSdata->m_sInitAngs ; m_nSolCh = pSdata->m_nSolCh ; m_dSpeed = pSdata->m_dSpeed ; m_dFeed = pSdata->m_dFeed ; @@ -125,6 +133,7 @@ PocketingData::CopyFrom( const MachiningData* pMdata) m_dTipFeed = pSdata->m_dTipFeed ; m_dOffsL = pSdata->m_dOffsL ; m_dOffsR = pSdata->m_dOffsR ; + m_bToolInvert = pSdata->m_bToolInvert ; m_bInvert = pSdata->m_bInvert ; m_sDepth = pSdata->m_sDepth ; m_dStartPos = pSdata->m_dStartPos ; @@ -158,6 +167,8 @@ PocketingData::SameAs(const MachiningData* pMdata) const m_sName == pSdata->m_sName && m_ToolUuid == pSdata->m_ToolUuid && m_sToolName == pSdata->m_sToolName && + m_sBlockedAxis == pSdata->m_sBlockedAxis && + m_sInitAngs == pSdata->m_sInitAngs && m_nSolCh == pSdata->m_nSolCh && abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR && @@ -166,6 +177,7 @@ PocketingData::SameAs(const MachiningData* pMdata) const abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR && abs( m_dOffsL - pSdata->m_dOffsL) < EPS_MACH_LEN_PAR && abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR && + m_bToolInvert == pSdata->m_bToolInvert && m_bInvert == pSdata->m_bInvert && m_sDepth == pSdata->m_sDepth && abs( m_dStartPos - pSdata->m_dStartPos) < EPS_MACH_LEN_PAR && @@ -218,6 +230,12 @@ PocketingData::FromString( const string& sString, int& nKey) nKey = FindPocketingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) @@ -290,6 +308,9 @@ PocketingData::FromString( const string& sString, int& nKey) case KEY_SUBTYPE : bOk = ::FromString( sVal, m_nSubType) ; break ; + case KEY_TI : + bOk = ::FromString( sVal, m_bToolInvert) ; + break ; case KEY_TNAME : m_sToolName = sVal ; break ; @@ -311,6 +332,8 @@ string PocketingData::ToString( int nInd) const { switch ( nInd) { + case KEY_AB : return ( sPocketingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sPocketingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_DH : return ( sPocketingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_F : return ( sPocketingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; case KEY_FE : return ( sPocketingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; @@ -334,6 +357,7 @@ PocketingData::ToString( int nInd) const case KEY_SS : return ( sPocketingKey[KEY_SS] + "=" + ::ToString( m_dSideStep)) ; case KEY_ST : return ( sPocketingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ; case KEY_SUBTYPE : return ( sPocketingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ; + case KEY_TI : return ( sPocketingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ; case KEY_TNAME : return ( sPocketingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sPocketingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sPocketingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; @@ -345,7 +369,7 @@ PocketingData::ToString( int nInd) const bool PocketingData::IsOptional( int nKey) const { - return ( nKey == KEY_LIEL) ; + return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_LIEL || nKey == KEY_TI) ; } //---------------------------------------------------------------------------- @@ -410,6 +434,9 @@ PocketingData::SetParam( int nType, bool bVal) case MPA_INVERT : m_bInvert = bVal ; return true ; + case MPA_TOOLINVERT : + m_bToolInvert = bVal ; + return true ; } return false ; } @@ -521,6 +548,12 @@ PocketingData::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -542,6 +575,9 @@ PocketingData::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_bInvert ; return true ; + case MPA_TOOLINVERT : + bVal = m_bToolInvert ; + return true ; } bVal = false ; return false ; @@ -650,6 +686,12 @@ PocketingData::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/PocketingData.h b/PocketingData.h index 3d2380e..62fd775 100644 --- a/PocketingData.h +++ b/PocketingData.h @@ -20,6 +20,8 @@ struct PocketingData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) @@ -28,6 +30,7 @@ struct PocketingData : public MachiningData double m_dTipFeed ; // velocità di lavorazione di testa ( se 0 da utensile) double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile) double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile) + bool m_bToolInvert ; // flag per inversione direzione utensile da geometria bool m_bInvert ; // flag di inversione direzione lavorazione std::string m_sDepth ; // affondamento (espressione numerica) double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0) @@ -45,7 +48,7 @@ struct PocketingData : public MachiningData PocketingData( void) : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0), - m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), m_bInvert( false), + m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), m_bToolInvert( false), m_bInvert( false), m_dStartPos( 0), m_dStep( 0), m_dSideStep( 0), m_nSubType( 0), m_dSideAngle( 0), m_nLeadInType( 0), m_dLiTang( 0), m_dLiElev( 0), m_nLeadOutType( 0), m_dLoTang( 0) {} diff --git a/SawFinishing.cpp b/SawFinishing.cpp index 0cabc14..cecde09 100644 --- a/SawFinishing.cpp +++ b/SawFinishing.cpp @@ -44,10 +44,9 @@ using namespace std ; // 2707 = "Error in SawFinishing : GetElevation" // 2708 = "Error in SawFinishing : CalculateAlongToolPath failed" // 2709 = "Error in SawFinishing : CalculateAcrossToolPath failed" - -//---------------------------------------------------------------------------- -typedef PtrOwner POWNCURVE ; -typedef std::vector POCRVVECTOR ; +// 2710 = "Error in SawFinishing : axes values not calculable" +// 2711 = "Error in SawFinishing : link movements not calculable" +// 2712 = "Error in SawFinishing : post apply not calculable" //---------------------------------------------------------------------------- const std::string MCH_SECTION = "Sect" ; @@ -359,6 +358,12 @@ SawFinishing::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; } return false ; } @@ -463,18 +468,36 @@ SawFinishing::Apply( bool bRecalc) if ( m_nCuts == 0) return true ; + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2710, "Error in SawFinishing : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2711, "Error in SawFinishing : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2712, "Error in SawFinishing : post apply not calculable") ; return false ; + } return true ; } @@ -595,6 +618,12 @@ SawFinishing::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/SawFinishingData.cpp b/SawFinishingData.cpp index 0fa7b34..898433b 100644 --- a/SawFinishingData.cpp +++ b/SawFinishingData.cpp @@ -26,7 +26,9 @@ using namespace std ; //---------------------------------------------------------------------------- enum nSawFinishingKey { - KEY_APPR = 0, + KEY_AB = 0, + KEY_AI, + KEY_APPR, KEY_DH, KEY_EAL, KEY_F, @@ -55,6 +57,8 @@ enum nSawFinishingKey { KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sSawFinishingKey = { + "AB", + "AI", "APPR", "DH", "EAL", @@ -117,6 +121,8 @@ SawFinishingData::CopyFrom( const MachiningData* pMdata) m_sName = pSdata->m_sName ; m_ToolUuid = pSdata->m_ToolUuid ; m_sToolName = pSdata->m_sToolName ; + m_sBlockedAxis = pSdata->m_sBlockedAxis ; + m_sInitAngs = pSdata->m_sInitAngs ; m_nSolCh = pSdata->m_nSolCh ; m_dSpeed = pSdata->m_dSpeed ; m_dFeed = pSdata->m_dFeed ; @@ -158,6 +164,8 @@ SawFinishingData::SameAs(const MachiningData* pMdata) const m_sName == pSdata->m_sName && m_ToolUuid == pSdata->m_ToolUuid && m_sToolName == pSdata->m_sToolName && + m_sBlockedAxis == pSdata->m_sBlockedAxis && + m_sInitAngs == pSdata->m_sInitAngs && m_nSolCh == pSdata->m_nSolCh && abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR && @@ -218,6 +226,12 @@ SawFinishingData::FromString( const string& sString, int& nKey) nKey = FindSawFinishingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_APPR : bOk = ::FromString( sVal, m_dApprox) ; break ; @@ -311,6 +325,8 @@ string SawFinishingData::ToString( int nInd) const { switch ( nInd) { + case KEY_AB : return ( sSawFinishingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sSawFinishingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_APPR : return ( sSawFinishingKey[KEY_APPR] + "=" + ::ToString( m_dApprox)) ; case KEY_DH : return ( sSawFinishingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_EAL : return ( sSawFinishingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; @@ -345,7 +361,8 @@ SawFinishingData::ToString( int nInd) const bool SawFinishingData::IsOptional( int nKey) const { - return ( nKey == KEY_FV || nKey == KEY_ST || nKey == KEY_SCC || nKey == KEY_SUBTYPE || + return ( nKey == KEY_AB || nKey == KEY_AI || + nKey == KEY_FV || nKey == KEY_ST || nKey == KEY_SCC || nKey == KEY_SUBTYPE || nKey == KEY_INV || nKey == KEY_EAL || nKey == KEY_SAL) ; } @@ -529,6 +546,12 @@ SawFinishingData::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -658,6 +681,12 @@ SawFinishingData::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/SawFinishingData.h b/SawFinishingData.h index 3da3dc5..20da677 100644 --- a/SawFinishingData.h +++ b/SawFinishingData.h @@ -20,6 +20,8 @@ struct SawFinishingData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) diff --git a/SawRoughing.cpp b/SawRoughing.cpp index a7ebea2..36f145f 100644 --- a/SawRoughing.cpp +++ b/SawRoughing.cpp @@ -44,10 +44,9 @@ using namespace std ; // 2607 = "Error in SawRoughing : CalculateToolAndCorrVersors" // 2608 = "Error in SawRoughing : GetElevation" // 2609 = "Error in SawRoughing : TrimSection failed" - -//---------------------------------------------------------------------------- -typedef PtrOwner POWNCURVE ; -typedef std::vector POCRVVECTOR ; +// 2610 = "Error in SawRoughing : axes values not calculable" +// 2611 = "Error in SawRoughing : link movements not calculable" +// 2612 = "Error in SawRoughing : post apply not calculable" //---------------------------------------------------------------------------- const std::string MCH_SECTION = "Sect" ; @@ -344,6 +343,12 @@ SawRoughing::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; } return false ; } @@ -439,18 +444,36 @@ SawRoughing::Apply( bool bRecalc) if ( m_nCuts == 0) return true ; + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2610, "Error in SawRoughing : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2611, "Error in SawRoughing : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2612, "Error in SawRoughing : post apply not calculable") ; return false ; + } return true ; } @@ -565,6 +588,12 @@ SawRoughing::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/SawRoughingData.cpp b/SawRoughingData.cpp index efae048..4816b6f 100644 --- a/SawRoughingData.cpp +++ b/SawRoughingData.cpp @@ -26,7 +26,9 @@ using namespace std ; //---------------------------------------------------------------------------- enum nSawRoughingKey { - KEY_APPR = 0, + KEY_AB = 0, + KEY_AI, + KEY_APPR, KEY_DH, KEY_EAL, KEY_F, @@ -53,6 +55,8 @@ enum nSawRoughingKey { KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sSawRoughingKey = { + "AB", + "AI", "APPR", "DH", "EAL", @@ -113,6 +117,8 @@ SawRoughingData::CopyFrom( const MachiningData* pMdata) m_sName = pSdata->m_sName ; m_ToolUuid = pSdata->m_ToolUuid ; m_sToolName = pSdata->m_sToolName ; + m_sBlockedAxis = pSdata->m_sBlockedAxis ; + m_sInitAngs = pSdata->m_sInitAngs ; m_nSolCh = pSdata->m_nSolCh ; m_dSpeed = pSdata->m_dSpeed ; m_dFeed = pSdata->m_dFeed ; @@ -152,6 +158,8 @@ SawRoughingData::SameAs(const MachiningData* pMdata) const m_sName == pSdata->m_sName && m_ToolUuid == pSdata->m_ToolUuid && m_sToolName == pSdata->m_sToolName && + m_sBlockedAxis == pSdata->m_sBlockedAxis && + m_sInitAngs == pSdata->m_sInitAngs && m_nSolCh == pSdata->m_nSolCh && abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR && @@ -210,6 +218,12 @@ SawRoughingData::FromString( const string& sString, int& nKey) nKey = FindSawRoughingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_APPR : bOk = ::FromString( sVal, m_dApprox) ; break ; @@ -297,6 +311,8 @@ string SawRoughingData::ToString( int nInd) const { switch ( nInd) { + case KEY_AB : return ( sSawRoughingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sSawRoughingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_APPR : return ( sSawRoughingKey[KEY_APPR] + "=" + ::ToString( m_dApprox)) ; case KEY_DH : return ( sSawRoughingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_EAL : return ( sSawRoughingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; @@ -329,7 +345,8 @@ SawRoughingData::ToString( int nInd) const bool SawRoughingData::IsOptional( int nKey) const { - return ( nKey == KEY_SCC || nKey == KEY_EAL || nKey == KEY_SAL) ; + return ( nKey == KEY_AB || nKey == KEY_AI || + nKey == KEY_SCC || nKey == KEY_EAL || nKey == KEY_SAL) ; } //---------------------------------------------------------------------------- @@ -497,6 +514,12 @@ SawRoughingData::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -620,6 +643,12 @@ SawRoughingData::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/SawRoughingData.h b/SawRoughingData.h index 584efa4..86f955f 100644 --- a/SawRoughingData.h +++ b/SawRoughingData.h @@ -20,6 +20,8 @@ struct SawRoughingData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) diff --git a/Sawing.cpp b/Sawing.cpp index cde8e16..5a9f8a2 100644 --- a/Sawing.cpp +++ b/Sawing.cpp @@ -48,6 +48,9 @@ using namespace std ; // 2212 = "Error in Sawing : Entity CalculateToolAndCorrVersors 2nd" // 2213 = "Error in Sawing : Center work not allowed with internal arc" // 2214 = "Error in Sawing : Chaining failed" +// 2215 = "Error in Sawing : axes values not calculable" +// 2216 = "Error in Sawing : link movements not calculable" +// 2217 = "Error in Sawing : post apply not calculable" //---------------------------------------------------------------------------- USEROBJ_REGISTER( "EMkSawing", Sawing) ; @@ -377,6 +380,12 @@ Sawing::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_Params.m_sUserNotes = sVal ; break ; + case MPA_INITANGS : + m_Params.m_sInitAngs = sVal ; + break ; + case MPA_BLOCKEDAXIS : + m_Params.m_sBlockedAxis = sVal ; + break ; } return false ; } @@ -549,18 +558,36 @@ Sawing::Apply( bool bRecalc) if ( m_nCuts == 0) return true ; + // imposto eventuale asse bloccato da lavorazione + if ( ! m_Params.m_sBlockedAxis.empty()) { + string sAxis, sVal ; + Split( m_Params.m_sBlockedAxis, "=", true, sAxis, sVal) ; + double dVal = 0 ; + FromString( sVal, dVal) ; + m_pMchMgr->ClearRotAxisBlock() ; + m_pMchMgr->SetRotAxisBlock( sAxis, dVal) ; + } + // calcolo gli assi macchina string sHint = ExtractHint( m_Params.m_sUserNotes) ; - if ( ! CalculateAxesValues( sHint)) + if ( ! m_Params.m_sInitAngs.empty()) + sHint = m_Params.m_sInitAngs ; + if ( ! CalculateAxesValues( sHint)) { + m_pMchMgr->SetLastError( 2215, "Error in Sawing : axes values not calculable") ; return false ; + } // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione - if ( ! AdjustStartEndMovements()) + if ( ! AdjustStartEndMovements()) { + m_pMchMgr->SetLastError( 2216, "Error in Sawing : link movements not calculable") ; return false ; + } // esecuzione eventuali personalizzazioni - if ( ! PostApply()) + if ( ! PostApply()) { + m_pMchMgr->SetLastError( 2217, "Error in Sawing : post apply not calculable") ; return false ; + } return true ; } @@ -699,6 +726,12 @@ Sawing::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_Params.m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_Params.m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_Params.m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; @@ -878,8 +911,6 @@ bool Sawing::Chain( int nGrpDestId) { // vettore puntatori alle curve - typedef PtrOwner POWNCURVE ; - typedef std::vector POCRVVECTOR ; POCRVVECTOR vpCrvs ; vpCrvs.reserve( m_vId.size()) ; // recupero tutte le curve e le porto in globale diff --git a/SawingData.cpp b/SawingData.cpp index bcdefb6..c87bf5f 100644 --- a/SawingData.cpp +++ b/SawingData.cpp @@ -26,7 +26,9 @@ using namespace std ; //---------------------------------------------------------------------------- enum nSawingKey { - KEY_APPR = 0, + KEY_AB = 0, + KEY_AI, + KEY_APPR, KEY_CRV, KEY_DH, KEY_EAL, @@ -61,6 +63,8 @@ enum nSawingKey { KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sSawingKey = { + "AB", + "AI", "APPR", "CRV", "DH", @@ -129,6 +133,8 @@ SawingData::CopyFrom( const MachiningData* pMdata) m_sName = pSdata->m_sName ; m_ToolUuid = pSdata->m_ToolUuid ; m_sToolName = pSdata->m_sToolName ; + m_sBlockedAxis = pSdata->m_sBlockedAxis ; + m_sInitAngs = pSdata->m_sInitAngs ; m_nSolCh = pSdata->m_nSolCh ; m_dSpeed = pSdata->m_dSpeed ; m_dFeed = pSdata->m_dFeed ; @@ -176,6 +182,8 @@ SawingData::SameAs(const MachiningData* pMdata) const m_sName == pSdata->m_sName && m_ToolUuid == pSdata->m_ToolUuid && m_sToolName == pSdata->m_sToolName && + m_sBlockedAxis == pSdata->m_sBlockedAxis && + m_sInitAngs == pSdata->m_sInitAngs && m_nSolCh == pSdata->m_nSolCh && abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR && @@ -242,6 +250,12 @@ SawingData::FromString( const string& sString, int& nKey) nKey = FindSawingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { + case KEY_AB : + m_sBlockedAxis = sVal ; + break ; + case KEY_AI : + m_sInitAngs = sVal ; + break ; case KEY_APPR : bOk = ::FromString( sVal, m_dApprox) ; break ; @@ -353,6 +367,8 @@ string SawingData::ToString( int nInd) const { switch ( nInd) { + case KEY_AB : return ( sSawingKey[KEY_AB] + "=" + m_sBlockedAxis) ; + case KEY_AI : return ( sSawingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_APPR : return ( sSawingKey[KEY_APPR] + "=" + ::ToString( m_dApprox)) ; case KEY_CRV : return ( sSawingKey[KEY_CRV] + "=" + ::ToString( m_nCurveUse)) ; case KEY_DH : return ( sSawingKey[KEY_DH] + "=" + m_sDepth) ; @@ -393,7 +409,8 @@ SawingData::ToString( int nInd) const bool SawingData::IsOptional( int nKey) const { - return ( nKey == KEY_F || nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || + return ( nKey == KEY_AB || nKey == KEY_AI || + nKey == KEY_F || nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || nKey == KEY_NNS || nKey == KEY_NNU || nKey == KEY_OL || nKey == KEY_OR || nKey == KEY_S || nKey == KEY_SCC || nKey == KEY_STEA || nKey == KEY_STIA || nKey == KEY_STSA) ; @@ -638,6 +655,12 @@ SawingData::SetParam( int nType, const string& sVal) case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; + case MPA_INITANGS : + m_sInitAngs = sVal ; + return true ; + case MPA_BLOCKEDAXIS : + m_sBlockedAxis = sVal ; + return true ; } return false ; } @@ -785,6 +808,12 @@ SawingData::GetParam( int nType, string& sVal) const case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; + case MPA_INITANGS : + sVal = m_sInitAngs ; + return true ; + case MPA_BLOCKEDAXIS : + sVal = m_sBlockedAxis ; + return true ; } sVal = "" ; return false ; diff --git a/SawingData.h b/SawingData.h index 95ca1dd..23c749b 100644 --- a/SawingData.h +++ b/SawingData.h @@ -20,6 +20,8 @@ struct SawingData : public MachiningData { EgtUUID m_ToolUuid ; // identificativo universale dell'utensile std::string m_sToolName ; // nome dell'utensile + std::string m_sInitAngs ; // angoli iniziali suggeriti (Nome1=val1,Nome2=val2) + std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) diff --git a/Simulator.cpp b/Simulator.cpp index ba22f1c..c9951bc 100644 --- a/Simulator.cpp +++ b/Simulator.cpp @@ -26,6 +26,9 @@ using namespace std ; +//------------------------------ Errors -------------------------------------- +// 1001 = "Error with setup : xxx" + //---------------------------------------------------------------------------- Simulator::Simulator( void) { @@ -76,11 +79,17 @@ bool Simulator::Start( bool bFirst) { // Verifico ci sia una macchinata corrente - if ( m_pMchMgr == nullptr || m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL) + if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr || m_pMachine == nullptr || + m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL) return false ; + m_pMchMgr->ResetLastError() ; - // forzo aggiornamento attrezzaggio della macchinata - m_pMchMgr->UpdateSetup() ; + // Forzo aggiornamento attrezzaggio della macchinata + bool bOk = m_pMchMgr->UpdateSetup() ; + + // Se avvio vero, verifico attrezzaggio + if ( bFirst && ! VerifySetup()) + bOk = false ; // Reset utensile e assi correnti m_sTool.clear() ; @@ -88,20 +97,45 @@ Simulator::Start( bool bFirst) ResetAuxAxes() ; // porto la macchina in home if ( ! GoHome()) - return false ; + bOk = false ; // Verifico la disposizione iniziale della macchinata m_nOpId = m_pMchMgr->GetFirstActiveOperation() ; m_nOpInd = 1 ; if ( m_pMchMgr->GetOperationType( m_nOpId) != OPER_DISP) - return false ; + bOk = false ; // Definisco tabella variabili globali - bool bOk = m_pMachine->LuaCreateGlobTable( GLOB_VAR) ; + if ( ! m_pMachine->LuaCreateGlobTable( GLOB_VAR)) + bOk = false ; // Arrivo alla preparazione per la prima lavorazione int nStatus ; - return FindAndManageOperationStart( true, bFirst, nStatus) ; + if ( ! FindAndManageOperationStart( true, bFirst, nStatus)) + bOk = false ; + + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +Simulator::VerifySetup( void) +{ + // se attrezzaggio non definito, nulla da verificare + if ( ! m_pMchMgr->GetCurrSetupMgr().Exists()) + return true ; + + // lancio la verifica + STRVECTOR vsErr ; + if ( m_pMchMgr->VerifyCurrSetup( vsErr)) + return true ; + + // gestisco errore + string sErr = "Error with setup :" ; + for each( const auto& sTmp in vsErr) + sErr += " " + sTmp ; + m_pMchMgr->SetLastError( 1001, sErr) ; + return false ; } //---------------------------------------------------------------------------- diff --git a/Simulator.h b/Simulator.h index cf570f7..9f928c3 100644 --- a/Simulator.h +++ b/Simulator.h @@ -44,6 +44,7 @@ class Simulator bool ResetAuxAxes( void) ; private : + bool VerifySetup( void) ; bool FindAndManageOperationStart( bool bStart, bool bFirst, int& nStatus) ; bool ManageOperationEnd( int& nStatus) ; bool FindAndManagePathStart( int& nStatus) ;