216 行
6.9 KiB
JavaScript
216 行
6.9 KiB
JavaScript
var ble = require('../../services/ble')
|
|
var api = require('../../utils/api')
|
|
var diagnosis = require('../../services/diagnosis')
|
|
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._seenRunState1 = 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 (data.run_state === 1) {
|
|
self._seenRunState1 = true
|
|
}
|
|
|
|
if (self._lastFitting === 1 && data.run_state === 1 && !self._collecting) {
|
|
console.log('[SCAN] 贴合确认，开始采集PD数据')
|
|
self._collecting = true
|
|
self.setData({ phase: 'collecting' })
|
|
}
|
|
|
|
if (self._seenRunState1 && 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._buildAndGoReport(avg)
|
|
},
|
|
|
|
// Scan finished -> run the (placeholder) diagnosis, store + persist a report, and
|
|
// navigate to the report page so the user sees their skin tendencies and chooses
|
|
// care. This replaces the previous auto-start-treatment behavior.
|
|
//
|
|
// NOTE: today only single-wavelength red PD is collected, and the thresholds +
|
|
// PD->region mapping in services/diagnosis.js are placeholders pending calibration.
|
|
// Report + persistence work end to end regardless; the numbers get real after
|
|
// 4-wavelength scan collection and calibration land.
|
|
_buildAndGoReport: function (avg) {
|
|
var self = this
|
|
var app = getApp()
|
|
var mask = self.data.regions || 0x1F
|
|
// Same device-id source the treating page uses (services/ble getDeviceId + currentDevice fallback).
|
|
var deviceId = ble.getDeviceId() || (app.globalData.currentDevice && app.globalData.currentDevice.device_id) || null
|
|
var scannedAt = Date.now()
|
|
|
|
function proceed(config) {
|
|
var scanData = diagnosis.fromRedScan(avg, mask, deviceId, scannedAt)
|
|
var report = diagnosis.analyze(scanData, config || diagnosis.DEFAULT_CONFIG)
|
|
app.globalData.lastScanReport = report
|
|
|
|
// Best-effort persist (also seeds the calibration dataset via raw_pd); never blocks navigation.
|
|
api.saveReport({
|
|
device_id: report.device_id,
|
|
scanned_at: report.scanned_at,
|
|
regions: report.regions,
|
|
overall: report.overall,
|
|
recommend_mask: report.recommend_mask,
|
|
recommend_plan: report.recommend_plan,
|
|
raw_pd: report.raw_pd,
|
|
calibrated: report.calibrated
|
|
}).catch(function () {})
|
|
|
|
wx.redirectTo({ url: '/pages/scan-report/scan-report' })
|
|
}
|
|
|
|
api.getDiagnosisConfig().then(function (cfg) {
|
|
proceed(cfg && cfg.levels ? cfg : diagnosis.DEFAULT_CONFIG)
|
|
}).catch(function () {
|
|
proceed(diagnosis.DEFAULT_CONFIG)
|
|
})
|
|
},
|
|
|
|
onUnload: function () {
|
|
if (!this._completed && (this.data.phase === 'waiting_fit' || this.data.phase === 'collecting')) {
|
|
ble.stopTreatment().catch(function () {})
|
|
}
|
|
this._cleanup()
|
|
}
|
|
})
|