primo commit
This commit is contained in:
luca.mazzoleni
@@ -0,0 +1,752 @@
|
||||
-- Processore macchina Essetre-WallXS by EgalTech s.r.l. 2022/08/03
|
||||
-- Con controllo numerico TPA
|
||||
-- 2021/12/10 DS Prima versione
|
||||
-- 2022/05/05 DS ver 2.4e1 Ora Nailing emette feed di lavoro.
|
||||
-- 2022/05/12 DS ver 2.4e3 Ora Nailing usa Z di lavorazione come PodBau (affondamento == lughezza utensile).
|
||||
|
||||
-- Variabili di modulo
|
||||
local MLE_INFO = 'Essetre-WallXS.TPA.mlpe ver.'..PP_VER..' by Egalware s.r.l.'
|
||||
local TEST_USE = false
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** GENERATION ***
|
||||
---------------------------------------------------------------------
|
||||
function OnStart()
|
||||
-- controllo versione programma
|
||||
if not EMT.VER or EMT.VER < '2.5d1' then
|
||||
EmtSetLastError( 1200, 'A newer version of the program is required (minimum EgtMachKernel 2.5d1)')
|
||||
end
|
||||
EMT.USETO1 = false -- abilitazione uso origine tavola
|
||||
EMT.MODAL = true -- abilitazione emissione modale
|
||||
EMT.INCHES = false -- unità di misura mm/inches
|
||||
EMT.NUM = false -- abilitazione numerazione linee
|
||||
--EMT.Nt = 'N' -- token per la numerazione di linea
|
||||
--EMT.LINENBR = 0 -- numero di linea
|
||||
--EMT.LINEINC = 1 -- incremento numerazione linee
|
||||
--EMT.Ft = 'F' -- token per feed
|
||||
--EMT.St = 'S' -- token per speed
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEnd()
|
||||
-- Ripristino fase iniziale come corrente
|
||||
EgtSetCurrPhase( 1)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnProgramStart()
|
||||
-- Info da gruppo BtlInfo
|
||||
local BtlInfoId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'BtlInfo') or EgtGetCurrMachGroup() or GDB_ID.NULL
|
||||
EMT.LOAD90 = EgtGetInfo( BtlInfoId, 'LOAD90', 'i') or 0
|
||||
local nRefPos = EgtClamp( EgtGetInfo( BtlInfoId, 'REFPOS', 'i') or 1, 1, 8)
|
||||
if nRefPos <= 4 then
|
||||
EMT.ORIG = nRefPos
|
||||
else
|
||||
EMT.ORIG = nRefPos + 6
|
||||
end
|
||||
-- Intestazioni
|
||||
if not TEST_USE then
|
||||
EMT.PRODID = EgtGetInfo( BtlInfoId, 'PRODID', 'i') or 0
|
||||
EMT.PATTID = EgtGetInfo( BtlInfoId, 'PATTID', 'i') or 0
|
||||
end
|
||||
EmtOutput( ';LISTA = ' .. tostring( EMT.PRODID or 0))
|
||||
if EMT.INFO then
|
||||
EmtOutput( ';'..EMT.INFO)
|
||||
else
|
||||
EmtOutput( ';Program Start')
|
||||
end
|
||||
EmtOutput( ';'.. MLE_INFO)
|
||||
-- Indice lavorazione
|
||||
EMT.CNT = 0
|
||||
-- Non effettuate lavorazioni con sega a catena sul fianco
|
||||
EMT.CSAWFIRST = true
|
||||
-- Non effettuata pausa per rimozione sfridi
|
||||
EMT.SCRAPFIRST = true
|
||||
-- Cerco primo utensile su testa 1
|
||||
EMT.TOOL_1, EMT.TLEN_1 = FindFirstToolOnHead( 'H1')
|
||||
-- Inizializzazioni varie
|
||||
EmtOutput( 'M6 T000000')
|
||||
EmtOutput( 'G49')
|
||||
-- Inizio lista utensili
|
||||
EmtOutput( 'M993 (Tool List Start)')
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnProgramEnd()
|
||||
EmtOutput( '; *** Program End ***')
|
||||
EmitCount( false)
|
||||
EmtOutput( 'M117 P1=0')
|
||||
-- Dichiarazione conclusione pezzi
|
||||
if EMT.PRODID then
|
||||
local sOut = 'M113 P1='..tostring( EMT.PRODID)..' P2='..tostring( EMT.PATTID)..' P3='..tostring( -1)..' P4=2'
|
||||
EmtOutput( sOut)
|
||||
end
|
||||
-- Arresto mandrino
|
||||
EmtOutput( 'M05')
|
||||
-- Tipo di scarico
|
||||
if not TEST_USE then
|
||||
EmtOutput( 'M116')
|
||||
end
|
||||
-- Termino il programma
|
||||
EmtOutput( 'M02')
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnToolData()
|
||||
-- emissione dati utensili
|
||||
if EMT.HEAD == 'H1' then
|
||||
local sOut = 'M992 P1=' .. EMT.TCPOS:gsub( 'T', '') .. ' P2=' .. EmtLenToString( EMT.TLEN, 3) .. ' P3=' .. EmtLenToString( EMT.TDIAM, 3) ..
|
||||
' P4=' .. EmtLenToString( EMT.SMAX, 3) .. ' P5=' .. EmtLenToString( EMT.TTOTLEN, 3)
|
||||
EmtOutput( sOut)
|
||||
-- cerco posizione di attrezzaggio del primo utensile di lavorazione
|
||||
if EMT.TOOL == EMT.TOOL_1 and EMT.TLEN_1 < 215.5 then
|
||||
EMT.TCPOS_1 = EMT.TCPOS
|
||||
end
|
||||
-- emissione dati lama
|
||||
elseif EMT.HEAD == 'H2' then
|
||||
local sOut = 'M992 P1=' .. EMT.TCPOS:gsub( 'T', '') .. ' P2=' .. EmtLenToString( -SawOffsZ + EMT.TLEN, 3) .. ' P3=' .. EmtLenToString( EMT.TDIAM, 3) ..
|
||||
' P4=' .. EmtLenToString( EMT.SMAX, 3) .. ' P5=' .. EmtLenToString( EMT.TTOTLEN, 3)
|
||||
EmtOutput( sOut)
|
||||
-- emissione dati sega a catena
|
||||
elseif EMT.HEAD == 'H3' then
|
||||
if EMT.TDIST and abs( EMT.TDIST) < 0.1 then EMT.TDIST = nil end
|
||||
local sData = ' P2=' .. EmtLenToString( ( EMT.TDIST or ChSawLen), 3) .. ' P3=' .. EmtLenToString( EMT.TLEN, 3) ..
|
||||
' P4=' .. EmtLenToString( EMT.SMAX, 3) .. ' P5=' .. EmtLenToString( (EMT.TDIST or ChSawLen), 3)
|
||||
EmtOutput( 'M992 P1=8' .. sData)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnDispositionStart()
|
||||
--EmtOutput( '(Disposition '..EMT.DISPIND..' = '..EMT.DISPID..')')
|
||||
EMT.OPEISDISP = true
|
||||
-- Se prima disposizione
|
||||
if EMT.PHASE == 1 then
|
||||
-- terminazione lista utensili
|
||||
EmtOutput( 'G990 (Tool List End)')
|
||||
-- Parametri macchina
|
||||
local d1stNailX, d1stNailY, d1stNailZ = 0, 0, 0
|
||||
if Nail11 ~= 0 then
|
||||
d1stNailX = DeltaTabY + DimTabY - Nail11DeltaY
|
||||
d1stNailY = -DeltaTabX + Nail11DeltaX
|
||||
d1stNailZ = DeltaTabZ - Nail11DeltaZ
|
||||
end
|
||||
local d2ndNailX, d2ndNailY, d2ndNailZ = 0, 0, 0
|
||||
if Nail12 ~= 0 then
|
||||
d2ndNailX = DeltaTabY + DimTabY - Nail12DeltaY
|
||||
d2ndNailY = -DeltaTabX + Nail12DeltaX
|
||||
d2ndNailZ = DeltaTabZ - Nail12DeltaZ
|
||||
end
|
||||
local sOut = 'M114'..' P1='..EgtNumToString( DeltaTabY + DimTabY, 2)..' P2='..EgtNumToString( -DeltaTabX, 2)..
|
||||
' P3='..EgtNumToString( DeltaTabZ - MillOffs, 2)..' P4='..EgtNumToString( d1stNailX, 2)..
|
||||
' P5='..EgtNumToString( d1stNailY, 2)..' P6='..EgtNumToString( d1stNailZ, 2)..
|
||||
' P7='..EgtNumToString( d2ndNailX, 2)..' P8='..EgtNumToString( d2ndNailY, 2)..
|
||||
' P9='..EgtNumToString( d2ndNailZ, 2)..' P10='..EgtNumToString( MillOffs, 2)..
|
||||
' P11='..EgtNumToString( Orig3DeltaY, 2)..' P12='..EgtNumToString( -Orig3DeltaX, 2)..' P13='..EgtNumToString( Orig3DeltaZ, 2)..
|
||||
' P14='..EgtNumToString( Orig5DeltaY, 2)..' P15='..EgtNumToString( -Orig5DeltaX, 2)..' P16='..EgtNumToString( Orig5DeltaZ, 2)..
|
||||
' P17='..EgtNumToString( Orig7DeltaY, 2)..' P18='..EgtNumToString( -Orig7DeltaX, 2)..' P19='..EgtNumToString( Orig7DeltaZ, 2)
|
||||
EmtOutput( sOut)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnDispositionEnd()
|
||||
-- Se prima disposizione
|
||||
if EMT.PHASE == 1 then
|
||||
-- Dimensioni grezzo
|
||||
local b3Raw = EgtGetRawPartBBox( EMT.RAWID)
|
||||
local sOut = 'M115 P1='..EgtNumToString( b3Raw:getDimY(), 0)..' P2='..EgtNumToString( b3Raw:getDimX(), 0)..
|
||||
' P3='..EgtNumToString( b3Raw:getDimZ(), 0)..' P4='..EgtNumToString( EMT.ORIG, 0)
|
||||
EmtOutput( sOut)
|
||||
EMT.ST = b3Raw:getDimZ()
|
||||
-- Posizione cuffia
|
||||
--local dHCuff = b3Raw:getDimZ() + 32
|
||||
--EmtOutput( 'E30039=' .. EgtNumToString( dHCuff * 1000, 0))
|
||||
-- Eventuale salto a lavorazione in corso
|
||||
--EmtOutput( 'G79 NE80000')
|
||||
-- Lancio del carico
|
||||
if not TEST_USE then
|
||||
; --EmtOutput( 'M26 E30054=' .. EgtNumToString( EMT.ORIG, 0))
|
||||
end
|
||||
-- Dichiarazione inizio lavorazione pezzi
|
||||
if EMT.PRODID then
|
||||
local sOut = 'M113 P1='..tostring( EMT.PRODID)..' P2='..tostring( EMT.PATTID)..' P3='..tostring( -1)..' P4=1'
|
||||
EmtOutput( sOut)
|
||||
end
|
||||
end
|
||||
EMT.OPEISDISP = false
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnTableData()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnFixtureData()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnRawMoveData()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnToolSelect()
|
||||
-- se utensile definito (non definito per disposizioni con movimento)
|
||||
if EMT.TOOL ~= '' then
|
||||
-- verifiche su utensile
|
||||
local sTool = EgtTdbGetToolFromUUID( EgtGetMachiningParam( MCH_MP.TUUID) or "")
|
||||
if sTool ~= EMT.TOOL then error( "Tool name mismatch") end
|
||||
-- predefinite EMT.TCPOS EMT.HEAD EMT.EXIT
|
||||
EMT.TOOLTYPE = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
|
||||
EMT.TOOLSEL = EMT.TCPOS..' M06'
|
||||
EMT.TDIAM = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
||||
EMT.TTOTDIAM = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM)
|
||||
EMT.TLEN = EgtTdbGetCurrToolParam( MCH_TP.LEN)
|
||||
EMT.TTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
||||
if MCH_TP.DIST then EMT.TDIST = EgtTdbGetCurrToolParam( MCH_TP.DIST) end
|
||||
if EMT.TDIST and abs( EMT.TDIST) < 0.1 then EMT.TDIST = nil end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnToolDeselect()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnMachiningStart()
|
||||
--EMT.MCHLIBNAME = EgtGetMachiningParam( MCH_MP.NAME)
|
||||
EMT.MCHNAME = EgtGetOperationName( EMT.MCHID)
|
||||
EMT.MCHTYPE = EgtGetMachiningParam(MCH_MP.TYPE)
|
||||
-- non ancora iniziata la lavorazione
|
||||
EMT.MCHFIRST = true
|
||||
-- primo posizionamento sempre in globale
|
||||
EMT.REFLOC = nil
|
||||
EMT.IPLGL = false
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnMachiningEnd()
|
||||
if not EMT.ZMAX then
|
||||
EmtOutput( 'G27')
|
||||
EmtOutput( 'M6 T000000')
|
||||
EmtOutput( 'M99')
|
||||
EmtOutput( 'M117 P1='..tostring( EMT.CNT+1))
|
||||
end
|
||||
EMT.PREVTOOL = EMT.TOOL
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnPathStart()
|
||||
-- reset valori precedenti (per forzare emissione di tutti gli assi del 1° movimento)
|
||||
EmtResetPrev()
|
||||
EMT.FEED_FIRST = true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnPathEnd()
|
||||
if IsNailingHead( EMT.HEAD) then
|
||||
EmtOutput( EgtIf( EMT.HEAD == 'H11', 'M6 T200000', 'M6 T300000'))
|
||||
EmtOutput( 'M101 P1='..EmtLenToString( EMT.NAIL_START_L2o, 3)..' P2='..EmtLenToString( -EMT.NAIL_START_L1o, 3)..' P3='..EmtLenToString( EMT.NAIL_START_L3o, 3))
|
||||
EmtOutput( 'G24'..EMT.NAIL_END)
|
||||
local bMoreNails = ( abs( EMT.NAIL_END_L1 - EMT.NAIL_START_L1) > 10 or abs( EMT.NAIL_END_L2 - EMT.NAIL_START_L2) > 10)
|
||||
local dStep = GetValNotes( EgtGetMachiningParam( MCH_MP.USERNOTES), 'Par', 'd') or 100
|
||||
local dSafeZ = EMT.ST + ( max( EgtGetMachiningParam( MCH_MP.STARTPOS), 10) or 20)
|
||||
local dDepth = EMT.NAIL_START_L3
|
||||
EMT.FP = nil
|
||||
EMT.F = EgtGetMachiningParam( MCH_MP.FEED) or 9876
|
||||
local sFeed = EmtGetFeed()
|
||||
EmtOutput( 'G0 X'..EmtLenToString( EMT.NAIL_START_L1, 3)..' Y'..EmtLenToString( EMT.NAIL_START_L2, 3)..' Z'..EmtLenToString( dSafeZ, 3))
|
||||
EmtOutput( EgtIf( EMT.HEAD == 'H11', 'M121', 'M131'))
|
||||
EmtOutput( 'G1 X'..EmtLenToString( EMT.NAIL_START_L1, 3)..' Y'..EmtLenToString( EMT.NAIL_START_L2, 3)..' Z'..EmtLenToString( dDepth, 3)..sFeed)
|
||||
if bMoreNails then
|
||||
EmtOutput( EgtIf( EMT.HEAD == 'H11', 'M122', 'M132')..' P1='..EmtLenToString( dStep, 3))
|
||||
EmtOutput( 'G1 X'..EmtLenToString( EMT.NAIL_END_L1, 3)..' Y'..EmtLenToString( EMT.NAIL_END_L2, 3)..' Z'..EmtLenToString( dDepth, 3)..sFeed)
|
||||
EmtOutput( EgtIf( EMT.HEAD == 'H11', 'M123', 'M133'))
|
||||
EmtOutput( 'G0 X'..EmtLenToString( EMT.NAIL_END_L1, 3)..' Y'..EmtLenToString( EMT.NAIL_END_L2, 3)..' Z'..EmtLenToString( dSafeZ, 3))
|
||||
else
|
||||
EmtOutput( EgtIf( EMT.HEAD == 'H11', 'M122', 'M132')..' P1=0')
|
||||
EmtOutput( EgtIf( EMT.HEAD == 'H11', 'M123', 'M133'))
|
||||
EmtOutput( 'G0 X'..EmtLenToString( EMT.NAIL_START_L1, 3)..' Y'..EmtLenToString( EMT.NAIL_START_L2, 3)..' Z'..EmtLenToString( dSafeZ, 3))
|
||||
end
|
||||
end
|
||||
EMT.FEED_FIRST = nil
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnRapid()
|
||||
-- se primo movimento della lavorazione, gestione speciale
|
||||
if EMT.MCHFIRST and not EMT.OPEISDISP then
|
||||
MyAdjustLinearAxes()
|
||||
EmtAdjustRotaryAxes()
|
||||
EmtOutput( '; *** '..EMT.MCHNAME..'/'..EMT.TOOL..' ***')
|
||||
EmitCount( true)
|
||||
-- se lavorazione con sega a catena
|
||||
if EMT.HEAD == 'H3' then
|
||||
-- se prima lavorazione sui fianchi con sega a catena
|
||||
if EMT.CSAWFIRST and string.sub( EMT.MCHNAME, 1, 5) == 'Csaw_' then
|
||||
EMT.CSAWFIRST = false
|
||||
-- pausa per rimozione sfridi
|
||||
local b3Raw = EgtGetRawPartBBox( EMT.RAWID)
|
||||
local ParkY = min( -( b3Raw:getMin():getX() - 2000), -MinY)
|
||||
EmtOutput( ';M104 Y' .. EmtLenToString( ParkY, 3) .. ' ET1' .. GetEF())
|
||||
-- pre-posizionamento
|
||||
EmtResetPrev()
|
||||
local sOut = 'M101' .. GetAxisParam( 'R1', 'P5=')
|
||||
EmtOutput( sOut)
|
||||
end
|
||||
-- altrimenti verifico se necessaria pausa
|
||||
else
|
||||
if EMT.SCRAPFIRST and EgtExistsInfo( EMT.MCHID, 'MOVE_AFTER') then
|
||||
EMT.SCRAPFIRST = false
|
||||
-- pausa per rimozione sfridi
|
||||
local b3Raw = EgtGetRawPartBBox( EMT.RAWID)
|
||||
local ParkY = min( -( b3Raw:getMin():getX() - 2000), -MinY)
|
||||
EmtOutput( ';M104 Y' .. EmtLenToString( ParkY, 3) .. ' ET1' .. GetEF())
|
||||
end
|
||||
end
|
||||
-- dichiarazione testa e utensile
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
EmtOutput( 'M6 T101' .. AdjustTcPos( true))
|
||||
local Speed = EMT.S * EgtIf( EMT.HEAD ~= 'H2', 1, 1.65)
|
||||
if Speed > 0 then
|
||||
EmtOutput( 'M3 S' .. EgtNumToString( abs( Speed), 0))
|
||||
else
|
||||
EmtOutput( 'M4 S' .. EgtNumToString( abs( Speed), 0))
|
||||
end
|
||||
-- primo posizionamento
|
||||
EmtResetPrev()
|
||||
local sOut = 'M101' .. GetAxisParam( 'L2', 'P1=') .. GetAxisParam( 'L1', 'P2=') .. GetAxisParam( 'L3', 'P3=') ..
|
||||
GetAxisParam( 'R2', 'P4=') .. GetAxisParam( 'R1', 'P5=')
|
||||
EmtOutput( sOut)
|
||||
end
|
||||
EMT.REFLOC = 0
|
||||
EMT.MCHFIRST = false
|
||||
EMT.ZMAX = false
|
||||
-- se standard
|
||||
elseif EMT.FLAG == 0 or EMT.FLAG == 1 or EMT.FLAG == 2 then
|
||||
-- se necessario, impostazione riferimento locale
|
||||
if EMT.REFLOC == 0 then
|
||||
-- calcolo per piano generico
|
||||
CalcInterpPlane()
|
||||
EMT.REFLOC = 1
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
EmtOutput( 'G24'..EMT.IPLGLSTR)
|
||||
end
|
||||
-- trasformo i punti nel piano
|
||||
MyAdjustLinearAxes()
|
||||
EmtAdjustRotaryAxes()
|
||||
EMT.L1p = nil
|
||||
EMT.L2p = nil
|
||||
EMT.L3p = nil
|
||||
EMT.R1p = nil
|
||||
EMT.R2p = nil
|
||||
-- emissione movimento
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
||||
EmtGetAxis('R2')..EmtGetAxis('R1')
|
||||
EmtOutput( sOut)
|
||||
else
|
||||
EMT.NAIL_START_L1o = EMT.L1o
|
||||
EMT.NAIL_START_L2o = EMT.L2o
|
||||
EMT.NAIL_START_L3o = EMT.L3o
|
||||
EMT.NAIL_START_L1 = EMT.L1
|
||||
EMT.NAIL_START_L2 = EMT.L2
|
||||
EMT.NAIL_START_L3 = EMT.L3
|
||||
EMT.NAIL_END_L1 = EMT.L1
|
||||
EMT.NAIL_END_L2 = EMT.L2
|
||||
EMT.NAIL_END = EMT.IPLGLSTR
|
||||
end
|
||||
else
|
||||
MyAdjustLinearAxes()
|
||||
EmtAdjustRotaryAxes()
|
||||
-- emissione movimento
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
||||
EmtGetAxis('R2')..EmtGetAxis('R1')
|
||||
EmtOutput( sOut)
|
||||
else
|
||||
if EMT.L1 then EMT.NAIL_END_L1 = EMT.L1 end
|
||||
if EMT.L2 then EMT.NAIL_END_L2 = EMT.L2 end
|
||||
if EMT.L3 and EMT.L3 < EMT.NAIL_START_L3 then
|
||||
EMT.NAIL_START_L3 = EMT.L3
|
||||
end
|
||||
end
|
||||
end
|
||||
-- se altrimenti risalita a Z max a fine lavorazione
|
||||
elseif EMT.FLAG == 3 then
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
if EMT.REFLOC then
|
||||
EMT.REFLOC = nil
|
||||
EMT.IPLGL = false
|
||||
EmtResetPrev()
|
||||
-- dichiarazione fine lavorazione
|
||||
EmtOutput( 'G27')
|
||||
EmtOutput( 'M6 T000000')
|
||||
EmtOutput( 'M99')
|
||||
EmtOutput( 'M117 P1='..tostring( EMT.CNT+1))
|
||||
MyAdjustLinearAxes()
|
||||
EmtAdjustRotaryAxes()
|
||||
local sOut = 'M101' .. GetAxisParam( 'L3', 'P3=') .. GetAxisParam( 'R2', 'P4=') .. GetAxisParam( 'R1', 'P5=')
|
||||
EmtOutput( sOut)
|
||||
EMT.ZMAX = true
|
||||
end
|
||||
else
|
||||
EMT.TO_ZMAX = true
|
||||
end
|
||||
-- se altrimenti movimento in Home
|
||||
elseif EMT.FLAG == 4 then
|
||||
-- non previsto
|
||||
-- altrimenti errore
|
||||
else
|
||||
error( "Unknown Rapid flag")
|
||||
end
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnLinear()
|
||||
-- se necessario, impostazione riferimento locale
|
||||
if EMT.REFLOC == 0 then
|
||||
-- calcolo per piano generico
|
||||
CalcInterpPlane()
|
||||
EMT.REFLOC = 1
|
||||
-- salvo posizione attuale
|
||||
local OldL1 = EMT.L1
|
||||
local OldL2 = EMT.L2
|
||||
local OldL3 = EMT.L3
|
||||
local OldR1p = EMT.R1p
|
||||
local OldR2p = EMT.R2p
|
||||
-- imposto posizione precedente
|
||||
EMT.L1 = EMT.L1o
|
||||
EMT.L2 = EMT.L2o
|
||||
EMT.L3 = EMT.L3o
|
||||
EMT.R1p = nil
|
||||
EMT.R2p = nil
|
||||
-- trasformo i punti nel piano
|
||||
MyAdjustLinearAxes()
|
||||
EmtAdjustRotaryAxes()
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
EmtOutput( 'G24'..EMT.IPLGLSTR)
|
||||
end
|
||||
-- emissione movimento
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
local sOut = 'G0'..EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
||||
EmtGetAxis('R2')..EmtGetAxis('R1')
|
||||
EmtOutput( sOut)
|
||||
EmtUpdatePrev()
|
||||
EMT.Fp = nil
|
||||
else
|
||||
EMT.NAIL_START_L1o = EMT.L1o
|
||||
EMT.NAIL_START_L2o = EMT.L2o
|
||||
EMT.NAIL_START_L3o = EMT.L3o
|
||||
EMT.NAIL_START_L1 = EMT.L1
|
||||
EMT.NAIL_START_L2 = EMT.L2
|
||||
EMT.NAIL_START_L3 = EMT.L3
|
||||
EMT.NAIL_END_L1 = EMT.L1
|
||||
EMT.NAIL_END_L2 = EMT.L2
|
||||
EMT.NAIL_END = EMT.IPLGLSTR
|
||||
end
|
||||
-- ripristino posizione attuale
|
||||
EMT.L1 = OldL1
|
||||
EMT.L2 = OldL2
|
||||
EMT.L3 = OldL3
|
||||
EMT.R1p = OldR1p
|
||||
EMT.R2p = OldR2p
|
||||
end
|
||||
|
||||
-- aggiustamento valori
|
||||
MyAdjustLinearAxes()
|
||||
EmtAdjustRotaryAxes()
|
||||
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
-- se inizio lavorazione
|
||||
if EMT.FEED_FIRST then
|
||||
EmtOutput( 'M98')
|
||||
EMT.FEED_FIRST = nil
|
||||
end
|
||||
-- valori degli assi
|
||||
local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
||||
EmtGetAxis('R2')..EmtGetAxis('R1')
|
||||
-- se nulla da emettere, esco
|
||||
if #sAxes == 0 then
|
||||
return
|
||||
end
|
||||
-- aggiungo feed
|
||||
local sFeed = EmtGetFeed()
|
||||
-- emetto linea
|
||||
EmtOutput( "G1"..sAxes..sFeed)
|
||||
-- eventuale gestione fondo foro
|
||||
if EMT.FLAG == 101 and EMT.HEAD == 'H5' then
|
||||
EmtOutput( 'M155')
|
||||
end
|
||||
else
|
||||
if EMT.L1 then EMT.NAIL_END_L1 = EMT.L1 end
|
||||
if EMT.L2 then EMT.NAIL_END_L2 = EMT.L2 end
|
||||
if EMT.L3 and EMT.L3 < EMT.NAIL_START_L3 then
|
||||
EMT.NAIL_START_L3 = EMT.L3
|
||||
end
|
||||
end
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnArc()
|
||||
-- non modale su archi
|
||||
local dPrevZ = EMT.L3p
|
||||
EmtResetPrevLinear()
|
||||
-- aggiustamento valori
|
||||
MyAdjustLinearAxes()
|
||||
EmtAdjustRotaryAxes()
|
||||
|
||||
if not IsNailingHead( EMT.HEAD) then
|
||||
-- valori degli assi
|
||||
local sAxes = EmtGetAxis('L1')..EmtGetAxis('L2')..EmtGetAxis('L3')..
|
||||
EmtGetAxis('R2')..EmtGetAxis('R1')
|
||||
-- se nulla da emettere, esco
|
||||
if #sAxes == 0 then
|
||||
return
|
||||
end
|
||||
-- valori delle coordinate del centro
|
||||
EmtAdjustCenterAxes()
|
||||
-- coordinate centro (per ora solo archi nel piano XY)
|
||||
--local sCen = ' ' .. EMT.C1t .. EmtLenToString(EMT.C1,3) ..
|
||||
-- ' ' .. EMT.C2t .. EmtLenToString(EMT.C2,3)
|
||||
-- raggio
|
||||
local sRad = ' ' .. EMT.RRt .. EmtLenToString(EMT.RR,3)
|
||||
-- aggiungo feed
|
||||
local sFeed = EmtGetFeed()
|
||||
-- tipo arco
|
||||
local sArc = 'G' .. EgtNumToString(EMT.MOVE,0)
|
||||
-- emetto arco
|
||||
EmtOutput( sArc..sAxes..sRad..sFeed)
|
||||
else
|
||||
-- Archi non previsti con chiodature
|
||||
EmtSetLastError( 1212, 'Arcs non allowed with nailing')
|
||||
end
|
||||
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function MyAdjustLinearAxes()
|
||||
local MyL1o = EMT.L1
|
||||
local MyL2o = EMT.L2
|
||||
local MyL3o = EMT.L3
|
||||
|
||||
if EMT.REFLOC then
|
||||
local vtDelta = V_NULL()
|
||||
local vtE = V_NULL()
|
||||
if EMT.HEAD == 'H1' then
|
||||
local Len = EMT.TLEN + MillOffs
|
||||
local LenRef = MillOffs
|
||||
local vtTool = EgtGetCalcToolDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
|
||||
vtE = vtTool * Len - Z_AX() * LenRef
|
||||
elseif EMT.HEAD == 'H2' then
|
||||
local Len = EMT.TLEN + MillOffs - SawOffsZ
|
||||
local LenRef = MillOffs
|
||||
local vtTool = EgtGetCalcToolDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
|
||||
vtE = vtTool * Len - Z_AX() * LenRef
|
||||
elseif EMT.HEAD == 'H3' then
|
||||
local Len = ( EMT.TDIST or ChSawLen) + MillOffs
|
||||
local LenRef = MillOffs
|
||||
local vtAux = EgtGetCalcAuxDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
|
||||
vtE = vtAux * Len - Z_AX() * LenRef
|
||||
elseif EMT.HEAD == 'H11' then
|
||||
vtDelta = -Vector3d( Nail11DeltaX, Nail11DeltaY, Nail11DeltaZ)
|
||||
vtE = Z_AX() * EMT.TLEN
|
||||
elseif EMT.HEAD == 'H12' then
|
||||
vtDelta = -Vector3d( Nail12DeltaX, Nail12DeltaY, Nail12DeltaZ)
|
||||
vtE = Z_AX() * EMT.TLEN
|
||||
end
|
||||
EMT.L1 = EMT.L1 - vtDelta:getX() - vtE:getX()
|
||||
EMT.L2 = EMT.L2 - vtDelta:getY() - vtE:getY()
|
||||
EMT.L3 = EMT.L3 - vtDelta:getZ() - DeltaTabZ - vtE:getZ()
|
||||
end
|
||||
|
||||
EmtAdjustLinearAxes()
|
||||
|
||||
EMT.L1o = MyL1o
|
||||
EMT.L2o = MyL2o
|
||||
EMT.L3o = MyL3o
|
||||
|
||||
if not EMT.REFLOC then
|
||||
EMT.L1 = - EMT.L1
|
||||
EMT.L1t = 'Y'
|
||||
EMT.L2t = 'X'
|
||||
else
|
||||
EMT.L1t = 'X'
|
||||
EMT.L2t = 'Y'
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function CalcInterpPlane()
|
||||
-- origine del piano
|
||||
local xS = EMT.START[1]
|
||||
local yS = EMT.START[2]
|
||||
local zS = 0
|
||||
local ptS = Point3d( xS, yS, zS)
|
||||
-- calcolo per piano generico
|
||||
local vtE
|
||||
if EMT.HEAD ~= 'H3' then
|
||||
vtE = EgtGetCalcToolDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
|
||||
else
|
||||
vtE = EgtGetCalcAuxDirFromAngles( EMT.R1, EMT.R2, EMT.R3)
|
||||
end
|
||||
EMT.IPLGLFR = Frame3d( ptS, vtE)
|
||||
--EmtOutput( 'IPLGLFR='..tostring(EMT.IPLGLFR))
|
||||
local vtX = EMT.IPLGLFR:getVersX()
|
||||
local vtY = EMT.IPLGLFR:getVersY()
|
||||
local vtZ = EMT.IPLGLFR:getVersZ()
|
||||
-- A seconda del corner di riferimento scelto
|
||||
local xOut = yS - DeltaTabY - DimTabY
|
||||
local yOut = - ( xS - DeltaTabX)
|
||||
local zOut = zS
|
||||
if EMT.ORIG == 2 then
|
||||
xOut = yS - DeltaTabY
|
||||
yOut = - ( xS - DeltaTabX)
|
||||
elseif EMT.ORIG == 3 then
|
||||
xOut = yS - DeltaTabY - DimTabY
|
||||
yOut = - ( xS - DeltaTabX - Orig3DeltaX)
|
||||
elseif EMT.ORIG == 4 then
|
||||
xOut = yS - DeltaTabY
|
||||
yOut = - ( xS - DeltaTabX - Orig3DeltaX)
|
||||
elseif EMT.ORIG == 11 then
|
||||
xOut = yS - DeltaTabY - DimTabY
|
||||
yOut = - ( xS - DeltaTabX - Orig5DeltaX)
|
||||
elseif EMT.ORIG == 12 then
|
||||
xOut = yS - DeltaTabY
|
||||
yOut = - ( xS - DeltaTabX - Orig5DeltaX)
|
||||
elseif EMT.ORIG == 13 then
|
||||
xOut = yS - DeltaTabY - DimTabY
|
||||
yOut = - ( xS - DeltaTabX - DimTabX)
|
||||
elseif EMT.ORIG == 14 then
|
||||
xOut = yS - DeltaTabY
|
||||
yOut = - ( xS - DeltaTabX - DimTabX)
|
||||
end
|
||||
EMT.IPLGLSTR = ' X' .. EmtLenToString( xOut) ..' Y' .. EmtLenToString( yOut) .. ' Z' .. EmtLenToString( zOut)..
|
||||
' A' .. EgtNumToString( vtX:getY(), 6) .. ' B' .. EgtNumToString( -vtX:getX(), 6) .. ' C' .. EgtNumToString( vtX:getZ(), 6) ..
|
||||
' I' .. EgtNumToString( vtY:getY(), 6) .. ' J' .. EgtNumToString( -vtY:getX(), 6) .. ' K' .. EgtNumToString( vtY:getZ(), 6) ..
|
||||
' P' .. EgtNumToString( vtZ:getY(), 6) .. ' Q' .. EgtNumToString( -vtZ:getX(), 6) .. ' R' .. EgtNumToString( vtZ:getZ(), 6)
|
||||
EMT.IPLGL = true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function AdjustTcPos( bLen3, sTcPos, dAxR3)
|
||||
if not sTcPos then sTcPos = EMT.TCPOS end
|
||||
local sPos = sTcPos:gsub( 'T', '')
|
||||
if bLen3 then
|
||||
if #sPos == 1 then
|
||||
sPos = '00' .. sPos
|
||||
elseif #sPos == 2 then
|
||||
sPos = '0' .. sPos
|
||||
end
|
||||
end
|
||||
if sPos == '101' then
|
||||
if not dAxR3 then dAxR3 = EMT.R3 end
|
||||
if abs( dAxR3 - 0) < 0.1 then
|
||||
sPos = '101'
|
||||
elseif abs( dAxR3 - 270) < 0.1 then
|
||||
sPos = '102'
|
||||
elseif abs( dAxR3 - 180) < 0.1 then
|
||||
sPos = '103'
|
||||
elseif abs( dAxR3 - 90) < 0.1 then
|
||||
sPos = '104'
|
||||
else
|
||||
EmtSetLastError( 1210, 'Chain saw orientation not allowed')
|
||||
end
|
||||
end
|
||||
return sPos
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function GetET()
|
||||
if EMT.HEAD == 'H1' or EMT.HEAD == 'H3' then
|
||||
return ' ET2'
|
||||
elseif EMT.HEAD == 'H2' then
|
||||
return ' ET1'
|
||||
elseif EMT.HEAD == 'H5' then
|
||||
return ' ET3'
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function GetEU()
|
||||
local sEU
|
||||
if EMT.HEAD == 'H1' then
|
||||
sEU = ' EU'..string.sub( EMT.TCPOS, 2)
|
||||
elseif EMT.HEAD == 'H2' then
|
||||
sEU = ' EU0'
|
||||
elseif EMT.HEAD == 'H3' then
|
||||
if abs( EMT.R3 - 0) < 0.1 then
|
||||
sEU = ' EU104'
|
||||
elseif abs( EMT.R3 - 270) < 0.1 then
|
||||
sEU = ' EU101'
|
||||
elseif abs( EMT.R3 - 180) < 0.1 then
|
||||
sEU = ' EU102'
|
||||
elseif abs( EMT.R3 - 90) < 0.1 then
|
||||
sEU = ' EU103'
|
||||
else
|
||||
EmtSetLastError( 1210, 'Chain saw orientation not allowed')
|
||||
end
|
||||
else
|
||||
sEU = ''
|
||||
end
|
||||
return sEU
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function GetEE()
|
||||
return ' EE' .. EgtNumToString( EMT.ORIG, 0)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function GetEF()
|
||||
return ' EF60000'
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function GetAxisParam( Ax, sPar)
|
||||
if EMT[Ax] then
|
||||
local nDec = EMT.DECNUM or 3
|
||||
if not EMT.INCHES or (( Ax == 'R1' or Ax == 'R2' or Ax == 'R3' or Ax == 'R4')) then
|
||||
return ' ' .. sPar .. EgtNumToString( EMT[Ax], nDec), true
|
||||
else
|
||||
return ' ' .. sPar .. EgtNumToString( EMT[Ax] / GEO.ONE_INCH, nDec + 1), true
|
||||
end
|
||||
end
|
||||
return '', false
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function EmitCount( bJump)
|
||||
EMT.CNT = EMT.CNT + 1
|
||||
if bJump then
|
||||
EmtOutput( 'N'..tostring( EMT.CNT)..' IF VGPL > '..tostring( EMT.CNT)..' GOTO N'..tostring( EMT.CNT+1))
|
||||
else
|
||||
EmtOutput( 'N'..tostring( EMT.CNT))
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function IsNailingHead( sHead)
|
||||
return ( sHead == 'H11' or sHead == 'H12')
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function GetValNotes( sNotes, sKey, sType)
|
||||
local vsChunk = EgtSplitString( sNotes or '', ';')
|
||||
local dVal
|
||||
for i = 1, #vsChunk do
|
||||
local dTmp = EgtGetVal( vsChunk[i], sKey, sType)
|
||||
if dTmp then dVal = dTmp end
|
||||
end
|
||||
return dVal
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** END GENERATION ***
|
||||
---------------------------------------------------------------------
|
||||
@@ -0,0 +1,991 @@
|
||||
-- Processore macchina Essetre-WALL by EgalTech s.r.l. 2023/06/27
|
||||
-- Funzioni generiche indipendenti dal controllo
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** GENERATION ***
|
||||
---------------------------------------------------------------------
|
||||
local sBaseDir = EgtGetSourceDir()
|
||||
if NumericalControl == 'NUM' then
|
||||
error( 'Numerical Control error : NUM not yet managed')
|
||||
elseif NumericalControl == 'TPA' then
|
||||
dofile( sBaseDir .. 'Essetre-Wall_XS.TPA.mlpe')
|
||||
else
|
||||
error( 'Numerical Control error : unkwnown type')
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** SIMULATION ***
|
||||
---------------------------------------------------------------------
|
||||
local COLL_SAFE_DIST = 2
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulStart()
|
||||
-- controllo versione programma
|
||||
if not EMT.VER or EMT.VER < '2.5d1' then
|
||||
EmtSetLastError( 1200, 'A newer version of the program is required (minimum EgtMachKernel 2.5d1)')
|
||||
end
|
||||
-- Carico gli utensili sulle barre portautensili
|
||||
local vTcPos = EgtGetAllTcPosNames()
|
||||
if vTcPos then
|
||||
for i = 1, #vTcPos do
|
||||
local vTools = EgtGetToolsInCurrSetupPos( vTcPos[i])
|
||||
if vTools and vTools[1] then
|
||||
EgtLoadTool( vTcPos[i], 1, vTools[1])
|
||||
ShowToolInTcPos( vTcPos[i], true)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- Se reset o home, esco
|
||||
if EMT.SIM1ST then return end
|
||||
-- Non effettuate lavorazioni con sega a catena sul fianco
|
||||
EMT.CSAWFIRST = true
|
||||
-- Non effettuata pausa per rimozione sfridi
|
||||
EMT.SCRAPFIRST = true
|
||||
-- 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( 'B', 'COLLISION', EMT.COLLOBJ)
|
||||
AddToCollisionCheck( 'C', '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 = {}
|
||||
EMT.MCODET[1] = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( EgtGetBaseId( 'Base'), 'COLLISION'), 'STM')
|
||||
-- Preparo lista collisioni vuota
|
||||
EMT.COLLIDE = {}
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulEnd()
|
||||
if EMT.SCRAPFIRST then
|
||||
EMT.SCRAPFIRST = false
|
||||
ExecScrapRemove()
|
||||
end
|
||||
ExecUnloading()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
--function OnSimulDispositionStarting()
|
||||
--end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulDispositionStart()
|
||||
|
||||
EMT.OPEISDISP = true
|
||||
|
||||
-- Se prima disposizione (dovrebbe essere l'unica)
|
||||
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 = FindFirstToolOnHead( 'H1')
|
||||
if sTool then
|
||||
EMT.TOOL_1 = sTool
|
||||
EgtLoadTool( 'H1', 1, EMT.TOOL_1)
|
||||
EMT.TCPOS_1 = GetToolTcPos( EMT.TOOL_1)
|
||||
ShowToolInTcPos( EMT.TCPOS_1, false)
|
||||
else
|
||||
EgtUnloadTool( 'H1', 1)
|
||||
end
|
||||
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
|
||||
|
||||
-- dati del grezzo
|
||||
local nRawId = EgtGetFirstRawPart()
|
||||
local b3Raw = EgtGetRawPartBBox( nRawId or GDB_ID.NULL)
|
||||
|
||||
-- Se abilitato e trovato grezzo, creazione Zmap
|
||||
if EgtGetInfo( EgtGetCurrMachGroup(), 'Vm', 'b') and nRawId then
|
||||
-- Se vero inizio, creo Zmap
|
||||
if not EMT.SIM1ST 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 dArea = b3Sol:getDimX() * b3Sol:getDimY() + b3Sol:getDimX() * b3Sol:getDimZ() + b3Sol:getDimY() * b3Sol:getDimZ()
|
||||
local dTol = 6.13
|
||||
if dArea < CoeffVM * 6.0e6 then
|
||||
dTol = 2.81
|
||||
elseif dArea < CoeffVM * 12.0e6 then
|
||||
dTol = 3.77
|
||||
elseif dArea < CoeffVM * 24.0e6 then
|
||||
dTol = 5.03
|
||||
end
|
||||
-- creo lo Zmap
|
||||
EMT.VMILL = EgtVolZmapBox( nRawId, b3Raw:getMin(), b3Raw:getDimX(), b3Raw:getDimY(), b3Raw:getDimZ(), dTol, true, GDB_RT.GLOB)
|
||||
if EMT.VMILL then
|
||||
EgtSetName( EMT.VMILL, 'VMill')
|
||||
EgtSetLevel( EMT.VMILL, GDB_LV.TEMP)
|
||||
EgtSetColor( EMT.VMILL, EgtGetColor( nSolId), false)
|
||||
-- nascondo le altre geometrie
|
||||
local nId = EgtGetFirstInGroup( nRawId)
|
||||
while nId do
|
||||
if nId ~= EMT.VMILL then
|
||||
EgtSetStatus( nId, GDB_ST.OFF)
|
||||
end
|
||||
nId = EgtGetNext( nId)
|
||||
end
|
||||
EgtSetStatus( EMT.SCRAP or GDB_ID.NULL, GDB_ST.OFF)
|
||||
-- imposto eventuale utensile corrente
|
||||
EmtSetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- se vero inizio, assegno solidi per verifica collisione
|
||||
if not EMT.SIM1ST then
|
||||
EMT.CODET = {}
|
||||
for i = 1, #EMT.MCODET do
|
||||
EMT.CODET[i] = EMT.MCODET[i]
|
||||
end
|
||||
if EMT.VMILL then
|
||||
table.insert( EMT.CODET, EMT.VMILL)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulDispositionEnd()
|
||||
if EMT.UNLOADING or EMT.FALL then
|
||||
EMT.UNLOADING = false
|
||||
EMT.FALL = false
|
||||
end
|
||||
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.TOOLTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
||||
-- se sega a catena, imposto subito angolo scelto per asse virtuale A
|
||||
if EMT.HEAD == 'H3' then
|
||||
-- recupero la lavorazione successiva
|
||||
local NextMchId
|
||||
if EMT.MCHID then
|
||||
NextMchId = EgtGetNextActiveOperation( EMT.MCHID)
|
||||
else
|
||||
NextMchId = EgtGetFirstActiveOperation()
|
||||
end
|
||||
if EgtGetOperationType( NextMchId) == MCH_OY.DISP then
|
||||
NextMchId = EgtGetNextActiveOperation( NextMchId)
|
||||
end
|
||||
EgtSetCurrMachining( NextMchId)
|
||||
-- leggo e imposto il valore di A1
|
||||
local sVal = EgtGetMachiningParam( MCH_MP.BLOCKEDAXIS)
|
||||
local dPosA = EgtGetVal( sVal, 'A1', 'd') or 0
|
||||
EgtSetAxisPos( 'A1', dPosA)
|
||||
EmtModifyAxisHome( 'A1', dPosA)
|
||||
EgtSetAxisPos( 'C', 90)
|
||||
end
|
||||
-- breve pausa
|
||||
EgtPause( 100)
|
||||
EgtOutText( '')
|
||||
if EMT.HEAD == 'H1' or EMT.HEAD == 'H2' or EMT.HEAD == 'H3' then
|
||||
-- dichiaro utensile su testa 1
|
||||
EMT.TOOL_1 = EMT.TOOL
|
||||
EMT.TCPOS_1 = EMT.TCPOS
|
||||
-- lo nascondo sul portautensili
|
||||
ShowToolInTcPos( EMT.TCPOS, false)
|
||||
end
|
||||
-- se attivo Vmill
|
||||
EmtSetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL)
|
||||
-- se attivo Collision Check
|
||||
EMT.SAFEDIST = COLL_SAFE_DIST
|
||||
if EMT.COLLOBJ then
|
||||
local nInd = EgtIf( EMT.HEAD ~= 'H2', 1001, 1011)
|
||||
AddToolToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd)
|
||||
AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd + 1)
|
||||
for i, Coll in ipairs( EMT.COLLOBJ) do
|
||||
EmtAddCollisionObjEx( i, Coll.Fr, Coll.Ty, Coll.Mv, Coll.P1, Coll.P2, Coll.P3)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulToolDeselect()
|
||||
-- Step di simulazione
|
||||
local RapSimStep = 4 * EMT.SIMSTEP
|
||||
local RapSimRotStep = RapSimStep / 10
|
||||
local CollSimRotStep = min( RapSimRotStep, 5)
|
||||
-- porto la testa in home
|
||||
local dPosY = EgtGetAxisHomePos( 'Y')
|
||||
if IsMobileTcPos( EMT.TCPOS) and IsMobileTcPos( EMT.NEXTTCPOS) then
|
||||
dPosY = EgtGetAxisPos( 'Y')
|
||||
end
|
||||
SimulMoveAxes( 'X', EgtGetAxisHomePos( 'X'), RapSimStep, 'Y', dPosY, RapSimStep,'C', EgtGetAxisHomePos( 'C'), CollSimRotStep, 'B', EgtGetAxisHomePos( 'B'), CollSimRotStep)
|
||||
-- se testa attuale è sega a catena devo depositarla
|
||||
if EMT.HEAD == 'H3' then
|
||||
ShowToolInTcPos( EMT.TCPOS_1, true)
|
||||
EgtUnloadTool( 'H3', 1)
|
||||
EMT.TOOL_1 = nil
|
||||
EMT.TCPOS_1 = nil
|
||||
end
|
||||
-- deposito utensile
|
||||
if EMT.NEXTTOOL ~= EMT.TOOL_1 then
|
||||
EgtOutText( 'Tool change in progress...')
|
||||
-- simulo movimento
|
||||
SimulMoveAxes( 'B', 0, CollSimRotStep, 'C', 0, CollSimRotStep)
|
||||
SimulMoveAxis( 'X', ( MinX + MaxX) / 2, RapSimStep)
|
||||
-- breve pausa
|
||||
EgtPause( 100)
|
||||
if EMT.HEAD == 'H1' or EMT.HEAD == 'H2' or EMT.HEAD == 'H3' then
|
||||
ShowToolInTcPos( EMT.TCPOS_1, true)
|
||||
EgtUnloadTool( EMT.HEAD, EMT.EXIT)
|
||||
EMT.TOOL_1 = nil
|
||||
EMT.TCPOS_1 = nil
|
||||
end
|
||||
-- se segue sega a catena
|
||||
if EMT.NEXTHEAD == 'H3' then
|
||||
-- nascondo l'utensile corrente
|
||||
EgtSetStatus( EgtGetHeadId( 'H1'), GDB_ST.OFF)
|
||||
-- eseguo movimenti opportuni
|
||||
SimulMoveAxis( 'X', ( MinX + MaxX) / 2, RapSimStep)
|
||||
SimulMoveAxes( 'B', 0, CollSimRotStep, 'C', -90, CollSimRotStep)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMachiningStart()
|
||||
-- recupero alcuni dati della lavorazione
|
||||
EMT.MCHNAME = EgtGetOperationName( EMT.MCHID)
|
||||
EMT.MCHTYPE = EgtGetMachiningParam( MCH_MP.TYPE)
|
||||
local sNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
||||
EMT.VMRS = false
|
||||
-- recupero CUTID e TASKID della feature lavorata
|
||||
local vId = EgtGetMachiningGeometry()
|
||||
if vId and #vId > 0 and #vId[1] > 0 then
|
||||
local nPartId = EgtGetParent( EgtGetParent( vId[1][1]) or GDB_ID.NULL)
|
||||
EMT.CUTID = EgtGetInfo( nPartId or GDB_ID.NULL, 'CUTID', 'i') or 0
|
||||
EMT.TASKID = EgtGetInfo( vId[1][1], 'TASKID', 'i') or 0 ;
|
||||
else
|
||||
EMT.CUTID = 0
|
||||
EMT.TASKID = 0
|
||||
end
|
||||
-- eventuale pausa per rimozione sfridi
|
||||
if EMT.SCRAPFIRST then
|
||||
if ( EMT.HEAD == 'H3' and string.sub( EMT.MCHNAME, 1, 5) == 'Csaw_') or EgtExistsInfo( EMT.MCHID, 'MOVE_AFTER') then
|
||||
EMT.SCRAPFIRST = false
|
||||
EgtOutText( 'Pause for Scrap Remove')
|
||||
ParkForScrapRemove()
|
||||
ExecScrapRemove()
|
||||
EgtPause( 500)
|
||||
EgtOutText( '')
|
||||
end
|
||||
end
|
||||
-- non ancora iniziata la lavorazione
|
||||
EMT.MCHFIRST = true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMachiningEnd()
|
||||
if EMT.UNLOADING or EMT.FALL then
|
||||
EMT.UNLOADING = false
|
||||
EMT.FALL = false
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
--function OnSimulPathStart()
|
||||
--end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulPathEnd()
|
||||
-- se attivo VMILL, lavorazione ed è richiesto di eliminare gli sfridi
|
||||
if EMT.VMILL and not EMT.OPEISDISP and EMT.VMRS then
|
||||
EgtOutLog( 'OnSimulPathEnd', 5)
|
||||
local nPart = EgtVolZmapPartCount( EMT.VMILL)
|
||||
if nPart > 1 then
|
||||
-- ricerca del pezzo con massimo volume
|
||||
local nPartMax = 0
|
||||
local dVolMax = 0
|
||||
for i = 1, nPart do
|
||||
local dVol = EgtVolZmapPartVolume( EMT.VMILL, 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( EMT.VMILL, i - 1, GDB_BB.STANDARD)
|
||||
if b3Vmill:getDimX() < 1200 then
|
||||
EgtRemoveVolZmapPart( EMT.VMILL, i - 1)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- aggiorno visualizzazione
|
||||
EgtDraw()
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulPathStartAux()
|
||||
--EgtOutLog( 'OnSimulPathStartAux - ' .. EgtNumToString( EMT.AUXIND, 0) .. ' - ' .. EMT.AUX)
|
||||
EgtOutLog( 'OnSimulPathStartAux', 5)
|
||||
-- eseguo il comando
|
||||
--ExecAuxCmd( EMT.AUX)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulPathEndAux()
|
||||
--EgtOutLog( 'OnSimulPathEndAux - ' .. EgtNumToString( EMT.AUXIND, 0) .. ' - ' .. EMT.AUX)
|
||||
EgtOutLog( 'OnSimulPathEndAux', 5)
|
||||
-- eseguo il comando
|
||||
--ExecAuxCmd( EMT.AUX)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMoveStart()
|
||||
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 or EMT.SIMCOBIND == 1011 then
|
||||
Class = 'T_'..EMT.HEAD
|
||||
elseif EMT.SIMCOBIND == 1002 or EMT.SIMCOBIND == 1012 then
|
||||
Class = 'TH_'..EMT.HEAD
|
||||
else
|
||||
Class = EMT.COLLOBJ[EMT.SIMCOBIND].Cl
|
||||
end
|
||||
-- se foratura verticale ammetto discesa nel piano fino a 20 mm
|
||||
if EMT.TOOLTYPE == MCH_TY.DRILL_STD and abs( EgtGetAxisPos( 'B')) < 0.1 then
|
||||
local PosZ = EgtGetAxisPos( 'Z')
|
||||
local DownZ = PosZ - EMT.TOOLTOTLEN - DeltaTabZ
|
||||
if DownZ >= -20 then
|
||||
EgtOutLog( 'Vertical drilling down table '..EgtNumToString( DownZ, 1), 1)
|
||||
return
|
||||
end
|
||||
end
|
||||
table.insert( EMT.COLLIDE, { Mc = EMT.MCHNAME, Cl = Class, Vm = EMT.SIMVMID})
|
||||
EMT.LAST_MCHNAME_COLLIDE = EMT.MCHNAME
|
||||
EMT.ERR = 11
|
||||
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
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ParkForScrapRemove()
|
||||
-- Step di simulazione
|
||||
local RapSimStep = 4 * EMT.SIMSTEP
|
||||
-- Quota di parcheggio
|
||||
local b3Raw = EgtGetRawPartBBox( EgtGetFirstRawPart() or GDB_ID.NULL)
|
||||
local ParkY = min( -( b3Raw:getMin():getX() - 2000), -MinY)
|
||||
--Eseguo
|
||||
SimulMoveAxis( 'Z', EgtGetAxisHomePos( 'Z'), RapSimStep)
|
||||
SimulMoveAxis( 'Y', ParkY, RapSimStep)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecScrapRemove()
|
||||
-- Se non c'è virtual milling attivo, esco
|
||||
if not EMT.VMILL then return end
|
||||
-- Se non ci sono almeno due parti nel virtual milling, esco
|
||||
local nVmPart = EgtVolZmapPartCount( EMT.VMILL)
|
||||
if nVmPart < 2 then return end
|
||||
-- Recupero box e area dei pezzi
|
||||
local vPart = {}
|
||||
local nPartId = EgtGetFirstPartInRawPart( EgtGetFirstRawPart() or GDB_ID.NULL)
|
||||
while nPartId do
|
||||
-- box e area
|
||||
local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
|
||||
local dPartArea = b3Part:getDimX() * b3Part:getDimY()
|
||||
-- box espanso
|
||||
local b3PartExp = BBox3d( b3Part)
|
||||
b3PartExp:Add( b3PartExp:getMin() - Vector3d( 10, 10, 0))
|
||||
b3PartExp:Add( b3PartExp:getMax() + Vector3d( 10, 10, 0))
|
||||
-- salvo i dati
|
||||
table.insert( vPart, { Box = b3Part, BoxExp = b3PartExp, Area = dPartArea})
|
||||
-- passo al successivo
|
||||
nPartId = EgtGetNextPartInRawPart( nPartId)
|
||||
end
|
||||
-- Recupero box e area delle parti di Vmill
|
||||
local vVmPart = {}
|
||||
for i = 1, nVmPart do
|
||||
-- recupero il box e calcolo l'area della parte come Vmill
|
||||
local b3VmPart = EgtVolZmapGetPartBBoxGlob( EMT.VMILL, i - 1, GDB_BB.STANDARD)
|
||||
local dVmPartArea = EgtVolZmapPartVolume( EMT.VMILL, i - 1) / b3VmPart:getDimZ()
|
||||
-- box espanso
|
||||
local b3VmPartExp = BBox3d( b3VmPart)
|
||||
b3VmPartExp:Add( b3VmPart:getMin() - Vector3d( 100, 100, 0))
|
||||
b3VmPartExp:Add( b3VmPart:getMax() + Vector3d( 100, 100, 0))
|
||||
-- salvo i dati
|
||||
table.insert( vVmPart, { Box = b3VmPart, BoxExp = b3VmPartExp, Area = dVmPartArea})
|
||||
end
|
||||
-- Tengo solo le parti del Vmill che contengono almeno un box di un pezzo o che interferiscono e sono abbastanza grandi
|
||||
local nValidCnt = 0
|
||||
for i = #vVmPart, 1, -1 do
|
||||
-- verifiche per parte da eliminare
|
||||
local bToRemove = true
|
||||
-- se area abbastanza grande, allora da verificare
|
||||
if vVmPart[i].Area > 1e4 then
|
||||
-- verifico se sono sicuramente valide (i due box si equivalgono entro la tolleranza)
|
||||
for j = 1, #vPart do
|
||||
if EnclosesXY( vVmPart[i].BoxExp, vPart[j].Box) and EnclosesXY( vPart[j].BoxExp, vVmPart[i].Box) then
|
||||
bToRemove = false
|
||||
vVmPart[i].Part = j
|
||||
nValidCnt = nValidCnt + 1
|
||||
break
|
||||
end
|
||||
end
|
||||
-- verifico se sono molto probabilmente valide
|
||||
for j = 1, #vPart do
|
||||
if bToRemove and ( OverlapsXY( vVmPart[i].Box, vPart[j].Box) and vVmPart[i].Area > 0.25 * vPart[j].Area) then
|
||||
bToRemove = false
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
-- se richiesta eliminazione, la eseguo
|
||||
if bToRemove then
|
||||
EgtRemoveVolZmapPart( EMT.VMILL, i - 1)
|
||||
table.remove( vVmPart, i)
|
||||
end
|
||||
end
|
||||
-- Se il numero delle parti non supera il numero dei pezzi, ho finito
|
||||
if #vVmPart <= #vPart then
|
||||
return
|
||||
end
|
||||
-- Se il numero delle parti sicuramente valide uguaglia il numero dei pezzi, elimino le altre ed ho finito
|
||||
if nValidCnt == #vPart then
|
||||
for i = #vVmPart, 1, -1 do
|
||||
if not vVmPart[i].Part then
|
||||
EgtRemoveVolZmapPart( EMT.VMILL, i - 1)
|
||||
table.remove( vVmPart, i)
|
||||
end
|
||||
end
|
||||
return
|
||||
end
|
||||
-- Calcolo punti interni alle parti di Vmill non sicuramente valide
|
||||
for i = 1, #vVmPart do
|
||||
if not vVmPart[i].Part then
|
||||
local ptP = vVmPart[i].Box:getCenter() - Y_AX() * vVmPart[i].Box:getDimY()
|
||||
local bOk, vIntType, vIntDist = EgtLineVolZmapInters( ptP, Y_AX(), EMT.VMILL, GDB_RT.GLOB)
|
||||
if bOk then
|
||||
for j = 1, #vIntType do
|
||||
-- se la corrente entra ed esiste la successiva che esce
|
||||
if vIntType[j] == 1 and j + 1 <= #vIntType and vIntType[j + 1] == 2 then
|
||||
local ptC = ptP + Y_AX() * (( vIntDist[j] + vIntDist[j + 1]) / 2)
|
||||
local nPart = EgtVolZmapGetPartMinDist( EMT.VMILL, ptC, GDB_RT.GLOB)
|
||||
if nPart == i - 1 then
|
||||
vVmPart[i].Cen = ptC
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
-- Verifico le parti di Vmill non già dichiarate valide
|
||||
for i = #vVmPart, 1, -1 do
|
||||
if not vVmPart[i].Part and vVmPart[i].Cen then
|
||||
local bToRemove = true
|
||||
for j = 1, #vPart do
|
||||
if EnclosesPointXY( vPart[j].Box, vVmPart[i].Cen) then
|
||||
bToRemove = false
|
||||
break
|
||||
end
|
||||
end
|
||||
for j = 1, #vVmPart do
|
||||
if j ~= i then
|
||||
local vExpBox = BBox3d( vVmPart[j].Box)
|
||||
-- lo espando in XY per sicurezza
|
||||
vExpBox:Add( vExpBox:getMin() - Vector3d( 100, 100, 0))
|
||||
vExpBox:Add( vExpBox:getMax() + Vector3d( 100, 100, 0))
|
||||
-- verifico contenimento
|
||||
if EnclosesXY( vExpBox, vVmPart[i].Box) then
|
||||
bToRemove = true
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
-- se richiesta eliminazione, la eseguo
|
||||
if bToRemove then
|
||||
EgtRemoveVolZmapPart( EMT.VMILL, i - 1)
|
||||
table.remove( vVmPart, i)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecUnloading()
|
||||
if EMT.VMILL then
|
||||
-- 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( EMT.VMILL))
|
||||
EgtRelocate( EMT.VMILL, nLayId)
|
||||
EgtSetLevel( EMT.VMILL, GDB_LV.USER)
|
||||
-- aggiungo gli spigoli
|
||||
local nFirstId, nCount = EgtVolZmapGetEdges( EMT.VMILL, nLayId)
|
||||
if nFirstId then
|
||||
for nId = nFirstId, nFirstId + nCount - 1 do
|
||||
EgtSetColor( nId, Color3d( 96, 96, 96))
|
||||
end
|
||||
end
|
||||
-- rilascio Vmill
|
||||
EMT.VMILL = nil
|
||||
-- aggiorno la visualizzazione
|
||||
EgtDraw()
|
||||
-- se finito
|
||||
if EMT.PHASE == EgtGetPhaseCount() then
|
||||
-- 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
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ShowToolInTcPos( sTcPos, bShow)
|
||||
-- recupero il gruppo dell'utensile
|
||||
local TcExitId = EgtGetFirstNameInGroup( EgtGetTcPosId( sTcPos or '') or GDB_ID.NULL, 'T1')
|
||||
if not TcExitId then return end
|
||||
-- imposto lo stato di visualizzazione
|
||||
EgtSetStatus( TcExitId, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF))
|
||||
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
|
||||
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** ESTIMATION T&L ***
|
||||
---------------------------------------------------------------------
|
||||
local RAPID_X_FEED = 75000 -- mm/min
|
||||
local RAPID_Y_FEED = 100000 -- mm/min
|
||||
local RAPID_Z_FEED = 50000 -- mm/min
|
||||
local RAPID_C_FEED = 15000 -- deg/min
|
||||
local RAPID_B_FEED = 15000 -- deg/min
|
||||
local RAPID_MIN_T = 0.1 -- s
|
||||
local LOAD_T = 2 -- s
|
||||
local CHAR_ONE_MOVE_T = 1 -- s
|
||||
local ROTATION_T = 40 -- s
|
||||
local SPLIT_T = 6 -- s
|
||||
local UNLOAD_T = 4 -- s
|
||||
local FALL_T = 2 -- 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( 'Y')
|
||||
EMT.L2 = EgtGetAxisHomePos( 'X')
|
||||
EMT.L3 = EgtGetAxisHomePos( 'Z')
|
||||
EMT.R1 = EgtGetAxisHomePos( 'C')
|
||||
EMT.R2 = EgtGetAxisHomePos( 'B')
|
||||
-- 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()
|
||||
-- inizio disposizione
|
||||
EMT.OPEISDISP = true
|
||||
-- sulla prima fase dichiaro carico barra
|
||||
if EMT.PHASE == 1 then
|
||||
EMT.LOAD = true
|
||||
else
|
||||
EMT.LOAD = false
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimDispositionEnd()
|
||||
-- emetto dati in sospeso
|
||||
if EMT.TLE_NAME then
|
||||
EmtTleAddMachining( EMT.TLE_NAME, EmtSecToHMS( EMT.TLE_TIME), ' - ', ' - ')
|
||||
EMT.TLE_NAME = nil
|
||||
EMT.TLE_TIME = nil
|
||||
end
|
||||
-- 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
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimToolDeselect()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimMachiningStart()
|
||||
EMT.MCHNAME = EgtGetOperationName( EMT.MCHID)
|
||||
EMT.MCHTYPE = EgtGetMachiningParam( MCH_MP.TYPE)
|
||||
EgtOutLog( 'Mach : ' .. EMT.MCHNAME, 5)
|
||||
-- reset contatori di lavorazione
|
||||
EMT.MCHCUTLEN = 0
|
||||
EMT.MCHCUTTIME = 0
|
||||
EMT.MCHEXTLEN = 0
|
||||
EMT.MCHEXTTIME = 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
|
||||
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
|
||||
-- emetto dati in sospeso
|
||||
if EMT.TLE_NAME then
|
||||
EmtTleAddMachining( EMT.TLE_NAME, EmtSecToHMS( EMT.TLE_TIME), ' - ', ' - ')
|
||||
EMT.TLE_NAME = nil
|
||||
EMT.TLE_TIME = nil
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimPathStart()
|
||||
EMT.AUXTYPE = nil
|
||||
EMT.MCHMOVEFIRST = true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimPathEnd()
|
||||
EMT.AUXTYPE = nil
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimPathStartAux()
|
||||
-- se richiesto, preparo il carico barra
|
||||
if EMT.LOAD then
|
||||
if EMT.AUXIND == EMT.AUXTOT then
|
||||
local dTime = LOAD_T
|
||||
EMT.TOTEXTTIME = EMT.TOTEXTTIME + dTime
|
||||
EmtTleAddMachining( 'Loading', EmtSecToHMS( dTime), ' - ', ' - ')
|
||||
EMT.LOAD = false
|
||||
end
|
||||
-- se altrimenti carico dopo rotazione
|
||||
elseif EMT.POSTROT then
|
||||
if EMT.AUXIND == EMT.AUXTOT then
|
||||
local dTime = ROTATION_T
|
||||
EMT.TOTEXTTIME = EMT.TOTEXTTIME + dTime
|
||||
EmtTleAddMachining( 'Rotation', EmtSecToHMS( dTime), ' - ', ' - ')
|
||||
EMT.POSTROT = false
|
||||
end
|
||||
-- altrimenti, spostamento carrelli
|
||||
else
|
||||
if EMT.AUXTOT > 2 and EMT.AUXIND == EMT.AUXTOT then
|
||||
local dTime = ( EMT.AUXTOT - 2) * CHAR_ONE_MOVE_T
|
||||
EMT.TOTEXTTIME = EMT.TOTEXTTIME + dTime
|
||||
EmtTleAddMachining( 'Charriots move', EmtSecToHMS( dTime), ' - ', ' - ')
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimPathEndAux()
|
||||
-- verifico tipo di emissione
|
||||
if EMT.OPEISDISP then
|
||||
if not EMT.AUXTYPE then
|
||||
local Cmd = EgtSplitString( EMT.AUX)
|
||||
if Cmd[1] == '0' and Cmd[2] == 'Unloading' then
|
||||
EMT.AUXTYPE = 'U'
|
||||
else
|
||||
EMT.AUXTYPE = 'R'
|
||||
end
|
||||
end
|
||||
else
|
||||
if not EMT.AUXTYPE then
|
||||
local Cmd = EgtSplitString( EMT.AUX)
|
||||
if Cmd[1] == '0' and Cmd[2] == 'Split' then
|
||||
EMT.AUXTYPE = 'S'
|
||||
elseif Cmd[1] == '0' and Cmd[2] == 'Unloading' then
|
||||
EMT.AUXTYPE = 'U'
|
||||
elseif Cmd[1] == '0' and Cmd[2] == 'Fall' then
|
||||
EMT.AUXTYPE = 'F'
|
||||
else
|
||||
EMT.AUXTYPE = 'P'
|
||||
end
|
||||
end
|
||||
end
|
||||
-- per lo scarico della rimanenza
|
||||
if EMT.AUXTYPE == 'R' then
|
||||
if EMT.AUXIND == EMT.AUXTOT then
|
||||
local dTime = LOAD_T + UNLOAD_T
|
||||
EMT.TOTEXTTIME = EMT.TOTEXTTIME + dTime
|
||||
EMT.TLE_NAME = 'Remnant unloading'
|
||||
EMT.TLE_TIME = dTime
|
||||
end
|
||||
-- per lo split
|
||||
elseif EMT.AUXTYPE == 'S' then
|
||||
if EMT.AUXIND == EMT.AUXTOT then
|
||||
local dTime = SPLIT_T
|
||||
EMT.TOTEXTTIME = EMT.TOTEXTTIME + dTime
|
||||
EMT.TLE_NAME = 'Splitting'
|
||||
EMT.TLE_TIME = dTime
|
||||
end
|
||||
-- per lo scarico
|
||||
elseif EMT.AUXTYPE == 'U' then
|
||||
if EMT.AUXIND == EMT.AUXTOT then
|
||||
local dTime = UNLOAD_T
|
||||
EMT.TOTEXTTIME = EMT.TOTEXTTIME + dTime
|
||||
EMT.TLE_NAME = 'Unloading'
|
||||
EMT.TLE_TIME = dTime
|
||||
end
|
||||
-- per lo scarico a caduta
|
||||
elseif EMT.AUXTYPE == 'F' then
|
||||
if EMT.AUXIND == EMT.AUXTOT then
|
||||
local dTime = FALL_T
|
||||
EMT.TOTEXTTIME = EMT.TOTEXTTIME + dTime
|
||||
EMT.TLE_NAME = 'Fall'
|
||||
EMT.TLE_TIME = dTime
|
||||
end
|
||||
-- per la pre-rotazione
|
||||
elseif EMT.AUXTYPE == 'P' then
|
||||
; -- calcolato come parte della rotazione
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimRapid()
|
||||
-- dati movimento
|
||||
local dL1 = EMT.L1 - ( EMT.L1p or 0)
|
||||
local dL2 = EMT.L2 - ( EMT.L2p or 0)
|
||||
local dL3 = EMT.L3 - ( EMT.L3p or 0)
|
||||
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
|
||||
-- se primo posizionamento della lavorazione il movimento di L1 è già conteggiato in quello dei carrelli
|
||||
if EMT.MCHMOVEFIRST then
|
||||
EMT.MCHMOVEFIRST = false
|
||||
dL1 = 0
|
||||
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
|
||||
EgtOutLog( string.format( ' G0 Len=%.0f Rot=%.0f° Time=%.2f', dLen, abs( dR1) + abs( dR2), dTime), 5)
|
||||
-- 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
|
||||
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 * 60
|
||||
EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
|
||||
EgtOutLog( string.format( ' G2 Len=%.0f Time=%.2f', dLen, dTime), 5)
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
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 IsMobileTcPos( sTcPos)
|
||||
return ( sTcPos == 'T9' or sTcPos == 'T10' or sTcPos == 'T11' or sTcPos == 'T12')
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** END GENERAL ***
|
||||
---------------------------------------------------------------------
|
||||
@@ -0,0 +1,11 @@
|
||||
-- Special Operations macchina Essetre-WALL by EgalTech s.r.l. 2020/11/16
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
|
||||
EgtOutLog ( '** Essetre-WALL.mlse '..PP_VER..' **', 1)
|
||||
|
||||
---------------------------------------------------------------------
|
||||
--function OnSpecialMoveZup()
|
||||
--end
|
||||
@@ -0,0 +1,58 @@
|
||||
; Commento per evitare BOM con UTF-8
|
||||
[General]
|
||||
Material=Beam
|
||||
|
||||
[Tools]
|
||||
Drillbit=1
|
||||
Sawblade=1
|
||||
Mill=1
|
||||
Mortise=1
|
||||
Chisel=0
|
||||
DrillMaker=MakeWoodDrill.lua
|
||||
SawbladeMaker=MakeSawblade.lua
|
||||
MillMaker=MakeWoodCylMill.lua
|
||||
MortiseMaker=MakeMortise.lua
|
||||
ChiselMaker=MakeChisel.lua
|
||||
Active=1
|
||||
|
||||
[ToolHolder]
|
||||
H1.1=Standard.nge
|
||||
H1.1:MILL_NOTIP=MillNoTip.nge
|
||||
H2.1=Saw.nge
|
||||
H3.1=ChainSaw.nge
|
||||
|
||||
[Machinings]
|
||||
Drilling=1
|
||||
Sawing=1
|
||||
Milling=1
|
||||
Pocketing=1
|
||||
Mortising=1
|
||||
Chiseling=0
|
||||
SawRoughing=0
|
||||
SawFinishing=0
|
||||
|
||||
[Machining]
|
||||
InitScript=InitMach.lua
|
||||
ExitScript=ExitMach.lua
|
||||
|
||||
[Disposition]
|
||||
;InitScript=InitDisp.lua
|
||||
|
||||
[Heads]
|
||||
; 5 axis head
|
||||
H1=6608
|
||||
; 5 axis saw
|
||||
H2=6615
|
||||
; Chainsaw
|
||||
H3=6616
|
||||
|
||||
[SetUp]
|
||||
Default=Standard
|
||||
|
||||
[Estimations]
|
||||
Enable=1
|
||||
WinPlace=0,514,138,628,810
|
||||
|
||||
[VMill]
|
||||
Enable=1
|
||||
Save=0
|
||||
@@ -0,0 +1,431 @@
|
||||
-- Descrizione macchina Essetre-WallXS0014 by EgalTech s.r.l. 2023/06/29
|
||||
-- Macchina Wall.
|
||||
-- 2023/06/27 v.2.5f1 DS Prima versione partende da WallXS standard.
|
||||
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
|
||||
PP_VER = '2.5f3'
|
||||
|
||||
-- Parametri macchina
|
||||
NumericalControl = 'TPA' -- NUM o TPA
|
||||
MinY = 0.0
|
||||
MaxY = 22000.0
|
||||
MinX = -3900.0
|
||||
MaxX = 45.0
|
||||
MinZ = -900.0
|
||||
MaxZ = 0.0
|
||||
MinB = -120.0
|
||||
MaxB = 120.0
|
||||
MinC = -360.0
|
||||
MaxC = 360.0
|
||||
MillOffs = 92.5
|
||||
ChainSaw = 0
|
||||
SawOffsX = 0.0
|
||||
SawOffsY = 111.0
|
||||
SawOffsZ = -150.0
|
||||
ChSawLen = 90.0
|
||||
Nail11 = 1
|
||||
Nail11DeltaX = 330.0
|
||||
Nail11DeltaY = 272.6
|
||||
Nail11DeltaZ = -76.5
|
||||
Nail12 = 1
|
||||
Nail12DeltaX = 330.0
|
||||
Nail12DeltaY = -272.6
|
||||
Nail12DeltaZ = -76.5
|
||||
Orig2DeltaX = 0
|
||||
Orig2DeltaY = -3500
|
||||
Orig2DeltaZ = 0
|
||||
Orig3DeltaX = 9000
|
||||
Orig3DeltaY = 0
|
||||
Orig3DeltaZ = 0
|
||||
Orig4DeltaX = 9000
|
||||
Orig4DeltaY = -3500
|
||||
Orig4DeltaZ = 0
|
||||
Orig5DeltaX = 11640
|
||||
Orig5DeltaY = 0
|
||||
Orig5DeltaZ = 0
|
||||
Orig6DeltaX = 11640
|
||||
Orig6DeltaY = -3500
|
||||
Orig6DeltaZ = 0
|
||||
Orig7DeltaX = 20640
|
||||
Orig7DeltaY = 0
|
||||
Orig7DeltaZ = 0
|
||||
Orig8DeltaX = 20640
|
||||
Orig8DeltaY = -3500
|
||||
Orig8DeltaZ = 0
|
||||
DimTabX = 20640.0
|
||||
DimTabY = 3500.0
|
||||
DeltaTabX = 970.0
|
||||
DeltaTabY = -3690.0
|
||||
DeltaTabZ = -606.0 + MillOffs -- -513.5
|
||||
CoeffVM = 0.75
|
||||
|
||||
-- Aggiornamento con dati da TechnoEssetre7
|
||||
local sTs3Data = EgtGetStringFromIni( 'Wall', 'DATA_DIR', "C:\\TechnoEssetre7\\EgtData", EgtGetIniFile()).."\\Essetre-Wall_XS0014.data"
|
||||
local sData = EgtGetSourceDir().."\\Wall\\Ts3Data.lua"
|
||||
if EgtExistsFile( sTs3Data) then
|
||||
EgtCopyFile( sTs3Data, sData)
|
||||
local sTs3DataOld = sTs3Data..'.old'
|
||||
EgtEraseFile( sTs3DataOld)
|
||||
EgtRenameFile( sTs3Data, sTs3DataOld)
|
||||
end
|
||||
|
||||
if EgtExistsFile( sData) then
|
||||
local Machine = dofile( sData)
|
||||
if Machine and Machine.Offsets then
|
||||
local MchOffs = Machine.Offsets
|
||||
NumericalControl = EgtIf( MchOffs.TIPO_CN ~= 1, 'NUM', 'TPA')
|
||||
if MchOffs.MAX_Y then MinY = -MchOffs.MAX_Y end
|
||||
if MchOffs.MIN_Y then MaxY = -MchOffs.MIN_Y end
|
||||
MinX = MchOffs.MIN_X or MinX
|
||||
MaxX = MchOffs.MAX_X or MaxX
|
||||
MinZ = MchOffs.MIN_Z or MinZ
|
||||
MaxZ = MchOffs.MAX_Z or MaxZ
|
||||
MinB = MchOffs.MIN_B or MinB
|
||||
MaxB = MchOffs.MAX_B or MaxB
|
||||
MinC = MchOffs.MIN_C or MinC
|
||||
MaxC = MchOffs.MAX_C or MaxC
|
||||
MillOffs = MchOffs.PIVOT or MillOffs
|
||||
if MchOffs.ZERO_Y then DeltaTabX = -MchOffs.ZERO_Y end
|
||||
if MchOffs.ZERO_X then DeltaTabY = MchOffs.ZERO_X - DimTabY end
|
||||
if MchOffs.ZERO_Z then DeltaTabZ = MchOffs.ZERO_Z + MillOffs end
|
||||
ChainSaw = ( MchOffs.CHAIN_SAW or 0)
|
||||
Nail11 = ( MchOffs.NAIL11 or 0)
|
||||
if Nail11 ~= 0 and MchOffs.ZERO_Y and MchOffs.ZERO_NAIL11_Y then Nail11DeltaX = - ( MchOffs.ZERO_Y - MchOffs.ZERO_NAIL11_Y) end
|
||||
if Nail11 ~= 0 and MchOffs.ZERO_X and MchOffs.ZERO_NAIL11_X then Nail11DeltaY = ( MchOffs.ZERO_X - MchOffs.ZERO_NAIL11_X) end
|
||||
if Nail11 ~= 0 and MchOffs.ZERO_Z and MchOffs.ZERO_NAIL11_Z then Nail11DeltaZ = ( MchOffs.ZERO_Z + MillOffs - MchOffs.ZERO_NAIL11_Z) end
|
||||
Nail12 = ( MchOffs.NAIL12 or 0)
|
||||
if Nail12 ~= 0 and MchOffs.ZERO_Y and MchOffs.ZERO_NAIL12_Y then Nail12DeltaX = - ( MchOffs.ZERO_Y - MchOffs.ZERO_NAIL12_Y) end
|
||||
if Nail12 ~= 0 and MchOffs.ZERO_X and MchOffs.ZERO_NAIL12_X then Nail12DeltaY = ( MchOffs.ZERO_X - MchOffs.ZERO_NAIL12_X) end
|
||||
if Nail12 ~= 0 and MchOffs.ZERO_Z and MchOffs.ZERO_NAIL12_Z then Nail12DeltaZ = ( MchOffs.ZERO_Z + MillOffs - MchOffs.ZERO_NAIL12_Z) end
|
||||
if MchOffs.OFFSET_ZERO3_Y then Orig3DeltaX = -MchOffs.OFFSET_ZERO3_Y end
|
||||
if MchOffs.OFFSET_ZERO3_X then Orig3DeltaY = MchOffs.OFFSET_ZERO3_X end
|
||||
if MchOffs.OFFSET_ZERO3_Z then Orig3DeltaZ = MchOffs.OFFSET_ZERO3_Z end
|
||||
if MchOffs.OFFSET_ZERO4_Y then Orig4DeltaX = -MchOffs.OFFSET_ZERO4_Y end
|
||||
if MchOffs.OFFSET_ZERO4_X then Orig4DeltaY = MchOffs.OFFSET_ZERO4_X end
|
||||
if MchOffs.OFFSET_ZERO4_Z then Orig4DeltaZ = MchOffs.OFFSET_ZERO4_Z end
|
||||
if MchOffs.OFFSET_ZERO11_Y then Orig5DeltaX = -MchOffs.OFFSET_ZERO11_Y end
|
||||
if MchOffs.OFFSET_ZERO11_X then Orig5DeltaY = MchOffs.OFFSET_ZERO11_X end
|
||||
if MchOffs.OFFSET_ZERO11_Z then Orig5DeltaZ = MchOffs.OFFSET_ZERO11_Z end
|
||||
if MchOffs.OFFSET_ZERO12_Y then Orig6DeltaX = -MchOffs.OFFSET_ZERO12_Y end
|
||||
if MchOffs.OFFSET_ZERO12_X then Orig6DeltaY = MchOffs.OFFSET_ZERO12_X end
|
||||
if MchOffs.OFFSET_ZERO12_Z then Orig6DeltaZ = MchOffs.OFFSET_ZERO12_Z end
|
||||
if MchOffs.OFFSET_ZERO13_Y then Orig7DeltaX = -MchOffs.OFFSET_ZERO13_Y end
|
||||
if MchOffs.OFFSET_ZERO13_X then Orig7DeltaY = MchOffs.OFFSET_ZERO13_X end
|
||||
if MchOffs.OFFSET_ZERO13_Z then Orig7DeltaZ = MchOffs.OFFSET_ZERO13_Z end
|
||||
if MchOffs.OFFSET_ZERO14_Y then Orig8DeltaX = -MchOffs.OFFSET_ZERO14_Y end
|
||||
if MchOffs.OFFSET_ZERO14_X then Orig8DeltaY = MchOffs.OFFSET_ZERO14_X end
|
||||
if MchOffs.OFFSET_ZERO14_Z then Orig8DeltaZ = MchOffs.OFFSET_ZERO14_Z end
|
||||
end
|
||||
end
|
||||
|
||||
-- Spostamenti delle chiodatrici rispetto al disegno
|
||||
local Nail11OffsX = Nail11DeltaX - 330.0
|
||||
local Nail11OffsY = Nail11DeltaY - 272.6
|
||||
local Nail11OffsZ = Nail11DeltaZ + 76.5
|
||||
local Nail12OffsX = Nail12DeltaX - 330.0
|
||||
local Nail12OffsY = Nail12DeltaY + 272.6
|
||||
local Nail12OffsZ = Nail12DeltaZ + 76.5
|
||||
|
||||
EmtGeneral {
|
||||
File='Essetre-WALL_XS0014.nge',
|
||||
Offset = Vector3d( 5470.0, -2000.0, -1243.5),
|
||||
AxisMaxAdjust = 3250,
|
||||
ExitMaxAdjust = 3250,
|
||||
Special = 'Essetre-WALL_XS.mlse',
|
||||
Processor = 'Essetre-WALL_XS.mlpe'}
|
||||
local BaseId = EmtBase {
|
||||
Name = 'Base',
|
||||
Geo='BASE/GEO',
|
||||
Aux={'BASE/SOLID', 'BASE/COLLISION'}}
|
||||
local vtMove = Vector3d( DeltaTabX - 970.0, DeltaTabY + 3690.0, DeltaTabZ + 513.5)
|
||||
EgtMove( BaseId, vtMove, GDB_RT.GLOB)
|
||||
-- Tavola
|
||||
EmtTable {
|
||||
Name = 'Tab',
|
||||
Parent = 'Base',
|
||||
Type = MCH_TT.FLAT,
|
||||
Ref1 = Point3d( DeltaTabX, DeltaTabY, DeltaTabZ),
|
||||
Geo = 'TABLE/GEO'}
|
||||
-- Traversa
|
||||
local YId = EmtAxis {
|
||||
Name = 'Y',
|
||||
Parent = 'Base',
|
||||
Invert = true,
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = X_AX(),
|
||||
Pos = Point3d( 0, 0, 0),
|
||||
Stroke = {MinY, MaxY},
|
||||
Home = 0,
|
||||
Geo = 'Y_AXIS/GEO',
|
||||
Aux = {'Y_AXIS/SOLID'}}
|
||||
-- Testa cambia utensili
|
||||
EmtAxis {
|
||||
Name = 'X',
|
||||
Parent = 'Y',
|
||||
Token = 'X',
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = Y_AX(),
|
||||
Pos = Point3d( 0, 0, 0),
|
||||
Stroke = {MinX, MaxX},
|
||||
Home = ( MinX + MaxX) / 2,
|
||||
Geo = 'X_AXIS/GEO',
|
||||
Aux = {'X_AXIS/SOLID'}}
|
||||
EmtAxis {
|
||||
Name = 'Z',
|
||||
Parent = 'X',
|
||||
Token = 'Z',
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = Z_AX(),
|
||||
Pos = Point3d( 0, 0, 0),
|
||||
Stroke = {MinZ, MaxZ},
|
||||
Home = 0,
|
||||
Geo = 'Z_AXIS/GEO',
|
||||
Aux = {'Z_AXIS/SOLID'}}
|
||||
-- Chiodatrici
|
||||
local H11Id, H12Id
|
||||
if Nail11 ~= 0 then
|
||||
H11Id = EmtHead {
|
||||
Name = 'H11',
|
||||
Parent = 'Z',
|
||||
HSet = 'H11',
|
||||
Type = MCH_HT.STD,
|
||||
Pos = Point3d( Nail11DeltaX, Nail11DeltaY, Nail11DeltaZ),
|
||||
TDir = Z_AX(),
|
||||
Geo = 'H11_HEAD/GEO',
|
||||
Aux = {'H11_HEAD/SOLID'}}
|
||||
EgtMove( EgtGetFirstNameInGroup( H11Id, 'SOLID'), Vector3d( Nail11OffsX, Nail11OffsY, Nail11OffsZ), GDB_RT.GLOB)
|
||||
end
|
||||
if Nail12 ~= 0 then
|
||||
H12Id = EmtHead {
|
||||
Name = 'H12',
|
||||
Parent = 'Z',
|
||||
HSet = 'H12',
|
||||
Type = MCH_HT.STD,
|
||||
Pos = Point3d( Nail12DeltaX, Nail12DeltaY, Nail12DeltaZ),
|
||||
TDir = Z_AX(),
|
||||
Geo = 'H12_HEAD/GEO',
|
||||
Aux = {'H12_HEAD/SOLID'}}
|
||||
EgtMove( EgtGetFirstNameInGroup( H12Id, 'SOLID'), Vector3d( Nail12OffsX, Nail12OffsY, Nail12OffsZ), GDB_RT.GLOB)
|
||||
end
|
||||
-- Assi rotanti
|
||||
EmtAxis {
|
||||
Name = 'C',
|
||||
Parent = 'Z',
|
||||
Token = 'C',
|
||||
Type = MCH_AT.ROTARY,
|
||||
Dir = Z_AX(),
|
||||
Pos = Point3d( 0, 0, 0),
|
||||
Stroke = {MinC, MaxC},
|
||||
Home = 0,
|
||||
Geo = 'C_AXIS/GEO',
|
||||
Aux = {'C_AXIS/SOLID', 'C_AXIS/COLLISION'}}
|
||||
EmtAxis {
|
||||
Name = 'B',
|
||||
Parent = 'C',
|
||||
Token = 'B',
|
||||
Type = MCH_AT.ROTARY,
|
||||
Dir = -X_AX(),
|
||||
Pos = Point3d( 0, 0, MillOffs),
|
||||
Stroke = {MinB, MaxB},
|
||||
Home = 0,
|
||||
Geo = 'B_AXIS/GEO',
|
||||
Aux = {'B_AXIS/SOLID', 'B_AXIS/COLLISION'}}
|
||||
-- Testa principale
|
||||
EmtHead {
|
||||
Name = 'H1',
|
||||
Parent = 'B',
|
||||
HSet = 'H1',
|
||||
Type = MCH_HT.STD,
|
||||
Pos = Point3d( 0, 0, 0),
|
||||
TDir = Z_AX(),
|
||||
ADir = Y_AX(),
|
||||
Rot1W = 0.1,
|
||||
OthColl = {'B/SOLID', 'C/SOLID'},
|
||||
Geo = 'H1_HEAD/GEO'}
|
||||
-- Lama su aggregato
|
||||
local H2Id = EmtHead {
|
||||
Name = 'H2',
|
||||
Parent = 'B',
|
||||
HSet = 'H1',
|
||||
Type = MCH_HT.STD,
|
||||
Pos = Point3d( SawOffsX, SawOffsY, SawOffsZ),
|
||||
TDir = Z_AX(),
|
||||
ADir = -Y_AX(),
|
||||
Rot1W = 0.1,
|
||||
OthColl = {'B/SOLID', 'C/SOLID'},
|
||||
Geo = 'H2_HEAD/GEO'}
|
||||
EgtSetInfo( H2Id, 'Gearbox', 1)
|
||||
-- Sega a catena
|
||||
if ChainSaw ~= 0 then
|
||||
EmtAxis {
|
||||
Name = 'A1',
|
||||
Parent = 'B',
|
||||
Token = '**',
|
||||
Type = MCH_AT.ROTARY,
|
||||
Dir = Z_AX(),
|
||||
Pos = Point3d( 0, 0, 0),
|
||||
Stroke = { 0, 270},
|
||||
Home = 180,
|
||||
Geo = 'A_AXIS/GEO'}
|
||||
local H3Id = EmtHead {
|
||||
Name = 'H3',
|
||||
Parent = 'A1',
|
||||
HSet = 'H1',
|
||||
Type = MCH_HT.STD,
|
||||
Pos = Point3d( 0, 0, -ChSawLen),
|
||||
TDir = -X_AX(),
|
||||
ADir = Z_AX(),
|
||||
Rot1W = 0.1,
|
||||
SolCh = MCH_SCC.ADIR_NEAR,
|
||||
OthColl = {'B/SOLID', 'C/SOLID'},
|
||||
Geo = 'H3_HEAD/GEO'}
|
||||
EgtSetInfo( H3Id, 'ZSAFEDELTA', 60)
|
||||
end
|
||||
-- ToolChanger
|
||||
local ptTc1 = Point3d( 18.0 + ( DeltaTabX - 970.0), -2687.9 + ( DeltaTabY + 3690.0), -691.5 + ( DeltaTabZ + 513.5))
|
||||
local ptTc = ptTc1 + 22 * Z_AX()
|
||||
EmtTcPos {
|
||||
Name = 'T1',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc1 + Vector3d( SawOffsX, SawOffsY, SawOffsZ),
|
||||
TDir = Z_AX(),
|
||||
ADir = -Y_AX(),
|
||||
Geo = 'BASE/T1'}
|
||||
EmtTcPos {
|
||||
Name = 'T2',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 600 * Y_AX(),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'BASE/T2'}
|
||||
EmtTcPos {
|
||||
Name = 'T3',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 800 * Y_AX(),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'BASE/T3'}
|
||||
EmtTcPos {
|
||||
Name = 'T4',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 1000 * Y_AX(),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'BASE/T4'}
|
||||
EmtTcPos {
|
||||
Name = 'T5',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 1200 * Y_AX(),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'BASE/T5'}
|
||||
EmtTcPos {
|
||||
Name = 'T6',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 1400 * Y_AX(),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'BASE/T6'}
|
||||
EmtTcPos {
|
||||
Name = 'T7',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 1600 * Y_AX(),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'BASE/T7'}
|
||||
if ChainSaw ~= 0 then
|
||||
EmtTcPos {
|
||||
Name = 'T8',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 1800 * Y_AX() - ChSawLen * Z_AX(),
|
||||
TDir = -X_AX(),
|
||||
ADir = Z_AX(),
|
||||
Geo = 'BASE/T8CS'}
|
||||
else
|
||||
EmtTcPos {
|
||||
Name = 'T8',
|
||||
Parent = 'Base',
|
||||
Pos = ptTc + 1800 * Y_AX(),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'BASE/T8'}
|
||||
end
|
||||
EmtTcPos {
|
||||
Name = 'T9',
|
||||
Parent = 'Y',
|
||||
Pos = Point3d( 0, -3825, -791.5),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'Y_AXIS/T9'}
|
||||
EmtTcPos {
|
||||
Name = 'T10',
|
||||
Parent = 'Y',
|
||||
Pos = Point3d( 0, -55, -791.5),
|
||||
TDir = Z_AX(),
|
||||
ADir = X_AX(),
|
||||
Geo = 'Y_AXIS/T10'}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Funzioni richiamate per modificare i dati macchina in casi particolari
|
||||
--function OnSetTable()
|
||||
--end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function MoveGroup( 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 OnSetHead()
|
||||
if H11Id then
|
||||
local dPos = EgtIf( EMC.HEAD == 'H11', 0, 650)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H11Id, 'SOLID'), Z_AX(), dPos, true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H11Id, 'T1'), Z_AX(), dPos, true)
|
||||
end
|
||||
if H12Id then
|
||||
local dPos = EgtIf( EMC.HEAD == 'H12', 0, 650)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H12Id, 'SOLID'), Z_AX(), dPos, true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H12Id, 'T1'), Z_AX(), dPos, true)
|
||||
end
|
||||
if EMC.HEAD == 'H11' or EMC.HEAD == 'H12' then
|
||||
EmtModifyAxisHome( 'B', 90)
|
||||
EgtResetAxisPos( 'B')
|
||||
else
|
||||
if EMC.HEAD == 'H3' then
|
||||
-- aggiustamenti per distanza da naso mandrino
|
||||
local dDist = EgtIf( EMC.DIST and abs( EMC.DIST) > 1, EMC.DIST, ChSawLen)
|
||||
EmtModifyExitPosition( EMC.HEAD, EMC.EXIT, Point3d( 0, 0, -dDist))
|
||||
local vtMove = Point3d( 0, 0, -dDist) - Point3d( EMC.EXITPOS)
|
||||
local ExitId = EgtGetFirstNameInGroup( EgtGetHeadId( EMC.HEAD), 'T'..tostring( EMC.EXIT))
|
||||
EgtMove( ExitId, vtMove)
|
||||
end
|
||||
EmtModifyAxisHome( 'B', 0)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Funzione per resettare tutte le attivazioni della macchina
|
||||
function OnResetMachine()
|
||||
EmtUnlinkAllRawPartsFromGroups()
|
||||
EmtUnlinkAllFixturesFromGroups()
|
||||
-- nascondo Vmill
|
||||
local nRawId = EgtGetFirstRawPart()
|
||||
while nRawId do
|
||||
local nVmId = EgtGetFirstNameInGroup( nRawId, 'VMill')
|
||||
local nId = EgtGetFirstInGroup( nRawId)
|
||||
while nId do
|
||||
EgtSetStatus( nId, EgtIf( nId ~= nVmId, GDB_ST.ON, GDB_ST.OFF))
|
||||
nId = EgtGetNext( nId)
|
||||
end
|
||||
nRawId = EgtGetNextRawPart( nRawId)
|
||||
end
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( GDB_ID.ROOT, 'VMill') or GDB_ID.NULL, GDB_ST.OFF)
|
||||
end
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,36 @@
|
||||
-- 2018/11/21 17:30:00
|
||||
-- Machining Exit for Essetre-FAST machine
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EgtBase')
|
||||
_ENV = EgtProtectGlobal()
|
||||
EgtEnableDebug( false)
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- *** Uscita da Lavorazioni ***
|
||||
|
||||
-- Nascondo il pezzo così marcato e le geometrie aggiunte, visualizzo il Box
|
||||
local function ProcessPart( PartId)
|
||||
-- visualizzo il Box
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( PartId, 'Box') or GDB_ID.NULL, GDB_ST.ON)
|
||||
end
|
||||
|
||||
-- Disabilito segnalazione modifica progetto
|
||||
local bEnMod = EgtGetEnableModified()
|
||||
EgtDisableModified()
|
||||
|
||||
-- Processo i pezzi nella radice (già chiusi tutti i gruppi di lavoro)
|
||||
local PartId = EgtGetFirstPart()
|
||||
while PartId do
|
||||
ProcessPart( PartId)
|
||||
PartId = EgtGetNextPart( PartId)
|
||||
end
|
||||
|
||||
EgtZoom( SCE_ZM.ALL, false)
|
||||
|
||||
-- Ripristino segnalazione modifica progetto
|
||||
if bEnMod then
|
||||
EgtEnableModified()
|
||||
end
|
||||
|
||||
MACH.ERR = 0
|
||||
@@ -0,0 +1,44 @@
|
||||
-- 2018/11/21 16:30:00
|
||||
-- Machining Init for Essetre-FAST machine
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EgtBase')
|
||||
_ENV = EgtProtectGlobal()
|
||||
EgtEnableDebug( false)
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- *** Ingresso in Lavorazioni ***
|
||||
|
||||
-- Rendo visibile il pezzo e le geometrie aggiunte, nascondo il Box
|
||||
local function ProcessPart( PartId)
|
||||
-- nascondo il Box
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( PartId, 'Box') or GDB_ID.NULL, GDB_ST.OFF)
|
||||
end
|
||||
|
||||
-- Disabilito segnalazione modifica progetto
|
||||
local bEnMod = EgtGetEnableModified()
|
||||
EgtDisableModified()
|
||||
|
||||
-- Processo i pezzi nella radice
|
||||
local PartId = EgtGetFirstPart()
|
||||
while PartId do
|
||||
ProcessPart( PartId)
|
||||
PartId = EgtGetNextPart( PartId)
|
||||
end
|
||||
|
||||
-- Processo i pezzi già nei gruppi di lavoro (quando appena lanciata Process)
|
||||
local GhostId = EgtGetFirstGhostPart()
|
||||
while GhostId do
|
||||
local PartId = EgtGetInfo( GhostId, GDB_SI.SOURCE, 'i')
|
||||
if PartId then
|
||||
ProcessPart( PartId)
|
||||
end
|
||||
GhostId = EgtGetNextGhostPart( GhostId)
|
||||
end
|
||||
|
||||
-- Ripristino segnalazione modifica progetto
|
||||
if bEnMod then
|
||||
EgtEnableModified()
|
||||
end
|
||||
|
||||
MACH.ERR = 0
|
||||
@@ -0,0 +1,213 @@
|
||||
-- 2023/06/28
|
||||
-- Gestione attrezzaggio per Essetre-WallXS0014
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EgtBase')
|
||||
_ENV = EgtProtectGlobal()
|
||||
EgtEnableDebug( false)
|
||||
|
||||
-- Tavola di passaggio valori
|
||||
local STU = {}
|
||||
STU.TUUID = ""
|
||||
STU.TCPOS = ""
|
||||
STU.HEAD = ""
|
||||
STU.GROUP = ""
|
||||
STU.POS = ""
|
||||
STU.EXIT = 0
|
||||
STU.INDEX = 0
|
||||
STU.HEAD1 = ""
|
||||
STU.HEAD2 = ""
|
||||
STU.ISVALID = false
|
||||
STU.ERR = 0
|
||||
_G.STU = STU
|
||||
|
||||
local INVALIDPOS = ""
|
||||
local POS = "Pos"
|
||||
|
||||
-- Geom Set
|
||||
local GS = {}
|
||||
|
||||
-- Flag presenza sega a catena e chiodatrici/graffettatrici
|
||||
local bChainSaw = ( EgtGetHeadId( 'H3') ~= nil)
|
||||
local bNail11 = ( EgtGetHeadId( 'H11') ~= nil)
|
||||
local bNail12 = ( EgtGetHeadId( 'H12') ~= nil)
|
||||
|
||||
-- Configurazione posizioni
|
||||
local PositionTable={{Pos = "Pos1", TcPos = "T9", Head = "H1", Group = "G1"},
|
||||
{Pos = "Pos2", TcPos = "T1", Head = "H2", Group = "G2"},
|
||||
{Pos = "Pos3", TcPos = "T2", Head = "H1", Group = "G2"},
|
||||
{Pos = "Pos4", TcPos = "T3", Head = "H1", Group = "G2"},
|
||||
{Pos = "Pos5", TcPos = "T4", Head = "H1", Group = "G2"},
|
||||
{Pos = "Pos6", TcPos = "T5", Head = "H1", Group = "G2"},
|
||||
{Pos = "Pos7", TcPos = "T6", Head = "H1", Group = "G2"},
|
||||
{Pos = "Pos8", TcPos = "T7", Head = "H1", Group = "G2"},
|
||||
{Pos = "Pos9", TcPos = "T8", Head = EgtIf( bChainSaw, "H3", "H1"), Group = "G2"},
|
||||
{Pos = "Pos10", TcPos = "T10", Head = "H1", Group = "G3"}}
|
||||
if bNail11 then
|
||||
table.insert( PositionTable, {Pos = "Pos11", TcPos = "T11", Head = "H11", Group = "G4"})
|
||||
end
|
||||
if bNail12 then
|
||||
if bNail11 then
|
||||
table.insert( PositionTable, {Pos = "Pos12", TcPos = "T12", Head = "H12", Group = "G4"})
|
||||
else
|
||||
table.insert( PositionTable, {Pos = "Pos11", TcPos = "T12", Head = "H12", Group = "G4"})
|
||||
end
|
||||
end
|
||||
|
||||
local UsePositionHead = true
|
||||
|
||||
local function IsInGeomSet( ToolHead, PosHead)
|
||||
for GsIndex = 1, #GS do
|
||||
local bToolHead = false
|
||||
local bPosHead = false
|
||||
for HIndex = 1, #GS[GsIndex] do
|
||||
if GS[GsIndex][HIndex] == ToolHead then
|
||||
bToolHead = true
|
||||
elseif GS[GsIndex][HIndex] == PosHead then
|
||||
bPosHead = true
|
||||
end
|
||||
if bToolHead and bPosHead then
|
||||
return true
|
||||
end
|
||||
end
|
||||
if bToolHead and bPosHead then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
function STU.IsCompatibleHeads()
|
||||
STU.ISVALID = false
|
||||
if IsInGeomSet(STU.HEAD1, STU.HEAD2) then
|
||||
STU.ISVALID = true
|
||||
else
|
||||
STU.ISVALID = false
|
||||
end
|
||||
end
|
||||
|
||||
function STU.GetValidHeadExitForPos()
|
||||
-- se TUUID non valido restituisco errore
|
||||
local ToolName = EgtTdbGetToolFromUUID( STU.TUUID)
|
||||
if ToolName == nill then
|
||||
STU.ERR = 1
|
||||
return
|
||||
end
|
||||
EgtTdbSetCurrTool( ToolName)
|
||||
local CurrToolHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
||||
STU.EXIT = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
|
||||
-- recupero testa predefinita per la posizione corrente
|
||||
local CurrPosHead
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
CurrPosHead = PositionTable[i].Head
|
||||
break
|
||||
end
|
||||
end
|
||||
-- verifico se la testa è quella della posizione predefinita
|
||||
if CurrPosHead == CurrToolHead then
|
||||
STU.HEAD = CurrToolHead
|
||||
STU.ERR = 0
|
||||
return
|
||||
-- verifico se la testa è compatibile con quella della posizione predefinita
|
||||
elseif IsInGeomSet( CurrToolHead, CurrPosHead) then
|
||||
if UsePositionHead then
|
||||
STU.HEAD = CurrPosHead
|
||||
STU.ERR = 0
|
||||
return
|
||||
else
|
||||
STU.HEAD = CurrToolHead
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
-- la testa non è compatibile con quella della posizione predefinita
|
||||
else
|
||||
STU.HEAD = INVALIDPOS
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
function STU.IsValidTcPosFromHead()
|
||||
STU.ISVALID = false
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
if PositionTable[i].Head == STU.HEAD then
|
||||
STU.ISVALID = true
|
||||
STU.ERR = 0
|
||||
return
|
||||
elseif IsInGeomSet(PositionTable[i].Head, STU.HEAD) then
|
||||
STU.ISVALID = true
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
STU.ISVALID = false
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function STU.GetTcPosHeadGroupFromPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].Pos == (POS .. tostring(STU.INDEX)) then
|
||||
STU.TCPOS = PositionTable[i].TcPos
|
||||
STU.HEAD = PositionTable[i].Head
|
||||
STU.GROUP = PositionTable[i].Group
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.TCPOS = INVALIDPOS
|
||||
STU.HEAD = INVALIDPOS
|
||||
STU.GROUP = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetPosFromTcPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
STU.POS = PositionTable[i].Pos
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.POS = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetGroupFromTcPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
STU.GROUP = PositionTable[i].Group
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.GROUP = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetHeadFromPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].Pos == (POS .. tostring(STU.INDEX)) then
|
||||
STU.HEAD = PositionTable[i].Head
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.HEAD = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetTcPosFromPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].Pos == (POS .. tostring(STU.INDEX)) then
|
||||
STU.TCPOS = PositionTable[i].TcPos
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.TCPOS = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 9.8 KiB |
@@ -0,0 +1,14 @@
|
||||
; Commento per evitare BOM con UTF-8
|
||||
[General]
|
||||
Pos1=T9;H1;1/C24D419A-4196-4A93-A392-AB60F7C21FA9/Fresa20x50
|
||||
Pos2=T1;H2;1/B68769CD-E781-4A6E-B8E8-25DABB823898/Lama450
|
||||
Pos3=T2
|
||||
Pos4=T3
|
||||
Pos5=T4;H1;1/0A54F32E-C48D-45DB-8502-953CA94FD7A0/Fresa14.5x100
|
||||
Pos6=T5;H1;1/0D83BA50-5D8F-4831-8EEF-CD2BCF6E21F2/Fresa200
|
||||
Pos7=T6
|
||||
Pos8=T7;H1;1/EC758B83-51D2-4247-B406-C13581AAC5C5/PuntaD18
|
||||
Pos9=T8;H1;1/B449357F-293E-4EDC-8EE4-127A9863F116/PuntaD12
|
||||
Pos10=T10;H1;1/B758356D-D1A5-4DA7-A0BC-65F59CA1DA24/Fresa25x130
|
||||
Pos11=T11;H11;1/C6F17A98-329D-410A-A339-51059CCE1A83/11
|
||||
Pos12=T12;H12;1/7EAAE1B6-0429-4074-A4E5-3E897BEEF424/12
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,12 @@
|
||||
-- CutData.lua by Egaltech s.r.l. 05/07/2022 19:29:52
|
||||
-- Gestione dati lavorazioni per Travi
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local CutData = {
|
||||
{ On = false, Name = 'Cutting300', Type = 'Standard'},
|
||||
{ On = true, Name = 'Cutting300Pull', Type = 'Standard'},
|
||||
{ On = true, Name = 'Cutting450', Type = 'Standard'}
|
||||
}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return CutData
|
||||
@@ -0,0 +1,19 @@
|
||||
-- DrillData.lua by Egaltech s.r.l. 04/03/2022 16:10:20
|
||||
-- Gestione dati lavorazioni per Travi
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local DrillData = {
|
||||
{ On = true, Name = 'DrillD7', Type = 'Drill'},
|
||||
{ On = true, Name = 'DrillD14', Type = 'Drill'},
|
||||
{ On = true, Name = 'DrillD16', Type = 'Drill'},
|
||||
{ On = true, Name = 'DrillD18', Type = 'Drill'},
|
||||
{ On = true, Name = 'DrillD20', Type = 'Drill'},
|
||||
{ On = true, Name = 'DrillD32', Type = 'Drill'},
|
||||
{ On = false, Name = 'DrillD35', Type = 'Drill'},
|
||||
{ On = true, Name = 'DrillPockD20', Type = 'Pocket'},
|
||||
{ On = true, Name = 'DrillPockD25', Type = 'Pocket'},
|
||||
{ On = true, Name = 'DrillPockD40X120', Type = 'Pocket'}
|
||||
}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return DrillData
|
||||
@@ -0,0 +1,24 @@
|
||||
[Cut]
|
||||
1=Standard
|
||||
|
||||
[Drill]
|
||||
1=Drill
|
||||
2=Pocket
|
||||
|
||||
[Milling]
|
||||
1=FreeContour
|
||||
2=Side
|
||||
3=SideGroove
|
||||
4=DtMortise
|
||||
5=Mark
|
||||
6=Text
|
||||
7=CleanCorner60
|
||||
8=CleanCorner30
|
||||
9=Nailing
|
||||
|
||||
[Pocketing]
|
||||
1=Pocket
|
||||
2=Mortise
|
||||
|
||||
[Sawing]
|
||||
1=Sawing
|
||||
@@ -0,0 +1,18 @@
|
||||
-- MillingData.lua by Egaltech s.r.l. 24/05/2022 08:41:12
|
||||
-- Gestione dati lavorazioni per Travi
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local MillingData = {
|
||||
{ On = true, Name = 'Milling200x63', Type = 'Side'},
|
||||
{ On = true, Name = 'MillingBH', Type = 'SideGroove'},
|
||||
{ On = true, Name = 'Milling25x130', Type = 'FreeContour'},
|
||||
{ On = true, Name = 'Milling20x50', Type = 'FreeContour'},
|
||||
{ On = true, Name = 'Clean60x40', Type = 'CleanCorner60'},
|
||||
{ On = true, Name = 'Clean30x40', Type = 'CleanCorner30'},
|
||||
{ On = true, Name = 'Text45x40', Type = 'Text'},
|
||||
{ On = true, Name = 'Nailing_11', Type = 'Nailing'},
|
||||
{ On = true, Name = 'Nailing_12', Type = 'Nailing'}
|
||||
}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return MillingData
|
||||
@@ -0,0 +1,15 @@
|
||||
-- PocketingData.lua by Egaltech s.r.l. 02/05/2022 09:25:48
|
||||
-- Gestione dati lavorazioni per Travi
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local PocketingData = {
|
||||
{ On = true, Name = 'Svuot20x50', Type = 'Pocket'},
|
||||
{ On = true, Name = 'Svuot100x60', Type = 'Pocket'},
|
||||
{ On = true, Name = 'Svuot25x130', Type = 'Pocket'},
|
||||
{ On = true, Name = 'Svuot40x120', Type = 'Pocket'},
|
||||
{ On = true, Name = 'Svuot20x50', Type = 'OpenPocket'},
|
||||
{ On = true, Name = 'Svuot25x130', Type = 'OpenPocket'}
|
||||
}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return PocketingData
|
||||
@@ -0,0 +1,10 @@
|
||||
-- SawingData.lua by Egaltech s.r.l. 14/12/2021 16:37:13
|
||||
-- Gestione dati lavorazioni per Travi
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local SawingData = {
|
||||
{ On = true, Name = 'TaglioCatena', Type = 'Sawing'}
|
||||
}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return SawingData
|
||||
@@ -0,0 +1,233 @@
|
||||
-- C:\TechnoEssetre7\EgtData\Essetre-Wall_XS0014.data
|
||||
|
||||
local Offsets = {
|
||||
MIN_X=-3900,
|
||||
MAX_X=45,
|
||||
MIN_Y=-22010,
|
||||
MAX_Y=0.1,
|
||||
MIN_Z=-875,
|
||||
MAX_Z=0,
|
||||
MIN_B=-120,
|
||||
MAX_B=120,
|
||||
MIN_C=-360,
|
||||
MAX_C=360,
|
||||
TIPO_CN=1,
|
||||
ZERO_X=-192.5,
|
||||
ZERO_Y=-1033.3,
|
||||
ZERO_Z=-781.4,
|
||||
PIVOT=92.9,
|
||||
OFFSET_ZERO3_X=0,
|
||||
OFFSET_ZERO3_Y=-9013.3,
|
||||
OFFSET_ZERO3_Z=0,
|
||||
ZERO_NAIL11_X=-455.0,
|
||||
ZERO_NAIL11_Y=-722.0,
|
||||
ZERO_NAIL11_Z=-573.7,
|
||||
ZERO_NAIL12_X=72,
|
||||
ZERO_NAIL12_Y=-716,
|
||||
ZERO_NAIL12_Z=-569.5,
|
||||
CHAIN_SAW=0,
|
||||
NAIL11=1,
|
||||
NAIL12=1,
|
||||
DELTA_X=0,
|
||||
OFFSET_ZERO11_X=-5.9,
|
||||
OFFSET_ZERO11_Y=-11639.8,
|
||||
OFFSET_ZERO11_Z=0,
|
||||
OFFSET_ZERO13_X=-5.9,
|
||||
OFFSET_ZERO13_Y=-20655.7,
|
||||
OFFSET_ZERO13_Z=0,
|
||||
Zzz=1
|
||||
}
|
||||
|
||||
local Trave = {
|
||||
XMIN=10,
|
||||
XMAX=3590,
|
||||
YMIN=50,
|
||||
YMAX=9350,
|
||||
ZMIN=1,
|
||||
ZMAX=400,
|
||||
ZMAX_LAYERS=400,
|
||||
Zzz=1
|
||||
}
|
||||
|
||||
local User = {
|
||||
VELOCITA_VELOCITARAPIDOFRESE=10000,
|
||||
VELOCITA_VELOCITA_USCITA_LAMA=20000,
|
||||
VELOCITA_FEED_ENTRY=5000,
|
||||
VELOCITA_FEED_EXIT=20000,
|
||||
NESTING_MATERIAL=1,
|
||||
NESTING_TYPEEXTERNALOP=1,
|
||||
NESTING_FROM_BTL=1,
|
||||
NESTING_ORDINA=1,
|
||||
NESTING_NOCOMPAT=0,
|
||||
PROFILES_PROF_SMUSSO=5,
|
||||
PAUSE_ACTIVE_PAUSE=0,
|
||||
SAFETY_DISTANCE_ZSAVE=40,
|
||||
OPTIMIZATIONS_ENABLE_SLICES_F5=0,
|
||||
OPTIMIZATIONS_LENGTH_MAX_SCRAP_F5=799,
|
||||
OPTIMIZATIONS_LENGTH_MAX_SCRAP_F5_P5=1350,
|
||||
OPTIMIZATIONS_ENABLE_SLICES_F6=0,
|
||||
OPTIMIZATIONS_LENGTH_SLICES=150,
|
||||
OPTIMIZATIONS_SYMMETRIC_HEADS_PF=0,
|
||||
OPTIMIZATIONS_RECOVERY_PRINT_ONLY=1,
|
||||
L056_DISTSICUR=5,
|
||||
L056_ENTRY_SPLINTER=10,
|
||||
L056_ACTIVE_AS=1,
|
||||
L055_ADD_P13=0,
|
||||
L055_MODSAG=1,
|
||||
L055_DISTSICUR=20,
|
||||
L055_ENTRY_SPLINTER=20,
|
||||
L055_TOLL_W=0,
|
||||
L055_ACTIVE_AS=1,
|
||||
L051_FORCE_P4=0,
|
||||
L050_ATTIVA_CICLO_L050=0,
|
||||
L050_FORCE_P4=0,
|
||||
L050_ISOOUTSVUOTA=1,
|
||||
L050_ADDDEPTH=0,
|
||||
L050_DIAM_LUNG=1,
|
||||
L050_USE2HEAD=0,
|
||||
L053_ISOOUTSVUOTA=2,
|
||||
L053_DIAM_LUNG=1,
|
||||
L060_PEN_F2=2,
|
||||
L060_PEN_F1=2,
|
||||
L060_ORTHO_WRITER=0,
|
||||
L060_ORTHO_WRITER_ADD_Y=0,
|
||||
L060_DISABLE_L060=0,
|
||||
L060_PEN_POSITION=0,
|
||||
L101_MANUAL_POSITIONING=0,
|
||||
L102_MANUAL_POSITIONING=0,
|
||||
L103_MANUAL_POSITIONING=0,
|
||||
L103_RID_SCALA_SMUSSO=5,
|
||||
L103_ADD_WIDTH=0,
|
||||
L103_ADD_WIDTH_CHAMFER=0,
|
||||
L106_MANUAL_POSITIONING=0,
|
||||
L106_RANGE=0,
|
||||
L106_ADD_WIDTH=0,
|
||||
L106_ASL=0,
|
||||
L106_ASL_DEPTH=0,
|
||||
L138_TOLLERANZA=0,
|
||||
L052_ATTIVA_CICLO_MASCHIO=2,
|
||||
L052_RIDLARGL052=0,
|
||||
L052_REDUCTION=0,
|
||||
L037_FEED_1=2000,
|
||||
L037_FEED_2=4000,
|
||||
L037_FEED_3=3000,
|
||||
L037_MIN_LENGTH_ROT_AXE_A=130,
|
||||
L037_TOOL_WIDTH=0,
|
||||
L034_CHAMFER=0,
|
||||
L034_FEED_CHAMFER=3000,
|
||||
L034_PROF_AS=180,
|
||||
L034_USE_SAW=19,
|
||||
L034_LENGTH_MIN_DIV=900,
|
||||
L032_ADD_P13=0,
|
||||
L032_LENGTH_MIN_DIV=900,
|
||||
T055_DISTSICURTENON=5,
|
||||
T055_RIDP11=1,
|
||||
T055_RIDLARGT055=0,
|
||||
T055_ACTIVE_AS=1,
|
||||
T055_ADDP15=0,
|
||||
T050_REDUCTION=2,
|
||||
T050_RIDLARGT050=0,
|
||||
T050_RIDALTET050=0,
|
||||
T050_FORCE_P4=0,
|
||||
T050_ATTIVA_CICLO_MASCHIO=0,
|
||||
T050_FEED_ENTRY=1500,
|
||||
L040_ADD_P11=1,
|
||||
L040_ADD_P11_PASS=0,
|
||||
L040_OFFSET_P1=-1,
|
||||
L040_OFFSET_P1_MAX_DISTANCE=0,
|
||||
L040_2_DRILLINGS=0,
|
||||
L040_TYPEDRILLING=1,
|
||||
L040_USE2HEAD=0,
|
||||
L017_ATTIVA_CICLO_MASCHIO=0,
|
||||
L017_USAMORTASA_TURN=0,
|
||||
L017_USAMORTASA=0,
|
||||
L017_USE_SAW=0,
|
||||
L017_GLOBAL_CUT=0,
|
||||
L017_P7MAGG90=0,
|
||||
L017_DIAM_LUNG=1,
|
||||
L012_ENABLE_180=0,
|
||||
L012_LIM=1,
|
||||
L012_WORK_F1=0,
|
||||
L012_MM_WORK_F1=0,
|
||||
L012_LENGTH_MIN_DIV=900,
|
||||
L012_USCITA_COMPLUVIO=0,
|
||||
L012_ALT_MAX_LAMA=361,
|
||||
L010_ENABLE_180=0,
|
||||
L010_LIM=0,
|
||||
L010_MM_SLICES=150,
|
||||
L010_LONGITUDINAL_CYCLE=0,
|
||||
L010_LENGTH_MIN_DIV=900,
|
||||
L010_ALT_MAX_LAMA=361,
|
||||
L016_CYCLE_ZPASS=0,
|
||||
L016_USAMORTASA=0,
|
||||
L016_LENGTH_MIN_DIV=2000,
|
||||
L020_DIAM_HOLE=0,
|
||||
L020_OFFSET_P1=0,
|
||||
L020_MANUAL_POSITIONING=0,
|
||||
L020_DIAM_HOLE_INV=0,
|
||||
L020_DOUBLE_HOLE=1,
|
||||
L020_ANTISCHEGGIA_LAMA=0,
|
||||
L020_ALTMAXLAMA=360,
|
||||
L030_NO_CAT_FIN=1,
|
||||
L030_AUM_DIM=0,
|
||||
L030_USE_ONLY_MILLER=0,
|
||||
L030_PAUSE_PARETI=2,
|
||||
L030_DELTA_PORTALE=500,
|
||||
L030_ANTISCHEGGIA_FRESA=0,
|
||||
L030_ANTISCHEGGIA_LAMA=0,
|
||||
L030_ANTISCHEGGIA_LIMITE_MINIMO=0,
|
||||
L030_USE_BIG_MILLER=1,
|
||||
L030_MAX_HAUTEUR_OUTIL_203=350,
|
||||
L030_MAX_LARGEUR_OUTIL_203=250,
|
||||
L030_OFFSET_P1_OUTIL_203=0,
|
||||
L030_SORMONTO_TASCA=0,
|
||||
L030_ATTIVA_CICLO_FEMMINA=0,
|
||||
L030_DISTANCE_FOR_TOOL_TYPE_4=135,
|
||||
L030_USE_SAW_P4_12=16,
|
||||
L030_LENGTH_MIN_DIV=900,
|
||||
L030_OFFSETPIANOCATENA=15,
|
||||
T010_TYPECUT=0,
|
||||
T010_LENGHT_SLICES=400,
|
||||
T010_ADD_EXIT_ORIZZ=26,
|
||||
T010_ADD_EXIT=26,
|
||||
T010_DISTSICURCUT=15,
|
||||
T010_ADD_EXIT_DOLAMA=10,
|
||||
T010_TRONCA_DOPPIA_PENDENZA=0,
|
||||
T010_TRONCATURA_CON_G107=1,
|
||||
T010_DISABILITA_TRONCATURA=0,
|
||||
T010_DOUBLE_CUT_HALF=0,
|
||||
T010_ALT_CAMBIO_TRONCATURA_FAST=360,
|
||||
T010_NO_START_X=0,
|
||||
T010_DIST_INF_HEAD=110,
|
||||
T010_ADD_ENTRY_CUT=20,
|
||||
T010_USACATENA=1,
|
||||
T010_ALTCATENA=362,
|
||||
T010_USA_TRUCIOLATORE=1,
|
||||
T010_OFFSETPIANOCATENA=20,
|
||||
T010_DISABLE_MILLING_AFTER_DIVISION=0,
|
||||
T010_SAFETY_DISTANCE=5,
|
||||
T010_ROT_C_SAW=700,
|
||||
T010_FEED_ENTRY_SAW=4900,
|
||||
T010_USASEMPRECATENA=0,
|
||||
T010_T010ORIZZFINITURA=0,
|
||||
T010_TAGLLAT=0,
|
||||
P010_DEPTH=6,
|
||||
P011_DISTSICURTENON=5,
|
||||
P011_RIDLARGT055=0,
|
||||
P011_RIDP11=2,
|
||||
P011_ACTIVE_AS=1,
|
||||
L038_ACTIVE_CUT=1,
|
||||
L036_LENGTH_MIN_DIV=900,
|
||||
T138_OFFSETTIMBERLAKE=0,
|
||||
WUP_LAVSOLOEST=1,
|
||||
T030_LENGTH_MIN_DIV=500,
|
||||
T030_ANGMAXINF=15,
|
||||
L013_LENGTH_MIN_DIV=2000,
|
||||
P003_ALT_MAX_LAMA=440,
|
||||
P003_OFFSETPIANOCATENA=0,
|
||||
T080_ALTCATENA=399,
|
||||
Zzz=1
|
||||
}
|
||||
|
||||
local Machine = { Offsets=Offsets, Trave=Trave, User=User}
|
||||
return Machine
|
||||
@@ -0,0 +1,120 @@
|
||||
-- WallData.lua by Egaltech s.r.l. 2023/06/28
|
||||
-- Raccolta dati generali per Pareti
|
||||
|
||||
EgtOutLog( ' Wall_XS0014-WallData started', 1)
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local WallData = {
|
||||
MIN_LENGTH = 100, -- lunghezza minima del grezzo
|
||||
MIN_WIDTH = 100, -- larghezza minima del grezzo
|
||||
MIN_HEIGHT = 10, -- altezza minima del grezzo
|
||||
MAX_LENGTH = 18000, -- lunghezza massima del grezzo
|
||||
MAX_WIDTH = 4900, -- larghezza massima del grezzo
|
||||
MAX_HEIGHT = 400, -- altezza massima del grezzo
|
||||
STD_RAW_LENGTH = 10000, -- lunghezza standard del grezzo
|
||||
STD_RAW_WIDTH = 4000, -- larghezza standard del grezzo
|
||||
OVM_HEAD = 60, -- sovramateriale testa
|
||||
OVM_MID = 50, -- sovramateriale intermedio
|
||||
COLL_SIC = 5, -- distanza di sicurezza per collisioni
|
||||
CUT_SIC = 20, -- distanza di sicurezza per tagli
|
||||
CUT_EXTRA = 0, -- affondamento extra standard per tagli di lama e fresature
|
||||
CUT_EXTRA_MIN = 0, -- affondamento extra ridotto per tagli di lama e fresature
|
||||
NZ_MINA = 0.5, -- componente limite in Z normale di una faccia (-30deg)
|
||||
NZ_MINB = -0.4, -- componente limite in Z normale di un insieme di facce (-23deg)
|
||||
DRILL_TOL = 0.5, -- tolleranza tra diametro foro e diametro punta
|
||||
DRILL_VZ_MIN = 0.5, -- componente limite in Z del versore di un foro
|
||||
DRILL_VX_MAX = 0.866, -- componente limite in X del versore di un foro sulle facce laterali
|
||||
DRILL_OVERLAP = 5, -- sovrapposizione tra due mezze forature
|
||||
MILL_OVERLAP = 5, -- sovrapposizione tra due mezze fresature
|
||||
RAWCOL = { 255, 160, 32, 30}, -- colore del grezzo
|
||||
SIMUL_VIEW_DIR = 3, -- direzione di vista predefinita per la simulazione (1=NW, 2=SW, 3=NE, 4=SE)
|
||||
ORIG_CORNER = 'TL', -- angolo tavola per origine di battuta (BR (default), TR, BL, TL)
|
||||
MAX_CLEAN_CRN30 = 60, -- massimo spessore per pulitura angolo con fresa 30deg
|
||||
MIN_DIM_ALLOW_CLEAN = 200, -- apertura minima per lavorazione pulitura spigolo
|
||||
USE_POSY = true, -- utilizzare POSY di BTL (spostamento sullo spessore per pareti a layer)
|
||||
MILL_MAX_DEPTH_AS_MAT = true, -- massimo affondamento frese uguale ad altezza tagliente (max materiale)
|
||||
CHECK_MIN_Z_SAW = false, -- controlla la quota minima della lama rispetto alla tavola (default true)
|
||||
TAB_EXTRA_XP = 3000, -- extra spazio su tavola per grezzo in X più
|
||||
TAB_EXTRA_XM = 0, -- extra spazio su tavola per grezzo in X meno
|
||||
TAB_EXTRA_YP = 0, -- extra spazio su tavola per grezzo in Y più
|
||||
TAB_EXTRA_YM = 100, -- extra spazio su tavola per grezzo in Y meno
|
||||
MID_REF = 9000, -- offset X per origini TM e BM
|
||||
NEW_REF =11640, -- offset X per origini TN e BN
|
||||
DELTA_Y = 0, -- allontanamento in Y dai riferimenti
|
||||
DELTA_Z = 0 -- sollevamento dalla tavola
|
||||
}
|
||||
|
||||
-- Aggiornamento con dati da TechnoEssetre7
|
||||
local sTs3Data = EgtGetStringFromIni( 'Wall', 'DATA_DIR', "C:\\TechnoEssetre7\\EgtData", EgtGetIniFile()).."\\Essetre-Wall_XS0014.data"
|
||||
local sData = EgtGetSourceDir().."\\Ts3Data.lua"
|
||||
if EgtExistsFile( sTs3Data) then
|
||||
EgtCopyFile( sTs3Data, sData)
|
||||
local sTs3DataOld = sTs3Data..'.old'
|
||||
EgtEraseFile( sTs3DataOld)
|
||||
EgtRenameFile( sTs3Data, sTs3DataOld)
|
||||
end
|
||||
if EgtExistsFile( sData) then
|
||||
local Machine = dofile( sData)
|
||||
if Machine then
|
||||
if Machine.Trave then
|
||||
WallData.MIN_LENGTH = Machine.Trave.YMIN or WallData.MIN_LENGTH
|
||||
WallData.MIN_WIDTH = Machine.Trave.XMIN or WallData.MIN_WIDTH
|
||||
WallData.MIN_HEIGHT = Machine.Trave.ZMIN or WallData.MIN_HEIGHT
|
||||
WallData.MAX_LENGTH = Machine.Trave.YMAX or WallData.MAX_LENGTH
|
||||
WallData.MAX_WIDTH = Machine.Trave.XMAX or WallData.MAX_WIDTH
|
||||
WallData.MAX_HEIGHT = Machine.Trave.ZMAX or WallData.MAX_HEIGHT
|
||||
end
|
||||
if Machine.Offsets then
|
||||
WallData.DELTA_Y = Machine.Offsets.DELTA_X or WallData.DELTA_Y
|
||||
WallData.DELTA_Z = Machine.Offsets.DELTA_Z or WallData.DELTA_Z
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
local function GetChainSawBlockedAxis( nInd)
|
||||
--if nInd == 1 then
|
||||
return 'A1=270'
|
||||
--else
|
||||
-- return 'A1=0'
|
||||
--end
|
||||
end
|
||||
WallData.GetChainSawBlockedAxis = GetChainSawBlockedAxis
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
local function GetSawHeadSide( dSpeed, sHead)
|
||||
local sMchNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
||||
if not sMchNotes or not string.find( sMchNotes, 'PULL;', 1, true) then
|
||||
return EgtIf( dSpeed < 0, MCH_SAW_HS.LEFT, MCH_SAW_HS.RIGHT)
|
||||
else
|
||||
return EgtIf( dSpeed > 0, MCH_SAW_HS.LEFT, MCH_SAW_HS.RIGHT)
|
||||
end
|
||||
end
|
||||
WallData.GetSawHeadSide = GetSawHeadSide
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
local function GetOrigCorner( RefPos)
|
||||
if RefPos == 1 then
|
||||
return 'TL'
|
||||
elseif RefPos == 2 then
|
||||
return 'BL'
|
||||
elseif RefPos == 3 then
|
||||
return 'TM'
|
||||
elseif RefPos == 4 then
|
||||
return 'BM'
|
||||
elseif RefPos == 5 then
|
||||
return 'TN'
|
||||
elseif RefPos == 6 then
|
||||
return 'BN'
|
||||
elseif RefPos == 7 then
|
||||
return 'TR'
|
||||
elseif RefPos == 8 then
|
||||
return 'BR'
|
||||
else
|
||||
return 'TL'
|
||||
end
|
||||
end
|
||||
WallData.GetOrigCorner = GetOrigCorner
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return WallData
|
||||
@@ -0,0 +1,9 @@
|
||||
-- %TABLE_NAME%.lua by Egaltech s.r.l. %DATE_TIME%
|
||||
-- Gestione dati lavorazioni per Travi
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local %TABLE_NAME% = {
|
||||
}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return %TABLE_NAME%
|
||||
Reference in New Issue
Block a user