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

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Routine;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using static Mono.Security.X509.X520;
using Venus_Core;
using Venus_RT.Devices;
using Venus_RT.Devices.TM;
using Aitex.Core.UI.DeviceControl;
using System.Windows.Documents;

namespace Venus_RT.Modules.TM.VenusEntity
{
    public class SEMFLeakCheckRoutine : ModuleRoutineBase, IRoutine
    {
        private enum LeakCheckStep
        {
            vWaitPump,
            vCloseValves,
            vPumpToCrossing,
            vPumpToBasePressure,
            vPumpingDelay,
            vLeakCheckDelay,
            vLeakCheckCalc,
            vPumpToCrossing_2,
            vPumpToBasePressure_2,
            vCloseAndRecord,
            vEnd,
        }
        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 TMBase _tm;
        //public string CurrentStep;
        private string _result;
        PressureType _pressureType = PressureType.mTorr;


        public SEMFLeakCheckRoutine(TMBase tm, ModuleName mod) : base(mod)
        {
            Name = $"{Module} Leakcheck";
            _tm = tm;
        }

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

                //关闭所有阀体
                _tm.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.Wait(LeakCheckStep.vWaitPump,            WaitPumpRelease,                                            _delay_60s)
                  .Delay(LeakCheckStep.vCloseValves,        _delay_1s)
                  .Run(LeakCheckStep.vPumpToCrossing,       HOFs.WrapAction(_tm.TurnSoftPumpValve, Module, true),       () => { return _tm.GetModulePressure(Module) <= _CrossingPressure; })
                  .Run(LeakCheckStep.vPumpToBasePressure,   SwitchFastPump,                                             () => { return _tm.GetModulePressure(Module) <= _basePressure; })
                  .Delay(LeakCheckStep.vPumpingDelay,                                                                   _leakcheckPumpTime * 1000)
                  .Run(LeakCheckStep.vLeakCheckDelay,       StartLeakCheck,                                             _leakcheckWaitTime * 1000)
                  .Run(LeakCheckStep.vLeakCheckCalc,        CalcLeakCheckResult,                                        _delay_50ms)
                  .Run(LeakCheckStep.vPumpToCrossing_2,     HOFs.WrapAction(_tm.TurnSoftPumpValve, Module, true),       () => { return _tm.GetModulePressure(Module) <= _CrossingPressure; })
                  .Run(LeakCheckStep.vPumpToBasePressure_2, SwitchFastPump,                                             () => { return _tm.GetModulePressure(Module) <= _basePressure; })
                  .Run(LeakCheckStep.vCloseAndRecord,       LeakCheckEnd,                                               _delay_3s)
                  .End(LeakCheckStep.vEnd,                  ReleasePump,                                                _delay_50ms);

            return Runner.Status;
        }

        public bool ReleasePump()
        {
            //释放控制权
            _tm.ReleasePump(Module);
            return true;
        }

        public bool WaitPumpRelease()
        {
            return _tm.TryGetPump(Module);
        }

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

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

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

        bool CalcLeakCheckResult()
        {
            _endPressure = _tm.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()
        {
            _tm.CloseModuleAllValves(Module);
            LeakCheckDataRecorder.Add(_leakcheckPumpTime, Math.Round(_startPressure, 1), Math.Round(_endPressure, 1), LeakRate, _result, "", Module.ToString(), "");
            return true;
        }

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

            return true;
        }
    }
}