PunkHPX8/PunkHPX8_RT/Devices/Reservoir/DMReservoirDevice.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.Reservoir;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.Persistent.Temperature;
using MECF.Framework.Common.TwinCat;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Devices.Reservoir
{
    public class DMReservoirDevice : ReservoirDevice
    {
        #region 常量
        private const string AN_PUMP = "ANPump";
        #endregion
        #region 内部变量
        /// <summary>
        /// 默认泵速
        /// </summary>
        private double _anPumpSpeed = 5000;
        /// <summary>
        /// an泵速Helper
        /// </summary>
        private ReservoirANPumpSpeedHelper _anPumpSpeedHelper;

        #endregion

        #region 属性
        /// <summary>
        /// 检验阳极是否highlevel
        /// </summary>
        public bool IsANHighLevel { get { return _reservoirData.AnTowerHigh; } }
        /// <summary>
        /// 检验阳极是否lowlevel
        /// </summary>
        public bool IsANLowLevel { get { return _reservoirData.AnTowerLow; } }
        /// <summary>
        /// 阳极是否需要补水
        /// </summary>
        public bool AnNeedDireplen { get { return CheckANNeedDiReplen(); } }
        #endregion

        #region Trigger
        /// <summary>
        /// low WaterLevel trigger
        /// </summary>
        private R_TRIG _anWaterLevelLowerTrigger = new R_TRIG();
        /// <summary>
        /// low WaterLevel trigger
        /// </summary>
        private R_TRIG _anWaterLevelHighTrigger = new R_TRIG();
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public DMReservoirDevice(string moduleName) : base(moduleName)
        {
            _anPumpSpeedHelper = new ReservoirANPumpSpeedHelper(Module, this);
        }
        /// <summary>
        /// 订阅变量
        /// </summary>
        protected override void SubscribeValueAction()
        {
            base.SubscribeValueAction();
            IoSubscribeUpdateVariable(AN_DI_REPLEN);
            IoSubscribeUpdateVariable(AN_FLOW);
            IoSubscribeUpdateVariable(AN_PUMP_ENABLE);
            IoSubscribeUpdateVariable(AN_PUMP_SPEED);
            IoSubscribeUpdateVariable(DEGAS_ENABLE);
        }
        /// <summary>
        /// 订阅Data
        /// </summary>
        protected override void SubscribeData()
        {
            base.SubscribeData();
            DATA.Subscribe($"{Module}.IsManualANReplen", () => { return _currentDireplenOperation == DiReplenOperation.ManualANDiReplen; }, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 订阅Operation
        /// </summary>
        protected override void InitializeOperation()
        {
            base.InitializeOperation(); 
            OP.Subscribe($"{Module}.ANPumpEnable", AnPumpOnOperation);
            OP.Subscribe($"{Module}.ANPumpSpeed", ANPumpSpeedOperation);
            OP.Subscribe($"{Module}.ANPumpDisable", AnPumpOffOperation);
            OP.Subscribe($"{Module}.ANIsolationOn", (cmd, para) => { return ANIsolationOn(); });
            OP.Subscribe($"{Module}.ANIsolationOff", (cmd, para) => { return ANIsolationOff(); });

            OP.Subscribe($"{Module}.ANDiReplenOn", ANDiReplenOnOperation);
            OP.Subscribe($"{Module}.ANDiReplenOff", ANDiReplenOff);

            OP.Subscribe($"{Module}.ManualANDiReplen", ManualANDiReplen);
        }

        #region AnPump
        /// <summary>
        /// AN Pump调速
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ANPumpSpeedOperation(string cmd, object[] args)
        {
            double anMaxPumpSpeed = 0;
            if (SC.ContainsItem("Reservoir.ANMaxPumpSpeed"))
            {
                anMaxPumpSpeed = SC.GetValue<double>("Reservoir.ANMaxPumpSpeed");
            }
            if (double.TryParse(args[0].ToString(), out double speed))
            {
                _anPumpSpeed = speed;
                if (_anPumpSpeed > anMaxPumpSpeed)
                {
                    LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"AN pump speed:{_anPumpSpeed} is over AN max pump speed {anMaxPumpSpeed}!");
                    return false;
                }
                return AnPumpSpeed(_anPumpSpeed);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{args[0]} is nor invalid speed");
                return false;
            }
        }
        /// <summary>
        /// 设置AN泵速
        /// </summary>
        /// <param name="caPumpSpeed"></param>
        /// <returns></returns>
        public bool AnPumpSpeed(double anPumpSpeed)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_PUMP_SPEED}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, anPumpSpeed);
        }
        /// <summary>
        /// 阳极Pump On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool AnPumpOnOperation(string cmd, object[] args)
        {
            double caPumpSpeed = SC.GetValue<double>("Reservoir.ANDefaultPumpSpeed");
            bool result = AnPumpSpeed(caPumpSpeed);
            if (result)
            {
                string enableIOName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_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 AnPumpOffOperation(string cmd, object[] args)
        {
            return AnPumpOff();
        }
        /// <summary>
        /// 关闭阳极Pump
        /// </summary>
        /// <returns></returns>
        public bool AnPumpOff()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_PUMP_ENABLE}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, false);
        }
        /// <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);
        }
        #endregion


        protected override void AutoMonitor()
        {
            base.AutoMonitor();
            if (_persistentValue.OperatingMode == AUTO)
            {
                _anPumpSpeedHelper.Monitor(_resRecipe);
            }
        }
        /// <summary>
        /// 水位监控
        /// </summary>
        protected override void WaterLevelMonitor()
        {
            base.WaterLevelMonitor();
            //增加AN tower监控逻辑
            _anWaterLevelLowerTrigger.CLK = _reservoirData.AnTowerLow;
            _anWaterLevelHighTrigger.CLK = _reservoirData.AnTowerHigh;
            if (_anWaterLevelLowerTrigger.Q  && !Recipe.ANDIReplenEnable)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"AN tower low is activate and recipe ANDIReplenEnable is false");
            }
            if (_anWaterLevelHighTrigger.Q && !Recipe.ANDIReplenEnable)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"AN tower high is activate and recipe ANDIReplenEnable is false");
            }
        }
        /// <summary>
        /// 补水监控,用于关闭自动补水
        /// </summary>
        protected override void AutoDireplenMonitor()
        {
            base.AutoDireplenMonitor();
            if (_currentDireplenOperation == DiReplenOperation.ManualANDiReplen)
            {
                bool result = _direplenHelper.MonitorManualDiReplenComplete(_manualReplenSecond, ANDiReplenOff, ref _isDIReplenMaxTimeOut);
                if (result)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                }
            }
            if (_currentDireplenOperation == DiReplenOperation.AutoANDiReplen)
            {
                AutoANDiReplenMonitor(ANDiReplenOff, _resRecipe.ANDIReplenEnable,  _resRecipe.ANDIReplenTimeRate, _resRecipe.ANDIReplenCurrentRate);
            }
        }

        /// <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;
        }
        /// <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>
        /// <returns></returns>
        private bool CheckANNeedDiReplen()
        {
            if (IsAuto && _resRecipe != null)
            {
                if (_resRecipe.ANDIReplenEnable && _resRecipe.ANDIReplenCurrentRate == 0 && _resRecipe.ANDIReplenTimeRate == 0)
                {
                    return _reservoirData.AnTowerLow;
                }
                return false;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 阳极自动注水
        /// </summary>
        /// <returns></returns>
        public bool AutoANDiReplen()
        {
            return AutoDireplen(ANDiReplenOn, DiReplenOperation.AutoANDiReplen);
        }

        /// <summary>
        /// 阳极自动注水监控
        /// </summary>
        /// <param name="direplenOff"></param>
        /// <param name="level"></param>
        /// <param name="recipeLevel"></param>
        private void AutoANDiReplenMonitor(Func<string, object[], bool> direplenOff, bool replenEnable, int direplenTimeRate, int direplenCurrentRate)
        {
            //判断是否注水超时（包括单次和累计）
            bool result = _direplenHelper.AutoDiReplenMonitorTimeOut(direplenOff, ref _isDIReplenMaxTimeOut, ref _isDIReplenPerfillTimeOut);
            if (result)
            {
                _currentDireplenOperation = DiReplenOperation.None;
            }
            else
            {
                //按液位补水
                result = AutoANDiReplenMonitorComplete(replenEnable, direplenTimeRate, direplenCurrentRate, direplenOff);
                if (result)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                }
            }
        }

        /// <summary>
        ///  阳极自动注水是否结束
        /// </summary>
        /// <param name="replenEnable"></param>
        /// <param name="direplenTimeRate"></param>
        /// <param name="direplenCurrentRate"></param>
        /// <param name="direplenOffAction"></param>
        /// <returns></returns>
        private bool AutoANDiReplenMonitorComplete(bool replenEnable, int direplenTimeRate, int direplenCurrentRate, Func<string, object[], bool> direplenOffAction)
        {
            if (replenEnable && direplenTimeRate == 0 && direplenCurrentRate == 0 && ReservoirData.AnTowerHigh)
            {
                LOG.WriteLog(eEvent.INFO_RESERVOIR, Module, "Auto AN DiReplen complete");
                bool result = direplenOffAction("", null);
                if (result)
                {
                    _persistentValue.LastTotalReplen = _persistentValue.TotalReplen;
                    _persistentValue.IsDiReplenOn = false;
                    ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module);
                    return result;
                }
            }
            return false;
        }

    }
}