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

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;

namespace Venus_RT.Modules.TM.VenusEntity
{
    public class SEMFPumpRoutine : ModuleRoutineBase, IRoutine
    {
        public enum PumpDownStep
        {
            seWaitModuleReady,
            seOpenSoftPump,
            seSwitchFastPump,
            seClosePumpValves,
            seDelayForSafe,
            seReleasePump
        }

        private double _pumpBasePressure;
        private double _pumpCrossingPressure;
        private int _pumpingTimeout;
        private int _switchPumpDelay;
        private readonly HongHuTM _TM;

        public SEMFPumpRoutine(HongHuTM tm,ModuleName module) : base(module)
        {
            _TM = tm;
            Name = "Pump Down";
        }
        public RState Start(params object[] objs)
        {
            //待补充 lid purge状态检查 没有相关IO
            if (_TM.CheckVentValveClosed(Module))
            {
                Reset();
                _pumpBasePressure = SC.GetValue<double>($"{Module}.PumpBasePressure");
                _pumpCrossingPressure = SC.GetValue<double>($"{Module}.PumpCrossingPressure");
                _pumpingTimeout = SC.GetValue<int>($"{Module}.PumpingTimeout") * 1000;
                _switchPumpDelay = SC.GetValue<int>($"{Module}.SwitchPumpDelay");

                return Runner.Start(Module, Name);
            }

            return RState.Failed;
        }

        public RState Monitor()
        {
            Runner
                .Wait(PumpDownStep.seWaitModuleReady,       WaitPump,                                               _delay_60s)
                .Run(PumpDownStep.seOpenSoftPump,           OpenSoftPump,           ArriveCrossPressure,            _pumpingTimeout)
                .Run(PumpDownStep.seSwitchFastPump,         SwitchFastPump,         IsPressureReady,                _pumpingTimeout)
                .Run(PumpDownStep.seClosePumpValves,        ClosePumpValves,        NullFun)
                .Delay(PumpDownStep.seDelayForSafe,                                                                 _switchPumpDelay)
                .End(PumpDownStep.seReleasePump,            ReleaseTMPump,NullFun);
            return Runner.Status;
        }

        private bool WaitPump()
        {
            if (!IsPressureReady())
            {
                return _TM.TryGetPump(Module);
            }
            return true;
        }

        private bool OpenSoftPump()
        {
            if (!IsPressureReady())
            {
                _TM.TurnSoftPumpValve(Module, true);
            }
            return true;
        }

        private bool ArriveCrossPressure()
        {
            return _TM.GetModulePressure(Module) < _pumpCrossingPressure;
        }

        public bool SwitchFastPump()
        {
            if (!IsPressureReady())
            {
                _TM.TurnSoftPumpValve(Module,false);
                _TM.TurnFastPumpValve(Module,true);
            }
            return true;
        }

        public bool IsPressureReady() 
        {
            return _TM.GetModulePressure(Module) < _pumpBasePressure;
        }

        public bool ClosePumpValves()
        {
            _TM.TurnFastPumpValve(Module, false);
            _TM.TurnSoftPumpValve(Module, false);
            return true;
        }

        public bool ReleaseTMPump()
        {
            _TM.ReleasePump(Module);
            return true;
        }

        public void Abort()
        {
            _TM.TurnFastPumpValve(Module, false);
            _TM.TurnSoftPumpValve(Module, false);
        }
    }
}