Dario Sassi
f31aacdc14
- aggiunta gestione TcPos (posizioni di cambio utensile) da configurazione macchina - aggiunte funzioni GetToolsInCurrSetupPos, GetTcPosId e GetAllTcPosNames.
1182 lines
42 KiB
C++
1182 lines
42 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2020
|
|
//----------------------------------------------------------------------------
|
|
// File : MachineLua.cpp Data : 26.04.20 Versione : 2.2d4
|
|
// Contenuto : Implementazione gestione macchina : funzioni Lua.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 06.05.15 DS Creazione modulo.
|
|
// 26.04.20 DS Aggiunta gestione TcPos.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- 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_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_INVERT = "Invert" ;
|
|
static const string FLD_REF1 = "Ref1" ;
|
|
static const string FLD_SCALE = "Scale" ;
|
|
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_TDIR = "TDir" ;
|
|
static const string FLD_ADIR = "ADir" ;
|
|
static const string FLD_ROT1W = "Rot1W" ;
|
|
static const string FLD_ROT2STROKE = "Rot2Stroke" ;
|
|
static const string FLD_SOLCH = "SolCh" ;
|
|
static const string FLD_OTHCOLL = "OthColl" ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
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( "EmtLinkRawPartToGroup", Machine::LuaEmtLinkRawPartToGroup) ;
|
|
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) ;
|
|
// registro le funzioni di lettura entità CL per lua
|
|
m_LuaMgr.RegisterFunction( "EmtGetMoveType", Machine::LuaEmtGetMoveType) ;
|
|
m_LuaMgr.RegisterFunction( "EmtGetAxesPos", Machine::LuaEmtGetAxesPos) ;
|
|
// 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) ;
|
|
|
|
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) ;
|
|
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 ;
|
|
|
|
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 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], 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 campo 'Type' dalla tabella
|
|
int nType ;
|
|
LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)
|
|
// 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, nType, 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 '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, 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 campo 'ExitNbr' dalla tabella
|
|
int nExitNbr ;
|
|
LuaCheckTabFieldParam( L, 1, "ExitNbr", 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 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 '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, vMuExit, vtADir,
|
|
dRot1W, 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::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 '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, 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 '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->LoadMachineTcPos( sName, sParent, ptPos, vtTDir, vtADir, sGeo, vsAux))
|
|
return luaL_error( L, " Load Machine Standard Head 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::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::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") ;
|
|
// assegno i dati
|
|
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") ;
|
|
// assegno i dati
|
|
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, nFrameId, nType, dPar1, dPar2, dPar3)) ;
|
|
// assegno risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|