Modbus和TCP这两个协议即有区别又有密切的联系。它们的相结合,不但实现了基于modbus/tcp/IP协议远程网络通讯,促进了modbus在其对应领域中的使用。

 

  控制器能设置为两种传输模式(ASCII或RTU)中的任何一种在标准的Modbus网络通信。用户选择想要的模式,包括串口通信参数(波特率、校验方式等),在配置每个控制器的时候,在一个Modbus网络上的所有设备都必须选择相同的传输模式和串口参数。

modbus协议主要应用于电气自动化和过程控制,一般采用RS-232或RS-485的通信接口。不足之处,就是其传输距离短、速度慢,导致应用受到局限。TCP/IP协议主要应用领域lnternet或lntranet中,它的优势就是传输距离远、传输速度快,应用范围广泛。

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

  ASCII模式:

88必发官网登入 1

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。

地址 功能代码 数据数量 数据1 数据n LRC高字节 LRC低字节 回车 换行

1、Modbus协议

 

  RTU模式:

它是应用于电气自动化电子控制器中的一种通用语言。通过这种协议就可以使控制器之间,以及控制器由网络和其它设备之间就可以通信,它也成为了一种工业标准。modbus协议是施耐德公司的串行总线协议,此协议具有良好的交互性、开放标准,在工业现场设备已经广泛被应用。

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

地址 功能代码 数据数量 数据1 数据n CRC低字节 CRC高字节

Modbus通信模式有两种,有ASCII和RTU两种。虽然有两种通信模式,使用时只能选用其中一种,混合使用是不允许的。

 

  所选的ASCII或RTU方式仅适用于标准的Modbus网络,它定义了在这些网络上连续传输的消息段的每一位,以及决定怎样将信息打包成消息域和如何解码。

2、TCP/IP协议

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

  在其它网络上(像MAP和Modbus
Plus)Modbus消息被转成与串行传输无关的帧。

其实,此协议就是物理网上的一组完整的网络协议。TCP的作用就是提供传输层服务,IP的作用就是提供网络层服务。TCP/IP协议的核心部分就是传输层协议、网络层协议及物理接口层。

 

  1、ASCII模式

上面说到了modbus协议的两种模式

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)

88必发官网登入 2

图1:RTU 模式位序列 

 

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

88必发官网登入 3

图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 算法如下:

private bool CheckResponse(byte[] response)
{
    //Perform a basic CRC check:
    byte[] CRC = new byte[2];
    GetCRC(response, ref CRC);
    if (CRC[0] == response[response.Length - 2] && CRC[1] == response[response.Length - 1])
    return true;
    else
    return false;
}

private void GetCRC(byte[] message, ref byte[] CRC)
{
    //Function expects a modbus message of any length as well as a 2 byte CRC array in which to 
    //return the CRC values:

    ushort CRCFull = 0xFFFF;
    byte CRCHigh = 0xFF, CRCLow = 0xFF;
    char CRCLSB;

    for (int i = 0; i < (message.Length) - 2; i++)
    {
    CRCFull = (ushort)(CRCFull ^ message[i]);

    for (int j = 0; j < 8; j++)
    {
        CRCLSB = (char)(CRCFull & 0x0001);
        CRCFull = (ushort)((CRCFull >> 1) & 0x7FFF);

        if (CRCLSB == 1)
        CRCFull = (ushort)(CRCFull ^ 0xA001);
    }
    }
    CRC[1] = CRCHigh = (byte)((CRCFull >> 8) & 0xFF);
    CRC[0] = CRCLow = (byte)(CRCFull & 0xFF);
}

 

帧描述 (如下图所示) :

88必发官网登入 4

图3:RTU 报文帧

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

 

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

88必发官网登入 5

图4:Modbus RTU 通信工具

 

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

88必发官网登入 688必发官网登入 7modbus.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;
using System.Threading;

namespace SerialPort_Lib
{
    public class modbus
    {
        private SerialPort sp = new SerialPort();
        public string modbusStatus;

        #region Constructor / Deconstructor
        public modbus()
        {
        }
        ~modbus()
        {
        }
        #endregion

        #region Open / Close Procedures
        public bool Open(string portName, int baudRate, int databits, Parity parity, StopBits stopBits)
        {
            //Ensure port isn't already opened:
            if (!sp.IsOpen)
            {
                //Assign desired settings to the serial port:
                sp.PortName = portName;
                sp.BaudRate = baudRate;
                sp.DataBits = databits;
                sp.Parity = parity;
                sp.StopBits = stopBits;
                //These timeouts are default and cannot be editted through the class at this point:
                sp.ReadTimeout = -1;
                sp.WriteTimeout = 10000;

                try
                {
                    sp.Open();
                }
                catch (Exception err)
                {
                    modbusStatus = "Error opening " + portName + ": " + err.Message;
                    return false;
                }
                modbusStatus = portName + " opened successfully";
                return true;
            }
            else
            {
                modbusStatus = portName + " already opened";
                return false;
            }
        }
        public bool Close()
        {
            //Ensure port is opened before attempting to close:
            if (sp.IsOpen)
            {
                try
                {
                    sp.Close();
                }
                catch (Exception err)
                {
                    modbusStatus = "Error closing " + sp.PortName + ": " + err.Message;
                    return false;
                }
                modbusStatus = sp.PortName + " closed successfully";
                return true;
            }
            else
            {
                modbusStatus = sp.PortName + " is not open";
                return false;
            }
        }
        #endregion

        #region CRC Computation
        private void GetCRC(byte[] message, ref byte[] CRC)
        {
            //Function expects a modbus message of any length as well as a 2 byte CRC array in which to 
            //return the CRC values:

            ushort CRCFull = 0xFFFF;
            byte CRCHigh = 0xFF, CRCLow = 0xFF;
            char CRCLSB;

            for (int i = 0; i < (message.Length) - 2; i++)
            {
                CRCFull = (ushort)(CRCFull ^ message[i]);

                for (int j = 0; j < 8; j++)
                {
                    CRCLSB = (char)(CRCFull & 0x0001);
                    CRCFull = (ushort)((CRCFull >> 1) & 0x7FFF);

                    if (CRCLSB == 1)
                        CRCFull = (ushort)(CRCFull ^ 0xA001);
                }
            }
            CRC[1] = CRCHigh = (byte)((CRCFull >> 8) & 0xFF);
            CRC[0] = CRCLow = (byte)(CRCFull & 0xFF);
        }
        #endregion

        #region Build Message
        private void BuildMessage(byte address, byte type, ushort start, ushort registers, ref byte[] message)
        {
            //Array to receive CRC bytes:
            byte[] CRC = new byte[2];

            message[0] = address;
            message[1] = type;
            message[2] = (byte)(start >> 8);
            message[3] = (byte)start;
            message[4] = (byte)(registers >> 8);
            message[5] = (byte)registers;

            GetCRC(message, ref CRC);
            message[message.Length - 2] = CRC[0];
            message[message.Length - 1] = CRC[1];
        }
        #endregion

        #region Check Response
        private bool CheckResponse(byte[] response)
        {
            //Perform a basic CRC check:
            byte[] CRC = new byte[2];
            GetCRC(response, ref CRC);
            if (CRC[0] == response[response.Length - 2] && CRC[1] == response[response.Length - 1])
                return true;
            else
                return false;
        }
        #endregion

        #region Get Response
        private void GetResponse(ref byte[] response)
        {
            //There is a bug in .Net 2.0 DataReceived Event that prevents people from using this
            //event as an interrupt to handle data (it doesn't fire all of the time).  Therefore
            //we have to use the ReadByte command for a fixed length as it's been shown to be reliable.
            for (int i = 0; i < response.Length; i++)
            {
                response[i] = (byte)(sp.ReadByte());
            }
        }
        #endregion

        #region GetModbusData 获得接收数据
        public bool GetModbusData(ref byte[] values)
        {
            //Ensure port is open:
            if (sp.IsOpen)
            {
                // 等待线程进入 
                //Monitor.Enter(sp);

                //Clear in/out buffers:
                //sp.DiscardOutBuffer();
                //sp.DiscardInBuffer();

                //Message is 1 addr + 1 type + N Data + 2 CRC

                try
                {
                    //GetResponse(ref readBuffer);
                    //string str = readBuffer.ToString();

                    int count = sp.BytesToRead;
                    if (count > 0)
                    {
                        byte[] readBuffer = new byte[count];

                        GetResponse(ref readBuffer);

                        //   readData = new byte[29];
                        //   Array.Copy(readBuffer, readData, readData.Length);

                        // CRC 验证
                        if (CheckResponse(readBuffer))
                        {
                            //显示输入数据
                            values = readBuffer;

                            modbusStatus = "Write successful";

                            sp.DiscardInBuffer();

                            //values = System.Text.Encoding.ASCII.GetString(readData);
                            return true;
                        }
                        else
                        {
                            modbusStatus = "CRC error";

                            sp.DiscardInBuffer();

                            return false;
                        }
                    }
                    else return false;
                }
                catch (Exception err)
                {
                    modbusStatus = "Error in write event: " + err.Message;

                    sp.DiscardInBuffer();

                    return false;
                }

                //finally
                //{
                    // 通知其它对象
                    //Monitor.Pulse(sp);
                    // 释放对象锁 
                    //Monitor.Exit(sp);
                //}
            }
            else
            {
                modbusStatus = "Serial port not open";
                return false;
            }
        }
        #endregion

        #region SendModbusData 打包发送数据
        public bool SendModbusData(ref byte[] values)
        {
            //Ensure port is open:
            if (sp.IsOpen)
            {
                //Clear in/out buffers:
                sp.DiscardOutBuffer();
                sp.DiscardInBuffer();

                //Function 3 response buffer:
                byte[] response = new byte[values.Length + 2];
                Array.Copy(values, response, values.Length);

                //BuildMessage(address, (byte)3, start, registers, ref message);

                //打包带有 CRC 验证的modbus 数据包:
                byte[] CRC = new byte[2];
                GetCRC(response, ref CRC);
                response[response.Length - 2] = CRC[0];
                response[response.Length - 1] = CRC[1];

                values = response; //返回带有 CRC 验证的modbus 数据包

                //Send modbus message to Serial Port:
                try
                {
                    sp.Write(response, 0, response.Length);
                    //GetResponse(ref response);
                    return true;
                }
                catch (Exception err)
                {
                    modbusStatus = "Error in read event: " + err.Message;
                    return false;
                }
                //Evaluate message:
                //if (CheckResponse(response))
                //{
                //    //Return requested register values:
                //    for (int i = 0; i < (response.Length - 5) / 2; i++)
                //    {
                //        values[i] = response[2 * i + 3];
                //        values[i] <<= 8;
                //        values[i] += response[2 * i + 4];
                //    }
                //    modbusStatus = "Read successful";
                //    return true;
                //}
                //else
                //{
                //    modbusStatus = "CRC error";
                //    return false;
                //}
            }
            else
            {
                modbusStatus = "Serial port not open";
                return false;
            }

        }
        #endregion

    }
}

 

调用的主要代码如下:

88必发官网登入 888必发官网登入 9modbus类的winform调用代码

public partial class FormConfig : Form,IModbusData
{
    //业务处理类
    B_ModbusData ModbusDataBLL = new B_ModbusData();

    modbus mb = new modbus();
    //SerialPort sp = new SerialPort();
    System.Timers.Timer timer = new System.Timers.Timer();

    public FormConfig()
    {
        InitializeComponent();

        timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
    }

    #region Timer Elapsed 事件处理程序
    bool runEnd = true;
    void timer_Elapsed(object sender, ElapsedEventArgs e)
    {
        if (runEnd == true)
        {
            runEnd = false;
            PollFunction();
            runEnd = true;
        }
    }

    //定时器调用方法
    private void PollFunction()
    {
        byte[] values = null;
        try
        {
            mb.GetModbusData(ref values);
            //while (!mb.SendFc3(Convert.ToByte(txtSlaveID.Text), pollStart, pollLength, ref values)) ;
        }
        catch (Exception err)
        {
            DoGUIStatus("Error in modbus read: " + err.Message);
        }

        if (values != null)
        {
            //业务处理
            byte[] sendData = ModbusDataProcess(values);
        }
    }
    #endregion

    #region IModbusData 接口成员处理
    public byte[] ModbusDataProcess(byte[] _data)
    {
       byte[] sendData = ModbusDataBLL.ModbusDataProcess(_data);

       // CRC验证,并打包发送数据。
       mb.SendModbusData(ref sendData);

       return sendData;
    }
    #endregion
}

 

其实,三步就能成功调用:

modbus mb = new modbus();
mb.GetModbusData(ref values); // 从串口设备获得数据。
byte[] sendData = ModbusDataBLL.ModbusDataProcess(values); // 你的业务处理,并产生最终返回数据。
mb.SendModbusData(ref sendData); // CRC验证,并打包发送数据。

主要代码已全部提供,由于工作原因暂不提供完整工具源代码,见谅!

(完)

 

  当控制器设为在Modbus网络上以ASCII模式通信,在消息中的每个8Bit字节都作为两个ASCII字符发送。这种方式的主要优点是字符发送的时间间隔可达到1秒而不产生错误。

88必发官网登入,modbus-RTU和modbus-ASCII(美国标准信息交换代码),两种模式的如下所示。

  代码系统:

1、进制:RTU是八位二进制,ASCII是十六进制。

  十六进制、ASCII字符0…9,A…F

2、字节位数:RTU是11位,ASCII是10位。

  消息中的每个ASCII字符都是一个十六进制字符组成

3、位信息:RTU一个起始位,八个数据位,先传送LSB,一个奇偶校验位,一个停止位,刚好满足RTU的字节位数11位。ASCII一个起始位,七个数据位,先传送LSB,一个奇偶校验位,一个停止位,刚好满足ASCII的字节位数10位。

  每个字节的位构成:

  1个起始位;7个数据位,最小的有效位先发送;1个奇偶校验位,无校验则无;1个停止位(有校验时),2个Bit(无校验时)。

  错误检测域:LRC(纵向冗长检测)

 

  2、RTU模式

  当控制器设为Modbus网络上以RTU(远程终端单元)模式通信,在消息中的每个8Bit字节包含两个4Bit的十六进制字符。这种方式的主要优点是:在同样的波特率下,可比ASCII方式传送更多的数据。

  代码系统:

  8位二进制,十六进制数0…9,A…F

  消息中的每个8位域都是一个两个十六进制字符组成

  每个字节的位:

  1个起始位;8个数据位,最小的有效位先发送;1个奇偶校验位,无校验则无;1个停止位(有校验时),2个Bit(无校验时)

  错误检测域:

  CRC(循环冗长检测)

 

  参考: