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

    00. 目录

    文章目录

    ​ ​00. 目录​​
    ​ ​01. 概述​​
    ​ ​02. 开发环境​​
    ​ ​03. 写Coils程序示例​​
    ​ ​04. 写HoldingRegisters程序示例​​
    ​ ​05. 综合示例​​
     

    01. 概述
    Qt中几个常用的串口modbus类

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

    02. 开发环境
    ​Windows系统​：Windows10

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

    Pro配置文件如下
     

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

    03. 写Coils程序示例
    ​widget.h文件

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5.  
    6. //前向声明
    7. class QModbusClient;
    8. class QModbusReply;
    9.  
    10.  
    11. class Widget : public QWidget
    12. {
    13.     Q_OBJECT
    14.  
    15. public:
    16.     Widget(QWidget *parent = nullptr);
    17.     ~Widget();
    18.  
    19.  
    20. private:
    21.     QModbusClient *modbusDevice = nullptr;
    22.  
    23.  
    24. private slots:
    25.     void onReadReady();
    26. };
    27. #endif // WIDGET_H

    ​widget.cpp文件

    1. #include "widget.h"
    2. #include <QModbusRtuSerialMaster>
    3. #include <QModbusDataUnit>
    4. #include <QModbusReply>
    5. #include <QVariant>
    6. #include <QSerialPort>
    7. #include <QDebug>
    8.  
    9. //构造函数
    10. Widget::Widget(QWidget *parent)
    11.     : QWidget(parent)
    12. {
    13.     //1. 创建QModbusDevice对象
    14.     modbusDevice = new QModbusRtuSerialMaster;
    15.  
    16.     //2. 如果处于连接状态，则断开连接
    17.     if (modbusDevice->state() == QModbusDevice::ConnectedState)
    18.     {
    19.         //断开连接设备
    20.         modbusDevice->disconnectDevice();
    21.     }
    22.  
    23.     //3. 设置串口相关参数
    24.     //设置串口信息
    25.     modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter, QVariant("COM3"));
    26.     //设置校验 无校验
    27.     modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter, QSerialPort::NoParity);
    28.     //设置波特率
    29.     modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter, QSerialPort::Baud19200);
    30.     //设置停止位
    31.     modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, QSerialPort::OneStop);
    32.     //设置数据位
    33.     modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter, QSerialPort::Data8);
    34.  
    35.     //4. 设置其他信息
    36.     //设置超时时间
    37.     modbusDevice->setTimeout(1000); //1秒
    38.     //设置失败重试次数
    39.     modbusDevice->setNumberOfRetries(3);
    40.  
    41.     //5. 连接到设备
    42.     bool ok = modbusDevice->connectDevice();
    43.     if (!ok)
    44.     {
    45.         qDebug() << "连接到串口失败： " << modbusDevice->errorString();
    46.     }
    47.     else
    48.     {
    49.         qDebug() << "连接到串口成功";
    50.     }
    51.  
    52.     //6. 发送写请求
    53.     //从地址0开始写10个保持寄存器的值
    54.     //QModbusDataUnit writeData(QModbusDataUnit::HoldingRegisters, 0, 10);
    55.  
    56.     //从地址0开始写10个线圈的值
    57.     QModbusDataUnit writeData(QModbusDataUnit::Coils, 0, 10);
    58.     for (int i = 0; i < writeData.valueCount(); i++)
    59.     {
    60.         writeData.setValue(i, (i * i) % 2);
    61.     }
    62.  
    63.     qDebug() << "发送的数据为： " << writeData.values();
    64.  
    65.     QModbusReply* reply = modbusDevice->sendWriteRequest(writeData, 1);
    66.     if (reply)
    67.     {
    68.         if (!reply->isFinished())
    69.         {
    70.             //接收响应信息
    71.             connect(reply, &QModbusReply::finished, this, [this, reply](){
    72.                 if (reply->error() == QModbusDevice::ProtocolError)
    73.                 {
    74.                     //接收到的响应信息是协议错误
    75.                     qDebug() << "写入数据错误：" << reply->errorString();
    76.                 }
    77.                 else if (reply->error() != QModbusDevice::NoError)
    78.                 {
    79.                     //接收到的响应消息是其它错误
    80.                     qDebug() << "写入数据错误： " << reply->errorString();
    81.                 }
    82.                 else
    83.                 {
    84.                     //接收到的消息没有错误 一般没有必要解析响应消息
    85.                     const QModbusDataUnit data = reply->result();
    86.  
    87.                     qDebug() << "消息数据个数：" << data.valueCount() << " :" << data.values();
    88.  
    89.                 }
    90.  
    91.                 reply->deleteLater();
    92.             });
    93.         }
    94.         else
    95.         {
    96.             //发送没有响应数据
    97.             //broadcast replies return immediately
    98.             reply->deleteLater();
    99.         }
    100.     }
    101.     else
    102.     {
    103.         qDebug() << "sendWriteRequest Error: " << reply->errorString();
    104.     }
    105.  
    106.  
    107.     //7. 发送读取数据请求
    108.     //从地址0开始读取10个保持寄存器的值
    109.     //QModbusDataUnit data(QModbusDataUnit::HoldingRegisters, 0, 10);
    110.     //从地址0开始读取10个离散输入量的值
    111.     //QModbusDataUnit data(QModbusDataUnit::DiscreteInputs, 0, 10);
    112.  
    113.     //QModbusDataUnit::Coils 从地址0开始读取10个线圈值
    114.     QModbusDataUnit data(QModbusDataUnit::Coils, 0, 10);
    115.  
    116.     //QModbusDataUnit::InputRegisters 从地址0开始读取10个输入寄存器的值
    117.     //QModbusDataUnit data(QModbusDataUnit::InputRegisters, 0, 10);
    118.  
    119.     reply = modbusDevice->sendReadRequest(data, 0x1);
    120.     if (nullptr == reply)
    121.     {
    122.         qDebug() << "发送请求数据失败: " << modbusDevice->errorString();
    123.     }
    124.     else
    125.     {
    126.         if (!reply->isFinished())
    127.         {
    128.             connect(reply, &QModbusReply::finished, this, &Widget::onReadReady);
    129.         }
    130.         else
    131.         {
    132.             //broadcast replies return immediately
    133.             delete reply;
    134.         }
    135.     }
    136.  
    137. }
    138.  
    139.  
    140. //析构函数
    141. Widget::~Widget()
    142. {
    143.     if (modbusDevice)
    144.     {
    145.         modbusDevice->disconnectDevice();
    146.     }
    147.  
    148.     delete modbusDevice;
    149. }
    150.  
    151. //准备读取数据的槽函数
    152. void Widget::onReadReady()
    153. {
    154.     auto reply = qobject_cast<QModbusReply*>(sender());
    155.     if (nullptr == reply)
    156.     {
    157.         return;
    158.     }
    159.  
    160.     //判断是否出错
    161.     if (reply->error() == QModbusDevice::NoError)
    162.     {
    163.         //读取响应数据
    164.         const QModbusDataUnit responseData = reply->result();
    165.  
    166.         qDebug() << "读到数据为：" << responseData.values();
    167.  
    168.     }
    169.     else if (reply->error() == QModbusDevice::ProtocolError)
    170.     {
    171.         qDebug() << "Read response Protocol error: " << reply->errorString();
    172.     }
    173.     else
    174.     {
    175.         qDebug() << "Read response Error: " << reply->errorString();
    176.     }
    177.  
    178.  
    179.     //删除reply
    180.     reply->deleteLater();
    181. }

    执行结果​

    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 
    04. 写HoldingRegisters程序示例
    ​widget.h文件

    1. #ifndef WIDGET_H
    2. #define WIDGET_H
    3.  
    4. #include 
    5.  
    6. //前向声明
    7. class QModbusClient;
    8. class QModbusReply;
    9.  
    10.  
    11. class Widget : public QWidget
    12. {
    13.     Q_OBJECT
    14.  
    15. public:
    16.     Widget(QWidget *parent = nullptr);
    17.     ~Widget();
    18.  
    19.  
    20. private:
    21.     QModbusClient *modbusDevice = nullptr;
    22.  
    23.  
    24. private slots:
    25.     void onReadReady();
    26. };
    27. #endif // WIDGET_H

    ​widget.cpp文件

    1. #include "widget.h"
    2. #include <QModbusRtuSerialMaster>
    3. #include <QModbusDataUnit>
    4. #include <QModbusReply>
    5. #include <QVariant>
    6. #include <QSerialPort>
    7. #include <QDebug>
    8.  
    9. //构造函数
    10. Widget::Widget(QWidget *parent)
    11.     : QWidget(parent)
    12. {
    13.     //1. 创建QModbusDevice对象
    14.     modbusDevice = new QModbusRtuSerialMaster;
    15.  
    16.     //2. 如果处于连接状态，则断开连接
    17.     if (modbusDevice->state() == QModbusDevice::ConnectedState)
    18.     {
    19.         //断开连接设备
    20.         modbusDevice->disconnectDevice();
    21.     }
    22.  
    23.     //3. 设置串口相关参数
    24.     //设置串口信息
    25.     modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter, QVariant("COM3"));
    26.     //设置校验 无校验
    27.     modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter, QSerialPort::NoParity);
    28.     //设置波特率
    29.     modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter, QSerialPort::Baud19200);
    30.     //设置停止位
    31.     modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, QSerialPort::OneStop);
    32.     //设置数据位
    33.     modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter, QSerialPort::Data8);
    34.  
    35.     //4. 设置其他信息
    36.     //设置超时时间
    37.     modbusDevice->setTimeout(1000); //1秒
    38.     //设置失败重试次数
    39.     modbusDevice->setNumberOfRetries(3);
    40.  
    41.     //5. 连接到设备
    42.     bool ok = modbusDevice->connectDevice();
    43.     if (!ok)
    44.     {
    45.         qDebug() << "连接到串口失败： " << modbusDevice->errorString();
    46.     }
    47.     else
    48.     {
    49.         qDebug() << "连接到串口成功";
    50.     }
    51.  
    52.     //6. 发送写请求
    53.     //从地址0开始写10个保持寄存器的值
    54.     QModbusDataUnit writeData(QModbusDataUnit::HoldingRegisters, 0, 10);
    55.     for (int i = 0; i < writeData.valueCount(); i++)
    56.     {
    57.         writeData.setValue(i, i * i);
    58.     }
    59.  
    60.     qDebug() << "发送的数据为： " << writeData.values();
    61.  
    62.     QModbusReply* reply = modbusDevice->sendWriteRequest(writeData, 1);
    63.     if (reply)
    64.     {
    65.         if (!reply->isFinished())
    66.         {
    67.             //接收响应信息
    68.             connect(reply, &QModbusReply::finished, this, [this, reply](){
    69.                 if (reply->error() == QModbusDevice::ProtocolError)
    70.                 {
    71.                     //接收到的响应信息是协议错误
    72.                     qDebug() << "写入数据错误：" << reply->errorString();
    73.                 }
    74.                 else if (reply->error() != QModbusDevice::NoError)
    75.                 {
    76.                     //接收到的响应消息是其它错误
    77.                     qDebug() << "写入数据错误： " << reply->errorString();
    78.                 }
    79.                 else
    80.                 {
    81.                     //接收到的消息没有错误 一般没有必要解析响应消息
    82.                     const QModbusDataUnit data = reply->result();
    83.  
    84.                     qDebug() << "消息数据个数：" << data.valueCount() << " :" << data.values();
    85.  
    86.                 }
    87.  
    88.                 reply->deleteLater();
    89.             });
    90.         }
    91.         else
    92.         {
    93.             //发送没有响应数据
    94.             //broadcast replies return immediately
    95.             reply->deleteLater();
    96.         }
    97.     }
    98.     else
    99.     {
    100.         qDebug() << "sendWriteRequest Error: " << reply->errorString();
    101.     }
    102.  
    103.  
    104.     //7. 发送读取数据请求
    105.     //从地址0开始读取10个保持寄存器的值
    106.     QModbusDataUnit data(QModbusDataUnit::HoldingRegisters, 0, 10);
    107.     //从地址0开始读取10个离散输入量的值
    108.     //QModbusDataUnit data(QModbusDataUnit::DiscreteInputs, 0, 10);
    109.  
    110.     //QModbusDataUnit::Coils 从地址0开始读取10个线圈值
    111.     //QModbusDataUnit data(QModbusDataUnit::Coils, 0, 10);
    112.  
    113.     //QModbusDataUnit::InputRegisters 从地址0开始读取10个输入寄存器的值
    114.     //QModbusDataUnit data(QModbusDataUnit::InputRegisters, 0, 10);
    115.  
    116.     reply = modbusDevice->sendReadRequest(data, 0x1);
    117.     if (nullptr == reply)
    118.     {
    119.         qDebug() << "发送请求数据失败: " << modbusDevice->errorString();
    120.     }
    121.     else
    122.     {
    123.         if (!reply->isFinished())
    124.         {
    125.             connect(reply, &QModbusReply::finished, this, &Widget::onReadReady);
    126.         }
    127.         else
    128.         {
    129.             //broadcast replies return immediately
    130.             delete reply;
    131.         }
    132.     }
    133.  
    134. }
    135.  
    136.  
    137. //析构函数
    138. Widget::~Widget()
    139. {
    140.     if (modbusDevice)
    141.     {
    142.         modbusDevice->disconnectDevice();
    143.     }
    144.  
    145.     delete modbusDevice;
    146. }
    147.  
    148. //准备读取数据的槽函数
    149. void Widget::onReadReady()
    150. {
    151.     auto reply = qobject_cast<QModbusReply*>(sender());
    152.     if (nullptr == reply)
    153.     {
    154.         return;
    155.     }
    156.  
    157.     //判断是否出错
    158.     if (reply->error() == QModbusDevice::NoError)
    159.     {
    160.         //读取响应数据
    161.         const QModbusDataUnit responseData = reply->result();
    162.  
    163.         qDebug() << "读到数据为：" << responseData.values();
    164.  
    165.     }
    166.     else if (reply->error() == QModbusDevice::ProtocolError)
    167.     {
    168.         qDebug() << "Read response Protocol error: " << reply->errorString();
    169.     }
    170.     else
    171.     {
    172.         qDebug() << "Read response Error: " << reply->errorString();
    173.     }
    174.  
    175.  
    176.     //删除reply
    177.     reply->deleteLater();
    178. }

    执行结果​

    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 ex

    05. 综合示例
    程序界面

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

    ​settingdialog.h文件

    1. #ifndef SETTINGDIALOG_H
    2. #define SETTINGDIALOG_H
    3.  
    4. #include <QDialog>
    5. #include <QtSerialPort>
    6.  
    7. namespace Ui {
    8. class SettingDialog;
    9. }
    10.  
    11. //串口设置相关类
    12. class SettingDialog : public QDialog
    13. {
    14.     Q_OBJECT
    15.  
    16. public:
    17.     struct Settings
    18.     {
    19.         //串口名
    20.         QString serialName = "COM3";
    21.         //校验位
    22.         int parity = QSerialPort::NoParity;
    23.         //波特率
    24.         int baud = QSerialPort::Baud19200;
    25.         //数据位
    26.         int dataBits = QSerialPort::Data8;
    27.         //停止位
    28.         int stopBits = QSerialPort::OneStop;
    29.  
    30.         //响应时间
    31.         int responseTime = 1000;
    32.         //重试次数
    33.         int numberOfRetries = 3;
    34.     };
    35.  
    36.     explicit SettingDialog(QWidget *parent = nullptr);
    37.     ~SettingDialog();
    38.  
    39.     //返回参数设置信息
    40.     Settings  settings() const;
    41.  
    42. private slots:
    43.     void on_btnApply_clicked();
    44.  
    45. private:
    46.     Ui::SettingDialog *ui;
    47.     Settings m_settings;
    48. };
    49.  
    50. #endif // SETTINGDIALOG_H

    ​settingdialog.cpp文件

    1. #include "settingdialog.h"
    2. #include "ui_settingdialog.h"
    3.  
    4. //构造函数
    5. SettingDialog::SettingDialog(QWidget *parent) :
    6.     QDialog(parent),
    7.     ui(new Ui::SettingDialog)
    8. {
    9.     ui->setupUi(this);
    10.  
    11.     //设置默认参数信息
    12.     ui->serialNameLineEdit->setText(tr("COM3"));
    13.     ui->parityComboBox->setCurrentIndex(0);
    14.  
    15.     ui->baudComboBox->setCurrentText(QString::number(m_settings.baud));
    16.     ui->dataBitComboBox->setCurrentText(QString::number(m_settings.dataBits));
    17.     ui->stopBitComboBox->setCurrentText(QString::number(m_settings.stopBits));
    18.  
    19.     ui->spinBoxTimeOut->setValue(m_settings.responseTime);
    20.     ui->spinBoxRetry->setValue(m_settings.numberOfRetries);
    21.  
    22. }
    23.  
    24. //析构函数
    25. SettingDialog::~SettingDialog()
    26. {
    27.     delete ui;
    28. }
    29.  
    30. //返回参数信息
    31. SettingDialog::Settings SettingDialog::settings() const
    32. {
    33.     return m_settings;
    34. }
    35.  
    36. //引用按钮槽函数
    37. void SettingDialog::on_btnApply_clicked()
    38. {
    39.     m_settings.serialName = ui->serialNameLineEdit->text();
    40.     m_settings.parity = ui->parityComboBox->currentText().toInt();
    41.     m_settings.baud = ui->baudComboBox->currentText().toInt();
    42.     m_settings.dataBits = ui->dataBitComboBox->currentText().toInt();
    43.     m_settings.stopBits = ui->stopBitComboBox->currentText().toInt();
    44.  
    45.     m_settings.responseTime = ui->spinBoxTimeOut->value();
    46.     m_settings.numberOfRetries = ui->spinBoxRetry->value();
    47.  
    48.     //隐藏参数设置对话框
    49.     hide();
    50. }

    ​mainwindow.h文件

    1. #ifndef MAINWINDOW_H
    2. #define MAINWINDOW_H
    3.  
    4. #include 
    5. #include 
    6. #include "writeregistermodel.h"
    7.  
    8. QT_BEGIN_NAMESPACE
    9.  
    10. namespace Ui
    11. {
    12. class MainWindow;
    13. }
    14.  
    15. class SettingDialog;
    16. class QModbusClient;
    17. class QModbusReply;
    18.  
    19.  
    20. QT_END_NAMESPACE
    21.  
    22. class MainWindow : public QMainWindow
    23. {
    24.     Q_OBJECT
    25.  
    26. public:
    27.     MainWindow(QWidget *parent = nullptr);
    28.     ~MainWindow();
    29.  
    30.     //信号与槽进行关联
    31.     void initActions();
    32.  
    33.     //读请求数据包封装
    34.     QModbusDataUnit readRequest() const;
    35.  
    36.     //写请求数据包封装
    37.     QModbusDataUnit writeRequest() const;
    38.  
    39. private slots:
    40.     void onConnectButtonClicked();
    41.  
    42.     void onConnectTypeChanged(int);
    43.  
    44.     void onModbusStateChanged(int state);
    45.  
    46.     void onReadButtonClicked();
    47.     void onReadReady();
    48.  
    49.  
    50.     void onWriteButtonClicked();
    51.  
    52.     void onReadWriteButtonClicked();
    53.  
    54.     void onWriteTableChanged(int);
    55.  
    56. private:
    57.     Ui::MainWindow *ui = nullptr;
    58.  
    59.     SettingDialog *m_settingDialog = nullptr;
    60.  
    61.     QModbusClient *modbusDevice = nullptr;
    62.  
    63.     QModbusReply *reply = nullptr;
    64.  
    65.     WriteRegisterModel *writeModel = nullptr;
    66.  
    67. };
    68. #endif // MAINWINDOW_H

    mainwindow.cpp文件

    1. #include "mainwindow.h"
    2. #include "ui_mainwindow.h"
    3. #include <QMessageBox>
    4. #include "settingdialog.h"
    5. #include <QModbusRtuSerialMaster>
    6. #include <QModbusReply>
    7. #include <QStandardItemModel>
    8. #include <QModbusDataUnit>
    9.  
    10. //连接类型枚举变量
    11. enum ModbusConnection {
    12.     Serial,
    13.     Tcp
    14. };
    15.  
    16.  
    17. MainWindow::MainWindow(QWidget *parent)
    18.     : QMainWindow(parent)
    19.     , ui(new Ui::MainWindow)
    20. {
    21.     ui->setupUi(this);
    22.  
    23.     //创建对象
    24.     m_settingDialog = new SettingDialog(this);
    25.  
    26.     //初始化信号与槽
    27.     initActions();
    28.  
    29.     //创建写模型
    30.     writeModel = new WriteRegisterModel(this);
    31.     writeModel->setStartAddress(ui->sbWriteStartAddr->value());
    32.     writeModel->setNumberOfValues(ui->cbWriteCount->currentText());
    33.  
    34.     //MVC
    35.     ui->treeViewWrite->setModel(writeModel);
    36.     //隐藏第二列
    37.     ui->treeViewWrite->hideColumn(2);
    38.     connect(writeModel, &WriteRegisterModel::updateViewport,
    39.             ui->treeViewWrite->viewport(), QOverload<>::of(&QWidget::update));
    40.  
    41.  
    42.     //默认为串口连接方式
    43.     ui->cbConnType->setCurrentIndex(0);
    44.     onConnectTypeChanged(0);
    45.  
    46.     auto model = new QStandardItemModel(10, 1, this);
    47.     for (int i = 0; i < 10; i++)
    48.     {
    49.         model->setItem(i, new QStandardItem(QStringLiteral("%1").arg(i + 1)));
    50.     }
    51.  
    52.     ui->cbWriteCount->setModel(model);
    53.     ui->cbWriteCount->setCurrentText("10");
    54.  
    55.     connect(ui->cbWriteCount, &QComboBox::currentTextChanged,
    56.             writeModel, &WriteRegisterModel::setNumberOfValues);
    57.  
    58.     auto valueChanged = QOverload<int>::of(&QSpinBox::valueChanged);
    59.     connect(ui->sbWriteStartAddr, valueChanged, writeModel, &WriteRegisterModel::setStartAddress);
    60.  
    61.  
    62.     connect(ui->sbWriteStartAddr, valueChanged, this, [this, model](int i){
    63.         int lastIndex = 0;
    64.         const int curIndex = ui->cbWriteCount->currentIndex();
    65.         for (int j = 0; j < 10; j++)
    66.         {
    67.             //设置使能
    68.             if (j < (10 - i))
    69.             {
    70.                 lastIndex = j;
    71.                 model->item(j)->setEnabled(true);
    72.             }
    73.             else
    74.             {
    75.                 //设置禁用
    76.                 model->item(j)->setEnabled(false);
    77.             }
    78.         }
    79.  
    80.         if (curIndex > lastIndex)
    81.         {
    82.             ui->cbWriteCount->setCurrentIndex(lastIndex);
    83.         }
    84.  
    85.     });
    86. }
    87.  
    88.  
    89. //析构函数
    90. MainWindow::~MainWindow()
    91. {
    92.     if (modbusDevice)
    93.     {
    94.         modbusDevice->disconnectDevice();
    95.         delete modbusDevice;
    96.     }
    97.     delete ui;
    98. }
    99.  
    100.  
    101.  
    102. //信号与槽进行关联s
    103. void MainWindow::initActions()
    104. {
    105.     //使能部分功能
    106.     ui->actionConnect->setEnabled(true);
    107.     ui->actionDisconnect->setEnabled(false);
    108.     ui->actionQuit->setEnabled(true);
    109.     ui->actionOption->setEnabled(true);
    110.  
    111.     //禁用读写操作
    112.     ui->btnRead->setEnabled(false);
    113.     ui->btnWrite->setEnabled(false);
    114.     ui->btnReadWrite->setEnabled(false);
    115.  
    116.  
    117.     //信号与槽关联
    118.     connect(ui->btnConnect, &QPushButton::clicked,
    119.             this, &MainWindow::onConnectButtonClicked);
    120.  
    121.     connect(ui->actionConnect, &QAction::triggered,
    122.             this, &MainWindow::onConnectButtonClicked);
    123.  
    124.     connect(ui->actionDisconnect, &QAction::triggered,
    125.             this, &MainWindow::onConnectButtonClicked);
    126.  
    127.     //读操作按钮槽函数关联
    128.     connect(ui->btnRead, &QPushButton::clicked,
    129.             this, &MainWindow::onReadButtonClicked);
    130.  
    131.     connect(ui->btnWrite, &QPushButton::clicked,
    132.             this, &MainWindow::onWriteButtonClicked);
    133.  
    134.     connect(ui->btnReadWrite, &QPushButton::clicked,
    135.             this, &MainWindow::onReadWriteButtonClicked);
    136.  
    137.     connect(ui->cbRegisterType, QOverload<int>::of(&QComboBox::currentIndexChanged),
    138.             this, &MainWindow::onWriteTableChanged);
    139.  
    140.     connect(ui->cbConnType, QOverload<int>::of(&QComboBox::currentIndexChanged),
    141.             this, &MainWindow::onConnectTypeChanged);
    142.  
    143.     //退出菜单
    144.     connect(ui->actionQuit, &QAction::triggered, this, &MainWindow::close);
    145.     //显示参数设置对话框
    146.     connect(ui->actionOption, &QAction::triggered, m_settingDialog, &QDialog::show);
    147.  
    148.     connect(ui->actionAbout, &QAction::triggered, [=]() {
    149.         QMessageBox::aboutQt(this, "About Qt");
    150.     });
    151. }
    152.  
    153. //构建请求报文
    154. QModbusDataUnit MainWindow::readRequest() const
    155. {
    156.     //const auto type = static_cast<QModbusDataUnit::RegisterType>(ui->cbRegisterType->currentData().toInt());
    157.  
    158.    QModbusDataUnit::RegisterType type = QModbusDataUnit::Invalid;
    159.  
    160.    qDebug() << ui->cbRegisterType->currentText();
    161.  
    162.    if (ui->cbRegisterType->currentText() == QString("线圈"))
    163.    {
    164.         type = QModbusDataUnit::Coils;
    165.    }
    166.    else if (ui->cbRegisterType->currentText() == QString("离散输入"))
    167.    {
    168.        type = QModbusDataUnit::DiscreteInputs;
    169.    }
    170.    else if (ui->cbRegisterType->currentText() == QString("输入寄存器"))
    171.    {
    172.        type = QModbusDataUnit::InputRegisters;
    173.    }
    174.    else if (ui->cbRegisterType->currentText() == QString("保持寄存器"))
    175.    {
    176.        type = QModbusDataUnit::HoldingRegisters;
    177.    }
    178.  
    179.     qDebug() << "请求报文类型: " << type;
    180.  
    181.     //获取
    182.     int startAddress = ui->spReadStartAddr->value();
    183.     Q_ASSERT(startAddress >= 0 && startAddress < 10);
    184.  
    185.     quint16 numberOfEntries = ui->cbReadCount->currentText().toUShort();
    186.  
    187.     return QModbusDataUnit(type, startAddress, numberOfEntries);
    188. }
    189.  
    190.  
    191. //写请求数据包封装
    192. QModbusDataUnit MainWindow::writeRequest() const
    193. {
    194.     QModbusDataUnit::RegisterType type = QModbusDataUnit::Invalid;
    195.  
    196.     qDebug() << ui->cbRegisterType->currentText();
    197.  
    198.     if (ui->cbRegisterType->currentText() == QString("线圈"))
    199.     {
    200.          type = QModbusDataUnit::Coils;
    201.     }
    202.     else if (ui->cbRegisterType->currentText() == QString("离散输入"))
    203.     {
    204.         type = QModbusDataUnit::DiscreteInputs;
    205.     }
    206.     else if (ui->cbRegisterType->currentText() == QString("输入寄存器"))
    207.     {
    208.         type = QModbusDataUnit::InputRegisters;
    209.     }
    210.     else if (ui->cbRegisterType->currentText() == QString("保持寄存器"))
    211.     {
    212.         type = QModbusDataUnit::HoldingRegisters;
    213.     }
    214.  
    215.      qDebug() << "请求报文类型: " << type;
    216.  
    217.      //获取
    218.      int startAddress = ui->sbWriteStartAddr->value();
    219.      Q_ASSERT(startAddress >= 0 && startAddress < 10);
    220.  
    221.      quint16 numberOfEntries = ui->cbWriteCount->currentText().toUShort();
    222.  
    223.      //qDebug() << "Test: " << startAddress << " " << numberOfEntries;
    224.      return QModbusDataUnit(type, startAddress, numberOfEntries);
    225. }
    226.  
    227. //连接和断开连接的槽函数
    228. void MainWindow::onConnectButtonClicked()
    229. {
    230.     if (!modbusDevice)
    231.     {
    232.         return;
    233.     }
    234.  
    235.     //清空状态栏消息
    236.     statusBar()->clearMessage();
    237.  
    238.     if (modbusDevice->state() != QModbusDevice::ConnectedState)
    239.     {
    240.         auto type = static_cast<ModbusConnection>(ui->cbConnType->currentIndex());
    241.         if (type == Serial)
    242.         {
    243.             //设置串口连接信息
    244.             modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter,
    245.                                                  m_settingDialog->settings().serialName);
    246.             modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter,
    247.                                                  m_settingDialog->settings().parity);
    248.             modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter,
    249.                                                  m_settingDialog->settings().baud);
    250.             modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter,
    251.                                                  m_settingDialog->settings().dataBits);
    252.             modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter,
    253.                                                  m_settingDialog->settings().stopBits);
    254.         }
    255.         else
    256.         {
    257.             //TCP连接信息
    258.         }
    259.  
    260.         modbusDevice->setTimeout(m_settingDialog->settings().responseTime);
    261.         modbusDevice->setNumberOfRetries(m_settingDialog->settings().numberOfRetries);
    262.  
    263.         if (!modbusDevice->connectDevice())
    264.         {
    265.             statusBar()->showMessage(tr("Connect failed..") + modbusDevice->errorString(), 5000);
    266.         }
    267.         else
    268.         {
    269.             statusBar()->showMessage(tr("Connect Successfully"), 5000);
    270.             qDebug() << "连接OK";
    271.             ui->actionConnect->setEnabled(false);
    272.             ui->actionDisconnect->setEnabled(true);
    273.  
    274.             //使能读写操作
    275.             ui->btnRead->setEnabled(true);
    276.             ui->btnWrite->setEnabled(true);
    277.             ui->btnReadWrite->setEnabled(true);
    278.  
    279.         }
    280.     }
    281.     else
    282.     {
    283.         //断开连接
    284.         modbusDevice->disconnectDevice();
    285.         ui->actionConnect->setEnabled(true);
    286.         ui->actionDisconnect->setDisabled(true);
    287.         qDebug() << "断开连接成功";
    288.  
    289.         //禁用读写操作
    290.         ui->btnRead->setEnabled(false);
    291.         ui->btnWrite->setEnabled(false);
    292.         ui->btnReadWrite->setEnabled(false);
    293.     }
    294. }
    295.  
    296.  
    297. //连接类型槽函数 TCP Serial
    298. void MainWindow::onConnectTypeChanged(int index)
    299. {
    300.     //如果之前存在连接，则断开连接，然后释放内存
    301.     if(modbusDevice)
    302.     {
    303.         modbusDevice->disconnectDevice();
    304.         delete modbusDevice;
    305.         modbusDevice = nullptr;
    306.     }
    307.  
    308.     auto type = static_cast<ModbusConnection>(index);
    309.     if (type == Serial)
    310.     {
    311.         modbusDevice = new QModbusRtuSerialMaster(this);
    312.         qDebug() << "new QModbusRtuSerialMaster Ok";
    313.         statusBar()->showMessage("new QModbusRtuSerialMaster Ok", 3000);
    314.  
    315.     }
    316.     else if (type == Tcp)
    317.     {
    318.  
    319.     }
    320.     else
    321.     {
    322.         statusBar()->showMessage("连接类型非法", 5000);
    323.     }
    324.  
    325.     connect(modbusDevice, &QModbusClient::errorOccurred, [this](QModbusDevice::Error){
    326.         statusBar()->showMessage(modbusDevice->errorString(), 5000);
    327.     });
    328.  
    329.     if (!modbusDevice)
    330.     {
    331.         //分配空间失败
    332.         ui->btnConnect->setDisabled(true);
    333.         if (type == Serial)
    334.         {
    335.             statusBar()->showMessage(tr("创建Modbus Master失败"), 5000);
    336.         }
    337.         else
    338.         {
    339.             statusBar()->showMessage(tr("创建Modbus Client失败"), 5000);
    340.         }
    341.     }
    342.     else
    343.     {
    344.         connect(modbusDevice, &QModbusClient::stateChanged,
    345.                 this, &MainWindow::onModbusStateChanged);
    346.     }
    347.  
    348. }
    349.  
    350.  
    351. //Modbus状态改变槽函数
    352. void MainWindow::onModbusStateChanged(int state)
    353. {
    354.     //判断Modbus设备连接是否处于连接状态
    355.     bool connected = (state != QModbusDevice::UnconnectedState);
    356.  
    357.     ui->actionConnect->setEnabled(!connected);
    358.     ui->actionDisconnect->setEnabled(connected);
    359.  
    360.     if (QModbusDevice::UnconnectedState == state)
    361.     {
    362.         ui->btnConnect->setText(tr("Connect"));
    363.     }
    364.     else
    365.     {
    366.         ui->btnConnect->setText(tr("Disconnect"));
    367.     }
    368. }
    369.  
    370.  
    371. //读操作槽函数
    372. void MainWindow::onReadButtonClicked()
    373. {
    374.     if (!modbusDevice)
    375.     {
    376.         return;
    377.     }
    378.  
    379.     ui->textEditRead->clear();
    380.     statusBar()->clearMessage();
    381.  
    382.     //发送请求报文数据
    383.     auto *reply = modbusDevice->sendReadRequest(readRequest(), ui->sbServerAddr->value());
    384.     if (reply)
    385.     {
    386.         if (!reply->isFinished())
    387.         {
    388.             //完毕之后 自动触发槽函数
    389.             connect(reply, &QModbusReply::finished, this, &MainWindow::onReadReady);
    390.         }
    391.         else
    392.         {
    393.             //广播消息  不需要返回响应
    394.             delete reply;
    395.         }
    396.     }
    397.     else
    398.     {
    399.         statusBar()->showMessage(tr("Read Error: ") + modbusDevice->errorString(), 5000);
    400.     }
    401.  
    402.  
    403. }
    404.  
    405.  
    406. //读取数据
    407. void MainWindow::onReadReady()
    408. {
    409.     auto reply = qobject_cast<QModbusReply*>(sender());
    410.     if (!reply)
    411.     {
    412.         return;
    413.     }
    414.  
    415.     if (reply->error() == QModbusDevice::NoError)
    416.     {
    417.         const QModbusDataUnit data = reply->result();
    418.         for (int i = 0, total = (int)data.valueCount(); i < total; i++)
    419.         {
    420.             const QString str = tr("Address: %1 Value: %2").arg(data.startAddress() + i)
    421.                     .arg(QString::number(data.value(i), data.registerType() <= QModbusDataUnit::Coils ? 10 : 16));
    422.             ui->textEditRead->append(str);
    423.         }
    424.     }
    425.     else if (reply->error() == QModbusDevice::ProtocolError)
    426.     {
    427.         statusBar()->showMessage(tr("Read response error: %1 (Modbus exception: 0x%2)").
    428.                                  arg(reply->errorString()).
    429.                                  arg(reply->rawResult().exceptionCode(), -1, 16), 5000);
    430.     }
    431.     else
    432.     {
    433.         statusBar()->showMessage(tr("Read response error: %1 (Code: 0x%2)").
    434.                                  arg(reply->errorString()).
    435.                                  arg(reply->error(), -1, 16), 5000);
    436.     }
    437.  
    438.  
    439.     //释放内存
    440.     reply->deleteLater();
    441. }
    442.  
    443. void MainWindow::onWriteButtonClicked()
    444. {
    445.     if (!modbusDevice)
    446.     {
    447.         return;
    448.     }
    449.  
    450.     statusBar()->clearMessage();
    451.  
    452.     QModbusDataUnit writeData = writeRequest();
    453.     QModbusDataUnit::RegisterType type = writeData.registerType();
    454.     //qDebug() << "test: " << writeData.valueCount();
    455.     for (int i = 0, total = (int)(writeData.valueCount()); i < total; i++)
    456.     {
    457.         if (type == QModbusDataUnit::Coils)
    458.         {
    459.             writeData.setValue(i, writeModel->m_coils[i + writeData.startAddress()]);
    460.         }
    461.         else
    462.         {
    463.             //qDebug() << "test: " << writeModel->m_holdingRegisters[i + writeData.startAddress()];
    464.             writeData.setValue(i, writeModel->m_holdingRegisters[i + writeData.startAddress()]);
    465.         }
    466.     }
    467.  
    468.     qDebug() << "写数据内容为：" << writeData.values();
    469.  
    470.     //发送请求报文数据
    471.     auto *reply = modbusDevice->sendWriteRequest(writeData, ui->sbServerAddr->value());
    472.     if (reply)
    473.     {
    474.         if (!reply->isFinished())
    475.         {
    476.             //完毕之后 自动触发槽函数
    477.             connect(reply, &QModbusReply::finished, this, [this, reply]{
    478.                 if (reply->error() == QModbusDevice::ProtocolError)
    479.                 {
    480.                     statusBar()->showMessage(tr("Write Protocaol response error: %1").arg(reply->errorString()), 5000);
    481.                 }
    482.                 else if (reply->error() != QModbusDevice::NoError)
    483.                 {
    484.                     statusBar()->showMessage(tr("Write response error: %1").arg(reply->errorString()), 5000);
    485.                 }
    486.                 else
    487.                 {
    488.                     qDebug() << "写响应的数据: " << reply->result().values();
    489.                 }
    490.  
    491.                 reply->deleteLater();
    492.  
    493.             });
    494.         }
    495.         else
    496.         {
    497.             //广播消息  不需要返回响应
    498.             reply->deleteLater();
    499.         }
    500.     }
    501.     else
    502.     {
    503.         statusBar()->showMessage(tr("Write Error: ") + modbusDevice->errorString(), 5000);
    504.     }
    505. }
    506.  
    507.  
    508. //读写按钮槽函数
    509. void MainWindow::onReadWriteButtonClicked()
    510. {
    511.     if (!modbusDevice)
    512.     {
    513.         return;
    514.     }
    515.  
    516.     statusBar()->clearMessage();
    517.  
    518.     QModbusDataUnit writeData = writeRequest();
    519.     QModbusDataUnit::RegisterType type = writeData.registerType();
    520.     //qDebug() << "test: " << writeData.valueCount();
    521.     for (int i = 0, total = (int)(writeData.valueCount()); i < total; i++)
    522.     {
    523.         if (type == QModbusDataUnit::Coils)
    524.         {
    525.             writeData.setValue(i, writeModel->m_coils[i + writeData.startAddress()]);
    526.         }
    527.         else
    528.         {
    529.             //qDebug() << "test: " << writeModel->m_holdingRegisters[i + writeData.startAddress()];
    530.             writeData.setValue(i, writeModel->m_holdingRegisters[i + writeData.startAddress()]);
    531.         }
    532.     }
    533.  
    534.     qDebug() << "写数据内容为：" << writeData.values();
    535.  
    536.     //发送请求报文数据
    537.     auto *reply = modbusDevice->sendReadWriteRequest(readRequest(), writeData, ui->sbServerAddr->value());
    538.     if (reply)
    539.     {
    540.         if (!reply->isFinished())
    541.         {
    542.             connect(reply, &QModbusReply::finished, this, &MainWindow::onReadReady);
    543.  
    544.             //完毕之后 自动触发槽函数
    545.             connect(reply, &QModbusReply::finished, this, [this, reply]{
    546.                 if (reply->error() == QModbusDevice::ProtocolError)
    547.                 {
    548.                     statusBar()->showMessage(tr("Write Protocaol response error: %1").arg(reply->errorString()), 5000);
    549.                 }
    550.                 else if (reply->error() != QModbusDevice::NoError)
    551.                 {
    552.                     statusBar()->showMessage(tr("Write response error: %1").arg(reply->errorString()), 5000);
    553.                 }
    554.                 else
    555.                 {
    556.                     qDebug() << "写响应的数据: " << reply->result().values();
    557.                 }
    558.  
    559.                 reply->deleteLater();
    560.  
    561.             });
    562.         }
    563.         else
    564.         {
    565.             //广播消息  不需要返回响应
    566.             reply->deleteLater();
    567.         }
    568.     }
    569.     else
    570.     {
    571.         statusBar()->showMessage(tr("Write Error: ") + modbusDevice->errorString(), 5000);
    572.     }
    573. }
    574.  
    575. void MainWindow::onWriteTableChanged(int index)
    576. {
    577.     const bool coilsOrHolding = index == 0 || index == 3;
    578.  
    579.     if (coilsOrHolding)
    580.     {
    581.         ui->treeViewWrite->setColumnHidden(1, index != 0);
    582.         ui->treeViewWrite->setColumnHidden(2, index != 3);
    583.         ui->treeViewWrite->resizeColumnToContents(0);
    584.     }
    585.  
    586.     ui->btnReadWrite->setEnabled(index == 3);
    587.     ui->btnWrite->setEnabled(coilsOrHolding);
    588.     ui->groupBox_2->setEnabled(coilsOrHolding);
    589. }

    ​writeregistermodel.h文件

    1. #ifndef WRITEREGISTERMODEL_H
    2. #define WRITEREGISTERMODEL_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. class WriteRegisterModel : public QAbstractTableModel
    9. {
    10.     Q_OBJECT
    11.  
    12. public:
    13.     WriteRegisterModel(QObject *parent = nullptr);
    14.  
    15.     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    16.     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    17.  
    18.     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    19.     QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
    20.     bool setData(const QModelIndex &index, const QVariant &value, int role) override;
    21.  
    22.     Qt::ItemFlags flags(const QModelIndex &index) const override;
    23.  
    24. public slots:
    25.     void setStartAddress(int address);
    26.     void setNumberOfValues(const QString &number);
    27.  
    28. signals:
    29.     void updateViewport();
    30.  
    31. public:
    32.     int m_number = 0;
    33.     int m_address = 0;
    34.     QBitArray m_coils;
    35.     QVector m_holdingRegisters;
    36. };
    37.  
    38. #endif // WRITEREGISTERMODEL_H

    ​writeregistermodel.cpp文件

    1. #include "writeregistermodel.h"
    2.  
    3. enum { NumColumn = 0, CoilsColumn = 1, HoldingColumn = 2, ColumnCount = 3, RowCount = 10 };
    4.  
    5. WriteRegisterModel::WriteRegisterModel(QObject *parent)
    6.     : QAbstractTableModel(parent),
    7.       m_coils(RowCount, false), m_holdingRegisters(RowCount, 0u)
    8. {
    9. }
    10.  
    11. int WriteRegisterModel::rowCount(const QModelIndex &/*parent*/) const
    12. {
    13.     return RowCount;
    14. }
    15.  
    16. int WriteRegisterModel::columnCount(const QModelIndex &/*parent*/) const
    17. {
    18.     return ColumnCount;
    19. }
    20.  
    21. QVariant WriteRegisterModel::data(const QModelIndex &index, int role) const
    22. {
    23.     if (!index.isValid() || index.row() >= RowCount || index.column() >= ColumnCount)
    24.         return QVariant();
    25.  
    26.     Q_ASSERT(m_coils.count() == RowCount);
    27.     Q_ASSERT(m_holdingRegisters.count() == RowCount);
    28.  
    29.     if (index.column() == NumColumn && role == Qt::DisplayRole)
    30.         return QString::number(index.row());
    31.  
    32.     if (index.column() == CoilsColumn && role == Qt::CheckStateRole) // coils
    33.         return m_coils.at(index.row()) ? Qt::Checked : Qt::Unchecked;
    34.  
    35.     if (index.column() == HoldingColumn && role == Qt::DisplayRole) // holding registers
    36.         return QString("0x%1").arg(QString::number(m_holdingRegisters.at(index.row()), 16));
    37.  
    38.     return QVariant();
    39.  
    40. }
    41.  
    42. QVariant WriteRegisterModel::headerData(int section, Qt::Orientation orientation, int role) const
    43. {
    44.     if (role != Qt::DisplayRole)
    45.         return QVariant();
    46.  
    47.     if (orientation == Qt::Horizontal) {
    48.         switch (section) {
    49.         case NumColumn:
    50.             return QStringLiteral("#");
    51.         case CoilsColumn:
    52.             return QStringLiteral("Coils  ");
    53.         case HoldingColumn:
    54.             return QStringLiteral("Holding Registers");
    55.         default:
    56.             break;
    57.         }
    58.     }
    59.     return QVariant();
    60. }
    61.  
    62. bool WriteRegisterModel::setData(const QModelIndex &index, const QVariant &value, int role)
    63. {
    64.     if (!index.isValid() ||  index.row() >= RowCount || index.column() >= ColumnCount)
    65.         return false;
    66.  
    67.     Q_ASSERT(m_coils.count() == RowCount);
    68.     Q_ASSERT(m_holdingRegisters.count() == RowCount);
    69.  
    70.     if (index.column() == CoilsColumn && role == Qt::CheckStateRole) { // coils
    71.         auto s = static_cast<Qt::CheckState>(value.toUInt());
    72.         s == Qt::Checked ? m_coils.setBit(index.row()) : m_coils.clearBit(index.row());
    73.         emit dataChanged(index, index);
    74.         return true;
    75.     }
    76.  
    77.     if (index.column() == HoldingColumn && role == Qt::EditRole) { // holding registers
    78.         bool result = false;
    79.         quint16 newValue = value.toString().toUShort(&result, 16);
    80.         if (result)
    81.             m_holdingRegisters[index.row()] = newValue;
    82.  
    83.         emit dataChanged(index, index);
    84.         return result;
    85.     }
    86.  
    87.     return false;
    88. }
    89.  
    90. Qt::ItemFlags WriteRegisterModel::flags(const QModelIndex &index) const
    91. {
    92.     if (!index.isValid() || index.row() >= RowCount || index.column() >= ColumnCount)
    93.         return QAbstractTableModel::flags(index);
    94.  
    95.     Qt::ItemFlags flags = QAbstractTableModel::flags(index);
    96.     if ((index.row() < m_address) || (index.row() >= (m_address + m_number)))
    97.         flags &= ~Qt::ItemIsEnabled;
    98.  
    99.     if (index.column() == CoilsColumn) // coils
    100.         return flags | Qt::ItemIsUserCheckable;
    101.     if (index.column() == HoldingColumn) // holding registers
    102.         return flags | Qt::ItemIsEditable;
    103.  
    104.     return flags;
    105. }
    106.  
    107. void WriteRegisterModel::setStartAddress(int address)
    108. {
    109.     m_address = address;
    110.     emit updateViewport();
    111. }
    112.  
    113. void WriteRegisterModel::setNumberOfValues(const QString &number)
    114. {
    115.     m_number = number.toInt();
    116.     emit updateViewport();
    117. }
    118.

  • 相关阅读:
    Linux用户管理
    7、Jedis测试
    【图灵MySQL】Explain详解与索引最佳实践
    pt30redis数据类型
    Vue首屏优化方案
    【执行数据库操作时Tomcat报错但不影响使用】error testWhileIdle is true, validationQuery not set
    谷歌紧急更新，Chrome 今年第二个零日漏洞曝光
    （附源码）计算机毕业设计SSM教师职称资料管理系统
    基于.Net 的 AvaloniUI 多媒体播放器方案汇总
    【20221103】【每日一题】二叉搜索树中的众数
  • 原文地址：https://blog.csdn.net/delphigbg/article/details/127799464