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服務在哪裏。因此以下代碼就水到渠成了。
    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;
            }

全部代碼都貼出來了，可是若是實在想運行的，也是須要簡單整理的。