From 16e04c85029e0eb7a87c946d1524adf6dfdb76ec Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Tue, 17 Sep 2024 12:24:29 +0200 Subject: [PATCH 01/14] Prima bozza nuova gestione riposizionamento carrelli --- Common_FAST.mlse | 244 ++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 208 insertions(+), 36 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index c9437d9..e352c0c 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1131,6 +1131,20 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack) return vCmd end -- SpecAdjustLoad [L] + +--------------------------------------------------------------------- +function GetMachiningStartingPoint( idPath) + local idFirstObj = EgtGetFirstInGroup( idPath) + -- se esiste l'oggetto, recupero la coordinata del primo punto + if idFirstObj then + local vAxes = EmtGetAxesPos( idFirstObj) + if #vAxes > 0 then + return vAxes[1] + end + end + return nil +end + --------------------------------------------------------------------- function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) @@ -1148,46 +1162,25 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) ' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1) .. ' Fixed : Delta=' .. EgtIf( bFixedDelta, 'T', 'F') .. ' Pos=' .. EgtIf( bFixedPos, 'T', 'F'), 3) + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + local dNewPosT = GetMachiningStartingPoint( EMC.PATHID) + local dNewYDelta = nil + local dNewVDelta = nil + -- [A] se posso mettere solo carrello Y if dDistFrontEff < MinFrontJoin and dDistBackEff > MinBackJoin - GEO.EPS_SMALL then - - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = EMC.LB - dDistBackEff - local dNewVDelta = nil - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - + dNewYDelta = EMC.LB - dDistBackEff + dNewVDelta = nil -- [B] se altrimenti posso mettere entrambi i carrelli Y e V - elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and - dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then - - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = EMC.LB - dDistBackEff - local dNewVDelta = dDistFrontEff - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - + elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + dNewYDelta = EMC.LB - dDistBackEff + dNewVDelta = dDistFrontEff -- [C] se altrimenti posso mettere solo carrello V elseif dDistBackEff < MinBackJoin and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then - - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = nil - local dNewVDelta = dDistFrontEff - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - + dNewYDelta = nil + dNewVDelta = dDistFrontEff -- altrimenti errore else if EgtGetDebugLevel() < 3 then @@ -1199,6 +1192,14 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) return {} end + -- salvo valori finali + EMC.YDELTANEXT = dNewYDelta + EMC.VDELTANEXT = dNewVDelta + + local vCmd = {} + SpecAdjustCarriages( vCmd, dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + return vCmd + end --------------------------------------------------------------------- @@ -1371,7 +1372,178 @@ function SpecCalcPreRot() end --------------------------------------------------------------------- -function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) +function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + local dYPosA, dVPosA, dTPosA + -- verifico che le morse non sono in posizione + if ( dYDeltaF ~= dYDeltaI or dVDeltaF ~= dVDeltaI) then + if #vCmd == 0 then + table.insert( vCmd, { 0, 'Clamp repositioning'}) + end + -- calcolo delta spostamento trave + local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico + + -- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando + if not dYDeltaI then + dYDeltaI = dVDeltaI + ( MinY - MaxV) + end + if not dVDeltaI then + dVDeltaI = dYDeltaI - ( MinY - MaxV) + end + if not dYDeltaF then + dYDeltaF = dVDeltaF + ( MinY - MaxV) + end + if not dVDeltaF then + dVDeltaF = dYDeltaF - ( MinY - MaxV) + end + + -- scambio diretto + if ( ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam > 0) or ( ( dVDeltaI - dYDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam < 0) then + if EMC.YDELTA then + if not EMC.VDELTA then + table.insert( vCmd, { 12, 0}) + end + dTPosA = MaxV - dVDeltaF + dVPosA = MaxV + dYPosA = dTPosA - dYDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + dTPosA = dTPosF + dYPosA = dVDeltaF + dTPosF + dVPosA = dYDeltaF + dTPosF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + if EMC.YDELTANEXT then + table.insert( vCmd, { 11, 1}) + end + if not EMC.VDELTANEXT then + table.insert( vCmd, { 12, 0}) + end + else + dTPosA = MinY - dYDeltaF + dVPosA = dTPosA - dVDeltaI + dYPosA = MinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + dTPosA = dTPosF + dYPosA = dYDeltaF + dTPosF + dVPosA = dVDeltaF + dTPosF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + if EMC.VDELTANEXT then + table.insert( vCmd, { 12, 1}) + end + if not EMC.YDELTANEXT then + table.insert( vCmd, { 11, 0}) + end + end + -- se devo recuperare corsa con passo del pellegrino + else + -- compatto al centro + if not EMC.YDELTA then + dTPosA = MaxV - dVDeltaI + dVPosA = MaxV + dYPosA = MinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + EMC.YDELTA = true + dYDeltaI = dVDeltaI - MaxV + MinY + dTPosI = dTPosA + end + if not EMC.VDELTA then + dTPosA = MinY - dYDeltaI + dVPosA = MaxV + dYPosA = MinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + EMC.VDELTA = true + dVDeltaI = dYDeltaI + MaxV - MinY + dTPosI = dTPosA + end + + -- aggiorno delta mancante + dDeltaBeam = dTPosI - dTPosF + + -- a questo punto entrambe le pinze sono in presa sul pezzo. Il trascinatore si decide in base alla direzione di movimento trave + -- trascino con morsa allo scarico + if dDeltaBeam > 0 then + -- apro morsa al carico + table.insert( vCmd, { 11, 0}) + -- devo recuperare più del doppio delle corse + if abs( dYDeltaI - dYDeltaF) > ( MinY + MaxY - MinV - MaxV) then + -- calcolo nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = dYDeltaI + ( MaxY - MinY - MinV + MaxV) + dYPosA = MaxY + dVPosA = MinV + dTPosA = dTPosI - MaxV + MinV + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + dTPosI = dTPosA + EMC.YDELTA = true + EMC.VDELTA = false + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- recupero una corsa massima e l'altra solo di quello che serve + elseif abs( dYDeltaI - dYDeltaF) > MinY + MaxY then + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = dYDeltaF + dVPosA = MinV + dTPosA = dTPosI - MaxV + MinV + dYPosA = - ( dYDeltaF + dTPosA) + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + dTPosI = dTPosA + EMC.YDELTA = true + EMC.VDELTA = false + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- non serve recuperare al massimo della corsa, suddivido movimento in due + else + -- suddivido il movimento su entrambe le morse + nTotMove = abs( dYDeltaI - dYDeltaF) / 2 ; + + dYPosA = dTPosI + dYDeltaI + nTotMove + dVPosA = dTPosI + dVDeltaI - nTotMove + dTPosA = dTPosI - nTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = dYDeltaF ; + + dYPosA = dYPosA - nTotMove + dVPosA = dVPosA + nTotMove + dTPosA = dTPosA - nTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento + dVDeltaI = dVDeltaF + + -- sistemo apertura morse + if EMC.VDELTANEXT then + table.insert( vCmd, { 12, 1}) + end + if not EMC.YDELTANEXT then + table.insert( vCmd, { 11, 0}) + table.insert( vCmd, { 1, 'Y', MinY}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + -- imposto i nuovi parametri di aggancio + table.insert( vCmd, { 21, 0, dVDeltaF}) + end + end + end + end + end +end + +--------------------------------------------------------------------- +function SpecAdjustCarriagesOLD( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- [A] richiesto solo carrello Y if dYDeltaF and ( not dVDeltaF) then From 5491e5cd81ca1652a2852eecebbfb33678315c10 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Tue, 17 Sep 2024 12:32:25 +0200 Subject: [PATCH 02/14] Cancellate vecchie funzioni --- Common_FAST.mlse | 2365 ---------------------------------------------- 1 file changed, 2365 deletions(-) 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 From 26126ac892a0ce8d7c9f5b987d96af81b2449ae9 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Tue, 17 Sep 2024 12:52:32 +0200 Subject: [PATCH 03/14] Aggiunto gestione riposizionamento per trave che si muove dallo scarico al carico --- Common_FAST.mlse | 100 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 97 insertions(+), 3 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 7c9bdde..6129589 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1418,6 +1418,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end if not EMC.VDELTANEXT then table.insert( vCmd, { 12, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) end else dTPosA = MinY - dYDeltaF @@ -1436,8 +1438,18 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end if not EMC.YDELTANEXT then table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) end end + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, 0}) + else + table.insert( vCmd, { 21, 0, dVDeltaF}) + end -- se devo recuperare corsa con passo del pellegrino else -- compatto al centro @@ -1503,7 +1515,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- non serve recuperare al massimo della corsa, suddivido movimento in due else -- suddivido il movimento su entrambe le morse - nTotMove = abs( dYDeltaI - dYDeltaF) / 2 ; + local nTotMove = abs( dYDeltaI - dYDeltaF) / 2 ; dYPosA = dTPosI + dYDeltaI + nTotMove dVPosA = dTPosI + dVDeltaI - nTotMove @@ -1530,10 +1542,92 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end if not EMC.YDELTANEXT then table.insert( vCmd, { 11, 0}) - table.insert( vCmd, { 1, 'Y', MinY}) -- sposto il carrello Y in parcheggio table.insert( vCmd, { 1, 'Y', ParkY}) - -- imposto i nuovi parametri di aggancio + end + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, 0}) + else + table.insert( vCmd, { 21, 0, dVDeltaF}) + end + + end + -- trave si muove dallo scarico verso il carico + else + -- apro morsa allo scarico + table.insert( vCmd, { 12, 0}) + -- devo recuperare più del doppio delle corse + if abs( dVDeltaI - dVDeltaF) > ( MinY + MaxY - MinV - MaxV) then + -- calcolo nuova posizione della morsa al carico dopo riposizionamento + dVDeltaI = dVDeltaI - ( MaxY - MinY - MinV + MaxV) + dYPosA = MaxY + dVPosA = MinV + dTPosA = dTPosI + MaxY - MinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + dTPosI = dTPosA + EMC.YDELTA = false + EMC.VDELTA = true + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- recupero una corsa massima e l'altra solo di quello che serve + elseif abs( dVDeltaI - dVDeltaF) > - MinV - MaxV then + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dVDeltaI = dVDeltaF + dYPosA = MaxY + dTPosA = dTPosI + MaxY - MinY + dVPosA = dVDeltaF + dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + dTPosI = dTPosA + EMC.YDELTA = false + EMC.VDELTA = true + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- non serve recuperare al massimo della corsa, suddivido movimento in due + else + -- suddivido il movimento su entrambe le morse + local nTotMove = abs( dVDeltaI - dVDeltaF) / 2 ; + + dYPosA = dTPosI + dYDeltaI + nTotMove + dVPosA = dTPosI + dVDeltaI - nTotMove + dTPosA = dTPosI + nTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dVDeltaI = dVDeltaF ; + + dYPosA = dYPosA - nTotMove + dVPosA = dVPosA + nTotMove + dTPosA = dTPosA + nTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento + dYDeltaI = dYDeltaF + + -- sistemo apertura morse + if EMC.YDELTANEXT then + table.insert( vCmd, { 11, 1}) + end + if not EMC.VDELTANEXT then + table.insert( vCmd, { 12, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + end + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, 0}) + else table.insert( vCmd, { 21, 0, dVDeltaF}) end end From aad2a95dfffdcc405457d19c7a961f9abd549653 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Tue, 17 Sep 2024 15:56:47 +0200 Subject: [PATCH 04/14] - Risalita a ZMAX - Migliorie se scambio diretto --- Common_FAST.mlse | 90 ++++++++++++++++++++++++++++-------------------- 1 file changed, 53 insertions(+), 37 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 6129589..3700454 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1378,6 +1378,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF if ( dYDeltaF ~= dYDeltaI or dVDeltaF ~= dVDeltaI) then if #vCmd == 0 then table.insert( vCmd, { 0, 'Clamp repositioning'}) + -- risalita testa a Zmax + local bZmaxOk = EnsureZmax( bZmaxOk, vCmd) end -- calcolo delta spostamento trave local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico @@ -1398,52 +1400,50 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- scambio diretto if ( ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam > 0) or ( ( dVDeltaI - dYDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam < 0) then - if EMC.YDELTA then - if not EMC.VDELTA then - table.insert( vCmd, { 12, 0}) - end - dTPosA = MaxV - dVDeltaF - dVPosA = MaxV - dYPosA = dTPosA - dYDeltaI + -- se da carico a scarico + if dDeltaBeam < 0 then + table.insert( vCmd, { 0, 'Direct - V to position first'}) + table.insert( vCmd, { 12, 0}) + -- suddivido il movimento su entrambe le morse + local nTotMove = ( dVDeltaF - dVDeltaI) / 2 ; + dTPosA = dTPosI - nTotMove + dVPosA = dTPosA + dVDeltaF + dYPosA = dTPosA + dYDeltaI table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) - dTPosA = dTPosF - dYPosA = dVDeltaF + dTPosF - dVPosA = dYDeltaF + dTPosF - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + -- sposto il carrello Y in posizione if EMC.YDELTANEXT then + dTPosA = dTPosF + dVPosA = dTPosA + dVDeltaF + dYPosA = dTPosA + dYDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) end - if not EMC.VDELTANEXT then - table.insert( vCmd, { 12, 0}) - -- sposto il carrello Y in parcheggio - table.insert( vCmd, { 1, 'V', ParkV}) - end + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF else - dTPosA = MinY - dYDeltaF - dVPosA = dTPosA - dVDeltaI - dYPosA = MinY + table.insert( vCmd, { 0, 'Direct - Y to position first'}) + table.insert( vCmd, { 11, 0}) + -- suddivido il movimento su entrambe le morse + local nTotMove = ( dYDeltaF - dYDeltaI) / 2 ; + dTPosA = dTPosI - nTotMove + dVPosA = dTPosA + dVDeltaI + dYPosA = dTPosA + dYDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) - dTPosA = dTPosF - dYPosA = dYDeltaF + dTPosF - dVPosA = dVDeltaF + dTPosF - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + -- sposto il carrello Y in posizione if EMC.VDELTANEXT then + dTPosA = dTPosF + dVPosA = dTPosA + dVDeltaF + dYPosA = dTPosA + dYDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) end - if not EMC.YDELTANEXT then - table.insert( vCmd, { 11, 0}) - -- sposto il carrello Y in parcheggio - table.insert( vCmd, { 1, 'Y', ParkY}) - end + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF end -- imposto i nuovi parametri di aggancio - if EMC.YDELTANEXT and EMC.VDELTANEXT then + if EMC.YDELTANEXT and EMC.VDELTANEXT then table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) elseif EMC.YDELTANEXT then table.insert( vCmd, { 21, dYDeltaF, 0}) @@ -1454,6 +1454,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF else -- compatto al centro if not EMC.YDELTA then + table.insert( vCmd, { 0, 'Compact Y'}) + table.insert( vCmd, { 11, 0}) dTPosA = MaxV - dVDeltaI dVPosA = MaxV dYPosA = MinY @@ -1464,6 +1466,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dTPosI = dTPosA end if not EMC.VDELTA then + table.insert( vCmd, { 0, 'Compact V'}) + table.insert( vCmd, { 12, 0}) dTPosA = MinY - dYDeltaI dVPosA = MaxV dYPosA = MinY @@ -1527,9 +1531,15 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- aggiorno nuova posizione della morsa al carico dopo riposizionamento dYDeltaI = dYDeltaF ; - dYPosA = dYPosA - nTotMove - dVPosA = dVPosA + nTotMove - dTPosA = dTPosA - nTotMove + if EMC.YDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + else + dYPosA = dYPosA - nTotMove + dVPosA = dVPosA + nTotMove + dTPosA = dTPosA - nTotMove + end table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF @@ -1604,9 +1614,15 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- aggiorno nuova posizione della morsa al carico dopo riposizionamento dVDeltaI = dVDeltaF ; - dYPosA = dYPosA - nTotMove - dVPosA = dVPosA + nTotMove - dTPosA = dTPosA + nTotMove + if EMC.VDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + else + dYPosA = dYPosA - nTotMove + dVPosA = dVPosA + nTotMove + dTPosA = dTPosA + nTotMove + end table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF From 235a8dacb770f31624eaa76d08184b47900f78eb Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Wed, 18 Sep 2024 08:28:26 +0200 Subject: [PATCH 05/14] Offset minimo impostato prima del controllo se spostare morse --- Common_FAST.mlse | 132 ++++++++++++++++++++++++++++++----------------- 1 file changed, 84 insertions(+), 48 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 3700454..4313986 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1374,8 +1374,23 @@ end --------------------------------------------------------------------- function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) local dYPosA, dVPosA, dTPosA + + -- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando + if not dYDeltaI then + dYDeltaI = dVDeltaI + ( MinY - MaxV) + end + if not dVDeltaI then + dVDeltaI = dYDeltaI - ( MinY - MaxV) + end + if not dYDeltaF then + dYDeltaF = dVDeltaF + ( MinY - MaxV) + end + if not dVDeltaF then + dVDeltaF = dYDeltaF - ( MinY - MaxV) + end + -- verifico che le morse non sono in posizione - if ( dYDeltaF ~= dYDeltaI or dVDeltaF ~= dVDeltaI) then + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL or abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then if #vCmd == 0 then table.insert( vCmd, { 0, 'Clamp repositioning'}) -- risalita testa a Zmax @@ -1384,70 +1399,91 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- calcolo delta spostamento trave local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico - -- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando - if not dYDeltaI then - dYDeltaI = dVDeltaI + ( MinY - MaxV) - end - if not dVDeltaI then - dVDeltaI = dYDeltaI - ( MinY - MaxV) - end - if not dYDeltaF then - dYDeltaF = dVDeltaF + ( MinY - MaxV) - end - if not dVDeltaF then - dVDeltaF = dYDeltaF - ( MinY - MaxV) - end - -- scambio diretto + -- scambio diretto if ( ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam > 0) or ( ( dVDeltaI - dYDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam < 0) then - -- se da carico a scarico - if dDeltaBeam < 0 then + -- se sono entrambe in presa sul pezzo + if EMC.YDELTA and EMC.VDELTA then + -- se da scarico a carico + if dVDeltaF - dVDeltaI > dYDeltaF - dYDeltaI then + table.insert( vCmd, { 0, 'Direct - V to position first'}) + table.insert( vCmd, { 12, 0}) + -- suddivido il movimento su entrambe le morse + local nTotMove = ( dVDeltaF - dVDeltaI) / 2 ; + dTPosA = dTPosI - nTotMove + dVPosA = dTPosA + dVDeltaF + dYPosA = dTPosA + dYDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + else + table.insert( vCmd, { 0, 'Direct - Y to position first'}) + table.insert( vCmd, { 11, 0}) + -- suddivido il movimento su entrambe le morse + local nTotMove = ( dYDeltaF - dYDeltaI) / 2 ; + dTPosA = dTPosI - nTotMove + dVPosA = dTPosA + dVDeltaI + dYPosA = dTPosA + dYDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + end + -- se pinza al carico in presa + elseif EMC.YDELTA then table.insert( vCmd, { 0, 'Direct - V to position first'}) table.insert( vCmd, { 12, 0}) - -- suddivido il movimento su entrambe le morse - local nTotMove = ( dVDeltaF - dVDeltaI) / 2 ; - dTPosA = dTPosI - nTotMove - dVPosA = dTPosA + dVDeltaF + + dTPosA = MaxV - dVDeltaF + dVPosA = MaxV dYPosA = dTPosA + dYDeltaI table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) - -- sposto il carrello Y in posizione - if EMC.YDELTANEXT then - dTPosA = dTPosF - dVPosA = dTPosA + dVDeltaF - dYPosA = dTPosA + dYDeltaF - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - table.insert( vCmd, { 11, 1}) - end dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + -- se pinza allo scarico in presa else table.insert( vCmd, { 0, 'Direct - Y to position first'}) table.insert( vCmd, { 11, 0}) - -- suddivido il movimento su entrambe le morse - local nTotMove = ( dYDeltaF - dYDeltaI) / 2 ; - dTPosA = dTPosI - nTotMove - dVPosA = dTPosA + dVDeltaI - dYPosA = dTPosA + dYDeltaF + + dTPosA = MinY - dVDeltaF + dVPosA = dTPosA + dYDeltaI + dYPosA = MinY table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) - -- sposto il carrello Y in posizione - if EMC.VDELTANEXT then - dTPosA = dTPosF - dVPosA = dTPosA + dVDeltaF - dYPosA = dTPosA + dYDeltaF - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - table.insert( vCmd, { 12, 1}) - end dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF end + + -- sposto il carrello Y in posizione + if EMC.YDELTANEXT then + -- sposto il carrello Y in parcheggio + dYPosA = dTPosA + dYDeltaF + table.insert( vCmd, { 1, 'Y', dYPosA}) + table.insert( vCmd, { 11, 1}) + end + + -- sposto il carrello Y in posizione + if EMC.VDELTANEXT then + -- sposto il carrello Y in parcheggio + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 1, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + end + -- imposto i nuovi parametri di aggancio if EMC.YDELTANEXT and EMC.VDELTANEXT then table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) elseif EMC.YDELTANEXT then + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) table.insert( vCmd, { 21, dYDeltaF, 0}) else + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) table.insert( vCmd, { 21, 0, dVDeltaF}) end -- se devo recuperare corsa con passo del pellegrino @@ -1536,9 +1572,9 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dYPosA = dTPosF + dYDeltaF dVPosA = dTPosF + dVDeltaF else - dYPosA = dYPosA - nTotMove - dVPosA = dVPosA + nTotMove - dTPosA = dTPosA - nTotMove + dYPosA = MinY + dTPosA = MinY - dYDeltaF + dVPosA = dTPosA + dVDeltaF end table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF @@ -1619,9 +1655,9 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dYPosA = dTPosF + dYDeltaF dVPosA = dTPosF + dVDeltaF else - dYPosA = dYPosA - nTotMove - dVPosA = dVPosA + nTotMove - dTPosA = dTPosA + nTotMove + dVPosA = MaxV + dTPosA = MaxY - dVDeltaF + dYPosA = - dTPosA - dVDeltaF end table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF From 1886d6620e2bb49d78588662f77bf87651ec7b7b Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Wed, 18 Sep 2024 10:29:42 +0200 Subject: [PATCH 06/14] Se posso fare scambio diretto non suddivido il movimento --- Common_FAST.mlse | 73 +++++++++++++++++++++++++++++------------------- 1 file changed, 44 insertions(+), 29 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 4313986..9b41f9e 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1402,6 +1402,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- scambio diretto if ( ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam > 0) or ( ( dVDeltaI - dYDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam < 0) then + local bCloseY, bCloseV -- se sono entrambe in presa sul pezzo if EMC.YDELTA and EMC.VDELTA then -- se da scarico a carico @@ -1409,26 +1410,26 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 0, 'Direct - V to position first'}) table.insert( vCmd, { 12, 0}) -- suddivido il movimento su entrambe le morse - local nTotMove = ( dVDeltaF - dVDeltaI) / 2 ; + local nTotMove = ( dVDeltaF - dVDeltaI) ; dTPosA = dTPosI - nTotMove dVPosA = dTPosA + dVDeltaF dYPosA = dTPosA + dYDeltaI table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + bCloseY = true else table.insert( vCmd, { 0, 'Direct - Y to position first'}) table.insert( vCmd, { 11, 0}) -- suddivido il movimento su entrambe le morse - local nTotMove = ( dYDeltaF - dYDeltaI) / 2 ; + local nTotMove = ( dYDeltaF - dYDeltaI) ; dTPosA = dTPosI - nTotMove dVPosA = dTPosA + dVDeltaI dYPosA = dTPosA + dYDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + bCloseV = true end -- se pinza al carico in presa elseif EMC.YDELTA then @@ -1441,7 +1442,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + bCloseY = true -- se pinza allo scarico in presa else table.insert( vCmd, { 0, 'Direct - Y to position first'}) @@ -1453,41 +1454,50 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + bCloseV = true end - -- sposto il carrello Y in posizione - if EMC.YDELTANEXT then - -- sposto il carrello Y in parcheggio - dYPosA = dTPosA + dYDeltaF - table.insert( vCmd, { 1, 'Y', dYPosA}) - table.insert( vCmd, { 11, 1}) - end - - -- sposto il carrello Y in posizione - if EMC.VDELTANEXT then - -- sposto il carrello Y in parcheggio - dVPosA = dTPosA + dVDeltaF - table.insert( vCmd, { 1, 'V', dVPosA}) - table.insert( vCmd, { 12, 1}) - end - - -- imposto i nuovi parametri di aggancio + -- se entrambi in presa if EMC.YDELTANEXT and EMC.VDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + if bCloseY then table.insert( vCmd, { 11, 1}) end + if bCloseV then table.insert( vCmd, { 12, 1}) end table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + -- sposto il carrello Y in posizione elseif EMC.YDELTANEXT then + -- vado in posizione e sposto il carrello V in parcheggio + dYPosA = MinY + dTPosA = MinY - dYDeltaF + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + if bCloseY then table.insert( vCmd, { 11, 1}) end table.insert( vCmd, { 12, 0}) -- sposto il carrello V in parcheggio table.insert( vCmd, { 1, 'V', ParkV}) table.insert( vCmd, { 21, dYDeltaF, 0}) + -- sposto il carrello Y in posizione else + dVPosA = MaxV + dTPosA = MaxV - dVDeltaF + dYPosA = - ( dTPosA + dYDeltaF) + -- vado in posizione e sposto il carrello Y in parcheggio + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + if bCloseV then table.insert( vCmd, { 12, 1}) end table.insert( vCmd, { 11, 0}) -- sposto il carrello Y in parcheggio table.insert( vCmd, { 1, 'Y', ParkY}) table.insert( vCmd, { 21, 0, dVDeltaF}) end + + -- movimento terminato + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + -- se devo recuperare corsa con passo del pellegrino else + local bForceMoveY = false -- compatto al centro if not EMC.YDELTA then table.insert( vCmd, { 0, 'Compact Y'}) @@ -1510,6 +1520,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) EMC.VDELTA = true + bForceMoveY = true dVDeltaI = dYDeltaI + MaxV - MinY dTPosI = dTPosA end @@ -1519,7 +1530,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- a questo punto entrambe le pinze sono in presa sul pezzo. Il trascinatore si decide in base alla direzione di movimento trave -- trascino con morsa allo scarico - if dDeltaBeam > 0 then + if dDeltaBeam > 0 or bForceMoveY then -- apro morsa al carico table.insert( vCmd, { 11, 0}) -- devo recuperare più del doppio delle corse @@ -1555,7 +1566,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- non serve recuperare al massimo della corsa, suddivido movimento in due else -- suddivido il movimento su entrambe le morse - local nTotMove = abs( dYDeltaI - dYDeltaF) / 2 ; + local nTotMove = ( dYDeltaF - dYDeltaI) / 2 ; dYPosA = dTPosI + dYDeltaI + nTotMove dVPosA = dTPosI + dVDeltaI - nTotMove @@ -1567,7 +1578,11 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- aggiorno nuova posizione della morsa al carico dopo riposizionamento dYDeltaI = dYDeltaF ; - if EMC.YDELTANEXT then + if not EMC.VDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = ParkV + elseif EMC.YDELTANEXT then dTPosA = dTPosF dYPosA = dTPosF + dYDeltaF dVPosA = dTPosF + dVDeltaF @@ -1638,7 +1653,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- non serve recuperare al massimo della corsa, suddivido movimento in due else -- suddivido il movimento su entrambe le morse - local nTotMove = abs( dVDeltaI - dVDeltaF) / 2 ; + local nTotMove = ( dVDeltaI - dVDeltaF) / 2 ; dYPosA = dTPosI + dYDeltaI + nTotMove dVPosA = dTPosI + dVDeltaI - nTotMove @@ -1656,8 +1671,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dVPosA = dTPosF + dVDeltaF else dVPosA = MaxV - dTPosA = MaxY - dVDeltaF - dYPosA = - dTPosA - dVDeltaF + dTPosA = MaxV - dVDeltaF + dYPosA = - dTPosA - dYDeltaF end table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF From 5b7bab28737ca63eea1308c2d3860cc09f472b63 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Thu, 19 Sep 2024 12:07:30 +0200 Subject: [PATCH 07/14] Rivisitazione condizioni per scambio diretto --- Common_FAST.mlse | 386 +++++++++++++++++++++++++++++------------------ 1 file changed, 236 insertions(+), 150 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 9b41f9e..51eb051 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1165,7 +1165,11 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) local dPosT = EMC.TPOS local dYDelta = EMC.YDELTA local dVDelta = EMC.VDELTA - local dNewPosT = GetMachiningStartingPoint( EMC.PATHID) + local dNewPosT + -- se sono già settati, non calcolo posizione finale + if not EMC.YDELTANEXT and not EMC.VDELTANEXT then + dNewPosT = GetMachiningStartingPoint( EMC.PATHID) + end local dNewYDelta = nil local dNewVDelta = nil @@ -1198,6 +1202,10 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) local vCmd = {} SpecAdjustCarriages( vCmd, dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + -- reset contatore + EMC.CNT = nil + + SpecOutputCNT() return vCmd end @@ -1389,6 +1397,11 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dVDeltaF = dYDeltaF - ( MinY - MaxV) end + -- se non c'è posizione finale, è lo scarico + if not dTPosF then + dTPosF = MaxV - dVDeltaF + end + -- verifico che le morse non sono in posizione if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL or abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then if #vCmd == 0 then @@ -1396,98 +1409,83 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- risalita testa a Zmax local bZmaxOk = EnsureZmax( bZmaxOk, vCmd) end + + -- ricavo posizione delle morse nelle corse + local dYPosI = max( MinY, dTPosI + dYDeltaI) + local dVPosI = min( MaxV, dTPosI + dVDeltaI) + -- calcolo delta spostamento trave local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico - + local dBeamMove = 0 - -- scambio diretto - if ( ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam > 0) or ( ( dVDeltaI - dYDeltaF) >= MinY - MaxV + DELTA_SIC and dDeltaBeam < 0) then - local bCloseY, bCloseV - -- se sono entrambe in presa sul pezzo - if EMC.YDELTA and EMC.VDELTA then - -- se da scarico a carico - if dVDeltaF - dVDeltaI > dYDeltaF - dYDeltaI then - table.insert( vCmd, { 0, 'Direct - V to position first'}) - table.insert( vCmd, { 12, 0}) - -- suddivido il movimento su entrambe le morse - local nTotMove = ( dVDeltaF - dVDeltaI) ; - dTPosA = dTPosI - nTotMove - dVPosA = dTPosA + dVDeltaF - dYPosA = dTPosA + dYDeltaI - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - table.insert( vCmd, { 12, 1}) + -- scambio diretto. V può andare in posizione direttamente. + if ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and ( dVDeltaF - dVDeltaI > MinV - dVPosI + dYPosI - MaxY and dVDeltaF - dVDeltaI < dVPosI - MinV + dYPosI - MinY) then + + -- se l'altra morsa non era in presa, vado a pinzare il pezzo + if not EMC.YDELTA then + dYPosA = MinY + dTPosA = MinY + dYDeltaI + dVPosA = dTPosA + dVDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dVPosI = dVPosA + table.insert( vCmd, { 11, 1}) + end + -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo + -- se non era ingagiata, vado al suo minimo + if not EMC.VDELTA then + dBeamMove = -( MaxV - dVDeltaF - dTPosI) + -- se spostamento verso lo scarico + elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) < MinV then + dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MinV + -- se spostamento verso il carico + elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) > MaxV then + dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MaxV + end + + table.insert( vCmd, { 12, 0}) + + dTPosA = dTPosI - dBeamMove + dYPosA = dTPosA + dYDeltaI + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + -- la morsa allo scarico è adesso in posizione + dVDeltaI = dVDeltaF + dTPosI = dTPosA + + -- blocco la morsa + table.insert( vCmd, { 12, 1}) + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + -- porto assi alla loro posizione finale + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then table.insert( vCmd, { 11, 0}) - bCloseY = true - else - table.insert( vCmd, { 0, 'Direct - Y to position first'}) - table.insert( vCmd, { 11, 0}) - -- suddivido il movimento su entrambe le morse - local nTotMove = ( dYDeltaF - dYDeltaI) ; - dTPosA = dTPosI - nTotMove - dVPosA = dTPosA + dVDeltaI - dYPosA = dTPosA + dYDeltaF + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) - table.insert( vCmd, { 12, 0}) - bCloseV = true + -- la morsa al carico è adesso in posizione + dYDeltaI = dYDeltaF end - -- se pinza al carico in presa - elseif EMC.YDELTA then - table.insert( vCmd, { 0, 'Direct - V to position first'}) - table.insert( vCmd, { 12, 0}) - - dTPosA = MaxV - dVDeltaF - dVPosA = MaxV - dYPosA = dTPosA + dYDeltaI - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - table.insert( vCmd, { 12, 1}) - table.insert( vCmd, { 11, 0}) - bCloseY = true - -- se pinza allo scarico in presa - else - table.insert( vCmd, { 0, 'Direct - Y to position first'}) - table.insert( vCmd, { 11, 0}) - - dTPosA = MinY - dVDeltaF - dVPosA = dTPosA + dYDeltaI - dYPosA = MinY - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - table.insert( vCmd, { 11, 1}) - table.insert( vCmd, { 12, 0}) - bCloseV = true - end - - -- se entrambi in presa - if EMC.YDELTANEXT and EMC.VDELTANEXT then - dTPosA = dTPosF - dYPosA = dTPosF + dYDeltaF - dVPosA = dTPosF + dVDeltaF - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - if bCloseY then table.insert( vCmd, { 11, 1}) end - if bCloseV then table.insert( vCmd, { 12, 1}) end table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) - -- sposto il carrello Y in posizione elseif EMC.YDELTANEXT then - -- vado in posizione e sposto il carrello V in parcheggio - dYPosA = MinY - dTPosA = MinY - dYDeltaF - dVPosA = dTPosA + dVDeltaF - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - if bCloseY then table.insert( vCmd, { 11, 1}) end + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 11, 0}) + dYPosA = dTPosI + dYDeltaF + table.insert( vCmd, { 1, 'Y', dYPosA}) + table.insert( vCmd, { 11, 1}) + -- la morsa al carico è adesso in posizione + dYDeltaI = dYDeltaF + end table.insert( vCmd, { 12, 0}) -- sposto il carrello V in parcheggio table.insert( vCmd, { 1, 'V', ParkV}) table.insert( vCmd, { 21, dYDeltaF, 0}) - -- sposto il carrello Y in posizione else - dVPosA = MaxV - dTPosA = MaxV - dVDeltaF - dYPosA = - ( dTPosA + dYDeltaF) - -- vado in posizione e sposto il carrello Y in parcheggio - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - if bCloseV then table.insert( vCmd, { 12, 1}) end table.insert( vCmd, { 11, 0}) - -- sposto il carrello Y in parcheggio table.insert( vCmd, { 1, 'Y', ParkY}) table.insert( vCmd, { 21, 0, dVDeltaF}) end @@ -1495,9 +1493,85 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- movimento terminato dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + -- scambio diretto. Y può andare in posizione direttamente + elseif ( dYDeltaF - dVDeltaI) >= MinY - MaxV + DELTA_SIC and ( dYDeltaF - dYDeltaI > MinV - dVPosI + dYPosI - MaxY and dYDeltaF - dYDeltaI < dVPosI - MinV + dYPosI - MinY ) then + + -- se l'altra morsa non era in presa, vado a pinzare il pezzo + if not EMC.VDELTA then + dVPosA = MaxV + dTPosA = MaxV - dVDeltaI + dYPosA = dTPosA + dYDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dYPosI = dYPosA + table.insert( vCmd, { 12, 1}) + end + + -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo + -- se non era ingagiata, vado al suo minimo + if not EMC.YDELTA then + dBeamMove = - ( dYDeltaF - MinY + dTPosI) + -- se spostamento verso lo scarico + elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) < MinY then + dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MinY + -- se spostamento verso il carico + elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) > MaxY then + dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MaxY + end + + + table.insert( vCmd, { 11, 0}) + + dTPosA = dTPosI + dBeamMove + dYPosA = dTPosA + dYDeltaF + dVPosA = dTPosA + dVDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + -- la morsa allo scarico è adesso in posizione + dYDeltaI = dYDeltaF + dTPosI = dTPosA + + -- blocco la morsa + table.insert( vCmd, { 11, 1}) + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 12, 0}) + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- la morsa al carico è adesso in posizione + dVDeltaI = dVDeltaF + end + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.VDELTANEXT then + if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 12, 0}) + dVPosA = dTPosI + dVDeltaF + table.insert( vCmd, { 1, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- la morsa al carico è adesso in posizione + dVDeltaI = dVDeltaF + end + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + table.insert( vCmd, { 21, 0, dVDeltaF}) + else + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + table.insert( vCmd, { 21, dYDeltaF, 0}) + end + -- movimento terminato + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + -- se devo recuperare corsa con passo del pellegrino else - local bForceMoveY = false + local bForceMoveY, bForceMoveV -- compatto al centro if not EMC.YDELTA then table.insert( vCmd, { 0, 'Compact Y'}) @@ -1507,8 +1581,9 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dYPosA = MinY table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) - EMC.YDELTA = true dYDeltaI = dVDeltaI - MaxV + MinY + EMC.YDELTA = dYDeltaI + bForceMoveV = true dTPosI = dTPosA end if not EMC.VDELTA then @@ -1519,9 +1594,9 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dYPosA = MinY table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) - EMC.VDELTA = true - bForceMoveY = true dVDeltaI = dYDeltaI + MaxV - MinY + EMC.VDELTA = dVDeltaI + bForceMoveY = true dTPosI = dTPosA end @@ -1530,7 +1605,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- a questo punto entrambe le pinze sono in presa sul pezzo. Il trascinatore si decide in base alla direzione di movimento trave -- trascino con morsa allo scarico - if dDeltaBeam > 0 or bForceMoveY then + if bForceMoveY or ( dDeltaBeam > 0 and not bForceMoveV) then -- apro morsa al carico table.insert( vCmd, { 11, 0}) -- devo recuperare più del doppio delle corse @@ -1544,8 +1619,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) dTPosI = dTPosA - EMC.YDELTA = true - EMC.VDELTA = false + EMC.YDELTA = dYDeltaI + EMC.VDELTA = nil -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- recupero una corsa massima e l'altra solo di quello che serve @@ -1554,64 +1629,62 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dYDeltaI = dYDeltaF dVPosA = MinV dTPosA = dTPosI - MaxV + MinV - dYPosA = - ( dYDeltaF + dTPosA) + dYPosA = dYDeltaF + dTPosA table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) dTPosI = dTPosA - EMC.YDELTA = true - EMC.VDELTA = false + EMC.YDELTA = dYDeltaI + EMC.VDELTA = nil -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- non serve recuperare al massimo della corsa, suddivido movimento in due else -- suddivido il movimento su entrambe le morse - local nTotMove = ( dYDeltaF - dYDeltaI) / 2 ; + local dTotMove = ( dYDeltaF - dYDeltaI) / 2 - dYPosA = dTPosI + dYDeltaI + nTotMove - dVPosA = dTPosI + dVDeltaI - nTotMove - dTPosA = dTPosI - nTotMove - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - table.insert( vCmd, { 11, 1}) - table.insert( vCmd, { 12, 0}) + if abs( dTotMove) > 10 * GEO.EPS_SMALL then + dYPosA = dTPosI + dYDeltaI + dTotMove + dVPosA = dTPosI + dVDeltaI - dTotMove + dTPosA = dTPosI - dTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) - -- aggiorno nuova posizione della morsa al carico dopo riposizionamento - dYDeltaI = dYDeltaF ; + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = dYDeltaF ; - if not EMC.VDELTANEXT then - dTPosA = dTPosF - dYPosA = dTPosF + dYDeltaF - dVPosA = ParkV - elseif EMC.YDELTANEXT then - dTPosA = dTPosF - dYPosA = dTPosF + dYDeltaF - dVPosA = dTPosF + dVDeltaF - else - dYPosA = MinY - dTPosA = MinY - dYDeltaF - dVPosA = dTPosA + dVDeltaF + if not EMC.VDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = ParkV + elseif EMC.YDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + else + dYPosA = MinY + dTPosA = MinY - dYDeltaF + dVPosA = dTPosA + dVDeltaF + end + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento + dVDeltaI = dVDeltaF end - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF - -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento - dVDeltaI = dVDeltaF - - -- sistemo apertura morse - if EMC.VDELTANEXT then - table.insert( vCmd, { 12, 1}) - end - if not EMC.YDELTANEXT then - table.insert( vCmd, { 11, 0}) - -- sposto il carrello Y in parcheggio - table.insert( vCmd, { 1, 'Y', ParkY}) - end -- imposto i nuovi parametri di aggancio if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) elseif EMC.YDELTANEXT then table.insert( vCmd, { 21, dYDeltaF, 0}) else + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) table.insert( vCmd, { 21, 0, dVDeltaF}) end @@ -1631,54 +1704,61 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) dTPosI = dTPosA - EMC.YDELTA = false - EMC.VDELTA = true + EMC.YDELTA = nil + EMC.VDELTA = dVDeltaI -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- recupero una corsa massima e l'altra solo di quello che serve elseif abs( dVDeltaI - dVDeltaF) > - MinV - MaxV then -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + local dTotMove = MaxY - dTPosI - dYDeltaI dVDeltaI = dVDeltaF dYPosA = MaxY - dTPosA = dTPosI + MaxY - MinY + dTPosA = dTPosI + dTotMove dVPosA = dVDeltaF + dTPosA table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) dTPosI = dTPosA - EMC.YDELTA = false - EMC.VDELTA = true + EMC.YDELTA = nil + EMC.VDELTA = dVDeltaI -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- non serve recuperare al massimo della corsa, suddivido movimento in due else -- suddivido il movimento su entrambe le morse - local nTotMove = ( dVDeltaI - dVDeltaF) / 2 ; + local dTotMove = ( dVDeltaI - dVDeltaF) / 2 - dYPosA = dTPosI + dYDeltaI + nTotMove - dVPosA = dTPosI + dVDeltaI - nTotMove - dTPosA = dTPosI + nTotMove - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - table.insert( vCmd, { 12, 1}) - table.insert( vCmd, { 11, 0}) + if abs( dTotMove) > 10 * GEO.EPS_SMALL then + dYPosA = dTPosI + dYDeltaI + dTotMove + dVPosA = dTPosI + dVDeltaI - dTotMove + dTPosA = dTPosI + dTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) - -- aggiorno nuova posizione della morsa al carico dopo riposizionamento - dVDeltaI = dVDeltaF ; + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dVDeltaI = dVDeltaF ; - if EMC.VDELTANEXT then - dTPosA = dTPosF - dYPosA = dTPosF + dYDeltaF - dVPosA = dTPosF + dVDeltaF - else - dVPosA = MaxV - dTPosA = MaxV - dVDeltaF - dYPosA = - dTPosA - dYDeltaF + if not EMC.YDELTANEXT then + dTPosA = dTPosF + dVPosA = dTPosF + dVDeltaF + dYPosA = ParkY + elseif EMC.VDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + else + dVPosA = MaxV + dTPosA = MaxV - dVDeltaF + dYPosA = - dTPosA - dYDeltaF + end + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento + dYDeltaI = dYDeltaF end - table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) - dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF - - -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento - dYDeltaI = dYDeltaF -- sistemo apertura morse if EMC.YDELTANEXT then @@ -1689,10 +1769,16 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- sposto il carrello Y in parcheggio table.insert( vCmd, { 1, 'V', ParkV}) end + -- imposto i nuovi parametri di aggancio if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) elseif EMC.YDELTANEXT then + table.insert( vCmd, { 11, 1}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 12, 0}) + table.insert( vCmd, { 1, 'V', ParkV}) table.insert( vCmd, { 21, dYDeltaF, 0}) else table.insert( vCmd, { 21, 0, dVDeltaF}) From 9b6c24017da67d257a00b5518d4173ce71fd5673 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Fri, 20 Sep 2024 08:19:22 +0200 Subject: [PATCH 08/14] Piccole correzioni ai calcoli del posizionamento --- Common_FAST.mlse | 76 ++++++++++++++++++++++++++++-------------------- 1 file changed, 44 insertions(+), 32 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 51eb051..e3326f1 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1397,7 +1397,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dVDeltaF = dYDeltaF - ( MinY - MaxV) end - -- se non c'è posizione finale, è lo scarico + -- se non c'è posizione finale, è lo scarico. Allora setto al minimo della morsa allo scarico. if not dTPosF then dTPosF = MaxV - dVDeltaF end @@ -1418,13 +1418,18 @@ 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 può andare in posizione direttamente. - if ( dYDeltaI - dVDeltaF) >= MinY - MaxV + DELTA_SIC and ( dVDeltaF - dVDeltaI > MinV - dVPosI + dYPosI - MaxY and dVDeltaF - dVDeltaI < dVPosI - MinV + dYPosI - MinY) then - + -- SCAMBIO DIRETTO : V IN POSIZIONE FINALE + -- V può andare in posizione direttamente se : + -- * rispetta interasse minimo con Y + -- * deve effettivamente spostarsi + -- * non si arriva da gestione passo del pellegrino + -- * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente + if ( dYDeltaI - dVDeltaF) >= MinY - MaxV and abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and + ( dVDeltaF - dVDeltaI > MinV - dVPosI + MinY - dYPosI) then -- se l'altra morsa non era in presa, vado a pinzare il pezzo if not EMC.YDELTA then dYPosA = MinY - dTPosA = MinY + dYDeltaI + dTPosA = MinY - dYDeltaI dVPosA = dTPosA + dVDeltaI table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI = dTPosA @@ -1474,8 +1479,10 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF elseif EMC.YDELTANEXT then if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then table.insert( vCmd, { 11, 0}) - dYPosA = dTPosI + dYDeltaF - table.insert( vCmd, { 1, 'Y', dYPosA}) + dYPosA = max( MinY, dTPosI + dYDeltaF) + dTPosA = -( dYPosA + dVDeltaF) + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) -- la morsa al carico è adesso in posizione dYDeltaI = dYDeltaF @@ -1493,9 +1500,14 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- movimento terminato dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF - -- scambio diretto. Y può andare in posizione direttamente - elseif ( dYDeltaF - dVDeltaI) >= MinY - MaxV + DELTA_SIC and ( dYDeltaF - dYDeltaI > MinV - dVPosI + dYPosI - MaxY and dYDeltaF - dYDeltaI < dVPosI - MinV + dYPosI - MinY ) then - + -- SCAMBIO DIRETTO : Y IN POSIZIONE FINALE + -- Y può andare in posizione direttamente se : + -- * rispetta interasse minimo con Y + -- * deve effettivamente spostarsi + -- * non si arriva da gestione passo del pellegrino + -- * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente + elseif ( dYDeltaF - dVDeltaI) >= MinY - MaxV and abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and + ( dYDeltaF - dYDeltaI < MaxY - dYPosI + MaxV - dVPosI) then -- se l'altra morsa non era in presa, vado a pinzare il pezzo if not EMC.VDELTA then dVPosA = MaxV @@ -1513,13 +1525,12 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dBeamMove = - ( dYDeltaF - MinY + dTPosI) -- se spostamento verso lo scarico elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) < MinY then - dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MinY + dBeamMove = -( dYPosI + ( dYDeltaF - dYDeltaI) - MinY) -- se spostamento verso il carico elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) > MaxY then dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MaxY end - table.insert( vCmd, { 11, 0}) dTPosA = dTPosI + dBeamMove @@ -1550,8 +1561,10 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF elseif EMC.VDELTANEXT then if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then table.insert( vCmd, { 12, 0}) - dVPosA = dTPosI + dVDeltaF - table.insert( vCmd, { 1, 'V', dVPosA}) + dVPosA = min( MaxV, dTPosI + dVDeltaF) + dTPosA = dVPosA - dVDeltaF + dYPosA = dTPosA + dYDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) -- la morsa al carico è adesso in posizione dVDeltaI = dVDeltaF @@ -1571,7 +1584,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- se devo recuperare corsa con passo del pellegrino else - local bForceMoveY, bForceMoveV + EMC.PILGRIMSTEP = false -- compatto al centro if not EMC.YDELTA then table.insert( vCmd, { 0, 'Compact Y'}) @@ -1583,7 +1596,6 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 1}) dYDeltaI = dVDeltaI - MaxV + MinY EMC.YDELTA = dYDeltaI - bForceMoveV = true dTPosI = dTPosA end if not EMC.VDELTA then @@ -1596,7 +1608,6 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 12, 1}) dVDeltaI = dYDeltaI + MaxV - MinY EMC.VDELTA = dVDeltaI - bForceMoveY = true dTPosI = dTPosA end @@ -1605,26 +1616,27 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- a questo punto entrambe le pinze sono in presa sul pezzo. Il trascinatore si decide in base alla direzione di movimento trave -- trascino con morsa allo scarico - if bForceMoveY or ( dDeltaBeam > 0 and not bForceMoveV) then + if dDeltaBeam > 0 then -- apro morsa al carico table.insert( vCmd, { 11, 0}) -- devo recuperare più del doppio delle corse - if abs( dYDeltaI - dYDeltaF) > ( MinY + MaxY - MinV - MaxV) then + if abs( dYDeltaI - dYDeltaF) > ( MaxY - MinY + MaxV - MinV) then -- calcolo nuova posizione della morsa al carico dopo riposizionamento - dYDeltaI = dYDeltaI + ( MaxY - MinY - MinV + MaxV) dYPosA = MaxY dVPosA = MinV dTPosA = dTPosI - MaxV + MinV table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) + dYDeltaI = - MaxY - dTPosA dTPosI = dTPosA EMC.YDELTA = dYDeltaI EMC.VDELTA = nil + EMC.PILGRIMSTEP = true -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- recupero una corsa massima e l'altra solo di quello che serve - elseif abs( dYDeltaI - dYDeltaF) > MinY + MaxY then + elseif abs( dYDeltaI - dYDeltaF) > MaxY - MinY then -- aggiorno nuova posizione della morsa al carico dopo riposizionamento dYDeltaI = dYDeltaF dVPosA = MinV @@ -1634,8 +1646,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) dTPosI = dTPosA - EMC.YDELTA = dYDeltaI - EMC.VDELTA = nil + EMC.YDELTA = dYDeltaF + EMC.VDELTA = dVDeltaI -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- non serve recuperare al massimo della corsa, suddivido movimento in due @@ -1687,29 +1699,29 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 1, 'Y', ParkY}) table.insert( vCmd, { 21, 0, dVDeltaF}) end - end -- trave si muove dallo scarico verso il carico else -- apro morsa allo scarico table.insert( vCmd, { 12, 0}) -- devo recuperare più del doppio delle corse - if abs( dVDeltaI - dVDeltaF) > ( MinY + MaxY - MinV - MaxV) then + if abs( dVDeltaI - dVDeltaF) > ( MaxY - MinY + MaxV - MinV) then -- calcolo nuova posizione della morsa al carico dopo riposizionamento - dVDeltaI = dVDeltaI - ( MaxY - MinY - MinV + MaxV) dYPosA = MaxY dVPosA = MinV - dTPosA = dTPosI + MaxY - MinY + dTPosA = dTPosI + ( MaxY - MinY) table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) + dVDeltaI = MinV - dTPosA dTPosI = dTPosA EMC.YDELTA = nil EMC.VDELTA = dVDeltaI + EMC.PILGRIMSTEP = true -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- recupero una corsa massima e l'altra solo di quello che serve - elseif abs( dVDeltaI - dVDeltaF) > - MinV - MaxV then + elseif abs( dVDeltaI - dVDeltaF) > MaxV - MinV then -- aggiorno nuova posizione della morsa al carico dopo riposizionamento local dTotMove = MaxY - dTPosI - dYDeltaI dVDeltaI = dVDeltaF @@ -1720,8 +1732,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) dTPosI = dTPosA - EMC.YDELTA = nil - EMC.VDELTA = dVDeltaI + EMC.YDELTA = dYDeltaI + EMC.VDELTA = dVDeltaF -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- non serve recuperare al massimo della corsa, suddivido movimento in due @@ -1751,12 +1763,12 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF else dVPosA = MaxV dTPosA = MaxV - dVDeltaF - dYPosA = - dTPosA - dYDeltaF + dYPosA = dTPosA + dYDeltaF end table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF - -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento dYDeltaI = dYDeltaF end From c33c3196f26ef21e3705400d50fe972b3001d88b Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Fri, 20 Sep 2024 10:01:56 +0200 Subject: [PATCH 09/14] =?UTF-8?q?Rimosse=20variabili=20non=20pi=C3=B9=20ut?= =?UTF-8?q?ilizzate?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Common_FAST.mlse | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index e3326f1..cc92bed 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1585,6 +1585,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- se devo recuperare corsa con passo del pellegrino else EMC.PILGRIMSTEP = false + local bForceMoveY, bForceMoveV -- compatto al centro if not EMC.YDELTA then table.insert( vCmd, { 0, 'Compact Y'}) @@ -1596,6 +1597,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 1}) dYDeltaI = dVDeltaI - MaxV + MinY EMC.YDELTA = dYDeltaI + bForceMoveV = true dTPosI = dTPosA end if not EMC.VDELTA then @@ -1608,6 +1610,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 12, 1}) dVDeltaI = dYDeltaI + MaxV - MinY EMC.VDELTA = dVDeltaI + bForceMoveY = true dTPosI = dTPosA end From 21104984ad5f0a6946d743eb11939489a32668f8 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Fri, 20 Sep 2024 12:13:25 +0200 Subject: [PATCH 10/14] Aggiunto controllo tolleranza su posizione pinze per evitare riposizionamenti --- Common_FAST.mlse | 158 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 130 insertions(+), 28 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index cc92bed..a682dd5 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1145,6 +1145,49 @@ function GetMachiningStartingPoint( idPath) return nil end +--------------------------------------------------------------------- +local function AdjustPositionsForB( dNewYDelta, dNewVDelta, TCING, HCING, HOVM, bFixedDelta) + local REF_DIST = 1400 + local dYDelta = 0 + local dVDelta = 0 + -- incremento se possibile la distanza tra le due posizioni + if not bFixedDelta and ( dNewYDelta - dNewVDelta) < REF_DIST then + local dEffAddDist = ( REF_DIST - ( dNewYDelta - dNewVDelta)) / 2 + dYDelta = max( min( dEffAddDist, EMC.LB - dNewYDelta - MinJoin - TCING), 0) + dVDelta = max( min( dEffAddDist, dNewVDelta - MinJoin - HOVM - HCING), 0) + end + return dYDelta, dVDelta +end + +--------------------------------------------------------------------- +local function GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta) + local dDeltaTolEff = DELTA_SIC + if Carr == 'Y' then + local dLenPreEff = dLenPresa - TCING + if dLenPreEff < MinJoin + DeltaTol then + dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) + else + if BD.GO_FAST and BD.GO_FAST ~= 0 then + if bFixedDelta == false then + dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200) + else + dDeltaTolEff = 900 + end + else + dDeltaTolEff = DeltaTol + end + end + elseif Carr == 'V' then + local dLenPreEff = dLenPresa - HCING - HOVM + if dLenPreEff < MinJoin + DeltaTol then + dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) + else + dDeltaTolEff = DeltaTol + end + end + return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff) +end + --------------------------------------------------------------------- function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) @@ -1175,16 +1218,72 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) -- [A] se posso mettere solo carrello Y if dDistFrontEff < MinFrontJoin and dDistBackEff > MinBackJoin - GEO.EPS_SMALL then + -- se Y non era in presa, mi ricalcolo la posizione + if not dYDelta then + dYDelta = dVDelta + ( MinY - MaxV) + end dNewYDelta = EMC.LB - dDistBackEff + -- verifico se posso lasciare la morsa in posizione + local dYDeltaTol = GetDeltaTol( EMC.LB - dNewYDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y') + local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC) + if bYDeltaS then + dNewYDelta = dNewYDelta + dYDeltaTol/2 + else + dNewYDelta = dYDelta + end + dNewVDelta = nil -- [B] se altrimenti posso mettere entrambi i carrelli Y e V elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + -- se Y non era in presa, mi ricalcolo la posizione + if not dYDelta then + dYDelta = dVDelta + ( MinY - MaxV) + end + -- se V non era in presa, mi ricalcolo la posizione + if not dVDelta then + dVDelta = dYDelta - ( MinY - MaxV) + end + dNewYDelta = EMC.LB - dDistBackEff dNewVDelta = dDistFrontEff + + -- incremento la distanza tra le due posizioni ( se abilitato e possibile) + local dYDeltaAgg, dVDeltaAgg = AdjustPositionsForB( dNewYDelta, dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta) + -- tolleranze + local dYDeltaTol = dYDeltaAgg + GetDeltaTol( EMC.LB - dNewYDelta - dYDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y', bFixedDelta) + local dVDeltaTol = dVDeltaAgg + GetDeltaTol( dNewVDelta - dVDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + -- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze + local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC) + local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or dNewVDelta < dVDelta - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bYDeltaS then + dNewYDelta = dNewYDelta + dYDeltaTol / 2 + else + dNewYDelta = dYDelta + end + if bVDeltaS then + dNewVDelta = dNewVDelta - dVDeltaTol / 2 + else + dNewVDelta = dVDelta + end + -- [C] se altrimenti posso mettere solo carrello V elseif dDistBackEff < MinBackJoin and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then - dNewYDelta = nil + -- se V non era in presa, mi ricalcolo la posizione + if not dVDelta then + dVDelta = dYDelta - ( MinY - MaxV) + end dNewVDelta = dDistFrontEff + -- verifico se posso lasciare la morsa in posizione + local dVDeltaTol = GetDeltaTol( dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or dNewVDelta < dVDelta - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bVDeltaS then + dNewVDelta = dNewVDelta - dVDeltaTol/2 + else + dNewVDelta = dVDelta + end + dNewYDelta = nil -- altrimenti errore else if EgtGetDebugLevel() < 3 then @@ -1202,8 +1301,6 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) local vCmd = {} SpecAdjustCarriages( vCmd, dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - -- reset contatore - EMC.CNT = nil SpecOutputCNT() return vCmd @@ -1383,18 +1480,21 @@ end function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) local dYPosA, dVPosA, dTPosA + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + -- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando if not dYDeltaI then - dYDeltaI = dVDeltaI + ( MinY - MaxV) + dYDeltaI = dVDeltaI + ( MyMinY - MaxV) end if not dVDeltaI then - dVDeltaI = dYDeltaI - ( MinY - MaxV) + dVDeltaI = dYDeltaI - ( MyMinY - MaxV) end if not dYDeltaF then - dYDeltaF = dVDeltaF + ( MinY - MaxV) + dYDeltaF = dVDeltaF + ( MyMinY - MaxV) end if not dVDeltaF then - dVDeltaF = dYDeltaF - ( MinY - MaxV) + dVDeltaF = dYDeltaF - ( MyMinY - MaxV) end -- se non c'è posizione finale, è lo scarico. Allora setto al minimo della morsa allo scarico. @@ -1411,7 +1511,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end -- ricavo posizione delle morse nelle corse - local dYPosI = max( MinY, dTPosI + dYDeltaI) + local dYPosI = max( MyMinY, dTPosI + dYDeltaI) local dVPosI = min( MaxV, dTPosI + dVDeltaI) -- calcolo delta spostamento trave @@ -1424,12 +1524,12 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- * deve effettivamente spostarsi -- * non si arriva da gestione passo del pellegrino -- * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente - if ( dYDeltaI - dVDeltaF) >= MinY - MaxV and abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and - ( dVDeltaF - dVDeltaI > MinV - dVPosI + MinY - dYPosI) then + 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 -- se l'altra morsa non era in presa, vado a pinzare il pezzo if not EMC.YDELTA then - dYPosA = MinY - dTPosA = MinY - dYDeltaI + dYPosA = MyMinY + dTPosA = MyMinY - dYDeltaI dVPosA = dTPosA + dVDeltaI table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) dTPosI = dTPosA @@ -1479,7 +1579,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF elseif EMC.YDELTANEXT then if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then table.insert( vCmd, { 11, 0}) - dYPosA = max( MinY, dTPosI + dYDeltaF) + dYPosA = max( MyMinY, dTPosI + dYDeltaF) dTPosA = -( dYPosA + dVDeltaF) dVPosA = dTPosA + dVDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) @@ -1506,7 +1606,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- * deve effettivamente spostarsi -- * non si arriva da gestione passo del pellegrino -- * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente - elseif ( dYDeltaF - dVDeltaI) >= MinY - MaxV and abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and + 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 -- se l'altra morsa non era in presa, vado a pinzare il pezzo if not EMC.VDELTA then @@ -1522,10 +1622,10 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo -- se non era ingagiata, vado al suo minimo if not EMC.YDELTA then - dBeamMove = - ( dYDeltaF - MinY + dTPosI) + dBeamMove = - ( dYDeltaF - MyMinY + dTPosI) -- se spostamento verso lo scarico - elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) < MinY then - dBeamMove = -( dYPosI + ( dYDeltaF - dYDeltaI) - MinY) + elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) < MyMinY then + dBeamMove = -( dYPosI + ( dYDeltaF - dYDeltaI) - MyMinY) -- se spostamento verso il carico elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) > MaxY then dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MaxY @@ -1592,10 +1692,10 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 0}) dTPosA = MaxV - dVDeltaI dVPosA = MaxV - dYPosA = MinY + dYPosA = MyMinY table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) - dYDeltaI = dVDeltaI - MaxV + MinY + dYDeltaI = dVDeltaI - MaxV + MyMinY EMC.YDELTA = dYDeltaI bForceMoveV = true dTPosI = dTPosA @@ -1603,12 +1703,12 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF if not EMC.VDELTA then table.insert( vCmd, { 0, 'Compact V'}) table.insert( vCmd, { 12, 0}) - dTPosA = MinY - dYDeltaI + dTPosA = MyMinY - dYDeltaI dVPosA = MaxV - dYPosA = MinY + dYPosA = MyMinY table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) - dVDeltaI = dYDeltaI + MaxV - MinY + dVDeltaI = dYDeltaI + MaxV - MyMinY EMC.VDELTA = dVDeltaI bForceMoveY = true dTPosI = dTPosA @@ -1623,7 +1723,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- apro morsa al carico table.insert( vCmd, { 11, 0}) -- devo recuperare più del doppio delle corse - if abs( dYDeltaI - dYDeltaF) > ( MaxY - MinY + MaxV - MinV) then + if abs( dYDeltaI - dYDeltaF) > ( MaxY - MyMinY + MaxV - MinV) then -- calcolo nuova posizione della morsa al carico dopo riposizionamento dYPosA = MaxY dVPosA = MinV @@ -1639,7 +1739,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- recupero una corsa massima e l'altra solo di quello che serve - elseif abs( dYDeltaI - dYDeltaF) > MaxY - MinY then + elseif abs( dYDeltaI - dYDeltaF) > MaxY - MyMinY then -- aggiorno nuova posizione della morsa al carico dopo riposizionamento dYDeltaI = dYDeltaF dVPosA = MinV @@ -1678,8 +1778,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dYPosA = dTPosF + dYDeltaF dVPosA = dTPosF + dVDeltaF else - dYPosA = MinY - dTPosA = MinY - dYDeltaF + dYPosA = MyMinY + dTPosA = MyMinY - dYDeltaF dVPosA = dTPosA + dVDeltaF end table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) @@ -1708,11 +1808,11 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- apro morsa allo scarico table.insert( vCmd, { 12, 0}) -- devo recuperare più del doppio delle corse - if abs( dVDeltaI - dVDeltaF) > ( MaxY - MinY + MaxV - MinV) then + if abs( dVDeltaI - dVDeltaF) > ( MaxY - MyMinY + MaxV - MinV) then -- calcolo nuova posizione della morsa al carico dopo riposizionamento dYPosA = MaxY dVPosA = MinV - dTPosA = dTPosI + ( MaxY - MinY) + dTPosA = dTPosI + ( MaxY - MyMinY) table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) @@ -1801,6 +1901,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end end end + -- reset contatore primo riposizionamento con compensazione lettura laser + EMC.CNT = nil end end From 48626b7f90b1b5559fa922be65fa288b41c4da56 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Fri, 20 Sep 2024 16:00:24 +0200 Subject: [PATCH 11/14] =?UTF-8?q?-=20Compensazione=20errore=20laser=20al?= =?UTF-8?q?=20carico=20per=20primo=20riposizionamento=20-=20Rimosse=20vari?= =?UTF-8?q?abili=20non=20pi=C3=B9=20utilizzate?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Common_FAST.mlse | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index a682dd5..19ae4dc 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1503,7 +1503,8 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end -- verifico che le morse non sono in posizione - if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL or abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL or abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL or + EMC.YDELTA ~= EMC.YDELTANEXT or EMC.VDELTA ~= EMC.VDELTANEXT then if #vCmd == 0 then table.insert( vCmd, { 0, 'Clamp repositioning'}) -- risalita testa a Zmax @@ -1537,7 +1538,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 1}) end -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo - -- se non era ingagiata, vado al suo minimo + -- se non era ingaggiata, vado al suo minimo if not EMC.VDELTA then dBeamMove = -( MaxV - dVDeltaF - dTPosI) -- se spostamento verso lo scarico @@ -1608,6 +1609,8 @@ 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 + -- compenso delta errore misurazione laser + dVDeltaI = dVDeltaI - EgtIf( EMC.CNT == 1, AGG_LOAD, 0) -- se l'altra morsa non era in presa, vado a pinzare il pezzo if not EMC.VDELTA then dVPosA = MaxV @@ -1620,7 +1623,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo - -- se non era ingagiata, vado al suo minimo + -- se non era ingaggiata, vado al suo minimo if not EMC.YDELTA then dBeamMove = - ( dYDeltaF - MyMinY + dTPosI) -- se spostamento verso lo scarico @@ -1685,7 +1688,6 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- se devo recuperare corsa con passo del pellegrino else EMC.PILGRIMSTEP = false - local bForceMoveY, bForceMoveV -- compatto al centro if not EMC.YDELTA then table.insert( vCmd, { 0, 'Compact Y'}) @@ -1697,7 +1699,6 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 11, 1}) dYDeltaI = dVDeltaI - MaxV + MyMinY EMC.YDELTA = dYDeltaI - bForceMoveV = true dTPosI = dTPosA end if not EMC.VDELTA then @@ -1710,7 +1711,6 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 12, 1}) dVDeltaI = dYDeltaI + MaxV - MyMinY EMC.VDELTA = dVDeltaI - bForceMoveY = true dTPosI = dTPosA end From 446b56d97554c88229b8686279b1f80638c68f4d Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Fri, 20 Sep 2024 17:05:55 +0200 Subject: [PATCH 12/14] Piccole correzioni a calcoli e gestione offset iniziale --- Common_FAST.mlse | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 19ae4dc..9ffde1d 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1609,8 +1609,6 @@ 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 - -- compenso delta errore misurazione laser - dVDeltaI = dVDeltaI - EgtIf( EMC.CNT == 1, AGG_LOAD, 0) -- se l'altra morsa non era in presa, vado a pinzare il pezzo if not EMC.VDELTA then dVPosA = MaxV @@ -1620,6 +1618,9 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dTPosI = dTPosA dYPosI = dYPosA table.insert( vCmd, { 12, 1}) + else + -- compenso delta errore misurazione laser + dVDeltaI = dVDeltaI - EgtIf( EMC.CNT == 1, AGG_LOAD, 0) end -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo @@ -1731,7 +1732,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 11, 1}) table.insert( vCmd, { 12, 0}) - dYDeltaI = - MaxY - dTPosA + dYDeltaI = MaxY - dTPosA dTPosI = dTPosA EMC.YDELTA = dYDeltaI EMC.VDELTA = nil From 5ae185cd0ecf23c25a1ab932cc8ecaaec16db83b Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Mon, 23 Sep 2024 09:51:06 +0200 Subject: [PATCH 13/14] Prima versione funzionante con tutti i test 101 e altri test ulteriori --- Common_FAST.mlse | 67 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 18 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index 9ffde1d..4458830 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1097,16 +1097,24 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack) local dNewVDelta = nil local dNewY = dPosT + TurnerOffs + dNewYDelta local vCmd = {} - EgtOutLog( ' *[L]', 1) - -- [L-1] - if dNewY - MaxY > 0 then - dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) - EgtOutLog( ' *[L1]', 1) - end --[L-2] - if EMC.LB - dNewYDelta < MinJoin then - dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) - EgtOutLog( ' *[L2]', 1) + + -- se flag attivo, vado a pinzare al massimo della corsa + if BD.FASTCLAMPING then + EgtOutLog( ' *[L]', 1) + -- [L-1] + if dNewY - MaxY > 0 then + dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) + EgtOutLog( ' *[L1]', 1) + end --[L-2] + if EMC.LB - dNewYDelta < MinJoin then + dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) + EgtOutLog( ' *[L2]', 1) + end + else + -- si pinza sempre a 1000mm massimo + dNewYDelta = min( dNewYDelta, 1000) end + -- Commento table.insert( vCmd, { 0, 'Loading'}) -- risalita testa a Zmax @@ -1511,9 +1519,23 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF local bZmaxOk = EnsureZmax( bZmaxOk, vCmd) end + -- reset contatore primo riposizionamento con compensazione lettura laser + EMC.CNT = nil + -- ricavo posizione delle morse nelle corse local dYPosI = max( MyMinY, dTPosI + dYDeltaI) local dVPosI = min( MaxV, dTPosI + dVDeltaI) + -- calcolo eventuale massimo riposizionamento con passo del pellegrino. Al primo step si calcolano posizioni attuali delle morse + local dMaxMovePilgrimStepDoubleClamp, dMaxMovePilgrimStepSingleClampY, dMaxMovePilgrimStepSingleClampV + if not EMC.PILGRIMSTEP then + dMaxMovePilgrimStepDoubleClamp = MaxY - dYPosI - MinV + dVPosI + dMaxMovePilgrimStepSingleClampY = MaxY - dYPosI + dMaxMovePilgrimStepSingleClampV = - MinV + dVPosI + else + dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV + dMaxMovePilgrimStepSingleClampY = MaxY - MinY + dMaxMovePilgrimStepSingleClampV = - MinV + MaxV + end -- calcolo delta spostamento trave local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico @@ -1701,6 +1723,11 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dYDeltaI = dVDeltaI - MaxV + MyMinY EMC.YDELTA = dYDeltaI dTPosI = dTPosA + dYPosI = dYPosA + dVPosI = dVPosA + dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV + dMaxMovePilgrimStepSingleClampY = MaxY - MinY + dMaxMovePilgrimStepSingleClampV = - MinV + MaxV end if not EMC.VDELTA then table.insert( vCmd, { 0, 'Compact V'}) @@ -1713,6 +1740,11 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dVDeltaI = dYDeltaI + MaxV - MyMinY EMC.VDELTA = dVDeltaI dTPosI = dTPosA + dYPosI = dYPosA + dVPosI = dVPosA + dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV + dMaxMovePilgrimStepSingleClampY = MaxY - MinY + dMaxMovePilgrimStepSingleClampV = - MinV + MaxV end -- aggiorno delta mancante @@ -1723,12 +1755,12 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF if dDeltaBeam > 0 then -- apro morsa al carico table.insert( vCmd, { 11, 0}) - -- devo recuperare più del doppio delle corse - if abs( dYDeltaI - dYDeltaF) > ( MaxY - MyMinY + MaxV - MinV) then + -- devo recuperare più delle corse disponiobili 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 - MaxV + 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}) @@ -1740,7 +1772,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- recupero una corsa massima e l'altra solo di quello che serve - elseif abs( dYDeltaI - dYDeltaF) > MaxY - MyMinY then + elseif abs( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepSingleClampY then -- aggiorno nuova posizione della morsa al carico dopo riposizionamento dYDeltaI = dYDeltaF dVPosA = MinV @@ -1809,11 +1841,12 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- apro morsa allo scarico table.insert( vCmd, { 12, 0}) -- devo recuperare più del doppio delle corse - if abs( dVDeltaI - dVDeltaF) > ( MaxY - MyMinY + MaxV - MinV) then + local dMaxMoveFirst + if abs( dVDeltaI - dVDeltaF) > dMaxMovePilgrimStepDoubleClamp then -- calcolo nuova posizione della morsa al carico dopo riposizionamento dYPosA = MaxY dVPosA = MinV - dTPosA = dTPosI + ( MaxY - MyMinY) + dTPosA = dTPosI + ( MaxY - dYPosI) table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) table.insert( vCmd, { 12, 1}) table.insert( vCmd, { 11, 0}) @@ -1825,7 +1858,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- recupero una corsa massima e l'altra solo di quello che serve - elseif abs( dVDeltaI - dVDeltaF) > MaxV - MinV then + elseif abs( dVDeltaI - dVDeltaF) > dMaxMovePilgrimStepSingleClampV then -- aggiorno nuova posizione della morsa al carico dopo riposizionamento local dTotMove = MaxY - dTPosI - dYDeltaI dVDeltaI = dVDeltaF @@ -1902,8 +1935,6 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end end end - -- reset contatore primo riposizionamento con compensazione lettura laser - EMC.CNT = nil end end From 8fdda065d45426c2fb4307c0e4014d7007ef01e5 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Mon, 23 Sep 2024 11:28:35 +0200 Subject: [PATCH 14/14] 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