Virgo_Mask/VirgoRT/Modules/PMs/CyclePurgeRoutine.cs

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using VirgoRT.Devices;

namespace VirgoRT.Modules.PMs
{
    class CyclePurgeRoutine : PMRoutineBase
    {
        private enum RoutineStep
        {
            CheckRfOff,
            CheckPumping,
            CloseAllValves,
            Loop,
            Pump,
            PumpDelay,
            Vent,
            VentDelay,
            EndLoop,
            PumpDefault,
            End,
        };

        // ----------------------------Fields--------------------------
        //
        private int _purgeCycleCount;
        private int _purgeVentPressure;
        private int _purgePumpPressure;
        private int _purgeVentTimeLimit;
        private int _purgePumpTimeLimit;
        private int _purgeVentStableTime;
        private int _purgePumpStableTime;

        // --------------------------Constructor-----------------------
        //
        public CyclePurgeRoutine(JetPM chamber) : base(chamber)
        {
            Name = "Cycle purge";
            bUINotify = true;
        }

        public Result Start(params object[] objs)
        {
            if (_chamber.IsGeneratorON)
            {
                Stop("Generator must be off");
                return Result.FAIL;
            }

            if (!_chamber.IsPumpRunning || !_chamber.IsFastPumpOpened)
            {
                Stop("Pump status error");
                return Result.FAIL;
            }

            Reset();

            _purgeCycleCount = (int)SC.GetValue<double>($"{Module}.Purge.PurgeCycleCount");
            _purgeVentPressure = (int)SC.GetValue<double>($"{Module}.Purge.PurgeVentPressure");
            _purgePumpPressure = (int)SC.GetValue<double>($"{Module}.Purge.PurgePumpPressure");
            _purgeVentTimeLimit = (int)SC.GetValue<double>($"{Module}.Purge.PurgeVentTimeLimit");
            _purgePumpTimeLimit = (int)SC.GetValue<double>($"{Module}.Purge.PurgePumpTimeLimit");
            _purgeVentStableTime = (int)SC.GetValue<double>($"{Module}.Purge.PurgeVentStableTime");
            _purgePumpStableTime = (int)SC.GetValue<double>($"{Module}.Purge.PurgePumpStableTime");

            //关闭所有阀门
            _chamber.CloseValves();

            return Result.RUN;
        }

        public Result Monitor()
        {
            try
            {
                StartLoop((int)RoutineStep.Loop, "PM Cycle Purge", _purgeCycleCount, Notify, Stop);

                CyclePump((int)RoutineStep.Pump, _purgePumpPressure, _purgePumpTimeLimit, true);

                TimeDelay((int)RoutineStep.PumpDelay, _purgePumpStableTime);

                CycleVent((int)RoutineStep.Vent, _purgeVentPressure, _purgeVentTimeLimit, true);

                TimeDelay((int)RoutineStep.VentDelay, _purgeVentStableTime);

                EndLoop((int)RoutineStep.EndLoop, Notify, Stop);

                CyclePump((int)RoutineStep.PumpDefault, _purgePumpPressure, _purgePumpTimeLimit, false);

                End((int)RoutineStep.End);
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                return Result.FAIL;
            }
            catch (System.Exception ex)
            {
                Stop(ex.Message);
                return Result.FAIL;
            }

            return Result.DONE;
        }

        public override void Abort()
        {
            _chamber.CloseValves();
        }
    }
}