Egalware/Saomad-Just3500
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d5c221bb244e50c44e989bc450312a3d3d7df4b3
Saomad-Just3500/Saomad-Just3500.mlpe
T
Dario Sassi 5f7c918434 Saomad-Just3500 3.1a1 : 
- modifiche per ToolTrace e ingombro tavola2.
2026-01-14 16:22:11 +01:00

739 lines
27 KiB
Plaintext
Raw Blame History

-- Special Operations macchina Saomad Just3500 by Egalware s.r.l. 2026/01/14
-- Intestazioni
require( 'EmtGenerator')
EgtEnableDebug( false)
---------------------------------------------------------------------
-- *** GENERATION ***
---------------------------------------------------------------------
local sBaseDir = EgtGetSourceDir()
if NumericalControl == 'SIEMENS' then
dofile( sBaseDir .. 'Saomad-Just3500.SIEMENS.mlpe')
else
EmtSetLastError( 1201, 'Numerical Control error : unkwnown type')
end
---------------------------------------------------------------------
-- *** SIMULATION ***
---------------------------------------------------------------------
local COLL_SAFE_DIST = 3
---------------------------------------------------------------------
function OnSimulInit()
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab'), 'SOLID'), GDB_ST.OFF)
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab2'), 'SOLID1'), GDB_ST.OFF)
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab2'), 'SOLID2'), GDB_ST.OFF)
end
---------------------------------------------------------------------
function OnSimulExit()
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab'), 'SOLID'), GDB_ST.ON)
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab2'), 'SOLID1'), GDB_ST.ON)
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab2'), 'SOLID2'), GDB_ST.ON)
end
---------------------------------------------------------------------
function OnSimulStart()
-- Se reset o home, esco
if EMT.SIM1ST then return end
-- Creo o svuoto gruppo per copia finale degli oggetti virtual milling
local nVmGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'VMill')
if nVmGrpId then
EgtSetStatus( nVmGrpId, GDB_ST.ON)
EgtEmptyGroup( nVmGrpId)
else
nVmGrpId = EgtGroup( GDB_ID.ROOT)
EgtSetName( nVmGrpId, 'VMill')
EgtSetLevel( nVmGrpId, GDB_LV.TEMP)
end
-- Preparo lista oggetti da verificare per collisioni
EMT.COLLOBJ = {}
AddToCollisionCheck( 'Z1', 'H11_COLLISION', EMT.COLLOBJ)
AddToCollisionCheck( 'Z1', 'H21_COLLISION', EMT.COLLOBJ)
AddToCollisionCheck( 'Z1', 'H31_COLLISION', EMT.COLLOBJ)
AddToCollisionCheck( 'Z1', 'H41_COLLISION', EMT.COLLOBJ)
AddToCollisionCheck( 'C2', 'COLLISION', EMT.COLLOBJ)
AddToCollisionCheck( 'H21', 'COLLISION', EMT.COLLOBJ)
DumpCollisionCheck( EMT.COLLOBJ, 'Collision Objects :', 4)
-- Preparo lista solidi macchina con cui possono collidere gli oggetti sopra riportati (in aggiunta a VMill)
EMT.MCODET = {}
local McdData = { { Grp = 'X1', Sub = 'COLLISION', Name = {'CAR1'}},
{ Grp = 'X1', Sub = 'CLAMP_1', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X1', Sub = 'CLAMP_2', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X1', Sub = 'CLAMP_3', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X1', Sub = 'CLAMP_4', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X1', Sub = 'CLAMP_5', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X1', Sub = 'CLAMP_6', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X1', Sub = 'CLAMP_7', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X1', Sub = 'CLAMP_8', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'COLLISION', Name = {'CAR2'}},
{ Grp = 'X2', Sub = 'CLAMP_1', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'CLAMP_2', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'CLAMP_3', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'CLAMP_4', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'CLAMP_5', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'CLAMP_6', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'CLAMP_7', Name = { 'COLLISION1', 'COLLISION2'}},
{ Grp = 'X2', Sub = 'CLAMP_8', Name = { 'COLLISION1', 'COLLISION2'}}}
EgtOutLog( 'MCODET Objects :', 4)
local nMcdNullCnt = 0
for i = 1, #McdData do
local nGrpId
if McdData[i].Grp == 'Base' then
nGrpId = EgtGetBaseId( 'Base')
else
nGrpId = EgtGetAxisId( McdData[i].Grp)
end
for j = 1, #McdData[i].Name do
local nId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nGrpId, McdData[i].Sub), McdData[i].Name[j])
if nId then
table.insert( EMT.MCODET, nId)
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name[j] .. ' (' .. tostring( nId) .. ') is ok', 4)
else
nMcdNullCnt = nMcdNullCnt + 1
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name[j] .. ' is null', 4)
end
end
end
if nMcdNullCnt > 0 then
EgtOutLog( 'Warning : MCODET with one or more null Element(s) ')
end
-- Preparo lista collisioni vuota
EMT.COLLIDE = {}
end
---------------------------------------------------------------------
function OnSimulEnd()
ExecMoveToHome()
end
---------------------------------------------------------------------
function OnSimulDispositionStarting()
if EMT.PHASE == 2 then
-- carrelli tornano in parcheggio
local dLoadPos = EgtGetAxisHomePos( 'T')
SimulMoveAxes( 'T', dLoadPos, MCH_SIM_STEP.RAPID, 'X1', dLoadPos, MCH_SIM_STEP.RAPID, 'X2', dLoadPos - EMT.X2DELTA, MCH_SIM_STEP.RAPID)
end
end
---------------------------------------------------------------------
function OnSimulDispositionStart()
EMT.OPEISDISP = true
-- se non esiste la lista con le info dei pezzi, la creo
if not EMT.PIECES or EMT.PHASE > 1 then
EMT.PIECES = {}
end
-- recupero tutte le info dei pezzi, dimensioni e posizione
local nPartRawId = EgtGetFirstRawPart()
while nPartRawId do
local vPiece = {}
-- recupero il solido
local nSolId = EgtGetFirstNameInGroup( nPartRawId, 'RawSolid')
local b3Raw = EgtGetBBoxGlob( nSolId, GDB_BB.STANDARD)
vPiece.Id = nPartRawId
vPiece.IdPiece = EgtGetFirstPartInRawPart( nPartRawId)
vPiece.SolId = nSolId
vPiece.Len = b3Raw:getDimX()
vPiece.Wid = b3Raw:getDimY()
vPiece.Thk = b3Raw:getDimZ()
vPiece.Offs = b3Raw:getMin() -- offset rispetto a zero
vPiece.OffTab = b3Raw:getMin() - Vector3d( DeltaTabX, DeltaTabY, DeltaTabZ) -- offset rispetto a zero tavola
vPiece.Clamp = {}
vPiece.Clamp.dPhase1 = EgtGetInfo( vPiece.IdPiece, 'CLAMPV_1', 'd') or vPiece.Thk
vPiece.Clamp.dPhase2 = EgtGetInfo( vPiece.IdPiece, 'CLAMPV_2', 'd') or vPiece.Thk
vPiece.Area = vPiece.Len * vPiece.Wid + vPiece.Len * vPiece.Thk + vPiece.Wid * vPiece.Thk
table.insert( EMT.PIECES, vPiece)
nPartRawId = EgtGetNextRawPart( nPartRawId)
end
-- se ho più di un pezzo, devo aprire carrelli (default sono chiusi)
local MAXDIMPIECE1CAR = 1500 -- da InitDisp.lua
if #EMT.PIECES > 1 or ( #EMT.PIECES == 1 and EMT.PIECES[1].Len <= MAXDIMPIECE1CAR) then
EMT.X2DELTA = 380
else
EMT.X2DELTA = 0
end
-- Se prima disposizione
if EMT.PHASE == 1 then
-- imposto carro X2 a interasse
EgtSetAxisPos( 'X2', -EMT.X2DELTA)
-- Carico primo utensile sulla testa 1
EMT.LOAD = true
-- Se vero inizio e abilitato creo gli Zmap
EMT.VMILL = {}
if not EMT.SIM1ST and EgtGetInfo( EgtGetCurrMachGroup(), 'Vm', 'b') then
for i = 1, #EMT.PIECES do
-- elimino eventuale vecchio Zmap
EgtErase( EgtGetFirstNameInGroup( EMT.PIECES[i].Id, 'VMill') or GDB_ID.NULL)
-- recupero il solido
local nSolId = EgtGetFirstNameInGroup( EMT.PIECES[i].Id, 'RawSolid')
-- determino la risoluzione dello Zmap
local dArea = EMT.PIECES[i].Area
local dTol = 3.77
if dArea < CoeffVM * 0.07e6 then
dTol = 0.49
elseif dArea < CoeffVM * 0.15e6 then
dTol = 0.71
elseif dArea < CoeffVM * 0.3e6 then
dTol = 1.01
elseif dArea < CoeffVM * 0.6e6 then
dTol = 1.51
elseif dArea < CoeffVM * 1.2e6 then
dTol = 1.97
elseif dArea < CoeffVM * 2.4e6 then
dTol = 2.81
end
-- creo lo Zmap
local VMillId = EgtVolZmapBox( EMT.PIECES[i].Id, EMT.PIECES[i].Offs, EMT.PIECES[i].Len, EMT.PIECES[i].Wid, EMT.PIECES[i].Thk, dTol, true, GDB_RT.GLOB)
if VMillId then
EgtSetName( VMillId, 'VMill')
EgtSetLevel( VMillId, GDB_LV.TEMP)
EgtSetColor( VMillId, EgtGetColor( nSolId), false)
-- nascondo le altre geometrie
local nId = EgtGetFirstInGroup( EMT.PIECES[i].Id)
while nId do
if nId ~= VMillId then
EgtSetStatus( nId, GDB_ST.OFF)
end
nId = EgtGetNext( nId)
end
table.insert( EMT.VMILL, VMillId)
end
end
end
-- se vero inizio, assegno solidi per verifica collisione
if not EMT.SIM1ST then
EMT.CODET = {}
for i = 1, #( EMT.MCODET or {}) do
EMT.CODET[i] = EMT.MCODET[i]
end
for i = 1, #( EMT.VMILL or {}) do
table.insert( EMT.CODET, EMT.VMILL[i])
end
end
-- se vero inizio, cancello gruppo/i per traccia tooltip e ne ricreo uno
if not EMT.SIM1ST then
EgtErase( EgtGetNameInGroup( EMT.PIECES[1].Id, 'ToolTrace'))
EMT.TOOLTRACE = EgtGroup( EMT.PIECES[1].Id)
EgtSetName( EMT.TOOLTRACE, 'ToolTrace')
EgtSetLevel( EMT.TOOLTRACE, GDB_LV.TEMP)
EgtSetColor( EMT.TOOLTRACE, 'RED')
end
-- se fase 2
else
ExecMoveToZmax()
end
-- Nascondo tutte le lavorazioni
local nMchId = EgtGetFirstOperation()
while nMchId do
if EgtGetOperationType( nMchId) ~= MCH_OY.DISP then
EgtSetOperationStatus( nMchId, false)
end
nMchId = EgtGetNextOperation( nMchId)
end
end
---------------------------------------------------------------------
function OnSimulDispositionEnd()
-- ottengo il grezzo relativo alla fase
local bGotRawIdInfo = false
-- Aggancio grezzi alla tavola
local nRawId = EgtGetFirstRawPart()
while nRawId do
if not bGotRawIdInfo and EgtVerifyRawPartPhase( nRawId, EMT.PHASE) then
nRawIGetInfo = nRawId
bGotRawIdInfo = true
end
local nNextRawId = EgtGetNextRawPart( nRawId)
EmtLinkRawPartToGroup( nRawId, EMT.TABNAME)
nRawId = nNextRawId
end
-- se fase 1 pinzo direttamente
if EMT.PHASE == 1 then
-- carico pezzo
-- se fase 2, sposto il pezzo in nuova posizione (carrelli già in home da 'OnSimulDispositionStarting')
elseif EMT.PHASE == 2 then
-- manipolatore prende il pezzo
-- apro morse
-- manipolatore sposta il pezzo in nuova posizione
end
-- alla fine della disposizione pinzo i pezzi
ExecClampPieces()
-- manipolatore in posizione a parcheggio
EMT.OPEISDISP = false
end
---------------------------------------------------------------------
function OnSimulToolSelect()
-- se utensile non definito, è disposizione ed esco
if EMT.TOOL == '' then return end
-- recupero dati utensile
EMT.TOOLTYPE = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
EMT.TOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
EMT.TOTDIAM = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM)
-- se attivo Vmill
SetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL)
-- se attivo Collision Check
EMT.SAFEDIST = COLL_SAFE_DIST
if EMT.COLLOBJ then
for i, Coll in ipairs( EMT.COLLOBJ) do
EmtAddCollisionObjEx( i, Coll.Fr, Coll.Ty, Coll.Mv, Coll.P1, Coll.P2, Coll.P3)
end
AddToolToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, 1001)
AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, 1002)
end
-- breve pausa
EgtPause( 100)
EgtOutText( '')
end
---------------------------------------------------------------------
function OnSimulToolDeselect()
end
---------------------------------------------------------------------
function OnSimulMachiningStart()
-- recupero alcuni dati della lavorazione
EMT.MCHNAME = EgtGetOperationName( EMT.MCHID)
end
---------------------------------------------------------------------
function OnSimulMachiningEnd()
-- se ultima lavorazione, visualizzo spigoli
if not EgtGetNextActiveOperation( EMT.MCHID) then
if EMT.VMILL and #EMT.VMILL > 0 then
-- setto che voglio vedere gli spigoli
for i = 1, #EMT.VMILL do
EgtVolZmapSetShowEdges( EMT.VMILL[i], true)
end
-- aggiorno la visualizzazione
EgtDraw()
end
end
end
---------------------------------------------------------------------
function OnSimulPathStart()
end
---------------------------------------------------------------------
function OnSimulPathEnd()
-- se attivo VMILL, lavorazione ed è richiesto di eliminare gli sfridi
if EMT.VMILL and #EMT.VMILL > 0 and not EMT.OPEISDISP and EMT.VMRS then
EgtOutLog( 'OnSimulPathEnd', 5)
local vMillId = EMT.VMILL[1]
local nPart = EgtVolZmapPartCount( vMillId)
if nPart > 1 then
-- ricerca del pezzo con massimo volume
local nPartMax = 0
local dVolMax = 0
for i = 1, nPart do
local dVol = EgtVolZmapPartVolume( vMillId, i - 1)
if dVol > dVolMax then
dVolMax = dVol
nPartMax = i
end
end
-- eliminazione di tutti i pezzi piccoli
for i = nPart, 1, -1 do
if i ~= nPartMax then
local b3Vmill = EgtVolZmapGetPartBBoxGlob( vMillId, i - 1, GDB_BB.STANDARD)
if b3Vmill:getDimX() < 1200 then
EgtRemoveVolZmapPart( vMillId, i - 1)
end
end
end
-- aggiorno visualizzazione
EgtDraw()
end
end
end
---------------------------------------------------------------------
function OnSimulMoveStart()
-- muovo i carrelli assieme al pezzo
EMT.AuxAxes = 2
EMT.A1n = 'X1'
EMT.A1m = 'T'
EMT.A1 = EMT.L1
EMT.A2n = 'X2'
EMT.A2m = 'T'
EMT.A2 = EMT.L1 - EMT.X2DELTA
-- se standard
if EMT.FLAG == 0 or EMT.FLAG == 1 or EMT.FLAG == 2 then
-- se primo movimento della lavorazione, gestione speciale
if EMT.MCHFIRST then
if EMT.GROUP == 1 then
-- muovo prima i primi due assi lineari
if EMT.L1 and EMT.L2 then
SimulMoveAxes( EMT.L1n, EMT.L1, MCH_SIM_STEP.RAPID, EMT.L2n, EMT.L2, MCH_SIM_STEP.RAPID)
end
-- muovo i restanti assi lineari
SimulMoveAxes( EMT.L3n, EMT.L3, MCH_SIM_STEP.RAPID, EMT.R1n, EMT.R1, MCH_SIM_STEP.RAPROT, EMT.R2n, EMT.R2, MCH_SIM_STEP.RAPROT)
elseif EMT.GROUP == 4 then
SimulMoveAxes( EMT.L1n, EMT.L1, MCH_SIM_STEP.RAPID, EMT.L2n, EMT.L2, MCH_SIM_STEP.RAPID, EMT.R1n, EMT.R1, MCH_SIM_STEP.RAPROT, EMT.R2n, EMT.R2, MCH_SIM_STEP.RAPROT)
SimulMoveAxes( EMT.L3n, EMT.L3, MCH_SIM_STEP.RAPID)
end
EMT.MCHFIRST = false
else -- caso standard
;
end
-- se altrimenti risalita a Z max a fine lavorazione
elseif EMT.FLAG == 3 then
ExecMoveToZmax()
-- se altrimenti movimento in Home (non si muove la X)
elseif EMT.FLAG == 4 then
ExecMoveToHome()
end
end
---------------------------------------------------------------------
function OnSimulMoveEnd()
end
---------------------------------------------------------------------
function OnSimulCollision()
-- se prima collisione della lavorazione, la segnalo
if EMT.MCHNAME ~= EMT.LAST_MCHNAME_COLLIDE then
local Class = ''
if EMT.SIMCOBIND == 1001 then
Class = 'T_H1'
elseif EMT.SIMCOBIND == 1002 then
Class = 'TH_H1'
else
Class = EMT.COLLOBJ[EMT.SIMCOBIND].Cl
end
table.insert( EMT.COLLIDE, { Mc = EMT.MCHNAME, Cl = Class, Vm = EMT.SIMVMID})
EMT.LAST_MCHNAME_COLLIDE = EMT.MCHNAME
EMT.ERR = 1
local sErr = 'Mach='..EMT.MCHNAME..'; Class='..Class..'; VMill='..EMT.SIMVMID
EmtSetLastError( 1221, sErr, true)
EgtOutLog( 'Collision : ' .. sErr, 1)
end
end
---------------------------------------------------------------------
function VerifyClampWithRawX( vPiece, dPosClamp)
local CLAMP_WID = 100
if ( vPiece.OffTab:getX() < dPosClamp) and ( ( vPiece.OffTab:getX() + vPiece.Len) > ( dPosClamp + CLAMP_WID)) then
return true
end
return false
end
---------------------------------------------------------------------
function VerifyClampWithMachining( vPiece, dPosClamp)
-- QQQQQ da controllare con lavorazioni
-- per il momento ritorna sempre ok
return true
end
---------------------------------------------------------------------
function ExecClampPieces()
-- COSTANTI (da mettere in MLDE)
local DIM_CAR = 1430
local DIST_CARR_CLOSED = 90
local DIMTABY = 250
local CLAMP_INTERAX = 190
local TOT_CLAMPS_ON_CAR = 8
local TOT_CARS = 2
for i = 1, TOT_CARS do
local dDeltaCarr = EgtIf( i == 1, 0, DIM_CAR + DIST_CARR_CLOSED + EMT.X2DELTA)
for j = 1, TOT_CLAMPS_ON_CAR do
local bFront
local dPosClamp = ( j - 1) * CLAMP_INTERAX + dDeltaCarr
local bClamp = true
local bFound = false
local dPieceThikness = 0
local k = 1
while k <= #EMT.PIECES and not bFound do
bFront = EMT.PIECES[k].OffTab:getY() < DIMTABY/2
bClamp = VerifyClampWithRawX( EMT.PIECES[k], dPosClamp)
bClamp = bClamp and VerifyClampWithMachining( EMT.PIECES[k], dPosClamp)
-- al primo controllo che dice che posso pinzare, esco
if bClamp then
if EMT.PHASE == 1 then
dPieceThikness = EMT.PIECES[k].Clamp.dPhase1
else
dPieceThikness = EMT.PIECES[k].Clamp.dPhase2
end
bFound = true
end
k = k + 1
end
if ( bFront and j == 8) or ( not bFront and j == 1) then bClamp = false end
SetClamp( j, i, EgtIf( bClamp, dPieceThikness, -1))
end
end
end
---------------------------------------------------------------------
function ExecMoveToZmax()
-- posizioni home degli assi testa
local HomeZ = EgtGetAxisHomePos( 'Z1')
SimulMoveAxis( 'Z1', HomeZ, MCH_SIM_STEP.RAPID)
end
---------------------------------------------------------------------
function ExecMoveToHome()
-- salgo a ZMAX
ExecMoveToZmax()
-- posizioni home degli assi testa
local HomeY = EgtGetAxisHomePos( 'Y1')
local HomeC1 = EgtGetAxisHomePos( 'C1')
local HomeC2 = EgtGetAxisHomePos( 'C2')
SimulMoveAxes( 'Y1', HomeY, MCH_SIM_STEP.RAPID, 'C1', HomeC1, MCH_SIM_STEP.COLLROT, 'C2', HomeC2, MCH_SIM_STEP.COLLROT)
end
---------------------------------------------------------------------
-- *** ESTIMATION T&L ***
---------------------------------------------------------------------
local RAPID_X_FEED = 50000 -- mm/min
local RAPID_Y_FEED = 50000 -- mm/min
local RAPID_Z_FEED = 10000 -- mm/min
local RAPID_C_FEED = 8000 -- deg/min
local RAPID_B_FEED = 8000 -- deg/min
local RAPID_MIN_T = 0.4 -- s
local TOOL_CHANGE_T = 15 -- s
local TOOL_CHANGE_T4 = 5 -- s
local TOOL_CHANGE_TSH = 3 -- s
---------------------------------------------------------------------
function OnEstimStart()
EMT.INCHES = not EgtUiUnitsAreMM() -- unità di misura mm/inches
end
---------------------------------------------------------------------
function OnEstimEnd()
end
---------------------------------------------------------------------
function OnEstimProgramStart()
-- imposto inizio movimenti da Home
EMT.L1 = EgtGetAxisHomePos( 'X1')
EMT.L2 = EgtGetAxisHomePos( 'Y1')
EMT.L3 = EgtGetAxisHomePos( 'Z1')
EMT.R1 = EgtGetAxisHomePos( 'C1')
EMT.R2 = EgtGetAxisHomePos( 'A1')
-- aggiorno valori come precedenti
EmtUpdatePrev()
-- totalizzatori tempi e lunghezze
EMT.TOTCUTLEN = 0
EMT.TOTCUTTIME = 0
EMT.TOTCUTTIMEPR = 0
EMT.TOTCUTTIME1 = 0
EMT.TOTCUTTIME2 = 0
EMT.TOTCUTTIME3 = 0
EMT.TOTEXTLEN = 0
EMT.TOTEXTTIME = 0
EMT.TOTEXTTIME1 = 0
EMT.TOTEXTTIME2 = 0
EMT.TOTEXTTIME3 = 0
-- variabile per lunghezza taglio utensili
EMT.TOOLCUTLEN = {}
-- intestazioni
EmtTleStart( EMT.INFO)
end
---------------------------------------------------------------------
function OnEstimProgramEnd()
-- stampa dei totali delle lavorazioni
-- per il tempo utilizzo quello tra i due più lungo
-- (è ovvio che è approssimativo ma meglio che sommare il tempo delle lavorazioni di tutti i gruppi)
EMT.TOTCUTTIME = EMT.TOTCUTTIME1 + EMT.TOTEXTTIME1 + EMT.TOTCUTTIME2 + EMT.TOTEXTTIME2 + EMT.TOTCUTTIME3 + EMT.TOTEXTTIME3
EMT.TOTCUTTIMEPR = max( (EMT.TOTCUTTIME1+EMT.TOTEXTTIME1), (EMT.TOTCUTTIME2+EMT.TOTEXTTIME2), (EMT.TOTCUTTIME3+EMT.TOTEXTTIME3))
EmtTleAddTotal( EmtSecToHMS( EMT.TOTCUTTIME), EmtLenToMF( EMT.TOTCUTLEN))
-- stampa dei totali degli utensili
for i = 1, #EMT.TOOLCUTLEN do
local TCL = EMT.TOOLCUTLEN[i]
EmtTleAddTool( TCL.Name, EmtLenToMF( TCL.Len))
end
-- completo il file
local _, _, sExt = EgtSplitPath( EMT.FILE)
EmtTleEnd( sExt:sub( 2))
-- salvo i dati principali nel progetto
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot' , EgtNumToString( EMT.TOTCUTTIME, 0))
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttotpr', EgtNumToString( EMT.TOTCUTTIMEPR, 0))
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot1' , EgtNumToString( (EMT.TOTCUTTIME1+EMT.TOTEXTTIME1), 0))
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot2' , EgtNumToString( (EMT.TOTCUTTIME2+EMT.TOTEXTTIME2), 0))
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot3' , EgtNumToString( (EMT.TOTCUTTIME3+EMT.TOTEXTTIME3), 0))
EgtSetInfo( EgtGetCurrMachGroup(), 'Ltot' , EgtNumToString( EMT.TOTCUTLEN, 0))
end
---------------------------------------------------------------------
function OnEstimDispositionStart()
-- inizio disposizione
EMT.OPEISDISP = true
end
---------------------------------------------------------------------
function OnEstimDispositionEnd()
-- termine disposizione
EMT.OPEISDISP = false
end
---------------------------------------------------------------------
function OnEstimToolSelect()
-- reset indice utensile in tabella lunghezze
EMT.TCLIND = 0
-- verifico che l'utensile sia definito
if #EMT.TOOL == 0 then return end
-- cerco l'utensile nella tabella
for i = 1, #EMT.TOOLCUTLEN do
if EMT.TOOLCUTLEN[i].Name == EMT.TOOL then
EMT.TCLIND = i
break
end
end
-- se non trovato, lo aggiungo
if EMT.TCLIND == 0 then
table.insert( EMT.TOOLCUTLEN, { Name = EMT.TOOL, Len = 0})
EMT.TCLIND = #EMT.TOOLCUTLEN
end
EMT.GROUP = EgtIf( EMT.HEAD == 'H8', 1, tonumber( EMT.HEAD:sub( 2, 2))) -- calcolo il gruppo per il diverso cambio di utensile
-- aggiungo tempo di cambio utensile
if EMT.GROUP == 4 then
EMT.TC_T = TOOL_CHANGE_T4
elseif EMT.GROUP == 2 or EMT.GROUP == 3 then
EMT.TC_T = TOOL_CHANGE_TSH
else
EMT.TC_T = TOOL_CHANGE_T
end
end
---------------------------------------------------------------------
function OnEstimToolDeselect()
end
---------------------------------------------------------------------
function OnEstimMachiningStart()
EMT.MCHNAME = EgtGetMachiningParam( MCH_MP.NAME)
EMT.MCHTYPE = EgtGetMachiningParam( MCH_MP.TYPE)
-- reset contatori di lavorazione
EMT.MCHCUTLEN = 0
EMT.MCHCUTTIME = 0
EMT.MCHEXTLEN = 0
EMT.MCHEXTTIME = ( EMT.TC_T or 0)
EMT.TC_T = 0
end
---------------------------------------------------------------------
function OnEstimMachiningEnd()
-- nel caso di foratura devo dimezzare la lunghezza di taglio perchè comprende anche l'uscita
if EMT.MCHTYPE == MCH_MY.DRILLING then
EMT.MCHCUTLEN = EMT.MCHCUTLEN / 2
end
local sName = EgtGetName( EMT.MCHID)
EmtTleAddMachining( sName, EmtSecToHMS( EMT.MCHCUTTIME + EMT.MCHEXTTIME), EmtLenToMF( EMT.MCHCUTLEN), EMT.TOOL)
-- aggiorno totali e utensili
EMT.TOTCUTLEN = EMT.TOTCUTLEN + EMT.MCHCUTLEN
if EMT.GROUP == 2 then
EMT.TOTCUTTIME2 = EMT.TOTCUTTIME2 + EMT.MCHCUTTIME
elseif EMT.GROUP == 3 then
EMT.TOTCUTTIME3 = EMT.TOTCUTTIME3 + EMT.MCHCUTTIME
else
EMT.TOTCUTTIME1 = EMT.TOTCUTTIME1 + EMT.MCHCUTTIME
end
-- EMT.TOTCUTTIME = EMT.TOTCUTTIME + EMT.MCHCUTTIME
if EMT.GROUP == 2 then
EMT.TOTEXTTIME2 = EMT.TOTEXTTIME2 + EMT.MCHEXTTIME
elseif EMT.GROUP == 3 then
EMT.TOTEXTTIME3 = EMT.TOTEXTTIME3 + EMT.MCHEXTTIME
else
EMT.TOTEXTTIME1 = EMT.TOTEXTTIME1 + EMT.MCHEXTTIME
end
-- EMT.TOTEXTTIME = EMT.TOTEXTTIME + EMT.MCHEXTTIME
EMT.TOTEXTLEN = EMT.TOTEXTLEN + EMT.MCHEXTLEN
EMT.TOOLCUTLEN[EMT.TCLIND].Len = EMT.TOOLCUTLEN[EMT.TCLIND].Len + EMT.MCHCUTLEN
end
---------------------------------------------------------------------
function OnEstimPathStart()
end
---------------------------------------------------------------------
function OnEstimPathEnd()
end
---------------------------------------------------------------------
function OnEstimRapid()
-- dati movimento
local dL1 = EMT.L1 - EMT.L1p
local dL2 = EMT.L2 - EMT.L2p
local dL3 = EMT.L3 - EMT.L3p
local dR1 = 0
local dR2 = 0
if EMT.R1 and EMT.R1p then dR1 = EMT.R1 - EMT.R1p end
if EMT.R2 and EMT.R2p then dR2 = EMT.R2 - EMT.R2p end
-- calcolo lunghezza
local dLen = sqrt( dL1 * dL1 + dL2 * dL2 + dL3 * dL3)
EMT.MCHEXTLEN = EMT.MCHEXTLEN + dLen
-- calcolo tempo
local dTime = RAPID_MIN_T
local dT1 = abs( dL1) / RAPID_X_FEED * 60
if dT1 > dTime then dTime = dT1 end
local dT2 = abs( dL2) / RAPID_Y_FEED * 60
if dT2 > dTime then dTime = dT2 end
local dT3 = abs( dL3) / RAPID_Z_FEED * 60
if dT3 > dTime then dTime = dT3 end
local dT4 = abs( dR1) / RAPID_C_FEED * 60
if dT4 > dTime then dTime = dT4 end
local dT5 = abs( dR2) / RAPID_B_FEED * 60
if dT5 > dTime then dTime = dT5 end
EMT.MCHEXTTIME = EMT.MCHEXTTIME + dTime
-- aggiorno valori come precedenti
EmtUpdatePrev()
end
---------------------------------------------------------------------
function OnEstimLinear()
-- dati movimento
local dL1 = EMT.L1 - EMT.L1p
local dL2 = EMT.L2 - EMT.L2p
local dL3 = EMT.L3 - EMT.L3p
-- calcolo lunghezza
local dLen = sqrt( dL1 * dL1 + dL2 * dL2 + dL3 * dL3)
EMT.MCHCUTLEN = EMT.MCHCUTLEN + dLen
-- calcolo tempo
local dTime = dLen / EMT.F * 60
EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
-- aggiorno valori come precedenti
EmtUpdatePrev()
end
---------------------------------------------------------------------
function OnEstimArc()
-- dati movimento
local dLxy = EMT.RR * abs( EMT.AC) * pi / 180
local dLz = abs( ( Point3d( EMT.L1, EMT.L2, EMT.L3) - Point3d( EMT.L1p, EMT.L2p, EMT.L3p)) * Vector3d( EMT.EXTR))
-- calcolo lunghezza
local dLen = sqrt( dLxy * dLxy + dLz * dLz)
EMT.MCHCUTLEN = EMT.MCHCUTLEN + dLen
-- calcolo tempo
local dTime = dLen / EMT.F * 60
EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
-- aggiorno valori come precedenti
EmtUpdatePrev()
end
Reference in New Issue View Git Blame Copy Permalink