蓝牙接收数据不是那么的稳定，相比起网络请求，蓝牙更容易出现丢包的情况

蓝牙数据传输

1. 初始化：打开蓝牙模块
2. 搜寻：检测附近存在的设备
3. 连接：找到目标设备进行
4. 监听：开启监听功能，接收其他设备传过来的数据
5. 发送指令：不管发送数据还是读取数据，都可以理解为向外发送指令

传输流程

1. 初始化

   uni.openBluetoothAdapter
   

2. 搜寻附近设备

   1. 开启搜寻功能

      uni.startBluetoothDevicesDiscovery
      

   2. 监听搜寻到新设备

      uni.onBluetoothDeviceFound
      

3. 连接目标设备

   1. 获取设备ID（通过以上的回调，拿到设备ID）

   2. 连接设备

      uni.createBLEConnection
      

   3. 停止搜索

      uni.stopBluetoothDevicesDiscovery
      

4. 监听

   要开启监听，首先需要知道蓝牙设备提供了那些服务，然后通过服务获取特征值，特征值会告诉你哪个可读，哪个可写。最后根据特征值进行消息监听。

   1. 获取蓝牙设备服务

      uni.getBLEDeviceServices
      

   2. 获取特征值

      uni.getBLEDeviceCharacteristics
      

   3. 开启消息监听

      uni.notifyBLECharacteristicValueChange
      

   4. 接收消息监听传来的数据

      uni.onBLECharacteristicValueChange
      

   5. （）设置MTU

5. 发送指令

   uni.writeBLECharacteristicValue
   

案例

//  初始化蓝牙
const initBlue = () => {
  showLoading('正在搜索中')
  uni.openBluetoothAdapter({
    success() {
      discovery()
    },
    fail() {
      showToast('请打开蓝牙')
    },
    complete() {
      hideLoading()
    }
  })
}
//  开始搜索
const discovery = () => {
  uni.startBluetoothDevicesDiscovery({
    success() {
      const map = new Map()
      // 开启监听回调
      uni.onBluetoothDeviceFound(function (res) {
        // console.log(res)
        const {
          deviceId,
          name
        } = res.devices[0]
        console.log(deviceId, name)

        if (map.has(deviceId) || name === "") {
          return
        }
        map.set(deviceId, name)
        // Map 对象转换为一个由键值对数组组成的数组
        // 迭代从 Map 对象转换而来的数组，然后逐步构建一个新的对象
        const obj = Array.from(map).reduce((obj, [key, value]) => {
          obj[key] = value
          return obj
        }, {})
        blueDeviceList.value = [
          ...Object.keys(obj).map((key) => ({
            deviceId: key,
            name: obj[key]
          }))
        ]
      })
    },
    fail(err) {
      showToast(bluetoothCodeList[err.code])
      console.log('搜索失败', err)
    }
  })
}
// 蓝牙设备的id
const deviceId = ref('')
// 连接
const connect = (item) => {
  showLoading('正在连接中')
  deviceId.value = item.deviceId
  uni.createBLEConnection({
    deviceId: deviceId.value,
    success() {
      // 设置mtu
      setMtu()
      // 停止搜索
      stopDiscovery()
      // 获取蓝牙服务
      getServices()
    },
    fail(err) {
      showToast(bluetoothCodeList[err.code])
    },
    complete() {
      hideLoading();
    }
  })
}
// 连接成功停止搜索
const stopDiscovery = () => {
  uni.stopBluetoothDevicesDiscovery({
    success(res) {
      console.log('停止成功', res)
    },
    fail(err) {
      showToast(bluetoothCodeList[err.code])
      console.log('停止失败', err)
    }
  })
}
// 设置MTU
const setMtu = () => {
  setTimeout(function () {
    uni.setBLEMTU({
      deviceId: deviceId.value,
      mtu: 247
    })
  }, 1000)
}
// 服务id
const serviceId = ref('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
// 获取蓝牙服务
const getServices = () => {
  setTimeout(() => {
    uni.getBLEDeviceServices({
      deviceId: deviceId.value, // 设备ID，在上一步获取
      success(res) {
        console.log('获取蓝牙服务成功', res)
        // 获取特征值
        getCharacteristics()
      },
      fail(err) {
        showToast(bluetoothCodeList[err.code])
        console.log('获取失败', err)
      }
    })
  }, 1000)
}
const notify_UUID = ref('')
const write_UUID = ref('')
// 获取特征值
const getCharacteristics = () => {
  showLoading('正在连接中')
  setTimeout(() => {
    uni.getBLEDeviceCharacteristics({
      deviceId: deviceId.value, // 设备ID，在【4】里获取到
      serviceId: serviceId.value, // 服务UUID，在【6】里能获取到
      success(res) {
        console.log(res)
        res.characteristics.forEach(item => {
          if (item.properties.notify && !item.properties.write) {
            notify_UUID.value = item.uuid
          }
          if (item.properties.write && !item.properties.notify) {
            write_UUID.value = item.uuid
          }
        })
        // 开始监听
        notify()
      },
      fail(err) {
        showToast(bluetoothCodeList[err.code])
        console.error(err)
      },
      complete() {
        hideLoading();
      }
    })
  }, 1000)
}
// 开始监听
const notify = () => {
  uni.notifyBLECharacteristicValueChange({
    state: true, // 启用 notify 功能
    deviceId: deviceId.value, // 设备ID
    serviceId: serviceId.value, // 服务UUID
    characteristicId: notify_UUID.value, // notify特征值
    success(res) {
      showToast('连接成功')
      console.log('监听成功', res)
      console.log('监听的参数', deviceId.value, serviceId.value, notify_UUID.value, write_UUID.value)
      // 监听消息变化
      listenValueChange()
    },
    fail(err) {
      showToast(bluetoothCodeList[err.code])
      console.error('监听失败', err)
    }
  })
}
// 获取信息
const getInfo = (str) => {
  const buffer = toBuffer(str)
  setTimeout(() => {
    uni.writeBLECharacteristicValue({
      deviceId: deviceId.value, // 设备ID
      serviceId: serviceId.value, // 服务UUID
      characteristicId: write_UUID.value, // write特征值
      value: buffer,
      writeType: 'writeNoResponse',
      success(res) {
		setStartTime(startTime)
        console.log('写入成功', res)
        console.log('写入的参数', deviceId.value, serviceId.value, write_UUID.value)
      },
      fail(err) {
        showToast(bluetoothCodeList[err.code])
        console.error('写入失败', err)
      }
    })
  }, 1000)
}
let buffer = "" // 数据缓冲区
const listenValueChange = () => {
  uni.onBLECharacteristicValueChange(res => {
    count2.value = count2.value + 1
    endTime2.value = new Date().getTime()
    // value为 ArrayBuffer 类型，所以在控制台无法用肉眼观察到，必须将该值转换为16进制
    const value = ab2hex(res.value)

    buffer += value
    while (true) {
      // 尝试在数据中找到一串合法的数据
      // 从头开始找，找到aaab开头的，然后找到ce结尾的
      let startIndex = buffer.indexOf("aaab");
      if (startIndex !== 0) {
        // 如果不是从头开始，说明前面有垃圾数据，需要清理掉
        console.error("清理掉前面的垃圾数据", buffer)
        buffer = buffer.substr(startIndex)
      }

      // 判断buffer长度是否大于12，如果小于12，说明数据不完整，跳出循环
      if (buffer.length < 12) {
        break
      }
      // 根据“有效数据长度"判断结束位置   有效数据长度 = sta
      let dataLength = parseInt(buffer.substr(8, 4), 16)
      // 包括数据起始位置（12）、有效数据的字节数乘以 2（因为每个字节有两个十六进制字符）、以及一个固定的后缀字节数（4）。
      let endIndex = 12 + dataLength * 2 + 4

      // 判断buffer长度是否大于endIndex，如果小于endIndex，说明数据不完整，跳出循环
      if (buffer.length < endIndex) {
        break
      }
      // 从 buffer 中截取出合法数据块，长度为 endIndex，以便进行处理。
      let data = buffer.substr(0, endIndex)
		// 处理合法数据，交给策略模式
      handleValidData(data)

      // 将已处理的数据块从 buffer 中裁剪掉，以便继续处理下一个数据块。
      buffer = buffer.substr(endIndex)
      // 如果 buffer 已经为空，即没有剩余数据可供处理，就跳出循环。
      if (!buffer) {
        break
      }
    }
  })
}

// 处理合法数据，交给策略模式
function handleValidData(rawData) {
  console.log('合法的数据', rawData)
  // 校验响应包
  // 校验响应包 - 头尾是否准确
  // 判断value头是不是aaab 结尾是不是ce
  if (!(rawData.startsWith("aaab") && rawData.endsWith("ce"))) {
    // 不是就返回
    console.log("头尾不对:", rawData);
    return
  }
  // 校验响应包 - checksum是否准确
  let checksum = parseInt(rawData.substr(rawData.length - 4, 2), 16)
  let sum = calculateByteSum(rawData.substr(0, rawData.length - 4))
  console.log(checksum, sum, checksum === sum)

  // 校验不通过，打印日志，然后return
  if (checksum !== sum) {
    // 不是就返回
    console.log("校验失败");
    return
  }
  console.log("校验成功");
  // 校验通过，裁剪类型、data（数据）出来，传给策略模式
  let type = rawData.substring(4, 8)
  let data = rawData.substring(12, rawData.length - 4)
  // 策略模式(类型,data)
  let strategy = vervelStrategyContext(type, data)
  if (!strategy) {
    console.error("找不到策略：", type)
    return;
  }
  strategy(data)
}

// 策略模式（根据指令类型分配）
vervelStrategyContext....