From 40aa1de2def90bf2f74dbda200dc9099a8a26bcb Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Mon, 21 Oct 2019 10:59:44 +0000 Subject: [PATCH] EgtMachKernel : - a lavorazione WaterJetting aggiunti parametri necessari. --- WaterJetting.cpp | 203 +++++++++++++++++++++++++++++++++++-------- WaterJetting.h | 3 + WaterJettingData.cpp | 199 +++++++++++++++++++++++++++++++++++++++++- WaterJettingData.h | 29 +++++-- 4 files changed, 390 insertions(+), 44 deletions(-) diff --git a/WaterJetting.cpp b/WaterJetting.cpp index db0d98d..0fc958b 100644 --- a/WaterJetting.cpp +++ b/WaterJetting.cpp @@ -248,6 +248,16 @@ WaterJetting::SetParam( int nType, bool bVal) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_bInvert = bVal ; return true ; + case MPA_PROBING : + if ( bVal != m_Params.m_bProbing) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_bProbing = bVal ; + return true ; + case MPA_LIHOLE : + if ( bVal != m_Params.m_bLiHole) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_bLiHole = bVal ; + return true ; } return false ; } @@ -264,6 +274,27 @@ WaterJetting::SetParam( int nType, int nVal) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nWorkSide = nVal ; return true ; + case MPA_EXTCORNERTYPE : + if ( ! m_Params.VerifyExtCornerType( nVal)) + return false ; + if ( nVal != m_Params.m_nExtCornerType) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_nExtCornerType = nVal ; + break ; + case MPA_INTCORNERTYPE : + if ( ! m_Params.VerifyIntCornerType( nVal)) + return false ; + if ( nVal != m_Params.m_nIntCornerType) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_nIntCornerType = nVal ; + break ; + case MPA_CORNERSLOWPERC : + if ( ! m_Params.VerifyCornerSlowPerc( nVal)) + return false ; + if ( nVal != m_Params.m_nCornerSlowPerc) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_nCornerSlowPerc = nVal ; + break ; case MPA_LEADINTYPE : if ( ! m_Params.VerifyLeadInType( nVal)) return false ; @@ -278,6 +309,16 @@ WaterJetting::SetParam( int nType, int nVal) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_nLeadOutType = nVal ; return true ; + case MPA_LPTURNS : + if ( nVal != m_Params.m_nLpTurns) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_nLpTurns = nVal ; + break ; + case MPA_HPTURNS : + if ( nVal != m_Params.m_nHpTurns) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_nHpTurns = nVal ; + break ; case MPA_SCC : if ( ! m_Params.VerifySolCh( nVal)) return false ; @@ -336,6 +377,13 @@ WaterJetting::SetParam( int nType, double dVal) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dSideAngle = dVal ; return true ; + case MPA_FORWARDANGLE : + if ( ! m_Params.VerifyForwardAngle( dVal)) + return false ; + if ( ! AreSameAngValue( dVal, m_Params.m_dForwardAngle)) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_dForwardAngle = dVal ; + return true ; case MPA_STARTADDLEN : if ( abs( dVal - m_Params.m_dStartAddLen) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; @@ -346,6 +394,21 @@ WaterJetting::SetParam( int nType, double dVal) m_nStatus |= MCH_ST_PARAM_MODIF ; m_Params.m_dEndAddLen = dVal ; return true ; + case MPA_PROBINGMINDIST : + if ( abs( dVal - m_Params.m_dProbingMinDist) > EPS_MACH_LEN_PAR) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_dProbingMinDist = dVal ; + return true ; + case MPA_PROBINGMAXDIST : + if ( abs( dVal - m_Params.m_dProbingMaxDist) > EPS_MACH_LEN_PAR) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_dProbingMaxDist = dVal ; + return true ; + case MPA_CORNERSLOWLEN : + if ( abs( dVal - m_Params.m_dCornerSlowLen) > EPS_MACH_LEN_PAR) + m_nStatus |= MCH_ST_PARAM_MODIF ; + m_Params.m_dCornerSlowLen = dVal ; + return true ; case MPA_LITANG : if ( abs( dVal - m_Params.m_dLiTang) > EPS_MACH_LEN_PAR) m_nStatus |= MCH_ST_PARAM_MODIF ; @@ -698,6 +761,12 @@ WaterJetting::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_Params.m_bInvert ; return true ; + case MPA_PROBING : + bVal = m_Params.m_bProbing ; + return true ; + case MPA_LIHOLE : + bVal = m_Params.m_bLiHole ; + return true ; } bVal = false ; return false ; @@ -714,12 +783,27 @@ WaterJetting::GetParam( int nType, int& nVal) const case MPA_WORKSIDE : nVal = m_Params.m_nWorkSide ; return true ; + case MPA_EXTCORNERTYPE : + nVal = m_Params.m_nExtCornerType ; + return true ; + case MPA_INTCORNERTYPE : + nVal = m_Params.m_nIntCornerType ; + return true ; + case MPA_CORNERSLOWPERC : + nVal = m_Params.m_nCornerSlowPerc ; + return true ; case MPA_LEADINTYPE : nVal = m_Params.m_nLeadInType ; return true ; case MPA_LEADOUTTYPE : nVal = m_Params.m_nLeadOutType ; return true ; + case MPA_LPTURNS : + nVal = m_Params.m_nLpTurns ; + return true ; + case MPA_HPTURNS : + nVal = m_Params.m_nHpTurns ; + return true ; case MPA_SCC : nVal = m_Params.m_nSolCh ; return true ; @@ -751,12 +835,24 @@ WaterJetting::GetParam( int nType, double& dVal) const case MPA_SIDEANGLE : dVal = m_Params.m_dSideAngle ; return true ; + case MPA_FORWARDANGLE : + dVal = m_Params.m_dForwardAngle ; + return true ; case MPA_STARTADDLEN : dVal = m_Params.m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_Params.m_dEndAddLen ; return true ; + case MPA_PROBINGMINDIST : + dVal = m_Params.m_dProbingMinDist ; + return true ; + case MPA_PROBINGMAXDIST : + dVal = m_Params.m_dProbingMaxDist ; + return true ; + case MPA_CORNERSLOWLEN : + dVal = m_Params.m_dCornerSlowLen ; + return true ; case MPA_LITANG : dVal = m_Params.m_dLiTang ; return true ; @@ -1373,6 +1469,10 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId) // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi VerifyArcs( pCompo) ; + // se abilitato probing, verifico lunghezza entità ed eventualmente le divido + if ( m_Params.m_bProbing) + VerifyMaxLenCurves( pCompo, m_Params.m_dProbingMaxDist) ; + // calcolo l'elevazione massima double dElev = 0 ; @@ -1697,10 +1797,8 @@ WaterJetting::AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* p Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ; // angolo tra le direzioni double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ; - // se deviazione esterna superiore a 30deg, si aggiunge l'anello - const double ANG_CORNER = 30 ; - if ( ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || - ( dAng < -ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) { + // se previsto e angolo esterno, si aggiunge l'anello + if ( m_Params.m_nExtCornerType == WJET_EC_LOOP && IsExternalAngle( dAng)) { // curva dell'anello PtrOwner pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo)) @@ -1749,6 +1847,9 @@ bool WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool, double dRbDist, double dElev, bool bSplitArcs) { + // numero punti di accelerazione/decelerazione + const int ACC_PNT_NUM = 3 ; + // recupero distanze di sicurezza double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; @@ -1799,12 +1900,10 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo // direzione iniziale corrente Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ; // angolo tra le direzioni - double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ; - // Valore limite angolo per corner - const double ANG_CORNER = 30 ; - // Se angolo esterno con precedente (deviazione esterna superiore a 30deg), aggiungo anello - if ( ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || - ( dAng < -ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) { + double dAng ; + vtEnd.GetAngleXY( vtStart, dAng) ; + // Se richiesto loop e angolo esterno con precedente + if ( m_Params.m_nExtCornerType == WJET_EC_LOOP && IsExternalAngle( dAng)) { // lunghezza tratti lineari e loro punti estremi double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * dAng * DEGTORAD) ; Point3d ptP ; pCrvC->GetStartPoint( ptP) ; @@ -1829,19 +1928,16 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo if ( AddLinearMove( ptP) == GDB_ID_NULL) return false ; } - // se altrimenti angolo interno con precedente (deviazione interna inferiore a -30deg), aggiungo accelerazione - else if ( ( dAng <- ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || - ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) { - // lunghezza max di accelerazione - const double ACC_MAX_LEN = 10 ; + // se altrimenti richiesto rallentamento esterno o interno e angolo dello stesso tipo, eseguo accelerazione + else if ( ( m_Params.m_nExtCornerType == WJET_EC_SLOW && IsExternalAngle( dAng)) || + ( m_Params.m_nIntCornerType == WJET_IC_SLOW && IsInternalAngle( dAng))) { // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; - double dAccLen = min( ACC_MAX_LEN, dLen / 2) ; + // lunghezza di accelerazione + double dAccLen = min( m_Params.m_dCornerSlowLen, dLen / 2) ; // Feed minima - const double COEFF_MIN_FEED = 0.5 ; - double dMinFeed = COEFF_MIN_FEED * GetFeed() ; + double dMinFeed = m_Params.m_nCornerSlowPerc / 100. * GetFeed() ; // ciclo sui punti di accelerazione - const int ACC_PNT_NUM = 3 ; for ( int j = 1 ; j <= ACC_PNT_NUM ; ++ j) { double dCoeff = j / double( ACC_PNT_NUM) ; double dU ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ; @@ -1854,12 +1950,11 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo } } // se non è l'ultima entità, verifico se dopo c'è un angolo interno - const double MIN_PROBE_DIST = 90 ; double dNextFeed = GetFeed() ; if ( i < nMaxInd) { // controlli per indice del punto di arrivo Point3d ptP3 ; pCrvC->GetEndPoint( ptP3) ; - if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST) + if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) SetIndex( i + 1 - nIdxSkip) ; // Recupero versore estrusione Vector3d vtN ; pCompo->GetExtrusion( vtN) ; @@ -1870,21 +1965,16 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo Vector3d vtStart ; pCrvN->GetStartDir( vtStart) ; // angolo tra le direzioni double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ; - // Valore limite angolo per corner - const double ANG_CORNER = 30 ; - // se altrimenti angolo interno con successivo (deviazione interna inferiore a -30deg), aggiungo accelerazione - if ( ( dAng <- ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || - ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) { - // lunghezza max di decelerazione - const double ACC_MAX_LEN = 10 ; + // se altrimenti richiesto rallentamento esterno o interno e angolo dello stesso tipo, aggiungo decelerazione + if ( ( m_Params.m_nExtCornerType == WJET_EC_SLOW && IsExternalAngle( dAng)) || + ( m_Params.m_nIntCornerType == WJET_IC_SLOW && IsInternalAngle( dAng))) { // lunghezza entità double dLen ; pCrvC->GetLength( dLen) ; - double dAccLen = min( ACC_MAX_LEN, dLen / 2) ; + // lunghezza di accelerazione + double dAccLen = min( m_Params.m_dCornerSlowLen, dLen / 2) ; // Feed minima - const double COEFF_MIN_FEED = 0.5 ; - double dMinFeed = COEFF_MIN_FEED * GetFeed() ; + double dMinFeed = m_Params.m_nCornerSlowPerc / 100. * GetFeed() ; // ciclo sui punti di decelerazione - const int ACC_PNT_NUM = 3 ; for ( int j = 0 ; j < ACC_PNT_NUM ; ++ j) { double dCoeff = j / double( ACC_PNT_NUM) ; double dU ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ; @@ -1905,7 +1995,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo Point3d ptP3 = pLine->GetEnd() ; SetFeed( dNextFeed) ; // controlli per indice del punto di arrivo - if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST) { + if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) { SetIndex( i + 1 - nIdxSkip) ; m_ptLastProbe = ptP3 ; } @@ -1922,7 +2012,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo Point3d ptP3 ; pArc->GetEndPoint( ptP3) ; SetFeed( dNextFeed) ; // controlli per indice del punto di arrivo - if ( SqDistXY( ptP3, m_ptLastProbe) >= MIN_PROBE_DIST * MIN_PROBE_DIST) { + if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) { SetIndex( i + 1 - nIdxSkip) ; m_ptLastProbe = ptP3 ; } @@ -1953,7 +2043,6 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo return true ; } - //---------------------------------------------------------------------------- class LeadIOStatus { @@ -2386,3 +2475,47 @@ WaterJetting::CalcOffset( ICurveComposite* pCompo, double dSignOffs) } return bOk ; } + +//---------------------------------------------------------------------------- +// Valore limite angolo per corner +const double ANG_CORNER = 30 ; + +//---------------------------------------------------------------------------- +bool +WaterJetting::IsExternalAngle( double dAng) +{ + return ( ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || + ( dAng < -ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) ; +} + +//---------------------------------------------------------------------------- +bool +WaterJetting::IsInternalAngle( double dAng) +{ + return ( ( dAng <- ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_RIGHT) || + ( dAng > ANG_CORNER && m_Params.m_nWorkSide == WJET_WS_LEFT)) ; +} + +//---------------------------------------------------------------------------- +bool +WaterJetting::VerifyMaxLenCurves( ICurveComposite* pCompo, double dMaxLen) +{ + // verifiche sulla lunghezza delle curve + int nMaxInd = pCompo->GetCurveCount() - 1 ; + for ( int i = 0 ; i <= nMaxInd ; ) { + // se lunghezza oltre il limite, la divido a metà + const ICurve* pCrv = GetCurve( pCompo->GetCurve( i)) ; + double dLen ; + if ( pCrv != nullptr && pCrv->GetLength( dLen) && dLen > dMaxLen) { + int nParts = int( ceil( dLen / dMaxLen)) ; + for ( int j = 0 ; j < nParts - 1 ; ++ j) { + double dCoeff = 1. / ( nParts - j) ; + pCompo->AddJoint( i + j + dCoeff) ; + ++ nMaxInd ; + } + } + else + ++ i ; + } + return true ; +} diff --git a/WaterJetting.h b/WaterJetting.h index 86360cd..5dc5129 100644 --- a/WaterJetting.h +++ b/WaterJetting.h @@ -96,6 +96,9 @@ class WaterJetting : public Machining Vector3d CalcToolDir( const ICurveComposite* pCompo, double dU) ; Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU) ; bool CalcOffset( ICurveComposite* pCompo, double dSignOffs) ; + bool IsExternalAngle( double dAng) ; + bool IsInternalAngle( double dAng) ; + bool VerifyMaxLenCurves( ICurveComposite* pCompo, double dMaxLen) ; private : double GetSpeed() const diff --git a/WaterJettingData.cpp b/WaterJettingData.cpp index 8852fe8..7934c48 100644 --- a/WaterJettingData.cpp +++ b/WaterJettingData.cpp @@ -28,11 +28,18 @@ using namespace std ; enum nWaterJetting { KEY_AB = 0, KEY_AI, + KEY_CSL, + KEY_CSP, KEY_EAL, + KEY_ECT, KEY_F, + KEY_FA, KEY_FT, + KEY_HPT, + KEY_ICT, KEY_INV, KEY_LICL, + KEY_LIH, KEY_LIHR, KEY_LIPR, KEY_LITG, @@ -41,11 +48,15 @@ enum nWaterJetting { KEY_LOPR, KEY_LOTG, KEY_LOTY, + KEY_LPT, KEY_NAME, KEY_NNS, KEY_NNU, KEY_OR, KEY_OVL, + KEY_PRB, + KEY_PRBMAX, + KEY_PRBMIN, KEY_S, KEY_SA, KEY_SAL, @@ -59,11 +70,18 @@ enum nWaterJetting { static const std::array sWaterJettingKey = { "AB", "AI", + "CSL", + "CSP", "EAL", + "ECT", "F", + "FA", "FT", + "HPT", + "ICT", "INV", "LICL", + "LIH", "LIHR", "LIPR", "LITG", @@ -72,11 +90,15 @@ static const std::array sWaterJettingKey = { "LOPR", "LOTG", "LOTY", + "LPT", "NAME", "NNS", "NNU", "OR", "OVL", + "PRB", + "PRBMAX", + "PRBMIN", "S", "SA", "SAL", @@ -132,13 +154,24 @@ WaterJettingData::CopyFrom( const MachiningData* pMdata) m_nWorkSide = pSdata->m_nWorkSide ; m_dOverlap = pSdata->m_dOverlap ; m_dSideAngle = pSdata->m_dSideAngle ; + m_dForwardAngle = pSdata->m_dForwardAngle ; m_dStartAddLen = pSdata->m_dStartAddLen ; m_dEndAddLen = pSdata->m_dEndAddLen ; + m_bProbing = pSdata->m_bProbing ; + m_dProbingMinDist = pSdata->m_dProbingMinDist ; + m_dProbingMaxDist = pSdata->m_dProbingMaxDist ; + m_nExtCornerType = pSdata->m_nExtCornerType ; + m_nIntCornerType = pSdata->m_nIntCornerType ; + m_dCornerSlowLen = pSdata->m_dCornerSlowLen ; + m_nCornerSlowPerc = pSdata->m_nCornerSlowPerc ; m_nLeadInType = pSdata->m_nLeadInType ; m_dLiTang = pSdata->m_dLiTang ; m_dLiPerp = pSdata->m_dLiPerp ; m_dLiCompLen = pSdata->m_dLiCompLen ; + m_bLiHole = pSdata->m_bLiHole ; m_dLiHoleRad = pSdata->m_dLiHoleRad ; + m_nLpTurns = pSdata->m_nLpTurns ; + m_nHpTurns = pSdata->m_nHpTurns ; m_nLeadOutType = pSdata->m_nLeadOutType ; m_dLoTang = pSdata->m_dLoTang ; m_dLoPerp = pSdata->m_dLoPerp ; @@ -175,13 +208,24 @@ WaterJettingData::SameAs( const MachiningData* pMdata) const m_nWorkSide == pSdata->m_nWorkSide && abs( m_dOverlap - pSdata->m_dOverlap) < EPS_MACH_LEN_PAR && abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR && + abs( m_dForwardAngle - pSdata->m_dForwardAngle) < EPS_MACH_ANG_PAR && abs( m_dStartAddLen - pSdata->m_dStartAddLen) < EPS_MACH_LEN_PAR && abs( m_dEndAddLen - pSdata->m_dEndAddLen) < EPS_MACH_LEN_PAR && + m_bProbing == pSdata->m_bProbing && + abs( m_dProbingMinDist - pSdata->m_dProbingMinDist) < EPS_MACH_LEN_PAR && + abs( m_dProbingMaxDist - pSdata->m_dProbingMaxDist) < EPS_MACH_LEN_PAR && + m_nExtCornerType == pSdata->m_nExtCornerType && + m_nIntCornerType == pSdata->m_nIntCornerType && + abs( m_dCornerSlowLen - pSdata->m_dCornerSlowLen) < EPS_MACH_LEN_PAR && + m_nCornerSlowPerc == pSdata->m_nCornerSlowPerc && m_nLeadInType == pSdata->m_nLeadInType && abs( m_dLiTang - pSdata->m_dLiTang) < EPS_MACH_LEN_PAR && abs( m_dLiPerp - pSdata->m_dLiPerp) < EPS_MACH_LEN_PAR && abs( m_dLiCompLen - pSdata->m_dLiCompLen) < EPS_MACH_LEN_PAR && + m_bLiHole == pSdata->m_bLiHole && abs( m_dLiHoleRad - pSdata->m_dLiHoleRad) < EPS_MACH_LEN_PAR && + m_nLpTurns == pSdata->m_nLpTurns && + m_nHpTurns == pSdata->m_nHpTurns && m_nLeadOutType == pSdata->m_nLeadOutType && abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR && abs( m_dLoPerp - pSdata->m_dLoPerp) < EPS_MACH_LEN_PAR && @@ -232,21 +276,42 @@ WaterJettingData::FromString( const string& sString, int& nKey) case KEY_AI : m_sInitAngs = sVal ; break ; + case KEY_CSL : + bOk = ::FromString( sVal, m_dCornerSlowLen) ; + break ; + case KEY_CSP : + bOk = ::FromString( sVal, m_nCornerSlowPerc) ; + break ; case KEY_EAL : bOk = ::FromString( sVal, m_dEndAddLen) ; break ; + case KEY_ECT : + bOk = ::FromString( sVal, m_nExtCornerType) ; + break ; case KEY_F : bOk = ::FromString( sVal, m_dFeed) ; break ; + case KEY_FA : + bOk = ::FromString( sVal, m_dForwardAngle) ; + break ; case KEY_FT : bOk = ::FromString( sVal, m_dTipFeed) ; break ; + case KEY_HPT : + bOk = ::FromString( sVal, m_nHpTurns) ; + break ; + case KEY_ICT : + bOk = ::FromString( sVal, m_nIntCornerType) ; + break ; case KEY_INV : bOk = ::FromString( sVal, m_bInvert) ; break ; case KEY_LICL : bOk = ::FromString( sVal, m_dLiCompLen) ; break ; + case KEY_LIH : + bOk = ::FromString( sVal, m_bLiHole) ; + break ; case KEY_LIHR : bOk = ::FromString( sVal, m_dLiHoleRad) ; break ; @@ -271,6 +336,9 @@ WaterJettingData::FromString( const string& sString, int& nKey) case KEY_LOTY : bOk = ::FromString( sVal, m_nLeadOutType) ; break ; + case KEY_LPT : + bOk = ::FromString( sVal, m_nLpTurns) ; + break ; case KEY_NAME : m_sName = sVal ; bOk = ! m_sName.empty() ; @@ -284,6 +352,15 @@ WaterJettingData::FromString( const string& sString, int& nKey) case KEY_OR : bOk = ::FromString( sVal, m_dOffsR) ; break ; + case KEY_PRB : + bOk = ::FromString( sVal, m_bProbing) ; + break ; + case KEY_PRBMAX : + bOk = ::FromString( sVal, m_dProbingMaxDist) ; + break ; + case KEY_PRBMIN : + bOk = ::FromString( sVal, m_dProbingMinDist) ; + break ; case KEY_OVL : bOk = ::FromString( sVal, m_dOverlap) ; break ; @@ -325,11 +402,18 @@ WaterJettingData::ToString( int nInd) const switch ( nInd) { case KEY_AB : return ( sWaterJettingKey[KEY_AB] + "=" + m_sBlockedAxis) ; case KEY_AI : return ( sWaterJettingKey[KEY_AI] + "=" + m_sInitAngs) ; + case KEY_CSL : return ( sWaterJettingKey[KEY_CSL] + "=" + ::ToString( m_dCornerSlowLen)) ; + case KEY_CSP : return ( sWaterJettingKey[KEY_CSP] + "=" + ::ToString( m_nCornerSlowPerc)) ; case KEY_EAL : return ( sWaterJettingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; + case KEY_ECT : return ( sWaterJettingKey[KEY_ECT] + "=" + ::ToString( m_nExtCornerType)) ; case KEY_F : return ( sWaterJettingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; + case KEY_FA : return ( sWaterJettingKey[KEY_FA] + "=" + ::ToString( m_dForwardAngle)) ; case KEY_FT : return ( sWaterJettingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; + case KEY_HPT : return ( sWaterJettingKey[KEY_HPT] + "=" + ::ToString( m_nHpTurns)) ; + case KEY_ICT : return ( sWaterJettingKey[KEY_ICT] + "=" + ::ToString( m_nIntCornerType)) ; case KEY_INV : return ( sWaterJettingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; case KEY_LICL : return ( sWaterJettingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ; + case KEY_LIH : return ( sWaterJettingKey[KEY_LIH] + "=" + ::ToString( m_bLiHole)) ; case KEY_LIHR : return ( sWaterJettingKey[KEY_LIHR] + "=" + ::ToString( m_dLiHoleRad)) ; case KEY_LIPR : return ( sWaterJettingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ; case KEY_LITG : return ( sWaterJettingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ; @@ -338,11 +422,15 @@ WaterJettingData::ToString( int nInd) const case KEY_LOPR : return ( sWaterJettingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ; case KEY_LOTG : return ( sWaterJettingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ; case KEY_LOTY : return ( sWaterJettingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ; + case KEY_LPT : return ( sWaterJettingKey[KEY_LPT] + "=" + ::ToString( m_nLpTurns)) ; case KEY_NAME : return ( sWaterJettingKey[KEY_NAME] + "=" + m_sName) ; case KEY_NNS : return ( sWaterJettingKey[KEY_NNS] + "=" + m_sSysNotes) ; case KEY_NNU : return ( sWaterJettingKey[KEY_NNU] + "=" + m_sUserNotes) ; case KEY_OR : return ( sWaterJettingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ; case KEY_OVL : return ( sWaterJettingKey[KEY_OVL] + "=" + ::ToString( m_dOverlap)) ; + case KEY_PRB : return ( sWaterJettingKey[KEY_PRB] + "=" + ::ToString( m_bProbing)) ; + case KEY_PRBMAX : return ( sWaterJettingKey[KEY_PRBMAX] + "=" + ::ToString( m_dProbingMaxDist)) ; + case KEY_PRBMIN : return ( sWaterJettingKey[KEY_PRBMIN] + "=" + ::ToString( m_dProbingMinDist)) ; case KEY_S : return ( sWaterJettingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ; case KEY_SA : return ( sWaterJettingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ; case KEY_SAL : return ( sWaterJettingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ; @@ -359,7 +447,9 @@ WaterJettingData::ToString( int nInd) const bool WaterJettingData::IsOptional( int nKey) const { - return false ; + return ( nKey == KEY_FA || nKey == KEY_PRB || nKey == KEY_PRBMAX || nKey == KEY_PRBMIN || + nKey == KEY_ECT || nKey == KEY_ICT || nKey == KEY_CSL || nKey == KEY_CSP || + nKey == KEY_LIH || nKey == KEY_LIHR || nKey == KEY_LPT || nKey == KEY_HPT) ; } //---------------------------------------------------------------------------- @@ -376,12 +466,32 @@ WaterJettingData::VerifyWorkSide( int nVal) const return ( nVal == WJET_WS_CENTER || nVal == WJET_WS_LEFT || nVal == WJET_WS_RIGHT) ; } +//---------------------------------------------------------------------------- +bool +WaterJettingData::VerifyExtCornerType( int nVal) const +{ + return ( nVal == WJET_EC_NONE || nVal == WJET_EC_SLOW || nVal == WJET_EC_LOOP) ; +} + +//---------------------------------------------------------------------------- +bool +WaterJettingData::VerifyIntCornerType( int nVal) const +{ + return ( nVal == WJET_IC_NONE || nVal == WJET_IC_SLOW) ; +} + +//---------------------------------------------------------------------------- +bool +WaterJettingData::VerifyCornerSlowPerc( int nVal) const +{ + return ( nVal >= 0 && nVal <= 100) ; +} + //---------------------------------------------------------------------------- bool WaterJettingData::VerifyLeadInType( int nVal) const { - return ( nVal == WJET_LI_NONE || nVal == WJET_LI_LINEAR || - nVal == WJET_LI_TANGENT) ; + return ( nVal == WJET_LI_NONE || nVal == WJET_LI_LINEAR || nVal == WJET_LI_TANGENT) ; } //---------------------------------------------------------------------------- @@ -401,6 +511,15 @@ WaterJettingData::VerifySideAngle( double dVal) const return ( ( dVal > - MAX_SIDE_ANG && dVal < MAX_SIDE_ANG) || abs( dVal - AUTO_SIDE_ANG) < EPS_ANG_SMALL) ; } +//---------------------------------------------------------------------------- +bool +WaterJettingData::VerifyForwardAngle( double dVal) const +{ + const double MAX_FORW_ANG = 30.0 + EPS_ANG_SMALL ; + const double AUTO_FORW_ANG = 99 ; + return ( ( dVal > - EPS_ZERO && dVal < MAX_FORW_ANG) || abs( dVal - AUTO_FORW_ANG) < EPS_ANG_SMALL) ; +} + //---------------------------------------------------------------------------- bool WaterJettingData::VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const @@ -433,6 +552,12 @@ WaterJettingData::SetParam( int nType, bool bVal) case MPA_INVERT : m_bInvert = bVal ; return true ; + case MPA_PROBING : + m_bProbing = bVal ; + return true ; + case MPA_LIHOLE : + m_bLiHole = bVal ; + return true ; } return false ; } @@ -447,6 +572,21 @@ WaterJettingData::SetParam( int nType, int nVal) return false ; m_nWorkSide = nVal ; return true ; + case MPA_EXTCORNERTYPE : + if ( ! VerifyExtCornerType( nVal)) + return false ; + m_nExtCornerType = nVal ; + break ; + case MPA_INTCORNERTYPE : + if ( ! VerifyIntCornerType( nVal)) + return false ; + m_nIntCornerType = nVal ; + break ; + case MPA_CORNERSLOWPERC : + if ( ! VerifyCornerSlowPerc( nVal)) + return false ; + m_nCornerSlowPerc = nVal ; + break ; case MPA_LEADINTYPE : if ( ! VerifyLeadInType( nVal)) return false ; @@ -457,6 +597,12 @@ WaterJettingData::SetParam( int nType, int nVal) return false ; m_nLeadOutType = nVal ; return true ; + case MPA_LPTURNS : + m_nLpTurns = nVal ; + break ; + case MPA_HPTURNS : + m_nHpTurns = nVal ; + break ; case MPA_SCC : if ( ! VerifySolCh( nVal)) return false ; @@ -491,12 +637,26 @@ WaterJettingData::SetParam( int nType, double dVal) return false ; m_dSideAngle = dVal ; return true ; + case MPA_FORWARDANGLE : + if ( ! VerifyForwardAngle( dVal)) + return false ; + m_dForwardAngle = dVal ; + return true ; case MPA_STARTADDLEN : m_dStartAddLen = dVal ; return true ; case MPA_ENDADDLEN : m_dEndAddLen = dVal ; return true ; + case MPA_PROBINGMINDIST : + m_dProbingMinDist = dVal ; + return true ; + case MPA_PROBINGMAXDIST : + m_dProbingMaxDist = dVal ; + return true ; + case MPA_CORNERSLOWLEN : + m_dCornerSlowLen = dVal ; + return true ; case MPA_LITANG : m_dLiTang = dVal ; return true ; @@ -570,6 +730,12 @@ WaterJettingData::GetParam( int nType, bool& bVal) const case MPA_INVERT : bVal = m_bInvert ; return true ; + case MPA_PROBING : + bVal = m_bProbing ; + return true ; + case MPA_LIHOLE : + bVal = m_bLiHole ; + return true ; } bVal = false ; return false ; @@ -586,12 +752,27 @@ WaterJettingData::GetParam( int nType, int& nVal) const case MPA_WORKSIDE : nVal = m_nWorkSide ; return true ; + case MPA_EXTCORNERTYPE : + nVal = m_nExtCornerType ; + return true ; + case MPA_INTCORNERTYPE : + nVal = m_nIntCornerType ; + return true ; + case MPA_CORNERSLOWPERC : + nVal = m_nCornerSlowPerc ; + return true ; case MPA_LEADINTYPE : nVal = m_nLeadInType ; return true ; case MPA_LEADOUTTYPE : nVal = m_nLeadOutType ; return true ; + case MPA_LPTURNS : + nVal = m_nLpTurns ; + return true ; + case MPA_HPTURNS : + nVal = m_nHpTurns ; + return true ; case MPA_SCC : nVal = m_nSolCh ; return true ; @@ -623,12 +804,24 @@ WaterJettingData::GetParam( int nType, double& dVal) const case MPA_SIDEANGLE : dVal = m_dSideAngle ; return true ; + case MPA_FORWARDANGLE : + dVal = m_dForwardAngle ; + return true ; case MPA_STARTADDLEN : dVal = m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_dEndAddLen ; return true ; + case MPA_PROBINGMINDIST : + dVal = m_dProbingMinDist ; + return true ; + case MPA_PROBINGMAXDIST : + dVal = m_dProbingMaxDist ; + return true ; + case MPA_CORNERSLOWLEN : + dVal = m_dCornerSlowLen ; + return true ; case MPA_LITANG : dVal = m_dLiTang ; return true ; diff --git a/WaterJettingData.h b/WaterJettingData.h index 3cf56ae..231cd7b 100644 --- a/WaterJettingData.h +++ b/WaterJettingData.h @@ -24,21 +24,32 @@ struct WaterJettingData : public MachiningData std::string m_sBlockedAxis ; // eventuale asse rotante bloccato (Nome=val) int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) double m_dSpeed ; // velocità afflusso abrasivo ( se 0 da utensile) - double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) - double m_dTipFeed ; // velocità di lavorazione di testa ( se 0 da utensile) + double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) + double m_dTipFeed ; // velocità di lavorazione di testa ( se 0 da utensile) double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile) bool m_bInvert ; // flag di inversione direzione lavorazione int m_nWorkSide ; // lato di lavoro (destra, sinistra, centro) double m_dOverlap ; // lunghezza di sovrapposizione se percorso chiuso double m_dSideAngle ; // angolo di sbandamento (0-60deg) + double m_dForwardAngle ; // angolo di inclinazione in avanti (0-30deg) double m_dStartAddLen ; // lunghezza da aggiungere/togliere all'inizio double m_dEndAddLen ; // lunghezza da aggiungere/togliere alla fine - int m_nLeadInType ; // tipo di attacco (nessuno, lineare, tangente, inseguimento) + bool m_bProbing ; // abilitazione tastatura + double m_dProbingMinDist ; // minima distanza tra punti di tastatura consecutivi + double m_dProbingMaxDist ; // massima distanza tra punti di tastatura consecutivi + int m_nExtCornerType ; // tipo di movimento su angoli esterni (niente, rallentamento, anello) + int m_nIntCornerType ; // tipo di movimento su angoli interni (niente, rallentamento) + double m_dCornerSlowLen ; // lunghezza di rallentamento su angoli + int m_nCornerSlowPerc ; // percentuale di rallentamento su angoli + int m_nLeadInType ; // tipo di attacco (nessuno, lineare, tangente) double m_dLiTang ; // distanza tangente da inizio attacco double m_dLiPerp ; // distanza perpendicolare da inizio attacco double m_dLiCompLen ; // lunghezza del tratto di inserimento correttore raggio utensile + bool m_bLiHole ; // flag abilitazione foro di attacco double m_dLiHoleRad ; // raggio foro attacco (se 0 non c'è foro) - int m_nLeadOutType ; // tipo di uscita (come attacco, nessuno, lineare, tangente, inseguimento) + int m_nLpTurns ; // numero di giri in bassa pressione sul foro di attacco + int m_nHpTurns ; // numero di giri in alta pressione sul foro di attacco + int m_nLeadOutType ; // tipo di uscita (come attacco, nessuno, lineare, tangente) double m_dLoTang ; // distanza tangente verso fine uscita double m_dLoPerp ; // distanza perpendicolare verso fine uscita double m_dLoCompLen ; // lunghezza del tratto di disinserimento correttore raggio utensile @@ -49,9 +60,11 @@ struct WaterJettingData : public MachiningData : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dTipFeed( 0), m_dOffsR( UNKNOWN_PAR), m_bInvert( false), m_nWorkSide( 0), - m_dOverlap( 0), m_dSideAngle( 0), + m_dOverlap( 0), m_dSideAngle( 0), m_dForwardAngle( 0), m_dStartAddLen( 0), m_dEndAddLen( 0), - m_nLeadInType( 0), m_dLiTang( 0), m_dLiPerp( 0), m_dLiCompLen( 0), m_dLiHoleRad( 0), + m_bProbing( true), m_dProbingMinDist( 90), m_dProbingMaxDist( 500), + m_nExtCornerType( 2), m_nIntCornerType( 1), m_dCornerSlowLen( 10), m_nCornerSlowPerc( 40), + m_nLeadInType( 0), m_dLiTang( 0), m_dLiPerp( 0), m_dLiCompLen( 0), m_bLiHole( true), m_dLiHoleRad( 0), m_nLpTurns( 5), m_nHpTurns( 5), m_nLeadOutType( 0), m_dLoTang( 0), m_dLoPerp( 0), m_dLoCompLen( 0) {} WaterJettingData* Clone( void) const override ; bool CopyFrom( const MachiningData* pMdata) override ; @@ -76,9 +89,13 @@ struct WaterJettingData : public MachiningData bool VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const override ; bool VerifySolCh( int nVal) const ; bool VerifyWorkSide( int nVal) const ; + bool VerifyExtCornerType( int nVal) const ; + bool VerifyIntCornerType( int nVal) const ; + bool VerifyCornerSlowPerc( int nVal) const ; bool VerifyLeadInType( int nVal) const ; bool VerifyLeadOutType( int nVal) const ; bool VerifySideAngle( double dVal) const ; + bool VerifyForwardAngle( double dVal) const ; } ; //----------------------------------------------------------------------------