//---------------------------------------------------------------------------- // 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 ; }