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:
- 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); - grava o slot inativo (
esp_ota_begincomOTA_WITH_SEQUENTIAL_WRITES, cedendo o núcleo a cada 32 KB); - relê o slot da flash, confere o SHA-256 e a assinatura de novo, e só então o promove;
- 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_1 | o OTA grava o slot que não está rodando | CONFIG_PARTITION_TABLE_CUSTOM_FILENAME apontando para partitions.csv do componente devui |
CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y | uma imagem nova que morre antes de se confirmar volta sozinha à anterior | sdkconfig.defaults, antes da primeira gravação por cabo (veja Bootloader sem rollback) |
| A curva P-384 no mbedTLS | as 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-IDF | a cadeia do armazenamento é conferida por ele | CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=y (o padrão do IDF) |
| A chave pública de firmware do produto | a placa só aceita o que essa chave assinou | CONFIG_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.
| Gancho | Quando | O que devolve | Sem ele |
|---|---|---|---|
on_offer(ctx, offer, &retry_after_ms) | chegou uma oferta (offer->version, release, size), antes de baixar | DEVUI_OTA_ACCEPT; DEVUI_OTA_DEFER (adiada; *retry_after_ms diz quando oferecer de novo); DEVUI_OTA_REFUSE | aceita |
on_ready(ctx, release) | a imagem foi baixada, conferida e promovida | DEVUI_OTA_RESTART_NOW, ou DEVUI_OTA_RESTART_LATER e o app chama devui_ota_restart_now() quando puder | reinicia sozinho em 2 s (uma placa sem tela não tem quem aperte) |
is_healthy(ctx) | na imagem nova, 60 s depois do HELLO_ACK | true para ficar com ela; false volta à anterior | saudá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.2ECDHE-ECDSA-CHACHA20-POLY1305. Só comECDHE-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 pelaGTS Root R4com 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 odevui_otanão compila semCONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED, e oexamples/otamanté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) | ESP32 | ESP32-C3 | ESP32-S3 |
|---|---|---|---|
| Pacote completo (o padrão) | 1.076.480 B | 1.157.264 B | 1.081.104 B |
Mínimo (CONFIG_DEVUI_OTA_CA_MINIMAL) | 1.012.512 B | 1.092.944 B | 1.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_SAFEpara o I2S não engasgar. - Outros:
CONFIG_GPTIMER_ISR_CACHE_SAFE,CONFIG_UART_ISR_IN_IRAM,CONFIG_GPIO_CTRL_FUNC_IN_IRAM, eIRAM_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:
- a placa baixa, confere e reinicia na imagem nova;
- o veneno cai em panic, o bootloader volta à imagem anterior no boot seguinte;
- a placa volta à nuvem com a versão de antes, manda
FW_STATUS revertidae 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.csvque o pacote põe na pasta de cada exemplo (no PlatformIO,board_build.partitionscom oextras/partitions.csvdo pacote): dois slots de app. Com a tabela padrão do core também há dois slots, mas sem a partiçãodevuida chave (Arduino). - O bootloader do core 3.3 já tem rollback (
CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLEnas 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
initArduinodo core chamaesp_ota_mark_app_valid_cancel_rollback()no boot, antes dosetup(), a menos que o app sobrescreva a função fracaverifyRollbackLater(). A biblioteca a sobrescreve: devolvetrueenquanto uma imagem que o OTA do SDK promoveu espera a confirmação do SDK (o registrodevui.fw_pendna NVS do SDK), efalseem qualquer outro caso, para que uma imagem que chegou por outro caminho (oUpdatedo 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óprioverifyRollbackLater()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 é oDevUIOta.beginque 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_ENABLEDeCONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL), e a receita do ESP32 sem PSRAM não os desliga. Umcustom_sdkconfigque os desligue deixa o build com um aviso e oDevUIOta.beginrecusando comESP_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=900no build, ou noconfirm_deadline_msdas opções. - A versão que a frota mostra é a do sketch, o
cfg.fw_version. A imagem do Arduino IDE (e doarduino-cli) traz noesp_app_desc_ta versão das bibliotecas do core (no 3.3.12,6671d0b), a mesma em todo sketch: a release pede o--version. A do pioarduino comcustom_sdkconfig(a receita do ESP32 sem PSRAM) traz a do projeto,1por padrão, e a release só aceita essa:--version 1, ou a versão do projeto nocustom_sdkconfig(CONFIG_APP_PROJECT_VER_FROM_CONFIG=yeCONFIG_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:
| ESP32 | ESP8266 | |
|---|---|---|
| Imagem nova que cai | volta sozinha à anterior | não volta: depois da cópia a anterior não existe mais; só o cabo conserta |
| Confirmação | reconectou, 60 s, is_healthy | aplicada no primeiro HELLO_ACK da imagem nova; o is_healthy nunca é chamado |
Queda de energia antes do end | segue na imagem que tinha | igual |
Queda de energia depois do end, antes do reinício | a imagem nova sobe | o 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 eboot | não se aplica | pode 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 HELLO | FW_CAPS com URL e rollback | FW_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 onodemcuv2e oesp12e) ou o4m2m(o padrão da Arduino IDE). No4m3m(e no2m1m) o sistema de arquivos começa onde a área do sketch termina, a placa anunciaFW_SPACE0 e recusa toda oferta com o motivoespaco.
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
Updaterrecusa (UPDATE_ERROR_BOOTSTRAP). - O
Update.begindo core desliga o modo de economia do Wi-Fi (wifi_set_sleep_type(NONE_SLEEP_T)), e ele fica assim. - Não use o
Updatedo 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 seuUpdate.beginrecusa 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 é.
