CyberX8/CyberX8_RT/Devices/Dryer/DryerDevice.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.CommonData.Dryer;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Persistent.Dryer;
using MECF.Framework.Common.TwinCat;
using MECF.Framework.Common.Utilities;
using CyberX8_Core;
using CyberX8_RT.Devices.Facilities;
using System.Collections.Generic;
using System.Reflection;
using CyberX8_RT.Modules.Dryer;
using CyberX8_RT.Modules;
using MECF.Framework.Common.IOCore;

namespace CyberX8_RT.Devices.Dryer
{
    public class DryerDevice : BaseDevice, IDevice
    {
        #region 常量 
        private const string POWER_CONTROL = "PowerControl";
        private const string EXHAUST_PRESSURE = "ExhaustPressure";
        private const string BLOWER_HIGH = "BlowerHigh";
        private const string EXHAUST_LIMIT_DATA = "ExhaustLimitData";
        private const string EXHAUST_PRESSURE_VALUE = "ExhaustPressure";
        private const string COMMON_DATA = "CommonData";
        private const string PERSISTENT_VALUE = "PersistentValue";
        #endregion
        /// <summary>
        /// Dryer操作枚举
        /// </summary>
        private enum DryerCommonOperation
        {
            None,
            ControlPowerOn,
            ControlPowerOff,
            BlowerHigh,
            BlowerLow
        }
        #region 内部变量
        /// <summary>
        /// 公用数据
        /// </summary>
        private DryerCommonData _dryerCommonData;
        /// <summary>
        /// 状态
        /// </summary>
        private RState _status;
        /// <summary>
        /// 当前操作
        /// </summary>
        private DryerCommonOperation _currentOperation;
        /// <summary>
        /// Blower High Routine 
        /// </summary>
        private DryerBlowerHighRoutine _blowerHighRoutine;
        /// <summary>
        /// ByPass
        /// </summary>
        private bool _byPass = false;
        /// <summary>
        /// Facilities
        /// </summary>
        private SystemFacilities _facilities;
        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();
        /// <summary>
        /// 定时器Job
        /// </summary>
        PeriodicJob _periodicJob = null;
        /// <summary>
        /// Dryer 持久性数值对象
        /// </summary>
        private DryerPersistentValue _dryerPersistentValue;
        #endregion

        #region 属性
        /// <summary>
        /// 公用数据对象
        /// </summary>
        public DryerCommonData CommonData { get { return _dryerCommonData; } }
        /// <summary>
        /// 所有io变量是否初始化
        /// </summary>
        public bool IOInitialized { get { return IOVariableDictionaryUtil.AllIoVariableInitialized(eEvent.ERR_DRYER,Module,_variableInitializeDic); } }
        /// <summary>
        /// 状态
        /// </summary>
        public RState Status { get { return _status; } }
        /// <summary>
        /// ByPass
        /// </summary>
        public bool Bypass {  get { return _byPass; } }
        /// <summary>
        /// FacilityCommonLimitData
        /// </summary>
        public CommonLimitData FacilityCommonLimitData { get { return _facilities.GetCommonLimitDataByName(EXHAUST_PRESSURE_VALUE); } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="name"></param>
        public DryerDevice(string moduleName) : base(moduleName, moduleName,moduleName,moduleName)
        {
            _periodicJob = new PeriodicJob(100, OnTimer, $"{Module}.OnTimer", true);
            _dryerCommonData = new DryerCommonData();
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeRoutine();
            SubscribeData();
            SubscribeValueAction();
            InitializeOperation();
            return true;
        }

        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _blowerHighRoutine = new DryerBlowerHighRoutine(Module, this);
        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeData()
        {
            _dryerPersistentValue = DryerPersistentManager.Instance.GetDryerPersistentValue(Module);
            if (_dryerPersistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, "Persistent Value Object is not exist");
            }
            DATA.Subscribe($"{Module}.{EXHAUST_LIMIT_DATA}", ()=>GetExhaustLimitData(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{COMMON_DATA}", () => CommonData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{PERSISTENT_VALUE}", () => _dryerPersistentValue,SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ExhaustPressure",()=>CommonData.ExhaustPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PowerControl", () => CommonData.PowerControl, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.BlowerHigh", () => CommonData.BlowerHigh, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 获取Exhaust Limit 数据
        /// </summary>
        /// <returns></returns>
        private CommonLimitData GetExhaustLimitData()
        {
            if (_facilities == null)
            {
                _facilities = DEVICE.GetDevice<SystemFacilities>("System.Facilities");
            }
            if (_facilities == null)
            {
                return null;
            }
            return _facilities.GetCommonLimitDataByName(EXHAUST_PRESSURE_VALUE);
        }
        /// <summary>
        /// 订阅变量数值发生变化
        /// </summary>
        private void SubscribeValueAction()
        {
            _variableInitializeDic[POWER_CONTROL] = false;
            IOModuleManager.Instance.SubscribeModuleVariable(Module, POWER_CONTROL, UpdateVariableValue);
            _variableInitializeDic[BLOWER_HIGH] = false;
            IOModuleManager.Instance.SubscribeModuleVariable(Module, BLOWER_HIGH, UpdateVariableValue);
            _variableInitializeDic[EXHAUST_PRESSURE] = false;
            IOModuleManager.Instance.SubscribeModuleVariable(Module, EXHAUST_PRESSURE, UpdateVariableValue);
        }
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateVariableValue(string variable, object value)
        {
            if (!CommonData.IsDataInitialized)
            {
                CommonData.IsDataInitialized = true;
            }
            PropertyInfo property = CommonData.GetType().GetProperty(variable);
            if (property != null)
            {               
                property.SetValue(CommonData, value);
            }
            if (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
            if(variable==BLOWER_HIGH)
            {
                if (CommonData.BlowerHigh)
                {
                    DryerAutoOff.Instance.Stop();
                }
                else if(CommonData.PowerControl)
                {
                    DryerAutoOff.Instance.Start();
                }
            }
            else if(variable==POWER_CONTROL)
            {
                if (CommonData.PowerControl)
                {
                    DryerAutoOff.Instance.Start();
                }
                else
                {
                    DryerAutoOff.Instance.Stop();
                }
            }
        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.PowerControlOn", PowerControlOnAction);
            OP.Subscribe($"{Module}.PowerControlOff", PowerControlOffAction);
            OP.Subscribe($"{Module}.BlowerHigh",BlowerHighAction);
            OP.Subscribe($"{Module}.BlowerLow", BlowerLowOnAction);
            OP.Subscribe($"{Module}.ByPass", (cmd, args) => { _byPass = (bool)args[0]; return true; });
            
            OP.Subscribe($"{Module}.DisabledAction", DisabledOperation);
            OP.Subscribe($"{Module}.ManualAction", ManualOperation);
            OP.Subscribe($"{Module}.AutoAction", AutoOperation);
            OP.Subscribe($"{Module}.EngineeringModeAction", EngineeringModeOperation);
            OP.Subscribe($"{Module}.ProductionModeAction", ProductionModeOperation);
        }
        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            if (_status == RState.Running)
            {
                if (_currentOperation != DryerCommonOperation.None)
                {
                    IRoutine routine = GetCurrentRoutine(_currentOperation);
                    if (routine != null)
                    {
                        CheckRoutineState(routine, _currentOperation);
                    }
                    else
                    {
                        EndOperation(RState.End);
                    }
                }
            }
            return true;
        }
        #region Action

        #region Power Control
        /// <summary>
        /// Power Control On操作
        /// </summary>
        private bool PowerControlOnAction(string cmd, object[] args)
        {
            return PowerControlOn();
        }
        /// <summary>
        /// Power Control Off操作
        /// </summary>
        private bool PowerControlOffAction(string cmd, object[] args)
        {
            return PowerControlOff();
        }
        /// <summary>
        /// Power Control On
        /// </summary>
        /// <returns></returns>
        public bool PowerControlOn()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{POWER_CONTROL}");
            bool result= IOModuleManager.Instance.WriteIoValue(ioName, true);

            if (result)
            {
                LOG.WriteLog(eEvent.INFO_DRYER, Module, "Power Control On Success");
            }
            return result;
        }
        /// <summary>
        /// Power Control Off
        /// </summary>
        /// <returns></returns>
        public bool PowerControlOff()
        {
            //检验任一HVD处于High On状态
            if(CheckDryersIsInBlowerHigh())
            {
                return false;
            }
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{POWER_CONTROL}");
            bool result = IOModuleManager.Instance.WriteIoValue(ioName, false);
            if(result)
            {
                LOG.WriteLog(eEvent.INFO_DRYER, Module, "Power Control Off Success");
            }
            return result;
        }
        /// <summary>
        /// 检验是否Dryers是否有处于BlowerHigh状态
        /// </summary>
        /// <returns></returns>
        public bool CheckDryersIsInBlowerHigh(bool error=true)
        {
            bool dryer1High = CheckDryerModuleIsInBlowerHigh(ModuleName.Dryer1);
            eEvent eEvent = eEvent.ERR_DRYER;
            if(!error)
            {
                eEvent = eEvent.INFO_DRYER;
            }
            if(dryer1High)
            {
                LOG.WriteLog(eEvent, Module, "Dryer1 is high on");
                return true;
            }
            bool dryer2High = CheckDryerModuleIsInBlowerHigh(ModuleName.Dryer2);
            if (dryer2High)
            {
                LOG.WriteLog(eEvent, Module, "Dryer2 is high on");
                return true;
            }
            bool dryer3High = CheckDryerModuleIsInBlowerHigh(ModuleName.Dryer3);
            if (dryer3High)
            {
                LOG.WriteLog(eEvent, Module, "Dryer3 is high on");
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检验Dryer模块是否处于Blower High
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        private bool CheckDryerModuleIsInBlowerHigh(ModuleName moduleName)
        {
            if (ModuleHelper.IsInstalled(moduleName))
            {
                DryerDevice dryerDevice1 = DEVICE.GetDevice<DryerDevice>(moduleName.ToString());
                if (dryerDevice1 != null)
                {
                    if (dryerDevice1.CommonData.BlowerHigh)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        #endregion

        #region Blower High
        /// <summary>
        /// Blow High动作
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool BlowerHighAction(string cmd, object[] args)
        {
            if(JudgeRunningState(DryerCommonOperation.BlowerHigh))
            {
                return false;
            }
            if(CheckDryerModulePowerOff(ModuleHelper.Converter(Module)))
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, $"{Module} is Power off");
                return false;
            }
            _currentOperation = DryerCommonOperation.BlowerHigh;
            _status = _blowerHighRoutine.Start(_byPass);
            return _status == RState.Running;
        }

        /// <summary>
        /// Blower High On
        /// </summary>
        /// <returns></returns>
        public bool BlowerHighOn()
        {
            if(CheckDryerModulePowerOff(ModuleHelper.Converter(Module)))
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, $"{Module} is Power off");
                return false;
            }
            CommonLimitData commonLimitData = GetExhaustLimitData();
            if (commonLimitData.IsWarning || commonLimitData.IsError)
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, "Exhuast Pressure is Abnormal");
                return false;
            }
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{BLOWER_HIGH}");
            bool result = IOModuleManager.Instance.WriteIoValue(ioName, true);

            if (result)
            {
                LOG.WriteLog(eEvent.INFO_DRYER, Module, "Blower High On Success");
            }
            return result;
        }
        /// <summary>
        /// 检验Dryer模块是否处于PowerOff
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        private bool CheckDryerModulePowerOff(ModuleName moduleName)
        {
            if (ModuleHelper.IsInstalled(moduleName))
            {
                DryerDevice dryerDevice1 = DEVICE.GetDevice<DryerDevice>(moduleName.ToString());
                if (dryerDevice1 != null)
                {
                    if (dryerDevice1.IOInitialized&&!dryerDevice1.CommonData.PowerControl)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 检验是否Dryers是否有处于BlowerHigh状态
        /// </summary>
        /// <returns></returns>
        private bool CheckDryersPowerOff()
        {
            bool dryer1High = CheckDryerModulePowerOff(ModuleName.Dryer1);
            if (dryer1High)
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, "Dryer1 is power off");
                return true;
            }
            bool dryer2High = CheckDryerModulePowerOff(ModuleName.Dryer2);
            if (dryer2High)
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, "Dryer2 is power off");
                return true;
            }
            bool dryer3High = CheckDryerModulePowerOff(ModuleName.Dryer3);
            if (dryer3High)
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, "Dryer3 is power off");
                return true;
            }
            return false;
        }
        #endregion

        #region Blower Low
        /// <summary>
        /// Blower Low On Action
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool BlowerLowOnAction(string cmd, object[] args)
        {
            return BlowerLowOn();
        }

        /// <summary>
        /// Blower Low On
        /// </summary>
        /// <returns></returns>
        public bool BlowerLowOn()
        {
            //High off
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{BLOWER_HIGH}");
            bool result= IOModuleManager.Instance.WriteIoValue(ioName, false);
            if(result)
            {
                string controlPowerOnName= BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{POWER_CONTROL}");
                result= IOModuleManager.Instance.WriteIoValue(controlPowerOnName, true);
            }
            return result;
        }
        #endregion
        /// <summary>
        /// 判定运行状态
        /// </summary>
        /// <returns></returns>
        private bool JudgeRunningState(DryerCommonOperation operation)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_DRYER, Module, $"{Module} current execute {_currentOperation},cannot {operation}");
                return true;
            }
            return false;
        }
        #endregion
        /// <summary>
        /// 获取当前操作对应的Routine
        /// </summary>
        /// <param name="currentOperation"></param>
        /// <returns></returns>
        private IRoutine GetCurrentRoutine(DryerCommonOperation currentOperation)
        {
            switch (currentOperation)
            {
                case DryerCommonOperation.BlowerHigh:
                    return _blowerHighRoutine;
                default:
                    return null;
            }
        }
        /// <summary>
        /// 检验Routine状态
        /// </summary>
        /// <param name="routine"></param>
        /// <param name="currentOperation"></param>
        private void CheckRoutineState(IRoutine routine, DryerCommonOperation currentOperation)
        {
            RState state = routine.Monitor();
            if (state == RState.End)
            {
                EndOperation(RState.End);
            }
            else if (state == RState.Failed || state == RState.Timeout)
            {
                LOG.WriteLog(eEvent.ERR_DRYER, $"{Module}", $"{currentOperation} error");
                EndOperation(RState.Failed);
            }
        }
        /// <summary>
        /// 结束操作
        /// </summary>
        private void EndOperation(RState state)
        {
            _status = state;
            _currentOperation = DryerCommonOperation.None;
        }
        /// <summary>
        /// DisabledAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DisabledOperation(string cmd, object[] args)
        {
            string currentOperation = "Disabled";
            DryerEntity dryerEntity = Singleton<RouteManager>.Instance.GetModule<DryerEntity>(Module);
            if (dryerEntity != null && _dryerPersistentValue != null && _dryerPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _dryerPersistentValue.OperatingMode;
                if (dryerEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_DRYER, Module, $"{Module} is Busy, can't switch to Disabled mode");
                    return false;
                }
                dryerEntity.EnterInit();
                _dryerPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_DRYER, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }
            DryerPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// ManualAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ManualOperation(string cmd, object[] args)
        {
            string currentOperation = "Manual";
            DryerEntity dryerEntity = Singleton<RouteManager>.Instance.GetModule<DryerEntity>(Module);
            if (dryerEntity != null && _dryerPersistentValue != null && _dryerPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _dryerPersistentValue.OperatingMode;
                if (dryerEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_DRYER, Module, $"{Module} is Busy, can't switch to Manual mode");
                    return false;
                }
                dryerEntity.EnterInit();
                _dryerPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_DRYER, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }
            DryerPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// AutoAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool AutoOperation(string cmd, object[] args)
        {
            string currentOperation = "Auto";
            DryerEntity dryerEntity = Singleton<RouteManager>.Instance.GetModule<DryerEntity>(Module);
            if (dryerEntity != null && _dryerPersistentValue != null && _dryerPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _dryerPersistentValue.OperatingMode;
                if (dryerEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_DRYER, Module, $"{Module} is Busy, can't switch to Auto mode");
                    return false;
                }
                dryerEntity.EnterInit();
                _dryerPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_DRYER, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }
            DryerPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// EngineeringModeAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool EngineeringModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Engineering";
            _dryerPersistentValue.RecipeOperatingMode = currentRecipeOperation;
            DryerPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// ProductionAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ProductionModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Production";
            _dryerPersistentValue.RecipeOperatingMode= currentRecipeOperation;
            DryerPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }

        #region 设备接口
        /// <summary>
        /// 监控
        /// </summary>
        public void Monitor()
        {

        }

        public void Reset()
        {
        }
        /// <summary>
        /// 中止
        /// </summary>
        public void Terminate()
        {
            _periodicJob.Stop(false);
        }
        #endregion
    }
}