Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
63f34925669a600aa870bef5a446df21fa64e84b
EgtMachKernel/Generator.cpp
T
Dario Sassi 63f3492566 EgtMachKernel 1.6n2 : 
- la funzione IsNotEmpty è stata sostituita dalla IsEmpty.
2016-02-09 09:49:26 +00:00

748 lines
29 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : Generator.cpp Data : 28.10.15 Versione : 1.6j4
// Contenuto : Implementazione della classe generator.
//
//
//
// Modifiche : 28.10.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "DllMain.h"
#include "Generator.h"
#include "MachMgr.h"
#include "Disposition.h"
#include "Machining.h"
#include "MachiningConst.h"
#include "/EgtDev/Include/EMkToolConst.h"
#include "/EgtDev/Include/EMkOperationConst.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGnFileUtils.h"
using namespace std ;
//----------------------------------------------------------------------------
static const string ERR_EXT = ".err" ;
static const int MAX_AXES = 5 ;
static const string GLOB_VAR = "EMT" ; // tavola variabili globali
static const string GVAR_USETO1 = ".USETO1" ; // (bool) flag per utilizzo origine tavola
static const string GVAR_MODAL = ".MODAL" ; // (bool) flag per emissione modale dei valori
static const string GVAR_NUM = ".NUM" ; // (bool) flag numerazione
static const string GVAR_NUMTOK = ".Nt" ; // (string) token per numerazione
static const string GVAR_LINENBR = ".LINENBR" ; // (int) numero progressivo di linea
static const string GVAR_LINEINC = ".LINEINC" ; // (int) incremento per numero di linea
static const string GVAR_F = ".F" ; // (num) valore della feed
static const string GVAR_FTOK = ".Ft" ; // (string) token per feed
static const string GVAR_S = ".S" ; // (num) valore della speed
static const string GVAR_STOK = ".St" ; // (string) token per speed
static const string GVAR_FILE = ".FILE" ; // (string) path file di output
static const string GVAR_INFO = ".INFO" ; // (string) informazioni iniziali
static const string GVAR_DISPID = ".DISPID" ; // (int) identificativo disposizione
static const string GVAR_DISPIND = ".DISPIND" ; // (int) indice disposizione
static const string GVAR_TABNAME = ".TABNAME" ; // (string) nome tavola
static const string GVAR_TABORI1 = ".TABORI1" ; // (Point3d) prima origine di tavola
static const string GVAR_FIXID = ".FIXID" ; // (int) identificativo bloccaggio (fixture)
static const string GVAR_FIXIND = ".FIXIND" ; // (int) indice bloccaggio
static const string GVAR_FIXNAME = ".FIXNAME" ; // (string) nome bloccaggio
static const string GVAR_FIXPOS = ".FIXPOS" ; // (Point3d) posizione bloccaggio
static const string GVAR_FIXANG = ".FIXANG" ; // (num) angolo di rotazione bloccaggio
static const string GVAR_RAWID = ".RAWID" ; // (int) identificativo grezzo
static const string GVAR_RAWIND = ".RAWIND" ; // (int) indice movimento del grezzo
static const string GVAR_RAWTYPE = ".RAWTYPE" ; // (int) tipo di movimento del grezzo
static const string GVAR_RAWPOS = ".RAWPOS" ; // (Point3d) posizione di movimento del grezzo
static const string GVAR_RAWFLAG = ".RAWFLAG" ; // (int) flag per movimento del grezzo
static const string GVAR_MCHID = ".MCHID" ; // (int) identificativo lavorazione
static const string GVAR_MCHIND = ".MCHIND" ; // (int) indice lavorazione
static const string GVAR_PATHID = ".PATHID" ; // (int) identificativo percorso di lavorazione
static const string GVAR_PATHIND = ".PATHIND" ; // (int) indice percorso di lavorazione
static const string GVAR_L1 = ".L1" ; // (num) valore del primo asse lineare
static const string GVAR_L2 = ".L2" ; // (num) valore del secondo asse lineare
static const string GVAR_L3 = ".L3" ; // (num) valore del terzo asse lineare
static const string GVAR_R1 = ".R1" ; // (num) valore del primo asse rotante
static const string GVAR_R2 = ".R2" ; // (num) valore del secondo asse rotante
static const string GVAR_L1P = ".L1p" ; // (num) valore precedente del primo asse lineare
static const string GVAR_L2P = ".L2p" ; // (num) valore precedente del secondo asse lineare
static const string GVAR_L3P = ".L3p" ; // (num) valore precedente del terzo asse lineare
static const string GVAR_R1P = ".R1p" ; // (num) valore precedente del primo asse rotante
static const string GVAR_R2P = ".R2p" ; // (num) valore precedente del secondo asse rotante
static const string GVAR_L1T = ".L1t" ; // (num) token del primo asse lineare
static const string GVAR_L2T = ".L2t" ; // (num) token del secondo asse lineare
static const string GVAR_L3T = ".L3t" ; // (num) token del terzo asse lineare
static const string GVAR_R1T = ".R1t" ; // (num) token del primo asse rotante
static const string GVAR_R2T = ".R2t" ; // (num) token del secondo asse rotante
static const string GVAR_MASK = ".MASK" ; // (int) mask associato ai movimenti in rapido
static const string GVAR_FLAG = ".FLAG" ; // (int) flag associato ad ogni movimento
static const string TEMP_VAR = "LOC" ; // tavola variabili locali (temporanee)
static const string ON_START = "OnStart" ;
static const string ON_END = "OnEnd" ;
static const string ON_PROGRAM_START = "OnProgramStart" ;
static const string ON_PROGRAM_END = "OnProgramEnd" ;
static const string ON_TOOL_SELECT = "OnToolSelect" ;
static const string ON_TOOL_DESELECT = "OnToolDeselect" ;
static const string ON_DISPOSITION_START = "OnDispositionStart" ;
static const string ON_DISPOSITION_END = "OnDispositionEnd" ;
static const string ON_TABLE_DATA = "OnTableData" ;
static const string ON_FIXTURE_DATA = "OnFixtureData" ;
static const string ON_RAWMOVE_DATA = "OnRawMoveData" ;
static const string ON_MACHINING_START = "OnMachiningStart" ;
static const string ON_MACHINING_END = "OnMachiningEnd" ;
static const string ON_PATH_START = "OnPathStart" ;
static const string ON_PATH_END = "OnPathEnd" ;
static const string ON_RAPID = "OnRapid" ;
static const string ON_LINEAR = "OnLinear" ;
static const string ON_ARC = "OnArc" ;
//----------------------------------------------------------------------------
Generator::Generator( void)
{
m_pMchMgr = nullptr ;
m_pGeomDB = nullptr ;
m_pMachine = nullptr ;
m_sPrevTool.clear() ;
m_sTool.clear() ;
m_AxesName.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_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 ;
// evento inizio esecuzione
bool bOk = true ;
if ( bOk && ! OnStart()) {
bOk = false ;
LOG_INFO( GetEMkLogger(), "OnStart error") ;
}
// apertura file di output ed evento inizio programma
if ( bOk && ! OnProgramStart( sCncFile, sInfo)) {
bOk = false ;
LOG_INFO( GetEMkLogger(), "OnProgramStart 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
switch ( m_pMchMgr->GetOperationType( nOpId)) {
case OPER_DISP :
if ( ! ProcessDisposition( nOpId, nInd))
bOk = false ;
break ;
case OPER_DRILLING :
case OPER_SAWING :
case OPER_MILLING :
if ( ! ProcessMachining( nOpId, nInd))
bOk = false ;
break ;
default :
break ;
}
// 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 ( bOk && ! OnEnd()) {
bOk = false ;
LOG_INFO( GetEMkLogger(), "OnEnd error") ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::ProcessDisposition( int nOpId, int nOpInd)
{
// Parametri della disposizione
Disposition* pDisp = dynamic_cast<Disposition*>( m_pGeomDB->GetUserObj( nOpId)) ;
if ( pDisp == nullptr)
return false ;
// Emetto inizio disposizione
if ( ! OnDispositionStart( nOpId, nOpInd))
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 ;
if ( pDisp->GetFixtureData( i, sName, nId, ptPos, dAngDeg)) {
if ( ! OnFixtureData( nId, i + 1, sName, ptPos, dAngDeg))
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 ;
}
// Emetto fine disposizione
if ( ! OnDispositionEnd())
return false ;
return true ;
}
//----------------------------------------------------------------------------
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->IsEmpty())
return true ;
// Recupero l'utensile della lavorazione corrente
string sTool ;
if ( ! m_pMchMgr->GetMachiningParam( MPA_TOOL, sTool))
return false ;
// Se utensile cambierà
if ( ! m_sTool.empty() && m_sTool != sTool) {
// emetto deselezione vecchio utensile
if ( ! OnToolDeselect())
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) {
if ( ! OnToolSelect())
return false ;
}
// Emetto inizio lavorazione
if ( ! OnMachiningStart( nOpId, nOpInd))
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)
{
// Emetto inizio percorso di lavoro
if ( ! OnPathStart( nClPathId, nClPathInd))
return false ;
// Ciclo su tutte le entità del percorsi 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) ;
}
// Emetto fine percorso di lavoro
bOk = bOk && OnPathEnd() ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd, int nOpId, int nOpInd)
{
// Recupero i dati Cam
CamData* pCamData = dynamic_cast<CamData*>( m_pGeomDB->GetUserObj( nEntId)) ;
if ( pCamData == nullptr || pCamData->GetAxesStatus() != CamData::AS_OK)
return false ;
const DBLVECTOR& AxesEnd = pCamData->GetAxisVal() ;
// Verifico se movimento in rapido
bool bRapid = ( pCamData->GetFeed() < EPS_SMALL) ;
// Emetto movimento
if ( bRapid) {
if ( ! OnRapid( AxesEnd, pCamData->GetAxesMask(), pCamData->GetFlag()))
return false ;
}
else {
if ( ! OnLinear( AxesEnd, pCamData->GetFeed(), pCamData->GetFlag()))
return false ;
}
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
string sHead ; m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ;
int nExit ; m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ;
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) ;
}
//----------------------------------------------------------------------------
bool
Generator::OnStart( void)
{
// definisco tavola variabili globali
bool bOk = m_pMachine->LuaCreateGlobTable( GLOB_VAR) ;
// definisco tavola variabili locali (temporanee)
bOk = bOk && m_pMachine->LuaCreateGlobTable( TEMP_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_FTOK, "F") ;
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_STOK, "S") ;
// chiamo la funzione
bOk = bOk && m_pMachine->LuaCallFunction( ON_START) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnEnd( void)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// chiamo la funzione
bOk = bOk && m_pMachine->LuaCallFunction( ON_END) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnProgramStart( const string& sCncFile, const string& sInfo)
{
// apro il file di output
bool bOk = m_pMachine->WriterOpen( sCncFile) ;
if ( ! bOk)
LOG_INFO( GetEMkLogger(), "Error opening Cnc file") ;
// assegno nome file
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FILE, sCncFile) ;
// definisco tavola variabili locali (temporanee)
bOk = bOk && m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno info
string sTxt = sInfo + " " + CurrDateTime() ;
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INFO, sTxt) ;
// chiamo la funzione di inizio programma
bOk = bOk && m_pMachine->LuaCallFunction( ON_PROGRAM_START) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnProgramEnd( void)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// chiamo fine programma
bOk = bOk && m_pMachine->LuaCallFunction( ON_PROGRAM_END) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnDispositionStart( int nOpId, int nOpInd)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno identificativo e indice disposizione
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPID, nOpId) ;
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPIND, nOpInd) ;
// chiamo la funzione di inizio disposizione
bOk = bOk && m_pMachine->LuaCallFunction( ON_DISPOSITION_START) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnDispositionEnd( void)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// chiamo la funzione di fine disposizione
bOk = bOk && m_pMachine->LuaCallFunction( ON_DISPOSITION_END) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnTableData( const string& sName, const Point3d& ptOri1)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno nome tavola e valore riferimento
bOk = 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) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnFixtureData( int nFixId, int nFixInd, const string& sName, const Point3d& ptPos, double dAngDeg)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno dati bloccaggio
bOk = 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) ;
// chiamo la funzione di gestione dati bloccaggio
bOk = bOk && m_pMachine->LuaCallFunction( ON_FIXTURE_DATA) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnRawMoveData( int nRawId, int RawMoveInd, int nType, const Point3d& ptPos, int nFlag)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno dati bloccaggio
bOk = 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) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnToolSelect( void)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno 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_AxesName[i-1]) ;
else
bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken(i)) ;
}
// chiamo la funzione di selezione utensile
bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_SELECT) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnToolDeselect( void)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// chiamo la funzione di deselezione utensile
bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_DESELECT) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnMachiningStart( int nOpId, int nOpInd)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno identificativo e indice lavorazione
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHID, nOpId) ;
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHIND, nOpInd) ;
// chiamo la funzione di inizio lavorazione
bOk = bOk && m_pMachine->LuaCallFunction( ON_MACHINING_START) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnMachiningEnd( void)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// chiamo la funzione di fine lavorazione
bOk = bOk && m_pMachine->LuaCallFunction( ON_MACHINING_END) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnPathStart( int nClPathId, int nClPathInd)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// assegno identificativo e indice percorso di lavorazione
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHID, nClPathId) ;
bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHIND, nClPathInd) ;
// chiamo la funzione di inizio percorso di lavorazione
bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_START) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnPathEnd( void)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// chiamo la funzione di fine percorso di lavorazione
bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_END) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnRapid( const DBLVECTOR& AxesEnd, int nAxesMask, int nFlag)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// 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) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnLinear( const DBLVECTOR& AxesEnd, double dFeed, int nFlag)
{
// definisco tavola variabili locali (temporanee)
bool bOk = m_pMachine->LuaCreateGlobTable( TEMP_VAR) ;
// 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) ;
// cancello variabili locali
bOk = bOk && m_pMachine->LuaResetGlobVar( TEMP_VAR) ;
return bOk ;
}
//----------------------------------------------------------------------------
string
Generator::GetGlobVarAxisValue( int nAx)
{
switch ( nAx) {
case 1 : return ( GLOB_VAR + GVAR_L1) ;
case 2 : return ( GLOB_VAR + GVAR_L2) ;
case 3 : return ( GLOB_VAR + GVAR_L3) ;
case 4 : return ( GLOB_VAR + GVAR_R1) ;
case 5 : return ( GLOB_VAR + GVAR_R2) ;
default : return "" ;
}
}
//----------------------------------------------------------------------------
string
Generator::GetGlobVarAxisPrev( int nAx)
{
switch ( nAx) {
case 1 : return ( GLOB_VAR + GVAR_L1P) ;
case 2 : return ( GLOB_VAR + GVAR_L2P) ;
case 3 : return ( GLOB_VAR + GVAR_L3P) ;
case 4 : return ( GLOB_VAR + GVAR_R1P) ;
case 5 : return ( GLOB_VAR + GVAR_R2P) ;
default : return "" ;
}
}
//----------------------------------------------------------------------------
string
Generator::GetGlobVarAxisToken( int nAx)
{
switch ( nAx) {
case 1 : return ( GLOB_VAR + GVAR_L1T) ;
case 2 : return ( GLOB_VAR + GVAR_L2T) ;
case 3 : return ( GLOB_VAR + GVAR_L3T) ;
case 4 : return ( GLOB_VAR + GVAR_R1T) ;
case 5 : return ( GLOB_VAR + GVAR_R2T) ;
default : return "" ;
}
}
Reference in New Issue View Git Blame Copy Permalink