BOB/DeviceCommand/Device/EAEL9080.cs

using Common.Attributes;
using DeviceCommand.Base;
using System.Threading;
using System.Threading.Tasks;

namespace DeviceCommand.Device
{
    [BOBCommand]
    public class EAEL9080 : ModbusTcp
    {
        public EAEL9080(string IpAddress, int port, int SendTimeout, int ReceiveTimeout)
        {
            ConfigureDevice(IpAddress, port, SendTimeout, ReceiveTimeout);

        }
        public EAEL9080()
        {

        }
        #region 一、基础控制

        public async Task SetRemoteControlAsync(bool activate, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(activate ? 0xFF00 : 0x0000);
            await WriteSingleRegisterAsync(slaveAddress, 402, value, ct);
        }

        public async Task SetOutputAsync(bool on, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(on ? 0xFF00 : 0x0000);
            await WriteSingleRegisterAsync(slaveAddress, 405, value, ct);
        }

        public async Task SetWorkModeAsync(bool useResistanceMode, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(useResistanceMode ? 0xFF00 : 0x0000);
            await WriteSingleRegisterAsync(slaveAddress, 409, value, ct);
        }

        public async Task<uint> ReadDeviceStatusAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 505, 2, ct);
            return (uint)(reg[0] << 16 | reg[1]);
        }

        public async Task<bool> IsDcOnAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            uint status = await ReadDeviceStatusAsync(slaveAddress, ct);
            return (status & (1 << 7)) != 0;
        }

        public async Task<bool> IsRemoteActiveAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            uint status = await ReadDeviceStatusAsync(slaveAddress, ct);
            return (status & (1 << 10)) != 0;
        }

        public async Task<bool> IsSinkModeActiveAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            uint status = await ReadDeviceStatusAsync(slaveAddress, ct);
            return (status & (1 << 12)) != 0;
        }

        #endregion

        #region 二、电压 / 电流 / 功率 / 电阻设定值

        public async Task SetVoltageAsync(double voltage, double ratedVoltage, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(voltage / ratedVoltage * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 500, value, ct);
        }

        public async Task<double> GetVoltageAsync(double ratedVoltage, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 500, 1, ct);
            return reg[0] / (double)0xCCCC * ratedVoltage;
        }

        public async Task SetCurrentAsync(double current, double ratedCurrent, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(current / ratedCurrent * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 501, value, ct);
        }

        public async Task<double> GetCurrentAsync(double ratedCurrent, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 501, 1, ct);
            return reg[0] / (double)0xCCCC * ratedCurrent;
        }

        public async Task SetPowerAsync(double power, double ratedPower, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(power / ratedPower * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 502, value, ct);
        }

        public async Task<double> GetPowerAsync(double ratedPower, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 502, 1, ct);
            return reg[0] / (double)0xCCCC * ratedPower;
        }

        public async Task SetResistanceAsync(double resistance, double maxResistance, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(resistance / maxResistance * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 503, value, ct);
        }

        public async Task<double> GetResistanceAsync(double maxResistance, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 503, 1, ct);
            return reg[0] / (double)0xCCCC * maxResistance;
        }

        #endregion

        #region 三、Sink 模式

        public async Task SetSinkPowerAsync(double power, double sinkRatedPower, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(power / sinkRatedPower * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 498, value, ct);
        }

        public async Task SetSinkCurrentAsync(double current, double sinkRatedCurrent, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(current / sinkRatedCurrent * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 499, value, ct);
        }

        public async Task SetSinkResistanceAsync(double resistance, double sinkMaxResistance, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(resistance / sinkMaxResistance * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 504, value, ct);
        }

        public async Task<double> GetSinkPowerAsync(double sinkRatedPower, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 498, 1, ct);
            return reg[0] / (double)0xCCCC * sinkRatedPower;
        }

        public async Task<double> GetSinkCurrentAsync(double sinkRatedCurrent, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 499, 1, ct);
            return reg[0] / (double)0xCCCC * sinkRatedCurrent;
        }

        public async Task<double> GetSinkResistanceAsync(double sinkMaxResistance, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 504, 1, ct);
            return reg[0] / (double)0xCCCC * sinkMaxResistance;
        }

        #endregion

        #region 四、实时测量

        public async Task<double> ReadActualVoltageAsync(double ratedVoltage, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 507, 1, ct);
            return reg[0] / (double)0xCCCC * ratedVoltage;
        }

        public async Task<double> ReadActualCurrentAsync(double ratedCurrent, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 508, 1, ct);
            double current = reg[0] / (double)0xCCCC * ratedCurrent;
            if (await IsSinkModeActiveAsync(slaveAddress, ct)) current = -current;
            return current;
        }

        public async Task<double> ReadActualPowerAsync(double ratedPower, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 509, 1, ct);
            double power = reg[0] / (double)0xCCCC * ratedPower;
            if (await IsSinkModeActiveAsync(slaveAddress, ct)) power = -power;
            return power;
        }

        #endregion

        #region 五、保护阈值

        public async Task SetOverVoltageLimitAsync(double voltage, double ratedVoltage, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(voltage / ratedVoltage * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 510, value, ct);
        }

        public async Task SetOverCurrentLimitAsync(double current, double ratedCurrent, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(current / ratedCurrent * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 511, value, ct);
        }

        public async Task SetOverPowerLimitAsync(double power, double ratedPower, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(power / ratedPower * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 512, value, ct);
        }

        #endregion
    }
}