//---------------------------------------------------------------------------- // EgalTech 2015-2016 //---------------------------------------------------------------------------- // File : Generator.cpp Data : 26.02.16 Versione : 1.6n8 // Contenuto : Implementazione della classe generator. // // // // Modifiche : 28.10.15 DS Creazione modulo. // 26.02.16 DS Aggiunta gestione archi. // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "DllMain.h" #include "Generator.h" #include "MachMgr.h" #include "Disposition.h" #include "Machining.h" #include "MachiningConst.h" #include "OutputConst.h" #include "/EgtDev/Include/EMkToolConst.h" #include "/EgtDev/Include/EMkOperationConst.h" #include "/EgtDev/Include/EGkCurve.h" #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Include/EGnFileUtils.h" using namespace std ; //------------------------------ Errors -------------------------------------- // 1001 = "Error with setup : xxx" // 1002 = "Error opening Cnc file" //---------------------------------------------------------------------------- static const string ERR_EXT = ".err" ; //---------------------------------------------------------------------------- Generator::Generator( void) { m_pMchMgr = nullptr ; m_pGeomDB = nullptr ; m_pMachine = nullptr ; m_AxesName.reserve( 8) ; m_AxesToken.reserve( 8) ; m_AxesVal.reserve( 8) ; } //---------------------------------------------------------------------------- Generator::~Generator( void) { } //---------------------------------------------------------------------------- bool Generator::Init( MachMgr* pMchMgr) { // verifico ambiente if ( pMchMgr == nullptr || pMchMgr->GetContextId() == 0 || pMchMgr->GetGeomDB() == nullptr || pMchMgr->GetCurrMachine() == nullptr) return false ; m_pMchMgr = pMchMgr ; m_pGeomDB = m_pMchMgr->GetGeomDB() ; m_pMachine = m_pMchMgr->GetCurrMachine() ; m_sPrevTool.clear() ; m_sTool.clear() ; return true ; } //---------------------------------------------------------------------------- bool Generator::Run( const string& sCncFile, const std::string& sInfo) { // emetto info di log { string sOut = "Generator Run : " + sCncFile ; LOG_INFO( GetEMkLogger(), sOut.c_str()) ; } // cancello l'eventuale file di uscita (e anche il file errore) EraseFile( sCncFile) ; string sErrFile = ChangeFileExtension( sCncFile, ERR_EXT) ; EraseFile( sErrFile) ; // verifico ci sia una macchinata corrente 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() ; if ( ! VerifySetup()) return false ; // evento inizio esecuzione bool bOk = true ; if ( ! OnStart()) { bOk = false ; LOG_INFO( GetEMkLogger(), "OnStart error") ; } // apertura file di output ed evento inizio programma if ( bOk && ! OnProgramStart( m_pMachine->GetMachineName(), sCncFile, sInfo, m_pMchMgr->GetCurrSetupMgr().Exists())) { bOk = false ; LOG_INFO( GetEMkLogger(), "OnProgramStart error") ; } // emissione dati utensili if ( bOk && ! ProcessToolData()) { bOk = false ; LOG_INFO( GetEMkLogger(), "ProcessToolData error") ; } // ciclo su tutte le operazioni della macchinata int nInd = 0 ; int nOpId = m_pMchMgr->GetFirstActiveOperation() ; while ( bOk && nOpId != GDB_ID_NULL) { // incremento l'indice della operazione ++ nInd ; // la prima operazione deve essere una disposizione if ( nInd == 1) { if ( m_pMchMgr->GetOperationType( nOpId) != OPER_DISP) { bOk = false ; continue ; } } // processo l'operazione int nType = m_pMchMgr->GetOperationType( nOpId) ; if ( IsValidDispositionType( nType)) { if ( ! ProcessDisposition( nOpId, nInd)) bOk = false ; } else if ( IsValidMachiningType( nType)) { if ( ! ProcessMachining( nOpId, nInd)) bOk = false ; } // passo alla operazione successiva nOpId = m_pMchMgr->GetNextActiveOperation( nOpId) ; } // evento fine programma if ( bOk && ! OnProgramEnd()) { bOk = false ; LOG_INFO( GetEMkLogger(), "OnProgramEnd error") ; } // chiudo il file di output if ( ! m_pMachine->WriterClose()) bOk = false ; // in caso di errore lo rinomino if ( ! bOk) RenameFile( sCncFile, sErrFile) ; // evento fine esecuzione if ( ! OnEnd()) { bOk = false ; LOG_INFO( GetEMkLogger(), "OnEnd error") ; } 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) { // Parametri della disposizione Disposition* pDisp = GetDisposition( m_pGeomDB->GetUserObj( nOpId)) ; if ( pDisp == nullptr) return false ; // Imposto la fase int nPhase = pDisp->GetPhase() ; m_pMchMgr->SetCurrPhase( nPhase) ; bool bEmpty = pDisp->IsEmpty() ; bool bSomeByHand = pDisp->GetSomeByHand() ; // Se disposizione con movimenti macchina if ( ! pDisp->IsEmpty()) { // Recupero l'utensile della disposizione corrente string sTool ; string sHead ; int nExit ; string sTcPos ; if ( ! pDisp->GetToolData( sTool, sHead, nExit, sTcPos)) return false ; // Se esiste utensile corrente e cambierà, lo scarico if ( ! m_sTool.empty() && m_sTool != sTool) { // emetto deselezione vecchio utensile if ( ! OnToolDeselect( sTool, sHead, nExit, sTcPos)) return false ; } // Aggiorno utensile e assi macchina if ( ! UpdateDispTool( sTool, sHead, nExit) || ! UpdateAxes()) return false ; // Se utensile non definito o cambiato, emetto selezione nuovo utensile if ( m_sTool.empty() || m_sTool != m_sPrevTool) { if ( ! OnToolSelect( sTool, sHead, nExit, sTcPos)) return false ; } } // Emetto inizio disposizione if ( ! OnDispositionStart( nOpId, nOpInd, nPhase, bEmpty, bSomeByHand)) return false ; // Emetto dati tavola string sTable ; pDisp->GetTable( sTable) ; Point3d ptOri1 ; pDisp->GetTableRef1( ptOri1) ; if ( ! OnTableData( sTable, ptOri1)) return false ; // Emetto dati bloccaggi for ( int i = 0 ; ; ++ i) { string sName ; int nId ; Point3d ptPos ; double dAngDeg ; double dMov ; if ( pDisp->GetFixtureData( i, sName, nId, ptPos, dAngDeg, dMov)) { if ( ! OnFixtureData( nId, i + 1, sName, ptPos, dAngDeg, dMov)) return false ; } else break ; } // Emetto movimenti sui grezzi for ( int i = 0 ; ; ++ i) { int nRawId ; int nType ; Point3d ptPos ; int nFlag ; if ( pDisp->GetMoveRawData( i, nRawId, nType, ptPos, nFlag)) { if ( ! OnRawMoveData( nRawId, i + 1, nType, ptPos, nFlag)) return false ; } else break ; } bool bOk = true ; // Se disposizione con movimenti macchina if ( ! pDisp->IsEmpty()) { // Ciclo su tutti i percorsi CL della disposizione int nClPathInd = 0 ; int nClId = m_pGeomDB->GetFirstNameInGroup( nOpId, MCH_CL) ; int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ; while ( bOk && nClPathId != GDB_ID_NULL) { ++ nClPathInd ; // processo il percorso di lavoro if ( ! ProcessClPath( nClPathId, nClPathInd, nOpId, nOpInd)) bOk = false ; // passo al percorso successivo nClPathId = m_pGeomDB->GetNextGroup( nClPathId) ; } } // Emetto fine disposizione bOk = bOk && OnDispositionEnd() ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::ProcessMachining( int nOpId, int nOpInd) { // Imposto come lavorazione corrente if ( ! m_pMchMgr->SetCurrMachining( nOpId)) return false ; // Verifico non sia vuota if ( m_pMchMgr->IsMachiningEmpty()) return true ; // Recupero l'utensile della lavorazione corrente string sTuuid, sTool ; if ( ! m_pMchMgr->GetMachiningParam( MPA_TUUID, sTuuid) || ! m_pMchMgr->TdbGetToolFromUUID( sTuuid, sTool)) return false ; // Se utensile cambierà if ( ! m_sTool.empty() && m_sTool != sTool) { // recupero la testa del prossimo utensile (prima dall'attrezzaggio, poi dal DB utensili) string sNextTcPos ; string sNextHead ; int nNextExit ; if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( sTool, sNextTcPos, sNextHead, nNextExit)) { if ( m_pMchMgr->TdbSetCurrTool( sTool)) { m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, sNextTcPos) ; m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sNextHead) ; m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nNextExit) ; } // ripristino l'utensile corrente m_pMchMgr->TdbSetCurrTool( m_sTool) ; } // emetto deselezione vecchio utensile if ( ! OnToolDeselect( sTool, sNextHead, nNextExit, sNextTcPos)) return false ; } // Aggiorno utensile e assi macchina if ( ! UpdateTool( sTool) || ! UpdateAxes()) return false ; // Se utensile cambiato, emetto selezione nuovo utensile if ( m_sTool != m_sPrevTool) { string sTcPos ; string sHead ; int nExit ; if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( m_sTool, sTcPos, sHead, nExit)) { m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ; m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ; m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, sTcPos) ; } if ( ! OnToolSelect( sTool, sHead, nExit, sTcPos)) return false ; } // Recupero speed double dSpeed ; if ( ! m_pMchMgr->GetMachiningParam( MPA_SPEED, dSpeed)) return false ; // Recupero punti di minimo e massimo ingombro int nClId = m_pGeomDB->GetFirstNameInGroup( nOpId, MCH_CL) ; Point3d ptMin, ptMax ; m_pGeomDB->GetInfo( nClId, KEY_MMIN, ptMin) ; m_pGeomDB->GetInfo( nClId, KEY_MMAX, ptMax) ; // Emetto inizio lavorazione if ( ! OnMachiningStart( nOpId, nOpInd, dSpeed, ptMin, ptMax)) return false ; // Ciclo su tutti i percorsi CL della lavorazione bool bOk = true ; int nClPathInd = 0 ; int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ; while ( bOk && nClPathId != GDB_ID_NULL) { ++ nClPathInd ; // processo il percorso di lavoro if ( ! ProcessClPath( nClPathId, nClPathInd, nOpId, nOpInd)) bOk = false ; // passo al percorso successivo nClPathId = m_pGeomDB->GetNextGroup( nClPathId) ; } // Emetto fine lavorazione bOk = bOk && OnMachiningEnd() ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd) { // Recupero punti di inizio e fine del percorso Point3d ptStart ; m_pGeomDB->GetInfo( nClPathId, KEY_START, ptStart) ; Point3d ptEnd ; m_pGeomDB->GetInfo( nClPathId, KEY_END, ptEnd) ; // Recupero versore estrusione associato al percorso (normale al piano di interpolazione) Vector3d vtExtr ; m_pGeomDB->GetInfo( nClPathId, KEY_EXTR, vtExtr) ; // Recupero punti di minimo e massimo ingombro Point3d ptMin, ptMax ; m_pGeomDB->GetInfo( nClPathId, KEY_PMIN, ptMin) ; m_pGeomDB->GetInfo( nClPathId, KEY_PMAX, ptMax) ; // Recupero massima elevazione double dElev = 0 ; m_pGeomDB->GetInfo( nClPathId, KEY_ELEV, dElev) ; // Recupero il numero di eventi ausiliari iniziali int nAS = 0 ; m_pGeomDB->GetInfo( nClPathId, KEY_AS_TOT, nAS) ; // Emetto inizio percorso di lavoro if ( ! OnPathStart( nClPathId, nClPathInd, nAS, ptStart, ptEnd, vtExtr, ptMin, ptMax, dElev)) return false ; // Emissione eventuali dati ausiliari di inizio // processo gli eventi for ( int i = 1 ; i <= nAS ; ++ i) { // recupero i dati per l'evento string sAS ; if ( ! m_pGeomDB->GetInfo( nClPathId, KEY_AS + ToString( i), sAS)) return false ; // richiamo gestione evento ausiliario prima di inizio percorso di lavoro if ( ! OnPathStartAux( i, sAS)) return false ; } // Ciclo su tutte le entità del percorso CL bool bOk = true ; int nEntInd = 0 ; int nEntId = m_pGeomDB->GetFirstInGroup( nClPathId) ; while ( bOk && nEntId != GDB_ID_NULL) { ++ nEntInd ; // processo l'entità if ( ! ProcessClEnt( nEntId, nEntInd, nClPathId, nClPathInd, nOpId, nOpInd)) bOk = false ; // passo all'entità successivo nEntId = m_pGeomDB->GetNext( nEntId) ; } // Recupero il numero di eventi ausiliari finali int nAE = 0 ; m_pGeomDB->GetInfo( nClPathId, KEY_AE_TOT, nAE) ; // Emetto fine percorso di lavoro bOk = bOk && OnPathEnd( nAE) ; // Emissione eventuali dati ausiliari di fine // processo gli eventi for ( int i = 1 ; i <= nAE ; ++ i) { // recupero i dati per l'evento string sAE ; if ( ! m_pGeomDB->GetInfo( nClPathId, KEY_AE + ToString( i), sAE)) return false ; // richiamo gestione evento ausiliario dopo fine percorso di lavoro if ( ! OnPathEndAux( i, sAE)) return false ; } return bOk ; } //---------------------------------------------------------------------------- bool Generator::ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd, int nOpId, int nOpInd) { // Recupero i dati Cam CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ; if ( pCamData == nullptr || pCamData->GetAxesStatus() != CamData::AS_OK) return false ; const DBLVECTOR& AxesEnd = pCamData->GetAxesVal() ; // Emetto movimento int nMove = pCamData->GetMoveType() ; switch ( nMove) { case 0 : // rapido if ( ! OnRapid( nMove, AxesEnd, pCamData->GetAxesMask(), pCamData->GetFlag())) return false ; break ; case 1 : // linea if ( ! OnLinear( nMove, AxesEnd, pCamData->GetFeed(), pCamData->GetFlag())) return false ; break ; case 2 : // arco CW case 3 : // arco CCW if ( ! OnArc( nMove, AxesEnd, pCamData->GetAxesCen(), pCamData->GetAxesRad(), pCamData->GetAxesAngCen(), pCamData->GetFeed(), pCamData->GetFlag())) return false ; break ; } return true ; } //---------------------------------------------------------------------------- bool Generator::UpdateTool( const string& sTool) { // Salvo l'utensile attuale come precedente m_sPrevTool = m_sTool ; // Se cambiato utensile ... if ( sTool != m_sTool) { // lo imposto come corrente if ( ! m_pMchMgr->TdbSetCurrTool( sTool)) return false ; // lo carico in macchina (se esiste attrezzaggio prendo i dati da questo) string sTcPos ; string sHead ; int nExit ; if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( sTool, sTcPos, sHead, nExit)) { m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ; m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ; } if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit)) return false ; m_sTool = sTool ; } return true ; } //---------------------------------------------------------------------------- bool Generator::UpdateDispTool( const string& sTool, const string& sHead, int nExit) { // Salvo l'utensile attuale come precedente m_sPrevTool = m_sTool ; // Se non definito o cambiato ... if ( sTool.empty() || sTool != m_sTool) { // lo carico in macchina if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit)) return false ; m_sTool = sTool ; } return true ; } //---------------------------------------------------------------------------- bool Generator::UpdateAxes( void) { // Carico i nomi degli assi macchina attivi return m_pMachine->GetAllCurrAxesName( m_AxesName) && m_pMachine->GetAllCurrAxesToken( m_AxesToken) ; } //---------------------------------------------------------------------------- bool Generator::OnStart( void) { // definisco tavola variabili globali bool bOk = m_pMachine->LuaCreateGlobTable( GLOB_VAR) ; // assegno valori di default bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_USETO1, false) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MODAL, false) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NUM, false) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NUMTOK, "N") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_LINENBR, 0) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_LINEINC, 1) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C1T, "I") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C2T, "J") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C3T, "K") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RRT, "R") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FT, "F") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ST, "S") ; // chiamo la funzione bOk = bOk && m_pMachine->LuaCallFunction( ON_START) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnEnd( void) { // chiamo la funzione bool bOk = m_pMachine->LuaCallFunction( ON_END) ; // rimuovo tavola variabili globali bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR) && bOk ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnProgramStart( const string& sMachName, const string& sCncFile, const string& sInfo, bool bSetup) { // apro il file di output bool bOk = m_pMachine->WriterOpen( sCncFile) ; if ( ! bOk) m_pMchMgr->SetLastError( 1002, "Error opening Cnc file") ; // assegno nome macchina bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MACHNAME, sMachName) ; // assegno nome file bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FILE, sCncFile) ; // assegno info string sTxt = sInfo + " " + CurrDateTime() ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INFO, sTxt) ; // assegno flag di presenza setup bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SETUP, bSetup) ; // chiamo la funzione di inizio programma bOk = bOk && m_pMachine->LuaCallFunction( ON_PROGRAM_START) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnProgramEnd( void) { // chiamo fine programma bool bOk = m_pMachine->LuaCallFunction( ON_PROGRAM_END) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::ProcessToolData( void) { struct MyToolData { string sName ; string sHead ; int nExit ; string sTcPos ; int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dMaxSpeed ; MyToolData( void) : sName(), sHead(), nExit( 0), sTcPos(), nComp(0), dDiam( 0), dLen( 0), dMaxSpeed( 0) {} } ; typedef vector TDATAVECTOR ; TDATAVECTOR vTdata ; // ciclo sulle lavorazioni per ricavare gli utensili utilizzati int nOpId = m_pMchMgr->GetFirstActiveOperation() ; while ( nOpId != GDB_ID_NULL) { // processo l'operazione int nType = m_pMchMgr->GetOperationType( nOpId) ; if ( IsValidMachiningType( nType)) { // Imposto come lavorazione corrente if ( ! m_pMchMgr->SetCurrMachining( nOpId)) return false ; // Recupero l'utensile della lavorazione corrente string sTuuid, sTool ; if ( ! m_pMchMgr->GetMachiningParam( MPA_TUUID, sTuuid) || ! m_pMchMgr->TdbGetToolFromUUID( sTuuid, sTool)) return false ; // Recupero i dati dell'utensile MyToolData Tdata ; if ( m_pMchMgr->TdbSetCurrTool( sTool)) { Tdata.sName = sTool ; m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, Tdata.sHead) ; m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, Tdata.nExit) ; m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, Tdata.sTcPos) ; m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, Tdata.nComp) ; m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, Tdata.dDiam) ; m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, Tdata.dTDiam) ; m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, Tdata.dLen) ; m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, Tdata.dTLen) ; m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, Tdata.dMaxSpeed) ; vTdata.push_back( Tdata) ; } } // passo alla operazione successiva nOpId = m_pMchMgr->GetNextActiveOperation( nOpId) ; } bool bOk = true ; // se definito attrezzaggio if ( m_pMchMgr->GetCurrSetupMgr().Exists()) { // verifico che tutti gli utensili siano attrezzati for ( size_t i = 0 ; i < vTdata.size() ; ++ i) { if ( ! m_pMchMgr->GetCurrSetupMgr().FindTool( vTdata[i].sName)) { string sErr = "Error : " + vTdata[i].sName + " missing in setup " ; LOG_INFO( GetEMkLogger(), sErr.c_str()) bOk = false ; } } // emetto l'elenco di tutti gli utensili attrezzati string sTcPos ; string sHead ; int nExit ; string sTool ; for ( int i = 1 ; m_pMchMgr->GetCurrSetupMgr().GetPosData( i, sTcPos, sHead , nExit, sTool); ++ i) { // se nella posizione non c'è utensile, vado oltre if ( sTool.empty()) continue ; // emetto i dati bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, sTool) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, sHead) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ; if ( m_pMchMgr->TdbSetCurrTool( sTool)) { int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dMaxSpeed ; m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, nComp) ; m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, dDiam) ; m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, dTDiam) ; m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, dLen) ; m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, dTLen) ; m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, dMaxSpeed) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, nComp) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, dDiam) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, dTDiam) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TLEN, dLen) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTLEN, dTLen) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, dMaxSpeed) ; } // se esiste, chiamo la funzione di emissione dati utensile if ( m_pMachine->LuaExistsFunction( ON_TOOL_DATA)) bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_DATA) ; } } // altrimenti emetto direttamente gli utensili else { // ordino l'elenco degli utensili std::sort( vTdata.begin(), vTdata.end(), []( const MyToolData& a, const MyToolData& b) { if ( a.sHead == b.sHead) return a.nExit < b.nExit ; else return a.sHead < b.sHead ; }) ; // emetto l'elenco degli utensili string sPrevHead ; int nPrevExit = 0 ; string sPrevTcPos ; string sPrevTool ; for ( size_t i = 0 ; i < vTdata.size() ; ++ i) { // se posizione diversa (testa o uscita o toolchanger) if ( vTdata[i].sHead != sPrevHead || vTdata[i].nExit != nPrevExit || vTdata[i].sTcPos != sPrevTcPos) { bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, vTdata[i].sName) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, vTdata[i].sHead) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, vTdata[i].nExit) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, vTdata[i].sTcPos) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, vTdata[i].nComp) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, vTdata[i].dDiam) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, vTdata[i].dTDiam) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TLEN, vTdata[i].dLen) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTLEN, vTdata[i].dTLen) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, vTdata[i].dMaxSpeed) ; // se esiste, chiamo la funzione di emissione dati utensile if ( m_pMachine->LuaExistsFunction( ON_TOOL_DATA)) bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_DATA) ; // salvo dati correnti come precedenti sPrevHead = vTdata[i].sHead ; nPrevExit = vTdata[i].nExit ; sPrevTool = vTdata[i].sName ; sPrevTcPos = vTdata[i].sTcPos ; } // altrimenti else { if ( vTdata[i].sName != sPrevTool) { string sErr = "Error : two tools in same position : " + sPrevTool + "<->" + vTdata[i].sName ; LOG_INFO( GetEMkLogger(), sErr.c_str()) bOk = false ; } } } } return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnDispositionStart( int nOpId, int nOpInd, int nPhase, bool bEmpty, bool bSomeByHand) { // assegno identificativo e indice disposizione bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPID, nOpId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPIND, nOpInd) ; // assegno nuovo indice di fase bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PHASE, nPhase) ; // assegno flag disposizione passiva bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EMPTY, bEmpty) ; // assegno flag disposizione con operazioni manuali bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SBH, bSomeByHand) ; // chiamo la funzione di inizio disposizione bOk = bOk && m_pMachine->LuaCallFunction( ON_DISPOSITION_START) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnDispositionEnd( void) { // chiamo la funzione di fine disposizione bool bOk = m_pMachine->LuaCallFunction( ON_DISPOSITION_END) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnTableData( const string& sName, const Point3d& ptOri1) { // assegno nome tavola e valore riferimento bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TABNAME, sName) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TABORI1, ptOri1) ; // chiamo la funzione di gestione dati tavola bOk = bOk && m_pMachine->LuaCallFunction( ON_TABLE_DATA) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnFixtureData( int nFixId, int nFixInd, const string& sName, const Point3d& ptPos, double dAngDeg, double dMov) { // assegno dati bloccaggio bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXID, nFixId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXIND, nFixInd) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXNAME, sName) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXPOS, ptPos) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXANG, dAngDeg) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXMOB, dMov) ; // chiamo la funzione di gestione dati bloccaggio bOk = bOk && m_pMachine->LuaCallFunction( ON_FIXTURE_DATA) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnRawMoveData( int nRawId, int RawMoveInd, int nType, const Point3d& ptPos, int nFlag) { // assegno dati bloccaggio bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWID, nRawId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWIND, RawMoveInd) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWTYPE, nType) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWPOS, ptPos) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWFLAG, nFlag) ; // chiamo la funzione di gestione movimento del grezzo bOk = bOk && m_pMachine->LuaCallFunction( ON_RAWMOVE_DATA) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnToolSelect( const string& sTool, const string& sHead, int nExit, const string& sTcPos) { // assegno il nome dell'utensile, la testa, l'uscita e l'eventuale posizione nel toolchanger bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, sTool) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, sHead) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ; // assegno il token e il nome degli assi int nNumAxes = int( m_AxesName.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) { bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken(i), m_AxesToken[i-1]) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisName(i), m_AxesName[i-1]) ; } else { bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken(i)) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisName(i)) ; } } // chiamo la funzione di selezione utensile bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_SELECT) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnToolDeselect( const std::string& sNextTool, const string& sNextHead, int nNextExit, const string& sNextTcPos) { // assegno il prossimo utensile bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTTOOL, sNextTool) ; // assegno la prossima testa bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTHEAD, sNextHead) ; // assegno la prossima uscita bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTEXIT, nNextExit) ; // assegno l'eventuale prossima posizione nel TC bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTTCPOS, sNextTcPos) ; // chiamo la funzione di deselezione utensile bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_DESELECT) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnMachiningStart( int nOpId, int nOpInd, double dSpeed, const Point3d& ptMin, const Point3d& ptMax) { // assegno identificativo e indice lavorazione bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHID, nOpId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHIND, nOpInd) ; // assegno speed bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_S, dSpeed) ; // assegno punti estremi dell'ingombro della lavorazione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MMIN, ptMin) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MMAX, ptMax) ; // chiamo la funzione di inizio lavorazione bOk = bOk && m_pMachine->LuaCallFunction( ON_MACHINING_START) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnMachiningEnd( void) { // chiamo la funzione di fine lavorazione bool bOk = m_pMachine->LuaCallFunction( ON_MACHINING_END) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax, double dElev) { // assegno identificativo e indice percorso di lavorazione bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHID, nClPathId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHIND, nClPathInd) ; // assegno numero di dati ausiliari iniziali bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXTOT, nAS) ; // assegno punti iniziale e finale e versore estrusione del percorso originale bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_START, ptStart) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_END, ptEnd) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXTR, vtExtr) ; // assegno punti estremi dell'ingombro del percorso di lavorazione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PMIN, ptMin) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PMAX, ptMax) ; // assegno la massima elevazione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ELEV, dElev) ; // chiamo la funzione di inizio percorso di lavorazione bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_START) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnPathEnd( int nAE) { // assegno numero di dati ausiliari finali bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXTOT, nAE) ; // chiamo la funzione di fine percorso di lavorazione bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_END) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnPathStartAux( int nInd, const string& sAS) { // verifico esistenza funzione if ( ! m_pMachine->LuaExistsFunction( ON_PATH_START_AUX)) return true ; // assegno indice e valore dato ausiliario bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXIND, nInd) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUX, sAS) ; // chiamo la funzione di emissione dato ausiliario ad inizio percorso di lavorazione bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_START_AUX) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnPathEndAux( int nInd, const string& sAE) { // verifico esistenza funzione if ( ! m_pMachine->LuaExistsFunction( ON_PATH_END_AUX)) return true ; // assegno indice e valore dato ausiliario bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXIND, nInd) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUX, sAE) ; // chiamo la funzione di emissione dato ausiliario alla fine percorso di lavorazione bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_END_AUX) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnRapid( int nMove, const DBLVECTOR& AxesEnd, int nAxesMask, int nFlag) { // cancello variabili estranee ResetArcData() ; // assegno il tipo di movimento bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ; // assegno il valore degli assi int nNumAxes = int( AxesEnd.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ; } // assegno la mascheratura degli assi bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MASK, nAxesMask) ; // assegno il valore del flag bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ; // chiamo la funzione di movimento in rapido bOk = bOk && m_pMachine->LuaCallFunction( ON_RAPID) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnLinear( int nMove, const DBLVECTOR& AxesEnd, double dFeed, int nFlag) { // cancello variabili estranee ResetArcData() ; // assegno il tipo di movimento bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ; // assegno il valore degli assi int nNumAxes = int( AxesEnd.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ; } // assegno il valore della feed bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_F, dFeed) ; // assegno il valore del flag bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ; // chiamo la funzione di movimento in rapido bOk = bOk && m_pMachine->LuaCallFunction( ON_LINEAR) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::OnArc( int nMove, const DBLVECTOR& AxesEnd, const Point3d& ptCen, double dRad, double dAngCen, double dFeed, int nFlag) { // assegno il tipo di movimento bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ; // assegno il valore degli assi int nNumAxes = int( AxesEnd.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ; } // assegno le coordinate del centro bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C1, ptCen.x) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C2, ptCen.y) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C3, ptCen.z) ; // assegno il valore del raggio bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RR, dRad) ; // assegno il valore dell'angolo al centro bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AC, dAngCen) ; // assegno il valore della feed bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_F, dFeed) ; // assegno il valore del flag bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ; // chiamo la funzione di movimento in rapido bOk = bOk && m_pMachine->LuaCallFunction( ON_ARC) ; return bOk ; } //---------------------------------------------------------------------------- bool Generator::ResetArcData( void) { // reset dati arco bool bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C1) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C2) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C3) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_RR) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_AC) ; return bOk ; }