qserialport.cpp

Go to the documentation of this file.

// Copyright (C) 2011-2012 Denis Shienkov <denis.shienkov@gmail.com>
// Copyright (C) 2011 Sergey Belyashov <Sergey.Belyashov@gmail.com>
// Copyright (C) 2012 Laszlo Papp <lpapp@kde.org>
// Copyright (C) 2012 Andre Hartmann <aha_1980@gmx.de>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qserialport.h"
 
#include <QtCore/qdebug.h>
 
#include "qserialport_p.h"
#include "qserialportinfo.h"
#include "qserialportinfo_p.h"
 
QT_BEGIN_NAMESPACE
 
QSerialPortErrorInfo::QSerialPortErrorInfo(QSerialPort::SerialPortError newErrorCode, const QString& newErrorString)
    : errorCode(newErrorCode), errorString(newErrorString)
{
    if (errorString.isNull()) {
        switch (errorCode) {
            case QSerialPort::NoError:
                errorString = QSerialPort::tr("No error");
                break;
            case QSerialPort::OpenError:
                errorString = QSerialPort::tr("Device is already open");
                break;
            case QSerialPort::NotOpenError:
                errorString = QSerialPort::tr("Device is not open");
                break;
            case QSerialPort::TimeoutError:
                errorString = QSerialPort::tr("Operation timed out");
                break;
            case QSerialPort::ReadError:
                errorString = QSerialPort::tr("Error reading from device");
                break;
            case QSerialPort::WriteError:
                errorString = QSerialPort::tr("Error writing to device");
                break;
            case QSerialPort::ResourceError:
                errorString = QSerialPort::tr("Device disappeared from the system");
                break;
            default:
                // an empty string will be interpreted as "Unknown error"
                // from the QIODevice::errorString()
                break;
        }
    }
}
 
QSerialPortPrivate::QSerialPortPrivate()
{
    writeBufferChunkSize = QSERIALPORT_BUFFERSIZE;
    readBufferChunkSize = QSERIALPORT_BUFFERSIZE;
}
 
void QSerialPortPrivate::setError(const QSerialPortErrorInfo& errorInfo)
{
    Q_Q(QSerialPort);
 
    q->setErrorString(errorInfo.errorString);
    error.setValue(errorInfo.errorCode);
    error.notify();
    emit q->errorOccurred(error);
}
 
QSerialPort::QSerialPort(QObject* parent) : QIODevice(*new QSerialPortPrivate, parent)
{
}
 
QSerialPort::QSerialPort(const QString& name, QObject* parent) : QIODevice(*new QSerialPortPrivate, parent)
{
    setPortName(name);
}
 
QSerialPort::QSerialPort(const QSerialPortInfo& serialPortInfo, QObject* parent)
    : QIODevice(*new QSerialPortPrivate, parent)
{
    setPort(serialPortInfo);
}
 
QSerialPort::~QSerialPort()
{
    
    if (isOpen())
        close();
}
 
void QSerialPort::setPortName(const QString& name)
{
    Q_D(QSerialPort);
    d->systemLocation = QSerialPortInfoPrivate::portNameToSystemLocation(name);
}
 
void QSerialPort::setPort(const QSerialPortInfo& serialPortInfo)
{
    Q_D(QSerialPort);
    d->systemLocation = serialPortInfo.systemLocation();
}
 
QString QSerialPort::portName() const
{
    Q_D(const QSerialPort);
    return QSerialPortInfoPrivate::portNameFromSystemLocation(d->systemLocation);
}
 
bool QSerialPort::open(OpenMode mode)
{
    Q_D(QSerialPort);
 
    if (isOpen()) {
        d->setError(QSerialPortErrorInfo(QSerialPort::OpenError));
        return false;
    }
 
    // Define while not supported modes.
    static const OpenMode unsupportedModes = Append | Truncate | Text | Unbuffered;
    if ((mode & unsupportedModes) || mode == NotOpen) {
        d->setError(QSerialPortErrorInfo(QSerialPort::UnsupportedOperationError, tr("Unsupported open mode")));
        return false;
    }
 
    clearError();
    if (!d->open(mode))
        return false;
 
    QIODevice::open(mode);
    return true;
}
 
void QSerialPort::close()
{
    Q_D(QSerialPort);
    if (!isOpen()) {
        d->setError(QSerialPortErrorInfo(QSerialPort::NotOpenError));
        return;
    }
 
    d->close();
    d->isBreakEnabled.setValue(false);
    QIODevice::close();
}
 
bool QSerialPort::setBaudRate(qint32 baudRate, Directions directions)
{
    Q_D(QSerialPort);
 
    if (!isOpen() || d->setBaudRate(baudRate, directions)) {
        if (directions & QSerialPort::Input) {
            if (d->inputBaudRate != baudRate)
                d->inputBaudRate = baudRate;
            else
                directions &= ~QSerialPort::Input;
        }
 
        if (directions & QSerialPort::Output) {
            if (d->outputBaudRate != baudRate)
                d->outputBaudRate = baudRate;
            else
                directions &= ~QSerialPort::Output;
        }
 
        if (directions)
            emit baudRateChanged(baudRate, directions);
 
        return true;
    }
 
    return false;
}
 
qint32 QSerialPort::baudRate(Directions directions) const
{
    Q_D(const QSerialPort);
    if (directions == QSerialPort::AllDirections)
        return d->inputBaudRate == d->outputBaudRate ? d->inputBaudRate : -1;
    return directions & QSerialPort::Input ? d->inputBaudRate : d->outputBaudRate;
}
 
bool QSerialPort::setDataBits(DataBits dataBits)
{
    Q_D(QSerialPort);
    d->dataBits.removeBindingUnlessInWrapper();
    const auto currentDataBits = d->dataBits.valueBypassingBindings();
    if (!isOpen() || d->setDataBits(dataBits)) {
        d->dataBits.setValueBypassingBindings(dataBits);
        if (currentDataBits != dataBits) {
            d->dataBits.notify();
            emit dataBitsChanged(dataBits);
        }
        return true;
    }
    return false;
}
 
QSerialPort::DataBits QSerialPort::dataBits() const
{
    Q_D(const QSerialPort);
    return d->dataBits;
}
 
QBindable<QSerialPort::DataBits> QSerialPort::bindableDataBits()
{
    return &d_func()->dataBits;
}
 
bool QSerialPort::setParity(Parity parity)
{
    Q_D(QSerialPort);
    d->parity.removeBindingUnlessInWrapper();
    const auto currentParity = d->parity.valueBypassingBindings();
    if (!isOpen() || d->setParity(parity)) {
        d->parity.setValueBypassingBindings(parity);
        if (currentParity != parity) {
            d->parity.notify();
            emit parityChanged(parity);
        }
        return true;
    }
    return false;
}
 
QSerialPort::Parity QSerialPort::parity() const
{
    Q_D(const QSerialPort);
    return d->parity;
}
 
QBindable<QSerialPort::Parity> QSerialPort::bindableParity()
{
    return &d_func()->parity;
}
 
bool QSerialPort::setStopBits(StopBits stopBits)
{
    Q_D(QSerialPort);
    d->stopBits.removeBindingUnlessInWrapper();
    const auto currentStopBits = d->stopBits.valueBypassingBindings();
    if (!isOpen() || d->setStopBits(stopBits)) {
        d->stopBits.setValueBypassingBindings(stopBits);
        if (currentStopBits != stopBits) {
            d->stopBits.notify();
            emit stopBitsChanged(stopBits);
        }
        return true;
    }
    return false;
}
 
QSerialPort::StopBits QSerialPort::stopBits() const
{
    Q_D(const QSerialPort);
    return d->stopBits;
}
 
QBindable<QSerialPort::StopBits> QSerialPort::bindableStopBits()
{
    return &d_func()->stopBits;
}
 
bool QSerialPort::setFlowControl(FlowControl flowControl)
{
    Q_D(QSerialPort);
    d->flowControl.removeBindingUnlessInWrapper();
    const auto currentFlowControl = d->flowControl.valueBypassingBindings();
    if (!isOpen() || d->setFlowControl(flowControl)) {
        d->flowControl.setValueBypassingBindings(flowControl);
        if (currentFlowControl != flowControl) {
            d->flowControl.notify();
            emit flowControlChanged(flowControl);
        }
        return true;
    }
    return false;
}
 
QSerialPort::FlowControl QSerialPort::flowControl() const
{
    Q_D(const QSerialPort);
    return d->flowControl;
}
 
QBindable<QSerialPort::FlowControl> QSerialPort::bindableFlowControl()
{
    return &d_func()->flowControl;
}
 
bool QSerialPort::setDataTerminalReady(bool set)
{
    Q_D(QSerialPort);
 
    if (!isOpen()) {
        d->setError(QSerialPortErrorInfo(QSerialPort::NotOpenError));
        qWarning("%s: device not open", Q_FUNC_INFO);
        return false;
    }
 
    const bool dataTerminalReady = isDataTerminalReady();
    const bool retval = d->setDataTerminalReady(set);
    if (retval && (dataTerminalReady != set))
        emit dataTerminalReadyChanged(set);
 
    return retval;
}
 
bool QSerialPort::isDataTerminalReady()
{
    Q_D(QSerialPort);
    return d->pinoutSignals() & QSerialPort::DataTerminalReadySignal;
}
 
bool QSerialPort::setRequestToSend(bool set)
{
    Q_D(QSerialPort);
 
    if (!isOpen()) {
        d->setError(QSerialPortErrorInfo(QSerialPort::NotOpenError));
        qWarning("%s: device not open", Q_FUNC_INFO);
        return false;
    }
 
    if (d->flowControl == QSerialPort::HardwareControl) {
        d->setError(QSerialPortErrorInfo(QSerialPort::UnsupportedOperationError));
        return false;
    }
 
    const bool requestToSend = isRequestToSend();
    const bool retval = d->setRequestToSend(set);
    if (retval && (requestToSend != set))
        emit requestToSendChanged(set);
 
    return retval;
}
 
bool QSerialPort::isRequestToSend()
{
    Q_D(QSerialPort);
    return d->pinoutSignals() & QSerialPort::RequestToSendSignal;
}
 
QSerialPort::PinoutSignals QSerialPort::pinoutSignals()
{
    Q_D(QSerialPort);
 
    if (!isOpen()) {
        d->setError(QSerialPortErrorInfo(QSerialPort::NotOpenError));
        qWarning("%s: device not open", Q_FUNC_INFO);
        return QSerialPort::NoSignal;
    }
 
    return d->pinoutSignals();
}
 
bool QSerialPort::flush()
{
    Q_D(QSerialPort);
 
    if (!isOpen()) {
        d->setError(QSerialPortErrorInfo(QSerialPort::NotOpenError));
        qWarning("%s: device not open", Q_FUNC_INFO);
        return false;
    }
 
    return d->flush();
}
 
bool QSerialPort::clear(Directions directions)
{
    Q_D(QSerialPort);
 
    if (!isOpen()) {
        d->setError(QSerialPortErrorInfo(QSerialPort::NotOpenError));
        qWarning("%s: device not open", Q_FUNC_INFO);
        return false;
    }
 
    if (directions & Input) {
        QMutexLocker locker(&d->_readMutex);
        d->buffer.clear();
        d->_pendingData.clear();
        d->_bufferBytesEstimate.store(0, std::memory_order_relaxed);
    }
    if (directions & Output)
        d->writeBuffer.clear();
    return d->clear(directions);
}
 
QSerialPort::SerialPortError QSerialPort::error() const
{
    Q_D(const QSerialPort);
    return d->error;
}
 
void QSerialPort::clearError()
{
    Q_D(QSerialPort);
    d->setError(QSerialPortErrorInfo(QSerialPort::NoError));
}
 
QBindable<QSerialPort::SerialPortError> QSerialPort::bindableError() const
{
    return &d_func()->error;
}
 
qint64 QSerialPort::readBufferSize() const
{
    Q_D(const QSerialPort);
    return d->readBufferMaxSize;
}
 
void QSerialPort::setReadBufferSize(qint64 size)
{
    Q_D(QSerialPort);
    d->readBufferMaxSize = size;
    if (isReadable())
        d->startAsyncRead();
}
 
bool QSerialPort::isSequential() const
{
    return true;
}
 
qint64 QSerialPort::bytesAvailable() const
{
    return QIODevice::bytesAvailable();
}
 
qint64 QSerialPort::bytesToWrite() const
{
    qint64 pendingBytes = QIODevice::bytesToWrite();
    return pendingBytes;
}
 
bool QSerialPort::canReadLine() const
{
    return QIODevice::canReadLine();
}
 
bool QSerialPort::waitForReadyRead(int msecs)
{
    Q_D(QSerialPort);
    return d->waitForReadyRead(msecs);
}
 
bool QSerialPort::waitForBytesWritten(int msecs)
{
    Q_D(QSerialPort);
    return d->waitForBytesWritten(msecs);
}
 
bool QSerialPort::setBreakEnabled(bool set)
{
    Q_D(QSerialPort);
    d->isBreakEnabled.removeBindingUnlessInWrapper();
    const auto currentSet = d->isBreakEnabled.valueBypassingBindings();
    if (isOpen()) {
        if (d->setBreakEnabled(set)) {
            d->isBreakEnabled.setValueBypassingBindings(set);
            if (currentSet != set) {
                d->isBreakEnabled.notify();
                emit breakEnabledChanged(set);
            }
            return true;
        }
    } else {
        d->setError(QSerialPortErrorInfo(QSerialPort::NotOpenError));
        qWarning("%s: device not open", Q_FUNC_INFO);
    }
    return false;
}
 
bool QSerialPort::isBreakEnabled() const
{
    Q_D(const QSerialPort);
    return d->isBreakEnabled;
}
 
QBindable<bool> QSerialPort::bindableIsBreakEnabled()
{
    return &d_func()->isBreakEnabled;
}
 
qint64 QSerialPort::readData(char* data, qint64 maxSize)
{
    Q_UNUSED(data);
    Q_UNUSED(maxSize);
 
    // QIODevice drains from d->buffer before calling here; refresh estimate so
    // Android read-backpressure tracks current buffered bytes.
    d_func()->_bufferBytesEstimate.store(d_func()->buffer.size(), std::memory_order_relaxed);
 
    // In any case we need to start the notifications if they were
    // disabled by the read handler. If enabled, next call does nothing.
    d_func()->startAsyncRead();
 
    // return 0 indicating there may be more data in the future
    return qint64(0);
}
 
qint64 QSerialPort::readLineData(char* data, qint64 maxSize)
{
    return QIODevice::readLineData(data, maxSize);
}
 
qint64 QSerialPort::writeData(const char* data, qint64 maxSize)
{
    Q_D(QSerialPort);
    return d->writeData(data, maxSize);
}
 
QT_END_NAMESPACE
 
#include "moc_qserialport.cpp"