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,
            // 色温
            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 fn;
      let nextMode = light_cmd.light_worker_mode.DEFAULT;
      if(flag){
        nextMode = light_cmd.light_worker_mode.FULL;
      }

      fn = this.excuteBleSend(
        light_cmd.set_mode(nextMode)
      );
      console.log(fn);
      [_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}`);
    },

    // 计算背景色
    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}
      })
    },
    
    bleFail(title,msg){
      wx.showModal({
        title: title,
        content: msg,
        success (res) { 
          this.setData({
            ble: {...this.data.ble, 
              state: connectStateTypes.unConnect, 
              init: false,
              devName: "",
              deviceId: "",
            },
            bleDevs: []
          });
          bleServices = [];
        }
      });
    },
    // 蓝牙控制板块
    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);
  },

  async connectServices(deviceId){
      // uuid FF01
      let [err,res] = await handle(ble.getBleServices(deviceId));
      if(err){ return this.bleFail('获取服务失败', err.errMsg);}
      // 保存服务信息;
      bleServices = res;
  },



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