improve WiFi handling, display IP when no data

jo-m · jo-m · commit 310ea54b577b · 2025-02-19T22:14:23.000+01:00
diff --git a/README.md b/README.md
@@ -60,8 +60,3 @@ gst-launch-1.0 filesrc location=components/rtpjpeg/BigBuckBunny_320x180.mp4 ! de
 - Both LVGL and the JPEG decoder use this same buffer, rendering one stripe at a time, which is then sent to the display.
 - When frames are arriving, LVGL is deactivated by not calling `lv_timer_handler()`.
 - We are not using the esp_jpeg component (or ROM decoder) because its API does not allow to receive decoded data block by block.
-
-## TODOs
-
-- [ ] Show IP address WiFi status
-- [ ] Honor RTP timestamps
diff --git a/main/jpeg.c b/main/jpeg.c
@@ -111,14 +111,14 @@ esp_err_t init_jpeg_decoder(lcd_t *lcd, uint8_t *px_buf, ptrdiff_t px_buf_sz, jp
 
     out->jdec = malloc(sizeof(*(out->jdec)));
     if (out->jdec == NULL) {
-        ESP_LOGW(TAG, "failed alloc of js sz=%u", sizeof(*(out->jdec)));
+        ESP_LOGW(TAG, "Failed alloc of js sz=%u", sizeof(*(out->jdec)));
         free(out->px_buf);
         return ESP_ERR_NO_MEM;
     }
 
     out->work = malloc(TJPGD_WORK_SZ);
     if (out->work == NULL) {
-        ESP_LOGW(TAG, "failed alloc of work arena sz=%d", TJPGD_WORK_SZ);
+        ESP_LOGW(TAG, "Failed alloc of work arena sz=%d", TJPGD_WORK_SZ);
         free(out->px_buf);
         free(out->jdec);
         return ESP_ERR_NO_MEM;
diff --git a/main/main.c b/main/main.c
@@ -73,7 +73,11 @@ void app_main(void) {
 
     print_free_heap_stack();
     ESP_LOGI(TAG, "Initialize WIFI");
-    init_wifi();
+    init_wifi_sta();
+    esp_netif_ip_info_t ip_info = {0};
+    ESP_ERROR_CHECK(get_ip_info(&ip_info));
+    smpte_image_set_text("Initializing...");
+    lv_timer_handler();
 
     print_free_heap_stack();
     ESP_LOGI(TAG, "Initialize mDNS");
@@ -101,7 +105,10 @@ void app_main(void) {
 
     // Main loop.
     print_free_heap_stack();
-    smpte_image_set_text("No stream available       ");
+    char no_stream_text[70] = {0};
+    snprintf(no_stream_text, sizeof(no_stream_text),
+             "No stream available, send RTP/JPEG data to " IPSTR "       ", IP2STR(&ip_info.ip));
+    smpte_image_set_text(no_stream_text);
     int64_t last_frame_recv_us = 0;
     bool reset_screen = false;
     while (1) {
diff --git a/main/wifi.c b/main/wifi.c
@@ -1,7 +1,7 @@
 #include "wifi.h"
 
-#include <esp_err.h>
-#include <esp_log.h>
+#include <assert.h>
+#include <stdint.h>
 #include <string.h>
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-compare"
@@ -20,41 +20,82 @@
 #define WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_PSK
 #define WIFI_H2E_IDENTIFIER "PASSWORD IDENTIFIER"
 
-/* FreeRTOS event group to signal when we are connected*/
+// FreeRTOS event group to signal when we are connected.
 static EventGroupHandle_t s_wifi_event_group;
 
-/* The event group allows multiple bits for each event, but we only care about two events:
- * - we are connected to the AP with an IP
- * - we failed to connect after the maximum amount of retries */
+static bool have_ip_info = false;
+static esp_netif_ip_info_t ip_info = {0};
+
+// The event group allows multiple bits for each event, but we only care about two events:
+// - we are connected to the AP with an IP.
+// - we failed to connect after the maximum amount of retries.
 #define WIFI_CONNECTED_BIT BIT0
 #define WIFI_FAIL_BIT BIT1
 
 static const char* TAG = "sta";
 
 static int s_retry_num = 0;
 
+esp_err_t get_ip_info(esp_netif_ip_info_t* ip_info_out) {
+    assert(ip_info_out != NULL);
+    if (have_ip_info) {
+        memcpy(ip_info_out, &ip_info, sizeof(*ip_info_out));
+        return ESP_OK;
+    }
+    return ESP_ERR_INVALID_STATE;
+}
+
 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 < CONFIG_SMALLTV_WIFI_MAXIMUM_RETRY) {
-            esp_wifi_connect();
-            s_retry_num++;
-            ESP_LOGI(TAG, "retry to connect to the AP");
-        } else {
-            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
+    if (event_base == WIFI_EVENT) {
+        switch (event_id) {
+            case WIFI_EVENT_STA_START:
+                ESP_LOGI(TAG, "esp_wifi_connect() initial");
+                esp_wifi_connect();
+                break;
+            case WIFI_EVENT_STA_DISCONNECTED:
+                if (s_retry_num < CONFIG_SMALLTV_WIFI_MAXIMUM_RETRY) {
+                    s_retry_num++;
+                    ESP_LOGI(TAG, "esp_wifi_connect() retry=%d", s_retry_num);
+                    esp_wifi_connect();
+                } else {
+                    ESP_LOGI(TAG, "esp_wifi_connect() giving up");
+                    xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
+                }
+                break;
+            default:
+                ESP_LOGV(TAG, "Received unhandled WIFI_EVENT event_id=%ld", event_id);
+                break;
+        }
+        return;
+    }
+
+    if (event_base == IP_EVENT) {
+        switch (event_id) {
+            case 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));
+                memcpy(&ip_info, &event->ip_info, sizeof(ip_info));
+                have_ip_info = true;
+                xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
+            } break;
+            case IP_EVENT_STA_LOST_IP: {
+                ESP_LOGE(TAG, "Lost IP, resetting");
+                fflush(stdout);
+                fflush(stderr);
+                esp_restart();
+            } break;
+            default:
+                ESP_LOGV(TAG, "Received unhandled IP_EVENT event_id=%ld", event_id);
+                break;
         }
-        ESP_LOGI(TAG, "connect to the AP fail");
-    } 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));
-        s_retry_num = 0;
-        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
+        return;
     }
+
+    ESP_LOGI(TAG, "Received unhandled event_base=%p event_id=%ld", event_base, event_id);
 }
 
-void init_wifi_sta(void) {
+void init_wifi_sta() {
     s_wifi_event_group = xEventGroupCreate();
 
     ESP_ERROR_CHECK(esp_netif_init());
@@ -65,8 +106,8 @@ void init_wifi_sta(void) {
     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_event_handler_instance_t instance_any_id = {0};
+    esp_event_handler_instance_t instance_got_ip = {0};
     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,
@@ -77,7 +118,10 @@ void init_wifi_sta(void) {
             {
                 .ssid = CONFIG_SMALLTV_WIFI_SSID,
                 .password = CONFIG_SMALLTV_WIFI_PASSWORD,
+                .scan_method = WIFI_ALL_CHANNEL_SCAN,
+                .sort_method = WIFI_CONNECT_AP_BY_SIGNAL,
                 .threshold.authmode = WIFI_SCAN_AUTH_MODE_THRESHOLD,
+                .failure_retry_cnt = 2,
                 .sae_pwe_h2e = WIFI_SAE_MODE,
                 .sae_h2e_identifier = WIFI_H2E_IDENTIFIER,
             },
@@ -86,28 +130,19 @@ void init_wifi_sta(void) {
     ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
     ESP_ERROR_CHECK(esp_wifi_start());
 
-    ESP_LOGI(TAG, "wifi_init_sta finished.");
-
-    /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed
-     * for the maximum number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see
-     * above) */
+    // Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed
+    // for the maximum number of re-tries (WIFI_FAIL_BIT).
+    // The bits are set by event_handler().
     EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
                                            pdFALSE, pdFALSE, portMAX_DELAY);
 
-    /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which
-     * event actually happened. */
+    // xEventGroupWaitBits() returns the bits before the call returned, hence we can test which
+    // event actually happened.
     if (bits & WIFI_CONNECTED_BIT) {
-        ESP_LOGI(TAG, "connected to ap SSID:%s password:%s", CONFIG_SMALLTV_WIFI_SSID,
-                 CONFIG_SMALLTV_WIFI_PASSWORD);
+        ESP_LOGI(TAG, "Connected to AP SSID: %s", CONFIG_SMALLTV_WIFI_SSID);
     } else if (bits & WIFI_FAIL_BIT) {
-        ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s", CONFIG_SMALLTV_WIFI_SSID,
-                 CONFIG_SMALLTV_WIFI_PASSWORD);
+        ESP_LOGW(TAG, "Failed to connect to SSID:%s ", CONFIG_SMALLTV_WIFI_SSID);
     } else {
-        ESP_LOGE(TAG, "UNEXPECTED EVENT");
+        ESP_LOGE(TAG, "Unexpected event");
     }
 }
-
-void init_wifi(void) {
-    ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");
-    init_wifi_sta();
-}
diff --git a/main/wifi.h b/main/wifi.h
@@ -1,3 +1,8 @@
 #pragma once
 
-void init_wifi();
+#include <esp_err.h>
+#include <esp_netif_types.h>
+#include <esp_wifi_types.h>
+
+void init_wifi_sta();
+esp_err_t get_ip_info(esp_netif_ip_info_t *ip_info_out);
