完善TcpClient方式与产线设备交互、托盘下线的轮询和Debug测试逻辑

kazelee

2025-06-25 3daf4392ed4b720d67067180c51d986cef806bbe

 device/ModbusFactory.cs

@@ -8,6 +8,7 @@
using System.Linq;

using TcpClient = System.Net.Sockets.TcpClient;
using System.IO;

namespace HH.WCS.Mobox3.DSZSH.device {
    // 定义Modbus通讯接口
@@ -48,13 +49,31 @@
        /// <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);
    }

@@ -80,7 +99,15 @@
        }

        static void Test() {
            var communicator = ModbusFactory.CreateCommunicator(ModbusCommunicationType.TcpSocket);
            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);
            }
        }
    }

@@ -134,16 +161,19 @@

        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");
                        LogHelper.Info($"读取成功：ReadCoils:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadCoils");
                        LogHelper.Info($"读取失败：ReadCoils:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -151,23 +181,26 @@
                }
            }
            else {
                LogHelper.Info($"设备未连接，读取失败：ReadCoils");
                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");
                        LogHelper.Info($"读取成功：ReadDiscreteInputs:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadDiscreteInputs");
                        LogHelper.Info($"读取失败：ReadDiscreteInputs:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -175,7 +208,7 @@
                }
            }
            else {
                LogHelper.Info($"设备未连接，读取失败：ReadDiscreteInputs");
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -183,26 +216,28 @@
        public int[] ReadHoldingRegisters(int startingAddress, int quantity) {
            int[] res = new int[0];
            var client = _modbusClient;
            var ip = client.IPAddress;
            var port = client.Port;
            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.Info($"发生了异常:{ex.Message},IP:{ip},Port:{port}", "Error");
                    LogHelper.InfoEx(ex);
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象:IP:{ip},Port:{port}");
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -210,24 +245,26 @@
        public int[] ReadInputRegisters(int startingAddress, int quantity) {
            int[] res = new int[0];
            var client = _modbusClient;
            var ip = client.IPAddress;
            var port = client.Port;
            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;
        }
@@ -235,25 +272,27 @@
        public bool WriteSingleCoil(int coilAddress, bool value) {
            var res = false;
            var client = _modbusClient;
            var ip = client.IPAddress;
            var port = client.Port;
            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;
        }
@@ -261,25 +300,27 @@
        public bool WriteSingleRegister(int registerAddress, ushort value) {
            var res = false;
            var client = _modbusClient;
            var ip = client.IPAddress;
            var port = client.Port;
            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;
        }
@@ -287,26 +328,28 @@
        public bool WriteMultipleCoils(int startingAddress, bool[] values) {
            var res = false;
            var client = _modbusClient;
            var ip = client.IPAddress;
            var port = client.Port;
            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;
        }
@@ -314,33 +357,34 @@
        public bool WriteMultipleRegisters(int startingAddress, int[] values) {
            var res = false;
            var client = _modbusClient;
            var ip = client.IPAddress;
            var port = client.Port;
            var log = string.Join(",", values.Select(x => x.ToString()));
            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($"写入成功,IP:{ip},Port:{port},{log}");
                        LogHelper.Info($"写入成功,WriteMultipleRegisters:IP:{ip},Port:{port},{log}");
                    }
                    else {
                        LogHelper.Info($"写入失败,IP:{ip},Port:{port},{log}");
                        LogHelper.Info($"写入失败,WriteMultipleRegisters:IP:{ip},Port:{port},{log}");
                    }
                }
                catch (Exception ex) {
                    LogHelper.Info($"发生了异常:{ex.Message},IP:{ip},Port:{port},{log}", "Error");
                    LogHelper.InfoEx(ex);
                }
            }
            else {
                LogHelper.Info($"未配置的设备信息,IP:{ip},Port:{port},{log}");
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }

        public void Dispose() {
            //_modbusClient?.Dispose();
            GC.SuppressFinalize(_modbusClient);
        }
    }

@@ -348,9 +392,10 @@
    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 true; } else { return false; } } }
        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();
@@ -372,50 +417,407 @@
            }
        }

        // 以下方法需要根据你的Modbus TCP协议具体实现
        public bool[] ReadCoils(int startingAddress, int quantity) {
            // 实现TCP方式读取线圈
            throw new NotImplementedException();
            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) {
            // 实现TCP方式读取离散输入
            throw new NotImplementedException();
            // 报文结构与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) {
            // 实现TCP方式读取保持寄存器
            throw new NotImplementedException();
            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) {
            // 实现TCP方式读取输入寄存器
            throw new NotImplementedException();
            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 coilAddress, bool value) {
            // 实现TCP方式写入单个线圈
            throw new NotImplementedException();
        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 registerAddress, ushort value) {
            // 实现TCP方式写入单个寄存器
            throw new NotImplementedException();
        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) {
            // 实现TCP方式写入多个线圈
            throw new NotImplementedException();
            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) {
            // 实现TCP方式写入多个寄存器
            throw new NotImplementedException();
            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();
            _tcpClient?.Dispose();
        }
    }
}