91超碰碰碰碰久久久久久综合_超碰av人澡人澡人澡人澡人掠_国产黄大片在线观看画质优化_txt小说免费全本

溫馨提示×

溫馨提示×

您好，登錄后才能下訂單哦！

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Modbus RTU 通信工具設計

發布時間：2020-06-18 05:02:04 來源：網絡 閱讀：3982 作者：guangrou 欄目：編程語言
 

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 runEnd = true; 
  21.     void timer_Elapsed(object sender, ElapsedEventArgs e) 
  22.     { 
  23.         if (runEnd == true) 
  24.         { 
  25.             runEnd = false; 
  26.             PollFunction(); 
  27.             runEnd = true; 
  28.         } 
  29.     } 
  30.  
  31.     //定時器調用方法 
  32.     private void PollFunction() 
  33.     { 
  34.         byte[] values = null; 
  35.         try 
  36.         { 
  37.             mb.GetModbusData(ref values); 
  38.             //while (!mb.SendFc3(Convert.ToByte(txtSlaveID.Text), pollStart, pollLength, ref values)) ; 
  39.         } 
  40.         catch (Exception err) 
  41.         { 
  42.             DoGUIStatus("Error in modbus read: " + err.Message); 
  43.         } 
  44.  
  45.         if (values != null) 
  46.         { 
  47.             //業務處理 
  48.             byte[] sendData = ModbusDataProcess(values); 
  49.         } 
  50.     } 
  51.     #endregion 
  52.  
  53.     #region IModbusData 接口成員處理 
  54.     public byte[] ModbusDataProcess(byte[] _data) 
  55.     { 
  56.        byte[] sendData = ModbusDataBLL.ModbusDataProcess(_data); 
  57.  
  58.        // CRC驗證，并打包發送數據。 
  59.        mb.SendModbusData(ref sendData); 
  60.  
  61.        return sendData; 
  62.     } 
  63.     #endregion 
  64. } 

 

其實，三步就能成功調用：

  1. modbus mb = new modbus(); 
  2. mb.GetModbusData(ref values); // 從串口設備獲得數據。 
  3. byte[] sendData = ModbusDataBLL.ModbusDataProcess(values); // 你的業務處理，并產生最終返回數據。 
  4. mb.SendModbusData(ref sendData); // CRC驗證，并打包發送數據。 


主要代碼已全部提供，由于工作原因暫不提供完整工具源代碼，見諒！

（完）

 
向AI問一下細節

免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。

AI
助
手
威信县| 青浦区| 扶绥县| 鄂伦春自治旗| 龙江县| 祁阳县| 琼海市| 菏泽市| 禹州市| 德清县| 永清县| 聂拉木县| 广宁县| 荆州市| 包头市| 文安县| 九龙县| 思南县| 武强县| 海丰县| 称多县| 台州市| 武鸣县| 静乐县| 余江县| 丘北县| 宁强县| 英超| 定襄县| 灌南县| 长宁区| 滕州市| 饶平县| 竹溪县| 诸暨市| 隆尧县| 家居| 布拖县| 万州区| 常宁市| 商都县|