diff --git a/Common_FAST.mlse b/Common_FAST.mlse index c9437d9..f4be8e6 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1097,16 +1097,24 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack) 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) + + -- se flag attivo, vado a pinzare al massimo della corsa + if BD.FASTCLAMPING then + 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 + else + -- si pinza sempre a 1000mm massimo + dNewYDelta = min( dNewYDelta, 1000) end + -- Commento table.insert( vCmd, { 0, 'Loading'}) -- risalita testa a Zmax @@ -1131,9 +1139,71 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack) 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 + +--------------------------------------------------------------------- +local function AdjustPositionsForB( dNewYDelta, dNewVDelta, TCING, HCING, HOVM, bFixedDelta) + local REF_DIST = 1400 + local dYDelta = 0 + local dVDelta = 0 + -- incremento se possibile la distanza tra le due posizioni + if not bFixedDelta and ( dNewYDelta - dNewVDelta) < REF_DIST then + local dEffAddDist = ( REF_DIST - ( dNewYDelta - dNewVDelta)) / 2 + dYDelta = max( min( dEffAddDist, EMC.LB - dNewYDelta - MinJoin - TCING), 0) + dVDelta = max( min( dEffAddDist, dNewVDelta - MinJoin - HOVM - HCING), 0) + end + return dYDelta, dVDelta +end + +--------------------------------------------------------------------- +local function GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta) + local dDeltaTolEff = DELTA_SIC + if Carr == 'Y' then + local dLenPreEff = dLenPresa - TCING + if dLenPreEff < MinJoin + DeltaTol then + dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) + else + if BD.GO_FAST and BD.GO_FAST ~= 0 then + if bFixedDelta == false then + dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200) + else + dDeltaTolEff = 900 + end + else + dDeltaTolEff = DeltaTol + end + end + elseif Carr == 'V' then + local dLenPreEff = dLenPresa - HCING - HOVM + if dLenPreEff < MinJoin + DeltaTol then + dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) + else + dDeltaTolEff = DeltaTol + end + end + return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff) +end + --------------------------------------------------------------------- function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) + -- Abilitazione gestione vecchia dei riposizionamenti + if not BD.NEWCLAMPING then + return SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos) + end + 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) @@ -1148,46 +1218,85 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) ' 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 + -- se sono già settati, non calcolo posizione finale + if not EMC.YDELTANEXT and not EMC.VDELTANEXT then + dNewPosT = GetMachiningStartingPoint( EMC.PATHID) + end + local dNewYDelta = nil + local dNewVDelta = nil + -- [A] se posso mettere solo carrello Y if dDistFrontEff < MinFrontJoin and dDistBackEff > MinBackJoin - GEO.EPS_SMALL then + -- se Y non era in presa, mi ricalcolo la posizione + if not dYDelta then + dYDelta = dVDelta + ( MinY - MaxV) + end + dNewYDelta = EMC.LB - dDistBackEff + -- verifico se posso lasciare la morsa in posizione + local dYDeltaTol = GetDeltaTol( EMC.LB - dNewYDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y') + local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC) + if bYDeltaS then + dNewYDelta = dNewYDelta + dYDeltaTol/2 + else + dNewYDelta = dYDelta + end - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = EMC.LB - dDistBackEff - local dNewVDelta = nil - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - + 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 - - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = EMC.LB - dDistBackEff - local dNewVDelta = dDistFrontEff - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + -- se Y non era in presa, mi ricalcolo la posizione + if not dYDelta then + dYDelta = dVDelta + ( MinY - MaxV) + end + -- se V non era in presa, mi ricalcolo la posizione + if not dVDelta then + dVDelta = dYDelta - ( MinY - MaxV) + end + + dNewYDelta = EMC.LB - dDistBackEff + dNewVDelta = dDistFrontEff + + -- incremento la distanza tra le due posizioni ( se abilitato e possibile) + local dYDeltaAgg, dVDeltaAgg = AdjustPositionsForB( dNewYDelta, dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta) + -- tolleranze + local dYDeltaTol = dYDeltaAgg + GetDeltaTol( EMC.LB - dNewYDelta - dYDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y', bFixedDelta) + local dVDeltaTol = dVDeltaAgg + GetDeltaTol( dNewVDelta - dVDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + -- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze + local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC) + local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or dNewVDelta < dVDelta - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bYDeltaS then + dNewYDelta = dNewYDelta + dYDeltaTol / 2 + else + dNewYDelta = dYDelta + end + if bVDeltaS then + dNewVDelta = dNewVDelta - dVDeltaTol / 2 + else + dNewVDelta = dVDelta + end -- [C] se altrimenti posso mettere solo carrello V elseif dDistBackEff < MinBackJoin and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then - - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = nil - local dNewVDelta = dDistFrontEff - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - + -- se V non era in presa, mi ricalcolo la posizione + if not dVDelta then + dVDelta = dYDelta - ( MinY - MaxV) + end + dNewVDelta = dDistFrontEff + -- verifico se posso lasciare la morsa in posizione + local dVDeltaTol = GetDeltaTol( dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or dNewVDelta < dVDelta - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bVDeltaS then + dNewVDelta = dNewVDelta - dVDeltaTol/2 + else + dNewVDelta = dVDelta + end + dNewYDelta = nil -- altrimenti errore else if EgtGetDebugLevel() < 3 then @@ -1199,6 +1308,16 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) return {} end + -- salvo valori finali + EMC.YDELTANEXT = dNewYDelta + EMC.VDELTANEXT = dNewVDelta + + local vCmd = {} + SpecAdjustCarriages( vCmd, dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + SpecOutputCNT() + return vCmd + end --------------------------------------------------------------------- @@ -1371,8 +1490,662 @@ function SpecCalcPreRot() end --------------------------------------------------------------------- -function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) +function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + local dYPosA, dVPosA, dTPosA + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + + -- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando + if not dYDeltaI then + dYDeltaI = dVDeltaI + ( MyMinY - MaxV) + end + if not dVDeltaI then + dVDeltaI = dYDeltaI - ( MyMinY - MaxV) + end + if not dYDeltaF then + dYDeltaF = dVDeltaF + ( MyMinY - MaxV) + end + if not dVDeltaF then + dVDeltaF = dYDeltaF - ( MyMinY - MaxV) + end + + -- se non c'è posizione finale, è lo scarico. Allora setto al minimo della morsa allo scarico. + if not dTPosF then + dTPosF = MaxV - dVDeltaF + 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 or + EMC.YDELTA ~= EMC.YDELTANEXT or EMC.VDELTA ~= EMC.VDELTANEXT then + if #vCmd == 0 then + table.insert( vCmd, { 0, 'Clamp repositioning'}) + -- risalita testa a Zmax + local bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + end + + -- reset contatore primo riposizionamento con compensazione lettura laser + EMC.CNT = nil + + -- ricavo posizione delle morse nelle corse + local dYPosI = max( MyMinY, dTPosI + dYDeltaI) + local dVPosI = min( MaxV, dTPosI + dVDeltaI) + + -- calcolo eventuale massimo riposizionamento con passo del pellegrino. + -- al primo step si calcolano posizioni attuali delle morse + -- al secondo step si considerano le corse massime + local dMaxMovePilgrimStepDoubleClamp, dMaxMovePilgrimStepSingleClampY, dMaxMovePilgrimStepSingleClampV + if not EMC.PILGRIMSTEP then + dMaxMovePilgrimStepDoubleClamp = MaxY - dYPosI - MinV + dVPosI + dMaxMovePilgrimStepSingleClampY = MaxY - dYPosI + dMaxMovePilgrimStepSingleClampV = - MinV + dVPosI + else + dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV + dMaxMovePilgrimStepSingleClampY = MaxY - MinY + dMaxMovePilgrimStepSingleClampV = - MinV + MaxV + end + + -- calcolo delta spostamento trave + local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico + local dBeamMove = 0 + + -- PRIMO CASO -> SCAMBIO DIRETTO : V IN POSIZIONE FINALE + -- V può andare in posizione direttamente se : + -- * rispetta interasse minimo con Y + -- * 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 + if ( dYDeltaI - dVDeltaF) >= MyMinY - MaxV and abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and + ( dVDeltaF - dVDeltaI > MinV - dVPosI + MyMinY - dYPosI) then + table.insert( vCmd, { 0, 'Direct-V-Y'}) + -- se l'altra morsa non era in presa, vado a pinzare il pezzo + if not EMC.YDELTA then + dYPosA = MyMinY + dTPosA = MyMinY - dYDeltaI + dVPosA = dTPosA + dVDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dVPosI = dVPosA + table.insert( vCmd, { 11, 1}) + end + -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo + -- se non era ingaggiata, vado al suo minimo + if not EMC.VDELTA then + dBeamMove = -( MaxV - dVDeltaF - dTPosI) + -- se spostamento verso lo scarico + elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) < MinV then + dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MinV + -- se spostamento verso il carico + elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) > MaxV then + dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MaxV + end + + table.insert( vCmd, { 12, 0}) + + dTPosA = dTPosI - dBeamMove + dYPosA = dTPosA + dYDeltaI + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + -- la morsa allo scarico è adesso in posizione + dVDeltaI = dVDeltaF + dTPosI = dTPosA + + -- blocco la morsa + table.insert( vCmd, { 12, 1}) + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + -- porto assi alla loro posizione finale + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 11, 0}) + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + -- la morsa al carico è adesso in posizione + dYDeltaI = dYDeltaF + end + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 11, 0}) + dYPosA = max( MyMinY, dTPosI + dYDeltaF) + dTPosA = -( dYPosA + dVDeltaF) + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + -- la morsa al carico è adesso in posizione + dYDeltaI = dYDeltaF + end + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + table.insert( vCmd, { 21, dYDeltaF, 0}) + else + table.insert( vCmd, { 11, 0}) + table.insert( vCmd, { 1, 'Y', ParkY}) + table.insert( vCmd, { 21, 0, dVDeltaF}) + end + + -- movimento terminato + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- SECONDO CASO -> SCAMBIO DIRETTO : Y IN POSIZIONE FINALE + -- Y può andare in posizione direttamente se : + -- * rispetta interasse minimo con Y + -- * 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 ( dYDeltaF - dVDeltaI) >= MyMinY - MaxV and abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and + ( dYDeltaF - dYDeltaI < MaxY - dYPosI + MaxV - dVPosI) then + table.insert( vCmd, { 0, 'Direct-Y-V'}) + -- se l'altra morsa non era in presa, vado a pinzare il pezzo + if not EMC.VDELTA then + dVPosA = MaxV + dTPosA = MaxV - dVDeltaI + dYPosA = dTPosA + dYDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dYPosI = dYPosA + table.insert( vCmd, { 12, 1}) + else + -- compenso delta errore misurazione laser + dVDeltaI = dVDeltaI - EgtIf( EMC.CNT == 1, AGG_LOAD, 0) + end + + -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo + -- se non era ingaggiata, vado al suo minimo + if not EMC.YDELTA then + dBeamMove = - ( dYDeltaF - MyMinY + dTPosI) + -- se spostamento verso lo scarico + elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) < MyMinY then + dBeamMove = -( dYPosI + ( dYDeltaF - dYDeltaI) - MyMinY) + -- se spostamento verso il carico + elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) > MaxY then + dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MaxY + end + + table.insert( vCmd, { 11, 0}) + + dTPosA = dTPosI + dBeamMove + dYPosA = dTPosA + dYDeltaF + dVPosA = dTPosA + dVDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + -- la morsa allo scarico è adesso in posizione + dYDeltaI = dYDeltaF + dTPosI = dTPosA + + -- blocco la morsa + table.insert( vCmd, { 11, 1}) + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 12, 0}) + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- la morsa al carico è adesso in posizione + dVDeltaI = dVDeltaF + end + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.VDELTANEXT then + if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 12, 0}) + dVPosA = min( MaxV, dTPosI + dVDeltaF) + dTPosA = dVPosA - dVDeltaF + dYPosA = dTPosA + dYDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- la morsa al carico è adesso in posizione + dVDeltaI = dVDeltaF + end + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + table.insert( vCmd, { 21, 0, dVDeltaF}) + else + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + table.insert( vCmd, { 21, dYDeltaF, 0}) + end + -- movimento terminato + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- TERZO CASO -> PASSO DEL PELLEGRINO + -- non è possibile fare scambio diretto. + -- le morse vengono compattate e allargate sfruttando tutta la corsa X, massimizzando spostamento trave + else + EMC.PILGRIMSTEP = false + local bUpdateValues = false + table.insert( vCmd, { 0, 'Pilgrim Cycle'}) + -- 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 = MyMinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + dYDeltaI = dVDeltaI - MaxV + MyMinY + EMC.YDELTA = dYDeltaI + bUpdateValues = true + end + if not EMC.VDELTA then + table.insert( vCmd, { 0, 'Compact V'}) + table.insert( vCmd, { 12, 0}) + dTPosA = MyMinY - dYDeltaI + dVPosA = MaxV + dYPosA = MyMinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + dVDeltaI = dYDeltaI + MaxV - MyMinY + EMC.VDELTA = dVDeltaI + bUpdateValues = true + end + + -- se si sono compattate le morse, bisogna aggiornare le posizioni e i massimi recuperi + if bUpdateValues then + dTPosI = dTPosA + dYPosI = dYPosA + dVPosI = dVPosA + dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV + dMaxMovePilgrimStepSingleClampY = MaxY - MinY + dMaxMovePilgrimStepSingleClampV = - MinV + MaxV + 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. Obiettivo mandare Y in posizione per prima + if dDeltaBeam > 0 then + -- apro morsa al carico + table.insert( vCmd, { 11, 0}) + -- devo recuperare più delle corse disponibili di entrambi i carrelli + if abs( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepDoubleClamp then + dYPosA = MaxY + dVPosA = MinV + dTPosA = dTPosI - dVPosI + MinV + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = MaxY - dTPosA + dTPosI = dTPosA + EMC.YDELTA = dYDeltaI + EMC.VDELTA = nil + EMC.PILGRIMSTEP = 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( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepSingleClampY then + -- morsa Y arriva in posizione finale + 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 = dYDeltaF + EMC.VDELTA = dVDeltaI + -- 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 dTotMove = ( dYDeltaF - dYDeltaI) / 2 + + if abs( dTotMove) > 10 * GEO.EPS_SMALL then + dYPosA = dTPosI + dYDeltaI + dTotMove + dVPosA = dTPosI + dVDeltaI - dTotMove + dTPosA = dTPosI - dTotMove + 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 = MyMinY + dTPosA = MyMinY - 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 + end + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, 0}) + else + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + table.insert( vCmd, { 21, 0, dVDeltaF}) + end + end + -- trave si muove dallo scarico verso il carico. Obiettivo mandare V in posizione per prima + else + -- apro morsa allo scarico + table.insert( vCmd, { 12, 0}) + -- devo recuperare più del doppio delle corse + local dMaxMoveFirst + if abs( dVDeltaI - dVDeltaF) > dMaxMovePilgrimStepDoubleClamp then + dYPosA = MaxY + dVPosA = MinV + dTPosA = dTPosI + ( MaxY - dYPosI) + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- nuova posizione della morsa allo scarico dopo riposizionamento + dVDeltaI = MinV - dTPosA + dTPosI = dTPosA + EMC.YDELTA = nil + EMC.VDELTA = dVDeltaI + EMC.PILGRIMSTEP = 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) > dMaxMovePilgrimStepSingleClampV then + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + local dTotMove = MaxY - dTPosI - dYDeltaI + dVDeltaI = dVDeltaF + dYPosA = MaxY + dTPosA = dTPosI + dTotMove + 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 = dYDeltaI + EMC.VDELTA = dVDeltaF + -- 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 dTotMove = ( dVDeltaI - dVDeltaF) / 2 + + if abs( dTotMove) > 10 * GEO.EPS_SMALL then + dYPosA = dTPosI + dYDeltaI + dTotMove + dVPosA = dTPosI + dVDeltaI - dTotMove + dTPosA = dTPosI + dTotMove + 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 allo scarico dopo riposizionamento + dVDeltaI = dVDeltaF ; + + if not EMC.YDELTANEXT then + dTPosA = dTPosF + dVPosA = dTPosF + dVDeltaF + dYPosA = ParkY + elseif 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 al carico dopo riposizionamento + dYDeltaI = dYDeltaF + end + + -- 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, { 11, 1}) + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + table.insert( vCmd, { 11, 1}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 12, 0}) + table.insert( vCmd, { 1, 'V', ParkV}) + 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 + +--------------------------------------------------------------------- +--XXXXX XXXXX XXXXX --- TO REMOVE --- XXXXX XXXXX XXXXX XXXXX-- +--------------------------------------------------------------------- +--------------------------------------------------------------------- +function SpecCalcCarriagesOLD( 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) + + -- [A] se posso mettere solo carrello Y + if dDistFrontEff < MinFrontJoin and dDistBackEff > MinBackJoin - GEO.EPS_SMALL then + + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + + local dNewPosT = nil + local dNewYDelta = EMC.LB - dDistBackEff + local dNewVDelta = nil + + return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + -- [B] se altrimenti posso mettere entrambi i carrelli Y e V + elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and + dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + + local dNewPosT = nil + local dNewYDelta = EMC.LB - dDistBackEff + local dNewVDelta = dDistFrontEff + + return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + -- [C] se altrimenti posso mettere solo carrello V + elseif dDistBackEff < MinBackJoin and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + + local dNewPosT = nil + local dNewYDelta = nil + local dNewVDelta = dDistFrontEff + + return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + -- 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 +end + +--------------------------------------------------------------------- +function SpecAdjustCarriagesOLD( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- [A] richiesto solo carrello Y if dYDeltaF and ( not dVDeltaF) then -- [A1] rimango sul carrello Y @@ -1388,7 +2161,6 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe EgtOutLog( ' Error CLAMP NULL-> Y impossibile') error( 'Error CLAMP NULL-> Y impossibile') end - -- (B) richiesti entrambi i carrelli elseif dYDeltaF and dVDeltaF then -- [B1] passo da carrello Y a entrambi @@ -1404,7 +2176,6 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe EgtOutLog( ' Error CLAMP NULL-> Y+V impossibile') error( 'Error CLAMP NULL-> Y+V impossibile') end - -- [C] richiesto solo carrello V elseif ( not dYDeltaF) and dVDeltaF then -- [C1] provengo da solo carrello Y @@ -1420,9 +2191,7 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe EgtOutLog( ' Error CLAMP NULL-> V impossibile') error( 'Error CLAMP NULL-> V impossibile') end - end - end --------------------------------------------------------------------- @@ -1436,35 +2205,6 @@ local function CalcCharStatus( sType, dDelta) end end ---------------------------------------------------------------------- -local function GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta) - local dDeltaTolEff = DELTA_SIC - if Carr == 'Y' then - local dLenPreEff = dLenPresa - TCING - if dLenPreEff < MinJoin + DeltaTol then - dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) - else - if BD.GO_FAST and BD.GO_FAST ~= 0 then - if bFixedDelta == false then - dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200) - else - dDeltaTolEff = 900 - end - else - dDeltaTolEff = DeltaTol - end - end - elseif Carr == 'V' then - local dLenPreEff = dLenPresa - HCING - HOVM - if dLenPreEff < MinJoin + DeltaTol then - dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) - else - dDeltaTolEff = DeltaTol - end - end - return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff) -end - --------------------------------------------------------------------- local function GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistN, sSide) local dRecTotn = min( dDistN, dCorsaYfc+ dCorsaVfc) -- recupero possibile al netto di dCorsa..TrA) @@ -3734,122 +4474,3 @@ function SpecAdjustCarrC3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDelta SpecOutputCNT() return vCmd end --SpecAdjustCarrC3 - ---------------------------------------------------------------------- -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