serial_port.py 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909
  1. import serial
  2. import serial.tools.list_ports
  3. import threading
  4. import time
  5. import logging
  6. import platform
  7. import glob
  8. import queue
  9. from dataclasses import dataclass
  10. # 配置日志
  11. logging.basicConfig(
  12. level=logging.INFO,
  13. format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
  14. )
  15. logger = logging.getLogger('serial_port')
  16. @dataclass
  17. class SerialConfig:
  18. """串口配置数据类"""
  19. port: str
  20. baudrate: int = 115200
  21. bytesize: int = serial.EIGHTBITS
  22. parity: str = serial.PARITY_NONE
  23. stopbits: int = serial.STOPBITS_ONE
  24. timeout: float = 1.0
  25. xonxoff: bool = False
  26. rtscts: bool = False
  27. dsrdtr: bool = False
  28. class Rs485Direction:
  29. """RS485 收发方向 GPIO 控制(可选)。
  30. 仅当配置了 SERIAL_RS485_DIR_GPIO(如 "gpiochip0:25")时启用。
  31. 典型用途:板载 TTL 转 RS485 模块为"自动方向"且切换太慢时,会把从机
  32. 立刻返回的应答压掉(表现为:发送正常、rx 计数完全不动)。把模块的
  33. DE/RE 引到空闲 GPIO 上,由本类在发送前拉高、发送完成后拉低即可解决。
  34. 任何异常都会让本类自动降级为"不控制方向",绝不影响串口主流程。
  35. """
  36. def __init__(self, spec: str, pre_delay: float = 0.001, post_delay: float = 0.001):
  37. self.spec = (spec or '').strip()
  38. self.pre_delay = max(0.0, float(pre_delay or 0))
  39. self.post_delay = max(0.0, float(post_delay or 0))
  40. self.chip_name = ''
  41. self.line_offset = -1
  42. self.active_low = False # True 表示低电平为"发送态"
  43. self.ready = False
  44. self._line = None
  45. self._chip = None
  46. def _parse(self) -> bool:
  47. parts = [p.strip() for p in self.spec.split(':') if p.strip()]
  48. if len(parts) < 2:
  49. logger.warning(f"RS485 方向 GPIO 配置无效(应为 gpiochip0:25[:low]): {self.spec!r}")
  50. return False
  51. self.chip_name = parts[0]
  52. try:
  53. self.line_offset = int(parts[1], 0)
  54. except ValueError:
  55. logger.warning(f"RS485 方向 GPIO line 号无效: {parts[1]!r}")
  56. return False
  57. self.active_low = len(parts) >= 3 and parts[2].lower() in ('low', 'active_low', '0')
  58. return True
  59. def open(self) -> bool:
  60. """打开并申请 GPIO 输出线,成功后 ready=True"""
  61. if not self.spec:
  62. return False
  63. if not self._parse():
  64. return False
  65. try:
  66. import gpiod # 延迟导入:没装 gpiod 的机器不受影响
  67. except Exception as e:
  68. logger.warning(f"RS485 方向 GPIO 不可用(gpiod 未安装): {e}")
  69. return False
  70. try:
  71. chip_cls = getattr(gpiod, 'Chip', None) or getattr(gpiod, 'chip', None)
  72. if chip_cls is None:
  73. logger.warning("RS485 方向 GPIO 不可用:当前 gpiod 版本不支持 Chip/chip API")
  74. return False
  75. self._chip = chip_cls(self.chip_name)
  76. self._line = self._chip.get_line(self.line_offset)
  77. if not self._request_output(gpiod):
  78. return False
  79. # 上电默认处于接收态
  80. self._set(False)
  81. self.ready = True
  82. logger.info(
  83. f"RS485 方向控制已启用: {self.spec}({'低' if self.active_low else '高'}电平为发送态,"
  84. f"前置 {self.pre_delay*1000:.1f}ms / 后置 {self.post_delay*1000:.1f}ms)"
  85. )
  86. return True
  87. except Exception as e:
  88. logger.warning(f"RS485 方向 GPIO 打开失败,将不控制方向: {e}")
  89. self._line = None
  90. self._chip = None
  91. self.ready = False
  92. return False
  93. def _request_output(self, gpiod) -> bool:
  94. """兼容 gpiod 1.4/1.5/2.x 的申请输出写法"""
  95. attempts = []
  96. # 1.5.x:line_request 对象
  97. if hasattr(gpiod, 'line_request'):
  98. try:
  99. req = gpiod.line_request()
  100. req.consumer = 'dzxj_dtu_rs485_dir'
  101. req.request_type = getattr(gpiod.line_request, 'DIRECTION_OUTPUT',
  102. getattr(gpiod, 'LINE_REQ_DIR_OUT', 2))
  103. attempts.append(lambda: self._line.request(req))
  104. except Exception:
  105. pass
  106. # 1.4.x:名称参数
  107. attempts.append(lambda: self._line.request(
  108. consumer='dzxj_dtu_rs485_dir',
  109. type=getattr(gpiod, 'LINE_REQ_DIR_OUT', 2)))
  110. # 2.x:位置参数
  111. attempts.append(lambda: self._line.request('dzxj_dtu_rs485_dir', 2, 0))
  112. last_err = None
  113. for fn in attempts:
  114. try:
  115. fn()
  116. return True
  117. except Exception as e:
  118. last_err = e
  119. logger.warning(f"RS485 方向 GPIO 申请失败: {last_err}")
  120. return False
  121. def _set(self, is_tx: bool):
  122. if self._line is None:
  123. return
  124. value = (0 if is_tx else 1) if self.active_low else (1 if is_tx else 0)
  125. try:
  126. self._line.set_value(value)
  127. except Exception as e:
  128. logger.warning(f"RS485 方向 GPIO 置位失败,停止方向控制: {e}")
  129. self.ready = False
  130. def to_tx(self):
  131. """切换到发送态"""
  132. if not self.ready:
  133. return
  134. self._set(True)
  135. if self.pre_delay:
  136. time.sleep(self.pre_delay)
  137. def to_rx(self):
  138. """切回接收态(必须在最后一位真正发完之后调用)"""
  139. if not self.ready:
  140. return
  141. if self.post_delay:
  142. time.sleep(self.post_delay)
  143. self._set(False)
  144. def close(self):
  145. self.ready = False
  146. try:
  147. if self._line is not None:
  148. self._line.release()
  149. except Exception:
  150. pass
  151. try:
  152. if self._chip is not None and hasattr(self._chip, 'close'):
  153. self._chip.close()
  154. except Exception:
  155. pass
  156. self._line = None
  157. self._chip = None
  158. class SerialPort:
  159. """串口通信类,提供串口连接、读写和状态管理功能"""
  160. def __init__(self):
  161. self.ser = None
  162. self.is_connected = False
  163. self.lock = threading.RLock() # 使用可重入锁
  164. self.read_thread = None
  165. self.stop_event = threading.Event()
  166. self.data_callback = None
  167. self.send_callback = None
  168. self.status_callback = None
  169. self.error_callback = None
  170. self.current_config = None
  171. self._rs485_dir = None # RS485 方向控制(可选)
  172. self.reconnect_attempts = 0
  173. self.max_reconnect_attempts = 3
  174. self.raw_response_buffer = []
  175. self._reconnect_monitor_thread = None
  176. # 同步接收模式:send_and_wait 活动时暂停后台读取线程,防止响应被读线程抢走
  177. self._sync_receive_active = False
  178. self._sync_lock = threading.Lock()
  179. # 串口发送队列:所有发送指令统一排队,按固定节拍(发送起点间隔)逐个发送,
  180. # 既避免总线冲突,也保证相邻指令(如 0x80 保活 与 0x03 读卡)不会背靠背贴得太近。
  181. self._cmd_queue = queue.Queue()
  182. self._cmd_min_interval = 0.20 # 相邻指令「发送起点」最小间隔(秒),默认值
  183. try:
  184. import config as _app_config
  185. self._cmd_min_interval = float(getattr(_app_config, 'SERIAL_CMD_INTERVAL', 0.20))
  186. except Exception:
  187. pass
  188. self._next_cmd_time = 0.0 # 下一条指令允许开始发送的时刻(发送起点锚点)
  189. self._cmd_worker_thread = threading.Thread(target=self._cmd_worker, daemon=True)
  190. self._cmd_worker_thread.start()
  191. # 启动后台重连监控线程,确保断线后可持续自动恢复
  192. self._start_reconnect_monitor()
  193. def _cmd_worker(self):
  194. """串口发送队列工作线程:统一按「发送起点」固定节拍逐个发送指令"""
  195. logger.info("启动串口发送队列工作线程")
  196. while True:
  197. try:
  198. item = self._cmd_queue.get()
  199. if item is None:
  200. break
  201. # 以「开始发送的时刻」为锚保证等间隔:把本条命令排到上一条起拍之后
  202. # 满一个节拍。若上一条命令本身耗时超过一个节拍(如读卡等满超时),
  203. # 则不补觉、立刻发(半双工总线上不可能重叠,也不回溯过去的时间)。
  204. now = time.time()
  205. if now < self._next_cmd_time:
  206. time.sleep(self._next_cmd_time - now)
  207. cmd_type = item.get('type')
  208. # 记录本条「发送起点」,下一条以此为基准排满一个节拍
  209. send_start = time.time()
  210. self._next_cmd_time = send_start + self._cmd_min_interval
  211. try:
  212. if cmd_type == 'send_and_wait':
  213. result = self._do_send_and_wait(
  214. item['data'],
  215. timeout=item.get('timeout', 2.0),
  216. min_response_bytes=item.get('min_response_bytes', 1)
  217. )
  218. elif cmd_type == 'wait_response':
  219. result = self._do_wait_response(
  220. timeout=item.get('timeout', 2.0),
  221. min_response_bytes=item.get('min_response_bytes', 1)
  222. )
  223. elif cmd_type == 'send_raw':
  224. result = self._do_send_raw(item['data'])
  225. elif cmd_type == 'send_data':
  226. result = self._do_send_data(item['data'], item.get('encoding', 'utf-8'))
  227. else:
  228. result = {'error': f'未知命令类型: {cmd_type}'}
  229. except Exception as e:
  230. logger.error(f"执行串口命令失败: {e}")
  231. result = {'error': str(e)}
  232. callback = item.get('callback')
  233. if callback:
  234. callback(result)
  235. except Exception as e:
  236. logger.error(f"串口发送队列工作线程异常: {e}")
  237. logger.info("串口发送队列工作线程结束")
  238. def _init_rs485_dir(self):
  239. """按配置初始化 RS485 方向控制 GPIO(未配置则不启用)"""
  240. self._close_rs485_dir()
  241. try:
  242. import config as app_config
  243. spec = getattr(app_config, 'SERIAL_RS485_DIR_GPIO', '') or ''
  244. pre = getattr(app_config, 'SERIAL_RS485_DIR_PRE_DELAY', 0.001)
  245. post = getattr(app_config, 'SERIAL_RS485_DIR_POST_DELAY', 0.001)
  246. except Exception:
  247. return
  248. if not spec:
  249. return
  250. direction = Rs485Direction(spec, pre_delay=pre, post_delay=post)
  251. if direction.open():
  252. self._rs485_dir = direction
  253. else:
  254. self._rs485_dir = None
  255. def _close_rs485_dir(self):
  256. if self._rs485_dir is not None:
  257. try:
  258. self._rs485_dir.close()
  259. except Exception:
  260. pass
  261. self._rs485_dir = None
  262. def _rs485_write(self, data: bytes) -> int:
  263. """写串口并 flush(tcdrain)。
  264. 配置了方向 GPIO 时:发送前切到发送态,最后一位发完后立刻切回接收态,
  265. 避免板载 485 模块方向切换滞后把从机应答压掉。
  266. """
  267. direction = self._rs485_dir
  268. if direction is not None and direction.ready:
  269. direction.to_tx()
  270. try:
  271. sent = self.ser.write(data)
  272. self.ser.flush()
  273. finally:
  274. direction.to_rx()
  275. return sent
  276. sent = self.ser.write(data)
  277. self.ser.flush()
  278. return sent
  279. def _do_send_raw(self, data: bytes):
  280. """实际执行 send_raw(在队列工作线程中调用)"""
  281. try:
  282. with self.lock:
  283. if not self.is_connected or not self.ser or not self.ser.is_open:
  284. return False, "serial port not connected"
  285. bytes_sent = self._rs485_write(data)
  286. if self.send_callback and data:
  287. self.send_callback(data.hex())
  288. return True, "send ok"
  289. except Exception as e:
  290. error_msg = f"send raw failed: {str(e)}"
  291. logger.error(error_msg)
  292. if self.error_callback:
  293. self.error_callback(error_msg)
  294. return False, error_msg
  295. def _do_send_data(self, data, encoding='utf-8'):
  296. """实际执行 send_data(在队列工作线程中调用)"""
  297. try:
  298. with self.lock:
  299. if not self.is_connected or not self.ser or not self.ser.is_open:
  300. return False, "串口未连接"
  301. # 确保数据以换行符结束
  302. if isinstance(data, str):
  303. if not data.endswith('\n'):
  304. data += '\n'
  305. bytes_data = data.encode(encoding)
  306. elif isinstance(data, bytes):
  307. if not data.endswith(b'\n'):
  308. bytes_data = data + b'\n'
  309. else:
  310. bytes_data = data
  311. else:
  312. raise TypeError("数据必须是字符串或字节类型")
  313. bytes_sent = self._rs485_write(bytes_data)
  314. logger.debug(f"发送数据到串口: {bytes_data.hex()[:50]}... (共{bytes_sent}字节)")
  315. return True, "发送成功"
  316. except Exception as e:
  317. error_msg = f"发送失败: {str(e)}"
  318. logger.error(error_msg)
  319. if self.error_callback:
  320. self.error_callback(error_msg)
  321. return False, error_msg
  322. def _emit_received_data(self, data: bytes):
  323. """把接收到的原始数据推送给 data_callback(与后台读线程行为一致)"""
  324. if not data or not self.data_callback:
  325. return
  326. hex_data = data.hex()
  327. self.data_callback(hex_data)
  328. try:
  329. decoded = data.decode('utf-8').strip()
  330. if decoded:
  331. self.data_callback(decoded)
  332. except Exception:
  333. pass
  334. def _do_send_and_wait(self, data: bytes, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  335. """实际执行 send_and_wait(在队列工作线程中调用)"""
  336. # 进入同步接收模式,暂停后台读取线程
  337. with self._sync_lock:
  338. self._sync_receive_active = True
  339. try:
  340. # 阶段 1:发送数据并清空缓冲区
  341. with self.lock:
  342. if not self.ser or not self.ser.is_open:
  343. return b''
  344. self.raw_response_buffer.clear()
  345. self.ser.reset_input_buffer()
  346. self._rs485_write(data)
  347. # 485 半双工:等最后字节发完并给收发器一点切换方向的时间
  348. time.sleep(0.03)
  349. if self.send_callback and data:
  350. self.send_callback(data.hex())
  351. # 阶段 2:等待响应。由于后台读线程已暂停,这里独占串口读取。
  352. response = b''
  353. start = time.time()
  354. while time.time() - start < timeout:
  355. # 先清掉缓冲区内可能残留的报文(正常情况下 sync 模式下读线程不会写入)
  356. with self.lock:
  357. while self.raw_response_buffer:
  358. try:
  359. response += bytes.fromhex(self.raw_response_buffer.pop(0))
  360. except Exception:
  361. pass
  362. try:
  363. if self.ser and self.ser.is_open and self.ser.in_waiting > 0:
  364. response += self.ser.read(self.ser.in_waiting)
  365. except Exception:
  366. pass
  367. if len(response) >= min_response_bytes:
  368. # 再等一小段时间收集可能的后续数据
  369. time.sleep(0.05)
  370. with self.lock:
  371. while self.raw_response_buffer:
  372. try:
  373. response += bytes.fromhex(self.raw_response_buffer.pop(0))
  374. except Exception:
  375. pass
  376. try:
  377. if self.ser and self.ser.is_open and self.ser.in_waiting > 0:
  378. response += self.ser.read(self.ser.in_waiting)
  379. except Exception:
  380. pass
  381. self._emit_received_data(response)
  382. return response
  383. time.sleep(0.01)
  384. self._emit_received_data(response)
  385. return response
  386. finally:
  387. # 退出同步接收模式,恢复后台读取线程
  388. with self._sync_lock:
  389. self._sync_receive_active = False
  390. def _do_wait_response(self, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  391. """实际执行 wait_response(在队列工作线程中调用)。
  392. 与 _do_send_and_wait 的区别:
  393. - 不发送任何数据(不 write),因此不触发 send_callback,不会在前端产生空 JSON;
  394. - 不清空接收缓冲(不 reset_input_buffer),避免把从机已回的应答冲掉。
  395. 用于发送完指令(send_raw)后专门等待从机应答。
  396. 收到 min_response_bytes 字节后,继续等到总线空闲(100ms 无新数据)再返回,
  397. 以便把回显与真实应答一并收齐后再交由调用方解析。
  398. """
  399. # 进入同步接收模式,暂停后台读取线程,独占串口读取
  400. with self._sync_lock:
  401. self._sync_receive_active = True
  402. try:
  403. response = b''
  404. start = time.time()
  405. last_data_time = start
  406. while time.time() - start < timeout:
  407. # 从后台读线程缓冲 + 串口硬件缓冲两处收集
  408. chunk = b''
  409. with self.lock:
  410. while self.raw_response_buffer:
  411. try:
  412. chunk += bytes.fromhex(self.raw_response_buffer.pop(0))
  413. except Exception:
  414. pass
  415. try:
  416. if self.ser and self.ser.is_open and self.ser.in_waiting > 0:
  417. chunk += self.ser.read(self.ser.in_waiting)
  418. except Exception:
  419. pass
  420. if chunk:
  421. response += chunk
  422. last_data_time = time.time()
  423. # 收够最小长度后,等总线空闲再返回,避免回显导致提前返回而漏掉真实应答
  424. if len(response) >= min_response_bytes:
  425. if time.time() - last_data_time > 0.1:
  426. self._emit_received_data(response)
  427. return response
  428. time.sleep(0.01)
  429. self._emit_received_data(response)
  430. return response
  431. finally:
  432. with self._sync_lock:
  433. self._sync_receive_active = False
  434. def list_ports(self):
  435. """列出系统中可用的串口"""
  436. ports = []
  437. try:
  438. # 首先尝试使用serial.tools.list_ports
  439. try:
  440. detected_ports = [port.device for port in serial.tools.list_ports.comports()]
  441. ports.extend(detected_ports)
  442. except Exception as e:
  443. logger.warning(f"使用serial.tools.list_ports失败: {str(e)}")
  444. # 根据不同平台进行补充查找
  445. system = platform.system()
  446. if system == 'Windows':
  447. try:
  448. import winreg
  449. # 在Windows系统中读取注册表
  450. key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
  451. r'HARDWARE\DEVICEMAP\SERIALCOMM')
  452. i = 0
  453. while True:
  454. try:
  455. port, value, _ = winreg.EnumValue(key, i)
  456. if value not in ports:
  457. ports.append(value)
  458. i += 1
  459. except OSError:
  460. break
  461. except Exception as e:
  462. logger.error(f"读取Windows串口注册表失败: {str(e)}")
  463. elif system == 'Darwin': # macOS
  464. # 使用glob查找/dev/tty.*设备
  465. darwin_ports = glob.glob('/dev/tty.*')
  466. # 过滤掉不需要的端口
  467. for port in darwin_ports:
  468. if not ('Bluetooth' in port or 'debug' in port or 'com.apple' in port) and port not in ports:
  469. ports.append(port)
  470. elif system == 'Linux':
  471. # 使用glob查找Linux系统中的串口
  472. linux_ports = glob.glob('/dev/ttyS*') + glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')
  473. for port in linux_ports:
  474. if port not in ports:
  475. ports.append(port)
  476. logger.info(f"找到 {len(ports)} 个可用串口: {ports}")
  477. except Exception as e:
  478. logger.error(f"列出串口时出错: {str(e)}")
  479. return sorted(ports) # 排序返回
  480. def connect(self, port, baudrate=9600, timeout=1, **kwargs):
  481. """连接到串口"""
  482. try:
  483. # 构建配置
  484. config = SerialConfig(
  485. port=port,
  486. baudrate=baudrate,
  487. timeout=timeout,
  488. **kwargs
  489. )
  490. with self.lock:
  491. if self.is_connected:
  492. # RLock 允许递归,避免死锁
  493. self.disconnect()
  494. # serial.Serial() 可能阻塞(端口被占用等),不要在持有锁的情况下调用,
  495. # 否则 disconnect() 会长时间等待锁而无法响应。
  496. logger.info(f"尝试连接串口: {port}, 波特率: {baudrate}")
  497. ser = serial.Serial(
  498. port=config.port,
  499. baudrate=config.baudrate,
  500. bytesize=config.bytesize,
  501. parity=config.parity,
  502. stopbits=config.stopbits,
  503. timeout=config.timeout,
  504. xonxoff=config.xonxoff,
  505. rtscts=config.rtscts,
  506. dsrdtr=config.dsrdtr
  507. )
  508. # 检查连接是否成功
  509. if not ser.is_open:
  510. ser.close()
  511. raise Exception("串口打开失败")
  512. with self.lock:
  513. self.ser = ser
  514. self.is_connected = True
  515. self.stop_event.clear()
  516. self.current_config = config
  517. self.reconnect_attempts = 0
  518. # RS485 方向控制 GPIO(可选,未配置则跳过)
  519. self._init_rs485_dir()
  520. # 启动读取线程
  521. self.read_thread = threading.Thread(target=self._read_loop, daemon=True)
  522. self.read_thread.start()
  523. if self.status_callback:
  524. self.status_callback(True)
  525. logger.info(f"已连接到 {port},波特率 {baudrate}")
  526. return True, f"已连接到 {port},波特率 {baudrate}"
  527. except Exception as e:
  528. error_msg = f"连接失败: {str(e)}"
  529. logger.error(error_msg)
  530. if self.status_callback:
  531. self.status_callback(False)
  532. if self.error_callback:
  533. self.error_callback(error_msg)
  534. return False, error_msg
  535. def disconnect(self):
  536. """断开串口连接"""
  537. try:
  538. logger.info("断开串口连接")
  539. # 释放 RS485 方向控制 GPIO
  540. self._close_rs485_dir()
  541. # 阶段 0:清空发送队列中待执行的指令,避免断开后再发数据
  542. try:
  543. while not self._cmd_queue.empty():
  544. self._cmd_queue.get_nowait()
  545. except Exception:
  546. pass
  547. # 阶段 1:通知读取线程退出,不要在持有锁的情况下 join,
  548. # 否则读取线程异常时调用 _close_on_error 会拿不到锁而死锁。
  549. with self.lock:
  550. self.stop_event.set()
  551. if self.read_thread and self.read_thread.is_alive():
  552. self.read_thread.join(timeout=2.0)
  553. if self.read_thread.is_alive():
  554. logger.warning("读取线程未能正常终止")
  555. # 阶段 2:关闭串口并清理状态
  556. with self.lock:
  557. if self.ser and self.ser.is_open:
  558. try:
  559. self.ser.close()
  560. except Exception as e:
  561. logger.error(f"关闭串口时出错: {str(e)}")
  562. self.ser = None
  563. self.is_connected = False
  564. self.current_config = None
  565. if self.status_callback:
  566. self.status_callback(False)
  567. return True, "已断开连接"
  568. except Exception as e:
  569. error_msg = f"断开连接失败: {str(e)}"
  570. logger.error(error_msg)
  571. if self.error_callback:
  572. self.error_callback(error_msg)
  573. return False, error_msg
  574. def _read_loop(self):
  575. """读取串口数据的循环"""
  576. logger.info("启动串口读取线程")
  577. while not self.stop_event.is_set():
  578. try:
  579. # send_and_wait 正在同步接收时,后台读线程让出总线,
  580. # 避免读线程把响应抢走导致同步调用超时。
  581. with self._sync_lock:
  582. sync_active = self._sync_receive_active
  583. if sync_active:
  584. time.sleep(0.001)
  585. continue
  586. if self.ser and self.ser.is_open:
  587. # 使用in_waiting提高效率
  588. if self.ser.in_waiting > 0:
  589. data = self.ser.read(self.ser.in_waiting)
  590. # 默认将原始数据以十六进制存入缓冲区
  591. hex_data = data.hex()
  592. with self.lock:
  593. self.raw_response_buffer.append(hex_data)
  594. if self.data_callback:
  595. self.data_callback(hex_data)
  596. # 如果能解码为文本,也通知回调
  597. try:
  598. decoded_data = data.decode('utf-8').strip()
  599. if decoded_data and self.data_callback:
  600. self.data_callback(decoded_data)
  601. except:
  602. pass
  603. time.sleep(0.001)
  604. except Exception as e:
  605. error_msg = f"读取串口数据错误: {str(e)}"
  606. logger.error(error_msg)
  607. if self.error_callback:
  608. self.error_callback(error_msg)
  609. # 读取线程只负责关闭当前连接并通知,重连由独立监控线程负责,
  610. # 避免在读取线程内调用 connect() 造成自连接/自 join 的问题
  611. self._close_on_error()
  612. break
  613. # 线程结束时清理资源
  614. logger.info("串口读取线程结束")
  615. def _close_on_error(self):
  616. """读取异常时关闭串口并触发状态回调,但不直接重连"""
  617. self._close_rs485_dir()
  618. with self.lock:
  619. if self.ser and self.ser.is_open:
  620. try:
  621. self.ser.close()
  622. except Exception:
  623. pass
  624. self.ser = None
  625. self.is_connected = False
  626. if self.status_callback:
  627. try:
  628. self.status_callback(False)
  629. except Exception:
  630. pass
  631. logger.warning("串口因读取错误已关闭,等待重连监控线程恢复")
  632. def _start_reconnect_monitor(self):
  633. """启动独立后台线程,在串口断开时持续尝试重连"""
  634. if getattr(self, '_reconnect_monitor_thread', None) and self._reconnect_monitor_thread.is_alive():
  635. return
  636. self._reconnect_monitor_thread = threading.Thread(target=self._reconnect_monitor, daemon=True)
  637. self._reconnect_monitor_thread.start()
  638. def _reconnect_monitor(self):
  639. """后台重连监控:只要保存过配置就无限重试,成功则重置计数"""
  640. logger.info("启动串口重连监控线程")
  641. while True:
  642. try:
  643. with self.lock:
  644. connected = self.is_connected
  645. config = self.current_config
  646. if not connected and config is not None:
  647. self.reconnect_attempts += 1
  648. attempt = self.reconnect_attempts
  649. logger.warning(f"重连监控尝试连接串口... (第{attempt}次)")
  650. success, msg = self.connect(
  651. port=config.port,
  652. baudrate=config.baudrate,
  653. timeout=config.timeout,
  654. bytesize=config.bytesize,
  655. parity=config.parity,
  656. stopbits=config.stopbits,
  657. xonxoff=config.xonxoff,
  658. rtscts=config.rtscts,
  659. dsrdtr=config.dsrdtr
  660. )
  661. if not success:
  662. # 指数退避,最长 30 秒
  663. delay = min(30, 2 + attempt * 2)
  664. logger.warning(f"重连失败: {msg},{delay}秒后再次尝试")
  665. time.sleep(delay)
  666. else:
  667. logger.info("串口重连成功")
  668. else:
  669. # 已连接或未保存配置时,重置失败计数并降低检查频率
  670. if connected:
  671. self.reconnect_attempts = 0
  672. time.sleep(3)
  673. except Exception as e:
  674. logger.error(f"重连监控线程异常: {e}")
  675. time.sleep(5)
  676. def send_data(self, data, encoding='utf-8'):
  677. """发送数据到串口(入队,由队列工作线程统一发送)"""
  678. result_container = {}
  679. event = threading.Event()
  680. def callback(result):
  681. result_container['result'] = result
  682. event.set()
  683. self._cmd_queue.put({
  684. 'type': 'send_data',
  685. 'data': data,
  686. 'encoding': encoding,
  687. 'callback': callback
  688. })
  689. # 最多等待 5 秒,避免队列卡死导致调用方永远阻塞
  690. if not event.wait(5):
  691. return False, "串口发送队列超时"
  692. return result_container.get('result', (False, "未知错误"))
  693. def set_data_callback(self, callback):
  694. """设置数据接收回调函数"""
  695. self.data_callback = callback
  696. def set_send_callback(self, callback):
  697. """设置数据发送回调函数"""
  698. self.send_callback = callback
  699. def set_status_callback(self, callback):
  700. """设置状态变化回调函数"""
  701. self.status_callback = callback
  702. def set_error_callback(self, callback):
  703. """设置错误回调函数"""
  704. self.error_callback = callback
  705. def get_status(self):
  706. """获取当前连接状态"""
  707. with self.lock:
  708. return {
  709. 'connected': self.is_connected,
  710. 'config': self.current_config,
  711. 'has_error': self.reconnect_attempts > 0
  712. }
  713. def _should_reconnect(self):
  714. """判断是否应该尝试重连"""
  715. self.reconnect_attempts += 1
  716. return self.reconnect_attempts <= self.max_reconnect_attempts
  717. def send_raw(self, data: bytes):
  718. """send raw binary data without adding newline(入队,由队列工作线程统一发送)"""
  719. result_container = {}
  720. event = threading.Event()
  721. def callback(result):
  722. result_container['result'] = result
  723. event.set()
  724. self._cmd_queue.put({
  725. 'type': 'send_raw',
  726. 'data': data,
  727. 'callback': callback
  728. })
  729. # 最多等待 5 秒,避免队列卡死导致调用方永远阻塞
  730. if not event.wait(5):
  731. return False, "串口发送队列超时"
  732. return result_container.get('result', (False, "未知错误"))
  733. def flush_input(self):
  734. """清空输入缓冲区"""
  735. try:
  736. with self.lock:
  737. if self.ser and self.ser.is_open:
  738. self.ser.reset_input_buffer()
  739. return True, "输入缓冲区已清空"
  740. return False, "串口未连接"
  741. except Exception as e:
  742. error_msg = f"清空缓冲区失败: {str(e)}"
  743. logger.error(error_msg)
  744. return False, error_msg
  745. def flush_output(self):
  746. """清空输出缓冲区"""
  747. try:
  748. with self.lock:
  749. if self.ser and self.ser.is_open:
  750. self.ser.reset_output_buffer()
  751. return True, "输出缓冲区已清空"
  752. return False, "串口未连接"
  753. except Exception as e:
  754. error_msg = f"清空缓冲区失败: {str(e)}"
  755. logger.error(error_msg)
  756. return False, error_msg
  757. def send_and_wait(self, data: bytes, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  758. """sync send and wait(入队,由队列工作线程统一发送并等待响应)"""
  759. result_container = {}
  760. event = threading.Event()
  761. def callback(result):
  762. result_container['result'] = result
  763. event.set()
  764. self._cmd_queue.put({
  765. 'type': 'send_and_wait',
  766. 'data': data,
  767. 'timeout': timeout,
  768. 'min_response_bytes': min_response_bytes,
  769. 'callback': callback
  770. })
  771. # 最多等待 timeout + 队列处理余量
  772. wait_time = timeout + 5
  773. if not event.wait(wait_time):
  774. return b''
  775. return result_container.get('result', b'')
  776. def wait_response(self, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  777. """只读取从机应答,不发送任何数据(入队,由队列工作线程统一执行)。
  778. 与 send_and_wait 的区别:不 write 数据、不触发 send_callback、不清空接收缓冲。
  779. 用于发送完指令(send_raw)后等待从机应答,避免发空数据污染前端显示、
  780. 避免清缓冲冲掉已到达的应答。
  781. """
  782. result_container = {}
  783. event = threading.Event()
  784. def callback(result):
  785. result_container['result'] = result
  786. event.set()
  787. self._cmd_queue.put({
  788. 'type': 'wait_response',
  789. 'timeout': timeout,
  790. 'min_response_bytes': min_response_bytes,
  791. 'callback': callback
  792. })
  793. # 最多等待 timeout + 队列处理余量
  794. wait_time = timeout + 5
  795. if not event.wait(wait_time):
  796. return b''
  797. return result_container.get('result', b'')