Workshop: ESP-IDF a ESP32-C5 - Úkol 3

Úkol 3: Připojení k Wi-Fi

Nyní je konečně čas připojit naši ESP32-C5 k Wi-Fi síti. ESP32-C5 až Wi-Fi 6 na frekvencích 2.4 a 5 GHz.

Wi-Fi konektivita je jednou z nejdůležitějších vlastností většiny čipů z rodiny ESP32 a je to jedna z podstatných součástí jejich úspěchu. Díky Wi-Fi je možné vaše IoT zařízení připojit k internetu a skutečně využít všechny jeho funkce. Tím se nutně nemyslí jen připojení ke cloudovým službám, ale také např. over-the-air (OTA) updaty, vzdálené ovládání, monitoring a mnohem víc.

ESP32 podporuje dva módy: Station a SoftAP:

Station mode: ESP se připojuje k existující síti (třeba k domácímu routeru).
SoftAP mode: Ostatní zařízení (třeba laptop nebo mobil) se připojují přímo na ESP, kde může běžet např. webový server s ovládáním.

Pro tento úkol navážeme na projekt z předchozího úkolu a připojíme se k existující Wi-Fi 4/Wi-Fi 6 síti (budeme tedy používat station mode).

Připojení k Wi-Fi

Abychom mohli začít Wi-Fi používat, musíme frameowrku říct, že budeme používat Wi-Fi: do souboru main/CMakeLists.txt, specificky do funkce idf_component_register přidáme násleudjící řádek:

REQUIRES esp_wifi esp_netif esp_event nvs_flash

Nyní potřebujeme nastavit ovladač Wi-Fi: musíme zadat SSID a heslo.

Zkopírujeme si kostru

Otevřeme projekt z úkolu 2 a rozšíříme main.c o níže uvedené dodatky, nebo zkopírujeme celou kostru do nového projektu.

#include <stdio.h>
#include "led_strip.h"
#include "esp_log.h"
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "nvs_flash.h"
#include "lwip/err.h"
#include "lwip/sys.h"

#define LED_STRIP_GPIO        27
#define LED_STRIP_RMT_RES_HZ  (10 * 1000 * 1000)

#define WIFI_SSID "network-ssid"
#define WIFI_PASS "network-pass"

#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1

static led_strip_handle_t led_strip;

static EventGroupHandle_t s_wifi_event_group;
static int s_retry_num = 0;

static const char *TAG = "workshop";

led_strip_handle_t configure_led(void)
{
    led_strip_handle_t strip;
    led_strip_config_t strip_config = {
        .strip_gpio_num = LED_STRIP_GPIO,
        .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 = LED_STRIP_RMT_RES_HZ,
        .mem_block_symbols = 0,
        .flags.with_dma = false,
    };
    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &strip));
    ESP_LOGI(TAG, "LED strip initialized successfully");
    return strip;
}

static void led_set_color(uint8_t r, uint8_t g, uint8_t b)
{
    ESP_ERROR_CHECK(led_strip_set_pixel(led_strip, 0, r, g, b));
    ESP_ERROR_CHECK(led_strip_refresh(led_strip));
}

// TODO handler

void wifi_init_sta(void)
{
    s_wifi_event_group = xEventGroupCreate();
    //TODO
}

void app_main(void)
{
    esp_err_t ret = nvs_flash_init();

    //TODO

    led_strip = configure_led();
    led_set_color(0x20, 0x0, 0x0);

    wifi_init_sta();
}

Inicializace Wi-Fi

Inicializace Wi-Fi se skládá z těchto kroků, které doplníme do funkce wifi_init_sta():

Inicializace TCP/IP stacku:

    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();

Vytvoření defaultní konfigurace pro Wi-Fi inicializaci a samotná inicializace:

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

Registrace event handlerů pro události WIFI_EVENT a IP_EVENT:

    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    esp_event_handler_instance_register(WIFI_EVENT,
            ESP_EVENT_ANY_ID,
            &event_handler,
            NULL,
            &instance_any_id);
    esp_event_handler_instance_register(IP_EVENT,
            IP_EVENT_STA_GOT_IP,
            &event_handler,
            NULL,
            &instance_got_ip);

Nastavení Wi-Fi módu na station pomocí WIFI_MODE_STA:

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));

Nastavení samotných parametrů připojení pomocí struktury wifi_config_t:

    wifi_config_t wifi_config = {
        .sta = {
            // Set the newtork name
            .ssid = WIFI_SSID,
            // Set the network pass key
            .password = WIFI_PASS,
            // Set WPA as the authentication mode
            .threshold.authmode = WIFI_AUTH_WPA_PSK,
            // Set Simultaneous Authentication (SAE) and Password Element (PWE) derivation method
            .sae_pwe_h2e = WPA3_SAE_PWE_BOTH,
            // Set the password identifier for H2E (Hash-to-Element)
            .sae_h2e_identifier = "",
        },
    };

Teď můžeme zavolat funkci esp_wifi_set_config.

    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));

Nyní jsou už jak Wi-Fi řadič, tak samotné spojení nastavené, můžeme tak zapnout Wi-Fi:

    ESP_ERROR_CHECK(esp_wifi_start());

Teď už stačí počkat na WIFI_CONNECTED_BIT nebo WIFI_FAIL_BIT a ujistit se, že se všechno zdařilo:

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
            pdFALSE,
            pdFALSE,
            portMAX_DELAY);

    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "Connected!");
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGE(TAG, "Failed to connect!");
    }

Vytvoření Wi-Fi event handler-u

Ten nebude součástí ani app_main ani wifi_init_sta, ale bude na stejné úrovni jako tyto dvě funkce. Musí se nacházet před wifi_init_sta, na místě komentáře //TODO event handler. Pro aktualizaci LED při každé Wi-Fi události používáme pomocnou funkci led_set_color() z kostry:

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();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (s_retry_num < 30) {
            esp_wifi_connect();
            s_retry_num++;
            ESP_LOGW(TAG, "Trying to connect to WiFi");
            led_set_color(0x0, 0x0, 0x20);
        } else {
            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
        }
        ESP_LOGE(TAG, "Failed to connect to WiFi");
        led_set_color(0x20, 0x0, 0x0);
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
        led_set_color(0x0, 0x20, 0x0);
        s_retry_num = 0;
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

Kontrola inicializace NVS

O NVS bude řeč v příštím úkolu, nyní to tedy bude trochu blackbox. Tento kód doplníme do app_main.

    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
      ESP_ERROR_CHECK(nvs_flash_erase());
      ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    led_strip = configure_led();
    led_set_color(0x0, 0x0, 0x20);

Inicializace Wi-Fi

Posledním krokem je zavolání naší funkce v app_main:

wifi_init_sta();

Nyní již můžete svůj kód sestavit a nahrát.

Funkce ESP_LOGI a ESP_LOGE vypisují data do seriové linky. Poté, co nahrajeme program do vývojové desky, můžeme otevřít komunikaci s deskou pomocí příkazu Monitor v ESP-IDF Exploreru nebo pomocí ESP-IDF: Monitor Device přes Command Pallete.

Kompletní kód

Níže můžete najít kompletní kód pro tento úkol:

#include <stdio.h>
#include "led_strip.h"
#include "esp_log.h"
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "nvs_flash.h"
#include "lwip/err.h"
#include "lwip/sys.h"

#define LED_STRIP_GPIO        27
#define LED_STRIP_RMT_RES_HZ  (10 * 1000 * 1000)

#define WIFI_SSID "network-ssid"
#define WIFI_PASS "network-pass"

#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1

static led_strip_handle_t led_strip;

static EventGroupHandle_t s_wifi_event_group;
static int s_retry_num = 0;

static const char *TAG = "workshop";

led_strip_handle_t configure_led(void)
{
    led_strip_handle_t strip;
    led_strip_config_t strip_config = {
        .strip_gpio_num = LED_STRIP_GPIO,
        .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 = LED_STRIP_RMT_RES_HZ,
        .mem_block_symbols = 0,
        .flags.with_dma = false,
    };
    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &strip));
    ESP_LOGI(TAG, "LED strip initialized successfully");
    return strip;
}

static void led_set_color(uint8_t r, uint8_t g, uint8_t b)
{
    ESP_ERROR_CHECK(led_strip_set_pixel(led_strip, 0, r, g, b));
    ESP_ERROR_CHECK(led_strip_refresh(led_strip));
}

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();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (s_retry_num < 30) {
            esp_wifi_connect();
            s_retry_num++;
            ESP_LOGW(TAG, "Trying to connect to WiFi");
            led_set_color(0x0, 0x0, 0x20);
        } else {
            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
        }
        ESP_LOGE(TAG, "Failed to connect to WiFi");
        led_set_color(0x20, 0x0, 0x0);
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
        led_set_color(0x0, 0x20, 0x0);
        s_retry_num = 0;
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

void wifi_init_sta(void)
{
    s_wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();

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

    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
            ESP_EVENT_ANY_ID,
            &event_handler,
            NULL,
            &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
            IP_EVENT_STA_GOT_IP,
            &event_handler,
            NULL,
            &instance_got_ip));

    wifi_config_t wifi_config = {
        .sta = {
            .ssid = WIFI_SSID,
            .password = WIFI_PASS,
            .threshold.authmode = WIFI_AUTH_WPA_PSK,
            .sae_pwe_h2e = WPA3_SAE_PWE_BOTH,
            .sae_h2e_identifier = "",
        },
    };

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
    ESP_ERROR_CHECK(esp_wifi_start());

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
            pdFALSE,
            pdFALSE,
            portMAX_DELAY);

    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "Connected!");
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGE(TAG, "Failed to connect!");
    }
}

void app_main(void)
{
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
      ESP_ERROR_CHECK(nvs_flash_erase());
      ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    led_strip = configure_led();
    led_set_color(0x0, 0x0, 0x20);

    wifi_init_sta();
}

Extra

Pokud budete chtít, můžete si například doma vyzkoušet připojení k Wi-Fi i pomocí komponenty common_components/protocol_examples_common.

Next step

Když už jsme se úspěšně připojili na Wi-Fi, přesuneme se na práci s pamětí!

Úkol 4: NVS