Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtMachKernel 1.8e5 :

Browse Source 
- gestione da parametri lavorazione di angoli iniziali suggeriti e asse rotante bloccato
- in fresatura, svuotatura, incisione e lav. generica aggiunta possibilità di invertire direzione utensile
- in fresatura aggiunto parametro per tipo lavorazione faccia (perpendicolare, parallela, ...)
- differenziata distanza sicurezza standard da distanza sicurezza per rinvio da sotto
- migliorati approcci e retrazioni con rinvio da sotto
- migliorata segnalazione errori.
This commit is contained in:
Dario Sassi
2017-05-31 14:18:11 +00:00
parent c9ab1c76ed
commit 6c7a60b60a
48 changed files with 1214 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Chiseling.cpp
+50 -5
View File
@@ -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<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> 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) {
ChiselingData.cpp
+45 -3
View File
@@ -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<std::string,KEY_ZZZ> sChiselingKey = {
"AB",
"AI",
"DH",
"EAL",
"F",
@@ -63,6 +68,7 @@ static const std::array<std::string,KEY_ZZZ> 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 ;
ChiselingData.h
+5 -1
View File
@@ -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 ;
Disposition.cpp
+15 -7
View File
@@ -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 ;
Drilling.cpp
+46 -9
View File
@@ -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 ;
DrillingData.cpp
+32 -3
View File
@@ -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<std::string,KEY_ZZZ> 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 ;
DrillingData.h
+2
View File
@@ -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)
EgtMachKernel.rc
BIN
View File
Binary file not shown.
GenMachining.cpp
+44 -5
View File
@@ -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<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> POCRVVECTOR ;
POCRVVECTOR vpCrvs ;
vpCrvs.reserve( m_vId.size()) ;
// recupero tutte le curve e le porto in globale
GenMachiningData.cpp
+45 -3
View File
@@ -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<std::string,KEY_ZZZ> sGenMachiningKey = {
"AB",
"AI",
"DH",
"F",
"FE",
@@ -62,6 +67,7 @@ static const std::array<std::string,KEY_ZZZ> 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 ;
GenMachiningData.h
+4 -1
View File
@@ -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 ;
Generator.cpp
+30 -2
View File
@@ -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
Generator.h
+1
View File
@@ -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) ;
Head.cpp
+3 -3
View File
@@ -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 ;
}
Head.h
+13 -9
View File
@@ -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 ;
} ;
MachMgr.h
+4
View File
@@ -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) ;
MachMgrDBMachinings.cpp
+5
View File
@@ -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 ;
}
MachMgrMachGroups.cpp
+4
View File
@@ -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 ;
MachMgrOperations.cpp
+4
View File
@@ -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)
MachMgrSetup.cpp
+8 -1
View File
@@ -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() ;
}
Machine.cpp
+9 -9
View File
@@ -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))
Machine.h
+6 -4
View File
@@ -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 ;
MachineCalc.cpp
+26
View File
@@ -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
MachineHeads.cpp
+36 -2
View File
@@ -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)
MachineLua.cpp
+13 -3
View File
@@ -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
MachiningsMgr.cpp
+28
View File
@@ -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)
MachiningsMgr.h
+4
View File
@@ -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 ;
Milling.cpp
+246 -64
View File
@@ -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<ICurveComposite> 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<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> 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 ;
}
Milling.h
+5 -2
View File
@@ -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
MillingData.cpp
+74 -5
View File
@@ -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<std::string,KEY_ZZZ> sMillingKey = {
"AB",
"AI",
"DH",
"EAL",
"F",
"FE",
"FS",
"FT",
"FU",
"INV",
"LICL",
"LIEL",
@@ -102,6 +109,7 @@ static const std::array<std::string,KEY_ZZZ> 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 ;
MillingData.h
+7 -1
View File
@@ -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 ;
Operation.cpp
+23 -29
View File
@@ -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
Operation.h
-1
View File
@@ -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) ;
Pocketing.cpp
+76 -25
View File
@@ -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<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> 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 ;
Pocketing.h
+4 -2
View File
@@ -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,
PocketingData.cpp
+44 -2
View File
@@ -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<std::string,KEY_ZZZ> sPocketingKey = {
"AB",
"AI",
"DH",
"F",
"FE",
@@ -78,6 +83,7 @@ static const std::array<std::string,KEY_ZZZ> 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 ;
PocketingData.h
+4 -1
View File
@@ -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) {}
SawFinishing.cpp
+36 -7
View File
@@ -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<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> 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 ;
SawFinishingData.cpp
+31 -2
View File
@@ -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<std::string,KEY_ZZZ> 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 ;
SawFinishingData.h
+2
View File
@@ -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)
SawRoughing.cpp
+36 -7
View File
@@ -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<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> 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 ;
SawRoughingData.cpp
+31 -2
View File
@@ -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<std::string,KEY_ZZZ> 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 ;
SawRoughingData.h
+2
View File
@@ -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)
Sawing.cpp
+36 -5
View File
@@ -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<ICurve> POWNCURVE ;
typedef std::vector<POWNCURVE> POCRVVECTOR ;
POCRVVECTOR vpCrvs ;
vpCrvs.reserve( m_vId.size()) ;
// recupero tutte le curve e le porto in globale
SawingData.cpp
+31 -2
View File
@@ -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<std::string,KEY_ZZZ> 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 ;
SawingData.h
+2
View File
@@ -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)
Simulator.cpp
+41 -7
View File
@@ -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 ;
}
//----------------------------------------------------------------------------
Simulator.h
+1
View File
@@ -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) ;