modbus_rtu.py 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687
  1. """MODBUS-RTU 协议实现(线架/配线架 V5 协议,20261023)。
  2. V5 关键变化(相对 V4):
  3. 1. 取消"广播发现 + 自动分配地址"(00 40 / 00 41 / 00 42 / 00 43) 流程;
  4. 地址改由现场用"配置卡"写入线架(DTU 可让线架进入配置地址状态)。
  5. 2. DTU 定时按固定地址查询线架:
  6. 0x80 查询: [add][0x80][12 字节 UID][CRC_L][CRC_H]
  7. - 已绑定地址 -> 携带绑定的 UID
  8. - 未绑定地址 -> UID 为 12 字节全 0(探测)
  9. 0x81 应答: [add][0x81][12 字节 UID][CRC_L][CRC_H](线架自身 UID)
  10. 0x82 确认: [add][0x82][12 字节 UID][CRC_L][CRC_H](DTU 确认绑定)
  11. 0x83 应答: [add][0x83][12 字节 UID][CRC_L][CRC_H]
  12. 3. 读卡 0x03 回归标准 MODBUS(不再在帧内携带 UID):
  13. 请求 8B: [add][0x03][0x00][0x02][0x00][0x48][CRC_L][CRC_H]
  14. 响应 149B:[add][0x03][0x90][144 数据字节][CRC_L][CRC_H]
  15. 每张卡 6 字节(硬件卡号,12 位十六进制);无卡标记 = FF FF FF FF FF FF
  16. 4. 支持让线架进入"配置地址状态"(读配置卡设置地址):
  17. 发送: AA B7 00 07 80 00 00 FF 00 00 02 64 03
  18. 应答: 55 00 00 02 [ANTLIST] [ADDR] [XOR] 03
  19. ANTLIST = 读到配置卡的天线号(1~24),ADDR = 配置的地址
  20. XOR = 0x55 起到 ADDR 的异或和
  21. 注: 硬件通信固定 6 字节卡号;对 MQTT 的 8 字节(16 位) jumper_uid 适配在 app.py
  22. 边界完成(前 4 位 DTU 号 + 后 12 位卡号)。
  23. """
  24. from typing import Optional
  25. import threading
  26. import struct
  27. import logging
  28. logger = logging.getLogger('serial_mqtt_gateway')
  29. # ========== CRC16 (MODBUS) ==========
  30. def calculate_crc16(data: bytes) -> bytes:
  31. """计算Modbus CRC16校验(低字节在前)"""
  32. crc = 0xFFFF
  33. for byte in data:
  34. crc ^= byte
  35. for _ in range(8):
  36. if crc & 0x0001:
  37. crc = (crc >> 1) ^ 0xA001
  38. else:
  39. crc >>= 1
  40. return struct.pack('<H', crc)
  41. def verify_crc16(data: bytes) -> bool:
  42. """验证Modbus CRC16校验"""
  43. if len(data) < 2:
  44. return False
  45. received_crc = struct.unpack('<H', data[-2:])[0]
  46. calculated_crc = struct.unpack('<H', calculate_crc16(data[:-2]))[0]
  47. return received_crc == calculated_crc
  48. # ========== V5 地址查询 / 确认协议(0x80 / 0x81 / 0x82 / 0x83) ==========
  49. ADDRESS_QUERY_FC = 0x80 # DTU -> 线架:地址查询
  50. ADDRESS_QUERY_RESP_FC = 0x81 # 线架 -> DTU:查询应答(携带自身 UID)
  51. ADDRESS_CONFIRM_FC = 0x82 # DTU -> 线架:确认绑定
  52. ADDRESS_CONFIRM_RESP_FC = 0x83 # 线架 -> DTU:确认应答
  53. ADDRESS_FRAME_LEN = 16 # add(1)+fc(1)+uid(12)+crc(2)
  54. ZERO_UID = b'\x00' * 12 # 未绑定地址探测用 UID(12 字节全 0)
  55. UID_BYTES = 12
  56. def _uid_bytes(uid) -> bytes:
  57. """把 UID 规范化为 12 字节。None -> 全 0;str/bytes 均可。"""
  58. if uid is None:
  59. return ZERO_UID
  60. if isinstance(uid, str):
  61. uid = uid.strip().replace(':', '').replace(' ', '').replace('-', '')
  62. try:
  63. uid = bytes.fromhex(uid)
  64. except ValueError:
  65. raise ValueError(f"UID 十六进制非法: {uid!r}")
  66. if not isinstance(uid, (bytes, bytearray)):
  67. raise ValueError(f"UID 类型非法: {type(uid)}")
  68. if len(uid) != UID_BYTES:
  69. raise ValueError(f"UID长度必须是{UID_BYTES}字节,当前: {len(uid)}")
  70. return bytes(uid)
  71. def build_address_query_request(device_address: int, uid=None) -> bytes:
  72. """构建 V5 地址查询请求(0x80,16 字节)。
  73. 格式: [add][0x80][12 字节 UID][CRC_L][CRC_H]
  74. uid=None 表示 12 字节全 0(未绑定地址探测)。
  75. 文档示例: 01 80 00*12 54 01
  76. """
  77. data = bytes([device_address, ADDRESS_QUERY_FC]) + _uid_bytes(uid)
  78. return data + calculate_crc16(data)
  79. def parse_address_query_response(data: bytes) -> dict:
  80. """解析 V5 地址查询应答(0x81,16 字节)。
  81. 格式: [add][0x81][12 字节 UID][CRC_L][CRC_H]
  82. 文档示例: 01 81 51 00 12 00 11 00 00 4C 30 31 33 56 D0 D3
  83. 返回: {'success': True, 'device_address', 'uid': '24位hex'|None, 'raw_data'}
  84. UID 全 0 / 全 FF 视为无效(uid=None)。
  85. """
  86. if not data or len(data) < ADDRESS_FRAME_LEN:
  87. return {'error': '数据长度不足',
  88. 'raw_data': data.hex() if data else ''}
  89. frame = data[:ADDRESS_FRAME_LEN]
  90. if frame[1] != ADDRESS_QUERY_RESP_FC:
  91. return {'error': f"非预期功能码: {frame[1]:#x}", 'raw_data': frame.hex()}
  92. if not verify_crc16(frame):
  93. return {'error': 'CRC校验失败', 'raw_data': frame.hex()}
  94. uid = frame[2:14]
  95. valid = uid not in (b'\x00' * 12, b'\xff' * 12)
  96. return {
  97. 'success': True,
  98. 'device_address': frame[0],
  99. 'uid': uid.hex() if valid else None,
  100. 'raw_data': frame.hex(),
  101. }
  102. def build_address_confirm_request(device_address: int, uid) -> bytes:
  103. """构建 V5 地址确认请求(0x82,16 字节)。
  104. 格式: [add][0x82][12 字节 UID][CRC_L][CRC_H]
  105. 文档示例: 01 82 51 00 12 00 11 00 00 4C 30 31 33 56 D5 10
  106. """
  107. data = bytes([device_address, ADDRESS_CONFIRM_FC]) + _uid_bytes(uid)
  108. return data + calculate_crc16(data)
  109. def parse_address_confirm_response(data: bytes) -> dict:
  110. """解析 V5 地址确认应答(0x83,16 字节)。
  111. 格式: [add][0x83][12 字节 UID][CRC_L][CRC_H]
  112. 文档示例: 01 83 51 00 12 00 11 00 00 4C 30 31 33 56 D7 91
  113. """
  114. if not data or len(data) < ADDRESS_FRAME_LEN:
  115. return {'error': '数据长度不足',
  116. 'raw_data': data.hex() if data else ''}
  117. frame = data[:ADDRESS_FRAME_LEN]
  118. if frame[1] != ADDRESS_CONFIRM_RESP_FC:
  119. return {'error': f"非预期功能码: {frame[1]:#x}", 'raw_data': frame.hex()}
  120. if not verify_crc16(frame):
  121. return {'error': 'CRC校验失败', 'raw_data': frame.hex()}
  122. uid = frame[2:14]
  123. valid = uid not in (b'\x00' * 12, b'\xff' * 12)
  124. return {
  125. 'success': True,
  126. 'device_address': frame[0],
  127. 'uid': uid.hex() if valid else None,
  128. 'raw_data': frame.hex(),
  129. }
  130. # ========== V5 配置地址状态(非 MODBUS 帧,用于刷配置卡设置地址) ==========
  131. # 文档帧: aa b7 00 07 80 00 00 ff 00 00 02 64 03
  132. # 帧头 AA B7 + 7 字节数据 + 0x64(帧内固定校验/参数, 按文档原样发送) + 0x03 结尾
  133. CONFIG_ADDRESS_ENTER_FRAME = bytes.fromhex('aab70007800000ff0000026403')
  134. # 应答帧: 55 00 00 02 ANTLIST ADDR XOR 03 (8 字节)
  135. CONFIG_ADDRESS_RESPONSE_LEN = 8
  136. CONFIG_ADDRESS_HEADER = 0x55
  137. CONFIG_ADDRESS_TAIL = 0x03
  138. def build_config_address_enter_frame() -> bytes:
  139. """让线架进入"配置地址状态"(等待刷配置卡)的广播帧。"""
  140. return CONFIG_ADDRESS_ENTER_FRAME
  141. def _parse_config_address_frame(frame: bytes) -> Optional[dict]:
  142. """解析单个 8 字节配置卡应答帧,失败返回 None。"""
  143. if len(frame) < CONFIG_ADDRESS_RESPONSE_LEN:
  144. return None
  145. head = frame[0]
  146. ant = frame[4]
  147. addr = frame[5]
  148. xor = frame[6]
  149. tail = frame[7]
  150. if head != CONFIG_ADDRESS_HEADER or tail != CONFIG_ADDRESS_TAIL:
  151. return None
  152. if not (1 <= ant <= 24) or not (0 <= addr <= 247):
  153. return None
  154. expect = 0
  155. for b in frame[:6]: # XOR = 0x55 起直到 ADDR
  156. expect ^= b
  157. if expect != xor:
  158. return None
  159. return {
  160. 'success': True,
  161. 'antenna': ant,
  162. 'address': addr,
  163. 'raw_data': frame.hex(),
  164. }
  165. def parse_config_address_response(data: bytes) -> dict:
  166. """在收到的数据中查找配置卡应答帧。
  167. 格式: 55 00 00 02 [ANTLIST] [ADDR] [XOR] 03
  168. ANTLIST: 读到配置卡的天线号(1 开始)
  169. ADDR : 配置的地址
  170. XOR : 0x55 起到 ADDR 的异或和
  171. 返回 {'success': True, 'antenna', 'address', 'raw_data'} 或 {'error': ...}
  172. """
  173. if not data:
  174. return {'error': '无数据', 'raw_data': ''}
  175. if len(data) < CONFIG_ADDRESS_RESPONSE_LEN:
  176. return {'error': f'数据长度不足 ({len(data)}/{CONFIG_ADDRESS_RESPONSE_LEN})',
  177. 'raw_data': data.hex()}
  178. for i in range(len(data) - CONFIG_ADDRESS_RESPONSE_LEN + 1):
  179. parsed = _parse_config_address_frame(data[i:i + CONFIG_ADDRESS_RESPONSE_LEN])
  180. if parsed:
  181. return parsed
  182. return {'error': '未找到有效的配置卡应答帧', 'raw_data': data.hex()}
  183. # ========== 线架绑定表 / 总线互斥 ==========
  184. class AddressConfigProtocol:
  185. """线架地址↔UID 绑定表 + 总线配置互斥锁。
  186. V5 起不再提供广播发现/自动分配地址,仅保留绑定表持久化与
  187. "配置地址期间占用总线"的互斥锁。
  188. """
  189. def __init__(self, serial_port):
  190. self.serial = serial_port
  191. self.default_timeout = 5.0
  192. self.stored_devices = {} # {uid_hex: address}
  193. self.config_lock = threading.RLock()
  194. def add_stored_device(self, uid: str, address: int):
  195. """添加已存储的设备"""
  196. self.stored_devices[uid] = address
  197. def get_stored_devices(self) -> dict:
  198. """获取已存储的设备列表"""
  199. return self.stored_devices.copy()
  200. def save_config(self, filepath: str) -> bool:
  201. """保存配置到文件"""
  202. import json
  203. try:
  204. with open(filepath, 'w') as f:
  205. json.dump(self.stored_devices, f, indent=2)
  206. return True
  207. except Exception as e:
  208. logger.error(f"保存配置失败: {e}")
  209. return False
  210. def load_config(self, filepath: str) -> bool:
  211. """从文件加载配置"""
  212. import json
  213. try:
  214. with open(filepath, 'r') as f:
  215. self.stored_devices = json.load(f)
  216. return True
  217. except Exception as e:
  218. logger.error(f"加载配置失败: {e}")
  219. return False
  220. # ========== V5 批量读卡 / 设置卡号协议常量 ==========
  221. CARD_REG_ADDR = 0x0002 # 批量卡号读起始寄存器
  222. CARD_REG_QUANTITY = 0x48 # 72 寄存器 = 144 字节
  223. CARD_DATA_BYTES = 144 # 24 天线 × 6 字节
  224. BYTES_PER_TAG = 6
  225. ANTENNA_COUNT = 24
  226. NO_TAG_BYTES = b'\xff' * 6 # 无卡标记
  227. NO_TAG_HEX = 'ffffffffffff'
  228. BULK_BYTE_COUNT = 0x90 # 144,Modbus 响应字节计数字段
  229. BULK_REQUEST_LEN = 8 # addr(1)+fc(1)+start(2)+qty(2)+crc(2)
  230. BULK_RESPONSE_LEN = 149 # addr(1)+fc(1)+bytecount(1)+data(144)+crc(2)
  231. # 过渡期兼容:V4 旧固件响应尾部还带 12 字节 UID(161 字节)
  232. LEGACY_UID_RESPONSE_LEN = 161
  233. # 设置卡号协议常量(非标准 MODBUS 0x10)
  234. # 协议帧: [addr][0x10][0x00][0x03][0x00][0x90][144字节数据][CRC_L][CRC_H]
  235. # 注意: 与标准 MODBUS 0x10 不同,此处省略 byte count 字段,数量字段 0x0090 直接表示字节数(144)
  236. SET_CARD_REG_ADDR = 0x0003 # 设置卡号起始寄存器
  237. SET_CARD_QUANTITY = 0x0090 # 数量字段 = 144(字节数,非寄存器数)
  238. SET_CARD_DATA_BYTES = 144 # 24 路 × 6 字节
  239. SET_CARD_REQUEST_LEN = 152 # addr(1)+fc(1)+start(2)+qty(2)+data(144)+crc(2)
  240. SET_CARD_RESPONSE_LEN = 8 # addr(1)+fc(1)+start(2)+qty(2)+crc(2)
  241. # 天线地址映射表(天线编号 -> Modbus寄存器地址)
  242. # 所有天线共享寄存器 0x0002,由 read_all_antenna_cards 一次批量读出
  243. ANTENNA_ADDRESSES = {i: CARD_REG_ADDR for i in range(1, 25)}
  244. def build_read_cards_request(device_address: int) -> bytes:
  245. """构建 V5 批量读卡请求(标准 MODBUS 0x03,8 字节)。
  246. 格式: [add][0x03][0x00][0x02][0x00][0x48][CRC_L][CRC_H]
  247. 文档示例: 01 03 00 02 00 48 E4 3C
  248. """
  249. data = bytes([device_address, 0x03]) + struct.pack('>HH', CARD_REG_ADDR, CARD_REG_QUANTITY)
  250. return data + calculate_crc16(data)
  251. class ModbusRTUClient:
  252. """Modbus RTU 客户端"""
  253. def __init__(self, serial_port):
  254. self.serial = serial_port
  255. self.default_timeout = 2.0
  256. self.test_cards = None # 测试注入:非 None 时 read_all_antenna_cards 返回构造数据
  257. self.test_panel_uids = None # 测试注入:{addr: 'hex24'} 模拟线架自身 UID(query_address 用)
  258. def _build_request(self, device_address: int, function_code: int, data: bytes = b'') -> bytes:
  259. """构建Modbus请求帧"""
  260. pdu = bytes([device_address, function_code]) + data
  261. return pdu + calculate_crc16(pdu)
  262. def _send_receive(self, request: bytes, expected_min_len: int = 5, timeout: float = None) -> dict:
  263. """send request and receive response using sync method"""
  264. timeout = timeout or self.default_timeout
  265. if not self.serial.ser:
  266. return {"error": "serial not connected"}
  267. response = self.serial.send_and_wait(request, timeout=timeout, min_response_bytes=expected_min_len)
  268. if not response or len(response) < expected_min_len:
  269. return {"error": "response timeout or too short", "raw_data": response.hex() if response else ""}
  270. if not verify_crc16(response):
  271. logger.warning(f"CRC check failed: {response.hex()}")
  272. return {"error": "CRC check failed", "raw_data": response.hex()}
  273. return {
  274. "success": True,
  275. "device_address": response[0],
  276. "function_code": response[1],
  277. "data": response[2:-2].hex(),
  278. "raw_data": response.hex()
  279. }
  280. # ----- V5 地址查询 / 确认 -----
  281. def query_address(self, device_address: int, uid=None, timeout: float = None) -> dict:
  282. """V5 地址查询(0x80)。
  283. Args:
  284. device_address: 要查询的固定地址
  285. uid: 已绑定的 UID(str/bytes);None -> 12 字节全 0 探测
  286. Returns:
  287. {'success': True, 'device_address', 'uid': '24位hex'|None, 'raw_data'}
  288. 或 {'error': ...}
  289. """
  290. if self.test_panel_uids is not None:
  291. # 测试注入:按地址返回模拟线架 UID(未列出的地址视为无应答)
  292. simulated = self.test_panel_uids.get(device_address)
  293. if simulated is None:
  294. return {"error": "response timeout or too short", "raw_data": ""}
  295. return {
  296. "success": True,
  297. "device_address": device_address,
  298. "uid": str(simulated).lower(),
  299. "raw_data": "TEST_INJECTED",
  300. }
  301. timeout = timeout or self.default_timeout
  302. if not self.serial.ser:
  303. return {"error": "serial not connected"}
  304. try:
  305. request = build_address_query_request(device_address, uid)
  306. except ValueError as e:
  307. return {"error": str(e)}
  308. response = self.serial.send_and_wait(
  309. request, timeout=timeout, min_response_bytes=ADDRESS_FRAME_LEN
  310. )
  311. if not response:
  312. return {"error": "response timeout or too short", "raw_data": ""}
  313. return parse_address_query_response(response)
  314. def confirm_address(self, device_address: int, uid, timeout: float = None) -> dict:
  315. """V5 地址确认(0x82):DTU 确认"地址↔UID"绑定。"""
  316. if self.test_panel_uids is not None:
  317. return {"success": True, "device_address": device_address,
  318. "uid": str(uid).lower() if uid else None, "raw_data": "TEST_INJECTED"}
  319. timeout = timeout or self.default_timeout
  320. if not self.serial.ser:
  321. return {"error": "serial not connected"}
  322. try:
  323. request = build_address_confirm_request(device_address, uid)
  324. except ValueError as e:
  325. return {"error": str(e)}
  326. response = self.serial.send_and_wait(
  327. request, timeout=timeout, min_response_bytes=ADDRESS_FRAME_LEN
  328. )
  329. if not response:
  330. return {"error": "response timeout or too short", "raw_data": ""}
  331. return parse_address_confirm_response(response)
  332. # ----- V5 批量读卡 -----
  333. def read_all_antenna_cards(self, device_address: int, timeout: float = None) -> dict:
  334. """V5: 批量读取全部 24 路天线卡号(标准 MODBUS 0x03)。
  335. 寄存器 0x0002,数量 0x48(72 寄存器 = 144 字节)。
  336. 请求 8B: [addr][0x03][0x00][0x02][0x00][0x48][CRC_L][CRC_H]
  337. 响应 149B:[addr][0x03][0x90][144 数据字节][CRC_L][CRC_H]
  338. 每张卡 6 字节(硬件卡号,12 位十六进制);无卡标记 = 6×0xFF。
  339. 过渡期兼容: V4 旧固件 161B 响应(尾部多 12 字节 UID)仍可解析,
  340. UID 字段在此层忽略(地址↔UID 绑定走 0x80/0x82 查询确认)。
  341. 返回:
  342. {'success': True, 'device_address', 'function_code': 0x03,
  343. 'cards': [{'antenna', 'card_str', 'present', 'uid'}, ...24],
  344. 'raw_data'}
  345. """
  346. # 测试注入: test_cards = {addr: {port_id: 'hex12'|None, ...}, ...}
  347. if self.test_cards is not None:
  348. panel_map = self.test_cards.get(device_address)
  349. if panel_map is not None:
  350. cards = []
  351. for i in range(ANTENNA_COUNT):
  352. ant = i + 1
  353. hex_str = panel_map.get(ant)
  354. if hex_str:
  355. tag = bytes.fromhex(hex_str)
  356. cards.append({
  357. 'antenna': ant,
  358. 'card_str': tag.hex(),
  359. 'present': True,
  360. 'uid': ':'.join(f'{b:02x}' for b in tag)
  361. })
  362. else:
  363. cards.append({
  364. 'antenna': ant, 'card_str': '', 'present': False, 'uid': ''
  365. })
  366. return {
  367. "success": True,
  368. "device_address": device_address,
  369. "function_code": 0x03,
  370. "cards": cards,
  371. "raw_data": "TEST_INJECTED"
  372. }
  373. timeout = timeout or self.default_timeout
  374. if not self.serial.ser:
  375. return {"error": "serial not connected"}
  376. request = build_read_cards_request(device_address)
  377. response = self.serial.send_and_wait(
  378. request, timeout=timeout, min_response_bytes=BULK_RESPONSE_LEN
  379. )
  380. if not response or len(response) < 5:
  381. return {"error": "response timeout or too short",
  382. "raw_data": response.hex() if response else ""}
  383. # Modbus 异常响应: addr + 0x83 + exception_code + CRC
  384. if response[1] & 0x80:
  385. return {"error": f"Modbus exception: {response[2]:#x}",
  386. "raw_data": response.hex()}
  387. frame = None
  388. if (len(response) >= BULK_RESPONSE_LEN
  389. and response[1] == 0x03 and response[2] == BULK_BYTE_COUNT
  390. and verify_crc16(response[:BULK_RESPONSE_LEN])):
  391. frame = response[:BULK_RESPONSE_LEN]
  392. elif len(response) >= LEGACY_UID_RESPONSE_LEN and verify_crc16(
  393. response[:LEGACY_UID_RESPONSE_LEN]):
  394. # 过渡期兼容:V4 旧固件 161B 响应(无 UID 使用价值,仅解析卡数据)
  395. logger.debug("收到旧格式(161B)批量读卡响应,UID 字段已忽略")
  396. frame = response[:BULK_RESPONSE_LEN]
  397. else:
  398. if len(response) < BULK_RESPONSE_LEN:
  399. return {"error": f"response too short ({len(response)}/{BULK_RESPONSE_LEN})",
  400. "raw_data": response.hex()}
  401. return {"error": "CRC check failed", "raw_data": response.hex()}
  402. if frame[1] != 0x03 or frame[2] != BULK_BYTE_COUNT:
  403. return {"error": f"unexpected response: fc={frame[1]:#x} count={frame[2]:#x}",
  404. "raw_data": frame.hex()}
  405. tag_data = frame[3:3 + CARD_DATA_BYTES] # 144 字节
  406. cards = []
  407. for i in range(ANTENNA_COUNT):
  408. tag = tag_data[i * BYTES_PER_TAG:(i + 1) * BYTES_PER_TAG] # 6 字节
  409. present = tag != NO_TAG_BYTES
  410. cards.append({
  411. 'antenna': i + 1,
  412. 'card_str': tag.hex() if present else '',
  413. 'present': present,
  414. 'uid': ':'.join(f'{b:02x}' for b in tag) if present else ''
  415. })
  416. return {
  417. "success": True,
  418. "device_address": frame[0],
  419. "function_code": 0x03,
  420. "cards": cards,
  421. "raw_data": frame.hex()
  422. }
  423. def read_antenna_card(self, device_address: int, antenna_num: int, timeout: float = None) -> dict:
  424. """读取单根天线卡号(由批量读提取,不再发逐天线帧)。
  425. 调用 read_all_antenna_cards 后提取指定天线,返回兼容 schema。
  426. 无卡时 card_number_str 为空串。
  427. """
  428. if antenna_num < 1 or antenna_num > ANTENNA_COUNT:
  429. return {"error": f"invalid antenna number: {antenna_num}, must be 1-{ANTENNA_COUNT}"}
  430. result = self.read_all_antenna_cards(device_address, timeout=timeout)
  431. if 'error' in result:
  432. return result
  433. card = next((c for c in result.get('cards', []) if c['antenna'] == antenna_num), None)
  434. if card is None:
  435. return {"error": f"antenna {antenna_num} not found in bulk response",
  436. "raw_data": result.get('raw_data', '')}
  437. base = {k: v for k, v in result.items() if k != 'cards'}
  438. if card['present']:
  439. tag_bytes = bytes.fromhex(card['card_str']) # 6 字节
  440. card_number = int.from_bytes(tag_bytes, 'big')
  441. return {
  442. 'card_number': card_number,
  443. 'card_number_hex': f'0x{card_number:012x}',
  444. 'card_number_str': card['card_str'],
  445. 'antenna': antenna_num,
  446. 'uid': card['uid'],
  447. **base
  448. }
  449. return {
  450. 'card_number': 0,
  451. 'card_number_hex': '0x000000000000',
  452. 'card_number_str': '',
  453. 'antenna': antenna_num,
  454. 'uid': '',
  455. **base
  456. }
  457. def set_card_mapping(self, device_address: int, card_mappings: dict, timeout: float = None) -> dict:
  458. """设置24路天线卡号(0x10 写 0x0003,144字节,非标准MODBUS无bytecount)。
  459. 协议帧(发送): [addr][0x10][0x00][0x03][0x00][0x90][144字节数据][CRC_L][CRC_H]
  460. 协议帧(响应): [addr][0x10][0x00][0x03][0x00][0x90][CRC_L][CRC_H]
  461. Args:
  462. device_address: 从机地址
  463. card_mappings: {port_id(1-24): 'hex12' or None}
  464. 未提供或 None 的端口填 0xFF*6(无卡标记)
  465. Returns:
  466. {'success': True, 'device_address', 'raw_data', 'cards_written'} 或
  467. {'error': ...}
  468. """
  469. timeout = timeout or self.default_timeout
  470. if not self.serial.ser:
  471. return {"error": "serial not connected"}
  472. # 构建 24 路 × 6 字节 = 144 字节数据
  473. data_bytes = b''
  474. written = {}
  475. for ant in range(1, ANTENNA_COUNT + 1):
  476. hex_str = card_mappings.get(ant)
  477. if hex_str:
  478. hex_str = str(hex_str).strip().lower().replace(':', '').replace(' ', '')
  479. try:
  480. tag = bytes.fromhex(hex_str)
  481. except ValueError:
  482. return {"error": f"port {ant} 卡号十六进制非法: {hex_str!r}"}
  483. if len(tag) != BYTES_PER_TAG:
  484. return {"error": f"port {ant} 卡号必须 {BYTES_PER_TAG} 字节,当前 {len(tag)} 字节: {hex_str!r}"}
  485. data_bytes += tag
  486. written[ant] = hex_str
  487. else:
  488. data_bytes += NO_TAG_BYTES
  489. written[ant] = None
  490. if len(data_bytes) != SET_CARD_DATA_BYTES:
  491. return {"error": f"数据长度异常: {len(data_bytes)} != {SET_CARD_DATA_BYTES}"}
  492. # 构建非标准 0x10 请求帧(无 byte count 字段)
  493. header = bytes([device_address, 0x10]) + struct.pack('>HH', SET_CARD_REG_ADDR, SET_CARD_QUANTITY)
  494. request = header + data_bytes + calculate_crc16(header + data_bytes)
  495. if len(request) != SET_CARD_REQUEST_LEN:
  496. return {"error": f"请求帧长度异常: {len(request)} != {SET_CARD_REQUEST_LEN}"}
  497. logger.info(f"设置卡号帧({len(request)}B): {request.hex()}")
  498. response = self.serial.send_and_wait(
  499. request, timeout=timeout, min_response_bytes=SET_CARD_RESPONSE_LEN
  500. )
  501. if not response or len(response) < 5:
  502. return {"error": "response timeout or too short",
  503. "raw_data": response.hex() if response else ""}
  504. # Modbus 异常响应: addr + 0x90 + exception_code + CRC
  505. if response[1] & 0x80:
  506. return {"error": f"Modbus exception: {response[2]:#x}",
  507. "raw_data": response.hex()}
  508. if len(response) < SET_CARD_RESPONSE_LEN:
  509. return {"error": f"response too short ({len(response)}/{SET_CARD_RESPONSE_LEN})",
  510. "raw_data": response.hex()}
  511. if not verify_crc16(response):
  512. logger.warning(f"设置卡号响应 CRC 失败: {response.hex()}")
  513. return {"error": "CRC check failed", "raw_data": response.hex()}
  514. if response[1] != 0x10:
  515. return {"error": f"非预期功能码: {response[1]:#x}", "raw_data": response.hex()}
  516. resp_start = struct.unpack('>H', response[2:4])[0]
  517. resp_qty = struct.unpack('>H', response[4:6])[0]
  518. if resp_start != SET_CARD_REG_ADDR or resp_qty != SET_CARD_QUANTITY:
  519. return {"error": f"响应地址/数量不匹配: start={resp_start:#x} qty={resp_qty:#x}",
  520. "raw_data": response.hex()}
  521. return {
  522. "success": True,
  523. "device_address": response[0],
  524. "function_code": 0x10,
  525. "cards_written": written,
  526. "raw_data": response.hex()
  527. }
  528. def read_holding_registers(self, device_address: int, start_address: int, quantity: int = 1, timeout: float = None) -> dict:
  529. """读取保持寄存器"""
  530. request_data = struct.pack('>HH', start_address, quantity)
  531. request = self._build_request(device_address, 0x03, request_data)
  532. result = self._send_receive(request, timeout=timeout)
  533. if 'error' in result:
  534. return result
  535. data_str = result.get('data', '')
  536. data_bytes = bytes.fromhex(data_str) if isinstance(data_str, str) and data_str else b''
  537. registers = []
  538. for i in range(0, len(data_bytes), 2):
  539. if i + 1 < len(data_bytes):
  540. registers.append(struct.unpack('>H', data_bytes[i:i+2])[0])
  541. return {'registers': registers, **result}
  542. def write_single_register(self, device_address: int, register_address: int, value: int, timeout: float = None) -> dict:
  543. """写单个寄存器"""
  544. request_data = struct.pack('>HH', register_address, value)
  545. request = self._build_request(device_address, 0x06, request_data)
  546. return self._send_receive(request, timeout=timeout)
  547. def set_rgb_led(self, device_address: int, led_number: int, color: int, timeout: float = None) -> dict:
  548. """设置RGB灯
  549. Register 0x0001, value = (led_number << 8) | color
  550. color: 0=off, 1=flashing red, 2=flashing green, 3=flashing blue
  551. """
  552. value = (led_number << 8) | (color & 0xFF)
  553. return self.write_single_register(device_address, 0x0001, value, timeout)
  554. def scan_devices(self, max_address: int = 247) -> list:
  555. """scan online devices using Modbus 03"""
  556. import time
  557. devices = []
  558. for addr in range(1, min(max_address + 1, 248)):
  559. request = self._build_request(addr, 0x03, struct.pack('>HH', 0x0000, 0x0001))
  560. response = self.serial.send_and_wait(request, timeout=0.3, min_response_bytes=5)
  561. if response and len(response) >= 5 and verify_crc16(response):
  562. devices.append(addr)
  563. return devices