基于STM32的物联网系统设计

一、系统总体架构

1.1 物联网系统分层架构

┌─────────────────────────────────────────────────────────────┐
│                    应用层 (Application Layer)              │
├─────────────────────────────────────────────────────────────┤
│  • 智能家居控制  • 工业设备监控  • 环境监测平台  • 农业物联网 │
│  • 智慧医疗终端  • 能源管理系统  • 资产追踪平台  • 车联网   │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│                    平台层 (Platform Layer)               │
├─────────────────────────────────────────────────────────────┤
│  • 设备管理      • 数据存储      • 规则引擎      • 可视化   │
│  • 告警通知      • 固件升级(OTA)  • 权限控制      • API服务  │
│  • 阿里云IoT     • 华为云IoT     • 腾讯云IoT     • AWS IoT │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│                    网络层 (Network Layer)                │
├─────────────────────────────────────────────────────────────┤
│  • WiFi(ESP8266/ESP32)  • 蜂窝网络(4G Cat.1/NB-IoT)    │
│  • LoRa/LoRaWAN        • ZigBee/Thread    • Bluetooth 5.0 │
│  • Ethernet            • 卫星通信        • 电力载波PLC      │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│                    感知层 (Perception Layer)             │
├─────────────────────────────────────────────────────────────┤
│  STM32微控制器 (F1/F4/G0/H7系列)                        │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐      │
│  │ 传感器  │ │ 执行器  │ │ 存储器  │ │ 通信模块│      │
│  │ 温度湿度│ │ 继电器  │ │ Flash   │ │ WiFi    │      │
│  │ 光照PM2.5│ │ 电机驱动│ │ EEPROM  │ │ 4G/NB  │      │
│  │ 人体红外│ │ LED控制 │ │ SD卡    │ │ LoRa    │      │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘      │
└─────────────────────────────────────────────────────────────┘

1.2 典型应用场景

应用领域	具体场景	STM32系列	通信方式	核心功能
智能家居	智能门锁、温控器、照明	STM32F103/F407	WiFi/蓝牙/ZigBee	远程控制、场景联动
工业物联网	设备监控、预测性维护	STM32H743/G474	以太网/4G/5G	数据采集、边缘计算
智慧农业	温室监控、精准灌溉	STM32L476/G070	LoRa/NB-IoT	环境监测、自动控制
智慧能源	智能电表、充电桩	STM32F407/G474	PLC/4G	计量采集、负荷控制
智慧医疗	体征监测、药物管理	STM32WB55/L476	蓝牙5.0/WiFi	生理参数监测、预警
智慧城市	路灯控制、环境监测	STM32F103/L476	NB-IoT/LoRa	数据采集、远程控制

二、硬件系统设计

2.1 核心控制器选型

/* STM32系列选型指南 */
typedef struct {
    char series[20];        // 系列名称
    uint32_t max_freq;      // 最大主频(MHz)
    uint16_t flash_kb;      // Flash大小(KB)
    uint16_t ram_kb;        // RAM大小(KB)
    uint8_t adc_bits;       // ADC位数
    uint8_t dac_bits;       // DAC位数
    uint8_t uart_num;        // UART数量
    uint8_t spi_num;         // SPI数量
    uint8_t i2c_num;        // I2C数量
    uint8_t can_num;         // CAN数量
    float power_consumption; // 功耗(mA@Run)
    float cost_usd;         // 成本(美元)
    char applications[100];  // 适用应用
} STM32_Series;

STM32_Series stm32_series[] = {
    {"STM32F030", 48, 64, 8, 12, 0, 2, 2, 2, 1, 0, 15.0, 0.5, "家电控制、简单传感"},
    {"STM32F103", 72, 512, 64, 12, 0, 5, 3, 2, 2, 0, 25.0, 1.2, "工业控制、消费电子"},
    {"STM32F407", 168, 1024, 192, 12, 12, 8, 6, 3, 3, 2, 45.0, 3.5, "图像处理、复杂控制"},
    {"STM32L476", 80, 1024, 128, 12, 12, 6, 5, 3, 3, 2, 2.5, 2.8, "低功耗IoT、可穿戴"},
    {"STM32G474", 170, 512, 128, 16, 12, 5, 4, 3, 3, 3, 35.0, 2.2, "数字电源、电机控制"},
    {"STM32H743", 400, 2048, 864, 16, 12, 8, 6, 6, 4, 2, 85.0, 8.5, "边缘计算、AI推理"}
};

// 物联网设备推荐配置
typedef struct {
    char device_type[30];   // 设备类型
    char recommended_mcu[20]; // 推荐MCU
    char communication[30];  // 通信方式
    char sensors[100];       // 传感器配置
    uint16_t battery_life;   // 电池寿命(天)
    float cost_total;        // 总成本(美元)
} IoT_Device_Config;

IoT_Device_Config device_configs[] = {
    {"智能温湿度传感器", "STM32L476RG", "LoRaWAN", "SHT30+BMP280", 365, 15.0},
    {"智能电表", "STM32G474RE", "NB-IoT", "计量芯片+继电器", 1825, 25.0},
    {"工业网关", "STM32H743II", "以太网+4G", "多协议转换", 0, 85.0},
    {"智能门锁", "STM32WB55CE", "蓝牙5.0+WiFi", "指纹+RFID+键盘", 180, 35.0},
    {"农业气象站", "STM32F407VG", "4G Cat.1", "多合一气象传感器", 90, 120.0}
};

2.2 物联网硬件模块清单

模块类别	型号/规格	接口方式	功耗	功能说明	成本
主控板	STM32F407VET6核心板	-	150mA@168MHz	系统主控	$8.5
WiFi模块	ESP8266-01S	UART	80mA@TX	WiFi通信	$2.5
4G模块	EC200S-CN	USB/UART	300mA@4G	4G Cat.1通信	$15.0
LoRa模块	SX1278 433MHz	SPI	120mA@TX	远距离低功耗通信	$6.0
NB-IoT模块	BC95-B5	UART	200mA@TX	窄带物联网	$12.0
传感器集	SHT30温湿度	I2C	1mA	温湿度监测	$3.5
光照传感器	BH1750	I2C	0.5mA	光照强度检测	$2.0
气体传感器	MQ-135	ADC	150mA@加热	空气质量检测	$4.0
存储模块	W25Q128 Flash	SPI	15mA	数据存储	$2.5
电源管理	TP4056+18650	-	-	锂电池管理	$5.0
继电器模块	5V/10A	GPIO	70mA@吸合	设备控制	$1.5

三、软件系统架构

3.1 物联网软件架构

/* 物联网设备软件架构 */
#include "stm32f4xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "lwip/api.h"
#include "mqtt_client.h"

// 系统任务定义
#define TASK_PRIORITY_SENSOR     5    // 传感器采集任务
#define TASK_PRIORITY_NETWORK    4    // 网络通信任务
#define TASK_PRIORITY_CONTROL    3    // 设备控制任务
#define TASK_PRIORITY_STORAGE   2    // 数据存储任务
#define TASK_PRIORITY_MONITOR   1    // 系统监控任务

// 任务堆栈大小
#define STACK_SIZE_SENSOR       4096
#define STACK_SIZE_NETWORK      8192
#define STACK_SIZE_CONTROL      2048
#define STACK_SIZE_STORAGE     3072
#define STACK_SIZE_MONITOR     1024

// 消息队列定义
QueueHandle_t xSensorQueue;        // 传感器数据队列
QueueHandle_t xControlQueue;       // 控制指令队列
QueueHandle_t xNetworkQueue;       // 网络数据队列
SemaphoreHandle_t xI2CMutex;     // I2C总线互斥锁
SemaphoreHandle_t xSPIMutex;      // SPI总线互斥锁

// 设备状态结构
typedef struct {
    uint32_t device_id;         // 设备唯一标识
    uint8_t device_type;        // 设备类型
    uint8_t firmware_version;   // 固件版本
    uint8_t online_status;      // 在线状态
    uint8_t battery_level;      // 电池电量
    uint32_t uptime;           // 运行时间
    uint32_t last_heartbeat;   // 最后心跳时间
    uint8_t error_code;        // 错误代码
} DeviceStatus;

// 传感器数据结构
typedef struct {
    uint32_t timestamp;        // 时间戳
    float temperature;          // 温度(°C)
    float humidity;             // 湿度(%)
    float pressure;            // 气压(hPa)
    float illuminance;          // 光照强度(lux)
    float air_quality;         // 空气质量(PM2.5)
    uint8_t sensor_status;     // 传感器状态
} SensorData;

// 控制指令结构
typedef struct {
    uint32_t command_id;       // 指令ID
    uint8_t command_type;      // 指令类型
    uint8_t target_device;     // 目标设备
    uint8_t action;            // 动作
    uint32_t parameter;        // 参数
    uint8_t priority;          // 优先级
} ControlCommand;

// 全局变量
DeviceStatus device_status;
SensorData current_sensor_data;

3.2 主程序框架

/* 物联网设备主程序 */
int main(void) {
    // HAL库初始化
    HAL_Init();
    
    // 系统时钟配置
    SystemClock_Config();
    
    // 硬件初始化
    hardware_init();
    
    // 外设初始化
    peripherals_init();
    
    // 网络初始化
    network_init();
    
    // 文件系统初始化
    filesystem_init();
    
    // 创建设备标识
    generate_device_id();
    
    // 加载配置参数
    load_device_config();
    
    // 创建FreeRTOS任务
    xTaskCreate(sensor_task, "Sensor", STACK_SIZE_SENSOR, 
                NULL, TASK_PRIORITY_SENSOR, NULL);
    
    xTaskCreate(network_task, "Network", STACK_SIZE_NETWORK,
                NULL, TASK_PRIORITY_NETWORK, NULL);
    
    xTaskCreate(control_task, "Control", STACK_SIZE_CONTROL,
                NULL, TASK_PRIORITY_CONTROL, NULL);
    
    xTaskCreate(storage_task, "Storage", STACK_SIZE_STORAGE,
                NULL, TASK_PRIORITY_STORAGE, NULL);
    
    xTaskCreate(monitor_task, "Monitor", STACK_SIZE_MONITOR,
                NULL, TASK_PRIORITY_MONITOR, NULL);
    
    // 创建消息队列
    xSensorQueue = xQueueCreate(20, sizeof(SensorData));
    xControlQueue = xQueueCreate(10, sizeof(ControlCommand));
    xNetworkQueue = xQueueCreate(30, sizeof(NetworkMessage));
    
    // 创建互斥锁
    xI2CMutex = xSemaphoreCreateMutex();
    xSPIMutex = xSemaphoreCreateMutex();
    
    // 启动调度器
    vTaskStartScheduler();
    
    // 不应该执行到这里
    while (1) {
        system_error_handler();
    }
}

四、传感器数据采集

4.1 多传感器管理

/* 传感器采集任务 */
void sensor_task(void *pvParameters) {
    SensorData sensor_data;
    uint32_t last_collection_time = 0;
    uint32_t collection_interval = 60000;  // 60秒采集一次
    
    // 初始化传感器
    init_temperature_sensor();   // 温度传感器
    init_humidity_sensor();      // 湿度传感器
    init_pressure_sensor();     // 气压传感器
    init_light_sensor();        // 光照传感器
    init_air_quality_sensor(); // 空气质量传感器
    
    while (1) {
        uint32_t current_time = HAL_GetTick();
        
        // 定时采集传感器数据
        if (current_time - last_collection_time >= collection_interval) {
            // 采集温度数据
            if (xSemaphoreTake(xI2CMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
                sensor_data.temperature = read_temperature();
                sensor_data.humidity = read_humidity();
                sensor_data.pressure = read_pressure();
                sensor_data.illuminance = read_illuminance();
                sensor_data.air_quality = read_air_quality();
                sensor_data.timestamp = get_system_timestamp();
                sensor_data.sensor_status = 0x01;  // 传感器正常
                
                xSemaphoreGive(xI2CMutex);
                
                // 发送数据到队列
                if (xQueueSend(xSensorQueue, &sensor_data, pdMS_TO_TICKS(100)) != pdPASS) {
                    printf("Sensor queue full!\n");
                }
                
                // 更新设备状态
                device_status.uptime = current_time / 1000;
                device_status.last_heartbeat = current_time;
                
                printf("Sensor data collected: T=%.1f°C, H=%.1f%%, P=%.1fhPa\n",
                       sensor_data.temperature, sensor_data.humidity, sensor_data.pressure);
            }
            
            last_collection_time = current_time;
        }
        
        // 传感器自诊断
        perform_sensor_diagnostics();
        
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

/* 温度传感器驱动 (SHT30) */
float read_temperature(void) {
    uint8_t cmd[2] = {0x2C, 0x06};  // 高精度测量命令
    uint8_t data[6];
    float temperature;
    
    // 发送测量命令
    HAL_I2C_Master_Transmit(&hi2c1, SHT30_ADDR << 1, cmd, 2, 100);
    HAL_Delay(15);  // 等待测量完成
    
    // 读取数据
    HAL_I2C_Master_Receive(&hi2c1, SHT30_ADDR << 1, data, 6, 100);
    
    // 转换温度数据
    uint16_t temp_raw = (data[0] << 8) | data[1];
    temperature = -45.0 + 175.0 * temp_raw / 65535.0;
    
    return temperature;
}

/* 光照传感器驱动 (BH1750) */
float read_illuminance(void) {
    uint8_t cmd = 0x10;  // 连续高分辨率模式
    uint8_t data[2];
    float illuminance;
    
    // 发送测量命令
    HAL_I2C_Master_Transmit(&hi2c1, BH1750_ADDR << 1, &cmd, 1, 100);
    HAL_Delay(180);  // 等待测量完成
    
    // 读取数据
    HAL_I2C_Master_Receive(&hi2c1, BH1750_ADDR << 1, data, 2, 100);
    
    // 转换光照数据
    uint16_t lux_raw = (data[0] << 8) | data[1];
    illuminance = lux_raw / 1.2;
    
    return illuminance;
}

参考代码 基于STM32的物联网系统设计 www.youwenfan.com/contentcst/133656.html

五、网络通信模块

5.1 MQTT物联网协议

/* MQTT客户端实现 */
#include "mqtt_client.h"

// MQTT连接配置
typedef struct {
    char broker_address[50];   // 服务器地址
    uint16_t broker_port;      // 服务器端口
    char client_id[30];       // 客户端ID
    char username[20];        // 用户名
    char password[20];        // 密码
    uint16_t keep_alive;      // 保活时间
    uint8_t clean_session;    // 清除会话
    uint8_t use_tls;         // 使用TLS加密
} MQTT_Config;

// MQTT主题定义
#define MQTT_TOPIC_TELEMETRY   "devices/%s/telemetry"
#define MQTT_TOPIC_ATTRIBUTES  "devices/%s/attributes"
#define MQTT_TOPIC_COMMANDS   "devices/%s/commands"
#define MQTT_TOPIC_RESPONSE   "devices/%s/response"
#define MQTT_TOPIC_FIRMWARE   "devices/%s/firmware"

// MQTT消息结构
typedef struct {
    char topic[100];         // 主题
    uint8_t qos;            // 服务质量
    uint8_t retained;        // 保留消息
    uint8_t *payload;        // 载荷数据
    uint16_t payload_len;    // 载荷长度
} MQTT_Message;

// MQTT客户端状态
typedef enum {
    MQTT_DISCONNECTED,
    MQTT_CONNECTING,
    MQTT_CONNECTED,
    MQTT_SUBSCRIBED,
    MQTT_PUBLISHING,
    MQTT_ERROR
} MQTT_Status;

// 全局MQTT客户端
MQTT_Client mqtt_client;
MQTT_Status mqtt_status = MQTT_DISCONNECTED;

/* MQTT初始化 */
void mqtt_init(void) {
    // 配置MQTT连接参数
    strcpy(mqtt_client.config.broker_address, "iot.example.com");
    mqtt_client.config.broker_port = 1883;
    sprintf(mqtt_client.config.client_id, "STM32_Device_%08lX", device_status.device_id);
    strcpy(mqtt_client.config.username, "device_user");
    strcpy(mqtt_client.config.password, "device_pass");
    mqtt_client.config.keep_alive = 60;
    mqtt_client.config.clean_session = 1;
    mqtt_client.config.use_tls = 0;
    
    // 初始化MQTT客户端
    mqtt_client_init(&mqtt_client);
    
    printf("MQTT client initialized\n");
}

/* MQTT连接 */
uint8_t mqtt_connect(void) {
    if (mqtt_status == MQTT_DISCONNECTED) {
        mqtt_status = MQTT_CONNECTING;
        
        // 建立TCP连接
        if (tcp_connect(mqtt_client.config.broker_address, 
                       mqtt_client.config.broker_port)) {
            
            // 发送MQTT CONNECT报文
            if (mqtt_send_connect(&mqtt_client)) {
                mqtt_status = MQTT_CONNECTED;
                printf("MQTT connected successfully\n");
                
                // 订阅命令主题
                subscribe_command_topic();
                return 1;
            }
        }
        
        mqtt_status = MQTT_ERROR;
        printf("MQTT connection failed\n");
        return 0;
    }
    
    return 1;
}

/* 发布遥测数据 */
void mqtt_publish_telemetry(SensorData *sensor_data) {
    char topic[100];
    char payload[512];
    
    // 构建主题
    sprintf(topic, MQTT_TOPIC_TELEMETRY, mqtt_client.config.client_id);
    
    // 构建JSON载荷
    sprintf(payload, 
            "{\"ts\":%lu,\"values\":{"
            "\"temperature\":%.1f,\"humidity\":%.1f,"
            "\"pressure\":%.1f,\"illuminance\":%.1f,"
            "\"air_quality\":%.1f,\"battery\":%d}}",
            sensor_data->timestamp,
            sensor_data->temperature,
            sensor_data->humidity,
            sensor_data->pressure,
            sensor_data->illuminance,
            sensor_data->air_quality,
            device_status.battery_level);
    
    // 发布消息
    MQTT_Message msg = {
        .topic = topic,
        .qos = 1,
        .retained = 0,
        .payload = (uint8_t*)payload,
        .payload_len = strlen(payload)
    };
    
    mqtt_publish(&mqtt_client, &msg);
    
    printf("Telemetry published: %s\n", payload);
}

/* 订阅命令主题 */
void subscribe_command_topic(void) {
    char topic[100];
    sprintf(topic, MQTT_TOPIC_COMMANDS, mqtt_client.config.client_id);
    
    MQTT_Message msg = {
        .topic = topic,
        .qos = 1,
        .retained = 0,
        .payload = NULL,
        .payload_len = 0
    };
    
    mqtt_subscribe(&mqtt_client, &msg);
    printf("Subscribed to command topic: %s\n", topic);
}

5.2 网络通信任务

/* 网络通信任务 */
void network_task(void *pvParameters) {
    NetworkMessage net_msg;
    uint32_t last_heartbeat = 0;
    uint32_t heartbeat_interval = 300000;  // 5分钟心跳
    
    // 初始化网络模块
    wifi_init();
    mqtt_init();
    
    while (1) {
        uint32_t current_time = HAL_GetTick();
        
        // 检查网络连接
        if (!network_is_connected()) {
            printf("Network disconnected, reconnecting...\n");
            network_reconnect();
            mqtt_connect();
        }
        
        // 处理MQTT消息
        if (mqtt_status == MQTT_CONNECTED) {
            mqtt_process(&mqtt_client);
            
            // 发送心跳包
            if (current_time - last_heartbeat >= heartbeat_interval) {
                send_heartbeat();
                last_heartbeat = current_time;
            }
        }
        
        // 处理网络队列消息
        if (xQueueReceive(xNetworkQueue, &net_msg, pdMS_TO_TICKS(100)) == pdPASS) {
            switch (net_msg.message_type) {
                case MSG_TELEMETRY:
                    mqtt_publish_telemetry((SensorData*)net_msg.data);
                    break;
                    
                case MSG_ATTRIBUTES:
                    mqtt_publish_attributes((DeviceAttributes*)net_msg.data);
                    break;
                    
                case MSG_FIRMWARE_UPDATE:
                    handle_firmware_update((FirmwareInfo*)net_msg.data);
                    break;
                    
                case MSG_COMMAND_RESPONSE:
                    send_command_response((CommandResponse*)net_msg.data);
                    break;
                    
                default:
                    break;
            }
        }
        
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

六、设备控制与执行

6.1 设备控制任务

/* 设备控制任务 */
void control_task(void *pvParameters) {
    ControlCommand cmd;
    uint8_t relay_status[8] = {0};  // 8路继电器状态
    uint8_t pwm_duty[4] = {0};      // 4路PWM占空比
    
    // 初始化执行器
    init_relays();
    init_pwm_outputs();
    init_led_indicators();
    
    while (1) {
        // 处理控制队列指令
        if (xQueueReceive(xControlQueue, &cmd, pdMS_TO_TICKS(100)) == pdPASS) {
            printf("Processing command: ID=%lu, Type=%d, Action=%d\n",
                   cmd.command_id, cmd.command_type, cmd.action);
            
            switch (cmd.command_type) {
                case CMD_RELAY_CONTROL:
                    handle_relay_control(&cmd, relay_status);
                    break;
                    
                case CMD_PWM_CONTROL:
                    handle_pwm_control(&cmd, pwm_duty);
                    break;
                    
                case CMD_LED_CONTROL:
                    handle_led_control(&cmd);
                    break;
                    
                case CMD_SYSTEM_RESET:
                    system_reset();
                    break;
                    
                case CMD_FIRMWARE_UPGRADE:
                    initiate_firmware_upgrade(&cmd);
                    break;
                    
                default:
                    printf("Unknown command type: %d\n", cmd.command_type);
                    break;
            }
            
            // 发送命令响应
            send_command_response(&cmd);
        }
        
        // 执行自动控制逻辑
        execute_auto_control_logic();
        
        // 更新设备状态
        update_device_status();
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

/* 继电器控制 */
void handle_relay_control(ControlCommand *cmd, uint8_t *relay_status) {
    uint8_t relay_id = cmd->target_device;
    uint8_t action = cmd->action;
    
    if (relay_id < 8) {
        if (action == RELAY_ON) {
            gpio_set_relay(relay_id, 1);
            relay_status[relay_id] = 1;
            printf("Relay %d turned ON\n", relay_id);
        } else if (action == RELAY_OFF) {
            gpio_set_relay(relay_id, 0);
            relay_status[relay_id] = 0;
            printf("Relay %d turned OFF\n", relay_id);
        } else if (action == RELAY_TOGGLE) {
            relay_status[relay_id] = !relay_status[relay_id];
            gpio_set_relay(relay_id, relay_status[relay_id]);
            printf("Relay %d toggled to %d\n", relay_id, relay_status[relay_id]);
        }
    }
}

/* PWM控制 */
void handle_pwm_control(ControlCommand *cmd, uint8_t *pwm_duty) {
    uint8_t pwm_channel = cmd->target_device;
    uint8_t duty = (uint8_t)(cmd->parameter & 0xFF);
    
    if (pwm_channel < 4 && duty <= 100) {
        pwm_duty[pwm_channel] = duty;
        set_pwm_duty(pwm_channel, duty);
        printf("PWM channel %d set to %d%%\n", pwm_channel, duty);
    }
}

七、低功耗管理

7.1 低功耗策略

/* 低功耗管理系统 */
typedef enum {
    POWER_MODE_ACTIVE,      // 活跃模式
    POWER_MODE_IDLE,        // 空闲模式
    POWER_MODE_SLEEP,       // 睡眠模式
    POWER_MODE_STOP,        // 停止模式
    POWER_MODE_STANDBY     // 待机模式
} PowerMode;

// 功耗配置
typedef struct {
    uint32_t active_current;     // 活跃模式电流(mA)
    uint32_t idle_current;       // 空闲模式电流(mA)
    uint32_t sleep_current;      // 睡眠模式电流(uA)
    uint32_t stop_current;       // 停止模式电流(uA)
    uint32_t standby_current;    // 待机模式电流(uA)
    uint32_t battery_capacity;   // 电池容量(mAh)
    uint32_t expected_life;     // 预期寿命(天)
} PowerConfig;

// 全局功耗管理
PowerMode current_power_mode = POWER_MODE_ACTIVE;
PowerConfig power_config = {
    .active_current = 150,      // 150mA
    .idle_current = 50,         // 50mA
    .sleep_current = 5000,      // 5mA
    .stop_current = 50,         // 50uA
    .standby_current = 5,       // 5uA
    .battery_capacity = 2000,   // 2000mAh
    .expected_life = 365        // 365天
};

/* 功耗管理任务 */
void power_management_task(void *pvParameters) {
    uint32_t last_activity_time = 0;
    uint32_t idle_timeout = 300000;      // 5分钟空闲进入睡眠
    uint32_t deep_sleep_timeout = 3600000; // 1小时无活动进入深度睡眠
    
    while (1) {
        uint32_t current_time = HAL_GetTick();
        uint32_t time_since_activity = current_time - last_activity_time;
        
        switch (current_time) {
            case POWER_MODE_ACTIVE:
                if (time_since_activity > idle_timeout) {
                    enter_idle_mode();
                }
                break;
                
            case POWER_MODE_IDLE:
                if (time_since_activity > deep_sleep_timeout) {
                    enter_sleep_mode();
                }
                break;
                
            case POWER_MODE_SLEEP:
                if (time_since_activity > deep_sleep_timeout * 2) {
                    enter_stop_mode();
                }
                break;
                
            case POWER_MODE_STOP:
                // 等待外部中断唤醒
                break;
                
            default:
                break;
        }
        
        // 更新电池电量
        update_battery_level();
        
        // 发送功耗统计
        send_power_statistics();
        
        vTaskDelay(pdMS_TO_TICKS(60000));  // 每分钟检查一次
    }
}

/* 进入停止模式 */
void enter_stop_mode(void) {
    printf("Entering STOP mode...\n");
    
    // 保存系统状态
    save_system_state();
    
    // 关闭外设
    disable_peripherals();
    
    // 配置唤醒源
    configure_wakeup_sources();
    
    // 进入停止模式
    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
    // 唤醒后恢复系统
    system_wakeup_handler();
}

/* 活动检测 */
void update_activity_time(void) {
    last_activity_time = HAL_GetTick();
    
    if (current_power_mode != POWER_MODE_ACTIVE) {
        // 恢复到活跃模式
        current_power_mode = POWER_MODE_ACTIVE;
        restore_peripherals();
        printf("System resumed to ACTIVE mode\n");
    }
}

八、安全与加密

8.1 物联网安全机制

/* 物联网安全模块 */
#include "mbedtls/aes.h"
#include "mbedtls/sha256.h"
#include "mbedtls/rsa.h"

// 设备证书结构
typedef struct {
    uint8_t device_cert[1024];    // 设备证书
    uint8_t private_key[2048];    // 私钥
    uint8_t ca_cert[1024];        // CA证书
    uint8_t cert_valid;           // 证书是否有效
    uint32_t cert_expiry;         // 证书过期时间
} DeviceCertificate;

// 安全配置
typedef struct {
    uint8_t use_tls;             // 使用TLS加密
    uint8_t use_certificate;      // 使用证书认证
    uint8_t use_token_auth;       // 使用Token认证
    uint8_t encrypt_payload;      // 加密载荷
    uint8_t secure_boot;         // 安全启动
    uint8_t tamper_detection;    // 篡改检测
} SecurityConfig;

// 全局安全配置
DeviceCertificate device_cert;
SecurityConfig security_config = {
    .use_tls = 1,
    .use_certificate = 1,
    .use_token_auth = 1,
    .encrypt_payload = 1,
    .secure_boot = 1,
    .tamper_detection = 1
};

/* 设备身份认证 */
uint8_t authenticate_device(void) {
    // 1. 验证设备证书
    if (!verify_device_certificate(&device_cert)) {
        printf("Device certificate verification failed\n");
        return 0;
    }
    
    // 2. 挑战-响应认证
    uint8_t challenge[32];
    uint8_t response[32];
    
    generate_random_challenge(challenge);
    calculate_response(challenge, response);
    
    if (!verify_response(response)) {
        printf("Challenge-response authentication failed\n");
        return 0;
    }
    
    // 3. Token验证
    if (!verify_auth_token()) {
        printf("Token authentication failed\n");
        return 0;
    }
    
    printf("Device authentication successful\n");
    return 1;
}

/* 数据加密传输 */
void encrypt_sensor_data(SensorData *data, uint8_t *encrypted_data) {
    mbedtls_aes_context aes;
    uint8_t key[32];
    uint8_t iv[16];
    
    // 生成加密密钥
    generate_encryption_key(key, sizeof(key));
    
    // 生成初始化向量
    generate_iv(iv, sizeof(iv));
    
    // 初始化AES上下文
    mbedtls_aes_init(&aes);
    mbedtls_aes_setkey_enc(&aes, key, 256);
    
    // 加密数据
    mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, 
                          sizeof(SensorData), iv, 
                          (uint8_t*)data, encrypted_data);
    
    mbedtls_aes_free(&aes);
}

/* 固件完整性验证 */
uint8_t verify_firmware_integrity(uint8_t *firmware, uint32_t size, 
                                 uint8_t *expected_hash) {
    uint8_t calculated_hash[32];
    
    // 计算SHA256哈希
    mbedtls_sha256(firmware, size, calculated_hash, 0);
    
    // 比较哈希值
    for (uint8_t i = 0; i < 32; i++) {
        if (calculated_hash[i] != expected_hash[i]) {
            printf("Firmware integrity check failed\n");
            return 0;
        }
    }
    
    printf("Firmware integrity verified\n");
    return 1;
}

九、固件升级(OTA)

9.1 OTA升级系统

/* OTA固件升级系统 */
typedef struct {
    uint32_t firmware_version;     // 固件版本
    uint32_t firmware_size;        // 固件大小
    uint8_t firmware_hash[32];    // 固件哈希
    uint32_t download_url;         // 下载地址
    uint8_t upgrade_status;       // 升级状态
    uint8_t progress;             // 升级进度
    uint32_t error_code;          // 错误代码
} FirmwareInfo;

// OTA升级状态
typedef enum {
    OTA_IDLE,
    OTA_CHECKING,
    OTA_DOWNLOADING,
    OTA_VERIFYING,
    OTA_UPDATING,
    OTA_SUCCESS,
    OTA_FAILED
} OTA_Status;

// 全局OTA状态
FirmwareInfo current_firmware = {
    .firmware_version = 0x010000,  // v1.0.0
    .firmware_size = 0,
    .upgrade_status = OTA_IDLE,
    .progress = 0
};

/* OTA升级任务 */
void ota_upgrade_task(void *pvParameters) {
    FirmwareInfo new_firmware;
    
    while (1) {
        // 检查新版本
        if (check_new_firmware_version(&new_firmware)) {
            printf("New firmware available: v%d.%d.%d\n",
                   (new_firmware.firmware_version >> 16) & 0xFF,
                   (new_firmware.firmware_version >> 8) & 0xFF,
                   new_firmware.firmware_version & 0xFF);
            
            // 下载新固件
            if (download_firmware(&new_firmware)) {
                // 验证固件完整性
                if (verify_firmware_integrity(&new_firmware)) {
                    // 更新固件
                    if (update_firmware(&new_firmware)) {
                        printf("Firmware update successful, restarting...\n");
                        system_restart();
                    }
                }
            }
        }
        
        vTaskDelay(pdMS_TO_TICKS(3600000));  // 每小时检查一次
    }
}

/* 下载固件 */
uint8_t download_firmware(FirmwareInfo *firmware) {
    uint8_t *firmware_buffer;
    uint32_t downloaded_size = 0;
    uint32_t chunk_size = 1024;
    
    // 分配内存
    firmware_buffer = pvPortMalloc(firmware->firmware_size);
    if (!firmware_buffer) {
        printf("Memory allocation failed for firmware download\n");
        return 0;
    }
    
    // 分段下载固件
    while (downloaded_size < firmware->firmware_size) {
        uint32_t remaining = firmware->firmware_size - downloaded_size;
        uint32_t current_chunk = (remaining > chunk_size) ? chunk_size : remaining;
        
        if (!download_firmware_chunk(firmware->download_url, 
                                    downloaded_size, 
                                    current_chunk,
                                    &firmware_buffer[downloaded_size])) {
            printf("Firmware download failed at offset %lu\n", downloaded_size);
            vPortFree(firmware_buffer);
            return 0;
        }
        
        downloaded_size += current_chunk;
        firmware->progress = (downloaded_size * 100) / firmware->firmware_size;
        
        printf("Download progress: %d%%\n", firmware->progress);
    }
    
    // 保存到Flash
    save_firmware_to_flash(firmware_buffer, firmware->firmware_size);
    
    vPortFree(firmware_buffer);
    printf("Firmware download completed\n");
    return 1;
}

十、系统测试与部署

10.1 物联网系统测试

/* 物联网系统测试 */
void iot_system_test(void) {
    printf("=== IoT System Integration Test ===\n");
    
    // 1. 硬件功能测试
    test_hardware_components();
    
    // 2. 传感器数据采集测试
    test_sensor_acquisition();
    
    // 3. 网络通信测试
    test_network_communication();
    
    // 4. MQTT协议测试
    test_mqtt_protocol();
    
    // 5. 设备控制测试
    test_device_control();
    
    // 6. 低功耗测试
    test_power_management();
    
    // 7. 安全机制测试
    test_security_features();
    
    // 8. OTA升级测试
    test_ota_upgrade();
    
    // 9. 压力测试
    test_system_stress();
    
    // 10. 长期稳定性测试
    test_long_term_stability();
    
    printf("=== All Tests Completed ===\n");
}

/* 系统部署脚本 */
void deploy_iot_system(void) {
    printf("Starting IoT system deployment...\n");
    
    // 1. 配置设备参数
    configure_device_parameters();
    
    // 2. 注册设备到云平台
    register_device_to_cloud();
    
    // 3. 配置网络参数
    configure_network_parameters();
    
    // 4. 配置安全证书
    configure_security_certificates();
    
    // 5. 启动系统服务
    start_system_services();
    
    // 6. 验证系统状态
    verify_system_status();
    
    printf("IoT system deployment completed successfully!\n");
}

总结

这个基于STM32的物联网系统设计具有以下特点：

核心技术亮点：

1. 多协议支持：WiFi/4G/NB-IoT/LoRa多种通信方式
2. 边缘计算能力：本地数据处理和智能决策
3. 安全通信：TLS加密、证书认证、数据签名
4. OTA升级：安全的远程固件升级机制
5. 低功耗设计：多级功耗管理，延长电池寿命

实际应用价值：

1. 快速部署：模块化设计，缩短开发周期
2. 高可靠性：多重冗余和故障恢复机制
3. 易扩展性：支持新传感器和设备接入
4. 成本控制：选用合适性价比的STM32系列
5. 标准化接口：统一的API和数据格式

扩展发展方向：

1. AI集成：TensorFlow Lite Micro边缘AI推理
2. 5G应用：超高速低延迟通信
3. 区块链：设备身份认证和数据防篡改
4. 数字孪生：虚拟设备映射和仿真
5. 绿色节能：太阳能供电和能量收集