PunkHPX8/PunkHPX8_RT/Modules/PlatingCell/PlatingCellEntity.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.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using CyberX12_RT.Modules.VpwCell;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.ProcessCell;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.RT.Core.Equipments;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.PlatingCell;
using PunkHPX8_RT.Devices.PowerSupplier;
using PunkHPX8_RT.Devices.Reservoir;
using PunkHPX8_RT.Devices.Temperature;
using PunkHPX8_RT.Modules.Reservoir;
using PunkHPX8_RT.Modules.VpwCell;
using PunkHPX8_RT.Modules.VpwMain;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Modules.PlatingCell
{
    public class PlatingCellEntity : 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 PlatingCellPersistentValue _persistentValue;
        /// <summary>
        /// 当前recipe
        /// </summary>
        private DepRecipe _currentRecipe;
        /// <summary>
        /// recipe时间
        /// </summary>
        private int _recipeTime;
        /// <summary>
        /// 循环次数
        /// </summary>
        private int _cycle = 0;
        /// <summary>
        /// 已经完成的Cycle次数
        /// </summary>
        private int _achievedCycle = 0;
        /// <summary>
        /// c&m Initialize routine
        /// </summary>
        private PlatingCellInitializeRoutine _initializeRoutine;
        /// <summary>
        /// CCR routine
        /// </summary>
        private PlatingCellCCRRoutine _platingCellCRRoutine;
        /// <summary>
        /// Run recipe routine
        /// </summary>
        private PlatingCellRunRecipeRoutine _runRecipeRoutine;
        /// <summary>
        /// dummy risne Run recipe routine
        /// </summary>
        private DummyRinseRunRecipeRoutine _dummyRinseRunRecipeRoutine;
        /// <summary>
        /// Unload Routine
        /// </summary>
        private PlatingCellUnloadRoutine _unloadRoutine;
        /// <summary>
        /// 工艺当前执行小步骤
        /// </summary>
        private string _currentStepState = "Init";
        /// <summary>
        /// 当前是否在跑dummy recipe
        /// </summary>
        private bool _isCurrentRunDummyRecipe;
        #endregion

        #region 属性
        /// <summary>
        /// 模块名称
        /// </summary>
        public ModuleName Module { get; private set; }
        /// <summary>
        /// 是否Init
        /// </summary>
        public bool IsInit
        {
            get { return fsm.State == (int)PlatingCellState.Init; }
        }
        /// <summary>
        /// 是否Idle
        /// </summary>
        public bool IsIdle
        {
            get
            {
                return fsm.State == (int)PlatingCellState.Idle;
            }
        }
        /// <summary>
        /// 是否错误
        /// </summary>
        public bool IsError
        {
            get { return fsm.State == (int)PlatingCellState.Error; }
        }
        /// <summary>
        /// 正在忙碌
        /// </summary>
        public bool IsBusy
        {
            get { return fsm.State == (int)PlatingCellState.Initializing ; }
        }
        /// <summary>
        /// 正在Run recipe
        /// </summary>
        public bool IsInRecipe
        {
            get { return fsm.State == (int)PlatingCellState.RunReciping; }
        }
        /// <summary>
        /// 已完成的RunRecipeCycle次数
        /// </summary>
        public int AchievedCycle { get { return _achievedCycle; } }
        /// <summary>
        /// 化学液
        /// </summary>
        public string Chemistry
        {
            get { return _currentRecipe != null ? _currentRecipe.Chemistry : ""; }
        }
        /// <summary>
        /// 当前正在run 的recipe
        /// </summary>
        public DepRecipe CurrentRecipe
        {
            get { return _currentRecipe; }
        }
        /// <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>
        /// 当前状态机状态
        /// </summary>
        public int State { get { return fsm.State; } }
        /// <summary>
        /// 是否初始化完成
        /// </summary>
        public bool IsInitialized { get { return fsm.State >= (int)PlatingCellState.Initialized; } }
        /// <summary>
        /// Reservoir项
        /// </summary>
        private ReservoirItem _reservoirItem;
        /// <summary>
        /// Wafer信息
        /// </summary>
        public WaferInfo WaferInfo { get { return WaferManager.Instance.GetWafer(Module,0); } }

        /// <summary>
        /// 当前Metal设置的WaferSize
        /// </summary>
        public int MetalWaferSize { get { return _persistentValue.PlatingCellWaferSize; } }
        /// <summary>
        /// 当前工步
        /// </summary>
        public string CurrentStepState { get { return _currentStepState; } }
        /// <summary>
        /// 是否正在跑dummy recipe
        /// </summary>
        public bool IsCurrentRunDummyRecipe
        {
            get
            {
                return _isCurrentRunDummyRecipe;
            }
        }
        #endregion

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

        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            _persistentValue = PlatingCellPersistentManager.Instance.GetPlatingCellPersistentValue(Module.ToString());
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module.ToString(), "Persistent Value Object is not exist");
            }
        }
      
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _initializeRoutine = new PlatingCellInitializeRoutine(Module.ToString());
            _platingCellCRRoutine = new PlatingCellCCRRoutine(Module.ToString());
            _runRecipeRoutine=new PlatingCellRunRecipeRoutine(Module.ToString());   
            _dummyRinseRunRecipeRoutine=new DummyRinseRunRecipeRoutine(Module.ToString());   
            _unloadRoutine=new PlatingCellUnloadRoutine(Module.ToString());
        }
        /// <summary>
        /// 初始化DATA
        /// </summary>
        private void InitializeDATA()
        {
            DATA.Subscribe($"{Module}.FsmState", () => ((PlatingCellState)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.CurrentRecipe", () => _currentRecipe != null ? _currentRecipe.Ppid : "", SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.TotalTime", () => _recipeTime, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.TimeRemain", () => CalculateRecipeTimeRemain(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Chemistry", () => Chemistry, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.AchievedCycle", () => AchievedCycle, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Module}.IsInit", () => IsInit, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsIdle", () => IsIdle, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsError", () => IsError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsBusy", () => IsBusy, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsDisable", () => IsDisable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化Operation
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.InitializeAll", (cmd, args) => { return CheckToPostMessage<PlatingCellState, PlatingCellMsg>(eEvent.ERR_RESERVOIR, Module.ToString(), (int)PlatingCellMsg.Initialize); });
            OP.Subscribe($"{Module}.ManualCCRStart", (cmd, args) => { return CheckToPostMessage<PlatingCellState, PlatingCellMsg>(eEvent.ERR_RESERVOIR, Module.ToString(), (int)PlatingCellMsg.CCR); });
            OP.Subscribe($"{Module}.ManualCCRStop", (cmd, args) => { return CheckToPostMessage<PlatingCellState, PlatingCellMsg>(eEvent.ERR_RESERVOIR, Module.ToString(), (int)PlatingCellMsg.CCRAbort); });
            OP.Subscribe($"{Module}.CycleManualProcessRecipe", (cmd, args) =>
            {
                bool isDummyLoad = (bool)args[1];
                object recipe = null;
                if (!isDummyLoad)
                {
                    recipe = RecipeFileManager.Instance.LoadGenericityRecipe<DepRecipe>(args[0].ToString());
                    if (recipe == null)
                    {
                        LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module.ToString(), $"{args[0]} recipe is null");
                        return false;
                    }
                }
                else
                {
                    recipe = RecipeFileManager.Instance.LoadGenericityRecipe<DqdrRecipe>(args[0].ToString());
                    if (recipe == null)
                    {
                        LOG.WriteLog(eEvent.ERR_PLATINGCELL, 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<PlatingCellState, PlatingCellMsg>(eEvent.ERR_PREWET, Module.ToString(), (int)PlatingCellMsg.RunRecipe, objects);
            });
            OP.Subscribe($"{Module}.Abort", (cmd, args) => { return CheckToPostMessage<PlatingCellState, PlatingCellMsg>(eEvent.ERR_RESERVOIR, Module.ToString(), (int)PlatingCellMsg.Abort); });
        }

        /// 初始化状态机
        /// </summary>
        private void InitialFsm()
        {
            fsm = new StateMachine<PlatingCellEntity>(Module.ToString(), (int)PlatingCellState.Init, 100);
            fsm.EnableRepeatedMsg(true);

            AnyStateTransition(PlatingCellMsg.Error, NullFunc, PlatingCellState.Error);
            //Initialized
            Transition(PlatingCellState.Error, PlatingCellMsg.Initialize, InitializeAll, PlatingCellState.Initializing);
            Transition(PlatingCellState.Init, PlatingCellMsg.Initialize, InitializeAll, PlatingCellState.Initializing);
            Transition(PlatingCellState.Idle, PlatingCellMsg.Initialize, InitializeAll, PlatingCellState.Initializing);
            Transition(PlatingCellState.Abort, PlatingCellMsg.Initialize, InitializeAll, PlatingCellState.Initializing);
            Transition(PlatingCellState.Initializing, FSM_MSG.TIMER, InitializeAllMonitor, PlatingCellState.Idle);

            //CCR
            Transition(PlatingCellState.Idle, PlatingCellMsg.CCR, ManualCCRStart, PlatingCellState.CCRing);
            Transition(PlatingCellState.CCRing, FSM_MSG.TIMER, CCRMonitor, PlatingCellState.Idle);
            Transition(PlatingCellState.CCRing, PlatingCellMsg.CCRAbort, CCRAbort, PlatingCellState.Init);
            //Cycle Manual Process
            Transition(PlatingCellState.Idle, PlatingCellMsg.RunRecipe, CycleManualProcess, PlatingCellState.RunReciping);
            Transition(PlatingCellState.RunReciping, FSM_MSG.TIMER, CycleManualMonitor, PlatingCellState.Idle);
            Transition(PlatingCellState.RunReciping, PlatingCellMsg.Abort, RunRecipeAbort, PlatingCellState.Idle);
            Transition(PlatingCellState.RunReciping, PlatingCellMsg.Abort, AbortRecipe, PlatingCellState.Abort);
            //Unload
            Transition(PlatingCellState.Idle, PlatingCellMsg.Unload, Unload, PlatingCellState.Unloading);
            Transition(PlatingCellState.Unloading, FSM_MSG.TIMER, UnloadMonitor, PlatingCellState.Idle);
            Transition(PlatingCellState.Unloading, PlatingCellMsg.Abort, UnloadAbort, PlatingCellState.Idle);
            //直接进入Idle
            Transition(PlatingCellState.Initialized, FSM_MSG.TIMER, NullFunc, PlatingCellState.Idle);
            //Enter Init
            Transition(PlatingCellState.Idle, PlatingCellMsg.Init, NullFunc, PlatingCellState.Init);

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

            EnumLoop<PlatingCellState>.ForEach((item) => { fsm.MapMessage((int)item, item.ToString()); });
        }
        /// <summary>
        /// 计算recipe的剩余时间
        /// </summary>
        /// <returns></returns>
        private int CalculateRecipeTimeRemain()
        {
            if (!IsInRecipe)
            {
                return 0;
            }
            int remainTime = 0;
            if(_recipeTime != 0 && !_isCurrentRunDummyRecipe)
            {
                remainTime = (int)(_recipeTime - Math.Round((double)_runRecipeRoutine.ElapsedMilliseconds / 1000));
            }
            if (_recipeTime != 0 &&  _isCurrentRunDummyRecipe)
            {
                remainTime = (int)(_recipeTime - Math.Round((double)_dummyRinseRunRecipeRoutine.ElapsedMilliseconds / 1000));
            }
            return remainTime;

        }
        /// <summary>
        /// Abort Recipe
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool AbortRecipe(object[] param)
        {
            //后续还要增加lottrack相关
            if (!_isCurrentRunDummyRecipe)
            {
                _runRecipeRoutine.Abort();
               
            }
            else
            { 
                _dummyRinseRunRecipeRoutine.Abort();
            }
            return true;
        }
        /// <summary>
        /// 手动CCR
        /// </summary>
        /// <returns></returns>
        private bool ManualCCRStart(object[] param)
        {
            bool result = _platingCellCRRoutine.Start() == RState.Running;
            return result;

        }
        /// <summary>
        /// CCR 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool CCRMonitor(object[] param)
        {
            RState rsstate = RState.Running;
            rsstate = _platingCellCRRoutine.Monitor();
            if (rsstate == RState.End)
            {
                return true;
            }
            else if (rsstate == RState.Failed || rsstate == RState.Timeout)
            {
                PostMsg(PlatingCellMsg.Error);
                return false;
            }
            return false;
        }
        /// <summary>
        /// CCR abort
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool CCRAbort(object[] param)
        {
            if(_platingCellCRRoutine.Monitor() == RState.Running)
            {
                _platingCellCRRoutine.Abort();
            }
            return true;
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        private bool InitializeAll(object[] param)
        {
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module.ToString(), "persistent is null");
                return false;
            }
            if (fsm.State == (int)PlatingCellState.Initializing)
            {
                LOG.WriteLog(eEvent.WARN_PLATINGCELL, Module.ToString(), "state is Initializing,cannot do initialize");
                return false;
            }
            if (!CheckReservoirInitialized())
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module.ToString(), "Reservoir is not initialized");
                return false;
            }
            if (!MetalUsageMointor(Module.ToString()))
            {
                return false;
            }
            if ("Auto".Equals(_persistentValue.OperatingMode))
            {
                if (!CheckReservoirIsAuto())
                {
                    LOG.WriteLog(eEvent.ERR_METAL, Module.ToString(), "Reservoir is not in Auto OperationMode");
                    return false;
                }
            }
            string AnotherModule = ModuleMatcherManager.Instance.GetMatcherByModule(Module.ToString());
            PlatingCellEntity anotherEntity = Singleton<RouteManager>.Instance.GetModule<PlatingCellEntity>(AnotherModule);
            {
                if(anotherEntity != null && anotherEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_METAL, Module.ToString(), "Another Platingcell is busy, can not initialized");
                    return false;
                }
            }
            bool result = _initializeRoutine.Start(_persistentValue) == RState.Running;
            return result;
           
        }
        /// <summary>
        /// 检验Reservoir是否Auto
        /// </summary>
        /// <returns></returns>
        private bool CheckReservoirIsAuto()
        {
            string reservoir = ReservoirItemManager.Instance.GetReservoirByPlatingCell(Module.ToString());
            ReservoirsPersistentValue reservoirsPersistentValue = ReservoirsPersistentManager.Instance.GetReservoirsPersistentValue(reservoir);
            if ("Auto".Equals(reservoirsPersistentValue.OperatingMode))
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检验Reservoir是否Initialized
        /// </summary>
        /// <returns></returns>
        private bool CheckReservoirInitialized()
        {
            string reservoir = ReservoirItemManager.Instance.GetReservoirByPlatingCell(Module.ToString());
            ReservoirEntity reservoirEntity = Singleton<RouteManager>.Instance.GetModule<ReservoirEntity>(reservoir);
            if (reservoirEntity != null)
            {
                return reservoirEntity.IsInitialized;
            }
            return false;
        }
        /// <summary>
        /// 监控 PM Counter Metal用量
        /// </summary>
        private bool MetalUsageMointor(string Module)
        {
            return true;
        }
        /// <summary>
        /// Initialize 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool InitializeAllMonitor(object[] param)
        {
            RState rsstate = RState.Running;
            rsstate = _initializeRoutine.Monitor();
            if (rsstate == RState.End)
            {
                return true;
            }
            else if (rsstate == RState.Failed || rsstate == RState.Timeout)
            {
                PostMsg(PlatingCellMsg.Error);
                return false;
            }
            return false;
        }

        /// <summary>
        /// EnterInit
        /// </summary>
        public void EnterInit()
        {
            if ((PlatingCellState)fsm.State != PlatingCellState.Idle) return;
            else
            {
                CheckToPostMessage<PlatingCellState, PlatingCellMsg>(eEvent.ERR_PLATINGCELL, Module.ToString(), (int)PlatingCellMsg.Init);
            }
        }

        #region cycle manual process
        /// <summary>
        /// process
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool CycleManualProcess(object[] param)
        {
            bool _isDummyLoad = (bool)param[1];
            if (!_isDummyLoad)
            {
                _isCurrentRunDummyRecipe = false;
                bool result = _runRecipeRoutine.Start(param) == RState.Running;
                _currentStepState = "";
                DepRecipe recipe = param[0] as DepRecipe;
                _cycle = (int)param[2];
                if (result)
                {
                    _recipeTime = recipe.CalculateRecipeTotalTime() * _cycle;
                    _currentRecipe = recipe;
                }
                return result;

            }
            else
            {
                _isCurrentRunDummyRecipe = true;
                bool result = _dummyRinseRunRecipeRoutine.Start(param) == RState.Running;
                _currentStepState = "";
                DqdrRecipe recipe = param[0] as DqdrRecipe;
                _cycle = (int)param[2];
                if (result)
                {
                    _recipeTime = recipe.CalculateRecipeTotalTime() * _cycle;
                    //run dummy recipe不需要记录当前recipe
                }
                return result;
            }
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool CycleManualMonitor(object[] param)
        {
            if (!_isCurrentRunDummyRecipe)
            {
                RState state = _runRecipeRoutine.Monitor();
                _currentStepState = _runRecipeRoutine.CurrentStep;
                _achievedCycle = _runRecipeRoutine.GetCurrentCycle();
                //LOG.WriteLog(eEvent.INFO_PLATINGCELL, Module.ToString(), _currentStepState);
                if (state == RState.Failed || state == RState.Timeout)
                {
                    PostMsg(PlatingCellMsg.Error);
                    _currentStepState = "";
                    _currentRecipe = null;
                    return false;
                }
                bool result = state == RState.End;
                if (result)
                {
                    _currentStepState = "";
                    _currentRecipe = null;
                }
                return result;
            }
            else
            {
                RState state = _dummyRinseRunRecipeRoutine.Monitor();
                _currentStepState = _dummyRinseRunRecipeRoutine.CurrentStep;
                _achievedCycle = _dummyRinseRunRecipeRoutine.GetCurrentCycle();
                //LOG.WriteLog(eEvent.INFO_PLATINGCELL, Module.ToString(), _currentStepState);
                if (state == RState.Failed || state == RState.Timeout)
                {
                    PostMsg(PlatingCellMsg.Error);
                    _currentStepState = "";
                    _currentRecipe = null;
                    return false;
                }
                bool result = state == RState.End;
                if (result)
                {
                    _currentStepState = "";
                    _currentRecipe = null;
                }
                return result;
            }
           
        }
        /// <summary>
        /// 中止
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool RunRecipeAbort(object[] param)
        {
            _runRecipeRoutine.Abort();
            _currentStepState = "";
            return true;
        }
        #endregion

        #region unload
        /// <summary>
        /// unload
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool Unload(object[] param)
        {
            return _unloadRoutine.Start(param) == RState.Running;
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool UnloadMonitor(object[] param)
        {
            RState state = _unloadRoutine.Monitor();
            if (state == RState.Failed || state == RState.Timeout)
            {
                PostMsg(PlatingCellMsg.Error);
                return false;
            }
            return state == RState.End;
        }
        /// <summary>
        /// 中止
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool UnloadAbort(object[] param)
        {
            _unloadRoutine.Abort();
            return true;
        }
        #endregion

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

        public bool CheckAcked(int msg)
        {
            throw new NotImplementedException();
        }

        public int Invoke(string function, params object[] args)
        {
            switch (function)
            {
                case "HomeAll":
                    if (IsIdle)
                    {
                        return (int)FSM_MSG.NONE;
                    }
                    if (CheckToPostMessage<PlatingCellState, PlatingCellMsg>(eEvent.ERR_PLATINGCELL, Module.ToString(), (int)PlatingCellMsg.Initialize))
                    {
                        return (int)PlatingCellMsg.Initialize;
                    }
                    else
                    {
                        return (int)FSM_MSG.NONE;
                    }
            }
            return (int)FSM_MSG.NONE;
        }
    }
    public enum PlatingCellMsg
    {
        NONE,
        Error,
        ResumeError,
        Initialize,
        Manual,
        Auto,
        CloseFlowValve,
        OpenFlowValve,
        RunRecipe,
        Abort,
        Init,
        CCR,
        CCRAbort,
        Unload
    }
}