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;
using MECF.Framework.Common.DBCore;
using System;

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 string CurrentStep;
        private string _result;
        PressureType _pressureType = PressureType.mTorr;


        public MFLeakCheckRoutine(JetTM tm, ModuleName mod) : base(mod)
        {
            Name = $"{Module} Leakcheck";
            _JetTM = tm;
            //if (RtInstance.pressureType == PressureType.Pa)
            //{
            //    _pressureType=PressureType.Pa;
            //}
        }

        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");
                _result = "";
                return Runner.Start(Module, Name);
            }
            return RState.Failed;
        }

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

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

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

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

            }

            return true;
        }

        bool LeakCheckEnd()
        {
            _JetTM.CloseModuleAllValves(Module);
            LeakCheckDataRecorder.Add(_leakcheckPumpTime, Math.Round(_startPressure, 1), Math.Round(_endPressure, 1), LeakRate, _result, "", Module.ToString(), "");
            return true;
        }

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

            return true;
        }
    }
}