//---------------------------------------------------------------------------- // 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 -------------------------------------- // 1001 = "Error with setup : xxx" // 1002 = "Error opening Cnc file" //---------------------------------------------------------------------------- static const string ERR_EXT = ".err" ; //---------------------------------------------------------------------------- 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 ; // 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") ; } 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( 1001, 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 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 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()) 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 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) { // 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 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, vAxMin, vAxMax, 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 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() ; // Emetto movimento int nMove = pCamData->GetMoveType() ; switch ( nMove) { case 0 : // rapido if ( ! OnRapid( nMove, AxesEnd, pCamData->GetAxesMask(), pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex())) return false ; break ; case 1 : // linea if ( ! OnLinear( nMove, AxesEnd, pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(), pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex())) 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( nMove, AxesEnd, pCamData->GetAxesCen(), ptMid, pCamData->GetAxesRad(), pCamData->GetAxesAngCen(), pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(), pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex())) 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->GetAllCurrAxesName( m_AxesName) && m_pMachine->GetAllCurrAxesToken( 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( 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 && 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 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 ( 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 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) ; } 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_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) ; 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::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 && CallOnFixtureData() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::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 && CallOnRawMoveData() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::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 && 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() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnPathStart( int nClPathId, int nClPathInd, 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) { // 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 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) ; // 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 nMove, const DBLVECTOR& AxesEnd, int nAxesMask, const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux, int nFlag, int nFlag2, int nIndex) { // 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 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) ; // chiamo la funzione di movimento in rapido bOk = bOk && CallOnRapid() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnLinear( int nMove, const DBLVECTOR& AxesEnd, const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux, double dFeed, int nFlag, int nFlag2, int nIndex) { // 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 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) ; // chiamo la funzione di movimento in rapido bOk = bOk && CallOnLinear() ; return bOk ; } //---------------------------------------------------------------------------- bool Processor::OnArc( 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) { // 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 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) ; // 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 ; }