IoT 固件开发最佳实践 2026

// 1. 接口与实现分离（头文件定义接口）
// sensor_interface.h
#ifndef SENSOR_INTERFACE_H
#define SENSOR_INTERFACE_H

typedef struct {
    int (*init)(void);
    int (*read)(float *value);
    int (*calibrate)(void);
} sensor_ops_t;

// 外部声明具体实现
extern sensor_ops_t dht22_ops;
extern sensor_ops_t bmp280_ops;

#endif

// 2. 依赖注入（便于测试和替换）
// main.c
void sensor_task(void *pvParameters) {
    // 通过指针传入具体实现，而非硬编码
    sensor_ops_t *sensor = &dht22_ops;  // 可轻松切换为 bmp280_ops
    
    sensor->init();
    
    while (1) {
        float value;
        if (sensor->read(&value) == 0) {
            publish_data(value);
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// 3. 配置与代码分离
// config.h
#define CONFIG_MQTT_BROKER      "mqtt.example.com"
#define CONFIG_MQTT_PORT        1883
#define CONFIG_MQTT_KEEPALIVE   60
#define CONFIG_WIFI_SSID        "MyNetwork"
#define CONFIG_WIFI_PASSWORD    "SecretPassword"

// Flash 分区表示例（ESP32 风格）
// 假设 Flash 总大小 4MB

typedef struct {
    uint32_t magic;         // 分区表魔数
    uint32_t version;       // 分区表版本
    uint32_t ota_seq;       // OTA 序列号（判断哪个分区是活动的）
    uint8_t  ota_data[32];  // OTA 状态数据
    uint32_t crc;           // CRC32 校验
} ota_data_t;

// 分区布局
// 0x0000 - 0x1000:   引导加载程序（Bootloader）
// 0x1000 - 0x2000:   分区表
// 0x2000 - 0x3000:   OTA 数据（ota_data）
// 0x3000 - 0x100000: 应用 A 区（约 988KB）
// 0x100000 - 0x1FD000: 应用 B 区（约 988KB）
// 0x1FD000 - 0x200000: NVS（非易失存储）

// OTA 升级流程
typedef enum {
    OTA_STATE_IDLE,
    OTA_STATE_DOWNLOADING,
    OTA_STATE_VERIFYING,
    OTA_STATE_FLASHING,
    OTA_STATE_VALIDATED,
    OTA_STATE_INVALID
} ota_state_t;

ota_state_t current_ota_state = OTA_STATE_IDLE;

// OTA 任务
void ota_task(void *pvParameters) {
    while (1) {
        // 1. 检查是否有新版本
        if (check_new_firmware_version()) {
            current_ota_state = OTA_STATE_DOWNLOADING;
            
            // 2. 下载新固件到非活动分区
            uint32_t inactive_partition = get_inactive_partition();
            int ret = download_firmware(inactive_partition);
            
            if (ret == 0) {
                current_ota_state = OTA_STATE_VERIFYING;
                
                // 3. 验证签名
                if (verify_firmware_signature(inactive_partition)) {
                    current_ota_state = OTA_STATE_VALIDATED;
                    
                    // 4. 更新 OTA 数据，标记下次从新分区启动
                    set_next_boot_partition(inactive_partition);
                    
                    // 5. 重启
                    esp_restart();
                } else {
                    current_ota_state = OTA_STATE_INVALID;
                    report_error("Signature verification failed");
                }
            } else {
                current_ota_state = OTA_STATE_IDLE;
                report_error("Download failed");
            }
        }
        
        // 每 6 小时检查一次
        vTaskDelay(pdMS_TO_TICKS(6 * 60 * 60 * 1000));
    }
}

// 完整的 OTA 升级流程（包含安全验证）
#include <mbedtls/sha256.h>
#include <mbedtls/pk.h>

typedef struct {
    uint32_t magic;             // 魔数：0xABCDEF00
    uint32_t version;           // 固件版本号
    uint32_t timestamp;         // 编译时间戳
    uint32_t image_size;        // 固件大小
    uint8_t  image_hash[32];    // SHA-256 哈希
    uint8_t  signature[64];     // ECDSA 签名
} firmware_header_t;

int perform_ota_update(const char *firmware_url) {
    firmware_header_t header;
    uint8_t download_buffer[4096];
    uint32_t total_downloaded = 0;
    
    // 1. 下载并解析头部
    int ret = http_download_range(firmware_url, 0, sizeof(header), &header);
    if (ret != 0) {
        ESP_LOGE("OTA", "Failed to download header");
        return -1;
    }
    
    // 2. 验证魔数
    if (header.magic != 0xABCDEF00) {
        ESP_LOGE("OTA", "Invalid firmware magic");
        return -2;
    }
    
    // 3. 验证签名（使用固化在设备中的公钥）
    ret = verify_signature_with_public_key(
        &header,
        header.signature,
        sizeof(header.signature),
        g_device_public_key
    );
    
    if (ret != 0) {
        ESP_LOGE("OTA", "Signature verification failed");
        return -3;
    }
    
    // 4. 擦除目标分区
    uint32_t target_partition = get_inactive_partition();
    spi_flash_erase_range(target_partition, header.image_size);
    
    // 5. 下载固件主体并写入 Flash
    ESP_LOGI("OTA", "Downloading firmware...");
    uint32_t offset = sizeof(header);
    
    while (total_downloaded < header.image_size) {
        uint32_t chunk_size = MIN(sizeof(download_buffer), header.image_size - total_downloaded);
        
        ret = http_download_range(firmware_url, offset, chunk_size, download_buffer);
        if (ret != 0) {
            ESP_LOGE("OTA", "Download failed at offset %lu", offset);
            return -4;
        }
        
        // 写入 Flash
        spi_flash_write(target_partition + offset, download_buffer, chunk_size);
        
        offset += chunk_size;
        total_downloaded += chunk_size;
        
        // 报告进度
        int progress = (total_downloaded * 100) / header.image_size;
        ESP_LOGI("OTA", "Progress: %d%%", progress);
        report_ota_progress(progress);
    }
    
    // 6. 验证下载的哈希
    uint8_t calculated_hash[32];
    calculate_flash_hash(target_partition, header.image_size, calculated_hash);
    
    if (memcmp(calculated_hash, header.image_hash, 32) != 0) {
        ESP_LOGE("OTA", "Hash verification failed");
        return -5;
    }
    
    // 7. 设置下次启动分区
    set_next_boot_partition(target_partition);
    
    ESP_LOGI("OTA", "OTA update successful, rebooting...");
    
    // 8. 重启
    vTaskDelay(pdMS_TO_TICKS(1000));  // 等待日志输出
    esp_restart();
    
    return 0;
}

// 回滚机制：如果新固件启动失败，自动回滚到旧版本
void app_main(void) {
    // 检查启动原因
    esp_reset_reason_t reset_reason = esp_reset_reason();
    
    if (reset_reason == ESP_RST_PANIC || reset_reason == ESP_RST_INT_WDT) {
        // 异常重启，可能是新固件有问题
        ESP_LOGE("BOOT", "Abnormal reset detected, rolling back...");
        
        // 回滚到之前的分区
        rollback_to_previous_partition();
    }
    
    // 标记当前分区为有效（看门狗机制）
    mark_current_partition_valid();
    
    // 正常运行
    run_application();
}

// ESP32 DVFS 配置
#include "esp_pm.h"

void configure_dvfs(void) {
    esp_pm_config_esp32_t pm_config = {
        .max_freq_mhz = 240,      // 最大频率
        .min_freq_mhz = 80,       // 最小频率
        .light_sleep_enable = true  // 启用 Light Sleep
    };
    
    esp_pm_configure(&pm_config);
}

// 根据负载动态调整频率
void adjust_frequency_based_on_load(void) {
    static uint32_t idle_count = 0;
    
    if (is_system_idle()) {
        idle_count++;
        
        if (idle_count > 100) {
            // 空闲时间长，降低频率
            esp_pm_cpu_freq_set(ESP_PM_CPU_FREQ_MAX_80M);
        }
    } else {
        idle_count = 0;
        
        // 有任务，提升频率
        esp_pm_cpu_freq_set(ESP_PM_CPU_FREQ_MAX_240M);
    }
}

// STM32 深度睡眠配置
#include <stm32l4xx_hal.h>

void enter_deep_sleep(uint32_t wake_time_ms) {
    // 1. 配置唤醒源（RTC、外部中断等）
    RTC_HandleTypeDef hrtc;
    
    // 配置 RTC 唤醒定时器
    hrtc.Instance = RTC;
    HAL_RTCEx_SetWakeUpTimer(&hrtc, wake_time_ms / 1000, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
    
    // 2. 配置 GPIO 为低功耗模式
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    // 所有未使用引脚设为模拟输入（最低功耗）
    for (int i = 0; i < 16; i++) {
        if (!is_pin_used(i)) {
            GPIO_InitStruct.Pin = (1 << i);
            GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
            HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        }
    }
    
    // 3. 关闭未使用外设时钟
    __HAL_RCC_USART2_CLK_DISABLE();
    __HAL_RCC_SPI2_CLK_DISABLE();
    __HAL_RCC_I2C1_CLK_DISABLE();
    __HAL_RCC_ADC_CLK_DISABLE();
    
    // 4. 禁用 SysTick 中断（睡眠期间不需要）
    SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
    
    // 5. 进入 STOP2 模式（最低功耗，保留 SRAM 内容）
    HAL_PWREx_EnterSTOP2Mode(PWR_STOPENTRY_LOWPOWER);
    
    // 唤醒后从这里继续执行
    // 6. 恢复系统时钟
    SystemClock_Config();
    
    // 7. 恢复外设时钟
    __HAL_RCC_USART2_CLK_ENABLE();
    __HAL_RCC_SPI2_CLK_ENABLE();
    
    // 8. 重新配置 GPIO
    gpio_init_all();
    
    // 9. 清除唤醒标志
    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
}

// 电池供电设备的功耗优化任务
void power_management_task(void *pvParameters) {
    uint32_t battery_voltage;
    
    while (1) {
        // 读取电池电压
        battery_voltage = read_battery_voltage();
        
        if (battery_voltage < 3300) {  // 低于 3.3V
            // 进入省电模式
            enter_power_saving_mode();
        } else if (battery_voltage < 3000) {  // 低于 3.0V
            // 紧急模式：只保留基本功能
            enter_emergency_mode();
        } else {
            // 正常模式
            enter_normal_mode();
        }
        
        // 每 5 分钟检查一次
        vTaskDelay(pdMS_TO_TICKS(5 * 60 * 1000));
    }
}

// WiFi 功耗优化（ESP32）
#include "esp_wifi.h"

void configure_wifi_power_save(void) {
    // 启用 WiFi 节能模式
    esp_wifi_set_ps(WIFI_PS_MAX_MODEM);
    
    // 配置 DTIM 监听间隔（越大越省电，但延迟越高）
    // DTIM = 3 表示每 3 个信标帧唤醒一次
    wifi_ps_type_t ps_type = WIFI_PS_MAX_MODEM;
    esp_wifi_set_ps(ps_type);
}

// BLE 广播功耗优化
#include "nimble/nimble_port.h"

void configure_ble_advertising(void) {
    // 配置广播参数
    struct ble_gap_adv_params adv_params;
    
    adv_params.conn_mode = BLE_GAP_CONN_MODE_NON;  // 不可连接
    adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN;  // 可发现
    adv_params.itvl_min = 0x0640;  // 1 秒（0x0640 = 1000ms）
    adv_params.itvl_max = 0x0C80;  // 2 秒
    
    // 较长的广播间隔 = 更低的功耗
    ble_gap_adv_start(OWN_ADDR_TYPE_PUBLIC, NULL, BLE_HS_FOREVER,
                      &adv_params, NULL, NULL);
}

// MQTT 客户端实现（使用 Paho MQTT）
#include <MQTTClient.h>

// MQTT 配置
typedef struct {
    const char *broker_url;
    uint16_t port;
    const char *client_id;
    const char *username;
    const char *password;
    const char *publish_topic;
    const char *subscribe_topic;
    uint16_t keepalive;
    bool clean_session;
} mqtt_config_t;

// 全局 MQTT 客户端
static MQTTClient client;
static mqtt_config_t config = {
    .broker_url = "mqtt.example.com",
    .port = 1883,
    .client_id = "iot_device_001",
    .username = "device_user",
    .password = "device_pass",
    .publish_topic = "devices/001/data",
    .subscribe_topic = "devices/001/command",
    .keepalive = 60,
    .clean_session = false
};

// 连接回调
void on_connected(void *context) {
    ESP_LOGI("MQTT", "Connected to broker");
    
    // 订阅命令主题
    MQTTClient_subscribe(client, config.subscribe_topic, 1);
    
    // 发布上线消息
    MQTTClient_publish(client, "devices/001/status", 
                       strlen("online"), "online", 1, 0, NULL);
}

// 消息到达回调
void on_message_arrived(void *context, char *topicName, int topicLen, 
                        MQTTClient_message *message) {
    ESP_LOGI("MQTT", "Message arrived on topic %s", topicName);
    
    // 处理命令
    handle_command(message->payload, message->payloadlen);
    
    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
}

// 连接丢失回调
void on_connection_lost(void *context, char *cause) {
    ESP_LOGW("MQTT", "Connection lost: %s", cause);
    
    // 自动重连
    MQTTClient_reconnect(client, 5000);
}

// MQTT 初始化
int mqtt_init(void) {
    MQTTClient_create(&client, config.broker_url, config.client_id,
                      MQTTCLIENT_PERSISTENCE_NONE, NULL);
    
    MQTTClient_callbacks callbacks = {
        .on_connect = on_connected,
        .on_message = on_message_arrived,
        .on_connection_lost = on_connection_lost
    };
    
    MQTTClient_setCallbacks(client, NULL, &callbacks);
    
    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
    conn_opts.keepAliveInterval = config.keepalive;
    conn_opts.cleansession = config.clean_session;
    conn_opts.username = config.username;
    conn_opts.password = config.password;
    conn_opts.automaticReconnect = 1;
    
    int rc = MQTTClient_connect(client, &conn_opts);
    if (rc != MQTTCLIENT_SUCCESS) {
        ESP_LOGE("MQTT", "Failed to connect: %d", rc);
        return -1;
    }
    
    return 0;
}

// 发布数据
int mqtt_publish_data(const uint8_t *data, size_t len) {
    MQTTClient_message pubmsg = MQTTClient_message_initializer;
    pubmsg.payload = (void *)data;
    pubmsg.payloadlen = len;
    pubmsg.qos = 1;  // QoS 1：至少送达一次
    pubmsg.retained = 0;
    
    return MQTTClient_publish(client, config.publish_topic, 
                              len, data, 1, 0, NULL);
}

// CoAP 客户端实现（使用 libcoap）
#include <coap3/coap.h>

// CoAP 资源定义
static coap_resource_t *resources[] = {
    NULL  // 资源列表结束标记
};

// CoAP 请求处理
static void
helloworld_get(coap_context_t *ctx, struct coap_resource_t *resource,
               coap_session_t *session, coap_pdu_t *pdu,
               coap_binary_t *token, coap_string_t *query,
               coap_pdu_t *response) {
    
    const char *payload = "Hello, World!";
    coap_add_data(response, strlen(payload), (const uint8_t *)payload);
}

// CoAP 服务器初始化
coap_context_t *coap_server_init(void) {
    coap_context_t *ctx;
    coap_address_t listen_addr;
    
    // 绑定到 5683 端口（CoAP 标准端口）
    coap_address_init(&listen_addr);
    listen_addr.addr.sin.sin_family = AF_INET;
    listen_addr.addr.sin.sin_addr.s_addr = INADDR_ANY;
    listen_addr.addr.sin.sin_port = htons(5683);
    
    ctx = coap_new_context(&listen_addr);
    if (!ctx) {
        return NULL;
    }
    
    // 注册资源
    coap_resource_t *r = coap_resource_init(coap_make_str_const("hello"), 0);
    coap_register_handler(r, COAP_REQUEST_GET, helloworld_get);
    coap_add_resource(ctx, r);
    
    return ctx;
}