EgtMachKernel 1.6r8 :

- aggiunta gestione SCC (Solution Choice Criterion) nelle lavorazioni
- possibilità di calcolo Tip con dimensioni massime anzichè quelle di lavoro
- migliorato controllo pezzi prima di inserimento nei grezzi
- migliorato caricamento tavola al cambio di gruppo di lavoro
- aggiunta prima versione di risalita tra i percorsi di lavorazione in base a controllo collisioni (ora solo box)
- in simulazione imposto variabile nome tavola prima di OnDispositionStart.
This commit is contained in:
Dario Sassi
2016-06-02 07:03:24 +00:00
parent 3cd21182d3
commit fe0cbd0191
37 changed files with 593 additions and 110 deletions
+89 -9
View File
@@ -121,6 +121,8 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
m_nCalcSolCh = MCH_SCC_NONE ;
m_dCalcTLen = 0 ;
m_dCalcTRad = 0 ;
m_dCalcTOvLen = 0 ;
m_dCalcTOvRad = 0 ;
// recupero il gruppo della testa
int nHeadId = GetGroup( sHead) ;
// recupero i dati della testa
@@ -144,6 +146,8 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
int nToolId = GDB_ID_NULL ;
double dTLen = 0 ;
double dTDiam = 0 ;
double dTOvLen = 0 ;
double dTOvDiam = 0 ;
// se definito
if ( ! sTool.empty()) {
if ( ! LoadTool( sHead, nExit, sTool))
@@ -153,7 +157,9 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
return false ;
if ( ! m_pMchMgr->TdbSetCurrTool( sTool) ||
! m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, dTLen) ||
! m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, dTDiam))
! m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, dTDiam) ||
! m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, dTOvLen) ||
! m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, dTOvDiam))
return false ;
}
// altrimenti casi speciali senza utensile
@@ -164,6 +170,8 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
nToolId = GDB_ID_NULL ;
dTLen = 0 ;
dTDiam = 0 ;
dTOvLen = 0 ;
dTOvDiam = 0 ;
m_pMchMgr->TdbSetCurrTool( sTool) ;
}
// assegno tutti i dati
@@ -177,6 +185,8 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
m_vtCalcADir = pHead->GetADir() ;
m_dCalcTLen = dTLen ;
m_dCalcTRad = dTDiam / 2 ;
m_dCalcTOvLen = dTOvLen ;
m_dCalcTOvRad = dTOvDiam / 2 ;
// lancio eventuale funzione lua di personalizzazione
if ( LuaExistsFunction( ON_SET_HEAD)) {
bool bOk = LuaCreateGlobTable( EMC_VAR) ;
@@ -448,6 +458,47 @@ Machine::IsKinematicRotAxisBlocked( int nInd)
return m_vCalcRotAx[nInd].bFixed ;
}
//----------------------------------------------------------------------------
bool
Machine::SetSolCh( int nScc)
{
// se standard o suo opposto
if ( nScc == MCH_SCC_STD || nScc == MCH_SCC_OPPOSITE) {
// recupero i dati della testa
Head* pHead = GetHead( m_nCalcHeadId) ;
if ( pHead == nullptr) {
LOG_INFO( GetEMkLogger(), "Missing head in SetSolCh")
return false ;
}
// assegno il criterio definito nella testa (standard)
m_nCalcSolCh = pHead->GetSolCh() ;
if ( nScc == MCH_SCC_STD)
return true ;
// essendo opposto, devo invertirlo
switch ( m_nCalcSolCh) {
case MCH_SCC_NONE : break ;
case MCH_SCC_ADIR_XP : m_nCalcSolCh = MCH_SCC_ADIR_XM ; break ;
case MCH_SCC_ADIR_XM : m_nCalcSolCh = MCH_SCC_ADIR_XP ; break ;
case MCH_SCC_ADIR_YP : m_nCalcSolCh = MCH_SCC_ADIR_YM ; break ;
case MCH_SCC_ADIR_YM : m_nCalcSolCh = MCH_SCC_ADIR_YP ; break ;
case MCH_SCC_ADIR_ZP : m_nCalcSolCh = MCH_SCC_ADIR_ZM ; break ;
case MCH_SCC_ADIR_ZM : m_nCalcSolCh = MCH_SCC_ADIR_ZP ; break ;
case MCH_SCC_ADIR_NEAR : m_nCalcSolCh = MCH_SCC_ADIR_FAR ; break ;
case MCH_SCC_ADIR_FAR : m_nCalcSolCh = MCH_SCC_ADIR_NEAR ; break ;
default : m_nCalcSolCh = MCH_SCC_NONE ; break ;
}
return true ;
}
// altri casi
if ( IsValidHeadScc( nScc)) {
m_nCalcSolCh = nScc ;
return true ;
}
// non previsto
m_nCalcSolCh = MCH_SCC_NONE ;
return false ;
}
//----------------------------------------------------------------------------
bool
Machine::GetAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
@@ -881,7 +932,7 @@ Machine::GetDirection( const Vector3d& vtDir, double dAngA, double dAngB, Vector
//----------------------------------------------------------------------------
bool
Machine::GetTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
bool bBottom, Point3d& ptTip) const
bool bOverall, bool bBottom, Point3d& ptTip) const
{
// la posizione deve essere espressa rispetto allo ZERO MACCHINA
// per ora gestisco solo gli assi rotanti di testa
@@ -893,18 +944,24 @@ Machine::GetTipFromPositions( double dX, double dY, double dZ, double dAngA, dou
return false ;
ptTip.Set( dX - dRecX, dY - dRecY, dZ - dRecZ) ;
// Se richiesto punto sotto del tip utensile
if ( bBottom) {
// Se richiesto ingombro totale o punto sotto del tip utensile
if ( bOverall || bBottom) {
// calcolo la direzione fresa
Vector3d vtDirT ;
if ( ! GetDirection( m_vtCalcDir, dAngA, dAngB, vtDirT))
return false ;
// se direzione fresa non esattamente verticale, esiste un punto più basso del'utensile
if ( ! vtDirT.IsZplus() && ! vtDirT.IsZminus()) {
// se richiesto ingombro totale
if ( bOverall)
ptTip -= vtDirT * max( m_dCalcTOvLen - m_dCalcTLen, 0.) ;
// se richiesto punto più basso e direzione fresa non esattamente verticale
if ( bBottom && ! vtDirT.IsZplus() && ! vtDirT.IsZminus()) {
// calcolo la direzione perpendicolare più verticale possibile
Vector3d vtCorr = FromUprightOrtho( vtDirT) ;
// correggo il tip
ptTip -= vtCorr * m_dCalcTRad ;
if ( bOverall)
ptTip -= vtCorr * max( m_dCalcTOvRad, m_dCalcTRad) ;
else
ptTip -= vtCorr * m_dCalcTRad ;
}
}
@@ -938,9 +995,9 @@ Machine::VerifyScc( const Vector3d& vtDirI, const Vector3d& vtDirA, int nSolCh)
case MCH_SCC_ADIR_ZM :
return ( vtDirI.z < EPS_ZERO) ;
case MCH_SCC_ADIR_NEAR :
return ( ( vtDirI * vtDirA) > cos( 60 * DEGTORAD)) ;
return ( vtDirA.IsSmall() || ( vtDirI * vtDirA) > cos( 60 * DEGTORAD)) ;
case MCH_SCC_ADIR_FAR :
return ( ( vtDirI * vtDirA) < cos( 120 * DEGTORAD)) ;
return ( vtDirA.IsSmall() || ( vtDirI * vtDirA) < cos( 120 * DEGTORAD)) ;
}
}
@@ -1052,6 +1109,29 @@ Machine::GetAllCurrAxesName( STRVECTOR& vAxName) const
return bOk ;
}
//----------------------------------------------------------------------------
bool
Machine::GetCurrAxisHomePos( int nInd, double& dHome) const
{
int nLinAxes = int( m_vCalcLinAx.size()) ;
int nRotAxes = int( m_vCalcRotAx.size()) ;
if ( nInd >= 0 && nInd < nLinAxes) {
Axis* pAx = GetAxis( m_vCalcLinAx[nInd].nGrpId) ;
if ( pAx == nullptr)
return false ;
dHome = pAx->GetHomeVal() ;
return true ;
}
else if ( nInd >= nLinAxes && nInd < nLinAxes + nRotAxes) {
Axis* pAx = GetAxis( m_vCalcRotAx[nInd-nLinAxes].nGrpId) ;
if ( pAx == nullptr)
return false ;
dHome = pAx->GetHomeVal() ;
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
Machine::GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const