jw-beauty/miniprogram/pages/auto-scan/auto-scan.js

var ble = require('../../services/ble')
var SCAN_TIMEOUT = 180000

Page({
  data: {
    statusBarHeight: 44,
    regions: 0x1F,
    phase: 'ready',
    frameCount: 0,
    pdAvg: [],
    vbat: 0,
    battery: 0,
    error: ''
  },

  onBack: function () {
    wx.navigateBack({
      fail: function () {
        wx.reLaunch({ url: '/pages/index/index' })
      }
    })
  },

  onLoad: function (options) {
    var app = getApp()
    this.setData({
      statusBarHeight: app.globalData.statusBarHeight,
      regions: parseInt(options.regions) || 0x1F
    })
  },

  _cleanup: function () {
    if (this._timeoutTimer) { clearTimeout(this._timeoutTimer); this._timeoutTimer = null }
    if (this._onAdc) { ble.off('adc', this._onAdc); this._onAdc = null }
    if (this._onFitting) { ble.off('fitting', this._onFitting); this._onFitting = null }
    if (this._onRunState) { ble.off('run_state', this._onRunState); this._onRunState = null }
  },

  onStartScan: function () {
    var self = this

    if (!ble.isConnected()) {
      self.setData({ error: '设备未连接' })
      return
    }

    self._pdSum = [0, 0, 0, 0, 0, 0, 0]
    self._frameCount = 0
    self._completed = false
    self._collecting = false
    self._lastFitting = -1
    self._lastRunState = -1
    self.setData({ phase: 'waiting_fit', frameCount: 0, pdAvg: [], error: '' })

    self._onFitting = function (data) {
      if (self._completed) return
      if (data.fitting !== self._lastFitting) {
        console.log('[SCAN] fitting:', data.fitting)
        self._lastFitting = data.fitting
      }
      if (data.fitting === 1 && self._lastRunState === 1 && !self._collecting) {
        console.log('[SCAN] 贴合确认，开始采集PD数据')
        self._collecting = true
        self.setData({ phase: 'collecting' })
      }
    }
    ble.on('fitting', self._onFitting)

    self._onRunState = function (data) {
      if (self._completed) return
      if (data.run_state !== self._lastRunState) {
        console.log('[SCAN] run_state:', data.run_state)
        self._lastRunState = data.run_state
      }

      if (self._lastFitting === 1 && data.run_state === 1 && !self._collecting) {
        console.log('[SCAN] 贴合确认，开始采集PD数据')
        self._collecting = true
        self.setData({ phase: 'collecting' })
      }

      if (self._lastFitting === 0 && data.run_state === 0 && self.data.phase === 'waiting_fit') {
        console.log('[SCAN] 未贴合，检测失败')
        self._completed = true
        self._cleanup()
        self.setData({ phase: 'ready', error: '面膜未佩戴好，请重新佩戴后再试' })
        return
      }

      if (data.run_state === 0 && self._collecting) {
        console.log('[SCAN] 扫描完成，共', self._frameCount, '帧')
        self._scanComplete()
      }
    }
    ble.on('run_state', self._onRunState)

    self._onAdc = function (data) {
      if (self._completed || !self._collecting) return
      if (!data || !data.pd || data.pd.length < 7) return

      self._frameCount++
      for (var i = 0; i < 7; i++) {
        self._pdSum[i] += data.pd[i]
      }
      self.setData({
        frameCount: self._frameCount,
        vbat: data.vbat || self.data.vbat,
        battery: data.battery || self.data.battery
      })
    }
    ble.on('adc', self._onAdc)

    console.log('[SCAN] 发送检测命令 control=0x01')
    ble.setParams({
      region_mask: self.data.regions,
      wavelength: 2,
      brightness: 128,
      hold_time: 0,
      control: 0x01
    }).then(function () {
      console.log('[SCAN] 检测命令发送成功，等待贴合...')
    }).catch(function (err) {
      console.error('[SCAN] 检测命令发送失败:', err)
      self._cleanup()
      self.setData({ phase: 'ready', error: '检测命令发送失败' })
    })

    self._timeoutTimer = setTimeout(function () {
      if (self._completed) return
      console.log('[SCAN] 超时（3分钟），已收到', self._frameCount, '帧')
      if (self._frameCount > 0) {
        self._scanComplete()
      } else {
        self._completed = true
        self._cleanup()
        self.setData({ phase: 'ready', error: '检测超时，未收到数据，请重试' })
      }
    }, SCAN_TIMEOUT)
  },

  _scanComplete: function () {
    if (this._completed) return
    this._completed = true
    this._cleanup()

    var avg = []
    var count = this._frameCount || 1
    for (var i = 0; i < 7; i++) {
      avg.push(Math.round(this._pdSum[i] / count))
    }

    this.setData({ phase: 'done', pdAvg: avg, frameCount: count })
    getApp().globalData.lastScanPdAvg = avg
    console.log('[SCAN] PD平均值:', avg, '帧数:', count)

    this._startTreatment()
  },

  _startTreatment: function () {
    var self = this
    var mask = self.data.regions || 0x1F
    var avg = self.data.pdAvg
    var params = self._calculateTreatParams(mask, avg)

    console.log('[SCAN] 自动发送治疗命令:', JSON.stringify(params))
    ble.setParams(params).then(function () {
      return ble.startTreatment(mask)
    }).then(function () {
      wx.redirectTo({
        url: '/pages/treating/treating?regions=' + mask +
          '&wavelength=2&duration=600000&mode=1'
      })
    }).catch(function (err) {
      self.setData({ error: err.error_msg || '启动治疗失败' })
    })
  },

  _calculateTreatParams: function (mask, pdAvg) {
    // TODO: 接入完整诊断算法（NR 归一化吸收率 → 匹配光谱+强度）
    // 需要 PD→区域映射确认后实现
    return {
      region_mask: mask,
      wavelength: 2,
      brightness: 200,
      duration_ms: 600000,
      mode: 1,
      control: 0x02
    }
  },

  onUnload: function () {
    if (!this._completed && (this.data.phase === 'waiting_fit' || this.data.phase === 'collecting')) {
      ble.stopTreatment().catch(function () {})
    }
    this._cleanup()
  }
})