Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtMachKernel :

Browse Source 
- prime modifiche per nuova versionedi NewLinkMgr (aggiunta OnSpecialLink).
This commit is contained in:
Dario Sassi
2025-07-07 15:01:59 +02:00
parent 3283f1780f
commit 2ed88f66e9
21 changed files with 604 additions and 613 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Operation.cpp
+416 -376
View File
@@ -2724,6 +2724,18 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
if ( IsEmpty( NEED_ONE_TP_OK))
return true ;
// se nuova gestione collegamenti tra lavorazioni oppure robot
if ( m_pMchMgr->GetCurrMachine()->GetNewLinkMgr() || m_pMchMgr->GetCurrIsRobot())
return AdjustStartEndMovementsNew( bVerifyPreviousLink) ;
// altrimenti modalità standard
else
return AdjustStartEndMovementsStd( bVerifyPreviousLink) ;
}
//----------------------------------------------------------------------------
bool
Operation::AdjustStartEndMovementsStd( bool bVerifyPreviousLink)
{
// recupero ultima operazione precedente non vuota o che richiede home precedente
// (disposizione qui considerata non vuota anche se nella path contiene solo comandi ausiliari)
int nPrevOpId = m_pMchMgr->GetPrevActiveOperation( m_nOwnerId) ;
@@ -2741,12 +2753,6 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
if ( pPrevOp != nullptr && ! pPrevOp->IsEmpty( NEED_ONE_TP_OK))
sPrevTool = pPrevOp->GetToolName() ;
// flag nuova gestione collegamenti tra lavorazioni
bool bNewLink = m_pMchMgr->GetCurrMachine()->GetNewLinkMgr() ;
// flag per CLIMB a inizio percorso già gestito
bool bClimbDone = false ;
// determino posizione precedente assi
DBLVECTOR vAxVal ;
bool bMaxZ = false ;
@@ -2761,16 +2767,6 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
return false ;
// si parte da Z massima
bMaxZ = true ;
// per nuova gestione collegamenti, verifica aree protette
if ( bVerifyPreviousLink && bNewLink && m_pMchMgr->GetCurrIsCenter()) {
// recupero posizione iniziale lavorazione
DBLVECTOR vAxIni ;
if ( ! GetInitialAxesValues( false, vAxIni))
return false ;
// eseguo verifica
if ( ! ManageProtectedAreas( vAxVal, vAxIni, nullptr, this, bClimbDone))
return false ;
}
}
// *** Se utensile non cambiato o su diversa uscita della stessa testa, uso posizione finale della lavorazione precedente
@@ -2791,194 +2787,177 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
DBLVECTOR vAxIni ;
if ( ! GetInitialAxesValues( false, vAxIni))
return false ;
// se centro di lavoro
if ( m_pMchMgr->GetCurrIsCenter()) {
// recupero se ZHome è in basso
bool bZHomeDown = GetZHomeDown() ;
// recupero quote home e max di Z
double dHomeZ ;
if ( ! m_pMchMgr->GetCurrAxisHomePos( 2, dHomeZ))
// recupero se ZHome è in basso
bool bZHomeDown = GetZHomeDown() ;
// recupero quote home e max di Z
double dHomeZ ;
if ( ! m_pMchMgr->GetCurrAxisHomePos( 2, dHomeZ))
return false ;
// se necessaria, aggiungo risalita parziale
double dDeltaZ = ( vAxIni[2] - vAxVal[2]) ;
if ( ( ! bZHomeDown && dDeltaZ > 100 * EPS_SMALL && vAxIni[2] <= dHomeZ) ||
( bZHomeDown && dDeltaZ < -100 * EPS_SMALL && vAxIni[2] >= dHomeZ)) {
if ( ! pPrevOp->AddRise( vAxVal, dDeltaZ))
return false ;
// se necessaria, aggiungo risalita parziale
double dDeltaZ = ( vAxIni[2] - vAxVal[2]) ;
if ( ( ! bZHomeDown && dDeltaZ > 100 * EPS_SMALL && vAxIni[2] <= dHomeZ) ||
( bZHomeDown && dDeltaZ < -100 * EPS_SMALL && vAxIni[2] >= dHomeZ)) {
if ( ! pPrevOp->AddRise( vAxVal, dDeltaZ))
return false ;
// aggiorno quota in Z della posizione iniziale ( anche se verrà aggiornata solo in seguito)
vAxIni[2] = vAxVal[2] ;
}
// Verifico non ci sia collisione a HomeZ
bool bToMaxZ = false ;
bool bToMyHomeZ = false ;
DBLVECTOR vAxVal2 = vAxVal ; vAxVal2[2] = dHomeZ ;
DBLVECTOR vAxIni2 = vAxIni ; vAxIni2[2] = dHomeZ ;
if ( ! TestCollisionAvoid( vAxVal2, vAxIni2)) {
// se ammessa risalita aggiuntiva
Vector3d vtTprev ; pPrevOp->GetFinalToolDir( false, vtTprev) ;
Vector3d vtTcurr ; GetInitialToolDir( false, vtTcurr) ;
double dExtraZ ;
if ( GetExtraZ( vAxVal2, vtTprev, vAxIni2, vtTcurr, dHomeZ, dExtraZ)) {
if ( abs( dExtraZ) > EPS_SMALL) {
double dMyHomeZ = dHomeZ + dExtraZ ;
vAxVal2[2] = dMyHomeZ ;
vAxIni2[2] = dMyHomeZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
dHomeZ = dMyHomeZ ;
bToMyHomeZ = true ;
}
else
bToMaxZ = true ;
// aggiorno quota in Z della posizione iniziale ( anche se verrà aggiornata solo in seguito)
vAxIni[2] = vAxVal[2] ;
}
// Verifico non ci sia collisione a HomeZ
bool bToMaxZ = false ;
bool bToMyHomeZ = false ;
DBLVECTOR vAxVal2 = vAxVal ; vAxVal2[2] = dHomeZ ;
DBLVECTOR vAxIni2 = vAxIni ; vAxIni2[2] = dHomeZ ;
if ( ! TestCollisionAvoid( vAxVal2, vAxIni2)) {
// se ammessa risalita aggiuntiva
Vector3d vtTprev ; pPrevOp->GetFinalToolDir( false, vtTprev) ;
Vector3d vtTcurr ; GetInitialToolDir( false, vtTcurr) ;
double dExtraZ ;
if ( GetExtraZ( vAxVal2, vtTprev, vAxIni2, vtTcurr, dHomeZ, dExtraZ)) {
if ( abs( dExtraZ) > EPS_SMALL) {
double dMyHomeZ = dHomeZ + dExtraZ ;
vAxVal2[2] = dMyHomeZ ;
vAxIni2[2] = dMyHomeZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
dHomeZ = dMyHomeZ ;
bToMyHomeZ = true ;
}
else
bToMaxZ = true ;
}
// se altrimenti ammessa rotazione a Zmax e richiesta rotazione
else if ( GetRotationAtZmax() &&
(( vAxVal2.size() >= 4 && abs( vAxVal2[3] - vAxIni2[3]) > 5) ||
( vAxVal2.size() >= 5 && abs( vAxVal2[4] - vAxIni2[4]) > 5))) {
// verifico se va bene rotazione assi iniziale e poi movimento
DBLVECTOR vAxMid2 = vAxVal2 ;
vAxMid2[3] = vAxIni2[3] ;
if ( vAxVal2.size() >= 5)
vAxMid2[4] = vAxIni2[4] ;
if ( TestCollisionAvoid( vAxVal2, vAxMid2) &&
TestCollisionAvoid( vAxMid2, vAxIni2) &&
pPrevOp->AddRise( vAxVal2) &&
pPrevOp->AddSpecialRise( vAxMid2, true, GDB_ID_NULL, 5)) {
vAxVal = vAxMid2 ;
bMaxZ = true ;
}
else
return false ;
else
bToMaxZ = true ;
}
// se altrimenti ammessa rotazione a Zmax e richiesta rotazione
else if ( GetRotationAtZmax() &&
(( vAxVal2.size() >= 4 && abs( vAxVal2[3] - vAxIni2[3]) > 5) ||
( vAxVal2.size() >= 5 && abs( vAxVal2[4] - vAxIni2[4]) > 5))) {
// verifico se va bene rotazione assi iniziale e poi movimento
DBLVECTOR vAxMid2 = vAxVal2 ;
vAxMid2[3] = vAxIni2[3] ;
if ( vAxVal2.size() >= 5)
vAxMid2[4] = vAxIni2[4] ;
if ( TestCollisionAvoid( vAxVal2, vAxMid2) &&
TestCollisionAvoid( vAxMid2, vAxIni2) &&
pPrevOp->AddRise( vAxVal2) &&
pPrevOp->AddSpecialRise( vAxMid2, true, GDB_ID_NULL, 5)) {
vAxVal = vAxMid2 ;
bMaxZ = true ;
}
// altrimenti impossibile
else
return false ;
}
// Recupero box complessivo dei grezzi attivi
BBox3d b3Raws ;
GetCurrRawsGlobBox( b3Raws) ;
// Se già a Zmax
if ( bMaxZ) {
// non devo fare alcunché
}
// se altrimenti richiesta risalita a Zmax
else if ( bToMaxZ || ForcedZmax( vAxVal, vAxIni, b3Raws)) {
// cancello eventuale risalita parziale della lavorazione precedente
pPrevOp->RemoveRise() ;
// aggiungo risalita a HomeZ/MaxZ
if ( ! pPrevOp->AddRise( vAxVal, NAN, GDB_ID_NULL, ( bNewLink ? ( bZHomeDown ? -1 : +1) : 0)))
return false ;
// si parte da Z massima
bMaxZ = true ;
}
// altrimenti, verifico se la testa interferisce con i pezzi o i bloccaggi sulla tavola
else if ( bToMyHomeZ || ! TestCollisionAvoid( vAxVal, vAxIni)) {
// riprovo con risalita parziale
bool bPartRise = false ;
double dSafeZ = dHomeZ ;
double dUnsafeZ = ( bZHomeDown ? min( vAxVal[2], vAxIni[2]) : max( vAxVal[2], vAxIni[2])) ;
if ( ( ! bZHomeDown && dUnsafeZ < dSafeZ) || ( bZHomeDown && dUnsafeZ > dSafeZ)) {
DBLVECTOR vAxVal2 = vAxVal ;
DBLVECTOR vAxIni2 = vAxIni ;
vAxVal2[2] = dUnsafeZ ;
vAxIni2[2] = dUnsafeZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
bPartRise = true ;
dSafeZ = dUnsafeZ ;
}
else {
for ( int i = 1 ; i <= 3 ; ++ i) {
double dTestSafeZ = ( dUnsafeZ + dSafeZ) / 2 ;
vAxVal2[2] = dTestSafeZ ;
vAxIni2[2] = dTestSafeZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
bPartRise = true ;
dSafeZ = dTestSafeZ ;
}
else {
dUnsafeZ = dTestSafeZ ;
}
}
}
// se necessario, riprovo appena prima di Zmax
if ( ! bPartRise) {
double dOffsZ = 1 * ( bZHomeDown ? 1 : -1) ;
vAxVal2[2] = dHomeZ + dOffsZ ;
vAxIni2[2] = dHomeZ + dOffsZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
bPartRise = true ;
dSafeZ = dHomeZ + dOffsZ ;
}
}
}
if ( ! bPartRise) {
// cancello eventuale risalita parziale della lavorazione precedente
pPrevOp->RemoveRise() ;
// aggiungo risalita a Zmax
if ( ! pPrevOp->AddRise( vAxVal))
return false ;
// si parte da Z massima
bMaxZ = true ;
}
else {
// cancello eventuale risalita parziale della lavorazione precedente
pPrevOp->RemoveRise() ;
// recupero le nuove quote finali (per calcolare il corretto delta)
pPrevOp->GetFinalAxesValues( false, vAxVal) ;
// aggiungo risalita a Zsafe
double dDelta = ( ! bZHomeDown ? max( dSafeZ - vAxVal[2], 0.) : min( dSafeZ - vAxVal[2], 0.)) ;
if ( ! pPrevOp->AddRise( vAxVal, dDelta))
return false ;
// aggiorno quota iniziale in Z
vAxIni[2] = dSafeZ ;
}
}
// gestione eventuali aree protette
if ( ! ManageProtectedAreas( vAxVal, vAxIni, pPrevOp, this, bClimbDone))
// altrimenti impossibile
else
return false ;
}
// se robot
else if ( m_pMchMgr->GetCurrIsRobot()) {
// recupero dati posizione finale lavorazione precedente
const CamData* pCdEnd = pPrevOp->GetFinalCamData( false) ;
const Point3d& ptPEnd = pCdEnd->GetEndPoint() ;
const Vector3d& vtDirEnd = pCdEnd->GetToolDir() ;
const Vector3d& vtAuxEnd = pCdEnd->GetAuxDir() ;
// recupero dati posizione iniziale lavorazione corrente
const CamData* pCdStart = GetInitialCamData( false) ;
const Point3d& ptPStart = pCdStart->GetEndPoint() ;
const Vector3d& vtDirStart = pCdStart->GetToolDir() ;
const Vector3d& vtAuxStart = pCdStart->GetAuxDir() ;
// verifico se collegamento diretto tra le due posizioni (muovendosi alla Z maggiore) è possibile senza collisioni
int nLowerPos = 0 ;
DBLVECTOR vAxEnd = vAxVal ;
DBLVECTOR vAxStart = vAxIni ;
if ( ptPEnd.z < ptPStart.z - 100 * EPS_SMALL) {
nLowerPos = - 1 ;
if ( ! CalcRobotAxesAbovePos( ptPEnd, vtDirEnd, vtAuxEnd, ptPStart.z - ptPEnd.z, vAxEnd))
return false ;
}
else if ( ptPEnd.z > ptPStart.z + 100 * EPS_SMALL) {
nLowerPos = 1 ;
if ( ! CalcRobotAxesAbovePos( ptPStart, vtDirStart, vtAuxStart, ptPEnd.z - ptPStart.z, vAxStart))
return false ;
}
if ( TestCollisionAvoid( vAxEnd, vAxStart)) {
if ( nLowerPos == -1) {
// aggiungo risalita a Z opportuna
if ( ! pPrevOp->AddRise( vAxVal, ptPStart.z - ptPEnd.z))
return false ;
// Recupero box complessivo dei grezzi attivi
BBox3d b3Raws ;
GetCurrRawsGlobBox( b3Raws) ;
// Se già a Zmax
if ( bMaxZ) {
// non devo fare alcunché
}
// se altrimenti richiesta risalita a Zmax
else if ( bToMaxZ || ForcedZmax( vAxVal, vAxIni, b3Raws)) {
// cancello eventuale risalita parziale della lavorazione precedente
pPrevOp->RemoveRise() ;
// aggiungo risalita a HomeZ/MaxZ
if ( ! pPrevOp->AddRise( vAxVal, NAN, GDB_ID_NULL, 0))
return false ;
// si parte da Z massima
bMaxZ = true ;
}
// altrimenti, verifico se la testa interferisce con i pezzi o i bloccaggi sulla tavola
else if ( bToMyHomeZ || ! TestCollisionAvoid( vAxVal, vAxIni)) {
// riprovo con risalita parziale
bool bPartRise = false ;
double dSafeZ = dHomeZ ;
double dUnsafeZ = ( bZHomeDown ? min( vAxVal[2], vAxIni[2]) : max( vAxVal[2], vAxIni[2])) ;
if ( ( ! bZHomeDown && dUnsafeZ < dSafeZ) || ( bZHomeDown && dUnsafeZ > dSafeZ)) {
DBLVECTOR vAxVal2 = vAxVal ;
DBLVECTOR vAxIni2 = vAxIni ;
vAxVal2[2] = dUnsafeZ ;
vAxIni2[2] = dUnsafeZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
bPartRise = true ;
dSafeZ = dUnsafeZ ;
}
else {
for ( int i = 1 ; i <= 3 ; ++ i) {
double dTestSafeZ = ( dUnsafeZ + dSafeZ) / 2 ;
vAxVal2[2] = dTestSafeZ ;
vAxIni2[2] = dTestSafeZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
bPartRise = true ;
dSafeZ = dTestSafeZ ;
}
else {
dUnsafeZ = dTestSafeZ ;
}
}
}
// se necessario, riprovo appena prima di Zmax
if ( ! bPartRise) {
double dOffsZ = 1 * ( bZHomeDown ? 1 : -1) ;
vAxVal2[2] = dHomeZ + dOffsZ ;
vAxIni2[2] = dHomeZ + dOffsZ ;
if ( TestCollisionAvoid( vAxVal2, vAxIni2)) {
bPartRise = true ;
dSafeZ = dHomeZ + dOffsZ ;
}
}
}
// altrimenti aggiungo risalita a Zmax
else {
if ( ! bPartRise) {
// cancello eventuale risalita parziale della lavorazione precedente
pPrevOp->RemoveRise() ;
// aggiungo risalita a Zmax
if ( ! pPrevOp->AddRise( vAxVal))
return false ;
// si parte da Z massima
bMaxZ = true ;
}
else {
// cancello eventuale risalita parziale della lavorazione precedente
pPrevOp->RemoveRise() ;
// recupero le nuove quote finali (per calcolare il corretto delta)
pPrevOp->GetFinalAxesValues( false, vAxVal) ;
// aggiungo risalita a Zsafe
double dDelta = ( ! bZHomeDown ? max( dSafeZ - vAxVal[2], 0.) : min( dSafeZ - vAxVal[2], 0.)) ;
if ( ! pPrevOp->AddRise( vAxVal, dDelta))
return false ;
// aggiorno quota iniziale in Z
vAxIni[2] = dSafeZ ;
}
}
// se ci sono aree protette...
if ( m_pMchMgr->GetCurrMachine()->ExistProtectedAreas()) {
// verifico se il collegamento le attraversa
const double PA_VERIF_LEN = 10 ;
Point3d ptStart( vAxVal[0], vAxVal[1], vAxVal[2]) ;
Point3d ptEnd( vAxIni[0], vAxIni[1], vAxIni[2]) ;
double dLen = DistXY( ptStart, ptEnd) ;
int nStep = int( dLen / PA_VERIF_LEN + 1) ;
bool bOutstroke = false ;
for ( int i = 1 ; i < nStep ; ++ i) {
Point3d ptCurr = Media( ptStart, ptEnd, double( i) / nStep) ;
int nStat = 0 ;
if ( ! m_pMchMgr->GetCurrMachine()->VerifyProtectedAreas( ptCurr.x, ptCurr.y, ptCurr.z, {}, nStat) || nStat != 0) {
bOutstroke = true ;
break ;
}
}
// in caso di attraversamento dell'area proibita
if ( bOutstroke) {
// chiamo funzione script OnSpecialRapidMove per avere nuovo punto intermedio
DBLVECTOR vAxNew ;
bool bModif = false ;
bool bOk = ( SpecialMoveRapid( vAxVal, vAxIni, vAxNew, bModif) && bModif) ;
// inserisco il nuovo punto alla fine della lavorazione precedente
if ( bOk)
vAxVal = vAxNew ;
if ( ! pPrevOp->AddSpecialRise( vAxVal, bOk))
return false ;
}
}
}
// altrimenti non richiesta verifica collegamento con lavorazione precedente
@@ -3001,18 +2980,6 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
if ( ! pPrevOp->AddRise( vAxVal))
return false ;
}
// per nuova gestione collegamenti, verifica aree protette
if ( bVerifyPreviousLink && bNewLink && m_pMchMgr->GetCurrIsCenter()) {
// recupero posizione finale lavorazione
if ( ! pPrevOp->GetFinalAxesValues( false, vAxVal))
return false ;
// recupero posizione home
DBLVECTOR vAxIni ;
if ( ! m_pMchMgr->GetAllCurrAxesHomePos( vAxIni))
return false ;
if ( ! pPrevOp->ManageProtectedAreas( vAxVal, vAxIni, pPrevOp, nullptr, bClimbDone))
return false ;
}
// ripristino la lavorazione corrente
m_pMchMgr->SetCurrMachining( GetOwner()) ;
@@ -3024,16 +2991,6 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
return false ;
// si parte da Z massima
bMaxZ = true ;
// per nuova gestione collegamenti, verifica aree protette
if ( bVerifyPreviousLink && bNewLink && m_pMchMgr->GetCurrIsCenter()) {
// recupero posizione iniziale lavorazione
DBLVECTOR vAxIni ;
if ( ! GetInitialAxesValues( false, vAxIni))
return false ;
// eseguo verifica
if ( ! ManageProtectedAreas( vAxVal, vAxIni, nullptr, this, bClimbDone))
return false ;
}
}
// aggiusto l'inizio di ogni percorso di lavoro
@@ -3042,7 +2999,7 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
int nClPathId = GetFirstFullToolpath() ;
while ( bOk && nClPathId != GDB_ID_NULL) {
// se richiesta verifica collegamento con lavorazione precedente, sistemo inizio
if ( bVerifyPreviousLink && ( ! bClimbDone || nPrevClPathId != GDB_ID_NULL)) {
if ( bVerifyPreviousLink) {
if ( ! AdjustOneStartEndMovement( nClPathId, nPrevClPathId, pPrevOp, vAxVal, bMaxZ))
bOk = false ;
}
@@ -3059,16 +3016,145 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
// Aggiungo risalita finale
bOk = bOk && AddRise( vAxVal) ;
// per nuova gestione collegamenti, verifica aree protette
if ( bVerifyPreviousLink && bNewLink && m_pMchMgr->GetCurrIsCenter()) {
// recupero posizione finale lavorazione
if ( ! GetFinalAxesValues( false, vAxVal))
// se ultima operazione o la successiva lo richiede, vado in home
int nNextOpId = m_pMchMgr->GetNextActiveOperation( m_nOwnerId) ;
Operation* pNextOp = GetOperation( m_pGeomDB->GetUserObj( nNextOpId)) ;
if ( pNextOp == nullptr || pNextOp->NeedPrevHome() ||
( IsValidMachiningType( pNextOp->GetType()) && ! pNextOp->IsAtLeastOnePathOk()))
bOk = bOk && AddHome() ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Operation::AdjustStartEndMovementsNew( bool bVerifyPreviousLink)
{
// recupero ultima operazione precedente non vuota o che richiede home precedente
// (disposizione qui considerata non vuota anche se nella path contiene solo comandi ausiliari)
int nPrevOpId = m_pMchMgr->GetPrevActiveOperation( m_nOwnerId) ;
Operation* pPrevOp = GetOperation( m_pGeomDB->GetUserObj( nPrevOpId)) ;
while ( pPrevOp != nullptr) {
if ( ! pPrevOp->IsEmpty( NEED_ONE_TP_OK) || pPrevOp->NeedPrevHome())
break ;
else {
nPrevOpId = m_pMchMgr->GetPrevActiveOperation( nPrevOpId) ;
pPrevOp = GetOperation( m_pGeomDB->GetUserObj( nPrevOpId)) ;
}
}
// recupero l'utensile precedente
string sPrevTool ;
if ( pPrevOp != nullptr && ! pPrevOp->IsEmpty( NEED_ONE_TP_OK))
sPrevTool = pPrevOp->GetToolName() ;
// determino posizione precedente assi
bool bMaxZ = false ;
// *** Se primo utensile o richiesto, uso la posizione home
if ( sPrevTool.empty() || NeedPrevHome()) {
// imposto l'utensile per i calcoli macchina
if ( ! m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()))
return false ;
// recupero posizione home
DBLVECTOR vAxIni ;
if ( ! m_pMchMgr->GetAllCurrAxesHomePos( vAxIni))
// si parte da Z massima
bMaxZ = true ;
// eventuale collegamento speciale
if ( bVerifyPreviousLink) {
// eseguo collegamento speciale
if ( ! ManageSpecialLink( nullptr, GDB_ID_NULL, this, GDB_ID_NULL))
return false ;
}
}
// *** Se utensile non cambiato o su diversa uscita della stessa testa, uso posizione finale della lavorazione precedente
else if ( ! ToolChangeNeeded( *pPrevOp, *this)) {
// imposto l'utensile per i calcoli macchina
if ( ! m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()))
return false ;
if ( ! ManageProtectedAreas( vAxVal, vAxIni, this, nullptr, bClimbDone))
// se richiesta verifica collegamento con lavorazione precedente
if ( bVerifyPreviousLink) {
// cancello eventuale risalita finale lavorazione precedente
pPrevOp->RemoveRise() ;
// recupero posizione finale lavorazione precedente
DBLVECTOR vAxVal ;
if ( ! pPrevOp->GetFinalAxesValues( false, vAxVal))
return false ;
// sistemo collegamento con lavorazione precedente
if ( ! AdjustOneStartEndMovement( GetFirstFullToolpath(), GDB_ID_NULL, pPrevOp, vAxVal, bMaxZ))
return false ;
// gestione collegamento speciale
if ( ! ManageSpecialLink( pPrevOp, GDB_ID_NULL, this, GDB_ID_NULL))
return false ;
}
}
// *** Altrimenti aggiungo uscita per cambio utensile alla lavorazione precedente e parto da questa
else {
// imposto la lavorazione precedente come corrente
m_pMchMgr->SetCurrMachining( pPrevOp->GetOwner()) ;
// imposto l'utensile precedente per i calcoli macchina
if ( ! m_pMchMgr->SetCalcTool( pPrevOp->GetToolName(), pPrevOp->GetHeadName(), pPrevOp->GetExitNbr()))
return false ;
// ricalcolo risalita di lavorazione precedente (se già calcolata)
if ( pPrevOp->RemoveRise()) {
DBLVECTOR vAxVal ;
if ( ! pPrevOp->AddRise( vAxVal))
return false ;
}
// se richiesta verifica collegamento con lavorazione precedente
if ( bVerifyPreviousLink) {
// eventuale rilascio utensile speciale di lavorazione precedente
if ( ! pPrevOp->ManageSpecialLink( pPrevOp, GDB_ID_NULL, nullptr, GDB_ID_NULL))
return false ;
}
// ripristino la lavorazione corrente
m_pMchMgr->SetCurrMachining( GetOwner()) ;
// imposto l'utensile per i calcoli macchina
if ( ! m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()))
return false ;
// si parte da Z massima
bMaxZ = true ;
// eventuale presa utensile speciale di lavorazione corrente
if ( bVerifyPreviousLink) {
// eseguo verifica
if ( ! ManageSpecialLink( nullptr, GDB_ID_NULL, this, GDB_ID_NULL))
return false ;
}
}
// aggiusto il collegamento iniziale di ogni percorso di lavoro successivo al primo
bool bOk = true ;
int nPrevClPathId = GetFirstFullToolpath() ;
int nClPathId = GetNextFullToolpath( nPrevClPathId) ;
while ( bOk && nClPathId != GDB_ID_NULL) {
// se richiesta verifica collegamento con lavorazione precedente
if ( bVerifyPreviousLink) {
// recupero nuovi finali senza risalite
RemoveRise( nPrevClPathId) ;
DBLVECTOR vAxVal ;
if ( ! GetClPathFinalAxesValues( nPrevClPathId, false, vAxVal))
bOk = false ;
// sistemo collegamento con precedente
if ( ! AdjustOneStartEndMovement( nClPathId, nPrevClPathId, nullptr, vAxVal, bMaxZ))
bOk = false ;
// gestione collegamento speciale ( tra due percorsi della stessa lavorazione)
if ( ! ManageSpecialLink( this, nPrevClPathId, this, nClPathId))
return false ;
}
bMaxZ = false ;
// passo al successivo
nPrevClPathId = nClPathId ;
nClPathId = GetNextFullToolpath( nClPathId) ;
pPrevOp = nullptr ;
}
// Aggiungo risalita finale
DBLVECTOR vAxVal ;
bOk = bOk && AddRise( vAxVal) ;
// nuova verifica aree protette alla fine
if ( bVerifyPreviousLink) {
if ( ! ManageSpecialLink( this, GDB_ID_NULL, nullptr, GDB_ID_NULL))
return false ;
}
@@ -3084,116 +3170,58 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
//----------------------------------------------------------------------------
bool
Operation::ManageProtectedAreas( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, Operation* pPrevOp, Operation* pNextOp,
bool& bClimbDone)
Operation::ManageSpecialLink( Operation* pPrevOpe, int nPrevClPathId, Operation* pNextOpe, int nNextClPathId)
{
// se non ci sono aree protette, esco subito.
if ( ! m_pMchMgr->GetCurrMachine()->ExistProtectedAreas())
return true ;
// il numero di assi non deve cambiare
if ( vAxStart.size() != vAxEnd.size())
// controlli
if ( pPrevOpe == nullptr && pNextOpe == nullptr)
return false ;
int nAxisTot = int( vAxStart.size()) ;
// recupero flag nuova gestione collegamenti tra lavorazioni
bool bNewLink = m_pMchMgr->GetCurrMachine()->GetNewLinkMgr() ;
// codifica tipo di collegamento
int nLinkType = ( pPrevOp == nullptr ? 0 : 2) + ( pNextOp == nullptr ? 0 : 1) ;
// Verifico se il collegamento le attraversa
Point3d ptSta( vAxStart[0], vAxStart[1], vAxStart[2]) ;
Point3d ptEnd( vAxEnd[0], vAxEnd[1], vAxEnd[2]) ;
DBLVECTOR vAngSta ;
for ( int i = 3 ; i < int( vAxStart.size()) && bNewLink ; ++ i)
vAngSta.emplace_back( vAxStart[i]) ;
DBLVECTOR vAngEnd ;
for ( int i = 3 ; i < int( vAxEnd.size()) && bNewLink ; ++ i)
vAngEnd.emplace_back( vAxEnd[i]) ;
// verifico inizio e fine
int nOutstroke = 0 ;
int nStSta = 0 ;
if ( ! m_pMchMgr->GetCurrMachine()->VerifyProtectedAreas( ptSta.x, ptSta.y, ptSta.z, vAngSta, nLinkType, nStSta) || nStSta != 0)
nOutstroke |= 2 ;
int nStEnd = 0 ;
if ( ! m_pMchMgr->GetCurrMachine()->VerifyProtectedAreas( ptEnd.x, ptEnd.y, ptEnd.z, vAngEnd, nLinkType, nStEnd) || nStEnd != 0)
nOutstroke |= 1 ;
// verifico i punti intermedi
const double PA_VERIF_LEN = 10 ;
double dLen = DistXY( ptSta, ptEnd) ;
int nStep = int( dLen / PA_VERIF_LEN) + 1 ;
for ( int i = 1 ; i < nStep && nOutstroke == 0 ; ++ i) {
double dCoeff = double( i) / nStep ;
Point3d ptCurr = Media( ptSta, ptEnd, dCoeff) ;
DBLVECTOR vAng ;
for ( int j = 0 ; j < int( vAngSta.size()) ; ++ j)
vAng.emplace_back( ( 1 - dCoeff) * vAngSta[j] + dCoeff * vAngEnd[j]) ;
int nStat = 0 ;
if ( ! m_pMchMgr->GetCurrMachine()->VerifyProtectedAreas( ptCurr.x, ptCurr.y, ptCurr.z, vAng, nLinkType, nStat) || nStat != 0)
nOutstroke |= 4 ;
}
if ( nOutstroke == 0)
return true ;
int nLinkType = ( pPrevOpe != nullptr ? 2 : 0) + ( pNextOpe != nullptr ? 1 : 0) ;
// assegno valori assi iniziali e finali, depurati di approcci/retrazioni aggiuntive (CLIMB e RISE) in area protetta
DBLVECTOR vNeatAxSta ;
if ( bNewLink && pPrevOp && ( nOutstroke & 2) != 0)
pPrevOp->GetFinalAxesValues( true, vNeatAxSta) ;
DBLVECTOR vAxSta, vNeatAxSta ;
if ( pPrevOpe != nullptr) {
if ( nPrevClPathId == GDB_ID_NULL) {
pPrevOpe->GetFinalAxesValues( false, vAxSta) ;
pPrevOpe->GetFinalAxesValues( true, vNeatAxSta) ;
}
else {
pPrevOpe->GetClPathFinalAxesValues( nPrevClPathId, false, vAxSta) ;
pPrevOpe->GetClPathFinalAxesValues( nPrevClPathId, true, vNeatAxSta) ;
}
}
else
vNeatAxSta = vAxStart ;
DBLVECTOR vNeatAxEnd ;
if ( bNewLink && pNextOp && ( nOutstroke & 1) != 0)
pNextOp->GetInitialAxesValues( true, vNeatAxEnd) ;
m_pMchMgr->GetAllCurrAxesHomePos( vNeatAxSta) ;
DBLVECTOR vAxEnd, vNeatAxEnd ;
if ( pNextOpe != nullptr) {
if ( nNextClPathId == GDB_ID_NULL) {
pNextOpe->GetInitialAxesValues( false, vAxEnd) ;
pNextOpe->GetInitialAxesValues( true, vNeatAxEnd) ;
}
else {
pNextOpe->GetClPathInitialAxesValues( nNextClPathId, false, vAxEnd) ;
pNextOpe->GetClPathInitialAxesValues( nNextClPathId, true, vNeatAxEnd) ;
}
}
else
vNeatAxEnd = vAxEnd ;
if ( int( vNeatAxSta.size()) != nAxisTot || int( vNeatAxEnd.size()) != nAxisTot)
m_pMchMgr->GetAllCurrAxesHomePos( vNeatAxEnd) ;
if ( vNeatAxSta.size() != vNeatAxEnd.size())
return false ;
// chiamo funzione script OnSpecialRapidMove per avere posizioni di movimento
POSVECTOR vPosNew ;
bool bOk = SpecialMoveRapid( vNeatAxSta, vNeatAxEnd, nOutstroke, nLinkType, vPosNew) ;
// se tutto bene, eseguo cancellazioni e inserimenti come richiesto
if ( bOk) {
bClimbDone = bNewLink ;
// eventuali cancellazioni
if ( bNewLink && ( nOutstroke & 2) != 0 && pPrevOp != nullptr)
pPrevOp->RemoveRise() ;
if ( bNewLink && ( nOutstroke & 1) != 0 && pNextOp != nullptr)
pNextOp->RemoveClimb() ;
// eventuali inserimenti
for ( const auto& PosNew : vPosNew) {
if ( PosNew.nSide == 2) {
if ( pPrevOp == nullptr ||
! pPrevOp->AddSpecialRise( PosNew.vAxis, true, GDB_ID_NULL,
PosNew.nFlag, PosNew.nFlag2, PosNew.nMask, PosNew.sInfo))
return false ;
}
else if ( PosNew.nSide != 1)
bool bOk = SpecialLink( vNeatAxSta, vNeatAxEnd, nLinkType, pPrevOpe, pNextOpe) ;
// in caso di errore eseguo inserimento con segnalazione di errore
if ( ! bOk) {
if ( pPrevOpe != nullptr) {
if ( ! pPrevOpe->AddSpecialRise( vAxSta, false))
return false ;
}
for ( int i = int( vPosNew.size()) - 1 ; i >= 0 ; --i) {
const auto& PosNew = vPosNew[i] ;
if ( PosNew.nSide == 1) {
if ( pNextOp == nullptr ||
! pNextOp->AddSpecialClimb( PosNew.vAxis, true, GDB_ID_NULL,
PosNew.nFlag, PosNew.nFlag2, PosNew.nMask, PosNew.sInfo))
return false ;
}
}
}
// altrimenti eseguo inserimento con segnalazione di errore
else {
if ( pPrevOp != nullptr) {
if ( ! pPrevOp->AddSpecialRise( vAxStart, false))
if ( pNextOpe != nullptr) {
if ( ! pNextOpe->AddSpecialClimb( vAxEnd, false))
return false ;
}
if ( pNextOp != nullptr) {
if ( ! pNextOp->AddSpecialClimb( vAxEnd, false))
return false ;
}
if ( pPrevOp == nullptr && pNextOp == nullptr)
return false ;
}
return true ;
@@ -3554,18 +3582,18 @@ Operation::AdjustOneStartEndMovement( int nClPathId, int nPrevClPathId, Operatio
//----------------------------------------------------------------------------
bool
Operation::ToolChangeNeeded( const Operation& Op1, const Operation& Op2) const
Operation::ToolChangeNeeded( const Operation& Ope1, const Operation& Ope2) const
{
// se non cambia l'utensile, non cambia la testa fisica
if ( EqualNoCase( Op1.GetToolName(), Op2.GetToolName()))
if ( EqualNoCase( Ope1.GetToolName(), Ope2.GetToolName()))
return false ;
// se non hanno TcPos e stanno sulla stessa testa con uscita diversa, non cambia la testa fisica
if ( Op1.GetToolTcPos().empty() && Op2.GetToolTcPos().empty() &&
EqualNoCase( Op1.GetHeadName(), Op2.GetHeadName()) && Op1.GetExitNbr() != Op2.GetExitNbr())
if ( Ope1.GetToolTcPos().empty() && Ope2.GetToolTcPos().empty() &&
EqualNoCase( Ope1.GetHeadName(), Ope2.GetHeadName()) && Ope1.GetExitNbr() != Ope2.GetExitNbr())
return false ;
// se hanno lo stesso TcPos e stanno sulla stessa testa con uscita diversa, non cambia la testa fisica
if ( EqualNoCase( Op1.GetToolTcPos(), Op2.GetToolTcPos()) &&
EqualNoCase( Op1.GetHeadName(), Op2.GetHeadName()) && Op1.GetExitNbr() != Op2.GetExitNbr())
if ( EqualNoCase( Ope1.GetToolTcPos(), Ope2.GetToolTcPos()) &&
EqualNoCase( Ope1.GetHeadName(), Ope2.GetHeadName()) && Ope1.GetExitNbr() != Ope2.GetExitNbr())
return false ;
// altrimenti necessario un cambio
return true ;
@@ -4969,8 +4997,63 @@ Operation::SpecialMoveZup( DBLVECTOR& vAx, Vector3d& vtTool, int& nFlag, int& nF
//----------------------------------------------------------------------------
bool
Operation::SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, int nOutstroke, int nLinkType,
POSVECTOR& vNewPos)
Operation::SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, DBLVECTOR& vAxNew, bool& bModif)
{
// recupero la macchina corrente
Machine* pMch = ( m_pMchMgr != nullptr ? m_pMchMgr->GetCurrMachine() : nullptr) ;
if ( pMch == nullptr)
return false ;
// costanti
static const string EMC_VAR = "EMC" ; // tabella variabili locali per calcolo
static const string EVAR_ERROR = ".ERR" ; // OUT (int) codice di errore ( 0 = ok)
static const string EVAR_MODIF = ".MODIF" ; // OUT (bool) flag di modifica effettuata
static const string ON_SPECIAL_MOVERAPID = "OnSpecialMoveRapid" ;
// se funzione non implementata
if ( ! pMch->LuaExistsFunction( ON_SPECIAL_MOVERAPID)) {
bModif = false ;
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 + GVAR_TOOL, GetToolName()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_HEAD, GetHeadName()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_EXIT, GetExitNbr()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TCPOS, GetToolTcPos()) ;
// valore degli assi
bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
int nNumAxes = int( vAxStart.size()) ;
for ( int i = 1 ; i <= nNumAxes ; ++ i)
bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR, bIsRobot), vAxStart[i-1]) ;
for ( int i = 1 ; i <= nNumAxes ; ++ i)
bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAxEnd[i-1]) ;
// eseguo
bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_MOVERAPID, false) ;
// recupero valori parametri obbligatori
bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MODIF, bModif) ;
vAxNew.resize( nNumAxes) ;
for ( int i = 1 ; i <= nNumAxes ; ++ i)
bOk = bOk && pMch->LuaGetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAxNew[i-1]) ;
// reset
bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
// segnalo errori
if ( nErr != 0) {
bOk = false ;
string sOut = " Error in " + ON_SPECIAL_MOVERAPID + " (" + ToString( nErr) + ")" ;
LOG_ERROR( GetEMkLogger(), sOut.c_str())
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
Operation::SpecialLink( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, int nLinkType,
const Operation* pPrevOpe, const Operation* pNextOpe)
{
// recupero la macchina corrente
Machine* pMch = ( m_pMchMgr != nullptr ? m_pMchMgr->GetCurrMachine() : nullptr) ;
@@ -4978,16 +5061,16 @@ Operation::SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd,
return false ;
// costanti
static const string EMC_VAR = "EMC" ; // tabella variabili locali per calcolo
static const string EVAR_OUTSTROKE = ".OUTSTROKE" ; // IN (int) codice extracorsa posizioni (1=Inizio, 2=Fine, 3=FinePrec+InizioSucc))
static const string EVAR_LINKTYPE = ".LINKTYPE" ; // IN (int) codice tipo collegamento (1=Inizio, 2=Fine, 3=FinePrec+InizioSucc))
static const string EVAR_PREVMCHID = ".PREVMCHID" ; // IN (int) identificativo lavorazione precedente
static const string EVAR_PREVPHASE = ".PREVPHASE" ; // IN (int) indice fase della lavorazione precedente
static const string EVAR_NEXTMCHID = ".NEXTMCHID" ; // IN (int) identificativo lavorazione successiva
static const string EVAR_NEXTPHASE = ".NEXTPHASE" ; // IN (int) indice fase della lavorazione successiva
static const string EVAR_LINKTYPE = ".LINKTYPE" ; // IN (int) codice tipo collegamento (1=Inizio, 2=Fine, 3=FinePrec+InizioSucc)
static const string EVAR_ERROR = ".ERR" ; // OUT (int) codice di errore ( 0 = ok)
static const string EVAR_POSTOT = ".POSTOT" ; // OUT (int) numero di nuove posizioni
static const string EVAR_POS = ".POS" ; // OUT (table) vettore di posizioni
static const string EVAR_SIDE = ".SIDE" ; // OUT (int) codice inserimento movimento (1=Inizio, 2=Fine)
static const string ON_SPECIAL_MOVERAPID = "OnSpecialMoveRapid" ;
static const string ON_SPECIAL_LINK = "OnSpecialLink" ;
// se la funzione non è definita, esco
if ( ! pMch->LuaExistsFunction( ON_SPECIAL_MOVERAPID))
if ( ! pMch->LuaExistsFunction( ON_SPECIAL_LINK))
return false ;
// eseguo
@@ -4999,9 +5082,11 @@ Operation::SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd,
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_HEAD, GetHeadName()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_EXIT, GetExitNbr()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TCPOS, GetToolTcPos()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_MCHID, GetOwner()) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_PREVMCHID, ( pPrevOpe != nullptr ? pPrevOpe->GetOwner() : GDB_ID_NULL)) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_PREVPHASE, ( pPrevOpe != nullptr ? pPrevOpe->m_nPhase : 0)) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_NEXTMCHID, ( pNextOpe != nullptr ? pNextOpe->GetOwner() : GDB_ID_NULL)) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_NEXTPHASE, ( pNextOpe != nullptr ? pNextOpe->m_nPhase : 0)) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_PHASE, m_nPhase) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OUTSTROKE, ( nOutstroke % 4)) ;
bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_LINKTYPE, nLinkType) ;
// valore degli assi
bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
@@ -5011,59 +5096,14 @@ Operation::SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd,
for ( int i = 1 ; i <= nNumAxes ; ++ i)
bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAxEnd[i-1]) ;
// eseguo
bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_MOVERAPID) ;
bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_LINK) ;
// recupero valori parametri obbligatori
bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) && nErr == 0 ;
// recupero i parametri facoltativi
int nPosTot ;
if ( ! pMch->LuaGetGlobVar( EMC_VAR + EVAR_POSTOT, nPosTot))
nPosTot = -1 ;
// recupero gli assi
vNewPos.clear() ;
if ( nPosTot == -1) {
vNewPos.resize( 1) ;
vNewPos[0].vAxis.resize( nNumAxes) ;
for ( int i = 1 ; i <= nNumAxes && bOk ; ++ i) {
if ( ! pMch->LuaGetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vNewPos[0].vAxis[i-1])) {
bOk = false ;
nErr = 91 ;
break ;
}
}
}
else {
for ( int j = 1 ; j <= nPosTot && bOk ; ++ j) {
string sRec = EMC_VAR + EVAR_POS + "." + ToString( j) ;
Position CurrPos ;
if ( ! pMch->LuaGetGlobVar( sRec + EVAR_SIDE, CurrPos.nSide)) {
bOk = false ;
nErr = 92 ;
break ;
}
CurrPos.vAxis.resize( nNumAxes) ;
for ( int i = 1 ; i <= nNumAxes ; ++ i) {
if ( ! pMch->LuaGetGlobVar( GetGlobVarAxisValue( i, sRec, bIsRobot), CurrPos.vAxis[i-1])) {
bOk = false ;
nErr = 93 ;
break ;
}
}
if ( ! pMch->LuaGetGlobVar( sRec + GVAR_MASK, CurrPos.nMask))
CurrPos.nMask = -1 ;
if ( ! pMch->LuaGetGlobVar( sRec + GVAR_FLAG, CurrPos.nFlag))
CurrPos.nFlag = 0 ;
if ( ! pMch->LuaGetGlobVar( sRec + GVAR_FLAG2, CurrPos.nFlag2))
CurrPos.nFlag2 = 0 ;
if ( ! pMch->LuaGetGlobVar( sRec + GVAR_INFO, CurrPos.sInfo))
CurrPos.sInfo = "" ;
vNewPos.emplace_back( CurrPos) ;
}
}
// reset
bOk = pMch->LuaResetGlobVar( EMC_VAR) && bOk ;
// segnalo errori
if ( ! bOk) {
string sOut = " Error in " + ON_SPECIAL_MOVERAPID + " (" + ToString( nErr) + ")" ;
string sOut = " Error in " + EVAR_LINKTYPE + " (" + ToString( nErr) + ")" ;
LOG_ERROR( GetEMkLogger(), sOut.c_str())
}
return bOk ;