andrea.villa
765 lines
27 KiB
Plaintext
765 lines
27 KiB
Plaintext
-- Processore macchina Homag Venture16L 2025/03/30
|
|
-- by EgalWare s.r.l.
|
|
--
|
|
-- Intestazioni
|
|
require( 'EmtGenerator')
|
|
EgtEnableDebug( false)
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** GENERATION ***
|
|
---------------------------------------------------------------------
|
|
local sBaseDir = EgtGetCurrMachineDir()
|
|
if NumericalControl == 'woodWOP' then
|
|
dofile( sBaseDir .. '\\Homag-woodWOP.mlpe')
|
|
else
|
|
EmtSetLastError( 1201, 'Numerical Control error : unkwnown type')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** SIMULATION ***
|
|
---------------------------------------------------------------------
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulStart()
|
|
-- controllo versione programma
|
|
if not EMT.VER or EMT.VER < MIN_MACH_VER then
|
|
EmtSetLastError( 1200, 'A newer version of the program is required (minimum EgtMachKernel '..MIN_MACH_VER..')')
|
|
end
|
|
-- Carico gli utensili sulle barre portautensili
|
|
local vTcPos = EgtGetAllTcPosNames()
|
|
if vTcPos then
|
|
for i = 1, #vTcPos do
|
|
local vTools = EgtGetToolsInCurrSetupPos( vTcPos[i])
|
|
for j = 1, #( vTools or {}) do
|
|
if vTools[j] ~= '' then
|
|
EgtLoadTool( vTcPos[i], j, vTools[j])
|
|
end
|
|
end
|
|
ShowToolInTcPos( vTcPos[i], true)
|
|
end
|
|
end
|
|
|
|
-- 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( 'C', 'COLLISION', EMT.COLLOBJ)
|
|
AddToCollisionCheck( 'A', '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 = 'PL1', Sub = 'COLLISION', Name = 'STM'},
|
|
{ Grp = 'PL2', Sub = 'COLLISION', Name = 'STM'},
|
|
{ Grp = 'PL3', Sub = 'COLLISION', Name = 'STM'},
|
|
{ Grp = 'PL4', Sub = 'COLLISION', Name = 'STM'},
|
|
{ Grp = 'PL5', Sub = 'COLLISION', Name = 'STM'},
|
|
{ Grp = 'PL6', Sub = 'COLLISION', Name = 'STM'}}
|
|
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
|
|
local nId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nGrpId or GDB_ID.NULL, McdData[i].Sub) or GDB_ID.NULL, McdData[i].Name)
|
|
if nId then
|
|
table.insert( EMT.MCODET, nId)
|
|
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name .. ' (' .. tostring( nId) .. ') is ok', 4)
|
|
else
|
|
nMcdNullCnt = nMcdNullCnt + 1
|
|
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name .. ' is null', 4)
|
|
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()
|
|
-- posizioni home degli assi testa
|
|
local HomeX = EgtGetAxisHomePos( 'X')
|
|
local HomeY = EgtGetAxisHomePos( 'Y')
|
|
local HomeZ1 = EgtGetAxisHomePos( 'Z1')
|
|
local HomeC = EgtGetAxisHomePos( 'C')
|
|
local HomeA = EgtGetAxisHomePos( 'A')
|
|
SimulMoveAxes( 'X', HomeX, MCH_SIM_STEP.RAPID, 'Y', HomeY, MCH_SIM_STEP.RAPID,'Z1', HomeZ1, MCH_SIM_STEP.RAPID, 'A', HomeA, MCH_SIM_STEP.COLLROT, 'C', HomeC, MCH_SIM_STEP.COLLROT)
|
|
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.Area = vPiece.Len * vPiece.Wid + vPiece.Len * vPiece.Thk + vPiece.Wid * vPiece.Thk
|
|
table.insert( EMT.PIECES, vPiece)
|
|
nPartRawId = EgtGetNextRawPart( nPartRawId)
|
|
end
|
|
-- Se prima disposizione
|
|
if EMT.PHASE == 1 then
|
|
-- Determino dimensioni del grezzo
|
|
local nSolId = EgtGetFirstNameInGroup( EgtGetFirstRawPart() or GDB_ID.NULL, 'RawSolid') or GDB_ID.NULL
|
|
local b3Sol = EgtGetBBoxGlob( nSolId, GDB_BB.STANDARD)
|
|
EMT.LB = 0
|
|
EMT.SB = 0
|
|
EMT.HB = 0
|
|
if b3Sol then
|
|
EMT.LB = b3Sol:getDimX()
|
|
EMT.SB = b3Sol:getDimY()
|
|
EMT.HB = b3Sol:getDimZ()
|
|
end
|
|
-- Carico primo utensile sulla testa 1
|
|
local sTool, nTlen = FindFirstToolOnHead( 'H11')
|
|
if sTool then
|
|
EMT.TOOL_1 = sTool
|
|
else
|
|
EMT.TOOL_1 = GetDefaultToolName()
|
|
end
|
|
EgtLoadTool( 'H11', 1, EMT.TOOL_1)
|
|
EMT.TCPOS_1 = GetToolTcPos( EMT.TOOL_1)
|
|
ShowToolInTcPos( EMT.TCPOS_1, false)
|
|
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 nPartSolId = EgtGetFirstNameInGroup( EMT.PIECES[i].Id, 'RawSolid')
|
|
local b3PartSol = EgtGetBBoxGlob( nPartSolId, GDB_BB.STANDARD)
|
|
-- determino la risoluzione dello Zmap
|
|
local dTol = 4.71
|
|
if EmtGetVMillStep then
|
|
dTol = EmtGetVMillStep( b3PartSol:getDimX(), b3PartSol:getDimY(), b3PartSol:getDimZ(), 4.71)
|
|
else
|
|
local dArea = b3PartSol:getDimX() * b3PartSol:getDimY() + b3PartSol:getDimX() * b3PartSol:getDimZ() + b3PartSol:getDimY() * b3PartSol:getDimZ()
|
|
if dArea < 0.075e6 then
|
|
dTol = 0.71
|
|
elseif dArea < 0.15e6 then
|
|
dTol = 1.01
|
|
elseif dArea < 0.3e6 then
|
|
dTol = 1.51
|
|
elseif dArea < 0.6e6 then
|
|
dTol = 1.97
|
|
elseif dArea < 1.2e6 then
|
|
dTol = 2.81
|
|
elseif dArea < 2.4e6 then
|
|
dTol = 3.77
|
|
end
|
|
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
|
|
-- 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
|
|
end
|
|
-- fasi successive
|
|
else
|
|
EMT.LOAD = false
|
|
end
|
|
|
|
-- nascondo lavorazioni che risulterebbero in posizione diversa dai pezzi
|
|
local nMchId = EgtGetNextOperation( EgtGetPhaseDisposition( EMT.PHASE))
|
|
while nMchId do
|
|
if EgtGetOperationPhase( nMchId) ~= EMT.PHASE then break end
|
|
EgtSetOperationStatus( nMchId, false)
|
|
nMchId = EgtGetNextOperation( nMchId)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulDispositionEnd()
|
|
-- Se prima disposizione
|
|
if EMT.PHASE == 1 then
|
|
-- Se vero inizio e abilitato creo gli Zmap
|
|
EMT.VMILL = {}
|
|
if not EMT.SIM1ST and EgtGetInfo( EgtGetCurrMachGroup(), 'Vm', 'b') then
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
if EgtVerifyRawPartPhase( nRawId, 1) then
|
|
-- elimino eventuale vecchio Zmap
|
|
EgtErase( EgtGetFirstNameInGroup( nRawId, 'VMill') or GDB_ID.NULL)
|
|
-- recupero il solido
|
|
local nSolId = EgtGetFirstNameInGroup( nRawId, 'RawSolid')
|
|
-- determino la risoluzione dello Zmap
|
|
local b3Sol = EgtGetBBoxGlob( nSolId, GDB_BB.STANDARD)
|
|
local dTol = EmtGetVMillStep( b3Sol:getDimX(), b3Sol:getDimY(), b3Sol:getDimZ(), 2.01)
|
|
-- creo lo Zmap
|
|
local VMillId = EgtVolZmapFromSurfTm( nRawId, nSolId, dTol, true)
|
|
if VMillId then
|
|
EgtSetName( VMillId, 'VMill')
|
|
EgtSetLevel( VMillId, GDB_LV.TEMP)
|
|
EgtSetColor( VMillId, EgtGetColor( nSolId), false)
|
|
-- nascondo le altre geometrie
|
|
local nId = EgtGetFirstInGroup( nRawId)
|
|
while nId do
|
|
if nId ~= VMillId then
|
|
EgtSetStatus( nId, GDB_ST.OFF)
|
|
end
|
|
nId = EgtGetNext( nId)
|
|
end
|
|
table.insert( EMT.VMILL, VMillId)
|
|
end
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
end
|
|
end
|
|
EMT.OPEISDISP = false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulToolSelect()
|
|
-- carico utensile, con breve pausa
|
|
EgtPause( 100)
|
|
EgtOutText( '')
|
|
-- lo nascondo sul portautensili
|
|
ShowToolInTcPos( EMT.TCPOS, false)
|
|
-- se attivo Vmill
|
|
if EMT.VMILL then
|
|
EmtSetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL)
|
|
end
|
|
-- 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
|
|
if EMT.HEAD ~= 'H2' then
|
|
AddToolToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, 1001)
|
|
AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, 1002)
|
|
else
|
|
AddToolToCollisionObj( nil, 'H1', 1, 1001)
|
|
AddToolHolderToCollisionObj( nil, 'H1', 1, 1002)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulToolDeselect()
|
|
-- se utensile non cambia e non è sega a catena, esco
|
|
if EMT.NEXTTOOL == EMT.PREVTOOL then return end
|
|
-- deposito utensile
|
|
EgtOutText( 'Tool change in progress...')
|
|
|
|
if EMT.HEAD == 'H11' then
|
|
SimulMoveAxis( 'Z1', 650, MCH_SIM_STEP.RAPID)
|
|
SimulMoveAxes( 'Y', 2000, MCH_SIM_STEP.RAPID, 'A', 0, MCH_SIM_STEP.RAPROT, 'C', 0, MCH_SIM_STEP.RAPROT)
|
|
-- visualizzo utensile su TcPos
|
|
ShowToolInTcPos( EMT.PREVTCPOS, true)
|
|
-- nascondo l'utensile sulla testa
|
|
EgtSetMode( EgtGetHeadId( EMT.PREVHEAD or '') or GDB_ID.NULL, GDB_MD.HIDDEN)
|
|
elseif EMT.NEXTHEAD == 'H11' then
|
|
SimulMoveAxis( 'Z2', 400, MCH_SIM_STEP.RAPID)
|
|
SimulMoveAxis( 'Y', 2000, MCH_SIM_STEP.RAPID)
|
|
end
|
|
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulMachiningStart()
|
|
EMT.MCHTYPE = EgtGetMachiningParam( MCH_MP.TYPE)
|
|
EMT.MCHNAME = EgtGetMachiningParam(MCH_MP.NAME)
|
|
EMT.NOTES = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
EMT.VMRS = ( EMT.MCHTYPE ~= MCH_MY.DRILLING and EgtGetValInNotes( EMT.NOTES or '', 'VMRS', 'i') ~= 0)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulMachiningEnd()
|
|
EMT.PREVTOOL = EMT.TOOL
|
|
EMT.PREVHEAD = EMT.HEAD
|
|
EMT.PREVTCPOS = EMT.TCPOS
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulPathStart()
|
|
if EMT.HEAD == 'H21' then
|
|
-- attivazione uscite
|
|
EMC = { HEADID = EgtGetHeadId( 'H21'), DRACEX = EMT.DRACEX}
|
|
OnActivateDrillingUnit()
|
|
EMC = nil
|
|
-- impostazione utensili aggiuntivi per Vmill
|
|
if EMT.VMILL then
|
|
for i = 1, #( EMT.DRACEX or {}) do
|
|
local nExit = EMT.DRACEX[i]
|
|
local sTool = EgtGetLoadedTool( EMT.HEAD, nExit)
|
|
if i == 1 then
|
|
EmtSetToolForVmill( sTool, EMT.HEAD, nExit, EMT.VMILL)
|
|
else
|
|
EmtAddToolForVmill( sTool, EMT.HEAD, nExit, EMT.VMILL)
|
|
end
|
|
end
|
|
end
|
|
elseif EMT.HEAD == 'H22' then
|
|
-- attivazione testa
|
|
EMC = { HEADID = EgtGetHeadId( 'H22'), ACTIVE = true}
|
|
OnActivateAngTransm()
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulPathEnd()
|
|
if EMT.VMILL and #EMT.VMILL > 0 and not EMT.OPEISDISP and EMT.VMRS then
|
|
-- elimino eventuali sfridi
|
|
for j = 1, #EMT.VMILL do
|
|
local vMillId = EMT.VMILL[j]
|
|
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
|
|
EgtRemoveVolZmapPart( vMillId, i - 1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
EgtDraw()
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulMoveStart()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulMoveEnd()
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSimulCollision()
|
|
-- se prima collisione della lavorazione, la segnalo
|
|
if EMT.MCHNAME ~= EMT.LAST_MCHNAME_COLLIDE then
|
|
-- speciale per utensile flottante (suo holder contro il grezzo)
|
|
if EMT.TFLOAT and EMT.TFLOAT_CMP and EMT.SIMCOBIND == 1002 and EMT.SIMVMID == EMT.VMILL[1] then
|
|
if EMT.MOVEID == EMT.TFLOAT_CMP then
|
|
EMT.TFLOAT_TH_COMPR_COLL = true
|
|
end
|
|
return
|
|
end
|
|
-- standard
|
|
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 = 'CUTID='..tostring( EMT.CUTID)..'; TASKID='..tostring( EMT.TASKID)..'; Mach='..EMT.MCHNAME..'; Class='..Class..'; VMill='..EMT.SIMVMID
|
|
EmtSetLastError( 1221, sErr, true)
|
|
EgtOutLog( 'Collision : ' .. sErr, 1)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** GENERAL ***
|
|
---------------------------------------------------------------------
|
|
function FindFirstToolOnHead( sH1)
|
|
-- salvo stato iniziale
|
|
local CurrMachId = EgtGetCurrMachining()
|
|
local CurrTool = EgtTdbGetCurrToolParam( MCH_TP.NAME)
|
|
-- cerco lavorazione con utensile su testa indicata
|
|
local sTool, nTlen
|
|
local OpId = EgtGetFirstActiveOperation()
|
|
while OpId do
|
|
local nType = EgtGetOperationType( OpId)
|
|
if nType ~= MCH_OY.NONE and nType ~= MCH_OY.DISP then
|
|
if EgtSetCurrMachining( OpId) then
|
|
local sTest = EgtGetMachiningParam( MCH_MP.TOOL)
|
|
if EgtTdbSetCurrTool( sTest) then
|
|
local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
if sHead and ( sHead == sH1) then
|
|
sTool = sTest
|
|
nTlen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
OpId = EgtGetNextActiveOperation( OpId)
|
|
end
|
|
-- ripristino stato iniziale
|
|
if CurrMachId then
|
|
EgtSetCurrMachining( CurrMachId)
|
|
else
|
|
EgtResetCurrMachining()
|
|
end
|
|
if CurrTool then
|
|
EgtTdbSetCurrTool( CurrTool)
|
|
else
|
|
EgtTdbSetCurrTool( '')
|
|
end
|
|
-- restituisco risultato
|
|
return sTool, nTlen
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function ShowToolInTcPos( sTcPos, bShow)
|
|
-- recupero identificativo della posizione sul TC
|
|
local TcPosId = EgtGetTcPosId( sTcPos or '')
|
|
if not TcPosId then return end
|
|
-- ciclo sulle possibili uscite
|
|
for i = 1, 100 do
|
|
-- recupero il gruppo dell'utensile
|
|
local TcExitId = EgtGetFirstNameInGroup( TcPosId, 'T'..tostring( i))
|
|
if not TcExitId then break end
|
|
-- imposto lo stato di visualizzazione
|
|
EgtSetStatus( TcExitId, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF))
|
|
end
|
|
-- recupero eventuale gruppo ausiliario da visualizzare/nascondere
|
|
local TcHSId = EgtGetFirstNameInGroup( TcPosId, sTcPos..'_HS')
|
|
if TcHSId then EgtSetStatus( TcHSId, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetDefaultToolName()
|
|
local DefTcPos = 'T1'
|
|
local vTools = EgtGetToolsInCurrSetupPos( DefTcPos)
|
|
if vTools and vTools[1] and #vTools[1] > 0 then
|
|
return vTools[1]
|
|
else
|
|
-- local sErr = 'Missing tool in Default Position ' .. DefTcPos
|
|
-- EgtOutLog( 'Error : ' .. sErr)
|
|
-- EgtOutBox( sErr, 'ERROR', 'ERROR')
|
|
return ''
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetToolTcPos( sTool)
|
|
-- salvo stato iniziale
|
|
local CurrTool = EgtTdbGetCurrToolParam( MCH_TP.NAME)
|
|
-- recupero la posizione di cambio utensile dell'utensile indicato
|
|
local sTcPos
|
|
if EgtTdbSetCurrTool( sTool) then
|
|
sTcPos = EgtTdbGetCurrToolParam( MCH_TP.TCPOS)
|
|
end
|
|
-- ripristino stato iniziale
|
|
if CurrTool then
|
|
EgtTdbSetCurrTool( CurrTool)
|
|
else
|
|
EgtTdbSetCurrTool( '')
|
|
end
|
|
-- restituisco risultato
|
|
return sTcPos
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function MoveHead( nGrpId, vtVers, dPos, bLoc)
|
|
local dVal = EgtGetInfo( nGrpId or GDB_ID.NULL, 'Val')
|
|
if not dVal then return end
|
|
if abs( dPos - dVal) > GEO.EPS_SMALL then
|
|
local nRT = EgtIf( bLoc, GDB_RT.LOC, GDB_RT.GLOB)
|
|
EgtMove( nGrpId, ( dPos - dVal) * vtVers, nRT)
|
|
EgtSetInfo( nGrpId, 'Val', dPos)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function ExecUnloading()
|
|
if EMT.VMILL then
|
|
local vMillId = EMT.VMILL
|
|
-- gruppo dei Vmill
|
|
local nVmGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'VMill')
|
|
-- creo un nuovo layer e vi inserisco il nuovo pezzo
|
|
local nLayId = EgtGroup( nVmGrpId, EgtGetGlobFrame( vMillId))
|
|
EgtRelocate( vMillId, nLayId)
|
|
EgtSetLevel( vMillId, GDB_LV.USER)
|
|
-- aggiungo gli spigoli
|
|
if EgtVolZmapSetShowEdges then
|
|
EgtVolZmapSetShowEdges( vMillId, true)
|
|
else
|
|
local nFirstId, nCount = EgtVolZmapGetEdges( vMillId, nLayId)
|
|
if nFirstId then
|
|
for nId = nFirstId, nFirstId + nCount - 1 do
|
|
EgtSetColor( nId, Color3d( 96, 96, 96))
|
|
end
|
|
end
|
|
end
|
|
-- rilascio Vmill
|
|
EMT.VMILL = nil
|
|
-- aggiorno la visualizzazione
|
|
EgtDraw()
|
|
-- se impostato di salvare i Vmill, lo faccio
|
|
local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini'
|
|
if EgtGetStringFromIni( 'VMill', 'Save', '', sMachIni) == '1' then
|
|
local sFile = EgtGetCurrFilePath()
|
|
if sFile then
|
|
local sDir, sName, sExt = EgtSplitPath( sFile)
|
|
if sExt and sExt:lower() == ".nge" then
|
|
sName = sName .. '_VM_' .. EgtGetMachGroupName( EgtGetCurrMachGroup())
|
|
EgtSetLevel( nVmGrpId, GDB_LV.USER)
|
|
EgtSaveObjToFile( nVmGrpId, sDir .. sName .. '.Nge')
|
|
EgtSetLevel( nVmGrpId, GDB_LV.TEMP)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- *** STIMA T&L ***
|
|
---------------------------------------------------------------------
|
|
local RAPID_X_FEED = 20000 -- mm/min
|
|
local RAPID_Y_FEED = 20000 -- mm/min
|
|
local RAPID_Z_FEED = 10000 -- mm/min
|
|
local RAPID_C_FEED = 3600 -- deg/min
|
|
local RAPID_B_FEED = 3600 -- deg/min
|
|
local RAPID_MIN_T = 1.0 -- s
|
|
local UNLOAD_RAW_T = 60 -- 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( 'X')
|
|
EMT.L2 = EgtGetAxisHomePos( 'Y')
|
|
EMT.L3 = EgtGetAxisHomePos( 'Z1')
|
|
EMT.R1 = EgtGetAxisHomePos( 'C')
|
|
EMT.R2 = EgtGetAxisHomePos( 'A')
|
|
-- aggiorno valori come precedenti
|
|
EmtUpdatePrev()
|
|
-- totalizzatori tempi e lunghezze
|
|
EMT.TOTCUTLEN = 0
|
|
EMT.TOTCUTTIME = 0
|
|
EMT.TOTEXTLEN = 0
|
|
EMT.TOTEXTTIME = 0
|
|
-- variabile per lunghezza taglio utensili
|
|
EMT.TOOLCUTLEN = {}
|
|
-- intestazioni
|
|
EmtTleStart( EMT.INFO)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnEstimProgramEnd()
|
|
-- stampa dei totali delle lavorazioni
|
|
EmtTleAddTotal( EmtSecToHMS( EMT.TOTCUTTIME + EMT.TOTEXTTIME), 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 + EMT.TOTEXTTIME, 0))
|
|
EgtSetInfo( EgtGetCurrMachGroup(), 'Ltot', EgtNumToString( EMT.TOTCUTLEN, 0))
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnEstimDispositionStart()
|
|
-- inizioe disposizione
|
|
EMT.OPEISDISP = true
|
|
-- non va fatto alcunché
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnEstimDispositionEnd()
|
|
-- termine disposizione
|
|
EMT.OPEISDISP = false
|
|
-- non va fatto alcunché
|
|
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
|
|
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 = 0
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnEstimMachiningEnd()
|
|
local sName = EgtGetName( EMT.MCHID) .. ' (' .. EMT.MCHNAME .. ')'
|
|
EmtTleAddMachining( sName, EmtSecToHMS( EMT.MCHCUTTIME + EMT.MCHEXTTIME), EmtLenToMF( EMT.MCHCUTLEN), EMT.TOOL)
|
|
-- aggiorno totali e utensili
|
|
EMT.TOTCUTLEN = EMT.TOTCUTLEN + EMT.MCHCUTLEN
|
|
EMT.TOTCUTTIME = EMT.TOTCUTTIME + EMT.MCHCUTTIME
|
|
EMT.TOTEXTLEN = EMT.TOTEXTLEN + EMT.MCHEXTLEN
|
|
EMT.TOTEXTTIME = EMT.TOTEXTTIME + EMT.MCHEXTTIME
|
|
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
|
|
if EMT.R1 and EMT.R1p then dR1 = EMT.R1 - EMT.R1p end
|
|
local dR2 = 0
|
|
if EMT.R2 and EMT.R2p then dR2 = EMT.R2 - EMT.R2p end
|
|
-- calcolo lunghezza
|
|
local dLen = sqrt( dL1 * dL1 + dL2 * dL2 + dL3 * dL3)
|
|
if not EMT.OPEISDISP then
|
|
EMT.MCHEXTLEN = EMT.MCHEXTLEN + dLen
|
|
else
|
|
EMT.DSPEXTLEN = EMT.DSPEXTLEN + dLen
|
|
end
|
|
-- 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 * 1000) * 60
|
|
EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
|
|
EgtOutLog( string.format( ' G1 Len=%.0f Time=%.2f', dLen, dTime), 5)
|
|
-- 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 * 1000) * 60
|
|
EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
|
|
EgtOutLog( string.format( ' G2 Len=%.0f Time=%.2f', dLen, dTime), 5)
|
|
-- aggiorno valori come precedenti
|
|
EmtUpdatePrev()
|
|
end
|