luca.mazzoleni
40e76a23c9
- in MachiningLib in GetSplitMachinings correzioni alla definizione dello stage della lavorazione; correzione a FindBlade - in SLOTBYBLADE e SLOTBYCHAINSAW correzioni per poter passare la profondità di lavoro - in STR0005 primo implemento di lavorazione con codolo
217 lines
9.2 KiB
Lua
217 lines
9.2 KiB
Lua
-- Strategia: STR0005
|
|
-- Descrizione
|
|
-- lama per taglio facce con cubetti se necessario
|
|
-- Feature: tagli singoli con eventuali cubetti
|
|
|
|
-- carico librerie
|
|
local BeamLib = require( 'BeamLib')
|
|
local BeamData = require( 'BeamData')
|
|
local MachiningLib = require( 'MachiningLib')
|
|
local FeatureLib = require( 'FeatureLib')
|
|
-- strategie di base
|
|
local BladeToWaste = require( 'BLADETOWASTE')
|
|
local SlotByBlade = require( 'SLOTBYBLADE')
|
|
|
|
-- Tabella per definizione modulo
|
|
local STR0005 = {}
|
|
local Strategy = {}
|
|
local Blade = {}
|
|
Blade.Result = {}
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function CompareEdges( EdgeA, EdgeB)
|
|
-- prima i lati orientati lungo X
|
|
if abs( EdgeA.vtToolDirection:getX()) < abs( EdgeB.vtToolDirection:getX()) - 10 * GEO.EPS_SMALL then
|
|
return true
|
|
elseif abs( EdgeA.vtToolDirection:getX()) > abs( EdgeB.vtToolDirection:getX()) + 10 * GEO.EPS_SMALL then
|
|
return false
|
|
-- se stessa X si preferiscono i lati più in basso
|
|
else
|
|
if EdgeA.vtToolDirection:getZ() > EdgeB.vtToolDirection:getZ() + 10 * GEO.EPS_SMALL then
|
|
return true
|
|
elseif EdgeA.vtToolDirection:getZ() < EdgeB.vtToolDirection:getZ() - 10 * GEO.EPS_SMALL then
|
|
return false
|
|
-- se stessa Z si preferiscono i lati verso il fronte della trave
|
|
else
|
|
if EdgeA.vtToolDirection:getY() > EdgeB.vtToolDirection:getY() + 10 * GEO.EPS_SMALL then
|
|
return true
|
|
elseif EdgeA.vtToolDirection:getY() < EdgeB.vtToolDirection:getY() - 10 * GEO.EPS_SMALL then
|
|
return false
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
function Blade.AddResult( Cutting)
|
|
table.insert( Blade.Result, Cutting)
|
|
|
|
return Blade.Result
|
|
end
|
|
|
|
|
|
function Blade.AddMachiningAllSteps( Proc, Cutting, AuxiliaryData)
|
|
local bMachiningAdded = false
|
|
if not AuxiliaryData then
|
|
AuxiliaryData = {}
|
|
end
|
|
AuxiliaryData.Clones = {}
|
|
|
|
local dOriginalRadialOffset = Cutting.dRadialOffset
|
|
local dOriginalLeadInPerpDistance = Cutting.LeadIn.dPerpDistance
|
|
local dOriginalLeadOutPerpDistance = Cutting.LeadOut.dPerpDistance
|
|
for i = 1, Cutting.HorizontalSteps.nCount do
|
|
AuxiliaryData.Clones[i] = {}
|
|
AuxiliaryData.Clones[i].LeadIn = {}
|
|
AuxiliaryData.Clones[i].LeadOut = {}
|
|
AuxiliaryData.Clones[i].dRadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.dStep * ( Cutting.HorizontalSteps.nCount - i)
|
|
-- update distanza perpendicolare attacco per contemplare l'offset applicato
|
|
AuxiliaryData.Clones[i].LeadIn.dPerpDistance = dOriginalLeadInPerpDistance - Cutting.dRadialOffset
|
|
AuxiliaryData.Clones[i].LeadOut.dPerpDistance = dOriginalLeadOutPerpDistance - Cutting.dRadialOffset
|
|
end
|
|
bMachiningAdded = MachiningLib.AddNewMachining( Proc, Cutting, AuxiliaryData)
|
|
|
|
return bMachiningAdded
|
|
end
|
|
|
|
|
|
function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
|
|
-- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
|
|
local StrategyLib = {}
|
|
StrategyLib.Config = require( 'STR0005\\STR0005Config')
|
|
Strategy.sName = StrategyLib.Config.sStrategyId
|
|
CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
|
|
Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
|
|
Strategy.Result = {}
|
|
Strategy.Result.sInfo = ''
|
|
Blade.Result = {}
|
|
|
|
local dExtendAfterTail = Strategy.Parameters.dExtendAfterTail or max( Part.dDistanceToNextPiece - BeamData.CUT_EXTRA, 0)
|
|
if MachiningLib.CanExtendAfterTail( Strategy.Parameters.sCanDamageNextPiece, Part) then
|
|
dExtendAfterTail = 10000
|
|
end
|
|
|
|
local dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail = FeatureLib.GetFeatureMaxNotClampableLengths( Proc, Part)
|
|
local bLeaveWasteAttached = Strategy.Parameters.sCuttingStrategy == 'LEAVE_WASTE_ATTACHED'
|
|
local bFeatureHindersClamping = FeatureLib.IsMachiningLong( max( dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
|
|
local Cutting = {}
|
|
local MRRParametersBlade = {}
|
|
|
|
if bFeatureHindersClamping or bLeaveWasteAttached then
|
|
-- TODO Lavorazione con codolo
|
|
-- La FaceByBlade (o altra??) dovrà accettare opzionalmente di fermarsi prima (basta l'Offset??) e accettare l'utensile forzato.
|
|
-- attenzione perchè se l'inclinazione della faccia la fa finire oltre lo spigolo questo riduce il massimo calcolare (come calcolare????)
|
|
-- il FindBlade dovrà restituire di utilizzare sempre la lama sopra se l'angolo lo permette, ma avendo un'altezza massima (da macchina) oltre cui il DownUp non sarà fattibile (evita collisioni tra asse e pezzo)
|
|
--Cutting = FaceByBlade.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
|
|
--Cutting.AddResult( Cutting)
|
|
|
|
-- si trovano i lati da lavorare
|
|
local EdgesSorted = {}
|
|
for i = 1, #Proc.Faces[1].Edges do
|
|
table.insert( EdgesSorted, Proc.Faces[1].Edges[i])
|
|
end
|
|
table.sort( EdgesSorted, CompareEdges)
|
|
|
|
local dDepthToMachine = abs( EdgesSorted[1].dElevation) / 2 - Strategy.Parameters.dStripWidth / 2
|
|
|
|
-- ricerca utensile
|
|
local ToolSearchParameters = {}
|
|
ToolSearchParameters.dElevation = dDepthToMachine
|
|
ToolSearchParameters.vtToolDirection = EdgesSorted[1].vtToolDirection
|
|
ToolSearchParameters.bAllowTopHead = true
|
|
ToolSearchParameters.bAllowBottomHead = true
|
|
ToolSearchParameters.bForceLongcutBlade = bForceLongcutBlade
|
|
local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
|
|
Cutting.nToolIndex = ToolInfo.nToolIndex
|
|
Cutting.nType = MCH_OY.MILLING
|
|
if not TOOLS[Cutting.nToolIndex].sName then
|
|
Cutting.sMessage = 'Blade not found'
|
|
Cutting.bIsApplicable = false
|
|
EgtOutLog( Cutting.sMessage)
|
|
return Cutting, abs( EdgesSorted[1].dElevation)
|
|
end
|
|
|
|
-- parametri per il calcolo della velocità di asportazione
|
|
MRRParametersBlade = {
|
|
dStep = min( TOOLS[Cutting.nToolIndex].dStep, abs( EdgesSorted[1].dElevation)),
|
|
dSideStep = TOOLS[Cutting.nToolIndex].dThickness,
|
|
dFeed = TOOLS[Cutting.nToolIndex].Feeds.dFeed
|
|
}
|
|
|
|
-- eventuali punti di spezzatura
|
|
local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
|
|
local bIsSplitFeature = false
|
|
if #FeatureSplittingPoints then
|
|
bIsSplitFeature = true
|
|
end
|
|
|
|
-- primo lato
|
|
local OptionalParameters = { dDepthToMachine = dDepthToMachine, nToolIndex = Cutting.nToolIndex, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail}
|
|
Cutting = SlotByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[1], OptionalParameters)
|
|
Blade.AddResult( Cutting)
|
|
-- secondo lato
|
|
Cutting = SlotByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[2], OptionalParameters)
|
|
--Blade.AddResult( Cutting)
|
|
|
|
-- lavorazioni raggruppate in unica lista
|
|
Blade.Result.Sorted = {}
|
|
for i = 1, #Blade.Result do
|
|
if Blade.Result[i].bIsApplicable then
|
|
table.insert( Blade.Result.Sorted, Blade.Result[i])
|
|
end
|
|
end
|
|
|
|
-- aggiunta eventuali lavorazioni splittate
|
|
if bIsSplitFeature then
|
|
Blade.Result.Sorted = MachiningLib.GetSplitMachinings( Blade.Result.Sorted, FeatureSplittingPoints, Part)
|
|
end
|
|
|
|
-- TODO ordinamento lavorazioni (se necessario)
|
|
|
|
-- se la lavorazione con codolo fallisce o non è possibile si proseguirà a quella con cubetti
|
|
end
|
|
|
|
if #Blade.Result == 0 and not bLeaveWasteAttached then
|
|
-- BladeToWaste
|
|
end
|
|
|
|
-- aggiunta lavorazioni
|
|
local nIsApplicableCount = 0
|
|
local dFinalCompletionPercentage = 100
|
|
local bAreAllMachiningsAdded = true
|
|
for i = 1, #Blade.Result.Sorted do
|
|
if Blade.Result.Sorted[i].bIsApplicable then
|
|
nIsApplicableCount = nIsApplicableCount + 1
|
|
if bAddMachining then
|
|
local bIsMachiningAdded = Blade.AddMachiningAllSteps( Proc, Blade.Result.Sorted[i])
|
|
if not bIsMachiningAdded then
|
|
bAreAllMachiningsAdded = false
|
|
end
|
|
end
|
|
Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Blade.Result.Sorted[i].sMessage
|
|
end
|
|
end
|
|
if nIsApplicableCount > 0 then
|
|
if Cutting.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
|
|
Strategy.Result.sStatus = 'Completed'
|
|
else
|
|
Strategy.Result.sStatus = 'Not-Completed'
|
|
-- TODO al momento si assume che la percentuale di completamento dell'ultima lavorazione sia quella rilevante
|
|
dFinalCompletionPercentage = Cutting.dCompletionPercentage
|
|
end
|
|
else
|
|
Strategy.Result.sStatus = 'Not-Applicable'
|
|
end
|
|
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dFinalCompletionPercentage)
|
|
Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
|
|
local dMRRBlade = MachiningLib.GetToolMRR( MRRParametersBlade)
|
|
Strategy.Result.dMRR = dMRRBlade
|
|
|
|
return bAreAllMachiningsAdded, Strategy.Result
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
|
|
return STR0005 |