Qt中几个常用的串口modbus类
QModbusRtuSerialSlave //modbus串口通信方式下的服务器类
QModbusRtuSerialMaster //串口通信方式下的客户端类
QModbusServer // QModbusServer类接收和处理modbus的请求。
QModbusDataUnit //存储接收和发送数据的类，数据类型为1bit和16bit
QModbusReply //客户端访问服务器后得到的回复（如客户端读服务器数据时包含数据信息）
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
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
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);
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
程序界面
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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();
}
6.1 RTUMaster写操作示例(一).rar
6.2 RTUMasterTest写操作(二).rar
7.1 Qt教程汇总
网址：https://dengjin.blog.csdn.net/article/details/115174639
文章浏览阅读2w次。mac电脑触控板快速选择前提：在截图或者选择的时候，点击触控板在拖动会很麻烦，mac提供一个三指拖移的功能，能够用三指快速拖移，这样就变成四指切换。步骤左上角，点击苹果logo，选择系统偏好设置点击辅助功能，选择“鼠标与触控板”点击“触控板选项”，勾选启动拖移，选择“三指拖移”，选择“好”就设置完毕啦。这样，就可以一指滑动，轻触点击；二指滑动三指拖移四指切换面板棒呆..._mac trackpad 两指移动
文章浏览阅读2.2k次。文章目录1 图片被划分为CTU2 图片被划分为SubPicture、Slice、Tile2.1 Tile、SLice、SubPicture的概念2.2 光栅扫描分区模式2.3 矩形分区模式3 CTU以树形继续向下划分3.1 HEVC的划分方式3.2 VVC的划分方式3.3 编解码方式3.4 示例3.5 高层参数及限制3.6 帧内的色度独立划分4 CU在图片边缘的划分5 CU冗余划分的限制6 虚拟管..._h.266 ctb
文章浏览阅读1.5k次。从零开始搭建自己的vue组件库——01创建引言项目创建修改目录结构添加第一个组件以及样式文件夹引言因工作需要，要打造一套属于自己团队的组件库，本人也是第一次接到这种任务，虽然不着急，但是之前从来没做过，因此特意再此记录下过程，也希望自己能坚持下去，当然，过程中少不了查阅各种资料，也会再次记录下各种各样的问题，本组件库的开发基于vue2.0，主要用于pc端，会参考element-ui进行开发项目创建首先第一步是要创建一个vue工程vue create xxxx创建具体流程在这里不再详细说明，创建完_vue构建自己的组件库
文章浏览阅读1.3k次。神经网络在优化中的应用:万能的模型+误差修正函数“，每次根据训练得到的结果与预想结果进行误差分析，进而修改权值和阈值，一步一步得到能输出和预想结果一致的模型。举一个例子：比如某厂商生产一种产品，投放到市场之后得到了消费者的反馈，根据消费者的反馈，厂商对产品进一步升级，优化，从而生产出让消费者更满意的产品。这就是BP神经网络的核心。BP神经网络是一种按误差反向传播(简称误差反传)训练的多层前馈网络，其算法称为BP算法，它的基本思想是梯度下降法，利用梯度搜索技术，以期使网络的实际输出值和期望输出值的误差均方
文章浏览阅读282次。适配器模式我们先讲适配器模式，后面的装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式，都是依赖于适配器模式中的对象的适配器模式为起源的。适配器模式，简单来讲，就是某个类的接口和另一个接口不匹配，将某个类的接口转换成客户端期望的另一个接口表示。目的是消除由于接口不匹配所造成的类的兼容性问题。1.类的适配器模式我们还是模拟一个场景，市电都是220V的交流电，但是手机充电是5..._android 适配器adapter相当于service层次吗吗
文章浏览阅读3.3k次。本篇主要介绍PCIe总线的复位方式。PCIe总线规定了两个复位方式：Conventional Reset和FLR（Function Level Reset），而Conventional Reset又可以进一步分为两大类：Fundamental Reset和Non-Fundamental Reset。Fundamental Reset方式包括Cold和WarmReset方式，可以将PCIe将设备中的绝大多数内部寄存器和内部状态都恢复成初始值；而Non-FundamentalReset方式为Hot Res._pcie flr复位使用方法
文章浏览阅读98次。计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？编写Demo04MathPractise.java类package com.iflytek.day08.demo04;/*题目：计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？分析：1. 既然已经确定了范围，for循环2. 起点位置-10.8应该转换成为-10，两种办法： 2.1 可以使用Math.ceil方法，向上（向正方向）取整 2.2 强转成为int，自动舍弃所有小数位3_java math计算在 -10.8 到 5.9 之间,绝对值大于 6 或者小于 2.1 的整数有多少个?
文章浏览阅读1.7k次。C++使用随机数_c++suijizhongzi
文章浏览阅读793次。参考地址：http://blog.csdn.net/jj120522/article/details/8075249
文章浏览阅读649次。总的来说，Twitter是一种强大的社交媒体工具，它有着许多优点，比如实时信息更新、广泛的观众和社区参与度高。用户可以实时获取和发布信息，无论是新闻、活动更新、产品发布，甚至是天气预报，这些都可以在Twitter上即时发布。限制的表达方式：Twitter的推文长度有限制（目前是280个字符），这限制了用户的表达方式。隐私问题：尽管Twitter提供了一些隐私设置，但用户的推文和信息仍然可能被大量的人看到。信息过载：由于Twitter上信息更新的速度非常快，用户可能会感到信息过载。_tiwwer软件亮点
文章浏览阅读421次。前言Hello我又来了，快年底了，作为一个有抱负的码农，我想给自己攒一个年终总结。自上上篇写了手动搭建Redis集群和MySQL主从同步(非Docker)和上篇写了动手实现MySQL读写分离and故障转移之后，索性这次把数据库中最核心的也是最难搞懂的内容，也就是索引，分享给大家。这篇博客我会谈谈对于索引结构我自己的看法，以及分享如何从零开始一层一层向上最终理解索引结构。从一个简单的..._insert into userweight(jdate,name,height,weight)values(?,?,?,?)
文章浏览阅读63次。简单来说Stable Diffusion是一个文本到图像的潜在扩散模型，由CompVis、Stability AI和LAION的研究人员和工程师创建。它使用来自LAION-5B数据库子集的512x512图像进行训练。使用这个模型，可以生成包括人脸在内的任何图像，因为有开源的预训练模型，所以我们也可以在自己的机器上运行它。****_stable diffusion 训练 ai画画