Kepler-Release/Venus/Venus_RT/Modules/PMs/LoadLockLeakCheckRoutine.cs

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Venus_RT.Devices;
using MECF.Framework.Common.Routine;
using Venus_Core;
namespace Venus_RT.Modules.PMs
{
    class LoadLockLeakCheckRoutine : PMRoutineBase, IRoutine
    {
        private enum LeakCheckStep
        {
            kCloseValves,
            kPumpToBasePressure,
            kPumpingDelay,
            kLeakCheckDelay,
            kLeakCheckCalc,
            kPumpToBasePressure_2,
            kEnd,
        }
        public double LeakRate { get; private set; }

        private int _basePressureLL = 100;
        private int _leakcheckPumpTimeLL = 180;
        private int _leakcheckWaitTimeLL = 300;

        private double _startPressure = 0;
        private double _endPressure = 0;
        private double _leakRate = 30.0;


        public LoadLockLeakCheckRoutine(JetPMBase chamber) : base(chamber)
        {
            Name = "Loadlock Leakcheck";
        }

        public RState Start(params object[] objs)
        {
            if (CheckLidLoadLock() &&
                CheckSlitDoor() &&
                CheckDryPump())
            {
                Reset();

                _chamber.CloseValves();
                _basePressureLL = SC.GetValue<int>($"{Module}.Pump.LoadLockPumpBasePressure");
                _leakcheckPumpTimeLL = SC.GetValue<int>($"{Module}.Pump.LoadLockLeakCheckPumpTime");
                _leakcheckWaitTimeLL = SC.GetValue<int>($"{Module}.Pump.LoadLockLeakCheckWaitTime");
                _leakRate = SC.GetValue<double>($"{Module}.Pump.LoadLockLeakRate");

                return Runner.Start(Module, Name);
            }
            return RState.Failed;
        }

        public RState Monitor()
        {
            Runner.Delay(LeakCheckStep.kCloseValves,       _delay_1s)
                .Run(LeakCheckStep.kPumpToBasePressure,    HOFs.WrapAction(_chamber.OpenValve, ValveType.LoadlockPumping, true),   () => { return _chamber.LoadlockPressure <= _basePressureLL; })
                .Delay(LeakCheckStep.kPumpingDelay,        _leakcheckPumpTimeLL * 1000)
                .Run(LeakCheckStep.kLeakCheckDelay,        StartLeakCheck,                                                         _leakcheckWaitTimeLL * 1000)
                .Run(LeakCheckStep.kLeakCheckCalc,         CalcLeakCheckResult,                                                    _delay_50ms)
                .Run(LeakCheckStep.kPumpToBasePressure_2,  HOFs.WrapAction(_chamber.OpenValve, ValveType.LoadlockPumping, true),   () => { return _chamber.LoadlockPressure <= _basePressureLL; })
                .End(LeakCheckStep.kEnd,                   LeakCheckEnd,                                                           _delay_50ms);

            return Runner.Status;
        }

        public void Abort()
        {
            CloseAllValves();
        }

        bool StartLeakCheck()
        {
            _chamber.OpenValve(ValveType.LoadlockPumping, false);
            _startPressure = _chamber.LoadlockPressure;

            Notify($"LoadLock压力开始值 {_startPressure} mt");
            return true;
        }

        bool CalcLeakCheckResult()
        {
            _endPressure = _chamber.LoadlockPressure;

            LeakRate = (_endPressure - _startPressure) * 60.0 / _leakcheckWaitTimeLL;

            if(LeakRate < _leakRate)
            {
                Notify($"LoadLock Leakcheck完成， 压力结束值: {_startPressure} mt， 漏率：{LeakRate} mt/min");
            }
            else
            {
                Stop($"LoadLock Leakcheck失败， 腔体漏率 [{LeakRate}] mt/min, 高于 [{_leakRate}] mt/min");
            }
            
            return true;
        }

        bool LeakCheckEnd()
        {
            // 临时版试验机， 关Pumping Valve, 正式版保持 Pumping Valve 打开
            _chamber.OpenValve(ValveType.LoadlockPumping, false);
            return true;
        }
    }
}