Jan Beran

View on GitHub

Úkol 4: Aktualizace na dálku (OTA)


Poznámka: Tohle je volitelná kapitola. Pokud nestíháte, můžete přeskočit rovnou na Úkol 5: ESP-NOW chatovací místnost.

V reálném nasazení nebudete mít fyzický přístup k USB portu, abyste nahráli nový firmware. Aktualizace Over-The-Air (OTA) umožňují stáhnout a nainstalovat nový firmware přes síť, například Wi-Fi.

Jak OTA na ESP32 funguje v kostce: ve flashi nejsou jeden, ale dva aplikační sloty. Zařízení vždy běží z jednoho z nich (aktivního slotu) a ten nikdy nepřepisuje. Nový firmware se zapíše do druhého, neaktivního slotu, a teprve když je celý stažený a ověřený, zařízení přepne malý záznam „bootuj z tohoto slotu“ a restartuje se do něj. Když se během stahování něco pokazí, starý firmware je pořád neporušený a běží dál. Když je zapnutý rollback (je to možné, ale v tomhle workshopu ho nebereme), jde bootloader ještě o krok dál: pokud nový firmware po startu nepotvrdí, že funguje, bootloader se vrátí k předchozímu slotu, takže špatná aktualizace zařízení neznefunkční.

Pokračujte ve stejném projektu. Pokračujte v projektu, který jste v Úkolu 3 naprovisionovali — OTA potřebuje zařízení, které se už umí připojit k Wi-Fi. Pokud ten krok uložil přihlašovací údaje do NVS, znovu se použijí; pokud ne, deska se připojí rovnou k workshopové síti ESP32-WS. Druhá deska, na kterou nahrajete serverový projekt, je na téže síti s pevnou adresou a poskytuje aktualizační soubor. main/my_first_project.c znovu nahradíme, ale idf_component.yml nechte být: už z Úkolu 2 tahá led_strip a za chvíli ho zase budeme potřebovat.

1. Tabulky oddílů (partition tables)

Aby OTA fungovalo, musí být flash paměť ESP32-C5 rozdělená na konkrétní oblasti, kterým se říká partitions. Typická OTA partition tabulka obsahuje:

Při OTA aktualizaci zařízení stáhne nový firmware do neaktivní partition (té z ota_0/ota_1, která právě neběží). Když stahování dopadne, zapíše do partition otadata, že se má bootovat odtud, a restartuje se.

Tohle rozložení definujeme v souboru partitions.csv v kořeni projektu:

# Name,   Type, SubType, Offset,  Size, Flags
nvs,      data, nvs,     ,        0x4000,
otadata,  data, ota,     ,        0x2000,
phy_init, data, phy,     ,        0x1000,
ota_0,    app,  ota_0,   ,        1500K,
ota_1,    app,  ota_1,   ,        1500K,

1500K na slot dává kódu OTA/TLS/Wi-Fi/LED v tomhle úkolu pohodlnou rezervu (skutečný binární soubor má zhruba 1,1 MB) a na 4MB flash se přitom vejdou oba sloty.

Tip: Pokud nechcete CSV upravovat ručně, rozšíření ESP-IDF pro VS Code má GUI editor jak pro partition tabulku, tak pro obsah NVS.

Editor partition tabulky v ESP-IDF

Editor NVS partition v ESP-IDF

2. Konfigurace pomocí menuconfig

Aby ESP-IDF použilo naši partition tabulku, spusťte:

idf.py menuconfig

Přejděte do:

Ukončete klávesou Q a uložte klávesou Y.

Pokud nechcete menuconfig proklikávat, vložte tahle nastavení do souboru sdkconfig.defaults v kořeni projektu:

CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
CONFIG_PARTITION_TABLE_FILENAME="partitions.csv"
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP=y

CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP dovolí esp_https_ota() stahovat z čistého HTTP serveru na druhé desce. Nechte ji vypnutou, pokud později nasměrujete .url na skutečný HTTPS server.

3. Připojení tlačítka

Místo aby se deska aktualizovala hned po startu, počká, až stisknete fyzické tlačítko, a teprve pak začne něco stahovat. Je to bezpečnější (žádné překvapivé stahování uprostřed ukázky) a dobrá příležitost naučit se základní vstup na GPIO. Tohle samé tlačítko budeme znovu používat v Úkolech 5 a 6, takže se vyplatí zapojit ho pořádně hned teď.

Stačí libovolné jednoduché taktilní tlačítko se 2 nebo 4 vývody. U čtyřvývodového tlačítka jsou dva vývody na každé kratší straně uvnitř propojené:

Zapojení taktilního tlačítka — dva vývody na každé straně jsou uvnitř propojené

Zapojte ho takto:

Se stahovacím rezistorem čte GPIO0 LOW, když je tlačítko puštěné, a HIGH, když je stisknuté (tlačítko ho tehdy spojí přímo s 3V3).

GPIO0 je na mnoha čipech ESP32 také strapping pin pro boot režim, ale to hraje roli jen v krátkém okamžiku při zapnutí nebo resetu. Stisk tlačítka za běhu (a nic jiného tady neděláme) na to nemá vliv.

4. Píšeme kód

Jako předtím to postavíme po částech, místo abychom všechno vložili najednou.

4.1 Kostra

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_ota_ops.h"
#include "esp_https_ota.h"
#include "esp_http_client.h"
#include "esp_wifi.h"
#include "esp_netif.h"
#include "esp_crt_bundle.h"
#include "nvs_flash.h"
#include "driver/gpio.h"
#include "led_strip.h"

#define BUTTON_GPIO       GPIO_NUM_0
#define LED_GPIO          27
/* Jen nouzovka pro workshop. NIKDY nehardcodujte Wi-Fi SSID a heslo v produkci;
   použijte provisioning (Úkol 3), aby každé zařízení dostalo vlastní přihlašovací údaje. */
#define FALLBACK_SSID     "ESP32-WS"
#define FALLBACK_PASSWORD "ESP32-WS"

static const char *TAG = "ota_example";

// (A) LED helpers - reused from Assignment 2
// (B) Button GPIO setup
// (C) Wi-Fi event handler - also updates the LED
// (D) A task that polls the button and wakes up the OTA task
// (E) The OTA task itself - now waits for a notification instead of running immediately
// (F) app_main wires everything together

4.2 Část (A)-(B): nastavení LED a tlačítka

static led_strip_handle_t led_strip;
static TaskHandle_t s_ota_task_handle = NULL;

static void led_set_color(uint8_t r, uint8_t g, uint8_t b)
{
    /* Stejný dvoukrok jako v Úkolu 2: nejdřív RAM, pak drát. */
    led_strip_set_pixel(led_strip, 0, r, g, b);
    led_strip_refresh(led_strip);
}

static void configure_led(void)
{
    led_strip_config_t strip_config = {
        .strip_gpio_num = LED_GPIO, /* vestavěná LED, stejná jako v Úkolu 2 */
        .max_leds = 1,
        .color_component_format = LED_STRIP_COLOR_COMPONENT_FMT_GRB,
        .led_model = LED_MODEL_WS2812,
        .flags.invert_out = false,
    };
    led_strip_rmt_config_t rmt_config = {
        .clk_src = RMT_CLK_SRC_DEFAULT,
        .resolution_hz = 10 * 1000 * 1000, /* 10 MHz: zhruba 10x jemnější než bit WS2812 (1,25 us) */
        .mem_block_symbols = 0, /* 0 = velikost bufferu vybere ovladač */
        .flags.with_dma = false, /* jedna LED je pár bajtů; DMA je pro dlouhé pásky */
    };
    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip)); /* vytvoří ovladač */
    led_strip_clear(led_strip); /* všechno zhasnout */
}

static void configure_button(void)
{
    gpio_config_t io_conf = {
        .pin_bit_mask = 1ULL << BUTTON_GPIO, /* bitová maska: jen tenhle pin */
        .mode = GPIO_MODE_INPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE, // we use an external pull-down resistor
    };
    ESP_ERROR_CHECK(gpio_config(&io_conf)); /* nastaví pin */
}

LED použijeme jako stavovou kontrolku s jednoduchým barevným kódem, který v tomhle úkolu postupně doplníme:

4.3 Část (C): Wi-Fi event handler

static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect(); /* rádio běží; začít se připojovat */
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        ESP_LOGI(TAG, "Disconnected. Connecting to the AP again...");
        led_set_color(20, 20, 0); // yellow: (re)connecting
        esp_wifi_connect(); /* spojení padlo; zkusit znovu */
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        /* event_data nese adresu, kterou přidělilo DHCP. */
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "Connected with IP Address:" IPSTR, IP2STR(&event->ip_info.ip));
        ESP_LOGI(TAG, "Ready. Press the button to start the OTA update.");
        led_set_color(0, 0, 20); // blue: ready, waiting for the button
    }
}

Je to stejná logika opětovného připojení k Wi-Fi, kterou už znáte, jen rozšířená o přepínání LED na žlutou nebo modrou podle stavu spojení.

4.4 Část (D): úloha tlačítka

// Polls the button and wakes ota_task up on a press. A dedicated task keeps
// the debounce logic simple and out of the way of everything else.
static void button_task(void *pvParameter)
{
    bool was_pressed = false;
    while (1) {
        /* HIGH, dokud je stisknuto (tlačítko spojí pin s 3V3). */
        bool pressed = gpio_get_level(BUTTON_GPIO) == 1;
        if (pressed && !was_pressed) {
            vTaskDelay(pdMS_TO_TICKS(50)); // simple debounce
            if (gpio_get_level(BUTTON_GPIO) == 1) {
                ESP_LOGI(TAG, "Button pressed - triggering OTA update");
                xTaskNotifyGive(s_ota_task_handle); /* vzbudí OTA úlohu; ta spí v ulTaskNotifyTake */
            }
        }
        was_pressed = pressed;
        vTaskDelay(pdMS_TO_TICKS(20)); /* kontrola každých 20 ms */
    }
}

Místo GPIO přerušení (na začátek se v něm dá snadno splést) tahle úloha pin jen každých 20 ms kontroluje. Když signál přejde z nízké úrovně na vysokou, počká 50 ms a znovu ověří, že pin je pořád ve vysoké úrovni — jednoduchý a účinný způsob, jak ignorovat drobné elektrické odskoky mechanického spínače — a potom vzbudí ota_task pomocí xTaskNotifyGive.

4.5 Část (E): OTA úloha

/* Totéž co esp_https_ota(), ale po krocích, abychom mohli logovat průběh a přesnou chybu. */
static esp_err_t run_ota(const esp_https_ota_config_t *ota_config)
{
    esp_https_ota_handle_t handle = NULL;
    esp_err_t err = esp_https_ota_begin(ota_config, &handle); /* připojit se, zkontrolovat hlavičku image */
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Could not start the download: %s", esp_err_to_name(err));
        return err;
    }

    int next_report = 0;
    while ((err = esp_https_ota_perform(handle)) == ESP_ERR_HTTPS_OTA_IN_PROGRESS) {
        int read = esp_https_ota_get_image_len_read(handle);
        if (read >= next_report) { /* server velikost předem neposílá, proto hlásíme kilobajty, ne procenta */
            ESP_LOGI(TAG, "Downloaded %d KB", read / 1024);
            next_report = read + 128 * 1024;
        }
    }
    if (err == ESP_OK && !esp_https_ota_is_complete_data_received(handle)) {
        err = ESP_ERR_INVALID_SIZE; /* spojení skončilo předčasně */
    }
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Download failed: %s", esp_err_to_name(err));
        esp_https_ota_abort(handle);
        return err;
    }
    return esp_https_ota_finish(handle); /* ověřit image a přepnout bootovací záznam */
}

static void ota_task(void *pvParameter)
{
    while (1) {
        // Block here until button_task wakes us up - no auto-update on boot anymore!
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

        ESP_LOGI(TAG, "Starting OTA update");
        led_set_color(20, 20, 20); // white: downloading

        esp_netif_ip_info_t local = { 0 };
        /* Najde naše vlastní station rozhraní a jeho adresu. */
        esp_netif_t *netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
        /* Zatím bez adresy (špatná síť?) – stahování ani nezkoušet. */
        if (netif == NULL || esp_netif_get_ip_info(netif, &local) != ESP_OK || local.ip.addr == 0) {
            ESP_LOGE(TAG, "This board has no IP. It must be on ESP32-WS before it can reach the server.");
            led_set_color(20, 0, 0);
            vTaskDelay(pdMS_TO_TICKS(3000));
            led_set_color(0, 0, 20);
            continue;
        }
        ESP_LOGI(TAG, "This board's IP is " IPSTR, IP2STR(&local.ip));

        esp_http_client_config_t config = {
            .url = "http://192.168.0.100/firmware.bin",
            .timeout_ms = 10000, /* když server mlčí, vzdát to, místo aby se úloha zasekla */
            // In production, serve this over HTTPS and check the server certificate:
            // .crt_bundle_attach = esp_crt_bundle_attach,
        };
        esp_https_ota_config_t ota_config = {
            .http_config = &config,
        };

        ESP_LOGI(TAG, "Attempting to download update from %s", config.url);
        /* Stáhne do neaktivního slotu, loguje průběh a přepne bootovací záznam. */
        esp_err_t ret = run_ota(&ota_config);
        if (ret == ESP_OK) {
            ESP_LOGI(TAG, "OTA succeeded, rebooting...");
            led_set_color(0, 20, 0); // green: success
            vTaskDelay(pdMS_TO_TICKS(1000)); /* nechat chvilku svítit zelenou a pak restart */
            esp_restart(); /* nabootuje nový image */
        } else {
            ESP_LOGE(TAG, "Firmware upgrade failed: %s", esp_err_to_name(ret));
            led_set_color(20, 0, 0); // red: failed
            vTaskDelay(pdMS_TO_TICKS(3000));
            led_set_color(0, 0, 20); // back to blue: ready, feel free to try again
        }
    }
}

ulTaskNotifyTake(pdTRUE, portMAX_DELAY) spí, dokud ho button_task neprobudí, místo aby stahování začalo hned po startu. Než se začne stahovat, úloha zkontroluje vlastní IP adresu: bez adresy (deska na špatné síti, nebo Wi-Fi ještě nabíhá) blikne červeně a počká na další stisk, místo aby selhala až v esp_https_ota(). URL je serverový projekt examples/C5/assignment-04-ota-server: ta deska je na téže síti ESP32-WS s pevnou adresou 192.168.0.100 a poskytuje image na http://192.168.0.100/firmware.bin. esp_https_ota() odmítne čisté HTTP, dokud není nastaveno CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP. V produktu by se image mělo podávat přes HTTPS a nastavit .crt_bundle_attach.

run_ota() dělá totéž co jednořádkové esp_https_ota(), ale po samostatných krocích (begin, opakované perform, finish). Díky tomu dostaneme dvě věci, které jednořádkové volání skrývá: řádek s průběhem každých 128 KB (server posílá soubor po částech a velikost předem neoznamuje, proto počítáme kilobajty, ne procenta) a přesný název chyby, když se něco pokazí, například ESP_ERR_HTTP_CONNECT nebo ESP_ERR_HTTP_CONNECTION_CLOSED. .timeout_ms způsobí, že mlčící server selže po 10 s, místo aby úlohu blokoval.

4.6 Část (F): app_main

void app_main(void)
{
    ESP_LOGI(TAG, "Running firmware v1!");

    // Initialize NVS
    esp_err_t err = nvs_flash_init();
    /* Flash se mazala nebo se změnil layout; začít s čistou NVS. */
    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        err = nvs_flash_init();
    }
    ESP_ERROR_CHECK(err);

    configure_led();
    configure_button();
    led_set_color(20, 20, 0); // yellow: connecting

    ESP_ERROR_CHECK(esp_netif_init()); /* TCP/IP stack */
    ESP_ERROR_CHECK(esp_event_loop_create_default()); /* smyčka, do které Wi-Fi posílá události */
    esp_netif_create_default_wifi_sta(); /* výchozí station rozhraní, zatím bez IP */

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL));

    // Prefer credentials stored in NVS by the Assignment 3 provisioning step.
    // If that never happened, connect to the fallback network instead.
    /* Režim stanice se musí nastavit před esp_wifi_set_config(), jinak skončí chybou ESP_ERR_WIFI_MODE. */
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    wifi_config_t wifi_config = { 0 };
    /* Co ovladač obnovil z NVS? */
    ESP_ERROR_CHECK(esp_wifi_get_config(WIFI_IF_STA, &wifi_config));
    /* Prázdné: nikdy se neprovisionovalo (nebo se smazala NVS). */
    if (wifi_config.sta.ssid[0] == '\0') {
        ESP_LOGW(TAG, "No Wi-Fi credentials in NVS, using fallback SSID \"%s\"", FALLBACK_SSID);
        wifi_config_t fallback = {
            .sta = {
                .ssid = FALLBACK_SSID,
                .password = FALLBACK_PASSWORD,
                .threshold.authmode = WIFI_AUTH_WPA2_PSK, // "ESP32-WS" is 8 characters, the WPA2 minimum
            },
        };
        ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &fallback));
    }

    ESP_ERROR_CHECK(esp_wifi_start());

    // Create the OTA task first so button_task has a valid handle to notify
    xTaskCreate(&ota_task, "ota_task", 8192, NULL, 5, &s_ota_task_handle); /* velký stack: TLS potřebuje místo */
    xTaskCreate(&button_task, "button_task", 2048, NULL, 5, NULL); /* jednoduchá smyčka, 2 KB stačí */
}

esp_wifi_set_mode() musí přijít první: esp_wifi_set_config() selže s ESP_ERR_WIFI_MODE, dokud rozhraní není v režimu stanice. esp_wifi_get_config() přečte konfiguraci stanice, kterou Wi-Fi ovladač obnovil z NVS. Uložené SSID nechá být. Prázdné SSID znamená, že deska nikdy nebyla naprovisionovaná (nebo že se NVS smazalo), takže esp_wifi_set_config() nastaví FALLBACK_SSID a FALLBACK_PASSWORD — obojí "ESP32-WS" — a ovladač to uloží do NVS stejně jako naprovisionovanou konfiguraci.

4.7 Celý kód

Celý soubor je v examples/C5/assignment-04-ota spolu s odpovídajícími partitions.csv a idf_component.yml. Můžete si ho odtud vzít, pokud nechcete všechno přepisovat, nebo podle něj zkontrolovat svou práci.

5. Build, flash a monitor

idf.py build flash monitor

Nejdřív nahrajte serverový projekt na druhou desku. Sledujte LED studentské desky: žlutá, dokud se připojuje, potom modrá, jakmile Wi-Fi naběhne. Připojí se s přihlašovacími údaji z Úkolu 3 z NVS — nebo rovnou k workshopové síti ESP32-WS, když je NVS prázdná. Stiskněte tlačítko — LED zbělá, dokud se image stahuje, potom zezelená a deska se restartuje do toho image. V monitoru by se pak mělo objevit Running firmware v2!. Když je serverová deska vypnutá, nebo tahle deska skončila na jiné síti (např. s přihlašovacími údaji z domova), LED zčervená a vrátí se na modrou. Jak ten image vznikl a jak ho vyměnit, je v kroku 6.

Řešení potíží: LED zčervenala. Podívejte se do monitoru na řádek vypsaný těsně předtím:

Monitor říká Pravděpodobná příčina Co dělat
This board has no IP... Deska není připojená k ESP32-WS, nebo Wi-Fi ještě naskakuje (LED je pořád žlutá) Počkejte na modrou LED. Pokud zůstane žlutá, deska má nejspíš uložené údaje jiné sítě (např. z Úkolu 3 doma): spusťte idf.py erase-flash a nahrajte znovu
Could not start the download: ESP_ERR_HTTP_CONNECT (nebo timeout) Serverová deska je vypnutá, ještě není v síti, nebo není na 192.168.0.100 Podívejte se do monitoru serveru na řádek Firmware URL; ujistěte se, že existuje jen jedna přístupová síť ESP32-WS
Could not start the download: ESP_ERR_INVALID_ARG a „No option for server verification is enabled“ Je vypnuté CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP Zapněte ho (viz krok 2). Pokud už sdkconfig existuje, změňte to v menuconfigu; úprava samotného sdkconfig.defaults na existující sdkconfig nepůsobí
Download failed: ESP_ERR_INVALID_SIZE (nebo jiná chyba po několika řádcích průběhu) Spojení spadlo uprostřed stahování (slabý signál, restart serveru) Stiskněte tlačítko znovu
Download failed: ESP_ERR_INVALID_VERSION nebo ESP_ERR_OTA_VALIDATE_FAILED Soubor není platný image aplikace pro ESP32-C5 Přeložte image pro esp32c5 a vyměňte firmware.bin (krok 6)
Selže hned na začátku se zprávou o oddílu nebo velikosti image Image se nevejde do OTA slotu 1500K Zmenšete aplikaci nebo zvětšete sloty v partitions.csv

6. Kde leží nový firmware {#6-kde-lezi-novy-firmware}

Pokud tenhle workshop děláte s lektorem, řekne vám, kde firmware najít, a tuhle kapitolu můžete brát jen jako informaci. Pokud ho děláte sami, pokračujte.

Image, který tlačítko stahuje, už je sestavený. Leží v serverovém projektu jako firmware.bin a je to tentýž program, jen s logovacím řádkem změněným na Running firmware v2!. Nahrajte ten projekt na druhou desku:

cd examples/C5/assignment-04-ota-server
idf.py build flash monitor

Server se připojí k workshopové síti ESP32-WS s pevnou adresou 192.168.0.100 a soubor poskytuje na http://192.168.0.100/firmware.bin. Studentská deska znovu použije přihlašovací údaje z Úkolu 3 z NVS; jen deska, která nikdy nebyla naprovisionovaná, spadne rovnou na ESP32-WS — což je tatáž síť. Pokud má deska přihlašovací údaje k jiné síti (např. naprovisionované doma), před touhle ukázkou zopakujte provisioning z Úkolu 3 nebo smažte flash, jinak se na 192.168.0.100 nikdy nedostane.

Výměna image. Změňte řádek s verzí ve studentském projektu, sestavte ho a build/assignment_04_ota.bin zkopírujte přes firmware.bin v serverovém projektu. Server znovu nahrajte. Image musí být sestavený pro ESP32-C5 a musí se vejít do partition fw na serveru (1536 KB).

Hostování na veřejném internetu. Dejte .bin někam, kde už je HTTPS od veřejné certifikační autority (odkaz na raw.githubusercontent.com, nebo objekt na S3/GCS s veřejným čtením). Odkomentujte .crt_bundle_attach = esp_crt_bundle_attach, zrušte CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP a .url namiřte na tu https:// adresu. Certifikát podepsaný sám sebou v tom balíku není — pokud potřebujete lokální HTTPS server, vložte ho přes .cert_pem.

Další krok

Pojďme se podívat na úplně jinou bezdrátovou technologii: ESP-NOW! Tlačítko a LED, které jste právě zapojili, jdou s námi.

Úkol 5: ESP-NOW chatovací místnost