From 8fdda065d45426c2fb4307c0e4014d7007ef01e5 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Mon, 23 Sep 2024 11:28:35 +0200 Subject: [PATCH] Ripristinato vecchio metodo riposizionamento morse --- Common_FAST.mlse | 2462 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 2440 insertions(+), 22 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 4458830..f4be8e6 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1199,6 +1199,11 @@ 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) @@ -1525,7 +1530,10 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- 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 + + -- 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 @@ -1541,7 +1549,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico local dBeamMove = 0 - -- SCAMBIO DIRETTO : V IN POSIZIONE FINALE + -- PRIMO CASO -> SCAMBIO DIRETTO : V IN POSIZIONE FINALE -- V può andare in posizione direttamente se : -- * rispetta interasse minimo con Y -- * deve effettivamente spostarsi @@ -1549,6 +1557,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- * 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 @@ -1623,7 +1632,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- movimento terminato dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF - -- SCAMBIO DIRETTO : Y IN POSIZIONE FINALE + -- SECONDO CASO -> SCAMBIO DIRETTO : Y IN POSIZIONE FINALE -- Y può andare in posizione direttamente se : -- * rispetta interasse minimo con Y -- * deve effettivamente spostarsi @@ -1631,6 +1640,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- * 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 @@ -1708,9 +1718,13 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- movimento terminato dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF - -- se devo recuperare corsa con passo del pellegrino + -- 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'}) @@ -1722,12 +1736,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 1}) dYDeltaI = dVDeltaI - MaxV + MyMinY EMC.YDELTA = dYDeltaI - dTPosI = dTPosA - dYPosI = dYPosA - dVPosI = dVPosA - dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV - dMaxMovePilgrimStepSingleClampY = MaxY - MinY - dMaxMovePilgrimStepSingleClampV = - MinV + MaxV + bUpdateValues = true end if not EMC.VDELTA then table.insert( vCmd, { 0, 'Compact V'}) @@ -1739,6 +1748,11 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF 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 @@ -1750,20 +1764,21 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- 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 + -- 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 disponiobili di entrambi i carrelli + -- devo recuperare più delle corse disponibili di entrambi i carrelli if abs( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepDoubleClamp then - -- calcolo nuova posizione della morsa al carico dopo riposizionamento 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 @@ -1773,7 +1788,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF 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 - -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + -- morsa Y arriva in posizione finale dYDeltaI = dYDeltaF dVPosA = MinV dTPosA = dTPosI - MaxV + MinV @@ -1836,20 +1851,20 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 21, 0, dVDeltaF}) end end - -- trave si muove dallo scarico verso il carico + -- 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 - -- calcolo nuova posizione della morsa al carico dopo riposizionamento 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 @@ -1886,7 +1901,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) - -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento dVDeltaI = dVDeltaF ; if not EMC.YDELTANEXT then @@ -1905,7 +1920,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF 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 + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento dYDeltaI = dYDeltaF end @@ -2048,11 +2063,2414 @@ end --------------------------------------------------------------------- function SpecTestOnlyRemarkInCmds( vCmd) if not vCmd then return true end - -- verifico se nella lista dei comandi ci sono solo commenti + -- 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 + 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 + if dYDeltaI and ( not dVDeltaI) then + return SpecAdjustCarrA1( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF) + -- [A2] torno da entrambi + elseif dYDeltaI and dVDeltaI then + return SpecAdjustCarrA2( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF) + -- [A3] torno da carrello V + elseif dVDeltaI and (not dYDeltaI) then + return SpecAdjustCarrA3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF) + else + 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 + if dYDeltaI and ( not dVDeltaI) then + return SpecAdjustCarrB1( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + -- [B2] continuo con entrambi i carrelli + elseif dYDeltaI and dVDeltaI then + return SpecAdjustCarrB2( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + -- [B3] passo da carrello V a entrambi + elseif dVDeltaI and (not dYDeltaI) then + return SpecAdjustCarrB3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + else + 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 + if dYDeltaI and ( not dVDeltaI) then + return SpecAdjustCarrC1( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + -- [C2] provengo da carrelli Y e V + elseif dYDeltaI and dVDeltaI then + return SpecAdjustCarrC2( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + -- [C3] rimango sul carrello V + elseif ( not dYDeltaI) and dVDeltaI then + return SpecAdjustCarrC3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + else + EgtOutLog( ' Error CLAMP NULL-> V impossibile') + error( 'Error CLAMP NULL-> V impossibile') + end + end +end + +--------------------------------------------------------------------- +local function CalcCharStatus( sType, dDelta) + -- se per carrello Y + if sType == 'Y' then + return EgtIf( EMC.LB - dDelta < LenToPress, 1, 2) + -- altrimenti per carrello V + else + return EgtIf( dDelta < LenToPress, 1, 2) + end +end + +--------------------------------------------------------------------- +local function GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistN, sSide) + local dRecTotn = min( dDistN, dCorsaYfc+ dCorsaVfc) -- recupero possibile al netto di dCorsa..TrA) + local dCorsaYd, dCorsaYTd, dCorsaVd, dCorsaVTd + if sSide == 'Fr' then + if dRecTotn / 2 <= dCorsaYfc then + if dRecTotn / 2 <= dCorsaVfc then + dCorsaYTd = dRecTotn / 2 + dCorsaVd = dRecTotn / 2 + else + dCorsaVd = dCorsaVfc + dCorsaYTd = min( dCorsaYfc, dRecTotn - dCorsaVd) + end + else + dCorsaYTd = dCorsaYfc + dCorsaVd = min( dCorsaVfc, dRecTotn - dCorsaYTd) + end + dCorsaY = dCorsaYTd + dCorsaV = dCorsaVd + else + if dRecTotn / 2 <= dCorsaVfc then + if dRecTotn / 2 <= dCorsaYfc then + dCorsaVTd = dRecTotn / 2 + dCorsaYd = dRecTotn / 2 + else + dCorsaYd = dCorsaYfc + dCorsaVTd = min( dCorsaVfc, dRecTotn - dCorsaYd) + end + else + dCorsaVTd = dCorsaVfc + dCorsaYd = min( dCorsaYfc, dRecTotn - dCorsaVTd) + end + dCorsaY = dCorsaYd + dCorsaV = dCorsaVTd + end + return dCorsaY, dCorsaV +end + +--------------------------------------------------------------------- +local function PosxExtraYV( dYPosA, dVPosA, dTPosA, dMinY, dMaxV, sYV) + -- svolge la predisposizione iniziale di trave e carrelli in caso di situazione iniziale con un solo carrello chiuso + -- con un solo carrello chiuso per l'aggancio del carrello aperto + local dYPos, dVPos, dTPos + -- per aggancio del carrello V + if sYV == 'V' then + dTPos = min( dTPosA, dVPosA - MinJoin - EgtIf( EMC.HCING_IGNORE, 0, EMC.HCING) - EMC.HOVM) + dYPos = dYPosA + ( dTPos - dTPosA) + if dYPos < dMinY then + dVPos = dVPosA + ( dMinY - dYPos) + if dVPos > dMaxV + GEO.EPS_SMALL then + EmitComment( vCmd, ' Error CLAMP V') + error( 'Error CLAMP V') + return + elseif dVPos > dMaxV - GEO.EPS_SMALL then + dVPos = dMaxV + end + dYPos = dMinY + dTPos = dTPosA + ( dYPos - dYPosA) + else + --dYPos = dMinY + --dYPos = dYPos! + --dTPos = dTPosA + ( dYPos - dYPosA) + --dTPos = dTPos! + dVPos = dVPosA + end + end + -- per aggancio del carrello Y + if sYV == 'Y' then + dTPos = max( dTPosA, dYPosA + MinJoin + EMC.TCING - EMC.LB) + dVPos = dVPosA + ( dTPos - dTPosA) + if dVPos > dMaxV then + dYPos = dYPosA - ( dVPos - dMaxV) + if dYPos < dMinY - GEO.EPS_SMALL then + EmitComment( vCmd, ' Error CLAMP Y') + error( 'Error CLAMP Y') + return + elseif dYPos < dMinY + GEO.EPS_SMALL then + dYPos = dMinY + end + dVPos = dMaxV + dTPos = dTPosA + ( dVPos - dVPosA) + else + -- ++++++++++++++++++++++++++++++++ + --dVPos = dMaxV + --dVPos = dVPos! + --dTPos = dTPosA + ( dVPos - dVPosA) + --dTpos = dTPos!! + dYPos = dYPosA + end + end + return dYPos, dVPos, dTPos +end + +--------------------------------------------------------------------- +local function PosXs2Enl (dYa, dVa, dTa, dExtraC, dCorsaTra, dCorsaYd, dCorsaVd, sYV) + -- svolge la fase di allontanamento dei carrelli per il recupero di 'ExtraV'/'ExtraY' + -- richiesto alle posizioni [--.xs2] delle funzioni SpecAdjustCarr.. + if sYV == 'V' then -- caso di ExtraV (ed eventuale ulteriore allontanamento di Y) + local dCorsaYTrA = dCorsaTra + local dExtraVn = dExtraC - dCorsaYTrA + -- eseguo allontanamento di Y e (V+T) + if dExtraVn / 2 <= dCorsaYd then + if dExtraVn / 2 <= dCorsaVd then + dYa = dYa + dExtraVn / 2 + dVa = dVa - dExtraVn / 2 + dTa = dTa - dExtraVn / 2 + else + dVa = dVa - dCorsaVd + dTa = dTa - dCorsaVd + dYa = dYa + min( dExtraVn - dCorsaVd, dCorsaYd) + end + else + dYa = dYa + dCorsaYd + dVa = dVa - min( dExtraVn - dCorsaYd, dCorsaVd) + dTa = dTa - min( dExtraVn - dCorsaYd, dCorsaVd) + end + end + + if sYV == 'Y' then -- caso di ExtraY (ed eventuale ulteriore allontanamento di V) + local dCorsaVTrA = dCorsaTra + local dExtraYn = -dExtraC - dCorsaVTrA + -- eseguo allontanamento di (Y+T) e V + if dExtraYn / 2 <= dCorsaVd then + if dExtraYn / 2 <= dCorsaYd then + dVa = dVa - dExtraYn / 2 + dYa = dYa + dExtraYn / 2 + dTa = dTa + dExtraYn / 2 + else + dYa = dYa + dCorsaYd + dTa = dTa + dCorsaYd + dVa = dVa - min( dExtraYn - dCorsaYd, dCorsaVd) + end + else + dVa = dVa - dCorsaVd + dYa = dYa + min( dExtraYn - dCorsaVd, dCorsaYd) + dTa = dTa + min( dExtraYn - dCorsaVd, dCorsaYd) + end + end + return dYa, dVa, dTa +end + +--------------------------------------------------------------------- +-- *** [A1] da carrello Y a Y : Y -> Y *** +--------------------------------------------------------------------- +function +SpecAdjustCarrA1( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF) + EgtOutLog( ' *[A1] = Y -> Y', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'Y -> Y'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + -- recupero le posizioni correnti dei carrelli + local dYPosA = dTPosI + dYDeltaI + local dVPosA = ParkV + local dTPosA = dTPosI + local dYDeltaA = dYDeltaI + local dVDeltaA = dVPosA - dTPosA + local dNewYDelta -- = dYDeltaF + local dCorsaYfc = MaxY - dYPosA + local dCorsaYd = min( dCorsaYfc, EMC.LB - dYDeltaI - MinJoin) + + -- tolleranza + local dYDeltaTol = GetDeltaTol( EMC.LB - dYDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y') + local bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + + if bYDeltaS then + dNewYDelta = dYDeltaF + dYDeltaTol/2 + else + dNewYDelta = dYDeltaA + end + EgtOutLog( ' YDeltaI=' .. EgtNumToString( dYDeltaI) .. ' TPosI=' .. EgtNumToString( dTPosI), 1) + EgtOutLog( ' YDeltaF=' .. EgtNumToString( dYDeltaF) .. ' NewYDelta=' .. EgtNumToString( dNewYDelta), 1) + -- flag per risalita resta a Zmax + local bZmaxOk = false + + -- **[A1Ys]** |pos. di Y cambia in modo significativo| + if bYDeltaS then + -- eventuale risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + -- definisco 'ExtraY' con (Y+T) e V accentrati q.b. per la presa con V + local dYPos, dVPos, dTPos = PosxExtraYV( dYPosA, dVPosA, dTPosA, MyMinY, MaxV, 'V') + local dNewY = dTPos + dNewYDelta + local dExtraY = dNewY - MyMinY + -- effettuo spostamenti di (Y+T) e V per predisporre all'aggancio di T con V + dYPosA = dYPos + dVPosA = dVPos + dTPosA = dTPos + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dVDeltaA = dVPosA - dTPosA + + -- **[A1Ys-x]** posizione di |Y non raggiungibile| (oltre MyMinY) + if dExtraY < 0 then + -- **[A1Ys-xs]** posizione di Y non raggiungibile, |con ExtraY 'significativo'| + if -dExtraY > dYDeltaTol /2 then + --EmitComment( vCmd, '[A1Ys-xs]') + -- calcolo le **corse disponibili dei carrelli a partire da Y e V c.s.** per allontanare q.p. (Y+T) e V + local dCorsaYfc = MaxY - dYPos + local dCorsaVfc = dVPos - MinV + local dDistFrN = (dVPos-dTPos) - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + local dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto **le corse di 'recupero'** dai due carrelli possibili riaccentrando Y e (V+T) + local dCorsaVTr = dCorsaVd + (MaxV - dVPos) + local dCorsaYr = dCorsaYTd + -- **[A1Ys-xsw]** posizione finale dNewV non raggiungibile, con |dEXtraY > CorsaVr + CorsaYr| + if -dExtraY > ( dCorsaVTr + dCorsaYr) and bYDeltaS then + EmitComment( vCmd, '[A1Ys-xsw]' .. 'CASO NON GESTITO') + return + end + + local dCorsaVTrA = MaxV - dVPos -- !! att.ne: non dVPosA !! + -- **[A1Ys-xs1]** se posso recuperare ExtraY semplicem' accentrando Y e (V+T) + -- (dalle posizione impostate sopra per l'aggancio di V) + if dCorsaVTrA >= -dExtraY then + EmitComment( vCmd, '[A1Ys-xs1]') + -- chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1: accentro** Y e (V+T) + dYPosA = MyMinY -- (pos. finale) + dVPosA = dVPosA + (-dExtraY) + dTPosA = dTPosA + (-dExtraY) + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dYDeltaA = dYPosA - dTPosA + + else -- **[A1Ys-xs2]** + -- ci sarebbe un doppio movimento di Y ? => caso impossibile ? + EmitComment( vCmd, '[A1Ys-xs2]') + -- **1:** posiziono (ulteriormente!) (Y+T) e V + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraY, dCorsaVTrA, dCorsaYTd, dCorsaVd, 'Y') + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + dVDeltaA = dVPosA - dTPosA + -- chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **2: accentro** Y e (V+T) + dYPosA = MyMinY -- (pos. finale) + dVPosA = MaxV + dTPosA = dVPosA - dVDeltaA + --dVDeltaA = dVPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [A1Ys-xs1/-xs2] + + -- **[A1Ys-xn]** |dExtraY ancora < 0 ma non 'significativo')| + else --if -dExtraY < DeltaToll/2 + EmitComment( vCmd, '[A1Ys-xn]') + -- chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1:** accentro Y + dExtraY = 0 + dYPosA = MyMinY -- (pos. finale) + table.insert( vCmd, { 1, 'Y', dYPosA}) + -- dYDeltaA = dYPosA - dTPosA + end --[A1Ys-xs/xn] + + -- **[A1Ys-r]** |posizione di Y raggiungibile| (ExtraY >=0) + -- (si esclude la possibilità di extra corsa oltre maxY) + else + EmitComment( vCmd, '[A1Ys-r]') + -- chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1:** posiziono Y alla posizione richiesta + dYPosA = dNewY + table.insert( vCmd, { 1, 'Y', dYPosA}) + end -- [A1Ys] + + -- calcolo il nuovo parametro di aggancio + dYDeltaA = dYPosA - dTPosA + -- chiudo Y e apro V + table.insert( vCmd, { 11, CalcCharStatus( 'Y', dYDeltaA)}) + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + -- imposto il nuovo parametro di aggancio + table.insert( vCmd, { 21, dYDeltaA, 0}) + + -- reset contatore + EMC.CNT = nil + + else -- **[A1Yns]** |spostamento| finale richiesto (ev' residuo) di |Y non 'significativo'| + EmitComment( vCmd, '[A1Yns]') + end --[A1Ys/ns] + + EgtOutLog(' YDeltaA =' .. EgtNumToString( dYDeltaA), 1) + + SpecOutputCNT() + return vCmd +end --SpecAdjustCarrA1 + +--------------------------------------------------------------------- +-- *** [A2] da entrambi a carrello Y : Y+V -> Y *** +--------------------------------------------------------------------- +function SpecAdjustCarrA2( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF) + EgtOutLog( ' *[A2] = Y+V -> Y ', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'Y+V -> Y'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + local dCorsaY = MaxY - MyMinY + local dCorsaV = MaxV - MinV + -- recupero le posizioni correnti dei carrelli + local dYPosA = dTPosI + dYDeltaI + local dVPosA = dTPosI + dVDeltaI + local dTPosA = dTPosI + local dYDeltaA = dYDeltaI + local dVDeltaA = dVDeltaI + local dNewYDelta -- = dYDeltaF + -- tolleranze + local dYDeltaTol = GetDeltaTol( EMC.LB - dYDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y') + local bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + + if bYDeltaS then + dNewYDelta = dYDeltaF + dYDeltaTol/2 + else + dNewYDelta = dYDeltaA + end + -- definisco 'ExtraY' + local dNewY = dTPosA + dNewYDelta + local dExtraY = dNewY - MyMinY -- < 0 = nuova pos. di Y 'non raggiungibile' (= oltre MyMinY) + -- definisco 'ExtraY significativo' + local bYxs = -dExtraY > dYDeltaTol/2 + + EgtOutLog( ' YDeltaI=' .. EgtNumToString( dYDeltaI) .. ' TPosI=' .. EgtNumToString( dTPosI) .. + ' VDeltaI=' .. EgtNumToString( dVDeltaI), 1) + EgtOutLog( ' YDeltaF=' .. EgtNumToString( dYDeltaF) .. ' NewYDelta=' .. EgtNumToString( dNewYDelta), 1) + -- flag per risalita resta a Zmax + local bZmaxOk = false + -- risalita testa a Zmax (da effettuare comunque, per il parcheggio di V) + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + -- calcoli preliminari in caso di spostamento richiesto per Y significativo + local dCorsaYfc, dCorsaVfc, dDistFrN, dCorsaYTd, dCorsaVd, dCorsaVTr, dCorsaYr, bXsw + if bYDeltaS then + if bYxs then + -- calcolo le **corse disponibili** dei carrelli **a partire dalle posizioni attuali** (=iniziali) + -- per allontanare q.p. (Y+T) e V + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto **le corse di 'recupero'** dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + (MaxV - dVPosA) + dCorsaYr = dCorsaYTd + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaYr + dCorsaVTr + end + end + + -- **[A2Ys-xsw]** posizione NewY non raggiungibile (oltre MyMinY), con ||dEXtraY | > CorsaYr + CorsaVTr| + while bXsw do + EmitComment( vCmd, '[A2Ys-xsw]') + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + -- chiudo eventualmente il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1:** allontano q.p. (Y+T) e V + dYPosA = dYPosA + dCorsaYTd + dTPosA = dTPosA + dCorsaYTd + dVPosA = dVPosA - dCorsaVd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + -- chiudo il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **2:** accentro Y e (V+T) + dYPosA = MyMinY + dVPosA = dVPosA + dCorsaVTr + dTPosA = dTPosA + dCorsaVTr + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + -- valuto Delta attuali + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + -- aggiorno l'extra corsa residua per Y + dExtraY = dExtraY + dCorsaYr + dCorsaVTr + bYxs = -dExtraY > dYDeltaTol/2 + -- **aggiorno la valutazione delle corse disponibili** + -- a partire da Y e V c.s. per allontanare q.p. (Y+T) e V + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + dCorsaYr = dCorsaYTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaVTr + dCorsaYr + end -- [A2Ys-xw] + + -- **[A2Ys]** se lo |spostamento| richiesto (ev' residuo) per |Y| è |'significativo'| + if bYDeltaS then + -- **[A2Ys-x]** se la |posizione per Y non è 'raggiungibile'| + if dExtraY < 0 then + -- **[A2Ys-xs]** se |ExtraY 'significativo'| + if bYxs then + local dCorsaVTrA = MaxV - dVPosA + -- **[A2Ys-xs1]** se posso recuperare ExtraY solo accentrando (V+T) e Y + if dCorsaVTrA >= -dExtraY then + EmitComment( vCmd, '[A2Ys-xs1]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1:** accentro (V+T) q.b. e Y + dVPosA = dVPosA + (-dExtraY) + dTPosA = dTPosA + (-dExtraY) + dYPosA = MyMinY -- (pos. finale) + --dYDeltaA = dYPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + else -- **[A2Ys-xs2]** + EmitComment( vCmd, '[A2Ys-xs2]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1:** allontano (Y+T) e V + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraY, dCorsaVTrA, dCorsaYTd, dCorsaVd, 'Y') + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + dVDeltaA = dVPosA - dTPosA + -- chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **2:** accentro Y e (V+T) q.b. per recupero di dExtraY + dYPosA = MyMinY + dVPosA = MaxV + dTPosA = dVPosA - dVDeltaA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end --[A2Ys-xs1/-xs2] + + -- [A2Ys-xn] |ExtraY ancora <= 0, ma 'non significativo'| + else --if dExtraY <= 0 then + EmitComment( vCmd, '[A2Ys-xn]') + dExtraY = 0 + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- 1: accentro Y + dYPosA = MyMinY -- (pos. finale) + table.insert( vCmd, { 1, 'Y', dYPosA}) + end -- [A2Ys-xs/xn] + + --[A2Ys-r] dExtrav > 0 ( |pos. Y'raggiungibile|) + else + EmitComment( vCmd, '[A2Ys-r]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- posizione Y + dYPosA = dTPosA + dNewYDelta -- (pos. finale) + table.insert( vCmd, { 1, 'Y', dYPosA}) + end -- [A2Ys-x/r] + + else -- [A2Yns] |spostamento Y| (ev' residuo) |non significativo| + EmitComment( vCmd, '[A2Yns]') + end -- [A2Ys/ns] + + -- calcolo i nuovi parametri di aggancio + dYDeltaA = dYPosA - dTPosA + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, CalcCharStatus( 'Y', dYDeltaA)}) + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + -- imposto i nuovi parametri di aggancio + table.insert( vCmd, { 21, dYDeltaA, 0}) + + EgtOutLog( ' YDeltaA =' .. EgtNumToString( dYDeltaA), 1) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() + return vCmd +end --SpecAdjustCarrA2 + +--------------------------------------------------------------------- +-- *** [A3] da carrello V a Y : V -> Y *** +--------------------------------------------------------------------- +function SpecAdjustCarrA3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF) + EgtOutLog( ' *[A3] = V -> Y', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'V -> Y'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + -- recupero le posizioni correnti + local dYPosA = ParkY + local dTPosA = dTPosI + local dVPosA = dTPosI + dVDeltaI + local dYDeltaA = dYPosA - dTPosA + local dVDeltaA = dVDeltaI + local dNewYDelta -- = dVDeltaF + -- tolleranza + local dYDeltaTol = GetDeltaTol( EMC.LB - dYDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y') + local bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bYDeltaS then + dNewYDelta = dYDeltaF + dYDeltaTol/2 + else + dNewYDelta = dYDeltaA + end + -- + EgtOutLog(' VDeltaI=' .. EgtNumToString( dVDeltaA) .. ' YDeltaI(Park)='.. EgtNumToString( dYDeltaA).. + ' TPosI=' .. EgtNumToString( dTPosI) , 1) + EgtOutLog(' YDeltaF=' .. EgtNumToString( dYDeltaF) .. ' NewYDelta=' .. EgtNumToString( dNewYDelta) , 1) + local bZmaxOk = false + -- risalita testa a Zmax (da effettuare comunque, dato lo scambio di carrelli) + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + -- calcoli preliminari in caso di spostamento richiesto per Y significativo + local dYPos, dVPos, dTPos + local dNewY, dExtraY, bYxs + local dCorsaYfc, dCorsaVfc, dDistFrN, dCorsaYTd, dCorsaVd, dCorsaVTr, dCorsaYr, bXsw + if bYDeltaS then + -- definisco 'ExtraY' con Y e (V+T) accentrati q.b. per la presa con Y + dYPos, dVPos, dTPos = PosxExtraYV( dYPosA, dVPosA, dTPosA, MyMinY, MaxV, 'Y') + dNewY = dTPos + dNewYDelta + dExtraY = dNewY - MyMinY --( <0 <=> pos. 'non raggiungibile') + bYxs = -dExtraY > dYDeltaTol/2 + if bYxs then + -- calcolo le **corse disponibili dei carrelli a partire da Y e V c.s.** per allontanare q.p. (Y+T) e V + dCorsaYfc = MaxY - dYPos + dCorsaVfc = dVPos - MinV + --local dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dDistFrN = (dVPos-dTPos) - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto **le corse di 'recupero'** dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + (MaxV - dVPos) + dCorsaYr = dCorsaYTd + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaVTr + dCorsaYr + end + -- inizializzo + dYPosA = dYPos + dVPosA = dVPos + dTPosA = dTPos + end + + -- **[A3Ys-xsw]** posizione finale dNewY non raggiungibile, con |dEXtraY > CorsaVr + CorsaYr| + while bXsw do + EmitComment( vCmd, '[A3Ys-xsw]') + -- |1:| posiziono (V+T) e Y come calcolato sopra + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo ev' il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- |2:| allontano (Y+T) e V quanto possibile + dYPosA = dYPosA + dCorsaYTd + dTPosA = dTPosA + dCorsaYTd + dVPosA = dVPosA - dCorsaVd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- |3:| accentro (V+T) e Y + dVPosA = dVPosA + dCorsaVTr + dTPosA = dTPosA + dCorsaVTr + dYPosA = MyMinY + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- valuto i Delta ottenuti + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + -- aggiorno ExtraY + dExtraY = dExtraY + dCorsaYr + dCorsaVTr + -- **aggiorno la valutazione delle corse disponibili** + -- a partire da Y e V c.s. per allontanare q.p. (Y+T) e V + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + dCorsaYr = dCorsaYTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaVTr + dCorsaYr + end --[A3Ys-xw] + + -- **[A3Ys]** |spostamento| richiesto (ev' residuo) |di Y| |'significativo'| + if bYDeltaS then + EmitComment( vCmd, '[A3Ys]') + -- **[A3Ys-x]** posizione di |Y non raggiungibile| + if dExtraY < 0 then + + -- **[A3Ys-xs]** |pos. NewY non raggiungibile, con ExtraY 'significativo'| + -- ( -dExtraY <= (CorsaYr+CorsaVr) da ciclo precedente ) + if bYxs then + local dCorsaVTrA = MaxV - dVPosA + -- **[A3Ys-xs1]** se posso recuperare ExtraY semplicem' accentrando Y e (V+T) + -- ulteriormente rispetto a YPos e Vpos definiti c.s. + if dCorsaVTrA >= -dExtraY then + EmitComment( vCmd, '[A3Ys-xs1]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1: accentro** Y e (V+T) + dYPosA = MyMinY -- (pos. finale) + dVPosA = dVPosA - dExtraY + dTPosA = dTPosA - dExtraY + dYDeltaA = dYPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + else -- **[A3Ys-xs2]** + EmitComment( vCmd, '[A3Ys-xs2]') + + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1: accentro** ev' Y e (V+T) alle posizioni impostate + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dYDeltaA = dYPosA - dTPosA + + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **2: allontano** (Y+T) e V + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraY, dCorsaVTrA, dCorsaYTd, dCorsaVd, 'Y') + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + dVDeltaA = dVPosA - dTPosA + + -- chiudo il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **3: accentro** Y e (V+T) + dYPosA = MyMinY -- (pos. finale) + dVPosA = MaxV + dTPosA = dVPosA - dVDeltaA + --dYDeltaA = dYPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [A3Ys-xs1/-xs2] + + -- **[A3Ys-xn]** |dExtraY ancora < 0 ma non 'significativo')| + else --if -dExtraY < DeltaToll/2 + EmitComment( vCmd, '[A3Ys-xn]') + -- ev' chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1:** accentro Y e porto (V+T) alla posizione impostata + dExtraY = 0 + dYPosA = MyMinY -- (pos. finale) + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end --[A3Ys-xs/xn] + + -- **[A3Ys-r]** |posizione di Y raggiungibile (ExtraY >=0)| + else + EmitComment( vCmd, '[A3Ys-r]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- posizione Y in posizione finale ed ev' (V+T) come impostato sopra + dYPosA = dTPosA + dNewYDelta + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [A3Ys] + + else -- **[A3Yns]** |spostamento| finale richiesto (ev' residuo) di |Y non 'significativo'| + EmitComment( vCmd, '[A3Yns]') + end --[A3Ys/ns] + + -- calcolo il nuovo parametro di aggancio + dYDeltaA = dYPosA - dTPosA + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, CalcCharStatus( 'Y', dYDeltaA)}) + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + -- imposto il nuovo parametro di aggancio + table.insert( vCmd, { 21, dYDeltaA, 0}) + + EgtOutLog( ' YDeltaA =' .. EgtNumToString( dYDeltaA), 1) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() + return vCmd +end --SpecAdjustCarrA3 + +--------------------------------------------------------------------- +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 + +--------------------------------------------------------------------- +-- *** [B1] da carrello Y a entrambi : Y -> Y+V *** +--------------------------------------------------------------------- +function SpecAdjustCarrB1( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + EgtOutLog( ' *[B1] = Y -> Y+V', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'Y -> Y+V'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + local dCorsaY = MaxY - MyMinY + local dCorsaV = MaxV - MinV + -- recupero le posizioni correnti + local dYPosA = dTPosI + dYDeltaI + local dVPosA = ParkV + local dTPosA = dTPosI + local dYDeltaA = dYDeltaI + local dVDeltaA = dVPosA - dTPosA + local dNewYDelta + local dNewVDelta + -- incremento la distanza tra le due posizioni ( se abilitato e possibile) + local dYDeltaAgg, dVDeltaAgg = AdjustPositionsForB( dYDeltaF, dVDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta) + -- tolleranze + local dYDeltaTol = dYDeltaAgg + GetDeltaTol( EMC.LB - dYDeltaF - dYDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y', bFixedDelta) + local dVDeltaTol = dVDeltaAgg + GetDeltaTol( dVDeltaF - dVDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + -- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze + local bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + local bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bYDeltaS then + dNewYDelta = dYDeltaF + dYDeltaTol / 2 + else + dNewYDelta = dYDeltaA + end + if bVDeltaS then + dNewVDelta = dVDeltaF - dVDeltaTol / 2 + else + dNewVDelta = dVDeltaA + end + + EgtOutLog(' YDeltaI=' .. EgtNumToString( dYDeltaA) .. ' VDeltaI(Park)='.. EgtNumToString( dVDeltaA) .. + ' TPosI='.. EgtNumToString( dTPosI), 1) + EgtOutLog(' YDeltaF=' .. EgtNumToString( dYDeltaF) .. ' VDeltaF=' .. EgtNumToString( dVDeltaF), 1) + EgtOutLog(' NewYDelta=' .. EgtNumToString( dNewYDelta) .. ' NewVDelta=' .. EgtNumToString( dNewVDelta), 1) + + -- risalita testa a Zmax + local bZmaxOk = false + + -- calcoli preliminari in caso di spostamento richiesto per V significativo + local dYPos, dVpos, dTPos + local dNewV, dExtraV, bVxs + local dCorsaYfc, dCorsaVfc, dDistBkN, dCorsaYd, dCorsaVTd, dCorsaYTr, dCorsaVr, bXsw + if bVDeltaS then + -- definisco 'ExtraV' con (Y+T) e V accentrati q.b. per la presa di V + dYPos, dVPos, dTPos = PosxExtraYV( dYPosA, dVPosA, dTPosA, MyMinY, MaxV, 'V') + dNewV = dTPos + dNewVDelta + dExtraV = dNewV - MaxV -- se > 0 pos. V non direttamente 'raggiungibile' + bVxs = dExtraV > dVDeltaTol/2 -- ExtraV 'significativo' + if bVxs then + -- calcolo le **corse disponibili** dei carrelli a partire da Y e V c.s.| + -- per allontanare q.p. Y e (V+T) + dCorsaYfc = MaxY - dYPos + dCorsaVfc = dVPos - MinV + dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- valuto le **corse di 'recupero'** dai due carrelli possibili riaccentrando (Y+T) e V + dCorsaYTr = dCorsaYd + (dYPos - MyMinY) + dCorsaVr = dCorsaVTd + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaVr + dCorsaYTr + end + -- inizializzo + dYPosA = dYPos + dVPosA = dVPos + dTPosA = dTPos + end + + -- **[B1Vs-xsw]** posizione finale dNewV non raggiungibile, con |dEXtraV > CorsaVr + CorsaYr| + while bXsw do + EmitComment( vCmd, '[B1Vs-xsw]') + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + -- |1:| imposto (Y+T) e V come calcolato sopra + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- |2:| allontano Y e (V+T) quanto possibile + dYPosA = dYPosA + dCorsaYd + dVPosA = dVPosA - dCorsaVTd + dTPosA = dTPosA - dCorsaVTd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- |3:| accentro (Y+T) e V + dYPosA = dYPosA - dCorsaYTr + dTPosA = dTPosA - dCorsaYTr + dVPosA = MaxV + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- valuto i Delta ottenuti + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- aggiorno l'extra corsa residuo per V + dExtraV = dExtraV - dCorsaYTr - dCorsaVr + + -- **aggiorno la valutazione delle corse disponibili** + -- a partire da Y e V c.s. per allontanare q.p. Y e (V+T) + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- aggiorno i prossimi recuperi disponibili + dCorsaYTr = dCorsaYd + dCorsaVr = dCorsaVTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaVr + dCorsaYTr + end --[B1Vs-xw] + + -- **[B1Vs]** se lo |spostamento| finale richiesto (ev' residuo) di |V| è |'significativo'| + if bVDeltaS then + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + -- **[B1Vs-x]** posizione di |V non raggiungibile| + if dExtraV > 0 then + -- **[B1Vs-xs]** |ExtraV 'signfificativo'| + -- (ExtraV <= (CorsaYr+CorsaVr) da ciclo precedente ) + if bVxs then + local dCorsaYTrA = dYPosA - MyMinY + local dCorsaVra = MaxV - dVPosA + -- **[B1Vs-xs1]** se posso recuperare ExtraV semplicem' accentrando V e (Y+T) + -- ulteriormente rispetto a YPos e Vpos definiti c.s. + if dCorsaYTrA >= dExtraV then + EmitComment( vCmd, '[B1Vs-xs1]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1: accentro** (Y+T) e V + dYPosA = dYPosA - dExtraV + dTPosA = dTPosA - dExtraV + dVPosA = MaxV -- (pos. finale) + dVDeltaA = dVPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + else -- **[B1Vs-xs2]** + EmitComment( vCmd, '[B1Vs-xs2]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1: accentro** ev' (Y+T) e V alle posizioni impostate + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dVDeltaA = dVPosA - dTPosA + + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **2: allontano** (V+T) e Y + -- tenendo conto di dover 'recuperare' ExtraV.... + local dYPos1, dVPos1, dTPos1 = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraV, dCorsaYTrA, dCorsaYd, dCorsaVTd, 'V') + local dYDispl1 = dYPos1 - dYPosA + local dVDispl1 = dVPos1 - dVPosA + --local dTDispl1 = dTPos1 - dTPosA + local dYDeltaDiff = dNewYDelta - (dYPos1 - dTPos1) + -- ...e anche di posizionare possibilmente Y alla posizione finale + if dYDeltaDiff > 0 then + dCorsaYfc = MaxY - dYPos1 + dCorsaVfc = dVPos1 - MinV + dDistBkN = EMC.LB - (dYPos1-dTPos1) - MinJoin - EMC.TCING -- DistBack1 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPos1, dVPos1, dTPos1, dYDeltaDiff, 0, dCorsaYd, dCorsaVTd, 'V') + else + dYPosA = dYPos1; dVPosA = dVPos1; dTPosA = dTPos1 + end + + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + + -- chiudo il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **3: accentro** (Y+T) e V + dYPosA = dYPosA - dYDispl1 - dCorsaYTrA -- POS. FINALE + dTPosA = dTPosA - dYDispl1 - dCorsaYTrA + dVPosA = dVPosA - dVDispl1 + dCorsaVra -- POS. FINALE + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [B1Vs-xs1/-xs2] + + -- **[B1Vs-xn]** |dExtraV ancora > 0 ma non 'significativo')| + else --if dExtraV < DeltaToll/2 + EmitComment( vCmd, '[B1Vs-xn]') + -- ev' chiudo Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- 1: accentro (Y+T) alla posizione impostate e V al max + dExtraV = 0 + dVPosA = MaxV -- (pos. finale) + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [B1s-xs/xn] + + -- **[B1Vs-r]** |dExtraV < 0 (pos. V raggiungibile)| + else + EmitComment( vCmd, '[B1Vs-r]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- posiziono ev' (Y+T) come impostato sopra e V in posizione finale + dVPosA = dTPosA + dNewVDelta + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [B1Vs] + + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + + else -- **[B1Vns]** |spostamento| finale richiesto (ev' residuo) di |V non 'significativo'| + EmitComment( vCmd, '[B1Vns]') + if SpecTestOnlyRemarkInCmds( vCmd) then + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + -- emetto posizione di V + table.insert( vCmd, { 1, 'V', dVPosA}) + end + end -- [B1-s/ns] + + -- aggiorno la verifica di movimento 'significativo' per Y + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + -- **[B1Ys]** Se vi è uno |spostamento residuo di Y significativo'| + if bYDeltaS then + EmitComment( vCmd, '[B1Ys]') + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + local dNewY = dTPosA + dNewYDelta + local dExtraY = dNewY - MyMinY + -- **[B1Ys-r]** se pos. NewY è raggiungibile direttamente + if dExtraY >= 0 then --dNewY > MyMinY then + EmitComment( vCmd, '[B1Ys-r]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y + dYPosA = dTPosA + dNewYDelta + table.insert( vCmd, { 1, 'Y', dYPosA}) + + -- **[B1Ys-xn]** se pos. NewY non è raggiungibile direttamente, ma ExtraY non è 'significativo' + elseif -dExtraY <= dYDeltaTol / 2 then + EmitComment( vCmd, '[B1Ys-xn]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- accentro Y + dYPosA = MyMinY + table.insert( vCmd, { 1, 'Y', dYPosA}) + -- [B1sY-nr.xs] ma ExtraY 'significativo' + + else -- **[B1Ys-xs]** + EmitComment( vCmd, '[B1Ys-xs]') + EgtOutLog( ' CLAMP : caso [B1Ys-xs] non gestito') + error( ' CLAMP : caso [B1Ys-xs] non gestito') + + end --[B1Ys-r/-nr] + else -- [B1Yns] spostamento residuo di Y non significativo + EmitComment( vCmd, '[B1Yns]') + end -- [B1Ys/ns] + + -- calcolo i nuovi parametri di aggancio + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- se non emessi movimenti, imposto posizione V + if not bZmaxOk then + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + table.insert( vCmd, { 1, 'V', dVPosA}) + end + -- imposto stato carrelli, per eventuale uso pressori (sempre eseguita risalita Z) + table.insert( vCmd, { 11, CalcCharStatus( 'Y', dYDeltaA)}) + table.insert( vCmd, { 12, CalcCharStatus( 'V', dVDeltaA)}) + -- imposto i nuovi parametri di aggancio + table.insert( vCmd, { 21, dYDeltaA, dVDeltaA}) + + EgtOutLog( ' YDeltaA =' .. EgtNumToString( dYDeltaA) .. ' VDeltaA =' .. EgtNumToString( dVDeltaA), 1) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() + return vCmd +end -- SpecAdjustCarrB1 + +--------------------------------------------------------------------- +-- *** [B2] da entrambi a entrambi i carrelli : Y+V -> Y+V *** +--------------------------------------------------------------------- +function SpecAdjustCarrB2( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + EgtOutLog( ' *[B2] = Y+V -> Y+V', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'Y+V -> Y+V'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + -- recupero le posizioni correnti + local dYPosA = dTPosI + dYDeltaI + local dVPosA = dTPosI + dVDeltaI + local dTPosA = dTPosI + local dYDeltaA = dYDeltaI + local dVDeltaA = dVDeltaI + local dNewYDelta + local dNewVDelta + -- incremento la distanza tra le due posizioni ( se abilitato e possibile) + local dYDeltaAgg, dVDeltaAgg = AdjustPositionsForB( dYDeltaF, dVDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta) + -- tolleranze + local dYDeltaTol = dYDeltaAgg + GetDeltaTol( EMC.LB - dYDeltaF - dYDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y', bFixedDelta) + local dVDeltaTol = dVDeltaAgg + GetDeltaTol( dVDeltaF - dVDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + -- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze + local bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + local bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bYDeltaS then + dNewYDelta = dYDeltaF + dYDeltaTol / 2 + else + dNewYDelta = dYDeltaA + end + if bVDeltaS then + dNewVDelta = dVDeltaF - dVDeltaTol / 2 + else + dNewVDelta = dVDeltaA + end + -- definisco 'ExtraY' e ExtraV' + local dNewY = dTPosA + dNewYDelta + local dNewV = dTPosA + dNewVDelta + local dExtraY = dNewY - MyMinY -- < 0 => nuova pos. di Y 'non raggiungibile' + local dExtraV = dNewV - MaxV -- > 0 => nuova pos. di V 'non raggiungibile' + local bYxs = -dExtraY > dYDeltaTol/2 + local bVxs = dExtraV > dVDeltaTol/2 + + EgtOutLog( ' YDeltaI=' .. EgtNumToString( dYDeltaI) .. ' VDeltaI=' .. EgtNumToString( dVDeltaI) .. + ' TPosI='.. EgtNumToString( dTPosI), 1) + EgtOutLog( ' YDeltaF=' .. EgtNumToString( dYDeltaF) .. ' VDeltaF=' .. EgtNumToString( dVDeltaF), 1) + EgtOutLog( ' NewYDelta=' .. EgtNumToString( dNewYDelta) .. ' NewVDelta=' .. EgtNumToString( dNewVDelta), 1) + -- flag risalita a Zmax + local bZmaxOk = false + + -- **[B2V]** |accentramento di V| + if dVDeltaF > dVDeltaI then + EmitComment( vCmd, '[B2V]') + + -- calcoli preliminari in caso di spostamento richiesto per V significativo + local dCorsaYfc, dCorsaVfc, dDistBkN, dCorsaYd, dCorsaVTd, dCorsaYTr, dCorsaVr, bXsw + if bVDeltaS then + -- eventuale risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + if bVxs then + -- calcolo le corse disponibili dei carrelli **dalle posizioni iniziali** + -- per allontanare Y e (V+T) + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- calcolo le corse di 'recupero' accentrando (Y+T) e V dopo l'allontanamento + dCorsaYTr = dCorsaYd + (dYPosA - MyMinY) + dCorsaVr = dCorsaVTd -- ((MaxV-dNewV) non fa parte del recupero in quanto già disponibile!) + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaYTr + dCorsaVr + end + end + + -- **[B2V-xsw]** posizione NewV non raggiungibile, con |dEXtraV > CorsaVr + CorsaYTr| + -- e spostamento richiesto di V significativo; + while bXsw do + EmitComment( vCmd, '[B2V-xsw]') + + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1**: allontano Y e V(+T) quanto possibile + dYPosA = dYPosA + dCorsaYd + dVPosA = dVPosA - dCorsaVTd + dTPosA = dTPosA - dCorsaVTd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **2:** accentro (Y+T) e V + dYPosA = dYPosA - dCorsaYTr -- = MyMinY + dTPosA = dTPosA - dCorsaYTr + dVPosA = MaxV + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- valuto Delta ottenuti + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- aggiorno ExtraV residuo + dExtraV = dExtraV - dCorsaYTr - dCorsaVr + -- **aggiorno i recuperi disponibili** riallontanando Y e (V+T) e riaccentrando (Y+T) e V + dCorsaYfc = dCorsaY -- MaxY - dNewY + dCorsaVfc = dCorsaV -- dNewV - MinV + dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + dCorsaYTr = dCorsaYd + dCorsaVr = dCorsaVTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaYTr + dCorsaVr + end -- [B2V-xsw] + + + --[B2Vs] |accentramento| (ev' residuo) |di V 'significativo'| + if bVDeltaS then + --[B2Vs-x] accentramento di V 'significativo' |con pos. NewV 'non raggiungibile'|(= oltre MaxV) + if dExtraV > 0 then + -- (ExtraV <= (CorsaYTr+CorsaVr) da ciclo precedente) + --[B2Vs-xs] accentramento di V con |ExtraV 'significativo'| + if bVxs then + local dCorsaYTrA = dYPosA - MyMinY + local dCorsaVra = MaxV - dVPosA + -- **[B2Vs-xs1]** se posso recuperare ExtraV solo accentrando V e (Y+T) + if dCorsaYTrA >= dExtraV then + EmitComment( vCmd, '[B2Vs-xs1]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1:** accentro (Y+T) q.b. e V + dYPosA = dYPosA - dExtraV + dTPosA = dTPosA - dExtraV + dVPosA = MaxV -- (pos. finale) + dExtraV = 0 + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + else -- **[B2Vs-xs2]** + EmitComment( vCmd, '[B2Vs-xs2]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1: allontano** (V+T) e Y + -- tenendo conto di dover 'recuperare' ExtraV... + local dYPos1, dVPos1, dTPos1 = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraV, dCorsaYTrA, dCorsaYd, dCorsaVTd, 'V') + local dYDispl1 = dYPos1 - dYPosA + local dVDispl1 = dVPos1 - dVPosA + --local dTDispl1 = dTPos1 - dTPosA + local dYDeltaDiff = dNewYDelta - (dYPos1 - dTPos1) + -- ...e anche possibilmente di posizionare Y alla posizione finale + if dYDeltaDiff > 0 then + dCorsaYfc = MaxY - dYPos1 + dCorsaVfc = dVPos1 - MinV + dDistBkN = EMC.LB - (dYPos1-dTPos1) - MinJoin - EMC.TCING -- DistBack1 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + --dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPos1, dVPos1, dTPos1, dYDeltaDiff, 0, dCorsaYd-dYDispl1, dCorsaVTd+dVDispl1, 'V') + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPos1, dVPos1, dTPos1, dYDeltaDiff, 0, dCorsaYd, dCorsaVTd, 'V') + else + dYPosA = dYPos1; dVPosA = dVPos1; dTPosA = dTPos1 + end + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + -- chiudo il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **2: accentro** (Y+T) e V + dYPosA = dYPosA - dYDispl1 - dCorsaYTrA -- POS. FINALE + dTPosA = dTPosA - dYDispl1 - dCorsaYTrA + dVPosA = dVPosA - dVDispl1 + dCorsaVra -- POS. FINALE + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [B2Vs-xs1/xs2] + + -- **[B2Vs-xn]** |dExtraV non 'significativo'| + else + EmitComment( vCmd, '[B2Vs-xn]') + dExtraV = 0 + -- ev' chiudo Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- 1: posiziono V assumendo maxV come pos. finale + dVPosA = MaxV -- (pos finale) + table.insert( vCmd, { 1, 'V', dVPosA}) + end -- [B2Vs-xs/xn] + + -- **[B2Vs-r]** accentramento di |V| 'significativo' con pos.|'raggiungibile'| (= non oltre MaxV) + else + EmitComment( vCmd, '[B2Vs-r]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- 1: posiziono V -- (pos finale) + dVPosA = dTPosA + dNewVDelta + dExtraV = 0 + table.insert( vCmd, { 1, 'V', dVPosA}) + end --[B2Vs] + + -- **[B2Vns]** accentramento di V non 'significativo'| + else + EmitComment( vCmd, '[B2Vns]') + dExtraV = 0 + end --[B2Vs/ns] + end --[B2V] ( accentramento di V) + + -- --------------------------------------------------------------------------- + -- **[B2Y]** |accentramento di Y| + if dYDeltaF < dYDeltaI then + EmitComment( vCmd, '[B2Y]') + + -- calcoli preliminari in caso di spostamento richiesto per Y significativo + local dCorsaYfc, dCorsaVfc, dDistFrN, dCorsaYTd, dCorsaVd, dCorsaVTr, dCorsaYr + if bYDeltaS then + -- eventuale risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + if bYxs then + -- calcolo le **corse disponibili** dei carrelli dalle posizioni iniziali + -- per allontanare (Y+T) e V + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + (MaxV - dVPosA) + dCorsaYr = dCorsaYTd + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaVTr + dCorsaYr + end + end + + -- **[B2Ys-xsw]** |-dEXtraY > dCorsaYr + dCorsaVTr| + while bXsw do + EmitComment( vCmd, '[B2Y-xsw]') + + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- |1:| allontano (Y+T) e V quanto possibile + dYPosA = dYPosA + dCorsaYTd + dTPosA = dTPosA + dCorsaYTd + dVPosA = dVPosA - dCorsaVd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + + -- |2:| accentro Y e (V+T) + dYPosA = MyMinY -- = dYPosA - dCorsaYr + dVPosA = dVPosA + dCorsaVTr -- = MaxV + dTPosA = dTPosA + dCorsaVTr + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- valuto Delta 'attuali' + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- aggiorno ExtraY residuo + dExtraY = dExtraY + dCorsaYr + dCorsaVTr + -- aggiorno i recuperi disponibili riallontanando (Y+T) V e riaccentrando succ' Y e (V+T) + dCorsaYfc = dCorsaY -- MaxY - dNewY + dCorsaVfc = dCorsaV -- dNewV - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + dCorsaYr = dCorsaYTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaVTr + dCorsaYr + end -- [B2Ys-xsw] + + -- **[B2Ys]** |accentramento di Y 'significativo'| + if bYDeltaS then + -- **[B2Ys-x]** accentramento di Y 'significativo' |con pos. NewY 'non raggiungibile'|(= oltre MyMinY) + if dExtraY < 0 then + -- (-ExtraY <= (dCorsaYr + dCorsaVTr ) a ciclo precedente + -- **[B2Ys-xs]** accentramento di Y con |'ExtraY 'significativo'| + if bYxs then + local dCorsaVTrA = MaxV - dVPosA + local dCorsaYra = dYPosA - MyMinY + -- **[B2Ys-xs1]** se posso recuperare ExtraY solo accentrando Y e (V+T) + if dCorsaVTrA >= -dExtraY then + EmitComment( vCmd, '[B2Ys-xs1]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- accentro Y e (V+T) q.b. + dYPosA = MyMinY -- (pos. finale) + dVPosA = dVPosA - dExtraY -- = +(-dEXtraY) + dTPosA = dTPosA - dExtraY -- = +(-dEXtraY) + dExtraY = 0 + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + else -- **[B2Ys-xs2]** + EmitComment( vCmd, '[B2Ys-xs2]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1: allontano** (Y+T) e V + -- tenendo conto di dover 'recuperare' ExtraY... + dYPos1, dVPos1, dTPos1 = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraY, dCorsaVTrA, dCorsaYTd, dCorsaVd, 'Y') + local dYDispl1 = dYPos1 - dYPosA + local dVDispl1 = dVPos1 - dVPosA + local dVDeltaDiff = dNewVDelta - (dVPos1 - dTPos1) + -- ...e anche possibilmente di posizionare V alla posizione finale + if dVDeltaDiff < 0 then + dCorsaYfc = MaxY - dYPos1 + dCorsaVfc = dVPos1 - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront1 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPos1, dVPos1, dTPos1, dVDeltaDiff, 0, dCorsaYTd, dCorsaVd, 'Y') + else + dYPosA = dYPos1; dVPosA = dVPos1; dTPosA = dTPos1 + end + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + --dVDeltaA = dVPosA - dTPosA + -- chiudo il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- |2:| accentro Y e (V+T) + dYPosA = dYPosA - dYDispl1 - dCorsaYra -- POS. FINALE + dVPosA = dVPosA - dVDispl1 + dCorsaVTrA -- POS. FINALE + dTPosA = dTPosA - dVDispl1 + dCorsaVTrA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [B2Ys-xs1/xs2] + + -- **[B2Ys-xn]** |dExtraY non 'significativo'| + else + EmitComment( vCmd, '[B2Ys-xn]') + dExtraY = 0 + -- ev' chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- 1: posiziono Y assumendo MyMinY come pos. finale + dYPosA = MyMinY -- (pos finale) + table.insert( vCmd, { 1, 'Y', dYPosA}) + end -- [B2Ys-xs/xn] + + --[B2Ys-r] accentramento di |Y| 'significativo' con pos.|'raggiungibile'| (non oltre MyMinY) + else + EmitComment( vCmd, '[B2Ys-r]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- |1:| posiziono Y -- (pos finale) + dYPosA = dTPosA + dNewYDelta + dExtraV = 0 + table.insert( vCmd, { 1, 'Y', dYPosA}) + end --[B2Ys] + + -- [B2Yns] accentramento di V non 'significativo'| + else + EmitComment( vCmd, '[B2Yns]') + dExtraV = 0 + end --[B2Ys/ns] + end --[B2Y] ( accentramento di V) + + -- ricalcolo gli 'spostamenti significativi' + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + + -- ------------------------------------------------------------------------------------------ + -- **[B2C]** |Spostamenti| di Y e/o V (ev' |residui| da cicli precedenti) + -- ++ possono essere solo allontanamenti ? +++++++++++++++++++++ + EmitComment( vCmd, '[B2C]') + -- **[B2Cs]** se c'è uno |spostamento (ev' residuo) significativo| + if bYDeltaS or bVDeltaS then + -- **[B2CYs]** se lo |spostamento (ev' residuo) di Y è 'significativo'| + if bYDeltaS then + EmitComment( vCmd, '[B2CYs]') + -- eventuale risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + local dNewY = dTPosA + dNewYDelta + local dExtraY = dNewY - MyMinY + + -- **[B2CYs-r]** se posizione di |Y raggiungibile| + if dExtraY >= 0 and dNewY <= MaxY then + EmitComment( vCmd, '[B2CYs-r]') + -- chiudo eventualmente V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y + dYPosA = dNewY + table.insert( vCmd, { 1, 'Y', dYPosA}) + -- **[B2CYs-nr]** + else + EmitComment( vCmd, '[B2CYs-nr]') + EgtOutLog( ' CLAMP : posizione Y non raggiungibile' .. '- caso [B2Ys-nr] non gestito') + error( 'CLAMP : posizione Y non raggiungibile') + end + end -- [B2CYs] + + -- **[B2CVs]** se lo |spostamento (ev' residuo) di V è 'significativo'| + if bVDeltaS then + EmitComment( vCmd, '[B2CVs]') + -- eventuale risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + local dNewV = dTPosA + dNewVDelta + local dExtraV = dNewV - MaxV + + -- **[B2CVs-r]** se posizione NewV raggiungibile + if dExtraV <= 0 and dNewV >= MinV then + EmitComment( vCmd, '[B2CVs-r]') + -- chiudo eventualmente Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V + dVPosA = dNewV + table.insert( vCmd, { 1, 'V', dVPosA}) + -- **[B2CVs-nr]** + else -- se ExtraV > 0 anche se non significativo + EmitComment( vCmd, '[B2CVs-nr]') + EgtOutLog( ' CLAMP : posizione V non raggiungibile' .. '- caso [B2cVs-nr] non gestito') + error( 'CLAMP : posizione V non raggiungibile') + end + end --[B2CsV] + + -- **[B2Cn]** |nessuno spostamento (ev' residuo significativo)| + else + EmitComment( vCmd, '[B2Cn]') + end -- [B2C] + + -- calcolo i nuovi parametri di aggancio + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- imposto stato carrelli, per eventuale uso pressori + table.insert( vCmd, { 11, CalcCharStatus( 'Y', dYDeltaA)}) + table.insert( vCmd, { 12, CalcCharStatus( 'V', dVDeltaA)}) + -- imposto i nuovi parametri di aggancio + table.insert( vCmd, { 21, dYDeltaA, dVDeltaA}) + + EgtOutLog( ' YDeltaA =' .. EgtNumToString( dYDeltaA) .. ' VDeltaA =' .. EgtNumToString( dVDeltaA), 1) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() + return vCmd +end --SpecAdjustCarrB2 + +--------------------------------------------------------------------------------------------------------- +-- *** [B3] da carrello V a entrambi i carrelli : V -> Y+V *** +--------------------------------------------------------------------------------------------------------- +function SpecAdjustCarrB3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + EgtOutLog( ' *[B3] = V -> Y+V', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'V -> Y+V'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + local dCorsaY = MaxY - MyMinY + local dCorsaV = MaxV - MinV + -- recupero le posizioni correnti + local dVPosA = dTPosI + dVDeltaI + local dYPosA = ParkY + local dTPosA = dTPosI + local dVDeltaA = dVDeltaI + local dYDeltaA = dYPosA - dTPosA + local dNewYDelta + local dNewVDelta + -- incremento la distanza tra le due posizioni ( se abilitato e possibile) + local dYDeltaAgg, dVDeltaAgg = AdjustPositionsForB( dYDeltaF, dVDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta) + -- tolleranze + local dYDeltaTol = dYDeltaAgg + GetDeltaTol( EMC.LB - dYDeltaF - dYDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y', bFixedDelta) + local dVDeltaTol = dVDeltaAgg + GetDeltaTol( dVDeltaF - dVDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + -- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze + local bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + local bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bYDeltaS then + dNewYDelta = dYDeltaF + dYDeltaTol / 2 + else + dNewYDelta = dYDeltaA + end + if bVDeltaS then + dNewVDelta = dVDeltaF - dVDeltaTol / 2 + else + dNewVDelta = dVDeltaA + end + + EgtOutLog( ' YDeltaI(Park)='.. EgtNumToString( dYDeltaA)..' VDeltaI=' .. EgtNumToString( dVDeltaA) .. + ' TPosI='.. EgtNumToString( dTPosI), 1) + EgtOutLog( ' YDeltaF=' .. EgtNumToString( dYDeltaF) .. ' VDeltaF=' .. EgtNumToString( dVDeltaF), 1) + EgtOutLog( ' NewYDelta=' .. EgtNumToString( dNewYDelta) .. ' NewVDelta=' .. EgtNumToString( dNewVDelta), 1) + -- risalita testa a Zmax + local bZmaxOk = false + + -- calcoli preliminari in caso di spostamento richiesto per Y significativo + local dYPos, dVPos, dTPos + local dNewY, dExtraY, bYxs + local dCorsaYfc, dCorsaVfc, dDistFrN, dCorsaYTd, dCorsaVd, dCorsaVTr, dCorsaYr, bXsw + if bYDeltaS then + -- definisco 'ExtraY' con (V+T) e Y accentrati q.b. per la presa di Y + dYPos, dVPos, dTPos = PosxExtraYV( dYPosA, dVPosA, dTPosA, MyMinY, MaxV, 'Y') + dNewY = dTPos + dNewYDelta + dExtraY = dNewY - MyMinY -- se < 0 pos. Y non direttamente 'raggiungibile' + bYxs = -dExtraY > dYDeltaTol/2 -- ExtraY 'significativo' + if bYxs then + -- calcolo le **corse disponibili dei carrelli a partire da Y e V c.s.** per allontanare q.p. (Y+T) e V + dCorsaYfc = MaxY - dYPos + dCorsaVfc = dVPos - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto **le corse di 'recupero'** dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + (MaxV - dVPos) + dCorsaYr = dCorsaYTd + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaVTr + dCorsaYr + end + -- inizializzo + dYPosA = dYPos + dVPosA = dVPos + dTPosA = dTPos + end + + -- **[B3Ys-xsw]** posizione finale dNewV non raggiungibile, con |dEXtraY > CorsaVr + CorsaYr| + while bXsw do + EmitComment( vCmd, '[B3Ys-xsw]') + + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + -- |1:| posiziono (V+T) e Y come calcolato sopra + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- |2:| allontano (Y+T) e V quanto possibile + dYPosA = dYPosA + dCorsaYTd + dTPosA = dTPosA + dCorsaYTd + dVPosA = dVPosA - dCorsaVd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- |3:| accentro (V+T) e Y + dVPosA = dVPosA + dCorsaVTr + dTPosA = dTPosA + dCorsaVTr + dYPosA = MyMinY + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- valuto i Delta ottenuti + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bYDeltaS = ( dYDeltaF < dYDeltaA - dYDeltaTol or dYDeltaF > dYDeltaA + DELTA_SIC) + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- aggiorno ExtraY + dExtraY = dExtraY + dCorsaYr + dCorsaVTr + + -- **aggiorno la valutazione delle corse disponibili** + -- a partire da Y e V c.s. per allontanare q.p. (Y+T) e V + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + -- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando Y e (V+T) + dCorsaVTr = dCorsaVd + dCorsaYr = dCorsaYTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bYDeltaS and bYxs and -dExtraY > dCorsaVTr + dCorsaYr + end --[B3Ys-xsw] + + -- **[B3Ys]** |spostamento| finale richiesto (ev' residuo) di |Y| |'significativo'| + if bYDeltaS then + EmitComment( vCmd, '[B3Ys]') + + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + -- **[B3Ys-x]** posizione di |Y non raggiungibile| + -- ( -dExtraY <= (CorsaYr+CorsaVr) da ciclo precedente ) + if dExtraY < 0 then + --EmitComment( vCmd, '[B3Ys-x]') + + -- **[B3Ys-xs]** |ExtraY 'significativo'| + if bYxs then + --EmitComment( vCmd, '[B3Ys-xs]') + + local dCorsaVTrA = MaxV - dVPosA + local dCorsaYra = dYPosA - MyMinY + -- **[B3Ys-xs1]** se posso recuperare ExtraY semplicem' accentrando Y e (V+T) + -- ulteriormente rispetto a YPos e Vpos definiti c.s. + if dCorsaVTrA >= -dExtraY then + EmitComment( vCmd, '[B3Ys-xs1]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1: accentro** Y e (V+T) + dYPosA = MyMinY -- (pos. finale) + dVPosA = dVPosA - dExtraY + dTPosA = dTPosA - dExtraY + dYDeltaA = dYPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + else -- **[B3Ys-xs2]** + EmitComment( vCmd, '[B3Ys-xs2]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1: accentro** ev' Y e (V+T) alle posizioni impostate + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dYDeltaA = dYPosA - dTPosA + + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **2: allontano** (Y+T) e V + -- tenendo conto di dover 'recuperare' ExtraY... + dYPos1, dVPos1, dTPos1 = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraY, dCorsaVTrA, dCorsaYTd, dCorsaVd, 'Y') + local dYDispl1 = dYPos1 - dYPosA + local dVDispl1 = dVPos1 - dVPosA + local dVDeltaDiff = dNewVDelta - (dVPos1 - dTPos1) + -- ...e anche di posizionare possibilmente V alla posizione finale + if dVDeltaDiff < 0 then + CorsaYfc = MaxY - dYPos1 + dCorsaVfc = dVPos1 - MinV + dDistFrN = dVDeltaA - MinJoin - EMC.HCING - EMC.HOVM -- DistFront1 'netta' + dCorsaYTd, dCorsaVd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistFrN, 'Fr') + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPos1, dVPos1, dTPos1, dVDeltaDiff, 0, dCorsaYTd, dCorsaVd, 'Y') + else + dYPosA = dYPos1; dVPosA = dVPos1; dTPosA = dTPos1 + end + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + + -- chiudo il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **3: accentro** Y e (V+T) + dYPosA = dYPosA - dYDispl1 - dCorsaYra -- POS. FINALE + dVPosA = dVPosA - dVDispl1 + dCorsaVTrA -- POS. FINALE + dTPosA = dTPosA - dVDispl1 + dCorsaVTrA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [B3Ys-xs1/-xs2] + + -- **[B3Ys-xn]** |dExtraY ancora < 0 ma non 'significativo')| + else --if -dExtraY < DeltaToll/2 + EmitComment( vCmd, '[B3Ys-xn]') + -- ev' chiudo V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- 1: accentro Y e porto (V+T) alla posizione impostata + dExtraY = 0 + dYPosA = MyMinY -- (pos. finale) + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end --[B3Ys-xs/xn] + + -- **[B3Ys-r]** |dExtraY > 0 (pos. Y raggiungibile)| + else + EmitComment( vCmd, '[B3Ys-r]') + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- posizione ev' (V+T) come impostato sopra e Y in posizione finale + dYPosA = dTPosA + dNewYDelta + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [B3Ys] + -- + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + + else -- [B3Yns] |spostamento| finale richiesto (ev' residuo) di |Y non 'significativo'| + EmitComment( vCmd, '[B3Yns]') + end --[B3Ys/ns] + + -- aggiorno la verifica di movimento 'significativo' per V + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- **[B3Vs]** Se vi è uno |spostamento residuo di V significativo'| + if bVDeltaS then + EmitComment( vCmd, '[B3Vs]') + + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + local dNewV = dTPosA + dNewVDelta + local dExtraV = dNewV - MaxV + + -- **[B3Vs-x]** se pos. |NewV non è raggiungibile direttamente| (oltre MaxV) + if dExtraV > 0 then --dNewV <= MaxV then + -- **[B3Vs-xs]** |ExtraV 'significativo'| + if dExtraV > dVDeltaTol /2 then + EmitComment( vCmd, '[B3Vs-xs]') + EgtOutLog( ' CLAMP : caso [B3Vs-xs] non gestito') + error( ' CLAMP : caso [B3Vs-xs] non gestito') + + -- **[B3Vs-xn]** |ExtraV non 'significativo'| + else + EmitComment( vCmd, '[B3Vs-xn]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- accentro V q.p. + dVPosA = MaxV + table.insert( vCmd, { 1, 'V', dVPosA}) + end -- [B3Vs-xs/xn] + + else -- **[B3Vs-r]** pos. |NewV raggiungibile direttamente| (non oltre MaxV) + EmitComment( vCmd, '[B3Vs-r]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V + dVPosA = dNewV + table.insert( vCmd, { 1, 'V', dVPosA}) + end --[B3Vs-x/-r] + + else -- [B3Vns] spostamento residuo di V non significativo + EmitComment( vCmd, '[B3Vns]') + end -- [B3Vs/ns] + + -- calcolo i nuovi parametri di aggancio + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- se non emessi movimenti, imposto posizione Y + if not bZmaxOk then + -- risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + table.insert( vCmd, { 1, 'Y', dYPosA}) + end + -- imposto stato carrelli, per eventuale uso pressori (sempre effettuato movimento) + table.insert( vCmd, { 11, CalcCharStatus( 'Y', dYDeltaA)}) + table.insert( vCmd, { 12, CalcCharStatus( 'V', dVDeltaA)}) + -- imposto i nuovi parametri di aggancio + table.insert( vCmd, { 21, dYDeltaA, dVDeltaA}) + + EgtOutLog( ' YDeltaA =' .. EgtNumToString( dYDeltaA) .. ' VDeltaA =' .. EgtNumToString( dVDeltaA), 1) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() + return vCmd +end -- SpecAdjustCarrB3 + +--------------------------------------------------------------------- +-- *** [C1] da carrello Y a V : Y -> V *** +--------------------------------------------------------------------- +function SpecAdjustCarrC1( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + EgtOutLog( ' *[C1] = Y -> V ', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'Y -> V'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + -- recupero le posizioni correnti + --local dCorsaY = MaxY - MyMinY + --local dCorsaV = MaxV - MinV + local dYPosA = dTPosI + dYDeltaI + local dVPosA = ParkV + local dTPosA = dTPosI + local dYDeltaA = dYDeltaI + local dVDeltaA = dVPosA - dTPosA + local dNewVDelta -- = dVDeltaF + -- tolleranza + local dVDeltaTol = GetDeltaTol( dVDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + local bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bVDeltaS then + dNewVDelta = dVDeltaF - dVDeltaTol/2 + else + dNewVDelta = dVDeltaA + end + EgtOutLog(' YDeltaI=' .. EgtNumToString( dYDeltaA) .. ' VDeltaI(Park)='.. EgtNumToString( dVDeltaA).. + ' TPosI=' .. EgtNumToString( dTPosI) , 1) + EgtOutLog(' VDeltaF=' .. EgtNumToString( dVDeltaF) .. ' NewVDelta=' .. EgtNumToString( dNewVDelta) , 1) + + -- risalita testa a Zmax (da effettuare comunque, dato lo scambio di carrelli) + local bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + -- calcoli preliminari in caso di spostamento richiesto per V significativo + local dYPos, dVPos, dTPos + local dNewV, dExtraV, bVxs + local dCorsaYfc, dCorsaVfc, dDistFrN, dCorsaYTd, dCorsaVd, dCorsaVTr, dCorsaYr, bXsw + if bVDeltaS then + -- definisco 'ExtraV' con (Y+T) e V accentrati q.b. per la presa di V + dYPos, dVPos, dTPos = PosxExtraYV( dYPosA, dVPosA, dTPosA, MyMinY, MaxV, 'V') + dNewV = dTPos + dNewVDelta + dExtraV = dNewV - MaxV + bVxs = dExtraV > dVDeltaTol/2 -- ExtraV 'significativo' + if bVxs then + -- calcolo le **corse disponibili dei carrelli a partire da Y e V c.s.** per allontanare q.p. Y e (V+T) + dCorsaYfc = MaxY - dYPos + dCorsaVfc = dVPos - MinV + --local dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dDistBkN = EMC.LB - (dYPos-dTPos) - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando (Y+T) e V + dCorsaYTr = dCorsaYd + (dYPos -MyMinY) + dCorsaVr = dCorsaVTd + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaVr + dCorsaYTr + end + -- inizializzo + dYPosA = dYPos + dVPosA = dVPos + dTPosA = dTPos + end + + -- **[C1Vs-xsw]** posizione finale di V non raggiungibile, con |dEXtraV > CorsaVr + CorsaYr| + -- con spostamento richiesto significativo e ExtraV significativo + while bXsw do + EmitComment( vCmd, '[C1Vs-xsw]') + -- **1:** posiziono (Y+T) e V come calcolato sopra + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **2:** allontano Y e (V+T) quanto possibile + dYPosA = dYPosA + dCorsaYd + dVPosA = dVPosA - dCorsaVTd + dTPosA = dTPosA - dCorsaVTd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **3:** accentro (Y+T) e V + dYPosA = dYPosA - dCorsaYTr -- = MyMinY + dTPosA = dTPosA - dCorsaYTr + dVPosA = MaxV + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- valuto i Delta ottenuti + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- **aggiorno ExtraV** + dExtraV = dExtraV - dCorsaYTr - dCorsaVr + -- **aggiorno la valutazione di ulteriori corse disponibili** + -- a partire da Y e V c.s. per allontanare q.p. Y e (V+T) + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- aggiorno i prossimi recuperi disponibili + dCorsaYTr = dCorsaYd + dCorsaVr = dCorsaVTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaVr + dCorsaYTr + end --[C1Vs-xw] + + -- **[C1Vs]** |spostamento| richiesto (ev' residuo) |di V| |'significativo'| + if bVDeltaS then + -- **[C1Vs-x]** posizione di |V non raggiungibile| + if dExtraV > 0 then + -- (dExtraV <= (CorsaYr+CorsaVr) da ciclo precedente) + -- **[C1Vs-xs]** posizione di V non raggiungibile, |con ExtraV 'significativo'| + if bVxs then + local dCorsaYTrA = dYPosA - MyMinY + -- **[C1Vs-xs1]** se posso recuperare dExtraV solo accentrando V e (Y+T) + if dCorsaYTrA >= dExtraV then + EmitComment( vCmd, '[C1Vs-xs1]') + + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1:** accentro (Y+T) q.b. e V + dYPosA = dYPosA - dExtraV + dTPosA = dTPosA - dExtraV + dVPosA = MaxV -- (pos. finale) + dVDeltaA = dVPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + -- **[C1Vs-xs2]** dCorsaYTrA < dExtraV + else + EmitComment( vCmd, '[C1Vs-xs2]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1: accentro** ev' (Y+T) e V alle posizioni impostate + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + dVDeltaA = dVPosA - dTPosA + -- chiudo (ev') il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **2:allontano** (V+T) q.b./q.p. e Y per preparare il recupero di ExtraV + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraV, dCorsaYTrA, dCorsaYd, dCorsaVTd, 'V') + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + dYDeltaA = dYPosA - dTPosA + + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **3: accentro**(Y+T) e V (pos. finale) + dYPosA = MyMinY + dTPosA = dYPosA - dYDeltaA + dVPosA = MaxV + dVDeltaA = dVPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + end -- [C1Vs-xs1/xs2] + + -- **[C1Vs-xn]** |ExtraV ancora > 0 , ma non 'significativo'| (<= DeltaTol/2) + else + EmitComment( vCmd, '[C1Vs-xn]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- 1: porto ev' (Y+T) alla posizione impostata sopra e accentro V + dExtraV = 0 + dVPosA = MaxV -- pos. finale + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + -- chiudo V (?) + table.insert( vCmd, { 12, 1}) + end -- [C1Vs-xs/xn] + + -- **[C1Vs-r]** posizione di V 'raggiungibile' (ExtraV <= 0) + else + EmitComment( vCmd, '[C1Vs-r]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- posizione ev' (Y+T) come impostato sopra e V in posizione finale + dVPosA = dTPosA + dNewVDelta + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [C1V-s] + + -- **[C1Vns]** |spostamento| richIesto per V |non 'significativo'| + else + EmitComment( vCmd, '[C1Vns]') + end + + -- calcolo i nuovi parametri di aggancio + dVDeltaA = dVPosA - dTPosA + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, CalcCharStatus( 'V', dVDeltaA)}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + -- imposto i nuovi parametri di aggancio + table.insert( vCmd, { 21, 0, dVDeltaA}) + + EgtOutLog( ' VDeltaA =' .. EgtNumToString( dVDeltaA), 1) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() + return vCmd +end --SpecAdjustCarrC1 + +--------------------------------------------------------------------- +-- *** [C2] da entrambi i carrelli a V : Y+V -> V *** +--------------------------------------------------------------------- +function SpecAdjustCarrC2( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta) + EgtOutLog( ' *[C2] = Y+V -> V', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'Y+V -> V'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + local dCorsaY = MaxY - MyMinY + local dCorsaV = MaxV - MinV + -- recupero le posizioni correnti dei carrelli + local dYPosA = dTPosI + dYDeltaI + local dVPosA = dTPosI + dVDeltaI + local dTPosA = dTPosI + local dYDeltaA = dYDeltaI + local dVDeltaA = dVDeltaI + local dNewVDelta -- = dVDeltaF + -- tolleranze + local dVDeltaTol = GetDeltaTol( dVDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + -- definisco spostamento 'significativo' in base alle tolleranze + local bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- reimposto ev' il delta finale + if bVDeltaS then + dNewVDelta = dVDeltaF - dVDeltaTol/2 + else + dNewVDelta = dVDeltaA + end + -- definisco 'ExtraV' + local dNewV = dTPosI + dNewVDelta + local dExtraV = dNewV - MaxV -- > 0 se nuova pos. di V 'non raggiungibile' (= oltre MaxV) + local bVxs = dExtraV > dVDeltaTol/2 -- 'ExtraV significativo' + + EgtOutLog( ' YDeltaI=' .. EgtNumToString( dYDeltaI) .. ' VDeltaI=' .. EgtNumToString( dVDeltaI) .. + ' VDeltaF=' .. EgtNumToString( dVDeltaF) ,1) + EgtOutLog( ' NewVDelta=' .. EgtNumToString( dNewVDelta), 1) + + -- risalita testa a Zmax (da effettuare comunque, per il parcheggio di Y) + local bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + + -- calcoli preliminari in caso di spostamento richiesto per YV significativo + local dCorsaYfc, dCorsaVfc, dDistBkN, dCorsaYd, dCorsaVd, dCorsaVTd, dCorsaYTr, dCorsaVr, bXsw + if bVDeltaS then + if bVxs then + -- calcolo le corse disponibili dei carrelli dalle posizioni attuali (=iniziali) + -- per allontanare Y e (V+T) q.p. + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- valuto le corse di 'recupero' dai due carrelli possibili riaccentrando (Y+T) e V + dCorsaYTr = dCorsaYd + (dYPosA - MyMinY) + dCorsaVr = dCorsaVTd + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaYTr + dCorsaVr + end + end + + -- **[C2Vs-xsw]** posizione finale di V non raggiungibile, |con dEXtraV > CorsaYTr + CorsaVr| + while bXsw do + EmitComment( vCmd, '[C2Vs-xsw]') + + -- chiudo eventualmente il carrello V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- |1:| allontano Y e (V+T) quanto possibile + dYPosA = dYPosA + dCorsaYd + dVPosA = dVPosA - dCorsaVTd + dTPosA = dTPosA - dCorsaVTd + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- chiudo il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- |3:| accentro (Y+T) e V + dYPosA = dYPosA - dCorsaYTr + dTPosA = dTPosA - dCorsaYTr + dVPosA = MaxV + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + + -- valuto i Delta ottenuti + dYDeltaA = dYPosA - dTPosA + dVDeltaA = dVPosA - dTPosA + -- aggiorno la verifica di spostamento significativo + bVDeltaS = ( dVDeltaF > dVDeltaA + dVDeltaTol or dVDeltaF < dVDeltaA - DELTA_SIC) + -- **aggiorno ExtraV** + dExtraV = dExtraV - dCorsaYTr - dCorsaVr + -- **aggiorno la valutazione di ulteriori corse disponibili** + dCorsaYfc = MaxY - dYPosA + dCorsaVfc = dVPosA - MinV + dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- aggiorno i prossimi recuperi disponibili + dCorsaYTr = dCorsaYd + (dYPosA - MyMinY) + dCorsaVr = dCorsaVTd + -- aggiorno verifica per ripetizione del ciclo + bXsw = bVDeltaS and bVxs and dExtraV > dCorsaYTr + dCorsaVr + end -- [C2V-xsw] + + -- **[C2Vs]** se lo |spostamento richiesto per V è significativo| + if bVDeltaS then + -- **[C2Vs-x]** posizione di |V non raggiungibile| (oltre MaxV) + if dExtraV > 0 then + -- **[C2Vs-xs]** |ExtraV 'significativo'| + if bVxs then + local dCorsaYTrA = dYPosA - MyMinY + -- **[C2Vs-xs1]** se posso recuperare ExtraV semplicem' accentrando V e (Y+T) + if dCorsaYTrA >= dExtraV then + EmitComment( vCmd, '[C2Vs-xs1]') + + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1: accentro** (Y+T) e V + dYPosA = dYPosA - dExtraV + dTPosA = dTPosA - dExtraV + dVPosA = MaxV -- (pos. finale) + dVDeltaA = dVPosA - dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + else -- **[C2Vs-xs2]** + EmitComment( vCmd, '[C2Vs-xs2]') + + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- **1: allontano** (V+T) e Y + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraV, dCorsaYTrA, dCorsaYd, dCorsaVTd, 'V') + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + dYDeltaA = dYPosA - dTPosA + + -- chiudo il carrello Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **2: accentro** (Y+T) e V + dYPosA = MyMinY + dTPosA = dYPosA - dYDeltaA + dVPosA = MaxV -- (pos. finale) + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [C2Vs-xs1/-xs2] + + -- **[C2Vs-xn]** |dExtraV ancora > 0 ma non 'significativo')| + else --if dExtraV < DeltaToll/2 + EmitComment( vCmd, '[B1Vs-xn]') + -- ev' chiudo Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1:** accentro V + dExtraV = 0 + dVPosA = MaxV -- (pos. finale) + table.insert( vCmd, { 1, 'V', dVPosA}) + end -- [C2s-xs/xn] + + -- **[C2Vs-r]** |dExtraV < 0 (pos. V raggiungibile)| + else + EmitComment( vCmd, '[C2Vs-r]') + -- chiudo ev' Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- porto V in posizione finale + dVPosA = dTPosA + dNewVDelta + table.insert( vCmd, { 1, 'V', dVPosA}) + end --[C2Vs] + + -- **[C2Vns]** = |spostamento di V non significativo| + else + EmitComment( vCmd, '[C2Vns]') + end --[C2Vs/n] + + -- calcolo il nuovo parametro di aggancio + dVDeltaA = dVPosA - dTPosA + -- chiudo eventualmente il carrello V e apro Y + table.insert( vCmd, { 12, CalcCharStatus( 'V', dVDeltaA)}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + -- imposto il nuovo parametro di aggancio + table.insert( vCmd, { 21, 0, dVDeltaA}) + + EgtOutLog( ' VDeltaA =' .. EgtNumToString( dVDeltaA), 1) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() + return vCmd +end --SpecAdjustCarrC2 + +--------------------------------------------------------------------- +-- *** [C3] da carrello V a V : V -> V *** +--------------------------------------------------------------------- +function SpecAdjustCarrC3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + EgtOutLog( ' *[C3] = V -> V', 1) + -- elenco comandi + local vCmd = {} + -- Commento + table.insert( vCmd, { 0, 'V -> V'}) + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + -- recupero le posizioni correnti dei carrelli + local dVPosA = dTPosI + dVDeltaI + local dYPosA = ParkY + local dTPosA = dTPosI + local dVDeltaA = dVDeltaI + local dYDeltaA = dYPosA - dTPosA + local dNewVDelta + -- tolleranza + local dVDeltaTol = GetDeltaTol( dVDeltaF, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + local bVDeltaS = (( dVDeltaF > dVDeltaA + dVDeltaTol and not bFixedPos) or dVDeltaF < dVDeltaA - DELTA_SIC) + if bVDeltaS then + dNewVDelta = dVDeltaF - dVDeltaTol / 2 + else + dNewVDelta = dVDeltaA + end + EgtOutLog( ' VDeltaI=' .. EgtNumToString( dVDeltaI) .. ' TPosI=' .. EgtNumToString( dTPosI), 1) + EgtOutLog( ' VDeltaF=' .. EgtNumToString( dVDeltaF) .. ' NewVDelta=' .. EgtNumToString( dNewVDelta), 1) + -- flag per risalita testa a Zmax + local bZmaxOk = false + + -- **[C3Vs]** |pos. di V cambia in modo significativo| + if bVDeltaS then + EmitComment( vCmd, '[C3Vs]') + -- eventuale risalita testa a Zmax + bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + -- definisco 'ExtraV' con (V+T) e Y accentrati q.b. per la presa con Y + local dYPos, dVPos, dTPos = PosxExtraYV( dYPosA, dVPosA, dTPosA, MyMinY, MaxV, 'Y') + local dNewV = dTPos + dNewVDelta + local dExtraV = dNewV - MaxV + -- effettuo spostamenti per predisporre all'aggancio di T con Y + dYPosA = dYPos + dVPosA = dVPos + dTPosA = dTPos + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dYDeltaA = dYPosA - dTPosA + + -- **[C3Vs-x]** posizione di |V non raggiungibile| (oltre MaxV) + if dExtraV > 0 then + -- **[C3Vs-xs]** posizione di V non raggiungibile, |con ExtraV 'significativo'| + if dExtraV > dVDeltaTol /2 then + -- calcolo le **corse disponibili dei carrelli a partire da Y e V c.s.** per allontanare q.p. (V+T) e Y + local dCorsaYfc = MaxY - dYPos + local dCorsaVfc = dVPos - MinV + local dDistBkN = EMC.LB - dYDeltaA - MinJoin - EMC.TCING -- DistBack 'netta' + local dCorsaYd, dCorsaVTd = GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistBkN, 'Bk') + -- valuto **le corse di 'recupero'** dai due carrelli possibili riaccentrando (Y+T) e V + local dCorsaYTr = dCorsaYd + (dYPos - MyMinY) + local dCorsaVr = dCorsaVTd + + -- **[C3Vs-xsw]** posizione finale dNewV non raggiungibile, con |dEXtraV > CorsaVr + CorsaYr| + if dExtraV > ( dCorsaYTr + dCorsaVr) and bVDeltaS then + EmitComment( vCmd, '[C3Vs-xsw]' .. 'CASO NON GESTITO') + return + end + + local dCorsaYTrA = dYPos - MyMinY -- !! att.ne: non dYPosA !! + -- **[C3Vs-xs1]** se posso recuperare ExtraV semplicem' accentrando (Y+T) e V + -- (dalle posizione impostate sopra per l'aggancio di Y) + if dCorsaYTrA >= dExtraV then + EmitComment( vCmd, '[C3Vs-xs1]') + -- chiudo Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1: accentro** (Y+T) e V + dYPosA = dYPosA - dExtraV + dTPosA = dTPosA - dExtraV + dVPosA = MaxV -- (pos. finale) + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dVDeltaA = dVPosA - dTPosA + + else -- **[C3Vs-xs2]** + -- ci sarebbe un doppio movimento di V ? => caso impossibile ? + EmitComment( vCmd, '[C3Vs-xs2]') + -- **1:** posiziono (ulteriormente!) Y e (V+T) + dYPosA, dVPosA, dTPosA = PosXs2Enl( dYPosA, dVPosA, dTPosA, dExtraV, dCorsaYTrA, dCorsaYd, dCorsaVTd, 'V') + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA }) + dYDeltaA = dYPosA - dTPosA + -- chiudo Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **2: accentro** (Y+T) e V + dYPosA = MyMinY + dVPosA = MaxV -- (pos. finale) + dTPosA = dYPosA - dYDeltaA + table.insert( vCmd, { 3, 'Y', dYPosA, 'T', dTPosA, 'V', dVPosA}) + end -- [C3Vs-xs1/-xs2] + + -- **[C3Vs-xn]** |dExtraV > 0 ma 'non significativo')| + else --if dExtraV < DeltaToll/2 + EmitComment( vCmd, '[C3Vs-xn]') + -- chiudo Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **1:** accentro V + dExtraV = 0 + dVPosA = MaxV -- (pos. finale) + table.insert( vCmd, { 1, 'V', dVPosA}) + end --[C3Vs-xs/xn] + + -- **[C3Vs-r]** |posizione di Y raggiungibile| (ExtraY >=0) + -- (si esclude la possibilità di extra corsa oltre maxY) + else + EmitComment( vCmd, '[C3Vs-r]') + -- chiudo Y e apro V + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- **2:** posiziono V alla posizione richiesta + dVPosA = dNewV + table.insert( vCmd, { 1, 'V', dVPosA}) + end -- [C3Vs] + + -- calcolo il nuovo parametro di aggancio + dVDeltaA = dVPosA - dTPosA + -- chiudo ev' V e apro Y + table.insert( vCmd, { 12, CalcCharStatus( 'V', dVDeltaA)}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + -- imposto il nuovo parametro di aggancio + table.insert( vCmd, { 21, 0, dVDeltaA}) + + -- reset contatore + EMC.CNT = nil + + else -- **[C3Vns]** |spostamento| finale richiesto (ev' residuo) di |V non 'significativo'| + EmitComment( vCmd, '[C3Vns]') + end --[C3Vs/ns] + + EgtOutLog( ' VDeltaA =' .. EgtNumToString( dVDeltaA), 1) + + SpecOutputCNT() + return vCmd +end --SpecAdjustCarrC3