"""MODBUS-RTU 协议实现(线架/配线架 V5 协议,20261023)。 V5 关键变化(相对 V4): 1. 取消"广播发现 + 自动分配地址"(00 40 / 00 41 / 00 42 / 00 43) 流程; 地址改由现场用"配置卡"写入线架(DTU 可让线架进入配置地址状态)。 2. DTU 定时按固定地址查询线架: 0x80 查询: [add][0x80][12 字节 UID][CRC_L][CRC_H] - 已绑定地址 -> 携带绑定的 UID - 未绑定地址 -> UID 为 12 字节全 0(探测) 0x81 应答: [add][0x81][12 字节 UID][CRC_L][CRC_H](线架自身 UID) 0x82 确认: [add][0x82][12 字节 UID][CRC_L][CRC_H](DTU 确认绑定) 0x83 应答: [add][0x83][12 字节 UID][CRC_L][CRC_H] 3. 读卡 0x03 回归标准 MODBUS(不再在帧内携带 UID): 请求 8B: [add][0x03][0x00][0x02][0x00][0x48][CRC_L][CRC_H] 响应 149B:[add][0x03][0x90][144 数据字节][CRC_L][CRC_H] 每张卡 6 字节(硬件卡号,12 位十六进制);无卡标记 = FF FF FF FF FF FF 4. 支持让线架进入"配置地址状态"(读配置卡设置地址): 发送: AA B7 00 07 80 00 00 FF 00 00 02 64 03 应答: 55 00 00 02 [ANTLIST] [ADDR] [XOR] 03 ANTLIST = 读到配置卡的天线号(1~24),ADDR = 配置的地址 XOR = 0x55 起到 ADDR 的异或和 注: 硬件通信固定 6 字节卡号;对 MQTT 的 8 字节(16 位) jumper_uid 适配在 app.py 边界完成(前 4 位 DTU 号 + 后 12 位卡号)。 """ from typing import Optional import threading import struct import logging logger = logging.getLogger('serial_mqtt_gateway') # ========== CRC16 (MODBUS) ========== def calculate_crc16(data: bytes) -> bytes: """计算Modbus CRC16校验(低字节在前)""" crc = 0xFFFF for byte in data: crc ^= byte for _ in range(8): if crc & 0x0001: crc = (crc >> 1) ^ 0xA001 else: crc >>= 1 return struct.pack(' bool: """验证Modbus CRC16校验""" if len(data) < 2: return False received_crc = struct.unpack(' 线架:地址查询 ADDRESS_QUERY_RESP_FC = 0x81 # 线架 -> DTU:查询应答(携带自身 UID) ADDRESS_CONFIRM_FC = 0x82 # DTU -> 线架:确认绑定 ADDRESS_CONFIRM_RESP_FC = 0x83 # 线架 -> DTU:确认应答 ADDRESS_FRAME_LEN = 16 # add(1)+fc(1)+uid(12)+crc(2) ZERO_UID = b'\x00' * 12 # 未绑定地址探测用 UID(12 字节全 0) UID_BYTES = 12 def _uid_bytes(uid) -> bytes: """把 UID 规范化为 12 字节。None -> 全 0;str/bytes 均可。""" if uid is None: return ZERO_UID if isinstance(uid, str): uid = uid.strip().replace(':', '').replace(' ', '').replace('-', '') try: uid = bytes.fromhex(uid) except ValueError: raise ValueError(f"UID 十六进制非法: {uid!r}") if not isinstance(uid, (bytes, bytearray)): raise ValueError(f"UID 类型非法: {type(uid)}") if len(uid) != UID_BYTES: raise ValueError(f"UID长度必须是{UID_BYTES}字节,当前: {len(uid)}") return bytes(uid) def build_address_query_request(device_address: int, uid=None) -> bytes: """构建 V5 地址查询请求(0x80,16 字节)。 格式: [add][0x80][12 字节 UID][CRC_L][CRC_H] uid=None 表示 12 字节全 0(未绑定地址探测)。 文档示例: 01 80 00*12 54 01 """ data = bytes([device_address, ADDRESS_QUERY_FC]) + _uid_bytes(uid) return data + calculate_crc16(data) def parse_address_query_response(data: bytes) -> dict: """解析 V5 地址查询应答(0x81,16 字节)。 格式: [add][0x81][12 字节 UID][CRC_L][CRC_H] 文档示例: 01 81 51 00 12 00 11 00 00 4C 30 31 33 56 D0 D3 返回: {'success': True, 'device_address', 'uid': '24位hex'|None, 'raw_data'} UID 全 0 / 全 FF 视为无效(uid=None)。 """ if not data or len(data) < ADDRESS_FRAME_LEN: return {'error': '数据长度不足', 'raw_data': data.hex() if data else ''} frame = data[:ADDRESS_FRAME_LEN] if frame[1] != ADDRESS_QUERY_RESP_FC: return {'error': f"非预期功能码: {frame[1]:#x}", 'raw_data': frame.hex()} if not verify_crc16(frame): return {'error': 'CRC校验失败', 'raw_data': frame.hex()} uid = frame[2:14] valid = uid not in (b'\x00' * 12, b'\xff' * 12) return { 'success': True, 'device_address': frame[0], 'uid': uid.hex() if valid else None, 'raw_data': frame.hex(), } def build_address_confirm_request(device_address: int, uid) -> bytes: """构建 V5 地址确认请求(0x82,16 字节)。 格式: [add][0x82][12 字节 UID][CRC_L][CRC_H] 文档示例: 01 82 51 00 12 00 11 00 00 4C 30 31 33 56 D5 10 """ data = bytes([device_address, ADDRESS_CONFIRM_FC]) + _uid_bytes(uid) return data + calculate_crc16(data) def parse_address_confirm_response(data: bytes) -> dict: """解析 V5 地址确认应答(0x83,16 字节)。 格式: [add][0x83][12 字节 UID][CRC_L][CRC_H] 文档示例: 01 83 51 00 12 00 11 00 00 4C 30 31 33 56 D7 91 """ if not data or len(data) < ADDRESS_FRAME_LEN: return {'error': '数据长度不足', 'raw_data': data.hex() if data else ''} frame = data[:ADDRESS_FRAME_LEN] if frame[1] != ADDRESS_CONFIRM_RESP_FC: return {'error': f"非预期功能码: {frame[1]:#x}", 'raw_data': frame.hex()} if not verify_crc16(frame): return {'error': 'CRC校验失败', 'raw_data': frame.hex()} uid = frame[2:14] valid = uid not in (b'\x00' * 12, b'\xff' * 12) return { 'success': True, 'device_address': frame[0], 'uid': uid.hex() if valid else None, 'raw_data': frame.hex(), } # ========== V5 配置地址状态(非 MODBUS 帧,用于刷配置卡设置地址) ========== # 文档帧: aa b7 00 07 80 00 00 ff 00 00 02 64 03 # 帧头 AA B7 + 7 字节数据 + 0x64(帧内固定校验/参数, 按文档原样发送) + 0x03 结尾 CONFIG_ADDRESS_ENTER_FRAME = bytes.fromhex('aab70007800000ff0000026403') # 应答帧: 55 00 00 02 ANTLIST ADDR XOR 03 (8 字节) CONFIG_ADDRESS_RESPONSE_LEN = 8 CONFIG_ADDRESS_HEADER = 0x55 CONFIG_ADDRESS_TAIL = 0x03 def build_config_address_enter_frame() -> bytes: """让线架进入"配置地址状态"(等待刷配置卡)的广播帧。""" return CONFIG_ADDRESS_ENTER_FRAME def _parse_config_address_frame(frame: bytes) -> Optional[dict]: """解析单个 8 字节配置卡应答帧,失败返回 None。""" if len(frame) < CONFIG_ADDRESS_RESPONSE_LEN: return None head = frame[0] ant = frame[4] addr = frame[5] xor = frame[6] tail = frame[7] if head != CONFIG_ADDRESS_HEADER or tail != CONFIG_ADDRESS_TAIL: return None if not (1 <= ant <= 24) or not (0 <= addr <= 247): return None expect = 0 for b in frame[:6]: # XOR = 0x55 起直到 ADDR expect ^= b if expect != xor: return None return { 'success': True, 'antenna': ant, 'address': addr, 'raw_data': frame.hex(), } def parse_config_address_response(data: bytes) -> dict: """在收到的数据中查找配置卡应答帧。 格式: 55 00 00 02 [ANTLIST] [ADDR] [XOR] 03 ANTLIST: 读到配置卡的天线号(1 开始) ADDR : 配置的地址 XOR : 0x55 起到 ADDR 的异或和 返回 {'success': True, 'antenna', 'address', 'raw_data'} 或 {'error': ...} """ if not data: return {'error': '无数据', 'raw_data': ''} if len(data) < CONFIG_ADDRESS_RESPONSE_LEN: return {'error': f'数据长度不足 ({len(data)}/{CONFIG_ADDRESS_RESPONSE_LEN})', 'raw_data': data.hex()} for i in range(len(data) - CONFIG_ADDRESS_RESPONSE_LEN + 1): parsed = _parse_config_address_frame(data[i:i + CONFIG_ADDRESS_RESPONSE_LEN]) if parsed: return parsed return {'error': '未找到有效的配置卡应答帧', 'raw_data': data.hex()} # ========== 线架绑定表 / 总线互斥 ========== class AddressConfigProtocol: """线架地址↔UID 绑定表 + 总线配置互斥锁。 V5 起不再提供广播发现/自动分配地址,仅保留绑定表持久化与 "配置地址期间占用总线"的互斥锁。 """ def __init__(self, serial_port): self.serial = serial_port self.default_timeout = 5.0 self.stored_devices = {} # {uid_hex: address} self.config_lock = threading.RLock() def add_stored_device(self, uid: str, address: int): """添加已存储的设备""" self.stored_devices[uid] = address def get_stored_devices(self) -> dict: """获取已存储的设备列表""" return self.stored_devices.copy() def save_config(self, filepath: str) -> bool: """保存配置到文件""" import json try: with open(filepath, 'w') as f: json.dump(self.stored_devices, f, indent=2) return True except Exception as e: logger.error(f"保存配置失败: {e}") return False def load_config(self, filepath: str) -> bool: """从文件加载配置""" import json try: with open(filepath, 'r') as f: self.stored_devices = json.load(f) return True except Exception as e: logger.error(f"加载配置失败: {e}") return False # ========== V5 批量读卡 / 设置卡号协议常量 ========== CARD_REG_ADDR = 0x0002 # 批量卡号读起始寄存器 CARD_REG_QUANTITY = 0x48 # 72 寄存器 = 144 字节 CARD_DATA_BYTES = 144 # 24 天线 × 6 字节 BYTES_PER_TAG = 6 ANTENNA_COUNT = 24 NO_TAG_BYTES = b'\xff' * 6 # 无卡标记 NO_TAG_HEX = 'ffffffffffff' BULK_BYTE_COUNT = 0x90 # 144,Modbus 响应字节计数字段 BULK_REQUEST_LEN = 8 # addr(1)+fc(1)+start(2)+qty(2)+crc(2) BULK_RESPONSE_LEN = 149 # addr(1)+fc(1)+bytecount(1)+data(144)+crc(2) # 过渡期兼容:V4 旧固件响应尾部还带 12 字节 UID(161 字节) LEGACY_UID_RESPONSE_LEN = 161 # 设置卡号协议常量(非标准 MODBUS 0x10) # 协议帧: [addr][0x10][0x00][0x03][0x00][0x90][144字节数据][CRC_L][CRC_H] # 注意: 与标准 MODBUS 0x10 不同,此处省略 byte count 字段,数量字段 0x0090 直接表示字节数(144) SET_CARD_REG_ADDR = 0x0003 # 设置卡号起始寄存器 SET_CARD_QUANTITY = 0x0090 # 数量字段 = 144(字节数,非寄存器数) SET_CARD_DATA_BYTES = 144 # 24 路 × 6 字节 SET_CARD_REQUEST_LEN = 152 # addr(1)+fc(1)+start(2)+qty(2)+data(144)+crc(2) SET_CARD_RESPONSE_LEN = 8 # addr(1)+fc(1)+start(2)+qty(2)+crc(2) # 天线地址映射表(天线编号 -> Modbus寄存器地址) # 所有天线共享寄存器 0x0002,由 read_all_antenna_cards 一次批量读出 ANTENNA_ADDRESSES = {i: CARD_REG_ADDR for i in range(1, 25)} def build_read_cards_request(device_address: int) -> bytes: """构建 V5 批量读卡请求(标准 MODBUS 0x03,8 字节)。 格式: [add][0x03][0x00][0x02][0x00][0x48][CRC_L][CRC_H] 文档示例: 01 03 00 02 00 48 E4 3C """ data = bytes([device_address, 0x03]) + struct.pack('>HH', CARD_REG_ADDR, CARD_REG_QUANTITY) return data + calculate_crc16(data) class ModbusRTUClient: """Modbus RTU 客户端""" def __init__(self, serial_port): self.serial = serial_port self.default_timeout = 2.0 self.test_cards = None # 测试注入:非 None 时 read_all_antenna_cards 返回构造数据 self.test_panel_uids = None # 测试注入:{addr: 'hex24'} 模拟线架自身 UID(query_address 用) def _build_request(self, device_address: int, function_code: int, data: bytes = b'') -> bytes: """构建Modbus请求帧""" pdu = bytes([device_address, function_code]) + data return pdu + calculate_crc16(pdu) def _send_receive(self, request: bytes, expected_min_len: int = 5, timeout: float = None) -> dict: """send request and receive response using sync method""" timeout = timeout or self.default_timeout if not self.serial.ser: return {"error": "serial not connected"} response = self.serial.send_and_wait(request, timeout=timeout, min_response_bytes=expected_min_len) if not response or len(response) < expected_min_len: return {"error": "response timeout or too short", "raw_data": response.hex() if response else ""} if not verify_crc16(response): logger.warning(f"CRC check failed: {response.hex()}") return {"error": "CRC check failed", "raw_data": response.hex()} return { "success": True, "device_address": response[0], "function_code": response[1], "data": response[2:-2].hex(), "raw_data": response.hex() } # ----- V5 地址查询 / 确认 ----- def query_address(self, device_address: int, uid=None, timeout: float = None) -> dict: """V5 地址查询(0x80)。 Args: device_address: 要查询的固定地址 uid: 已绑定的 UID(str/bytes);None -> 12 字节全 0 探测 Returns: {'success': True, 'device_address', 'uid': '24位hex'|None, 'raw_data'} 或 {'error': ...} """ if self.test_panel_uids is not None: # 测试注入:按地址返回模拟线架 UID(未列出的地址视为无应答) simulated = self.test_panel_uids.get(device_address) if simulated is None: return {"error": "response timeout or too short", "raw_data": ""} return { "success": True, "device_address": device_address, "uid": str(simulated).lower(), "raw_data": "TEST_INJECTED", } timeout = timeout or self.default_timeout if not self.serial.ser: return {"error": "serial not connected"} try: request = build_address_query_request(device_address, uid) except ValueError as e: return {"error": str(e)} response = self.serial.send_and_wait( request, timeout=timeout, min_response_bytes=ADDRESS_FRAME_LEN ) if not response: return {"error": "response timeout or too short", "raw_data": ""} return parse_address_query_response(response) def confirm_address(self, device_address: int, uid, timeout: float = None) -> dict: """V5 地址确认(0x82):DTU 确认"地址↔UID"绑定。""" if self.test_panel_uids is not None: return {"success": True, "device_address": device_address, "uid": str(uid).lower() if uid else None, "raw_data": "TEST_INJECTED"} timeout = timeout or self.default_timeout if not self.serial.ser: return {"error": "serial not connected"} try: request = build_address_confirm_request(device_address, uid) except ValueError as e: return {"error": str(e)} response = self.serial.send_and_wait( request, timeout=timeout, min_response_bytes=ADDRESS_FRAME_LEN ) if not response: return {"error": "response timeout or too short", "raw_data": ""} return parse_address_confirm_response(response) # ----- V5 批量读卡 ----- def read_all_antenna_cards(self, device_address: int, timeout: float = None) -> dict: """V5: 批量读取全部 24 路天线卡号(标准 MODBUS 0x03)。 寄存器 0x0002,数量 0x48(72 寄存器 = 144 字节)。 请求 8B: [addr][0x03][0x00][0x02][0x00][0x48][CRC_L][CRC_H] 响应 149B:[addr][0x03][0x90][144 数据字节][CRC_L][CRC_H] 每张卡 6 字节(硬件卡号,12 位十六进制);无卡标记 = 6×0xFF。 过渡期兼容: V4 旧固件 161B 响应(尾部多 12 字节 UID)仍可解析, UID 字段在此层忽略(地址↔UID 绑定走 0x80/0x82 查询确认)。 返回: {'success': True, 'device_address', 'function_code': 0x03, 'cards': [{'antenna', 'card_str', 'present', 'uid'}, ...24], 'raw_data'} """ # 测试注入: test_cards = {addr: {port_id: 'hex12'|None, ...}, ...} if self.test_cards is not None: panel_map = self.test_cards.get(device_address) if panel_map is not None: cards = [] for i in range(ANTENNA_COUNT): ant = i + 1 hex_str = panel_map.get(ant) if hex_str: tag = bytes.fromhex(hex_str) cards.append({ 'antenna': ant, 'card_str': tag.hex(), 'present': True, 'uid': ':'.join(f'{b:02x}' for b in tag) }) else: cards.append({ 'antenna': ant, 'card_str': '', 'present': False, 'uid': '' }) return { "success": True, "device_address": device_address, "function_code": 0x03, "cards": cards, "raw_data": "TEST_INJECTED" } timeout = timeout or self.default_timeout if not self.serial.ser: return {"error": "serial not connected"} request = build_read_cards_request(device_address) response = self.serial.send_and_wait( request, timeout=timeout, min_response_bytes=BULK_RESPONSE_LEN ) if not response or len(response) < 5: return {"error": "response timeout or too short", "raw_data": response.hex() if response else ""} # Modbus 异常响应: addr + 0x83 + exception_code + CRC if response[1] & 0x80: return {"error": f"Modbus exception: {response[2]:#x}", "raw_data": response.hex()} frame = None if (len(response) >= BULK_RESPONSE_LEN and response[1] == 0x03 and response[2] == BULK_BYTE_COUNT and verify_crc16(response[:BULK_RESPONSE_LEN])): frame = response[:BULK_RESPONSE_LEN] elif len(response) >= LEGACY_UID_RESPONSE_LEN and verify_crc16( response[:LEGACY_UID_RESPONSE_LEN]): # 过渡期兼容:V4 旧固件 161B 响应(无 UID 使用价值,仅解析卡数据) logger.debug("收到旧格式(161B)批量读卡响应,UID 字段已忽略") frame = response[:BULK_RESPONSE_LEN] else: if len(response) < BULK_RESPONSE_LEN: return {"error": f"response too short ({len(response)}/{BULK_RESPONSE_LEN})", "raw_data": response.hex()} return {"error": "CRC check failed", "raw_data": response.hex()} if frame[1] != 0x03 or frame[2] != BULK_BYTE_COUNT: return {"error": f"unexpected response: fc={frame[1]:#x} count={frame[2]:#x}", "raw_data": frame.hex()} tag_data = frame[3:3 + CARD_DATA_BYTES] # 144 字节 cards = [] for i in range(ANTENNA_COUNT): tag = tag_data[i * BYTES_PER_TAG:(i + 1) * BYTES_PER_TAG] # 6 字节 present = tag != NO_TAG_BYTES cards.append({ 'antenna': i + 1, 'card_str': tag.hex() if present else '', 'present': present, 'uid': ':'.join(f'{b:02x}' for b in tag) if present else '' }) return { "success": True, "device_address": frame[0], "function_code": 0x03, "cards": cards, "raw_data": frame.hex() } def read_antenna_card(self, device_address: int, antenna_num: int, timeout: float = None) -> dict: """读取单根天线卡号(由批量读提取,不再发逐天线帧)。 调用 read_all_antenna_cards 后提取指定天线,返回兼容 schema。 无卡时 card_number_str 为空串。 """ if antenna_num < 1 or antenna_num > ANTENNA_COUNT: return {"error": f"invalid antenna number: {antenna_num}, must be 1-{ANTENNA_COUNT}"} result = self.read_all_antenna_cards(device_address, timeout=timeout) if 'error' in result: return result card = next((c for c in result.get('cards', []) if c['antenna'] == antenna_num), None) if card is None: return {"error": f"antenna {antenna_num} not found in bulk response", "raw_data": result.get('raw_data', '')} base = {k: v for k, v in result.items() if k != 'cards'} if card['present']: tag_bytes = bytes.fromhex(card['card_str']) # 6 字节 card_number = int.from_bytes(tag_bytes, 'big') return { 'card_number': card_number, 'card_number_hex': f'0x{card_number:012x}', 'card_number_str': card['card_str'], 'antenna': antenna_num, 'uid': card['uid'], **base } return { 'card_number': 0, 'card_number_hex': '0x000000000000', 'card_number_str': '', 'antenna': antenna_num, 'uid': '', **base } def set_card_mapping(self, device_address: int, card_mappings: dict, timeout: float = None) -> dict: """设置24路天线卡号(0x10 写 0x0003,144字节,非标准MODBUS无bytecount)。 协议帧(发送): [addr][0x10][0x00][0x03][0x00][0x90][144字节数据][CRC_L][CRC_H] 协议帧(响应): [addr][0x10][0x00][0x03][0x00][0x90][CRC_L][CRC_H] Args: device_address: 从机地址 card_mappings: {port_id(1-24): 'hex12' or None} 未提供或 None 的端口填 0xFF*6(无卡标记) Returns: {'success': True, 'device_address', 'raw_data', 'cards_written'} 或 {'error': ...} """ timeout = timeout or self.default_timeout if not self.serial.ser: return {"error": "serial not connected"} # 构建 24 路 × 6 字节 = 144 字节数据 data_bytes = b'' written = {} for ant in range(1, ANTENNA_COUNT + 1): hex_str = card_mappings.get(ant) if hex_str: hex_str = str(hex_str).strip().lower().replace(':', '').replace(' ', '') try: tag = bytes.fromhex(hex_str) except ValueError: return {"error": f"port {ant} 卡号十六进制非法: {hex_str!r}"} if len(tag) != BYTES_PER_TAG: return {"error": f"port {ant} 卡号必须 {BYTES_PER_TAG} 字节,当前 {len(tag)} 字节: {hex_str!r}"} data_bytes += tag written[ant] = hex_str else: data_bytes += NO_TAG_BYTES written[ant] = None if len(data_bytes) != SET_CARD_DATA_BYTES: return {"error": f"数据长度异常: {len(data_bytes)} != {SET_CARD_DATA_BYTES}"} # 构建非标准 0x10 请求帧(无 byte count 字段) header = bytes([device_address, 0x10]) + struct.pack('>HH', SET_CARD_REG_ADDR, SET_CARD_QUANTITY) request = header + data_bytes + calculate_crc16(header + data_bytes) if len(request) != SET_CARD_REQUEST_LEN: return {"error": f"请求帧长度异常: {len(request)} != {SET_CARD_REQUEST_LEN}"} logger.info(f"设置卡号帧({len(request)}B): {request.hex()}") response = self.serial.send_and_wait( request, timeout=timeout, min_response_bytes=SET_CARD_RESPONSE_LEN ) if not response or len(response) < 5: return {"error": "response timeout or too short", "raw_data": response.hex() if response else ""} # Modbus 异常响应: addr + 0x90 + exception_code + CRC if response[1] & 0x80: return {"error": f"Modbus exception: {response[2]:#x}", "raw_data": response.hex()} if len(response) < SET_CARD_RESPONSE_LEN: return {"error": f"response too short ({len(response)}/{SET_CARD_RESPONSE_LEN})", "raw_data": response.hex()} if not verify_crc16(response): logger.warning(f"设置卡号响应 CRC 失败: {response.hex()}") return {"error": "CRC check failed", "raw_data": response.hex()} if response[1] != 0x10: return {"error": f"非预期功能码: {response[1]:#x}", "raw_data": response.hex()} resp_start = struct.unpack('>H', response[2:4])[0] resp_qty = struct.unpack('>H', response[4:6])[0] if resp_start != SET_CARD_REG_ADDR or resp_qty != SET_CARD_QUANTITY: return {"error": f"响应地址/数量不匹配: start={resp_start:#x} qty={resp_qty:#x}", "raw_data": response.hex()} return { "success": True, "device_address": response[0], "function_code": 0x10, "cards_written": written, "raw_data": response.hex() } def read_holding_registers(self, device_address: int, start_address: int, quantity: int = 1, timeout: float = None) -> dict: """读取保持寄存器""" request_data = struct.pack('>HH', start_address, quantity) request = self._build_request(device_address, 0x03, request_data) result = self._send_receive(request, timeout=timeout) if 'error' in result: return result data_str = result.get('data', '') data_bytes = bytes.fromhex(data_str) if isinstance(data_str, str) and data_str else b'' registers = [] for i in range(0, len(data_bytes), 2): if i + 1 < len(data_bytes): registers.append(struct.unpack('>H', data_bytes[i:i+2])[0]) return {'registers': registers, **result} def write_single_register(self, device_address: int, register_address: int, value: int, timeout: float = None) -> dict: """写单个寄存器""" request_data = struct.pack('>HH', register_address, value) request = self._build_request(device_address, 0x06, request_data) return self._send_receive(request, timeout=timeout) def set_rgb_led(self, device_address: int, led_number: int, color: int, timeout: float = None) -> dict: """设置RGB灯 Register 0x0001, value = (led_number << 8) | color color: 0=off, 1=flashing red, 2=flashing green, 3=flashing blue """ value = (led_number << 8) | (color & 0xFF) return self.write_single_register(device_address, 0x0001, value, timeout) def scan_devices(self, max_address: int = 247) -> list: """scan online devices using Modbus 03""" import time devices = [] for addr in range(1, min(max_address + 1, 248)): request = self._build_request(addr, 0x03, struct.pack('>HH', 0x0000, 0x0001)) response = self.serial.send_and_wait(request, timeout=0.3, min_response_bytes=5) if response and len(response) >= 5 and verify_crc16(response): devices.append(addr) return devices