Dario Sassi
20b05935fb
- migliorato riconoscimento taglio doppio longitudinale con numero di facce longitudinali e di limitazione - aggiunta lavorazione di lama sui tagli doppi longitudinali - migliorato LongCut con svuotature se molto corti e non fattibili altrimenti.
463 lines
20 KiB
Lua
463 lines
20 KiB
Lua
-- ProcessLongDoubleCut.lua by Egaltech s.r.l. 2020/01/28
|
|
-- Gestione calcolo doppio taglio longitudinale per Travi
|
|
|
|
-- Tabella per definizione modulo
|
|
local ProcessLong2Cut = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
local BL = require( 'BeamLib')
|
|
|
|
EgtOutLog( ' ProcessLongDoubleCut started', 1)
|
|
|
|
-- Dati
|
|
local BD = require( 'BeamData')
|
|
local ML = require( 'MachiningLib')
|
|
|
|
---------------------------------------------------------------------
|
|
-- Riconoscimento della feature
|
|
function ProcessLong2Cut.Identify( Proc)
|
|
return ( Proc.Grp == 0 and Proc.Prc == 12)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Classificazione della feature
|
|
function ProcessLong2Cut.Classify( Proc)
|
|
return true, false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Classificazione della feature, calcolo il numero di facce longitudinali e limite.
|
|
-- Ritorna due valori :
|
|
-- il primo indica il numero di facce longitudinali
|
|
-- il secondo indica quante e quali facce limite sono presenti con questa codifica
|
|
-- 0: nessuna faccia limite; 1: faccia limite a destra (X+); 2: faccia limite a sinistra (X-); 3: due facce limite.
|
|
function ProcessLong2Cut.IdentifyFaces( Proc)
|
|
-- verifico le normali delle facce
|
|
local nFaceLong = 0
|
|
local nFaceLimit = 0
|
|
local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
|
|
for i = 1, nFacetCnt do
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT)
|
|
-- se è una faccia limite a sinistra
|
|
if vtN:getX() > GEO.EPS_SMALL then
|
|
nFaceLimit = nFaceLimit + 2
|
|
-- se è una faccia limite a destra
|
|
elseif vtN:getX() < -GEO.EPS_SMALL then
|
|
nFaceLimit = nFaceLimit + 1
|
|
-- altrimenti è una faccia longitudinale
|
|
else
|
|
nFaceLong = nFaceLong + 1
|
|
end
|
|
end
|
|
return nFaceLong, nFaceLimit
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Applicazione della lavorazione
|
|
function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId)
|
|
-- dati delle facce
|
|
local nFc = {0,1}
|
|
local ptC = {}
|
|
local vtN = {}
|
|
-- ciclo sulle facce per identificare le facce longitudinali
|
|
local nLongFct = 0
|
|
for j = 1, Proc.Fct do
|
|
local ptCen, vtNrm = EgtSurfTmFacetCenter( Proc.Id, (j-1), GDB_ID.ROOT)
|
|
if abs( vtNrm:getX()) < GEO.EPS_SMALL then
|
|
nLongFct = nLongFct + 1
|
|
ptC[nLongFct] = Point3d( ptCen)
|
|
vtN[nLongFct] = Vector3d( vtNrm)
|
|
end
|
|
end
|
|
local dLen = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD):getDimX()
|
|
-- verifico posizione (+1=sopra, -1=sotto, 0=sui lati)
|
|
local nSide = 0
|
|
if vtN[1]:getZ() > -10 * GEO.EPS_SMALL and vtN[2]:getZ() > -10 * GEO.EPS_SMALL then
|
|
nSide = 1
|
|
elseif vtN[1]:getZ() < -10 * GEO.EPS_SMALL and vtN[2]:getZ() < -10 * GEO.EPS_SMALL then
|
|
nSide = -1
|
|
end
|
|
-- angolo diedro per stabilire se taglio convesso
|
|
local bInt, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFc[1], nFc[2], GDB_ID.ROOT)
|
|
local bConvex
|
|
local bOrtho
|
|
local ptM
|
|
if bInt then
|
|
bConvex = ( dAng >= 0)
|
|
bOrtho = ( abs( dAng + 90) < 1)
|
|
ptM = ( ptP1 + ptP2) / 2
|
|
else
|
|
bConvex = true
|
|
bOrtho = false
|
|
ptM = ( ptC[1] + ptC[2]) / 2
|
|
end
|
|
local ptRef = ( ptC[1] + ptC[2]) / 2
|
|
-- analisi del taglio
|
|
local vOrd = {}
|
|
local vFaceUse = {}
|
|
if nSide == 1 then
|
|
vOrd = EgtIf( ptC[1]:getY() < ptRef:getY(), { 1, 2}, { 2, 1})
|
|
vFaceUse = { BL.GetNearestOrthoOpposite( ptC[1] - ptM), BL.GetNearestOrthoOpposite( ptC[2] - ptM)}
|
|
elseif nSide == -1 then
|
|
vOrd = EgtIf( ptC[1]:getY() < ptM:getY(), { 1, 2}, { 2, 1})
|
|
vFaceUse = { BL.GetNearestParalOpposite( ptC[1] - ptM), BL.GetNearestParalOpposite( ptC[2] - ptM)}
|
|
else
|
|
local bFront = ( vtN[1]:getY() < 0)
|
|
if bFront then
|
|
vOrd = EgtIf( ptC[1]:getZ() < ptM:getZ(), { 1, 2}, { 2, 1})
|
|
vFaceUse = { BL.GetNearestOrthoOpposite( ptC[1] - ptM), BL.GetNearestOrthoOpposite( ptC[2] - ptM)}
|
|
else
|
|
vOrd = EgtIf( ptC[1]:getZ() < ptM:getZ(), { 2, 1}, { 1, 2})
|
|
vFaceUse = { BL.GetNearestOrthoOpposite( ptC[1] - ptM), BL.GetNearestOrthoOpposite( ptC[2] - ptM)}
|
|
end
|
|
end
|
|
local vWidth = {}
|
|
_, _, vWidth[1] = BL.GetFaceHvRefDim( Proc.Id, nFc[1])
|
|
_, _, vWidth[2] = BL.GetFaceHvRefDim( Proc.Id, nFc[2])
|
|
|
|
local sWarn
|
|
-- Se ho 2 face longitudinali e non limitato da altre facce e da sopra e richiesto con doppio taglio di lama
|
|
if nLongFct == 2 and Proc.Fct == 2 and nSide == 1 and EgtGetInfo( Proc.Id, 'Q01', 'i') == 1 then
|
|
-- recupero la lavorazione
|
|
local sCutting = ML.FindCutting( 'HeadSide')
|
|
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
|
|
|
|
-- determino numero di parti
|
|
local dStartAccDist = BD.LONGCUT_ENDLEN
|
|
local dEndAccDist = BD.LONGCUT_ENDLEN
|
|
local nC = ceil( ( dLen - dStartAccDist - dEndAccDist) / BD.LONGCUT_MAXLEN)
|
|
local dC = 0
|
|
if nC > 0 then
|
|
dC = dLen / ( nC + 2)
|
|
dStartAccDist = dC
|
|
dEndAccDist = dC
|
|
nC = nC + 2
|
|
else
|
|
if dLen > min( dStartAccDist, dEndAccDist) then
|
|
nC = 2
|
|
dStartAccDist = dLen/2
|
|
dEndAccDist = dStartAccDist
|
|
else
|
|
nC = 1
|
|
dStartAccDist = 0
|
|
dEndAccDist = 0
|
|
end
|
|
end
|
|
|
|
local nM = 0
|
|
-- se convesso lavoro ogni faccia in due metà lasciando attaccata la parte centrale
|
|
if bConvex then
|
|
-- si percorrono i lati alto e basso della faccia
|
|
for i = 1, nC do
|
|
-- Posizione braccio portatesta
|
|
local nSCC = EgtIf( ( i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
|
|
-- ciclo sulle due facce
|
|
for j = 1, #vOrd do
|
|
-- determino se lavorazione da davanti o da dietro
|
|
local bFront = ( vtN[vOrd[j]]:getY() < 0)
|
|
-- determino l'utilizzo della faccia
|
|
local nFaceUse = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_TOP, EgtIf( bFront, MCH_MILL_FU.ORTHO_BACK, MCH_MILL_FU.ORTHO_FRONT))
|
|
local nFaceUse2 = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK))
|
|
-- ciclo sulle passate
|
|
local dOffset = ( vWidth[vOrd[j]] + BD.DIM_STRIP_SMALL) / 2 ;
|
|
local dLioTang = 0
|
|
local dLioPerp = ( vWidth[vOrd[j]] - BD.DIM_STRIP_SMALL) / 2 + BD.CUT_SIC ;
|
|
for k = 1, 2 do
|
|
-- inserisco le parti di lavorazione
|
|
nM = nM + 1
|
|
local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM) .. '_' .. tostring(j)
|
|
local nMchFId = EgtAddMachining( sNameF, sCutting)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, vOrd[j]-1}})
|
|
-- limito opportunamente la lavorazione
|
|
local dSal = EgtIf( i == nC, 0, - dEndAccDist - ( nC - i - 1) * dC)
|
|
local dEal = EgtIf( i == 1, 0, - dStartAccDist - ( i - 2) * dC)
|
|
if ( not bFront and k == 1) or ( bFront and k == 2) then
|
|
dSal, dEal = dEal, dSal
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
|
|
-- imposto offset radiale
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dOffset)
|
|
-- imposto attacco/uscita
|
|
EgtSetMachiningParam( MCH_MP.LITANG, dLioTang)
|
|
EgtSetMachiningParam( MCH_MP.LIPERP, dLioPerp)
|
|
EgtSetMachiningParam( MCH_MP.LOTANG, dLioTang)
|
|
EgtSetMachiningParam( MCH_MP.LOPERP, dLioPerp)
|
|
-- imposto posizione braccio porta testa per non ingombrare agli estremi
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- imposto uso della faccia
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse, nFaceUse2))
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- altrimenti concavo
|
|
else
|
|
-- si percorrono i lati alto e basso della faccia
|
|
for i = 1, nC do
|
|
-- Posizione braccio portatesta
|
|
local nSCC = EgtIf( ( i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
|
|
-- ciclo sulle due facce
|
|
for j = 1, #vOrd do
|
|
-- determino se lavorazione da davanti o da dietro
|
|
local bFront = ( vtN[vOrd[j]]:getY() < 0)
|
|
-- determino l'utilizzo della faccia
|
|
local nFaceUse = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_TOP, EgtIf( bFront, MCH_MILL_FU.ORTHO_BACK, MCH_MILL_FU.ORTHO_FRONT))
|
|
local nFaceUse2 = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK))
|
|
-- ciclo sulle passate
|
|
local dOffset
|
|
local dLioPerp
|
|
if j == 1 then -- il primo taglio lo faccio completo
|
|
dOffset = 0
|
|
dLioPerp = vWidth[vOrd[j]] + BD.CUT_SIC
|
|
else -- il secondo ridotto della distanza minima e della componente spessore della lama
|
|
dOffset = BD.DIM_STRIP_SMALL + ((dToolThick* vtN[vOrd[1]]) - (dToolThick* vtN[vOrd[1]]) * vtN[vOrd[2]] * vtN[vOrd[2]]):len()
|
|
dLioPerp = vWidth[vOrd[j]] - dOffset + BD.CUT_SIC
|
|
end
|
|
local dLioTang = 0
|
|
|
|
local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring(j)
|
|
local nMchFId = EgtAddMachining( sNameF, sCutting)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, vOrd[j]-1}})
|
|
-- limito opportunamente la lavorazione
|
|
local dSal = EgtIf( i == nC, 0, - dEndAccDist - ( nC - i - 1) * dC)
|
|
local dEal = EgtIf( i == 1, 0, - dStartAccDist - ( i - 2) * dC)
|
|
if ( bFront) then
|
|
dSal, dEal = dEal, dSal
|
|
end
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
|
|
-- imposto offset radiale
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dOffset)
|
|
-- imposto attacco/uscita
|
|
EgtSetMachiningParam( MCH_MP.LITANG, dLioTang)
|
|
EgtSetMachiningParam( MCH_MP.LIPERP, dLioPerp)
|
|
EgtSetMachiningParam( MCH_MP.LOTANG, dLioTang)
|
|
EgtSetMachiningParam( MCH_MP.LOPERP, dLioPerp)
|
|
-- imposto posizione braccio porta testa per non ingombrare agli estremi
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- imposto uso della faccia
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse2)
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Se non è sotto : lavorazione Long2Cut
|
|
elseif nSide ~= - 1 then
|
|
-- recupero la lavorazione
|
|
local sMilling = ML.FindMilling( 'Long2Cut')
|
|
if not sMilling then
|
|
local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- recupero i dati dell'utensile
|
|
local dToolDiam = 0
|
|
local dMaxDepth = 0
|
|
if EgtMdbSetCurrMachining( sMilling) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
|
|
dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
|
|
end
|
|
end
|
|
-- determino il numero di parti in cui dividere la lavorazione
|
|
local dEndLen = BD.LONGCUT_ENDLEN
|
|
if dLen < 2 * dEndLen + BD.LONGCUT_MAXLEN then
|
|
dEndLen = dLen / 3
|
|
end
|
|
local nC = ceil( ( dLen - 2 * dEndLen) / BD.LONGCUT_MAXLEN)
|
|
local dC = 0
|
|
if nC > 0 then dC = ( dLen - 2 * dEndLen) / nC end
|
|
nC = nC + 2
|
|
-- ciclo sulle parti
|
|
local nM = 0
|
|
for j = 1, nC do
|
|
-- se facce ortogonali (concave), lavoro solo quella con versore maggiormente verso l'alto
|
|
local nIni, nFin = 1, 2
|
|
if bOrtho then
|
|
if vtN[vOrd[1]]:getZ() >= vtN[vOrd[2]]:getZ() then
|
|
nFin = 1
|
|
else
|
|
nIni = 2
|
|
end
|
|
end
|
|
-- su entrambe le facce
|
|
for i = nIni, nFin do
|
|
-- Limitazioni della lavorazione
|
|
local nPos = EgtIf( i == 1, j, nC - j + 1)
|
|
local dSal = EgtIf( nPos == 1, 0, - dEndLen - ( nPos - 2) * dC)
|
|
local dEal = EgtIf( nPos == nC, 0, - dEndLen - ( nC - nPos - 1) * dC)
|
|
-- Posizione braccio portatesta
|
|
local nSCC = EgtIf( ( j == 1 or j == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
|
|
-- ciclo sulle passate
|
|
local nO = 1
|
|
local dStep = 0
|
|
local dAgg = EgtIf( bConvex, 2 * BD.CUT_EXTRA, BD.CUT_EXTRA)
|
|
if vWidth[vOrd[i]] > 0.8 * dToolDiam then
|
|
nO = ceil( vWidth[vOrd[i]] / ( 0.6 * dToolDiam))
|
|
if nO > 1 then
|
|
dStep = vWidth[vOrd[i]] / nO
|
|
end
|
|
end
|
|
for k = 1, nO do
|
|
-- inserisco le parti di lavorazione
|
|
nM = nM + 1
|
|
local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
|
|
local nMchFId = EgtAddMachining( sNameF, sMilling)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sNameF .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, nFc[vOrd[i]]}})
|
|
-- limito opportunamente la lavorazione
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
|
|
-- imposto posizione braccio porta testa per non ingombrare agli estremi
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- imposto uso faccia
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, vFaceUse[vOrd[i]])
|
|
-- imposto lato di lavoro e inversione
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, false)
|
|
-- imposto offset radiale (nullo se concavo)
|
|
if k < nO then
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, ( nO - k) * dStep)
|
|
else
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, EgtIf( bConvex, - BD.CUT_EXTRA, 0))
|
|
end
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- altrimenti è sotto : lavorazione Long2CutDown
|
|
else
|
|
-- recupero la lavorazione
|
|
local sMilling = ML.FindMilling( 'Long2CutDown')
|
|
if not sMilling then
|
|
local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- recupero i dati dell'utensile
|
|
local dToolDiam = 0
|
|
local dMaxDepth = 0
|
|
if EgtMdbSetCurrMachining( sMilling) then
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
|
dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
|
|
dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
|
|
end
|
|
end
|
|
-- aggiuntivo sull'affondamento
|
|
local dAgg = EgtIf( bConvex, BD.CUT_EXTRA, 0)
|
|
-- determino il numero di parti in cui dividere la lavorazione
|
|
local dEndLen = BD.LONGCUT_ENDLEN
|
|
if dLen < 2 * dEndLen + BD.LONGCUT_MAXLEN then
|
|
dEndLen = dLen / 3
|
|
end
|
|
local nC = ceil( ( dLen - 2 * dEndLen) / BD.LONGCUT_MAXLEN)
|
|
local dC = 0
|
|
if nC > 0 then dC = ( dLen - 2 * dEndLen) / nC end
|
|
nC = nC + 2
|
|
-- ciclo sulle parti
|
|
local nM = 0
|
|
for j = 1, nC do
|
|
-- su entrambe le facce
|
|
for i = 1, 2 do
|
|
-- Limitazioni della lavorazione
|
|
local nPos = EgtIf( i == 1, j, nC - j + 1)
|
|
local dSal = EgtIf( nPos == 1, 0, - dEndLen - ( nPos - 2) * dC)
|
|
local dEal = EgtIf( nPos == nC, 0, - dEndLen - ( nC - nPos - 1) * dC)
|
|
-- Posizione braccio portatesta
|
|
local nSCC = MCH_SCC.ADIR_XP
|
|
-- inserisco le parti di lavorazione
|
|
nM = nM + 1
|
|
local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
|
|
local nMchFId = EgtAddMachining( sNameF, sMilling)
|
|
if not nMchFId then
|
|
local sErr = 'Error adding machining ' .. sNameF .. '-' .. sMilling
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
-- aggiungo geometria
|
|
EgtSetMachiningGeometry( {{ Proc.Id, nFc[vOrd[i]]}})
|
|
-- limito opportunamente la lavorazione
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
|
|
-- imposto posizione braccio porta testa per non ingombrare agli estremi
|
|
EgtSetMachiningParam( MCH_MP.SCC, nSCC)
|
|
-- imposto uso faccia
|
|
EgtSetMachiningParam( MCH_MP.FACEUSE, vFaceUse[vOrd[i]])
|
|
-- imposto lato di lavoro e inversione
|
|
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
if vWidth[vOrd[i]] + dAgg > dMaxDepth - BD.COLL_SIC then
|
|
sWarn = 'Warning in LongDoubleCut : depth (' .. EgtNumToString( vWidth[vOrd[i]] + dAgg, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth - BD.COLL_SIC, 1) .. ')'
|
|
end
|
|
local dDepth = min( dMaxDepth - BD.COLL_SIC, vWidth[vOrd[i]] + dAgg)
|
|
EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
|
|
-- eseguo
|
|
if not EgtApplyMachining( true, false) then
|
|
local _, sErr = EgtGetLastMachMgrError()
|
|
EgtSetOperationMode( nMchFId, false)
|
|
return false, sErr
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return true, sWarn
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
return ProcessLong2Cut
|