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

chore: update files of project

Browse Source
This commit is contained in:
x-tools-author 2024-03-21 10:50:08 +08:00
parent 30d0ef52d2
commit 35a82ee26f
7 changed files with 175 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/MainWindow.cpp
View File

@ -48,7 +48,7 @@
#endif #endif
#ifdef X_TOOLS_IMPORT_MODULE_MODBUS_STUDIO #ifdef X_TOOLS_IMPORT_MODULE_MODBUS_STUDIO
#include "xToolsModbusUi.h" #include "xToolsModbusStudioUi.h"
#endif #endif
#define SAK_QT_CONF (qApp->applicationDirPath() + "/qt.conf") #define SAK_QT_CONF (qApp->applicationDirPath() + "/qt.conf")
@ -647,7 +647,7 @@ void MainWindow::initNav()
QString path = ":/Resources/Icon/IconModbus.svg"; QString path = ":/Resources/Icon/IconModbus.svg";
#ifdef X_TOOLS_IMPORT_MODULE_MODBUS_STUDIO #ifdef X_TOOLS_IMPORT_MODULE_MODBUS_STUDIO
xToolsModbusUi* modbus = new xToolsModbusUi(this); xToolsModbusStudioUi* modbus = new xToolsModbusStudioUi(this);
initNav( initNav(
{&navButtonGroup, xToolsUiInterface::cookedIcon(QIcon(path)), "Modbus Studio", modbus, tb}); {&navButtonGroup, xToolsUiInterface::cookedIcon(QIcon(path)), "Modbus Studio", modbus, tb});
#endif #endif

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

@ -6,7 +6,7 @@
* xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source * xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source
* code directory. * code directory.
**************************************************************************************************/ **************************************************************************************************/
#include "xToolsModbusFactory.h" #include "xToolsModbusStudio.h"
#include <QCoreApplication> #include <QCoreApplication>
#include <QModbusTcpClient> #include <QModbusTcpClient>
@ -19,24 +19,24 @@
#include <QModbusRtuSerialServer> #include <QModbusRtuSerialServer>
#endif #endif
xToolsModbusFactory::xToolsModbusFactory(QObject *parent) xToolsModbusStudio::xToolsModbusStudio(QObject *parent)
: QObject(parent) : QObject(parent)
{} {}
xToolsModbusFactory::~xToolsModbusFactory() {} xToolsModbusStudio::~xToolsModbusStudio() {}
xToolsModbusFactory *xToolsModbusFactory::Instance() xToolsModbusStudio *xToolsModbusStudio::Instance()
{ {
static xToolsModbusFactory *factory = Q_NULLPTR; static xToolsModbusStudio *factory = Q_NULLPTR;
if (!factory) { if (!factory) {
factory = new xToolsModbusFactory(qApp); factory = new xToolsModbusStudio(qApp);
} }
return factory; return factory;
} }
const QString xToolsModbusFactory::TypeName(int type) const QString xToolsModbusStudio::TypeName(int type)
{ {
if (type == kModbusRtuSerialClient) { if (type == kModbusRtuSerialClient) {
return tr("RTU Client"); return tr("RTU Client");
@ -54,7 +54,7 @@ const QString xToolsModbusFactory::TypeName(int type)
return "Unknown"; return "Unknown";
} }
QModbusDevice *xToolsModbusFactory::CreateDevice(int type) QModbusDevice *xToolsModbusStudio::CreateDevice(int type)
{ {
if (type == kModbusRtuSerialClient) { if (type == kModbusRtuSerialClient) {
qCInfo(kLoggingCategory) << "Create rtu serial client."; qCInfo(kLoggingCategory) << "Create rtu serial client.";
@ -84,7 +84,7 @@ QModbusDevice *xToolsModbusFactory::CreateDevice(int type)
return Q_NULLPTR; return Q_NULLPTR;
} }
bool xToolsModbusFactory::IsTcpDevice(QModbusDevice *modbus_device) bool xToolsModbusStudio::IsTcpDevice(QModbusDevice *modbus_device)
{ {
if (modbus_device) { if (modbus_device) {
if (qobject_cast<QModbusTcpClient *>(modbus_device)) { if (qobject_cast<QModbusTcpClient *>(modbus_device)) {
@ -97,7 +97,7 @@ bool xToolsModbusFactory::IsTcpDevice(QModbusDevice *modbus_device)
return false; return false;
} }
bool xToolsModbusFactory::IsRtuSerialDevice(QModbusDevice *modbus_device) bool xToolsModbusStudio::IsRtuSerialDevice(QModbusDevice *modbus_device)
{ {
if (modbus_device) { if (modbus_device) {
#if QT_VERSION >= QT_VERSION_CHECK(6, 2, 0) #if QT_VERSION >= QT_VERSION_CHECK(6, 2, 0)
@ -118,7 +118,7 @@ bool xToolsModbusFactory::IsRtuSerialDevice(QModbusDevice *modbus_device)
return false; return false;
} }
bool xToolsModbusFactory::IsTcpDeviceType(int type) bool xToolsModbusStudio::IsTcpDeviceType(int type)
{ {
bool is_tcp = (type == kModbusTcpClient); bool is_tcp = (type == kModbusTcpClient);
is_tcp |= (type == kModbusTcpServer); is_tcp |= (type == kModbusTcpServer);
@ -126,7 +126,7 @@ bool xToolsModbusFactory::IsTcpDeviceType(int type)
return is_tcp; return is_tcp;
} }
bool xToolsModbusFactory::IsRtuSerialDeviceType(int type) bool xToolsModbusStudio::IsRtuSerialDeviceType(int type)
{ {
bool is_rtu = (type == kModbusRtuSerialClient); bool is_rtu = (type == kModbusRtuSerialClient);
is_rtu |= (type == kModbusRtuSerialServer); is_rtu |= (type == kModbusRtuSerialServer);
@ -134,7 +134,7 @@ bool xToolsModbusFactory::IsRtuSerialDeviceType(int type)
return is_rtu; return is_rtu;
} }
bool xToolsModbusFactory::IsServerDevice(QModbusDevice *modbus_device) bool xToolsModbusStudio::IsServerDevice(QModbusDevice *modbus_device)
{ {
if (modbus_device && qobject_cast<QModbusServer *>(modbus_device)) { if (modbus_device && qobject_cast<QModbusServer *>(modbus_device)) {
return true; return true;
@ -143,7 +143,7 @@ bool xToolsModbusFactory::IsServerDevice(QModbusDevice *modbus_device)
return false; return false;
} }
bool xToolsModbusFactory::IsClientDevice(QModbusDevice *modbus_device) bool xToolsModbusStudio::IsClientDevice(QModbusDevice *modbus_device)
{ {
if (modbus_device && qobject_cast<QModbusClient *>(modbus_device)) { if (modbus_device && qobject_cast<QModbusClient *>(modbus_device)) {
return true; return true;
@ -152,7 +152,7 @@ bool xToolsModbusFactory::IsClientDevice(QModbusDevice *modbus_device)
return false; return false;
} }
bool xToolsModbusFactory::ConnectDeivce(QModbusDevice *modbus_device) bool xToolsModbusStudio::ConnectDeivce(QModbusDevice *modbus_device)
{ {
if (modbus_device) { if (modbus_device) {
return modbus_device->connectDevice(); return modbus_device->connectDevice();
@ -161,7 +161,7 @@ bool xToolsModbusFactory::ConnectDeivce(QModbusDevice *modbus_device)
return false; return false;
} }
bool xToolsModbusFactory::IsConnected(QModbusDevice *modbus_device) bool xToolsModbusStudio::IsConnected(QModbusDevice *modbus_device)
{ {
if (modbus_device) { if (modbus_device) {
if (modbus_device->state() == QModbusDevice::ConnectedState) { if (modbus_device->state() == QModbusDevice::ConnectedState) {
@ -172,7 +172,7 @@ bool xToolsModbusFactory::IsConnected(QModbusDevice *modbus_device)
return false; return false;
} }
bool xToolsModbusFactory::IsValidModbusReply(QModbusReply *reply) bool xToolsModbusStudio::IsValidModbusReply(QModbusReply *reply)
{ {
if (reply && !reply->isFinished()) { if (reply && !reply->isFinished()) {
return true; return true;
@ -181,7 +181,7 @@ bool xToolsModbusFactory::IsValidModbusReply(QModbusReply *reply)
return false; return false;
} }
bool xToolsModbusFactory::SetServerData(QModbusDevice *server, bool xToolsModbusStudio::SetServerData(QModbusDevice *server,
QModbusDataUnit::RegisterType table, QModbusDataUnit::RegisterType table,
int address, int address,
int data, int data,
@ -200,7 +200,7 @@ bool xToolsModbusFactory::SetServerData(QModbusDevice *server,
return is_ok; return is_ok;
} }
QList<quint16> xToolsModbusFactory::GetServerData(QModbusDevice *server, QList<quint16> xToolsModbusStudio::GetServerData(QModbusDevice *server,
QModbusDataUnit::RegisterType table, QModbusDataUnit::RegisterType table,
int address, int address,
int quantity) int quantity)
@ -224,7 +224,7 @@ QList<quint16> xToolsModbusFactory::GetServerData(QModbusDevice *server,
return values; return values;
} }
void xToolsModbusFactory::DeleteModbusDevuce(QModbusDevice **modbus_device) void xToolsModbusStudio::DeleteModbusDevuce(QModbusDevice **modbus_device)
{ {
if (*modbus_device) { if (*modbus_device) {
QModbusServer *server = qobject_cast<QModbusServer *>(*modbus_device); QModbusServer *server = qobject_cast<QModbusServer *>(*modbus_device);
@ -237,7 +237,7 @@ void xToolsModbusFactory::DeleteModbusDevuce(QModbusDevice **modbus_device)
} }
} }
QModbusDevice *xToolsModbusFactory::CreateRtuSerialDevice( QModbusDevice *xToolsModbusStudio::CreateRtuSerialDevice(
int type, const QString &port_name, int parity, int baud_rate, int data_bits, int stop_bits) int type, const QString &port_name, int parity, int baud_rate, int data_bits, int stop_bits)
{ {
QModbusDevice *device = CreateDevice(type); QModbusDevice *device = CreateDevice(type);
@ -257,7 +257,7 @@ QModbusDevice *xToolsModbusFactory::CreateRtuSerialDevice(
return device; return device;
} }
QModbusDevice *xToolsModbusFactory::CreateTcpDevice(int type, QString address, int port) QModbusDevice *xToolsModbusStudio::CreateTcpDevice(int type, QString address, int port)
{ {
QModbusDevice *device = CreateDevice(type); QModbusDevice *device = CreateDevice(type);
if (IsTcpDevice(device)) { if (IsTcpDevice(device)) {
@ -271,7 +271,7 @@ QModbusDevice *xToolsModbusFactory::CreateTcpDevice(int type, QString address, i
return device; return device;
} }
void xToolsModbusFactory::SetClientDeviceParameters(QModbusDevice *client, void xToolsModbusStudio::SetClientDeviceParameters(QModbusDevice *client,
int timeout, int timeout,
int number_of_retries) int number_of_retries)
{ {
@ -286,7 +286,7 @@ void xToolsModbusFactory::SetClientDeviceParameters(QModbusDevice *client,
} }
} }
void xToolsModbusFactory::SetServerDeviceParameters(QModbusDevice *server, void xToolsModbusStudio::SetServerDeviceParameters(QModbusDevice *server,
int address, int address,
bool device_busy, bool device_busy,
bool listen_only_mode) bool listen_only_mode)
@ -303,7 +303,7 @@ void xToolsModbusFactory::SetServerDeviceParameters(QModbusDevice *server,
} }
} }
QModbusReply *xToolsModbusFactory::SendWriteRequest(QModbusDevice *modbus_device, QModbusReply *xToolsModbusStudio::SendWriteRequest(QModbusDevice *modbus_device,
int register_type, int register_type,
int start_address, int start_address,
#if QT_VERSION < QT_VERSION_CHECK(6, 2, 0) #if QT_VERSION < QT_VERSION_CHECK(6, 2, 0)
@ -332,7 +332,7 @@ QModbusReply *xToolsModbusFactory::SendWriteRequest(QModbusDevice *modbus_device
return Q_NULLPTR; return Q_NULLPTR;
} }
QModbusReply *xToolsModbusFactory::SendRawRequest(QModbusDevice *modbus_device, QModbusReply *xToolsModbusStudio::SendRawRequest(QModbusDevice *modbus_device,
int server_address, int server_address,
int function_code, int function_code,
const QByteArray &data) const QByteArray &data)

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

@ -14,7 +14,7 @@
#include <QModbusReply> #include <QModbusReply>
#include <QObject> #include <QObject>
class xToolsModbusFactory : public QObject class xToolsModbusStudio : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
@ -27,11 +27,11 @@ public:
Q_ENUM(ModbusDeviceType) Q_ENUM(ModbusDeviceType)
private: private:
xToolsModbusFactory(QObject *parent = Q_NULLPTR); xToolsModbusStudio(QObject *parent = Q_NULLPTR);
public: public:
~xToolsModbusFactory(); ~xToolsModbusStudio();
static xToolsModbusFactory *Instance(); static xToolsModbusStudio *Instance();
public: public:
const QString TypeName(int type); const QString TypeName(int type);

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

@ -6,8 +6,8 @@
* xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source * xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source
* code directory. * code directory.
**************************************************************************************************/ **************************************************************************************************/
#include "xToolsModbusUi.h" #include "xToolsModbusStudioUi.h"
#include "ui_xToolsModbusUi.h" #include "ui_xToolsModbusStudioUi.h"
#include <QAbstractSocket> #include <QAbstractSocket>
#include <QCheckBox> #include <QCheckBox>
@ -39,7 +39,7 @@
#include <QModbusRtuSerialServer> #include <QModbusRtuSerialServer>
#endif #endif
#include "xToolsModbusFactory.h" #include "xToolsModbusStudio.h"
#include "xToolsSettings.h" #include "xToolsSettings.h"
#define RXCOLOR "green" #define RXCOLOR "green"
@ -97,9 +97,9 @@ public:
} }
}; };
xToolsModbusUi::xToolsModbusUi(QWidget *parent) xToolsModbusStudioUi::xToolsModbusStudioUi(QWidget *parent)
: QWidget{parent} : QWidget{parent}
, ui(new Ui::xToolsModbusUi) , ui(new Ui::xToolsModbusStudioUi)
, modbus_device_(Q_NULLPTR) , modbus_device_(Q_NULLPTR)
, register_model_(Q_NULLPTR) , register_model_(Q_NULLPTR)
, key_ctx_(new SAKModbusUiSettingKeys) , key_ctx_(new SAKModbusUiSettingKeys)
@ -120,12 +120,12 @@ xToolsModbusUi::xToolsModbusUi(QWidget *parent)
UpdateClientReadWriteButtonState(); UpdateClientReadWriteButtonState();
} }
xToolsModbusUi::~xToolsModbusUi() xToolsModbusStudioUi::~xToolsModbusStudioUi()
{ {
delete ui; delete ui;
} }
void xToolsModbusUi::InitComponents() void xToolsModbusStudioUi::InitComponents()
{ {
InitComponentDevices(); InitComponentDevices();
InitComponentAddress(); InitComponentAddress();
@ -140,15 +140,15 @@ void xToolsModbusUi::InitComponents()
InitComponentRegisterTabWidget(); InitComponentRegisterTabWidget();
} }
void xToolsModbusUi::InitComponentDevices() void xToolsModbusStudioUi::InitComponentDevices()
{ {
ui->device_list_->addItem(tr("RtuClient"), xToolsModbusFactory::kModbusRtuSerialClient); ui->device_list_->addItem(tr("RtuClient"), xToolsModbusStudio::kModbusRtuSerialClient);
ui->device_list_->addItem(tr("RtuServer"), xToolsModbusFactory::kModbusRtuSerialServer); ui->device_list_->addItem(tr("RtuServer"), xToolsModbusStudio::kModbusRtuSerialServer);
ui->device_list_->addItem(tr("TcpClient"), xToolsModbusFactory::kModbusTcpClient); ui->device_list_->addItem(tr("TcpClient"), xToolsModbusStudio::kModbusTcpClient);
ui->device_list_->addItem(tr("TcpServer"), xToolsModbusFactory::kModbusTcpServer); ui->device_list_->addItem(tr("TcpServer"), xToolsModbusStudio::kModbusTcpServer);
} }
void xToolsModbusUi::InitComponentAddress() void xToolsModbusStudioUi::InitComponentAddress()
{ {
ui->address_combo_box->clear(); ui->address_combo_box->clear();
QList<QHostAddress> addresses = QNetworkInterface::allAddresses(); QList<QHostAddress> addresses = QNetworkInterface::allAddresses();
@ -159,7 +159,7 @@ void xToolsModbusUi::InitComponentAddress()
} }
} }
void xToolsModbusUi::InitComponentPortName() void xToolsModbusStudioUi::InitComponentPortName()
{ {
ui->port_name_->clear(); ui->port_name_->clear();
QList<QSerialPortInfo> infos = QSerialPortInfo::availablePorts(); QList<QSerialPortInfo> infos = QSerialPortInfo::availablePorts();
@ -168,7 +168,7 @@ void xToolsModbusUi::InitComponentPortName()
} }
} }
void xToolsModbusUi::InitComponnetBaudRate() void xToolsModbusStudioUi::InitComponnetBaudRate()
{ {
ui->baud_rate_->clear(); ui->baud_rate_->clear();
QList<qint32> bds = QSerialPortInfo::standardBaudRates(); QList<qint32> bds = QSerialPortInfo::standardBaudRates();
@ -177,7 +177,7 @@ void xToolsModbusUi::InitComponnetBaudRate()
} }
} }
void xToolsModbusUi::InitComponnetDataBits() void xToolsModbusStudioUi::InitComponnetDataBits()
{ {
ui->data_bits_->clear(); ui->data_bits_->clear();
ui->data_bits_->addItem("8", QSerialPort::Data8); ui->data_bits_->addItem("8", QSerialPort::Data8);
@ -186,7 +186,7 @@ void xToolsModbusUi::InitComponnetDataBits()
ui->data_bits_->addItem("5", QSerialPort::Data5); ui->data_bits_->addItem("5", QSerialPort::Data5);
} }
void xToolsModbusUi::InitComponnetStopBits() void xToolsModbusStudioUi::InitComponnetStopBits()
{ {
ui->stop_bits_->clear(); ui->stop_bits_->clear();
ui->stop_bits_->addItem("1", QSerialPort::OneStop); ui->stop_bits_->addItem("1", QSerialPort::OneStop);
@ -196,7 +196,7 @@ void xToolsModbusUi::InitComponnetStopBits()
ui->stop_bits_->addItem("2", QSerialPort::TwoStop); ui->stop_bits_->addItem("2", QSerialPort::TwoStop);
} }
void xToolsModbusUi::InitComponnetParity() void xToolsModbusStudioUi::InitComponnetParity()
{ {
ui->parity_->clear(); ui->parity_->clear();
ui->parity_->addItem(tr("NoParity"), QSerialPort::NoParity); ui->parity_->addItem(tr("NoParity"), QSerialPort::NoParity);
@ -206,7 +206,7 @@ void xToolsModbusUi::InitComponnetParity()
ui->parity_->addItem(tr("MarkParity"), QSerialPort::MarkParity); ui->parity_->addItem(tr("MarkParity"), QSerialPort::MarkParity);
} }
void xToolsModbusUi::InitComponentFunctionCode() void xToolsModbusStudioUi::InitComponentFunctionCode()
{ {
const QString str0x01 = tr("0x01-ReadCoils"); const QString str0x01 = tr("0x01-ReadCoils");
const QString str0x02 = tr("0x02-ReadDiscreteInputs"); const QString str0x02 = tr("0x02-ReadDiscreteInputs");
@ -236,13 +236,13 @@ void xToolsModbusUi::InitComponentFunctionCode()
ui->function_code_->addItem(str0x10, func0x10); ui->function_code_->addItem(str0x10, func0x10);
} }
void xToolsModbusUi::InitComponentRegisterTableView() void xToolsModbusStudioUi::InitComponentRegisterTableView()
{ {
QTableView *table_view = CreateTableView(1, ui->client_registers_); QTableView *table_view = CreateTableView(1, ui->client_registers_);
register_model_ = qobject_cast<QStandardItemModel *>(table_view->model()); register_model_ = qobject_cast<QStandardItemModel *>(table_view->model());
} }
void xToolsModbusUi::InitComponentInput() void xToolsModbusStudioUi::InitComponentInput()
{ {
QRegularExpression re("([0-9a-fA-F][0-9a-fA-F][ ])*"); QRegularExpression re("([0-9a-fA-F][0-9a-fA-F][ ])*");
QLineEdit *le = ui->pdu_->lineEdit(); QLineEdit *le = ui->pdu_->lineEdit();
@ -251,7 +251,7 @@ void xToolsModbusUi::InitComponentInput()
le->clear(); le->clear();
} }
void xToolsModbusUi::InitComponentRegisterTabWidget() void xToolsModbusStudioUi::InitComponentRegisterTabWidget()
{ {
QTabWidget *tab_widget = ui->server_registers_; QTabWidget *tab_widget = ui->server_registers_;
QStringList titles = QStringList() << tr("Coils") << tr("DiscreteInputs") QStringList titles = QStringList() << tr("Coils") << tr("DiscreteInputs")
@ -263,7 +263,7 @@ void xToolsModbusUi::InitComponentRegisterTabWidget()
} }
} }
void xToolsModbusUi::InitSettings() void xToolsModbusStudioUi::InitSettings()
{ {
InitSettingsDevice(); InitSettingsDevice();
InitSettingsNetwork(); InitSettingsNetwork();
@ -274,7 +274,7 @@ void xToolsModbusUi::InitSettings()
InitSettingsInput(); InitSettingsInput();
} }
void xToolsModbusUi::InitSettingsDevice() void xToolsModbusStudioUi::InitSettingsDevice()
{ {
int deviceIndex = settings_->value(key_ctx_->device_index).toInt(); int deviceIndex = settings_->value(key_ctx_->device_index).toInt();
if (deviceIndex >= 0 && deviceIndex < ui->device_list_->count()) { if (deviceIndex >= 0 && deviceIndex < ui->device_list_->count()) {
@ -282,7 +282,7 @@ void xToolsModbusUi::InitSettingsDevice()
} }
} }
void xToolsModbusUi::InitSettingsNetwork() void xToolsModbusStudioUi::InitSettingsNetwork()
{ {
QString address = settings_->value(key_ctx_->address).toString(); QString address = settings_->value(key_ctx_->address).toString();
ui->address_combo_box->setCurrentText(address); ui->address_combo_box->setCurrentText(address);
@ -295,7 +295,7 @@ void xToolsModbusUi::InitSettingsNetwork()
ui->port_spin_box->setValue(port); ui->port_spin_box->setValue(port);
} }
void xToolsModbusUi::InitSettingsSerialPort() void xToolsModbusStudioUi::InitSettingsSerialPort()
{ {
auto SetComboBoxIndex = [](int index, QComboBox *cb) { auto SetComboBoxIndex = [](int index, QComboBox *cb) {
if (index >= 0 && index < cb->count()) { if (index >= 0 && index < cb->count()) {
@ -320,7 +320,7 @@ void xToolsModbusUi::InitSettingsSerialPort()
SetComboBoxIndex(index, ui->stop_bits_); SetComboBoxIndex(index, ui->stop_bits_);
} }
void xToolsModbusUi::InitSettingsClient() void xToolsModbusStudioUi::InitSettingsClient()
{ {
int timeout = settings_->value(key_ctx_->client_timeout).toInt(); int timeout = settings_->value(key_ctx_->client_timeout).toInt();
ui->timeout_->setValue(timeout < 100 ? 100 : timeout); ui->timeout_->setValue(timeout < 100 ? 100 : timeout);
@ -330,7 +330,7 @@ void xToolsModbusUi::InitSettingsClient()
ui->repeat_time_->setValue(repeatTimes); ui->repeat_time_->setValue(repeatTimes);
} }
void xToolsModbusUi::InitSettingsServer() void xToolsModbusStudioUi::InitSettingsServer()
{ {
bool isBusy = settings_->value(key_ctx_->server_is_busy).toBool(); bool isBusy = settings_->value(key_ctx_->server_is_busy).toBool();
ui->device_busy_->setChecked(isBusy); ui->device_busy_->setChecked(isBusy);
@ -343,7 +343,7 @@ void xToolsModbusUi::InitSettingsServer()
ui->server_address->setValue(address); ui->server_address->setValue(address);
} }
void xToolsModbusUi::InitSettingsClientOperations() void xToolsModbusStudioUi::InitSettingsClientOperations()
{ {
int index = settings_->value(key_ctx_->function_code).toInt(); int index = settings_->value(key_ctx_->function_code).toInt();
if (index >= 0 && index < ui->function_code_->count()) { if (index >= 0 && index < ui->function_code_->count()) {
@ -360,7 +360,7 @@ void xToolsModbusUi::InitSettingsClientOperations()
ui->quantity_->setValue(number); ui->quantity_->setValue(number);
} }
void xToolsModbusUi::InitSettingsInput() void xToolsModbusStudioUi::InitSettingsInput()
{ {
ui->pdu_->clear(); ui->pdu_->clear();
settings_->beginReadArray(key_ctx_->send_history); settings_->beginReadArray(key_ctx_->send_history);
@ -377,7 +377,7 @@ void xToolsModbusUi::InitSettingsInput()
ui->pdu_->setCurrentIndex(index - 1); ui->pdu_->setCurrentIndex(index - 1);
} }
void xToolsModbusUi::InitSignals() void xToolsModbusStudioUi::InitSignals()
{ {
InitSignalsDevice(); InitSignalsDevice();
InitSignalsNetworking(); InitSignalsNetworking();
@ -387,95 +387,95 @@ void xToolsModbusUi::InitSignals()
InitSignalsClientOperations(); InitSignalsClientOperations();
} }
void xToolsModbusUi::InitSignalsDevice() void xToolsModbusStudioUi::InitSignalsDevice()
{ {
connect(ui->device_list_, connect(ui->device_list_,
QOverload<int>::of(&QComboBox::currentIndexChanged), QOverload<int>::of(&QComboBox::currentIndexChanged),
this, this,
&xToolsModbusUi::OnDeviceTypeChanged); &xToolsModbusStudioUi::OnDeviceTypeChanged);
connect(ui->open_button_, &QPushButton::clicked, this, &xToolsModbusUi::OnOpenClicked); connect(ui->open_button_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnOpenClicked);
connect(ui->cloese_button_, &QPushButton::clicked, this, &xToolsModbusUi::OnCloseClicked); connect(ui->cloese_button_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnCloseClicked);
} }
void xToolsModbusUi::InitSignalsNetworking() void xToolsModbusStudioUi::InitSignalsNetworking()
{ {
connect(ui->address_combo_box, connect(ui->address_combo_box,
&QComboBox::currentTextChanged, &QComboBox::currentTextChanged,
this, this,
&xToolsModbusUi::OnAddressChanged); &xToolsModbusStudioUi::OnAddressChanged);
connect(ui->port_spin_box, connect(ui->port_spin_box,
QOverload<int>::of(&QSpinBox::valueChanged), QOverload<int>::of(&QSpinBox::valueChanged),
this, this,
&xToolsModbusUi::OnPortChanged); &xToolsModbusStudioUi::OnPortChanged);
} }
void xToolsModbusUi::InitSignalsSerialPort() void xToolsModbusStudioUi::InitSignalsSerialPort()
{ {
connect(ui->port_name_, &QComboBox::currentTextChanged, this, &xToolsModbusUi::OnPortNameChanged); connect(ui->port_name_, &QComboBox::currentTextChanged, this, &xToolsModbusStudioUi::OnPortNameChanged);
connect(ui->parity_, connect(ui->parity_,
QOverload<int>::of(&QComboBox::currentIndexChanged), QOverload<int>::of(&QComboBox::currentIndexChanged),
this, this,
&xToolsModbusUi::OnParityChanged); &xToolsModbusStudioUi::OnParityChanged);
connect(ui->baud_rate_, &QComboBox::currentTextChanged, this, &xToolsModbusUi::OnBaudRateChanged); connect(ui->baud_rate_, &QComboBox::currentTextChanged, this, &xToolsModbusStudioUi::OnBaudRateChanged);
connect(ui->data_bits_, connect(ui->data_bits_,
QOverload<int>::of(&QComboBox::currentIndexChanged), QOverload<int>::of(&QComboBox::currentIndexChanged),
this, this,
&xToolsModbusUi::OnDataBitsChanged); &xToolsModbusStudioUi::OnDataBitsChanged);
connect(ui->stop_bits_, connect(ui->stop_bits_,
QOverload<int>::of(&QComboBox::currentIndexChanged), QOverload<int>::of(&QComboBox::currentIndexChanged),
this, this,
&xToolsModbusUi::OnStopBistChanged); &xToolsModbusStudioUi::OnStopBistChanged);
} }
void xToolsModbusUi::InitSignalsClient() void xToolsModbusStudioUi::InitSignalsClient()
{ {
connect(ui->timeout_, connect(ui->timeout_,
QOverload<int>::of(&QSpinBox::valueChanged), QOverload<int>::of(&QSpinBox::valueChanged),
this, this,
&xToolsModbusUi::OnClientTimeoutChanged); &xToolsModbusStudioUi::OnClientTimeoutChanged);
connect(ui->repeat_time_, connect(ui->repeat_time_,
QOverload<int>::of(&QSpinBox::valueChanged), QOverload<int>::of(&QSpinBox::valueChanged),
this, this,
&xToolsModbusUi::OnClientRepeatTimeChanged); &xToolsModbusStudioUi::OnClientRepeatTimeChanged);
} }
void xToolsModbusUi::InitSignalsServer() void xToolsModbusStudioUi::InitSignalsServer()
{ {
connect(ui->device_busy_, &QCheckBox::clicked, this, &xToolsModbusUi::OnServerIsBusyChanged); connect(ui->device_busy_, &QCheckBox::clicked, this, &xToolsModbusStudioUi::OnServerIsBusyChanged);
connect(ui->listen_only_mode_, connect(ui->listen_only_mode_,
&QCheckBox::clicked, &QCheckBox::clicked,
this, this,
&xToolsModbusUi::OnServerJustListenChanged); &xToolsModbusStudioUi::OnServerJustListenChanged);
connect(ui->server_address, connect(ui->server_address,
QOverload<int>::of(&QSpinBox::valueChanged), QOverload<int>::of(&QSpinBox::valueChanged),
this, this,
&xToolsModbusUi::OnServerAddressChanged); &xToolsModbusStudioUi::OnServerAddressChanged);
} }
void xToolsModbusUi::InitSignalsClientOperations() void xToolsModbusStudioUi::InitSignalsClientOperations()
{ {
connect(ui->function_code_, connect(ui->function_code_,
&QComboBox::currentTextChanged, &QComboBox::currentTextChanged,
this, this,
&xToolsModbusUi::OnFunctionCodeChanged); &xToolsModbusStudioUi::OnFunctionCodeChanged);
connect(ui->device_address_, connect(ui->device_address_,
QOverload<int>::of(&QSpinBox::valueChanged), QOverload<int>::of(&QSpinBox::valueChanged),
this, this,
&xToolsModbusUi::OnTargetAddressChanged); &xToolsModbusStudioUi::OnTargetAddressChanged);
connect(ui->start_address_, connect(ui->start_address_,
QOverload<int>::of(&QSpinBox::valueChanged), QOverload<int>::of(&QSpinBox::valueChanged),
this, this,
&xToolsModbusUi::OnStartAddressChanged); &xToolsModbusStudioUi::OnStartAddressChanged);
connect(ui->quantity_, connect(ui->quantity_,
QOverload<int>::of(&QSpinBox::valueChanged), QOverload<int>::of(&QSpinBox::valueChanged),
this, this,
&xToolsModbusUi::OnAddressNumberChanged); &xToolsModbusStudioUi::OnAddressNumberChanged);
connect(ui->read_, &QPushButton::clicked, this, &xToolsModbusUi::OnReadClicked); connect(ui->read_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnReadClicked);
connect(ui->write_, &QPushButton::clicked, this, &xToolsModbusUi::OnWriteClicked); connect(ui->write_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnWriteClicked);
connect(ui->send_, &QPushButton::clicked, this, &xToolsModbusUi::OnSendClicked); connect(ui->send_, &QPushButton::clicked, this, &xToolsModbusStudioUi::OnSendClicked);
} }
void xToolsModbusUi::OnErrorOccurred() void xToolsModbusStudioUi::OnErrorOccurred()
{ {
outputMessage(modbus_device_->errorString(), true, "", "error"); outputMessage(modbus_device_->errorString(), true, "", "error");
if (modbus_device_->error() == QModbusDevice::ConnectionError) { if (modbus_device_->error() == QModbusDevice::ConnectionError) {
@ -485,13 +485,13 @@ void xToolsModbusUi::OnErrorOccurred()
} }
} }
void xToolsModbusUi::OnDeviceTypeChanged() void xToolsModbusStudioUi::OnDeviceTypeChanged()
{ {
int type = ui->device_list_->currentData().toInt(); int type = ui->device_list_->currentData().toInt();
bool isSerial = (type == xToolsModbusFactory::kModbusRtuSerialClient bool isSerial = (type == xToolsModbusStudio::kModbusRtuSerialClient
|| type == xToolsModbusFactory::kModbusRtuSerialServer); || type == xToolsModbusStudio::kModbusRtuSerialServer);
bool isClient = (type == xToolsModbusFactory::kModbusRtuSerialClient bool isClient = (type == xToolsModbusStudio::kModbusRtuSerialClient
|| type == xToolsModbusFactory::kModbusTcpClient); || type == xToolsModbusStudio::kModbusTcpClient);
// Hide ui component first then show ui component, // Hide ui component first then show ui component,
// or the window will be resize to the max size of default. // or the window will be resize to the max size of default.
@ -522,20 +522,20 @@ void xToolsModbusUi::OnDeviceTypeChanged()
settings_->setValue(key_ctx_->device_index, type); settings_->setValue(key_ctx_->device_index, type);
} }
void xToolsModbusUi::OnCloseClicked() void xToolsModbusStudioUi::OnCloseClicked()
{ {
xToolsModbusFactory::Instance()->DeleteModbusDevuce(&modbus_device_); xToolsModbusStudio::Instance()->DeleteModbusDevuce(&modbus_device_);
UpdateUiState(false); UpdateUiState(false);
} }
void xToolsModbusUi::OnOpenClicked() void xToolsModbusStudioUi::OnOpenClicked()
{ {
ui->open_button_->setEnabled(false); ui->open_button_->setEnabled(false);
xToolsModbusFactory::Instance()->DeleteModbusDevuce(&modbus_device_); xToolsModbusStudio::Instance()->DeleteModbusDevuce(&modbus_device_);
modbus_device_ = CreateModbusDevice(); modbus_device_ = CreateModbusDevice();
if (xToolsModbusFactory::Instance()->IsServerDevice(modbus_device_)) { if (xToolsModbusStudio::Instance()->IsServerDevice(modbus_device_)) {
if (!UpdateServerMap(modbus_device_)) { if (!UpdateServerMap(modbus_device_)) {
ui->open_button_->setEnabled(true); ui->open_button_->setEnabled(true);
qCWarning(kLoggingCategory) << "Can not reset server map!"; qCWarning(kLoggingCategory) << "Can not reset server map!";
@ -546,8 +546,8 @@ void xToolsModbusUi::OnOpenClicked()
QModbusServer *server = qobject_cast<QModbusServer *>(modbus_device_); QModbusServer *server = qobject_cast<QModbusServer *>(modbus_device_);
UpdateServerRegistersData(); UpdateServerRegistersData();
connect(server, &QModbusServer::dataWritten, this, &xToolsModbusUi::OnDateWritten); connect(server, &QModbusServer::dataWritten, this, &xToolsModbusStudioUi::OnDateWritten);
} else if (xToolsModbusFactory::Instance()->IsClientDevice(modbus_device_)) { } else if (xToolsModbusStudio::Instance()->IsClientDevice(modbus_device_)) {
UpdateClientParameters(); UpdateClientParameters();
} else { } else {
ui->open_button_->setEnabled(true); ui->open_button_->setEnabled(true);
@ -555,8 +555,8 @@ void xToolsModbusUi::OnOpenClicked()
return; return;
} }
connect(modbus_device_, &QModbusDevice::errorOccurred, this, &xToolsModbusUi::OnErrorOccurred); connect(modbus_device_, &QModbusDevice::errorOccurred, this, &xToolsModbusStudioUi::OnErrorOccurred);
xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); xToolsModbusStudio *factory = xToolsModbusStudio::Instance();
bool connected = factory->ConnectDeivce(modbus_device_); bool connected = factory->ConnectDeivce(modbus_device_);
if (!connected) { if (!connected) {
QString errStr = modbus_device_->errorString(); QString errStr = modbus_device_->errorString();
@ -569,106 +569,106 @@ void xToolsModbusUi::OnOpenClicked()
UpdateUiState(connected); UpdateUiState(connected);
} }
void xToolsModbusUi::OnAddressChanged() void xToolsModbusStudioUi::OnAddressChanged()
{ {
settings_->setValue(key_ctx_->address, ui->address_combo_box->currentText()); settings_->setValue(key_ctx_->address, ui->address_combo_box->currentText());
} }
void xToolsModbusUi::OnPortChanged() void xToolsModbusStudioUi::OnPortChanged()
{ {
settings_->setValue(key_ctx_->port, ui->port_spin_box->value()); settings_->setValue(key_ctx_->port, ui->port_spin_box->value());
} }
void xToolsModbusUi::OnPortNameChanged() void xToolsModbusStudioUi::OnPortNameChanged()
{ {
settings_->setValue(key_ctx_->port_name, ui->port_name_->currentText()); settings_->setValue(key_ctx_->port_name, ui->port_name_->currentText());
} }
void xToolsModbusUi::OnParityChanged() void xToolsModbusStudioUi::OnParityChanged()
{ {
settings_->setValue(key_ctx_->parity, ui->parity_->currentIndex()); settings_->setValue(key_ctx_->parity, ui->parity_->currentIndex());
} }
void xToolsModbusUi::OnBaudRateChanged() void xToolsModbusStudioUi::OnBaudRateChanged()
{ {
settings_->setValue(key_ctx_->baud_rate, ui->baud_rate_->currentText()); settings_->setValue(key_ctx_->baud_rate, ui->baud_rate_->currentText());
} }
void xToolsModbusUi::OnDataBitsChanged() void xToolsModbusStudioUi::OnDataBitsChanged()
{ {
settings_->setValue(key_ctx_->data_bits, ui->data_bits_->currentIndex()); settings_->setValue(key_ctx_->data_bits, ui->data_bits_->currentIndex());
} }
void xToolsModbusUi::OnStopBistChanged() void xToolsModbusStudioUi::OnStopBistChanged()
{ {
settings_->setValue(key_ctx_->stop_bits, ui->stop_bits_->currentIndex()); settings_->setValue(key_ctx_->stop_bits, ui->stop_bits_->currentIndex());
} }
void xToolsModbusUi::OnInvokeRefresh() void xToolsModbusStudioUi::OnInvokeRefresh()
{ {
InitComponentPortName(); InitComponentPortName();
} }
void xToolsModbusUi::OnClientTimeoutChanged() void xToolsModbusStudioUi::OnClientTimeoutChanged()
{ {
settings_->setValue(key_ctx_->client_timeout, ui->timeout_->value()); settings_->setValue(key_ctx_->client_timeout, ui->timeout_->value());
UpdateClientParameters(); UpdateClientParameters();
} }
void xToolsModbusUi::OnClientRepeatTimeChanged() void xToolsModbusStudioUi::OnClientRepeatTimeChanged()
{ {
settings_->setValue(key_ctx_->client_repeat_time, ui->repeat_time_->value()); settings_->setValue(key_ctx_->client_repeat_time, ui->repeat_time_->value());
UpdateClientParameters(); UpdateClientParameters();
} }
void xToolsModbusUi::OnServerIsBusyChanged() void xToolsModbusStudioUi::OnServerIsBusyChanged()
{ {
settings_->setValue(key_ctx_->server_is_busy, ui->device_busy_->isChecked()); settings_->setValue(key_ctx_->server_is_busy, ui->device_busy_->isChecked());
UpdateServerParameters(); UpdateServerParameters();
} }
void xToolsModbusUi::OnServerJustListenChanged() void xToolsModbusStudioUi::OnServerJustListenChanged()
{ {
settings_->setValue(key_ctx_->server_just_listen, ui->listen_only_mode_->isChecked()); settings_->setValue(key_ctx_->server_just_listen, ui->listen_only_mode_->isChecked());
UpdateServerParameters(); UpdateServerParameters();
} }
void xToolsModbusUi::OnServerAddressChanged() void xToolsModbusStudioUi::OnServerAddressChanged()
{ {
settings_->setValue(key_ctx_->server_address, ui->server_address->value()); settings_->setValue(key_ctx_->server_address, ui->server_address->value());
UpdateServerParameters(); UpdateServerParameters();
} }
void xToolsModbusUi::OnFunctionCodeChanged() void xToolsModbusStudioUi::OnFunctionCodeChanged()
{ {
settings_->setValue(key_ctx_->function_code, ui->function_code_->currentIndex()); settings_->setValue(key_ctx_->function_code, ui->function_code_->currentIndex());
UpdateClientReadWriteButtonState(); UpdateClientReadWriteButtonState();
} }
void xToolsModbusUi::OnTargetAddressChanged() void xToolsModbusStudioUi::OnTargetAddressChanged()
{ {
settings_->setValue(key_ctx_->target_address, ui->device_address_->value()); settings_->setValue(key_ctx_->target_address, ui->device_address_->value());
} }
void xToolsModbusUi::OnStartAddressChanged() void xToolsModbusStudioUi::OnStartAddressChanged()
{ {
settings_->setValue(key_ctx_->start_address, ui->start_address_->value()); settings_->setValue(key_ctx_->start_address, ui->start_address_->value());
UpdateClientTableView(); UpdateClientTableView();
} }
void xToolsModbusUi::OnAddressNumberChanged() void xToolsModbusStudioUi::OnAddressNumberChanged()
{ {
settings_->setValue(key_ctx_->address_number, ui->quantity_->value()); settings_->setValue(key_ctx_->address_number, ui->quantity_->value());
UpdateClientTableView(); UpdateClientTableView();
} }
void xToolsModbusUi::OnReadClicked() void xToolsModbusStudioUi::OnReadClicked()
{ {
if (!IsConnected()) { if (!IsConnected()) {
return; return;
} }
if (!xToolsModbusFactory::Instance()->IsClientDevice(modbus_device_)) { if (!xToolsModbusStudio::Instance()->IsClientDevice(modbus_device_)) {
return; return;
} }
@ -688,7 +688,7 @@ void xToolsModbusUi::OnReadClicked()
QModbusDataUnit data_unit(type, start_address, quantity); QModbusDataUnit data_unit(type, start_address, quantity);
QModbusClient *client = qobject_cast<QModbusClient *>(modbus_device_); QModbusClient *client = qobject_cast<QModbusClient *>(modbus_device_);
QModbusReply *reply = client->sendReadRequest(data_unit, server_address); QModbusReply *reply = client->sendReadRequest(data_unit, server_address);
if (!xToolsModbusFactory::Instance()->IsValidModbusReply(reply)) { if (!xToolsModbusStudio::Instance()->IsValidModbusReply(reply)) {
return; return;
} }
@ -704,7 +704,7 @@ void xToolsModbusUi::OnReadClicked()
}); });
} }
void xToolsModbusUi::OnWriteClicked() void xToolsModbusStudioUi::OnWriteClicked()
{ {
if (!IsConnected()) { if (!IsConnected()) {
return; return;
@ -715,13 +715,13 @@ void xToolsModbusUi::OnWriteClicked()
int server_address = ui->device_address_->value(); int server_address = ui->device_address_->value();
quint8 function_code = GetClientFunctionCode(); quint8 function_code = GetClientFunctionCode();
QList<quint16> values = GetClientRegisterValue(); QList<quint16> values = GetClientRegisterValue();
xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); xToolsModbusStudio *factory = xToolsModbusStudio::Instance();
QModbusReply *reply = factory->SendWriteRequest(modbus_device_, QModbusReply *reply = factory->SendWriteRequest(modbus_device_,
registerType, registerType,
start_address, start_address,
values, values,
server_address); server_address);
if (xToolsModbusFactory::Instance()->IsValidModbusReply(reply)) { if (xToolsModbusStudio::Instance()->IsValidModbusReply(reply)) {
connect(reply, &QModbusReply::finished, this, [=]() { connect(reply, &QModbusReply::finished, this, [=]() {
OutputModbusReply(reply, function_code); OutputModbusReply(reply, function_code);
reply->deleteLater(); reply->deleteLater();
@ -732,7 +732,7 @@ void xToolsModbusUi::OnWriteClicked()
} }
} }
void xToolsModbusUi::OnSendClicked() void xToolsModbusStudioUi::OnSendClicked()
{ {
if (!IsConnected()) { if (!IsConnected()) {
return; return;
@ -749,7 +749,7 @@ void xToolsModbusUi::OnSendClicked()
if (!pdu.isEmpty()) { if (!pdu.isEmpty()) {
function_code = pdu.at(0); function_code = pdu.at(0);
} }
xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); xToolsModbusStudio *factory = xToolsModbusStudio::Instance();
QModbusReply *reply = factory->SendRawRequest(modbus_device_, QModbusReply *reply = factory->SendRawRequest(modbus_device_,
server_address, server_address,
function_code, function_code,
@ -759,7 +759,7 @@ void xToolsModbusUi::OnSendClicked()
<< "server address:" << server_address << "server address:" << server_address
<< "function code:" << function_code << "function code:" << function_code
<< "data:" << QString(pdu.toHex(' ')); << "data:" << QString(pdu.toHex(' '));
if (xToolsModbusFactory::Instance()->IsValidModbusReply(reply)) { if (xToolsModbusStudio::Instance()->IsValidModbusReply(reply)) {
connect(reply, &QModbusReply::finished, this, [=]() { connect(reply, &QModbusReply::finished, this, [=]() {
OutputModbusReply(reply, function_code); OutputModbusReply(reply, function_code);
reply->deleteLater(); reply->deleteLater();
@ -791,14 +791,14 @@ void xToolsModbusUi::OnSendClicked()
settings_->setValue(key_ctx_->send_history_index, index); settings_->setValue(key_ctx_->send_history_index, index);
} }
void xToolsModbusUi::OnDateWritten(QModbusDataUnit::RegisterType table, int address, int size) void xToolsModbusStudioUi::OnDateWritten(QModbusDataUnit::RegisterType table, int address, int size)
{ {
qCInfo(kLoggingCategory) << "Data written:" qCInfo(kLoggingCategory) << "Data written:"
<< "table:" << table << "start address:" << address << "size:" << size; << "table:" << table << "start address:" << address << "size:" << size;
QTableView *tv = GetTableView(table); QTableView *tv = GetTableView(table);
QStandardItemModel *model = qobject_cast<QStandardItemModel *>(tv->model()); QStandardItemModel *model = qobject_cast<QStandardItemModel *>(tv->model());
QModbusServer *server = qobject_cast<QModbusServer *>(modbus_device_); QModbusServer *server = qobject_cast<QModbusServer *>(modbus_device_);
QList<quint16> data = xToolsModbusFactory::Instance()->GetServerData(server, table, address, size); QList<quint16> data = xToolsModbusStudio::Instance()->GetServerData(server, table, address, size);
size = qMin<int>(data.count(), size); size = qMin<int>(data.count(), size);
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
int row = address + i; int row = address + i;
@ -817,7 +817,7 @@ void xToolsModbusUi::OnDateWritten(QModbusDataUnit::RegisterType table, int addr
tv->viewport()->update(); tv->viewport()->update();
} }
void xToolsModbusUi::OnItemChanged(QStandardItem *item) void xToolsModbusStudioUi::OnItemChanged(QStandardItem *item)
{ {
if (!item) { if (!item) {
return; return;
@ -827,7 +827,7 @@ void xToolsModbusUi::OnItemChanged(QStandardItem *item)
return; return;
} }
if (xToolsModbusFactory::Instance()->IsServerDevice(modbus_device_)) { if (xToolsModbusStudio::Instance()->IsServerDevice(modbus_device_)) {
int address = item->row(); int address = item->row();
int current_index = ui->server_registers_->currentIndex(); int current_index = ui->server_registers_->currentIndex();
QModbusDataUnit::RegisterType table = QModbusDataUnit::Invalid; QModbusDataUnit::RegisterType table = QModbusDataUnit::Invalid;
@ -845,31 +845,31 @@ void xToolsModbusUi::OnItemChanged(QStandardItem *item)
} }
quint16 value = item->text().toInt(Q_NULLPTR, 16); quint16 value = item->text().toInt(Q_NULLPTR, 16);
xToolsModbusFactory::Instance()->SetServerData(modbus_device_, table, address, value); xToolsModbusStudio::Instance()->SetServerData(modbus_device_, table, address, value);
} }
} }
QModbusDevice *xToolsModbusUi::CreateModbusDevice() QModbusDevice *xToolsModbusStudioUi::CreateModbusDevice()
{ {
QModbusDevice *device = Q_NULLPTR; QModbusDevice *device = Q_NULLPTR;
int type = ui->device_list_->currentData().toInt(); int type = ui->device_list_->currentData().toInt();
if (xToolsModbusFactory::Instance()->IsRtuSerialDeviceType(type)) { if (xToolsModbusStudio::Instance()->IsRtuSerialDeviceType(type)) {
QString port_name = ui->port_name_->currentText(); QString port_name = ui->port_name_->currentText();
int parity = ui->parity_->currentData().toInt(); int parity = ui->parity_->currentData().toInt();
int baud_rate = ui->baud_rate_->currentData().toInt(); int baud_rate = ui->baud_rate_->currentData().toInt();
int data_bits = ui->data_bits_->currentData().toInt(); int data_bits = ui->data_bits_->currentData().toInt();
int stop_bits = ui->stop_bits_->currentData().toInt(); int stop_bits = ui->stop_bits_->currentData().toInt();
xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); xToolsModbusStudio *factory = xToolsModbusStudio::Instance();
device = factory->CreateRtuSerialDevice(type, device = factory->CreateRtuSerialDevice(type,
port_name, port_name,
parity, parity,
baud_rate, baud_rate,
data_bits, data_bits,
stop_bits); stop_bits);
} else if (xToolsModbusFactory::Instance()->IsTcpDeviceType(type)) { } else if (xToolsModbusStudio::Instance()->IsTcpDeviceType(type)) {
QString address = ui->address_combo_box->currentText(); QString address = ui->address_combo_box->currentText();
int port = ui->port_spin_box->value(); int port = ui->port_spin_box->value();
xToolsModbusFactory *factory = xToolsModbusFactory::Instance(); xToolsModbusStudio *factory = xToolsModbusStudio::Instance();
device = factory->CreateTcpDevice(type, address, port); device = factory->CreateTcpDevice(type, address, port);
} else { } else {
Q_ASSERT_X(false, __FUNCTION__, "Unknown device type"); Q_ASSERT_X(false, __FUNCTION__, "Unknown device type");
@ -878,7 +878,7 @@ QModbusDevice *xToolsModbusUi::CreateModbusDevice()
return device; return device;
} }
QTableView *xToolsModbusUi::CreateTableView(int row_count, QTableView *table_view) QTableView *xToolsModbusStudioUi::CreateTableView(int row_count, QTableView *table_view)
{ {
if (!table_view) { if (!table_view) {
table_view = new QTableView(this); table_view = new QTableView(this);
@ -909,12 +909,12 @@ QTableView *xToolsModbusUi::CreateTableView(int row_count, QTableView *table_vie
} }
model->blockSignals(false); model->blockSignals(false);
connect(model, &QStandardItemModel::itemChanged, this, &xToolsModbusUi::OnItemChanged); connect(model, &QStandardItemModel::itemChanged, this, &xToolsModbusStudioUi::OnItemChanged);
return table_view; return table_view;
} }
void xToolsModbusUi::UpdateUiState(bool connected) void xToolsModbusStudioUi::UpdateUiState(bool connected)
{ {
ui->device_list_->setEnabled(!connected); ui->device_list_->setEnabled(!connected);
ui->cloese_button_->setEnabled(connected); ui->cloese_button_->setEnabled(connected);
@ -927,7 +927,7 @@ void xToolsModbusUi::UpdateUiState(bool connected)
#endif #endif
} }
void xToolsModbusUi::UpdateClientTableView() void xToolsModbusStudioUi::UpdateClientTableView()
{ {
int number = ui->quantity_->value(); int number = ui->quantity_->value();
int rowCount = register_model_->rowCount(); int rowCount = register_model_->rowCount();
@ -942,7 +942,7 @@ void xToolsModbusUi::UpdateClientTableView()
UpdateClientTableViewAddress(ui->client_registers_, start_address); UpdateClientTableViewAddress(ui->client_registers_, start_address);
} }
void xToolsModbusUi::UpdateClientTableViewData(const QList<quint16> &values) void xToolsModbusStudioUi::UpdateClientTableViewData(const QList<quint16> &values)
{ {
for (int row = 0; row < values.count(); row++) { for (int row = 0; row < values.count(); row++) {
int value = values.at(row); int value = values.at(row);
@ -961,7 +961,7 @@ void xToolsModbusUi::UpdateClientTableViewData(const QList<quint16> &values)
ui->client_registers_->viewport()->update(); ui->client_registers_->viewport()->update();
} }
void xToolsModbusUi::UpdateClientReadWriteButtonState() void xToolsModbusStudioUi::UpdateClientReadWriteButtonState()
{ {
QStringList list = ui->function_code_->currentText().split('-'); QStringList list = ui->function_code_->currentText().split('-');
int code = list.length() ? list.first().toInt(Q_NULLPTR, 16) : 0; int code = list.length() ? list.first().toInt(Q_NULLPTR, 16) : 0;
@ -978,14 +978,14 @@ void xToolsModbusUi::UpdateClientReadWriteButtonState()
ui->write_->setEnabled(!is_reading_operation); ui->write_->setEnabled(!is_reading_operation);
} }
void xToolsModbusUi::UpdateClientParameters() void xToolsModbusStudioUi::UpdateClientParameters()
{ {
int timeout = ui->timeout_->value(); int timeout = ui->timeout_->value();
int repeat_time = ui->repeat_time_->value(); int repeat_time = ui->repeat_time_->value();
xToolsModbusFactory::Instance()->SetClientDeviceParameters(modbus_device_, timeout, repeat_time); xToolsModbusStudio::Instance()->SetClientDeviceParameters(modbus_device_, timeout, repeat_time);
} }
void xToolsModbusUi::UpdateClientTableViewAddress(QTableView *view, int start_address) void xToolsModbusStudioUi::UpdateClientTableViewAddress(QTableView *view, int start_address)
{ {
auto *model = qobject_cast<QStandardItemModel *>(view->model()); auto *model = qobject_cast<QStandardItemModel *>(view->model());
for (int row = 0; row < model->rowCount(); row++) { for (int row = 0; row < model->rowCount(); row++) {
@ -1003,18 +1003,18 @@ void xToolsModbusUi::UpdateClientTableViewAddress(QTableView *view, int start_ad
} }
} }
void xToolsModbusUi::UpdateServerParameters() void xToolsModbusStudioUi::UpdateServerParameters()
{ {
bool device_busy = ui->device_busy_->isChecked(); bool device_busy = ui->device_busy_->isChecked();
bool listen_only_mode = ui->listen_only_mode_->isChecked(); bool listen_only_mode = ui->listen_only_mode_->isChecked();
int address = ui->server_address->value(); int address = ui->server_address->value();
xToolsModbusFactory::Instance()->SetServerDeviceParameters(modbus_device_, xToolsModbusStudio::Instance()->SetServerDeviceParameters(modbus_device_,
address, address,
device_busy, device_busy,
listen_only_mode); listen_only_mode);
} }
bool xToolsModbusUi::UpdateServerMap(QModbusDevice *server) bool xToolsModbusStudioUi::UpdateServerMap(QModbusDevice *server)
{ {
if (server && qobject_cast<QModbusServer *>(server)) { if (server && qobject_cast<QModbusServer *>(server)) {
QVector<quint16> values(UINT16_MAX + 1, 0); QVector<quint16> values(UINT16_MAX + 1, 0);
@ -1036,7 +1036,7 @@ bool xToolsModbusUi::UpdateServerMap(QModbusDevice *server)
return false; return false;
} }
void xToolsModbusUi::UpdateServerRegistersData() void xToolsModbusStudioUi::UpdateServerRegistersData()
{ {
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
QWidget *widget = ui->server_registers_->widget(i); QWidget *widget = ui->server_registers_->widget(i);
@ -1060,12 +1060,12 @@ void xToolsModbusUi::UpdateServerRegistersData()
QStandardItem *item = model->item(row, 1); QStandardItem *item = model->item(row, 1);
quint16 value = item ? item->text().toInt(Q_NULLPTR, 16) : 0; quint16 value = item ? item->text().toInt(Q_NULLPTR, 16) : 0;
auto table = static_cast<QModbusDataUnit::RegisterType>(type); auto table = static_cast<QModbusDataUnit::RegisterType>(type);
xToolsModbusFactory::Instance()->SetServerData(modbus_device_, table, row, value, false); xToolsModbusStudio::Instance()->SetServerData(modbus_device_, table, row, value, false);
} }
} }
} }
quint8 xToolsModbusUi::GetClientFunctionCode() quint8 xToolsModbusStudioUi::GetClientFunctionCode()
{ {
QString txt = ui->function_code_->currentText(); QString txt = ui->function_code_->currentText();
QStringList list = txt.split('-', Qt::SkipEmptyParts); QStringList list = txt.split('-', Qt::SkipEmptyParts);
@ -1076,7 +1076,7 @@ quint8 xToolsModbusUi::GetClientFunctionCode()
return 0; return 0;
} }
QList<quint16> xToolsModbusUi::GetClientRegisterValue() QList<quint16> xToolsModbusStudioUi::GetClientRegisterValue()
{ {
QList<quint16> values; QList<quint16> values;
for (int row = 0; row < register_model_->rowCount(); row++) { for (int row = 0; row < register_model_->rowCount(); row++) {
@ -1092,7 +1092,7 @@ QList<quint16> xToolsModbusUi::GetClientRegisterValue()
return values; return values;
} }
QByteArray xToolsModbusUi::GetClientPdu() QByteArray xToolsModbusStudioUi::GetClientPdu()
{ {
QString text = ui->pdu_->currentText(); QString text = ui->pdu_->currentText();
#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0) #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
@ -1108,7 +1108,7 @@ QByteArray xToolsModbusUi::GetClientPdu()
return data; return data;
} }
QTableView *xToolsModbusUi::GetTableView(QModbusDataUnit::RegisterType table) QTableView *xToolsModbusStudioUi::GetTableView(QModbusDataUnit::RegisterType table)
{ {
QWidget *tv = Q_NULLPTR; QWidget *tv = Q_NULLPTR;
if (table == QModbusDataUnit::Coils) { if (table == QModbusDataUnit::Coils) {
@ -1127,7 +1127,7 @@ QTableView *xToolsModbusUi::GetTableView(QModbusDataUnit::RegisterType table)
return qobject_cast<QTableView *>(tv); return qobject_cast<QTableView *>(tv);
} }
QList<quint16> xToolsModbusUi::GetTableValues(QTableView *table_view, int row, int count) QList<quint16> xToolsModbusStudioUi::GetTableValues(QTableView *table_view, int row, int count)
{ {
if (!table_view) { if (!table_view) {
qCWarning(kLoggingCategory) << "Table view can not be null!"; qCWarning(kLoggingCategory) << "Table view can not be null!";
@ -1154,7 +1154,7 @@ QList<quint16> xToolsModbusUi::GetTableValues(QTableView *table_view, int row, i
return values; return values;
} }
void xToolsModbusUi::OutputModbusReply(QModbusReply *reply, int function_code) void xToolsModbusStudioUi::OutputModbusReply(QModbusReply *reply, int function_code)
{ {
if (reply->error() != QModbusDevice::NoError) { if (reply->error() != QModbusDevice::NoError) {
outputMessage(reply->errorString(), true, "", "error"); outputMessage(reply->errorString(), true, "", "error");
@ -1178,7 +1178,7 @@ void xToolsModbusUi::OutputModbusReply(QModbusReply *reply, int function_code)
} }
} }
void xToolsModbusUi::outputMessage(const QString &msg, void xToolsModbusStudioUi::outputMessage(const QString &msg,
bool isError, bool isError,
const QString &color, const QString &color,
const QString &flag) const QString &flag)
@ -1201,9 +1201,9 @@ void xToolsModbusUi::outputMessage(const QString &msg,
ui->text_browser_->append(cookedMsg); ui->text_browser_->append(cookedMsg);
} }
bool xToolsModbusUi::IsConnected() bool xToolsModbusStudioUi::IsConnected()
{ {
if (xToolsModbusFactory::Instance()->IsConnected(modbus_device_)) { if (xToolsModbusStudio::Instance()->IsConnected(modbus_device_)) {
return true; return true;
} }
@ -1214,7 +1214,7 @@ bool xToolsModbusUi::IsConnected()
return false; return false;
} }
bool xToolsModbusUi::WriteSettingsArray( bool xToolsModbusStudioUi::WriteSettingsArray(
const QString &group, const QString &key, const QString &value, int index, int max_index) const QString &group, const QString &key, const QString &value, int index, int max_index)
{ {
settings_->beginWriteArray(group); settings_->beginWriteArray(group);

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

@ -21,22 +21,22 @@
#include <QWidget> #include <QWidget>
namespace Ui { namespace Ui {
class xToolsModbusUi; class xToolsModbusStudioUi;
} }
struct SAKModbusUiSettingKeys; struct SAKModbusUiSettingKeys;
class xToolsModbusUi : public QWidget class xToolsModbusStudioUi : public QWidget
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit xToolsModbusUi(QWidget *parent = Q_NULLPTR); explicit xToolsModbusStudioUi(QWidget *parent = Q_NULLPTR);
~xToolsModbusUi(); ~xToolsModbusStudioUi();
signals: signals:
void deviceChanged(QModbusDevice *device); void deviceChanged(QModbusDevice *device);
private: private:
Ui::xToolsModbusUi *ui; Ui::xToolsModbusStudioUi *ui;
QModbusDevice *modbus_device_{Q_NULLPTR}; QModbusDevice *modbus_device_{Q_NULLPTR};
QSettings *settings_{Q_NULLPTR}; QSettings *settings_{Q_NULLPTR};
QStandardItemModel *register_model_{Q_NULLPTR}; QStandardItemModel *register_model_{Q_NULLPTR};

4
Source/ModbusStudio/ModbusStudioUI/xToolsModbusStudioUi.ui
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0"> <ui version="4.0">
<class>xToolsModbusUi</class> <class>xToolsModbusStudioUi</class>
<widget class="QWidget" name="xToolsModbusUi"> <widget class="QWidget" name="xToolsModbusStudioUi">
<property name="geometry"> <property name="geometry">
<rect> <rect>
<x>0</x> <x>0</x>

4
Source/ModbusStudio/main.cpp
View File

@ -6,11 +6,11 @@
* xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source * xTools is licensed according to the terms in the file LICENCE(GPL V3) in the root of the source
* code directory. * code directory.
**************************************************************************************************/ **************************************************************************************************/
#include "xToolsModbusUi.h" #include "xToolsModbusStudioUi.h"
#include "xToolsUi.h" #include "xToolsUi.h"
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
const QString appName = QObject::tr("Modbus Studio"); const QString appName = QObject::tr("Modbus Studio");
return xToolsExec<xToolsModbusUi>(argc, argv, appName); return xToolsExec<xToolsModbusStudioUi>(argc, argv, appName);
} }