鸿蒙app 传感器数据展示（温湿度/烟雾报警实时监控

2. 技术背景

• 多传感器接入：通过@ohos.sensor模块统一管理传感器生命周期。
• 实时数据采集：支持订阅传感器数据变化，低延迟回调。
• 分布式数据同步：采集数据可同步至其他鸿蒙设备，实现多端监控。
• 后台持续监测：结合BackgroundTaskManager实现熄屏后持续采集。
• 告警机制：数据超阈值时触发本地通知或分布式告警。

graph TD
    A[传感器硬件] --> B[鸿蒙传感器服务]
    B --> C[数据采集服务]
    C --> D[数据处理与阈值判断]
    D --> E[UI实时展示]
    D --> F[告警触发]
    F --> G[本地通知/分布式告警]
    C --> H[分布式数据同步]
    H --> I[其他鸿蒙设备]

3. 应用使用场景

4. 核心原理与流程图

4.1 核心原理

4.2 原理流程图

sequenceDiagram
    participant Sensor as 传感器硬件
    participant SensorService as 鸿蒙传感器服务
    participant DataService as 数据采集服务
    participant UI as 展示UI
    participant AlarmService as 告警服务
    participant DistributedData as 分布式数据管理

    Sensor->>SensorService: 上报原始数据
    SensorService->>DataService: 推送传感器数据(温湿度/烟雾)
    DataService->>UI: 更新实时数据显示
    DataService->>AlarmService: 传递数据与阈值判断
    AlarmService->>AlarmService: 判断是否超阈值
    alt 超阈值
        AlarmService->>UI: 显示告警状态(红色闪烁)
        AlarmService->>Notification: 发送本地通知
        AlarmService->>DistributedData: 同步告警信息
    end
    DataService->>DistributedData: 同步正常监测数据
    DistributedData->>OtherDevices: 推送数据至其他鸿蒙设备

5. 环境准备

5.1 开发环境

• DevEco Studio 4.0+
• HarmonyOS SDK 9+
• Language: ArkTS
• 权限：ohos.permission.ACCELEROMETER（部分传感器依赖）、ohos.permission.LOCATION（室内定位辅助）、ohos.permission.KEEP_BACKGROUND_RUNNING（后台监测）

5.2 权限配置（module.json5）

{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.KEEP_BACKGROUND_RUNNING",
        "reason": "后台持续监测传感器数据",
        "usedScene": { "abilities": ["MainAbility"], "when": "always" }
      },
      {
        "name": "ohos.permission.DISTRIBUTED_DATASYNC",
        "reason": "传感器数据多端同步",
        "usedScene": { "abilities": ["MainAbility"], "when": "always" }
      }
    ]
  }
}

6. 实际详细应用代码示例实现

6.1 数据模型

export class SensorData {
  timestamp: number = 0;
  temperature: number = 0; // 温度(℃)
  humidity: number = 0;    // 湿度(%RH)
  smoke: number = 0;       // 烟雾浓度(ppm)
  isAlarm: boolean = false; // 是否告警
}

6.2 数据采集服务

import sensor from '@ohos.sensor';
import { SensorData } from '../models/SensorData';
import { BusinessError } from '@ohos.base';

export class SensorDataService {
  private static instance: SensorDataService;
  private listeners: ((data: SensorData) => void)[] = [];
  private data: SensorData = new SensorData();
  private humiditySensorId: number = sensor.SensorId.HUMIDITY;
  private temperatureSensorId: number = sensor.SensorId.TEMPERATURE;
  private smokeSensorId: number = sensor.SensorId.SMOKE; // 假设烟雾传感器ID

  static getInstance(): SensorDataService {
    if (!SensorDataService.instance) {
      SensorDataService.instance = new SensorDataService();
    }
    return SensorDataService.instance;
  }

  registerListener(listener: (data: SensorData) => void) {
    this.listeners.push(listener);
  }

  startMonitoring() {
    // 订阅温湿度传感器
    sensor.on(this.humiditySensorId, (error: BusinessError, humidityData: sensor.HumidityData) => {
      if (error) {
        console.error(`Humidity sensor error: ${JSON.stringify(error)}`);
        return;
      }
      this.data.humidity = humidityData.humidity;
      this.data.timestamp = Date.now();
      this.notifyListeners();
    });

    sensor.on(this.temperatureSensorId, (error: BusinessError, tempData: sensor.TemperatureData) => {
      if (error) {
        console.error(`Temperature sensor error: ${JSON.stringify(error)}`);
        return;
      }
      this.data.temperature = tempData.temperature;
      this.notifyListeners();
    });

    // 订阅烟雾传感器（假设存在）
    sensor.on(this.smokeSensorId, (error: BusinessError, smokeData: sensor.SmokeData) => {
      if (error) {
        console.error(`Smoke sensor error: ${JSON.stringify(error)}`);
        return;
      }
      this.data.smoke = smokeData.smoke;
      this.notifyListeners();
    });
  }

  stopMonitoring() {
    sensor.off(this.humiditySensorId);
    sensor.off(this.temperatureSensorId);
    sensor.off(this.smokeSensorId);
  }

  private notifyListeners() {
    this.listeners.forEach(listener => listener({ ...this.data }));
  }

  getCurrentData(): SensorData {
    return { ...this.data };
  }
}

6.3 告警服务

import { SensorData } from '../models/SensorData';
import notification from '@ohos.notification';

export class AlarmService {
  private static instance: AlarmService;
  private thresholds = {
    temperatureMax: 30,
    temperatureMin: 0,
    humidityMax: 80,
    humidityMin: 30,
    smokeMax: 50
  };

  static getInstance(): AlarmService {
    if (!AlarmService.instance) {
      AlarmService.instance = new AlarmService();
    }
    return AlarmService.instance;
  }

  checkAlarm(data: SensorData): boolean {
    const { temperature, humidity, smoke } = data;
    const isAlarm = 
      temperature > this.thresholds.temperatureMax ||
      temperature < this.thresholds.temperatureMin ||
      humidity > this.thresholds.humidityMax ||
      humidity < this.thresholds.humidityMin ||
      smoke > this.thresholds.smokeMax;
    
    data.isAlarm = isAlarm;
    if (isAlarm) {
      this.sendAlarmNotification(data);
    }
    return isAlarm;
  }

  private sendAlarmNotification(data: SensorData) {
    const content = `告警: 温度${data.temperature}℃, 湿度${data.humidity}%, 烟雾${data.smoke}ppm`;
    notification.publish({
      contentTitle: '传感器告警',
      contentText: content,
      clickAction: { bundleName: 'com.example.sensordemo', abilityName: 'MainAbility' }
    }).catch(err => console.error(`Notification error: ${JSON.stringify(err)}`));
  }
}

6.4 分布式数据同步服务

import distributedData from '@ohos.data.distributedData';
import { SensorData } from '../models/SensorData';

export class DistributedSyncService {
  private kvManager: distributedData.KVManager | null = null;
  private kvStore: distributedData.KVStore | null = null;
  private static instance: DistributedSyncService;

  static getInstance(): DistributedSyncService {
    if (!DistributedSyncService.instance) {
      DistributedSyncService.instance = new DistributedSyncService();
    }
    return DistributedSyncService.instance;
  }

  async init() {
    const config = {
      bundleName: 'com.example.sensordemo',
      userInfo: { userId: 'sensor_user' }
    };
    this.kvManager = await distributedData.createKVManager(config);
    const options = {
      createIfMissing: true,
      encrypt: false,
      backup: false,
      kvStoreType: distributedData.KVStoreType.SINGLE_VERSION,
      securityLevel: distributedData.SecurityLevel.S1
    };
    this.kvStore = await this.kvManager.getKVStore('sensor_data', options);
  }

  async syncData(data: SensorData) {
    if (!this.kvStore) return;
    await this.kvStore.put(Date.now().toString(), JSON.stringify(data));
  }
}

6.5 主页面展示

import { SensorDataService } from '../services/SensorDataService';
import { AlarmService } from '../services/AlarmService';
import { DistributedSyncService } from '../services/DistributedSyncService';
import { SensorData } from '../models/SensorData';

@Entry
@Component
struct Index {
  @State temperature: number = 0;
  @State humidity: number = 0;
  @State smoke: number = 0;
  @State isAlarm: boolean = false;
  private sensorService: SensorDataService = SensorDataService.getInstance();
  private alarmService: AlarmService = AlarmService.getInstance();
  private syncService: DistributedSyncService = DistributedSyncService.getInstance();

  aboutToAppear() {
    this.syncService.init();
    this.sensorService.registerListener((data: SensorData) => {
      this.temperature = data.temperature;
      this.humidity = data.humidity;
      this.smoke = data.smoke;
      this.isAlarm = data.isAlarm;
      this.alarmService.checkAlarm(data);
      this.syncService.syncData(data);
    });
    this.sensorService.startMonitoring();
  }

  aboutToDisappear() {
    this.sensorService.stopMonitoring();
  }

  build() {
    Column({ space: 20 }) {
      Text("传感器实时监控")
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .fontColor(this.isAlarm ? Color.Red : Color.Black)

      Row() {
        Text("温度:").fontSize(18)
        Text(`${this.temperature.toFixed(1)}℃`).fontSize(18)
          .fontColor(this.isAlarm ? Color.Red : Color.Black)
      }

      Row() {
        Text("湿度:").fontSize(18)
        Text(`${this.humidity.toFixed(1)}%RH`).fontSize(18)
          .fontColor(this.isAlarm ? Color.Red : Color.Black)
      }

      Row() {
        Text("烟雾:").fontSize(18)
        Text(`${this.smoke.toFixed(1)}ppm`).fontSize(18)
          .fontColor(this.isAlarm ? Color.Red : Color.Black)
      }

      if (this.isAlarm) {
        Text("⚠️ 告警状态")
          .fontSize(20)
          .fontColor(Color.Red)
          .backgroundColor('#FFF0F0')
          .padding(10)
          .borderRadius(8)
      }
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
    .backgroundColor(this.isAlarm ? '#FFF0F0' : Color.White)
  }
}

7. 运行结果

• 实时显示温度、湿度、烟雾浓度数值。
• 当温度>30℃或烟雾>50ppm时，UI文字及背景变红，显示“告警状态”，并收到系统通知。
• 数据通过分布式同步在其他鸿蒙设备可见。

8. 测试步骤以及详细代码

1. 环境配置：创建鸿蒙项目，添加权限，部署真机。
2. 传感器模拟：使用鸿蒙传感器模拟工具注入温湿度/烟雾数据。
3. 正常监测测试：观察UI数据实时更新。
4. 告警测试：注入超阈值数据，验证UI告警样式与通知推送。
5. 分布式同步测试：在两台鸿蒙设备登录同一账号，确认数据同步。

9. 部署场景

• 家庭：客厅/厨房部署温湿度+烟雾传感器，手机实时查看。
• 工厂：车间部署多传感器，后台持续监测并告警。
• 农业大棚：温湿度传感器联动灌溉/通风设备。

10. 疑难解答

11. 未来展望

• 接入AI异常检测模型，预测潜在设备故障。
• 支持更多传感器类型（光照、PM2.5、CO₂）。
• 可视化历史数据曲线，生成环境报告。

12. 技术趋势与挑战

• 趋势：边缘计算实时处理传感器数据；跨设备协同形成智能环境闭环。
• 挑战：低功耗传感器续航与数据实时性平衡；多厂商传感器协议标准化；海量数据高效同步。

13. 总结