基于libmodbus库实现modbus TCP/RTU通信
Posted tutu-hu
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了基于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::嵌入式Libmodbus下载和编译详解
00. 目录
01. Modbus开源库概述
Modbus作为一种常见的工业通信协议，几乎被所有的设备在支持，如果能在软件或者设备中增强Modbus的通信功能，无疑对于市场应用来说是个很吸引人的。对于Modbus开发来说，网络上存在很多的开源库。其中libmodbus和freemobus非常常见，值得开发者认真分析和学习。
02. Libmodbus下载
libmodbus库适用于Linux，Mac OS X，FreeBSD，QNX和Win32的Modbus库。
libmodbus是一个免费软件库，可根据Modbus协议发送/接收数据。该库用C编写，并支持RTU（串行）和TCP（以太网）通信。
libmodbus的许可证为LGPL v2.1。
源码下载：https://github.com/stephane/libmodbus
官网下载：https://libmodbus.org/download/
03. Libmodbus源码结构
3.1 源码下载完毕之后，解压，简单查看源代码目录的构成
doc目录：libmodbus库的各API接口说明文档。
m4目录：存放GNU m4文件，在这里对理解代码没有意义。
src目录：全部libmodbus源文件
tests目录：包含自带的测试代码
其它文件对我们理解源代码关系不大，可以暂时忽略。
3.2 src目录内容
win32：定了在Windows下使用Visual Studio编译时的项目文件和工程文件，以及相关配置选项等。
Makefile.am：Makefile.am是Linux下AutoTool编译时读取相关编译参数的配置文件，用于生成Makefile文件，因用于Linux下开发，在这里暂时忽略。
源码文件描述：
mudbus.c 核心文件，试了Modbus协议层，定了通用的Modbus消息发送和接收函数、各功能码对应的函数。
modbus.h libmodbus对外接口API头文件
modbus-data.c 数据处理的通用函数，包括大小端相关的字节、位交换等函数。
modbus-private.h libmodbus内部使用的数据结构和函数定义
modbus-rtu.c 通信层协议，RTU模式相关的函数定义，主要是串口的设置、连接和消息的发送、接收等等
modbus-rtu.h RTU模式对外提供的API定义
modbus-rtu-private.h RTU模式的私有定义
modbus-tcp.c 通信层实现，TCP模式下相关函数的定义、主要包括TCP/IP网络的设置、连接、消息的发送和接收等等。
modbus-tcp.h 定义TCP模式度外提供的各API定义
modbus-tcp-private.h TCP模式的私有定义
modbus-version.h.in 版本定义文件
04. Visual Studio2019编译Libmodbus源码
4.1 双击configure.js，生成config.h和modbus-version.h文件
4.2 使用Visual Studio2019打开工程文件
4.3 项目文件升级对话框，选择确定
4.4 编译工程文件，发生编译错误。
原因是新生成的modbus-version.h文件没有正确加载，先移除该文件，然后再添加该文件
按下Alt + F7弹出项目属性设置对话框，依次找到如下选项
再次编译，显示编程成功，生成对应的动态库。
05. 附录
Libmodbus官方网站：https://libmodbus.org/
Freemodbus官方网站：https://www.embedded-experts.at/en/freemodbus/about/
以上是关于基于libmodbus库实现modbus TCP/RTU通信的主要内容，如果未能解决你的问题，请参考以下文章