#region ModbusTCP客户端
public class ModbusTCP : IDisposable
{
#region 字段与属性
private TcpClient tcpClient; //----------------------------------------TCP 客户端实例
private NetworkStream stream; //---------------------------------------网络流，用于收发数据
private volatile bool connected
= false; //----------------------------当前连接状态
private readonly object socketLock
= new object(); //------------------锁，保证线程安全
private static ushort transId
= 1; //----------------------------------Modbus 事务ID，每次递增
string nameClient; //--------------------------------------------------客户端名称
private
string currentIp; //-------------------------------------------当前连接IP
private int currentPort; //--------------------------------------------当前连接端口
private volatile bool disposed
= false; //-----------------------------是否已释放资源
private readonly object responseLock
= new object(); //----------------响应锁
public del LogInfoDisplay; //-------------------------------------------委托变量-信息显示
public InfoMsg info
= new InfoMsg("", ""); //---------------------------显示信息
public event Action<
string> returnReceiveEvent;//-----------------------数据接收事件
//自动重连
private bool autoReconnect
= true; //----------------------------------自动重连，默认开启
private int maxReconnectAttempts
= 5; //-------------------------------重连次数
public bool Connected
=> connected; //---------------------------------连接状态
public bool AutoReconnect
{
get
=> autoReconnect;
set { lock (socketLock) autoReconnect
= value; }
}
public int MaxReconnectAttempts
{
get
=> maxReconnectAttempts;
set { lock (socketLock) maxReconnectAttempts
= value; }
}
public int ReconnectInterval { get; set; }
= 5000; //------------------重连间隔
public int Timeout { get; set; }
= 5000; //----------------------------超时时间（毫秒）
public int AddressOffset { get; set; }
= 0; //-------------------------地址偏移，默认M0对应0（如 D100 实际地址为100）
private static readonly object idLock
= new object();
private static ushort GenerateTransactionId()
{
lock (idLock)
{
return transId++;
}
}
private System.Timers.Timer heartbeatTimer; //-------------------------心跳定时器
#endregion
#region 数据类型枚举
/// <summary>
/// 读写数据类型
/// 字
= 16位（short），双字
= 32位（int）
/// </summary>
public enum DataType : short
{
字
= 1,
双字
= 2
}
/// <summary>
/// 寄存器内字节顺序（用于16位数据）
/// </summary>
public enum ByteOrder
{
BigEndian, // 高字节在前（AB）
LittleEndian // 低字节在前（BA）
}
/// <summary>
/// 定义32位数据在两个16位寄存器中的
存储顺序
/// </summary>
public enum WordOrder
{
/// <summary>
/// 高字在前，低字在后（如西门子、标准 Modbus）
/// 示例：0x12345678 → [0x1234][0x5678]
/// </summary>
HighFirst
= 1, // 高位寄存器在前（ABCD）
/// <summary>
/// 低字在前，高字在后（如三菱、欧姆龙常见）
/// 示例：0x12345678 → [0x5678][0x1234]
/// </summary>
LowFirst
= 2 // 低位寄存器在前（CDAB）
}
#endregion
#region 客户端初始化
/// <summary>
/// 客户端初始化
/// </summary>
/// <param name
="name">客户端名称</param>
/// <param name
="receiveData">接收数据事件</param>
/// <param name
="info">消息显示事件</param>
/// <param name
="addressOffset">地址偏移量（如M0对应0，则为0；若PLC从1开始则设为-1）</param>
public void Initialize(
string name
= "客户端", Action<
string> receiveData
= null, del info
= null,int addressOffset
= 0)
{
nameClient
= name; //-----------------------客户端名称
returnReceiveEvent +
= receiveData; //-------接收数据事件
LogInfoDisplay +
= info; //------------------消息事件
this.info.msgType
= nameClient; //----------log消息类型
this.AddressOffset
= addressOffset; //------地址偏移设置
}
/// <summary>
/// 配置自动重连
/// </summary>
/// <param name
="enabled">开启重连true/false</param>
/// <param name
="intervalMs">重连间隔</param>
/// <param name
="maxAttempts">重连次数</param>
public void ConfigureAutoReconnect(bool enabled, int intervalMs
= 5000, int maxAttempts
= 5)
{
AutoReconnect
= enabled;
ReconnectInterval
= intervalMs;
MaxReconnectAttempts
= maxAttempts;
}
/// <summary>
/// 配置并启用心跳功能
/// 通过定时器周期性向指定地址写入0/1交替信号，用于PLC监控连接状态
/// </summary>
/// <param name
="enabled">是否启用心跳功能，true
=启用，false
=禁用</param>
/// <param name
="address">心跳信号写入的PLC地址，如"D750"</param>
/// <param name
="intervalMs">心跳间隔时间，单位毫秒，默认500ms</param>
/// <example>
/// // 启用心跳，每500ms向D750地址写入0/1交替信号
/// modbusTCP.ConfigureHeartbeat(true, "D750", 500);
///
/// // 禁用心跳功能
/// modbusTCP.ConfigureHeartbeat(false);
/// </example>
public void ConfigureHeartbeat(bool enabled
= true,
string address
= "D700", int intervalMs
= 500)
{
// 停止并释放之前的心跳定时器，避免多个定时器同时运行
heartbeatTimer?.Stop(); // 停止定时器
heartbeatTimer?.Dispose(); // 释放定时器资源
heartbeatTimer
= null;
// 如果禁用心跳，直接返回
if (!enabled) return;
// 创建新的心跳定时器
heartbeatTimer
= new System.Timers.Timer(intervalMs);
bool state
= false; // 心跳状态标志，用于0/1交替
heartbeatTimer.Elapsed +
= async (s, e)
=>
{
try
{
if (!connected) return;
state
= !state;
await WriteSingleRegistersAsync(1, address, state ? 1 : 0);
}
catch (Exception ex)
{
// 异常必须在 async void 中捕获，否则会崩溃整个程序
Console.WriteLine("[Heartbeat] Exception: " + ex.Message);
}
};
heartbeatTimer.Start();
}
#endregion
#region 连接与断开
/// <summary>
/// 连接到 Modbus TCP 服务器
/// </summary>
/// <param name
="ip">PLC IP 地址</param>
/// <param name
="port">端口，默认 502</param>
/// <returns>是否连接成功</returns>
public bool Connect(
string ip, int port
= 502)
{
lock (socketLock)
{
if (connected) return true; // 已连接则直接返回
try
{
tcpClient
= new TcpClient();
tcpClient.SendTimeout
= Timeout;
tcpClient.ReceiveTimeout
= Timeout;
var result
= tcpClient.BeginConnect(IPAddress.Parse(ip), port,
null,
null);
var success
= result.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(Timeout));
if (!success)
{
info.msg
= $"连接超时 ({ip}:{port})";
LogInfoDisplay?.Invoke(info);
return false;
}
tcpClient.EndConnect(result);
stream
= tcpClient.GetStream();
connected
= true;
currentIp
= ip;
currentPort
= port;
info.msg
= $"连接成功 {ip}:{port}";
LogInfoDisplay?.Invoke(info);
return true;
}
catch (Exception ex)
{
info.msg
= $"连接失败: {ex.Message}";
LogInfoDisplay?.Invoke(info);
Disconnect();
HandleReconnection();
return false;
}
}
}
/// <summary>
/// 断开连接
/// </summary>
public void Disconnect()
{
lock (socketLock)
{
if (!connected) return;
try
{
connected
= false;
stream?.Close();
tcpClient?.Close();
stream
= null;
tcpClient
= null;
info.msg
= "已断开连接";
LogInfoDisplay?.Invoke(info);
}
catch (Exception ex)
{
info.msg
= $"断开异常: {ex.Message}";
LogInfoDisplay?.Invoke(info);
}
}
}
/// <summary>
/// 处理自动重连逻辑（避免阻塞主线程）
/// </summary>
private void HandleReconnection()
{
if (!AutoReconnect ||
string.Is
NullOrEmpty(currentIp)) return;
Task.Run(()
=>
{
int attempts
= 0;
while (!connected && !disposed && attempts < MaxReconnectAttempts)
{
Thread.Sleep(ReconnectInterval);
try
{
if (Connect(currentIp, currentPort))
{
info.msg
= "自动重连成功";
LogInfoDisplay?.Invoke(info);
break;
}
attempts++;
}
catch { }
}
});
}
#endregion
#region 发送请求
/// <summary>
/// 发送 Modbus 请求并等待响应
/// </summary>
/// <param name
="request">请求报文</param>
/// <param name
="expectedResponseLength">期望响应长度（用于校验）</param>
/// <returns>响应字节数组，失败返回
null</returns>
private async Task<byte[]> SendRequestAsync(byte[] request, int expectedResponseLength)
{
CancellationTokenSource cts
= new CancellationTokenSource();
try
{
cts.CancelAfter(Timeout); // 建议 Timeout >
= 3000
// 假设 tcpClient 已连接，networkStream
= tcpClient.GetStream()
if (stream
== null || !stream.CanWrite) return
null;
// 设置事务ID（大端字节序）
ushort transactionId
= GenerateTransactionId(); // 自增或随机生成
request[0]
= (byte)(transactionId >> 8);
request[1]
= (byte)(transactionId & 0xFF);
// 发送请求
await stream.WriteAsync(request, 0, request.Length).ConfigureAwait(false);
byte[] header
= new byte[6]; // 先读6字节获取 Length
int read
= await ReadExactAsync(stream, header, 0, 6, cts.Token).ConfigureAwait(false);
if (read !
= 6)
return
null;
// 校验 Protocol ID
short protocolId
= (short)((header[2] << 8) | header[3]);
if (protocolId !
= 0)
{
Console.WriteLine($"协议ID
错误: {protocolId}");
return
null;
}
// 解析后续长度（第5-6字节）
int pduLength
= (header[4] << 8) | header[5];
int totalResponseLength
= 6 + pduLength;
byte[] response
= new byte[totalResponseLength];
Array.Copy(header, 0, response, 0, 6);
if (pduLength > 0)
{
read
= await ReadExactAsync(stream, response, 6, pduLength, cts.Token).ConfigureAwait(false);
if (read !
= pduLength)
return
null;
if (returnReceiveEvent !
= null)
{
string hex
String = BitConverter.To
String(response).Replace("-", " ");
returnReceiveEvent(hex
String);
}
}
// 校验 Transaction ID
ushort responseTid
= (ushort)((response[0] << 8) | response[1]);
if (responseTid !
= transactionId)
{
Console.WriteLine("事务ID不匹配");
return
null;
}
// 检查异常码
if (pduLength >
= 2 && (response[7] & 0x80)
== 0x80)
{
Console.WriteLine($"Modbus 异常码: 0x{response[8]:X2}");
return
null;
}
// 最终长度校验
if (response.Length < expectedResponseLength)
{
Console.WriteLine("响应长度不足");
return
null;
}
return response;
}
catch (TimeoutException)
{
Console.WriteLine("通信超时：等待响应时间过长");
return
null;
}
catch (Exception ex)
{
Console.WriteLine("通信异常: " + ex.Message);
connected
= false;
return
null;
}
finally
{
// 必须手动 Dispose
cts?.Dispose();
}
}
/// <summary>
/// 确保异步读取指定数量的字节
/// </summary>
private async Task<int> ReadExactAsync(NetworkStream stream, byte[] buffer, int offset, int count, CancellationToken ct
= default)
{
int totalRead
= 0;
while (totalRead < count)
{
try
{
int read
= await stream.ReadAsync(buffer, offset + totalRead, count - totalRead, ct).ConfigureAwait(false);
if (read
== 0) break; // 连接关闭
totalRead +
= read;
}
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
{
throw new TimeoutException("读取超时");
}
}
return totalRead;
}
#endregion
#region 地址解析
/// <summary>
/// 如 PLC 地址从 1 开始编号，则设置 AddressOffset
= -1
/// 解析地址字符串如 "D100" -> 实际地址 99（若偏移-1）
/// </summary>
private ushort ParseAddress(
string address)
{
if (
string.Is
NullOrEmpty(address) || address.Length < 2)
throw new ArgumentException("地址格式
错误");
char type
= char.ToUpper(address[0]);
string numPart
= address.Sub
string(1).Split('.')[0]; // 忽略位索引
if (!int.TryParse(numPart, out int rawAddr))
throw new ArgumentException("地址数值无效");
int baseAddress;
switch (type)
{
case 'D':
case 'M':
case 'X':
case 'Y':
baseAddress
= 0x0000;
break;
default:
throw new ArgumentException($"不支持的地址类型: {type}");
}
int finalAddr
= baseAddress + rawAddr + AddressOffset;
if (finalAddr < 0 || finalAddr > 65535)
throw new ArgumentException("地址超出范围");
return (ushort)finalAddr;
}
#endregion
#region 读取线圈寄存器(M寄存器)
/// <summary>
/// 读取线圈寄存器（功能码01）
/// </summary>
/// <param name
="ID">客户端ID</param>
/// <param name
="address">地址</param>
/// <param name
="length">长度</param>
/// <returns>值</returns>
public async Task<bool[]> ReadCoilsAsync(byte ID,
string address, int length)
{
if (length <
= 0) length
= 1;
if (length > 2048) length
= 2048;
ushort addr
= ParseAddress(address);
int byteCount
= (length + 7) / 8;
byte[] request
= new byte[12];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= 0x00; request[5]
= 0x06; //----后续长度：6字节(PDU)
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x01; //-----------------------功能码(读线圈)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(length >> 8); //-------数量高字节
request[11]
= (byte)(length & 0xFF); //-----数量低字节
byte[] response
= await SendRequestAsync(request, 9 + byteCount).ConfigureAwait(false);
if (response
== null || response.Length < 9 + byteCount) return
null;
bool[] result
= new bool[length];
for (int i
= 0; i < length; i++)
{
int byteIdx
= i / 8;
int bitIdx
= i % 8;
result[i]
= (response[9 + byteIdx] & (1 << bitIdx)) !
= 0;
}
return result;
}
#endregion
#region 读取输入状态
/// <summary>
/// 读取输入状态（功能码02）
/// </summary>
/// <param name
="ID">客户端ID</param>
/// <param name
="address">地址</param>
/// <param name
="length">长度</param>
/// <returns>值</returns>
public async Task<bool[]> ReadDiscreteInputsAsync(byte ID,
string address, int length)
{
if (length <
= 0) length
= 1;
if (length > 2048) length
= 2048;
ushort addr
= ParseAddress(address);
int byteCount
= (length + 7) / 8;
byte[] request
= new byte[12];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= 0x00; request[5]
= 0x06; //----后续长度：6字节(PDU)
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x02; //-----------------------功能码(读离散输入)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(length >> 8); //-------数量高字节
request[11]
= (byte)(length & 0xFF); //-----数量低字节
byte[] response
= await SendRequestAsync(request, 9 + byteCount).ConfigureAwait(false);
if (response
== null || response.Length < 9 + byteCount) return
null;
bool[] result
= new bool[length];
for (int i
= 0; i < length; i++)
{
int byteIdx
= i / 8;
int bitIdx
= i % 8;
result[i]
= (response[9 + byteIdx] & (1 << bitIdx)) !
= 0;
}
return result;
}
#endregion
#region 读取保持寄存器(D寄存器)
/// <summary>
/// 读取保持寄存器（功能码03）
/// </summary>
/// <param name
="ID">客户端ID</param>
/// <param name
="address">地址</param>
/// <param name
="length">长度</param>
/// <param name
="type">类型</param>
/// <returns>值</returns>
public async Task<int[]> ReadHoldingRegistersAsync(byte ID,
string address, int length, DataType type
= DataType.字)
{
if (length <
= 0) length
= 1;
if (length > 125) length
= 125;
ushort addr
= ParseAddress(address);
ushort regCount
= (ushort)(length * (ushort)type);
byte[] request
= new byte[12];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= 0x00; request[5]
= 0x06; //----后续长度：6字节(PDU)
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x03; //-----------------------功能码(读保持寄存器)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(regCount >> 8); //-----数量高字节
request[11]
= (byte)(regCount & 0xFF); //---数量低字节
byte[] response
= await SendRequestAsync(request, 9 + regCount * 2).ConfigureAwait(false);
if (response
== null || response.Length < 9 + regCount * 2) return
null;
return ParseRegisterResponse(response, length, type);
}
/// <summary>
/// 解析寄存器响应(16位和32位)
/// </summary>
private int[] ParseRegisterResponse(byte[] response, int length, DataType type, ByteOrder byteOrder
= ByteOrder.BigEndian, WordOrder wordOrder
= WordOrder.HighFirst)
{
int[] result
= new int[length];
if (type
== DataType.字)
{
for (int i
= 0; i < length; i++)
{
int dataIndex
= 9 + i * 2;
if (dataIndex + 1 < response.Length)
{
ushort value;
if (byteOrder
== ByteOrder.BigEndian)
{
value
= (ushort)(response[dataIndex] << 8 | response[dataIndex + 1]); // AB
}
else
{
value
= (ushort)(response[dataIndex] | response[dataIndex + 1] << 8); // BA
}
result[i]
= (short)value; // 直接转换为有符号short
}
}
}
else //双字
{
for (int i
= 0; i < length; i++)
{
int dataIndex
= 9 + i * 4;
if (dataIndex + 3 < response.Length)
{
// Step 1: 先按字节序读两个16位寄存器
ushort reg1, reg2;
if (byteOrder
== ByteOrder.BigEndian)
{
reg1
= (ushort)(response[dataIndex] << 8 | response[dataIndex + 1]);
reg2
= (ushort)(response[dataIndex + 2] << 8 | response[dataIndex + 3]);
}
else
{
reg1
= (ushort)(response[dataIndex + 1] << 8 | response[dataIndex]);
reg2
= (ushort)(response[dataIndex + 3] << 8 | response[dataIndex + 2]);
}
// Step 2: 再按字序组合
uint value;
if (wordOrder
== WordOrder.HighFirst)
{
value
= ((uint)reg1 << 16) | reg2;
}
else
{
value
= ((uint)reg2 << 16) | reg1;
}
result[i]
= (int)value; // 自动处理补码
}
}
}
return result;
}
#endregion
#region 读取输入寄存器
/// <summary>
/// 读取输入寄存器（功能码04）
/// </summary>
/// <param name
="ID">客户端ID</param>
/// <param name
="address">地址</param>
/// <param name
="length">长度</param>
/// <param name
="type">类型</param>
/// <returns>值</returns>
public async Task<int[]> ReadInputRegistersAsync(byte ID,
string address, int length, DataType type
= DataType.字)
{
if (length <
= 0) length
= 1;
if (length > 125) length
= 125;
ushort addr
= ParseAddress(address);
ushort regCount
= (ushort)(length * (ushort)type);
byte[] request
= new byte[12];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= 0x00; request[5]
= 0x06; //----后续长度：6字节(PDU)
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x04; //-----------------------功能码(读输入寄存器)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(regCount >> 8); //-----数量高字节
request[11]
= (byte)(regCount & 0xFF); //---数量低字节
byte[] response
= await SendRequestAsync(request, 9 + regCount * 2).ConfigureAwait(false);
if (response
== null || response.Length < 9 + regCount * 2) return
null;
return ParseRegisterResponse(response, length, type);
}
#endregion
#region 写入单个线圈寄存器值(M寄存器)
/// <summary>
/// 写入单个线圈寄存器值（功能码05）
/// </summary>
/// <param name
="ID">客户端ID</param>
/// <param name
="address">地址</param>
/// <param name
="value">值</param>
public async Task<bool> WriteSingleCoilsAsync(byte ID,
string address, bool value)
{
if (!connected) return false;
ushort addr
= ParseAddress(address);
byte[] request
= new byte[12];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= 0x00; request[5]
= 0x06; //----后续长度：6字节(PDU)
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x05; //-----------------------功能码(写单个线圈)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(value ? 0xFF : 0x00); //数据(FF表示ON,00表示OFF)
request[11]
= 0x00; //----------------------数据(固定0x00)
try
{
byte[] response
= await SendRequestAsync(request, 12).ConfigureAwait(false);
return response !
= null && response.Length >
= 12 &&
response[7]
== 0x05 && (response[8] << 8 | response[9])
== addr;
}
catch { return false; }
}
#endregion
#region 写入单个保持寄存器值(D寄存器)
/// <summary>
/// 写入单个保持寄存器值（功能码06）（功能码16）
/// </summary>
/// <param name
="ID">设备ID</param>
/// <param name
="address">地址</param>
/// <param name
="value">值（16位或32位）</param>
/// <param name
="type">数据类型（字
=16位，双字
=32位）</param>
/// <returns>是否写入成功</returns>
public async Task<bool> WriteSingleRegistersAsync(byte ID,
string address, int value, DataType type
= DataType.字)
{
if (!connected) return false;
if (type
== DataType.字)
{
return await WriteSingleRegister16(ID, address, (short)value);
}
else
{
return await WriteDoubleRegister32(ID, address, (int)value);
}
}
/// <summary>
/// 16位写入实现（功能码06）
/// </summary>
/// <param name
="ID"></param>
/// <param name
="address"></param>
/// <param name
="value"></param>
/// <returns></returns>
private async Task<bool> WriteSingleRegister16(byte ID,
string address, short value)
{
ushort addr
= ParseAddress(address);
ushort uvalue
= (ushort)value;
byte[] request
= new byte[12];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= 0x00; request[5]
= 0x06; //----后续长度：6字节(PDU)
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x06; //-----------------------功能码(写16位保存寄存器)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(uvalue >> 8); //-------数量高字节
request[11]
= (byte)(uvalue & 0xFF); //-----数量低字节
byte[] response
= await SendRequestAsync(request, 12).ConfigureAwait(false);
return response !
= null && response.Length >
= 12 &&
response[7]
== 0x06 && (response[8] << 8 | response[9])
== addr;
}
/// <summary>
/// 32位写入实现（功能码16）
/// </summary>
/// <param name
="ID"></param>
/// <param name
="address"></param>
/// <param name
="value"></param>
/// <returns></returns>
private async Task<bool> WriteDoubleRegister32(byte ID,
string address, int value, WordOrder wordOrder
= WordOrder.HighFirst)
{
short hiWord
= (short)(value >> 16);
short loWord
= (short)(value & 0xFFFF);
short[] words
= wordOrder
== WordOrder.HighFirst ?
new[] { hiWord, loWord } :
new[] { loWord, hiWord };
return await WriteMultipleRegistersAsync(ID, address, words);
}
#endregion
#region 写入多个线圈寄存器值(M寄存器)
/// <summary>
/// 写入多个线圈寄存器值（功能码15）- 所有线圈写入相同值
/// </summary>
/// <param name
="ID">设备ID</param>
/// <param name
="address">起始地址（如"M100"）</param>
/// <param name
="length">写入的线圈数量</param>
/// <param name
="value">所有线圈的状态（true
=ON, false
=OFF）</param>
/// <returns>是否写入成功</returns>
/// <example>
/// WriteMultipleCoils(1, "M100", 2, true);
/// // 写入M100
=true, M101
=true
/// WriteMultipleCoils(1, "M100", 5, false);
/// // 写入M100~M104全部为false
/// </example>
public async Task<bool> WriteMultipleCoilsAsync(byte ID,
string address, int length, bool value)
{
if (!connected) return false;
bool[] values
= new bool[length];
for (int i
= 0; i < length; i++) values[i]
= value;
return await WriteMultipleCoilsAsync(ID, address, values);
}
/// <summary>
/// 写入多个线圈寄存器值（bool数组版本）- 每个线圈独立控制
/// </summary>
/// <param name
="ID">设备ID</param>
/// <param name
="address">起始地址</param>
/// <param name
="values">每个线圈的状态数组</param>
/// <returns>是否写入成功</returns>
/// <example>
/// WriteMultipleCoils(1, "M100", new bool[] { true, false, true });
/// // 写入M100
=true, M101
=false, M102
=true
/// </example>
public async Task<bool> WriteMultipleCoilsAsync(byte ID,
string address, bool[] values)
{
if (!connected) return false;
ushort addr
= ParseAddress(address);
int byteCount
= (values.Length + 7) / 8;
byte[] coilBytes
= new byte[byteCount];
for (int i
= 0; i < values.Length; i++)
{
if (values[i])
coilBytes[i / 8] |
= (byte)(1 << (i % 8));
}
byte[] request
= new byte[13 + byteCount];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= (byte)((request.Length - 6) >> 8);
request[5]
= (byte)((request.Length - 6) & 0xFF);
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x0F; //-----------------------功能码(写多线圈寄存器)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(values.Length >> 8); //数量高字节
request[11]
= (byte)(values.Length & 0xFF);//数量低字节
request[12]
= (byte)byteCount;
Array.Copy(coilBytes, 0, request, 13, byteCount);
byte[] response
= await SendRequestAsync(request, 12).ConfigureAwait(false);
return response !
= null && response.Length >
= 12;
}
#endregion
#region 写入多个保持寄存器值(D寄存器)
/// <summary>
/// 写入多个保持寄存器值（功能码16） - 所有寄存器写入相同值
/// </summary>
/// <param name
="ID">设备ID</param>
/// <param name
="address">起始地址（如"D100"）</param>
/// <param name
="length">写入的寄存器数量</param>
/// <param name
="value">所有寄存器的值</param>
/// <param name
="type">数据类型（字
=16位，双字
=32位）</param>
/// <returns>是否写入成功</returns>
/// <example>
/// WriteMultipleRegister(1, "D100", 3, 100);
/// // 写入D100
=100, D101
=100, D102
=100
/// WriteMultipleRegister(1, "D200", 2, 123456789, ReadTypeEnum.双字);
/// // 写入D200-D201
=123456789, D202-D203
=123456789
/// </example>
public async Task<bool> WriteMultipleRegistersAsync(byte ID,
string address, int length, int value, DataType type
= DataType.字)
{
if (!connected) return false;
if (type
== DataType.字)
{
short[] arr
= new short[length];
for (int i
= 0; i < length; i++) arr[i]
= (short)value;
return await WriteMultipleRegistersAsync(ID, address, arr);
}
else
{
short[] arr
= new short[length * 2];
for (int i
= 0; i < length; i++)
{
arr[i * 2]
= (short)(value >> 16);
arr[i * 2 + 1]
= (short)(value & 0xFFFF);
}
return await WriteMultipleRegistersAsync(ID, address, arr);
}
}
/// <summary>
/// 写入多个保持寄存器值（功能码16）
/// </summary>
/// <param name
="ID"></param>
/// <param name
="address"></param>
/// <param name
="values"></param>
/// <returns></returns>
private async Task<bool> WriteMultipleRegistersAsync(byte ID,
string address, short[] values)
{
ushort addr
= ParseAddress(address);
byte[] request
= new byte[13 + values.Length * 2];
// 构建 Modbus TCP 请求报文
request[0]
= 0; request[1]
= 0; //----------事务ID(由 SendRequestAsync 填充或自动生成）
request[2]
= 0x00; request[3]
= 0x00; //----协议ID
request[4]
= (byte)((request.Length - 6) >> 8);
request[5]
= (byte)((request.Length - 6) & 0xFF);
request[6]
= ID; //-------------------------单元标识符ID
request[7]
= 0x10; //-----------------------功能码(写多保存寄存器)
request[8]
= (byte)(addr >> 8); //----------起始地址高字节
request[9]
= (byte)(addr & 0xFF); //--------起始地址低字节
request[10]
= (byte)(values.Length >> 8); //数量高字节
request[11]
= (byte)(values.Length & 0xFF);//数量低字节
request[12]
= (byte)(values.Length * 2);
for (int i
= 0; i < values.Length; i++)
{
request[13 + i * 2]
= (byte)(values[i] >> 8);
request[13 + i * 2 + 1]
= (byte)(values[i] & 0xFF);
}
byte[] response
= await SendRequestAsync(request, 12).ConfigureAwait(false);
return response !
= null && response.Length >
= 12 && response[7]
== 0x10 &&
(response[8] << 8 | response[9])
== addr &&
(response[10] << 8 | response[11])
== values.Length;
}
#endregion
#region 同步支持
/// <summary>
/// 读取线圈寄存器（功能码01）
/// </summary>
public bool[] ReadCoils(byte ID,
string address, int length)
{
return ReadCoilsAsync(ID, address, length).GetAwaiter().GetResult();
}
/// <summary>
/// 读取输入状态（功能码02）
/// </summary>
public bool[] ReadDiscreteInputs(byte ID,
string address, int length)
{
return ReadDiscreteInputsAsync(ID, address, length).GetAwaiter().GetResult();
}
/// <summary>
/// 读取保持寄存器（功能码03）
/// </summary>
public int[] ReadHoldingRegisters(byte ID,
string address, int length, DataType type
= DataType.字)
{
return ReadHoldingRegistersAsync(ID, address, length, type).GetAwaiter().GetResult();
}
/// <summary>
/// 读取输入寄存器（功能码04）
/// </summary>
public int[] ReadInputRegisters(byte ID,
string address, int length, DataType type
= DataType.字)
{
return ReadInputRegistersAsync(ID, address, length, type).GetAwaiter().GetResult();
}
/// <summary>
/// 写入单个线圈（功能码05）
/// </summary>
public bool WriteSingleCoils(byte ID,
string address, bool value)
{
return WriteSingleCoilsAsync(ID, address, value).GetAwaiter().GetResult();
}
/// <summary>
/// 写入单个寄存器（功能码06 或 16）
/// </summary>
public bool WriteSingleRegisters(byte ID,
string address, int value, DataType type
= DataType.字)
{
return WriteSingleRegistersAsync(ID, address, value, type).GetAwaiter().GetResult();
}
/// <summary>
/// 写入多个线圈（相同值）（功能码15）
/// </summary>
public bool WriteMultipleCoils(byte ID,
string address, int length, bool value)
{
return WriteMultipleCoilsAsync(ID, address, length, value).GetAwaiter().GetResult();
}
/// <summary>
/// 写入多个线圈（数组）（功能码15）
/// </summary>
public bool WriteMultipleCoils(byte ID,
string address, bool[] values)
{
return WriteMultipleCoilsAsync(ID, address, values).GetAwaiter().GetResult();
}
/// <summary>
/// 写入多个寄存器（相同值）（功能码16）
/// </summary>
public bool WriteMultipleRegisters(byte ID,
string address, int length, int value, DataType type
= DataType.字)
{
return WriteMultipleRegistersAsync(ID, address, length, value, type).GetAwaiter().GetResult();
}
#endregion
#region 客户端关闭
/// <summary>
/// 释放所有资源
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposed) return;
disposed
= true;
if (disposing)
{
// 释放托管资源
heartbeatTimer?.Dispose();
stream?.Dispose();
tcpClient?.Dispose();
}
}
#endregion
}
#endregion这是我的modbus代码。private void btn_桌盘_Click(object sender, EventArgs e)
{
automation.modbusTCP.WriteSingleCoilsAsync(1, "M16", true);
//automation.modbusTCP.WriteSingleRegistersAsync(1, "D0", 100);
//automation.modbusTCP.WriteMultipleRegistersAsync(1, "D1" , 4, 50);
//bool[] result
= await automation.modbusTCP.ReadCoilsAsync(1, "M0", 1);
}这是一个写入寄存器代码。private void btn_自动切屏_Click(object sender, EventArgs e)
{
//automation.modbusTCP.WriteSingleCoilsAsync(1, "M1000", true);
bool[] result
= automation.modbusTCP.ReadCoils(1, "M16", 1);
if (result !
= null && result.Length > 0)
{
bool m16Value
= result[0];
MessageBox.Show("M16
= " + m16Value);
}
else
{
MessageBox.Show("读取失败");
}
}这是读寄存器代码。用modbusSlave测试读写都可以正常实现。但是有这么一种情况。private void btn_桌盘_Click(object sender, EventArgs e)
{
automation.modbusTCP.WriteSingleCoilsAsync(1, "M16", true);
automation.modbusTCP.WriteSingleRegistersAsync(1, "D0", 100);
automation.modbusTCP.WriteMultipleRegistersAsync(1, "D1" , 4, 50);
//bool[] result
= await automation.modbusTCP.ReadCoilsAsync(1, "M0", 1);
}这个代码写多个。private void btn_自动切屏_Click(object sender, EventArgs e)
{
//automation.modbusTCP.WriteSingleCoilsAsync(1, "M1000", true);
bool[] result
= automation.modbusTCP.ReadCoils(1, "M16", 1);
if (result !
= null && result.Length > 0)
{
bool m16Value
= result[0];
MessageBox.Show("M16
= " + m16Value);
}
else
{
MessageBox.Show("读取失败");
}
}这个保持不变。这时候如果先写入寄存器，能写入成功，但是读寄存器总是失败。如果先读就没事
本文讲解了如何正确初始化数组以防止出现空指针异常的问题，通过对比错误与正确的代码示例，帮助读者理解并掌握这一基本概念。
扫一扫
3564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
