PunkHPX8/PunkHPX8_RT/Modules/PlatingCell/PlatingCellVerticalEntity.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using MECF.Framework.Common.CommonData.PUF;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.Persistent.Temperature;
using MECF.Framework.Common.ToolLayout;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.AXIS;
using PunkHPX8_RT.Modules.Reservoir;
using PunkHPX8_RT.Modules.VpwCell;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static PunkHPX8_RT.Modules.PlatingCell.PlatingCellEntity;

namespace PunkHPX8_RT.Modules.PlatingCell
{

    public class PlatingCellVerticalEntity : Entity, IEntity, IModuleEntity
    {
        public enum VerticalMsg
        {
            NONE,
            Error,
            ResumeError,
            Initialize,
            Abort,
            Init,
            Position
        }

        #region 内部变量
        private PlatingCellVerticalInitializeRoutine _initializeRoutine;
        private PlatingCellVerticalPositionRoutine _positionRoutine;
        /// <summary>
        /// vertical axis
        /// </summary>
        private JetAxisBase _verticalAxis;
        #endregion

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

        public bool IsAuto { get { return true; } }

        public bool IsEngineering { get { return false; } }

        public bool IsProduction { get { return true; } }

        /// <summary>
        /// 运动数据对象
        /// </summary>
        public CommandMotionData MotionData { get { return _verticalAxis.MotionData; } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public PlatingCellVerticalEntity(ModuleName module)
        {
            Module = module;
            _verticalAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Vertical");
            InitialFsm();
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        protected override bool Init()
        {
            InitializeRoutine();
            return true;
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _initializeRoutine = new PlatingCellVerticalInitializeRoutine(Module.ToString());
            _positionRoutine=new PlatingCellVerticalPositionRoutine(Module.ToString());
        }

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

            AnyStateTransition(VerticalMsg.Initialize, InitializeAll, PlatingCellVerticalState.Initializing);
            Transition(PlatingCellVerticalState.Initializing, FSM_MSG.TIMER, InitializeAllMonitor, PlatingCellVerticalState.Idle);
            Transition(PlatingCellVerticalState.Initializing, VerticalMsg.Abort, HomeAbort, PlatingCellVerticalState.Init);
            AnyStateTransition(VerticalMsg.Error, NullFunc, PlatingCellVerticalState.Error);
            //Enter Init
            Transition(PlatingCellVerticalState.Idle, VerticalMsg.Init, NullFunc, PlatingCellVerticalState.Init);

            //Position
            Transition(PlatingCellVerticalState.Idle,VerticalMsg.Position,Position,PlatingCellVerticalState.Positioning);
            Transition(PlatingCellVerticalState.Positioning, VerticalMsg.Position, NullFunc, PlatingCellVerticalState.Positioning);
            Transition(PlatingCellVerticalState.Positioning, FSM_MSG.TIMER, PositionMonitor, PlatingCellVerticalState.Idle);
            Transition(PlatingCellVerticalState.Positioning, VerticalMsg.Abort, PositionAbort, PlatingCellVerticalState.Idle);

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

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

        #region 初始化
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        private bool InitializeAll(object[] param)
        {
            return _initializeRoutine.Start() == RState.Running;
        }
        /// <summary>
        /// Initialize 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool InitializeAllMonitor(object[] param)
        {
            RState rsstate = _initializeRoutine.Monitor();
            if (rsstate == RState.End)
            {
                return true;
            }
            else if (rsstate == RState.Failed || rsstate == RState.Timeout)
            {
                PostMsg(VerticalMsg.Error);
                return false;
            }
            return false;
        }
        /// <summary>
        /// 中止Home
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool HomeAbort(object[] param)
        {
            _initializeRoutine.Abort();
            return true;
        }
        #endregion

        #region Position
        /// <summary>
        /// Position
        /// </summary>
        /// <returns></returns>
        private bool Position(object[] param)
        {
            return _positionRoutine.Start(param) == RState.Running;
        }
        /// <summary>
        /// Position 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool PositionMonitor(object[] param)
        {
            RState rsstate = _positionRoutine.Monitor();
            if (rsstate == RState.End)
            {
                return true;
            }
            else if (rsstate == RState.Failed || rsstate == RState.Timeout)
            {
                PostMsg(VerticalMsg.Error);
                return false;
            }
            return false;
        }
        /// <summary>
        /// 中止
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool PositionAbort(object[] param)
        {
            _positionRoutine.Abort();
            return true; ;
        }
        #endregion


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

        public bool CheckAcked(int msg)
        {
            return true;
        }

        public int Invoke(string function, params object[] args)
        {
            return (int)FSM_MSG.NONE;
        }
    }
}