Egalware/DataWall
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
develop
DataWall/LuaLibs/Squaring.lua
T

494 lines
22 KiB
Lua
Raw Permalink Blame History

-- Squaring.lua by Egaltech s.r.l. 2024/10/15
-- Libreria squadratura pareti
-- Tabella per definizione modulo
local Squaring = {}
-- Include
require( 'EgtBase')
EgtOutLog( ' Squaring started', 1)
-- Dati
local WD = require( 'WallData')
local WM = require( 'WMachiningLib')
-------------------------------------------------------------------------------------------------------------
local function IsToolOk( Tool, dRawPartHeight)
local bIsToolOk = false
local bToolExists = false
local bToolCanReachDepth = false
local dMaxOvermaterial = 0
if type( WD.SQUARING_MAX_OVERMATERIAL) == "number" then
dMaxOvermaterial = WD.SQUARING_MAX_OVERMATERIAL
end
bToolExists = ( next( Tool) ~= nil)
if bToolExists then
if Tool.nType == MCH_TY.MILL_NOTIP then
bToolCanReachDepth = ( Tool.dThickness > dMaxOvermaterial - 10 * GEO.EPS_SMALL)
and ( Tool.dSideDepth > dRawPartHeight - 10 * GEO.EPS_SMALL)
else
bToolCanReachDepth = Tool.dMaxDepth > dRawPartHeight - 10 * GEO.EPS_SMALL
end
end
bIsToolOk = bToolExists and bToolCanReachDepth
return bIsToolOk
end
-------------------------------------------------------------------------------------------------------------
function Squaring.GetTools()
-- TODO vedere se questo valore è coerente sulle diverse macchine
local dHeadEncumberance = 130
local Tool = {}
local SquaringTools = {}
SquaringTools.Blade = {}
SquaringTools.Diskmill = {}
SquaringTools.Mill = {}
SquaringTools.Blade.H1 = {}
SquaringTools.Blade.H2 = {}
SquaringTools.Blade.H7 = {}
SquaringTools.Diskmill.H1 = {}
SquaringTools.Diskmill.H7 = {}
SquaringTools.Mill.H1 = {}
SquaringTools.Mill.H7 = {}
Tool.sName = EgtTdbGetFirstTool( MCH_TF.SAWBLADE + MCH_TF.MILL + MCH_TF.MORTISE)
while Tool.sName ~= '' do
EgtTdbSetCurrTool( Tool.sName)
local bIsToolLoadedOnSetup = EgtFindToolInCurrSetup( Tool.sName)
local bIsSquaringTool = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SQUARING', 'b') or false
Tool.nType = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
Tool.dDiameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
Tool.dMaxMaterial = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
Tool.dThickness = EgtIf( ( Tool.nType == MCH_TY.SAW_FLAT or Tool.nType == MCH_TY.SAW_STD), EgtTdbGetCurrToolParam( MCH_TP.THICK), Tool.dMaxMaterial)
Tool.dMaxDepth = EgtTdbGetCurrToolMaxDepth() or Tool.dMaxMaterial
Tool.sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
Tool.bIsCcw = EgtTdbGetCurrToolParam( MCH_TP.SPEED) < 0
Tool.dFeed = EgtTdbGetCurrToolParam( MCH_TP.FEED)
Tool.dStartFeed = EgtTdbGetCurrToolParam( MCH_TP.STARTFEED)
Tool.dEndFeed = EgtTdbGetCurrToolParam( MCH_TP.ENDFEED)
Tool.dTipFeed = EgtTdbGetCurrToolParam( MCH_TP.TIPFEED)
Tool.dMinFeed = EgtTdbGetCurrToolParam( MCH_TP.MINFEED)
Tool.dStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'STEP', 'd') or EgtIf( ( Tool.nType == MCH_TY.SAW_FLAT or Tool.nType == MCH_TY.SAW_STD), ( Tool.dDiameter / 3), ( Tool.dMaxMaterial / 3))
Tool.dSideStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDESTEP', 'd') or ( Tool.dDiameter / 3)
Tool.dSideDepth = Tool.dDiameter / 2 - dHeadEncumberance
if bIsToolLoadedOnSetup and Tool.nType and bIsSquaringTool then
-- lame
if Tool.nType == MCH_TY.SAW_FLAT or Tool.nType == MCH_TY.SAW_STD then
SquaringTools.Blade[Tool.sHead] = Tool
Tool.bIsPathCw = Tool.bIsCcw
Tool.dSideStep = Tool.dStep
Tool.dStep = Tool.dThickness
-- frese standard
elseif Tool.nType == MCH_TY.MILL_STD then
SquaringTools.Mill[Tool.sHead] = Tool
Tool.bIsPathCw = not Tool.bIsCcw
-- truciolatori
elseif Tool.nType == MCH_TY.MILL_NOTIP then
SquaringTools.Diskmill[Tool.sHead] = Tool
Tool.bIsPathCw = Tool.bIsCcw
end
end
Tool = {}
Tool.sName = EgtTdbGetNextTool( MCH_TF.SAWBLADE + MCH_TF.MILL + MCH_TF.MORTISE)
end
return SquaringTools
end
-------------------------------------------------------------------------------------------------------------
function Squaring.AreToolsOk( sSquaringTool, SquaringTools, dRawPartHeight)
local bAreToolsOk = false
if sSquaringTool == 'DoubleDiskmill' then
bAreToolsOk = ( IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
and IsToolOk( SquaringTools.Diskmill.H1, dRawPartHeight)
and IsToolOk( SquaringTools.Diskmill.H7, dRawPartHeight))
elseif sSquaringTool == 'DoubleDiskmillAndBlade' then
bAreToolsOk = ( IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
and ( IsToolOk( SquaringTools.Diskmill.H1, dRawPartHeight) or IsToolOk( SquaringTools.Diskmill.H7, dRawPartHeight)))
elseif sSquaringTool == 'DoubleBlade' then
bAreToolsOk = ( IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
and ( IsToolOk( SquaringTools.Blade.H1, dRawPartHeight) or IsToolOk( SquaringTools.Blade.H7, dRawPartHeight)))
elseif sSquaringTool == 'Diskmill' then
bAreToolsOk = IsToolOk( SquaringTools.Diskmill.H1, dRawPartHeight) or IsToolOk( SquaringTools.Diskmill.H7, dRawPartHeight)
elseif sSquaringTool == 'Blade' then
bAreToolsOk = IsToolOk( SquaringTools.Blade.H2, dRawPartHeight)
elseif sSquaringTool == 'DoubleMill' then
bAreToolsOk = IsToolOk( SquaringTools.Mill.H1, dRawPartHeight) and IsToolOk( SquaringTools.Mill.H7, dRawPartHeight)
elseif sSquaringTool == 'Mill' then
bAreToolsOk = IsToolOk( SquaringTools.Mill.H1, dRawPartHeight) or IsToolOk( SquaringTools.Mill.H7, dRawPartHeight)
else
error( 'Squaring Tool not recognized')
end
return bAreToolsOk
end
-------------------------------------------------------------------------------------------------------------
function Squaring.CalculateParameters( sSquaringTool, SquaringTools, RawPart, vPart)
local SquaringParameters = {}
local sOrigCorner = EgtGetInfo( RawPart.nId, 'ORIGCORNER')
local bShrinkToParts = ( WD.SQUARING_TYPE == 2)
local bSquaringStartsOnReference = ( type( WD.SQUARING_STARTS_ON_REFERENCE) == "boolean") and ( WD.SQUARING_STARTS_ON_REFERENCE == true)
local dOffsetXY = 0
local dExtendZ = 0
if type( WD.SQUARING_OFFSET_XY) == "number" and ( WD.SQUARING_TYPE < 2) then
dOffsetXY = WD.SQUARING_OFFSET_XY
end
if type( WD.SQUARING_EXTEND_Z) == "number" then
dExtendZ = WD.SQUARING_EXTEND_Z
end
local Front = { sSide = 'Front'}
local Right = { sSide = 'Right'}
local Back = { sSide = 'Back'}
local Left = { sSide = 'Left'}
local b3Squaring = BBox3d( RawPart.b3)
-- se squadratura sui pezzi invece che sul master panel, si costruisce il box minimo che contiene tutti i pezzi
if bShrinkToParts then
b3Squaring = BBox3d( vPart[1].Box:getCenter())
for i = 1, #vPart do
b3Squaring:Add( vPart[i].Box)
end
end
local dDimX = b3Squaring:getDimX()
local dDimY = b3Squaring:getDimY()
local pt1 = b3Squaring:getMin() + Point3d( -dOffsetXY, -dOffsetXY, -dExtendZ)
local pt2 = pt1 + Point3d( dDimX + 2 * dOffsetXY, 0, 0)
local pt3 = pt2 + Point3d( 0, dDimY + 2 * dOffsetXY,0 )
local pt4 = pt3 + Point3d( -dDimX - 2 * dOffsetXY, 0, 0)
b3Squaring:Add( pt1)
b3Squaring:Add( pt2)
b3Squaring:Add( pt3)
b3Squaring:Add( pt4)
Front.nId = EgtLine( RawPart.nId, pt1, pt2, GDB_RT.GLOB)
Right.nId = EgtLine( RawPart.nId, pt2, pt3, GDB_RT.GLOB)
Back.nId = EgtLine( RawPart.nId, pt3, pt4, GDB_RT.GLOB)
Left.nId = EgtLine( RawPart.nId, pt4, pt1, GDB_RT.GLOB)
if not ( sSquaringTool == 'DoubleMill') and not ( sSquaringTool == 'Mill') then
EgtModifyCurveExtrusion( Front.nId, -Y_AX(), GDB_RT.GLOB)
EgtModifyCurveExtrusion( Right.nId, X_AX(), GDB_RT.GLOB)
EgtModifyCurveExtrusion( Back.nId, Y_AX(), GDB_RT.GLOB)
EgtModifyCurveExtrusion( Left.nId, -X_AX(), GDB_RT.GLOB)
end
EgtSetName( Front.nId, 'SquaringGeometry')
EgtSetName( Right.nId, 'SquaringGeometry')
EgtSetName( Back.nId, 'SquaringGeometry')
EgtSetName( Left.nId, 'SquaringGeometry')
-- in base al caso si assegna l'utensile al lato
if sSquaringTool == 'DoubleDiskmill' then
Left.Tool = SquaringTools.Diskmill.H1
Right.Tool = SquaringTools.Blade.H2
Front.Tool = SquaringTools.Diskmill.H1
Front.ToolDouble = SquaringTools.Diskmill.H7
Front.sSide = 'Front+Back'
elseif sSquaringTool == 'DoubleDiskmillAndBlade' then
Left.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
Right.Tool = SquaringTools.Blade.H2
Front.Tool = SquaringTools.Blade.H2
Front.ToolDouble = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
Front.sSide = 'Front+Back'
elseif sSquaringTool == 'DoubleBlade' then
Left.Tool = SquaringTools.Blade.H2
Right.Tool = SquaringTools.Blade.H2
Front.Tool = SquaringTools.Blade.H2
Front.ToolDouble = SquaringTools.Blade.H1 or SquaringTools.Blade.H7
Front.sSide = 'Front+Back'
elseif sSquaringTool == 'Diskmill' then
Left.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
Back.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
Right.Tool = SquaringTools.Blade.H2
Front.Tool = SquaringTools.Diskmill.H1 or SquaringTools.Diskmill.H7
elseif sSquaringTool == 'Blade' then
Left.Tool = SquaringTools.Blade.H2
Back.Tool = SquaringTools.Blade.H2
Right.Tool = SquaringTools.Blade.H2
Front.Tool = SquaringTools.Blade.H2
elseif sSquaringTool == 'DoubleMill' then
Left.Tool = SquaringTools.Mill.H1
Right.Tool = SquaringTools.Mill.H1
Front.Tool = SquaringTools.Mill.H1
Front.ToolDouble = SquaringTools.Mill.H7
Front.sSide = 'Front+Back'
elseif sSquaringTool == 'Mill' then
Left.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
Back.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
Right.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
Front.Tool = SquaringTools.Mill.H1 or SquaringTools.Mill.H7
end
-- l'ordinamento delle linee dipende dal verso di percorrenza e, se attivato, dal riferimento utilizzato
-- con doppio l'ordine cambia
-- lato lungo lavorato in doppio
if not Back.Tool then
for i = 1, 3 do
SquaringParameters[i] = {}
end
if Front.Tool.bIsPathCw then
if bSquaringStartsOnReference and ( sOrigCorner == 'BL' or sOrigCorner == 'BM') then
SquaringParameters[1] = Front
SquaringParameters[2] = Left
SquaringParameters[3] = Right
elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
SquaringParameters[1] = Right
SquaringParameters[2] = Front
SquaringParameters[3] = Left
elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
SquaringParameters[1] = Right
SquaringParameters[2] = Front
SquaringParameters[3] = Left
elseif bSquaringStartsOnReference and ( sOrigCorner == 'TL' or sOrigCorner == 'TM') then
SquaringParameters[1] = Left
SquaringParameters[2] = Front
SquaringParameters[3] = Right
else
SquaringParameters[1] = Right
SquaringParameters[2] = Front
SquaringParameters[3] = Left
end
else
if bSquaringStartsOnReference and ( sOrigCorner == 'BL' or sOrigCorner == 'BM') then
SquaringParameters[1] = Left
SquaringParameters[2] = Front
SquaringParameters[3] = Right
elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
SquaringParameters[1] = Front
SquaringParameters[2] = Right
SquaringParameters[3] = Left
elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
SquaringParameters[1] = Front
SquaringParameters[2] = Right
SquaringParameters[3] = Left
elseif bSquaringStartsOnReference and ( sOrigCorner == 'TL' or sOrigCorner == 'TM') then
SquaringParameters[1] = Left
SquaringParameters[2] = Front
SquaringParameters[3] = Right
else
SquaringParameters[1] = Left
SquaringParameters[2] = Front
SquaringParameters[3] = Right
end
end
-- doppio non attivo
else
for i = 1, 4 do
SquaringParameters[i] = {}
end
if Front.Tool.bIsPathCw then
if bSquaringStartsOnReference and ( sOrigCorner == 'BL' or sOrigCorner == 'BM') then
SquaringParameters[1] = Front
SquaringParameters[2] = Left
SquaringParameters[3] = Back
SquaringParameters[4] = Right
elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
SquaringParameters[1] = Back
SquaringParameters[2] = Right
SquaringParameters[3] = Front
SquaringParameters[4] = Left
elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
SquaringParameters[1] = Right
SquaringParameters[2] = Front
SquaringParameters[3] = Left
SquaringParameters[4] = Back
else
SquaringParameters[1] = Left
SquaringParameters[2] = Back
SquaringParameters[3] = Right
SquaringParameters[4] = Front
end
else
if bSquaringStartsOnReference and ( sOrigCorner == 'TL' or sOrigCorner == 'TM') then
SquaringParameters[1] = Back
SquaringParameters[2] = Left
SquaringParameters[3] = Front
SquaringParameters[4] = Right
elseif bSquaringStartsOnReference and ( sOrigCorner == 'TR' or sOrigCorner == 'TN') then
SquaringParameters[1] = Right
SquaringParameters[2] = Back
SquaringParameters[3] = Left
SquaringParameters[4] = Front
elseif bSquaringStartsOnReference and ( sOrigCorner == 'BR' or sOrigCorner == 'BN') then
SquaringParameters[1] = Front
SquaringParameters[2] = Right
SquaringParameters[3] = Back
SquaringParameters[4] = Left
else
SquaringParameters[1] = Left
SquaringParameters[2] = Front
SquaringParameters[3] = Right
SquaringParameters[4] = Back
end
end
end
return SquaringParameters, b3Squaring
end
-------------------------------------------------------------------------------------------------------------
function Squaring.AddMachinings( SquaringParameters, b3Squaring, nFirstOperationId)
local nNotOkCount = 0
local sMsgTotal = ''
local dSquaringHeight = b3Squaring:getDimZ()
local dExtendPath = 0
local dMaxOvermaterial = 0
if type( WD.SQUARING_MAX_OVERMATERIAL) == "number" then
dMaxOvermaterial = WD.SQUARING_MAX_OVERMATERIAL
end
local bUseZigZagStep = ( type( WD.SQUARING_USE_ZIGZAG) == "boolean") and ( WD.SQUARING_USE_ZIGZAG == true)
for i = 1, #SquaringParameters do
local dToolRadius = SquaringParameters[i].Tool.dDiameter / 2
local vtExtr = EgtCurveExtrusion( SquaringParameters[i].nId, GDB_RT.GLOB)
local bIsVerticalMilling = false
if AreSameVectorApprox( vtExtr, Z_AX()) then
bIsVerticalMilling = true
end
-- calcolo step laterale
local MachiningSteps = { nCount = 1, dStep = 0}
if not bIsVerticalMilling then
MachiningSteps = WM.GetMachiningSteps( dSquaringHeight, SquaringParameters[i].Tool.dSideStep)
end
for j = 1, MachiningSteps.nCount do
local nOperationId = EgtCreateMachining( 'SQUARING_' .. SquaringParameters[i].sSide, MCH_OY.MILLING, SquaringParameters[i].Tool.sName)
-- geometria
EgtSetMachiningGeometry( SquaringParameters[i].nId)
-- profondità di lavoro
EgtSetMachiningParam( MCH_MP.DEPTH_STR, 0)
-- workside e inversione
if SquaringParameters[i].Tool.bIsPathCw then
if SquaringParameters[i].Tool.nType == MCH_TY.MILL_STD then
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
else
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
end
EgtSetMachiningParam( MCH_MP.INVERT, true)
else
if SquaringParameters[i].Tool.nType == MCH_TY.MILL_STD then
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
else
EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
end
EgtSetMachiningParam( MCH_MP.INVERT, false)
end
-- distanza di sicurezza
if bIsVerticalMilling then
EgtSetMachiningParam( MCH_MP.STARTPOS, WD.CUT_SIC + dSquaringHeight)
else
EgtSetMachiningParam( MCH_MP.STARTPOS, WD.CUT_SIC)
end
-- overlap
EgtSetMachiningParam( MCH_MP.OVERL, 0)
-- tipo di step
if bIsVerticalMilling and bUseZigZagStep then
EgtSetMachiningParam( MCH_MP.STEPTYPE, MCH_MILL_ST.ZIGZAG)
else
EgtSetMachiningParam( MCH_MP.STEPTYPE, MCH_MILL_ST.ONEWAY)
end
-- step
if bIsVerticalMilling then
EgtSetMachiningParam( MCH_MP.STEP, SquaringParameters[i].Tool.dStep)
else
EgtSetMachiningParam( MCH_MP.STEP, 0)
end
-- offset radiale
local dRadialOffset = 0
if not bIsVerticalMilling then
dRadialOffset = ( MachiningSteps.nCount - j) * MachiningSteps.dStep
end
EgtSetMachiningParam( MCH_MP.OFFSR, dRadialOffset)
-- offset longitudinale
EgtSetMachiningParam( MCH_MP.OFFSL, 0)
-- inversione utensile
EgtSetMachiningParam( MCH_MP.TOOLINVERT, false)
-- faceuse
EgtSetMachiningParam( MCH_MP.FACEUSE, MCH_MILL_FU.NONE)
-- angoli suggeriti
EgtSetMachiningParam( MCH_MP.INITANGS, '')
-- asse bloccato
EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, '')
-- SCC
EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.NONE)
-- calcolo estensione percorso
if bIsVerticalMilling then
-- per utensili che lavorano di fianco, si deve partire fuori dall'altezza del grezzo
dExtendPath = dMaxOvermaterial + dToolRadius + WD.COLL_SIC
else
-- si calcola l'impronta utensile per uscire quanto basta a garantire il maxOvermaterial, con una distanza di sicurezza
dExtendPath = dMaxOvermaterial + WD.COLL_SIC + dToolRadius - ( dToolRadius - sqrt( dToolRadius * dToolRadius - ( ( dToolRadius - dSquaringHeight) * ( dToolRadius - dSquaringHeight))))
end
-- approccio
EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dExtendPath)
EgtSetMachiningParam( MCH_MP.LITANG, 0)
if bIsVerticalMilling then
EgtSetMachiningParam( MCH_MP.LIPERP, 0)
else
-- per utensili che lavorano di fianco, si deve partire fuori dall'altezza del grezzo
EgtSetMachiningParam( MCH_MP.LIPERP, WD.CUT_SIC + dSquaringHeight)
end
EgtSetMachiningParam( MCH_MP.LIELEV, 0)
EgtSetMachiningParam( MCH_MP.LICOMPLEN, 0)
-- retrazione
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LO.LINEAR)
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dExtendPath)
EgtSetMachiningParam( MCH_MP.LOTANG, 0)
if bIsVerticalMilling then
EgtSetMachiningParam( MCH_MP.LOPERP, 0)
else
-- per utensili che lavorano di fianco, si deve partire fuori dall'altezza del grezzo
EgtSetMachiningParam( MCH_MP.LOPERP, WD.CUT_SIC + dSquaringHeight)
end
EgtSetMachiningParam( MCH_MP.LOELEV, 0)
EgtSetMachiningParam( MCH_MP.LOCOMPLEN, 0)
-- note utente
local sUserNotes = ''
sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
if SquaringParameters[i].ToolDouble then
local dYMirrorAx
local b3Tab = EgtGetTableArea()
dYMirrorAx = b3Squaring:getCenter():getY() - b3Tab:getMin():getY()
sUserNotes = EgtSetValInNotes( sUserNotes, 'DOUBLE', 2)
sUserNotes = EgtSetValInNotes( sUserNotes, 'MirrorAx', dYMirrorAx)
sUserNotes = EgtSetValInNotes( sUserNotes, 'TOOLDOUBLE', SquaringParameters[i].ToolDouble.sName)
end
if not bIsVerticalMilling then
sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', 0)
end
EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
local bOk = EgtApplyMachining( true, false)
-- la squadratura va sempre prima delle eventuali altre lavorazioni
if nFirstOperationId then
EgtRelocateGlob( nOperationId, nFirstOperationId, GDB_IN.BEFORE)
end
if not bOk then
local _, sMsg = EgtGetLastMachMgrError()
nNotOkCount = nNotOkCount + 1
sMsgTotal = sMsgTotal ..'\n' .. ( sMsg or '')
end
end
end
return ( nNotOkCount < 1), sMsgTotal
end
-------------------------------------------------------------------------------------------------------------
function Squaring.AddScrapRemoval( nFirstOperationId)
-- pulizia sfridi alla prima lavorazione dopo la squadratura
EgtSetCurrMachining( nFirstOperationId)
local sMachiningNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
sMachiningNotes = sMachiningNotes .. 'ScrapRemove=1;'
EgtSetMachiningParam( MCH_MP.USERNOTES, sMachiningNotes)
end
-------------------------------------------------------------------------------------------------------------
return Squaring
Reference in New Issue View Git Blame Copy Permalink