物联网设备OTA升级全方案：从ESP32双分区到差分升级的工程化实践

沧州虎王科技
1 阅读8分钟

前言

在物联网项目中，设备部署后最让人头疼的问题之一就是"如何升级固件"。当你的设备分布在工厂车间、户外农田、或者嵌入了用户家中时，逐一拆机用数据线烧录固件显然不现实。

OTA（Over-The-Air）空中升级技术让设备通过 WiFi/4G 网络远程更新固件，是物联网平台的核心能力之一。

沧州虎王科技在 ESP32 工具箱和随身WiFi调试工具中，深度实践了多种 OTA 方案。本文将从原理到工程实践，全面解析物联网设备 OTA 升级的技术方案。

一、OTA 升级基础

1.1 什么是 OTA

OTA（Over-The-Air）是指通过无线网络远程更新设备固件的技术。在物联网场景下，OTA 的典型流程：

开发者构建固件 → 上传到OTA服务器 → 服务器推送升级通知 → 设备下载固件 → 校验完整性 → 写入Flash → 切换分区 → 重启运行新固件

1.2 OTA 的核心挑战

挑战描述解决方案
断电恢复升级过程中断电导致设备变砖双分区/A-B分区设计
网络不稳定下载过程中断连断点续传 + 校验重试
存储空间MCU Flash有限差分升级 / 流式写入
安全性固件被篡改签名验证 + 加密传输
回滚新固件异常版本回退机制
批量管理大规模设备同时升级灰度发布 + 分批推送

二、ESP32 OTA 实现方案

2.1 分区表设计

ESP32 的 Flash 分区是 OTA 的基础。默认分区表：

# ESP32 默认分区表（简化版）
nvs      0x9000    24KB    非易失性存储
otadata  0xE000    8KB     OTA 分区信息
app0     0x10000   1280KB  应用分区A
app1     0x150000  1280KB  应用分区B
spiffs   0x290000  1024KB  文件系统

otadata 分区记录当前应该启动哪个应用分区。OTA 升级时，新固件写入非活动分区，升级完成后修改 otadata 切换启动分区。

2.2 Arduino 框架 OTA

ESP32 Arduino 框架内置了 OTA 支持：

#include <WiFi.h>
#include <HTTPClient.h>
#include <Update.h>

const char* firmwareUrl = "https://ota.czkree.com/firmware/v2.1.0.bin";

void performOTA() {
  HTTPClient http;
  http.begin(firmwareUrl);
  
  int httpCode = http.GET();
  if (httpCode == HTTP_CODE_OK) {
    int contentLength = http.getSize();
    
    if (!Update.begin(contentLength)) {
      Serial.println("Not enough space for OTA");
      return;
    }
    
    // 流式写入
    WiFiClient* stream = http.getStreamPtr();
    size_t written = 0;
    uint8_t buff[1024];
    
    while (http.connected() && written < contentLength) {
      size_t avail = stream->available();
      if (avail) {
        int c = stream->readBytes(buff, min(avail, sizeof(buff)));
        Update.write(buff, c);
        written += c;
        
        // 进度上报
        Serial.printf("OTA Progress: %d%%\n", 
          (written * 100) / contentLength);
      }
    }
    
    if (Update.end() && Update.isFinished()) {
      Serial.println("OTA Update Success");
      ESP.restart();
    } else {
      Serial.printf("OTA Error: %d\n", Update.getError());
    }
  }
  
  http.end();
}

2.3 ESP-IDF 原生 OTA

ESP-IDF 提供了更底层的 OTA 控制：

#include "esp_ota_ops.h"
#include "esp_https_ota.h"

esp_err_t perform_https_ota(const char* url) {
    esp_http_client_config_t config = {
        .url = url,
        .cert_pem = server_cert_pem,  // HTTPS 证书
        .timeout_ms = 30000,
    };
    
    esp_https_ota_config_t ota_config = {
        .http_config = &config,
        .partial_http_download = true,   // 启用断点续传
        .max_http_request_size = 4096,
    };
    
    esp_https_ota_handle_t ota_handle = NULL;
    esp_err_t err = esp_https_ota_begin(&ota_config, &ota_handle);
    if (err != ESP_OK) return err;
    
    while (1) {
        err = esp_https_ota_perform(ota_handle);
        if (err != ESP_ERR_HTTPS_OTA_IN_PROGRESS) break;
        
        // 进度上报
        int remaining = esp_https_ota_get_image_len_read(ota_handle);
        int total = esp_https_ota_get_image_size(ota_handle);
        ESP_LOGI("OTA", "Progress: %d/%d bytes", remaining, total);
    }
    
    if (err == ESP_OK) {
        err = esp_https_ota_finish(ota_handle);
        if (err == ESP_OK) {
            esp_restart();
        }
    }
    
    return err;
}

三、OTA 平台架构设计

3.1 整体架构

沧州虎王科技 OTA 平台架构：

┌─────────────────────────────────────────────────┐
│                   OTA 管理平台                     │
│  ┌──────────┐  ┌──────────┐  ┌───────────────┐  │
│  │ 固件管理  │  │ 设备分组  │  │ 升级策略引擎   │  │
│  │ 上传/版本 │  │ 标签/区域 │  │ 灰度/全量/定时 │  │
│  └──────────┘  └──────────┘  └───────────────┘  │
└──────────────────┬──────────────────────────────┘
                   │ REST API
                   v
┌─────────────────────────────────────────────────┐
│                  OTA 服务端                       │
│  ┌──────────┐  ┌──────────┐  ┌───────────────┐  │
│  │ CDN分发  │  │ 设备注册  │  │ 升级状态跟踪   │  │
│  │ 静态资源 │  │ 心跳上报  │  │ 统计与告警    │  │
│  └──────────┘  └──────────┘  └───────────────┘  │
└──────────────────┬──────────────────────────────┘
                   │ HTTPS/MQTT
                   v
┌─────────────────────────────────────────────────┐
│                  IoT 设备端                       │
│  ┌──────────┐  ┌──────────┐  ┌───────────────┐  │
│  │ OTA Agent│  │ 固件校验  │  │ A/B分区管理   │  │
│  │ 下载/写入 │  │ 签名验证  │  │ 回滚保护      │  │
│  └──────────┘  └──────────┘  └───────────────┘  │
└─────────────────────────────────────────────────┘

3.2 固件版本管理

// OTA 服务端 - 固件版本管理 API
const express = require('express');
const app = express();

// 固件版本数据库模型
const firmwareSchema = {
  version: '2.1.0',           // 语义化版本号
  deviceType: 'esp32',        // 设备类型
  chipVariant: 'esp32-s3',     // 芯片变体
  fileUrl: 'https://cdn.czkree.com/fw/2.1.0.bin',
  fileSize: 1248576,           // 文件大小
  md5sum: 'a1b2c3d4e5f6...',  // MD5 校验
  signature: 'base64...',      // 数字签名
  changelog: '修复WiFi断连问题',
  releaseType: 'stable',       // stable/beta/test
  createdAt: '2026-08-01',
  minVersion: '2.0.0',        // 最低升级版本要求
};

// 设备检查更新 API
app.get('/api/ota/check', (req, res) => {
  const { deviceType, currentVersion, chipVariant, deviceId } = req.query;
  
  // 查找适用于该设备的最新固件
  const latest = findLatestFirmware(deviceType, chipVariant, currentVersion);
  
  if (!latest || compareVersion(latest.version, currentVersion) <= 0) {
    return res.json({ update: false });
  }
  
  // 检查灰度策略
  const canUpdate = checkGrayPolicy(deviceId, latest.version);
  if (!canUpdate) {
    return res.json({ update: false });
  }
  
  res.json({
    update: true,
    version: latest.version,
    url: latest.fileUrl,
    md5: latest.md5sum,
    size: latest.fileSize,
    changelog: latest.changelog,
    signature: latest.signature
  });
});

3.3 灰度发布策略

class GrayReleaseStrategy {
  constructor() {
    this.strategies = {
      // 按百分比灰度
      percentage: (deviceId, percent) => {
        const hash = this.hashDeviceId(deviceId);
        return (hash % 100) < percent;
      },
      
      // 按设备分组灰度
      group: (deviceId, groups) => {
        const group = getDeviceGroup(deviceId);
        return groups.includes(group);
      },
      
      // 按地域灰度
      region: (deviceId, regions) => {
        const region = getDeviceRegion(deviceId);
        return regions.includes(region);
      },
      
      // 指定设备列表
      whitelist: (deviceId, deviceList) => {
        return deviceList.includes(deviceId);
      }
    };
  }
  
  check(deviceId, releaseConfig) {
    const { type, params } = releaseConfig.strategy;
    const strategy = this.strategies[type];
    return strategy ? strategy(deviceId, params) : false;
  }
  
  hashDeviceId(deviceId) {
    let hash = 0;
    for (let i = 0; i < deviceId.length; i++) {
      hash = ((hash << 5) - hash) + deviceId.charCodeAt(i);
      hash = hash & hash;
    }
    return Math.abs(hash);
  }
}

四、安全 OTA 设计

4.1 固件签名验证

安全是 OTA 的重中之重。沧州虎王科技采用 ECDSA 签名 + AES 加密的双重保护：

// ESP32 端签名验证（ESP-IDF）
#include "mbedtls/ecdsa.h"
#include "mbedtls/sha256.h"

esp_err_t verify_firmware_signature(const uint8_t* firmware, 
                                      size_t fw_len,
                                      const uint8_t* signature,
                                      size_t sig_len) {
    // 1. 计算固件 SHA256 哈希
    uint8_t hash[32];
    mbedtls_sha256(firmware, fw_len, hash, 0);
    
    // 2. 使用公钥验证签名
    mbedtls_ecdsa_context ec_ctx;
    mbedtls_ecdsa_init(&ec_ctx);
    
    // 加载预置的公钥
    mbedtls_ecp_group_load(&ec_ctx.MBEDTLS_PRIVATE(grp), 
                           MBEDTLS_ECP_DP_SECP256R1);
    // ... 加载公钥点 ...
    
    int ret = mbedtls_ecdsa_verify(&ec_ctx.MBEDTLS_PRIVATE(grp),
                                    hash, sizeof(hash),
                                    &pubkey, sig_r, sig_s);
    
    return (ret == 0) ? ESP_OK : ESP_ERR_INVALID_VERSION;
}

4.2 防回滚机制

// ESP32 eFuse 中存储安全版本号
// 每次发布新固件，安全版本号递增
// 设备启动时检查固件版本号 >= eFuse 中的版本号

#define EFUSE_BLK_SECURE_VERSION  EFUSE_BLK3

esp_err_t check_anti_rollback(uint32_t fw_version) {
    uint32_t sec_version;
    esp_efuse_read_field_blob(
        ESP_EFUSE_SECURE_VERSION, &sec_version, 32);
    
    if (fw_version < sec_version) {
        ESP_LOGE("OTA", "Anti-rollback: firmware too old");
        return ESP_FAIL;
    }
    return ESP_OK;
}

// 升级成功后更新安全版本号
esp_err_t burn_secure_version(uint32_t new_version) {
    // 注意：eFuse 是一次性的，只能从 0 烧到 1
    return esp_efuse_write_field_blob(
        ESP_EFUSE_SECURE_VERSION, &new_version, 32);
}

五、差分升级

5.1 为什么需要差分升级

当固件从 v2.0.0 升级到 v2.0.1 时，可能只有几百字节的差异，却需要下载完整的 1.2MB 固件。差分升级只传输变化部分，大幅减少下载量。

升级方式下载大小下载时间(100KB/s)适用场景
全量升级1.2MB~12s大版本更新
差分升级20-80KB<1s小版本修复
增量升级5-20KB<0.2s配置/资源更新

5.2 bsdiff 差分算法

# 服务端生成差分包
import bsdiff

old_firmware = open('v2.0.0.bin', 'rb').read()
new_firmware = open('v2.0.1.bin', 'rb').read()

# 生成差分包
patch = bsdiff.diff(old_firmware, new_firmware)
print(f'差分包大小: {len(patch)} bytes')  # 通常 20-80KB

# 保存差分包
open('patch_2.0.0_to_2.0.1.bin', 'wb').write(patch)

// ESP32 端应用差分包
#include "bspatch.h"

esp_err_t apply_ota_patch(const char* patch_url) {
    // 1. 下载差分包
    uint8_t* patch_data = download_file(patch_url, &patch_len);
    
    // 2. 读取当前固件
    const esp_partition_t* running = esp_ota_get_running_partition();
    uint8_t* old_firmware = read_partition(running, running->size);
    
    // 3. 应用差分
    uint8_t* new_firmware = NULL;
    size_t new_len = 0;
    int ret = bspatch(old_firmware, running->size,
                      patch_data, patch_len,
                      &new_firmware, &new_len);
    
    // 4. 写入 OTA 分区
    const esp_partition_t* update_partition = 
        esp_ota_get_next_update_partition(NULL);
    esp_ota_write(update_partition, new_firmware, new_len);
    
    // 5. 验证并切换
    esp_ota_set_boot_partition(update_partition);
    esp_restart();
}

六、升级状态监控

6.1 设备状态上报

// ESP32 端通过 MQTT 上报升级状态
class OTAStatusReporter {
  constructor(mqttClient, deviceId) {
    this.client = mqttClient;
    this.deviceId = deviceId;
  }
  
  report(state, data = {}) {
    const payload = {
      deviceId: this.deviceId,
      state: state,
      timestamp: Date.now(),
      ...data
    };
    
    this.client.publish(
      `ota/status/${this.deviceId}`,
      JSON.stringify(payload)
    );
  }
  
  // 状态枚举
  static STATES = {
    IDLE: 'idle',
    CHECKING: 'checking',
    DOWNLOADING: 'downloading',
    VERIFYING: 'verifying',
    WRITING: 'writing',
    SUCCESS: 'success',
    FAILED: 'failed',
    ROLLBACK: 'rollback'
  };
}

// 使用
const reporter = new OTAStatusReporter(mqtt, deviceId);
reporter.report('downloading', { progress: 45, speed: '120KB/s' });

6.2 服务端监控面板

// OTA 升级监控 API
app.get('/api/ota/dashboard', async (req, res) => {
  const { version } = req.query;
  
  const stats = await getOTAStats(version);
  
  res.json({
    total: stats.total,
    success: stats.success,
    failed: stats.failed,
    inProgress: stats.downloading + stats.writing,
    successRate: (stats.success / stats.total * 100).toFixed(1) + '%',
    avgDownloadTime: stats.avgDownloadTime + 's',
    avgDownloadSpeed: stats.avgDownloadSpeed + 'KB/s',
    failureReasons: stats.failureReasons,
    // 按时间分布
    timeline: stats.timeline,
    // 按地域分布
    byRegion: stats.byRegion
  });
});

七、沧州虎王科技 OTA 实践总结

7.1 关键经验

  1. 双分区是底线：永远不要在当前运行的分区上直接写入，使用 A/B 分区设计确保断电安全
  2. 校验比速度重要：下载完成后先校验 MD5/签名，确认无误再写入 Flash
  3. 灰度发布不可省：先 5% → 20% → 50% → 100%，每批次观察失败率
  4. 超时和重试：下载超时设置为 30s，重试 3 次，每次间隔递增
  5. 日志和告警：升级失败自动告警，保留完整日志用于排查

7.2 踩坑记录

问题原因解决方案
升级后WiFi连不上NVS分区被误覆盖固定分区表，OTA不碰NVS区域
部分设备升级失败Flash质量参差增加坏块检测和重试机制
升级后频繁重启新固件有BUG启动计数器，3次失败自动回滚
下载速度慢CDN未覆盖使用多CDN + 就近节点

总结

OTA 升级是物联网平台的"生命线"。一个可靠的 OTA 系统需要从分区设计、安全验证、灰度发布、状态监控到回滚保护的全链路考虑。

沧州虎王科技在 ESP32 工具箱和随身WiFi调试工具中，实践了从全量升级到差分升级、从单设备到灰度批量发布的完整 OTA 方案。我们相信，好的 OTA 系统应该让开发者专注于固件本身，而把升级的复杂性交给平台处理。

后续我们将开源 ESP32 OTA Agent 的参考实现，帮助更多 IoT 团队快速搭建自己的 OTA 系统。欢迎访问 hardware.czkree.com 了解更多。

avatar
文章
阅读
粉丝