智能家居系统设计：从零开始构建物联网家居控制系统

学习目标

完成本教程后，你将能够：

• 理解智能家居系统的整体架构和核心组件
• 掌握常用智能家居通信协议（MQTT、HTTP、WebSocket）
• 能够设计和实现设备联动场景
• 学会集成语音控制功能（如天猫精灵、小爱同学）
• 开发简单的移动端控制应用
• 实现云端数据存储和远程控制
• 掌握智能家居系统的安全防护措施

前置要求

在开始本教程之前，你需要：

知识要求： - 了解基本的电子电路知识 - 掌握至少一门编程语言（Python、JavaScript或C/C++） - 理解网络通信基础（TCP/IP、HTTP） - 了解物联网基本概念

技能要求： - 能够使用开发板进行简单编程 - 会使用基本的调试工具 - 具备移动应用开发基础（可选）

第一部分：智能家居系统概述

1.1 什么是智能家居？

智能家居（Smart Home） 是利用物联网技术，将家庭中的各种设备连接到一起，实现智能化控制和自动化管理的系统。

核心特点： - 互联互通：所有设备通过网络连接，实现数据共享 - 远程控制：通过手机APP随时随地控制家中设备 - 自动化：根据预设规则自动执行任务 - 智能学习：系统可以学习用户习惯，提供个性化服务 - 语音控制：通过语音助手实现自然交互

典型应用场景： - 智能照明：根据环境光线自动调节亮度 - 智能安防：实时监控，异常报警 - 智能温控：自动调节空调、地暖温度 - 智能窗帘：定时开关，联动光线传感器 - 智能家电：远程控制洗衣机、扫地机器人等

1.2 智能家居系统架构

┌─────────────────────────────────────────────────────────┐
│                  智能家居系统架构                          │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│                    应用层 (Application Layer)            │
├─────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐│
│  │ 移动APP  │  │ Web控制台│  │ 语音助手 │  │ 小程序  ││
│  └──────────┘  └──────────┘  └──────────┘  └─────────┘│
└─────────────────────────────────────────────────────────┘
                          ↕
┌─────────────────────────────────────────────────────────┐
│                    云端层 (Cloud Layer)                  │
├─────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐│
│  │ 设备管理 │  │ 数据存储 │  │ 规则引擎 │  │ AI服务  ││
│  └──────────┘  └──────────┘  └──────────┘  └─────────┘│
└─────────────────────────────────────────────────────────┘
                          ↕
┌─────────────────────────────────────────────────────────┐
│                    网关层 (Gateway Layer)                │
├─────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐             │
│  │ 智能网关 │  │ 协议转换 │  │ 本地控制 │             │
│  └──────────┘  └──────────┘  └──────────┘             │
└─────────────────────────────────────────────────────────┘
                          ↕
┌─────────────────────────────────────────────────────────┐
│                    设备层 (Device Layer)                 │
├─────────────────────────────────────────────────────────┤
│  ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐   │
│  │灯光│ │插座│ │门锁│ │窗帘│ │空调│ │摄像│ │传感│   │
│  └────┘ └────┘ └────┘ └────┘ └────┘ └────┘ └────┘   │
└─────────────────────────────────────────────────────────┘

各层功能说明：

1. 设备层
2. 各类智能设备和传感器
3. 执行具体的控制动作

4. 采集环境数据

5. 网关层

6. 连接设备和云端的桥梁
7. 协议转换和数据聚合

8. 本地场景执行

9. 云端层

10. 设备管理和数据存储
11. 规则引擎和自动化

12. AI算法和数据分析

13. 应用层

14. 用户交互界面
15. 多种控制方式
16. 数据可视化

1.3 常用通信协议

智能家居系统中常用的通信协议：

协议	特点	适用场景	功耗
Wi-Fi	速度快，覆盖广	智能家电、摄像头	高
Zigbee	低功耗，自组网	传感器、开关	低
Bluetooth	近距离，配对简单	可穿戴设备	中
MQTT	轻量级，发布订阅	设备间通信	低
HTTP/HTTPS	通用，易开发	云端通信	中

第二部分：系统硬件准备

2.1 核心硬件清单

名称	数量	说明	参考价格
ESP32开发板	1	作为智能网关	¥30
ESP8266模块	3	智能插座、灯光控制	¥15/个
继电器模块	3	控制家电开关	¥5/个
DHT22温湿度传感器	1	环境监测	¥15
人体红外传感器	1	人员检测	¥5
光敏电阻	1	光线检测	¥2
LED灯带	1	智能照明演示	¥20
5V电源适配器	2	供电	¥10/个
面包板和杜邦线	若干	电路连接	¥20

总预算：约 ¥200

2.2 软件环境准备

开发工具： - Arduino IDE 或 PlatformIO - Node.js（用于后端开发） - Python 3.x（用于数据处理） - MQTT Broker（如Mosquitto）

移动端开发（可选）： - Android Studio 或 Xcode - React Native 或 Flutter

云平台（选择其一）： - 阿里云IoT平台 - 腾讯云IoT平台 - AWS IoT Core - 自建服务器

2.3 开发环境配置

安装Arduino IDE

1. 下载Arduino IDE：https://www.arduino.cc/
2. 安装ESP32开发板支持：
3. 打开 文件 → 首选项
4. 在"附加开发板管理器网址"中添加：

   https://dl.espressif.com/dl/package_esp32_index.json
   

5. 安装ESP32开发板：
6. 工具 → 开发板 → 开发板管理器
7. 搜索"ESP32"并安装

安装MQTT Broker

Windows系统：

# 下载Mosquitto
# https://mosquitto.org/download/

# 安装后启动服务
net start mosquitto

Linux/Mac系统：

# 安装Mosquitto
sudo apt-get install mosquitto mosquitto-clients  # Ubuntu/Debian
brew install mosquitto  # macOS

# 启动服务
sudo systemctl start mosquitto

第三部分：智能设备开发

3.1 智能灯光控制

硬件连接

ESP8266 模块连接：
┌──────────────┐
│   ESP8266    │
│              │
│  GPIO5  ─────┼───> 继电器IN
│  VCC    ─────┼───> 5V
│  GND    ─────┼───> GND
└──────────────┘

继电器连接：
┌──────────────┐
│   继电器     │
│              │
│  COM    ─────┼───> 灯具火线
│  NO     ─────┼───> 电源火线
└──────────────┘

⚠️ 安全警告：涉及220V交流电，请务必注意安全！建议使用低压LED灯进行测试。

固件代码

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// Wi-Fi配置
const char* ssid = "你的WiFi名称";
const char* password = "你的WiFi密码";

// MQTT配置
const char* mqtt_server = "192.168.1.100";  // MQTT服务器地址
const int mqtt_port = 1883;
const char* mqtt_user = "admin";
const char* mqtt_password = "password";

// 设备配置
const char* device_id = "light_001";
const char* topic_control = "home/light/001/control";
const char* topic_state = "home/light/001/state";

// 硬件配置
const int RELAY_PIN = 5;  // GPIO5连接继电器
bool lightState = false;

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);

  // 连接Wi-Fi
  setup_wifi();

  // 配置MQTT
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("连接到 ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi已连接");
  Serial.println("IP地址: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("收到消息 [");
  Serial.print(topic);
  Serial.print("] ");

  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  Serial.println(message);

  // 解析命令
  if (message == "ON") {
    lightState = true;
    digitalWrite(RELAY_PIN, HIGH);
    Serial.println("灯光已打开");
  } else if (message == "OFF") {
    lightState = false;
    digitalWrite(RELAY_PIN, LOW);
    Serial.println("灯光已关闭");
  } else if (message == "TOGGLE") {
    lightState = !lightState;
    digitalWrite(RELAY_PIN, lightState ? HIGH : LOW);
    Serial.println(lightState ? "灯光已打开" : "灯光已关闭");
  }

  // 发布状态
  publishState();
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("尝试MQTT连接...");

    if (client.connect(device_id, mqtt_user, mqtt_password)) {
      Serial.println("已连接");
      client.subscribe(topic_control);
      publishState();
    } else {
      Serial.print("失败, rc=");
      Serial.print(client.state());
      Serial.println(" 5秒后重试");
      delay(5000);
    }
  }
}

void publishState() {
  String state = lightState ? "ON" : "OFF";
  client.publish(topic_state, state.c_str());
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

代码说明： - 使用MQTT协议进行通信 - 订阅控制主题接收命令 - 发布状态主题报告设备状态 - 支持ON、OFF、TOGGLE三种命令

测试验证

1. 上传代码到ESP8266
2. 打开串口监视器（波特率115200）
3. 使用MQTT客户端测试：

# 发送开灯命令
mosquitto_pub -h 192.168.1.100 -t "home/light/001/control" -m "ON"

# 发送关灯命令
mosquitto_pub -h 192.168.1.100 -t "home/light/001/control" -m "OFF"

# 订阅状态主题
mosquitto_sub -h 192.168.1.100 -t "home/light/001/state"

3.2 温湿度监测

硬件连接

ESP8266 + DHT22连接：
┌──────────────┐
│   ESP8266    │
│              │
│  GPIO4  ─────┼───> DHT22 DATA
│  3.3V   ─────┼───> DHT22 VCC
│  GND    ─────┼───> DHT22 GND
└──────────────┘

固件代码

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

// DHT传感器配置
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

// Wi-Fi和MQTT配置（同上）
const char* device_id = "sensor_001";
const char* topic_temperature = "home/sensor/001/temperature";
const char* topic_humidity = "home/sensor/001/humidity";

WiFiClient espClient;
PubSubClient client(espClient);

unsigned long lastMsg = 0;
const long interval = 10000;  // 10秒上报一次

void setup() {
  Serial.begin(115200);
  dht.begin();

  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  unsigned long now = millis();
  if (now - lastMsg > interval) {
    lastMsg = now;

    // 读取温湿度
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

    if (isnan(temperature) || isnan(humidity)) {
      Serial.println("读取DHT传感器失败!");
      return;
    }

    // 发布数据
    char tempStr[8];
    char humStr[8];
    dtostrf(temperature, 6, 2, tempStr);
    dtostrf(humidity, 6, 2, humStr);

    client.publish(topic_temperature, tempStr);
    client.publish(topic_humidity, humStr);

    Serial.print("温度: ");
    Serial.print(temperature);
    Serial.print("°C, 湿度: ");
    Serial.print(humidity);
    Serial.println("%");
  }
}

3.3 人体感应灯光

硬件连接

ESP8266 + PIR传感器 + 继电器：
┌──────────────┐
│   ESP8266    │
│              │
│  GPIO12 ─────┼───> PIR传感器 OUT
│  GPIO5  ─────┼───> 继电器 IN
│  VCC    ─────┼───> 5V (PIR和继电器)
│  GND    ─────┼───> GND
└──────────────┘

固件代码

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const int PIR_PIN = 12;
const int RELAY_PIN = 5;
const int AUTO_OFF_DELAY = 30000;  // 30秒无人自动关灯

bool motionDetected = false;
unsigned long lastMotionTime = 0;
bool autoMode = true;  // 自动模式开关

// Wi-Fi和MQTT配置
const char* device_id = "motion_light_001";
const char* topic_control = "home/motion_light/001/control";
const char* topic_state = "home/motion_light/001/state";
const char* topic_motion = "home/motion_light/001/motion";

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);

  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void callback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }

  if (message == "AUTO_ON") {
    autoMode = true;
    Serial.println("自动模式已开启");
  } else if (message == "AUTO_OFF") {
    autoMode = false;
    digitalWrite(RELAY_PIN, LOW);
    Serial.println("自动模式已关闭");
  } else if (message == "MANUAL_ON") {
    autoMode = false;
    digitalWrite(RELAY_PIN, HIGH);
    Serial.println("手动开灯");
  } else if (message == "MANUAL_OFF") {
    autoMode = false;
    digitalWrite(RELAY_PIN, LOW);
    Serial.println("手动关灯");
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  if (autoMode) {
    // 检测人体移动
    int pirState = digitalRead(PIR_PIN);

    if (pirState == HIGH) {
      if (!motionDetected) {
        motionDetected = true;
        digitalWrite(RELAY_PIN, HIGH);
        client.publish(topic_motion, "DETECTED");
        Serial.println("检测到人体移动，开灯");
      }
      lastMotionTime = millis();
    } else {
      // 无人移动超过设定时间，关灯
      if (motionDetected && (millis() - lastMotionTime > AUTO_OFF_DELAY)) {
        motionDetected = false;
        digitalWrite(RELAY_PIN, LOW);
        client.publish(topic_motion, "CLEAR");
        Serial.println("无人移动，关灯");
      }
    }
  }
}

功能说明： - 自动模式：检测到人体移动自动开灯，30秒无人自动关灯 - 手动模式：通过MQTT命令手动控制 - 状态上报：实时上报人体检测状态

第四部分：智能网关开发

4.1 网关功能设计

智能网关作为系统的核心，负责： - 设备管理和状态监控 - 场景联动执行 - 数据聚合和转发 - 本地规则引擎

4.2 网关代码实现

使用ESP32作为网关，代码框架：

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <WebServer.h>

// 设备列表
struct Device {
  String id;
  String type;
  String state;
  unsigned long lastUpdate;
};

std::vector<Device> devices;

// Web服务器
WebServer server(80);

// MQTT客户端
WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);

  // 连接Wi-Fi
  setup_wifi();

  // 配置MQTT
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(mqttCallback);

  // 配置Web服务器
  setupWebServer();
  server.begin();

  Serial.println("智能网关已启动");
}

void setupWebServer() {
  // 获取设备列表
  server.on("/api/devices", HTTP_GET, []() {
    DynamicJsonDocument doc(1024);
    JsonArray array = doc.to<JsonArray>();

    for (auto& device : devices) {
      JsonObject obj = array.createNestedObject();
      obj["id"] = device.id;
      obj["type"] = device.type;
      obj["state"] = device.state;
      obj["lastUpdate"] = device.lastUpdate;
    }

    String response;
    serializeJson(doc, response);
    server.send(200, "application/json", response);
  });

  // 控制设备
  server.on("/api/control", HTTP_POST, []() {
    if (server.hasArg("plain")) {
      DynamicJsonDocument doc(256);
      deserializeJson(doc, server.arg("plain"));

      String deviceId = doc["deviceId"];
      String command = doc["command"];

      // 发送MQTT命令
      String topic = "home/" + deviceId + "/control";
      client.publish(topic.c_str(), command.c_str());

      server.send(200, "application/json", "{\"status\":\"ok\"}");
    } else {
      server.send(400, "application/json", "{\"error\":\"invalid request\"}");
    }
  });

  // 创建场景
  server.on("/api/scene", HTTP_POST, []() {
    // 场景逻辑处理
    server.send(200, "application/json", "{\"status\":\"ok\"}");
  });
}

void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String topicStr = String(topic);
  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }

  // 解析主题，更新设备状态
  if (topicStr.indexOf("/state") > 0) {
    updateDeviceState(topicStr, message);
  }

  // 执行场景联动
  checkSceneRules();
}

void updateDeviceState(String topic, String state) {
  // 从主题中提取设备ID
  // 例如: home/light/001/state -> light_001

  for (auto& device : devices) {
    if (topic.indexOf(device.id) > 0) {
      device.state = state;
      device.lastUpdate = millis();
      Serial.println("设备状态更新: " + device.id + " = " + state);
      break;
    }
  }
}

void checkSceneRules() {
  // 场景规则示例：
  // 规则1：晚上7点后，检测到人体移动，自动开灯
  // 规则2：温度超过28度，自动开启空调
  // 规则3：离家模式，关闭所有灯光和电器

  // 这里可以实现复杂的规则引擎
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  server.handleClient();
}

4.3 场景联动实现

场景1：回家模式

void executeHomeScene() {
  // 1. 打开玄关灯
  client.publish("home/light/entrance/control", "ON");

  // 2. 打开客厅灯（亮度50%）
  client.publish("home/light/living/control", "{\"state\":\"ON\",\"brightness\":50}");

  // 3. 如果温度高于26度，开启空调
  float temp = getTemperature();
  if (temp > 26.0) {
    client.publish("home/ac/001/control", "{\"state\":\"ON\",\"temp\":24}");
  }

  // 4. 打开背景音乐
  client.publish("home/music/001/control", "PLAY");

  Serial.println("回家模式已执行");
}

场景2：离家模式

void executeAwayScene() {
  // 1. 关闭所有灯光
  for (auto& device : devices) {
    if (device.type == "light") {
      String topic = "home/" + device.id + "/control";
      client.publish(topic.c_str(), "OFF");
    }
  }

  // 2. 关闭空调
  client.publish("home/ac/001/control", "OFF");

  // 3. 启动安防模式
  client.publish("home/security/001/control", "ARM");

  // 4. 关闭不必要的电器
  client.publish("home/tv/001/control", "OFF");

  Serial.println("离家模式已执行");
}

场景3：睡眠模式

void executeSleepScene() {
  // 1. 关闭客厅和餐厅灯光
  client.publish("home/light/living/control", "OFF");
  client.publish("home/light/dining/control", "OFF");

  // 2. 卧室灯调至夜灯模式（亮度10%）
  client.publish("home/light/bedroom/control", "{\"state\":\"ON\",\"brightness\":10}");

  // 3. 关闭电视和音响
  client.publish("home/tv/001/control", "OFF");
  client.publish("home/music/001/control", "STOP");

  // 4. 空调设置为睡眠模式
  client.publish("home/ac/001/control", "{\"mode\":\"sleep\",\"temp\":26}");

  Serial.println("睡眠模式已执行");
}

第五部分：移动应用开发

5.1 应用功能设计

核心功能： - 设备列表和状态显示 - 设备控制（开关、调节） - 场景快捷执行 - 定时任务设置 - 数据统计和历史记录

5.2 使用React Native开发

项目初始化

# 创建新项目
npx react-native init SmartHomeApp

# 安装依赖
cd SmartHomeApp
npm install mqtt axios react-navigation

设备控制界面

// DeviceControl.js
import React, { useState, useEffect } from 'react';
import { View, Text, Switch, StyleSheet, FlatList } from 'react-native';
import mqtt from 'mqtt';

const DeviceControl = () => {
  const [devices, setDevices] = useState([]);
  const [client, setClient] = useState(null);

  useEffect(() => {
    // 连接MQTT服务器
    const mqttClient = mqtt.connect('mqtt://192.168.1.100:1883', {
      username: 'admin',
      password: 'password'
    });

    mqttClient.on('connect', () => {
      console.log('MQTT已连接');
      // 订阅所有设备状态主题
      mqttClient.subscribe('home/+/+/state');
    });

    mqttClient.on('message', (topic, message) => {
      // 更新设备状态
      updateDeviceState(topic, message.toString());
    });

    setClient(mqttClient);

    // 获取设备列表
    fetchDevices();

    return () => {
      if (mqttClient) {
        mqttClient.end();
      }
    };
  }, []);

  const fetchDevices = async () => {
    try {
      const response = await fetch('http://192.168.1.100/api/devices');
      const data = await response.json();
      setDevices(data);
    } catch (error) {
      console.error('获取设备列表失败:', error);
    }
  };

  const updateDeviceState = (topic, state) => {
    setDevices(prevDevices => 
      prevDevices.map(device => {
        if (topic.includes(device.id)) {
          return { ...device, state: state };
        }
        return device;
      })
    );
  };

  const toggleDevice = (device) => {
    if (client) {
      const command = device.state === 'ON' ? 'OFF' : 'ON';
      const topic = `home/${device.id}/control`;
      client.publish(topic, command);
    }
  };

  const renderDevice = ({ item }) => (
    <View style={styles.deviceItem}>
      <View style={styles.deviceInfo}>
        <Text style={styles.deviceName}>{item.name}</Text>
        <Text style={styles.deviceType}>{item.type}</Text>
      </View>
      <Switch
        value={item.state === 'ON'}
        onValueChange={() => toggleDevice(item)}
      />
    </View>
  );

  return (
    <View style={styles.container}>
      <Text style={styles.title}>我的设备</Text>
      <FlatList
        data={devices}
        renderItem={renderDevice}
        keyExtractor={item => item.id}
      />
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#f5f5f5',
    padding: 16,
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    marginBottom: 16,
  },
  deviceItem: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    alignItems: 'center',
    backgroundColor: 'white',
    padding: 16,
    marginBottom: 8,
    borderRadius: 8,
  },
  deviceInfo: {
    flex: 1,
  },
  deviceName: {
    fontSize: 18,
    fontWeight: '500',
  },
  deviceType: {
    fontSize: 14,
    color: '#666',
    marginTop: 4,
  },
});

export default DeviceControl;

场景控制界面

// SceneControl.js
import React from 'react';
import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';

const SceneControl = () => {
  const scenes = [
    { id: 'home', name: '回家模式', icon: '🏠' },
    { id: 'away', name: '离家模式', icon: '🚪' },
    { id: 'sleep', name: '睡眠模式', icon: '🌙' },
    { id: 'movie', name: '观影模式', icon: '🎬' },
  ];

  const executeScene = async (sceneId) => {
    try {
      await fetch('http://192.168.1.100/api/scene', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ sceneId }),
      });
      console.log(`场景 ${sceneId} 已执行`);
    } catch (error) {
      console.error('执行场景失败:', error);
    }
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>智能场景</Text>
      <View style={styles.sceneGrid}>
        {scenes.map(scene => (
          <TouchableOpacity
            key={scene.id}
            style={styles.sceneButton}
            onPress={() => executeScene(scene.id)}
          >
            <Text style={styles.sceneIcon}>{scene.icon}</Text>
            <Text style={styles.sceneName}>{scene.name}</Text>
          </TouchableOpacity>
        ))}
      </View>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#f5f5f5',
    padding: 16,
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    marginBottom: 16,
  },
  sceneGrid: {
    flexDirection: 'row',
    flexWrap: 'wrap',
    justifyContent: 'space-between',
  },
  sceneButton: {
    width: '48%',
    aspectRatio: 1,
    backgroundColor: 'white',
    borderRadius: 12,
    justifyContent: 'center',
    alignItems: 'center',
    marginBottom: 16,
    elevation: 2,
  },
  sceneIcon: {
    fontSize: 48,
    marginBottom: 8,
  },
  sceneName: {
    fontSize: 16,
    fontWeight: '500',
  },
});

export default SceneControl;

5.3 数据可视化

// DataVisualization.js
import React, { useState, useEffect } from 'react';
import { View, Text, StyleSheet, Dimensions } from 'react-native';
import { LineChart } from 'react-native-chart-kit';

const DataVisualization = () => {
  const [temperatureData, setTemperatureData] = useState([]);
  const [humidityData, setHumidityData] = useState([]);

  useEffect(() => {
    // 获取历史数据
    fetchHistoryData();

    // 每分钟更新一次
    const interval = setInterval(fetchHistoryData, 60000);

    return () => clearInterval(interval);
  }, []);

  const fetchHistoryData = async () => {
    try {
      const response = await fetch('http://192.168.1.100/api/history?hours=24');
      const data = await response.json();

      setTemperatureData(data.temperature);
      setHumidityData(data.humidity);
    } catch (error) {
      console.error('获取历史数据失败:', error);
    }
  };

  const chartConfig = {
    backgroundColor: '#ffffff',
    backgroundGradientFrom: '#ffffff',
    backgroundGradientTo: '#ffffff',
    decimalPlaces: 1,
    color: (opacity = 1) => `rgba(0, 122, 255, ${opacity})`,
    style: {
      borderRadius: 16,
    },
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>环境数据</Text>

      <View style={styles.chartContainer}>
        <Text style={styles.chartTitle}>温度趋势（24小时）</Text>
        <LineChart
          data={{
            labels: ['0h', '6h', '12h', '18h', '24h'],
            datasets: [{ data: temperatureData }],
          }}
          width={Dimensions.get('window').width - 32}
          height={220}
          chartConfig={chartConfig}
          bezier
          style={styles.chart}
        />
      </View>

      <View style={styles.chartContainer}>
        <Text style={styles.chartTitle}>湿度趋势（24小时）</Text>
        <LineChart
          data={{
            labels: ['0h', '6h', '12h', '18h', '24h'],
            datasets: [{ data: humidityData }],
          }}
          width={Dimensions.get('window').width - 32}
          height={220}
          chartConfig={{
            ...chartConfig,
            color: (opacity = 1) => `rgba(52, 199, 89, ${opacity})`,
          }}
          bezier
          style={styles.chart}
        />
      </View>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#f5f5f5',
    padding: 16,
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    marginBottom: 16,
  },
  chartContainer: {
    backgroundColor: 'white',
    borderRadius: 12,
    padding: 16,
    marginBottom: 16,
  },
  chartTitle: {
    fontSize: 18,
    fontWeight: '500',
    marginBottom: 12,
  },
  chart: {
    borderRadius: 8,
  },
});

export default DataVisualization;

第六部分：语音控制集成

6.1 接入天猫精灵

注册开发者账号

1. 访问天猫精灵开放平台：https://open.bot.tmall.com/
2. 注册并创建技能
3. 配置OAuth2.0授权
4. 设置设备控制接口

实现控制接口

// 使用Node.js实现天猫精灵控制接口
const express = require('express');
const mqtt = require('mqtt');
const app = express();

app.use(express.json());

// MQTT客户端
const mqttClient = mqtt.connect('mqtt://localhost:1883');

// 天猫精灵设备发现接口
app.post('/tmall/discovery', (req, res) => {
  const devices = [
    {
      deviceId: 'light_001',
      deviceName: '客厅灯',
      deviceType: 'light',
      zone: '客厅',
      brand: 'DIY',
      model: 'v1.0',
      icon: 'https://example.com/icon/light.png',
      properties: [
        { name: 'powerstate', value: 'off' },
        { name: 'brightness', value: 100 }
      ],
      actions: ['TurnOn', 'TurnOff', 'SetBrightness']
    },
    {
      deviceId: 'ac_001',
      deviceName: '客厅空调',
      deviceType: 'aircondition',
      zone: '客厅',
      brand: 'DIY',
      model: 'v1.0',
      properties: [
        { name: 'powerstate', value: 'off' },
        { name: 'temperature', value: 26 }
      ],
      actions: ['TurnOn', 'TurnOff', 'SetTemperature']
    }
  ];

  res.json({
    header: {
      namespace: 'AliGenie.Iot.Device.Discovery',
      name: 'DiscoveryDevicesResponse',
      messageId: req.body.header.messageId,
      payLoadVersion: 1
    },
    payload: {
      devices: devices
    }
  });
});

// 天猫精灵设备控制接口
app.post('/tmall/control', (req, res) => {
  const { header, payload } = req.body;
  const { deviceId, deviceType } = payload;
  const action = header.name;

  let command = '';
  let topic = '';

  // 根据设备类型和动作生成MQTT命令
  if (deviceType === 'light') {
    topic = `home/light/${deviceId}/control`;
    if (action === 'TurnOn') {
      command = 'ON';
    } else if (action === 'TurnOff') {
      command = 'OFF';
    } else if (action === 'SetBrightness') {
      const brightness = payload.brightness;
      command = JSON.stringify({ state: 'ON', brightness });
    }
  } else if (deviceType === 'aircondition') {
    topic = `home/ac/${deviceId}/control`;
    if (action === 'TurnOn') {
      command = JSON.stringify({ state: 'ON', temp: 26 });
    } else if (action === 'TurnOff') {
      command = 'OFF';
    } else if (action === 'SetTemperature') {
      const temp = payload.temperature;
      command = JSON.stringify({ state: 'ON', temp });
    }
  }

  // 发送MQTT命令
  mqttClient.publish(topic, command);

  res.json({
    header: {
      namespace: 'AliGenie.Iot.Device.Control',
      name: action + 'Response',
      messageId: req.body.header.messageId,
      payLoadVersion: 1
    },
    payload: {
      deviceId: deviceId
    }
  });
});

app.listen(3000, () => {
  console.log('天猫精灵接口服务已启动，端口3000');
});

6.2 语音命令示例

配置完成后，可以使用以下语音命令：

"天猫精灵，打开客厅灯"
"天猫精灵，关闭客厅灯"
"天猫精灵，把客厅灯调到50%"
"天猫精灵，打开空调"
"天猫精灵，把空调温度设置为26度"
"天猫精灵，执行回家模式"

第七部分：云端集成

7.1 使用阿里云IoT平台

创建产品和设备

1. 登录阿里云IoT平台控制台
2. 创建产品（选择"自定义品类"）
3. 定义物模型（属性、事件、服务）
4. 添加设备并获取三元组信息

设备端代码

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

// 阿里云IoT三元组
const char* productKey = "your_product_key";
const char* deviceName = "your_device_name";
const char* deviceSecret = "your_device_secret";

// 阿里云IoT MQTT服务器
const char* mqtt_server = "iot-as-mqtt.cn-shanghai.aliyuncs.com";
const int mqtt_port = 1883;

// 计算MQTT连接参数
String clientId;
String mqttUsername;
String mqttPassword;

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);

  // 连接Wi-Fi
  setup_wifi();

  // 计算阿里云IoT连接参数
  calculateAliyunParams();

  // 配置MQTT
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void calculateAliyunParams() {
  // 阿里云IoT MQTT连接参数计算
  // clientId格式: clientId + "|securemode=3,signmethod=hmacsha1|"
  clientId = String(deviceName) + "|securemode=3,signmethod=hmacsha1|";

  // username格式: deviceName + "&" + productKey
  mqttUsername = String(deviceName) + "&" + String(productKey);

  // password需要使用HMAC-SHA1算法计算
  // 这里简化处理，实际应用中需要正确计算
  mqttPassword = deviceSecret;
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("收到消息 [");
  Serial.print(topic);
  Serial.print("] ");

  DynamicJsonDocument doc(1024);
  deserializeJson(doc, payload, length);

  // 解析阿里云IoT下发的命令
  if (doc.containsKey("method")) {
    String method = doc["method"];

    if (method == "thing.service.property.set") {
      // 属性设置
      JsonObject params = doc["params"];
      if (params.containsKey("PowerSwitch")) {
        int powerSwitch = params["PowerSwitch"];
        digitalWrite(RELAY_PIN, powerSwitch);

        // 上报属性
        reportProperty("PowerSwitch", powerSwitch);
      }
    }
  }
}

void reportProperty(String propertyName, int value) {
  // 构造属性上报消息
  DynamicJsonDocument doc(256);
  doc["id"] = String(millis());
  doc["version"] = "1.0";
  doc["method"] = "thing.event.property.post";

  JsonObject params = doc.createNestedObject("params");
  params[propertyName] = value;

  String payload;
  serializeJson(doc, payload);

  // 发布到属性上报主题
  String topic = "/sys/" + String(productKey) + "/" + String(deviceName) + "/thing/event/property/post";
  client.publish(topic.c_str(), payload.c_str());
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  // 定期上报数据
  static unsigned long lastReport = 0;
  if (millis() - lastReport > 10000) {
    lastReport = millis();

    // 上报温湿度数据
    float temperature = readTemperature();
    float humidity = readHumidity();

    DynamicJsonDocument doc(256);
    doc["id"] = String(millis());
    doc["version"] = "1.0";
    doc["method"] = "thing.event.property.post";

    JsonObject params = doc.createNestedObject("params");
    params["CurrentTemperature"] = temperature;
    params["CurrentHumidity"] = humidity;

    String payload;
    serializeJson(doc, payload);

    String topic = "/sys/" + String(productKey) + "/" + String(deviceName) + "/thing/event/property/post";
    client.publish(topic.c_str(), payload.c_str());
  }
}

7.2 数据存储和分析

使用时序数据库

// 使用InfluxDB存储时序数据
const Influx = require('influx');

const influx = new Influx.InfluxDB({
  host: 'localhost',
  database: 'smart_home',
  schema: [
    {
      measurement: 'temperature',
      fields: {
        value: Influx.FieldType.FLOAT
      },
      tags: ['device_id', 'location']
    },
    {
      measurement: 'humidity',
      fields: {
        value: Influx.FieldType.FLOAT
      },
      tags: ['device_id', 'location']
    }
  ]
});

// 写入数据
async function writeData(deviceId, location, temperature, humidity) {
  await influx.writePoints([
    {
      measurement: 'temperature',
      tags: { device_id: deviceId, location: location },
      fields: { value: temperature },
      timestamp: new Date()
    },
    {
      measurement: 'humidity',
      tags: { device_id: deviceId, location: location },
      fields: { value: humidity },
      timestamp: new Date()
    }
  ]);
}

// 查询数据
async function queryData(hours = 24) {
  const result = await influx.query(`
    SELECT mean(value) as avg_temp
    FROM temperature
    WHERE time > now() - ${hours}h
    GROUP BY time(1h), device_id
  `);

  return result;
}

7.3 RESTful API设计

// 使用Express构建RESTful API
const express = require('express');
const app = express();

app.use(express.json());

// 获取设备列表
app.get('/api/devices', async (req, res) => {
  try {
    const devices = await getDevicesFromDatabase();
    res.json(devices);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// 获取设备状态
app.get('/api/devices/:id', async (req, res) => {
  try {
    const device = await getDeviceById(req.params.id);
    res.json(device);
  } catch (error) {
    res.status(404).json({ error: 'Device not found' });
  }
});

// 控制设备
app.post('/api/devices/:id/control', async (req, res) => {
  try {
    const { command, params } = req.body;
    await controlDevice(req.params.id, command, params);
    res.json({ status: 'success' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// 获取历史数据
app.get('/api/devices/:id/history', async (req, res) => {
  try {
    const { start, end } = req.query;
    const history = await getDeviceHistory(req.params.id, start, end);
    res.json(history);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// 创建场景
app.post('/api/scenes', async (req, res) => {
  try {
    const scene = await createScene(req.body);
    res.json(scene);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// 执行场景
app.post('/api/scenes/:id/execute', async (req, res) => {
  try {
    await executeScene(req.params.id);
    res.json({ status: 'success' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000, () => {
  console.log('API服务已启动，端口3000');
});

第八部分：系统安全

8.1 网络安全

使用HTTPS/TLS加密

// 配置HTTPS服务器
const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('private-key.pem'),
  cert: fs.readFileSync('certificate.pem')
};

https.createServer(options, app).listen(443, () => {
  console.log('HTTPS服务器已启动，端口443');
});

MQTT TLS配置

// ESP32使用TLS连接MQTT
#include <WiFiClientSecure.h>

WiFiClientSecure espClient;
PubSubClient client(espClient);

void setup() {
  // 设置CA证书
  espClient.setCACert(ca_cert);

  // 连接到MQTT服务器（使用8883端口）
  client.setServer(mqtt_server, 8883);
}

8.2 身份认证

JWT Token认证

const jwt = require('jsonwebtoken');
const SECRET_KEY = 'your_secret_key';

// 生成Token
function generateToken(userId) {
  return jwt.sign(
    { userId: userId },
    SECRET_KEY,
    { expiresIn: '7d' }
  );
}

// 验证Token中间件
function authenticateToken(req, res, next) {
  const token = req.headers['authorization'];

  if (!token) {
    return res.status(401).json({ error: 'No token provided' });
  }

  jwt.verify(token, SECRET_KEY, (err, decoded) => {
    if (err) {
      return res.status(403).json({ error: 'Invalid token' });
    }
    req.userId = decoded.userId;
    next();
  });
}

// 使用认证中间件
app.get('/api/devices', authenticateToken, (req, res) => {
  // 只有认证用户才能访问
  // ...
});

8.3 数据加密

// 敏感数据加密存储
#include <mbedtls/aes.h>

void encryptData(const char* plaintext, char* ciphertext, const char* key) {
  mbedtls_aes_context aes;
  mbedtls_aes_init(&aes);
  mbedtls_aes_setkey_enc(&aes, (const unsigned char*)key, 256);

  mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT,
                        (const unsigned char*)plaintext,
                        (unsigned char*)ciphertext);

  mbedtls_aes_free(&aes);
}

8.4 访问控制

// 基于角色的访问控制（RBAC）
const roles = {
  admin: ['read', 'write', 'delete', 'control'],
  user: ['read', 'control'],
  guest: ['read']
};

function checkPermission(userRole, action) {
  return roles[userRole] && roles[userRole].includes(action);
}

// 权限检查中间件
function requirePermission(action) {
  return (req, res, next) => {
    const userRole = req.user.role;

    if (checkPermission(userRole, action)) {
      next();
    } else {
      res.status(403).json({ error: 'Permission denied' });
    }
  };
}

// 使用权限检查
app.delete('/api/devices/:id', 
  authenticateToken,
  requirePermission('delete'),
  (req, res) => {
    // 只有admin可以删除设备
    // ...
  }
);

第九部分：系统测试与调试

9.1 单元测试

// 使用Jest进行单元测试
const { controlDevice, getDeviceState } = require('./deviceController');

describe('设备控制测试', () => {
  test('打开灯光', async () => {
    const result = await controlDevice('light_001', 'ON');
    expect(result.status).toBe('success');

    const state = await getDeviceState('light_001');
    expect(state).toBe('ON');
  });

  test('关闭灯光', async () => {
    const result = await controlDevice('light_001', 'OFF');
    expect(result.status).toBe('success');

    const state = await getDeviceState('light_001');
    expect(state).toBe('OFF');
  });
});

9.2 集成测试

// 测试场景联动
describe('场景联动测试', () => {
  test('回家模式', async () => {
    await executeScene('home');

    // 验证各设备状态
    expect(await getDeviceState('light_entrance')).toBe('ON');
    expect(await getDeviceState('light_living')).toBe('ON');

    const temp = await getTemperature();
    if (temp > 26) {
      expect(await getDeviceState('ac_001')).toBe('ON');
    }
  });
});

9.3 性能测试

// 使用Artillery进行负载测试
// artillery.yml
const config = {
  target: 'http://localhost:3000',
  phases: [
    { duration: 60, arrivalRate: 10 }  // 60秒内，每秒10个请求
  ],
  scenarios: [
    {
      name: '设备控制',
      flow: [
        { get: { url: '/api/devices' } },
        { post: {
            url: '/api/devices/light_001/control',
            json: { command: 'ON' }
          }
        }
      ]
    }
  ]
};

// 运行测试
// artillery run artillery.yml

9.4 常见问题排查

问题1：设备离线

排查步骤： 1. 检查设备电源 2. 检查Wi-Fi连接状态 3. 检查MQTT连接状态 4. 查看设备日志

// 添加调试日志
void loop() {
  if (!client.connected()) {
    Serial.println("MQTT未连接，尝试重连...");
    reconnect();
  }

  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Wi-Fi未连接，尝试重连...");
    setup_wifi();
  }
}

问题2：控制延迟

可能原因： - 网络延迟 - MQTT服务器负载高 - 设备处理能力不足

优化方案： - 使用本地网关减少云端通信 - 优化MQTT QoS设置 - 减少设备扫描周期

问题3：数据丢失

解决方案： - 使用MQTT QoS 1或2 - 实现消息确认机制 - 添加数据缓存

// 使用QoS 1确保消息送达
client.publish(topic, message, 1);  // QoS = 1

第十部分：系统扩展与优化

10.1 添加更多设备类型

智能窗帘

// 智能窗帘控制
#include <Stepper.h>

const int stepsPerRevolution = 2048;
Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);

int currentPosition = 0;  // 0=关闭, 100=完全打开

void setup() {
  myStepper.setSpeed(10);
}

void setCurtainPosition(int targetPosition) {
  int steps = (targetPosition - currentPosition) * stepsPerRevolution / 100;
  myStepper.step(steps);
  currentPosition = targetPosition;

  Serial.print("窗帘位置: ");
  Serial.print(currentPosition);
  Serial.println("%");
}

void callback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }

  if (message == "OPEN") {
    setCurtainPosition(100);
  } else if (message == "CLOSE") {
    setCurtainPosition(0);
  } else if (message.startsWith("SET:")) {
    int position = message.substring(4).toInt();
    setCurtainPosition(position);
  }
}

智能门锁

// 智能门锁控制
#include <Keypad.h>
#include <Servo.h>

Servo lockServo;
const int LOCK_PIN = 9;
const int LOCKED_ANGLE = 0;
const int UNLOCKED_ANGLE = 90;

bool isLocked = true;
String correctPassword = "1234";

void setup() {
  lockServo.attach(LOCK_PIN);
  lockServo.write(LOCKED_ANGLE);
}

void unlock() {
  lockServo.write(UNLOCKED_ANGLE);
  isLocked = false;
  client.publish("home/lock/001/state", "UNLOCKED");
  Serial.println("门锁已打开");

  // 30秒后自动上锁
  delay(30000);
  lock();
}

void lock() {
  lockServo.write(LOCKED_ANGLE);
  isLocked = true;
  client.publish("home/lock/001/state", "LOCKED");
  Serial.println("门锁已关闭");
}

void callback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }

  if (message == "UNLOCK") {
    unlock();
  } else if (message == "LOCK") {
    lock();
  } else if (message.startsWith("PASSWORD:")) {
    String password = message.substring(9);
    if (password == correctPassword) {
      unlock();
    } else {
      client.publish("home/lock/001/error", "WRONG_PASSWORD");
    }
  }
}

10.2 能耗监测

// 使用PZEM-004T模块监测能耗
#include <PZEM004Tv30.h>

PZEM004Tv30 pzem(Serial2);

void loop() {
  float voltage = pzem.voltage();
  float current = pzem.current();
  float power = pzem.power();
  float energy = pzem.energy();
  float frequency = pzem.frequency();
  float pf = pzem.pf();

  if (!isnan(voltage)) {
    // 构造JSON数据
    DynamicJsonDocument doc(256);
    doc["voltage"] = voltage;
    doc["current"] = current;
    doc["power"] = power;
    doc["energy"] = energy;
    doc["frequency"] = frequency;
    doc["pf"] = pf;

    String payload;
    serializeJson(doc, payload);

    client.publish("home/energy/001/data", payload.c_str());

    Serial.print("电压: "); Serial.print(voltage); Serial.println("V");
    Serial.print("电流: "); Serial.print(current); Serial.println("A");
    Serial.print("功率: "); Serial.print(power); Serial.println("W");
    Serial.print("电能: "); Serial.print(energy); Serial.println("kWh");
  }

  delay(2000);
}

10.3 AI智能学习

# 使用机器学习预测用户行为
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
import joblib

# 训练数据示例
# 特征：时间、星期、温度、湿度、光照
# 标签：是否开灯
data = pd.read_csv('user_behavior.csv')

X = data[['hour', 'weekday', 'temperature', 'humidity', 'light']]
y = data['light_on']

# 训练模型
model = RandomForestClassifier(n_estimators=100)
model.fit(X, y)

# 保存模型
joblib.dump(model, 'behavior_model.pkl')

# 预测
def predict_light_state(hour, weekday, temperature, humidity, light):
    model = joblib.load('behavior_model.pkl')
    prediction = model.predict([[hour, weekday, temperature, humidity, light]])
    return prediction[0]

# 在智能网关中使用
def auto_control_light():
    from datetime import datetime
    now = datetime.now()

    hour = now.hour
    weekday = now.weekday()
    temperature = get_temperature()
    humidity = get_humidity()
    light = get_light_level()

    should_turn_on = predict_light_state(hour, weekday, temperature, humidity, light)

    if should_turn_on:
        mqtt_client.publish('home/light/living/control', 'ON')
    else:
        mqtt_client.publish('home/light/living/control', 'OFF')

10.4 系统监控和告警

// 系统健康监控
const nodemailer = require('nodemailer');

// 邮件配置
const transporter = nodemailer.createTransport({
  service: 'gmail',
  auth: {
    user: 'your_email@gmail.com',
    pass: 'your_password'
  }
});

// 监控设备在线状态
function monitorDevices() {
  setInterval(async () => {
    const devices = await getDevices();
    const now = Date.now();

    for (const device of devices) {
      const offlineTime = now - device.lastUpdate;

      // 设备超过5分钟未更新，发送告警
      if (offlineTime > 5 * 60 * 1000) {
        sendAlert(`设备离线告警: ${device.name} (${device.id})`);
      }
    }
  }, 60000);  // 每分钟检查一次
}

// 监控异常数据
function monitorAbnormalData() {
  mqttClient.on('message', (topic, message) => {
    if (topic.includes('temperature')) {
      const temp = parseFloat(message.toString());

      // 温度异常告警
      if (temp > 35 || temp < 0) {
        sendAlert(`温度异常: ${temp}°C`);
      }
    }

    if (topic.includes('humidity')) {
      const humidity = parseFloat(message.toString());

      // 湿度异常告警
      if (humidity > 80 || humidity < 20) {
        sendAlert(`湿度异常: ${humidity}%`);
      }
    }
  });
}

// 发送告警邮件
function sendAlert(message) {
  const mailOptions = {
    from: 'your_email@gmail.com',
    to: 'admin@example.com',
    subject: '智能家居系统告警',
    text: message
  };

  transporter.sendMail(mailOptions, (error, info) => {
    if (error) {
      console.log('发送告警邮件失败:', error);
    } else {
      console.log('告警邮件已发送:', info.response);
    }
  });
}

总结

通过本教程的学习，你已经掌握了：

✅ 系统架构设计 - 智能家居系统的整体架构 - 设备层、网关层、云端层、应用层的设计 - 通信协议的选择和应用

✅ 设备开发 - ESP8266/ESP32固件开发 - 智能灯光、温湿度监测、人体感应等设备实现 - MQTT通信协议的使用

✅ 网关开发 - 智能网关的核心功能 - 设备管理和状态监控 - 场景联动和规则引擎

✅ 应用开发 - React Native移动应用开发 - 设备控制界面设计 - 数据可视化实现

✅ 云端集成 - 阿里云IoT平台接入 - RESTful API设计 - 数据存储和分析

✅ 语音控制 - 天猫精灵接入 - 语音命令处理

✅ 系统安全 - 网络加密（HTTPS/TLS） - 身份认证（JWT） - 访问控制（RBAC）

实践项目

为了巩固所学知识，建议完成以下项目：

项目1：智能卧室系统

要求： - 实现智能灯光控制（亮度调节） - 温湿度监测和自动调节 - 智能窗帘控制 - 睡眠模式场景

项目2：智能安防系统

要求： - 门窗传感器监测 - 人体移动检测 - 摄像头监控（可选） - 异常情况告警

项目3：能耗管理系统

要求： - 实时能耗监测 - 历史数据分析 - 能耗报表生成 - 节能建议

进阶学习方向

技术深化

1. 边缘计算
2. 在网关端实现AI推理
3. 本地语音识别

4. 图像识别和分析

5. 大数据分析

6. 用户行为分析
7. 设备故障预测

8. 能耗优化建议

9. 区块链应用

10. 设备身份认证
11. 数据安全存储

12. 智能合约

13. 5G和NB-IoT

14. 低功耗广域网应用
15. 大规模设备连接
16. 实时数据传输

商业化方向

1. 产品化
2. 硬件设计和生产
3. 软件产品化

4. 用户体验优化

5. 平台化

6. 开放API接口
7. 第三方设备接入

8. 生态系统建设

9. 服务化

10. SaaS服务模式
11. 增值服务开发
12. 运维服务

常见问题解答（FAQ）

Q1：智能家居系统的成本如何？

A：成本取决于规模和功能： - 基础系统（3-5个设备）：500-1000元 - 中等系统（10-15个设备）：2000-5000元 - 完整系统（20+设备）：5000-10000元 - 可以从小规模开始，逐步扩展

Q2：如何选择通信协议？

A：根据应用场景选择： - Wi-Fi：适合需要高带宽的设备（摄像头、音响） - Zigbee：适合低功耗传感器和开关 - Bluetooth：适合近距离控制 - 建议使用多协议网关，支持不同设备

Q3：系统的可靠性如何保证？

A： - 使用稳定的硬件平台 - 实现设备离线检测和自动重连 - 本地网关提供离线控制能力 - 定期备份配置和数据 - 实施监控和告警机制

Q4：如何保护隐私和安全？

A： - 使用加密通信（TLS/SSL） - 实施强身份认证 - 定期更新固件和软件 - 限制外网访问 - 使用VPN进行远程访问

Q5：系统如何扩展？

A： - 采用模块化设计 - 使用标准通信协议 - 预留扩展接口 - 使用可扩展的云平台 - 支持第三方设备接入

学习资源

推荐书籍

1. 《物联网技术与应用》
2. 《智能家居系统设计与实现》
3. 《MQTT协议详解》
4. 《ESP32开发实战》

在线资源

1. Arduino官方文档：https://www.arduino.cc/
2. ESP32官方文档：https://docs.espressif.com/
3. MQTT.org：https://mqtt.org/
4. 阿里云IoT文档：https://help.aliyun.com/product/30520.html

开源项目

1. Home Assistant：https://www.home-assistant.io/
2. OpenHAB：https://www.openhab.org/
3. ESPHome：https://esphome.io/
4. Node-RED：https://nodered.org/

社区论坛

1. Arduino中文社区
2. ESP32中文社区
3. 智能家居DIY论坛
4. GitHub相关项目

下一步学习建议

完成本教程后，建议继续学习：

1. 可穿戴设备开发 - 学习智能手环、手表开发
2. 智能音箱开发技术 - 学习语音交互技术
3. MQTT协议详解 - 深入学习MQTT协议

参考资料

1. IEEE 802.11 Wi-Fi标准
2. Zigbee Alliance规范
3. MQTT v3.1.1协议规范
4. 阿里云IoT平台技术白皮书
5. 《智能家居系统安全白皮书》

---

版权声明：本教程内容仅供学习参考，实际项目应用请遵循相关安全规范和标准。

反馈与建议：如果你在学习过程中遇到问题或有改进建议，欢迎通过评论区反馈！

最后更新：2024-01-15