qt_demoe/tool/3rd_qextserialport/qextserialport.cpp

1096 lines
30 KiB
C++

/****************************************************************************
** Copyright (c) 2000-2003 Wayne Roth
** Copyright (c) 2004-2007 Stefan Sander
** Copyright (c) 2007 Michal Policht
** Copyright (c) 2008 Brandon Fosdick
** Copyright (c) 2009-2010 Liam Staskawicz
** Copyright (c) 2011 Debao Zhang
** All right reserved.
** Web: http://code.google.com/p/qextserialport/
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**
****************************************************************************/
#include "qextserialport.h"
#include "qextserialport_p.h"
#include <stdio.h>
#include <QtCore/QDebug>
#include <QtCore/QReadLocker>
#include <QtCore/QWriteLocker>
/*!
\class PortSettings
\brief The PortSettings class contain port settings
Structure to contain port settings.
\code
BaudRateType BaudRate;
DataBitsType DataBits;
ParityType Parity;
StopBitsType StopBits;
FlowType FlowControl;
long Timeout_Millisec;
\endcode
*/
QextSerialPortPrivate::QextSerialPortPrivate(QextSerialPort *q)
: lock(QReadWriteLock::Recursive), q_ptr(q)
{
lastErr = E_NO_ERROR;
settings.BaudRate = BAUD9600;
settings.Parity = PAR_NONE;
settings.FlowControl = FLOW_OFF;
settings.DataBits = DATA_8;
settings.StopBits = STOP_1;
settings.Timeout_Millisec = 10;
settingsDirtyFlags = DFE_ALL;
platformSpecificInit();
}
QextSerialPortPrivate::~QextSerialPortPrivate()
{
platformSpecificDestruct();
}
void QextSerialPortPrivate::setBaudRate(BaudRateType baudRate, bool update)
{
switch (baudRate) {
#ifdef Q_OS_WIN
//Windows Special
case BAUD14400:
case BAUD56000:
case BAUD128000:
case BAUD256000:
QESP_PORTABILITY_WARNING() << "QextSerialPort Portability Warning: POSIX does not support baudRate:" << baudRate;
#elif defined(Q_OS_UNIX)
//Unix Special
case BAUD50:
case BAUD75:
case BAUD134:
case BAUD150:
case BAUD200:
case BAUD1800:
# ifdef B76800
case BAUD76800:
# endif
# if defined(B230400) && defined(B4000000)
case BAUD230400:
case BAUD460800:
case BAUD500000:
case BAUD576000:
case BAUD921600:
case BAUD1000000:
case BAUD1152000:
case BAUD1500000:
case BAUD2000000:
case BAUD2500000:
case BAUD3000000:
case BAUD3500000:
case BAUD4000000:
# endif
QESP_PORTABILITY_WARNING() << "QextSerialPort Portability Warning: Windows does not support baudRate:" << baudRate;
#endif
case BAUD110:
case BAUD300:
case BAUD600:
case BAUD1200:
case BAUD2400:
case BAUD4800:
case BAUD9600:
case BAUD19200:
case BAUD38400:
case BAUD57600:
case BAUD115200:
#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
default:
#endif
settings.BaudRate = baudRate;
settingsDirtyFlags |= DFE_BaudRate;
if (update && q_func()->isOpen()) {
updatePortSettings();
}
break;
#if !(defined(Q_OS_WIN) || defined(Q_OS_MAC))
default:
QESP_WARNING() << "QextSerialPort does not support baudRate:" << baudRate;
#endif
}
}
void QextSerialPortPrivate::setParity(ParityType parity, bool update)
{
switch (parity) {
case PAR_SPACE:
if (settings.DataBits == DATA_8) {
#ifdef Q_OS_WIN
QESP_PORTABILITY_WARNING("QextSerialPort Portability Warning: Space parity with 8 data bits is not supported by POSIX systems.");
#else
QESP_WARNING("Space parity with 8 data bits is not supported by POSIX systems.");
#endif
}
break;
#ifdef Q_OS_WIN
/*mark parity - WINDOWS ONLY*/
case PAR_MARK:
QESP_PORTABILITY_WARNING("QextSerialPort Portability Warning: Mark parity is not supported by POSIX systems");
break;
#endif
case PAR_NONE:
case PAR_EVEN:
case PAR_ODD:
break;
default:
QESP_WARNING() << "QextSerialPort does not support Parity:" << parity;
}
settings.Parity = parity;
settingsDirtyFlags |= DFE_Parity;
if (update && q_func()->isOpen()) {
updatePortSettings();
}
}
void QextSerialPortPrivate::setDataBits(DataBitsType dataBits, bool update)
{
switch (dataBits) {
case DATA_5:
if (settings.StopBits == STOP_2) {
QESP_WARNING("QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
} else {
settings.DataBits = dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
case DATA_6:
#ifdef Q_OS_WIN
if (settings.StopBits == STOP_1_5) {
QESP_WARNING("QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
} else
#endif
{
settings.DataBits = dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
case DATA_7:
#ifdef Q_OS_WIN
if (settings.StopBits == STOP_1_5) {
QESP_WARNING("QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
} else
#endif
{
settings.DataBits = dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
case DATA_8:
#ifdef Q_OS_WIN
if (settings.StopBits == STOP_1_5) {
QESP_WARNING("QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
} else
#endif
{
settings.DataBits = dataBits;
settingsDirtyFlags |= DFE_DataBits;
}
break;
default:
QESP_WARNING() << "QextSerialPort does not support Data bits:" << dataBits;
}
if (update && q_func()->isOpen()) {
updatePortSettings();
}
}
void QextSerialPortPrivate::setStopBits(StopBitsType stopBits, bool update)
{
switch (stopBits) {
/*one stop bit*/
case STOP_1:
settings.StopBits = stopBits;
settingsDirtyFlags |= DFE_StopBits;
break;
#ifdef Q_OS_WIN
/*1.5 stop bits*/
case STOP_1_5:
QESP_PORTABILITY_WARNING("QextSerialPort Portability Warning: 1.5 stop bit operation is not supported by POSIX.");
if (settings.DataBits != DATA_5) {
QESP_WARNING("QextSerialPort: 1.5 stop bits can only be used with 5 data bits");
} else {
settings.StopBits = stopBits;
settingsDirtyFlags |= DFE_StopBits;
}
break;
#endif
/*two stop bits*/
case STOP_2:
if (settings.DataBits == DATA_5) {
QESP_WARNING("QextSerialPort: 2 stop bits cannot be used with 5 data bits");
} else {
settings.StopBits = stopBits;
settingsDirtyFlags |= DFE_StopBits;
}
break;
default:
QESP_WARNING() << "QextSerialPort does not support stop bits: " << stopBits;
}
if (update && q_func()->isOpen()) {
updatePortSettings();
}
}
void QextSerialPortPrivate::setFlowControl(FlowType flow, bool update)
{
settings.FlowControl = flow;
settingsDirtyFlags |= DFE_Flow;
if (update && q_func()->isOpen()) {
updatePortSettings();
}
}
void QextSerialPortPrivate::setTimeout(long millisec, bool update)
{
settings.Timeout_Millisec = millisec;
settingsDirtyFlags |= DFE_TimeOut;
if (update && q_func()->isOpen()) {
updatePortSettings();
}
}
void QextSerialPortPrivate::setPortSettings(const PortSettings &settings, bool update)
{
setBaudRate(settings.BaudRate, false);
setDataBits(settings.DataBits, false);
setStopBits(settings.StopBits, false);
setParity(settings.Parity, false);
setFlowControl(settings.FlowControl, false);
setTimeout(settings.Timeout_Millisec, false);
settingsDirtyFlags = DFE_ALL;
if (update && q_func()->isOpen()) {
updatePortSettings();
}
}
void QextSerialPortPrivate::_q_canRead()
{
qint64 maxSize = bytesAvailable_sys();
if (maxSize > 0) {
char *writePtr = readBuffer.reserve(size_t(maxSize));
qint64 bytesRead = readData_sys(writePtr, maxSize);
if (bytesRead < maxSize) {
readBuffer.chop(maxSize - bytesRead);
}
Q_Q(QextSerialPort);
Q_EMIT q->readyRead();
}
}
/*! \class QextSerialPort
\brief The QextSerialPort class encapsulates a serial port on both POSIX and Windows systems.
\section1 Usage
QextSerialPort offers both a polling and event driven API. Event driven
is typically easier to use, since you never have to worry about checking
for new data.
\bold Example
\code
QextSerialPort *port = new QextSerialPort("COM1");
connect(port, SIGNAL(readyRead()), myClass, SLOT(onDataAvailable()));
port->open();
void MyClass::onDataAvailable()
{
QByteArray data = port->readAll();
processNewData(usbdata);
}
\endcode
\section1 Compatibility
The user will be notified of errors and possible portability conflicts at run-time
by default.
For example, if a application has used BAUD1800, when it is runing under unix, you
will get following message.
\code
QextSerialPort Portability Warning: Windows does not support baudRate:1800
\endcode
This behavior can be turned off by defining macro QESP_NO_WARN (to turn off all warnings)
or QESP_NO_PORTABILITY_WARN (to turn off portability warnings) in the project.
\bold Author: Stefan Sander, Michal Policht, Brandon Fosdick, Liam Staskawicz, Debao Zhang
*/
/*!
\enum QextSerialPort::QueryMode
This enum type specifies query mode used in a serial port:
\value Polling
asynchronously read and write
\value EventDriven
synchronously read and write
*/
/*!
\fn void QextSerialPort::dsrChanged(bool status)
This signal is emitted whenever dsr line has changed its state. You may
use this signal to check if device is connected.
\a status true when DSR signal is on, false otherwise.
*/
/*!
\fn QueryMode QextSerialPort::queryMode() const
Get query mode.
*/
/*!
Default constructor. Note that the name of the device used by a QextSerialPort is dependent on
your OS. Possible naming conventions and their associated OS are:
\code
OS Constant Used By Naming Convention
------------- ------------- ------------------------
Q_OS_WIN Windows COM1, COM2
Q_OS_IRIX SGI/IRIX /dev/ttyf1, /dev/ttyf2
Q_OS_HPUX HP-UX /dev/tty1p0, /dev/tty2p0
Q_OS_SOLARIS SunOS/Slaris /dev/ttya, /dev/ttyb
Q_OS_OSF Digital UNIX /dev/tty01, /dev/tty02
Q_OS_FREEBSD FreeBSD /dev/ttyd0, /dev/ttyd1
Q_OS_OPENBSD OpenBSD /dev/tty00, /dev/tty01
Q_OS_LINUX Linux /dev/ttyS0, /dev/ttyS1
<none> /dev/ttyS0, /dev/ttyS1
\endcode
This constructor assigns the device name to the name of the first port on the specified system.
See the other constructors if you need to open a different port. Default \a mode is EventDriven.
As a subclass of QObject, \a parent can be specified.
*/
QextSerialPort::QextSerialPort(QextSerialPort::QueryMode mode, QObject *parent)
: QIODevice(parent), d_ptr(new QextSerialPortPrivate(this))
{
#ifdef Q_OS_WIN
setPortName(QLatin1String("COM1"));
#elif defined(Q_OS_IRIX)
setPortName(QLatin1String("/dev/ttyf1"));
#elif defined(Q_OS_HPUX)
setPortName(QLatin1String("/dev/tty1p0"));
#elif defined(Q_OS_SOLARIS)
setPortName(QLatin1String("/dev/ttya"));
#elif defined(Q_OS_OSF) //formally DIGITAL UNIX
setPortName(QLatin1String("/dev/tty01"));
#elif defined(Q_OS_FREEBSD)
setPortName(QLatin1String("/dev/ttyd1"));
#elif defined(Q_OS_OPENBSD)
setPortName(QLatin1String("/dev/tty00"));
#else
setPortName(QLatin1String("/dev/ttyS0"));
#endif
setQueryMode(mode);
}
/*!
Constructs a serial port attached to the port specified by name.
\a name is the name of the device, which is windowsystem-specific,
e.g."COM1" or "/dev/ttyS0". \a mode
*/
QextSerialPort::QextSerialPort(const QString &name, QextSerialPort::QueryMode mode, QObject *parent)
: QIODevice(parent), d_ptr(new QextSerialPortPrivate(this))
{
setQueryMode(mode);
setPortName(name);
}
/*!
Constructs a port with default name and specified \a settings.
*/
QextSerialPort::QextSerialPort(const PortSettings &settings, QextSerialPort::QueryMode mode, QObject *parent)
: QIODevice(parent), d_ptr(new QextSerialPortPrivate(this))
{
Q_D(QextSerialPort);
setQueryMode(mode);
d->setPortSettings(settings);
}
/*!
Constructs a port with specified \a name , \a mode and \a settings.
*/
QextSerialPort::QextSerialPort(const QString &name, const PortSettings &settings, QextSerialPort::QueryMode mode, QObject *parent)
: QIODevice(parent), d_ptr(new QextSerialPortPrivate(this))
{
Q_D(QextSerialPort);
setPortName(name);
setQueryMode(mode);
d->setPortSettings(settings);
}
/*!
Opens a serial port and sets its OpenMode to \a mode.
Note that this function does not specify which device to open.
Returns true if successful; otherwise returns false.This function has no effect
if the port associated with the class is already open. The port is also
configured to the current settings, as stored in the settings structure.
*/
bool QextSerialPort::open(OpenMode mode)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (mode != QIODevice::NotOpen && !isOpen()) {
d->open_sys(mode);
}
return isOpen();
}
/*! \reimp
Closes a serial port. This function has no effect if the serial port associated with the class
is not currently open.
*/
void QextSerialPort::close()
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (isOpen()) {
// Be a good QIODevice and call QIODevice::close() before really close()
// so the aboutToClose() signal is emitted at the proper time
QIODevice::close(); // mark ourselves as closed
d->close_sys();
d->readBuffer.clear();
}
}
/*!
Flushes all pending I/O to the serial port. This function has no effect if the serial port
associated with the class is not currently open.
*/
void QextSerialPort::flush()
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (isOpen()) {
d->flush_sys();
}
}
/*! \reimp
Returns the number of bytes waiting in the port's receive queue. This function will return 0 if
the port is not currently open, or -1 on error.
*/
qint64 QextSerialPort::bytesAvailable() const
{
QWriteLocker locker(&d_func()->lock);
if (isOpen()) {
qint64 bytes = d_func()->bytesAvailable_sys();
if (bytes != -1) {
return bytes + d_func()->readBuffer.size()
+ QIODevice::bytesAvailable();
} else {
return -1;
}
}
return 0;
}
/*! \reimp
*/
bool QextSerialPort::canReadLine() const
{
QReadLocker locker(&d_func()->lock);
return QIODevice::canReadLine() || d_func()->readBuffer.canReadLine();
}
/*!
* Set desired serial communication handling style. You may choose from polling
* or event driven approach. This function does nothing when port is open; to
* apply changes port must be reopened.
*
* In event driven approach read() and write() functions are acting
* asynchronously. They return immediately and the operation is performed in
* the background, so they doesn't freeze the calling thread.
* To determine when operation is finished, QextSerialPort runs separate thread
* and monitors serial port events. Whenever the event occurs, adequate signal
* is emitted.
*
* When polling is set, read() and write() are acting synchronously. Signals are
* not working in this mode and some functions may not be available. The advantage
* of polling is that it generates less overhead due to lack of signals emissions
* and it doesn't start separate thread to monitor events.
*
* Generally event driven approach is more capable and friendly, although some
* applications may need as low overhead as possible and then polling comes.
*
* \a mode query mode.
*/
void QextSerialPort::setQueryMode(QueryMode mode)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (mode != d->queryMode) {
d->queryMode = mode;
}
}
/*!
Sets the \a name of the device associated with the object, e.g. "COM1", or "/dev/ttyS0".
*/
void QextSerialPort::setPortName(const QString &name)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
d->port = name;
}
/*!
Returns the name set by setPortName().
*/
QString QextSerialPort::portName() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->port;
}
QextSerialPort::QueryMode QextSerialPort::queryMode() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->queryMode;
}
/*!
Reads all available data from the device, and returns it as a QByteArray.
This function has no way of reporting errors; returning an empty QByteArray()
can mean either that no data was currently available for reading, or that an error occurred.
*/
QByteArray QextSerialPort::readAll()
{
int avail = this->bytesAvailable();
return (avail > 0) ? this->read(avail) : QByteArray();
}
/*!
Returns the baud rate of the serial port. For a list of possible return values see
the definition of the enum BaudRateType.
*/
BaudRateType QextSerialPort::baudRate() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->settings.BaudRate;
}
/*!
Returns the number of data bits used by the port. For a list of possible values returned by
this function, see the definition of the enum DataBitsType.
*/
DataBitsType QextSerialPort::dataBits() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->settings.DataBits;
}
/*!
Returns the type of parity used by the port. For a list of possible values returned by
this function, see the definition of the enum ParityType.
*/
ParityType QextSerialPort::parity() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->settings.Parity;
}
/*!
Returns the number of stop bits used by the port. For a list of possible return values, see
the definition of the enum StopBitsType.
*/
StopBitsType QextSerialPort::stopBits() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->settings.StopBits;
}
/*!
Returns the type of flow control used by the port. For a list of possible values returned
by this function, see the definition of the enum FlowType.
*/
FlowType QextSerialPort::flowControl() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->settings.FlowControl;
}
/*!
\reimp
Returns true if device is sequential, otherwise returns false. Serial port is sequential device
so this function always returns true. Check QIODevice::isSequential() documentation for more
information.
*/
bool QextSerialPort::isSequential() const
{
return true;
}
/*!
Return the error number, or 0 if no error occurred.
*/
ulong QextSerialPort::lastError() const
{
QReadLocker locker(&d_func()->lock);
return d_func()->lastErr;
}
/*!
Returns the line status as stored by the port function. This function will retrieve the states
of the following lines: DCD, CTS, DSR, and RI. On POSIX systems, the following additional lines
can be monitored: DTR, RTS, Secondary TXD, and Secondary RXD. The value returned is an unsigned
long with specific bits indicating which lines are high. The following constants should be used
to examine the states of individual lines:
\code
Mask Line
------ ----
LS_CTS CTS
LS_DSR DSR
LS_DCD DCD
LS_RI RI
LS_RTS RTS (POSIX only)
LS_DTR DTR (POSIX only)
LS_ST Secondary TXD (POSIX only)
LS_SR Secondary RXD (POSIX only)
\endcode
This function will return 0 if the port associated with the class is not currently open.
*/
unsigned long QextSerialPort::lineStatus()
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (isOpen()) {
return d->lineStatus_sys();
}
return 0;
}
/*!
Returns a human-readable description of the last device error that occurred.
*/
QString QextSerialPort::errorString()
{
Q_D(QextSerialPort);
QReadLocker locker(&d->lock);
switch (d->lastErr) {
case E_NO_ERROR:
return tr("No Error has occurred");
case E_INVALID_FD:
return tr("Invalid file descriptor (port was not opened correctly)");
case E_NO_MEMORY:
return tr("Unable to allocate memory tables (POSIX)");
case E_CAUGHT_NON_BLOCKED_SIGNAL:
return tr("Caught a non-blocked signal (POSIX)");
case E_PORT_TIMEOUT:
return tr("Operation timed out (POSIX)");
case E_INVALID_DEVICE:
return tr("The file opened by the port is not a valid device");
case E_BREAK_CONDITION:
return tr("The port detected a break condition");
case E_FRAMING_ERROR:
return tr("The port detected a framing error (usually caused by incorrect baud rate settings)");
case E_IO_ERROR:
return tr("There was an I/O error while communicating with the port");
case E_BUFFER_OVERRUN:
return tr("Character buffer overrun");
case E_RECEIVE_OVERFLOW:
return tr("Receive buffer overflow");
case E_RECEIVE_PARITY_ERROR:
return tr("The port detected a parity error in the received data");
case E_TRANSMIT_OVERFLOW:
return tr("Transmit buffer overflow");
case E_READ_FAILED:
return tr("General read operation failure");
case E_WRITE_FAILED:
return tr("General write operation failure");
case E_FILE_NOT_FOUND:
return tr("The %1 file doesn't exists").arg(this->portName());
case E_PERMISSION_DENIED:
return tr("Permission denied");
case E_AGAIN:
return tr("Device is already locked");
default:
return tr("Unknown error: %1").arg(d->lastErr);
}
}
/*!
Destructs the QextSerialPort object.
*/
QextSerialPort::~QextSerialPort()
{
if (isOpen()) {
close();
}
delete d_ptr;
}
/*!
Sets the flow control used by the port to \a flow. Possible values of flow are:
\code
FLOW_OFF No flow control
FLOW_HARDWARE Hardware (RTS/CTS) flow control
FLOW_XONXOFF Software (XON/XOFF) flow control
\endcode
*/
void QextSerialPort::setFlowControl(FlowType flow)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (d->settings.FlowControl != flow) {
d->setFlowControl(flow, true);
}
}
/*!
Sets the parity associated with the serial port to \a parity. The possible values of parity are:
\code
PAR_SPACE Space Parity
PAR_MARK Mark Parity
PAR_NONE No Parity
PAR_EVEN Even Parity
PAR_ODD Odd Parity
\endcode
*/
void QextSerialPort::setParity(ParityType parity)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (d->settings.Parity != parity) {
d->setParity(parity, true);
}
}
/*!
Sets the number of data bits used by the serial port to \a dataBits. Possible values of dataBits are:
\code
DATA_5 5 data bits
DATA_6 6 data bits
DATA_7 7 data bits
DATA_8 8 data bits
\endcode
\bold note:
This function is subject to the following restrictions:
\list
\o 5 data bits cannot be used with 2 stop bits.
\o 1.5 stop bits can only be used with 5 data bits.
\o 8 data bits cannot be used with space parity on POSIX systems.
\endlist
*/
void QextSerialPort::setDataBits(DataBitsType dataBits)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (d->settings.DataBits != dataBits) {
d->setDataBits(dataBits, true);
}
}
/*!
Sets the number of stop bits used by the serial port to \a stopBits. Possible values of stopBits are:
\code
STOP_1 1 stop bit
STOP_1_5 1.5 stop bits
STOP_2 2 stop bits
\endcode
\bold note:
This function is subject to the following restrictions:
\list
\o 2 stop bits cannot be used with 5 data bits.
\o 1.5 stop bits cannot be used with 6 or more data bits.
\o POSIX does not support 1.5 stop bits.
\endlist
*/
void QextSerialPort::setStopBits(StopBitsType stopBits)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (d->settings.StopBits != stopBits) {
d->setStopBits(stopBits, true);
}
}
/*!
Sets the baud rate of the serial port to \a baudRate. Note that not all rates are applicable on
all platforms. The following table shows translations of the various baud rate
constants on Windows(including NT/2000) and POSIX platforms. Speeds marked with an *
are speeds that are usable on both Windows and POSIX.
\code
RATE Windows Speed POSIX Speed
----------- ------------- -----------
BAUD50 X 50
BAUD75 X 75
*BAUD110 110 110
BAUD134 X 134.5
BAUD150 X 150
BAUD200 X 200
*BAUD300 300 300
*BAUD600 600 600
*BAUD1200 1200 1200
BAUD1800 X 1800
*BAUD2400 2400 2400
*BAUD4800 4800 4800
*BAUD9600 9600 9600
BAUD14400 14400 X
*BAUD19200 19200 19200
*BAUD38400 38400 38400
BAUD56000 56000 X
*BAUD57600 57600 57600
BAUD76800 X 76800
*BAUD115200 115200 115200
BAUD128000 128000 X
BAUD230400 X 230400
BAUD256000 256000 X
BAUD460800 X 460800
BAUD500000 X 500000
BAUD576000 X 576000
BAUD921600 X 921600
BAUD1000000 X 1000000
BAUD1152000 X 1152000
BAUD1500000 X 1500000
BAUD2000000 X 2000000
BAUD2500000 X 2500000
BAUD3000000 X 3000000
BAUD3500000 X 3500000
BAUD4000000 X 4000000
\endcode
*/
void QextSerialPort::setBaudRate(BaudRateType baudRate)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (d->settings.BaudRate != baudRate) {
d->setBaudRate(baudRate, true);
}
}
/*!
For Unix:
Sets the read and write timeouts for the port to \a millisec milliseconds.
Note that this is a per-character timeout, i.e. the port will wait this long for each
individual character, not for the whole read operation. This timeout also applies to the
bytesWaiting() function.
\bold note:
POSIX does not support millisecond-level control for I/O timeout values. Any
timeout set using this function will be set to the next lowest tenth of a second for
the purposes of detecting read or write timeouts. For example a timeout of 550 milliseconds
will be seen by the class as a timeout of 500 milliseconds for the purposes of reading and
writing the port. However millisecond-level control is allowed by the select() system call,
so for example a 550-millisecond timeout will be seen as 550 milliseconds on POSIX systems for
the purpose of detecting available bytes in the read buffer.
For Windows:
Sets the read and write timeouts for the port to \a millisec milliseconds.
Setting 0 indicates that timeouts are not used for read nor write operations;
however read() and write() functions will still block. Set -1 to provide
non-blocking behaviour (read() and write() will return immediately).
\bold note: this function does nothing in event driven mode.
*/
void QextSerialPort::setTimeout(long millisec)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (d->settings.Timeout_Millisec != millisec) {
d->setTimeout(millisec, true);
}
}
/*!
Sets DTR line to the requested state (\a set default to high). This function will have no effect if
the port associated with the class is not currently open.
*/
void QextSerialPort::setDtr(bool set)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (isOpen()) {
d->setDtr_sys(set);
}
}
/*!
Sets RTS line to the requested state \a set (high by default).
This function will have no effect if
the port associated with the class is not currently open.
*/
void QextSerialPort::setRts(bool set)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
if (isOpen()) {
d->setRts_sys(set);
}
}
/*! \reimp
Reads a block of data from the serial port. This function will read at most maxlen bytes from
the serial port and place them in the buffer pointed to by data. Return value is the number of
bytes actually read, or -1 on error.
\warning before calling this function ensure that serial port associated with this class
is currently open (use isOpen() function to check if port is open).
*/
qint64 QextSerialPort::readData(char *data, qint64 maxSize)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
qint64 bytesFromBuffer = 0;
if (!d->readBuffer.isEmpty()) {
bytesFromBuffer = d->readBuffer.read(data, maxSize);
if (bytesFromBuffer == maxSize) {
return bytesFromBuffer;
}
}
qint64 bytesFromDevice = d->readData_sys(data + bytesFromBuffer, maxSize - bytesFromBuffer);
if (bytesFromDevice < 0) {
return -1;
}
return bytesFromBuffer + bytesFromDevice;
}
/*! \reimp
Writes a block of data to the serial port. This function will write len bytes
from the buffer pointed to by data to the serial port. Return value is the number
of bytes actually written, or -1 on error.
\warning before calling this function ensure that serial port associated with this class
is currently open (use isOpen() function to check if port is open).
*/
qint64 QextSerialPort::writeData(const char *data, qint64 maxSize)
{
Q_D(QextSerialPort);
QWriteLocker locker(&d->lock);
return d->writeData_sys(data, maxSize);
}
#include "moc_qextserialport.cpp"