Egalware/egwwindowlua
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Prima versione lavorazione Profiling

Browse Source 
- aggiunta funzione GetAffectedFaces per calcolo facce di riferimento
- Lettura DB Utensili (da sistemare)
- Gestione multipezzo in raccolta e lavorazione feature
- Piccole correzioni varie
This commit is contained in:
andrea.villa
2024-06-20 08:36:46 +02:00
parent 1c00c1224b
commit cc3ac6e186
10 changed files with 187 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CAMAuto/LuaLibs/FeatureData.lua
+23 -2
View File
@@ -20,6 +20,27 @@ function FeatureData.GetDrillingData( Proc)
return Proc
end
-------------------------------------------------------------------------------------------------------------
-- Recupero dati taglio
function FeatureData.GetCuttingData( Proc)
return Proc
end
-------------------------------------------------------------------------------------------------------------
-- Recupero dati foro
function FeatureData.GetPocketingData( Proc)
return Proc
end
-------------------------------------------------------------------------------------------------------------
-- Recupero dati foro
function FeatureData.GetMillingData( Proc)
return Proc
end
-------------------------------------------------------------------------------------------------------------
-- Recupero dati profilatura
function FeatureData.GetProfilingData( Proc)
@@ -29,8 +50,8 @@ function FeatureData.GetProfilingData( Proc)
for t = 1, Proc.nToolsToUse do
local Data = {}
Data.sName = EgtGetInfo( Proc.id, 'TOOL_NAME_' .. tostring(t), 's') or 0
Data.dRadialOvermat = EgtGetInfo( Proc.id, 'OFFR_' .. tostring(t), 'd') or 0
Data.dLongitudinalOvermat = EgtGetInfo( Proc.id, 'OFFL_' .. tostring(t), 'd') or 0
Data.dRadialOffset = EgtGetInfo( Proc.id, 'OFFR_' .. tostring(t), 'd') or 0
Data.dLongitudinalOffset = EgtGetInfo( Proc.id, 'OFFL_' .. tostring(t), 'd') or 0
Data.sSide = EgtGetInfo( Proc.id, 'N', 's') or 0
table.insert( Proc.Tools, Data)
end
CAMAuto/LuaLibs/MachiningLib.lua
+6 -62
View File
@@ -8,57 +8,10 @@ local MachiningLib = {}
require( 'EgtBase')
-- Carico i dati globali
local BeamData = require( 'BeamData')
local WinData = require( 'WinData')
EgtOutLog( ' MachiningLib started', 1)
---------------------------------------------------------------------
-- TODO da considerare solo angolo 2D??
local function GetToolEntryAngle( Proc, vtTool)
local Angle = {}
local dSinAngle = -10 * GEO.EPS_SMALL
local vtNorm
if Proc.AffectedFaces.bTop then
vtNorm = Z_AX()
dSinAngle = max( dSinAngle, vtTool * vtNorm)
end
if Proc.AffectedFaces.bBottom then
vtNorm = -Z_AX()
dSinAngle = max( dSinAngle, vtTool * vtNorm)
end
if Proc.AffectedFaces.bFront then
vtNorm = -Y_AX()
dSinAngle = max( dSinAngle, vtTool * vtNorm)
end
if Proc.AffectedFaces.bBack then
vtNorm = Y_AX()
dSinAngle = max( dSinAngle, vtTool * vtNorm)
end
if Proc.AffectedFaces.bLeft then
vtNorm = -X_AX()
dSinAngle = max( dSinAngle, vtTool * vtNorm)
end
if Proc.AffectedFaces.bRight then
vtNorm = X_AX()
dSinAngle = max( dSinAngle, vtTool * vtNorm)
end
local dCosAngle = sqrt( 1 - sqr( dSinAngle))
local dAngle = acos( dCosAngle)
local dTanAngle
if dAngle ~= 0 and dAngle ~= 90 then
dTanAngle = sqrt( 1 - dCosAngle * dCosAngle) / dCosAngle
end
Angle.dValue = dAngle
Angle.dSin = dSinAngle
Angle.dCos = dCosAngle
Angle.dTan = dTanAngle
return Angle
end
-------------------------------------------------------------------------------------------------------------
-- funzione per cercare utensile tipo FRESA con certe caratteristiche
function MachiningLib.FindMill( Proc, ToolSearchParameters)
@@ -92,19 +45,10 @@ function MachiningLib.FindMill( Proc, ToolSearchParameters)
-- scelgo il migliore
if bIsToolCompatible then
-- calcolo riduzione del massimo materiale utilizzabile
local ToolEntryAngle = GetToolEntryAngle( Proc, ToolSearchParameters.vtToolDirection)
-- se ToolHolder più grande dell'utensile, il primo oggetto in collisione è il ToolHolder. Altrimenti il motore.
local dDimObjToCheck = EgtIf( TOOLS[i].ToolHolder.dDiameter > TOOLS[i].dDiameter, TOOLS[i].ToolHolder.dDiameter, BeamData.C_SIMM_ENC)
local dCurrentMaxMatReduction = BeamData.COLL_SIC or 5
local dDimObjToCheck = EgtIf( TOOLS[i].ToolHolder.dDiameter > TOOLS[i].dDiameter, TOOLS[i].ToolHolder.dDiameter, WinData.C_SIMM_ENC)
local dCurrentMaxMatReduction = WinData.COLL_SIC or 5
-- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
-- TODO considerare anche il caso in cui lo stelo sia più grande del diametro utensile
-- TODO nei confronti tra valori gestire tolleranze
-- calcolo riduzione per non toccare con ToolHolder / Motore
if ToolEntryAngle.dValue > 0 and ToolEntryAngle.dValue < 90 then
dCurrentMaxMatReduction = dCurrentMaxMatReduction / ToolEntryAngle.dSin + ( ( dDimObjToCheck - TOOLS[i].dDiameter) / 2) / ToolEntryAngle.dTan
end
-- dCurrMachReduction = negativo -> limitare, positivo -> mm extra disponibili
local dCurrentResidualDepth = ToolSearchParameters.dElevation + dCurrentMaxMatReduction - TOOLS[i].dMaxDepth
@@ -210,7 +154,7 @@ function MachiningLib.AddNewMachining( ProcToAdd, MachiningToAdd)
end
-- se nome non definito, assegno alla lavorazioen un nome standard
if not MachiningToAdd.sOperationName then
MachiningToAdd.sOperationName = MachiningToAdd.sTypeName .. ( EgtGetName( ProcToAdd.id) or tostring( ProcToAdd.id)) .. '_' .. tostring( MachiningToAdd.Geometry[1][2])
MachiningToAdd.sOperationName = MachiningToAdd.sTypeName .. ( EgtGetName( ProcToAdd.id) or tostring( ProcToAdd.id)) -- TODO serve scrivere faccia? -->> .. '_' .. tostring( MachiningToAdd.Geometry[1][2])
end
if not MachiningToAdd.sToolName then
MachiningToAdd.sToolName = TOOLS[MachiningToAdd.nToolIndex].sName
@@ -244,8 +188,8 @@ function MachiningLib.AddOperations( vProc, Part)
if MACHININGS[i].Machining.bInvert then
EgtSetMachiningParam( MCH_MP.INVERT, MACHININGS[i].Machining.bInvert)
end
if MACHININGS[i].Machining.nWorkside then
EgtSetMachiningParam( MCH_MP.WORKSIDE, MACHININGS[i].Machining.nWorkside)
if MACHININGS[i].Machining.nWorkSide then
EgtSetMachiningParam( MCH_MP.WORKSIDE, MACHININGS[i].Machining.nWorkSide)
end
if MACHININGS[i].Machining.nFaceuse then
EgtSetMachiningParam( MCH_MP.FACEUSE, MACHININGS[i].Machining.nFaceuse)
CAMAuto/LuaLibs/WinExec.lua
+70 -22
View File
@@ -12,6 +12,20 @@ local WinData = require( 'WinData')
local WinLib = require( 'WinLib')
local ID = require( 'Identity')
local FeatureData = require( 'FeatureData')
local MachiningLib = require( 'MachiningLib')
-- carico librerie di lavorazione
_G.package.loaded.Drilling = nil
_G.package.loaded.Cutting = nil
_G.package.loaded.Pocketing = nil
_G.package.loaded.Milling = nil
_G.package.loaded.Profiling = nil
local Drilling = require( 'Drilling')
local Cutting = require( 'Cutting')
local Pocketing = require( 'Pocketing')
local Milling = require( 'Milling')
local Profiling = require( 'Profiling')
EgtOutLog( ' WinExec started', 1)
EgtMdbSave()
@@ -23,7 +37,7 @@ TOOLS = nil
MACHININGS = nil
-------------------------------------------------------------------------------------------------------------
-- *** COSTANTI *** TODO -> DA SPOSTARE IN BEAMDATA???
-- *** COSTANTI *** TODO -> DA SPOSTARE IN WINDATA???
-------------------------------------------------------------------------------------------------------------
TH_DIAMETER_HSK63 = 63
TH_LENGTH_HSK63 = 75
@@ -116,10 +130,10 @@ function WinExec.GetToolsFromDB()
Tool.Feeds.dStartFeed = EgtTdbGetCurrToolParam( MCH_TP.STARTFEED)
Tool.Feeds.dEndFeed = EgtTdbGetCurrToolParam( MCH_TP.ENDFEED)
Tool.Feeds.dTipFeed = EgtTdbGetCurrToolParam( MCH_TP.TIPFEED)
-- TODO serve funzione in BeamData che data la posizione dell'utensile e della testa, capisca il montaggio (testa sopra - testa sotto - aggregato - ecc...)
-- TODO serve funzione in WinData che data la posizione dell'utensile e della testa, capisca il montaggio (testa sopra - testa sotto - aggregato - ecc...)
Tool.sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
Tool.SetupInfo = {}
Tool.SetupInfo = BeamData.GetSetupInfo( Tool.sHead)
Tool.SetupInfo = WinData.GetSetupInfo( Tool.sHead)
Tool.sUUID = EgtTdbGetCurrToolParam( MCH_TP.UUID)
Tool.sUserNotes = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES)
Tool.dMaxDepth = EgtTdbGetCurrToolMaxDepth() or Tool.dMaxMaterial
@@ -187,7 +201,7 @@ end
local function CollectFeatures( Part)
-- recupero le feature
local vProc = {}
local vPartProc = {}
local LayerId = {}
LayerId[1] = WinLib.GetAddGroup( Part.id)
LayerId[2] = EgtGetFirstNameInGroup( Part.id or GDB_ID.NULL, 'Processings')
@@ -207,6 +221,8 @@ local function CollectFeatures( Part)
Proc.sType = sType
Proc.b3Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
Proc.nPhase = EgtGetInfo( ProcId, 'PHASE', 'i') or nil
-- informazioni facce
Proc.AffectedFaces = WinLib.GetAffectedFaces( Proc, Part)
-- se esiste la geometria
if Proc.b3Box and not Proc.b3Box:isEmpty() then
@@ -217,12 +233,15 @@ local function CollectFeatures( Part)
end
-- se taglio
if ID.IsCutting( Proc) then
Proc = FeatureData.GetCuttingData( Proc)
end
-- se fresatura
if ID.IsMilling( Proc) then
Proc = FeatureData.GetMillingData( Proc)
end
-- se svuotatura
if ID.IsPocketing( Proc) then
Proc = FeatureData.GetPocketingData( Proc)
end
-- se profilatura
if ID.IsProfiling( Proc) then
@@ -230,10 +249,10 @@ local function CollectFeatures( Part)
end
-- inserisco feature in lista
table.insert( vProc, Proc)
table.insert( vPartProc, Proc)
else
Proc.nFlg = 0
table.insert( vProc, Proc)
table.insert( vPartProc, Proc)
EgtOutLog( ' Feature ' .. tostring( Proc.idFeature) .. ' is empty (no geometry)')
end
end
@@ -241,7 +260,7 @@ local function CollectFeatures( Part)
ProcId = EgtGetNext( ProcId)
end
end
return vProc
return vPartProc
end
-------------------------------------------------------------------------------------------------------------
@@ -260,6 +279,10 @@ local function GetFeatureInfoAndDependency( vProc, Part)
return vProc
end
-------------------------------------------------------------------------------------------------------------
local function OrderMachining( vProc, PARTS)
end
-------------------------------------------------------------------------------------------------------------
-- Ordina le feature in base a fase di lavorazione
-- L'ordine è indicativamente:
@@ -276,9 +299,6 @@ local function OrderFeatures( vProc)
-- se secondo disabilitato, va lasciato dopo
if B1.nFlg ~= 0 and B2.nFlg == 0 then
return true
-- se entrambi disabilitati seguo l'Id
elseif B1.nFlg == 0 and B2.nFlg == 0 then
return ( B1.id < B2.id)
elseif B1.nPhase and B2.nPhase and B1.nPhase < B2.nPhase then
return true
elseif B1.nPhase and B2.nPhase and B2.nPhase < B1.nPhase then
@@ -316,9 +336,31 @@ end
-------------------------------------------------------------------------------------------------------------
-- applica le lavorazioni
local function AddMachinings( Proc, Part)
-- TODO applicare lavorazioni!!
return Proc
local function AddMachinings( ProcPart, Part)
local bMachiningOk = true
for nFeatureIndex = 1, #ProcPart do
local Proc = ProcPart[nFeatureIndex]
if ID.IsDrilling( Proc) then
bMachiningOk = Drilling.Make( Proc, Part)
end
-- se taglio
if ID.IsCutting( Proc) then
bMachiningOk = Cutting.Make( Proc, Part)
end
-- se fresatura
if ID.IsMilling( Proc) then
bMachiningOk = Milling.Make( Proc, Part)
end
-- se svuotatura
if ID.IsPocketing( Proc) then
bMachiningOk = Pocketing.Make( Proc, Part)
end
-- se profilatura
if ID.IsProfiling( Proc) then
bMachiningOk = Profiling.Make( Proc, Part)
end
end
return bMachiningOk
end
-------------------------------------------------------------------------------------------------------------
@@ -339,36 +381,42 @@ function WinExec.ProcessFeatures( PARTS)
local nOrd = 1
local Part = {}
local vProc = {}
for nPart = 1, #PARTS do
-- lista contenente le feature da eseguire
local vProc = {}
-- recupero le feature di lavorazione della trave
vProc = CollectFeatures( PARTS[nPart])
table.insert( vProc, CollectFeatures( PARTS[nPart]))
-- recupero informazioni ausiliarie feature e dipendenze tra feature stesse
vProc = GetFeatureInfoAndDependency( vProc, PARTS[nPart])
vProc[nPart] = GetFeatureInfoAndDependency( vProc[nPart], PARTS[nPart])
-- debug
if EgtGetDebugLevel() >= 1 then
PrintFeatures( vProc, PARTS[nPart])
PrintFeatures( vProc[nPart], PARTS[nPart])
end
-- ordino le features
vProc = OrderFeatures( vProc)
vProc[nPart] = OrderFeatures( vProc[nPart])
EgtOutLog( ' *** AddMachinings ***', 1)
for i = 1, #vProc do
-- aggiunge le lavorazioni
AddMachinings( vProc[i], PARTS[nPart])
end
-- TODO da fare
MACHININGS = {}
-- esegue le strategie migliori che ha precedentemente scelto e salva le lavorazioni nella lista globale
AddMachinings( vProc[nPart], PARTS[nPart])
EgtOutLog( ' *** End AddMachinings ***', 1)
-- passo al grezzo successivo
nOrd = nOrd + 1
end
OrderMachining( vProc, PARTS)
-- aggiunge effettivamente le lavorazioni
MachiningLib.AddOperations( vProc, PARTS)
-- Aggiornamento finale di tutto
EgtSetCurrPhase( 1)
local bApplOk, sApplErrors, sApplWarns = EgtApplyAllMachinings()
CAMAuto/LuaLibs/WinLib.lua
+28
View File
@@ -10,6 +10,34 @@ local WinData = require( 'WinData')
EgtOutLog( ' WinLib started', 1)
-------------------------------------------------------------------------------------------------------------
-- restituisce le facce della parte interessate dalla feature Proc
function WinLib.GetAffectedFaces( Proc, Part)
local vtFacesAffected = { bTop = false, bBottom = false, bFront = false, bBack = false, bLeft = false, bRight = false}
if Proc.b3Box and not Proc.b3Box:isEmpty() then
if Proc.b3Box:getMax():getZ() > Part.b3Solid:getMax():getZ() - 500 * GEO.EPS_SMALL then
vtFacesAffected.bTop = true
end
if Proc.b3Box:getMin():getZ() < Part.b3Solid:getMin():getZ() + 500 * GEO.EPS_SMALL then
vtFacesAffected.bBottom = true
end
if Proc.b3Box:getMin():getY() < Part.b3Solid:getMin():getY() + 500 * GEO.EPS_SMALL then
vtFacesAffected.bFront = true
end
if Proc.b3Box:getMax():getY() > Part.b3Solid:getMax():getY() - 500 * GEO.EPS_SMALL then
vtFacesAffected.bBack = true
end
if Proc.b3Box:getMin():getX() < Part.b3Solid:getMin():getX() + 500 * GEO.EPS_SMALL then
vtFacesAffected.bLeft = true
end
if Proc.b3Box:getMax():getX() > Part.b3Solid:getMax():getX() - 500 * GEO.EPS_SMALL then
vtFacesAffected.bRight = true
end
end
return vtFacesAffected
end
-------------------------------------------------------------------------------------------------------------
function WinLib.GetAddGroup( PartId)
-- recupero il nome del gruppo di lavoro corrente
CAMAuto/ProcessWin.lua
+6 -1
View File
@@ -41,6 +41,7 @@ _G.package.loaded.WinData = nil
_G.package.loaded.WinExec = nil
_G.package.loaded.WinLib = nil
_G.package.loaded.FeatureData = nil
_G.package.loaded.MachiningLib = nil
-- TODO controllare se c'è un modo migliore per resettare librerie delle strategie caricate precedentemente
-- Per ottimizzare potremmo anche ciclare solo fino al numero di strategie raggiunto per il momento.
@@ -116,7 +117,7 @@ end
-------------------------------------------------------------------------------------------------------------
local function GetDataConfig()
-- recupero utensili dal magazzino
-- WinExec.GetToolsFromDB()
WinExec.GetToolsFromDB()
-- TODO da gestire eventuali errori bloccanti
return true
@@ -296,6 +297,10 @@ local function MyProcessPieces()
-- si dispongono i pezzi sulla tavola
WinData.ExecDisposition( PARTS)
-- Impostazione dell'attrezzaggio di default
-- TODO se lascio il campo vuoto non mi carica il default!!!!!!!
local bOk = EgtImportSetup( 'CIAO')
return true
end
CAMAuto/Strategies/Cutting.lua
+5
View File
@@ -13,5 +13,10 @@ local WinData = require( 'WinData')
EgtOutLog( ' Cutting started', 1)
EgtMdbSave()
-------------------------------------------------------------------------------------------------------------
function Cutting.Make( Proc, Part)
return true
end
-------------------------------------------------------------------------------------------------------------
return Cutting
CAMAuto/Strategies/Drillin.lua → CAMAuto/Strategies/Drilling.lua
+5
View File
@@ -13,5 +13,10 @@ local WinData = require( 'WinData')
EgtOutLog( ' Drilling started', 1)
EgtMdbSave()
-------------------------------------------------------------------------------------------------------------
function Drilling.Make( Proc, Part)
return true
end
-------------------------------------------------------------------------------------------------------------
return Drilling
CAMAuto/Strategies/Milling.lua
+5
View File
@@ -13,5 +13,10 @@ local WinData = require( 'WinData')
EgtOutLog( ' Milling started', 1)
EgtMdbSave()
-------------------------------------------------------------------------------------------------------------
function Milling.Make( Proc, Part)
return true
end
-------------------------------------------------------------------------------------------------------------
return Milling
CAMAuto/Strategies/Pocketing.lua
+5
View File
@@ -13,5 +13,10 @@ local WinData = require( 'WinData')
EgtOutLog( ' Pocketing started', 1)
EgtMdbSave()
-------------------------------------------------------------------------------------------------------------
function Pocketing.Make( Proc, Part)
return true
end
-------------------------------------------------------------------------------------------------------------
return Pocketing
CAMAuto/Strategies/Profiling.lua
+34 -12
View File
@@ -9,29 +9,51 @@ require( 'EgtBase')
-- Carico i dati globali
local WinData = require( 'WinData')
local MachiningLib = require( 'MachiningLib')
EgtOutLog( ' Profiling started', 1)
EgtMdbSave()
-------------------------------------------------------------------------------------------------------------
function Profiling.Make( Proc, Part)
local ToolInfo = {}
local Machining = {}
Machining.LeadIn = {}
Machining.LeadOut = {}
Machining.Steps = {}
Machining.sDepth = 0
Machining.dRadialOffset = Proc.dRadialOffset
Machining.dLongitudinalOffset = Proc.dLongitudinalOffset
Machining.Steps.dSideStep = TOOLS[nIndexTool].dSideStep
Machining.LeadIn.nType = MCH_MILL_LI.TANGENT
Machining.LeadIn.dTangentDistance = TOOLS[nIndexTool].dDiameter
Machining.LeadIn.dPerpDistance = TOOLS[nIndexTool].dDiameter
Machining.LeadOut.nType = MCH_MILL_LI.TANGENT
Machining.LeadOut.dTangentDistance = TOOLS[nIndexTool].dDiameter
Machining.LeadOut.dPerpDistance = 0
-- se so che utensili utilizzare, associazione diretta
if Proc.nToolsToUse then
for i = 1, Proc.nToolsToUse do
local ToolSearchParameters = {}
ToolSearchParameters.sName = Proc.Tools[i].sName
ToolSearchParameters.dElevation = 0
ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
-- se trovato utensile
if ToolInfo.nToolIndex then
Machining.nType = MCH_MY.MILLING
Machining.nWorkSide = MCH_MILL_WS.RIGHT
Machining.nToolIndex = ToolInfo.nToolIndex
Machining.sDepth = 0
Machining.dRadialOffset = Proc.Tools[i].dRadialOffset
Machining.dLongitudinalOffset = Proc.Tools[i].dLongitudinalOffset
Machining.LeadIn.nType = MCH_MILL_LI.TANGENT
Machining.LeadIn.dTangentDistance = TOOLS[ToolInfo.nToolIndex].dDiameter
Machining.LeadIn.dPerpDistance = TOOLS[ToolInfo.nToolIndex].dDiameter
Machining.LeadOut.nType = MCH_MILL_LO.TANGENT
Machining.LeadOut.dTangentDistance = TOOLS[ToolInfo.nToolIndex].dDiameter
Machining.LeadOut.dPerpDistance = 0
Machining.Geometry = Proc.id
MachiningLib.AddNewMachining( Proc, Machining)
else
return false, 'Tool not found'
end
end
-- altrimenti cerco tra quelli disponibili
else
; --per il momento non serve. Le info sull'utensile arrivano sempre
end
return true
end
-------------------------------------------------------------------------------------------------------------