Kepler-Release/Venus/Venus_RT/Modules/TM/MFLeakCheckRoutine.cs

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Venus_RT.Devices;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Equipment;
using Venus_Core;

namespace Venus_RT.Modules.TM
{
    class MFLeakCheckRoutine : ModuleRoutineBase, IRoutine
    {
        private enum LeakCheckStep
        {
            kCloseValves,
            kPumpToCrossing,
            kPumpToBasePressure,
            kPumpingDelay,
            kLeakCheckDelay,
            kLeakCheckCalc,
            kPumpToCrossing_2,
            kPumpToBasePressure_2,
            kEnd,
        }
        public double LeakRate { get; private set; }

        private double _basePressure = 100;
        private double _CrossingPressure = 2000;
        private int _leakcheckPumpTime = 180;
        private int _leakcheckWaitTime = 300;

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

        private readonly JetTM _JetTM;

        public MFLeakCheckRoutine(JetTM tm, ModuleName mod) : base(mod)
        {
            Name = $"{Module} Leakcheck";
            _JetTM = tm;
        }

        public RState Start(params object[] objs)
        {
            if (_JetTM.CheckLidClosed(Module) &&
                _JetTM.CheckVentValveClosed(Module) &&
                _JetTM.CheckPurgeValveClosed(Module) &&
                _JetTM.CheckPumpValveClosed(Module))
            {
                Reset();

                _JetTM.CloseModuleAllValves(Module);

                _basePressure = SC.GetValue<double>($"{Module}.PumpBasePressure");
                _CrossingPressure = SC.GetValue<double>($"{Module}.PumpCrossingPressure");
                _leakcheckPumpTime = SC.GetValue<int>($"{Module}.LeakCheckPumpTime");
                _leakcheckWaitTime = SC.GetValue<int>($"{Module}.LeakCheckWaitTime");
                _leakRate = SC.GetValue<double>($"{Module}.LeakRate");

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

        public RState Monitor()
        {
            Runner.Delay((int)LeakCheckStep.kCloseValves,       _delay_1s)
                .Run((int)LeakCheckStep.kPumpToCrossing,        HOFs.WrapAction(_JetTM.TurnSoftPumpValve, Module, true),    () => { return _JetTM.GetModulePressure(Module) <= _CrossingPressure; })
                .Run((int)LeakCheckStep.kPumpToBasePressure,    SwitchFastPump,                                             () => { return _JetTM.GetModulePressure(Module) <= _basePressure; })
                .Delay((int)LeakCheckStep.kPumpingDelay,        _leakcheckPumpTime * 1000)
                .Run((int)LeakCheckStep.kLeakCheckDelay,        StartLeakCheck,                                             _leakcheckWaitTime * 1000)
                .Run((int)LeakCheckStep.kLeakCheckCalc,         CalcLeakCheckResult,                                        _delay_50ms)
                .Run((int)LeakCheckStep.kPumpToCrossing_2,      HOFs.WrapAction(_JetTM.TurnSoftPumpValve, Module, true),    () => { return _JetTM.GetModulePressure(Module) <= _CrossingPressure; })
                .Run((int)LeakCheckStep.kPumpToBasePressure_2,  SwitchFastPump,                                             () => { return _JetTM.GetModulePressure(Module) <= _basePressure; })
                .End((int)LeakCheckStep.kEnd,                   LeakCheckEnd,                                               _delay_50ms);

            return Runner.Status;
        }

        public void Abort()
        {
            _JetTM.CloseModuleAllValves(Module);
        }

        bool StartLeakCheck()
        {
            _JetTM.TurnFastPumpValve(Module, false);
            _startPressure = _JetTM.GetModulePressure(Module);

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

        bool CalcLeakCheckResult()
        {
            _endPressure = _JetTM.GetModulePressure(Module);

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

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

            return true;
        }

        bool LeakCheckEnd()
        {
            _JetTM.CloseModuleAllValves(Module);
            return true;
        }

        private bool SwitchFastPump()
        {
            _JetTM.TurnSoftPumpValve(Module, false);
            _JetTM.TurnFastPumpValve(Module, true);

            return true;
        }
    }
}