using System;
|
using System.Net.Sockets;
|
using System.Net;
|
using Microsoft.Owin.BuilderProperties;
|
using System.Web.Services.Description;
|
using Org.BouncyCastle.Utilities.Net;
|
using System.Web.UI.WebControls.WebParts;
|
using System.Linq;
|
|
using TcpClient = System.Net.Sockets.TcpClient;
|
using System.IO;
|
|
namespace HH.WCS.Mobox3.DSZSH.device {
|
// 定义Modbus通讯接口
|
public interface IModbusCommunicator : IDisposable {
|
bool IsConnected { get; }
|
|
void Link(string ipAddress, int port);
|
void Disconnect();
|
void ReconnectAll();
|
|
// 常用的Modbus功能码方法
|
/// <summary>
|
/// 读一个或多个线圈，返回一个bit真假数组
|
/// </summary>
|
/// <param name="startingAddress"></param>
|
/// <param name="quantity"></param>
|
/// <returns></returns>
|
bool[] ReadCoils(int startingAddress, int quantity);
|
/// <summary>
|
/// 读一个或多个离散输入，返回一个bit真假数组
|
/// </summary>
|
/// <param name="startingAddress"></param>
|
/// <param name="quantity"></param>
|
/// <returns></returns>
|
bool[] ReadDiscreteInputs(int startingAddress, int quantity);
|
/// <summary>
|
/// 批量读取或单独读取保持寄存器，返回的是32位int数组
|
/// </summary>
|
/// <param name="startingAddress"></param>
|
/// <param name="quantity"></param>
|
/// <returns></returns>
|
int[] ReadHoldingRegisters(int startingAddress, int quantity);
|
/// <summary>
|
/// 读一个或多个输入寄存器，返回一个int32位数组
|
/// </summary>
|
/// <param name="startingAddress"></param>
|
/// <param name="quantity"></param>
|
/// <returns></returns>
|
int[] ReadInputRegisters(int startingAddress, int quantity);
|
/// <summary>
|
/// 写入单个线圈
|
/// </summary>
|
/// <param name="coilAddress"></param>
|
/// <param name="value"></param>
|
bool WriteSingleCoil(int coilAddress, bool value);
|
/// <summary>
|
/// 写入单个寄存器数据
|
/// </summary>
|
/// <param name="registerAddress"></param>
|
/// <param name="value"></param>
|
/// <returns></returns>
|
bool WriteSingleRegister(int registerAddress, ushort value);
|
/// <summary>
|
/// 写入多个线圈
|
/// </summary>
|
/// <param name="startingAddress"></param>
|
/// <param name="values"></param>
|
/// <returns></returns>
|
bool WriteMultipleCoils(int startingAddress, bool[] values);
|
/// <summary>
|
/// 写入多个寄存器数据
|
/// </summary>
|
/// <param name="startingAddress"></param>
|
/// <param name="values"></param>
|
/// <returns></returns>
|
bool WriteMultipleRegisters(int startingAddress, int[] values);
|
}
|
|
// Modbus通讯方式枚举
|
public enum ModbusCommunicationType {
|
EasyModbus,
|
TcpSocket
|
}
|
|
// Modbus通讯工厂类
|
public static class ModbusFactory {
|
public static IModbusCommunicator CreateCommunicator(ModbusCommunicationType type) {
|
switch (type) {
|
case ModbusCommunicationType.EasyModbus:
|
return new EasyModbusCommunicator();
|
case ModbusCommunicationType.TcpSocket:
|
return new TcpSocketCommunicator();
|
default:
|
//throw new ArgumentException("不支持的Modbus通信方式：请选择EasyModbus或TcpSocket");
|
LogHelper.Info("不支持的Modbus通信方式：请选择EasyModbus或TcpSocket");
|
return null;
|
}
|
}
|
|
static void Test() {
|
try {
|
var communicator = ModbusFactory.CreateCommunicator(ModbusCommunicationType.TcpSocket);
|
|
communicator.Link("127.0.0.1", 502);
|
var read = communicator.ReadInputRegisters(0, 5);
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
}
|
|
// EasyModbus实现
|
public class EasyModbusCommunicator : IModbusCommunicator {
|
private EasyModbus.ModbusClient _modbusClient;
|
|
public bool IsConnected => _modbusClient?.Connected ?? false;
|
|
public void Link(string ipAddress, int port) {
|
if (IsConnected) {
|
LogHelper.Info($"(ip:{ipAddress}, port:{port})已经连接");
|
return;
|
}
|
|
_modbusClient = new EasyModbus.ModbusClient(ipAddress, port);
|
_modbusClient.Connect();
|
|
if (IsConnected) {
|
LogHelper.Info($"连接成功：{ipAddress}:{port}");
|
}
|
else {
|
LogHelper.Info($"连接失败：{ipAddress}:{port}");
|
}
|
}
|
|
public void Disconnect() {
|
if (!IsConnected) {
|
LogHelper.Info($"当前没有要断开的连接");
|
return;
|
}
|
|
_modbusClient?.Disconnect();
|
|
if (IsConnected) {
|
LogHelper.Info($"连接成功：{_modbusClient.IPAddress}:{_modbusClient.Port}");
|
}
|
else {
|
LogHelper.Info($"连接失败：{_modbusClient.IPAddress} : {_modbusClient.Port}");
|
}
|
}
|
|
public void ReconnectAll() {
|
if (_modbusClient != null) {
|
var ip = _modbusClient.IPAddress;
|
var port = _modbusClient.Port;
|
Disconnect();
|
Link(ip, port);
|
}
|
}
|
|
public bool[] ReadCoils(int startingAddress, int quantity) {
|
bool[] res = new bool[0];
|
var client = _modbusClient;
|
if (_modbusClient != null && IsConnected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
try {
|
res = _modbusClient.ReadCoils(startingAddress, quantity);
|
if (res.Length != 0) {
|
//读取成功
|
LogHelper.Info($"读取成功：ReadCoils:IP:{ip},Port:{port}");
|
}
|
else {
|
//读取失败
|
LogHelper.Info($"读取失败：ReadCoils:IP:{ip},Port:{port}");
|
}
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public bool[] ReadDiscreteInputs(int startingAddress, int quantity) {
|
bool[] res = new bool[0];
|
var client = _modbusClient;
|
if (_modbusClient != null && IsConnected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
try {
|
res = _modbusClient.ReadDiscreteInputs(startingAddress, quantity);
|
if (res.Length != 0) {
|
//读取成功
|
LogHelper.Info($"读取成功：ReadDiscreteInputs:IP:{ip},Port:{port}");
|
}
|
else {
|
//读取失败
|
LogHelper.Info($"读取失败：ReadDiscreteInputs:IP:{ip},Port:{port}");
|
}
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public int[] ReadHoldingRegisters(int startingAddress, int quantity) {
|
int[] res = new int[0];
|
var client = _modbusClient;
|
if (client != null && client.Connected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
try {
|
//一个寄存器是16位，返回2个int类型
|
res = client.ReadHoldingRegisters(startingAddress, quantity);
|
if (res.Length != 0) {
|
//读取成功
|
LogHelper.Info($"读取成功：ReadHoldingRegisters:IP:{ip},Port:{port}");
|
}
|
else {
|
//读取失败
|
LogHelper.Info($"读取失败：ReadHoldingRegisters:IP:{ip},Port:{port}");
|
}
|
}
|
catch (Exception ex) {
|
//如果请求数量超出保持寄存器的最大数据行数，会报错
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public int[] ReadInputRegisters(int startingAddress, int quantity) {
|
int[] res = new int[0];
|
var client = _modbusClient;
|
if (client != null && client.Connected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
try {
|
res = client.ReadInputRegisters(startingAddress, quantity);
|
if (res.Length != 0) {
|
//读取成功
|
LogHelper.Info($"读取成功：ReadInputRegisters:IP:{ip},Port:{port}");
|
}
|
else {
|
//读取失败
|
LogHelper.Info($"读取失败：ReadInputRegisters:IP:{ip},Port:{port}");
|
}
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public bool WriteSingleCoil(int coilAddress, bool value) {
|
var res = false;
|
var client = _modbusClient;
|
if (client != null && client.Connected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
try {
|
client.WriteSingleCoil(coilAddress, value);
|
res = value == client.ReadCoils(coilAddress, 1)[0];
|
if (res) {
|
//写入成功
|
LogHelper.Info($"写入成功：WriteSingleCoil:IP:{ip},Port:{port}");
|
}
|
else {
|
//写入失败
|
LogHelper.Info($"写入失败：WriteSingleCoil:IP:{ip},Port:{port}");
|
}
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public bool WriteSingleRegister(int registerAddress, ushort value) {
|
var res = false;
|
var client = _modbusClient;
|
if (client != null && client.Connected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
try {
|
client.WriteSingleRegister(registerAddress, value);
|
res = value == client.ReadHoldingRegisters(registerAddress, 1)[0];
|
if (res) {
|
//写入成功
|
LogHelper.Info($"写入成功：WriteSingleRegister:IP:{ip},Port:{port}");
|
}
|
else {
|
//写入失败
|
LogHelper.Info($"写入失败：WriteSingleRegister:IP:{ip},Port:{port}");
|
}
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public bool WriteMultipleCoils(int startingAddress, bool[] values) {
|
var res = false;
|
var client = _modbusClient;
|
if (client != null && client.Connected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
try {
|
client.WriteMultipleCoils(startingAddress, values);
|
var dataRead = client.ReadCoils(startingAddress, values.Length);
|
res = values.SequenceEqual(dataRead);
|
if (res) {
|
//写入成功
|
LogHelper.Info($"写入成功：WriteMultipleCoils:IP:{ip},Port:{port}");
|
}
|
else {
|
//写入失败
|
LogHelper.Info($"写入失败：WriteMultipleCoils:IP:{ip},Port:{port}");
|
}
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public bool WriteMultipleRegisters(int startingAddress, int[] values) {
|
var res = false;
|
var client = _modbusClient;
|
if (client != null && client.Connected) {
|
var ip = client.IPAddress;
|
var port = client.Port;
|
var log = string.Join(",", values.Select(x => x.ToString()));
|
try {
|
client.WriteMultipleRegisters(startingAddress, values);
|
var dataRead = client.ReadHoldingRegisters(startingAddress, values.Length);
|
res = values.SequenceEqual(dataRead);
|
if (res) {
|
LogHelper.Info($"写入成功,WriteMultipleRegisters:IP:{ip},Port:{port},{log}");
|
}
|
else {
|
LogHelper.Info($"写入失败,WriteMultipleRegisters:IP:{ip},Port:{port},{log}");
|
}
|
}
|
catch (Exception ex) {
|
LogHelper.InfoEx(ex);
|
}
|
}
|
else {
|
LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
|
}
|
return res;
|
}
|
|
public void Dispose() {
|
//_modbusClient?.Dispose();
|
GC.SuppressFinalize(_modbusClient);
|
}
|
}
|
|
// TCPSocket实现
|
public class TcpSocketCommunicator : IModbusCommunicator {
|
private System.Net.Sockets.TcpClient _tcpClient;
|
private NetworkStream _networkStream;
|
private byte unitIdentifier = 1; // 默认单元标识符
|
|
public bool IsConnected => _tcpClient?.Connected ?? false;
|
//public bool IsConnected { get { if (_tcpClient != null) { return _tcpClient.Connected; } else { return false; } } }
|
|
public void Link(string ipAddress, int port) {
|
_tcpClient = new System.Net.Sockets.TcpClient();
|
_tcpClient.Connect(ipAddress, port);
|
_networkStream = _tcpClient.GetStream();
|
}
|
|
public void Disconnect() {
|
_networkStream?.Close();
|
_tcpClient?.Close();
|
}
|
|
public void ReconnectAll() {
|
if (_tcpClient != null) {
|
var ip = ((IPEndPoint)_tcpClient.Client.RemoteEndPoint).Address.ToString();
|
var port = ((IPEndPoint)_tcpClient.Client.RemoteEndPoint).Port;
|
Disconnect();
|
Link(ip, port);
|
}
|
}
|
|
public bool[] ReadCoils(int startingAddress, int quantity) {
|
if (quantity < 1 || quantity > 2000)
|
throw new ArgumentException("Quantity must be between 1 and 2000");
|
|
// 构建请求报文（12字节）
|
byte[] request = new byte[12];
|
request[0] = 0x00; // 事务ID高字节
|
request[1] = 0x01; // 事务ID低字节（示例值）
|
request[2] = 0x00; // 协议ID高字节（固定0）
|
request[3] = 0x00; // 协议ID低字节（固定0）
|
request[4] = 0x00; // 长度高字节（后续6字节）
|
request[5] = 0x06; // 长度低字节
|
request[6] = unitIdentifier; // 单元标识符
|
request[7] = 0x01; // 功能码（读线圈）
|
request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
|
request[9] = (byte)startingAddress; // 起始地址低字节
|
request[10] = (byte)(quantity >> 8); // 数量高字节
|
request[11] = (byte)quantity; // 数量低字节
|
|
// 发送请求
|
_networkStream.Write(request, 0, request.Length);
|
|
// 读取响应头（8字节）
|
byte[] responseHeader = new byte[8];
|
int bytesRead = _networkStream.Read(responseHeader, 0, 8);
|
if (bytesRead != 8)
|
throw new Exception("Invalid response header length");
|
|
// 校验事务ID、协议ID、单元标识符
|
if (responseHeader[0] != request[0] || responseHeader[1] != request[1] ||
|
responseHeader[2] != 0x00 || responseHeader[3] != 0x00 ||
|
responseHeader[6] != unitIdentifier)
|
throw new Exception("Invalid response header");
|
|
// 检查异常响应（功能码 + 0x80）
|
if (responseHeader[7] == 0x81) {
|
int errorCode = _networkStream.ReadByte();
|
throw new Exception($"Modbus error. Code: {errorCode}");
|
}
|
else if (responseHeader[7] != 0x01)
|
throw new Exception("Invalid function code in response");
|
|
// 读取数据部分（字节数 + 实际数据）
|
byte byteCount = responseHeader[8];
|
byte[] responseData = new byte[byteCount];
|
bytesRead = _networkStream.Read(responseData, 0, byteCount);
|
if (bytesRead != byteCount)
|
throw new Exception("Invalid response data length");
|
|
// 解析线圈状态（每个位表示一个线圈）
|
bool[] coils = new bool[quantity];
|
for (int i = 0; i < quantity; i++) {
|
int byteIndex = i / 8;
|
int bitIndex = i % 8;
|
coils[i] = (responseData[byteIndex] & (1 << bitIndex)) != 0;
|
}
|
|
return coils;
|
}
|
|
public bool[] ReadDiscreteInputs(int startingAddress, int quantity) {
|
// 报文结构与ReadCoils几乎相同，仅功能码改为0x02
|
byte[] request = new byte[12];
|
request[0] = 0x00; // 事务ID高字节
|
request[1] = 0x01; // 事务ID低字节（示例值）
|
request[2] = 0x00; // 协议ID高字节（固定0）
|
request[3] = 0x00; // 协议ID低字节（固定0）
|
request[4] = 0x00; // 长度高字节（后续6字节）
|
request[5] = 0x06; // 长度低字节
|
request[6] = unitIdentifier;
|
request[7] = 0x02; // 功能码：读离散输入
|
request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
|
request[9] = (byte)startingAddress; // 起始地址低字节
|
request[10] = (byte)(quantity >> 8); // 数量高字节
|
request[11] = (byte)quantity; // 数量低字节
|
|
_networkStream.Write(request, 0, request.Length);
|
|
// 响应处理逻辑与ReadCoils一致
|
byte[] responseHeader = new byte[8];
|
_networkStream.Read(responseHeader, 0, 8);
|
|
// 校验和异常处理（参考ReadCoils）
|
if (responseHeader[7] == 0x82) // 异常响应
|
{
|
int errorCode = _networkStream.ReadByte();
|
throw new Exception($"Modbus error. Code: {errorCode}");
|
}
|
|
byte byteCount = responseHeader[8];
|
byte[] responseData = new byte[byteCount];
|
_networkStream.Read(responseData, 0, byteCount);
|
|
// 解析离散输入状态
|
bool[] inputs = new bool[quantity];
|
for (int i = 0; i < quantity; i++) {
|
int byteIndex = i / 8;
|
int bitIndex = i % 8;
|
inputs[i] = (responseData[byteIndex] & (1 << bitIndex)) != 0;
|
}
|
|
return inputs;
|
}
|
|
public int[] ReadHoldingRegisters(int startingAddress, int quantity) {
|
if (quantity < 1 || quantity > 125)
|
throw new ArgumentException("Quantity must be between 1 and 125");
|
|
// 构建请求报文（12字节）
|
byte[] request = new byte[12];
|
request[0] = 0x00; // 事务ID高字节（示例值）
|
request[1] = 0x01; // 事务ID低字节
|
request[2] = 0x00; // 协议ID高字节（固定0）
|
request[3] = 0x00; // 协议ID低字节（固定0）
|
request[4] = 0x00; // 长度高字节（后续6字节）
|
request[5] = 0x06; // 长度低字节
|
request[6] = unitIdentifier; // 单元标识符
|
request[7] = 0x03; // 功能码（读保持寄存器）
|
request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
|
request[9] = (byte)startingAddress; // 起始地址低字节
|
request[10] = (byte)(quantity >> 8); // 数量高字节
|
request[11] = (byte)quantity; // 数量低字节
|
|
// 发送请求
|
_networkStream.Write(request, 0, request.Length);
|
|
// 读取响应头（8字节）
|
byte[] responseHeader = new byte[8];
|
int bytesRead = _networkStream.Read(responseHeader, 0, 8);
|
if (bytesRead != 8)
|
throw new Exception("Invalid response header length");
|
|
// 校验事务ID、协议ID、单元标识符
|
if (responseHeader[0] != request[0] || responseHeader[1] != request[1] ||
|
responseHeader[2] != 0x00 || responseHeader[3] != 0x00 ||
|
responseHeader[6] != unitIdentifier)
|
throw new Exception("Invalid response header");
|
|
// 检查异常响应（功能码 + 0x80）
|
if (responseHeader[7] == 0x83) {
|
int errorCode = _networkStream.ReadByte();
|
throw new Exception($"Modbus error. Code: {errorCode}");
|
}
|
else if (responseHeader[7] != 0x03)
|
throw new Exception("Invalid function code in response");
|
|
// 读取数据部分（字节数 + 实际数据）
|
byte byteCount = responseHeader[8];
|
byte[] responseData = new byte[byteCount];
|
bytesRead = _networkStream.Read(responseData, 0, byteCount);
|
if (bytesRead != byteCount)
|
throw new Exception("Invalid response data length");
|
|
// 解析寄存器值（大端序）
|
int[] registers = new int[quantity];
|
for (int i = 0; i < quantity; i++) {
|
int offset = i * 2;
|
registers[i] = (ushort)((responseData[offset] << 8) | responseData[offset + 1]);
|
}
|
|
return registers;
|
}
|
|
public int[] ReadInputRegisters(int startingAddress, int quantity) {
|
if (quantity < 1 || quantity > 125)
|
throw new ArgumentException("Quantity must be between 1 and 125");
|
|
// 构建Modbus TCP请求报文
|
byte[] request = new byte[12];
|
|
// 事务标识符（可以简单递增）
|
request[0] = 0x00;
|
request[1] = 0x01;
|
|
// 协议标识符（Modbus固定为0）
|
request[2] = 0x00;
|
request[3] = 0x00;
|
|
// 长度字段（后面还有6字节）
|
request[4] = 0x00;
|
request[5] = 0x06;
|
|
// 单元标识符
|
request[6] = unitIdentifier;
|
|
// 功能码（4表示读输入寄存器）
|
request[7] = 0x04;
|
|
// 起始地址
|
request[8] = (byte)(startingAddress >> 8);
|
request[9] = (byte)startingAddress;
|
|
// 寄存器数量
|
request[10] = (byte)(quantity >> 8);
|
request[11] = (byte)quantity;
|
|
// 发送请求
|
_networkStream.Write(request, 0, request.Length);
|
|
// 接收响应
|
byte[] responseHeader = new byte[8];
|
int bytesRead = _networkStream.Read(responseHeader, 0, 8);
|
|
if (bytesRead != 8)
|
throw new Exception("Invalid response header length");
|
|
// 检查事务ID和协议ID是否匹配
|
if (responseHeader[0] != request[0] || responseHeader[1] != request[1] ||
|
responseHeader[2] != 0x00 || responseHeader[3] != 0x00)
|
throw new Exception("Invalid response header");
|
|
// 检查单元标识符和功能码
|
if (responseHeader[6] != unitIdentifier)
|
throw new Exception("Unit identifier mismatch");
|
|
if (responseHeader[7] != 0x04 && responseHeader[7] != 0x84)
|
throw new Exception("Invalid function code in response");
|
|
// 检查异常响应
|
if (responseHeader[7] == 0x84) {
|
byte errorCode = responseHeader[8];
|
throw new Exception($"Modbus error response. Error code: {errorCode}");
|
}
|
|
// 读取剩余响应数据
|
byte byteCount = responseHeader[8];
|
byte[] responseData = new byte[byteCount];
|
bytesRead = _networkStream.Read(responseData, 0, byteCount);
|
|
if (bytesRead != byteCount)
|
throw new Exception("Invalid response data length");
|
|
// 解析寄存器值
|
int[] registers = new int[quantity];
|
for (int i = 0; i < quantity; i++) {
|
int offset = i * 2;
|
registers[i] = (ushort)((responseData[offset] << 8) | responseData[offset + 1]);
|
}
|
|
return registers;
|
}
|
|
public bool WriteSingleCoil(int address, bool value) {
|
// 请求报文固定长度12字节
|
byte[] request = new byte[12];
|
request[0] = 0x00; // 事务ID
|
request[1] = 0x01;
|
request[2] = 0x00; // 协议ID
|
request[3] = 0x00;
|
request[4] = 0x00; // 长度
|
request[5] = 0x06;
|
request[6] = unitIdentifier;
|
request[7] = 0x05; // 功能码
|
request[8] = (byte)(address >> 8); // 地址高字节
|
request[9] = (byte)address; // 地址低字节
|
request[10] = (byte)(value ? 0xFF : 0x00); // ON=0xFF00, OFF=0x0000
|
request[11] = 0x00;
|
|
_networkStream.Write(request, 0, request.Length);
|
|
// 响应应与请求完全一致（回显）
|
byte[] response = new byte[12];
|
int bytesRead = _networkStream.Read(response, 0, 12);
|
if (bytesRead != 12)
|
throw new Exception("Invalid response length");
|
|
// 校验回显报文
|
for (int i = 0; i < 12; i++) {
|
if (response[i] != request[i])
|
throw new Exception("Response does not match request");
|
}
|
return true;
|
}
|
|
public bool WriteSingleRegister(int address, ushort value) {
|
byte[] request = new byte[12];
|
request[0] = 0x00; // 事务ID
|
request[1] = 0x01;
|
request[2] = 0x00; // 协议ID
|
request[3] = 0x00;
|
request[4] = 0x00; // 长度
|
request[5] = 0x06;
|
request[6] = unitIdentifier;
|
request[7] = 0x06; // 功能码
|
request[8] = (byte)(address >> 8); // 地址高字节
|
request[9] = (byte)address;
|
request[10] = (byte)(value >> 8); // 值高字节
|
request[11] = (byte)value; // 值低字节
|
|
_networkStream.Write(request, 0, request.Length);
|
|
// 检查回显响应（同WriteSingleCoil）
|
byte[] response = new byte[12];
|
_networkStream.Read(response, 0, 12);
|
if (!response.SequenceEqual(request))
|
throw new Exception("Response mismatch");
|
|
return true;
|
}
|
|
public bool WriteMultipleCoils(int startingAddress, bool[] values) {
|
int quantity = values.Length;
|
if (quantity < 1 || quantity > 1968)
|
throw new ArgumentException("Quantity must be between 1 and 1968");
|
|
// 计算需要的字节数（每个字节存储8个线圈状态）
|
int byteCount = (quantity + 7) / 8;
|
byte[] coilBytes = new byte[byteCount];
|
|
// 将bool数组压缩为字节数组
|
for (int i = 0; i < quantity; i++) {
|
if (values[i]) {
|
int byteIndex = i / 8;
|
int bitIndex = i % 8;
|
coilBytes[byteIndex] |= (byte)(1 << bitIndex);
|
}
|
}
|
|
// 构建请求报文（13 + 线圈字节数）
|
byte[] request = new byte[13 + coilBytes.Length];
|
request[0] = 0x00; // 事务ID高字节
|
request[1] = 0x01; // 事务ID低字节
|
request[2] = 0x00; // 协议ID高字节
|
request[3] = 0x00; // 协议ID低字节
|
request[4] = (byte)((7 + coilBytes.Length) >> 8); // 长度高字节
|
request[5] = (byte)(7 + coilBytes.Length); // 长度低字节
|
request[6] = unitIdentifier;
|
request[7] = 0x0F; // 功能码（写多个线圈）
|
request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
|
request[9] = (byte)startingAddress; // 起始地址低字节
|
request[10] = (byte)(quantity >> 8); // 数量高字节
|
request[11] = (byte)quantity; // 数量低字节
|
request[12] = (byte)byteCount; // 字节数
|
Buffer.BlockCopy(coilBytes, 0, request, 13, coilBytes.Length);
|
|
// 发送请求
|
_networkStream.Write(request, 0, request.Length);
|
|
// 读取响应（固定12字节）
|
byte[] response = new byte[12];
|
int bytesRead = _networkStream.Read(response, 0, 12);
|
if (bytesRead != 12)
|
throw new Exception("Invalid response length");
|
|
// 校验回显的地址和数量
|
if (response[8] != request[8] || response[9] != request[9] ||
|
response[10] != request[10] || response[11] != request[11])
|
throw new Exception("Response address/quantity mismatch");
|
|
return true;
|
}
|
|
public bool WriteMultipleRegisters(int startingAddress, int[] values) {
|
int quantity = values.Length;
|
if (quantity < 1 || quantity > 123)
|
throw new ArgumentException("Quantity must be between 1 and 123");
|
|
// 将ushort数组转换为字节数组（大端序）
|
byte[] valueBytes = new byte[quantity * 2];
|
for (int i = 0; i < quantity; i++) {
|
valueBytes[i * 2] = (byte)(values[i] >> 8);
|
valueBytes[i * 2 + 1] = (byte)values[i];
|
}
|
|
// 构建请求报文（13 + 值字节数）
|
byte[] request = new byte[13 + valueBytes.Length];
|
request[0] = 0x00; // 事务ID高字节
|
request[1] = 0x01; // 事务ID低字节
|
request[2] = 0x00; // 协议ID高字节
|
request[3] = 0x00; // 协议ID低字节
|
request[4] = (byte)((7 + valueBytes.Length) >> 8); // 长度高字节
|
request[5] = (byte)(7 + valueBytes.Length); // 长度低字节
|
request[6] = unitIdentifier;
|
request[7] = 0x10; // 功能码（写多个寄存器）
|
request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
|
request[9] = (byte)startingAddress; // 起始地址低字节
|
request[10] = (byte)(quantity >> 8); // 数量高字节
|
request[11] = (byte)quantity; // 数量低字节
|
request[12] = (byte)(quantity * 2); // 字节数
|
Buffer.BlockCopy(valueBytes, 0, request, 13, valueBytes.Length);
|
|
// 发送请求
|
_networkStream.Write(request, 0, request.Length);
|
|
// 读取响应（固定12字节）
|
byte[] response = new byte[12];
|
int bytesRead = _networkStream.Read(response, 0, 12);
|
if (bytesRead != 12)
|
throw new Exception("Invalid response length");
|
|
// 校验回显的地址和数量
|
if (response[8] != request[8] || response[9] != request[9] ||
|
response[10] != request[10] || response[11] != request[11])
|
throw new Exception("Response address/quantity mismatch");
|
|
return true;
|
}
|
|
public void Dispose() {
|
_networkStream?.Dispose();
|
_tcpClient?.Dispose();
|
}
|
}
|
}
|
