一、引言

二、技术背景

1. 鸿蒙分布式自动化能力

• ​​设备发现与连接​​：自动发现同一局域网或跨公网的鸿蒙设备（如智能灯、空调、门锁），并建立低延迟的安全通信通道；
• ​​统一控制接口​​：将不同厂商的家电硬件能力（如开关、模式、温度）抽象为标准化的控制指令（如 turnOn()、setMode('cool')、setBrightness(50%)）；
• ​​自动化规则引擎​​：支持基于 ​​条件触发​​（如“门锁打开”“时间到达 18:00”）和 ​​动作执行​​（如“开灯”“开空调制冷”）的规则配置，实现“事件-响应”的自动化逻辑；
• ​​多设备协同​​：支持同时控制多个设备（如灯+空调+窗帘），形成完整的场景联动（如“回家模式”“睡眠模式”）。

2. 家电联动的核心场景

• ​​回家模式​​：用户回家时（通过门锁传感器检测），自动开启客厅灯和空调（调节至舒适温度）；
• ​​睡眠模式​​：夜间定时关闭所有灯光，调暗卧室空调；
• ​​离家模式​​：用户出门后（通过门锁或传感器检测），自动关闭所有家电设备；
• ​​环境联动​​：当室内温度超过 30℃ 时，自动开启空调制冷；当光线较暗时，自动开灯。

三、应用使用场景

1. 日常家庭场景

• ​​场景描述​​：用户下班回家，门锁打开后，“回家模式”自动触发——客厅灯亮起（亮度 70%）、空调开启制冷模式（温度 26℃），无需手动操作；
• ​​需求​​：低延迟（<200ms）、多设备协同（灯+空调）、条件触发（门锁状态+时间）。

2. 智慧办公场景

• ​​场景描述​​：员工进入办公室（通过门禁打卡或传感器检测），自动开启工位灯和空调（温度 24℃），离开后自动关闭；
• ​​需求​​：支持人员识别（如工卡/人脸）与设备联动的精准匹配。

3. 酒店/公寓场景

• ​​场景描述​​：客人办理入住后，“欢迎模式”自动开启客房灯（暖光）和空调（舒适温度），退房后自动关闭所有设备；
• ​​需求​​：临时权限管理（仅客人可控制当前房间设备）、预设场景快速触发。

4. 老人/儿童关怀场景

• ​​场景描述​​：当老人起夜时（通过红外传感器检测到移动），自动开启走廊灯（低亮度），避免摸黑摔倒；
• ​​需求​​：基于传感器的自动化响应（无手动触发）、安全优先（低亮度防刺眼）。

四、不同场景下详细代码实现

场景 1：手机配置“回家模式”（基础版）

1.1 项目结构

HomeAutomationApp/
├── entry/src/main/ets/pages/
│   ├── Index.ets          // 主页面（规则配置与状态显示）
│   ├── RuleManager.ets    // 自动化规则管理逻辑
│   ├── DeviceManager.ets  // 家电设备控制逻辑（灯/空调/门锁）
├── entry/src/main/module.json5  // 模块配置（声明分布式能力与权限）
└── build-profile.json5

1.2 分布式能力与权限配置（module.json5）

{
  "module": {
    "name": "entry",
    "type": "entry",
    "description": "$string:module_desc",
    "mainElement": "EntryAbility",
    "deviceTypes": [
      "phone",  // 支持手机配置端
      "tablet"  // 可扩展平板配置端
    ],
    "deliveryWithInstall": true,
    "installationFree": false,
    "requestPermissions": [
      {
        "name": "ohos.permission.DISTRIBUTED_DEVICE_CONTROL",  // 分布式设备控制权限
        "reason": "$string:control_permission_reason"
      },
      {
        "name": "ohos.permission.SENSOR",  // 传感器权限（如门锁传感器）
        "reason": "$string:sensor_permission_reason"
      },
      {
        "name": "ohos.permission.TIME",  // 时间/日期权限（用于判断触发时间）
        "reason": "$string:time_permission_reason"
      }
    ],
    "abilities": [
      {
        "name": "EntryAbility",
        "srcEntry": "./ets/entryability/EntryAbility.ts",
        "description": "$string:EntryAbility_desc",
        "icon": "$media:icon",
        "label": "$string:EntryAbility_label",
        "startWindowIcon": "$media:icon",
        "startWindowBackground": "$color:start_window_background",
        "exported": true,
        "skills": [
          {
            "entities": [
              "entity.system.home"
            ],
            "actions": [
              "action.system.home"
            ]
          }
        ]
      }
    ]
  }
}

1.3 设备控制逻辑（DeviceManager.ets）

// entry/src/main/ets/pages/DeviceManager.ets
import distributedDevice from '@ohos.distributed.device'; // 鸿蒙分布式设备管理模块
import lightControl from '@ohos.smart.device.light'; // 灯光控制模块
import acControl from '@ohos.smart.device.airconditioner'; // 空调控制模块
import lockControl from '@ohos.smart.device.lock'; // 门锁控制模块

export class DeviceManager {
  private lightDeviceId: string = 'light_001'; // 客厅灯设备 ID
  private acDeviceId: string = 'ac_001'; // 客厅空调设备 ID
  private lockDeviceId: string = 'lock_001'; // 门锁设备 ID
  private isConnected: boolean = false; // 设备连接状态

  // 初始化：连接所有家电设备
  async init() {
    try {
      // 1. 连接灯光设备
      const lightDevices = await distributedDevice.getDevicesByType('light');
      const targetLight = lightDevices.find(device => device.deviceId === this.lightDeviceId);
      if (targetLight) {
        await lightControl.connect(targetLight.deviceId);
        console.log('✅ 灯光设备已连接：', this.lightDeviceId);
      }

      // 2. 连接空调设备
      const acDevices = await distributedDevice.getDevicesByType('airconditioner');
      const targetAc = acDevices.find(device => device.deviceId === this.acDeviceId);
      if (targetAc) {
        await acControl.connect(targetAc.deviceId);
        console.log('✅ 空调设备已连接：', this.acDeviceId);
      }

      // 3. 连接门锁设备
      const lockDevices = await distributedDevice.getDevicesByType('lock');
      const targetLock = lockDevices.find(device => device.deviceId === this.lockDeviceId);
      if (targetLock) {
        await lockControl.connect(targetLock.deviceId);
        console.log('✅ 门锁设备已连接：', this.lockDeviceId);
      }

      this.isConnected = true;
    } catch (error) {
      console.error('设备连接失败:', error);
      this.isConnected = false;
    }
  }

  // 控制灯光（开关+亮度）
  async controlLight(isOn: boolean, brightness: number = 50) {
    if (!this.isConnected) {
      console.warn('灯光设备未连接！');
      return;
    }
    try {
      await lightControl.setPower(this.lightDeviceId, isOn);
      if (isOn) {
        await lightControl.setBrightness(this.lightDeviceId, brightness); // 亮度 0~100
      }
      console.log(`💡 灯光已${isOn ? '开启' : '关闭'}，亮度：${brightness}%`);
    } catch (error) {
      console.error('灯光控制失败:', error);
    }
  }

  // 控制空调（开关+模式+温度）
  async controlAC(isOn: boolean, mode: 'cool' | 'heat' | 'fan' | 'dry' = 'cool', temperature: number = 26) {
    if (!this.isConnected) {
      console.warn('空调设备未连接！');
      return;
    }
    try {
      await acControl.setPower(this.acDeviceId, isOn);
      if (isOn) {
        await acControl.setMode(this.acDeviceId, mode);
        await acControl.setTemperature(this.acDeviceId, temperature); // 温度 16~30℃
      }
      console.log(`❄️ 空调已${isOn ? '开启' : '关闭'}，模式：${mode}，温度：${temperature}℃`);
    } catch (error) {
      console.error('空调控制失败:', error);
    }
  }

  // 监听门锁状态（示例：通过轮询或事件回调，实际需用分布式事件监听）
  async checkLockStatus(): Promise<boolean> {
    if (!this.isConnected) {
      console.warn('门锁设备未连接！');
      return false;
    }
    try {
      const isLocked = await lockControl.getLockState(this.lockDeviceId); // 假设返回 true=已锁，false=未锁
      return !isLocked; // 门锁未锁表示“打开”（用户回家）
    } catch (error) {
      console.error('门锁状态获取失败:', error);
      return false;
    }
  }

  // 释放连接
  disconnect() {
    if (this.isConnected) {
      lightControl.disconnect(this.lightDeviceId);
      acControl.disconnect(this.acDeviceId);
      lockControl.disconnect(this.lockDeviceId);
      this.isConnected = false;
    }
  }
}

1.4 规则管理逻辑（RuleManager.ets）

// entry/src/main/ets/pages/RuleManager.ets
import { DeviceManager } from './DeviceManager.ets';
import { DateTime } from '@ohos.datetime'; // 鸿蒙时间处理模块

export class RuleManager {
  private deviceManager: DeviceManager = new DeviceManager();
  private isRuleActive: boolean = false; // 规则是否启用

  // 初始化规则（回家模式：门锁打开且时间 18:00~22:00 → 开灯+开空调）
  async initRule() {
    await this.deviceManager.init(); // 先连接设备
    this.startMonitoring();
  }

  // 开始监控门锁状态和时间（简化版：轮询，实际可用分布式事件监听）
  private async startMonitoring() {
    setInterval(async () => {
      if (!this.isRuleActive) return;

      const currentTime = DateTime.now();
      const currentHour = currentTime.hour;
      const isWithinTimeRange = currentHour >= 18 && currentHour <= 22; // 18:00~22:00

      const isDoorUnlocked = await this.deviceManager.checkLockStatus(); // 门锁未锁=用户回家

      if (isDoorUnlocked && isWithinTimeRange) {
        console.log('🔄 触发回家模式：门锁打开且时间符合');
        await this.executeHomeMode();
      }
    }, 5000); // 每 5 秒检查一次（实际可优化为事件驱动）
  }

  // 执行回家模式的具体动作
  private async executeHomeMode() {
    // 1. 开灯（亮度 70%）
    await this.deviceManager.controlLight(true, 70);

    // 2. 开空调（制冷模式，温度 26℃）
    await this.deviceManager.controlAC(true, 'cool', 26);
  }

  // 启用/禁用规则
  toggleRule(enable: boolean) {
    this.isRuleActive = enable;
    console.log('📝 回家模式规则已', enable ? '启用' : '禁用');
  }

  // 释放资源
  cleanup() {
    this.deviceManager.disconnect();
  }
}

1.5 主页面（Index.ets）

// entry/src/main/ets/pages/Index.ets
import { RuleManager } from './RuleManager.ets';

@Entry
@Component
struct Index {
  @State private ruleManager: RuleManager = new RuleManager();
  @State private isRuleEnabled: boolean = false;

  aboutToAppear() {
    // 初始化规则（应用启动时自动启用回家模式）
    this.ruleManager.initRule();
    this.isRuleEnabled = true;
  }

  // 手动切换规则状态（示例：通过按钮控制）
  private toggleRule() {
    this.isRuleEnabled = !this.isRuleEnabled;
    this.ruleManager.toggleRule(this.isRuleEnabled);
  }

  build() {
    Column() {
      Text('鸿蒙家电联动 - 回家模式（自动开灯/开空调）')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 30 });

      // 规则状态显示
      Text(this.isRuleEnabled ? '✅ 回家模式已启用' : '❌ 回家模式已禁用')
        .fontSize(18)
        .fontColor(this.isRuleEnabled ? '#4CAF50' : '#f44336')
        .margin({ bottom: 20 });

      // 手动切换按钮（测试用）
      Button(this.isRuleEnabled ? '禁用回家模式' : '启用回家模式')
        .onClick(() => this.toggleRule())
        .margin({ bottom: 30 });

      // 当前设备状态（模拟）
      Text('🔅 客厅灯：待触发')
        .fontSize(14)
        .margin({ bottom: 5 });
      Text('❄️ 客厅空调：待触发')
        .fontSize(14);
    }
    .width('100%')
    .height('100%')
    .padding(20)
    .justifyContent(FlexAlign.Center);
  }

  aboutToDisappear() {
    this.ruleManager.cleanup();
  }
}

• 手机端启动应用后，自动连接客厅灯、空调和门锁设备；
• 当用户回家（门锁打开）且时间在 18:00~22:00 之间时，系统自动触发“回家模式”——客厅灯以 70% 亮度开启，空调以制冷模式（26℃）启动；
• 用户可通过“启用/禁用回家模式”按钮手动控制规则状态（测试用）。

场景 2：多设备扩展联动（进阶版）

2.1 新增设备控制逻辑（CurtainManager.ets & MusicManager.ets）

// CurtainManager.ets（窗帘控制）
export class CurtainManager {
  private curtainDeviceId: string = 'curtain_001';

  async openCurtain() {
    // 调用分布式 API 控制窗帘电机（示例）
    console.log('🪟 窗帘已拉开');
  }
}

// MusicManager.ets（音乐控制）
export class MusicManager {
  async playBackgroundMusic() {
    // 调用音乐播放 API（示例）
    console.log('🎵 背景音乐已播放（轻音乐）');
  }
}

2.2 修改规则执行逻辑（RuleManager.ets）

// 在 executeHomeMode() 中增加窗帘和音乐控制
private async executeHomeMode() {
  await this.deviceManager.controlLight(true, 70);
  await this.deviceManager.controlAC(true, 'cool', 26);
  const curtainManager = new CurtainManager();
  await curtainManager.openCurtain();
  const musicManager = new MusicManager();
  await musicManager.playBackgroundMusic();
}

• 触发“回家模式”时，灯光、空调、窗帘、音乐同时响应，形成“开灯+开空调+拉窗帘+播音乐”的完整回家体验。

五、原理解释

1. 鸿蒙家电联动的核心流程

1. ​​设备发现与连接​​：
   • 手机通过鸿蒙 ​​分布式软总线​​ 自动扫描同一局域网内的家电设备（灯、空调、门锁），并建立低延迟的安全通信通道；
   • 使用 distributedDevice.getDevicesByType()API 获取设备列表，并通过 connect()方法连接目标设备。
2. ​​自动化规则配置​​：
   • 用户通过 APP 设置规则条件（如“门锁打开”“时间 18:00~22:00”）和动作（如“开灯”“开空调”）；
   • 规则引擎（RuleManager）持续监控条件（通过轮询或事件监听），当条件满足时触发对应的设备控制指令。
3. ​​设备协同执行​​：
   • 规则引擎调用 DeviceManager中的标准化 API（如 controlLight()、controlAC()），通过分布式软总线将指令下发至对应设备；
   • 设备接收指令后，执行具体的硬件操作（如灯光电路通电、空调压缩机启动）。

2. 关键技术点

• ​​分布式软总线​​：提供低延迟（<100ms）、高可靠性的设备间通信，确保控制指令实时到达；
• ​​统一控制接口​​：屏蔽不同厂商设备的硬件差异，通过标准化 API（如 setPower、setBrightness）实现多设备兼容；
• ​​事件驱动与轮询​​：条件监控可通过分布式事件监听（如门锁状态变化事件）或定时轮询（如每 5 秒检查时间与门锁状态）实现；
• ​​安全与权限​​：通过鸿蒙权限管理（如 ohos.permission.DISTRIBUTED_DEVICE_CONTROL）保障设备控制的安全性。

六、核心特性

七、原理流程图及原理解释

原理流程图（鸿蒙家电联动 - 回家模式）

+-----------------------+       +-----------------------+       +-----------------------+
|     手机（控制端）    |       |     家电设备（被控端）|       |     分布式软总线      |
|  (Control Terminal)   |       |  (Light/AC/Lock等)    |       |  (Distributed SoftBus)|
+-----------------------+       +-----------------------+       +-----------------------+
          |                             |                             |
          |  1. 发现并连接设备        |                             |  4. 传输控制指令       |
          |-------------------------->|                             |-----------------------> |
          |  (getDevicesByType)       |                             |  (turnOn/light/ac)     |
          |                             |  2. 建立连接             |                             |
          |                             |<--------------------------|                             |
          |                             |  3. 执行设备动作         |                             |
          |                             |  (开灯/开空调/拉窗帘)  |                             |
          |  5. 监控条件（轮询/事件） |                             |  6. 返回状态（可选）   |
          |<--------------------------|                             |<----------------------- |

原理解释

1. ​​设备发现​​：手机端通过鸿蒙分布式软总线扫描同一局域网内的家电设备（如灯、空调、门锁），获取设备列表（如 light_001、ac_001、lock_001）；
2. ​​连接建立​​：手机与目标设备（如 light_001）通过软总线建立低延迟连接，为后续控制指令传输做准备；
3. ​​规则监控​​：规则引擎（RuleManager）通过轮询（每 5 秒检查一次）或事件监听（如门锁状态变化事件），实时监控“门锁打开且时间 18:00~22:00”的条件；
4. ​​指令下发​​：当条件满足时，规则引擎调用 DeviceManager的标准化 API（如 controlLight(true, 70)、controlAC(true, 'cool', 26)），通过软总线将指令传输至对应的家电设备；
5. ​​设备执行​​：家电设备接收到指令后，执行具体的硬件操作（如灯光电路通电、空调压缩机启动），实现“回家模式”的自动化响应；
6. ​​状态反馈（可选）​​：部分设备支持将当前状态（如灯光亮度、空调温度）通过软总线回传至手机端，用于 UI 实时更新。

八、环境准备

1. 开发环境

• ​​鸿蒙 SDK​​：需安装鸿蒙开发者工具（DevEco Studio），并配置 HarmonyOS 3.0 及以上版本的 SDK；
• ​​开发语言​​：eTS（基于 TypeScript 的鸿蒙声明式开发语言）；
• ​​设备​​：至少一台鸿蒙手机（如华为 P50、Mate 40 系列）和多台鸿蒙认证家电设备（如智能灯、空调、门锁、窗帘电机）；
• ​​网络​​：手机与家电设备需处于同一局域网（如连接同一 Wi-Fi），或支持蓝牙 Mesh/分布式软总线直连。

2. 权限配置

• ​​分布式设备控制权限​​：在 module.json5中声明 ohos.permission.DISTRIBUTED_DEVICE_CONTROL，用于调用家电设备控制 API；
• ​​传感器权限​​：如使用门锁传感器或红外传感器，需声明 ohos.permission.SENSOR；
• ​​时间权限​​：用于获取当前时间以判断规则触发条件（如 ohos.permission.TIME）。

3. 家电设备要求

• 必须为 ​​鸿蒙认证设备​​（支持鸿蒙智联协议），或通过第三方协议（如 Zigbee、Wi-Fi）接入鸿蒙生态（需适配层转换）；
• 支持标准控制接口（如开关、模式、温度、亮度），部分高端设备还需支持状态反馈。

九、实际详细应用代码示例实现

完整项目代码（整合上述场景）

1. 主页面（Index.ets）

2. 设备控制逻辑（DeviceManager.ets）

3. 规则管理逻辑（RuleManager.ets）

4. 模块配置（module.json5）

十、运行结果

1. 基础版表现

• 手机端启动应用后，自动连接客厅灯、空调和门锁设备；
• 当用户回家（门锁打开）且时间在 18:00~22:00 之间时，客厅灯以 70% 亮度开启，空调以制冷模式（26℃）启动；
• 控制指令实时下发，设备状态同步更新。

2. 进阶版表现

• 触发“回家模式”时，灯光、空调、窗帘、音乐同时响应，形成完整的回家场景体验；
• 用户可通过 APP 手动启用/禁用规则（测试用）。

十一、测试步骤以及详细代码

1. 测试目标

• 设备连接是否成功（手机能否发现并连接灯、空调、门锁）；
• 规则条件监控是否准确（门锁状态+时间判断）；
• 动作执行是否及时（灯光/空调/窗帘/音乐是否同时响应）；
• 规则启用/禁用是否生效。

2. 测试步骤

步骤 1：启动应用

• 在手机上安装并运行应用，确保手机与所有家电设备（灯、空调、门锁、窗帘电机）处于同一局域网。

步骤 2：验证设备连接

• 打开应用，观察控制台日志（通过 DevEco Studio 的 Log 工具）是否输出设备连接成功信息（如“✅ 灯光设备已连接：light_001”）；
• 若未连接成功，检查设备是否开机、是否支持鸿蒙协议、网络是否互通。

步骤 3：测试规则触发

• 模拟“回家场景”：打开门锁（或通过 APP 模拟门锁未锁状态），并将手机时间调整为 18:30；
• 观察是否自动触发“回家模式”——客厅灯开启（亮度 70%）、空调启动（制冷 26℃）、窗帘拉开（进阶版）、音乐播放（进阶版）。

步骤 4：测试规则控制

• 通过 APP 的“启用/禁用回家模式”按钮，手动关闭规则后，再次