| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687 |
- """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('<H', crc)
- def verify_crc16(data: bytes) -> bool:
- """验证Modbus CRC16校验"""
- if len(data) < 2:
- return False
- received_crc = struct.unpack('<H', data[-2:])[0]
- calculated_crc = struct.unpack('<H', calculate_crc16(data[:-2]))[0]
- return received_crc == calculated_crc
- # ========== V5 地址查询 / 确认协议(0x80 / 0x81 / 0x82 / 0x83) ==========
- ADDRESS_QUERY_FC = 0x80 # DTU -> 线架:地址查询
- 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
|