ESP32 OTA升级失败自救指南：Bootloader回滚机制与出厂固件恢复全流程

一、为什么需要回滚机制？

OTA（Over-The-Air）升级是物联网设备远程维护的核心手段，但网络中断、固件损坏、签名校验失败等意外情况可能导致设备无法启动。如果没有回滚机制，设备将变砖，只能通过串口或JTAG手动烧录，成本极高。ESP32的Bootloader提供了两种回滚方案：

• 基于分区状态的自动回滚：利用esp_ota组件管理App分区状态，启动时检查状态并决定是否回滚。
• 基于GPIO触发的强制回滚：通过外部引脚电平触发，强制从备份分区启动。

本文重点讲解第一种方案，因为它无需额外硬件，且能自动处理大多数升级失败场景。

二、ESP32启动流程与分区表设计

2.1 启动流程

ESP32上电后，ROM Bootloader执行以下步骤：

1. 加载并运行Flash中的二级Bootloader（即bootloader.bin）。
2. 二级Bootloader读取分区表（partition table），找到factory分区或ota_0、ota_1等App分区。
3. 根据otadata分区中的信息，决定启动哪个App分区。
4. 加载App并跳转执行。

2.2 分区表设计

要实现回滚，分区表必须包含以下关键分区：

• factory：出厂固件，只读，不可被OTA覆盖。
• ota_0、ota_1：OTA升级用的App分区，轮流写入。
• otadata：存储OTA状态信息，包括当前启动分区、升级状态等。

典型分区表（partitions.csv）示例：

# Name,   Type, SubType, Offset,   Size, Flags
nvs,      data, nvs,     0x9000,   0x4000,
otadata,  data, ota,     0xd000,   0x2000,
phy_init, data, phy,     0xf000,   0x1000,
factory,  app,  factory, 0x10000,  0x200000,
ota_0,    app,  ota_0,   0x210000, 0x200000,
ota_1,    app,  ota_1,   0x410000, 0x200000,

• factory分区大小建议与OTA分区一致，以便回滚时能完整运行。
• otadata分区大小至少0x2000，用于存储esp_ota_img_states_t结构。

三、回滚原理：分区状态机

ESP32的esp_ota组件为每个App分区维护一个状态，存储在otadata中。状态包括：

• ESP_OTA_IMG_UNDEFINED：未定义，首次启动。
• ESP_OTA_IMG_NEW：新固件，等待确认。
• ESP_OTA_IMG_PENDING_VERIFY：正在验证中。
• ESP_OTA_IMG_VALID：固件有效，可长期使用。
• ESP_OTA_IMG_INVALID：固件无效，触发回滚。
• ESP_OTA_IMG_ABORTED：升级被中止。

启动时，Bootloader读取otadata，根据状态决定启动哪个分区：

• 如果当前分区状态为NEW或PENDING_VERIFY，则启动它，但会设置一个“回滚标志”。
• 如果App在启动后调用esp_ota_mark_app_valid_cancel_rollback()，则状态变为VALID，回滚标志清除。
• 如果App未调用该函数，或发生重启，Bootloader会认为固件无效，自动回滚到上一个有效分区（如factory或另一个OTA分区）。

四、配置步骤

4.1 启用OTA与回滚功能

在menuconfig中配置：

idf.py menuconfig

• 进入 Component config → ESP System Settings → OTA behavior，选择 Rollback after test 或 Rollback after reboot（推荐后者，更灵活）。
• 确保 Enable app rollback support 已勾选。

4.2 编写OTA升级代码

以下代码演示了如何下载新固件并执行OTA升级：

#include "esp_ota_ops.h"
#include "esp_http_client.h"
#include "esp_log.h"

static const char *TAG = "OTA";

extern void app_main(void);

void ota_task(void *pvParameter) {
    esp_http_client_config_t config = {
        .url = "http://example.com/firmware.bin",
        .timeout_ms = 10000,
    };
    esp_http_client_handle_t client = esp_http_client_init(&config);
    esp_ota_handle_t ota_handle;
    const esp_partition_t *update_partition = esp_ota_get_next_update_partition(NULL);
    
    if (update_partition == NULL) {
        ESP_LOGE(TAG, "No OTA partition found");
        return;
    }
    
    esp_err_t err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &ota_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
        return;
    }
    
    char buffer[1024];
    int content_length = 0;
    esp_http_client_open(client, 0);
    esp_http_client_fetch_headers(client);
    content_length = esp_http_client_get_content_length(client);
    
    while (1) {
        int read_len = esp_http_client_read(client, buffer, sizeof(buffer));
        if (read_len <= 0) break;
        esp_ota_write(ota_handle, buffer, read_len);
    }
    
    esp_http_client_close(client);
    esp_ota_end(ota_handle);
    
    // 设置新固件为待验证状态
    err = esp_ota_set_boot_partition(update_partition);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "esp_ota_set_boot_partition failed (%s)", esp_err_to_name(err));
        return;
    }
    
    ESP_LOGI(TAG, "OTA upgrade successful, rebooting...");
    esp_restart();
}

4.3 在App中标记固件有效

新固件启动后，必须尽快调用esp_ota_mark_app_valid_cancel_rollback()，否则下次重启会回滚。建议在app_main()开头调用：

#include "esp_ota_ops.h"

void app_main(void) {
    // 标记当前固件有效，取消回滚
    esp_err_t err = esp_ota_mark_app_valid_cancel_rollback();
    if (err != ESP_OK) {
        ESP_LOGE("APP", "Failed to mark app valid: %s", esp_err_to_name(err));
    } else {
        ESP_LOGI("APP", "App marked as valid, rollback disabled");
    }
    
    // 其他初始化代码...
}

五、完整示例：带回滚的OTA流程

以下是一个完整的OTA任务，包含错误处理和回滚逻辑：

#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_ota_ops.h"
#include "esp_http_client.h"
#include "esp_log.h"

static const char *TAG = "OTA_EXAMPLE";

#define OTA_URL "http://192.168.1.100:8080/firmware.bin"

void ota_task(void *pvParameter) {
    ESP_LOGI(TAG, "Starting OTA...");
    
    esp_http_client_config_t config = {
        .url = OTA_URL,
        .timeout_ms = 10000,
        .buffer_size = 1024,
    };
    esp_http_client_handle_t client = esp_http_client_init(&config);
    
    const esp_partition_t *update_partition = esp_ota_get_next_update_partition(NULL);
    if (update_partition == NULL) {
        ESP_LOGE(TAG, "No OTA partition found");
        vTaskDelete(NULL);
        return;
    }
    ESP_LOGI(TAG, "Writing to partition subtype %d at offset 0x%x", 
             update_partition->subtype, update_partition->address);
    
    esp_ota_handle_t ota_handle;
    esp_err_t err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &ota_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "esp_ota_begin failed: %s", esp_err_to_name(err));
        esp_http_client_cleanup(client);
        vTaskDelete(NULL);
        return;
    }
    
    err = esp_http_client_open(client, 0);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Failed to open HTTP connection: %s", esp_err_to_name(err));
        esp_ota_abort(ota_handle);
        esp_http_client_cleanup(client);
        vTaskDelete(NULL);
        return;
    }
    
    int content_length = esp_http_client_fetch_headers(client);
    ESP_LOGI(TAG, "Content length: %d", content_length);
    
    char buffer[1024];
    int total_read = 0;
    while (1) {
        int read_len = esp_http_client_read(client, buffer, sizeof(buffer));
        if (read_len <= 0) {
            break;
        }
        esp_ota_write(ota_handle, buffer, read_len);
        total_read += read_len;
        ESP_LOGI(TAG, "Progress: %d/%d", total_read, content_length);
    }
    
    esp_http_client_close(client);
    esp_http_client_cleanup(client);
    
    err = esp_ota_end(ota_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "esp_ota_end failed: %s", esp_err_to_name(err));
        vTaskDelete(NULL);
        return;
    }
    
    err = esp_ota_set_boot_partition(update_partition);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "esp_ota_set_boot_partition failed: %s", esp_err_to_name(err));
        vTaskDelete(NULL);
        return;
    }
    
    ESP_LOGI(TAG, "OTA success, rebooting in 3 seconds...");
    vTaskDelay(pdMS_TO_TICKS(3000));
    esp_restart();
}

void app_main(void) {
    // 标记当前固件有效（如果是新升级的固件）
    esp_ota_img_states_t state;
    const esp_partition_t *running = esp_ota_get_running_partition();
    if (esp_ota_get_state_partition(running, &state) == ESP_OK) {
        if (state == ESP_OTA_IMG_PENDING_VERIFY) {
            ESP_LOGI(TAG, "New firmware detected, marking valid");
            esp_ota_mark_app_valid_cancel_rollback();
        }
    }
    
    // 创建OTA任务
    xTaskCreate(&ota_task, "ota_task", 8192, NULL, 5, NULL);
}

六、注意事项

• 回滚触发条件：如果新固件在启动后未调用esp_ota_mark_app_valid_cancel_rollback()，且发生重启，Bootloader会回滚到上一个有效分区。因此，务必在固件初始化早期调用该函数。
• 分区大小：factory分区和OTA分区大小必须一致，否则回滚后可能因空间不足而失败。
• 断电保护：OTA写入过程中断电可能导致分区损坏，但esp_ota_begin会写入魔数，esp_ota_end会校验，失败时自动标记无效。
• 回滚次数：如果连续多次升级失败，设备会一直回滚到factory，但不会无限循环，因为otadata会记录状态。
• 测试建议：在开发阶段，可以故意在app_main中不调用标记函数，观察回滚是否生效。
• 日志查看：使用idf.py monitor查看启动日志，会显示“Rollback”相关提示。

七、总结

ESP32的Bootloader回滚机制是保障OTA可靠性的关键。通过合理设计分区表、利用esp_ota组件状态机，并在App中正确标记固件有效性，可以轻松实现升级失败后的自动恢复出厂固件。本文提供的代码可直接用于实际项目，建议结合具体业务场景进行扩展，如增加升级进度显示、失败重试等。

掌握这一机制，你的物联网设备将具备更强的自愈能力，大幅降低维护成本。