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

tutu-hu 2023-04-08 原文

文章目录

一.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::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_rtu::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_rtu::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_rtu::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_rtu.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_rtu modbus("/dev/pts/4", 115200, 'N', 8, 1);  //创建一个modbus_rtu对象
	
    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

2.3 虚拟串口终端

可以看到在构造modbus_rtu对象的时候传入的参数包括"/dev/pts/4"，这表示串口输出终端的文件名，通常是采用USB转串口的方式进行RS232/485通信（采用硬件芯片进行电平转换，如CH340），因此生产的串口通信终端通常为：“/dev/ttyUSB0"等类型。在我的测试中，由于没有USB转串口的工具，因此采用虚拟串口的方式进行测试，这里采用了socat工具。
安装socat工具：
sudo apt install socat
虚拟串口未开启前，查看/dev/pts下设备：

开启虚拟串口：
socat -d -d PTY PTY

开启虚拟串口后，查看/dev/pts下设备：

若是虚拟的串口一直有效，必须使socat一直运行。使用"minicom -D /dev/pts/5 -b 9600”，打开一个串口终端，在使用"minicom -D /dev/pts/6 -b 9600", 打开另一个串口终端。在minicom命令中输入指令，在另一个minicom终端就能接收到了。

三.modbuslib库安装

3.1 modbuslib库介绍

libmodbus，是一个基于C语言实现的Modbus驱动库，作者是Stephane，支持Linux, Mac OS X, FreeBSD, QNX and Win32操作系统，主要应用在PC上，用来开发上位机，也可以对源代码进行交叉编译，以适配更多的平台，比如ARM Linux。源代码开源，遵循 LGPL-2.1 许可。目前最新版本是3.1.6，Github仓库最新提交时间是2021年5月21日。

官方网站：

www.libmodbus.org

开源地址：

github.com/stephane/libmodbus

3.2 modbuslib库安装

1.获取源代码
使用Git工具下载GitHub代码仓库源代码到本地，这样可以获取到最新的libmodbus代码，但是也会有一些Bug。

git clone https://github.com/stephane/libmodbus/

如果下载速度缓慢，可以到我的Gitee仓库下载：

git clone https://gitee.com/whik/libmodbus

或者到官方仓库下载最新稳定发布版本v3.1.6：

libmodbus.org/releases/libmodbus-3.1.6.tar.gz

下载完成之后，解压到本地，Linux系统可以使用tar -zxvf libmodbus-3.0.6.tar.gz命令行解压：
libmodbus支持如下功能：

//1.解压
tar -zxvf libmodbus-3.0.6.tar.gz

//2.配置
./configure

//3.编译
make

//4.安装
make install

3.3 modbuslib库功能

支持Modbus-RTU和Modbus-TCP
支持常用功能码，如01/02/03/04/05/06/07/0F/10/11/16/17
支持线圈类型读写、寄存器读写、离散量读取等
支持广播地址0，从机地址1-247
支持浮点数和整形数据转换，大端小端等多种模式
参数根据Modbus_Application_Protocol_V1_1b.pdf官方标准文档设计，比如最大读写线圈个数，最大读写寄存器个数等。
源代码基于C编写，方便在各平台移植，只有11个文件。

有关基于libmodbus库实现modbus TCP/RTU通信的更多相关文章

ruby-on-rails - Rails 应用程序之间的通信 - 2
我构建了两个需要相互通信和发送文件的Rails应用程序。例如，一个Rails应用程序会发送请求以查看其他应用程序数据库中的表。然后另一个应用程序将呈现该表的json并将其发回。我还希望一个应用程序将存储在其公共(public)目录中的文本文件发送到另一个应用程序的公共(public)目录。我从来没有做过这样的事情，所以我什至不知道从哪里开始。任何帮助，将不胜感激。谢谢! 最佳答案无论Rails是什么，几乎所有Web应用程序都有您的要求，大多数现代Web应用程序都需要相互通信。但是有一个小小的理解需要你坚持下去，网站不应直接访问彼此
ruby - 如何根据特征实现 FactoryGirl 的条件行为 - 2
我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden
叮咚买菜基于 Apache Doris 统一 OLAP 引擎的应用实践 - 2
导读：随着叮咚买菜业务的发展，不同的业务场景对数据分析提出了不同的需求，他们希望引入一款实时OLAP数据库，构建一个灵活的多维实时查询和分析的平台，统一数据的接入和查询方案，解决各业务线对数据高效实时查询和精细化运营的需求。经过调研选型，最终引入ApacheDoris作为最终的OLAP分析引擎，Doris作为核心的OLAP引擎支持复杂地分析操作、提供多维的数据视图，在叮咚买菜数十个业务场景中广泛应用。作者｜叮咚买菜资深数据工程师韩青叮咚买菜创立于2017年5月，是一家专注美好食物的创业公司。叮咚买菜专注吃的事业，为满足更多人“想吃什么”而努力，通过美好食材的供应、美好滋味的开发以及美食品牌的孵
华为OD机试用Python实现 -【明明的随机数】 2023Q1A - 2
华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o
基于C#实现简易绘图工具【100010177】 - 2
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
MIMO-OFDM无线通信技术及MATLAB实现（1）无线信道：传播和衰落 - 2
MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO
kvm虚拟机安装centos7基于ubuntu20.04系统 - 2
需求：要创建虚拟机，就需要给他提供一个虚拟的磁盘，我们就在/opt目录下创建一个10G大小的raw格式的虚拟磁盘CentOS-7-x86_64.raw命令格式：qemu-imgcreate-f磁盘格式磁盘名称磁盘大小qemu-imgcreate-f磁盘格式-o?1.创建磁盘qemu-imgcreate-fraw/opt/CentOS-7-x86_64.raw10G执行效果#ls/opt/CentOS-7-x86_64.raw2.安装虚拟机使用virt-install命令，基于我们提供的系统镜像和虚拟磁盘来创建一个虚拟机，另外在创建虚拟机之前，提前打开vnc客户端，在创建虚拟机的时候，通过vnc
【Java入门】使用Java实现文件夹的遍历 - 2
遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg
ruby - Arrays Sets 和 SortedSets 在 Ruby 中是如何实现的 - 2
通常，数组被实现为内存块，集合被实现为HashMap，有序集合被实现为跳跃列表。在Ruby中也是如此吗？我正在尝试从性能和内存占用方面评估Ruby中不同容器的使用情况最佳答案数组是Ruby核心库的一部分。每个Ruby实现都有自己的数组实现。Ruby语言规范只规定了Ruby数组的行为，并没有规定任何特定的实现策略。它甚至没有指定任何会强制或至少建议特定实现策略的性能约束。然而，大多数Rubyist对数组的性能特征有一些期望，这会迫使不符合它们的实现变得默默无闻，因为实际上没有人会使用它:插入、前置或追加以及删除元素的最坏情况步骤复
ruby - "public/protected/private"方法是如何实现的，我该如何模拟它？ - 2
在ruby中，你可以这样做:classThingpublicdeff1puts"f1"endprivatedeff2puts"f2"endpublicdeff3puts"f3"endprivatedeff4puts"f4"endend现在f1和f3是公共(public)的，f2和f4是私有(private)的。内部发生了什么，允许您调用一个类方法，然后更改方法定义？我怎样才能实现相同的功能(表面上是创建我自己的java之类的注释)例如...classThingfundeff1puts"hey"endnotfundeff2puts"hey"endendfun和notfun将更改以下函数定