IoT新手速通：2025智能家居DIY成就感爆棚

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

// 定义引脚
#define RED_PIN 9
#define GREEN_PIN 10
#define BLUE_PIN 11
#define RX_PIN 0
#define TX_PIN 1

// 定义Wi-Fi信息
const char* ssid = "你的Wi-Fi名称";
const char* password = "你的Wi-Fi密码";

// 定义MQTT信息
const char* mqtt_server = "你的MQTT服务器地址";
const int mqtt_port = 1883;
const char* mqtt_client_id = "arduino_led";
const char* mqtt_topic_led = "home/led";
const char* mqtt_topic_brightness = "home/brightness";
const char* mqtt_topic_color = "home/color";

// 创建软件串口对象，用于与ESP8266通信
SoftwareSerial espSerial(RX_PIN, TX_PIN);

// 创建ESP8266WiFiClient对象
WiFiClient espClient;

// 创建PubSubClient对象
PubSubClient client(espClient);

// 定义变量
int ledState = 0; // 0: off, 1: on
int brightness = 255; // 0-255
int red = 255;
int green = 255;
int blue = 255;

void setup() {
  // 初始化串口通信
  Serial.begin(9600);
  espSerial.begin(9600);
  delay(1000);

  // 初始化LED引脚
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);

  // 设置MQTT服务器和回调函数
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(mqttCallback);

  // 连接到Wi-Fi网络
  connectToWiFi();

  // 连接到MQTT服务器
  connectToMQTT();

  // 初始化LED状态
  updateLED();
}

void loop() {
  // 检查MQTT连接状态，如果断开则重新连接
  if (!client.connected()) {
    connectToMQTT();
  }
  
  // 保持MQTT客户端运行
  client.loop();
}

// 连接到Wi-Fi网络
void connectToWiFi() {
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  // 连接到Wi-Fi网络
  WiFi.begin(ssid, password);

  // 等待连接成功
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

// 连接到MQTT服务器
void connectToMQTT() {
  // 等待连接成功
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    
    // 尝试连接到MQTT服务器
    if (client.connect(mqtt_client_id)) {
      Serial.println("connected");
      
      // 订阅MQTT主题
      client.subscribe(mqtt_topic_led);
      client.subscribe(mqtt_topic_brightness);
      client.subscribe(mqtt_topic_color);
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      
      // 等待5秒后重新尝试连接
      delay(5000);
    }
  }
}

// MQTT消息回调函数
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  
  // 将payload转换为字符串
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  Serial.println(message);
  
  // 处理接收到的消息
  if (strcmp(topic, mqtt_topic_led) == 0) {
    // 处理LED开关消息
    ledState = message.toInt();
    updateLED();
  } else if (strcmp(topic, mqtt_topic_brightness) == 0) {
    // 处理亮度调节消息
    brightness = message.toInt();
    updateLED();
  } else if (strcmp(topic, mqtt_topic_color) == 0) {
    // 处理颜色调节消息
    // 假设颜色消息格式为"R,G,B"，例如"255,0,0"表示红色
    int comma1 = message.indexOf(',');
    int comma2 = message.lastIndexOf(',');
    if (comma1 != -1 && comma2 != -1 && comma1 != comma2) {
      red = message.substring(0, comma1).toInt();
      green = message.substring(comma1 + 1, comma2).toInt();
      blue = message.substring(comma2 + 1).toInt();
      updateLED();
    }
  }
}

// 更新LED状态
void updateLED() {
  if (ledState == 1) {
    // 计算实际的RGB值（考虑亮度）
    int actualRed = map(brightness, 0, 255, 0, red);
    int actualGreen = map(brightness, 0, 255, 0, green);
    int actualBlue = map(brightness, 0, 255, 0, blue);
    
    // 设置LED颜色
    analogWrite(RED_PIN, actualRed);
    analogWrite(GREEN_PIN, actualGreen);
    analogWrite(BLUE_PIN, actualBlue);
  } else {
    // 关闭LED
    analogWrite(RED_PIN, 0);
    analogWrite(GREEN_PIN, 0);
    analogWrite(BLUE_PIN, 0);
  }
}

import paho.mqtt.client as mqtt
import time

# 定义MQTT服务器信息
mqtt_server = "mqtt.eclipseprojects.io"  # 公共MQTT服务器地址
mqtt_port = 1883  # MQTT服务器端口
mqtt_client_id = "python_mqtt_client"  # 客户端ID，应该是唯一的
mqtt_topic = "home/device1/status"  # 要订阅的主题

# 当连接到MQTT服务器时的回调函数
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connected to MQTT server successfully!")
        # 订阅主题
        client.subscribe(mqtt_topic)
    else:
        print(f"Failed to connect to MQTT server, return code: {rc}")

# 当接收到MQTT消息时的回调函数
def on_message(client, userdata, msg):
    print(f"Received message on topic '{msg.topic}': {msg.payload.decode()}")

# 创建MQTT客户端对象
client = mqtt.Client(client_id=mqtt_client_id)

# 设置回调函数
client.on_connect = on_connect
client.on_message = on_message

# 连接到MQTT服务器
print(f"Connecting to MQTT server at {mqtt_server}:{mqtt_port}...")
client.connect(mqtt_server, mqtt_port, 60)

# 启动MQTT客户端的网络循环
client.loop_start()

# 主循环，定期发布消息
try:
    while True:
        # 发布消息
        message = "Hello from Python MQTT client!"
        client.publish(mqtt_topic, message)
        print(f"Published message: {message}")
        
        # 等待5秒
        time.sleep(5)

except KeyboardInterrupt:
    # 当用户按下Ctrl+C时，停止MQTT客户端的网络循环并断开连接
    print("Disconnecting from MQTT server...")
    client.loop_stop()
    client.disconnect()
    print("Disconnected from MQTT server.")

import paho.mqtt.client as mqtt
import time
import random
import json

# 定义MQTT服务器信息
mqtt_server = "mqtt.eclipseprojects.io"
mqtt_port = 1883
mqtt_client_id = "iot_device_simulator"

sensor_data_topic = "home/sensor/data"  # 传感器数据主题
device_status_topic = "home/device/status"  # 设备状态主题
command_topic = "home/device/command"  # 命令主题

# 定义设备信息
device_id = "device_001"
location = "living_room"

# 设备状态
device_status = {
    "device_id": device_id,
    "location": location,
    "online": True,
    "battery_level": 100,
    "last_update": time.strftime("%Y-%m-%d %H:%M:%S")
}

# 当连接到MQTT服务器时的回调函数
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connected to MQTT server successfully!")
        # 订阅命令主题
        client.subscribe(command_topic)
        # 发布设备上线状态
        client.publish(device_status_topic, json.dumps(device_status))
    else:
        print(f"Failed to connect to MQTT server, return code: {rc}")

# 当接收到MQTT消息时的回调函数
def on_message(client, userdata, msg):
    print(f"Received message on topic '{msg.topic}': {msg.payload.decode()}")
    
    # 如果是命令主题，处理命令
    if msg.topic == command_topic:
        try:
            command = json.loads(msg.payload.decode())
            if command.get("device_id") == device_id or command.get("device_id") == "all":
                print(f"Processing command: {command}")
                # 这里可以根据命令类型执行相应的操作
                # 例如，命令设备发送最新数据、调整采样频率、重启设备等
        except json.JSONDecodeError:
            print("Invalid JSON format in command message.")

# 创建MQTT客户端对象
client = mqtt.Client(client_id=mqtt_client_id)

# 设置回调函数
client.on_connect = on_connect
client.on_message = on_message

# 连接到MQTT服务器
print(f"Connecting to MQTT server at {mqtt_server}:{mqtt_port}...")
client.connect(mqtt_server, mqtt_port, 60)

# 启动MQTT客户端的网络循环
client.loop_start()

# 主循环，模拟传感器数据收集和发送
try:
    while True:
        # 模拟传感器数据
        sensor_data = {
            "device_id": device_id,
            "location": location,
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
            "temperature": round(random.uniform(20.0, 25.0), 2),  # 模拟温度数据（20-25℃）
            "humidity": round(random.uniform(40.0, 60.0), 2),     # 模拟湿度数据（40-60%）
            "light": round(random.uniform(100, 1000), 0)          # 模拟光照数据（100-1000 lux）
        }
        
        # 发布传感器数据
        client.publish(sensor_data_topic, json.dumps(sensor_data))
        print(f"Published sensor data: {sensor_data}")
        
        # 更新设备状态
        device_status["last_update"] = time.strftime("%Y-%m-%d %H:%M:%S")
        device_status["battery_level"] = max(0, device_status["battery_level"] - 1)  # 模拟电池消耗
        
        # 如果电池电量低于20%，发布低电量警告
        if device_status["battery_level"] == 20:
            warning_message = {
                "device_id": device_id,
                "warning_type": "low_battery",
                "message": f"Battery level is low: {device_status['battery_level']}%",
                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
            }
            client.publish(device_status_topic, json.dumps(warning_message))
            print(f"Published warning message: {warning_message}")
        
        # 等待5秒
        time.sleep(5)

except KeyboardInterrupt:
    # 当用户按下Ctrl+C时，发布设备离线状态，然后停止MQTT客户端的网络循环并断开连接
    device_status["online"] = False
    device_status["last_update"] = time.strftime("%Y-%m-%d %H:%M:%S")
    client.publish(device_status_topic, json.dumps(device_status))
    
    print("Disconnecting from MQTT server...")
    client.loop_stop()
    client.disconnect()
    print("Disconnected from MQTT server.")

import paho.mqtt.client as mqtt
import time
import json
from datetime import datetime

# 定义MQTT服务器信息
mqtt_server = "mqtt.eclipseprojects.io"
mqtt_port = 1883
mqtt_client_id = "iot_control_system"

sensor_data_topic = "home/sensor/data"  # 传感器数据主题
device_status_topic = "home/device/status"  # 设备状态主题
command_topic = "home/device/command"  # 命令主题

# 存储设备数据的字典
devices_data = {}

# 当连接到MQTT服务器时的回调函数
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connected to MQTT server successfully!")
        # 订阅传感器数据主题和设备状态主题
        client.subscribe(sensor_data_topic)
        client.subscribe(device_status_topic)
    else:
        print(f"Failed to connect to MQTT server, return code: {rc}")

# 当接收到MQTT消息时的回调函数
def on_message(client, userdata, msg):
    print(f"Received message on topic '{msg.topic}': {msg.payload.decode()}")
    
    try:
        # 尝试将消息负载解析为JSON
        message_data = json.loads(msg.payload.decode())
        
        # 处理传感器数据
        if msg.topic == sensor_data_topic:
            device_id = message_data.get("device_id")
            if device_id:
                if device_id not in devices_data:
                    devices_data[device_id] = {}
                
                devices_data[device_id]["last_sensor_data"] = message_data
                devices_data[device_id]["last_sensor_update"] = datetime.now().isoformat()
                
                # 在这里可以添加数据分析和处理的逻辑
                # 例如，检查温度是否超过阈值、计算平均值、生成报表等
                temperature = message_data.get("temperature")
                if temperature and temperature > 28.0:
                    print(f"Warning: Temperature in device {device_id} is too high: {temperature}°C")
        
        # 处理设备状态
        elif msg.topic == device_status_topic:
            device_id = message_data.get("device_id")
            if device_id:
                if device_id not in devices_data:
                    devices_data[device_id] = {}
                
                devices_data[device_id]["last_status"] = message_data
                devices_data[device_id]["last_status_update"] = datetime.now().isoformat()
                
                # 检查设备是否离线或有警告
                online = message_data.get("online", True)
                if not online:
                    print(f"Warning: Device {device_id} is offline!")
                
                warning_type = message_data.get("warning_type")
                if warning_type:
                    print(f"Warning from device {device_id}: {warning_type} - {message_data.get('message')}")
        
    except json.JSONDecodeError:
        print("Invalid JSON format in message.")

# 向设备发送命令的函数
def send_command(device_id, command_type, parameters=None):
    command = {
        "command_id": f"cmd_{int(time.time())}",
        "device_id": device_id,
        "command_type": command_type,
        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
    }
    
    if parameters:
        command["parameters"] = parameters
    
    client.publish(command_topic, json.dumps(command))
    print(f"Sent command to device {device_id}: {command}")

# 创建MQTT客户端对象
client = mqtt.Client(client_id=mqtt_client_id)

# 设置回调函数
client.on_connect = on_connect
client.on_message = on_message

# 连接到MQTT服务器
print(f"Connecting to MQTT server at {mqtt_server}:{mqtt_port}...")
client.connect(mqtt_server, mqtt_port, 60)

# 启动MQTT客户端的网络循环
client.loop_start()

# 主循环，定期显示设备状态并发送测试命令
try:
    while True:
        print("\n--- Device Status Summary ---")
        for device_id, device_data in devices_data.items():
            print(f"Device ID: {device_id}")
            last_sensor_data = device_data.get("last_sensor_data")
            if last_sensor_data:
                print(f"  Last Sensor Data: {last_sensor_data}")
            last_status = device_data.get("last_status")
            if last_status:
                print(f"  Last Status: {last_status}")
        print("----------------------------\n")
        
        # 如果你想向某个设备发送命令，可以在这里调用send_command函数
        # 例如，send_command("device_001", "get_data")
        
        # 等待10秒
        time.sleep(10)

except KeyboardInterrupt:
    print("Disconnecting from MQTT server...")
    client.loop_stop()
    client.disconnect()
    print("Disconnected from MQTT server.")

pip install paho-mqtt

python mqtt_client.py

python iot_device_simulator.py

python iot_control_system.py