C#基于NModbus实现MODBUSTCP字符串、浮点数读写

最新推荐文章于 2024-08-08 20:05:02 发布
最新推荐文章于 2024-08-08 20:05:02 发布
阅读量1.3w 收藏 76
点赞数 12
分类专栏： C#教程 文章标签： c#
原文链接：https://www.cnblogs.com/Samberger/p/13039429.html
版权

引用NModbus
在NuGet搜索NModbus，添加引用。
在这里插入图片描述

封装ModbusTcp类
public class ModbusTCP
{
private ModbusFactory modbusFactory;
private IModbusMaster master;
private TcpClient tcpClient;

    public string IPAdress { get; set; }
    public int Port { get; set; }

    public bool Connected
    {
        get => tcpClient.Connected;
    }

    public ModbusTCP(string ip, int port)
    {
        IPAdress = ip;
        Port = port;

        modbusFactory = new ModbusFactory();
        tcpClient = new TcpClient(IPAdress, Port);
        master = modbusFactory.CreateMaster(tcpClient);
        master.Transport.ReadTimeout = 2000;
        master.Transport.Retries = 10;
    }


    public bool[] ReadCoils(byte slaveAddress, ushort startAddress, ushort num)
    {
        return master.ReadCoils(slaveAddress, startAddress, num);
    }

    public bool[] ReadInputs(byte slaveAddress, ushort startAddress, ushort num)
    {
        return master.ReadInputs(slaveAddress, startAddress, num);
    }

    public ushort[] ReadHoldingRegisters(byte slaveAddress, ushort startAddress, ushort num)
    {
        return master.ReadHoldingRegisters(slaveAddress, startAddress, num);
    }

    public ushort[] ReadInputRegisters(byte slaveAddress, ushort startAddress, ushort num)
    {
        return master.ReadInputRegisters(slaveAddress, startAddress, num);
    }

    public void WriteSingleCoil(byte slaveAddress, ushort startAddress, bool value)
    {
        master.WriteSingleCoil(slaveAddress, startAddress, value);
    }

    public void WriteSingleRegister(byte slaveAddress, ushort startAddress, ushort value)
    {
        master.WriteSingleRegister(slaveAddress, startAddress, value);
    }

    public void WriteMultipleCoils(byte slaveAddress, ushort startAddress, bool[] value)
    {
        master.WriteMultipleCoils(slaveAddress, startAddress, value);
    }

    public void WriteMultipleRegisters(byte slaveAddress, ushort startAddress, ushort[] value)
    {
        master.WriteMultipleRegisters(slaveAddress, startAddress, value);
    }

}

连接测试
下载 Modbus Slave
链接：https://pan.baidu.com/s/1ydX_9KElkOTA7h-E3SIadw
提取码：7fh5
设置
在这里插入图片描述
在这里插入图片描述

连接
private ModbusTCP modbus;
private void ConnectExecute()
{
try
{
modbus = new ModbusTCP(IP, Port);
pollingTimer.Start();
}
catch (Exception ex)
{
Msg.Info(ex.Message);
}
}

在这里插入图片描述

写入测试
NModbus提供的对寄存器读写方法，只包括ushort类型，需要对ushort进行进行转换。
封装转换类型

    public class MODBUS
    {
        /// <summary>
        /// 赋值string
        /// </summary>
        /// <param name="src"></param>
        /// <param name="start"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static void SetString(ushort[] src, int start, string value)
        {
            byte[] bytesTemp = Encoding.UTF8.GetBytes(value);
            ushort[] dest = Bytes2Ushorts(bytesTemp);
            dest.CopyTo(src, start);
        }

        /// <summary>
        /// 获取string
        /// </summary>
        /// <param name="src"></param>
        /// <param name="start"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public static string GetString(ushort[] src, int start, int len)
        {
            ushort[] temp = new ushort[len];
            for (int i = 0; i < len; i++)
            {
                temp[i] = src[i + start];
            }
            byte[] bytesTemp = Ushorts2Bytes(temp);
            string res = Encoding.UTF8.GetString(bytesTemp).Trim(new char[] { '\0' });
            return res;
        }

        /// <summary>
        /// 赋值Real类型数据
        /// </summary>
        /// <param name="src"></param>
        /// <param name="start"></param>
        /// <param name="value"></param>
        public static void SetReal(ushort[] src, int start, float value)
        {
            byte[] bytes = BitConverter.GetBytes(value);

            ushort[] dest = Bytes2Ushorts(bytes);

            dest.CopyTo(src, start);
        }

        /// <summary>
        /// 获取float类型数据
        /// </summary>
        /// <param name="src"></param>
        /// <param name="start"></param>
        /// <returns></returns>
        public static float GetReal(ushort[] src, int start)
        {
            ushort[] temp = new ushort[2];
            for (int i = 0; i < 2; i++)
            {
                temp[i] = src[i + start];
            }
            byte[] bytesTemp = Ushorts2Bytes(temp);
            float res = BitConverter.ToSingle(bytesTemp, 0);
            return res;
        }

        /// <summary>
        /// 赋值Short类型数据
        /// </summary>
        /// <param name="src"></param>
        /// <param name="start"></param>
        /// <param name="value"></param>
        public static void SetShort(ushort[] src, int start, short value)
        {
            byte[] bytes = BitConverter.GetBytes(value);

            ushort[] dest = Bytes2Ushorts(bytes);

            dest.CopyTo(src, start);
        }

        /// <summary>
        /// 获取short类型数据
        /// </summary>
        /// <param name="src"></param>
        /// <param name="start"></param>
        /// <returns></returns>
        public static short GetShort(ushort[] src, int start)
        {
            ushort[] temp = new ushort[1];
            temp[0] = src[start];
            byte[] bytesTemp = Ushorts2Bytes(temp);
            short res = BitConverter.ToInt16(bytesTemp, 0);
            return res;
        }


        public static bool[] GetBools(ushort[] src, int start, int num)
        {
            ushort[] temp = new ushort[num];
            for (int i = start; i < start + num; i++)
            {
                temp[i] = src[i + start];
            }
            byte[] bytes = Ushorts2Bytes(temp);

            bool[] res = Bytes2Bools(bytes);

            return res;
        }

        private static bool[] Bytes2Bools(byte[] b)
        {
            bool[] array = new bool[8*b.Length];

            for (int i = 0; i < b.Length; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    array[i * 8 + j] = (b[i] & 1) == 1;//判定byte的最后一位是否为1，若为1，则是true；否则是false
                    b[i] = (byte)(b[i] >> 1);//将byte右移一位
                }
            }
            return array;
        }

        private static byte Bools2Byte(bool[] array)
        {
            if (array != null && array.Length > 0)
            {
                byte b = 0;
                for (int i = 0; i < 8; i++)
                {
                    if (array[i])
                    {
                        byte nn = (byte)(1 << i);//左移一位，相当于×2
                        b += nn;
                    }
                }
                return b;
            }
            return 0;
        }

        private static ushort[] Bytes2Ushorts(byte[] src, bool reverse = false)
        {
            int len = src.Length;

            byte[] srcPlus = new byte[len + 1];
            src.CopyTo(srcPlus, 0);
            int count = len >> 1;

            if (len % 2 != 0)
            {
                count += 1;
            }

            ushort[] dest = new ushort[count];
            if(reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] << 8 | srcPlus[2 * i + 1] & 0xff);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i] = (ushort)(srcPlus[i * 2] & 0xff | srcPlus[2 * i + 1] << 8 );
                }
            }
         
            return dest;
        }

        private static byte[] Ushorts2Bytes(ushort[] src, bool reverse = false)
        {

            int count = src.Length;
            byte[] dest = new byte[count << 1];
            if(reverse)
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 8);
                    dest[i * 2 + 1] = (byte)(src[i] >> 0);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    dest[i * 2] = (byte)(src[i] >> 0);
                    dest[i * 2 + 1] = (byte)(src[i] >> 8);
                }
            }
            return dest;
        }
    }

vb.net教程
c#教程
根据选择的类型写入

在这里插入图片描述
在这里插入图片描述

        private void WriteExecute()
        {
            try
            {
                if(VariableType == "real")
                {
                    ushort[] buff = new ushort[2];
                    float value = float.Parse(WriteValue);
                    MODBUS.SetReal(buff, 0, value);
                    modbus.WriteMultipleRegisters(SlaveID, WriteAddress, buff);
                }
                else if(VariableType == "string")
                {
                    ushort[] buff = new ushort[10];
                    MODBUS.SetString(buff, 0, WriteValue);
                    modbus.WriteMultipleRegisters(SlaveID, WriteAddress, buff);
                }
                else if(VariableType == "Int16")
                {
                    ushort[] buff = new ushort[1];
                    short value = short.Parse(WriteValue);
                    MODBUS.SetShort(buff, 0, value);
                    modbus.WriteMultipleRegisters(SlaveID, WriteAddress, buff);
                }
            }
            catch (Exception ex)
            {
                Msg.Info(ex.Message);
            }
        }

在这里插入图片描述

可以看到ModbusSlave上面的数据，一个浮点型数据占用两个寄存器，4个byte。按照下图设置后，可以看到，已经写入成功。

在这里插入图片描述

读取测试

private void ReadExecute()
{
    try
    {
        if (VariableType == "real")
        {
            ushort[] buff = modbus.ReadHoldingRegisters(SlaveID, ReadAddress, 2);
            float value = MODBUS.GetReal(buff, 0);
            ReadValue = value.ToString();
        }
        else if(VariableType == "string")
        {
            ushort[] buff = modbus.ReadHoldingRegisters(SlaveID, ReadAddress, 10);
            ReadValue = MODBUS.GetString(buff, 0, 10); 
        }
        else if(VariableType == "Int16")
        {
            ushort[] buff = modbus.ReadHoldingRegisters(SlaveID, ReadAddress, 1);
            short value = MODBUS.GetShort(buff, 0);
            ReadValue = value.ToString();
        }
    }
    catch (Exception ex)
    {
        Msg.Info(ex.Message);
    }
}

字符串写入和读取
参照VariableType=="string"部分代码。
在这里插入图片描述

转载请注明出处
https://www.cnblogs.com/Samberger/p/13039429.html

chinaherolts2008
关注
专栏目录
C#ModBus Tcp读写数据
Yueqin0512的博客
12-19 1万+
引用-添加引用-HslCommunication.dll ModBus组件所有的功能类都在 HslCommunication.ModBus命名空间，所以再使用之前先添加 using HslCommunication.ModBus; using HslCommunication; 在使用读写功能之前必须先进行实例化： private ModbusTcpNet busTcpClient = new ModbusTcpNet("192.168.3.45", 502, 0x01); // 站..
使用C#和NModbus库轻松实现Modbus通信
东城十三
06-05 2623
在C#中实现Modbus协议可以使用诸如NModbus这样的开源库。NModbus库提供了实现Modbus协议的所有必要功能，包括主站和从站的实现。
C# modbus浮点数处理
05-05
文档里x1 x2 为读取到浮点数的2个16位寄存器整型数据，返回值就是所需要的浮点数
Modbus TCP 、 Nmodbus开源库 Nmodbus上位机(C#)Demo
04-23
Nmodbus的开源库，4种方式读取Modbus Tcp 数据。
C#中的通信-NModbus4
最新发布
愿你历尽千帆，归来仍是少年。
08-08 485
NModbus4是一个用于Modbus通信的开源库，它提供了一套简单易用的API来实现Modbus协议的通信。Modbus是一种应用层协议，主要用于工业自动化领域的电子设备之间的通信。它支持多种通信方式，包括RTU（二进制模式）、ASCII和TCP/IP。​// 创建一个Modbus Master，假设使用TCP/IP通信​// 连接到Modbus Slave，Slave的地址是1​// 读取保持寄存器的值，从地址0开始，读取10个寄存器​// 断开连接。
C# Modbus协议中读取浮点数的操作方法
12-10 3610
输入参数P1,P2代表PLC中浮点数储存的两个寄存器获取的数据 public static float GetFloat(ushort P1, ushort P2) { int intSign, intSignRest, intExponent, intExponentRest; float faResult, faDigit; intSign = P1 / 32768; intSignRes
C# nmodbus
12-23
C#写的modbus实现,很全面,很好用.内有DEMO,vs2005写的
NModbus-一个C#的Modbus协议库实现
ccf19881030的专栏
12-30 1716
最近在学习C#的时候，特意看了一下C#下有什么Modbus协议库，在Github上面找了一下，有一个的源代码，亲测可以在VS2022中完美运行。实际测试过程中可以用Modbus Slave或Modbus Poll等工具进行配合测试。在C#中NuGet特此记录一下。
C# Modbus协议通讯，NModbus轻松实现
qq_42707143的博客
01-31 2367
先安装NModbus库，在nuget中搜索：直接上代码！！！
C# 2015最新版NMODBUS4.0源码,支持TCP/IP,RTU,ASCII
09-17
NModbus_net-4.0_1.11.0.0-source是最新版的源码，主要应用于工业控制行业。修改一下可以直接用于工程~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
基于C#开发ModbusTCP服务器实现数据接口
xiketangAndy的博客
10-20 3132
-Begin- 前言 有一个项目使用的是西门子的PLC，你开发了一个上位机，现在有一个第三方软件也想要获取西门子PLC的数据，希望你能提供一个接口，该如何实现。 我相信你们应该会遇到这种问题，其实解决方案很多，今天跟大家分享一种方式——提供ModbusTCP接口，提供ModbusTCP接口其实就是开发ModbusTCP服务器。 首先我们要清楚ModbusTCP服务器的本质就是Socket服务器，只是创建了4个集合或数组作为4个存储区，当接收到ModbusTCP客户端的报文请求时，将对应的存储区数
C#通过NModBus读取modbus设备上的温湿度
08-02
使用NModBus组件读取modbus设备上的参数，温度和湿度，仅供新手使用，建议使用最新版vs打开运行。
C# NModbus协议类
07-27
C# 编写的碁于 NModbus协议的通用类，可在不同项目中使用
基于C#的modbus Tcp协议的数据抓取和解析
weixin_44310020的博客
11-16 3874
基于Modbus tcp 协议的数据抓取，并解析，源码使用C#开发 using System; using System.Collections.Generic; using System.Linq; using System.Net; using System.Net.Sockets; using System.Text; namespace modbus { class Program { #region 字节转换为16进制字符 /// &lt.
c# NModBus 使用
热门推荐
sunstar8921的博客
01-18 1万+
最近在做一个项目，串口通讯，接口是RS232，通讯协议是ModBus，一开始真的是一头雾水，如果不管协议，直接用C#自带的SerialPort类，直接发送指令，获取返回信息，解析相对应的结果，得出需要使用的字段，这样可以不管是什么协议，只要知道指令解析方式即可。 如果指令较多，还非得按照ModBus协议解析，可以用NModBus4，百度有很多解释，包括需要理解下ModBus的相关协议，及其定义的...
在C#中使用NModbus4通信库执行读操作
qq_35320456的博客
03-11 3017
在C#中使用NModbus4通信库执行【读】操作
C++ Modbus tcp 如何读取寄存器的字符串
u013083044的博客
05-21 2226
函数，我们可以指定起始地址和要读取的寄存器数量。然后，我们将读取到的 16 位数字数组按顺序转换为字符串类型的数据，这里使用的是。希望这可以帮助你读取多个寄存器地址的数据，并将其转换为字符串类型的数据。函数从多个寄存器地址读取数据，并将其转换为字符串类型的数据。函数连接到 Modbus TCP 服务器。最后，我们输出转换后的字符串数据。在 Modbus TCP 中，可以使用。函数从多个连续的寄存器地址中读取数据。函数关闭 Modbus TCP 连接。
C#使用NModbus4库创建Modbus TCP Slave(服务器)简单示例
原来你也__的博客
03-01 7446
上篇描述在Codesys端的Modbus TCP Master(客户端)的设备添加、IO映射、通讯简单展示等方面，本文记录PC端C#利用NModbus4通讯库创建Modbus TCP Slave(服务器)的方法。本文分以下几个步骤分享NModbus4的使用：1.添加NModbus4库2.ModbusTcpSlave从站的创建3.事件订阅4.通讯示例界面附加显示功能：1.在收到客户端报文的事件后，将会在信息提示框中显示报文内容，报文内容不包含CRC；
C#、.Net使用NModbus4进行ModbusTCP连接
u014241344的博客
02-16 2448
C#、.Net使用NModbus4进行ModbusTCP连接
基于c#开发一个modbus tcp实时通讯读写
06-08
以下是一个基于C#的Modbus TCP实时通讯读写示例代码，你可以参考一下： ```csharp using System; using System.Threading; using System.Net.Sockets; using Modbus.Data; using Modbus.Device; using Modbus.Utility; class Program { static void Main(string[] args) { // 创建Modbus TCP客户端 TcpClient client = new TcpClient("localhost", 502); ModbusIpMaster master = ModbusIpMaster.CreateIp(client); // 定义读写操作的数据 ushort address = 1; ushort count = 1; ushort[] readData = new ushort[count]; ushort[] writeData = new ushort[] { 12345 }; // 循环执行实时通讯读写 while (true) { // 读取保持寄存器（地址为0x0001）中的值 readData = master.ReadHoldingRegisters(address, count); ushort value = readData[0]; Console.WriteLine("保持寄存器中的值为：" + value); // 写入保持寄存器（地址为0x0001）中的新值 master.WriteMultipleRegisters(address, writeData); Console.WriteLine("新值已写入保持寄存器中"); // 等待1秒钟 Thread.Sleep(1000); } // 关闭客户端 client.Close(); } } ``` 在代码中，我们首先创建了一个 Modbus TCP 客户端，并定义了读写操作的数据。然后，使用一个无限循环不断执行实时通讯读写操作，并使用 `Thread.Sleep` 方法暂停1秒钟。在实际应用中，可以根据需要设置读写的地址、数量和数据，并进行相应的操作。当然，在使用时也需要根据实际情况设置 Modbus TCP 服务器的 IP 地址和端口号。 需要注意的是，Modbus TCP 协议是一种基于连接的协议，因此需要在每次使用完成后关闭客户端。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值