PunkHPX8/PunkHPX8_RT/Devices/PowerSupplier/CellPowerSupplier.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.Util;
using MECF.Framework.Common.CommonData.PowerSupplier;
using MECF.Framework.Common.Device.PowerSupplier;
using MECF.Framework.Common.Equipment;
using PunkHPX8_Core;
using PunkHPX8_RT.Modules.Transporter;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Channels;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Documents;

namespace PunkHPX8_RT.Devices.PowerSupplier
{
    public class CellPowerSupplier : BaseDevice, IDevice
    {
        private enum PowerSupplierOperation
        {
            None=0,
            StepOperation=1,
            SetCurrent=2,
            SetStartOperation=3
        }
        #region 常量 
        private const string POWERSUPPLIER_DATA = "PowerSupplierData";
        private const string SET_POINT = "SetPoint";
        private const string CURRENT = "Current";
        private const string VOLTAGE = "Voltage";
        private const string ENABLED = "Enabled";
        private const string CONNECTED = "Connected";
        private const string POWER_STATUS = "PowerStatus";
        private const string POWER_CONTROL = "PowerControl";
        private const string POWER_RUN_MODEL = "PowerRunModel";
        private const string POWER_GRADE = "PowerGrade";
        #endregion

        #region 内部变量
        /// <summary>
        /// 数据
        /// </summary>
        private PowerSupplierData _powerSupplierData;
        /// <summary>
        /// 通道
        /// </summary>
        private byte _channel=0;
        /// <summary>
        /// 设备参数
        /// </summary>
        private PowerSupplierDevice _deviceParameter;
        /// <summary>
        /// 定时器
        /// </summary>
        private PeriodicJob _periodicJob;
        /// <summary>
        /// 指定读取指令集合
        /// </summary>
        private ConcurrentQueue<string> _readCommandList = new ConcurrentQueue<string>();
        /// <summary>
        /// 步阶Routine
        /// </summary>
        private PowerSupplierStepRoutine _powerSupplierStepRoutine;
        /// <summary>
        /// 设置电流Routine
        /// </summary>
        private PowerSupplierSetCurrentRoutine _powerSupplierSetCurrentRoutine;
        /// <summary>
        /// 设置步阶Routine
        /// </summary>
        private PowerSupplierStartStepRoutine _powerSupplierStartStepRoutine;
        /// <summary>
        /// 状态
        /// </summary>
        private RState _status;
        /// <summary>
        /// 当前操作
        /// </summary>
        private PowerSupplierOperation _currentOperation;
        /// <summary>
        /// <summary>
        /// 读取电流时间
        /// </summary>
        private DateTime _sendDateTime = DateTime.Now;

        /// <summary>
        /// 连接上升沿
        /// </summary>
        private R_TRIG _connectedTrig = new R_TRIG();
        /// <summary>
        /// 发送Remote上升沿
        /// </summary>
        private R_TRIG _sendRemoteTrig = new R_TRIG();
        /// <summary>
        /// 连接成功时间
        /// </summary>
        private DateTime _connectTime = DateTime.Now;
        /// <summary>
        /// 设置电压数值比例
        /// </summary>
        private int _voltageUnitSetScale;
        /// <summary>
        /// 读取电压数值比例
        /// </summary>
        private int _voltageUnitScale;
        /// <summary>
        /// 高档位设置电流数值比例
        /// </summary>
        private int _highGradeCurrentSetScale;
        /// <summary>
        /// 高档位读取电流数值比例
        /// </summary>
        private int _highGradeCurrentScale;
        /// <summary>
        /// 中档位设置电流数值比例
        /// </summary>
        private int _middleGradeCurrentSetScale;
        /// <summary>
        /// 中档位读取电流数值比例
        /// </summary>
        private int _middleGradeCurrentScale;
        /// <summary>
        /// 低档位设置电流数值比例
        /// </summary>
        private int _lowGradeCurrentSetScale;
        /// <summary>
        /// 低档位读取电流数值比例
        /// </summary>
        private int _lowGradeCurrentScale;
        /// <summary>
        /// 当前电源所处的挡位
        /// </summary>
        private int _currentPowerGrade;
        /// <summary>
        /// 当前正在使用的电流设置比例
        /// </summary>
        private int _currentSetScale;
        /// <summary>
        /// 当前正在使用的电流读取比例
        /// </summary>
        private int _currentScale;
        #endregion

        #region 属性
        /// <summary>
        /// 数据
        /// </summary>
        public PowerSupplierData PowerSupplierData { get { return _powerSupplierData; } }
        /// <summary>
        /// 状态
        /// </summary>
        public RState Status { get { return _status; } }
        /// <summary>
        /// 连接状态
        /// </summary>
        public bool IsConnected { get { return PowerSupplierDeviceConfigManager.Instance.GetModuleConnected(Module); } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public CellPowerSupplier(string moduleName) : base(moduleName, moduleName, moduleName, moduleName)
        {
            _powerSupplierData = new PowerSupplierData();
            _periodicJob = new PeriodicJob(100, OnTimer, $"{Module}.OnTimer", true);
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeOperation();
            InitializeData();
            InitializeRoutine();
            return true;
        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.Enable", EnableOperation);
            OP.Subscribe($"{Module}.Disable", DisableOperation);
            OP.Subscribe($"{Module}.SetPoint", SetPointOperation);
            OP.Subscribe($"{Module}.StartStepPeriod", StartStepPeriod);
            OP.Subscribe($"{Module}.SetLocalControl", SetLocalOperation);
            OP.Subscribe($"{Module}.SetRemoteControl", SetRemoteOperation);
            OP.Subscribe($"{Module}.Abort", AbortOperation);
            OP.Subscribe($"{Module}.SetPowerGrade", SetPowerGrade);
        }
        /// <summary>
        /// 初始化数据
        /// </summary>
        private void InitializeData()
        {
            _deviceParameter = PowerSupplierDeviceConfigManager.Instance.GetPowerSupplierDeviceByName(Module);
            if(_deviceParameter!=null)
            {
                if(!byte.TryParse(_deviceParameter.Address,out _channel))
                {
                    LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, $"{Module} channel is invalid");
                }
      
                _voltageUnitSetScale = _deviceParameter.VoltageUnitSetScale;
                _voltageUnitScale = _deviceParameter.VoltageUnitScale;
                _highGradeCurrentSetScale = _deviceParameter.HighGradeCurrentSetScale;
                _highGradeCurrentScale = _deviceParameter.HighGradeCurrentScale;
                _middleGradeCurrentSetScale = _deviceParameter.MiddleGradeCurrentSetScale;
                _middleGradeCurrentScale = _deviceParameter.MiddleGradeCurrentScale;
                _lowGradeCurrentSetScale = _deviceParameter.LowGradeCurrentSetScale;
                _lowGradeCurrentScale = _deviceParameter.LowGradeCurrentScale;
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, $"{Module} is not in config xml");
            }
            DATA.Subscribe($"{Module}.{POWERSUPPLIER_DATA}", () => _powerSupplierData, Aitex.Core.Util.SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{CONNECTED}", () => PowerSupplierDeviceConfigManager.Instance.GetModuleConnected(Module), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module, ENABLED, UpdateVariableValue);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module, SET_POINT, UpdateVariableValue);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module, VOLTAGE, UpdateVariableValue);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module, CURRENT, UpdateVariableValue);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module, POWER_STATUS, UpdateVariableValue);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module,POWER_CONTROL, UpdateVariableValue);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module, POWER_RUN_MODEL, UpdateVariableValue);
            PowerSupplierDeviceConfigManager.Instance.SubscribeModuleVariable(Module, POWER_GRADE, UpdateVariableValue);
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _powerSupplierStepRoutine = new PowerSupplierStepRoutine(Module);
            _powerSupplierSetCurrentRoutine = new PowerSupplierSetCurrentRoutine(Module);
            _powerSupplierStartStepRoutine= new PowerSupplierStartStepRoutine(Module);
        }
        /// <summary>
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateVariableValue(string variable, object value)
        {
            PropertyInfo property = PowerSupplierData.GetType().GetProperty(variable);
            
            if (property != null)
            {
                if (!PowerSupplierData.IsDataInitialized)
                {
                    PowerSupplierData.IsDataInitialized = true;
                    SetPowerCCStatus();
                }
                if (variable == POWER_GRADE)
                {
                    if (int.TryParse(value.ToString(), out int intvalue))
                    {
                        property.SetValue(PowerSupplierData, value);
                        if (intvalue == 0)
                        {
                            _currentSetScale = _lowGradeCurrentSetScale;
                            _currentScale = _lowGradeCurrentScale;
                        }
                        else if (intvalue == 1)
                        {
                            _currentSetScale = _middleGradeCurrentSetScale;
                            _currentScale = _middleGradeCurrentScale;
                        }
                        else
                        {
                            _currentSetScale = _highGradeCurrentSetScale;
                            _currentScale = _highGradeCurrentScale;
                        }
                    }
                    else //默认使用高档的比例
                    {
                        _currentSetScale = _highGradeCurrentSetScale;
                        _currentScale = _highGradeCurrentScale;
                    }
                }
                if (variable==SET_POINT)
                {
                    if (double.TryParse(value.ToString(), out double doubleValue))
                    {
                        property.SetValue(PowerSupplierData, doubleValue / _currentSetScale);
                    }
                    else
                    {
                        property.SetValue(PowerSupplierData, value);
                    }
                }
                
                else if(variable==CURRENT)
                {
                    if (double.TryParse(value.ToString(), out double doubleValue))
                    {
                        property.SetValue(PowerSupplierData, doubleValue / _currentScale);
                    }
                    else
                    {
                        property.SetValue(PowerSupplierData, value);
                    }
                }
                else if (variable == VOLTAGE)
                {
                    if (double.TryParse(value.ToString(), out double doubleValue))
                    {
                        property.SetValue(PowerSupplierData, doubleValue / _voltageUnitScale);
                    }
                    else
                    {
                        property.SetValue(PowerSupplierData, value);
                    }
                }
                else
                {
                    property.SetValue(PowerSupplierData, value);
                }
            }
        }

        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            bool connected = PowerSupplierDeviceConfigManager.Instance.GetModuleConnected(Module);
            _connectedTrig.CLK = connected;
            if (_connectedTrig.Q)
            {
                _connectTime = DateTime.Now;
                return true;
            }
            if(!connected)
            {
                _connectedTrig.RST = true;
                PowerSupplierDeviceConfigManager.Instance.StartConnectDevice(Module);
                return true;
            }
            if (!_sendRemoteTrig.Q)
            {
                if (DateTime.Now.Subtract(_connectTime).TotalSeconds >= 1)
                {
                    _sendRemoteTrig.CLK = SetRemoteOperation("", null);
                    SetRemoteOperation("", null);
                }
                return true;
            }

            if (_readCommandList.Count != 0)
            {
                if (_readCommandList.TryDequeue(out string command))
                {
                    switch (command)
                    {
                        case ENABLED:
                            PowerSupplierDeviceConfigManager.Instance.GetChannelOutputSwitch(Module, _channel);
                            break;
                        case SET_POINT:
                            PowerSupplierDeviceConfigManager.Instance.GetChannelCurrentSetting(Module, _channel);
                            break;
                        case POWER_STATUS:
                            PowerSupplierDeviceConfigManager.Instance.GetChannelPowerStatus(Module, _channel);
                            break;
                        case POWER_CONTROL:
                            PowerSupplierDeviceConfigManager.Instance.GetChannelPowerControl(Module, _channel);
                            break;
                        case POWER_RUN_MODEL:
                            PowerSupplierDeviceConfigManager.Instance.GetPowerRunmodelControl(Module, _channel);
                            break;
                        case POWER_GRADE:
                            PowerSupplierDeviceConfigManager.Instance.GetPowerGrade(Module, _channel);
                            break;
                    }
                    _sendDateTime = DateTime.Now;
                }
            }
            else
            {
                //控制模式为local
                if (PowerSupplierData.PowerControlContent != null && PowerSupplierData.PowerControlContent.ToLower() == "local")
                {
                    return true;
                }
                if (DateTime.Now.Subtract(_sendDateTime).TotalMilliseconds >= 300)
                {
                    ReadCurrentAndVoltage();  //每隔0.3s读一下电流电压
                }
            }

            if(_status==RState.Running)
            {
                IRoutine routine = GetCurrentRoutine();
                if (routine != null)
                {
                    _status = routine.Monitor();
                    if (_status == RState.Failed || _status == RState.Timeout)
                    {
                        _status = RState.Failed;
                        if(_currentOperation==PowerSupplierOperation.SetCurrent)
                        {
                            DisableOperation("", null);
                        }
                        _currentOperation = PowerSupplierOperation.None;
                    }
                    else if (_status == RState.End)
                    {
                        _currentOperation = PowerSupplierOperation.None;
                    }
                }
            }
            return true;
        }
        /// <summary>
        /// 读取电流和电压
        /// </summary>
        private void ReadCurrentAndVoltage()
        {
            _sendDateTime = DateTime.Now;
            PowerSupplierDeviceConfigManager.Instance.GetChannelCurrentAndVoltage(Module, _channel);
        }

        #region Operation
        /// <summary>
        /// Enable Operation
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool EnableOperation(string cmd, object[] args)
        {
            if (PowerSupplierData == null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if (PowerSupplierData.PowerControl == (short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            if (PowerSupplierData.SetPoint==0)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Setpoint is 0,cannot enable output");
                return false;
            }
            EnableOutput();
            LOG.WriteLog(eEvent.INFO_POWERSUPPLIER, Module, $"Power Control enable output Success");
            return true;
        }
        /// <summary>
        /// Disable Operation
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool DisableOperation(string cmd, object[] args)
        {
            if(_status==RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            
            DisableOutput();
            LOG.WriteLog(eEvent.INFO_POWERSUPPLIER, Module, $"Power Control disable output Success");
            return true;
        }
        /// <summary>
        /// 中止
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool AbortOperation(string cmd, object[] args)
        {
            if(_status==RState.Running)
            {
                IRoutine routine = GetCurrentRoutine();
                if(routine!=null)
                {
                    routine.Abort();
                }
                DisableOutput();
                PowerSupplierDeviceConfigManager.Instance.SetPowerRunmodelControl(Module, _channel, (byte)PowerRunModelEnum.Normal);
                LOG.WriteLog(eEvent.INFO_POWERSUPPLIER, Module, $"abort {_currentOperation} operation");
                _status = RState.End;
                _currentOperation = PowerSupplierOperation.None;
                _readCommandList.Enqueue(POWER_RUN_MODEL);
            }
            return true;
        }
        /// <summary>
        /// 关闭输出
        /// </summary>
        /// <returns></returns>
        public bool DisableOutput()
        {
            if(PowerSupplierData==null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if(PowerSupplierData.PowerControl==(short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            bool result= PowerSupplierDeviceConfigManager.Instance.SetChannelOutputSwitchControl(Module, _channel, false);
            _sendDateTime = DateTime.Now;
            _readCommandList.Enqueue(ENABLED);
            _readCommandList.Enqueue(POWER_STATUS);
            return result;
        }
        /// <summary>
        /// 启动输出
        /// </summary>
        /// <returns></returns>
        public bool EnableOutput()
        {
            if (PowerSupplierData == null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if (PowerSupplierData.PowerControl == (short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            bool result= PowerSupplierDeviceConfigManager.Instance.SetChannelOutputSwitchControl(Module, _channel, true);
            _sendDateTime = DateTime.Now;
            _readCommandList.Enqueue(ENABLED);
            _readCommandList.Enqueue(POWER_STATUS);
            return result;
        }
        /// <summary>
        /// SetPoint
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool SetPointOperation(string cmd, object[] args)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            if (PowerSupplierData == null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if (PowerSupplierData.PowerControl == (short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            if (args.Length<2)
            {
                return false;
            }
            if (double.TryParse(args[1].ToString(), out double value))
            {
                SetCurrent(value);
            }
            return true;
        }
        /// <summary>
        /// 设置电流
        /// </summary>
        /// <param name="current"></param>
        /// <returns></returns>
        public bool SetCurrent(double current)
        {
            PowerSupplierDeviceConfigManager.Instance.SetPowerRunmodelControl(Module, _channel, (byte)PowerRunModelEnum.Normal);
            int setPoint = (int)Math.Round(_currentSetScale * current, 0);
            bool result= PowerSupplierDeviceConfigManager.Instance.SetChannelCurrent(Module, _channel, setPoint);
            _sendDateTime = DateTime.Now;
            if (result)
            {
                LOG.WriteLog(eEvent.INFO_POWERSUPPLIER, Module, $"Current {current} Setting success");
                _readCommandList.Enqueue(SET_POINT);
                _readCommandList.Enqueue(POWER_RUN_MODEL);
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 设置电源挡位
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool SetPowerGrade(string cmd, object[] args)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            if (PowerSupplierData == null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if (PowerSupplierData.PowerControl == (short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            byte grade = (byte)args[0];
            PowerSupplierDeviceConfigManager.Instance.SetPowerRunmodelControl(Module, _channel, (byte)PowerRunModelEnum.Normal);
            bool result = PowerSupplierDeviceConfigManager.Instance.SetPowerGrade(Module, _channel, grade);
            if (result) //挡位设置成功则默认当前挡位
            {
                PowerSupplierData.PowerGrade = grade;
            }
            return result;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool StartStepPeriod(string cmd, object[] args)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            if (PowerSupplierData == null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if (PowerSupplierData.PowerControl == (short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            bool result= _powerSupplierStepRoutine.Start(args)==RState.Running;
            if(result)
            {
                _status = RState.Running;
                _currentOperation = PowerSupplierOperation.StepOperation;
            }
            return result;
        }
        /// <summary>
        /// 启动设置步阶,
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool StartSetStepPeriodNoWaitEnd(List<PowerSupplierStepPeriodData> datas)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            if (PowerSupplierData == null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if (PowerSupplierData.PowerControl == (short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            bool result = _powerSupplierStartStepRoutine.Start(datas) == RState.Running;
            if (result)
            {
                _status = RState.Running;
                _currentOperation = PowerSupplierOperation.SetStartOperation;
            }
            return result;
        }
        /// <summary>
        /// 设置步阶
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool SetStepPeriod(string cmd, object[] args)
        {
            List<PowerSupplierStepPeriodData> powerSupplierStepPeriodDatas = (List<PowerSupplierStepPeriodData>)args[1];

            bool result=PowerSupplierDeviceConfigManager.Instance.SetStepPeriod(Module, _channel, powerSupplierStepPeriodDatas,_currentSetScale, _voltageUnitSetScale);
            _sendDateTime = DateTime.Now;
            if (result)
            {
                LOG.WriteLog(eEvent.INFO_POWERSUPPLIER, Module, $"Step Period Set Success");
                return true;
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, $"Step Period Set Fail");
                return false;
            }
        }
        /// <summary>
        /// 启动步阶
        /// </summary>
        /// <param name="endStep"></param>
        /// <param name="cycle"></param>
        /// <returns></returns>
        public bool StartStepPeriod(ushort endStep,ushort cycle)
        {
            bool result = PowerSupplierDeviceConfigManager.Instance.StartStepPeriod(Module, _channel, 1, endStep, cycle);
            _sendDateTime= DateTime.Now;
            return result;
        }
        /// <summary>
        /// 设置电源运行模式
        /// </summary>
        /// <param name="runModel"></param>
        /// <returns></returns>
        public bool SwitchPowerRunModel(byte runModel)
        {
            bool result= PowerSupplierDeviceConfigManager.Instance.SetPowerRunmodelControl(Module,_channel, runModel);
            _sendDateTime = DateTime.Now;
            _readCommandList.Enqueue(POWER_RUN_MODEL);
            return result;
        }
        /// <summary>
        /// 设置本地模式 
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool SetLocalOperation(string cmd, object[] args)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            bool result= PowerSupplierDeviceConfigManager.Instance.SetChannelPowerControl(Module, _channel, 1);
            _sendDateTime = DateTime.Now;
            if (result)
            {
                LOG.WriteLog(eEvent.INFO_POWERSUPPLIER, Module, $"Power Control Switch Local Control Success");
                _readCommandList.Enqueue(POWER_CONTROL);
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 设置远程模式
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool SetRemoteOperation(string cmd, object[] args)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            bool result= PowerSupplierDeviceConfigManager.Instance.SetChannelPowerControl(Module, _channel, 2);
            _sendDateTime = DateTime.Now;
            if (result)
            {
                LOG.WriteLog(eEvent.INFO_POWERSUPPLIER, Module, $"Power Control Switch Remote Control Success");
                _readCommandList.Enqueue(POWER_CONTROL);
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 设置电流并设置输出
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool SetCurrentAndOutput(double current)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is Busy");
                return false;
            }
            if (PowerSupplierData == null)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Data is null");
                return false;
            }
            if (PowerSupplierData.PowerControl == (short)PowerControlEnum.Local)
            {
                LOG.WriteLog(eEvent.ERR_POWERSUPPLIER, Module, "Power Supplier is local control");
                return false;
            }
            bool result = _powerSupplierSetCurrentRoutine.Start(current) == RState.Running;

            if (result)
            {
                _status = RState.Running;
                _currentOperation = PowerSupplierOperation.SetCurrent;
            }
            return result;
        }
        /// <summary>
        /// 获取当前的routine
        /// </summary>
        /// <returns></returns>
        private IRoutine GetCurrentRoutine()
        {
            switch(_currentOperation)
            {
                case PowerSupplierOperation.StepOperation:
                    return _powerSupplierStepRoutine;
                case PowerSupplierOperation.SetCurrent:
                    return _powerSupplierSetCurrentRoutine;
                case PowerSupplierOperation.SetStartOperation:
                    return _powerSupplierStartStepRoutine;
                default:
                    return null;
            }
        }
        /// <summary>
        /// 设置CC电源状态
        /// </summary>
        private void SetPowerCCStatus()
        {
            _readCommandList.Enqueue(POWER_STATUS);
            _readCommandList.Enqueue(POWER_GRADE);
            _readCommandList.Enqueue(SET_POINT);
            _readCommandList.Enqueue(ENABLED);
            _readCommandList.Enqueue(POWER_CONTROL);
            _readCommandList.Enqueue(POWER_RUN_MODEL);
        
        }
        #endregion

        public void Monitor()
        {

        }

        public void Reset()
        {
        }

        public void Terminate()
        {
            DisableOutput();
        }

    }
}