kicer/app_rf915_dump
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

backup

Browse Source
This commit is contained in:
kicer
2026-04-15 09:30:07 +08:00
parent 7e9f9b5f25
commit a9f0b97d26
3 changed files with 534 additions and 292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

296
protocol.md
View File

@@ -1,4 +1,4 @@
# MT6 RFID 读卡器 USB HID 私有协议参考文档
# MT6 RFID 读卡器 USB HID 私有协议参考文档（最终修正版）
## 1. 概述
@@ -12,50 +12,48 @@
主机发送的命令帧结构如下（从 Report ID 后开始计算偏移）。**SetReq 必须填充至 256 字节**，不足部分用 `0x00` 补齐。
| 偏移 | 长度 | 字段名 | 说明 |
|:---|:---|:---|:---|
| 0x00 | 1 | Report ID | 固定 `0x01` |
| 0x01 | 4 | Fixed | 固定 `0x00 0x00 0x00 0x00` |
| 0x05 | 2 | Frame Length | 从下一字段（`0x07`）到数据末尾（不含校验和结束符）的总字节数，小端序 |
| 0x07 | 2 | Constant | 固定 `0x00 0x02` |
| 0x09 | 2 | Data Length | 后续数据负载的字节数，小端序 |
| 0x0B | N | Data | 实际数据负载（命令参数） |
| 0x0B+N | 1 | Checksum | 校验字节，计算方法见第 3 节 |
| 0x0C+N | 1 | End Marker | 固定 `0x03` |
| 剩余 | - | Padding | 填充 `0x00` 至 **256 字节** |
| 偏移 | 长度 | 字段名 | 字节序 | 示例（打开蜂鸣器） | 说明 |
|:---|:---|:---|:---|:---|:---|
| 0x00 | 1 | Report ID | - | `01` | 固定 `0x01` |
| 0x01 | 4 | Fixed | - | `00 00 00 00` | 固定 |
| 0x05 | 2 | Frame Length | **大端** | `00 07` | 从Constant到Data的总字节数 |
| 0x07 | 2 | Constant | - | `00 02` | 固定 `0x00 0x02` |
| 0x09 | 2 | Data Length | **大端** | `00 02` | 后续数据负载的字节数 |
| 0x0B | N | Data | - | `cd 01` | 实际数据负载 |
| 0x0B+N | 1 | Checksum | - | `ce` | 校验字节，算法见第 3 节 |
| 0x0C+N | 1 | End Marker | - | `03` | 固定 `0x03` |
| 剩余 | - | Padding | - | `00 ...` | 填充至 **256 字节** |
### 2.2 GetRes（设备 → 主机，Report ID = 0x03）
设备返回的数据帧结构与 SetReq 相同，但 **GetRes 无需填充至 256 字节**，其实际有效长度由 USB 传输层决定。
设备返回的数据帧结构与 SetReq 相同，但 **GetRes 无需填充至 256 字节**。
**通用 Data 段格式**：
**Data 段格式**：
| 偏移（相对 Data 段起点） | 长度 | 字段名 | 说明 |
| 偏移 | 长度 | 字段名 | 说明 |
|:---|:---|:---|:---|
| 0x00 | 1 | Status | 状态字节。`0x00` 表示成功，非零表示异常 |
| 0x01 | M | Response Data | 实际返回数据（长度由 Data Length - 1 决定） |
| 0x00 | 1 | Status | `0x00` 成功，非零异常 |
| 0x01 | M | Response Data | 实际返回数据 |
## 3. 校验算法
### 3.1 外层帧校验
**计算范围**：`Data Length` 字段的 2 个字节 + `Data` 字段的全部 N 个字节。
**算法**：逐字节异或（XOR）。
**算法**：逐字节异或（XOR）
**计算范围**：`Data Length` 两字节+ `Data` 全部字节。
```python
def calc_outer_checksum(data_len_bytes: bytes, payload: bytes) -> int:
result = 0
for b in data_len_bytes + payload:
result ^= b
return result
```
**验证示例**（打开蜂鸣器）：
- Data Length: `00 02`
- Data: `cd 01`
- XOR: `00 ^ 02 ^ cd ^ 01 = ce` ✅
### 3.2 EPC 操作内部校验
#### 3.2.1 Payload Checksum（累加和）
**计算范围**：从 Card Op Command 字段开始，到 Payload 末尾（不含校验字节自身）。
**算法**：所有字节累加（无符号 8 位溢出，即模 256）。
**算法**：字节累加模 256
**计算范围**：从 Card Op Command 字段开始，到 Payload 末尾（不含校验字节自身）。
#### 3.2.2 EPC CRC
@@ -64,191 +62,157 @@ def calc_outer_checksum(data_len_bytes: bytes, payload: bytes) -> int:
- 多项式：`0x1021`
- 初始值：`0xFFFF`
- 输出异或：`0xFFFF`
- 输入/输出是否反转：`false` / `false`
- 输入/输出反转：`false`
**计算范围**：EPC Len Indicator（1 字节）+ EPC Status（1 字节）+ EPC Data（N 字节）
```python
import crcmod
crc16_genibus = crcmod.mkCrcFun(0x11021, rev=False, initCrc=0xFFFF, xorOut=0xFFFF)
def calc_epc_crc(epc_len_indicator: int, epc_status: int, epc_data: bytes) -> int:
data = bytes([epc_len_indicator, epc_status]) + epc_data
return crc16_genibus(data)
```
**计算范围**：`EPC Len Indicator`（1 字节）+ `EPC Status`（1 字节）+ `EPC Data`（N 字节）
## 4. 已知命令集
### 4.1 读版本号
以下列出所有已分析命令，仅给出 **Data 段**内容（不含外层帧头），实际发送时需按第 2 节格式包装并填充至 256 字节。
- **功能**：获取设备固件版本字符串。
- **SetReq Data**（1 字节）：`c0`
- **SetReq 完整数据段**（填充前）：
```
01 00 00 00 00 06 00 00 02 01 00 c0 c1 03
```
- **GetRes Data 段**：
```
00 # Status = 成功
4d 54 36 5f 52 46 39 31 35 5f 52 57 ... 20 # ASCII 版本字符串
```
**注意**：版本字符串后的 `0x20` 为外层帧校验字节，`0x03` 为帧结束标志。
### 4.1 系统与配置类命令
| 功能 | SetReq Data | GetRes Data | 备注 |
|:---|:---|:---|:---|
| 读版本号 | `c0` | `00` + ASCII 字符串 | |
| 恢复出厂设置 | `cf` | `00 80` | |
| 读取格式 | `83` | `00 01 00 00 00 01 01 00 00`（示例） | 返回当前格式参数 |
| 设置格式 | `82 0f 00 00 00 01 01 01 00` | `00 80` | 参数含义略 |
### 4.2 蜂鸣器控制
#### 打开蜂鸣器
- **SetReq Data**（2 字节）：`cd 01`
- **SetReq 数据段**：
```
01 00 00 00 00 07 00 00 02 02 00 cd 01 ce 03
```
- **GetRes Data 段**：`00 80`
| 功能 | SetReq Data | GetRes Data |
|:---|:---|:---|
| 打开蜂鸣器 | `cd 01` | `00 80` |
| 关闭蜂鸣器 | `cd 00` | `00 80` |
#### 关闭蜂鸣器
- **SetReq Data**（2 字节）：`cd 00`
- **SetReq 数据段**：
```
01 00 00 00 00 07 00 00 02 02 00 cd 00 cf 03
```
- **GetRes Data 段**：`00 80`
### 4.3 射频电源控制
### 4.3 设置功率
| 功能 | SetReq Data | GetRes Data |
|:---|:---|:---|
| 打开射频 | `90 01` | `00 80` |
| 关闭射频 | `90 00` | `00 80` |
- **功能**：设置发射功率等级（取值范围 0~9）。
- **示例（功率 = 8）SetReq Data**（2 字节）：`cc 08`
- **SetReq 数据段**：
```
01 00 00 00 00 07 00 00 02 02 00 cc 08 c6 03
```
- **GetRes Data 段**：`00 80`
### 4.4 工作模式与功率
### 4.4 设置工作模式
- **功能**：切换读卡器工作模式。
- **SetReq Data**（2 字节）：`0f 0X`，其中 `X` 为模式编号。
- `0f 01`：单标签巡查
- `0f 02`：被动模式
- `0f 03`：多标签巡查
- **示例（被动模式）SetReq 数据段**：
```
01 00 00 00 00 07 00 00 02 02 00 0f 02 0f 03
```
- **GetRes Data 段**：`00 80`
| 功能 | SetReq Data | GetRes Data | 参数说明 |
|:---|:---|:---|:---|
| 设置单标签巡查 | `0f 01` | `00 80` | 模式 1（主动读卡） |
| 设置被动模式 | `0f 02` | `00 80` | 模式 2（被动读卡）|
| 设置多标签巡查 | `0f 03` | `00 80` | 模式 3 |
| 设置功率 = N | `cc N` | `00 80` | N 范围 0~9 |
### 4.5 EPC 操作
所有 EPC 相关命令（读、选中、写）的 SetReq Data 段均遵循以下通用结构：
所有 EPC 相关命令（读、选中、写）的 SetReq/GetRes Data 段均遵循以下内部结构：
| 偏移 | 长度 | 字段名 | 说明 |
|:---|:---|:---|:---|
| 0x00 | 1 | Command | 固定 `ce` |
| 0x01 | 1 | Magic | 固定 `bb` |
| 0x02 | 2 | Card Op Command | 操作码，见各子命令 |
| 0x04 | 2 | Internal Length | 后续 Payload 的字节数（小端） |
| 0x06 | N | Payload | 具体操作参数 |
| 0x06+N | 1 | Payload Checksum | 从 Card Op Command 到 Payload 末尾的累加和（模 256） |
| 0x07+N | 1 | End Marker | 固定 `7e` |
| 偏移 | 长度 | 字段名 | 字节序 | 说明 |
|:---|:---|:---|:---|:---|
| 0x00 | 1 | Command/Status | - | 固定 SetReq=`ce`，GetRes=`00`(成功) |
| 0x01 | 1 | Magic | - | 固定 `bb` |
| 0x02 | 2 | Card Op Command | - | 操作码（见各子命令） |
| 0x04 | 2 | Internal Length | **大端** | 后续 Payload 的字节数 |
| 0x06 | N | Payload | - | 具体操作参数 |
| 0x06+N | 1 | Payload Checksum | - | 累加和（模 256） |
| 0x07+N | 1 | End Marker | - | 固定 `7e` |
#### 4.5.1 读取 EPC
**Card Op Command**：`00 22`
##### SetReq
- Internal Length：`00 00`
- Payload：（无）
- Payload Checksum：`22`
- End Marker：`7e`
- **完整 Data 段**：`ce bb 00 22 00 00 22 7e`
- **SetReq Data**：`ce bb 00 22 00 00 22 7e`
- Internal Length = `00 00`
- Payload Checksum = `22`
##### GetRes
- Data 段结构（有卡）：
- **GetRes Data 段（有卡）**：
```
00 bb 02 22 00 0b d3 18 00 11 22 33 44 55 66 75 ce c2 7e
```
| 偏移 | 字段 | 值示例 | 说明 |
|:---|:---|:---|:---|
| 0x00 | Status | `00` | 成功 |
| 0x01 | Magic | `bb` | 固定 |
| 0x02 | Card Op Resp | `02 22` | 读卡成功标志 |
| 0x04 | Internal Length | `00 0b` | 后续数据长度（大端） |
| 0x06 | RSSI | `d3` | 信号强度 |
| 0x07 | EPC Len Indicator | `18` | EPC 字节数 = 值 ÷ 4 |
| 0x08 | EPC Status | `00` | 成功 |
| 0x09 | EPC Data | `11 22 33 44 55 66` | 实际 EPC |
| 0x0F | EPC CRC | `75 ce` | CRC-16/GENIBUS |
| 0x11 | Payload Checksum | `c2` | 累加和 |
| 0x12 | End Marker | `7e` | 固定尾部 |
| 偏移 | 长度 | 字段名 | 示例值 | 说明 |
|:---|:---|:---|:---|:---|
| 0x00 | 1 | Status | `00` | 成功 |
| 0x01 | 1 | Magic | `bb` | 固定 |
| 0x02 | 2 | Card Op Resp | `02 22` | 读卡成功标志 |
| 0x04 | 2 | Internal Length | `00 0b` | 后续数据长度 |
| 0x06 | 1 | RSSI | `d3` | 信号强度 |
| 0x07 | 1 | EPC Len Indicator | `18` | EPC 字节数 = 该值 ÷ 4 |
| 0x08 | 1 | EPC Status | `00` | 读取状态 |
| 0x09 | N | EPC Data | `11 22 33 44 55 66` | 实际 EPC |
| 0x09+N | 2 | EPC CRC | `75 ce` | CRC-16/GENIBUS |
| 0x0B+N | 1 | Payload Checksum | `c2` | 累加和 |
| 0x0C+N | 1 | End Marker | `7e` | 固定尾部 |
- 无卡时 Card Op Resp 为 `01 ff`，Payload 仅含 RSSI 及累加和。
- **无卡时**：Card Op Resp = `01 ff`，Payload 仅含 RSSI 及累加和，无 EPC 数据。
#### 4.5.2 选中卡
**Card Op Command**：`00 0c`
##### SetReq
- Internal Length：`00 09`
- Payload（9 字节）：
- 偏移 0x00~0x05：保留字段（`01 00 00 00 20 10`）
- 偏移 0x06~0x07：EPC Data（如 `11 22`）
- **完整 Data 段示例**：`ce bb 00 0c 00 09 01 00 00 00 20 10 00 11 22 79 7e`
- **SetReq Data 示例**（选中 EPC `11 22`）：
```
ce bb 00 0c 00 09 01 00 00 00 20 10 00 11 22 79 7e
```
- Internal Length = `00 09`
- Payload（7+N 字节）：7字节保留字段 + EPC Data
- Payload Checksum = `79`
##### GetRes
- Data 段：
- **GetRes Data 段**：
```
00 bb 01 0c 00 01 00 0e 7e
```
- Card Op Resp：`01 0c`
- Internal Length：`00 01`
- Payload：`00`（选中成功标志）
- Payload Checksum：`0e`
- Card Op Resp = `01 0c`
- Internal Length = `00 01`
- Payload = `00`（选中成功标志）
#### 4.5.3 写入 EPC
**Card Op Command**：`00 49`
##### SetReq
- Internal Length：`00 0f`
- Payload（15 字节）：
| 偏移 | 长度 | 字段名 | 示例值 | 说明 |
|:---|:---|:---|:---|:---|
| 0x00 | 6 | Reserved | `00 00 00 00 01 00` | 保留 |
| 0x06 | 1 | Word Count | `03` | = 2 + 新 EPC 字节数/2 |
| 0x07 | 2 | Old EPC CRC | `ca 9e` | 原卡 EPC 的 CRC-16/GENIBUS |
| 0x09 | 1 | EPC Len Indicator | `08` | 新 EPC 字节数 = 值 ÷ 4 |
| 0x0A | 1 | EPC Status | `00` | 固定 |
| 0x0B | N | New EPC Data | `11 23` | 新 EPC |
- Payload Checksum：`00`
- End Marker：`7e`
- **完整 Data 段示例**：
- **SetReq Data 示例**（将 EPC `11 22` 改为 `11 23`）：
```
ce bb 00 49 00 0f 00 00 00 00 01 00 00 00 03 ca 9e 08 00 11 23 00 7e
```
- Internal Length = `00 0f`
- Payload（15 字节）：
| 偏移 | 字段 | 值示例 | 说明 |
|:---|:---|:---|:---|
| 0x00 | Reserved | `00 00 00 00 01 00 00 00` | 保留 |
| 0x09 | Word Count | `03` | = 2 + 新 EPC 字节数/2 |
| 0x0A | Old EPC CRC | `ca 9e` | 原卡 EPC 的 CRC-16/GENIBUS（大端） |
| 0x0C | EPC Len Indicator | `08` | 新 EPC 字节数 = 值 ÷ 4 |
| 0x0D | EPC Status | `00` | 固定 |
| 0x0E | New EPC Data | `11 23` | 新 EPC |
- Payload Checksum = `00`
##### GetRes
- Data 段：
- **GetRes Data 段**：
```
00 bb 01 49 00 06 04 08 00 11 22 00 8f 7e
```
- Card Op Resp：`01 49`（写卡成功）
- Internal Length：`00 06`
- Payload：包含原 EPC `11 22` 等信息，用于确认
- Card Op Resp = `01 49`
- Payload 偏移0x03中开始原 EPC `11 22` 用于确认
## 5. 附录：命令速查表
## 5. 附录：命令速查表（SetReq Data 部分）
| 功能 | SetReq Data（十六进制） | 说明 |
|:---|:---|:---|
| 读版本号 | `c0` | 返回 ASCII 字符串 |
| 打开蜂鸣器 | `cd 01` | |
| 关闭蜂鸣器 | `cd 00` | |
| 设置功率 = 8 | `cc 08` | 取值范围 0~9 |
| 设置单标签巡查 | `0f 01` | |
| 设置被动模式 | `0f 02` | |
| 设置多标签巡查 | `0f 03` | |
| 读取 EPC | `ce bb 00 22 00 00 22 7e` | 返回 EPC 数据 |
| 选中卡（EPC=1122） | `ce bb 00 0c 00 09 01 00 00 00 20 10 00 11 22 79 7e` | Payload Checksum 需根据实际计算 |
| 写 EPC（1122→1123） | `ce bb 00 49 00 0f 00 00 00 00 01 00 00 00 03 ca 9e 08 00 11 23 00 7e` | 注意 Word Count 和 Old EPC CRC |
| 功能 | Data（十六进制） |
|:---|:---|
| 读版本号 | `c0` |
| 恢复出厂设置 | `cf` |
| 读取格式 | `83` |
| 设置格式 | `82 0f 00 00 00 01 01 01 00` |
| 打开蜂鸣器 | `cd 01` |
| 关闭蜂鸣器 | `cd 00` |
| 打开射频 | `90 01` |
| 关闭射频 | `90 00` |
| 设置单标签巡查 | `0f 01` |
| 设置被动模式 | `0f 02` |
| 设置多标签巡查 | `0f 03` |
| 设置功率 = 8 | `cc 08` |
| 读取 EPC | `ce bb 00 22 00 00 22 7e` |
| 选中卡（EPC=1122） | `ce bb 00 0c 00 09 01 00 00 00 20 10 00 11 22 79 7e` |
| 写 EPC（1122→1123） | `ce bb 00 49 00 0f 00 00 00 00 01 00 00 00 03 ca 9e 08 00 11 23 00 7e` |
---
**文档版本**：2.2
**最后更新**：2026-04-14
**文档版本**：2.3
**最后更新**：2026-04-15
**适用设备**：MT6_RF915_RW_WY 及兼容固件

378
rfid_tester.py
View File

@@ -49,14 +49,14 @@ def build_setreq_frame(data: bytes) -> bytes:
# Frame Length: 从 0x07 到 Checksum（包含校验和，不含结束符）
# = 2 (constant) + 2 (data length) + len(data) + 1 (checksum)
frame_length = 5 + len(data)
frame_length_bytes = frame_length.to_bytes(2, 'little')
frame_length_bytes = frame_length.to_bytes(2, 'big')
# Data Length
data_length_bytes = len(data).to_bytes(2, 'little')
data_length_bytes = len(data).to_bytes(2, 'big')
# Checksum
checksum = calc_outer_checksum(data_length_bytes, data)
# 构建帧
frame = bytearray(REPORT_SIZE)
frame[0] = REPORT_ID_SET_REQ
@@ -67,33 +67,58 @@ def build_setreq_frame(data: bytes) -> bytes:
frame[11:11+len(data)] = data # Data
frame[11+len(data)] = checksum # Checksum
frame[12+len(data)] = 0x03 # End Marker
return bytes(frame)
def parse_getres_frame(data: bytes) -> tuple:
"""
解析 GetRes 帧
解析 GetRes 帧（带Checksum和End Marker验证）
:param data: 接收到的数据
:return: (status, response_data) 或 None
:return: (status, response_data) 或 None，校验失败返回None并打印错误
"""
if len(data) < 12:
if len(data) < 14: # 最小帧长度需要包含Checksum和End Marker
print(f"[DEBUG] 数据长度不足: {len(data)} < 14")
return None
# 检查 Report ID
if data[0] != REPORT_ID_GET_RES:
print(f"[DEBUG] Report ID错误: 0x{data[0]:02x} (应为 0x03)")
return None
# 解析帧结构
frame_length = int.from_bytes(data[5:7], 'little')
data_length = int.from_bytes(data[9:11], 'little')
# 解析帧结构（大端序）
frame_length = int.from_bytes(data[5:7], 'big')
data_length = int.from_bytes(data[9:11], 'big')
# 检查数据长度是否合理
expected_total_len = 11 + data_length + 2 # header + data + checksum + end_marker
if len(data) < expected_total_len:
print(f"[DEBUG] 数据长度不匹配: 实际{len(data)}, 期望{expected_total_len}")
return None
# 提取 Data 段
response_data = data[11:11+data_length]
# 提取 Checksum 和 End Marker
received_checksum = data[11+data_length]
received_end_marker = data[12+data_length]
# 验证 End Marker（固定为 0x03）
if received_end_marker != 0x03:
print(f"[DEBUG] End Marker错误: 0x{received_end_marker:02x} (应为 0x03)")
return None
# 计算并验证 Checksum（XOR算法：Data Length两字节 + Data全部字节）
calculated_checksum = calc_outer_checksum(data[9:11], response_data)
if calculated_checksum != received_checksum:
print(f"[DEBUG] Checksum错误: 计算=0x{calculated_checksum:02x}, 接收=0x{received_checksum:02x}")
return None
print(f"[DEBUG] 帧校验通过: Checksum=0x{received_checksum:02x}, EndMarker=0x{received_end_marker:02x}")
if len(response_data) < 1:
return None
status = response_data[0]
return (status, response_data[1:])
@@ -105,11 +130,31 @@ def cmd_get_version() -> bytes:
return bytes([0xc0])
def cmd_factory_reset() -> bytes:
"""恢复出厂设置命令"""
return bytes([0xcf])
def cmd_read_format() -> bytes:
"""读取格式命令"""
return bytes([0x83])
def cmd_set_format() -> bytes:
"""设置格式命令"""
return bytes([0x82, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00])
def cmd_buzzer(on: bool) -> bytes:
"""蜂鸣器控制命令"""
return bytes([0xcd, 0x01 if on else 0x00])
def cmd_rf_power(on: bool) -> bytes:
"""射频电源控制命令"""
return bytes([0x90, 0x01 if on else 0x00])
def cmd_set_power(power: int) -> bytes:
"""设置功率命令 (0-9)"""
power = max(0, min(9, power))
@@ -134,39 +179,41 @@ def cmd_select_card(epc_data: bytes) -> bytes:
"""选中卡命令"""
# 固定前缀 + EPC 数据
payload = bytes([0x01, 0x00, 0x00, 0x00, 0x20, 0x10, 0x00]) + epc_data
# 计算 checksum
# 计算 checksum（包含 Card Op Command + Internal Length + Payload）
card_op_cmd = bytes([0x00, 0x0c])
internal_len = len(payload).to_bytes(2, 'big')
checksum = 0
for b in card_op_cmd + payload:
for b in card_op_cmd + internal_len + payload:
checksum = (checksum + b) & 0xFF
internal_len = len(payload).to_bytes(2, 'little')
return bytes([0xce, 0xbb]) + card_op_cmd + internal_len + payload + bytes([checksum, 0x7e])
def cmd_write_epc(old_epc_crc: bytes, new_epc: bytes) -> bytes:
"""写入 EPC 命令"""
epc_len_indicator = (len(new_epc) * 4) // 4
# EPC Len Indicator: EPC字节数 = 值 ÷ 4，所以值 = EPC字节数 * 4
epc_len_indicator = len(new_epc) * 4
if epc_len_indicator == 0:
epc_len_indicator = 8
epc_len_indicator = 8 # 默认最小值
word_count = 2 + len(new_epc) // 2
payload = bytes([0x00, 0x00, 0x00, 0x00, 0x01, 0x00]) # Reserved
payload += bytes([0x00, 0x00]) # Reserved
payload = bytes([0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00]) # Reserved (8 bytes)
payload += bytes([word_count]) # Word Count
payload += old_epc_crc # Old EPC CRC
payload += old_epc_crc # Old EPC CRC (大端序)
payload += bytes([epc_len_indicator, 0x00]) # EPC Len Indicator, Status
payload += new_epc # New EPC Data
# 计算 checksum
# 计算 checksum（包含 Card Op Command + Internal Length + Payload）
card_op_cmd = bytes([0x00, 0x49])
internal_len = len(payload).to_bytes(2, 'big')
checksum = 0
for b in card_op_cmd + len(payload).to_bytes(2, 'little') + payload:
for b in card_op_cmd + internal_len + payload:
checksum = (checksum + b) & 0xFF
internal_len = len(payload).to_bytes(2, 'little')
return bytes([0xce, 0xbb]) + card_op_cmd + internal_len + payload + bytes([checksum, 0x7e])
@@ -177,7 +224,11 @@ class RFIDDevice:
self.device = None
self.vendor_id = VENDOR_ID
self.product_id = PRODUCT_ID
self.current_path = None # 当前连接的设备路径
self.current_interface = -1 # 当前连接的接口号
self.current_path = None # 当前连接的设备路径
self.current_interface = -1 # 当前连接的接口号
def list_devices(self):
"""列出所有 HID 设备"""
devices = []
@@ -195,54 +246,103 @@ class RFIDDevice:
except Exception as e:
print(f"枚举设备失败: {e}")
return devices
def connect(self, vendor_id=None, product_id=None):
"""连接设备"""
"""通过VID/PID连接设备（会打开第一个匹配的设备）"""
if vendor_id:
self.vendor_id = vendor_id
if product_id:
self.product_id = product_id
try:
self.device = hid.device()
self.device.open(self.vendor_id, self.product_id)
return True, f"已连接到设备 (VID: 0x{self.vendor_id:04x}, PID: 0x{self.product_id:04x})"
self.current_path = None
self.current_interface = -1
print(f"[DEBUG] 通过VID/PID连接: VID=0x{self.vendor_id:04x}, PID=0x{self.product_id:04x}")
return True, f"已连接到设备 (VID: 0x{self.vendor_id:04x}, PID: 0x{self.product_id:04x}) - 注意：可能连接到任意接口"
except Exception as e:
print(f"[DEBUG] VID/PID连接失败: {e}")
return False, f"连接失败: {e}"
def connect_by_path(self, path, interface_number=-1):
"""通过路径连接设备（可以精确指定接口）"""
try:
self.device = hid.device()
# path可能是bytes类型，需要处理
if isinstance(path, bytes):
path_str = path
else:
path_str = path.encode('utf-8') if isinstance(path, str) else path
self.device.open_path(path_str)
self.current_path = path
self.current_interface = interface_number
# 获取设备信息
info = self.device.get_manufacturer_string() or "未知"
product = self.device.get_product_string() or "未知"
print(f"[DEBUG] 通过路径连接成功:")
print(f"[DEBUG] 路径: {path}")
print(f"[DEBUG] 接口号: {interface_number}")
print(f"[DEBUG] 制造商: {info}")
print(f"[DEBUG] 产品: {product}")
path_display = path.decode('utf-8', errors='ignore') if isinstance(path, bytes) else str(path)
return True, f"已连接到设备 (IF={interface_number}, 路径: ...{path_display[-30:]})"
except Exception as e:
print(f"[DEBUG] 路径连接失败: {e}")
return False, f"连接失败: {e}"
def disconnect(self):
"""断开连接"""
if self.device:
try:
print(f"[DEBUG] 断开设备连接 (接口: {self.current_interface})")
self.device.close()
except:
pass
self.device = None
self.current_path = None
self.current_interface = -1
return "已断开连接"
def is_connected(self):
"""检查是否已连接"""
return self.device is not None
if self.device:
#print(f"[DEBUG] 设备已连接 - 接口: {self.current_interface}, 路径: {self.current_path}")
return True
return False
def get_connection_info(self):
"""获取当前连接信息"""
return {
'interface': self.current_interface,
'path': self.current_path,
'vendor_id': self.vendor_id,
'product_id': self.product_id
}
def send_command(self, cmd_data: bytes):
"""发送命令并接收响应"""
if not self.device:
return None, "设备未连接"
try:
# 构建并发送 SetReq
frame = build_setreq_frame(cmd_data)
self.device.send_feature_report(frame)
# 接收 GetRes
time.sleep(0.1)
response = self.device.get_feature_report(REPORT_ID_GET_RES, REPORT_SIZE)
# 解析响应
result = parse_getres_frame(bytes(response))
if result is None:
return None, "响应格式错误"
status, data = result
return data, None
except Exception as e:
@@ -254,22 +354,27 @@ class RFIDDevice:
def create_window():
"""创建主窗口"""
sg.theme('LightBlue2')
# 设备连接区域
device_frame = [
[sg.Text('VID (十六进制):'), sg.Input('FFFF', size=(8, 1), key='-VID-'),
sg.Text('PID (十六进制):'), sg.Input('0035', size=(8, 1), key='-PID-'),
sg.Button('枚举设备', key='-ENUM-'),
sg.Button('连接', key='-CONNECT-'),
sg.Button('断开', key='-DISCONNECT-')],
sg.Button('断开', key='-DISCONNECT-'),
sg.Button('枚举设备', key='-ENUM-')],
[sg.Text('状态: ', size=(12, 1)), sg.Text('未连接', key='-STATUS-', text_color='red')]
]
# 基本命令区域
basic_frame = [
[sg.Button('读取版本号', key='-VERSION-', size=(15, 1)),
sg.Button('打开蜂鸣器', key='-BUZZER_ON-', size=(15, 1)),
sg.Button('关闭蜂鸣器', key='-BUZZER_OFF-', size=(15, 1))],
[sg.Button('读取版本号', key='-VERSION-', size=(12, 1)),
sg.Button('恢复出厂', key='-FACTORY_RESET-', size=(12, 1)),
sg.Button('读取格式', key='-READ_FORMAT-', size=(12, 1)),
sg.Button('设置格式', key='-SET_FORMAT-', size=(12, 1))],
[sg.Button('打开蜂鸣器', key='-BUZZER_ON-', size=(12, 1)),
sg.Button('关闭蜂鸣器', key='-BUZZER_OFF-', size=(12, 1)),
sg.Button('打开射频', key='-RF_ON-', size=(12, 1)),
sg.Button('关闭射频', key='-RF_OFF-', size=(12, 1))],
[sg.Text('功率 (0-9):'), sg.Slider(range=(0, 9), default_value=8, orientation='h', size=(20, 15), key='-POWER-'),
sg.Button('设置功率', key='-SET_POWER-')],
[sg.Text('工作模式:'),
@@ -278,7 +383,7 @@ def create_window():
sg.Radio('多标签巡查', 'mode', key='-MODE3-'),
sg.Button('设置模式', key='-SET_MODE-')]
]
# EPC 操作区域
epc_frame = [
[sg.Button('读取 EPC', key='-READ_EPC-', size=(15, 1)),
@@ -287,12 +392,12 @@ def create_window():
[sg.Text('新 EPC (十六进制):'), sg.Input('', size=(40, 1), key='-NEW_EPC-')],
[sg.Button('写入 EPC', key='-WRITE_EPC-', size=(15, 1))]
]
# 日志输出区域
log_frame = [
[sg.Multiline('', size=(80, 15), key='-LOG-', autoscroll=True, disabled=True)]
]
layout = [
[sg.Frame('设备连接', device_frame)],
[sg.Frame('基本命令', basic_frame)],
@@ -300,7 +405,7 @@ def create_window():
[sg.Frame('日志', log_frame)],
[sg.Button('清空日志', key='-CLEAR_LOG-'), sg.Button('退出', key='-EXIT-')]
]
return sg.Window('MT6 RFID 读卡器测试程序', layout, finalize=True)
@@ -328,14 +433,14 @@ def main():
window = create_window()
rfid = RFIDDevice()
device_list = []
while True:
event, values = window.read()
if event in (sg.WIN_CLOSED, '-EXIT-'):
rfid.disconnect()
break
# 枚举设备
if event == '-ENUM-':
device_list = rfid.list_devices()
@@ -343,11 +448,17 @@ def main():
log_message(window, f"找到 {len(device_list)} 个 HID 设备")
device_strs = []
for i, d in enumerate(device_list):
# 显示路径信息，帮助区分相同VID/PID的设备
path = d['path']
path_str = path.decode('utf-8', errors='ignore') if isinstance(path, bytes) else str(path)
s = f"[{i}] VID:0x{d['vendor_id']:04x} PID:0x{d['product_id']:04x} " \
f"IF:{d['interface_number']} {d['manufacturer_string']} {d['product_string']}"
f"IF:{d['interface_number']} {d['manufacturer_string']} {d['product_string']} " \
f"Path:...{path_str[-20:]}"
device_strs.append(s)
log_message(window, s)
# 详细日志显示完整路径
log_message(window, f" -> 完整路径: {path_str}")
# 创建设备选择窗口
select_layout = [
[sg.Listbox(values=device_strs, size=(80, min(10, len(device_strs))), key='-SELECTED-')],
@@ -366,12 +477,28 @@ def main():
d = device_list[idx]
window['-VID-'].update(f"{d['vendor_id']:04x}")
window['-PID-'].update(f"{d['product_id']:04x}")
log_message(window, f"已选择设备: VID=0x{d['vendor_id']:04x}, PID=0x{d['product_id']:04x}, IF={d['interface_number']}")
# 使用路径连接设备
path = d['path']
interface_number = d['interface_number']
log_message(window, f"正在连接设备...")
log_message(window, f" VID: 0x{d['vendor_id']:04x}, PID: 0x{d['product_id']:04x}")
log_message(window, f" 接口号: {interface_number}")
path_str = path.decode('utf-8', errors='ignore') if isinstance(path, bytes) else str(path)
log_message(window, f" 路径: {path_str}")
success, msg = rfid.connect_by_path(path, interface_number)
log_message(window, msg)
if success:
window['-STATUS-'].update('已连接', text_color='green')
log_message(window, f"当前使用接口: IF{rfid.current_interface}")
else:
window['-STATUS-'].update('连接失败', text_color='red')
select_window.close()
break
else:
log_message(window, "未找到 HID 设备")
# 连接设备
if event == '-CONNECT-':
try:
@@ -385,13 +512,13 @@ def main():
window['-STATUS-'].update('连接失败', text_color='red')
except ValueError:
log_message(window, "请输入有效的十六进制 VID/PID")
# 断开连接
if event == '-DISCONNECT-':
msg = rfid.disconnect()
log_message(window, msg)
window['-STATUS-'].update('未连接', text_color='red')
# 读取版本号
if event == '-VERSION-':
if not rfid.is_connected():
@@ -402,14 +529,72 @@ def main():
if err:
log_message(window, f"错误: {err}")
else:
log_message(window, f"响应 (hex): ", is_hex=True)
log_message(window, data, is_hex=True)
try:
version = data.decode('ascii', errors='ignore')
log_message(window, f"版本: {version}")
except:
pass
# 恢复出厂设置
if event == '-FACTORY_RESET-':
if not rfid.is_connected():
log_message(window, "错误: 设备未连接")
else:
log_message(window, "发送命令: 恢复出厂设置")
data, err = rfid.send_command(cmd_factory_reset())
if err:
log_message(window, f"错误: {err}")
else:
log_message(window, data, is_hex=True)
# 读取格式
if event == '-READ_FORMAT-':
if not rfid.is_connected():
log_message(window, "错误: 设备未连接")
else:
log_message(window, "发送命令: 读取格式")
data, err = rfid.send_command(cmd_read_format())
if err:
log_message(window, f"错误: {err}")
else:
log_message(window, data, is_hex=True)
# 设置格式
if event == '-SET_FORMAT-':
if not rfid.is_connected():
log_message(window, "错误: 设备未连接")
else:
log_message(window, "发送命令: 设置格式")
data, err = rfid.send_command(cmd_set_format())
if err:
log_message(window, f"错误: {err}")
else:
log_message(window, data, is_hex=True)
# 射频电源控制
if event == '-RF_ON-':
if not rfid.is_connected():
log_message(window, "错误: 设备未连接")
else:
log_message(window, "发送命令: 打开射频")
data, err = rfid.send_command(cmd_rf_power(True))
if err:
log_message(window, f"错误: {err}")
else:
log_message(window, data, is_hex=True)
if event == '-RF_OFF-':
if not rfid.is_connected():
log_message(window, "错误: 设备未连接")
else:
log_message(window, "发送命令: 关闭射频")
data, err = rfid.send_command(cmd_rf_power(False))
if err:
log_message(window, f"错误: {err}")
else:
log_message(window, data, is_hex=True)
# 蜂鸣器控制
if event == '-BUZZER_ON-':
if not rfid.is_connected():
@@ -421,7 +606,7 @@ def main():
log_message(window, f"错误: {err}")
else:
log_message(window, f"响应: {data.hex() if data else '无数据'}")
if event == '-BUZZER_OFF-':
if not rfid.is_connected():
log_message(window, "错误: 设备未连接")
@@ -432,7 +617,7 @@ def main():
log_message(window, f"错误: {err}")
else:
log_message(window, f"响应: {data.hex() if data else '无数据'}")
# 设置功率
if event == '-SET_POWER-':
if not rfid.is_connected():
@@ -445,7 +630,7 @@ def main():
log_message(window, f"错误: {err}")
else:
log_message(window, f"响应: {data.hex() if data else '无数据'}")
# 设置工作模式
if event == '-SET_MODE-':
if not rfid.is_connected():
@@ -463,7 +648,7 @@ def main():
log_message(window, f"错误: {err}")
else:
log_message(window, f"响应: {data.hex() if data else '无数据'}")
# 读取 EPC
if event == '-READ_EPC-':
if not rfid.is_connected():
@@ -477,22 +662,31 @@ def main():
log_message(window, f"响应 (hex): ", is_hex=True)
log_message(window, data, is_hex=True)
# 解析 EPC
# 注意: parse_getres_frame返回的data是从bb开始的（status已被去除）
# 原始格式: 00 bb 02 22 00 0b d3 18 00 [EPC] ...
# 去掉status后: bb 02 22 00 0b d3 18 00 [EPC] ...
# 所以: data[0]=bb, data[1:3]=Card Op Resp, data[5]=RSSI, data[6]=EPC Len, data[8:]=EPC
if data and len(data) > 10:
# 检查 Card Op Resp
if data[2:4] == b'\x02\x22':
# 有卡
rssi = data[6] if len(data) > 6 else 0
epc_len_indicator = data[7] if len(data) > 7 else 0
# 检查 Magic 和 Card Op Resp
if data[0:1] == b'\xbb' and data[1:3] == b'\x02\x22':
# 有卡，解析 EPC
rssi = data[5] if len(data) > 5 else 0
epc_len_indicator = data[6] if len(data) > 6 else 0
epc_len = epc_len_indicator // 4 if epc_len_indicator > 0 else 0
epc_data = data[9:9+epc_len] if len(data) > 9 else b''
epc_data = data[8:8+epc_len] if len(data) > 8 else b''
log_message(window, f"Magic: 0x{data[0]:02x} (应为 bb)")
log_message(window, f"Card Op Resp: {data[1:3].hex()} (02 22=有卡)")
log_message(window, f"RSSI: 0x{rssi:02x}")
log_message(window, f"EPC Len Indicator: 0x{epc_len_indicator:02x} (字节数={epc_len})")
log_message(window, f"EPC: {epc_data.hex()}")
window['-EPC_DATA-'].update(epc_data.hex())
elif data[2:4] == b'\x01\xff':
log_message(window, "无卡或读取失败")
elif data[0:1] == b'\xbb' and data[1:3] == b'\x01\xff':
log_message(window, "无卡或读取失败 (Card Op Resp: 01 ff)")
else:
log_message(window, f"未知响应: {data[2:4].hex()}")
log_message(window, f"未知响应格式:")
log_message(window, f" Magic: {data[0:1].hex()} (应为 bb)")
log_message(window, f" Card Op Resp: {data[1:3].hex()}")
# 选中卡
if event == '-SELECT_CARD-':
if not rfid.is_connected():
@@ -510,14 +704,18 @@ def main():
log_message(window, f"错误: {err}")
else:
log_message(window, f"响应 (hex): {data.hex() if data else '无数据'}")
if data and len(data) > 6:
if data[6] == 0x00:
# 注意: parse_getres_frame返回的data是从bb开始的（status已被去除）
# 原始格式: 00 bb 01 0c 00 01 00 0e 7e
# 去掉status后: bb 01 0c 00 01 00 0e 7e
# data[0]=bb, data[1:3]=01 0c(Card Op Resp), data[3:5]=00 01(Internal Length), data[5]=00(Payload-选中成功标志)
if data and len(data) > 5:
if data[5] == 0x00:
log_message(window, "选中成功")
else:
log_message(window, f"选中失败: 0x{data[6]:02x}")
log_message(window, f"选中失败: 0x{data[5]:02x}")
except ValueError:
log_message(window, "错误: EPC 数据格式错误，请使用十六进制")
# 写入 EPC
if event == '-WRITE_EPC-':
if not rfid.is_connected():
@@ -539,13 +737,13 @@ def main():
log_message(window, f"响应 (hex): {data.hex() if data else '无数据'}")
except ValueError:
log_message(window, "错误: EPC 数据格式错误，请使用十六进制")
# 清空日志
if event == '-CLEAR_LOG-':
window['-LOG-'].update('')
window.close()
if __name__ == '__main__':
main()
main()

152
test_protocol.py
View File

@@ -1,7 +1,7 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
测试 MT6 RFID 读卡器协议函数
测试 MT6 RFID 读卡器协议函数（大端序版本）
"""
import sys
@@ -16,7 +16,11 @@ from rfid_tester import (
build_setreq_frame,
parse_getres_frame,
cmd_get_version,
cmd_factory_reset,
cmd_read_format,
cmd_set_format,
cmd_buzzer,
cmd_rf_power,
cmd_set_power,
cmd_set_mode,
cmd_read_epc,
@@ -29,28 +33,28 @@ def test_calc_outer_checksum():
"""测试校验和计算"""
print("\n=== 测试校验和计算 ===")
# 根据文档，读版本号命令的校验和应该是 0xc1
# Data Length: 01 00 (小端序)
# 根据文档，读版本号命令
# Data Length: 00 01 (大端序)
# Data: c0
data_len = bytes([0x01, 0x00])
data_len = bytes([0x00, 0x01])
data = bytes([0xc0])
checksum = calc_outer_checksum(data_len, data)
print(f"读版本号校验和: 0x{checksum:02x} (期望: 0xc1)")
assert checksum == 0xc1, f"校验和计算错误: 期望 0xc1, 实际 0x{checksum:02x}"
# 打开蜂鸣器的校验和应该是 0xce
# Data Length: 02 00
# 打开蜂鸣器
# Data Length: 00 02 (大端序)
# Data: cd 01
data_len = bytes([0x02, 0x00])
data_len = bytes([0x00, 0x02])
data = bytes([0xcd, 0x01])
checksum = calc_outer_checksum(data_len, data)
print(f"打开蜂鸣器校验和: 0x{checksum:02x} (期望: 0xce)")
assert checksum == 0xce, f"校验和计算错误: 期望 0xce, 实际 0x{checksum:02x}"
# 设置功率=8的校验和应该是 0xc6
# Data Length: 02 00
# 设置功率=8
# Data Length: 00 02 (大端序)
# Data: cc 08
data_len = bytes([0x02, 0x00])
data_len = bytes([0x00, 0x02])
data = bytes([0xcc, 0x08])
checksum = calc_outer_checksum(data_len, data)
print(f"设置功率=8校验和: 0x{checksum:02x} (期望: 0xc6)")
@@ -60,14 +64,14 @@ def test_calc_outer_checksum():
def test_build_setreq_frame():
"""测试帧构建"""
print("\n=== 测试帧构建 ===")
"""测试帧构建（大端序）"""
print("\n=== 测试帧构建（大端序）===")
# 测试读版本号命令
cmd = cmd_get_version()
frame = build_setreq_frame(cmd)
# 根据文档，应该是: 01 00 00 00 00 06 00 00 02 01 00 c0 c1 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x01, 0x00, 0xc0, 0xc1, 0x03])
# 大端序: 01 00 00 00 00 00 06 00 02 00 01 c0 c1 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x02, 0x00, 0x01, 0xc0, 0xc1, 0x03])
print(f"读版本号帧 (前14字节): {frame[:14].hex()}")
print(f"期望: {expected.hex()}")
assert frame[:14] == expected, f"读版本号帧不匹配"
@@ -77,8 +81,8 @@ def test_build_setreq_frame():
# 测试打开蜂鸣器命令
cmd = cmd_buzzer(True)
frame = build_setreq_frame(cmd)
# 根据文档: 01 00 00 00 00 07 00 00 02 02 00 cd 01 ce 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x02, 0x02, 0x00, 0xcd, 0x01, 0xce, 0x03])
# 大端序: 01 00 00 00 00 00 07 00 02 00 02 cd 01 ce 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x02, 0xcd, 0x01, 0xce, 0x03])
print(f"打开蜂鸣器帧 (前15字节): {frame[:15].hex()}")
print(f"期望: {expected.hex()}")
assert frame[:15] == expected, f"打开蜂鸣器帧不匹配"
@@ -87,8 +91,8 @@ def test_build_setreq_frame():
# 测试关闭蜂鸣器命令
cmd = cmd_buzzer(False)
frame = build_setreq_frame(cmd)
# 根据文档: 01 00 00 00 00 07 00 00 02 02 00 cd 00 cf 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x02, 0x02, 0x00, 0xcd, 0x00, 0xcf, 0x03])
# 大端序: 01 00 00 00 00 00 07 00 02 00 02 cd 00 cf 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x02, 0xcd, 0x00, 0xcf, 0x03])
print(f"关闭蜂鸣器帧 (前15字节): {frame[:15].hex()}")
print(f"期望: {expected.hex()}")
assert frame[:15] == expected, f"关闭蜂鸣器帧不匹配"
@@ -97,8 +101,8 @@ def test_build_setreq_frame():
# 测试设置功率命令
cmd = cmd_set_power(8)
frame = build_setreq_frame(cmd)
# 根据文档: 01 00 00 00 00 07 00 00 02 02 00 cc 08 c6 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x02, 0x02, 0x00, 0xcc, 0x08, 0xc6, 0x03])
# 大端序: 01 00 00 00 00 00 07 00 02 00 02 cc 08 c6 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x02, 0xcc, 0x08, 0xc6, 0x03])
print(f"设置功率=8帧 (前15字节): {frame[:15].hex()}")
print(f"期望: {expected.hex()}")
assert frame[:15] == expected, f"设置功率帧不匹配"
@@ -107,8 +111,8 @@ def test_build_setreq_frame():
# 测试设置被动模式命令
cmd = cmd_set_mode(2)
frame = build_setreq_frame(cmd)
# 根据文档: 01 00 00 00 00 07 00 00 02 02 00 0f 02 0f 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x02, 0x02, 0x00, 0x0f, 0x02, 0x0f, 0x03])
# 大端序: 01 00 00 00 00 00 07 00 02 00 02 0f 02 0f 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x02, 0x0f, 0x02, 0x0f, 0x03])
print(f"设置被动模式帧 (前15字节): {frame[:15].hex()}")
print(f"期望: {expected.hex()}")
assert frame[:15] == expected, f"设置模式帧不匹配"
@@ -117,34 +121,49 @@ def test_build_setreq_frame():
# 测试读取 EPC 命令
cmd = cmd_read_epc()
frame = build_setreq_frame(cmd)
print(f"读取EPC帧 (前20字节): {frame[:20].hex()}")
# 验证帧结构
assert frame[0] == 0x01, "Report ID 应为 0x01"
assert frame[1:5] == b'\x00\x00\x00\x00', "固定字段应为 0x00000000"
assert frame[7:9] == b'\x00\x02', "Constant 应为 0x0002"
# Data: ce bb 00 22 00 00 22 7e (8 bytes)
# Frame Length: 00 0d (大端序, 13)
# Data Length: 00 08 (大端序)
# Checksum: 00 ^ 08 ^ ce ^ bb ^ 00 ^ 22 ^ 00 ^ 00 ^ 22 ^ 7e = 03
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x02, 0x00, 0x08,
0xce, 0xbb, 0x00, 0x22, 0x00, 0x00, 0x22, 0x7e, 0x03, 0x03])
print(f"读取EPC帧 (前21字节): {frame[:21].hex()}")
print(f"期望: {expected.hex()}")
assert frame[:21] == expected, f"读取EPC帧不匹配"
print("读取EPC帧测试通过!")
# 测试打开射频命令
cmd = cmd_rf_power(True)
frame = build_setreq_frame(cmd)
# Data: 90 01 (2 bytes)
# Data Length: 00 02
# Frame Length: 00 07
# Checksum: 00 ^ 02 ^ 90 ^ 01 = 93
expected = bytes([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x02, 0x90, 0x01, 0x93, 0x03])
print(f"打开射频帧 (前15字节): {frame[:15].hex()}")
print(f"期望: {expected.hex()}")
assert frame[:15] == expected, f"打开射频帧不匹配"
print("打开射频帧测试通过!")
def test_parse_getres_frame():
"""测试响应帧解析"""
print("\n=== 测试响应帧解析 ===")
"""测试响应帧解析（大端序）"""
print("\n=== 测试响应帧解析（大端序）===")
# 模拟读版本号成功的响应
# Report ID: 0x03
# 响应数据: 00 + 版本字符串 "MT6_RF915_RW"
version_str = b"MT6_RF915_RW"
response = bytearray()
response.append(0x03) # Report ID
response.extend([0x00, 0x00, 0x00, 0x00]) # Fixed
frame_len = 2 + 2 + 1 + len(version_str) # constant + data_len + status + version
response.extend(frame_len.to_bytes(2, 'little')) # Frame Length
frame_len = 2 + 2 + 1 + len(version_str) + 1 # constant + data_len + status + version + checksum
response.extend(frame_len.to_bytes(2, 'big')) # Frame Length (大端序)
response.extend([0x00, 0x02]) # Constant
data_len = 1 + len(version_str)
response.extend(data_len.to_bytes(2, 'little')) # Data Length
response.extend(data_len.to_bytes(2, 'big')) # Data Length (大端序)
response.append(0x00) # Status = 成功
response.extend(version_str) # Version string
# 计算校验和
checksum = calc_outer_checksum(data_len.to_bytes(2, 'little'), bytes([0x00]) + version_str)
checksum = calc_outer_checksum(data_len.to_bytes(2, 'big'), bytes([0x00]) + version_str)
response.append(checksum)
response.append(0x03) # End Marker
@@ -167,6 +186,21 @@ def test_command_functions():
print(f"读版本号命令: {cmd.hex()}")
assert cmd == bytes([0xc0]), f"读版本号命令应为 c0"
# 测试恢复出厂设置命令
cmd = cmd_factory_reset()
print(f"恢复出厂设置命令: {cmd.hex()}")
assert cmd == bytes([0xcf]), f"恢复出厂设置命令应为 cf"
# 测试读取格式命令
cmd = cmd_read_format()
print(f"读取格式命令: {cmd.hex()}")
assert cmd == bytes([0x83]), f"读取格式命令应为 83"
# 测试设置格式命令
cmd = cmd_set_format()
print(f"设置格式命令: {cmd.hex()}")
assert cmd == bytes([0x82, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00]), f"设置格式命令不匹配"
# 测试蜂鸣器命令
cmd = cmd_buzzer(True)
print(f"打开蜂鸣器命令: {cmd.hex()}")
@@ -176,6 +210,15 @@ def test_command_functions():
print(f"关闭蜂鸣器命令: {cmd.hex()}")
assert cmd == bytes([0xcd, 0x00]), f"关闭蜂鸣器命令应为 cd 00"
# 测试射频电源命令
cmd = cmd_rf_power(True)
print(f"打开射频命令: {cmd.hex()}")
assert cmd == bytes([0x90, 0x01]), f"打开射频命令应为 90 01"
cmd = cmd_rf_power(False)
print(f"关闭射频命令: {cmd.hex()}")
assert cmd == bytes([0x90, 0x00]), f"关闭射频命令应为 90 00"
# 测试设置功率命令
cmd = cmd_set_power(5)
print(f"设置功率=5命令: {cmd.hex()}")
@@ -195,13 +238,49 @@ def test_command_functions():
print(f"读取EPC命令: {cmd.hex()}")
assert cmd == bytes([0xce, 0xbb, 0x00, 0x22, 0x00, 0x00, 0x22, 0x7e]), f"读取EPC命令不匹配"
# 测试选中卡命令（验证校验和计算包含Internal Length）
epc_data = bytes([0x11, 0x22])
cmd = cmd_select_card(epc_data)
print(f"选中卡命令 (EPC=1122): {cmd.hex()}")
# 根据协议: ce bb 00 0c 00 09 01 00 00 00 20 10 00 11 22 79 7e
# Checksum = 00+0c+00+09+01+00+00+00+20+10+00+11+22 mod 256 = 79
expected = bytes([0xce, 0xbb, 0x00, 0x0c, 0x00, 0x09, 0x01, 0x00, 0x00, 0x00, 0x20, 0x10, 0x00, 0x11, 0x22, 0x79, 0x7e])
assert cmd == expected, f"选中卡命令不匹配: 期望 {expected.hex()}, 实际 {cmd.hex()}"
print("命令生成函数测试通过!")
def test_epc_operations():
"""测试EPC操作命令"""
print("\n=== 测试EPC操作命令 ===")
# 测试选中卡命令
epc_data = bytes([0x11, 0x22])
cmd = cmd_select_card(epc_data)
print(f"选中卡命令: {cmd.hex()}")
# 验证结构: ce bb + Card Op Command + Internal Length(大端) + Payload + Checksum + 7e
assert cmd[0:2] == bytes([0xce, 0xbb]), "Command/Magic不正确"
assert cmd[2:4] == bytes([0x00, 0x0c]), "Card Op Command不正确"
assert cmd[4:6] == bytes([0x00, 0x09]), "Internal Length应为00 09 (大端序)"
assert cmd[-1] == 0x7e, "End Marker应为7e"
print("选中卡命令测试通过!")
# 测试写入EPC命令
old_epc_crc = bytes([0xca, 0x9e]) # 大端序
new_epc = bytes([0x11, 0x23])
cmd = cmd_write_epc(old_epc_crc, new_epc)
print(f"写入EPC命令: {cmd.hex()}")
# 验证结构
assert cmd[0:2] == bytes([0xce, 0xbb]), "Command/Magic不正确"
assert cmd[2:4] == bytes([0x00, 0x49]), "Card Op Command不正确"
assert cmd[-1] == 0x7e, "End Marker应为7e"
print("写入EPC命令测试通过!")
def main():
"""主测试函数"""
print("=" * 60)
print("MT6 RFID 读卡器协议函数测试")
print("MT6 RFID 读卡器协议函数测试（大端序版本）")
print("=" * 60)
try:
@@ -209,6 +288,7 @@ def main():
test_build_setreq_frame()
test_parse_getres_frame()
test_command_functions()
test_epc_operations()
print("\n" + "=" * 60)
print("所有测试通过!")