Qt串口

#ifndef MYREVICETHREAD_H
#define MYREVICETHREAD_H

#include <QThread>
#include <stdio.h>
#include <QtGlobal>
#include <QList>

class MyReviceThread : public QThread
{
    Q_OBJECT

public:
    MyReviceThread();
   ~MyReviceThread();
//    QByteArray mTxData;
    QList<QByteArray> mSendDataArray;
    QList<QByteArray> mRequestDataArray;
    QList<QByteArray> mSendErrorArray;
    void setMessage(const QString message);
    void setPortnum(const QString num);
    void setBaudrate(const int baudrate);
    void stop();
    void startCom();
    void changeTxState(bool stat);
    void changeRxState(bool stat);
    void changeComState(bool stat);

signals:
    void request(const QString &s);
    void comRecive();
    void SendTojieshiData(QByteArray jieshitemp);
    void serialFinished(QByteArray temp);
protected:
    void run();
    bool CheckSum(unsigned char *data,int index);
private:
    uint sendErrNum;
    QString mMessageStr;
    QString mPortNum;
    int mBaudrate;
    QByteArray mRequestData;
    volatile bool mComOpened;
    volatile bool mStopped;
    volatile bool mTxEvent;
    volatile bool mRxEvent;

};

#endif // MYREVICETHREAD_H
           

方法实现



```cpp
#include "myrevicethread.h"
#include <QtDebug>
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include <QException>


MyReviceThread::MyReviceThread()
{
    sendErrNum = 0;
    mStopped=false;
}

MyReviceThread::~MyReviceThread(){
}
bool MyReviceThread::CheckSum(unsigned char *data,int index)
{
    bool res = false;
    if(data && index > 1)
    {

        int sum = 0;
        for(int i = 0;i<index-1;i++)
        {
            sum += data[i];
        }
        if((unsigned char)(~sum+1) == data[index-1])
        {
            res = true;
        }
    }
    return res;
}

void MyReviceThread::run()
{
    QSerialPort *my_serialport= new QSerialPort;

    while(!mStopped)
    {
        if(mStopped&&mComOpened)
        {
            my_serialport->close();
            mComOpened=false;

        }
        if(!mComOpened)
        {
            my_serialport->setPortName(mPortNum);
            mComOpened = my_serialport->open(QIODevice::ReadWrite);
            my_serialport->setBaudRate(mBaudrate);
            my_serialport->setDataBits(QSerialPort::Data8);
            my_serialport->setParity(QSerialPort::NoParity);
            my_serialport->setStopBits(QSerialPort::OneStop);
            my_serialport->setFlowControl(QSerialPort::NoFlowControl);
        }
        if(this->mComOpened&&this->mTxEvent&&mSendDataArray.length()>0)
        {
            //this->mTxEvent=false;
            my_serialport->clear(QSerialPort::AllDirections);
            while(mSendDataArray.size()>0){
                //qDebug() << "SendDataArray.size:"<<mSendDataArray.size();
                try{
                    QByteArray txData = mSendDataArray.at(0);
                    int ret = my_serialport->write(txData);
                    //qDebug() << "write size:"<<ret<<txData.toHex();
                    if(ret < txData.length())
                    {
                        //qDebug() << "write size:"<<ret;
                    }
                    my_serialport->flush();
                    if (my_serialport->waitForBytesWritten(300))
                    {
                        mSendDataArray.removeAt(0);
                        sendErrNum = 0;
                    }else
                    {
                        sendErrNum++;
                        QString str = "发送信息超时！";
                        QByteArray errString;
                        errString.append(str);
                        mSendErrorArray.append(errString);
                        emit(this->comRecive());
                        this->msleep(300);
                        if(sendErrNum > 3)
                            mSendDataArray.removeAt(0);
                    }
                }catch(QException){
                }
            }
        }
        if (mComOpened&&my_serialport->waitForReadyRead(100))  //50ms
        {
            try{
                //while (my_serialport->waitForReadyRead(50))
                //this->msleep(20);
                mRequestData += my_serialport->readAll();

                if(!mRequestData.isEmpty())
                {

                    while(mRequestData.length() >= 5)
                    {
                        uint length = mRequestData.length();
                        uint offset = 0;
                        bool isFind = false;
                        while (offset<length)
                        {
                      
                            emit serialFinished(emit serialFinished(comData););

                        }
                        else
                        {
                            mRequestData.clear();
                            //qDebug()<<"tempData.clear();"<<mRequestData.toHex()<<"length"<<mRequestData.length();
                        }
                    }
                }
            }catch(QException){}
        }
        if(mStopped&&mComOpened&&my_serialport!=NULL)
        {
            my_serialport->close();
            mComOpened=false;
        }
    }
    delete my_serialport;
    my_serialport = NULL;
}


void MyReviceThread::stop()
{
    mStopped=true;

}
void MyReviceThread::startCom()
{
    mStopped=false;

}
void MyReviceThread::changeComState(bool stat)
{
    mComOpened=stat;
}
void MyReviceThread::setMessage(const QString message)
{
    mMessageStr = message;

}
void MyReviceThread::setPortnum(const QString num)
{
    mPortNum=num;

}

void MyReviceThread::setBaudrate(const int baudrate){
    mBaudrate = baudrate;
}

void MyReviceThread:: changeTxState(bool stat)
{
    mTxEvent=stat;
}
void MyReviceThread:: changeRxState(bool stat)
{
    mRxEvent=stat;
}