From c0906ef63c7c40309d2e0cba42b609f8f34270bf Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Mon, 4 Mar 2019 08:04:32 +0000 Subject: [PATCH] =?UTF-8?q?EgtMachKernel=202.1c1=20:=20-=20corretta=20risa?= =?UTF-8?q?lita=20in=20Z=20tra=20lavorazioni=20(senza=20pi=C3=B9=20CalcDel?= =?UTF-8?q?taZForHeadRotation)=20-=20corretta=20svuotatura=20per=20reset?= =?UTF-8?q?=20flag=20lato=20aperto=20prima=20di=20analisi=20-=20modificata?= =?UTF-8?q?=20simulazione=20per=20gestire=20pi=C3=B9=20grezzi=20simultanea?= =?UTF-8?q?mente.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- EgtMachKernel.rc | Bin 11774 -> 11774 bytes Milling.cpp | 2 +- Operation.cpp | 91 +++++++++++++++++++++++++++++------------------ Operation.h | 1 + Pocketing.cpp | 30 ++++++++++++++-- Pocketing.h | 3 +- Simulator.cpp | 57 ++++++++++++++--------------- Simulator.h | 6 ++-- 8 files changed, 121 insertions(+), 69 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 726bf1ce371b8458efdf3583ef1631c506dd8056..b6ae9a59e8c5e0ea12e027f87299670c6836a54e 100644 GIT binary patch delta 121 zcmewt{V#gMH#Syd1|0^&&A-{KnVFLr3@1O7)ZLuM)x!c8zsNNCgkT;*P6$a3MUMyL R=2g-z%(yjz6ex#q0RU-NCWrt4 delta 121 zcmewt{V#gMH#Sxy1|0^I&A-{KnVFLqOeQ~+)ZLuM)x!c8zsNNCgkT;*P6$a3MUMyL R=2g-z%(yjz6ex#q0RU}7CYS&K diff --git a/Milling.cpp b/Milling.cpp index 519fbb3..83fb9e8 100644 --- a/Milling.cpp +++ b/Milling.cpp @@ -3504,7 +3504,7 @@ bool Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) { // eseguo offset semplice - int nFlag = ICurve::OFF_FILLET ; + int nFlag = ICurve::OFF_FILLET | ICurve::OFF_FORCE_OPEN ; if ( pCompo->SimpleOffset( dSignOffs, nFlag)) return true ; // se curva piatta, provo con offset avanzato diff --git a/Operation.cpp b/Operation.cpp index 1434cd4..f84c347 100644 --- a/Operation.cpp +++ b/Operation.cpp @@ -1394,31 +1394,38 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink) DBLVECTOR vAxIni ; if ( ! GetInitialAxesValues( vAxIni)) return false ; - // aggiungo eventuale delta Z - double dDeltaZ = 0 ; - // determino delta Z rispetto a posizione finale - if ( vAxVal.size() >= 4 && vAxIni.size() >= 4) { - // verifico se movimento assi rotanti richiede una risalita parziale - if ( ! CalcDeltaZForHeadRotation( vAxVal, vAxIni, dDeltaZ)) - return false ; - } - // confronto con eventuale risalita di inizio lavorazione - dDeltaZ = max( dDeltaZ, ( vAxIni[2] - vAxVal[2])) ; // se necessaria, aggiungo risalita parziale + double dDeltaZ = ( vAxIni[2] - vAxVal[2]) ; if ( dDeltaZ > 100 * EPS_SMALL) { 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 se la testa interferisce con i pezzi o i bloccaggi sulla tavola - if ( ! TestCollisionAvoid( vAxVal, vAxIni)) { - // riprovo con risalita parziale - double dHomeZ ; - if ( ! m_pMchMgr->GetCurrAxisHomePos( 2, dHomeZ)) + // Verifico non ci sia collisione a Zmax + double dSafeZ ; + if ( m_pMchMgr->GetCurrAxisHomePos( 2, dSafeZ)) { + DBLVECTOR vAxVal2 = vAxVal ; vAxVal2[2] = dSafeZ ; + DBLVECTOR vAxIni2 = vAxIni ; vAxIni2[2] = dSafeZ ; + if ( ! TestCollisionAvoid( vAxVal2, vAxIni2)) return false ; + } + else + return false ; + // Se richiesta risalita a Zmax + if ( ForcedZmax( vAxVal, vAxIni)) { + // 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 ; + } + // altrimenti, verifico se la testa interferisce con i pezzi o i bloccaggi sulla tavola + else if ( ! TestCollisionAvoid( vAxVal, vAxIni)) { + // riprovo con risalita parziale bool bPartRise = false ; - double dSafeZ = dHomeZ ; double dUnsafeZ = max( vAxVal[2], vAxIni[2]) ; DBLVECTOR vAxVal2 = vAxVal ; DBLVECTOR vAxIni2 = vAxIni ; @@ -1558,8 +1565,10 @@ Operation::AdjustOneStartMovement( int nClPathId, int nPrevClPathId, const DBLVE // per il test uso posizioni temporanee con questa Z DBLVECTOR vAxPrevTmp = vAxPrev ; vAxPrevTmp[2] = dTopZ ; DBLVECTOR vAxCurrTmp = vAxCurr ; vAxCurrTmp[2] = dTopZ ; + // verifico se forzata risalita a Zmax + bool bForcedZMax = ForcedZmax( vAxPrevTmp, vAxCurrTmp) ; // se interferisce - if ( ! TestCollisionAvoid( vAxPrevTmp, vAxCurrTmp)) { + if ( bForcedZMax || ! TestCollisionAvoid( vAxPrevTmp, vAxCurrTmp)) { // recupero HomeZ double dHomeZ ; if ( ! m_pMchMgr->GetCurrAxisHomePos( 2, dHomeZ)) @@ -1571,7 +1580,7 @@ Operation::AdjustOneStartMovement( int nClPathId, int nPrevClPathId, const DBLVE double dTestSafeZ = ( dUnsafeZ + dSafeZ) / 2 ; vAxPrevTmp[2] = dTestSafeZ ; vAxCurrTmp[2] = dTestSafeZ ; - if ( TestCollisionAvoid( vAxPrevTmp, vAxCurrTmp)) + if ( ! bForcedZMax && TestCollisionAvoid( vAxPrevTmp, vAxCurrTmp)) dSafeZ = dTestSafeZ ; else dUnsafeZ = dTestSafeZ ; @@ -1939,6 +1948,35 @@ Operation::CalcDeltaZForHeadRotation( const DBLVECTOR& vAxStart, const DBLVECTOR return true ; } +//---------------------------------------------------------------------------- +bool +Operation::ForcedZmax( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) +{ + // Recupero macchina corrente + Machine* pMch = ( m_pMchMgr != nullptr ? m_pMchMgr->GetCurrMachine() : nullptr) ; + if ( pMch == nullptr) + return true ; + // Recupero numero assi e ne verifico la costanza + int nLinAxes = m_pMchMgr->GetCurrLinAxes() ; + int nRotAxes = m_pMchMgr->GetCurrRotAxes() ; + if ( nLinAxes + nRotAxes != vAxStart.size() || nLinAxes + nRotAxes != vAxEnd.size()) + return true ; + // Se testa con Info ZMAXONROT != 0 e movimento assi rotanti -> risalita a Zmax + int nHeadId = pMch->GetCurrHead() ; + DBLVECTOR vdVal ; + if ( m_pGeomDB->GetInfo( nHeadId, MCH_ZMAXONROT, vdVal) && vdVal.size() >= 1 && lround(vdVal[0]) > 0) { + double dAngTol = 100 * EPS_ANG_SMALL ; + if ( vdVal.size() >= 2) + dAngTol = max( vdVal[1], dAngTol) ; + for ( int i = nLinAxes ; i < nLinAxes + nRotAxes ; ++ i) { + if ( abs( vAxEnd[i] - vAxStart[i]) > dAngTol) + return true ; + } + } + // Non forzata risalita a Zmax + return false ; +} + //---------------------------------------------------------------------------- bool Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) @@ -1951,26 +1989,11 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn string sTable ; if ( ! pMch->GetCurrTable( sTable)) return false ; - // Recupero assi correnti + // Recupero assi correnti e ne verifico la costanza STRVECTOR vAxName ; pMch->GetAllCurrAxesName( vAxName) ; - // il numero di assi deve essere costante if ( vAxName.size() != vAxStart.size() || vAxName.size() != vAxEnd.size()) return false ; - // Se testa con Info ZMAXONROT != 0 e movimento assi rotanti -> collisione - int nHeadId = pMch->GetCurrHead() ; - DBLVECTOR vdVal ; - if ( m_pGeomDB->GetInfo( nHeadId, MCH_ZMAXONROT, vdVal) && vdVal.size() >= 1 && lround(vdVal[0]) > 0) { - double dAngTol = 100 * EPS_ANG_SMALL ; - if ( vdVal.size() >= 2) - dAngTol = max( vdVal[1], dAngTol) ; - int nLinAxes = m_pMchMgr->GetCurrLinAxes() ; - int nRotAxes = m_pMchMgr->GetCurrRotAxes() ; - for ( int i = nLinAxes ; i < nLinAxes + nRotAxes ; ++ i) { - if ( int( vAxName.size()) > i && abs( vAxEnd[i] - vAxStart[i]) > dAngTol) - return false ; - } - } // Porto la macchina in home pMch->ResetAllAxesPos() ; // Elenco grezzi attivi diff --git a/Operation.h b/Operation.h index 6387bf3..a6165d2 100644 --- a/Operation.h +++ b/Operation.h @@ -103,6 +103,7 @@ class Operation : public IUserObj bool RemoveRise( int nClPathId = GDB_ID_NULL) ; bool AddHome( void) ; bool CalcDeltaZForHeadRotation( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, double& dDeltaZ) ; + bool ForcedZmax( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) ; bool TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) ; bool SpecialMoveZup( Vector3d& vtTool, DBLVECTOR& vAx, bool& bModif) ; diff --git a/Pocketing.cpp b/Pocketing.cpp index 67fd532..9e9699a 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -932,6 +932,8 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC) return false ; // la duplico pCurve.Set( pOriCurve->Clone()) ; + // reset proprietą temporanee + ResetCurveAllTempProp( pCurve) ; // se estrusione mancante, imposto default Vector3d vtExtr ; if ( ! pCurve->GetExtrusion( vtExtr) || vtExtr.IsSmall()) @@ -949,6 +951,8 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC) return false ; // la duplico pCurve.Set( pOriCurve->Clone()) ; + // reset proprietą temporanee + ResetCurveAllTempProp( pCurve) ; // recupero estrusione e spessore Vector3d vtExtr ; if ( ! pCompo->GetExtrusion( vtExtr) || vtExtr.IsSmall()) @@ -975,6 +979,9 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC) // recupero l'outline del testo if ( ! pText->GetOutline( lstPC)) return false ; + // reset proprietą temporanee + for ( auto pCrv : lstPC) + ResetCurveAllTempProp( pCrv) ; // porto le curve in globale for ( auto pCrv : lstPC) pCrv->ToGlob( frGlob) ; @@ -999,6 +1006,8 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC) pCrvCompo->FromPolyLine( vPL[0]) ; if ( ! pCrvCompo->IsValid()) return false ; + // reset proprietą temporanee + ResetCurveAllTempProp( pCrvCompo) ; // determino eventuali lati aperti e aggiorno proprietą del contorno int nInd = 0 ; double dPar ; @@ -1063,6 +1072,8 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC) PtrOwner pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo) || ! pCrvCompo->AddCurve( pReg->GetLoop( nC, nL))) return false ; + // reset proprietą temporanee + ResetCurveAllTempProp( pCrvCompo) ; // assegno l'estrusione dalla normale alla regione pCrvCompo->SetExtrusion( vtN) ; // unisco le eventuali parti allineate @@ -1082,6 +1093,21 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC) return false ; } +//---------------------------------------------------------------------------- +bool +Pocketing::ResetCurveAllTempProp( ICurve* pCurve) +{ + if ( pCurve == nullptr) + return false ; + pCurve->SetTempProp( 0) ; + ICurveComposite* pCC = GetCurveComposite( pCurve) ; + if ( pCC != nullptr) { + for ( int i = 0 ; i < pCC->GetCurveCount() ; ++ i) + pCC->SetCurveTempProp( i, 0) ; + } + return true ; +} + //---------------------------------------------------------------------------- bool Pocketing::Chain( int nGrpDestId) @@ -1429,7 +1455,7 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId) m_pGeomDB->SetName( nPxId, sPathName) ; m_pGeomDB->SetMaterial( nPxId, GREEN) ; // creo l'anteprima del percorso - if ( ! GenerateMillingPv( nPxId, pCompo)) + if ( ! GeneratePocketingPv( nPxId, pCompo)) return false ; } @@ -1611,7 +1637,7 @@ Pocketing::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& //---------------------------------------------------------------------------- bool -Pocketing::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) +Pocketing::GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) { // creo copia della curva composita PtrOwner< ICurve> pCrv( pCompo->Clone()) ; diff --git a/Pocketing.h b/Pocketing.h index 81f599e..198c5bb 100644 --- a/Pocketing.h +++ b/Pocketing.h @@ -65,11 +65,12 @@ class Pocketing : public Machining private : bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ; bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ; + bool ResetCurveAllTempProp( ICurve* pCurve) ; bool Chain( int nGrpDestId) ; bool ProcessPath( int nPathId, int nPvId, int nClId) ; bool CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) ; bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ; - bool GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) ; + bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ; bool AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, double dOkStep, bool bSplitArcs) ; bool CalcZigZag( const ICurveComposite* pOffs, ICRVCOMPOPOVECTOR& vpCrvs) ; diff --git a/Simulator.cpp b/Simulator.cpp index fedf69b..7aeece3 100644 --- a/Simulator.cpp +++ b/Simulator.cpp @@ -57,7 +57,6 @@ Simulator::Simulator( void) m_nAuxSInd = 0 ; m_nAuxETot = 0 ; m_nAuxEInd = 0 ; - m_nVmId = GDB_ID_NULL ; m_dVmTdOffs = 0 ; m_dVmAdOffs = 0 ; m_bEnabAxes = true ; @@ -176,7 +175,7 @@ Simulator::ResetInterpolation( void) m_nAuxSInd = 0 ; m_nAuxETot = 0 ; m_nAuxEInd = 0 ; - m_nVmId = GDB_ID_NULL ; + m_VmId.clear() ; m_dVmTdOffs = 0 ; m_dVmAdOffs = 0 ; m_bEnabAxes = true ; @@ -913,21 +912,24 @@ Simulator::ManageSingleMove( int& nStatus, double& dMove) dMove = ( m_dCoeff - dPrevCoeff) * dDist ; // Posizione e direzione attuali dell'utensile e riferimento attuale del pezzo (per Vmill) - Point3d ptNoseI ; Vector3d vtDirI ; Vector3d vtAuxI ; Frame3d frVzmI ; - bool bOkI = GetHeadCurrPosDirAux( ptNoseI, vtDirI, vtAuxI) && m_pGeomDB->GetGlobFrame( m_nVmId, frVzmI) ; + Point3d ptNoseI ; Vector3d vtDirI ; Vector3d vtAuxI ; + bool bOkI = GetHeadCurrPosDirAux( ptNoseI, vtDirI, vtAuxI) ; + vector vFrVzmI( m_VmId.size()) ; + for ( int i = 0 ; i < int( m_VmId.size()) ; ++ i) + bOkI = m_pGeomDB->GetGlobFrame( m_VmId[i], vFrVzmI[i]) && bOkI ; // Eseguo movimento rapido o lineare if ( nMoveType != 2 && nMoveType != 3) { // assegno posizioni finali - for ( size_t i = 0 ; i < m_AxesName.size() ; ++ i) { + for ( int i = 0 ; i < int( m_AxesName.size()) ; ++ i) { double dVal = m_AxesVal[i] * ( 1 - m_dCoeff) + AxesEnd[i] * m_dCoeff ; m_pMachine->SetAxisPos( m_AxesName[i], dVal) ; } // eseguo eventuale Vmill - if ( m_nVmId != GDB_ID_NULL) { + for ( int j = 0 ; j < int( m_VmId.size()) ; ++ j) { Point3d ptNoseF ; Vector3d vtDirF ; Vector3d vtAuxF ; Frame3d frVzmF ; - bool bOkF = GetHeadCurrPosDirAux( ptNoseF, vtDirF, vtAuxF) && m_pGeomDB->GetGlobFrame( m_nVmId, frVzmF) ; ; - ExecLineVmill( ptNoseI, vtDirI, vtAuxI, frVzmI, ptNoseF, vtDirF, vtAuxF, frVzmF) ; + bool bOkF = GetHeadCurrPosDirAux( ptNoseF, vtDirF, vtAuxF) && m_pGeomDB->GetGlobFrame( m_VmId[j], frVzmF) ; ; + ExecLineVmill( m_VmId[j], ptNoseI, vtDirI, vtAuxI, vFrVzmI[j], ptNoseF, vtDirF, vtAuxF, frVzmF) ; } } // Eseguo movimento su arco @@ -943,10 +945,10 @@ Simulator::ManageSingleMove( int& nStatus, double& dMove) vtRot.Rotate( vtN, dPrevCoeff * dAngCen) ; // approssimo movimento con 1 o pił step a seconda ci sia Vmill int nStep = 1 ; - if ( m_nVmId != GDB_ID_NULL) { + if ( ! m_VmId.empty()) { const double LEN_STEP = 2. ; nStep = max( int( abs( dDiffAng * DEGTORAD * dRad) / LEN_STEP), 1) ; - const double ANG_STEP = 10. ; + const double ANG_STEP = 5. ; if ( abs( dDiffAng) / nStep > ANG_STEP) nStep = int( abs( dDiffAng) / ANG_STEP) ; } @@ -958,20 +960,23 @@ Simulator::ManageSingleMove( int& nStatus, double& dMove) m_pMachine->SetAxisPos( m_AxesName[1], ptCen.y + vtRot.y + dCurrCoeff * dDeltaN * vtN.y) ; m_pMachine->SetAxisPos( m_AxesName[2], ptCen.z + vtRot.z + dCurrCoeff * dDeltaN * vtN.z) ; // assi rotanti - for ( size_t j = 3 ; j < m_AxesName.size() ; ++ j) { + for ( int j = 3 ; j < int( m_AxesName.size()) ; ++ j) { double dVal = m_AxesVal[j] * ( 1 - dCurrCoeff) + AxesEnd[j] * dCurrCoeff ; m_pMachine->SetAxisPos( m_AxesName[j], dVal) ; } // eseguo eventuale Vmill - if ( m_nVmId != GDB_ID_NULL) { - Point3d ptNoseF ; Vector3d vtDirF ; Vector3d vtAuxF ; Frame3d frVzmF ; - bool bOkF = GetHeadCurrPosDirAux( ptNoseF, vtDirF, vtAuxF) && m_pGeomDB->GetGlobFrame( m_nVmId, frVzmF) ; - ExecLineVmill( ptNoseI, vtDirI, vtAuxI, frVzmI, ptNoseF, vtDirF, vtAuxF, frVzmF) ; - // aggiorno prossimo inizio - ptNoseI = ptNoseF ; - vtDirI = vtDirF ; - frVzmI = frVzmF ; + Point3d ptNoseF ; Vector3d vtDirF ; Vector3d vtAuxF ; + bool bOkF = GetHeadCurrPosDirAux( ptNoseF, vtDirF, vtAuxF) ; + for ( int k = 0 ; k < int( m_VmId.size()) ; ++ k) { + Frame3d frVzmF ; + bOkF = m_pGeomDB->GetGlobFrame( m_VmId[k], frVzmF) && bOkF ; + ExecLineVmill( m_VmId[k], ptNoseI, vtDirI, vtAuxI, vFrVzmI[k], ptNoseF, vtDirF, vtAuxF, frVzmF) ; + // salvo riferimento per prossimo inizio + vFrVzmI[k] = frVzmF ; } + // aggiorno prossimo inizio + ptNoseI = ptNoseF ; + vtDirI = vtDirF ; } } } @@ -1046,11 +1051,11 @@ Simulator::GetHeadCurrPosDirAux( Point3d& ptH, Vector3d& vtH, Vector3d& vtA) //---------------------------------------------------------------------------- bool -Simulator::ExecLineVmill( const Point3d& ptHi, const Vector3d& vtHi, const Vector3d& vtAi, const Frame3d& frVzmI, - const Point3d& ptHf, const Vector3d& vtHf, const Vector3d& vtAf, const Frame3d& frVzmF) +Simulator::ExecLineVmill( int nVmId, const Point3d& ptHi, const Vector3d& vtHi, const Vector3d& vtAi, const Frame3d& frVzmI, + const Point3d& ptHf, const Vector3d& vtHf, const Vector3d& vtAf, const Frame3d& frVzmF) { // Recupero Zmap - IVolZmap* pVZM = GetVolZmap( m_pGeomDB->GetGeoObj( m_nVmId)) ; + IVolZmap* pVZM = GetVolZmap( m_pGeomDB->GetGeoObj( nVmId)) ; if ( pVZM == nullptr) return false ; // Porto gli estremi nel riferimento opportuno dello Zmap @@ -1145,9 +1150,7 @@ Simulator::OnDispositionStart( int nOpId, int nOpInd, int nPhase, // chiamo la funzione di inizio disposizione bOk = bOk && m_pMachine->LuaCallFunction( ON_SIMUL_DISPOSITION_START) ; // recupero i dati di ritorno - int nVmId = GDB_ID_NULL ; - m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_VMILL, nVmId) ; - m_nVmId = nVmId ; + m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_VMILL, m_VmId) ; // forzo aggiornamento posizione assi (possono essere stati mossi nello script) UpdateAxesPos() ; return bOk ; @@ -1163,9 +1166,7 @@ Simulator::OnDispositionEnd( void) // chiamo la funzione di fine disposizione bool bOk = m_pMachine->LuaCallFunction( ON_SIMUL_DISPOSITION_END) ; // recupero i dati di ritorno - int nVmId = GDB_ID_NULL ; - m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_VMILL, nVmId) ; - m_nVmId = nVmId ; + m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_VMILL, m_VmId) ; // forzo aggiornamento posizione assi (possono essere stati mossi nello script) UpdateAxesPos() ; return bOk ; diff --git a/Simulator.h b/Simulator.h index 1d4d4d6..a542b63 100644 --- a/Simulator.h +++ b/Simulator.h @@ -56,8 +56,8 @@ class Simulator bool ManageMove( int& nStatus) ; bool ManageSingleMove( int& nStatus, double& dMove) ; bool GetHeadCurrPosDirAux( Point3d& ptH, Vector3d& vtH, Vector3d& vtA) ; - bool ExecLineVmill( const Point3d& ptHi, const Vector3d& vtHi, const Vector3d& vtAi, const Frame3d& frVzmI, - const Point3d& ptHf, const Vector3d& vtHf, const Vector3d& vtAf, const Frame3d& frVzmF) ; + bool ExecLineVmill( int nVmId, const Point3d& ptHi, const Vector3d& vtHi, const Vector3d& vtAi, const Frame3d& frVzmI, + const Point3d& ptHf, const Vector3d& vtHf, const Vector3d& vtAf, const Frame3d& frVzmF) ; bool Stopped( void) { return ( m_nUiStatus == MCH_UISIM_STOP) ; } bool OnStart( bool bFirst) ; @@ -98,7 +98,7 @@ class Simulator int m_nAuxETot ; // numero totale movimenti ausiliari di fine percorso int m_nAuxEInd ; // indice del movimento ausiliario di fine percorso corrente std::string m_sTool ; // nome dell'utensile corrente - int m_nVmId ; // identificativo dell'oggetto Zmap per Virtual Milling + INTVECTOR m_VmId ; // vettore identificativi Zmap per Virtual Milling double m_dVmTdOffs ; // offset utensile in direzione principale per VM double m_dVmAdOffs ; // offset utensile in direzione ausiliaria per VM bool m_bEnabAxes ; // flag abilitazione movimento assi attivi