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

EgtMachKernel :

Browse Source 
- modifiche per gestione aggregato da sotto in foratura e fresatura
- modifiche per nuovi tipi di uscite lame allungate.
This commit is contained in:
Dario Sassi
2017-01-26 09:36:38 +00:00
parent 5849ad4f41
commit 5ffbaab0e4
10 changed files with 279 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Milling.cpp
+130 -6
View File
@@ -1263,6 +1263,12 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
}
}
// verifiche per fresatura dal basso
m_bAggrBottom = false ;
if ( ! VerifyPathFromBottom( pCompo, vtTool)) {
return false ;
}
// se richiesta anteprima
if ( nPvId != GDB_ID_NULL) {
// creo gruppo per geometria di lavorazione del percorso
@@ -1398,6 +1404,72 @@ Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtToo
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool)
{
// se non è fresatura dal basso in alto, esco
if ( vtTool.z > - 0.5)
return true ;
// se c'è tavola basculante, esco
bool bTabTilting = false ;
if ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTabTilting) && bTabTilting)
return true ;
// verifico se c'è rinvio da sotto
int nHeadId = m_pMchMgr->GetHeadId( m_TParams.m_sHead) ;
int nAgbType ;
if ( ! m_pGeomDB->GetInfo( nHeadId, "AGB_TYPE", nAgbType) || nAgbType == 0) {
string sOut = "Milling error : missing aggregate from bottom" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
// recupero la massima distanza consentita dal rinvio
double dAgbDmax = 0 ;
m_pGeomDB->GetInfo( nHeadId, "AGB_DMAX", dAgbDmax) ;
// calcolo la massima distanza minima del percorso dal contorno del grezzo
double dDist = 0 ;
Vector3d vtDir ;
int nMaxInd = pCompo->GetCurveCount() - 1 ;
for ( int i = 0 ; i <= nMaxInd ; ++ i) {
// curva corrente
const ICurve* pCrvC = pCompo->GetCurve( i) ;
// considero inizio della prima curva, punto medio e fine di tutte
Point3d ptP ;
double dCurrDist = 0 ;
Vector3d vtCurrDir ;
if ( i == 0) {
pCrvC->GetStartPoint( ptP) ;
GetMinDistanceFromRawSide( m_nPhase, ptP, dCurrDist, vtCurrDir) ;
if ( dCurrDist > dDist) {
dDist = dCurrDist ;
vtDir = vtCurrDir ;
}
}
pCrvC->GetMidPoint( ptP) ;
GetMinDistanceFromRawSide( m_nPhase, ptP, dCurrDist, vtCurrDir) ;
if ( dCurrDist > dDist) {
dDist = dCurrDist ;
vtDir = vtCurrDir ;
}
pCrvC->GetEndPoint( ptP) ;
GetMinDistanceFromRawSide( m_nPhase, ptP, dCurrDist, vtCurrDir) ;
if ( dCurrDist > dDist) {
dDist = dCurrDist ;
vtDir = vtCurrDir ;
}
}
// se supera il limite, errore
if ( dDist > dAgbDmax) {
string sOut = "Milling error : path too far from part sides" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
// assegno direzione di accesso e segnalo utilizzo aggregato da sotto
SetAuxDir( vtDir) ;
m_bAggrBottom = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo)
@@ -2048,23 +2120,50 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
bool
Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
SetFlag( 1) ;
// se con aggregato da sotto
if ( m_bAggrBottom) {
// ne recupero alcuni dati
double dAgbEncH = 0 ;
double dAgbEncV = 0 ;
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ;
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ;
// aggiuntivo in Z
double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ;
// distanza dal bordo del pezzo
double dDistBottom ;
if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom))
dDistBottom = 0 ;
// pre-approccio
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ;
Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ;
Vector3d vtAux = m_vtAux ;
vtAux.Rotate( Z_AX, 90) ;
SetAuxDir( vtAux) ;
if ( AddRapidStart( ptP00, MCH_CL_AGB_DWN) == GDB_ID_NULL)
return false ;
vtAux.Rotate( Z_AX, - 90) ;
SetAuxDir( vtAux) ;
SetFlag( 0) ;
if ( AddRapidMove( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
return false ;
}
// se sopra attacco c'è spazio per sicurezza o approccio
if ( dElev + max( dSafeZ, dAppr) > 10 * EPS_SMALL) {
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
SetFlag( 1) ;
Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
if ( ( ! m_bAggrBottom && AddRapidStart( ptP1) == GDB_ID_NULL) ||
( m_bAggrBottom && AddRapidMove( ptP1) == GDB_ID_NULL))
return false ;
}
else {
// 1a -> punto sopra inizio
SetFlag( 1) ;
Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - dAppr) ;
if ( AddRapidStart( ptP1a) == GDB_ID_NULL)
return false ;
if ( ( ! m_bAggrBottom && AddRapidStart( ptP1a) == GDB_ID_NULL) ||
( m_bAggrBottom && AddRapidMove( ptP1a) == GDB_ID_NULL))
// 1b -> punto appena sopra inizio
if ( ( dElev + dAppr) > EPS_SMALL) {
SetFlag( 0) ;
@@ -2081,7 +2180,8 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
else {
// affondo diretto al punto iniziale
SetFlag( 0) ;
if ( AddRapidStart( ptP) == GDB_ID_NULL)
if ( ( ! m_bAggrBottom && AddRapidStart( ptP) == GDB_ID_NULL) ||
( m_bAggrBottom && AddRapidMove( ptP) == GDB_ID_NULL))
return false ;
}
return true ;
@@ -2114,6 +2214,30 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
return false ;
}
}
// se con aggregato da sotto
if ( m_bAggrBottom) {
// ne recupero alcuni dati
double dAgbEncH = 0 ;
double dAgbEncV = 0 ;
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCH", dAgbEncH) ;
m_pGeomDB->GetInfo( m_pMchMgr->GetHeadId( m_TParams.m_sHead), "AGB_ENCV", dAgbEncV) ;
// aggiuntivo in Z
double dAggZ = max( dElev + max( dSafeZ, dAppr), 0.) ;
// distanza dal bordo del pezzo
double dDistBottom ;
if ( ! GetDistanceFromRawSide( m_nPhase, ptP, m_vtAux, dDistBottom))
dDistBottom = 0 ;
// post-retract
Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAux * ( dDistBottom + dAgbEncH + dAppr) ;
Point3d ptP00 = ptP0 + Z_AX * ( dAgbEncV + m_TParams.m_dLen + dAggZ) ;
if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL)
return false ;
Vector3d vtAux = m_vtAux ;
vtAux.Rotate( Z_AX, 90) ;
SetAuxDir( vtAux) ;
if ( AddRapidMove( ptP00, MCH_CL_AGB_UP) == GDB_ID_NULL)
return false ;
}
return true ;
}