diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index cc1a2c6..a83d532 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -35,6 +35,7 @@ STRATEGIES = {} -- tabella contenente le strategie disponibili per ogni STRATEGIES_CONFIG = {} -- tabella contenente i parametri di default delle strategie disponibili MACHININGS = {} -- tabella contenente le lavorazioni da applicare MACHININGS.Info = {} +DB_MACH_APPLIED = {} -- tabella contenente informazioni delle lavorazioni create e aggiunte in lista PROCESSINGS = {} -- tabella contenente tutte le informazioni di ogni feature, processate per ogni rotazione RESULT = {} -- tabella contenente il risultato, feature per feature, dell'applicazione della strategia scelta e il resoconto dell'analisi fatta GENERAL_PARAMETERS = {} -- tabella contenente i parametri generali già letti e importati @@ -1600,6 +1601,11 @@ function BeamExec.ProcessMachinings( PARTS) -- si mette subito il pezzo nella fase if nOrd == 1 then EgtSetCurrPhase( 1) + local nPhase = EgtGetCurrPhase() + -- salvo info nuova fase aggiunta + local MachExtraInfo = { sType = 'DISP', + nPhase = nPhase} + table.insert( DB_MACH_APPLIED, MachExtraInfo) else BeamLib.AddPhaseWithRawParts( PARTS[nPart].idRaw, BeamData.ptOriXR, BeamData.dPosXR, 0) end @@ -1693,11 +1699,10 @@ function BeamExec.ProcessMachinings( PARTS) -- si preparano le lavorazioni assegnandole al proprio stage MACHININGS = MachiningLib.PrepareMachiningsForSorting( PARTS[nPart]) - -- ordinamento lavorazioni - -- TODO sostituire con sorting Egt + MACHININGS = BeamLib.StableSort( MACHININGS, MachiningLib.CompareMachinings) + -- TODO la FinalizeSorting andrebbe rimossa e usato un sorting che non viola le dipendenze - -- MACHININGS = BeamLib.StableSort( MACHININGS, MachiningLib.CompareMachinings) -- MACHININGS = MachiningLib.FinalizeSorting() -- finiti i calcoli di applicazione delle lavorazioni, si riporta il pezzo nello zero della fase @@ -1783,12 +1788,12 @@ function BeamExec.ProcessMachinings( PARTS) MachiningLib.AddOperations( MACHININGS, PARTS[nPart], 'STD') -- ottimizzazione con algoritmo ShortestPath - -- TODO completare ordinamento. Mancano le dipendenze - MACHININGS = MachiningLib.ShortestPathSorting( MACHININGS) + MachiningLib.ShortestPathSorting() EgtOutLog( ' *** End AddMachinings ***', 1) -- azzero lavorazioni per pezzo successivo MACHININGS = {} + DB_MACH_APPLIED = {} MACHININGS.Info = {} -- indice pezzo successivo nOrd = nOrd + 1 diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua index dfc7061..e267d99 100644 --- a/LuaLibs/BeamLib.lua +++ b/LuaLibs/BeamLib.lua @@ -104,7 +104,7 @@ end ------------------------------------------------------------------------------------------------------------- function BeamLib.AddPhaseWithRawParts( idRaw, OriXR, PosXR, dDeltaSucc) - EgtAddPhase() + local nPhase = EgtAddPhase() -- si aprono i limiti tavola per permettere rotazioni di pezzi più larghi della tavola EgtSetTableAreaOffset( 2000, 2000, 2000, 2000) local dRawMove = 0 @@ -116,6 +116,10 @@ function BeamLib.AddPhaseWithRawParts( idRaw, OriXR, PosXR, dDeltaSucc) dRawMove = dRawMove + EgtGetRawPartBBox( idRaw):getDimX() idRaw = EgtGetNextRawPart( idRaw) end + -- salvo info nuova fase aggiunta + local MachExtraInfo = { sType = 'DISP', + nPhase = nPhase} + table.insert( DB_MACH_APPLIED, MachExtraInfo) end ------------------------------------------------------------------------------------------------------------- diff --git a/LuaLibs/MachiningLib.lua b/LuaLibs/MachiningLib.lua index c55ac8c..f734847 100644 --- a/LuaLibs/MachiningLib.lua +++ b/LuaLibs/MachiningLib.lua @@ -1127,6 +1127,10 @@ function MachiningLib.AddOperations( vProc, Part, sRotation) if MACHININGS[i].AuxiliaryData.Clones then nClonesToAdd = #MACHININGS[i].AuxiliaryData.Clones end + -- dati da salvare dopo applicazione della lavorazione + MACHININGS[i].Machining.MachStartAxesPos = {} + MACHININGS[i].Machining.MachEndAxesPos = {} + MACHININGS[i].Machining.nOperationId = {} for j = 1, nClonesToAdd do -- creazione lavorazione local nOperationId = EgtCreateMachining( MACHININGS[i].Machining.sOperationName, MACHININGS[i].Machining.nType, MACHININGS[i].Machining.sToolName) @@ -1227,6 +1231,15 @@ function MachiningLib.AddOperations( vProc, Part, sRotation) end local bIsApplyOk = MachiningLib.ApplyMachining( true, false) + + -- si salva sulla lista info lavorazione applicata + local MachExtraInfo = { sType = 'MACH', + nIndexInMachinings = i, + nOperationId = nOperationId, + MachStartAxesPos = EgtGetMachiningStartAxes(), + MachEndAxesPos = EgtGetMachiningEndAxes()} + table.insert( DB_MACH_APPLIED, MachExtraInfo) + -- se errore in applicazione if not bIsApplyOk then bAreAllMachiningApplyOk = false @@ -1239,10 +1252,6 @@ function MachiningLib.AddOperations( vProc, Part, sRotation) RESULT[MACHININGS[i].Proc.nIndexInResult].ChosenStrategy.nApplyError = nErr -- se applicazione andata a buon fine else - -- si salva sulla lista info lavorazione applicata - MACHININGS[i].Machining.MachStartAxesPos = EgtGetMachiningStartAxes() - MACHININGS[i].Machining.MachEndAxesPos = EgtGetMachiningEndAxes() - MACHININGS[i].Machining.nOperationId = nOperationId -- se non deve essere igniorato, si salva ingombro lavorazione attuale e fasi successive if not MACHININGS[i].AuxiliaryData.bIgnoreNotClampableLength then @@ -1570,19 +1579,6 @@ end -- TODO libreria Sorting?? ------------------------------------------------------------------------------------------------------------- local SortingComparisonRules = { - -- ordine interno alla feature - function( MachiningA, MachiningB) - if MachiningA.Proc.id == MachiningB.Proc.id then - if MachiningA.Machining.nFeatureInternalIndex < MachiningB.Machining.nFeatureInternalIndex then - return 1 - elseif MachiningA.Machining.nFeatureInternalIndex > MachiningB.Machining.nFeatureInternalIndex then - return -1 - end - end - - return 0 - end, - -- dipendenze solo spostamento stage 2->4 -- TODO da fare @@ -1596,110 +1592,6 @@ local SortingComparisonRules = { return 0 end end, - - -- dipendenze - -- TODO da fare - - -- segment - function ( MachiningA, MachiningB) - if MachiningA.Machining.nPartSegment < MachiningB.Machining.nPartSegment then - return 1 - elseif MachiningA.Machining.nPartSegment > MachiningB.Machining.nPartSegment then - return -1 - else - return 0 - end - end, - - -- testa - -- TODO da fare - - -- famiglia utensile - function ( MachiningA, MachiningB) - -- TODO tirare fuori da qua?? - local ToolFamilyOrder = { - SAWBLADE = 1, - DRILLBIT = 2, - MILL = 3, - MORTISE = 4 - } - local nToolFamilyOrderA = ToolFamilyOrder[ TOOLS[ MachiningA.Machining.nToolIndex].sFamily] - local nToolFamilyOrderB = ToolFamilyOrder[ TOOLS[ MachiningB.Machining.nToolIndex].sFamily] - - if nToolFamilyOrderA < nToolFamilyOrderB then - return 1 - elseif nToolFamilyOrderA > nToolFamilyOrderB then - return -1 - else - return 0 - end - end, - - -- performance utensile - function( MachiningA, MachiningB) - local dToolPerformanceIndexA = TOOLS[MachiningA.Machining.nToolIndex].dPerformanceIndex - local dToolPerformanceIndexB = TOOLS[MachiningB.Machining.nToolIndex].dPerformanceIndex - - if dToolPerformanceIndexA > dToolPerformanceIndexB then - return 1 - elseif dToolPerformanceIndexA < dToolPerformanceIndexB then - return -1 - else - return 0 - end - end, - - -- probabilmente arrivati qui significa che gli utensili A e B sono gli stessi - -- se così non fosse e tutte le caratteristiche sopra sono uguali, ordine alfabetico - function( MachiningA, MachiningB) - local sToolNameA = TOOLS[MachiningA.Machining.nToolIndex].sName - local sToolNameB = TOOLS[MachiningB.Machining.nToolIndex].sName - - if sToolNameA < sToolNameB then - return 1 - elseif sToolNameA > sToolNameB then - return -1 - else - return 0 - end - end, - - -- lato di lavoro - -- TODO questo, insieme all'ordinamento X, andrà sostituito dallo shortest path pesato sulla quantità di rotazione della testa - function( MachiningA, MachiningB) - if MachiningA.Machining.vtToolDirection:getY() < -0.174 and MachiningB.Machining.vtToolDirection:getY() >= 0.174 then - return 1 - elseif MachiningA.Machining.vtToolDirection:getY() >= 0.174 and MachiningB.Machining.vtToolDirection:getY() < -0.174 then - return -1 - else - return 0 - end - end, - - -- ordinamento X - -- TODO questo andrà sostituito dallo shortest path pesato sulla quantità di rotazione della testa - function( MachiningA, MachiningB) - local bIsMachiningOnFront = MachiningA.Machining.vtToolDirection:getY() < 10 * GEO.EPS_SMALL - local nResult = 0 - - -- se lavorazione davanti ordine testa->coda - if bIsMachiningOnFront then - if MachiningA.Machining.ptCenter:getX() > MachiningB.Machining.ptCenter:getX() + 10 * GEO.EPS_SMALL then - nResult = 1 - elseif MachiningA.Machining.ptCenter:getX() < MachiningB.Machining.ptCenter:getX() - 10 * GEO.EPS_SMALL then - nResult = -1 - end - -- se lavorazione dietro ordine coda->testa - else - if MachiningA.Machining.ptCenter:getX() < MachiningB.Machining.ptCenter:getX() - 10 * GEO.EPS_SMALL then - nResult = 1 - elseif MachiningA.Machining.ptCenter:getX() > MachiningB.Machining.ptCenter:getX() + 10 * GEO.EPS_SMALL then - nResult = -1 - end - end - - return nResult - end } ------------------------------------------------------------------------------------------------------------- @@ -1721,26 +1613,28 @@ end local function OrderMachining( MachiningOptList) -- Recupero l'identificativo del gruppo di lavoro corrente for i = 1, #MachiningOptList - 1 do - local idSource = MACHININGS[MachiningOptList[i+1]].Machining.nOperationId - local idRef = MACHININGS[MachiningOptList[i]].Machining.nOperationId + local idSource = DB_MACH_APPLIED[MachiningOptList[i+1]].nOperationId + local idRef = DB_MACH_APPLIED[MachiningOptList[i]].nOperationId EgtRelocateGlob( idSource, idRef, GDB_IN.AFTER) end end + ------------------------------------------------------------------------------------------------------------- -function MachiningLib.ShortestPathSorting( MachiningList) +function MachiningLib.ShortestPathSorting() -- verificare se serve settare prima e ultima lavorazione -- EgtOptMachSetFirstMachining( int nId) -- EgtOptMachSetLastMachining( int nId) - -- Recupero l'identificativo del gruppo di lavoro corrente - local nOperation = EgtGetFirstOperation() - - local nMachiningIndexInGlobList = 0 - while nOperation do - if EgtGetOperationType( nOperation) ~= MCH_OY.DISP then - local MachiningOptList = {} + local nStartIndex + local i = 1 + while i <= #DB_MACH_APPLIED do + local nMachInDisp = 0 + local MachiningOptList = {} + -- se è una lavorazione + if DB_MACH_APPLIED[i].sType ~= 'DISP' then -- inizio + nStartIndex = i EgtOptMachInit() -- leggere feed dalla macchina @@ -1749,37 +1643,34 @@ function MachiningLib.ShortestPathSorting( MachiningList) -- tra gruppi (stage) non si può ottimizzare EgtOptMachSetAllGroupsDependencesAsMandatory( true) - local nMachiningInDisp = 0 - while EgtGetOperationType( nOperation) ~= MCH_OY.DISP do - nMachiningIndexInGlobList = nMachiningIndexInGlobList + 1 - nMachiningInDisp = nMachiningInDisp + 1 - - table.insert( MachiningOptList, nMachiningIndexInGlobList) - local nToolIndex = MachiningList[nMachiningIndexInGlobList].Machining.nToolIndex - -- TODO leggere tempo cambio utensile e posizione del magazzino da macchina + -- se è una lavorazione + while DB_MACH_APPLIED[i] and DB_MACH_APPLIED[i].sType ~= 'DISP' do + -- aggiungo lavorazioni + local nToolIndex = MACHININGS[DB_MACH_APPLIED[i].nIndexInMachinings].Machining.nToolIndex EgtOptMachAddTool( nToolIndex, 2, 2) -- , [ num dTC_X, num dTC_Y, num dTC_Z, num dTC_A, num dTC_B, num dTC_C]) - -- viene eseguito prima il gruppo con indice più alto, quindi si inverte indice dato che lo stage è dal più piccolo al più grande - local nGroup = 10 - MachiningList[nMachiningIndexInGlobList].Machining.nStage - local MachStartAxesPos = MachiningList[nMachiningIndexInGlobList].Machining.MachStartAxesPos - local MachEndAxesPos = MachiningList[nMachiningIndexInGlobList].Machining.MachEndAxesPos - EgtOptMachAddMachining( nMachiningIndexInGlobList, nToolIndex, nGroup, MachStartAxesPos, MachEndAxesPos) + local nOperationId = DB_MACH_APPLIED[i].nOperationId + local nGroup = 10 - MACHININGS[DB_MACH_APPLIED[i].nIndexInMachinings].Machining.nStage + local MachStartAxesPos = DB_MACH_APPLIED[i].MachStartAxesPos + local MachEndAxesPos = DB_MACH_APPLIED[i].MachEndAxesPos + EgtOptMachAddMachining( i, nToolIndex, nGroup, MachStartAxesPos, MachEndAxesPos) + table.insert( MachiningOptList, i) - nOperation = EgtGetNextOperation( nOperation) + nMachInDisp = nMachInDisp + 1 + i = i + 1 end - local nStartIndex = nMachiningIndexInGlobList - nMachiningInDisp + 1 - local nStopIndex = nMachiningIndexInGlobList + local nStopIndex = nStartIndex + nMachInDisp - 1 -- cliclo su tutte le lavorazioni - for i = nStartIndex, nStopIndex do + for k = nStartIndex, nStopIndex do for j = nStartIndex, nStopIndex do -- se non è stessa lavorazione, imposto dati e dipendenze - if i ~= j then + if k ~= j then -- se stessa Proc - if MachiningList[i].Proc.id == MachiningList[j].Proc.id then + if MACHININGS[DB_MACH_APPLIED[k].nIndexInMachinings].Proc.id == MACHININGS[DB_MACH_APPLIED[j].nIndexInMachinings].Proc.id then -- se lavorazioni della stessa feature, obbligatorio rispettare ordine - if MachiningList[i].Machining.nFeatureInternalIndex < MachiningList[j].Machining.nFeatureInternalIndex then - EgtOptMachAddDependence( i, j) + if MACHININGS[DB_MACH_APPLIED[k].nIndexInMachinings].Machining.nFeatureInternalIndex < MACHININGS[DB_MACH_APPLIED[j].nIndexInMachinings].Machining.nFeatureInternalIndex then + EgtOptMachAddDependence( k, j) end -- se tra due Proc diverse else @@ -1787,14 +1678,13 @@ function MachiningLib.ShortestPathSorting( MachiningList) -- se ci sono dipendenze tra due feature diverse, la dipendenza è obbligatoria! ATTENZIONE A DIPENDENZE INCROCIATE A->B, B->C, C->A -- se in diversa rotazione dipendenza obbligatoria - if MachiningList[i].Proc.bDown and ( MachiningList[j].Proc.bStd or MachiningList[j].Proc.bSide) then - EgtOptMachAddDependence( i, j) - elseif MachiningList[i].Proc.bSide and MachiningList[j].Proc.bStd then - EgtOptMachAddDependence( i, j) + if MACHININGS[DB_MACH_APPLIED[k].nIndexInMachinings].Proc.bDown and ( MACHININGS[DB_MACH_APPLIED[j].nIndexInMachinings].Proc.bStd or MACHININGS[DB_MACH_APPLIED[j].nIndexInMachinings].Proc.bSide) then + EgtOptMachAddDependence( k, j) + elseif MACHININGS[DB_MACH_APPLIED[k].nIndexInMachinings].Proc.bSide and MACHININGS[DB_MACH_APPLIED[j].nIndexInMachinings].Proc.bStd then + EgtOptMachAddDependence( k, j) -- dipendenza suggerita se sono su segmenti diversi (non sempre il segmento è settato) - elseif MachiningList[i].Machining.nFeatureSegment and MachiningList[j].Machining.nFeatureSegment and - MachiningList[i].Machining.nFeatureSegment < MachiningList[j].Machining.nFeatureSegment then - EgtOptMachAddSuggestedDependence( i, j) + elseif MACHININGS[DB_MACH_APPLIED[k].nIndexInMachinings].Machining.nPartSegment < MACHININGS[DB_MACH_APPLIED[j].nIndexInMachinings].Machining.nPartSegment then + EgtOptMachAddSuggestedDependence( k, j) end end end @@ -1809,11 +1699,8 @@ function MachiningLib.ShortestPathSorting( MachiningList) -- fine EgtOptMachTerminate() end - nOperation = EgtGetNextOperation( nOperation) + i = i + 1 end - - - return MachiningList end diff --git a/Process.lua b/Process.lua index ff9d242..448d9fc 100644 --- a/Process.lua +++ b/Process.lua @@ -7,7 +7,7 @@ -- Intestazioni require( 'EgtBase') _ENV = EgtProtectGlobal() -EgtEnableDebug( true) +EgtEnableDebug( false) -- Imposto direttorio libreria specializzata per Travi EgtAddToPackagePath( BEAM.BASEDIR .. '\\LuaLibs\\?.lua')