This section contains snippets that were automatically translated from C++ to Python and may contain errors.
Shows how to use the synchronous API of
QSerialPort in a worker thread.
Blocking Sender shows how to create an application for a serial interface using the synchronous API of
QSerialPort in a worker thread.
QSerialPort supports two programming alternatives:
The asynchronous (non-blocking) alternative. Operations are scheduled and performed when the control returns to the Qt event loop. The
QSerialPortclass emits a signal when the operation is finished. For example, the
write()method returns immediately. When the data is sent to the serial port, the
QSerialPortclass emits the
The synchronous (blocking) alternative. In headless and multithreaded applications, the wait method can be called (in this case,
waitForReadyRead()) to suspend the calling thread until the operation has completed.
In this example, the synchronous alternative is demonstrated. The Terminal example illustrates the asynchronous alternative.
The purpose of this example is to demonstrate how to simplify your serial programming code without losing the responsiveness of the user interface. The blocking serial programming API often leads to simpler code, but it should only be used in non-GUI threads to keep the user interface responsive.
This application is the sender which demonstrates the work paired with the receiver application Blocking Receiver example .
The sender application initiates the transfer request via the serial port to the receiver application and waits for response.
class SenderThread(QThread): Q_OBJECT # public SenderThread = explicit(QObject parent = None) ~SenderThread() def transaction(portName, waitTimeout, request): # signals def response(s): def error(s): def timeout(s): # private def run(): m_portName = QString() m_request = QString() m_waitTimeout = 0 m_mutex = QMutex() m_cond = QWaitCondition() m_quit = False
SenderThread is a
QThread subclass that provides API for scheduling requests to the receiver. This class provides signals for responding and reporting errors. The transaction() method can be called to start up the new sender transaction with the desired request. The result is provided by the response() signal. In case of any issues, the error() or timeout() signal is emitted.
Note, the transaction() method is called in the main thread, but the request is provided in the SenderThread thread. The SenderThread data members are read and written concurrently in different threads, thus the
QMutex class is used to synchronize the access.
def transaction(self, portName, waitTimeout, request): locker = QMutexLocker(m_mutex) m_portName = portName m_waitTimeout = waitTimeout m_request = request if not isRunning(): start() else: m_cond.wakeOne()
The transaction() method stores the serial port name, timeout and request data. The mutex can be locked with
QMutexLocker to protect this data. The thread can be started then, unless it is already running. The
wakeOne() method is discussed later.
def run(self): currentPortNameChanged = False m_mutex.lock() currentPortName = QString() if currentPortName != m_portName: currentPortName = m_portName currentPortNameChanged = True currentWaitTimeout = m_waitTimeout currentRequest = m_request m_mutex.unlock()
In the run() function, the first is to lock the
QMutex object, then fetch the serial port name, timeout and request data by using the member data. Having that done, the
QMutex lock is released.
Under no circumstance should the
transaction() method be called simultaneously with a process fetching the data. Note, while the
QString class is reentrant, it is not thread-safe. Thereby, it is not recommended to read the serial port name in a request thread, and timeout or request data in another thread. The SenderThread class can only handle one request at a time.
QSerialPort object is constructed on stack in the run() method before entering the loop:
serial = QSerialPort() if currentPortName.isEmpty(): error.emit(tr("No port name specified")) return while not m_quit:
This makes it possible to create an object while running the loop. It also means that all the object methods are executed in the scope of the run() method.
It is checked inside the loop whether or not the serial port name of the current transaction has changed. If this has changed, the serial port is reopened and then reconfigured.
if currentPortNameChanged: serial.close() serial.setPortName(currentPortName) if not serial.open(QIODevice.ReadWrite): error.emit(tr("Can't open %1, error code %2") .arg(m_portName).arg(serial.error())) return
The loop will continue to request data, write to the serial port and wait until all data is transferred.
# write request requestData = currentRequest.toUtf8() serial.write(requestData) if serial.waitForBytesWritten(m_waitTimeout):
As for the blocking transfer, the
waitForBytesWritten() method should be used after each
write method call. This will process all the I/O routines instead of the Qt event loop.
The timeout() signal is emitted if a timeout error occurs when transferring data.
else: timeout.emit(tr("Wait write request timeout %1") .arg(QTime.currentTime().toString()))
There is a waiting period for response after a successful request, and then it is read again.
# read response if serial.waitForReadyRead(currentWaitTimeout): responseData = serial.readAll() while serial.waitForReadyRead(10): responseData += serial.readAll() response = QString.fromUtf8(responseData) self.response.emit(response)
As for the blocking alternative, the
waitForReadyRead() method should be used before each read() call. This will processes all the I/O routines instead of the Qt event loop.
The timeout() signal is emitted if a timeout error occurs when receiving data.
else: timeout.emit(tr("Wait read response timeout %1") .arg(QTime.currentTime().toString()))
When a transaction has been completed successfully, the response() signal contains the data received from the receiver application:
Afterwards, the thread goes to sleep until the next transaction appears. The thread reads the new data after waking up by using the members and runs the loop from the beginning.
m_mutex.lock() m_cond.wait(m_mutex) if currentPortName != m_portName: currentPortName = m_portName currentPortNameChanged = True else: currentPortNameChanged = False currentWaitTimeout = m_waitTimeout currentRequest = m_request m_mutex.unlock()