码上快乐

相关内容   简体   繁体

C#读取Modbus数据

本文转载自  查看原文  2017-04-10 16:15  2355    C#/ 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服务在哪里。所以如下代码就水到渠成了。
   
[csharp]  view plain  copy
 
 在CODE上查看代码片派生到我的代码片
  1. public bool Open(string ip,int port) {  
  2.            try {  
  3.                tcpClient = new TcpClient();  
  4.   
  5.                tcpClient.Connect(IPAddress.Parse(ip), port);  
  6.   
  7.                return true;  
  8.            }catch(SocketException e){  
  9.                string m = string.Format("modbus Client服务器连接错误:{0},ip:{1},port:{2}", e.Message, ip, port);  
  10.                LogHelper.WriteLog(m);  
  11.                return false;  
  12.            }  
  13.        }  
         其中LogHelper代码这里就不写，因为与主题无关，如果想运行上面代码的话，注释就行了，我个人推荐这样的代码也没必要去运行一下，看看能明白就行了。去运行这个事情，有事会耽误太多的时间。这里IP和端口号都是由设备方提供的。真实程序一般都把这两个参数写配置文件中。
       设备连上以后，下一步当然就是读取数据。Modbus的基本原理就是程序向设备请求，需要读取哪个数据，设备就会返回相应的数据。我们知道机器或者说是电脑是只认识01001这样的字符串的。所以所谓的Modbus协议，说得简单一点，就是规定这样一个0101字符各代表什么含义。
    
[csharp]  view plain  copy
 
 在CODE上查看代码片派生到我的代码片
  1. /// <summary>  
  2.         /// 读取数据 Modbus  
  3.         /// </summary>  
  4.         /// <param name="rData">结果</param>  
  5.         /// <param name="id">设备号</param>  
  6.         /// <param name="address">设备地址</param>  
  7.         /// <param name="len">长度-多少个设备</param>  
  8.         /// <returns>数据读取结果 是否成功</returns>  
  9.         public bool ReceiveData(ref short[] rData, short id, short address, short len)  
  10.         {  
  11.             try  
  12.             {  
  13.                 short m = Convert.ToInt16(new Random().Next(2, 20));  
  14.                 rData = null;  
  15.   
  16.                 byte[] bs = Receive(m, id, address, len);  
  17.                 byte[] b = TrimModbus(bs, m, id, len);  
  18.   
  19.                 if (b==null) { return false; }  
  20.   
  21.                 List<short> data = new List<short>(255);  
  22.                 for (int i = 0; i < b.Length-1; i++)  
  23.                 {  
  24.                    if (!Convert.ToBoolean(i & 1))  
  25.                    {  
  26.                         byte[] temp = new byte[] { b[i+1], b[i] };  
  27.                         data.Add(BitConverter.ToInt16(temp, 0));  
  28.                    }  
  29.                 }  
  30.                 rData = data.ToArray();  
  31.   
  32.                 return true;  
  33.             }  
  34.             catch (Exception e) {  
  35.                 LogHelper.WriteLog("返回Modbus数据错误"+ e.Message);  
  36.                 return false;  
  37.             }  
  38.         }  
这个其实更多的是处理数据异常，LogHelper与前面一样，核心好像还不在了，就是那个Receive方法。
[csharp]  view plain  copy
 
 在CODE上查看代码片派生到我的代码片
  1. /// <summary>  
  2. /// 读取 Modbus  
  3. ///00 00 00 00 00 0d  01  03  0A 14 00  14 00  14 00  14 00  14 00  
  4. /// </summary>  
  5. /// <param name="m">标示</param>  
  6. /// <param name="id">设备码</param>  
  7. /// <param name="address">开始地址</param>  
  8. /// <param name="len">设备数量</param>  
  9. /// <returns></returns>  
  10. private byte[] Receive(short m, short id, short address, short len)  
  11. {  
  12.     try  
  13.     {  
  14.         if (tcpClient == null || !tcpClient.Connected) { return null; }  
  15.   
  16.         byte[] data = GetSrcData(m, id, address, len);  
  17.           
  18.         //00 00 00 00 00 06 01 03 00 00 00 05  
  19.         tcpClient.Client.Send(data, data.Length, SocketFlags.None);  
  20.   
  21.         int size = len * 2 + 9;  
  22.   
  23.         byte[] rData = new byte[size];  
  24.   
  25.         tcpClient.Client.Receive(rData, size, SocketFlags.None);  
  26.   
  27.         //string t1 = TranBytes(rData);  
  28.   
  29.         return rData;  
  30.   
  31.     }catch(SocketException e){  
  32.         if (e.ErrorCode != 10004)  
  33.         {  
  34.             LogHelper.WriteLog(e.Message);  
  35.         }  
  36.   
  37.         if (tcpClient != null) {  
  38.             tcpClient.Close();  
  39.             tcpClient = null;  
  40.         }  
  41.   
  42.         return null;  
  43.     }  
  44. }  
  45. #endregion  
上面的代码可以说是Modbus协议核心，其实就是SOCKET发送数据和接受数据，发送是告诉主机需要取那些的数据。接受就是把主机返回来的数据接受过来。
[csharp]  view plain  copy
 
 在CODE上查看代码片派生到我的代码片
  1. //发送  
  2.         //00 00 00 00 00 06 01 03 00 00 00 05  
  3.         /// <summary>  
  4.         /// 发送字节数  
  5.         /// </summary>  
  6.         /// <param name="m"></param>  
  7.         /// <param name="len"></param>  
  8.         /// <param name="id"></param>  
  9.         /// <param name="address"></param>  
  10.         /// <returns></returns>  
  11.         private byte[] GetSrcData(short m, short id, short add, short len)  
  12.         {  
  13.             List<byte> data = new List<byte>(255);  
  14.   
  15.             data.AddRange(ValueHelper.Instance.GetBytes(m));                     //             00 01  
  16.             data.AddRange(new byte[] { 0x00, 0x00 });                            //             00 00  
  17.             data.AddRange(ValueHelper.Instance.GetBytes(Convert.ToInt16(6)));    //字节数       00 06  
  18.             data.Add(Convert.ToByte(id));                                        //路由码       01  
  19.             data.Add(Convert.ToByte(3));                                         //功能码 3-读  03  
  20.             data.AddRange(ValueHelper.Instance.GetBytes(add));                   //开始地址     00 00  
  21.             data.AddRange(ValueHelper.Instance.GetBytes(len));                   //设备数量     00 05  
  22.             return data.ToArray();  
  23.         }  
 好，到这里基本上搞定了。其实很多逻辑都在代码中，说简单的就是某个ID设备，从哪个地址开始，读几个设备的值，这里需要注意是short 不要用32位的int去替换，结果会不一样的。仔细看看估计大家都能明白，也没有什么神秘的东西。
哦，对了还ValueHelper代码
[csharp]  view plain  copy
 
 在CODE上查看代码片派生到我的代码片
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4.   
  5. namespace Modbus {  
  6.     public class ValueHelper  
  7.     {  
  8.         #region 大小端判断  
  9.   
  10.         public static bool LittleEndian = false;  
  11.   
  12.         static ValueHelper()  
  13.         {  
  14.             unsafe  
  15.             {  
  16.                 int tester = 1;  
  17.                 LittleEndian = (*(byte*)(&tester)) == (byte)1;  
  18.             }  
  19.         }  
  20.         #endregion  
  21.  
  22.         #region Factory  
  23.         public static ValueHelper _Instance = null;  
  24.         internal static ValueHelper Instance  
  25.         {  
  26.             get  
  27.             {  
  28.                 if (_Instance == null)  
  29.                 {  
  30.                     _Instance = LittleEndian ? new LittleEndianValueHelper() : new ValueHelper();  
  31.                     //_Instance = new ValueHelper();  
  32.                 }  
  33.                 return _Instance;  
  34.             }  
  35.         }  
  36.         #endregion  
  37.   
  38.         protected ValueHelper()  
  39.         {  
  40.   
  41.         }  
  42.   
  43.         public virtual Byte[] GetBytes(short value)  
  44.         {  
  45.             return BitConverter.GetBytes(value);  
  46.         }  
  47.   
  48.         public virtual Byte[] GetBytes(int value)  
  49.         {  
  50.             return BitConverter.GetBytes(value);  
  51.         }  
  52.   
  53.         public virtual Byte[] GetBytes(float value)  
  54.         {  
  55.             return BitConverter.GetBytes(value);  
  56.         }  
  57.   
  58.         public virtual Byte[] GetBytes(double value)  
  59.         {  
  60.             return BitConverter.GetBytes(value);  
  61.         }  
  62.   
  63.         public virtual short GetShort(byte[] data)  
  64.         {  
  65.             return BitConverter.ToInt16(data, 0);  
  66.         }  
  67.   
  68.         public virtual int GetInt(byte[] data)  
  69.         {  
  70.             return BitConverter.ToInt32(data, 0);  
  71.         }  
  72.   
  73.         public virtual float GetFloat(byte[] data)  
  74.         {  
  75.             return BitConverter.ToSingle(data, 0);  
  76.         }  
  77.   
  78.         public virtual double GetDouble(byte[] data)  
  79.         {  
  80.             return BitConverter.ToDouble(data, 0);  
  81.         }  
  82.     }  
  83.   
  84.     internal class LittleEndianValueHelper : ValueHelper  
  85.     {  
  86.         public override Byte[] GetBytes(short value)  
  87.         {  
  88.             return this.Reverse(BitConverter.GetBytes(value));  
  89.         }  
  90.   
  91.         public override Byte[] GetBytes(int value)  
  92.         {  
  93.             return this.Reverse(BitConverter.GetBytes(value));  
  94.         }  
  95.   
  96.         public override Byte[] GetBytes(float value)  
  97.         {  
  98.             return this.Reverse(BitConverter.GetBytes(value));  
  99.         }  
  100.   
  101.         public override Byte[] GetBytes(double value)  
  102.         {  
  103.             return this.Reverse(BitConverter.GetBytes(value));  
  104.         }  
  105.   
  106.         public virtual short GetShort(byte[] data)  
  107.         {  
  108.             return BitConverter.ToInt16(this.Reverse(data), 0);  
  109.         }  
  110.   
  111.         public virtual int GetInt(byte[] data)  
  112.         {  
  113.             return BitConverter.ToInt32(this.Reverse(data), 0);  
  114.         }  
  115.   
  116.         public virtual float GetFloat(byte[] data)  
  117.         {  
  118.             return BitConverter.ToSingle(this.Reverse(data), 0);  
  119.         }  
  120.   
  121.         public virtual double GetDouble(byte[] data)  
  122.         {  
  123.             return BitConverter.ToDouble(this.Reverse(data), 0);  
  124.         }  
  125.   
  126.         private Byte[] Reverse(Byte[] data)  
  127.         {  
  128.             Array.Reverse(data);  
  129.             return data;  
  130.         }  
  131.     }  
  132. }  
不好意思，有个方法给忘记了
[csharp]  view plain  copy
 
 在CODE上查看代码片派生到我的代码片
  1. private byte[] TrimModbus(byte[] d, short m, short id, short len)  
  2.        {  
  3.            int size = Convert.ToInt32(len) * 2;  
  4.            int dLen = size + 9;  
  5.   
  6.            if (d == null || d.Length != dLen || m != Convert.ToInt16(d[1]) || id != Convert.ToInt16(d[6]))  
  7.            {  
  8.                return null;  
  9.            }  
  10.            byte[] n = new byte[size];  
  11.            Array.Copy(d, 9, n, 0, size);  
  12.            return n;  
  13.        }  
代码都贴大概都贴出来，但是如果实在想运行的，也是需要简单整理的。


免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。



猜您在找 c#读取Modbus数据 C# 读取Modbus C# Modbus 数据读取 使用NModBus4库 C# ModBus Tcp客户端读取数据 完整Demo C# 使用modbus 读取PLC 寄存器地址 C# MODBUS 通信 C# Modbus 之 EasyModbus C# MODBUS-RTU返回的数据解析 modbus串口通讯C# C# Modbus协议中读取浮点数的操作方法
 
粤ICP备18138465号  © 2018-2025 CODEPRJ.COM