luca.mazzoleni
917bf5ec4b
- in ProcessDtTenon correzione in scelta testa - in MakeAntiSplintBySaw se non si trova adiacenza tra le facce si restituisce errore
508 lines
25 KiB
Lua
508 lines
25 KiB
Lua
-- MachiningLib.lua by Egaltech s.r.l. 2023/11/06
|
|
-- Libreria ricerca lavorazioni per Travi
|
|
-- 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.
|
|
-- 2022/12/28 Per FindMilling e FindDrilling possibilità di escludere la testa H2 dalla ricerca utensile.
|
|
-- 2023/01/31 Per FindPocketing implementata la possibilità di escludere le teste H2 o H3 dalla ricerca utensile.
|
|
-- 2023/07/28 Aggiunta gestione del tipo di foratura "Drill_AT".
|
|
-- 2023/11/06 Migliorie e correzioni alle forature con AngularTransmission ("_AT").
|
|
-- 2024/01/18 In FindSawing aggiunto il parametro opzionale dDepth.
|
|
-- 2024/01/19 In FindSawing aggiunto parametro opzionale bConsiderCSimmEncumberance per considerare l'ingombro dell'asse C nel massimo materiale (default false).
|
|
-- 2024/01/23 Nella GetMachinings vengono ora raccolti i parametri utensile necessari per i VerifyTool, scritti direttamente nella tabella Machining.Tool.
|
|
-- Le lavorazioni possono essere ora ordinate per dimensioni utensile (Longest, Shortest, Biggest, Smallest) se passato l'apposito parametro SortingCriterion in FindMachining. Al momento implementato solo per FindSawing.
|
|
-- 2024/03/01 In VerifyPocketing implementato l'ordinamento per dimensioni utensile.
|
|
-- 2024/03/13 Aggiunta gestione Predrill
|
|
|
|
-- Tabella per definizione modulo
|
|
local MachiningLib = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
|
|
EgtOutLog( ' MachiningLib started', 1)
|
|
|
|
-- Dati
|
|
local BD = require( 'BeamData')
|
|
local Cuttings = require( 'CutData')
|
|
local Millings = require( 'MillingData')
|
|
local Pocketings = require( 'PocketingData')
|
|
local Sawings = require( 'SawingData')
|
|
local Drillings = require( 'DrillData')
|
|
|
|
-- tipo di teste macchina
|
|
local ONE_HEAD = 1 -- una testa (Fast, One, Turn1T)
|
|
local TWO_EQUAL_HEADS = 2 -- due teste uguali (PF, Turn)
|
|
local TWO_UP_DOWN_HEADS = 3 -- due teste una sopra l'altra sotto (PF1250)
|
|
local MachineHeadType = 0
|
|
|
|
-- testa correntementa attiva, e utensili correnti per ogni testa
|
|
local nActiveHead = 0
|
|
local H1_TOOL = ''
|
|
local H2_TOOL = ''
|
|
|
|
-- testa e utensile della lavorazione restituita ma non ancora confermata
|
|
local nNextMachHead = 0
|
|
local H1_NEXT_TOOL = ''
|
|
local H2_NEXT_TOOL = ''
|
|
|
|
-- teste con utensili fissi
|
|
local vFixedHeads = {}
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che imposta il tipo di macchina corrente
|
|
local function SetCurrMachineHeadType()
|
|
-- se già inizializzato, esco
|
|
if MachineHeadType and MachineHeadType >= 1 and MachineHeadType <= 3 then return end
|
|
-- altrimenti, lo imposto
|
|
if BD.DOWN_HEAD then
|
|
MachineHeadType = TWO_UP_DOWN_HEADS
|
|
elseif BD.TWO_EQUAL_HEADS then
|
|
MachineHeadType = TWO_EQUAL_HEADS
|
|
else
|
|
MachineHeadType = ONE_HEAD
|
|
end
|
|
-- imposto eventuali teste con utensili fissi
|
|
if BD.C_SIMM then
|
|
vFixedHeads = { [31] = true}
|
|
elseif BD.TURN then
|
|
vFixedHeads = { [12] = true, [22] = true}
|
|
else -- FAST
|
|
vFixedHeads = { [2] = true}
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- setta ultimi testa e utensile utilizzati se compatibili con ottimizzazione testa
|
|
local function ConfirmNextMachining()
|
|
-- utensile corrente
|
|
local sToolUuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
local sToolName = EgtTdbGetToolFromUUID( sToolUuid or '')
|
|
EgtTdbSetCurrTool( sToolName or '')
|
|
-- testa dell'utensile corrente
|
|
local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
local nHead = tonumber( sHead:sub( 2, #sHead)) + 0
|
|
|
|
if ( nHead < 10 and nHead >= 30) or vFixedHeads[nHead] then
|
|
-- testa che non richiede ottimizzazione
|
|
return
|
|
elseif nHead >= 20 then
|
|
nHead = 2
|
|
elseif nHead >= 10 then
|
|
nHead = 1
|
|
end
|
|
|
|
-- se la testa richiede ottimizzazione, confermo testa attiva
|
|
nActiveHead = nHead
|
|
if nActiveHead == 1 then
|
|
H1_TOOL = sToolName
|
|
elseif nActiveHead == 2 then
|
|
H2_TOOL = sToolName
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function SetCurrMachiningAndTool( Machining)
|
|
EgtMdbSetCurrMachining( Machining.Name)
|
|
EgtTdbSetCurrTool( Machining.Tool.Name)
|
|
local bActive = EgtFindToolInCurrSetup( Machining.Tool.Name)
|
|
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, Machining.Tool.Name, bH2, bFixed, bH3
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyDrill( Machining, dDiam, dDepth, bH2)
|
|
local dFreeLen = Machining.Tool.Length - Machining.Tool.ToolHolderLength - EgtMdbGetGeneralParam( MCH_GP.MAXDEPTHSAFE)
|
|
if Machining.Tool.Diameter < dDiam + 10 * GEO.EPS_SMALL and
|
|
Machining.Tool.Diameter > dDiam - BD.DRILL_TOL - 10 * GEO.EPS_SMALL and
|
|
( not dDepth or Machining.Tool.MaxMat > dDepth - GEO.EPS_SMALL) then
|
|
return true, { TMaxMat = Machining.Tool.MaxMat, MaxToolLength = Machining.Tool.TotalLength, ToolDiam = Machining.Tool.Diameter, DiamTh = Machining.Tool.ToolHolderDiameter, FreeLen = dFreeLen, H2 = bH2}
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyDrillPocket( Machining, dDiam, dDepth, bH2)
|
|
if Machining.Tool.Diameter < dDiam - 10 * GEO.EPS_SMALL and
|
|
( not dDepth or Machining.Tool.MaxMat > dDepth - GEO.EPS_SMALL) then
|
|
return true, { TMaxDepth = Machining.Tool.MaxMat, MaxToolLength = Machining.Tool.TotalLength, ToolDiam = Machining.Tool.Diameter, DiamTh = Machining.Tool.ToolHolderDiameter, FreeLen = Machining.Tool.MaxMat, H2 = bH2}
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyMill( Machining, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bH2)
|
|
if ( not dDepth or Machining.Tool.MaxMat > dDepth - GEO.EPS_SMALL) and
|
|
( not sTuuidMstr or sTuuidMstr == Machining.Tool.UUID) and
|
|
( not dMaxDiam or Machining.Tool.Diameter < dMaxDiam + GEO.EPS_SMALL) and
|
|
( not dMaxTotLen or Machining.Tool.TotalLength < dMaxTotLen + GEO.EPS_SMALL) then
|
|
return true, { TMaxDepth = Machining.Tool.MaxMat, TDiam = Machining.Tool.Diameter, H2 = bH2}
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyPocket( Machining, dMaxDiam, dDepth, dMaxTotLen, bH2)
|
|
if ( not dMaxDiam or Machining.Tool.Diameter < dMaxDiam + GEO.EPS_SMALL) and
|
|
( not dDepth or Machining.Tool.MaxMat > dDepth - GEO.EPS_SMALL) and
|
|
( not dMaxTotLen or Machining.Tool.TotalLength < dMaxTotLen + GEO.EPS_SMALL) then
|
|
return true, { TDiam = Machining.Tool.Diameter, TMaxDepth = Machining.Tool.MaxMat, H2 = bH2}
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyChainSaw( Machining, dDepth, CSimmEncumberance, bH2)
|
|
-- riduco il massimo materiale dell'ingombro asse C. Se non richiesto, arriverà un valore di CSimmEncumberance nullo
|
|
Machining.Tool.MaxMat = min( Machining.Tool.MaxMat, Machining.Tool.TotalLength - CSimmEncumberance)
|
|
if not dDepth or Machining.Tool.MaxMat > dDepth - GEO.EPS_SMALL then
|
|
return true, { H2 = bH2}
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyTool( Machining, MachiningType, Params, bH2)
|
|
if MachiningType == MCH_MY.DRILLING then
|
|
if Machining.SubType == 'Drill' or Machining.SubType == 'AngleDrill' or Machining.SubType == 'Predrill' then
|
|
return VerifyDrill( Machining, Params.Diam, Params.Depth, bH2)
|
|
elseif Machining.SubType == 'DrillPocket' then
|
|
return VerifyDrillPocket( Machining, Params.Diam, Params.Depth, bH2)
|
|
end
|
|
elseif MachiningType == MCH_MY.SAWING then
|
|
return true, { H2 = bH2}
|
|
elseif MachiningType == MCH_MY.MILLING then
|
|
return VerifyMill( Machining, Params.Depth, Params.TuuidMstr, Params.MaxDiam, Params.MaxTotLen, bH2)
|
|
elseif MachiningType == MCH_MY.POCKETING then
|
|
return VerifyPocket( Machining, Params.MaxDiam, Params.Depth, Params.MaxTotLen, bH2)
|
|
elseif MachiningType == MCH_MY.MORTISING then
|
|
return VerifyChainSaw( Machining, Params.Depth, Params.CSimmEncumberance, bH2)
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetMachinings( MachiningType, sType)
|
|
local Machinings
|
|
-- leggo le lavorazioni disponibili
|
|
if MachiningType == MCH_MY.DRILLING then
|
|
Machinings = Drillings
|
|
elseif MachiningType == MCH_MY.SAWING then
|
|
Machinings = Cuttings
|
|
elseif MachiningType == MCH_MY.MILLING then
|
|
Machinings = Millings
|
|
elseif MachiningType == MCH_MY.POCKETING then
|
|
Machinings = Pocketings
|
|
elseif MachiningType == MCH_MY.MORTISING then
|
|
Machinings = Sawings
|
|
end
|
|
-- scrivo i parametri utensile nella lavorazione
|
|
local validMachinings = {}
|
|
for i = 1, #Machinings do
|
|
local Machining = Machinings[i]
|
|
if EgtMdbSetCurrMachining( Machining.Name) then
|
|
Machining.Tool = {}
|
|
Machining.Tool.UUID = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
Machining.Tool.Name = EgtTdbGetToolFromUUID( Machining.Tool.UUID)
|
|
if Machining.Tool.Name then
|
|
if EgtTdbSetCurrTool( Machining.Tool.Name) then
|
|
table.insert( validMachinings, Machining)
|
|
if ( MachiningType == MCH_MY.MILLING) or ( MachiningType == MCH_MY.POCKETING) or ( MachiningType == MCH_MY.DRILLING and EgtStartsWith( sType, 'Pocket')) then
|
|
Machining.Tool.MaxMat = EgtTdbGetCurrToolMaxDepth()
|
|
else
|
|
Machining.Tool.MaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
|
|
end
|
|
if MachiningType == MCH_MY.DRILLING then
|
|
if EgtStartsWith( Machining.Type, 'Drill') then
|
|
Machining.SubType = 'Drill'
|
|
elseif EgtStartsWith( Machining.Type, 'AngleDrill') then
|
|
Machining.SubType = 'AngleDrill'
|
|
elseif EgtStartsWith( Machining.Type, 'Pocket') then
|
|
Machining.SubType = 'DrillPocket'
|
|
elseif EgtStartsWith( Machining.Type, 'Predrill') then
|
|
Machining.SubType = 'Predrill'
|
|
end
|
|
end
|
|
Machining.Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
|
Machining.Tool.Length = EgtTdbGetCurrToolParam( MCH_TP.LEN)
|
|
Machining.Tool.TotalLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
|
Machining.Tool.ToolHolderDiameter = EgtTdbGetCurrToolThDiam()
|
|
Machining.Tool.ToolHolderLength = EgtTdbGetCurrToolThLength() or 72
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- ritorno la lista delle sole lavorazioni valide
|
|
return validMachinings
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
---restituisce la lista delle lavorazioni ordinata secondo il criterio *sCriterion*
|
|
---@param Machinings table lista della lavorazioni da riordinare
|
|
---@param sCriterion string criterio di ordinamento ('Longest', 'Shortest', 'Biggest', 'Smallest')
|
|
function ReorderMachinings( Machinings, sCriterion)
|
|
|
|
-- funzioni di ordinamento
|
|
local function SortMachiningsByLongestTool( Machining1, Machining2)
|
|
if Machining1.Tool.MaxMat > Machining2.Tool.MaxMat + 10 * GEO.EPS_SMALL then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
local function SortMachiningsByShortestTool( Machining1, Machining2)
|
|
if Machining1.Tool.MaxMat < Machining2.Tool.MaxMat - 10 * GEO.EPS_SMALL then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
local function SortMachiningsByBiggestTool( Machining1, Machining2)
|
|
if Machining1.Tool.Diameter > Machining2.Tool.Diameter + 10 * GEO.EPS_SMALL then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
local function SortMachiningsBySmallestTool( Machining1, Machining2)
|
|
if Machining1.Tool.Diameter < Machining2.Tool.Diameter - 10 * GEO.EPS_SMALL then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- ordinamento in base al criterio
|
|
-- ordine di default, ossia quello che arriva dal database
|
|
if not sCriterion then
|
|
return
|
|
-- prima gli utensili più lunghi
|
|
elseif sCriterion == 'Longest' then
|
|
table.sort( Machinings, SortMachiningsByLongestTool)
|
|
-- prima gli utensili più corti
|
|
elseif sCriterion == 'Shortest' then
|
|
table.sort( Machinings, SortMachiningsByShortestTool)
|
|
-- prima gli utensili con diametro più grande
|
|
elseif sCriterion == 'Biggest' then
|
|
table.sort( Machinings, SortMachiningsByBiggestTool)
|
|
-- prima gli utensili con diametro più piccolo
|
|
elseif sCriterion == 'Smallest' then
|
|
table.sort( Machinings, SortMachiningsBySmallestTool)
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function ReturnParams( MachiningType, MachiningName, sType, ToolParams)
|
|
if MachiningType == MCH_MY.DRILLING then
|
|
local _, sOrigType = EgtEndsWith( sType, '_H2')
|
|
return MachiningName, sType, EgtIf( sOrigType == 'Drill' or sOrigType == 'Drill_AT' or sOrigType == 'AngleDrill' or sOrigType == 'Predrill' , ToolParams.TMaxMat, ToolParams.TMaxDepth), ToolParams.MaxToolLength, ToolParams.ToolDiam, ToolParams.DiamTh, ToolParams.FreeLen
|
|
elseif MachiningType == MCH_MY.SAWING then
|
|
return MachiningName, ToolParams.H2
|
|
elseif MachiningType == MCH_MY.MILLING then
|
|
return MachiningName, ToolParams.TMaxDepth, ToolParams.TDiam, ToolParams.H2
|
|
elseif MachiningType == MCH_MY.POCKETING then
|
|
return MachiningName, ToolParams.TDiam, ToolParams.TMaxDepth, ToolParams.H2
|
|
elseif MachiningType == MCH_MY.MORTISING then
|
|
return MachiningName
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead, bExcludeH2, bExcludeH3, sSortingCriterion)
|
|
if bTopHead == nil and bDownHead == nil then
|
|
bTopHead = true
|
|
bDownHead = false
|
|
elseif bTopHead == nil then
|
|
bTopHead = not bDownHead
|
|
elseif bDownHead == nil then
|
|
bDownHead = not bTopHead
|
|
end
|
|
if bExcludeH2 == nil then
|
|
bExcludeH2 = false
|
|
end
|
|
if bExcludeH3 == nil then
|
|
bExcludeH3 = false
|
|
end
|
|
SetCurrMachineHeadType()
|
|
-- verifico se non richiesta testa sopra e macchina ha solo teste sopra
|
|
if not bTopHead and MachineHeadType ~= TWO_UP_DOWN_HEADS and not BD.TURN then
|
|
return nil
|
|
end
|
|
-- verifico se testa attiva va bene
|
|
local sH1Mach = ''
|
|
local sH1Tool = ''
|
|
local sH1Param
|
|
local sH2Mach = ''
|
|
local sH2Tool = ''
|
|
local sH2Param
|
|
local Machinings = GetMachinings( MachiningType, sType)
|
|
ReorderMachinings( Machinings, sSortingCriterion)
|
|
local ForStart = 1
|
|
local ForEnd = #Machinings
|
|
local ForStep = 1
|
|
-- le forature vanno scorse dal diametro maggiore al minore
|
|
if MachiningType == MCH_MY.DRILLING then
|
|
ForStart = #Machinings
|
|
ForEnd = 1
|
|
ForStep = -1
|
|
end
|
|
if ( BEAM and BEAM.BW) or MachineHeadType == ONE_HEAD or MachineHeadType == TWO_EQUAL_HEADS or ( MachineHeadType == TWO_UP_DOWN_HEADS and not bDownHead) then
|
|
_, sType = EgtEndsWith( sType, '_H2')
|
|
elseif not ( BEAM and BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and not bTopHead and bDownHead then
|
|
if not EgtEndsWith( sType, '_H2') then
|
|
sType = sType .. '_H2'
|
|
end
|
|
end
|
|
local MachineHeadUse = MachineHeadType
|
|
if not ( BEAM and BEAM.BW) and MachineHeadUse == TWO_EQUAL_HEADS then
|
|
MachineHeadUse = ONE_HEAD
|
|
end
|
|
if MachineHeadUse == TWO_UP_DOWN_HEADS and bTopHead and bDownHead then
|
|
-- se posso usare entrambe le teste, la gestisco come una macchina a due teste da sopra
|
|
MachineHeadUse = TWO_EQUAL_HEADS
|
|
end
|
|
-- variabile che definisce quando un utensile ha un diametro sostanzialmente più grande di un altro
|
|
local dBiggerToolTolerance = 1.25
|
|
for i = ForStart, ForEnd, ForStep do
|
|
local Machining = Machinings[i]
|
|
local sMachiningType = Machining.Type
|
|
if ( BEAM and BEAM.BW) or MachineHeadUse == TWO_EQUAL_HEADS then
|
|
_, sMachiningType = EgtEndsWith( Machining.Type, '_H2')
|
|
end
|
|
-- recupero dati utensile
|
|
local bToolActive, sToolName, bH2, bFixed, bH3 = SetCurrMachiningAndTool( Machining)
|
|
if Machining.On and sMachiningType == sType and bToolActive and ( not bH2 or bH2 == not bExcludeH2) and ( not bH3 or bH3 == not bExcludeH3) then
|
|
local bOk, ToolParams = VerifyTool( Machining, MachiningType, Params, bH2)
|
|
if bOk then
|
|
if MachineHeadUse == ONE_HEAD then
|
|
return ReturnParams(MachiningType, Machining.Name, Machining.Type, ToolParams)
|
|
elseif MachineHeadUse == TWO_EQUAL_HEADS then
|
|
-- se nessuna testa attiva, prendo la prima lavorazione disponibile
|
|
if nActiveHead == 0 then
|
|
return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
|
|
-- verifico se posso usare lo stesso utensile della testa attiva
|
|
elseif ( nActiveHead == 1 and not bH2 and sToolName == H1_TOOL) or ( nActiveHead == 2 and bH2 and sToolName == H2_TOOL) then
|
|
-- se l'utensile sulla testa attiva è molto più piccolo rispetto a quelli salvati non lo scelgo, a meno che non siano entrambi grandi (truciolatori)
|
|
if ( not sH1Param or not sH1Param.TDiam or ( sH1Param.TDiam < 75 and ToolParams.TDiam < 75 and sH1Param.TDiam < dBiggerToolTolerance * ToolParams.TDiam)) and ( not sH2Param or not sH2Param.TDiam or ( sH2Param.TDiam < 75 and ToolParams.TDiam < 75 and sH2Param.TDiam < 1.25 * ToolParams.TDiam)) then
|
|
return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
|
|
end
|
|
end
|
|
-- segno le lavorazioni disponibili per entrambe le teste
|
|
if bH2 then
|
|
if not sH2Mach or sH2Mach == '' then
|
|
sH2Mach = Machining.Name
|
|
sH2Tool = sToolName
|
|
sH2Param = ToolParams
|
|
end
|
|
else
|
|
if not sH1Mach or sH1Mach == '' then
|
|
sH1Mach = Machining.Name
|
|
sH1Tool = sToolName
|
|
sH1Param = ToolParams
|
|
end
|
|
end
|
|
elseif MachineHeadUse == TWO_UP_DOWN_HEADS then
|
|
if bTopHead and not bH2 then
|
|
return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
|
|
elseif bDownHead and bH2 then
|
|
return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if MachineHeadUse == TWO_EQUAL_HEADS then
|
|
-- se entrambi gli utensili sono piccoli (no truciolatori) e uno dei due è molto più grande dell'altro scelgo quello senza fare altre analisi
|
|
if sH1Mach ~= "" and sH1Param.TDiam and sH2Mach ~= "" and sH2Param.TDiam then
|
|
if sH1Param.TDiam < 75 or sH2Param.TDiam < 75 then
|
|
if sH1Param.TDiam > dBiggerToolTolerance * sH2Param.TDiam then
|
|
return ReturnParams( MachiningType, sH1Mach, sType, sH1Param)
|
|
elseif sH2Param.TDiam > dBiggerToolTolerance * sH1Param.TDiam then
|
|
return ReturnParams( MachiningType, sH2Mach, sType, sH2Param)
|
|
end
|
|
end
|
|
end
|
|
-- verifico se cambiare testa o cambiare utensile su quella corrente
|
|
if nActiveHead == 1 then
|
|
if sH2Mach ~= "" then
|
|
return ReturnParams( MachiningType, sH2Mach, sType, sH2Param)
|
|
--return sH2Mach, sH2Param.Type, sH2Param.TMaxMat, sH2Param.MaxToolLength, sH2Param.ToolDiam, sH2Param.DiamTh, sH2Param.FreeLen
|
|
elseif sH1Mach ~= "" then
|
|
return ReturnParams( MachiningType, sH1Mach, sType, sH1Param)
|
|
--return sH1Mach, sH1Param.Type, sH1Param.TMaxMat, sH1Param.MaxToolLength, sH1Param.ToolDiam, sH1Param.DiamTh, sH1Param.FreeLen
|
|
end
|
|
elseif nActiveHead == 2 then
|
|
if sH1Mach ~= "" then
|
|
return ReturnParams( MachiningType, sH1Mach, sType, sH1Param)
|
|
--return sH1Mach, sH1Param.Type, sH1Param.TMaxMat, sH1Param.MaxToolLength, sH1Param.ToolDiam, sH1Param.DiamTh, sH1Param.FreeLen
|
|
elseif sH2Mach ~= "" then
|
|
return ReturnParams( MachiningType, sH2Mach, sType, sH2Param)
|
|
--return sH2Mach, sH2Param.Type, sH2Param.TMaxMat, sH2Param.MaxToolLength, sH2Param.ToolDiam, sH2Param.DiamTh, sH2Param.FreeLen
|
|
end
|
|
end
|
|
end
|
|
local bH2, sOrigType = EgtEndsWith( sType, '_H2')
|
|
if ( not BEAM or not BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and bH2 and bTopHead then
|
|
return FindMachining( MachiningType, sOrigType, Params, true, false)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MachiningLib.FindCutting( sType, bTopHead, bDownHead)
|
|
return FindMachining( MCH_MY.SAWING, sType, nil, bTopHead, bDownHead)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MachiningLib.FindDrilling( dDiam, dDepth, bTopHead, bDownHead, bExcludeH2, bAngleTransmission, bIsPredrill)
|
|
local MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5, sTypeMach
|
|
-- se il foro è un predrill, cerco solo punte abilitate al Predrill
|
|
if bIsPredrill then
|
|
sTypeMach = 'Predrill'
|
|
else
|
|
sTypeMach = EgtIf( bAngleTransmission, 'Drill_AT', 'Drill')
|
|
end
|
|
MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, sTypeMach, { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead, bExcludeH2)
|
|
if ( not MachiningName or MachiningName == '') then
|
|
MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, EgtIf( bAngleTransmission, 'Pocket_AT', 'Pocket'), { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead)
|
|
end
|
|
if MachiningName and MachiningName ~= '' then
|
|
return MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MachiningLib.FindAngleDrilling( dDiam, dDepth, bTopHead, bDownHead)
|
|
local MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, 'AngleDrill', { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead)
|
|
if MachiningName and MachiningName ~= '' then
|
|
return MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead, bExcludeH2, bExcludeH3)
|
|
return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH2, bExcludeH3)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MachiningLib.FindPocketing( sType, dMaxDiam, dDepth, dMaxTotLen, bTopHead, bDownHead, bExcludeH2, bExcludeH3, sSortingCriterion)
|
|
return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH2, bExcludeH3, sSortingCriterion)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MachiningLib.FindSawing( sType, dDepth, bConsiderCSimmEncumberance, sSortingCriterion)
|
|
if not BD.C_SIMM_ENC then BD.C_SIMM_ENC = EgtIf( BD.C_SIMM, 180, 90) end
|
|
return FindMachining( MCH_MY.MORTISING, sType, { Depth = dDepth, CSimmEncumberance = EgtIf( bConsiderCSimmEncumberance, BD.C_SIMM_ENC, 0)}, nil, nil, nil, nil, sSortingCriterion)
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function MachiningLib.ApplyMachining( bRecalc, bApplyPost)
|
|
local bResult = EgtApplyMachining( bRecalc, bApplyPost)
|
|
if bResult then ConfirmNextMachining() end
|
|
return bResult
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
return MachiningLib
|