Skip to content
ThingFace

Remote firmware update (OTA)

devui_ota is the SDK's optional component that updates the board's firmware through the cloud. The maker uploads the .bin in the portal (or with the CLI); the cloud signs it with the product's firmware key and offers the release to the boards over the SDK's own connection (FW_OFFER). The board downloads the artifact by HTTPS straight from the storage (Cloudflare R2, a signed URL valid for a few minutes) and:

  1. before the first byte written, checks the header: the Ed25519 signature of one of the keys of the ring, the chip, the size and the anti-downgrade floor (security_version, kept in the board's NVS);
  2. writes the inactive slot (esp_ota_begin with OTA_WITH_SEQUENTIAL_WRITES, yielding the core every 32 KB);
  3. reads the slot back from the flash, checks the SHA-256 and the signature again, and only then promotes it;
  4. restarts (or lets the app decide when) and, in the new image, confirms itself or goes back to the one before.

An app without devui_ota builds and runs as before. The OTA is the ESP-IDF's (proved on boards on the ESP32 and the S3; the C3 builds) and the Arduino library's: on the ESP32 with the core 3.3 (Arduino-ESP32) and on the ESP8266, over the SDK's own connection and with smaller guarantees (ESP8266). The examples are examples/ota and arduino/examples/Ota.

Turning the OTA on

What the firmware needs:

WhyWhere
The SDK's partition table, with ota_0 and ota_1the OTA writes the slot that is not runningCONFIG_PARTITION_TABLE_CUSTOM_FILENAME naming the partitions.csv of the devui component
CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=ya new image that dies before confirming goes back to the one before by itselfsdkconfig.defaults, before the first flashing by cable (see Bootloader without rollback)
The curve P-384 in the mbedTLSthe storage's roots are P-384 keys (The bundle of CAs)do not turn CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED off; without it the build stops
The ESP-IDF's bundle of CAsit checks the storage's chainCONFIG_MBEDTLS_CERTIFICATE_BUNDLE=y (the IDF's default)
The product's firmware public keythe board takes only what this key signedCONFIG_DEVUI_OTA_KEY_1 (The key)

The component: in the repository, ports/esp-idf/devui_ota, beside devui (the EXTRA_COMPONENT_DIRS of ports/esp-idf brings both); in the ESP Component Registry, the package thingface/devui_ota, which depends on thingface/devui of the same version. main names devui_ota in its PRIV_REQUIRES, and the app calls devui_ota_begin once, after nvs_flash_init and before devui_start:

#include "devui_ota.h"

devui_ota_options_t ota = {
    .hooks = {.on_offer = on_offer, .on_ready = on_ready, .is_healthy = is_healthy}, /* all three optional */
};
ESP_ERROR_CHECK(devui_ota_begin(&ota)); /* keys NULL: the ring of CONFIG_DEVUI_OTA_KEY_1..4 */
ESP_ERROR_CHECK(devui_start(&cfg));

The PROJECT_VER of the project's CMakeLists.txt is the version the portal shows and the one the release carries: raise it for each release. The OTA belongs to the paid plans: the product's Firmware tab shows only on them.

The firmware public key

The portal shows the product's firmware public key in hex, 64 characters (Product > Firmware > Firmware key, "Public key (hex)", with the Copy button). Paste it into the sdkconfig (in the product's sdkconfig.defaults: the key is public and may go to git):

CONFIG_DEVUI_OTA_KEY_1="d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"

(that value is a test vector of RFC 8032, not a product's key). The build checks the text: 64 hex characters, upper or lower case, not all zeros, no key twice and no gap in the ring. A typo stops idf.py build with the message devui_ota: CONFIG_DEVUI_OTA_KEY_1 não é uma chave pública, instead of becoming a fleet that refuses every update. With no key at all, the build passes and devui_ota_begin returns ESP_ERR_INVALID_ARG with a warning in the log (the example goes on without OTA).

The ring holds up to 4 keys, in the portal's order (CONFIG_DEVUI_OTA_KEY_1 to _4). The board takes a release signed by any of them, and nothing over the wire changes the ring. To change the key: rotate it in the portal, put the new one in CONFIG_DEVUI_OTA_KEY_2 (keeping the old one in _1) and publish that release, which is still signed by the old key. Take the old key out of the ring only when every board in the field runs a build that has the new one.

Whoever keeps the keys elsewhere passes the ring in code, and it is used instead of the sdkconfig's:

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

The 32 bytes come from the portal's hex like this:

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

The app's hooks

All three are optional and run in the SDK's task: they read the app's state and return at once, without blocking and without calling the SDK's API from inside them.

HookWhenWhat it returnsWithout it
on_offer(ctx, offer, &retry_after_ms)an offer came (offer->version, release, size), before downloadingDEVUI_OTA_ACCEPT; DEVUI_OTA_DEFER (deferred; *retry_after_ms says when to offer it again); DEVUI_OTA_REFUSEaccepts
on_ready(ctx, release)the image was downloaded, checked and promotedDEVUI_OTA_RESTART_NOW, or DEVUI_OTA_RESTART_LATER and the app calls devui_ota_restart_now() when it canrestarts by itself in 2 s (a board with no screen has no one to press)
is_healthy(ctx)in the new image, 60 s after the HELLO_ACKtrue to keep it; false goes back to the one beforehealthy

The usual use: do not download nor restart in the middle of a sale, a dose or a print (defer in on_offer, RESTART_LATER in on_ready), and confirm the new image only when what matters in the product works (the sensor answers, the screen drew, the main task is alive). examples/ota shows all three with a "busy" switch on the page. devui_ota_state() tells the phase (DEVUI_OTA_IDLE, _DOWNLOADING, _PROMOTED, _CONFIRMING).

The confirmation and its deadline

After the restart, the new image confirms itself when it reconnected to the cloud, got the HELLO_ACK, stayed up 60 s and is_healthy agreed. Only then does the SDK call esp_ota_mark_app_valid_cancel_rollback, raise the security_version floor and send FW_STATUS aplicada. An image that restarts (or is switched off) before that goes back to the one before at the next boot: that is what one wants of an image that hangs, and it is also what happens to a board unplugged too early.

The deadline is to reconnect: if the new image gets no HELLO_ACK by 10 minutes after the boot (no network, the cloud out of reach), the SDK goes back to the image before. Reconnected within the deadline, the 60 s up and is_healthy go on to their end even past the 10 minutes (a board that reconnects at 9 min 30 s confirms itself at 10 min 30 s; an is_healthy false goes back at once). For an image that reconnects but never stays up 60 s in a row (the connection drops before each end, and the count starts again), there is a safety cap: the deadline plus 5 minutes (or plus the 60 s and 1 minute, when confirm_ms is above 4 minutes); there, the SDK goes back to the one before. The deadline is the app's, in the sdkconfig:

CONFIG_DEVUI_OTA_CONFIRM_DEADLINE_S=600

(from 120 s to 24 h). Give more to a product whose network may take long to come back after a restart (a gateway that boots slowly, a cellular modem); never less than the time to connect. devui_ota_options_t.confirm_deadline_ms, when not 0, is used instead.

If esp_ota_mark_app_valid_cancel_rollback fails, the SDK tries once more; failing again, the image stays unconfirmed: the floor does not rise, no aplicada goes, FW_STATUS falhou goes with error 13 (flash, the esp_err_t in FW_DETAIL), and the SDK does not revert by itself. The bootloader decides at the next restart: if it goes back to the image before, that one tells revertida (18); if it keeps the new one, the new one confirms itself again at that boot.

The brake

The board keeps in the NVS the release it is trying (the mark ota_em_curso) and how many times in a row it failed. Three failures in a row of the same release, whatever failed (the network, the HTTP, the deadline with no new bytes, an expired URL, memory, the image, the signature, a restart in the middle), or a single reversion (the new image went back to the one before), suspend that release on the board: it refuses it from then on (FW_STATUS with the reason "suspensa"), and the portal shows why. A success zeroes the count. The suspension holds only for that release: a new release is offered as usual. Refusing or deferring an offer (on_offer, the wrong key, the floor) is no failure and does not count; nor is an offer that comes while the task of the download before still closes its TLS connection: it gets recusou with the reason "ocupado", which the cloud offers again.

Why even the network's failures count: a release that never finishes downloading on a board (a network that always drops at the same point, an image too big for the URL's lifetime) would hold the board in a loop of downloads; after three, it stops trying and the fleet shows who was left behind.

The bundle of CAs

The download checks the storage's certificate (Cloudflare R2, <account>.r2.cloudflarestorage.com) with the ESP-IDF's bundle of CAs (esp_crt_bundle), complete by default: the IDF's CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL, ~63 KB more flash. Complete, because Cloudflare changes the CA of its certificates whenever it wants (today it uses Google Trust Services, Let's Encrypt, SSL.com and Sectigo), and a board that stops recognising the storage's CA downloads nothing more, not even the update that would fix it.

What was checked on 14/11/2026, with a real TLS connection to the R2 (openssl s_client) and the chain received checked by the mbedTLS of ESP-IDF 5.5.5 built on the PC:

  • the R2 has two certificates and picks by what the client offers. With ECDSA suites (the SDK's), it sends the ECDSA chain: r2.cloudflarestorage.com (P-256) ← WE1 (P-256) ← GTS Root R4 (P-384), in TLS 1.2 ECDHE-ECDSA-CHACHA20-POLY1305. With ECDHE-RSA only, it sends the RSA chain (WR1 ← GTS Root R1);
  • no ECDHE_RSA is needed: the mbedTLS cut of the examples (CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=n) negotiates with the R2;
  • P-384 is needed: WE1 is signed by GTS Root R4 with ECDSA P-384/SHA-384. With P-384 off (the cut of the examples without OTA), the mbedTLS cannot read the root's key and the chain does not verify (The certificate is not correctly signed by the trusted CA); with it, it verifies. So devui_ota does not build without CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED, and examples/ota keeps P-384 (the rest of the cut is the other examples').

The minimal one, as an option: CONFIG_DEVUI_OTA_CA_MINIMAL=y (menuconfig > devui_ota) swaps the IDF's bundle for the ECDSA roots of Cloudflare's CAs (GTS Root R3 and R4, ISRG Root X2, SSL.com Root Certification Authority ECC, SSL.com TLS ECC Root CA 2022, USERTrust ECC Certification Authority and Sectigo Public Server Authentication Root E46, in ports/esp-idf/devui_ota/ca/minimal.pem, copied from the IDF's bundle). It saves ~63 KB of flash (measured below). It is offered only with ECDHE_RSA and TLS 1.3 off, so the storage always sends its ECDSA chain. The risk is the one above: if Cloudflare moves to a CA outside the list, the boards with the minimal set stop updating for good. Use it only when the flash does not fit.

examples/ota (IDF 5.5.5, the SDK's -Os)ESP32ESP32-C3ESP32-S3
Complete bundle (the default)1,076,480 B1,157,264 B1,081,104 B
Minimal (CONFIG_DEVUI_OTA_CA_MINIMAL)1,012,512 B1,092,944 B1,017,040 B

Care in the app: the cache during the writes

Writing the flash turns its cache off while each write and each erase lasts. In that interval only what is in IRAM runs: an interrupt that is not IRAM-safe waits until the write ends (the screen flickers, the audio stutters, a UART byte is lost), and one marked IRAM that touches code or data in the flash takes the board down (Cache disabled but cached memory region accessed). During an OTA this repeats for the whole download, several times a second. In ThingFace this is the maker's app's concern, and each driver has its option:

  • Screen: a DSI screen was stable only with CONFIG_LCD_DSI_ISR_CACHE_SAFE; for the RGB bus, CONFIG_LCD_RGB_ISR_IRAM_SAFE, and LVGL with its buffers in internal RAM.
  • Audio: the I2S needs CONFIG_I2S_ISR_IRAM_SAFE for the I2S not to stutter.
  • Others: CONFIG_GPTIMER_ISR_CACHE_SAFE, CONFIG_UART_ISR_IN_IRAM, CONFIG_GPIO_CTRL_FUNC_IN_IRAM, and IRAM_ATTR (with the data in DRAM) on every ISR of your own that must run during the download.

The SDK already yields the core every 32 KB written, to the watchdog and the other tasks (an erase in one block holds the core for seconds, and the watchdog takes the board down). Count on the memory too: during the download two TLS sessions are open (the SDK's and the download's); we measured 113 KB of minimum heap on the C3 with both.

Bootloader without rollback

The rollback lives in the bootloader, and the OTA never updates the bootloader: what the board got at its first flashing by cable is what it has for good. A board flashed without CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE does not come back by itself from an image that hangs at boot; no remote update fixes that, only flashing the bootloader again by cable. That is why every SDK example with the two-slot table has it on already (it costs only in the bootloader, nothing in the app), and tests/test_examples.py fails the example that turns it off.

The board says in the HELLO whether it has rollback (FW_CAPS): the portal shows "no rollback" in the fleet and asks for a second confirmation before starting a rollout on it. A board whose bootloader was built with the option but that still boots a new image as NEW (an old bootloader flashed underneath) becomes "no rollback" too.

Flashing by cable after an OTA

After an OTA the board runs from ota_1 (or ota_0), and otadata keeps that choice. The whole idf.py flash writes a blank otadata with the app (the board goes back to ota_0), but idf.py app-flash, or an esptool write_flash of the app alone, writes the new app to ota_0 and leaves otadata alone: if the board was on ota_1, it keeps booting the OTA's image, and the flashing seems not to have taken. When in doubt, erase otadata too:

idf.py -p COMxx erase-otadata flash

(or python -m esptool --chip esp32 -p COMxx erase_region 0xe000 0x2000 with the SDK's table). The board's identity does not change: the key lives in the devui partition. The board says in the HELLO which partition runs, and the SDK tells by the image's identity (its SHA-256) that the board no longer runs the OTA's release and stops announcing it. Do not flash by cable while a new image waits for its confirmation: the SDK takes the change for a reversion and suspends that release on the board.

The poison test

The positive control of the rollback is an image that hangs on purpose: the "poison" that comes with the SDK, among the OTA's test tools, an app that prints VENENO|<target>|... and calls abort() right at boot. Before releasing the OTA of a product, publish it as a release to a test board running the product's firmware, and check that:

  1. the board downloads, checks and restarts into the new image;
  2. the poison panics, and the bootloader goes back to the image before at the next boot;
  3. the board comes back to the cloud with the version before, sends FW_STATUS revertida and suspends that release (the portal shows the reversion).

If the board stays in a panic loop, its bootloader has no rollback (Bootloader without rollback): flash it by cable with the right bootloader before releasing the OTA to the fleet.

Arduino-ESP32

The Arduino library carries the same devui_ota, built inside the core 3.3 (which brings the ESP-IDF 5.5): the HTTPS download, the writing of the inactive slot, the read back, the confirmation and the rollback are the ones above. The key comes in hex, as the portal shows it, and the OTA is turned on before DevUI.begin:

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

devui_ota_hooks_t hooks = {};          // on_offer, on_ready and is_healthy, all three optional
hooks.is_healthy = healthy;
DevUIOta.begin("<the portal's Public key (hex)>", &hooks);
DevUI.begin(cfg);                      // cfg.fw_version: the version the release carries

DevUIOta.begin refuses with ESP_ERR_INVALID_ARG (and says it on the serial) a text that is not a key: fewer or more than 64 hex characters, only zeros, a key twice in the ring. The whole ring (up to 4, after a rotation) goes in DevUIOta.begin(keys, n, &options). DevUIOta.restartNow() and DevUIOta.state() are devui_ota_restart_now() and devui_ota_state(). The example is arduino/examples/Ota.

What changes from the ESP-IDF:

  • The partition table is the SDK's, the partitions.csv the package puts in each example's folder (on PlatformIO, board_build.partitions with the package's extras/partitions.csv): two app slots. The core's default table has two slots as well, but not the key's partition devui (Arduino).
  • The core 3.3's bootloader already has rollback (CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE in the core's prebuilt libraries): every board flashed by the core 3.x goes back by itself from an image that dies before confirming.
  • The core would confirm the new image by itself. The core's initArduino calls esp_ota_mark_app_valid_cancel_rollback() at the boot, before setup(), unless the app overrides the weak function verifyRollbackLater(). The library overrides it: it returns true while an image the SDK's OTA promoted waits for the SDK's confirmation (the record devui.fw_pend in the SDK's NVS), and false in any other case, so an image that came another way (the app's own Update, ArduinoOTA) is still confirmed by the core as before. Without this override the health check would decide nothing: the poison that dies after the boot would never go back. A sketch with its own verifyRollbackLater() does not link (a repeated definition): take its own out.
  • Every new image keeps DevUIOta.begin. What confirms the new image is the SDK's OTA, and DevUIOta.begin is what turns it on. A release without it does not confirm itself the right way: built with the Arduino IDE, no one confirms it and it goes back to the one before at the next restart; built with PlatformIO, the core confirms it at the boot, with no health check, and the board is left without OTA (the next release only by cable).
  • The curve P-384 and the complete bundle of CAs come in the core's libraries (CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED and CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL), and the recipe of ESP32 without PSRAM does not turn them off. A custom_sdkconfig that turns them off leaves the build with a warning and DevUIOta.begin refusing with ESP_ERR_NOT_SUPPORTED: without them the firmware does not download. The minimal bundle of CAs (CONFIG_DEVUI_OTA_CA_MINIMAL) does not exist on Arduino.
  • The confirmation's deadline is the same, 10 minutes; another goes by -DCONFIG_DEVUI_OTA_CONFIRM_DEADLINE_S=900 in the build, or in the options' confirm_deadline_ms.
  • The version the fleet shows is the sketch's, cfg.fw_version. An image of the Arduino IDE (and of arduino-cli) carries in its esp_app_desc_t the version of the core's libraries (on 3.3.12, 6671d0b), the same in every sketch: the release asks for --version. One of pioarduino with custom_sdkconfig (the recipe of the ESP32 without PSRAM) carries the project's, 1 by default, and the release takes only that one: --version 1, or the project's version in the custom_sdkconfig (CONFIG_APP_PROJECT_VER_FROM_CONFIG=y and CONFIG_APP_PROJECT_VER).
  • Two TLS sessions during the download. On the core 3.3.12 the SDK online costs ~82 KB of heap, ~41 KB of which are the fixed buffers of one TLS session (16 KB in and out), and the download's session asks as much again. Measured with an image of 1.2 MB, 8-bit heap (the S3 on a local network, the ESP32 in the production):

    • S3 without PSRAM, the core as it comes: ~70 to 75 KB less than online; the lowest 92 to 97 KB;
    • classic ESP32 without PSRAM, the core as it comes: ~78 KB free online and a lowest of 15.6 to 18.3 KB in the download. It passes, with no margin left for the app;
    • the same ESP32 with the recipe of ESP32 without PSRAM: ~131 KB free online and a lowest of 69 KB.

    On a classic ESP32 without PSRAM, use the recipe (dynamic buffers): it serves the download's session too. On the ESP-IDF, with dynamic buffers, the lowest was 172 KB on the ESP32 and 87 to 113 KB on the C3.

What the OTA adds to the example, measured on the core 3.3.12's build (the same sketch with and without the calls of DevUIOta): +126 KB of flash on the ESP32 and +130 KB on the C3 (almost all of it the HTTP client and the bundle of CAs, 69 KB; on the ESP-IDF, from +133 to +141 KB), and 1.6 KB of static RAM.

ESP8266

The ESP8266 receives the firmware over the SDK's own connection: there is no memory for a second TLS session that checks the server. The cloud sends the artifact in pieces of up to 1,008 B (FW_CHUNK), which the board asks for with FW_WANT (the offset and the credit, four pieces at a time by default; the options' window changes it), and the core 3.1.2's Updater writes the image in the free space below the file system. At the next restart, the core's eboot copies it to the start of the flash, over the old one. The API is the ESP32's (DevUIOta.begin with the key in hex), and so is the example.

What stays the same: the header's Ed25519 signature is checked before the first byte written (the same Monocypher as the ESP32's, on the port's stack of 7 KB, not on loop()'s 4 KB; 140 ms at 160 MHz, 280 ms at 80 MHz); the image's SHA-256 is checked as it streams and again reading back the copy written (with the byte 2, the flash mode the Updater rewrites, given back to the image's), with the signature once more, before Update.end(). Without the end the eboot copies nothing: a wrong signature, a copy that does not check or a drop before the end leave the board as it was. The anti-downgrade floor (security_version) lives in the SDK's sector of the flash (0x3FA000), the board key's, out of the reach of the Updater, the file system and the app's EEPROM; the factory reset keeps it. The brake is the same (three failures in a row, whatever failed, suspend the release on the board).

What is lost:

ESP32ESP8266
A new image that diesgoes back by itself to the one beforedoes not go back: after the copy the one before no longer exists; only the cable fixes it
Confirmationreconnected, 60 s, is_healthyaplicada at the new image's first HELLO_ACK; is_healthy is never called
Power cut before the endstays on the image it hadthe same
Power cut after the end, before the restartthe new image bootsthe eboot's command (in the RTC's memory) is lost: the board stays on the one before, and the cloud gets falhou (interrompido)
Power cut during the eboot's copydoes not applymay need the cable: the copy takes ~6.3 s (470 KB) and the eboot does not resume it; what is left at the start of the flash is a mixture of the two images. In 3 of 4 cuts measured the board went into a restart loop and only came back by cable; in the other the mixture ran (the two images differed in 6 bytes), the board reported falhou (interrompido) and the next offer mended it. The identity (the SDK's sector) survived all four
The HELLOFW_CAPS with URL and rollbackFW_CAPS with the channel and no rollback; the portal marks "ESP8266: no automatic way back"

So, on the ESP8266:

  • the new image has to keep the SDK up and DevUIOta.begin: the SDK is what brings the next OTA. A release that does not connect to the cloud, or that does not turn the OTA on, only leaves by cable;
  • the rollout to the fleet needs a pilot board: the same release applied and confirmed first on a board the maker chooses;
  • the flash layout needs free space: eagle.flash.4m1m.ld (the PlatformIO's default for the nodemcuv2 and the esp12e) or 4m2m (the Arduino IDE's default). On 4m3m (and 2m1m) the file system starts where the sketch's area ends, the board announces FW_SPACE 0 and refuses every offer with the reason espaco.

Care:

  • After flashing by cable, press reset (or power it off and on): the board that leaves esptool is still in the flashing mode, and the Updater refuses (UPDATE_ERROR_BOOTSTRAP).
  • The core's Update.begin turns the Wi-Fi's power saving off (wifi_set_sleep_type(NONE_SLEEP_T)), and it stays so.
  • Do not use the core's Update in the app during an SDK's OTA: one writer of the free space (the SDK refuses the offer with another under way, and your Update.begin refuses while the SDK writes).
  • The board recognizes the image it runs by the SHA-256 of the sketch in the flash: at the boot of a board that already did an OTA this takes, for 400 KB, 0.45 s at 160 MHz and 0.84 s at 80 MHz (the read back, measured).
  • The OTA's state takes ~190 B of the SDK's sector per OTA; a board with an owner compacts the sector once every twenty OTAs or so, and a power cut exactly during that compaction costs the identity (the single sector's risk as ever, ESP8266).

What the OTA adds, measured on the core 3.1.2's build (the same sketch with and without the calls of DevUIOta, layout 4m1m): +38 KB of flash (21 KB of it Monocypher) and 4.4 KB of static RAM (1.8 KB are Monocypher's constants, which the core puts in the DRAM). During the download, the Updater takes 4 KB more of the heap (the buffer of one sector). A sketch without the OTA carries none of this.

The channel's window (the options' window, in bytes) is four pieces (4,032 B) since 0.4.0. Measured on 16/11 through the production, on an ESP-12F at 160 MHz, an image of 473 KB: with 1 piece, 99 s from the acceptance to the image ready (~4.7 KB/s) and 12,256 B of heap at the lowest; with 2, 73 s and 11,360 B; with 4, 57 s (~8.3 KB/s) and 11,088 B. A sketch with little heap to spare goes back to one piece with window = 1008.

The offline keys

Without OTA, the firmware's endpoint and roots of trust change only by an order signed by the platform's offline keys. With the OTA on, the cloud signs the firmware, and a new firmware may bring another endpoint and other roots without that order. This was accepted and recorded: the OTA is optional per product, and whoever does not turn it on keeps the guarantee of the offline keys. The portal warns at the product's first release, and the product's declaration of conformity says which of the two it is.