software/x-tools
1
0
Fork 0
mirror of https://github.com/x-tools-author/x-tools.git synced 2025-09-15 15:28:40 +08:00
Code Issues Actions 7 Packages Projects Releases Wiki Activity

refact: rename data member

Browse Source
This commit is contained in:
x-tools-author 2024-03-27 13:13:23 +08:00
parent abacd765d0
commit 0ae4cff3c4
4 changed files with 86 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.cpp
View File

@ -9,6 +9,7 @@
#include "xToolsModbusStudio.h"
#include <QCoreApplication>
#include <QDebug>
#include <QModbusTcpClient>
#include <QModbusTcpServer>
#if QT_VERSION < QT_VERSION_CHECK(6, 2, 0)
@ -49,7 +50,7 @@ const QString xToolsModbusStudio::TypeName(int type)
}
Q_ASSERT_X(false, __FUNCTION__, "Unknown modebus device type");
qCWarning(kLoggingCategory) << "Unknown modebus device type";
qWarning() << "Unknown modebus device type";
return "Unknown";
}
@ -57,29 +58,29 @@ const QString xToolsModbusStudio::TypeName(int type)
QModbusDevice *xToolsModbusStudio::CreateDevice(int type)
{
if (type == kModbusRtuSerialClient) {
qCInfo(kLoggingCategory) << "Create rtu serial client.";
qInfo() << "Create rtu serial client.";
#if QT_VERSION < QT_VERSION_CHECK(6, 2, 0)
return new QModbusRtuSerialMaster(this);
#else
return new QModbusRtuSerialClient(this);
#endif
} else if (type == kModbusRtuSerialServer) {
qCInfo(kLoggingCategory) << "Create rtu serial server.";
qInfo() << "Create rtu serial server.";
#if QT_VERSION < QT_VERSION_CHECK(6, 2, 0)
return new QModbusRtuSerialSlave(this);
#else
return new QModbusRtuSerialServer(this);
#endif
} else if (type == kModbusTcpClient) {
qCInfo(kLoggingCategory) << "Create tcp client.";
qInfo() << "Create tcp client.";
return new QModbusTcpClient();
} else if (type == kModbusTcpServer) {
qCInfo(kLoggingCategory) << "Create tcp server.";
qInfo() << "Create tcp server.";
return new QModbusTcpServer();
}
Q_ASSERT_X(false, __FUNCTION__, "Unknown modebus device type");
qCWarning(kLoggingCategory) << "Unknown modebus device type";
qWarning() << "Unknown modebus device type";
return Q_NULLPTR;
}
@ -192,8 +193,8 @@ bool xToolsModbusStudio::SetServerData(QModbusDevice *server,
QModbusServer *modbusServer = qobject_cast<QModbusServer *>(server);
is_ok = modbusServer->setData(table, address, data);
if (enable_log) {
qCInfo(kLoggingCategory) << "Set register data result:" << is_ok << "table:" << table
<< "address:" << address << "data:" << data;
qInfo() << "Set register data result:" << is_ok << "table:" << table
<< "address:" << address << "data:" << data;
}
}
@ -213,12 +214,12 @@ QList<quint16> xToolsModbusStudio::GetServerData(QModbusDevice *server,
if (cooked_server->data(table, i, &value)) {
values.append(value);
} else {
qCWarning(kLoggingCategory) << "Parameters error!";
qWarning() << "Parameters error!";
break;
}
}
} else {
qCWarning(kLoggingCategory) << "Can not get values from null object!";
qWarning() << "Can not get values from null object!";
}
return values;
@ -248,10 +249,9 @@ QModbusDevice *xToolsModbusStudio::CreateRtuSerialDevice(
device->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, stop_bits);
device->setConnectionParameter(QModbusDevice::SerialParityParameter, parity);
qCInfo(kLoggingCategory) << "Set rtu serial modbus device parameters:"
<< "port name:" << port_name << "baud rate:" << baud_rate
<< "data bits:" << data_bits << "stop bits" << stop_bits
<< "parity" << parity;
qInfo() << "Set rtu serial modbus device parameters:"
<< "port name:" << port_name << "baud rate:" << baud_rate
<< "data bits:" << data_bits << "stop bits" << stop_bits << "parity" << parity;
}
return device;
@ -264,8 +264,8 @@ QModbusDevice *xToolsModbusStudio::CreateTcpDevice(int type, QString address, in
device->setConnectionParameter(QModbusDevice::NetworkAddressParameter, address);
device->setConnectionParameter(QModbusDevice::NetworkPortParameter, port);
qCInfo(kLoggingCategory) << "Set tcp modbus device parameters:"
<< "ip address:" << address << "port" << port;
qInfo() << "Set tcp modbus device parameters:"
<< "ip address:" << address << "port" << port;
}
return device;
@ -276,9 +276,8 @@ void xToolsModbusStudio::SetClientDeviceParameters(QModbusDevice *client,
int number_of_retries)
{
if (client) {
qCInfo(kLoggingCategory) << "Set modbus client device parameters:"
<< "timeout:" << timeout << "number_of_retries"
<< number_of_retries;
qInfo() << "Set modbus client device parameters:"
<< "timeout:" << timeout << "number_of_retries" << number_of_retries;
QModbusClient *cooked_client = qobject_cast<QModbusClient *>(client);
cooked_client->setTimeout(timeout);
@ -292,9 +291,9 @@ void xToolsModbusStudio::SetServerDeviceParameters(QModbusDevice *server,
bool listen_only_mode)
{
if (server) {
qCInfo(kLoggingCategory) << "Set modbus server device parameters:"
<< "address:" << address << "device busy" << device_busy
<< "listen only mode:" << listen_only_mode;
qInfo() << "Set modbus server device parameters:"
<< "address:" << address << "device busy" << device_busy
<< "listen only mode:" << listen_only_mode;
QModbusServer *cooked_server = qobject_cast<QModbusServer *>(server);
cooked_server->setServerAddress(address);
@ -317,15 +316,14 @@ QModbusReply *xToolsModbusStudio::SendWriteRequest(QModbusDevice *modbus_device,
auto cooked_type = QModbusDataUnit::RegisterType(register_type);
QModbusDataUnit dataUnit(cooked_type, start_address, values);
if (dataUnit.isValid()) {
qCInfo(kLoggingCategory)
<< "register-type:" << register_type << " start-address:" << start_address
<< " serverAddress:" << server_address << " values:" << values;
qInfo() << "register-type:" << register_type << " start-address:" << start_address
<< " serverAddress:" << server_address << " values:" << values;
auto *client = qobject_cast<QModbusClient *>(modbus_device);
QModbusReply *reply = client->sendWriteRequest(dataUnit, server_address);
return reply;
} else {
qCWarning(kLoggingCategory) << "Unvalid data unit!";
qWarning() << "Unvalid data unit!";
}
}

4
Source/ModbusStudio/ModbusStudio/xToolsModbusStudio.h
View File

@ -8,7 +8,6 @@
**************************************************************************************************/
#pragma once
#include <QLoggingCategory>
#include <QModbusDataUnit>
#include <QModbusDevice>
#include <QModbusReply>
@ -77,7 +76,4 @@ public:
int server_address,
int function_code,
const QByteArray &data);
private:
const QLoggingCategory kLoggingCategory{"SAK.Modbus.Factory"};
};

118
Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.cpp
View File

@ -49,35 +49,35 @@
#define TXFLAG "tx:"
#define MAX_HISTORY_INDEX 9
struct SAKModbusUiSettingKeys
struct xToolsModbusUiSettingKeys
{
const QString device_index = "SAKModbus/deviceIndex";
const QString deviceIndex = "xToolsModbus/deviceIndex";
const QString port_name = "SAKModbus/portName";
const QString parity = "SAKModbus/parity";
const QString baud_rate = "SAKModbus/baudRate";
const QString data_bits = "SAKModbus/dataBits";
const QString stop_bits = "SAKModbus/stopBits";
const QString custom_baud_rate = "SAKModbus/customBaudRate";
const QString portName = "xToolsModbus/portName";
const QString parity = "xToolsModbus/parity";
const QString baudRate = "xToolsModbus/baudRate";
const QString dataBits = "xToolsModbus/dataBits";
const QString stopBits = "xToolsModbus/stopBits";
const QString customBaudRate = "xToolsModbus/customBaudRate";
const QString address = "SAKModbus/address";
const QString port = "SAKModbus/port";
const QString custom_address = "SAKModbus/customAddress";
const QString address = "xToolsModbus/address";
const QString port = "xToolsModbus/port";
const QString customAddress = "xToolsModbus/customAddress";
const QString client_timeout = "SAKModbus/clientTimeout";
const QString client_repeat_time = "SAKModbus/clientRepeatTime";
const QString clientTimeout = "xToolsModbus/clientTimeout";
const QString clientRepeatTime = "xToolsModbus/clientRepeatTime";
const QString server_is_busy = "SAKModbus/serverIsBusy";
const QString server_just_listen = "SAKModbus/serverJustListen";
const QString server_address = "SAKModbus/serverAddress";
const QString serverIsBusy = "xToolsModbus/serverIsBusy";
const QString serverJustListen = "xToolsModbus/serverJustListen";
const QString serverAddress = "xToolsModbus/serverAddress";
const QString function_code = "SAKModbus/functionCode";
const QString target_address = "SAKModbus/targetAddress";
const QString start_address = "SAKModbus/startAddress";
const QString address_number = "SAKModbus/addressNumber";
const QString functionCode = "xToolsModbus/functionCode";
const QString targetAddress = "xToolsModbus/targetAddress";
const QString startAddress = "xToolsModbus/startAddress";
const QString addressNumber = "xToolsModbus/addressNumber";
const QString send_history = "SAKModbus/sendHistory";
const QString send_history_index = "SAKModbus/sendHistoryIndex";
const QString sendHistory = "xToolsModbus/sendHistory";
const QString sendHistoryIndex = "xToolsModbus/sendHistoryIndex";
const QString pdu = "pdu";
};
@ -121,7 +121,7 @@ xToolsModbusStudioUi::xToolsModbusStudioUi(QWidget *parent)
, ui(new Ui::xToolsModbusStudioUi)
, m_modbusDevice(Q_NULLPTR)
, m_registerModel(Q_NULLPTR)
, m_keyCtx(new SAKModbusUiSettingKeys)
, m_keyCtx(new xToolsModbusUiSettingKeys)
{
if (!m_settings) {
m_settings = xToolsSettings::instance();
@ -295,7 +295,7 @@ void xToolsModbusStudioUi::initSettings()
void xToolsModbusStudioUi::initSettingsDevice()
{
int deviceIndex = m_settings->value(m_keyCtx->device_index).toInt();
int deviceIndex = m_settings->value(m_keyCtx->deviceIndex).toInt();
if (deviceIndex >= 0 && deviceIndex < ui->device_list_->count()) {
ui->device_list_->setCurrentIndex(deviceIndex);
}
@ -322,67 +322,67 @@ void xToolsModbusStudioUi::initSettingsSerialPort()
}
};
QString portName = m_settings->value(m_keyCtx->port_name).toString();
QString portName = m_settings->value(m_keyCtx->portName).toString();
int index = ui->port_name_->findText(portName);
SetComboBoxIndex(index, ui->port_name_);
index = m_settings->value(m_keyCtx->parity).toInt();
SetComboBoxIndex(index, ui->parity_);
QString bd = m_settings->value(m_keyCtx->baud_rate).toString();
QString bd = m_settings->value(m_keyCtx->baudRate).toString();
ui->baud_rate_->setCurrentText(bd);
index = m_settings->value(m_keyCtx->data_bits).toInt();
index = m_settings->value(m_keyCtx->dataBits).toInt();
SetComboBoxIndex(index, ui->data_bits_);
index = m_settings->value(m_keyCtx->stop_bits).toInt();
index = m_settings->value(m_keyCtx->stopBits).toInt();
SetComboBoxIndex(index, ui->stop_bits_);
}
void xToolsModbusStudioUi::initSettingsClient()
{
int timeout = m_settings->value(m_keyCtx->client_timeout).toInt();
int timeout = m_settings->value(m_keyCtx->clientTimeout).toInt();
ui->timeout_->setValue(timeout < 100 ? 100 : timeout);
const QString key = m_keyCtx->client_repeat_time;
const QString key = m_keyCtx->clientRepeatTime;
int repeatTimes = m_settings->value(key).toInt();
ui->repeat_time_->setValue(repeatTimes);
}
void xToolsModbusStudioUi::initSettingsServer()
{
bool isBusy = m_settings->value(m_keyCtx->server_is_busy).toBool();
bool isBusy = m_settings->value(m_keyCtx->serverIsBusy).toBool();
ui->device_busy_->setChecked(isBusy);
QString key = m_keyCtx->server_just_listen;
QString key = m_keyCtx->serverJustListen;
bool just_listen = m_settings->value(key).toBool();
ui->listen_only_mode_->setChecked(just_listen);
int address = m_settings->value(m_keyCtx->server_address).toInt();
int address = m_settings->value(m_keyCtx->serverAddress).toInt();
ui->server_address->setValue(address);
}
void xToolsModbusStudioUi::initSettingsClientOperations()
{
int index = m_settings->value(m_keyCtx->function_code).toInt();
int index = m_settings->value(m_keyCtx->functionCode).toInt();
if (index >= 0 && index < ui->function_code_->count()) {
ui->function_code_->setCurrentIndex(index);
}
int address = m_settings->value(m_keyCtx->target_address).toInt();
int address = m_settings->value(m_keyCtx->targetAddress).toInt();
ui->device_address_->setValue(address);
int start = m_settings->value(m_keyCtx->start_address).toInt();
int start = m_settings->value(m_keyCtx->startAddress).toInt();
ui->start_address_->setValue(start);
int number = m_settings->value(m_keyCtx->address_number).toInt();
int number = m_settings->value(m_keyCtx->addressNumber).toInt();
ui->quantity_->setValue(number);
}
void xToolsModbusStudioUi::initSettingsInput()
{
ui->pdu_->clear();
m_settings->beginReadArray(m_keyCtx->send_history);
m_settings->beginReadArray(m_keyCtx->sendHistory);
for (int i = 0; i < 10; i++) {
m_settings->setArrayIndex(i);
QString text = m_settings->value(m_keyCtx->pdu).toString();
@ -392,7 +392,7 @@ void xToolsModbusStudioUi::initSettingsInput()
}
m_settings->endArray();
int index = m_settings->value(m_keyCtx->send_history_index).toInt();
int index = m_settings->value(m_keyCtx->sendHistoryIndex).toInt();
ui->pdu_->setCurrentIndex(index - 1);
}
@ -547,7 +547,7 @@ void xToolsModbusStudioUi::onDeviceTypeChanged()
ui->registersGroupBox->setHidden(false);
}
m_settings->setValue(m_keyCtx->device_index, type);
m_settings->setValue(m_keyCtx->deviceIndex, type);
}
void xToolsModbusStudioUi::onCloseClicked()
@ -612,7 +612,7 @@ void xToolsModbusStudioUi::onPortChanged()
void xToolsModbusStudioUi::onPortNameChanged()
{
m_settings->setValue(m_keyCtx->port_name, ui->port_name_->currentText());
m_settings->setValue(m_keyCtx->portName, ui->port_name_->currentText());
}
void xToolsModbusStudioUi::onParityChanged()
@ -622,17 +622,17 @@ void xToolsModbusStudioUi::onParityChanged()
void xToolsModbusStudioUi::onBaudRateChanged()
{
m_settings->setValue(m_keyCtx->baud_rate, ui->baud_rate_->currentText());
m_settings->setValue(m_keyCtx->baudRate, ui->baud_rate_->currentText());
}
void xToolsModbusStudioUi::onDataBitsChanged()
{
m_settings->setValue(m_keyCtx->data_bits, ui->data_bits_->currentIndex());
m_settings->setValue(m_keyCtx->dataBits, ui->data_bits_->currentIndex());
}
void xToolsModbusStudioUi::onStopBistChanged()
{
m_settings->setValue(m_keyCtx->stop_bits, ui->stop_bits_->currentIndex());
m_settings->setValue(m_keyCtx->stopBits, ui->stop_bits_->currentIndex());
}
void xToolsModbusStudioUi::onInvokeRefresh()
@ -642,54 +642,54 @@ void xToolsModbusStudioUi::onInvokeRefresh()
void xToolsModbusStudioUi::onClientTimeoutChanged()
{
m_settings->setValue(m_keyCtx->client_timeout, ui->timeout_->value());
m_settings->setValue(m_keyCtx->clientTimeout, ui->timeout_->value());
updateClientParameters();
}
void xToolsModbusStudioUi::onClientRepeatTimeChanged()
{
m_settings->setValue(m_keyCtx->client_repeat_time, ui->repeat_time_->value());
m_settings->setValue(m_keyCtx->clientRepeatTime, ui->repeat_time_->value());
updateClientParameters();
}
void xToolsModbusStudioUi::onServerIsBusyChanged()
{
m_settings->setValue(m_keyCtx->server_is_busy, ui->device_busy_->isChecked());
m_settings->setValue(m_keyCtx->serverIsBusy, ui->device_busy_->isChecked());
updateServerParameters();
}
void xToolsModbusStudioUi::onServerJustListenChanged()
{
m_settings->setValue(m_keyCtx->server_just_listen, ui->listen_only_mode_->isChecked());
m_settings->setValue(m_keyCtx->serverJustListen, ui->listen_only_mode_->isChecked());
updateServerParameters();
}
void xToolsModbusStudioUi::onServerAddressChanged()
{
m_settings->setValue(m_keyCtx->server_address, ui->server_address->value());
m_settings->setValue(m_keyCtx->serverAddress, ui->server_address->value());
updateServerParameters();
}
void xToolsModbusStudioUi::onFunctionCodeChanged()
{
m_settings->setValue(m_keyCtx->function_code, ui->function_code_->currentIndex());
m_settings->setValue(m_keyCtx->functionCode, ui->function_code_->currentIndex());
updateClientReadWriteButtonState();
}
void xToolsModbusStudioUi::onTargetAddressChanged()
{
m_settings->setValue(m_keyCtx->target_address, ui->device_address_->value());
m_settings->setValue(m_keyCtx->targetAddress, ui->device_address_->value());
}
void xToolsModbusStudioUi::onStartAddressChanged()
{
m_settings->setValue(m_keyCtx->start_address, ui->start_address_->value());
m_settings->setValue(m_keyCtx->startAddress, ui->start_address_->value());
updateClientTableView();
}
void xToolsModbusStudioUi::onAddressNumberChanged()
{
m_settings->setValue(m_keyCtx->address_number, ui->quantity_->value());
m_settings->setValue(m_keyCtx->addressNumber, ui->quantity_->value());
updateClientTableView();
}
@ -808,8 +808,8 @@ void xToolsModbusStudioUi::onSendClicked()
}
// Update settings data.
int index = m_settings->value(m_keyCtx->send_history_index).toInt();
bool ret = writeSettingsArray(m_keyCtx->send_history,
int index = m_settings->value(m_keyCtx->sendHistoryIndex).toInt();
bool ret = writeSettingsArray(m_keyCtx->sendHistory,
m_keyCtx->pdu,
QString(xToolsByteArrayToHex(pdu, ' ')),
index,
@ -825,7 +825,7 @@ void xToolsModbusStudioUi::onSendClicked()
}
index = index + 1 > MAX_HISTORY_INDEX ? 0 : index + 1;
m_settings->setValue(m_keyCtx->send_history_index, index);
m_settings->setValue(m_keyCtx->sendHistoryIndex, index);
}
void xToolsModbusStudioUi::onDateWritten(QModbusDataUnit::RegisterType table, int address, int size)
@ -1164,14 +1164,14 @@ QTableView *xToolsModbusStudioUi::getTableView(QModbusDataUnit::RegisterType tab
return qobject_cast<QTableView *>(tv);
}
QList<quint16> xToolsModbusStudioUi::getTableValues(QTableView *table_view, int row, int count)
QList<quint16> xToolsModbusStudioUi::getTableValues(QTableView *tableView, int row, int count)
{
if (!table_view) {
if (!tableView) {
qWarning() << "Table view can not be null!";
return QList<quint16>();
}
auto *model = qobject_cast<QStandardItemModel *>(table_view->model());
auto *model = qobject_cast<QStandardItemModel *>(tableView->model());
if (!model) {
qWarning() << "Model can not be null!";
return QList<quint16>();

6
Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.h
View File

@ -24,7 +24,7 @@ namespace Ui {
class xToolsModbusStudioUi;
}
struct SAKModbusUiSettingKeys;
struct xToolsModbusUiSettingKeys;
class xToolsModbusStudioUi : public QWidget
{
Q_OBJECT
@ -40,7 +40,7 @@ private:
QModbusDevice *m_modbusDevice{Q_NULLPTR};
QSettings *m_settings{Q_NULLPTR};
QStandardItemModel *m_registerModel{Q_NULLPTR};
SAKModbusUiSettingKeys *m_keyCtx;
xToolsModbusUiSettingKeys *m_keyCtx;
private:
void initComponents();
@ -121,7 +121,7 @@ private:
QList<quint16> getClientRegisterValue();
QByteArray getClientPdu();
QTableView *getTableView(QModbusDataUnit::RegisterType table);
QList<quint16> getTableValues(QTableView *table_view, int row, int count);
QList<quint16> getTableValues(QTableView *tableView, int row, int count);
void outputModbusReply(QModbusReply *reply, int functionCode);
void outputMessage(const QString &msg,