小程序蓝牙与 IoT 设备连接实战

function initBluetooth() {
  return new Promise((resolve, reject) => {
    wx.openBluetoothAdapter({
      mode: 'central',   // 手机作为中心设备
      success: resolve,
      fail: (err) => {
        // 10000 未初始化适配器；10001 适配器不可用（通常是手机蓝牙未打开）
        if (err.errCode === 10001) {
          wx.showModal({
            title: '请打开蓝牙',
            content: '需要开启手机蓝牙才能搜索设备',
            confirmText: '去设置',
            success: (r) => { if (r.confirm) wx.openSystemBluetoothSetting(); }
          });
        }
        reject(err);
      }
    });
  });
}

// 用户中途关蓝牙时清理连接状态
wx.onBluetoothAdapterStateChange((res) => {
  if (!res.available) resetConnectionState();
});

async function startScan() {
  await initBluetooth();

  wx.onBluetoothDeviceFound((res) => {
    res.devices.forEach((device) => {
      // device.name 可能为空字符串，需要按规则过滤
      if (!/^SmartLock_/.test(device.localName || '')) return;
      handleDevice({
        deviceId: device.deviceId,
        name: device.localName || device.name,
        rssi: device.RSSI,
        advertisData: device.advertisData,   // ArrayBuffer
        advertisServiceUUIDs: device.advertisServiceUUIDs
      });
    });
  });

  wx.startBluetoothDevicesDiscovery({
    services: ['0000FFE0-0000-1000-8000-00805F9B34FB'],  // 只扫特定服务，降功耗减噪音
    allowDuplicatesKey: false,                            // 同一设备只上报一次
    powerLevel: 'high',                                   // Android 有效
    fail: (err) => console.error('扫描失败', err)
  });
}

function connect(deviceId, timeout = 10000) {
  // 10012 连接超时；10003 连接失败
  return new Promise((resolve, reject) => {
    wx.createBLEConnection({ deviceId, timeout, success: resolve, fail: reject });
  });
}

// 建立连接后立刻挂监听，否则断线时业务无感知
wx.onBLEConnectionStateChange((res) => {
  if (!res.connected) {
    markDisconnected(res.deviceId);
    scheduleReconnect(res.deviceId);
  }
});

function scheduleReconnect(deviceId) {
  const state = reconnectMap.get(deviceId) || { attempts: 0, timer: null };
  if (state.attempts >= 5) {
    wx.showToast({ title: '设备连接已断开', icon: 'none' });
    return;
  }

  const delay = Math.pow(2, state.attempts) * 1000;   // 1s, 2s, 4s, 8s, 16s
  state.timer = setTimeout(async () => {
    state.attempts += 1;
    reconnectMap.set(deviceId, state);
    try {
      await connect(deviceId);
      await discoverGatt(deviceId);     // 必须重新发现服务
      await resubscribe(deviceId);      // 必须重新订阅通知
    } catch (e) {
      scheduleReconnect(deviceId);      // 递归触发下一次退避重试
    }
  }, delay);
  reconnectMap.set(deviceId, state);
}

async function discoverGatt(deviceId) {
  const services = await promisify(wx.getBLEDeviceServices)({ deviceId });
  for (const service of services.services) {
    const chars = await promisify(wx.getBLEDeviceCharacteristics)({
      deviceId, serviceId: service.uuid
    });
    chars.characteristics.forEach((c) => console.log('特征值:', c.uuid, c.properties));
  }
}

function subscribe(deviceId, serviceId, characteristicId, handler) {
  wx.onBLECharacteristicValueChange((res) => {
    // 全局回调会收到所有特征值的数据，必须按 id 分发
    if (res.deviceId === deviceId && res.characteristicId === characteristicId) {
      handler(res.value);   // res.value 是 ArrayBuffer
    }
  });

  wx.notifyBLECharacteristicValueChange({
    deviceId, serviceId, characteristicId, state: true,
    fail: (err) => console.error('订阅失败', err)
  });
}

async function writeLong(deviceId, serviceId, characteristicId, buffer, chunkSize = 20) {
  const total = buffer.byteLength;
  for (let offset = 0; offset < total; offset += chunkSize) {
    const chunk = buffer.slice(offset, Math.min(offset + chunkSize, total));
    await write(deviceId, serviceId, characteristicId, chunk);
    await sleep(20);   // 部分设备固件需要包间隔，过快会丢包
  }
}

// Android 可协商更大 MTU 提升吞吐，成功时返回实际单包载荷
function requestMtu(deviceId, mtu) {
  if (!wx.setBLEMTU) return Promise.resolve(20);
  return new Promise((resolve) => {
    wx.setBLEMTU({
      deviceId, mtu,   // iOS 最大 185，Android 最大 512
      success: (res) => resolve(Math.max(res.mtu - 3, 20)),
      fail: () => resolve(20)
    });
  });
}

// utils/buffer.js
// ArrayBuffer -> 十六进制字符串（调试打印用）
function ab2hex(buffer) {
  return Array.prototype.map
    .call(new Uint8Array(buffer), (b) => b.toString(16).padStart(2, '0'))
    .join('');
}

function parseFrame(buffer) {
  const view = new DataView(buffer);
  const bytes = new Uint8Array(buffer);

  if (bytes[0] !== 0xaa) throw new Error('非法帧头');
  const length = view.getUint16(2, true);   // 小端
  const command = view.getUint8(4);
  const payload = buffer.slice(5, 5 + length);

  let sum = 0;
  for (let i = 0; i < 5 + length; i++) sum = (sum + bytes[i]) & 0xff;
  if (sum !== view.getUint8(5 + length)) throw new Error('校验失败');

  return { command, payload };
}

push(chunk) {
  const merged = new Uint8Array(this.buffer.length + chunk.byteLength);
  merged.set(this.buffer, 0);
  merged.set(new Uint8Array(chunk), this.buffer.length);
  this.buffer = merged;

  while (this.buffer.length >= 6) {
    if (this.buffer[0] !== 0xaa) {
      const idx = this.buffer.indexOf(0xaa, 1);
      this.buffer = idx === -1 ? new Uint8Array(0) : this.buffer.slice(idx);
      continue;
    }
    const length = this.buffer[2] | (this.buffer[3] << 8);
    const frameLen = 5 + length + 1;
    if (this.buffer.length < frameLen) break;   // 半帧，等待后续数据

    const frame = this.buffer.slice(0, frameLen);
    this.buffer = this.buffer.slice(frameLen);
    try { this.onFrame(parseFrame(frame.buffer)); }
    catch (e) { console.warn('帧解析失败', e.message); }
  }
}

async function provision(deviceId, serviceId, writeCharId, notifyCharId, wifi) {
  const token = await fetchProvisionToken();   // 服务端下发的短时凭据
  const resultPromise = waitForResult(deviceId, notifyCharId, 30000);

  // 凭据通常超过 20 字节，需要按 MTU 分包写入
  const payload = JSON.stringify({
    ssid: wifi.ssid, password: wifi.password, token, endpoint: 'iot.example.com'
  });
  await writeLong(deviceId, serviceId, writeCharId, str2ab(payload));

  const result = await resultPromise;
  if (result.code !== 0) throw new Error(mapErrorCode(result.code));
  return result;
}

function waitForResult(deviceId, characteristicId, timeout) {
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => reject(new Error('配网超时')), timeout);
    const handler = (res) => {
      if (res.characteristicId !== characteristicId) return;
      clearTimeout(timer);
      wx.offBLECharacteristicValueChange(handler);
      resolve(JSON.parse(ab2str(res.value)));
    };
    wx.onBLECharacteristicValueChange(handler);
  });
}

[ ] 手机蓝牙已开启，且已授权小程序；Android 还需打开系统定位
[ ] 设备未被其他手机占用（BLE 通常只允许单连接）
[ ] 设备电量充足，距离在 5 米内
[ ] 避开微波炉、USB 3.0 设备等 2.4G 干扰源
[ ] 使用 vConsole 或自定义日志面板查看回调时序