Pular para o conteúdo
ThingFace

Atualização remota de firmware (OTA)

O devui_ota é o componente opcional do SDK que atualiza o firmware da placa pela nuvem. O fabricante sobe o .bin no portal (ou pela CLI); a nuvem o assina com a chave de firmware do produto e oferece a release às placas pela própria conexão do SDK (FW_OFFER). A placa baixa o artefato por HTTPS direto do armazenamento (Cloudflare R2, URL assinada de poucos minutos) e:

  1. antes do primeiro byte gravado, confere o cabeçalho: a assinatura Ed25519 de uma das chaves do anel, o chip, o tamanho e o piso contra rebaixamento (security_version, guardado na NVS da placa);
  2. grava o slot inativo (esp_ota_begin com OTA_WITH_SEQUENTIAL_WRITES, cedendo o núcleo a cada 32 KB);
  3. relê o slot da flash, confere o SHA-256 e a assinatura de novo, e só então o promove;
  4. reinicia (ou deixa o app decidir quando) e, na imagem nova, se confirma ou volta à anterior.

Um app sem o devui_ota compila e roda como antes. O OTA é do ESP-IDF (provado em placa no ESP32 e no S3; o C3 compila) e da biblioteca Arduino: no ESP32 com o core 3.3 (Arduino-ESP32) e no ESP8266, pela própria conexão do SDK e com garantias menores (ESP8266). Os exemplos são o examples/ota e o arduino/examples/Ota.

Ligar o OTA

O que o firmware precisa ter:

Por quêOnde
A tabela de partições do SDK, com ota_0 e ota_1o OTA grava o slot que não está rodandoCONFIG_PARTITION_TABLE_CUSTOM_FILENAME apontando para partitions.csv do componente devui
CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=yuma imagem nova que morre antes de se confirmar volta sozinha à anteriorsdkconfig.defaults, antes da primeira gravação por cabo (veja Bootloader sem rollback)
A curva P-384 no mbedTLSas raízes do armazenamento são chaves P-384 (O pacote de CAs)não desligue CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED; sem ela o build para
O pacote de CAs do ESP-IDFa cadeia do armazenamento é conferida por eleCONFIG_MBEDTLS_CERTIFICATE_BUNDLE=y (o padrão do IDF)
A chave pública de firmware do produtoa placa só aceita o que essa chave assinouCONFIG_DEVUI_OTA_KEY_1 (A chave)

O componente: no repositório, ports/esp-idf/devui_ota, ao lado do devui (o EXTRA_COMPONENT_DIRS de ports/esp-idf traz os dois); no ESP Component Registry, o pacote thingface/devui_ota, que depende do thingface/devui da mesma versão. O main pede devui_ota no PRIV_REQUIRES, e o app chama devui_ota_begin uma vez, depois do nvs_flash_init e antes do devui_start:

#include "devui_ota.h"

devui_ota_options_t ota = {
    .hooks = {.on_offer = on_offer, .on_ready = on_ready, .is_healthy = is_healthy}, /* os três são opcionais */
};
ESP_ERROR_CHECK(devui_ota_begin(&ota)); /* keys NULL: o anel de CONFIG_DEVUI_OTA_KEY_1..4 */
ESP_ERROR_CHECK(devui_start(&cfg));

O PROJECT_VER do CMakeLists.txt do projeto é a versão que o portal mostra e a que a release leva: suba-o a cada release. O OTA é dos planos pagos: a aba Firmware do produto só aparece neles.

A chave pública de firmware

O portal mostra a chave pública de firmware do produto em hex, 64 caracteres (Produto > Firmware > Chave de firmware, "Chave pública (hex)", com o botão Copiar). Cole-a no sdkconfig (no sdkconfig.defaults do produto: a chave é pública e pode ir para o git):

CONFIG_DEVUI_OTA_KEY_1="d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"

(esse valor é um vetor de teste da RFC 8032, não a chave de um produto). O build confere o texto: 64 caracteres hex, maiúsculas ou minúsculas, nada só de zeros, nenhuma chave repetida e nenhum buraco no anel. Um erro de digitação para o idf.py build com a mensagem devui_ota: CONFIG_DEVUI_OTA_KEY_1 não é uma chave pública, em vez de virar uma frota que recusa toda atualização. Sem nenhuma chave, o build passa e devui_ota_begin devolve ESP_ERR_INVALID_ARG com o aviso no log (o exemplo segue sem OTA).

O anel tem até 4 chaves, na ordem do portal (CONFIG_DEVUI_OTA_KEY_1 a _4). A placa aceita uma release assinada por qualquer uma delas, e nada pelo fio muda o anel. Para trocar a chave: gire-a no portal, ponha a nova em CONFIG_DEVUI_OTA_KEY_2 (mantendo a antiga em _1) e publique essa release, que ainda sai assinada pela antiga. Só tire a antiga do anel quando todas as placas em campo rodarem um build que já tem a nova.

Quem guarda as chaves em outro lugar passa o anel em código, e ele vale no lugar do sdkconfig:

static const uint8_t chaves[1][32] = {{0xd7, 0x5a, 0x98, 0x01, /* ... os 32 bytes */}};
devui_ota_options_t ota = {.keys = chaves, .n_keys = 1};

Os 32 bytes saem do hex do portal assim:

python -c "h='<os 64 caracteres>'; print(', '.join('0x' + h[i:i + 2] for i in range(0, 64, 2)))"

Os ganchos do app

Os três são opcionais e rodam na task do SDK: leem o estado do app e devolvem na hora, sem bloquear e sem chamar a API do SDK de dentro deles.

GanchoQuandoO que devolveSem ele
on_offer(ctx, offer, &retry_after_ms)chegou uma oferta (offer->version, release, size), antes de baixarDEVUI_OTA_ACCEPT; DEVUI_OTA_DEFER (adiada; *retry_after_ms diz quando oferecer de novo); DEVUI_OTA_REFUSEaceita
on_ready(ctx, release)a imagem foi baixada, conferida e promovidaDEVUI_OTA_RESTART_NOW, ou DEVUI_OTA_RESTART_LATER e o app chama devui_ota_restart_now() quando puderreinicia sozinho em 2 s (uma placa sem tela não tem quem aperte)
is_healthy(ctx)na imagem nova, 60 s depois do HELLO_ACKtrue para ficar com ela; false volta à anteriorsaudável

O uso típico: não baixar nem reiniciar no meio de uma venda, de uma dose ou de uma impressão (adiar no on_offer, RESTART_LATER no on_ready), e só confirmar a imagem nova quando o que importa no produto funciona (o sensor responde, a tela desenhou, a task principal está viva). O examples/ota mostra os três com um interruptor "ocupado" na página. devui_ota_state() diz a fase (DEVUI_OTA_IDLE, _DOWNLOADING, _PROMOTED, _CONFIRMING).

A confirmação e o prazo

Depois do reinício, a imagem nova se confirma quando reconectou à nuvem, recebeu o HELLO_ACK, ficou 60 s de pé e o is_healthy concordou. Só então o SDK chama esp_ota_mark_app_valid_cancel_rollback, sobe o piso de security_version e manda FW_STATUS aplicada. Uma imagem que reinicia (ou é desligada) antes disso volta à anterior no boot seguinte: é o que se quer de uma imagem que trava, e é também o que acontece com uma placa desligada da tomada antes da hora.

O prazo é para reconectar: se a imagem nova não receber o HELLO_ACK até 10 minutos depois do boot (sem rede, com a nuvem fora de alcance), o SDK volta à imagem anterior. Reconectada dentro do prazo, os 60 s de pé e o is_healthy seguem até o fim mesmo que passem dos 10 minutos (uma placa que reconecta aos 9 min 30 s se confirma aos 10 min 30 s; um is_healthy falso volta à anterior na hora). Para uma imagem que reconecta mas nunca fica 60 s seguidos de pé (a conexão cai antes de cada fim, e a contagem recomeça), há um teto de segurança: o prazo mais 5 minutos (ou mais os 60 s e 1 minuto, quando o confirm_ms passa de 4 minutos); nele, o SDK volta à anterior. O prazo é do app, no sdkconfig:

CONFIG_DEVUI_OTA_CONFIRM_DEADLINE_S=600

(de 120 s a 24 h). Dê mais a um produto cuja rede pode demorar a voltar depois de um reinício (um gateway que sobe devagar, um modem celular); nunca menos que o tempo de conectar. O devui_ota_options_t.confirm_deadline_ms, quando não é 0, vale no lugar dele.

Se o esp_ota_mark_app_valid_cancel_rollback falhar, o SDK tenta de novo uma vez; falhando outra vez, a imagem fica sem confirmar: o piso não sobe, não sai aplicada, sai FW_STATUS falhou com o erro 13 (flash, o esp_err_t no FW_DETAIL), e o SDK não reverte por conta própria. Quem decide é o bootloader no próximo reinício: se voltar à imagem anterior, ela conta revertida (18); se ficar na nova, ela se confirma de novo naquele boot.

O freio

A placa guarda na NVS a release que está tentando (a marca ota_em_curso) e quantas vezes seguidas ela falhou. Três falhas seguidas da mesma release, seja qual for a falha (rede, HTTP, prazo sem bytes novos, URL vencida, memória, a imagem, a assinatura, um reinício no meio), ou uma única reversão (a imagem nova voltou à anterior), suspendem aquela release na placa: ela passa a recusá-la (FW_STATUS com o motivo "suspensa"), e o portal mostra por quê. Um sucesso zera a contagem. A suspensão vale só para aquela release: uma release nova é oferecida normalmente. Recusar ou adiar uma oferta (o on_offer, a chave errada, o piso) não é falha e não conta; nem uma oferta que chega enquanto a task do download anterior ainda fecha a conexão TLS: ela recebe recusou com o motivo "ocupado", que a nuvem oferece de novo.

Por que contar até as falhas de rede: uma release que nunca termina de baixar numa placa (uma rede que cai sempre no mesmo ponto, uma imagem grande demais para o tempo da URL) prenderia a placa num laço de downloads; depois de três, ela para de tentar e a frota mostra quem ficou para trás.

O pacote de CAs

O download confere o certificado do armazenamento (Cloudflare R2, <conta>.r2.cloudflarestorage.com) com o pacote de CAs do ESP-IDF (esp_crt_bundle), completo por padrão: o CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL do IDF, ~63 KB de flash a mais. Completo, porque a Cloudflare troca a CA dos certificados dela quando quer (hoje usa Google Trust Services, Let's Encrypt, SSL.com e Sectigo), e uma placa que deixa de reconhecer a CA do armazenamento não baixa mais nada, nem a atualização que consertaria isso.

O que foi conferido em 14/11/2026, com uma conexão TLS de verdade ao R2 (openssl s_client) e a verificação da cadeia recebida pelo mbedTLS do ESP-IDF 5.5.5 compilado no PC:

  • o R2 tem dois certificados e escolhe pelo que o cliente oferece. Com suítes ECDSA (as do SDK), manda a cadeia ECDSA: r2.cloudflarestorage.com (P-256) ← WE1 (P-256) ← GTS Root R4 (P-384), em TLS 1.2 ECDHE-ECDSA-CHACHA20-POLY1305. Só com ECDHE-RSA, manda a cadeia RSA (WR1 ← GTS Root R1);
  • não precisa de ECDHE_RSA: o corte do mbedTLS dos exemplos (CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=n) negocia com o R2;
  • precisa da P-384: o WE1 é assinado pela GTS Root R4 com ECDSA P-384/SHA-384. Com a P-384 desligada (o corte dos exemplos sem OTA), o mbedTLS não lê a chave da raiz e a cadeia não confere (The certificate is not correctly signed by the trusted CA); com ela, confere. Por isso o devui_ota não compila sem CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED, e o examples/ota mantém a P-384 (o resto do corte é o dos outros exemplos).

O mínimo, como opção: CONFIG_DEVUI_OTA_CA_MINIMAL=y (menuconfig > devui_ota) troca o pacote do IDF pelas raízes ECDSA das CAs da Cloudflare (GTS Root R3 e R4, ISRG Root X2, SSL.com Root Certification Authority ECC, SSL.com TLS ECC Root CA 2022, USERTrust ECC Certification Authority e Sectigo Public Server Authentication Root E46, em ports/esp-idf/devui_ota/ca/minimal.pem, copiadas do pacote do IDF). Economiza ~63 KB de flash (medido abaixo). Só aparece com ECDHE_RSA e TLS 1.3 desligados, para que o armazenamento sempre mande a cadeia ECDSA. O risco é o de cima: se a Cloudflare passar a usar uma CA fora da lista, as placas com o mínimo param de atualizar para sempre. Use só quando a flash não couber.

examples/ota (IDF 5.5.5, -Os do SDK)ESP32ESP32-C3ESP32-S3
Pacote completo (o padrão)1.076.480 B1.157.264 B1.081.104 B
Mínimo (CONFIG_DEVUI_OTA_CA_MINIMAL)1.012.512 B1.092.944 B1.017.040 B

Cuidados no app: o cache durante a escrita

Gravar a flash desliga o cache da flash enquanto dura cada escrita e cada apagamento. Nesse intervalo, só roda o que está na IRAM: uma interrupção que não é IRAM-safe fica parada até a escrita terminar (a tela pisca, o áudio engasga, um byte da UART se perde), e uma marcada como IRAM que toca código ou dados da flash derruba a placa (Cache disabled but cached memory region accessed). Durante um OTA isso se repete o download inteiro, várias vezes por segundo. No ThingFace isso é do app do fabricante, e cada driver tem a sua opção:

  • Tela: uma tela DSI só ficou estável com CONFIG_LCD_DSI_ISR_CACHE_SAFE; para o barramento RGB, CONFIG_LCD_RGB_ISR_IRAM_SAFE, e o LVGL com os buffers em RAM interna.
  • Áudio: o I2S pede o CONFIG_I2S_ISR_IRAM_SAFE para o I2S não engasgar.
  • Outros: CONFIG_GPTIMER_ISR_CACHE_SAFE, CONFIG_UART_ISR_IN_IRAM, CONFIG_GPIO_CTRL_FUNC_IN_IRAM, e IRAM_ATTR (com os dados em DRAM) em toda ISR própria que precisa rodar durante o download.

O SDK já cede o núcleo a cada 32 KB gravados, para o watchdog e as outras tasks (o apagamento em bloco segura o núcleo por segundos, e o watchdog derruba a placa). Também conte com a memória: durante o download há duas sessões TLS abertas (a do SDK e a do download); medimos 113 KB de heap mínimo no C3 com as duas.

Bootloader sem rollback

O rollback mora no bootloader, e o OTA nunca atualiza o bootloader: o que a placa recebeu na primeira gravação por cabo é o que ela tem para sempre. Uma placa gravada sem CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE não volta sozinha de uma imagem que trava no boot; nenhuma atualização remota resolve isso, só regravar o bootloader por cabo. Por isso todos os exemplos do SDK com a tabela de dois slots já vêm com ele ligado (o custo é só no bootloader, nada no app), e tests/test_examples.py reprova o exemplo que o desligar.

A placa diz no HELLO se tem rollback (FW_CAPS): o portal mostra "sem rollback" na frota e pede uma segunda confirmação antes de disparar uma implantação nela. Uma placa cujo bootloader foi compilado com a opção mas que mesmo assim sobe uma imagem nova como NEW (um bootloader antigo gravado por baixo) também passa a ser "sem rollback".

Gravar por cabo depois de um OTA

Depois de um OTA, a placa roda do ota_1 (ou do ota_0), e o otadata guarda essa escolha. O idf.py flash completo grava o otadata em branco junto com o app (a placa volta ao ota_0), mas o idf.py app-flash, ou um esptool write_flash só do app, grava o app novo no ota_0 e não mexe no otadata: se a placa estava no ota_1, ela continua subindo a imagem do OTA, e parece que a gravação não pegou. Na dúvida, apague o otadata junto:

idf.py -p COMxx erase-otadata flash

(ou python -m esptool --chip esp32 -p COMxx erase_region 0xe000 0x2000 na tabela do SDK). A identidade da placa não muda: a chave fica na partição devui. A placa diz no HELLO a partição que está rodando, e o SDK reconhece pela identidade da imagem (o SHA-256 dela) que a placa não roda mais a release do OTA e deixa de anunciá-la. Não grave por cabo enquanto uma imagem nova espera a confirmação: o SDK toma a troca por uma reversão e suspende aquela release na placa.

A prova do veneno

O controle positivo do rollback é uma imagem que trava de propósito: o "veneno" que acompanha o SDK, nas ferramentas de teste do OTA, um app que imprime VENENO|<alvo>|... e chama abort() logo no boot. Antes de liberar o OTA de um produto, publique-o como release numa placa de teste com o firmware do produto, e confira que:

  1. a placa baixa, confere e reinicia na imagem nova;
  2. o veneno cai em panic, o bootloader volta à imagem anterior no boot seguinte;
  3. a placa volta à nuvem com a versão de antes, manda FW_STATUS revertida e suspende aquela release (o portal mostra a reversão).

Se a placa ficar em laço de panic, o bootloader dela não tem rollback (Bootloader sem rollback): regrave por cabo com o bootloader certo antes de liberar o OTA para a frota.

Arduino-ESP32

A biblioteca Arduino leva o mesmo devui_ota, compilado dentro do core 3.3 (que traz o ESP-IDF 5.5): o download por HTTPS, a gravação do slot inativo, a releitura, a confirmação e o rollback são os de cima. A chave vem em hex, como o portal a mostra, e o OTA liga antes do DevUI.begin:

#include <DevUI.h>
#include <DevUIOta.h>

devui_ota_hooks_t ganchos = {};        // on_offer, on_ready e is_healthy, os três opcionais
ganchos.is_healthy = saudavel;
DevUIOta.begin("<a Chave pública (hex) do portal>", &ganchos);
DevUI.begin(cfg);                      // cfg.fw_version: a versão que a release leva

DevUIOta.begin recusa com ESP_ERR_INVALID_ARG (e diz na serial) o texto que não é uma chave: menos ou mais de 64 caracteres hex, só zeros, uma chave repetida no anel. O anel inteiro (até 4, depois de uma rotação) vai em DevUIOta.begin(chaves, n, &opcoes). DevUIOta.restartNow() e DevUIOta.state() são o devui_ota_restart_now() e o devui_ota_state(). O exemplo é o arduino/examples/Ota.

O que muda em relação ao ESP-IDF:

  • A tabela de partições é a do SDK, o partitions.csv que o pacote põe na pasta de cada exemplo (no PlatformIO, board_build.partitions com o extras/partitions.csv do pacote): dois slots de app. Com a tabela padrão do core também há dois slots, mas sem a partição devui da chave (Arduino).
  • O bootloader do core 3.3 já tem rollback (CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE nas bibliotecas pré-compiladas do core): toda placa gravada pelo core 3.x volta sozinha de uma imagem que morre antes de se confirmar.
  • O core confirmaria a imagem nova sozinho. O initArduino do core chama esp_ota_mark_app_valid_cancel_rollback() no boot, antes do setup(), a menos que o app sobrescreva a função fraca verifyRollbackLater(). A biblioteca a sobrescreve: devolve true enquanto uma imagem que o OTA do SDK promoveu espera a confirmação do SDK (o registro devui.fw_pend na NVS do SDK), e false em qualquer outro caso, para que uma imagem que chegou por outro caminho (o Update do próprio app, o ArduinoOTA) continue confirmada pelo core como antes. Sem essa sobrescrita a checagem de saúde não decidiria nada: o veneno que cai depois do boot nunca voltaria. Um sketch que tenha o seu próprio verifyRollbackLater() não liga (definição repetida): tire o dele.
  • Toda imagem nova mantém o DevUIOta.begin. Quem confirma a imagem nova é o OTA do SDK, e é o DevUIOta.begin que o liga. Uma release sem ele não se confirma do jeito certo: compilada pela Arduino IDE, ninguém a confirma e ela volta à anterior no reinício seguinte; compilada pelo PlatformIO, o core a confirma no boot, sem a checagem de saúde, e a placa fica sem OTA (a próxima release só por cabo).
  • A curva P-384 e o pacote de CAs completo vêm nas bibliotecas do core (CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED e CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL), e a receita do ESP32 sem PSRAM não os desliga. Um custom_sdkconfig que os desligue deixa o build com um aviso e o DevUIOta.begin recusando com ESP_ERR_NOT_SUPPORTED: sem eles o firmware não baixa. O pacote mínimo de CAs (CONFIG_DEVUI_OTA_CA_MINIMAL) não existe no Arduino.
  • O prazo da confirmação é o mesmo, 10 minutos; outro vai por -DCONFIG_DEVUI_OTA_CONFIRM_DEADLINE_S=900 no build, ou no confirm_deadline_ms das opções.
  • A versão que a frota mostra é a do sketch, o cfg.fw_version. A imagem do Arduino IDE (e do arduino-cli) traz no esp_app_desc_t a versão das bibliotecas do core (no 3.3.12, 6671d0b), a mesma em todo sketch: a release pede o --version. A do pioarduino com custom_sdkconfig (a receita do ESP32 sem PSRAM) traz a do projeto, 1 por padrão, e a release só aceita essa: --version 1, ou a versão do projeto no custom_sdkconfig (CONFIG_APP_PROJECT_VER_FROM_CONFIG=y e CONFIG_APP_PROJECT_VER).
  • Duas sessões TLS durante o download. No core 3.3.12 o SDK online custa ~82 KB de heap, dos quais ~41 KB são os buffers fixos de uma sessão TLS (entrada e saída de 16 KB), e a sessão do download pede outros tantos. Medido numa imagem de 1,2 MB, heap de 8 bits (o S3 em rede local, o ESP32 na produção):

    • S3 sem PSRAM, core como vem: ~70 a 75 KB a menos que online; o mínimo de 92 a 97 KB;
    • ESP32 clássico sem PSRAM, core como vem: ~78 KB livres online e o mínimo de 15,6 a 18,3 KB no download. Passa, mas sem margem para o app;
    • o mesmo ESP32 com a receita do ESP32 sem PSRAM: ~131 KB livres online e o mínimo de 69 KB.

    No ESP32 clássico sem PSRAM, use a receita (buffers dinâmicos): ela vale também para a sessão do download. No ESP-IDF, com buffers dinâmicos, o mínimo foi de 172 KB no ESP32 e de 87 a 113 KB no C3.

O que o OTA acrescenta ao exemplo, medido no build do core 3.3.12 (o mesmo sketch com e sem as chamadas do DevUIOta): +126 KB de flash no ESP32 e +130 KB no C3 (quase tudo o cliente HTTP e o pacote de CAs, 69 KB; no ESP-IDF, de +133 a +141 KB), e 1,6 KB de RAM estática.

ESP8266

O ESP8266 recebe o firmware pela própria conexão do SDK: não há memória para uma segunda sessão TLS que confira o servidor. A nuvem manda o artefato em pedaços de até 1.008 B (FW_CHUNK), que a placa pede com FW_WANT (o offset e o crédito, quatro pedaços por vez por padrão; o window das opções muda), e o Updater do core 3.1.2 grava a imagem no espaço livre abaixo do sistema de arquivos. No reinício seguinte, o eboot do core a copia para o começo da flash, por cima da antiga. A API é a mesma do ESP32 (DevUIOta.begin com a chave em hex), e o exemplo também.

O que fica igual: a assinatura Ed25519 do cabeçalho é conferida antes do primeiro byte gravado (o mesmo Monocypher do ESP32, na pilha de 7 KB do porte, não nos 4 KB do loop(); 140 ms a 160 MHz, 280 ms a 80 MHz); o SHA-256 da imagem é conferido em fluxo e de novo relendo a cópia gravada (com o byte 2, o modo da flash que o Updater reescreve, devolvido ao da imagem), junto com a assinatura outra vez, antes do Update.end(). Sem o end o eboot não copia nada: uma assinatura errada, uma cópia que não confere ou uma queda antes do fim deixam a placa como estava. O piso contra rebaixamento (security_version) mora no setor do SDK na flash (0x3FA000), o da chave da placa, fora do alcance do Updater, do sistema de arquivos e da EEPROM do app; o reset de fábrica o mantém. O freio é o mesmo (três falhas seguidas, qualquer falha, suspendem a release na placa).

O que se perde:

ESP32ESP8266
Imagem nova que caivolta sozinha à anteriornão volta: depois da cópia a anterior não existe mais; só o cabo conserta
Confirmaçãoreconectou, 60 s, is_healthyaplicada no primeiro HELLO_ACK da imagem nova; o is_healthy nunca é chamado
Queda de energia antes do endsegue na imagem que tinhaigual
Queda de energia depois do end, antes do reinícioa imagem nova sobeo comando do eboot (na memória do RTC) se perde: a placa segue na anterior, e a nuvem recebe falhou (interrompido)
Queda de energia durante a cópia do ebootnão se aplicapode exigir o cabo: a cópia leva ~6,3 s (470 KB) e o eboot não a retoma; o que fica no começo da flash é uma mistura das duas imagens. Em 3 de 4 cortes medidos a placa entrou em laço de reinícios e só voltou por cabo; no outro a mistura rodou (as duas imagens diferiam em 6 bytes), a placa avisou falhou (interrompido) e a próxima oferta a consertou. A identidade (o setor do SDK) sobreviveu aos quatro
O HELLOFW_CAPS com URL e rollbackFW_CAPS com o canal e sem rollback; o portal marca "ESP8266: sem volta automática"

Por isso, no ESP8266:

  • a imagem nova tem de manter o SDK de pé e o DevUIOta.begin: é o SDK que traz o próximo OTA. Uma release que não conecta à nuvem, ou que não liga o OTA, só sai por cabo;
  • a implantação para a frota exige uma placa-piloto: a mesma release aplicada e confirmada antes numa placa escolhida pelo fabricante;
  • o layout de flash precisa de espaço livre: o eagle.flash.4m1m.ld (o padrão do PlatformIO para o nodemcuv2 e o esp12e) ou o 4m2m (o padrão da Arduino IDE). No 4m3m (e no 2m1m) o sistema de arquivos começa onde a área do sketch termina, a placa anuncia FW_SPACE 0 e recusa toda oferta com o motivo espaco.

Cuidados:

  • Depois de gravar por cabo, aperte o reset (ou desligue e ligue): a placa que sai do esptool ainda está no modo de gravação, e o Updater recusa (UPDATE_ERROR_BOOTSTRAP).
  • O Update.begin do core desliga o modo de economia do Wi-Fi (wifi_set_sleep_type(NONE_SLEEP_T)), e ele fica assim.
  • Não use o Update do core no app durante um OTA do SDK: um só escreve no espaço livre (o SDK recusa a oferta com outro em andamento, e o seu Update.begin recusa se o SDK estiver gravando).
  • A placa reconhece a imagem que roda pelo SHA-256 do sketch na flash: no boot de uma placa que já fez um OTA isso leva, para 400 KB, 0,45 s a 160 MHz e 0,84 s a 80 MHz (a releitura, medida).
  • O estado do OTA ocupa ~190 B do setor do SDK por OTA; uma placa com dono compacta o setor uma vez a cada vinte OTAs, mais ou menos, e um corte de energia exatamente nessa compactação custa a identidade (o risco de sempre do setor único, ESP8266).

O que o OTA acrescenta, medido no build do core 3.1.2 (o mesmo sketch com e sem as chamadas do DevUIOta, layout 4m1m): +38 KB de flash (21 KB do Monocypher) e 4,4 KB de RAM estática (1,8 KB são as constantes do Monocypher, que o core põe na DRAM). Durante o download, o Updater toma mais 4 KB do heap (o buffer de um setor). Um sketch sem o OTA não leva nada disso.

A janela do canal (o window das opções, em bytes) é de quatro pedaços (4.032 B) desde a 0.4.0. Medido em 16/11 pela produção, num ESP-12F a 160 MHz, uma imagem de 473 KB: com 1 pedaço, 99 s do aceite à imagem pronta (~4,7 KB/s) e 12.256 B de heap no ponto mais baixo; com 2, 73 s e 11.360 B; com 4, 57 s (~8,3 KB/s) e 11.088 B. Um sketch com pouco heap de sobra volta a um pedaço com window = 1008.

As chaves offline

Sem OTA, o endpoint e as raízes de confiança do firmware só mudam por uma ordem assinada pelas chaves offline da plataforma. Com o OTA ligado, a nuvem assina o firmware, e um firmware novo pode trazer outro endpoint e outras raízes sem essa ordem. Isso foi aceito e registrado: o OTA é opcional por produto, e quem não o liga mantém a garantia das chaves offline. O portal avisa na primeira release do produto, e a declaração de conformidade do produto diz qual dos dois ele é.