BOB/DeviceCommand/Device/PSB11000.cs

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

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

        public PSB11000() { }

        #region 一、基础控制寄存器

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

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

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

        public virtual async Task ResetAlarmAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(slaveAddress, 411, 0xFF00, ct);
        }

        public virtual async Task<bool> QueryRemoteControlAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] result = await ReadHoldingRegistersAsync(slaveAddress, 402, 1, ct);
            return result[0] == 0xFF00;
        }

        public virtual async Task<bool> QueryOutputAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] result = await ReadHoldingRegistersAsync(slaveAddress, 405, 1, ct);
            return result[0] == 0xFF00;
        }

        public virtual async Task<bool> QueryWorkModeAsync(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] result = await ReadHoldingRegistersAsync(slaveAddress, 409, 1, ct);
            return result[0] == 0xFF00;
        }

        #endregion

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

        public virtual 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 virtual 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 virtual 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 virtual 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 virtual 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 virtual 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 virtual 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 virtual 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

        // 后面三、四、五区域的所有方法也同样加上 virtual
        // 例如：
        public virtual 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 virtual 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;
        }

        // 类似方法全部加上 virtual，保证代理可以拦截
    }
}