PunkHPX8/PunkHPX8_RT/Devices/Reservoir/ReservoirDevice.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.RecipeCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Alarm;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.Reservoir;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.TwinCat;
using MECF.Framework.Common.Utilities;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.Facilities;
using PunkHPX8_RT.Devices.Safety;
using PunkHPX8_RT.Devices.Temperature;
using PunkHPX8_RT.Modules;
using PunkHPX8_RT.Modules.Reservoir;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.ServiceModel.Security;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Devices.Reservoir
{
    public class ReservoirDevice : BaseDevice, IDevice
    {
        #region 常量
        protected const string AUTO = "Auto";
        protected const string MANUAL = "Manual";
        protected const string DISABLE = "Disable";

        protected const string CA_PUMP_RUNNING="CaPumpRunning";
        protected const string AN_TOWER_HIGH="AnTowerHigh";
        protected const string AN_TOWER_LOW="AnTowerLow";
        protected const string CA_LEVEL="CaLevel";
        protected const string CA_WATER_LEVEL="CaWaterLevel";
        protected const string AN_FLOW="AnFlow";
        protected const string AN_PUMP_ENABLE="AnPumpEnable";
        protected const string AN_PUMP_SPEED="AnPumpSpeed";
        protected const string CA_FLOW="CaFlow";
        protected const string CA_PUMP_ENABLE="CaPumpEnable";
        protected const string CA_PUMP_SPEED="CaPumpSpeed";
        protected const string RETURN_VALVE_OPENING="ReturnValveOpening";
        protected const string RETURN_VALVE= "ReturnValveEnable";
        protected const string RETURN_VALVE_PERCENT="ReturnValvePercent";
        protected const string CA_DI_REPLEN="CaDiReplen";
        protected const string AN_DI_REPLEN="AnDiReplen";
        protected const string SAMPLE_OUT="SampleOut";
        protected const string DEGAS_ENABLE="DegasEnable";
        protected const string CA_ISOLATION="CaIsolation";
        protected const string AN_ISOLATION="AnIsolation";
        protected const string HED_FLOW="HedFlow";
        protected const string HED_FLOW_ENABLE="HedFlowEnable";
        protected const string PH_FLOW_VALVE="PhFlowValve";
        protected const string PH_VALUE="PhValue";
        #endregion

        #region 内部变量
        /// <summary>
        /// Prewet 持久性数值对象
        /// </summary>
        private ReservoirsPersistentValue _persistentValue;

        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();
        /// <summary>
        /// 数据
        /// </summary>
        private ReservoirData _reservoirData = new ReservoirData();
        /// <summary>
        /// 定时器
        /// </summary>
        private PeriodicJob _periodicJob;
        /// <summary>
        /// 阴极Pump速度
        /// </summary>
        private double _caPumpSpeed = 0;
        /// <summary>
        /// Return Valve比例
        /// </summary>
        private double _returnValvePercent = 0.5;
        /// <summary>
        /// CA Level取样平均值
        /// </summary>
        private double _avgCALevel;
        /// <summary>
        /// CA Level取样队列
        /// </summary>
        private Queue<double> _CALevelSamples;
        /// <summary>
        /// CA level计算平均值取样数
        /// </summary>
        private int _levelSampleCount;
        /// <summary>
        /// Recipe
        /// </summary>
        private ResRecipe _resRecipe;

        /// <summary>
        /// 累计补水是否超时
        /// </summary>
        private bool _isDIReplenMaxTimeOut = false;
        /// <summary>
        /// 单次补水是否超时
        /// </summary>
        private bool _isDIReplenPerfillTimeOut = false;
        /// <summary>
        /// 注水Helper
        /// </summary>
        private ReservoirDiReplenHelper _direplenHelper;
        #endregion

        #region Trigger
        /// <summary>
        /// low WaterLevel trigger
        /// </summary>
        private R_TRIG _caWaterLevelLowerTrigger=new R_TRIG();
        /// <summary>
        /// low WaterLevel trigger
        /// </summary>
        private R_TRIG _caWaterLevelHighTrigger = new R_TRIG();

        #endregion

        #region 共享变量
        protected DiReplenOperation _currentDireplenOperation = DiReplenOperation.None;
        /// <summary>
        /// 手动注水时间(秒)
        /// </summary>
        protected int _manualReplenSecond = 0;
        #endregion

        #region 属性
        /// <summary>
        /// 操作模式
        /// </summary>
        public string OperationMode { get { return _persistentValue.OperatingMode; } }
        /// <summary>
        /// 工程模式
        /// </summary>
        public string EngineerMode { get { return _persistentValue.RecipeOperatingMode; } }
        /// <summary>
        /// 是否自动
        /// </summary>
        public bool IsAuto { get { return _persistentValue.OperatingMode == AUTO; } }

        /// <summary>
        /// 数据
        /// </summary>
        public ReservoirData ReservoirData { get { return _reservoirData; } }
        /// <summary>
        /// 检验阴极是否highlevel
        /// </summary>
        public bool IsCAHighLevel { get { return CheckCAHighLevelStatus(); } }
        /// <summary>
        /// 检验阴极是否lowlevel
        /// </summary>
        public bool IsCALowLevel { get { return CheckCALowLevelStatus(); } }
        /// <summary>
        /// 检验阳极是否highlevel
        /// </summary>
        public bool IsANHighLevel { get { return _reservoirData.AnTowerHigh; } }
        /// <summary>
        /// 检验阳极是否lowlevel
        /// </summary>
        public bool IsANLowLevel { get { return _reservoirData.AnTowerLow; } }
        /// <summary>
        /// 当前Recipe
        /// </summary>
        public ResRecipe Recipe { get { return _resRecipe; } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="name"></param>
        public ReservoirDevice(string moduleName) : base(moduleName, moduleName, moduleName, moduleName)
        {
            _levelSampleCount = SC.GetValue<int>("Reservoir.LevelAvgSamples");
            _levelSampleCount = _levelSampleCount == 0 ? 20 : _levelSampleCount;
            _CALevelSamples = new Queue<double>(_levelSampleCount);
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeParameter();
            InitializeRoutine();
            SubscribeData();
            InitializeOperation();
            SubscribeValueAction();
            _periodicJob = new PeriodicJob(200, OnTimer, $"{Module}.Timer", true, true);
            return true;
        }
        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            _persistentValue = ReservoirsPersistentManager.Instance.GetReservoirsPersistentValue(Module.ToString());
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module.ToString(), "Persistent Value Object is not exist");
            }
            _persistentValue = ReservoirsPersistentManager.Instance.GetReservoirsPersistentValue(Module);
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, "Persistent Value Object is not exist");
            }
            if (!string.IsNullOrEmpty(_persistentValue.Recipe))
            {
                _resRecipe = RecipeFileManager.Instance.LoadGenericityRecipe<ResRecipe>(_persistentValue.Recipe);
            }
            _direplenHelper = new ReservoirDiReplenHelper(Module, _persistentValue);
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {

        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeData()
        {
            DATA.Subscribe($"{Module}.ReservoirData", () => _reservoirData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PersistentValue", () => _persistentValue, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.CurrentRecipe", () => _resRecipe, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化Operation
        /// </summary>
        protected virtual void InitializeOperation()
        {
            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); 
            OP.Subscribe($"{Module}.CAPumpEnable", CAPumpOn);
            OP.Subscribe($"{Module}.CAPumpSpeed", CAPumpSpeedOperation);
            OP.Subscribe($"{Module}.CAPumpDisable", CAPumpOff);
            OP.Subscribe($"{Module}.LoadRecipe", LoadRecipeOperation);
            OP.Subscribe($"{Module}.ReturnValveOn", ReturnValveOn);
            OP.Subscribe($"{Module}.ReturnValveOff", (cmd, para) => { return ReturnValveOff();});
            OP.Subscribe($"{Module}.ReturnValvePercent", ReturnValvePercentOperation);

            OP.Subscribe($"{Module}.CAIsolationOn", (cmd, para) => { return CAIsolationOn(); });
            OP.Subscribe($"{Module}.CAIsolationOff", (cmd, para) => { return CAIsolationOff(); });
            OP.Subscribe($"{Module}.ANIsolationOn", (cmd, para) => { return ANIsolationOn(); });
            OP.Subscribe($"{Module}.ANIsolationOff", (cmd, para) => { return ANIsolationOff(); });
            OP.Subscribe($"{Module}.SampleOutValveOn", (cmd, para) => { return SampleOutValveOn(); });
            OP.Subscribe($"{Module}.SampleOutValveOff", (cmd, para) => { return SampleOutValveOff(); });
            OP.Subscribe($"{Module}.DegasValveOn", (cmd, para) => { return DegasValveOn(); });
            OP.Subscribe($"{Module}.DegasValveOff", (cmd, para) => { return DegasValveOff(); });
            OP.Subscribe($"{Module}.PhValveOn", (cmd, para) => { return PhValveOn(); });
            OP.Subscribe($"{Module}.PhValveOff", (cmd, para) => { return PhValveOff(); });
            OP.Subscribe($"{Module}.HedValveOn", (cmd, para) => { return HedValveOn(); });
            OP.Subscribe($"{Module}.HedValveOff", (cmd, para) => { return HedValveOff(); });
        }
        /// <summary>
        /// 订阅变量数值发生变化
        /// </summary>
        protected virtual void SubscribeValueAction()
        {
            IoSubscribeUpdateVariable(CA_PUMP_RUNNING);
            IoSubscribeUpdateVariable(AN_TOWER_HIGH);
            IoSubscribeUpdateVariable(AN_TOWER_LOW);
            IoSubscribeUpdateVariable(CA_LEVEL);
            IoSubscribeUpdateVariable(CA_WATER_LEVEL);
            IoSubscribeUpdateVariable(CA_PUMP_ENABLE);
            IoSubscribeUpdateVariable(CA_PUMP_SPEED);
            IoSubscribeUpdateVariable(CA_DI_REPLEN);
            IoSubscribeUpdateVariable(RETURN_VALVE);
            IoSubscribeUpdateVariable(RETURN_VALVE_OPENING);
            IoSubscribeUpdateVariable(RETURN_VALVE_PERCENT);
            IoSubscribeUpdateVariable(SAMPLE_OUT);
            IoSubscribeUpdateVariable(CA_ISOLATION);
            IoSubscribeUpdateVariable(AN_ISOLATION);
            IoSubscribeUpdateVariable(DEGAS_ENABLE);
        }
        /// <summary>
        /// 订阅IO变量
        /// </summary>
        /// <param name="variable"></param>
        protected void IoSubscribeUpdateVariable(string variable)
        {
            _variableInitializeDic[variable] = false;
            IOModuleManager.Instance.SubscribeModuleVariable(Module, variable, UpdateVariableValue);
        }
        /// <summary>
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateVariableValue(string variable, object value)
        {
            if (!_reservoirData.IsDataInitialized)
            {
                _reservoirData.IsDataInitialized = true;
            }
            PropertyInfo property = _reservoirData.GetType().GetProperty(variable);
            if (property != null)
            {
                property.SetValue(_reservoirData, value);
                if (variable == CA_WATER_LEVEL)
                {
                    string caLevelCurve = SC.GetStringValue($"Reservoir.{Module}.CALevelCurve");
                    ReservoirData.CaLevel = LevelCurveManager.Instance.CalculateLevelByWaterLevel(ReservoirData.CaWaterLevel, caLevelCurve);
                }
            }
            if (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
        }
        /// <summary>
        /// 写变量
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        private bool WriteVariableValue(string variable, object value)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{variable}");
            return IOModuleManager.Instance.WriteIoValue(ioName, value);
        }


        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        protected virtual bool OnTimer()
        {
            //CalculateCALevel();
            //WaterLevelMonitor();
            //DireplenMonitor();
            return true;
        }
        #region timer
        /// <summary>
        /// 计算CA
        /// </summary>
        private void CalculateCALevel()
        {
            if (ReservoirData != null)
            {
                if (_CALevelSamples.Count >= _levelSampleCount)
                {
                    _CALevelSamples.Dequeue();
                    _CALevelSamples.Enqueue(ReservoirData.CaLevel);
                }
                else
                {
                    _CALevelSamples.Enqueue(ReservoirData.CaLevel);
                }
                _avgCALevel = _CALevelSamples.Count > 0 ? _CALevelSamples.Average() : 0;
            }
        }

        /// <summary>
        /// WaterLevel监控
        /// </summary>
        protected virtual void WaterLevelMonitor()
        {
            _caWaterLevelLowerTrigger.CLK = IsCALowLevel;
            if (_caWaterLevelLowerTrigger.Q)
            {
                ReservoirEntity reservoirEntity = Singleton<RouteManager>.Instance.GetModule<ReservoirEntity>(Module);

                string reason = $"Current CAWaterlevel:{ReservoirData.CaWaterLevel} is lower than  CALowLevel Config:{SC.GetValue<double>($"Reservoir.{Module}.CALowLevel")}";
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, reason);
                CALowLevelOperation();
                if (reservoirEntity.IsAuto && !AlarmListManager.Instance.IsContainDataError(Module, "CAWaterLevel"))
                {
                    AlarmListManager.Instance.AddDataError(Module,
                        $"CAWaterLevel", $"Current CAWaterlevel:{ReservoirData.CaWaterLevel} is lower than  CALowLevel Config:{SC.GetValue<double>($"Reservoir.{Module}.CALowLevel")}");
                }
                if (!reservoirEntity.IsError) reservoirEntity.PostMsg(ReservoirMsg.Error);
            }

            _caWaterLevelLowerTrigger.CLK = IsCAHighLevel;
            if (_caWaterLevelHighTrigger.Q)
            {
                HighLevelOperation();
            }
        }

        /// <summary>
        /// CA Low Level触发对应操作
        /// </summary>
        private void CALowLevelOperation()
        {
            ReservoirItem reservoirItem = ReservoirItemManager.Instance.GetReservoirItem(Module);
            if (_reservoirData.CaPumpEnable)
            {
                CAPumpOff("", null);
            }
            //禁用TC
            if (!string.IsNullOrEmpty(reservoirItem.TCID))
            {
                TemperatureController temperatureController = DEVICE.GetDevice<TemperatureController>(reservoirItem.TCID);
                if (temperatureController != null && temperatureController.TemperatureData.ControlOperationModel == (int)TemperatureEnumData.ENABLE)
                {
                    temperatureController.DisableOperation("", null);
                }
            }

            ReservoirEntity reservoirEntity = Singleton<RouteManager>.Instance.GetModule<ReservoirEntity>(Module);

            if (!reservoirEntity.IsError) reservoirEntity.PostMsg(ReservoirMsg.Error);
        }
        /// <summary>
        /// High Level Common Operation
        /// </summary>
        private void HighLevelOperation()
        {
            ReservoirEntity reservoirEntity = Singleton<RouteManager>.Instance.GetModule<ReservoirEntity>(Module);
            SystemFacilities systemFacilities = DEVICE.GetDevice<SystemFacilities>("System.Facilities");
            if (systemFacilities != null)
            {
                if (systemFacilities.DIFillEnable) systemFacilities.DiFillDisableOperation("DIFillDisableOpeartion", null);
                if (systemFacilities.DIReplenEnable) systemFacilities.DiReplenDisableOperation("DiReplenDisableOperation", null);

                if (_reservoirData.CaDiReplen)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                    CADiReplenOff("", null);
                }
            }
            if (!reservoirEntity.IsError) reservoirEntity.PostMsg(ReservoirMsg.Error);
            if (reservoirEntity.IsAuto && !AlarmListManager.Instance.IsContainDataError(Module, "CAWaterLevel"))
            {
                AlarmListManager.Instance.AddDataError(Module,
                    $"CAWaterLevel", $"Current CAWaterlevel:{ReservoirData.CaWaterLevel} is large than  CAHighLevel Config:{SC.GetValue<double>($"Reservoir.{Module}.CAHighLevel")}");
            }
        }
        /// <summary>
        /// Direplen监控
        /// </summary>
        private void DireplenMonitor()
        {
            var facilities = DEVICE.GetDevice<SystemFacilities>("System.Facilities");
            //补水监控
            if (_direplenHelper != null)
            {
                _direplenHelper.MonitorPeriodTime(ref _isDIReplenMaxTimeOut);
                if (!_isDIReplenMaxTimeOut && !_isDIReplenPerfillTimeOut && facilities.DIFillEnable)
                {
                    AutoDireplenMonitor();
                }
            }
        }
        /// <summary>
        /// 自动补水
        /// </summary>
        protected virtual void AutoDireplenMonitor()
        {
            if (_currentDireplenOperation == DiReplenOperation.ManualCADiReplen)
            {
                bool result = _direplenHelper.MonitorManualDiReplenComplete(_manualReplenSecond, CADiReplenOff, ref _isDIReplenMaxTimeOut);
                if (result)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                }
            }
            if (_currentDireplenOperation == DiReplenOperation.ManualANDiReplen)
            {
                bool result = _direplenHelper.MonitorManualDiReplenComplete(_manualReplenSecond, ANDiReplenOff, ref _isDIReplenMaxTimeOut);
                if (result)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                }
            }
            if (_currentDireplenOperation == DiReplenOperation.AutoCADiReplen)
            {
                AutoDiReplenMonitor(CADiReplenOff, _reservoirData.CaLevel, _resRecipe.ReservoirCALevel, _resRecipe.DIReplenEnable,
                    _resRecipe.DIReplenTimeRate, _resRecipe.DIReplenCurrentRate);
            }
            if (_currentDireplenOperation == DiReplenOperation.AutoANDiReplen) //阳极没有水位，自动补水监控逻辑待修正
            {
          
            }
        }
        /// <summary>
        /// 自动注水监控
        /// </summary>
        /// <param name="direplenOff"></param>
        /// <param name="level"></param>
        /// <param name="recipeLevel"></param>
        private void AutoDiReplenMonitor(Func<string, object[], bool> direplenOff, double level, double recipeLevel, bool replenEnable,
            int direplenTimeRate, int direplenCurrentRate)
        {
            bool result = _direplenHelper.AutoDiReplenMonitorTimeOut(direplenOff, ref _isDIReplenMaxTimeOut, ref _isDIReplenPerfillTimeOut);
            if (result)
            {
                _currentDireplenOperation = DiReplenOperation.None;
            }
            else
            {
                //按液位补水
                result = _direplenHelper.AutoDiReplenMonitorComplete(level, recipeLevel, replenEnable, direplenTimeRate, direplenCurrentRate, direplenOff);
                if (result)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                }
            }
        }

        #endregion

        #region Mode switch
        /// <summary>
        /// DisabledAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DisabledOperation(string cmd, object[] args)
        {
            string currentOperation = "Disabled";
            string preOperation = _persistentValue.OperatingMode;
            _persistentValue.OperatingMode = currentOperation;

            LOG.WriteLog(eEvent.INFO_RESERVOIR, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            
            ReservoirsPersistentManager.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";
            string preOperation = _persistentValue.OperatingMode;
            
            _persistentValue.OperatingMode = currentOperation;

            LOG.WriteLog(eEvent.INFO_RESERVOIR, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            
            ReservoirsPersistentManager.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";
            string preOperation = _persistentValue.OperatingMode;

            _persistentValue.OperatingMode = currentOperation;

            LOG.WriteLog(eEvent.INFO_RESERVOIR, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            
            ReservoirsPersistentManager.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";
            if (_persistentValue != null)
            {
                _persistentValue.RecipeOperatingMode = currentRecipeOperation;
            }
            ReservoirsPersistentManager.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";
            if (_persistentValue != null)
            {
                _persistentValue.RecipeOperatingMode = currentRecipeOperation;
            }
            ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        #endregion
        
        /// <summary>
        /// 加载Recipe
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool LoadRecipeOperation(string cmd, object[] args)
        {
            _persistentValue.Recipe = args[0].ToString();
            string[] fileRoute = _persistentValue.Recipe.Split('\\');
            string recipeRoute = "";
            if (fileRoute.Length > 2)
            {
                recipeRoute = fileRoute[fileRoute.Length - 2];
            }
            _resRecipe = RecipeFileManager.Instance.LoadGenericityRecipe<ResRecipe>(_persistentValue.Recipe);
            ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module.ToString());
            LOG.WriteLog(eEvent.INFO_RESERVOIR, Module.ToString(), $"Load {recipeRoute} Recipe {_resRecipe.Ppid} Success");
            return true;
        }
   

        /// <summary>
        /// 监控
        /// </summary>
        public void Monitor()
        {
        }
        #region CA Pump
        /// <summary>
        /// CA Pump调速
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool CAPumpSpeedOperation(string cmd, object[] args)
        {
            double caMaxPumpSpeed = 0;
            if (SC.ContainsItem("Reservoir.CAMaxPumpSpeed"))
            {
                caMaxPumpSpeed = SC.GetValue<double>("Reservoir.CAMaxPumpSpeed");
            }
            if (double.TryParse(args[0].ToString(), out double speed))
            {
                _caPumpSpeed = speed;
                if (_caPumpSpeed > caMaxPumpSpeed)
                {
                    LOG.WriteLog(eEvent.WARN_METAL, Module, $"CA pump speed:{_caPumpSpeed} is over CA max pump speed {caMaxPumpSpeed}!");
                    return false;
                }
                return CAPumpSpeed(_caPumpSpeed);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, $"{args[0]} is nor invalid speed");
                return false;
            }
        }
        /// <summary>
        /// 设置阴极泵速
        /// </summary>
        /// <param name="caPumpSpeed"></param>
        /// <returns></returns>
        public bool CAPumpSpeed(double caPumpSpeed)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CA_PUMP_SPEED}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, caPumpSpeed);
        }
        /// <summary>
        /// 阴极Pump On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool CAPumpOn(string cmd, object[] args)
        {
            double caPumpSpeed = SC.GetValue<double>("Reservoir.CADefaultPumpSpeed");
            bool result = CAPumpSpeed(caPumpSpeed);
            if (result)
            {
                string enableIOName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CA_PUMP_ENABLE}");
                return BeckhoffIOManager.Instance.WriteIoValue(enableIOName, true);
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 阴极Pump Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool CAPumpOff(string cmd, object[] args)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CA_PUMP_ENABLE}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, false);
        }

        #endregion

        #region Return Valve
        /// <summary>
        /// Return Valve
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ReturnValvePercentOperation(string cmd, object[] args)
        {
            if (double.TryParse(args[0].ToString(), out double percent))
            {
                _returnValvePercent = percent;
                return ReturnValvePercent(_returnValvePercent);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, $"{args[0]} is invalid percent");
                return false;
            }
        }
        /// <summary>
        /// 设置比例
        /// </summary>
        /// <param name="caPumpSpeed"></param>
        /// <returns></returns>
        public bool ReturnValvePercent(double percent)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{RETURN_VALVE_OPENING}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, percent);
        }
        /// <summary>
        /// Return Valve On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ReturnValveOn(string cmd, object[] args)
        {
            double percent = SC.GetValue<double>("Reservoir.ReturnOpenDefaultPercentage");
            bool result = ReturnValvePercent(percent);
            if (result)
            {
                //string enableIOName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{RETURN_VALVE}");
                //return BeckhoffIOManager.Instance.WriteIoValue(enableIOName, true);
                return WriteVariableValue(RETURN_VALVE, true);
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Return Valve Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool ReturnValveOff()
        {
            //string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{RETURN_VALVE}");
            //return BeckhoffIOManager.Instance.WriteIoValue(ioName, false);
            return WriteVariableValue(RETURN_VALVE, false);
        }
        #endregion
        
        /// <summary>
        /// ANIsolationOn
        /// </summary>
        /// <returns></returns>
        public bool ANIsolationOn()
        {
            return WriteVariableValue(AN_ISOLATION, true);
        }
        /// <summary>
        /// ANIsolationOff
        /// </summary>
        /// <returns></returns>
        public bool ANIsolationOff()
        {
            return WriteVariableValue(AN_ISOLATION, false);
        }
        /// <summary>
        /// CAIsolationOn
        /// </summary>
        /// <returns></returns>
        public bool CAIsolationOn()
        {
            return WriteVariableValue(CA_ISOLATION, true);
        }
        /// <summary>
        /// CAIsolationOff
        /// </summary>
        /// <returns></returns>
        public bool CAIsolationOff()
        {
            return WriteVariableValue(CA_ISOLATION, false);
        }
        /// <summary>
        /// DegasValveOn
        /// </summary>
        /// <returns></returns>
        public bool DegasValveOn()
        {
            return WriteVariableValue(DEGAS_ENABLE, true);
        }
        /// <summary>
        /// DegasValveOff
        /// </summary>
        /// <returns></returns>
        public bool DegasValveOff()
        {
            return WriteVariableValue(DEGAS_ENABLE, false);
        }
        /// <summary>
        /// HedValveOn
        /// </summary>
        /// <returns></returns>
        public bool HedValveOn()
        {
            return WriteVariableValue(HED_FLOW_ENABLE, true);
        }
        /// <summary>
        /// HedValveOff
        /// </summary>
        /// <returns></returns>
        public bool HedValveOff()
        {
            return WriteVariableValue(HED_FLOW_ENABLE, false);
        }
        /// <summary>
        /// PhValveOn
        /// </summary>
        /// <returns></returns>
        public bool PhValveOn()
        {
            return WriteVariableValue(PH_FLOW_VALVE, true);
        }
        /// <summary>
        /// PhValveOff
        /// </summary>
        /// <returns></returns>
        public bool PhValveOff()
        {
            return WriteVariableValue(PH_FLOW_VALVE, false);
        }
        /// <summary>
        /// SampleOutValveOn
        /// </summary>
        /// <returns></returns>
        public bool SampleOutValveOn()
        {
            return WriteVariableValue(SAMPLE_OUT, true);
        }
        /// <summary>
        /// SampleOutValveOff
        /// </summary>
        /// <returns></returns>
        public bool SampleOutValveOff()
        {
            return WriteVariableValue(SAMPLE_OUT, false);
        }

        #region CA DiReplen
        /// <summary>
        /// 阴极DI Replen On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool CADiReplenOnOperation(string cmd, object[] args)
        {
            return CADiReplenOn();
        }
        /// <summary>
        /// 阴极DI Replen On
        /// </summary>
        /// <param name="showError"></param>
        /// <returns></returns>
        private bool CADiReplenOn()
        {
            bool preCondition = CheckPreDiReplenCondition();
            if (!preCondition)
            {
                return false;
            }
            if (IsCAHighLevel)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"CAHighLevel is activate,Can't do CA_DIReple");
                return false;
            }
            if (IsCALowLevel)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"CALowLevel is activate,Can't do CA_DIReple");
                return false;
            }
            if (ReservoirData.AnDiReplen)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, "ANDiReplen is on");
                return false;
            }
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CA_DI_REPLEN}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, true);
        }

        /// <summary>
        /// 阴极DI Replen Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool CADiReplenOff(string cmd, object[] args)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CA_DI_REPLEN}");
            bool result = BeckhoffIOManager.Instance.WriteIoValue(ioName, false);
            if (result)
            {
                _persistentValue.IsDiReplenOn = false;
                if (_currentDireplenOperation == DiReplenOperation.ManualCADiReplen || _currentDireplenOperation == DiReplenOperation.AutoCADiReplen)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                    _persistentValue.LastTotalReplen = _persistentValue.TotalReplen;
                    ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module);
                }
            }
            return result;
        }

        /// <summary>
        /// 检验DiReplen前置条件
        /// </summary>
        /// <returns></returns>
        public bool CheckPreDiReplenCondition()
        {
            if (!CheckFacilitiesDiReplenStatus())
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, "Facilities DiReplen is Off, can't start auto diReplen");
                return false;
            }
            SafetyDevice safetyDevice = DEVICE.GetDevice<SafetyDevice>("Safety");
            if (safetyDevice != null && safetyDevice.SafetyData.Reservoir1CALevelHigh)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"Safety high is Activate, can't start auto diReplen");
                return false;
            }
            if (CheckOtherReservoirDiReplenStatus())
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 检验总Di有没有开
        /// </summary>
        /// <returns></returns>
        private bool CheckFacilitiesDiReplenStatus()
        {
            SystemFacilities systemFacilities = DEVICE.GetDevice<SystemFacilities>("System.Facilities");
            if (systemFacilities != null)
            {
                return systemFacilities.DIReplenEnable;
            }
            return false;
        }
        /// <summary>
        /// 检验是否其他Reservoir Direplen已经
        /// </summary>
        /// <returns></returns>
        protected bool CheckOtherReservoirDiReplenStatus()
        {
            List<string> reservoirs = ReservoirItemManager.Instance.InstalledModules;
            foreach (string item in reservoirs)
            {
                if (item != Module)
                {
                    ReservoirDevice tmpDevice = DEVICE.GetDevice<ReservoirDevice>(item);
                    if (tmpDevice.ReservoirData.CaDiReplen)
                    {
                        return true;
                    }
                    ReservoirItem reservoirItem = ReservoirItemManager.Instance.GetReservoirItem(item);
                    if (reservoirItem.SubType == ReservoirType.DegasMembrance.ToString())
                    {
                        if (tmpDevice.ReservoirData.AnDiReplen)
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
        #endregion

        #region AN DiReplen
        /// <summary>
        /// 阳极DI Replen On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ANDiReplenOnOperation(string cmd, object[] args)
        {
            return ANDiReplenOn();
        }
        /// <summary>
        /// 阳极DI Replen On
        /// </summary>
        /// <param name="showError"></param>
        /// <returns></returns>
        private bool ANDiReplenOn()
        {
            bool preCondition = CheckPreDiReplenCondition();
            if (!preCondition)
            {
                return false;
            }
            if (IsANHighLevel)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"ANHighLevel is activate,Can't do AN_DIReple");
                return false;
            }
            if (IsANLowLevel)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"ANLowLevel is activate,Can't do AN_DIReple");
                return false;
            }
            if (ReservoirData.CaDiReplen)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, "CADiReplen is on");
                return false;
            }
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_DI_REPLEN}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, true);
        }

        /// <summary>
        /// 阳极DI Replen Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ANDiReplenOff(string cmd, object[] args)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_DI_REPLEN}");
            bool result = BeckhoffIOManager.Instance.WriteIoValue(ioName, false);
            if (result)
            {
                _persistentValue.IsDiReplenOn = false;
                if (_currentDireplenOperation == DiReplenOperation.ManualANDiReplen || _currentDireplenOperation == DiReplenOperation.AutoANDiReplen)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                    _persistentValue.LastTotalReplen = _persistentValue.TotalReplen;
                    ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module);
                }
            }
            return result;
        }

        #endregion

        #region DiReplen Operation
        /// <summary>
        /// 重置时长
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="objs"></param>
        /// <returns></returns>
        private bool ResetTotalTime(string cmd, object[] objs)
        {
            _isDIReplenMaxTimeOut = false;
            _persistentValue.TotalReplen = 0;
            _persistentValue.LastTotalReplen = 0;
            ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// 手动阴极注水
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ManualCADiReplen(string cmd, object[] args)
        {
            return ManualDiReplen(CADiReplenOnOperation, DiReplenOperation.ManualCADiReplen, args[0].ToString());
        }
        /// <summary>
        /// 手动阳极注水
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ManualANDiReplen(string cmd, object[] args)
        {
            return ManualDiReplen(ANDiReplenOnOperation, DiReplenOperation.ManualANDiReplen, args[0].ToString());
        }
        /// <summary>
        /// 手动注水
        /// </summary>
        /// <param name="direplenOn"></param>
        /// <param name="direplenOperation"></param>
        /// <returns></returns>
        private bool ManualDiReplen(Func<string, object[], bool> direplenOn, DiReplenOperation direplenOperation, string timeLength)
        {
            if (_currentDireplenOperation != DiReplenOperation.None)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"current operation is {_currentDireplenOperation},cannot execute {direplenOperation}");
                return false;
            }
            ReservoirEntity reservoirEntity = Singleton<RouteManager>.Instance.GetModule<ReservoirEntity>(Module);
            if (!reservoirEntity.IsInitialized)
            {
                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} is not initialized. Can't start DiReplen");
                return false;
            }
            if (_isDIReplenMaxTimeOut)
            {
                double diValveMaxOnTime = SC.GetValue<double>($"Reservoir.{Module}.DIValveMaxOnTime");
                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"Direplen time over conifg's DIValveMaxOnTime:{diValveMaxOnTime} min");
                return false;
            }
            if (_isDIReplenPerfillTimeOut)
            {
                double diValveMaxOnTimePerFill = SC.GetValue<double>($"Reservoir.{Module}.DIValveMaxOnTimePerFill");
                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"Direplen time over conifg's DIValveMaxOnTimePerFill:{diValveMaxOnTimePerFill} min");
                return false;
            }
            bool result = direplenOn("", null);
            if (result)
            {
                _currentDireplenOperation = direplenOperation;
                _persistentValue.DiReplenTime = DateTime.Now;
                ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module);
                int.TryParse(timeLength, out _manualReplenSecond);
            }
            return result;
        }
        /// <summary>
        /// 阴极自动流水
        /// </summary>
        /// <returns></returns>
        public bool AutoCADiReplen()
        {
            if (IsCALowLevel)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"CALowLevel is activate,Can't AutoANDireplen");
                return false;
            }
            return AutoDireplen(CADiReplenOn, DiReplenOperation.AutoCADiReplen);
        }

        /// <summary>
        /// 自动注水
        /// </summary>
        /// <returns></returns>
        protected bool AutoDireplen(Func<bool> direplenOn, DiReplenOperation reservoirOperation)
        {
            if (_currentDireplenOperation != DiReplenOperation.None)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"current operation is {_currentDireplenOperation},cannot execute {reservoirOperation}");
                return false;
            }
            if (_resRecipe == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"recipe is null");
                return false;
            }
            bool result = direplenOn();
            if (result)
            {
                _currentDireplenOperation = reservoirOperation;
                _persistentValue.DiReplenTime = DateTime.Now;
            }
            return result;
        }
        #endregion

        /// <summary>
        /// 检验阴极是否highlevel
        /// </summary>
        public bool CheckCAHighLevelStatus()
        {
            return ReservoirData.CaWaterLevel > SC.GetValue<double>($"Reservoir.{Module}.CAHighLevel") ? true : false;
        }
        /// <summary>
        /// 检验阴极是否lowlevel
        /// </summary>
        public bool CheckCALowLevelStatus()
        {
            return ReservoirData.CaWaterLevel < SC.GetValue<double>($"Reservoir.{Module}.CALowLevel") ? true : false;
        }


        public void Reset()
        {
        }

        public void Terminate()
        {
        }
        protected enum DiReplenOperation
        {
            None,
            ManualANDiReplen,
            ManualCADiReplen,
            AutoANDiReplen,
            AutoCADiReplen
        }

    }
}