Question

我在按住按钮时尝试让我的程序不断发送字符串"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中的串行监视器显示发送的所有内容并且机器人移动

Answer 1

我建议你稍微扩展一下你的设计：

重复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

当然，您还必须进行一些错误检查，您不能指望它能够正常工作。链接的示例包含基本错误处理。

Answer 2

来自文档：

当鼠标，空格键或键盘快捷键激活时，按钮会发出clicked（）信号。连接此信号以执行按钮的操作。按钮还提供较少使用的信号，例如，按下（）和释放（）。

所以请使用按下/释放而不是点击。

一旦鼠标点击按钮，就可以发送

clicked，也许在它被释放后发送。我不知道Qt如何“知道”处理单击和双击。

pressed由“下推”操作发送，released由发布操作发送。因此，只需根据两个信号设置标志。

顺便说一句：你必须在发送函数时使用某种循环，通常是定期调用，或者总是在文件io变得可写时调用。简单地在io上开火不会达到预期效果。

Answer 3

“盲目”或未经证实的自动重复不是一个好主意，因为可能是Arduino需要一些时间来对命令作出反应。鉴于默认情况下你在任何地方都没有流量控制，你将沿着途径溢出缓冲区 - 在USB到串行芯片（如果有的话），以及在Arduino中。由于你的数据包（行）没有错误检查，你最终会在Arduino上执行垃圾命令，效果会有所不同。

至少，Arduino应发送一条消息，指示命令已完成。它可以是一个简单的Serial.println("OK")。然后，您会在收到成功回复后立即发送下一个命令。

由于下一个命令只能在您收到回复并完成发送命令后才能处理，因此这会减慢速度。相反，您可以提前预先发送一个或多个命令，以便Arduino始终处于忙碌状态。

我们可以利用Qt简洁地模拟它的PC端以及Arduino。

下面是一个完整的例子，用文字编程风格写成。

首先，我们需要一个本地管道来在PC和模型Arduino之间进行通信。这比使用QLocalServer容易得多。

// https://github.com/KubaO/stackoverflown/tree/master/questions/comm-button-loop-43695121
#include <QtWidgets>
#include <private/qringbuffer_p.h>
#include <cctype>

class AppPipe; // See https://stackoverflow.com/a/32317276/1329652

为了管理通信，控制器在任何给定时间允许“飞行中”最多两个命令。这是一个非常简单的控制器 - 在生产代码中，我们应该有一个显式的状态机，允许错误处理等。 this question

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“语言”真的是C ++ 11！我们使用Qt类实现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中找不到的类 - 它提供异步输入标记化，并允许在设置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] = '\0';
      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 = '\0';
            str.print(F("\b \b"));
         }
      }
      else if (c >= 32 && c < 127 && m_ptr < m_data+N-1) {
         *m_ptr++ = c;
         *m_ptr = '\0';
         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++ = '\0'; // 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();
}

适配器类执行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获取完整的项目。

如何在Qt中创建我的程序不断向我的Arduino发送一个字符串？

3 个答案: