Kepler-Release/Venus/Venus_RT/Modules/LLs/LLEntity.cs

using System;
using Aitex.Core.Util;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using Venus_RT.Modules.TM;
using Venus_RT.Devices;
using Venus_Core;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Event;
using System.Diagnostics;
using System.Linq;
using System.Windows.Interop;
using System.Collections.Generic;

namespace Venus_RT.Modules
{
    class LLEntity : Entity, IEntity, IModuleEntity
    {
        public enum LLStatus
        {
            Not_Ready,
            Ready_For_TM,
            Ready_For_EFEM,
        }

        public enum STATE
        {
            Unknown,
            Init,
            Initializing,
            Idle,
            Error,
            Pumping,
            Venting,
            Purging,
            Cooling,
            LeakCheck,
            Prepare_For_TM,
            Prepare_For_EFEM,
            Ready_For_TM,
            Ready_For_EFEM,
            WaitCooling,
            AutoCooling,

        }

        public enum MSG
        {
            Home,
            Online,
            Offline,
            Pump,
            Vent,
            AutoPump,
            AutoVent,
            Purge,
            CyclePurge,
            LeakCheck,
            Prepare_TM,
            Prepare_EFEM,
            TM_Exchange_Ready,
            EFEM_Exchange_Ready,
            Error,
            Abort,
            AutoCooling,

        }

        public ModuleName Module { get; private set; }

        public LLStatus Status { get; private set; }

        public bool Check(int msg, out string reason, params object[] args)
        {
            throw new NotImplementedException();
        }
        public bool IsIdle
        {
            get { return fsm.State == (int)STATE.Idle; }
        }

        public bool IsError
        {
            get { return fsm.State == (int)STATE.Error; }
        }

        public bool IsInit
        {
            get { return fsm.State == (int)STATE.Unknown || fsm.State == (int)STATE.Init; }
        }

        public bool IsBusy
        {
            get { return !IsInit && !IsError && !IsIdle; }
        }

        public bool IsOnline { get; internal set; }
        public bool IsInclude
        {
            get;
            private set;
        } = true;
        public bool IsVac { get { return _JetTM.IsModuleVaccum(Module); } }

        public bool IsATM { get { return _JetTM.IsModuleATM(Module); } }

        public override int TimeToReady
        {
            get
            {
                switch ((STATE)fsm.State)
                {
                    case STATE.Pumping:
                    case STATE.Venting:
                        return base.TimeToReady;

                }

                return int.MaxValue / 2;
            }
        }

        private readonly JetTM _JetTM;
        private readonly MFPumpRoutine _pumpingRoutine;
        private readonly MFVentRoutine _ventingRoutine;
        private readonly MFLeakCheckRoutine _leakCheckRoutine;
        private readonly MFPurgeRoutine _purgeRoutine;

        private readonly MFCoolingRoutine _coolingRoutine;
        private readonly int _slotNumber = 4;
        //private bool startControlPressureFlag = true;

        private int _controlPressureCheckPoint = 100;
        private int _controlPressureSetPoint = 90;
        private int _controlFlowSetPoint = 90;

        private bool _isEnableControlPressure;
        private Stopwatch _coolingStopWatch=new Stopwatch();


        private double _coolingMFCFlow;
        private int _coolingTime;

        CoolingStatu[] _coolingStatus;

        //private bool _coolingFlag = false;

        private int _PressureAlarmUpperLimit;
        //private int _PressureAlarmLowerLimitDuration;
        private int _PressureAlarmUpperLimitCounter;

        private int _RealPressureAlarmUpperLimitCounter;

        public LLEntity(ModuleName module)
        {
            Module = module;
            _JetTM = DEVICE.GetDevice<JetTM>("TM");

            _pumpingRoutine = new MFPumpRoutine(_JetTM, Module);
            _ventingRoutine = new MFVentRoutine(_JetTM, Module);
            _leakCheckRoutine = new MFLeakCheckRoutine(_JetTM, Module);
            _purgeRoutine = new MFPurgeRoutine(_JetTM, Module);
            _coolingRoutine=new MFCoolingRoutine(_JetTM, Module);

            _slotNumber = SC.GetValue<int>($"{module.ToString()}.SlotNumber");
            WaferManager.Instance.SubscribeLocation(Module, _slotNumber);

            InitFsmMap();

            _coolingStatus=new CoolingStatu[_slotNumber];
            for (int i = 0; i < _slotNumber; i++)
            {
                _coolingStatus[i] = CoolingStatu.Init;
            }
            GetCoolingInfo();

            _PressureAlarmUpperLimit = SC.GetValue<int>($"{Module}.PressureAlarmUpperLimit");
             int _PressureAlarmLowerLimitDuration = SC.GetValue<int>($"{Module}.PressureAlarmUpperLimitDuration")*1000;
            _PressureAlarmUpperLimitCounter = _PressureAlarmLowerLimitDuration / 50;
        }
        private void GetCoolingInfo()
        {
            if (RtInstance.ConfigType == ConfigType.Kepler2200)
            {
                _coolingMFCFlow = SC.GetValue<double>($"{Module.ToString()}.Cooling.MFCFlow");
                _coolingTime = SC.GetValue<int>($"{Module.ToString()}.Cooling.CoolingTime");
            }
        }
        protected override bool Init()
        {

            OP.Subscribe($"{Module}.Home", (cmd, args) => CheckToPostMessage((int)MSG.Home));
            OP.Subscribe($"{Module}.{RtOperation.Pump}", (cmd, args) => CheckToPostMessage((int)MSG.Pump));
            OP.Subscribe($"{Module}.{RtOperation.Vent}", (cmd, args) => CheckToPostMessage((int)MSG.Vent));
            OP.Subscribe($"{Module}.{RtOperation.Purge}", (cmd, args) => CheckToPostMessage((int)MSG.Purge));
            OP.Subscribe($"{Module}.{RtOperation.Abort}", (cmd, args) => CheckToPostMessage((int)MSG.Abort));
            OP.Subscribe($"{Module}.{RtOperation.LeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.LeakCheck));
            OP.Subscribe($"{Module}.{RtOperation.Online}", (cmd, args) => CheckToPostMessage((int)MSG.Online));
            OP.Subscribe($"{Module}.{RtOperation.Offline}", (cmd, args) => CheckToPostMessage((int)MSG.Offline));
            OP.Subscribe($"{Module}.{RtOperation.Include}", (cmd, args) => FnSetInclude());
            OP.Subscribe($"{Module}.{RtOperation.Exclude}", (cmd, args) => FnSetExclude());

            OP.Subscribe($"{Module}.{RtOperation.ControlPressure}", (cmd, args) => StartControlPressure());
            OP.Subscribe($"{Module}.{RtOperation.AbortControlPressure}", (cmd, args) => StopControlPressure());

            DATA.Subscribe($"{Module}.FsmState", () => (((STATE)fsm.State).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.FsmPrevState", () => (((PMState)fsm.PrevState).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.FsmLastMessage", () => (((MSG)fsm.LastMsg).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsOnline", () => IsOnline, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsInclude", () => IsInclude, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsBusy", () => IsBusy, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsEnableControlPressure", () => _isEnableControlPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Module}.CoolingTime", () => _coolingStopWatch.ElapsedMilliseconds/1000, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            return true;
        }
        private void InitFsmMap()
        {
            fsm = new StateMachine<LLEntity>(Module.ToString(), (int)STATE.Init, 50);
            fsm.EnableRepeatedMsg(true);

            EnterExitTransition<STATE, FSM_MSG>(STATE.Ready_For_TM,     fnEnterTMReady,     FSM_MSG.NONE,   fnExitTMReady);
            EnterExitTransition<STATE, FSM_MSG>(STATE.Ready_For_EFEM,   fnEnterEFEMReady,   FSM_MSG.NONE,   fnExitEFEMReady);

            AnyStateTransition(FSM_MSG.TIMER,   fnMonitorPressure,         FSM_STATE.SAME);


            AnyStateTransition(MSG.Error,       fnError,        STATE.Error);
            AnyStateTransition(MSG.Online,      fnOnline,       FSM_STATE.SAME);
            AnyStateTransition(MSG.Offline,     fnOffline,      FSM_STATE.SAME);
            AnyStateTransition(MSG.Home,        fnHome,         STATE.Initializing);

            // Home
            Transition(STATE.Initializing,      FSM_MSG.TIMER,          fnHoming,               STATE.Idle);

            Transition(STATE.Idle,              FSM_MSG.TIMER,          fnMonitor,              STATE.Idle);
            Transition(STATE.Init,              FSM_MSG.TIMER,          fnMonitor,              STATE.Init);

            //vent sequence
            Transition(STATE.Idle,              MSG.Vent,               FnStartVent,            STATE.Venting);
            Transition(STATE.Venting,           FSM_MSG.TIMER,          FnVentTimeout,          STATE.Idle);
            Transition(STATE.Venting,           MSG.Abort,              FnAbortVent,            STATE.Idle);

            Transition(STATE.Idle,              MSG.AutoCooling,        FnStartCooling,         STATE.Cooling);
            Transition(STATE.Cooling,           FSM_MSG.TIMER,          FnCoolingTimeout,       STATE.Idle);
            Transition(STATE.Cooling,           MSG.Abort,              FnAbortCooling,         STATE.Idle);

            //Pump sequence
            Transition(STATE.Idle,              MSG.Pump,               FnStartPump,            STATE.Pumping);
            Transition(STATE.Pumping,           FSM_MSG.TIMER,          FnPumpTimeout,          STATE.Idle);
            Transition(STATE.Pumping,           MSG.Abort,              FnAbortPump,            STATE.Idle);

            // Purge sequence
            Transition(STATE.Idle,              MSG.Purge,              FnStartPurge,           STATE.Purging);
            Transition(STATE.Purging,           FSM_MSG.TIMER,          FnPurgeTimeout,         STATE.Idle);
            Transition(STATE.Purging,           MSG.Abort,              FnAbortPurge,           STATE.Idle);

            // Leak check sequence
            Transition(STATE.Idle,              MSG.LeakCheck,          FnStartLeakCheck,       STATE.LeakCheck);
            Transition(STATE.LeakCheck,         FSM_MSG.TIMER,          FnLeakCheckTimeout,     STATE.Idle);
            Transition(STATE.LeakCheck,         MSG.Abort,              FnAbortLeakCheck,       STATE.Idle);

            // Prepare TM Transfer
            Transition(STATE.Idle,              MSG.Prepare_TM,         FnStartPrepareTM,       STATE.Prepare_For_TM);
            Transition(STATE.Prepare_For_TM,    FSM_MSG.TIMER,          FnPreparaTMTimeout,     STATE.Ready_For_TM);
            Transition(STATE.Prepare_For_TM,    MSG.Prepare_TM,         null,                   STATE.Prepare_For_TM);
            Transition(STATE.Prepare_For_TM,    MSG.Abort,              FnAbortPreparaTM,       STATE.Idle);
            Transition(STATE.Ready_For_TM,      MSG.TM_Exchange_Ready,  FnTMExchange,           STATE.Idle);
            Transition(STATE.Ready_For_TM,      MSG.Prepare_TM,         null,                   STATE.Ready_For_TM);
            Transition(STATE.Ready_For_TM,      MSG.Abort,              null,                   STATE.Idle);
            Transition(STATE.Idle,              MSG.AutoVent,           FnTryAutoVent,          STATE.Venting);

            Transition(STATE.Ready_For_TM,      MSG.AutoVent,           FnTryAutoVent,          STATE.Venting);

            // Prepare EFEM Transfer
            Transition(STATE.Idle,              MSG.Prepare_EFEM,       FnStartPrepareEFEM,     STATE.Prepare_For_EFEM);
            Transition(STATE.Prepare_For_EFEM,  FSM_MSG.TIMER,          FnPrepareEFEMTimeout,   STATE.Ready_For_EFEM);
            Transition(STATE.Prepare_For_EFEM,  MSG.Abort,              FnAbortPrepareEFEM,     STATE.Idle);
            Transition(STATE.Ready_For_EFEM,    MSG.EFEM_Exchange_Ready, null,                  STATE.Idle);
            Transition(STATE.Ready_For_EFEM,    MSG.Prepare_EFEM,       null,                   STATE.Ready_For_EFEM);
            Transition(STATE.Ready_For_EFEM,    MSG.Abort,              null,                   STATE.Idle);
            Transition(STATE.Ready_For_EFEM,    MSG.AutoPump,           FnTryAutoPump,          STATE.Pumping);

            Running = true;
        }

        public int Invoke(string function, params object[] args)
        {
            switch (function)
            {
                case "Home":
                case "Vent":
                case "Pump":
                case "AutoCooling":
                    if (Enum.TryParse(function, out MSG message))
                    {
                        if (CheckToPostMessage((int)message))
                            return (int)message;
                    }
                    break;
            }

            return (int)FSM_MSG.NONE;
        }

        public bool CheckAcked(int msg)
        {
            return fsm.CheckExecuted(msg);
        }

        public bool CheckToPostMessage(int msg, params object[] args)
        {
            if (!fsm.FindTransition(fsm.State, msg))
            {
                LOG.Write(eEvent.WARN_FSM_WARN, Module, $"{Module} is in {(STATE)fsm.State} state，can not do {(MSG)msg}");
                return false;
            }

            Running = true;
            fsm.PostMsg(msg, args);

            return true;
        }

        public (int processed, int unprocessed) GetWaferProcessStatus()
        {
            int processedCount = 0;
            int unprocessCount = 0;
            for (int i = 0; i < _slotNumber; i++)
            {
                var wafer = WaferManager.Instance.GetWafer(Module, i);
                if (!wafer.IsEmpty)
                {
                    if (wafer.ProcessState == Aitex.Core.Common.EnumWaferProcessStatus.Completed)
                    {
                        processedCount++;
                    }
                    else
                    {
                        unprocessCount++;
                    }
                }
            }

            return (processedCount, unprocessCount);
        }

        private bool fnEnterTMReady(object[] param)
        {          
            if (RouteManager.IsATMMode)
            {
                Status = LLStatus.Ready_For_TM;

                return true;
            }
            StartControlPressure();
            Status = LLStatus.Ready_For_TM;

            return true;
        }

        private bool fnExitTMReady(object[] param)
        {           
            if (RouteManager.IsATMMode)
            {
                Status = LLStatus.Not_Ready;

                return true;
            }         
            StopControlPressure();
            Status = LLStatus.Not_Ready;

            return true;
        }


        private bool fnEnterEFEMReady(object[] param)
        {
            Status = LLStatus.Ready_For_EFEM;
            return true;
        }

        private bool fnExitEFEMReady(object[] param)
        {
            Status = LLStatus.Not_Ready;
            return true;
        }

        private bool fnMonitor(object[] param)
        {
            _debugRoutine();
            return true;
        }
        private bool fnMonitorPressure(object[] param)
        {           
            double pressure;
            if (Module == ModuleName.LLA)
            {
                pressure = _JetTM==null?0:_JetTM.LLAPressure;
            }
            else if (Module == ModuleName.LLB)
            {
                pressure = _JetTM == null ? 0 : _JetTM.LLBPressure;
            }
            else
            {
                return true;
            }
            if (pressure > _PressureAlarmUpperLimit)
            {
                _RealPressureAlarmUpperLimitCounter += 1;
                if (_RealPressureAlarmUpperLimitCounter > _PressureAlarmUpperLimitCounter)
                {
                    PostMsg(MSG.Error);
                }
            }
            else
            {
                _RealPressureAlarmUpperLimitCounter = 0;
            }
            return true;
        }
        private bool fnError(object[] param)
        {
            IsOnline = false;
            return true;
        }

        private bool fnOnline(object[] param)
        {
            if (!IsInclude)
            {
                LOG.Write(eEvent.WARN_LL, Module, $"{Module} is excluded，can not be put online");
                return false;
            }

            IsOnline = true;
            return true;
        }

        private bool fnOffline(object[] param)
        {
            IsOnline = false;
            return true;
        }
        private bool FnSetInclude()
        {
            if (IsOnline == true)
            {
                LOG.Write(eEvent.WARN_LL, Module, $"{Module} is online，can not set Include");
                return false;
            }
            IsInclude = true;
            LOG.Write(eEvent.INFO_LL, Module, $"{Module}  Set Include Success");
            return true;
        }
        private bool FnSetExclude()
        {
            if (IsOnline == true)
            {
                LOG.Write(eEvent.WARN_LL, Module, $"{Module} is online，can not set Exclude");
                return false;
            }
            IsInclude = false;
            LOG.Write(eEvent.INFO_LL, Module, $"{Module}  Set Exclude Success");
            return true;
        }
        private bool fnAbort(object[] param)
        {
            return true;
        }

        private bool fnHome(object[] param)
        {
            //IsOnline = true;
            _RealPressureAlarmUpperLimitCounter = 0;
            return true;
        }

        private bool fnHoming(object[] param)
        {
            return true;
        }

        private bool FnStartVent(object[] param)
        {
            //_PressureAlarmUpperLimit        = SC.GetValue<int>($"{Module}.PressureAlarmUpperLimit");
            // int _PressureAlarmLowerLimitDuration = SC.GetValue<int>($"{Module}.PressureAlarmUpperLimitDuration") * 1000;
            //_PressureAlarmUpperLimitCounter = _PressureAlarmLowerLimitDuration / 50;
            return _ventingRoutine.Start(false) == RState.Running;
        }

        private  bool FnTryAutoVent(object[] param)
        {
            if (RouteManager.IsATMMode)
            {
                PostMsg(MSG.TM_Exchange_Ready, false);
                return false;
            }
            _coolingMFCFlow = SC.GetValue<double>($"{Module.ToString()}.Cooling.MFCFlow");
            _coolingTime = SC.GetValue<int>($"{Module.ToString()}.Cooling.CoolingTime");
            return _ventingRoutine.Start(false) == RState.Running;
        }

        private bool FnVentTimeout(object[] param)
        {
            RState ret = _ventingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            if(ret == RState.End)
            {           
                MarkStateTime();
                return true;
            }

            return false;
        }

        private bool FnAbortVent(object[] param)
        {
            _ventingRoutine.Abort();
            return true;
        }

        private bool FnStartPump(object[] param)
        {
            return _pumpingRoutine.Start() == RState.Running;
        }

        private bool FnPumpTimeout(object[] param)
        {
            RState ret = _pumpingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            if (ret == RState.End)
            {
                MarkStateTime();
                return true;
            }

            return false;
        }

        private bool FnAbortPump(object[] param)
        {
            _pumpingRoutine.Abort();
            return true;
        }

        private bool FnTryAutoPump(object[] param)
        {
            if (_JetTM.LLPumpStatus != JetTM.LLPumpState.Idle || RouteManager.IsATMMode)
            {
                PostMsg(MSG.EFEM_Exchange_Ready);
                return false;
            }

            return _pumpingRoutine.Start() == RState.Running;
        }

        private bool FnStartPurge(object[] param)
        {
            return _purgeRoutine.Start() == RState.Running;
        }

        private bool FnPurgeTimeout(object[] param)
        {
            RState ret = _purgeRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortPurge(object[] param)
        {
            _purgeRoutine.Abort();
            return true;
        }

        private bool FnStartLeakCheck(object[] param)
        {
            return _leakCheckRoutine.Start() == RState.Running;
        }

        private bool FnLeakCheckTimeout(object[] param)
        {
            RState ret = _leakCheckRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortLeakCheck(object[] param)
        {
            _leakCheckRoutine.Abort();
            return true;
        }

        private bool FnStartPrepareTM(object[] param)
        {
            if (RouteManager.IsATMMode)
                return true;

            return _pumpingRoutine.Start() == RState.Running;
        }

        private bool FnPreparaTMTimeout(object[] param)
        {
            if (RouteManager.IsATMMode)
            {
                if (fsm.ElapsedTime > 10000)
                {
                    LOG.Write(eEvent.ERR_TM, Module, $"Cannot transfer wafer as {Module} is not ATM.");
                    PostMsg(MSG.Error);
                    return true;
                }


                return _JetTM.IsModuleATM(Module);
            }

            RState ret = _pumpingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortPreparaTM(object[] param)
        {
            _pumpingRoutine.Abort();
            return true;
        }

        private bool FnStartPrepareEFEM(object[] param)
        {
            if (RouteManager.IsATMMode)
                return true;

            return _ventingRoutine.Start(false) == RState.Running;
        }

        private bool FnPrepareEFEMTimeout(object[] param)
        {
            if (RouteManager.IsATMMode)
            {
                //if (fsm.ElapsedTime > 10000)
                //{
                   
                //}
                //LOG.Write(eEvent.ERR_TM, Module, $"Cannot transfer wafer as {Module} is not ATM.");
                //PostMsg(MSG.Error);
                
                return _JetTM.IsModuleATM(Module);
            }

            RState ret = _ventingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
            //if (ret == RState.End && _coolingFlag)
            //{
            //    //if (_coolingStatus.Any(x => x == CoolingStatu.WaitCooling) && Singleton<RouteManager>.Instance.IsAutoRunning)
            //    //{
            //    //    PostMsg(MSG.AutoCooling);
            //    //}
            //    return true;
            //}
            //else if (_coolingFlag == false)
            //{
            //    return true;
            //}
            //else
            //{
            //    return false;
            //}
        }

        private bool FnAbortPrepareEFEM(object[] param)
        {
            _ventingRoutine.Abort();
            return true;
        }
      
        private bool StartControlPressure()
        {
            _isEnableControlPressure = true;
            _controlPressureCheckPoint = SC.GetValue<int>($"{Module}.ControlPressureCheckPoint");
            _controlPressureSetPoint = SC.GetValue<int>($"{Module}.ControlPressureSetPoint");
            _controlFlowSetPoint = SC.GetValue<int>($"{Module}.{Module}_MFC1.DefaultSetPoint");
            _JetTM.TurnFastPumpValve(Module, true);

            //_JetTM.TurnSoftPumpValve(Module, true);


            _JetTM.TurnPurgeValve(Module, true);
            _JetTM.TurnN2Valve(true);
            if (Module == ModuleName.LLA)
            {
                _JetTM.SwitchLLAPressureMode(true);
                _JetTM.SetLLAPressure((int)_controlPressureSetPoint);
            }
            else if (Module == ModuleName.LLB)
            {
                _JetTM.SwitchLLBPressureMode(true);
                _JetTM.SetLLBPressure((int)_controlPressureSetPoint);
            }
            return true;
        }
        private bool StopControlPressure()
        {
            _isEnableControlPressure = false;

            _JetTM.TurnFastPumpValve(Module, false);
            _JetTM.TurnSoftPumpValve(Module, false);

            _JetTM.TurnPurgeValve(Module, false);


            if (Module == ModuleName.LLA)
            {
                _JetTM.SwitchLLAPressureMode(false);
                _JetTM.SetLLAPressure(0);
            }
            else if (Module == ModuleName.LLB)
            {
                _JetTM.SwitchLLBPressureMode(false);
                _JetTM.SetLLBPressure(0);
            }
            return true;
        }

        private bool FnStartCooling(object[] param)
        {
            _coolingStopWatch.Restart();
            _coolingTime = SC.GetValue<int>($"{Module}.Cooling.CoolingTime") * 1000;
            return _ventingRoutine.Start(true) == RState.Running;         
        }
       
        private bool FnCoolingTimeout(object[] param)
        {          
            RState ret = _ventingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                _coolingStopWatch.Reset();
                return false;
            }

            if(_coolingStopWatch.ElapsedMilliseconds > _coolingTime && _JetTM.IsModuleATM(Module))
            {
                MarkStateTime();
                _ventingRoutine.Abort();
                _coolingStopWatch.Reset();
                return true;
            }
            if (ret == RState.End)
            {
                _coolingStopWatch.Reset();
                return true;
            }
            else
            {
                return false;
            }
        }

        private bool FnAbortCooling(object[] param)
        {
            _ventingRoutine.Abort();
            return true;
        }
        private bool FnTMExchange(object[] param)
        {
            return true;
        }
        //private bool FnEFEMExchange(object[] param)
        //{
        //    int slot = (int)param[0];
        //    _coolingStatus[slot] = CoolingStatu.Init;
        //    return true;
        //}

        private void _debugRoutine()
        {
            int flag = 0;
            // Test Home routine
            if (flag == 1)
            {
                PostMsg(MSG.Home);
            }
            else if (flag == 2)
            {
                PostMsg(MSG.Vent);
            }
            else if (flag == 3)
            {
                PostMsg(MSG.Pump);
            }
            //else if (flag == 4)
            //{
            //    PostMsg(MSG.PumpLoadLock);
            //}
            //else if (flag == 5)
            //{
            //    PostMsg(MSG.VentLoadLock);
            //}
            //else if (flag == 6)
            //{
            //    PostMsg(MSG.PurgeLoadLock);
            //}
            //else if (flag == 7)
            //{
            //    PostMsg(MSG.LaunchPump);
            //}
            //else if (flag == 8)
            //{
            //    PostMsg(MSG.LaunchTurboPump);
            //}
            //else if (flag == 9)
            //{
            //    PostMsg(MSG.LoadLockLeakCheck);
            //}
            else if (flag == 10)
            {
                PostMsg(MSG.CyclePurge);
            }
            //else if (flag == 11)
            //{
            //    PostMsg(MSG.GasLinePurge);
            //}
            //else if (flag == 12)
            //{
            //    PostMsg(MSG.LeakCheck);
            //}
            //else if (flag == 13)
            //{
            //    PostMsg(MSG.GasLeakCheck);
            //}
            //else if (flag == 14)
            //{
            //    PostMsg(MSG.LLPlace);
            //}
            //else if (flag == 15)
            //{
            //    PostMsg(MSG.LLPick);
            //}
            //else if (flag == 16)
            //{
            //    PostMsg(MSG.RunRecipe, "7777");
            //}
            //else if (flag == 17)
            //{
            //    PostMsg(MSG.MFCVerification, "MFC2", (double)50, 10);
            //}
        }
    }
}