andrea.villa
1824 lines
71 KiB
Plaintext
1824 lines
71 KiB
Plaintext
-- Special Operations macchina Essetre-FAST by EgalWare s.r.l. 2024/03/28
|
|
|
|
-- Intestazioni
|
|
require( 'EmtGenerator')
|
|
EgtEnableDebug( false)
|
|
|
|
-- carico librerie
|
|
local BD = require( 'BeamData')
|
|
|
|
---------------------- OnSpecialMoveZup -----------------------------
|
|
---------------------------------------------------------------------
|
|
function OnSpecialMoveZup()
|
|
--EgtOutLog( 'OnSpecialMoveZup : ' .. EMC.HEAD .. '.' .. tostring( EMC.EXIT))
|
|
|
|
-- Inizializzazioni
|
|
EMC.ERR = 0
|
|
EMC.MODIF = false
|
|
|
|
-- se sega a catena
|
|
if EMC.HEAD == 'H3' then
|
|
|
|
end
|
|
|
|
end
|
|
|
|
---------- OnSpecialApplyDisposition & OnPostApplyMachining ---------
|
|
----------------------- Costanti ------------------------------------
|
|
local DELTA_TOL_V = 110
|
|
local DELTA_TOL_S = 210
|
|
local DELTA_TOL_L = 410
|
|
local DELTA_TOL_FIXED = 50
|
|
local DeltaTol = DELTA_TOL_S
|
|
local DELTA_SIC = 1
|
|
local AGG_LOAD = 50
|
|
local MIN_JOIN_VV = EgtClamp( MinJoinVV or 75, 60, 150)
|
|
local MIN_JOIN_SS = EgtClamp( MinJoinSS or 100, 80, 200)
|
|
local MIN_JOIN_LS = EgtClamp( MinJoinLS or 290, 250, 400)
|
|
local MIN_JOIN_SL = EgtClamp( MinJoinSL or 100, 80, 200)
|
|
local MIN_JOIN_LL = EgtClamp( MinJoinLL or 400, 300, 600)
|
|
local MinJoin = MIN_JOIN_SS
|
|
local MinOther = abs( MinY) + abs( MaxV) + MinJoin
|
|
|
|
----------------------- Variabili -----------------------------------
|
|
local Test = false
|
|
|
|
---------------------------------------------------------------------
|
|
local function PrepareClGroup( nParentId)
|
|
|
|
local nClId = EgtGetFirstNameInGroup( nParentId, 'CL')
|
|
-- se non c'è, lo aggiunge
|
|
if not nClId then
|
|
nClId = EgtGroup( EMC.DISPID)
|
|
if not nClId then
|
|
return nil
|
|
end
|
|
EgtSetName( nClId, 'CL')
|
|
-- altrimenti lo svuoto
|
|
else
|
|
EgtEmptyGroup( nClId)
|
|
end
|
|
|
|
return nClId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function IsStartOrRestPhase( nPhase)
|
|
local sVal = EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'TYPE')
|
|
return ( sVal == 'START' or sVal == 'REST')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function IsMidPhase( nPhase)
|
|
local sVal = EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'TYPE')
|
|
return ( sVal == 'MID')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function IsEndPhase( nPhase)
|
|
local sVal = EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'TYPE')
|
|
return ( sVal == 'END')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function IsMid2Phase( nPhase)
|
|
local sVal = EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'TYPE')
|
|
return ( sVal == 'MID2')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function IsEnd2Phase( nPhase)
|
|
local sVal = EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'TYPE')
|
|
return ( sVal == 'END2')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetNextStartOrRestPhase( nPhase)
|
|
local nNextPhase = nPhase + 1
|
|
while nNextPhase <= EgtGetPhaseCount() do
|
|
if IsStartOrRestPhase( nNextPhase) then
|
|
break ;
|
|
end
|
|
nNextPhase = nNextPhase + 1
|
|
end
|
|
return nNextPhase
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetPhaseRot( nPhase)
|
|
return ( EgtGetInfo( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL, 'ROT', 'i') or 0)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function IsLastOperationBeforeRotation( nOperId)
|
|
-- se ultima fase o ultima fase del pezzo, ritorno risultato negativo
|
|
if EMC.PHASE == EgtGetPhaseCount() or IsEndPhase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE) then
|
|
return false
|
|
end
|
|
-- recupero la successiva operazione attiva
|
|
local nNextOperId = EgtGetNextActiveOperation( nOperId)
|
|
-- se non esiste o non è una disposizione, ritorno risultato negativo
|
|
if not nNextOperId or EgtGetOperationType( nNextOperId) ~= MCH_OY.DISP then
|
|
return false
|
|
end
|
|
-- recupero le rotazioni della fase corrente e della prossima fase
|
|
local nRot = GetPhaseRot( EMC.PHASE)
|
|
local nNextRot = GetPhaseRot( EMC.PHASE + 1)
|
|
-- ritorno se sono diverse
|
|
return ( nRot ~= nNextRot)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function IsFirstMachiningAfterRotation( nMchId)
|
|
-- se prima fase o prima fase del pezzo, ritorno risultato negativo
|
|
if EMC.PHASE == 1 or IsStartOrRestPhase( EMC.PHASE) then
|
|
return false
|
|
end
|
|
-- recupero la precedente operazione attiva
|
|
local nPrevOperId = EgtGetPrevActiveOperation( nMchId)
|
|
-- se non esiste o non è una disposizione, ritorno risultato negativo
|
|
if not nPrevOperId or EgtGetOperationType( nPrevOperId) ~= MCH_OY.DISP then
|
|
return false
|
|
end
|
|
-- recupero le rotazioni della fase corrente e della fase precedente
|
|
local nRot = GetPhaseRot( EMC.PHASE)
|
|
local nPrevRot = GetPhaseRot( EMC.PHASE - 1)
|
|
-- ritorno se sono diverse
|
|
return ( nRot ~= nPrevRot)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function UpdateMinJoinDeltaTol()
|
|
local L_SMALL = 800
|
|
local H_V = 90
|
|
local H_S = 200
|
|
local H_L = 400
|
|
local W_V = 90
|
|
local W_S = 150
|
|
local W_L = 250
|
|
if EMC.SB <= W_V and EMC.HB <= H_V then
|
|
MinJoin = MIN_JOIN_VV
|
|
DeltaTol = DELTA_TOL_V
|
|
elseif EMC.LB <= L_SMALL then
|
|
MinJoin = MIN_JOIN_SS
|
|
DeltaTol = DELTA_TOL_S
|
|
else
|
|
local dMinJoinS
|
|
local dMinJoinL
|
|
if EMC.SB <= W_S then
|
|
dMinJoinS = MIN_JOIN_SS
|
|
dMinJoinL = MIN_JOIN_LS
|
|
elseif EMC.SB <= W_L then
|
|
local Coeff = ( EMC.SB - W_S) / ( W_L - W_S)
|
|
dMinJoinS = ( 1 - Coeff) * MIN_JOIN_SS + Coeff * MIN_JOIN_SL
|
|
dMinJoinL = ( 1 - Coeff) * MIN_JOIN_LS + Coeff * MIN_JOIN_LL
|
|
else
|
|
dMinJoinS = MIN_JOIN_SL
|
|
dMinJoinL = MIN_JOIN_LL
|
|
end
|
|
if EMC.HB <= H_S then
|
|
MinJoin = dMinJoinS
|
|
DeltaTol = DELTA_TOL_S
|
|
elseif EMC.HB <= H_L then
|
|
local Coeff = ( EMC.HB - H_S) / ( H_L - H_S)
|
|
MinJoin = ( 1 - Coeff) * dMinJoinS + Coeff * dMinJoinL
|
|
DeltaTol = ( 1 - Coeff) * DELTA_TOL_S + Coeff * DELTA_TOL_L
|
|
else
|
|
MinJoin = dMinJoinL
|
|
DeltaTol = DELTA_TOL_L
|
|
end
|
|
if EMC.SB < W_V then
|
|
DeltaTol = DELTA_TOL_V
|
|
end
|
|
end
|
|
MinOther = abs( MinY) + abs( MaxV) + MinJoin
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetCUTID()
|
|
-- recupero CUTID del pezzo in lavoro
|
|
local nOrd = GetPhaseOrd( EMC.PHASE)
|
|
local nPartRawId
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
local nRawOrd = EgtGetInfo( nRawId, 'ORD', 'i')
|
|
if nRawOrd == nOrd then
|
|
nPartRawId = nRawId
|
|
break
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
local CutID = EgtGetInfo( EgtGetFirstPartInRawPart( nPartRawId or GDB_ID.NULL) or GDB_ID.NULL, 'CUTID', 'i') or 0
|
|
return CutID
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function EnsureZmax( bZmaxOk, vCmd)
|
|
if not bZmaxOk then table.insert( vCmd, { 1, 'Z', EgtGetAxisHomePos( 'Z')}) end
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function EmitComment( vCmd, sOut)
|
|
EgtOutLog( ' ' .. sOut, 1)
|
|
if Test then
|
|
table.insert( vCmd, { 0, sOut})
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnSpecialApplyDisposition()
|
|
|
|
EgtOutLog( ' *** Fase : ' .. EgtNumToString( EMC.PHASE, 0) .. ' ***', 1)
|
|
|
|
-- Inizializzo codice di errore
|
|
EMC.ERR = 0
|
|
|
|
-- Campi obbligatori ma non usati
|
|
EMC.HEAD = ""
|
|
EMC.EXIT = 1
|
|
EMC.TCPOS = ""
|
|
EMC.SHIFTS = 0
|
|
EMC.SBH = false
|
|
|
|
-- Se disposizione da saltare non devo fare alcunché
|
|
if EgtExistsInfo( EMC.DISPID, 'SKIP') then return end
|
|
|
|
-- Assegno flag di pezzo separato dal resto del grezzo
|
|
local bSplit = IsEndPhase( EMC.PHASE) or IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE)
|
|
|
|
-- Recupero il tipo dell'operazione successiva
|
|
local nNextOpeType = EgtGetOperationType( EgtGetNextActiveOperation( EMC.DISPID) or GDB_ID.NULL)
|
|
|
|
-- Se ci sono lavorazioni successive non devo fare alcunché
|
|
if nNextOpeType ~= MCH_OY.NONE and nNextOpeType ~= MCH_OY.DISP then return end
|
|
|
|
-- Imposto gruppo e path di movimento
|
|
local nClId = PrepareClGroup( EMC.DISPID)
|
|
if not nClId then
|
|
EMC.ERR = 3
|
|
return
|
|
end
|
|
local nPathId = EgtGroup( nClId)
|
|
if not nPathId then
|
|
EMC.ERR = 6
|
|
return
|
|
end
|
|
EgtSetName( nPathId, 'Empty')
|
|
EMC.PATHID = nPathId
|
|
EMC.SHIFTS = -1
|
|
|
|
-- Se l'operazione successiva è una disposizione con rotazione, devo preparare il pezzo alla rotazione
|
|
if IsLastOperationBeforeRotation( EMC.DISPID) then
|
|
-- aggiornamento posizioni
|
|
if IsStartPhase( EMC.PHASE) then
|
|
-- carico le posizioni
|
|
local dPosT = EgtGetInfo( EMC.DISPID, 'TPOS', 'd')
|
|
local dPosY = EgtGetInfo( EMC.DISPID, 'YPOS', 'd')
|
|
EMC.TPOS = dPosT
|
|
EMC.YDELTA = dPosY - dPosT
|
|
EMC.VDELTA = nil
|
|
EMC.CNT = 1
|
|
else
|
|
local nPrevOpeId = EgtGetPrevActiveOperation( EMC.DISPID)
|
|
local nLastPathId = EgtGetLastInGroup( EgtGetFirstNameInGroup( nPrevOpeId, 'CL') or GDB_ID.NULL)
|
|
local nLastEntId = EgtGetLastInGroup( nLastPathId)
|
|
local vAxes = EmtGetAxesPos( nLastEntId)
|
|
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
|
EMC.YDELTA = EgtGetInfo( nLastPathId, 'YDELTA', 'd')
|
|
EMC.VDELTA = EgtGetInfo( nLastPathId, 'VDELTA', 'd')
|
|
EMC.CNT = EgtGetInfo( nLastPathId, 'CNT', 'i')
|
|
end
|
|
-- Determinazione delle dimensioni del grezzo in lavoro
|
|
local b3Raw = BBox3d()
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
if EgtVerifyRawPartPhase( nRawId, EMC.PHASE) then
|
|
b3Raw = EgtGetRawPartBBox( nRawId)
|
|
break
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
EMC.LB = 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
|
|
EMC.TCING = EgtGetInfo( nRawId, 'TCING', 'd') or 0
|
|
-- Eseguo preparazione alla rotazione
|
|
local vCmd = SpecCalcPreRot()
|
|
SpecOutputCmds( vCmd, true)
|
|
return
|
|
end
|
|
|
|
-- Se l'operazione successiva è ancora una disposizione, devo scaricare il pezzo
|
|
if nNextOpeType == MCH_OY.DISP and bSplit and not IsEnd2Phase( EMC.PHASE) then
|
|
-- aggiornamento posizioni
|
|
local nPrevOpeId = EgtGetPrevActiveOperation( EMC.DISPID)
|
|
local nLastPathId = EgtGetLastInGroup( EgtGetFirstNameInGroup( nPrevOpeId, 'CL') or GDB_ID.NULL)
|
|
local nLastEntId = EgtGetLastInGroup( nLastPathId)
|
|
local vAxes = EmtGetAxesPos( nLastEntId)
|
|
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
|
EMC.YDELTA = EgtGetInfo( nLastPathId, 'YDELTA', 'd')
|
|
EMC.VDELTA = EgtGetInfo( nLastPathId, 'VDELTA', 'd')
|
|
EMC.CNT = EgtGetInfo( nLastPathId, 'CNT', 'i')
|
|
-- Determinazione delle dimensioni del grezzo in lavoro
|
|
local b3Raw = BBox3d()
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
if EgtVerifyRawPartPhase( nRawId, EMC.PHASE) and not EgtVerifyRawPartPhase( nRawId, EMC.PHASE + 1) then
|
|
b3Raw = EgtGetRawPartBBox( nRawId)
|
|
break
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
EMC.LB = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
|
EMC.HOVM = EgtGetInfo( nRawId or GDB_ID.NULL, 'HOVM', 'd') or 0
|
|
-- Eseguo scarico
|
|
local vCmd = SpecCalcUnload()
|
|
SpecOutputCmds( vCmd, true)
|
|
return
|
|
end
|
|
|
|
-- Recupero il grezzo in lavoro
|
|
local nCurrRawId = GDB_ID.NULL
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
if EgtVerifyRawPartPhase( nRawId, EMC.PHASE) and not EgtVerifyRawPartPhase( nRawId, EMC.PHASE + 1) then
|
|
nCurrRawId = nRawId
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
|
|
-- Determinazione delle sue dimensioni
|
|
local b3Raw = EgtGetRawPartBBox( nCurrRawId)
|
|
if not b3Raw or b3Raw:isEmpty() then
|
|
EMC.ERR = 11
|
|
return
|
|
end
|
|
EMC.LB = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
|
EMC.SB = b3Raw:getDimY()
|
|
EMC.HB = b3Raw:getDimZ()
|
|
EMC.ZMIN = b3Raw:getMin():getZ()
|
|
|
|
-- Aggiorno limiti di presa e tolleranza
|
|
UpdateMinJoinDeltaTol()
|
|
|
|
-- Assegno sovramateriale di testa e ingombro tagli di testa e di coda
|
|
EMC.HOVM = EgtGetInfo( nCurrRawId, 'HOVM', 'd') or 0
|
|
EMC.HCING = EgtGetInfo( nCurrRawId, 'HCING', 'd') or 0
|
|
EMC.TCING = EgtGetInfo( nCurrRawId, 'TCING', 'd') or 0
|
|
|
|
-- Devo scaricare il pezzo o il grezzo rimasto
|
|
-- Posizione trave
|
|
local dPosT
|
|
|
|
-- Se fase 1 o dopo rotazione eseguo carico con carrello Y
|
|
local vCmd = {}
|
|
if EMC.PHASE == 1 or IsEnd2Phase( EMC.PHASE) then
|
|
dPosT = LoadT
|
|
if IsEnd2Phase( EMC.PHASE) then dPosT = dPosT + TurnerOffs - EMC.HOVM end
|
|
vCmd = SpecCalcLoad( dPosT, 0, min( EMC.LB - MinOther - AGG_LOAD - EMC.HOVM, MaxY - 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
|
|
dPosT = EgtGetInfo( EMC.DISPID, 'TPOS', 'd')
|
|
local dPosY = EgtGetInfo( EMC.DISPID, 'YPOS', 'd')
|
|
-- se carrello agganciato
|
|
if dPosY then
|
|
-- confermo i nuovi parametri di aggancio
|
|
table.insert( vCmd, { 21, dPosY - dPosT, 0})
|
|
-- recupero CNT
|
|
local nPrevOpeId = EgtGetPrevActiveOperation( EMC.DISPID)
|
|
if EgtGetOperationType( nPrevOpeId) == MCH_OY.DISP and EgtExistsInfo( nPrevOpeId, 'SKIP') then
|
|
nPrevOpeId = EgtGetPrevActiveOperation( nPrevOpeId)
|
|
end
|
|
local nLastPathId = EgtGetLastInGroup( EgtGetFirstNameInGroup( nPrevOpeId, 'CL') or GDB_ID.NULL)
|
|
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, MaxY - dPosT))
|
|
end
|
|
-- altrimenti fase successiva pari
|
|
else
|
|
local dPosV = EgtGetInfo( EMC.DISPID, 'VPOS', 'd')
|
|
EMC.VDELTA = dPosV
|
|
end
|
|
-- Se fase inizio o rimanenza, eseguo scambio per avere solo pinza V
|
|
local vCmd2 = {}
|
|
if IsStartOrRestPhase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE) then
|
|
EMC.TPOS = dPosT
|
|
SpecSetCarrPosFromCmds( vCmd)
|
|
local dDistFront = EgtIf( EMC.LB < abs( MinV - UnloadT), MinJoin, EMC.LB - abs( MinV - UnloadT) + MinJoin + DeltaTol) + EMC.HOVM
|
|
vCmd2 = SpecCalcCarriages( dDistFront, 0)
|
|
if vCmd and #vCmd > 1 and vCmd2 and #vCmd2 > 1 then
|
|
table.insert( vCmd, { 0, 'CARR_MOVE'})
|
|
end
|
|
end
|
|
-- eseguo scarico
|
|
SpecSetCarrPosFromCmds( vCmd2)
|
|
local vCmd3 = SpecCalcUnload()
|
|
-- unisco ed emetto i comandi
|
|
vCmd = EgtJoinTables( vCmd, vCmd2)
|
|
vCmd = EgtJoinTables( vCmd, vCmd3)
|
|
SpecOutputCmds( vCmd, true)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function OnPostApplyMachining()
|
|
|
|
EgtOutLog( ' Lavorazione : ' .. EgtGetName( EMC.MCHID), 1)
|
|
|
|
-- Inizializzo codice di errore
|
|
EMC.ERR = 0
|
|
|
|
-- Recupero la posizione della trave e dei carrelli al termine della precedente operazione
|
|
local nPrevOpeId = EgtGetPrevActiveOperation( EMC.MCHID)
|
|
-- se precedente operazione non esiste, errore
|
|
if not nPrevOpeId then
|
|
EMC.ERR = 1
|
|
return
|
|
-- se precedente operazione è disposizione
|
|
elseif EgtGetOperationType( nPrevOpeId) == MCH_OY.DISP then
|
|
if EMC.PHASE == 1 or IsFirstMachiningAfterRotation( EMC.MCHID) then
|
|
-- posizioni home
|
|
EMC.TPOS = nil
|
|
EMC.YDELTA = nil
|
|
EMC.VDELTA = nil
|
|
EMC.HCING_IGNORE = true
|
|
EMC.CNT = 1
|
|
elseif IsStartOrRestPhase( EMC.PHASE) then
|
|
-- carico le posizioni
|
|
local dPosT = EgtGetInfo( nPrevOpeId, 'TPOS', 'd')
|
|
local dPosY = EgtGetInfo( nPrevOpeId, 'YPOS', 'd')
|
|
-- se carrello agganciato
|
|
if dPosY then
|
|
EMC.TPOS = dPosT
|
|
EMC.YDELTA = dPosY - dPosT
|
|
EMC.VDELTA = nil
|
|
-- altrimenti è grezzo scaricato al carico e devo ricaricarlo
|
|
else
|
|
EMC.TPOS = nil
|
|
EMC.YDELTA = nil
|
|
EMC.VDELTA = nil
|
|
end
|
|
EMC.HCING_IGNORE = true
|
|
EMC.CNT = nil
|
|
else
|
|
-- aggiornamento posizioni (da lavorazione precedente a disposizione)
|
|
local nPrev2OpeId = EgtGetPrevActiveOperation( nPrevOpeId)
|
|
if not nPrev2OpeId then
|
|
EMC.ERR = 2
|
|
return
|
|
end
|
|
local nLastPathId = EgtGetLastInGroup( EgtGetFirstNameInGroup( nPrev2OpeId, 'CL') or GDB_ID.NULL)
|
|
local nLastEntId = EgtGetLastInGroup( nLastPathId)
|
|
local vAxes = EmtGetAxesPos( nLastEntId or GDB_ID.NULL)
|
|
if not vAxes then
|
|
EMC.ERR = 3
|
|
return
|
|
end
|
|
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
|
EMC.YDELTA = EgtGetInfo( nLastPathId, 'YDELTA', 'd')
|
|
EMC.VDELTA = EgtGetInfo( nLastPathId, 'VDELTA', 'd')
|
|
EMC.CNT = nil
|
|
end
|
|
-- altrimenti precedente operazione è lavorazione
|
|
else
|
|
-- aggiornamento posizioni
|
|
local nLastPathId = EgtGetLastInGroup( EgtGetFirstNameInGroup( nPrevOpeId, 'CL') or GDB_ID.NULL)
|
|
local nLastEntId = EgtGetLastInGroup( nLastPathId)
|
|
local vAxes = EmtGetAxesPos( nLastEntId or GDB_ID.NULL)
|
|
if not vAxes then
|
|
EMC.ERR = 4
|
|
return
|
|
end
|
|
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
|
EMC.YDELTA = EgtGetInfo( nLastPathId, 'YDELTA', 'd')
|
|
EMC.VDELTA = EgtGetInfo( nLastPathId, 'VDELTA', 'd')
|
|
EMC.CNT = EgtGetInfo( nLastPathId, 'CNT', 'i')
|
|
end
|
|
|
|
-- Verifico se ultima lavorazione della fase
|
|
local nNextOpeId = EgtGetNextActiveOperation( EMC.MCHID)
|
|
local bMchLast = ( not nNextOpeId or EgtGetOperationPhase( nNextOpeId) ~= EMC.PHASE)
|
|
|
|
-- Verifico se ultima lavorazione prima di una rotazione
|
|
local bPreRotMch = IsLastOperationBeforeRotation( EMC.MCHID)
|
|
|
|
-- Verifico flag di separazione e fase di scarico
|
|
local sNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
local bPreSplit = ( sNotes:find( 'Presplit') ~= nil)
|
|
local bSplitting = ( sNotes:find( 'Split') ~= nil)
|
|
local bPreCut = ( sNotes:find( 'Precut') ~= nil)
|
|
local bCutting = ( sNotes:find( 'Cut') ~= nil)
|
|
local bUnload = IsEndPhase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE)
|
|
if bPreSplit or bPreCut then
|
|
EgtSetInfo( EMC.MCHID, 'IS_PRE', '1')
|
|
else
|
|
EgtRemoveInfo( EMC.MCHID, 'IS_PRE')
|
|
end
|
|
|
|
-- Agisco sui diversi percorsi della lavorazione
|
|
local nPathId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( EMC.MCHID, 'CL') or GDB_ID.NULL)
|
|
while nPathId do
|
|
-- assegno id percorso da elaborare
|
|
EMC.PATHID = nPathId
|
|
-- 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
|
|
-- salvo lo stato di trave e carrelli
|
|
local OriTPos = EMC.TPOS
|
|
local OriYDelta = EMC.YDELTA
|
|
local OriVDelta = EMC.VDELTA
|
|
local OriCnt = EMC.CNT
|
|
-- eseguo le elaborazioni
|
|
SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bLast and bUnload, bLast and bPreRotMch)
|
|
-- se separazione, verifico il risultato
|
|
if bSplitting then
|
|
-- recupero CUTID del pezzo in lavoro
|
|
local CutID = GetCUTID()
|
|
-- in caso di errore mancato pinzaggio uscita riprovo dopo aver disabilitato le lavorazioni finali
|
|
if EMC.ERR == 18 then
|
|
-- segnalazione warning
|
|
EMC.ERR = -101
|
|
EMC.MSG = 'Warning : skipped final processes (WRN=101,CUTID='..tostring( CutID)..')'
|
|
-- ripristino lo stato originale di trave e carrelli
|
|
EMC.TPOS = OriTPos
|
|
EMC.YDELTA = OriYDelta
|
|
EMC.VDELTA = OriVDelta
|
|
EMC.CNT = OriCnt
|
|
-- eseguo le elaborazioni
|
|
SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bLast and bUnload, bLast and bPreRotMch)
|
|
-- pinzaggio ancora impossibile, pezzo a caduta
|
|
if EMC.ERR == 18 then
|
|
-- segnalazione warning
|
|
EMC.ERR = -102
|
|
EMC.MSG = 'Warning : skipped final processes and unload by fall (WRN=102,CUTID='..tostring( CutID)..')'
|
|
end
|
|
-- scarico standard
|
|
elseif EMC.ERR == 0 then
|
|
-- segnalazione warning
|
|
EMC.ERR = -100
|
|
EMC.MSG = 'Warning : standard unload (WRN=100,CUTID='..tostring( CutID)..')'
|
|
end
|
|
-- se taglio del residuo finale, scarico standard
|
|
elseif bCutting then
|
|
-- recupero CUTID del pezzo in lavoro
|
|
local CutID = GetCUTID()
|
|
-- se non ci sono errori, segnalazione warning
|
|
if EMC.ERR == 0 then
|
|
EMC.ERR = -100
|
|
EMC.MSG = 'Warning : standard unload (WRN=100,CUTID='..tostring( CutID)..')'
|
|
end
|
|
end
|
|
if EMC.ERR > 0 then return end
|
|
-- determino la posizione finale della trave
|
|
local nLastEntId = EgtGetLastInGroup( EMC.PATHID)
|
|
local vAxes = EmtGetAxesPos( nLastEntId)
|
|
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecApplyPath( bPreSplit, bSplitting, bPreCut, bCutting, bUnload, bPreRotMch)
|
|
|
|
-- Assegno flag di pezzo separato dal resto del grezzo
|
|
local bSplit = IsEndPhase( EMC.PHASE) or IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE)
|
|
|
|
-- Assegno flag di pezzo in separazione
|
|
local bFixedDelta = ( bPreSplit or bSplitting or bPreCut or bCutting)
|
|
|
|
-- Se separazione o taglio del grezzo finale, verifico se precedente era una preparazione
|
|
local bFixedPos = false
|
|
if bPreSplit or bSplitting or bPreCut or bCutting then
|
|
local nPrevOpeId = EgtGetPrevActiveOperation( EMC.MCHID)
|
|
bFixedPos = EgtExistsInfo( nPrevOpeId or GDB_ID.NULL, 'IS_PRE')
|
|
end
|
|
|
|
-- Determinazione delle dimensioni totali dei grezzi e del grezzo in lavoro
|
|
local b3Tot = BBox3d()
|
|
local b3Raw = BBox3d()
|
|
local nNextOddPhase = GetNextStartOrRestPhase( EMC.PHASE)
|
|
local nRawId = EgtGetFirstRawPart()
|
|
local nCurrRawId = GDB_ID.NULL
|
|
while nRawId do
|
|
if EgtVerifyRawPartPhase( nRawId, EMC.PHASE) then
|
|
local b3Tmp = EgtGetRawPartBBox( nRawId)
|
|
b3Tot:Add( b3Tmp)
|
|
if EgtGetPartInRawPartCount( nRawId) > 0 and not EgtVerifyRawPartPhase( nRawId, nNextOddPhase) then
|
|
b3Raw = b3Tmp
|
|
nCurrRawId = nRawId
|
|
end
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
if b3Tot:isEmpty() then
|
|
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.YMIN = b3Raw:getMin():getY()
|
|
EMC.ZMIN = b3Raw:getMin():getZ()
|
|
|
|
-- Aggiorno limiti di presa e tolleranza
|
|
UpdateMinJoinDeltaTol()
|
|
|
|
-- Recupero sovramateriale di testa e ingombro tagli di testa e di coda
|
|
EMC.HOVM = EgtGetInfo( nCurrRawId, 'HOVM', 'd') or 0
|
|
EMC.HCING = EgtGetInfo( nCurrRawId, 'HCING', 'd') or 0
|
|
EMC.TCING = EgtGetInfo( nCurrRawId, 'TCING', 'd') or 0
|
|
|
|
-- Calcolo dell'ingombro della lavorazione
|
|
local dDistFront, dDistBack = SpecialCalcMachiningEncumbrance( EMC.MCHID, bPreCut)
|
|
if not dDistFront or not dDistBack then return end
|
|
if bPreSplit or bSplitting then
|
|
local dDistF = SpecialCalcPhaseEncumbrance( EMC.PHASE + 1)
|
|
dDistFront = min( dDistFront, dDistF)
|
|
local dNextHOVM = EgtGetInfo( EgtGetNextRawPart( nCurrRawId) or GDB_ID.NULL, 'HOVM', 'd') or 0
|
|
local dBackOther = b3Tot:getDimX() - b3Raw:getDimX() - MinOther - dNextHOVM
|
|
EgtOutLog( 'DistBack='..EgtNumToString( dDistBack)..' OtherBack='..EgtNumToString( dBackOther), 3)
|
|
dDistBack = min( dDistBack, dBackOther)
|
|
elseif bPreCut or bCutting then
|
|
local dDistF = SpecialCalcPhaseEncumbrance( EMC.PHASE + 1)
|
|
dDistFront = min( dDistFront, dDistF)
|
|
dDistBack = 0.0
|
|
end
|
|
|
|
-- Verifico lunghezza pezzo
|
|
if not bSplit and not VerifyPartLength() then
|
|
return
|
|
end
|
|
|
|
-- Se inizio o appena dopo rotazione, eseguo il carico
|
|
if not EMC.TPOS then
|
|
local dPosT = LoadT
|
|
if IsFirstMachiningAfterRotation( EMC.MCHID) then dPosT = dPosT + TurnerOffs end
|
|
local vCmd = SpecCalcLoad( dPosT, dDistFront, max( dDistBack, MinJoin))
|
|
local vCmd2 = SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
|
if vCmd2 and #vCmd2 > 1 then
|
|
table.insert( vCmd, { 0, 'CARR_MOVE'})
|
|
end
|
|
EgtJoinTables( vCmd, vCmd2)
|
|
SpecOutputCmds( vCmd)
|
|
|
|
-- Se altrimenti carri entrambi diponibili, eseguo calcoli per carrelli
|
|
elseif not IsEndPhase( EMC.PHASE) then
|
|
local vCmd = SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
|
-- Se non ci sono spostamenti, confermo i parametri di aggancio
|
|
if SpecTestOnlyRemarkInCmds( vCmd) then
|
|
table.insert( vCmd, { 21, EgtIf( EMC.YDELTA, EMC.YDELTA, 0), EgtIf( EMC.VDELTA, EMC.VDELTA, 0)})
|
|
end
|
|
SpecOutputCmds( vCmd)
|
|
|
|
-- Altrimenti, non muovo i carrelli rispetto alla trave
|
|
else
|
|
local vCmd = {}
|
|
SpecOutputCmds( vCmd)
|
|
end
|
|
EMC.HCING_IGNORE = nil
|
|
|
|
-- Se taglio di separazione
|
|
local vCmd = {}
|
|
if bSplitting then
|
|
-- rimuovo eventuale vecchia info di Skip
|
|
local NextDispId = EgtGetPhaseDisposition( EMC.PHASE + 1) or GDB_ID.NULL
|
|
EgtRemoveInfo( NextDispId, 'SKIP')
|
|
-- verifico se separazione con caduta
|
|
if not EMC.VDELTA then
|
|
EgtOutLog( ' Warning SPLITTING -> separazione con caduta pezzo')
|
|
if IsEndPhase( EMC.PHASE + 1) then
|
|
EgtSetInfo( NextDispId, 'SKIP', '1')
|
|
local NextOpeId = EgtGetNextOperation( NextDispId)
|
|
while NextOpeId and EgtGetOperationPhase( NextOpeId) == EMC.PHASE + 1 do
|
|
EgtSetOperationMode( NextOpeId, false)
|
|
NextOpeId = EgtGetNextOperation( NextOpeId)
|
|
end
|
|
end
|
|
EMC.ERR = 18
|
|
-- verifico che la barra sia agganciata ad entrambi i carrelli
|
|
elseif not EMC.YDELTA or not EMC.VDELTA then
|
|
EMC.ERR = 19
|
|
EMC.MSG = ' Error SPLIT : Y or V not clamped'
|
|
return false
|
|
end
|
|
-- eseguo la separazione ( standard o di pezzo ruotato)
|
|
if not IsMid2Phase( EMC.PHASE + 1) then
|
|
vCmd = SpecCalcSplit( b3Raw:getDimX())
|
|
else
|
|
vCmd = SpecCalcSplitRot( b3Raw:getDimX())
|
|
end
|
|
end
|
|
-- Se taglio finale di grezzo a perdere
|
|
if bCutting then
|
|
-- salvo distanza carrello V da inizio grezzo rimasto nella disposizione della prossima fase
|
|
local NextDispId = EgtGetPhaseDisposition( EMC.PHASE + 1)
|
|
if NextDispId then
|
|
EgtSetInfo( NextDispId, 'VPOS', EMC.VDELTA)
|
|
end
|
|
end
|
|
|
|
-- Se previsto scarico, lo eseguo
|
|
if bUnload then
|
|
EMC.LB = b3Raw:getDimX() + 10 * GEO.EPS_SMALL
|
|
local vCmdTmp = SpecCalcUnload()
|
|
vCmd = EgtJoinTables( vCmd, vCmdTmp)
|
|
end
|
|
|
|
-- Se ritorno al carico per rotazione
|
|
if bPreRotMch then
|
|
-- determino posizione testa trave
|
|
local nLastEntId = EgtGetLastInGroup( EMC.PATHID)
|
|
local vAxes = EmtGetAxesPos( nLastEntId)
|
|
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
|
-- eseguo movimento prima di rotazione
|
|
local vCmdTmp = SpecCalcPreRot()
|
|
vCmd = EgtJoinTables( vCmd, vCmdTmp)
|
|
end
|
|
|
|
-- Emetto eventuali comandi di separazione e/o scarico
|
|
if #vCmd > 0 then
|
|
SpecOutputCmds( vCmd, true)
|
|
end
|
|
|
|
end --SpecApplyPath( bLast)
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecialCalcMachiningEncumbrance( nMchId, bPreCut)
|
|
-- gruppi della lavorazione
|
|
local nClId = EgtGetFirstNameInGroup( nMchId, 'CL')
|
|
local nPathId = EgtGetFirstInGroup( nClId or GDB_ID.NULL)
|
|
if not nPathId then
|
|
EMC.ERR = 12
|
|
return
|
|
end
|
|
-- recupero ptMin ptMax della lavorazione
|
|
local ptMin = EgtGetInfo( nClId, 'MMIN', 'p')
|
|
local ptMax = EgtGetInfo( nClId, 'MMAX', 'p')
|
|
if not ptMin or not ptMax then
|
|
EMC.ERR = 13
|
|
return
|
|
end
|
|
-- se pre-taglio, aggiorno ptMax con quello del taglio finale
|
|
if bPreCut then
|
|
local ptFinMax = GetFinalCutPmax( nMchId)
|
|
if ptFinMax then
|
|
ptMax = ptFinMax
|
|
end
|
|
end
|
|
-- Recupero del vettore estrusione (coincide con il vettore utensile)
|
|
local vtTool = EgtGetInfo( nPathId, 'EXTR', 'v')
|
|
if not vtTool then
|
|
EMC.ERR = 14
|
|
return
|
|
end
|
|
-- Recupero testa
|
|
local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
-- Calcolo del vettore ausiliario
|
|
local vAxes = EmtGetAxesPos( EgtGetFirstInGroup( nPathId))
|
|
if not vAxes or #vAxes < 5 or ( sHead == 'H3' and #vAxes < 6) then
|
|
EMC.ERR = 15
|
|
return
|
|
end
|
|
local vtAux = EgtGetCalcAuxDirFromAngles( vAxes[4], vAxes[5], vAxes[6])
|
|
if not vtAux then
|
|
EMC.ERR = 16
|
|
return
|
|
end
|
|
-- Recupero dei dati dell'utensile
|
|
local nToolType = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
|
|
local bSaw = ( nToolType == MCH_TY.SAW_STD or nToolType == MCH_TY.SAW_FLAT)
|
|
local bChain = ( nToolType == MCH_TY.MORTISE_STD)
|
|
local bAngTrasm = ( sHead == 'H5' or sHead == 'H6')
|
|
local dTLen = EgtTdbGetCurrToolParam( MCH_TP.LEN)
|
|
local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
|
local dThLen = EgtTdbGetCurrToolThLength()
|
|
-- Se sega a catena, devo correggere il versore Aux per farlo coincidere con la direzione del braccio C
|
|
if bChain then
|
|
if abs( vAxes[6] or 0) < 1 then
|
|
vtAux = vtTool
|
|
else
|
|
vtAux = vtTool ^ vtAux
|
|
end
|
|
end
|
|
-- Se rinvio da sotto, devo correggere il versore Aux per farlo coincidere con la direzione del braccio C
|
|
if bAngTrasm then
|
|
local nExit = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
|
|
vtAux = vtTool ^ vtAux
|
|
if nExit == 2 then vtAux = -vtAux end
|
|
end
|
|
-- Calcolo limiti derivanti dalla lavorazione
|
|
local dDistFront, dDistBack = SpecCalcEncumbrance( vtTool, vtAux, ptMin, ptMax, bSaw, bChain, dTLen, dTDiam, dThLen)
|
|
return dDistFront, dDistBack
|
|
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
|
|
-- Salvo lavorazione e utensile correnti, per ripristinarli alla fine
|
|
local nOrigMchId = EgtGetCurrMachining()
|
|
local sOrigTool = EgtTdbGetCurrToolParam( MCH_TP.NAME)
|
|
local sOrigHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
local nOrigExit = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
|
|
-- Ciclo sulle lavorazioni
|
|
local nMchId = EgtGetNextActiveOperation( EgtGetPhaseDisposition( nPhase) or GDB_ID.NULL)
|
|
while nMchId and EgtGetOperationPhase( nMchId) == nPhase do
|
|
-- imposto lavorazione e utensile correnti
|
|
EgtSetCurrMachining( nMchId)
|
|
local sTool = EgtGetMachiningParam( MCH_MP.TOOL)
|
|
if not EgtTdbSetCurrTool( sTool) then
|
|
local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID)
|
|
sTool = EgtTdbGetToolFromUUID( sTuuid)
|
|
EgtTdbSetCurrTool( sTool)
|
|
end
|
|
local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
|
local nExit = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
|
|
if sTool and sHead and nExit then EgtSetCalcTool( sTool, sHead, nExit) end
|
|
-- calcolo ingombri
|
|
local dDistF, dDistB = SpecialCalcMachiningEncumbrance( nMchId)
|
|
if dDistF and dDistB then
|
|
dDistFront = min( dDistFront, dDistF)
|
|
dDistBack = min( dDistBack, dDistB)
|
|
end
|
|
nMchId = EgtGetNextActiveOperation( nMchId)
|
|
end
|
|
-- Ripristino lavorazione e utensile correnti
|
|
if nOrigMchId then EgtSetCurrMachining( nOrigMchId) end
|
|
if sOrigTool then EgtTdbSetCurrTool( sOrigTool) end
|
|
if sOrigTool and sOrigHead and nOrigExit then EgtSetCalcTool( sOrigTool, sOrigHead, nOrigExit) end
|
|
-- Restituisco gli ingombri trovati
|
|
return dDistFront, dDistBack
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function GetFinalCutPmax( nMchId)
|
|
local nFinalCutId
|
|
local nId = EgtGetNextActiveOperation( nMchId)
|
|
while nId and EgtGetOperationPhase( nId) == EMC.PHASE do
|
|
nFinalCutId = nId
|
|
nId = EgtGetNextActiveOperation( nId)
|
|
end
|
|
if not nFinalCutId then return end
|
|
local nCLId = EgtGetFirstNameInGroup( nFinalCutId, 'CL')
|
|
if not nCLId then return end
|
|
return EgtGetInfo( nCLId, 'MMAX', 'p')
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecCalcEncumbrance( vtTool, vtArm, ptMin, ptMax, bSaw, bChain, dTLen, dTDiam, dThLen)
|
|
-- Quota in Z dal punto di inclinazione dei carrelli
|
|
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 riferimento pezzo in Y e Z)
|
|
local ptHeadMin = ptMin + vtTool * dTLen - Vector3d( 0, EMC.YMIN + EMC.SB, EMC.ZMIN)
|
|
local ptHeadMax = ptMax + vtTool * dTLen - Vector3d( 0, EMC.YMIN + EMC.SB, EMC.ZMIN)
|
|
-- Ingombro a sinistra
|
|
local dDistBack = EMC.LB + 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
|
|
dHeadBack = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
|
elseif abs( vtTool:getZ()) < 0.26 and abs( vtTool:getX()) < 0.35 then
|
|
dHeadBack = EgtIf( vtArm:getX() < 0, 540, 350)
|
|
elseif abs( vtTool:getZ()) < 0.26 and abs( vtTool:getX()) < 0.71 then
|
|
if vtArm:getX() < 0 then
|
|
dHeadBack = 450
|
|
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
|
|
if vtTool:getZ() > 0 then
|
|
dHeadBack = max( 50, 90 - 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()))
|
|
else
|
|
dHeadBack = max( 50, 40 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()))
|
|
end
|
|
if ptMax:getZ() < EMC.ZMIN + BD.VICE_MINH then
|
|
dHeadBack = dHeadBack + BD.VICE_MINH
|
|
end
|
|
elseif ( vtTool:getX() > 0.2 and abs( vtTool:getZ()) < 0.5) then
|
|
dHeadBack = max( 90, 40 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()))
|
|
elseif abs( vtTool:getZ()) < 0.93 then
|
|
if vtTool:getX() > 0 and abs( vtTool:getY()) < 0.2 and ptMax:getZ() > EMC.ZMIN + BD.VICE_MINH then
|
|
dHeadBack = 180
|
|
elseif vtTool:getX() > -0.06 then
|
|
dHeadBack = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
|
elseif vtTool:getX() > -0.3 then
|
|
dHeadBack = 250
|
|
elseif vtTool:getX() > -0.707 then
|
|
dHeadBack = 350
|
|
elseif vtTool:getX() > -0.8667 then
|
|
dHeadBack = 450
|
|
else
|
|
dHeadBack = 660
|
|
end
|
|
else
|
|
dHeadBack = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
|
end
|
|
else
|
|
if ( vtTool:getX() > -0.1 and vtArm:getX() > -0.1) or
|
|
( abs( vtTool:getX()) < 0.1 and abs( vtTool:getZ()) < 0.1) then
|
|
dHeadBack = EgtIf( EMC.CNT == 1, 180, 130)
|
|
elseif ( vtTool:getX() > -0.1 and vtArm:getX() > -0.95) then
|
|
dHeadBack = 180
|
|
elseif ( vtTool:getX() < -0.8) then
|
|
dHeadBack = 675
|
|
elseif ( vtTool:getX() < -0.75) then
|
|
dHeadBack = 650
|
|
elseif ( vtTool:getX() < -0.5) then
|
|
dHeadBack = 450
|
|
end
|
|
if vtTool:getX() < -0.25 then
|
|
dHeadBack = dHeadBack + max( dTLen - 130, 0) * abs( vtTool:getX())
|
|
elseif vtTool:getX() < 0 then
|
|
dHeadBack = dHeadBack + ( dTLen + 180) * abs( vtTool:getX())
|
|
end
|
|
if vtTool:getX() > 0.866 then
|
|
dHeadBack = 50
|
|
elseif vtTool:getX() >= 0 and dZup > 0 then
|
|
dHeadBack = max( EgtIf( EMC.CNT == 1, 180, 130), dHeadBack - dZup)
|
|
end
|
|
if abs( vtTool:getX()) < 0.5 and abs( vtTool:getZ()) > 0.259 and dZup < 0 then
|
|
if vtArm:getX() < -0.259 then
|
|
dHeadBack = 510
|
|
else
|
|
dHeadBack = EgtIf( vtTool:getZ() > 0.966, 160, 280)
|
|
end
|
|
end
|
|
-- per fresature longitudinali con utensile di fianco
|
|
if abs( vtTool:getX()) < 0.1 and vtTool:getZ() < 0.707 and vtArm:getX() < -0.5 then
|
|
dHeadBack = 500
|
|
end
|
|
-- per sega a catena di fianco
|
|
if bChain and vtTool:getX() < 0.5 and vtTool:getZ() < 0.5 and vtArm:getX() < -0.5 then
|
|
dHeadBack = max( dHeadBack, 510)
|
|
end
|
|
-- per fresa diretta quasi esattamente come Y+/- 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
|
|
dHeadBack = EgtIf( EMC.CNT == 1, 180, 130)
|
|
end
|
|
-- per interferenza con triangolo di rinforzo sulla pinza Y
|
|
if ( vtTool:getZ() < 0.25 and vtTool:getX() < 0.10 and vtTool:getY() > 0 and vtArm:getX() < -0.707 and not BD.RIGHT_LOAD) or
|
|
( vtTool:getZ() < 0.25 and vtTool:getX() < 0.10 and vtTool:getY() < 0 and vtArm:getX() < -0.707 and BD.RIGHT_LOAD)then
|
|
dHeadBack = dHeadBack + 90
|
|
end
|
|
end
|
|
-- Ingombro a destra
|
|
local dDistFront = - ptMax:getX() - LoadT
|
|
local dHeadFront = 350
|
|
if bSaw then
|
|
if vtTool:getX() < 0 and abs( vtTool:getY()) < 0.088 and abs( vtTool:getZ()) < 0.088 then
|
|
dHeadFront = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
|
elseif abs( vtTool:getZ()) < 0.26 and abs( vtTool:getX()) < 0.35 then
|
|
dHeadFront = EgtIf( vtArm:getX() > 0, 540, 350)
|
|
elseif abs( vtTool:getZ()) < 0.26 and abs( vtTool:getX()) < 0.71 then
|
|
if vtArm:getX() > 0 then
|
|
dHeadFront = 450
|
|
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
|
|
if vtTool:getZ() > 0 then
|
|
dHeadFront = max( 50, 90 - 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()))
|
|
else
|
|
dHeadFront = max( 50, 40 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()))
|
|
end
|
|
if ptMax:getZ() < EMC.ZMIN + BD.VICE_MINH then
|
|
dHeadFront = dHeadFront + BD.VICE_MINH
|
|
end
|
|
elseif ( vtTool:getX() < -0.2 and abs( vtTool:getZ()) < 0.5) then
|
|
dHeadFront = max( 90, 40 + 0.5 * dTDiam * sqrt( vtTool:getY() * vtTool:getY() + vtTool:getZ() * vtTool:getZ()))
|
|
elseif abs( vtTool:getZ()) < 0.93 then
|
|
if vtTool:getX() < 0 and abs( vtTool:getY()) < 0.2 and ptMax:getZ() > EMC.ZMIN + BD.VICE_MINH then
|
|
dHeadFront = 180
|
|
elseif vtTool:getX() < 0.06 then
|
|
dHeadFront = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
|
elseif vtTool:getX() < 0.3 then
|
|
dHeadFront = 250
|
|
elseif vtTool:getX() < 0.707 then
|
|
dHeadFront = 350
|
|
elseif vtTool:getX() < 0.8667 then
|
|
dHeadFront = 450
|
|
else
|
|
dHeadFront = 660
|
|
end
|
|
else
|
|
dHeadFront = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX())
|
|
end
|
|
else
|
|
if ( vtTool:getX() < -0.5 and vtArm:getX() < 0.1) then
|
|
dHeadFront = max( 50, dTDiam / 2 * abs( vtTool:getZ()) + 20)
|
|
elseif ( vtTool:getX() < 0.1 and vtArm:getX() < 0.1) or
|
|
( abs( vtTool:getX()) < 0.1 and abs( vtTool:getZ()) < 0.1) then
|
|
dHeadFront = 130
|
|
elseif ( vtTool:getX() < 0.1 and vtArm:getX() < 0.95) then
|
|
dHeadFront = 180
|
|
elseif ( vtTool:getX() > 0.8) then
|
|
dHeadFront = 675
|
|
elseif ( vtTool:getX() > 0.75) then
|
|
dHeadFront = 650
|
|
elseif ( vtTool:getX() > 0.5) then
|
|
dHeadFront = 450
|
|
end
|
|
if vtTool:getX() > 0.25 then
|
|
dHeadFront = dHeadFront + max( dTLen - 130, 0) * vtTool:getX()
|
|
elseif vtTool:getX() > 0 then
|
|
dHeadFront = dHeadFront + ( dTLen + 180) * vtTool:getX()
|
|
end
|
|
if vtTool:getX() < -0.866 then
|
|
dHeadFront = 50
|
|
elseif vtTool:getX() <= 0 and dZup > 0 then
|
|
dHeadFront = max( 130, dHeadFront - dZup)
|
|
end
|
|
if abs( vtTool:getX()) < 0.5 and abs( vtTool:getZ()) > 0.259 and dZup < 0 then
|
|
if vtArm:getX() > 0.259 then
|
|
dHeadFront = 510
|
|
else
|
|
dHeadFront = EgtIf( vtTool:getZ() > 0.966, 160, 280)
|
|
end
|
|
end
|
|
-- per fresature longitudinali con utensile di fianco
|
|
if abs( vtTool:getX()) < 0.1 and vtTool:getZ() < 0.707 and vtArm:getX() > 0.5 then
|
|
dHeadFront = 500
|
|
end
|
|
-- per sega a catena di fianco
|
|
if bChain and vtTool:getX() > -0.5 and vtTool:getZ() < 0.5 and vtArm:getX() > 0.5 then
|
|
dHeadFront = max( dHeadFront, 510)
|
|
end
|
|
-- per fresa diretta quasi esattamente come Y+/- 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
|
|
dHeadFront = 130
|
|
end
|
|
-- per forature di coda abbastanza lontane dai bordi pezzo in Y
|
|
if BD.ENABLE_TOOL_BETWEEN_VICES and not bChain and vtTool:getX() < -0.999 and ptHeadMax:getY() + dTDiam / 2 < -15 and ptHeadMin:getY() - dTDiam / 2 > -EMC.SB + 15 then
|
|
dHeadFront = - ( dTLen - dThLen - 15)
|
|
end
|
|
-- per interferenza con triangolo di rinforzo sulla pinza V
|
|
if ( vtTool:getZ() < 0.25 and vtTool:getX() > -0.10 and vtTool:getY() > 0 and vtArm:getX() > 0.707 and not BD.RIGHT_LOAD) or
|
|
( vtTool:getZ() < 0.25 and vtTool:getX() > -0.10 and vtTool:getY() < 0 and vtArm:getX() > 0.707 and BD.RIGHT_LOAD) then
|
|
dHeadFront = dHeadFront + 90
|
|
end
|
|
end
|
|
-- Stampe debug
|
|
EgtOutLog( ' Tdir=' .. tostring( vtTool) .. ' Adir=' .. tostring( vtArm) .. ' Zup=' .. EgtNumToString( dZup), 3)
|
|
EgtOutLog( ' DistFront=' .. EgtNumToString( dDistFront) .. ' DistBack=' .. EgtNumToString( dDistBack) ..
|
|
' HeadFront=' .. EgtNumToString( dHeadFront) .. ' HeadBack=' .. EgtNumToString( dHeadBack), 3)
|
|
-- Restituisco ingombri effettivi
|
|
return ( dDistFront - dHeadFront), ( dDistBack - dHeadBack)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function VerifyPartLength()
|
|
|
|
-- Verifico lunghezza pezzo
|
|
if EMC.LB < MinJoin + MinOther + AGG_LOAD + EMC.HCING + EMC.HOVM then
|
|
EgtOutLog( ' Error CLAMP -> pezzo troppo corto')
|
|
EMC.ERR = 17
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecCalcLoad( dPosT, dDistFront, dDistBack)
|
|
--[L]
|
|
local dMinDistBack= max( dDistBack, MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0))
|
|
local dNewYDelta = max( EMC.LB - dMinDistBack, MinOther + AGG_LOAD + EMC.HCING + EMC.HOVM)
|
|
local dNewVDelta = nil
|
|
local dNewY = dPosT + TurnerOffs + dNewYDelta
|
|
local vCmd = {}
|
|
EgtOutLog( ' *[L]', 1)
|
|
-- [L-1]
|
|
if dNewY - MaxY > 0 then
|
|
dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs)
|
|
EgtOutLog( ' *[L1]', 1)
|
|
end --[L-2]
|
|
if EMC.LB - dNewYDelta < MinJoin then
|
|
dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs)
|
|
EgtOutLog( ' *[L2]', 1)
|
|
end
|
|
-- Commento
|
|
table.insert( vCmd, { 0, 'Loading'})
|
|
-- risalita testa a Zmax
|
|
local bZmaxOk = EnsureZmax( bZmaxOk, vCmd)
|
|
-- Apro entrambe le morse
|
|
table.insert( vCmd, { 11, 0})
|
|
table.insert( vCmd, { 12, 0})
|
|
-- Sposto il carrello Y per il carico
|
|
table.insert( vCmd, { 2, 'Y', dPosT + dNewYDelta, 'V', ParkV})
|
|
-- Chiudo morsa Y
|
|
table.insert( vCmd, { 11, EgtIf( EMC.LB - dNewYDelta < LenToPress, 1, 2)})
|
|
-- confermo i nuovi parametri di aggancio
|
|
table.insert( vCmd, { 21, dNewYDelta, 0})
|
|
-- Inizializzo contatore globale
|
|
EMC.CNT = 1
|
|
SpecOutputCNT()
|
|
-- Assegno stato corrente
|
|
EMC.TPOS = dPosT
|
|
EMC.YDELTA = dNewYDelta
|
|
EMC.VDELTA = nil
|
|
-- Restituisco i comandi
|
|
return vCmd
|
|
end -- SpecAdjustLoad [L]
|
|
|
|
|
|
---------------------------------------------------------------------
|
|
function GetMachiningStartingPoint( idPath)
|
|
local idFirstObj = EgtGetFirstInGroup( idPath)
|
|
-- se esiste l'oggetto, recupero la coordinata del primo punto
|
|
if idFirstObj then
|
|
local vAxes = EmtGetAxesPos( idFirstObj)
|
|
if #vAxes > 0 then
|
|
return vAxes[1]
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos)
|
|
|
|
local MinFrontJoin = MinJoin + EMC.HCING + EMC.HOVM
|
|
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)
|
|
if bFixedDelta and IsMid2Phase( EMC.PHASE + 1) then
|
|
dDistFrontEff = min( dDistFrontEff, EMC.LR - MinOther - EMC.TCING)
|
|
end
|
|
local dDistBackEff = min( dDistBack, EMC.LB - MyMinOther - EMC.HCING - EMC.HOVM)
|
|
|
|
EgtOutLog( ' Dist/Min : Back=' .. EgtNumToString( dDistBackEff, 1) .. '/' .. EgtNumToString( MinBackJoin, 1) ..
|
|
' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1) ..
|
|
' Fixed : Delta=' .. EgtIf( bFixedDelta, 'T', 'F') .. ' Pos=' .. EgtIf( bFixedPos, 'T', 'F'), 3)
|
|
|
|
local dPosT = EMC.TPOS
|
|
local dYDelta = EMC.YDELTA
|
|
local dVDelta = EMC.VDELTA
|
|
local dNewPosT = GetMachiningStartingPoint( EMC.PATHID)
|
|
local dNewYDelta = nil
|
|
local dNewVDelta = nil
|
|
|
|
-- [A] se posso mettere solo carrello Y
|
|
if dDistFrontEff < MinFrontJoin and dDistBackEff > MinBackJoin - GEO.EPS_SMALL then
|
|
dNewYDelta = EMC.LB - dDistBackEff
|
|
dNewVDelta = nil
|
|
-- [B] se altrimenti posso mettere entrambi i carrelli Y e V
|
|
elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then
|
|
dNewYDelta = EMC.LB - dDistBackEff
|
|
dNewVDelta = dDistFrontEff
|
|
-- [C] se altrimenti posso mettere solo carrello V
|
|
elseif dDistBackEff < MinBackJoin and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then
|
|
dNewYDelta = nil
|
|
dNewVDelta = dDistFrontEff
|
|
-- altrimenti errore
|
|
else
|
|
if EgtGetDebugLevel() < 3 then
|
|
EgtOutLog( ' Dist/Min : Back=' .. EgtNumToString( dDistBackEff, 1) .. '/' .. EgtNumToString( MinBackJoin, 1) ..
|
|
' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1))
|
|
end
|
|
EgtOutLog( ' Error CLAMP impossible')
|
|
EMC.ERR = 18
|
|
return {}
|
|
end
|
|
|
|
-- salvo valori finali
|
|
EMC.YDELTANEXT = dNewYDelta
|
|
EMC.VDELTANEXT = dNewVDelta
|
|
|
|
local vCmd = {}
|
|
SpecAdjustCarriages( vCmd, dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos)
|
|
return vCmd
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecCalcSplit( dLenRaw)
|
|
local vCmd = {}
|
|
EgtOutLog( ' *[S]', 1)
|
|
table.insert( vCmd, { 0, EgtIf( EMC.VDELTA, 'Split', 'Fall')})
|
|
-- determino i grezzi da agganciare al carrello Y (sono quelli presenti nella fase successiva dispari)
|
|
local nNextOddPhase = GetNextStartOrRestPhase( EMC.PHASE)
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
if EgtVerifyRawPartPhase( nRawId, nNextOddPhase) then
|
|
table.insert( vCmd, { 31, nRawId, 'Y'})
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
-- riporto il carrello Y al carico con il resto della trave
|
|
local dLDelta = EMC.YDELTA - dLenRaw
|
|
table.insert( vCmd, { 1, 'Y', LoadT + dLDelta})
|
|
table.insert( vCmd, { 21, 0, EMC.VDELTA or 0})
|
|
-- imposto subito Y non più attaccato al trave in lavoro
|
|
EMC.YDELTA = nil
|
|
-- salvo posizione carrello Y in disposizione del pezzo dopo split
|
|
local PostDispId = EgtGetPhaseDisposition( EMC.PHASE + 1)
|
|
if PostDispId then
|
|
EgtSetInfo( PostDispId, 'YPOS', LoadT + dLDelta)
|
|
end
|
|
-- salvo posizione grezzo rimasto e posizione carrello Y nella disposizione iniziale del pezzo succ (prossima fase dispari)
|
|
local NextDispId = EgtGetPhaseDisposition( nNextOddPhase)
|
|
if NextDispId then
|
|
EgtSetInfo( NextDispId, 'TPOS', LoadT)
|
|
EgtSetInfo( NextDispId, 'YPOS', LoadT + dLDelta)
|
|
end
|
|
return vCmd
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecCalcSplitRot( dLenRaw)
|
|
local vCmd = {}
|
|
EgtOutLog( ' *[SR]', 1)
|
|
table.insert( vCmd, { 0, 'SplitRot'})
|
|
-- determino i grezzi da agganciare al carrello Y (sono quelli presenti nella fase successiva dispari)
|
|
local vRaw = {}
|
|
local nNextOddPhase = GetNextStartOrRestPhase( EMC.PHASE)
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
if EgtVerifyRawPartPhase( nRawId, nNextOddPhase) then
|
|
table.insert( vRaw, nRawId)
|
|
end
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
for _, nId in ipairs( vRaw) do
|
|
table.insert( vCmd, { 31, nId, 'Y'})
|
|
end
|
|
-- riporto il carrello Y al carico con il resto della trave
|
|
local dLDelta = EMC.YDELTA - dLenRaw
|
|
table.insert( vCmd, { 1, 'Y', LoadT + TurnerOffs + dLDelta})
|
|
table.insert( vCmd, { 21, 0, EMC.VDELTA})
|
|
-- imposto subito Y non più attaccato alla trave in lavoro
|
|
EMC.YDELTA = nil
|
|
-- apro il carrello Y
|
|
table.insert( vCmd, { 11, 0})
|
|
-- sgancio i grezzi dal carrello Y
|
|
for _, nId in ipairs( vRaw) do
|
|
table.insert( vCmd, { 31, nId, ''})
|
|
end
|
|
-- lo porto in parcheggio
|
|
table.insert( vCmd, { 1, 'Y', ParkY})
|
|
-- salvo posizione grezzo rimasto nella disposizione iniziale del pezzo succ (prossima fase dispari)
|
|
local NextDispId = EgtGetPhaseDisposition( nNextOddPhase)
|
|
if NextDispId then
|
|
EgtSetInfo( NextDispId, 'TPOS', LoadT)
|
|
end
|
|
return vCmd
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecCalcUnload()
|
|
local vCmdPre = {}
|
|
EgtOutLog( ' *[U]', 1)
|
|
-- Se pinza Y chiusa , devo effettuare uno scambio
|
|
if EMC.YDELTA then
|
|
-- determino posizione testa trave
|
|
local nLastEntId = EgtGetLastInGroup( EMC.PATHID)
|
|
local vAxes = EmtGetAxesPos( nLastEntId)
|
|
if #vAxes > 0 then EMC.TPOS = vAxes[1] end
|
|
-- imposto quote aggancio per avere solo pinza V
|
|
local dDistFront = EMC.LB - MinOther - EMC.TCING - 10 * GEO.EPS_SMALL
|
|
local dDistBack = 0
|
|
-- effettuo scambio
|
|
vCmdPre = SpecCalcCarriages( dDistFront, dDistBack)
|
|
if EMC.ERR ~= 0 then
|
|
return {}
|
|
end
|
|
-- recupero nuova posizione carrelli
|
|
SpecSetCarrPosFromCmds( vCmdPre)
|
|
EgtOutLog( ' *[U1]', 1)
|
|
end
|
|
local vCmd = {}
|
|
-- Tipo di scarico
|
|
local bStdUl = ( MaxUnloadLen < 1 or EMC.LB - EMC.HOVM < MaxUnloadLen + 1)
|
|
-- Commento
|
|
table.insert( vCmd, { 0, 'Unloading', EgtIf( bStdUl, 'Unloading', 'Manual Unloading')})
|
|
-- risalita testa a Zmax
|
|
local bZmaxOk = EnsureZmax( bZmaxOk, vCmd)
|
|
-- Se pinza Y chiusa, la apro
|
|
if EMC.YDELTA then
|
|
table.insert( vCmd, { 11, 0})
|
|
end
|
|
-- Se non supero la lunghezza massima di scarico, sposto il pezzo in posizione di scarico
|
|
if bStdUl then
|
|
local dFinT = UnloadT - EMC.LB
|
|
local dFinV = dFinT + EMC.VDELTA
|
|
table.insert( vCmd, { 2, 'T', dFinT, 'V', dFinV})
|
|
else
|
|
table.insert( vCmd, { 1, 'V', MaxV})
|
|
end
|
|
-- apro la morsa
|
|
table.insert( vCmd, { 12, 0})
|
|
-- riporto il carrello in home
|
|
table.insert( vCmd, { 1, 'V', ParkV})
|
|
|
|
-- eventuale unione tabelle
|
|
if #vCmdPre > 0 then
|
|
vCmd = EgtJoinTables( vCmdPre, vCmd)
|
|
end
|
|
|
|
return vCmd
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecCalcPreRot()
|
|
local vCmdPre = {}
|
|
EgtOutLog( ' *[PR]', 1)
|
|
-- Se pinza V chiusa , devo effettuare uno scambio
|
|
if EMC.VDELTA then
|
|
-- imposto quote aggancio per avere solo pinza Y
|
|
local dDistFront = 0
|
|
local dDistBack = EMC.LB - MinOther - EMC.HOVM + 10 * GEO.EPS_SMALL
|
|
-- effettuo scambio
|
|
vCmdPre = SpecCalcCarriages( dDistFront, dDistBack)
|
|
-- recupero nuova posizione carrelli
|
|
SpecSetCarrPosFromCmds( vCmdPre)
|
|
EgtOutLog( ' *[PR1]', 1)
|
|
end
|
|
-- porto il pezzo alla zona di rotazione con il carro Y
|
|
local vCmd = {}
|
|
-- Commento
|
|
table.insert( vCmd, { 0, 'Pre-Rotation'})
|
|
-- risalita testa a Zmax
|
|
local bZmaxOk = EnsureZmax( bZmaxOk, vCmd)
|
|
-- Se pinza V chiusa, la apro
|
|
if EMC.VDELTA then
|
|
table.insert( vCmd, { 12, 0})
|
|
end
|
|
-- riporto la trave al carico
|
|
local RotT = LoadT + TurnerOffs - EMC.HOVM
|
|
table.insert( vCmd, { 2, 'Y', RotT + EMC.YDELTA, 'T', RotT})
|
|
-- apro la morsa
|
|
table.insert( vCmd, { 11, 0})
|
|
-- riporto il carrello in home
|
|
table.insert( vCmd, { 1, 'Y', ParkY})
|
|
|
|
-- eventuale unione tabelle
|
|
if #vCmdPre > 0 then
|
|
vCmd = EgtJoinTables( vCmdPre, vCmd)
|
|
end
|
|
|
|
return vCmd
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
|
|
local dYPosA, dVPosA, dTPosA
|
|
|
|
-- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando
|
|
if not dYDeltaI then
|
|
dYDeltaI = dVDeltaI + ( MinY - MaxV)
|
|
end
|
|
if not dVDeltaI then
|
|
dVDeltaI = dYDeltaI - ( MinY - MaxV)
|
|
end
|
|
if not dYDeltaF then
|
|
dYDeltaF = dVDeltaF + ( MinY - MaxV)
|
|
end
|
|
if not dVDeltaF then
|
|
dVDeltaF = dYDeltaF - ( MinY - MaxV)
|
|
end
|
|
|
|
-- verifico che le morse non sono in posizione
|
|
if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL or abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then
|
|
if #vCmd == 0 then
|
|
table.insert( vCmd, { 0, 'Clamp repositioning'})
|
|
-- risalita testa a Zmax
|
|
local bZmaxOk = EnsureZmax( bZmaxOk, vCmd)
|
|
end
|
|
-- calcolo delta spostamento trave
|
|
local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico
|
|
|
|
|
|
-- scambio diretto
|
|
if ( ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam > 0) or ( ( dVDeltaI - dYDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam < 0) then
|
|
local bCloseY, bCloseV
|
|
-- se sono entrambe in presa sul pezzo
|
|
if EMC.YDELTA and EMC.VDELTA then
|
|
-- se da scarico a carico
|
|
if dVDeltaF - dVDeltaI > dYDeltaF - dYDeltaI then
|
|
table.insert( vCmd, { 0, 'Direct - V to position first'})
|
|
table.insert( vCmd, { 12, 0})
|
|
-- suddivido il movimento su entrambe le morse
|
|
local nTotMove = ( dVDeltaF - dVDeltaI) ;
|
|
dTPosA = dTPosI - nTotMove
|
|
dVPosA = dTPosA + dVDeltaF
|
|
dYPosA = dTPosA + dYDeltaI
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 12, 1})
|
|
table.insert( vCmd, { 11, 0})
|
|
bCloseY = true
|
|
else
|
|
table.insert( vCmd, { 0, 'Direct - Y to position first'})
|
|
table.insert( vCmd, { 11, 0})
|
|
-- suddivido il movimento su entrambe le morse
|
|
local nTotMove = ( dYDeltaF - dYDeltaI) ;
|
|
dTPosA = dTPosI - nTotMove
|
|
dVPosA = dTPosA + dVDeltaI
|
|
dYPosA = dTPosA + dYDeltaF
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 11, 1})
|
|
table.insert( vCmd, { 12, 0})
|
|
bCloseV = true
|
|
end
|
|
-- se pinza al carico in presa
|
|
elseif EMC.YDELTA then
|
|
table.insert( vCmd, { 0, 'Direct - V to position first'})
|
|
table.insert( vCmd, { 12, 0})
|
|
|
|
dTPosA = MaxV - dVDeltaF
|
|
dVPosA = MaxV
|
|
dYPosA = dTPosA + dYDeltaI
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 12, 1})
|
|
table.insert( vCmd, { 11, 0})
|
|
bCloseY = true
|
|
-- se pinza allo scarico in presa
|
|
else
|
|
table.insert( vCmd, { 0, 'Direct - Y to position first'})
|
|
table.insert( vCmd, { 11, 0})
|
|
|
|
dTPosA = MinY - dVDeltaF
|
|
dVPosA = dTPosA + dYDeltaI
|
|
dYPosA = MinY
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 11, 1})
|
|
table.insert( vCmd, { 12, 0})
|
|
bCloseV = true
|
|
end
|
|
|
|
-- se entrambi in presa
|
|
if EMC.YDELTANEXT and EMC.VDELTANEXT then
|
|
dTPosA = dTPosF
|
|
dYPosA = dTPosF + dYDeltaF
|
|
dVPosA = dTPosF + dVDeltaF
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
if bCloseY then table.insert( vCmd, { 11, 1}) end
|
|
if bCloseV then table.insert( vCmd, { 12, 1}) end
|
|
table.insert( vCmd, { 21, dYDeltaF, dVDeltaF})
|
|
-- sposto il carrello Y in posizione
|
|
elseif EMC.YDELTANEXT then
|
|
-- vado in posizione e sposto il carrello V in parcheggio
|
|
dYPosA = MinY
|
|
dTPosA = MinY - dYDeltaF
|
|
dVPosA = dTPosA + dVDeltaF
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
if bCloseY then table.insert( vCmd, { 11, 1}) end
|
|
table.insert( vCmd, { 12, 0})
|
|
-- sposto il carrello V in parcheggio
|
|
table.insert( vCmd, { 1, 'V', ParkV})
|
|
table.insert( vCmd, { 21, dYDeltaF, 0})
|
|
-- sposto il carrello Y in posizione
|
|
else
|
|
dVPosA = MaxV
|
|
dTPosA = MaxV - dVDeltaF
|
|
dYPosA = - ( dTPosA + dYDeltaF)
|
|
-- vado in posizione e sposto il carrello Y in parcheggio
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
if bCloseV then table.insert( vCmd, { 12, 1}) end
|
|
table.insert( vCmd, { 11, 0})
|
|
-- sposto il carrello Y in parcheggio
|
|
table.insert( vCmd, { 1, 'Y', ParkY})
|
|
table.insert( vCmd, { 21, 0, dVDeltaF})
|
|
end
|
|
|
|
-- movimento terminato
|
|
dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF
|
|
|
|
-- se devo recuperare corsa con passo del pellegrino
|
|
else
|
|
local bForceMoveY = false
|
|
-- compatto al centro
|
|
if not EMC.YDELTA then
|
|
table.insert( vCmd, { 0, 'Compact Y'})
|
|
table.insert( vCmd, { 11, 0})
|
|
dTPosA = MaxV - dVDeltaI
|
|
dVPosA = MaxV
|
|
dYPosA = MinY
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 11, 1})
|
|
EMC.YDELTA = true
|
|
dYDeltaI = dVDeltaI - MaxV + MinY
|
|
dTPosI = dTPosA
|
|
end
|
|
if not EMC.VDELTA then
|
|
table.insert( vCmd, { 0, 'Compact V'})
|
|
table.insert( vCmd, { 12, 0})
|
|
dTPosA = MinY - dYDeltaI
|
|
dVPosA = MaxV
|
|
dYPosA = MinY
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 12, 1})
|
|
EMC.VDELTA = true
|
|
bForceMoveY = true
|
|
dVDeltaI = dYDeltaI + MaxV - MinY
|
|
dTPosI = dTPosA
|
|
end
|
|
|
|
-- aggiorno delta mancante
|
|
dDeltaBeam = dTPosI - dTPosF
|
|
|
|
-- a questo punto entrambe le pinze sono in presa sul pezzo. Il trascinatore si decide in base alla direzione di movimento trave
|
|
-- trascino con morsa allo scarico
|
|
if dDeltaBeam > 0 or bForceMoveY then
|
|
-- apro morsa al carico
|
|
table.insert( vCmd, { 11, 0})
|
|
-- devo recuperare più del doppio delle corse
|
|
if abs( dYDeltaI - dYDeltaF) > ( MinY + MaxY - MinV - MaxV) then
|
|
-- calcolo nuova posizione della morsa al carico dopo riposizionamento
|
|
dYDeltaI = dYDeltaI + ( MaxY - MinY - MinV + MaxV)
|
|
dYPosA = MaxY
|
|
dVPosA = MinV
|
|
dTPosA = dTPosI - MaxV + MinV
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 11, 1})
|
|
table.insert( vCmd, { 12, 0})
|
|
dTPosI = dTPosA
|
|
EMC.YDELTA = true
|
|
EMC.VDELTA = false
|
|
-- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
|
|
SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
|
|
-- recupero una corsa massima e l'altra solo di quello che serve
|
|
elseif abs( dYDeltaI - dYDeltaF) > MinY + MaxY then
|
|
-- aggiorno nuova posizione della morsa al carico dopo riposizionamento
|
|
dYDeltaI = dYDeltaF
|
|
dVPosA = MinV
|
|
dTPosA = dTPosI - MaxV + MinV
|
|
dYPosA = - ( dYDeltaF + dTPosA)
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 11, 1})
|
|
table.insert( vCmd, { 12, 0})
|
|
dTPosI = dTPosA
|
|
EMC.YDELTA = true
|
|
EMC.VDELTA = false
|
|
-- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
|
|
SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
|
|
-- non serve recuperare al massimo della corsa, suddivido movimento in due
|
|
else
|
|
-- suddivido il movimento su entrambe le morse
|
|
local nTotMove = ( dYDeltaF - dYDeltaI) / 2 ;
|
|
|
|
dYPosA = dTPosI + dYDeltaI + nTotMove
|
|
dVPosA = dTPosI + dVDeltaI - nTotMove
|
|
dTPosA = dTPosI - nTotMove
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 11, 1})
|
|
table.insert( vCmd, { 12, 0})
|
|
|
|
-- aggiorno nuova posizione della morsa al carico dopo riposizionamento
|
|
dYDeltaI = dYDeltaF ;
|
|
|
|
if not EMC.VDELTANEXT then
|
|
dTPosA = dTPosF
|
|
dYPosA = dTPosF + dYDeltaF
|
|
dVPosA = ParkV
|
|
elseif EMC.YDELTANEXT then
|
|
dTPosA = dTPosF
|
|
dYPosA = dTPosF + dYDeltaF
|
|
dVPosA = dTPosF + dVDeltaF
|
|
else
|
|
dYPosA = MinY
|
|
dTPosA = MinY - dYDeltaF
|
|
dVPosA = dTPosA + dVDeltaF
|
|
end
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF
|
|
|
|
-- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento
|
|
dVDeltaI = dVDeltaF
|
|
|
|
-- sistemo apertura morse
|
|
if EMC.VDELTANEXT then
|
|
table.insert( vCmd, { 12, 1})
|
|
end
|
|
if not EMC.YDELTANEXT then
|
|
table.insert( vCmd, { 11, 0})
|
|
-- sposto il carrello Y in parcheggio
|
|
table.insert( vCmd, { 1, 'Y', ParkY})
|
|
end
|
|
-- imposto i nuovi parametri di aggancio
|
|
if EMC.YDELTANEXT and EMC.VDELTANEXT then
|
|
table.insert( vCmd, { 21, dYDeltaF, dVDeltaF})
|
|
elseif EMC.YDELTANEXT then
|
|
table.insert( vCmd, { 21, dYDeltaF, 0})
|
|
else
|
|
table.insert( vCmd, { 21, 0, dVDeltaF})
|
|
end
|
|
|
|
end
|
|
-- trave si muove dallo scarico verso il carico
|
|
else
|
|
-- apro morsa allo scarico
|
|
table.insert( vCmd, { 12, 0})
|
|
-- devo recuperare più del doppio delle corse
|
|
if abs( dVDeltaI - dVDeltaF) > ( MinY + MaxY - MinV - MaxV) then
|
|
-- calcolo nuova posizione della morsa al carico dopo riposizionamento
|
|
dVDeltaI = dVDeltaI - ( MaxY - MinY - MinV + MaxV)
|
|
dYPosA = MaxY
|
|
dVPosA = MinV
|
|
dTPosA = dTPosI + MaxY - MinY
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 12, 1})
|
|
table.insert( vCmd, { 11, 0})
|
|
dTPosI = dTPosA
|
|
EMC.YDELTA = false
|
|
EMC.VDELTA = true
|
|
-- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
|
|
SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
|
|
-- recupero una corsa massima e l'altra solo di quello che serve
|
|
elseif abs( dVDeltaI - dVDeltaF) > - MinV - MaxV then
|
|
-- aggiorno nuova posizione della morsa al carico dopo riposizionamento
|
|
dVDeltaI = dVDeltaF
|
|
dYPosA = MaxY
|
|
dTPosA = dTPosI + MaxY - MinY
|
|
dVPosA = dVDeltaF + dTPosA
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 12, 1})
|
|
table.insert( vCmd, { 11, 0})
|
|
dTPosI = dTPosA
|
|
EMC.YDELTA = false
|
|
EMC.VDELTA = true
|
|
-- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo
|
|
SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos)
|
|
-- non serve recuperare al massimo della corsa, suddivido movimento in due
|
|
else
|
|
-- suddivido il movimento su entrambe le morse
|
|
local nTotMove = ( dVDeltaI - dVDeltaF) / 2 ;
|
|
|
|
dYPosA = dTPosI + dYDeltaI + nTotMove
|
|
dVPosA = dTPosI + dVDeltaI - nTotMove
|
|
dTPosA = dTPosI + nTotMove
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
table.insert( vCmd, { 12, 1})
|
|
table.insert( vCmd, { 11, 0})
|
|
|
|
-- aggiorno nuova posizione della morsa al carico dopo riposizionamento
|
|
dVDeltaI = dVDeltaF ;
|
|
|
|
if EMC.VDELTANEXT then
|
|
dTPosA = dTPosF
|
|
dYPosA = dTPosF + dYDeltaF
|
|
dVPosA = dTPosF + dVDeltaF
|
|
else
|
|
dVPosA = MaxV
|
|
dTPosA = MaxV - dVDeltaF
|
|
dYPosA = - dTPosA - dYDeltaF
|
|
end
|
|
table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA})
|
|
dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF
|
|
|
|
-- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento
|
|
dYDeltaI = dYDeltaF
|
|
|
|
-- sistemo apertura morse
|
|
if EMC.YDELTANEXT then
|
|
table.insert( vCmd, { 11, 1})
|
|
end
|
|
if not EMC.VDELTANEXT then
|
|
table.insert( vCmd, { 12, 0})
|
|
-- sposto il carrello Y in parcheggio
|
|
table.insert( vCmd, { 1, 'V', ParkV})
|
|
end
|
|
-- imposto i nuovi parametri di aggancio
|
|
if EMC.YDELTANEXT and EMC.VDELTANEXT then
|
|
table.insert( vCmd, { 21, dYDeltaF, dVDeltaF})
|
|
elseif EMC.YDELTANEXT then
|
|
table.insert( vCmd, { 21, dYDeltaF, 0})
|
|
else
|
|
table.insert( vCmd, { 21, 0, dVDeltaF})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecOutputCNT()
|
|
if EMC.CNT == 1 then
|
|
EgtSetInfo( EMC.PATHID, 'CNT', 1)
|
|
else
|
|
EgtRemoveInfo( EMC.PATHID, 'CNT')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecOutputCmds( vCmd, bEnd)
|
|
|
|
local sRoot = EgtIf( not bEnd, 'AS', 'AE')
|
|
|
|
-- Registro il numero di comandi
|
|
if #vCmd > 0 then
|
|
EgtSetInfo( EMC.PATHID, sRoot..'#', #vCmd)
|
|
else
|
|
EgtRemoveInfo( EMC.PATHID, sRoot..'#')
|
|
end
|
|
-- Registro i comandi
|
|
for i = 1, #vCmd do
|
|
local Cmd = vCmd[i]
|
|
local sKey = sRoot..tostring( i)
|
|
-- commento
|
|
if Cmd[1] == 0 then
|
|
local sInfo = '0,'..Cmd[2]
|
|
if Cmd[3] then sInfo = sInfo..','..Cmd[3] end
|
|
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
|
-- movimento di 1 asse
|
|
elseif Cmd[1] == 1 then
|
|
local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)
|
|
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)
|
|
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
|
-- movimento di 3 assi
|
|
elseif Cmd[1] == 3 then
|
|
local sInfo = '3,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..','..
|
|
Cmd[6]..','..EgtNumToString( Cmd[7],3)
|
|
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
|
-- apertura/chiusura morsa Y
|
|
elseif Cmd[1] == 11 then
|
|
local sInfo = '11,'..EgtNumToString( Cmd[2],0)
|
|
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
|
if Cmd[2] == 0 then EMC.YDELTA = nil end
|
|
-- apertura/chiusura morsa V
|
|
elseif Cmd[1] == 12 then
|
|
local sInfo = '12,'..EgtNumToString( Cmd[2],0)
|
|
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
|
if Cmd[2] == 0 then EMC.VDELTA = nil end
|
|
-- impostazione nuovo stato dei carrelli
|
|
elseif Cmd[1] == 21 then
|
|
local sInfo = '21,'..EgtNumToString( Cmd[2],3)..','..EgtNumToString( Cmd[3],3)
|
|
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
|
if Cmd[2] > 0 and Cmd[3] > 0 then
|
|
EMC.YDELTA = Cmd[2]
|
|
EMC.VDELTA = Cmd[3]
|
|
elseif Cmd[2] > 0 then
|
|
EMC.YDELTA = Cmd[2]
|
|
EMC.VDELTA = nil
|
|
elseif Cmd[3] > 0 then
|
|
EMC.YDELTA = nil
|
|
EMC.VDELTA = Cmd[3]
|
|
end
|
|
-- aggancio grezzo a carrello
|
|
elseif Cmd[1] == 31 then
|
|
local sInfo = '31,'..EgtNumToString( Cmd[2],0)..','..Cmd[3]
|
|
EgtSetInfo( EMC.PATHID, sKey, sInfo)
|
|
end
|
|
end
|
|
|
|
-- Salvo i nuovi delta dei carrelli
|
|
if EMC.YDELTA then
|
|
EgtSetInfo( EMC.PATHID, 'YDELTA', EMC.YDELTA)
|
|
else
|
|
EgtRemoveInfo( EMC.PATHID, 'YDELTA')
|
|
end
|
|
if EMC.VDELTA then
|
|
EgtSetInfo( EMC.PATHID, 'VDELTA', EMC.VDELTA)
|
|
else
|
|
EgtRemoveInfo( EMC.PATHID, 'VDELTA')
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecSetCarrPosFromCmds( vCmd)
|
|
-- recupero nuova posizione carrelli
|
|
for i = 1, #vCmd do
|
|
local Cmd = vCmd[i]
|
|
if Cmd[1] == 21 then
|
|
if Cmd[2] > 0 and Cmd[3] > 0 then
|
|
EMC.YDELTA = Cmd[2]
|
|
EMC.VDELTA = Cmd[3]
|
|
elseif Cmd[2] > 0 then
|
|
EMC.YDELTA = Cmd[2]
|
|
EMC.VDELTA = nil
|
|
elseif Cmd[3] > 0 then
|
|
EMC.YDELTA = nil
|
|
EMC.VDELTA = Cmd[3]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function SpecTestOnlyRemarkInCmds( vCmd)
|
|
if not vCmd then return true end
|
|
-- verifico se nella lista dei comandi ci sono solo commenti
|
|
for i = 1, #vCmd do
|
|
if vCmd[i][1] ~= 0 then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|