Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4ab7788d6d789ddaf554e26f088832487dbaf14e
EgtMachKernel/Machining.cpp
T
Dario Sassi 4ab7788d6d EgtMachkernel : 
- aggiunta gestione OnSpecialApplyMachining appena prima del calcolo dei collegamenti tra lavorazioni.
2026-01-21 09:46:38 +01:00

660 lines
24 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : Machining.cpp Data : 10.06.15 Versione : 1.6f2
// Contenuto : Implementazione gestione base lavorazioni.
//
//
//
// Modifiche : 10.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "DllMain.h"
#include "MachMgr.h"
#include "Machining.h"
#include "OperUserNotesConst.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurve.h"
using namespace std ;
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Machining::Machining( void)
{
}
//----------------------------------------------------------------------------
const string&
Machining::GetToolName( void) const
{
return GetToolData().m_sName ;
}
//----------------------------------------------------------------------------
const string&
Machining::GetHeadName( void) const
{
return GetToolData().m_sHead ;
}
//----------------------------------------------------------------------------
int
Machining::GetExitNbr( void) const
{
return GetToolData().m_nExit ;
}
//----------------------------------------------------------------------------
const string&
Machining::GetToolTcPos( void) const
{
return GetToolData().m_sTcPos ;
}
//----------------------------------------------------------------------------
bool
Machining:: NeedPrevHome( void) const
{
return false ;
}
//----------------------------------------------------------------------------
bool
Machining::GetStartPoint( Point3d& ptStart) const
{
// verifico validità gestore DB geometrico
if ( m_pGeomDB == nullptr)
return false ;
// recupero gruppo per geometria di lavorazione (Cutter Location)
int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
if ( nClId == GDB_ID_NULL)
return false ;
// recupero la prima entità del primo sottogruppo
int nEntId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstGroupInGroup( nClId)) ;
if ( nEntId == GDB_ID_NULL)
return false ;
// recupero il punto iniziale di questa entità
const IGeoObj* pGeoObj = m_pGeomDB->GetGeoObj( nEntId) ;
if ( pGeoObj->GetType() == GEO_PNT3D) {
ptStart = GetGeoPoint3d( pGeoObj)->GetPoint() ;
return true ;
}
else if ( ( pGeoObj->GetType() & GEO_CURVE) != 0)
return GetCurve( pGeoObj)->GetStartPoint( ptStart) ;
else
return false ;
}
//----------------------------------------------------------------------------
bool
Machining::GetEndPoint( Point3d& ptEnd) const
{
// verifico validità gestore DB geometrico
if ( m_pGeomDB == nullptr)
return false ;
// recupero gruppo per geometria di lavorazione (Cutter Location)
int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
if ( nClId == GDB_ID_NULL)
return false ;
// recupero l'ultima entità dell'ultimo sottogruppo
int nEntId = m_pGeomDB->GetLastInGroup( m_pGeomDB->GetLastGroupInGroup( nClId)) ;
if ( nEntId == GDB_ID_NULL)
return false ;
// recupero il punto finale di questa entità
const IGeoObj* pGeoObj = m_pGeomDB->GetGeoObj( nEntId) ;
if ( pGeoObj->GetType() == GEO_PNT3D) {
ptEnd = GetGeoPoint3d( pGeoObj)->GetPoint() ;
return true ;
}
else if ( ( pGeoObj->GetType() & GEO_CURVE) != 0)
return GetCurve( pGeoObj)->GetEndPoint( ptEnd) ;
else
return false ;
}
//----------------------------------------------------------------------------
bool
Machining::PrepareToolPreview( void) const
{
// verifico validità gestori DB geometrico e CAM
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return false ;
// creo o svuoto gruppo per anteprima utensile
int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
// se non c'è, lo aggiungo
if ( nStId == GDB_ID_NULL) {
nStId = m_pGeomDB->AddGroup( GDB_ID_NULL, GetOwner(), Frame3d()) ;
if ( nStId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nStId, MCH_ST) ;
m_pGeomDB->SetLevel( nStId, GDB_LV_TEMP) ;
}
// altrimenti lo svuoto
else
m_pGeomDB->EmptyGroup( nStId) ;
// se necessario, imposto l'utensile corrente
string sCurrTool ; m_pMchMgr->GetCalcTool( sCurrTool) ;
const_cast<Machining*>( this)->UpdateToolData() ;
if ( ! EqualNoCase( sCurrTool, GetToolName())) {
if ( ! m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()))
return false ;
}
// copio la testa della lavorazione nel gruppo
int nHeadId = m_pMchMgr->GetHeadId( GetHeadName()) ;
int nId = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nStId) ;
m_pGeomDB->SetMode( nId, GDB_MD_STD) ;
m_pGeomDB->SetStatus( nId, GDB_ST_OFF) ;
// elimino eventuali gruppi opportunamente indicati
int nSubId = m_pGeomDB->GetFirstGroupInGroup( nId) ;
while ( nSubId != GDB_ID_NULL) {
int nNextSubId = m_pGeomDB->GetNextGroup( nSubId) ;
bool bShow = true ;
if ( m_pGeomDB->GetInfo( nSubId, KEY_PREVIEWSHOW, bShow) && ! bShow)
m_pGeomDB->Erase( nSubId) ;
nSubId = nNextSubId ;
}
return ( nId != GDB_ID_NULL) ;
}
//----------------------------------------------------------------------------
bool
Machining::RemoveToolPreview( void) const
{
// verifico validità gestore DB geometrico
if ( m_pGeomDB == nullptr)
return false ;
// recupero gruppo per anteprima utensile
int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
// lo svuoto
m_pGeomDB->EmptyGroup( nStId) ;
return true ;
}
//----------------------------------------------------------------------------
int
Machining::GetToolPreviewStepCount( void) const
{
// verifico validità gestori DB geometrico e CAM
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return 0 ;
// recupero gruppo per geometria di lavorazione (Cutter Location)
int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
if ( nClId == GDB_ID_NULL)
return 0 ;
// determino il numero di entità di tutti i sottogruppi, escludendo CLIMB e RISE
int nCount = 0 ;
int nPxId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
while ( nPxId != GDB_ID_NULL) {
// aggiungo tutte le entità del truppo
nCount += m_pGeomDB->GetGroupObjs( nPxId) ;
// tolgo le entità CLIMB
int nClimbId = m_pGeomDB->GetFirstNameInGroup( nPxId, MCH_CL_CLIMB) ;
while ( nClimbId != GDB_ID_NULL) {
-- nCount ;
nClimbId = m_pGeomDB->GetNextName( nClimbId, MCH_CL_CLIMB) ;
}
// tolgo le entità RISE
int nRiseId = m_pGeomDB->GetFirstNameInGroup( nPxId, MCH_CL_RISE) ;
while ( nRiseId != GDB_ID_NULL) {
-- nCount ;
nRiseId = m_pGeomDB->GetNextName( nRiseId, MCH_CL_RISE) ;
}
// passo al successivo sottogruppo
nPxId = m_pGeomDB->GetNextGroup( nPxId) ;
}
return nCount ;
}
//----------------------------------------------------------------------------
int
Machining::GetToolPreviewNext( int nEntId, int nParentId, int nStId) const
{
// recupero la successiva
int nNewId = (( nEntId != GDB_ID_NULL) ? m_pGeomDB->GetNext( nEntId) : m_pGeomDB->GetFirstInGroup( nParentId)) ;
int nNewParentId = nParentId ;
// ciclo nei gruppi successivi
do {
// ciclo nel gruppo
while ( nNewId != GDB_ID_NULL) {
string sName ; m_pGeomDB->GetName( nNewId, sName) ;
if ( sName != MCH_CL_CLIMB && sName != MCH_CL_RISE)
break ;
nNewId = m_pGeomDB->GetNext( nNewId) ;
}
// se trovata, esco
if ( nNewId != GDB_ID_NULL) {
// se prima entità, eventuale attivazione uscite di gruppo a forare
if ( nEntId == GDB_ID_NULL && m_pGeomDB->ExistsInfo( nNewParentId, KEY_DRACEX)) {
INTVECTOR vActExit ;
if ( m_pGeomDB->GetInfo( nNewParentId, KEY_DRACEX, vActExit))
ActivateDrillingUnit( nStId, vActExit) ;
}
return nNewId ;
}
// passo al gruppo successivo
nNewParentId = m_pGeomDB->GetNextGroup( nNewParentId) ;
// eventuale attivazione uscite di gruppo a forare
if ( m_pGeomDB->ExistsInfo( nNewParentId, KEY_DRACEX)) {
INTVECTOR vActExit ;
if ( m_pGeomDB->GetInfo( nNewParentId, KEY_DRACEX, vActExit))
ActivateDrillingUnit( nStId, vActExit) ;
}
// recupero la prima entità del successivo gruppo
nNewId = m_pGeomDB->GetFirstInGroup( nNewParentId) ;
} while ( nNewId != GDB_ID_NULL) ;
return GDB_ID_NULL ;
}
//----------------------------------------------------------------------------
int
Machining::GetToolPreviewPrev( int nEntId, int nParentId, int nStId) const
{
// recupero la precedente
int nNewId = (( nEntId != GDB_ID_NULL) ? m_pGeomDB->GetPrev( nEntId) : m_pGeomDB->GetLastInGroup( nParentId)) ;
int nNewParentId = nParentId ;
// ciclo nei gruppi precedenti
do {
// ciclo nel gruppo
while ( nNewId != GDB_ID_NULL) {
string sName ; m_pGeomDB->GetName( nNewId, sName) ;
if ( sName != MCH_CL_CLIMB && sName != MCH_CL_RISE)
break ;
nNewId = m_pGeomDB->GetPrev( nNewId) ;
}
// se trovata, esco
if ( nNewId != GDB_ID_NULL)
return nNewId ;
// passo al gruppo precedente
nNewParentId = m_pGeomDB->GetPrevGroup( nNewParentId) ;
// eventuale attivazione uscite di gruppo a forare
if ( m_pGeomDB->ExistsInfo( nNewParentId, KEY_DRACEX)) {
INTVECTOR vActExit ;
if ( m_pGeomDB->GetInfo( nNewParentId, KEY_DRACEX, vActExit))
ActivateDrillingUnit( nStId, vActExit) ;
}
// recupero l'ultima entità del precedente gruppo
nNewId = m_pGeomDB->GetLastInGroup( nNewParentId) ;
} while ( nNewId != GDB_ID_NULL) ;
return GDB_ID_NULL ;
}
//----------------------------------------------------------------------------
int
Machining::ToolPreview( int nEntId, int nStep) const
{
// verifico validità gestori DB geometrico e CAM
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return GDB_ID_NULL ;
// recupero la testa nel gruppo per anteprima utensile
int nStId = m_pGeomDB->GetFirstGroupInGroup( m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST)) ;
if ( nStId == GDB_ID_NULL)
return GDB_ID_NULL ;
m_pGeomDB->SetStatus( nStId, GDB_ST_OFF) ;
// recupero gruppo per geometria di lavorazione (Cutter Location)
int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
if ( nClId == GDB_ID_NULL)
return GDB_ID_NULL ;
int nParentId ;
// se entità nulla
if ( nEntId == GDB_ID_NULL || ! m_pGeomDB->ExistsObj( nEntId)) {
// recupero il gruppo di appartenenza
nParentId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
// se richiesta successiva
if ( nStep > 0)
nEntId = GetToolPreviewNext( nEntId, nParentId, nStId) ;
// se richiesta precedente
else if ( nStep < 0)
nEntId = GetToolPreviewPrev( nEntId, nParentId, nStId) ;
// altrimenti richiesta corrente
else
nEntId = GDB_ID_NULL ;
}
// altrimenti
else {
// verifico che l'entità stia in un sottogruppo di CL
nParentId = m_pGeomDB->GetParentId( nEntId) ;
if ( m_pGeomDB->GetParentId( nParentId) == nClId) {
// se richiesta successiva
if ( nStep > 0) {
while ( nStep > 0) {
int nOldId = nEntId ;
nEntId = GetToolPreviewNext( nEntId, nParentId, nStId) ;
-- nStep ;
if ( nEntId == GDB_ID_NULL) {
nEntId = nOldId ;
break ;
}
}
}
// se richiesta precedente
else if ( nStep < 0) {
while ( nStep < 0) {
int nOldId = nEntId ;
nEntId = GetToolPreviewPrev( nEntId, nParentId, nStId) ;
++ nStep ;
if ( nEntId == GDB_ID_NULL) {
nEntId = nOldId ;
break ;
}
}
}
}
else
nEntId = GDB_ID_NULL ;
}
// se esiste il gruppo genitore, visualizzo testa preview
if ( nParentId != GDB_ID_NULL)
m_pGeomDB->SetStatus( nStId, GDB_ST_ON) ;
// recupero i dati di questa entità
const CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
if ( pCamData == nullptr)
return GDB_ID_NULL ;
Point3d ptEnd = pCamData->GetEndPoint() ;
AdjustEndPointForAxesCalc( pCamData, ptEnd) ;
Vector3d vtTool = pCamData->GetToolDir() ;
Vector3d vtBAux = pCamData->GetBackAuxDir() ;
// dati correnti testa/uscita
int nExitId = m_pGeomDB->GetFirstNameInGroup( nStId, MCH_EXIT + ToString( GetExitNbr())) ;
Frame3d frExit ;
m_pGeomDB->GetGroupGlobFrame( nExitId, frExit) ;
// correggo eventuale movimento di disattivazione sempre in Z globale
double dVal ;
if ( m_pGeomDB->GetInfo( nExitId, MCH_EXIT_VAL, dVal))
frExit.Translate( -dVal * Z_AX) ;
Point3d ptOrig = frExit.Orig() ;
Vector3d vtDir = frExit.VersZ() ;
Vector3d vtAux ;
int nAvId = m_pGeomDB->GetFirstNameInGroup( nStId, MCH_AUX_VECT) ;
ExeStartVector( nAvId, GDB_ID_ROOT, vtAux) ;
// rototraslo opportunamente
Frame3d frHead ;
m_pGeomDB->GetGroupGlobFrame( nStId, frHead) ;
Frame3d frRef ;
if ( vtAux.IsSmall() || AreSameOrOppositeVectorApprox( vtAux, vtDir))
frRef.Set( ptOrig, vtDir) ;
else
frRef.Set( ptOrig, vtDir, vtAux) ;
Frame3d frShow ;
if ( vtBAux.IsSmall() || AreSameOrOppositeVectorApprox( vtBAux, vtTool))
frShow.Set( ptEnd + vtTool * GetToolData().m_dLen, vtTool) ;
else
frShow.Set( ptEnd + vtTool * GetToolData().m_dLen, vtTool, vtBAux) ;
frHead.ToLoc( frRef) ;
frHead.ToGlob( frShow) ;
*(m_pGeomDB->GetGroupFrame( nStId)) = frHead ;
return nEntId ;
}
//----------------------------------------------------------------------------
int
Machining::GetDoubleType( const string& sUserNotes)
{
int nDouble ;
if ( ! GetValInNotes( sUserNotes, UN_DOUBLE, nDouble) ||
( nDouble != 1 && nDouble != 2 && nDouble != 3))
return 0 ;
else
return nDouble ;
}
//----------------------------------------------------------------------------
bool
Machining::GetDoubleToolData( string& sDblTool, string& sDblHead, int& nDblExit)
{
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return false ;
// recupero il gestore DB utensili della macchina corrente
ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
if ( pTMgr == nullptr)
return false ;
// recupero dati utensile in doppio
if ( ! GetValInNotes( GetToolData().m_sUserNotes, "DOUBLE", sDblTool))
return false ;
string sDblTcPos ;
if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( sDblTool, sDblTcPos, sDblHead, nDblExit)) {
const ToolData* pTdata = pTMgr->GetTool( sDblTool) ;
if ( pTdata == nullptr)
return false ;
sDblHead = pTdata->m_sHead ;
nDblExit = pTdata->m_nExit ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Machining::CalcMirrorByDouble( int nClId, const string& sUserNotes)
{
if ( m_pGeomDB == nullptr || m_pMchMgr == nullptr)
return false ;
// verifico se prevista lavorazione in doppio
int nDouble = GetDoubleType( sUserNotes) ;
if ( nDouble == 0)
return true ;
// assegno Id entità originali
int nPathId = m_pGeomDB->GetFirstNameInGroup( nClId, MCH_PATH + "*") ;
while ( nPathId != GDB_ID_NULL) {
int nEntId = m_pGeomDB->GetFirstInGroup( nPathId) ;
while ( nEntId != GDB_ID_NULL) {
string sName ;
if ( ! m_pGeomDB->GetName( nEntId, sName) ||
( sName != MCH_CL_CLIMB && sName != MCH_CL_RISE && sName != MCH_CL_HOME))
m_pGeomDB->SetInfo( nEntId, KEY_DBL_MAIN, nEntId) ;
nEntId = m_pGeomDB->GetNext( nEntId) ;
}
nPathId = m_pGeomDB->GetNextName( nPathId, MCH_PATH + "*") ;
}
// copio gruppo di lavorazione e cambio nome
int nDblId = m_pGeomDB->Copy( nClId, GDB_ID_NULL, nClId, GDB_AFTER) ;
if ( nDblId == GDB_ID_NULL)
return false ;
m_pGeomDB->SetName( nDblId, MCH_DBL) ;
// assegno colore di copia
int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nDblId) ;
while ( nClPathId != GDB_ID_NULL) {
m_pGeomDB->SetMaterial( nClPathId, GRAY) ;
nClPathId = m_pGeomDB->GetNextGroup( nClPathId) ;
}
// assegno Id entità double
nPathId = m_pGeomDB->GetFirstNameInGroup( nDblId, MCH_PATH + "*") ;
while ( nPathId != GDB_ID_NULL) {
int nEntId = m_pGeomDB->GetFirstInGroup( nPathId) ;
while ( nEntId != GDB_ID_NULL) {
int nMainEntId ;
if ( m_pGeomDB->GetInfo( nEntId, KEY_DBL_MAIN, nMainEntId)) {
m_pGeomDB->RemoveInfo( nMainEntId, KEY_DBL_MAIN) ;
m_pGeomDB->SetInfo( nMainEntId, KEY_CL_DOUBLE, nEntId) ;
}
nEntId = m_pGeomDB->GetNext( nEntId) ;
}
nPathId = m_pGeomDB->GetNextName( nPathId, MCH_PATH + "*") ;
}
// determino posizione del piano di mirroring
BBox3d b3Raw ;
Point3d ptOn ;
if ( ! GetCurrRawsGlobBox( b3Raw) || ! b3Raw.GetCenter( ptOn))
return false ;
Vector3d vtNorm ;
switch ( nDouble) {
case 1 : vtNorm = X_AX ; break ;
case 2 : vtNorm = Y_AX ; break ;
case 3 : vtNorm = Z_AX ; break ;
}
double dPlanePos ;
if ( GetValInNotes( sUserNotes, UN_MIRRORAX, dPlanePos))
ptOn = b3Raw.GetMin() + dPlanePos * vtNorm ;
// eseguo mirroring rispetto a piano opportuno
nPathId = m_pGeomDB->GetFirstNameInGroup( nDblId, MCH_PATH + "*") ;
while ( nPathId != GDB_ID_NULL) {
int nEntId = m_pGeomDB->GetFirstInGroup( nPathId) ;
while ( nEntId != GDB_ID_NULL) {
m_pGeomDB->Mirror( nEntId, ptOn, vtNorm) ;
nEntId = m_pGeomDB->GetNext( nEntId) ;
}
nPathId = m_pGeomDB->GetNextName( nPathId, MCH_PATH + "*") ;
}
// se presente una differenza in Z, eseguo spostamento
double dDeltaZ ;
if ( GetValInNotes( sUserNotes, UN_DELTAZ, dDeltaZ) && abs( dDeltaZ) > EPS_SMALL)
m_pGeomDB->TranslateGlob( nDblId, Vector3d( 0, 0, dDeltaZ)) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Machining::ActivateDrillingUnit( int nHeadId, const INTVECTOR& vActExit) const
{
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// costanti
static const string EMC_VAR = "EMC" ; // tabella variabili locali per calcolo
static const string EVAR_VER = ".VER" ; // IN (string) versione della Dll
static const string EVAR_HEADID = ".HEADID" ; // IN (int) identificativo testa
static const string EVAR_DRACEX = ".DRACEX" ; // IN (ints) vettore indici uscite attive
static const string EVAR_ERROR = ".ERR" ; // OUT (int) codice di errore ( 0 = ok, > 0 errore)
static const string ON_ACTIVATE_DRILLING_UNIT = "OnActivateDrillingUnit" ;
// se non esiste la funzione, esco
if ( ! pMch->LuaExistsFunction( ON_ACTIVATE_DRILLING_UNIT))
return true ;
// eseguo l'azione
bool bOk = true ;
int nErr = 99 ;
// imposto valori parametri
bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_VER, GetEMkVer()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_HEADID, nHeadId) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_DRACEX, vActExit) ;
// eseguo
bOk = bOk && pMch->LuaCallFunction( ON_ACTIVATE_DRILLING_UNIT) ;
// recupero valori parametri obbligatori
bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
// reset
bOk = pMch->LuaResetGlobVar( EMC_VAR) && bOk ;
// segnalo errori
return ( bOk && nErr == 0) ;
}
//----------------------------------------------------------------------------
bool
Machining::SpecialApply( string& sErr)
{
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// costanti
static const string EMC_VAR = "EMC" ; // tabella variabili locali per calcolo
static const string EVAR_PHASE = ".PHASE" ; // IN (int) indice fase
static const string EVAR_MCHID = ".MCHID" ; // IN (int) identificativo della lavorazione
static const string EVAR_ERROR = ".ERR" ; // OUT (int) codice di errore ( 0 = ok, > 0 errore, < 0 warning)
static const string EVAR_MSG = ".MSG" ; // OUT (string) stringa di errore ( opzionale)
static const string ON_SPECIAL_APPLY = "OnSpecialApplyMachining" ;
// se non esiste la funzione, esco
if ( ! pMch->LuaExistsFunction( ON_SPECIAL_APPLY))
return true ;
// eseguo l'azione
bool bOk = true ;
int nErr = 99 ;
// imposto valori parametri
bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_PHASE, m_nPhase) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MCHID, m_nOwnerId) ;
// eseguo
bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_APPLY, false) ;
// recupero valori parametri obbligatori
bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
// recupero valori parametri opzionali
string sMsg ;
bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MSG, sMsg) ;
// reset
bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
// segnalo errori
if ( ! bOk || nErr > 0) {
bOk = false ;
sErr = sMsg ;
if ( IsEmptyOrSpaces( sErr))
sErr = " Error in " + ON_SPECIAL_APPLY + " (" + ToString( nErr) + ")" ;
}
// recupero eventuale warning
else if ( nErr < 0) {
string sOut = sMsg ;
if ( IsEmptyOrSpaces( sOut))
sOut = " Warning in " + ON_SPECIAL_APPLY + " (" + ToString( abs( nErr)) + ")" ;
m_pMchMgr->SetWarning( abs( nErr), sOut) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
Machining::PostApply( string& sErr)
{
// recupero la macchina corrente
Machine* pMch = m_pMchMgr->GetCurrMachine() ;
if ( pMch == nullptr)
return false ;
// costanti
static const string EMC_VAR = "EMC" ; // tabella variabili locali per calcolo
static const string EVAR_PHASE = ".PHASE" ; // IN (int) indice fase
static const string EVAR_MCHID = ".MCHID" ; // IN (int) identificativo della lavorazione
static const string EVAR_ERROR = ".ERR" ; // OUT (int) codice di errore ( 0 = ok, > 0 errore, < 0 warning)
static const string EVAR_MSG = ".MSG" ; // OUT (string) stringa di errore ( opzionale)
static const string ON_POST_APPLY = "OnPostApplyMachining" ;
// se non esiste la funzione, esco
if ( ! pMch->LuaExistsFunction( ON_POST_APPLY))
return true ;
// eseguo l'azione
bool bOk = true ;
int nErr = 99 ;
// imposto valori parametri
bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_PHASE, m_nPhase) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MCHID, m_nOwnerId) ;
// eseguo
bOk = bOk && pMch->LuaCallFunction( ON_POST_APPLY, false) ;
// recupero valori parametri obbligatori
bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
// recupero valori parametri opzionali
string sMsg ;
bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MSG, sMsg) ;
// reset
bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
// segnalo errori
if ( ! bOk || nErr > 0) {
bOk = false ;
sErr = sMsg ;
if ( IsEmptyOrSpaces( sErr))
sErr = " Error in " + ON_POST_APPLY + " (" + ToString( nErr) + ")" ;
}
// recupero eventuale warning
else if ( nErr < 0) {
string sOut = sMsg ;
if ( IsEmptyOrSpaces( sOut))
sOut = " Warning in " + ON_POST_APPLY + " (" + ToString( abs( nErr)) + ")" ;
m_pMchMgr->SetWarning( abs( nErr), sOut) ;
}
return bOk ;
}
Reference in New Issue View Git Blame Copy Permalink