CyberX8/CyberX8_RT/Devices/Prewet/PrewetDevice.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.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Algorithm;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.Prewet;
using MECF.Framework.Common.Persistent.Prewet;
using MECF.Framework.Common.TwinCat;
using CyberX8_Core;
using System;
using System.Collections.Generic;
using System.Reflection;
using CyberX8_RT.Modules;
using CyberX8_RT.Modules.Prewet;
using CyberX8_RT.Modules.Metal;
using MECF.Framework.Common.Persistent.Temperature;
using MECF.Framework.Common.IOCore;

namespace CyberX8_RT.Devices.Prewet
{
    public class PrewetDevice : BaseDevice, IDevice
    {
        private enum PrewetOperation
        {
            None,
            PumpEnable,
            PumpDisable
        }
        #region 常量 
        private const string PUMP_VALVE = "PumpValve";
        private const string PUMP_ENABLE = "PumpEnable";
        private const string PUMP_SPEED = "PumpSpeed";
        private const string PUMP_STAUS = "PumpStatus";
        private const string PUMP_CURRENT = "PumpCurrent";
        private const string PUMP_FLOW = "PumpFlow";
        private const string PUMP_PRESSURE = "PumpPressure";
        private const string PUMP_DATA = "PumpData";
        private const string PERSISTENT_VALUE = "PersistentValue";
        #endregion

        #region 内部变量
        /// <summary>
        /// 数据
        /// </summary>
        private PrewetPumpData _prewetPumpData=new PrewetPumpData();
        /// <summary>
        /// pdi控制中的p
        /// </summary>
        private double _pumpKp;
        /// <summary>
        /// pdi控制中的i
        /// </summary>
        private double _pumpKi;
        /// <summary>
        /// pdi控制中的d
        /// </summary>
        private double _pumpKd;
        /// <summary>
        /// 操作当前状态
        /// </summary>
        private RState _status;
        /// <summary>
        /// 当前操作
        /// </summary>
        private PrewetOperation _currentOperation;
        /// <summary>
        /// Prewet 持久性数值对象
        /// </summary>
        private PrewetPersistentValue _prewetPersistentValue;
        /// <summary>
        /// Pump Enable routine
        /// </summary>
        private PrewetPumpEnableRoutine _prewetPumpEnableRoutine;
        /// <summary>
        /// Pump Disable routine
        /// </summary>
        private PrewetPumpDisableRoutine _prewetPumpDisableRoutine;
        /// <summary>
        /// 上一次Pump速度
        /// </summary>
        private short _lastPumpSpeed;
        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();
        /// <summary>
        /// 定时器Job
        /// </summary>
        PeriodicJob _periodicJob = null;
        /// <summary>
        /// Run recipe total time
        /// </summary>
        public int _runRecipeTotalTime;
        #endregion

        #region 属性
        /// <summary>
        /// Pump 数据
        /// </summary>
        public PrewetPumpData PrewetPumpData { get { return _prewetPumpData; } }
        /// <summary>
        /// 操作当前状态
        /// </summary>
        public RState Status { get { return _status; } }
        /// <summary>
        /// 所有io变量是否初始化
        /// </summary>
        public bool IOInitialized { get { return AllIoVariableInitialized(); } }
        /// <summary>
        /// Last Pump Speed
        /// </summary>
        public short LastPumpSpeed { get { return _lastPumpSpeed; } }
        /// 是否启动调速
        /// </summary>
        public bool IsStartAutoSpeed { get; set; }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="name"></param>
        public PrewetDevice(string moduleName) : base(moduleName, moduleName,moduleName,moduleName)
        {
            _prewetPumpData = new PrewetPumpData();
            _prewetPumpData.PumpPressureData = new MECF.Framework.Common.CommonData.CommonLimitData();
            _prewetPumpData.PumpFlowData = new MECF.Framework.Common.CommonData.CommonLimitData();
            _periodicJob = new PeriodicJob(100, OnTimer, $"{Module}.OnTimer", true);
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeParameter();
            InitializeRoutine();
            SubscribeData();
            SubscribeValueAction();
            InitializeOperation();
            return true;
        }
        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            _prewetPersistentValue = PrewetPersistentManager.Instance.GetPrewetPersistentValue(Module);
            if (_prewetPersistentValue != null)
            {
                _lastPumpSpeed = _prewetPersistentValue.Speed;
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_PREWET, Module, "Persistent Value Object is not exist");
            }

        }

        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _prewetPumpEnableRoutine = new PrewetPumpEnableRoutine(Module, this, _prewetPersistentValue);
            _prewetPumpDisableRoutine = new PrewetPumpDisableRoutine(Module, this, _prewetPersistentValue);
        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeData()
        {
            DATA.Subscribe($"{Module}.{PERSISTENT_VALUE}", () => _prewetPersistentValue, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{PUMP_DATA}", () => PrewetPumpData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.OfTotalTime", () => _runRecipeTotalTime ,SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpStatus", () => PrewetPumpData.PumpStatus, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpCurrent",()=>PrewetPumpData.PumpCurrent,SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpSpeed", () => _lastPumpSpeed, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpEnable", () => PrewetPumpData.PumpEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpValve", () => PrewetPumpData.PumpValve, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpFlow", () => PrewetPumpData.PumpFlowData.Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpFlow.MinWarning", () => PrewetPumpData.PumpFlowData.MinWarning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpFlow.MaxWarning", () => PrewetPumpData.PumpFlowData.MaxWarning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpFlow.MinError", () => PrewetPumpData.PumpFlowData.MinError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpFlow.MaxError", () => PrewetPumpData.PumpFlowData.MaxError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpPressure", () => PrewetPumpData.PumpPressureData.Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpPressure.MinWarning", () => PrewetPumpData.PumpPressureData.MinWarning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpPressure.MaxWarning", () => PrewetPumpData.PumpPressureData.MaxWarning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpPressure.MinError", () => PrewetPumpData.PumpPressureData.MinError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.PumpPressure.MaxError", () => PrewetPumpData.PumpPressureData.MaxError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.TargetPressure", () => PrewetPumpData.PressureTarget, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 订阅变量数值发生变化
        /// </summary>
        private void SubscribeValueAction()
        {
            BeckhoffIoSubscribeUpdateVariable( PUMP_VALVE);
            BeckhoffIoSubscribeUpdateVariable( PUMP_ENABLE);
            BeckhoffIoSubscribeUpdateVariable( PUMP_STAUS);
            BeckhoffIoSubscribeUpdateVariable( PUMP_CURRENT);
            BeckhoffIoSubscribeUpdateVariable( PUMP_PRESSURE);
            BeckhoffIoSubscribeUpdateVariable( PUMP_FLOW);
        }
        /// <summary>
        /// 订阅IO变量
        /// </summary>
        /// <param name="variable"></param>
        private void BeckhoffIoSubscribeUpdateVariable(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 (!PrewetPumpData.IsDataInitialized)
            {
                PrewetPumpData.IsDataInitialized = true;
                PrewetPumpData.PumpModel = "Manual";
            }
            PropertyInfo property = PrewetPumpData.GetType().GetProperty(variable);
            if (property != null)
            {
                property.SetValue(PrewetPumpData, value);
            }
            if (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
            switch (variable)
            {
                case PUMP_STAUS:
                    string statusContent = PrewetPumpData.PumpStatus ? "On" : "Off";
                    PrewetPumpData.PumpStatusContent = $"{PrewetPumpData.PumpModel}: {statusContent}";
                    break;
                case PUMP_FLOW:
                    if (double.TryParse(value.ToString(), out var flow))
                    {
                        PrewetPumpData.PumpFlowData.Value = flow;
                    }
                    break;
                case PUMP_PRESSURE:
                    if(double.TryParse(value.ToString(),out var pressure))
                    {
                        PrewetPumpData.PumpPressureData.Value = pressure;
                    }
                    break;
            }
        }
        /// <summary>
        /// 是否所有IO变量初始化完成
        /// </summary>
        /// <returns></returns>
        private bool AllIoVariableInitialized()
        {
            foreach (string item in _variableInitializeDic.Keys)
            {
                if (!_variableInitializeDic[item])
                {
                    LOG.WriteLog(eEvent.ERR_PREWET, Module, $"{item} is not initialized");
                    return false;
                }
            }
            return true;
        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.PumpValveOn", PumpValveOnOperation);
            OP.Subscribe($"{Module}.PumpValveOff", PumpValveOffOperation);
            OP.Subscribe($"{Module}.PumpEnable", PumpEnableOperation);
            OP.Subscribe($"{Module}.PumpDisable", PumpDisableOperation);
            OP.Subscribe($"{Module}.PumpSpeedManual", PumpSpeedManualOperation);
            OP.Subscribe($"{Module}.PumpSpeedAuto", PumpSpeedAutoOperation);
            OP.Subscribe($"{Module}.PumpSpeedKeyDown", PumpSpeedKeyDownOperation);
            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()
        {
            PrewetPumpData.PumpFlowData.MinError = SC.GetValue<double>($"Prewet.PumpFlow.Error_Min");
            PrewetPumpData.PumpFlowData.MinWarning = SC.GetValue<double>($"Prewet.PumpFlow.Warning_Min");
            PrewetPumpData.PumpFlowData.MaxError = SC.GetValue<double>($"Prewet.PumpFlow.Error_Max");
            PrewetPumpData.PumpFlowData.MaxWarning = SC.GetValue<double>($"Prewet.PumpFlow.Warning_Max");

            PrewetPumpData.PumpPressureData.MinError = SC.GetValue<double>($"Prewet.PumpPressure.Error_Min");
            PrewetPumpData.PumpPressureData.MinWarning = SC.GetValue<double>($"Prewet.PumpPressure.Warning_Min");
            PrewetPumpData.PumpPressureData.MaxError = SC.GetValue<double>($"Prewet.PumpPressure.Error_Max");
            PrewetPumpData.PumpPressureData.MaxWarning = SC.GetValue<double>($"Prewet.PumpPressure.Warning_Max");
            PrewetPumpData.PressureTarget = SC.GetValue<double>($"Prewet.PressureTarget");

            if (_status == RState.Running)
            {
                IRoutine routine = GetCurrentRoutine();
                if (routine != null)
                {
                    RState rsState = routine.Monitor();
                    if (rsState == RState.Failed || rsState == RState.Timeout)
                    {
                        _status = RState.Failed;
                        _currentOperation = PrewetOperation.None;
                        LOG.WriteLog(eEvent.ERR_LINMOT, Module.ToString(), $"{_currentOperation} error");
                        IsStartAutoSpeed = false;
                    }
                    else if (rsState == RState.End)
                    {
                        if (_currentOperation == PrewetOperation.PumpEnable)
                        {
                            IsStartAutoSpeed = true;
                        }
                        else
                        {
                            IsStartAutoSpeed = false;
                        }
                        _status = RState.End;
                        _currentOperation = PrewetOperation.None;                        
                    }
                }
            }

            if (IsStartAutoSpeed)
            {
                AdjustPumpSpeed();
            }
            return true;
        }
        /// <summary>
        /// 调速
        /// </summary>
        public void AdjustPumpSpeed()
        {
            //Speed Auto模式同时pump enbled,根据kdi调整泵速
            if (PrewetPumpData.PumpSpeedAuto && PrewetPumpData.PumpEnable)
            {
                _pumpKp = SC.GetValue<double>($"Prewet.PumpKp");
                _pumpKd = SC.GetValue<double>($"Prewet.PumpKd");
                _pumpKi = SC.GetValue<double>($"Prewet.PumpKi");
                double limit = SC.GetValue<double>("Prewet.PrewetTargetLimit");
                short speed = PdiAlgorithm.Instance.CalculateSpeed(_pumpKp, _pumpKi, _pumpKd, PrewetPumpData.PressureTarget,
                    PrewetPumpData.PumpPressureData.Value, _lastPumpSpeed,limit);
                if (Math.Abs(speed - _lastPumpSpeed) >= 1)
                {
                    _lastPumpSpeed = speed;
                    PumpSpeed(speed);
                }
            }
            else
            {
                IsStartAutoSpeed = false;
            }
        }
        /// <summary>
        /// 当前Routine;
        /// </summary>
        /// <returns></returns>
        private IRoutine GetCurrentRoutine()
        {
            switch (_currentOperation)
            {
                case PrewetOperation.PumpEnable:
                    return _prewetPumpEnableRoutine;
                case PrewetOperation.PumpDisable:
                    return _prewetPumpDisableRoutine;
                default:
                    return null;
            }
        }
        #region Operation
        /// <summary>
        /// DisabledAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DisabledOperation(string cmd, object[] args)
        {
            string currentOperation = "Disabled";
            PrewetEntity prewetEntity = Singleton<RouteManager>.Instance.GetModule<PrewetEntity>(Module);
            if (prewetEntity != null && _prewetPersistentValue != null && _prewetPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _prewetPersistentValue.OperatingMode;
                if (prewetEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_PREWET, Module, $"{Module} is Busy, can't switch to Disabled mode");
                    return false;
                }
                prewetEntity.EnterInit();
                _prewetPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_PREWET, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }

            PrewetPersistentManager.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";
            PrewetEntity prewetEntity = Singleton<RouteManager>.Instance.GetModule<PrewetEntity>(Module);
            if (prewetEntity != null && _prewetPersistentValue != null && _prewetPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _prewetPersistentValue.OperatingMode;
                if (prewetEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_PREWET, Module, $"{Module} is Busy, can't switch to Manual mode");
                    return false;
                }
                prewetEntity.EnterInit();
                _prewetPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_PREWET, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }

            PrewetPersistentManager.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";
            PrewetEntity prewetEntity = Singleton<RouteManager>.Instance.GetModule<PrewetEntity>(Module);
            if (prewetEntity != null && _prewetPersistentValue != null && _prewetPersistentValue.OperatingMode != currentOperation)
            {
                string preOperation = _prewetPersistentValue.OperatingMode;
                if (prewetEntity.IsBusy)
                {
                    LOG.WriteLog(eEvent.ERR_PREWET, Module, $"{Module} is Busy, can't switch to Auto mode");
                    return false;
                }
                prewetEntity.EnterInit();
                _prewetPersistentValue.OperatingMode = currentOperation;

                LOG.WriteLog(eEvent.INFO_PREWET, Module, $"Operating mode is switched from {preOperation} to {currentOperation}");
            }

            PrewetPersistentManager.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";
            _prewetPersistentValue.RecipeOperatingMode=currentRecipeOperation;
            PrewetPersistentManager.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";
            _prewetPersistentValue.RecipeOperatingMode = currentRecipeOperation;
            PrewetPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// Pump Valve On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpValveOnOperation(string cmd, object[] param)
        {
            return PumpValveOpen();
        }
        /// <summary>
        /// Pump Valve Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpValveOffOperation(string cmd, object[] param)
        {
            return PumpValveClose();
        }
        /// <summary>
        /// Pump Valve Open
        /// </summary>
        /// <returns></returns>
        public bool PumpValveOpen()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{PUMP_VALVE}");
            return IOModuleManager.Instance.WriteIoValue(ioName, true);
        }
        /// <summary>
        /// Pump Valve Close
        /// </summary>
        /// <returns></returns>
        public bool PumpValveClose()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{PUMP_VALVE}");
            bool result= IOModuleManager.Instance.WriteIoValue(ioName, false);
            if(result && PrewetPumpData.PumpEnable)
            {
                PumpDisable();
            }
            return result;
        }
        /// <summary>
        /// Pump Enable操作
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpEnableOperation(string cmd, object[] param)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_PREWET, Module.ToString(), $"{Module} current execute {_currentOperation},cannot Pump enable");
                return false;
            }
            _status = _prewetPumpEnableRoutine.Start();
            _currentOperation = PrewetOperation.PumpEnable;
            return _status==RState.Running;
        }
        /// <summary> 
        /// pump disable 操作
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpDisableOperation(string cmd, object[] param)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_PREWET, Module.ToString(), $"{Module} current execute {_currentOperation},cannot Pump disable");
                return false;
            }
            _status = _prewetPumpDisableRoutine.Start();
            _currentOperation = PrewetOperation.PumpDisable;
            return _status == RState.Running;
            //return PumpDisable();
        }
        /// <summary>
        /// Pump enable
        /// </summary>
        /// <returns></returns>
        public bool PumpEnable()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{PUMP_ENABLE}");
            return IOModuleManager.Instance.WriteIoValue(ioName, true);
        }
        /// <summary>
        /// Pump disable
        /// </summary>
        /// <returns></returns>
        public bool PumpDisable()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{PUMP_ENABLE}");
            return IOModuleManager.Instance.WriteIoValue(ioName, false);
        }
        /// <summary>
        /// 写入Pump速度
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool PumpSpeed(short speed=0)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{PUMP_SPEED}");
            return IOModuleManager.Instance.WriteIoValue(ioName, speed==0?_lastPumpSpeed:speed);
        }
        /// <summary>
        /// Pump Speed手动模式
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpSpeedManualOperation(string cmd, object[] param)
        {
            PrewetPumpData.PumpSpeedAuto = false;
            PrewetPumpData.PumpModel = "Manual";
            string statusContent = PrewetPumpData.PumpStatus ? "On" : "Off";
            PrewetPumpData.PumpStatusContent = $"{PrewetPumpData.PumpModel}: {statusContent}";
            return true;
        }
        /// <summary>
        /// Pump Speed自动模式
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpSpeedAutoOperation(string cmd, object[] param)
        {
            PrewetPumpData.PumpSpeedAuto = true;
            PrewetPumpData.PumpModel = "Auto";
            string statusContent = PrewetPumpData.PumpStatus ? "On" : "Off";
            PrewetPumpData.PumpStatusContent = $"{PrewetPumpData.PumpModel}: {statusContent}";
            return true;
        }
        /// <summary>
        /// Pump Speed回车操作
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpSpeedKeyDownOperation(string cmd, object[] param)
        {
            if (PrewetPumpData.PumpSpeedAuto)
            {
                LOG.WriteLog(eEvent.ERR_PREWET, Module, "Pump speed is auto,cannot change speed");
                return false;
            }

            short speed=(short)param[0];
            bool result = PumpSpeed(speed);
            if(result)
            {
                _prewetPersistentValue.Speed = speed;
                _lastPumpSpeed = speed;
                PrewetPersistentManager.Instance.UpdatePersistentValue(Module);
            }
            return true;
        }
        /// <summary>
        /// 中止当前Routine
        /// </summary>
        public void AbortCurrentRoutine()
        {
            if (_status == RState.Running)
            {
                IRoutine routine = GetCurrentRoutine();
                if (routine != null)
                {
                    routine.Abort();
                    _currentOperation = PrewetOperation.None;
                }
            }
        }
        #endregion

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

        }

        public void Reset()
        {
        }

        public void Terminate()
        {
            _prewetPersistentValue.Speed = _lastPumpSpeed;
            PrewetPersistentManager.Instance.UpdatePersistentValue(Module);
            _periodicJob.Stop(false);
        }
        #endregion
    }
}