PunkHPX8/PunkHPX8_RT/Modules/VpwMain/VpwMainEntity.cs

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.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.Persistent.VpwMain;
using MECF.Framework.Common.ToolLayout;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.VpwCell;
using PunkHPX8_RT.Devices.VpwMain;
using PunkHPX8_RT.Modules.VpwCell;
using PunkHPX8_RT.Modules.VpwCelMain;
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 VpwMainEntity : Entity, IEntity, IModuleEntity
    {

        public enum MSG
        {
            Home
        }

        #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 VpwMainPersistentValue _persistentValue;
        /// <summary>
        /// VPW cell集合
        /// </summary>
        private List<VpwCellDevice> _vpwCellDevices = new List<VpwCellDevice>();
        /// <summary>
        /// Home Routine
        /// </summary>
        private VPWHomeRoutine _homeRoutine;
        /// <summary>
        /// purge Routine
        /// </summary>
        private VpwPurgeRoutine _vpwPurgeRoutine;
        /// <summary>
        /// chamber down routine
        /// </summary>
        private VPWChamberDownRoutine _chamberDownRoutine;
        /// <summary>
        /// chamber down routine
        /// </summary>
        private VPWChamberUpRoutine _chamberUpRoutine;
        /// <summary>
        /// 设备
        /// </summary>
        private VpwMainDevice _mainDevice;

        #endregion

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

        /// <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>
        /// Chamber打开状态
        /// </summary>
        public bool IsChamberOpened { get { return _mainDevice.CommonData.ChamberOpened && !_mainDevice.CommonData.ChamberClosed; } }
        /// <summary>
        /// Chamber关闭状态
        /// </summary>
        public bool IsChamberClosed { get { return _mainDevice.CommonData.ChamberClosed && !_mainDevice.CommonData.ChamberOpened; } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public VpwMainEntity(ModuleName module)
        {
            Module = module;
            _mainDevice = DEVICE.GetDevice<VpwMainDevice>(Module.ToString());
        }

        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        protected override bool Init()
        {
            InitialFsm();
            InitializeParameter();
            InitializeRoutine();
            InitializeDATA();
            InitializeOperation();
            return true;
        }
        /// 初始化状态机
        /// </summary>
        private void InitialFsm()
        {
            fsm = new StateMachine<VpwMainEntity>(Module.ToString(), (int)VPWMainState.Init, 100);
            fsm.EnableRepeatedMsg(true);
            AnyStateTransition(VPWMainMsg.Error, NullFunc, VPWMainState.Error);
            AnyStateTransition(VPWMainMsg.Abort, PurgeAbort, VPWMainState.Aborting);
            //Initialized
            Transition(VPWMainState.Error, VPWMainMsg.Initialize, InitializeAll, VPWMainState.Initializing);
            Transition(VPWMainState.Init, VPWMainMsg.Initialize, InitializeAll, VPWMainState.Initializing);
            Transition(VPWMainState.Idle, VPWMainMsg.Initialize, InitializeAll, VPWMainState.Initializing);
            Transition(VPWMainState.Aborting, VPWMainMsg.Initialize, InitializeAll, VPWMainState.Initializing);
            Transition(VPWMainState.Initializing, FSM_MSG.TIMER, InitializeAllMonitor, VPWMainState.Idle);
            Transition(VPWMainState.Error, VPWMainMsg.EnterIdle, NullFunc, VPWMainState.Idle);
            Transition(VPWMainState.Init, VPWMainMsg.EnterIdle, NullFunc, VPWMainState.Idle);
            Transition(VPWMainState.Idle, VPWMainMsg.EnterIdle, NullFunc, VPWMainState.Idle);
            Transition(VPWMainState.Aborting, VPWMainMsg.EnterIdle, NullFunc, VPWMainState.Idle);
            //Enter Init
            Transition(VPWMainState.Idle, VPWMainMsg.Init, NullFunc, VPWMainState.Init);
            //Purge
            Transition(VPWMainState.Idle, VPWMainMsg.Purge, Purge, VPWMainState.Purging);
            Transition(VPWMainState.Purging, VPWMainMsg.Purge, NullFunc, VPWMainState.Purging);
            Transition(VPWMainState.Purging, FSM_MSG.TIMER, PurgeMonitor, VPWMainState.Idle);
            //ChamberUp
            Transition(VPWMainState.Idle, VPWMainMsg.ChamberUp, ChamberUp, VPWMainState.ChamberUping);
            Transition(VPWMainState.ChamberUping, VPWMainMsg.ChamberUp, NullFunc, VPWMainState.ChamberUping);
            Transition(VPWMainState.ChamberUping, FSM_MSG.TIMER, ChamberUpMonitor, VPWMainState.Idle);
            //ChamberDown
            Transition(VPWMainState.Idle, VPWMainMsg.ChamberDown, ChamberDown, VPWMainState.ChamberDowning);
            Transition(VPWMainState.ChamberDowning, VPWMainMsg.ChamberDown, NullFunc, VPWMainState.ChamberDowning);
            Transition(VPWMainState.ChamberDowning, FSM_MSG.TIMER, ChamberDownMonitor, VPWMainState.Idle);

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

            EnumLoop<VPWMainMsg>.ForEach((item) => { fsm.MapMessage((int)item, item.ToString()); });
        }
        /// <summary
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            _persistentValue = VpwMainPersistentManager.Instance.GetPersistentValue(Module.ToString());
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_VPWMAIN, Module.ToString(), "Persistent Value Object is not exist");
            }
            _vpwCellDevices.Clear();
            VpwMainItem vpwMainItem = VpwMainItemManager.Instance.GetItem(Module.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 InitializeDATA()
        {
            InitializeSVID();
            DATA.Subscribe($"{Module}.FsmState", () => ((VPWMainState)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);
        }
        /// <summary>
        /// 初始化SVID
        /// </summary>
        private void InitializeSVID()
        {
            DATA.Subscribe($"{Module}.State", () => ((VPWMainState)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.OperatingMode", () => _persistentValue != null ? _persistentValue.OperatingMode : "None", SubscriptionAttribute.FLAG.IgnoreSaveDB);
            
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _homeRoutine = new VPWHomeRoutine(Module.ToString());
            _vpwPurgeRoutine = new VpwPurgeRoutine(Module.ToString());
            _chamberDownRoutine=new VPWChamberDownRoutine(Module.ToString());
            _chamberUpRoutine=new VPWChamberUpRoutine(Module.ToString());
        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.InitializeAll", (cmd, args) => { return CheckToPostMessage<VPWMainState, VPWMainMsg>(eEvent.ERR_VPWMAIN, Module.ToString(), (int)VPWMainMsg.Initialize); });
            OP.Subscribe($"{Module}.Purge", (cmd, args) => { return CheckToPostMessage<VPWMainState, VPWMainMsg>(eEvent.ERR_VPWMAIN, Module.ToString(), (int)VPWMainMsg.Purge); });
        }

        #region Purge
        
        private bool Purge(object[] param)
        {
            if (_vpwCellDevices == null || _vpwCellDevices.Count == 0)
            {
                LOG.WriteLog(eEvent.ERR_VPWMAIN, 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_VPWMAIN, Module.ToString(), $"cell device {device.Module} is busy,cannot purge");
                    return false;
                }
            }
            return _vpwPurgeRoutine.Start(_vpwCellDevices) == RState.Running;
        }

        private bool PurgeMonitor(object[] param)
        {
            RState ret = _vpwPurgeRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(VPWMainMsg.Error);
                return false;
            }
            return ret == RState.End;
        }

        private bool PurgeAbort(object[] param)
        {
            _vpwPurgeRoutine.Abort();
            return true;
        }
        #endregion

        #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_VPWMAIN, 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_VPWMAIN, Module.ToString(), $"cell device {device.Module} is busy,cannot initialize");
                    return false;
                }
            }
            bool result= _homeRoutine.Start(_vpwCellDevices) == RState.Running;
            if (result)
            {
                foreach (var device in _vpwCellDevices)
                {
                    VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(device.Module);
                    if (!vpwCellEntity.IsDisable)
                    {
                        vpwCellEntity.CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.INFO_VPW, device.Module, (int)VPWCellMsg.MainInitialize);
                    }
                }
            }
            return result;
        }

        
        /// <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(VPWMainMsg.Error);
                return false;
            }

            return ret == RState.End;
        }
        #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<VPWMainState, VPWMainMsg>(eEvent.ERR_VPWMAIN, Module.ToString(), (int)VPWMainMsg.Initialize))
                    {
                        return (int)VPWMainMsg.Initialize;
                    }
                    else
                    {
                        return (int)FSM_MSG.NONE;
                    }
            }

            return (int)FSM_MSG.NONE;
        }
    }
}