HarmonyOS APP开发：计步器实现与步态分析

核心要点：本文深入讲解基于HarmonyOS加速度传感器的计步器实现方案，涵盖步频检测算法、步态特征提取、卡路里消耗计算，以及如何利用Sensor API实现高精度步数统计与步态分析功能。

一、背景与动机

随着可穿戴设备和健康监测应用的普及，计步器已成为智能设备的标配功能。HarmonyOS的分布式能力使得手机、手表、手环之间的运动数据可以无缝流转，为用户提供了更完整的运动追踪体验。

传统计步器仅统计步数，而步态分析则更进一步——通过分析加速度波形的频率、振幅、对称性等特征，可以判断用户的行走姿态是否健康，辅助康复训练和运动指导。HarmonyOS提供了丰富的传感器API，使得在应用层实现高精度计步和步态分析成为可能。

为什么选择HarmonyOS实现计步器？

1. 统一传感器框架：一套API适配手机、手表、手环多种设备形态
2. 低功耗订阅模式：基于事件回调的传感器数据获取，避免轮询耗电
3. 分布式数据同步：运动数据跨设备流转，手表计步、手机查看
4. AI能力增强：可结合端侧AI模型实现智能步态识别

二、核心原理

2.1 计步器工作原理

计步器的核心是加速度传感器（Accelerometer）。人行走时，身体会产生周期性的上下振动，加速度信号在Z轴（竖直方向）上呈现明显的周期性波动。

加速度波形示意：
    ↑
    |   /\      /\      /\
    |  /  \    /  \    /  \
----|-/----\--/----\--/----\----→ 时间
    |        \/      \/
    |
  每个波峰 = 一步

2.2 峰值检测算法

峰值检测是最经典的计步算法，核心步骤：

1. 低通滤波：去除高频噪声，保留1-3Hz的步行频率
2. 峰值检测：检测加速度信号中的局部最大值
3. 阈值过滤：排除幅度过小的伪峰
4. 时间约束：两步之间间隔不小于250ms（正常人最快步频约4Hz）

2.3 步态分析特征

步态分析从加速度信号中提取以下特征：

2.4 算法流程图

flowchart TD
    A[加速度传感器原始数据] --> B[三轴合成加速度]
    B --> C[低通滤波器<br/>截止频率3Hz]
    C --> D[滑动窗口均值去趋势]
    D --> E{峰值检测}
    E --> F[振幅阈值过滤]
    F --> G[时间间隔约束<br/>≥250ms]
    G --> H[步数计数+1]
    H --> I[更新步频统计]
    I --> J[步态特征提取]
    J --> K[步态分析报告]
    
    classDef dataStyle fill:#1a1a2e,stroke:#e94560,color:#fff,stroke-width:2px
    classDef processStyle fill:#16213e,stroke:#0f3460,color:#e0e0e0,stroke-width:2px
    classDef decisionStyle fill:#0f3460,stroke:#533483,color:#fff,stroke-width:2px
    classDef outputStyle fill:#533483,stroke:#e94560,color:#fff,stroke-width:2px
    
    class A,B dataStyle
    class C,D,F,G processStyle
    class E decisionStyle
    class H,I,J,K outputStyle

三、代码实战

3.1 传感器数据订阅与预处理

首先创建传感器管理器，订阅加速度数据并进行预处理：

// PedometerSensorManager.ets — 传感器数据订阅与预处理
import sensor from '@ohos.sensor';
import { BusinessError } from '@ohos.base';

// 传感器数据采样点
interface AccelDataPoint {
  timestamp: number;   // 时间戳（纳秒）
  x: number;           // X轴加速度
  y: number;           // Y轴加速度
  z: number;           // Z轴加速度
  magnitude: number;   // 合加速度
}

// 传感器配置常量
const SENSOR_CONFIG = {
  samplingInterval: 20_000_000,  // 采样间隔20ms（50Hz），满足奈奎斯特采样定理
  gravity: 9.81,                 // 重力加速度参考值
  filterCutoff: 3.0,             // 低通滤波截止频率3Hz
  windowSize: 50,                // 滑动窗口大小（1秒数据量@50Hz）
};

@ObservedV2
export class PedometerSensorManager {
  // 数据缓冲区
  private dataBuffer: AccelDataPoint[] = [];
  private readonly maxBufferSize: number = 500; // 最多缓存10秒数据

  // 订阅ID
  private subscribeId: number = -1;

  // 数据回调
  private onDataCallback?: (data: AccelDataPoint) => void;

  /**
   * 订阅加速度传感器
   */
  subscribeAccelerometer(callback: (data: AccelDataPoint) => void): void {
    this.onDataCallback = callback;

    try {
      this.subscribeId = sensor.on(sensor.SensorId.ACCELEROMETER,
        (data: sensor.AccelerometerResponse) => {
          const point: AccelDataPoint = {
            timestamp: data.timestamp,
            x: data.x,
            y: data.y,
            z: data.z,
            // 计算合加速度（去除重力方向后）
            magnitude: Math.sqrt(data.x * data.x + data.y * data.y + data.z * data.z)
          };

          // 缓存数据
          this.dataBuffer.push(point);
          if (this.dataBuffer.length > this.maxBufferSize) {
            this.dataBuffer.shift();
          }

          // 回调通知
          this.onDataCallback?.(point);
        },
        { interval: SENSOR_CONFIG.samplingInterval }
      );
      console.info('[PedometerSensor] 加速度传感器订阅成功');
    } catch (error) {
      const e = error as BusinessError;
      console.error(`[PedometerSensor] 订阅失败: code=${e.code}, msg=${e.message}`);
    }
  }

  /**
   * 取消订阅加速度传感器
   */
  unsubscribeAccelerometer(): void {
    if (this.subscribeId !== -1) {
      try {
        sensor.off(sensor.SensorId.ACCELEROMETER, this.subscribeId);
        this.subscribeId = -1;
        console.info('[PedometerSensor] 已取消传感器订阅');
      } catch (error) {
        const e = error as BusinessError;
        console.error(`[PedometerSensor] 取消订阅失败: ${e.message}`);
      }
    }
  }

  /**
   * 获取缓冲区数据（用于步态分析）
   */
  getBufferedData(): AccelDataPoint[] {
    return [...this.dataBuffer];
  }

  /**
   * 清空缓冲区
   */
  clearBuffer(): void {
    this.dataBuffer = [];
  }
}

3.2 峰值检测与计步核心算法

实现基于峰值检测的计步算法，包含低通滤波和步态特征提取：

// StepDetector.ets — 峰值检测与计步核心算法

// 步态特征数据
interface GaitFeatures {
  cadence: number;           // 步频（步/分钟）
  avgStrideInterval: number; // 平均步间间隔（毫秒）
  strideVariability: number; // 步间间隔变异系数
  verticalAmplitude: number; // 垂直振幅（加速度峰值均值）
  symmetryIndex: number;     // 对称性指数（0-1，越接近1越对称）
}

// 算法参数配置
const STEP_DETECT_CONFIG = {
  minPeakInterval: 250,     // 最小步间间隔250ms
  maxPeakInterval: 2000,    // 最大步间间隔2000ms（超时视为停止行走）
  amplitudeThreshold: 0.3,  // 加速度振幅阈值（m/s²）
  warmupSteps: 3,           // 预热步数（前几步不纳入统计）
  filterAlpha: 0.1,         // 低通滤波系数（越小越平滑）
};

@ObservedV2
export class StepDetector {
  // 计步状态
  @Trace stepCount: number = 0;
  @Trace currentCadence: number = 0;
  @Trace isWalking: boolean = false;

  // 内部状态
  private lastPeakTime: number = 0;
  private lastPeakValue: number = 0;
  private filteredMagnitude: number = SENSOR_CONFIG.gravity;
  private stepIntervals: number[] = [];       // 最近的步间间隔
  private peakValues: number[] = [];          // 最近的峰值
  private lastDirection: number = 0;          // 上一次加速度变化方向
  private walkingTimeoutId: number = -1;      // 行走超时定时器

  /**
   * 处理单个加速度数据点
   * @param dataPoint 加速度采样点
   */
  processDataPoint(dataPoint: { timestamp: number; magnitude: number }): void {
    // 一阶低通滤波：去除高频噪声
    this.filteredMagnitude = STEP_DETECT_CONFIG.filterAlpha * dataPoint.magnitude +
      (1 - STEP_DETECT_CONFIG.filterAlpha) * this.filteredMagnitude;

    // 计算去趋势后的信号（减去重力基线）
    const detrended = this.filteredMagnitude - SENSOR_CONFIG.gravity;

    // 检测过零方向变化（从正到负 = 峰值点）
    const currentDirection = detrended > 0 ? 1 : -1;

    if (this.lastDirection === 1 && currentDirection === -1) {
      // 检测到峰值，进行步数判定
      this.onPeakDetected(dataPoint.timestamp, this.lastPeakValue);
    }

    if (detrended > 0) {
      this.lastPeakValue = detrended;
    }
    this.lastDirection = currentDirection;
  }

  /**
   * 峰值检测回调
   */
  private onPeakDetected(timestamp: number, peakValue: number): void {
    // 振幅阈值过滤
    if (peakValue < STEP_DETECT_CONFIG.amplitudeThreshold) {
      return;
    }

    const currentTime = timestamp / 1_000_000; // 纳秒转毫秒
    const interval = currentTime - this.lastPeakTime;

    // 时间间隔约束
    if (this.lastPeakTime > 0) {
      if (interval < STEP_DETECT_CONFIG.minPeakInterval) {
        return; // 间隔太短，视为噪声
      }
      if (interval > STEP_DETECT_CONFIG.maxPeakInterval) {
        // 间隔太长，视为重新开始行走
        this.stepIntervals = [];
        this.peakValues = [];
      } else {
        // 有效步间间隔
        this.stepIntervals.push(interval);
        this.peakValues.push(peakValue);

        // 保留最近20步数据
        if (this.stepIntervals.length > 20) {
          this.stepIntervals.shift();
          this.peakValues.shift();
        }
      }
    }

    // 步数+1
    this.stepCount++;
    this.lastPeakTime = currentTime;
    this.isWalking = true;

    // 更新步频（基于最近5步的滑动窗口）
    this.updateCadence();

    // 重置行走超时
    this.resetWalkingTimeout();
  }

  /**
   * 更新步频
   */
  private updateCadence(): void {
    const recentSteps = this.stepIntervals.slice(-5);
    if (recentSteps.length >= 2) {
      const avgInterval = recentSteps.reduce((a, b) => a + b, 0) / recentSteps.length;
      this.currentCadence = Math.round(60000 / avgInterval); // 毫秒间隔转步/分钟
    }
  }

  /**
   * 重置行走超时定时器
   */
  private resetWalkingTimeout(): void {
    if (this.walkingTimeoutId !== -1) {
      clearTimeout(this.walkingTimeoutId);
    }
    this.walkingTimeoutId = setTimeout(() => {
      this.isWalking = false;
      this.currentCadence = 0;
    }, STEP_DETECT_CONFIG.maxPeakInterval) as number;
  }

  /**
   * 提取步态特征
   */
  extractGaitFeatures(): GaitFeatures | null {
    if (this.stepIntervals.length < STEP_DETECT_CONFIG.warmupSteps) {
      return null; // 数据不足
    }

    const intervals = this.stepIntervals;
    const peaks = this.peakValues;

    // 平均步间间隔
    const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;

    // 步间间隔变异系数（标准差/均值）
    const variance = intervals.reduce((sum, val) => sum + Math.pow(val - avgInterval, 2), 0) / intervals.length;
    const stdDev = Math.sqrt(variance);
    const strideVariability = avgInterval > 0 ? stdDev / avgInterval : 0;

    // 垂直振幅（峰值均值）
    const verticalAmplitude = peaks.reduce((a, b) => a + b, 0) / peaks.length;

    // 对称性指数：基于相邻步间间隔的比值
    let symmetrySum = 0;
    let symmetryCount = 0;
    for (let i = 1; i < intervals.length; i++) {
      const ratio = Math.min(intervals[i - 1], intervals[i]) / Math.max(intervals[i - 1], intervals[i]);
      symmetrySum += ratio;
      symmetryCount++;
    }
    const symmetryIndex = symmetryCount > 0 ? symmetrySum / symmetryCount : 1;

    return {
      cadence: Math.round(60000 / avgInterval),
      avgStrideInterval: Math.round(avgInterval),
      strideVariability: Math.round(strideVariability * 1000) / 1000,
      verticalAmplitude: Math.round(verticalAmplitude * 1000) / 1000,
      symmetryIndex: Math.round(symmetryIndex * 1000) / 1000,
    };
  }

  /**
   * 重置检测器状态
   */
  reset(): void {
    this.stepCount = 0;
    this.currentCadence = 0;
    this.isWalking = false;
    this.lastPeakTime = 0;
    this.lastPeakValue = 0;
    this.stepIntervals = [];
    this.peakValues = [];
    this.lastDirection = 0;
  }
}

3.3 计步器完整UI界面

结合传感器管理和步数检测，实现完整的计步器界面，包含步态分析展示：

// PedometerPage.ets — 计步器完整界面
import { PedometerSensorManager } from './PedometerSensorManager';
import { StepDetector, GaitFeatures } from './StepDetector';
import vibrator from '@ohos.vibrator';

@Entry
@Component
struct PedometerPage {
  // 传感器管理器
  private sensorManager: PedometerSensorManager = new PedometerSensorManager();
  private stepDetector: StepDetector = new StepDetector();

  // UI状态
  @State stepCount: number = 0;
  @State cadence: number = 0;
  @State isWalking: boolean = false;
  @State isMonitoring: boolean = false;
  @State calories: number = 0;
  @State distance: number = 0;
  @State duration: string = '00:00:00';
  @State gaitFeatures: GaitFeatures | null = null;

  // 计时器
  private startTime: number = 0;
  private timerId: number = -1;

  // 用户配置
  private readonly userWeight: number = 70;    // 体重kg
  private readonly strideLength: number = 0.7;  // 步幅m

  build() {
    Navigation() {
      Scroll() {
        Column({ space: 24 }) {
          // 顶部状态栏
          this.StatusBar()

          // 步数环形展示
          this.StepCircleSection()

          // 运动数据卡片
          this.MotionDataCards()

          // 步态分析卡片
          this.GaitAnalysisSection()

          // 控制按钮
          this.ControlButtons()
        }
        .width('100%')
        .padding({ left: 20, right: 20, top: 16, bottom: 40 })
      }
      .scrollBar(BarState.Off)
    }
    .title('计步器与步态分析')
    .titleMode(NavigationTitleMode.Mini)
    .navBarStyle(NavBarStyleConstants.TRANSPARENT)
  }

  // ===== 顶部状态栏 =====
  @Builder
  StatusBar() {
    Row({ space: 12 }) {
      // 传感器状态指示
      Circle({ width: 8, height: 8 })
        .fill(this.isMonitoring ? '#00E676' : '#FF5252')

      Text(this.isMonitoring ? '传感器运行中' : '传感器未启动')
        .fontSize(13)
        .fontColor('#B0BEC5')

      Blank()

      // 行走状态
      if (this.isWalking) {
        Row({ space: 6 }) {
          LoadingProgress()
            .width(16)
            .height(16)
            .color('#00E676')
          Text('行走中')
            .fontSize(13)
            .fontColor('#00E676')
            .fontWeight(FontWeight.Bold)
        }
        .padding({ left: 12, right: 12, top: 4, bottom: 4 })
        .borderRadius(12)
        .backgroundColor('rgba(0, 230, 118, 0.15)')
      }
    }
    .width('100%')
    .height(40)
  }

  // ===== 步数环形展示 =====
  @Builder
  StepCircleSection() {
    Column({ space: 16 }) {
      Stack() {
        // 背景圆环
        Circle()
          .width(220)
          .height(220)
          .fill('transparent')
          .stroke('#1a1a2e')
          .strokeWidth(12)

        // 进度圆环
        Circle()
          .width(220)
          .height(220)
          .fill('transparent')
          .stroke('#e94560')
          .strokeWidth(12)
          .strokeDasharray({
            // 目标10000步的进度
            lineDash: [Math.PI * 220 * Math.min(this.stepCount / 10000, 1),
              Math.PI * 220]
          })

        // 中心数字
        Column({ space: 4 }) {
          Text(this.stepCount.toString())
            .fontSize(52)
            .fontColor('#FFFFFF')
            .fontWeight(FontWeight.Bold)
            .fontFamily('HarmonyOS Sans')

          Text('步')
            .fontSize(16)
            .fontColor('#78909C')

          Text(`目标 ${Math.min(Math.round(this.stepCount / 100), 100)}%`)
            .fontSize(12)
            .fontColor('#e94560')
            .margin({ top: 4 })
        }
      }

      // 步频显示
      Row({ space: 8 }) {
        Text('步频')
          .fontSize(13)
          .fontColor('#78909C')
        Text(`${this.cadence}`)
          .fontSize(20)
          .fontColor('#00E676')
          .fontWeight(FontWeight.Bold)
        Text('步/分钟')
          .fontSize(12)
          .fontColor('#546E7A')
      }
    }
    .width('100%')
    .alignItems(HorizontalAlign.Center)
    .padding({ top: 8, bottom: 8 })
  }

  // ===== 运动数据卡片 =====
  @Builder
  MotionDataCards() {
    Row({ space: 12 }) {
      // 卡路里
      this.DataCard('🔥', '卡路里', `${this.calories}`, 'kcal')
      // 距离
      this.DataCard('📏', '距离', `${this.distance}`, 'km')
      // 时长
      this.DataCard('⏱', '时长', this.duration, '')
    }
    .width('100%')
  }

  @Builder
  DataCard(icon: string, label: string, value: string, unit: string) {
    Column({ space: 8 }) {
      Text(icon)
        .fontSize(24)

      Text(label)
        .fontSize(11)
        .fontColor('#78909C')

      Row({ space: 2 }) {
        Text(value)
          .fontSize(18)
          .fontColor('#FFFFFF')
          .fontWeight(FontWeight.Bold)
        if (unit) {
          Text(unit)
            .fontSize(10)
            .fontColor('#546E7A')
        }
      }
    }
    .layoutWeight(1)
    .padding(16)
    .borderRadius(16)
    .backgroundColor('rgba(22, 33, 62, 0.8)')
    .alignItems(HorizontalAlign.Center)
  }

  // ===== 步态分析卡片 =====
  @Builder
  GaitAnalysisSection() {
    Column({ space: 16 }) {
      // 标题
      Row({ space: 8 }) {
        Text('🦶')
          .fontSize(20)
        Text('步态分析')
          .fontSize(18)
          .fontColor('#FFFFFF')
          .fontWeight(FontWeight.Bold)
        Blank()
        Text(this.gaitFeatures ? '实时' : '等待数据...')
          .fontSize(12)
          .fontColor(this.gaitFeatures ? '#00E676' : '#546E7A')
      }
      .width('100%')

      if (this.gaitFeatures) {
        // 步态特征网格
        Grid() {
          GridItem() {
            this.GaitFeatureItem('步频', `${this.gaitFeatures.cadence}`, '步/分',
              this.gaitFeatures.cadence >= 100 && this.gaitFeatures.cadence <= 130)
          }
          GridItem() {
            this.GaitFeatureItem('平均步间', `${this.gaitFeatures.avgStrideInterval}`, 'ms',
              this.gaitFeatures.avgStrideInterval >= 450 && this.gaitFeatures.avgStrideInterval <= 600)
          }
          GridItem() {
            this.GaitFeatureItem('变异系数', `${this.gaitFeatures.strideVariability}`, '',
              this.gaitFeatures.strideVariability < 0.1)
          }
          GridItem() {
            this.GaitFeatureItem('对称性', `${this.gaitFeatures.symmetryIndex}`, '',
              this.gaitFeatures.symmetryIndex > 0.9)
          }
        }
        .columnsTemplate('1fr 1fr')
        .rowsTemplate('1fr 1fr')
        .width('100%')
        .height(180)
        .columnsGap(10)
        .rowsGap(10)

        // 步态健康提示
        Row({ space: 8 }) {
          Text(this.getGaitHealthTip())
            .fontSize(13)
            .fontColor('#B0BEC5')
            .layoutWeight(1)
        }
        .width('100%')
        .padding(12)
        .borderRadius(10)
        .backgroundColor('rgba(83, 52, 131, 0.3)')
      } else {
        // 空状态
        Column({ space: 8 }) {
          Text('开始行走后将自动分析步态特征')
            .fontSize(13)
            .fontColor('#546E7A')
          Text('至少需要3步数据')
            .fontSize(11)
            .fontColor('#37474F')
        }
        .width('100%')
        .height(120)
        .justifyContent(FlexAlign.Center)
        .borderRadius(12)
        .backgroundColor('rgba(22, 33, 62, 0.5)')
      }
    }
    .width('100%')
    .padding(20)
    .borderRadius(20)
    .backgroundColor('rgba(15, 52, 96, 0.6)')
    .backdropBlur(20)
  }

  @Builder
  GaitFeatureItem(label: string, value: string, unit: string, isNormal: boolean) {
    Column({ space: 6 }) {
      Text(label)
        .fontSize(11)
        .fontColor('#78909C')

      Row({ space: 2 }) {
        Text(value)
          .fontSize(16)
          .fontColor(isNormal ? '#00E676' : '#FF9800')
          .fontWeight(FontWeight.Bold)
        if (unit) {
          Text(unit)
            .fontSize(9)
            .fontColor('#546E7A')
        }
      }

      // 状态指示
      Circle({ width: 6, height: 6 })
        .fill(isNormal ? '#00E676' : '#FF9800')
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
    .borderRadius(12)
    .backgroundColor('rgba(22, 33, 62, 0.8)')
  }

  // ===== 控制按钮 =====
  @Builder
  ControlButtons() {
    Row({ space: 16 }) {
      // 开始/暂停按钮
      Button(this.isMonitoring ? '暂停监测' : '开始监测')
        .width('60%')
        .height(52)
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .backgroundColor(this.isMonitoring ? '#FF5252' : '#e94560')
        .borderRadius(26)
        .onClick(() => this.toggleMonitoring())

      // 重置按钮
      Button('重置')
        .width('35%')
        .height(52)
        .fontSize(14)
        .fontColor('#78909C')
        .backgroundColor('rgba(22, 33, 62, 0.8)')
        .borderRadius(26)
        .onClick(() => this.resetAll())
    }
    .width('100%')
    .margin({ top: 8 })
  }

  // ===== 业务逻辑方法 =====

  /**
   * 切换监测状态
   */
  private toggleMonitoring(): void {
    if (this.isMonitoring) {
      this.stopMonitoring();
    } else {
      this.startMonitoring();
    }
  }

  /**
   * 开始监测
   */
  private startMonitoring(): void {
    this.isMonitoring = true;
    this.startTime = Date.now();

    // 订阅加速度传感器
    this.sensorManager.subscribeAccelerometer((dataPoint) => {
      // 送入步数检测器
      this.stepDetector.processDataPoint(dataPoint);

      // 更新UI状态
      this.stepCount = this.stepDetector.stepCount;
      this.cadence = this.stepDetector.currentCadence;
      this.isWalking = this.stepDetector.isWalking;

      // 计算卡路里（简易公式：步数 × 步幅 × 体重系数）
      this.calories = Math.round(this.stepCount * this.strideLength * this.userWeight * 0.0005 * 10) / 10;
      this.distance = Math.round(this.stepCount * this.strideLength / 1000 * 100) / 100;

      // 每10步更新步态分析
      if (this.stepCount % 10 === 0 && this.stepCount > 0) {
        this.gaitFeatures = this.stepDetector.extractGaitFeatures();
      }
    });

    // 启动计时器
    this.startTimer();

    // 振动反馈
    try {
      vibrator.startVibration({ type: 'time', duration: 100 });
    } catch (e) {
      // 忽略振动失败
    }
  }

  /**
   * 停止监测
   */
  private stopMonitoring(): void {
    this.isMonitoring = false;
    this.sensorManager.unsubscribeAccelerometer();
    this.stopTimer();

    // 最终步态分析
    this.gaitFeatures = this.stepDetector.extractGaitFeatures();
  }

  /**
   * 重置所有数据
   */
  private resetAll(): void {
    this.stopMonitoring();
    this.stepDetector.reset();
    this.sensorManager.clearBuffer();
    this.stepCount = 0;
    this.cadence = 0;
    this.isWalking = false;
    this.calories = 0;
    this.distance = 0;
    this.duration = '00:00:00';
    this.gaitFeatures = null;
  }

  /**
   * 启动计时器
   */
  private startTimer(): void {
    this.timerId = setInterval(() => {
      const elapsed = Date.now() - this.startTime;
      const hours = Math.floor(elapsed / 3600000);
      const minutes = Math.floor((elapsed % 3600000) / 60000);
      const seconds = Math.floor((elapsed % 60000) / 1000);
      this.duration = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
    }, 1000) as number;
  }

  /**
   * 停止计时器
   */
  private stopTimer(): void {
    if (this.timerId !== -1) {
      clearInterval(this.timerId);
      this.timerId = -1;
    }
  }

  /**
   * 获取步态健康提示
   */
  private getGaitHealthTip(): string {
    if (!this.gaitFeatures) return '';
    const tips: string[] = [];
    if (this.gaitFeatures.cadence < 80) {
      tips.push('步频偏低，建议适当加快步速');
    } else if (this.gaitFeatures.cadence > 130) {
      tips.push('步频偏高，注意控制节奏');
    }
    if (this.gaitFeatures.strideVariability > 0.15) {
      tips.push('步态规律性较差，注意保持稳定节奏');
    }
    if (this.gaitFeatures.symmetryIndex < 0.85) {
      tips.push('步态对称性偏低，建议关注左右步伐均衡');
    }
    return tips.length > 0 ? tips.join('；') : '步态特征正常，继续保持！';
  }

  // 页面销毁时释放资源
  aboutToDisappear(): void {
    this.sensorManager.unsubscribeAccelerometer();
    this.stopTimer();
  }
}

四、踩坑与注意事项

4.1 传感器权限声明

加速度传感器属于敏感权限，必须在module.json5中声明：

{
  "requestPermissions": [
    {
      "name": "ohos.permission.ACCELEROMETER",
      "reason": "$string:accelerometer_reason",
      "usedScene": {
        "abilities": ["EntryAbility"],
        "when": "inuse"
      }
    }
  ]
}

⚠️ 关键注意：ohos.permission.ACCELEROMETER 是 user_grant 级别权限，需要运行时动态申请。如果未授权直接订阅传感器，将抛出权限异常。

4.2 传感器数据时间戳处理

HarmonyOS传感器时间戳单位为纳秒（ns），而非毫秒：

// ❌ 错误：直接当作毫秒使用
const interval = data.timestamp - lastTimestamp;

// ✅ 正确：纳秒转毫秒
const intervalMs = (data.timestamp - lastTimestamp) / 1_000_000;

4.3 后台传感器订阅限制

HarmonyOS对后台传感器订阅有严格限制：

• 应用进入后台后，传感器订阅可能被系统暂停
• 长时间计步应使用后台任务（@ohos.backgroundTaskManager）保活
• 推荐使用计步器传感器（SensorId.PEDOMETER）替代加速度传感器，系统级计步更省电

4.4 不同设备传感器差异

开发时应根据设备类型动态调整采样率和算法参数。

4.5 卡路里计算公式选择

本文使用简化公式，实际生产建议使用更精确的模型：

简易公式：Calories = steps × strideLength × weight × 0.0005
ACSM公式：Calories = MET × weight(kg) × duration(h)

其中MET（代谢当量）根据运动类型不同：

• 慢走(3km/h)：MET = 2.0
• 快走(5km/h)：MET = 3.5
• 慢跑(8km/h)：MET = 8.0

五、HarmonyOS 6适配

5.1 Sensor API变更

HarmonyOS 6对Sensor API进行了以下优化：

// HarmonyOS 6 新增：批量数据回调模式
sensor.on(sensor.SensorId.ACCELEROMETER, (dataList: sensor.AccelerometerResponse[]) => {
  // 批量获取数据，减少回调频率，降低CPU唤醒次数
  for (const data of dataList) {
    this.processDataPoint(data);
  }
}, {
  interval: 20_000_000,
  batchCount: 5  // 新增：每5个采样点回调一次
});

5.2 计步器专用API

HarmonyOS 6推荐使用专用的计步器传感器，系统级算法更精准：

// HarmonyOS 6：使用系统计步器传感器
import sensor from '@ohos.sensor';

// 订阅计步器事件（系统级计步，功耗更低）
sensor.on(sensor.SensorId.PEDOMETER, (data: sensor.PedometerResponse) => {
  console.info(`系统步数: ${data.steps}`);
  console.info(`检测时间: ${data.timestamp}`);
});

5.3 性能模式支持

HarmonyOS 6新增传感器性能模式配置：

// 高精度模式（运动监测场景）
sensor.on(sensor.SensorId.ACCELEROMETER, callback, {
  interval: 10_000_000,  // 10ms采样
  mode: sensor.SensorMode.HIGH_PERFORMANCE  // 新增枚举
});

// 低功耗模式（日常计步场景）
sensor.on(sensor.SensorId.ACCELEROMETER, callback, {
  interval: 50_000_000,  // 50ms采样
  mode: sensor.SensorMode.LOW_POWER  // 新增枚举
});

六、总结

本文完整实现了基于HarmonyOS加速度传感器的计步器与步态分析功能，核心要点如下：

最佳实践建议：

1. 日常计步优先使用 PEDOMETER 传感器，系统级算法更省电更精准
2. 步态分析场景使用加速度传感器，可获取原始波形数据进行深度分析
3. 后台计步务必申请长时任务，否则传感器订阅会被系统回收
4. 算法参数需根据设备类型适配，手表和手机的采样率和精度差异较大
5. 步态分析结果仅供参考，不能替代专业医疗诊断

下一篇文章将深入讲解运动检测与活动状态识别，实现从静止到行走、跑步的自动状态切换。