Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
03dd454ef9ba7bf7586ec2c8ddf638a2c24f9187
EgtMachKernel/Generator.cpp
T
Dario Sassi 03dd454ef9 EgtMachKernel : 
- aggiunta gestione attrezzaggio anche in simulazione
- in ToolDeselect aggiunto nome prossimo utensile EMT.NEXTTOOL.
2017-01-19 11:32:39 +00:00

978 lines
38 KiB
C++
Raw Blame History

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