//---------------------------------------------------------------------------- // EgalTech 2015-2015 //---------------------------------------------------------------------------- // File : MachMgrMachines.cpp Data : 02.05.15 Versione : 1.6e1 // Contenuto : Implementazione gestione macchine della classe MachMgr. // // // // Modifiche : 02.05.15 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "MachMgr.h" #include "MachConst.h" #include "ToolsMgr.h" #include "MachiningsMgr.h" #include "SawingData.h" #include "/EgtDev/Include/EGkGdbIterator.h" #include "/EgtDev/Include/EgnStringUtils.h" #include "/EgtDev/Include/EgnFileUtils.h" #include "/EgtDev/Include/EgtPointerOwner.h" using namespace std ; //---------------------------------------------------------------------------- bool MachMgr::LoadMachine( const string& sMachineName) { // verifico validitā del nome if ( ! IsValidFileName( sMachineName)) return false ; // se macchina giā caricata, non devo fare alcunchč if ( GetMachine( sMachineName) != - 1) return true ; // verifico esista il file mlde ( o mde) della macchina string sMachineMlde = m_sMachinesDir + "\\" + sMachineName + "\\" + sMachineName + ".Mlde" ; if ( ! ExistsFile( sMachineMlde)) sMachineMlde = ChangeFileExtension( sMachineMlde, ".Mde") ; if ( ! ExistsFile( sMachineMlde)) return false ; // salvo nel vettore m_vMachines.emplace_back( sMachineName, nullptr, nullptr, nullptr) ; return true ; } //---------------------------------------------------------------------------- int MachMgr::GetMachine( const string& sMachineName) const { // ciclo sulle macchine for ( size_t i = 0 ; i < m_vMachines.size() ; ++ i) { if ( EqualNoCase( m_vMachines[i].sName, sMachineName)) return int( i) ; } return - 1 ; } //---------------------------------------------------------------------------- bool MachMgr::SetCurrMachine( const string& sMachineName) { // se č giā la macchina corrente, tutto bene if ( m_nCurrMch >= 0 && m_nCurrMch < int( m_vMachines.size()) && EqualNoCase( m_vMachines[m_nCurrMch].sName, sMachineName)) return true ; // se c'č macchinata corrente, non posso cambiare la macchina if ( m_nCurrMGrpId != GDB_ID_NULL) return false ; // verifica ed eventuale caricamento della macchina if ( ! LoadMachine( sMachineName)) return false ; // imposto i dati della macchina corrente m_nCurrMch = GetMachine( sMachineName) ; return true ; } //---------------------------------------------------------------------------- bool MachMgr::GetCurrMachineName( string& sMachineName) const { // verifico validitā indice macchina corrente if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size())) return false ; // assegno il nome sMachineName = m_vMachines[m_nCurrMch].sName ; return true ; } //---------------------------------------------------------------------------- bool MachMgr::GetCurrMachineDir( string& sMachineDir) const { // recupero la macchina Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; // assegno il relativo direttorio sMachineDir = pMch->GetMachineDir() ; return true ; } //---------------------------------------------------------------------------- bool MachMgr::IsCurrMachineLoaded( void) const { // verifico validitā indice macchina corrente if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size())) return false ; // verifico esistenza gestore macchina return ( m_vMachines[m_nCurrMch].pMachine != nullptr) ; } //---------------------------------------------------------------------------- Machine* MachMgr::GetCurrMachine( void) const { // verifico validitā indice macchina corrente if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size())) return nullptr ; // se gestore macchina non esiste, provo a crearlo e caricarlo if ( m_vMachines[m_nCurrMch].pMachine == nullptr) { // creo gruppo ausiliario di base per le macchine if ( ! const_cast(this)->CreateMachAux()) return nullptr ; // creo e carico la macchina PtrOwner pMch( new( nothrow) Machine) ; if ( IsNull( pMch) || ! pMch->Init( m_sMachinesDir, m_vMachines[m_nCurrMch].sName, const_cast(this))) return nullptr ; // nascondo la macchina if ( m_pGeomDB != nullptr) m_pGeomDB->SetStatus( pMch->GetMachineId(), GDB_ST_OFF) ; // salvo nel vettore const_cast( m_vMachines[m_nCurrMch]).pMachine = Release( pMch) ; } // restituisco il gestore macchina return m_vMachines[m_nCurrMch].pMachine ; } //---------------------------------------------------------------------------- ToolsMgr* MachMgr::GetCurrToolsMgr( void) const { // verifico validitā indice macchina corrente if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size())) return nullptr ; // se DB utensili non esiste, provo a crearlo e caricarlo if ( m_vMachines[m_nCurrMch].pTsMgr == nullptr) { PtrOwner pTsMgr( new( nothrow) ToolsMgr) ; string sToolsFile = m_sMachinesDir + "\\" + m_vMachines[m_nCurrMch].sName + "\\" + TOOLS_DIR + "\\" + TOOLS_FILE ; if ( IsNull( pTsMgr) || ! pTsMgr->Load( sToolsFile)) return nullptr ; // salvo nel vettore const_cast( m_vMachines[m_nCurrMch]).pTsMgr = Release( pTsMgr) ; } // restituisco il gestore DB utensili return m_vMachines[m_nCurrMch].pTsMgr ; } //---------------------------------------------------------------------------- MachiningsMgr* MachMgr::GetCurrMachiningsMgr( void) const { // verifico validitā indice macchina corrente if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size())) return nullptr ; // se DB lavorazioni non esiste, provo a crearlo e caricarlo if ( m_vMachines[m_nCurrMch].pMsMgr == nullptr) { PtrOwner pMsMgr( new( nothrow) MachiningsMgr) ; string sMachsFile = m_sMachinesDir + "\\" + m_vMachines[m_nCurrMch].sName + "\\" + MACHININGS_DIR + "\\" + MACHININGS_FILE ; if ( IsNull( pMsMgr) || ! pMsMgr->Load( sMachsFile, GetCurrToolsMgr())) return nullptr ; // salvo nel vettore const_cast( m_vMachines[m_nCurrMch]).pMsMgr = Release( pMsMgr) ; } // restituisco il gestore DB lavorazioni return m_vMachines[m_nCurrMch].pMsMgr ; } //---------------------------------------------------------------------------- int MachMgr::GetCurrMachineId( void) const { Machine* pMch = GetCurrMachine() ; // restituisco identificativo della radice della geometria della macchina corrente return ( ( pMch != nullptr) ? pMch->GetMachineId() : GDB_ID_NULL) ; } //---------------------------------------------------------------------------- int MachMgr::GetBaseId( const string& sBase) const { Machine* pMch = GetCurrMachine() ; // restituisco identificativo della base indicata nella macchina corrente return ( ( pMch != nullptr) ? pMch->GetBaseId( sBase) : GDB_ID_NULL) ; } //---------------------------------------------------------------------------- int MachMgr::GetTableId( const string& sTable) const { Machine* pMch = GetCurrMachine() ; // restituisco identificativo della tavola indicata nella macchina corrente return ( ( pMch != nullptr) ? pMch->GetTableId( sTable) : GDB_ID_NULL) ; } //---------------------------------------------------------------------------- int MachMgr::GetAxisId( const string& sAxis) const { Machine* pMch = GetCurrMachine() ; // restituisco identificativo dell'asse indicato nella macchina corrente return ( ( pMch != nullptr) ? pMch->GetAxisId( sAxis) : GDB_ID_NULL) ; } //---------------------------------------------------------------------------- int MachMgr::GetHeadId( const string& sHead) const { Machine* pMch = GetCurrMachine() ; // restituisco identificativo della testa indicata nella macchina corrente return ( ( pMch != nullptr) ? pMch->GetHeadId( sHead) : GDB_ID_NULL) ; } //---------------------------------------------------------------------------- int MachMgr::GetHeadExitCount( const string& sHead) const { Machine* pMch = GetCurrMachine() ; // recupero il numero di uscite della testa return ( ( pMch != nullptr) ? pMch->GetHeadExitCount( sHead) : 0) ; } //---------------------------------------------------------------------------- bool MachMgr::GetHeadAbove( const string& sHead) const { if ( m_pGeomDB == nullptr) return false ; bool bAbove = true ; return ( ! m_pGeomDB->GetInfo( GetHeadId( sHead), "ABOVE", bAbove) || bAbove) ; } //---------------------------------------------------------------------------- double MachMgr::GetAngDeltaMinForHome( void) const { Machine* pMch = GetCurrMachine() ; // recupero la minima differenza angolare da posizione precedente per stare vivino a posizione home return ( ( pMch != nullptr) ? pMch->GetAngDeltaMinForHome() : INFINITO) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAxisToken( const string& sAxis, string& sToken) const { Machine* pMch = GetCurrMachine() ; // restituisco token dell'asse indicato nella macchina corrente return ( ( pMch != nullptr) ? pMch->GetAxisToken( sAxis, sToken) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAxisType( const string& sAxis, bool& bLinear) const { Machine* pMch = GetCurrMachine() ; // restituisco il tipo dell'asse indicato nella macchina corrente return ( ( pMch != nullptr) ? pMch->GetAxisType( sAxis, bLinear) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::SetAxisPos( const string& sAxis, double dVal) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->SetAxisPos( sAxis, dVal) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAxisPos( const string& sAxis, double& dVal) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetAxisPos( sAxis, dVal) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAxisHomePos( const string& sAxis, double& dHomeVal) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetAxisHomePos( sAxis, dHomeVal) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::ResetAxisPos( const string& sAxis) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->ResetAxisPos( sAxis) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::ResetAllAxesPos( void) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->ResetAllAxesPos() : false) ; } //---------------------------------------------------------------------------- bool MachMgr::LoadTool( const string& sHead, int nExit, const string& sTool) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->LoadTool( sHead, nExit, sTool) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetLoadedTool( const string& sHead, int nExit, string& sTool) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetLoadedTool( sHead, nExit, sTool) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::UnloadTool( const string& sHead, int nExit) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->UnloadTool( sHead, nExit) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::ResetHeadSet( const string& sHead) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->ResetHeadSet( sHead) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::SetCalcTable( const string& sTable) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->SetCurrTable( sTable) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::SetCalcTool( const string& sTool, const string& sHead, int nExit) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->SetCurrTool( sTool, sHead, nExit) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::SetRotAxisBlock( const string& sAxis, double dVal) { Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; int nAxId = pMch->GetAxisId( sAxis) ; if ( nAxId == GDB_ID_NULL) return false ; m_vAxisBlock.emplace_back( sAxis, dVal) ; return true ; } //---------------------------------------------------------------------------- bool MachMgr::GetRotAxisBlocked( int nInd, string& sAxis, double& dVal) const { // se bloccaggi non ancora impostati if ( ! m_vAxisBlock.empty()) { if ( nInd < 0 || nInd >= int( m_vAxisBlock.size())) return false ; sAxis = m_vAxisBlock[nInd].sAxis ; dVal = m_vAxisBlock[nInd].dVal ; return true ; } // altrimenti cerco negli assi rotanti correnti const Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; int nMyInd = 0 ; for ( int i = 0 ; i < pMch->GetCurrRotAxes() ; ++ i) { if ( pMch->GetKinematicRotAxisBlocked( i, sAxis, dVal)) { if ( nMyInd == nInd) return true ; else ++ nMyInd ; } } return false ; } //---------------------------------------------------------------------------- bool MachMgr::ApplyRotAxisBlock( void) { Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; // applico blocchi bool bOk = true ; for ( auto& abVal : m_vAxisBlock) { if ( ! pMch->BlockKinematicRotAxis( abVal.sAxis, abVal.dVal)) bOk = false ; } // pulisco m_vAxisBlock.clear() ; return bOk ; } //---------------------------------------------------------------------------- bool MachMgr::IsKinematicRotAxisBlocked( int nInd) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->IsKinematicRotAxisBlocked( nInd) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::SetCalcSolCh( int nScc, bool bExact) { Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; // imposto il criterio di scelta della soluzione return pMch->SetSolCh( nScc, bExact) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcTool( string& sTool) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetCurrTool( sTool) : false) ; } //---------------------------------------------------------------------------- double MachMgr::GetCalcRot1W( void) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetCurrRot1W() : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAllHeadsNames( STRVECTOR& vNames) const { // pulisco il vettore vNames.clear() ; // recupero la macchina corrente Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; // richiedo elenco teste alla macchina return pMch->GetAllHeadsNames( vNames) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAllTablesNames( STRVECTOR& vNames) const { // pulisco il vettore vNames.clear() ; // recupero la macchina corrente Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; // richiedo elenco tavole alla macchina return pMch->GetAllTablesNames( vNames) ; } //---------------------------------------------------------------------------- int MachMgr::GetCurrLinAxes( void) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetCurrLinAxes() : false) ; } //---------------------------------------------------------------------------- int MachMgr::GetCurrRotAxes( void) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetCurrRotAxes() : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAllCurrAxesName( STRVECTOR& vAxName) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetAllCurrAxesName( vAxName) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetAllCurrAxesHomePos( vAxHomeVal) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCurrAxisHomePos( int nInd, double& dHome) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetCurrAxisHomePos( nInd, dHome) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA, int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetAngles( vtDirT, vtDirA, nStat, dAngA1, dAngB1, dAngA2, dAngB2) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA, int& nStat, DBLVECTOR& vAng1, DBLVECTOR& vAng2) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetAngles( vtDirT, vtDirA, nStat, vAng1, vAng2) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB, int& nStat, double& dX, double& dY, double& dZ) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcPositions( const Point3d& ptP, DBLVECTOR& vAng, int& nStat, double& dX, double& dY, double& dZ) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, vAng, nStat, dX, dY, dZ) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB, bool bOverall, bool bBottom, Point3d& ptTip) const { DBLVECTOR vAng( 2) ; vAng[0] = dAngA ; vAng[1] = dAngB ; Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bOverall, bool bBottom, Point3d& ptTip) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcToolDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) const { Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; return pMch->GetToolDirFromAngles( vAng, vtDir) ; } //---------------------------------------------------------------------------- bool MachMgr::GetCalcAuxDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) const { Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return false ; return pMch->GetAuxDirFromAngles( vAng, vtDir) ; } //---------------------------------------------------------------------------- bool MachMgr::GetNearestAngleInStroke( int nInd, double dAngRef, double& dAng) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->GetNearestAngleInStroke( nInd, dAngRef, dAng) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::LimitAngleToStroke( int nInd, double& dAng) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->LimitAngleToStroke( nInd, dAng) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::VerifyAngleOutstroke( int nInd, double dAng) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->VerifyAngleOutstroke( nInd, dAng) : false) ; } //---------------------------------------------------------------------------- bool MachMgr::VerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) const { DBLVECTOR vAng(2) ; vAng[0] = dAngA ; vAng[1] = dAngB ; return VerifyOutstroke( dX, dY, dZ, vAng, true, nStat) ; } //---------------------------------------------------------------------------- bool MachMgr::VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bClear, int& nStat) const { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->VerifyOutstroke( dX, dY, dZ, vAng, bClear, nStat) : false) ; } //---------------------------------------------------------------------------- std::string MachMgr::GetOutstrokeInfo( bool bMM) const { Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return "" ; return pMch->GetOutstrokeInfo( bMM) ; } //---------------------------------------------------------------------------- bool MachMgr::SetMachineLook( int nFlag) { Machine* pMch = GetCurrMachine() ; return ( ( pMch != nullptr) ? pMch->SetLook( nFlag) : false) ; } //---------------------------------------------------------------------------- int MachMgr::GetMachineLook( void) const { Machine* pMch = GetCurrMachine() ; if ( pMch == nullptr) return MCH_LOOK_NONE ; return pMch->GetLook() ; }