Compare commits
3 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 andrea.villa
|
94c0729630 | ||
|
andrea.villa
|
b96009933a | ||
|
andrea.villa
|
689fab0c05 |
@@ -42,7 +42,6 @@ local BeamData = {
|
||||
DRILL_TOL = 0.2, -- tolleranza tra diametro foro e diametro punta
|
||||
DRILL_VZ_MIN = - 0.51, -- componente limite in Z del versore di un foro
|
||||
DRILL_VX_MAX = 0.867, -- componente limite in X del versore di un foro sulle facce laterali
|
||||
MAX_ANGLE_DRILL_CUT = 15, -- delta angolo massimo tra foro e taglio che lo attraversa
|
||||
DRILL_OVERLAP = 5, -- sovrapposizione tra due mezze forature
|
||||
MILL_OVERLAP = 5, -- sovrapposizione tra due mezze fresature
|
||||
MAX_DIST_HTFEA = 50.0, -- massima distanza di feature da testa o coda per essere considerata tale
|
||||
@@ -114,11 +113,7 @@ if EgtExistsFile( sDataBeam) then
|
||||
BeamData.ADVANCE_TAIL_OFFS = Machine.Offsets.ADVANCE_TAIL_OFFS or BeamData.ADVANCE_TAIL_OFFS
|
||||
BeamData.LEN_VERY_SHORT_PART = Machine.Offsets.LEN_VERY_SHORT_PART or BeamData.LEN_VERY_SHORT_PART
|
||||
BeamData.LEN_SHORT_PART = Machine.Offsets.LEN_SHORT_PART or BeamData.LEN_SHORT_PART
|
||||
if Machine.Offsets.MAX_ANGLE_DRILL_CUT then BeamData.MAX_ANGLE_DRILL_CUT = EgtClamp( Machine.Offsets.MAX_ANGLE_DRILL_CUT, 1, 89) end
|
||||
BeamData.OVM_MID = Machine.Offsets.OVM_MID or BeamData.OVM_MID
|
||||
if Machine.Offsets.CUT_SIC then BeamData.CUT_SIC = EgtClamp( Machine.Offsets.CUT_SIC, 15, 50) end
|
||||
if Machine.Offsets.MIN_JOIN_S then BeamData.MIN_JOIN_S = EgtClamp( Machine.Offsets.MIN_JOIN_S, 80, 150) end
|
||||
if Machine.Offsets.MIN_JOIN_L then BeamData.MIN_JOIN_L = EgtClamp( Machine.Offsets.MIN_JOIN_L, 300, 450) end
|
||||
end
|
||||
if Machine.Trave then
|
||||
BeamData.MIN_WIDTH = Machine.Trave.XMIN or BeamData.MIN_WIDTH
|
||||
|
||||
@@ -50,6 +50,7 @@
|
||||
33=AntiSplintMillCut_H2
|
||||
34=SideMillAsBlade
|
||||
35=SideMillAsBlade_H2
|
||||
36=Prof_end
|
||||
|
||||
[Pocketing]
|
||||
1=Pocket
|
||||
|
||||
+361
-648
File diff suppressed because it is too large
Load Diff
+92
-517
@@ -79,14 +79,6 @@ function OnSimulStart()
|
||||
for j = 1, #( vTools or {}) do
|
||||
if vTools[j] ~= '' then
|
||||
EgtLoadTool( vTcPos[i], j, vTools[j])
|
||||
-- Aggiunto controllo lunghezza lama minima * 0.9 per ricavare la tolleranza del VMILL
|
||||
if EgtTdbSetCurrTool(vTools[j]) then -- set utensile corrente
|
||||
if EgtTdbGetCurrToolParam( MCH_TP.TYPE) == MCH_TY.SAW_STD or EgtTdbGetCurrToolParam( MCH_TP.TYPE) == MCH_TY.SAW_FLAT then -- controllo tipo utensile sega
|
||||
local dCurrSawLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) * 0.9
|
||||
-- se non definito o minore del valore precedente aggiorna la tolleranza
|
||||
EMT.VMILLTOL = EgtIf( not EMT.VMILLTOL or dCurrSawLen < EMT.VMILLTOL, dCurrSawLen, EMT.VMILLTOL)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
ShowToolInTcPos( vTcPos[i], true)
|
||||
@@ -160,10 +152,10 @@ function OnSimulStart()
|
||||
local nId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nGrpId, McdData[i].Sub), McdData[i].Name)
|
||||
if nId then
|
||||
table.insert( EMT.MCODET, nId)
|
||||
EgtOutLog( ' Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name .. ' (' .. tostring( nId) .. ') is ok', 4)
|
||||
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name .. ' (' .. tostring( nId) .. ') is ok', 4)
|
||||
else
|
||||
nMcdNullCnt = nMcdNullCnt + 1
|
||||
EgtOutLog( ' Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name .. ' is null', 4)
|
||||
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name .. ' is null', 4)
|
||||
end
|
||||
end
|
||||
if nMcdNullCnt > 0 then
|
||||
@@ -171,29 +163,6 @@ function OnSimulStart()
|
||||
end
|
||||
-- Preparo lista collisioni vuota
|
||||
EMT.COLLIDE = {}
|
||||
|
||||
-- si crea gruppo temporaneo appoggio controllo clamping
|
||||
CLAMP_CHECK_GROUP = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'CLAMP_CHECK')
|
||||
CLAMP_CHECK_INTERS = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'CLAMP_INTERS')
|
||||
|
||||
if CLAMP_CHECK_GROUP then
|
||||
EgtEmptyGroup( CLAMP_CHECK_GROUP)
|
||||
else
|
||||
local frClampCheckGroup = Frame3d( ORIG(), GDB_FR.FRONT)
|
||||
CLAMP_CHECK_GROUP = EgtGroup( GDB_ID.ROOT, frClampCheckGroup)
|
||||
EgtSetName( CLAMP_CHECK_GROUP, 'CLAMP_CHECK')
|
||||
EgtSetLevel( CLAMP_CHECK_GROUP, GDB_LV.TEMP)
|
||||
EgtSetStatus( CLAMP_CHECK_GROUP, GDB_ST.OFF)
|
||||
end
|
||||
|
||||
if CLAMP_CHECK_INTERS then
|
||||
EgtEmptyGroup( CLAMP_CHECK_INTERS)
|
||||
else
|
||||
CLAMP_CHECK_INTERS = EgtGroup( GDB_ID.ROOT)
|
||||
EgtSetName( CLAMP_CHECK_INTERS, 'CLAMP_INTERS')
|
||||
EgtSetLevel( CLAMP_CHECK_INTERS, GDB_LV.TEMP)
|
||||
EgtSetStatus( CLAMP_CHECK_INTERS, GDB_ST.OFF)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -257,7 +226,7 @@ function OnSimulDispositionStart()
|
||||
-- determino la risoluzione dello Zmap
|
||||
local dTol = 4.71
|
||||
if EmtGetVMillStep then
|
||||
dTol = EmtGetVMillStep( b3Raw:getDimX(), b3Raw:getDimY(), b3Raw:getDimZ(), dTol)
|
||||
dTol = EmtGetVMillStep( b3Raw:getDimX(), b3Raw:getDimY(), b3Raw:getDimZ(), 4.71)
|
||||
else
|
||||
local dArea = b3Raw:getDimX() * b3Raw:getDimY() + b3Raw:getDimX() * b3Raw:getDimZ() + b3Raw:getDimY() * b3Raw:getDimZ()
|
||||
if dArea < 0.075e6 then
|
||||
@@ -274,7 +243,6 @@ function OnSimulDispositionStart()
|
||||
dTol = 3.77
|
||||
end
|
||||
end
|
||||
dTol = min( dTol, EMT.VMILLTOL or dTol) -- imposto dTol al valore minore tra quello per volume e quello per spessore lama
|
||||
-- creo lo Zmap
|
||||
local VMillId = EgtVolZmapBox( nPartRawId, b3Raw:getMin(), b3Raw:getDimX(), b3Raw:getDimY(), b3Raw:getDimZ(), dTol, true, GDB_RT.GLOB)
|
||||
if VMillId then
|
||||
@@ -352,10 +320,6 @@ function OnSimulDispositionStart()
|
||||
EMT.LB = b3Bar:getDimX()
|
||||
EMT.LR = b3Raw:getDimX()
|
||||
EMT.LT = b3Part:getDimX()
|
||||
if b3Part:getMin() then
|
||||
EMT.XMINT = b3Part:getMin():getX() + ( EgtGetAxisPos( 'T') - EgtGetAxisHomePos( 'T'))
|
||||
end
|
||||
EMT.HOVM = EgtGetInfo( nPartRawId or GDB_ID.NULL, 'HOVM', 'd') or 0
|
||||
EMT.CUTID = EgtGetInfo( EgtGetFirstPartInRawPart( nPartRawId or GDB_ID.NULL) or GDB_ID.NULL, 'CUTID', 'i') or 0
|
||||
EMT.Y1SPEC = nil
|
||||
-- se vero inizio, assegno solidi per verifica collisione
|
||||
@@ -488,12 +452,10 @@ end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulToolSelect( dPosA)
|
||||
EgtOutLog( '===> ToolSelect : Reset CollisionObj', 4)
|
||||
-- se utensile non definito, è disposizione ed esco
|
||||
if EMT.TOOL == '' then return end
|
||||
-- recupero dati utensile
|
||||
EMT.TOOLTYPE = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
|
||||
EMT.TDIAM = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
||||
EMT.TLEN = EgtTdbGetCurrToolParam( MCH_TP.LEN)
|
||||
EMT.TTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
||||
EMT.TUSERNOTES = EgtTdbGetCurrToolParam( MCH_TP.USERNOTES)
|
||||
@@ -581,9 +543,9 @@ function OnSimulToolSelect( dPosA)
|
||||
-- se attivo Collision Check
|
||||
EMT.SAFEDIST = COLL_SAFE_DIST
|
||||
if EMT.COLLOBJ then
|
||||
local nInd = 1000 + tonumber( string.sub( EMT.HEAD, 2))
|
||||
local nInd = EgtIf( nSetHead ~= 2, 1001, 1011)
|
||||
AddToolToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd, true)
|
||||
AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd + 100)
|
||||
AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, nInd + 1)
|
||||
for i, Coll in ipairs( EMT.COLLOBJ or {}) do
|
||||
EmtAddCollisionObjEx( i, Coll.Fr, Coll.Ty, Coll.Mv, Coll.P1, Coll.P2, Coll.P3)
|
||||
end
|
||||
@@ -684,7 +646,7 @@ function OnSimulToolDeselect( dPrevA)
|
||||
-- se passo da testa 1 a 3 scarico aggregato
|
||||
if nNextSetHead == 3 then
|
||||
-- deposito utensile prelevato da posizioni speciali
|
||||
if EMT.PREVTCPOS_H1 == 'T101' or EMT.PREVTCPOS_H1 == 'T111' or EMT.PREVTCPOS_H1 == 'T121' then
|
||||
if EMT.TCPOS == 'T101' or EMT.TCPOS == 'T111' or EMT.TCPOS == 'T121' then
|
||||
-- visualizzo utensile su TcPos
|
||||
ShowToolInTcPos( EMT.PREVTCPOS_H1, true)
|
||||
-- nascondo l'utensile sulla testa
|
||||
@@ -742,9 +704,8 @@ function OnSimulToolDeselect( dPrevA)
|
||||
-- prendo utensile lama su aggregato
|
||||
elseif EMT.NEXTHEAD == 'H22' then
|
||||
-- aggiungo utensile per verifica collisione
|
||||
local nInd = 1000 + tonumber( string.sub( EMT.NEXTHEAD, 2))
|
||||
AddToolToCollisionObj( EMT.NEXTTOOL, EMT.NEXTHEAD, EMT.NEXTEXIT, nInd, false)
|
||||
AddToolHolderToCollisionObj( EMT.NEXTTOOL, EMT.NEXTHEAD, EMT.NEXTEXIT, nInd + 100)
|
||||
AddToolToCollisionObj( EMT.NEXTTOOL, EMT.NEXTHEAD, EMT.NEXTEXIT, 1011, false)
|
||||
AddToolHolderToCollisionObj( EMT.NEXTTOOL, EMT.NEXTHEAD, EMT.NEXTEXIT, 1011 + 1)
|
||||
-- simulo movimento
|
||||
SimulMoveAxis( 'X2', ParkSawX2, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxes( 'B2', ParkSawB2, MCH_SIM_STEP.COLLROT, 'C2', ParkSawC2, MCH_SIM_STEP.COLLROT)
|
||||
@@ -753,7 +714,6 @@ end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMachiningStart()
|
||||
EgtOutLog( '===> Start Machining : ' .. EgtGetName( EMT.MCHID), 4)
|
||||
-- se lavorazione è con gruppo a forare, abilito le altre punte alla lavorazione del VMILL
|
||||
if EMT.HEAD == 'H14' then
|
||||
local OtherTools = EgtGetToolsInCurrSetupPos( 'T121')
|
||||
@@ -762,7 +722,7 @@ function OnSimulMachiningStart()
|
||||
if OtherTools[i] ~= '' and OtherTools[i] ~= EMT.TOOL then
|
||||
EmtAddToolForVmill( OtherTools[i], 'H14', i, EMT.VMILL)
|
||||
-- dichiaro utensile per verifica collisioni
|
||||
local nInd = 1000 + tonumber( string.sub( 'H14', 2))
|
||||
local nInd = 1011
|
||||
AddToolToCollisionObj( OtherTools[i], 'H14', i, nInd, true)
|
||||
end
|
||||
end
|
||||
@@ -804,8 +764,6 @@ function OnSimulMachiningStart()
|
||||
EMT.MCHUSERNOTES = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
|
||||
EMT.VMRS = ( EMT.MCHTYPE ~= MCH_MY.DRILLING and not EMT.MCHUSERNOTES:find( 'VMRS=0;', 1, true))
|
||||
EMT.MCHSPLIT = ( EMT.MCHUSERNOTES:find( 'Split;', 1, true) ~= nil)
|
||||
EMT.MCHPRECUT = ( EMT.MCHUSERNOTES:find( 'Precut;', 1, true) ~= nil)
|
||||
EMT.MCHCUT = ( EMT.MCHUSERNOTES:find( 'Cut;', 1, true) ~= nil)
|
||||
-- recupero TASKID e CUTID della feature lavorata (CUTID va recuperato qui per le pareti)
|
||||
local vId = EgtGetMachiningGeometry()
|
||||
if vId and #vId > 0 and #vId[1] > 0 then
|
||||
@@ -831,9 +789,9 @@ function OnSimulMachiningStart()
|
||||
-- dichiaro utensile per Vmill
|
||||
EmtAddToolForVmill( sDouTool, sDouHead, nDouExit, EMT.VMILL)
|
||||
-- dichiaro utensile per verifica collisioni
|
||||
local nInd = 1000 + tonumber( string.sub( sDouHead, 2))
|
||||
local nInd = 1011
|
||||
AddToolToCollisionObj( sDouTool, sDouHead, nDouExit, nInd, true)
|
||||
AddToolHolderToCollisionObj( sDouTool, sDouHead, nDouExit, nInd + 100)
|
||||
AddToolHolderToCollisionObj( sDouTool, sDouHead, nDouExit, nInd + 1)
|
||||
-- salvo dati
|
||||
EMT.DOU_TLEN = EgtTdbGetCurrToolParam( MCH_TP.LEN)
|
||||
EMT.DOU_TTOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
||||
@@ -850,17 +808,19 @@ function OnSimulMachiningStart()
|
||||
local nSetHead = GetHeadSet( EMT.HEAD)
|
||||
if nSetHead ~= 1 and ( EMT.PREVTOOL_H1 and EMT.PREVHEAD_H1) then
|
||||
local nPrevExit_H1 = 1
|
||||
local nInd_H1 = 1000 + tonumber( string.sub( EMT.PREVHEAD_H1, 2))
|
||||
local nInd_H1 = 1001
|
||||
AddToolToCollisionObj( EMT.PREVTOOL_H1, EMT.PREVHEAD_H1, nPrevExit_H1, nInd_H1, true)
|
||||
AddToolHolderToCollisionObj( EMT.PREVTOOL_H1, EMT.PREVHEAD_H1, nPrevExit_H1, nInd_H1 + 100)
|
||||
AddToolHolderToCollisionObj( EMT.PREVTOOL_H1, EMT.PREVHEAD_H1, nPrevExit_H1, nInd_H1 + 1)
|
||||
end
|
||||
if nSetHead ~= 2 and ( EMT.PREVTOOL_H2 and EMT.PREVHEAD_H2) then
|
||||
local nPrevExit_H2 = 1
|
||||
local nInd_H2 = 1000 + tonumber( string.sub( EMT.PREVHEAD_H2, 2))
|
||||
local nInd_H2 = 1011
|
||||
AddToolToCollisionObj( EMT.PREVTOOL_H2, EMT.PREVHEAD_H2, nPrevExit_H2, nInd_H2, true)
|
||||
AddToolHolderToCollisionObj( EMT.PREVTOOL_H2, EMT.PREVHEAD_H2, nPrevExit_H2, nInd_H2 + 100)
|
||||
AddToolHolderToCollisionObj( EMT.PREVTOOL_H2, EMT.PREVHEAD_H2, nPrevExit_H2, nInd_H2 + 1)
|
||||
end
|
||||
if nSetHead ~= 3 and IsHeadExisting( 3) then
|
||||
local nPrevExit_H3 = 1
|
||||
local nInd_H3 = 1001
|
||||
local sHeadName
|
||||
if EgtGetHeadId( 'H39') then
|
||||
sHeadName = 'H39'
|
||||
@@ -869,10 +829,8 @@ function OnSimulMachiningStart()
|
||||
else
|
||||
EmtSetLastError( 1212, "HEAD not managed")
|
||||
end
|
||||
local nPrevExit_H3 = 1
|
||||
local nInd_H3 = 1000 + tonumber( string.sub( sHeadName, 2))
|
||||
AddToolToCollisionObj( nil, sHeadName, nPrevExit_H3, nInd_H3)
|
||||
AddToolHolderToCollisionObj( nil, sHeadName, nPrevExit_H3, nInd_H3 + 100)
|
||||
AddToolToCollisionObj( nil, sHeadName, nPrevExit_H3, 1001)
|
||||
AddToolHolderToCollisionObj( nil, sHeadName, nPrevExit_H3, 1002)
|
||||
end
|
||||
end
|
||||
-- se precedente in doppio ma ora solo testa 1 e non in sicurezza
|
||||
@@ -891,7 +849,9 @@ function OnSimulMachiningStart()
|
||||
end
|
||||
|
||||
-- non ancora iniziata la lavorazione
|
||||
EMT.MCHFIRST = true
|
||||
if not IsNewLinkHead( EMT.HEAD) then
|
||||
EMT.MCHFIRST = true
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -943,17 +903,6 @@ function OnSimulPathStart()
|
||||
EMT.TO_FALL = true
|
||||
end
|
||||
end
|
||||
-- dump oggetti di collisione
|
||||
if DumpCollisionObj then
|
||||
DumpCollisionObj( ' ==> CollisionObj :', 4)
|
||||
end
|
||||
-- se taglio di precut verifico quanto è più lungo il grezzo rispetto al pezzo (non tiene conto dell'ultimo cubetto)
|
||||
EMT.DELTA_LT = 0
|
||||
if EMT.MCHPRECUT then
|
||||
local dCosA = sqrt( max( 1 - EMT.EXTR[1] * EMT.EXTR[1], 0))
|
||||
EMT.DELTA_LT = max( EMT.XMINT - Point3d( EMT.MMAX):getX() - dCosA * EMT.TDIAM / 2, 0)
|
||||
EgtOutLog( 'PreCutDeltaLT='..EgtNumToString( EMT.DELTA_LT, 3), 5)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -967,7 +916,7 @@ function OnSimulPathEnd()
|
||||
EMT.Y1DELTA = nil
|
||||
ExecMovePY1( false)
|
||||
end
|
||||
ExecMoveZmax( EMT.MCHSPLIT)
|
||||
-- ExecMoveZmax( EMT.MCHSPLIT)
|
||||
EMT.TO_ZMAX = nil
|
||||
end
|
||||
end
|
||||
@@ -990,7 +939,7 @@ function OnSimulPathEndAux()
|
||||
ExecAuxCmd( EMT.AUX, false)
|
||||
-- se ultimo comando e richiesta risalita a Zmax
|
||||
if EMT.AUXIND == EMT.AUXTOT and EMT.TO_ZMAX then
|
||||
ExecMoveZmax( EMT.MCHSPLIT)
|
||||
-- ExecMoveZmax( EMT.MCHSPLIT)
|
||||
EMT.TO_ZMAX = nil
|
||||
end
|
||||
end
|
||||
@@ -998,6 +947,8 @@ end
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMoveStart()
|
||||
if EMT.MCHFIRST then EgtOutText( '') end
|
||||
-- recupero eventuali flag da Info del movimento
|
||||
local bSplit = EgtGetInfo( EMT.MOVEID, 'Split', 'b')
|
||||
-- set della testa
|
||||
local nSetHead = GetHeadSet( EMT.HEAD)
|
||||
-- Posizioni correnti
|
||||
@@ -1014,7 +965,7 @@ function OnSimulMoveStart()
|
||||
EMT.A1 = EMT.L1 + EMT.Y1DELTA
|
||||
else
|
||||
EMT.A1m = nil
|
||||
EMT.A1 = EgtIf( EMT.Y1SPEC, EgtGetAxisPos( 'Y1'), ParkY1)
|
||||
EMT.A1 = EgtIf( EMT.Y1SPEC or Y1Pos > ParkY1, Y1Pos, ParkY1)
|
||||
end
|
||||
EMT.A2n = 'Y2'
|
||||
if EMT.Y2DELTA then
|
||||
@@ -1024,8 +975,9 @@ function OnSimulMoveStart()
|
||||
EMT.A2m = nil
|
||||
EMT.A2 = ParkY2
|
||||
end
|
||||
|
||||
-- Controllo scorrimento pinze chiuse Y1 e Y2
|
||||
if EMT.Y1DELTA then
|
||||
if EMT.Y1DELTA and ( EMT.MOVE ~= 0 or ( EMT.MASK & 1) == 1) then
|
||||
local dY1DeltaP = Y1Pos - EMT.L1p
|
||||
if abs( EMT.Y1DELTA - dY1DeltaP) > 0.1 then
|
||||
EMT.ERR = 2
|
||||
@@ -1033,7 +985,7 @@ function OnSimulMoveStart()
|
||||
EmtSetLastError( 1202, sErr)
|
||||
end
|
||||
end
|
||||
if EMT.Y2DELTA then
|
||||
if EMT.Y2DELTA and ( EMT.MOVE ~= 0 or ( EMT.MASK & 1) == 1) then
|
||||
local dY2DeltaP = Y2Pos - EMT.L1p
|
||||
if abs( EMT.Y2DELTA - dY2DeltaP) > 0.1 then
|
||||
EMT.ERR = 2
|
||||
@@ -1041,13 +993,14 @@ function OnSimulMoveStart()
|
||||
EmtSetLastError( 1202, sErr)
|
||||
end
|
||||
end
|
||||
|
||||
-- rulli
|
||||
EMT.A3n = 'V1'
|
||||
EMT.A3 = EgtIf( GetV1ToClose(), EMT.V1NEXTPOS, ParkV1)
|
||||
EMT.A4n = 'V2'
|
||||
EMT.A4 = EgtIf( GetV2ToClose(), EMT.V2NEXTPOS, ParkV2)
|
||||
local bParkV = false
|
||||
if EMT.MCHFIRST then
|
||||
if EMT.MCHFIRST or ( EMT.MOVE == 0 and IsNewLinkHead( EMT.HEAD)) then
|
||||
-- se rulli più chiusi del richiesto o cambio direzione utensile (tranne solo asse B con C0 o equivalenti) devo mettere i rulli in parcheggio
|
||||
if V1Pos < EMT.V1NEXTPOS - 1 or V2Pos > EMT.V2NEXTPOS + 1 or RollerParkingNeeded( EMT.HEAD, EMT.R1p, EMT.R2p, EMT.R1, EMT.R2) then
|
||||
bParkV = true
|
||||
@@ -1055,6 +1008,12 @@ function OnSimulMoveStart()
|
||||
EMT.A4 = ParkV2
|
||||
end
|
||||
end
|
||||
local bNlhParkV = ( EMT.MOVE == 0 and IsNewLinkHead( EMT.HEAD) and ( EMT.FLAG2 == 1 or EMT.FLAG2 == 2))
|
||||
if bNlhParkV then
|
||||
bParkV = ( EMT.FLAG == 2 and bParkV) or ( not EMT.MCHSPLIT or bSplit)
|
||||
EMT.A3 = ParkV1
|
||||
EMT.A4 = ParkV2
|
||||
end
|
||||
-- Controllo corse assi ausiliari
|
||||
VerifyY1Stroke( EMT.A1)
|
||||
VerifyY2Stroke( EMT.A2)
|
||||
@@ -1063,186 +1022,17 @@ function OnSimulMoveStart()
|
||||
-- se devo subito parcheggiare i rulli
|
||||
local nRes = 0
|
||||
if bParkV then
|
||||
local bMchSplit = ( bNlhParkV and EMT.MCHSPLIT and bSplit)
|
||||
local bAgg = EgtExistsInfo( EMT.PATHID, 'CNT')
|
||||
nRes = ExecParkRoller( Y1Pos, Y2Pos, V1Pos, V2Pos, false, bAgg)
|
||||
end
|
||||
-- se movimento in rapido
|
||||
if EMT.MOVE == 0 then
|
||||
-- se testa 1
|
||||
if nSetHead == 1 then
|
||||
-- Dati
|
||||
local B1Pos = EgtGetAxisPos( 'B1')
|
||||
local B1Home = EgtGetAxisHomePos( 'B1')
|
||||
local C1Pos = EgtGetAxisPos( 'C1')
|
||||
local C1Home = EgtGetAxisHomePos( 'C1')
|
||||
local Z1Pos = EgtGetAxisPos( 'Z1')
|
||||
local Z1Home = EgtGetAxisHomePos( 'Z1')
|
||||
local MyMaxZ1 = EgtGetAxisMax( 'Z1')
|
||||
-- se fresa o lama
|
||||
if EMT.HEAD ~= 'H13' then
|
||||
-- se movimento iniziale da Zmax con lama o fresa
|
||||
if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
|
||||
local bXSpec = EgtIf( BD.RIGHT_LOAD, EMT.L2 < DeltaTabY, EMT.L2 > DeltaTabY)
|
||||
-- in caso di rotazione della lama lontano dalla posizione di home degli assi rotanti
|
||||
if ( EMT.HEAD == 'H12' or EMT.HEAD == 'H16') and ( abs( C1Pos - EMT.R1) > 1 or abs( B1Pos - EMT.R2) > 1) and ( abs( C1Home - EMT.R1) > 30.1 or abs( B1Home - EMT.R2) > 30.1) then
|
||||
SimulMoveAxis( 'X1', EgtIf( bXSpec, DeltaTabY, EMT.L2), MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxes( 'Z1', MyMaxZ1, MCH_SIM_STEP.RAPID, 'B1', 0, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
|
||||
-- se movimento di B > di 90°, spezza il movimento in 2 arrivando alla quota Z con B+-90 e poi muove l'ultimo segmento
|
||||
-- evita collisione con carro X
|
||||
if EMT.R2 > 91 or EMT.R2 < -91 then
|
||||
local dBref = EgtClamp( EMT.R2, -91, 91)
|
||||
SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', dBref, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxis( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
|
||||
else
|
||||
SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
-- caso standard
|
||||
else
|
||||
-- se bisogna scrivere tutti gli assi
|
||||
if WriteAllCoordsOnFirstM101 then
|
||||
SimulMoveAxis( 'X1', EgtIf( bXSpec, DeltaTabY, EMT.L2), MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
-- se ero in posizione speciale, prima ruoto poi scendo
|
||||
if bXSpec then
|
||||
local dZPos = max( Z1Home, EMT.L3)
|
||||
SimulMoveAxis( 'Z1', dZPos, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxes( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
|
||||
if abs( dZPos - EMT.L3) > 1 then
|
||||
SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
else
|
||||
SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxes( 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- altrimenti sega a catena
|
||||
else
|
||||
local dSafeZ1 = EgtIf( EMT.TTOTLEN < MinLengthLongCSaw, ParkCSawZ1, ParkLongCSawZ1)
|
||||
-- Porto la Z alla giusta quota
|
||||
if Z1Pos > dSafeZ1 + 1 and abs( B1Pos) > 89.9 then
|
||||
SimulMoveAxis( 'X1', EMT.L2, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxis( 'Z1', dSafeZ1, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
|
||||
-- se movimento iniziale da Zmax
|
||||
if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
|
||||
local dChSawEncumbrance = EMT.L3 + MillOffs - ( ( ChSawLen + MillOffs) * EMT.ADIR[3]) - ( EMT.TTOTLEN * EMT.TDIR[3])
|
||||
local dBeamQuote = DeltaTabZ + EMT.SB + 30
|
||||
if dChSawEncumbrance < dBeamQuote then
|
||||
SimulMoveAxes( 'Z1', dSafeZ1, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID, 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
SimulMoveAxis( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID)
|
||||
else
|
||||
SimulMoveAxes( 'Z1', EMT.L3, MCH_SIM_STEP.RAPID, 'B1', EMT.R2, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
-- se motosega molto lunga, ruoto prima di muovermi in X
|
||||
if EMT.TTOTLEN >= MinLengthLongCSaw then
|
||||
SimulMoveAxis( 'C1', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- se altrimenti testa 2
|
||||
elseif nSetHead == 2 then
|
||||
local B2Home = EgtGetAxisHomePos( 'B2')
|
||||
local C2Home = EgtGetAxisHomePos( 'C2')
|
||||
local Z2Home = EgtGetAxisHomePos( 'Z2')
|
||||
local X2Home = EgtGetAxisHomePos( 'X2')
|
||||
local X2Pos = EgtGetAxisPos( 'X2')
|
||||
local B2Pos = EgtGetAxisPos( 'B2')
|
||||
local C2Pos = EgtGetAxisPos( 'C2')
|
||||
-- calcolo posizione reale
|
||||
EMT.TCPOSREAL = 'T' .. AdjustTcPos( false, EMT.TCPOS, EMT.R3)
|
||||
-- se utensile cambiato (controllo il reale perchè per aggregato dipende come è stato caricato)
|
||||
if EMT.PREVTCPOSREAL_H2 ~= EMT.TCPOSREAL then
|
||||
if EMT.ZMAX then
|
||||
-- se bisogna scrivere tutti gli assi
|
||||
if WriteAllCoordsOnFirstM101 then
|
||||
if EMT.HEAD == 'H22' then
|
||||
SimulMoveAxes( 'X2', ParkSawX2, MCH_SIM_STEP.RAPID, 'B2', 0, MCH_SIM_STEP.COLLROT, 'C2', C2Home, MCH_SIM_STEP.COLLROT)
|
||||
X2Pos = ParkSawX2
|
||||
else
|
||||
SimulMoveAxes( 'X2', SafeX2, MCH_SIM_STEP.RAPID, 'B2', B2Home, MCH_SIM_STEP.COLLROT, 'C2', C2Home, MCH_SIM_STEP.COLLROT)
|
||||
X2Pos = SafeX2
|
||||
end
|
||||
else
|
||||
if EMT.HEAD == 'H22' then
|
||||
SimulMoveAxis( 'X2', ParkSawX2, MCH_SIM_STEP.RAPID)
|
||||
X2Pos = ParkSawX2
|
||||
else
|
||||
SimulMoveAxis( 'X2', SafeX2, MCH_SIM_STEP.RAPID)
|
||||
X2Pos = SafeX2
|
||||
end
|
||||
end
|
||||
SimulMoveAxis( 'Z2', Z2Home, MCH_SIM_STEP.RAPID)
|
||||
-- Porto la X alla giusta quota
|
||||
if X2Pos > SafeX2RotAxis and ( B2Pos ~= EMT.R2 or C2Pos ~= EMT.R1) then
|
||||
SimulMoveAxis( 'X2', SafeX2RotAxis, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
end
|
||||
else
|
||||
-- solo se è macchina a 3 teste con gruppo truciolatore 4 assi, devo andare prima in Z0
|
||||
if EgtGetHeadId( 'H39') then
|
||||
SimulMoveAxis( 'Z2', Z2Home, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
-- Porto la X alla giusta quota
|
||||
if EMT.ZMAX and X2Pos > SafeX2RotAxis and ( B2Pos ~= EMT.R2 or C2Pos ~= EMT.R1) then
|
||||
SimulMoveAxis( 'X2', SafeX2RotAxis, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
end
|
||||
if EMT.HEAD == 'H22' then
|
||||
SimulMoveAxes( 'B2', EMT.R2, MCH_SIM_STEP.COLLROT, 'C2', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
-- se ero a ZMAX, mi sposto in posizione a Z home. Ultimo movimento muove in Z
|
||||
if EMT.ZMAX then
|
||||
SimulMoveAxes( 'X2', EMT.L2, MCH_SIM_STEP.RAPID, 'B2', EMT.R2, MCH_SIM_STEP.COLLROT, 'C2', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
-- altrimenti testa 3
|
||||
else
|
||||
-- testa 4 assi dedicata truciolatore
|
||||
if EgtGetHeadId( 'H39') then
|
||||
if EMT.ZMAX then
|
||||
local MaxZ3 = EgtGetAxisMax( 'Z3')
|
||||
SimulMoveAxes( 'X3', EMT.L2, MCH_SIM_STEP.RAPID, 'Z3', MaxZ3, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
SimulMoveAxis( 'Z3', EMT.L3, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxes( 'B3', EMT.R2, MCH_SIM_STEP.COLLROT, 'C3', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
-- testa 5 assi dedicata lama
|
||||
elseif EgtGetHeadId( 'H38') then
|
||||
if EMT.ZMAX then
|
||||
local B3Home = EgtGetAxisHomePos( 'B3')
|
||||
local C3Home = EgtGetAxisHomePos( 'C3')
|
||||
SimulMoveAxis( 'X3', SafeX3RotAxis, MCH_SIM_STEP.RAPID)
|
||||
-- se non sono esattamente in home, devo ruotare in zona sicura
|
||||
if abs( C3Home - EMT.R1) > 1 or abs( B3Home - EMT.R2) > 1 then
|
||||
EMT.L3 = min( EMT.L3, SafeZ3RotAxis)
|
||||
SimulMoveAxis( 'Z3', SafeZ3RotAxis, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxes( 'B3', EMT.R2, MCH_SIM_STEP.COLLROT, 'C3', EMT.R1, MCH_SIM_STEP.COLLROT)
|
||||
if ( EMT.L3 - SafeZ3RotAxis) > 100 * GEO.EPS_SMALL then
|
||||
SimulMoveAxis( 'Z3', EMT.L3, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
SimulMoveAxis( 'X3', EMT.L2, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
end
|
||||
-- si muovono tutti gli assi assieme
|
||||
-- altre configurazioni
|
||||
else
|
||||
EmtSetLastError( 1212, "HEAD not managed")
|
||||
end
|
||||
end
|
||||
nRes = ExecParkRoller( Y1Pos, Y2Pos, V1Pos, V2Pos, bMchSplit, bAgg)
|
||||
end
|
||||
-- se lavorazione split, muovo per riaggancio del carro Y1
|
||||
if EMT.SPLIT_Y1DELTA then
|
||||
if EMT.SPLIT_Y1DELTA and ( not IsNewLinkHead( EMT.HEAD) or IsL1Enabled( EMT.MASK)) then
|
||||
EMT.Y1DELTA = EMT.SPLIT_Y1DELTA
|
||||
EMT.A1 = EMT.L1 + EMT.Y1DELTA
|
||||
end
|
||||
-- se Zmax dopo fine lavorazione
|
||||
if EMT.MOVE == 0 and EMT.FLAG == 3 then
|
||||
if EMT.MOVE == 0 and EMT.FLAG == 3 and not IsNewLinkHead( EMT.HEAD) then
|
||||
-- demando movimento completo a MoveEnd
|
||||
EMT.EnabAxes = false
|
||||
EMT.ShowAxes = true
|
||||
@@ -1268,12 +1058,6 @@ function OnSimulMoveStart()
|
||||
EMT.A6n = 'Z2'
|
||||
local Z2 = -Head2Z + MillOffs + Mill2Offs + EMT.L3
|
||||
EMT.A6 = EgtClamp( Z2, MinZ2, MaxZ2)
|
||||
-- dato che la testa 2 è slave, bisogna controllare eventuale extra-corsa da post
|
||||
if not( EMT.MOVE == 0 and EMT.FLAG == 2) and Z2 > MaxZ2 then
|
||||
local sErr = EMT.MCHNAME..' ==> Out of Stroke: Z2 : '.. EgtNumToString( dZ2-MaxZ2, 2)
|
||||
EmtSetLastError( 1220, sErr, true)
|
||||
EgtOutBox( sErr, 'ERROR')
|
||||
end
|
||||
EMT.A6m = EgtIf( ( EMT.MOVE == 2 or EMT.MOVE == 3), 'Z1', nil)
|
||||
EMT.A7n = 'C2'
|
||||
EMT.A7 = EMT.R1
|
||||
@@ -1304,12 +1088,6 @@ function OnSimulMoveStart()
|
||||
EMT.DOU_DRILL_END = EMT.L3p - EMT.L3
|
||||
Z2 = Z2 - 2 * EMT.DOU_DRILL_END
|
||||
end
|
||||
-- dato che la testa 2 è slave, bisogna controllare eventuale extra-corsa da post
|
||||
if not( EMT.MOVE == 0 and EMT.FLAG == 2) and Z2 < MinZ2 then
|
||||
local sErr = EMT.MCHNAME..' ==> Out of Stroke: Z2 : '.. EgtNumToString( MinZ2-Z2, 2)
|
||||
EmtSetLastError( 1220, sErr, true)
|
||||
EgtOutBox( sErr, 'ERROR')
|
||||
end
|
||||
EMT.A6 = EgtClamp( Z2, MinZ2, MaxZ2)
|
||||
EMT.A6m = nil
|
||||
EMT.A7n = 'C2'
|
||||
@@ -1323,16 +1101,10 @@ function OnSimulMoveStart()
|
||||
local sErr = 'Z1 Z2 tools in collision (distance=' .. EgtNumToString( dDistToolZ1Z2, 1) .. ')'
|
||||
EmtSetLastError( 1208, sErr)
|
||||
end
|
||||
if EMT.ZMAX or ( EMT.FLAG == 2 and EMT.FLAG2 == 1) then
|
||||
local B2Home = EgtGetAxisHomePos( 'B2')
|
||||
local C2Home = EgtGetAxisHomePos( 'C2')
|
||||
SimulMoveAxes( 'X2', SafeX2, MCH_SIM_STEP.RAPID, 'C2', C2Home, MCH_SIM_STEP.RAPROT, 'B2', B2Home, MCH_SIM_STEP.RAPROT)
|
||||
SimulMoveAxis( 'X2', X2, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- se necessario ...
|
||||
if EMT.MCHFIRST and EMT.EnabAxes ~= false then
|
||||
if ( EMT.MCHFIRST or ( EMT.MOVE == 0 and IsNewLinkHead( EMT.HEAD))) and EMT.EnabAxes ~= false then
|
||||
if nSetHead == 1 then
|
||||
SimulMoveAxes( 'X1', EMT.L2, MCH_SIM_STEP.RAPID,
|
||||
'Z1', EMT.L3, MCH_SIM_STEP.RAPID,
|
||||
@@ -1349,20 +1121,19 @@ function OnSimulMoveStart()
|
||||
'Z2', EMT.L3, MCH_SIM_STEP.RAPID,
|
||||
'C2', EMT.R1, MCH_SIM_STEP.COLLROT,
|
||||
'B2', EMT.R2, MCH_SIM_STEP.COLLROT)
|
||||
else
|
||||
elseif not IsNewLinkHead( EMT.HEAD) or ( bParkV and not bNlhParkV) then
|
||||
SimulMoveAxes( 'X3', EMT.L2, MCH_SIM_STEP.RAPID,
|
||||
'Z3', EMT.L3, MCH_SIM_STEP.RAPID,
|
||||
'C3', EMT.R1, MCH_SIM_STEP.COLLROT,
|
||||
'B3', EMT.R2, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
end
|
||||
if nRes ~= 0 then
|
||||
if nRes ~= 0 and not bNlhParkV then
|
||||
EMT.A3 = EgtIf( GetV1ToClose(), EMT.V1NEXTPOS, ParkV1)
|
||||
EMT.A4 = EgtIf( GetV2ToClose(), EMT.V2NEXTPOS, ParkV2)
|
||||
end
|
||||
EMT.ZMAX = nil
|
||||
EMT.TO_ZMAX = nil
|
||||
|
||||
-- se aggregato flottante su inizio attacco va compresso
|
||||
if EMT.TFLOAT and not EMT.TFLOAT_CMP and EMT.MOVE == 1 and EgtGetName( EMT.MOVEID) == 'LI' then
|
||||
-- recupero lunghezza
|
||||
@@ -1385,7 +1156,7 @@ function OnSimulMoveEnd()
|
||||
ExecRemoveScraps()
|
||||
end
|
||||
-- se primo rapido della lavorazione
|
||||
if EMT.MCHFIRST and EMT.MOVE == 0 then
|
||||
if EMT.MOVE == 0 and ( EMT.MCHFIRST or ( IsNewLinkHead( EMT.HEAD) and IsL1Enabled( EMT.MASK))) then
|
||||
-- se lavorazione split, dichiaro carro Y1 riagganciato
|
||||
if EMT.SPLIT_Y1DELTA then
|
||||
EMT.SPLIT_Y1DELTA = nil
|
||||
@@ -1421,18 +1192,17 @@ function OnSimulMoveEnd()
|
||||
end
|
||||
end
|
||||
-- se Zmax dopo fine lavorazione
|
||||
if EMT.MOVE == 0 and EMT.FLAG == 3 then
|
||||
if EMT.MOVE == 0 and EMT.FLAG == 3 and not IsNewLinkHead( EMT.HEAD) then
|
||||
-- eventuale rimozione sfridi
|
||||
ExecRemoveScraps()
|
||||
-- ricavo prossimo utensile
|
||||
local sNextTool = GetNextTool( EMT.MCHID)
|
||||
-- vado in home se è ultimo movimento ed è ultima lavorazione
|
||||
local bToXhome = ( IsLastPath( EMT.PATHID) and not sNextTool and nHSet == 3) or EMT.HEAD == 'H38' or ( nHSet == 1 and EMT.TTOTLEN > LongTool)
|
||||
local bToXhome = ( IsLastPath( EMT.PATHID) and not sNextTool and nHSet == 3) or ( nHSet == 1 and EMT.TTOTLEN > LongTool)
|
||||
-- eseguo
|
||||
ExecMoveZmax( EMT.MCHSPLIT, bToXhome)
|
||||
--ExecMoveZmax( EMT.MCHSPLIT, bToXhome)
|
||||
EMT.TO_ZMAX = nil
|
||||
end
|
||||
|
||||
-- se utensile flottante e movimento di compressione
|
||||
if EMT.TFLOAT and EMT.MOVEID == EMT.TFLOAT_CMP then
|
||||
-- verifico ci sia stata collisione tra ghiera flottante (portautensile e pezzo)
|
||||
@@ -1466,10 +1236,10 @@ function OnSimulCollision()
|
||||
return
|
||||
end
|
||||
local Class = ''
|
||||
if EMT.SIMCOBIND > 1000 and EMT.SIMCOBIND < 1099 then
|
||||
Class = 'T_H'.. tostring( EMT.SIMCOBIND - 1000)
|
||||
elseif EMT.SIMCOBIND > 1100 and EMT.SIMCOBIND < 1199 then
|
||||
Class = 'TH_H'..tostring( EMT.SIMCOBIND - 1100)
|
||||
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
|
||||
@@ -1499,9 +1269,6 @@ function ExecAuxCmd( sCmd, bPathStart)
|
||||
if Cmd[2] ~= 'Z' then
|
||||
ExecOpenRoller( 1)
|
||||
ExecOpenRoller( 2)
|
||||
if Cmd[4] and Cmd[4] == 'Manual Unloading' then
|
||||
ExecMovePY2( false)
|
||||
end
|
||||
local sV1, MoveV1, sV2, MoveV2 = CalcMoveV1V2ForAuxCmd( Cmd)
|
||||
local bOk, bOk1, bOk2, bOk3 = SimulMoveAxes( Cmd[2], tonumber( Cmd[3]), MCH_SIM_STEP.RAPID,
|
||||
sV1, MoveV1, MCH_SIM_STEP.RAPID,
|
||||
@@ -1639,8 +1406,8 @@ end
|
||||
---------------------------------------------------------------------
|
||||
function ExecMoveHome( bNearV, bMchSplit)
|
||||
-- risalita a Zmax
|
||||
ExecMoveZmax( bMchSplit, true)
|
||||
-- se testa sotto e macchina a 3 teste
|
||||
-- ExecMoveZmax( bMchSplit, true)
|
||||
-- se testa sotto e macchina a 3 teste e gruppo truciolatore a 4 assi
|
||||
if GetHeadSet( EMT.HEAD) == 2 and IsHeadExisting( 3) then
|
||||
if not SimulMoveAxis( 'X2', EgtIf( EMT.HEAD == 'H22', SafeX2, ParkX2), MCH_SIM_STEP.RAPID) then
|
||||
EgtOutLog( 'Error on MoveHome : X2')
|
||||
@@ -1648,7 +1415,7 @@ function ExecMoveHome( bNearV, bMchSplit)
|
||||
-- se gruppo truciolatore a 4 assi
|
||||
if EgtGetHeadId( 'H39') then
|
||||
if not SimulMoveAxis( 'Z2', ParkInLavZ2, MCH_SIM_STEP.RAPID) then
|
||||
EgtOutLog( 'Error on MoveHome : Z2')
|
||||
EgtOutLog( 'Error on MoveHome : Z2')
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1748,9 +1515,9 @@ function ExecMoveZmax( bMchSplit, bGoToHome)
|
||||
SimulMoveAxes( 'B3', ParkB3, MCH_SIM_STEP.COLLROT)
|
||||
elseif EgtGetHeadId( 'H38') then
|
||||
local MyMaxZ3 = EgtGetAxisMax( 'Z3')
|
||||
-- se non sono esattamente in home, ruoto dove sono
|
||||
-- se non sono esattamente in home, devo ruotare in zona sicura
|
||||
if abs( HomeC - CurrC) > 1 or abs( HomeB - CurrB) > 1 then
|
||||
-- SimulMoveAxis( 'X3', SafeX3RotAxis, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxis( 'X3', SafeX3RotAxis, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxis( 'Z3', SafeZ3RotAxis, MCH_SIM_STEP.RAPID)
|
||||
SimulMoveAxes( 'C3', HomeC, MCH_SIM_STEP.COLLROT, 'B3', HomeB, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
@@ -1780,7 +1547,7 @@ function ExecUnloading()
|
||||
-- creo un nuovo layer e vi inserisco il nuovo pezzo
|
||||
local nLayId = EgtGroup( nVmGrpId, EgtGetGlobFrame( vMillId))
|
||||
EgtRelocate( vMillId, nLayId)
|
||||
local vtMove = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, 1600, -1600), 0)
|
||||
local vtMove = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, 1900, -1900), 0)
|
||||
if EMT.FALL then vtMove = Vector3d( 0, EgtIf( BD.RIGHT_LOAD, 3200, -2600), -1150) end
|
||||
EgtMove( nLayId, vtMove, GDB_RT.GLOB)
|
||||
EgtSetLevel( vMillId, GDB_LV.USER)
|
||||
@@ -1817,163 +1584,16 @@ function ExecUnloading()
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function CheckClamping( sClampName)
|
||||
nIndexClamp = EgtGetAxisId( sClampName)
|
||||
local idClampPath = EgtGetFirstInGroup( EgtGetFirstNameInGroup( nIndexClamp, 'CLAMP_CHECK') or GDB_ID.NULL)
|
||||
local b3ClampingArea = EgtGetBBoxGlob( idClampPath or GDB_ID.NULL, GDB_BB.STANDARD)
|
||||
-- se non trovo percorso area di clamping, esco subito
|
||||
if not idClampPath or not EMT.VMILL or not ClampingCoeffMin then
|
||||
return
|
||||
end
|
||||
|
||||
local function GetCurveListFromIntersection( sPosIntersPlane, sIntersPlane, dDepth)
|
||||
local idCurveList = {}
|
||||
local vtIntersPlane
|
||||
-- piano di interpolazione
|
||||
if sIntersPlane == 'X' then
|
||||
vtIntersPlane = X_AX()
|
||||
elseif sIntersPlane == 'Y' then
|
||||
vtIntersPlane = Y_AX()
|
||||
elseif sIntersPlane == 'Z' then
|
||||
vtIntersPlane = Z_AX()
|
||||
end
|
||||
|
||||
for i = 1, #EMT.VMILL do
|
||||
local b3VMill = EgtGetBBoxGlob( EMT.VMILL[i], GDB_BB.EXACT)
|
||||
local ptPosIntersPlane
|
||||
if sPosIntersPlane == 'MIN' then
|
||||
ptPosIntersPlane = b3VMill:getMin() + dDepth * vtIntersPlane
|
||||
elseif sPosIntersPlane == 'MAX' then
|
||||
ptPosIntersPlane = b3VMill:getMax() - dDepth * vtIntersPlane
|
||||
end
|
||||
|
||||
local idLoop, nLoopCnt = EgtPlaneVolZmapInters( ptPosIntersPlane, vtIntersPlane, EMT.VMILL[i], CLAMP_CHECK_INTERS, GDB_RT.GLOB)
|
||||
-- se c'è almeno una curva
|
||||
if idLoop then
|
||||
for j = 1, nLoopCnt do
|
||||
local idLoopTemp = idLoop + j - 1
|
||||
table.insert( idCurveList, idLoopTemp)
|
||||
end
|
||||
end
|
||||
end
|
||||
return idCurveList
|
||||
end
|
||||
|
||||
local function CalculateIntersectionArea( sPosIntersPlane, sIntersPlane, dDepth)
|
||||
-- test piano frontale
|
||||
local idCurveList = GetCurveListFromIntersection( sPosIntersPlane, sIntersPlane, dDepth)
|
||||
|
||||
-- si copia curva intersezione e curva pinza in gruppo di confronto
|
||||
local idFlatSurf, nFlatSurfCnt = EgtSurfFlatRegion( CLAMP_CHECK_GROUP, idCurveList)
|
||||
local idClampSurf = EgtSurfFlatRegion( CLAMP_CHECK_GROUP, idClampPath)
|
||||
|
||||
if idFlatSurf then
|
||||
local dTotalArea = 0
|
||||
local dTotalXLenght = 0
|
||||
for k = 1, nFlatSurfCnt do
|
||||
local idTempSurf = idFlatSurf + k - 1
|
||||
EgtSurfFrIntersect( idTempSurf, idClampSurf)
|
||||
if idTempSurf then
|
||||
dTotalArea = dTotalArea + ceil( EgtSurfArea( idTempSurf) or 0)
|
||||
local b3BoxIntersectionBox = EgtGetBBoxGlob( idTempSurf, GDB_BB.STANDARD)
|
||||
if b3BoxIntersectionBox then
|
||||
dTotalXLenght = dTotalXLenght + ceil( b3BoxIntersectionBox:getDimX()) -- somma lunghezze (x) delle aree pinzate
|
||||
end
|
||||
end
|
||||
end
|
||||
return dTotalArea, dTotalXLenght
|
||||
end
|
||||
return 0
|
||||
end
|
||||
|
||||
-- minima area considerata per un corretto pinzaggio
|
||||
DistZClampToTable = DistZClampToTable or 0
|
||||
local MinJoin = BD.GetMinJoin( EMT.HB, EMT.SB, EgtIf( EMT.SPLIT, EMT.LT, EMT.LB))
|
||||
local MinZClamping = min( b3ClampingArea:getDimZ() + DistZClampToTable, EMT.SB) - DistZClampToTable
|
||||
-- si moltiplica per un coefficiente minimo sotto al quale si da l'errore di pinzaggio
|
||||
ClampingCoeffMin = EgtClamp( ClampingCoeffMin, 0.01, 1)
|
||||
local dMinClampingAreaWarn = ( MinJoin * MinZClamping) * ClampingCoeffMin
|
||||
local dMinClampingAreaErr = ( MinJoin * MinZClamping) * ( ClampingCoeffMin / 3)
|
||||
|
||||
local bError = true
|
||||
local sWrn, sErr
|
||||
local bWriteWarnMessage = false
|
||||
local bWriteErrMessage = false
|
||||
-- controllo faccia frontale
|
||||
local dArea, dXClampedLenght = CalculateIntersectionArea( 'MIN', 'Y', 3)
|
||||
-- ERRORE: pinza troppo poco (meno di 1/3 del minimo richiesto)
|
||||
if dArea and dArea < dMinClampingAreaErr then
|
||||
-- solo se pinza almeno 1cm2, e la somma della lunghezza pinzata è maggiore della lunghezza minima pinzabile da Warning e non errore
|
||||
if dXClampedLenght >= MinJoin * ClampingCoeffMin and dArea > 1000 then
|
||||
bError = false
|
||||
end
|
||||
-- pinzaggio non fattibile, errore
|
||||
if bError then
|
||||
sErr = 'ERROR CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
|
||||
bWriteErrMessage = true
|
||||
end
|
||||
end
|
||||
-- WARNING: pinza meno del minimo richiesto
|
||||
if dArea and dArea < dMinClampingAreaWarn and not bWriteErrMessage then
|
||||
sWrn = 'WARNING CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
|
||||
bWriteWarnMessage = true
|
||||
end
|
||||
EgtEmptyGroup( CLAMP_CHECK_GROUP)
|
||||
EgtEmptyGroup( CLAMP_CHECK_INTERS)
|
||||
|
||||
-- controllo altro lato solo se non sono già in errore
|
||||
if not bWriteErrMessage then
|
||||
-- controllo faccia posteriore
|
||||
dArea = CalculateIntersectionArea( 'MAX', 'Y', 3)
|
||||
-- ERRORE: pinza troppo poco (meno di 1/3 del minimo richiesto)
|
||||
if dArea and dArea < dMinClampingAreaErr then
|
||||
-- solo se pinza almeno 1cm2, e la somma della lunghezza pinzata è maggiore della lunghezza minima pinzabile da Warning e non errore
|
||||
if dXClampedLenght >= MinJoin * ClampingCoeffMin and dArea > 1000 then
|
||||
bError = false
|
||||
end
|
||||
-- pinzaggio non fattibile, errore
|
||||
if bError then
|
||||
sErr = 'ERROR CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
|
||||
bWriteErrMessage = true
|
||||
end
|
||||
end
|
||||
-- WARNING: pinza meno del minimo richiesto
|
||||
if dArea and dArea < dMinClampingAreaWarn and not bWriteWarnMessage and not bWriteErrMessage then
|
||||
sWrn = 'WARNING CLAMPING ' .. sClampName .. ' : '..tostring( ceil( ( dArea / dMinClampingAreaWarn) * 100))..'% ( '.. tostring( dArea/1000)..'cm2)'
|
||||
bWriteWarnMessage = true
|
||||
end
|
||||
EgtEmptyGroup( CLAMP_CHECK_GROUP)
|
||||
EgtEmptyGroup( CLAMP_CHECK_INTERS)
|
||||
end
|
||||
|
||||
if bWriteErrMessage then
|
||||
EmtSetLastError( 1213, sErr, EgtGetEnableUI())
|
||||
EgtOutBox( sErr, 'CLAMPING', 'ERROR', 'OK')
|
||||
EmtSetSimulPause()
|
||||
elseif bWriteWarnMessage then
|
||||
EgtOutLog( sWrn)
|
||||
EgtOutBox( sWrn, 'CLAMPING', 'WARNING', 'OK')
|
||||
EmtSetSimulPause()
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecMovePY1( bClose)
|
||||
SimulMoveAxes( 'PY1', EgtIf( not bClose, MaxHoOpen, EMT.HB), MCH_SIM_STEP.RAPID)
|
||||
SetPY1Light( bClose)
|
||||
if bClose then
|
||||
CheckClamping( 'PY1')
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecMovePY2( bClose)
|
||||
SimulMoveAxes( 'PY2', EgtIf( not bClose, MaxHoOpen, EMT.HB), MCH_SIM_STEP.RAPID)
|
||||
SetPY2Light( bClose)
|
||||
if bClose then
|
||||
CheckClamping( 'PY2')
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -2025,6 +1645,8 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg)
|
||||
EMT.ERR = 2
|
||||
EmtSetLastError( 1202, 'Error on MoveAxes in ParkRoller (12A)')
|
||||
end
|
||||
EMT.Y1DELTA = nil
|
||||
EMT.Y1SPEC = true
|
||||
return 32
|
||||
elseif DiffY1 > 0.1 and DiffY2 < -0.1 then
|
||||
EMT.ERR = 2
|
||||
@@ -2091,8 +1713,8 @@ function ExecParkRoller( PosY1, PosY2, PosV1, PosV2, bSpliCut, bAgg)
|
||||
local MoveV2 = ParkV2 - PosV2
|
||||
local DiffY2 = MyParkY2 - PosY2
|
||||
local MoveY2 = EgtIf( DiffY2 < -0.1, MoveV2, 0)
|
||||
local TryMoveY2 = max( ParkV2 - PosT - EMT.LT - EMT.DELTA_LT - EMT.HOVM, MinY2 - PosY2 + 10)
|
||||
if ( PosT + EMT.LT + EMT.DELTA_LT + EMT.HOVM < ParkV1 + ExtraParkV and PosT + EMT.LT + EMT.DELTA_LT + EMT.HOVM > ParkV2 and PosY2 + TryMoveY2 > MinY2) then MoveY2 = min( MoveY2, TryMoveY2) end
|
||||
local TryMoveY2 = max( ParkV2 - PosT - EMT.LT, MinY2 - PosY2 + 10)
|
||||
if ( PosT + EMT.LT < ParkV1 + ExtraParkV and PosT + EMT.LT > ParkV2 and PosY2 + TryMoveY2 > MinY2) then MoveY2 = min( MoveY2, TryMoveY2) end
|
||||
if not SimulMoveAxes( 'T', PosT + MoveY2, MCH_SIM_STEP.RAPID,
|
||||
'V1', ParkV1, MCH_SIM_STEP.RAPID,
|
||||
'V2', ParkV2, MCH_SIM_STEP.RAPID,
|
||||
@@ -2325,9 +1947,6 @@ end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function GetV1ToClose()
|
||||
if EMT.MCHPRECUT or EMT.MCHCUT then
|
||||
return false
|
||||
end
|
||||
--EgtOutLog( string.format( 'L1m=%.3f L1M=%.3f V2NP=%.3f LB=%.3f', EMT.MAXMIN[1], EMT.MAXMAX[1], EMT.V2NEXTPOS, EMT.LB))
|
||||
--EgtOutLog( string.format( 'LB=%.3f LT=%.3f', EMT.LB, EMT.LT or 0))
|
||||
return ( EMT.MAXMAX[1] <= EMT.V1NEXTPOS + RollCageMin and EMT.MAXMIN[1] + EMT.LB >= EMT.V1NEXTPOS + RollCageMax)
|
||||
@@ -2409,29 +2028,36 @@ function LoadFirstTool( nHSet, sTcPosDef)
|
||||
return sTool
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function IsNewLinkHead( sHead)
|
||||
--return ( sHead == 'H11' or sHead == 'H12' or sHead == 'H13' or sHead == 'H14' or sHead == 'H16' or sHead == 'H38')
|
||||
return true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function IsL1Enabled( nMask)
|
||||
return ( ( nMask & 1) ~= 0)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** ESTIMATION T&L ***
|
||||
---------------------------------------------------------------------
|
||||
local ESTIMATION_RAPID_COEFF = EstimationRapidMultiplier or 1
|
||||
local RAPID_X_FEED = 70000 / ESTIMATION_RAPID_COEFF -- mm/min
|
||||
local RAPID_Y_FEED = 100000 / ESTIMATION_RAPID_COEFF -- mm/min
|
||||
local RAPID_Z_FEED = 32000 / ESTIMATION_RAPID_COEFF -- mm/min
|
||||
local RAPID_C_FEED = 15000 / ESTIMATION_RAPID_COEFF -- deg/min
|
||||
local RAPID_B_FEED = 15000 / ESTIMATION_RAPID_COEFF -- deg/min
|
||||
local RAPID_MIN_T = 0.1 * ESTIMATION_RAPID_COEFF -- s
|
||||
local LOAD_T = 2 * ESTIMATION_RAPID_COEFF -- s
|
||||
local CHAR_ONE_MOVE_T = 1 * ESTIMATION_RAPID_COEFF -- s
|
||||
local ROTATION_T = 40 * ESTIMATION_RAPID_COEFF -- s
|
||||
local SPLIT_T = 6 * ESTIMATION_RAPID_COEFF -- s
|
||||
local UNLOAD_T = 4 * ESTIMATION_RAPID_COEFF -- s
|
||||
local FALL_T = 2 * ESTIMATION_RAPID_COEFF -- s
|
||||
local RAPID_X_FEED = 70000 -- mm/min
|
||||
local RAPID_Y_FEED = 100000 -- mm/min
|
||||
local RAPID_Z_FEED = 32000 -- 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
|
||||
EMT.FMAXPINZE = EgtClamp( MaxFeedPinze or 116000, 20000, 130000) -- feed massima pinze
|
||||
EMT.MAXACC = MaxAcc or 6000 -- accelerazione massima pinze. In realtà è il tempo in millisecondi, quindi MAXACC corrisponde al tempo massimo per raggiungere la velocità desiderata
|
||||
EMT.MINACC = MinAcc or 600 -- accelerazione minima pinze. In realtà è il tempo in millisecondi, quindi MINACC corrisponde al tempo massimo per raggiungere la velocità desiderata
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -2517,15 +2143,6 @@ function OnEstimDispositionEnd()
|
||||
EMT.OPEISDISP = false
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimRawMoveData()
|
||||
-- se start del pezzo
|
||||
if IsStartOrRestPhase( EMT.PHASE) then
|
||||
EMT.SPLIT = false
|
||||
end
|
||||
OnRawMoveData()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimToolSelect()
|
||||
-- reset indice utensile in tabella lunghezze
|
||||
@@ -2582,12 +2199,6 @@ function OnEstimMachiningEnd()
|
||||
EMT.TLE_NAME = nil
|
||||
EMT.TLE_TIME = nil
|
||||
end
|
||||
|
||||
EMT.MCHUSERNOTES = EgtGetMachiningParam( MCH_MP.USERNOTES) or ''
|
||||
EMT.MCHSPLIT = ( EMT.MCHUSERNOTES:find( 'Split;', 1, true) ~= nil)
|
||||
if EMT.MCHSPLIT then
|
||||
EMT.SPLIT = true
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -2713,20 +2324,17 @@ function OnEstimRapid()
|
||||
EMT.MCHEXTLEN = EMT.MCHEXTLEN + dLen
|
||||
-- calcolo tempo
|
||||
local dTime = RAPID_MIN_T
|
||||
|
||||
local dT1 = CalcMoveTime( abs( dL1), RAPID_X_FEED, EMT.SPLIT)
|
||||
local dT1 = abs( dL1) / RAPID_X_FEED * 60
|
||||
if dT1 > dTime then dTime = dT1 end
|
||||
local dT2 = CalcMoveTime( abs( dL2), EMT.FMAXPINZE, EMT.SPLIT)
|
||||
local dT2 = abs( dL2) / RAPID_Y_FEED * 60
|
||||
if dT2 > dTime then dTime = dT2 end
|
||||
local dT3 = CalcMoveTime( abs( dL3), RAPID_Z_FEED, EMT.SPLIT)
|
||||
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()
|
||||
@@ -2742,7 +2350,7 @@ function OnEstimLinear()
|
||||
local dLen = sqrt( dL1 * dL1 + dL2 * dL2 + dL3 * dL3)
|
||||
EMT.MCHCUTLEN = EMT.MCHCUTLEN + dLen
|
||||
-- calcolo tempo
|
||||
local dTime = CalcMoveTime( dLen, EMT.F, EMT.SPLIT)
|
||||
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
|
||||
@@ -2997,9 +2605,9 @@ end
|
||||
---------------------------------------------------------------------
|
||||
function RollerParkingNeeded( sHead, dAng1p, dAng2p, dAng1, dAng2)
|
||||
if sHead == 'H11' or sHead == 'H12' or sHead == 'H13' or sHead == 'H16' then
|
||||
return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1) % 180.0 > 1))
|
||||
return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1 % 180.0) > 1))
|
||||
elseif sHead == 'H21' or sHead == 'H22' then
|
||||
return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1) % 180.0 > 1))
|
||||
return ( abs( dAng1 - dAng1p) > 1 or ( abs( dAng2 - dAng2p) > 1 and abs( dAng1 % 180.0) > 1))
|
||||
elseif sHead == 'H38' then
|
||||
return ( abs( dAng1 - dAng1p) > 1 or abs( dAng2 - dAng2p) > 1)
|
||||
end
|
||||
@@ -3016,38 +2624,5 @@ function GetCmdAxMove( Cmd, sAx)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function CalcDinamicaPinze( dH, dS, dL)
|
||||
local MinTempoAcc = EMT.MINACC -- [ms] ~600
|
||||
local MaxTempoAcc = EMT.MAXACC -- [ms] ~6000
|
||||
local KgMtCubo= WoodDensity or 550 -- densità legno [Kg / metro cubo]
|
||||
local Massa = ( dH * dS * dL * KgMtCubo ) / 1e9 -- massa [Kg]
|
||||
local FMaxPinze = EMT.FMAXPINZE -- Feed massima pinze [mm/min]
|
||||
local ForzaAttrito = 350 * 9.8 * 0.2 -- Forza chiusura pinze [Kgf] * g * Coeff_Attrito -> [N]
|
||||
local TempoAcc = EgtClamp( ( Massa * FMaxPinze) / ( 60 * ForzaAttrito), MinTempoAcc, MaxTempoAcc)
|
||||
local RidFeed = 100 / Massa * 100
|
||||
if RidFeed > 100 then
|
||||
RidFeed = 100
|
||||
elseif RidFeed < 10 then
|
||||
RidFeed = 10
|
||||
end
|
||||
return TempoAcc, MinTempoAcc, RidFeed
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function CalcMoveTime( dPathLen, dFeed, bIsSplitted)
|
||||
local dTime
|
||||
local dFeedInSec = dFeed / 60
|
||||
local dTempoAcc, _, _ = CalcDinamicaPinze( EMT.HB, EMT.SB, EgtIf( bIsSplitted, EMT.LT, EMT.LB))
|
||||
dTempoAcc = dTempoAcc / 1000
|
||||
-- se si raggiunge la velocità massima
|
||||
if dPathLen >= dFeedInSec * dTempoAcc then
|
||||
dTime = dTempoAcc * 2 + ( ( dPathLen - dFeedInSec * dTempoAcc) / dFeedInSec)
|
||||
else
|
||||
dTime = 2 * sqrt( (dPathLen * dTempoAcc) / dFeedInSec)
|
||||
end
|
||||
return dTime
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** END GENERAL ***
|
||||
|
||||
+311
-256
@@ -1,4 +1,4 @@
|
||||
-- Special Operations macchina Essetre-PF1250 by Egalware s.r.l. 2024/04/09
|
||||
-- Special Operations macchina Essetre-PF1250 by Egalware s.r.l. 2025/07/02
|
||||
-- Intestazioni
|
||||
|
||||
require( 'EmtGenerator')
|
||||
@@ -12,250 +12,269 @@ local BD = require( 'BeamData')
|
||||
---------------------------------------------------------------------
|
||||
require( 'EmtGenMachining')
|
||||
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** Special GetPrevMachiningOffset ***
|
||||
-- *** Special Link moves ***
|
||||
---------------------------------------------------------------------
|
||||
-----------------------------------------------------------------------------------------
|
||||
function OnSpecialGetPrevMachiningOffset()
|
||||
-- Aggiorno posizione della testa della trave a seguito di movimenti delle pinze non previsti tra le fasi
|
||||
local function TPosUpdate()
|
||||
local nClId = EgtGetFirstNameInGroup( EMC.CURRMCHID, 'CL') -- recupero Id del gruppo CL della lavorazione corrente
|
||||
local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL) -- Id del primo gruppo nella lavorazione (P1)
|
||||
if not nPathId then
|
||||
EMC.ERR = 12
|
||||
EMC.MSG = ' Error : CL group path not found'
|
||||
return
|
||||
end
|
||||
local dAuxMoveCount = EgtGetInfo( nPathId, 'AS#', 'd') or 0 -- numero di movimenti ausiliari
|
||||
local dTRepos = nil
|
||||
-- controlla ogni gruppo di movimenti ausiliari
|
||||
for i = 1, dAuxMoveCount do
|
||||
local aAuxMove = EgtGetInfo( nPathId, 'AS' .. tostring( i), 'vs') or {} -- array contenete i parametri di ogni gruppo
|
||||
-- controlla solo i movimenti della testa trave e salva l'ultimo
|
||||
if aAuxMove[1] == '2' or aAuxMove[1] == '3' then
|
||||
for j = 2, #aAuxMove do
|
||||
if aAuxMove[j] == 'T' then
|
||||
dTRepos = aAuxMove[j+1]
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
return dTRepos
|
||||
end
|
||||
|
||||
-- default
|
||||
EMC.ERR = 0
|
||||
EMC.PREVOFFSX = 0
|
||||
|
||||
-- se c'è cambio di fase tra le lavorazioni (quindi la precedente è l'ultima della sua fase e la corrente la prima)
|
||||
if EMC.PREVPHASE ~= EMC.CURRPHASE then
|
||||
-- se la fase corrente è di inizio lavorazione di nuova trave
|
||||
if IsStartOrRestPhase( EMC.CURRPHASE) then
|
||||
-- recupero la posizione finale della lavorazione precedente
|
||||
local vPrevAx = EmtGetFinalAxesPos( EMC.PREVMCHID)
|
||||
-- ricava se e quanto la trave viene spostata tra le due fasi dai movimenti ausiliari e corregge l'offset di fine fase
|
||||
local dNewTPos = TPosUpdate()
|
||||
-- se ci sono dei movimenti della testa trave tra le due fasi ricava il delta tra la vecchia e la nuova posizione
|
||||
if dNewTPos then
|
||||
EMC.PREVOFFSX = dNewTPos - vPrevAx[1]
|
||||
-- oppure la X (L1) di questa corrisponde alla posizione iniziale della nuova trave, se ne deduce l'offset
|
||||
else
|
||||
EMC.PREVOFFSX = ParkV1 - vPrevAx[1]
|
||||
end
|
||||
end
|
||||
local function IsPrevSplit()
|
||||
local sPrevUserNotes = ''
|
||||
if EMC.LINKTYPE == 2 then
|
||||
sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
||||
elseif EMC.LINKTYPE == 3 then
|
||||
EgtSetCurrMachining( EMC.PREVMCHID)
|
||||
sPrevUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
||||
EgtSetCurrMachining( EMC.NEXTMCHID)
|
||||
end
|
||||
return ( sPrevUserNotes:find( 'Split;', 1, true) ~= nil)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** Special Z moves ***
|
||||
---------------------------------------------------------------------
|
||||
---------------------- OnSpecialGetMaxZ -----------------------------
|
||||
local function CalcExtraZ( vtTp, vtT, vMZ)
|
||||
-- la tabella deve esistere ed essere non vuota
|
||||
if not vMZ or #vMZ == 0 then return 0 end
|
||||
-- componente Z di riferimento è la minima
|
||||
local vtTz = min( vtTp:getZ(), vtT:getZ())
|
||||
-- se oltre il massimo
|
||||
if vtTz > vMZ[1].Tz then return vMZ[1].Ez end
|
||||
-- interpolo
|
||||
for i = 2, #vMZ do
|
||||
if vtTz > vMZ[i].Tz then
|
||||
local dCoeff = ( vtTz - vMZ[i-1].Tz) / ( vMZ[i].Tz - vMZ[i-1].Tz)
|
||||
return (( 1 - dCoeff) * vMZ[i-1].Ez + dCoeff * vMZ[i].Ez)
|
||||
-----------------------------------------------------------------------------------------
|
||||
local function GetActiveRawBBox()
|
||||
local b3Raw = BBox3d()
|
||||
local nRawId = EgtGetFirstRawPart()
|
||||
while nRawId do
|
||||
if EgtVerifyRawPartPhase( nRawId, EMC.PHASE) then
|
||||
b3Raw = EgtGetRawPartBBox( nRawId)
|
||||
break
|
||||
end
|
||||
nRawId = EgtGetNextRawPart( nRawId)
|
||||
end
|
||||
-- sotto il minimo
|
||||
return 0
|
||||
return b3Raw
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSpecialGetMaxZ()
|
||||
-- Inizializzazioni
|
||||
EMC.ERR = 0
|
||||
-----------------------------------------------------------------------------------------
|
||||
function OnSpecialLink()
|
||||
|
||||
-- Gestione speciale per sega a catena
|
||||
if EMC.HEAD == 'H13' then
|
||||
EMC.MAXZ = EgtGetAxisHomePos( 'Z1')
|
||||
return
|
||||
end
|
||||
|
||||
-- Sistemazione dati di input
|
||||
local vtTp = Vector3d( EMC.TDIRp)
|
||||
local bFromZmax = false
|
||||
-- recupero il gruppo
|
||||
local nSetHead = GetHeadSet( EMC.HEAD)
|
||||
if vtTp:isSmall() then
|
||||
vtTp = X_AX()
|
||||
bFromZmax = true
|
||||
if nSetHead == 1 then
|
||||
EMC.R1p = ParkC1
|
||||
EMC.R2p = ParkB1
|
||||
elseif nSetHead == 2 then
|
||||
EMC.R1p = ParkC2
|
||||
EMC.R2p = ParkB2
|
||||
elseif nSetHead == 3 then
|
||||
EMC.R1p = ParkC3
|
||||
EMC.R2p = ParkB3
|
||||
end
|
||||
end
|
||||
local vtT = Vector3d( EMC.TDIR)
|
||||
local vtTpZm = EgtIf( bFromZmax, vtT, vtTp)
|
||||
local bBSameSign = (( EMC.R2p < 10 and EMC.R2 < 10) or ( EMC.R2p > -10 and EMC.R2 > -10))
|
||||
|
||||
-- Calcolo in funzione della testa e dei parametri
|
||||
-- se fresa su testa 1
|
||||
if EMC.HEAD == 'H11' then
|
||||
if bBSameSign and vtTp:getX() > -0.1 and vtT:getX() > -0.1 then
|
||||
EMC.MAXZ = MaxZ1
|
||||
else
|
||||
local vMZ = {{ Tz=0.85, Ez=390}, { Tz=0.5, Ez=280}, { Tz=-0.01, Ez=160}}
|
||||
EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
|
||||
end
|
||||
elseif EMC.HEAD == 'H12' then
|
||||
if vtTp:getX() > 0.3 and vtT:getX() > 0.3 then
|
||||
if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then
|
||||
EMC.MAXZ = MaxZ1Blade - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130)
|
||||
elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then
|
||||
EMC.MAXZ = ParkZ1 + 200
|
||||
elseif vtTp:getZ() > 0.5 or vtT:getZ() > 0.5 then
|
||||
EMC.MAXZ = ParkZ1 + 100
|
||||
else
|
||||
EMC.MAXZ = ParkZ1 + 1
|
||||
|
||||
-- se inizio lavorazione con prelievo utensile
|
||||
if EMC.LINKTYPE == 1 then
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 1)
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2)
|
||||
end
|
||||
elseif bBSameSign and EMC.R1p > 29.9 and EMC.R1p < 180.1 and EMC.R1 > 29.9 and EMC.R1 < 180.1 and EMC.R2p > -10 and EMC.R2 > -10 then
|
||||
EMC.MAXZ = MaxZ1Blade - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130)
|
||||
elseif bBSameSign and EMC.R1p > -0.1 and EMC.R1p < 180.1 and EMC.R1 > -0.1 and EMC.R1 < 180.1 and EMC.R2p > -10 and EMC.R2 > -10 then
|
||||
local vMZ = {{ Tz=0.85, Ez=440}, { Tz=0.5, Ez=200}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
|
||||
EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
|
||||
else
|
||||
local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=60}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
|
||||
EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
|
||||
end
|
||||
elseif EMC.HEAD == 'H16' then
|
||||
if vtTp:getX() > 0.3 and vtT:getX() > 0.3 then
|
||||
if bBSameSign and abs( EMC.R1 - EMC.R1p) < 165 then
|
||||
EMC.MAXZ = MaxZ1Blade - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130)
|
||||
elseif vtTp:getZ() > 0.707 or vtT:getZ() > 0.707 then
|
||||
EMC.MAXZ = ParkZ1 + 200
|
||||
elseif vtTp:getZ() > 0.5 or vtT:getZ() > 0.5 then
|
||||
EMC.MAXZ = ParkZ1 + 100
|
||||
|
||||
-- se fine lavorazione con deposito utensile
|
||||
elseif EMC.LINKTYPE == 2 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 1)
|
||||
else
|
||||
EMC.MAXZ = ParkZ1 + 1
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2)
|
||||
end
|
||||
elseif bBSameSign and EMC.R1p > 29.9 and EMC.R1p < 180.1 and EMC.R1 > 29.9 and EMC.R1 < 180.1 and EMC.R2p > -10 and EMC.R2 > -10 then
|
||||
EMC.MAXZ = MaxZ1Blade - EgtIf( abs( EMC.R2) < 90.1 and abs( EMC.R2p) < 90.1, 0, 130)
|
||||
elseif bBSameSign and EMC.R1p > -0.1 and EMC.R1p < 180.1 and EMC.R1 > -0.1 and EMC.R1 < 180.1 and EMC.R2p > -10 and EMC.R2 > -10 then
|
||||
local vMZ = {{ Tz=0.85, Ez=440}, { Tz=0.5, Ez=200}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
|
||||
EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 1, 'LastRapid=1;')
|
||||
|
||||
-- altrimenti collegamento tra due lavorazioni (3)
|
||||
else
|
||||
local vMZ = {{ Tz=0.85, Ez=400}, { Tz=0.7, Ez=300}, { Tz=0.5, Ez=195}, { Tz=0.15, Ez=60}, { Tz=-0.01, Ez=5}, { Tz=-0.5, Ez=1}}
|
||||
EMC.MAXZ = ParkZ1 + CalcExtraZ( vtTpZm, vtT, vMZ)
|
||||
-- recupero quota massima di collegamento
|
||||
local vLFiAx = EmtGetFinalAxesPos( EMC.PREVMCHID, false)
|
||||
local vLInAx = EmtGetInitialAxesPos( EMC.NEXTMCHID, false)
|
||||
-- se superata quota massima ammessa
|
||||
if max( vLFiAx[3], vLInAx[3]) > ParkZ1 + 1 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, MaxZ1, EMC.R1p, 0}, 30, 3, 1)
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, MaxZ1, EMC.R1, 0}, 30, 2, 1)
|
||||
end
|
||||
end
|
||||
elseif EMC.HEAD == 'H21' then
|
||||
if bBSameSign and vtTp:getX() > -0.1 and vtT:getX() > -0.1 then
|
||||
EMC.MAXZ = MaxZ2
|
||||
else
|
||||
local vMZ = {{ Tz=0.85, Ez=390}, { Tz=0.5, Ez=280}, { Tz=-0.01, Ez=160}}
|
||||
EMC.MAXZ = ParkZ2 + CalcExtraZ( vtTpZm, vtT, vMZ)
|
||||
end
|
||||
elseif EMC.HEAD == 'H38' then
|
||||
EMC.MAXZ = SafeZ3RotAxis
|
||||
end
|
||||
end
|
||||
|
||||
---------------------- OnSpecialMoveZup -----------------------------
|
||||
function OnSpecialMoveZup()
|
||||
|
||||
--EgtOutLog( 'OnSpecialMoveZup : ' .. EMC.HEAD .. '.' .. tostring( EMC.EXIT))
|
||||
|
||||
-- Inizializzazioni
|
||||
EMC.ERR = 0
|
||||
EMC.MODIF = false
|
||||
|
||||
-- Direzione utensile
|
||||
local vtT = Vector3d( EMC.TDIR)
|
||||
|
||||
-- recupero Z1 home
|
||||
local nHeadSet = GetHeadSet( EMC.HEAD)
|
||||
local dZmax = EgtGetAxisHomePos( EgtIf( nHeadSet ~= 2, 'Z1', 'Z2'))
|
||||
|
||||
|
||||
-- se fresa su testa1 o testa 2
|
||||
if EMC.HEAD == 'H11' or EMC.HEAD == 'H21' or EMC.HEAD == 'H22' then
|
||||
;
|
||||
-- se lama
|
||||
-- se lama su rinvio standard o opposto di testa 1
|
||||
elseif EMC.HEAD == 'H12' or EMC.HEAD == 'H16' then
|
||||
-- riporto i valori tra -179 e + 180
|
||||
local dCheckAxR1 = EMC.R1
|
||||
if dCheckAxR1 < -180 then
|
||||
dCheckAxR1 = dCheckAxR1 + 360
|
||||
elseif dCheckAxR1 > 180 then
|
||||
dCheckAxR1 = dCheckAxR1 - 360
|
||||
end
|
||||
-- se lama su testa1
|
||||
if EMC.HEAD == 'H12' then
|
||||
-- se inclinata oltre 90 gradi e interferisce con la trave
|
||||
if ( EMC.R2 > 87.9 and ( dCheckAxR1 < 15.0 or dCheckAxR1 > 180.0)) or ( EMC.R2 < -87.9 and ( dCheckAxR1 > -15.0 and dCheckAxR1 < 180.0)) then
|
||||
local dZref = dZmax + min( 330 * vtT:getZ(), 0) + 260 * ( 1 - sqrt( 1- vtT:getZ() * vtT:getZ()))
|
||||
-- se troppo in alto
|
||||
if EMC.L3 > dZref + 1 then
|
||||
---- sistemo asse rotante
|
||||
--EMC.R2 = EgtIf( ( EMC.R2 > 0), 90, -90)
|
||||
---- ricalcolo versore utensile
|
||||
--EMC.TDIR = EgtGetCalcToolDirFromAngles( EMC.R1, EMC.R2)
|
||||
---- porto alla giusta quota
|
||||
--EMC.L3 = dZmax
|
||||
EMC.L3 = dZref
|
||||
-- dichiaro modificato
|
||||
EMC.MODIF = true
|
||||
end
|
||||
-- recupero se split da note utente di lavorazione precedente
|
||||
local bSplit = IsPrevSplit()
|
||||
|
||||
-- se inizio lavorazione con prelievo utensile
|
||||
if EMC.LINKTYPE == 1 then
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 1)
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2)
|
||||
end
|
||||
-- se seconda lama su testa1
|
||||
elseif EMC.HEAD == 'H16' then
|
||||
-- se inclinata oltre 90 gradi e interferisce con la trave
|
||||
if ( EMC.R2 > 87.9 and ( dCheckAxR1 < 15.0 or dCheckAxR1 > 180.0)) or ( EMC.R2 < -87.9 and ( dCheckAxR1 > -15.0 and dCheckAxR1< 180.0)) then
|
||||
local dZref = dZmax + min( 330 * vtT:getZ(), 0) + 260 * ( 1 - sqrt( 1- vtT:getZ() * vtT:getZ()))
|
||||
-- se troppo in alto
|
||||
if EMC.L3 > dZref + 1 then
|
||||
---- sistemo asse rotante
|
||||
--EMC.R2 = EgtIf( ( EMC.R2 > 0), 90, -90)
|
||||
---- ricalcolo versore utensile
|
||||
--EMC.TDIR = EgtGetCalcToolDirFromAngles( EMC.R1, EMC.R2)
|
||||
---- porto alla giusta quota
|
||||
--EMC.L3 = dZmax
|
||||
EMC.L3 = dZref
|
||||
-- dichiaro modificato
|
||||
EMC.MODIF = true
|
||||
end
|
||||
|
||||
-- se fine lavorazione con deposito utensile
|
||||
elseif EMC.LINKTYPE == 2 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', ''))
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 1)
|
||||
else
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', ''))
|
||||
end
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 1, 'LastRapid=1;')
|
||||
|
||||
-- altrimenti collegamento tra due lavorazioni (3)
|
||||
else
|
||||
-- recupero quota massima di collegamento
|
||||
local vLFiAx = EmtGetFinalAxesPos( EMC.PREVMCHID, false)
|
||||
local vLInAx = EmtGetInitialAxesPos( EMC.NEXTMCHID, false)
|
||||
-- se superata quota massima ammessa
|
||||
if max( vLFiAx[3], vLInAx[3]) > ParkZ1 + 1 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, MaxZ1Blade, EMC.R1p, 0}, 30, 3, 1, EgtIf( bSplit, 'Split=1;', ''))
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, MaxZ1Blade, EMC.R1, 0}, 30, 2, 1)
|
||||
end
|
||||
end
|
||||
|
||||
-- se sega a catena su testa 1
|
||||
elseif EMC.HEAD == 'H13' then
|
||||
-- recupero se split da note utente di lavorazione precedente
|
||||
local bSplit = IsPrevSplit()
|
||||
|
||||
-- se inizio lavorazione con prelievo utensile
|
||||
if EMC.LINKTYPE == 1 then
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, ParkCSawZ1, EMC.R1p, EMC.R2p, EMC.R3p}, 30, 2, 1)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2p, EMC.R3p}, 30, 2, 0)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, EMC.R2, EMC.R3p}, 30, 2, 0)
|
||||
|
||||
-- se fine lavorazione con deposito utensile
|
||||
elseif EMC.LINKTYPE == 2 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, EMC.R2, EMC.R3p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', ''))
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, EMC.R2, EMC.R3p}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, ParkCSawZ1, EMC.R1, EMC.R2, EMC.R3p}, 30, 3, 1, 'LastRapid=1;')
|
||||
end
|
||||
|
||||
-- se aggregato foratore multiplo su testa 1
|
||||
elseif EMC.HEAD == 'H14' then
|
||||
|
||||
-- se inizio lavorazione con prelievo utensile
|
||||
if EMC.LINKTYPE == 1 then
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 1)
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1p, 0}, 30, 2, 2)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, EMC.L3p, EMC.R1, 0}, 30, 2, 2)
|
||||
end
|
||||
|
||||
-- se fine lavorazione con deposito utensile
|
||||
elseif EMC.LINKTYPE == 2 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1p, 0, EMC.R3}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, EMC.L3, EMC.R1, 0, EMC.R3}, 30, 3, 2)
|
||||
end
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2, EMC.R3}, 30, 3, 1, 'LastRapid=1;')
|
||||
end
|
||||
|
||||
-- se fresa su testa 2
|
||||
elseif EMC.HEAD == 'H21' then
|
||||
-- se inizio lavorazione con prelievo utensile
|
||||
if EMC.LINKTYPE == 1 then
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, ParkZ2, ParkC2, ParkB2}, 30, 2, 1)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, ParkZ2, EMC.R1, EMC.R2}, 30, 2, 2)
|
||||
|
||||
-- se fine lavorazione con deposito utensile
|
||||
elseif EMC.LINKTYPE == 2 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, ParkZ2, EMC.R1p, EMC.R2p}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, ParkZ2, ParkC2, ParkB2}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, ParkX2, ParkZ2, ParkC2, ParkB2}, 30, 3, 1, 'LastRapid=1;')
|
||||
end
|
||||
|
||||
-- se lama su testa 2
|
||||
elseif EMC.HEAD == 'H22' then
|
||||
-- se inizio lavorazione con prelievo utensile
|
||||
if EMC.LINKTYPE == 1 then
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, ParkZ2, ParkC2, ParkB2}, 30, 2, 1)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, ParkZ2, EMC.R1, EMC.R2}, 30, 2, 2)
|
||||
|
||||
-- se fine lavorazione con deposito utensile
|
||||
elseif EMC.LINKTYPE == 2 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, ParkZ2, EMC.R1p, EMC.R2p}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, ParkZ2, ParkC2, ParkB2}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, SafeX2, ParkZ2, ParkC2, ParkB2}, 30, 3, 1, 'LastRapid=1;')
|
||||
end
|
||||
|
||||
-- se lama su testa 3
|
||||
elseif EMC.HEAD == 'H38' then
|
||||
EMC.L3 = SafeZ3RotAxis
|
||||
-- dichiaro modificato
|
||||
EMC.MODIF = true
|
||||
else
|
||||
; -- non si fa nulla
|
||||
-- sicurezza aggiuntiva
|
||||
local SAFE_DIST = 50
|
||||
local dExtraDist = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM) / 2 + SAFE_DIST
|
||||
-- recupero se split da note utente di lavorazione precedente
|
||||
local bSplit = IsPrevSplit()
|
||||
-- recupero ingombro del primo grezzo in lavoro
|
||||
local b3Raw = GetActiveRawBBox()
|
||||
local dMinRawX3 = b3Raw:getMin():getY() - Head3Y
|
||||
local dMaxRawX3 = b3Raw:getMax():getY() - Head3Y
|
||||
local dMidRawX3 = ( dMinRawX3 + dMaxRawX3) / 2
|
||||
|
||||
-- se inizio lavorazione con prelievo utensile
|
||||
if EMC.LINKTYPE == 1 then
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
local dSafeX3 = EgtIf( EMC.L2 < dMidRawX3, dMinRawX3 - dExtraDist, dMaxRawX3 + dExtraDist)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, dSafeX3, EMC.L3p, EMC.R1p, EMC.R2p}, 30, 2, 1)
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, dSafeX3, SafeZ3RotAxis, EMC.R1p, EMC.R2p}, 30, 2, 2)
|
||||
-- deve muoversi anche la trave (la lama non è abbastanza alta in Z) quindi Mask = 31
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, dSafeX3, SafeZ3RotAxis, EMC.R1, EMC.R2}, 31, 2, 2)
|
||||
end
|
||||
|
||||
-- se fine lavorazione con deposito utensile
|
||||
elseif EMC.LINKTYPE == 2 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
local dSafeX3 = EgtIf( EMC.L2p < dMidRawX3, dMinRawX3 - dExtraDist, dMaxRawX3 + dExtraDist)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, dSafeX3, SafeZ3RotAxis, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', ''))
|
||||
if abs( EMC.R1 - EMC.R1p) > 1 or abs( EMC.R2 - EMC.R2p) > 1 then
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, dSafeX3, SafeZ3RotAxis, EMC.R1, EMC.R2}, 30, 3, 2)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, dSafeX3, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 1)
|
||||
end
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2, EMC.L3, EMC.R1, EMC.R2}, 30, 3, 1, 'LastRapid=1;')
|
||||
|
||||
-- altrimenti collegamento tra due lavorazioni (3)
|
||||
else
|
||||
-- recupero quota massima di collegamento
|
||||
local vLFiAx = EmtGetFinalAxesPos( EMC.PREVMCHID, false)
|
||||
local vLInAx = EmtGetInitialAxesPos( EMC.NEXTMCHID, false)
|
||||
-- se superata quota massima ammessa
|
||||
if max( vLFiAx[3], vLInAx[3]) > SafeZ3RotAxis + 1 then
|
||||
-- retrazione
|
||||
EmtRemoveRise( EMC.PREVMCHID)
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, SafeZ3RotAxis, EMC.R1p, EMC.R2p}, 30, 3, 2, EgtIf( bSplit, 'Split=1;', ''))
|
||||
EmtAddRise( EMC.PREVMCHID, { EMC.L1p, EMC.L2p, SafeZ3RotAxis, EMC.R1p, 0}, 30, 3, 2, 'LastRapid=1;')
|
||||
-- approccio
|
||||
EmtRemoveClimb( EMC.NEXTMCHID)
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, SafeZ3RotAxis, EMC.R1, 0}, 30, 2, 2)
|
||||
-- se non split deve muoversi anche la trave (la lama non è abbastanza alta in Z) quindi Mask = 31
|
||||
EmtAddClimb( EMC.NEXTMCHID, { EMC.L1, EMC.L2, SafeZ3RotAxis, EMC.R1, EMC.R2}, EgtIf( bSplit, 30, 31), 2, 2)
|
||||
end
|
||||
end
|
||||
-- testa con truciolatore su testa 3
|
||||
elseif EMC.HEAD == 'H39' then
|
||||
;
|
||||
end
|
||||
|
||||
EMC.ERR = 0
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -406,6 +425,57 @@ local function EmitComment( vCmd, sOut)
|
||||
end
|
||||
end
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
local function CallSpecialLink()
|
||||
-- cerco la lavorazione attiva precedente
|
||||
local nPrevMchId = EgtGetPrevActiveOperation( EMC.MCHID)
|
||||
while nPrevMchId and EgtGetOperationType( nPrevMchId) == MCH_OY.DISP do
|
||||
nPrevMchId = EgtGetPrevActiveOperation( nPrevMchId)
|
||||
end
|
||||
-- se non esiste lavorazione precedente, non devo fare alcunché
|
||||
if not nPrevMchId then return end
|
||||
-- salvo nome utensile corrente
|
||||
local sTool = EgtGetMachiningParam( MCH_MP.TOOL)
|
||||
-- recupero utensile, testa, uscita e TcPos della lavorazione precedente
|
||||
EgtSetCurrMachining( nPrevMchId)
|
||||
local sPrevTool = EgtGetMachiningParam( MCH_MP.TOOL)
|
||||
-- se utensili cambiati, non devo fare alcunché
|
||||
if sTool ~= sPrevTool then
|
||||
EgtSetCurrMachining( EMC.MCHID)
|
||||
return
|
||||
end
|
||||
-- recupero altri dati lavorazione precedente
|
||||
EgtTdbSetCurrTool( sPrevTool)
|
||||
local sPrevHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
||||
local sPrevExit = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
|
||||
local _, sPrevTcPos = EgtFindToolInCurrSetup( sPrevTool)
|
||||
local nPrevPhase = EgtGetOperationPhase( nPrevMchId)
|
||||
local vPrevAxIni = EmtGetFinalAxesPos( nPrevMchId)
|
||||
local vPrevAxFin = EmtGetCurrAxesHomePos()
|
||||
-- lancio risalita al termine della lavorazione precedente
|
||||
local OrigEMC = EMC
|
||||
EMC = { TOOL = sPrevTool, HEAD = sPrevHead, EXIT = sPrevExit, TCPOS = sPrevTcPos, PREVMCHID = nPrevMchId, PREVPHASE = nPrevPhase, LINKTYPE = 2,
|
||||
L1p = vPrevAxIni[1], L2p = vPrevAxIni[2], L3p = vPrevAxIni[3], R1p = vPrevAxIni[4], R2p = vPrevAxIni[5], R3p = vPrevAxIni[6],
|
||||
L1 = vPrevAxFin[1], L2 = vPrevAxFin[2], L3 = vPrevAxFin[3], R1 = vPrevAxFin[4], R2 = vPrevAxFin[5], R3 = vPrevAxFin[6]}
|
||||
OnSpecialLink()
|
||||
EMC = OrigEMC
|
||||
-- recupero dati lavorazione corrente
|
||||
EgtSetCurrMachining( EMC.MCHID)
|
||||
EgtTdbSetCurrTool( sTool)
|
||||
local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
||||
local sExit = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
|
||||
local _, sTcPos = EgtFindToolInCurrSetup( sTool)
|
||||
local vAxIni = EmtGetCurrAxesHomePos()
|
||||
local vAxFin = EmtGetInitialAxesPos( EMC.MCHID)
|
||||
-- lancio discesa all'inizio della lavorazione corrente
|
||||
OrigEMC = EMC
|
||||
EMC = { TOOL = sTool, HEAD = sHead, EXIT = sExit, TCPOS = sTcPos, NEXTMCHID = OrigEMC.MCHID, NEXTPHASE = OrigEMC.PHASE, LINKTYPE = 1,
|
||||
L1p = vAxIni[1], L2p = vAxIni[2], L3p = vAxIni[3], R1p = vAxIni[4], R2p = vAxIni[5], R3p = vAxIni[6],
|
||||
L1 = vAxFin[1], L2 = vAxFin[2], L3 = vAxFin[3], R1 = vAxFin[4], R2 = vAxFin[5], R3 = vAxFin[6]}
|
||||
OnSpecialLink()
|
||||
EMC = OrigEMC
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSpecialApplyDisposition()
|
||||
|
||||
@@ -577,30 +647,14 @@ end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnPostApplyMachining()
|
||||
-- Inizializzo codice di errore
|
||||
EMC.ERR = 0
|
||||
-- Verifico se ultima lavorazione della fase
|
||||
local nNextOpeId = EgtGetNextActiveOperation( EMC.MCHID)
|
||||
local bMchLast = ( not nNextOpeId or EgtGetOperationPhase( nNextOpeId) ~= EMC.PHASE) -- Agisco sui diversi percorsi della lavorazione
|
||||
local nPathId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( EMC.MCHID, 'CL') or GDB_ID.NULL)
|
||||
while nPathId do
|
||||
-- recupero id del successivo
|
||||
nPathId = EgtGetNext( nPathId)
|
||||
-- verifico se ultimo percorso di ultima lavorazione della fase
|
||||
local bLast = ( bMchLast and ( not nPathId))
|
||||
-- se ultimo, elimino ritorno in home
|
||||
if bLast then EgtRemoveOperationHome( EMC.MCHID) end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSpecialApplyMachining()
|
||||
|
||||
EgtOutLog( ' Lavorazione : ' .. EgtGetName( EMC.MCHID) .. ' (' .. tostring( EMC.MCHID) .. ')')
|
||||
|
||||
-- Inizializzo codice di errore
|
||||
EMC.ERR = 0
|
||||
|
||||
EMC.ZMAX = false
|
||||
|
||||
-- Recupero la posizione della trave e dei carrelli al termine della precedente operazione
|
||||
local nPrevOpeId = EgtGetPrevActiveOperation( EMC.MCHID)
|
||||
-- se precedente operazione non esiste, errore
|
||||
@@ -651,13 +705,14 @@ function OnSpecialApplyMachining()
|
||||
-- aggiornamento posizioni
|
||||
local nLastPathId = EgtGetLastInGroup( EgtGetFirstNameInGroup( nPrevOpeId, 'CL') or GDB_ID.NULL)
|
||||
local nLastEntId = EgtGetLastInGroup( nLastPathId)
|
||||
local bAtZMax = ( EgtGetClEntMove( nLastEntId) == 0 and EgtGetClEntFlag( nLastEntId) == 3)
|
||||
local nFlag, nFlag2 = EgtGetClEntFlag( nLastEntId)
|
||||
local bVParked = ( EgtGetClEntMove( nLastEntId) == 0 and ( nFlag == 3 or nFlag2 == 1 or nFlag2 == 2))
|
||||
local vAxes = EmtGetAxesPos( nLastEntId)
|
||||
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
||||
EMC.Y1DELTA = EgtGetInfo( nLastPathId, 'Y1DELTA', 'd')
|
||||
EMC.Y2DELTA = EgtGetInfo( nLastPathId, 'Y2DELTA', 'd')
|
||||
EMC.V1POS = EgtIf( bAtZMax, ParkV1, EgtGetInfo( nLastPathId, 'V1POS', 'd') or ParkV1)
|
||||
EMC.V2POS = EgtIf( bAtZMax, ParkV2, EgtGetInfo( nLastPathId, 'V2POS', 'd') or ParkV2)
|
||||
EMC.V1POS = EgtIf( bVParked, ParkV1, EgtGetInfo( nLastPathId, 'V1POS', 'd') or ParkV1)
|
||||
EMC.V2POS = EgtIf( bVParked, ParkV2, EgtGetInfo( nLastPathId, 'V2POS', 'd') or ParkV2)
|
||||
EMC.CNT = SpecGetCNT( EMC.MCHID)
|
||||
end
|
||||
|
||||
@@ -687,7 +742,7 @@ function OnSpecialApplyMachining()
|
||||
-- verifico se ultimo percorso di ultima lavorazione della fase
|
||||
local bLast = ( bMchLast and ( not nPathId))
|
||||
-- se ultimo, elimino ritorno in home
|
||||
-- if bLast then EgtRemoveOperationHome( EMC.MCHID) end
|
||||
if bLast then EgtRemoveOperationHome( EMC.MCHID) end
|
||||
-- salvo lo stato dei carrelli
|
||||
local OriTPos = EMC.TPOS
|
||||
local OriY1Delta = EMC.Y1DELTA
|
||||
@@ -744,6 +799,11 @@ function OnSpecialApplyMachining()
|
||||
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
||||
end
|
||||
|
||||
-- Se richiesto movimento preliminare della testa a Zmax
|
||||
if EMC.ZMAX then
|
||||
CallSpecialLink()
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -886,12 +946,6 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload)
|
||||
if not EMC.Y2DELTA then
|
||||
EgtOutLog( ' Warning SPLITTING -> separazione con caduta pezzo')
|
||||
SpecOutputCNT()
|
||||
-- non funziona ma servirebbe un controllo simile, di modo che non possa avvenire la presenza di un pezzo "FALL" più grande di LEN_VERY_SHORT_PART
|
||||
--if EMC.LT > LEN_VERY_SHORT_PART then
|
||||
-- EMC.ERR = 19
|
||||
-- EMC.MSG = ' Error SPLIT : Y1 or Y2 not clamped'
|
||||
-- return false
|
||||
--end
|
||||
if IsEndPhase( EMC.PHASE + 1) then
|
||||
EgtSetInfo( NextDispId, 'SKIP', '1')
|
||||
local NextOpeId = EgtGetNextOperation( NextDispId)
|
||||
@@ -1193,7 +1247,7 @@ function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1Del
|
||||
-- dopo che si è calcolato il minimo e massimo dell'intervallo, verifico che in testa rimanga almeno il minimo per poter fare passaggio pinze e scaricare
|
||||
if AuxInfoMach and ( AuxInfoMach.bSplitting or AuxInfoMach.bCutting) then
|
||||
if WorkTab.dY1DeltaMaxF - WorkTab.dY1DeltaMinF > 1.5 * BD.CHAR_EXTRA_DIST and WorkTab.dY1DeltaMaxF > EMC.LT + BD.MINRAW_S + BD.CHAR_EXTRA_DIST then
|
||||
WorkTab.dY1DeltaMinF = max( min( EMC.LT + BD.MINRAW_S, WorkTab.dY1DeltaMaxF - 1), WorkTab.dY1DeltaMinF + EMC.LT)
|
||||
WorkTab.dY1DeltaMinF = max( min( EMC.LT + BD.MINRAW_S, WorkTab.dY1DeltaMaxF - 1), WorkTab.dY1DeltaMinF)
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1226,9 +1280,7 @@ function SpecCalcCarriages( dDistFront, dDistBack, dRollFront, dRollBack, dY1Del
|
||||
WorkTab.dY1DeltaMaxF = min( EMC.LB - MinJoin, MaxY1 + dDistFront + dRollFront + AGG_V)
|
||||
WorkTab.dY2DeltaMinF = max( MinJoin + EMC.HCING + EMC.HOVM, EMC.LB + MinY2 - dMyDistBack - AGG_V - dRollBack)
|
||||
WorkTab.dY2DeltaMaxF = min( dDistFront, EMC.LB - MyMinOther) -- - EMC.TCING
|
||||
if dY1DeltaMaxSP and dY1DeltaMaxSP > WorkTab.dY1DeltaMinF then
|
||||
WorkTab.dY1DeltaMaxF = min( WorkTab.dY1DeltaMaxF, dY1DeltaMaxSP)
|
||||
end
|
||||
if dY1DeltaMaxSP then WorkTab.dY1DeltaMaxF = min( WorkTab.dY1DeltaMaxF, dY1DeltaMaxSP) end
|
||||
if dY2DeltaMinUL then WorkTab.dY2DeltaMinF = max( WorkTab.dY2DeltaMinF, dY2DeltaMinUL) end
|
||||
WorkTab.dV1PosF = dRollBack
|
||||
WorkTab.bV1CloseF = false
|
||||
@@ -1406,7 +1458,7 @@ function SpecCalcUnload()
|
||||
table.insert( vCmd, { 2, 'T', dFinT, 'Y2', dFinY2})
|
||||
EgtOutLog( ' Y2PosF=' .. EgtNumToString( dFinY2), 1)
|
||||
else
|
||||
table.insert( vCmd, { 1, 'Y2', MaxY2, 'Manual Unloading'})
|
||||
table.insert( vCmd, { 1, 'Y2', MaxY2})
|
||||
end
|
||||
-- apro la morsa
|
||||
table.insert( vCmd, { 12, 0})
|
||||
@@ -2536,11 +2588,11 @@ function SpecOutputCmds( vCmd, bEnd)
|
||||
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
||||
-- movimento di 1 asse
|
||||
elseif Cmd[1] == 1 then
|
||||
local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..EgtIf( Cmd[4], ','..tostring(Cmd[4]), '')
|
||||
local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..EgtIf( Cmd[4], ',*', '')
|
||||
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
||||
-- movimento di 2 assi
|
||||
elseif Cmd[1] == 2 then
|
||||
local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..EgtIf( Cmd[6], ','..tostring(Cmd[6]), '')
|
||||
local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..EgtIf( Cmd[6], ',*', '')
|
||||
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
||||
-- movimento di 3 assi
|
||||
elseif Cmd[1] == 3 then
|
||||
@@ -2551,6 +2603,9 @@ function SpecOutputCmds( vCmd, bEnd)
|
||||
elseif Cmd[1] == 4 then
|
||||
local sInfo = '4,'..EgtNumToString( Cmd[2],0)
|
||||
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
||||
if not bEnd and Cmd[2] == 1 then
|
||||
EMC.ZMAX = true
|
||||
end
|
||||
-- apertura/chiusura morsa Y
|
||||
elseif Cmd[1] == 11 then
|
||||
local sInfo = '11,'..EgtNumToString( Cmd[2],0)
|
||||
|
||||
+25
-24
@@ -3,12 +3,12 @@
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
EgtEnableDebug( true)
|
||||
|
||||
PP_VER = '3.1e1'
|
||||
PP_NVER = '3.1.5.1'
|
||||
MIN_MACH_VER = '2.7d2'
|
||||
MACH_NAME = EgtGetCurrMachineName()
|
||||
PP_VER = '2.7g2_DEV1'
|
||||
PP_NVER = '2.7.7.2'
|
||||
MIN_MACH_VER = '2.7g1'
|
||||
MACH_NAME = string.match( EgtGetCurrMachineDir(), "[^\\]+$") -- si ricava il nome della macchina dal direttorio
|
||||
|
||||
-- Carico i dati globali
|
||||
local sMachDir = EgtGetCurrMachineDir()
|
||||
@@ -93,7 +93,7 @@ ParkTc1X1 = 800
|
||||
ParkZ1 = -525
|
||||
ParkC1 = -90
|
||||
ParkB1 = -90
|
||||
ParkCSawX1 = 2500
|
||||
ParkCSawX1 = 1700
|
||||
ParkCSawZ1 = -100
|
||||
ParkCSaw0Z1 = -400
|
||||
ParkCSawC1 = -90
|
||||
@@ -129,9 +129,9 @@ ParkX3 = 0
|
||||
ParkZ3 = -200
|
||||
ParkC3 = -90
|
||||
ParkB3 = -75
|
||||
SafeX3RotAxis = 1600
|
||||
SafeX3RotAxis = 1550
|
||||
SafeZ3RotAxis = -655
|
||||
MinX2 = -3060
|
||||
MinX2 = -3800
|
||||
MaxX2 = 0
|
||||
MinZ2 = 0
|
||||
MaxZ2 = 1450
|
||||
@@ -142,7 +142,7 @@ MaxB2 = 127
|
||||
MinB2b = -119
|
||||
MaxB2b = 119
|
||||
ParkX2 = -100
|
||||
SafeX2 = -400
|
||||
SafeX2 = -200
|
||||
SafeX2RotAxis = -1000
|
||||
ParkZ2 = 0
|
||||
ParkInLavZ2 = 200
|
||||
@@ -174,6 +174,7 @@ Head2Y = DeltaTabY - Delta2TabY
|
||||
Head2Z = DeltaTabZ - Delta2TabZ
|
||||
DefTcPos1 = 'T1'
|
||||
DefTcPos2 = 'T220'
|
||||
CoeffVM = 0.5
|
||||
MinForzaPinze = 400 -- [Kgf]
|
||||
MaxForzaPinze = 1000 -- [Kgf]
|
||||
Tc2Active = true
|
||||
@@ -187,10 +188,6 @@ EmitAccClamps = true
|
||||
WriteAllCoordsOnFirstM101 = true
|
||||
ForceToCloseRollersGate = false
|
||||
Motors23KW = true
|
||||
EstimationRapidMultiplier = 1
|
||||
DistZClampToTable = 5 -- distanza tra la tavola e il punto più basso della morsa
|
||||
ClampingCoeffMin = nil
|
||||
|
||||
|
||||
-- Aggiornamento con dati da TechnoEssetre7
|
||||
local sTs3Data = EgtGetStringFromIni( 'Beam', 'DATA_DIR', "C:\\TechnoEssetre7\\EgtData", EgtGetIniFile()).."\\Essetre-PF1500MAXrl-3T.data"
|
||||
@@ -289,11 +286,9 @@ if EgtExistsFile( sDataBeam) then
|
||||
if Machine.Offsets.MAXFEEDPINZE then MaxFeedPinze = Machine.Offsets.MAXFEEDPINZE end
|
||||
if Machine.Offsets.MAXACC then MaxAcc = Machine.Offsets.MAXACC end
|
||||
if Machine.Offsets.MINACC then MinAcc = Machine.Offsets.MINACC end
|
||||
if Machine.Offsets.COEFF_STIMATEMPI and Machine.Offsets.COEFF_STIMATEMPI > 0 then EstimationRapidMultiplier = Machine.Offsets.COEFF_STIMATEMPI end
|
||||
if Machine.Offsets.CHIUDI_PINZE_2_3_SCAMBIO then ForceToCloseRollersGate = Machine.Offsets.CHIUDI_PINZE_2_3_SCAMBIO == 1 end
|
||||
if Machine.Offsets.WOOD_DENSITY then WoodDensity = Machine.Offsets.WOOD_DENSITY end
|
||||
if Machine.Offsets.MOTORS23KW then Motors23KW = Machine.Offsets.MOTORS23KW == 1 end
|
||||
if Machine.Offsets.COEFF_CLAMP_CHECK then ClampingCoeffMin = Machine.Offsets.COEFF_CLAMP_CHECK end
|
||||
|
||||
-- aggiustamenti
|
||||
MinY1 = MinV1 + MinDeltaYV
|
||||
@@ -332,7 +327,7 @@ EmtGeneral {
|
||||
ExitMaxAdjust = 300,
|
||||
ExitMaxRotAdj = 0.5,
|
||||
AngDeltaMinForHome = 80,
|
||||
LinkAxesMoveOrder = MCH_LKAMO.HEAD_BEFORE_IF_SAME_ANG,
|
||||
NewLinkMgr = 1,
|
||||
Special = 'Common_PF1250.mlse',
|
||||
Processor = 'Common_PF1250.mlpe'}
|
||||
-- in base alla corsa macchina, si carica la rulliera di carico/scarico appropriata
|
||||
@@ -679,7 +674,7 @@ local PY1Id = EmtAxis {
|
||||
Stroke = {0, MaxHoOpen},
|
||||
Home = MaxHoOpen,
|
||||
Geo = 'PY1_AXIS/GEO',
|
||||
Aux = {'PY1_AXIS/SOLID', 'PY1_AXIS/CLAMP_CHECK'}}
|
||||
Aux = 'PY1_AXIS/SOLID'}
|
||||
local Y2Id = EmtAxis {
|
||||
Name = 'Y2',
|
||||
Parent = 'Base',
|
||||
@@ -699,7 +694,7 @@ local PY2Id = EmtAxis {
|
||||
Stroke = {0, MaxHoOpen},
|
||||
Home = MaxHoOpen,
|
||||
Geo = 'PY2_AXIS/GEO',
|
||||
Aux = {'PY2_AXIS/SOLID', 'PY2_AXIS/CLAMP_CHECK'}}
|
||||
Aux = 'PY2_AXIS/SOLID'}
|
||||
-- Rulli
|
||||
local V1Id = EmtAxis {
|
||||
Name = 'V1',
|
||||
@@ -1108,10 +1103,8 @@ local vtMove = Vector3d( 0, ( DeltaTabY - 2065.5), ( DeltaTabZ + 1321.0))
|
||||
EgtMove( EgtGetFirstNameInGroup( BaseId, 'CONVOYER'..sGeomConvoyer), vtMove, GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( Y1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( PY1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( PY1Id, 'CLAMP_CHECK'), vtMove + Vector3d(0,0,DistZClampToTable), GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( Y2Id, 'SOLID'), vtMove, GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( PY2Id, 'SOLID'), vtMove, GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( PY2Id, 'CLAMP_CHECK'), vtMove + Vector3d(0,0,DistZClampToTable), GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( V1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( V1Id, 'COLLISION'), vtMove, GDB_RT.GLOB)
|
||||
EgtMove( EgtGetFirstNameInGroup( PV1Id, 'SOLID'), vtMove, GDB_RT.GLOB)
|
||||
@@ -1138,7 +1131,7 @@ function OnSetHead()
|
||||
if EMC.HEAD == 'H11' then
|
||||
local nTc = GetTcForTopHeadTool( EMC.TCPOS)
|
||||
if nTc ~= 2 then
|
||||
EmtModifyAxisHome( 'X1', ParkX1)
|
||||
EmtModifyAxisHome( 'X1', ParkTc1X1)
|
||||
else
|
||||
EmtModifyAxisHome( 'X1', ParkTc2X1)
|
||||
end
|
||||
@@ -1163,8 +1156,8 @@ function OnSetHead()
|
||||
-- se testa H12 (lama)
|
||||
elseif EMC.HEAD == 'H12' then
|
||||
EmtModifyAxisHome( 'X1', ParkX1)
|
||||
EmtModifyAxisHome( 'Z1', ParkZ1)
|
||||
EmtModifyAxisStroke( 'Z1', {MinZ1, MaxZ1Blade})
|
||||
EmtModifyAxisHome( 'Z1', MaxZ1Blade)
|
||||
EmtModifyAxisStroke( 'C1', {MinC1, MaxC1})
|
||||
EmtModifyAxisHome( 'C1', ParkC1)
|
||||
EmtModifyAxisHome( 'B1', ParkB1)
|
||||
@@ -1192,8 +1185,8 @@ function OnSetHead()
|
||||
-- recupero il valore dell'asse virtuale bloccato A
|
||||
local MultiDrillPosA = GetCurrMultiDrillVirtualAxis()
|
||||
EmtModifyAxisHome( 'X1', ParkMultiDrillX1)
|
||||
EmtModifyAxisHome( 'Z1', ParkMultiDrillZ1)
|
||||
EmtModifyAxisStroke( 'Z1', {MinZ1, MaxZ1})
|
||||
EmtModifyAxisHome( 'Z1', ParkMultiDrillZ1)
|
||||
EmtModifyAxisStroke( 'C1', {MinC1, MaxC1})
|
||||
EmtModifyAxisHome( 'C1', GetMultiDrillCHomeFromVirtualAxis( MultiDrillPosA, EMC.TOTLEN))
|
||||
EmtModifyAxisHome( 'B1', EgtIf( EMC.TOTLEN < MinLengthLongCSaw, ParkCSawB1, ParkLongCSawB1))
|
||||
@@ -1201,8 +1194,8 @@ function OnSetHead()
|
||||
-- se testa H16 ( seconda lama)
|
||||
elseif EMC.HEAD == 'H16' then
|
||||
EmtModifyAxisHome( 'X1', ParkTc2X1)
|
||||
EmtModifyAxisHome( 'Z1', ParkZ1)
|
||||
EmtModifyAxisStroke( 'Z1', {MinZ1, MaxZ1Blade})
|
||||
EmtModifyAxisHome( 'Z1', MaxZ1Blade)
|
||||
EmtModifyAxisStroke( 'C1', {MinC1, MaxC1})
|
||||
EmtModifyAxisHome( 'C1', ParkC1)
|
||||
EmtModifyAxisHome( 'B1', ParkB1)
|
||||
@@ -1213,6 +1206,14 @@ function OnSetHead()
|
||||
else
|
||||
EmtModifyAxisStroke( 'B2', {MinB2, MaxB2})
|
||||
end
|
||||
EmtModifyAxisHome( 'C2', ParkC2)
|
||||
EmtModifyAxisDirection( 'B2', X_AX())
|
||||
elseif EMC.HEAD == 'H22' then
|
||||
-- recupero valore asse A2 bloccato
|
||||
local sVal = EgtGetMachiningParam( MCH_MP.BLOCKEDAXIS) or 'A2=0'
|
||||
local SawUnderPosA2 = tonumber( sVal:sub( 4) or '') or 0
|
||||
EmtModifyAxisHome( 'C2', GetSawCHomeFromVirtualAxis( SawUnderPosA2))
|
||||
EmtModifyAxisDirection( 'B2', Vector3d( cos( SawUnderC2Offs), -sin( SawUnderC2Offs), 0))
|
||||
elseif EMC.HEAD == 'H38' then
|
||||
EmtModifyAxisDirection( 'B3', Vector3d( cos( SawC3Offs), -sin( SawC3Offs), 0))
|
||||
|
||||
|
||||
Binary file not shown.
@@ -20,7 +20,6 @@
|
||||
2=d,OpenMinSafe,0
|
||||
3=d,OpenOutRaw,0
|
||||
4=l,MaxOptSize,0
|
||||
5=b,AdjustFeed,1
|
||||
|
||||
[Mortising]
|
||||
0=d,MaxElev,0
|
||||
|
||||
Binary file not shown.
@@ -1,64 +1,5 @@
|
||||
==== Common_PF1250 Update Log ====
|
||||
|
||||
Versione 3.1e1 (12/05/2026)
|
||||
- (SIM-GEN) Corretta SIM (muoveva Y2 a MaxY2 senza aprire pinza) e GEN (non chiudeva rulliere e dava extracorsa e non generava P7=-85) di pezzi lunghi che necessitano lo scarico manuale. Ticket#2971
|
||||
|
||||
Versione 3.1c1
|
||||
- (SIM-GEN) Corretto calcolo rimanenza durante ParkRoller. Ticket#2832
|
||||
- (SIM) Corretto caricamento geometrie di collisioni. Modificato indice di collisione per una migliore gestione. ATT: MIN_MACH -> 3.1b2
|
||||
- (SIM-GEN) Aggiunta OnSpecialApplyMachining per calcolare i carrelli da subito
|
||||
- Aggiungendo OnSpecialApplyMachining, ora la OnSpecialGetPrevMachiningOffset lavora correttamente. Ticket#2798
|
||||
- (SIM-GEN) Solo se dY1DeltaMaxSP > WorkTab.dY1DeltaMinF lo prende in considerazione per il valore di WorkTab.dY1DeltaMaxF Ticket#2798
|
||||
|
||||
Versione 3.1b1 (17/02/2026)
|
||||
- (GEN) Generazione non allineata a simulazione. Ticket#2819
|
||||
|
||||
Versione 3.1a2 (30/01/2026)
|
||||
- (SIM) Allineato approccio simulazione a generazione in caso di lavorazione in doppio verticale. Ticket#2781
|
||||
- (GEN) Simulazione non allineata a generazione. Mancava reset flag di pezzo a caduta. Ticket#2798
|
||||
|
||||
Versione 3.1a1 (16/01/2026)
|
||||
- (SIM-GEN) Corretto movimento di approccio con sega a catena e allineati Simulazione e Generazione. Ticket#2771
|
||||
|
||||
Versione 2.7l1 (18/12/2025)
|
||||
- (SIM-GEN) Aggiunto controllo post movimenti ausiliari dell' EMC.PREVOFFSX nella funzione OnSpecialGetPrevMachiningOffset() come su ONE-PF. Ticket#2727
|
||||
- (SIM-GEN) Cambiato delta di correzione Z per lama con inclinazione >= 81° da 70 a 60 mm. Risoluzione Ticket#2210
|
||||
- (SIM-GEN) Divisione movimento B in approccio se > 90°.
|
||||
|
||||
Versione 2.7k5 (26/11/2025)
|
||||
- (SIM) Migliorata funzione CheckClamping, ora il controllo di warning si basa sulla somma delle lunghezze delle aree pinzate
|
||||
|
||||
Versione 2.7k4 (25/11/2025)
|
||||
- (SIM) Migliorata funzione CheckClamping, ora la sezione rientra di 3 mm
|
||||
|
||||
Versione 2.7k3 (21/11/2025)
|
||||
- (SIM-GEN) Corretto problema riposizionamento carrelli. Ticket#2704
|
||||
- (SIM) Aggiornata risoluzione VMillTol in funzione dello spessore lama
|
||||
|
||||
Versione 2.7k2 (19/11/2025)
|
||||
- (SIM-GEN) Con testa H38 si va in home quando testa viene comandata a Zmassima. Ticket#2703_b
|
||||
|
||||
Versione 2.7k1 (19/11/2025)
|
||||
- (GEN) Preselzione testa 1 spostata prima della selezione testa 3. Ticket#2513
|
||||
- (SIM-GEN) Corretto calcolo per decidere se serve aprire i rulli
|
||||
- (SIM) Aggiunto controllo Extra-Corsa testa 2 in caso di lavorazione in doppio. Ticket#2201
|
||||
- (SIM) Prima versione controllo pinzaggio su VMILL. Per attivarlo serve modifica della macchina a MLDE e NGE.
|
||||
- (GEN) Simulazione non allineata a generazione. Se testa H38 e si chiudono i rulli, si deve andare in home. Ticket#2703
|
||||
|
||||
Versione 2.7i1 (08/09/2025)
|
||||
- (GEN) Se fase start o restart, si aggiorna la posizione in X dell'asse per calcolare il link corretto. Serve CAM5 2.7h1 (facoltativo)
|
||||
- (EST) La stima tempi considera ora le accelerazoni degli assi
|
||||
- (SIM) Corretto controllo ultimo utensile utilizzato su testa 1, prima si controllava il precedente, ma poteva essere la testa 2
|
||||
- (SIM-GEN) Se testa 3 deve salire a ZMAX, sale alla X dove si trova e non torna in home
|
||||
|
||||
Versione 2.7h2 (21/08/2025)
|
||||
- (GEN) Se la testa rimane bassa, corretto caso di reset del piano generico a fine lavorazione
|
||||
- (GEN) Corretto movimento in Z massima dopo scarico pezzo
|
||||
|
||||
Versione 2.7h1 (20/08/2025)
|
||||
- (GEN) Per posizione T111 e T121, se non è presente asse rotante per presa aggregato (es. se si mette una fresa normale) viene settato a zero.
|
||||
- (MLDE-SIM) Aggiunta variabile FACOLTATIVA 'EstimationRapidMultiplier' in mlde per regolare il tempo stimato di rapido su macchine vecchie. Se non presente default 1.
|
||||
|
||||
Versione 2.7g1 (01/07/2025)
|
||||
- (GEN) Lettura parametri accelerazioni da TS3. Ticket#2052
|
||||
- (SIM-GEN) Aggiunta gestione massima lunghezza scarico
|
||||
|
||||
+2
-2
@@ -3,8 +3,8 @@
|
||||
|
||||
local InfoCommon_STD_PP = {
|
||||
NAME = 'Common_PF1250', -- nome script PP standard
|
||||
VERSION = '3.1e1', -- versione script
|
||||
MIN_MACH_VER_PP_COMMON = '3.1b2' -- versione minima kernel
|
||||
VERSION = '2.7g1', -- versione script
|
||||
MIN_MACH_VER_PP_COMMON = '2.5k1' -- versione minima kernel
|
||||
}
|
||||
|
||||
return InfoCommon_STD_PP
|
||||
|
||||
Reference in New Issue
Block a user