#include "modbustcpmanager.h" #include #include #include #include #include #include #include #include namespace { const int RRegisterBase = 0x3000; const int MaxRRealAddress = 32766; bool isValidRRealAddress(int address) { return address >= 0 && address <= MaxRRealAddress && address % 2 == 0; } } static_assert(sizeof(float) == sizeof(quint32), "R REAL requires a 32-bit float"); 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, 1, {}, false, [callback](bool success, const QVector &values, const QString &error) { if (callback) { callback(success, success && values.first() != 0, error); } }}); } void ModbusTcpManager::readCoils( int startAddress, quint16 count, const std::function &, const QString &)> &callback, bool visionRequest) { if (count == 0 || count > 2000) { if (callback) { callback(false, {}, "Modbus coil count must be between 1 and 2000"); } return; } if (startAddress < 0 || startAddress > 0xffff || static_cast(startAddress) + count > 0x10000u) { if (callback) { callback(false, {}, "Modbus coil address range is invalid"); } return; } Request request(QModbusDataUnit::Coils, startAddress, count, {}, false, [callback](bool success, const QVector &values, const QString &error) { if (!callback) { return; } QVector coils; if (success) { coils.reserve(values.size()); for (quint16 value : values) { coils.append(value != 0); } } callback(success, coils, error); }); request.vision = visionRequest; enqueue(request); } void ModbusTcpManager::readHoldingRegister( int address, const std::function &callback) { enqueue({QModbusDataUnit::HoldingRegisters, address, 1, {}, false, [callback](bool success, const QVector &values, const QString &error) { if (callback) { callback(success, success ? values.first() : 0, error); } }}); } void ModbusTcpManager::writeCoil( int address, bool value, const std::function &callback) { enqueue({QModbusDataUnit::Coils, address, 1, {static_cast(value ? 1 : 0)}, true, [callback](bool success, const QVector &, const QString &error) { if (callback) { callback(success, error); } }}); } void ModbusTcpManager::writeHoldingRegister( int address, quint16 value, const std::function &callback) { enqueue({QModbusDataUnit::HoldingRegisters, address, 1, {value}, true, [callback](bool success, const QVector &, const QString &error) { if (callback) { callback(success, error); } }}); } bool ModbusTcpManager::readRReal( int rAddress, const std::function &callback) { if (!isValidRRealAddress(rAddress) || m_aborting) { return false; } enqueue({QModbusDataUnit::HoldingRegisters, RRegisterBase + rAddress, 2, {}, false, [callback](bool success, const QVector &values, const QString &error) { float value = 0.0f; if (success) { const quint32 bits = quint32(values.at(0)) | (quint32(values.at(1)) << 16); std::memcpy(&value, &bits, sizeof(value)); } if (callback) { callback(success, value, error); } }}); return true; } bool ModbusTcpManager::writeRReal( int rAddress, float value, const std::function &callback) { if (!isValidRRealAddress(rAddress) || m_aborting) { return false; } quint32 bits = 0; std::memcpy(&bits, &value, sizeof(bits)); enqueue({QModbusDataUnit::HoldingRegisters, RRegisterBase + rAddress, 2, {static_cast(bits & 0xffffu), static_cast(bits >> 16)}, true, [callback](bool success, const QVector &, const QString &error) { if (callback) { callback(success, error); } }}); return true; } bool ModbusTcpManager::readRReals( int rAddress, int count, const std::function &, const QString &)> &callback, bool lowWordFirst) { if (!isValidRRealAddress(rAddress) || count < 1 || count > 62 || rAddress + count * 2 > MaxRRealAddress + 2 || m_aborting || m_cancelingVision) { return false; } Request request(QModbusDataUnit::HoldingRegisters, RRegisterBase + rAddress, quint16(count * 2), {}, false, [callback, count, lowWordFirst](bool success, const QVector &words, const QString &error) { QVector values; QString text = error; if (success && words.size() != count * 2) { success = false; text = "R REAL response length does not match the request"; } if (success) { for (int i = 0; i < count; ++i) { const quint32 bits = quint32(words.at(i * 2 + (lowWordFirst ? 0 : 1))) | (quint32(words.at(i * 2 + (lowWordFirst ? 1 : 0))) << 16); float value = 0; std::memcpy(&value, &bits, sizeof(value)); if (!std::isfinite(value)) { success = false; text = "R REAL response contains NaN or infinity"; break; } values.append(double(value)); } } if (callback) { callback(success, success ? values : QVector(), text); } }); request.vision = true; enqueue(request); return true; } bool ModbusTcpManager::writeRReals(int rAddress, const QVector &values, const VisionWriteCallback &callback, bool lowWordFirst, const std::function &beforeSend) { if (!isValidRRealAddress(rAddress) || values.isEmpty() || values.size() > 61 || rAddress + values.size() * 2 > MaxRRealAddress + 2 || m_aborting || m_cancelingVision) { return false; } QVector words; for (double value : values) { if (!std::isfinite(value) || qAbs(value) > std::numeric_limits::max()) { return false; } const float real = float(value); quint32 bits = 0; std::memcpy(&bits, &real, sizeof(bits)); const quint16 low = quint16(bits & 0xffffu); const quint16 high = quint16(bits >> 16); words.append(lowWordFirst ? low : high); words.append(lowWordFirst ? high : low); } Request request(QModbusDataUnit::HoldingRegisters, RRegisterBase + rAddress, quint16(words.size()), words, true, {}); request.vision = true; request.writeCallback = callback; request.beforeSend = beforeSend; enqueue(request); return true; } void ModbusTcpManager::readVisionCoil( int address, const std::function &callback) { Request request(QModbusDataUnit::Coils, address, 1, {}, false, [callback](bool success, const QVector &values, const QString &error) { if (callback) { callback(success, success && values.value(0) != 0, error); } }); request.vision = true; enqueue(request); } void ModbusTcpManager::writeVisionCoil(int address, bool value, const VisionWriteCallback &callback, const std::function &beforeSend) { Request request(QModbusDataUnit::Coils, address, 1, {quint16(value ? 1 : 0)}, true, {}); request.vision = true; request.writeCallback = callback; request.beforeSend = beforeSend; enqueue(request); } void ModbusTcpManager::writeVisionHoldingRegister(int address, quint16 value, const VisionWriteCallback &callback, const std::function &beforeSend) { Request request(QModbusDataUnit::HoldingRegisters, address, 1, {value}, true, {}); request.vision = true; request.writeCallback = callback; request.beforeSend = beforeSend; enqueue(request); } void ModbusTcpManager::cancelVisionRequests(const QString &reason) { if (m_cancelingVision) { return; } m_cancelingVision = true; const QString text = reason.isEmpty() ? "Vision PLC request canceled" : reason; QQueue retained; QVector canceled; while (!m_requests.isEmpty()) { const Request request = m_requests.dequeue(); if (!request.vision) { retained.enqueue(request); } else { canceled.append(request); } } m_requests = retained; if (m_hasCurrentRequest && m_currentRequest.vision) { const Request request = m_currentRequest; canceled.prepend(request); m_currentRequest.callback = ValuesCompletion(); m_currentRequest.writeCallback = VisionWriteCallback(); if (!request.sent) { m_hasCurrentRequest = false; m_currentRequest = Request(); } } // Detach every callback before invoking user code, which may abort all work. // A sent request must drain; cancellation cannot retract the wire write. for (const Request &request : canceled) { if (request.callback) request.callback(false, {}, text); if (request.writeCallback) { request.writeCallback(request.sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent, text); } } m_cancelingVision = false; startNext(); } 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 ValuesCompletion callback = m_currentRequest.callback; const VisionWriteCallback writeCallback = m_currentRequest.writeCallback; const bool sent = m_currentRequest.sent; m_currentRequest = Request(); m_hasCurrentRequest = false; setError(text); if (callback) { callback(false, {}, text); } if (writeCallback) { writeCallback(sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent, text); } } while (!m_requests.isEmpty()) { Request request = m_requests.dequeue(); if (request.callback) { request.callback(false, {}, text); } if (request.writeCallback) { request.writeCallback(VisionWriteOutcome::NotSent, text); } } if (m_client) { // disconnectDevice completes asynchronously. A new request must not // reuse this client while its previous socket is still closing. QModbusTcpClient *client = m_client; m_client = nullptr; client->disconnect(this); client->disconnectDevice(); client->deleteLater(); } m_aborting = false; } bool ModbusTcpManager::isBusy() const { return m_hasCurrentRequest || !m_requests.isEmpty() || m_connecting || m_reply; } void ModbusTcpManager::enqueue(const Request &request) { if (request.vision && request.write && m_config.serverAddress == 0) { if (request.writeCallback) { request.writeCallback(VisionWriteOutcome::NotSent, "Vision writes require a non-broadcast Modbus address"); } return; } if (m_aborting || (m_cancelingVision && request.vision)) { if (request.callback) { request.callback(false, {}, "Modbus request was canceled"); } if (request.writeCallback) { request.writeCallback(VisionWriteOutcome::NotSent, "Modbus request was canceled"); } return; } if (request.address < 0 || request.address > 65535 || request.address + request.count > 65536) { if (request.callback) { request.callback(false, {}, "Modbus address must be greater than or equal to 0"); } if (request.writeCallback) { request.writeCallback(VisionWriteOutcome::NotSent, "Modbus address range is invalid"); } return; } m_requests.enqueue(request); startNext(); } void ModbusTcpManager::startNext() { if (m_aborting || m_cancelingVision || 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; } if (m_currentRequest.beforeSend && !m_currentRequest.beforeSend()) { finishCurrent(false, {}, "Vision request invalidated before transmission"); return; } QModbusDataUnit unit( static_cast( m_currentRequest.registerType), m_currentRequest.address, m_currentRequest.count); // Qt applies retries when sendWriteRequest queues the request. Only vision // writes disable retries; legacy commands retain the existing policy. m_client->setNumberOfRetries(m_currentRequest.vision && m_currentRequest.write ? 0 : m_config.retryCount); if (m_currentRequest.write) { unit.setValues(m_currentRequest.values); m_reply = m_client->sendWriteRequest(unit, m_config.serverAddress); } else { m_reply = m_client->sendReadRequest(unit, m_config.serverAddress); } if (!m_reply) { finishCurrent(false, {}, m_client->errorString().isEmpty() ? "Failed to create Modbus request" : m_client->errorString()); return; } m_currentRequest.sent = true; connect(m_reply, &QModbusReply::finished, this, &ModbusTcpManager::onReplyFinished); if (m_reply->isFinished()) { // Broadcast replies can already be complete when returned by Qt. QMetaObject::invokeMethod(m_reply, "finished", Qt::QueuedConnection); } } void ModbusTcpManager::finishCurrent(bool success, const QVector &values, const QString &error) { if (!m_hasCurrentRequest) { return; } const ValuesCompletion callback = m_currentRequest.callback; const VisionWriteCallback writeCallback = m_currentRequest.writeCallback; const bool sent = m_currentRequest.sent; m_currentRequest = Request(); m_hasCurrentRequest = false; if (!success) { setError(error); } else { m_lastErrorText.clear(); } if (callback) { callback(success, values, error); } if (writeCallback) { writeCallback(success ? VisionWriteOutcome::Confirmed : (sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent), 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, {}, 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; QVector values; QString error; if (!success) { error = reply->errorString().isEmpty() ? QString("Modbus reply failed with error %1").arg(int(reply->error())) : reply->errorString(); } else if (!m_currentRequest.write) { const QModbusDataUnit result = reply->result(); if (result.valueCount() != m_currentRequest.count) { error = QString("Modbus read returned %1 values; expected %2") .arg(result.valueCount()) .arg(m_currentRequest.count); } else { values = result.values(); } } reply->deleteLater(); if (!success || !error.isEmpty()) { finishCurrent(false, {}, error); return; } finishCurrent(true, values, QString()); } void ModbusTcpManager::onConnectTimeout() { handleConnectionFailure("Modbus TCP connect timeout"); }