【2022.6.5获奖项目】基于迪文屏的新冠核酸采样登记系统

dwinForumAdmin

【开源】基于迪文屏的新冠核酸采样登记系统

该方案是基于迪文屏开发的一款核酸采样登记的系统，使用了两块屏幕，一块用于登记、一块用于采样确认。开发目的是使用迪文屏当作输入窗口，替代原先手工填写表格，提高数据质量，减少群众等待时间等，在此向迪文及广大网友将所有的源码、素材开源如下：

一、前言

我是一名新冠肺炎防控一线的白衣战士，同时也是一名软硬件开发的工程师，在上次电子发烧友的迪文智慧屏的试用活动中，我与迪文屏相识，当时开发出的一个小作品得到了优秀作品奖。于是我产生了用迪文屏给我们单位采样室做一款核酸采样登记的系统，于是加班加点开始项目的研发，从项目开始到现在快40天，这40天来早上6点起来、下班后加班到晚上11点，写代码、调试，终于项目有了开发结果，经过两次实战，成功上线。得到单位领导、同事、以及采集群众的认可，效果非常好！

【材料】迪文屏10.1寸、7寸智慧串口屏各1块，笔记本电脑一台。

【软件】DGUS_V7.637，Python

主登记台

采样确认台

效果合照

二、设计过程

（一）架构设想

这次我在迪文官方申请到了两块屏，用于制作一个新冠核酸采样的登记系统。我的日常有一项工作就是核酸采样，以前都是用手工登记姓名、手机号码等。然后拿到登记表后还要人工转成电子表格才能完成送样。在工作中遇到有些人写的字不是很工整，难以辩认。我前段时间参与了迪文屏有评测，就想出了设计一个核酸登记系统的想法，这个想法得到迪文的认可，我申请了两块屏。今天屏已经到了，下面就记录一下我的开发记录。

【架构设想】PC端用python与两块迪文屏建立串口通讯。Python提供查询数据、接收数据、最后生成送样的excel文件。迪文屏负责与采样人以及被采样人的交互。

今天先晒晒我收到的屏：屏的包装非常好，专业水准呀，这里给迪文的点赞。

这个是10.1寸的型号：DMG10600C101-03WTC是一块电容触摸屏。

这是两块屏的全家福，还送了转接线、16G的转接卡、USB数据线。

最后，再次感谢迪文屏的支持。其如果你有好的创意，也可以跟他们申请哦。作品还可以发到迪文论坛，每个月都评选优秀作品，还有机会得大奖！

（二）UI人机界面设计

串口屏开发，先是要制作背景图片。今天花了好几个小时整好了部份图片：

2.1 输入手机号查找档案：

2.2 输入身份证查找界面：

2.3 如果没有在数据库找到信息，进行自主登记界面

2.4 身份证录入键盘

2.5 这个是查到到信息，确认的界面：

因为不懂PS，花了很大的心思的才弄好。大家给点建议呀，或者有好的素材借给我用用哈！

（三）连上迪文云

几天没有更新帖子了，一来是单位的任务繁重，忙了一天回来不想动了；二来是等屏的wifi模块回来。昨天焊了wifi模块跟其他的几个元件，焊0603的还好，焊0403的电容，搞了半天，电容没焊成，原因是人老眼花，用风枪吹一下就跑了，用焊台就看不见，头大。所以想买一套好的设备，不服老不行呀。但是wifi模块还是成功工作了，也成功的连上了迪文云，实现数据互动。今天在这里小结一下：

3.1 我申请的屏是支持wifi，但是出厂默认是不带模块的，我上迪文的官方淘宝准备买wifi模块，细心的小姐姐提前跟我说还需要其他几个元件才行，我于是联系迪云的业务员，买了3个模块（其实只要两个，我是留一个做预备），附带给我申请了三个配套的元件。这里给大家展示一下前后的对比哈：

焊接前：

焊接后：

我这焊工纯属入门级的呀。有点惨吧。。。

3.2 在迪文云上申请帐号，创建自己的帐号跟产品：

拿到生产商地址、设备分类地址、产品编号地址后改写22_config.bin

注意在bin中的地址要用变量地址乘2：即0x822 \0x0826 0x828

如果有需要可以去看看。

然后，配置wifiSSD\密码就可以啦，很简单滴：

展示一下，咱们看视频吧：

视频展示链接：http://bbs.eeworld.com.cn/thread-1200897-1-1.html

下一步，实现mqtt与后台数据的交换。

（四）查询数据并显示

今天要实现的功能是输入身份证号号码或者手机号码查询出资料，并显示在迪云屏上面：

实现思路是输入手机号码或者身份证号，点击查询，然后通过串口上传到PC，PC接收到命令后读取存储手机或身份证的地址上取回数据，读取excel的数据进行对比。

【python代码】

1. import time
   
2. 
   
3. import serial #导入模块
   
4. import threading
   
5. from win32com.client import Dispatch
   
6. import pythoncom
   
7. 
   
8. from excel import *
   
9. STRGLO="" #读取的数据
   
10. BOOL=True  #读取标志位
    
11. import win32com.client
    
12. cmd_read_phone = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x60, 0x13])
    
13. cmd_read_ID_number = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x20, 0x18])
    
14. cmd_write_to_enter_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x03])
    
15. send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
    
16. 
    
17. # 姓名数据组装
    
18. def creat_gbk_list(mydata, my_commad, H_address,L_address):
    
19.     # 发送的list
    
20.     send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
    
21.     send_len = 1 + 2 + 2 + len(mydata)*2
    
22.     send_list[2] = send_len
    
23.     # 添加 命令
    
24.     send_list[3] = my_commad
    
25.     send_list[4] = H_address
    
26.     send_list[5] = L_address
    
27.     mysend_list = bytes(send_list) + mydata.encode("gbk") + b'\xFF\xFF'
    
28.     print(mysend_list)
    
29.     DWritePort(ser, mysend_list)
    
30. 
    
31. def ReadData(ser):
    
32.     while BOOL:
    
33.         if ser.in_waiting:
    
34.             #STRGLO = ser.read(ser.in_waiting).decode("gbk")
    
35.             STRGLO = ser.read(ser.in_waiting)
    
36.             # print(STRGLO)
    
37.             # print("长度为：" + str(len(STRGLO)))
    
38.             if STRGLO[0] == 0x5a and STRGLO[1] == 0xa5:
    
39.                 #获取地址
    
40.                 addres = STRGLO[4] << 8 | STRGLO[5]
    
41.                 commd = STRGLO[3]
    
42.                 recv_len = STRGLO[2]
    
43.                 print("地址为：" + hex(addres) + "  长度为：" + str(recv_len) + " 命令为：" + hex(commd))
    
44.                 if recv_len == 0x06 and commd == 0x83:
    
45.                     if addres == 0x1080:
    
46.                         print("按身手机号码查询")
    
47.                         # 读取手机号码数据
    
48.                         DWritePort(ser, cmd_read_phone)
    
49.                     elif addres == 0x1090:
    
50.                         print("按身份证查询")
    
51.                         DWritePort(ser, cmd_read_ID_number)
    
52.                 elif commd == 0x83 and recv_len == 42 and addres == 0x1060:
    
53.                     # print("接收到手机号码")
    
54.                     recv_phone_len = STRGLO[6]
    
55.                     if(recv_phone_len == 0x13):
    
56.                         str_ph = STRGLO[7:18]
    
57.                         phone_code = str_ph.decode()
    
58.                         # 开始查找是否有手机号存在
    
59.                         pythoncom.CoInitialize()
    
60.                         try:
    
61.                             xls = easyExcel(r'H:\疫情登记项目\pythonpro\核酸数据库.xlsx')
    
62.                             xls_phone_code = str(int(xls.getCell('Sheet1', 2, 3)))
    
63.                             if xls_phone_code == phone_code:
    
64.                                 #获取身份证号码
    
65.                                 # 写性别
    
66.                                 my_xb = xls.getCell('Sheet1', 2, 5)
    
67.                                 creat_gbk_list(my_xb, 0x82, 0x11, 0x20)
    
68. 
    
69.                                 my_sh = str(int(xls.getCell('Sheet1', 2, 4)))
    
70.                                 creat_gbk_list(my_sh, 0x82, 0x10, 0x20)
    
71. 
    
72.                                 # 写职业
    
73.                                 my_job = xls.getCell('Sheet1', 2, 6)
    
74.                                 creat_gbk_list(my_job, 0x82, 0x11, 0x40)
    
75. 
    
76.                                 # 写姓名
    
77.                                 my_name = xls.getCell('Sheet1', 2, 2)
    
78.                                 creat_gbk_list(my_name, 0x82, 0x11, 0x60)
    
79.                                 # 写职业
    
80.                                 my_job = xls.getCell('Sheet1', 2, 6)
    
81.                                 creat_gbk_list(my_job, 0x82, 0x11, 0x40)
    
82.                                 # 页面转移到确认页面
    
83.                                 # 写姓名
    
84.                                 my_name = xls.getCell('Sheet1', 2, 2)
    
85.                                 creat_gbk_list(my_name, 0x82, 0x11, 0x60)
    
86.                                 DWritePort(ser, cmd_write_to_enter_page)
    
87.                             xls.close()
    
88.                         except Exception as e:
    
89.                             print("出错啦:" + str(e))
    
90.                             xls.close()
    
91.                         pythoncom.CoUninitialize()
    
92.                     else:
    
93.                         print("接收到的电话号码长度不对 长度为：" + str((recv_phone_len-8)))
    
94.                     # 查找手机号
    
95.                 elif commd == 0x83 and recv_len == 52 and addres == 0x1020:
    
96.                     print("接收到手机号码")
    
97.                     recv_ID_len = STRGLO[6]
    
98.                     if(recv_ID_len == 0x18):
    
99.                         str_ID = STRGLO[7:25]
    
100.                         str_ID = str_ID.decode()
     
101.                         # 开始查找是否有手机号存在
     
102.                         pythoncom.CoInitialize()
     
103.                         try:
     
104.                             xls = easyExcel(r'H:\疫情登记项目\pythonpro\核酸数据库.xlsx')
     
105.                             ID_code = str(int(xls.getCell('Sheet1', 2, 4)))
     
106.                             if ID_code == str_ID:
     
107.                                 # 写性别
     
108.                                 my_xb = xls.getCell('Sheet1', 2, 5)
     
109.                                 creat_gbk_list(my_xb, 0x82, 0x11, 0x20)
     
110.                                 #获取手机号码
     
111.                                 my_phone = str(int(xls.getCell('Sheet1', 2, 3)))
     
112.                                 creat_gbk_list(my_phone, 0x82, 0x10, 0x60)
     
113.                                 # 写职业
     
114.                                 my_job = xls.getCell('Sheet1', 2, 6)
     
115.                                 creat_gbk_list(my_job, 0x82, 0x11, 0x40)
     
116.                                 # 写职业
     
117.                                 my_job = xls.getCell('Sheet1', 2, 6)
     
118.                                 creat_gbk_list(my_job, 0x82, 0x11, 0x40)
     
119.                                 # 写姓名
     
120.                                 my_name = xls.getCell('Sheet1', 2, 2)
     
121.                                 creat_gbk_list(my_name, 0x82, 0x11, 0x60)
     
122.                                 # 页面转移到确认页面
     
123.                                 DWritePort(ser, cmd_write_to_enter_page)
     
124.                             xls.close()
     
125.                         except Exception as e:
     
126.                             print("出错啦:" + str(e))
     
127.                             xls.close()
     
128.                         pythoncom.CoUninitialize()
     
129.                     else:
     
130.                         print("接收到的电话号码长度不对 长度为：" + str((recv_phone_len-8)))
     
131.                     # 查找手机号码
     
132.             else:
     
133.                 print("非法数据")
     
134. 
     
135. #打开串口
     
136. # 端口，GNU / Linux上的/ dev / ttyUSB0 等 或 Windows上的 COM3 等
     
137. # 波特率，标准值之一：50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400,57600,115200
     
138. # 超时设置,None：永远等待操作，0为立即返回请求结果，其他值为等待超时时间(单位为秒）
     
139. def DOpenPort(portx,bps,timeout):
     
140.     ret=False
     
141.     try:
     
142.         # 打开串口，并得到串口对象
     
143.         ser = serial.Serial(portx, bps, timeout=timeout)
     
144.         #判断是否打开成功
     
145.         if(ser.is_open):
     
146.            ret=True
     
147.            threading.Thread(target=ReadData, args=(ser,)).start()
     
148.     except Exception as e:
     
149.         print("---异常---：", e)
     
150.     return ser, ret
     
151. 
     
152. #关闭串口
     
153. def DColsePort(ser):
     
154.     global BOOL
     
155.     BOOL=False
     
156.     ser.close()
     
157. 
     
158. #写数据
     
159. def DWritePort(ser,text):
     
160.     result = ser.write(text)  # 写数据
     
161.     return result
     
162. 
     
163. #读数据
     
164. def DReadPort():
     
165.     global STRGLO
     
166.     str=STRGLO
     
167.     STRGLO="" #清空当次读取
     
168.     return str
     
169. 
     
170. def reade_excel():
     
171.     global STRGLO,BOOL
     
172.     # 循环接收数据，此为死循环，可用线程实现
     
173.     try:
     
174.         xls = easyExcel(r'H:\疫情登记项目\pythonpro\核酸数据库.xlsx')
     
175.         xls_phone_code = str(int(xls.getCell('Sheet1', 2, 3)))
     
176.         xls.close()
     
177.         return xls_phone_code
     
178. 
     
179.     except Exception as e:
     
180.         print("出错啦:" + str(e))
     
181. 
     
182. if __name__=="__main__":
     
183.     ser,ret=DOpenPort("COM18",115200,None)
     
184.     if(ret==True):#判断串口是否成功打开
     
185.         print("打开串口成功1")
     
186.         reade_excel()
     
187.          # count=DWritePort(ser,"我是东小东，哈哈")
     
188.          # print("写入字节数：",count)
     
189.          #DReadPort() #读串口数据
     
190.          #DColsePort(ser)  #关闭串口

复制代码

excel文件：

查询界面：

新建档案界面

数据确认界面：

目前做可以查询档案，具体多数据库查询待后一步：

效果展示视频链接：http://bbs.eeworld.com.cn/thread-1201503-1-1.html

（五）数据保存

优化了python代码，实现了查数的查询，数据的保存：

1. import time
   
2. 
   
3. import serial  # 导入模块
   
4. import threading
   
5. from win32com.client import Dispatch
   
6. import pythoncom
   
7. 
   
8. from excel import *
   
9. 
   
10. STRGLO = ""  # 读取的数据
    
11. BOOL = True  # 读取标志位
    
12. import win32com.client
    
13. 
    
14. cmd_read_phone = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x60, 0x13])
    
15. cmd_read_ID_number = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x20, 0x18])
    
16. cmd_write_to_enter_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x10])
    
17. cmd_write_to_main_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x00])
    
18. send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
    
19. all_range = None
    
20. """
    
21. # 等待接收命令: wait_infor
    
22. # 查询状态     query_infor
    
23. # 确认信息：   confirmation_infor
    
24. # 保存信息：   save_infor
    
25. """
    
26. work_state = 'wait_enter'
    
27. 
    
28. dict_in_data = {
    
29.     'tube_number': '',
    
30.     'name': '',
    
31.     'phone': '',
    
32.     'ID': '',
    
33.     'sex': '',
    
34.     'company': '',
    
35.     'test_date': ''
    
36. }
    
37. 
    
38. # 姓名数据组装
    
39. def creat_gbk_list(mydata, my_commad, H_address, L_address):
    
40.     # 发送的list
    
41.     send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
    
42.     send_len = 1 + 2 + 2 + len(mydata) * 2
    
43.     send_list[2] = send_len
    
44.     # 添加 命令
    
45.     send_list[3] = my_commad
    
46.     send_list[4] = H_address
    
47.     send_list[5] = L_address
    
48.     mysend_list = bytes(send_list) + mydata.encode("gbk") + b'\xFF\xFF'
    
49.     print(mysend_list)
    
50.     DWritePort(ser, mysend_list)
    
51. 
    
52. def ReadData(ser):
    
53.     global all_range, work_state
    
54.     while BOOL:
    
55.         if ser.in_waiting:
    
56.             # STRGLO = ser.read(ser.in_waiting).decode("gbk")
    
57.             STRGLO = ser.read(ser.in_waiting)
    
58.             # print(STRGLO)
    
59.             # print("长度为：" + str(len(STRGLO)))
    
60.             if STRGLO[0] == 0x5a and STRGLO[1] == 0xa5:
    
61.                 # 获取地址
    
62.                 addres = STRGLO[4] << 8 | STRGLO[5]
    
63.                 commd = STRGLO[3]
    
64.                 recv_len = STRGLO[2]
    
65.                 print("地址为：" + hex(addres) + "  长度为：" + str(recv_len) + " 命令为：" + hex(commd))
    
66.                 if recv_len == 0x06 and commd == 0x83:
    
67.                     if addres == 0x1080:
    
68.                         print("按身手机号码查询")
    
69.                         # 读取手机号码数据
    
70.                         work_state = 'query_infor'
    
71.                         DWritePort(ser, cmd_read_phone)
    
72.                     elif addres == 0x1090:
    
73.                         print("按身份证查询")
    
74.                         work_state = 'query_infor'
    
75.                         DWritePort(ser, cmd_read_ID_number)
    
76.                     elif addres == 0x1200 and work_state == 'wait_enter':
    
77. 
    
78.                         # 增加时间，保存数据
    
79.                         pythoncom.CoInitialize()
    
80.                         save_test_file(my_data)
    
81.                         pythoncom.CoUninitialize()
    
82.                         print("保存数据")
    
83.                         work_state = 'query_infor'
    
84.                         my_data = dict_in_data
    
85.                         # 转到主页面
    
86.                         DWritePort(ser, cmd_write_to_main_page)
    
87.                 elif commd == 0x83 and recv_len == 42 and addres == 0x1060 and work_state == 'query_infor':
    
88.                     # print("接收到手机号码")
    
89.                     recv_phone_len = STRGLO[6]
    
90.                     if (recv_phone_len == 0x13):
    
91.                         str_ph = STRGLO[7:18]
    
92.                         phone_code = str_ph.decode()
    
93.                         # 开始查找是否有手机号存在
    
94.                         my_index = None
    
95.                         try:
    
96.                             for index, value in enumerate(all_range):
    
97.                                 xls_phone_code = str(int(value[2]))
    
98.                                 if phone_code == xls_phone_code:
    
99.                                     my_index = index
    
100.                                     break
     
101.                             if xls_phone_code == phone_code and (my_index is not None):
     
102.                                 my_data = dict_in_data
     
103.                                 my_data['name'] = all_range[my_index][1]
     
104.                                 my_data['sex'] = all_range[my_index][4]
     
105.                                 my_data['company'] = all_range[my_index][5]
     
106.                                 my_data['phone'] = xls_phone_code
     
107.                                 my_data['ID'] = all_range[my_index][3]
     
108.                                 creat_gbk_list(my_data['sex'], 0x82, 0x11, 0x20)
     
109.                                 creat_gbk_list(my_data['ID'], 0x82, 0x10, 0x20)
     
110.                                 creat_gbk_list(my_data['company'], 0x82, 0x11, 0x40)
     
111.                                 creat_gbk_list(my_data['name'], 0x82, 0x11, 0x60)
     
112.                                 creat_gbk_list(my_data['company'], 0x82, 0x11, 0x40)
     
113.                                 creat_gbk_list(my_data['name'], 0x82, 0x11, 0x60)
     
114.                                 # 页面转移到确认页面 为什么要写两遍，BUG——
     
115.                                 DWritePort(ser, cmd_write_to_enter_page)
     
116.                                 DWritePort(ser, cmd_write_to_enter_page)
     
117.                                 work_state = 'wait_enter'
     
118. 
     
119.                         except Exception as e:
     
120.                             print("出错啦:" + str(e))
     
121.                     else:
     
122.                         print("接收到的电话号码长度不对 长度为：" + str((recv_phone_len - 8)))
     
123.                     # 查找手机号
     
124.                 elif commd == 0x83 and recv_len == 52 and addres == 0x1020 and work_state == 'query_infor':
     
125.                     print("接收到身份证号码")
     
126.                     recv_ID_len = STRGLO[6]
     
127.                     if (recv_ID_len == 0x18):
     
128.                         str_ID = STRGLO[7:25]
     
129.                         str_ID = str_ID.decode()
     
130.                         # 开始查找是否有手机号存在
     
131.                         try:
     
132.                             my_index = None
     
133.                             for index, value in enumerate(all_range):
     
134.                                 xls_ID_code = str(int(value[3]))
     
135.                                 if str_ID == xls_ID_code:
     
136.                                     my_index = index
     
137.                                     break
     
138.                             if xls_ID_code == str_ID:
     
139.                                 # 写性别
     
140.                                 my_data = dict_in_data
     
141.                                 my_data['name'] = all_range[my_index][1]
     
142.                                 my_data['sex'] = all_range[my_index][4]
     
143.                                 my_data['company'] = all_range[my_index][5]
     
144.                                 my_data['phone'] = all_range[my_index][2]
     
145.                                 my_data['ID'] = xls_ID_code
     
146.                                 creat_gbk_list(my_data['sex'], 0x82, 0x11, 0x20)
     
147.                                 creat_gbk_list(my_data['phone'], 0x82, 0x10, 0x60)
     
148.                                 creat_gbk_list(my_data['company'], 0x82, 0x11, 0x40)
     
149.                                 creat_gbk_list(my_data['name'], 0x82, 0x11, 0x60)
     
150.                                 creat_gbk_list(my_data['company'], 0x82, 0x11, 0x40)
     
151.                                 creat_gbk_list(my_data['name'], 0x82, 0x11, 0x60)
     
152.                                 # 页面转移到确认页面 为什么要写两遍，BUG——
     
153.                                 DWritePort(ser, cmd_write_to_enter_page)
     
154.                                 DWritePort(ser, cmd_write_to_enter_page)
     
155.                                 work_state = 'wait_enter'
     
156.                         except Exception as e:
     
157.                             work_state = 'wait_enter'
     
158.                             print("出错啦:" + str(e))
     
159.                     else:
     
160.                         work_state = 'wait_enter'
     
161.                         print("接收到的电话号码长度不对 长度为：" + str((recv_phone_len - 8)))
     
162. 
     
163.             else:
     
164.                 print("非法数据")
     
165. 
     
166. # 打开串口
     
167. # 端口，GNU / Linux上的/ dev / ttyUSB0 等 或 Windows上的 COM3 等
     
168. # 波特率，标准值之一：50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400,57600,115200
     
169. # 超时设置,None：永远等待操作，0为立即返回请求结果，其他值为等待超时时间(单位为秒）
     
170. def DOpenPort(portx, bps, timeout):
     
171.     ret = False
     
172.     try:
     
173.         # 打开串口，并得到串口对象
     
174.         ser = serial.Serial(portx, bps, timeout=timeout)
     
175.         # 判断是否打开成功
     
176.         if (ser.is_open):
     
177.             ret = True
     
178.             threading.Thread(target=ReadData, args=(ser,)).start()
     
179.     except Exception as e:
     
180.         print("---异常---：", e)
     
181.     return ser, ret
     
182. 
     
183. # 关闭串口
     
184. def DColsePort(ser):
     
185.     global BOOL
     
186.     BOOL = False
     
187.     ser.close()
     
188. 
     
189. # 写数据
     
190. def DWritePort(ser, text):
     
191.     result = ser.write(text)  # 写数据
     
192.     return result
     
193. 
     
194. # 读数据
     
195. def DReadPort():
     
196.     global STRGLO
     
197.     str = STRGLO
     
198.     STRGLO = ""  # 清空当次读取
     
199.     return str
     
200. 
     
201. def reade_excel():
     
202.     global all_range
     
203.     # 循环接收数据，此为死循环，可用线程实现
     
204.     try:
     
205. 
     
206.         my_xls = easyExcel(r'H:\疫情登记项目\pythonpro\核酸数据库.xlsx')
     
207.         cols = my_xls.getCols('Sheet1')
     
208.         print("总列数为：" + str(cols))
     
209.         rows = my_xls.getRows('Sheet1') - 1
     
210.         print("总行数为：" + str(rows))
     
211.         # 获取全部数据到内存
     
212.         all_range = my_xls.getRange('Sheet1', 2, 1, rows - 1, cols)
     
213.         my_xls.close()
     
214.     except Exception as e:
     
215.         print("出错啦:" + str(e))
     
216. 
     
217. # 保存数据
     
218. def save_test_file(data):
     
219.     # 先检查是否有文件，没有新建一个，有测打开
     
220.     """
     
221.     :param data: dict_in_data = {
     
222.             'tube_number': '',
     
223.             'name': '',
     
224.             'phone': '',
     
225.             'ID': '',
     
226.             'sex': '',
     
227.             'company': '',
     
228.             'test_date': ''
     
229.         }
     
230.     :return: None
     
231.     """
     
232.     try:
     
233.         save_xls = easyExcel(r'H:\疫情登记项目\pythonpro\送检单.xlsx')
     
234.         max_row = save_xls.getRows('Sheet1')
     
235.         if max_row == 1:
     
236.             print("当天第一次写数据，初始化一下")
     
237.             # 试号管为 1
     
238.             data['tube_number'] = 1
     
239.             this_row = 1
     
240.         else:
     
241.             tube = save_xls.getCell('Sheet1', max_row, 2)
     
242.             this_row = save_xls.getCell('Sheet1', max_row, 2)
     
243.             if (this_row % 10) == 0:  # 10混1
     
244.                 tube = tube + 1
     
245.         # 表行号增加一行
     
246.         max_row = max_row + 1
     
247.         save_xls.setCell('Sheet1', max_row, 1, this_row)  # 增加序号
     
248.         save_xls.setCell('Sheet1', max_row, 2, data['tube_number'])  # 增加管号
     
249.         save_xls.setCell('Sheet1', max_row, 3, data['name'])  # 增加姓名
     
250.         save_xls.setCell('Sheet1', max_row, 4, data['sex'])  # 增加性别
     
251.         save_xls.setCell('Sheet1', max_row, 5, data['phone'])  # 增加电话号码
     
252.         save_xls.setCell('Sheet1', max_row, 6, data['ID'])  # 增加身份证号
     
253.         save_xls.setCell('Sheet1', max_row, 7, data['company'])  # 增加单位
     
254.         save_xls.setCell('Sheet1', max_row, 8, time.strftime("%Y-%m-%d", time.localtime()))  # 增加检测时间
     
255.         save_xls.save()
     
256.         save_xls.close()
     
257.     except Exception as e:
     
258.         save_xls.close()
     
259.         print("保存数据出错：" + str(e))
     
260. 
     
261. if __name__ == "__main__":
     
262.     ser, ret = DOpenPort("COM18", 115200, None)
     
263.     if (ret == True):  # 判断串口是否成功打开
     
264.         print("打开串口成功1")
     
265.         reade_excel()

复制代码

修改了数据确认页面：

基本功能实现50%了，展示一下：

查到数据的界面：

没有添加数据的表格：

成功录入数据以后的表格：

下一步，新建信息的录入，还有一些弹出菜单提示等

效果展示视频链接：http://bbs.eeworld.com.cn/thread-1201641-1-1.html

（六）增加采样工作台

上个星期去单位试用了，没有正式投入，这个星期再进行改进，增加了采样工作站。

采样站的主要功能就是被采样人登记好后，会在采样工作显示姓名，采样到第一个试管了，序号是多少，好核实信息等等。采样完后发送信号给服务器，服务清空数据，等待下一个采样人员进行登记。

服务器代码已经更新可以同时操作两个串口：

1. import os
   
2. import sys
   
3. 
   
4. import time
   
5. 
   
6. import serial  # 导入模块
   
7. import threading
   
8. from win32com.client import Dispatch
   
9. import pythoncom
   
10. 
    
11. from excel import *
    
12. 
    
13. STRGLO = ""  # 读取的数据
    
14. BOOL = True  # 读取标志位
    
15. ser10 = None
    
16. ser7 = None
    
17. import win32com.client
    
18. 
    
19. cmd_read_phone = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x60, 0x13])
    
20. cmd_read_ID_number = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x20, 0x18])
    
21. cmd_write_to_enter_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x10])
    
22. cmd_write_to_main_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x00])
    
23. cmd_write_to_waite_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x12])
    
24. send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
    
25. all_range = None
    
26. """
    
27. # 等待接收命令: wait_infor
    
28. # 查询状态     query_infor
    
29. # 确认信息：   confirmation_infor
    
30. # 保存信息：   save_infor
    
31. """
    
32. work_state = 'wait_enter'
    
33. path = sys.path[0]
    
34. dict_in_data = {
    
35.     'tube_number': '',
    
36.     'name': '',
    
37.     'phone': '',
    
38.     'ID': '',
    
39.     'sex': '',
    
40.     'company': '',
    
41.     'test_date': ''
    
42. }
    
43. save_dict = None
    
44. 
    
45. # 姓名数据组装
    
46. def creat_gbk_list(mydata, my_commad, H_address, L_address, ser):
    
47.     # 发送的list
    
48.     send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
    
49.     send_len = 1 + 2 + 2 + len(mydata) * 2
    
50.     send_list[2] = send_len
    
51.     # 添加 命令
    
52.     send_list[3] = my_commad
    
53.     send_list[4] = H_address
    
54.     send_list[5] = L_address
    
55.     mysend_list = bytes(send_list) + mydata.encode("gbk") + b'\xFF\xFF'
    
56.     print(mysend_list)
    
57.     DWritePort(ser, mysend_list)
    
58. # 清空数据
    
59. def clear_show_data():
    
60.     dict_in_data['name'] = ''
    
61.     dict_in_data['sex'] = ''
    
62.     dict_in_data['company'] = ''
    
63.     dict_in_data['phone'] = ''
    
64.     dict_in_data['phone'] = ''
    
65.     dict_in_data['ID'] = ''
    
66.     creat_gbk_list(dict_in_data['sex'], 0x82, 0x11, 0x20, ser10)
    
67.     creat_gbk_list(dict_in_data['phone'], 0x82, 0x10, 0x60, ser10)
    
68.     creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40, ser10)
    
69.     creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60, ser10)
    
70.     creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40, ser10)
    
71.     creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60, ser10)
    
72.     creat_gbk_list(dict_in_data['ID'], 0x82, 0x10, 0x20, ser10)
    
73.     # 清理护士站的
    
74.     creat_gbk_list(dict_in_data['name'], 0x82, 0x20, 0x20, ser7)
    
75. def ReadData(ser):
    
76.     global all_range, work_state, dict_in_data, ser10,ser7
    
77.     while BOOL:
    
78.         if ser.in_waiting:
    
79.             # STRGLO = ser.read(ser.in_waiting).decode("gbk")
    
80.             STRGLO = ser.read(ser.in_waiting)
    
81.             print(STRGLO)
    
82.             print(ser)
    
83.             print("长度为：" + str(len(STRGLO)))
    
84.             if STRGLO[0] == 0x5a and STRGLO[1] == 0xa5:
    
85.                 # 获取地址
    
86.                 addres = STRGLO[4] << 8 | STRGLO[5]
    
87.                 commd = STRGLO[3]
    
88.                 recv_len = STRGLO[2]
    
89.                 print("地址为：" + hex(addres) + "  长度为：" + str(recv_len) + " 命令为：" + hex(commd))
    
90.                 try:
    
91.                     if recv_len == 0x06 and commd == 0x83:
    
92.                         if addres == 0x1080:
    
93.                             print("按手机号码查询")
    
94.                             # 读取手机号码数据
    
95.                             print("手机号码为：" + dict_in_data['phone'])
    
96.                             my_index = None
    
97.                             try:
    
98.                                 for index, value in enumerate(all_range):
    
99.                                     xls_phone_code = str(int(value[2]))
    
100.                                     if phone_code == xls_phone_code:
     
101.                                         my_index = index
     
102.                                         break
     
103.                                 if xls_phone_code == phone_code and (my_index is not None):
     
104.                                     dict_in_data['name'] = all_range[my_index][1]
     
105.                                     dict_in_data['sex'] = all_range[my_index][4]
     
106.                                     dict_in_data['company'] = all_range[my_index][5]
     
107.                                     dict_in_data['ID'] = all_range[my_index][3]
     
108.                                     creat_gbk_list(dict_in_data['sex'], 0x82, 0x11, 0x20, ser10)
     
109.                                     creat_gbk_list(dict_in_data['ID'], 0x82, 0x10, 0x20,  ser10)
     
110.                                     creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40, ser10)
     
111.                                     creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60, ser10)
     
112.                                     creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40, ser10)
     
113.                                     creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60, ser10)
     
114.                                     # 页面转移到确认页面 为什么要写两遍，BUG——
     
115.                                     DWritePort(ser10, cmd_write_to_enter_page)
     
116.                                     DWritePort(ser10, cmd_write_to_enter_page)
     
117.                             except Exception as e:
     
118.                                 print("出错啦:" + str(e))
     
119.                         elif addres == 0x1090:
     
120.                             print("按身份证查询")
     
121.                             print("身份证号码为：" + dict_in_data['ID'])
     
122.                             try:
     
123.                                 my_index = None
     
124.                                 for index, value in enumerate(all_range):
     
125.                                     xls_ID_code = value[3]
     
126.                                     if dict_in_data['ID'] == xls_ID_code:
     
127.                                         my_index = index
     
128.                                         break
     
129.                                 dict_in_data['name'] = all_range[my_index][1]
     
130.                                 dict_in_data['sex'] = all_range[my_index][4]
     
131.                                 dict_in_data['company'] = all_range[my_index][5]
     
132.                                 dict_in_data['phone'] = str(int(all_range[my_index][2]))
     
133.                                 creat_gbk_list(dict_in_data['sex'], 0x82, 0x11, 0x20, ser10)
     
134.                                 creat_gbk_list(dict_in_data['phone'], 0x82, 0x10, 0x60, ser10)
     
135.                                 creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40, ser10)
     
136.                                 creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60, ser10)
     
137.                                 creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40, ser10)
     
138.                                 creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60, ser10)
     
139.                                 # 页面转移到确认页面 为什么要写两遍，BUG——
     
140.                                 # 页面转移到确认页面 为什么要写两遍，BUG——
     
141.                                 DWritePort(ser10, cmd_write_to_enter_page)
     
142.                                 DWritePort(ser10, cmd_write_to_enter_page)
     
143.                             except Exception as e:
     
144.                                 print("出错啦:" + str(e))
     
145.                             # DWritePort(ser, cmd_read_ID_number)
     
146.                         elif addres == 0x1200:
     
147.                             # 增加时间，保存数据
     
148.                             print("确认登记数据")
     
149.                             # 转到等待画面
     
150.                             DWritePort(ser10, cmd_write_to_waite_page)
     
151.                             DWritePort(ser10, cmd_write_to_waite_page)
     
152.                             pythoncom.CoInitialize()
     
153.                             tub, xh = save_test_file(dict_in_data)
     
154.                             pythoncom.CoUninitialize()
     
155.                             if tub is not None:
     
156.                                 creat_gbk_list(dict_in_data['name'], 0x82, 0x20, 0x20, ser7)
     
157.                                 creat_gbk_list(str(int(tub)), 0x82, 0x20, 0x40, ser7)
     
158.                                 creat_gbk_list(str(int(tub)), 0x82, 0x20, 0x40, ser7)
     
159.                                 creat_gbk_list(str(xh), 0x82, 0x20, 0x60, ser7)
     
160.                                 creat_gbk_list(str(xh), 0x82, 0x20, 0x60, ser7)
     
161.                             else:
     
162.                                 # 弹出失败
     
163.                                 pass
     
164.                             # 转到主页面
     
165.                         elif addres == 0x1210:
     
166.                             print('保存数据')
     
167.                             pythoncom.CoInitialize()
     
168.                             save_state = save_infor_file(dict_in_data)
     
169.                             reade_excel()
     
170.                             pythoncom.CoUninitialize()
     
171.                             DWritePort(ser, cmd_write_to_enter_page)
     
172.                         elif addres == 0x2004:
     
173.                             clear_show_data()
     
174.                             DWritePort(ser10, cmd_write_to_main_page)
     
175.                     elif commd == 0x83 and recv_len == 0x12 and addres == 0x1060:
     
176.                         print("接收到手机号码")
     
177.                         recv_phone_len = STRGLO[6]
     
178.                         if recv_phone_len == 0x07:
     
179.                             str_ph = STRGLO[7:18]
     
180.                             phone_code = str_ph.decode()
     
181.                             # 开始查找是否有手机号存在
     
182.                             dict_in_data['phone'] = phone_code
     
183.                         else:
     
184.                             print("接收到的电话号码长度不对 长度为：" + str((recv_phone_len - 8)))
     
185.                     elif commd == 0x83 and recv_len == 24 and addres == 0x1020:
     
186.                         print("接收到身份证号码")
     
187.                         recv_ID_len = STRGLO[6]
     
188.                         if recv_ID_len == 10:
     
189.                             dict_in_data['ID'] = STRGLO[7:25].decode()
     
190.                         else:
     
191.                             print("接收到的身份证长度不对 长度为：" + str((recv_ID_len - 8)))
     
192.                     elif commd == 0x83 and addres == 0x1160:
     
193.                         # 接收到姓名
     
194.                         recv_name_len = STRGLO[6] - 1
     
195.                         if 0 < recv_name_len < 5:
     
196.                             dict_in_data['name'] = (STRGLO[7:(7 + recv_name_len * 2)]).decode("gbk")
     
197.                         else:
     
198.                             print("姓名的长度不符合")
     
199.                         print(dict_in_data['name'])
     
200.                     elif commd == 0x83 and addres == 0x1140:
     
201.                         # 接收到姓名
     
202.                         recv_company_len = STRGLO[6] - 1
     
203.                         if 1 < recv_company_len < 6:
     
204.                             dict_in_data['company'] = (STRGLO[7:(7 + recv_company_len * 2)]).decode("gbk")
     
205.                         else:
     
206.                             print("单位的长度不符合")
     
207.                         print(dict_in_data['company'])
     
208.                     elif commd == 0x83 and addres == 0x1120:
     
209.                         # 接收到性别
     
210.                         recv_sex_len = STRGLO[6]
     
211.                         if recv_sex_len == 2:
     
212.                             str_sex = (STRGLO[7:9]).decode("gbk")
     
213.                             if str_sex == '男' or str_sex == '女':
     
214.                                 dict_in_data['sex'] = str_sex
     
215.                             else:
     
216.                                 print("性别必须为男或者女")
     
217.                                 dict_in_data['sex'] = ''
     
218.                         else:
     
219.                             print("姓名的长度不符合")
     
220.                         print(dict_in_data['sex'])
     
221.                 except Exception as e:
     
222.                     print(str(e))
     
223.             else:
     
224.                 print("非法数据")
     
225. 
     
226. 
     
227. # 打开串口
     
228. # 端口，GNU / Linux上的/ dev / ttyUSB0 等 或 Windows上的 COM3 等
     
229. # 波特率，标准值之一：50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400,57600,115200
     
230. # 超时设置,None：永远等待操作，0为立即返回请求结果，其他值为等待超时时间(单位为秒）
     
231. def DOpenPort(portx, bps, timeout):
     
232.     ret = False
     
233.     try:
     
234.         # 打开串口，并得到串口对象
     
235.         ser = serial.Serial(portx, bps, timeout=timeout)
     
236.         # 判断是否打开成功
     
237.         if (ser.is_open):
     
238.             ret = True
     
239.             threading.Thread(target=ReadData, args=(ser,)).start()
     
240.     except Exception as e:
     
241.         print("---异常---：", e)
     
242.     return ser, ret
     
243. 
     
244. # 关闭串口
     
245. def DColsePort(ser):
     
246.     global BOOL
     
247.     BOOL = False
     
248.     ser.close()
     
249. 
     
250. # 写数据
     
251. def DWritePort(ser, text):
     
252.     result = ser.write(text)  # 写数据
     
253.     return result
     
254. 
     
255. # 读数据
     
256. def DReadPort():
     
257.     global STRGLO
     
258.     str = STRGLO
     
259.     STRGLO = ""  # 清空当次读取
     
260.     return str
     
261. 
     
262. def reade_excel():
     
263.     global all_range
     
264.     # 循环接收数据，此为死循环，可用线程实现
     
265.     try:
     
266.         print(path)
     
267.         my_xls_path = path + '\核酸数据库.xlsx'
     
268.         my_xls = easyExcel(my_xls_path)
     
269.         cols = my_xls.getCols('Sheet1')
     
270.         print("总列数为：" + str(cols))
     
271.         rows = my_xls.getRows('Sheet1') + 1
     
272.         print("总行数为：" + str(rows))
     
273.         # 获取全部数据到内存
     
274.         all_range = my_xls.getRange('Sheet1', 2, 1, rows - 1, cols)
     
275.         my_xls.close()
     
276.     except Exception as e:
     
277.         print("出错啦:" + str(e))
     
278. 
     
279. # 保存基本信息数据
     
280. def save_infor_file(data):
     
281.     try:
     
282.         my_xls_path = path + '\核酸数据库.xlsx'
     
283.         save_infor_xls = easyExcel(my_xls_path)
     
284.         rows = save_infor_xls.getRows('Sheet1') + 1
     
285.         save_infor_xls.setCell('Sheet1', rows, 1, rows)  # 增加姓名
     
286.         save_infor_xls.setCell('Sheet1', rows, 2, data['name'])  # 增加姓名
     
287.         save_infor_xls.setCell('Sheet1', rows, 5, data['sex'])  # 增加性别
     
288.         save_infor_xls.setCell('Sheet1', rows, 3, data['phone'])  # 增加电话号码
     
289.         save_infor_xls.setCell('Sheet1', rows, 4, data['ID'])  # 增加身份证号
     
290.         save_infor_xls.setCell('Sheet1', rows, 6, data['company'])  # 增加单位
     
291.         save_infor_xls.save()
     
292.         save_infor_xls.close()
     
293.         return 1
     
294.     except Exception as e:
     
295.         print("保存基本信息出错：" + str(e))
     
296. 
     
297. # 保存采样信息数据
     
298. def save_test_file(data):
     
299.     # 先检查是否有文件，没有新建一个，有测打开
     
300.     """
     
301.     :param data: dict_in_data = {
     
302.             'tube_number': '',
     
303.             'name': '',
     
304.             'phone': '',
     
305.             'ID': '',
     
306.             'sex': '',
     
307.             'company': '',
     
308.             'test_date': ''
     
309.         }
     
310.     :return: None
     
311.     """
     
312.     try:
     
313.         my_save_xls_path = path + '\送检单.xlsx'
     
314.         save_xls = easyExcel(my_save_xls_path)
     
315.         max_row = save_xls.getRows('Sheet1')
     
316.         if max_row == 1:
     
317.             print("当天第一次写数据，初始化一下")
     
318.             # 试号管为 1
     
319.             data['tube_number'] = 1
     
320.             this_row = 1
     
321.             tube = 1
     
322.         else:
     
323.             tube = save_xls.getCell('Sheet1', max_row, 2)
     
324.             if ((max_row-1) % 10) == 0:  # 10混1
     
325.                 tube = tube + 1
     
326.         # 表行号增加一行
     
327.         max_row = max_row + 1
     
328.         save_xls.setCell('Sheet1', max_row, 1, max_row - 1)  # 增加序号
     
329.         save_xls.setCell('Sheet1', max_row, 2, tube)  # 增加管号
     
330.         save_xls.setCell('Sheet1', max_row, 3, data['name'])  # 增加姓名
     
331.         save_xls.setCell('Sheet1', max_row, 4, data['sex'])  # 增加性别
     
332.         save_xls.setCell('Sheet1', max_row, 5, data['phone'])  # 增加电话号码
     
333.         save_xls.setCell('Sheet1', max_row, 6, data['ID'])  # 增加身份证号
     
334.         save_xls.setCell('Sheet1', max_row, 7, data['company'])  # 增加单位
     
335.         save_xls.setCell('Sheet1', max_row, 8, time.strftime("%Y-%m-%d", time.localtime()))  # 增加检测时间
     
336.         save_xls.save()
     
337.         save_xls.close()
     
338.         save_xls = None
     
339.         print("保存数据成功")
     
340.         xh = max_row - 1   # 修正序号
     
341.         return tube, xh
     
342.     except Exception as e:
     
343.         save_xls.close()
     
344.         print("保存数据出错：" + str(e))
     
345.         return 0
     
346. 
     
347. if __name__ == "__main__":
     
348.     ser10, ret = DOpenPort("COM3", 115200, None)
     
349.     if ret:  # 判断串口是否成功打开
     
350.         reade_excel()
     
351.     ser7, ret1 = DOpenPort('COM23',115200,None)
     
352.     if ret1:
     
353.         print("打开串口2成功")

复制代码

【总结】现在还有一个缺点，就是读取EXCEL文件还很慢，差不多要2秒钟才能反应过来。下一步考虑是不是用数据库。还有一些细节要处理好。明天到单位再试用一下，看看效果。

效果展示视频链接：http://bbs.eeworld.com.cn/thread-1202802-1-1.html

（七）实战应用

上个星期四到单位实用，在保存数方面比较慢，究其原因是读写excel占用了太多的时间，这个星期一直在考虑如何解决这个问题，再加上最近的评测作品比较多，今年花了一天的时间对项目进行的修正，基本达到实用效果，现在跟大家汇报如下：

7.1 更新了界面，用Pyside设计界面：

7.2 代码：

1. import sys
   
2. import time
   
3. from PySide2.QtWidgets import *
   
4. from PySide2.QtCore import *
   
5. from PySide2.QtGui import *
   
6. from PySide2.QtSerialPort import *
   
7. from excel import *
   
8. from Test_main import Ui_MainWindow
   
9. from threading import Thread  # 导入thread
   
10. import qtmodern.styles
    
11. import qtmodern.windows
    
12. import pythoncom
    
13. from PySide2.QtCore import Signal,QObject  # 导入信号类
    
14. cmd_read_phone = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x60, 0x13])
    
15. cmd_read_ID_number = bytes([0x5a, 0xa5, 0x04, 0x83, 0x10, 0x20, 0x18])
    
16. cmd_write_to_enter_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x10])
    
17. cmd_write_to_main_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x00])
    
18. cmd_write_to_waite_page = bytes([0x5a, 0xa5, 0x07, 0x82, 0x00, 0x84, 0x5a, 0x01, 0x00, 0x12])
    
19. send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
    
20. all_range = None
    
21. phone_code = None
    
22. xls_ID_code = None
    
23. dict_in_data = {
    
24.     'tube_number': '',
    
25.     'name': '',
    
26.     'phone': '',
    
27.     'ID': '',
    
28.     'sex': '',
    
29.     'company': '',
    
30.     'test_date': ''
    
31. }
    
32. class MainWindow(Ui_MainWindow, QMainWindow):
    
33.     global all_range, my_xls, save_xls, phone_code
    
34.     def __init__(self):
    
35.         super(MainWindow, self).__init__()
    
36.         self.setupUi(self)
    
37.         self.setWindowTitle("核酸检测登记管理系统")
    
38.         self.comboBaudrate = 115200
    
39.         serial_list = QSerialPortInfo.availablePorts()
    
40.         for port in serial_list:
    
41.             self.comMainPort.addItem(port.portName())
    
42.             self.comSlavePort.addItem(port.portName())
    
43.         self.serialMain = QSerialPort()
    
44.         self.serialSlave = QSerialPort()
    
45.         self.bntOpen.clicked.connect(self.open_serial)
    
46.         self.serialMain.readyRead.connect(self.MainPortReadData)
    
47.         self.serialSlave.readyRead.connect(self.SlavePortReadData)
    
48.         self.bntExit.clicked.connect(self.exit_save_data)
    
49.         self.reade_excel()
    
50. 
    
51.     def reade_excel(self):
    
52.         # 循环接收数据，此为死循环，可用线程实现
    
53.         global my_xls, save_xls, all_range
    
54.         try:
    
55.             path = sys.path[0]
    
56.             print(path)
    
57.             my_xls_path = path + '\核酸数据库.xlsx'
    
58.             my_save_xls_path = path + '\送检单.xlsx'
    
59.             pythoncom.CoInitialize()
    
60.             my_xls = easyExcel(my_xls_path)
    
61.             cols = my_xls.getCols('Sheet1')
    
62.             print("总列数为：" + str(cols))
    
63.             rows = my_xls.getRows('Sheet1') + 1
    
64.             print("总行数为：" + str(rows))
    
65.             # 获取全部数据到内存
    
66.             all_range = my_xls.getRange('Sheet1', 2, 1, rows - 1, cols)
    
67.             save_xls = easyExcel(my_save_xls_path)
    
68.             pythoncom.CoUninitialize()
    
69.         except Exception as e:
    
70.             print("打开EXCEL出错啦:" + str(e))
    
71. 
    
72.     # 保存基本信息数据
    
73.     def save_infor_file(self,data):
    
74.         global my_xls
    
75.         try:
    
76.             rows = my_xls.getRows('Sheet1') + 1
    
77.             my_xls.setCell('Sheet1', rows, 1, rows)  # 增加姓名
    
78.             my_xls.setCell('Sheet1', rows, 2, data['name'])  # 增加姓名
    
79.             my_xls.setCell('Sheet1', rows, 5, data['sex'])  # 增加性别
    
80.             my_xls.setCell('Sheet1', rows, 3, data['phone'])  # 增加电话号码
    
81.             my_xls.setCell('Sheet1', rows, 4, data['ID'])  # 增加身份证号
    
82.             my_xls.setCell('Sheet1', rows, 6, data['company'])  # 增加单位
    
83.             my_xls.save()
    
84.             return 1
    
85.         except Exception as e:
    
86.             print("保存基本信息出错：" + str(e))
    
87.     # 保存采样信息数据
    
88.     def save_test_file(self,data):
    
89.         global save_xls
    
90.         # 先检查是否有文件，没有新建一个，有测打开
    
91.         try:
    
92.             max_row = save_xls.getRows('Sheet1')
    
93.             if max_row == 1:
    
94.                 print("当天第一次写数据，初始化一下")
    
95.                 # 试号管为 1
    
96.                 data['tube_number'] = 1
    
97.                 this_row = 1
    
98.                 tube = 1
    
99.             else:
    
100.                 tube = save_xls.getCell('Sheet1', max_row, 2)
     
101.                 if ((max_row - 1) % 10) == 0:  # 10混1
     
102.                     tube = tube + 1
     
103.             # 表行号增加一行
     
104.             max_row = max_row + 1
     
105.             save_xls.setCell('Sheet1', max_row, 1, max_row - 1)  # 增加序号
     
106.             save_xls.setCell('Sheet1', max_row, 2, tube)  # 增加管号
     
107.             save_xls.setCell('Sheet1', max_row, 3, data['name'])  # 增加姓名
     
108.             save_xls.setCell('Sheet1', max_row, 4, data['sex'])  # 增加性别
     
109.             save_xls.setCell('Sheet1', max_row, 5, data['phone'])  # 增加电话号码
     
110.             save_xls.setCell('Sheet1', max_row, 6, data['ID'])  # 增加身份证号
     
111.             save_xls.setCell('Sheet1', max_row, 7, data['company'])  # 增加单位
     
112.             save_xls.setCell('Sheet1', max_row, 8, time.strftime("%Y-%m-%d", time.localtime()))  # 增加检测时间
     
113.             save_xls.save()
     
114.             print("保存数据成功")
     
115.             xh = max_row - 1  # 修正序号
     
116.             return tube, xh
     
117.         except Exception as e:
     
118.             print("保存数据出错：" + str(e))
     
119.             return 0
     
120. 
     
121.     def open_serial(self):
     
122.         self.serialMain.setPortName(self.comMainPort.currentText())
     
123.         self.serialSlave.setPortName(self.comSlavePort.currentText())
     
124.         if self.bntOpen.text() == "打开":
     
125.             self.serialMain.open(QIODevice.ReadWrite)
     
126.             self.serialMain.setBaudRate(self.comboBaudrate)
     
127.             self.serialSlave.open(QIODevice.ReadWrite)
     
128.             self.serialSlave.setBaudRate(self.comboBaudrate)
     
129.             self.bntOpen.setText("关闭")
     
130.         else:
     
131.             self.serialMain.close()
     
132.             self.serialSlave.close()
     
133.             self.bntOpen.setText("打开")
     
134. 
     
135.     # 姓名数据组装
     
136.     def creat_gbk_list(self, mydata, my_commad, H_address, L_address):
     
137.         # 发送的list
     
138.         send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
     
139.         send_len = 1 + 2 + 2 + len(mydata) * 2
     
140.         send_list[2] = send_len
     
141.         # 添加 命令
     
142.         send_list[3] = my_commad
     
143.         send_list[4] = H_address
     
144.         send_list[5] = L_address
     
145.         mysend_list = bytes(send_list) + mydata.encode("gbk") + b'\xFF\xFF'
     
146.         print(mysend_list)
     
147.         self.MaiNwritePort(mysend_list)
     
148. 
     
149.     # 清空数据
     
150.     def clear_show_data(self):
     
151.         global dict_in_data
     
152.         dict_in_data['name'] = ''
     
153.         dict_in_data['sex'] = ''
     
154.         dict_in_data['company'] = ''
     
155.         dict_in_data['phone'] = ''
     
156.         dict_in_data['phone'] = ''
     
157.         dict_in_data['ID'] = ''
     
158.         self.creat_gbk_list(dict_in_data['sex'], 0x82, 0x11, 0x20)
     
159.         self.creat_gbk_list(dict_in_data['phone'], 0x82, 0x10, 0x60)
     
160.         self.creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40)
     
161.         # self.creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60)
     
162.         # self.creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40)
     
163.         self.creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60)
     
164.         self.creat_gbk_list(dict_in_data['ID'], 0x82, 0x10, 0x20)
     
165.     # 护士站姓名数据组装
     
166.     def creat_gbk_list_nu(self, mydata, my_commad, H_address, L_address):
     
167.         # 发送的list
     
168.         send_list = [0x5a, 0xa5, 0x00, 0x00, 0x00, 0x00]
     
169.         send_len = 1 + 2 + 2 + len(mydata) * 2
     
170.         send_list[2] = send_len
     
171.         # 添加 命令
     
172.         send_list[3] = my_commad
     
173.         send_list[4] = H_address
     
174.         send_list[5] = L_address
     
175.         mysend_list = bytes(send_list) + mydata.encode("gbk") + b'\xFF\xFF\xFF'
     
176.         print(mysend_list)
     
177.         self.SlaveWritePort(mysend_list)
     
178. 
     
179.     # 护士站写数据
     
180.     def SlaveWritePort(self, text):
     
181.         if self.serialSlave.isOpen():
     
182.             self.serialSlave.write(text)
     
183. 
     
184.     # 主屏写数据
     
185.     def MaiNwritePort(self, text):
     
186.         if self.serialMain.isOpen():
     
187.             self.serialMain.write(text)
     
188. 
     
189.     def MainPortReadData(self):
     
190.         global all_range, dict_in_data, phone_code, xls_ID_code
     
191.         ba = self.serialMain.readAll()
     
192.         main_port_recv = QTextCodec.codecForLocale().toUnicode(ba.data())
     
193.         self.textInfor.appendPlainText(main_port_recv)
     
194.         STRGLO = ba.data()
     
195.         try:
     
196.             if STRGLO[0] == 0x5a and STRGLO[1] == 0xa5:
     
197.                 # 获取地址
     
198.                 addres = STRGLO[4] << 8 | STRGLO[5]
     
199.                 commd = STRGLO[3]
     
200.                 recv_len = STRGLO[2]
     
201.                 print("地址为：" + hex(addres) + "  长度为：" + str(recv_len) + " 命令为：" + hex(commd))
     
202.                 try:
     
203.                     if recv_len == 0x06 and commd == 0x83:
     
204.                         if addres == 0x1080:
     
205.                             print("按手机号码查询")
     
206.                             # # 读取手机号码数据
     
207.                             # print("手机号码为：" + dict_in_data['phone'])
     
208.                             my_index = None
     
209.                             try:
     
210.                                 for index, value in enumerate(all_range):
     
211.                                     xls_phone_code = str(int(value[2]))
     
212.                                     if phone_code == xls_phone_code:
     
213.                                         my_index = index
     
214.                                         break
     
215.                                 if xls_phone_code == phone_code and (my_index is not None):
     
216.                                     print("查到数据")
     
217.                                     dict_in_data['name'] = all_range[my_index][1]
     
218.                                     dict_in_data['sex'] = all_range[my_index][4]
     
219.                                     dict_in_data['company'] = all_range[my_index][5]
     
220.                                     dict_in_data['ID'] = all_range[my_index][3]
     
221.                                     self.creat_gbk_list(dict_in_data['sex'], 0x82, 0x11, 0x20)
     
222.                                     self.creat_gbk_list(dict_in_data['ID'], 0x82, 0x10, 0x20)
     
223.                                     self.creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40)
     
224.                                     self.creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60)
     
225.                                     # self.creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40)
     
226.                                     self.creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60)
     
227.                                     # 页面转移到确认页面 为什么要写两遍，BUG——
     
228.                                     self.MaiNwritePort(cmd_write_to_enter_page)
     
229.                                     self.MaiNwritePort(cmd_write_to_enter_page)
     
230.                                 else:
     
231.                                     print("没有查到信息")
     
232.                             except Exception as e:
     
233.                                 print("按手机号码查询出错啦:" + str(e))
     
234.                         elif addres == 0x1090:
     
235.                             # print("按身份证查询")
     
236.                             # print("身份证号码为：" + dict_in_data['ID'])
     
237.                             try:
     
238.                                 my_index = None
     
239.                                 for index, value in enumerate(all_range):
     
240.                                     xls_ID_code = value[3]
     
241.                                     if dict_in_data['ID'] == xls_ID_code:
     
242.                                         my_index = index
     
243.                                         break
     
244.                                 dict_in_data['name'] = all_range[my_index][1]
     
245.                                 dict_in_data['sex'] = all_range[my_index][4]
     
246.                                 dict_in_data['company'] = all_range[my_index][5]
     
247.                                 dict_in_data['phone'] = str(int(all_range[my_index][2]))
     
248.                                 self.creat_gbk_list(dict_in_data['sex'], 0x82, 0x11, 0x20)
     
249.                                 self.creat_gbk_list(dict_in_data['phone'], 0x82, 0x10, 0x60)
     
250.                                 self.creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40)
     
251.                                 self.creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60)
     
252.                                 self.creat_gbk_list(dict_in_data['company'], 0x82, 0x11, 0x40)
     
253.                                 self.creat_gbk_list(dict_in_data['name'], 0x82, 0x11, 0x60)
     
254.                                 # 页面转移到确认页面 为什么要写两遍，BUG——
     
255.                                 # 页面转移到确认页面 为什么要写两遍，BUG——
     
256. 
     
257.                                 self.MaiNwritePort(cmd_write_to_enter_page)
     
258.                                 self.MaiNwritePort(cmd_write_to_enter_page)
     
259.                             except Exception as e:
     
260.                                 print("出错啦:" + str(e))
     
261.                             # DWritePort(ser, cmd_read_ID_number)
     
262.                         elif addres == 0x1200:
     
263.                             # 增加时间，保存数据
     
264.                             print("确认登记数据")
     
265.                             tub, xh = self.save_test_file(dict_in_data)
     
266.                             if tub is not None:
     
267.                                 self.MaiNwritePort(cmd_write_to_waite_page)
     
268.                                 self.creat_gbk_list_nu(dict_in_data['name'], 0x82, 0x20, 0x20)
     
269.                                 self.creat_gbk_list_nu(str(int(tub)), 0x82, 0x20, 0x40)
     
270.                                 self.creat_gbk_list_nu(str(int(tub)), 0x82, 0x20, 0x40)
     
271.                                 self.creat_gbk_list_nu(str(xh), 0x82, 0x20, 0x60)
     
272.                                 self.creat_gbk_list_nu(str(xh), 0x82, 0x20, 0x60)
     
273.                             else:
     
274.                                 # 弹出失败
     
275.                                 pass
     
276.                             # 转到主页面
     
277.                         elif addres == 0x1210:
     
278.                             print('保存数据')
     
279.                             if dict_in_data['name'] == "" or \
     
280.                                     dict_in_data['sex'] == "" or\
     
281.                                 dict_in_data['company'] == "" or\
     
282.                                 dict_in_data['phone'] == "" or\
     
283.                                 dict_in_data['ID'] == "":
     
284.                                 print("data ERROR")
     
285.                             else:
     
286.                                 save_state = self.save_infor_file(dict_in_data)
     
287.                                 cols = my_xls.getCols('Sheet1')
     
288.                                 print("总列数为：" + str(cols))
     
289.                                 rows = my_xls.getRows('Sheet1') + 1
     
290.                                 print("总行数为：" + str(rows))
     
291.                                 # 获取全部数据到内存
     
292.                                 all_range = my_xls.getRange('Sheet1', 2, 1, rows - 1, cols)
     
293.                                 self.MaiNwritePort(cmd_write_to_enter_page)
     
294.                     elif commd == 0x83 and recv_len == 0x12 and addres == 0x1060:
     
295.                         print("接收到手机号码")
     
296.                         recv_phone_len = STRGLO[6]
     
297.                         if recv_phone_len == 0x07:
     
298.                             str_ph = STRGLO[7:18]
     
299.                             phone_code = str_ph.decode()
     
300.                             # 开始查找是否有手机号存在
     
301.                             dict_in_data['phone'] = phone_code
     
302.                         else:
     
303.                             print("接收到的电话号码长度不对 长度为：" + str((recv_phone_len - 8)))
     
304.                     elif commd == 0x83 and recv_len == 24 and addres == 0x1020:
     
305.                         print("接收到身份证号码")
     
306.                         recv_ID_len = STRGLO[6]
     
307.                         if recv_ID_len == 10:
     
308.                             dict_in_data['ID'] = STRGLO[7:25].decode()
     
309.                         else:
     
310.                             print("接收到的身份证长度不对 长度为：" + str((recv_ID_len - 8)))
     
311.                     elif commd == 0x83 and addres == 0x1160:
     
312.                         # 接收到姓名
     
313.                         recv_name_len = STRGLO[6] - 1
     
314.                         if 0 < recv_name_len < 5:
     
315.                             dict_in_data['name'] = (STRGLO[7:(7 + recv_name_len * 2)]).decode("gbk")
     
316.                         else:
     
317.                             print("姓名的长度不符合")
     
318.                         print(dict_in_data['name'])
     
319.                     elif commd == 0x83 and addres == 0x1140:
     
320.                         # 接收到姓名
     
321.                         recv_company_len = STRGLO[6] - 1
     
322.                         if 1 < recv_company_len < 6:
     
323.                             dict_in_data['company'] = (STRGLO[7:(7 + recv_company_len * 2)]).decode("gbk")
     
324.                         else:
     
325.                             print("单位的长度不符合")
     
326.                         print(dict_in_data['company'])
     
327.                     elif commd == 0x83 and addres == 0x1120:
     
328.                         # 接收到性别
     
329.                         recv_sex_len = STRGLO[6]
     
330.                         if recv_sex_len == 2:
     
331.                             str_sex = (STRGLO[7:9]).decode("gbk")
     
332.                             if str_sex == '男' or str_sex == '女':
     
333.                                 dict_in_data['sex'] = str_sex
     
334.                             else:
     
335.                                 print("性别必须为男或者女")
     
336.                                 dict_in_data['sex'] = ''
     
337.                         else:
     
338.                             print("姓名的长度不符合")
     
339.                         print(dict_in_data['sex'])
     
340.                 except Exception as e:
     
341.                     print("解释命令出错" + str(e))
     
342.             else:
     
343.                 print("命令不认识")
     
344.         except Exception as e:
     
345.             print(str(e))
     
346.     def SlavePortReadData(self):
     
347.         ba = self.serialSlave.readAll()
     
348.         main_port_recv = QTextCodec.codecForLocale().toUnicode(ba.data())
     
349.         self.textInfor.appendPlainText(main_port_recv)
     
350.         STRGLO = ba.data()
     
351.         try:
     
352.             if STRGLO[0] == 0x5a and STRGLO[1] == 0xa5:
     
353.                 # 获取地址
     
354.                 addres = STRGLO[4] << 8 | STRGLO[5]
     
355.                 commd = STRGLO[3]
     
356.                 recv_len = STRGLO[2]
     
357.                 print("地址为：" + hex(addres) + "  长度为：" + str(recv_len) + " 命令为：" + hex(commd))
     
358.                 if addres == 0x2004:
     
359.                     self.clear_show_data()
     
360.                     self.MaiNwritePort(cmd_write_to_main_page)
     
361.                     self.creat_gbk_list_nu('', 0x82, 0x11, 0x60)
     
362. 
     
363.         except Exception as e:
     
364.             print("接收护士站错据出错：" + str(e))
     
365. 
     
366.     def save_exec_data(self):
     
367.         try:
     
368.             my_xls.save()
     
369.             save_xls.save()
     
370.         except Exception as e:
     
371.             print("保存数据出错：" + str(e))
     
372. 
     
373.     def exit_save_data(self):
     
374.         try:
     
375.             my_xls.save()
     
376.             my_xls.close()
     
377.             save_xls.save()
     
378.             save_xls.close()
     
379.             sys.exit(1)
     
380.         except Exception as e:
     
381.             print("保存数据出错:" + str(e))
     
382. 
     
383. if __name__ == "__main__":
     
384.     app = QApplication(sys.argv)
     
385. 
     
386.     qtmodern.styles.dark(app)
     
387. 
     
388.     app.setWindowIcon(QIcon("../monkey.ico"))
     
389. 
     
390.     mwin = MainWindow()
     
391. 
     
392.     win = qtmodern.windows.ModernWindow(mwin)
     
393. 
     
394.     win.show()
     
395. 
     
396.     sys.exit(app.exec_())

复制代码

7.3 应用的视频：

效果展示视频链接：http://bbs.eeworld.com.cn/thread-1204656-1-1.html

总的来说基本功能实现了，还有一些需要进一步完善的地方

备注说明：如需源码，请参考此链接：http://inforum.dwin.com.cn:20080/forum.php?mod=viewthread&tid=6070&_dsign=7cf6c848