PunkHPX8/PunkHPX8_RT/Modules/VpwCell/VpwCellEntity.cs

using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.RecipeCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using CyberX12_RT.Modules.VpwCell;
using MECF.Framework.Common.Alarm;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Persistent.Temperature;
using MECF.Framework.Common.Persistent.VpwCell;
using MECF.Framework.Common.Persistent.VpwMain;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.LinMot;
using PunkHPX8_RT.Devices.VpwCell;
using PunkHPX8_RT.Modules.VpwCell;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Modules.VpwMain
{
    public class VpwCellEntity : Entity, IEntity, IModuleEntity
    {
        #region 常量
        private const string STRATUS = "Stratus";
        private const string AUTO = "Auto";
        private const string MANUAL = "Manual";
        private const string DISABLED = "Disabled";
        private const string ENGINEERING = "Engineering";
        private const string PRODUCTION = "Production";
        #endregion

        #region 内部变量
        /// <summary>
        /// 持久化数值
        /// </summary>
        private VpwCellPersistentValue _persistentValue;

        /// <summary>
        /// VPW cell集合
        /// </summary>
        private List<VpwCellDevice> _vpwCellDevices = new List<VpwCellDevice>();
        /// <summary>
        /// Home Routine
        /// </summary>
        private VPWHomeRoutine _homeRoutine;
        /// <summary>
        /// Prepare
        /// </summary>
        private VpwPrepareRoutine _prepareRoutine;
        /// <summary>
        /// recipe routine
        /// </summary>
        private VpwRecipeRoutine _recipeRoutine;
        /// <summary>
        /// Chamber down
        /// </summary>
        private VpwChamberDownRoutine _chamberDownRoutine;
        /// <summary>
        /// Chamber Up
        /// </summary>
        private VpwChamberUpRoutine _chamberUpRoutine;
        /// <summary>
        /// 循环routine
        /// </summary>
        private VpwCycleManualProcessRecipeRoutine _cycleManualProcessRoutine;
        /// <summary>
        /// recipe完成次数
        /// </summary>
        private int _achievedCycle;
        /// <summary>
        /// Cycle次数
        /// </summary>
        private int _cycle = 0;
        /// <summary>
        /// 是否Retry
        /// </summary>
        private bool _isRetry = false;
        /// <summary>
        /// recipe时长
        /// </summary>
        private int _recipeTime;
        /// <summary>
        /// 当前Recipe
        /// </summary>
        private VpwRecipe _currentRecipe;
        /// <summary>
        /// run recipe start time
        /// </summary>
        private DateTime _runRecipeStartTime;
        /// <summary>
        ///  run recipe complete time
        /// </summary>
        private DateTime _runRecipeCompleteTime;
        /// <summary>
        /// 工艺当前执行小步骤
        /// </summary>
        private string _currentStepState = "Init";
        /// <summary>
        /// 工艺当前执行大步骤
        /// </summary>
        private string _currentStatus = "Init";
        #endregion

        #region 属性
        public ModuleName Module { get; private set; }
        /// <summary>
        /// 是否Init
        /// </summary>
        public bool IsInit
        {
            get { return fsm.State == (int)VPWCellState.Init; }
        }
        /// <summary>
        /// 是否Idle
        /// </summary>
        public bool IsIdle
        {
            get
            {
                return fsm.State == (int)VPWCellState.Idle;
            }
        }
        /// <summary>
        /// 是否错误
        /// </summary>
        public bool IsError
        {
            get { return fsm.State == (int)VPWCellState.Error; }
        }
        /// <summary>
        /// 正在忙碌
        /// </summary>
        public bool IsBusy
        {
            get { return fsm.State == (int)VPWCellState.Initializing; }
        }

        /// <summary>
        /// 是否禁用
        /// </summary>
        public bool IsDisable { get { return _persistentValue == null || _persistentValue.OperatingMode == DISABLED; } }

        /// <summary>
        /// 自动模式
        /// </summary>
        public bool IsAuto { get { return _persistentValue != null && _persistentValue.OperatingMode == AUTO; } }
        /// <summary>
        /// 自动模式
        /// </summary>
        public bool IsManual { get { return _persistentValue != null && _persistentValue.OperatingMode == MANUAL; } }
        /// <summary>
        /// 是否为工程模式
        /// </summary>
        public bool IsEngineering { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == ENGINEERING; } }
        /// <summary>
        /// 是否为产品模式
        /// </summary>
        public bool IsProduction { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == PRODUCTION; } }
        /// <summary>
        /// recipe时长
        /// </summary>
        public int RecipeTime { get { return _recipeTime; } }
        /// <summary>
        /// 当前Vpw设置的WaferSize
        /// </summary>
        public int VpwWaferSize { get { return _persistentValue.VpwCellWaferSize; } }
        /// <summary>
        /// Wafer信息
        /// </summary>
        public WaferInfo WaferInfo { get { return WaferManager.Instance.GetWafer(Module, 0); } }

        /// <summary>
        /// 当前状态机状态
        /// </summary>
        public int State { get { return fsm.State; } }

        /// <summary>
        /// 当前执行步骤
        /// </summary>
        public string CurrentStepState { get { return _currentStepState; } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public VpwCellEntity(ModuleName module)
        {
            Module = module;
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        protected override bool Init()
        {
            InitialFsm();
            InitializeParameter();
            InitializeRoutine();
            InitializeDATA();
            InitializeOperation();
            return true;
        }

        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            WaferManager.Instance.SubscribeLocation(Module, 1);
            
            _persistentValue = VpwCellPersistentManager.Instance.GetPersistentValue(Module.ToString());
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_VPW, Module.ToString(), "Persistent Value Object is not exist");
            }
            _vpwCellDevices.Clear();
            VpwMainItem vpwMainItem = VpwMainItemManager.Instance.GetItem(ModuleName.VPWMain1.ToString());
            if (vpwMainItem == null || vpwMainItem.VpwCells == null)
            {
                return;
            }
            foreach (var item in vpwMainItem.VpwCells)
            {
                VpwCellDevice cellDevice = DEVICE.GetDevice<VpwCellDevice>(item.ModuleName);
                _vpwCellDevices.Add(cellDevice);
            }
        }
        /// <summary>
        /// 初始化状态机
        /// </summary>
        private void InitialFsm()
        {
            fsm = new StateMachine<VpwCellEntity>(Module.ToString(), (int)VPWCellState.Init, 100);
            fsm.EnableRepeatedMsg(true);
            AnyStateTransition(VPWCellMsg.Error, NullFunc, VPWCellState.Error);
            AnyStateTransition(VPWCellMsg.MainInitialize, NullFunc, VPWCellState.MainInitializing);
            //Initialized
            Transition(VPWCellState.Error, VPWCellMsg.Initialize, InitializeAll, VPWCellState.Initializing);
            Transition(VPWCellState.Aborting, VPWCellMsg.Initialize, InitializeAll, VPWCellState.Initializing);
            Transition(VPWCellState.Init, VPWCellMsg.Initialize, InitializeAll, VPWCellState.Initializing);
            Transition(VPWCellState.Idle, VPWCellMsg.Initialize, InitializeAll, VPWCellState.Initializing);
            Transition(VPWCellState.Initializing, FSM_MSG.TIMER, InitializeAllMonitor, VPWCellState.Idle);
            Transition(VPWCellState.Error, VPWCellMsg.EnterIdle, NullFunc, VPWCellState.Idle);
            Transition(VPWCellState.MainInitializing, VPWCellMsg.EnterIdle, NullFunc, VPWCellState.Idle);
            Transition(VPWCellState.Init, VPWCellMsg.EnterIdle, NullFunc, VPWCellState.Idle);
            Transition(VPWCellState.Idle, VPWCellMsg.EnterIdle, NullFunc, VPWCellState.Idle);
            //Enter Init
            Transition(VPWCellState.Idle, VPWCellMsg.Init, NullFunc, VPWCellState.Init);
            //Cycle Manual Process
            Transition(VPWCellState.Idle, VPWCellMsg.CycleProcessRecipe, CycleManualProcess, VPWCellState.CycleManualProcessing);
            Transition(VPWCellState.CycleManualProcessing, FSM_MSG.TIMER, CycleManualMonitor, VPWCellState.Idle);
            Transition(VPWCellState.CycleManualProcessing, VPWCellMsg.Abort, RunRecipeAbort, VPWCellState.Aborting);
            //Prepare
            Transition(VPWCellState.Idle, VPWCellMsg.Prepare, Prepare, VPWCellState.Preparing);
            Transition(VPWCellState.Preparing, FSM_MSG.TIMER, PrepareMonitor, VPWCellState.WaitForRunRecipe);
            Transition(VPWCellState.WaitForRunRecipe, VPWCellMsg.RunRecipe, RunRecipe, VPWCellState.RunReciping);
            Transition(VPWCellState.RunReciping, FSM_MSG.TIMER, RunRecipeMonitor, VPWCellState.Idle);
            //ChamberUp
            Transition(VPWCellState.Idle, VPWCellMsg.ChamberUp, ChamberUp, VPWCellState.ChamberUping);
            Transition(VPWCellState.ChamberUping, FSM_MSG.TIMER, ChamberUpMonitor, VPWCellState.Idle);
            //ChamberDown
            Transition(VPWCellState.Idle, VPWCellMsg.ChamberDown, ChamberDown, VPWCellState.ChamberDowning);
            Transition(VPWCellState.ChamberDowning, FSM_MSG.TIMER, ChamberDownMonitor, VPWCellState.Idle);
            //Retry
            Transition(VPWCellState.Error, VPWCellMsg.Retry, NullFunc, VPWCellState.Retrying);
            Transition(VPWCellState.Retrying, FSM_MSG.TIMER, VpwCellRetry, VPWCellState.Retrying);
            Transition(VPWCellState.Retrying, VPWCellMsg.Prepare, RetryPrepare, VPWCellState.Preparing);
            Transition(VPWCellState.Retrying, VPWCellMsg.RunRecipe, RetryRunRecipe, VPWCellState.RunReciping);


            EnumLoop<VPWCellState>.ForEach((item) => { fsm.MapState((int)item, item.ToString()); });

            EnumLoop<VPWCellMsg>.ForEach((item) => { fsm.MapMessage((int)item, item.ToString()); });
        }
        /// <summary>
        /// 初始化数据
        /// </summary>
        private void InitializeDATA()
        {
            InitializeSVID();
            DATA.Subscribe($"{Module}.FsmState", () => ((VPWCellState)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsIdle", () => IsIdle, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsInit", () => IsInit, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsDisable", () => IsDisable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsBusy", () => IsBusy, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsError", () => IsError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.AchievedCycle", () => _achievedCycle, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化SVID
        /// </summary>
        private void InitializeSVID()
        {

            DATA.Subscribe($"{Module}.OperatingMode", () => _persistentValue != null ? _persistentValue.OperatingMode : "None", SubscriptionAttribute.FLAG.IgnoreSaveDB);

        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _homeRoutine = new VPWHomeRoutine(Module.ToString());
            _prepareRoutine=new VpwPrepareRoutine(Module.ToString());
            _recipeRoutine=new VpwRecipeRoutine(Module.ToString());
            _chamberDownRoutine=new VpwChamberDownRoutine(Module.ToString());
            _chamberUpRoutine=new VpwChamberUpRoutine(Module.ToString());   
            _cycleManualProcessRoutine = new VpwCycleManualProcessRecipeRoutine(Module.ToString());
        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.InitializeAll", (cmd, args) => { return CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.ERR_VPW, Module.ToString(), (int)VPWCellMsg.Initialize); });
            OP.Subscribe($"{Module}.Prepare", (cmd, args) => { return CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.ERR_VPW, Module.ToString(), (int)VPWCellMsg.Prepare); });
            OP.Subscribe($"{Module}.Abort", (cmd, args) => { return CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.ERR_VPW, Module.ToString(), (int)VPWCellMsg.Abort); });
            OP.Subscribe($"{Module}.CycleManualProcessRecipe", (cmd, args) =>
            {
                VpwRecipe recipe = RecipeFileManager.Instance.LoadGenericityRecipe<VpwRecipe>(args[0].ToString());
                if (recipe == null)
                {
                    LOG.WriteLog(eEvent.ERR_VPW, Module.ToString(), $"{args[0]} recipe is null");
                    return false;
                }
                object[] objects = new object[args.Length];
                objects[0] = recipe;
                for (int i = 1; i < args.Length; i++)
                {
                    objects[i] = args[i];
                }
                return CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.ERR_PREWET, Module.ToString(), (int)VPWCellMsg.CycleProcessRecipe, objects);
            });
        }

        #region InitializeAll
        /// <summary>
        /// Initialize
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool InitializeAll(object[] param)
        {
            if (_vpwCellDevices == null || _vpwCellDevices.Count == 0)
            {
                LOG.WriteLog(eEvent.ERR_VPW, Module.ToString(), "cell device is empty");
                return false;
            }
            foreach (var device in _vpwCellDevices)
            {
                VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(device.Module);
                if (vpwCellEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_VPW, Module.ToString(), $"cell device {device.Module} is busy,cannot initialize");
                    return false;
                }
            }
            VpwMainEntity vpwMainEntity = Singleton<RouteManager>.Instance.GetModule<VpwMainEntity>(ModuleName.VPWMain1.ToString());
            if (vpwMainEntity!=null&&vpwMainEntity.IsBusy)
            {
                LOG.WriteLog(eEvent.ERR_VPW, Module.ToString(), $"VPWMain is busy,cannot initialize");
                return false;
            }
            return _homeRoutine.Start(_vpwCellDevices) == RState.Running;
        }
        /// <summary>
        /// Initialize 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool InitializeAllMonitor(object[] param)
        {
            RState ret = _homeRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(VPWCellMsg.Error);
                return false;
            }

            return ret == RState.End;
        }
        #endregion

        #region Prepare
        /// <summary>
        /// Prepare
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool Prepare(object[] param)
        {
            VpwRecipe recipe = param[0] as VpwRecipe;
            return _prepareRoutine.Start(recipe) == RState.Running;
        }
        /// <summary>
        /// Prepare 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool PrepareMonitor(object[] param)
        {
            RState ret = _prepareRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                AlarmList alarmList = new AlarmList(Module.ToString(), ((VPWCellState)fsm.State).ToString(), (int)VPWCellMsg.Prepare,
                        _prepareRoutine.ErrorMsg, _prepareRoutine.ErrorStep, (int)AlarmType.Error);
                AlarmListManager.Instance.AddAlarm(alarmList);
                PostMsg(VPWCellMsg.Error);
                _currentStepState = "";
                return false;
            }

            _currentStepState = _prepareRoutine.CurrentStep;
            bool result= ret == RState.End;
            if (result)
            {
                _currentStepState = "";
            }
            return result;
        }

        /// <summary>
        /// Retry Prepare
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool RetryPrepare(object[] param)
        {
            int stepIndex = (int)param[0];
            bool result = _prepareRoutine.Retry(stepIndex) == RState.Running;
            return result;
        }
        #endregion

        #region Run Recipe
        /// <summary>
        /// run recipe
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool RunRecipe(object[] param)
        {
            VpwRecipe recipe = param[0] as VpwRecipe;
            return _recipeRoutine.Start(recipe) == RState.Running;
        }
        /// <summary>
        /// Prepare 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool RunRecipeMonitor(object[] param)
        {
            RState ret = _recipeRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                AlarmList alarmList = new AlarmList(Module.ToString(), ((VPWCellState)fsm.State).ToString(), (int)VPWCellMsg.RunRecipe,
                        _recipeRoutine.ErrorMsg, _recipeRoutine.ErrorStep, (int)AlarmType.Error);
                AlarmListManager.Instance.AddAlarm(alarmList);
                PostMsg(VPWCellMsg.Error);
                _currentStepState = "";
                return false;
            }

            _currentStepState = _prepareRoutine.CurrentStep;
            bool result= ret == RState.End;
            if (result)
            {
                _currentStepState = "";
            }
            return result;
        }

        /// <summary>
        /// Retry RunRecipe
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool RetryRunRecipe(object[] param)
        {
            int stepIndex = (int)param[0];
            bool result = _recipeRoutine.Retry(stepIndex) == RState.Running;
            return result;
        }
        #endregion

        #region cycle manual process
        private bool CycleManualProcess(object[] param)
        {
            VpwRecipe recipe = param[0] as VpwRecipe;
            _cycle = (int)param[1];

            bool result = _cycleManualProcessRoutine.Start(param) == RState.Running;
            if (result)
            {
                _isRetry = false;
                if (CellItemRecipeTimeManager.Instance.ContainRecipe(recipe.Ppid))
                {
                    _recipeTime = _cycle * CellItemRecipeTimeManager.Instance.GetRecipeTotalTime(recipe.Ppid);
                }
                else
                {
                    _recipeTime = 0;
                }
                _currentRecipe = recipe;
                _runRecipeStartTime = DateTime.Now;
            }
            return result;
        }

        private bool CycleManualMonitor(object[] param)
        {
            RState state = _cycleManualProcessRoutine.Monitor();
            _currentStatus = _cycleManualProcessRoutine.CurrentStatus;
            _currentStepState = _cycleManualProcessRoutine.CurrentStateMachine;
            if (state == RState.Failed || state == RState.Timeout)
            {
                PostMsg(VPWCellMsg.Error);
                _currentStepState = "Error";
                _currentStatus = "Error";

                _runRecipeCompleteTime = DateTime.Now;
                _cycleManualProcessRoutine.VpwLotTrackHeaderDatas.ProcessTime = (_runRecipeCompleteTime - _runRecipeStartTime).TotalSeconds.ToString("F2");
                //导出lotTrack数据
                VpwLotTrackUtil.ExportVpwLotTrack(Module.ToString(), _cycleManualProcessRoutine.VpwLotTrackDatas,
                    _cycleManualProcessRoutine.VpwLotTrackHeaderDatas, IsAuto, _isRetry);                
                return false;
            }
            _achievedCycle = _cycleManualProcessRoutine.GetAchievedCycle();
            bool result = state == RState.End;
            if (result)
            {
                double elapsedMilliseconds = _cycleManualProcessRoutine.ElapsedMilliseconds;
                int recipeTime = (int)Math.Floor(elapsedMilliseconds / _cycle / 1000);
                CellItemRecipeTimeManager.Instance.UpdateRecipeTime(_currentRecipe.Ppid, recipeTime);
                _runRecipeCompleteTime = DateTime.Now;
                _cycleManualProcessRoutine.VpwLotTrackHeaderDatas.ProcessTime = (_runRecipeCompleteTime - _runRecipeStartTime).TotalSeconds.ToString("F2");
                //导出lotTrack数据
                VpwLotTrackUtil.ExportVpwLotTrack(Module.ToString(), _cycleManualProcessRoutine.VpwLotTrackDatas,
                    _cycleManualProcessRoutine.VpwLotTrackHeaderDatas, IsAuto, _isRetry);
            }
            return result;
        }
        private bool RunRecipeAbort(object[] param)
        {
            _cycleManualProcessRoutine.Abort();

            VpwMainEntity vpwMainEntity = Singleton<RouteManager>.Instance.GetModule<VpwMainEntity>("VPWMain1");
            if (vpwMainEntity != null) 
            {
                //把main的状态置为暂停
                vpwMainEntity.PostMsg(VPWMainMsg.Abort);
            }
           
            //记录LotTrack
            _runRecipeCompleteTime = DateTime.Now;
            _cycleManualProcessRoutine.VpwLotTrackHeaderDatas.ProcessTime = (_runRecipeCompleteTime - _runRecipeStartTime).TotalSeconds.ToString("F2");
            VpwLotTrackUtil.ExportVpwLotTrack(Module.ToString(), _cycleManualProcessRoutine.VpwLotTrackDatas,
                _cycleManualProcessRoutine.VpwLotTrackHeaderDatas, IsAuto, _isRetry);
            return true;
        }
        #endregion

        #region VpwCell Retry
        /// <summary>
        /// VpwCell
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool VpwCellRetry(object[] param)
        {
            AlarmList alarmList = AlarmListManager.Instance.GetAlarmListByModule(Module.ToString());
            if (alarmList != null)
            {
                CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.WARN_VPW, Module.ToString(), alarmList.ModuleCmd,
                    alarmList.ModuleStep);
            }
            return false;
        }
        #endregion

        #region ChamberUp
        /// <summary>
        /// Chamber Up
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ChamberUp(object[] param)
        {
            return _chamberUpRoutine.Start(param) == RState.Running;
        }
        /// <summary>
        /// ChamberUp Monitor
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ChamberUpMonitor(object[] param)
        {
            RState state = _chamberUpRoutine.Monitor();
            if (state == RState.Failed || state == RState.Timeout)
            {
                PostMsg(VPWCellMsg.Error);
                return false;
            }
            return state == RState.End;
        }
        #endregion

        #region ChamberDown
        /// <summary>
        /// Chamber Down
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ChamberDown(object[] param)
        {
            return _chamberDownRoutine.Start(param) == RState.Running;
        }
        /// <summary>
        /// ChamberUp Monitor
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ChamberDownMonitor(object[] param)
        {
            RState state = _chamberDownRoutine.Monitor();
            if (state == RState.Failed || state == RState.Timeout)
            {
                PostMsg(VPWCellMsg.Error);
                return false;
            }
            return state == RState.End;
        }
        #endregion

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

        public bool CheckAcked(int msg)
        {
            return false;
        }
        /// <summary>
        /// EnterInit
        /// </summary>
        public void EnterInit()
        {

        }
        public int Invoke(string function, params object[] args)
        {
            switch (function)
            {
                case "HomeAll":
                    if (IsIdle)
                    {
                        return (int)FSM_MSG.NONE;
                    }
                    if (CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.ERR_VPW, Module.ToString(), (int)VPWCellMsg.Initialize))
                    {
                        return (int)VPWCellMsg.Initialize;
                    }
                    else
                    {
                        return (int)FSM_MSG.NONE;
                    }
            }

            return (int)FSM_MSG.NONE;
        }
    }
}