int numRead = 0, numReadTotal = 0;
char buffer[50];

forever {
    numRead  = serial.read(buffer, 50);

    // Do whatever with the array

    numReadTotal += numRead;
    if (numRead == 0 && !serial.waitForReadyRead())
        break;
}

Member Function Documentation

QSerialPort::​QSerialPort(QObject * parent = Q_NULLPTR)

Constructs a new serial port object with the given parent.

QSerialPort::​QSerialPort(const QString & name, QObject * parent = Q_NULLPTR)

Constructs a new serial port object with the given parent to represent the serial port with the specified name.

The name should have a specific format; see the setPort() method.

QSerialPort::​QSerialPort(const QSerialPortInfo & serialPortInfo, QObject * parent = Q_NULLPTR)

Constructs a new serial port object with the given parent to represent the serial port with the specified helper class serialPortInfo.

[virtual] QSerialPort::​~QSerialPort()

Closes the serial port, if necessary, and then destroys object.

[virtual] bool QSerialPort::​atEnd() const

Reimplemented from QIODevice::atEnd().

Returns true if no more data is currently available for reading; otherwise returns false.

This function is most commonly used when reading data from the serial port in a loop. For example:

// This slot is connected to QSerialPort::readyRead()
void QSerialPortClass::readyReadSlot()
{
    while (!port.atEnd()) {
        QByteArray data = port.read(100);
        ....
    }
}

See also bytesAvailable() and readyRead().

[virtual] qint64 QSerialPort::​bytesAvailable() const

Reimplemented from QIODevice::bytesAvailable().

Returns the number of incoming bytes that are waiting to be read.

See also bytesToWrite() and read().

[virtual] qint64 QSerialPort::​bytesToWrite() const

Reimplemented from QIODevice::bytesToWrite().

Returns the number of bytes that are waiting to be written. The bytes are written when control goes back to the event loop or when flush() is called.

See also bytesAvailable() and flush().

[virtual] bool QSerialPort::​canReadLine() const

Reimplemented from QIODevice::canReadLine().

Returns true if a line of data can be read from the serial port; otherwise returns false.

See also readLine().

bool QSerialPort::​clear(Directions directions = AllDirections)

Discards all characters from the output or input buffer, depending on given directions directions. This includes clearing the internal class buffers and the UART (driver) buffers. Also terminate pending read or write operations. If successful, returns true; otherwise returns false.

Note: The serial port has to be open before trying to clear any buffered data; otherwise returns false and sets the NotOpenError error code.

[virtual] void QSerialPort::​close()

Reimplemented from QIODevice::close().

Note: The serial port has to be open before trying to close it; otherwise sets the NotOpenError error code.

See also QIODevice::close().

bool QSerialPort::​flush()

This function writes as much as possible from the internal write buffer to the underlying serial port without blocking. If any data was written, this function returns true; otherwise returns false.

Call this function for sending the buffered data immediately to the serial port. The number of bytes successfully written depends on the operating system. In most cases, this function does not need to be called, because the QSerialPort class will start sending data automatically once control is returned to the event loop. In the absence of an event loop, call waitForBytesWritten() instead.

Note: The serial port has to be open before trying to flush any buffered data; otherwise returns false and sets the NotOpenError error code.

See also write() and waitForBytesWritten().

Handle QSerialPort::​handle() const

If the platform is supported and the serial port is open, returns the native serial port handle; otherwise returns -1.

Warning: This function is for expert use only; use it at your own risk. Furthermore, this function carries no compatibility promise between minor Qt releases.

This function was introduced in Qt 5.2.

[virtual] bool QSerialPort::​isSequential() const

Reimplemented from QIODevice::isSequential().

Always returns true. The serial port is a sequential device.

[virtual] bool QSerialPort::​open(OpenMode mode)

Reimplemented from QIODevice::open().

Opens the serial port using OpenMode mode, and then returns true if successful; otherwise returns false and sets an error code which can be obtained by calling the error() method.

Note: The method returns false if opening the port is successful, but could not set any of the port settings successfully. In that case, the port is closed automatically not to leave the port around with incorrect settings.

Warning: The mode has to be QIODevice::ReadOnly, QIODevice::WriteOnly, or QIODevice::ReadWrite. Other modes are unsupported.

See also QIODevice::OpenMode and setPort().

PinoutSignals QSerialPort::​pinoutSignals()

Returns the state of the line signals in a bitmap format.

From this result, it is possible to allocate the state of the desired signal by applying a mask "AND", where the mask is the desired enumeration value from QSerialPort::PinoutSignals.

Note: This method performs a system call, thus ensuring that the line signal states are returned properly. This is necessary when the underlying operating systems cannot provide proper notifications about the changes.

Note: The serial port has to be open before trying to get the pinout signals; otherwise returns NoSignal and sets the NotOpenError error code.

See also QSerialPort::dataTerminalReady and QSerialPort::requestToSend.

QString QSerialPort::​portName() const

Returns the name set by setPort() or passed to the QSerialPort constructor. This name is short, i.e. it is extracted and converted from the internal variable system location of the device. The conversion algorithm is platform specific:

See also setPortName(), setPort(), and QSerialPortInfo::portName().

qint64 QSerialPort::​readBufferSize() const

Returns the size of the internal read buffer. This limits the amount of data that the client can receive before calling the read() or readAll() methods.

A read buffer size of 0 (the default) means that the buffer has no size limit, ensuring that no data is lost.

See also setReadBufferSize() and read().

[virtual protected] qint64 QSerialPort::​readData(char * data, qint64 maxSize)

Reimplemented from QIODevice::readData().

[virtual protected] qint64 QSerialPort::​readLineData(char * data, qint64 maxSize)

Reimplemented from QIODevice::readLineData().

bool QSerialPort::​sendBreak(int duration = 0)

Sends a continuous stream of zero bits during a specified period of time duration in msec if the terminal is using asynchronous serial data. If successful, returns true; otherwise returns false.

If the duration is zero then zero bits are transmitted by at least 0.25 seconds, but no more than 0.5 seconds.

If the duration is non zero then zero bits are transmitted within a certain period of time depending on the implementation.

Note: The serial port has to be open before trying to send a break duration; otherwise returns false and sets the NotOpenError error code.

See also setBreakEnabled().

bool QSerialPort::​setBreakEnabled(bool set = true)

Controls the signal break, depending on the flag set. If successful, returns true; otherwise returns false.

If set is true then enables the break transmission; otherwise disables.

Note: The serial port has to be open before trying to set break enabled; otherwise returns false and sets the NotOpenError error code.

See also sendBreak().

void QSerialPort::​setPort(const QSerialPortInfo & serialPortInfo)

Sets the port stored in the serial port info instance serialPortInfo.

See also portName() and QSerialPortInfo.

void QSerialPort::​setPortName(const QString & name)

Sets the name of the serial port.

The name of the serial port can be passed as either a short name or the long system location if necessary.

See also portName() and QSerialPortInfo.

void QSerialPort::​setReadBufferSize(qint64 size)

Sets the size of QSerialPort's internal read buffer to be size bytes.

If the buffer size is limited to a certain size, QSerialPort will not buffer more than this size of data. The special case of a buffer size of 0 means that the read buffer is unlimited and all incoming data is buffered. This is the default.

This option is useful if the data is only read at certain points in time (for instance in a real-time streaming application) or if the serial port should be protected against receiving too much data, which may eventually cause the application to run out of memory.

See also readBufferSize() and read().

[virtual] bool QSerialPort::​waitForBytesWritten(int msecs)

Reimplemented from QIODevice::waitForBytesWritten().

[virtual] bool QSerialPort::​waitForReadyRead(int msecs)

Reimplemented from QIODevice::waitForReadyRead().

This function blocks until new data is available for reading and the readyRead() signal has been emitted. The function will timeout after msecs milliseconds.

The function returns true if the readyRead() signal is emitted and there is new data available for reading; otherwise it returns false (if an error occurred or the operation timed out).

See also waitForBytesWritten().

[virtual protected] qint64 QSerialPort::​writeData(const char * data, qint64 maxSize)

Reimplemented from QIODevice::writeData().