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

EgtMachKernel :

Browse Source 
- a lavorazione WaterJetting aggiunti parametri necessari.
This commit is contained in:
Dario Sassi
2019-10-21 10:59:44 +00:00
parent 222db2563a
commit 40aa1de2de
4 changed files with 390 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files
WaterJetting.cpp
+168 -35
View File
@@ -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<ICurveComposite> 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 ;
}
WaterJetting.h
+3
View File
@@ -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
WaterJettingData.cpp
+196 -3
View File
@@ -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<std::string,KEY_ZZZ> 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<std::string,KEY_ZZZ> 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 ;
WaterJettingData.h
+23 -6
View File
@@ -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 ;
} ;
//----------------------------------------------------------------------------