program/src/utils/bluetooth.js

import game_store from "../store/game";
import ble_store from "../store/bluetooth";
import Notify from "../../static/vant/notify/notify";
import {setDeviceInDb} from "../requests/game";

var $ff = "ff";
var $8f = "ffffffff"
var control_close = false
var connect_toy = true;

export default {

  // 打开大包数据
  sendOpenBigData() {
    this.SendOrder('ff')
  },
  // 关闭大包数据
  sendCloseBigData() {
    this.SendOrder('00')
  },
  //获取当前连接的教具类型
  sendGetToyType() {
    this.SendOrder('06')
  },
  // 开启脑控
  sendControl() {
    this.SendOrder('07')
  },
  //暂停脑控
  sendControlPause() {
    //AA CC 03 00 00 00 09 F3
    this.SendOrder('08')
  },
  // 关闭脑控
  sendControlClose() {
    let that = this
    let $intv = setInterval(() => {
      if (!control_close) {
        that.SendOrder('09')
      } else {
        clearInterval($intv)
        control_close = false
      }
    }, 1000)
  },
  //发送一对多连接
  sendConnectOneToMore(id) {
    this.WriteBufferInBle(`03 00 ${id} 00 0A`);
  },
  //发送一对一连接
  sendConnectOneToOne(id) {
    this.WriteBufferInBle(`03 00 ${id} 01 0A`)
  },

  //获取教具电量
  sendToyPower() {
    let that = this;
    let toy_intv = setInterval(() => {
      if (connect_toy) {
        that.SendOrder('8a')
        connect_toy = false
      }
    }, 3000)
  },

  //  获取大包数据 进行绘制图表
  get_big_data(hex) {
    if (hex.substr(0, 6) != "555520") {
      return false;
    }
    //当s1为 00时 数据有效
    let $s1 = hex.substr(8, 2);
    if ($s1 != "00") {
      return false;
    }

    //专注度数据
    let $att = parseInt("0x" + hex.substr(12, 2));
    //放松度数据
    let $med = parseInt("0x" + hex.substr(16, 2));

    //Delta数据
    let $delta_1 = hex.substr(hex.indexOf("0418") + 4, 2);
    let $delta_2 = hex.substr(hex.indexOf("0418") + 6, 2);
    let $delta_3 = hex.substr(hex.indexOf("0418") + 8, 2);
    let $delta = parseInt($delta_1 + $delta_2 + $delta_3, 16);

    //Theta数据
    let $theta_1 = hex.substr(hex.indexOf("0418") + 10, 2);
    let $theta_2 = hex.substr(hex.indexOf("0418") + 12, 2);
    let $theta_3 = hex.substr(hex.indexOf("0418") + 14, 2);
    let $theta = parseInt($theta_1 + $theta_2 + $theta_3, 16);


    //low_Alpha
    let $low_alpha_1 = hex.substr(hex.indexOf("0418") + 16, 2);
    let $low_alpha_2 = hex.substr(hex.indexOf("0418") + 18, 2);
    let $low_alpha_3 = hex.substr(hex.indexOf("0418") + 20, 2);
    let $low_alpha = parseInt($low_alpha_1 + $low_alpha_2 + $low_alpha_3, 16);

    //high_Alpha
    let $high_alpha_1 = hex.substr(hex.indexOf("0418") + 22, 2);
    let $high_alpha_2 = hex.substr(hex.indexOf("0418") + 24, 2);
    let $high_alpha_3 = hex.substr(hex.indexOf("0418") + 26, 2);
    let $high_alpha = parseInt($high_alpha_1 + $high_alpha_2 + $high_alpha_3, 16);

    //low_beta
    let $low_beta_1 = hex.substr(hex.indexOf("0418") + 28, 2);
    let $low_beta_2 = hex.substr(hex.indexOf("0418") + 30, 2);
    let $low_beta_3 = hex.substr(hex.indexOf("0418") + 32, 2);
    let $low_beta = parseInt($low_beta_1 + $low_beta_2 + $low_beta_3, 16);

    //high_beta
    let $high_beta_1 = hex.substr(hex.indexOf("0418") + 34, 2);
    let $high_beta_2 = hex.substr(hex.indexOf("0418") + 36, 2);
    let $high_beta_3 = hex.substr(hex.indexOf("0418") + 38, 2);
    let $high_beta = parseInt($high_beta_1 + $high_beta_2 + $high_beta_3, 16);
    let $max_num = 30000;
    return {
      att: $att,
      med: $med,
      delta: $delta >= $max_num ? $max_num : $delta,
      theta: $theta >= $max_num ? $max_num : $theta,
      low_alpha: $low_alpha >= $max_num ? $max_num : $low_alpha,
      high_alpha: $high_alpha >= $max_num ? $max_num : $high_alpha,
      low_beta: $low_beta >= $max_num ? $max_num : $low_beta,
      high_beta: $high_beta >= $max_num ? $max_num : $high_beta
    };
  },
  //获取设备电量
  get_device_elc(hex) {
    if (hex.substr(0, 8) != "55550203") {
      return false;
    }
    let $power = parseInt("0x" + hex.substr(8, 2));
    return $power;
  },

  //  监听蓝牙连接状态
  watch_bluetooth_status($this) {
    let that = this;
    // 微信自身监听低功耗蓝牙连接状态的改变事件
    wx.onBLEConnectionStateChange((res) => {
      // 该方法回调中可以用于处理连接意外断开等异常情况
      ble_store.setters.setBluetoothLinkStatus(res.connected);
      if (res.connected == false) {
        //判断游戏是否游戏中
        let $game_status = game_store.getters.getGameStatus();
        if ($game_status == 1) {
          // $that.game_finished();
          //清除状态 设置为默认初始状态 0 小乌龟
          Notify({
            type: 'danger',
            duration: 0,
            message: '智脑环已断开连接，正在尝试重新连接',
            onOpened() {
              that.reconnect(res.deviceId, $this)
            }
          });
          // game_store.setters.setGameStatus(0);
          // 结束状态更改为1

        }
      }
    });
  },

  //重新连接蓝牙
  reconnect($deviceId, $this) {
    let that = this;
    let $serviceId = game_store.getters.getServiceId();
    let $characteristicId = game_store.getters.getReadCharacterId();
    //重连的次数
    let $connect_count = 0;
    let $rec = setInterval(() => {
      $connect_count += 1;
      wx.createBLEConnection({
        deviceId: $deviceId,
        success(res) {
          Notify({type: 'success', message: `第${$connect_count}次重新连接成功`});
          wx.notifyBLECharacteristicValueChange({
            deviceId: $deviceId,
            serviceId: $serviceId,
            characteristicId: $characteristicId,
            state: true,
            success(res) {
              console.log("重新连接SUCCESS,log", res)
              that.watchingDevice($this)
            }, fail(res) {
              console.log("重新失败,log", res)
            }
          })
          that.watchingDevice($this)
          clearInterval($rec)
        },
        fail(res) {
          Notify({type: 'danger', message: `第${$connect_count}次重新连接失败`});
          game_store.setters.setGameCloseStatus(1);
        }
      })
      if ($connect_count == 3) {
        $this.game_finished();
      }

    }, 5000)

  },

  //获取蓝牙设备服务
  getBLEDeviceServices(deviceId) {
    const $this = this;

    wx.getBLEDeviceServices({
      deviceId,
      success: (res) => {
        for (let i = 0; i < res.services.length; i++) {
          console.log("serviceItem:" + res.services[i].uuid);
          if (res.services[i].uuid.indexOf('6E') != -1 || res.services[i].uuid.indexOf('0000FFF0') != -1) {
            console.log("SelectedServiceItem:" + res.services[i].uuid);
            $this.getBLEDeviceCharacteristics(deviceId, res.services[i].uuid);
            return;
          }
        }
      },
      fail(res) {
        console.log("连接蓝牙成功,获取服务失败");
      },
    });
  },

  //获取蓝牙设备某个服务中所有特征值
  getBLEDeviceCharacteristics(deviceId, serviceId) {
    console.log(deviceId, serviceId);
    const $this = this;
    wx.getBLEDeviceCharacteristics({
      deviceId,
      serviceId,
      success: (res) => {
        console.log("getBLEDeviceCharacteristics success", res.characteristics);
        for (let i = 0; i < res.characteristics.length; i++) {
          let item = res.characteristics[i];
          if (item.properties.read) {
            wx.readBLECharacteristicValue({
              deviceId,
              serviceId,
              characteristicId: item.uuid,
            });
          }
          if (item.properties.write) {
            $this.deviceId = deviceId;
            $this.serviceId = serviceId;
            $this.cid = item.uuid;
            game_store.setters.setDeviceId(deviceId);
            game_store.setters.setServiceId(serviceId);
            game_store.setters.setCid(item.uuid);
            //打开数据帧
            $this.sendOpenBigData();
          }

          if (item.properties.notify || item.properties.indicate) {
            wx.notifyBLECharacteristicValueChange({
              deviceId,
              serviceId,
              characteristicId: item.uuid,
              state: true,
            });
            game_store.setters.setReadCid(item.uuid);
          }
        }
      },
      fail(res) {
        console.error("getBLEDeviceCharacteristics", res);
      },
    });
  },

  // ArrayBuffer转16进度字符串示例
  ab2hex(buffer) {
    var hexArr = Array.prototype.map.call(
      new Uint8Array(buffer),
      function (bit) {
        return ("00" + bit.toString(16)).slice(-2);
      }
    );
    return hexArr.join("");
  },


  // 监听脑环数据
  watchingDevice($this) {
    const that = this;
    wx.onBLECharacteristicValueChange((characteristic) => {
      let hexStr = that.ab2hex(characteristic.value);
      // if (hexStr.toUpperCase().indexOf("AADD") != -1) {
      console.log(hexStr);
      // }
      let $data = that.get_big_data(hexStr);
      let $game_status = game_store.getters.getGameStatus();

      // 2021年10月20日17:18:13 判断教具 连接
      if (hexStr.toUpperCase().indexOf("AADD0A") != -1) {
        //没连接上教具
        if (hexStr.toUpperCase().indexOf("AADD0A0000") != -1) {
          $this.change_toy_connect_status(3);
          return false;
        }
        let $hexAry = $this.current_hex.split(" ")
        // 03 00 01 00 0a
        //      [2] [3]
        // 连接上教具
        if (new RegExp("00").test($hexAry[2]) == false) {
          if (new RegExp("00").test($hexAry[3]) == true) {
            that.sendConnectOneToOne($hexAry[2])
            $this.current_hex = `03 00 $hexAry[2] 01 0A`
            console.log("一对多")
          } else {
            console.log("一对一")
            $this.current_hex = "";
            wx.showToast({
              title: "已连接到" + $this.toy_item.name
            });
            $this.toy_connected = true;
            $this.change_toy_connect_status(2);
            //连接成功后 获取一次教具电量信息
            that.SendOrder('8a')
          }
        }
      }


      //2021年10月21日16:30:07
      // 获取教具电量
      if (hexStr.toUpperCase().indexOf("AADD8A") != -1) {//接收教具电量状态
        let $_hexStr = hexStr.substr(6);
        let $power = parseInt($_hexStr.substr(0, 2), 16)
        let $voltage = parseInt($_hexStr.substr(2, 2), 16)
        console.log("电量:" + $power)
        console.log("电压:" + $voltage / 10)
        $this.toy_power = $power;
        //连接上教具的标识
        connect_toy = true;

        //2021年10月25日09:16:06
        //获取教具UUID
        that.SendOrder('84')
      }

      //监听佩戴正确
      if (hexStr.substr(0, 6) == "555520") {
        //当s1为 00时 数据有效
        let $s1 = hexStr.substr(8, 2);
        // console.log("监听脑环是否带正：", $s1 == '00')

        $this.device_bg = $s1 == "00";
      }

      // 2021年10月25日09:15:50
      // 收到一次UUID就发送一次获取教具的电量
      // 读取教具UUID
      if (hexStr.toUpperCase().indexOf("AADD84") != -1) {//接收UUID 5个字节
        let $_hexStr = hexStr.substr(6);
        let $datas = $_hexStr.substr(0, 10);
        if ($datas != "0000000000") {
          $this.toy_UUID = $datas;
        }
      }


      //2021年10月26日11:09:01
      // 量产结束读取数据
      if (hexStr.toUpperCase().indexOf("AADD02") != -1) {
        //脑环型号
        let $ring_type = hexStr.substr(10).substr(0, hexStr.substr(10).length - 2);
        for (let $i = 0; $i < $ring_type.length; $i += 2) {
          let $code = parseInt($ring_type.substr($i, 2), 16)
          $this.device_data.product_model += String.fromCharCode($code)
        }
        that.SendOrder("01")

      }
      if (hexStr.toUpperCase().indexOf("AADD01") != -1) {
        let _UUID = ""
        let $_str4 = hexStr.substr(6);
        let $UUID = $_str4.substr(0, $_str4.length - 2);
        for (let $i = 0; $i < $UUID.length; $i += 8) {
          let $code = $UUID.substr($i, 8);
          _UUID += `${$code}-`
        }
        _UUID = _UUID.substr(0, _UUID.length - 1)
        $this.device_data.UUID = _UUID
        that.SendOrder("03")
      }
      if (hexStr.toUpperCase().indexOf("AADD03") != -1) {
        let $_data = that.DoAnalysis(hexStr, 12);
        $this.device_data.software_version = $_data.substr(0, 4)
        // $this.device_data.software_date = $_data.substr(4)
        that.SendOrder("8d")
      }
      if (hexStr.toUpperCase().indexOf("AADD8D") != -1) {
        let $_str5 = hexStr.substr(10);
        let $version_date = $_str5.substr(0, $_str5.length - 2);
        let $_data = "";
        for (let $i = 0; $i < $version_date.length; $i += 2) {
          let $code = parseInt($version_date.substr($i, 2), 16)
          $_data += String.fromCharCode($code)
        }
        let $version_data = $_data.substr(0, 2).split('')
        $this.device_data.hardware_version = `${$version_data[0]}.${$version_data[1]}`

        setDeviceInDb($this, $this.device.deviceId)
      }

      if (hexStr.toUpperCase().indexOf("AADD09") != -1) {
        control_close = true;
      }


      //  监听脑环电量
      let $power = that.get_device_elc(hexStr);
      if ($power) {
        // console.log("当前脑环电量:", $power)
        $this.device_power = $power;
      }
      if ($power < 10 && $power > 0) {
        wx.showToast({
          title: "脑环电量不足",
          icon: "none",
          duration: 2000,
          success() {
            // $this.change_device_status(0);
          },
        });
      }

      //游戏中模块
      if ($game_status == 1 && $data) {
        try {
          if ($this.played_time > 0) {
            //自定义定时器
            $this.played_time -= 1;
            game_store.setters.setPlayedTime($this.played_time)
            $this.played_time_text = that.formatPlaySeconds($this.played_time);
            $this.do_datas($data);
            if ($this.played_time % 10 == 0) {
              //读取教具电量
              that.SendOrder('8a')
            }
          }
          if ($this.played_time == 0) {
            $this.post_data();
            //判断是否隐藏 隐藏则不绘画
            that.sendControlClose();
            let $hide_status = game_store.getters.getHideStatus();
            if (!$hide_status) {
              $this.game_finished();
            }
          }
        } catch (e) {
          console.log("调用方法失败", e);
        }
      }
    });
  },
  // 游玩时间倒计时
  formatPlaySeconds(value) {
    // 字符串转数字
    var secondTime = parseInt(value); // 秒
    var minuteTime = 0; // 分
    if (secondTime > 60) {
      //如果秒数大于60，将秒数转换成整数
      //获取分钟，除以60取整数，得到整数分钟
      minuteTime = parseInt(secondTime / 60);
      //获取秒数，秒数取佘，得到整数秒数
      secondTime = parseInt(secondTime % 60);
      //如果分钟大于60，将分钟转换成小时
    }
    var result = "" + parseInt(secondTime);

    if (minuteTime > 0) {
      if (result.length == 1) {
        result = "0" + result;
      }
      if (parseInt(minuteTime).toString().length == 1) {
        minuteTime = "0" + parseInt(minuteTime);
      }
      result = "" + minuteTime + ":" + result;
    } else {
      result = "00:" + result;
    }
    return result;
  },

  //根据错误代码返回字符串信息
  GetopenBluetoothAdapterError(errCode) {

    let $errmsg = "";
    if (errCode == 10000) {
      $errmsg = "未初始化蓝牙适配器"
    }

    if (errCode == 10001) {
      $errmsg = "当前蓝牙适配器不可用"
    }

    if (errCode == 10002) {
      $errmsg = "没有找到指定设备"
    }

    if (errCode == 10003) {
      $errmsg = "连接失败"
    }

    if (errCode == 10006) {
      $errmsg = "当前连接已断开"
    }

    return $errmsg;
  },
  //写入buffer
  WriteBufferInBle($hex, $buffer_len = 8) {
    let $device_id = game_store.getters.getDeviceId();
    let $service_id = game_store.getters.getServiceId()
    let $charateristic = game_store.getters.getCharacterId();
    let $hex_header = "aa cc ";
    // let $hex = "03 00 01 00 0a";

    let $hex_sum = 0;
    let $hex_ary = $hex.split(" ");
    $hex_ary.forEach(($val, $index) => {
      $hex_sum += parseInt($val, 16);
    })

    let $checksum = ($hex_sum ^ parseInt($8f, 16)) & parseInt($ff, 16);

    $hex = $hex_header + $hex + " " + $checksum.toString(16);
    let buffer = new ArrayBuffer($buffer_len);
    let dataView = new DataView(buffer);
    $hex_ary = $hex.split(" ");
    $hex_ary.forEach(($val, $index) => {
      dataView.setUint8($index, parseInt($val, 16))
    })

    wx.writeBLECharacteristicValue({
      deviceId: $device_id,
      serviceId: $service_id,
      characteristicId: $charateristic,
      value: buffer,
      success: function (res) {
        console.log($hex + ',写入成功')
      },
      fail: function (err) {
        console.log($hex + "写入失败");
        console.log(err);
      },
    });
  },
  //写入指令
  SendOrder(id) {
    let $hexStr = `03 00 00 00 ${id}`;
    this.WriteBufferInBle($hexStr)
  },
  Send16Order(val, id) {
    let $str = val;
    let $str_ary = $str.split('');
    $str = "";
    $str_ary.forEach(($val, $index) => {
      $str += $val.charCodeAt().toString(16) + " "
    });
    $str = $str.substr(0, $str.length - 1)
    let $hexStr = "03 ff " + $str + ` ${id}`;
    this.WriteBufferInBle($hexStr, 16)
  },
//解析
  DoAnalysis(hexStr, byte_count, sublen = 6) {
    //byte_count
    let $_str5 = hexStr.substr(sublen);
    let $datas = $_str5.substr(0, byte_count * 2);
    let $_data = "";
    for (let $i = 0; $i < $datas.length; $i += 2) {
      let $code = parseInt($datas.substr($i, 2), 16)
      $_data += String.fromCharCode($code)
    }
    return $_data;
  },
};