//SerialPortTool.h
#ifndef SERIALPORTTOOL_H
#define SERIALPORTTOOL_H
#include <QObject>
#include <QDebug>
#include <QMetaEnum>
#include <QSerialPort>
#include <QSerialPortInfo>
class SerialPortTool : public QObject
{
Q_OBJECT
private:
QSerialPort* m_serialPort;
QString m_lastError;
void setLastError(const QString& e = "");
const QStringList m_baudEnum = { "1200","2400","4800","9600","19200","38400","57600","115200" };
const QStringList m_verityEnum = { "NoParity","EvenParity","OddParity","SpaceParity","MarkParity" };
const QStringList m_dataBitEnum = { "5","6","7","8" };
const QStringList m_stopBitEnum = { "1","1.5","2" };
protected:
bool setBaud(const int &baud);
bool setDataBit(const int& dataBit);
bool setVerify(const int& verify);
bool setStopBit(const int& stopBit);
bool setFlowControl(const int& flowControl);
public:
typedef struct Configuration {
QString portName;
uint baud;
uint verify;
uint dataBit;
uint stopBit;
uint flow;
}configuration_t;
explicit SerialPortTool(QObject* parent = nullptr);
~SerialPortTool();
QList<QSerialPortInfo> getSerialPortList();
bool openSerialPort(configuration_t& config);
void closeSerialPort();
const QStringList& getBaudEnum();
const QStringList& getVerityEnum();
const QStringList& getDataBitEnum();
const QStringList& getStopBitEnum();
QSerialPort* getSerialPort();
const QString& getLastError();
qint64 writeData(const QString& data);
signals:
void readyRead(const QString& portName,QByteArray& data);
private slots:
void readData();
};
#endif // SERIALPORTTOOL_H
//SerialPortTool.cpp
#include "SerialPortTool.h"
SerialPortTool::SerialPortTool(QObject* parent) : QObject(parent)
{
m_serialPort = new QSerialPort;
}
SerialPortTool::~SerialPortTool()
{
if (m_serialPort->isOpen())
m_serialPort->close();
delete m_serialPort;
}
QList<QSerialPortInfo> SerialPortTool::getSerialPortList()
{
QList<QSerialPortInfo> availablePorts = QSerialPortInfo::availablePorts();
return availablePorts;
}
bool SerialPortTool::openSerialPort(configuration_t& config)
{
bool result = false;
do {
if (config.portName.isEmpty())
{
m_lastError = "Invalid Serial Port";
break;
}
bool convert = false;
config.portName.toInt(&convert);
if (convert)
{
config.portName.insert(0, "COM");
}
QSerialPortInfo* info = new QSerialPortInfo(config.portName);
m_serialPort->setPort(*info);
if (!m_serialPort->open(QIODevice::ReadWrite))
{
setLastError();
break;
}
if (!setBaud(config.baud))
{
setLastError("set baud error");
break;
}
if (!setDataBit(config.dataBit))
{
setLastError("set dataBit error");
break;
}
if (!setVerify(config.verify))
{
setLastError("set verify error");
break;
}
if (!setStopBit(config.stopBit))
{
setLastError("set stopBit error");
break;
}
if (!setFlowControl(config.flow))
{
setLastError("set FlowControl error");
break;
}
connect(m_serialPort, &QSerialPort::readyRead, this, &SerialPortTool::readData);
result = true;
} while (false);
return result;
}
void SerialPortTool::closeSerialPort()
{
if (m_serialPort->isOpen())
m_serialPort->close();
}
const QStringList& SerialPortTool::getBaudEnum()
{
return m_baudEnum;
}
const QStringList& SerialPortTool::getVerityEnum()
{
return m_verityEnum;
}
const QStringList& SerialPortTool::getDataBitEnum()
{
return m_dataBitEnum;
}
bool SerialPortTool::setBaud(const int& baud)
{
bool result = false;
switch (baud)
{
case 1200:
result = m_serialPort->setBaudRate(QSerialPort::Baud1200);
break;
case 2400:
result = m_serialPort->setBaudRate(QSerialPort::Baud2400);
break;
case 4800:
result = m_serialPort->setBaudRate(QSerialPort::Baud4800);
break;
case 9600:
result = m_serialPort->setBaudRate(QSerialPort::Baud9600);
break;
case 19200:
result = m_serialPort->setBaudRate(QSerialPort::Baud19200);
break;
case 38400:
result = m_serialPort->setBaudRate(QSerialPort::Baud38400);
break;
case 57600:
result = m_serialPort->setBaudRate(QSerialPort::Baud57600);
break;
case 115200:
result = m_serialPort->setBaudRate(QSerialPort::Baud115200);
break;
default:
result = false;
break;
}
return result;
}
bool SerialPortTool::setDataBit(const int& dataBit)
{
bool result = false;
switch (dataBit)
{
case 5:
result = m_serialPort->setDataBits(QSerialPort::Data5);
break;
case 6:
result = m_serialPort->setDataBits(QSerialPort::Data6);
break;
case 7:
result = m_serialPort->setDataBits(QSerialPort::Data7);
break;
case 8:
result = m_serialPort->setDataBits(QSerialPort::Data8);
break;
default:
result = false;
break;
}
return result;
}
const QStringList& SerialPortTool::getStopBitEnum()
{
return m_stopBitEnum;
}
bool SerialPortTool::setVerify(const int& verify)
{
bool result = false;
switch (verify)
{
case 0:
result = m_serialPort->setParity(QSerialPort::NoParity);
break;
case 2:
result = m_serialPort->setParity(QSerialPort::EvenParity);
break;
case 3:
result = m_serialPort->setParity(QSerialPort::OddParity);
break;
case 4:
result = m_serialPort->setParity(QSerialPort::SpaceParity);
break;
case 5:
result = m_serialPort->setParity(QSerialPort::MarkParity);
break;
default:
result = false;
break;
}
return result;
}
bool SerialPortTool::setStopBit(const int& stopBit)
{
bool result = false;
switch (stopBit)
{
case 1:
result = m_serialPort->setStopBits(QSerialPort::OneStop);
break;
case 2:
result = m_serialPort->setStopBits(QSerialPort::TwoStop);
break;
case 3:
result = m_serialPort->setStopBits(QSerialPort::OneAndHalfStop);
break;
default:
result = false;
break;
}
return result;
}
bool SerialPortTool::setFlowControl(const int& flowControl)
{
bool result = false;
switch (flowControl)
{
case 0:
result = m_serialPort->setFlowControl(QSerialPort::NoFlowControl);
break;
case 1:
result = m_serialPort->setFlowControl(QSerialPort::HardwareControl);
break;
case 2:
result = m_serialPort->setFlowControl(QSerialPort::SoftwareControl);
break;
default:
result = false;
break;
}
return result;
}
QSerialPort* SerialPortTool::getSerialPort()
{
return m_serialPort;
}
void SerialPortTool::setLastError(const QString& e)
{
if (e.isEmpty())
{
m_lastError = QMetaEnum::fromType<QSerialPort::SerialPortError>()
.valueToKey(m_serialPort->error());
}
else
{
m_lastError = e;
}
}
const QString& SerialPortTool::getLastError()
{
return m_lastError;
}
qint64 SerialPortTool::writeData(const QString& data)
{
QByteArray byte = QByteArray::fromHex(data.toLatin1());
qint64 result = m_serialPort->write(byte);
return result;
}
void SerialPortTool::readData()
{
emit readyRead(m_serialPort->portName(),m_serialPort->readAll());
}