Pular para o conteúdo
ThingFace

Novidades

O que mudou em cada versão do SDK da placa, da biblioteca da página e do serviço.

O SDK segue versões semânticas abaixo de 1.0.0 até o lançamento: o MINOR sobe com o que é novo para quem usa o SDK, o PATCH com uma correção (As versões do SDK). Uma mudança só de documentação não sobe o número: a entrada dela fica em "Ainda sem versão", sob "Documentação", e vai junto na próxima versão. A placa manda a versão no HELLO, e o portal a mostra na saúde do dispositivo. Cada versão diz a versão do protocolo devui.1 que fala; a API v1 está congelada desde 16/10/2026, e daqui em diante ela só cresce por adições (Compatibilidade).

Ainda sem versão

Documentação

  • O heap do OTA no Arduino-ESP32, medido (16/11): no ESP32 clássico sem PSRAM, com o core como vem, o mínimo durante o download foi de 15,6 a 18,3 KB; com a receita do ESP32 sem PSRAM, 69 KB. O guia recomenda a receita e diz a versão que a release pede numa imagem do pioarduino (1 por padrão) (Arduino-ESP32).

0.4.0 (16/11/2026), protocolo 1.2

  • ESP8266: o download do firmware até 42 % mais rápido (16/11): a janela do modo canal passa de um pedaço para quatro (4.032 B). Medido pela produção num ESP-12F, uma imagem de 473 KB: 57 s em vez de 99 s, com ~1,2 KB de heap a mais no ponto mais baixo. Quem precisa desse heap volta a um pedaço com window = 1008 nas opções do DevUIOta.begin (ESP8266).

0.3.3 (15/11/2026), protocolo 1.2

  • Os dependencies.lock dos exemplos do ESP-IDF (16/11): o manifest_hash de cada um é o que o build escreve, de novo em todos os exemplos (15 estavam velhos desde versões anteriores, e o build os reescrevia). A cada versão, o tools/bump_version.py refaz esses hashes com o cálculo do próprio IDF Component Manager (tools/lock_hashes.py, que precisa do python do IDF), e um teste confere. Nada muda na placa nem na CLI.

0.3.2 (15/11/2026), protocolo 1.2

  • CLI: as placas sem espaço para a imagem (15/11): o devui firmware status diz quantas placas da implantação estão sem espaço livre para a imagem (o estado no_space da nuvem: um ESP8266 gravado com o layout 4m3m, por exemplo) e o que fazer: gravá-las por cabo com o layout 4m1m ou 4m2m. Antes elas ficavam pending sem motivo visível (ESP8266).

0.3.1 (15/11/2026), protocolo 1.2

  • ESP8266: o diagnóstico de uma cópia do eboot interrompida (15/11): quando a energia cai no meio da cópia da imagem nova (~6,3 s), o eboot não a retoma e o que fica no começo da flash é uma mistura das duas imagens. Se a mistura roda, a placa dizia no log que a imagem nunca tinha sido copiada; agora ela compara a imagem que roda com a da última atualização aplicada e diz "não foi copiada inteira". O que vai para a nuvem não muda (falhou, interrompido, e a próxima oferta conserta a imagem). O guia passa a dizer o que acontece com uma queda de energia durante a cópia, medido em quatro cortes num ESP-12F: em três a placa só voltou por cabo (ESP8266).

0.3.0 (15/11/2026), protocolo 1.2

  • Atualização remota de firmware no Arduino-ESP32 (15/11): a biblioteca Arduino leva o mesmo devui_ota do ESP-IDF, compilado no core 3.3: DevUIOta.begin com a chave pública de firmware em hex, antes do DevUI.begin, os mesmos ganchos opcionais, o mesmo download por HTTPS, a releitura e a confirmação depois de reconectar e de 60 s. A biblioteca sobrescreve o verifyRollbackLater() do core, que senão confirmaria a imagem nova já no boot, antes da checagem de saúde; uma imagem que chegou por outro caminho (o Update do app, o ArduinoOTA) segue confirmada pelo core como antes. Toda release nova tem de manter o DevUIOta.begin. Provado em placa no S3 (imagem boa aplicada, imagem que cai depois do boot revertida, assinatura errada recusada antes do primeiro byte gravado, queda de rede no meio); durante o download, medido no S3 sem PSRAM, o heap livre fica ~70 a 75 KB abaixo do de online. O exemplo é o arduino/examples/Ota (Atualização remota de firmware).
  • Atualização remota de firmware no ESP8266, pela própria conexão (15/11): sem memória para uma segunda sessão TLS, o ESP8266 recebe o firmware em pedaços pelo canal do SDK (FW_CHUNK, pedidos com FW_WANT, sem versão nova do protocolo), e o Updater do core 3.1.2 os grava no espaço livre. A assinatura Ed25519 é conferida antes do primeiro byte gravado e de novo relendo a cópia gravada, antes do Update.end(); o piso contra rebaixamento fica no setor do SDK na flash. O ESP8266 não volta sozinho de uma imagem nova que cai: a implantação para mais de uma placa exige antes uma placa-piloto com a mesma release aplicada, e o portal marca "ESP8266: sem volta automática". Layouts 4m1m e 4m2m; no 4m3m a placa recusa a oferta por falta de espaço. Provado em placa num ESP-12F (imagem boa aplicada, ~24 KB/s medidos em rede local; a queda de energia antes do end deixa a placa na versão de antes); a queda de energia durante a cópia do eboot ainda está em medição (ESP8266).
  • devui firmware: fases, notas da release e avançar a fase (15/11): o rollout para uma lista ou para o produto vai em fases por padrão (1 % → 10 % → 100 % das placas, com parada automática quando a taxa de falha passa do limite; --no-phases, --failure-pct, --failure-min e --phase-minutes); o status diz a fase e por que a implantação está pausada; o advance abre a fase seguinte à mão; o publish leva as notas da release (--notes ou --notes-file), que o portal, o app do dono e os e-mails ao dono mostram; uma release de ESP8266 para mais de uma placa sem a placa-piloto recebe 409 pilot_required, e a CLI diz o caminho. Na imagem do core Arduino-ESP32 o --version é obrigatório, como no ESP8266 (Referência da CLI).

0.2.0 (14/11/2026), protocolo 1.2

  • Atualização remota de firmware (OTA), no ESP-IDF (14/11): o componente opcional devui_ota (ports/esp-idf/devui_ota; no ESP Component Registry, thingface/devui_ota, da mesma versão do thingface/devui) atualiza a placa pela nuvem. O fabricante sobe o .bin do app no portal ou pela CLI, a nuvem o assina com a chave de firmware do produto e oferece a release pela própria conexão do SDK (FW_OFFER, sem versão nova do protocolo). A placa baixa por HTTPS direto do armazenamento e, antes do primeiro byte gravado, confere a assinatura Ed25519 (Monocypher 4.0.2, no NOTICE), o chip, o tamanho e o piso contra rebaixamento; grava o slot inativo, relê e confere o SHA-256 e a assinatura de novo antes de promover; e, na imagem nova, só se confirma depois de reconectar, do HELLO_ACK, de 60 s e do is_healthy do app, senão volta à anterior. Os ganchos on_offer, on_ready e is_healthy são opcionais; o progresso e o resultado chegam ao portal (FW_STATUS). Provado em placa no ESP32 e no S3; o C3, o C6 e o P4 compilam. O exemplo é o examples/ota e o guia, Atualização remota de firmware. Um app sem o devui_ota compila e roda como antes; o núcleo só anuncia as capacidades de OTA no HELLO quando ele está ligado. A biblioteca Arduino e o ESP8266 vêm depois.
  • O rollback do bootloader ligado nos exemplos (14/11): todo exemplo com a tabela de partições do SDK passa a ter CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y. O OTA não atualiza o bootloader, então um produto nascido de um exemplo já sai da primeira gravação por cabo pronto para voltar sozinho de uma imagem que morre antes de se confirmar.
  • devui firmware: publicar e implantar o firmware pela CLI (14/11): firmware publish <app.bin> --chip CHIP publica a release (--version, --security-version, --key-id, --commit), e firmware releases, rollout, status, pause, resume e complete cuidam das implantações, com a chave de publicação (ou o OIDC) e sem segundo fator; publicar e implantar pedem a chave de um administrador do produto. A saída padrão leva só o JSON da nuvem (Referência da CLI).
  • ESP8266 no Arduino: cada ponte de pilha na sua seção (14/11): o linker deixa de levar para todo sketch as funções que nada chama (sem isso, o Ed25519 do OTA iria para todo sketch do ESP8266, com ou sem OTA: +19 KB de flash e 1,8 KB de RAM). Nada muda no fio nem na API.

0.1.1 (11/11/2026), protocolo 1.2

  • ESP32 sem PSRAM no Arduino: buffers TLS dinâmicos, e o STOPPED com a memória de volta (11/11): no core Arduino 3.3 como ele vem, a sessão TLS do SDK parada prende ~40 KB (o mbedTLS pré-compilado usa buffers fixos), e num ESP32 sem PSRAM um segundo TLS do app (uma API HTTPS) pode não caber. A recomendação para esse caso é recompilar o mbedTLS do core com buffers dinâmicos pelo custom_sdkconfig do pioarduino, com os --wrap do link que o pioarduino não põe sozinho: a sessão parada cai para ~4 KB e o handshake de um segundo TLS pede 23 KB em vez de 54 KB (ESP32 sem PSRAM no Arduino). No SDK: o devui_stop passa a publicar DEVUI_STATUS_STOPPED só quando a sessão TLS já voltou ao heap (de 0,2 a 0,35 s depois, em vez de logo; com o cliente travado ao fechar, 20 s depois assim mesmo, com um aviso no log), para um app que pausa o SDK poder esperar por ele antes de abrir o próprio TLS; e a biblioteca Arduino para a família ESP32 deixa de levar o modo cofre, que ela já não oferecia (+3 KB de heap). Nada muda no fio nem na API.

0.1.0 (11/11/2026), protocolo 1.2

A primeira versão numerada: tudo o que está abaixo, de 13/10 até aqui. Placas que mandam 0.0.0 são de antes dela.

  • O SDK passa a ter versão (11/11): o número do SDK (devui_version(), o SDK_VERSION do HELLO) deixa de ser sempre 0.0.0 e sobe a cada mudança que chega à placa ou à CLI: o MINOR com o que é novo para quem usa o SDK, o PATCH com uma correção, abaixo de 1.0.0 até o lançamento. Duas placas com o mesmo número rodam o mesmo SDK; uma placa compilada antes da primeira versão segue mandando 0.0.0. A CLI (devui, no User-Agent), a biblioteca Arduino, o componente do ESP-IDF e o binding Rust levam o mesmo número. Esta página passa a ter um título por versão, com a data e a versão do protocolo, e o histórico de antes fica em "Antes do 0.1.0". Nada muda no fio nem na API (As versões do SDK).

Antes do 0.1.0 (sem número, 0.0.0)

O SDK não tinha número antes do 0.1.0: toda placa compilada de 13/10/2026 até ele manda 0.0.0. As mudanças desse tempo estão agrupadas pela versão do protocolo que cada uma trouxe.

Desde 26/10/2026, ainda no protocolo 1.2

  • A permissão da placa nos próprios registros (11/11): o device de cada tabela do banco passa a ser um objeto, {"device": [...], "account": [...]}, no molde do guest. O device.device, novo e obrigatório (pode ser []), diz o que a placa faz nos próprios registros (DEVUI_DB_DEVICE), que antes ela sempre lia e escrevia; o device.account é a lista de antes, nos registros da conta, com o mesmo padrão (só read). Uma tabela em que a placa só insere leva "device": {"device": ["insert"]}, e o que ela não pode volta DEVUI_DB_FORBIDDEN. A lista antiga ("device": [...]) é recusada: o devui tables push sai com o código 2 mostrando a forma nova, e a nuvem recusa de novo. As tabelas declaradas antes ficaram com as quatro ações nos próprios registros, o que a placa já podia, e o tables get as devolve na forma nova. No portal, a tela "Declarar tabela" vira uma grade de quem × escopo, e numa tabela nova a linha da placa nos próprios registros começa vazia. Nada muda no fio nem na API (Banco de dados).
  • devui unpublish: despublicar pela CLI (11/11): devui unpublish --project-key pk_... tira do ar a publicação do produto em vigor, em todos os dispositivos dele, como o botão Despublicar da página do produto, com a mesma chave (ou o OIDC) do publish; a saída diz o hash retirado. Com a interface do produto na nuvem, as abas ficam sem interface até a próxima publicação; no dispositivo, cada placa volta a servir a do próprio firmware. Sem publicação em vigor, ou com o produto travado (a publicação assinada fica), sai com o código 5 e o motivo, e nada muda (Referência da CLI).
  • O ESP32-C3 usa a tabela de partições do SDK, como o C6 (11/11): o exemplo do LED cresceu de 26.960 a 27.968 B por alvo desde 27/10 (18.432 B no C6), com o modo local, o banco, as preferências da conta e a recusa da interface do firmware, e não cabe mais no app de 1 MB da tabela de partições padrão do ESP-IDF no C3 (faltam 6.672 B, medido em 11/11 no build do exemplo com o ESP-IDF 5.5.5). O exemplo já usa a tabela do SDK em todos os alvos; o devui pack --target esp32c3 passa a avisar, como no C6, que o firmware com a interface não cabe na tabela padrão, e sem --target o limiar do aviso é o do S3. Nada muda na API.
  • DevUI.getPrefs na casca Arduino (11/11): o devui_get_prefs ganha o método da casca, como as outras funções de devui.h (o nome C sem o prefixo, em camelCase); uma adição à API v1.
  • As tabelas do banco são do produto (11/11): devui tables push tabelas.json --project-key pk_... confere o arquivo aqui, pelas regras da nuvem (o arquivo inválido sai com o código 2, com a tabela e o campo, sem sair da máquina), e grava as tabelas no produto, com a mesma chave (ou o OIDC) do publish; a resposta diz a versão nova. devui tables get mostra as tabelas em vigor, em JSON, prontas para um push. O devui pack não põe mais tabelas no manifesto: um tabelas.json ao lado de web/ é erro, com o motivo apontando para a aba "Banco de dados" do produto e para o devui tables, e o --tabelas saiu (Banco de dados).
  • O produto manda na interface (11/11): num produto com a interface na nuvem, a nuvem recusa o bundle que a placa anuncia com o REFUSAL 4 (DEVUI_REFUSAL_CLOUD_UI), e o SDK diz na serial por quê (bundle REJECT, REFUSAL 4: the product serves its interface from the cloud...) e segue conectado, como em todo REJECT; um SDK anterior registra o 4 como número. Para esse produto, o firmware pode sair sem interface (sem web/): o HELLO vai sem os campos do bundle, e as abas recebem a publicação do produto (Firmware sem interface).
  • O fuso e o idioma da conta dona na placa (10/11): o quadro PREFS (0x66) traz o fuso IANA, a regra POSIX dele e o idioma da conta dona, e o SDK anuncia que o conhece pelo bit 7 do OPTIONS. Aceito, o SDK guarda os três na NVS (sem regravar quando vêm iguais), avisa o app com DEVUI_EV_PREFS e, por padrão, aplica a regra com setenv("TZ", …) e tzset(), de modo que localtime() sai no fuso da conta, também num boot sem nuvem; devui_config_t.manual_tz desliga isso. Um PREFS fora das regras (a gramática POSIX do TZ) é recusado com 4400 e nada muda. O limbo e o devui_factory_reset() apagam as preferências e devolvem o TZ do firmware. devui_get_prefs() lê as guardadas; no modo local, o /_devui/env passa a dizer o locale e o time_zone da conta (ou null). Uma regra com hora de transição com sinal (America/Nuuk), que a newlib lê errado, não é aplicada. Exemplo novo: examples/hora-local (Preferências da conta).
  • Banco de dados simples pela conexão da placa (10/11): devui_db_insert, devui_db_update, devui_db_delete, devui_db_find, devui_db_aggregate e o genérico devui_db_request gravam, leem e somam registros das tabelas que o dono declarou, no escopo da placa (DEVUI_DB_DEVICE) ou da conta (DEVUI_DB_ACCOUNT), com o pedido e a resposta em JSON. O SDK monta o pedido e põe nele o escopo; o resultado chega ao callback uma vez (devui_db_result_t: o resultado da nuvem, a resposta em JSON, a espera pedida). No máximo 4 pedidos de uma vez (o quinto volta DEVUI_ERR_DB_LIMIT sem ir ao fio); sem resposta em 10 s, ou com a queda da conexão, DEVUI_DB_UNAVAILABLE. Sem nuvem, a chamada é recusada na hora, a não ser que o app ligue a fila (devui_db_queue, na RAM ou na NVS): as inserções esperam e vão na ordem quando a conexão volta, cada uma com um op_id sorteado na placa, para a nuvem não gravar duas vezes. Os métodos dbInsert... na casca Arduino; no ESP8266, a fila só na RAM. Exemplo novo: examples/banco (Banco de dados).
  • Arduino: a biblioteca pode deixar a Serial em paz (09/11): compilado com -D DEVUI_ARDUINO_SERIAL=0 (no PlatformIO, em build_flags, que chegam também à biblioteca), o DevUI.begin não chama Serial.begin e o SDK não escreve nada na Serial, no ESP32 e no ESP8266: nem a linha do código de pareamento, nem os avisos de onde está a chave, nem os erros do begin. É para a placa cujo pino de TX da UART0 aciona outra coisa (o relé no TX da ESP32-2432S028, a "Cheap Yellow Display"): o Serial.begin devolveria o pino à UART, e cada linha o faria comutar. O pareamento segue igual, e o código chega ao app pelos eventos DEVUI_EV_PAIR_CODE (pair_code, pair_url, pair_ttl_s) e DEVUI_EV_PAIR_CODE_ACCEPTED, para mostrar na tela ou na página da placa. Ficam fora do alcance da opção o log do próprio ESP-IDF (ESP_LOGx, os avisos do porte), que só chega ao pino enquanto ele é da UART (um pino tomado por pinMode não é), as mensagens de boot da ROM e, no ESP8266, a mensagem fatal de estouro da pilha do BearSSL, escrita direto nas UARTs. Sem a opção, nada muda (o padrão é 1). Sem mudança na API; no ESP8266, o Hello8266 compilado com a opção fica 8,7 KB menor na flash.
  • A nuvem que não conseguiu guardar o bundle pede "tente depois" (04/11): quando o armazenamento da nuvem falha no fim de uma subida, o BUNDLE_DONE vem com RESULT 5 e um RETRY_AFTER_MS, no lugar do 3 ("contêiner inválido") de antes. O SDK encerra a subida, avisa o app (DEVUI_EV_BUNDLE_REJECTED com result 5; no Rust, BundleRejected { result: 5 }) e registra na serial; a conexão segue. Passado o prazo, a própria nuvem pede o bundle de novo na mesma conexão (BUNDLE_WANT do 0), e a placa o sobe de novo, sem reconectar e sem derrubar abas; no máximo 5 vezes por subida, com a espera dobrando (de 1-2 min a 16-32 min). O último RESULT 5 vem sem RETRY_AFTER_MS, e a serial diz que a nuvem não pede mais nesta conexão. Sem mudança na API; o firmware anterior, que já atende o BUNDLE_WANT a qualquer momento, sobe de novo do mesmo jeito.
  • Modo local: a UI pela LAN e pelo AP do app (31/10, em revisão): com CONFIG_DEVUI_LOCAL, o devui_local() deixa de responder ESP_ERR_NOT_SUPPORTED e a placa serve a própria UI, a lib e o /_devui/env (mode: "local") em http://<IP da placa>/, atrás do login dela com a senha local (80 bits nascidos na placa; devui_local_secret a dá ao app para mostrar ao dono). Nunca em AP aberto. Cada aba local é uma sessão de 0x8000 a 0xFFFE, de tipo DEVUI_SESSION_LOCAL, papel operador; o tráfego na LAN é HTTP sem TLS. Adições à API v1: devui_local_secret, devui_local_secret_renew, DEVUI_SESSION_LOCAL e DEVUI_LOCAL_SECRET_SIZE (no Arduino, DevUI.localSecret e DevUI.localSecretRenew, que respondem ESP_ERR_NOT_SUPPORTED, como o local()). O ESP8266 fica fora. No exemplo LED, sdkconfig.localmode liga o modo (Modo local).
  • A placa atende a API de dispositivos (26/10): um servidor, um script ou outra placa manda uma mensagem ao dispositivo por POST /v1/devices/{id}/messages, com uma chave de acesso que o dono cria na página dele, e recebe a resposta do firmware (API de dispositivos). Na placa, cada chamada é uma sessão de tipo API (SESSION_KIND 2), que o SDK abre como a de uma aba; o tipo 1 (o túnel) e os desconhecidos continuam recusados com 4400. O SDK anuncia no HELLO que atende a API (bit 2 de OPTIONS), sempre, sem opção do firmware; o SDK anterior recusa a sessão, e a nuvem responde 422 firmware_sem_api a quem chama. Adições à API v1: DEVUI_SESSION_BROWSER e DEVUI_SESSION_API, o campo session_kind de devui_event_t (no SESSION_OPEN) e o campo kind de devui_session_info_t, os mesmos no Arduino (ESP32 e ESP8266). O firmware que não quer chamadas de máquina recusa pelo tipo da sessão. No perfil "8266", o HELLO de um app sem opções cresce 7 bytes (o OPTIONS). Exemplo novo: examples/api-chamada, uma placa que chama outra pela API, em ESP-IDF.
  • Uma placa chama outra pela própria conexão (27/10): devui_call(apelido, dados, tamanho, prazo_ms, callback, ctx) (C), call (Rust), DevUI.call (Arduino, ESP32 e ESP8266), uma adição à API v1. O dono liga as duas placas no portal com um apelido; o firmware chama pelo apelido, sem chave e sem segunda conexão TLS, e o callback vem uma vez, na task do SDK, com a resposta da outra placa ou o motivo de não ter havido (DEVUI_CALL_*, os nomes da API por HTTP, mais DEVUI_CALL_NOT_SENT e DEVUI_CALL_ERROR, do SDK) (Ligar um dispositivo a outro). No fio, os quadros CALL (0x24) e CALL_REPLY (0x25). A placa chamada vê uma sessão de tipo dispositivo (DEVUI_SESSION_DEVICE, 3; SessionKind::Device no Rust, uma variante nova do enum #[non_exhaustive]), que o SDK novo abre sempre e anuncia no HELLO (bit 3 de OPTIONS); o SDK anterior a recusa, e quem chama recebe DEVUI_CALL_UNSUPPORTED. O HELLO não cresce (o OPTIONS já ia). Exemplos novos: examples/chamar-outro (ESP-IDF) e arduino/examples/ChamarOutro (ESP32 e ESP8266).
  • Ações com nome no manifesto (27/10): o acoes.json ao lado de web/ (ou --acoes) entra no manifesto do bundle como acoes, e quem chama pela API pede a ação pelo nome (POST /v1/devices/{id}/actions/{nome}) (Ações com nome). devui pack, devui publish e devui_add_bundle validam a lista antes de gravar ou enviar (nome, descrição, papel mínimo, marcadores {{nonce}} e {{p:<nome>}} só como valor inteiro, parâmetros tipados, até 32 ações, payload final até 4 KB no pior caso, manifesto inteiro até 8 KB) e recusam apontando a ação e o campo. devui publish com ações manda o manifesto também sem assinatura (Devui-Manifest) e confere na resposta que a nuvem guardou as ações; elas só existem para o bundle publicado pela CLI (a placa nunca manda o manifesto). Sem o arquivo, o manifesto é o de antes, byte a byte; o firmware não muda.
  • O firmware fecha uma sessão (27/10): devui_session_close(sessao, motivo) (C), session_close (Rust), DevUI.sessionClose (Arduino, ESP32 e ESP8266), uma adição à API v1. Manda o SESSION_CLOSE com o motivo (um código de 1000 a 4999, ou 0 para nenhum) e esquece a sessão na hora, sem DEVUI_EV_SESSION_CLOSE; o que ainda estava na fila do SDK para ela é descartado. Com 4405, a recusa do firmware: o fluxo de eventos da API termina com o evento closed ({"erro":"proibido"}) e a chamada recebe 403 proibido (API de dispositivos). Serve também para a aba de uma pessoa. No ESP32, entra na fila do SDK atrás do que o app pôs antes (uma devui_reply à sessão sai antes do fechamento); no ESP8266, sai antes de a função voltar.
  • Mudança visível no binding Rust: o tipo da sessão em Event::SessionOpen e em SessionInfo. As duas ganham o campo kind: SessionKind (o enum novo, Browser, Api ou Other(u8), #[non_exhaustive]), o mesmo session_kind/kind do C. Diferente das outras mudanças desde 26/10, esta não é só uma adição: um campo novo numa variante e numa struct que já existiam quebra o código que desmonta Event::SessionOpen { session, role, reopened, user } ou SessionInfo { open, role } sem .., ou que monta um SessionInfo por literal. Conserto: acrescente kind ou .. ao padrão. Decisão de 26/10, preferida a uma função nova só para o tipo; a foto da API v1 (api/devui-rust-v1.txt) foi corrigida à mão nesses dois itens, e o SessionKind entrou nela como adição. O C e o Arduino não mudam.
  • A troca de dono vem assinada: o build leva a chave de posse da nuvem ao lado das raízes e das chaves de ordens (owner.pub.pem, e owner-next.pub.pem para a troca de chave, na pasta das chaves de ordens; o perfil dev leva a de staging do SDK). Com ela, uma geração da posse nova, pelo OWNER_CHANGED ou pelo HELLO_ACK, só vale com o OWNER_SIG da nuvem que confere para este device_id; sem assinatura, de outra chave ou com um byte trocado, a placa a ignora (nem evento, nem gravação) e a serial diz owner change ignored (<motivo>): generation <n>. Sem a chave no build, como antes. Nada muda na API. A troca de dono pelo limbo também (26/10): com a chave, o HELLO_ACK que tira a placa do limbo só dá PAIRED com a geração assinada; sem ela, a placa age como pareada naquela conexão (sem código nem botão), mas não avisa o app nem grava o dono (pairing not taken ... na serial), e o PAIRED vem no primeiro HELLO_ACK (ou OWNER_CHANGED) assinado. A chave de posse é obrigatória no release (desde 26/10): o build ESP-IDF de release sem owner.pub.pem (fixada como owner no production.sha256) falha no configure e no check-bin, e o pacote Arduino da produção (ESP32 e ESP8266) não sai sem ela; só o perfil dev e o endpoint de teste ficam sem. O endpoint ESP-IDF com as raízes fixadas como produção é release: só com as chaves de ordens e de posse fixadas, como o pacote Arduino.
  • O reset de fábrica vem assinado pela placa (30/10): o devui_factory_reset() com a conexão pronta assina o UNPAIR com a chave de identidade da placa (a mesma da assinatura do HELLO; ECDSA P-256 sobre SHA-256("devui.1/unpair\0" ‖ device_id)) e o manda com o TLV SIGNATURE; depois fecha com 1000 e apaga a chave, como antes. O HELLO passa a anunciar isso, sempre, no bit 4 de OPTIONS (UNPAIR_SIGNED), sem opção do firmware; a nuvem trava a placa ao ver o bit e, daí em diante, só marca o reset que a placa assinou: um gateway comprometido não reseta mais o registro de uma placa por conta própria. Se a assinatura falhar, o UNPAIR vai sem ela (a serial diz UNPAIR signature failed) e o reset acontece do mesmo jeito. Custo: uma assinatura P-256 por reset (o tempo na ESP8266 e no S3 ainda vai ser medido); o UNPAIR cresce de 8 para 75 bytes, e o HELLO não cresce (o OPTIONS já ia). A nuvem anterior ignora a assinatura. Nada muda na API. Desde 31/10: a placa que guarda a geração da posse assina também a geração, SHA-256("devui.1/unpair\0" ‖ device_id ‖ OWNER_GEN), com a geração em u32 little-endian. Com a identidade de fábrica o reset mantém a chave e o device_id, e o nonce determinístico daria a mesma assinatura em todo reset: presa à geração, que muda a cada pareamento, a assinatura de um reset nunca reseta o dono seguinte. Sem geração guardada, vai a mensagem de antes. A nuvem anterior a esta mudança recusa a assinatura com a geração (o reset não é marcado e a placa volta como dispositivo novo, ou, com identidade de fábrica, com o mesmo dono): publique a nuvem antes. Nada muda na API.
  • O HELLO diz onde a chave mora (30/10): todo HELLO leva o TLV KEY_STORE (2 bytes: o esquema e os sinais), e a nuvem calcula dele o nível de proteção da chave, mostra na frota e recusa o pareamento num produto que exige mais (PAIR_RESULT 4; a placa segue no limbo renovando o código, e a serial diz pairing refused: the key protection is below the product minimum (PAIR_RESULT 4)). O esquema sai do build: identidade de fábrica pela chave HMAC do eFuse (4), pelo periférico ECDSA (5) ou sob a flash encryption (3); sem CONFIG_DEVUI_FACTORY_ID, a NVS (1), e a NVS cifrada (2) só quando a chave está na partição NVS padrão de um build com CONFIG_NVS_ENCRYPTION (a partição devui nunca é cifrada pelo IDF: nvs_flash_init_partition não usa a NVS encryption). Os sinais são lidos do chip no boot: flash encryption, secure boot e eFuse virtual (para testes). ESP8266 e POSIX mandam NVS, sem sinal. O nível é autodeclarado: a assinatura do HELLO prova a chave, não onde ela mora. O HELLO cresce 5 bytes: no perfil "8266", o host mais longo que cabe com os demais campos no máximo cai de 41 para 36 caracteres (o do serviço tem 16). A nuvem anterior ignora o TLV. Nada muda na API.
  • O desvínculo e a troca da chave de posse vêm assinados (27/10). Só na placa com a chave de posse no build; sem ela, nada muda.
    • O desvínculo: na placa com uma geração guardada, o fechamento 4410 vira só um aviso (ela reconecta com o backoff normal, com o mesmo dono e a mesma geração). Quem leva ao limbo é o HELLO_ACK com OWNED = 0 e o UNOWN_SIG (76 bytes: a geração que termina e a assinatura dela, com as convenções do OWNER_SIG) de uma geração igual ou maior que a guardada (desde 27/10: a geração só sobe); aí, como antes: UNPAIRED, a geração apagada. De uma geração menor (um desvínculo antigo repetido depois de um pareamento novo: stale, sem conferir a assinatura), sem assinatura, de outra chave ou com um byte trocado, a placa fica com o dono e a geração, sem ERROR; a serial diz unown ignored (<motivo>), e a conexão segue sem sessão da nuvem e sem código de pareamento até cair ou até a nuvem fechá-la com 4410 depois de assinar. Sem geração guardada (nunca pareada com geração assinada, ou já no limbo), OWNED = 0 não pede assinatura. O reset de fábrica local continua sem assinatura. A nuvem com o desvínculo assinado vai antes do firmware com ele: a nuvem anterior manda o OWNED = 0 sem UNOWN_SIG, e a placa desvinculada por ela fica com o dono até a nuvem mandar a assinatura (ou até um reset de fábrica local).
    • A troca da chave de posse: o HELLO leva o OWNER_KEY_SEQ (a maior sequência de troca aceita; 0 se nenhuma), e o quadro novo OWNER_KEY traz a chave nova, a sequência e a assinatura de uma das chaves de posse que a placa tem. A sequência só sobe (igual ou menor: owner key ignored (stale); 0 é 4400), e a chave nova tem de ser um ponto de P-256 (senão, point); aceita, a chave nova vira a atual e a que assinou fica como a segunda até a próxima troca. As duas, com a sequência, ficam na NVS (devui.okeys) ou, no ESP8266, no setor próprio do SDK (um registro novo, a etiqueta 8; o setor já gravado nas placas é lido como antes), valem no lugar das do build também depois de reiniciar, e sobrevivem ao reset de fábrica, como as ordens de confiança; a troca que a gravação recusa não vale (owner key ignored (not stored)), e a nuvem a manda de novo. Custo: uma conferência P-256 por troca; no perfil "8266", 136 bytes a mais no devui_conn_t e 7 no HELLO. Um firmware anterior a este que encontre o registro novo no setor do ESP8266 (voltar de versão) o lê como gravação cortada e o descarta, com o que veio depois dele, na gravação seguinte.
  • A placa leva a assinatura da interface (26/10): com a chave do fabricante no build (devui_pack.py --sign-key <arquivo>, ou idf.py -DDEVUI_SIGN_KEY=<arquivo> build com devui_add_bundle, ou devui pack web/ --sign-key <arquivo> no Arduino), o empacotador assina o bundle e grava os 72 bytes da assinatura junto dele (devui_bundle_sig, bundle.sig); o SDK os manda no HELLO (BUNDLE_SIG), e a nuvem confere com as chaves do produto. Assinatura que não confere (chave desconhecida ou revogada, ou um byte mudado depois de assinar): a nuvem recusa o bundle (REJECT com REFUSAL 2), a placa segue conectada, a serial diz o motivo e a interface de antes continua. Conferida: o selo "Assinada" na página do dispositivo. Adições à API v1: o campo bundle_sig de devui_config_t deixa de ser reservado (72 bytes, ou ESP_ERR_INVALID_ARG), DevUIBundle.bundle_sig (Arduino) e Config::bundle_sig (Rust). Sem a chave, nada muda. A chave privada nunca entra no firmware.
  • O texto do evento de negócio recusa também os invisíveis (26/10): U+2028, U+2029, os controles bidirecionais (U+061C, U+200E, U+200F, U+202A–U+202E, U+2066–U+2069) e o BOM (U+FEFF); devui_audit responde ESP_ERR_INVALID_ARG. O ZWJ (U+200D) dos emoji compostos segue texto.
  • Interface assinada pela CLI: devui keygen cria a chave Ed25519 do fabricante, e devui publish --sign-key assina o manifesto (que cita o hash do contêiner); a nuvem confere com as chaves públicas do produto, registradas no portal, e a interface ganha o selo "assinada". Só a CLI muda: o firmware e o protocolo seguem os mesmos.
  • Eventos de negócio no log do dispositivo (26/10): devui_audit("abriu o portão") (C), audit (Rust), DevUI.audit (Arduino, ESP32 e ESP8266), uma adição à API v1. A placa diz só o que aconteceu: a nuvem grava o evento com a hora dela (a da placa vai à parte, quando o relógio dela vale) e com quem estava com a interface aberta; sem ninguém, o evento vale do mesmo jeito. Texto de 1 a 128 B (DEVUI_AUDIT_MAX) de UTF-8, sem quebra de linha nem outro caractere de controle. A nuvem diz no HELLO_ACK (AUDIT_QUOTA) que aceita o evento e quantos: 10 de uma vez e 360 por hora, por padrão, contados também na placa (DEVUI_ERR_OVER_QUOTA). Uma nuvem anterior não diz, e a função responde ESP_ERR_NOT_SUPPORTED; sem dono, ESP_ERR_INVALID_STATE. O dono vê os eventos na página de eventos do dispositivo, no portal.
  • Modo cofre: a cifragem de ponta a ponta por produto (31/10). Com CONFIG_DEVUI_VAULT no build (desligado por padrão) e devui_config_t.vault = true, as sessões de navegador do produto só trocam mensagens cifradas de ponta a ponta com a moldura do portal (Noise_XXpsk3_25519_AESGCM_SHA256; no ESP32, o X25519 Everest/HACL* que já vem no mbedTLS do IDF e o AES-GCM por hardware): a nuvem repassa tamanhos e horários, nunca o conteúdo. O PSK nasce na placa (32 B, com a guarda de entropia da chave) e sai para o usuário fora da nuvem: devui_vault_psk_text(texto, tamanho) dá o texto de 55 caracteres (11 grupos de 5, com conferência) para a tela, a etiqueta ou a serial; o código curto de pareamento não serve de PSK. A chave X25519 da placa vai atestada pela chave de identidade. A placa guarda a lista de acesso (até 8 usuários, o primeiro é o dono, o papel efetivo é o menos privilegiado entre o da lista e o da nuvem; devui_vault_enroll(false) fecha a inscrição; a troca de dono e a volta ao limbo apagam a lista; devui_vault_reset(novo_psk) apaga a lista e, com true, sorteia PSK e chave novos). O que muda para o app: o DEVUI_EV_SESSION_OPEN só vem quando o handshake da aba fecha, com o papel efetivo; a mensagem máxima fica DEVUI_VAULT_OVERHEAD (26) bytes menor; sem sessões da API de dispositivos nem de outra placa; a nuvem não guarda o último estado. No fio: o bit 6 de OPTIONS (VAULT) e a flag E2E em DATA. Adições à API v1: o campo vault, DEVUI_VAULT_OVERHEAD, DEVUI_VAULT_PSK_TEXT_SIZE, devui_vault_psk_text, devui_vault_reset, devui_vault_enroll, e os métodos DevUI.vaultPskText, vaultReset e vaultEnroll (Arduino; no ESP8266 respondem ESP_ERR_NOT_SUPPORTED). A HAL de cripto ganha duas primitivas opcionais, x25519 e aead, depois de ctx; o binding Rust ainda não liga o cofre.

Protocolo 1.2 (a partir de 16/10/2026)

  • Troca de dono avisada ao firmware: OWNER_CHANGED e OWNER_GEN, com a geração guardada na NVS; o app apaga os dados do dono anterior antes de voltar online.
  • Ordens de confiança (TRUST_ORDER): o tratador confere assinatura, escopo, origem e sequência, e aplica a troca de endpoint, de raízes ou de chaves depois dos 7 dias de funcionamento. Uma ordem também entra por um caminho local: devui_trust_order_local() (C), trust_order_local (Rust), DevUI.trustOrderLocal (Arduino), e o comando de fabricante 0xF0 do Improv no exemplo do LED (tools/improv_cli.py order).
  • Recusas do plano: QUOTA_KIND no ERROR (a franquia do mês), e o REJECT do upload e um BUNDLE_DONE recusado ditos na serial.
  • DEVUI_EV_CLOCK_SET, o teto da hora da nuvem, e devui_reply que só responde na conexão do pedido (DEVUI_ERR_STALE_REQUEST).
  • Arduino e PlatformIO: a biblioteca ThingFace (DevUI), o hello world, o pacote para o Library Manager e o PlatformIO, e o Serial no USB nativo do C3 e do S3.
  • Ordens no pacote Arduino (25/10): o pacote leva as três chaves de ordens junto das raízes (src/devui_trust_gen.h) e liga o tratador do TRUST_ORDER no ESP32 (devui: ordens: tratador ligado na serial); as da produção andam com as raízes dela (as de staging até a cerimônia), e --order-keys DIR dá outras a um --endpoint. A conferência do pacote reprova um com raízes e sem as três chaves.
  • ESP8266 (18 a 21/10): a mesma biblioteca Arduino no core ESP8266 3.1.2, com o perfil "8266" (mensagens de até 1 KB, até 4 abas, sem ordens assinadas), a pilha própria do BearSSL com zona de guarda e o exemplo Hello8266 (O SDK no ESP8266).
  • Diagnóstico da queda no HELLO (21/10): LAST_DROP, o motivo do OFFLINE da última conexão que ficou online (0 na primeira do boot) com o código de fechamento, e WIFI_RSSI, o sinal do Wi-Fi em dBm, nos portes ESP-IDF (sem RSSI na P4) e ESP8266; a nuvem os mostra na saúde do dispositivo.
  • Exemplos: Olá, Formulário e Painel ao vivo, no ESP-IDF e no Arduino; o adaptador do ESPUI (ThingFaceESPUI).
  • Linha do código na serial: o SDK, e não o exemplo, escreve devui: pair code XXXX-XXXX ttl=NNN uma vez por código que vale na nuvem (o novo, o renovado ou o que volta da NVS, depois de chegar à nuvem); é a linha que o portal lê pela USB. A linha em português dos exemplos saiu (Quickstart).
  • Improv pelo BLE (opcional: sdkconfig.ble no exemplo do LED, só na família ESP32): o mesmo núcleo do Improv Serial (Wi-Fi e URL de redirecionamento com a base do HELLO_ACK), e uma característica GATT própria que dá o código de pareamento atual enquanto a placa não tem dono; o cliente de PC tools/improv_ble.py. Custa ~99 KB de heap no ESP32 sem PSRAM (o README do exemplo do LED). Desde 25/10, com dono o BLE só fica ligado nos 2 primeiros minutos depois do boot, aceitando Wi-Fi nessa janela, e depois desliga de vez, devolvendo ~69 KB de heap no ESP32 (~56 KB no S3).
  • DEVUI_EV_PAIR_CODE_ACCEPTED (25/10, adição no fim do enum, nos portes ESP-IDF e ESP8266; Event::PairCodeAccepted no Rust): o código atual está registrado na nuvem, a cada envio, com o código, a URL e o tempo que resta. A característica do código e a URL do Improv do exemplo do LED esperam por ele. Desde 25/10 ele vem da confirmação explícita da nuvem, o PAIR CODE_ACK, conferida contra o código atual, e não mais de 2 s sem um 4429 (que davam por aceito também o código que a nuvem não guardou). Com uma nuvem sem o CODE_ACK, o evento não vem.
  • A linha devui: pair code espera o CODE_ACK (25/10): sai na hora em que a nuvem confirma o código atual, em vez de 2 s depois do envio. Com uma nuvem sem o CODE_ACK, sai 5 s depois do envio, se não veio um 4429 (a regra de antes, com 5 s). Depois do primeiro CODE_ACK do boot, essa espera desliga: um código que a nuvem não confirmou (um que ela não guardou) não ganha a linha. devui_pair_code_trusted() e DEVUI_PAIR_NO_ACK_WAIT_MS (devui/devui_conn.h, cabeçalho do núcleo fora da API v1, que trocou o DEVUI_PAIR_LINE_AFTER_MS) são a regra, que o exemplo do LED também usa para a característica do BLE e a URL do Improv.
  • O link de um código entregue offline continua valendo (25/10): pedido antes da primeira conexão do boot, o código guardado do boot anterior é o que sai (com o tempo máximo, acertado na conexão), em vez de um novo que cedia o lugar a ele e matava o link entregue; com 60 s ou menos restando, um novo toma o lugar.
  • Ferramentas: a CLI de publicação (devui pack e devui publish), a página de instalação pela USB (ESP Web Tools e Improv), e a documentação gerada do repositório.
  • DEVUI_EV_DUPLICATE emitido (25/10, adição): os portes ESP-IDF e ESP8266 passam a mandá-lo quando a nuvem fecha a conexão com 4409 (outra placa com a mesma identidade tomou o lugar), logo depois do DEVUI_EV_OFFLINE dessa queda (que continua saindo, com close_code 4409), ou sozinho se o 4409 veio antes do DEVUI_EV_ONLINE. O evento estava declarado desde o protocolo 1.0 e nenhum porte o emitia. A doc também deixou de dizer que o SDK descarta o pedido que esperou demais na fila do app: quem confere essa espera é o app (Os níveis de confirmação), e DEVUI_ERR_STALE_REQUEST quer dizer "a conexão do pedido acabou", não "pedido velho".
  • C3 no PlatformIO (25/10): o ambiente esp32c3 de arduino/platformio ganhou ARDUINO_USB_MODE=1 (sem ele o build parava em "USBSerial was not declared") e a flash em DIO (board_build.flash_mode = dio): um app em QIO numa C3 de bootloader ou flash DIO lê a NVS errado, apaga a partição devui a cada boot e troca o device_id (README do Arduino).

Protocolo 1.1 (14 a 16/10/2026)

  • Pareamento: código de 8 caracteres na serial, pelo botão, o resultado e o reset de fábrica; o código sobrevive a um reinício.
  • Fila de envio com TX_READY, cota local, keepalive do servidor e mensagens em pedaços.
  • Confiança: perfis de build (release com as raízes de produção fixadas, desenvolvimento com as de staging), o piso de relógio que sobe pelas folhas verificadas, e uma tabela de partições só para ESP-IDF, Rust e Arduino, com a identidade numa partição própria (devui).
  • Improv Serial no exemplo do LED, o pacote do ESP Component Registry e o binding Rust interno, com o exemplo no S3 e na P4.
  • API congelada (devui.h e o binding Rust), conferida a cada build.

Protocolo 1.0 (13/10/2026)

  • O núcleo C99 do devui.1, os portes POSIX e ESP-IDF, o empacotador da interface e o exemplo do LED, nos cinco chips (ESP32, C3, S3, C6 e P4).