devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Qt实现串口通信（C++实现串口通信小助手）---串口收发及串口数据解码、串口通信模拟器。_qt下实现串口通信源码

作者：繁依Fanyi0 | 2024-02-23 02:14:59

赞

踩

qt下实现串口通信源码

                                                     Qt实现串口通信示例

前言：以下串口通信示例，参考了现有网上前辈们的资源，最后结合部分个人的思想，所以下述博客会将实现的原理及代码的案例进行公开。

这里我们先上效果图：

一、串口通信简介

串口通信是上下位机进行通信的一种常用的通信协议，大部分单片机中都有一到多个串口资源经过简单的配置就可以实现上下位机的通信，下图是串口通信协议中的一种形式。如果你不是用硬件描述语言去实现一个串口，这部分了解下即可。常用的是8位数据位加起始位加停止位，因此串口是只能发送0-255区间的数据。因此想要发送int或者float型的数据需要按高地位或者到内存中取出数据来发送，此时就需要通信协议来确保数据的准确性，接下来将依次进行介绍。

二、串口通信各参数的含义

了解完串口通信的大致含义，我们再编程时候比较关心的还是串口通信中波特率、奇偶校验、数据位以及停止位的含义。下面我们引用一位前辈作出的解释，有关本文中涉及到的引用会在本文最后附上原创的出处，为了美观，不在相应的地方附上版权声明了。

简介

串口是一种非常通用的设备通信的协议（不要与通用串行总线Universal Serial Bus(USB)混淆）。大多数计算机包含两个基于RS232的串口。串口同时也是仪器仪表设备通用的通信协议；很多GPIB兼容的设备也带有RS-232口。同时，串口通信协议也可以用于获取远程采集设备的数据。
串口通信的概念非常简单，串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。它很简单并且能够实现远距离通信。比如IEEE488定义并行通行状态时，规定设备线总长不得超过20米，并且任意两个设备间的长度不得超过2米；而对于串口而言，长度可达1200米。
典型地，串口用于ASCII码字符的传输。通信使用3根线完成：（1）地线，（2）发送，（3）接收。由于串口通信是异步的，端口能够在一根线上发送数据同时在另一根线上接收数据。其他线用于握手，但不是必须的。串口通信最重要的参数是波特率、数据位、停止位和奇偶校验。对于两个进行通行的端口，这些参数必须匹配：
波特率

这是一个衡量符号传输速率的参数。它表示每秒钟传送的符号的个数。例如300波特表示每秒钟发送300个符号。当我们提到时钟周期时，我们就是指波特率，例如如果协议需要4800波特率，那么时钟是4800Hz。这意味着串口通信在数据线上的采样率为4800Hz。通常电话线的波特率为14400，28800和36600。波特率可以远远大于这些值，但是波特率和距离成反比。高波特率常常用于放置的很近的仪器间的通信，典型的例子就是GPIB设备的通信。
数据位

这是衡量通信中实际数据位的参数。当计算机发送一个信息包，实际的数据不会是8位的，标准的值是5、6、7和8位。如何设置取决于你想传送的信息。比如，标准的ASCII码是0～127（7位）。扩展的ASCII码是0～255（8位）。如果数据使用简单的文本（标准 ASCII码），那么每个数据包使用7位数据。每个包是指一个字节，包括开始/停止位，数据位和奇偶校验位。由于实际数据位取决于通信协议的选取，术语“包”指任何通信的情况。
停止位

用于表示单个包的最后一位。典型的值为1，1.5和2位。由于数据是在传输线上定时的，并且每一个设备有其自己的时钟，很可能在通信中两台设备间出现了小小的不同步。因此停止位不仅仅是表示传输的结束，并且提供计算机校正时钟同步的机会。适用于停止位的位数越多，不同时钟同步的容忍程度越大，但是数据传输率同时也越慢。
奇偶校验位

在串口通信中一种简单的检错方式。有四种检错方式：偶、奇、高和低。当然没有校验位也是可以的。对于偶和奇校验的情况，串口会设置校验位（数据位后面的一位），用一个值确保传输的数据有偶个或者奇个逻辑高位。例如，如果数据是011，那么对于偶校验，校验位为0，保证逻辑高的位数是偶数个。如果是奇校验，校验位为1，这样就有3个逻辑高位。高位和低位不是真正的检查数据，简单置位逻辑高或者逻辑低校验。这样使得接收设备能够知道一个位的状态，有机会判断是否有噪声干扰了通信或者是否传输和接收数据是否不同步。
2.补充

比特率
在数字信道中，比特率是数字信号的传输速率，它用单位时间内传输的二进制代码的有效位(bit)数来表示，其单位为每秒比特数bit/s(bps)、每秒千比特数(Kbps)或每秒兆比特数(Mbps)来表示(此处K和M分别为1000和1000000，而不是涉及计算机存储器容量时的1024和1048576)。
波特率
波特率指数据信号对载波的调制速率，它用单位时间内载波调制状态改变次数来表示，其单位为波特(Baud)。 波特率与比特率的关系为：比特率=波特率X单个调制状态对应的二进制位数。
显然，两相调制(单个调制状态对应1个二进制位)的比特率等于波特率；四相调制(单个调制状态对应2个二进制位)的比特率为波特率的两倍；八相调制(单个调制状态对应3个二进制位)的比特率为波特率的三倍；依次类推。
RS232是要用在近距离传输上最大距离为30M
RS485用在长距离传输最大距离1200M

三、Qt中的串口通信

qt中集成了QSerialport类，可以直接使用该类实现串口通信。这部分内容看到网上有的说在建立工程的时候要选择Qt Project  Setting ,不过我在使用Qt5.12建立工程的时候仍然按照普通项目工程建立（这里不再额外叙述怎么New 一个Project了），如果Qt版本低的话，工程失败情况下可以另行找工程建立方法。

在qt中使用串口通信仍然比较简单，只需要在.pro文件中加入下述代码就完成了。

QT       += core gui serialport

然后在工程的头文件中引用相关的头文件。

  1. #include <QtSerialPort/QSerialPort>
  2. #include <QtSerialPort/QSerialPortInfo>

接着在类中将串口类进行实例化。

    QSerialPort *serialPort;

以上的过程，我们就已经准备好了串口通信所需要的必要条件，接下来要使用串口通信，少不了的要对串口实例化的对象进行参数的设定，下面我们对串口进行初始化。

  1. void Serial_port::InitPort()
  2. {
  3.     const auto infos = QSerialPortInfo::availablePorts();
  4.     for(const QSerialPortInfo &info : infos)
  5.     {
  6.         QSerialPort serial;
  7.         serial.setPort(info);
  8.         if(serial.open(QIODevice::ReadWrite))
  9.         {
  10.             ui->PortBox->addItem(info.portName());
  11.             serial.close();
  12.         }
  13.     }
  14.     QStringList baudList;   //波特率
  15.     QStringList parityList; //校验位
  16.     QStringList dataBitsList;   //数据位
  17.     QStringList stopBitsList;   //停止位
  18.     // 波特率    //波特率默认选择下拉第三项：9600
  19.     baudList<<"1200"<<"2400"<<"4800"<<"9600"
  20.            <<"14400"<<"19200"<<"38400"<<"56000"
  21.           <<"57600"<<"115200";
  22.     ui->BaudBox->addItems(baudList);
  23.     ui->BaudBox->setCurrentIndex(3);
  24.     // 校验      //校验默认选择无
  25.     parityList<<"无"<<"奇"<<"偶";
  26.     ui->ParityBox->addItems(parityList);
  27.     ui->ParityBox->setCurrentIndex(0);
  28.     // 数据位      //数据位默认选择8位
  29.     dataBitsList<<"5"<<"6"<<"7"<<"8";
  30.     ui->DataBox->addItems(dataBitsList);
  31.     ui->DataBox->setCurrentIndex(3);
  32.     // 停止位      //停止位默认选择1位
  33.     stopBitsList<<"1"<<"2";
  34.     ui->StopBox->addItems(stopBitsList);
  35.     ui->StopBox->setCurrentIndex(0);
  36. }

其中初始化函数 中首先获取计算机中有效的端口号，然后将端口号的名称给端口选择控件。相应的波特率等也是赋予选择控件相应的值。setCurrentIndex（）是给控件设定默认下拉项的index。

经过对串口对象指针的初始化，就已经完成串口通信所要求的各参数配置，一个完整的通信当然也少不了串口的收数了，下面给出串口数据的收报函数。

  1. void Serial_port::readData()
  2. {
  3.     QByteArray buf;
  4.     if (serialPort){
  5.  
  6.     buf = serialPort->readAll();
  7.  
  8.     if (!buf.isEmpty())
  9.     {
  10.  
  11.         receBytes += buf.size();
  12.         QString redata = QString("received:%1").arg(QString::number(receBytes));
  13.         ui->sendlabel->setText(redata);
  14.         QString myStrTemp = QString::fromLocal8Bit(buf); //支持中文显示
  15.         if(ui->reDisplay->isChecked())
  16.         {
  17.             QString str = ui->textBrowser->toPlainText();
  18.             str +=myStrTemp;
  19.             ui->textBrowser->clear();
  20.             ui->textBrowser->append(str);
  21.         }
  22.     }
  23.     buf.clear();
  24.     }
  25.  
  26. }

其实，从上面的函数中我们就能发现qt中串口的收报函数很简单，只是需要下面的一行命令，就能够完成了串口的收数功能。

    buf = serialPort->readAll();

而相应的我们并不会满足这样单调的功能，所以在收报函数中加入接收总字节数显示以及显示收到的内容，这样的功能。

  1.         receBytes += buf.size();
  2.         QString redata = QString("received:%1").arg(QString::number(receBytes));
  3.         ui->sendlabel->setText(redata);
            ui->textBrowser->append(str);

说完了串口通信的收报，我们先不提发报的事情，从相关的串口助手上我们都知道，在显示接收的数据时候，很多情况下要求显示收到报文的16进制形式，所以这里我们再写另外一种收报函数（以16进制接收并显示）。

  1. void Serial_port::readToHex()
  2. {
  3.     QByteArray temp = serialPort->readAll();
  4.     auto isShow = ui->reDisplay->isChecked();         //接收显示？
  5.     QDataStream out(&temp,QIODevice::ReadOnly);    //将字节数组读入
  6.     while(!out.atEnd())
  7.     {
  8.            qint8 outChar = 0;
  9.            out>>outChar;   //每字节填充一次，直到结束
  10.            //十六进制的转换
  11.            QString str = QString("%1").arg(outChar&0xFF,2,16,QLatin1Char('0'));
  12.            if(isShow){
  13.                ui->textBrowser->insertPlainText(str.toUpper());//大写
  14.                ui->textBrowser->insertPlainText(" ");//每发送两个字符后添加一个空格
  15.                ui->textBrowser->moveCursor(QTextCursor::End);
  16.            }
  17.     }
  18.  
  19. }

最后让我们完成串口通信的发报功能，这部分其实很简单，但为了追求发报功能的完整性，所以我们丰富这部分函数的功能，同样的将发送功能分为文本发送和以16进制形式的发送。

  1. void Serial_port::on_sendButton_clicked()
  2. {
  3.     //Latin1是ISO-8859-1的别名，有些环境下写作Latin-1。ISO-8859-1编码是单字节编码，向下兼容ASCII
  4.    //其编码范围是0x00-0xFF，0x00-0x7F之间完全和ASCII一致，0x80-0x9F之间是控制字符，0xA0-0xFF之间是文字符号。
  5.     QString str = ui->lineEdit->text();
  6.  
  7.     if(!str.isEmpty())
  8.     {
  9.         auto isHexSend = ui->sHexRadio->isChecked();
  10.  
  11.         int len = str.length();
  12.         if(len%2 == 1)
  13.         {
  14.             str = str.insert(len-1,'0');
  15.         }
  16.         QByteArray senddata;
  17.         if(isHexSend)
  18.         {
  19.             StringToHex(str,senddata);
  20.             serialPort->write(senddata);
  21.  
  22.             if(serialPort->write(senddata)<0)
  23.             {
  24.                 QMessageBox::critical(this, tr("Error"), serialPort->errorString());
  25.             }
  26.         }
  27.         else
  28.         {
  29.             if(serialPort->write(ui->lineEdit->text().toLocal8Bit())<0)
  30.             {
  31.                 QMessageBox::critical(this, tr("Error"), serialPort->errorString());
  32.             }
  33.         }
  34.  
  35.     }
  36.  
  37. }

字符转换为16进制函数如下：

  1. void Serial_port::StringToHex(QString str, QByteArray &senddata)
  2. {
  3.     int hexdata,lowhexdata;
  4.            int hexdatalen = 0;
  5.            int len = str.length();
  6.            senddata.resize(len/2);
  7.            char lstr,hstr;
  8.            for(int i=0; i<len; )
  9.            {
  10.                //char lstr,
  11.                hstr=str[i].toLatin1();
  12.                if(hstr == ' ')
  13.                {
  14.                    i++;
  15.                    continue;
  16.                }
  17.                i++;
  18.                if(i >= len)
  19.                    break;
  20.                lstr = str[i].toLatin1();
  21.                hexdata = convertHexChart(hstr);
  22.                lowhexdata = convertHexChart(lstr);
  23.                if((hexdata == 16) || (lowhexdata == 16))
  24.                    break;
  25.                else
  26.                    hexdata = hexdata*16+lowhexdata;
  27.                i++;
  28.                senddata[hexdatalen] = (char)hexdata;
  29.                hexdatalen++;
  30.            }
  31.            senddata.resize(hexdatalen);
  32.  
  33. }
  1. char Serial_port::convertHexChart(char ch)
  2. {
  3.     if((ch >= '0') && (ch <= '9'))
  4.                 return ch-0x30;  // 0x30 对应 ‘0’
  5.             else if((ch >= 'A') && (ch <= 'F'))
  6.                 return ch-'A'+10;
  7.             else if((ch >= 'a') && (ch <= 'f'))
  8.                 return ch-'a'+10;
  9.     //        else return (-1);
  10.     else return ch-ch;//不在0-f范围内的会发送成0
  11.  
  12. }

四、解码

对于串口通信来说，收报是重要的一步但也不是最后的一步，在进行开发时，我们不但要完成数据的接收，同样要根据协议双方的约定完成报文的解码，再进行相应算法的开发，解码的复杂程度依赖于协议的复杂程度，这里我们仅仅提供一种简单的解码校验方式。

假设上图是我们接收的一个完整报的形式，其中ox55和0x53表示报文头，中间的校验位等暂不考虑，最后的sum表示和校验位。和校验即通过数据的累加和去验证数据的正确与否。上图是一帧需要发送的数据可以看从左到右分别为帧头，功能字，数据帧与和校验，还可以加上数据位数。帧头和功能字可以根据自己的需求进行定制，数据位即需要发送的数据，最后的SUM即为无符号char型数据，将SUM之前的数据求和（不用管数据的溢出）即可。下位机按这种方式将数据发送上来上位机只要找到帧头即可进行解码并且对数据进行验证，这里附一个简单的上位机解码的程序，之前用来解码下位机发送来的欧拉角数据使用的程序。

  1. void uart::ReadData()
  2. {
  3. 	ui.buffSize->setText(QString::number(serialPort.bytesAvailable()));
  4. 	int buffersize = ui.bufferSize->value();
  5. 	if (serialPort.bytesAvailable()>buffersize){   //更改过滤个数，提高通信速率
  6. 	requestData = serialPort.readAll().toHex();//转成 hex
  7.             }
  8. 	if (!requestData.isEmpty() )
  9. 	{
  10. 		QByteArray temp = requestData.mid(QString(requestData).indexOf("55"), 22);
  11. 		unsigned char buffer[11] = { 0 };
  12. 		unsigned char sum = 0;
  13. 		for (int i = 0; i < 11; i++)
  14. 		{
  15. 			buffer[i] = (ByteArrayToHexchar(temp.at((i << 1) )) << 4 )+ ByteArrayToHexchar(temp.at((i << 1) + 1 ));
  16. 			if (i<10)
  17. 				sum = sum + buffer[i];
  18. 		}
  19. 		//sum = buffer[0] + buffer[1] + buffer[2] + buffer[3] + buffer[5] + buffer[6];
  20. 		if ((buffer[0] == 0x55) && (buffer[1] == 0x53))
  21. 		if (sum == buffer[10])
  22. 		{
  23. 			float x, y, z;
  24. 			x = (buffer[3] << 8 | buffer[2]);
  25. 			y = (buffer[5] << 8 | buffer[4]);
  26. 			z = (buffer[7] << 8 | buffer[6]);
  27. 			x = x / 32768 * 180;
  28. 			y = y / 32768 * 180;
  29. 			z = z / 32768 * 180;
  30. 			ui.x->setText(QString::number(x, 'f', 2));
  31. 			ui.y->setText(QString::number(y, 'f', 2));
  32. 			ui.z->setText(QString::number(z, 'f', 2));
  33. 			//ui.textEdit->append(QString::number(z, 'f', 2));
  34. 			
  35. 			requestData.clear();
  36. 		}
  37. 	}
  38. 	
  39. 	if (!timer.isActive())
  40. 		timer.start(5000);//500ms定时器
  41. }

当然如果不考虑和校验位置的话就更简单了，假设我们的协议规定了一个完整报的长度为40字节，报文头为ox03和0x66,然后我们要从第15位和第16位解码出一个int数据，这里将去掉大部分个人的内容。

  1.         if(temp.size()==40)
  2.         {
  3.             if((recvdata[0]==0x03)&&(recvdata[1]==0x66))
  4.             {
  5.                 target_data.e=(int)(recvdata[15]+recvdata[16]*256);
  6.                 
  7.             }
  8.         }

五、发报模拟器

这里我们嵌入到demo中作为其中的一个小功能了，其中路径后面的输入框，在进行单击时候会打开文件系统框要求你去选取txt文件，然后点击播放按钮将读取txt中的内容（这里我的txt所有的数据都在一行，如果是分行的txt需要你自己去更改相应的代码）然后我这里每次模拟发报40个字节。

  1. void Serial_port::handleLineEditClicked()
  2. {
  3.     //QString curPath = QDir::currentPath();
  4.     QString curPath = "../QSerial_port";
  5.     //QFile file;
  6.     QString aFileName = QFileDialog::getOpenFileName(this,QString("选择文件"),curPath,QString("TEXT(*.txt)"));
  7.     ui->m_txt->setText(aFileName);
  8.  
  9. }
  1. void Serial_port::on_Playbutton_clicked()
  2. {
  3.     QString path = ui->m_txt->text();
  4.     //qDebug()<<"是否成功获取"<<path_ce->text();
  5.  
  6.     if(path.isEmpty())
  7.         return;
  8.     QFile aFile(path);
  9.     if(!aFile.exists())     //文件不存在
  10.         qDebug() <<"the file not exist!!";
  11.         //return;
  12.     if(!aFile.open(QIODevice::ReadOnly | QIODevice::Text))
  13.         qDebug() <<"文件无法打开";
  14.         //return;
  15.     QTextStream aStream(&aFile);    //用文件流读取文件
  16.     while (!aStream.atEnd())
  17.     {
  18.         QString qstr = aStream.readLine();   //读取文件的一行文本
  19.         //qDebug()<<qstr.length();
  20.         int len = qstr.length();
  21.         if(len%2 == 1)
  22.         {
  23.             qstr = qstr.insert(len-1,'0');
  24.         }
  25.         QByteArray senddata;
  26.         StringToHex(qstr,senddata);
  27.         //qDebug()<<senddata.size();
  28.         for(int i=0;i<senddata.size();i++)
  29.         {
  30.             QByteArray tmpsenddata=senddata.mid(i,40);
  31.             i=i+39;
  32.             //qDebug()<<tmpsenddata.length();
  33.             serialPort->write(tmpsenddata);
  34.  
  35.             if(!serialPort->waitForBytesWritten())   //这一句很关键，决定是否能发送成功
  36.             {
  37.                  qDebug()<<"serial write error";
  38.             }
  39.  
  40.             Sleep(1000);
  41.         }
  42.  
  43.     }
  44.  
  45. }

到这里基本就完成了串口通信的全部内容（上述代码设计到了工程的ui控件，请自行修改），另外额外提供一点，在模拟器中如果循环对串口数据进行发报，我们都知道，核心的代码就是

            serialPort->write(tmpsenddata);

但是当我们在进行发报的时候，会发现哪怕程序执行了write功能，收报方仍然无法收到，这里有人提出qt中的串口通信在发送后必须要进行发送是否成功的判断才能够正常工作，当然，这一点在循环中执行write是最明显看到的，单个命令可能是正常的，所以这里我们必须要加上判断。

  1.             if(!serialPort->waitForBytesWritten())   //这一句很关键，决定是否能发送成功
  2.             {
  3.                  qDebug()<<"serial write error";
  4.             }

好了到此Qt的串口通信就完全结束了，为了更直观的看到各功能的实现，下面给出完整的代码，如果还不明白，点击最后链接下载完整工程唠！

Serial_port.h

  1. #ifndef SERIAL_PORT_H
  2. #define SERIAL_PORT_H
  3.  
  4. #include <QMainWindow>
  5. #include <QtSerialPort/QSerialPort>
  6. #include <QtSerialPort/QSerialPortInfo>
  7. #include <QLabel>
  8. #include <QTimer>
  9. #include <windows.h>
  10. #include <QString>
  11. #include <QDebug>
  12. #include <dbt.h>
  13. #include <devguid.h>
  14. #include <setupapi.h>
  15. #include <initguid.h>
  16. #include <list>
  17. using namespace std;
  18.  
  19. namespace Ui {
  20. class Serial_port;
  21. }
  22.  
  23. class Serial_port : public QMainWindow
  24. {
  25.     Q_OBJECT
  26.  
  27. public:
  28.     explicit Serial_port(QWidget *parent = nullptr);
  29.     void InitPort();
  30.     ~Serial_port();
  31.  
  32. private slots:
  33.     void readData();    //读取数据
  34.     void timeToSend();  //定时发送
  35.  
  36.     void on_OpenButton_clicked();
  37.  
  38.     void on_r_clearButton_clicked();
  39.  
  40.     void on_s_clearButton_clicked();
  41.  
  42.     void on_sendButton_clicked();
  43.  
  44.     void StringToHex(QString str,QByteArray &senddata); //发送时进制转换
  45.     char convertHexChart(char ch);  //16进制转换
  46.     void readToHex();   //将读取的数据以16进制显示
  47.     void Mdisplay();
  48.     //void pasingData(QByteArray &array); //解析串口数据
  49.  
  50.     void handleLineEditClicked();
  51.  
  52.     void on_Playbutton_clicked();
  53.  
  54. private:
  55.     Ui::Serial_port *ui;
  56.     QSerialPort *serialPort;
  57.     QTimer *time;
  58.     static   int sendBytes;
  59.     static   int receBytes;
  60. };
  61. #endif // SERIAL_PORT_H

Serial_port.cpp

  1. #include "Serial_port.h"
  2. #include "ui_Serial_port.h"
  3. #include <QMessageBox>
  4. #include "m_lineEdit.h"
  5. #include <QDebug>
  6. #include <QFileDialog>
  7.  
  8.  
  9. Serial_port::Serial_port(QWidget *parent) :
  10.     QMainWindow(parent),
  11.     ui(new Ui::Serial_port)
  12. {
  13.     ui->setupUi(this);
  14.     time = new QTimer(this);
  15.     InitPort();
  16.     //设置默认值
  17.     ui->PortBox->setCurrentIndex(1);
  18.     ui->BaudBox->setCurrentIndex(7);
  19.     ui->StopBox->setCurrentIndex(0);
  20.     ui->DataBox->setCurrentIndex(3);
  21.     ui->ParityBox->setCurrentIndex(0);
  22.  
  23.     ui->sendButton->setEnabled(false);
  24.     ui->sHexRadio->setEnabled(false);
  25.     ui->sTextRadio->setChecked(true);
  26.     ui->sTextRadio->setEnabled(false);
  27.     ui->rTextRadio->setChecked(true);
  28.     ui->rHexRadio->setChecked(false);
  29.     ui->reDisplay->setChecked(true);
  30.  
  31.     connect(ui->reSendCheck, &QCheckBox::stateChanged,
  32.             this, &Serial_port::timeToSend);         //自动重发
  33.     connect(time, &QTimer::timeout, this, &Serial_port::on_sendButton_clicked);//
  34.  
  35.     connect(ui->rHexRadio, &QRadioButton::toggled, this, &Serial_port::Mdisplay);
  36.  
  37.     connect(ui->m_txt, SIGNAL(clicked()), this, SLOT(handleLineEditClicked()));
  38.  
  39.  
  40. }
  41.  
  42. int Serial_port::sendBytes = 0;
  43. int Serial_port::receBytes = 0;
  44.  
  45. void Serial_port::InitPort()
  46. {
  47.     const auto infos = QSerialPortInfo::availablePorts();
  48.     for(const QSerialPortInfo &info : infos)
  49.     {
  50.         QSerialPort serial;
  51.         serial.setPort(info);
  52.         if(serial.open(QIODevice::ReadWrite))
  53.         {
  54.             ui->PortBox->addItem(info.portName());
  55.             //qDebug()<<info.portName();
  56.             serial.close();
  57.         }
  58.     }
  59.     QStringList baudList;   //波特率
  60.     QStringList parityList; //校验位
  61.     QStringList dataBitsList;   //数据位
  62.     QStringList stopBitsList;   //停止位
  63.     // 波特率    //波特率默认选择下拉第三项：9600
  64.     baudList<<"1200"<<"2400"<<"4800"<<"9600"
  65.            <<"14400"<<"19200"<<"38400"<<"56000"
  66.           <<"57600"<<"115200";
  67.     ui->BaudBox->addItems(baudList);
  68.     ui->BaudBox->setCurrentIndex(3);
  69.     // 校验      //校验默认选择无
  70.     parityList<<"无"<<"奇"<<"偶";
  71.     ui->ParityBox->addItems(parityList);
  72.     ui->ParityBox->setCurrentIndex(0);
  73.     // 数据位      //数据位默认选择8位
  74.     dataBitsList<<"5"<<"6"<<"7"<<"8";
  75.     ui->DataBox->addItems(dataBitsList);
  76.     ui->DataBox->setCurrentIndex(3);
  77.     // 停止位      //停止位默认选择1位
  78.     stopBitsList<<"1"<<"2";
  79.     ui->StopBox->addItems(stopBitsList);
  80.     ui->StopBox->setCurrentIndex(0);
  81. }
  82.  
  83. Serial_port::~Serial_port()
  84. {
  85.     delete serialPort;
  86.     delete time;
  87.     delete ui;
  88. }
  89.  
  90. void Serial_port::readData()
  91. {
  92.     QByteArray buf;
  93.     if (serialPort){
  94.  
  95.     buf = serialPort->readAll();
  96.  
  97.     if (!buf.isEmpty())
  98.     {
  99.  
  100.         receBytes += buf.size();
  101.         QString redata = QString("received:%1").arg(QString::number(receBytes));
  102.         ui->sendlabel->setText(redata);
  103.         QString myStrTemp = QString::fromLocal8Bit(buf); //支持中文显示
  104.         if(ui->reDisplay->isChecked())
  105.         {
  106.             QString str = ui->textBrowser->toPlainText();
  107.             str +=myStrTemp;
  108.             ui->textBrowser->clear();
  109.             ui->textBrowser->append(str);
  110.         }
  111.     }
  112.     buf.clear();
  113.     }
  114.  
  115. }
  116.  
  117. void Serial_port::timeToSend()
  118. {
  119.     if(ui->reSendCheck->isChecked())
  120.     {
  121.         if(time->isActive())
  122.         {
  123.             return;
  124.         }
  125.         else
  126.         {
  127.             int ms = ui->spinBox->value();
  128.             time->start(ms);
  129.         }
  130.     }
  131.     else
  132.     {
  133.         if(time->isActive())
  134.         {
  135.             time->stop();
  136.         }
  137.         else
  138.         {
  139.             return;
  140.         }
  141.     }
  142.  
  143. }
  144.  
  145. void Serial_port::on_OpenButton_clicked()
  146. {
  147.     if (ui->OpenButton->text() == tr("打开串口"))
  148.     {
  149.         serialPort = new QSerialPort;
  150.  
  151.         serialPort->setPortName(ui->PortBox->currentText());
  152.  
  153.         if(serialPort->open(QIODevice::ReadWrite))
  154.         {
  155.             //qDebug()<<ui->BaudBox->currentIndex();
  156.             switch (ui->BaudBox->currentIndex()) {
  157.             case 0:
  158.                 serialPort->setBaudRate(QSerialPort::Baud1200);
  159.                 break;
  160.             case 1:
  161.                 serialPort->setBaudRate(QSerialPort::Baud2400);
  162.                 break;
  163.             case 2:
  164.                 serialPort->setBaudRate(QSerialPort::Baud4800);
  165.                 break;
  166.             case 3:
  167.                 serialPort->setBaudRate(QSerialPort::Baud9600);
  168.                 break;
  169.             case 4:
  170.                 serialPort->setBaudRate(QSerialPort::Baud19200);
  171.                 break;
  172.             case 5:
  173.                 serialPort->setBaudRate(QSerialPort::Baud38400);
  174.                 break;
  175.             case 6:
  176.                 serialPort->setBaudRate(QSerialPort::Baud57600);
  177.                 break;
  178.             case 7:
  179.                 serialPort->setBaudRate(QSerialPort::Baud115200);
  180.                 break;
  181.             default:
  182.                 break;
  183.             }
  184.  
  185.             switch (ui->StopBox->currentIndex()) {
  186.             case 0:
  187.                 serialPort->setStopBits(QSerialPort::OneStop);
  188.                 break;
  189.             case 1:
  190.                 serialPort->setStopBits(QSerialPort::TwoStop);
  191.                 break;
  192.             default:
  193.                 break;
  194.             }
  195.  
  196.             switch (ui->DataBox->currentIndex()) {
  197.             case 0:
  198.                 serialPort->setDataBits(QSerialPort::Data5);
  199.                 break;
  200.             case 1:
  201.                 serialPort->setDataBits(QSerialPort::Data6);
  202.                 break;
  203.             case 2:
  204.                 serialPort->setDataBits(QSerialPort::Data7);
  205.                 break;
  206.             case 3:
  207.                 serialPort->setDataBits(QSerialPort::Data8);
  208.                 break;
  209.             default:
  210.                 break;
  211.             }
  212.  
  213.             switch (ui->ParityBox->currentIndex()) {
  214.             case 0:
  215.                 serialPort->setParity(QSerialPort::NoParity);
  216.                 break;
  217.             case 1:
  218.                 serialPort->setParity(QSerialPort::OddParity);
  219.                 break;
  220.             case 2:
  221.                 serialPort->setParity(QSerialPort::EvenParity);
  222.                 break;
  223.             default:
  224.                 break;
  225.             }
  226.  
  227.             ui->OpenButton->setText(tr("关闭串口"));
  228.             ui->PortBox->setEnabled(false);
  229.             ui->BaudBox->setEnabled(false);
  230.             ui->StopBox->setEnabled(false);
  231.             ui->DataBox->setEnabled(false);
  232.             ui->ParityBox->setEnabled(false);
  233.             ui->sendButton->setEnabled(true);
  234.             ui->sTextRadio->setEnabled(true);
  235.             ui->sHexRadio->setEnabled(true);
  236.             connect(serialPort, &QSerialPort::readyRead, this, &Serial_port::readData);
  237.             connect(serialPort, &QSerialPort::readyRead, this, &Serial_port::readToHex);
  238.         }
  239.         else
  240.         {
  241.             QMessageBox::critical(this, tr("Error"), serialPort->errorString());
  242.         }
  243.     }
  244.     else
  245.     {
  246.         serialPort->clear();
  247.         serialPort->close();
  248.         serialPort->deleteLater();
  249.  
  250.         ui->sendButton->setEnabled(false);
  251.         ui->OpenButton->setText(tr("打开串口"));
  252.         ui->PortBox->setEnabled(true);
  253.         ui->BaudBox->setEnabled(true);
  254.         ui->StopBox->setEnabled(true);
  255.         ui->DataBox->setEnabled(true);
  256.         ui->ParityBox->setEnabled(true);
  257.         ui->sHexRadio->setEnabled(false);
  258.         ui->sTextRadio->setEnabled(false);
  259.  
  260.     }
  261.  
  262. }
  263.  
  264. void Serial_port::on_r_clearButton_clicked()
  265. {
  266.     ui->textBrowser->clear();
  267.  
  268. }
  269.  
  270. void Serial_port::on_s_clearButton_clicked()
  271. {
  272.     ui->lineEdit->clear();
  273. }
  274.  
  275. void Serial_port::on_sendButton_clicked()
  276. {
  277.     //Latin1是ISO-8859-1的别名，有些环境下写作Latin-1。ISO-8859-1编码是单字节编码，向下兼容ASCII
  278.    //其编码范围是0x00-0xFF，0x00-0x7F之间完全和ASCII一致，0x80-0x9F之间是控制字符，0xA0-0xFF之间是文字符号。
  279.     QString str = ui->lineEdit->text();
  280.  
  281.     if(!str.isEmpty())
  282.     {
  283.         auto isHexSend = ui->sHexRadio->isChecked();
  284.  
  285.         int len = str.length();
  286.         if(len%2 == 1)
  287.         {
  288.             str = str.insert(len-1,'0');
  289.         }
  290.         QByteArray senddata;
  291.         if(isHexSend)
  292.         {
  293.             StringToHex(str,senddata);
  294.             serialPort->write(senddata);
  295.  
  296.             if(serialPort->write(senddata)<0)
  297.             {
  298.                 QMessageBox::critical(this, tr("Error"), serialPort->errorString());
  299.             }
  300.         }
  301.         else
  302.         {
  303.             if(serialPort->write(ui->lineEdit->text().toLocal8Bit())<0)
  304.             {
  305.                 QMessageBox::critical(this, tr("Error"), serialPort->errorString());
  306.             }
  307.         }
  308.  
  309.     }
  310.  
  311. }
  312.  
  313. void Serial_port::StringToHex(QString str, QByteArray &senddata)
  314. {
  315.     int hexdata,lowhexdata;
  316.            int hexdatalen = 0;
  317.            int len = str.length();
  318.            senddata.resize(len/2);
  319.            char lstr,hstr;
  320.            for(int i=0; i<len; )
  321.            {
  322.                //char lstr,
  323.                hstr=str[i].toLatin1();
  324.                if(hstr == ' ')
  325.                {
  326.                    i++;
  327.                    continue;
  328.                }
  329.                i++;
  330.                if(i >= len)
  331.                    break;
  332.                lstr = str[i].toLatin1();
  333.                hexdata = convertHexChart(hstr);
  334.                lowhexdata = convertHexChart(lstr);
  335.                if((hexdata == 16) || (lowhexdata == 16))
  336.                    break;
  337.                else
  338.                    hexdata = hexdata*16+lowhexdata;
  339.                i++;
  340.                senddata[hexdatalen] = (char)hexdata;
  341.                hexdatalen++;
  342.            }
  343.            senddata.resize(hexdatalen);
  344.  
  345. }
  346.  
  347. char Serial_port::convertHexChart(char ch)
  348. {
  349.     if((ch >= '0') && (ch <= '9'))
  350.                 return ch-0x30;  // 0x30 对应 ‘0’
  351.             else if((ch >= 'A') && (ch <= 'F'))
  352.                 return ch-'A'+10;
  353.             else if((ch >= 'a') && (ch <= 'f'))
  354.                 return ch-'a'+10;
  355.     //        else return (-1);
  356.     else return ch-ch;//不在0-f范围内的会发送成0
  357.  
  358. }
  359.  
  360. void Serial_port::readToHex()
  361. {
  362.     QByteArray temp = serialPort->readAll();
  363.     auto isShow = ui->reDisplay->isChecked();         //接收显示？
  364.     QDataStream out(&temp,QIODevice::ReadOnly);    //将字节数组读入
  365.     while(!out.atEnd())
  366.     {
  367.            qint8 outChar = 0;
  368.            out>>outChar;   //每字节填充一次，直到结束
  369.            //十六进制的转换
  370.            QString str = QString("%1").arg(outChar&0xFF,2,16,QLatin1Char('0'));
  371.            if(isShow){
  372.                ui->textBrowser->insertPlainText(str.toUpper());//大写
  373.                ui->textBrowser->insertPlainText(" ");//每发送两个字符后添加一个空格
  374.                ui->textBrowser->moveCursor(QTextCursor::End);
  375.            }
  376.     }
  377.  
  378. }
  379.  
  380. void Serial_port::Mdisplay()
  381. {
  382.     if(ui->rHexRadio->isChecked())
  383.     {
  384.         disconnect(serialPort, &QSerialPort::readyRead, this, &Serial_port::readData);
  385.         connect(serialPort, &QSerialPort::readyRead, this, &Serial_port::readToHex);
  386.     }
  387.     else
  388.     {
  389.         connect(serialPort, &QSerialPort::readyRead, this, &Serial_port::readData);
  390.         disconnect(serialPort, &QSerialPort::readyRead, this, &Serial_port::readToHex);
  391.     }
  392.  
  393. }
  394.  
  395. void Serial_port::handleLineEditClicked()
  396. {
  397.     //QString curPath = QDir::currentPath();
  398.     QString curPath = "../QSerial_port";
  399.     //QFile file;
  400.     QString aFileName = QFileDialog::getOpenFileName(this,QString("选择文件"),curPath,QString("TEXT(*.txt)"));
  401.     ui->m_txt->setText(aFileName);
  402.  
  403. }
  404.  
  405. void Serial_port::on_Playbutton_clicked()
  406. {
  407.     QString path = ui->m_txt->text();
  408.     //qDebug()<<"是否成功获取"<<path_ce->text();
  409.  
  410.     if(path.isEmpty())
  411.         return;
  412.     QFile aFile(path);
  413.     if(!aFile.exists())     //文件不存在
  414.         qDebug() <<"the file not exist!!";
  415.         //return;
  416.     if(!aFile.open(QIODevice::ReadOnly | QIODevice::Text))
  417.         qDebug() <<"文件无法打开";
  418.         //return;
  419.     QTextStream aStream(&aFile);    //用文件流读取文件
  420.     while (!aStream.atEnd())
  421.     {
  422.         QString qstr = aStream.readLine();   //读取文件的一行文本
  423.         //qDebug()<<qstr.length();
  424.         int len = qstr.length();
  425.         if(len%2 == 1)
  426.         {
  427.             qstr = qstr.insert(len-1,'0');
  428.         }
  429.         QByteArray senddata;
  430.         StringToHex(qstr,senddata);
  431.         //qDebug()<<senddata.size();
  432.         for(int i=0;i<senddata.size();i++)
  433.         {
  434.             QByteArray tmpsenddata=senddata.mid(i,40);
  435.             i=i+39;
  436.             //qDebug()<<tmpsenddata.length();
  437.             serialPort->write(tmpsenddata);
  438.  
  439.             if(!serialPort->waitForBytesWritten())   //这一句很关键，决定是否能发送成功
  440.             {
  441.                  qDebug()<<"serial write error";
  442.             }
  443.  
  444.             Sleep(1000);
  445.         }
  446.  
  447.     }
  448.  
  449. }

最后提示一点，ui中的lineedit为自定义控件，需要提升相应功能，及添加对应类。

六、虚拟串口工具

对于程序来说，最方便的测验程序的时候不需要接硬件就能测试，这里介绍给大家一款能够创建虚拟串口的工具Virtual Serial Port Driver，以及串口小助手，当然咱们自己写的就是小助手，为了严重功能确实好用，那也可以下载个网上的，或者运行两个，有关工具的介绍这里就不提了，百度上讲的已经很好了，具体的资源也很容易百度到，这里也不提供了，百度对该工具的使用介绍链接（点击）。

七、参考文献

1.文中第一部分，串口通信的简介、和校验解码、串口通信图片及报文示图片来源于CSDN博主「WAmani」的原创文章，链接为：https://blog.csdn.net/wamani/article/details/52849043

2.文中第二部分，串口通信各参数的含义来源于CSDN博主「guomutian911」的原创文章，链接为：https://blog.csdn.net/guomutian911/article/details/47044603/

3.文中一些功能的实现来源于CSDN博主「苍雨流痕」的原创文章，链接为https://blog.csdn.net/hellolru/article/details/80838824

八、资源下载

点击下载。或者访问链接：https://download.csdn.net/download/zijinmu69/12376049

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/132949
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号