Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
06a8b15d99beae5024aefe00fc64ab9a8065b190
EgtMachKernel/Generator.cpp
T
Dario Sassi 06a8b15d99 EgtMachKernel 1.6p3 : 
- gestione script OnSetTable in file mde per modificare dati assi
- migliorato sequenziamento curve per lavorazione
- eliminata tabella LOC per variabili locali in generazione part program
- aggiunte funzioni EmtModifyAxisStroke e EmtModifyAxisHome richiamabili da lua macchina
- aggiunta ExistsTable in interfaccia.
2016-04-19 15:55:10 +00:00

763 lines
30 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 "/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_FT = ".Ft" ; // (string) token per feed
static const string GVAR_S = ".S" ; // (num) valore della speed
static const string GVAR_ST = ".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_PHASE = ".PHASE" ; // (int) indice fase
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_MOVE = ".MOVE" ; // (int) tipo di movimento (0,1,2,3)
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_C1 = ".C1" ; // (num) valore del primo asse lineare per centro arco
static const string GVAR_C2 = ".C2" ; // (num) valore del secondo asse lineare per centro arco
static const string GVAR_C3 = ".C3" ; // (num) valore del terzo asse lineare per centro arco
static const string GVAR_RR = ".RR" ; // (num) valore raggio per arco
static const string GVAR_AC = ".AC" ; // (num) valore angolo al centro per arco
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_C1T = ".C1t" ; // (num) token del primo asse lineare per centro arco
static const string GVAR_C2T = ".C2t" ; // (num) token del secondo asse lineare per centro arco
static const string GVAR_C3T = ".C3t" ; // (num) token del terzo asse lineare per centro arco
static const string GVAR_RRT = ".RRt" ; // (num) token del raggio per arco
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 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
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 ( bOk && ! 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) ;
// Emetto inizio disposizione
if ( ! OnDispositionStart( nOpId, nOpInd, nPhase))
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->IsMachiningEmpty())
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 ;
}
// 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)
{
// 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 = 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
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) ;
// 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) ;
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) ;
// 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) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnProgramEnd( void)
{
// chiamo fine programma
bool bOk = m_pMachine->LuaCallFunction( ON_PROGRAM_END) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnDispositionStart( int nOpId, int nOpInd, int nPhase)
{
// 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) ;
// 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)
{
// 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) ;
// 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( void)
{
// assegno il nome degli assi
bool bOk = true ;
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) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnToolDeselect( void)
{
// chiamo la funzione di deselezione utensile
bool 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)
{
// 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) ;
// chiamo la funzione di inizio percorso di lavorazione
bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_START) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Generator::OnPathEnd( void)
{
// chiamo la funzione di fine percorso di lavorazione
bool bOk = m_pMachine->LuaCallFunction( ON_PATH_END) ;
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 ;
}
//----------------------------------------------------------------------------
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