#include "modbustcpmanager.h" #include #include #include #include #include ModbusTcpManager::ModbusTcpManager(const ModbusConfig &config, QObject *parent) : QObject(parent) , m_config(config) , m_client(nullptr) , m_reply(nullptr) , m_connectTimer(new QTimer(this)) , m_hasCurrentRequest(false) , m_connecting(false) , m_aborting(false) , m_connectAttempts(0) { m_connectTimer->setSingleShot(true); connect(m_connectTimer, &QTimer::timeout, this, &ModbusTcpManager::onConnectTimeout); } ModbusTcpManager::~ModbusTcpManager() { abortAll("Modbus manager is shutting down"); } ModbusConfig ModbusTcpManager::config() const { return m_config; } void ModbusTcpManager::readCoil( int address, const std::function &callback) { enqueue({QModbusDataUnit::Coils, address, 0, false, [callback](bool success, quint16 value, const QString &error) { if (callback) { callback(success, value != 0, error); } }}); } void ModbusTcpManager::readHoldingRegister( int address, const std::function &callback) { enqueue({QModbusDataUnit::HoldingRegisters, address, 0, false, callback}); } void ModbusTcpManager::writeCoil( int address, bool value, const std::function &callback) { enqueue({QModbusDataUnit::Coils, address, static_cast(value ? 1 : 0), true, [callback](bool success, quint16, const QString &error) { if (callback) { callback(success, error); } }}); } void ModbusTcpManager::writeHoldingRegister( int address, quint16 value, const std::function &callback) { enqueue({QModbusDataUnit::HoldingRegisters, address, value, true, [callback](bool success, quint16, const QString &error) { if (callback) { callback(success, error); } }}); } void ModbusTcpManager::abortAll(const QString &reason) { if (m_aborting) { return; } const QString text = reason.isEmpty() ? "Modbus request was canceled" : reason; m_aborting = true; m_connectTimer->stop(); m_connecting = false; if (m_reply) { QModbusReply *reply = m_reply; m_reply = nullptr; reply->disconnect(this); reply->deleteLater(); } if (m_hasCurrentRequest) { const Completion callback = m_currentRequest.callback; m_currentRequest = Request(); m_hasCurrentRequest = false; setError(text); if (callback) { callback(false, 0, text); } } while (!m_requests.isEmpty()) { Request request = m_requests.dequeue(); if (request.callback) { request.callback(false, 0, text); } } if (m_client && m_client->state() != QModbusDevice::UnconnectedState) { m_client->disconnectDevice(); } m_aborting = false; } bool ModbusTcpManager::isBusy() const { return m_hasCurrentRequest || !m_requests.isEmpty() || m_connecting || m_reply; } void ModbusTcpManager::enqueue(const Request &request) { if (m_aborting) { if (request.callback) { request.callback(false, 0, "Modbus request was canceled"); } return; } if (request.address < 0) { if (request.callback) { request.callback(false, 0, "Modbus address must be greater than or equal to 0"); } return; } m_requests.enqueue(request); startNext(); } void ModbusTcpManager::startNext() { if (m_aborting || m_hasCurrentRequest || m_requests.isEmpty()) { return; } m_currentRequest = m_requests.dequeue(); m_hasCurrentRequest = true; m_connectAttempts = 0; ensureConnected(); } void ModbusTcpManager::ensureConnected() { if (m_aborting || !m_hasCurrentRequest) { return; } ensureClient(); if (m_client->state() == QModbusDevice::ConnectedState) { startCurrentRequest(); return; } if (m_connecting) { return; } m_client->setConnectionParameter( QModbusDevice::NetworkAddressParameter, QVariant(m_config.host)); m_client->setConnectionParameter( QModbusDevice::NetworkPortParameter, QVariant(m_config.port)); m_client->setTimeout(m_config.timeoutMs); m_client->setNumberOfRetries(m_config.retryCount); ++m_connectAttempts; m_connecting = true; if (!m_client->connectDevice()) { handleConnectionFailure(m_client->errorString()); return; } m_connectTimer->start(qMax(1, m_config.timeoutMs)); } void ModbusTcpManager::startCurrentRequest() { if (m_aborting || !m_hasCurrentRequest || m_connecting || m_reply) { return; } QModbusDataUnit unit( static_cast( m_currentRequest.registerType), m_currentRequest.address, 1); if (m_currentRequest.write) { unit.setValue(0, m_currentRequest.value); m_reply = m_client->sendWriteRequest(unit, m_config.serverAddress); } else { m_reply = m_client->sendReadRequest(unit, m_config.serverAddress); } if (!m_reply) { finishCurrent(false, 0, m_client->errorString().isEmpty() ? "Failed to create Modbus request" : m_client->errorString()); return; } connect(m_reply, &QModbusReply::finished, this, &ModbusTcpManager::onReplyFinished); } void ModbusTcpManager::finishCurrent(bool success, quint16 value, const QString &error) { if (!m_hasCurrentRequest) { return; } const Completion callback = m_currentRequest.callback; m_currentRequest = Request(); m_hasCurrentRequest = false; if (!success) { setError(error); } else { m_lastErrorText.clear(); } if (callback) { callback(success, value, error); } if (!m_aborting) { startNext(); } } void ModbusTcpManager::handleConnectionFailure(const QString &error) { if (m_aborting) { return; } m_connectTimer->stop(); m_connecting = false; if (m_client && m_client->state() != QModbusDevice::UnconnectedState) { m_client->disconnectDevice(); } const int attempts = qMax(1, m_config.reconnectAttempts + 1); if (m_connectAttempts < attempts) { QTimer::singleShot( qMax(0, m_config.reconnectDelayMs), this, &ModbusTcpManager::ensureConnected); return; } finishCurrent(false, 0, error.isEmpty() ? "Failed to connect to PLC" : error); } void ModbusTcpManager::ensureClient() { if (m_client) { return; } m_client = new QModbusTcpClient(this); connect(m_client, &QModbusClient::stateChanged, this, &ModbusTcpManager::onStateChanged); connect(m_client, &QModbusClient::errorOccurred, this, &ModbusTcpManager::onErrorOccurred); } void ModbusTcpManager::setError(const QString &text) { m_lastErrorText = text; } void ModbusTcpManager::onStateChanged(QModbusDevice::State state) { if (m_aborting) { return; } if (state == QModbusDevice::ConnectedState) { m_connectTimer->stop(); m_connecting = false; startCurrentRequest(); return; } if (state == QModbusDevice::UnconnectedState && m_connecting) { handleConnectionFailure(m_client ? m_client->errorString() : QString()); } } void ModbusTcpManager::onErrorOccurred(QModbusDevice::Error error) { Q_UNUSED(error) if (m_aborting) { return; } if (m_connecting) { handleConnectionFailure(m_client ? m_client->errorString() : QString()); } } void ModbusTcpManager::onReplyFinished() { QModbusReply *reply = qobject_cast(sender()); if (!reply || reply != m_reply) { if (reply) { reply->deleteLater(); } return; } m_reply = nullptr; const bool success = reply->error() == QModbusDevice::NoError; quint16 value = 0; QString error; if (!success) { error = reply->errorString(); } else if (!m_currentRequest.write) { const QModbusDataUnit result = reply->result(); if (result.valueCount() < 1) { error = "Modbus read returned an empty result"; } else { value = result.value(0); } } reply->deleteLater(); if (!error.isEmpty()) { finishCurrent(false, 0, error); return; } finishCurrent(true, value, QString()); } void ModbusTcpManager::onConnectTimeout() { handleConnectionFailure("Modbus TCP connect timeout"); }