Modbus基础知识

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Modbus基础知识相关的知识,希望对你有一定的参考价值。

参考技术A RS485是一个接口,是ModBus协议支持的多种接口之一,如RS-232是其支持的另一种接口。RS485一般是2线制的,即由485A、485B两条接线进行数据传输。由两条线间的电压差不同分别表示0和1(正2-6伏特表示逻辑0,负2-6伏特表示逻辑1)。

Modbus是一个协议。是由Modicon(现为施耐德电气公司的一个品牌)在1979年发明的,是全球第一个真正用于工业现场的总线协议。它可应用于各种数据采集和过程监控。

所谓的协议是什么?就是不同实体间,为了相互通讯而进行的一种约定。比如点头表示同意,摇头表示不同意就可以看成一种通讯协议。没有约定好的协议,便无法交流。

任何人都可以使用国际通用的摩尔斯电码救难信号S.O.S(...---...)进行求救,因为全球都接受这个约定。在夜晚可以用手电筒三短三长三短的发光进行求救。

报文(message)是网络中交换与传输的数据单元,即数据交换过程中一次性要发送的数据块。也称为数据帧, 一个报文就是一帧数据,一个数据帧就一个报文。由协议约定,对报文中的数据进行解释,赋予报文以意义,使得通讯各方都能够理解报文,从而能够交流。
先来简单分析一条MODBUS-RTU报文,例如:01 06 00 01 00 17 98 04
01 06 0001 0017 9804
从机地址 功能号 数据地址 数据 CRC校验

这一串数据的意思是:把数据 0x0017(十进制23) 写入 1号从机地址 0x0001数据地址。

数据在传输过程中可能受到干扰或者丢失,为了保证数据的正确性,人们通过CRC校验,来判断报文是否正确,从而决定是接受还是放弃报文。
上面报文最后面的9804就是校验码。他是前面的有效数据 01 06 00 01 00 17通过一系列算法计算出来的。报文接收方通过同样的算法多数据部分进行计算,得到一个CRC校验码。如果接收方计算出的CRC和发送方的CRC不同,则认为报文在发生过程中发生了错误,就拒绝接受报文。

基于libmodbus库实现modbus TCP/RTU通信

文章目录

一.modbus TCP

  Modbus由MODICON公司于1979年开发,是一种工业现场总线协议标准。1996年施耐德公司推出基于以太网TCP/IP的Modbus协议:ModbusTCP。
  Modbus协议是一项应用层报文传输协议,包括ASCII、RTU、TCP三种报文类型。
  标准的Modbus协议物理层接口有RS232、RS422、RS485和以太网(modbus TCP)接口,采用master/slave方式通信。
  ModbusTCP数据帧:
ModbusTCP的数据帧可分为两部分:MBAP+PDU。

1.1 报文头MBAP

MBAP为报文头,长度为7字节,组成如下:

内容解释
事务处理标识可以理解为报文的序列号,一般每次通信之后就要加1以区别不同的通信数据报文
协议标识符00 00表示ModbusTCP协议
长度表示接下来的数据长度,单位为字节
单元标识符可以理解为设备地址

比如一帧modbus TCP报文如下:00 01 00 00 00 06 01 06 08 00 12 34
  其中前7个字节(标红的部分)为报文头MBAP。

1.2 帧结构PDU

  PDU由功能码+数据组成。功能码为1字节,数据长度不定,由具体功能决定。
功能码:
  Modbus的操作对象有四种:线圈离散输入保持寄存器输入寄存器

PDU详细结构:
1. 0x01:读线圈状态
在从站中读1~2000个连续线圈状态,ON=1,OFF=0
请求:MBAP 功能码 起始地址H 起始地址L 数量H 数量L(共12字节)
响应:MBAP 功能码 数据长度 数据(一个地址的数据为1位)
如:在从站0x01中,读取开始地址为0x0002的线圈数据,读0x0008位
00 01 00 00 00 06 01 01 00 02 00 08
回:数据长度为0x01个字节,数据为0x01,第一个线圈为ON,其余为OFF
00 01 00 00 00 04 01 01 01 01

2. 0x02:读离散量输入
从一个从站中读1~2000个连续的离散量输入状态
请求:MBAP 功能码 起始地址H 起始地址L 数量H 数量L(共12字节)
响应:MBAP 功能码 数据长度 数据(长度:9+ceil(数量/8))
如:从地址0x0000开始读0x0012个离散量输入
00 01 00 00 00 06 01 02 00 00 00 12
回:数据长度为0x03个字节,数据为0x01 04 00,表示第一个离散量输入和第11个离散量输入为ON,其余为OFF
00 01 00 00 00 06 01 02 03 01 04 00

3. 0x03:读保持寄存器
从远程设备中读保持寄存器连续块的内容
请求:MBAP 功能码 起始地址H 起始地址L 寄存器数量H 寄存器数量L(共12字节)
响应:MBAP 功能码 数据长度 寄存器数据(长度:9+寄存器数量×2)
如:起始地址是0x0000,寄存器数量是 0x0003
00 01 00 00 00 06 01 03 00 00 00 03
回:数据长度为0x06,第一个寄存器的数据为0x21,其余为0x00
00 01 00 00 00 09 01 03 06 00 21 00 00 00 00

4. 0x04:读输入寄存器
从一个远程设备中读1~2000个连续输入寄存器
请求:MBAP 功能码 起始地址H 起始地址L 寄存器数量H 寄存器数量L(共12字节)
响应:MBAP 功能码 数据长度 寄存器数据(长度:9+寄存器数量×2)
如:读起始地址为0x0002,数量为0x0005的寄存器数据
00 01 00 00 00 06 01 04 00 02 00 05
回:数据长度为0x0A,第一个寄存器的数据为0x0c,其余为0x00
00 01 00 00 00 0D 01 04 0A 00 0C 00 00 00 00 00 00 00 00

5. 0x05:写单个线圈
将从站中的一个输出写成ON或OFF,0xFF00请求输出为ON,0x000请求输出为OFF
请求:MBAP 功能码 输出地址H 输出地址L 输出值H 输出值L(共12字节)
响应:MBAP 功能码 输出地址H 输出地址L 输出值H 输出值L(共12字节)
如:将地址为0x0003的线圈设为ON
00 01 00 00 00 06 01 05 00 03 FF 00
回:写入成功
00 01 00 00 00 06 01 05 00 03 FF 00

6. 0x06:写单个保持寄存器
在一个远程设备中写一个保持寄存器
请求:MBAP 功能码 寄存器地址H 寄存器地址L 寄存器值H 寄存器值L(共12字节)
响应:MBAP 功能码 寄存器地址H 寄存器地址L 寄存器值H 寄存器值L(共12字节)
如:向地址是0x0000的寄存器写入数据0x000A
00 01 00 00 00 06 01 06 00 00 00 0A
回:写入成功
00 01 00 00 00 06 01 06 00 00 00 0A

7. 0x0F(15):写多个线圈
将一个从站中的一个线圈序列的每个线圈都强制为ON或OFF,数据域中置1的位请求相应输出位ON,置0的位请求响应输出为OFF
请求:MBAP 功能码 起始地址H 起始地址L 输出数量H 输出数量L 字节长度 输出值H 输出值L
响应:MBAP 功能码 起始地址H 起始地址L 输出数量H 输出数量L

8. 0x10(16):写多个保持寄存器
在一个远程设备中写连续寄存器块(1~123个寄存器)
请求:MBAP 功能码 起始地址H 起始地址L 寄存器数量H 寄存器数量L 字节长度 寄存器值(13+寄存器数量×2)
响应:MBAP 功能码 起始地址H 起始地址L 寄存器数量H 寄存器数量L(共12字节)
如:向起始地址为0x0000,数量为0x0001的寄存器写入数据,数据长度为0x02,数据为0x000F
00 01 00 00 00 09 01 10 00 00 00 01 02 00 0F
回:写入成功
00 01 00 00 00 06 01 10 00 00 00 01

1.3 库函数调用

下面的函数分别实现了上述的八种功能,并给出了发送的数据格式:

modbus_t *mb;                //modbus_t
uint8_t read_buffer[1024];   //定义read_buffer
uint8_t write_buffer[1024];  //定义write_buffer
uint16_t read_buffer_16[1024];  //定义read_buffer_16
uint16_t write_buffer_16[1024];  //定义write_buffer_16

modbus_read_bits(mb, 0x6789, 5, read_buffer);              //0x01:读线圈状态: 00 01 00 00 00 06 01        01 67 89 00 05 
modbus_read_input_bits(mb, 0x6789, 5, read_buffer);        //0x02:读离散量输入: 00 01 00 00 00 06 01      02 67 89 00 05 
modbus_read_registers(mb, 0x6789, 5, read_buffer_16);      //0x03:读保持寄存器: 00 01 00 00 00 06 01      03 67 89 00 05 
modbus_read_input_registers(mb, 0x6789, 5, read_buffer_16);//0x04:读输入寄存器: 00 01 00 00 00 06 01      04 67 89 00 05
modbus_write_bit(mb, 0x6789, 0x1234);                      //0x05:写单个线圈: 00 01 00 00 00 06 01        05 67 89 FF 00 
modbus_write_register(mb, 0x6789, 0x1234);                 //0x06:写单个保持寄存器: 00 01 00 00 00 06 01    06 67 89 12 34
modbus_write_bits(mb, 0x6789, 5, write_buffer);            //0x0F(15):写多个线圈: 00 01 00 00 00 08 01     0F 67 89 00 05 01 1F
modbus_write_registers(mb, 0x6789, 5,  write_buffer_16);   //0x10(16):写多个保持寄存器: 00 01 00 00 00 11 01   10 67 89 00 05 0A 00 00 00 00 00 00 00 00 00 05 

1.4 写成基类封装基础功能

  为了方便其他客户端的调用,此处将上述的功能实现封装成一个基类,在基类中实现上述8中读写操作,当客户端需要调用Modbus功能时只需继承上述基类,并拓展相关功能函数即可,简单易用。下面给出了modbus_tcp.hpp和modbus_tcp.cpp程序。
modbus_tcp.hpp

/**
 * @brief  modbus tcp base class
 */
#ifndef __MODBUS_TCP_HPP__
#define __MODBUS_TCP_HPP__

#include <chrono>
#include <string>

#include "modbus/modbus.h"

namespace modbus 
    /**
     * modbus_tcp base class
     */
    class modbus_tcp
    
    public:
        /**
         * @brief       Constructor
         * @throw       @ref std::runtime_error() on gripper modbus communication failure
         *
         * @param[in]   ip      The modbus ip of gripper
         * @param[in]   port    The modbus tcp port of gripper
         */
        modbus_tcp(const std::string& ip, const short port);
        ~modbus_tcp();

        //! libmodbus's error return value
        static constexpr int        MODBUS_ERR = -1;

        //0x01:读线圈状态: 00 01 00 00 00 06 01        01 67 89 00 05 
        int read_coil_status(int addr, int nb, uint8_t *dest);
        //0x02:读离散量输入: 00 01 00 00 00 06 01      02 67 89 00 05 
        int read_input_status(int addr, int nb, uint8_t *dest);
        //0x03:读保持寄存器: 00 01 00 00 00 06 01      03 67 89 00 05 
        int read_holding_register(int addr, int nb, uint16_t *dest);
        //0x04:读输入寄存器: 00 01 00 00 00 06 01      04 67 89 00 05
        int read_input_register(int addr, int nb, uint16_t *dest);
        //0x05:写单个线圈: 00 01 00 00 00 06 01        05 67 89 FF 00 
        int write_single_coil(int coil_addr, int status);
        //0x06:写单个保持寄存器: 00 01 00 00 00 06 01    06 67 89 12 34
        int write_single_register(int reg_addr, const uint16_t value);
        //0x0F(15):写多个线圈: 00 01 00 00 00 08 01     0F 67 89 00 05 01 1F
        int write_multiple_coil(int addr, int nb, const uint8_t *data);
        //0x10(16):写多个保持寄存器: 00 01 00 00 00 11 01   10 67 89 00 05 0A 00 00 00 00 00 00 00 00 00 05 
        int write_multiple_registers(int addr, int nb, const uint16_t *data);

    private:
        modbus_t* ctx_;
    ;
  // namespace modbus
#endif

modbus_tcp.cpp

#include <stdexcept>
#include <iostream>

#include "modbus_tcp.hpp"

namespace modbus 
    // modbus_tcp构造函数
    modbus_tcp::modbus_tcp(const std::string& ip, const short port)
        : ctx_(modbus_new_tcp(ip.c_str(), port))
    
        if (MODBUS_ERR == modbus_set_slave(ctx_, 1)                            //
            || MODBUS_ERR == modbus_set_response_timeout(ctx_, 0, 1000 * 100)  //!< [100ms],注意,此处的响应延时需要根据实际情况设定!!!
            || MODBUS_ERR == modbus_connect(ctx_))                             //
        
            modbus_free(ctx_);
            throw std::runtime_error("modbus_tcp init or connect failed");
        ;
        std::cout<<"modbus_tcp构造函数调用"<<std::endl;
    

    // modbus_tcp析构函数
    modbus_tcp::~modbus_tcp()
    
        modbus_close(ctx_);
        modbus_free(ctx_);
        std::cout<<"modbus_tcp析构函数调用"<<std::endl;
    

    //0x01:读线圈状态: 00 01 00 00 00 06 01        01 67 89 00 05 
    int modbus_tcp::read_coil_status(int addr, int nb, uint8_t *dest)
    
        return modbus_read_bits(ctx_, addr, nb, dest);       // return the number of read bits if successful. Otherwise it shall return -1 and set errno.
    
    //0x02:读离散量输入: 00 01 00 00 00 06 01      02 67 89 00 05 
    int modbus_tcp::read_input_status(int addr, int nb, uint8_t *dest)
    
        return modbus_read_input_bits(ctx_, addr, nb, dest);  // return the number of read input status if successful. Otherwise it shall return -1 and set errno.
    
    //0x03:读保持寄存器: 00 01 00 00 00 06 01      03 67 89 00 05 
    int modbus_tcp::read_holding_register(int addr, int nb, uint16_t *dest)
    
        return modbus_read_registers(ctx_, addr, nb, dest);   //成功时返回读取输入位的数目即nb,失败时返回-1.
    
    //0x04:读输入寄存器: 00 01 00 00 00 06 01      04 67 89 00 05
    int modbus_tcp::read_input_register(int addr, int nb, uint16_t *dest)
    
        return modbus_read_input_registers(ctx_, addr, nb, dest);  //return the number of read input registers if successful. Otherwise it shall return -1 and set errno.
    
    //0x05:写单个线圈: 00 01 00 00 00 06 01        05 67 89 FF 00 
    int modbus_tcp::write_single_coil(int coil_addr, int status)
    
        return modbus_write_bit(ctx_, coil_addr, status);  //成功时,返回1;失败时,返回-1。
    
    //0x06:写单个保持寄存器: 00 01 00 00 00 06 01    06 67 89 12 34
    int modbus_tcp::write_single_register(int reg_addr, const uint16_t value)
    
        return modbus_write_register(ctx_, reg_addr, value); //成功时返回1,失败时返回-1.
    
    //0x0F(15):写多个线圈: 00 01 00 00 00 08 01     0F 67 89 00 05 01 1F
    int modbus_tcp::write_multiple_coil(int addr, int nb, const uint8_t *data)
    
        return modbus_write_bits(ctx_, addr, nb, data); //return the number of written bits if successful. Otherwise it shall return -1 and set errno.
    
    //0x10(16):写多个保持寄存器: 00 01 00 00 00 11 01   10 67 89 00 05 0A 00 00 00 00 00 00 00 00 00 05 
    int modbus_tcp::write_multiple_registers(int addr, int nb, const uint16_t *data)
    
        return modbus_write_registers(ctx_, addr, nb, data);  //成功时返回写入寄存器个数即nb,失败时返回-1.
    
  // namespace modbus

main.cpp

#include "modbus_tcp.hpp"

int main(int argc, char *argv[])

    uint8_t read_buffer[1024];
    uint8_t write_buffer[1024];
    uint16_t read_buffer_16[3];
    uint16_t write_buffer_16[1024];
    modbus::modbus_tcp modbus("192.168.2.128",8080);  //创建一个modbus_tcp对象

    modbus.read_coil_status(0x6789, 5, read_buffer);//00 01 00 00 00 06 01   01 67 89 00 05 
    modbus.read_input_status(0x6789, 5, read_buffer);//00 01 00 00 00 06 01    01 67 89 00 05 
    modbus.read_holding_register(0x6789, 5, read_buffer_16);//00 01 00 00 00 06 01   01 67 89 00 05 
    modbus.read_input_register(0x6789, 5, read_buffer_16);//00 01 00 00 00 06 01    04 67 89 00 05 
    modbus.write_single_coil(0x6789, 0x1234);
    modbus.write_single_register(0x6789, 0x1234);//0x06:写单个保持寄存器: 00 01 00 00 00 06 01    06 67 89 12 34
    modbus.write_multiple_coil(0x6789, 5, write_buffer);//0x0F(15):写多个线圈: 00 01 00 00 00 08 01     0F 67 89 00 05 01 1F
    modbus.write_multiple_registers(0x6789, 5,  write_buffer_16);    //0x10(16):写多个保持寄存器: 00 01 00 00 00 11 01   10 67 89 00 05 0A 00 00 00 00 00 00 00 00 00 05 

编译 & 执行:

g++ main.cpp modbus_tcp.cpp -lmodbus -std=c++17
./a.out

输出结果:

二.modbus RTU

  在一般工业场景使用modbus RTU的场景还是更多一些,modbus RTU基于串行协议进行手法数据,包括RS232/485等工业总线协议。与modbus TCP不同的是RTU没有报文头MBAP字段,但是在尾部增加了两个CRC检验字节(CRC16),因为网络协议中自带校验,所以在TCP协议中不需要使用CRC校验码。RTU和TCP的总体使用方法基本一致,只是在创建modbus对象时有所不同,TCP需要传入网络socket信息;而RTU需要传入串口相关信息。

2.1 使用示例

  当需要向某个从机寄存器写入某个值时,如向01地址的设备,0x0105保持寄存器写入1个数据:0x0190为例,那么需要构建这样一个数据帧:

主机发送:01 06 01 05 01 90 99 CB
01表示从机地址,06功能码表示写单个保持寄存器,0105表示寄存器地址,0190表示写入寄存器的数值,99 CB为CRC校验值。
如果从机正确的收到了数据,会回复一个数据帧:

从机回复:01 06 01 05 01 90 99 CB
所以作为主机,写数据的流程是:

  • 构建一个Modbus-RTU数据帧
  • 等待从机响应的数据
  • 如果响应数据正确,说明写入成功,否则写入失败。

2.2 写成基类封装基础功能

  为了方便其他客户端的调用,此处将上述的功能实现封装成一个基类,在基类中实现上述8中读写操作,当客户端需要调用Modbus功能时只需继承上述基类,并拓展相关功能函数即可,简单易用。下面给出了modbus_rtu.hpp和modbus_rtu.cpp程序。
modbus_rtu.hpp

/**
 * @brief  modbus rtu base class
 */
#ifndef __MODBUS_RTU_HPP__
#define __MODBUS_RTU_HPP__

#include <chrono>
#include <string>

#include "modbus/modbus.h"

namespace modbus 
    /**
     * modbus_rtu base class
     */
    class modbus_rtu
    
    public:
        /**
         * @brief       Constructor
         * @throw       @ref std::runtime_error() on gripper modbus communication failure
         *
         * @param[in]   ip      The modbus ip of gripper
         * @param[in]   port    The modbus rtu port of gripper
         */
        modbus_rtu( const std::string& device,   //串口设备,类似于:"/dev/ttyUSB0"
                    int baud,                    //波特率:9600 115200等等
                    char parity,                 //奇偶校验位:通常设置为'N'
                    int data_bit,                //数据位:通常设置为8
                    int stop_bit                 //停止位:通常设置为1
                  );
        ~modbus_rtu();

        //! libmodbus's error return value
        static constexpr int        MODBUS_ERR = -1;

        //0x01:读线圈状态: 00 01 00 00 00 06 01        01 67 89 00 05 
        int read_coil_status(int addr, int nb, uint8_t *dest);
        //0x02:读离散量输入: 00 01 00 00 00 06 01      02 67 89 00 05 
        int read_input_status(int addr, int nb, uint8_t *dest);
        //0x03:读保持寄存器: 00 01 00 00 00 06 01      03 67 89 00 05 
        int read_holding_register(int addr, int nb, uint16_t *dest);
        //0x04:读输入寄存器: 00 01 00 00 00 06 01      04 67 89 00 05
        int read_input_register(int addr, int nb, uint16_t *dest);
        //0x05:写单个线圈: 00 01 00 00 00 06 01        05 67 89 FF 00 
        int write_single_coil(int coil_addr, int status);
        //0x06:写单个保持寄存器: 00 01 00 00 00 06 01    06 67 89 12 34
        int write_single_register(int reg_addr, const uint16_t value);
        //0x0F(15):写多个线圈: 00 01 00 00 00 08 01     0F 67 89 00 05 01 1F
        int write_multiple_coil(int addr, int nb, const uint8_t *data);
        //0x10(16):写多个保持寄存器: 00 01 00 00 00 11 01   10 67 89 00 05 0A 00 00 00 00 00 00 00 00 00 05 
        int write_multiple_registers(int addr, int nb, const uint16_t *data);

    private:
        modbus_t* ctx_;
    ;
  // namespace modbus
#endif

modbus_rtu.cpp

#include <stdexcept>
#include <iostream>

#include "modbus_rtu.hpp"

namespace modbus 
    // modbus_rtu构造函数
    modbus_rtu::modbus_rtu( const std::string& device,   //串口设备,类似于:"/dev/ttyUSB0"
                    int baud,                    //波特率:9600 115200等等
                    char parity,                 //奇偶校验位:通常设置为'N'
                    int data_bit,                //数据位:通常设置为8
                    int stop_bit)                 //停止位:通常设置为1
        : ctx_(modbus_new_rtu(device.c_str(), baud,parity,data_bit,stop_bit))
    
        if (MODBUS_ERR == modbus_set_slave(ctx_, 1)                            //
            || MODBUS_ERR == modbus_set_response_timeout(ctx_, 0, 1000 * 100)  //!< [100ms],注意,此处的响应延时需要根据实际情况设定!!!
            || MODBUS_ERR == modbus_connect(ctx_))                             //
        
            modbus_free(ctx_);
            throw std::runtime_error("modbus_rtu init or connect failed");
        ;
        std::cout<<"modbus_rtu构造函数调用"<<std::endl;
    

    // modbus_rtu析构函数
    modbus_rtu::~modbus_rtu()
    
        modbus_close(ctx_);
        modbus_free(ctx_);
        std::cout<<"modbus_rtu析构函数调用"<<std::endl;
    

    //0x01:读线圈状态: 00 01 00 00 00 06 01        01 67 89 00 05 
    int modbus_rtu::read_coil_status(int addr, int nb, uint8_t *dest)
    
        return modbus_read_bits(ctx_, addr, nb, dest);       // return the number of read bits if successful. Otherwise it shall return -1 and set errno.
    
    //0x02:读离散量输入: 00 01 00 00 00 06 01      02 67 89 00 05 
    int modbus_rtu::read_input_status(int addr, int nb, uint8_t *dest)
    
        return modbus_read_input_bits(ctx_, addr, nb, dest);  // return the number of read input status if successful. Otherwise it shall return -1 and set errno.
    
    //0x03:读保持寄存器: 00 01 00 00 00 06 01      03 67 89 00 05 
    int modbus_rtu::read_holding_register(int addr, int nb, uint16_t *dest)
    
        return modbus_read_registers(ctx_, addr, nb, dest);   //成功时返回读取输入位的数目即nb,失败时返回-1.
    
    //0x04:读输入寄存器: 00 01 00 00 00 06 01      04 67 89 00 05
    int modbus_rtu::read_input_register(int addr, int nb, uint16_t *dest)
    
        return modbus_read_input_registers(ctx_, addr, nb, dest);  //return the number of read input registers if successful. Otherwise it shall return -1 and set errno.
    
    //0x05:写单个线圈: 00 01 00 00 00 06 01        05 67 89 FF 00 
    int modbus_rtu::以上是关于Modbus基础知识的主要内容,如果未能解决你的问题,请参考以下文章

基于libmodbus库实现modbus TCP/RTU通信

MODBUS RTU通讯协议简介

详解Modbus通信协议---清晰易懂

详解Modbus通信协议---清晰易懂

modbus协议rtu是啥

485通讯协议和modbus协议区别