Qt串口编程

//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());
}