serial_port.py 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900
  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. self._cmd_queue = queue.Queue()
  181. self._cmd_min_interval = 0.10 # 相邻指令最小间隔 100ms
  182. self._last_cmd_time = 0
  183. self._cmd_worker_thread = threading.Thread(target=self._cmd_worker, daemon=True)
  184. self._cmd_worker_thread.start()
  185. # 启动后台重连监控线程,确保断线后可持续自动恢复
  186. self._start_reconnect_monitor()
  187. def _cmd_worker(self):
  188. """串口发送队列工作线程:统一按最小间隔逐个发送指令"""
  189. logger.info("启动串口发送队列工作线程")
  190. while True:
  191. try:
  192. item = self._cmd_queue.get()
  193. if item is None:
  194. break
  195. # 确保相邻指令最小间隔
  196. elapsed = time.time() - self._last_cmd_time
  197. if elapsed < self._cmd_min_interval:
  198. time.sleep(self._cmd_min_interval - elapsed)
  199. cmd_type = item.get('type')
  200. try:
  201. if cmd_type == 'send_and_wait':
  202. result = self._do_send_and_wait(
  203. item['data'],
  204. timeout=item.get('timeout', 2.0),
  205. min_response_bytes=item.get('min_response_bytes', 1)
  206. )
  207. elif cmd_type == 'wait_response':
  208. result = self._do_wait_response(
  209. timeout=item.get('timeout', 2.0),
  210. min_response_bytes=item.get('min_response_bytes', 1)
  211. )
  212. elif cmd_type == 'send_raw':
  213. result = self._do_send_raw(item['data'])
  214. elif cmd_type == 'send_data':
  215. result = self._do_send_data(item['data'], item.get('encoding', 'utf-8'))
  216. else:
  217. result = {'error': f'未知命令类型: {cmd_type}'}
  218. except Exception as e:
  219. logger.error(f"执行串口命令失败: {e}")
  220. result = {'error': str(e)}
  221. self._last_cmd_time = time.time()
  222. callback = item.get('callback')
  223. if callback:
  224. callback(result)
  225. except Exception as e:
  226. logger.error(f"串口发送队列工作线程异常: {e}")
  227. logger.info("串口发送队列工作线程结束")
  228. def _init_rs485_dir(self):
  229. """按配置初始化 RS485 方向控制 GPIO(未配置则不启用)"""
  230. self._close_rs485_dir()
  231. try:
  232. import config as app_config
  233. spec = getattr(app_config, 'SERIAL_RS485_DIR_GPIO', '') or ''
  234. pre = getattr(app_config, 'SERIAL_RS485_DIR_PRE_DELAY', 0.001)
  235. post = getattr(app_config, 'SERIAL_RS485_DIR_POST_DELAY', 0.001)
  236. except Exception:
  237. return
  238. if not spec:
  239. return
  240. direction = Rs485Direction(spec, pre_delay=pre, post_delay=post)
  241. if direction.open():
  242. self._rs485_dir = direction
  243. else:
  244. self._rs485_dir = None
  245. def _close_rs485_dir(self):
  246. if self._rs485_dir is not None:
  247. try:
  248. self._rs485_dir.close()
  249. except Exception:
  250. pass
  251. self._rs485_dir = None
  252. def _rs485_write(self, data: bytes) -> int:
  253. """写串口并 flush(tcdrain)。
  254. 配置了方向 GPIO 时:发送前切到发送态,最后一位发完后立刻切回接收态,
  255. 避免板载 485 模块方向切换滞后把从机应答压掉。
  256. """
  257. direction = self._rs485_dir
  258. if direction is not None and direction.ready:
  259. direction.to_tx()
  260. try:
  261. sent = self.ser.write(data)
  262. self.ser.flush()
  263. finally:
  264. direction.to_rx()
  265. return sent
  266. sent = self.ser.write(data)
  267. self.ser.flush()
  268. return sent
  269. def _do_send_raw(self, data: bytes):
  270. """实际执行 send_raw(在队列工作线程中调用)"""
  271. try:
  272. with self.lock:
  273. if not self.is_connected or not self.ser or not self.ser.is_open:
  274. return False, "serial port not connected"
  275. bytes_sent = self._rs485_write(data)
  276. if self.send_callback and data:
  277. self.send_callback(data.hex())
  278. return True, "send ok"
  279. except Exception as e:
  280. error_msg = f"send raw failed: {str(e)}"
  281. logger.error(error_msg)
  282. if self.error_callback:
  283. self.error_callback(error_msg)
  284. return False, error_msg
  285. def _do_send_data(self, data, encoding='utf-8'):
  286. """实际执行 send_data(在队列工作线程中调用)"""
  287. try:
  288. with self.lock:
  289. if not self.is_connected or not self.ser or not self.ser.is_open:
  290. return False, "串口未连接"
  291. # 确保数据以换行符结束
  292. if isinstance(data, str):
  293. if not data.endswith('\n'):
  294. data += '\n'
  295. bytes_data = data.encode(encoding)
  296. elif isinstance(data, bytes):
  297. if not data.endswith(b'\n'):
  298. bytes_data = data + b'\n'
  299. else:
  300. bytes_data = data
  301. else:
  302. raise TypeError("数据必须是字符串或字节类型")
  303. bytes_sent = self._rs485_write(bytes_data)
  304. logger.debug(f"发送数据到串口: {bytes_data.hex()[:50]}... (共{bytes_sent}字节)")
  305. return True, "发送成功"
  306. except Exception as e:
  307. error_msg = f"发送失败: {str(e)}"
  308. logger.error(error_msg)
  309. if self.error_callback:
  310. self.error_callback(error_msg)
  311. return False, error_msg
  312. def _emit_received_data(self, data: bytes):
  313. """把接收到的原始数据推送给 data_callback(与后台读线程行为一致)"""
  314. if not data or not self.data_callback:
  315. return
  316. hex_data = data.hex()
  317. self.data_callback(hex_data)
  318. try:
  319. decoded = data.decode('utf-8').strip()
  320. if decoded:
  321. self.data_callback(decoded)
  322. except Exception:
  323. pass
  324. def _do_send_and_wait(self, data: bytes, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  325. """实际执行 send_and_wait(在队列工作线程中调用)"""
  326. # 进入同步接收模式,暂停后台读取线程
  327. with self._sync_lock:
  328. self._sync_receive_active = True
  329. try:
  330. # 阶段 1:发送数据并清空缓冲区
  331. with self.lock:
  332. if not self.ser or not self.ser.is_open:
  333. return b''
  334. self.raw_response_buffer.clear()
  335. self.ser.reset_input_buffer()
  336. self._rs485_write(data)
  337. # 485 半双工:等最后字节发完并给收发器一点切换方向的时间
  338. time.sleep(0.03)
  339. if self.send_callback and data:
  340. self.send_callback(data.hex())
  341. # 阶段 2:等待响应。由于后台读线程已暂停,这里独占串口读取。
  342. response = b''
  343. start = time.time()
  344. while time.time() - start < timeout:
  345. # 先清掉缓冲区内可能残留的报文(正常情况下 sync 模式下读线程不会写入)
  346. with self.lock:
  347. while self.raw_response_buffer:
  348. try:
  349. response += bytes.fromhex(self.raw_response_buffer.pop(0))
  350. except Exception:
  351. pass
  352. try:
  353. if self.ser and self.ser.is_open and self.ser.in_waiting > 0:
  354. response += self.ser.read(self.ser.in_waiting)
  355. except Exception:
  356. pass
  357. if len(response) >= min_response_bytes:
  358. # 再等一小段时间收集可能的后续数据
  359. time.sleep(0.05)
  360. with self.lock:
  361. while self.raw_response_buffer:
  362. try:
  363. response += bytes.fromhex(self.raw_response_buffer.pop(0))
  364. except Exception:
  365. pass
  366. try:
  367. if self.ser and self.ser.is_open and self.ser.in_waiting > 0:
  368. response += self.ser.read(self.ser.in_waiting)
  369. except Exception:
  370. pass
  371. self._emit_received_data(response)
  372. return response
  373. time.sleep(0.01)
  374. self._emit_received_data(response)
  375. return response
  376. finally:
  377. # 退出同步接收模式,恢复后台读取线程
  378. with self._sync_lock:
  379. self._sync_receive_active = False
  380. def _do_wait_response(self, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  381. """实际执行 wait_response(在队列工作线程中调用)。
  382. 与 _do_send_and_wait 的区别:
  383. - 不发送任何数据(不 write),因此不触发 send_callback,不会在前端产生空 JSON;
  384. - 不清空接收缓冲(不 reset_input_buffer),避免把从机已回的应答冲掉。
  385. 用于发送完指令(send_raw)后专门等待从机应答。
  386. 收到 min_response_bytes 字节后,继续等到总线空闲(100ms 无新数据)再返回,
  387. 以便把回显与真实应答一并收齐后再交由调用方解析。
  388. """
  389. # 进入同步接收模式,暂停后台读取线程,独占串口读取
  390. with self._sync_lock:
  391. self._sync_receive_active = True
  392. try:
  393. response = b''
  394. start = time.time()
  395. last_data_time = start
  396. while time.time() - start < timeout:
  397. # 从后台读线程缓冲 + 串口硬件缓冲两处收集
  398. chunk = b''
  399. with self.lock:
  400. while self.raw_response_buffer:
  401. try:
  402. chunk += bytes.fromhex(self.raw_response_buffer.pop(0))
  403. except Exception:
  404. pass
  405. try:
  406. if self.ser and self.ser.is_open and self.ser.in_waiting > 0:
  407. chunk += self.ser.read(self.ser.in_waiting)
  408. except Exception:
  409. pass
  410. if chunk:
  411. response += chunk
  412. last_data_time = time.time()
  413. # 收够最小长度后,等总线空闲再返回,避免回显导致提前返回而漏掉真实应答
  414. if len(response) >= min_response_bytes:
  415. if time.time() - last_data_time > 0.1:
  416. self._emit_received_data(response)
  417. return response
  418. time.sleep(0.01)
  419. self._emit_received_data(response)
  420. return response
  421. finally:
  422. with self._sync_lock:
  423. self._sync_receive_active = False
  424. def list_ports(self):
  425. """列出系统中可用的串口"""
  426. ports = []
  427. try:
  428. # 首先尝试使用serial.tools.list_ports
  429. try:
  430. detected_ports = [port.device for port in serial.tools.list_ports.comports()]
  431. ports.extend(detected_ports)
  432. except Exception as e:
  433. logger.warning(f"使用serial.tools.list_ports失败: {str(e)}")
  434. # 根据不同平台进行补充查找
  435. system = platform.system()
  436. if system == 'Windows':
  437. try:
  438. import winreg
  439. # 在Windows系统中读取注册表
  440. key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
  441. r'HARDWARE\DEVICEMAP\SERIALCOMM')
  442. i = 0
  443. while True:
  444. try:
  445. port, value, _ = winreg.EnumValue(key, i)
  446. if value not in ports:
  447. ports.append(value)
  448. i += 1
  449. except OSError:
  450. break
  451. except Exception as e:
  452. logger.error(f"读取Windows串口注册表失败: {str(e)}")
  453. elif system == 'Darwin': # macOS
  454. # 使用glob查找/dev/tty.*设备
  455. darwin_ports = glob.glob('/dev/tty.*')
  456. # 过滤掉不需要的端口
  457. for port in darwin_ports:
  458. if not ('Bluetooth' in port or 'debug' in port or 'com.apple' in port) and port not in ports:
  459. ports.append(port)
  460. elif system == 'Linux':
  461. # 使用glob查找Linux系统中的串口
  462. linux_ports = glob.glob('/dev/ttyS*') + glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')
  463. for port in linux_ports:
  464. if port not in ports:
  465. ports.append(port)
  466. logger.info(f"找到 {len(ports)} 个可用串口: {ports}")
  467. except Exception as e:
  468. logger.error(f"列出串口时出错: {str(e)}")
  469. return sorted(ports) # 排序返回
  470. def connect(self, port, baudrate=9600, timeout=1, **kwargs):
  471. """连接到串口"""
  472. try:
  473. # 构建配置
  474. config = SerialConfig(
  475. port=port,
  476. baudrate=baudrate,
  477. timeout=timeout,
  478. **kwargs
  479. )
  480. with self.lock:
  481. if self.is_connected:
  482. # RLock 允许递归,避免死锁
  483. self.disconnect()
  484. # serial.Serial() 可能阻塞(端口被占用等),不要在持有锁的情况下调用,
  485. # 否则 disconnect() 会长时间等待锁而无法响应。
  486. logger.info(f"尝试连接串口: {port}, 波特率: {baudrate}")
  487. ser = serial.Serial(
  488. port=config.port,
  489. baudrate=config.baudrate,
  490. bytesize=config.bytesize,
  491. parity=config.parity,
  492. stopbits=config.stopbits,
  493. timeout=config.timeout,
  494. xonxoff=config.xonxoff,
  495. rtscts=config.rtscts,
  496. dsrdtr=config.dsrdtr
  497. )
  498. # 检查连接是否成功
  499. if not ser.is_open:
  500. ser.close()
  501. raise Exception("串口打开失败")
  502. with self.lock:
  503. self.ser = ser
  504. self.is_connected = True
  505. self.stop_event.clear()
  506. self.current_config = config
  507. self.reconnect_attempts = 0
  508. # RS485 方向控制 GPIO(可选,未配置则跳过)
  509. self._init_rs485_dir()
  510. # 启动读取线程
  511. self.read_thread = threading.Thread(target=self._read_loop, daemon=True)
  512. self.read_thread.start()
  513. if self.status_callback:
  514. self.status_callback(True)
  515. logger.info(f"已连接到 {port},波特率 {baudrate}")
  516. return True, f"已连接到 {port},波特率 {baudrate}"
  517. except Exception as e:
  518. error_msg = f"连接失败: {str(e)}"
  519. logger.error(error_msg)
  520. if self.status_callback:
  521. self.status_callback(False)
  522. if self.error_callback:
  523. self.error_callback(error_msg)
  524. return False, error_msg
  525. def disconnect(self):
  526. """断开串口连接"""
  527. try:
  528. logger.info("断开串口连接")
  529. # 释放 RS485 方向控制 GPIO
  530. self._close_rs485_dir()
  531. # 阶段 0:清空发送队列中待执行的指令,避免断开后再发数据
  532. try:
  533. while not self._cmd_queue.empty():
  534. self._cmd_queue.get_nowait()
  535. except Exception:
  536. pass
  537. # 阶段 1:通知读取线程退出,不要在持有锁的情况下 join,
  538. # 否则读取线程异常时调用 _close_on_error 会拿不到锁而死锁。
  539. with self.lock:
  540. self.stop_event.set()
  541. if self.read_thread and self.read_thread.is_alive():
  542. self.read_thread.join(timeout=2.0)
  543. if self.read_thread.is_alive():
  544. logger.warning("读取线程未能正常终止")
  545. # 阶段 2:关闭串口并清理状态
  546. with self.lock:
  547. if self.ser and self.ser.is_open:
  548. try:
  549. self.ser.close()
  550. except Exception as e:
  551. logger.error(f"关闭串口时出错: {str(e)}")
  552. self.ser = None
  553. self.is_connected = False
  554. self.current_config = None
  555. if self.status_callback:
  556. self.status_callback(False)
  557. return True, "已断开连接"
  558. except Exception as e:
  559. error_msg = f"断开连接失败: {str(e)}"
  560. logger.error(error_msg)
  561. if self.error_callback:
  562. self.error_callback(error_msg)
  563. return False, error_msg
  564. def _read_loop(self):
  565. """读取串口数据的循环"""
  566. logger.info("启动串口读取线程")
  567. while not self.stop_event.is_set():
  568. try:
  569. # send_and_wait 正在同步接收时,后台读线程让出总线,
  570. # 避免读线程把响应抢走导致同步调用超时。
  571. with self._sync_lock:
  572. sync_active = self._sync_receive_active
  573. if sync_active:
  574. time.sleep(0.001)
  575. continue
  576. if self.ser and self.ser.is_open:
  577. # 使用in_waiting提高效率
  578. if self.ser.in_waiting > 0:
  579. data = self.ser.read(self.ser.in_waiting)
  580. # 默认将原始数据以十六进制存入缓冲区
  581. hex_data = data.hex()
  582. with self.lock:
  583. self.raw_response_buffer.append(hex_data)
  584. if self.data_callback:
  585. self.data_callback(hex_data)
  586. # 如果能解码为文本,也通知回调
  587. try:
  588. decoded_data = data.decode('utf-8').strip()
  589. if decoded_data and self.data_callback:
  590. self.data_callback(decoded_data)
  591. except:
  592. pass
  593. time.sleep(0.001)
  594. except Exception as e:
  595. error_msg = f"读取串口数据错误: {str(e)}"
  596. logger.error(error_msg)
  597. if self.error_callback:
  598. self.error_callback(error_msg)
  599. # 读取线程只负责关闭当前连接并通知,重连由独立监控线程负责,
  600. # 避免在读取线程内调用 connect() 造成自连接/自 join 的问题
  601. self._close_on_error()
  602. break
  603. # 线程结束时清理资源
  604. logger.info("串口读取线程结束")
  605. def _close_on_error(self):
  606. """读取异常时关闭串口并触发状态回调,但不直接重连"""
  607. self._close_rs485_dir()
  608. with self.lock:
  609. if self.ser and self.ser.is_open:
  610. try:
  611. self.ser.close()
  612. except Exception:
  613. pass
  614. self.ser = None
  615. self.is_connected = False
  616. if self.status_callback:
  617. try:
  618. self.status_callback(False)
  619. except Exception:
  620. pass
  621. logger.warning("串口因读取错误已关闭,等待重连监控线程恢复")
  622. def _start_reconnect_monitor(self):
  623. """启动独立后台线程,在串口断开时持续尝试重连"""
  624. if getattr(self, '_reconnect_monitor_thread', None) and self._reconnect_monitor_thread.is_alive():
  625. return
  626. self._reconnect_monitor_thread = threading.Thread(target=self._reconnect_monitor, daemon=True)
  627. self._reconnect_monitor_thread.start()
  628. def _reconnect_monitor(self):
  629. """后台重连监控:只要保存过配置就无限重试,成功则重置计数"""
  630. logger.info("启动串口重连监控线程")
  631. while True:
  632. try:
  633. with self.lock:
  634. connected = self.is_connected
  635. config = self.current_config
  636. if not connected and config is not None:
  637. self.reconnect_attempts += 1
  638. attempt = self.reconnect_attempts
  639. logger.warning(f"重连监控尝试连接串口... (第{attempt}次)")
  640. success, msg = self.connect(
  641. port=config.port,
  642. baudrate=config.baudrate,
  643. timeout=config.timeout,
  644. bytesize=config.bytesize,
  645. parity=config.parity,
  646. stopbits=config.stopbits,
  647. xonxoff=config.xonxoff,
  648. rtscts=config.rtscts,
  649. dsrdtr=config.dsrdtr
  650. )
  651. if not success:
  652. # 指数退避,最长 30 秒
  653. delay = min(30, 2 + attempt * 2)
  654. logger.warning(f"重连失败: {msg},{delay}秒后再次尝试")
  655. time.sleep(delay)
  656. else:
  657. logger.info("串口重连成功")
  658. else:
  659. # 已连接或未保存配置时,重置失败计数并降低检查频率
  660. if connected:
  661. self.reconnect_attempts = 0
  662. time.sleep(3)
  663. except Exception as e:
  664. logger.error(f"重连监控线程异常: {e}")
  665. time.sleep(5)
  666. def send_data(self, data, encoding='utf-8'):
  667. """发送数据到串口(入队,由队列工作线程统一发送)"""
  668. result_container = {}
  669. event = threading.Event()
  670. def callback(result):
  671. result_container['result'] = result
  672. event.set()
  673. self._cmd_queue.put({
  674. 'type': 'send_data',
  675. 'data': data,
  676. 'encoding': encoding,
  677. 'callback': callback
  678. })
  679. # 最多等待 5 秒,避免队列卡死导致调用方永远阻塞
  680. if not event.wait(5):
  681. return False, "串口发送队列超时"
  682. return result_container.get('result', (False, "未知错误"))
  683. def set_data_callback(self, callback):
  684. """设置数据接收回调函数"""
  685. self.data_callback = callback
  686. def set_send_callback(self, callback):
  687. """设置数据发送回调函数"""
  688. self.send_callback = callback
  689. def set_status_callback(self, callback):
  690. """设置状态变化回调函数"""
  691. self.status_callback = callback
  692. def set_error_callback(self, callback):
  693. """设置错误回调函数"""
  694. self.error_callback = callback
  695. def get_status(self):
  696. """获取当前连接状态"""
  697. with self.lock:
  698. return {
  699. 'connected': self.is_connected,
  700. 'config': self.current_config,
  701. 'has_error': self.reconnect_attempts > 0
  702. }
  703. def _should_reconnect(self):
  704. """判断是否应该尝试重连"""
  705. self.reconnect_attempts += 1
  706. return self.reconnect_attempts <= self.max_reconnect_attempts
  707. def send_raw(self, data: bytes):
  708. """send raw binary data without adding newline(入队,由队列工作线程统一发送)"""
  709. result_container = {}
  710. event = threading.Event()
  711. def callback(result):
  712. result_container['result'] = result
  713. event.set()
  714. self._cmd_queue.put({
  715. 'type': 'send_raw',
  716. 'data': data,
  717. 'callback': callback
  718. })
  719. # 最多等待 5 秒,避免队列卡死导致调用方永远阻塞
  720. if not event.wait(5):
  721. return False, "串口发送队列超时"
  722. return result_container.get('result', (False, "未知错误"))
  723. def flush_input(self):
  724. """清空输入缓冲区"""
  725. try:
  726. with self.lock:
  727. if self.ser and self.ser.is_open:
  728. self.ser.reset_input_buffer()
  729. return True, "输入缓冲区已清空"
  730. return False, "串口未连接"
  731. except Exception as e:
  732. error_msg = f"清空缓冲区失败: {str(e)}"
  733. logger.error(error_msg)
  734. return False, error_msg
  735. def flush_output(self):
  736. """清空输出缓冲区"""
  737. try:
  738. with self.lock:
  739. if self.ser and self.ser.is_open:
  740. self.ser.reset_output_buffer()
  741. return True, "输出缓冲区已清空"
  742. return False, "串口未连接"
  743. except Exception as e:
  744. error_msg = f"清空缓冲区失败: {str(e)}"
  745. logger.error(error_msg)
  746. return False, error_msg
  747. def send_and_wait(self, data: bytes, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  748. """sync send and wait(入队,由队列工作线程统一发送并等待响应)"""
  749. result_container = {}
  750. event = threading.Event()
  751. def callback(result):
  752. result_container['result'] = result
  753. event.set()
  754. self._cmd_queue.put({
  755. 'type': 'send_and_wait',
  756. 'data': data,
  757. 'timeout': timeout,
  758. 'min_response_bytes': min_response_bytes,
  759. 'callback': callback
  760. })
  761. # 最多等待 timeout + 队列处理余量
  762. wait_time = timeout + 5
  763. if not event.wait(wait_time):
  764. return b''
  765. return result_container.get('result', b'')
  766. def wait_response(self, timeout: float = 2.0, min_response_bytes: int = 1) -> bytes:
  767. """只读取从机应答,不发送任何数据(入队,由队列工作线程统一执行)。
  768. 与 send_and_wait 的区别:不 write 数据、不触发 send_callback、不清空接收缓冲。
  769. 用于发送完指令(send_raw)后等待从机应答,避免发空数据污染前端显示、
  770. 避免清缓冲冲掉已到达的应答。
  771. """
  772. result_container = {}
  773. event = threading.Event()
  774. def callback(result):
  775. result_container['result'] = result
  776. event.set()
  777. self._cmd_queue.put({
  778. 'type': 'wait_response',
  779. 'timeout': timeout,
  780. 'min_response_bytes': min_response_bytes,
  781. 'callback': callback
  782. })
  783. # 最多等待 timeout + 队列处理余量
  784. wait_time = timeout + 5
  785. if not event.wait(wait_time):
  786. return b''
  787. return result_container.get('result', b'')