Member Function Documentation

QSerialPort::QSerialPort(QObject *parent = nullptr)

Constructs a new serial port object with the given parent.

QSerialPort::QSerialPort(const QString &name, QObject *parent = 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 = 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.

[override 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().

[signal] void QSerialPort::baudRateChanged(qint32 baudRate, QSerialPort::Directions directions)

This signal is emitted after the baud rate has been changed. The new baud rate is passed as baudRate and directions as directions.

Note: Notifier signal for property baudRate.

See also QSerialPort::baudRate.

[override 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().

[override 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().

[override 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(QSerialPort::Directions directions)

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.

[override 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().

[signal] void QSerialPort::dataBitsChanged(QSerialPort::DataBits dataBits)

This signal is emitted after the data bits in a frame has been changed. The new data bits in a frame is passed as dataBits.

Note: Notifier signal for property dataBits.

See also QSerialPort::dataBits.

[signal] void QSerialPort::dataTerminalReadyChanged(bool set)

This signal is emitted after the state (high or low) of the line signal DTR has been changed. The new the state (high or low) of the line signal DTR is passed as set.

Note: Notifier signal for property dataTerminalReady.

See also QSerialPort::dataTerminalReady.

[signal] void QSerialPort::errorOccurred(QSerialPort::SerialPortError error)

This signal is emitted when an error occurs in the serial port. The specified error describes the type of error that occurred.

This function was introduced in Qt 5.8.

See also QSerialPort::error.

[signal] void QSerialPort::flowControlChanged(QSerialPort::FlowControl flow)

This signal is emitted after the flow control mode has been changed. The new flow control mode is passed as flow.

Note: Notifier signal for property flowControl.

See also QSerialPort::flowControl.

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().

QSerialPort::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.

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

Reimplemented from QIODevice::isSequential().

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

[override virtual] bool QSerialPort::open(QIODevice::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().

[signal] void QSerialPort::parityChanged(QSerialPort::Parity parity)

This signal is emitted after the parity checking mode has been changed. The new parity checking mode is passed as parity.

Note: Notifier signal for property parity.

See also QSerialPort::parity.

QSerialPort::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().

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

Reimplemented from QIODevice::readData().

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

Reimplemented from QIODevice::readLineData().

[signal] void QSerialPort::requestToSendChanged(bool set)

This signal is emitted after the state (high or low) of the line signal RTS has been changed. The new the state (high or low) of the line signal RTS is passed as set.

Note: Notifier signal for property requestToSend.

See also QSerialPort::requestToSend.

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().

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().

[signal] void QSerialPort::stopBitsChanged(QSerialPort::StopBits stopBits)

This signal is emitted after the number of stop bits in a frame has been changed. The new number of stop bits in a frame is passed as stopBits.

Note: Notifier signal for property stopBits.

See also QSerialPort::stopBits.

[override virtual] bool QSerialPort::waitForBytesWritten(int msecs = 30000)

Reimplemented from QIODevice::waitForBytesWritten().

This function blocks until at least one byte has been written to the serial port and the bytesWritten() signal has been emitted. The function will timeout after msecs milliseconds; the default timeout is 30000 milliseconds. If msecs is -1, this function will not time out.

The function returns true if the bytesWritten() signal is emitted; otherwise it returns false (if an error occurred or the operation timed out).

[override virtual] bool QSerialPort::waitForReadyRead(int msecs = 30000)

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 default timeout is 30000 milliseconds. If msecs is -1, this function will not time out.

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().

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

Reimplemented from QIODevice::writeData().