SerialPort Class Reference

    #include <SerialPort>

    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

SerialPort::SerialPort ( QObject * parent = 0 )

Constructs a new serial port object with the given parent.

SerialPort::SerialPort ( const QString & name, QObject * parent = 0 )

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.

SerialPort::SerialPort ( const SerialPortInfo & info, QObject * parent = 0 )

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

SerialPort::~SerialPort () [virtual]

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

bool SerialPort::atEnd () const [virtual]

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 SerialPort::readyRead()
    void SerialPortClass::readyReadSlot()
    {
        while (!port.atEnd()) {
            QByteArray data = port.read(100);
            ....
        }
    }

See also bytesAvailable() and readyRead().

qint64 SerialPort::bytesAvailable () const [virtual]

Reimplemented from QIODevice::bytesAvailable().

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

See also bytesToWrite() and read().

qint64 SerialPort::bytesToWrite () const [virtual]

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

bool SerialPort::canReadLine () const [virtual]

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 SerialPort::clear ( Directions dir = AllDirections )

Discards all characters from the output or input buffer, depending on a given direction dir. Including clear an internal class buffers and the UART (driver) buffers. Also terminate pending read or write operations. If successful, returns true; otherwise returns false.

bool SerialPort::clearBreak ( bool clear = true ) [slot]

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

If clear is false then enables the break transmission; otherwise disables.

See also setBreak() and sendBreak().

void SerialPort::close () [virtual]

Reimplemented from QIODevice::close().

Calls SerialPort::flush() and closes the serial port. Errors from flush are ignored.

See also QIODevice::close().

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

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.

See also SerialPort::dataBits.

void SerialPort::dataErrorPolicyChanged ( DataErrorPolicy policy ) [signal]

void SerialPort::dtrChanged ( bool set ) [signal]

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.

See also SerialPort::dtr.

void SerialPort::errorChanged ( PortError error ) [signal]

This signal is emitted after the error has been changed. The new erroris passed as error.

See also SerialPort::error.

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

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

See also SerialPort::flowControl.

bool SerialPort::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 SerialPort class will start sending data automatically once control is returned to the event loop. In the absence of an event loop, call waitForBytesWritten() instead.

See also write() and waitForBytesWritten().

bool SerialPort::isSequential () const [virtual]

Reimplemented from QIODevice::isSequential().

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

Lines SerialPort::lines () const

Returns the bitmap states of the line signals. 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 SerialPort::Lines.

See also dtr(), rts(), setDtr(), and setRts().

bool SerialPort::open ( OpenMode mode ) [virtual]

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

Warning: The mode has to be QIODevice::ReadOnly, QIODevice::WriteOnly, or QIODevice::ReadWrite. This may also have additional flags, such as QIODevice::Unbuffered. Other modes are unsupported.

See also QIODevice::OpenMode and setPort().

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

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

See also SerialPort::parity.

QString SerialPort::portName () const

Returns the name set by setPort() or to the SerialPort constructors. This name is short, i.e. it extract and convert out from the internal variable system location of the device. Conversion algorithm is platform specific:

Platform	Brief Description
Windows	Removes the prefix "\\.\" from the system location and returns the remainder of the string.
Windows CE	Removes the postfix ":" from the system location and returns the remainder of the string.
Symbian	Returns the system location as it is, as it is equivalent to the port name.
GNU/Linux	Removes the prefix "/dev/" from the system location and returns the remainder of the string.
Mac OSX	Removes the prefix "/dev/cu." and "/dev/tty." from the system location and returns the remainder of the string.
Other *nix	The same as for GNU/Linux.

See also setPort() and SerialPortInfo::portName().

void SerialPort::rateChanged ( qint32 rate, Directions dir ) [signal]

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

See also SerialPort::rate.

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

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

Reimplemented from QIODevice::readData().

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

Reimplemented from QIODevice::readLineData().

void SerialPort::restoreSettingsOnCloseChanged ( bool restore ) [signal]

This signal is emitted after the flag which allows to restore the previous settings while closing the serial port has been changed. The new flag which allows to restore the previous settings while closing the serial port is passed as \restore.

See also SerialPort::restoreSettingsOnClose.

void SerialPort::rtsChanged ( bool set ) [signal]

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.

See also SerialPort::rts.

bool SerialPort::sendBreak ( int duration = 0 ) [slot]

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.

See also setBreak() and clearBreak().

bool SerialPort::setBreak ( bool set = true ) [slot]

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.

See also clearBreak() and sendBreak().

void SerialPort::setPort ( const QString & name )

Sets the name of the port. The name may be in any format; either short, or also as system location (with all the prefixes and postfixed). As a result, this name will be automatically written and converted into an internal variable as system location.

See also portName() and SerialPortInfo.

void SerialPort::setPort ( const SerialPortInfo & info )

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

See also portName() and SerialPortInfo.

void SerialPort::setReadBufferSize ( qint64 size )

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

If the buffer size is limited to a certain size, SerialPort will not buffer more than this size of data. Exceptionally, 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 causes that the application runs out of memory.

See also readBufferSize() and read().

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

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.

See also SerialPort::stopBits.

bool SerialPort::waitForBytesWritten ( int msecs ) [virtual]

Reimplemented from QIODevice::waitForBytesWritten().

bool SerialPort::waitForReadyRead ( int msecs ) [virtual]

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

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

Reimplemented from QIODevice::writeData().