从多标签防碰撞到数据一致性校验，RFID算法完整资产闭环管理

时间槽:  |  T1  |  T2  |  T3  |  T4  |  T5  |
标签A:    响应→   ← 碰撞(与C)
标签B:            响应→  成功
标签C:    响应→   ← 碰撞(与A)
标签D:                    响应→  成功

帧长度 N=16:
时隙0: 标签A响应 → 成功
时隙1: 空
时隙2: 标签B+C碰撞 → 下一帧重试
时隙3: 标签D响应 → 成功
...
时隙15: 标签E响应 → 成功

算法逻辑：
1. 初始功率 = 中等（如20dBm）
2. 读取标签数量 > 阈值 → 降低功率（减少覆盖范围）
3. 读取标签数量 < 阈值 → 提高功率（扩大覆盖范围）
4. 功率范围: 15dBm ~ 30dBm

// 去重逻辑伪代码
BloomFilter<String> readFilter = new BloomFilter<>(expectedCount, 0.001);

for (TagRead read : incomingReads) {
    if (!readFilter.mightContain(read.epc)) {
        readFilter.add(read.epc);
        validReads.add(read);  // 首次读取，保留
    } else {
        // 已读取过，比较信号强度，保留更强的
        TagRead existing = readMap.get(read.epc);
        if (read.rssi > existing.rssi) {
            readMap.put(read.epc, read);
        }
    }
}

def merge_duplicate_reads(sub_results):
    """
    合并多个子盘点结果，去除重复读取
    """
    merged = {}
    for sub in sub_results:
        for read in sub.records:
            key = read.epc  # 以EPC为唯一键
            if key not in merged:
                merged[key] = read
            else:
                # 保留信号强度更高的读取记录
                if read.rssi > merged[key].rssi:
                    merged[key] = read
    return list(merged.values())

def resolve_position_conflict(read_a, read_b):
    time_diff = abs(read_a.timestamp - read_b.timestamp)
    
    if time_diff < 300:  # 5分钟内
        # 取较晚的读取（设备可能刚被移动）
        return read_a if read_a.timestamp > read_b.timestamp else read_b
    else:
        # 时间差大，可能串读，取信号更强的
        return read_a if read_a.rssi > read_b.rssi else read_b

def check_coverage(merged_result, expected_assets):
    """
    检查盘点是否覆盖了所有预期设备
    """
    read_epcs = set(r.epc for r in merged_result)
    expected_epcs = set(a.epc for a in expected_assets)
    
    missing = expected_epcs - read_epcs      # 预期有但没读到
    unexpected = read_epcs - expected_epcs    # 读到了但台账没有
    
    coverage = len(read_epcs & expected_epcs) / len(expected_epcs)
    
    return {
        'coverage_rate': coverage,
        'missing_count': len(missing),
        'unexpected_count': len(unexpected),
        'missing_epcs': list(missing),
        'unexpected_epcs': list(unexpected)
    }

预期清单 (台账数据)          实际清单 (盘点数据)
    │                              │
    ├──────── Hash匹配 ────────────┤
    │                              │
    ▼                              ▼
  构建HashMap<epc, asset>     构建HashMap<epc, read>
    │                              │
    └──────── 交叉比对 ────────────┘
                │
    ┌───────────┼───────────┐
    ▼           ▼           ▼
  预期有       都有        实际有
  实际无      位置不同     预期无
  →盘亏      →迁移        →盘盈

public DiffReport compare(List<Asset> expected, List<TagRead> actual) {
    Map<String, Asset> expectedMap = expected.stream()
        .collect(Collectors.toMap(Asset::getEpc, a -> a));
    
    Map<String, TagRead> actualMap = actual.stream()
        .collect(Collectors.toMap(TagRead::getEpc, r -> r));
    
    DiffReport report = new DiffReport();
    
    // 遍历实际读取数据
    for (Map.Entry<String, TagRead> entry : actualMap.entrySet()) {
        String epc = entry.getKey();
        TagRead read = entry.getValue();
        
        if (!expectedMap.containsKey(epc)) {
            // 实际有，预期无 → 盘盈
            report.addSurplus(epc, read);
        } else {
            Asset asset = expectedMap.get(epc);
            if (!asset.getLocation().equals(read.getLocation())) {
                // 位置不一致 → 迁移
                report.addMigration(epc, asset.getLocation(), read.getLocation());
            }
            expectedMap.remove(epc); // 已匹配，从预期中移除
        }
    }
    
    // 剩余在expectedMap中的就是盘亏
    for (Asset asset : expectedMap.values()) {
        report.addLoss(asset.getEpc(), asset);
    }
    
    return report;
}

SUSPICIOUS_RSSI_THRESHOLD = -70  # dBm

for read in reads:
    if read.rssi < SUSPICIOUS_RSSI_THRESHOLD:
        read.confidence = "LOW"
        # 不直接丢弃，标记后人工复核
    else:
        read.confidence = "HIGH"

{
  "task_id": "INV-2026-0809-001",
  "device_id": "HANDHELD-003",
  "operator": "zhang_san",
  "start_time": "2026-08-09T14:00:00",
  "end_time": "2026-08-09T15:30:00",
  "device_clock_offset": "+12ms",
  "records": [
    {"epc": "E2801105200056A1", "rssi": -45, "read_time": "2026-08-09T14:05:23", "location": "RACK_A-12U"},
    {"epc": "E2801105200056A2", "rssi": -52, "read_time": "2026-08-09T14:05:23", "location": "RACK_A-13U"}
  ],
  "checksum": "a3f5e8d2..."
}

冲突场景：
- 在线盘点员A在14:30读到设备X在机柜3
- 离线盘点员B在14:25读到设备X在机柜5（14:40才同步上传）

解决策略：
- 按读取时间戳排序（B的14:25早于A的14:30）
- 但B的数据上传时间晚（14:40 > 14:30）
- 取实际读取时间更晚的结果（A的14:30）
- 但标记为"存在位置冲突记录"，供人工复核

漏读原因分类：
├── 标签物理遮挡 (金属设备遮挡标签)
├── 标签角度问题 (标签面朝机柜内侧)
├── 读取距离不足 (手持设备走得太快/太远)
├── 信号干扰 (机柜内金属反射导致信号盲区)
└── 标签失效 (标签电池/天线损坏)