//---------------------------------------------------------------------------- // EgalTech 2018-2018 //---------------------------------------------------------------------------- // File : Processor.cpp Data : 29.05.18 Versione : 1.9e6 // Contenuto : Implementazione della classe Processor. // // // // Modifiche : 29.05.18 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "DllMain.h" #include "Processor.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 -------------------------------------- // 1002 = "Error with setup : xxx" // 1003 = "Error opening Cnc file" //---------------------------------------------------------------------------- Processor::Processor( void) { m_pMchMgr = nullptr ; m_pGeomDB = nullptr ; m_pMachine = nullptr ; m_AxesName.reserve( 8) ; m_AxesToken.reserve( 8) ; m_AxesVal.reserve( 8) ; } //---------------------------------------------------------------------------- Processor::~Processor( void) { } //---------------------------------------------------------------------------- bool Processor::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 Processor::Run( const string& sOutFile, const string& sInfo) { // 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() ; m_pMchMgr->ResetWarnings() ; // forzo aggiornamento attrezzaggio della macchinata m_pMchMgr->UpdateCurrSetup() ; if ( ! VerifySetup()) return false ; // imposto la fase iniziale come corrente m_pMchMgr->SetCurrPhase( 1) ; // evento inizio esecuzione bool bOk = true ; if ( ! OnStart()) { bOk = false ; LOG_ERROR( GetEMkLogger(), "OnStart error") ; } // apertura file di output ed evento inizio programma if ( bOk && ! OnProgramStart( m_pMachine->GetMachineName(), sOutFile, sInfo, m_pMchMgr->GetCurrSetupMgr().Exists())) { bOk = false ; LOG_ERROR( GetEMkLogger(), "OnProgramStart error") ; } // emissione dati utensili if ( bOk && ! ProcessToolData()) { bOk = false ; LOG_ERROR( 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_ERROR( GetEMkLogger(), "OnProgramEnd error") ; } // chiudo il file di output if ( ! m_pMachine->WriterClose()) bOk = false ; // evento fine esecuzione if ( ! OnEnd()) { bOk = false ; LOG_ERROR( GetEMkLogger(), "OnEnd error") ; } // imposto la fase iniziale come corrente m_pMchMgr->SetCurrPhase( 1) ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::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 ( const auto& sTmp : vsErr) sErr += " " + sTmp ; m_pMchMgr->SetLastError( 1002, sErr) ; return false ; } //---------------------------------------------------------------------------- bool Processor::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 autonomi e utensile associato if ( ! pDisp->IsEmpty() && pDisp->IsWithTool()) { // 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, false)) 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 ; // Recupero assi tavola mossi nella disposizione INTVECTOR vMovAxId ; for ( int i = 0 ; ; ++ i) { string sName ; double dPos ; if ( pDisp->GetMoveAxisData( i, sName, dPos)) { int nAxId = m_pMachine->GetAxisId( sName) ; if ( nAxId != GDB_ID_NULL) vMovAxId.emplace_back( nAxId) ; } else break ; } // Emetto posizioni assi di tavola INTVECTOR vAxisId ; m_pMachine->GetAllAxesIds( vAxisId) ; int nTableId = m_pMachine->GetTableId( sTable) ; int nInd = 0 ; for ( int nAxId : vAxisId) { string sName ; double dPos ; if ( m_pMachine->IsDispositionAxis( nAxId, nTableId) && m_pMachine->GetAxisName( nAxId, sName) && m_pMachine->GetAxisPos( sName, dPos)) { ++ nInd ; bool bMoved = ( std::find( vMovAxId.begin(), vMovAxId.end(), nAxId) != vMovAxId.end()) ; if ( ! OnTableAxisData( nInd, sName, dPos, bMoved)) return false ; } } // Emetto dati bloccaggi for ( int i = 0 ; ; ++ i) { string sName ; int nId ; Point3d ptPos ; double dAngDeg ; double dMov ; string sTaLink ; if ( pDisp->GetFixtureData( i, sName, nId, ptPos, dAngDeg, dMov, sTaLink)) { if ( ! OnFixtureData( nId, i + 1, sName, ptPos, dAngDeg, dMov, sTaLink)) 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 Processor::ProcessMachining( int nOpId, int nOpInd) { // Imposto come lavorazione corrente if ( ! m_pMchMgr->SetCurrMachining( nOpId)) return false ; // Verifico non sia vuota if ( m_pMchMgr->IsMachiningEmpty( NEED_ONE_TP_OK)) 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) ; } bool bFloating = m_pMachine->IsCurrToolFloating() ; if ( ! OnToolSelect( sTool, sHead, nExit, sTcPos, bFloating)) return false ; } // Recupero speed double dSpeed ; if ( ! m_pMchMgr->GetMachiningParam( MPA_SPEED, dSpeed)) return false ; // Recupero punti di minimo e massimo di ingombro e degli assi 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) ; DBLVECTOR vAxMin, vAxMax ; m_pGeomDB->GetInfo( nClId, KEY_MAXMIN, vAxMin) ; m_pGeomDB->GetInfo( nClId, KEY_MAXMAX, vAxMax) ; // Emetto inizio lavorazione if ( ! OnMachiningStart( nOpId, nOpInd, dSpeed, ptMin, ptMax, vAxMin, vAxMax)) 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 Processor::ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd) { // verifico se Path in doppio int nDblPathId = GDB_ID_NULL ; int nDblId = m_pGeomDB->GetFirstNameInGroup( nOpId, MCH_DBL) ; if ( nDblId != GDB_ID_NULL) { string sCLPathName ; m_pGeomDB->GetName( nClPathId, sCLPathName) ; nDblPathId = m_pGeomDB->GetFirstNameInGroup( nDblId, sCLPathName) ; } // 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 valori degli assi di minimo e massimo ingombro DBLVECTOR vAxMin, vAxMax ; m_pGeomDB->GetInfo( nClPathId, KEY_PAXMIN, vAxMin) ; m_pGeomDB->GetInfo( nClPathId, KEY_PAXMAX, vAxMax) ; // Recupero massima elevazione double dElev = 0 ; m_pGeomDB->GetInfo( nClPathId, KEY_ELEV, dElev) ; // recupero eventuale attivazione uscite (gruppi a forare) INTVECTOR vActiveExit ; m_pGeomDB->GetInfo( nClPathId, KEY_DRACEX, vActiveExit) ; // 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, nDblPathId, nAS, ptStart, ptEnd, vtExtr, ptMin, ptMax, vAxMin, vAxMax, dElev, vActiveExit)) 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à successiva 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 Processor::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() ; int nMove = pCamData->GetMoveType() ; // Recupero i dati Cam del movimento successivo del percorso (se esiste) CamData* pNextCamData = GetCamData( m_pGeomDB->GetUserObj( m_pGeomDB->GetNext( nEntId))) ; int nMoveNext = ( pNextCamData != nullptr ? pNextCamData->GetMoveType() : -1) ; DBLVECTOR AxesNull ; const DBLVECTOR& AxesNext = ( pNextCamData != nullptr ? pNextCamData->GetAxesVal() : AxesNull) ; // Emetto movimento switch ( nMove) { case 0 : // rapido if ( ! OnRapid( nEntId, nEntInd, nMove, AxesEnd, pCamData->GetAxesMask(), pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex(), nMoveNext, AxesNext)) return false ; break ; case 1 : // linea if ( ! OnLinear( nEntId, nEntInd, nMove, AxesEnd, pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(), pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex(), nMoveNext, AxesNext)) return false ; break ; case 2 : // arco CW case 3 : // arco CCW Point3d ptMid( AxesEnd[0], AxesEnd[1], AxesEnd[2]) ; ptMid.Rotate( pCamData->GetAxesCen(), pCamData->GetAxesNormDir(), - pCamData->GetAxesAngCen() / 2) ; if ( ! OnArc( nEntId, nEntInd, nMove, AxesEnd, pCamData->GetAxesCen(), ptMid, pCamData->GetAxesRad(), pCamData->GetAxesAngCen(), pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(), pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex(), nMoveNext, AxesNext)) return false ; break ; } return true ; } //---------------------------------------------------------------------------- bool Processor::UpdateTool( const string& sTool) { // Salvo l'utensile attuale come precedente m_sPrevTool = 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 Processor::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 Processor::UpdateAxes( void) { // Carico i nomi degli assi macchina attivi return m_pMachine->GetAllCurrAxesNames( m_AxesName) && m_pMachine->GetAllCurrAxesTokens( m_AxesToken) ; } //---------------------------------------------------------------------------- bool Processor::OnStart( void) { // definisco tavola variabili globali bool bOk = m_pMachine->LuaCreateGlobTable( GLOB_VAR) ; // assegno versione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_VER, GetEMkVer()) ; // 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_INCHES, ! ExeUiUnitsAreMM()) ; 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_M1T, "I") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M2T, "J") ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M3T, "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") ; // variabili di sola lettura int nSplitArcs = 0 ; m_pMchMgr->MdbGetGeneralParam( MGP_SPLITARCS, nSplitArcs) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SPLITARCS, nSplitArcs) ; // chiamo la funzione bOk = bOk && CallOnStart() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnEnd( void) { // chiamo la funzione bool bOk = CallOnEnd() ; // rimuovo tavola variabili globali bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR) && bOk ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::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( 1003, "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 && CallOnProgramStart() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnProgramEnd( void) { // chiamo fine programma bool bOk = CallOnProgramEnd() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::ProcessToolData( void) { struct MyToolData { string sName ; string sHead ; int nExit ; string sTcPos ; int nType ; int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dDist ; double dMaxSpeed ; MyToolData( void) : sName(), sHead(), nExit( 0), sTcPos(), nType(0), nComp(0), dDiam( 0), dLen( 0), dDist( 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_TYPE, Tdata.nType) ; 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_DIST, Tdata.dDist) ; 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 ( const auto& tData : vTdata) { if ( ! m_pMchMgr->GetCurrSetupMgr().FindTool( tData.sName)) { string sErr = "Error : " + tData.sName + " missing in setup " ; LOG_ERROR( 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 nType ; int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dDist ; double dMaxSpeed ; m_pMchMgr->TdbGetCurrToolParam( TPA_TYPE, nType) ; 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_DIST, dDist) ; m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, dMaxSpeed) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTYPE, nType) ; 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_TDIST, dDist) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, dMaxSpeed) ; } bool bUsed = false ; for ( const auto& tData : vTdata) { if ( EqualNoCase( sTool, tData.sName)) { bUsed = true ; break ; } } bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TUSED, bUsed) ; // chiamo la funzione di emissione dati utensile bOk = bOk && CallOnToolData() ; } } // altrimenti emetto direttamente gli utensili else { // ordino l'elenco degli utensili 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_TTYPE, vTdata[i].nType) ; 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_TDIST, vTdata[i].dDist) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, vTdata[i].dMaxSpeed) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TUSED, true) ; // se esiste, chiamo la funzione di emissione dati utensile bOk = bOk && CallOnToolData() ; // 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_ERROR( GetEMkLogger(), sErr.c_str()) bOk = false ; } } } } return bOk ; } //---------------------------------------------------------------------------- bool Processor::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 && CallOnDispositionStart() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnDispositionEnd( void) { // chiamo la funzione di fine disposizione bool bOk = CallOnDispositionEnd() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::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 && CallOnTableData() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnTableAxisData( int nAxisInd, const string& sName, double dPos, bool bMoved) { // assegno dati movimento asse di tavola bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TAIND, nAxisInd) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TANAME, sName) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TAPOS, dPos) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TAMOVED, bMoved) ; // chiamo la funzione di gestione dati movimento asse di tavola bOk = bOk && CallOnTableAxisData() ; return true ; } //---------------------------------------------------------------------------- bool Processor::OnFixtureData( int nFixId, int nFixInd, const string& sName, const Point3d& ptPos, double dAngDeg, double dMov, const string& sTaLink) { // 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) ; if ( ! IsEmptyOrSpaces( sTaLink)) bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXTAL, sTaLink) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_FIXTAL) ; // chiamo la funzione di gestione dati bloccaggio bOk = bOk && CallOnFixtureData() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnRawMoveData( int nRawId, int nRawMoveInd, 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, nRawMoveInd) ; 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 && CallOnRawMoveData() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnToolSelect( const string& sTool, const string& sHead, int nExit, const string& sTcPos, bool bFloating) { // 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) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TFLOAT, bFloating) ; // assegno il token e il nome degli assi bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ; int nNumAxes = int( m_AxesName.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) { bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken( i, bIsRobot), m_AxesToken[i-1]) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisName( i, bIsRobot), m_AxesName[i-1]) ; } else { bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken( i, bIsRobot)) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisName( i, bIsRobot)) ; } } // chiamo la funzione di selezione utensile bOk = bOk && CallOnToolSelect() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnToolDeselect( const 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 && CallOnToolDeselect() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnMachiningStart( int nOpId, int nOpInd, double dSpeed, const Point3d& ptMin, const Point3d& ptMax, const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax) { // 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) ; // assegno punti estremi dell'ingombro degli assi della lavorazione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MAXMIN, vAxMin) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MAXMAX, vAxMax) ; // chiamo la funzione di inizio lavorazione bOk = bOk && CallOnMachiningStart() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnMachiningEnd( void) { // chiamo la funzione di fine lavorazione bool bOk = CallOnMachiningEnd() ; // reset eventuale Path in double bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_DBLPATHID) ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnPathStart( int nClPathId, int nClPathInd, int nDblPathId, int nAS, const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax, const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax, double dElev, const INTVECTOR& vActiveExit) { // 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 identificativo eventuale percorso in doppio if ( nDblPathId == GDB_ID_NULL) bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_DBLPATHID) ; else bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DBLPATHID, nDblPathId) ; // 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 punti estremi dell'ingombro degli assi della lavorazione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PAXMIN, vAxMin) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PAXMAX, vAxMax) ; // assegno la massima elevazione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ELEV, dElev) ; // assegno uscite attive per gruppi a forare bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DRACEX, vActiveExit) ; // chiamo la funzione di inizio percorso di lavorazione bOk = bOk && CallOnPathStart() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::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 && CallOnPathEnd() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnPathStartAux( int nInd, const string& sAS) { // 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 && CallOnPathStartAux() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnPathEndAux( int nInd, const string& sAE) { // 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 && CallOnPathEndAux() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnRapid( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd, int nAxesMask, const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux, int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext) { // cancello variabili estranee ResetArcData() ; // assegno Id e indice entità di movimento bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVEID, nEntId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVEIND, nEntInd) ; // assegno il tipo di movimento bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ; // assegno il valore degli assi bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ; int nNumAxes = int( AxesEnd.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot), AxesEnd[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot)) ; } // assegno la mascheratura degli assi bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MASK, nAxesMask) ; // assegno il valore del versore utensile bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIR, vtTool) ; // assegno il valore del versore correzione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_CDIR, vtCorr) ; // assegno il valore del versore ausiliario bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ADIR, vtAux) ; // assegno il valore del flag bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ; // assegno il valore del secondo flag bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG2, nFlag2) ; // assegno il valore dell'indice bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INDEX, nIndex) ; // anticipazione di alcuni dati dell'eventuale movimento successivo dello stesso percorso if ( nMoveNext != -1) { bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVESUCC, nMoveNext) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot), AxesNext[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ; } } else { bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_MOVESUCC) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ; } // chiamo la funzione di movimento in rapido bOk = bOk && CallOnRapid() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnLinear( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd, const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux, double dFeed, int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext) { // cancello variabili estranee ResetArcData() ; // assegno Id e indice entità di movimento bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVEID, nEntId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVEIND, nEntInd) ; // assegno il tipo di movimento bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ; // assegno il valore degli assi bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ; int nNumAxes = int( AxesEnd.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot), AxesEnd[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot)) ; } // assegno il valore del versore utensile bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIR, vtTool) ; // assegno il valore del versore correzione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_CDIR, vtCorr) ; // assegno il valore del versore ausiliario bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ADIR, vtAux) ; // 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) ; // assegno il valore del secondo flag bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG2, nFlag2) ; // assegno il valore dell'indice bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INDEX, nIndex) ; // anticipazione di alcuni dati dell'eventuale movimento successivo dello stesso percorso if ( nMoveNext != -1) { bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVESUCC, nMoveNext) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot), AxesNext[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ; } } else { bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_MOVESUCC) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ; } // chiamo la funzione di movimento in rapido bOk = bOk && CallOnLinear() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnArc( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd, const Point3d& ptCen, const Point3d& ptMid, double dRad, double dAngCen, const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux, double dFeed, int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext) { // assegno Id e indice entità di movimento bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVEID, nEntId) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVEIND, nEntInd) ; // assegno il tipo di movimento bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ; // assegno il valore degli assi bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ; int nNumAxes = int( AxesEnd.size()) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot), AxesEnd[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot)) ; } // 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 le coordinate del punto medio bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M1, ptMid.x) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M2, ptMid.y) ; bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M3, ptMid.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 del versore utensile bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIR, vtTool) ; // assegno il valore del versore correzione bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_CDIR, vtCorr) ; // assegno il valore del versore ausiliario bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ADIR, vtAux) ; // 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) ; // assegno il valore del secondo flag bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG2, nFlag2) ; // assegno il valore dell'indice bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INDEX, nIndex) ; // anticipazione di alcuni dati dell'eventuale movimento successivo dello stesso percorso if ( nMoveNext != -1) { bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVESUCC, nMoveNext) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) { if ( i <= nNumAxes) bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot), AxesNext[i-1]) ; else bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ; } } else { bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_MOVESUCC) ; for ( int i = 1 ; i <= MAX_AXES ; ++ i) bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ; } // chiamo la funzione di movimento in rapido bOk = bOk && CallOnArc() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::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_M1) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_M2) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_M3) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_RR) ; bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_AC) ; return bOk ; }