Subversion Repositories Code-Repo

#include "SerialHelper.h"

SerialHelper::SerialHelper(QObject *parent) : QObject(parent)
{
    connected = false;
    speeds << "9600" << "19200" << "38400" << "57600" << "115200" << "230400" << "250000";
    dataBits << "8 Bits" << "7 Bits" << "6 Bits" << "5 Bits";
    stopBits << "1 Bit" << "1.5 Bits" << "2 Bits";
    parity << "None" << "Even" << "Odd" << "Space" << "Mark";
    flowControl << "None" << "Hardware" << "Software";

    serialPort = NULL;
}

SerialHelper::~SerialHelper()
{
    if (serialPort != NULL && serialPort->isOpen())
        serialPort->close();
    delete serialPort;
}

void SerialHelper::QueryParameters()
{
    QList<QSerialPortInfo> portsList = QSerialPortInfo::availablePorts();
    QStringList ports;
    for (int i = 0; i < portsList.size(); i++) {
        ports.append(portsList[i].portName());
    }
    emit UpdateParameters(ports, speeds, dataBits, stopBits, parity, flowControl);
}

void SerialHelper::Connect(QString port, QString speed, QString dataBits,
                            QString stopBits, QString parity, QString flowControl)
{
    if (!connected) {
        emit UpdateStatus("Connecting to " + port);
        serialPort = new QSerialPort();
        connect(serialPort, SIGNAL(readyRead()), this, SLOT(ProcessIncomingData()));
        connect(serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(ProcessError(QSerialPort::SerialPortError)));
        serialPort->setPortName(port);
        if (serialPort->open(QIODevice::ReadWrite)) {
            connected = true;
            bool ok = false;

            int baud = speed.toInt(&ok);
            if (ok) serialPort->setBaudRate(baud);

            if (dataBits == "5 Bits")
                serialPort->setDataBits(QSerialPort::Data5);
            else if (dataBits == "6 Bits")
                serialPort->setDataBits(QSerialPort::Data6);
            else if (dataBits == "7 Bits")
                serialPort->setDataBits(QSerialPort::Data7);
            else
                serialPort->setDataBits(QSerialPort::Data8);

            if (stopBits == "1.5 Bits")
                serialPort->setStopBits(QSerialPort::OneAndHalfStop);
            else if (stopBits == "2 Bits")
                serialPort->setStopBits(QSerialPort::TwoStop);
            else
                serialPort->setStopBits(QSerialPort::OneStop);

            if (parity == "Even")
                serialPort->setParity(QSerialPort::EvenParity);
            else if (parity == "Odd")
                serialPort->setParity(QSerialPort::OddParity);
            else if (parity == "Space")
                serialPort->setParity(QSerialPort::SpaceParity);
            else if (parity == "Mark")
                serialPort->setParity(QSerialPort::MarkParity);
            else
                serialPort->setParity(QSerialPort::NoParity);

            if (flowControl == "Hardware")
                serialPort->setFlowControl(QSerialPort::HardwareControl);
            else if (flowControl == "Software")
                serialPort->setFlowControl(QSerialPort::SoftwareControl);
            else
                serialPort->setFlowControl(QSerialPort::NoFlowControl);

            // See http://umforum.ultimaker.com/index.php?/topic/5886-um2-controller-resetreboot-when-opening-usb-port-on-linux/
            serialPort->setDataTerminalReady(1);

            if (ok) {
                QString status = "Connected (%1 @ %2 D: %3 S: %4 P: %5 FC: %6)";
                emit UpdateStatus(status.arg(port).arg(speed).arg(dataBits).arg(stopBits).arg(parity).arg(flowControl));
                emit Connected();
            } else
                Disconnect();
        }
    }
}

void SerialHelper::Disconnect(bool errored)
{
    serialPort->disconnect();
    serialPort->close();
    delete serialPort;
    connected = false;
    if (!errored)
        emit UpdateStatus("Disconnected");
    emit Disconnected();
}

void SerialHelper::TransmitString(QString string)
{
    serialPort->write(string.toStdString().c_str());
    serialPort->write(SERIAL_NEWLINE_CHAR);
}

void SerialHelper::TransmitByteArray(QByteArray data)
{
    serialPort->write(data);
}

void SerialHelper::ProcessIncomingData()
{
    char tmpBuffer[SERIAL_BUFFER_SIZE];
    int len = serialPort->read(tmpBuffer, sizeof(tmpBuffer));
    while (len > 0) {
        QByteArray data(tmpBuffer, len);
        emit ReceivedByte(data);
        // Check if there is more data to be read from the serial port
        len = serialPort->read(tmpBuffer, sizeof(tmpBuffer));
    }
}

void SerialHelper::ProcessError(QSerialPort::SerialPortError error)
{
    if (error == QSerialPort::NoError) return;

    switch(error) {
        case QSerialPort::DeviceNotFoundError:
            emit UpdateStatus("(Error) Device not found");
            return;
        case QSerialPort::PermissionError:
            emit UpdateStatus("(Error) Device already opened or lacking permission");
            return;
        case QSerialPort::OpenError:
            emit UpdateStatus("(Error) Device already opened");
            return;
        case QSerialPort::NotOpenError:
            emit UpdateStatus("(Error) Device not opened");
            return;
        case QSerialPort::ParityError:
            emit UpdateStatus("(Error) Parity error detected");
            break;
        case QSerialPort::FramingError:
            emit UpdateStatus("(Error) Framing error detected");
            break;
        case QSerialPort::BreakConditionError:
            emit UpdateStatus("(Error) Break condition detected");
            break;
        case QSerialPort::WriteError:
            emit UpdateStatus("(Error) Unable to write to device");
            break;
        case QSerialPort::ReadError:
            emit UpdateStatus("(Error) Unable to read from device");
            break;
        case QSerialPort::ResourceError:
            emit UpdateStatus("(Error) Device missing or disconnected");
            break;
        case QSerialPort::UnsupportedOperationError:
            emit UpdateStatus("(Error) Operation not supported or prohibited");
            break;
        case QSerialPort::TimeoutError:
            emit UpdateStatus("(Error) Connection timeout");
            break;
        case QSerialPort::UnknownError:
            emit UpdateStatus("(Error) Unknown error");
            break;
        default:
            break;
    }

    serialPort->clearError();
    Disconnect(true);
}