C# modbusTCP从机类编写

以下是一个简单的 C# Modbus TCP 从机类编写示例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace ModbusTcpSlave
{
    class ModbusTcpSlave
    {
        private const int Port = 502;
        private TcpListener _listener;
        private TcpClient _client;
        private NetworkStream _stream;

        // Modbus address range
        private const int StartAddress = 0;
        private const int EndAddress = 100;

        // Modbus register values
        private readonly ushort[] _registers = new ushort[EndAddress - StartAddress + 1];

        public ModbusTcpSlave()
        {
            _listener = new TcpListener(IPAddress.Any, Port);
        }

        public void Start()
        {
            _listener.Start();
            Console.WriteLine("Modbus TCP slave started");

            while (true)
            {
                Console.WriteLine("Waiting for client connection...");
                _client = _listener.AcceptTcpClient();
                Console.WriteLine("Client connected");

                _stream = _client.GetStream();

                while (_client.Connected)
                {
                    // Read the Modbus TCP request
                    var request = new byte[12];
                    _stream.Read(request, 0, request.Length);

                    // Check if the request is a read or write request
                    if (request[7] == 3) // Read request
                    {
                        var startAddress = (ushort)(request[8] << 8 | request[9]);
                        var numRegisters = (ushort)(request[10] << 8 | request[11]);

                        // Check if the requested address is within range
                        if (startAddress >= StartAddress && startAddress + numRegisters <= EndAddress)
                        {
                            // Build the Modbus TCP response
                            var response = new byte[9 + 2 * numRegisters];
                            response[0] = request[0];
                            response[1] = request[1];
                            response[2] = request[2];
                            response[3] = request[3];
                            response[4] = (byte)(5 + 2 * numRegisters);
                            response[5] = request[5];
                            response[6] = request[6];
                            response[7] = request[7];
                            response[8] = (byte)(2 * numRegisters);

                            // Fill in the register values
                            for (var i = 0; i < numRegisters; i++)
                            {
                                var address = startAddress + i - StartAddress;
                                var value = _registers[address];
                                response[9 + 2 * i] = (byte)(value >> 8);
                                response[10 + 2 * i] = (byte)value;
                            }

                            // Send the response
                            _stream.Write(response, 0, response.Length);
                        }
                    }
                    else if (request[7] == 16) // Write request
                    {
                        var startAddress = (ushort)(request[8] << 8 | request[9]);
                        var numRegisters = (ushort)(request[10] << 8 | request[11]);
                        var numBytes = request[12];

                        // Check if the requested address is within range
                        if (startAddress >= StartAddress && startAddress + numRegisters <= EndAddress)
                        {
                            // Write the register values
                            for (var i = 0; i < numRegisters; i++)
                            {
                                var address = startAddress + i - StartAddress;
                                var value = (ushort)(request[13 + 2 * i] << 8 | request[14 + 2 * i]);
                                _registers[address] = value;
                            }

                            // Build the Modbus TCP response
                            var response = new byte[12];
                            response[0] = request[0];
                            response[1] = request[1];
                            response[2] = request[2];
                            response[3] = request[3];
                            response[4] = 0;
                            response[5] = 6;
                            response[6] = request[6];
                            response[7] = request[7];
                            response[8] = request[8];
                            response[9] = request[9];
                            response[10] = request[10];
                            response[11] = request[11];

                            // Send the response
                            _stream.Write(response, 0, response.Length);
                        }
                    }
                }
            }
        }

        public void Stop()
        {
            _listener.Stop();
            Console.WriteLine("Modbus TCP slave stopped");
        }
    }
}

该类可以创建一个 Modbus TCP 从机，并提供读写寄存器的功能。在示例中，Modbus 寄存器的地址范围为 0 到 100，寄存器的值存储在 `_registers` 数组中。该类使用了 C# 的 TcpListener 和 TcpClient 类来监听和处理客户端请求，使用 NetworkStream 对象来进行数据传输。当有客户端连接时，该类会进入一个循环，不断监听客户端的请求并进行处理。如果请求是一个读取请求，则该类会根据请求的起始地址和寄存器数量来读取寄存器的值，并将结果发送回客户端。如果请求是一个写入请求，则该类会根据请求的起始地址和寄存器数量来写入寄存器的值，并向客户端发送确认响应。