DarioS
cdbc4bfb63
- aggiunta gestione quota di base del tool holder ( se negativa indica spazio libero su testa).
388 lines
13 KiB
C++
388 lines
13 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : MachineHeads.cpp Data : 10.05.15 Versione : 1.6e3
|
|
// Contenuto : Implementazione gestione macchina : funzioni per teste.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 10.05.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "MachMgr.h"
|
|
#include "DllMain.h"
|
|
#include "Head.h"
|
|
#include "Exit.h"
|
|
#include "/EgtDev/Include/EMkToolConst.h"
|
|
#include "/EgtDev/Include/EGnStringUtils.h"
|
|
#include "/EgtDev/Include/EGnFileUtils.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::GetAllHeadsNames( STRVECTOR& vNames) const
|
|
{
|
|
// reset lista nomi
|
|
vNames.clear() ;
|
|
// ricerca delle teste
|
|
for ( const auto& snGro : m_mapGroups) {
|
|
if ( IsHeadGroup( snGro.second))
|
|
vNames.push_back( snGro.first) ;
|
|
}
|
|
// ordino alfabeticamente
|
|
sort( vNames.begin(), vNames.end()) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::GetAllTcPosNames( STRVECTOR& vNames) const
|
|
{
|
|
// reset lista nomi
|
|
vNames.clear() ;
|
|
// ricerca delle posizioni di cambio utensile
|
|
for ( const auto& snGro : m_mapGroups) {
|
|
if ( IsTcPosGroup( snGro.second))
|
|
vNames.push_back( snGro.first) ;
|
|
}
|
|
// ordino alfabeticamente
|
|
sort( vNames.begin(), vNames.end()) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Machine::GetHeadExitCount( const string& sHead) const
|
|
{
|
|
Head* pHead = GetHead( GetGroup( sHead)) ;
|
|
return ( ( pHead != nullptr) ? pHead->GetExitCount() : 0) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Machine::GetHeadExitPosDirAux( const string& sHead, int nExit, Point3d& ptPos, Vector3d& vtDir, Vector3d& vtAux) const
|
|
{
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero testa
|
|
int nHeadId = GetGroup( sHead) ;
|
|
Head* pHead = GetHead( nHeadId) ;
|
|
if ( pHead == nullptr)
|
|
return false ;
|
|
// recupero uscita
|
|
int nExitId = m_pGeomDB->GetFirstNameInGroup( nHeadId, MCH_EXIT + ToString( nExit)) ;
|
|
Exit* pExit = GetExit( nExitId) ;
|
|
if ( pExit == nullptr)
|
|
return false ;
|
|
// assegno i dati
|
|
ptPos = pExit->GetPos() ;
|
|
vtDir = pExit->GetTDir() ;
|
|
vtAux = pHead->GetADir() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Machine::GetHeadSolCh( const string& sHead) const
|
|
{
|
|
// recupero testa
|
|
Head* pHead = GetHead( GetGroup( sHead)) ;
|
|
if ( pHead == nullptr)
|
|
return MCH_SCC_NONE ;
|
|
// recupero criterio di soluzione associato alla testa
|
|
return pHead->GetSolCh() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadTool( const string& sHead, int nExit, const string& sTool)
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero il gruppo dell' oggetto
|
|
int nHdGrp = GetGroup( sHead) ;
|
|
// se testa
|
|
if ( IsHeadGroup( nHdGrp)) {
|
|
// cerco il gruppo dell'uscita in quello della testa
|
|
string sExit = MCH_EXIT + ToString( nExit) ;
|
|
int nExGrp = m_pGeomDB->GetFirstNameInGroup( nHdGrp, sExit) ;
|
|
Exit* pExit = GetExit( nExGrp) ;
|
|
if ( pExit == nullptr)
|
|
return false ;
|
|
// inserisco l'utensile nell'uscita
|
|
if ( ! LoadTool( pExit, sTool))
|
|
return false ;
|
|
// abilito la testa
|
|
return EnableHeadInSet( sHead) ;
|
|
}
|
|
// se posizione cambio utensile
|
|
else if ( IsTcPosGroup( nHdGrp)) {
|
|
// cerco il gruppo dell'uscita in quello della posizione cambio utensile
|
|
string sExit = MCH_EXIT + ToString( nExit) ;
|
|
int nExGrp = m_pGeomDB->GetFirstNameInGroup( nHdGrp, sExit) ;
|
|
Exit* pExit = GetExit( nExGrp) ;
|
|
if ( pExit == nullptr)
|
|
return false ;
|
|
// inserisco l'utensile nell'uscita
|
|
if ( ! LoadTool( pExit, sTool))
|
|
return false ;
|
|
// abilito la posizione cambio utensile
|
|
return m_pGeomDB->SetStatus( nHdGrp, GDB_ST_ON) ;
|
|
}
|
|
// altrimenti errore
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadTool( Exit* pExit, const string& sTool)
|
|
{
|
|
// controllo GeomDB e Exit
|
|
if ( m_pGeomDB == nullptr || pExit == nullptr)
|
|
return false ;
|
|
// se utensile già montato, esco
|
|
if ( sTool == pExit->GetTool())
|
|
return true ;
|
|
// verifico esistenza file utensile
|
|
string sDraw ;
|
|
if ( ! m_pMchMgr->TdbSetCurrTool( sTool) || ! m_pMchMgr->TdbGetCurrToolParam( TPA_DRAW, sDraw))
|
|
return false ;
|
|
string sToolFile = m_sMachineDir + "\\" + TOOLS_DIR + "\\" + sDraw ;
|
|
if ( ! ExistsFile( sToolFile)) {
|
|
string sOut = "Missing tool (" + sTool + ") draw : " + sToolFile ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str()) ;
|
|
return false ;
|
|
}
|
|
// pulisco il gruppo dell'uscita
|
|
int nExGrp = pExit->GetOwner() ;
|
|
m_pGeomDB->EmptyGroup( nExGrp) ;
|
|
// inserisco l'utensile nel gruppo
|
|
if ( ! m_pGeomDB->Load( sToolFile, nExGrp))
|
|
return false ;
|
|
int nTGrpId = m_pGeomDB->GetFirstGroupInGroup( nExGrp) ;
|
|
int nSolidId = m_pGeomDB->GetFirstNameInGroup( nTGrpId, "SOLID") ;
|
|
if ( nSolidId == GDB_ID_NULL)
|
|
return false ;
|
|
// sposto eventuali info relative al porta utensile (ToolHolder) nel gruppo SOLID
|
|
double dVal ;
|
|
if ( m_pGeomDB->GetInfo( nTGrpId, TTH_BASE, dVal))
|
|
m_pGeomDB->SetInfo( nSolidId, TTH_BASE, dVal) ;
|
|
if ( m_pGeomDB->GetInfo( nTGrpId, TTH_LEN, dVal))
|
|
m_pGeomDB->SetInfo( nSolidId, TTH_LEN, dVal) ;
|
|
if ( m_pGeomDB->GetInfo( nTGrpId, TTH_DIAM, dVal))
|
|
m_pGeomDB->SetInfo( nSolidId, TTH_DIAM, dVal) ;
|
|
if ( m_pGeomDB->GetInfo( nTGrpId, TTH_STEM_DIAM, dVal))
|
|
m_pGeomDB->SetInfo( nSolidId, TTH_STEM_DIAM, dVal) ;
|
|
// sposto il gruppo SOLID nell'uscita ed elimino la sua vecchia base
|
|
m_pGeomDB->RelocateGlob( nSolidId, nExGrp, GDB_FIRST_SON) ;
|
|
m_pGeomDB->Erase( nTGrpId) ;
|
|
// rinomino il gruppo SOLID con il nome dell'utensile
|
|
if ( ! m_pGeomDB->SetName( nSolidId, sTool)) {
|
|
string sOut = "LoadTool error : " + sTool + " invalid name" ;
|
|
LOG_ERROR( GetEMkLogger(), sOut.c_str())
|
|
return false ;
|
|
}
|
|
// lo ruoto 90 deg attorno alla X locale
|
|
m_pGeomDB->Rotate( nSolidId, ORIG, X_AX, 0, 1) ;
|
|
// se mortasa, lo ruoto 90 deg attorno a Z
|
|
int nType ;
|
|
if ( m_pMchMgr->TdbGetCurrToolParam( TPA_TYPE, nType) && nType == TT_MORTISE_STD)
|
|
m_pGeomDB->Rotate( nSolidId, ORIG, Z_AX, 0, 1) ;
|
|
pExit->SetTool( sTool) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::GetLoadedTool( const string& sHead, int nExit, string& sTool) const
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero il gruppo della testa
|
|
int nHdGrp = GetGroup( sHead) ;
|
|
if ( ! IsHeadGroup( nHdGrp))
|
|
return false ;
|
|
// cerco il gruppo dell'uscita in quello della testa
|
|
string sExit = MCH_EXIT + ToString( nExit) ;
|
|
int nExGrp = m_pGeomDB->GetFirstNameInGroup( nHdGrp, sExit) ;
|
|
Exit* pExit = GetExit( nExGrp) ;
|
|
if ( pExit == nullptr)
|
|
return false ;
|
|
// recupero nome utensile montato
|
|
sTool = pExit->GetTool() ;
|
|
return ( ! sTool.empty()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::UnloadTool( const string& sHead, int nExit)
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero il gruppo della testa o della posizione nel cambio utensili
|
|
int nHdGrp = GetGroup( sHead) ;
|
|
if ( ! IsHeadGroup( nHdGrp) && ! IsTcPosGroup( nHdGrp))
|
|
return false ;
|
|
// cerco il gruppo dell'uscita in quello della testa
|
|
string sExit = MCH_EXIT + ToString( nExit) ;
|
|
int nExGrp = m_pGeomDB->GetFirstNameInGroup( nHdGrp, sExit) ;
|
|
Exit* pExit = GetExit( nExGrp) ;
|
|
if ( pExit == nullptr)
|
|
return false ;
|
|
// pulisco il gruppo dell'uscita
|
|
m_pGeomDB->EmptyGroup( nExGrp) ;
|
|
pExit->SetTool( "") ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::LoadTools( const string& sHead, int nNoExit, 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 ;
|
|
// verifico che l'attrezzaggio contenga qualcosa
|
|
if ( ! m_pMchMgr->GetCurrSetupMgr().Exists())
|
|
return true ;
|
|
// recupero la testa
|
|
int nHdGrp = GetGroup( sHead) ;
|
|
Head* pHead = GetHead( nHdGrp) ;
|
|
if ( pHead == nullptr)
|
|
return false ;
|
|
// ciclo su tutte le uscite
|
|
for ( int nExit = 1 ; nExit <= pHead->GetExitCount() ; ++ nExit) {
|
|
// se uscita da saltare, vado oltre
|
|
if ( nExit == nNoExit)
|
|
continue ;
|
|
// recupero l'uscita
|
|
string sExit = MCH_EXIT + ToString( nExit) ;
|
|
int nExGrp = m_pGeomDB->GetFirstNameInGroup( nHdGrp, sExit) ;
|
|
Exit* pExit = GetExit( nExGrp) ;
|
|
if ( pExit == nullptr)
|
|
continue ;
|
|
// recupero l'utensile da attrezzare sull'uscita
|
|
string sTool ;
|
|
if ( m_pMchMgr->GetCurrSetupMgr().GetToolName( sHead, nExit, sTool) && ! sTool.empty()) {
|
|
bool bOk = LoadTool( pExit, sTool) ;
|
|
if ( bOk && pnCount != nullptr)
|
|
++ ( *pnCount) ;
|
|
}
|
|
// se nessun utensile, allora pulisco il gruppo dell'uscita
|
|
else {
|
|
m_pGeomDB->EmptyGroup( nExGrp) ;
|
|
pExit->SetTool( "") ;
|
|
}
|
|
}
|
|
|
|
// abilito la testa
|
|
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 ( const auto& snGro : 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], 0, &nTools) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::UnloadTools( const string& sHead)
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero la testa
|
|
int nHdGrp = GetGroup( sHead) ;
|
|
Head* pHead = GetHead( nHdGrp) ;
|
|
if ( pHead == nullptr)
|
|
return false ;
|
|
// ciclo su tutte le uscite
|
|
for ( int nExit = 1 ; nExit <= pHead->GetExitCount() ; ++ nExit) {
|
|
// recupero l'uscita
|
|
string sExit = MCH_EXIT + ToString( nExit) ;
|
|
int nExGrp = m_pGeomDB->GetFirstNameInGroup( nHdGrp, sExit) ;
|
|
Exit* pExit = GetExit( nExGrp) ;
|
|
if ( pExit == nullptr)
|
|
continue ;
|
|
// pulisco il gruppo dell'uscita
|
|
m_pGeomDB->EmptyGroup( nExGrp) ;
|
|
pExit->SetTool( "") ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::UnloadAllTools( void)
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// ciclo su tutte le teste
|
|
bool bOk = true ;
|
|
for ( const auto& snGro : m_mapGroups) {
|
|
if ( IsHeadGroup( snGro.second)) {
|
|
if ( ! UnloadTools( snGro.first))
|
|
bOk = false ;
|
|
}
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Machine::ResetHeadSet( const string& sHead)
|
|
{
|
|
// controllo GeomDB
|
|
if ( m_pGeomDB == nullptr)
|
|
return false ;
|
|
// recupero il set della testa
|
|
const STRVECTOR& vsHSet = GetHSet( sHead) ;
|
|
if ( vsHSet.empty())
|
|
return false ;
|
|
// ciclo su tutte le teste dell'insieme per svuotarle
|
|
bool bOk = true ;
|
|
for ( size_t i = 0 ; i < vsHSet.size() ; ++ i) {
|
|
if ( ! UnloadTools( vsHSet[i]))
|
|
bOk = false ;
|
|
// visualizzo solo la prima testa
|
|
m_pGeomDB->SetMode( GetGroup( sHead), ( i == 0 ? GDB_MD_STD : GDB_MD_HIDDEN)) ;
|
|
}
|
|
return bOk ;
|
|
}
|