feat: redesign auto-scan as detection page with manual trigger and PD averaging

- Add "start detection" button (not auto-start on page load)
- Send control=0x01 only when user clicks button
- Accumulate PD values across all ADC frames during scan
- Monitor run_state: wait for 0x01→0x00 transition as completion signal
- Calculate PD averages on completion
- Send treatment command (control=0x02) on "next" with calculated params
- TODO: plug in full NR diagnosis algorithm when PD→region mapping confirmed

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

@@ -1,16 +1,14 @@
 var ble = require('../../services/ble')
-var SCAN_TIMEOUT = 15000
-var SPECTRUM_NAMES = ['红光', '紫外光', '黄光', '红外光']
-var SPECTRUM_COUNT = 4
+var SCAN_TIMEOUT = 30000
 
 Page({
   data: {
     statusBarHeight: 44,
-    scanning: true,
-    scanProgress: 0,
     regions: 0x1F,
-    spectrumIndex: 0,
-    spectrumData: [],
+    state: 'ready',
+    scanProgress: 0,
+    frameCount: 0,
+    pdAvg: [],
     vbat: 0,
     battery: 0,
     error: ''
@@ -30,7 +28,6 @@ Page({
       statusBarHeight: app.globalData.statusBarHeight,
       regions: parseInt(options.regions) || 0x1F
     })
-    this.startScan()
   },
 
   _cleanup: function () {
@@ -40,72 +37,72 @@ Page({
     if (this._onRunState) { ble.off('run_state', this._onRunState); this._onRunState = null }
   },
 
-  startScan: function () {
+  onStartScan: function () {
     var self = this
-    self._scanResults = []
-    self._completed = false
 
     if (!ble.isConnected()) {
-      self.setData({ scanning: false, error: '设备未连接，请先连接设备' })
+      self.setData({ error: '设备未连接' })
       return
     }
 
-    self.setData({ scanning: true, scanProgress: 0, error: '', spectrumData: [], spectrumIndex: 0 })
+    self._pdSum = [0, 0, 0, 0, 0, 0, 0]
+    self._frameCount = 0
+    self._completed = false
+    self._seenScanning = false
+    self.setData({ state: 'scanning', scanProgress: 0, frameCount: 0, pdAvg: [], error: '' })
 
-    this._progressTimer = setInterval(function () {
-      var target = ((self._scanResults.length + 1) / SPECTRUM_COUNT) * 90
+    self._progressTimer = setInterval(function () {
       var p = self.data.scanProgress
-      if (p < target) p += 1
-      if (p > 90) p = 90
-      self.setData({ scanProgress: p })
-    }, 100)
+      if (p < 90) self.setData({ scanProgress: p + 1 })
+    }, 200)
 
-    this._onAdc = function (data) {
-      if (!self.data.scanning) return
-      var idx = self._scanResults.length
-      if (idx >= SPECTRUM_COUNT) return
+    self._onAdc = function (data) {
+      if (self._completed) return
+      if (!data || !data.pd || data.pd.length < 7) return
 
-      console.log('[SCAN] 收到第' + (idx + 1) + '组ADC (' + SPECTRUM_NAMES[idx] + '):', data.pd)
-      self._scanResults.push({
-        spectrum: SPECTRUM_NAMES[idx],
-        pd: data.pd.slice(0),
-        vbat: data.vbat,
-        battery: data.battery
+      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
       })
-      self.setData({ spectrumIndex: idx + 1 })
+    }
+    ble.on('adc', self._onAdc)
 
-      if (self._scanResults.length >= SPECTRUM_COUNT) {
+    self._onRunState = function (data) {
+      if (self._completed) return
+      console.log('[SCAN] run_state:', data.run_state)
+      if (data.run_state === 0x01) {
+        self._seenScanning = true
+      }
+      if (data.run_state === 0x00 && self._seenScanning) {
+        console.log('[SCAN] 检测完成，收到', self._frameCount, '帧')
         self._scanComplete()
       }
     }
-    ble.on('adc', this._onAdc)
+    ble.on('run_state', self._onRunState)
 
-    this._onRunState = function (data) {
-      if (data.run_state === 0x00 && self._scanResults.length > 0 && self.data.scanning) {
-        console.log('[SCAN] 设备进入IDLE，扫描结束')
-        self._scanComplete()
-      }
-    }
-    ble.on('run_state', this._onRunState)
-
-    console.log('[SCAN] 下发扫描指令，等待固件序贯扫描 R→UV→Y→IR')
+    console.log('[SCAN] 发送检测命令 control=0x01')
     ble.setParams({
       region_mask: self.data.regions,
       wavelength: 2,
       brightness: 128,
-      hold_time: 10,
+      hold_time: 0,
       control: 0x01
     }).then(function () {
-      console.log('[SCAN] 扫描指令发送成功')
+      console.log('[SCAN] 检测命令发送成功')
     }).catch(function (err) {
-      console.error('[SCAN] 扫描指令发送失败:', err)
+      console.error('[SCAN] 检测命令发送失败:', err)
       self._cleanup()
-      self.setData({ scanning: false, scanProgress: 0, error: '扫描指令发送失败' })
+      self.setData({ state: 'ready', error: '检测命令发送失败' })
     })
 
-    this._timeoutTimer = setTimeout(function () {
-      if (!self.data.scanning) return
-      console.log('[SCAN] 超时，已收到' + self._scanResults.length + '组数据')
+    self._timeoutTimer = setTimeout(function () {
+      if (self._completed) return
+      console.log('[SCAN] 超时，已收到', self._frameCount, '帧')
       self._scanComplete()
     }, SCAN_TIMEOUT)
   },
@@ -114,57 +111,27 @@ Page({
     if (this._completed) return
     this._completed = true
     this._cleanup()
-    this.setData({ scanning: false, scanProgress: 100 })
-    this._buildDisplay()
-  },
 
-  _buildDisplay: function () {
-    var results = this._scanResults || []
-    var spectrumData = []
-
-    for (var s = 0; s < results.length; s++) {
-      var r = results[s]
-      var items = []
-      for (var i = 0; i < 7; i++) {
-        var val = r.pd[i] || 0
-        items.push({
-          label: 'PD' + (i + 1),
-          value: val,
-          barWidth: Math.min(100, Math.round(val / 40.95))
-        })
-      }
-      spectrumData.push({ name: r.spectrum, items: items })
+    var avg = []
+    var count = this._frameCount || 1
+    for (var i = 0; i < 7; i++) {
+      avg.push(Math.round(this._pdSum[i] / count))
     }
 
-    if (results.length > 0) {
-      var last = results[results.length - 1]
-      this.setData({
-        vbat: last.vbat || 0,
-        battery: last.battery || 0
-      })
-    }
-
-    getApp().globalData.lastScanData = results
-    this.setData({ spectrumData: spectrumData })
-  },
-
-  onUnload: function () {
-    this._cleanup()
-    ble.stopTreatment().catch(function () {})
+    this.setData({ state: 'done', scanProgress: 100, pdAvg: avg })
+    getApp().globalData.lastScanPdAvg = avg
+    console.log('[SCAN] PD平均值:', avg, '帧数:', count)
   },
 
   onNext: function () {
     var self = this
     var mask = self.data.regions || 0x1F
+    var avg = self.data.pdAvg
 
-    ble.setParams({
-      region_mask: mask,
-      wavelength: 2,
-      brightness: 200,
-      duration_ms: 600000,
-      mode: 1,
-      control: 0x02
-    }).then(function () {
+    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({
@@ -174,5 +141,23 @@ Page({
     }).catch(function (err) {
       wx.showToast({ title: err.error_msg || '启动失败', icon: 'none' })
     })
+  },
+
+  _calculateTreatParams: function (mask, pdAvg) {
+    // TODO: 接入完整诊断算法（NR 归一化吸收率 → 匹配光谱+强度）
+    // 需要 PD→区域映射确认后实现
+    // 当前使用统一参数：红光、亮度 200、10 分钟
+    return {
+      region_mask: mask,
+      wavelength: 2,
+      brightness: 200,
+      duration_ms: 600000,
+      mode: 1,
+      control: 0x02
+    }
+  },
+
+  onUnload: function () {
+    this._cleanup()
   }
 })