From 54d285cbc873362ba28d4d5eab2dc659b7f0c481 Mon Sep 17 00:00:00 2001 From: Lenn Date: Tue, 20 Jan 2026 11:13:31 +0800 Subject: [PATCH] fix:baud error --- qml/content/LeftPanel.qml | 2 +- src/glwidget.cpp | 1 - src/serial/serial_backend.cpp | 211 ++++++++++++++++++++-------------- 3 files changed, 124 insertions(+), 90 deletions(-) diff --git a/qml/content/LeftPanel.qml b/qml/content/LeftPanel.qml index 38e6f14..9cc9687 100644 --- a/qml/content/LeftPanel.qml +++ b/qml/content/LeftPanel.qml @@ -104,7 +104,7 @@ Rectangle { ComboBox { Layout.fillWidth: true - model: ["9600", "57600", "115200", "230400", "912600"] + model: ["9600", "57600", "115200", "230400", "921600"] Component.onCompleted: { const idx = model.indexOf(String(Backend.serial.baudRate)) if (idx >= 0) diff --git a/src/glwidget.cpp b/src/glwidget.cpp index 9d72ba3..40fc1f3 100644 --- a/src/glwidget.cpp +++ b/src/glwidget.cpp @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include diff --git a/src/serial/serial_backend.cpp b/src/serial/serial_backend.cpp index a1334f4..ae23b3d 100644 --- a/src/serial/serial_backend.cpp +++ b/src/serial/serial_backend.cpp @@ -10,12 +10,9 @@ #include #include -SerialBackend::SerialBackend(QObject* parent) - : QObject(parent) - , m_packetQueue(2048) - , m_frameQueue(2048) - , m_readThread(&m_packetQueue) - , m_decodeThread(&m_packetQueue, &m_frameQueue) { +SerialBackend::SerialBackend(QObject *parent) + : QObject(parent), m_packetQueue(2048), m_frameQueue(2048), m_readThread(&m_packetQueue), m_decodeThread(&m_packetQueue, &m_frameQueue) +{ m_request.dataLength = 24; m_spec.model = QStringLiteral("PZR-A"); @@ -27,27 +24,27 @@ SerialBackend::SerialBackend(QObject* parent) m_sendWorker = new SerialSendWorker(); m_sendWorker->moveToThread(&m_sendThread); - connect(m_sendWorker, &SerialSendWorker::bytesReceived, this, [this](const QByteArray& data) { + connect(m_sendWorker, &SerialSendWorker::bytesReceived, this, [this](const QByteArray &data) + { #if 0 if (!data.isEmpty()) qDebug().noquote() << "Serial recv bytes:" << QString::fromLatin1(data.toHex(' ')); #endif - m_readThread.enqueueBytes(data); - }); + m_readThread.enqueueBytes(data); }); connect(m_sendWorker, &SerialSendWorker::requestBuilt, this, &SerialBackend::requestBuilt); - connect(m_sendWorker, &SerialSendWorker::writeFailed, this, [](const QString& error) { + connect(m_sendWorker, &SerialSendWorker::writeFailed, this, [](const QString &error) + { if (!error.isEmpty()) - qWarning().noquote() << "Serial write failed:" << error; - }); + qWarning().noquote() << "Serial write failed:" << error; }); - connect(&m_readThread, &SerialReadThread::parseError, this, [](const QString& error) { + connect(&m_readThread, &SerialReadThread::parseError, this, [](const QString &error) + { if (!error.isEmpty()) - qWarning().noquote() << "Serial packet invalid:" << error; - }); - connect(&m_decodeThread, &SerialDecodeThread::decodeError, this, [](const QString& error) { + qWarning().noquote() << "Serial packet invalid:" << error; }); + connect(&m_decodeThread, &SerialDecodeThread::decodeError, this, [](const QString &error) + { if (!error.isEmpty()) - qWarning().noquote() << "Serial decode failed:" << error; - }); + qWarning().noquote() << "Serial decode failed:" << error; }); connect(&m_decodeThread, &SerialDecodeThread::frameAvailable, this, &SerialBackend::drainFrames_); m_sendThread.start(); @@ -59,21 +56,24 @@ SerialBackend::SerialBackend(QObject* parent) refreshPorts(); } -SerialBackend::~SerialBackend() { +SerialBackend::~SerialBackend() +{ close(); stopPipeline_(); - if (m_sendWorker && m_sendThread.isRunning()) { - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker]() { - worker->closeTransport(); - }, Qt::BlockingQueuedConnection); + if (m_sendWorker && m_sendThread.isRunning()) + { + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker]() + { worker->closeTransport(); }, Qt::BlockingQueuedConnection); } - if (m_sendWorker && m_sendThread.isRunning()) { + if (m_sendWorker && m_sendThread.isRunning()) + { QMetaObject::invokeMethod(m_sendWorker, &QObject::deleteLater, Qt::QueuedConnection); } - if (m_sendThread.isRunning()) { + if (m_sendThread.isRunning()) + { m_sendThread.quit(); m_sendThread.wait(); } @@ -81,15 +81,18 @@ SerialBackend::~SerialBackend() { m_sendWorker = nullptr; } -QString SerialBackend::mode() const { +QString SerialBackend::mode() const +{ return (m_config.mode == DeviceMode::Slave) ? QStringLiteral("slave") : QStringLiteral("master"); } -QString SerialBackend::sensorGrid() const { +QString SerialBackend::sensorGrid() const +{ return QStringLiteral("%1x%2").arg(m_spec.rows).arg(m_spec.cols); } -void SerialBackend::setPortName(const QString& name) { +void SerialBackend::setPortName(const QString &name) +{ if (m_config.portName == name) return; m_config.portName = name; @@ -97,7 +100,8 @@ void SerialBackend::setPortName(const QString& name) { emit portNameChanged(); } -void SerialBackend::setBaudRate(int rate) { +void SerialBackend::setBaudRate(int rate) +{ if (m_config.baudRate == rate) return; m_config.baudRate = rate; @@ -105,7 +109,8 @@ void SerialBackend::setBaudRate(int rate) { emit baudRateChanged(); } -void SerialBackend::setPollIntervalMs(int intervalMs) { +void SerialBackend::setPollIntervalMs(int intervalMs) +{ intervalMs = qMax(1, intervalMs); if (m_config.pollIntervalMs == intervalMs) return; @@ -114,7 +119,8 @@ void SerialBackend::setPollIntervalMs(int intervalMs) { emit pollIntervalMsChanged(); } -void SerialBackend::setDeviceAddress(int address) { +void SerialBackend::setDeviceAddress(int address) +{ const int capped = qBound(0, address, 255); if (m_config.deviceAddress == static_cast(capped)) return; @@ -123,7 +129,8 @@ void SerialBackend::setDeviceAddress(int address) { emit deviceAddressChanged(); } -void SerialBackend::setMode(const QString& mode) { +void SerialBackend::setMode(const QString &mode) +{ const QString lower = mode.trimmed().toLower(); const DeviceMode next = (lower == QStringLiteral("master")) ? DeviceMode::Master : DeviceMode::Slave; if (m_config.mode == next) @@ -133,7 +140,8 @@ void SerialBackend::setMode(const QString& mode) { emit modeChanged(); } -void SerialBackend::setRequestFunction(int func) { +void SerialBackend::setRequestFunction(int func) +{ const int capped = qBound(0, func, 255); if (m_request.functionCode == static_cast(capped)) return; @@ -142,7 +150,8 @@ void SerialBackend::setRequestFunction(int func) { emit requestFunctionChanged(); } -void SerialBackend::setRequestStartAddress(int addr) { +void SerialBackend::setRequestStartAddress(int addr) +{ const quint32 capped = static_cast(qMax(0, addr)); if (m_request.startAddress == capped) return; @@ -151,7 +160,8 @@ void SerialBackend::setRequestStartAddress(int addr) { emit requestStartAddressChanged(); } -void SerialBackend::setRequestLength(int len) { +void SerialBackend::setRequestLength(int len) +{ const int capped = qBound(0, len, 65535); if (m_request.dataLength == static_cast(capped)) return; @@ -160,26 +170,30 @@ void SerialBackend::setRequestLength(int len) { emit requestLengthChanged(); } -void SerialBackend::setProtocol(const QString& name) { +void SerialBackend::setProtocol(const QString &name) +{ if (!m_manager.setActiveProtocol(name)) return; updateProtocolBindings_(); emit protocolChanged(); } -void SerialBackend::applySensorSpec(const QString& model, int rows, int cols) { +void SerialBackend::applySensorSpec(const QString &model, int rows, int cols) +{ const QString nextModel = model.trimmed(); const int nextRows = qMax(0, rows); const int nextCols = qMax(0, cols); bool changed = false; - if (!nextModel.isEmpty() && m_spec.model != nextModel) { + if (!nextModel.isEmpty() && m_spec.model != nextModel) + { m_spec.model = nextModel; emit sensorModelChanged(); changed = true; } - if (m_spec.rows != nextRows || m_spec.cols != nextCols) { + if (m_spec.rows != nextRows || m_spec.cols != nextCols) + { m_spec.rows = nextRows; m_spec.cols = nextCols; emit sensorGridChanged(); @@ -190,34 +204,38 @@ void SerialBackend::applySensorSpec(const QString& model, int rows, int cols) { return; } -void SerialBackend::setTransport(std::unique_ptr transport) { +void SerialBackend::setTransport(std::unique_ptr transport) +{ if (!transport || !m_sendWorker) return; if (!m_sendThread.isRunning()) m_sendThread.start(); if (transport->thread() != &m_sendThread) transport->moveToThread(&m_sendThread); - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, transport = std::move(transport)]() mutable { - worker->setTransport(std::move(transport)); - }, Qt::BlockingQueuedConnection); + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, transport = std::move(transport)]() mutable + { worker->setTransport(std::move(transport)); }, Qt::BlockingQueuedConnection); } -void SerialBackend::refreshPorts() { +void SerialBackend::refreshPorts() +{ // Placeholder for real port discovery (QtSerialPort or third-party transport). m_availablePorts.clear(); auto device_found = QSerialPortInfo::availablePorts(); - for (auto item : device_found) { + for (auto item : device_found) + { m_availablePorts.append(item.portName()); } - if (m_config.portName.isEmpty() && !m_availablePorts.isEmpty()) { + if (m_config.portName.isEmpty() && !m_availablePorts.isEmpty()) + { m_config.portName = m_availablePorts.first(); emit portNameChanged(); } emit availablePortsChanged(); } -bool SerialBackend::open() { +bool SerialBackend::open() +{ if (m_connected) return true; @@ -225,12 +243,13 @@ bool SerialBackend::open() { bool ok = false; QString error; - if (m_sendWorker) { - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, config = m_config, &ok, &error]() { - ok = worker->openTransport(config, &error); - }, Qt::BlockingQueuedConnection); + if (m_sendWorker) + { + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, config = m_config, &ok, &error]() + { ok = worker->openTransport(config, &error); }, Qt::BlockingQueuedConnection); } - if (!ok) { + if (!ok) + { qWarning().noquote() << "Serial open failed:" << error; return false; } @@ -241,44 +260,49 @@ bool SerialBackend::open() { return true; } -void SerialBackend::close() { +void SerialBackend::close() +{ if (!m_connected) return; - if (m_sendWorker && m_sendThread.isRunning()) { - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker]() { - worker->closeTransport(); - }, Qt::BlockingQueuedConnection); + if (m_sendWorker && m_sendThread.isRunning()) + { + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker]() + { worker->closeTransport(); }, Qt::BlockingQueuedConnection); } stopPipeline_(); m_connected = false; emit connectedChanged(); } -void SerialBackend::requestOnce() { +void SerialBackend::requestOnce() +{ if (!m_sendWorker) return; - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker]() { - worker->requestOnce(); - }, Qt::QueuedConnection); + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker]() + { worker->requestOnce(); }, Qt::QueuedConnection); } -void SerialBackend::feedBytes(const QByteArray& data) { +void SerialBackend::feedBytes(const QByteArray &data) +{ if (!m_readThread.isRunning()) startPipeline_(); m_readThread.enqueueBytes(data); } -void SerialBackend::setSensorWidth(int w) { +void SerialBackend::setSensorWidth(int w) +{ m_spec.cols = w; syncSendConfig_(); } -void SerialBackend::setSensorHeight(int h) { +void SerialBackend::setSensorHeight(int h) +{ m_spec.rows = h; syncSendConfig_(); } -void SerialBackend::drainFrames_() { +void SerialBackend::drainFrames_() +{ if (!m_frameCallback) return; DataFrame frame; @@ -286,7 +310,8 @@ void SerialBackend::drainFrames_() { m_frameCallback(frame); } -void SerialBackend::startPipeline_() { +void SerialBackend::startPipeline_() +{ if (m_readThread.isRunning() || m_decodeThread.isRunning()) stopPipeline_(); m_packetQueue.reset(); @@ -300,12 +325,15 @@ void SerialBackend::startPipeline_() { m_decodeThread.start(); } -void SerialBackend::stopPipeline_() { - if (m_readThread.isRunning()) { +void SerialBackend::stopPipeline_() +{ + if (m_readThread.isRunning()) + { m_readThread.stop(); m_readThread.wait(); } - if (m_decodeThread.isRunning()) { + if (m_decodeThread.isRunning()) + { m_decodeThread.stop(); m_decodeThread.wait(); } @@ -314,53 +342,60 @@ void SerialBackend::stopPipeline_() { m_readThread.clear(); } -void SerialBackend::updateProtocolBindings_() { +void SerialBackend::updateProtocolBindings_() +{ const auto bundle = m_manager.activeBundle(); SerialReadThread::ParseFunc parseFunc; - if (bundle.format) { - parseFunc = [format = bundle.format](QByteArray* buffer, QByteArray* packet, QString* error) { + if (bundle.format) + { + parseFunc = [format = bundle.format](QByteArray *buffer, QByteArray *packet, QString *error) + { return format->tryParse(buffer, packet, error); }; } m_readThread.setParseFunc(std::move(parseFunc)); SerialDecodeThread::DecodeFunc decodeFunc; - if (bundle.decoder) { - decodeFunc = [decoder = bundle.decoder](const QByteArray& packet, DataFrame* frame, QString* error) { + if (bundle.decoder) + { + decodeFunc = [decoder = bundle.decoder](const QByteArray &packet, DataFrame *frame, QString *error) + { return decoder->decodeFrame(packet, frame, error); }; } m_decodeThread.setDecodeFunc(std::move(decodeFunc)); SerialSendWorker::BuildRequestFunc requestFunc; - if (bundle.codec) { - requestFunc = [codec = bundle.codec](const SerialConfig& config, const SensorRequest& request) { + if (bundle.codec) + { + requestFunc = [codec = bundle.codec](const SerialConfig &config, const SensorRequest &request) + { return codec->buildRequest(config, request); }; } - if (m_sendWorker) { - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, requestFunc]() mutable { - worker->setBuildRequestFunc(std::move(requestFunc)); - }, Qt::QueuedConnection); + if (m_sendWorker) + { + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, requestFunc]() mutable + { worker->setBuildRequestFunc(std::move(requestFunc)); }, Qt::QueuedConnection); } } -void SerialBackend::syncSendConfig_() { +void SerialBackend::syncSendConfig_() +{ if (!m_sendWorker) return; const SerialConfig config = m_config; - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, config]() { - worker->setConfig(config); - }, Qt::QueuedConnection); + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, config]() + { worker->setConfig(config); }, Qt::QueuedConnection); } -void SerialBackend::syncSendRequest_() { +void SerialBackend::syncSendRequest_() +{ if (!m_sendWorker) return; const SensorRequest request = m_request; - QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, request]() { - worker->setRequest(request); - }, Qt::QueuedConnection); + QMetaObject::invokeMethod(m_sendWorker, [worker = m_sendWorker, request]() + { worker->setRequest(request); }, Qt::QueuedConnection); }