modbus介绍、环境搭建测试与qt下串口/Tcp的demo工程测试

一、modbus的介绍

1.简介

  Modbus是一种串行通信协议，于1979年为使用可编程逻辑控制器（PLC）通信而发表。Modbus已经成为工业领域通信协议的业界标准（De facto），并且现在是工业电子设备之间常用的连接方式，Modbus协议目前存在用于串口、以太网以及其他支持互联网协议的网络的版本。

2.具体内容

2.1 modbus通用帧：

ADU： 应用数据单元
PDU： 协议数据单元

2.2 数据校验方式：

2.2.1 CRC-16（循环冗余错误校验）

    1）定义一个16位的无符号变量CR，初值为0XFFFF；
    2）把报文的第一个八位字节和CR的低字节异或，结果送入CR；
    3）若CR最低位为0，将CR右移一位送入 CR，转5，否则跳过；
    4）若CR最低位为1，将CR右移一位送入 CR，然后将CR与0XA001异或的结果送入CR，否则跳过；
    5）移位次数n++，n<8则转3，否则转6；
    6）重复步骤2和5，进行通讯信息帧下一个字节的处理；
    7）CR中生成的即是最终的CRC校验码；
    8）当CRC值放在报文中的时候高低字节必须交换位置；

2.2.2 LRC（纵向冗余错误校验）

    将ASCII码帧的头尾去掉，将串中的每个字节转成16进制相加，将相加后的结果取反加1（补码）

    ASCII 模式采用LRC校验，RTU模式采用16 位CRC校验。

2.3 Modbus主站和从站的区别：

    2.3.1.发出指令不同

      1）Modbus主站：Modbus主站可以主动发出指令。
      2）Modbus从站：Modbus从站不会主动发出指令。

    2.3.2.唯一性不同

      1）Modbus主站：Modbus主站具有唯一性。
      2）Modbus从站：Modbus从站不具有唯一性，可以有多个。

    2.3.3.对接不同

      1）Modbus主站：Modbus主站可以对接多个Modbus从站。
      2）Modbus从站：Modbus从站职能对接一个Modbus主站。

2.4 Modbus 寄存器类型：

线圈状态对应开出（遥控）
离散量输入对应开入（遥信）
输入寄存器对应只读的模拟量（遥测）
保持寄存器对应可读可写的模拟量（遥调）

2.5 Modbus 常用功能码：

    公共功能码和用户定义功能码：

2.6 大小端介绍：

MODBUS 采用大端来表示地址和数据对象。

1）小端：低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
      例如：0x12345678
      存储:
      低地址 --------------------- 高地址
        0x78 0x56 0x34 0x12

2）大端：高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

      例如：0x12345678
      存储:
      低地址 --------------------- 高地址
        0x12 0x34 0x56 0x78

2.7 MODBUS 响应

    一旦服务器处理请求，使用合适的 MODBUS 服务器事务建立 MODBUS 响应。根据处理结果，可以建立两种类型响应：

    1）一个正 MODBUS 响应：
        响应功能码 = 请求功能码

    2） 一个 MODBUS 异常响应：
        用来为客户机提供处理过程中与被发现的差错相关的信息；
        响应功能码 = 请求功能码 + 0x80；
        提供一个异常码来指示差错原因。

2.8 报文类型（RTU、ASCII、TCP）

  Modbus规约上有三种不同的协议，分别是ModbusRTU、ModbusAscII、ModbusTCP，其中RTU和ASCII主要用于串行通信领域，而TCP则常用于以太网通信。

2.8.1 RTU （Remote Terminal Unit 远程终端单元）

    Modbus RTU常采用RS-485做为物理层，一般利用芯片的串口实现数据报文的收发，报文数据采用二进制数据进行通信。当设备使用RTU 模式在Modbus 串行链路通信， 报文中每个8位字节含有两个4 位十六进制字符。这种模式的主要优点是较高的数据密度，在相同的波特率下比ASCII 模式有更高的吞吐率。每个报文必须以连续的字符流传送。设备必须要有RTU协议！这是Modbus协议上规定的，且默认模式必须是RTU，ASCII作为选项。
  报文格式：

  2.8.1.1 单个保持寄存器的读写：

  1）保持寄存器读操作：
  发送：
  假设从机地址为01H，读取的保持寄存器的起始地址为006BH，读取3个寄存器

  响应：
  每个保持寄存器的长度为2个字节。保持寄存器之间，低地址寄存器先传输，高地址寄存器后传输。单个保持寄存器，高字节数据先传输，低字节数据后传输。

  2）保持寄存器写操作：
  发送：
  假设从机地址为01H，保持寄存器的地址为0001H，数据位0003H

  响应：
  如果写入成功，返回发送的指令，即01 06 00 01 00 03 98 0B。

  其他寄存器的读写请参看该博文：  https://blog.csdn.net/qq446252221/article/details/125293329

2.8.2 Ascii

    Modbus ASCII是一种人类可读的，冗长的表示方式，ASCII 可打印字符便于故障检测，而且对于用高级语言（如 Fortan）编程的主计算机及主 PC 很适宜。在 ASCII 模式中，以(:)号(ASCII3AH)表示信息开始，以回撤一换行键(CRLF) (ASCII OD 和 OAH)表示信息结束。对其它的区，允许发送的字符为 16 进制字符 0-9,A-F。网络中设备连续检测并接收一个冒号(:)时，每台设备对地址区解码，找出要寻址的设备。字符之间的最大间隔为 1S,若大于 1S，则接收设备认为出现了一个错误。

    开始字符（:）+从站地址（2个字节）+功能码（2个字节）+数据部分（N个字节）校验、CRC检验（2个字节）+结束字符（CR LF）
、

2.8.3 TCP

Modbus -TCP，是基于在以太网TCP/IP上，将数据以Modbus帧格式进行传输。
modbus TCP 和 modbus RTU基本相同，但是也存在一些区别：
  1）从机地址变得不再重要，多数情况下忽略。从某种意义上说从机地址被IP地址取代。
  2）CRC校验变得不再重要，甚至可以忽略。由于TCP数据包中已经存在校验，为了不重复造轮子，modbus TCP干脆取消了CRC校验。

  TCP 模式去除了附加地址和校验，增加了报文头：

  2.8.3.1 单个保持寄存器的读写：

  1）保持寄存器读操作：
  发送：
  读取服务器1号从站保持寄存器，起始地址为0x6B=107，对应地址为40108，寄存器数量为0x02=2，即读取1号从站保持寄存器，地址从40108-40109，共2个寄存器的数值：

  响应：
  返回服务器1号从站保持寄存器40108-40109，共2个寄存器的数值，返回字节数为4个，分别为02 2B 01 06，40108对应数值为0x022B，40109对应数值为0x0106：

  1）保持寄存器写操作：
  发送：
  预置服务器1号从站单个保持寄存器的值，寄存器地址为0x0087=135，对应地址为40136，写入值为0x039E，即预置1号从站保持寄存器40136值为0x039E：

  响应：
  预置单保持寄存器原报文返回。

  其他寄存器的读写请参看该博文：  https://blog.csdn.net/xiketangAndy/article/details/120204238

二、modbus串口下测试环境搭建

1.ModbusPollSetup64Bit安装：Modbus主设备模拟软件

下载地址:  https://download.csdn.net/download/linyibin_123/87323117

    这款软件主要是用来测试或者是调试从属设备，拥有多个用途，软件为通信设备开发人员进行其通讯协议模拟、测试提供了有利且充足的实验环境，使它为监控、测试及调试通讯设备开辟了一条完美的渠道路径。软件支持多个窗口中同时监控多个子设备，支持多种电气接口和多种规格监视串口数据，接入总网络中即可进行操作管理，并可读写超100个寄存器和2000个输入/线圈，对设备实现集群监控管理，方便用户使用。

    安装与操作关键点：

    1）单击Connection->Connect,弹出注册窗口；打开压缩包解压后的SN文件，复制ModbusPoll的序列号，粘贴到注册窗口的注册栏

    2）选择"Display"->“Communication…”，可打开查看收发报文的窗口。通过这个窗口可以查看当前的原始收发报文，有助于异常的分析。

    3）点击"Function"->“Test Center”，可以打开串口调试功能的窗口。通过这个窗口可以自己编辑发送的报文。

2.ModbusSlaveSetup64Bit安装：Modbus从设备模拟软件

Modbus Slave是Modbus子设备模拟工具，可以仿真32个从设备/地址域。每个接口都提供了对EXCEL报表的OLE自动化支持。帮助Modbus通讯设备开发人员进行Modbus通讯协议的模拟和测试，用于模拟、测试、调试Modbus通讯设备。与Modbus Poll的用户界面相同，支持功能01, 02, 03, 04, 05, 06, 15, 16, 22 和23，监视串口数据。

下载地址:  https://download.csdn.net/download/linyibin_123/87323123

3.虚拟串口vspd安装：

virtual serial port driver简称vspd，这是一款强大的虚拟串口软件。如果你的电脑没有串口，可以使用virtual serial port driver来代替。虚拟端口，创建虚拟串口驱动程序，工作和实际的一样。他们模仿真实的串口波特率设置和提供严格的仿真和全handflow控制支持。此外，你可以很 容易地模拟串行线中断。

下载地址:  https://download.csdn.net/download/linyibin_123/87323130

4.安装包程序测试结果：

虚拟串口软件创建COM2与COM4, Modbus-Poll选择COM2进行连接，Modbus-Slave选择COM4进行连接，如下图修改Modbus-Slave的寄存器值，Modbus-Poll能准确获取到：

三、qt-modbus串口工程

1.界面

2.核心代码

2.1 主机

modbuspoll.h

#ifndef MODBUSPOLL_H
#define MODBUSPOLL_H

#include <QObject>
#include <QThread>
#include "modbus.h"
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QDebug>
#include <QTimer>
#include <QStringList>
#include <QThread>

class modbusPoll : public QObject
{
    Q_OBJECT
public:
    explicit modbusPoll(QObject *parent = nullptr);
    ~modbusPoll();

    //单例
    static modbusPoll& getInstance();

    //接收从机消息回调函数
    static void modbusAddItemBack(modbus_t *pModbus, uint8_t isRequest, uint8_t Slave,
                             uint8_t func, uint16_t addr, uint16_t nb, uint16_t expectedCRC,
                             uint16_t actualCRC);

     void setReadAddrAndNum(int nReadStartAddr, int nReadNum);
     void setSlaveId(int nSlaveId);
 signals:
    //返回从机信息信号
    void sig_returnSlaveInfo(QString info);

 public slots:
    void Init();
    void UnInit();

    void ConnectPoll(QString sPortName, int nBaudRate);
    void DisconnectPoll();

    //定时器工作
    void TimerWork();

 private:
    //读取保存寄存器数据
    void ReadHoldRegisterData();


 private:
    bool m_bWork; //连接成功与否标志
    int m_nSlaveId; //从机ID
    QThread* m_pThread; //线程处理
    modbus_t* m_pModbusRtu; //modbus rtu对象
    QTimer* m_pTimer; //数据更新定时器
    int m_nReadNum;
    int m_nReadStartAddr;
};

#endif // MODBUSPOLL_H

modbuspoll.cpp

#include "modbuspoll.h"
#include "commondef.h"

uint16_t g_modbus_hold_reg[100] = {0};

modbusPoll::modbusPoll(QObject *parent)
{
    Q_UNUSED(parent)
    m_nReadNum = 3;
    m_nReadStartAddr = 0;
    m_nSlaveId = 1;
    m_bWork = false;

    m_pThread = new QThread();
    this->moveToThread(m_pThread);

    connect(m_pThread, SIGNAL(started()),
            this, SLOT(Init()));
    connect(m_pThread, SIGNAL(finished()),
            this, SLOT(UnInit()));
    m_pThread->start();
}

modbusPoll::~modbusPoll()
{
    m_pThread->quit();
    m_pThread->wait();
}

modbusPoll &modbusPoll::getInstance()
{
    static modbusPoll s_obj;
    return s_obj;
}

void modbusPoll::modbusAddItemBack(modbus_t *pModbus, uint8_t isRequest, uint8_t Slave, uint8_t func, uint16_t addr, uint16_t nb, uint16_t expectedCRC, uint16_t actualCRC)
{
    Q_UNUSED(pModbus);
    MY_DEBUG << "Recv Slave Answer:"  << "isRequest" << isRequest << "slave" << Slave << "func" << func \
             << "addr" << addr << "nb" << nb << "expectedCRC" << expectedCRC  << "actualCRC" << actualCRC;
}

void modbusPoll::ReadHoldRegisterData()
{
    QString sErr;
    modbus_set_slave(m_pModbusRtu, m_nSlaveId);

    //读寄存器设置：寄存器地址、数量、数据缓冲
    int nRet = modbus_read_registers(m_pModbusRtu, m_nReadStartAddr, m_nReadNum, g_modbus_hold_reg);
    if(nRet != m_nReadNum)
    {
        if(nRet < 0 )
        {
            if(
#ifdef WIN32
                errno == WSAETIMEDOUT ||
#endif
                errno == EIO
              )
            {
                sErr += tr( "I/O error" );
                sErr += ": ";
                sErr += tr( "did not receive any data from slave." );
            }
            else
            {
                sErr += tr( "Protocol error" );
                sErr += ": ";
                sErr += tr( "Slave threw exception '" );
                sErr += modbus_strerror( errno );
                sErr += tr( "' or function not implemented." );
            }
        }
        else
        {
            sErr += tr( "Protocol error" );
            sErr += ": ";
            sErr += tr( "Number of registers returned does not "
                    "match number of registers requested!" );
        }
    }

    if(sErr.size() > 0)
    {
        emit sig_returnSlaveInfo("Read Failed:" + sErr);
    }
    else
    {
        QString sInfo = QString("Slave ID: %1 modbus read : %2  %3  %4  %5  %6 \r\n ")\
                .arg(QString::number(m_nSlaveId)).arg(g_modbus_hold_reg[0])\
             .arg(g_modbus_hold_reg[1]).arg(g_modbus_hold_reg[2])\
             .arg(g_modbus_hold_reg[3]).arg(g_modbus_hold_reg[4]);

        emit sig_returnSlaveInfo(sInfo);
    }
}

void modbusPoll::Init()
{
    m_pTimer = new QTimer();
    m_pTimer->stop();
    connect(m_pTimer, &QTimer::timeout,
            this, &modbusPoll::TimerWork);
}

void modbusPoll::UnInit()
{
    m_pTimer->stop();
    delete m_pTimer;
    if(m_bWork)
    {
        //关闭设备
        modbus_close(m_pModbusRtu);
        modbus_free(m_pModbusRtu);
    }
}

void modbusPoll::ConnectPoll(QString sPortName, int nBaudRate)
{
    MY_DEBUG << "ConnectPoll:" << QThread::currentThreadId();
    //设置串口信息:端口，波特率，校验位，数据位，停止位
    m_pModbusRtu = modbus_new_rtu(sPortName.toLatin1().data(), nBaudRate, 'N', 8, 1);

    //设置从机地址
    modbus_set_slave(m_pModbusRtu, m_nSlaveId);

    //设置串口模式(可选)
    //modbus_rtu_set_serial_mode(m_pModbusRtu, MODBUS_RTU_RS485);

    //设置RTS(可选)
    //modbus_rtu_set_rts(m_pModbusRtu, MODBUS_RTU_RTS_UP);

    //打开串口,建立连接
    if(modbus_connect(m_pModbusRtu) == -1)
    {
        MY_DEBUG << "Connect Failed:" << modbus_strerror(errno);
        modbus_free(m_pModbusRtu);
        return;
    }

    //设置应答延时(可选)
    //modbus_set_response_timeout(m_pModbusRtu, 0, 1000000);

    //设置回调函数，获取主从交互信息
    modbus_register_monitor_add_item_fnc(m_pModbusRtu, modbusPoll::modbusAddItemBack);

    m_pTimer->start(1000);
    m_bWork = true;
}

void modbusPoll::DisconnectPoll()
{
    MY_DEBUG << "DisconnectPoll:" << QThread::currentThreadId();
    m_pTimer->stop();

    //关闭设备
    modbus_close(m_pModbusRtu);
    modbus_free(m_pModbusRtu);
    m_bWork = false;
}

void modbusPoll::setReadAddrAndNum(int nReadStartAddr, int nReadNum)
{
    m_nReadNum = nReadNum;
    m_nReadStartAddr = nReadStartAddr;
}

void modbusPoll::setSlaveId(int nSlaveId)
{
    m_nSlaveId = nSlaveId;
}

void modbusPoll::TimerWork()
{
    ReadHoldRegisterData();
}

2.2 从机

modbusslave.h

#ifndef MODBUSSLAVE_H
#define MODBUSSLAVE_H

#include <QObject>
#include <QThread>
#include "modbus.h"
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QDebug>
#include <QTimer>
#include <QStringList>
#include <QThread>

class modbusSlave : public QObject
{
    Q_OBJECT
public:
    explicit modbusSlave(QObject *parent = nullptr);
    ~modbusSlave();

    //单例
    static modbusSlave& getInstance();

    //接收主机消息回调函数
    static void modbusRawDataBack(modbus_t * pModbus, uint8_t * pData,
                                     uint8_t dataLen, uint8_t addNewline, uint8_t direction);
    void setSlaveId(int nSlaveId);
    void setRegVal(int nVal0, int nVal1, int nVal2, int nVal3, int nVal4);

 public slots:
    void Init();
    void UnInit();

    void ConnectSlave(QString sPortName, int nBaudRate);
    void DisconnectSlave();

    //定时器工作
    void TimerWork();

 private:
    bool m_bWork; //连接成功与否标志
    int m_nSlaveId; //从机ID
    QThread* m_pThread; //线程处理
    modbus_t* m_pModbusRtu; //modbus rtu对象
    modbus_mapping_t* m_pModbusMapping = nullptr; //寄存器
    QTimer* m_pTimer; //数据更新定时器
    int m_nReadNum;
    int m_nReadStartAddr;

};

#endif // MODBUSSLAVE_H

modbusslave.cpp

#include "modbusslave.h"
#include "commondef.h"

modbusSlave::modbusSlave(QObject *parent)
{
    Q_UNUSED(parent)
    m_bWork = false;
    m_pThread = new QThread();
    this->moveToThread(m_pThread);

    connect(m_pThread, SIGNAL(started()),
            this, SLOT(Init()));
    connect(m_pThread, SIGNAL(finished()),
            this, SLOT(UnInit()));

    m_pThread->start();
}

modbusSlave::~modbusSlave()
{
    m_pThread->quit();
    m_pThread->wait();
}

modbusSlave &modbusSlave::getInstance()
{
    static modbusSlave s_obj;
    return s_obj;
}

void modbusSlave::modbusRawDataBack(modbus_t *pModbus, uint8_t *pData, uint8_t dataLen, uint8_t addNewline, uint8_t direction)
{
    Q_UNUSED(pModbus);
    Q_UNUSED(addNewline);

    QString sDump;
    for(int i = 0; i < dataLen; ++i)
    {
        sDump += QString::asprintf( "%.2x ", pData[i]);
    }
    if(direction == 0)
    {
        MY_DEBUG << "Slave receive Poll Success, Data:" << sDump;
    }
}

void modbusSlave::setSlaveId(int nSlaveId)
{
    m_nSlaveId = nSlaveId;
}

void modbusSlave::setRegVal(int nVal0, int nVal1, int nVal2, int nVal3, int nVal4)
{
    //MY_DEBUG << "setRegVal";
    if(m_bWork)
    {
        if(m_pModbusMapping && m_pModbusMapping->tab_registers)
        {
            m_pModbusMapping->tab_registers[0] = nVal0;
            m_pModbusMapping->tab_registers[1] = nVal1;
            m_pModbusMapping->tab_registers[2] = nVal2;
            m_pModbusMapping->tab_registers[3] = nVal3;
            m_pModbusMapping->tab_registers[4] = nVal4;
        }
    }
}

void modbusSlave::Init()
{
    m_pTimer = new QTimer();
    m_pTimer->stop();
    connect(m_pTimer, &QTimer::timeout,
            this, &modbusSlave::TimerWork);
}

void modbusSlave::UnInit()
{
    m_pTimer->stop();
    delete m_pTimer;
    if(m_bWork)
    {
        modbus_close(m_pModbusRtu);
        modbus_free(m_pModbusRtu);
    }
}

void modbusSlave::ConnectSlave(QString sPortName, int nBaudRate)
{
    MY_DEBUG << "ConnectSlave:" << QThread::currentThreadId();
    MY_DEBUG << "ConnectSlave sPortName:" << sPortName << ", nBaudRate:" << nBaudRate << ", m_nSlaveId:" << m_nSlaveId;

    //打开端口: 端口，波特率，校验位，数据位，停止位
    m_pModbusRtu = modbus_new_rtu(sPortName.toLatin1().data(), nBaudRate, 'N', 8, 1);

    //设置从机地址
    modbus_set_slave(m_pModbusRtu, m_nSlaveId);

    //建立连接
    if(modbus_connect(m_pModbusRtu) == -1)
    {
        MY_DEBUG << "Connect Failed:" << modbus_strerror(errno);
        modbus_free(m_pModbusRtu);
        return;
    }

    //寄存器map初始化
    m_pModbusMapping = modbus_mapping_new(MODBUS_MAX_READ_BITS, 0, MODBUS_MAX_READ_REGISTERS, 0);
    if(nullptr == m_pModbusMapping)
    {
        MY_DEBUG << "Connect Failed:" << (stderr, "Failed to allocate the mapping: %s\n",
                modbus_strerror(errno));
        modbus_free(m_pModbusRtu);
        return;
    }

    //设置寄存器的值
    m_pModbusMapping->tab_registers[0] = 1;
    m_pModbusMapping->tab_registers[1] = 2;
    m_pModbusMapping->tab_registers[2] = 3;
    m_pModbusMapping->tab_registers[3] = 4;
    m_pModbusMapping->tab_registers[4] = 5;

    //设置回调函数，获取主从交互信息
    modbus_register_monitor_raw_data_fnc(m_pModbusRtu, modbusSlave::modbusRawDataBack);

    m_pTimer->start(300);
    m_bWork = true;
}

void modbusSlave::DisconnectSlave()
{
    MY_DEBUG << "DisconnectSlave";
    m_pTimer->stop();
    modbus_close(m_pModbusRtu);
    modbus_free(m_pModbusRtu);
    m_bWork = false;
}

void modbusSlave::TimerWork()
{
    int rc = 0;
    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH] = {0};

    rc = modbus_receive(m_pModbusRtu, query);
    if(rc > 0)
    {
        modbus_reply(m_pModbusRtu, query, rc, m_pModbusMapping);
    }
}

2.3 调用

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "modbuspoll.h"
#include "modbusslave.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

    //更新串口号
    void SearchSerial();
signals:
    void sig_connectPoll(QString sPortName, int nBaudRate);
    void sig_disconnectPoll();
    void sig_connectSlave(QString sPortName, int nBaudRate);
    void sig_disconnectSlave();

private slots:
    void on_pushButton_Poll_clicked();
    void on_pushButton_ClearPollInfo_clicked();
    void on_pushButton_Slave_clicked();
    void on_showSlaveInfo(QString sInfo);

    //定时器工作
    void TimerWork();
private:
    Ui::MainWindow *ui;
    QTimer* m_pTimer;
    QStringList m_oldPortStringList;
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "commondef.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    SearchSerial();

    connect(this, &MainWindow::sig_connectPoll,
            &modbusPoll::getInstance(), &modbusPoll::ConnectPoll);
    connect(this, &MainWindow::sig_disconnectPoll,
            &modbusPoll::getInstance(), &modbusPoll::DisconnectPoll);

    connect(&modbusPoll::getInstance(), &modbusPoll::sig_returnSlaveInfo,
            this, &MainWindow::on_showSlaveInfo);

    connect(this, &MainWindow::sig_connectSlave,
            &modbusSlave::getInstance(), &modbusSlave::ConnectSlave);
    connect(this, &MainWindow::sig_disconnectSlave,
            &modbusSlave::getInstance(), &modbusSlave::DisconnectSlave);

    m_pTimer = new QTimer();
    m_pTimer->stop();
    connect(m_pTimer, &QTimer::timeout,
            this, &MainWindow::TimerWork);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::SearchSerial()
{
    QStringList newPortStringList;
    const auto infos = QSerialPortInfo::availablePorts();
    for (const QSerialPortInfo &info : infos)
    {
        newPortStringList += info.portName();
    }

    if(newPortStringList.size() != m_oldPortStringList.size())
    {
        m_oldPortStringList = newPortStringList;
        ui->comboBox_PollSerial->clear();
        ui->comboBox_PollSerial->addItems(m_oldPortStringList);
        ui->comboBox_SlaveSerial->clear();
        ui->comboBox_SlaveSerial->addItems(m_oldPortStringList);
    }
}

void MainWindow::on_pushButton_Poll_clicked()
{
    if(ui->pushButton_Poll->text() == "Open Poll")
    {
        if(ui->comboBox_PollSerial->currentText().isEmpty() == true)
        {
            ui->textEdit_Poll->setText(ui->textEdit_Poll->toPlainText().append("Not Set Serial\r\n"));

            //textedit 滚动条自动往下滚动
            ui->textEdit_Poll->moveCursor(QTextCursor::End);
            return;
        }
        QString sSerialName = ui->comboBox_PollSerial->currentText();
        int nBaudrate = ui->comboBox_PollBaudrate->currentText().toInt();
        int nReadStartAddr = ui->lineEdit_PollStartAddr->text().toInt();
        int nReadNum = ui->lineEdit_PollRegNum->text().toInt();
        int nSlaveId = ui->lineEdit_ID->text().toInt();

        modbusPoll::getInstance().setReadAddrAndNum(nReadStartAddr, nReadNum);
        modbusPoll::getInstance().setSlaveId(nSlaveId);

        emit sig_connectPoll(sSerialName, nBaudrate);
        ui->pushButton_Poll->setText("Close Poll");

        ui->comboBox_PollSerial->setDisabled(true);
        ui->comboBox_PollBaudrate->setDisabled(true);
        ui->lineEdit_PollRegNum->setDisabled(true);
        ui->lineEdit_PollStartAddr->setDisabled(true);
        ui->lineEdit_ID->setDisabled(true);
    }
    else
    {
        emit sig_disconnectPoll();
        ui->pushButton_Poll->setText("Open Poll");

        ui->comboBox_PollSerial->setDisabled(false);
        ui->comboBox_PollBaudrate->setDisabled(false);
        ui->lineEdit_PollRegNum->setDisabled(false);
        ui->lineEdit_PollStartAddr->setDisabled(false);
        ui->lineEdit_ID->setDisabled(false);
    }
}

void MainWindow::on_pushButton_ClearPollInfo_clicked()
{
    ui->textEdit_Poll->clear();
}

void MainWindow::on_pushButton_Slave_clicked()
{
    if(ui->pushButton_Slave->text() == "Open Slave")
    {
        MY_DEBUG << "Open Slave 000";
        QString sSerialName = ui->comboBox_SlaveSerial->currentText();
        int nBaudrate = ui->comboBox_SlaveBaudrate->currentText().toInt();
        int nSlaveId = ui->lineEdit_SlaveId->text().toInt();

        modbusSlave::getInstance().setSlaveId(nSlaveId);

        emit sig_connectSlave(sSerialName, nBaudrate);
        MY_DEBUG << "Open Slave 111";

        ui->pushButton_Slave->setText("Close Slave");
        ui->comboBox_SlaveBaudrate->setDisabled(true);
        ui->comboBox_SlaveSerial->setDisabled(true);

        m_pTimer->start(1000);
    }
    else
    {
        emit sig_disconnectSlave();
        m_pTimer->stop();

        ui->pushButton_Slave->setText("Open Slave");

        ui->comboBox_SlaveSerial->setDisabled(false);
        ui->comboBox_SlaveBaudrate->setDisabled(false);
    }
}

void MainWindow::on_showSlaveInfo(QString sInfo)
{
    ui->textEdit_Poll->setText(ui->textEdit_Poll->toPlainText().append(sInfo + "\r\n"));
    //textedit 滚动条自动往下滚动
    ui->textEdit_Poll->moveCursor(QTextCursor::End);
}

void MainWindow::TimerWork()
{
    int nRegVal0 = ui->lineEdit_Reg0->text().toInt();
    int nRegVal1 = ui->lineEdit_Reg1->text().toInt();
    int nRegVal2 = ui->lineEdit_Reg2->text().toInt();
    int nRegVal3 = ui->lineEdit_Reg3->text().toInt();
    int nRegVal4 = ui->lineEdit_Reg4->text().toInt();

    modbusSlave::getInstance().setRegVal(nRegVal0, nRegVal1, nRegVal2, nRegVal3, nRegVal4);
}

3.demo工程下载地址

下载地址:  https://download.csdn.net/download/linyibin_123/87326662

4.测试结果：

三、qt-modbus Tcp

参考该篇：https://www.jianshu.com/p/0ed380fa39eb 修改以上工程即可文章来源地址https://www.toymoban.com/news/detail-668504.html

到了这里，关于modbus介绍、环境搭建测试与qt下串口/Tcp的demo工程测试的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！