sony-ble/pages/light/light.js

// pages/light/light.js
import { connectStateMap, connectStateTypes } from '../../data/devType.js'
import { MAX_COLOR_TEMPERATURE, MIN_COLOR_TEMPERATURE, COLOR_TEMPERATURE_STEP, bleInfo } from '../../data/lampType.js'
import { handle } from '../../utils/mjs_handle.js'
import { calculateColor } from '../../utils/mjs_color.js'
import light_cmd from '../../utils/light_cmd.js'
import { _curry } from '../../utils/mjs_curry.js'
import BLE from '../../utils/mjs_wxble.js'
console.log(BLE);
const ble = new BLE(null, ["bleLight"]);
const tmpDevs = [
    {
        id: 1,
        name: "123",
        deviceId: "1234"
    },
    {
        id: 2,
        name: "设备2",
        deviceId: "23456"
    }
]
// 蓝牙模块连接对象信息参数
const connectBleParams = [];
// 蓝牙服务信息
let bleServices = [];
Page({

    /**
     * 页面的初始数据
     */
    data: {
        // unConnect scaning connecting connected
        connectStateTypes: connectStateTypes,
        ble: {
            state: connectStateTypes.unConnect,
            devName: "",
            deviceId: "",
            init: false,
            // 控制uuid
            controlUuid: "",
            // 监听数据uuid
            notifyUuid: "",
        },
        lamp: {
            // 信息相关
            temp_max: MAX_COLOR_TEMPERATURE,
            temp_min: MIN_COLOR_TEMPERATURE,
            temp_step: COLOR_TEMPERATURE_STEP,
            // 开关状态
            switch: false,
            // 全开状态(无色温调节)
            fullOpen: false,
            // 亮度
            brightness: 50,
            fan: 0,
            // 色温
            colorTemperature: MAX_COLOR_TEMPERATURE,
            // 色彩
            bgc: "#3b3b3b"
        },
        bleDevs: tmpDevs,
    },
    // 获取蓝牙发送数据对象
    excuteBleSend(data){
      console.log('获取蓝牙发送数据对象');
      // 固定值
      let controlUuid = bleInfo.controlUuid;
      let characteristicFirstUuid = bleInfo.characteristicFirstUuid;

      let deviceId = this.data.ble.deviceId;
      let serverUuid = '';
      let characteristicUuid = '';
      let characteristic;
      let server = bleServices.find(s=>{
        console.log(`服务uuid ${s.uuid}`);
        console.log(s);
        return s.uuid.startsWith(controlUuid);
      });
      if(!server)
      {
        serverUuid = bleInfo.controlUuid;
      }else
      {
        serverUuid = server.uuid;
        characteristic = server.characteristics.find(c=>
          c.uuid.startsWith(characteristicFirstUuid)
        );
      }

      //获取
      
      
      if(!characteristic)
      {
        // return bleFail('获取服务失败', '该设备不支持该程序');
        characteristicUuid = bleInfo.controlUuid;
      }
      else
      {
        characteristicUuid = characteristic.uuid;
      }
      console.log(`服务uuid ${serverUuid} 特征uuid ${characteristicUuid}`);

      return ble.sendData(deviceId, serverUuid, characteristicUuid, data);
    },
    // 亮度调节
    async brightnessChangeHandle(e){
        console.log("亮度改变");
        console.log(e);
        this.setData({
          lamp: {...this.data.lamp, brightness: e.detail.value}
        })
        this.reComputeBgColor();
        
        let fn = this.excuteBleSend(
          light_cmd.set_light(this.data.lamp.brightness)
          );
        let [_err,_res] = await handle(fn);
        if(_err){
          console.log(_err);
          return this.bleFail('发送失败', _err.errMsg);
        }
        console.log(`亮度调节命令发送成功,亮度:${this.data.lamp.brightness}`);
    },
    async colorChangeHandle(e){
      console.log("色温改变");
      console.log(e);
      this.setData({
        lamp: {...this.data.lamp, colorTemperature: e.detail.value}
      })
      this.reComputeBgColor();

      let fn = this.excuteBleSend(
        light_cmd.set_temp(this.data.lamp.colorTemperature)
      );
      let [_err,_res] = await handle(fn);
      if(_err){
        return this.bleFail('发送失败', _err.errMsg);
      }
      console.log(`亮度调节命令发送成功,亮度:${this.data.lamp.colorTemperature}`);
    },
    async executeFullModeSwitch(flag){
      this.setData({
        lamp: {...this.data.lamp, fullOpen: flag}
      })

      
      let nextMode = light_cmd.light_worker_mode.DEFAULT;
      if(flag){
        nextMode = light_cmd.light_worker_mode.FULL;
      }

      let fn = this.excuteBleSend(
        light_cmd.set_mode(nextMode)
      );
      console.log(fn);
      let [_err,_res] = await handle(fn);
      if(_err){
        return this.bleFail('发送失败', _err.errMsg);
      }
      console.log(`工作模式切换成功:${this.data.lamp.fullOpen}`);
    },
    async fullModeSwitchHandle(e){
      // 全开模式切换
      console.log("全开模式切换");
      let _err,_res;
      let flag = !this.data.lamp.fullOpen;
      if(!this.data.lamp.switch){
        return;
      }

      if (flag) {
        // 弹窗询问是否需要启动全开模式
        wx.showModal({
              title: '提示',
              content: '是否启动全开模式',
              success: (res) => {
                  if (res.confirm) {
                    this.executeFullModeSwitch(flag);
                  } else if (res.cancel) {
                    console.log('用户点击取消')
                    return;
                  }
              }
          });
      }else{
        this.executeFullModeSwitch(flag);
      }
    },
    async switchHandle(e){
        let _err,_res;
        // 开关切换
        this.setData({
            lamp: {...this.data.lamp, switch: !this.data.lamp.switch}
        });
        this.setData({
            lamp: {...this.data.lamp, fullOpen: false}
        })
        
        this.reComputeBgColor();

        console.log(`开关切换:${this.data.lamp.switch}`);
        let fn;
        if(this.data.lamp.switch){
          fn = this.excuteBleSend(
            light_cmd.open_light()
          );
        }else{
          fn = this.excuteBleSend(
            light_cmd.close_light()
          );
        }
        
        [_err,_res] = await handle(fn);
        if(_err){
          console.log(_err);
          return this.bleFail('发送失败', _err.errMsg);
        }
        console.log(`开关命令发送成功,开关:${this.data.lamp.switch}`);
    },
    registerLightCmdAction(){
      // 灯光信息响应
      light_cmd.registerHandle(light_cmd.light_cmd_code.CMD_QUERY, (data)=>{
        console.log('灯光状态响应');
        data = data.join('');
        console.log(data);
        // 灯光数据 开关状态 模式 亮度 色温 风扇速度
        let switchState = data.slice(0, 2);
        let mode = data.slice(2, 4);
        // 亮度 占1位
        let light = data.slice(4, 6);
        // 色温 占2位
        let temp = data.slice(6, 10);
        // 风扇速度 占1位
        let fan = data.slice(10, 12);
        light = parseInt(light, 16);
        temp = parseInt(temp, 16);
        fan = parseInt(fan, 16);
        switchState = switchState === '01';
        let infoStr = `设备:${this.data.ble.deviceId} `
        infoStr += `开关:${switchState ? '开':'关'} `
        infoStr += `模式:${mode} `
        infoStr += `色温:${temp} `
        infoStr += `亮度:${light} `
        infoStr += `风扇:${fan} `
        console.log(infoStr);
        this.setData({
          lamp: {...this.data.lamp, 
            switch: switchState,
            fullOpen:  mode === light_cmd.light_worker_mode.FULL,
            colorTemperature: temp,
            brightness: light,
            fan: fan
          }
        });
        this.reComputeBgColor();
      });
      // 色温响应
      light_cmd.registerHandle(light_cmd.light_cmd_code.CMD_TEMP, (data)=>{
        console.log('色温调节响应');
        data = data.join('');
        console.log(data);
        // hex转10进制
        let temp = parseInt(data, 16);
        console.log(temp);
        this.setData({
          lamp: {...this.data.lamp, colorTemperature: temp}
        })
        this.reComputeBgColor();
      });
      // 亮度响应
      light_cmd.registerHandle(light_cmd.light_cmd_code.CMD_LIGTH, (data)=>{
        console.log('亮度调节响应');
        data = data.join('');
        // hex转10进制
        let light = parseInt(data, 16);
        console.log(light);
        this.setData({
          lamp: {...this.data.lamp, brightness: light}
        })
        this.reComputeBgColor();
      });
      // 开灯响应
      light_cmd.registerHandle(light_cmd.light_cmd_code.CMD_OPEN, (data)=>{
        console.log('开灯调节响应');
        data = data.join('');
        console.log(data);
        this.setData({
          lamp: {...this.data.lamp, switch: true}
        });
        this.reComputeBgColor();
      });
      // 关灯响应
      light_cmd.registerHandle(light_cmd.light_cmd_code.CMD_CLOSE, (data)=>{
        console.log('关灯调节响应');
        data = data.join('');
        console.log(data);
        this.setData({
          lamp: {...this.data.lamp, switch: false}
        });
        this.reComputeBgColor();
      });
      // 模式切换响应
      light_cmd.registerHandle(light_cmd.light_cmd_code.CMD_MODE, (data)=>{
        console.log('模式调节响应');
        data = data.join('');
        console.log(data);
        let mode = parseInt(data, 16);
        this.setData({
          lamp: {...this.data.lamp, fullOpen: mode === light_cmd.light_worker_mode.FULL}
        });
        this.reComputeBgColor();
      });
    },

    // 计算背景色
    reComputeBgColor(){
      let newBgC;
      let temp = this.data.lamp.colorTemperature;
      let light = this.data.lamp.brightness;
      if(this.data.lamp.fullOpen){
          temp = MAX_COLOR_TEMPERATURE / 2;
      }
      if(this.data.lamp.switch){
          newBgC = calculateColor(temp, light);
      }else{
          newBgC = "#3b3b3b";
      }
      this.setData({
          lamp: {...this.data.lamp, bgc: newBgC}
      })
    },
    initPageInfo(){
      this.setData({
        ble: {...this.data.ble, 
          state: connectStateTypes.unConnect, 
          init: false,
          devName: "",
          deviceId: "",
        },
        bleDevs: [],
      });
      bleServices = [];
      // 灯光信息初始化
    },
    // 连接失败
    bleFail(title,msg){
      wx.showModal({
        title: title,
        content: msg,
        success: (res) =>{ 
          this.initPageInfo();
        }
      });
    },

    disconnectHandle(){
      this.excuteDisconnect();
    },

    async excuteDisconnect(){
      console.log('断开连接');
      if(this.data.ble.state !== connectStateTypes.connected){
        return this.bleFail('断开连接失败', '当前未连接设备');
      }
      let err,res;
      [err,res] = await handle(ble.disconnectDev(this.data.ble.deviceId));
      if(err){
        return this.bleFail('断开连接失败', err.errMsg);
      }
      light_cmd.clearHandle();
      wx.showToast({title: `断开连接成功`, })
      this.initPageInfo();
    },
    // 蓝牙控制板块
    searchDeviceHandle() {
        // 开始搜索设备
        this.excuteSearchDevice();
    },
    
    async excuteSearchDevice(){
        console.log("搜索 蓝牙设备");
        let err,res;
        if(!this.data.ble.init){
          [err,res] = await handle(ble.initBle());
          if(err){
            return this.bleFail('蓝牙初始化失败', err.errMsg);
          }
          ble.onSearch = this.onSearchHandle;
        }
        this.setData({
          ble: {...this.data.ble, 
            state: connectStateTypes.scaning, 
            init: true
          },
          bleDevs: []
        });
        ble.search(this.onSearchHandle);
    },
    // 搜索到设备基础函数
    onSearchHandle(device){
      console.log('搜索到设备');
      if(this.data.bleDevs.find(dev=>dev.deviceId === device.deviceId )){
        return console.log('设备再次被搜索到');
      }
      console.log(device);
      device.id = device.deviceId;
      let arr = this.data.bleDevs;
      arr.push(device);
      this.setData({
        bleDevs: arr
      })
    },
    // 连接设备
    async connectDevHandle(e) {
      console.log("click connectDev")
      let err,res;
      let dev = e.detail;
      console.log(dev);
      this.setData({
        ble: {...this.data.ble,state: connectStateTypes.connecting, 
          devName: dev.name, 
          deviceId: dev.deviceId
        },
      });
      // 停止搜索
      [err,res] = await handle(ble.stopSearch());
      if(err){
        return this.bleFail('停止搜索失败', err.errMsg);
      }
      wx.showToast({title: `连接${dev.name}中...`, })
      // 连接至设备
      [err,res] = await handle(ble.connectDev(dev.deviceId));
      if(err){  return this.bleFail('连接失败', err.errMsg);}
      // 连接成功
      this.setData({
        ble:{...this.data.ble, state:connectStateTypes.connected }
      });
      // 设备服务管理
      this.connectServices(dev.deviceId);
      // 注册监听函数
      ble.registerListenerHandle(this.onNotifyHandle);
      
  },
  onNotifyHandle(data){
    console.log(`收到数据:${data}`);
    // 解析数据
    light_cmd.parseCmdData(data);
  },
  async connectServices(deviceId){
      // uuid FF01
      let [err,res] = await handle(ble.getBleServices(deviceId));
      if(err){ return this.bleFail('获取服务失败', err.errMsg);}
      // 保存服务信息;
      bleServices = res;

      // 注册灯光响应函数
      this.registerLightCmdAction();
      // 查询灯光状态
      let fn = this.excuteBleSend(
        light_cmd.query_light()
      );
      [_err,_res] = await handle(fn);
      if(_err){
        console.log(_err);
        return this.bleFail('发送失败', _err.errMsg);
      }
  },



      
    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
  
    },
  
    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {
  
    },
  
    /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 配置导航栏
    wx.setNavigationBarTitle({
      title: '灯光控制'
    })
  },
  
    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {
  
    },
  
    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {
  
    },
  
    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {
  
    },
  
    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {
  
    },
  
    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {
  
    }
  })