Kepler-Release/Venus/Venus_RT/Modules/TM/VenusEntity/SEMFVentRoutine.cs

using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.Equipment;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Venus_Core;
using Venus_RT.Devices;
using Venus_RT.Devices.TM;

namespace Venus_RT.Modules.TM.VenusEntity
{
    public class SEMFVentRoutine : ModuleRoutineBase, IRoutine
    {

        private enum SEVentStep
        {
            seTryGetVent,
            seOpenSoftVent,
            seSwitchFastVent,
            seDelayForClose,
            seCloseVentValves,
            seReleaseVent
        }


        private int _venttimeout;
        private int _ventcrosspressure;
        private int _ventDelay;
        private readonly TMBase _tm;
        //private SEVentStatus
        public SEMFVentRoutine(TMBase tm, ModuleName module) : base(module)
        {
            _tm = tm;
            Name = "Vent";

        }


        public RState Start(params object[] objs)
        {
            if (_tm.CheckPumpValveClosed(Module))
            {
                Reset();
                _venttimeout = SC.GetValue<int>($"{Module}.VentingTimeout") * 1000;
                _ventcrosspressure = SC.GetValue<int>($"{Module}.SoftVentEndPressure");
                _ventDelay = SC.GetValue<int>($"{Module}.OverVentDelay")*1000;
                return Runner.Start(Module, Name);
            }
            else
            {
                LOG.Write(eEvent.ERR_DEVICE_INFO,Module, "Pump Valve not all Close! Cannot Vent!");
                return RState.Failed;
            }
        }

        public RState Monitor()
        {
            Runner.Wait(SEVentStep.seTryGetVent,            TryGetVent                   ,_delay_60s)
                   .Run(SEVentStep.seOpenSoftVent,           OpenSoftVentValve,          IsSoftVentEnd)
                   .Run(SEVentStep.seSwitchFastVent,        SwitchFastVentValve,        IsPressureReady,        _venttimeout)
                   .Delay(SEVentStep.seDelayForClose,       _ventDelay)
                   .Run(SEVentStep.seCloseVentValves,       CloseVentValve,             NullFun,                _delay_50ms)
                   .End(SEVentStep.seReleaseVent,           ReleaseVent,                NullFun,                _delay_50ms);
            return Runner.Status;
        }
        private bool ReleaseVent()
        {
            _tm.ReleaseVent(Module);
            return true;
        }
        private bool TryGetVent()
        {
            return _tm.TryGetVent(Module);
        }

        private bool OpenSoftVentValve()
        {
            _tm.TurnSoftVentValve(Module, true);
            return true;
        }

        private bool IsSoftVentEnd() => _tm.GetModulePressure(Module) > _ventcrosspressure;

        private bool SwitchFastVentValve()
        {
            if (Module == ModuleName.TM)
                _tm.SetTMFlow(100);
            _tm.TurnSoftVentValve(Module, false);
            _tm.TurnFastVentValve(Module, true);
            return true;
        }

        private bool IsPressureReady()
        {
            switch (Module)
            {
               case ModuleName.TM:
                    return _tm.IsTMATM;
               case ModuleName.VCE1:
                    return _tm.IsVCEATM;
                case ModuleName.VCEA:
                    return _tm.IsVCEAATM;
                case ModuleName.VCEB:
                    return _tm.IsVCEBATM;
            }
            return false;
        }

        private bool CloseVentValve()
        {
            _tm.TurnSoftVentValve(Module,false);
            _tm.TurnFastVentValve(Module,false);

            if (Module == ModuleName.TM)
                _tm.SetTMFlow(0);

            return true;
        }

        public void Abort()
        {
            _tm.TurnFastVentValve(Module,false);
            _tm.TurnSoftVentValve(Module, false);
            _tm.ReleaseVent(Module);
        }
    }
}