ModbusRTU通信工具设计

 

Modbus 是一个工业上常用的通讯协议、一种通讯约定。

成都创新互联是一家集网站建设,威海企业网站建设,威海品牌网站建设,网站定制,威海网站建设报价,网络营销,网络优化,威海网站推广为一体的创新建站企业,帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿,时刻以成就客户成长自我,坚持不断学习、思考、沉淀、净化自己,让我们为更多的企业打造出实用型网站。

ModBus 协议是应用层报文传输协议(OSI 模型第7层),它定义了一个与通信层无关的协议数据单元(PDU),即PDU=功能码+数据域。
ModBus 协议能够应用在不同类型的总线或网络。对应不同的总线或网络,Modbus 协议引入一些附加域映射成应用数据单元(ADU),即ADU=附加域+PDU。目前,Modbus 有下列三种通信方式:
1. 以太网,对应的通信模式是Modbus TCP。
2. 异步串行传输(各种介质如有线RS-232-/422/485/;光纤、无线等),对应的通信模式是 Modbus RTU 或 Modbus ASCII。Modbus 的ASCII、RTU 协议规定了消息、数据的结构、命令和应答的方式,数据通讯采用Maser/Slave方式。
3. 高速令牌传递网络,对应的通信模式是Modbus PLUS。

 

Modbus 需要对数据进行校验,串行协议中除有奇偶校验外,ASCII 模式采用LRC 校验;RTU 模式采用16位CRC 校验;TCP 模式没有额外规定校验,因为TCP 是一个面向连接的可靠协议。

 

Modbus 协议的应用中,最常用的是Modbus RTU 传输模式。

 

RTU 传输模式 

当设备使用RTU (Remote Terminal Unit) 模式在 Modbus  串行链路通信, 报文中每个8位字节含有两个4位十六进制字符。这种模式的主要优点是较高的数据密度,在相同的波特率下比ASCII 模式有更高的吞吐率。每个报文必须以连续的字符流传送。 

 

RTU 模式每个字节 ( 11 位 ) 的格式为:

       编码系统:  8位二进制。 报文中每个8位的字节含有两个4位十六进制字符(0–9, A–F)

  Bits per Byte:  1 起始位

                   8 数据位, 首先发送最低有效位

                   1 位作为奇偶校验

                   1 停止位

偶校验是要求的,其它模式 ( 奇校验, 无校验 ) 也可以使用。为了保证与其它产品的最大兼容性,同时支持无校验模式是建议的。默认校验模式模式 必须为偶校验。注:使用无校验要求2 个停止位。 

 

字符的串行传送方式:

每个字符或字节均由此顺序发送(从左到右):最低有效位 (LSB) . . . 最高有效位 (MSB)

Modbus RTU 通信工具设计

图1:RTU 模式位序列 

 

设备配置为奇校验、偶校验或无校验都可以接受。如果无奇偶校验,将传送一个附加的停止位以填充字符帧:

Modbus RTU 通信工具设计

图2:RTU 模式位序列 (无校验的特殊情况)

 

帧检验域:循环冗余校验 (CRC)

在RTU 模式包含一个对全部报文内容执行的,基于循环冗余校验 (CRC - Cyclical Redundancy Checking) 算法的错误检验域。

CRC 域检验整个报文的内容。不管报文有无奇偶校验,均执行此检验。

CRC 包含由两个8位字节组成的一个16位值。  

CRC 域作为报文的最后的域附加在报文之后。计算后,首先附加低字节,然后是高字节。CRC 高字节为报文发送的最后一个子节。

附加在报文后面的CRC 的值由发送设备计算。接收设备在接收报文时重新计算 CRC 的值,并将计算结果于实际接收到的CRC 值相比较。如果两个值不相等,则为错误。

CRC 的计算,开始对一个16位寄存器预装全1。 然后将报文中的连续的8位子节对其进行后续的计算。只有字符中的8个数据位参与生成CRC 的运算,起始位,停止位和校验位不参与 CRC 计算。

CRC 的生成过程中, 每个 8–位字符与寄存器中的值异或。然后结果向最低有效位(LSB)方向移动(Shift) 1位,而最高有效位(MSB)位置充零。 然后提取并检查 LSB:如果LSB 为1, 则寄存器中的值与一个固定的预置值异或;如果LSB 为 0, 则不进行异或操作。

这个过程将重复直到执行完8次移位。完成最后一次(第8次)移位及相关操作后,下一个8位字节与寄存器的当前值异或,然后又同上面描述过的一样重复8次。当所有报文中子节都运算之后得到的寄存器中的最终值,就是CRC。

当CRC 附加在报文之后时,首先附加低字节,然后是高字节。

CRC 算法如下:

  1. private bool CheckResponse(byte[] response) 
  2.     //Perform a basic CRC check: 
  3.     byte[] CRC = new byte[2]; 
  4.     GetCRC(response, ref CRC); 
  5.     if (CRC[0] == response[response.Length - 2] && CRC[1] == response[response.Length - 1]) 
  6.     return true; 
  7.     else 
  8.     return false; 
  9.  
  10. private void GetCRC(byte[] message, ref byte[] CRC) 
  11.     //Function expects a modbus message of any length as well as a 2 byte CRC array in which to  
  12.     //return the CRC values: 
  13.  
  14.     ushort CRCFull = 0xFFFF; 
  15.     byte CRCHigh = 0xFF, CRCLow = 0xFF; 
  16.     char CRCLSB; 
  17.  
  18.     for (int i = 0; i < (message.Length) - 2; i++) 
  19.     { 
  20.     CRCFull = (ushort)(CRCFull ^ message[i]); 
  21.  
  22.     for (int j = 0; j < 8; j++) 
  23.     { 
  24.         CRCLSB = (char)(CRCFull & 0x0001); 
  25.         CRCFull = (ushort)((CRCFull >> 1) & 0x7FFF); 
  26.  
  27.         if (CRCLSB == 1) 
  28.         CRCFull = (ushort)(CRCFull ^ 0xA001); 
  29.     } 
  30.     } 
  31.     CRC[1] = CRCHigh = (byte)((CRCFull >> 8) & 0xFF); 
  32.     CRC[0] = CRCLow = (byte)(CRCFull & 0xFF); 

 

帧描述 (如下图所示) :

Modbus RTU 通信工具设计

图3:RTU 报文帧

注意:Modbus  RTU 帧最大为256字节。

 

下面是我为公司设计的一个 Modbus RTU 通信测试小工具,界面截图如下:

Modbus RTU 通信工具设计

图4:Modbus RTU 通信工具

 

我的通用Modbus RTU 动态库,modbus.cs 如下:

  1. modbus.cs 
  2.  
  3. using System; 
  4. using System.Collections.Generic; 
  5. using System.Text; 
  6. using System.IO.Ports; 
  7. using System.Threading; 
  8.  
  9. namespace SerialPort_Lib 
  10.     public class modbus 
  11.     { 
  12.         private SerialPort sp = new SerialPort(); 
  13.         public string modbusStatus; 
  14.  
  15.         #region Constructor / Deconstructor 
  16.         public modbus() 
  17.         { 
  18.         } 
  19.         ~modbus() 
  20.         { 
  21.         } 
  22.         #endregion 
  23.  
  24.         #region Open / Close Procedures 
  25.         public bool Open(string portName, int baudRate, int databits, Parity parity, StopBits stopBits) 
  26.         { 
  27.             //Ensure port isn't already opened: 
  28.             if (!sp.IsOpen) 
  29.             { 
  30.                 //Assign desired settings to the serial port: 
  31.                 sp.PortName = portName; 
  32.                 sp.BaudRate = baudRate; 
  33.                 sp.DataBits = databits; 
  34.                 sp.Parity = parity; 
  35.                 sp.StopBits = stopBits; 
  36.                 //These timeouts are default and cannot be editted through the class at this point: 
  37.                 sp.ReadTimeout = -1; 
  38.                 sp.WriteTimeout = 10000; 
  39.  
  40.                 try 
  41.                 { 
  42.                     sp.Open(); 
  43.                 } 
  44.                 catch (Exception err) 
  45.                 { 
  46.                     modbusStatus = "Error opening " + portName + ": " + err.Message; 
  47.                     return false; 
  48.                 } 
  49.                 modbusStatus = portName + " opened successfully"; 
  50.                 return true; 
  51.             } 
  52.             else 
  53.             { 
  54.                 modbusStatus = portName + " already opened"; 
  55.                 return false; 
  56.             } 
  57.         } 
  58.         public bool Close() 
  59.         { 
  60.             //Ensure port is opened before attempting to close: 
  61.             if (sp.IsOpen) 
  62.             { 
  63.                 try 
  64.                 { 
  65.                     sp.Close(); 
  66.                 } 
  67.                 catch (Exception err) 
  68.                 { 
  69.                     modbusStatus = "Error closing " + sp.PortName + ": " + err.Message; 
  70.                     return false; 
  71.                 } 
  72.                 modbusStatus = sp.PortName + " closed successfully"; 
  73.                 return true; 
  74.             } 
  75.             else 
  76.             { 
  77.                 modbusStatus = sp.PortName + " is not open"; 
  78.                 return false; 
  79.             } 
  80.         } 
  81.         #endregion 
  82.  
  83.         #region CRC Computation 
  84.         private void GetCRC(byte[] message, ref byte[] CRC) 
  85.         { 
  86.             //Function expects a modbus message of any length as well as a 2 byte CRC array in which to  
  87.             //return the CRC values: 
  88.  
  89.             ushort CRCFull = 0xFFFF; 
  90.             byte CRCHigh = 0xFF, CRCLow = 0xFF; 
  91.             char CRCLSB; 
  92.  
  93.             for (int i = 0; i < (message.Length) - 2; i++) 
  94.             { 
  95.                 CRCFull = (ushort)(CRCFull ^ message[i]); 
  96.  
  97.                 for (int j = 0; j < 8; j++) 
  98.                 { 
  99.                     CRCLSB = (char)(CRCFull & 0x0001); 
  100.                     CRCFull = (ushort)((CRCFull >> 1) & 0x7FFF); 
  101.  
  102.                     if (CRCLSB == 1) 
  103.                         CRCFull = (ushort)(CRCFull ^ 0xA001); 
  104.                 } 
  105.             } 
  106.             CRC[1] = CRCHigh = (byte)((CRCFull >> 8) & 0xFF); 
  107.             CRC[0] = CRCLow = (byte)(CRCFull & 0xFF); 
  108.         } 
  109.         #endregion 
  110.  
  111.         #region Build Message 
  112.         private void BuildMessage(byte address, byte type, ushort start, ushort registers, ref byte[] message) 
  113.         { 
  114.             //Array to receive CRC bytes: 
  115.             byte[] CRC = new byte[2]; 
  116.  
  117.             message[0] = address; 
  118.             message[1] = type; 
  119.             message[2] = (byte)(start >> 8); 
  120.             message[3] = (byte)start; 
  121.             message[4] = (byte)(registers >> 8); 
  122.             message[5] = (byte)registers; 
  123.  
  124.             GetCRC(message, ref CRC); 
  125.             message[message.Length - 2] = CRC[0]; 
  126.             message[message.Length - 1] = CRC[1]; 
  127.         } 
  128.         #endregion 
  129.  
  130.         #region Check Response 
  131.         private bool CheckResponse(byte[] response) 
  132.         { 
  133.             //Perform a basic CRC check: 
  134.             byte[] CRC = new byte[2]; 
  135.             GetCRC(response, ref CRC); 
  136.             if (CRC[0] == response[response.Length - 2] && CRC[1] == response[response.Length - 1]) 
  137.                 return true; 
  138.             else 
  139.                 return false; 
  140.         } 
  141.         #endregion 
  142.  
  143.         #region Get Response 
  144.         private void GetResponse(ref byte[] response) 
  145.         { 
  146.             //There is a bug in .Net 2.0 DataReceived Event that prevents people from using this 
  147.             //event as an interrupt to handle data (it doesn't fire all of the time).  Therefore 
  148.             //we have to use the ReadByte command for a fixed length as it's been shown to be reliable. 
  149.             for (int i = 0; i < response.Length; i++) 
  150.             { 
  151.                 response[i] = (byte)(sp.ReadByte()); 
  152.             } 
  153.         } 
  154.         #endregion 
  155.  
  156.         #region GetModbusData 获得接收数据 
  157.         public bool GetModbusData(ref byte[] values) 
  158.         { 
  159.             //Ensure port is open: 
  160.             if (sp.IsOpen) 
  161.             { 
  162.                 // 等待线程进入  
  163.                 //Monitor.Enter(sp); 
  164.  
  165.                 //Clear in/out buffers: 
  166.                 //sp.DiscardOutBuffer(); 
  167.                 //sp.DiscardInBuffer(); 
  168.  
  169.                 //Message is 1 addr + 1 type + N Data + 2 CRC 
  170.                      
  171.                 try 
  172.                 { 
  173.                     //GetResponse(ref readBuffer); 
  174.                     //string str = readBuffer.ToString(); 
  175.  
  176.                     int count = sp.BytesToRead; 
  177.                     if (count > 0) 
  178.                     { 
  179.                         byte[] readBuffer = new byte[count]; 
  180.  
  181.                         GetResponse(ref readBuffer); 
  182.  
  183.                         //   readData = new byte[29]; 
  184.                         //   Array.Copy(readBuffer, readData, readData.Length); 
  185.  
  186.                         // CRC 验证 
  187.                         if (CheckResponse(readBuffer)) 
  188.                         { 
  189.                             //显示输入数据 
  190.                             values = readBuffer; 
  191.  
  192.                             modbusStatus = "Write successful"; 
  193.  
  194.                             sp.DiscardInBuffer(); 
  195.  
  196.                             //values = System.Text.Encoding.ASCII.GetString(readData); 
  197.                             return true; 
  198.                         } 
  199.                         else 
  200.                         { 
  201.                             modbusStatus = "CRC error"; 
  202.  
  203.                             sp.DiscardInBuffer(); 
  204.  
  205.                             return false; 
  206.                         } 
  207.                     } 
  208.                     else return false; 
  209.                 } 
  210.                 catch (Exception err) 
  211.                 { 
  212.                     modbusStatus = "Error in write event: " + err.Message; 
  213.  
  214.                     sp.DiscardInBuffer(); 
  215.  
  216.                     return false; 
  217.                 } 
  218.  
  219.                 //finally 
  220.                 //{ 
  221.                     // 通知其它对象 
  222.                     //Monitor.Pulse(sp); 
  223.                     // 释放对象锁  
  224.                     //Monitor.Exit(sp); 
  225.                 //} 
  226.             } 
  227.             else 
  228.             { 
  229.                 modbusStatus = "Serial port not open"; 
  230.                 return false; 
  231.             } 
  232.         } 
  233.         #endregion 
  234.  
  235.         #region SendModbusData 打包发送数据 
  236.         public bool SendModbusData(ref byte[] values) 
  237.         { 
  238.             //Ensure port is open: 
  239.             if (sp.IsOpen) 
  240.             { 
  241.                 //Clear in/out buffers: 
  242.                 sp.DiscardOutBuffer(); 
  243.                 sp.DiscardInBuffer(); 
  244.  
  245.                 //Function 3 response buffer: 
  246.                 byte[] response = new byte[values.Length + 2]; 
  247.                 Array.Copy(values, response, values.Length); 
  248.  
  249.                 //BuildMessage(address, (byte)3, start, registers, ref message); 
  250.  
  251.                 //打包带有 CRC 验证的modbus 数据包: 
  252.                 byte[] CRC = new byte[2]; 
  253.                 GetCRC(response, ref CRC); 
  254.                 response[response.Length - 2] = CRC[0]; 
  255.                 response[response.Length - 1] = CRC[1]; 
  256.  
  257.                 values = response; //返回带有 CRC 验证的modbus 数据包 
  258.  
  259.                 //Send modbus message to Serial Port: 
  260.                 try 
  261.                 { 
  262.                     sp.Write(response, 0, response.Length); 
  263.                     //GetResponse(ref response); 
  264.                     return true; 
  265.                 } 
  266.                 catch (Exception err) 
  267.                 { 
  268.                     modbusStatus = "Error in read event: " + err.Message; 
  269.                     return false; 
  270.                 } 
  271.                 //Evaluate message: 
  272.                 //if (CheckResponse(response)) 
  273.                 //{ 
  274.                 //    //Return requested register values: 
  275.                 //    for (int i = 0; i < (response.Length - 5) / 2; i++) 
  276.                 //    { 
  277.                 //        values[i] = response[2 * i + 3]; 
  278.                 //        values[i] <<= 8; 
  279.                 //        values[i] += response[2 * i + 4]; 
  280.                 //    } 
  281.                 //    modbusStatus = "Read successful"; 
  282.                 //    return true; 
  283.                 //} 
  284.                 //else 
  285.                 //{ 
  286.                 //    modbusStatus = "CRC error"; 
  287.                 //    return false; 
  288.                 //} 
  289.             } 
  290.             else 
  291.             { 
  292.                 modbusStatus = "Serial port not open"; 
  293.                 return false; 
  294.             } 
  295.  
  296.         } 
  297.         #endregion 
  298.  
  299.     } 

 

调用的主要代码如下:

  1. modbus类的winform调用代码 
  2.  
  3. public partial class FormConfig : Form,IModbusData 
  4.     //业务处理类 
  5.     B_ModbusData ModbusDataBLL = new B_ModbusData(); 
  6.  
  7.     modbus mb = new modbus(); 
  8.     //SerialPort sp = new SerialPort(); 
  9.     System.Timers.Timer timer = new System.Timers.Timer(); 
  10.  
  11.     public FormConfig() 
  12.     { 
  13.         InitializeComponent(); 
  14.         
  15.         timer.Elapsed += new ElapsedEventHandler(timer_Elapsed); 
  16.     } 
  17.  
  18.     #region Timer Elapsed 事件处理程序 
  19.     bool&
    分享题目:ModbusRTU通信工具设计
    文章出自:http://scyanting.com/article/gjpjjp.html