C#使用Modbus TCP通讯PLC，实现读写寄存器

一、创建一个Moudbus类，引入NModbus和Modbus这两个包

 #region ModbusTCP
 public class NmodbusTcpHelper
 {
     // 静态成员变量，用于存储TcpClient实例
     private static TcpClient tcpClient = null;

     // 静态成员变量，用于存储ModbusIpMaster实例
     private static ModbusIpMaster master;

     // 连接到指定的IP和端口
     public static void Connect(string ip, int port, int MaxConnectTime)
     {
         try
         {
             // 创建一个新的TcpClient实例
             tcpClient = new TcpClient();

             // 尝试异步连接到指定的IP和端口，最多等待3000毫秒
             if (!tcpClient.ConnectAsync(ip, port).Wait(3000))
             {
                 // 如果连接失败，则抛出一个异常
                 throw new Exception(string.Format("客户端连接在{0}:{1}失败", ip, port));
             }
             else
             {
                 // 连接成功，创建ModbusIpMaster实例
                 master = ModbusIpMaster.CreateIp(tcpClient);

                 // 设置Modbus通信的读取超时时间为2000毫秒
                 master.Transport.ReadTimeout = 2000;

                 // 设置Modbus通信的写入超时时间为2000毫秒
                 master.Transport.WriteTimeout = 2000;

                 // 设置Modbus通信的重试次数为3次
                 master.Transport.Retries = 3;

                 // 设置Modbus通信的重试等待时间为1000毫秒
                 master.Transport.WaitToRetryMilliseconds = 1000;
             }
         }
         catch (Exception ex)
         {
             // 捕获异常并输出连接失败的消息
             Console.WriteLine("连接失败:" + ex.Message);
         }
     }
     /// <summary>
     /// 从指定的寄存器地址读取浮点数值（小字端）
     /// </summary>
     /// <param name="Adrss">寄存器地址的字符串表示</param>
     /// <returns>读取的浮点数值</returns>
     public static float Readfloat(string Adrss)
     {
         try
         {
             ushort Address = ushort.Parse(Adrss); // 将地址字符串转换为ushort类型
             ushort[] registers = master.ReadHoldingRegisters(1, Address, 2); // 读取指定寄存器数量（2个寄存器）的数据

             byte[] floatBytes = new byte[4]; // 创建一个字节数组用于存储浮点数的字节
             Buffer.BlockCopy(registers, 0, floatBytes, 0, 4); // 从寄存器中拷贝数据到字节数组

             float floatValue = BitConverter.ToSingle(floatBytes, 0); // 将字节数组转换为浮点数
             return floatValue;
         }
         catch (Exception)
         {
             Console.WriteLine("读取浮点数失败");
         }
         return 0; // 出现异常时返回0作为默认值
     }

     /// <summary>
     /// 将浮点数值写入指定的寄存器地址（小字端）
     /// </summary>
     /// <param name="Adrss">寄存器地址的字符串表示</param>
     /// <param name="Value">要写入的浮点数值的字符串表示</param>
     public static void Writefloat(string Adrss, float Value)
     {
         try
         {
             ushort Address = ushort.Parse(Adrss); // 将地址字符串转换为ushort类型
             ushort[] registers = new ushort[2]; // 创建一个ushort数组用于存储浮点数的寄存器值

             byte[] floatBytes = BitConverter.GetBytes(Value); // 将浮点数值转换为字节数组
             registers[0] = BitConverter.ToUInt16(floatBytes, 0); // 获取低位寄存器的值
             registers[1] = BitConverter.ToUInt16(floatBytes, 2); // 获取高位寄存器的值

             master.WriteMultipleRegisters(1, Address, registers); // 将寄存器值写入到指定地址
         }
         catch (Exception)
         {
             Console.WriteLine("写入浮点数失败");
         }
     }

     /// <summary>
     /// 将整数值写入指定的寄存器地址
     /// </summary>
     /// <param name="Adrss">寄存器地址的字符串表示</param>
     /// <param name="Value">要写入的整数值</param>
     public static void WriteInt(string Adrss, int Value)
     {
         try
         {
             ushort Address = ushort.Parse(Adrss); // 将地址字符串转换为ushort类型
             ushort[] registers = new ushort[1]; // 创建一个ushort数组用于存储整数值

             registers[0] = (ushort)Value; // 将整数值转换为ushort，并存储到寄存器数组中
             master.WriteMultipleRegisters(1, Address, registers); // 将寄存器值写入到指定地址
         }
         catch (Exception)
         {
             // 捕获并忽略异常，这里可以添加错误处理逻辑
         }
     }

     /// <summary>
     /// 从指定的寄存器地址读取整数值
     /// </summary>
     /// <param name="Adrss">寄存器地址的字符串表示</param>
     /// <returns>读取的整数值</returns>
     public static int ReadInt(string Adrss)
     {
         try
         {
             ushort Address = ushort.Parse(Adrss); // 将地址字符串转换为ushort类型
             ushort[] registers = master.ReadHoldingRegisters(1, Address, 1); // 读取一个寄存器

             int result = (int)registers[0]; // 将寄存器值转换为整数
             return result;
         }
         catch (Exception)
         {
             return -1; // 出现异常时返回-1作为默认值，或可以选择其他适当的默认值
         }
     }

     /// <summary>
     /// 将单个线圈的状态写入到指定的寄存器地址
     /// </summary>
     /// <param name="Adress">寄存器地址的字符串表示</param>
     /// <param name="status">要写入的线圈状态</param>
     public static void WriteCoil(string Adress, bool status)
     {
         try
         {
             byte SlaveID = Convert.ToByte(1); // 从站ID（假设为1）
             ushort Address = ushort.Parse(Adress); // 将地址字符串转换为ushort类型
             master.WriteSingleCoil(SlaveID, Address, status); // 写入线圈状态到指定地址
         }
         catch (Exception)
         {
             Console.WriteLine("写入线圈失败");
         }
     }

     /// <summary>
     /// 从指定的地址读取输入状态
     /// </summary>
     /// <param name="Address">输入地址的字符串表示</param>
     /// <returns>读取的输入状态</returns>
     public static bool ReadInput(string Address)
     {
         try
         {
             ushort CoilAddress = ushort.Parse(Address); // 将地址字符串转换为ushort类型
             byte SlaveID = Convert.ToByte(1); // 从站ID（假设为1）
             return master.ReadInputs(SlaveID, CoilAddress, 1)[0]; // 读取输入状态
         }
         catch (Exception)
         {
             throw; // 重新抛出异常，或可以选择其他异常处理机制
         }
     }

     /// <summary>
     /// 从指定的地址读取线圈状态
     /// </summary>
     /// <param name="Address">线圈地址的字符串表示</param>
     /// <returns>读取的线圈状态</returns>
     public static bool ReadCoil(string Address)
     {
         try
         {
             ushort CoilAddress = ushort.Parse(Address); // 将地址字符串转换为ushort类型
             byte SlaveID = Convert.ToByte(1); // 从站ID（假设为1）
             return master.ReadCoils(SlaveID, CoilAddress, 1)[0]; // 读取线圈状态
         }
         catch (Exception)
         {
             Console.WriteLine("读取线圈失败");
             return false; // 出现异常时返回false作为默认值
         }
     }
 }
 #endregion

二、以button按钮的点击事件为例连接PLC，根据实际情况填写IP、端口、和响应超时时间

 private void PLC_Open_btn_Click(object sender, EventArgs e)
 {
     NmodbusTcpHelper.Connect("192.168.1.1",502,2000);
 }

三、使用读写方法来实现对PLC寄存器的读写，本文以1000的寄存器地址为例，并且PLC的Slave ID为1（请根据实际情况来！）

 private void Operate_btn_Click(object sender, EventArgs e)
 {
     NmodbusTcpHelper.ReadInt("1000");
     NmodbusTcpHelper.WriteInt("1000",20);
     NmodbusTcpHelper.Readfloat("1000");
     NmodbusTcpHelper.Writefloat("1000", 20.00f);
     NmodbusTcpHelper.ReadCoil("1000");
     NmodbusTcpHelper.WriteCoil("1000",true);
 }