From a0b55b8628833efacdc4f7e0b45e320fb088e0e2 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 16 Nov 2022 16:47:39 +0100 Subject: [PATCH 01/24] -- 2022/11/10 Corrette finiture lama per BigSection con trave alta --- LuaLibs/ProcessHeadCut.lua | 35 +++++++++++++++++++++++++++-------- LuaLibs/ProcessSplit.lua | 9 ++++++++- 2 files changed, 35 insertions(+), 9 deletions(-) diff --git a/LuaLibs/ProcessHeadCut.lua b/LuaLibs/ProcessHeadCut.lua index 2abb99a..51f397b 100644 --- a/LuaLibs/ProcessHeadCut.lua +++ b/LuaLibs/ProcessHeadCut.lua @@ -5,6 +5,7 @@ -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata. -- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut -- 2022/11/02 Corretti accorciamenti per DoubleCut +-- 2022/11/10 Corrette finiture lama per BigSection con trave alta -- Tabella per definizione modulo local ProcessHeadCut = {} @@ -168,11 +169,13 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut -- recupero i dati dell'utensile local dSawDiam = 400 local dMaxDepth = 50 + local dSawThick = 2 if EgtMdbSetCurrMachining( sCutting) then local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth + dSawThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick end end local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0) @@ -181,20 +184,22 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut -- recupero i dati della eventuale seconda lama local dSawDiam2 = 0 local dMaxDepth2 = 0 + local dSawThick2 = 0 if sCutting2 and EgtMdbSetCurrMachining( sCutting2) then local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2 dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2 + dSawThick2 = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick2 end end -- caratteristiche taglio local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM)) local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( b3Raw:getDimZ() > EgtIf( BD.TURN, 2 * dMaxVertDepth, dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) - local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA) - local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) - local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL) + local bHorizCut = ( ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA) + local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) + local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL) -- dati geometrici del taglio local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT) -- se non obbligatorio e coincide con inizio grezzo, non va fatto @@ -210,8 +215,21 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut local nQ05 = EgtGetInfo( nOriId or GDB_ID.NULL, 'Q05', 'i') or 0 -- se finitura con lama if nQ05 == 1 or nQ05 == 0 then - local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT) - if not bOk then return bOk, sErr end + local dSawThickCheck = dSawThick + if dSawThick2 > 0 and bDoubleHorizCut then + dSawThickCheck = min( dSawThick, dSawThick2) + end + local dMaxElev = 0 + if vtN:getX() > 0 then + dMaxElev = b3Raw:getMax():getX() - Proc.Box:getMin():getX() + else + dMaxElev = Proc.Box:getMax():getX() - b3Raw:getMin():getX() + end + -- controllo se è necessario un taglio con dicing o si deve proseguire ai casi standard + if dMaxElev > dSawThickCheck then + local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT) + return bOk, sErr + end -- se finitura con truciolatore elseif nQ05 == 2 then local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) @@ -227,11 +245,12 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut return false, sErr end local bOk, sErr = Pocket.Make( Proc, Proc.Id, 0, sPocketing, nPartId, b3Solid) - if not bOk then return bOk, sErr end + return bOk, sErr end end + end -- se tagli standard - elseif not bDoubleHorizCut then + if not bDoubleHorizCut then -- flag di lavorazione faccia local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT) -- calcolo extra taglio ed accorciamento @@ -277,7 +296,7 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut -- verifico che le due lame riescano a lavorare la sezione local dDimZ = b3Raw:getDimZ() local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ - if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then + if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then local sErr = 'Error : section too big for head cut' EgtOutLog( sErr) return false, sErr diff --git a/LuaLibs/ProcessSplit.lua b/LuaLibs/ProcessSplit.lua index 92c8340..f617d5f 100644 --- a/LuaLibs/ProcessSplit.lua +++ b/LuaLibs/ProcessSplit.lua @@ -6,6 +6,7 @@ -- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut -- 2022/11/02 Corretti accorciamenti per DoubleCut -- 2022/11/10 Corrette finiture lama per BigSection con trave alta +-- 2022/11/16 Correzioni per travi larghe -- Tabella per definizione modulo local ProcessSplit = {} @@ -346,6 +347,12 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt -- altrimenti tagli dai due fianchi (dietro e davanti) else local cutDepth = 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN + -- se la sega a catena non può completare lo split esco + if cutDepth >= min( dMaxMat, dTLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then + sErr = 'Error : section too big for splitting' + EgtOutLog( sErr) + return false, sErr, -1 + end local sNotesSplit = 'Presplit;' local bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_BACK, cutDepth, sNotesSplit, dOffs) if not bOk then return bOk, sErr, nNewPhase end @@ -482,7 +489,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt -- verifico che le due lame riescano a lavorare la sezione local dDimZ = b3Raw:getDimZ() local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ - if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then + if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then local sErr = 'Error : section too big for tail cut' EgtOutLog( sErr) return false, sErr From ec1a8e711d83256e8fb6abec087af936642ea182 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 18 Nov 2022 10:46:50 +0100 Subject: [PATCH 02/24] Revert "Revert "Merge branch 'Feature/FindMirroredFeatures' of https://gitlab.steamware.net/egaltech/DataBeam into develop"" This reverts commit 182639772d4b8660289b094a98765830c7ed99d2. --- LuaLibs/BeamExec.lua | 111 ++++++++++++++++++++++++++++++++++- LuaLibs/ProcessDtMortise.lua | 7 +++ 2 files changed, 117 insertions(+), 1 deletion(-) diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index d9eeb9a..a1732f6 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -35,8 +35,9 @@ -- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL). -- 2022/08/08 Modifica per macchine senza BD.MAX_WIDTH2 e BD.MAX_HEIGHT2. -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata. --- 2022/09/21 Nella funzione di ordinamento il foro del birdsmouth viene sempre fatto prima della lavorazione stessa -- 2022/09/28 I fori vengono sempre fatti prima delle tacche. +-- 2022/09/29 Aggiunta la ricerca di feature specchiate, al momento solo per DtMortise, con le relative funzioni. + -- Tabella per definizione modulo local BeamExec = {} @@ -1368,6 +1369,109 @@ local function MoveDrillsOnTenon( vProc) end end +------------------------------------------------------------------------------------------------------------- +-- Estrazione parametri P da lavorazioni di tipo DtMortise +local function GetPParametersDtMortise( Proc) + local vPParameters = { + { 'P01', 'd'}, + { 'P02', 'd'}, + { 'P03', 'd'}, + { 'P04', 'i'}, + { 'P05', 'i'}, + { 'P06', 'd'}, + { 'P07', 'd'}, + { 'P09', 'd'}, + { 'P10', 'd'}, + { 'P11', 'd'}, + { 'P12', 'd'}, + { 'P13', 'd'}, + { 'P14', 'd'}, + { 'P15', 'd'} + } + for i = 1, #vPParameters do + vPParameter = vPParameters[i] + vPParameter[3] = EgtGetInfo( Proc.Id, vPParameter[1], vPParameter[2]) + end + return vPParameters +end + +------------------------------------------------------------------------------------------------------------- +-- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo DtMortise +local function CheckMirrorDtMortise( Proc, ProcMirror, dHBeam) + local bIsMirror = true + local vPParametersProc = GetPParametersDtMortise( Proc) + local vPParametersMirror = GetPParametersDtMortise( ProcMirror) + local nP02, nP06 = 2, 6 + -- controllo che i parametri P delle due feature, tranne P02 e P06, siano uguali + for i = 1, #vPParametersProc do + local vPParameterProc = vPParametersProc[i] + local vPParameterMirror = vPParametersMirror[i] + if vPParameterProc[1] ~= 'P02' and vPParameterProc[1] ~= 'P06'then + bIsMirror = ( abs( vPParameterProc[3] - vPParameterMirror[3]) < 100 * GEO.EPS_SMALL) + if bIsMirror == false then break end + elseif vPParameterProc[1] == 'P02' then + nP02 = i + elseif vPParameterProc[1] == 'P06' then + nP06 = i + end + end + -- se gli altri parametri P sono uguali, verifico che P02 e P06 siano compatibili con feature specchiate + if bIsMirror == true then + bIsMirror = ( ( vPParametersProc[nP02][3] == 0 and abs( vPParametersMirror[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and + ( vPParametersProc[nP06][3] == 90 and vPParametersMirror[nP06][3] == -90)) or + ( ( vPParametersMirror[nP02][3] == 0 and abs( vPParametersProc[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and + ( vPParametersMirror[nP06][3] == 90 and vPParametersProc[nP06][3] == -90)) + end + return bIsMirror +end + +------------------------------------------------------------------------------------------------------------- +-- Cerca se esiste una feature specchiata di Proc e nel caso ne restituisce la posizione in vProc +local function FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam) + local nProcMirror + -- se mortasa a coda di rondine + if sFeatureType == 'DtMortise' then + Proc.Side = EgtGetInfo( Proc.Id, 'SIDE', 'i') + if Proc.Side == 1 or Proc.Side == 3 then + for i = 1, #vProc do + local ProcMirror = vProc[i] + if DtMortise.SideIdentify(ProcMirror) then + ProcMirror.Side = EgtGetInfo( ProcMirror.Id, 'SIDE', 'i') + if ( Proc.Side == 1 and ProcMirror.Side == 3) or ( Proc.Side == 3 and ProcMirror.Side == 1) then + local bIsMirror = CheckMirrorDtMortise( Proc, ProcMirror, dHBeam) + if bIsMirror then nProcMirror = i end + end + end + end + end + end + -- se foratura (da implementare) + return nProcMirror +end + +------------------------------------------------------------------------------------------------------------- +-- Cerca in vProc la presenza di feature specchiate. Se le trova scrive in Proc e nelle info l'Id della specchiata. +local function SetMirroredFeatures( vProc, dHBeam) + for i = 1, #vProc do + local Proc = vProc[i] + local sFeatureType + if DtMortise.SideIdentify(Proc) then + sFeatureType = 'DtMortise' + elseif Drill.Identify(Proc) then + sFeatureType = 'Drill' + end + if ( sFeatureType == 'DtMortise' or sFeatureType == 'Drill') and not Proc.MirrorId then + local nProcMirror = FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam) + if nProcMirror then + Proc.MirrorId = vProc[nProcMirror].Id + vProc[nProcMirror].MirrorId = Proc.Id + EgtSetInfo( Proc.Id, 'MIRRORID', vProc[nProcMirror].Id) + EgtSetInfo( vProc[nProcMirror].Id, 'MIRRORID', Proc.Id) + end + end + end +end + ------------------------------------------------------------------------------------------------------------- -- verifica se ci sono forature da lavorare dopo tagli di testa o coda e nel caso le classifica come Head o Tail e gli assegna l'Id della rispettiva feature di taglio local function SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings) @@ -1462,6 +1566,11 @@ function BeamExec.ProcessFeatures() if BD.IMPROVE_HEAD_TAIL_DRILLINGS then SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings) end + -- verifica presenza di feature specchiate per eventuali lavorazioni simultanee + local bConcurrentDoubleHead = BD.DOUBLE_HEAD_MIRRORED_FEATURES and ( BD.TWO_EQUAL_HEADS or BD.TWO_UP_DOWN_HEADS) + if bConcurrentDoubleHead then + SetMirroredFeatures( vProc, EgtGetRawPartBBox( nRawId):getDimZ()) + end -- le ordino lungo X OrderFeatures( vProc, b3Raw) -- le classifico diff --git a/LuaLibs/ProcessDtMortise.lua b/LuaLibs/ProcessDtMortise.lua index def01c1..e7ebb09 100644 --- a/LuaLibs/ProcessDtMortise.lua +++ b/LuaLibs/ProcessDtMortise.lua @@ -7,6 +7,7 @@ -- 2021/12/01 Se frontale aggiungo taglio con Grp e Proc di vero taglio (per aggiornare ingombro di testa /coda). -- 2022/06/01 Modifiche per evitare di entrare nel legno con mortase parziali. -- 2022/08/18 Migliorato calcolo dello step. +-- 2022/09/29 Aggiunto riconoscimento della sola feature laterale. -- Tabella per definizione modulo local ProcessDtMortise = {} @@ -39,6 +40,12 @@ function ProcessDtMortise.FrontIdentify( Proc) return (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 56) end +--------------------------------------------------------------------- +-- Riconoscimento della sola feature laterale +function ProcessDtMortise.SideIdentify( Proc) + return (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 55) +end + --------------------------------------------------------------------- -- Verifica se feature di coda function ProcessDtMortise.IsTailFeature( Proc, b3Raw) From ea40658bd359c2e998c8b051ba7d761563adaf98 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 21 Nov 2022 12:41:38 +0100 Subject: [PATCH 03/24] BugFix/Ticket#802: - piccolo fix per dovetail in doppio --- LuaLibs/BeamExec.lua | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index a1732f6..d003a51 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -1432,18 +1432,17 @@ local function FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam) -- se mortasa a coda di rondine if sFeatureType == 'DtMortise' then Proc.Side = EgtGetInfo( Proc.Id, 'SIDE', 'i') - if Proc.Side == 1 or Proc.Side == 3 then for i = 1, #vProc do local ProcMirror = vProc[i] if DtMortise.SideIdentify(ProcMirror) then ProcMirror.Side = EgtGetInfo( ProcMirror.Id, 'SIDE', 'i') - if ( Proc.Side == 1 and ProcMirror.Side == 3) or ( Proc.Side == 3 and ProcMirror.Side == 1) then + if ( Proc.Side == 1 and ProcMirror.Side == 3) or ( Proc.Side == 3 and ProcMirror.Side == 1) or + ( Proc.Side == 2 and ProcMirror.Side == 4) or ( Proc.Side == 4 and ProcMirror.Side == 2) then local bIsMirror = CheckMirrorDtMortise( Proc, ProcMirror, dHBeam) if bIsMirror then nProcMirror = i end end end end - end end -- se foratura (da implementare) return nProcMirror From 5bc4e6f24f2d301c22eb2f1c0cb70ce3665a51ef Mon Sep 17 00:00:00 2001 From: DarioS Date: Tue, 22 Nov 2022 08:42:51 +0100 Subject: [PATCH 04/24] DataBeam : - modifica alla lavorazione tenoni per favorire in generale l'attacco da sopra. --- LuaLibs/ProcessTenon.lua | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LuaLibs/ProcessTenon.lua b/LuaLibs/ProcessTenon.lua index a278ab9..7aa3754 100644 --- a/LuaLibs/ProcessTenon.lua +++ b/LuaLibs/ProcessTenon.lua @@ -225,7 +225,7 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) local OVERLAP_COEFF = 0.7 -- porto inizio curva il più possibile sul bordo in alto o in basso local dMaxDist = OVERLAP_COEFF * dMillDiam * MAX_PASS - local bMyShortPart = ( bShortPart and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259) + local bMyShortPart = ( bShortPart and vtN:getX() < 0 and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259) BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, ( bH2 and bMillDown) ~= bMyShortPart) -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente local sWarn From b48fe0da34a3b88f8c9c3477df03665ec0b979c2 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 22 Nov 2022 09:33:22 +0100 Subject: [PATCH 05/24] Improvement/DownHeadInFreeContour: - fresatura ok, da sistemare funzionamento smussi --- LuaLibs/ProcessFreeContour.lua | 130 +++++++++++++++++++++++++-------- 1 file changed, 98 insertions(+), 32 deletions(-) diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index b681f39..607fb6a 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -121,7 +121,7 @@ function ProcessFreeContour.Classify( Proc, b3Raw) end --------------------------------------------------------------------- -local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham) +local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham, bDownHead) local nChamfer = 0 -- ingombro del grezzo local b3Raw = EgtGetRawPartBBox( nRawId) @@ -161,7 +161,11 @@ local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham) -- recupero la lavorazione local sMilling if nChamfer > 0 then - sMilling = ML.FindMilling( 'Mark') + if bDownHead then + sMilling = ML.FindMilling( 'Mark_H2') + else + sMilling = ML.FindMilling( 'Mark') + end if not sMilling then local sErr = 'Error : Mark not found in library' EgtOutLog( sErr) @@ -302,7 +306,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end local dOriDepth = dDepth local nDouble = 1 - local bCanDouble = ( abs( vtExtr:getY()) > abs( vtExtr:getZ()) and bCross) + local bCanDouble = ( abs( vtExtr:getY()) > abs( vtExtr:getZ()) and bCross) or ( BD.DOWN_HEAD and bCross) local dDimStrip = BD.DIM_STRIP if dDimStrip < 0 then dDimStrip = EgtGetInfo( Proc.Id, Q_DIM_STRIP, 'd') or 0 @@ -323,6 +327,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) local bIsDepthReduced = false -- se parametro beamdata forza codolo in centro e lavorazione orizzontale e se larghezza trave è sufficientemente larga -- se chiamata da SimpleScarf il codolo è sempre attivo + local dDepthWork = dDepth if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and ( nStep > 1 or Proc.Prc == 70) and bCanDouble and b3Raw:getDimY() > BD.DIM_TO_CENTER_STRIP - 0.1 then nDouble = 2 @@ -332,8 +337,9 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if dDepth > dMaxDepth then if bCanDouble then nDouble = 2 - dDepth = min( 0.5 * dDepth, dMaxDepth) - if dDepth < 0.5 * dDepth - 10 * GEO.EPS_SMALL then + dDepthWork = 0.5 * dDepth + dDepth = min( dDepthWork, dMaxDepth) + if dDepth < dDepthWork - 10 * GEO.EPS_SMALL then bIsDepthReduced = true end else @@ -345,7 +351,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) local sWarn = '' -- se ho ridotto l'altezza emetto warning if bIsDepthReduced then - sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : elevation bigger than max tool depth' + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : depth (' .. EgtNumToString( dDepthWork, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')' EgtOutLog( sWarn) end -- se utensile orizzontale verso Y+, non in doppio e codolo da lasciare, devo invertire per lavorare sempre da Y- @@ -374,35 +380,66 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) -- aggiungo geometria EgtSetMachiningGeometry( {{ AuxId, -1}}) -- se lavorazione da sopra o da sotto - if nSide ~= 0 then + if nSide == 0 then bDoubleCham = true - end - if Proc.Grp == 3 then - if not bToolInv then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - else - if not bDownHead and vtExtr:getZ() < 0 then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - else - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - end - end - end - if Proc.Grp == 4 then - if not bToolInv then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - else - if not bDownHead and vtExtr:getZ() < 0 then + if Proc.Grp == 3 then + if not bToolInv then EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) EgtSetMachiningParam( MCH_MP.INVERT, true) - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) else + if not bDownHead and vtExtr:getZ() < 0 then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + else + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + end + end + end + if Proc.Grp == 4 then + if not bToolInv then EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + else + if not bDownHead and vtExtr:getZ() < 0 then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + else + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + end + end + end + else + bDoubleCham = true + if Proc.Grp == 3 then + if not bToolInv then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + else + if not bDownHead and vtExtr:getZ() < 0 then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + else + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + end + end + end + if Proc.Grp == 4 then + if not bToolInv then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + else + if not bDownHead and vtExtr:getZ() < 0 then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + else + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + end end end end @@ -446,11 +483,26 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) return false, sErr end + local sChamferDown + if nDouble > 1 and bCanDouble then + if nSide == 0 then + if BD.DOWN_HEAD then + -- recupero la lavorazione + _, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, bDownHead) + if not sChamferDown then + sWarn = 'Warning : chamfer from bottom not found in library' + EgtOutLog( sWarn) + bCanDouble = false + end + end + end + 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 nMchId = EgtAddMachining( sName, sChamfer) + local nMchId = EgtAddMachining( sName, EgtIf( BD.DOWN_HEAD and nSide == 0, sChamfer, sChamfer)) if not nMchId then local sErr = 'Error adding machining ' .. sName .. '-' .. sChamfer EgtOutLog( sErr) @@ -511,6 +563,20 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end -- verifico se devo fare sgrossatura più finitura local dOffsetPar = EgtGetInfo( Proc.Id, Q_OVERMAT_FOR_FINISH, 'i') or 0 + local sMillingDown + if nDouble > 1 and bCanDouble 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) + bCanDouble = false + end + end + end + end -- eseguo for i = 1, nStep do for j = 1, nDouble do @@ -535,7 +601,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) else -- inserisco la lavorazione sName = 'Free_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - nMchId = EgtAddMachining( sName, sMilling) + nMchId = EgtAddMachining( sName, EgtIf( j == 2 and BD.DOWN_HEAD and nSide == 0, sMillingDown, sMilling)) if not nMchId then local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling EgtOutLog( sErr) From 07dad8f8c20e6439ef93cab312088b7f0bb8ca1e Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 22 Nov 2022 14:51:39 +0100 Subject: [PATCH 06/24] Improvement/DownHeadInFreeContour: - correzione fresatura per casi in cui si parte dalla testa sotto --- LuaLibs/ProcessFreeContour.lua | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index 607fb6a..ea36115 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -381,7 +381,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) EgtSetMachiningGeometry( {{ AuxId, -1}}) -- se lavorazione da sopra o da sotto if nSide == 0 then - bDoubleCham = true + bDoubleCham = false if Proc.Grp == 3 then if not bToolInv then EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) @@ -563,18 +563,26 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end -- verifico se devo fare sgrossatura più finitura local dOffsetPar = EgtGetInfo( Proc.Id, Q_OVERMAT_FOR_FINISH, 'i') or 0 - local sMillingDown + local sMillingDown, sMillingUp if nDouble > 1 and bCanDouble then if nSide == 0 then if BD.DOWN_HEAD then -- recupero la lavorazione - sMillingDown = ML.FindMilling( 'Prof_H2', nil, nil, nil, nil, false, true) + sMillingDown = ML.FindMilling( 'FreeContour_H2', nil, nil, nil, nil, false, true) if not sMillingDown then sWarn = 'Warning : milling from bottom not found in library' EgtOutLog( sWarn) bCanDouble = false end end + if EgtEndsWith( sMilling, '_H2') then + sMillingUp = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, true, false) + if not sMillingDown then + sWarn = 'Warning : milling not found in library' + EgtOutLog( sWarn) + bCanDouble = false + end + end end end -- eseguo @@ -601,7 +609,11 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) else -- inserisco la lavorazione sName = 'Free_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - nMchId = EgtAddMachining( sName, EgtIf( j == 2 and BD.DOWN_HEAD and nSide == 0, sMillingDown, sMilling)) + if EgtEndsWith( sMilling, '_H2') then + nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingUp, sMilling)) + else + nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingDown, sMilling)) + end if not nMchId then local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling EgtOutLog( sErr) From 2c5de2516daf9e364de61c722f959d0eca5aa0cb Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 22 Nov 2022 17:53:17 +0100 Subject: [PATCH 07/24] Improvement/DownHeadInFreeContour: - implementazione corretta degli smussi --- LuaLibs/ProcessFreeContour.lua | 134 ++++++++++++++------------------- 1 file changed, 57 insertions(+), 77 deletions(-) diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index ea36115..696a610 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -162,7 +162,7 @@ local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham, bDownHead) local sMilling if nChamfer > 0 then if bDownHead then - sMilling = ML.FindMilling( 'Mark_H2') + sMilling = ML.FindMilling( 'Mark_H2', nil, nil, nil, nil, false, true) else sMilling = ML.FindMilling( 'Mark') end @@ -367,11 +367,30 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if nChamfer > 0 and Proc.Grp ~= 0 and dOriDepth > dDepthCham and Proc.Prc ~= 70 then local bDoubleCham = false local dExtra = 2 + local sChamferDown, sChamferUp + if nDouble > 1 and bCanDouble then + if nSide == 0 then + if BD.DOWN_HEAD then + -- recupero la lavorazione + _, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true) + if not sChamferDown then + sWarn = 'Warning : chamfer from bottom not found in library' + EgtOutLog( sWarn) + end + end + _, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false) + if not sChamferUp then + sWarn = 'Warning : milling not found in library' + EgtOutLog( sWarn) + end + end + end -- eseguo for i = 1, nStep do -- inserisco la lavorazione local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchId = EgtAddMachining( sNameCh, sChamfer) + local sChamferSide1 = EgtIf( bDownHead, sChamferDown, sChamfer) + local nMchId = EgtAddMachining( sNameCh, sChamferSide1) if not nMchId then local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sChamfer EgtOutLog( sErr) @@ -380,68 +399,39 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) -- aggiungo geometria EgtSetMachiningGeometry( {{ AuxId, -1}}) -- se lavorazione da sopra o da sotto - if nSide == 0 then - bDoubleCham = false - if Proc.Grp == 3 then - if not bToolInv then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - else - if not bDownHead and vtExtr:getZ() < 0 then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - else - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - end - end - end - if Proc.Grp == 4 then - if not bToolInv then + if Proc.Grp == 3 then + if not bToolInv then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + else + if not bDownHead and vtExtr:getZ() < 0 then EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) EgtSetMachiningParam( MCH_MP.INVERT, true) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) else - if not bDownHead and vtExtr:getZ() < 0 then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - else - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - end + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) end end + end + if Proc.Grp == 4 then + if not bToolInv then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + else + if not bDownHead and vtExtr:getZ() < 0 then + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) + EgtSetMachiningParam( MCH_MP.INVERT, true) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + else + EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) + end + end + end + if nSide == 0 then + bDoubleCham = BD.DOWN_HEAD else bDoubleCham = true - if Proc.Grp == 3 then - if not bToolInv then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - else - if not bDownHead and vtExtr:getZ() < 0 then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - else - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - end - end - end - if Proc.Grp == 4 then - if not bToolInv then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - else - if not bDownHead and vtExtr:getZ() < 0 then - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) - EgtSetMachiningParam( MCH_MP.INVERT, true) - EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) - else - EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT) - end - end - end end -- assegno affondamento e offset radiale EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra) @@ -482,27 +472,19 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) EgtSetOperationMode( nMchId, false) return false, sErr end - - local sChamferDown - if nDouble > 1 and bCanDouble then - if nSide == 0 then - if BD.DOWN_HEAD then - -- recupero la lavorazione - _, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, bDownHead) - if not sChamferDown then - sWarn = 'Warning : chamfer from bottom not found in library' - EgtOutLog( sWarn) - bCanDouble = false - end - end - end - 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 nMchId = EgtAddMachining( sName, EgtIf( BD.DOWN_HEAD and nSide == 0, sChamfer, sChamfer)) + local sChamferSide2 + if EgtEndsWith( sChamferSide1, 'H2') then + sChamferSide2 = sChamferUp + elseif nSide == 0 then + sChamferSide2 = sChamferDown + else + sChamferSide2 = sChamfer + end + nMchId = EgtAddMachining( sName, sChamferSide2) if not nMchId then local sErr = 'Error adding machining ' .. sName .. '-' .. sChamfer EgtOutLog( sErr) @@ -572,15 +554,13 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if not sMillingDown then sWarn = 'Warning : milling from bottom not found in library' EgtOutLog( sWarn) - bCanDouble = false end end if EgtEndsWith( sMilling, '_H2') then sMillingUp = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, true, false) - if not sMillingDown then + if not sMillingUp then sWarn = 'Warning : milling not found in library' EgtOutLog( sWarn) - bCanDouble = false end end end From 8baf4ad2d6b480c2e96e5b5fd5b9ec03c0589461 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 23 Nov 2022 19:28:23 +0100 Subject: [PATCH 08/24] Improvement/DrillingsUnder30Deg: - Aggiunta la gestione dei fori con angolo < 30 gradi, per i quali si usa la testa della macchina per accorciare l'utile di lavoro. Fast esclusa. --- LuaLibs/ProcessDrill.lua | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/LuaLibs/ProcessDrill.lua b/LuaLibs/ProcessDrill.lua index 6f318eb..2e3714c 100644 --- a/LuaLibs/ProcessDrill.lua +++ b/LuaLibs/ProcessDrill.lua @@ -14,6 +14,7 @@ -- 2022/07/27 Aggiunta la gestione del tipo di foratura "AngleDrill" per fori molto inclinati -- 2022/08/18 Aggiunta gestione macchine con testa da sotto e punta disabilitata. -- 2022/10/25 Nella funzione Split aggiunto il controllo che le facce di ingresso e uscita siano differenti (potrebbe succedere per fori molto corti). Modifica importatore in futuro. +-- 2022/11/23 Aggiunta la gestione dei fori con angolo < 30 gradi, per i quali si usa la testa della macchina per accorciare l'utile di lavoro. -- Tabella per definizione modulo local ProcessDrill = {} @@ -267,7 +268,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId) local nErrorCode = 0 -- abilitazione foratura da sotto local bDrillDown = ( bDownDrill and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259)) - local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.5) + local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.421) -- primo gruppo di controlli con lunghezza utensile pari a metà foro se passante -- recupero la lavorazione local sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown) @@ -370,10 +371,14 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId) -- Calcolo acciorciamento affondamento utile per evitare collisione portautensile con faccia local TgA = CosB / sqrt( 1 - CosB * CosB) local dSubL = ( dDiamTh / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA + -- Per fori molto inclinati ( < 30 gradi) si usa la testa della macchina per l'accorciamento. Fast esclusa + if BD.C_SIMM and CosB > 0.866 then + dSubL = ( 190 / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA - 96 + end local dMaxDepthOri = dMaxDepth - dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL) + dMaxDepth = min( dMaxDepth, max( dToolFreeLen - dSubL, 0)) -- Verifico inclinazione foro nei limiti - local bTryDrill = ( CosB < BD.DRILL_VX_MAX) + local bTryDrill = EgtIf( dMaxDepth > 0, ( CosB < BD.DRILL_VX_MAX), false) if ( CosB > 0.8 * BD.DRILL_VX_MAX and CosB < BD.DRILL_VX_MAX_ANGLEDRILL) then -- cerco le forature speciali AngleDrill local sDrilling3, sType3, dMaxDepth3 = ML.FindAngleDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown) From 5b1fb41c434080c919d3108bf8f75a6e0f70664a Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 24 Nov 2022 12:22:42 +0100 Subject: [PATCH 09/24] Improvement/FreeContour: - gestione lavorazioni L250 con 2 teste partendo da sotto - se da BeamData si forza la lettura del codolo da parametro Q questo viene sempre fatto indipendentemente dalle dimensioni della feature --- LuaLibs/ProcessFreeContour.lua | 41 ++++++++++++++++++++-------------- 1 file changed, 24 insertions(+), 17 deletions(-) diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index 696a610..988bbc1 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -313,8 +313,8 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end local bStripOnSide = false if bCross then - -- se chiamata da SimpleScarf il codolo è sempre attivo - if dDimStrip > 10 * GEO.EPS_SMALL and ( nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX()) or Proc.Prc == 70) then + -- se forzata da parametro Q il codolo è sempre attivo + if dDimStrip > 10 * GEO.EPS_SMALL and ( BD.DIM_STRIP < 0 or nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX())) then -- devo lasciare un codolo local dExtraCham = EgtIf( nChamfer > 0, 2, 0) dDepth = EgtIf( Proc.Prc == 70, dDepth - dDimStrip - dDepthCham - dExtraCham, dDepth - dDimStrip) @@ -326,9 +326,9 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end local bIsDepthReduced = false -- se parametro beamdata forza codolo in centro e lavorazione orizzontale e se larghezza trave è sufficientemente larga - -- se chiamata da SimpleScarf il codolo è sempre attivo + -- se forzata da parametro Q il codolo è sempre attivo local dDepthWork = dDepth - if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and ( nStep > 1 or Proc.Prc == 70) and + if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and ( BD.DIM_STRIP < 0 or nStep > 1) and bCanDouble and b3Raw:getDimY() > BD.DIM_TO_CENTER_STRIP - 0.1 then nDouble = 2 dDepth = min( ( b3Raw:getDimY() - dDimStrip) * 0.5, dMaxDepth) @@ -372,15 +372,19 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if nSide == 0 then if BD.DOWN_HEAD then -- recupero la lavorazione - _, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true) - if not sChamferDown then + local nChamferDown + nChamferDown, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true) + if nChamferDown < 0 then sWarn = 'Warning : chamfer from bottom not found in library' + sChamferDown = nil EgtOutLog( sWarn) end end - _, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false) - if not sChamferUp then - sWarn = 'Warning : milling not found in library' + local nChamferUp + nChamferUp, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false) + if nChamferUp < 0 then + sWarn = 'Warning : chamfer from bottom not found in library' + sChamferUp = nil EgtOutLog( sWarn) end end @@ -429,7 +433,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end end if nSide == 0 then - bDoubleCham = BD.DOWN_HEAD + bDoubleCham = EgtIf( sChamferDown and BD.DOWN_HEAD, true, false) else bDoubleCham = true end @@ -554,14 +558,15 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if not sMillingDown then sWarn = 'Warning : milling from bottom not found in library' EgtOutLog( sWarn) + elseif sMillingDown and not bDownHead then + bToolInv = true + sMilling = sMillingDown end end - if EgtEndsWith( sMilling, '_H2') then - sMillingUp = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, true, false) - if not sMillingUp then - sWarn = 'Warning : milling not found in library' - EgtOutLog( sWarn) - end + sMillingUp = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, true, false) + if not sMillingUp then + sWarn = 'Warning : milling not found in library' + EgtOutLog( sWarn) end end end @@ -591,8 +596,10 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) sName = 'Free_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) if EgtEndsWith( sMilling, '_H2') then nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingUp, sMilling)) - else + elseif sMillingDown then nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingDown, sMilling)) + else + nMchId = EgtAddMachining( sName, sMilling) end if not nMchId then local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling From 04abd401f6aa7bb9b48da0bf61232c218241c9fe Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 24 Nov 2022 12:59:01 +0100 Subject: [PATCH 10/24] Improvement/FreeContour: piccolo fix per quando manca l'utensile sulla testa inferiore --- LuaLibs/ProcessFreeContour.lua | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index 988bbc1..aca2ad3 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -4,6 +4,8 @@ -- 2022/09/21 In MakeByMill aggiunto messaggio per elevazione non raggiunta. -- 2022/11/03 In MakeByMill migliorata gestione lavorazione con fresa su testa da sotto. -- 2022/11/09 Aggiunta la gestione della chiamata della FreeContour da parte della SimpleScarf. +-- 2022/11/24 In MakeByMill aggiunta la lavorazione sopra/sotto nel caso di testa sotto +-- In MakeByMill se BeamData forza lettura codolo da Q questo viene sempre fatto indipendentemente dalle dimensioni della feature -- Tabella per definizione modulo @@ -549,6 +551,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end -- verifico se devo fare sgrossatura più finitura local dOffsetPar = EgtGetInfo( Proc.Id, Q_OVERMAT_FOR_FINISH, 'i') or 0 + -- nel caso di lavorazioni sopra/sotto cerco lavorazioni specifiche local sMillingDown, sMillingUp if nDouble > 1 and bCanDouble then if nSide == 0 then @@ -558,6 +561,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if not sMillingDown then sWarn = 'Warning : milling from bottom not found in library' EgtOutLog( sWarn) + nDouble = 1 elseif sMillingDown and not bDownHead then bToolInv = true sMilling = sMillingDown From 6ffb0da24dc36e896a83a24171aa15af073ddc06 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 24 Nov 2022 15:19:28 +0100 Subject: [PATCH 11/24] Improvement/FreeContour: - fix --- LuaLibs/ProcessFreeContour.lua | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index aca2ad3..9352d5c 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -559,9 +559,11 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) -- recupero la lavorazione sMillingDown = ML.FindMilling( 'FreeContour_H2', nil, nil, nil, nil, false, true) if not sMillingDown then - sWarn = 'Warning : milling from bottom not found in library' - EgtOutLog( sWarn) nDouble = 1 + dDepth = min( dOriDepth, dMaxDepth) + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : milling from bottom not found in library' .. '\n' .. + '; depth (' .. EgtNumToString( dOriDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')' + EgtOutLog( sWarn) elseif sMillingDown and not bDownHead then bToolInv = true sMilling = sMillingDown From 33d70bdbf49a9bef97ac5e6c6fab94c8640defe5 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 25 Nov 2022 16:46:39 +0100 Subject: [PATCH 12/24] BugFix/FixLongCut: - in LongCut per lavorazioni con fresa su F2 e F4 si esclude la testa 3 per evitare problemi di finecorsa --- LuaLibs/MachiningLib.lua | 14 ++++++++------ LuaLibs/ProcessLongCut.lua | 3 ++- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/LuaLibs/MachiningLib.lua b/LuaLibs/MachiningLib.lua index 8d1bc16..b4faff5 100644 --- a/LuaLibs/MachiningLib.lua +++ b/LuaLibs/MachiningLib.lua @@ -3,6 +3,7 @@ -- 2022/05/07 ES Profonde modifiche per scelta ottimale lavorazioni in macchine con più teste. -- 2022/07/27 Aggiunta la gestione del tipo di foratura "AngleDrill" per fori molto inclinati -- 2022/11/02 Modificata scelta utensile ottimizzata. Ora se c'è un utensile più grande disponibile si dà preferenza a quello. +-- 2022/11/25 Per FindMilling implementata la possibilità di escludere la testa H3 dalla ricerca utensile. -- Tabella per definizione modulo local MachiningLib = {} @@ -108,8 +109,9 @@ local function SetCurrMachiningAndTool( sMachName) local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) local nHead = tonumber( sHead:sub( 2, #sHead)) local bH2 = ( nHead >= 21 and nHead <= 29) + local bH3 = ( nHead >= 31 and nHead <= 39) local bFixed = ( vFixedHeads[nHead]) - return bActive, sTool, bH2, bFixed + return bActive, sTool, bH2, bFixed, bH3 end --------------------------------------------------------------------- @@ -222,7 +224,7 @@ function ReturnParams( MachiningType, MachiningName, sType, ToolParams) end --------------------------------------------------------------------- -local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead) +local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead, bExcludeH3) if bTopHead == nil and bDownHead == nil then bTopHead = true bDownHead = false @@ -273,8 +275,8 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead) _, sMachiningType = EgtEndsWith( Machining.Type, '_H2') end -- recupero dati utensile - local bToolActive, sToolName, bH2, bFixed = SetCurrMachiningAndTool( Machining.Name) - if Machining.On and sMachiningType == sType and bToolActive then + local bToolActive, sToolName, bH2, bFixed, bH3 = SetCurrMachiningAndTool( Machining.Name) + if Machining.On and sMachiningType == sType and bToolActive and ( not bH3 or bH3 == not bExcludeH3) then local bOk, ToolParams = VerifyTool( MachiningType, sType, Params, bH2) if bOk then if MachineHeadUse == ONE_HEAD then @@ -384,8 +386,8 @@ function MachiningLib.FindAngleDrilling( dDiam, dDepth, bTopHead, bDownHead) end --------------------------------------------------------------------- -function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead) - return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead) +function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead, bExcludeH3) + return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH3) end --------------------------------------------------------------------- diff --git a/LuaLibs/ProcessLongCut.lua b/LuaLibs/ProcessLongCut.lua index d47bc00..f72e26b 100644 --- a/LuaLibs/ProcessLongCut.lua +++ b/LuaLibs/ProcessLongCut.lua @@ -860,7 +860,8 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus -- recupero la lavorazione local bDownHead = ( nSide == - 1) sMchType = EgtIf( bDownHead, 'Long2Cut_H2', 'Long2Cut') - local sMilling = ML.FindMilling( sMchType, dElev, nil, nil, nil, not bDownHead, bDownHead) + local bExcludeH3 = bLarghAsFace and abs( nSide) ~= 1 + local sMilling = ML.FindMilling( sMchType, dElev, nil, nil, nil, not bDownHead, bDownHead, bExcludeH3) if not sMilling then local sErr = 'Error : milling '..sMchType..' not found in library' EgtOutLog( sErr) From c8b5f9ca27b59df071e2703edc6c6902355e68d3 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 28 Nov 2022 09:52:01 +0100 Subject: [PATCH 13/24] BugFix/FixLongCut: - aggiustato l'attacco in caso di inizio/fine limitate --- LuaLibs/ProcessLongCut.lua | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) diff --git a/LuaLibs/ProcessLongCut.lua b/LuaLibs/ProcessLongCut.lua index f72e26b..6b0f2de 100644 --- a/LuaLibs/ProcessLongCut.lua +++ b/LuaLibs/ProcessLongCut.lua @@ -886,11 +886,22 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus if bLimXmin and bLimXmax and Proc.Box:getDimX() < 2 * dToolDiam then return MakeByPocketing( Proc, nPhase, nRawId, nPartId) end + -- determino l'utilizzo della faccia + local nFaceUse = EgtIf( abs( vtN:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK)) + -- determino il lato di attacco (0:xMin, 1:xMax) + local nStartSide = 0 + if nFaceUse == MCH_MILL_FU.ORTHO_DOWN and not bFront then + nStartSide = 1 + elseif nFaceUse ~= MCH_MILL_FU.ORTHO_DOWN then + if ( bFront and nSide == -1) or ( not bFront and nSide == 1) then + nStartSide = 1 + end + end -- determino gli estremi local dStartDist = 0 local dStartAccDist = BD.LONGCUT_ENDLEN local bStartFixed = true - if ( bLimXmin and bFront) or ( bLimXmax and not bFront) then + if ( bLimXmin and nStartSide == 0) or ( bLimXmax and nStartSide == 1) then dStartDist = dToolDiam / 2 dStartAccDist = BD.LONGCUT_MAXLEN bStartFixed = false @@ -898,7 +909,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus local dEndDist = 0 local dEndAccDist = BD.LONGCUT_ENDLEN local bEndFixed = true - if ( bLimXmin and not bFront) or ( bLimXmax and bFront) then + if ( bLimXmin and nStartSide == 1) or ( bLimXmax and nStartSide == 0) then dEndDist = dToolDiam / 2 dEndAccDist = BD.LONGCUT_MAXLEN bEndFixed = false @@ -963,8 +974,6 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus dEndAccDist = 0 end end - -- determino l'utilizzo della faccia - local nFaceUse = EgtIf( abs( vtN:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK)) -- si percorre il lato basso della faccia local nM = 0 local nCountMilHead = 0 @@ -995,6 +1004,21 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus EgtOutLog( sErr) return false, sErr end + if i == 1 and not bStartFixed then + if nO == 1 or EgtGetMachiningParam( MCH_MP.LITANG) ~= 0 then + EgtSetMachiningParam( MCH_MP.LIELEV, 0) + EgtSetMachiningParam( MCH_MP.LITANG, 0) + EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR) + EgtSetMachiningParam( MCH_MP.LIPERP, dWidth + BD.CUT_EXTRA + BD.CUT_SIC or 20) + end + elseif i == nC and not bEndFixed then + if nO == 1 or EgtGetMachiningParam( MCH_MP.LOTANG) ~= 0 then + EgtSetMachiningParam( MCH_MP.LOELEV, 0) + EgtSetMachiningParam( MCH_MP.LOTANG, 0) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR) + EgtSetMachiningParam( MCH_MP.LOPERP, dWidth + BD.CUT_EXTRA + BD.CUT_SIC or 20) + end + end -- aggiungo geometria EgtSetMachiningGeometry( {{ Proc.Id, 0}}) -- limito opportunamente la lavorazione From 58ea4361323a227c172d07cf26c5d3075a3b8c31 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 28 Nov 2022 12:28:22 +0100 Subject: [PATCH 14/24] BugFix/FixLongCut: - corrette le passate di pulizia che venivano omesse in alcuni casi --- LuaLibs/ProcessLongCut.lua | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/LuaLibs/ProcessLongCut.lua b/LuaLibs/ProcessLongCut.lua index 6b0f2de..739320f 100644 --- a/LuaLibs/ProcessLongCut.lua +++ b/LuaLibs/ProcessLongCut.lua @@ -13,6 +13,7 @@ -- 2022/07/14 Aggiunta limitazione lavorazione a sinistra anche se il grezzo successivo non ha lavorazioni (finale barra) ma è abbastanza lungo da poter essere riutilizzato (BD.MinRaw). -- 2022/09/23 Modificato l'angolo per l'abilitazione della lama da sotto: ora interviene anche per facce verticali. -- 2022/11/04 Aggiunto passaggio parametro bDownHead (Testa da Sotto) nelle chiamate a MakeSideFace. +-- 2022/11/28 Correzioni varie per attacco, pulizia spigoli, utilizzo H3 -- Tabella per definizione modulo local ProcessLongCut = {} @@ -1004,6 +1005,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus EgtOutLog( sErr) return false, sErr end + -- correggo l'attacco se necessario if i == 1 and not bStartFixed then if nO == 1 or EgtGetMachiningParam( MCH_MP.LITANG) ~= 0 then EgtSetMachiningParam( MCH_MP.LIELEV, 0) @@ -1047,7 +1049,11 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus end -- eventuale lavorazione della faccia limitante l'inizio if i == 1 and not bStartFixed then - local vtIni = EgtIf( bFront, X_AX(), -X_AX()) + -- per il lato sotto il vettore è opposto + local vtIni = EgtIf( bFront, X_AX(), -X_AX()) + if nSide == -1 then + vtIni = -1 * vtIni + end for j = 1, Proc.Fct - 1 do local _, vtN = EgtSurfTmFacetCenter( Proc.Id, j, GDB_ID.ROOT) if vtIni * vtN > 0 and nCountMilHead < 2 then @@ -1064,7 +1070,11 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus -- eventuale lavorazione della faccia limitante la fine if not bEndFixed then - local vtFin = EgtIf( bFront, -X_AX(), X_AX()) + -- per il lato sotto il vettore è opposto + local vtFin = EgtIf( bFront, -X_AX(), X_AX()) + if nSide == -1 then + vtFin = -1 * vtFin + end for j = 1, Proc.Fct - 1 do local _, vtN = EgtSurfTmFacetCenter( Proc.Id, j, GDB_ID.ROOT) if vtFin * vtN > 0 and nCountMilHead < 2 then From 0ab2e88d77fc6178fd5cc8869c5e0f3ea22a19b8 Mon Sep 17 00:00:00 2001 From: DarioS Date: Tue, 29 Nov 2022 09:22:47 +0100 Subject: [PATCH 15/24] DataBeam : - modifiche a LongCut per TURN. --- LuaLibs/ProcessLongCut.lua | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/LuaLibs/ProcessLongCut.lua b/LuaLibs/ProcessLongCut.lua index 739320f..adda025 100644 --- a/LuaLibs/ProcessLongCut.lua +++ b/LuaLibs/ProcessLongCut.lua @@ -981,10 +981,14 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus for i = 1, nC do -- Posizione braccio portatesta local nSCC - if bFront then - nSCC = EgtIf( ( BD.C_SIMM or i == 1 or i == nC - 1), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + if not BD.TURN then + if bFront then + nSCC = EgtIf( ( BD.C_SIMM or i == 1 or i == nC - 1), MCH_SCC.ADIR_XM, MCH_SCC.ADIR_XP) + else + nSCC = EgtIf( ( BD.C_SIMM or i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM) + end else - nSCC = EgtIf( ( BD.C_SIMM or i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM) + nSCC = MCH_SCC.ADIR_ZP end -- ciclo sulle passate local nO = 1 From 9f8e024b3561c2c61995a6f77eae3aca535d717d Mon Sep 17 00:00:00 2001 From: DarioS Date: Wed, 30 Nov 2022 09:52:21 +0100 Subject: [PATCH 16/24] DataBeam : - modifiche in LongCut e LongDoubleCut per macchina Turn. --- LuaLibs/ProcessLongCut.lua | 5 +++-- LuaLibs/ProcessLongDoubleCut.lua | 7 ++++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/LuaLibs/ProcessLongCut.lua b/LuaLibs/ProcessLongCut.lua index adda025..d01ffe9 100644 --- a/LuaLibs/ProcessLongCut.lua +++ b/LuaLibs/ProcessLongCut.lua @@ -1,4 +1,4 @@ --- ProcessLongCut.lua by Egaltech s.r.l. 2022/11/04 +-- ProcessLongCut.lua by Egaltech s.r.l. 2022/11/30 -- Gestione calcolo taglio longitudinale per Travi -- 2021/02/03 Corretto FaceUse con fresa orizzontale su taglio orizzontale. -- 2021/05/18 Possibile taglio con lama anche di fianco su macchina con testa da sotto. @@ -14,6 +14,7 @@ -- 2022/09/23 Modificato l'angolo per l'abilitazione della lama da sotto: ora interviene anche per facce verticali. -- 2022/11/04 Aggiunto passaggio parametro bDownHead (Testa da Sotto) nelle chiamate a MakeSideFace. -- 2022/11/28 Correzioni varie per attacco, pulizia spigoli, utilizzo H3 +-- 2022/11/30 Modifiche su SCC per TURN. -- Tabella per definizione modulo local ProcessLongCut = {} @@ -988,7 +989,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus nSCC = EgtIf( ( BD.C_SIMM or i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM) end else - nSCC = MCH_SCC.ADIR_ZP + nSCC = EgtIf( nFaceUse == MCH_MILL_FU.ORTHO_DOWN, MCH_SCC.ADIR_ZP, EgtIf( nFaceUse == MCH_MILL_FU.ORTHO_FRONT, MCH_SCC.ADIR_YP, MCH_SCC.ADIR_YM)) end -- ciclo sulle passate local nO = 1 diff --git a/LuaLibs/ProcessLongDoubleCut.lua b/LuaLibs/ProcessLongDoubleCut.lua index e3d0cc8..26bc9a2 100644 --- a/LuaLibs/ProcessLongDoubleCut.lua +++ b/LuaLibs/ProcessLongDoubleCut.lua @@ -1,4 +1,4 @@ --- ProcessLongDoubleCut.lua by Egaltech s.r.l. 2022/06/29 +-- ProcessLongDoubleCut.lua by Egaltech s.r.l. 2022/11/30 -- Gestione calcolo doppio taglio longitudinale per Travi -- 2021/05/18 Possibile taglio con lama anche di fianco su macchina con testa da sotto. -- 2021/06/29 Corretta gestione caso equivalente a due smussi. @@ -9,6 +9,7 @@ -- 2022/03/20 Tolta da scelta milling tipo Long2CutDown controllo max diametro fresa. -- 2022/05/27 Corretto ordine per casi sui lati. -- 2022/06/29 Corretto calcolo lunghezza attacco/uscita perpendicolare per lavorazioni di fianco. +-- 2022/11/30 Modifiche su SCC per TURN. -- Tabella per definizione modulo local ProcessLong2Cut = {} @@ -1048,11 +1049,11 @@ function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId, bForcedBladeMaster nSCC = EgtIf( ( j == 1 or j == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM) else if nSide == 1 then - nSCC = EgtIf( vtN[vOrd[i]]:getY() < -0.5, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP) + nSCC = EgtIf( vtN[vOrd[i]]:getY() < 0, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP) elseif nSide == -1 then nSCC = EgtIf( vtN[vOrd[i]]:getY() < 0, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP) else - nSCC = MCH_SCC.ADIR_ZP + nSCC = EgtIf( vtN[vOrd[i]]:getZ() < 0, MCH_SCC.ADIR_ZM, MCH_SCC.ADIR_ZP) end end end From b3cbb4753de52c74ae10d728b8632b5cd519f22a Mon Sep 17 00:00:00 2001 From: DarioS Date: Wed, 30 Nov 2022 16:16:13 +0100 Subject: [PATCH 17/24] DataBeam : - correzione per split su grandi sezioni (dopo taglio con sega a catena senza finitura aggiungeva uno split con lama) --- LuaLibs/ProcessSplit.lua | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/LuaLibs/ProcessSplit.lua b/LuaLibs/ProcessSplit.lua index f617d5f..3737905 100644 --- a/LuaLibs/ProcessSplit.lua +++ b/LuaLibs/ProcessSplit.lua @@ -1,4 +1,4 @@ --- ProcessSplit.lua by Egaltech s.r.l. 2022/08/18 +-- ProcessSplit.lua by Egaltech s.r.l. 2022/11/30 -- Gestione calcolo tagli di separazione per Travi -- 2022/05/31 Aggiunta gestione sezioni alte e larghe con taglio con sega a catena seguito da rifinitura con lama (aggiunta funzione MakeSplitByChainSaw); gestione eventuale creazione nuova fase dall'interno della Make. -- 2022/06/10 Per sezioni alte e larghe aggiunta gestione finitura in base a sovramateriale e a parametro Q05 dell' eventuale lavorazione sostituita. @@ -7,6 +7,7 @@ -- 2022/11/02 Corretti accorciamenti per DoubleCut -- 2022/11/10 Corrette finiture lama per BigSection con trave alta -- 2022/11/16 Correzioni per travi larghe +-- 2022/11/30 Correzione per tagli su grandi sezioni (dopo taglio con sega a catena senza finitura aggiungeva uno split con lama). -- Tabella per definizione modulo local ProcessSplit = {} @@ -435,6 +436,8 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt end return bOk, sErr, nNewPhase end + else + return true, nil, nNewPhase end end -- se tagli standard From b614b85652e64457052f4b27fc9142762cafde30 Mon Sep 17 00:00:00 2001 From: DarioS Date: Thu, 1 Dec 2022 07:33:55 +0100 Subject: [PATCH 18/24] DataBeam : - in forature modifiche per ingombri testa C_SIMM con angoli estremi. --- LuaLibs/ProcessDrill.lua | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/LuaLibs/ProcessDrill.lua b/LuaLibs/ProcessDrill.lua index 2e3714c..d53f865 100644 --- a/LuaLibs/ProcessDrill.lua +++ b/LuaLibs/ProcessDrill.lua @@ -1,4 +1,4 @@ --- ProcessDrill.lua by Egaltech s.r.l. 2022/08/18 +-- ProcessDrill.lua by Egaltech s.r.l. 2022/11/30 -- Gestione calcolo forature per Travi -- 2021/04/14 DS Corretta gestione Invert con testa da sotto. Migliorato calcolo ingombro portautensile. -- 2021/05/03 DS Su macchina con testa da sotto aggiunta possibilità di fare fori verticali metà sopra e l'altra sotto. @@ -370,10 +370,10 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId) local nFac, CosB, vFaces = GetHoleStartData( ptCen, vtExtr, b3Solid) -- Calcolo acciorciamento affondamento utile per evitare collisione portautensile con faccia local TgA = CosB / sqrt( 1 - CosB * CosB) - local dSubL = ( dDiamTh / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA + local dSubL = ( dDiamTh / 2 + ( Proc.Diam - dToolDiam) / 2 + 4) * TgA -- Per fori molto inclinati ( < 30 gradi) si usa la testa della macchina per l'accorciamento. Fast esclusa if BD.C_SIMM and CosB > 0.866 then - dSubL = ( 190 / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA - 96 + dSubL = ( 190 / 2 + ( Proc.Diam - dToolDiam) / 2 + 4) * TgA - 116 end local dMaxDepthOri = dMaxDepth dMaxDepth = min( dMaxDepth, max( dToolFreeLen - dSubL, 0)) From cc24b3b3aee2bf71787824e6cdde00e2e4efd43f Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 5 Dec 2022 18:03:20 +0100 Subject: [PATCH 19/24] BugFix: - corretta la chiamata della FindMilling tramite UUID (MachiningLib) --- LuaLibs/MachiningLib.lua | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LuaLibs/MachiningLib.lua b/LuaLibs/MachiningLib.lua index b4faff5..b51dd6b 100644 --- a/LuaLibs/MachiningLib.lua +++ b/LuaLibs/MachiningLib.lua @@ -147,7 +147,7 @@ end --------------------------------------------------------------------- function VerifyMill( dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bH2) - local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID) + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) local dTMaxDepth = EgtTdbGetCurrToolMaxDepth() local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) local dTTotLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) From b3ca865b42b37d37392d4ca15d8ef5f2871ba46f Mon Sep 17 00:00:00 2001 From: DarioS Date: Mon, 5 Dec 2022 20:23:31 +0100 Subject: [PATCH 20/24] =?UTF-8?q?DataBeam=20:=20-=20a=20Mark=20e=20Text=20?= =?UTF-8?q?sulla=20faccia=20sotto=20aggiunta=20la=20possibilit=C3=A0=20di?= =?UTF-8?q?=20essere=20lavorati=20con=20rinvio=20angolare=20(Text=5FAT).?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LuaLibs/ProcessMark.lua | 35 ++++++++++++++++++++--------------- LuaLibs/ProcessText.lua | 29 +++++++++++++++++++---------- 2 files changed, 39 insertions(+), 25 deletions(-) diff --git a/LuaLibs/ProcessMark.lua b/LuaLibs/ProcessMark.lua index a88acfe..328279e 100644 --- a/LuaLibs/ProcessMark.lua +++ b/LuaLibs/ProcessMark.lua @@ -1,7 +1,8 @@ --- ProcessMark.lua by Egaltech s.r.l. 2022/06/07 +-- ProcessMark.lua by Egaltech s.r.l. 2022/12/05 -- Gestione calcolo marcatura per Travi -- 2020/05/28 Tipo di lavorazione passato da Mark a Text. -- 2021/05/03 Aggiunta gestione testa da sotto. +-- 2022/12/05 Aggiunta gestione tipo di lavorazione Text_AT. -- Tabella per definizione modulo local ProcessMark = {} @@ -37,6 +38,12 @@ function ProcessMark.Classify( Proc) end -- verifico se la marcatura è lavorabile solo da sotto local bDown = (( vtN:getZ() < -0.1)) + -- se da sotto e presente rinvio angolare verifico se c'è opportuna lavorazione + if bDown and BD.ANG_TRASM then + if ML.FindMilling( 'Text_AT') then + bDown = false + end + end return true, bDown end @@ -55,25 +62,25 @@ function ProcessMark.Make( Proc, nPhase, nRawId, nPartId) end -- verifico sia una curva/testo if not vtExtr then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Mark with geometry type not accepted' + local sErr = 'Error : Mark with geometry type not accepted' EgtOutLog( sErr) return false, sErr end -- verifico che la marcatura non sia orientata verso il basso (-5 deg) - if vtExtr:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.TURN then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Mark from bottom impossible' + if vtExtr:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.ANG_TRASM and not BD.TURN then + local sErr = 'Error : Mark from bottom impossible' EgtOutLog( sErr) return false, sErr end -- abilitazione lavorazione da sotto local bMillUp = ( BD.DOWN_HEAD and vtExtr:getZ() > -0.259) local bMillDown = ( BD.DOWN_HEAD and vtExtr:getZ() < 0.174) + local bMillAngTrasm = ( BD.ANG_TRASM and vtExtr:getZ() < -0.1) -- recupero la lavorazione - local sMillType = 'Text' - --local sMchExt = EgtIf( bMillDown, '_H2', '') + local sMillType = EgtIf( not bMillAngTrasm, 'Text', 'Text_AT') local sMilling = ML.FindMilling( sMillType, nil, nil, nil, nil, bMillUp, bMillDown) if not sMilling then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' + local sErr = 'Error : milling not found in library' EgtOutLog( sErr) return false, sErr end @@ -88,11 +95,13 @@ function ProcessMark.Make( Proc, nPhase, nRawId, nPartId) -- aggiungo geometria EgtSetMachiningGeometry( {{ Proc.Id, -1}}) -- imposto posizione braccio porta testa - if vtExtr:getY() <= 0 then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + local nSCC = MCH_SCC.NONE + if bMillAngTrasm then + nSCC = MCH_SCC.ADIR_NEAR else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + nSCC = EgtIf( vtExtr:getY() <= 0, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP) end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) -- eseguo if not ML.ApplyMachining( true, false) then local _, sErr = EgtGetLastMachMgrError() @@ -112,11 +121,7 @@ function ProcessMark.Make( Proc, nPhase, nRawId, nPartId) -- aggiungo geometria EgtSetMachiningGeometry( {{ AuxId, -1}}) -- imposto posizione braccio porta testa - if vtExtr:getY() <= 0 then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) - else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) - end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) -- eseguo if not ML.ApplyMachining( true, false) then local _, sErr = EgtGetLastMachMgrError() diff --git a/LuaLibs/ProcessText.lua b/LuaLibs/ProcessText.lua index 53609aa..c405865 100644 --- a/LuaLibs/ProcessText.lua +++ b/LuaLibs/ProcessText.lua @@ -1,6 +1,7 @@ --- ProcessText.lua by Egaltech s.r.l. 2021/05/03 +-- ProcessText.lua by Egaltech s.r.l. 2022/12/05 -- Gestione calcolo testi per Travi -- 2021/05/03 Aggiunta gestione testa da sotto. +-- 2022/12/05 Aggiunta gestione tipo di lavorazione Text_AT. -- Tabella per definizione modulo local ProcessText = {} @@ -31,6 +32,12 @@ function ProcessText.Classify( Proc) end -- verifico se il testo è lavorabile solo da sotto local bDown = (( vtN:getZ() < -0.1)) + -- se da sotto e presente rinvio angolare verifico se c'è opportuna lavorazione + if bDown and BD.ANG_TRASM then + if ML.FindMilling( 'Text_AT') then + bDown = false + end + end return true, bDown end @@ -41,25 +48,25 @@ function ProcessText.Make( Proc, nPhase, nRawId, nPartId) local vtN = EgtTextNormVersor( Proc.Id, GDB_ID.ROOT) -- verifico sia un testo if not vtN then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Text with geometry type not accepted' + local sErr = 'Error : Text with geometry type not accepted' EgtOutLog( sErr) return false, sErr end -- verifico che il testo non sia orientato verso il basso (-5 deg) - if vtN:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.TURN then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' Text from bottom impossible' + if vtN:getZ() < - 0.1 and not BD.DOWN_HEAD and not BD.ANG_TRASM and not BD.TURN then + local sErr = 'Error : Text from bottom impossible' EgtOutLog( sErr) return false, sErr end -- abilitazione lavorazione da sotto local bMillUp = ( BD.DOWN_HEAD and vtN:getZ() > -0.259) local bMillDown = ( BD.DOWN_HEAD and vtN:getZ() < 0.174) + local bMillAngTrasm = ( BD.ANG_TRASM and vtN:getZ() < -0.1) -- recupero la lavorazione - local sMillType = 'Text' - --local sMchExt = EgtIf( bMillDown, '_H2', '') + local sMillType = EgtIf( not bMillAngTrasm, 'Text', 'Text_AT') local sMilling = ML.FindMilling( sMillType, nil, nil, nil, nil, bMillUp, bMillDown) if not sMilling then - local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library' + local sErr = 'Error : milling not found in library' EgtOutLog( sErr) return false, sErr end @@ -74,11 +81,13 @@ function ProcessText.Make( Proc, nPhase, nRawId, nPartId) -- aggiungo geometria EgtSetMachiningGeometry( {{ Proc.Id, -1}}) -- imposto posizione braccio porta testa - if vtN:getY() <= 0 then - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM) + local nSCC = MCH_SCC.NONE + if bMillAngTrasm then + nSCC = MCH_SCC.ADIR_NEAR else - EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP) + nSCC = EgtIf( vtN:getY() <= 0, MCH_SCC.ADIR_YM, MCH_SCC.ADIR_YP) end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) -- eseguo if not ML.ApplyMachining( true, false) then local _, sErr = EgtGetLastMachMgrError() From 77c7e42e4266e905110b2c376000572947f26917 Mon Sep 17 00:00:00 2001 From: DarioS Date: Mon, 12 Dec 2022 15:33:02 +0100 Subject: [PATCH 21/24] =?UTF-8?q?DataBeam=20:=20-=20in=20Tenon=20corretta?= =?UTF-8?q?=20scelta=20bordo=20vicino=20per=20attacco=20-=20in=20LapJoint?= =?UTF-8?q?=20se=20non=20definito=20BD.MIN=5FLEN=5FLAMELLO=20si=20usa=2010?= =?UTF-8?q?00,=20in=20MachineByMill=20migliorata=20ricerca=20utensile=20e?= =?UTF-8?q?=20corretta=20gestione=20inversione=20in=20funzione=20del=20lat?= =?UTF-8?q?o=20di=20lavoro=20-=20in=20Mortise=20migliorato=20controllo=20n?= =?UTF-8?q?ecessit=C3=A0=20CleanCorners.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LuaLibs/ProcessLapJoint.lua | 18 +++++++++++------- LuaLibs/ProcessMortise.lua | 32 ++++++++++++++++++-------------- LuaLibs/ProcessTenon.lua | 2 +- 3 files changed, 30 insertions(+), 22 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 50d0c03..9c54b49 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -1,4 +1,4 @@ --- ProcessLapJoint.lua by Egaltech s.r.l. 2022/09/27 +-- ProcessLapJoint.lua by Egaltech s.r.l. 2022/12/12 -- Gestione calcolo mezzo-legno per Travi -- 2019/10/08 Agg. gestione OpenPocket. -- 2021/01/24 Con sega a catena ora sempre impostato asse A. @@ -56,6 +56,7 @@ -- Migliorata gestione AntiSplint (Mill e Saw) -- 2022/09/27 Aggiunta gestione SCC per svuotature con TURN (solo dopo applicazione lavorazione). -- 2022/10/20 In MakeByChainOrSaw modificato check per trovare la faccia adiacente sul lato più lungo. +-- 2022/12/12 Default 1000 per BD.MIN_LEN_LAMELLO. In MachineByMill migliorata ricerca utensile e gestione inversione in funzione del lato di lavoro. -- Tabella per definizione modulo local ProcessLapJoint = {} @@ -3246,8 +3247,10 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas local sMilling if nUseRoughTool > 0 then sMilling = ML.FindMilling( 'Long2Cut', nil, sTuuidPk) + if not sMilling then sMilling = ML.FindMilling( 'Long2Cut') end else sMilling = ML.FindMilling( 'LongSmallCut', nil, sTuuidPk) + if not sMilling then sMilling = ML.FindMilling( 'LongSmallCut') end end if not sMilling then local sErr = 'Error : Long2Cut & LongSmallCut not found in library' @@ -3276,8 +3279,9 @@ local function MachineByMill( Proc, nPhase, nRawId, nPartId, b3Solid, tvtN, nBas EgtSetMachiningGeometry( {{ Proc.Id, (nSideFace)}}) -- imposto uso faccia EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse) - -- setto inversione del percorso - EgtSetMachiningParam( MCH_MP.INVERT, true) + -- sistemazione inversione del percorso + local nWrkSide = EgtGetMachiningParam( MCH_MP.WORKSIDE) + EgtSetMachiningParam( MCH_MP.INVERT, ( nWrkSide ~= MCH_MILL_WS.RIGHT)) -- setto a 0 eventuali offset EgtSetMachiningParam( MCH_MP.OFFSR, 0) -- calcolo elevazione per allungamenti attacchi con fianchi chiusi @@ -4936,7 +4940,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa local nFaces = EgtSurfTmFacetCount( nTestId) while not bExit and nFaces >= 3 do local bDeleteFace - nInt = 0 + local nInt = 0 while not bDeleteFace and nInt < nFaces do nInt = nInt + 1 local b3Facet = EgtSurfTmGetFacetBBoxGlob( nTestId, nInt-1, GDB_BB.STANDARD) @@ -4963,9 +4967,9 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa -- cancello la copia del percorso EgtErase( nTestId) - if bNewIsU and ( not BD.MIN_LEN_LAMELLO or - ( Proc.TotBox and Proc.TotBox:getDimX() > BD.MIN_LEN_LAMELLO) or - ( not Proc.TotBox and Proc.Box:getDimX() > BD.MIN_LEN_LAMELLO)) then + if bNewIsU and + (( Proc.TotBox and Proc.TotBox:getDimX() > ( BD.MIN_LEN_LAMELLO or 1000)) or + ( not Proc.TotBox and Proc.Box:getDimX() > ( BD.MIN_LEN_LAMELLO or 1000))) then -- recupero la lavorazione local bDownHead = BD.DOWN_HEAD and vtN:getZ() < BD.NZ_MINA sMillingOnSide = ML.FindMilling( 'SideMillAsBlade_H2', nil, nil, nil, nil, not bDownHead, bDownHead) diff --git a/LuaLibs/ProcessMortise.lua b/LuaLibs/ProcessMortise.lua index 1b8a87d..d321317 100644 --- a/LuaLibs/ProcessMortise.lua +++ b/LuaLibs/ProcessMortise.lua @@ -1,4 +1,4 @@ --- ProcessMortise.lua by Egaltech s.r.l. 2021/12/01 +-- ProcessMortise.lua by Egaltech s.r.l. 2022/12/12 -- Gestione calcolo mortase per Travi -- 2021/07/20 Aggiunta gestione rinvio angolare su FAST. -- 2021/12/01 Se frontale aggiungo taglio con Grp e Proc di vero taglio (per aggiornare ingombro di testa /coda). @@ -6,6 +6,7 @@ -- 2022/07/29 Nella pulitura angoli aggiunto il check dimensioni tasca vs utensile. Corretta direzione utensile per mortasa frontale. -- 2022/09/27 Migliorata la scelta utensile. Se c'è almeno una lavorazione 'mortise' si cerca di usare quelle, riducendo l'elevazione se necessario. -- Se non c'è nemmeno una lavorazione 'mortise' si passa alle pocket. +-- 2022/12/12 Migliorato controllo necessità CleanCorners. -- Tabella per definizione modulo local ProcessMortise = {} @@ -141,20 +142,21 @@ end --------------------------------------------------------------------- -- Pulizia angoli nel caso sia settato il parametro P04=1 local function CleanCorners( Proc, dMorH, vtN, bDoubleDir, AuxId) - -- verifico se è attiva la pulizia e se l'orientamento della feature è adeguato - local bCleanCorners = ( EgtGetInfo( Proc.Id, 'P04', 'i') == 1 and - ( AreSameOrOppositeVectorApprox( vtN, X_AX()) or - AreSameOrOppositeVectorApprox( vtN, Y_AX()) or - AreSameOrOppositeVectorApprox( vtN, Z_AX()))) + -- verifico se l'orientamento della feature è adeguato + local bCleanCorners = ( AreSameOrOppositeVectorApprox( vtN, X_AX()) or + AreSameOrOppositeVectorApprox( vtN, Y_AX()) or + AreSameOrOppositeVectorApprox( vtN, Z_AX())) if not bCleanCorners then - EgtOutLog( 'Warning: mortising not aligned with XYZ axes, corner cleaning skipped') - return + local sWarn = 'Warning: mortising not aligned with XYZ axes, corner cleaning skipped' + EgtOutLog( sWarn) + return true, sWarn end -- cerco la lavorazione adatta local sMortisingCleanCorners = ML.FindSawing( 'Mortising') if not sMortisingCleanCorners then - EgtOutLog( 'Warning: mortising tool not found, corner cleaning skipped') - return + local sWarn = 'Warning: mortising tool not found, corner cleaning skipped' + EgtOutLog( sWarn) + return true, sWarn end -- recupero i dati dell'utensile local dSawWidth = 50 @@ -565,10 +567,12 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH) end end -- verifico se necessaria la pulizia degli angoli ( tenone ad angoli non raggiati) e applico nel caso - local _, sWarn2 = CleanCorners( Proc, dMorH, vtN, bOpenBtm and not bForceOneSide, AuxId) - if sWarn2 then - if not sWarn then sWarn = '' end - sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + if ( EgtGetInfo( Proc.Id, 'P04', 'i') == 1) then + local _, sWarn2 = CleanCorners( Proc, dMorH, vtN, bOpenBtm and not bForceOneSide, AuxId) + if sWarn2 then + if not sWarn then sWarn = '' end + sWarn = EgtIf( #sWarn > 0, sWarn .. '\n' .. sWarn2, sWarn2) + end end return true, sWarn diff --git a/LuaLibs/ProcessTenon.lua b/LuaLibs/ProcessTenon.lua index 7aa3754..fdf59a4 100644 --- a/LuaLibs/ProcessTenon.lua +++ b/LuaLibs/ProcessTenon.lua @@ -226,7 +226,7 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) -- porto inizio curva il più possibile sul bordo in alto o in basso local dMaxDist = OVERLAP_COEFF * dMillDiam * MAX_PASS local bMyShortPart = ( bShortPart and vtN:getX() < 0 and abs( vtN:getX()) < 0.999 and abs( vtN:getY()) < 0.259) - BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, ( bH2 and bMillDown) ~= bMyShortPart) + BL.PutStartNearestToEdge( AuxId, b3Solid, dMaxDist, EgtIf( bH2 and bMillDown, not bMyShortPart, bMyShortPart)) -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente local sWarn local dDepth = 0 From 1b6f8b3be4e2ca192b3d78914b6df0865691f29a Mon Sep 17 00:00:00 2001 From: DarioS Date: Tue, 13 Dec 2022 16:48:48 +0100 Subject: [PATCH 22/24] =?UTF-8?q?DataBeam=20:=20-=20in=20Tenon=20se=20incl?= =?UTF-8?q?inati=20solo=20verticalmente=20e=20macchine=20tipo=20PF=20(BD.P?= =?UTF-8?q?RESS=5FROLLER)=20si=20riduce=20l'ingombro=20di=20testa=20o=20co?= =?UTF-8?q?da=20-=20in=20LapJoint=20con=203=20o=20pi=C3=B9=20facce=20e=20p?= =?UTF-8?q?rincipale=20verso=20il=20basso=20modificato=20criterio=20possib?= =?UTF-8?q?ilit=C3=A0=20di=20lavorare=20su=20seconda=20faccia=20possibile.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LuaLibs/ProcessLapJoint.lua | 23 ++++++++--------------- LuaLibs/ProcessTenon.lua | 7 ++++--- 2 files changed, 12 insertions(+), 18 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 9c54b49..17fbf70 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -710,16 +710,10 @@ function ProcessLapJoint.Classify( Proc, b3Raw) else -- dati della faccia local rfFac, dH, dV = EgtSurfTmFacetMinAreaRectangle( Proc.Id, nFacInd, GDB_ID.ROOT) - local nFac2Ind = EgtIf( nFacInd ~= 0, 0, 1) - local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFac2Ind, GDB_ID.ROOT) - if abs( rfFac:getVersY() * vtN2) < 0.5 then - dH, dV = dV, dH - rfFac:rotate( rfFac:getOrigin(), rfFac:getVersZ(), 90) - end + local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) -- se può essere fatto con utensile tipo lama local bUseBHSideMill, _, _, _, _, dTDiam = VerifyBHSideMill( Proc) if bUseBHSideMill then - local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) if vtN:getZ() > -0.5 or b3Raw:getDimZ() - Proc.Box:getDimZ() < ( BD.MAX_DIST_BH_FROM_BOTTOM or 395) - dTDiam / 2 then return true, false else @@ -727,8 +721,6 @@ function ProcessLapJoint.Classify( Proc, b3Raw) end -- altrimenti controllo se deve essere ruotato con le altre lavorazioni else - -- dati della faccia - local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, nFacInd, GDB_ID.ROOT) -- cerco se c'è faccia adiacente sul lato più lungo local nFaceAdj = GetFaceAdj( Proc, nFacInd, dH, dV) or -1 local bIsL = ( Proc.Fct == 2 or TestElleShape3( Proc) or TestElleShape4( Proc) == 2) @@ -738,23 +730,24 @@ function ProcessLapJoint.Classify( Proc, b3Raw) if bDown then local bIsU = ( Proc.Fct == 3 and not TestElleShape3( Proc)) -- se forzata la lavorazione con fresa di lato da parametro Q03=2/3 non devo ruotare - local bForceSideMill = ( ( EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 2 or EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') == 3) and ( Proc.Fct == 3 or Proc.Fct == 4)) + local nSideRoughTool = EgtGetInfo( Proc.Id, Q_SIDE_ROUGH_TOOL, 'd') + local bForceSideMill = ( ( nSideRoughTool == 2 or nSideRoughTool == 3) and ( Proc.Fct == 3 or Proc.Fct == 4)) if bForceSideMill then bDown = false - elseif nFacInd2 and dElev2 < 2 * dElev then - local ptC2, vtN2 = EgtSurfTmFacetCenter( Proc.Id, nFacInd2, GDB_ID.ROOT) + elseif nFacInd2 and dElev2 < 160 and dElev2 < 2 * dElev then + local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd2, GDB_ID.ROOT) bDown = ( vtN2:getZ() < BD.NZ_MINB) elseif not nFacInd2 and bIsL and nFaceAdj >= 0 then - local ptC2, vtN2 = EgtSurfTmFacetCenter( Proc.Id, nFaceAdj, GDB_ID.ROOT) + local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFaceAdj, GDB_ID.ROOT) bDown = ( vtN2:getZ() < BD.NZ_MINB) end -- verifico se la faccia principale è sottosquadra, ha forma L ed esiste la faccia adiacente elseif vtN:getZ() < -0.2589 and bIsL and nFaceAdj >= 0 then -- box del pezzo local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) - -- se il numero di facce > 2 o il box della feature supera una certa distanza dalle teste allora controllo la z della faccia ausiiaria + -- se più di 2 facce o il box della feature supera una certa distanza dalle teste allora controllo Nz della faccia ausiiaria if Proc.Fct > 2 or ( Proc.Box:getMax():getX() < b3Solid:getMin():getX() - 150) or ( Proc.Box:getMin():getX() > b3Solid:getMax():getX() + 150) then - local ptC2, vtN2 = EgtSurfTmFacetCenter( Proc.Id, nFaceAdj, GDB_ID.ROOT) + local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, nFaceAdj, GDB_ID.ROOT) bDown = ( vtN2:getZ() < BD.NZ_MINB) end end diff --git a/LuaLibs/ProcessTenon.lua b/LuaLibs/ProcessTenon.lua index fdf59a4..93acbd4 100644 --- a/LuaLibs/ProcessTenon.lua +++ b/LuaLibs/ProcessTenon.lua @@ -1,4 +1,4 @@ --- ProcessTenon.lua by Egaltech s.r.l. 2022/11/03 +-- ProcessTenon.lua by Egaltech s.r.l. 2022/12/12 -- Gestione calcolo tenone per Travi -- 2021/10/04 Corretto calcolo HCING per pezzi piccoli. -- 2022/02/15 Aggiornata VerifyOrientation per macchine con testa da sotto. @@ -6,6 +6,7 @@ -- 2022/05/28 Spostato calcolo svuotatura in modulo di libreria. -- 2022/09/20 Migliorato il calcolo delle passate laterali; ora considera la reale distanza tra contorno del tenone e estremi della faccia -- 2022/11/03 Corretto uso di bH2 (da sotto solo se anche bMillDown vero). +-- 2022/12/12 Su macchine con rulli pressori e pinze separate si riduce di meno l'ingombro con tenoni inclinati. -- Tabella per definizione modulo local ProcessTenon = {} @@ -287,7 +288,7 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) local dOffs = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX() local dDelta = 0 if abs( vtN:getY()) < 0.1 and vtN:getZ() > 0.5 then - dDelta = - 0.5 * dOffs + dDelta = - EgtIf( BD.PRESS_ROLLER, 0.7, 0.5) * dOffs end if bShortPart and b3Raw:getDimZ() < BD.VICE_MINH and abs( vtN:getZ()) > 0.575 then local b3Base = EgtSurfTmGetFacetBBoxGlob( Proc.Id, 0, GDB_BB.STANDARD) @@ -298,7 +299,7 @@ function ProcessTenon.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) elseif Proc.Tail then local dOffs = Proc.Box:getMax():getX() - b3Solid:getMin():getX() if abs( vtN:getY()) < 0.1 and vtN:getZ() > 0.5 then - dOffs = 0.5 * dOffs + dOffs = EgtIf( BD.PRESS_ROLLER, 0.3, 0.5) * dOffs end BL.UpdateTCING( nRawId, dOffs) end From 478945252343a4f045282c455a2f0c0152d194fe Mon Sep 17 00:00:00 2001 From: DarioS Date: Wed, 14 Dec 2022 11:18:33 +0100 Subject: [PATCH 23/24] DataBeam : - Corrette rotazioni 90 deg per macchine con carico da destra. --- LuaLibs/BeamExec.lua | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index d003a51..b15c420 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -1,4 +1,4 @@ --- BeamExec.lua by Egaltech s.r.l. 2022/09/28 +-- BeamExec.lua by Egaltech s.r.l. 2022/12/23 -- Libreria esecuzione lavorazioni per Travi -- 2019/07/11 Aggiunta gestione stato rotazione di feature per TS3. -- 2019/09/04 Corretto controllo feature di testa e coda con sovramateriale di testa elevato. @@ -37,6 +37,7 @@ -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata. -- 2022/09/28 I fori vengono sempre fatti prima delle tacche. -- 2022/09/29 Aggiunta la ricerca di feature specchiate, al momento solo per DtMortise, con le relative funzioni. +-- 2022/12/23 Corrette rotazioni 90 deg per macchine con carico da destra. -- Tabella per definizione modulo @@ -1658,7 +1659,7 @@ function BeamExec.ProcessFeatures() sDownOrSideOrStd = 'SIDE' -- vettore movimento grezzi per rotazione di 90deg local dDeltaYZ = EgtGetRawPartBBox( nRawId):getDimY() - EgtGetRawPartBBox( nRawId):getDimZ() - local vtMove = Vector3d( 0, dDeltaYZ / 2, dDeltaYZ / 2) + local vtMove = Vector3d( 0, dDeltaYZ / 2 * EgtIf( BD.RIGHT_LOAD, -1, 1), dDeltaYZ / 2) local bPreMove = ( dDeltaYZ < 0) -- ruoto le travi della fase corrente local nRId = nRawId From 63d9d24e3081344027d141ad8e8c1ea934320a6d Mon Sep 17 00:00:00 2001 From: DarioS Date: Wed, 14 Dec 2022 12:36:34 +0100 Subject: [PATCH 24/24] DataBeam : - aggiunti messaggi minimo grezzo scaricabile in Process. --- Process.lua | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Process.lua b/Process.lua index 396666c..65c66fd 100644 --- a/Process.lua +++ b/Process.lua @@ -144,10 +144,11 @@ local function MyProcessBeams() end dTotLen = dTotLen + max( vBeam[#vBeam].Box:getDimX(), BD.MinRaw) local dAddLen = BD.OVM_HEAD + ( #vBeam - 1) * BD.OVM_MID - EgtOutLog( 'Ltot : ' .. EgtNumToString( dTotLen, 1) .. ' Lagg : '.. EgtNumToString( dAddLen, 1), 1) + EgtOutLog( 'Ltot : '..EgtNumToString( dTotLen, 1) .. ' Lagg : '..EgtNumToString( dAddLen, 1)..' MinUnloadRaw : '.. EgtNumToString( BD.MinRaw + BD.OVM_MID, 1), 1) -- Richiedo lunghezza del grezzo e sovramateriale di testa - local vsVal = EgtDialogBox( 'Lavora Travi' .. ' (Ltot='.. EgtNumToString( dTotLen + dAddLen + 0.5, 0) .. ', Lmax=' .. EgtNumToString( BD.MAX_RAW, 0) .. ')', + local vsVal = EgtDialogBox( 'Lavora Travi' .. ' (Ltot='..EgtNumToString( dTotLen + dAddLen + 0.5, 0).. + ', Lmax='..EgtNumToString( BD.MAX_RAW, 0)..',MinUlr='..EgtNumToString( BD.MinRaw + BD.OVM_MID, 0)..')', {'Lunghezza grezzo', EgtNumToString( BD.STD_RAW, 0)}, {'Sovramateriale di testa', EgtNumToString( BD.OVM_HEAD, 0)}, {'Forza sezione verticale', ' CB:true,*false'})