第4章 蓝牙数据采集与缓冲：定时读取、数据包校验、内存环形缓冲设计

4.1 设计原理与挑战

蓝牙数据采集位于离线链路的最前端，其可靠性直接决定上传数据的完整性。嵌入式蓝牙设备通常以固定频率（如 10 Hz、50 Hz）向外推送小包数据，而 Android 端存在蓝牙堆栈抖动、线程调度延迟、系统 GC 暂停等不确定因素，导致数据读取极易丢失或重复。本章围绕三个核心设计点展开：定时读取保证采集节奏稳定；数据包校验过滤损坏帧；内存环形缓冲实现生产者‑消费者模式解耦，为后续 OkHttp 上传提供连续、完整的数据源。

4.2 定时读取机制

Android 端通过 ScheduledExecutorService 或 HandlerThread 实现周期读取，避免在 BluetoothGatt 回调中直接执行耗时操作。读取间隔须与蓝牙设备发送周期对齐，常见配置为 50–200 ms。

4.3 数据包校验策略

蓝牙传输受射频干扰、缓冲区溢出等因素影响，数据包可能出现比特翻转、长度截断、乱序等问题。校验策略分为两级：帧结构校验和载荷完整性校验。

4.3.1 帧结构校验

验证包头标志、数据长度域、包尾标志是否匹配预期。典型帧格式如下：

帧格式：[0xAA][0x55][长度(1字节)][载荷(n字节)][校验和(1字节)][0xBB]
校验流程：
  1. 检查头部 0xAA 0x55，不匹配则丢弃整帧
  2. 读取长度域，若载荷长度 != 长度域值 → 丢弃
  3. 累加长度域 + 载荷字节，与校验和比较
  4. 检查尾部 0xBB 是否到位

4.3.2 校验算法对比

4.4 内存环形缓冲设计

环形缓冲区（Ring Buffer）用固定长度的数组和两个指针（读指针 head、写指针 tail）实现 FIFO 队列。核心优势：无动态内存分配、O(1) 入队出队、天然支持生产者‑消费者模式。

4.4.1 核心状态与指针规则

• 初始状态：head = tail = 0，count = 0
• 写数据：将字节写入 tail 位置，tail = (tail + 1) % capacity，count++
• 读数据：从 head 位置读取字节，head = (head + 1) % capacity，count--
• 满判断：count == capacity
• 空判断：count == 0

4.4.2 溢出策略

蓝牙采集场景推荐丢弃旧数据策略：当消费线程（OkHttp 上传）因网络抖动暂时落后时，采集线程持续覆盖最旧帧，保证始终拿到最新数据。

4.5 核心代码实现

以下代码展示了数据包校验、环形缓冲区及定时读取服务的完整实现。所有代码均运行在专用后台线程，避免阻塞蓝牙回调。

4.5.1 数据包校验工具

public class PacketValidator {
    private static final byte HEAD0 = (byte) 0xAA;
    private static final byte HEAD1 = (byte) 0x55;
    private static final byte TAIL  = (byte) 0xBB;

    /**
     * 校验一帧数据，成功返回 true，失败返回 false
     * frame[0..1] = 包头, frame[2] = 载荷长度, frame[3..3+len-1] = 载荷,
     * frame[3+len] = 校验和, frame[3+len+1] = 包尾
     */
    public static boolean verify(byte[] frame, int length) {
        if (length < 5) return false;                     // 最小帧：2包头 + 1长度 + 1校验 + 1包尾
        if (frame[0] != HEAD0 || frame[1] != HEAD1) return false;
        int payloadLen = frame[2] & 0xFF;
        if (payloadLen + 5 != length) return false;      // 总长 = 2包头 + 1长度 + payloadLen + 1校验 + 1包尾
        if (frame[length - 1] != TAIL) return false;

        byte checksum = 0;
        checksum += frame[2];                             // 长度域参与校验
        for (int i = 3; i < 3 + payloadLen; i++) {
            checksum += frame[i];
        }
        return checksum == frame[3 + payloadLen];
    }
}

4.5.2 内存环形缓冲区

public class RingBuffer {
    private final byte[] buffer;
    private int head = 0;
    private int tail = 0;
    private int count = 0;
    private final int capacity;

    public RingBuffer(int capacity) {
        this.capacity = capacity;
        this.buffer = new byte[capacity];
    }

    // 生产者调用：写入长度不超过 available 时成功
    public synchronized boolean put(byte[] data, int offset, int len) {
        if (len <= 0 || len > capacity) return false;
        // 空间不足时丢弃旧数据（覆盖策略）
        while (count + len > capacity) {
            int discard = Math.min(len, capacity - count);
            head = (head + discard) % capacity;
            count -= discard;
        }
        for (int i = 0; i < len; i++) {
            buffer[tail] = data[offset + i];
            tail = (tail + 1) % capacity;
        }
        count += len;
        return true;
    }

    // 消费者调用：读取最多 maxLen 字节到 dest，返回实际读取字节数
    public synchronized int get(byte[] dest, int maxLen) {
        if (count == 0 || maxLen <= 0) return 0;
        int toRead = Math.min(count, maxLen);
        for (int i = 0; i < toRead; i++) {
            dest[i] = buffer[head];
            head = (head + 1) % capacity;
        }
        count -= toRead;
        return toRead;
    }

    public synchronized int available() { return count; }
    public synchronized boolean isEmpty() { return count == 0; }
}

4.5.3 定时采集服务

public class BleCollectorService {
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    private final RingBuffer ringBuffer = new RingBuffer(4096);   // 4 KB 环形缓冲
    private final BluetoothGatt gatt;
    private volatile boolean running = false;

    public BleCollectorService(BluetoothGatt gatt) { this.gatt = gatt; }

    public void start(int intervalMs) {
        running = true;
        scheduler.scheduleAtFixedRate(() -> {
            if (!running) return;
            try {
                // 1. 从蓝牙特征读取原始数据
                byte[] raw = gatt.readCharacteristicSync();   // 伪代码，实际需封装同步读
                if (raw == null || raw.length == 0) return;

                // 2. 数据包校验
                if (!PacketValidator.verify(raw, raw.length)) {
                    Metrics.recordDrop("checksum_fail");
                    return;
                }

                // 3. 提取净载荷（去掉包头、长度、校验、包尾）
                int payloadLen = raw[2] & 0xFF;
                byte[] payload = new byte[payloadLen];
                System.arraycopy(raw, 3, payload, 0, payloadLen);

                // 4. 写入环形缓冲区
                ringBuffer.put(payload, 0, payload.length);
                Metrics.recordEnqueue(payload.length);
            } catch (Exception e) {
                Metrics.recordDrop("collector_error");
            }
        }, 0, intervalMs, TimeUnit.MILLISECONDS);
    }

    public void stop() {
        running = false;
        scheduler.shutdownNow();
    }

    public RingBuffer getBuffer() { return ringBuffer; }
}

4.6 调试与验证

采集与缓冲阶段的调试重点在于验证无丢帧、无损坏帧写入缓冲、环形缓冲不溢出崩溃。

4.6.1 调试手段

• 日志打点：每次校验失败输出帧头尾字节序列，便于定位射频干扰模式
• 缓冲区水位监控：每隔 1 s 输出 ringBuffer.available() 值，观察是否持续增长或跳动异常
• 序列号追踪：要求蓝牙设备在载荷中嵌入递增序列号（1 字节，0–255），接收端检测跳号即可量化丢帧率

4.6.2 验证指标

4.7 性能优化要点

• 缓冲区大小选择：典型经验值 = 蓝牙设备发送速率 (bytes/s) × 最大预期网络中断时间 (s)。例如 100 B/packet × 20 Hz × 30 s = 60 KB，取 64 KB 对齐
• 避免 byte[] 频繁分配：在采集线程内预分配复用缓冲区，每次读取后拷贝净载荷而非创建新数组
• 锁粒度控制：环形缓冲使用 synchronized 保护，但 put/get 内循环应尽量短；若并发压力高可用 ReentrantLock + 条件变量
• 批量出队：消费线程每次调用 get(dest, 512) 批量取出数据，减少锁竞争次数

4.8 常见错误与避坑