diff --git a/Common_FAST.mlse b/Common_FAST.mlse index e352c0c..7c9bdde 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1542,2371 +1542,6 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF 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 GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta) - local dDeltaTolEff = DELTA_SIC - if Carr == 'Y' then - local dLenPreEff = dLenPresa - TCING - if dLenPreEff < MinJoin + DeltaTol then - dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) - else - if BD.GO_FAST and BD.GO_FAST ~= 0 then - if bFixedDelta == false then - dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200) - else - dDeltaTolEff = 900 - end - else - dDeltaTolEff = DeltaTol - end - end - elseif Carr == 'V' then - local dLenPreEff = dLenPresa - HCING - HOVM - if dLenPreEff < MinJoin + DeltaTol then - dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) - else - dDeltaTolEff = DeltaTol - end - end - return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff) -end - ---------------------------------------------------------------------- -local function GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistN, sSide) - local dRecTotn = min( dDistN, dCorsaYfc+ dCorsaVfc) -- recupero possibile al netto di dCorsa..TrA) - 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 - --------------------------------------------------------------------- function SpecOutputCNT() if EMC.CNT == 1 then