Riccardo Elitropi
306 lines
9.6 KiB
C++
306 lines
9.6 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2025-2025
|
|
//----------------------------------------------------------------------------
|
|
// File : LUA_MachOpt.cpp Data : 02.04.25 Versione : 2.7c1
|
|
// Contenuto : Funzioni per Ottimizzare i tempi tra le lavorazioni per LUA.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 02.04.25 RE Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "LUA.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EGkLuaAux.h"
|
|
#include "/EgtDev/Include/EGnStringUtils.h"
|
|
|
|
using namespace std ;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachInit( lua_State* L)
|
|
{
|
|
// Nessun parametro
|
|
LuaClearStack( L) ;
|
|
// Inizializzo il calcolatore per minimizzare i tempi tra le lavorazioni
|
|
bool bOk = ExeOptMachInit() ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachTerminate( lua_State* L)
|
|
{
|
|
// Nessun parametro
|
|
LuaClearStack( L) ;
|
|
// Termino il calcolatore per minimizzare i tempi tra le lavorazioni
|
|
bool bOk = ExeOptMachTerminate() ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachAddTool( lua_State* L)
|
|
{
|
|
// Definizione 9 parametri (3 obbligatori)
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId) ;
|
|
double dTLoad ;
|
|
LuaCheckParam( L, 2, dTLoad) ;
|
|
double dTUnload ;
|
|
LuaCheckParam( L, 3, dTUnload) ;
|
|
double dTC_X = 0. ;
|
|
bool bTC_X = LuaGetParam( L, 4, dTC_X) ;
|
|
double dTC_Y = 0. ;
|
|
bool bTC_Y = LuaGetParam( L, 5, dTC_Y) ;
|
|
double dTC_Z = 0. ;
|
|
bool bTC_Z = LuaGetParam( L, 6, dTC_Z) ;
|
|
double dTC_A = 0. ;
|
|
bool bTC_A = LuaGetParam( L, 7, dTC_A) ;
|
|
double dTC_B = 0. ;
|
|
bool bTC_B = LuaGetParam( L, 8, dTC_B) ;
|
|
double dTC_C = 0. ;
|
|
bool bTC_C = LuaGetParam( L, 9, dTC_C) ;
|
|
LuaClearStack( L) ;
|
|
// Aggiungo la Lavorazione
|
|
bool bOk = ExeOptMachAddTool( nId, dTC_X, dTC_Y, dTC_Z, dTC_A, dTC_B, dTC_C,
|
|
bTC_X, bTC_Y, bTC_Z, bTC_A, bTC_B, bTC_C,
|
|
dTLoad, dTUnload) ;
|
|
// Rstituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachAddMachining( lua_State* L)
|
|
{
|
|
// Definizione 5 parametri
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId) ;
|
|
int nToolId ;
|
|
LuaCheckParam( L, 2, nToolId) ;
|
|
int nGroup ;
|
|
LuaCheckParam( L, 3, nGroup) ;
|
|
DBLVECTOR vAxStart ;
|
|
LuaCheckParam( L, 4, vAxStart) ;
|
|
DBLVECTOR vAxEnd ;
|
|
LuaCheckParam( L, 5, vAxEnd) ;
|
|
LuaClearStack( L) ;
|
|
// Completamento valori assi
|
|
while ( vAxStart.size() < 6)
|
|
vAxStart.push_back( 0) ;
|
|
while ( vAxEnd.size() < 6)
|
|
vAxEnd.push_back( 0) ;
|
|
// Aggiungo la Lavorazione
|
|
bool bOk = ExeOptMachAddMachining( nId, nToolId, nGroup,
|
|
vAxStart[0], vAxStart[1], vAxStart[2], vAxStart[3], vAxStart[4], vAxStart[5],
|
|
vAxEnd[0], vAxEnd[1], vAxEnd[2], vAxEnd[3], vAxEnd[4], vAxEnd[5]) ;
|
|
// Rstituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachSetFirstMachining( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId = 0 ;
|
|
LuaCheckParam( L, 1, nId) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto la prima lavorazione
|
|
bool bOk = ExeOptMachSetFirstMachining( nId) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachSetLastMachining( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId = 0 ;
|
|
LuaCheckParam( L, 1, nId) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto la prima lavorazione
|
|
bool bOk = ExeOptMachSetLastMachining( nId) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachSetFeeds( lua_State* L)
|
|
{
|
|
// 2 Parametri : dFeedL, dFeedA
|
|
double dFeedL = 1. ;
|
|
LuaCheckParam( L, 1, dFeedL) ;
|
|
double dFeedA = 1. ;
|
|
LuaCheckParam( L, 2, dFeedA) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto le Feeds
|
|
bool bOk = ExeOptMachSetFeeds( dFeedL, dFeedA) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachAddDependence( lua_State* L)
|
|
{
|
|
// 2 parametri : nIdPrev, nIdSucc
|
|
int nIdPrev = 0 ; int nIdNext = 0 ;
|
|
LuaCheckParam( L, 1, nIdPrev) ;
|
|
LuaCheckParam( L, 2, nIdNext) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto Dipendenza obbligatoria
|
|
bool bOk = ExeOptMachAddDependence( nIdPrev, nIdNext) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachAddSuggestedDependence( lua_State* L)
|
|
{
|
|
// 2 parametri : nIdPrev, nIdSucc
|
|
int nIdPrev = 0 ; int nIdNext = 0 ;
|
|
LuaCheckParam( L, 1, nIdPrev) ;
|
|
LuaCheckParam( L, 2, nIdNext) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto Dipendenza suggerita
|
|
bool bOk = ExeOptMachAddSuggestedDependence( nIdPrev, nIdNext) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachSetAllGroupDependencesAsMandatory( lua_State* L)
|
|
{
|
|
// 1 Parametro : bAllMendatory
|
|
bool bAllMendatory = false ;
|
|
LuaCheckParam( L, 1, bAllMendatory) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto il Flag
|
|
bool bOk = ExeOptMachSetAllGroupDependencesAsMandatory( bAllMendatory) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachSetOptimizationForGroups( lua_State* L)
|
|
{
|
|
// 1 Parametro : bOptForGroups
|
|
bool bOptForGroups = false ;
|
|
LuaCheckParam( L, 1, bOptForGroups) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto il Flag
|
|
bool bOk = ExeOptMachSetOptimizationForGroups( bOptForGroups) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachSetOpenBound( lua_State* L)
|
|
{
|
|
// 5 parametri : bStartVsEnd, nFlag, dX, dY, dZ
|
|
bool bStartVsEnd ;
|
|
LuaCheckParam( L, 1, bStartVsEnd) ;
|
|
int nFlag ;
|
|
LuaCheckParam( L, 2, nFlag) ;
|
|
double dX ;
|
|
LuaCheckParam( L, 3, dX) ;
|
|
double dY ;
|
|
LuaCheckParam( L, 4, dY) ;
|
|
double dZ ;
|
|
LuaCheckParam( L, 5, dZ) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto la condizione
|
|
bool bOk = ExeOptMachSetOpenBound( bStartVsEnd, nFlag, dX, dY, dZ) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachSetOpenBoundForGroups( lua_State* L)
|
|
{
|
|
// 6 parametri : nGroup, bStartVsEnd, nFlag, dX, dY, dZ
|
|
int nGroup ;
|
|
LuaCheckParam( L, 1, nGroup) ;
|
|
bool bStartVsEnd ;
|
|
LuaCheckParam( L, 2, bStartVsEnd) ;
|
|
int nFlag ;
|
|
LuaCheckParam( L, 3, nFlag) ;
|
|
double dX ;
|
|
LuaCheckParam( L, 4, dX) ;
|
|
double dY ;
|
|
LuaCheckParam( L, 5, dY) ;
|
|
double dZ ;
|
|
LuaCheckParam( L, 6, dZ) ;
|
|
LuaClearStack( L) ;
|
|
// Imposto la condizione
|
|
bool bOk = ExeOptMachSetOpenBoundForGroups( nGroup, bStartVsEnd, nFlag, dX, dY, dZ) ;
|
|
// Restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaOptMachCalculate( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// eseguo calcolo di minimo percorso
|
|
INTVECTOR vOrder ;
|
|
bool bOk = ExeOptMachCalculate( vOrder) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vOrder) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallMachiningOptimization( LuaMgr& luaMgr)
|
|
{
|
|
bool bOk = ( &luaMgr != nullptr) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachInit", LuaOptMachInit) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachTerminate", LuaOptMachTerminate) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddTool", LuaOptMachAddTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddMachining", LuaOptMachAddMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetFirstMachining", LuaOptMachSetFirstMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetLastMachining", LuaOptMachSetLastMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetFeeds", LuaOptMachSetFeeds) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddDependence", LuaOptMachAddDependence) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachAddSuggestedDependence", LuaOptMachAddSuggestedDependence) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetAllGroupsDependencesAsMandatory", LuaOptMachSetAllGroupDependencesAsMandatory) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOptimizationForGroups", LuaOptMachSetOptimizationForGroups) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOpenBound", LuaOptMachSetOpenBound) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachSetOpenBoundForGroups", LuaOptMachSetOpenBoundForGroups) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtOptMachCalculate", LuaOptMachCalculate) ;
|
|
return bOk ;
|
|
} |