Kepler-Release/Venus/Venus_RT/Modules/PMs/PMEntity.cs

using System;
using System.Collections.Generic;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using Venus_Core;
using Venus_RT.Devices;
using Aitex.Core.RT.Log;
using Aitex.Core.UI.DeviceControl;

namespace Venus_RT.Modules.PMs
{
    public class RecipeRunningInfo
    {
        public Guid InnerId { get; set; }

        public RecipeHead Head { get; set; }
        public List<RecipeStep> RecipeStepList { get; set; }

        public string RecipeName { get; set; }

        public DateTime BeginTime { get; set; }
        public DateTime EndTime { get; set; }

        public int StepNumber { get; set; }
        public string StepName { get; set; }

        public double StepTime { get; set; }
        public double StepElapseTime { get; set; }

        public double TotalTime { get; set; }
        public double TotalElapseTime { get; set; }
    }

    public class PMEntity : Entity, IModuleEntity
    {
        public enum PMStatus
        {
            Not_Ready,
            Ready_For_Pick,
            Ready_For_Place,
            Exchange_Ready,
        }

        public enum MSG
        {
            Home,
            Transfer,
            PrepareTransfer,
            PostTransfer,
            Reset,
            Abort,
            Error,
            LaunchPump,
            LaunchTurboPump,
            Pump,
            Vent,
            PumpLoadLock,
            VentLoadLock,
            PurgeLoadLock,
            LoadLockLeakCheck,
            CyclePurge,
            GasLinePurge,
            Heat,
            TransferHandoff,
            StartTransfer,
            LeakCheck,
            GasLeakCheck,
            MoveLiftPin,
            MoveGuidePin,
            PartialPressure,
            VATPerformance,

            LLPlace,
            LLPick,

            Process,
            RunRecipe,
            PostProcess,
            RecipeSkipStep,
            RecipeUpdate,
            RecipeResume,
            RecipePause,
            RecipeAbort,
            PreProcess,
            AutoMode,
            ManualMode,
            LockLid,
            Clean,

            Online,
            Offline,
            GasFlow,
            StopGasFlow,
            RfPower,
            MFCVerification,

            // exchange wafer with TM
            PreparePick,
            PreparePlace,
            LiftUpWafer,
            DropDownWafer,
            PickReady,
            PlaceReady,
            MaxMsg
        }

        private readonly JetPMBase _chamber;

        public ModuleName Module { get; }
        public PMStatus Status { get; private set; }

        private readonly PMHomeRoutine _home;
        private readonly StartDryPumpRoutine _startDryPumpRoutine;
        private readonly StartTurboPumpRoutine _startTurboPumpRoutine;
        private readonly VentRoutine _ventRoutine;
        private readonly PumpDownRoutine _pumpRoutine;
        private readonly LoadLockVentRoutine _ventLoadLockRoutine;
        private readonly LoadLockPumpRoutine _pumpLoadLockRoutine;
        private readonly LoadLockPurgeRoutine _purgeLoadLockRoutine;
        private readonly LoadLockLeakCheckRoutine _loadLockLeakCheckRoutine;
        private readonly PMPurgeRoutine _purgeRoutine;
        private readonly PMGaslinePurgeRoutine _gaslinePurgeRoutine;
        private readonly PMLeakCheckRoutine _leakCheckRoutine;
        private readonly GasBoxLeakCheckRoutine _gasBoxLeakCheckRoutine;
        private readonly LLPlaceRoutine _llPlaceRoutine;
        private readonly LLPickRoutine _llPickRoutine;
        private readonly PMProcessRoutine _processRoutine;
        private readonly GasFlowRoutine _gasFlowRoutine;
        private readonly RFPowerSwitchRoutine _rfPowerRoutine;
        private readonly PMGasVerificationRoutine _gasVerificationRoutine;
        private readonly PMPartialPressureRoutine _pmPartialPressureRoutine;
        private readonly PMVATPerformanceRoutine _pmVATPerformanceRoutine;

        private readonly PMHeatRoutine _pmHeatRoutine;



        private AutoFlag _AutoMode;
        private bool _isOnline = false;
        //private bool _isAlarm;
        //private DateTime _pumpStartTime;
        //private TimeSpan _pumpElapsedTime;
        //private DateTime _rfStartTime;
        //private DateTime _tcStartTime;
        //private TimeSpan _rfElapsedTime;
        //private TimeSpan _tcElapsedTime;
        //private MovementPosition _goalLiftPin;
        //private ushort _ActivatedActionID;
        //private Stopwatch _LifpinSleepTimer;
        private bool startControlPressureFlag = true;
        //private bool stopControlPressureFlag = false;

        private int _controlPressureSetPoint = 90;
        private int _controlFlowSetPoint = 90;
        public JetChamber ChamberType => _chamber.ChamberType;
        public bool IsIdle
        {
            get { return fsm.State == (int)PMState.Idle; }
        }

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

        public bool IsInit
        {
            get { return fsm.State == (int)PMState.Init; }
        }
        public bool IsBusy
        {
            get { return !IsInit && !IsError && !IsIdle; }
        }

        public bool IsProcessing
        {
            get { return fsm.State == (int)PMState.PreProcess || fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PostProcess; }
        }

        public bool IsOnline
        {
            get { return _isOnline; }
        }
        public bool IsInclude
        {
            get;
            private set;
        } = true;


        private Dictionary<string, int> _dictRecipeTime = new Dictionary<string, int>();
        public override int TimeToReady
        {
            get
            {
                switch ((PMState)fsm.State)
                {
                    case PMState.Processing:
                    case PMState.Clean:
                        if (Singleton<RouteManager>.Instance.IsAutoMode && IsOnline)
                        {
                            if (_dictRecipeTime.ContainsKey(_processRoutine.currentRecipeResult.RecipeName))
                            {
                                return Math.Max(_dictRecipeTime[_processRoutine.currentRecipeResult.RecipeName] - fsm.ElapsedTime, 0);
                            }
                        }

                        break;

                }

                return int.MaxValue;
            }
        }

        public bool IsAutoMode => _AutoMode == AutoFlag.Auto;
        public bool IsSlitDoorOpen => _chamber.CheckSlitDoorOpen();
        public bool IsSlitDoorClose => _chamber.CheckSlitDoorClose();
        public bool LiftPinIsDown => _chamber.LiftPinIsDown;
        public bool LiftPinIsUp => _chamber.LiftPinIsUp;
        public double ChamberPressure => _chamber.ChamberPressure;

        public bool IsVac => _chamber.IsVAC;
        public bool IsAtm => _chamber.IsATM;

        public float ChamberTemperature => _chamber.ChamberTemperature;
        public bool Check(int msg, out string reason, object[] objs)
        {
            reason = "";
            return true;
        }
        // 
        private bool CheckToPostMessage(int msg, params object[] args)
        {
            if (!fsm.FindTransition(fsm.State, msg))
            {
                EV.PostWarningLog(Module.ToString(), eEvent.WARN_State, $"{Module} is in {(PMState)fsm.State} state，can not do {(MSG)msg}");
                return false;
            }

            fsm.PostMsg(msg, args);

            return true;
        }

        public int Invoke(string function, params object[] args)
        {
            switch (function)
            {
                case "Home":
                    CheckToPostMessage((int)MSG.Home);
                    return (int)MSG.Home;
            }

            return (int)FSM_MSG.NONE;
        }

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

        public void ResetRecipeTime()
        {
            _dictRecipeTime.Clear();
        }

        public bool IsPrepareTransferReady(ModuleName robot, EnumTransferType type, int slot, Hand blade)
        {
            //if (type == EnumTransferType.Pick)
            //{
            //    return _chamber.CheckEnableTransfer(type, WaferManager.Instance.GetWafer(_chamber.Module, 0).Size);
            //}
            //else if (type == EnumTransferType.Place)
            //{
            //    return _chamber.CheckEnableTransfer(type, WaferManager.Instance.GetWafer(robot, (int)blade).Size);
            //}

            return false;
        }
        public int InvokePrepareTransfer(ModuleName robot, EnumTransferType type, int slot)
        {
            if (CheckToPostMessage((int)MSG.PrepareTransfer, type.ToString()))
                return (int)MSG.PrepareTransfer;

            return (int)FSM_MSG.NONE;
        }

        public int InvokePrepareTransfer(ModuleName robot, EnumTransferType type, int slot, float temp)
        {
            if (CheckToPostMessage((int)MSG.PrepareTransfer, type.ToString(), temp))
                return (int)MSG.PrepareTransfer;

            return (int)FSM_MSG.NONE;
        }
        public int InvokePrepareTransfer(ModuleName robot, EnumTransferType type, int slot, float temp, WaferSize size)
        {
            if (CheckToPostMessage((int)MSG.PrepareTransfer, type.ToString(), temp, size))
                return (int)MSG.PrepareTransfer;

            return (int)FSM_MSG.NONE;
        }
        public int InvokePostTransfer(ModuleName robot, EnumTransferType type, int slot)
        {
            if (CheckToPostMessage((int)MSG.PostTransfer, type.ToString()))
                return (int)MSG.PostTransfer;

            return (int)FSM_MSG.NONE;
        }

        public int InvokeClean(string recipeName, string waferID, RecipeType recipeType)
        {
            if (CheckToPostMessage((int)MSG.Clean, recipeName, waferID, recipeType))
            {
                return (int)MSG.Clean;
            }
            return (int)FSM_MSG.NONE;
        }

        public int InvokeProcess(string recipeName, string waferID, RecipeType recipeType)
        {
            if (CheckToPostMessage((int)MSG.RunRecipe, recipeName, waferID, recipeType))
                return (int)MSG.RunRecipe;

            return (int)FSM_MSG.NONE;
        }

        public int InvokePreHeat(float temperature)
        {
            if (CheckToPostMessage((int)MSG.Heat, (double)temperature))
                return (int)MSG.Heat;

            return (int)FSM_MSG.NONE;
        }

        public void InvokeReset()
        {
            PostMsg((int)MSG.Reset);
        }

        public void SetAuto()
        {
            this._AutoMode = AutoFlag.Auto;
        }


        private bool FnSetManual(object[] param)
        {
            if (fsm.State == (int)PMState.PreProcess || fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PostProcess)
            {
                EV.PostWarningLog(Module.ToString(), $"{Module} is in {(PMState)fsm.State}，can not do SetAutoMode");
                return false;
            }
            this._AutoMode = AutoFlag.Manual;

            if (IsOnline)
            {
                EV.PostWarningLog(Module.ToString(), $"{Module} is online，change to offline due to the chamber change to manual mode");
                this._isOnline = false;
            }

            return true;
        }

        private bool FnSetInclude()
        {
            if (IsOnline == true)
            {
                LOG.Write(eEvent.WARN_PM, Module, $"{Module} is online，can not set Include");
                return false;
            }
            IsInclude = true;
            LOG.Write(eEvent.INFO_PM, Module, $"{Module}  Set Include Success");

            return true;
        }
        private bool FnSetExclude()
        {
            if (IsOnline == true)
            {
                LOG.Write(eEvent.WARN_PM, Module, $"{Module} is online，can not set Exclude");
                return false;
            }
            IsInclude = false;
            LOG.Write(eEvent.INFO_PM, Module, $"{Module}  Set Exclude Success");

            return true;
        }
        private bool FnSetOnline(object[] param)
        {
            //if (!IsAutoMode)
            //{
            //    EV.PostWarningLog(Module.ToString(), $"{Module} in manual mode，can not set online.");
            //    return false;
            //}

            if (!IsInclude)
            {
                LOG.Write(eEvent.WARN_PM, Module, $"{Module} is excluded，can not be put online");
                return false;
            }

            if (!_chamber.CheckSlitDoorClose())
            {
                EV.PostWarningLog(Module.ToString(), $"{Module} slit door is open，can not set online.");
                return false;
            }

            this._isOnline = true;
            return true;
        }

        private bool FnSetOffline(object[] param)
        {
            this._isOnline = false;
            return true;
        }

        public PMEntity(ModuleName module)
        {
            Module = module;
            _chamber = DEVICE.GetDevice<JetPMBase>(Module.ToString());
            _home = new PMHomeRoutine(_chamber);
            _startDryPumpRoutine = new StartDryPumpRoutine(_chamber);
            _startTurboPumpRoutine = new StartTurboPumpRoutine(_chamber);
            _ventRoutine = new VentRoutine(_chamber);
            _pumpRoutine = new PumpDownRoutine(_chamber);
            _ventLoadLockRoutine = new LoadLockVentRoutine(_chamber);
            _pumpLoadLockRoutine = new LoadLockPumpRoutine(_chamber);
            _purgeLoadLockRoutine = new LoadLockPurgeRoutine(_chamber);
            _loadLockLeakCheckRoutine = new LoadLockLeakCheckRoutine(_chamber);
            _purgeRoutine = new PMPurgeRoutine(_chamber);
            _gaslinePurgeRoutine = new PMGaslinePurgeRoutine(_chamber);
            _leakCheckRoutine = new PMLeakCheckRoutine(_chamber);
            _gasBoxLeakCheckRoutine = new GasBoxLeakCheckRoutine(_chamber);
            _llPlaceRoutine = new LLPlaceRoutine(_chamber);
            _llPickRoutine = new LLPickRoutine(_chamber, _ventLoadLockRoutine);
            _processRoutine = new PMProcessRoutine(_chamber, _pumpRoutine);
            _gasFlowRoutine = new GasFlowRoutine(_chamber);
            _rfPowerRoutine = new RFPowerSwitchRoutine(_chamber, true);
            _gasVerificationRoutine = new PMGasVerificationRoutine(_chamber, _pumpRoutine);
            _pmPartialPressureRoutine = new PMPartialPressureRoutine(_chamber);
            _pmVATPerformanceRoutine = new PMVATPerformanceRoutine(_chamber);
            //_pmControlPressureRoutine = new PMControlPressureRoutine(_chamber);

            _pmHeatRoutine = new PMHeatRoutine(_chamber);
            fsm = new StateMachine<PMEntity>(Module.ToString(), (int)PMState.Init, 50);

            //Idle
            EnterExitTransition((int)PMState.Idle, FnIdle, (int)FSM_MSG.NONE, null);
            EnterExitTransition<PMState, FSM_MSG>(PMState.Error, fEnterError, FSM_MSG.NONE, null);

            EnterExitTransition<PMState, FSM_MSG>(PMState.ReadyForPick, fnEnterPickReady, FSM_MSG.NONE, fnExitPickReady);
            EnterExitTransition<PMState, FSM_MSG>(PMState.ReadyForPlace, fnEnterPlaceReady, FSM_MSG.NONE, fnExitPlaceReady);
            EnterExitTransition<PMState, FSM_MSG>(PMState.DropDownReady, fnEnterDropDownReady, FSM_MSG.NONE, fnExitDropDownReady);
            EnterExitTransition<PMState, FSM_MSG>(PMState.LiftUpReady, fnEnterLiftUpReady, FSM_MSG.NONE, fnExitLiftUpReady);




            //Home
            //EnterExitTransition((int)PMState.Homing, FnEnterHome, (int)FSM_MSG.NONE, FnExitHome);

            AnyStateTransition(MSG.Error, FnError, PMState.Error);
            AnyStateTransition(MSG.Online, FnSetOnline, FSM_STATE.SAME);
            AnyStateTransition(MSG.Offline, FnSetOffline, FSM_STATE.SAME);

            Transition(PMState.Init, FSM_MSG.TIMER, FnTimeout, PMState.Init);
            Transition(PMState.Init, MSG.Home, FnStartHome, PMState.Homing);
            Transition(PMState.Error, MSG.Home, FnStartHome, PMState.Homing);
            Transition(PMState.Idle, MSG.Home, FnStartHome, PMState.Homing);
            Transition(PMState.Homing, MSG.Home, FnStartHome, PMState.Homing);
            Transition(PMState.Homing, FSM_MSG.TIMER, FnMonitorHome, PMState.Idle);

            Transition(PMState.Idle, FSM_MSG.TIMER, FnIdleTimeout, PMState.Idle);
            Transition(PMState.Error, FSM_MSG.TIMER, FnErrorTimeout, PMState.Error);

            //Launch DryPump sequence
            Transition(PMState.Idle, MSG.LaunchPump, FnLaunchPump, PMState.LaunchingPump);
            Transition(PMState.LaunchingPump, FSM_MSG.TIMER, FnLaunchPumpTimeout, PMState.Idle);
            Transition(PMState.LaunchingPump, MSG.Abort, FnAbortStartPumping, PMState.Idle);

            //Launch TurboPump sequence
            Transition(PMState.Idle, MSG.LaunchTurboPump, FnLaunchTurboPump, PMState.LaunchingTurboPump);
            Transition(PMState.LaunchingTurboPump, FSM_MSG.TIMER, FnLaunchTurboPumpTimeout, PMState.Idle);
            Transition(PMState.LaunchingTurboPump, MSG.Abort, FnAbortStartTurboPumping, PMState.Idle);

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

            //Pump sequence
            Transition(PMState.Idle, MSG.Pump, FnStartPumpDown, PMState.Pumping);
            Transition(PMState.Venting, MSG.Pump, FnVentToPumping, PMState.Pumping);
            Transition(PMState.Pumping, FSM_MSG.TIMER, FnPumpDownTimeout, PMState.Idle);
            Transition(PMState.Pumping, MSG.Abort, FnAbortPumping, PMState.Idle);

            //Pump Loadlock sequence
            Transition(PMState.Idle, MSG.PumpLoadLock, FnStartPumpDownLoadLock, PMState.PumpingLoadLock);
            Transition(PMState.VentingLoadLock, MSG.PumpLoadLock, FnVentLoadLockToPumpingLoadLock, PMState.PumpingLoadLock);
            Transition(PMState.PumpingLoadLock, FSM_MSG.TIMER, FnPumpDownLoadLockTimeout, PMState.Idle);
            Transition(PMState.PumpingLoadLock, MSG.Abort, FnAbortPumpingLoadLock, PMState.Idle);

            //Vent Loadlock sequence
            Transition(PMState.Idle, MSG.VentLoadLock, FnStartVentLoadlock, PMState.VentingLoadLock);
            Transition(PMState.PumpingLoadLock, MSG.VentLoadLock, FnPumpingLoadLockToVentLoadLock, PMState.VentingLoadLock);
            Transition(PMState.VentingLoadLock, FSM_MSG.TIMER, FnVentLoadLockTimeout, PMState.Idle);
            Transition(PMState.VentingLoadLock, MSG.Abort, FnAbortVentLoadLock, PMState.Idle);

            // Purge LoadLock sequence
            Transition(PMState.Idle, MSG.PurgeLoadLock, FnStartPurgeLoadlock, PMState.PurgingLoadLock);
            Transition(PMState.PurgingLoadLock, FSM_MSG.TIMER, FnPurgeLoadLockTimeout, PMState.Idle);
            Transition(PMState.PurgingLoadLock, MSG.Abort, FnAbortPurgeLoadLock, PMState.Idle);

            //LoadLock Leak check sequence
            Transition(PMState.Idle, MSG.LoadLockLeakCheck, FnStartLoadLockLeakCheck, PMState.LoadLockLeakCheck);
            Transition(PMState.LoadLockLeakCheck, FSM_MSG.TIMER, FnLoadLockLeakCheckTimeout, PMState.Idle);
            Transition(PMState.LoadLockLeakCheck, MSG.Abort, FnAbortLoadLockLeakCheck, PMState.Idle);

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

            // PM GasLine Purge sequence
            Transition(PMState.Idle, MSG.GasLinePurge, FnStartGasLinePurge, PMState.GasLinePurge);
            Transition(PMState.GasLinePurge, FSM_MSG.TIMER, FnGasLinePurgeTimeout, PMState.Idle);
            Transition(PMState.GasLinePurge, MSG.Abort, FnAbortGasLinePurge, PMState.Idle);

            //PM Leak check sequence
            Transition(PMState.Idle, MSG.LeakCheck, FnStartPMLeakCheck, PMState.LeakCheck);
            Transition(PMState.LeakCheck, FSM_MSG.TIMER, FnPMLeakCheckTimeout, PMState.Idle);
            Transition(PMState.LeakCheck, MSG.Abort, FnAbortPMLeakCheck, PMState.Idle);

            //PM GasBox Leak check sequence
            Transition(PMState.Idle, MSG.GasLeakCheck, FnStartGasBoxLeakCheck, PMState.GasBoxLeakCheck);
            Transition(PMState.GasBoxLeakCheck, FSM_MSG.TIMER, FnGasBoxLeakCheckTimeout, PMState.Idle);
            Transition(PMState.GasBoxLeakCheck, MSG.Abort, FnAbortGasBoxLeakCheck, PMState.Idle);


            // PlaceWafer from LoadLock Arm sequence
            Transition(PMState.Idle, MSG.LLPlace, FnStartLLPlace, PMState.LLPlacing);
            Transition(PMState.LLPlacing, FSM_MSG.TIMER, FnLLPlaceTimeout, PMState.Idle);
            Transition(PMState.LLPlacing, MSG.Abort, FnAbortLLPlace, PMState.Idle);

            // PickWafer to LoadLock Arm sequence
            Transition(PMState.Idle, MSG.LLPick, FnStartLLPick, PMState.LLPicking);
            Transition(PMState.LLPicking, FSM_MSG.TIMER, FnLLPickTimeout, PMState.Idle);
            Transition(PMState.LLPicking, MSG.Abort, FnAbortLLPick, PMState.Idle);

            // Process
            Transition(PMState.Idle, MSG.RunRecipe, FnRunRecipe, PMState.Processing);
            Transition(PMState.Processing, FSM_MSG.TIMER, FnProcessTimeout, PMState.Idle);
            Transition(PMState.Processing, MSG.Abort, FnAbortProcess, PMState.Idle);

            // Clean
            Transition(PMState.Idle, MSG.Clean, FnRunRecipe, PMState.Clean);
            Transition(PMState.Clean, FSM_MSG.TIMER, FnProcessTimeout, PMState.Idle);
            Transition(PMState.Clean, MSG.Abort, FnAbortProcess, PMState.Idle);

            // Gas Flow sequence
            Transition(PMState.Idle, MSG.GasFlow, FnStartGasFlow, PMState.GasFlowing);
            Transition(PMState.GasFlowing, MSG.GasFlow, FnAbortGasFlow, PMState.Idle);
            Transition(PMState.GasFlowing, FSM_MSG.TIMER, FnGasFlowTimeout, PMState.Idle);
            Transition(PMState.GasFlowing, MSG.StopGasFlow, FnStopGasFlow, PMState.Idle);
            Transition(PMState.GasFlowing, MSG.Abort, FnAbortGasFlow, PMState.Idle);

            //RF Power sequence
            Transition(PMState.Idle, MSG.RfPower, FnStartRfPower, PMState.RfPowering);
            Transition(PMState.GasFlowing, MSG.RfPower, FnStartRfPower, PMState.RfPowering);
            Transition(PMState.RfPowering, FSM_MSG.TIMER, FnRfPowerTimeout, PMState.Idle);
            Transition(PMState.RfPowering, MSG.Abort, FnAbortRfPower, PMState.Idle);

            //MFC verification
            Transition(PMState.Idle, MSG.MFCVerification, FnStartMFCVerification, PMState.MFCVerification);
            Transition(PMState.MFCVerification, FSM_MSG.TIMER, FnMFCVerificationTimeout, PMState.Idle);
            Transition(PMState.MFCVerification, MSG.Abort, FnAbortMFCVerification, PMState.Idle);

            //////////////////////// Exchange Wafer with TM ///////////////////////////////////////////////////////
            // Pick Wafer from PM
            Transition(PMState.Idle, MSG.PreparePick, FnStartPreparePick, PMState.PreparePick);
            Transition(PMState.PreparePick, MSG.Abort, FnAbortPreparePick, PMState.Idle);
            Transition(PMState.PreparePick, FSM_MSG.TIMER, FnPreparePickTimeout, PMState.ReadyForPick);
            Transition(PMState.PreparePick, MSG.PreparePick, null, PMState.PreparePick);
            Transition(PMState.ReadyForPick, MSG.Abort, FnAbortPick, PMState.Idle);
            Transition(PMState.ReadyForPick, MSG.DropDownWafer, FnStartDropDownWafer, PMState.DropDownWafer);


            Transition(PMState.ReadyForPick, MSG.PreparePick, null, PMState.ReadyForPick);
            Transition(PMState.DropDownWafer, FSM_MSG.TIMER, FnDropDownTimeout, PMState.DropDownReady);
            Transition(PMState.DropDownReady, MSG.PickReady, FnStartFinishPick, PMState.FinishPick);
            Transition(PMState.ReadyForPick, MSG.PickReady, FnStartFinishPick, PMState.FinishPick);
            Transition(PMState.FinishPick, FSM_MSG.TIMER, FnFinishPickTimeout, PMState.Idle);


            // Place Wafer to PM
            Transition(PMState.Idle, MSG.PreparePlace, FnStartPreparePlace, PMState.PreparePlace);
            Transition(PMState.Heating, MSG.PreparePlace, FnStartPreparePlace, PMState.PreparePlace);
            Transition(PMState.PreparePlace, MSG.Abort, FnAbortPreparePlace, PMState.Idle);
            Transition(PMState.PreparePlace, FSM_MSG.TIMER, FnPreparePlaceTimeout, PMState.ReadyForPlace);
            Transition(PMState.PreparePlace, MSG.PreparePlace, null, PMState.PreparePlace);
            Transition(PMState.ReadyForPlace, MSG.LiftUpWafer, FnStartLiftUpWafer, PMState.LiftUpWafer);
            Transition(PMState.LiftUpWafer, FSM_MSG.TIMER, FnLiftUpTimeout, PMState.LiftUpReady);
            Transition(PMState.LiftUpReady, MSG.PlaceReady, FnStartFinishPlace, PMState.FinishPlace);
            Transition(PMState.ReadyForPlace, MSG.PlaceReady, FnStartFinishPlace, PMState.FinishPlace);
            Transition(PMState.PreparePlace, MSG.Abort, FnAortPlace, PMState.Idle);
            Transition(PMState.ReadyForPlace, MSG.Abort, FnAortPlace, PMState.Idle);
            Transition(PMState.ReadyForPlace, MSG.PreparePlace, null, PMState.ReadyForPlace);
            Transition(PMState.LiftUpReady, MSG.Abort, FnAortPlace, PMState.Idle);
            Transition(PMState.FinishPlace, FSM_MSG.TIMER, FnFinishPlaceTimeout, PMState.Idle);


            // Swap Wafer With PM
            Transition(PMState.DropDownReady, MSG.PreparePlace, FnStartSwapPlace, PMState.PreparePlace);
            Transition(PMState.ReadyForPick, MSG.PreparePlace, FnStartPreparePlace, PMState.PreparePlace);

            Transition(PMState.Idle, MSG.PartialPressure, FnStartPartialPressure, PMState.PartialPressureTesting);
            Transition(PMState.PartialPressureTesting, FSM_MSG.TIMER, FnPartialPressureTimeout, PMState.Idle);
            Transition(PMState.PartialPressureTesting, MSG.Abort, FnAbortPartialPressure, PMState.Idle);
            Transition(PMState.Idle, MSG.VATPerformance, FnStartVATPerformance, PMState.VATPerformanceTesting);
            Transition(PMState.VATPerformanceTesting, FSM_MSG.TIMER, FnVATPerformanceTimeout, PMState.Idle);
            Transition(PMState.VATPerformanceTesting, MSG.Abort, FnAbortVATPerformance, PMState.Idle);

            //Transition(PMState.Idle, MSG.Heat, FnStartHeat, PMState.Heating);
            AnyStateTransition(FSM_MSG.TIMER, FnControlPressure, FSM_STATE.SAME);
            Running = true;

            WaferManager.Instance.SubscribeLocation(Module, 1);
        }

        protected override bool Init()
        {
            DATA.Subscribe($"{Module}.FsmState", () => (((PMState)fsm.State)), 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}.LoadLockPurge.PurgeCounter", () => _purgeLoadLockRoutine.PurgeCounter, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PartialPressureCounter", () => _pmPartialPressureRoutine.counter, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.VATPerformanceCounter", () => _pmVATPerformanceRoutine.counter, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.VATPerformanceResult", () => _pmVATPerformanceRoutine?.m_sb.ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Module}.PartialPressureResult", () => _pmPartialPressureRoutine?.m_sb.ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.MFCCalibrationDatas", () => _gasVerificationRoutine?._MFCCalibrationDatas, SubscriptionAttribute.FLAG.IgnoreSaveDB);



            DATA.Subscribe($"{Module}.IsIdle", () => IsIdle, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsAlarm", () => IsError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsBusy", () => IsBusy, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsInit", () => IsInit, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsOnline", () => _isOnline, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Module}.VentingFlag", () => _ventRoutine.VentingFlag, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            //DATA.Subscribe($"{Module}.GetLeakCheckDatas", () => LeakCheckDataRecorder.GetAllLeakCheckData(Module.ToString()));


            DATA.Subscribe($"{Module}.CurrentRecipeResult", () => _processRoutine.currentRecipeResult, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.LeakCheck.Step", () => _leakCheckRoutine.CurrentStep, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.GasLeakCheck.Step", () => _gasBoxLeakCheckRoutine.CurrentStep, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsInclude", () => IsInclude, SubscriptionAttribute.FLAG.IgnoreSaveDB);



            OP.Subscribe($"{Module}.{RtOperation.GasFlow}", (cmd, args) => CheckToPostMessage((int)MSG.GasFlow, args));
            OP.Subscribe($"{Module}.{RtOperation.LeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.LeakCheck, args));
            OP.Subscribe($"{Module}.{RtOperation.GasLeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.GasLeakCheck, args));

            OP.Subscribe($"{Module}.Home", (cmd, args) => CheckToPostMessage((int)MSG.Home));
            OP.Subscribe($"{Module}.{RtOperation.StartPump}", (cmd, args) => CheckToPostMessage((int)MSG.LaunchPump));
            OP.Subscribe($"{Module}.{RtOperation.StartTurboPump}", (cmd, args) => CheckToPostMessage((int)MSG.LaunchTurboPump));
            OP.Subscribe($"{Module}.{RtOperation.Pump}", (cmd, args) => CheckToPostMessage((int)MSG.Pump));
            OP.Subscribe($"{Module}.{RtOperation.Purge}", (cmd, args) => CheckToPostMessage((int)MSG.CyclePurge));
            OP.Subscribe($"{Module}.{RtOperation.RfPower}", (cmd, args) => CheckToPostMessage((int)MSG.RfPower));
            OP.Subscribe($"{Module}.{RtOperation.Vent}", (cmd, args) => CheckToPostMessage((int)MSG.Vent));
            OP.Subscribe($"{Module}.{RtOperation.VentLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.VentLoadLock));
            OP.Subscribe($"{Module}.{RtOperation.PurgeLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.PurgeLoadLock));
            OP.Subscribe($"{Module}.{RtOperation.PumpLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.PumpLoadLock));
            OP.Subscribe($"{Module}.{RtOperation.Reset}", (cmd, args) => CheckToPostMessage((int)MSG.Reset));
            OP.Subscribe($"{Module}.{RtOperation.Abort}", (cmd, args) => CheckToPostMessage((int)MSG.Abort));

            OP.Subscribe($"{Module}.{RtOperation.LLPick}", (cmd, args) => CheckToPostMessage((int)MSG.LLPick));
            OP.Subscribe($"{Module}.{RtOperation.LLPlace}", (cmd, args) => CheckToPostMessage((int)MSG.LLPlace));

            OP.Subscribe($"{Module}.{RtOperation.MFCVerification}", (cmd, args) => CheckToPostMessage((int)MSG.MFCVerification, args));

            OP.Subscribe($"{Module}.{RtOperation.RunRecipe}", (cmd, args) => CheckToPostMessage((int)MSG.RunRecipe, args));

            OP.Subscribe($"{Module}.{RtOperation.RunCleanRecipe}", (cmd, args) => CheckToPostMessage((int)MSG.Clean, args));


            OP.Subscribe($"{Module}.PartialPressureTest", (cmd, args) => CheckToPostMessage((int)MSG.PartialPressure, args[0], args[1]));
            OP.Subscribe($"{Module}.VATPerformanceTest", (cmd, args) => CheckToPostMessage((int)MSG.VATPerformance, args[0], args[1], args[2]));

            OP.Subscribe($"{Module}.GasLinePurge", (cmd, args) => CheckToPostMessage((int)MSG.GasLinePurge));

            OP.Subscribe($"{Module}.ManualEndStep", (cmd, args) => ManualEndStep());

            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.PmError}", (cmd, args) => CheckToPostMessage((int)MSG.Error));

            OP.Subscribe($"{Module}.{RtOperation.Include}", (cmd, args) => FnSetInclude());
            OP.Subscribe($"{Module}.{RtOperation.Exclude}", (cmd, args) => FnSetExclude());


            if (ChamberType == JetChamber.Kepler2200A && ChamberType == JetChamber.Kepler2200B)
            {
                LOG.PMErrorInterrupt += (pmname) => PMErrorInterrupt(pmname);
            }

            return true;
        }

        private void PMErrorInterrupt(ModuleName pmname)
        {
            if (pmname == Module)
            {
                LOG.Write(eEvent.ERR_PM, Module, $"Device Error Happend! {Module} Crash!");
                CheckToPostMessage((int)MSG.Error);
            }
        }

        private bool ManualEndStep()
        {
            _processRoutine.isMaualEndStep = true;
            return true;
        }
        private bool FnIdle(object[] objs)
        {
            Running = false;
            return true;
        }

        private bool fEnterError(object[] objs)
        {
            return true;
        }

        private bool fnEnterPickReady(object[] objs)
        {
            Status = PMStatus.Ready_For_Pick;
            return true;
        }

        private bool fnExitPickReady(object[] objs)
        {
            Status = PMStatus.Not_Ready;
            return true;
        }

        private bool fnEnterPlaceReady(object[] objs)
        {
            Status = PMStatus.Ready_For_Place;
            return true;
        }

        private bool fnExitPlaceReady(object[] objs)
        {
            Status = PMStatus.Not_Ready;
            return true;
        }

        private bool fnEnterDropDownReady(object[] objs)
        {
            Status = PMStatus.Exchange_Ready;
            return true;
        }

        private bool fnExitDropDownReady(object[] objs)
        {
            Status = PMStatus.Not_Ready;
            return true;
        }

        private bool fnEnterLiftUpReady(object[] objs)
        {
            Status = PMStatus.Exchange_Ready;
            return true;
        }

        private bool fnExitLiftUpReady(object[] objs)
        {
            Status = PMStatus.Not_Ready;
            return true;
        }

        private bool FnError(object[] objs)
        {
            Running = false;
            _isOnline = false;

            //if (((PMState)fsm.State == PMState.Processing) || ((PMState)fsm.State == PMState.PreProcess)
            //    || ((PMState)fsm.State == PMState.Homing) || ((PMState)fsm.State == PMState.LoadProcessRecipe))
            //    return false;

            _chamber.CloseValves();
            _chamber.GeneratorPowerOn(false);
            _chamber.GeneratorBiasPowerOn(false);
            _chamber.OpenValve(ValveType.TurboPumpPumping, true);
            _chamber.OpenValve(ValveType.TurboPumpPurge, true);
            _chamber.OnOffSetESCHV(false);

            if (IsProcessing)
            {
                WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.Failed);
            }

            return true;
        }

        private bool FnTimeout(object[] objs)
        {
            _debugRoutine();
            return true;
        }

        private bool FnIdleTimeout(object[] objs)
        {
            _chamber.CheckIdleInterlock();
            //_debugRoutine();
            return true;
        }

        private bool FnErrorTimeout(object[] objs)
        {
            //_debugRoutine();
            return true;
        }

        private bool FnStartHome(object[] objs)
        {
            return _home.Start() == RState.Running;
        }

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

            return ret == RState.End;
        }

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

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

            return ret == RState.End;
        }

        private bool FnAbortStartPumping(object[] param)
        {
            _startDryPumpRoutine.Abort();
            return true;
        }
        private bool FnLaunchTurboPump(object[] param)
        {
            return _startTurboPumpRoutine.Start() == RState.Running;
        }

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

            return ret == RState.End;
        }

        private bool FnAbortStartTurboPumping(object[] param)
        {
            _startTurboPumpRoutine.Abort();
            return true;
        }

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

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

            return ret == RState.End;
        }

        private bool FnVentToPumping(object[] param)
        {
            _ventRoutine.Abort();
            return true; // FnStartPumpDown(param);
        }

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

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

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

            return ret == RState.End;
        }

        private bool FnAbortPumping(object[] param)
        {
            _pumpRoutine.Abort();
            return true;
        }

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

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

            return ret == RState.End;
        }

        private bool FnVentLoadLockToPumpingLoadLock(object[] param)
        {
            _ventLoadLockRoutine.Abort();
            return FnStartPumpDownLoadLock(param);
        }

        private bool FnAbortVentLoadLock(object[] param)
        {
            _ventLoadLockRoutine.Abort();
            return true;
        }

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

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

            return ret == RState.End;
        }

        private bool FnPumpingToVent(object[] param)
        {
            _pumpRoutine.Abort();
            return FnStartVent(param);
        }

        private bool FnPumpingLoadLockToVentLoadLock(object[] param)
        {
            _pumpLoadLockRoutine.Abort();
            return FnStartVentLoadlock(param);
        }

        private bool FnAbortPumpingLoadLock(object[] param)
        {
            _pumpLoadLockRoutine.Abort();
            return true;
        }
        private bool FnStartPurgeLoadlock(object[] param)
        {
            return _purgeLoadLockRoutine.Start() == RState.Running;
        }

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

            return ret == RState.End;
        }

        private bool FnAbortPurgeLoadLock(object[] param)
        {
            _purgeLoadLockRoutine.Abort();
            return true;
        }

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

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

            return ret == RState.End;
        }

        private bool FnAbortLoadLockLeakCheck(object[] param)
        {
            _loadLockLeakCheckRoutine.Abort();
            return true;
        }

        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 FnStartGasLinePurge(object[] param)
        {
            return _gaslinePurgeRoutine.Start() == RState.Running;
        }

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

            return ret == RState.End;
        }
        private bool FnAbortGasLinePurge(object[] param)
        {
            _gaslinePurgeRoutine.Abort();
            return true;
        }

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

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

            return ret == RState.End;
        }

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

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

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

            return ret == RState.End;
        }

        private bool FnAbortGasBoxLeakCheck(object[] param)
        {
            _gasBoxLeakCheckRoutine.Abort();
            return true;
        }

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

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

            return ret == RState.End;
        }

        private bool FnAbortLLPlace(object[] param)
        {
            _llPlaceRoutine.Abort();
            return true;
        }

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

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

            return ret == RState.End;
        }

        private bool FnAbortLLPick(object[] param)
        {
            _llPickRoutine.Abort();
            return true;
        }

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

            return ret == RState.Running;
        }
        private bool FnProcessTimeout(object[] param)
        {
            _chamber.CheckIdleInterlock();
            RState ret = _processRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            if (ret == RState.End)
            {
                _dictRecipeTime[_processRoutine.currentRecipeResult.RecipeName] = fsm.ElapsedTime;
                return true;
            }

            return false;
        }
        private bool FnAbortProcess(object[] param)
        {
            _processRoutine.Abort();
            return true;
        }

        private bool FnStartGasFlow(object[] param)
        {
            return _gasFlowRoutine.Start(param) == RState.Running;
        }
        private bool FnGasFlowTimeout(object[] param)
        {
            RState ret = _gasFlowRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnStopGasFlow(object[] param)
        {
            _gasFlowRoutine.Abort();
            return true;
        }

        private bool FnAbortGasFlow(object[] param)
        {
            _gasFlowRoutine.Abort();
            return true;
        }

        private bool FnStartRfPower(object[] param)
        {
            return _rfPowerRoutine.Start(param) == RState.Running;
        }
        private bool FnRfPowerTimeout(object[] param)
        {
            RState ret = _rfPowerRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortRfPower(object[] param)
        {
            _rfPowerRoutine.Abort();
            if (_gasFlowRoutine._gasStatus)
            {
                _gasFlowRoutine.StopFlow();
            }
            return true;
        }

        private bool FnStartMFCVerification(object[] param)
        {
            _gasVerificationRoutine.Init((string)param[0], Convert.ToDouble(param[1]), (int)param[2]);
            return _gasVerificationRoutine.Start(param) == RState.Running;
        }

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

            return ret == RState.End;
        }

        private bool FnAbortMFCVerification(object[] param)
        {
            _gasVerificationRoutine.Abort();
            return true;
        }
        private bool FnControlPressure(object[] param)
        {
            if (RouteManager.IsATMMode)
            {
                return true;
            }

            if (IsOnline == true && fsm.State != (int)PMState.Processing && fsm.State != (int)PMState.Clean)
            {
                if (startControlPressureFlag == true)
                {
                    startControlPressureFlag = false;

                    if (_chamber.GetPVPosition() <= 0)
                    {
                        LOG.Write(eEvent.WARN_PM, Module, $"{Module} control pressure fail,due to pendulum valve is not Open");
                        return false;
                    }
                    if (_chamber.IsTurboPumpRunning == false)
                    {
                        LOG.Write(eEvent.WARN_PM, Module, $"{Module} control pressure fail,due to turbo pump is not Open");
                        return false;
                    }
                    _controlPressureSetPoint = SC.GetValue<int>($"{Module}.ControlPressureSetPoint");
                    _controlFlowSetPoint = SC.GetValue<int>($"{Module}.ControlPressureN2FlowSetPoint");
                    _chamber.StartControlPressure(_controlPressureSetPoint, _controlFlowSetPoint);
                }
            }
            else
            {
                if (startControlPressureFlag == false)
                {
                    _chamber.AbortControlPressure();
                    startControlPressureFlag = true;
                }
            }
            return true;

        }

        #region Exchange wafer with TM
        private bool FnStartPreparePick(object[] param)
        {
            if (!_chamber.PreparePick())
            {
                LOG.Write(eEvent.ERR_PM, Module, $"Prepare Pick failed");
                return false;
            }

            return true;
        }
        private bool FnPreparePickTimeout(object[] param)
        {
            // return _chamber.WaferIsDown && IsSlitDoorOpen;
            return _chamber.PreparePickIsOK();
        }
        private bool FnAbortPreparePick(object[] param)
        {
            return true;
        }

        private bool FnStartFinishPick(object[] param)
        {
            //if (!_chamber.SetSlitDoor(false, out string reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Close failed:{reason}");
            //    return false;
            //}

            //return true;
            return _chamber.EndPick();
        }
        private bool FnAbortPick(object[] param)
        {
            return true;
        }
        private bool FnFinishPickTimeout(object[] param)
        {
            //return IsSlitDoorClose;
            return _chamber.EndPickIsOK();
        }

        private bool FnStartDropDownWafer(object[] param)
        {
            if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason))
            {
                LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin Down failed:{reason}");
                return false;
            }

            return _chamber.SetLiftPin(MovementPosition.Down, out string _);
        }

        private bool FnDropDownTimeout(object[] param)
        {
            return _chamber.LiftPinIsDown;
        }

        private bool FnStartPreparePlace(object[] param)
        {
            //if (_chamber.ChamberType == JetChamber.Venus || _chamber.ChamberType == JetChamber.Kepler2300)
            //{
            //    if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason))
            //    {
            //        LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin down failed:{reason}");
            //        return false;
            //    }
            //}
            if (!_chamber.PreparePlace())
            {
                LOG.Write(eEvent.ERR_PM, Module, $"Set Wafer Down failed");
                return false;
            }
            //string reason = "";
            //if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin down failed:{reason}");
            //    return false;
            //}



            return true;
        }
        private bool FnPreparePlaceTimeout(object[] param)
        {
            return _chamber.PreparePlaceIsOK();

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

        private bool FnStartLiftUpWafer(object[] param)
        {
            if (!_chamber.SetLiftPin(MovementPosition.Up, out string reason))
            {
                LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin Up failed:{reason}");
                return false;
            }

            return true;
        }

        private bool FnLiftUpTimeout(object[] param)
        {
            return _chamber.LiftPinIsUp;
        }

        private bool FnStartFinishPlace(object[] param)
        {
            //if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin Down failed:{reason}");
            //    return false;
            //}

            //if (!_chamber.SetSlitDoor(false, out reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Close failed:{reason}");
            //    return false;
            //}

            //return true;
            return _chamber.EndPlace();
        }
        private bool FnAortPlace(object[] param)
        {
            return true;
        }
        private bool FnFinishPlaceTimeout(object[] param)
        {
            //return _chamber.LiftPinIsDown && IsSlitDoorClose;
            return _chamber.EndPlaceIsOK();
        }
        private bool FnStartSwapPlace(object[] param)
        {
            return true;
        }
        private bool FnStartPartialPressure(object[] param)
        {
            return _pmPartialPressureRoutine.Start(param) == RState.Running;
        }
        private bool FnPartialPressureTimeout(object[] param)
        {
            RState ret = _pmPartialPressureRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }
            return ret == RState.End;
        }
        private bool FnAbortPartialPressure(object[] param)
        {
            _pmPartialPressureRoutine.Abort();
            return true;
        }
        private bool FnStartVATPerformance(object[] param)
        {
            return _pmVATPerformanceRoutine.Start(param) == RState.Running;
        }
        private bool FnVATPerformanceTimeout(object[] param)
        {
            RState ret = _pmVATPerformanceRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }
            return ret == RState.End;
        }
        private bool FnAbortVATPerformance(object[] param)
        {
            _pmVATPerformanceRoutine.Abort();
            return true;
        }
        private bool FnStartHeat(object[] param)
        {
            if (ChamberType == JetChamber.Kepler2200A || ChamberType == JetChamber.Kepler2200B)
            {
                _pmHeatRoutine.Start();
            }
            return true;
        }
        #endregion

        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);
            }
        }
    }
}