From 8dd67afcb738d31965f67cf75659727d335b601f Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Fri, 20 Nov 2015 13:41:10 +0000 Subject: [PATCH] EgtMachKernel 1.6k8 : - modifiche per tagli di lama inclinati. --- EgtMachKernel.rc | Bin 11782 -> 11782 bytes MachMgr.h | 1 + MachMgrMachines.cpp | 10 ++++ Machine.h | 1 + MachineCalc.cpp | 29 ++++++++++++ Machining.cpp | 11 +++++ Machining.h | 2 +- Sawing.cpp | 112 +++++++++++++++++++++++++++++++++++++++----- Sawing.h | 1 + SawingData.cpp | 4 +- 10 files changed, 156 insertions(+), 15 deletions(-) diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc index 2de7558e57ca3c90f532984cac8065bce6c29fdb..1f4c1c227bb3c3eb4e82857f1713c0d9dffc329a 100644 GIT binary patch delta 97 zcmZpRX^YwLhmFx<^ItYwW=4z2j>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHS3w|Z delta 97 zcmZpRX^YwLhmFyE^ItYwW=8YLj>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh Hr8(RHRjnXm diff --git a/MachMgr.h b/MachMgr.h index f18e9ac..9aac3b4 100644 --- a/MachMgr.h +++ b/MachMgr.h @@ -183,6 +183,7 @@ class MachMgr : public IMachMgr int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) ; virtual bool GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB, int& nStat, double& dX, double& dY, double& dZ) ; + virtual bool GetNearestAngleInStroke( int nId, double dAngRef, double& dAng) ; virtual bool VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) ; // Machine Move virtual bool SetAxisPos( const std::string& sAxis, double dVal) ; diff --git a/MachMgrMachines.cpp b/MachMgrMachines.cpp index 6f0ce1b..4b60775 100644 --- a/MachMgrMachines.cpp +++ b/MachMgrMachines.cpp @@ -299,6 +299,16 @@ MachMgr::GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB, return m_vMachines[m_nCurrMch].pMachine->GetPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) ; } +//---------------------------------------------------------------------------- +bool +MachMgr::GetNearestAngleInStroke( int nId, double dAngRef, double& dAng) +{ + if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || + m_vMachines[m_nCurrMch].pMachine == nullptr) + return false ; + return m_vMachines[m_nCurrMch].pMachine->GetNearestAngleInStroke( nId, dAngRef, dAng) ; +} + //---------------------------------------------------------------------------- bool MachMgr::VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) diff --git a/Machine.h b/Machine.h index 91041e6..f4d1fbc 100644 --- a/Machine.h +++ b/Machine.h @@ -64,6 +64,7 @@ class Machine int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) ; bool GetPositions( const Point3d& ptP, double dA, double dB, int& nStat, double& dX, double& dY, double& dZ) ; + bool GetNearestAngleInStroke( int nId, double dAngRef, double& dAng) ; bool VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) ; bool LuaCallFunction( const std::string& sFun) ; bool LuaCreateGlobTable( const std::string& sName) ; diff --git a/MachineCalc.cpp b/MachineCalc.cpp index 3b42acb..3a780d4 100644 --- a/MachineCalc.cpp +++ b/MachineCalc.cpp @@ -469,6 +469,35 @@ Machine::AdjustAngleInStroke( int nId, double& dAng) return false ; } +//---------------------------------------------------------------------------- +bool +Machine::GetNearestAngleInStroke( int nId, double dAngRef, double& dAng) +{ + // se non ci sono assi rotanti, non c'è alcunchè da fare + if ( m_vCalcRotAx.size() == 0) + return true ; + // se primo angolo ed esiste primo asse rotante + if ( nId == 1 && m_vCalcRotAx.size() >= 1) { + while ( dAng - dAngRef > ANG_STRAIGHT && dAng - ANG_FULL >= m_vCalcRotAx[0].stroke.Min) + dAng -= ANG_FULL ; + while ( dAng - dAngRef < - ANG_STRAIGHT && dAng + ANG_FULL <= m_vCalcRotAx[0].stroke.Max) + dAng += ANG_FULL ; + return ( dAng >= m_vCalcRotAx[0].stroke.Min && + dAng <= m_vCalcRotAx[0].stroke.Max) ; + } + // se secondo angolo ed esiste secondo asse rotante + if ( nId == 2 && m_vCalcRotAx.size() >= 2) { + while ( dAng - dAngRef > ANG_STRAIGHT && dAng - ANG_FULL >= m_vCalcRotAx[1].stroke.Min) + dAng -= ANG_FULL ; + while ( dAng - dAngRef < - ANG_STRAIGHT && dAng + ANG_FULL <= m_vCalcRotAx[1].stroke.Max) + dAng += ANG_FULL ; + return ( dAng >= m_vCalcRotAx[1].stroke.Min && + dAng <= m_vCalcRotAx[1].stroke.Max) ; + } + // errore + return false ; +} + //---------------------------------------------------------------------------- bool Machine::VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) diff --git a/Machining.cpp b/Machining.cpp index e871340..1c622e3 100644 --- a/Machining.cpp +++ b/Machining.cpp @@ -441,7 +441,18 @@ Machining::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, pCamData->SetAxes( CamData::AS_ERR, vAxVal) ; continue ; } + if ( nRStat == 1) { + // porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri + m_pMchMgr->GetNearestAngleInStroke( 1, dAngAprec, dAngA1) ; + m_pMchMgr->GetNearestAngleInStroke( 2, dAngBprec, dAngB1) ; + } if ( nRStat == 2) { + // porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri + m_pMchMgr->GetNearestAngleInStroke( 1, dAngAprec, dAngA1) ; + m_pMchMgr->GetNearestAngleInStroke( 2, dAngBprec, dAngB1) ; + m_pMchMgr->GetNearestAngleInStroke( 1, dAngAprec, dAngA2) ; + m_pMchMgr->GetNearestAngleInStroke( 2, dAngBprec, dAngB2) ; + // scelgo la soluzione più vicina ai precedenti double dDeltaA1 = dRot1W * fabs( dAngA1 - dAngAprec) ; double dDeltaB1 = fabs( dAngB1 - dAngBprec) ; double dDeltaA2 = dRot1W * fabs( dAngA2 - dAngAprec) ; diff --git a/Machining.h b/Machining.h index c9040b0..5a5279e 100644 --- a/Machining.h +++ b/Machining.h @@ -51,7 +51,7 @@ class Machining : public IUserObj Machining( void) ; protected : - double GetApproachDist( void) { return 30.0 ; } + double GetApproachDist( void) { return 60.0 ; } bool GetElevation( const Point3d& ptP, const Vector3d& vtDir, double& dElev) ; bool GetElevation( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtDir, double& dElev) ; bool GetFinalAxesValues( DBLVECTOR& vAxVal) ; diff --git a/Sawing.cpp b/Sawing.cpp index 5780a44..a9508bc 100644 --- a/Sawing.cpp +++ b/Sawing.cpp @@ -329,6 +329,10 @@ Sawing::Apply( void) else m_pGeomDB->EmptyGroup( nAuxId) ; + // verifiche per angolo di sbandamento + if ( ! VerifySideAngle()) + return false ; + // eseguo concatenamento, inserisco i percorsi sotto la geometria ausiliaria if ( ! Chain( nAuxId)) return false ; @@ -543,6 +547,51 @@ Sawing::GetCurve( SelData Id) return Release( pCurve) ; } +//---------------------------------------------------------------------------- +bool +Sawing::VerifySideAngle( void) +{ + // verifiche per angolo di sbandamento + if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) { + // non ammesso lato di lavoro in centro + if ( m_Params.m_nWorkSide == SAW_WS_CENTER) { + LOG_INFO( GetEMkLogger(), "Center work not allowed with side angle") ; + return false ; + } + // se angolo esterno lato mandrino deve uguagliare lato di lavoro + if ( m_Params.m_dSideAngle > 0) { + if ( m_Params.m_nWorkSide == SAW_WS_RIGHT) { + if ( m_Params.m_nHeadSide == SAW_HS_LEFT) { + LOG_INFO( GetEMkLogger(), "External side angle HeadSide must equal WorkSide") ; + m_Params.m_nHeadSide = SAW_HS_RIGHT ; + } + } + if ( m_Params.m_nWorkSide == SAW_WS_LEFT) { + if ( m_Params.m_nHeadSide == SAW_HS_RIGHT) { + LOG_INFO( GetEMkLogger(), "External side angle HeadSide must equal WorkSide") ; + m_Params.m_nHeadSide = SAW_HS_LEFT ; + } + } + } + // altrimenti angolo interno, lato mandrino deve essere opposto a lato di lavoro + else { + if ( m_Params.m_nWorkSide == SAW_WS_RIGHT) { + if ( m_Params.m_nHeadSide == SAW_HS_RIGHT) { + LOG_INFO( GetEMkLogger(), "Internal side angle HeadSide must opposite WorkSide") ; + m_Params.m_nHeadSide = SAW_HS_LEFT ; + } + } + if ( m_Params.m_nWorkSide == SAW_WS_LEFT) { + if ( m_Params.m_nHeadSide == SAW_HS_LEFT) { + LOG_INFO( GetEMkLogger(), "Internal side angle HeadSide must opposite WorkSide") ; + m_Params.m_nHeadSide = SAW_HS_RIGHT ; + } + } + } + } + return true ; +} + //---------------------------------------------------------------------------- bool Sawing::Chain( int nGrpDestId) @@ -721,7 +770,21 @@ Sawing::PathApply( int nPathId, int nClId) ExeLuaExecLine( sExec) ; double dDepth ; if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) { - string sOut = "Depth non calculable by Sawing" ; + string sOut = "Depth not computable by Sawing" ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) ; + return false ; + } + // correzione per angolo di fianco + if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) { + // generale + dDepth /= cos( m_Params.m_dSideAngle * DEGTORAD) ; + // se sottosquadra (controllo il lato opposto della lama, quindi ...) + if ( m_Params.m_dSideAngle < 0) + dDepth += m_TParams.m_dThick * tan( abs( m_Params.m_dSideAngle) * DEGTORAD) ; + } + // verifico di non superare il massimo materiale + if ( dDepth > m_TParams.m_dMaxMat) { + string sOut = "Depth bigger than MaxMaterial" ; LOG_INFO( GetEMkLogger(), sOut.c_str()) ; return false ; } @@ -770,13 +833,13 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr // calcolo i versori fresa e correzione Vector3d vtTool, vtCorr ; if ( ! CalculateToolAndCorrVersors( Get( pLine), vtTool, vtCorr)) { - string sOut = "Entity non versorable by Sawing" ; + string sOut = "Entity not versorable by Sawing" ; LOG_INFO( GetEMkLogger(), sOut.c_str()) ; return false ; } // correzioni per lato lama, lato mandrino if ( ! AdjustForSide( Get( pLine))) { - string sOut = "Entity non offsetable by Sawing" ; + string sOut = "Entity not offsetable by Sawing" ; LOG_INFO( GetEMkLogger(), sOut.c_str()) ; return false ; } @@ -785,7 +848,7 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr // calcolo elevazione double dElev ; if ( ! GetElevation( pLine->GetStart(), pLine->GetEnd(), vtCorr, dElev)) { - string sOut = "Entity non elevation-enabled by Sawing" ; + string sOut = "Entity not elevation-enabled by Sawing" ; LOG_INFO( GetEMkLogger(), sOut.c_str()) ; return false ; } @@ -818,6 +881,9 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr AdjustForEdges( Get( pLine), dElev, bIsFirst, bIsLast, bExtAngPC, bExtAngCN) ; // recupero distanza di approccio double dAppr = GetApproachDist() ; + // correzione per angolo di fianco + if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) + dAppr /= cos( m_Params.m_dSideAngle * DEGTORAD) ; // imposto dati comuni SetPathId( nPxId) ; SetToolDir( vtTool) ; @@ -848,19 +914,36 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr bool Sawing::CalculateToolAndCorrVersors( const ICurve* pCurve, Vector3d& vtTool, Vector3d& vtCorr) { - // recupero la direzione della linea - pCurve->GetStartDir( vtTool) ; - // annullo la componente in Z e normalizzo - vtTool.z = 0 ; - if ( ! vtTool.Normalize()) + // Recupero la direzione della linea e la proietto nel piano XY + Vector3d vtTang ; + pCurve->GetStartDir( vtTang) ; + vtTang.z = 0 ; + if ( ! vtTang.Normalize()) return false ; + + // Versore fresa : annullo la componente in Z e normalizzo + vtTool = vtTang ; // ruoto attorno a Zglob+ a seconda del lato mandrino - if ( m_Params.m_nHeadSide == SAW_HS_LEFT) - vtTool.Rotate( Z_AX, 0, 1) ; + if ( m_Params.m_nHeadSide == SAW_HS_LEFT) + vtTool.Rotate( Z_AX, 90) ; else - vtTool.Rotate( Z_AX, 0, -1) ; - // versore correzione + vtTool.Rotate( Z_AX, -90) ; + + // Versore correzione vtCorr = Z_AX ; + + // Se lama sbandata + if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) { + if ( m_Params.m_nWorkSide == SAW_WS_RIGHT) { + vtTool.Rotate( vtTang, - m_Params.m_dSideAngle) ; + vtCorr.Rotate( vtTang, - m_Params.m_dSideAngle) ; + } + else { + vtTool.Rotate( vtTang, m_Params.m_dSideAngle) ; + vtCorr.Rotate( vtTang, m_Params.m_dSideAngle) ; + } + } + return true ; } @@ -882,6 +965,9 @@ Sawing::AdjustForSide( ICurve* pCurve) dOffs = 0.5 * m_TParams.m_dThick ; else // testa a destra e lama in centro dOffs = - 0.5 * m_TParams.m_dThick ; + // correzione per angolo di fianco + if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) + dOffs /= cos( m_Params.m_dSideAngle * DEGTORAD) ; // eseguo offset curva ( nel piano XY globale) return pCurve->SimpleOffset( dOffs) ; } diff --git a/Sawing.h b/Sawing.h index 08e6efd..bc1f43d 100644 --- a/Sawing.h +++ b/Sawing.h @@ -52,6 +52,7 @@ class Sawing : public Machining private : bool VerifyGeometry( SelData Id, int& nSubs) ; ICurve* GetCurve( SelData Id) ; + bool VerifySideAngle( void) ; bool Chain( int nGrpDestId) ; bool PathApply( int nPathId, int nClId) ; bool EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCrvN, diff --git a/SawingData.cpp b/SawingData.cpp index f8a1df4..2168807 100644 --- a/SawingData.cpp +++ b/SawingData.cpp @@ -300,7 +300,9 @@ SawingData::VerifyCurveUse( int nVal) const bool SawingData::VerifySideAngle( double dVal) const { - return ( ( dVal > - EPS_SMALL && dVal < 60 + EPS_SMALL) || fabs( dVal - 99) < EPS_SMALL) ; + const double MAX_SIDE_ANG = 60 + EPS_ANG_SMALL ; + const double AUTO_SIDE_ANG = 99 ; + return ( ( dVal > - MAX_SIDE_ANG && dVal < MAX_SIDE_ANG) || fabs( dVal - AUTO_SIDE_ANG) < EPS_ANG_SMALL) ; } //----------------------------------------------------------------------------