c#读取modbus数据

C#读取Modbus数据

万次阅读 多人点赞 2014-10-27 11:08:31

C#如何读取Modbus数据，Modbus很多人可能一点都不知道，也正常，隔行如隔山嘛。Modbus在自动化行业就不一样，属于路人皆知的东西，很多设备、程序都与Modbus息息相关。 Modbus这个东西，本人也是个二把刀，只有半...

        前面连续写了关于SOCKET编程的东西，似乎有点高大上，为了学习而学习。因此这里我们来整点实际应用的东西。C#如何读取Modbus数据，Modbus很多人可能一点都不知道，也正常，隔行如隔山嘛。Modbus在自动化行业就不一样，属于路人皆知的东西，很多设备、程序都与Modbus息息相关。

        Modbus这个东西，本人也是个二把刀，只有半瓶水，所以在这里晃荡，写点Modbus东西，也是让自己能理解得更深一点，入门级别的东西，希望能帮助到那些像我一样不太了解Modbus，但是又想了解Modbus的同学。

        至于高手，可以吐槽，当然最好是直接绕过。

        闲话少说，书归正传。何谓Modbus

        Modbus通讯协议，ModBus网络是一个工业通信系统，由带智能终端的可编程序控制器和计算机通过公用线路或局部专用线路连接而成。其系统结构既包括硬件、亦包括软件。它可应用于各种数据采集和过程监控。

      Modbus通讯协议是施耐德电气公司......

        Modbus 协议是应用于电子控制器上的一种通用语言。通过此协议，控制器相互之间、控制器经由网络（例如以太网）和其它设备之间可以通信。它已经成为一通用工业标准。有了它，不同厂商生产的控制设备可以连成工业网络，进行集中监控......

      这些都是百度来的，呵呵，别吐槽。网上资料很多，有兴趣的可以自己撸，看多了感觉好像都差不多。

      个人认为所谓的通讯协议，机器、设备或者程序之间相互通讯的一种方式。人与人交流不也有不同的语言或者文字嘛，机器之间当然可以相互发送信息，只要定好规则即可。而Modbus就是与自动化设备用来交流的语言。

      这些理解了也好，不明白其实也不要紧。因为Modbus对于我们码农来说，我们可以大大的缩小理解范围，我们只需要关心与编码有关系东西，对于硬件的那些什么针脚、电缆、信号位都不用太关心，当然如果想成为为一个Modbus方面的专家，那就不同了。

     Modbus分两种模式，一种串口模式，一种是TCP/IP模式。串口模式感觉越来越少，现在大多都是TCP/IP模式，所以这里就暂时写TCP/IP模式

     首先要做就是SOCKET客户端与设备建立连接，因为前面的文章中，关于SOCKET，我们已经说过了，那么下面的代码就非常easy了。说简单点，先不要去想什么Modbus，就认为有一台服务器，开了SOCKET服务在哪里。所以如下代码就水到渠成了。

   

private TcpClient tcpClient; 
public bool Open(string ip,int port) {
            try {
                tcpClient = new TcpClient();

                tcpClient.Connect(IPAddress.Parse(ip), port);

                return true;
            }catch(SocketException e){
                 //LogHelper.WriteLog(e.Message);
                return false;
            }
        }

         LogHelper代码这里就不写，与主题无关，个人感觉这样的代码也没必要去运行一下，看看能明白就行了。去运行这个事情，有时会耽误太多的时间。这里IP和端口号都是由设备方提供的。真实程序一般都把这两个参数写配置文件中。

       设备连上以后，下一步当然就是读取数据。Modbus的基本原理就是程序向设备请求，需要读取哪个数据，设备就会返回相应的数据。我们知道机器或者说是电脑是只认识01001这样的字符串的。所以所谓的Modbus协议，说得简单一点，就是规定这样一个0101字符各代表什么含义。

    

/// <summary>
        /// 读取数据 Modbus
        /// </summary>
        /// <param name="rData">结果</param>
        /// <param name="id">设备号</param>
        /// <param name="address">设备地址</param>
        /// <param name="len">长度-多少个设备</param>
        /// <returns>数据读取结果 是否成功</returns>
        public bool ReceiveData(ref short[] rData, short id, short address, short len)
        {
            try
            {
                short m = Convert.ToInt16(new Random().Next(2, 20));
                rData = null;

                byte[] bs = Receive(m, id, address, len);
                byte[] b = TrimModbus(bs, m, id, len);

                if (b==null) { return false; }

                List<short> data = new List<short>(255);
                for (int i = 0; i < b.Length-1; i++)
                {
                   if (!Convert.ToBoolean(i & 1))
                   {
                        byte[] temp = new byte[] { b[i+1], b[i] };
                        data.Add(BitConverter.ToInt16(temp, 0));
                   }
                }
                rData = data.ToArray();

                return true;
            }
            catch (Exception e) {
                LogHelper.WriteLog("返回Modbus数据错误"+ e.Message);
                return false;
            }
        }

这个其实更多的是处理数据异常，LogHelper与前面一样，核心好像还不在了，就是那个Receive方法。

        /// <summary>
        /// 读取 Modbus
        ///00 00 00 00 00 0d  01  03  0A 14 00  14 00  14 00  14 00  14 00
        /// </summary>
        /// <param name="m">标示</param>
        /// <param name="id">设备码</param>
        /// <param name="address">开始地址</param>
        /// <param name="len">设备数量</param>
        /// <returns></returns>
        private byte[] Receive(short m, short id, short address, short len)
        {
            try
            {
                if (tcpClient == null || !tcpClient.Connected) { return null; }

                byte[] data = GetSrcData(m, id, address, len);
                
                //00 00 00 00 00 06 01 03 00 00 00 05
                tcpClient.Client.Send(data, data.Length, SocketFlags.None);

                int size = len * 2 + 9;

                byte[] rData = new byte[size];

                tcpClient.Client.Receive(rData, size, SocketFlags.None);

                //string t1 = TranBytes(rData);

                return rData;

            }catch(SocketException e){
                if (e.ErrorCode != 10004)
                {
                    LogHelper.WriteLog(e.Message);
                }

                if (tcpClient != null) {
                    tcpClient.Close();
                    tcpClient = null;
                }

                return null;
            }
        }
        #endregion

上面的代码可以说是Modbus协议核心，其实就是SOCKET发送数据和接受数据，发送是告诉主机需要取那些的数据。接受就是把主机返回来的数据接受过来。

//发送
        //00 00 00 00 00 06 01 03 00 00 00 05
        /// <summary>
        /// 发送字节数
        /// </summary>
        /// <param name="m"></param>
        /// <param name="len"></param>
        /// <param name="id"></param>
        /// <param name="address"></param>
        /// <returns></returns>
        private byte[] GetSrcData(short m, short id, short add, short len)
        {
            List<byte> data = new List<byte>(255);

            data.AddRange(ValueHelper.Instance.GetBytes(m));                     //             00 01
            data.AddRange(new byte[] { 0x00, 0x00 });                            //             00 00
            data.AddRange(ValueHelper.Instance.GetBytes(Convert.ToInt16(6)));    //字节数       00 06
            data.Add(Convert.ToByte(id));                                        //路由码       01
            data.Add(Convert.ToByte(3));                                         //功能码 3-读  03
            data.AddRange(ValueHelper.Instance.GetBytes(add));                   //开始地址     00 00
            data.AddRange(ValueHelper.Instance.GetBytes(len));                   //设备数量     00 05
            return data.ToArray();
        }

 好，到这里基本上搞定了。其实很多逻辑都在代码中，说简单的就是某个ID设备，从哪个地址开始，读几个设备的值，这里需要注意是short 不要用32位的int去替换，结果会不一样的。仔细看看估计大家都能明白，也没有什么神秘的东西。

哦，对了还ValueHelper代码

using System;
using System.Collections.Generic;
using System.Text;

namespace Modbus {
    public class ValueHelper
    {
        #region 大小端判断

        public static bool LittleEndian = false;

        static ValueHelper()
        {
            unsafe
            {
                int tester = 1;
                LittleEndian = (*(byte*)(&tester)) == (byte)1;
            }
        }
        #endregion

        #region Factory
        public static ValueHelper _Instance = null;
        internal static ValueHelper Instance
        {
            get
            {
                if (_Instance == null)
                {
                    _Instance = LittleEndian ? new LittleEndianValueHelper() : new ValueHelper();
                    //_Instance = new ValueHelper();
                }
                return _Instance;
            }
        }
        #endregion

        protected ValueHelper()
        {

        }

        public virtual Byte[] GetBytes(short value)
        {
            return BitConverter.GetBytes(value);
        }

        public virtual Byte[] GetBytes(int value)
        {
            return BitConverter.GetBytes(value);
        }

        public virtual Byte[] GetBytes(float value)
        {
            return BitConverter.GetBytes(value);
        }

        public virtual Byte[] GetBytes(double value)
        {
            return BitConverter.GetBytes(value);
        }

        public virtual short GetShort(byte[] data)
        {
            return BitConverter.ToInt16(data, 0);
        }

        public virtual int GetInt(byte[] data)
        {
            return BitConverter.ToInt32(data, 0);
        }

        public virtual float GetFloat(byte[] data)
        {
            return BitConverter.ToSingle(data, 0);
        }

        public virtual double GetDouble(byte[] data)
        {
            return BitConverter.ToDouble(data, 0);
        }
    }

    internal class LittleEndianValueHelper : ValueHelper
    {
        public override Byte[] GetBytes(short value)
        {
            return this.Reverse(BitConverter.GetBytes(value));
        }

        public override Byte[] GetBytes(int value)
        {
            return this.Reverse(BitConverter.GetBytes(value));
        }

        public override Byte[] GetBytes(float value)
        {
            return this.Reverse(BitConverter.GetBytes(value));
        }

        public override Byte[] GetBytes(double value)
        {
            return this.Reverse(BitConverter.GetBytes(value));
        }

        public virtual short GetShort(byte[] data)
        {
            return BitConverter.ToInt16(this.Reverse(data), 0);
        }

        public virtual int GetInt(byte[] data)
        {
            return BitConverter.ToInt32(this.Reverse(data), 0);
        }

        public virtual float GetFloat(byte[] data)
        {
            return BitConverter.ToSingle(this.Reverse(data), 0);
        }

        public virtual double GetDouble(byte[] data)
        {
            return BitConverter.ToDouble(this.Reverse(data), 0);
        }

        private Byte[] Reverse(Byte[] data)
        {
            Array.Reverse(data);
            return data;
        }
    }
}


不好意思，有个方法给忘记了

 private byte[] TrimModbus(byte[] d, short m, short id, short len)
        {
            int size = Convert.ToInt32(len) * 2;
            int dLen = size + 9;

            if (d == null || d.Length != dLen || m != Convert.ToInt16(d[1]) || id != Convert.ToInt16(d[6]))
            {
                return null;
            }
            byte[] n = new byte[size];
            Array.Copy(d, 9, n, 0, size);
            return n;
        }

所有代码都贴出来了，但是如果实在想运行的，也是需要简单整理的。实在想要代码的，请发邮件 blank250@163.com

收起

展开全文

c#读取modbus数据
2020-08-13 17:34:32
https://www.cnblogs.com/MuZiJin/p/11753826.html
```
https://www.cnblogs.com/MuZiJin/p/11753826.html
```
收起
展开全文

【转】c#读取Modbus数据

2020-03-01 16:40:56

前面连续写了关于SOCKET编程的东西，似乎有点高大上，为了学习而学习。因此这里我们来整点实际应用的东西。C#如何读取Modbus数据，Modbus很多人可能一点都不知道，也正常，隔行如隔山嘛。Modbus在自动化行业就不一样，属于路人皆知的东西，很多设备、程序都与Modbus息息相关。

        Modbus这个东西，本人也是个二把刀，只有半瓶水，所以在这里晃荡，写点Modbus东西，也是让自己能理解得更深一点，入门级别的东西，希望能帮助到那些像我一样不太了解Modbus，但是又想了解Modbus的同学。

        至于高手，可以吐槽，当然最好是直接绕过。

        闲话少说，书归正传。何谓Modbus

        Modbus通讯协议，ModBus网络是一个工业通信系统，由带智能终端的可编程序控制器和计算机通过公用线路或局部专用线路连接而成。其系统结构既包括硬件、亦包括软件。它可应用于各种数据采集和过程监控。

      Modbus通讯协议是施耐德电气公司......

        Modbus 协议是应用于电子控制器上的一种通用语言。通过此协议，控制器相互之间、控制器经由网络（例如以太网）和其它设备之间可以通信。它已经成为一通用工业标准。有了它，不同厂商生产的控制设备可以连成工业网络，进行集中监控......

      这些都是百度来的，呵呵，别吐槽。网上资料很多，有兴趣的可以自己撸，看多了感觉好像都差不多。

      个人认为所谓的通讯协议，机器、设备或者程序之间相互通讯的一种方式。人与人交流不也有不同的语言或者文字嘛，机器之间当然可以相互发送信息，只要定好规则即可。而Modbus就是与自动化设备用来交流的语言。

      这些理解了也好，不明白其实也不要紧。因为Modbus对于我们码农来说，我们可以大大的缩小理解范围，我们只需要关心与编码有关系东西，对于硬件的那些什么针脚、电缆、信号位都不用太关心，当然如果想成为为一个Modbus方面的专家，那就不同了。

     Modbus分两种模式，一种串口模式，一种是TCP/IP模式。串口模式感觉越来越少，现在大多都是TCP/IP模式，所以这里就暂时写TCP/IP模式

     首先要做就是SOCKET客户端与设备建立连接，因为前面的文章中，关于SOCKET，我们已经说过了，那么下面的代码就非常easy了。说简单点，先不要去想什么Modbus，就认为有一台服务器，开了SOCKET服务在哪里。所以如下代码就水到渠成了。
    public bool Open(string ip,int port) {
                try {
                    tcpClient = new TcpClient();
     
                    tcpClient.Connect(IPAddress.Parse(ip), port);
     
                    return true;
                }catch(SocketException e){
                    string m = string.Format("modbus Client服务器连接错误:{0},ip:{1},port:{2}", e.Message, ip, port);
                    LogHelper.WriteLog(m);
                    return false;
                }
            }

         其中LogHelper代码这里就不写，因为与主题无关，如果想运行上面代码的话，注释就行了，我个人推荐这样的代码也没必要去运行一下，看看能明白就行了。去运行这个事情，有事会耽误太多的时间。这里IP和端口号都是由设备方提供的。真实程序一般都把这两个参数写配置文件中。

       设备连上以后，下一步当然就是读取数据。Modbus的基本原理就是程序向设备请求，需要读取哪个数据，设备就会返回相应的数据。我们知道机器或者说是电脑是只认识01001这样的字符串的。所以所谓的Modbus协议，说得简单一点，就是规定这样一个0101字符各代表什么含义。

    

    /// <summary>
            /// 读取数据 Modbus
            /// </summary>
            /// <param name="rData">结果</param>
            /// <param name="id">设备号</param>
            /// <param name="address">设备地址</param>
            /// <param name="len">长度-多少个设备</param>
            /// <returns>数据读取结果 是否成功</returns>
            public bool ReceiveData(ref short[] rData, short id, short address, short len)
            {
                try
                {
                    short m = Convert.ToInt16(new Random().Next(2, 20));
                    rData = null;
     
                    byte[] bs = Receive(m, id, address, len);
                    byte[] b = TrimModbus(bs, m, id, len);
     
                    if (b==null) { return false; }
     
                    List<short> data = new List<short>(255);
                    for (int i = 0; i < b.Length-1; i++)
                    {
                       if (!Convert.ToBoolean(i & 1))
                       {
                            byte[] temp = new byte[] { b[i+1], b[i] };
                            data.Add(BitConverter.ToInt16(temp, 0));
                       }
                    }
                    rData = data.ToArray();
     
                    return true;
                }
                catch (Exception e) {
                    LogHelper.WriteLog("返回Modbus数据错误"+ e.Message);
                    return false;
                }
            }

这个其实更多的是处理数据异常，LogHelper与前面一样，核心好像还不在了，就是那个Receive方法。

            /// <summary>
            /// 读取 Modbus
            ///00 00 00 00 00 0d  01  03  0A 14 00  14 00  14 00  14 00  14 00
            /// </summary>
            /// <param name="m">标示</param>
            /// <param name="id">设备码</param>
            /// <param name="address">开始地址</param>
            /// <param name="len">设备数量</param>
            /// <returns></returns>
            private byte[] Receive(short m, short id, short address, short len)
            {
                try
                {
                    if (tcpClient == null || !tcpClient.Connected) { return null; }
     
                    byte[] data = GetSrcData(m, id, address, len);
                    
                    //00 00 00 00 00 06 01 03 00 00 00 05
                    tcpClient.Client.Send(data, data.Length, SocketFlags.None);
     
                    int size = len * 2 + 9;
     
                    byte[] rData = new byte[size];
     
                    tcpClient.Client.Receive(rData, size, SocketFlags.None);
     
                    //string t1 = TranBytes(rData);
     
                    return rData;
     
                }catch(SocketException e){
                    if (e.ErrorCode != 10004)
                    {
                        LogHelper.WriteLog(e.Message);
                    }
     
                    if (tcpClient != null) {
                        tcpClient.Close();
                        tcpClient = null;
                    }
     
                    return null;
                }
            }
            #endregion

上面的代码可以说是Modbus协议核心，其实就是SOCKET发送数据和接受数据，发送是告诉主机需要取那些的数据。接受就是把主机返回来的数据接受过来。

    //发送
            //00 00 00 00 00 06 01 03 00 00 00 05
            /// <summary>
            /// 发送字节数
            /// </summary>
            /// <param name="m"></param>
            /// <param name="len"></param>
            /// <param name="id"></param>
            /// <param name="address"></param>
            /// <returns></returns>
            private byte[] GetSrcData(short m, short id, short add, short len)
            {
                List<byte> data = new List<byte>(255);
     
                data.AddRange(ValueHelper.Instance.GetBytes(m));                     //             00 01
                data.AddRange(new byte[] { 0x00, 0x00 });                            //             00 00
                data.AddRange(ValueHelper.Instance.GetBytes(Convert.ToInt16(6)));    //字节数       00 06
                data.Add(Convert.ToByte(id));                                        //路由码       01
                data.Add(Convert.ToByte(3));                                         //功能码 3-读  03
                data.AddRange(ValueHelper.Instance.GetBytes(add));                   //开始地址     00 00
                data.AddRange(ValueHelper.Instance.GetBytes(len));                   //设备数量     00 05
                return data.ToArray();
            }

 好，到这里基本上搞定了。其实很多逻辑都在代码中，说简单的就是某个ID设备，从哪个地址开始，读几个设备的值，这里需要注意是short 不要用32位的int去替换，结果会不一样的。仔细看看估计大家都能明白，也没有什么神秘的东西。

哦，对了还ValueHelper代码

    using System;
    using System.Collections.Generic;
    using System.Text;
     
    namespace Modbus {
        public class ValueHelper
        {
            #region 大小端判断
     
            public static bool LittleEndian = false;
     
            static ValueHelper()
            {
                unsafe
                {
                    int tester = 1;
                    LittleEndian = (*(byte*)(&tester)) == (byte)1;
                }
            }
            #endregion
     
            #region Factory
            public static ValueHelper _Instance = null;
            internal static ValueHelper Instance
            {
                get
                {
                    if (_Instance == null)
                    {
                        _Instance = LittleEndian ? new LittleEndianValueHelper() : new ValueHelper();
                        //_Instance = new ValueHelper();
                    }
                    return _Instance;
                }
            }
            #endregion
     
            protected ValueHelper()
            {
     
            }
     
            public virtual Byte[] GetBytes(short value)
            {
                return BitConverter.GetBytes(value);
            }
     
            public virtual Byte[] GetBytes(int value)
            {
                return BitConverter.GetBytes(value);
            }
     
            public virtual Byte[] GetBytes(float value)
            {
                return BitConverter.GetBytes(value);
            }
     
            public virtual Byte[] GetBytes(double value)
            {
                return BitConverter.GetBytes(value);
            }
     
            public virtual short GetShort(byte[] data)
            {
                return BitConverter.ToInt16(data, 0);
            }
     
            public virtual int GetInt(byte[] data)
            {
                return BitConverter.ToInt32(data, 0);
            }
     
            public virtual float GetFloat(byte[] data)
            {
                return BitConverter.ToSingle(data, 0);
            }
     
            public virtual double GetDouble(byte[] data)
            {
                return BitConverter.ToDouble(data, 0);
            }
        }
     
        internal class LittleEndianValueHelper : ValueHelper
        {
            public override Byte[] GetBytes(short value)
            {
                return this.Reverse(BitConverter.GetBytes(value));
            }
     
            public override Byte[] GetBytes(int value)
            {
                return this.Reverse(BitConverter.GetBytes(value));
            }
     
            public override Byte[] GetBytes(float value)
            {
                return this.Reverse(BitConverter.GetBytes(value));
            }
     
            public override Byte[] GetBytes(double value)
            {
                return this.Reverse(BitConverter.GetBytes(value));
            }
     
            public virtual short GetShort(byte[] data)
            {
                return BitConverter.ToInt16(this.Reverse(data), 0);
            }
     
            public virtual int GetInt(byte[] data)
            {
                return BitConverter.ToInt32(this.Reverse(data), 0);
            }
     
            public virtual float GetFloat(byte[] data)
            {
                return BitConverter.ToSingle(this.Reverse(data), 0);
            }
     
            public virtual double GetDouble(byte[] data)
            {
                return BitConverter.ToDouble(this.Reverse(data), 0);
            }
     
            private Byte[] Reverse(Byte[] data)
            {
                Array.Reverse(data);
                return data;
            }
        }
    }

不好意思，有个方法给忘记了
     private byte[] TrimModbus(byte[] d, short m, short id, short len)
            {
                int size = Convert.ToInt32(len) * 2;
                int dLen = size + 9;
     
                if (d == null || d.Length != dLen || m != Convert.ToInt16(d[1]) || id != Convert.ToInt16(d[6]))
                {
                    return null;
                }
                byte[] n = new byte[size];
                Array.Copy(d, 9, n, 0, size);
                return n;
            }

所有代码都贴出来了，但是如果实在想运行的，也是需要简单整理的。

收起

展开全文

C#编程之C# Modbus 数据读取使用NModBus4库

千次阅读 2019-06-04 17:10:27

C#编程之C# Modbus 数据读取 使用NModBus4库 http://m.zhizuobiao.com/net/net-18091700173/ 2018-09-17 来自 03142 摘要：本文主要向大家介绍了C#编程之C# Modbus 数据读取 使用NModBus4库，通过具体的内容向...

C#编程之C# Modbus 数据读取 使用NModBus4库

http://m.zhizuobiao.com/net/net-18091700173/

2018-09-17 来自 03142

摘要：本文主要向大家介绍了C#编程之C# Modbus 数据读取 使用NModBus4库，通过具体的内容向大家展示，希望对大家学习C#编程有所帮助。

本文主要向大家介绍了C#编程之C#  Modbus 数据读取  使用NModBus4库，通过具体的内容向大家展示，希望对大家学习C#编程有所帮助。

方法名    作用    所需参数    返回值    对应功能码    

ReadCoils    读取DO的状态    从站地址(8位)    bool[]    1    

byte slaveAddress    

起始地址(16位)    

 

ushort startAddress    

读取数量(16位)    

ushort numberOfPoints    

ReadInputs    读取DI的状态    从站地址(8位)    bool[]    2    

byte slaveAddress    

起始地址(16位)    

 

ushort startAddress    

读取数量(16位)    

ushort numberOfPoints    

ReadHoldingRegisters    读取AO的值    从站地址(8位)    ushort[]    3    

byte slaveAddress    

起始地址(16位)     

ushort startAddress    

读取数量(16位)    

ushort numberOfPoints    

ReadInputRegisters    读取AI的值    从站地址(8 位)    ushort[]    4    

byte slaveAddress    

起始地址(16位)    

 

ushort startAddress    

读取数量(16位)    

ushort numberOfPoints    

WriteSingleCoil    写入值到DO    从站地址(8位)    无返回值    5    

byte slaveAddress    

线圈地址(16位)    

ushort coilAddress    

写入值(布尔型)    

bool value    

WriteSingleRegister    写入值到AO    从站地址(8位)    无返回值    6    

byte slaveAddress    

寄存器地址(16位)    

ushort registerAddress    

写入值(16位)    

ushort value    

WriteMultipleCoils    写多线圈寄存器    从站地址(8位)    无返回值    15    

byte slaveAddress    

起始地址(16位)    

ushort startAddress    

写入值(布尔型数组)    

bool[] data    

WriteMultipleRegisters    写多个保持寄存器    从站地址(8位)    无返回值    16    

byte slaveAddress    

 

起始地址(16位)    

ushort startAddress,    

寄存器值(16位整型数组)    

ushort[] data    

ReadWriteMultipleRegisters    读写多个保持寄存器    从站地址(8位)    ushort[]    23    

byte slaveAddress    

读起始地址(16位)    

ushort startReadAddress    

 

读取数量(16位)    

ushort numberOfPointsToRead,    

写入起始地址(16位)    

ushort startWriteAddress,    

写入值(16位整型数组)    

ushort[] writeData    



modbus通讯协议NET库

　　  这样的开源库很多,我这边用的库是github的开源实现类库：NModBus4，github地址：https://github.com/NModbus4/NModbus4

 

          我用Modbus Slave模拟一个从机

            

           设置数据

            

 

           NModbus4的读取从机代码示例

           

 1             IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });

 2             using (TcpClient client = new TcpClient(address.ToString(), 502))

 3             {

 4                 client.SendTimeout = 1;

 5                 //client.op

 6                 ModbusIpMaster master = ModbusIpMaster.CreateIp(client);

 7                 //master.op

 8                 // read five input values

 9                 ushort startAddress = 0;

10                 ushort numInputs = 10;

11                 bool[] inputs = master.ReadCoils(1, startAddress, numInputs);

12 

13                 for (int i = 0; i < numInputs; i++)

14                 {

15                     Console.WriteLine($"Input {(startAddress + i)}={(inputs[i] ? 1 : 0)}");

16                 }

17 

18             }

   这边值得注意的是主机Read的方法第一个参数是slaveId  如果不加就startAddress And numInputs   NModbus就会默认 slaveId是0  一直异常( d(╯﹏╰)b 痛苦经历~~)

 

   

   以上数据是 刚才设置的DO 状态

   在演示一个读取AI的值

     

     

 

     代码没差多少就是方法ReadInputRegisters不一样  . 以下是示例代码

 1 IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });

 2             using (TcpClient client = new TcpClient(address.ToString(), 502))

 3             {

 4                 client.SendTimeout = 1;

 5                 //client.op

 6                 ModbusIpMaster master = ModbusIpMaster.CreateIp(client);

 7                 //master.op

 8                 // read five input values

 9                 ushort startAddress = 0;

10                 ushort numInputs = 10;

11                 ushort[] inputs = master.ReadInputRegisters(2, startAddress, numInputs);

12 

13                 for (int i = 0; i < numInputs; i++)

14                 {

15                     Console.WriteLine($"Register {(startAddress + i)}={(inputs[i])}");

16                 }

17 

18             }

收起

展开全文

C#读取串口数据封装， RS485、232 MODBUS通讯协议，亲测可用
2020-09-17 14:30:49
C#读取串口数据封装， RS485、232 MODBUS通讯协议，亲测可用
收起
C# Modbus RTU数据读取代码文件
2017-08-15 10:28:11
这是一款基于C#的简单实用的数据测试工具的后台代码文件
收起
C# Modbus 数据读取 使用NModBus4库
千次阅读 2019-09-24 00:52:01
ModBus通讯协议方法名作用所需参数返回值对应功能码 ReadCoils 读取DO的状态从站地址(8位) byte slaveAddress 起始地址(16位) ushort startAddress...
收起
C#实现Modbus RTU高速读取下位机寄存器数据
2016-08-09 04:53:37
如题，已经实现读数，但是速度不是特别快，有没有超快速的读取方法？
收起
C# ModBus Tcp客户端读取数据 完整Demo
千次阅读 2019-10-04 19:47:07
简单介绍：　项目上需要与多家公司做接口对接。我们提供接口的有，其他公司提供的接口也有。所有的接口全部对接完了，遇到一个非常棘手的问题，需要...　Modbus是一种串行通信协议，是Modicon公司（现在的施耐德电...
收起
C# 读取18b20温度计度数 MODBUS协议
2016-06-27 23:12:17
本程序能够自动读取温度数据，采用C#实现，对刚接触串口通讯的童鞋具有重要的意义。
收起
C# ModbusRTU通信寄存器数据读写
千次阅读 2020-07-13 11:13:52
先了解ModbusRTU的通信协议。功能码：代码名称作用 01 读取线圈状态取得一组逻辑线圈的当前状态（ON/OFF) 02 读取输入状态...
收起
C# modbus TCPIO
千次阅读 2016-08-10 00:13:45
C#如何读取Modbus数据，Modbus很多人可能一点都不知道，也正常，隔行如隔山嘛。Modbus在自动化行业就不一样，属于路人皆知的东西，很多设备、程序都与Modbus息息相关。 Modbus这个东西，本人也是个二把刀，只有...
收起
C# Modbus协议中读取浮点数的操作方法
2020-12-10 17:19:49
输入参数P1,P2代表PLC中浮点数储存的两个寄存器获取的数据 public static float GetFloat(ushort P1, ushort P2) { int intSign, intSignRest, intExponent, intExponentRest; float faResult, faDigit; ...
收起
多个线程对串口读取 modbus_结合工控和IT的一个Modbus通讯小测试
2020-12-14 11:30:02
为了拓展自己的知识，最近开始接触使用C#...这不，参考着相关的Modbus通讯协议先写了一个03功能的小测试程序，也就是读取保持型寄存器数据。软件结构如下图所示一个Modbus通讯类库，一个测试窗口程序，当然还少不...
收起
c#与485MODBUS串口通信源代码.rar
2019-12-17 14:29:59
c#与485MODBUS串口通信源代码，通过串口读取设备数据，c#的源代码，比如读取PLC数据（AD采集的或设置的），可以控制PLC（支持MODBUS）动作，485通信可以达到500M(稳定通信)，也可和单片机通信，我资源里有关于8051...
收起
C# modbus浮点数处理
2014-05-05 15:30:13
文档里x1 x2 为读取到浮点数的2个16位寄存器整型数据，返回值就是所需要的浮点数
收起
Modbus TCP 、 Nmodbus开源库 Nmodbus上位机(C#)Demo
2019-04-23 13:14:42
Nmodbus的开源库，4种方式读取Modbus Tcp 数据。
收起
C#Modbus通讯帮助类库(串口下的ModbusRTUMaster 主站)
2019-04-08 16:57:29
/// 数据读取延迟 /// 设备从站地址 /// 数据起始地址 /// 寄存器数量 /// 返回的寄存器数值 /// 返回异常描述 /// 是否读取成功 public bool ReadHoldReg(int timeout, byte slaveAddress, ushort start...
收起
C#工控机作为Modbus从站的方法
2020-02-10 14:15:16
工作需要实现HMI作为Modbus主站，工控机作为modbus从站。... 首先，工控机作为从站的话，是没有办法去读写主站的，也就是说，工控机端只能读取HMI写进来的数据，或者把数据写如到存储区，等待HMI来读取。这里使用...
收起
NModbus
Modbus Poll CS.zip
2020-04-20 13:53:43
C# modbus对对串口发送的封装，实现串口modbus rtu数据发送，显示发送缓冲区内容，用于读取Modbus通讯里slave 的寄存器的值
收起
C#中针对NModbus4库文件的简单使用分享(Modbus Tcp协议)
2020-12-25 00:53:52
ModBus地址：由5位数字组成（PS：40001-49999表示HoldingRegister），包括起始数据类型代号，以及后面的偏移地址 2. 实验目的：实现主机\从机对任意线圈和寄存器的写入和读取。这里用到的Dll名称是：NModbus4。 ...
收起
ModbusRTU.zip
2020-07-07 16:56:26
Visual studio 2012 C#语言，ModbusRTU通信，读取保持寄存器的值，两个按钮，连接串口 读取数据
收起
友善串口工具接收数据随机换行_C#制作STM32上位机升级工具（完整教程）
2021-01-02 17:45:15
本文转自21ic论坛，作者cry1109思路很简单，C#制作一个上位机工具，将读取的bin文件通过串口下发至单片机，一帧数据包含：7字节的Modbus协议帧头+200字节数据更新包(最后一帧少于等于200字节)+2字节的CRC校验码。...
收起
Modbus之Nmodbus的下载和使用
万次阅读 2017-02-18 10:25:59
最近做个项目，需要PC机通过局域网读取多台威纶人机中的数据，于是找到了Nmodbus库。环境：win10+vs2010 C# Nmodbus下载：这里 step 1.将Nmodbus中的modbus作为一个类项目直接加载到我们自己的项目中，直接右键...
收起
C#电力测控装置
2018-03-12 15:56:56
电力测控装置，编写串口，通过modbus通讯协议，读取仪器中的数据。适合初学者，不过需要有仪器的使用说明书。
收起
[求助]关于Modbus通讯，一主多从，通讯卡顿
2019-05-31 17:19:07
问题描述：上位机是C#WINFORM通过485串口用modbus协议和PLC、陀螺仪、以及支架传感器通信。 1.当通讯波特率设置到115200时，就通讯错误了，但是和一个设备用115200是没问题的。 2.只和PLC进行通讯，既有读也有写，...
收起
C# USB转串口程序问题
2019-06-20 13:31:27
我很疑惑这个程序是不是从USB端口里面拿的数据，即数据经过USB转串口线，然后程序读取USB内的数据，在展现出来；那么问题来了，我现在是继续寻找发掘现在电脑的串口在哪里，继续走开发串口的路子；还是用USB...
收起

C#读取Modbus数据

c#读取modbus数据

【转】c#读取Modbus数据

C#编程之C# Modbus 数据读取 使用NModBus4库

C#读取串口数据封装， RS485、232 MODBUS通讯协议，亲测可用

C# Modbus RTU数据读取代码文件

C# Modbus 数据读取 使用NModBus4库

C#实现Modbus RTU高速读取下位机寄存器数据

C# ModBus Tcp客户端读取数据 完整Demo

C# 读取18b20温度计度数 MODBUS协议

C# ModbusRTU通信寄存器数据读写

C# modbus TCPIO

C# Modbus协议中读取浮点数的操作方法

多个线程对串口读取 modbus_结合工控和IT的一个Modbus通讯小测试

c#与485MODBUS串口通信源代码.rar

C# modbus浮点数处理

Modbus TCP 、 Nmodbus开源库 Nmodbus上位机(C#)Demo

C#Modbus通讯帮助类库(串口下的ModbusRTUMaster 主站)

C#工控机作为Modbus从站的方法

Modbus Poll CS.zip

C#中针对NModbus4库文件的简单使用分享(Modbus Tcp协议)

ModbusRTU.zip

友善串口工具接收数据随机换行_C#制作STM32上位机升级工具（完整教程）

Modbus之Nmodbus的下载和使用

C#电力测控装置

[求助]关于Modbus通讯，一主多从，通讯卡顿

C# USB转串口程序问题

c#读取modbus数据

libFuzzer视频教程

【布道者】Linux极速入门

MySQL 高可用工具 DRBD 实战部署详解

质量保证书-源码

a2a-ip-trust-ip-configuration：用于访问IP音频信任组件的OpenShift构建和部署配置-源码

一天学完MySQL数据库

Amoeba 实现 MySQL 高可用、负载均衡和读写分离

Reflect.ownKeys()与Object.keys()区别

产品经理的情报收集与分析.pdf

一个认真做技术分享的小年青，欢迎关注他

在 Linux 上构建企业级 DNS 域名解析服务

自动化测试Python3+Selenium3+Unittest

==与===有什么区别

2.2.2 服务通信自定义srv

3-2 数据类型之char类型

第四章 C语言 PTA数组——作业-答案.html

access应用的3个开发实例

null和undifind的区别？

MySQL 主从复制 Replication 详解（Linux 和 W

基于Flink+Hudi构建企业亿级云上实时数据湖教程（PC、移动、小

C#编程之C# Modbus 数据读取使用NModBus4库

C# Modbus 数据读取使用NModBus4库

C# ModBus Tcp客户端读取数据完整Demo