添加管控软件和相机的通讯
This commit is contained in:
+345
-32
@@ -6,6 +6,26 @@
|
||||
#include <QTimer>
|
||||
#include <QVariant>
|
||||
|
||||
#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)
|
||||
@@ -37,28 +57,82 @@ void ModbusTcpManager::readCoil(
|
||||
int address,
|
||||
const std::function<void(bool, bool, const QString &)> &callback)
|
||||
{
|
||||
enqueue({QModbusDataUnit::Coils, address, 0, false,
|
||||
[callback](bool success, quint16 value, const QString &error) {
|
||||
enqueue({QModbusDataUnit::Coils, address, 1, {}, false,
|
||||
[callback](bool success, const QVector<quint16> &values,
|
||||
const QString &error) {
|
||||
if (callback) {
|
||||
callback(success, value != 0, error);
|
||||
callback(success,
|
||||
success && values.first() != 0,
|
||||
error);
|
||||
}
|
||||
}});
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
enqueue({QModbusDataUnit::HoldingRegisters, address, 0, false, callback});
|
||||
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);
|
||||
}
|
||||
}});
|
||||
}
|
||||
|
||||
void ModbusTcpManager::writeCoil(
|
||||
int address, bool value,
|
||||
const std::function<void(bool, const QString &)> &callback)
|
||||
{
|
||||
enqueue({QModbusDataUnit::Coils, address,
|
||||
static_cast<quint16>(value ? 1 : 0), true,
|
||||
[callback](bool success, quint16, const QString &error) {
|
||||
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);
|
||||
}
|
||||
@@ -69,14 +143,204 @@ void ModbusTcpManager::writeHoldingRegister(
|
||||
int address, quint16 value,
|
||||
const std::function<void(bool, const QString &)> &callback)
|
||||
{
|
||||
enqueue({QModbusDataUnit::HoldingRegisters, address, value, true,
|
||||
[callback](bool success, quint16, const QString &error) {
|
||||
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);
|
||||
}
|
||||
}});
|
||||
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::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();
|
||||
}
|
||||
|
||||
void ModbusTcpManager::abortAll(const QString &reason)
|
||||
{
|
||||
if (m_aborting) {
|
||||
@@ -98,19 +362,27 @@ void ModbusTcpManager::abortAll(const QString &reason)
|
||||
}
|
||||
|
||||
if (m_hasCurrentRequest) {
|
||||
const Completion callback = m_currentRequest.callback;
|
||||
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, 0, text);
|
||||
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, 0, text);
|
||||
request.callback(false, {}, text);
|
||||
}
|
||||
if (request.writeCallback) {
|
||||
request.writeCallback(VisionWriteOutcome::NotSent, text);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -130,18 +402,32 @@ bool ModbusTcpManager::isBusy() const
|
||||
|
||||
void ModbusTcpManager::enqueue(const Request &request)
|
||||
{
|
||||
if (m_aborting) {
|
||||
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, 0, "Modbus request was canceled");
|
||||
request.callback(false, {}, "Modbus request was canceled");
|
||||
}
|
||||
if (request.writeCallback) {
|
||||
request.writeCallback(VisionWriteOutcome::NotSent, "Modbus request was canceled");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (request.address < 0) {
|
||||
if (request.address < 0 || request.address > 65535
|
||||
|| request.address + request.count > 65536) {
|
||||
if (request.callback) {
|
||||
request.callback(false, 0,
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -151,7 +437,7 @@ void ModbusTcpManager::enqueue(const Request &request)
|
||||
|
||||
void ModbusTcpManager::startNext()
|
||||
{
|
||||
if (m_aborting || m_hasCurrentRequest || m_requests.isEmpty()) {
|
||||
if (m_aborting || m_cancelingVision || m_hasCurrentRequest || m_requests.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -200,38 +486,56 @@ 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<QModbusDataUnit::RegisterType>(
|
||||
m_currentRequest.registerType),
|
||||
m_currentRequest.address, 1);
|
||||
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.setValue(0, m_currentRequest.value);
|
||||
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, 0,
|
||||
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, quint16 value,
|
||||
void ModbusTcpManager::finishCurrent(bool success,
|
||||
const QVector<quint16> &values,
|
||||
const QString &error)
|
||||
{
|
||||
if (!m_hasCurrentRequest) {
|
||||
return;
|
||||
}
|
||||
|
||||
const Completion callback = m_currentRequest.callback;
|
||||
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) {
|
||||
@@ -241,7 +545,12 @@ void ModbusTcpManager::finishCurrent(bool success, quint16 value,
|
||||
}
|
||||
|
||||
if (callback) {
|
||||
callback(success, value, error);
|
||||
callback(success, values, error);
|
||||
}
|
||||
if (writeCallback) {
|
||||
writeCallback(success ? VisionWriteOutcome::Confirmed
|
||||
: (sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent),
|
||||
error);
|
||||
}
|
||||
if (!m_aborting) {
|
||||
startNext();
|
||||
@@ -270,7 +579,7 @@ void ModbusTcpManager::handleConnectionFailure(const QString &error)
|
||||
return;
|
||||
}
|
||||
|
||||
finishCurrent(false, 0,
|
||||
finishCurrent(false, {},
|
||||
error.isEmpty() ? "Failed to connect to PLC" : error);
|
||||
}
|
||||
|
||||
@@ -336,26 +645,30 @@ void ModbusTcpManager::onReplyFinished()
|
||||
|
||||
m_reply = nullptr;
|
||||
const bool success = reply->error() == QModbusDevice::NoError;
|
||||
quint16 value = 0;
|
||||
QVector<quint16> values;
|
||||
QString error;
|
||||
if (!success) {
|
||||
error = reply->errorString();
|
||||
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() < 1) {
|
||||
error = "Modbus read returned an empty result";
|
||||
if (result.valueCount() != m_currentRequest.count) {
|
||||
error = QString("Modbus read returned %1 values; expected %2")
|
||||
.arg(result.valueCount())
|
||||
.arg(m_currentRequest.count);
|
||||
} else {
|
||||
value = result.value(0);
|
||||
values = result.values();
|
||||
}
|
||||
}
|
||||
|
||||
reply->deleteLater();
|
||||
if (!error.isEmpty()) {
|
||||
finishCurrent(false, 0, error);
|
||||
if (!success || !error.isEmpty()) {
|
||||
finishCurrent(false, {}, error);
|
||||
return;
|
||||
}
|
||||
|
||||
finishCurrent(true, value, QString());
|
||||
finishCurrent(true, values, QString());
|
||||
}
|
||||
|
||||
void ModbusTcpManager::onConnectTimeout()
|
||||
|
||||
Reference in New Issue
Block a user