Modificati nomi variabili EMT/EMC.LB, HB, SB, LR...
This commit is contained in:
+51
-51
@@ -131,21 +131,21 @@ function OnDispositionEnd()
|
||||
-- reset recupero sovramateriale in X non più presente
|
||||
EMT.X_OFF = nil
|
||||
-- dati della barra
|
||||
local LBarra = EMT.LB
|
||||
local LBarra = EMT.LENGTHBEAM
|
||||
-- dati del pezzo
|
||||
local IdTrave = EMT.IT
|
||||
local LTrave = EMT.LT
|
||||
local HTrave = EMT.HT
|
||||
local STrave = EMT.ST
|
||||
local IdTrave = EMT.IDPART
|
||||
local LTrave = EMT.LENGTHPART
|
||||
local WTrave = EMT.WIDTHPART
|
||||
local HTrave = EMT.HEIGHTPART
|
||||
local HOverM = EMT.HOVM
|
||||
-- se carico barra
|
||||
if EMT.LOAD then
|
||||
-- assegnazione dati barra
|
||||
local sOut = ';Bar Dimensions'
|
||||
EmtOutput( sOut)
|
||||
sOut = 'C_WIDTH='..EmtLenToString( HTrave, 3)
|
||||
sOut = 'C_WIDTH='..EmtLenToString( WTrave, 3)
|
||||
EmtOutput( sOut)
|
||||
sOut = 'C_HEIGHT='..EmtLenToString( STrave, 3)
|
||||
sOut = 'C_HEIGHT='..EmtLenToString( HTrave, 3)
|
||||
EmtOutput( sOut)
|
||||
sOut = 'C_LENGTH='..EmtLenToString( LBarra, 3)
|
||||
EmtOutput( sOut)
|
||||
@@ -153,9 +153,9 @@ function OnDispositionEnd()
|
||||
elseif EMT.RELOAD then
|
||||
local sOut = ';Bar Dimensions'
|
||||
EmtOutput( sOut)
|
||||
sOut = 'C_WIDTH='..EmtLenToString( HTrave, 3)
|
||||
sOut = 'C_WIDTH='..EmtLenToString( WTrave, 3)
|
||||
EmtOutput( sOut)
|
||||
sOut = 'C_HEIGHT='..EmtLenToString( STrave, 3)
|
||||
sOut = 'C_HEIGHT='..EmtLenToString( HTrave, 3)
|
||||
EmtOutput( sOut)
|
||||
sOut = 'C_LENGTH='..EmtLenToString( LBarra, 3)
|
||||
EmtOutput( sOut)
|
||||
@@ -267,30 +267,30 @@ function OnRawMoveData()
|
||||
-- Se disposizione inizio o rimanenza
|
||||
if IsStartOrRestPhase( EMT.PHASE) then
|
||||
-- se primo grezzo, reset lunghezza barra
|
||||
if EMT.RAWIND == 1 then EMT.LB = 0 end
|
||||
if EMT.RAWIND == 1 then EMT.LENGTHBEAM = 0 end
|
||||
-- aggiungo la lunghezza del grezzo (solo se movimento in corner)
|
||||
if EMT.RAWTYPE == 1 then
|
||||
local b3Raw = EgtGetBBoxGlob( EgtGetFirstNameInGroup( EMT.RAWID, 'RawSolid'), GDB_BB.STANDARD)
|
||||
local LBarra = b3Raw:getDimX()
|
||||
EMT.LB = EMT.LB + LBarra
|
||||
EMT.LENGTHBEAM = EMT.LENGTHBEAM + LBarra
|
||||
end
|
||||
-- se primo grezzo, calcolo dati del pezzo
|
||||
if EMT.RAWIND == 1 then
|
||||
local PartId = EgtGetFirstPartInRawPart( EMT.RAWID)
|
||||
if PartId then
|
||||
EMT.IDT = PartId
|
||||
EMT.IT = EgtGetInfo( PartId, 'PDN', 'i') or 0
|
||||
EMT.IDPART = EgtGetInfo( PartId, 'PDN', 'i') or 0
|
||||
local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PartId, 'Box'), GDB_BB.STANDARD)
|
||||
EMT.LT = b3Part:getDimX()
|
||||
EMT.HT = b3Part:getDimY()
|
||||
EMT.ST = b3Part:getDimZ()
|
||||
EMT.LENGTHPART = b3Part:getDimX()
|
||||
EMT.WIDTHPART = b3Part:getDimY()
|
||||
EMT.HEIGHTPART = b3Part:getDimZ()
|
||||
EMT.HOVM = EgtGetInfo( EMT.RAWID, 'HOVM', 'd') or 0
|
||||
else
|
||||
EMT.IDT = GDB_ID.NULL
|
||||
EMT.IT = -1
|
||||
EMT.LT = 0
|
||||
EMT.HT = EMT.HT or 0
|
||||
EMT.ST = EMT.ST or 0
|
||||
EMT.IDPART = -1
|
||||
EMT.LENGTHPART = 0
|
||||
EMT.WIDTHPART = EMT.WIDTHPART or 0
|
||||
EMT.HEIGHTPART = EMT.HEIGHTPART or 0
|
||||
EMT.HOVM = 0
|
||||
end
|
||||
end
|
||||
@@ -672,11 +672,11 @@ function OnRapid()
|
||||
-- primo posizionamento carrello rispetto a 0M
|
||||
if EMT.X1DELTA then
|
||||
local dPosX1 = EMT.L1 + EMT.X1DELTA
|
||||
sOut = 'G1 X' .. EmtLenToString( dPosX1, 3) .. ' F' .. GetClampFeed( EMT.LB)
|
||||
sOut = 'G1 X' .. EmtLenToString( dPosX1, 3) .. ' F' .. GetClampFeed( EMT.LENGTHBEAM)
|
||||
EmtOutput( sOut)
|
||||
elseif EMT.X2DELTA then
|
||||
local dPosX2 = EMT.L1 + EMT.X2DELTA
|
||||
sOut = 'G1 X' .. EmtLenToString( dPosX2, 3) .. ' F' .. GetClampFeed( EMT.LB)
|
||||
sOut = 'G1 X' .. EmtLenToString( dPosX2, 3) .. ' F' .. GetClampFeed( EMT.LENGTHBEAM)
|
||||
EmtOutput( sOut)
|
||||
else
|
||||
EmtSetLastError( 1213, "Part to machine without charriots")
|
||||
@@ -930,7 +930,7 @@ function PrepareLoad( sCmd, bStart)
|
||||
local nFunz = 1
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 0
|
||||
local sRef1 = EmtLenToString( EMT.X1DELTA, 3)
|
||||
@@ -1016,7 +1016,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 11
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 0
|
||||
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
||||
@@ -1029,7 +1029,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 12
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 0
|
||||
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
||||
@@ -1042,7 +1042,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 12
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
||||
@@ -1055,7 +1055,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 32
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EgtIf( EMT.MCX2[1] == 0, EMT.L1opp + EMT.X2DLTP, EMT.MCX2[1]), 3)
|
||||
@@ -1065,12 +1065,12 @@ function PrepareMoveChar( sCmd)
|
||||
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
||||
table.insert( EMT.AUXSTR, sOut)
|
||||
elseif EMT.X1STAP ~= 0 and EMT.X2STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 1 then
|
||||
local sInfo = string.format( ';X1+X2->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
||||
local sInfo = string.format( ';X1+X2->X2 D2=%.1f', EMT.LENGTHBEAM - EMT.X2DELTA)
|
||||
table.insert( EMT.AUXSTR, sInfo)
|
||||
local nFunz = 21
|
||||
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 0
|
||||
local sRef1 = EmtLenToString( EMT.L1opp + EMT.X1DLTP, 3)
|
||||
@@ -1078,12 +1078,12 @@ function PrepareMoveChar( sCmd)
|
||||
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
||||
table.insert( EMT.AUXSTR, sOut)
|
||||
elseif EMT.X1STAP ~= 0 and EMT.X2STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND >= 3 then
|
||||
local sInfo = string.format( ';X1+X2->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
||||
local sInfo = string.format( ';X1+X2->X2 D2=%.1f', EMT.LENGTHBEAM - EMT.X2DELTA)
|
||||
table.insert( EMT.AUXSTR, sInfo)
|
||||
local nFunz = 34
|
||||
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = EgtIf( EMT.MCIND >= 4, 2, 1)
|
||||
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
||||
@@ -1095,12 +1095,12 @@ function PrepareMoveChar( sCmd)
|
||||
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,%s,%s)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4, sRef5, sRef6)
|
||||
table.insert( EMT.AUXSTR, sOut)
|
||||
elseif EMT.X1STAP ~= 0 and EMT.X2STAP == 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 1 then
|
||||
local sInfo = string.format( ';X1->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
||||
local sInfo = string.format( ';X1->X2 D2=%.1f', EMT.LENGTHBEAM - EMT.X2DELTA)
|
||||
table.insert( EMT.AUXSTR, sInfo)
|
||||
local nFunz = 31
|
||||
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EMT.L1opp + EMT.X1DLTP, 3)
|
||||
@@ -1110,12 +1110,12 @@ function PrepareMoveChar( sCmd)
|
||||
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
||||
table.insert( EMT.AUXSTR, sOut)
|
||||
elseif EMT.X1STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND == 2 then
|
||||
local sInfo = string.format( ';X1%s->X2 D2=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.LB - EMT.X2DELTA)
|
||||
local sInfo = string.format( ';X1%s->X2 D2=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.LENGTHBEAM - EMT.X2DELTA)
|
||||
table.insert( EMT.AUXSTR, sInfo)
|
||||
local nFunz = 31
|
||||
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EgtIf( EMT.MCX1[1] == 0, EMT.L1opp + EMT.X1DLTP, EMT.MCX1[1]), 3)
|
||||
@@ -1125,7 +1125,7 @@ function PrepareMoveChar( sCmd)
|
||||
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2, sRef3, sRef4)
|
||||
table.insert( EMT.AUXSTR, sOut)
|
||||
elseif EMT.X1STAP ~= 0 and not EMT.X1DELTA and EMT.X2DELTA and EMT.MCIND >= 3 then
|
||||
local sInfo = string.format( ';X1%s->X2 D2=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.LB - EMT.X2DELTA)
|
||||
local sInfo = string.format( ';X1%s->X2 D2=%.1f', EgtIf( EMT.X2STAP > 0, '+X2', ''), EMT.LENGTHBEAM - EMT.X2DELTA)
|
||||
table.insert( EMT.AUXSTR, sInfo)
|
||||
local sGet = 'GET(X1,X2)'
|
||||
table.insert( EMT.AUXSTR, sGet)
|
||||
@@ -1138,7 +1138,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 34
|
||||
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = EgtIf( EMT.MCIND >= 5, 2, 1)
|
||||
local sRef1 = EmtLenToString( EMT.MCX2[2], 3)
|
||||
@@ -1155,7 +1155,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 41
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EgtIf( EMT.MCX1[1] == 0, EMT.L1opp + EMT.X1DLTP, EMT.MCX1[1]), 3)
|
||||
@@ -1170,7 +1170,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 42
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
||||
@@ -1185,7 +1185,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 43
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = EgtIf( EMT.MCIND >= 4, 2, 1)
|
||||
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
||||
@@ -1202,7 +1202,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 33
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = EgtIf( EMT.MCIND >= 4, 2, 1)
|
||||
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
||||
@@ -1219,7 +1219,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 42
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0) + EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
||||
@@ -1242,7 +1242,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 33
|
||||
local nVertClamp = EgtIf( EMT.X1STAT == 2, 1, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EMT.MCX1[2], 3)
|
||||
@@ -1259,7 +1259,7 @@ function PrepareMoveChar( sCmd)
|
||||
local nFunz = 34
|
||||
local nVertClamp = EgtIf( EMT.X2STAT == 2, 2, 0)
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = 1
|
||||
local sRef1 = EmtLenToString( EMT.MCX2[1], 3)
|
||||
@@ -1337,11 +1337,11 @@ function PrepareResidue( sCmd)
|
||||
local nFunz = 6
|
||||
local nVertClamp = 0
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LT)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHPART)
|
||||
local dAcc = 4
|
||||
local nOpt = 0
|
||||
local sRef1 = EMT.MCX2[#EMT.MCX2]
|
||||
local sRef2 = EmtLenToString( ParkX2 - ( EMT.LB - EMT.X2DELTA), 3)
|
||||
local sRef2 = EmtLenToString( ParkX2 - ( EMT.LENGTHBEAM - EMT.X2DELTA), 3)
|
||||
local sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
||||
table.insert( EMT.AUXSTR, sOut)
|
||||
end
|
||||
@@ -1359,7 +1359,7 @@ function PrepareResidue( sCmd)
|
||||
EMT.X2DELTA = dX2Delta
|
||||
end
|
||||
if EMT.AUXIND > 1 then
|
||||
local sInfo = string.format( ';X1->X2 D2=%.1f', EMT.LB - EMT.X2DELTA)
|
||||
local sInfo = string.format( ';X1->X2 D2=%.1f', EMT.LENGTHBEAM - EMT.X2DELTA)
|
||||
table.insert( EMT.AUXSTR, sInfo)
|
||||
local sWait = 'WAIT_CHAN(2)'
|
||||
table.insert( EMT.AUXSTR, sWait)
|
||||
@@ -1368,7 +1368,7 @@ function PrepareResidue( sCmd)
|
||||
local nFunz = 31
|
||||
local nVertClamp = 0
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LB)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHBEAM)
|
||||
local dAcc = 4
|
||||
local nOpt = EgtIf( EMT.MCIND >= 3, 2, 1)
|
||||
local sRef1 = EmtLenToString( EMT.MCX1[1], 3)
|
||||
@@ -1442,11 +1442,11 @@ function PrepareUnload( sCmd)
|
||||
local nFunz = 6
|
||||
local nVertClamp = 0
|
||||
local dPress = 2.5
|
||||
local dFeed = GetClampFeed( EMT.LT)
|
||||
local dFeed = GetClampFeed( EMT.LENGTHPART)
|
||||
local dAcc = 4
|
||||
local nOpt = 0
|
||||
local sRef1 = Cmd[5]
|
||||
local sRef2 = EmtLenToString( ParkX2 - ( EMT.LT - EMT.X2DELTA), 3)
|
||||
local sRef2 = EmtLenToString( ParkX2 - ( EMT.LENGTHPART - EMT.X2DELTA), 3)
|
||||
sOut = string.format( '_POSIZ_T(%d,%d,%.1f,%.1f,%.1f,%d,%s,%s,,)', nFunz, nVertClamp, dPress, dFeed, dAcc, nOpt, sRef1, sRef2)
|
||||
table.insert( EMT.AUXSTR, sOut)
|
||||
sOut = '_N'..sStep..':STOPRE'
|
||||
@@ -1706,7 +1706,7 @@ function VerifyEmitRotation()
|
||||
-- determino quanto ruotare
|
||||
local nDeltaRot = nRot - nPrevRot
|
||||
-- se rotazione automatica richiesta e possibile
|
||||
if AutomaticRotation and EMT.LB >= AutoRotMinLen then
|
||||
if AutomaticRotation and EMT.LENGTHBEAM >= AutoRotMinLen then
|
||||
local sOut = 'M180 L0=' .. tostring( nDeltaRot)
|
||||
EmtOutput( sOut)
|
||||
else
|
||||
@@ -1755,7 +1755,7 @@ end
|
||||
---------------------------------------------------------------------
|
||||
function GetClampFeed( dLen)
|
||||
local KgMtCubo= 550 -- densità legno [Kg / metro cubo]
|
||||
local Massa = ( EMT.HT * EMT.ST * dLen * KgMtCubo ) / 1e9 -- massa [Kg]
|
||||
local Massa = ( EMT.HEIGHTPART * EMT.WIDTHPART * dLen * KgMtCubo ) / 1e9 -- massa [Kg]
|
||||
local RefMassa = 100 -- massa di riferimento con massima feed
|
||||
local dCoeff = EgtClamp( RefMassa / Massa, 0.1, 1)
|
||||
return EmtLenToString( dCoeff * EMT.FMAXPINZE, 0)
|
||||
|
||||
+1
-1
@@ -9,7 +9,7 @@
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
|
||||
PP_VER = '2.7l3'
|
||||
PP_VER = '2.7l3_DEV1'
|
||||
MIN_MACH_VER = '2.7l2'
|
||||
|
||||
EgtOutLog ( '** Saomad-KAIROS '..PP_VER..' (MinMach '.. MIN_MACH_VER ..') **', 1)
|
||||
|
||||
+21
-21
@@ -155,13 +155,13 @@ function OnSimulDispositionStart()
|
||||
-- Determino dimensioni del grezzo
|
||||
local nSolId = EgtGetFirstNameInGroup( EgtGetFirstRawPart() or GDB_ID.NULL, 'RawSolid') or GDB_ID.NULL
|
||||
local b3Sol = EgtGetBBoxGlob( nSolId, GDB_BB.STANDARD)
|
||||
EMT.LB = 0
|
||||
EMT.SB = 0
|
||||
EMT.HB = 0
|
||||
EMT.LENGTHBEAM = 0
|
||||
EMT.WIDTHBEAM = 0
|
||||
EMT.HEIGHTBEAM = 0
|
||||
if b3Sol then
|
||||
EMT.LB = b3Sol:getDimX()
|
||||
EMT.SB = b3Sol:getDimY()
|
||||
EMT.HB = b3Sol:getDimZ()
|
||||
EMT.LENGTHBEAM = b3Sol:getDimX()
|
||||
EMT.WIDTHBEAM = b3Sol:getDimY()
|
||||
EMT.HEIGHTBEAM = b3Sol:getDimZ()
|
||||
end
|
||||
-- Se vero inizio e abilitato creo gli Zmap
|
||||
EMT.VMILL = {}
|
||||
@@ -296,9 +296,9 @@ function OnSimulDispositionStart()
|
||||
else
|
||||
EMT.SCRAP = nil
|
||||
end
|
||||
EMT.LB = b3Bar:getDimX()
|
||||
EMT.LR = b3Raw:getDimX()
|
||||
EMT.LT = b3Part:getDimX()
|
||||
EMT.LENGTHBEAM = b3Bar:getDimX()
|
||||
EMT.LENGTHRAW = b3Raw:getDimX()
|
||||
EMT.LENGTHPART = b3Part:getDimX()
|
||||
-- recupero CutId del pezzo in lavorazione
|
||||
EMT.CUTID = EgtGetInfo( EgtGetFirstPartInRawPart( nPartRawId or GDB_ID.NULL) or GDB_ID.NULL, 'CUTID', 'i') or 0
|
||||
EMT.X1SPEC = nil
|
||||
@@ -376,7 +376,7 @@ function OnSimulDispositionStart()
|
||||
end
|
||||
nRawId = nNextRawId
|
||||
end
|
||||
EMT.LB = b3Bar:getDimX()
|
||||
EMT.LENGTHBEAM = b3Bar:getDimX()
|
||||
-- altrimenti fase finale, aggancio primo grezzo alla tavola e gli altri in posizione carico al carro Y
|
||||
else
|
||||
-- indice primo grezzo della fase
|
||||
@@ -407,7 +407,7 @@ function OnSimulDispositionStart()
|
||||
end
|
||||
nRawId = nNextRawId
|
||||
end
|
||||
EMT.LB = b3Bar:getDimX()
|
||||
EMT.LENGTHBEAM = b3Bar:getDimX()
|
||||
end
|
||||
-- Indicazione angolo rotazione pezzo
|
||||
EMT.ROT = EgtGetInfo( EMT.DISPID, 'ROT', 'i') or 0
|
||||
@@ -820,7 +820,7 @@ function ExecUnloading()
|
||||
-- li sposto per lasciare spazio al nuovo pezzo
|
||||
local nId = EgtGetFirstInGroup( nVmGrpId)
|
||||
while nId do
|
||||
EgtMove( nId, Vector3d( 0, -( EMT.SB + 50.0), 0), GDB_RT.GLOB)
|
||||
EgtMove( nId, Vector3d( 0, -( EMT.WIDTHBEAM + 50.0), 0), GDB_RT.GLOB)
|
||||
nId = EgtGetNext( nId)
|
||||
end
|
||||
-- creo un nuovo layer e vi inserisco il nuovo pezzo
|
||||
@@ -925,9 +925,9 @@ function CheckClamping( sClampName)
|
||||
|
||||
-- minima area considerata per un corretto pinzaggio
|
||||
DistZClampToTable = DistZClampToTable or 0
|
||||
--local MinJoin = BD.GetMinJoin( EMT.ST, EMT.HT, EgtIf( EMT.SPLIT, EMT.LT, EMT.LB))
|
||||
UpdateMinJoinDeltaTol( EMT.ST, EMT.HT, EgtIf( EMT.SPLIT, EMT.LT, EMT.LB))
|
||||
local MinZClamping = min( b3ClampingArea:getDimZ() + DistZClampToTable, EMT.HT) - DistZClampToTable
|
||||
--local MinJoin = BD.GetMinJoin( EMT.WIDTHPART, EMT.HEIGHTPART, EgtIf( EMT.SPLIT, EMT.LENGTHPART , EMT.LENGTHBEAM))
|
||||
UpdateMinJoinDeltaTol( EMT.WIDTHPART, EMT.HEIGHTPART, EgtIf( EMT.SPLIT, EMT.LENGTHPART , EMT.LENGTHBEAM))
|
||||
local MinZClamping = min( b3ClampingArea:getDimZ() + DistZClampToTable, EMT.HEIGHTPART) - DistZClampToTable
|
||||
local dMinClamping = ( MinJoin * MinZClamping)
|
||||
-- si moltiplica per un coefficiente minimo sotto al quale si da l'errore di pinzaggio
|
||||
ClampingCoeffMin = EgtClamp( ClampingCoeffMin, 0.01, 1)
|
||||
@@ -1005,15 +1005,15 @@ end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecMovePX1( Cmd)
|
||||
--SimulMoveAxes( 'PX1', EgtIf( not bClose, MaxHoOpen, EMT.HB), MCH_SIM_STEP.RAPID)
|
||||
--SimulMoveAxes( 'PX1', EgtIf( not bClose, MaxHoOpen, EMT.HEIGHTBEAM), MCH_SIM_STEP.RAPID)
|
||||
local dPX1 = MaxHOpen
|
||||
if Cmd[2] ~= '0' then
|
||||
dPX1 = EgtIf( EMT.ROT == -1, EMT.HB, EMT.SB)
|
||||
dPX1 = EgtIf( EMT.ROT == -1, EMT.HEIGHTBEAM, EMT.WIDTHBEAM)
|
||||
end
|
||||
SimulMoveAxis( 'PX1', dPX1, MCH_SIM_STEP.RAPID)
|
||||
local dQX1 = MaxVOpen
|
||||
if Cmd[2] == '2' then
|
||||
dQX1 = EgtIf( EMT.ROT == -1, EMT.SB, EMT.HB)
|
||||
dQX1 = EgtIf( EMT.ROT == -1, EMT.WIDTHBEAM, EMT.HEIGHTBEAM)
|
||||
end
|
||||
SimulMoveAxis( 'QX1', dQX1, MCH_SIM_STEP.RAPID)
|
||||
SetPX1Light( Cmd[2] ~= '0')
|
||||
@@ -1024,15 +1024,15 @@ end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecMovePX2( Cmd)
|
||||
--EgtIf( not bClose, MaxHoOpen, EMT.HB), MCH_SIM_STEP.RAPID)
|
||||
--EgtIf( not bClose, MaxHoOpen, EMT.HEIGHTBEAM), MCH_SIM_STEP.RAPID)
|
||||
local dPX2 = MaxHOpen
|
||||
if Cmd[2] ~= '0' then
|
||||
dPX2 = EgtIf( EMT.ROT == -1, EMT.HB, EMT.SB)
|
||||
dPX2 = EgtIf( EMT.ROT == -1, EMT.HEIGHTBEAM, EMT.WIDTHBEAM)
|
||||
end
|
||||
SimulMoveAxis( 'PX2', dPX2, MCH_SIM_STEP.RAPID)
|
||||
local dQX2 = MaxVOpen
|
||||
if Cmd[2] == '2' then
|
||||
dQX2 = EgtIf( EMT.ROT == -1, EMT.SB, EMT.HB)
|
||||
dQX2 = EgtIf( EMT.ROT == -1, EMT.WIDTHBEAM, EMT.HEIGHTBEAM)
|
||||
end
|
||||
SimulMoveAxis( 'QX2', dQX2, MCH_SIM_STEP.RAPID)
|
||||
SetPX2Light( Cmd[2] ~= '0')
|
||||
|
||||
+74
-74
@@ -249,7 +249,7 @@ function OnSpecialApplyDisposition()
|
||||
end
|
||||
nRawId = EgtGetNextRawPart( nRawId)
|
||||
end
|
||||
EMC.LB = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.LENGTHBEAM = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
-- Assegno sovramateriale di testa e ingombro tagli di testa e di coda
|
||||
EMC.HOVM = EgtGetInfo( nRawId, 'HOVM', 'd') or 0
|
||||
EMC.HCING = 0
|
||||
@@ -281,7 +281,7 @@ function OnSpecialApplyDisposition()
|
||||
end
|
||||
nRawId = EgtGetNextRawPart( nRawId)
|
||||
end
|
||||
EMC.LB = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.LENGTHBEAM = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.HOVM = EgtGetInfo( nRawId or GDB_ID.NULL, 'HOVM', 'd') or 0
|
||||
-- Eseguo scarico
|
||||
local vCmd = SpecCalcUnload()
|
||||
@@ -307,13 +307,13 @@ function OnSpecialApplyDisposition()
|
||||
EMC.ERR = 11
|
||||
return
|
||||
end
|
||||
EMC.LB = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.SB = b3Raw:getDimY()
|
||||
EMC.HB = b3Raw:getDimZ()
|
||||
EMC.LENGTHBEAM = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.WIDTHBEAM = b3Raw:getDimY()
|
||||
EMC.HEIGHTBEAM = b3Raw:getDimZ()
|
||||
EMC.ZMIN = b3Raw:getMin():getZ()
|
||||
|
||||
-- Aggiorno limiti di presa e tolleranza
|
||||
UpdateMinJoinDeltaTol( EMC.SB, EMC.HB, EMC.LB)
|
||||
UpdateMinJoinDeltaTol( EMC.WIDTHBEAM, EMC.HEIGHTBEAM, EMC.LENGTHBEAM)
|
||||
|
||||
-- Assegno sovramateriale di testa e ingombro tagli di testa e di coda
|
||||
-- Assegno sovramateriale di testa e ingombro tagli di testa e di coda
|
||||
@@ -341,7 +341,7 @@ function OnSpecialApplyDisposition()
|
||||
if EMC.PHASE == 1 or IsEnd2Phase( EMC.PHASE) then
|
||||
dPosT = LoadT
|
||||
if IsEnd2Phase( EMC.PHASE) then dPosT = dPosT + TurnerOffs end
|
||||
vCmd = SpecCalcLoad( dPosT, 0, min( EMC.LB - MinOther - AGG_LOAD, MaxX1 - dPosT))
|
||||
vCmd = SpecCalcLoad( dPosT, 0, min( EMC.LENGTHBEAM - MinOther - AGG_LOAD, MaxX1 - dPosT))
|
||||
-- se altrimenti fase successiva alla prima di tipo inizio o rimanenza
|
||||
elseif IsStartOrRestPhase( EMC.PHASE) then
|
||||
-- recupero posizione trave e quota di aggancio carrello
|
||||
@@ -360,7 +360,7 @@ function OnSpecialApplyDisposition()
|
||||
EMC.CNT = EgtGetInfo( nLastPathId, 'CNT', 'i')
|
||||
-- altrimenti è grezzo scaricato al carico e devo ricaricarlo
|
||||
else
|
||||
vCmd = SpecCalcLoad( dPosT, 0, min( EMC.LB - MinOther - AGG_LOAD, MaxX1 - dPosT))
|
||||
vCmd = SpecCalcLoad( dPosT, 0, min( EMC.LENGTHBEAM - MinOther - AGG_LOAD, MaxX1 - dPosT))
|
||||
end
|
||||
-- altrimenti fase successiva pari
|
||||
else
|
||||
@@ -372,8 +372,8 @@ function OnSpecialApplyDisposition()
|
||||
if IsStartOrRestPhase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE) then
|
||||
EMC.TPOS = dPosT
|
||||
SpecSetCarrPosFromCmds( vCmd)
|
||||
local CurrUnloadT = EgtIf( EMC.LB < MaxLenSmT, UnloadSmT, UnloadT)
|
||||
local dDistFront = EgtIf( EMC.LB < abs( MinX2 - CurrUnloadT), MinJoin, EMC.LB - abs( MinX2 - CurrUnloadT) + MinJoin + DeltaTol)
|
||||
local CurrUnloadT = EgtIf( EMC.LENGTHBEAM < MaxLenSmT, UnloadSmT, UnloadT)
|
||||
local dDistFront = EgtIf( EMC.LENGTHBEAM < abs( MinX2 - CurrUnloadT), MinJoin, EMC.LENGTHBEAM - abs( MinX2 - CurrUnloadT) + MinJoin + DeltaTol)
|
||||
vCmd2 = SpecCalcCarriages( dDistFront, 0)
|
||||
if vCmd and #vCmd > 1 and vCmd2 and #vCmd2 > 1 then
|
||||
table.insert( vCmd, { 0, 'CARR_MOVE'})
|
||||
@@ -583,15 +583,15 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload, bPreR
|
||||
EMC.ERR = 11
|
||||
return
|
||||
end
|
||||
EMC.LB = EgtIf( bSplit, b3Raw:getDimX(), b3Tot:getDimX()) + 10 * GEO.EPS_SMALL
|
||||
EMC.SB = b3Tot:getDimY()
|
||||
EMC.HB = b3Tot:getDimZ()
|
||||
EMC.LR = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.LENGTHBEAM = EgtIf( bSplit, b3Raw:getDimX(), b3Tot:getDimX()) + 10 * GEO.EPS_SMALL
|
||||
EMC.WIDTHBEAM = b3Tot:getDimY()
|
||||
EMC.HEIGHTBEAM = b3Tot:getDimZ()
|
||||
EMC.LENGTHRAW = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.YMIN = b3Raw:getMin():getY()
|
||||
EMC.ZMIN = b3Raw:getMin():getZ()
|
||||
|
||||
-- Aggiorno limiti di presa e tolleranza
|
||||
UpdateMinJoinDeltaTol( EMC.SB, EMC.HB, EMC.LB)
|
||||
UpdateMinJoinDeltaTol( EMC.WIDTHBEAM, EMC.HEIGHTBEAM, EMC.LENGTHBEAM)
|
||||
|
||||
-- Recupero sovramateriale di testa e ingombro tagli di testa e di coda dal pezzo
|
||||
EMC.HOVM = EgtGetInfo( nCurrRawId, 'HOVM', 'd') or 0
|
||||
@@ -706,7 +706,7 @@ function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload, bPreR
|
||||
|
||||
-- Se previsto scarico, lo eseguo
|
||||
if bUnload then
|
||||
EMC.LB = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
EMC.LENGTHBEAM = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
||||
local vCmdTmp = SpecCalcUnload()
|
||||
vCmd = EgtJoinTables( vCmd, vCmdTmp)
|
||||
end
|
||||
@@ -795,8 +795,8 @@ end
|
||||
---------------------------------------------------------------------
|
||||
function SpecialCalcPhaseEncumbrance( nPhase)
|
||||
-- Deve essere la fase finale di lavorazione di un pezzo (già staccato dal resto della trave)
|
||||
local dDistFront = EMC.LB
|
||||
local dDistBack = EMC.LB
|
||||
local dDistFront = EMC.LENGTHBEAM
|
||||
local dDistBack = EMC.LENGTHBEAM
|
||||
local dMaxLenLeft = 0
|
||||
-- Salvo lavorazione e utensile correnti, per ripristinarli alla fine
|
||||
local nOrigMchId = EgtGetCurrMachining()
|
||||
@@ -822,7 +822,7 @@ function SpecialCalcPhaseEncumbrance( nPhase)
|
||||
if dDistF and dDistB then
|
||||
dDistFront = min( dDistFront, dDistF)
|
||||
dDistBack = min( dDistBack, dDistB)
|
||||
local dMaxLenL = EMC.LR - dDistF
|
||||
local dMaxLenL = EMC.LENGTHRAW - dDistF
|
||||
EgtOutLog( ' MaxLenLeft = ' .. EgtNumToString( dMaxLenL, 1), 3)
|
||||
dMaxLenLeft = max( dMaxLenLeft, dMaxLenL)
|
||||
end
|
||||
@@ -856,10 +856,10 @@ function SpecCalcEncumbrance( vtTool, vtArm, vtAux, ptMin, ptMax, bSaw, bChain,
|
||||
local dCompZ = sqrt( 1 - vtTool:getZ() * vtTool:getZ())
|
||||
local dZup = ptMin:getZ() - 0.5 * dCompZ * dTDiam - ( EMC.ZMIN + 130)
|
||||
-- Posizione min e max del naso mandrino (rispetto a testa pezzo in X e riferimento pezzo in Y e Z)
|
||||
local ptHeadMin = ptMin + vtTool * dTLen - Vector3d( EMC.XMAX, EMC.YMIN + EMC.SB, EMC.ZMIN)
|
||||
local ptHeadMax = ptMax + vtTool * dTLen - Vector3d( EMC.XMAX, EMC.YMIN + EMC.SB, EMC.ZMIN)
|
||||
local ptHeadMin = ptMin + vtTool * dTLen - Vector3d( EMC.XMAX, EMC.YMIN + EMC.WIDTHBEAM, EMC.ZMIN)
|
||||
local ptHeadMax = ptMax + vtTool * dTLen - Vector3d( EMC.XMAX, EMC.YMIN + EMC.WIDTHBEAM, EMC.ZMIN)
|
||||
-- Ingombro a sinistra
|
||||
local dDistBack = EMC.LB + ptMin:getX() + LoadT
|
||||
local dDistBack = EMC.LENGTHBEAM + ptMin:getX() + LoadT
|
||||
local dHeadBack = 350
|
||||
if bSaw then
|
||||
if vtTool:getX() > 0 and abs( vtTool:getY()) < 0.088 and abs( vtTool:getZ()) < 0.088 then
|
||||
@@ -872,7 +872,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, vtAux, ptMin, ptMax, bSaw, bChain,
|
||||
else
|
||||
dHeadBack = EgtIf( vtTool:getX() > 0, 50, 90) + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
||||
end
|
||||
elseif ( vtTool:getX() > 0.7 and abs( vtTool:getY()) < 0.2 and ptMax:getZ() > EMC.ZMIN + 0.9 * EMC.HB) then
|
||||
elseif ( vtTool:getX() > 0.7 and abs( vtTool:getY()) < 0.2 and ptMax:getZ() > EMC.ZMIN + 0.9 * EMC.HEIGHTBEAM) then
|
||||
if vtTool:getZ() > 0 then
|
||||
dHeadBack = max( 50, 90 - 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()))
|
||||
else
|
||||
@@ -942,7 +942,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, vtAux, ptMin, ptMax, bSaw, bChain,
|
||||
end
|
||||
-- per fresa diretta quasi esattamente come X1+/- e con la testa non troppo nel pezzo
|
||||
if not bChain and abs( vtTool:getX()) < 0.017 and abs( vtTool:getZ()) < 0.017 and
|
||||
(( vtTool:getY() > 0 and ptHeadMin:getY() > 80) or ( vtTool:getY() < 0 and ptHeadMax:getY() < -EMC.SB - 80)) then
|
||||
(( vtTool:getY() > 0 and ptHeadMin:getY() > 80) or ( vtTool:getY() < 0 and ptHeadMax:getY() < -EMC.WIDTHBEAM - 80)) then
|
||||
dHeadBack = EgtIf( EMC.CNT == 1, 180, 130)
|
||||
end
|
||||
-- per limiti corsa asse X1
|
||||
@@ -966,7 +966,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, vtAux, ptMin, ptMax, bSaw, bChain,
|
||||
else
|
||||
dHeadFront = EgtIf( vtTool:getX() < 0, 50, 90) + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
||||
end
|
||||
elseif ( vtTool:getX() < - 0.7 and abs( vtTool:getY()) < 0.2 and ptMax:getZ() > EMC.ZMIN + 0.9 * EMC.HB) then
|
||||
elseif ( vtTool:getX() < - 0.7 and abs( vtTool:getY()) < 0.2 and ptMax:getZ() > EMC.ZMIN + 0.9 * EMC.HEIGHTBEAM) then
|
||||
if vtTool:getZ() > 0 then
|
||||
dHeadFront = max( 50, 90 - 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()))
|
||||
else
|
||||
@@ -1038,7 +1038,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, vtAux, ptMin, ptMax, bSaw, bChain,
|
||||
end
|
||||
-- per fresa diretta quasi esattamente come X1+/- e con la testa non troppo nel pezzo
|
||||
if not bChain and abs( vtTool:getX()) < 0.017 and abs( vtTool:getZ()) < 0.017 and
|
||||
(( vtTool:getY() > 0 and ptHeadMin:getY() > 80) or ( vtTool:getY() < 0 and ptHeadMax:getY() < -EMC.SB - 80)) then
|
||||
(( vtTool:getY() > 0 and ptHeadMin:getY() > 80) or ( vtTool:getY() < 0 and ptHeadMax:getY() < -EMC.WIDTHBEAM - 80)) then
|
||||
dHeadFront = 130
|
||||
end
|
||||
-- per limiti corsa asse X2
|
||||
@@ -1060,7 +1060,7 @@ end
|
||||
function VerifyPartLength()
|
||||
|
||||
-- Verifico lunghezza pezzo
|
||||
if EMC.LB < MinJoin + MinOther + AGG_LOAD + EMC.HCING + EMC.HOVM then
|
||||
if EMC.LENGTHBEAM < MinJoin + MinOther + AGG_LOAD + EMC.HCING + EMC.HOVM then
|
||||
EgtOutLog( ' Error CLAMP -> pezzo troppo corto')
|
||||
EMC.ERR = 17
|
||||
return false
|
||||
@@ -1073,18 +1073,18 @@ end
|
||||
function SpecCalcLoad( dPosT, dDistFront, dDistBack)
|
||||
--[L]
|
||||
local dMinDistBack= max( dDistBack, MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0))
|
||||
local dNewX1Delta = max( EMC.LB - dMinDistBack, MinOther + AGG_LOAD + EMC.HCING + EMC.HOVM)
|
||||
local dNewX1Delta = max( EMC.LENGTHBEAM - dMinDistBack, MinOther + AGG_LOAD + EMC.HCING + EMC.HOVM)
|
||||
local dNewX2Delta = nil
|
||||
local dNewY = dPosT + TurnerOffs + dNewX1Delta
|
||||
local vCmd = {}
|
||||
EgtOutLog( ' *[L]', 1)
|
||||
-- [L-1]
|
||||
if dNewY - MaxX1 > 0 then
|
||||
dNewX1Delta = min( EMC.LB - MinJoin + AGG_LOAD, MaxX1 - dPosT - TurnerOffs)
|
||||
dNewX1Delta = min( EMC.LENGTHBEAM - MinJoin + AGG_LOAD, MaxX1 - dPosT - TurnerOffs)
|
||||
EgtOutLog( ' *[L1]', 1)
|
||||
end --[L-2]
|
||||
if EMC.LB - dNewX1Delta < MinJoin then
|
||||
dNewX1Delta = min( EMC.LB - MinJoin + AGG_LOAD, MaxX1 - dPosT - TurnerOffs)
|
||||
if EMC.LENGTHBEAM - dNewX1Delta < MinJoin then
|
||||
dNewX1Delta = min( EMC.LENGTHBEAM - MinJoin + AGG_LOAD, MaxX1 - dPosT - TurnerOffs)
|
||||
EgtOutLog( ' *[L2]', 1)
|
||||
end
|
||||
-- Commento
|
||||
@@ -1097,7 +1097,7 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack)
|
||||
-- Sposto il carrello X1 per il carico
|
||||
table.insert( vCmd, { 2, 'X1', dPosT + dNewX1Delta, 'X2', ParkX2})
|
||||
-- Chiudo morsa X1
|
||||
table.insert( vCmd, { 11, EgtIf( EMC.LB - dNewX1Delta < LenToPress, 1, 2)})
|
||||
table.insert( vCmd, { 11, EgtIf( EMC.LENGTHBEAM - dNewX1Delta < LenToPress, 1, 2)})
|
||||
-- confermo i nuovi parametri di aggancio
|
||||
table.insert( vCmd, { 21, dNewX1Delta, 0})
|
||||
-- Inizializzo contatore globale
|
||||
@@ -1132,7 +1132,7 @@ local function AdjustPositionsForB( dNewX1Delta, dNewX2Delta, TCING, HCING, HOVM
|
||||
-- incremento se possibile la distanza tra le due posizioni
|
||||
if not bFixedDelta and ( dNewX1Delta - dNewX2Delta) < REF_DIST then
|
||||
local dEffAddDist = ( REF_DIST - ( dNewX1Delta - dNewX2Delta)) / 2
|
||||
dX1Delta = max( min( dEffAddDist, EMC.LB - dNewX1Delta - MinJoin - TCING), 0)
|
||||
dX1Delta = max( min( dEffAddDist, EMC.LENGTHBEAM - dNewX1Delta - MinJoin - TCING), 0)
|
||||
dX2Delta = max( min( dEffAddDist, dNewX2Delta - MinJoin - HOVM - HCING), 0)
|
||||
end
|
||||
return dX1Delta, dX2Delta
|
||||
@@ -1170,11 +1170,11 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
||||
local MinBackJoin = MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0)
|
||||
local MyMinOther = MinOther + EgtIf( EMC.CNT == 1, AGG_LOAD, 0)
|
||||
|
||||
local dDistFrontEff = min( dDistFront, EMC.LB - MyMinOther - EMC.TCING)
|
||||
local dDistFrontEff = min( dDistFront, EMC.LENGTHBEAM - MyMinOther - EMC.TCING)
|
||||
if bFixedDelta and IsMid2Phase( EMC.PHASE + 1) then
|
||||
dDistFrontEff = min( dDistFrontEff, EMC.LR - MinOther - EMC.TCING)
|
||||
dDistFrontEff = min( dDistFrontEff, EMC.LENGTHRAW - MinOther - EMC.TCING)
|
||||
end
|
||||
local dDistBackEff = min( dDistBack, EMC.LB - MyMinOther - EMC.HCING - EMC.HOVM)
|
||||
local dDistBackEff = min( dDistBack, EMC.LENGTHBEAM - MyMinOther - EMC.HCING - EMC.HOVM)
|
||||
|
||||
-- se primo scambio
|
||||
local MyMinX1 = EgtIf( EMC.CNT == 1, MinX1 + AGG_LOAD, MinX1)
|
||||
@@ -1200,9 +1200,9 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
||||
if not dX1Delta then
|
||||
dX1Delta = dX2Delta + ( MyMinX1 - MaxX2)
|
||||
end
|
||||
dNewX1Delta = EMC.LB - dDistBackEff
|
||||
dNewX1Delta = EMC.LENGTHBEAM - dDistBackEff
|
||||
-- verifico se posso lasciare la morsa in posizione
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LB - dNewX1Delta, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LENGTHBEAM - dNewX1Delta, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local bX1DeltaS = ( dNewX1Delta < dX1Delta - dX1DeltaTol or dNewX1Delta > dX1Delta + DELTA_SIC)
|
||||
if bX1DeltaS then
|
||||
dNewX1Delta = dNewX1Delta + dX1DeltaTol/2
|
||||
@@ -1222,13 +1222,13 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
||||
dX2Delta = dX1Delta - ( MyMinX1 - MaxX2)
|
||||
end
|
||||
|
||||
dNewX1Delta = EMC.LB - dDistBackEff
|
||||
dNewX1Delta = EMC.LENGTHBEAM - dDistBackEff
|
||||
dNewX2Delta = dDistFrontEff
|
||||
|
||||
-- incremento la distanza tra le due posizioni ( se abilitato e possibile)
|
||||
local dX1DeltaAgg, dX2DeltaAgg = AdjustPositionsForB( dNewX1Delta, dNewX2Delta, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta)
|
||||
-- tolleranze
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LB - dNewX1Delta - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LENGTHBEAM - dNewX1Delta - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX2DeltaTol = dX2DeltaAgg + GetDeltaTol( dNewX2Delta - dX2DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X2', bFixedDelta)
|
||||
-- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze
|
||||
local bX1DeltaS = ( dNewX1Delta < dX1Delta - dX1DeltaTol or dNewX1Delta > dX1Delta + DELTA_SIC)
|
||||
@@ -1388,7 +1388,7 @@ function SpecCalcUnload()
|
||||
local vAxes = EmtGetAxesPos( nLastEntId)
|
||||
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
||||
-- imposto quote aggancio per avere solo pinza X2
|
||||
local dDistFront = EMC.LB - MinOther - EMC.TCING - 10 * GEO.EPS_SMALL
|
||||
local dDistFront = EMC.LENGTHBEAM - MinOther - EMC.TCING - 10 * GEO.EPS_SMALL
|
||||
local dDistBack = 0
|
||||
-- effettuo scambio
|
||||
vCmdPre = SpecCalcCarriages( dDistFront, dDistBack)
|
||||
@@ -1401,7 +1401,7 @@ function SpecCalcUnload()
|
||||
end
|
||||
local vCmd = {}
|
||||
-- Tipo di scarico
|
||||
local bStdUl = ( MaxUnloadLen < 1 or EMC.LB - EMC.HOVM < MaxUnloadLen + 1)
|
||||
local bStdUl = ( MaxUnloadLen < 1 or EMC.LENGTHBEAM - EMC.HOVM < MaxUnloadLen + 1)
|
||||
-- Commento
|
||||
table.insert( vCmd, { 0, 'Unloading', EgtIf( bStdUl, 'Unloading', 'Manual Unloading')})
|
||||
-- risalita testa a Zmax
|
||||
@@ -1412,7 +1412,7 @@ function SpecCalcUnload()
|
||||
end
|
||||
-- Se non supero la lunghezza massima di scarico, sposto il pezzo in posizione di scarico
|
||||
if bStdUl then
|
||||
local dFinT = EgtIf( EMC.LB < MaxLenSmT, UnloadSmT, UnloadT) - EMC.LB
|
||||
local dFinT = EgtIf( EMC.LENGTHBEAM < MaxLenSmT, UnloadSmT, UnloadT) - EMC.LENGTHBEAM
|
||||
local dFinV = dFinT + EMC.X2DELTA
|
||||
table.insert( vCmd, { 2, 'T', dFinT, 'X2', dFinV})
|
||||
else
|
||||
@@ -1439,7 +1439,7 @@ function SpecCalcPreRot()
|
||||
if EMC.X2DELTA then
|
||||
-- imposto quote aggancio per avere solo pinza X1
|
||||
local dDistFront = 0
|
||||
local dDistBack = EMC.LB - MinOther - EMC.HOVM + 10 * GEO.EPS_SMALL
|
||||
local dDistBack = EMC.LENGTHBEAM - MinOther - EMC.HOVM + 10 * GEO.EPS_SMALL
|
||||
-- effettuo scambio
|
||||
vCmdPre = SpecCalcCarriages( dDistFront, dDistBack)
|
||||
-- recupero nuova posizione carrelli
|
||||
@@ -1476,7 +1476,7 @@ end
|
||||
local function CalcCharStatus( sType, dDelta)
|
||||
-- se per carrello X1
|
||||
if sType == 'X1' then
|
||||
return EgtIf( EMC.LB - dDelta < LenToPress, 1, 2)
|
||||
return EgtIf( EMC.LENGTHBEAM - dDelta < LenToPress, 1, 2)
|
||||
-- altrimenti per carrello X2
|
||||
else
|
||||
return EgtIf( dDelta < LenToPress, 1, 2)
|
||||
@@ -1587,7 +1587,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1Del
|
||||
end
|
||||
|
||||
-- se serve un grande spostamento e si sta pinzando poco. X1 trascinatore pinza poco e X2 si sposta per prima per recuperare
|
||||
if not BD.FASTCLAMPING and abs( dBeamMove) > 2000 and dDeltaBeam < 0 and EMC.LB - dX1DeltaI < max( 550, (MinJoin * 2)) then
|
||||
if not BD.FASTCLAMPING and abs( dBeamMove) > 2000 and dDeltaBeam < 0 and EMC.LENGTHBEAM - dX1DeltaI < max( 550, (MinJoin * 2)) then
|
||||
table.insert( vCmd, { 12, 0})
|
||||
dX2PosA = dX2PosI - dGainOnReclamping
|
||||
-- sposto il carrello X2 di 1000mm
|
||||
@@ -1665,7 +1665,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1Del
|
||||
-- * deve effettivamente spostarsi
|
||||
-- * non si arriva da gestione passo del pellegrino
|
||||
-- * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente
|
||||
elseif ( dX1DeltaF - dX2DeltaI) + 10 * GEO.EPS_SMALL >= MyMinX1 - MaxX2 and
|
||||
elseif ( dX1DeltaF - dX2DeltaI) + 10 * GEO.EPS_SMALL >= MyMinX1 - MaxX2 and
|
||||
( abs( dX1DeltaF - dX1DeltaI) > 10 * GEO.EPS_SMALL or not EMC.X1DELTA) and
|
||||
not EMC.PILGRIMSTEP and
|
||||
( dX1DeltaF - dX1DeltaI < MaxX1 - dX1PosI + MaxX2 - dX2PosI) then
|
||||
@@ -1924,7 +1924,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1Del
|
||||
-- trave si muove dallo scarico verso il carico. Obiettivo mandare X2 in posizione per prima
|
||||
else
|
||||
-- se serve un grande spostamento e si sta pinzando poco. X1 trascinatore pinza poco e X2 si sposta per prima per recuperare
|
||||
if not BD.FASTCLAMPING and abs( dDeltaBeam) > 2000 and EMC.LB - dX1DeltaI < max( 550, (MinJoin * 2)) then
|
||||
if not BD.FASTCLAMPING and abs( dDeltaBeam) > 2000 and EMC.LENGTHBEAM - dX1DeltaI < max( 550, (MinJoin * 2)) then
|
||||
table.insert( vCmd, { 12, 0})
|
||||
dX2PosA = dX2PosI - dGainOnReclamping
|
||||
-- sposto il carrello X2 di 1000mm
|
||||
@@ -2161,11 +2161,11 @@ function SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
||||
local MinBackJoin = MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0)
|
||||
local MyMinOther = MinOther + EgtIf( EMC.CNT == 1, AGG_LOAD, 0)
|
||||
|
||||
local dDistFrontEff = min( dDistFront, EMC.LB - MyMinOther - EMC.TCING)
|
||||
local dDistFrontEff = min( dDistFront, EMC.LENGTHBEAM - MyMinOther - EMC.TCING)
|
||||
if bFixedDelta and IsMid2Phase( EMC.PHASE + 1) then
|
||||
dDistFrontEff = min( dDistFrontEff, EMC.LR - MinOther - EMC.TCING)
|
||||
dDistFrontEff = min( dDistFrontEff, EMC.LENGTHRAW - MinOther - EMC.TCING)
|
||||
end
|
||||
local dDistBackEff = min( dDistBack, EMC.LB - MyMinOther - EMC.HCING - EMC.HOVM)
|
||||
local dDistBackEff = min( dDistBack, EMC.LENGTHBEAM - MyMinOther - EMC.HCING - EMC.HOVM)
|
||||
|
||||
EgtOutLog( ' Dist/Min : Back=' .. EgtNumToString( dDistBackEff, 1) .. '/' .. EgtNumToString( MinBackJoin, 1) ..
|
||||
' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1) ..
|
||||
@@ -2179,7 +2179,7 @@ function SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
||||
local dX2Delta = EMC.X2DELTA
|
||||
|
||||
local dNewPosT = nil
|
||||
local dNewX1Delta = EMC.LB - dDistBackEff
|
||||
local dNewX1Delta = EMC.LENGTHBEAM - dDistBackEff
|
||||
local dNewX2Delta = nil
|
||||
|
||||
return SpecAdjustCarriagesOLD( dPosT, dX1Delta, dX2Delta, dNewPosT, dNewX1Delta, dNewX2Delta, bFixedDelta, bFixedPos)
|
||||
@@ -2193,7 +2193,7 @@ function SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
||||
local dX2Delta = EMC.X2DELTA
|
||||
|
||||
local dNewPosT = nil
|
||||
local dNewX1Delta = EMC.LB - dDistBackEff
|
||||
local dNewX1Delta = EMC.LENGTHBEAM - dDistBackEff
|
||||
local dNewX2Delta = dDistFrontEff
|
||||
|
||||
return SpecAdjustCarriagesOLD( dPosT, dX1Delta, dX2Delta, dNewPosT, dNewX1Delta, dNewX2Delta, bFixedDelta, bFixedPos)
|
||||
@@ -2347,7 +2347,7 @@ local function PosxExtraYV( dX1PosA, dX2PosA, dTPosA, dMinX1, dMaxX2, sYV)
|
||||
end
|
||||
-- per aggancio del carrello X1
|
||||
if sYV == 'X1' then
|
||||
dTPos = max( dTPosA, dX1PosA + MinJoin + EMC.TCING - EMC.LB)
|
||||
dTPos = max( dTPosA, dX1PosA + MinJoin + EMC.TCING - EMC.LENGTHBEAM)
|
||||
dX2Pos = dX2PosA + ( dTPos - dTPosA)
|
||||
if dX2Pos > dMaxX2 then
|
||||
dX1Pos = dX1PosA - ( dX2Pos - dMaxX2)
|
||||
@@ -2439,10 +2439,10 @@ function SpecAdjustCarrA1( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
local dX2DeltaA = dX2PosA - dTPosA
|
||||
local dNewX1Delta -- = dX1DeltaF
|
||||
local dCorsaYfc = MaxX1 - dX1PosA
|
||||
local dCorsaYd = min( dCorsaYfc, EMC.LB - dX1DeltaI - MinJoin)
|
||||
local dCorsaYd = min( dCorsaYfc, EMC.LENGTHBEAM - dX1DeltaI - MinJoin)
|
||||
|
||||
-- tolleranza
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LB - dX1DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LENGTHBEAM - dX1DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local bX1DeltaS = ( dX1DeltaF < dX1DeltaA - dX1DeltaTol or dX1DeltaF > dX1DeltaA + DELTA_SIC)
|
||||
|
||||
if bX1DeltaS then
|
||||
@@ -2591,7 +2591,7 @@ function SpecAdjustCarrA2( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
local dX2DeltaA = dX2DeltaI
|
||||
local dNewX1Delta -- = dX1DeltaF
|
||||
-- tolleranze
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LB - dX1DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LENGTHBEAM - dX1DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local bX1DeltaS = ( dX1DeltaF < dX1DeltaA - dX1DeltaTol or dX1DeltaF > dX1DeltaA + DELTA_SIC)
|
||||
|
||||
if bX1DeltaS then
|
||||
@@ -2775,7 +2775,7 @@ function SpecAdjustCarrA3( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
local dX2DeltaA = dX2DeltaI
|
||||
local dNewX1Delta -- = dX2DeltaF
|
||||
-- tolleranza
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LB - dX1DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local dX1DeltaTol = GetDeltaTol( EMC.LENGTHBEAM - dX1DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1')
|
||||
local bX1DeltaS = ( dX1DeltaF < dX1DeltaA - dX1DeltaTol or dX1DeltaF > dX1DeltaA + DELTA_SIC)
|
||||
-- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze
|
||||
if bX1DeltaS then
|
||||
@@ -2969,7 +2969,7 @@ local function AdjustPositionsForB( dNewX1Delta, dNewX2Delta, TCING, HCING, HOVM
|
||||
-- incremento se possibile la distanza tra le due posizioni
|
||||
if not bFixedDelta and ( dNewX1Delta - dNewX2Delta) < REF_DIST then
|
||||
local dEffAddDist = ( REF_DIST - ( dNewX1Delta - dNewX2Delta)) / 2
|
||||
dX1Delta = max( min( dEffAddDist, EMC.LB - dNewX1Delta - MinJoin - TCING), 0)
|
||||
dX1Delta = max( min( dEffAddDist, EMC.LENGTHBEAM - dNewX1Delta - MinJoin - TCING), 0)
|
||||
dX2Delta = max( min( dEffAddDist, dNewX2Delta - MinJoin - HOVM - HCING), 0)
|
||||
end
|
||||
return dX1Delta, dX2Delta
|
||||
@@ -2999,7 +2999,7 @@ function SpecAdjustCarrB1( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- incremento la distanza tra le due posizioni ( se abilitato e possibile)
|
||||
local dX1DeltaAgg, dX2DeltaAgg = AdjustPositionsForB( dX1DeltaF, dX2DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta)
|
||||
-- tolleranze
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LB - dX1DeltaF - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LENGTHBEAM - dX1DeltaF - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX2DeltaTol = dX2DeltaAgg + GetDeltaTol( dX2DeltaF - dX2DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X2', bFixedDelta)
|
||||
-- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze
|
||||
local bX1DeltaS = ( dX1DeltaF < dX1DeltaA - dX1DeltaTol or dX1DeltaF > dX1DeltaA + DELTA_SIC)
|
||||
@@ -3039,7 +3039,7 @@ function SpecAdjustCarrB1( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- per allontanare q.p. X1 e (X2+T)
|
||||
dCorsaYfc = MaxX1 - dX1Pos
|
||||
dCorsaVfc = dX2Pos - MinX2
|
||||
dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- valuto le **corse di 'recupero'** dai due carrelli possibili riaccentrando (X1+T) e X2
|
||||
dCorsaYTr = dCorsaYd + (dX1Pos - MyMinX1)
|
||||
@@ -3092,7 +3092,7 @@ function SpecAdjustCarrB1( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- a partire da X1 e X2 c.s. per allontanare q.p. X1 e (X2+T)
|
||||
dCorsaYfc = MaxX1 - dX1PosA
|
||||
dCorsaVfc = dX2PosA - MinX2
|
||||
dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- aggiorno i prossimi recuperi disponibili
|
||||
dCorsaYTr = dCorsaYd
|
||||
@@ -3149,7 +3149,7 @@ function SpecAdjustCarrB1( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
if dX1DeltaDiff > 0 then
|
||||
dCorsaYfc = MaxX1 - dX1Pos1
|
||||
dCorsaVfc = dX2Pos1 - MinX2
|
||||
dDistBkN = EMC.LB - (dX1Pos1-dTPos1) - MinJoin - EMC.TCING -- DistBack1 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - (dX1Pos1-dTPos1) - MinJoin - EMC.TCING -- DistBack1 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
dX1PosA, dX2PosA, dTPosA = PosXs2Enl( dX1Pos1, dX2Pos1, dTPos1, dX1DeltaDiff, 0, dCorsaYd, dCorsaVTd, 'X2')
|
||||
else
|
||||
@@ -3290,7 +3290,7 @@ function SpecAdjustCarrB2( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- incremento la distanza tra le due posizioni ( se abilitato e possibile)
|
||||
local dX1DeltaAgg, dX2DeltaAgg = AdjustPositionsForB( dX1DeltaF, dX2DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta)
|
||||
-- tolleranze
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LB - dX1DeltaF - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LENGTHBEAM - dX1DeltaF - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX2DeltaTol = dX2DeltaAgg + GetDeltaTol( dX2DeltaF - dX2DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X2', bFixedDelta)
|
||||
-- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze
|
||||
local bX1DeltaS = ( dX1DeltaF < dX1DeltaA - dX1DeltaTol or dX1DeltaF > dX1DeltaA + DELTA_SIC)
|
||||
@@ -3335,7 +3335,7 @@ function SpecAdjustCarrB2( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- per allontanare X1 e (X2+T)
|
||||
dCorsaYfc = MaxX1 - dX1PosA
|
||||
dCorsaVfc = dX2PosA - MinX2
|
||||
dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- calcolo le corse di 'recupero' accentrando (X1+T) e X2 dopo l'allontanamento
|
||||
dCorsaYTr = dCorsaYd + (dX1PosA - MyMinX1)
|
||||
@@ -3378,7 +3378,7 @@ function SpecAdjustCarrB2( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- **aggiorno i recuperi disponibili** riallontanando X1 e (X2+T) e riaccentrando (X1+T) e X2
|
||||
dCorsaYfc = dCorsaY -- MaxX1 - dNewY
|
||||
dCorsaVfc = dCorsaV -- dNewV - MinX2
|
||||
dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
dCorsaYTr = dCorsaYd
|
||||
dCorsaVr = dCorsaVTd
|
||||
@@ -3425,7 +3425,7 @@ function SpecAdjustCarrB2( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
if dX1DeltaDiff > 0 then
|
||||
dCorsaYfc = MaxX1 - dX1Pos1
|
||||
dCorsaVfc = dX2Pos1 - MinX2
|
||||
dDistBkN = EMC.LB - (dX1Pos1-dTPos1) - MinJoin - EMC.TCING -- DistBack1 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - (dX1Pos1-dTPos1) - MinJoin - EMC.TCING -- DistBack1 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
--dX1PosA, dX2PosA, dTPosA = PosXs2Enl( dX1Pos1, dX2Pos1, dTPos1, dX1DeltaDiff, 0, dCorsaYd-dX1Displ1, dCorsaVTd+dX2Displ1, 'X2')
|
||||
dX1PosA, dX2PosA, dTPosA = PosXs2Enl( dX1Pos1, dX2Pos1, dTPos1, dX1DeltaDiff, 0, dCorsaYd, dCorsaVTd, 'X2')
|
||||
@@ -3737,7 +3737,7 @@ function SpecAdjustCarrB3( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- incremento la distanza tra le due posizioni ( se abilitato e possibile)
|
||||
local dX1DeltaAgg, dX2DeltaAgg = AdjustPositionsForB( dX1DeltaF, dX2DeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta)
|
||||
-- tolleranze
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LB - dX1DeltaF - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX1DeltaTol = dX1DeltaAgg + GetDeltaTol( EMC.LENGTHBEAM - dX1DeltaF - dX1DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X1', bFixedDelta)
|
||||
local dX2DeltaTol = dX2DeltaAgg + GetDeltaTol( dX2DeltaF - dX2DeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'X2', bFixedDelta)
|
||||
-- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze
|
||||
local bX1DeltaS = ( dX1DeltaF < dX1DeltaA - dX1DeltaTol or dX1DeltaF > dX1DeltaA + DELTA_SIC)
|
||||
@@ -4058,8 +4058,8 @@ function SpecAdjustCarrC1( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2
|
||||
-- calcolo le **corse disponibili dei carrelli a partire da X1 e X2 c.s.** per allontanare q.p. X1 e (X2+T)
|
||||
dCorsaYfc = MaxX1 - dX1Pos
|
||||
dCorsaVfc = dX2Pos - MinX2
|
||||
--local dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LB - (dX1Pos-dTPos) - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
--local dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - (dX1Pos-dTPos) - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando (X1+T) e X2
|
||||
dCorsaYTr = dCorsaYd + (dX1Pos -MyMinX1)
|
||||
@@ -4108,7 +4108,7 @@ function SpecAdjustCarrC1( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2
|
||||
-- a partire da X1 e X2 c.s. per allontanare q.p. X1 e (X2+T)
|
||||
dCorsaYfc = MaxX1 - dX1PosA
|
||||
dCorsaVfc = dX2PosA - MinX2
|
||||
dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- aggiorno i prossimi recuperi disponibili
|
||||
dCorsaYTr = dCorsaYd
|
||||
@@ -4265,7 +4265,7 @@ function SpecAdjustCarrC2( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- per allontanare X1 e (X2+T) q.p.
|
||||
dCorsaYfc = MaxX1 - dX1PosA
|
||||
dCorsaVfc = dX2PosA - MinX2
|
||||
dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando (X1+T) e X2
|
||||
dCorsaYTr = dCorsaYd + (dX1PosA - MyMinX1)
|
||||
@@ -4306,7 +4306,7 @@ function SpecAdjustCarrC2( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- **aggiorno la valutazione di ulteriori corse disponibili**
|
||||
dCorsaYfc = MaxX1 - dX1PosA
|
||||
dCorsaVfc = dX2PosA - MinX2
|
||||
dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- aggiorno i prossimi recuperi disponibili
|
||||
dCorsaYTr = dCorsaYd + (dX1PosA - MyMinX1)
|
||||
@@ -4457,7 +4457,7 @@ function SpecAdjustCarrC3( dTPosI, dX1DeltaI, dX2DeltaI, dTPosF, dX1DeltaF, dX2D
|
||||
-- calcolo le **corse disponibili dei carrelli a partire da X1 e X2 c.s.** per allontanare q.p. (X2+T) e X1
|
||||
local dCorsaYfc = MaxX1 - dX1Pos
|
||||
local dCorsaVfc = dX2Pos - MinX2
|
||||
local dDistBkN = EMC.LB - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
local dDistBkN = EMC.LENGTHBEAM - dX1DeltaA - MinJoin - EMC.TCING -- DistBack 'netta'
|
||||
local dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk')
|
||||
-- valuto **le corse di 'recupero'** dai due carrelli possibili riaccentrando (X1+T) e X2
|
||||
local dCorsaYTr = dCorsaYd + (dX1Pos - MyMinX1)
|
||||
|
||||
Reference in New Issue
Block a user