Dario Sassi
614532c2a0
- aggiunta impostazione variabile EMT.DBLPATHID anche per generazione e simulazione quando è il caso.
1242 lines
52 KiB
C++
1242 lines
52 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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<MyToolData> 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 ;
|
|
}
|