Bluesun
/
BatteryMonitor
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Add] move modbusrtu to thread very smoothgit status!

This commit is contained in:
Carl 2024-11-01 11:24:09 +08:00
parent 54d0c9e831
commit f474423549
6 changed files with 148 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
appserial.cpp
View File

@ -49,7 +49,7 @@ void AppSerial::setHWND(HWND hwnd)
this->m_hwnd = hwnd; this->m_hwnd = hwnd;
} }
bool AppSerial::nativeEventFilter(const QByteArray &eventType, void *message, long *result) bool AppSerial::nativeEventFilter(const QByteArray &eventType, void *message, qintptr *result)
{ {
Q_UNUSED(eventType); Q_UNUSED(eventType);
Q_UNUSED(result); Q_UNUSED(result);

2
appserial.h
View File

@ -33,7 +33,7 @@ public:
void setHWND(HWND hwnd); void setHWND(HWND hwnd);
protected: protected:
bool nativeEventFilter(const QByteArray &eventType, void *message, long *result); bool nativeEventFilter(const QByteArray &eventType, void *message, qintptr *result);
signals: signals:
/** /**

3
dialoglogin.cpp
View File

@ -159,6 +159,7 @@ void DialogLogin::slot_comChangeStatus(QString name, bool flag)
void DialogLogin::slot_btnConnect_clicked() void DialogLogin::slot_btnConnect_clicked()
{ {
BCUNumbers = ui->comboBoxBCUQuantity->currentText().toInt(); BCUNumbers = ui->comboBoxBCUQuantity->currentText().toInt();
emit sendBCUNumberSignals(BCUNumbers); emit sendBCUNumberSignals(BCUNumbers);
connect(this, &DialogLogin::sendBCUNumberSignals, m_MainWindow, &MainWindow::slot_getBcuNumberFromDialoglogin); connect(this, &DialogLogin::sendBCUNumberSignals, m_MainWindow, &MainWindow::slot_getBcuNumberFromDialoglogin);
ini->setValue("Serial/BaudRate", ui->comboBoxBaudRate->currentIndex()); ini->setValue("Serial/BaudRate", ui->comboBoxBaudRate->currentIndex());
@ -246,7 +247,7 @@ void DialogLogin::slot_btnConnect_clicked()
m_MainWindow->statusBarConnectedIcon->setPixmap(QPixmap(QIcon(":/Image/connected2.png").pixmap(QSize(24, 24)))); m_MainWindow->statusBarConnectedIcon->setPixmap(QPixmap(QIcon(":/Image/connected2.png").pixmap(QSize(24, 24))));
m_MainWindow->show(); m_MainWindow->show();
// m_MainWindow->showMaximized(); // m_MainWindow->showMaximized();
m_ModbusRTU->start();
} }
else { else {
if(ini->value("System/Language") == MainWindow::LANGUAGE_ENG) { if(ini->value("System/Language") == MainWindow::LANGUAGE_ENG) {

1
mainwindow.cpp
View File

@ -1266,6 +1266,7 @@ void MainWindow::slot_pageHomeBaseInfo1_45(QByteArray byteArray, int dataType)
{ {
if(dataType == TypeRecvData) if(dataType == TypeRecvData)
{ {
// qDebug() << "33333333333333333333333333333333";
QList<int> result_int; QList<int> result_int;
bool ok; bool ok;

270
modbusrtu.cpp
View File

@ -3,8 +3,8 @@
#include <QEvent> #include <QEvent>
#include <QDebug> #include <QDebug>
#include "modbus-private.h" #include "modbus-private.h"
#include <QMessageBox>
ModbusRTU::ModbusRTU(QObject *parent) : QObject(parent) ModbusRTU::ModbusRTU(QObject *parent) : QThread(parent)
{ {
init(); init();
} }
@ -17,151 +17,153 @@ ModbusRTU::~ModbusRTU()
void ModbusRTU::init() void ModbusRTU::init()
{ {
timer50msId = startTimer(50);
timer100msId = startTimer(100);
timer200msId = startTimer(200);
timer1000msId = startTimer(1000);
} }
void ModbusRTU::timerEvent(QTimerEvent *event) void ModbusRTU::run()
{ {
if(isConnect != true) { qDebug() << "进入线程：" << QThread::currentThread();
return; while(true)
} {
else { // qDebug() << "11111111111111111111111111111111";
if(event->timerId() == timer50msId) { QThread::msleep(200);
uint16_t base1_45[45];
uint16_t base57_78[22];
uint16_t base83_106[24];
uint16_t base47[1];
uint16_t base49[1];
uint16_t base51[1];
uint16_t base53[1];
uint16_t base55[1];
QList<int> base_list_47_49_51_53_55;
uint16_t sgl_vol[112]; // Buffer to store the registers
uint16_t sgl_tempt[112];
label: int ret_base1_45 = modbus_read_input_registers(m_ModbusRTUDevice, 1, 45, base1_45);
if(MODBUS_ERR == ret_base1_45)
{
qDebug() << "modbus no message";
goto label;
}
else
{
// qDebug() << "2222222222222222222222222222222";
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info1_45(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData_base_info1_45(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
// qDebug() << "in modbus:" << base1_45;
}
int ret_base47 = modbus_read_input_registers(m_ModbusRTUDevice, 47, 1, base47);
int ret_base49 = modbus_read_input_registers(m_ModbusRTUDevice, 49, 1, base49);
int ret_base51 = modbus_read_input_registers(m_ModbusRTUDevice, 51, 1, base51);
int ret_base53 = modbus_read_input_registers(m_ModbusRTUDevice, 53, 1, base53);
int ret_base55 = modbus_read_input_registers(m_ModbusRTUDevice, 55, 1, base55);
if (ret_base47 == -1 | ret_base49 == -1 | ret_base51 == -1 | ret_base53 == -1 | ret_base55 == -1)
{
return;
}
else
{
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info47_49_51_53_55(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
// QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
QByteArray recvArray;
recvArray.append(reinterpret_cast<char*>(&base47), sizeof(base47));
recvArray.append(reinterpret_cast<char*>(&base49), sizeof(base49));
recvArray.append(reinterpret_cast<char*>(&base51), sizeof(base51));
recvArray.append(reinterpret_cast<char*>(&base53), sizeof(base53));
recvArray.append(reinterpret_cast<char*>(&base55), sizeof(base55));
for (int i = 0; i < recvArray.size(); i += 2) {
uint16_t value;
memcpy(&value, recvArray.data() + i, 2);
base_list_47_49_51_53_55.append(value);
// base47_49_51_53_55[i] = value;
// qDebug() << "Value: " << value;
}
emit sig_showModbusData_base_info_list_47_49_51_53_55(base_list_47_49_51_53_55, TypeRecvData);
// emit sig_showModbusData_base_info47_49_51_53_55(sendArray, TypeSendData);
free(m_ModbusRTUDevice->recvMsg);
}
int ret_base57_78 = modbus_read_input_registers(m_ModbusRTUDevice, 57, 22, base57_78);
if(MODBUS_ERR == ret_base57_78)
{
// qDebug() << "modbus no message";
return;
}
else
{
// qDebug() << "4444444444444444444444444444";
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info57_78(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData_base_info57_78(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
}
int ret_base83_106 = modbus_read_input_registers(m_ModbusRTUDevice, 83, 24, base83_106);
if(MODBUS_ERR == ret_base83_106)
{
// qDebug() << "modbus no message";
goto label;
}
else
{
// qDebug() << "5555555555555555555555555555";
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info83_106(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData_base_info83_106(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
}
int ret_vol = modbus_read_input_registers(m_ModbusRTUDevice, 1001, 112, sgl_vol);
if(MODBUS_ERR == ret_vol)
{
// qDebug() << "modbus no message";
goto label;
} }
if(event->timerId() == timer100msId) { else
{
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
} }
if(event->timerId() == timer200msId) {
int ret_tempt = modbus_read_input_registers(m_ModbusRTUDevice, 1601, 112, sgl_tempt);
if(MODBUS_ERR == ret_tempt)
{
// qDebug() << "modbus no message";
goto label;
} }
if(event->timerId() == timer1000msId) { else
uint16_t sgl_vol[112]; // Buffer to store the registers {
uint16_t sgl_tempt[112]; QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
uint16_t base1_45[45]; emit sig_showModbusData_sgl_tempt(sendArray, TypeSendData);
uint16_t base57_78[22]; free(m_ModbusRTUDevice->sendMsg);
uint16_t base83_106[24]; QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
uint16_t base47[1]; emit sig_showModbusData_sgl_tempt(recvArray, TypeRecvData);
uint16_t base49[1]; free(m_ModbusRTUDevice->recvMsg);
uint16_t base51[1];
uint16_t base53[1];
uint16_t base55[1];
uint16_t base47_49_51_53_55[5];
uint16_t test2[2] = {10, 20};
QList<int> base_list_47_49_51_53_55;
int ret_base1_45 = modbus_read_input_registers(m_ModbusRTUDevice, 1, 45, base1_45);
if(MODBUS_ERR == ret_base1_45) {
// qDebug() << "modbus no message";
return;
}
else {
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info1_45(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData_base_info1_45(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
// qDebug() << "in modbus:" << base1_45;
}
int ret_base47 = modbus_read_input_registers(m_ModbusRTUDevice, 47, 1, base47);
int ret_base49 = modbus_read_input_registers(m_ModbusRTUDevice, 49, 1, base49);
int ret_base51 = modbus_read_input_registers(m_ModbusRTUDevice, 51, 1, base51);
int ret_base53 = modbus_read_input_registers(m_ModbusRTUDevice, 53, 1, base53);
int ret_base55 = modbus_read_input_registers(m_ModbusRTUDevice, 55, 1, base55);
if (ret_base47 == -1 | ret_base49 == -1 | ret_base51 == -1 | ret_base53 == -1 | ret_base55 == -1)
{
return;
}
else
{
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info47_49_51_53_55(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
// QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
QByteArray recvArray;
recvArray.append(reinterpret_cast<char*>(&base47), sizeof(base47));
recvArray.append(reinterpret_cast<char*>(&base49), sizeof(base49));
recvArray.append(reinterpret_cast<char*>(&base51), sizeof(base51));
recvArray.append(reinterpret_cast<char*>(&base53), sizeof(base53));
recvArray.append(reinterpret_cast<char*>(&base55), sizeof(base55));
for (int i = 0; i < recvArray.size(); i += 2) {
uint16_t value;
memcpy(&value, recvArray.data() + i, 2);
base_list_47_49_51_53_55.append(value);
// base47_49_51_53_55[i] = value;
// qDebug() << "Value: " << value;
}
emit sig_showModbusData_base_info_list_47_49_51_53_55(base_list_47_49_51_53_55, TypeRecvData);
// emit sig_showModbusData_base_info47_49_51_53_55(sendArray, TypeSendData);
free(m_ModbusRTUDevice->recvMsg);
}
int ret_base57_78 = modbus_read_input_registers(m_ModbusRTUDevice, 57, 22, base57_78);
if(MODBUS_ERR == ret_base57_78) {
// qDebug() << "modbus no message";
return;
}
else {
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info57_78(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData_base_info57_78(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
}
int ret_base83_106 = modbus_read_input_registers(m_ModbusRTUDevice, 83, 24, base83_106);
if(MODBUS_ERR == ret_base83_106) {
// qDebug() << "modbus no message";
return;
}
else {
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_base_info83_106(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData_base_info83_106(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
}
int ret_vol = modbus_read_input_registers(m_ModbusRTUDevice, 1001, 112, sgl_vol);
if(MODBUS_ERR == ret_vol) {
// qDebug() << "modbus no message";
return;
}
else {
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
}
int ret_tempt = modbus_read_input_registers(m_ModbusRTUDevice, 1601, 112, sgl_tempt);
if(MODBUS_ERR == ret_tempt) {
// qDebug() << "modbus no message";
return;
}
else {
QByteArray sendArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->sendMsg), m_ModbusRTUDevice->sendMsgLen);
emit sig_showModbusData_sgl_tempt(sendArray, TypeSendData);
free(m_ModbusRTUDevice->sendMsg);
QByteArray recvArray = QByteArray::fromRawData(reinterpret_cast<char *>(m_ModbusRTUDevice->recvMsg), m_ModbusRTUDevice->recvMsgLen);
emit sig_showModbusData_sgl_tempt(recvArray, TypeRecvData);
free(m_ModbusRTUDevice->recvMsg);
}
} }
} }
} }
void ModbusRTU::write_regs_slot(int addr,const uint16_t data) void ModbusRTU::write_regs_slot(int addr,const uint16_t data)
{ {
int rc = write_single_register(addr, data); int rc = write_single_register(addr, data);

15
modbusrtu.h
View File

@ -3,16 +3,16 @@
#include <QObject> #include <QObject>
#include "modbus.h" #include "modbus.h"
#include <QThread>
class QTimer; class QTimer;
class ModbusRTU : public QObject class ModbusRTU : public QThread
{ {
Q_OBJECT Q_OBJECT
public: public:
ModbusRTU(QObject *parent = nullptr); ModbusRTU(QObject *parent = nullptr);
~ModbusRTU(); ~ModbusRTU();
void timerEvent(QTimerEvent *event);
void write_regs_slot(int addr, const uint16_t data); void write_regs_slot(int addr, const uint16_t data);
void read_regs_slot(int addr, int nb, uint16_t *data, int row); void read_regs_slot(int addr, int nb, uint16_t *data, int row);
@ -25,13 +25,12 @@ public:
int dataBit; int dataBit;
int stopBit; int stopBit;
private: protected:
int timer50msId; void run() override;
int timer100msId;
int timer200msId;
int timer1000msId;
static constexpr int MODBUS_ERR = -1; private:
static constexpr int MODBUS_ERR = -1;
enum DataType{ enum DataType{
TypeRecvData, TypeRecvData,