平武建站

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

 

帧描述 (如下图所示) ：

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

 

调用的主要代码如下：

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

其他资讯