andrea.villa
833 lines
36 KiB
Lua
833 lines
36 KiB
Lua
-- ProcessProfCamb.lua by Egaltech s.r.l. 2022/11/03
|
|
-- Gestione calcolo profilo caudato per Travi
|
|
-- 2021/05/03 Aggiunta gestione smusso da sopra e sotto per macchina con testa da sotto.
|
|
-- 2021/06/28 Per macchine con testa sotto, smussi di lato con questa testa se non c'è lav.ne da sopra.
|
|
-- 2021/10/12 Estesa gestione di testa da sotto, se presente.
|
|
-- 2021/10/12 Portato a 30deg l'angolo limite per fare l'antischeggia.
|
|
-- 2022/01/26 Migliorato controllo lavorazione con fresa su testa da sotto.
|
|
-- 2022/02/02 Aggiunta funzione OnlyChamfer.
|
|
-- 2022/05/24 Aggiunta fresatura da sotto su macchine con testa da sotto.
|
|
-- 2022/05/28 Aggiunto calcolo svuotatura da modulo di libreria.
|
|
-- 2022/11/03 Correzione per riconoscimento testa da sotto su fresatura.
|
|
-- 2023/11/30 Calcolo elevazione velocizzato e centralizzato tramite la funzione GetFaceElevation.
|
|
|
|
-- Tabella per definizione modulo
|
|
local ProcessProfCamb = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
local BL = require( 'BeamLib')
|
|
local Fbs = require( 'FacesBySaw')
|
|
local Fbp = require( 'FaceByPocket')
|
|
local Cut = require( 'ProcessCut')
|
|
|
|
EgtOutLog( ' ProcessProfCamb started', 1)
|
|
|
|
-- Dati
|
|
local BD = require( 'BeamData')
|
|
local ML = require( 'MachiningLib')
|
|
|
|
-- variabili assegnazione parametri Q
|
|
local sEnableExtraMillUpperFace = 'Q01' -- i
|
|
local sEnableExtraBladeUpperFace = 'Q02' -- i
|
|
local sDepthChamferMill = 'Q03' -- d
|
|
local sOverMaterialForFinish = 'Q04' -- d
|
|
local sPreemptiveChamfer = 'Q05' -- i
|
|
|
|
-- abilitazioni extra
|
|
local dMakeAntiSplintOnHead = 1 -- valore impronta antischeggia, per disattivare settare = nil o = 0
|
|
local dActivateCompoAng = 0.5 -- valore componente Y o Z per antischeggia
|
|
|
|
---------------------------------------------------------------------
|
|
-- Riconoscimento della feature
|
|
function ProcessProfCamb.Identify( Proc)
|
|
return (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 103)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Classificazione della feature
|
|
function ProcessProfCamb.Classify( Proc, b3Raw)
|
|
-- recupero la curva associata
|
|
local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
|
|
AuxId = EgtIf( AuxId, AuxId + Proc.Id, GDB_ID.NULL)
|
|
local vtN = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
|
|
if not vtN then return false end
|
|
-- se profilo orizzontale
|
|
if abs( vtN:getZ()) < 0.5 then
|
|
return true, false, false
|
|
-- altrimenti è profilo verticale che interessa tutta la sezione
|
|
else
|
|
-- recupero la massima capacità di lavoro dell'utensile da utilizzare
|
|
local sMilling, dMaxDepth = ML.FindMilling( 'Prof')
|
|
if not sMilling then dMaxDepth = 0 end
|
|
if Proc.Box:getDimZ() > dMaxDepth and BD.ROT90 then
|
|
return true, false, true
|
|
else
|
|
return true, false, false
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Verifico se richiesto il solo smusso
|
|
function ProcessProfCamb.OnlyChamfer( Proc)
|
|
return (( EgtGetInfo( Proc.Id, sDepthChamferMill, 'd') or 0) > 0.1 and EgtGetInfo( Proc.Id, sPreemptiveChamfer, 'i') == 1)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetSawCutData( AuxId, vtNF)
|
|
-- comincio con la normale a 45deg
|
|
local vtNP = Vector3d( vtNF)
|
|
for i = 1, 3 do
|
|
if vtNP[i] > GEO.EPS_SMALL then
|
|
vtNP[i] = 1
|
|
elseif vtNP[i] < -GEO.EPS_SMALL then
|
|
vtNP[i] = -1
|
|
end
|
|
end
|
|
vtNP:normalize()
|
|
-- assegno un punto di passaggio
|
|
local ptStart = EgtSP( AuxId, GDB_ID.ROOT) + vtNP * 5.0
|
|
-- determino asse di rotazione
|
|
local vtRot = - Y_AX()
|
|
if vtNF:getX() < 0 then vtRot = - vtRot end
|
|
if vtNF:getZ() < -0.1 then
|
|
vtRot = - vtRot
|
|
elseif vtNF:getY() < -0.1 then
|
|
vtRot:rotate( X_AX(), 90)
|
|
elseif vtNF:getY() > 0.1 then
|
|
vtRot:rotate( X_AX(), -90)
|
|
end
|
|
-- miglioro l'inclinazione (ripartendo da faccia perpendicolare asse trave)
|
|
vtNP[2] = 0 vtNP[3] = 0
|
|
local dRot = 45
|
|
for i = 1, 4 do
|
|
local vtNP2 = Vector3d( vtNP)
|
|
vtNP2:rotate( vtRot, dRot)
|
|
local frRef = Frame3d( ptStart, vtNP2)
|
|
local b3Box = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frRef)
|
|
if b3Box:getMax():getZ() < -3 then
|
|
vtNP = Vector3d( vtNP2)
|
|
end
|
|
dRot = dRot / 2
|
|
end
|
|
-- restituisco i dati del piano
|
|
return ptStart, vtNP
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function ModifySideAndInvert( Proc, bHead, bForceInvert, nCutLengthMach)
|
|
-- confronto il punto iniziale e finale della lavorazione con il box della feature
|
|
-- e se è vicino alla parte esterna della trave inverto la lavorazione
|
|
ptSP = EgtGetMachiningStartPoint()
|
|
ptEp = EgtGetMachiningEndPoint()
|
|
local nMachMode = EgtGetMachiningParam( MCH_MP.STEPTYPE)
|
|
if bForceInvert or ( nMachMode == 1 and ptSP and ptEp) then
|
|
if bForceInvert or ( abs( EgtIf( bHead, Proc.Box:getMax():getX(), Proc.Box:getMin():getX()) - ptSP:getX()) <
|
|
abs( EgtIf( bHead, Proc.Box:getMax():getX(), Proc.Box:getMin():getX()) - ptEp:getX())) then
|
|
-- ottengo il lato lavoro e lo inverto
|
|
local nSideWork = EgtGetMachiningParam( MCH_MP.WORKSIDE)
|
|
if nSideWork > 0 then
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, EgtIf( nSideWork == MCH_MILL_WS.LEFT, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT))
|
|
end
|
|
-- ottengo l'inversione e setto il contrario
|
|
local bInvertMode = EgtGetMachiningParam( MCH_MP.INVERT)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, not bInvertMode)
|
|
-- se devo tagliare il percorso setto anche i parametri per l'antischeggia
|
|
if nCutLengthMach then
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, 0.5)
|
|
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, 0)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, nCutLengthMach)
|
|
end
|
|
-- riapplico la lavorazione
|
|
ML.ApplyMachining( true, false)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function VerifyCham( Proc, AuxId, nRawId, bMakeVertCham, sDephtCham, sOnlyCham)
|
|
local nChamfer = 0
|
|
-- ingombro del grezzo
|
|
local b3Raw = EgtGetRawPartBBox( nRawId)
|
|
-- verifico che lo smusso sia richiesto
|
|
local dDepth = EgtGetInfo( Proc.Id, sDephtCham, 'd') or 0
|
|
if dDepth > 0.1 then
|
|
nChamfer = 1
|
|
end
|
|
-- verifico se posso fare solo lo smusso
|
|
if EgtGetInfo( Proc.Id, sOnlyCham, 'i') == 1 then
|
|
if nChamfer == 1 then
|
|
nChamfer = nChamfer + 1
|
|
-- altrimenti se non ho l'affondamento esco
|
|
else
|
|
local sErr = 'Error : no chamfer depth'
|
|
EgtOutLog( sErr)
|
|
return -1, dDepth, sErr
|
|
end
|
|
end
|
|
-- recupero i dati della curva e del profilo
|
|
local dWidth = abs( EgtCurveThickness( AuxId))
|
|
local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
|
|
-- eseguo lo smusso solo se direzione orizzontale e il flag di lavorazione verticale è disabilitato
|
|
if abs( vtExtr:getZ()) > 0.1 then
|
|
if not bMakeVertCham then
|
|
if nChamfer == 2 then -- se devo fare solo smusso, genero errore
|
|
local sErr = 'Error : not horizontal chamfer'
|
|
EgtOutLog( sErr)
|
|
return -1, dDepth, sErr
|
|
else
|
|
local sWarn = 'Warning : skipped not horizontal chamfer'
|
|
EgtOutLog( sWarn)
|
|
return 0, dDepth
|
|
end
|
|
end
|
|
end
|
|
-- recupero la lavorazione
|
|
local sMilling, sMilling2
|
|
if nChamfer > 0 then
|
|
local bDownHead = BD.DOWN_HEAD and abs( vtExtr:getZ()) < 0.1 and BD.DH_MAX_TOP and ( Proc.Box:getMax():getZ() - b3Raw:getMax():getZ()) < BD.DH_MAX_TOP
|
|
sMilling = ML.FindMilling( 'Mark_H2', nil, nil, nil, nil, true, bDownHead)
|
|
if not sMilling then
|
|
local sErr = 'Error : chamfer not found in library'
|
|
EgtOutLog( sErr)
|
|
return -1, 0, sErr
|
|
end
|
|
if BD.DOWN_HEAD and abs( vtExtr:getZ()) > 0.9 then
|
|
sMilling2 = ML.FindMilling( 'Mark_H2', nil, nil, nil, nil, false, true)
|
|
if not sMilling2 then
|
|
local sErr = 'Error : chamfer2 not found in library'
|
|
EgtOutLog( sErr)
|
|
return -1, 0, sErr
|
|
end
|
|
end
|
|
end
|
|
|
|
return nChamfer, dDepth, sMilling, sMilling2
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyOtherMillCanFinish( dDepthProfile, nSide)
|
|
local dToolMaxDepthFinish
|
|
-- abilitazione lavorazione da sotto
|
|
local sMillType = 'Prof_end'
|
|
local sMillingFinish, _, _, _ = ML.FindMilling( sMillType, nil, nil, nil, nil, true, nil, nil, nil)
|
|
if not sMillingFinish then
|
|
return false
|
|
end
|
|
-- Recupero i dati dell'utensile
|
|
if EgtMdbSetCurrMachining( sMillingFinish) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid)) then
|
|
dToolMaxDepthFinish = EgtTdbGetCurrToolMaxDepth()
|
|
end
|
|
else
|
|
return false
|
|
end
|
|
local bDouble = ( dDepthProfile + BD.CUT_EXTRA > dToolMaxDepthFinish)
|
|
-- se lavorazione in doppio richiesta, si verifica se richiesta testa sotto
|
|
if bDouble and nSide == 0 then
|
|
return false -- TODO macchine con BD.DOWN_HEAD potrebbero lavorare in doppio in questo caso!
|
|
end
|
|
|
|
if not bDouble or ( dDepthProfile + BD.MILL_OVERLAP < dToolMaxDepthFinish * 2) then
|
|
return true, sMillingFinish, bDouble
|
|
end
|
|
return false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Applicazione della lavorazione
|
|
function ProcessProfCamb.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH)
|
|
local sWarn
|
|
-- ingombro del grezzo
|
|
local b3Raw = EgtGetRawPartBBox( nRawId)
|
|
-- ingombro del pezzo
|
|
local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
|
|
local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
if not b3Solid then
|
|
local sErr = 'Error : part box not found'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- recupero e verifico l'entità curva
|
|
local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
|
|
if AuxId then AuxId = AuxId + Proc.Id end
|
|
if not AuxId or ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
|
|
local sErr = 'Error : missing profile geometry'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- recupero i dati della curva e del profilo
|
|
local dProfDepth = abs( EgtCurveThickness( AuxId))
|
|
local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
|
|
local nLastFacet = EgtSurfTmFacetCount( Proc.Id) - 1 -- ultima faccia
|
|
local rfFac, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nLastFacet, GDB_ID.ROOT)
|
|
local nRefFacet = nLastFacet - 1 -- penultima faccia
|
|
local vtNF = EgtSurfTmFacetNormVersor( Proc.Id, nLastFacet, GDB_ID.ROOT)
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nRefFacet, GDB_ID.ROOT)
|
|
-- verifico se in testa o coda
|
|
local bHead = ( vtNF:getX() > 0)
|
|
EgtOutLog( 'vtN=' .. tostring( vtN), 3)
|
|
-- verifico se profilo orientato verso l'alto (1), il basso (-1) o di fianco (0)
|
|
local nSide = 0
|
|
if vtN:getZ() > 0.1 then
|
|
nSide = 1
|
|
elseif vtN:getZ() < -0.1 then
|
|
nSide = -1
|
|
end
|
|
-- abilitazione lavorazione da sotto
|
|
local bMillDown = ( BD.DOWN_HEAD and nSide == -1)
|
|
-- recupero gruppo per geometria addizionale
|
|
local nAddGrpId = BL.GetAddGroup( nPartId)
|
|
if not nAddGrpId then
|
|
local sErr = 'Error : missing AddGroup'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- verifico se sono presenti i parametri Q per la profondità smusso e
|
|
-- per eseguire in esclusiva solo lo smusso
|
|
local bMakeVertCham = BD.DOWN_HEAD
|
|
local nChamfer, dDepthCham, sChamfer, sChamfer2 = VerifyCham( Proc, AuxId, nRawId, bMakeVertCham, sDepthChamferMill, sPreemptiveChamfer)
|
|
-- se non posso lavorare la feature perché condizionata dall'esecuzione del solo chamfer
|
|
-- genero errore e non faccio nulla
|
|
if nChamfer < 0 then
|
|
return false, sChamfer
|
|
end
|
|
--variabili utilizzate in varie parti
|
|
local dMillDiam = 0
|
|
local dToolMaxDepth = 0
|
|
local dToolMaxMat = 0
|
|
local sMilling
|
|
-- in base alla direzione iniziale della curva e al valore di entrata valido, setto l'antischeggia
|
|
local bMakeAs
|
|
local vtStart = EgtSV( AuxId, GDB_ID.ROOT)
|
|
if nSide == 0 then
|
|
if abs(vtStart:getY()) >= dActivateCompoAng and dMakeAntiSplintOnHead and abs(dMakeAntiSplintOnHead) > 0 then
|
|
bMakeAs = true
|
|
end
|
|
else
|
|
if abs(vtStart:getZ()) >= dActivateCompoAng and dMakeAntiSplintOnHead and abs(dMakeAntiSplintOnHead) > 0 then
|
|
bMakeAs = true
|
|
end
|
|
end
|
|
-- se smusso non è esclusivo, aggiungo sgrossatura
|
|
if nChamfer < 2 then
|
|
-- aggiungo piano di sgrossatura e lo lavoro
|
|
local ptStart, vtNP = GetSawCutData( AuxId, vtNF)
|
|
local AddId = EgtSurfTmPlaneInBBox( nAddGrpId, ptStart, vtNP, b3Solid, GDB_RT.GLOB)
|
|
if AddId and BL.GetFaceElevation( AddId, 0, b3Solid) > 20.0 then
|
|
EgtSetName( AddId, 'AddCut_' .. tostring( Proc.Id))
|
|
EgtSetInfo( AddId, 'TASKID', Proc.TaskId)
|
|
-- se macchina PF o ONE e profilo sopra davanti e pezzo alto applico svuotatura
|
|
if BD.C_SIMM and not BD.DOWN_HEAD and vtNP:getZ() > 0 and vtNP:getX() > 0 and b3Raw:getDimZ() > 550 then
|
|
-- recupero la lavorazione
|
|
local sPockType = 'OpenPocket'
|
|
local sPocketing = ML.FindPocketing( sPockType, nil, nil, nil, true, false)
|
|
if not sPocketing then
|
|
local sErr = 'Error : pocketing '..sPockType..' not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- eseguo le svuotature necessarie
|
|
local bOk, sErr = Fbp.Make( Proc, AddId, 0, sPocketing, nPartId, b3Solid)
|
|
if not bOk then
|
|
return false, sErr
|
|
end
|
|
-- altrimenti applico taglio di lama
|
|
else
|
|
local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg,
|
|
Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
|
|
CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
|
|
local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dCurrOvmH)
|
|
if not bOk then
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
-- leggo anticipatamente i parametri utensile fresa per dare un valore opportuno all'elevazione della lama
|
|
-- recupero la lavorazione di fresatura
|
|
local sMillType = 'Prof'
|
|
local bH2
|
|
sMilling, _, _, bH2 = ML.FindMilling( sMillType, nil, nil, nil, nil, true, bMillDown)
|
|
if not sMilling then
|
|
local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
bMillDown = ( bMillDown and bH2)
|
|
-- Recupero i dati dell'utensile
|
|
if EgtMdbSetCurrMachining( sMilling) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
|
|
dToolMaxDepth = EgtTdbGetCurrToolMaxDepth() or dToolMaxDepth
|
|
dToolMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or dToolMaxMat
|
|
end
|
|
end
|
|
-- se non da sotto e abilitato dal parametro Q aggiungo taglio di lama
|
|
if ( nSide ~= -1 or bMillDown) and nLastFacet and EgtGetInfo( Proc.Id, sEnableExtraBladeUpperFace, 'i') == 1 then
|
|
-- recupero la lavorazione
|
|
local sCutType = 'HeadSide'
|
|
local sCutting = ML.FindCutting( sCutType, not bMillDown, bMillDown)
|
|
-- se richiesto taglio con lama da sotto e non trovato non posso utilizzare quello da sopra
|
|
if not sCutting then
|
|
local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' sawing not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- recupero i dati dell'utensile
|
|
local dToolDiam = 0
|
|
local dMaxDepth = 0
|
|
local dToolThick = 0
|
|
if EgtMdbSetCurrMachining( sCutting) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
|
|
dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
|
|
dToolThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dToolThick
|
|
end
|
|
end
|
|
local vtOrthoO = Vector3d( vtN)
|
|
local dVzLimDwnUp = EgtIf( bMillDown, -2, nil)
|
|
local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, nLastFacet, sCutting, dToolDiam, vtOrthoO, dVzLimDwnUp, -((dMillDiam/2)+1), BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
|
|
end
|
|
end
|
|
-- se devo inserire il chamfer
|
|
if nChamfer > 0 then
|
|
local bDoubleCham = false
|
|
local dExtra = 2
|
|
-- inserisco la lavorazione
|
|
local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMchId = EgtAddMachining( sNameCh, sChamfer)
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sChamfer
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ AuxId, -1}})
|
|
-- se profilo sopra o sotto (lavorazioni di fianco)
|
|
if nSide ~= 0 then
|
|
bDoubleCham = true
|
|
-- se lavorazione a destra di fronte o sinistra da dietro, inverto
|
|
if ( bHead and vtExtr:getY() < -0.1) or
|
|
( not bHead and vtExtr:getY() > 0.1) then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
-- altrimenti profilo davanti o dietro (lavorazioni da sopra e/o sotto)
|
|
else
|
|
bDoubleCham = BD.DOWN_HEAD
|
|
-- se fresa verso il basso, la porto verso l'alto
|
|
if vtExtr:getZ() < 0 then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
-- se lavorazione a destra da dietro o sinistra di fronte, inverto
|
|
if ( bHead and vtNF:getY() > 0.1) or
|
|
( not bHead and vtNF:getY() < -0.1) then
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
end
|
|
-- assegno affondamento e offset radiale
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra)
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
|
|
-- allungo inizio e fine attacco
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 10)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 10)
|
|
-- posizione braccio porta testa
|
|
EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
else
|
|
-- applico controllo del punto entrata lavorazione e se non è distante dall'esterno
|
|
-- della feature inverto il punto di inizio della lavorazione
|
|
ModifySideAndInvert( Proc, bHead)
|
|
end
|
|
-- se lavorazione da due parti, aggiungo la seconda
|
|
if bDoubleCham then
|
|
-- inserisco la lavorazione
|
|
local sName = 'ChamB_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local sMachining2 = EgtIf( BD.DOWN_HEAD and sChamfer2, sChamfer2, sChamfer)
|
|
local nMchId = EgtAddMachining( sName, sMachining2)
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMachining2
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ AuxId, -1}})
|
|
-- se lavorazione da sopra o da sotto
|
|
if nSide ~= 0 then
|
|
-- se lavorazione a destra di fronte o sinistra da dietro, inverto
|
|
if ( bHead and vtExtr:getY() > 0.1) or
|
|
( not bHead and vtExtr:getY() < -0.1) then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
else
|
|
-- se lavorazione a destra di fronte o sinistra da dietro, inverto
|
|
if ( bHead and vtN:getY() > 0.1) or
|
|
( not bHead and vtN:getY() < -0.1) then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
end
|
|
-- assegno affondamento e offset radiale
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra)
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
|
|
-- allungo inizio e fine attacco
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 10)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 10)
|
|
-- posizione braccio porta testa
|
|
EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
else
|
|
-- applico controllo del punto entrata lavorazione e se non è distante dall'esterno
|
|
-- della feature inverto il punto di inizio della lavorazione
|
|
ModifySideAndInvert( Proc, bHead)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
-- se configurata fresa di finitura
|
|
local bUseOtherMillOnFinish, sFinishMilling, bDoubleFinishMill = VerifyOtherMillCanFinish( dProfDepth, nSide)
|
|
|
|
-- se il chamfer non è esclusivo continuo con le altre lavorazioni
|
|
if nChamfer < 2 then
|
|
-- verifico se necessario lavorare in doppio
|
|
local bDouble = ( dProfDepth + BD.CUT_EXTRA - 100 * GEO.EPS_SMALL > dToolMaxDepth)
|
|
local dDepth = min( dToolMaxDepth, dProfDepth / 2 + BD.MILL_OVERLAP)
|
|
-- se lavorazione da due parti, aggiungo la seconda
|
|
local sMillingDown
|
|
if bDouble then
|
|
if nSide == 0 then
|
|
if BD.DOWN_HEAD then
|
|
-- recupero la lavorazione
|
|
sMillingDown = ML.FindMilling( 'Prof_H2', nil, nil, nil, nil, false, true)
|
|
if not sMillingDown then
|
|
sWarn = 'Warning : milling from bottom not found in library'
|
|
EgtOutLog( sWarn)
|
|
bDouble = false
|
|
end
|
|
else
|
|
sWarn = 'Warning in profiling : depth (' .. EgtNumToString( dProfDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dToolMaxDepth, 1) .. ')'
|
|
EgtOutLog( sWarn)
|
|
bDouble = false
|
|
end
|
|
end
|
|
end
|
|
-- se orizzontale o trovata lavorazione per doppio verticale
|
|
if bDouble then
|
|
-- inserisco la lavorazione
|
|
local sName
|
|
if bMakeAs then
|
|
sName = 'ProfB_As_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
else
|
|
sName = 'ProfB_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
end
|
|
local nMchId = EgtAddMachining( sName, EgtIf( BD.DOWN_HEAD and nSide == 0, sMillingDown, sMilling))
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ AuxId, -1}})
|
|
-- se lavorazione da sopra e da sotto
|
|
if ( nSide == 0) then
|
|
if vtExtr:getZ() > 0.1 then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
-- altrimenti lavorazione davanti e dietro
|
|
else
|
|
-- se lavorazione a destra di fronte o sinistra da dietro, inverto
|
|
if ( bHead and vtExtr:getY() > 0.1) or
|
|
( not bHead and vtExtr:getY() < -0.1) then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
end
|
|
-- imposto l'affondamento
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
|
|
-- posizione braccio porta testa
|
|
EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
|
|
-- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
|
|
local bFinish
|
|
local dOriOffset = 0
|
|
local dOffsetPar = EgtGetInfo( Proc.Id, sOverMaterialForFinish, 'i') or 0
|
|
-- se parametro sovramateriale è maggiore di 0 lo aggiungo al sovramateriale
|
|
if dOffsetPar > 0 then
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, ( dOriOffset + dOffsetPar))
|
|
bFinish = true
|
|
end
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
else
|
|
-- applico controllo del punto entrata lavorazione e se non è distante dall'esterno
|
|
-- della feature inverto il punto di inizio della lavorazione
|
|
ModifySideAndInvert( Proc, bHead)
|
|
end
|
|
-- se devo fare l'antischeggia in testa
|
|
if bMakeAs then
|
|
local sNewName = 'ProfB_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
-- copio lavorazione per ingresso antischeggia (la copia è la lavorazione finale)
|
|
local nMch2Id = EgtCopyMachining( sNewName, EgtGetName( nMchId))
|
|
-- rendo corrente la precedente, la inverto e modifico il parametri di uscita
|
|
EgtSetCurrMachining( nMchId)
|
|
local dCrvLen = EgtCurveLength( AuxId)
|
|
if dCrvLen > abs(dMakeAntiSplintOnHead) then
|
|
ModifySideAndInvert( Proc, bHead, true, ( abs(dMakeAntiSplintOnHead) - dCrvLen))
|
|
end
|
|
-- rendo corrente la copia (cioè la lavorazione completa)
|
|
EgtSetCurrMachining( nMch2Id)
|
|
nMchId = nMch2Id
|
|
end
|
|
-- se abilitata, aggiungo lavorazione di finitura
|
|
if bFinish and not bUseOtherMillOnFinish then
|
|
-- inserisco la lavorazione
|
|
local sNewName = 'ProfB_Fin_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMch2Id = EgtCopyMachining( sNewName, EgtGetName( nMchId))
|
|
if not nMch2Id then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
else
|
|
-- riporto il sovramateriale originale e tolgo i passi inutili
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dOriOffset)
|
|
EgtSetMachiningParam( MCH_MP.STEP, dToolMaxMat)
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMch2Id, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- inserisco la prima lavorazione
|
|
local sName
|
|
if bMakeAs then
|
|
sName = 'Prof_As_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
else
|
|
sName = 'Prof_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
end
|
|
local nMchId = EgtAddMachining( sName, sMilling)
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ AuxId, -1}})
|
|
-- se lavorazione da sopra o da sotto
|
|
if nSide ~= 0 then
|
|
if not bDouble and nSide == -1 then
|
|
-- se lavorazione a sinistra di fronte o destra da dietro, inverto
|
|
if ( bHead and vtExtr:getY() > 0.1) or
|
|
( not bHead and vtExtr:getY() < -0.1) then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
else
|
|
-- se lavorazione a destra di fronte o sinistra da dietro, inverto
|
|
if ( bHead and vtExtr:getY() < -0.1) or
|
|
( not bHead and vtExtr:getY() > 0.1) then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
end
|
|
-- altrimenti lavorazione dal davanti o dal dietro
|
|
else
|
|
-- se fresa verso il basso, la porto verso l'alto
|
|
if vtExtr:getZ() < 0 then
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
-- se lavorazione a destra da dietro o sinistra di fronte, inverto
|
|
if ( bHead and vtNF:getY() > 0.1) or
|
|
( not bHead and vtNF:getY() < -0.1) then
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
end
|
|
-- se in doppio, imposto l'affondamento
|
|
if bDouble then
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
|
|
end
|
|
-- posizione braccio porta testa
|
|
local nSCC = MCH_SCC.ADIR_NONE
|
|
if BD.TURN == 2 then
|
|
nSCC = MCH_SCC.ADIR_ZP
|
|
else
|
|
nSCC = EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- variabili per gestione direzione percorso e per gestione lavorazione di finitura opzionale
|
|
local ptSP, ptEp
|
|
local bFinish
|
|
local dOriOffset = 0
|
|
local dOffsetPar = EgtGetInfo( Proc.Id, sOverMaterialForFinish, 'i') or 0
|
|
-- se parametro sovramateriale è maggiore di 0 lo aggiungo al sovramateriale
|
|
if dOffsetPar > 0 then
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, ( dOriOffset + dOffsetPar))
|
|
bFinish = true
|
|
end
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
else
|
|
-- applico controllo del punto entrata lavorazione e se non è distante dall'esterno
|
|
-- della feature inverto il punto di inizio della lavorazione
|
|
ModifySideAndInvert( Proc, bHead)
|
|
end
|
|
-- se devo fare l'antischeggia in testa
|
|
if bMakeAs then
|
|
local sNewName = 'Prof_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
-- copio lavorazione per ingresso antischeggia (la copia è la lavorazione finale)
|
|
local nMch2Id = EgtCopyMachining( sNewName, EgtGetName( nMchId))
|
|
-- rendo corrente la precedente, la inverto e modifico il parametri di uscita
|
|
EgtSetCurrMachining( nMchId)
|
|
local dCrvLen = EgtCurveLength( AuxId)
|
|
if dCrvLen > abs(dMakeAntiSplintOnHead) then
|
|
ModifySideAndInvert( Proc, bHead, true, ( abs(dMakeAntiSplintOnHead) - dCrvLen))
|
|
end
|
|
-- rendo corrente la copia (cioè la lavorazione completa)
|
|
EgtSetCurrMachining( nMch2Id)
|
|
nMchId = nMch2Id
|
|
end
|
|
-- se abilitata, aggiungo lavorazione di finitura
|
|
if bFinish and not bUseOtherMillOnFinish then
|
|
-- inserisco la lavorazione
|
|
local sNewName = 'Prof_Fin_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMch2Id = EgtCopyMachining( sNewName, EgtGetName( nMchId))
|
|
if not nMch2Id then
|
|
local sErr = 'Error adding machining ' .. sNewName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
else
|
|
-- riporto il sovramateriale originale e tolgo i passi inutili
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dOriOffset)
|
|
EgtSetMachiningParam( MCH_MP.STEP, dToolMaxMat)
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMch2Id, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
-- se non da sotto e parametro Q abilitato, inserisco lavorazione finitura angolo
|
|
if ( nSide ~= -1 or bMillDown) and EgtGetInfo( Proc.Id, sEnableExtraMillUpperFace, 'i') == 1 then
|
|
sName = 'ProfV_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMchVId = EgtAddMachining( sName, sMilling)
|
|
if not nMchVId then
|
|
local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, nLastFacet}})
|
|
-- aggiusto i parametri
|
|
EgtSetMachiningParam( MCH_MP.INVERT, false)
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, 1)
|
|
EgtSetMachiningParam( MCH_MP.DEPTH_STR, 'TH')
|
|
EgtSetMachiningParam( MCH_MP.STEP, 0)
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, -0.5)
|
|
-- imposto tipo uso faccia
|
|
local nFaceUse = EgtIf( bMillDown, MCH_MILL_FU.ORTHO_TOP, MCH_MILL_FU.ORTHO_DOWN)
|
|
if nSide == 0 then
|
|
nFaceUse = EgtIf( vtN:getY() > 0.1, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK)
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse)
|
|
-- imposto posizione braccio porta testa
|
|
local nSCC = MCH_SCC.ADIR_YM
|
|
if vtN:getY() > 100 * GEO.EPS_ZERO then
|
|
nSCC = MCH_SCC.ADIR_YP
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchVId, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
-- se finitura con fresa piccola
|
|
if bFinish and bUseOtherMillOnFinish then
|
|
local sDepthFinishMill = EgtIf( bDoubleFinishMill, ( dProfDepth+ BD.MILL_OVERLAP ) / 2, dProfDepth + BD.CUT_EXTRA)
|
|
local sMachName = 'Fin_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
nMchId = EgtAddMachining( sMachName, sFinishMilling)
|
|
if not nMchId then
|
|
local sErr = 'Error adding machining ' .. sMachName .. '-' .. sFinishMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ AuxId, -1}})
|
|
|
|
-- imposto l'affondamento
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, sDepthFinishMill)
|
|
-- posizione braccio porta testa
|
|
EgtSetMachiningParam( MCH_MP.SCC, EgtIf( bHead, MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM))
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
end
|
|
|
|
if bDoubleFinishMill then
|
|
local sNewName = 'FinB_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
|
|
local nMch2Id = EgtCopyMachining( sNewName, EgtGetName( nMchId))
|
|
-- ottengo l'inversione e setto il contrario
|
|
local bInvertMode = EgtGetMachiningParam( MCH_MP.INVERT)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, not bInvertMode)
|
|
EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
|
|
|
|
-- eseguo
|
|
if not ML.ApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchId, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- aggiorno ingombro testa o coda per presa
|
|
if nSide ~= 1 then -- se feature di fianco o da sotto
|
|
if bHead then
|
|
BL.UpdateHCING( nRawId, b3Raw:getMax():getX() - dCurrOvmH - Proc.Box:getMin():getX())
|
|
else
|
|
BL.UpdateTCING( nRawId, Proc.Box:getMax():getX() - b3Solid:getMin():getX())
|
|
end
|
|
-- altrimenti feature da sopra
|
|
else
|
|
if bHead then
|
|
BL.UpdateHCING( nRawId, b3Raw:getMax():getX() - dCurrOvmH - Proc.Box:getMax():getX())
|
|
else
|
|
BL.UpdateTCING( nRawId, Proc.Box:getMin():getX() - b3Solid:getMin():getX())
|
|
end
|
|
end
|
|
return true, sWarn
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
return ProcessProfCamb
|