【花雕学编程】ESP32 DeepSeek 之智能家居 AI 边缘-云端协同计算
·
《Arduino 手册（思路与案例）》栏目介绍：
在电子制作与智能控制的应用领域，本栏目涵盖了丰富的内容，包括但不限于以下主题：Arduino BLDC、Arduino CNC、Arduino E-Ink、Arduino ESP32 SPP、Arduino FreeRTOS、Arduino FOC、Arduino GRBL、Arduino HTTP、Arduino HUB75、Arduino IoT Cloud、Arduino JSON、Arduino LCD、Arduino OLED、Arduino LVGL、Arduino PID、Arduino TFT，以及Arduino智能家居、智慧交通、月球基地、智慧校园和智慧农业等多个方面与领域。不仅探讨了这些技术的基础知识和应用领域，还提供了众多具体的参考案例，帮助读者更好地理解和运用Arduino平台进行创新项目。目前，本栏目已有近4000篇相关博客，旨在为广大电子爱好者和开发者提供全面的学习资源与实践指导。通过这些丰富的案例和思路，读者可以获取灵感，推动自己的创作与开发进程。
https://blog.csdn.net/weixin_41659040/category_12422453.html
ESP32 DeepSeek之智能家居 AI 边缘-云端协同计算
一、主要特点
边缘计算能力：
ESP32 DeepSeek支持在本地设备上进行数据处理，能够在边缘实时分析传感器数据，减少延迟，提升响应速度。这使得智能家居系统能够快速应对环境变化。
云端智能分析：
通过将数据上传至云端，系统可以利用云计算的强大能力进行深度数据分析、机器学习和模型训练，从而实现更复杂的智能决策。
高效的数据管理：
边缘设备负责实时处理和响应，而云端则进行数据的长期存储和分析，优化数据流转，提升资源利用效率。
动态资源调配：
系统能够根据实时需求动态调整边缘和云端的计算资源分配，确保高效性能，并能适应不同的负载情况。
安全性与隐私保护：
本地处理敏感数据，减少数据上传至云端的频率，从而降低隐私泄露的风险。同时，采用加密技术保障数据传输和存储的安全性。
二、应用场景
智能家居自动化：
通过边缘计算，智能家居系统能够实时监测环境变化（如温度、湿度、光照），并自动调节家居设备（如空调、灯光）以保持舒适的居住环境。
智能安防系统：
在安防领域，边缘计算可用于实时分析视频监控数据，识别异常行为并及时发出警报，而云端则进行长期数据存储和行为模式分析。
健康监测与管理：
对于老年人或慢性病患者，边缘设备可以实时监测健康指标（如心率、血压），并在云端进行数据分析，提供个性化的健康管理方案。
环境监测与控制：
系统可用于监测室内外环境数据，结合云端分析提供环境改善建议，如空气质量监测和自动通风控制。
智慧城市建设：
在智慧城市中，边缘-云端协同可以用于交通管理、公共设施监控等，实现实时数据共享与资源优化，提升城市管理效率。
三、注意事项
网络连接稳定性：
边缘和云端之间的连接依赖于稳定的网络环境，需确保网络可靠，避免因网络问题导致的数据传输中断。
数据同步与一致性：
需要确保边缘设备与云端之间的数据实时同步，避免因延迟导致的数据不一致，影响系统决策的准确性。
隐私与安全性：
在数据处理和传输过程中，需采取必要的安全措施，保护用户隐私，防止数据泄露及恶意攻击。
系统的可扩展性：
设计时需考虑系统的可扩展性，确保未来能够方便地添加新设备或功能，满足不断变化的用户需求。
用户体验设计：
在用户界面和交互设计上需注重用户体验，确保用户能够轻松操作和管理智能家居设备，提高满意度。
1、温度监测与云端上传
#include <WiFi.h>
#include <HTTPClient.h>
#include "DeepSeek.h"
#include <DHT.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
const char* serverUrl = "http://your-server.com/api/temperature"; // 云端API地址
#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
DeepSeek deepSeek;
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("连接中...");
}
Serial.println("已连接 WiFi");
dht.begin();
deepSeek.begin();
}
void loop() {
float temperature = dht.readTemperature();
Serial.print("当前温度: ");
Serial.println(temperature);
uploadTemperature(temperature);
delay(5000); // 每5秒上传一次数据
}
void uploadTemperature(float temperature) {
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
http.begin(serverUrl);
http.addHeader("Content-Type", "application/json");
String jsonData = "{\"temperature\":" + String(temperature) + "}";
int httpResponseCode = http.POST(jsonData);
if (httpResponseCode > 0) {
Serial.printf("HTTP响应码: %d\n", httpResponseCode);
} else {
Serial.printf("HTTP错误: %s\n", http.errorToString(httpResponseCode).c_str());
}
http.end();
} else {
Serial.println("WiFi未连接");
}
}
要点解读：
温度监测：使用DHT11传感器实时获取环境温度，确保系统能够监测环境变化。
Wi-Fi连接：ESP32连接到Wi-Fi网络，确保可以与云端进行数据交互。
数据上传：将温度数据以JSON格式上传到云端API，实现边缘计算与云端协同。
实时反馈：通过串口输出当前温度和HTTP响应状态，便于用户监控系统运行情况。
可扩展性：可以添加湿度监测、光照等功能，形成更全面的环境监控系统。
2、云端控制与设备状态反馈
#include <WiFi.h>
#include <HTTPClient.h>
#include "DeepSeek.h"
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
const char* serverUrl = "http://your-server.com/api/control"; // 云端控制API地址
DeepSeek deepSeek;
bool deviceState = false;
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("连接中...");
}
Serial.println("已连接 WiFi");
deepSeek.begin();
}
void loop() {
String command = deepSeek.listen();
if (command.length() > 0) {
controlDevice(command);
}
sendDeviceState();
delay(5000); // 每5秒更新一次状态
}
void controlDevice(String command) {
if (command == "打开设备") {
deviceState = true;
Serial.println("设备已打开");
} else if (command == "关闭设备") {
deviceState = false;
Serial.println("设备已关闭");
}
}
void sendDeviceState() {
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
http.begin(serverUrl);
http.addHeader("Content-Type", "application/json");
String jsonData = "{\"deviceState\":" + String(deviceState) + "}";
int httpResponseCode = http.POST(jsonData);
if (httpResponseCode > 0) {
Serial.printf("HTTP响应码: %d\n", httpResponseCode);
} else {
Serial.printf("HTTP错误: %s\n", http.errorToString(httpResponseCode).c_str());
}
http.end();
} else {
Serial.println("WiFi未连接");
}
}
要点解读：
命令接收：通过DeepSeek识别语音命令，实现对设备的控制，如打开或关闭设备。
Wi-Fi连接：保持与Wi-Fi的连接，确保能够向云端发送设备状态。
设备状态反馈：将设备当前状态上传至云端，实现状态同步和远程监控。
实时输出：通过串口输出设备状态和HTTP响应状态，便于用户监控。
扩展性强：可以增加更多控制命令和设备，形成更复杂的智能家居系统。
3、环境监测与云端分析
#include <WiFi.h>
#include <HTTPClient.h>
#include "DeepSeek.h"
#include <DHT.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
const char* serverUrl = "http://your-server.com/api/analyze"; // 云端分析API地址
#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
DeepSeek deepSeek;
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("连接中...");
}
Serial.println("已连接 WiFi");
dht.begin();
deepSeek.begin();
}
void loop() {
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();
Serial.print("当前温度: ");
Serial.println(temperature);
Serial.print("当前湿度: ");
Serial.println(humidity);
analyzeData(temperature, humidity);
delay(10000); // 每10秒分析一次数据
}
void analyzeData(float temperature, float humidity) {
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
http.begin(serverUrl);
http.addHeader("Content-Type", "application/json");
String jsonData = "{\"temperature\":" + String(temperature) + ",\"humidity\":" + String(humidity) + "}";
int httpResponseCode = http.POST(jsonData);
if (httpResponseCode > 0) {
Serial.printf("分析请求HTTP响应码: %d\n", httpResponseCode);
} else {
Serial.printf("分析请求HTTP错误: %s\n", http.errorToString(httpResponseCode).c_str());
}
http.end();
} else {
Serial.println("WiFi未连接");
}
}
要点解读：
环境监测：通过DHT11传感器监测环境的温度和湿度，为云端分析提供数据。
数据上传：将监测到的温度和湿度数据以JSON格式上传到云端进行分析。
Wi-Fi连接：确保设备能够与云端进行稳定的通信，实现数据传输。
实时反馈：通过串口输出温度和湿度的监测值，帮助用户了解环境变化。
分析能力：可以根据云端的分析结果，对设备进行调整或给出改进建议，提升智能家居体验。
4、智能照明与能耗优化系统
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Adafruit_TCS34725.h>
#include <BH1750.h>
// WiFi配置
const char* ssid = "你的WiFi名称";
const char* password = "你的WiFi密码";
// DeepSeek API配置
const char* deepseek_api_key = "你的DeepSeek API密钥";
const char* deepseek_api_url = "https://api.deepseek.com/v1/chat/completions";
// 传感器与设备
Adafruit_TCS34725 colorSensor = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
BH1750 lightMeter(0x23);
const int ledPin = 13;
int currentBrightness = 0;
// 用户偏好
struct UserPreference {
int preferredColorTemp; // 偏好色温(K)
int preferredBrightness; // 偏好亮度(%)
bool autoMode; // 自动模式
};
UserPreference user = {4500, 70, true};
void setup() {
Serial.begin(115200);
// 初始化传感器
if (!colorSensor.begin()) {
Serial.println("颜色传感器初始化失败");
while (1);
}
if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE)) {
Serial.println("光照传感器初始化失败");
while (1);
}
// 初始化LED控制引脚
pinMode(ledPin, OUTPUT);
analogWriteRange(100); // 设置PWM范围为0-100
// 连接WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("正在连接WiFi...");
}
Serial.println("WiFi已连接");
}
void loop() {
// 读取环境数据
uint16_t r, g, b, c;
colorSensor.getRawData(&r, &g, &b, &c);
float lux = colorSensor.calculateLux(r, g, b);
float colorTemp = colorSensor.calculateColorTemperature(r, g, b);
float ambientLight = lightMeter.readLightLevel();
Serial.print("环境光照: ");
Serial.print(ambientLight);
Serial.print(" lux, 色温: ");
Serial.print(colorTemp);
Serial.println(" K");
// 边缘计算：简单规则控制
if (!user.autoMode) {
// 手动模式：直接应用用户偏好
setLight(user.preferredBrightness, user.preferredColorTemp);
delay(5000);
return;
}
// 每小时执行一次云端协同计算
static unsigned long lastCloudSync = 0;
if (millis() - lastCloudSync > 3600000) {
// 云端协同：调用DeepSeek优化照明策略
optimizeLightingPolicy(ambientLight, colorTemp);
lastCloudSync = millis();
} else {
// 边缘计算：基于本地规则的实时调整
adjustLightingLocally(ambientLight, colorTemp);
}
delay(1000);
}
void setLight(int brightness, float colorTemp) {
// 此处应根据实际LED驱动电路实现亮度和色温控制
// 简化示例：仅控制亮度
currentBrightness = brightness;
analogWrite(ledPin, brightness);
Serial.print("设置灯光 - 亮度: ");
Serial.print(brightness);
Serial.print("%, 色温: ");
Serial.print(colorTemp);
Serial.println(" K");
}
void adjustLightingLocally(float ambientLight, float colorTemp) {
// 本地规则：根据环境光照调整灯光亮度
int targetBrightness = 100; // 默认最大亮度
if (ambientLight > 500) {
targetBrightness = 20; // 强光环境，低亮度
} else if (ambientLight > 200) {
targetBrightness = 50; // 中等光照，中等亮度
} else if (ambientLight > 50) {
targetBrightness = 80; // 弱光环境，高亮度
}
// 色温调整（简化）
float targetColorTemp = 4500; // 默认中性白
if (colorTemp < 3000) {
targetColorTemp = 5500; // 环境偏暖，使用冷白光平衡
} else if (colorTemp > 6000) {
targetColorTemp = 3500; // 环境偏冷，使用暖白光平衡
}
// 平滑过渡到新亮度
if (abs(targetBrightness - currentBrightness) > 5) {
setLight(targetBrightness, targetColorTemp);
}
}
void optimizeLightingPolicy(float ambientLight, float colorTemp) {
// 构建请求数据
String requestData = "{\"model\":\"deepseek-chat\",\"messages\":[";
requestData += "{\"role\":\"system\",\"content\":\"你是一个智能照明优化专家。根据环境光照数据、用户偏好和能耗数据，提供照明策略优化建议。\"},";
requestData += "{\"role\":\"user\",\"content\":\"当前环境光照为" + String(ambientLight) + "lux，色温为" + String(colorTemp) + "K。";
requestData += "用户偏好亮度为" + String(user.preferredBrightness) + "%，偏好色温为" + String(user.preferredColorTemp) + "K。";
requestData += "请分析并提供优化的照明策略，同时考虑能源效率。\"}]}";
// 发送请求到DeepSeek API
HTTPClient http;
http.begin(deepseek_api_url);
http.addHeader("Content-Type", "application/json");
http.addHeader("Authorization", "Bearer " + String(deepseek_api_key));
int httpResponseCode = http.POST(requestData);
String response = "";
if (httpResponseCode > 0) {
response = http.getString();
// 解析DeepSeek响应
DynamicJsonDocument doc(4096);
deserializeJson(doc, response);
String advice = doc["choices"][0]["message"]["content"].as<String>();
Serial.println("照明优化建议: " + advice);
// 提取建议中的亮度和色温值
// 实际应用中应使用更健壮的解析逻辑
if (advice.indexOf("亮度") != -1 && advice.indexOf("%") != -1) {
int brightnessStart = advice.indexOf("亮度") + 2;
int brightnessEnd = advice.indexOf("%", brightnessStart);
if (brightnessStart < brightnessEnd) {
String brightnessStr = advice.substring(brightnessStart, brightnessEnd);
int recommendedBrightness = brightnessStr.toInt();
if (recommendedBrightness > 0 && recommendedBrightness <= 100) {
user.preferredBrightness = recommendedBrightness;
setLight(recommendedBrightness, user.preferredColorTemp);
}
}
}
if (advice.indexOf("色温") != -1 && advice.indexOf("K") != -1) {
int tempStart = advice.indexOf("色温") + 2;
int tempEnd = advice.indexOf("K", tempStart);
if (tempStart < tempEnd) {
String tempStr = advice.substring(tempStart, tempEnd);
int recommendedTemp = tempStr.toInt();
if (recommendedTemp > 2000 && recommendedTemp <= 7000) {
user.preferredColorTemp = recommendedTemp;
setLight(user.preferredBrightness, recommendedTemp);
}
}
}
} else {
Serial.print("调用DeepSeek API失败，错误代码: ");
Serial.println(httpResponseCode);
}
http.end();
}
5、智能温控与能源管理系统
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <DHT.h>
#include <Adafruit_Sensor.h>
// WiFi配置
const char* ssid = "你的WiFi名称";
const char* password = "你的WiFi密码";
// DeepSeek API配置
const char* deepseek_api_key = "你的DeepSeek API密钥";
const char* deepseek_api_url = "https://api.deepseek.com/v1/chat/completions";
// DHT传感器配置
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
// 温控设备
const int heaterPin = 12;
const int coolerPin = 13;
const int fanPin = 14;
// 温度数据历史
float temperatureHistory[24]; // 存储24小时的温度数据
int historyIndex = 0;
// 用户偏好
struct UserPreference {
float targetTemperature; // 目标温度
float comfortRange; // 舒适范围(±)
bool ecoMode; // 节能模式
bool homeOccupied; // 是否有人在家
};
UserPreference user = {24.0, 1.0, true, true};
void setup() {
Serial.begin(115200);
// 初始化DHT传感器
if (!dht.begin()) {
Serial.println("DHT传感器初始化失败");
while (1);
}
// 初始化温控设备引脚
pinMode(heaterPin, OUTPUT);
pinMode(coolerPin, OUTPUT);
pinMode(fanPin, OUTPUT);
// 初始化为关闭状态
digitalWrite(heaterPin, LOW);
digitalWrite(coolerPin, LOW);
digitalWrite(fanPin, LOW);
// 初始化温度历史
for (int i = 0; i < 24; i++) {
temperatureHistory[i] = 24.0; // 默认24°C
}
// 连接WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("正在连接WiFi...");
}
Serial.println("WiFi已连接");
}
void loop() {
// 读取当前温度和湿度
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();
// 检查数据有效性
if (isnan(temperature) || isnan(humidity)) {
Serial.println("读取传感器数据失败");
delay(2000);
return;
}
// 更新温度历史
temperatureHistory[historyIndex] = temperature;
historyIndex = (historyIndex + 1) % 24;
Serial.print("当前温度: ");
Serial.print(temperature);
Serial.print("°C, 湿度: ");
Serial.print(humidity);
Serial.println("%");
// 边缘计算：实时温度调节
adjustTemperature(temperature);
// 每天执行一次云端协同计算
static unsigned long lastCloudSync = 0;
if (millis() - lastCloudSync > 86400000) { // 24小时
// 云端协同：优化温控策略
optimizeTemperaturePolicy();
lastCloudSync = millis();
}
delay(60000); // 每分钟检查一次
}
void adjustTemperature(float currentTemp) {
// 基于当前温度和用户偏好进行实时调节
float lowerBound = user.targetTemperature - user.comfortRange;
float upperBound = user.targetTemperature + user.comfortRange;
// 关闭所有设备
digitalWrite(heaterPin, LOW);
digitalWrite(coolerPin, LOW);
digitalWrite(fanPin, LOW);
// 根据温度调节
if (currentTemp < lowerBound) {
// 需要加热
digitalWrite(heaterPin, HIGH);
Serial.println("启动加热器");
} else if (currentTemp > upperBound) {
// 需要降温
digitalWrite(coolerPin, HIGH);
Serial.println("启动制冷器");
} else {
// 温度在舒适范围内
if (user.ecoMode) {
// 节能模式：仅保持风扇运行
digitalWrite(fanPin, HIGH);
Serial.println("仅运行风扇");
}
Serial.println("温度在舒适范围内");
}
}
void optimizeTemperaturePolicy() {
// 构建24小时温度历史字符串
String historyStr = "";
for (int i = 0; i < 24; i++) {
historyStr += String(temperatureHistory[i]) + ",";
}
historyStr.remove(historyStr.length() - 1); // 移除最后一个逗号
// 构建请求数据
String requestData = "{\"model\":\"deepseek-chat\",\"messages\":[";
requestData += "{\"role\":\"system\",\"content\":\"你是一个智能温控专家。根据历史温度数据、用户偏好和能源价格，提供最优的温控策略。\"},";
requestData += "{\"role\":\"user\",\"content\":\"过去24小时的温度数据为: " + historyStr + ". 用户目标温度为" + String(user.targetTemperature) + "°C，";
requestData += "舒适范围为±" + String(user.comfortRange) + "°C，节能模式为" + String(user.ecoMode ? "开启" : "关闭") + "，";
requestData += "当前家中" + String(user.homeOccupied ? "有人" : "无人" + "。请分析并提供优化的温控策略，包括目标温度调整建议和设备运行时间优化。\"}]}";
// 发送请求到DeepSeek API
HTTPClient http;
http.begin(deepseek_api_url);
http.addHeader("Content-Type", "application/json");
http.addHeader("Authorization", "Bearer " + String(deepseek_api_key));
int httpResponseCode = http.POST(requestData);
String response = "";
if (httpResponseCode > 0) {
response = http.getString();
// 解析DeepSeek响应
DynamicJsonDocument doc(4096);
deserializeJson(doc, response);
String advice = doc["choices"][0]["message"]["content"].as<String>();
Serial.println("温控优化建议: " + advice);
// 提取建议中的目标温度值
// 实际应用中应使用更健壮的解析逻辑
if (advice.indexOf("目标温度") != -1 && advice.indexOf("°C") != -1) {
int tempStart = advice.indexOf("目标温度") + 4;
int tempEnd = advice.indexOf("°C", tempStart);
if (tempStart < tempEnd) {
String tempStr = advice.substring(tempStart, tempEnd);
float recommendedTemp = tempStr.toFloat();
if (recommendedTemp > 16.0 && recommendedTemp <= 30.0) {
user.targetTemperature = recommendedTemp;
Serial.print("更新目标温度为: ");
Serial.print(user.targetTemperature);
Serial.println("°C");
}
}
}
// 检查是否建议调整节能模式
if (advice.indexOf("开启节能模式") != -1) {
user.ecoMode = true;
Serial.println("已开启节能模式");
} else if (advice.indexOf("关闭节能模式") != -1) {
user.ecoMode = false;
Serial.println("已关闭节能模式");
}
} else {
Serial.print("调用DeepSeek API失败，错误代码: ");
Serial.println(httpResponseCode);
}
http.end();
}
6、智能安防与异常检测系统
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include "esp_camera.h"
#include <Adafruit_NeoPixel.h>
// WiFi配置
const char* ssid = "你的WiFi名称";
const char* password = "你的WiFi密码";
// DeepSeek API配置
const char* deepseek_api_key = "你的DeepSeek API密钥";
const char* deepseek_api_url = "https://api.deepseek.com/v1/chat/completions";
// 摄像头配置（ESP32-CAM）
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27
#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22
// 报警设备
#define LED_PIN 13
#define LED_COUNT 1
Adafruit_NeoPixel pixels(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
const int buzzerPin = 12;
// 安防状态
struct SecurityStatus {
bool armed; // 布防状态
bool motionDetected; // 检测到移动
bool alertTriggered; // 警报触发
int alertLevel; // 警报级别(1-3)
};
SecurityStatus security = {false, false, false, 0};
// 异常事件历史
String eventHistory[10];
int eventIndex = 0;
void setup() {
Serial.begin(115200);
// 初始化摄像头
camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;
config.frame_size = FRAMESIZE_SVGA; // 800x600
config.jpeg_quality = 12;
config.fb_count = 1;
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("摄像头初始化失败，错误: 0x%x\n", err);
while (1);
}
// 初始化报警设备
pixels.begin();
pixels.clear();
pinMode(buzzerPin, OUTPUT);
// 连接WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("正在连接WiFi...");
}
Serial.println("WiFi已连接");
}
void loop() {
// 仅在布防状态下进行监控
if (!security.armed) {
delay(5000);
return;
}
// 边缘计算：移动检测
bool motion = detectMotion();
if (motion) {
security.motionDetected = true;
Serial.println("检测到移动！");
// 捕获图像
camera_fb_t *fb = esp_camera_fb_get();
if (!fb) {
Serial.println("获取图像失败");
security.motionDetected = false;
delay(2000);
return;
}
// 边缘计算：初步图像分析（简化）
bool potentialThreat = analyzeImageLocally(fb);
if (potentialThreat) {
// 云端协同：调用DeepSeek进行详细分析
security.alertLevel = 2;
analyzeImageWithDeepSeek(fb);
} else {
security.motionDetected = false;
security.alertLevel = 1;
recordEvent("检测到轻微移动，无潜在威胁");
}
esp_camera_fb_return(fb);
} else {
security.motionDetected = false;
if (security.alertTriggered) {
// 警报解除
security.alertTriggered = false;
security.alertLevel = 0;
stopAlert();
recordEvent("警报解除");
}
}
delay(1000);
}
bool detectMotion() {
// 实际应用中应实现基于帧差的移动检测算法
// 简化示例：随机返回移动状态
return (random(0, 100) < 5); // 5%概率检测到移动
}
bool analyzeImageLocally(camera_fb_t *fb) {
// 边缘端简单图像分析（如亮度、颜色分析）
// 实际应用中应实现基于OpenCV或TensorFlow Lite的轻量级模型
// 简化示例：基于图像平均亮度判断
uint32_t sum = 0;
for (size_t i = 0; i < fb->len; i++) {
sum += fb->buf[i];
}
uint32_t avg = sum / fb->len;
// 如果平均亮度高于阈值，可能有异常（如强光、火焰）
return (avg > 180);
}
void analyzeImageWithDeepSeek(camera_fb_t *fb) {
// 将图像转换为Base64编码（仅发送部分数据以节省资源）
size_t encodedSize = fb->len * 4 / 3 + 4;
char *base64Image = (char *)malloc(encodedSize);
if (!base64Image) {
Serial.println("内存分配失败");
return;
}
// 简化版Base64编码（实际应用中应使用完整实现）
size_t encodedLength = 0;
// base64_encode(fb->buf, fb->len, base64Image, &encodedLength);
// 构建请求数据
String requestData = "{\"model\":\"deepseek-vision\",\"messages\":[";
requestData += "{\"role\":\"system\",\"content\":\"你是一个智能安防分析专家。分析监控图像，检测潜在威胁（如人、动物、火灾、烟雾等），并评估风险等级。\"},";
requestData += "{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"检测到异常活动，请分析此图像是否存在安全威胁。\"},";
requestData += "{\"type\":\"image_url\",\"image_url\":{\"url\":\"data:image/jpeg;base64," + String(base64Image) + "\"}}]}]}";
// 发送请求到DeepSeek API
HTTPClient http;
http.begin(deepseek_api_url);
http.addHeader("Content-Type", "application/json");
http.addHeader("Authorization", "Bearer " + String(deepseek_api_key));
int httpResponseCode = http.POST(requestData);
String response = "";
if (httpResponseCode > 0) {
response = http.getString();
// 解析DeepSeek响应
DynamicJsonDocument doc(8192);
deserializeJson(doc, response);
String analysis = doc["choices"][0]["message"]["content"].as<String>();
Serial.println("安全分析结果: " + analysis);
// 基于分析结果决定是否触发警报
if (analysis.indexOf("威胁") != -1 || analysis.indexOf("危险") != -1 ||
analysis.indexOf("可疑") != -1 || analysis.indexOf("入侵") != -1) {
security.alertTriggered = true;
security.alertLevel = 3;
triggerAlert(analysis);
recordEvent("检测到安全威胁: " + analysis);
} else {
security.alertLevel = 1;
recordEvent("检测到活动: " + analysis);
}
} else {
Serial.print("调用DeepSeek API失败，错误代码: ");
Serial.println(httpResponseCode);
// API调用失败时，保守起见触发警报
security.alertTriggered = true;
security.alertLevel = 2;
triggerAlert("无法获取云端分析结果，可能存在安全风险");
recordEvent("API调用失败，触发中级警报");
}
http.end();
free(base64Image);
}
void triggerAlert(String message) {
Serial.println("触发警报: " + message);
// 根据警报级别设置不同的报警方式
if (security.alertLevel == 3) {
// 高级警报：声光报警
pixels.setPixelColor(0, pixels.Color(255, 0, 0)); // 红色
pixels.show();
for (int i = 0; i < 10; i++) {
digitalWrite(buzzerPin, HIGH);
delay(500);
digitalWrite(buzzerPin, LOW);
delay(500);
}
// 此处可添加发送短信或推送通知的代码
} else if (security.alertLevel == 2) {
// 中级警报：仅灯光报警
pixels.setPixelColor(0, pixels.Color(255, 165, 0)); // 橙色
pixels.show();
delay(5000);
} else {
// 低级警报：仅记录
pixels.setPixelColor(0, pixels.Color(0, 0, 255)); // 蓝色
pixels.show();
delay(2000);
}
pixels.clear();
pixels.show();
}
void stopAlert() {
pixels.clear();
pixels.show();
digitalWrite(buzzerPin, LOW);
}
void recordEvent(String event) {
// 记录事件到历史
eventHistory[eventIndex] = "[" + String(millis() / 1000) + "] " + event;
eventIndex = (eventIndex + 1) % 10;
// 打印事件历史
Serial.println("事件历史:");
for (int i = 0; i < 10; i++) {
int idx = (eventIndex + i) % 10;
if (!eventHistory[idx].isEmpty()) {
Serial.println(eventHistory[idx]);
}
}
}
要点解读
边缘 - 云端分工协作
边缘端快速响应：案例 1 中边缘端根据环境光照实时调整灯光亮度，案例 3 中边缘端快速检测移动并进行初步图像分析
云端深度分析：案例 1 中云端定期优化照明策略，案例 3 中云端对可疑图像进行详细安全分析
协同决策：案例 2 中边缘端实时调节温度，云端基于历史数据优化温控策略
数据处理与传输优化
数据压缩：图像数据通过降采样和 Base64 编码减少传输量
选择性上传：仅在检测到异常时上传数据（如案例 3 中检测到移动后才调用云端分析）
本地缓存：案例 2 中存储 24 小时温度数据，减少云端依赖
智能反馈与自动化控制
规则引擎：案例 1 和案例 2 中边缘端基于预设规则进行实时控制
AI 增强决策：云端 AI 分析提供优化建议，如案例 1 中的光照策略优化和案例 2 中的温度调节建议
分级响应：案例 3 根据威胁级别触发不同强度的警报
可靠性与容错设计
本地优先原则：边缘端在网络中断时仍能维持基本功能（如案例 2 中温度调节）
异常处理：完善的错误捕获机制，确保传感器初始化和网络通信稳定
降级策略：案例 3 中云端 API 调用失败时触发中级警报，保证系统安全性
能效优化与资源管理
采样频率控制：根据需求调整数据采集频率，如案例 1 中边缘端每秒检测光照，云端每小时优化策略
休眠模式：非布防状态下案例 3 的摄像头处于低功耗状态
动态资源分配：根据任务复杂度分配计算资源，复杂任务才调用云端
扩展建议
多设备联动：实现不同智能设备之间的协同工作，如温度调节与通风系统联动
用户行为学习：通过机器学习分析用户习惯，自动调整设备参数
预测性维护：基于设备状态数据预测潜在故障，提前提醒用户
隐私保护：在边缘端进行数据匿名化处理，仅上传必要信息到云端
注意，以上案例只是为了拓展思路，仅供参考。它们可能有错误、不适用或者无法编译。您的硬件平台、使用场景和Arduino版本可能影响使用方法的选择。实际编程时，您要根据自己的硬件配置、使用场景和具体需求进行调整，并多次实际测试。您还要正确连接硬件，了解所用传感器和设备的规范和特性。涉及硬件操作的代码，您要在使用前确认引脚和电平等参数的正确性和安全性。
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
28
0- 0
已为社区贡献16条内容
所有评论(0)