Files
ssp/modbus/modbustcpmanager.cpp
T

689 lines
21 KiB
C++
Raw Normal View History

2026-08-18 09:40:43 +08:00
#include "modbustcpmanager.h"
#include <QModbusDataUnit>
#include <QModbusReply>
#include <QModbusTcpClient>
#include <QTimer>
#include <QVariant>
2026-10-27 22:16:55 +08:00
#include <cstring>
#include <cmath>
#include <limits>
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)
2026-08-18 09:40:43 +08:00
{
m_connectTimer->setSingleShot(true);
connect(m_connectTimer, &QTimer::timeout,
this, &ModbusTcpManager::onConnectTimeout);
2026-08-18 09:40:43 +08:00
}
ModbusTcpManager::~ModbusTcpManager()
2026-08-18 09:40:43 +08:00
{
abortAll("Modbus manager is shutting down");
2026-08-18 09:40:43 +08:00
}
ModbusConfig ModbusTcpManager::config() const
2026-08-18 09:40:43 +08:00
{
return m_config;
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::readCoil(
int address,
const std::function<void(bool, bool, const QString &)> &callback)
2026-08-18 09:40:43 +08:00
{
2026-10-27 22:16:55 +08:00
enqueue({QModbusDataUnit::Coils, address, 1, {}, false,
[callback](bool success, const QVector<quint16> &values,
const QString &error) {
if (callback) {
2026-10-27 22:16:55 +08:00
callback(success,
success && values.first() != 0,
error);
}
}});
2026-08-18 09:40:43 +08:00
}
2026-10-27 22:16:55 +08:00
void ModbusTcpManager::readCoils(
int startAddress, quint16 count,
const std::function<void(
bool, const QVector<bool> &, 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<quint32>(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<quint16> &values,
const QString &error) {
if (!callback) {
return;
}
QVector<bool> 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<void(bool, quint16, const QString &)> &callback)
2026-08-18 09:40:43 +08:00
{
2026-10-27 22:16:55 +08:00
enqueue({QModbusDataUnit::HoldingRegisters, address, 1, {}, false,
[callback](bool success, const QVector<quint16> &values,
const QString &error) {
if (callback) {
callback(success,
success ? values.first() : 0,
error);
}
}});
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::writeCoil(
int address, bool value,
const std::function<void(bool, const QString &)> &callback)
2026-08-18 09:40:43 +08:00
{
2026-10-27 22:16:55 +08:00
enqueue({QModbusDataUnit::Coils, address, 1,
{static_cast<quint16>(value ? 1 : 0)}, true,
[callback](bool success, const QVector<quint16> &,
const QString &error) {
if (callback) {
callback(success, error);
}
}});
}
2026-08-18 09:40:43 +08:00
void ModbusTcpManager::writeHoldingRegister(
int address, quint16 value,
const std::function<void(bool, const QString &)> &callback)
{
2026-10-27 22:16:55 +08:00
enqueue({QModbusDataUnit::HoldingRegisters, address, 1, {value}, true,
[callback](bool success, const QVector<quint16> &,
const QString &error) {
if (callback) {
callback(success, error);
}
}});
}
bool ModbusTcpManager::readRReal(
int rAddress,
const std::function<void(bool, float, const QString &)> &callback)
{
if (!isValidRRealAddress(rAddress) || m_aborting) {
return false;
}
enqueue({QModbusDataUnit::HoldingRegisters,
RRegisterBase + rAddress, 2, {}, false,
[callback](bool success, const QVector<quint16> &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<void(bool, const QString &)> &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<quint16>(bits & 0xffffu),
static_cast<quint16>(bits >> 16)},
true,
[callback](bool success, const QVector<quint16> &,
const QString &error) {
if (callback) {
callback(success, error);
}
}});
2026-10-27 22:16:55 +08:00
return true;
}
bool ModbusTcpManager::readRReals(
int rAddress, int count,
const std::function<void(bool, const QVector<double> &, 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<quint16> &words,
const QString &error) {
QVector<double> 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<double>(), text);
}
});
request.vision = true;
enqueue(request);
return true;
}
bool ModbusTcpManager::writeRReals(int rAddress, const QVector<double> &values,
const VisionWriteCallback &callback,
bool lowWordFirst, const std::function<bool()> &beforeSend)
{
if (!isValidRRealAddress(rAddress) || values.isEmpty() || values.size() > 61
|| rAddress + values.size() * 2 > MaxRRealAddress + 2
|| m_aborting || m_cancelingVision) {
return false;
}
QVector<quint16> words;
for (double value : values) {
if (!std::isfinite(value) || qAbs(value) > std::numeric_limits<float>::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<void(bool, bool, const QString &)> &callback)
{
Request request(QModbusDataUnit::Coils, address, 1, {}, false,
[callback](bool success, const QVector<quint16> &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<bool()> &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<bool()> &beforeSend)
{
Request request(QModbusDataUnit::HoldingRegisters, address, 1, {value}, true, {});
request.vision = true;
request.writeCallback = callback;
request.beforeSend = beforeSend;
enqueue(request);
}
2026-10-27 22:16:55 +08:00
void ModbusTcpManager::cancelVisionRequests(const QString &reason)
{
if (m_cancelingVision) {
return;
}
m_cancelingVision = true;
const QString text = reason.isEmpty() ? "Vision PLC request canceled" : reason;
QQueue<Request> retained;
QVector<Request> 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();
}
2026-08-18 09:40:43 +08:00
void ModbusTcpManager::abortAll(const QString &reason)
{
if (m_aborting) {
return;
2026-08-18 09:40:43 +08:00
}
const QString text = reason.isEmpty()
? "Modbus request was canceled" : reason;
2026-08-18 09:40:43 +08:00
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) {
2026-10-27 22:16:55 +08:00
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) {
2026-10-27 22:16:55 +08:00
callback(false, {}, text);
}
if (writeCallback) {
writeCallback(sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent, text);
2026-08-18 09:40:43 +08:00
}
}
while (!m_requests.isEmpty()) {
Request request = m_requests.dequeue();
if (request.callback) {
2026-10-27 22:16:55 +08:00
request.callback(false, {}, text);
}
if (request.writeCallback) {
request.writeCallback(VisionWriteOutcome::NotSent, text);
}
}
2026-08-18 09:40:43 +08:00
if (m_client
&& m_client->state() != QModbusDevice::UnconnectedState) {
2026-08-18 09:40:43 +08:00
m_client->disconnectDevice();
}
m_aborting = false;
2026-08-18 09:40:43 +08:00
}
bool ModbusTcpManager::isBusy() const
2026-08-18 09:40:43 +08:00
{
return m_hasCurrentRequest || !m_requests.isEmpty()
|| m_connecting || m_reply;
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::enqueue(const Request &request)
2026-08-18 09:40:43 +08:00
{
2026-10-27 22:16:55 +08:00
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) {
2026-10-27 22:16:55 +08:00
request.callback(false, {}, "Modbus request was canceled");
}
if (request.writeCallback) {
request.writeCallback(VisionWriteOutcome::NotSent, "Modbus request was canceled");
}
return;
2026-08-18 09:40:43 +08:00
}
2026-10-27 22:16:55 +08:00
if (request.address < 0 || request.address > 65535
|| request.address + request.count > 65536) {
if (request.callback) {
2026-10-27 22:16:55 +08:00
request.callback(false, {},
"Modbus address must be greater than or equal to 0");
}
2026-10-27 22:16:55 +08:00
if (request.writeCallback) {
request.writeCallback(VisionWriteOutcome::NotSent, "Modbus address range is invalid");
}
return;
2026-08-18 09:40:43 +08:00
}
m_requests.enqueue(request);
startNext();
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::startNext()
2026-08-18 09:40:43 +08:00
{
2026-10-27 22:16:55 +08:00
if (m_aborting || m_cancelingVision || m_hasCurrentRequest || m_requests.isEmpty()) {
return;
2026-08-18 09:40:43 +08:00
}
m_currentRequest = m_requests.dequeue();
m_hasCurrentRequest = true;
m_connectAttempts = 0;
ensureConnected();
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::ensureConnected()
2026-08-18 09:40:43 +08:00
{
if (m_aborting || !m_hasCurrentRequest) {
return;
}
2026-08-18 09:40:43 +08:00
ensureClient();
if (m_client->state() == QModbusDevice::ConnectedState) {
startCurrentRequest();
return;
}
if (m_connecting) {
return;
}
2026-08-18 09:40:43 +08:00
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));
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::startCurrentRequest()
2026-08-18 09:40:43 +08:00
{
if (m_aborting || !m_hasCurrentRequest || m_connecting || m_reply) {
return;
2026-08-18 09:40:43 +08:00
}
2026-10-27 22:16:55 +08:00
if (m_currentRequest.beforeSend
&& !m_currentRequest.beforeSend()) {
finishCurrent(false, {}, "Vision request invalidated before transmission");
return;
}
2026-08-18 09:40:43 +08:00
QModbusDataUnit unit(
static_cast<QModbusDataUnit::RegisterType>(
m_currentRequest.registerType),
2026-10-27 22:16:55 +08:00
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) {
2026-10-27 22:16:55 +08:00
unit.setValues(m_currentRequest.values);
m_reply = m_client->sendWriteRequest(unit, m_config.serverAddress);
} else {
m_reply = m_client->sendReadRequest(unit, m_config.serverAddress);
2026-08-18 09:40:43 +08:00
}
if (!m_reply) {
2026-10-27 22:16:55 +08:00
finishCurrent(false, {},
m_client->errorString().isEmpty()
? "Failed to create Modbus request"
: m_client->errorString());
return;
2026-08-18 09:40:43 +08:00
}
2026-10-27 22:16:55 +08:00
m_currentRequest.sent = true;
connect(m_reply, &QModbusReply::finished,
this, &ModbusTcpManager::onReplyFinished);
2026-10-27 22:16:55 +08:00
if (m_reply->isFinished()) {
// Broadcast replies can already be complete when returned by Qt.
QMetaObject::invokeMethod(m_reply, "finished", Qt::QueuedConnection);
}
}
2026-08-18 09:40:43 +08:00
2026-10-27 22:16:55 +08:00
void ModbusTcpManager::finishCurrent(bool success,
const QVector<quint16> &values,
const QString &error)
{
if (!m_hasCurrentRequest) {
return;
2026-08-18 09:40:43 +08:00
}
2026-10-27 22:16:55 +08:00
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();
2026-08-18 09:40:43 +08:00
}
if (callback) {
2026-10-27 22:16:55 +08:00
callback(success, values, error);
}
if (writeCallback) {
writeCallback(success ? VisionWriteOutcome::Confirmed
: (sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent),
error);
}
if (!m_aborting) {
startNext();
2026-08-18 09:40:43 +08:00
}
}
void ModbusTcpManager::handleConnectionFailure(const QString &error)
2026-08-18 09:40:43 +08:00
{
if (m_aborting) {
return;
2026-08-18 09:40:43 +08:00
}
m_connectTimer->stop();
m_connecting = false;
2026-08-18 09:40:43 +08:00
if (m_client
&& m_client->state() != QModbusDevice::UnconnectedState) {
m_client->disconnectDevice();
}
2026-08-18 09:40:43 +08:00
const int attempts = qMax(1, m_config.reconnectAttempts + 1);
if (m_connectAttempts < attempts) {
QTimer::singleShot(
qMax(0, m_config.reconnectDelayMs),
this, &ModbusTcpManager::ensureConnected);
return;
2026-08-18 09:40:43 +08:00
}
2026-10-27 22:16:55 +08:00
finishCurrent(false, {},
error.isEmpty() ? "Failed to connect to PLC" : error);
}
2026-08-18 09:40:43 +08:00
void ModbusTcpManager::ensureClient()
{
if (m_client) {
return;
}
2026-08-18 09:40:43 +08:00
m_client = new QModbusTcpClient(this);
connect(m_client, &QModbusClient::stateChanged,
this, &ModbusTcpManager::onStateChanged);
connect(m_client, &QModbusClient::errorOccurred,
this, &ModbusTcpManager::onErrorOccurred);
}
2026-08-18 09:40:43 +08:00
void ModbusTcpManager::setError(const QString &text)
{
m_lastErrorText = text;
}
void ModbusTcpManager::onStateChanged(QModbusDevice::State state)
{
if (m_aborting) {
return;
2026-08-18 09:40:43 +08:00
}
if (state == QModbusDevice::ConnectedState) {
m_connectTimer->stop();
m_connecting = false;
startCurrentRequest();
return;
2026-08-18 09:40:43 +08:00
}
if (state == QModbusDevice::UnconnectedState && m_connecting) {
handleConnectionFailure(m_client ? m_client->errorString()
: QString());
}
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::onErrorOccurred(QModbusDevice::Error error)
2026-08-18 09:40:43 +08:00
{
Q_UNUSED(error)
if (m_aborting) {
2026-08-18 09:40:43 +08:00
return;
}
if (m_connecting) {
handleConnectionFailure(m_client ? m_client->errorString()
: QString());
}
2026-08-18 09:40:43 +08:00
}
void ModbusTcpManager::onReplyFinished()
2026-08-18 09:40:43 +08:00
{
QModbusReply *reply = qobject_cast<QModbusReply *>(sender());
if (!reply || reply != m_reply) {
if (reply) {
reply->deleteLater();
}
return;
2026-08-18 09:40:43 +08:00
}
m_reply = nullptr;
const bool success = reply->error() == QModbusDevice::NoError;
2026-10-27 22:16:55 +08:00
QVector<quint16> values;
QString error;
if (!success) {
2026-10-27 22:16:55 +08:00
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();
2026-10-27 22:16:55 +08:00
if (result.valueCount() != m_currentRequest.count) {
error = QString("Modbus read returned %1 values; expected %2")
.arg(result.valueCount())
.arg(m_currentRequest.count);
} else {
2026-10-27 22:16:55 +08:00
values = result.values();
}
}
reply->deleteLater();
2026-10-27 22:16:55 +08:00
if (!success || !error.isEmpty()) {
finishCurrent(false, {}, error);
return;
}
2026-10-27 22:16:55 +08:00
finishCurrent(true, values, QString());
}
void ModbusTcpManager::onConnectTimeout()
{
handleConnectionFailure("Modbus TCP connect timeout");
2026-08-18 09:40:43 +08:00
}