Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e16e604ec71318ea80f5f796d6bf4a8d67e901c
EgtMachKernel/MachineLua.cpp
T
Dario Sassi 0c3e6c83d2 EgtMachKernel : 
- aggiunta funzione lua EmtGetCurrAxesHomePos.
2025-07-02 08:57:03 +02:00

1645 lines
59 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2015-2024
//----------------------------------------------------------------------------
// File : MachineLua.cpp Data : 01.09.24 Versione : 2.6i1
// Contenuto : Implementazione gestione macchina : funzioni Lua.
//
//
//
// Modifiche : 06.05.15 DS Creazione modulo.
// 26.04.20 DS Aggiunta gestione TcPos.
// 05.08.24 DS Aggiunta gestione SpecialEstimate.
// 01.09.24 DS SpecialEstimate è diventato MultiProcess.
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeSetModifiedOff.h"
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGnFileUtils.h"
using namespace std ;
//----------------------------------------------------------------------------
static const string FLD_FILE = "File" ;
static const string FLD_OFFSET = "Offset" ;
static const string FLD_SPECIAL = "Special" ;
static const string FLD_PROCESSOR = "Processor" ;
static const string FLD_AXISMAXADJUST = "AxisMaxAdjust" ;
static const string FLD_AXISMAXROTADJ = "AxisMaxRotAdj" ;
static const string FLD_EXITMAXADJUST = "ExitMaxAdjust" ;
static const string FLD_EXITMAXROTADJ = "ExitMaxRotAdj" ;
static const string FLD_ANGDELTAMINFORHOME = "AngDeltaMinForHome" ;
static const string FLD_MULTIPROCESS = "MultiProcess" ;
static const string FLD_LINKAXESMOVEORDER = "LinkAxesMoveOrder" ;
static const string FLD_NEWLINKMGR = "NewLinkMgr" ;
static const string FLD_NAME = "Name" ;
static const string FLD_PARENT = "Parent" ;
static const string FLD_GEO = "Geo" ;
static const string FLD_AUX = "Aux" ;
static const string FLD_TOKEN = "Token" ;
static const string FLD_TYPE = "Type" ;
static const string FLD_USE = "Use" ;
static const string FLD_INVERT = "Invert" ;
static const string FLD_AXIS_OFFSET = "Offset" ;
static const string FLD_REF1 = "Ref1" ;
static const string FLD_SCALE = "Scale" ;
static const string FLD_EXIT_NBR = "ExitNbr" ;
static const string FLD_POS = "Pos" ;
static const string FLD_DIR = "Dir" ;
static const string FLD_STROKE = "Stroke" ;
static const string FLD_HOME = "Home" ;
static const string FLD_ADJUSTAUX = "AdjustAux" ;
static const string FLD_HSET = "HSet" ;
static const string FLD_SEL_TYPE = "SelType" ;
static const string FLD_TDIR = "TDir" ;
static const string FLD_ADIR = "ADir" ;
static const string FLD_ROT1W = "Rot1W" ;
static const string FLD_MAXDELTAR2ON1 = "MaxDeltaR2OnFirst" ;
static const string FLD_ROT2STROKE = "Rot2Stroke" ;
static const string FLD_SOLCH = "SolCh" ;
static const string FLD_OTHCOLL = "OthColl" ;
static const string FLD_COLL = "Coll" ;
//----------------------------------------------------------------------------
Machine* Machine::m_pMchLua = nullptr ;
//----------------------------------------------------------------------------
bool
Machine::LuaInit( const string& sMachineName)
{
// inizializzo l'interprete lua
if ( ! m_LuaMgr.Init())
return false ;
// carico le funzioni speciali
if ( ! LuaInstallEgtFunctions( m_LuaMgr))
return false ;
// recupero la versione di Lua
string sLua ;
if ( m_LuaMgr.GetVersion( sLua))
sLua += " machine interpreter started" ;
else
sLua = "Lua *.* machine interpreter started" ;
sLua += " (" + sMachineName + ")" ;
LOG_INFO( GetEMkLogger(), sLua.c_str())
// imposto il direttorio delle librerie
m_LuaMgr.SetLuaLibsDir( m_pMchMgr->GetLuaLibsDir()) ;
// carico la libreria standard
m_LuaMgr.Require( m_pMchMgr->GetLuaLastRequire()) ;
// registro le funzioni di lettura macchina per lua
m_LuaMgr.RegisterFunction( "EmtGeneral", Machine::LuaEmtGeneral) ;
m_LuaMgr.RegisterFunction( "EmtBase", Machine::LuaEmtBase) ;
m_LuaMgr.RegisterFunction( "EmtTable", Machine::LuaEmtTable) ;
m_LuaMgr.RegisterFunction( "EmtAxis", Machine::LuaEmtAxis) ;
m_LuaMgr.RegisterFunction( "EmtHead", Machine::LuaEmtHead) ;
m_LuaMgr.RegisterFunction( "EmtTcPos", Machine::LuaEmtTcPos) ;
// registro le funzioni di modifica macchina per lua
m_LuaMgr.RegisterFunction( "EmtModifyAxisPosition", Machine::LuaEmtModifyAxisPosition) ;
m_LuaMgr.RegisterFunction( "EmtModifyAxisDirection", Machine::LuaEmtModifyAxisDirection) ;
m_LuaMgr.RegisterFunction( "EmtModifyAxisStroke", Machine::LuaEmtModifyAxisStroke) ;
m_LuaMgr.RegisterFunction( "EmtModifyAxisHome", Machine::LuaEmtModifyAxisHome) ;
m_LuaMgr.RegisterFunction( "EmtModifyHeadAuxDirection", Machine::LuaEmtModifyHeadAuxDirection) ;
m_LuaMgr.RegisterFunction( "EmtModifyExitPosition", Machine::LuaEmtModifyExitPosition) ;
m_LuaMgr.RegisterFunction( "EmtLinkRawPartToGroup", Machine::LuaEmtLinkRawPartToGroup) ;
m_LuaMgr.RegisterFunction( "EmtGetAllLinkedRawParts", Machine::LuaEmtGetAllLinkedRawParts) ;
m_LuaMgr.RegisterFunction( "EmtUnlinkRawPartFromGroup", Machine::LuaEmtUnlinkRawPartFromGroup) ;
m_LuaMgr.RegisterFunction( "EmtUnlinkAllRawPartsFromGroups", Machine::LuaEmtUnlinkAllRawPartsFromGroups) ;
m_LuaMgr.RegisterFunction( "EmtLinkFixtureToGroup", Machine::LuaEmtLinkFixtureToGroup) ;
m_LuaMgr.RegisterFunction( "EmtUnlinkFixtureFromGroup", Machine::LuaEmtUnlinkFixtureFromGroup) ;
m_LuaMgr.RegisterFunction( "EmtUnlinkAllFixturesFromGroups", Machine::LuaEmtUnlinkAllFixturesFromGroups) ;
m_LuaMgr.RegisterFunction( "EmtLinkPartToGroup", Machine::LuaEmtLinkPartToGroup) ;
m_LuaMgr.RegisterFunction( "EmtUnlinkPartFromGroup", Machine::LuaEmtUnlinkPartFromGroup) ;
m_LuaMgr.RegisterFunction( "EmtUnlinkAllPartsFromGroups", Machine::LuaEmtUnlinkAllPartsFromGroups) ;
// registro le funzioni di definizione entità CL per lua
m_LuaMgr.RegisterFunction( "EmtAddRapidStart", Machine::LuaEmtAddRapidStart) ;
m_LuaMgr.RegisterFunction( "EmtAddRapidMove", Machine::LuaEmtAddRapidMove) ;
m_LuaMgr.RegisterFunction( "EmtAddLinearMove", Machine::LuaEmtAddLinearMove) ;
m_LuaMgr.RegisterFunction( "EmtAddArcMove", Machine::LuaEmtAddArcMove) ;
m_LuaMgr.RegisterFunction( "EmtAddClimb", Machine::LuaEmtAddClimb) ;
m_LuaMgr.RegisterFunction( "EmtRemoveClimb", Machine::LuaEmtRemoveClimb) ;
m_LuaMgr.RegisterFunction( "EmtAddRise", Machine::LuaEmtAddRise) ;
m_LuaMgr.RegisterFunction( "EmtRemoveRise", Machine::LuaEmtRemoveRise) ;
m_LuaMgr.RegisterFunction( "EmtGetInitialAxesPos", Machine::LuaEmtGetInitialAxesPos) ;
m_LuaMgr.RegisterFunction( "EmtGetFinalAxesPos", Machine::LuaEmtGetFinalAxesPos) ;
m_LuaMgr.RegisterFunction( "EmtGetCurrAxesHomePos", Machine::LuaEmtGetCurrAxesHomePos) ;
// registro le funzioni di lettura entità CL per lua
m_LuaMgr.RegisterFunction( "EmtGetMoveType", Machine::LuaEmtGetMoveType) ;
m_LuaMgr.RegisterFunction( "EmtGetAxesPos", Machine::LuaEmtGetAxesPos) ;
m_LuaMgr.RegisterFunction( "EmtGetBackAuxDir", Machine::LuaEmtGetBackAuxDir) ;
// registro le funzioni di scrittura part program per lua
m_LuaMgr.RegisterFunction( "EmtWrite", Machine::LuaEmtWrite) ;
// registro la funzione per impostare informazioni di outstroke
m_LuaMgr.RegisterFunction( "EmtSetOutstrokeInfo", Machine::LuaEmtSetOutstrokeInfo) ;
// registro la funzione per impostare informazioni di errore
m_LuaMgr.RegisterFunction( "EmtSetLastError", Machine::LuaEmtSetLastError) ;
// registro la funzione per aggiungere informazioni di warning
m_LuaMgr.RegisterFunction( "EmtSetWarning", Machine::LuaEmtSetWarning) ;
// registro la funzione per aggiungere un oggetto da verificare per la collisione in simulazione
m_LuaMgr.RegisterFunction( "EmtAddCollisionObj", Machine::LuaEmtAddCollisionObj) ;
// registro la funzione estesa per aggiungere un oggetto da verificare per la collisione in simulazione
m_LuaMgr.RegisterFunction( "EmtAddCollisionObjEx", Machine::LuaEmtAddCollisionObjEx) ;
// registro la funzione di esecuzione della verifica di collisione in simulazione
m_LuaMgr.RegisterFunction( "EmtExecCollisionCheck", Machine::LuaEmtExecCollisionCheck) ;
// registro la funzione di gestione della collisione in simulazione
m_LuaMgr.RegisterFunction( "EmtOnCollision", Machine::LuaEmtOnCollision) ;
// registro la funzione di impostazione del primo utensile per virtual milling in simulazione
m_LuaMgr.RegisterFunction( "EmtSetToolForVmill", Machine::LuaEmtSetToolForVmill) ;
// registro la funzione di impostazione di utensile aggiuntivo per virtual milling in simulazione
m_LuaMgr.RegisterFunction( "EmtAddToolForVmill", Machine::LuaEmtAddToolForVmill) ;
// registro la funzione per abilitare/disabilitare l'esecuzione del virtual milling
m_LuaMgr.RegisterFunction( "EmtEnableToolsForVmill", Machine::LuaEmtEnableToolsForVmill) ;
// registro la funzione di movimento assi in simulazione
m_LuaMgr.RegisterFunction( "EmtMoveAxes", Machine::LuaEmtMoveAxes) ;
// registro la funzione di salvataggio comandi in simulazione MP
m_LuaMgr.RegisterFunction( "EmtSaveCmd", Machine::LuaEmtSaveCmd) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Machine::LuaExit( void)
{
// chiudo lua ( se era aperto)
if ( m_LuaMgr.Exit()) {
string sLua = "Lua machine interpreter closed (" + m_sName + ")" ;
LOG_INFO( GetEMkLogger(), sLua.c_str())
}
return true ;
}
//----------------------------------------------------------------------------
bool
Machine::LuaExistsFunction( const string& sFun) const
{
// imposto contesto corretto
int nOldCtx = ExeGetCurrentContext() ;
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
// imposto l'oggetto corrente per Lua
Machine* pOldMchLua = m_pMchLua ;
m_pMchLua = const_cast<Machine*>( this) ;
// verifico esistenza della funzione
bool bOk = m_LuaMgr.ExistsFunction( sFun) ;
// ripristino contesto originale
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( nOldCtx) ;
// ripristino dell'oggetto corrente per Lua
m_pMchLua = pOldMchLua ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Machine::LuaCallFunction( const string& sFun, bool bSetModifiedOff)
{
// imposto contesto corretto
int nOldCtx = ExeGetCurrentContext() ;
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
// se richiesto, disabilito gestione segnalazione modifiche progetto
bool bOldMod = false ;
if ( bSetModifiedOff) {
bOldMod = ExeGetEnableModified() ;
ExeDisableModified() ;
}
// imposto l'oggetto corrente per Lua
Machine* pOldMchLua = m_pMchLua ;
m_pMchLua = this ;
// eseguo la funzione
bool bOk = m_LuaMgr.CallFunction( sFun, 0) ;
// ripristino gestione segnalazione modifiche progetto
if ( bSetModifiedOff && bOldMod)
ExeEnableModified() ;
// ripristino contesto originale
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( nOldCtx) ;
// ripristino dell'oggetto corrente per Lua
m_pMchLua = pOldMchLua ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Machine::LuaCreateGlobTable( const string& sName)
{
// imposto contesto corretto
int nOldCtx = ExeGetCurrentContext() ;
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
// imposto l'oggetto corrente per Lua
Machine* pOldMchLua = m_pMchLua ;
m_pMchLua = this ;
// eseguo la funzione
bool bOk = ::LuaCreateGlobTable( m_LuaMgr.GetLuaState(), sName) ;
// ripristino contesto originale
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( nOldCtx) ;
// ripristino dell'oggetto corrente per Lua
m_pMchLua = pOldMchLua ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Machine::LuaResetGlobVar( const string& sName)
{
// imposto contesto corretto
int nOldCtx = ExeGetCurrentContext() ;
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
// imposto l'oggetto corrente per Lua
Machine* pOldMchLua = m_pMchLua ;
m_pMchLua = this ;
// eseguo la funzione
bool bOk = ::LuaResetGlobVar( m_LuaMgr.GetLuaState(), sName) ;
// ripristino contesto originale
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( nOldCtx) ;
// ripristino dell'oggetto corrente per Lua
m_pMchLua = pOldMchLua ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Machine::LuaChangeNameGlobVar( const string& sOldName, const string& sNewName)
{
// imposto contesto corretto
int nOldCtx = ExeGetCurrentContext() ;
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
// imposto l'oggetto corrente per Lua
Machine* pOldMchLua = m_pMchLua ;
m_pMchLua = this ;
// eseguo la funzione
bool bExists = ::LuaChangeNameGlobVar( m_LuaMgr.GetLuaState(), sOldName, sNewName) ;
// ripristino contesto originale
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( nOldCtx) ;
// ripristino dell'oggetto corrente per Lua
m_pMchLua = pOldMchLua ;
return bExists ;
}
//----------------------------------------------------------------------------
bool
Machine::LuaLoadMachine( const string& sFile)
{
// info
string sOut = "LuaLoadMachine : " + sFile ;
LOG_INFO( GetEMkLogger(), sOut.c_str())
// imposto contesto corretto
int nOldCtx = ExeGetCurrentContext() ;
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
// disabilito gestione segnalazione modifiche progetto
SetModifiedOff modOff ;
// imposto l'oggetto corrente per Lua
Machine* pOldMchLua = m_pMchLua ;
m_pMchLua = this ;
// carico la macchina
bool bOk = m_LuaMgr.ExecFile( sFile) ;
// verifico sia stato caricato effettivamente qualcosa
if ( bOk) {
if ( m_pGeomDB == nullptr || m_pGeomDB->GetGroupObjs( m_nGroupId) == 0) {
LOG_ERROR( GetEMkLogger(), "Error : mlde file is empty")
bOk = false ;
}
}
// ripristino gestione segnalazione modifiche progetto
modOff.Reset() ;
// ripristino contesto originale
if ( nOldCtx != m_pMchMgr->GetContextId())
ExeSetCurrentContext( nOldCtx) ;
// ripristino dell'oggetto corrente per Lua
m_pMchLua = pOldMchLua ;
return bOk ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtGeneral( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'File' dalla tabella
string sFile ;
LuaCheckTabFieldParam( L, 1, FLD_FILE, sFile)
// lettura eventuale campo 'Offset' dalla tabella (default 0,0,0)
Vector3d vtOffset ;
LuaGetTabFieldParam( L, 1, FLD_OFFSET, vtOffset) ;
// lettura eventuale campo 'Special' dalla tabella
string sSpecial ;
LuaGetTabFieldParam( L, 1, FLD_SPECIAL, sSpecial) ;
// lettura eventuale campo 'Processor' dalla tabella
string sProcessor ;
LuaGetTabFieldParam( L, 1, FLD_PROCESSOR, sProcessor) ;
// lettura eventuale campo 'AxisMaxAdjust' dalla tabella (default EPS_SMALL)
double dAxisMaxAdjust = EPS_SMALL ;
LuaGetTabFieldParam( L, 1, FLD_AXISMAXADJUST, dAxisMaxAdjust) ;
// lettura eventuale campo 'AxisMaxRotAdj' dalla tabella (default 10 * EPS_ANG_SMALL)
double dAxisMaxRotAdj = 10 * EPS_ANG_SMALL ;
LuaGetTabFieldParam( L, 1, FLD_AXISMAXROTADJ, dAxisMaxRotAdj) ;
// lettura eventuale campo 'ExitMaxAdjust' dalla tabella (default EPS_SMALL)
double dExitMaxAdjust = EPS_SMALL ;
LuaGetTabFieldParam( L, 1, FLD_EXITMAXADJUST, dExitMaxAdjust) ;
// lettura eventuale campo 'ExitMaxRotAdj' dalla tabella (default 10 * EPS_ANG_SMALL)
double dExitMaxRotAdj = 10 * EPS_ANG_SMALL ;
LuaGetTabFieldParam( L, 1, FLD_EXITMAXROTADJ, dExitMaxRotAdj) ;
// lettura eventuale campo 'AngDeltaForHome' dalla tabella (default INFINITO)
double dAngDeltaMinForHome = INFINITO ;
LuaGetTabFieldParam( L, 1, FLD_ANGDELTAMINFORHOME, dAngDeltaMinForHome) ;
// lettura eventuale campo 'MultiProcess' dalla tabella (0=no, 1=si, 2=si con simulazione MP)
int nMultiProcess = 0 ;
LuaGetTabFieldParam( L, 1, FLD_MULTIPROCESS, nMultiProcess) ;
// lettura eventuale campo "LinkAxesMoveOrder" dalla tabella(0=interpolati, ...)
int nLinkAxesMoveOrder = 0 ;
LuaGetTabFieldParam( L, 1, FLD_LINKAXESMOVEORDER, nLinkAxesMoveOrder) ;
// lettura eventuale campo 'NewLinkMgr' dalla tabella (0=old, 1 =new)
int nNewLinkMgr = 0 ;
LuaGetTabFieldParam( L, 1, FLD_NEWLINKMGR, nNewLinkMgr) ;
// pulizia stack
LuaClearStack( L) ;
// info
string sOut = "LuaEmtGeneral : " + sFile ;
if ( ! sSpecial.empty())
sOut += ", " + sSpecial ;
if ( ! sProcessor.empty())
sOut += ", " + sProcessor ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico la geometria della macchina
if ( ! m_pMchLua->LoadMachineGeometry( sFile, vtOffset))
return luaL_error( L, " Load Machine failed") ;
// carico il gestore delle azioni speciali della macchina
if ( ! sSpecial.empty()) {
// carico il file lua dello special
string sSpecPath = m_pMchLua->m_sMachineDir + "\\" + sSpecial ;
if ( ! m_pMchLua->m_LuaMgr.ExecFile( sSpecPath))
return luaL_error( L, " Load Special failed") ;
}
else {
LOG_DBG_INFO( GetEMkLogger(), " Special file not specified")
}
// carico il processore della macchina
if ( ! sProcessor.empty()) {
// carico il file lua del processore
string sProcPath = m_pMchLua->m_sMachineDir + "\\" + sProcessor ;
if ( ! m_pMchLua->m_LuaMgr.ExecFile( sProcPath))
return luaL_error( L, " Load Processor failed") ;
}
else {
LOG_DBG_INFO( GetEMkLogger(), " Processor file not specified")
}
// imposto massimo spostamento assi e uscite tra definizione cinematica e geometria
m_pMchLua->m_dAxisMaxAdjust = dAxisMaxAdjust ;
m_pMchLua->m_dAxisMaxRotAdj = dAxisMaxRotAdj ;
m_pMchLua->m_dExitMaxAdjust = dExitMaxAdjust ;
m_pMchLua->m_dExitMaxRotAdj = dExitMaxRotAdj ;
// imposto minima differenza angolare da posizione precedente per stare vivino a posizione home
m_pMchLua->m_dAngDeltaMinForHome = dAngDeltaMinForHome ;
// imposto codice per macchina multiprocesso
m_pMchLua->m_nMultiProcess = nMultiProcess ;
// imposto codice per ordine interpolazione assi nei collegamenti
m_pMchLua->m_nLinkAxesMoveOrder = nLinkAxesMoveOrder ;
// imposto codice per gestione link tra lavorazioni
m_pMchLua->m_nNewLinkMgr = nNewLinkMgr ;
return 0 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtBase( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtBase : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati della base
if ( ! m_pMchLua->LoadMachineBase( sName, sGeo, vsAux))
return luaL_error( L, " Load Machine Base failed") ;
// restituisco l'indice della base
int nBaseId = m_pMchLua->GetBaseId( sName) ;
if ( nBaseId != GDB_ID_NULL)
LuaSetParam( L, nBaseId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtTable( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Parent' dalla tabella
string sParent ;
LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
// lettura campo 'Type' dalla tabella
int nType ;
LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)
// lettura campo 'Ref1' dalla tabella
Point3d Ref1 ;
LuaCheckTabFieldParam( L, 1, FLD_REF1, Ref1)
// lettura eventuale campo 'Scale' dalla tabella
double vScale[3] = {1.0, 1.0, 1.0} ;
LuaGetTabFieldParam( L, 1, FLD_SCALE, vScale) ;
// lettura eventuale campo 'Coll' dalla tabella
STRVECTOR vsColl ;
LuaGetTabFieldParam( L, 1, FLD_COLL, vsColl) ;
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtTable : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati della tavola
if ( ! m_pMchLua->LoadMachineTable( sName, sParent, nType, Ref1, vScale[0], vScale[1], vScale[2], vsColl, sGeo, vsAux))
return luaL_error( L, " Load Machine Table failed") ;
// restituisco l'indice della tavola
int nTableId = m_pMchLua->GetTableId( sName) ;
if ( nTableId != GDB_ID_NULL)
LuaSetParam( L, nTableId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtAxis( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Parent' dalla tabella
string sParent ;
LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
// lettura eventuale campo 'Token' dalla tabella (default Name)
string sToken = sName ;
LuaGetTabFieldParam( L, 1, FLD_TOKEN, sToken) ;
// lettura eventuale campo 'Invert' dalla tabella (default false)
bool bInvert = false ;
LuaGetTabFieldParam( L, 1, FLD_INVERT, bInvert) ;
// lettura eventuale campo 'Offset' dalla tabella (default 0)
double dOffset = 0 ;
LuaGetTabFieldParam( L, 1, FLD_AXIS_OFFSET, dOffset) ;
// lettura campo 'Type' dalla tabella
int nType ;
LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)
// lettura eventuale campo 'Use' della tabella (default General)
int nUse = MCH_AU_GENERAL ;
LuaGetTabFieldParam( L, 1, FLD_USE, nUse) ;
// lettura campo 'Pos' dalla tabella
Point3d ptPos ;
LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
// lettura campo 'Dir' dalla tabella
Vector3d vtDir ;
LuaCheckTabFieldParam( L, 1, FLD_DIR, vtDir)
// lettura campo 'Stroke' dalla tabella
STROKE Stroke ;
LuaCheckTabFieldParam( L, 1, FLD_STROKE, Stroke.v)
// lettura eventuale campo 'Home' dalla tabella (default 0)
double dHome = 0 ;
LuaGetTabFieldParam( L, 1, FLD_HOME, dHome) ;
// lettura eventuale campo 'AdjustAux' dalla tabella (default false)
bool bAdjustAux = false ;
LuaGetTabFieldParam( L, 1, FLD_ADJUSTAUX, bAdjustAux) ;
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtAxis : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati dell'asse
if ( ! m_pMchLua->LoadMachineAxis( sName, sParent, sToken, bInvert, dOffset,
nType, nUse, ptPos, vtDir, Stroke, dHome, bAdjustAux, sGeo, vsAux))
return luaL_error( L, " Load Machine Axis failed") ;
// restituisco l'indice dell'asse
int nAxisId = m_pMchLua->GetAxisId( sName) ;
if ( nAxisId != GDB_ID_NULL)
LuaSetParam( L, nAxisId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtHead( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Type' dalla tabella
int nType ;
LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)
// Procedo alla lettura a seconda del tipo
switch ( nType) {
case MCH_HT_STD :
return LuaEmtStdHead( L) ;
case MCH_HT_MULTI :
return LuaEmtMultiHead( L) ;
case MCH_HT_SPECIAL :
return LuaEmtSpecialHead( L) ;
default :
return luaL_error( L, " Head type unknown") ;
}
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtStdHead( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Parent' dalla tabella
string sParent ;
LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
// lettura campo 'HSet' dalla tabella
string sHSet ;
LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
// lettura campo 'Pos' dalla tabella
Point3d ptPos ;
LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
// lettura campo 'TDir' dalla tabella
Vector3d vtTDir ;
LuaCheckTabFieldParam( L, 1, FLD_TDIR, vtTDir)
// lettura eventuale campo 'ADir' dalla tabella
Vector3d vtADir ;
LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
// lettura eventuale campo 'Rot1W' dalla tabella (default 1)
double dRot1W = 1 ;
LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
// lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
bool bMaxDeltaR2On1 = true ;
LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
// lettura eventuale campo 'Rot2Stroke' dalla tabella
STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
// lettura eventuale campo 'SolCh' dalla tabella
int nSolCh = MCH_SCC_NONE ;
LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ;
// lettura eventuale campo 'OthColl' dalla tabella
STRVECTOR vsOthColl ;
LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ;
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtStdHead : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati della testa standard
if ( ! m_pMchLua->LoadMachineStdHead( sName, sParent, sHSet, ptPos, vtTDir, vtADir,
dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
return luaL_error( L, " Load Machine Standard Head failed") ;
// restituisco l'indice della testa
int nHeadId = m_pMchLua->GetHeadId( sName) ;
if ( nHeadId != GDB_ID_NULL)
LuaSetParam( L, nHeadId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtMultiHead( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Parent' dalla tabella
string sParent ;
LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
// lettura campo 'HSet' dalla tabella
string sHSet ;
LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
// lettura eventuale campo tipo di selezione ammessa per le uscite
int nSelectType = MCH_SLT_FIXEDEXITS ;
LuaGetTabFieldParam( L, 1, FLD_SEL_TYPE, nSelectType) ;
// lettura campo 'ExitNbr' dalla tabella
int nExitNbr ;
LuaCheckTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr)
// lettura campi 'PosN' e 'TDirN' per ogni uscita dalla tabella
MUEXITVECTOR vMuExit ;
vMuExit.reserve( nExitNbr) ;
for ( int i = 0 ; i < nExitNbr ; ++ i) {
// lettura
string sPos = FLD_POS + ToString( i + 1) ;
Point3d ptPos ;
LuaCheckTabFieldParam( L, 1, sPos.c_str(), ptPos)
string sTDir = FLD_TDIR + ToString( i + 1) ;
Vector3d vtTDir ;
LuaCheckTabFieldParam( L, 1, sTDir.c_str(), vtTDir)
// inserimento nell'array
vMuExit.emplace_back( ptPos, vtTDir) ;
}
// lettura eventuale campo 'ADir' dalla tabella
Vector3d vtADir ;
LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
// lettura eventuale campo 'Rot1W' dalla tabella (default 1)
double dRot1W = 1 ;
LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
// lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
bool bMaxDeltaR2On1 = true ;
LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
// lettura eventuale campo 'Rot2Stroke' dalla tabella
STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
// lettura eventuale campo 'SolCh' dalla tabella
int nSolCh = MCH_SCC_NONE ;
LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ;
// lettura eventuale campo 'OthColl' dalla tabella
STRVECTOR vsOthColl ;
LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ;
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtMultiHead : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati della testa multipla
if ( ! m_pMchLua->LoadMachineMultiHead( sName, sParent, sHSet, nSelectType, vMuExit, vtADir,
dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
return luaL_error( L, " Load Machine Multi Head failed") ;
// restituisco l'indice della testa
int nHeadId = m_pMchLua->GetHeadId( sName) ;
if ( nHeadId != GDB_ID_NULL)
LuaSetParam( L, nHeadId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtSpecialHead( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Parent' dalla tabella
string sParent ;
LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
// lettura campo 'HSet' dalla tabella
string sHSet ;
LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
// lettura campo 'Pos' dalla tabella
Point3d ptPos ;
LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
// lettura campo 'TDir' dalla tabella
Vector3d vtTDir ;
LuaCheckTabFieldParam( L, 1, FLD_TDIR, vtTDir)
// lettura eventuale campo 'ADir' dalla tabella
Vector3d vtADir ;
LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
// lettura eventuale campo 'Rot1W' dalla tabella (default 1)
double dRot1W = 1 ;
LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
// lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
bool bMaxDeltaR2On1 = true ;
LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
// lettura eventuale campo 'Rot2Stroke' dalla tabella
STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
// lettura eventuale campo 'SolCh' dalla tabella
int nSolCh = MCH_SCC_NONE ;
LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ;
// lettura eventuale campo 'OthColl' dalla tabella
STRVECTOR vsOthColl ;
LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ;
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtSpecialHead : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati della testa standard
if ( ! m_pMchLua->LoadMachineSpecialHead( sName, sParent, sHSet, ptPos, vtTDir, vtADir,
dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
return luaL_error( L, " Load Machine Special Head failed") ;
// restituisco l'indice della testa
int nHeadId = m_pMchLua->GetHeadId( sName) ;
if ( nHeadId != GDB_ID_NULL)
LuaSetParam( L, nHeadId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtTcPos( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo opzionale 'ExitNbr' dalla tabella
int nExitNbr = 1 ;
LuaGetTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr) ;
// Procedo alla lettura a seconda del tnumero di uscite
if ( nExitNbr == 1)
return LuaEmtStdTcPos( L) ;
else if ( nExitNbr > 1)
return LuaEmtMultiTcPos( L) ;
else
return luaL_error( L, " Tc Position type unknown") ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtStdTcPos( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Parent' dalla tabella
string sParent ;
LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
// lettura campo 'Pos' dalla tabella
Point3d ptPos ;
LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
// lettura campo 'TDir' dalla tabella
Vector3d vtTDir ;
LuaCheckTabFieldParam( L, 1, FLD_TDIR, vtTDir)
// lettura eventuale campo 'ADir' dalla tabella
Vector3d vtADir ;
LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtTcPos : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati della posizione cambio utensile
if ( ! m_pMchLua->LoadMachineStdTcPos( sName, sParent, ptPos, vtTDir, vtADir, sGeo, vsAux))
return luaL_error( L, " Load Machine Standard Tc Position failed") ;
// restituisco l'indice della posizione cambio utensile
int nTcPosId = m_pMchLua->GetTcPosId( sName) ;
if ( nTcPosId != GDB_ID_NULL)
LuaSetParam( L, nTcPosId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtMultiTcPos( lua_State* L)
{
// Il parametro 1 deve essere una tabella
if ( ! lua_istable( L, 1))
return luaL_error( L, " Invalid Parameter, required a table") ;
// lettura campo 'Name' dalla tabella
string sName ;
LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
// lettura campo 'Parent' dalla tabella
string sParent ;
LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
// lettura campo 'ExitNbr' dalla tabella
int nExitNbr ;
LuaCheckTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr)
// lettura campi 'PosN' e 'TDirN' per ogni uscita dalla tabella
MUEXITVECTOR vMuExit ;
vMuExit.reserve( nExitNbr) ;
for ( int i = 0 ; i < nExitNbr ; ++ i) {
// lettura
string sPos = FLD_POS + ToString( i + 1) ;
Point3d ptPos ;
LuaCheckTabFieldParam( L, 1, sPos.c_str(), ptPos)
string sTDir = FLD_TDIR + ToString( i + 1) ;
Vector3d vtTDir ;
LuaCheckTabFieldParam( L, 1, sTDir.c_str(), vtTDir)
// inserimento nell'array
vMuExit.emplace_back( ptPos, vtTDir) ;
}
// lettura eventuale campo 'ADir' dalla tabella
Vector3d vtADir ;
LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
// lettura campo 'Geo' dalla tabella
string sGeo ;
LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
// lettura eventuale campo 'Aux' dalla tabella
STRVECTOR vsAux ;
LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
LuaClearStack( L) ;
// info
string sOut = "LuaEmtTcPos : " + sName ;
LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// carico i dati della posizione cambio utensile
if ( ! m_pMchLua->LoadMachineMultiTcPos( sName, sParent, vMuExit, vtADir, sGeo, vsAux))
return luaL_error( L, " Load Machine Multi Tc Position failed") ;
// restituisco l'indice della posizione cambio utensile
int nTcPosId = m_pMchLua->GetTcPosId( sName) ;
if ( nTcPosId != GDB_ID_NULL)
LuaSetParam( L, nTcPosId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisPosition( lua_State* L)
{
// 2 parametri : sAxisName, ptPos
string sAxisName ;
LuaCheckParam( L, 1, sAxisName)
Point3d ptPos ;
LuaCheckParam( L, 2, ptPos)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// modifico la posizione dell'asse
bool bOk = m_pMchLua->ModifyMachineAxisPosition( sAxisName, ptPos) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisDirection( lua_State* L)
{
// 2 parametri : sAxisName, vtDir
string sAxisName ;
LuaCheckParam( L, 1, sAxisName)
Vector3d vtDir ;
LuaCheckParam( L, 2, vtDir)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// modifico la direzione dell'asse
bool bOk = m_pMchLua->ModifyMachineAxisDirection( sAxisName, vtDir) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisStroke( lua_State* L)
{
// 2 parametri : sAxisName, {dMin, dMax}
string sAxisName ;
LuaCheckParam( L, 1, sAxisName)
STROKE Stroke ;
LuaCheckParam( L, 2, Stroke.v)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// modifico i limiti di corsa dell'asse
bool bOk = m_pMchLua->ModifyMachineAxisStroke( sAxisName, Stroke) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisHome( lua_State* L)
{
// 2 parametri : sAxisName, dHome
string sAxisName ;
LuaCheckParam( L, 1, sAxisName)
double dHome ;
LuaCheckParam( L, 2, dHome)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// modifico la posizione home dell'asse
bool bOk = m_pMchLua->ModifyMachineAxisHome( sAxisName, dHome) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyHeadAuxDirection( lua_State* L)
{
// 2 parametri : sHead, vtADir
string sHead ;
LuaCheckParam( L, 1, sHead)
Vector3d vtADir ;
LuaCheckParam( L, 2, vtADir)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// modifico la direzione ausiliaria della testa
bool bOk = m_pMchLua->ModifyMachineHeadAuxDirection( sHead, vtADir) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyExitPosition( lua_State* L)
{
// 3 parametri : sHead, nExit, ptPos
string sHead ;
LuaCheckParam( L, 1, sHead)
int nExit ;
LuaCheckParam( L, 2, nExit)
Point3d ptPos ;
LuaCheckParam( L, 3, ptPos)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// modifico la posizione dell'uscita della testa
bool bOk = m_pMchLua->ModifyMachineExitPosition( sHead, nExit, ptPos) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtLinkRawPartToGroup( lua_State* L)
{
// 2 parametri : nRawId, sGroupName
int nRawId ;
LuaCheckParam( L, 1, nRawId)
string sGroupName ;
LuaCheckParam( L, 2, sGroupName)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// aggancio il grezzo al gruppo
bool bOk = m_pMchLua->LinkRawPartToGroup( nRawId, sGroupName) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkRawPartFromGroup( lua_State* L)
{
// 1 parametro : nRawId
int nRawId ;
LuaCheckParam( L, 1, nRawId)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// riporto il grezzo nel gruppo dei grezzi
bool bOk = m_pMchLua->UnlinkRawPartFromGroup( nRawId) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtGetAllLinkedRawParts( lua_State* L)
{
// nessun parametro
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// recupero l'elenco dei grezzi agganciati ad un gruppo macchina
const INTVECTOR& vLinkedRawParts = m_pMchLua->GetAllLinkedRawParts() ;
// assegno risultato
LuaSetParam( L, vLinkedRawParts) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkAllRawPartsFromGroups( lua_State* L)
{
// nessun parametro
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// riporto tutti i grezzi linkati nel gruppo dei grezzi
bool bOk = m_pMchLua->UnlinkAllRawPartsFromGroups() ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtLinkFixtureToGroup( lua_State* L)
{
// 2 parametri : nFxtId, sGroupName
int nFxtId ;
LuaCheckParam( L, 1, nFxtId)
string sGroupName ;
LuaCheckParam( L, 2, sGroupName)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// aggancio il bloccaggio al gruppo
bool bOk = m_pMchLua->LinkFixtureToGroup( nFxtId, sGroupName) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkFixtureFromGroup( lua_State* L)
{
// 1 parametro : nFxtId
int nFxtId ;
LuaCheckParam( L, 1, nFxtId)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// riporto il bloccaggio nel gruppo delle fixtures
bool bOk = m_pMchLua->UnlinkFixtureFromGroup( nFxtId) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkAllFixturesFromGroups( lua_State* L)
{
// nessun parametro
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// riporto tutti i bloccaggi linkati nel gruppo delle fixtures
bool bOk = m_pMchLua->UnlinkAllFixturesFromGroups() ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtLinkPartToGroup( lua_State* L)
{
// 2 parametri : nPartId, sGroupName
int nPartId ;
LuaCheckParam( L, 1, nPartId)
string sGroupName ;
LuaCheckParam( L, 2, sGroupName)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// aggancio il pezzo al gruppo
bool bOk = m_pMchLua->LinkPartToGroup( nPartId, sGroupName) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkPartFromGroup( lua_State* L)
{
// 1 parametro : nRawId
int nPartId ;
LuaCheckParam( L, 1, nPartId)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// riporto il pezzo nel suo grezzo
bool bOk = m_pMchLua->UnlinkPartFromGroup( nPartId) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkAllPartsFromGroups( lua_State* L)
{
// nessun parametro
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// riporto tutti i pezzi linkati nel loro grezzo
bool bOk = m_pMchLua->UnlinkAllPartsFromGroups() ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtWrite( lua_State* L)
{
// 1 parametro : string
string sOut ;
LuaCheckParam( L, 1, sOut)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// emetto stringa
bool bOk = m_pMchLua->WriterEmit( sOut) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtSetOutstrokeInfo( lua_State* L)
{
// 5 parametri : sAxName, sAxToken, bLinear, dExtra, sAuxInfo
string sAxName ;
LuaCheckParam( L, 1, sAxName)
string sAxToken ;
LuaCheckParam( L, 2, sAxToken)
bool bLinear ;
LuaCheckParam( L, 3, bLinear)
double dExtra ;
LuaCheckParam( L, 4, dExtra)
string sAuxInfo ;
LuaCheckParam( L, 5, sAuxInfo)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// assegno i dati
m_pMchLua->m_OutstrokeInfo.sAxName = sAxName ;
m_pMchLua->m_OutstrokeInfo.sAxToken = sAxToken ;
m_pMchLua->m_OutstrokeInfo.bLinear = bLinear ;
m_pMchLua->m_OutstrokeInfo.dExtra = dExtra ;
m_pMchLua->m_OutstrokeInfo.sAuxInfo = sAuxInfo ;
// assegno risultato
LuaSetParam( L, true) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtSetLastError( lua_State* L)
{
// 2 o 3 parametri : nErrId, sErrDesc [, bSoftExit = false]
int nErrId ;
LuaCheckParam( L, 1, nErrId)
string sErrDesc ;
LuaCheckParam( L, 2, sErrDesc)
bool bSoftExit = false ;
LuaGetParam( L, 3, bSoftExit) ;
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// imposto informazioni di errore
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SetLastError( nErrId, sErrDesc)) ;
string sOut = "(" + ToString( nErrId) + ") " + sErrDesc ;
// se uscita dolce
if ( bSoftExit) {
LuaSetParam( L, true) ;
return 1 ;
}
else
return luaL_error( L, sOut.c_str()) ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtSetWarning( lua_State* L)
{
// 2 parametri : nWarnId, sWarnDesc
int nWarnId ;
LuaCheckParam( L, 1, nWarnId)
string sWarnDesc ;
LuaCheckParam( L, 2, sWarnDesc)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// imposto informazioni di warning
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SetWarning( nWarnId, sWarnDesc)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtAddCollisionObj( lua_State* L)
{
// 6 parametri : nInd, nFrameId, nType, dPar1, dPar2, dPar3
int nInd ;
LuaCheckParam( L, 1, nInd)
int nFrameId ;
LuaCheckParam( L, 2, nFrameId)
int nType ;
LuaCheckParam( L, 3, nType)
double dPar1 ;
LuaCheckParam( L, 4, dPar1)
double dPar2 ;
LuaCheckParam( L, 5, dPar2)
double dPar3 ;
LuaCheckParam( L, 6, dPar3)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// assegno i dati
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimAddCollisionObj( nInd, false, nFrameId, nType, Vector3d(), dPar1, dPar2, dPar3)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtAddCollisionObjEx( lua_State* L)
{
// 7 o 8 parametri : nInd, nFrameId, nType, vtMove, dPar1, dPar2, dPar3 [,bToolOn]
int nInd ;
LuaCheckParam( L, 1, nInd)
int nFrameId ;
LuaCheckParam( L, 2, nFrameId)
int nType ;
LuaCheckParam( L, 3, nType)
Vector3d vtMove ;
LuaCheckParam( L, 4, vtMove)
double dPar1 ;
LuaCheckParam( L, 5, dPar1)
double dPar2 ;
LuaCheckParam( L, 6, dPar2)
double dPar3 ;
LuaCheckParam( L, 7, dPar3)
bool bToolOn = false ;
LuaGetParam( L, 8, bToolOn) ;
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// assegno i dati
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimAddCollisionObj( nInd, bToolOn, nFrameId, nType, vtMove, dPar1, dPar2, dPar3)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtExecCollisionCheck( lua_State* L)
{
// 1 parametro opzionale : [nMoveType = 0]
int nMoveType = 0 ;
LuaGetParam( L, 1, nMoveType) ;
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// eseguo la verifica di collisione (nessuna collisione -> true)
int nCdInd = -1, nObjInd = -1 ;
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimExecCollisionCheck( nCdInd, nObjInd, nMoveType)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
LuaSetParam( L, nCdInd) ;
LuaSetParam( L, nObjInd) ;
return 3 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtOnCollision( lua_State* L)
{
// 2 parametri : nCdInd, nObjInd
int nCdInd ;
LuaCheckParam( L, 1, nCdInd)
int nObjInd ;
LuaCheckParam( L, 2, nObjInd)
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// eseguo gestione della collisione in simulazione
int nErr = 0 ;
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimOnCollision( nCdInd, nObjInd, nErr)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
LuaSetParam( L, nErr) ;
return 2 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtSetToolForVmill( lua_State* L)
{
// 4 o 7 parametri : sTool, sHead, nExit, vVmill [, nFlag , dPar1, dPar2]
string sTool ;
LuaGetParam( L, 1, sTool) ;
string sHead ;
LuaGetParam( L, 2, sHead) ;
int nExit = 0 ;
LuaGetParam( L, 3, nExit) ;
INTVECTOR vVmill ;
LuaGetParam( L, 4, vVmill) ;
int nFlag = 0 ;
LuaGetParam( L, 5, nFlag) ;
double dPar1 = 0 ;
LuaGetParam( L, 6, dPar1) ;
double dPar2 = 0 ;
LuaGetParam( L, 7, dPar2) ;
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// imposto dati primo utensile per virtual milling in simulazione
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr &&
m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, nFlag, dPar1, dPar2, vVmill, true)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtAddToolForVmill( lua_State* L)
{
// 4 o 7 parametri : sTool, sHead, nExit, vVmill [, nFlag, dPar1, dPar2]
string sTool ;
LuaGetParam( L, 1, sTool) ;
string sHead ;
LuaGetParam( L, 2, sHead) ;
int nExit = 0 ;
LuaGetParam( L, 3, nExit) ;
INTVECTOR vVmill ;
LuaGetParam( L, 4, vVmill) ;
int nFlag = 0 ;
LuaGetParam( L, 5, nFlag) ;
double dPar1 = 0 ;
LuaGetParam( L, 6, dPar1) ;
double dPar2 = 0 ;
LuaGetParam( L, 7, dPar2) ;
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// imposto dati utensile aggiuntivo per virtual milling in simulazione
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr &&
m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, nFlag, dPar1, dPar2, vVmill, false)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtEnableToolsForVmill( lua_State* L)
{
// 1 parametro : bEnable
bool bEnable = false ;
LuaGetParam( L, 1, bEnable) ;
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// imposto abilitazione utensili per virtual milling in simulazione
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimEnableToolsForVmill( bEnable)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtMoveAxes( lua_State* L)
{
// 4, ..., 31 parametri : nMoveType, sAx1, dPos1, dStep1 [, sAx2, dPos2, dStep2] ... [, sAx10, dPos10, dStep10]
int nMoveType = 0 ;
LuaGetParam( L, 1, nMoveType) ;
SAMVECTOR vAxNaEpSt ;
for ( int i = 0 ; i < 10 ; ++ i) {
int nInd = 2 + 3 * i ;
string sAxN ;
double dEndN ;
double dStepN ;
if ( LuaGetParam( L, nInd, sAxN) && LuaGetParam( L, nInd + 1, dEndN) && LuaGetParam( L, nInd + 2, dStepN))
vAxNaEpSt.emplace_back( sAxN, dEndN, dStepN) ;
else
break ;
}
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// eseguo movimento in simulazione
int nRes = 0 ;
if ( m_pMchLua->m_pMchMgr != nullptr)
nRes = m_pMchLua->m_pMchMgr->SimMoveAxes( nMoveType, vAxNaEpSt) ;
// assegno risultato
if ( nRes == SIM_AXMV_RES_STOP)
return luaL_error( L, "STOP") ;
else {
LuaSetParam( L, ( nRes == SIM_AXMV_RES_OK)) ;
LuaSetParam( L, m_pMchLua->GetMultiProcess()) ;
}
return 2 ;
}
//----------------------------------------------------------------------------
int
Machine::LuaEmtSaveCmd( lua_State* L)
{
// parametri : nType,
int nType = 0 ;
LuaGetParam( L, 1, nType) ;
int nPar = 0 ;
LuaGetParam( L, 2, nPar) ;
string sPar ;
LuaGetParam( L, 3, sPar) ;
string sPar2 ;
if ( nType == 4) {
switch ( lua_type( L, 4)) {
case LUA_TNIL :
nPar = 0 ;
break ;
case LUA_TBOOLEAN :
{ nPar = 1 ;
bool bVal ;
LuaGetParam( L, 4, bVal) ;
sPar2 = ( bVal ? "1" : "0") ;
} break ;
case LUA_TNUMBER :
if ( lua_isinteger( L, 4)) {
nPar = 2 ;
int nVal ;
LuaGetParam( L, 4, nVal) ;
sPar2 = ToString( nVal) ;
}
else {
nPar = 3 ;
double dVal ;
LuaGetParam( L, 4, dVal) ;
sPar2 = ToString( dVal, 9) ;
}
break ;
case LUA_TSTRING :
{ nPar = 4 ;
LuaGetParam( L, 4, sPar2) ;
} break ;
default :
return luaL_error( L, " Unknown Type") ;
}
}
LuaClearStack( L) ;
// verifico ci sia una macchina attiva
if ( m_pMchLua == nullptr)
return luaL_error( L, " Unknown Machine") ;
// salvo il comando
bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimSaveCmd( nType, nPar, sPar, sPar2)) ;
// assegno risultato
LuaSetParam( L, bOk) ;
return 1 ;
}
Reference in New Issue View Git Blame Copy Permalink