【Qt】modbus之串口模式写操作

太过爱你忘了你带给我的痛 2023-01-22 13:58 553阅读 0赞

## 00. 目录 ##

### 文章目录 ###

*   *  00. 目录
     *  01. 概述
     *  02. 开发环境
     *  03. 写Coils程序示例
     *  04. 写HoldingRegisters程序示例
     *  05. 综合示例
     *  06. 程序下载
     *  07. 附录

## 01. 概述 ##

Qt中几个常用的串口modbus类

QModbusRtuSerialSlave       //modbus串口通信方式下的服务器类
    QModbusRtuSerialMaster      //串口通信方式下的客户端类
    QModbusServer               // QModbusServer类接收和处理modbus的请求。
    QModbusDataUnit             //存储接收和发送数据的类，数据类型为1bit和16bit
    QModbusReply                //客户端访问服务器后得到的回复（如客户端读服务器数据时包含数据信息）

## 02. 开发环境 ##

**Windows系统**：Windows10

**Qt版本**：Qt5.15或者Qt6

Pro配置文件如下

QT       += core gui serialbus serialport
    
    greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
    
    CONFIG += c++11
    
    # You can make your code fail to compile if it uses deprecated APIs.
    # In order to do so, uncomment the following line.
    #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
    
    SOURCES += \
        main.cpp \
        widget.cpp
    
    HEADERS += \
        widget.h
    
    # Default rules for deployment.
    qnx: target.path = /tmp/$${TARGET}/bin
    else: unix:!android: target.path = /opt/$${TARGET}/bin
    !isEmpty(target.path): INSTALLS += target

## 03. 写Coils程序示例 ##

**widget.h文件**

#ifndef WIDGET_H
    #define WIDGET_H
    
    #include <QWidget>
    
    //前向声明
    class QModbusClient;
    class QModbusReply;
    
    
    class Widget : public QWidget
    { 
        Q_OBJECT
    
    public:
        Widget(QWidget *parent = nullptr);
        ~Widget();
    
    
    private:
        QModbusClient *modbusDevice = nullptr;
    
    
    private slots:
        void onReadReady();
    };
    #endif // WIDGET_H

**widget.cpp文件**

#include "widget.h"
    #include <QModbusRtuSerialMaster>
    #include <QModbusDataUnit>
    #include <QModbusReply>
    #include <QVariant>
    #include <QSerialPort>
    #include <QDebug>
    
    //构造函数
    Widget::Widget(QWidget *parent)
        : QWidget(parent)
    { 
        //1. 创建QModbusDevice对象
        modbusDevice = new QModbusRtuSerialMaster;
    
        //2. 如果处于连接状态，则断开连接
        if (modbusDevice->state() == QModbusDevice::ConnectedState)
        { 
            //断开连接设备
            modbusDevice->disconnectDevice();
        }
    
        //3. 设置串口相关参数
        //设置串口信息
        modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter, QVariant("COM3"));
        //设置校验 无校验
        modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter, QSerialPort::NoParity);
        //设置波特率
        modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter, QSerialPort::Baud19200);
        //设置停止位
        modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, QSerialPort::OneStop);
        //设置数据位
        modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter, QSerialPort::Data8);
    
        //4. 设置其他信息
        //设置超时时间
        modbusDevice->setTimeout(1000); //1秒
        //设置失败重试次数
        modbusDevice->setNumberOfRetries(3);
    
        //5. 连接到设备
        bool ok = modbusDevice->connectDevice();
        if (!ok)
        { 
            qDebug() << "连接到串口失败： " << modbusDevice->errorString();
        }
        else
        { 
            qDebug() << "连接到串口成功";
        }
    
        //6. 发送写请求
        //从地址0开始写10个保持寄存器的值
        //QModbusDataUnit writeData(QModbusDataUnit::HoldingRegisters, 0, 10);
    
        //从地址0开始写10个线圈的值
        QModbusDataUnit writeData(QModbusDataUnit::Coils, 0, 10);
        for (int i = 0; i < writeData.valueCount(); i++)
        { 
            writeData.setValue(i, (i * i) % 2);
        }
    
        qDebug() << "发送的数据为： " << writeData.values();
    
        QModbusReply* reply = modbusDevice->sendWriteRequest(writeData, 1);
        if (reply)
        { 
            if (!reply->isFinished())
            { 
                //接收响应信息
                connect(reply, &QModbusReply::finished, this, [this, reply](){ 
                    if (reply->error() == QModbusDevice::ProtocolError)
                    { 
                        //接收到的响应信息是协议错误
                        qDebug() << "写入数据错误：" << reply->errorString();
                    }
                    else if (reply->error() != QModbusDevice::NoError)
                    { 
                        //接收到的响应消息是其它错误
                        qDebug() << "写入数据错误： " << reply->errorString();
                    }
                    else
                    { 
                        //接收到的消息没有错误 一般没有必要解析响应消息
                        const QModbusDataUnit data = reply->result();
    
                        qDebug() << "消息数据个数：" << data.valueCount() << " :" << data.values();
    
                    }
    
                    reply->deleteLater();
                });
            }
            else
            { 
                //发送没有响应数据
                //broadcast replies return immediately
                reply->deleteLater();
            }
        }
        else
        { 
            qDebug() << "sendWriteRequest Error: " << reply->errorString();
        }
    
    
        //7. 发送读取数据请求
        //从地址0开始读取10个保持寄存器的值
        //QModbusDataUnit data(QModbusDataUnit::HoldingRegisters, 0, 10);
        //从地址0开始读取10个离散输入量的值
        //QModbusDataUnit data(QModbusDataUnit::DiscreteInputs, 0, 10);
    
        //QModbusDataUnit::Coils 从地址0开始读取10个线圈值
        QModbusDataUnit data(QModbusDataUnit::Coils, 0, 10);
    
        //QModbusDataUnit::InputRegisters 从地址0开始读取10个输入寄存器的值
        //QModbusDataUnit data(QModbusDataUnit::InputRegisters, 0, 10);
    
        reply = modbusDevice->sendReadRequest(data, 0x1);
        if (nullptr == reply)
        { 
            qDebug() << "发送请求数据失败: " << modbusDevice->errorString();
        }
        else
        { 
            if (!reply->isFinished())
            { 
                connect(reply, &QModbusReply::finished, this, &Widget::onReadReady);
            }
            else
            { 
                //broadcast replies return immediately
                delete reply;
            }
        }
    
    }
    
    
    //析构函数
    Widget::~Widget()
    { 
        if (modbusDevice)
        { 
            modbusDevice->disconnectDevice();
        }
    
        delete modbusDevice;
    }
    
    //准备读取数据的槽函数
    void Widget::onReadReady()
    { 
        auto reply = qobject_cast<QModbusReply*>(sender());
        if (nullptr == reply)
        { 
            return;
        }
    
        //判断是否出错
        if (reply->error() == QModbusDevice::NoError)
        { 
            //读取响应数据
            const QModbusDataUnit responseData = reply->result();
    
            qDebug() << "读到数据为：" << responseData.values();
    
        }
        else if (reply->error() == QModbusDevice::ProtocolError)
        { 
            qDebug() << "Read response Protocol error: " << reply->errorString();
        }
        else
        { 
            qDebug() << "Read response Error: " << reply->errorString();
        }
    
    
        //删除reply
        reply->deleteLater();
    }

**执行结果**

20:32:27: Starting D:\ProgramData\Qt\build-Test-Desktop_Qt_5_15_2_MinGW_32_bit-Debug\debug\Test.exe ...
    连接到串口成功
    发送的数据为：  QVector(0, 1, 0, 1, 0, 1, 0, 1, 0, 1)
    消息数据个数： 10  : QVector(0, 1, 0, 1, 0, 1, 0, 1, 0, 1)
    读到数据为： QVector(0, 1, 0, 1, 0, 1, 0, 1, 0, 1)
    20:34:02: D:\ProgramData\Qt\build-Test-Desktop_Qt_5_15_2_MinGW_32_bit-Debug\debug\Test.exe exited with code 0

## 04. 写HoldingRegisters程序示例 ##

**widget.h文件**

**widget.cpp文件**

#include "widget.h"
    #include <QModbusRtuSerialMaster>
    #include <QModbusDataUnit>
    #include <QModbusReply>
    #include <QVariant>
    #include <QSerialPort>
    #include <QDebug>
    
    //构造函数
    Widget::Widget(QWidget *parent)
        : QWidget(parent)
    { 
        //1. 创建QModbusDevice对象
        modbusDevice = new QModbusRtuSerialMaster;
    
        //2. 如果处于连接状态，则断开连接
        if (modbusDevice->state() == QModbusDevice::ConnectedState)
        { 
            //断开连接设备
            modbusDevice->disconnectDevice();
        }
    
        //3. 设置串口相关参数
        //设置串口信息
        modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter, QVariant("COM3"));
        //设置校验 无校验
        modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter, QSerialPort::NoParity);
        //设置波特率
        modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter, QSerialPort::Baud19200);
        //设置停止位
        modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, QSerialPort::OneStop);
        //设置数据位
        modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter, QSerialPort::Data8);
    
        //4. 设置其他信息
        //设置超时时间
        modbusDevice->setTimeout(1000); //1秒
        //设置失败重试次数
        modbusDevice->setNumberOfRetries(3);
    
        //5. 连接到设备
        bool ok = modbusDevice->connectDevice();
        if (!ok)
        { 
            qDebug() << "连接到串口失败： " << modbusDevice->errorString();
        }
        else
        { 
            qDebug() << "连接到串口成功";
        }
    
        //6. 发送写请求
        //从地址0开始写10个保持寄存器的值
        QModbusDataUnit writeData(QModbusDataUnit::HoldingRegisters, 0, 10);
        for (int i = 0; i < writeData.valueCount(); i++)
        { 
            writeData.setValue(i, i * i);
        }
    
        qDebug() << "发送的数据为： " << writeData.values();
    
        QModbusReply* reply = modbusDevice->sendWriteRequest(writeData, 1);
        if (reply)
        { 
            if (!reply->isFinished())
            { 
                //接收响应信息
                connect(reply, &QModbusReply::finished, this, [this, reply](){ 
                    if (reply->error() == QModbusDevice::ProtocolError)
                    { 
                        //接收到的响应信息是协议错误
                        qDebug() << "写入数据错误：" << reply->errorString();
                    }
                    else if (reply->error() != QModbusDevice::NoError)
                    { 
                        //接收到的响应消息是其它错误
                        qDebug() << "写入数据错误： " << reply->errorString();
                    }
                    else
                    { 
                        //接收到的消息没有错误 一般没有必要解析响应消息
                        const QModbusDataUnit data = reply->result();
    
                        qDebug() << "消息数据个数：" << data.valueCount() << " :" << data.values();
    
                    }
    
                    reply->deleteLater();
                });
            }
            else
            { 
                //发送没有响应数据
                //broadcast replies return immediately
                reply->deleteLater();
            }
        }
        else
        { 
            qDebug() << "sendWriteRequest Error: " << reply->errorString();
        }
    
    
        //7. 发送读取数据请求
        //从地址0开始读取10个保持寄存器的值
        QModbusDataUnit data(QModbusDataUnit::HoldingRegisters, 0, 10);
        //从地址0开始读取10个离散输入量的值
        //QModbusDataUnit data(QModbusDataUnit::DiscreteInputs, 0, 10);
    
        //QModbusDataUnit::Coils 从地址0开始读取10个线圈值
        //QModbusDataUnit data(QModbusDataUnit::Coils, 0, 10);
    
        //QModbusDataUnit::InputRegisters 从地址0开始读取10个输入寄存器的值
        //QModbusDataUnit data(QModbusDataUnit::InputRegisters, 0, 10);
    
        reply = modbusDevice->sendReadRequest(data, 0x1);
        if (nullptr == reply)
        { 
            qDebug() << "发送请求数据失败: " << modbusDevice->errorString();
        }
        else
        { 
            if (!reply->isFinished())
            { 
                connect(reply, &QModbusReply::finished, this, &Widget::onReadReady);
            }
            else
            { 
                //broadcast replies return immediately
                delete reply;
            }
        }
    
    }
    
    
    //析构函数
    Widget::~Widget()
    { 
        if (modbusDevice)
        { 
            modbusDevice->disconnectDevice();
        }
    
        delete modbusDevice;
    }
    
    //准备读取数据的槽函数
    void Widget::onReadReady()
    { 
        auto reply = qobject_cast<QModbusReply*>(sender());
        if (nullptr == reply)
        { 
            return;
        }
    
        //判断是否出错
        if (reply->error() == QModbusDevice::NoError)
        { 
            //读取响应数据
            const QModbusDataUnit responseData = reply->result();
    
            qDebug() << "读到数据为：" << responseData.values();
    
        }
        else if (reply->error() == QModbusDevice::ProtocolError)
        { 
            qDebug() << "Read response Protocol error: " << reply->errorString();
        }
        else
        { 
            qDebug() << "Read response Error: " << reply->errorString();
        }
    
    
        //删除reply
        reply->deleteLater();
    }

**执行结果**

20:23:23: Starting D:\ProgramData\Qt\build-Test-Desktop_Qt_5_15_2_MinGW_32_bit-Debug\debug\Test.exe ...
    连接到串口成功
    发送的数据为：  QVector(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
    消息数据个数： 10  : QVector(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
    读到数据为： QVector(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
    20:23:29: D:\ProgramData\Qt\build-Test-Desktop_Qt_5_15_2_MinGW_32_bit-Debug\debug\Test.exe exited with code 0

## 05. 综合示例 ##

程序界面

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J2Oiv0Co-1621479015968)(assets/image-20210520104421393.png)\]

**settingdialog.h文件**

#ifndef SETTINGDIALOG_H
    #define SETTINGDIALOG_H
    
    #include <QDialog>
    #include <QtSerialPort>
    
    namespace Ui { 
    class SettingDialog;
    }
    
    //串口设置相关类
    class SettingDialog : public QDialog
    { 
        Q_OBJECT
    
    public:
        struct Settings
        { 
            //串口名
            QString serialName = "COM3";
            //校验位
            int parity = QSerialPort::NoParity;
            //波特率
            int baud = QSerialPort::Baud19200;
            //数据位
            int dataBits = QSerialPort::Data8;
            //停止位
            int stopBits = QSerialPort::OneStop;
    
            //响应时间
            int responseTime = 1000;
            //重试次数
            int numberOfRetries = 3;
        };
    
        explicit SettingDialog(QWidget *parent = nullptr);
        ~SettingDialog();
    
        //返回参数设置信息
        Settings  settings() const;
    
    private slots:
        void on_btnApply_clicked();
    
    private:
        Ui::SettingDialog *ui;
        Settings m_settings;
    };
    
    #endif // SETTINGDIALOG_H

**settingdialog.cpp文件**

#include "settingdialog.h"
    #include "ui_settingdialog.h"
    
    //构造函数
    SettingDialog::SettingDialog(QWidget *parent) :
        QDialog(parent),
        ui(new Ui::SettingDialog)
    { 
        ui->setupUi(this);
    
        //设置默认参数信息
        ui->serialNameLineEdit->setText(tr("COM3"));
        ui->parityComboBox->setCurrentIndex(0);
    
        ui->baudComboBox->setCurrentText(QString::number(m_settings.baud));
        ui->dataBitComboBox->setCurrentText(QString::number(m_settings.dataBits));
        ui->stopBitComboBox->setCurrentText(QString::number(m_settings.stopBits));
    
        ui->spinBoxTimeOut->setValue(m_settings.responseTime);
        ui->spinBoxRetry->setValue(m_settings.numberOfRetries);
    
    }
    
    //析构函数
    SettingDialog::~SettingDialog()
    { 
        delete ui;
    }
    
    //返回参数信息
    SettingDialog::Settings SettingDialog::settings() const
    { 
        return m_settings;
    }
    
    //引用按钮槽函数
    void SettingDialog::on_btnApply_clicked()
    { 
        m_settings.serialName = ui->serialNameLineEdit->text();
        m_settings.parity = ui->parityComboBox->currentText().toInt();
        m_settings.baud = ui->baudComboBox->currentText().toInt();
        m_settings.dataBits = ui->dataBitComboBox->currentText().toInt();
        m_settings.stopBits = ui->stopBitComboBox->currentText().toInt();
    
        m_settings.responseTime = ui->spinBoxTimeOut->value();
        m_settings.numberOfRetries = ui->spinBoxRetry->value();
    
        //隐藏参数设置对话框
        hide();
    }

**mainwindow.h文件**

#ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    #include <QModbusDataUnit>
    #include "writeregistermodel.h"
    
    QT_BEGIN_NAMESPACE
    
    namespace Ui
    { 
    class MainWindow;
    }
    
    class SettingDialog;
    class QModbusClient;
    class QModbusReply;
    
    
    QT_END_NAMESPACE
    
    class MainWindow : public QMainWindow
    { 
        Q_OBJECT
    
    public:
        MainWindow(QWidget *parent = nullptr);
        ~MainWindow();
    
        //信号与槽进行关联
        void initActions();
    
        //读请求数据包封装
        QModbusDataUnit readRequest() const;
    
        //写请求数据包封装
        QModbusDataUnit writeRequest() const;
    
    private slots:
        void onConnectButtonClicked();
    
        void onConnectTypeChanged(int);
    
        void onModbusStateChanged(int state);
    
        void onReadButtonClicked();
        void onReadReady();
    
    
        void onWriteButtonClicked();
    
        void onReadWriteButtonClicked();
    
        void onWriteTableChanged(int);
    
    private:
        Ui::MainWindow *ui = nullptr;
    
        SettingDialog *m_settingDialog = nullptr;
    
        QModbusClient *modbusDevice = nullptr;
    
        QModbusReply *reply = nullptr;
    
        WriteRegisterModel *writeModel = nullptr;
    
    };
    #endif // MAINWINDOW_H

**mainwindow.cpp文件**

#include "mainwindow.h"
    #include "ui_mainwindow.h"
    #include <QMessageBox>
    #include "settingdialog.h"
    #include <QModbusRtuSerialMaster>
    #include <QModbusReply>
    #include <QStandardItemModel>
    #include <QModbusDataUnit>
    
    //连接类型枚举变量
    enum ModbusConnection { 
        Serial,
        Tcp
    };
    
    
    MainWindow::MainWindow(QWidget *parent)
        : QMainWindow(parent)
        , ui(new Ui::MainWindow)
    { 
        ui->setupUi(this);
    
        //创建对象
        m_settingDialog = new SettingDialog(this);
    
        //初始化信号与槽
        initActions();
    
        //创建写模型
        writeModel = new WriteRegisterModel(this);
        writeModel->setStartAddress(ui->sbWriteStartAddr->value());
        writeModel->setNumberOfValues(ui->cbWriteCount->currentText());
    
        //MVC
        ui->treeViewWrite->setModel(writeModel);
        //隐藏第二列
        ui->treeViewWrite->hideColumn(2);
        connect(writeModel, &WriteRegisterModel::updateViewport,
                ui->treeViewWrite->viewport(), QOverload<>::of(&QWidget::update));
    
    
        //默认为串口连接方式
        ui->cbConnType->setCurrentIndex(0);
        onConnectTypeChanged(0);
    
        auto model = new QStandardItemModel(10, 1, this);
        for (int i = 0; i < 10; i++)
        { 
            model->setItem(i, new QStandardItem(QStringLiteral("%1").arg(i + 1)));
        }
    
        ui->cbWriteCount->setModel(model);
        ui->cbWriteCount->setCurrentText("10");
    
        connect(ui->cbWriteCount, &QComboBox::currentTextChanged,
                writeModel, &WriteRegisterModel::setNumberOfValues);
    
        auto valueChanged = QOverload<int>::of(&QSpinBox::valueChanged);
        connect(ui->sbWriteStartAddr, valueChanged, writeModel, &WriteRegisterModel::setStartAddress);
    
    
        connect(ui->sbWriteStartAddr, valueChanged, this, [this, model](int i){ 
            int lastIndex = 0;
            const int curIndex = ui->cbWriteCount->currentIndex();
            for (int j = 0; j < 10; j++)
            { 
                //设置使能
                if (j < (10 - i))
                { 
                    lastIndex = j;
                    model->item(j)->setEnabled(true);
                }
                else
                { 
                    //设置禁用
                    model->item(j)->setEnabled(false);
                }
            }
    
            if (curIndex > lastIndex)
            { 
                ui->cbWriteCount->setCurrentIndex(lastIndex);
            }
    
        });
    }
    
    
    //析构函数
    MainWindow::~MainWindow()
    { 
        if (modbusDevice)
        { 
            modbusDevice->disconnectDevice();
            delete modbusDevice;
        }
        delete ui;
    }
    
    
    
    //信号与槽进行关联s
    void MainWindow::initActions()
    { 
        //使能部分功能
        ui->actionConnect->setEnabled(true);
        ui->actionDisconnect->setEnabled(false);
        ui->actionQuit->setEnabled(true);
        ui->actionOption->setEnabled(true);
    
        //禁用读写操作
        ui->btnRead->setEnabled(false);
        ui->btnWrite->setEnabled(false);
        ui->btnReadWrite->setEnabled(false);
    
    
        //信号与槽关联
        connect(ui->btnConnect, &QPushButton::clicked,
                this, &MainWindow::onConnectButtonClicked);
    
        connect(ui->actionConnect, &QAction::triggered,
                this, &MainWindow::onConnectButtonClicked);
    
        connect(ui->actionDisconnect, &QAction::triggered,
                this, &MainWindow::onConnectButtonClicked);
    
        //读操作按钮槽函数关联
        connect(ui->btnRead, &QPushButton::clicked,
                this, &MainWindow::onReadButtonClicked);
    
        connect(ui->btnWrite, &QPushButton::clicked,
                this, &MainWindow::onWriteButtonClicked);
    
        connect(ui->btnReadWrite, &QPushButton::clicked,
                this, &MainWindow::onReadWriteButtonClicked);
    
        connect(ui->cbRegisterType, QOverload<int>::of(&QComboBox::currentIndexChanged),
                this, &MainWindow::onWriteTableChanged);
    
        connect(ui->cbConnType, QOverload<int>::of(&QComboBox::currentIndexChanged),
                this, &MainWindow::onConnectTypeChanged);
    
        //退出菜单
        connect(ui->actionQuit, &QAction::triggered, this, &MainWindow::close);
        //显示参数设置对话框
        connect(ui->actionOption, &QAction::triggered, m_settingDialog, &QDialog::show);
    
        connect(ui->actionAbout, &QAction::triggered, [=]() { 
            QMessageBox::aboutQt(this, "About Qt");
        });
    }
    
    //构建请求报文
    QModbusDataUnit MainWindow::readRequest() const
    { 
        //const auto type = static_cast<QModbusDataUnit::RegisterType>(ui->cbRegisterType->currentData().toInt());
    
       QModbusDataUnit::RegisterType type = QModbusDataUnit::Invalid;
    
       qDebug() << ui->cbRegisterType->currentText();
    
       if (ui->cbRegisterType->currentText() == QString("线圈"))
       { 
            type = QModbusDataUnit::Coils;
       }
       else if (ui->cbRegisterType->currentText() == QString("离散输入"))
       { 
           type = QModbusDataUnit::DiscreteInputs;
       }
       else if (ui->cbRegisterType->currentText() == QString("输入寄存器"))
       { 
           type = QModbusDataUnit::InputRegisters;
       }
       else if (ui->cbRegisterType->currentText() == QString("保持寄存器"))
       { 
           type = QModbusDataUnit::HoldingRegisters;
       }
    
        qDebug() << "请求报文类型: " << type;
    
        //获取
        int startAddress = ui->spReadStartAddr->value();
        Q_ASSERT(startAddress >= 0 && startAddress < 10);
    
        quint16 numberOfEntries = ui->cbReadCount->currentText().toUShort();
    
        return QModbusDataUnit(type, startAddress, numberOfEntries);
    }
    
    
    //写请求数据包封装
    QModbusDataUnit MainWindow::writeRequest() const
    { 
        QModbusDataUnit::RegisterType type = QModbusDataUnit::Invalid;
    
        qDebug() << ui->cbRegisterType->currentText();
    
        if (ui->cbRegisterType->currentText() == QString("线圈"))
        { 
             type = QModbusDataUnit::Coils;
        }
        else if (ui->cbRegisterType->currentText() == QString("离散输入"))
        { 
            type = QModbusDataUnit::DiscreteInputs;
        }
        else if (ui->cbRegisterType->currentText() == QString("输入寄存器"))
        { 
            type = QModbusDataUnit::InputRegisters;
        }
        else if (ui->cbRegisterType->currentText() == QString("保持寄存器"))
        { 
            type = QModbusDataUnit::HoldingRegisters;
        }
    
         qDebug() << "请求报文类型: " << type;
    
         //获取
         int startAddress = ui->sbWriteStartAddr->value();
         Q_ASSERT(startAddress >= 0 && startAddress < 10);
    
         quint16 numberOfEntries = ui->cbWriteCount->currentText().toUShort();
    
         //qDebug() << "Test: " << startAddress << " " << numberOfEntries;
         return QModbusDataUnit(type, startAddress, numberOfEntries);
    }
    
    //连接和断开连接的槽函数
    void MainWindow::onConnectButtonClicked()
    { 
        if (!modbusDevice)
        { 
            return;
        }
    
        //清空状态栏消息
        statusBar()->clearMessage();
    
        if (modbusDevice->state() != QModbusDevice::ConnectedState)
        { 
            auto type = static_cast<ModbusConnection>(ui->cbConnType->currentIndex());
            if (type == Serial)
            { 
                //设置串口连接信息
                modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter,
                                                     m_settingDialog->settings().serialName);
                modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter,
                                                     m_settingDialog->settings().parity);
                modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter,
                                                     m_settingDialog->settings().baud);
                modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter,
                                                     m_settingDialog->settings().dataBits);
                modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter,
                                                     m_settingDialog->settings().stopBits);
            }
            else
            { 
                //TCP连接信息
            }
    
            modbusDevice->setTimeout(m_settingDialog->settings().responseTime);
            modbusDevice->setNumberOfRetries(m_settingDialog->settings().numberOfRetries);
    
            if (!modbusDevice->connectDevice())
            { 
                statusBar()->showMessage(tr("Connect failed..") + modbusDevice->errorString(), 5000);
            }
            else
            { 
                statusBar()->showMessage(tr("Connect Successfully"), 5000);
                qDebug() << "连接OK";
                ui->actionConnect->setEnabled(false);
                ui->actionDisconnect->setEnabled(true);
    
                //使能读写操作
                ui->btnRead->setEnabled(true);
                ui->btnWrite->setEnabled(true);
                ui->btnReadWrite->setEnabled(true);
    
            }
        }
        else
        { 
            //断开连接
            modbusDevice->disconnectDevice();
            ui->actionConnect->setEnabled(true);
            ui->actionDisconnect->setDisabled(true);
            qDebug() << "断开连接成功";
    
            //禁用读写操作
            ui->btnRead->setEnabled(false);
            ui->btnWrite->setEnabled(false);
            ui->btnReadWrite->setEnabled(false);
        }
    }
    
    
    //连接类型槽函数 TCP Serial
    void MainWindow::onConnectTypeChanged(int index)
    { 
        //如果之前存在连接，则断开连接，然后释放内存
        if(modbusDevice)
        { 
            modbusDevice->disconnectDevice();
            delete modbusDevice;
            modbusDevice = nullptr;
        }
    
        auto type = static_cast<ModbusConnection>(index);
        if (type == Serial)
        { 
            modbusDevice = new QModbusRtuSerialMaster(this);
            qDebug() << "new QModbusRtuSerialMaster Ok";
            statusBar()->showMessage("new QModbusRtuSerialMaster Ok", 3000);
    
        }
        else if (type == Tcp)
        { 
    
        }
        else
        { 
            statusBar()->showMessage("连接类型非法", 5000);
        }
    
        connect(modbusDevice, &QModbusClient::errorOccurred, [this](QModbusDevice::Error){ 
            statusBar()->showMessage(modbusDevice->errorString(), 5000);
        });
    
        if (!modbusDevice)
        { 
            //分配空间失败
            ui->btnConnect->setDisabled(true);
            if (type == Serial)
            { 
                statusBar()->showMessage(tr("创建Modbus Master失败"), 5000);
            }
            else
            { 
                statusBar()->showMessage(tr("创建Modbus Client失败"), 5000);
            }
        }
        else
        { 
            connect(modbusDevice, &QModbusClient::stateChanged,
                    this, &MainWindow::onModbusStateChanged);
        }
    
    }
    
    
    //Modbus状态改变槽函数
    void MainWindow::onModbusStateChanged(int state)
    { 
        //判断Modbus设备连接是否处于连接状态
        bool connected = (state != QModbusDevice::UnconnectedState);
    
        ui->actionConnect->setEnabled(!connected);
        ui->actionDisconnect->setEnabled(connected);
    
        if (QModbusDevice::UnconnectedState == state)
        { 
            ui->btnConnect->setText(tr("Connect"));
        }
        else
        { 
            ui->btnConnect->setText(tr("Disconnect"));
        }
    }
    
    
    //读操作槽函数
    void MainWindow::onReadButtonClicked()
    { 
        if (!modbusDevice)
        { 
            return;
        }
    
        ui->textEditRead->clear();
        statusBar()->clearMessage();
    
        //发送请求报文数据
        auto *reply = modbusDevice->sendReadRequest(readRequest(), ui->sbServerAddr->value());
        if (reply)
        { 
            if (!reply->isFinished())
            { 
                //完毕之后 自动触发槽函数
                connect(reply, &QModbusReply::finished, this, &MainWindow::onReadReady);
            }
            else
            { 
                //广播消息 不需要返回响应
                delete reply;
            }
        }
        else
        { 
            statusBar()->showMessage(tr("Read Error: ") + modbusDevice->errorString(), 5000);
        }
    
    
    }
    
    
    //读取数据
    void MainWindow::onReadReady()
    { 
        auto reply = qobject_cast<QModbusReply*>(sender());
        if (!reply)
        { 
            return;
        }
    
        if (reply->error() == QModbusDevice::NoError)
        { 
            const QModbusDataUnit data = reply->result();
            for (int i = 0, total = (int)data.valueCount(); i < total; i++)
            { 
                const QString str = tr("Address: %1 Value: %2").arg(data.startAddress() + i)
                        .arg(QString::number(data.value(i), data.registerType() <= QModbusDataUnit::Coils ? 10 : 16));
                ui->textEditRead->append(str);
            }
        }
        else if (reply->error() == QModbusDevice::ProtocolError)
        { 
            statusBar()->showMessage(tr("Read response error: %1 (Modbus exception: 0x%2)").
                                     arg(reply->errorString()).
                                     arg(reply->rawResult().exceptionCode(), -1, 16), 5000);
        }
        else
        { 
            statusBar()->showMessage(tr("Read response error: %1 (Code: 0x%2)").
                                     arg(reply->errorString()).
                                     arg(reply->error(), -1, 16), 5000);
        }
    
    
        //释放内存
        reply->deleteLater();
    }
    
    void MainWindow::onWriteButtonClicked()
    { 
        if (!modbusDevice)
        { 
            return;
        }
    
        statusBar()->clearMessage();
    
        QModbusDataUnit writeData = writeRequest();
        QModbusDataUnit::RegisterType type = writeData.registerType();
        //qDebug() << "test: " << writeData.valueCount();
        for (int i = 0, total = (int)(writeData.valueCount()); i < total; i++)
        { 
            if (type == QModbusDataUnit::Coils)
            { 
                writeData.setValue(i, writeModel->m_coils[i + writeData.startAddress()]);
            }
            else
            { 
                //qDebug() << "test: " << writeModel->m_holdingRegisters[i + writeData.startAddress()];
                writeData.setValue(i, writeModel->m_holdingRegisters[i + writeData.startAddress()]);
            }
        }
    
        qDebug() << "写数据内容为：" << writeData.values();
    
        //发送请求报文数据
        auto *reply = modbusDevice->sendWriteRequest(writeData, ui->sbServerAddr->value());
        if (reply)
        { 
            if (!reply->isFinished())
            { 
                //完毕之后 自动触发槽函数
                connect(reply, &QModbusReply::finished, this, [this, reply]{ 
                    if (reply->error() == QModbusDevice::ProtocolError)
                    { 
                        statusBar()->showMessage(tr("Write Protocaol response error: %1").arg(reply->errorString()), 5000);
                    }
                    else if (reply->error() != QModbusDevice::NoError)
                    { 
                        statusBar()->showMessage(tr("Write response error: %1").arg(reply->errorString()), 5000);
                    }
                    else
                    { 
                        qDebug() << "写响应的数据: " << reply->result().values();
                    }
    
                    reply->deleteLater();
    
                });
            }
            else
            { 
                //广播消息 不需要返回响应
                reply->deleteLater();
            }
        }
        else
        { 
            statusBar()->showMessage(tr("Write Error: ") + modbusDevice->errorString(), 5000);
        }
    }
    
    
    //读写按钮槽函数
    void MainWindow::onReadWriteButtonClicked()
    { 
        if (!modbusDevice)
        { 
            return;
        }
    
        statusBar()->clearMessage();
    
        QModbusDataUnit writeData = writeRequest();
        QModbusDataUnit::RegisterType type = writeData.registerType();
        //qDebug() << "test: " << writeData.valueCount();
        for (int i = 0, total = (int)(writeData.valueCount()); i < total; i++)
        { 
            if (type == QModbusDataUnit::Coils)
            { 
                writeData.setValue(i, writeModel->m_coils[i + writeData.startAddress()]);
            }
            else
            { 
                //qDebug() << "test: " << writeModel->m_holdingRegisters[i + writeData.startAddress()];
                writeData.setValue(i, writeModel->m_holdingRegisters[i + writeData.startAddress()]);
            }
        }
    
        qDebug() << "写数据内容为：" << writeData.values();
    
        //发送请求报文数据
        auto *reply = modbusDevice->sendReadWriteRequest(readRequest(), writeData, ui->sbServerAddr->value());
        if (reply)
        { 
            if (!reply->isFinished())
            { 
                connect(reply, &QModbusReply::finished, this, &MainWindow::onReadReady);
    
                //完毕之后 自动触发槽函数
                connect(reply, &QModbusReply::finished, this, [this, reply]{ 
                    if (reply->error() == QModbusDevice::ProtocolError)
                    { 
                        statusBar()->showMessage(tr("Write Protocaol response error: %1").arg(reply->errorString()), 5000);
                    }
                    else if (reply->error() != QModbusDevice::NoError)
                    { 
                        statusBar()->showMessage(tr("Write response error: %1").arg(reply->errorString()), 5000);
                    }
                    else
                    { 
                        qDebug() << "写响应的数据: " << reply->result().values();
                    }
    
                    reply->deleteLater();
    
                });
            }
            else
            { 
                //广播消息 不需要返回响应
                reply->deleteLater();
            }
        }
        else
        { 
            statusBar()->showMessage(tr("Write Error: ") + modbusDevice->errorString(), 5000);
        }
    }
    
    void MainWindow::onWriteTableChanged(int index)
    { 
        const bool coilsOrHolding = index == 0 || index == 3;
    
        if (coilsOrHolding)
        { 
            ui->treeViewWrite->setColumnHidden(1, index != 0);
            ui->treeViewWrite->setColumnHidden(2, index != 3);
            ui->treeViewWrite->resizeColumnToContents(0);
        }
    
        ui->btnReadWrite->setEnabled(index == 3);
        ui->btnWrite->setEnabled(coilsOrHolding);
        ui->groupBox_2->setEnabled(coilsOrHolding);
    }

**writeregistermodel.h文件**

#ifndef WRITEREGISTERMODEL_H
    #define WRITEREGISTERMODEL_H
    
    #include <QAbstractItemModel>
    #include <QBitArray>
    #include <QObject>
    
    class WriteRegisterModel : public QAbstractTableModel
    { 
        Q_OBJECT
    
    public:
        WriteRegisterModel(QObject *parent = nullptr);
    
        int rowCount(const QModelIndex &parent = QModelIndex()) const override;
        int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    
        QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
        QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
        bool setData(const QModelIndex &index, const QVariant &value, int role) override;
    
        Qt::ItemFlags flags(const QModelIndex &index) const override;
    
    public slots:
        void setStartAddress(int address);
        void setNumberOfValues(const QString &number);
    
    signals:
        void updateViewport();
    
    public:
        int m_number = 0;
        int m_address = 0;
        QBitArray m_coils;
        QVector<quint16> m_holdingRegisters;
    };
    
    #endif // WRITEREGISTERMODEL_H

**writeregistermodel.cpp文件**

#include "writeregistermodel.h"
    
    enum {  NumColumn = 0, CoilsColumn = 1, HoldingColumn = 2, ColumnCount = 3, RowCount = 10 };
    
    WriteRegisterModel::WriteRegisterModel(QObject *parent)
        : QAbstractTableModel(parent),
          m_coils(RowCount, false), m_holdingRegisters(RowCount, 0u)
    { 
    }
    
    int WriteRegisterModel::rowCount(const QModelIndex &/*parent*/) const
    { 
        return RowCount;
    }
    
    int WriteRegisterModel::columnCount(const QModelIndex &/*parent*/) const
    { 
        return ColumnCount;
    }
    
    QVariant WriteRegisterModel::data(const QModelIndex &index, int role) const
    { 
        if (!index.isValid() || index.row() >= RowCount || index.column() >= ColumnCount)
            return QVariant();
    
        Q_ASSERT(m_coils.count() == RowCount);
        Q_ASSERT(m_holdingRegisters.count() == RowCount);
    
        if (index.column() == NumColumn && role == Qt::DisplayRole)
            return QString::number(index.row());
    
        if (index.column() == CoilsColumn && role == Qt::CheckStateRole) // coils
            return m_coils.at(index.row()) ? Qt::Checked : Qt::Unchecked;
    
        if (index.column() == HoldingColumn && role == Qt::DisplayRole) // holding registers
            return QString("0x%1").arg(QString::number(m_holdingRegisters.at(index.row()), 16));
    
        return QVariant();
    
    }
    
    QVariant WriteRegisterModel::headerData(int section, Qt::Orientation orientation, int role) const
    { 
        if (role != Qt::DisplayRole)
            return QVariant();
    
        if (orientation == Qt::Horizontal) { 
            switch (section) { 
            case NumColumn:
                return QStringLiteral("#");
            case CoilsColumn:
                return QStringLiteral("Coils ");
            case HoldingColumn:
                return QStringLiteral("Holding Registers");
            default:
                break;
            }
        }
        return QVariant();
    }
    
    bool WriteRegisterModel::setData(const QModelIndex &index, const QVariant &value, int role)
    { 
        if (!index.isValid() ||  index.row() >= RowCount || index.column() >= ColumnCount)
            return false;
    
        Q_ASSERT(m_coils.count() == RowCount);
        Q_ASSERT(m_holdingRegisters.count() == RowCount);
    
        if (index.column() == CoilsColumn && role == Qt::CheckStateRole) {  // coils
            auto s = static_cast<Qt::CheckState>(value.toUInt());
            s == Qt::Checked ? m_coils.setBit(index.row()) : m_coils.clearBit(index.row());
            emit dataChanged(index, index);
            return true;
        }
    
        if (index.column() == HoldingColumn && role == Qt::EditRole) {  // holding registers
            bool result = false;
            quint16 newValue = value.toString().toUShort(&result, 16);
            if (result)
                m_holdingRegisters[index.row()] = newValue;
    
            emit dataChanged(index, index);
            return result;
        }
    
        return false;
    }
    
    Qt::ItemFlags WriteRegisterModel::flags(const QModelIndex &index) const
    { 
        if (!index.isValid() || index.row() >= RowCount || index.column() >= ColumnCount)
            return QAbstractTableModel::flags(index);
    
        Qt::ItemFlags flags = QAbstractTableModel::flags(index);
        if ((index.row() < m_address) || (index.row() >= (m_address + m_number)))
            flags &= ~Qt::ItemIsEnabled;
    
        if (index.column() == CoilsColumn) // coils
            return flags | Qt::ItemIsUserCheckable;
        if (index.column() == HoldingColumn) // holding registers
            return flags | Qt::ItemIsEditable;
    
        return flags;
    }
    
    void WriteRegisterModel::setStartAddress(int address)
    { 
        m_address = address;
        emit updateViewport();
    }
    
    void WriteRegisterModel::setNumberOfValues(const QString &number)
    { 
        m_number = number.toInt();
        emit updateViewport();
    }

## 06. 程序下载 ##

6.1 [RTUMaster写操作示例(一).rar][RTUMaster_.rar]  
6.2 [RTUMasterTest写操作(二).rar][RTUMasterTest_.rar]

## 07. 附录 ##

**7.1 Qt教程汇总**  
网址：[https://dengjin.blog.csdn.net/article/details/115174639][https_dengjin.blog.csdn.net_article_details_115174639]

[RTUMaster_.rar]: https://download.csdn.net/download/dengjin20104042056/18883965
[RTUMasterTest_.rar]: https://download.csdn.net/download/dengjin20104042056/18900111
[https_dengjin.blog.csdn.net_article_details_115174639]: https://dengjin.blog.csdn.net/article/details/115174639