Smart.Modbus 1.0.1

Smart.Modbus

Smart.Modbus 是一个支持 .NET 8/9 的Modbus协议封装库，支持Modbus RTU、Modbus TCP协议，提供了简单易用的API接口，不涉及数据通信，只提供组帧、校验和数据解析功能。

使用示例

csharp

// 创建对象
private readonly IModbusHandler _modbusTcp = new ModbusTcpHandler(1);

// 或者使用如下工厂方法创建Modbus协议处理器对象
private readonly IModbusHandler _modbusTcp = ModbusFactory.Create(ModbusProtocol.ModbusTcp, 1);

public void ReadCoils()
{
    _logger.LogDebug("ModbusService ReadCoils,{}", DateTime.Now);
    // 读取线圈
    byte[] data = _modbusTcp.BuildReadCoilsRequest(0, 10);
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

public void ReadDiscreteInputs()
{
    _logger.LogDebug("ModbusService ReadDiscreteInputs,{}", DateTime.Now);
    // 读取离散输入
    byte[] data = _modbusTcp.BuildReadDiscreteInputsRequest(0, 10);
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

public void ReadHoldingRegisters()
{
    _logger.LogDebug("ModbusService ReadHoldingRegisters,{}", DateTime.Now);
    // 读取保持寄存器
    byte[] data = _modbusTcp.BuildReadHoldingRegistersRequest(0, 10);
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

public void ReadInputRegisters()
{
    _logger.LogDebug("ModbusService ReadInputRegisters,{}", DateTime.Now);
    // 读取输入寄存器
    byte[] data = _modbusTcp.BuildReadInputRegistersRequest(0, 10);
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

public void WriteSingleCoil()
{
    _logger.LogDebug("ModbusService WriteSingleCoil,{}", DateTime.Now);
    // 写单个线圈
    byte[] data = _modbusTcp.BuildWriteSingleCoilRequest(0, Random.Shared.Next() % 2 == 0);
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

public void WriteSingleRegister()
{
    _logger.LogDebug("ModbusService WriteSingleRegister,{}", DateTime.Now);
    // 写单个保持寄存器
    byte[] data = _modbusTcp.BuildWriteSingleRegisterRequest(0, (ushort)(Random.Shared.Next() % 65535));
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

public void WriteMultipleCoils()
{
    _logger.LogDebug("ModbusService WriteMultipleCoils,{}", DateTime.Now);
    // 写线圈
    List<bool> bools = new List<bool>();
    for (int i = 0; i < 10; i++)
    {
        bools.Add(i % 2 == 1);
    }
    byte[] data = _modbusTcp.BuildWriteMultipleCoilsRequest(0, bools.ToArray());
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

public void WriteMultipleRegisters()
{
    _logger.LogDebug("ModbusService WriteMultipleRegisters,{}", DateTime.Now);
    // 写保持寄存器
    List<ushort> ushorts = new List<ushort>();
    for (int i = 0; i < 10; i++)
    {
        ushorts.Add((ushort)(Random.Shared.Next() % 65535 + i));
    }

    byte[] data = _modbusTcp.BuildWriteMultipleRegistersRequest(0, ushorts.ToArray());
    if (!_client.Send(data, data.Length))
    {
        _logger.LogError("Send Failed,Data:{}", SmartConvert.ByteArrayToHexString(data, true));
    }
}

// 处理响应
var (Valid, Fail) = _modbusTcp.ValidateResponse(response);
if (Valid)
{
    FunctionCode function = _modbusTcp.DetectionFunctionCode(response);
    switch (function)
    {
        case FunctionCode.ReadHoldingRegisters:
        case FunctionCode.ReadInputRegisters:
            var registers = _modbusTcp.ParseRegistersResponse(response);
            _logger.LogInformation("{} Success,Registers:{}", function, string.Join(",", registers));
            break;
        case FunctionCode.ReadCoils:
        case FunctionCode.ReadDiscreteInputs:
            var coils = _modbusTcp.ParseCoilsResponse(response, 10);
            _logger.LogInformation("{} Success,Coils:{}", function, string.Join(",", coils));
            break;
        case FunctionCode.WriteSingleRegister:
        case FunctionCode.WriteSingleCoil:
        case FunctionCode.WriteMultipleRegisters:
        case FunctionCode.WriteMultipleCoils:
            _logger.LogInformation("{} Success,Response:{}", function, SmartConvert.ByteArrayToHexString(response, true));
            break;
        default:
            _logger.LogError("Unknown FunctionCode:{},response:{}", function, SmartConvert.ByteArrayToHexString(response, true));
            break;
    }
}
else
{
    _logger.LogError("ValidateResponse Failed,Reason:{},response:{}", Fail, SmartConvert.ByteArrayToHexString(response, true));
}

Developed by zenglei