发送一系列命令并等待响应

Question

我必须更新连接到串行端口的设备上的固件和设置。由于这是通过一系列命令完成的，因此我发送一个命令并等待直到收到答复。在 answere（多行）中，我搜索一个字符串，指示操作是否成功完成。

Serial->write(“boot”, 1000);
Serial->waitForKeyword(“boot successful”);
Serial->sendFile(“image.dat”);
…

所以我为这个阻塞 read/write 方法创建了一个新线程。在线程内部，我使用了 waitForX() 函数。如果我调用 watiForKeyword() 它将调用 readLines() 直到它检测到关键字或超时

bool waitForKeyword(const QString &keyword)
{
    QString str;

    // read all lines
    while(serial->readLines(10000))
    {
        // check each line
        while((str = serial->getLine()) != "")
        {
            // found!
            if(str.contains(keyword))
                return true;
        }
    }
    // timeout
    return false;
}

readLines() 读取所有可用的内容并将其分成几行，每行都放在 QStringList 中并获取一个字符串，我调用 getLine() returns 列表中的第一个字符串并将其删除.

bool SerialPort::readLines(int waitTimeout)
{
if(!waitForReadyRead(waitTimeout))
{
    qDebug() << "Timeout reading" << endl;
    return false;
}

QByteArray data = readAll();
while (waitForReadyRead(100))
    data += readAll();

char* begin = data.data();
char* ptr = strstr(data, "\r\n");

while(ptr != NULL)
{
    ptr+=2;
    buffer.append(begin, ptr - begin);
    emit readyReadLine(buffer);
    lineBuffer.append(QString(buffer)); // store line in Qstringlist
    buffer.clear();

    begin = ptr;
    ptr = strstr(begin, "\r\n");
}
// rest
buffer.append(begin, -1);
return true;
}

问题是如果我通过终端发送文件来测试应用程序 readLines() 将只读取文件的一小部分（5 行左右）。由于这些行不包含关键字。该函数将再次运行，但这次它不会等待超时，readLines 会立即 return false。怎么了？我也不确定这是否是正确的方法...有谁知道如何每次发送一系列命令并等待响应？

Answer 1

我不确定这是否是正确的方法。

您正在与 waitForReadyRead() 进行投票。但是由于串口是QIODevice，当有东西到达串口时，它会发出一个void QIODevice::readyRead()信号。为什么不将此信号连接到您的输入解析代码？不需要 waitForReadyRead().

Also/on 另一方面：“...这次它不等待超时，readLines 立即 return false。怎么了？”

引用文档：

If waitForReadyRead() returns false, the connection has been closed or an error has occurred.

（强调我的）根据我作为嵌入式开发人员的经验，将设备置于某种 "firmware upgrade" 模式并非不可能，并且通过这样做设备会重新启动到特殊的启动模式（而不是运行固件你即将更新）并因此关闭了连接。除非 documented/you 与设备开发人员联系，否则无法判断。使用串行终端输入命令并见证这一点并不明显，我每天使用 minicom 连接到我的设备并且它在重新启动时非常有弹性 - 对我有好处。

Answer 2

让我们使用 QStateMachine 来简化这个过程。让我们回忆一下您希望这样的代码看起来如何：

Serial->write("boot", 1000);
Serial->waitForKeyword("boot successful");
Serial->sendFile("image.dat");

让我们把它放在一个 class 中，它为程序员可能处于的每个状态都有明确的状态成员。我们还将有动作生成器 send、expect 等。将给定的动作附加到状态。

// https://github.com/KubaO/Whosebugn/tree/master/questions/comm-commands-32486198
#include <QtWidgets>
#include <private/qringbuffer_p.h>
#include <type_traits>

[...]

class Programmer : public StatefulObject {
   Q_OBJECT
   AppPipe m_port { nullptr, QIODevice::ReadWrite, this };
   State      s_boot   { &m_mach, "s_boot" },
              s_send   { &m_mach, "s_send" };
   FinalState s_ok     { &m_mach, "s_ok" },
              s_failed { &m_mach, "s_failed" };
public:
   Programmer(QObject * parent = 0) : StatefulObject(parent) {
      connectSignals();
      m_mach.setInitialState(&s_boot);
      send  (&s_boot, &m_port, "boot\n");
      expect(&s_boot, &m_port, "boot successful", &s_send, 1000, &s_failed);
      send  (&s_send, &m_port, ":HULLOTHERE\n:00000001FF\n");
      expect(&s_send, &m_port, "load successful", &s_ok, 1000, &s_failed);
   }
   AppPipe & pipe() { return m_port; }
};

这是面向程序员的功能齐全、完整的代码！完全异步、非阻塞，它也处理超时。

可以拥有即时生成状态的基础结构，这样您就不必手动创建所有状态。如果您有明确的状态，代码要小得多，恕我直言，更容易理解。仅对于具有 50-100 多个状态的复杂通信协议，摆脱显式命名状态才有意义。

AppPipe是一个简单的进程内双向管道，可以作为真实串口的替代品：

// See 
/// A simple point-to-point intra-process pipe. The other endpoint can live in any
/// thread.
class AppPipe : public QIODevice {
  [...]
};

StatefulObject 包含一个状态机，一些用于监视状态机进度的基本信号，以及用于将信号与状态连接的 connectSignals 方法：

class StatefulObject : public QObject {
   Q_OBJECT
   Q_PROPERTY (bool running READ isRunning NOTIFY runningChanged)
protected:
   QStateMachine m_mach  { this };
   StatefulObject(QObject * parent = 0) : QObject(parent) {}
   void connectSignals() {
      connect(&m_mach, &QStateMachine::runningChanged, this, &StatefulObject::runningChanged);
      for (auto state : m_mach.findChildren<QAbstractState*>())
         QObject::connect(state, &QState::entered, this, [this, state]{
            emit stateChanged(state->objectName());
         });
   }
public:
   Q_SLOT void start() { m_mach.start(); }
   Q_SIGNAL void runningChanged(bool);
   Q_SIGNAL void stateChanged(const QString &);
   bool isRunning() const { return m_mach.isRunning(); }
};

State 和 FinalState 是 Qt 3 风格的简单命名状态包装器。它们允许我们一次性声明状态并为其命名。

template <class S> struct NamedState : S {
   NamedState(QState * parent, const char * name) : S(parent) {
      this->setObjectName(QLatin1String(name));
   }
};
typedef NamedState<QState> State;
typedef NamedState<QFinalState> FinalState;

动作生成器也非常简单。动作生成器的意思是“当进入给定状态时做某事”。要采取行动的状态始终作为第一个参数给出。第二个和后续参数特定于给定的操作。有时，一个动作可能还需要一个目标状态，例如如果成功或失败。

void send(QAbstractState * src, QIODevice * dev, const QByteArray & data) {
   QObject::connect(src, &QState::entered, dev, [dev, data]{
      dev->write(data);
   });
}

QTimer * delay(QState * src, int ms, QAbstractState * dst) {
   auto timer = new QTimer(src);
   timer->setSingleShot(true);
   timer->setInterval(ms);
   QObject::connect(src, &QState::entered, timer, static_cast<void (QTimer::*)()>(&QTimer::start));
   QObject::connect(src, &QState::exited,  timer, &QTimer::stop);
   src->addTransition(timer, SIGNAL(timeout()), dst);
   return timer;
}

void expect(QState * src, QIODevice * dev, const QByteArray & data, QAbstractState * dst,
            int timeout = 0, QAbstractState * dstTimeout = nullptr)
{
   addTransition(src, dst, dev, SIGNAL(readyRead()), [dev, data]{
      return hasLine(dev, data);
   });
   if (timeout) delay(src, timeout, dstTimeout);
}

hasLine 测试只是检查可以从给定针的设备读取的所有行。这适用于这个简单的通信协议。如果您的通信涉及更多，您将需要更复杂的机器。有必要阅读所有的行，即使你找到了你的针。这是因为此测试是从 readyRead 信号调用的，在该信号中，您必须读取满足所选标准的所有数据。这里的标准是数据是整行的。

static bool hasLine(QIODevice * dev, const QByteArray & needle) {
   auto result = false;
   while (dev->canReadLine()) {
      auto line = dev->readLine();
      if (line.contains(needle)) result = true;
   }
   return result;
}

使用默认 API 向状态添加受保护的转换有点麻烦，因此我们将其包装起来使其更易于使用，并保持上面的动作生成器可读：

template <typename F>
class GuardedSignalTransition : public QSignalTransition {
   F m_guard;
protected:
   bool eventTest(QEvent * ev) Q_DECL_OVERRIDE {
      return QSignalTransition::eventTest(ev) && m_guard();
   }
public:
   GuardedSignalTransition(const QObject * sender, const char * signal, F && guard) :
      QSignalTransition(sender, signal), m_guard(std::move(guard)) {}
   GuardedSignalTransition(const QObject * sender, const char * signal, const F & guard) :
      QSignalTransition(sender, signal), m_guard(guard) {}
};

template <typename F> static GuardedSignalTransition<F> *
addTransition(QState * src, QAbstractState *target,
              const QObject * sender, const char * signal, F && guard) {
   auto t = new GuardedSignalTransition<typename std::decay<F>::type>
         (sender, signal, std::forward<F>(guard));
   t->setTargetState(target);
   src->addTransition(t);
   return t;
}

仅此而已 - 如果您有一个真实的设备，这就是您所需要的。由于我没有你的设备，我将创建另一个 StatefulObject 来模拟假定的设备行为：

class Device : public StatefulObject {
   Q_OBJECT
   AppPipe m_dev { nullptr, QIODevice::ReadWrite, this };
   State      s_init     { &m_mach, "s_init" },
              s_booting  { &m_mach, "s_booting" },
              s_firmware { &m_mach, "s_firmware" };
   FinalState s_loaded   { &m_mach, "s_loaded" };
public:
   Device(QObject * parent = 0) : StatefulObject(parent) {
      connectSignals();
      m_mach.setInitialState(&s_init);
      expect(&s_init, &m_dev, "boot", &s_booting);
      delay (&s_booting, 500, &s_firmware);
      send  (&s_firmware, &m_dev, "boot successful\n");
      expect(&s_firmware, &m_dev, ":00000001FF", &s_loaded);
      send  (&s_loaded,   &m_dev, "load successful\n");
   }
   Q_SLOT void stop() { m_mach.stop(); }
   AppPipe & pipe() { return m_dev; }
};

现在让我们把它形象化。我们将有一个 window，带有显示通信内容的文本浏览器。下面是 start/stop 编程器或设备的按钮，以及指示仿真设备和编程器状态的标签：

int main(int argc, char ** argv) {
   using Q = QObject;
   QApplication app{argc, argv};
   Device dev;
   Programmer prog;

   QWidget w;
   QGridLayout grid{&w};
   QTextBrowser comms;
   QPushButton devStart{"Start Device"}, devStop{"Stop Device"},
               progStart{"Start Programmer"};
   QLabel devState, progState;
   grid.addWidget(&comms, 0, 0, 1, 3);
   grid.addWidget(&devState, 1, 0, 1, 2);
   grid.addWidget(&progState, 1, 2);
   grid.addWidget(&devStart, 2, 0);
   grid.addWidget(&devStop, 2, 1);
   grid.addWidget(&progStart, 2, 2);
   devStop.setDisabled(true);
   w.show();

我们将连接设备和程序员的 AppPipe。我们还将可视化程序员发送和接收的内容：

   dev.pipe().addOther(&prog.pipe());
   prog.pipe().addOther(&dev.pipe());
   Q::connect(&prog.pipe(), &AppPipe::hasOutgoing, &comms, [&](const QByteArray & data){
      comms.append(formatData("&gt;", "blue", data));
   });
   Q::connect(&prog.pipe(), &AppPipe::hasIncoming, &comms, [&](const QByteArray & data){
      comms.append(formatData("&lt;", "green", data));
   });

最后，我们将连接按钮和标签：

   Q::connect(&devStart, &QPushButton::clicked, &dev, &Device::start);
   Q::connect(&devStop, &QPushButton::clicked, &dev, &Device::stop);
   Q::connect(&dev, &Device::runningChanged, &devStart, &QPushButton::setDisabled);
   Q::connect(&dev, &Device::runningChanged, &devStop, &QPushButton::setEnabled);
   Q::connect(&dev, &Device::stateChanged, &devState, &QLabel::setText);
   Q::connect(&progStart, &QPushButton::clicked, &prog, &Programmer::start);
   Q::connect(&prog, &Programmer::runningChanged, &progStart, &QPushButton::setDisabled);
   Q::connect(&prog, &Programmer::stateChanged, &progState, &QLabel::setText);
   return app.exec();
}

#include "main.moc"

Programmer 和 Device 可以存在于任何线程中。我将它们留在主线程中，因为没有理由将它们移出，但您可以将它们都放入一个专用线程中，或者每个都放入自己的线程中，或者放入与其他对象共享的线程中，等等。它是完全透明的，因为 AppPipe 支持跨线程通信。如果使用 QSerialPort 而不是 AppPipe，情况也会如此。重要的是 QIODevice 的每个实例仅从一个线程使用。其他一切都通过 signal/slot 连接发生。

例如如果你想让 Programmer 存在于一个专用线程中，你可以在 main 的某处添加以下内容：

  // fix QThread brokenness
  struct Thread : QThread { ~Thread() { quit(); wait(); } };

  Thread progThread;
  prog.moveToThread(&progThread);
  progThread.start();

一个小帮手格式化数据以使其更易于阅读：

static QString formatData(const char * prefix, const char * color, const QByteArray & data) {
   auto text = QString::fromLatin1(data).toHtmlEscaped();
   if (text.endsWith('\n')) text.truncate(text.size() - 1);
   text.replace(QLatin1Char('\n'), QString::fromLatin1("<br/>%1 ").arg(QLatin1String(prefix)));
   return QString::fromLatin1("<font color=\"%1\">%2 %3</font><br/>")
         .arg(QLatin1String(color)).arg(QLatin1String(prefix)).arg(text);
}

发送一系列命令并等待响应

Sending a sequence of commands and wait for response

c++

qt

serial-port

blocking