Sending a sequence of commands and waiting for a response

In your scenario, a thread is responding to a blocking read/write method, waiting until it detects a keyword or times out using waitForKeyword(). Unfortunately, when readLines() is utilized to test the app, only a small portion of the file is obtained. Additionally, readLines immediately returns false during the second iteration without waiting for timeout.

Understanding the problem

The issue stems from the design of readLines(), which reads all available data and separates it into lines. When a sequence of commands is being processed, readLines() reads only the first part of the file because it doesn't detect the keyword. Subsequently, when it's called again, readLines() returns false as it has already iterated over the entire available data.

Achieving a reliable approach

To effectively send a sequence of commands and wait for their responses, consider utilizing a state machine approach. This provides a structured and reliable method for managing the flow of commands and responses, ensuring that the expected response is received before proceeding.

Example implementation

The following snippet demonstrates a state machine implementation using Qt's QStateMachine and related classes:

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; }
};

In this example, Programmer encapsulates the state machine and provides an interface to communicate with the device. State transitions are defined using the send() and expect() functions to handle sending commands and waiting for expected responses, respectively.

Advantages of this approach

Using a state machine has several advantages:

• Structured flow control: The state machine ensures a well-defined sequence of commands and responses, preventing out-of-order communication.
• Timeout handling: Timeouts can be specified for each expected response, ensuring that the system doesn't hang indefinitely.
• Error handling: Final error states can be defined to capture communication failures, enabling appropriate error handling.
• Asynchronous nature: The state machine can be executed concurrently with the main application, eliminating blocking issues.