Virgo_ST/VirgoRT/Modules/PMs/PMEntity.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Diagnostics;
using System.Linq;
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.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.RT.Device.Custom;
using Aitex.Sorter.Common;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using VirgoCommon;
using VirgoRT.Devices;
using VirgoRT.Modules;
using VirgoRT.Modules.PMs;

namespace VirgoRT.Module
{

    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 MSG
        {
            Home,
            Transfer,
            PrepareTransfer,
            PostTransfer,
            Reset,
            Abort,
            Error,
            LaunchPump,
            Pump,
            Vent,
            CyclePurge,
            Heat,
            TransferHandoff,
            StartTransfer,
            LeakCheck,
            DeleteLeakCheck,
            MoveLiftPin,
            WaitLiftpin,
            MoveGuidePin,
            MFCVerification,
            AllMFCVerification,

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

            OpenSlitDoor,
            CloseSlitDoor,
            
            Online,
            Offline,
            GasFlow,
            StopGasFlow,
            RfPower,
            MaxMsg
        }

        // ----------------------------Fields--------------------------
        // 
        private int _bigWafer = 0;
        private int _midWafer = 0;
        private int _smallWafer = 0;
        private bool _enableBias;
        private int _liftpinDelayTime = 0;
        private StatsDataItem _statProcessedWafer;
        private StatsDataItemRFAndPump _statRfOnTime;
        private StatsDataItemRFAndPump _statBiasRfOnTime;
        private StatsDataItemRFAndPump _statPumpOnTime;

        private readonly JetPM                      _chamber;
        private string                              _processStatus;
        private DateTime                            _recipeStartTime;
 
        //routine
        private readonly VentRoutine                _ventRoutine;
        private readonly PumpDownRoutine            _pumpRoutine;
        private readonly StartPumpRoutine           _startPumpRoutine;
        private readonly TemperatureControlRoutine  _temperatureControlRoutine;
        private readonly GasFlowRoutine             _gasFlowRoutine;
        private readonly RfPowerRoutine             _rfPowerRoutine;
        private readonly CyclePurgeRoutine          _cyclePurgeRoutine;
        private readonly CleanRoutine               _cleanRoutine;
        private readonly ProcessRoutine             _processRoutine;
        private readonly PreProcessRoutine          _preProcessRoutine;
        private readonly PostProcessRoutine         _postProcessRoutine;
        private readonly LeakCheckRoutine           _leakCheckRoutine;
        private readonly PMPrepareTransferRoutine   _prepareTrans;
        private readonly PMPostTransferRoutine      _postTrans;
        private readonly PMHomeRoutine              _home;
        private readonly PMMfcVerificationRoutine   _mfcVerification;
        private readonly PMAllMfcVerificationRoutine _allMfcVerification;

        private AutoFlag                            _AutoMode;
        private bool                                _isOnline;
        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;
        // --------------------------Properties------------------------
        // 
        public ModuleName Module { get; }
        public Action<bool, bool> TransferPrepared;

        public bool IsIdle
        {
            get { return fsm.State == (int)PMState.Idle; }
        }

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

        public bool IsAutoMode => _AutoMode == AutoFlag.Auto;


        public RecipeRunningInfo RecipeRunningInfo
        {
            get
            {
                return _recipeRunningInfo;
            }
        }

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

        private DateTime _leakCheckStartTime;
        private TimeSpan _leakCheckElapsedTime;
        private string LeakCheckElapseTime
        {
            get
            {
                if ((fsm.State == (int)PMState.LeakCheck))
                    _leakCheckElapsedTime = DateTime.Now - _leakCheckStartTime;

                return string.Format("{0}:{1}:{2}", ((int)_leakCheckElapsedTime.TotalHours).ToString("00"),
                    _leakCheckElapsedTime.Minutes.ToString("00"), _leakCheckElapsedTime.Seconds.ToString("00"));
            }
        }

        private string PumpTime
        {
            get
            {
                if ((fsm.State == (int)PMState.Pumping) || (fsm.State == (int)PMState.PreProcess))
                    _pumpElapsedTime = DateTime.Now - _pumpStartTime;

                return string.Format("{0}:{1}:{2}", ((int)_pumpElapsedTime.TotalHours).ToString("00"),
                    _pumpElapsedTime.Minutes.ToString("00"), _pumpElapsedTime.Seconds.ToString("00"));
            }
        }

        private int StepNo
        {
            get
            {
                if ( (fsm.State == (int)PMState.Processing) || (fsm.State == (int)PMState.PostProcess))
                {
                    return _processRoutine.CurStepNum + 1;
                }
                return 0;
            }
        }

        private int RecipeSteps
        {
            get
            {
                if ((fsm.State == (int)PMState.PreProcess) || (fsm.State == (int)PMState.Processing) || (fsm.State == (int)PMState.PostProcess))
                {
                    return _preProcessRoutine.CurrentRecipeStepList.Count;
                }
                return 0;
            }
        }

        private string RecipeStepName
        {
            get
            {
                if ((fsm.State == (int)PMState.PreProcess) || (fsm.State == (int)PMState.Processing) || (fsm.State == (int)PMState.PostProcess))
                {
                    return _processRoutine.CurStepComment;
                }
                return null;
            }
        }

        private double LeakRate
        {
            get { return _leakCheckRoutine.LeakRate; }
        }

        private string RecipeName
        {
            get
            {
                if ((fsm.State == (int)PMState.PreProcess) || (fsm.State == (int)PMState.Processing) || (fsm.State == (int)PMState.PostProcess))
                {
                    return _preProcessRoutine.CurrentRecipeRunningName.Split('\\').Last();
                }
                return null;
            }
        }

        private string RFTime
        {
            get
            {
                if (fsm.State == (int)PMState.RfPowering)
                    _rfElapsedTime = DateTime.Now - _rfStartTime;

                return $"{((int)_rfElapsedTime.TotalHours).ToString("00")}:{_rfElapsedTime.Minutes.ToString("00")}:{_rfElapsedTime.Seconds.ToString("00")}";
            }
        }

        private string TCTime
        {
            get
            {
                if (fsm.State == (int)PMState.Heating)
                    _tcElapsedTime = DateTime.Now - _tcStartTime;

                return $"{((int)_tcElapsedTime.TotalHours).ToString("00")}:{_tcElapsedTime.Minutes.ToString("00")}:{_tcElapsedTime.Seconds.ToString("00")}";
            }
        }

        private TimeSpan _recipeElapsedTime;
        public string RecipeElapsedTime
        {
            get
            {
                if (fsm.State == (int)PMState.LoadProcessRecipe || fsm.State == (int)PMState.PreProcess
                                                                || fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PostProcess)
                    _recipeElapsedTime = DateTime.Now - _recipeStartTime;

                return string.Format("{0}:{1}:{2}", ((int)_recipeElapsedTime.TotalHours).ToString("00"),
                    _recipeElapsedTime.Minutes.ToString("00"), _recipeElapsedTime.Seconds.ToString("00"));
            }
        }

        public double RecipeTotalElapsedSeconds
        {
            get
            {
                if (fsm.State == (int)PMState.LoadProcessRecipe || fsm.State == (int)PMState.PreProcess
                                                                || fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PostProcess)
                    _recipeElapsedTime = DateTime.Now - _recipeStartTime;

                return _recipeElapsedTime.TotalSeconds;
            }
        }

        public bool IsOnline
        {
            get { return _isOnline; }
        }

        private RecipeRunningInfo _recipeRunningInfo = new RecipeRunningInfo();


        // --------------------------Constructor-----------------------
        // 
        public PMEntity(ModuleName module)
        {
            this.Module = module;
            //_chamber = new JetPM(ModuleHelper.Converter(Name));
            _smallWafer = SC.GetValue<int>($"System.SmallWafer");
            _midWafer = SC.GetValue<int>($"System.MidWafer");
            _bigWafer = SC.GetValue<int>($"System.BigWafer");
            _enableBias = SC.GetValue<bool>($"{Module}.BiasRf.EnableBiasRF");
            _chamber = DEVICE.GetDevice<JetPM>(Module.ToString());
            _isAlarm = false;
            _LifpinSleepTimer = new Stopwatch();

            LeakCheckResultManager.Instance.Initialize(Module.ToString());

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

            _ventRoutine        = new VentRoutine(_chamber);
            _pumpRoutine        = new PumpDownRoutine(_chamber);
            _startPumpRoutine   = new StartPumpRoutine(_chamber);
            _temperatureControlRoutine = new TemperatureControlRoutine(_chamber);
            _prepareTrans       = new PMPrepareTransferRoutine(_chamber, _ventRoutine);
            _postTrans          = new PMPostTransferRoutine(_chamber);
            _gasFlowRoutine     = new GasFlowRoutine(_chamber);
            _rfPowerRoutine     = new RfPowerRoutine(_chamber, true);
            _cyclePurgeRoutine  = new CyclePurgeRoutine(_chamber);
            _leakCheckRoutine   = new LeakCheckRoutine(_chamber, _pumpRoutine);
            _cleanRoutine       = new CleanRoutine(_chamber);
            _preProcessRoutine  = new PreProcessRoutine(_chamber, _pumpRoutine);
            _processRoutine     = new ProcessRoutine(_chamber, this);
            _postProcessRoutine = new PostProcessRoutine(_chamber, _ventRoutine);
            _home               = new PMHomeRoutine(_chamber);
            _mfcVerification    = new PMMfcVerificationRoutine(_chamber, _pumpRoutine);
            _allMfcVerification = new PMAllMfcVerificationRoutine(_chamber, _pumpRoutine);

            //Idle
            EnterExitTransition((int)PMState.Idle,                    FnIdle, (int)FSM_MSG.NONE, null);
            EnterExitTransition<PMState, FSM_MSG>(PMState.Error,      fEnterError, FSM_MSG.NONE, null);
            //Error
            Transition(PMState.Init, MSG.Error,                       FnError, PMState.Error);
            Transition(PMState.Error, MSG.Reset,                      FnReset, PMState.Idle);
            //AnyStateTransition(MSG.Error,                             FnError, PMState.Error);
            AnyStateTransition(FSM_MSG.WARNING,                       fWarning, FSM_STATE.SAME);
            AnyStateTransition((int)FSM_MSG.ALARM,                    fAlarm, (int)PMState.Error);
            AnyStateTransition(MSG.AutoMode,                          FnSetAuto, FSM_STATE.SAME);
            AnyStateTransition(MSG.ManualMode,                        FnSetManual, FSM_STATE.SAME);
            AnyStateTransition(MSG.Online,                            FnSetOnline, FSM_STATE.SAME);
            AnyStateTransition(MSG.Offline,                           FnSetOffline, FSM_STATE.SAME);

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

            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, FSM_MSG.TIMER,                 FnMonitorHome, PMState.Idle);
            Transition(PMState.Homing, MSG.Error,                     null, PMState.Init);
            Transition(PMState.Homing, MSG.Abort,                     FnAbortTask, PMState.Init);

            // Gas Flow sequence
            Transition(PMState.Idle, MSG.GasFlow,                     FnStartGasFlow, PMState.GasFlowing);
            Transition(PMState.GasFlowing, MSG.GasFlow,               FnStartGasFlow, PMState.GasFlowing);
            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);

            // Heat substrate
            Transition(PMState.Idle, MSG.Heat,                        FnHeat, PMState.Heating);
            Transition(PMState.Heating, FSM_MSG.TIMER,                FnHeatTimeout, PMState.Idle);
            Transition(PMState.Heating, MSG.Abort,                    FnAbortHeating, PMState.Idle);

            //Launch Pump 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);

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

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

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

            //Leak check sequence
            Transition(PMState.Idle, MSG.LeakCheck,                   FnStartLeakCheck, PMState.LeakCheck);
            Transition(PMState.Idle, MSG.DeleteLeakCheck,             FnDeleteLeakCheck, PMState.Idle);
            Transition(PMState.LeakCheck, FSM_MSG.TIMER,              FnLeakCheckTimeout, PMState.Idle);
            Transition(PMState.LeakCheck, MSG.Abort,                  FnAbortLeakCheck, 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);

            //MFC verification
            Transition(PMState.Idle, MSG.AllMFCVerification, FnStartAllMFCVerification, PMState.AllMFCVerification);
            Transition(PMState.AllMFCVerification, FSM_MSG.TIMER, FnAllMFCVerificationTimeout, PMState.Idle);
            Transition(PMState.AllMFCVerification, MSG.Abort, FnAbortAllMFCVerification, PMState.Idle);

            // Transfer
            Transition(PMState.Idle, MSG.PrepareTransfer,             FnStartPrepareTransfer, PMState.PrepareTransfer);
            Transition(PMState.PrepareTransfer, FSM_MSG.TIMER,        FnPreTransferTimeout, PMState.Idle);
            Transition(PMState.PrepareTransfer, MSG.Abort,            FnAbortTask, PMState.Idle);

            Transition(PMState.Idle, MSG.PostTransfer,                FnStartPostTransfer, PMState.PostTransfer);
            Transition(PMState.PostTransfer, FSM_MSG.TIMER,           FnPostTransferTimeout, PMState.Idle);
            Transition(PMState.PostTransfer, MSG.Abort,               FnAbortTask, PMState.Idle);

            //EnterExitTransition<PMState, FSM_MSG>(PMState.TransferHandoff, null, FSM_MSG.NONE, fExitTransfer);
            //Transition(PMState.Idle, MSG.TransferHandoff,             FnStartTransferHandoff, PMState.TransferHandoff);
            //Transition(PMState.TransferHandoff, FSM_MSG.TIMER,        FnHandoffTime, PMState.Idle);
            //Transition(PMState.TransferHandoff, MSG.Abort,            FnAbortTask, PMState.Idle);

            // lift pin
            Transition(PMState.Idle,            MSG.MoveLiftPin,    FnSetLiftpin,           PMState.LiftpinMoving);
            Transition(PMState.Idle,            MSG.WaitLiftpin,    null,                   PMState.LiftpinWaiting);
            Transition(PMState.LiftpinWaiting,  FSM_MSG.TIMER,      FnWaitLiftpinTimeout,   PMState.LiftpinMoving);
            Transition(PMState.LiftpinMoving,   FSM_MSG.TIMER,      FnLiftpinTimeout,       PMState.Idle);

            // OpenSlitDoor
            Transition(PMState.Idle, MSG.OpenSlitDoor, FnOpenSlitDoor, PMState.OpeningSlitDoor);
            Transition(PMState.OpeningSlitDoor, FSM_MSG.TIMER, FnOpenSlitDoorTimeout, PMState.Idle);

            // CloseSlitDoor
            Transition(PMState.Idle, MSG.CloseSlitDoor, FnCloseSlitDoor, PMState.ClosingSlitDoor);
            Transition(PMState.ClosingSlitDoor, FSM_MSG.TIMER, FnCloseSlitDoorTimeout, PMState.Idle);

            // guide pin
            Transition(PMState.Idle, MSG.MoveGuidePin,                FnSetGuidePin, PMState.GuidePinMoving);
            Transition(PMState.GuidePinMoving, FSM_MSG.TIMER,         FnGuidePinTimeout, PMState.Idle);

            // PreClean sequence
            Transition(PMState.Idle, MSG.Clean,                       FnPreClean, PMState.PreClean);
            Transition(PMState.PreClean, FSM_MSG.TIMER,               FnPreCleanTimeout, PMState.LoadProcessRecipe);

            // PreProcess sequence
            Transition(PMState.Idle, MSG.RunRecipe,                   FnProcessLoadRecipe, PMState.LoadProcessRecipe);
            Transition(PMState.LoadProcessRecipe, MSG.PreProcess,     FnStartPreProcess, PMState.PreProcess);
            Transition(PMState.LoadProcessRecipe, MSG.Abort,          null, PMState.Idle);
            Transition(PMState.LoadProcessRecipe, MSG.Error,          null, PMState.Idle);
            Transition(PMState.PreProcess, FSM_MSG.TIMER,             FnPreProcessTimeout, PMState.PreProcess);
            Transition(PMState.PreProcess, MSG.Abort,                 FnAbortPreProcess, PMState.Idle);
            Transition(PMState.PreProcess, MSG.RecipeAbort,           FnAbortPreProcess, PMState.Idle);
            Transition(PMState.PreProcess, MSG.Error,                 FnAbortPreProcess, PMState.Error);

            // Process
            Transition(PMState.PreProcess, MSG.Process,               FnStartProcess, PMState.Processing);
            Transition(PMState.Processing, FSM_MSG.TIMER,             FnProcessTimeout, PMState.Processing);
            Transition(PMState.Processing, MSG.Error,                 FnAbortProcess, PMState.Error);
            Transition(PMState.Processing, MSG.RecipeAbort,           FnAbortProcess, PMState.PostProcess);
            Transition(PMState.Processing, MSG.RecipePause,           FnPauseProcess, PMState.Processing);
            Transition(PMState.Processing, MSG.RecipeResume,          FnResumeRecipe, PMState.Processing);
            Transition(PMState.Processing, MSG.RecipeUpdate,          FnUpdateRecipe, PMState.Processing);
            Transition(PMState.Processing, MSG.RecipeSkipStep,        FnSkipStep, PMState.Processing);
            EnterExitTransition<PMState, FSM_MSG>(PMState.Processing, FnEnterProcess, FSM_MSG.NONE, FnExitProcess);

            //PostProcess sequence
            Transition(PMState.Processing, MSG.PostProcess,           FnStartPostProcess, PMState.PostProcess);
            Transition(PMState.PostProcess, FSM_MSG.TIMER,            FnPostProcessTimeout, PMState.Idle);
            Transition(PMState.PostProcess, MSG.Abort,                FnAbortPostProcess, PMState.Idle);
            Transition(PMState.PostProcess, MSG.RecipeAbort,          FnAbortPostProcess, PMState.Idle);
            Transition(PMState.PostProcess, MSG.Error, FnAbortPostProcess, PMState.Error);

            EnterExitTransition<PMState, FSM_MSG>(PMState.PostProcess, null, FSM_MSG.NONE, fExitPostProcess);

            Running = true;
        }

        protected override bool Init()
        {
            DATA.Subscribe($"{Module}.FsmState",            () => ((PMState)fsm.State).ToString());
            DATA.Subscribe($"{Module}.FsmPrevState",        () => ((PMState)fsm.PrevState).ToString());
            DATA.Subscribe($"{Module}.FsmLastMessage", GetFsmLastMessage);
            DATA.Subscribe($"{Module}.PMState",             () => fsm.State);
            DATA.Subscribe($"{Module}.IsAutoMode",          () => IsAutoMode);
            DATA.Subscribe($"{Module}.IsOnline",            () => _isOnline);
            DATA.Subscribe($"{Module}.IsAlarm",            () => _isAlarm);
            DATA.Subscribe($"{Module}.ProcessStatus",       () => _processStatus);
            DATA.Subscribe($"{Module}.PumpTime",            () => PumpTime);
            DATA.Subscribe($"{Module}.TCTime",              () => TCTime);
            DATA.Subscribe($"{Module}.StepNo",              () => StepNo);
            DATA.Subscribe($"{Module}.RecipeStepName",      () => RecipeStepName);
            DATA.Subscribe($"{Module}.RecipeName",          () => RecipeName);
            DATA.Subscribe($"{Module}.LeakRate",            () => LeakRate);
            DATA.Subscribe($"{Module}.LeakCheckElapseTime", () => LeakCheckElapseTime);
            DATA.Subscribe($"{Module}.SmallWafer",          () => _smallWafer);
            DATA.Subscribe($"{Module}.BigWafer",            () => _bigWafer);
            DATA.Subscribe($"{Module}.MidWafer",            () => _midWafer);
            DATA.Subscribe($"{Module}.RecipeSteps",         () => RecipeSteps);
            DATA.Subscribe($"{Module}.RecipeProcessTime",   () => RecipeElapsedTime);
            DATA.Subscribe($"{Module}.RecipeTotalElapsedSeconds", () => RecipeTotalElapsedSeconds);
            DATA.Subscribe($"{Module}.RecipeStepTimeElapsed", () => (_processRoutine.CurStepElpasedTime / 1000).ToString("F0"));
            DATA.Subscribe($"{Module}.RecipeStepTimeSetPoint", () => (_processRoutine.CurStepTotalTime / 1000).ToString("F0"));



            OP.Subscribe($"{Module}.{RtOperation.GasFlow}",         (cmd, args) => CheckToPostMessage((int)MSG.GasFlow, args));
            OP.Subscribe($"{Module}.{RtOperation.RfPower}",         (cmd, args) => CheckToPostMessage((int)MSG.RfPower, args));
            OP.Subscribe($"{Module}.{RtOperation.MoveLiftPin}",     (cmd, args) => CheckToPostMessage((int)MSG.MoveLiftPin, args[0], 0, true));
            OP.Subscribe($"{Module}.{RtOperation.MoveGuidePin}",    (cmd, args) => CheckToPostMessage((int)MSG.MoveGuidePin, args[0], args[1]));
            OP.Subscribe($"{Module}.Home",                          (cmd, args) => CheckToPostMessage((int)MSG.Home));
            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}.PrepareTransfer",               (cmd, args) => CheckToPostMessage((int)MSG.PrepareTransfer, args[0]));
            OP.Subscribe($"{Module}.TransferHandoff",               (cmd, args) => CheckToPostMessage((int)MSG.TransferHandoff, args[0]));
            OP.Subscribe($"{Module}.{RtOperation.Pump}",            (cmd, args) => CheckToPostMessage((int)MSG.Pump));
            OP.Subscribe($"{Module}.{RtOperation.StartPump}",       (cmd, args) => CheckToPostMessage((int)MSG.LaunchPump));
            OP.Subscribe($"{Module}.{RtOperation.Vent}",            (cmd, args) => CheckToPostMessage((int)MSG.Vent));
            OP.Subscribe($"{Module}.{RtOperation.Purge}",           (cmd, args) => CheckToPostMessage((int)MSG.CyclePurge));
            OP.Subscribe($"{Module}.{RtOperation.LeakCheck}",       (cmd, args) => CheckToPostMessage((int)MSG.LeakCheck, args));
            OP.Subscribe($"{Module}.{RtOperation.DeleteLeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.DeleteLeakCheck, args));
            OP.Subscribe($"{Module}.{RtOperation.LockLid}",         (cmd, args) => CheckToPostMessage((int)MSG.LockLid, true));
            OP.Subscribe($"{Module}.{RtOperation.UnlockLid}",       (cmd, args) => CheckToPostMessage((int)MSG.LockLid, false));
            OP.Subscribe($"{Module}.{RtOperation.RunRecipe}",       (cmd, args) => CheckToPostMessage((int)MSG.RunRecipe, (string)args[0], "", true));
            OP.Subscribe($"{Module}.{RtOperation.SkipCurrentStep}", (cmd, args) => CheckToPostMessage((int)MSG.RecipeSkipStep));
            OP.Subscribe($"{Module}.{RtOperation.AbortRecipe}",     (cmd, args) => CheckToPostMessage((int)MSG.RecipeAbort));
            OP.Subscribe($"{Module}.{RtOperation.PmAuto}",          (cmd, args) => CheckToPostMessage((int)MSG.AutoMode));
            OP.Subscribe($"{Module}.{RtOperation.PmManual}",        (cmd, args) => CheckToPostMessage((int)MSG.ManualMode));
            OP.Subscribe($"{Module}.{RtOperation.PmOnline}",        (cmd, args) => CheckToPostMessage((int)MSG.Online));
            OP.Subscribe($"{Module}.{RtOperation.PmOffline}",       (cmd, args) => CheckToPostMessage((int)MSG.Offline));
            OP.Subscribe($"{Module}.{RtOperation.Heat}",            (cmd, args) => CheckToPostMessage((int)MSG.Heat, args[0]));
            OP.Subscribe($"{Module}.{RtOperation.MFCVerification}", (cmd, args) => CheckToPostMessage((int)MSG.MFCVerification, args));
            OP.Subscribe($"{Module}.{RtOperation.AllMFCVerification}", (cmd, args) => CheckToPostMessage((int)MSG.AllMFCVerification, args));

            StatsDataManager.Instance.Subscribe($"{Module}.ProcessedWaferCount", "Processed Wafer Count", 0);
            StatsDataManager.Instance.Subscribe($"{Module}.RfOnTime", "Rf On Time");
            if (_enableBias)
                StatsDataManager.Instance.Subscribe($"{Module}.BiasRfOnTime", "Bias  Rf On Time");
            StatsDataManager.Instance.Subscribe($"{Module}.PumpOnTime", "Pump On Time");

            _statProcessedWafer = StatsDataManager.Instance.GetItem($"{Module}.ProcessedWaferCount");
            _statRfOnTime = StatsDataManager.Instance.GetItemRFAndPump($"{Module}.RfOnTime");
            if (_enableBias)
                _statBiasRfOnTime = StatsDataManager.Instance.GetItemRFAndPump($"{Module}.BiasRfOnTime");
            _statPumpOnTime = StatsDataManager.Instance.GetItemRFAndPump($"{Module}.PumpOnTime");


            DATA.Subscribe($"{Module}.ProcessedWaferCount", () => _statProcessedWafer.Value);
            DATA.Subscribe($"{Module}.RfOnTime", () => _statRfOnTime.fromLastPM);
            if (_enableBias)
                DATA.Subscribe($"{Module}.BiasRfOnTime", () => _statBiasRfOnTime.fromLastPM);
            DATA.Subscribe($"{Module}.PumpOnTime", () => _statPumpOnTime.fromLastPM);

            return true;
        }

        // Methods
        // 
        private bool CheckToPostMessage(int msg, params object[] args)
        {
            if (!fsm.FindTransition(fsm.State, msg))
            {
                EV.PostWarningLog(Module.ToString(), $"{Module} is in { (PMState)fsm.State} state，can not do {(MSG)msg}");
                return false;
            }

            fsm.PostMsg(msg, args);

            return true;
        }

        private bool FnAbortTask(object[] param)
        {
            //_task.Abort();
            return true;
        }

        private bool FnSetAuto(object[] param)
        {
            this._AutoMode = AutoFlag.Auto;
            return true;
        }

        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 FnSetOnline(object[] param)
        {
            if (!IsAutoMode)
            {
                EV.PostWarningLog(Module.ToString(), $"{Module} in manual mode，can not set 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;
        }

        #region Gas&RF

        private bool FnStartGasFlow(object[] objs)
        {
            Result ret = _gasFlowRoutine.Start(objs);

            if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                return false;  //do noting
            }
            return true;
        }

        private bool FnGasFlowTimeout(object[] objs)
        {
            Result ret = _gasFlowRoutine.Monitor();
            if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                PostMsg(MSG.Abort);
                return true;
            }
            return false;
        }

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

        private bool FnStopGasFlow(object[] objs)
        {
            _gasFlowRoutine.StopFlow2();
            return true;
        }

        private bool FnStartRfPower(object[] objs)
        {
            _rfStartTime = DateTime.Now;
            Result ret = _rfPowerRoutine.Start(objs);

            if (ret == Result.DONE)
            {
                return false;
            }

            if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                return false;  //do noting
            }
            return true;
        }

        private bool FnRfPowerTimeout(object[] objs)
        {
            Result ret = _rfPowerRoutine.Monitor();
            if (ret == Result.DONE)
                return true;
            else if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                //do nothing  
                return true;
            }
            return false;
            ;
        }

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

        private bool FnHeat(object[] objs)
        {
            _tcStartTime = DateTime.Now;
            return _temperatureControlRoutine.Start(objs) == Result.RUN;
        }

        private bool FnHeatTimeout(object[] param)
        {
            Result ret = _temperatureControlRoutine.Monitor();
            if (ret == Result.DONE)
            {
                return true;
            }
            if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                //do nothing
                return true;
            }
            return false;
        }

        private bool FnAbortHeating(object[] param)
        {
            _temperatureControlRoutine.Abort();
            return true;
        }

        #endregion Gas&RF

        #region Subroutine

        private bool FnStartLeakCheck(object[] param)
        {
            _leakCheckStartTime = DateTime.Now;
            return _leakCheckRoutine.Start(param) == Result.RUN;
        }

        private bool FnLeakCheckTimeout(object[] param)
        {
            Result res = _leakCheckRoutine.Monitor();
            return res == Result.DONE || res == Result.FAIL;
        }

        private bool FnDeleteLeakCheck(object[] param)
        {
            _leakCheckRoutine.DeleteLeadCheck(param);
            return true;
        }

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

        private bool FnStartMFCVerification(object[] param)
        {
            _mfcVerification.Init((string)param[0], (float)param[1], (int)param[2]);
            return _mfcVerification.Start(param) == Result.RUN;
        }

        private bool FnMFCVerificationTimeout(object[] param)
        {
            Result res = _mfcVerification.Monitor();
            return res == Result.DONE || res == Result.FAIL;
        }

        private bool FnAbortMFCVerification(object[] param)
        {
            _mfcVerification.Abort();
            return true;
        }

        private bool FnStartAllMFCVerification(object[] param)
        {
            _allMfcVerification.Init((string[])param[0], (bool[])param[1]);
            return _allMfcVerification.Start(param) == Result.RUN;
        }

        private bool FnAllMFCVerificationTimeout(object[] param)
        {
            Result res = _allMfcVerification.Monitor();
            return res == Result.DONE || res == Result.FAIL;
        }

        private bool FnAbortAllMFCVerification(object[] param)
        {
            _allMfcVerification.Abort();
            return true;
        }
        private bool FnStartVent(object[] param)
        {
            Result ret = _ventRoutine.Start();
            if (ret == Result.DONE)
            {
                return false;
            }
            else if (ret == Result.FAIL)
            {
                return false;  //do noting
            }
            return true;
        }

        private bool FnVentTimeout(object[] param)
        {
            Result ret = _ventRoutine.Monitor();
            if (ret == Result.DONE)
            {
                return true;
            }
            if (ret == Result.FAIL)
            {
                //do nothing
                return true;
            }
            return false;
        }

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

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

        private bool FnLaunchPump(object[] param)
        {
            _pumpStartTime = DateTime.Now;
            return _startPumpRoutine.Start() == Result.RUN;
        }

        private bool FnLaunchPumpTimeout(object[] param)
        {
            Result ret = _startPumpRoutine.Monitor();
            if (ret == Result.DONE)
            {
                return true;
            }
            if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                PostMsg(MSG.Abort);
                return false;
            }
            return false;
        }

        private bool FnAbortStartPumping(object[] param)
        {
            _startPumpRoutine.Abort();
            return true;
        }

        private bool FnStartPumpDown(object[] param)
        {
            _pumpStartTime = DateTime.Now;
            return _pumpRoutine.Start() == Result.RUN;
        }

        private bool FnPumpDownTimeout(object[] param)
        {
            Result ret = _pumpRoutine.Monitor();
            if (ret == Result.DONE)
            {
                return true;
            }
            if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                //do nothing
                return true;
            }
            return false;
        }

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

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

        private bool FnStartPurge(object[] param)
        {
            return _cyclePurgeRoutine.Start(param) == Result.RUN;
        }

        private bool FnPurgeTimeout(object[] param)
        {
            Result ret = _cyclePurgeRoutine.Monitor();
            if (ret == Result.DONE)
            {
                return true;
            }
            else if (ret == Result.FAIL || ret == Result.TIMEOUT)
            {
                return true;
            }
            return false;
        }

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

        #endregion Subroutine

        #region Transfer
        private bool FnStartPrepareTransfer(object[] param)
        {
            if (param.Length > 2)
                _prepareTrans.Init((EnumTransferType)Enum.Parse(typeof(EnumTransferType), (string)param[0]), (float)param[1], (WaferSize)param[2]);
            else if (param.Length > 1)
                _prepareTrans.Init((EnumTransferType)Enum.Parse(typeof(EnumTransferType), (string)param[0]), (float)param[1]);
            else
                _prepareTrans.Init((EnumTransferType)Enum.Parse(typeof(EnumTransferType), (string)param[0]), 0);
            Result ret = _prepareTrans.Start();
            if (ret == Result.FAIL || ret == Result.DONE)
                return false;
            return ret == Result.RUN;
        }

        private bool FnPreTransferTimeout(object[] param)
        {
            Result ret = _prepareTrans.Monitor();
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.Abort);
                return false;
            }

            return ret == Result.DONE;
        }

        private bool FnStartPostTransfer(object[] param)
        {
            Result ret = _postTrans.Start();
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == Result.RUN;
        }

        private bool FnPostTransferTimeout(object[] param)
        {
            Result ret = _postTrans.Monitor();
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.Abort);
                return false;
            }

            return ret == Result.DONE;
        }

        private bool FnSetLiftpin(object[] param)
        {
            MovementPosition pos = (MovementPosition)param[0];
            _ActivatedActionID = (ushort)param[1];
            bool isPick = (bool)param[2];
            bool isDelay = (bool)param[3];

            _goalLiftPin = pos;
            _liftpinDelayTime = SC.GetValue<int>(isPick ? $"{Module}.PinDownDelayTimePick" : $"{Module}.PinDownDelayTimePlace") * 1000;
            if (_liftpinDelayTime > 0&& isDelay)
            {
                EV.PostInfoLog(Module.ToString(), $"执行 lift pin {pos} Delayrecorder");
                _LifpinSleepTimer.Restart();
                CheckToPostMessage((int)MSG.WaitLiftpin);
                return false;
            }

            _chamber.SetLiftPin(pos, out _);
            EV.PostInfoLog(Module.ToString(), $"执行 lift pin {pos}");
            return true;
        }

        private bool FnWaitLiftpinTimeout(object[] param)
        {
            if (_LifpinSleepTimer.ElapsedMilliseconds > _liftpinDelayTime)
            {
                _chamber.SetLiftPin(_goalLiftPin, out _);
                EV.PostInfoLog(Module.ToString(), $"执行 lift pin {_goalLiftPin}");
                _LifpinSleepTimer.Reset();
                return true;
            }

            return false;
        }

        private bool FnLiftpinTimeout(object[] param)
        {
            if (_chamber.LiftPinPosition == _goalLiftPin)
            {
                EV.PostInfoLog(Module.ToString(), $"lift pin 当前位置 {_chamber.LiftPinPosition}");

                Singleton<RouteManager>.Instance.EFEM.PostMsg(
                    _goalLiftPin == MovementPosition.Up ? EfemEntity.MSG.PMLiftPinUp : EfemEntity.MSG.PMLiftPinDown, _ActivatedActionID);

                _goalLiftPin = MovementPosition.Unknown;
                _ActivatedActionID = 0;
                return true;
            }
            return false;
        }

        private bool FnOpenSlitDoor(object[] param)
        {
            _ActivatedActionID = (ushort)param[0];

            _chamber.SetSlitDoor(true, out _);

            EV.PostInfoLog(Module.ToString(), $"Start opening {Module} slit door");

            return true;
        }

        private bool FnOpenSlitDoorTimeout(object[] param)
        {
            if (_chamber.CheckSlitDoorOpen()  )
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} slit door is opened");

                Singleton<RouteManager>.Instance.EFEM.PostMsg( EfemEntity.MSG.PMSlitDoorOpened, _ActivatedActionID);

                _ActivatedActionID = 0;

                return true;
            }
            return false;
        }

        private bool FnCloseSlitDoor(object[] param)
        {
            _ActivatedActionID = (ushort)param[0];

            _chamber.SetSlitDoor(false, out _);

            EV.PostInfoLog(Module.ToString(), $"Start closing {Module} slit door");

            return true;
        }

        private bool FnCloseSlitDoorTimeout(object[] param)
        {
            if (_chamber.CheckSlitDoorClose())
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} slit door is closed");

                Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.PMSlitDoorClosed, _ActivatedActionID);

                _ActivatedActionID = 0;

                return true;
            }
            return false;
        }
        private bool FnSetGuidePin(object[] param)
        {
            WaferSize ws = (WaferSize)param[0];
            MovementPosition pos = (MovementPosition)param[1];

            _chamber.SetGuidePin(ws, pos);
 
            return true;
        }

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

        private bool FnPreClean(object[] param)
        {
            _cleanRoutine.param = param;
            _chamber.SetSlitDoor(false, out _);
            return true;
        }

        private bool FnPreCleanTimeout(object[] param)
        {
            if (_chamber.IsSlitDoorClosed)
            {
                if (!FnProcessLoadRecipe(_cleanRoutine.param))
                {
                    EV.PostAlarmLog(_chamber.Module.ToString(), "Clean recipe read failed");
                    PostMsg(FSM_MSG.ALARM);
                    return false;
                }
                return true;
            }
            return false;
        }

        #endregion Transfer

        #region Process
        private bool FnProcessLoadRecipe(object[] param)
        {
            _processStatus = "Succeed to load recipe";
            _recipeStartTime = DateTime.Now;
            Result ret = _preProcessRoutine.LoadRecipe(param);
            if (ret == Result.DONE)
            {
                PostMsg(MSG.PreProcess);
            }
            else if (ret == Result.FAIL)
            {
                _processStatus = "Failed to load recipe";
                return false;
            }
            return true;
        }

        private bool FnStartPreProcess(object[] param)
        {
            _pumpStartTime = DateTime.Now;

            //_processStatus = Resources.PMEntity_fStartPreProcess_PreparingRunningRecipe;

            Result ret = _preProcessRoutine.Start(param);
            if (ret == Result.DONE)
            {
                return false;
            }

            if (ret == Result.FAIL || ret == Result.VERIFYFAIL)
            {
                //_processStatus = Resources.PMEntity_fStartPreProcess_PreparingRunningRecipeFailed;
                PostMsg(MSG.Error);
                return false;  //do noting
            }

            WaferManager.Instance.UpdateWaferProcessStatus(this.Module, 0, EnumWaferProcessStatus.InProcess);
            return true;
        }

        private bool FnPreProcessTimeout(object[] param)
        {
            //_processStatus = Resources.PMEntity_fPreProcess_RunRecipePumpingDown;

            Result ret = _preProcessRoutine.Monitor();
            if (ret == Result.DONE)
            {
                PostMsg(MSG.Process,
                    _preProcessRoutine.CurrentRecipeBaseName,
                    _preProcessRoutine.CurrentRecipeRunningName,
                    0,
                    _preProcessRoutine.CurrentLotName,
                    _preProcessRoutine.CurrentRecipeContent,
                    _preProcessRoutine.CurrentRecipeHead,
                    _preProcessRoutine.CurrentRecipeStepList);
                return true;
            }

            if (ret == Result.FAIL)
            {
                //_processStatus = Resources.PMEntity_fPreProcess_RunRecipePumpingDownFailed;
                PostMsg(MSG.Error);
                return true;
            }
            return false; ;
        }

        private bool FnAbortPreProcess(object[] param)
        {
            //_processStatus = Resources.PMEntity_fAbortPreProcess_RunRecipePumpingDownAborted;

            WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.Failed);

            _preProcessRoutine.Abort();
            return true;
        }

        private bool FnStartProcess(object[] param)
        {
            //_processStatus = Resources.PMEntity_fStartProcess_StartRunningRecipe;

            Result ret = _processRoutine.Start(param);
            if (ret == Result.DONE)
            {
                return true;
            }
            else if (ret == Result.FAIL || ret == Result.VERIFYFAIL)
            {
                //_processStatus = Resources.PMEntity_fStartProcess_RunRecipeFailed;
                PostMsg(MSG.Error);
                return true;  //do noting
            }
            return true;
        }

        private bool FnProcessTimeout(object[] param)
        {
            //_processStatus = Resources.PMEntity_fProcess_RunningRecipe;
            Result ret = _processRoutine.Monitor();
            {
                if (ret == Result.DONE)
                {
                    PostMsg(MSG.PostProcess, _processRoutine.CurrentRecipeRunningName, _processRoutine.CurrentRecipeContent);
                    return true;
                }
                else if (ret == Result.FAIL)
                {
                    //_processStatus = Resources.PMEntity_fStartProcess_RunRecipeFailed;
                    PostMsg(MSG.Error);
                    return true;
                }
                return false;
            }
        }

        private bool FnAbortProcess(object[] param)
        {
            //_processStatus = Resources.PMEntity_fAbortProcess_RunningRecipeAborted;
            _processRoutine.AbortRecipe();
            WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.Failed);
            _processRoutine.Abort();
            Result ret = _postProcessRoutine.Start(new object[] { _processRoutine.CurrentRecipeRunningName, _processRoutine.CurrentRecipeContent });
            if (ret == Result.DONE)
            {
                return false;
            }
            else if (ret == Result.FAIL)
            {
                PostMsg(MSG.Error);
                //_processStatus = Resources.PMEntity_fAbortProcess_RunRecipeAborted;
                return false;  //do noting
            }
            return true;
        }

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

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

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

        private bool FnSkipStep(object[] param)
        {
            _processRoutine.SkipCurrentRecipeStep();
            return true;
        }

        private bool FnExitProcess(object[] param)
        {
            //_statProcessedWafer

            StatsDataManager.Instance.Increase(_statProcessedWafer.Name);

            _processRoutine.Exit();

            return true;
        }

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

        private bool FnStartPostProcess(object[] param)
        {
            //_processStatus = Resources.PMEntity_fStartPostProcess_RunRecipePostProcess;

            Result ret = _postProcessRoutine.Start(param);
            if (ret == Result.DONE)
            {
                return false;
            }
            else if (ret == Result.FAIL)
            {
                PostMsg(MSG.Error);
                return false;
            }
            return true;
        }

        private bool FnPostProcessTimeout(object[] param)
        {
            //_processStatus = Resources.PMEntity_fPostProcess_RunRecipeCyclePurge;

            Result ret = _postProcessRoutine.Monitor();
            if (ret == Result.DONE)
            {

                WaferManager.Instance.UpdateWaferProcessStatus(this.Module, 0, EnumWaferProcessStatus.Completed);

                //_processStatus = Resources.PMEntity_fPostProcess_RecipeCompleted;
                return true;
            }
            else if (ret == Result.FAIL)
            {
                //_processStatus = Resources.PMEntity_fPostProcess_RunRecipeCyclePurgeError;
                PostMsg(MSG.Error);
                return true;
            }
            return false;
        }

        private bool FnAbortPostProcess(object[] param)
        {
            //_processStatus = Resources.PMEntity_fAbortPostProcess_RecipeAborted;
            WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.Failed);

            _postProcessRoutine.Abort();
            return true;
        }

        private bool fExitPostProcess(object[] objs)
        {
            _postProcessRoutine.Exit();


            //EV.Notify(EventLotFinished, new SerializableDictionary<string, string>()
            //{
            //    {DVIDName.LotId,  preProcessRoutine.CurrentLotName},
            //    {DVIDName.JobId,  preProcessRoutine.CurrentJobName},
            //    {DVIDName.RecipeId, preProcessRoutine.CurrentRecipeBaseName }
            //});

            return true;
        }

        #endregion PROCESS

        private string GetFsmLastMessage()
        {
            int msg = fsm.LastMsg;
            if (msg >= (int)MSG.Home && msg <= (int)MSG.MaxMsg)
                return ((MSG)msg).ToString();

            if (msg == (int)FSM_MSG.TIMER)
                return "Timer";

            return msg.ToString();
        }

        protected override void Term()
        {
        }

        private bool FnReset(object[] param)
        {
            _isAlarm = false;
            if ((PMState)fsm.State == PMState.Error)
                return true;

            return false;
        }

        public bool Check(int msg, out string reason, object[] objs)
        {
            reason = "";
            return true;
        }

        public bool IsProcessed()
        {
            return IsIdle;
        }

        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)
            {
              WaferSize ws=  WaferManager.Instance.GetWafer(robot, (int)blade).Size;

              string SupportedWaferSize = SC.GetStringValue($"{Module}.SupportedWaferSize");
              if (!SupportedWaferSize.Split(',').Contains(ws.ToString().Replace("WS", "")))
                  return false;

              return _chamber.CheckEnableTransfer(type, ws);
            }

            return false;
        }

        public void Home()
        {
            CheckToPostMessage((int)MSG.Home);
        }

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

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

        private bool FnStartHome(object[] objs)
        {
            Result ret = _home.Start();
            if (ret == Result.FAIL || ret == Result.DONE)
                return false;
            return ret == Result.RUN;
        }

        private bool FnMonitorHome(object[] objs)
        {
            Result ret = _home.Monitor();
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == Result.DONE;
        }

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

        private bool fEnterError(object[] objs)
        {
            //if (IsProcessMode)
            //{

            //    EV.Notify(EventLotFinished, new SerializableDictionary<string, string>()
            //    {
            //        {DVIDName.LotId,  preProcessRoutine.CurrentLotName},
            //        {DVIDName.JobId,  preProcessRoutine.CurrentJobName},
            //        {DVIDName.RecipeId, preProcessRoutine.CurrentRecipeBaseName }
            //    });
            //}

            _chamber.GeneratorPowerOn(false);
            _chamber.GeneratorBiasPowerOn(false);
            _chamber.StopAllGases();
            return true;
        }

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

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

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

            return true;
        }

        private bool fWarning(object[] objs)
        {
            //IsWarning = false;
            return true;
        }

        private bool fAlarm(object[] objs)
        {
            _isAlarm = true;
            if (fsm.State == (int)PMState.Init)
                return false;

            if (fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PreProcess || fsm.State == (int)PMState.PostProcess)
            {
                PostMsg(MSG.Error);
                return false;
            }
            //IsAlarm = true;

            return true;
        }

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

        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, bool withWafer)
        {
            if (CheckToPostMessage((int)MSG.Clean, recipeName, waferID, withWafer))
            {
                return (int)MSG.Clean;
            }
            return (int)FSM_MSG.NONE;
        }

        public int InvokeProcess(string recipeName, string waferID, bool withWafer)
        {
            if (CheckToPostMessage((int)MSG.RunRecipe, recipeName, waferID, withWafer))
                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;
        }



        #region EndPoint

        public bool CheckEndPoint()
        {
            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");

            if (epd == null)
                return false;

            return epd.IsEnd;
        }


        public void StartEndPoint(string config, int index)
        {
            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");

            if (epd == null)
                return;

            epd.StepStart(config, index);

        }

        public void StopEndPoint()
        {
            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");

            if (epd == null)
                return;

            epd.StepStop();

        }

        public void EndPointRecipeStop()
        {
            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");

            if (epd == null)
                return;

            epd.RecipeStop();

        }

        public void EndPointRecipeStart(string recipeName)
        {
            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");

            if (epd == null)
                return;

            epd.RecipeStart(recipeName);

        }


        #endregion
    }
}