如何让我的 Qt 程序持续向我的 Arduino 发送字符串？
How Do I Make My Program in Qt Continually Send A String to My Arduino?
我在尝试让我的程序在按住按钮时持续发送字符串 "move 200" 时遇到了问题。我将按钮设置为自动重复，但它只会在按钮被释放时发送，而不是在按住按钮时发送。然而，当被按住时，计数器会添加消息应该发送的次数。我迷路了。
mainwindow.cpp
void MainWindow::on_forwardButton_clicked()
{
if(arduino->isWritable()){
arduino->write(command.toStdString().c_str());
qDebug() << i;
}else{
qDebug() << "Couldn't write to serial!";
}
ui->label->setText("Moving");
i++;
}
mainwindow.h
ifndef MAINWINDOW_H
define MAINWINDOW_H
include <QMainWindow>
include <QDialog>
include <QSerialPort>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private slots:
void on_forwardButton_clicked();
private:
Ui::MainWindow *ui;
QSerialPort *arduino; //makes arduino a pointer to the SerialPort
bool arduino_is_available;
QString command = "move 200";
bool buttonReleased = false;
};
endif // MAINWINDOW_H
根据@dtech 建议添加的代码
pButtonTimer = new QTimer;
connect(pButtonTimer, SIGNAL(timeout()), this, SLOT(sendData()));
int i = 0;
void MainWindow::on_forwardButton_pressed()
{
pButtonTimer->start(1000);
ui->label->setText("Moving");
qDebug() << "Button Pushed";
}
void MainWindow::on_forwardButton_released()
{
pButtonTimer->stop();
}
void MainWindow::sendData(){
i++; //used to count how many times the command should have been sent
qDebug() << i << "sendData is running"; //notifies me the function has been called
if(arduino->isWritable()){
arduino->write(command.toStdString().c_str());
qDebug() << i << "arduino is writable with command " << command; //lets me know the Arduino is writable
}
else{qDebug() << "Couldn't write to serial!";}
}
松开按钮后，Arduino 中的串行监视器会显示所有已发送的内容，机器人会移动
来自文档：
A push button emits the signal clicked() when it is activated by the mouse, the Spacebar or by a keyboard shortcut. Connect to this signal to perform the button's action. Push buttons also provide less commonly used signals, for example, pressed() and released().
所以请使用 pressed/released 而不是点击。
clicked 在鼠标单击按钮后发送，可能在按钮被释放后发送。我不知道 Qt "knows" 如何处理单击和双击。
pressed 由 "push down" 动作发送，released 由释放动作发送。因此，只需根据这两个信号设置您的标志即可。
顺便说一句：您必须在发送函数周围使用某种循环，通常会定期调用或总是在您的文件 io 变得可写时调用。简单地触发一个 io 不会做你期望的事情。
我建议你稍微扩展一下你的设计：
- 有一个重复
QTimer，间隔取决于您希望发送字符串的速率，以及发送字符串的函数的计时器
- 连接按钮的按下信号以启动定时器
- 连接按钮的释放信号停止定时器
事件只发送一次，因此处理程序只会执行一次，如果你想一直重复它，你将不得不使用定时器或其他一些事件驱动的方式。您不能使用循环，因为那样会阻塞 GUI 线程并且您的应用程序将停止响应。
当然，您可以使用按钮的自动重复，并且可以选择调整触发和重复间隔，但是在逻辑和 GUI 之间划清界线的解决方案更好。您应该真正依赖 GUI 来存储数据或控制内部逻辑。 GUI 应该只是一个前端。
但您需要在串行端口上做更多的工作。如果你打算从 GUI 线程使用它，你将不得不使用非阻塞 API。这将需要更多地扩展您的实施。有一个good example on how to achieve that，你只需要修改它就可以在上一个有效载荷成功发送后简单地启用进一步的有效载荷发送。在伪代码中：
on button press
start timer
on button release
stop timer
onTimeout
if (can send)
send
can send = false
onBytesWritten
accumulate bytes
if (payload is completed)
can send = true
reset payload byte counter
当然，您还必须进行一些错误检查，您不能指望它会起作用。链接的示例包含基本错误处理。
A "blind" 或未经确认的自动重复不是一个好主意，因为 Arduino 可能需要一些时间才能对命令做出反应。鉴于默认情况下您在任何地方都没有流量控制，您将沿途溢出缓冲区 - 在 USB 到串行芯片（如果有的话）以及 Arduino 中。由于您的数据包（线路）没有错误检查，您最终将在 Arduino 上执行垃圾命令，并产生不同的影响。
Arduino 至少应发送一条消息，指示命令已完成。可以是简单的Serial.println("OK")。一旦收到成功回复，您将立即发送下一个命令。
这会稍微减慢速度，因为下一个命令只能在您收到回复并完成发送命令后才能处理。相反，您可以提前预发送一个或多个命令，让Arduino一直处于忙碌状态。
我们可以利用 Qt 对其 PC 端以及 Arduino 进行简洁建模。
下面是一个完整的示例，以文学编程风格编写。
首先，我们需要一个本地管道在 PC 和模型 Arduino 之间进行通信。这比使用 QLocalServer.
容易得多
// https://github.com/KubaO/Whosebugn/tree/master/questions/comm-button-loop-43695121
#include <QtWidgets>
#include <private/qringbuffer_p.h>
#include <cctype>
class AppPipe; // See
为了管理通信，控制器在任何给定时间最多允许两个命令 "in flight"。这是一个非常简单的控制器 - 在生产代码中，我们应该有一个允许错误处理等的显式状态机。参见例如.
class Controller : public QObject {
Q_OBJECT
int m_sent = {}, m_received = {};
QPointer<QIODevice> m_dev;
QByteArray m_command;
QQueue<QByteArray> m_commands;
void sendCommand() {
if (m_command.isEmpty()) return;
while (m_commands.size() < 2) {
m_commands.enqueue(m_command);
m_dev->write(m_command);
m_dev->write("\n");
m_sent ++;
updateStatus();
}
}
Q_SLOT void updateStatus() {
emit statusChanged(m_sent, m_received, m_commands.size());
}
public:
Controller(QIODevice * dev, QObject * parent = {}) : QObject{parent}, m_dev(dev) {
connect(dev, &QIODevice::readyRead, [this]{
if (!m_dev->canReadLine()) return;
auto const replyFor = m_commands.dequeue();
m_received ++;
if (m_dev->readLine() == "OK\n" || m_dev->readLine() == "ERROR\n")
sendCommand();
updateStatus();
Q_UNUSED(replyFor);
});
QMetaObject::invokeMethod(this, "updateStatus", Qt::QueuedConnection);
}
Q_SLOT void setCommand(const QByteArray & cmd) {
m_command = cmd;
sendCommand();
}
Q_SLOT void stop() {
m_command.clear();
}
Q_SIGNAL void statusChanged(int sent, int received, int queueDepth);
};
用户界面提供了一个按钮和一个状态指示器：
class Ui : public QWidget {
Q_OBJECT
QFormLayout m_layout{this};
QPushButton m_move{"Move"};
QLabel m_status;
public:
Ui(QWidget * parent = {}) : QWidget{parent} {
setMinimumWidth(300);
m_layout.addWidget(&m_move);
m_layout.addWidget(&m_status);
connect(&m_move, &QPushButton::pressed, this, &Ui::moveActive);
connect(&m_move, &QPushButton::released, this, &Ui::inactive);
}
Q_SIGNAL void moveActive();
Q_SIGNAL void inactive();
Q_SLOT void setStatus(const QString & status) {
m_status.setText(status);
}
};
我们已经完成了 PC 方面的大部分工作 - 测试设置稍后会在 main.
中进行
我们现在转向 Arduino 方面，模拟一个最小的 Arduino 环境。回想一下 Arduino "language" 真的是 C++11！我们使用 Qt classes.
实现 Arduino 功能
#define F(str) str
QElapsedTimer arduinoTimer;
unsigned long millis() {
return arduinoTimer.elapsed();
}
inline bool isSpace(int c) {
return ( isspace (c) == 0 ? false : true);
}
class Print {
public:
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == nullptr) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size) = 0;
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
size_t print(const char text[]) { return write(text); }
size_t println(const char text[]) { return write(text) + write("\n"); }
size_t println() { return write("\n"); }
};
class Stream : public Print {
public:
virtual int available() = 0;
virtual int read() = 0;
};
class HardwareSerial : public Stream {
QPointer<QIODevice> m_dev;
public:
void setDevice(QIODevice * dev) { m_dev = dev; }
void begin(int) {}
size_t write(uint8_t c) override {
return m_dev->putChar(c) ? 1 : 0;
}
size_t write(const uint8_t * buffer, size_t size) override {
return m_dev->write((const char*)buffer, size);
}
int read() override {
char c;
return m_dev->getChar(&c) ? c : -1;
}
int available() override {
return m_dev->bytesAvailable();
}
} Serial;
我们现在可以编写 Arduino 代码，就像在真正的 Arduino 上出现的那样。 LineEditor 是我在 Arduino 中发现缺失的 class - 它提供异步输入标记化，并在设置 TTY 时允许交互式行编辑。当 运行 在实际的 Arduino 上时，您可以调用 Line.setTTY(true) 并通过 PUTTY 或任何其他终端程序连接到 Arduino。是的 - PUTTY 是一个可以连接到串行端口的通用终端。
template <unsigned int N> class LineEditor {
char m_data[N];
char * m_ptr;
bool m_has : 1; ///< Have we got a complete line yet?
bool m_tty : 1; ///< Are we an interactive application (attached to a terminal)?
LineEditor(const LineEditor &) = delete;
LineEditor & operator=(const LineEditor &) = delete;
public:
LineEditor() : m_tty{false} { clear(); }
void clear() {
m_data[0] = '[=14=]';
m_ptr = m_data;
m_has = false;
}
void input(Stream & str) {
auto const c = str.read();
if (c == '\r' || c == '\n') {
m_has = true;
m_ptr = m_data;
if (m_tty) str.println();
}
else if (m_tty && (c == '\b' || c == 0x7F)) {
if (m_ptr > m_data) {
*--m_ptr = '[=14=]';
str.print(F("\b \b"));
}
}
else if (c >= 32 && c < 127 && m_ptr < m_data+N-1) {
*m_ptr++ = c;
*m_ptr = '[=14=]';
if (m_tty) str.write(c);
}
}
void setTTY(bool tty) { m_tty = tty; }
bool isTTY() const { return m_tty; }
bool ready() const { return m_has; }
char * data() { return m_data; }
unsigned int size() const { return m_ptr-m_data; }
const char * getToken() {
if (!m_has) return nullptr;
char c;
while ((c = *m_ptr) && isSpace(c)) m_ptr++;
auto ret = m_ptr;
while ((c = *m_ptr) && !isSpace(c)) *m_ptr++ = tolower(c);
if (c)
*m_ptr++ = '[=14=]'; // terminate the previous token
return ret;
}
};
LineEditor<32> Line;
void s_input();
void s_moveCommand();
struct {
unsigned long at = {};
void (*handler)() = s_input;
} state ;
void processLine() {
auto const cmd = Line.getToken();
auto const param = Line.getToken();
if (strcmp(cmd, "move") == 0 && param) {
char * end;
auto distance = strtol(param, &end, 10);
if (param != end && distance >= 0 && distance <= 10000) {
// valid move command - pretend that it took some time
state.at = millis() + 1000;
state.handler = s_moveCommand;
}
} else
Serial.println("ERROR");
Line.clear();
}
void s_moveCommand() {
Serial.println("OK");
state.at = {};
state.handler = s_input;
}
void s_input() {
while (Serial.available()) {
Line.input(Serial);
if (Line.ready())
return processLine();
}
}
void setup() {
Serial.begin(9600);
}
void loop() {
if (!state.at || millis() >= state.at)
state.handler();
}
适配器class执行Arduino环境：
class Arduino : public QObject {
QBasicTimer m_loopTimer;
static QPointer<Arduino> m_instance;
void timerEvent(QTimerEvent * event) override {
if (event->timerId() == m_loopTimer.timerId())
loop();
}
public:
Arduino(QObject * parent = {}) : QObject{parent} {
Q_ASSERT(!m_instance);
m_instance = this;
m_loopTimer.start(0, this);
arduinoTimer.start();
setup();
}
};
QPointer<Arduino> Arduino::m_instance;
最后，我们设置测试并连接所有相关组件。
Arduino 对象 运行 在它自己的线程中。
class SafeThread : public QThread {
using QThread::run;
public:
~SafeThread() { quit(); wait(); }
};
int main(int argc, char ** argv) {
using Q = QObject;
QApplication app{argc, argv};
AppPipe ctlPipe(nullptr, QIODevice::ReadWrite | QIODevice::Text);
AppPipe serialPipe(&ctlPipe, QIODevice::ReadWrite | QIODevice::Text);
ctlPipe.addOther(&serialPipe);
Serial.setDevice(&serialPipe);
Controller ctl(&ctlPipe);
Ui ui;
Arduino arduino;
SafeThread thread;
arduino.moveToThread(&thread);
thread.start(QThread::LowPriority);
Q::connect(&ui, &Ui::moveActive, &ctl, [&]{ ctl.setCommand("move 200"); });
Q::connect(&ui, &Ui::inactive, &ctl, [&]{ ctl.stop(); });
Q::connect(&ctl, &Controller::statusChanged, &ui, [&](int s, int r, int d){
ui.setStatus(QStringLiteral("sent=%1 received=%2 queue depth=%3").arg(s).arg(r).arg(d));
});
ui.show();
return app.exec();
}
#include "main.moc"
示例到此结束。您可以将其复制粘贴到一个空的 main.cpp 中，或者您可以从 github.
中获取完整的项目
我在尝试让我的程序在按住按钮时持续发送字符串 "move 200" 时遇到了问题。我将按钮设置为自动重复，但它只会在按钮被释放时发送，而不是在按住按钮时发送。然而，当被按住时，计数器会添加消息应该发送的次数。我迷路了。
mainwindow.cpp
void MainWindow::on_forwardButton_clicked()
{
if(arduino->isWritable()){
arduino->write(command.toStdString().c_str());
qDebug() << i;
}else{
qDebug() << "Couldn't write to serial!";
}
ui->label->setText("Moving");
i++;
}
mainwindow.h
ifndef MAINWINDOW_H
define MAINWINDOW_H
include <QMainWindow>
include <QDialog>
include <QSerialPort>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private slots:
void on_forwardButton_clicked();
private:
Ui::MainWindow *ui;
QSerialPort *arduino; //makes arduino a pointer to the SerialPort
bool arduino_is_available;
QString command = "move 200";
bool buttonReleased = false;
};
endif // MAINWINDOW_H
根据@dtech 建议添加的代码
pButtonTimer = new QTimer;
connect(pButtonTimer, SIGNAL(timeout()), this, SLOT(sendData()));
int i = 0;
void MainWindow::on_forwardButton_pressed()
{
pButtonTimer->start(1000);
ui->label->setText("Moving");
qDebug() << "Button Pushed";
}
void MainWindow::on_forwardButton_released()
{
pButtonTimer->stop();
}
void MainWindow::sendData(){
i++; //used to count how many times the command should have been sent
qDebug() << i << "sendData is running"; //notifies me the function has been called
if(arduino->isWritable()){
arduino->write(command.toStdString().c_str());
qDebug() << i << "arduino is writable with command " << command; //lets me know the Arduino is writable
}
else{qDebug() << "Couldn't write to serial!";}
}
松开按钮后，Arduino 中的串行监视器会显示所有已发送的内容，机器人会移动
来自文档：
A push button emits the signal clicked() when it is activated by the mouse, the Spacebar or by a keyboard shortcut. Connect to this signal to perform the button's action. Push buttons also provide less commonly used signals, for example, pressed() and released().
所以请使用 pressed/released 而不是点击。
clicked 在鼠标单击按钮后发送，可能在按钮被释放后发送。我不知道 Qt "knows" 如何处理单击和双击。
pressed 由 "push down" 动作发送，released 由释放动作发送。因此，只需根据这两个信号设置您的标志即可。
顺便说一句：您必须在发送函数周围使用某种循环，通常会定期调用或总是在您的文件 io 变得可写时调用。简单地触发一个 io 不会做你期望的事情。
我建议你稍微扩展一下你的设计：
- 有一个重复
QTimer，间隔取决于您希望发送字符串的速率，以及发送字符串的函数的计时器 - 连接按钮的按下信号以启动定时器
- 连接按钮的释放信号停止定时器
事件只发送一次，因此处理程序只会执行一次，如果你想一直重复它，你将不得不使用定时器或其他一些事件驱动的方式。您不能使用循环，因为那样会阻塞 GUI 线程并且您的应用程序将停止响应。
当然，您可以使用按钮的自动重复，并且可以选择调整触发和重复间隔，但是在逻辑和 GUI 之间划清界线的解决方案更好。您应该真正依赖 GUI 来存储数据或控制内部逻辑。 GUI 应该只是一个前端。
但您需要在串行端口上做更多的工作。如果你打算从 GUI 线程使用它，你将不得不使用非阻塞 API。这将需要更多地扩展您的实施。有一个good example on how to achieve that，你只需要修改它就可以在上一个有效载荷成功发送后简单地启用进一步的有效载荷发送。在伪代码中：
on button press
start timer
on button release
stop timer
onTimeout
if (can send)
send
can send = false
onBytesWritten
accumulate bytes
if (payload is completed)
can send = true
reset payload byte counter
当然，您还必须进行一些错误检查，您不能指望它会起作用。链接的示例包含基本错误处理。
A "blind" 或未经确认的自动重复不是一个好主意，因为 Arduino 可能需要一些时间才能对命令做出反应。鉴于默认情况下您在任何地方都没有流量控制，您将沿途溢出缓冲区 - 在 USB 到串行芯片（如果有的话）以及 Arduino 中。由于您的数据包（线路）没有错误检查，您最终将在 Arduino 上执行垃圾命令，并产生不同的影响。
Arduino 至少应发送一条消息，指示命令已完成。可以是简单的Serial.println("OK")。一旦收到成功回复，您将立即发送下一个命令。
这会稍微减慢速度，因为下一个命令只能在您收到回复并完成发送命令后才能处理。相反，您可以提前预发送一个或多个命令，让Arduino一直处于忙碌状态。
我们可以利用 Qt 对其 PC 端以及 Arduino 进行简洁建模。
下面是一个完整的示例，以文学编程风格编写。
首先，我们需要一个本地管道在 PC 和模型 Arduino 之间进行通信。这比使用 QLocalServer.
// https://github.com/KubaO/Whosebugn/tree/master/questions/comm-button-loop-43695121
#include <QtWidgets>
#include <private/qringbuffer_p.h>
#include <cctype>
class AppPipe; // See
为了管理通信，控制器在任何给定时间最多允许两个命令 "in flight"。这是一个非常简单的控制器 - 在生产代码中，我们应该有一个允许错误处理等的显式状态机。参见例如
class Controller : public QObject {
Q_OBJECT
int m_sent = {}, m_received = {};
QPointer<QIODevice> m_dev;
QByteArray m_command;
QQueue<QByteArray> m_commands;
void sendCommand() {
if (m_command.isEmpty()) return;
while (m_commands.size() < 2) {
m_commands.enqueue(m_command);
m_dev->write(m_command);
m_dev->write("\n");
m_sent ++;
updateStatus();
}
}
Q_SLOT void updateStatus() {
emit statusChanged(m_sent, m_received, m_commands.size());
}
public:
Controller(QIODevice * dev, QObject * parent = {}) : QObject{parent}, m_dev(dev) {
connect(dev, &QIODevice::readyRead, [this]{
if (!m_dev->canReadLine()) return;
auto const replyFor = m_commands.dequeue();
m_received ++;
if (m_dev->readLine() == "OK\n" || m_dev->readLine() == "ERROR\n")
sendCommand();
updateStatus();
Q_UNUSED(replyFor);
});
QMetaObject::invokeMethod(this, "updateStatus", Qt::QueuedConnection);
}
Q_SLOT void setCommand(const QByteArray & cmd) {
m_command = cmd;
sendCommand();
}
Q_SLOT void stop() {
m_command.clear();
}
Q_SIGNAL void statusChanged(int sent, int received, int queueDepth);
};
用户界面提供了一个按钮和一个状态指示器：
class Ui : public QWidget {
Q_OBJECT
QFormLayout m_layout{this};
QPushButton m_move{"Move"};
QLabel m_status;
public:
Ui(QWidget * parent = {}) : QWidget{parent} {
setMinimumWidth(300);
m_layout.addWidget(&m_move);
m_layout.addWidget(&m_status);
connect(&m_move, &QPushButton::pressed, this, &Ui::moveActive);
connect(&m_move, &QPushButton::released, this, &Ui::inactive);
}
Q_SIGNAL void moveActive();
Q_SIGNAL void inactive();
Q_SLOT void setStatus(const QString & status) {
m_status.setText(status);
}
};
我们已经完成了 PC 方面的大部分工作 - 测试设置稍后会在 main.
我们现在转向 Arduino 方面，模拟一个最小的 Arduino 环境。回想一下 Arduino "language" 真的是 C++11！我们使用 Qt classes.
实现 Arduino 功能#define F(str) str
QElapsedTimer arduinoTimer;
unsigned long millis() {
return arduinoTimer.elapsed();
}
inline bool isSpace(int c) {
return ( isspace (c) == 0 ? false : true);
}
class Print {
public:
virtual size_t write(uint8_t) = 0;
size_t write(const char *str) {
if (str == nullptr) return 0;
return write((const uint8_t *)str, strlen(str));
}
virtual size_t write(const uint8_t *buffer, size_t size) = 0;
size_t write(const char *buffer, size_t size) {
return write((const uint8_t *)buffer, size);
}
size_t print(const char text[]) { return write(text); }
size_t println(const char text[]) { return write(text) + write("\n"); }
size_t println() { return write("\n"); }
};
class Stream : public Print {
public:
virtual int available() = 0;
virtual int read() = 0;
};
class HardwareSerial : public Stream {
QPointer<QIODevice> m_dev;
public:
void setDevice(QIODevice * dev) { m_dev = dev; }
void begin(int) {}
size_t write(uint8_t c) override {
return m_dev->putChar(c) ? 1 : 0;
}
size_t write(const uint8_t * buffer, size_t size) override {
return m_dev->write((const char*)buffer, size);
}
int read() override {
char c;
return m_dev->getChar(&c) ? c : -1;
}
int available() override {
return m_dev->bytesAvailable();
}
} Serial;
我们现在可以编写 Arduino 代码，就像在真正的 Arduino 上出现的那样。 LineEditor 是我在 Arduino 中发现缺失的 class - 它提供异步输入标记化，并在设置 TTY 时允许交互式行编辑。当 运行 在实际的 Arduino 上时，您可以调用 Line.setTTY(true) 并通过 PUTTY 或任何其他终端程序连接到 Arduino。是的 - PUTTY 是一个可以连接到串行端口的通用终端。
template <unsigned int N> class LineEditor {
char m_data[N];
char * m_ptr;
bool m_has : 1; ///< Have we got a complete line yet?
bool m_tty : 1; ///< Are we an interactive application (attached to a terminal)?
LineEditor(const LineEditor &) = delete;
LineEditor & operator=(const LineEditor &) = delete;
public:
LineEditor() : m_tty{false} { clear(); }
void clear() {
m_data[0] = '[=14=]';
m_ptr = m_data;
m_has = false;
}
void input(Stream & str) {
auto const c = str.read();
if (c == '\r' || c == '\n') {
m_has = true;
m_ptr = m_data;
if (m_tty) str.println();
}
else if (m_tty && (c == '\b' || c == 0x7F)) {
if (m_ptr > m_data) {
*--m_ptr = '[=14=]';
str.print(F("\b \b"));
}
}
else if (c >= 32 && c < 127 && m_ptr < m_data+N-1) {
*m_ptr++ = c;
*m_ptr = '[=14=]';
if (m_tty) str.write(c);
}
}
void setTTY(bool tty) { m_tty = tty; }
bool isTTY() const { return m_tty; }
bool ready() const { return m_has; }
char * data() { return m_data; }
unsigned int size() const { return m_ptr-m_data; }
const char * getToken() {
if (!m_has) return nullptr;
char c;
while ((c = *m_ptr) && isSpace(c)) m_ptr++;
auto ret = m_ptr;
while ((c = *m_ptr) && !isSpace(c)) *m_ptr++ = tolower(c);
if (c)
*m_ptr++ = '[=14=]'; // terminate the previous token
return ret;
}
};
LineEditor<32> Line;
void s_input();
void s_moveCommand();
struct {
unsigned long at = {};
void (*handler)() = s_input;
} state ;
void processLine() {
auto const cmd = Line.getToken();
auto const param = Line.getToken();
if (strcmp(cmd, "move") == 0 && param) {
char * end;
auto distance = strtol(param, &end, 10);
if (param != end && distance >= 0 && distance <= 10000) {
// valid move command - pretend that it took some time
state.at = millis() + 1000;
state.handler = s_moveCommand;
}
} else
Serial.println("ERROR");
Line.clear();
}
void s_moveCommand() {
Serial.println("OK");
state.at = {};
state.handler = s_input;
}
void s_input() {
while (Serial.available()) {
Line.input(Serial);
if (Line.ready())
return processLine();
}
}
void setup() {
Serial.begin(9600);
}
void loop() {
if (!state.at || millis() >= state.at)
state.handler();
}
适配器class执行Arduino环境：
class Arduino : public QObject {
QBasicTimer m_loopTimer;
static QPointer<Arduino> m_instance;
void timerEvent(QTimerEvent * event) override {
if (event->timerId() == m_loopTimer.timerId())
loop();
}
public:
Arduino(QObject * parent = {}) : QObject{parent} {
Q_ASSERT(!m_instance);
m_instance = this;
m_loopTimer.start(0, this);
arduinoTimer.start();
setup();
}
};
QPointer<Arduino> Arduino::m_instance;
最后，我们设置测试并连接所有相关组件。
Arduino 对象 运行 在它自己的线程中。
class SafeThread : public QThread {
using QThread::run;
public:
~SafeThread() { quit(); wait(); }
};
int main(int argc, char ** argv) {
using Q = QObject;
QApplication app{argc, argv};
AppPipe ctlPipe(nullptr, QIODevice::ReadWrite | QIODevice::Text);
AppPipe serialPipe(&ctlPipe, QIODevice::ReadWrite | QIODevice::Text);
ctlPipe.addOther(&serialPipe);
Serial.setDevice(&serialPipe);
Controller ctl(&ctlPipe);
Ui ui;
Arduino arduino;
SafeThread thread;
arduino.moveToThread(&thread);
thread.start(QThread::LowPriority);
Q::connect(&ui, &Ui::moveActive, &ctl, [&]{ ctl.setCommand("move 200"); });
Q::connect(&ui, &Ui::inactive, &ctl, [&]{ ctl.stop(); });
Q::connect(&ctl, &Controller::statusChanged, &ui, [&](int s, int r, int d){
ui.setStatus(QStringLiteral("sent=%1 received=%2 queue depth=%3").arg(s).arg(r).arg(d));
});
ui.show();
return app.exec();
}
#include "main.moc"
示例到此结束。您可以将其复制粘贴到一个空的 main.cpp 中，或者您可以从 github.