当前位置:   article > 正文

Python+PyQt5实现串口数据采集和显示

pyqt5 串口

本节我们将会通过PyQt5实现串口数据采集和实时通信,涉及到的技术栈包括:PythonPyQt5

一、环境搭建

1.1 Python 3.X安装

直接从官网下载安装包:https://www.python.org/ftp/python/

这里我下载的包为https://www.python.org/ftp/python/3.9.6/python-3.9.6-amd64.exe,安装版本:python 3.9.6

双击开始安装的时候,一定要把下面的 Add Path勾上 (表示添加到环境变量,这样cmd也能使用了),其他一路Next安装完成。默认会安装一键式工具pip

pip工具镜像源配置。配置方法如下:

  • cmd窗口下执行echo %HOMEPATH%获取用户HOME目录,并在该目录下创建pip目录;
  • pip目录下创建pip.ini文件。记住,后缀必须是.ini格式。并在该文件中写入如下内容;

内容如下:

  1. [global]
  2. index-url = https://pypi.tuna.tsinghua.edu.cn/simple
  3. [install]
  4. trusted-host = pypi.tuna.tsinghua.edu.cn
1.2 安装Pycharm

官方网站:http://www.jetbrains.com/pycharm/,提供以下安装版本:

  • Professional:专业版(收费,网上一大堆破解方法)
  • Community:社区版(免费,我用的这个),下载版本为pycharm-community-2023.3.4.exe
1.3 PyQt5安装

使用pip工具安装PyQt5工具,执行:

pip install pyqt5

如果慢,用国内源:

pip install pyqt5 -i https://pypi.tuna.tsinghua.edu.cn/simple

使用pip工具安装PyQt5-tools工具,执行:

pip install pyqt5-tools

如果慢,用国内源:

pip install pyqt5-tools -i https://pypi.tuna.tsinghua.edu.cn/simple

工具安装完成后的路径在E:\Program Files\Python\Lib\site-packages

PyQt5主要有三个部分:

  • QtCore: 包含了核心的非GUI的功能。主要和时间、文件与文件夹、各种数据、模型、流、URLsmime类文件、进程与线程一起使用;
  • QtGui: 包含了窗口系统、事件处理、2D图像、基本绘画、字体和文字类;
  • QtWidgets: 包含了一些创建桌面的UI元素和控件;
1.4 环境配置

PyCharm是开发Python程序主流常用的IDE。为方便调用Qt Designer实现界面开发和编译相应完成,可以在PyCharm配置Qt DesignerPyUICPyrcc

其中Qt DesignerQt 设计师,PyUics是把UI界面转换成py文件,Pyrcc是资源系统转换。

打开PyCharm, 新建一个项目,项目名称为serial_port

这里Python path选择我们之前安装的python 3.9.6的路径:E:\Program Files\Python\python.exe

1.4.1 配置Qt Designer

菜单File ->Settings -> Tools -> External Tools -> +号,进行添加。 参数配置说明:

  • Name:填入Qt Designer,实际可以任意取值;
  • Programdesigner.exe程序绝对路径。根据实际安装路径填写,这里我配置的是E:\Program Files\Python\Lib\site-packages\qt5_applications\Qt\bin\designer.exe
  • Working directory: 填入$FileDir$,固定取值;

具体如下:

1.4.2 配置PyUIC

该工具是用于将Qt Designer工具开发完成的.ui文件转化为.py文件。配置打开路径同Qt Designer,参数配置说明:

  • Name:填入PyUIC,实际可以任意取值。
  • Programpython.exe程序绝对路径,根据实际安装路径填写,这里我配置的是E:\Program Files\Python\python.exe
  • Arguments: -m PyQt5.uic.pyuic $FileName$ -o $FileNameWithoutExtension$.py
  • Working directory: 填入$FileDir$,固定取值;

具体如下:

1.4.3 配置Pyqcc

配置打开路径同Qt Designer。参数配置说明:

  • Name:填入Pyqcc,实际可以任意取值。
  • Program:这里我配置的是E:\Program Files\Python\Scripts\pyrcc5.exe
  • Arguments: $FileName$ -o $FileNameWithoutExtension$_rc.py
  • Working directory: 填入$FileDir$,固定取值;

具体如下:

1.5 测试

测试Qt DesignerPyUICPyqcc配置是否成功。打开路径:菜单栏Tools ->External Tools ->Qt Designer/PyUIC/Pyqcc

1.5.1 ui_serial_port.ui

点击Qt Designer,打开Designer程序主主界面,会弹出一个窗口,这里一般是选择Main Window或者Widget,其中Main Window继承自Widget,添加了一些内容,本质二者差不多。这里选择的是Main Window

将左侧Widget BoxPush button空间拖到主界面,Ctrl + S保存名称ui_serial_port.ui,默认后缀就是.ui

1.5.2 ui_serial_port.py

选中ui_serial_port.ui文件,同理点击PyUIC,自动完成ui_serial_port.ui文件的转换,生成文件名为ui_serial_port.py

1.5.3 serial_port.py

ui界面代码,还需要有一个逻辑代码,而逻辑代码个人感觉使用类的形式来组织更加方便,也更优雅。

还记得创建ui时选择的类吗?是Widget还是Main Window,逻辑代码类最好是继承这个这个类,即QWidgetQMainWindow。一般的代码结构如下所示:

  1. from PyQt5.QtWidgets import QMainWindow
  2. # 导入设计的ui界面转换成的py文件
  3. from ui_serial_port import Ui_MainWindow
  4. class SerialPort(QMainWindow):
  5. """
  6. 串口行为
  7. """
  8. def __init__(self):
  9. # QMainWindow构造函数初始化
  10. super().__init__()
  11. self.ui = Ui_MainWindow()
  12. # 这个函数本身需要传递一个MainWindow类,而该类本身就继承了这个,所以可以直接传入self
  13. self.ui.setupUi(self)
1.5.4 main.py

在当前项目下,新建main.py 文件;

  1. import sys
  2. from serial_port import SerialPort
  3. from PyQt5.QtWidgets import QApplication, QMainWindow
  4. if __name__ == '__main__':
  5. # 先建立一个app
  6. app = QApplication(sys.argv)
  7. # 初始化一个对象,调用init函数,已加载设计的ui文件
  8. ui = SerialPort()
  9. # 显示这个ui
  10. ui.show()
  11. # 运行界面,响应按钮等操作
  12. sys.exit(app.exec_())

运行程序:

二、程序设计

2.1 需求

客户这里有一款惯性设备,在惯性装置的AXS31接口,里面有两路数据,一路称为导航解算,一路称为原始信息。我们通过串口读取该设备的数据并在界面显示处理,同时还需要将读取到的数据保存到文本中。

实际在测试时候发现只能接收到导航解算报文,因此猜测原始信息已经被传感器内部转换为导航解算报文了。

2.1.1 导航解算报文

波特率:230400,数据位8,停止位1,无校验;

字节意义类型所占字节备注
1-2报文头2字节5a 5a
3工作状态1字节0xFF等待对准
0x00码头对准
0x01海上对准
0x02牵引对准
0x03 是无阻尼
0x04是惯导阻尼
0x05 点校
0x06 综合校正
0x07 位置组合
4参数状态1字节B8 =0手动 B8=1自动
5-8运行时间4字节单位0.05s
9-11纬度3字节量纲93206.75556
12-14经度3字节量纲46603.37778
15-16升沉2字节最小量纲100m
17-18东速2字节最小量纲100kn
19-20北速2字节最小量纲100kn
21-22垂速2字节最小量纲100m/s
23-25姿态角13字节最小量纲0.25*93206.75556
26-28姿态角23字节最小量纲93206.75556
29-31姿态角33字节最小量纲93206.75556
32-34姿态角速率1(纵摇角速率)3字节93206.75556 度每秒
35-37姿态角速率2 (横摇角速率)3字节93206.75556 度每秒
38-40姿态角速率3(航向角速率)3字节93206.75556度每秒
41故障码1字节B0=1 IMU接收错
B1=1 测角采样错
B2=1 接收缓存错
B3=1 测角控制板错
B4=1 驱动错
B5=1 测角错
B6=1 激磁错
B7=1 转台保护错
42-43IMUtime2字节
44-47备用4字节
48应答标志1字节可忽略
49校验和1字节3-48字节累加和
2.1.2 原始信息报文

波特率:230400,数据位8,停止位1,无校验;

字节意义类型所占字节备注
1-2报文头Int2字节5a 5a
3-6IMUtimeInt4字节整型时戳
7-10GYROXfloat4字节直接浮点数
11-14GYROYfloat4字节直接浮点数
15-18GYROZfloat4字节直接浮点数
19-22ACCEXfloat4字节直接浮点数
23-26ACCEYfloat4字节直接浮点数
27-30ACCEZfloat4字节直接浮点数
31-34备用Int4字节
35-37转台角1Int3字节量纲2.330168888888889*e4°
38-40转台角2Int3字节量纲2.330168888888889*e4°
41-43GPS经度Int3字节量纲93206.75556
44-46GPS纬度Int3字节量纲46603.37778
47-48Para4Int2字节
49-50Para[2]/para[5]Int2字节
51-52Para[3]/para[6]Int2字节
53-54Para[7]Int2字节
55-56Para[8]Int2字节
57comdatavalidInt1字节
58校验和Int1字节3-57和校验
2.2 界面设计

首先,我们设计一个简单的用户界面,包括:

  • 串口配置区域:【串口】、【波特率】、【数据位】、【停止位】的设置,以及一个按钮用于开始打开和关闭串口;
  • 接收设置区域:用于设置接收和发送的数据格式,支持16进制以及ASCII两种格式;这里为了简单起见,程序中发送/接收采用一样的数据格式;
    • 16进制:例如:5a 5a 02 03 5a
    • ASCII格式:例如:DDR V1.12 52218f4949 cym 23/07/0
  • 数据发送区域:由一个文本框和一个发送按钮组成;
  • 数据接收区域:由一个文本域组成;
  • 如果接收到的数据时导航解算或者原始信息报文,则将解析后的数据显示在导航结算和原始信息区域;

界面效果如下(参考网上串口助手工具);

三、程序实现

我们将界面原型划分成了五个区域;

  • 串口设置区域;
  • 接收设置区域;
  • 数据发送区域;
  • 数据接收区域;
  • 导航解算和原始信息区域;

我们针对这五个区域编写相关实现代码,其具体流程如下;

  • 使用Qt Designer工具按照界面原型设置窗口,主要使用到一些基础控件,比如按钮、文本框、文本域、单选框、复选框等;‘
  • 针对窗体各个区域中的控件进行初始化工作;

我们将界面相关的代码均放置在serial_port.py文件中,该文件主要包含了如下功能;

  • 界面初始化工作;
  • 打开串口;
  • 接收数据;
  • 发送数据。
3.1 初始化工作
3.1.1 初始化串口设置区域

串口设置区域主要由【串口】、【波特率】、【校验位】、【数据位】、【停止位】下拉列表以及【打开串口】按钮组成。

首先需要初始化【串口】、【波特率】、【校验位】、【数据位】、【停止位】下拉列表;

  • 串口:下拉列表加载系统当前可用的串口;
  • 波特率:下拉列表设置常见的波特率,比如1200240096004800, 9600, 19200, 384000, 57600, 115200, 460800, 921600, 230400, 1500000等;
  • 校验位:下拉列表设置校验位为NoneOddEvenMarkSpace
  • 数据位:下拉列表设置为5678
  • 停止位:下拉列表设置为12

设置【打开串口】按钮点击事件对应的槽函数为self.open_serial_connection,当点击【打开串口】按钮时将会执行该函数;

代码位于serial_port.py__init_serial_setting__,具体如下;

  1. def __init_serial_setting__(self):
  2. """
  3. 初始化串口设置相关控件默认参数
  4. 设置下拉列表自动补全 https://blog.csdn.net/xuleisdjn/article/details/51434118
  5. :return:
  6. """
  7. # 加载可用串口
  8. self.ui.cbx_com.setEditable(False)
  9. self.ui.cbx_com.setMaxVisibleItems(10) # 设置最大显示下列项 超过要使用滚动条拖拉
  10. self.ui.cbx_com.setInsertPolicy(QComboBox.InsertAfterCurrent) # 设置插入方式\
  11. port_list = list(serial.tools.list_ports.comports()) # 获取当前的所有串口,得到一个列表
  12. for port in port_list:
  13. self.ui.cbx_com.addItem(port.device)
  14. # 初始化波特率列表
  15. self.ui.cbx_baud_rate.setEditable(False)
  16. self.ui.cbx_baud_rate.setMaxVisibleItems(10) # 设置最大显示下列项 超过要使用滚动条拖拉
  17. self.ui.cbx_baud_rate.setInsertPolicy(QComboBox.InsertAfterCurrent) # 设置插入方式
  18. for baud_rate in [1200, 2400, 4800, 9600, 19200, 384000, 57600, 115200, 460800, 921600, 230400, 1500000]:
  19. self.ui.cbx_baud_rate.addItem(str(baud_rate), baud_rate)
  20. # 设置默认值
  21. self.ui.cbx_baud_rate.setCurrentIndex(7)
  22. # 初始化校验位列表
  23. self.ui.cbx_parity_bit.setEditable(False)
  24. self.ui.cbx_parity_bit.setMaxVisibleItems(10) # 设置最大显示下列项 超过要使用滚动条拖拉
  25. self.ui.cbx_parity_bit.setInsertPolicy(QComboBox.InsertAfterCurrent) # 设置插入方式
  26. for (key, value) in {'None': serial.PARITY_NONE, 'Odd': serial.PARITY_ODD,
  27. 'Even': serial.PARITY_EVEN, 'Mark': serial.PARITY_MARK,
  28. 'Space': serial.PARITY_SPACE}.items():
  29. self.ui.cbx_parity_bit.addItem(key, value)
  30. # 设置默认值
  31. self.ui.cbx_parity_bit.setCurrentIndex(0)
  32. # 初始化数据位列表
  33. self.ui.cbx_data_bit.setEditable(False)
  34. self.ui.cbx_data_bit.setMaxVisibleItems(10) # 设置最大显示下列项 超过要使用滚动条拖拉
  35. self.ui.cbx_data_bit.setInsertPolicy(QComboBox.InsertAfterCurrent) # 设置插入方式
  36. for data_bit in [serial.FIVEBITS, serial.SIXBITS, serial.SEVENBITS, serial.EIGHTBITS]:
  37. self.ui.cbx_data_bit.addItem(str(data_bit), data_bit)
  38. # 设置默认值
  39. self.ui.cbx_data_bit.setCurrentIndex(3)
  40. # 初始化停止位列表
  41. self.ui.cbx_stop_bit.setEditable(False)
  42. self.ui.cbx_stop_bit.setMaxVisibleItems(10) # 设置最大显示下列项 超过要使用滚动条拖拉
  43. self.ui.cbx_stop_bit.setInsertPolicy(QComboBox.InsertAfterCurrent) # 设置插入方式
  44. for data_bit in [serial.STOPBITS_ONE, serial.STOPBITS_TWO]:
  45. self.ui.cbx_stop_bit.addItem(str(data_bit), data_bit)
  46. # 设置默认值
  47. self.ui.cbx_stop_bit.setCurrentIndex(0)
  48. # 设置点击打开串口按钮对应的槽函数
  49. self.ui.btx_start.clicked.connect(self.open_serial_connection)
3.1.2 初始化串口接收区域

串口接收区域主要由【Hex】、【ASCII】单选框以及【显示时间】复选框组成;

设置发送/接收的数据格式,支持HexASCIIHexASCII是互斥的,默认选中Hex,这里我们设置:

  • Hex】单选框点击事件对应的槽函数为self.rbn_data_format_hex_clicked,当点击【Hex】单选框时将会执行该函数,在该函数内会记录当前选中的是hex
  • ASCII】单选框点击事件对应的槽函数为self.rbn_data_format_ascii_clicked,当点击【ASCII】单选框时将会执行该函数,在该函数内出记录当前选中的是ascii

【显示时间】复选框用于设置串口接收到数据时,是否在接收区域输出当前时间;

代码位于serial_port.py__init_recv_setting__,具体如下;

  1. def __init_recv_setting__(self):
  2. """
  3. 接收设置初始化
  4. :return:
  5. """
  6. self.ui.rbn_data_format_hex.clicked.connect(self.rbn_data_format_hex_clicked)
  7. self.ui.rbn_data_format_ascii.clicked.connect(self.rbn_data_format_ascii_clicked)

其中rbn_data_format_hex_clicked函数;

  1. def rbn_data_format_hex_clicked(self):
  2. """
  3. 接收数据格式发生变化
  4. :return:
  5. """
  6. if self.ui.rbn_data_format_hex.isChecked():
  7. self.ui.rbn_data_format_ascii.setChecked(False)
  8. if self.serial_thread:
  9. self.serial_thread.date_format = 'hex'

其中rbn_data_format_ascii_clicked函数;

  1. def rbn_data_format_ascii_clicked(self):
  2. """
  3. 接收数据格式发生变化
  4. :return:
  5. """
  6. if self.ui.rbn_data_format_ascii.isChecked():
  7. self.ui.rbn_data_format_hex.setChecked(False)
  8. if self.serial_thread:
  9. self.serial_thread.date_format = 'ascii'
3.1.3 初始化串口数据接收区域

串口数据接收区域由一个【文本域控件】组成,用于存放串口接收到的数据,数据长度默认最长为5000字符,超过5000字符自动清空;

这里初始化【文本域控件】为只读,并且串口接收到数据时,自动将滚动条移动至【文本域控件】的最低端;

代码位于serial_port.py__init_recv_setting__,具体如下;

  1. def __init_recv_data_viewer__(self):
  2. """
  3. 初始化串口数据接收区域
  4. :return:
  5. """
  6. self.ui.txt_recv_data_viewer.setReadOnly(True)
  7. self.ui.txt_recv_data_viewer.textChanged.connect(
  8. lambda: self.ui.txt_recv_data_viewer.moveCursor(QTextCursor.End))
3.1.4 初始化串口数据发送区域

串口数据接收区域由一个【文本输入框】和一个【发送】按钮组成,文本输入框用于输入要发送的内容,点击发送按钮,会将文本输入框的内容通过当前打开的串口发送出去;

代码位于serial_port.py__init_send_data_viewer__,具体如下;

  1. def __init_send_data_viewer__(self):
  2. """
  3. 初始化串口数据发送区域
  4. :return:
  5. """
  6. self.ui.btn_send.clicked.connect(self.send_serial_data)

设置【发送】按钮点击事件对应的槽函数为self.send_serial_data,当点击【发送】按钮时将会执行该函数进行串口数据的发送。

3.1.5 初始化报文解析区域

报文解析区域主要由两部分组成;

  • 导航结算区域:该部分主要由【报文头】、【工作状态】、【参数状态】、【运行时间】等文本输入框组成,其与导航解算报文字段一一对应;
  • 原始信息区域:该部分主要由【报文头】、【IMUTime】、【GYROX】、【GYROZ】等文本输入框组成,其与原始信息报文字段一一对应;

代码位于serial_port.py__init_package_setting__,具体如下;

  1. def __init_package_setting__(self):
  2. self.ui.let_nav_header.setReadOnly(True)
  3. self.ui.let_nav_work_state.setReadOnly(True)
  4. self.ui.let_nav_param_state.setReadOnly(True)
  5. self.ui.let_nav_run_time.setReadOnly(True)
  6. self.ui.let_nav_latitude.setReadOnly(True)
  7. self.ui.let_nav_longitude.setReadOnly(True)
  8. self.ui.let_nav_heave.setReadOnly(True)
  9. self.ui.let_nav_east_speed.setReadOnly(True)
  10. self.ui.let_nav_north_speed.setReadOnly(True)
  11. self.ui.let_nav_vertical_speed.setReadOnly(True)
  12. self.ui.let_nav_attitude_angle1.setReadOnly(True)
  13. self.ui.let_nav_attitude_angle2.setReadOnly(True)
  14. self.ui.let_nav_attitude_angle3.setReadOnly(True)
  15. self.ui.let_nav_attitude_velocity1.setReadOnly(True)
  16. self.ui.let_nav_attitude_velocity2.setReadOnly(True)
  17. self.ui.let_nav_attitude_velocity3.setReadOnly(True)
  18. self.ui.let_nav_fault_code.setReadOnly(True)
  19. self.ui.let_nav_imu_time.setReadOnly(True)
  20. self.ui.let_nav_reserved.setReadOnly(True)
  21. self.ui.let_nav_response_flag.setReadOnly(True)
  22. self.ui.let_nav_check_sum.setReadOnly(True)
  23. self.ui.let_raw_header.setReadOnly(True)
  24. self.ui.let_raw__imu_time.setReadOnly(True)
  25. self.ui.let_raw_gyrox.setReadOnly(True)
  26. self.ui.let_raw_gyroy.setReadOnly(True)
  27. self.ui.let_raw_gyroz.setReadOnly(True)
  28. self.ui.let_raw_accex.setReadOnly(True)
  29. self.ui.let_raw_accey.setReadOnly(True)
  30. self.ui.let_raw_accez.setReadOnly(True)
  31. self.ui.let_raw_reserved.setReadOnly(True)
  32. self.ui.let_raw_turntable_angle1.setReadOnly(True)
  33. self.ui.let_raw_turntable_angle2.setReadOnly(True)
  34. self.ui.let_raw_longitude.setReadOnly(True)
  35. self.ui.let_raw_latitude.setReadOnly(True)
  36. self.ui.let_raw_para4.setReadOnly(True)
  37. self.ui.let_raw_para2_5.setReadOnly(True)
  38. self.ui.let_raw_para3_6.setReadOnly(True)
  39. self.ui.let_raw_para7.setReadOnly(True)
  40. self.ui.let_raw_para8.setReadOnly(True)
  41. self.ui.let_raw_comdata_valid.setReadOnly(True)
  42. self.ui.let_raw_check_sum.setReadOnly(True)

这里我们仅仅是将上述这些控件设置为只读状态。

3.2 打开串口

根据硬件设备参数在串口设置区域进行配置【串口】、【波特率】、【校验位】、【数据位】、【停止位】,配置完成后,当点击【打开串口】按钮,将会执行open_serial_connection函数;

open_serial_connection函数内主要会进行如下工作;

  • 获取串口设置区域配置的参数,并对参数进行校验,具体是由__validate_setting__函数完成;
  • 调用SerialThread创建串口线程,并将串口设置区域配置参数传递给线程;
  • 设置串口线程接收到数据时对应的槽函数为handle_data_received,即串口接收到数据时会执行handle_data_received函数;
  • 设置串口线程发生异常时对应的槽函数为handler_serial_error,即串口线程发生异常时,会将错误信息发送给主线程,主线程接收到错误信息,将会在界面显示;

核心代码如下:

  1. def open_serial_connection(self):
  2. """
  3. 打开串口
  4. :return:
  5. """
  6. if not self.serial_thread or not self.serial_thread.isRunning():
  7. # 参数校验
  8. if not self.__validate_setting__():
  9. return
  10. # 建立一个串口
  11. self.serial_thread = SerialThread(self.ui.cbx_com.currentText(),
  12. self.ui.cbx_baud_rate.currentData(),
  13. self.ui.cbx_data_bit.currentData(),
  14. self.ui.cbx_parity_bit.currentData(),
  15. self.ui.cbx_stop_bit.currentData(),
  16. 'hex' if self.ui.rbn_data_format_hex.isChecked() else 'ascii')
  17. self.serial_thread.data_received.connect(self.handle_data_received)
  18. self.serial_thread.serial_error.connect(self.handler_serial_error)
  19. self.serial_thread.start()
  20. self.ui.btx_start.setText("关闭串口")
  21. else:
  22. self.serial_thread.stop()
  23. # 打开串口操作
  24. self.ui.btx_start.setText("打开串口")
3.2.1 __validate_setting__

__validate_setting__函数主要就是校验【串口】、【波特率】、【校验位】、【数据位】、【停止位】下拉列表是否已经配置,如果未配置将会弹出警告提示信息;

  1. def __validate_setting__(self):
  2. """
  3. 校验串口设置参数
  4. :return:
  5. """
  6. # 参数校验
  7. if self.ui.cbx_com.currentIndex() == -1:
  8. QMessageBox.warning(self, "Warning", "请选择串口!")
  9. return False
  10. if self.ui.cbx_baud_rate.currentIndex() == -1:
  11. QMessageBox.warning(self, "Warning", "请选择波特率!")
  12. return False
  13. if self.ui.cbx_parity_bit.currentIndex() == -1:
  14. QMessageBox.warning(self, "Warning", "请选择校验位!")
  15. return False
  16. if self.ui.cbx_data_bit.currentIndex() == -1:
  17. QMessageBox.warning(self, "Warning", "请选择数据位!")
  18. return False
  19. if self.ui.cbx_data_bit.currentIndex() == -1:
  20. QMessageBox.warning(self, "Warning", "请选择停止位!")
  21. return False
  22. return True
3.2.2 SerialThread

SerialThread类的实现位于serial_thread.py文件中,这块我们后面单独接收。

3.2.3 handle_data_received

当串口接收到数据时会执行handle_data_received函数,这块我们后面单独接收。

3.2.4 handler_serial_error

串口线程发生异常时,会将错误信息发送给主线程,主线程接收到错误信息,将会在界面显示;具体实现函数为handler_serial_error

  1. def handler_serial_error(self, error):
  2. """
  3. 串口接收线程异常
  4. :param error:
  5. :return:
  6. """
  7. QMessageBox.critical(self, '错误', error)
3.3 接收数据

上面我们提到,当串口线程接收到数据时,会将数据通过信号与槽机制传递给主线程,将会由主线程handle_data_received函数进行处理;

handle_data_received函数内主要会进行如下工作;

  • 获取当前时间;
  • 串口数据接收区域【文本域控件】内容超过5000个字符将会清空;
  • 如果配置了显示当前时间,将会在接收到的数据前面插入当前时间,并将数据追加到串口数据接收区域【文本域控件】中;
  • 如果串口接收区域配置的数据格式为hex,将会对接收到的报文信息进行解析;
    • 解析由PackageParse类完成,解析类会根据报文数据长度、报文头、以及校验和等参数判定当前报文格式为导航结算还是原始信息;
    • 如果为导航结算报文,保存报文到nav_data.csv,同时将报文解析到的字段一一填入界面导航结算区域对应的控件中;
    • 如果为原始信息报文,保存报文到raw_data.csv,同时将报文解析到的字段一一填入界面原始信息区域对应的控件中;
  • 移除已经解析的报文,截取未解析的报文,重复报文解析的流程,直至报文内容不满足导航结算、原始信息报文格式;

handle_data_received代码如下:

  1. def handle_data_received(self, data):
  2. """
  3. 接收数据
  4. :param data:接收到的数据
  5. :return:
  6. """
  7. # 获取时间
  8. current_time = QDateTime.currentDateTime().toString("yyyy-MM-dd hh:mm:ss")
  9. # 超过5000字符清空
  10. if len(self.ui.txt_recv_data_viewer.toPlainText()) > 5000:
  11. self.ui.txt_recv_data_viewer.clear()
  12. # 更新显示区域中的数据
  13. if self.ui.cbx_show_time.isChecked():
  14. self.ui.txt_recv_data_viewer.insertPlainText(f"[{current_time}] {data}")
  15. else:
  16. self.ui.txt_recv_data_viewer.insertPlainText(f"[{data}")
  17. # 必须是hex格式
  18. if self.ui.rbn_data_format_ascii.isChecked():
  19. return
  20. # 如果报文最后两位是换行符,则移除
  21. data = data.replace('0d 0a', '')
  22. data = bytes.fromhex(data.replace(' ', ''))
  23. # 解析data
  24. while data is not None:
  25. package_parse = PackageParse(data)
  26. data_format = package_parse.get_data_format()
  27. if data_format == PackageParse.Type.NAl_SOL:
  28. # 解析数据
  29. dict_msg = package_parse.get_nav_sol()
  30. # 写入当前时间,并保存到文件
  31. dict_msg["current_time"] = current_time
  32. save_csv('nav_data.csv', dict_msg)
  33. # 界面显示
  34. self.ui.let_nav_header.setText(dict_msg["header"])
  35. self.ui.let_nav_work_state.setText(dict_msg["work_state"])
  36. self.ui.let_nav_param_state.setText(dict_msg["param_state"])
  37. self.ui.let_nav_run_time.setText(str(dict_msg["run_time"]))
  38. self.ui.let_nav_latitude.setText(str(dict_msg["latitude"]))
  39. self.ui.let_nav_longitude.setText(str(dict_msg["longitude"]))
  40. self.ui.let_nav_heave.setText(str(dict_msg["heave"]))
  41. self.ui.let_nav_east_speed.setText(str(dict_msg["east_speed"]))
  42. self.ui.let_nav_north_speed.setText(str(dict_msg["north_speed"]))
  43. self.ui.let_nav_vertical_speed.setText(str(dict_msg["vertical_speed"]))
  44. self.ui.let_nav_attitude_angle1.setText(str(dict_msg["attitude_angle1"]))
  45. self.ui.let_nav_attitude_angle2.setText(str(dict_msg["attitude_angle2"]))
  46. self.ui.let_nav_attitude_angle3.setText(str(dict_msg["attitude_angle3"]))
  47. self.ui.let_nav_attitude_velocity1.setText(str(dict_msg["attitude_velocity1"]))
  48. self.ui.let_nav_attitude_velocity2.setText(str(dict_msg["attitude_velocity2"]))
  49. self.ui.let_nav_attitude_velocity3.setText(str(dict_msg["attitude_velocity3"]))
  50. self.ui.let_nav_fault_code.setText(dict_msg["fault_code"])
  51. self.ui.let_nav_imu_time.setText(dict_msg["imu_time"])
  52. self.ui.let_nav_reserved.setText(dict_msg["reserved"])
  53. self.ui.let_nav_response_flag.setText(dict_msg["response_flag"])
  54. self.ui.let_nav_check_sum.setText(dict_msg["check_sum"])
  55. if data_format == PackageParse.Type.RAW:
  56. # 解析数据
  57. data = package_parse.get_raw()
  58. # 写入当前时间,并保存到文件
  59. data["current_time"] = current_time
  60. save_csv('raw_data.csv', data)
  61. # 界面显示
  62. self.ui.let_raw_header.setText(dict_msg["header"])
  63. self.ui.let_raw__imu_time.setText(dict_msg["imu_time"])
  64. self.ui.let_raw_gyrox.setText(dict_msg["gyrox"])
  65. self.ui.let_raw_gyroy.setText(dict_msg["gyroy"])
  66. self.ui.let_raw_gyroz.setText(dict_msg["gyroz"])
  67. self.ui.let_raw_accex.setText(dict_msg["accex"])
  68. self.ui.let_raw_accey.setText(dict_msg["accey"])
  69. self.ui.let_raw_accez.setText(dict_msg["accez"])
  70. self.ui.let_raw_reserved.setText(dict_msg["reserved"])
  71. self.ui.let_raw_turntable_angle1.setText(dict_msg["turntable_angle1"])
  72. self.ui.let_raw_turntable_angle2.setText(dict_msg["turntable_angle2"])
  73. self.ui.let_raw_longitude.setText(dict_msg["longitude"])
  74. self.ui.let_raw_latitude.setText(dict_msg["latitude"])
  75. self.ui.let_raw_para4.setText(dict_msg["para4"])
  76. self.ui.let_raw_para2_5.setText(dict_msg["para2_5"])
  77. self.ui.let_raw_para3_6.setText(dict_msg["para3_6"])
  78. self.ui.let_raw_para7.setText(dict_msg["para7"])
  79. self.ui.let_raw_para8.setText(dict_msg["para8"])
  80. self.ui.let_raw_comdata_valid.setText(dict_msg["comdata_valid"])
  81. self.ui.let_raw_check_sum.setText(dict_msg["check_sum"])
  82. # 一次收到若干个数据包
  83. if data_format != PackageParse.Type.UNkNOWN and len(data) > data_format.value:
  84. data = data[data_format.value:]
  85. else:
  86. data = None

文件保存函数save_csv

  1. def save_csv(file_name, dict: {}):
  2. """
  3. 保存到csv文件
  4. :param file_name:文件名
  5. :param dict: 数据,字典格式
  6. :return:
  7. """
  8. file_exists = os.path.exists(file_name)
  9. # Save data to CSV file
  10. with open(file_name, 'a', newline='') as csvfile:
  11. writer = csv.writer(csvfile)
  12. # 如果文件不存在,则写入列名
  13. if not file_exists:
  14. writer.writerow(dict.keys())
  15. # 写入数据
  16. writer.writerow(dict.values())
3.4 报文解析

报文解析是由PackageParse类实现的,代码位于package_parse.py,在该类内部主要实现了一下功能;

  • 判断当前报文格式是导航结算还是原始信息,由get_data_format函数实现;
  • 实现导航结算报文的解析,由get_nav_sol函数实现;
  • 实现原始信息报文的解析,由get_raw函数实现;
3.4.1 get_data_format

这里判断报文格式的方法很简单;

  • 首先就是长度判定,如果是导航结算报文,长度至少为49个字符;如果是原始信息报文,长度至少是58个字符;
  • 接着判断报文前两个字节是否为0x5a 0X5a
  • 然后判定第58个字节是否为3~57个字节的累加和,如果满足条件就是原始信息报文;
  • 最后判定第49个字节是否为3~48个字节的累加和,如果满足条件就是导航结算报文;

具体代码如下:

  1. def validate_nal_sol(self):
  2. """
  3. 校验和
  4. 导航结算:第49个字节为3-48字节累加和
  5. """
  6. # 取出第3到第48字节
  7. selected_bytes = self.__byte_array[2:48]
  8. # 计算累加和并只保留低两位数字
  9. checksum = sum(selected_bytes) & 0xFF
  10. return checksum == self.__byte_array[48]
  11. def validate_raw(self):
  12. """
  13. 校验和
  14. 原始信息:第58个字节为3-57字节累加和
  15. """
  16. # 取出第3到第48字节
  17. selected_bytes = self.__byte_array[2:57]
  18. # 计算累加和并只保留低两位数字
  19. checksum = sum(selected_bytes) & 0xFF
  20. return checksum == self.__byte_array[57]
  21. def get_data_format(self):
  22. """
  23. 返回数据类型:在惯性装置的AXS31接口,里面有两路数据,一路称为导航解算,一路称为原始数
  24. :return: 0: 导航解算 1:原始信息 2:非法数据
  25. """
  26. # 原始信息报文
  27. if (len(self.__byte_array) >= 58 and self.__byte_array[0] == 0x5a and self.__byte_array[1] == 0x5a
  28. and self.validate_raw()):
  29. return PackageParse.Type.RAW
  30. # 导航解算的报文内容
  31. if (len(self.__byte_array) >= 49 and self.__byte_array[0] == 0x5a and self.__byte_array[1] == 0x5a
  32. and self.validate_nal_sol()):
  33. return PackageParse.Type.NAl_SOL
  34. return PackageParse.Type.UNkNOWN
3.4.2 get_nav_sol

如果报文格式是导航结算,那么调用该方法实现导航结算报文的解析,在函数内部根据字段单位、量纲对原始字节进行了转换;

  1. def translate(hex_array: [], unit=None):
  2. """
  3. 将字节数组转换为16进制字符串 [0x0a,0x04]-> 0x0a 0x04
  4. :param hex_array: 字节数组
  5. :param unit 量纲
  6. :return:
  7. """
  8. if unit is not None:
  9. # 将字节数组按照小端格式转换为数字
  10. num = int.from_bytes(hex_array, byteorder='little')
  11. return num / unit
  12. return ' '.join(f'0x{val:02X}' for val in hex_array)
  13. def get_nav_sol(self):
  14. """
  15. 获取导航解算数据
  16. :return:
  17. """
  18. if self.get_data_format() != PackageParse.Type.NAl_SOL:
  19. print("数据格式错误,非导航解算报文!")
  20. return None
  21. message_dict = {}
  22. # 解析报文头
  23. message_dict['header'] = translate(self.__byte_array[0:2])
  24. # 解析工作状态
  25. message_dict['work_state'] = translate(self.__byte_array[2:3])
  26. # 解析参数状态
  27. message_dict['param_state'] = translate(self.__byte_array[3:4])
  28. # 解析运行时间
  29. message_dict['run_time'] = translate(self.__byte_array[4:8], 20)
  30. # 解析纬度
  31. message_dict['latitude'] = translate(self.__byte_array[8:11], 93206.75556)
  32. # 解析经度
  33. message_dict['longitude'] = translate(self.__byte_array[11:14], 46603.37778)
  34. # 解析升沉
  35. message_dict['heave'] = translate(self.__byte_array[14:16], 100)
  36. # 解析东速
  37. message_dict['east_speed'] = translate(self.__byte_array[16:18], 100)
  38. # 解析北速
  39. message_dict['north_speed'] = translate(self.__byte_array[18:20], 100)
  40. # 解析垂速
  41. message_dict['vertical_speed'] = translate(self.__byte_array[20:22], 100)
  42. # 解析姿态角1
  43. message_dict['attitude_angle1'] = translate(self.__byte_array[22:25], 0.25 * 93206.75556)
  44. # 解析姿态角2
  45. message_dict['attitude_angle2'] = translate(self.__byte_array[25:28], 93206.75556)
  46. # 解析姿态角3
  47. message_dict['attitude_angle3'] = translate(self.__byte_array[28:31], 93206.75556)
  48. # 姿态角速率1
  49. message_dict['attitude_velocity1'] = translate(self.__byte_array[31:34], 93206.75556)
  50. # 姿态角速率2
  51. message_dict['attitude_velocity2'] = translate(self.__byte_array[34:37], 93206.75556)
  52. # 姿态角速率3
  53. message_dict['attitude_velocity3'] = translate(self.__byte_array[37:40], 93206.75556)
  54. # 故障码
  55. message_dict['fault_code'] = translate(self.__byte_array[40:41])
  56. # IMU时间
  57. message_dict['imu_time'] = translate(self.__byte_array[41:43])
  58. # 备用
  59. message_dict['reserved'] = translate(self.__byte_array[43:47])
  60. # 应答标志
  61. message_dict['response_flag'] = translate(self.__byte_array[47:48])
  62. # 校验和
  63. message_dict['check_sum'] = translate(self.__byte_array[48:49])
  64. return message_dict
3.4.3 get_raw

如果报文格式是原始信息,那么调用该方法实现原始信息报文的解析;

  1. def get_raw(self):
  2. """
  3. 获取原始信息报文
  4. :return:
  5. """
  6. if self.get_data_format() != PackageParse.Type.RAW:
  7. print("数据格式错误,非原始信息报文!")
  8. return None
  9. message_dict = {}
  10. # 解析报文头
  11. message_dict['header'] = translate(self.__byte_array[0:2])
  12. # IMUtime
  13. message_dict['imu_time'] = translate(self.__byte_array[2:6])
  14. # GYROX
  15. message_dict['gyrox'] = translate(self.__byte_array[6:10])
  16. # GYROY
  17. message_dict['gyroy'] = translate(self.__byte_array[10:14])
  18. # GYROZ
  19. message_dict['gyroz'] = translate(self.__byte_array[14:18])
  20. # ACCEX
  21. message_dict['accex'] = translate(self.__byte_array[18:22])
  22. # ACCEY
  23. message_dict['accey'] = translate(self.__byte_array[22:26])
  24. # ACCEZ
  25. message_dict['accez'] = translate(self.__byte_array[26:30])
  26. # 备用
  27. message_dict['reserved'] = translate(self.__byte_array[30:34])
  28. # 转台角1
  29. message_dict['turntable_angle1'] = translate(self.__byte_array[34:37])
  30. # 转台角2
  31. message_dict['turntable_angle2'] = translate(self.__byte_array[37:40])
  32. # GPS经度
  33. message_dict['longitude'] = translate(self.__byte_array[40:43])
  34. # GPS纬度
  35. message_dict['latitude'] = translate(self.__byte_array[43:46])
  36. # Para[4](电磁/牵引时为航向)
  37. message_dict['para4'] = translate(self.__byte_array[46:48])
  38. # Para[2]/para[5]
  39. message_dict['para2_5'] = translate(self.__byte_array[48:50])
  40. # Para[3]/para[6]
  41. message_dict['para3_6'] = translate(self.__byte_array[50:52])
  42. # Para[7]
  43. message_dict['para7'] = translate(self.__byte_array[52:54])
  44. # Para[8]
  45. message_dict['para8'] = translate(self.__byte_array[54:56])
  46. # comdatavalid
  47. message_dict['comdata_valid'] = translate(self.__byte_array[56:57])
  48. # 校验和
  49. message_dict['check_sum'] = translate(self.__byte_array[57:58])
  50. return message_dict
3.5 发送数据

当用户在串口数据接收区域的【文本输入框】录入内容,点击【发送】按钮时,会调用send_serial_data方法:

  1. def send_serial_data(self, data: str):
  2. """
  3. 发送数据
  4. :return:
  5. """
  6. if not self.serial_thread or not self.serial_thread.isRunning():
  7. QMessageBox.warning(self, "Warning", "请先打开串口!")
  8. return
  9. data = self.ui.let_send_data_viewer.text()
  10. if data != "":
  11. self.serial_thread.send_data(data)
  12. self.ui.let_send_data_viewer.clear()

函数内部首先校验串口是否已经打开,如果串口已经打开并且【文本输入框】输入了内容,将调用串口线程的send_data方法来进行数据发送。

3.6 串口线程

PyQt已经为我们提供了串口控件,控件名称为QtSerialPort,使用方法比较简单,主要是两个模块:QSerialPort, QSerialPortInfo,但是这个控件提供的能力有限。

这里我们使用另一个串口包pyserial来实现:

pip install pyserial -i https://pypi.tuna.tsinghua.edu.cn/simple

为了实现串口数据的读取和发送,我们创建了一个继承自QThreadSerialThread类;

  1. from PyQt5.QtCore import QThread,pyqtSignal
  2. import serial
  3. class SerialThread(QThread):
  4. """
  5. 创建一个继承自QThread的SerialThread类,实现串口数据的读取/发送
  6. """
  7. # 用于发送串口数据接收信号
  8. data_received = pyqtSignal(str)
  9. # 串口打开/接收异常
  10. serial_error = pyqtSignal(str)
  11. .......
3.6.1 初始化

在首次点击【打开串口】按钮时会创建SerialThread实例,即调用串口线程初始化方法;

  1. def __init__(self, port, baud_rate, data_bits, parity_bits, stop_bits, data_format):
  2. """
  3. 初始化
  4. :param port: 串口号
  5. :param baud_rate: 波特率
  6. :param data_bits: 数据位
  7. :param stop_bits: 停止位
  8. :param parity_bits: 奇偶校验位
  9. """
  10. super().__init__()
  11. self.port = port
  12. self.baud_rate = baud_rate
  13. self.data_bits = data_bits
  14. self.stop_bits = stop_bits
  15. self.parity_bits = parity_bits
  16. # 串口已经运行标志位
  17. self.running = False
  18. # 串口
  19. self.serial = None
  20. # 数据格式
  21. self.__date_format = data_format
  22. # 发送开启追加换行
  23. self.__auto_line = True
  24. @property
  25. def date_format(self):
  26. """
  27. #把一个getter方法变成属性
  28. :return:
  29. """
  30. return self.__date_format
  31. @date_format.setter
  32. def date_format(self, value):
  33. """
  34. # 负责把一个setter方法变成属性赋值
  35. :param value:
  36. :return:
  37. """
  38. if not isinstance(value, str):
  39. raise ValueError('date_format must be an str')
  40. if value not in ['hex', 'ascii']:
  41. raise ValueError('date_format must in [hex,ascii]')
  42. self.__date_format = value

在这段代码中,主要就是保存构造函数传递过来的参数,比如串口号、波特率等。

3.6.2 线程运行

串口线程初始化完成后,调用start方法,将会执行run函数;

  1. def run(self):
  2. """
  3. 打开串口
  4. :return:
  5. """
  6. # 串口已经运行
  7. if self.running:
  8. return
  9. try:
  10. # 建立一个串口
  11. with serial.Serial(port=self.port,
  12. baudrate=self.baud_rate,
  13. parity=self.parity_bits,
  14. bytesize=self.data_bits,
  15. stopbits=self.stop_bits,
  16. timeout=2) as self.serial:
  17. self.running = True
  18. while self.running:
  19. data = self.__read_data__()
  20. if data:
  21. self.data_received.emit(data)
  22. except Exception as e:
  23. print("打开串口时失败:", e)
  24. self.serial_error.emit("打开串口时失败!")

在函数内部我们实际上就是调用了pyserial提供的Serial类去实现串口的打开,并在while循环中,调用__read_data__获取串口发送过来的数据,如果接受到数据将串口数据通过信号与槽机制推送给主线程。

3.6.3 接受数据

串口数据的读取是由__read_data__函数完成的,在函数内部我们调用self.serial.readline()依次读取一行的数据,这里读取到的是字节数组,我们根据我们串口接收区域设置的数据格式来进行解析;

  1. def __read_data__(self):
  2. """
  3. 按行接收数据
  4. :return:
  5. """
  6. if self.serial is None or not self.serial.isOpen():
  7. return
  8. try:
  9. # 读取串口数据 例如:b'DDR V1.12 52218f4949 cym 23/07/0'
  10. byte_array = self.serial.readline()
  11. if len(byte_array) == 0:
  12. return None
  13. # ascii显示
  14. if self.__date_format == 'ascii':
  15. # 串口接收到的字符串为b'ABC',要转化成unicode字符串才能输出到窗口中去
  16. data_str = byte_array.decode('utf-8')
  17. else:
  18. # 串口接收到的字符串为b'ZZ\x02\x03Z',要转换成16进制字符串显示
  19. data_str = ' '.join(format(x, '02x') for x in byte_array)
  20. if self.__auto_line:
  21. data_str += '\r\n'
  22. return data_str
  23. except Exception as e:
  24. print("接收数据异常:", e)
  25. self.serial_error.emit("接收数据异常!")
3.6.4 发送数据

当用户在串口数据接收区域的【文本输入框】录入内容,点击【发送】按钮时,最终调用的就是串口线程的send_data方法;我们根据我们串口接收区域设置的数据格式处理将要发送的数据,然后调用self.serial.write实现串口数据的发送;

  1. def send_data(self, data: str):
  2. """
  3. 发送数据
  4. :return:
  5. """
  6. if not self.running:
  7. self.serial_error.emit("请先打开串口!")
  8. return
  9. # hex发送 比如:5a 5a 02 03 5a -> b'ZZ\x02\x03Z'
  10. if self.__date_format == 'hex':
  11. data_str = data.strip()
  12. send_list = []
  13. while data_str != '':
  14. try:
  15. num = int(data_str[0:2], 16)
  16. except ValueError:
  17. self.serial_error.emit('请输入十六进制数据,以空格分开!')
  18. return
  19. data_str = data_str[2:].strip()
  20. send_list.append(num)
  21. if self.__auto_line:
  22. send_list.append(0x0d)
  23. send_list.append(0x0a)
  24. byte_array = bytes(send_list)
  25. else:
  26. if self.__auto_line:
  27. data += '\r\n'
  28. # ascii发送 比如:'ABC' -> b'ABC'
  29. byte_array = data.encode('utf-8')
  30. try:
  31. self.serial.write(byte_array)
  32. except Exception as e:
  33. print("发送失败", e)
  34. self.serial_error.emit('发送失败!')

四、代码下载

大奥特曼打小怪兽 / python

参考文章

[1] PyQt5开发环境搭建和配置

[2] PyQt5 从零开始环境搭建

[3] PyQt5入门

[4] pythonpyserial模块接收串口助手发送HEX过来接收到非16进制乱码问题

[5] Python串口通信详解:从基础到高级

[6] Windows中使用PyQtPySerial实现串口数据读取

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

闽ICP备14008679号