lenn/tactileipc3d
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

fix:baud error

Browse Source
This commit is contained in:
Lenn
2026-01-20 11:13:31 +08:00
parent 59564fd312
commit 54d285cbc8
3 changed files with 124 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
qml/content/LeftPanel.qml
View File

@@ -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)

1
src/glwidget.cpp
View File

@@ -8,7 +8,6 @@
#include <QtMath>
#include <QFile>
#include <QDebug>
#include <GL/gl.h>
#include <qevent.h>
#include <qlogging.h>
#include <qminmax.h>

209
src/serial/serial_backend.cpp
View File

@@ -11,11 +11,8 @@
#include <vector>
SerialBackend::SerialBackend(QObject *parent)
: QObject(parent)
, m_packetQueue(2048)
, m_frameQueue(2048)
, m_readThread(&m_packetQueue)
, m_decodeThread(&m_packetQueue, &m_frameQueue) {
: 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<quint8>(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<quint8>(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<quint32>(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<quint16>(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<ISerialTransport> transport) {
void SerialBackend::setTransport(std::unique_ptr<ISerialTransport> 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);
}