Add tests for init error handling.

Added tests for covering initialization error handling cases like; NULL pointer, invalid GPIO count etc.

This changed implied removing the `relay_chn_create` from the Unity's `setUp` function and place it in each testcase.

Refs #1050, #1030.

app_test/CMakeLists.txt

@@ -1,13 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-
-# Define component search paths
-# IMPORTANT: We should tell to the ESP-IDF
-# where it can find relay_chn component.
-# We add the 'relay_chn' directory to the COMPONENT_DIRS by specifying: ../relay_chn
-set(EXTRA_COMPONENT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../relay_chn")
-
-# Include ESP-IDF project build system
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-
-# Define the name of this project
-project(relay_chn_app_test)

include/relay_chn.h

@@ -49,6 +49,7 @@ typedef enum relay_chn_direction_enum relay_chn_direction_t;
  * @brief Enums that represent the state of a relay channel.
  */
 enum relay_chn_state_enum {
+    RELAY_CHN_STATE_UNDEFINED,  ///< The relay channel state is undefined.
     RELAY_CHN_STATE_FREE,       ///< The relay channel is free to run or execute commands.
     RELAY_CHN_STATE_STOPPED,    ///< The relay channel is stopped and not running.
     RELAY_CHN_STATE_FORWARD,    ///< The relay channel is running in the forward direction.
@@ -96,6 +97,13 @@ typedef void (*relay_chn_state_listener_t)(uint8_t chn_id, relay_chn_state_t old
  */
 esp_err_t relay_chn_create(const gpio_num_t* gpio_map, uint8_t gpio_count);
 
+/**
+ * @brief Destroy the relay channels and free resources.
+ *
+ * This function cleans up the relay channels and releases any resources allocated during their creation.
+ */
+void relay_chn_destroy(void);
+
 /**
  * @brief Register a channel state change listener.
  * 

relay_chn/sdkconfig.defaults

@@ -1,5 +0,0 @@
-# For IDF 5.0
-CONFIG_ESP_TASK_WDT_EN=n
-
-# For IDF4.4
-CONFIG_ESP_TASK_WDT=n

src/relay_chn.c

@@ -23,6 +23,7 @@
 #include "esp_event_base.h"
 #include "esp_event.h"
 #include "relay_chn.h"
+#include "freertos/idf_additions.h"
 #include "sdkconfig.h"
 
 
@@ -180,13 +181,19 @@ static esp_err_t relay_chn_dispatch_tilt_cmd(relay_chn_t *relay_chn, relay_chn_t
 
 
 /**
- * @brief Structure to manage the state change listeners. 
+ * @brief Structure to hold a listener entry in the linked list. 
  */
-struct relay_chn_state_listener_manager_type {
-    uint8_t listener_count;                 ///< The number of registered listeners.
-    relay_chn_state_listener_t *listeners;  ///< The list that holds references to the registered listeners.
-} relay_chn_state_listener_manager;
+typedef struct relay_chn_listener_entry_type {
+    relay_chn_state_listener_t listener;  ///< The listener function pointer.
+    ListItem_t list_item;                 ///< FreeRTOS list item.
+} relay_chn_listener_entry_t;
 
+/**
+ * @brief The list that holds references to the registered listeners.
+ *
+ * Uses a FreeRTOS list for safe and dynamic management of listeners.
+ */
+static List_t relay_chn_listener_list;
 
 static relay_chn_t relay_channels[RELAY_CHN_COUNT];
 static esp_event_loop_handle_t relay_chn_event_loop;
@@ -291,6 +298,8 @@ static esp_err_t relay_chn_create_event_loop()
 
 esp_err_t relay_chn_create(const gpio_num_t* gpio_map, uint8_t gpio_count)
 {
+    ESP_RETURN_ON_FALSE(gpio_map, ESP_ERR_INVALID_ARG, TAG, "gpio_map cannot be NULL");
+
     // Check if the device's GPIOs are enough for the number of channels
     if (RELAY_CHN_COUNT > (GPIO_PIN_COUNT / 2)) {
         ESP_LOGE(TAG, "Not enough GPIOs for the number of channels!");
@@ -360,84 +369,117 @@ esp_err_t relay_chn_create(const gpio_num_t* gpio_map, uint8_t gpio_count)
     ESP_RETURN_ON_ERROR(ret, TAG, "Failed to initialize tilt feature");
 #endif
 
-    // Init the state listener manager
-    relay_chn_state_listener_manager.listeners = malloc(sizeof(relay_chn_state_listener_t*));
-    if (relay_chn_state_listener_manager.listeners == NULL) {
-        ESP_LOGE(TAG, "Failed to initialize memory for the listeners!");
-        ret = ESP_ERR_NO_MEM;
-    }
+    // Init the state listener list
+    vListInitialise(&relay_chn_listener_list);
 
     return ret;
 }
 
-static int relay_chn_listener_index(relay_chn_state_listener_t listener)
+void relay_chn_destroy(void)
 {
-    for (int i = 0; i < relay_chn_state_listener_manager.listener_count; i++) {
-        if (relay_chn_state_listener_manager.listeners[i] == listener) {
-            // This is the listener to unregister. Check if it is in the middle
-            ESP_LOGD(TAG, "relay_chn_listener_index: Listener %p; found at index %d.", listener, i);
-            return i;
+    // Destroy the event loop
+    esp_event_loop_delete(relay_chn_event_loop);
+    relay_chn_event_loop = NULL;
+
+    // Free the listeners
+    while (listCURRENT_LIST_LENGTH(&relay_chn_listener_list) > 0) {
+        ListItem_t *pxItem = listGET_HEAD_ENTRY(&relay_chn_listener_list);
+        relay_chn_listener_entry_t *entry = listGET_LIST_ITEM_OWNER(pxItem);
+        uxListRemove(pxItem);
+        free(entry);
+    }
+
+    // Destroy the timers and reset GPIOs
+    for (int i = 0; i < RELAY_CHN_COUNT; i++) {
+        relay_chn_t* relay_chn = &relay_channels[i];
+        if (relay_chn->inertia_timer != NULL) {
+            esp_timer_delete(relay_chn->inertia_timer);
+            relay_chn->inertia_timer = NULL;
+        }
+
+#if RELAY_CHN_ENABLE_TILTING == 1
+        if (relay_chn->tilt_control.tilt_timer != NULL) {
+            esp_timer_delete(relay_chn->tilt_control.tilt_timer);
+            relay_chn->tilt_control.tilt_timer = NULL;
+        }
+#endif // RELAY_CHN_ENABLE_TILTING
+
+        gpio_reset_pin(relay_chn->output.forward_pin);
+        gpio_reset_pin(relay_chn->output.reverse_pin);
     }
 }
-    return -1;
+
+/**
+ * @brief Find a listener entry in the list by its function pointer.
+ *
+ * This function replaces the old index-based search and is used to check
+ * for the existence of a listener before registration or for finding it
+ * during unregistration.
+ *
+ * @param listener The listener function pointer to find.
+ * @return Pointer to the listener entry if found, otherwise NULL.
+ */
+static relay_chn_listener_entry_t* find_listener_entry(relay_chn_state_listener_t listener)
+{
+    // Iterate through the linked list of listeners
+    for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&relay_chn_listener_list);
+         pxListItem != listGET_END_MARKER(&relay_chn_listener_list);
+         pxListItem = listGET_NEXT(pxListItem)) {
+        
+        relay_chn_listener_entry_t *entry = (relay_chn_listener_entry_t *) listGET_LIST_ITEM_OWNER(pxListItem);
+        if (entry->listener == listener) {
+            // Found the listener, return the entry
+            return entry;
+        }
+    }
+
+    // Listener was not found in the list
+    return NULL;
 }
 
 esp_err_t relay_chn_register_listener(relay_chn_state_listener_t listener)
 {
-    if (listener == NULL) {
-        ESP_LOGE(TAG, "relay_chn_register_listener: A NULL listener given.");
-        return ESP_ERR_INVALID_ARG;
-    }
+    ESP_RETURN_ON_FALSE(listener, ESP_ERR_INVALID_ARG, TAG, "Listener cannot be NULL");
 
-    if (relay_chn_listener_index(listener) > -1) {
-        ESP_LOGD(TAG, "relay_chn_register_listener: The listener %p is already registered.", listener);
+    // Check for duplicates
+    if (find_listener_entry(listener) != NULL) {
+        ESP_LOGD(TAG, "Listener %p already registered", listener);
         return ESP_OK;
     }
 
-    ESP_LOGD(TAG, "relay_chn_register_listener: Register listener: %p", listener);
-    relay_chn_state_listener_manager.listeners[relay_chn_state_listener_manager.listener_count] = listener;
-    // Update listener count
-    relay_chn_state_listener_manager.listener_count++;
+    // Allocate memory for the new listener entry
+    relay_chn_listener_entry_t *entry = malloc(sizeof(relay_chn_listener_entry_t));
+    ESP_RETURN_ON_FALSE(entry, ESP_ERR_NO_MEM, TAG, "Failed to allocate memory for listener");
 
+    // Initialize and insert the new listener
+    entry->listener = listener;
+    vListInitialiseItem(&(entry->list_item));
+    listSET_LIST_ITEM_OWNER(&(entry->list_item), (void *)entry);
+    vListInsertEnd(&relay_chn_listener_list, &(entry->list_item));
+
+    ESP_LOGD(TAG, "Registered listener %p", listener);
     return ESP_OK;
 }
 
 void relay_chn_unregister_listener(relay_chn_state_listener_t listener)
 {
-    if (listener == NULL) {
-        ESP_LOGD(TAG, "relay_chn_unregister_listener: A NULL listener given, nothing to do.");
-        return;
-    }
-    // Search the listener in the listeners list and get its index if exists
-    int i = relay_chn_listener_index(listener);
-    if (i == -1) {
-        ESP_LOGD(TAG, "relay_chn_unregister_listener: %p is not registered already.", listener);
+    if (listener == NULL)
+    {
+        ESP_LOGD(TAG, "Cannot unregister a NULL listener.");
         return;
     }
 
-    uint8_t max_index = relay_chn_state_listener_manager.listener_count - 1;
-    // Check whether the listener's index is in the middle
-    if (i == max_index) {
-        // free(&relay_chn_state_listener_manager.listeners[i]);
-        relay_chn_state_listener_manager.listeners[i] = NULL;
+    // Find the listener entry in the list
+    relay_chn_listener_entry_t *entry = find_listener_entry(listener);
+
+    if (entry != NULL) {
+        // Remove the item from the list and free the allocated memory
+        uxListRemove(&(entry->list_item));
+        free(entry);
+        ESP_LOGD(TAG, "Unregistered listener %p", listener);
+    } else {
+        ESP_LOGD(TAG, "Listener %p not found for unregistration.", listener);
     }
-    else {
-        // It is in the middle, so align the next elements in the list and then free the last empty pointer
-        // Align the next elements
-        uint8_t num_of_elements = max_index - i;
-        relay_chn_state_listener_t *pnext = NULL;
-        // (i + j): current index; (i + j + 1): next index
-        for (uint8_t j = 0; j < num_of_elements; j++) {
-            uint8_t current_index = i + j;
-            uint8_t next_index = current_index + 1;
-            pnext = &relay_chn_state_listener_manager.listeners[next_index];
-            relay_chn_state_listener_manager.listeners[current_index] = *pnext;
-        }
-        // free(&relay_chn_state_listener_manager.listeners[max_index]); // Free the last element
-        relay_chn_state_listener_manager.listeners[max_index] = NULL; // Free the last element
-    }
-    // Decrease listener count
-    relay_chn_state_listener_manager.listener_count--;
 }
 
 /**
@@ -492,17 +534,24 @@ static esp_err_t relay_chn_start_esp_timer_once(esp_timer_handle_t esp_timer, ui
 
 static void relay_chn_update_state(relay_chn_t *relay_chn, relay_chn_state_t new_state)
 {
-    relay_chn_state_t old = relay_chn->state;
+    relay_chn_state_t old_state = relay_chn->state;
+
+    // Only update and notify if the state has actually changed.
+    if (old_state == new_state) {
+        return;
+    }
+
     relay_chn->state = new_state;
 
-    for (uint8_t i = 0; i < relay_chn_state_listener_manager.listener_count; i++) {
-        relay_chn_state_listener_t listener = relay_chn_state_listener_manager.listeners[i];
-        if (listener == NULL) {
-            relay_chn_state_listener_manager.listener_count -= 1;
-            ESP_LOGD(TAG, "relay_chn_update_state: A listener is NULL at index: %u", i);
-        }
+    // Iterate through the linked list of listeners and notify them.
+    for (ListItem_t *pxListItem = listGET_HEAD_ENTRY(&relay_chn_listener_list);
+         pxListItem != listGET_END_MARKER(&relay_chn_listener_list);
+         pxListItem = listGET_NEXT(pxListItem)) {
+        relay_chn_listener_entry_t *entry = (relay_chn_listener_entry_t *) listGET_LIST_ITEM_OWNER(pxListItem);
+        if (entry && entry->listener) {
             // Emit the state change to the listeners
-        listener(relay_chn->id, old, new_state);
+            entry->listener(relay_chn->id, old_state, new_state);
+        }
     }
 }
 
@@ -648,16 +697,16 @@ static void relay_chn_issue_cmd(relay_chn_t* relay_chn, relay_chn_cmd_t cmd)
 /* relay_chn APIs */
 relay_chn_state_t relay_chn_get_state(uint8_t chn_id)
 {
-    if (!relay_chn_is_channel_id_valid(chn_id)) {
-        return RELAY_CHN_STATE_STOPPED;
+    if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
+        return RELAY_CHN_STATE_UNDEFINED;
     }
     return relay_channels[chn_id].state;
 }
 
 char *relay_chn_get_state_str(uint8_t chn_id)
 {
-    if (!relay_chn_is_channel_id_valid(chn_id)) {
-        return "INVALID";
+    if (!relay_chn_is_channel_id_valid(chn_id) || chn_id == RELAY_CHN_ID_ALL) {
+        return relay_chn_state_str(RELAY_CHN_STATE_UNDEFINED);
     }
     return relay_chn_state_str(relay_channels[chn_id].state);
 }

test_apps/CMakeLists.txt

@@ -0,0 +1,17 @@
+# This is the project CMakeLists.txt file for the test subproject
+cmake_minimum_required(VERSION 3.5)
+
+# Define component search paths
+# IMPORTANT: We should tell to the ESP-IDF
+# where it can find relay_chn component.
+# We add the 'relay_chn' root directory to the EXTRA_COMPONENT_DIRS by specifying: "../"
+set(EXTRA_COMPONENT_DIRS "../")
+
+# "Trim" the build. Include the minimal set of components, main, and anything it depends on.
+set(COMPONENTS main)
+
+# Include ESP-IDF project build system
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+# Define the name of this project
+project(relay_chn_test)

test_apps/main/test_relay_chn.c

@@ -6,6 +6,10 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include "sdkconfig.h" // For accessing CONFIG_* values
+#include <string.h>
+
+
+const char *TAG = "RELAY_CHN_TEST";
 
 // Test GPIOs and channel IDs
 // Please ensure these GPIOs are correct and suitable for your board.
@@ -15,52 +19,75 @@ const uint8_t gpio_count = sizeof(gpio_map) / sizeof(gpio_map[0]);
 // Assuming 2 GPIOs are used per channel
 const uint8_t relay_chn_count = gpio_count / 2; 
 
-// Retrieve inertia value from SDKconfig
-#ifndef CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS
-#define CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS 500 // Default if not defined in SDKconfig
-#endif
-
 const uint32_t opposite_inertia_ms = CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS;
 
 // Tolerant delay margin to ensure operations complete, especially after inertia.
 const uint32_t test_delay_margin_ms = 50; 
 
+static bool g_is_component_initialized = false;
+
 // --- Test Setup/Teardown Functions ---
 void setUp(void) {
-    ESP_LOGI("TEST_SETUP", "Running setUp for relay_chn tests.");
-    // Re-create the component before each test. relay_chn_create returns esp_err_t.
-    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count)); 
-    // Ensure all relays are stopped at the beginning, and transition to FREE state
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        relay_chn_stop(i); // relay_chn_stop returns void
-        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
-    }
-    ESP_LOGI("TEST_SETUP", "All channels initialized to RELAY_CHN_STATE_FREE.");
+    // Reset state before each test. Initialization is now done inside each test case
+    // to allow for testing of initialization failures.
+    g_is_component_initialized = false;
 }
 
 void tearDown(void) {
-    ESP_LOGI("TEST_TEARDOWN", "Running tearDown for relay_chn tests.");
-    // Stop all relays after each test, and transition to FREE state
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        relay_chn_stop(i); // relay_chn_stop returns void
-        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
+    // Conditionally destroy the component to avoid crashing if creation failed.
+    if (g_is_component_initialized) {
+        relay_chn_destroy();
     }
-    ESP_LOGI("TEST_TEARDOWN", "All channels returned to RELAY_CHN_STATE_FREE.");
+}
+
+
+// --- Initialization Tests ---
+
+TEST_CASE("relay_chn_create handles invalid arguments", "[relay_chn][init]")
+{
+    // 1. Test with NULL gpio_map
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(NULL, gpio_count));
+
+    // 2. Test with incorrect gpio_count (must be RELAY_CHN_COUNT * 2)
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(gpio_map, gpio_count - 1));
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(gpio_map, 1));
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(gpio_map, 0));
+
+    // 3. Test with invalid GPIO numbers (GPIO_NUM_MAX is an invalid GPIO for output)
+    gpio_num_t invalid_gpio_map[] = {GPIO_NUM_4, GPIO_NUM_MAX, GPIO_NUM_18, GPIO_NUM_19};
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_create(invalid_gpio_map, gpio_count));
 }
 
 // --- Basic Functionality Tests ---
 
-// TEST_CASE 1: Test that relay channels initialize correctly to RELAY_CHN_STATE_FREE
+// TEST_CASE: Test that relay channels initialize correctly to RELAY_CHN_STATE_FREE
 TEST_CASE("Relay channels initialize correctly to FREE state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels initialize correctly to FREE state");
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
     }
 }
 
-// TEST_CASE 2: Test that relays run in the forward direction and update their state
+// TEST_CASE: Test that relays do nothing when an invlid channel id given
+TEST_CASE("Run forward does nothing if channel id is invalid", "[relay_chn]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        relay_chn_run_forward(invalid_id); // relay_chn_run_forward returns void
+        // Short delay for state to update
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE: Test that relays run in the forward direction and update their state
 TEST_CASE("Relay channels run forward and update state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels run forward and update state");
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         relay_chn_run_forward(i); // relay_chn_run_forward returns void
         // Short delay for state to update
@@ -69,9 +96,26 @@ TEST_CASE("Relay channels run forward and update state", "[relay_chn]") {
     }
 }
 
-// TEST_CASE 3: Test that relays run in the reverse direction and update their state
+// TEST_CASE: Test that relays do nothing when an invlid channel id given
+TEST_CASE("Run reverse does nothing if channel id is invalid", "[relay_chn]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    // Verify that no valid channels were affected
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        // Call run_reverse with an invalid ID
+        relay_chn_run_reverse(invalid_id);
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE: Test that relays run in the reverse direction and update their state
 TEST_CASE("Relay channels run reverse and update state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels run reverse and update state");
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         relay_chn_run_reverse(i); // relay_chn_run_reverse returns void
         vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
@@ -79,10 +123,12 @@ TEST_CASE("Relay channels run reverse and update state", "[relay_chn]") {
     }
 }
 
-// TEST_CASE 4: Test that relays stop and transition to RELAY_CHN_STATE_FREE
+// TEST_CASE: Test that relays stop and transition to RELAY_CHN_STATE_FREE
 // This test also verifies the transition to FREE state after a STOP command.
 TEST_CASE("Relay channels stop and update to FREE state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels stop and update to FREE state");
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         // First, run forward to test stopping and transitioning to FREE state
         relay_chn_run_forward(i); // relay_chn_run_forward returns void
@@ -101,28 +147,47 @@ TEST_CASE("Relay channels stop and update to FREE state", "[relay_chn]") {
     }
 }
 
-// TEST_CASE 5: Test function calls with invalid channel IDs
-// TEST_CASE("Invalid channel ID handling", "[relay_chn]") {
-//     ESP_LOGI("TEST", "Running test: Invalid channel ID handling");
-//     uint8_t invalid_channel_id = relay_chn_count + 1; // An ID that is out of bounds
+// TEST_CASE: Get state should return UNDEFINED when id is not valid
+TEST_CASE("Get state returns UNDEFINED when id is invalid", "[relay_chn]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
 
-//     // These calls are expected to return ESP_ERR_INVALID_ARG, so TEST_ASSERT_EQUAL is appropriate.
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_run_forward(invalid_channel_id));
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_run_reverse(invalid_channel_id));
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_stop(invalid_channel_id));
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_UNDEFINED, relay_chn_get_state(invalid_id));
+    }
+    // Test for running states also
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_UNDEFINED, relay_chn_get_state(invalid_id));
+    }
+}
 
-//     // Test tilt commands only if tilt functionality is enabled
-// #if CONFIG_RELAY_CHN_ENABLE_TILTING == 1
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_tilt_forward(invalid_channel_id));
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_tilt_reverse(invalid_channel_id));
-// #endif
+// TEST_CASE: Get state string should return "UNKNOWN" when id is not valid
+TEST_CASE("Get state string returns UNKNOWN when id is invalid", "[relay_chn]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
 
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_get_state(invalid_channel_id));
-// }
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL_STRING("UNKNOWN", relay_chn_get_state_str(invalid_id));
+    }
+    // Test for running states also
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    for (uint8_t i = 0; i < relay_chn_count; i++) {
+        int invalid_id = relay_chn_count * 2 + i;
+        TEST_ASSERT_EQUAL_STRING("UNKNOWN", relay_chn_get_state_str(invalid_id));
+    }
+}
 
-// TEST_CASE 6: Test independent operation of multiple relay channels
+// TEST_CASE: Test independent operation of multiple relay channels
 TEST_CASE("Multiple channels can operate independently", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Multiple channels can operate independently");
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     if (relay_chn_count >= 2) {
         // Start Channel 0 in forward direction
         relay_chn_run_forward(0); // relay_chn_run_forward returns void
@@ -157,12 +222,14 @@ TEST_CASE("Multiple channels can operate independently", "[relay_chn]") {
 
 // This section specifically targets the inertia periods and complex state transitions as per the component's logic.
 
-// TEST_CASE 7: Test transition from forward to reverse with inertia and state checks
+// TEST_CASE: Test transition from forward to reverse with inertia and state checks
 // Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_REVERSE
 TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: Forward to Reverse transition with opposite inertia");
     uint8_t ch = 0; // Channel to test
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // 1. Start in forward direction
     relay_chn_run_forward(ch); // relay_chn_run_forward returns void
     vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Short delay for state stabilization
@@ -179,12 +246,14 @@ TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][in
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch)); // Should now be in reverse state
 }
 
-// TEST_CASE 8: Test transition from reverse to forward with inertia and state checks
+// TEST_CASE: Test transition from reverse to forward with inertia and state checks
 // Scenario: RELAY_CHN_STATE_REVERSE -> (relay_chn_run_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: Reverse to Forward transition with opposite inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // 1. Start in reverse direction
     relay_chn_run_reverse(ch); // relay_chn_run_reverse returns void
     vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
@@ -200,12 +269,14 @@ TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][in
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 9: Test issuing the same run command while already running (no inertia expected)
+// TEST_CASE: Test issuing the same run command while already running (no inertia expected)
 // Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: Running in same direction does not incur inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // 1. Start in forward direction
     relay_chn_run_forward(ch); // relay_chn_run_forward returns void
     vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
@@ -219,12 +290,14 @@ TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][inert
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 10: Test transition from FREE state to running (no inertia expected)
+// TEST_CASE: Test transition from FREE state to running (no inertia expected)
 // Scenario: RELAY_CHN_STATE_FREE -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("FREE to Running transition without inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: FREE to Running transition without inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // setUp() should have already brought the channel to FREE state
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(ch));
 
@@ -235,6 +308,139 @@ TEST_CASE("FREE to Running transition without inertia", "[relay_chn][inertia]")
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
+// --- Listener Test Globals ---
+typedef struct {
+    uint8_t chn_id;
+    relay_chn_state_t old_state;
+    relay_chn_state_t new_state;
+    int call_count;
+} listener_callback_info_t;
+
+static listener_callback_info_t listener1_info;
+static listener_callback_info_t listener2_info;
+
+// --- Listener Test Helper Functions ---
+
+// Clear the memory from possible garbage values
+static void reset_listener_info(listener_callback_info_t* info) {
+    memset(info, 0, sizeof(listener_callback_info_t));
+}
+
+static void test_listener_1(uint8_t chn_id, relay_chn_state_t old_state, relay_chn_state_t new_state) {
+    listener1_info.chn_id = chn_id;
+    listener1_info.old_state = old_state;
+    listener1_info.new_state = new_state;
+    listener1_info.call_count++;
+}
+
+static void test_listener_2(uint8_t chn_id, relay_chn_state_t old_state, relay_chn_state_t new_state) {
+    listener2_info.chn_id = chn_id;
+    listener2_info.old_state = old_state;
+    listener2_info.new_state = new_state;
+    listener2_info.call_count++;
+}
+
+// ### Listener Functionality Tests
+
+TEST_CASE("Listener is called on state change", "[relay_chn][listener]") {
+    uint8_t ch = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+
+    // 1. Register the listener
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+
+    // 2. Trigger a state change
+    relay_chn_run_forward(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms)); // Allow event to be processed
+
+    // 3. Verify the listener was called with correct parameters
+    TEST_ASSERT_EQUAL(1, listener1_info.call_count);
+    TEST_ASSERT_EQUAL(ch, listener1_info.chn_id);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, listener1_info.old_state);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, listener1_info.new_state);
+
+    // 4. Unregister to clean up
+    relay_chn_unregister_listener(test_listener_1);
+}
+
+TEST_CASE("Unregistered listener is not called", "[relay_chn][listener]") {
+    uint8_t ch = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+
+    // 1. Register and then immediately unregister the listener
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+    relay_chn_unregister_listener(test_listener_1);
+
+    // 2. Trigger a state change
+    relay_chn_run_forward(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    // 3. Verify the listener was NOT called
+    TEST_ASSERT_EQUAL(0, listener1_info.call_count);
+}
+
+TEST_CASE("Multiple listeners are called on state change", "[relay_chn][listener]") {
+    uint8_t ch = 0;
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+    reset_listener_info(&listener2_info);
+
+    // 1. Register two different listeners
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_2));
+
+    // 2. Trigger a state change
+    relay_chn_run_forward(ch);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+
+    // 3. Verify listener 1 was called correctly
+    TEST_ASSERT_EQUAL(1, listener1_info.call_count);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, listener1_info.old_state);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, listener1_info.new_state);
+
+    // 4. Verify listener 2 was also called correctly
+    TEST_ASSERT_EQUAL(1, listener2_info.call_count);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, listener2_info.old_state);
+    TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, listener2_info.new_state);
+
+    // 5. Clean up
+    relay_chn_unregister_listener(test_listener_1);
+    relay_chn_unregister_listener(test_listener_2);
+}
+
+TEST_CASE("Listener registration handles invalid arguments and duplicates", "[relay_chn][listener]") {
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
+    reset_listener_info(&listener1_info);
+
+    // 1. Registering a NULL listener should fail
+    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_register_listener(NULL));
+
+    // 2. Unregistering a NULL listener should not crash
+    relay_chn_unregister_listener(NULL);
+
+    // 3. Registering the same listener twice should be handled gracefully
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1));
+    TEST_ESP_OK(relay_chn_register_listener(test_listener_1)); // Second call should be a no-op
+
+    // 4. Trigger a state change and verify the listener is only called ONCE
+    relay_chn_run_forward(0);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    TEST_ASSERT_EQUAL(1, listener1_info.call_count);
+
+    // 5. Clean up
+    relay_chn_unregister_listener(test_listener_1);
+}
+
 
 // ### Tilt Functionality Tests (Conditional)
 
@@ -259,12 +465,14 @@ void prepare_channel_for_tilt(uint8_t chn_id, int initial_cmd) {
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(chn_id));
 }
 
-// TEST_CASE 11: Test transition from running forward to tilt forward
+// TEST_CASE: Test transition from running forward to tilt forward
 // Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_tilt_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_FORWARD
 TEST_CASE("Run Forward to Tilt Forward transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Run Forward to Tilt Forward transition with inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running forward first to set last_run_cmd
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
 
@@ -284,12 +492,14 @@ TEST_CASE("Run Forward to Tilt Forward transition with inertia", "[relay_chn][ti
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 12: Test transition from running reverse to tilt reverse
+// TEST_CASE: Test transition from running reverse to tilt reverse
 // Scenario: RELAY_CHN_STATE_REVERSE -> (relay_chn_tilt_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_REVERSE
 TEST_CASE("Run Reverse to Tilt Reverse transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Run Reverse to Tilt Reverse transition with inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running reverse first to set last_run_cmd
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
 
@@ -307,12 +517,14 @@ TEST_CASE("Run Reverse to Tilt Reverse transition with inertia", "[relay_chn][ti
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 13: Test transition from FREE state to tilt forward (now with preparation)
+// TEST_CASE: Test transition from FREE state to tilt forward (now with preparation)
 // Scenario: RELAY_CHN_STATE_FREE -> (prepare) -> RELAY_CHN_STATE_FREE -> (relay_chn_tilt_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_FORWARD
 TEST_CASE("FREE to Tilt Forward transition with inertia (prepared)", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: FREE to Tilt Forward transition with inertia (prepared)");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running forward first to set last_run_cmd
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(ch)); // Ensure we are back to FREE
@@ -324,12 +536,14 @@ TEST_CASE("FREE to Tilt Forward transition with inertia (prepared)", "[relay_chn
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 14: Test transition from FREE state to tilt reverse (now with preparation)
+// TEST_CASE: Test transition from FREE state to tilt reverse (now with preparation)
 // Scenario: RELAY_CHN_STATE_FREE -> (prepare) -> RELAY_CHN_STATE_FREE -> (relay_chn_tilt_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_REVERSE
 TEST_CASE("FREE to Tilt Reverse transition with inertia (prepared)", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: FREE to Tilt Reverse transition with inertia (prepared)");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running reverse first to set last_run_cmd
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(ch)); // Ensure we are back to FREE
@@ -340,12 +554,14 @@ TEST_CASE("FREE to Tilt Reverse transition with inertia (prepared)", "[relay_chn
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 15: Test transition from tilt forward to run forward (inertia expected for run)
+// TEST_CASE: Test transition from tilt forward to run forward (inertia expected for run)
 // Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("Tilt Forward to Run Forward transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt Forward to Run Forward transition with inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running forward first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_forward(ch); // Go to tilt state
@@ -360,12 +576,14 @@ TEST_CASE("Tilt Forward to Run Forward transition with inertia", "[relay_chn][ti
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 16: Test transition from tilt reverse to run reverse (no inertia expected for run)
+// TEST_CASE: Test transition from tilt reverse to run reverse (no inertia expected for run)
 // Scenario: RELAY_CHN_STATE_TILT_REVERSE -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_REVERSE
 TEST_CASE("Tilt Reverse to Run Reverse transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt Reverse to Run Reverse transition with inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running reverse first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
     relay_chn_tilt_reverse(ch); // Go to tilt state
@@ -379,12 +597,14 @@ TEST_CASE("Tilt Reverse to Run Reverse transition with inertia", "[relay_chn][ti
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 17: Test transition from tilt forward to run reverse (without inertia)
+// TEST_CASE: Test transition from tilt forward to run reverse (without inertia)
 // Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_REVERSE
 TEST_CASE("Tilt Forward to Run Reverse transition without inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt Forward to Run Reverse transition without inertia");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running forward first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_forward(ch); // Go to tilt state
@@ -397,12 +617,14 @@ TEST_CASE("Tilt Forward to Run Reverse transition without inertia", "[relay_chn]
     TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
 }
 
-// TEST_CASE 18: Test stopping from a tilt state (no inertia for stop command itself)
+// TEST_CASE: Test stopping from a tilt state (no inertia for stop command itself)
 // Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_stop) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_FREE
 TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt to Stop transition without immediate inertia for stop");
     uint8_t ch = 0;
 
+    TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
+    g_is_component_initialized = true;
+
     // Prepare channel by running forward first to set last_run_cmd, then tilt
     prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
     relay_chn_tilt_forward(ch); // Go to tilt state
@@ -420,7 +642,6 @@ TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_
 // If tilt functionality is disabled, these tests are skipped.
 // A dummy test case is added to indicate this in the test output.
 TEST_CASE("Tilt functionality is disabled, skipping tilt tests", "[relay_chn][tilt_disabled]") {
-    ESP_LOGI("TEST", "Tilt functionality is disabled (CONFIG_RELAY_CHN_ENABLE_TILTING is 0). Skipping tilt tests.");
     TEST_ASSERT_TRUE(true); // Just to ensure at least one test passes for visibility
 }
 #endif // CONFIG_RELAY_CHN_ENABLE_TILTING
@@ -430,13 +651,12 @@ TEST_CASE("Tilt functionality is disabled, skipping tilt tests", "[relay_chn][ti
 
 // --- app_main function ---
 void app_main(void) {
-    ESP_LOGI("APP_MAIN", "Starting relay_chn unit tests...");
-
     // Run the Unity test runner
     unity_run_all_tests();
 
+    ESP_LOGI(TAG, "============================== END OF TESTS ==============================");
+
     // After tests complete, instead of restarting, the device will halt.
-    ESP_LOGI("APP_MAIN", "All relay_chn tests completed. Device halted.");
     while (1) {
         vTaskDelay(pdMS_TO_TICKS(1000)); // Wait with low power consumption
     }

test_apps/sdkconfig

@@ -1,6 +1,6 @@
 #
 # Automatically generated file. DO NOT EDIT.
-# Espressif IoT Development Framework (ESP-IDF) 5.4.0 Project Configuration
+# Espressif IoT Development Framework (ESP-IDF) 5.4.2 Project Configuration
 #
 CONFIG_SOC_ADC_SUPPORTED=y
 CONFIG_SOC_DEDICATED_GPIO_SUPPORTED=y
@@ -215,6 +215,8 @@ CONFIG_SOC_TIMER_GROUP_COUNTER_BIT_WIDTH=54
 CONFIG_SOC_TIMER_GROUP_SUPPORT_XTAL=y
 CONFIG_SOC_TIMER_GROUP_SUPPORT_APB=y
 CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=2
+CONFIG_SOC_LP_TIMER_BIT_WIDTH_LO=32
+CONFIG_SOC_LP_TIMER_BIT_WIDTH_HI=16
 CONFIG_SOC_MWDT_SUPPORT_XTAL=y
 CONFIG_SOC_TWAI_CONTROLLER_NUM=1
 CONFIG_SOC_TWAI_CLK_SUPPORT_APB=y
@@ -502,31 +504,6 @@ CONFIG_COMPILER_ORPHAN_SECTIONS_WARNING=y
 # Component config
 #
 
-#
-# Application Level Tracing
-#
-# CONFIG_APPTRACE_DEST_JTAG is not set
-CONFIG_APPTRACE_DEST_NONE=y
-# CONFIG_APPTRACE_DEST_UART1 is not set
-# CONFIG_APPTRACE_DEST_USB_CDC is not set
-CONFIG_APPTRACE_DEST_UART_NONE=y
-CONFIG_APPTRACE_UART_TASK_PRIO=1
-CONFIG_APPTRACE_LOCK_ENABLE=y
-# end of Application Level Tracing
-
-#
-# Bluetooth
-#
-# CONFIG_BT_ENABLED is not set
-CONFIG_BT_ALARM_MAX_NUM=50
-# end of Bluetooth
-
-#
-# Console Library
-#
-# CONFIG_CONSOLE_SORTED_HELP is not set
-# end of Console Library
-
 #
 # Driver Configurations
 #
@@ -542,6 +519,7 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 # Legacy ADC Driver Configuration
 #
 # CONFIG_ADC_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_ADC_SKIP_LEGACY_CONFLICT_CHECK is not set
 
 #
 # Legacy ADC Calibration Configuration
@@ -554,30 +532,41 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 # Legacy Timer Group Driver Configurations
 #
 # CONFIG_GPTIMER_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_GPTIMER_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy Timer Group Driver Configurations
 
 #
 # Legacy RMT Driver Configurations
 #
 # CONFIG_RMT_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_RMT_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy RMT Driver Configurations
 
 #
 # Legacy I2S Driver Configurations
 #
 # CONFIG_I2S_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_I2S_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy I2S Driver Configurations
 
+#
+# Legacy I2C Driver Configurations
+#
+# CONFIG_I2C_SKIP_LEGACY_CONFLICT_CHECK is not set
+# end of Legacy I2C Driver Configurations
+
 #
 # Legacy SDM Driver Configurations
 #
 # CONFIG_SDM_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_SDM_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy SDM Driver Configurations
 
 #
 # Legacy Temperature Sensor Driver Configurations
 #
 # CONFIG_TEMP_SENSOR_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_TEMP_SENSOR_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy Temperature Sensor Driver Configurations
 # end of Driver Configurations
 
@@ -589,37 +578,6 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 CONFIG_EFUSE_MAX_BLK_LEN=256
 # end of eFuse Bit Manager
 
-#
-# ESP-TLS
-#
-CONFIG_ESP_TLS_USING_MBEDTLS=y
-CONFIG_ESP_TLS_USE_DS_PERIPHERAL=y
-# CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS is not set
-# CONFIG_ESP_TLS_SERVER_SESSION_TICKETS is not set
-# CONFIG_ESP_TLS_SERVER_CERT_SELECT_HOOK is not set
-# CONFIG_ESP_TLS_SERVER_MIN_AUTH_MODE_OPTIONAL is not set
-# CONFIG_ESP_TLS_PSK_VERIFICATION is not set
-# CONFIG_ESP_TLS_INSECURE is not set
-# end of ESP-TLS
-
-#
-# ADC and ADC Calibration
-#
-# CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM is not set
-# CONFIG_ADC_CONTINUOUS_ISR_IRAM_SAFE is not set
-# CONFIG_ADC_CONTINUOUS_FORCE_USE_ADC2_ON_C3_S3 is not set
-# CONFIG_ADC_ONESHOT_FORCE_USE_ADC2_ON_C3 is not set
-# CONFIG_ADC_ENABLE_DEBUG_LOG is not set
-# end of ADC and ADC Calibration
-
-#
-# Wireless Coexistence
-#
-CONFIG_ESP_COEX_ENABLED=y
-# CONFIG_ESP_COEX_EXTERNAL_COEXIST_ENABLE is not set
-# CONFIG_ESP_COEX_GPIO_DEBUG is not set
-# end of Wireless Coexistence
-
 #
 # Common ESP-related
 #
@@ -638,6 +596,7 @@ CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
 CONFIG_GPTIMER_ISR_HANDLER_IN_IRAM=y
 # CONFIG_GPTIMER_CTRL_FUNC_IN_IRAM is not set
 # CONFIG_GPTIMER_ISR_IRAM_SAFE is not set
+CONFIG_GPTIMER_OBJ_CACHE_SAFE=y
 # CONFIG_GPTIMER_ENABLE_DEBUG_LOG is not set
 # end of ESP-Driver:GPTimer Configurations
 
@@ -704,18 +663,6 @@ CONFIG_SPI_SLAVE_ISR_IN_IRAM=y
 CONFIG_USJ_ENABLE_USB_SERIAL_JTAG=y
 # end of ESP-Driver:USB Serial/JTAG Configuration
 
-#
-# Ethernet
-#
-CONFIG_ETH_ENABLED=y
-CONFIG_ETH_USE_SPI_ETHERNET=y
-# CONFIG_ETH_SPI_ETHERNET_DM9051 is not set
-# CONFIG_ETH_SPI_ETHERNET_W5500 is not set
-# CONFIG_ETH_SPI_ETHERNET_KSZ8851SNL is not set
-# CONFIG_ETH_USE_OPENETH is not set
-# CONFIG_ETH_TRANSMIT_MUTEX is not set
-# end of Ethernet
-
 #
 # Event Loop Library
 #
@@ -724,53 +671,6 @@ CONFIG_ESP_EVENT_POST_FROM_ISR=y
 CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR=y
 # end of Event Loop Library
 
-#
-# GDB Stub
-#
-CONFIG_ESP_GDBSTUB_ENABLED=y
-# CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME is not set
-CONFIG_ESP_GDBSTUB_SUPPORT_TASKS=y
-CONFIG_ESP_GDBSTUB_MAX_TASKS=32
-# end of GDB Stub
-
-#
-# ESP HTTP client
-#
-CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS=y
-# CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH is not set
-# CONFIG_ESP_HTTP_CLIENT_ENABLE_DIGEST_AUTH is not set
-# CONFIG_ESP_HTTP_CLIENT_ENABLE_CUSTOM_TRANSPORT is not set
-CONFIG_ESP_HTTP_CLIENT_EVENT_POST_TIMEOUT=2000
-# end of ESP HTTP client
-
-#
-# HTTP Server
-#
-CONFIG_HTTPD_MAX_REQ_HDR_LEN=512
-CONFIG_HTTPD_MAX_URI_LEN=512
-CONFIG_HTTPD_ERR_RESP_NO_DELAY=y
-CONFIG_HTTPD_PURGE_BUF_LEN=32
-# CONFIG_HTTPD_LOG_PURGE_DATA is not set
-# CONFIG_HTTPD_WS_SUPPORT is not set
-# CONFIG_HTTPD_QUEUE_WORK_BLOCKING is not set
-CONFIG_HTTPD_SERVER_EVENT_POST_TIMEOUT=2000
-# end of HTTP Server
-
-#
-# ESP HTTPS OTA
-#
-# CONFIG_ESP_HTTPS_OTA_DECRYPT_CB is not set
-# CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP is not set
-CONFIG_ESP_HTTPS_OTA_EVENT_POST_TIMEOUT=2000
-# end of ESP HTTPS OTA
-
-#
-# ESP HTTPS server
-#
-# CONFIG_ESP_HTTPS_SERVER_ENABLE is not set
-CONFIG_ESP_HTTPS_SERVER_EVENT_POST_TIMEOUT=2000
-# end of ESP HTTPS server
-
 #
 # Hardware Settings
 #
@@ -848,8 +748,10 @@ CONFIG_PERIPH_CTRL_FUNC_IN_IRAM=y
 # GDMA Configurations
 #
 CONFIG_GDMA_CTRL_FUNC_IN_IRAM=y
-# CONFIG_GDMA_ISR_IRAM_SAFE is not set
+CONFIG_GDMA_ISR_HANDLER_IN_IRAM=y
+CONFIG_GDMA_OBJ_DRAM_SAFE=y
 # CONFIG_GDMA_ENABLE_DEBUG_LOG is not set
+# CONFIG_GDMA_ISR_IRAM_SAFE is not set
 # end of GDMA Configurations
 
 #
@@ -862,56 +764,16 @@ CONFIG_XTAL_FREQ=40
 CONFIG_ESP_SPI_BUS_LOCK_ISR_FUNCS_IN_IRAM=y
 # end of Hardware Settings
 
-#
-# ESP-Driver:LCD Controller Configurations
-#
-# CONFIG_LCD_ENABLE_DEBUG_LOG is not set
-# end of ESP-Driver:LCD Controller Configurations
-
 #
 # ESP-MM: Memory Management Configurations
 #
 # end of ESP-MM: Memory Management Configurations
 
-#
-# ESP NETIF Adapter
-#
-CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL=120
-# CONFIG_ESP_NETIF_PROVIDE_CUSTOM_IMPLEMENTATION is not set
-CONFIG_ESP_NETIF_TCPIP_LWIP=y
-# CONFIG_ESP_NETIF_LOOPBACK is not set
-CONFIG_ESP_NETIF_USES_TCPIP_WITH_BSD_API=y
-CONFIG_ESP_NETIF_REPORT_DATA_TRAFFIC=y
-# CONFIG_ESP_NETIF_RECEIVE_REPORT_ERRORS is not set
-# CONFIG_ESP_NETIF_L2_TAP is not set
-# CONFIG_ESP_NETIF_BRIDGE_EN is not set
-# CONFIG_ESP_NETIF_SET_DNS_PER_DEFAULT_NETIF is not set
-# end of ESP NETIF Adapter
-
 #
 # Partition API Configuration
 #
 # end of Partition API Configuration
 
-#
-# PHY
-#
-CONFIG_ESP_PHY_ENABLED=y
-CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE=y
-# CONFIG_ESP_PHY_INIT_DATA_IN_PARTITION is not set
-CONFIG_ESP_PHY_MAX_WIFI_TX_POWER=20
-CONFIG_ESP_PHY_MAX_TX_POWER=20
-# CONFIG_ESP_PHY_REDUCE_TX_POWER is not set
-CONFIG_ESP_PHY_ENABLE_USB=y
-# CONFIG_ESP_PHY_ENABLE_CERT_TEST is not set
-CONFIG_ESP_PHY_RF_CAL_PARTIAL=y
-# CONFIG_ESP_PHY_RF_CAL_NONE is not set
-# CONFIG_ESP_PHY_RF_CAL_FULL is not set
-CONFIG_ESP_PHY_CALIBRATION_MODE=0
-# CONFIG_ESP_PHY_PLL_TRACK_DEBUG is not set
-# CONFIG_ESP_PHY_RECORD_USED_TIME is not set
-# end of PHY
-
 #
 # Power Management
 #
@@ -920,10 +782,6 @@ CONFIG_ESP_PHY_CALIBRATION_MODE=0
 CONFIG_PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP=y
 # end of Power Management
 
-#
-# ESP PSRAM
-#
-
 #
 # ESP Ringbuf
 #
@@ -944,7 +802,6 @@ CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ=160
 # CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT is not set
 CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT=y
 # CONFIG_ESP_SYSTEM_PANIC_SILENT_REBOOT is not set
-# CONFIG_ESP_SYSTEM_PANIC_GDBSTUB is not set
 CONFIG_ESP_SYSTEM_PANIC_REBOOT_DELAY_SECONDS=0
 CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE=y
 CONFIG_ESP_SYSTEM_RTC_FAST_MEM_AS_HEAP_DEPCHECK=y
@@ -1028,122 +885,6 @@ CONFIG_ESP_TIMER_ISR_AFFINITY_CPU0=y
 CONFIG_ESP_TIMER_IMPL_SYSTIMER=y
 # end of ESP Timer (High Resolution Timer)
 
-#
-# Wi-Fi
-#
-CONFIG_ESP_WIFI_ENABLED=y
-CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM=10
-CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM=32
-# CONFIG_ESP_WIFI_STATIC_TX_BUFFER is not set
-CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER=y
-CONFIG_ESP_WIFI_TX_BUFFER_TYPE=1
-CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM=32
-CONFIG_ESP_WIFI_STATIC_RX_MGMT_BUFFER=y
-# CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER is not set
-CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUF=0
-CONFIG_ESP_WIFI_RX_MGMT_BUF_NUM_DEF=5
-# CONFIG_ESP_WIFI_CSI_ENABLED is not set
-CONFIG_ESP_WIFI_AMPDU_TX_ENABLED=y
-CONFIG_ESP_WIFI_TX_BA_WIN=6
-CONFIG_ESP_WIFI_AMPDU_RX_ENABLED=y
-CONFIG_ESP_WIFI_RX_BA_WIN=6
-CONFIG_ESP_WIFI_NVS_ENABLED=y
-CONFIG_ESP_WIFI_SOFTAP_BEACON_MAX_LEN=752
-CONFIG_ESP_WIFI_MGMT_SBUF_NUM=32
-CONFIG_ESP_WIFI_IRAM_OPT=y
-# CONFIG_ESP_WIFI_EXTRA_IRAM_OPT is not set
-CONFIG_ESP_WIFI_RX_IRAM_OPT=y
-CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=y
-CONFIG_ESP_WIFI_ENABLE_SAE_PK=y
-CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT=y
-CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA=y
-# CONFIG_ESP_WIFI_SLP_IRAM_OPT is not set
-CONFIG_ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME=50
-CONFIG_ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME=10
-CONFIG_ESP_WIFI_SLP_DEFAULT_WAIT_BROADCAST_DATA_TIME=15
-# CONFIG_ESP_WIFI_FTM_ENABLE is not set
-CONFIG_ESP_WIFI_STA_DISCONNECTED_PM_ENABLE=y
-# CONFIG_ESP_WIFI_GCMP_SUPPORT is not set
-CONFIG_ESP_WIFI_GMAC_SUPPORT=y
-CONFIG_ESP_WIFI_SOFTAP_SUPPORT=y
-# CONFIG_ESP_WIFI_SLP_BEACON_LOST_OPT is not set
-CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM=7
-CONFIG_ESP_WIFI_MBEDTLS_CRYPTO=y
-CONFIG_ESP_WIFI_MBEDTLS_TLS_CLIENT=y
-# CONFIG_ESP_WIFI_WAPI_PSK is not set
-# CONFIG_ESP_WIFI_SUITE_B_192 is not set
-# CONFIG_ESP_WIFI_11KV_SUPPORT is not set
-# CONFIG_ESP_WIFI_MBO_SUPPORT is not set
-# CONFIG_ESP_WIFI_DPP_SUPPORT is not set
-# CONFIG_ESP_WIFI_11R_SUPPORT is not set
-# CONFIG_ESP_WIFI_WPS_SOFTAP_REGISTRAR is not set
-
-#
-# WPS Configuration Options
-#
-# CONFIG_ESP_WIFI_WPS_STRICT is not set
-# CONFIG_ESP_WIFI_WPS_PASSPHRASE is not set
-# end of WPS Configuration Options
-
-# CONFIG_ESP_WIFI_DEBUG_PRINT is not set
-# CONFIG_ESP_WIFI_TESTING_OPTIONS is not set
-CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=y
-# CONFIG_ESP_WIFI_ENT_FREE_DYNAMIC_BUFFER is not set
-# end of Wi-Fi
-
-#
-# Core dump
-#
-# CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH is not set
-# CONFIG_ESP_COREDUMP_ENABLE_TO_UART is not set
-CONFIG_ESP_COREDUMP_ENABLE_TO_NONE=y
-# end of Core dump
-
-#
-# FAT Filesystem support
-#
-CONFIG_FATFS_VOLUME_COUNT=2
-CONFIG_FATFS_LFN_NONE=y
-# CONFIG_FATFS_LFN_HEAP is not set
-# CONFIG_FATFS_LFN_STACK is not set
-# CONFIG_FATFS_SECTOR_512 is not set
-CONFIG_FATFS_SECTOR_4096=y
-# CONFIG_FATFS_CODEPAGE_DYNAMIC is not set
-CONFIG_FATFS_CODEPAGE_437=y
-# CONFIG_FATFS_CODEPAGE_720 is not set
-# CONFIG_FATFS_CODEPAGE_737 is not set
-# CONFIG_FATFS_CODEPAGE_771 is not set
-# CONFIG_FATFS_CODEPAGE_775 is not set
-# CONFIG_FATFS_CODEPAGE_850 is not set
-# CONFIG_FATFS_CODEPAGE_852 is not set
-# CONFIG_FATFS_CODEPAGE_855 is not set
-# CONFIG_FATFS_CODEPAGE_857 is not set
-# CONFIG_FATFS_CODEPAGE_860 is not set
-# CONFIG_FATFS_CODEPAGE_861 is not set
-# CONFIG_FATFS_CODEPAGE_862 is not set
-# CONFIG_FATFS_CODEPAGE_863 is not set
-# CONFIG_FATFS_CODEPAGE_864 is not set
-# CONFIG_FATFS_CODEPAGE_865 is not set
-# CONFIG_FATFS_CODEPAGE_866 is not set
-# CONFIG_FATFS_CODEPAGE_869 is not set
-# CONFIG_FATFS_CODEPAGE_932 is not set
-# CONFIG_FATFS_CODEPAGE_936 is not set
-# CONFIG_FATFS_CODEPAGE_949 is not set
-# CONFIG_FATFS_CODEPAGE_950 is not set
-CONFIG_FATFS_CODEPAGE=437
-CONFIG_FATFS_FS_LOCK=0
-CONFIG_FATFS_TIMEOUT_MS=10000
-CONFIG_FATFS_PER_FILE_CACHE=y
-# CONFIG_FATFS_USE_FASTSEEK is not set
-CONFIG_FATFS_USE_STRFUNC_NONE=y
-# CONFIG_FATFS_USE_STRFUNC_WITHOUT_CRLF_CONV is not set
-# CONFIG_FATFS_USE_STRFUNC_WITH_CRLF_CONV is not set
-CONFIG_FATFS_VFS_FSTAT_BLKSIZE=0
-# CONFIG_FATFS_IMMEDIATE_FSYNC is not set
-# CONFIG_FATFS_USE_LABEL is not set
-CONFIG_FATFS_LINK_LOCK=y
-# end of FAT Filesystem support
-
 #
 # FreeRTOS
 #
@@ -1223,7 +964,6 @@ CONFIG_HAL_ASSERTION_EQUALS_SYSTEM=y
 CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=2
 CONFIG_HAL_SPI_MASTER_FUNC_IN_IRAM=y
 CONFIG_HAL_SPI_SLAVE_FUNC_IN_IRAM=y
-# CONFIG_HAL_ECDSA_GEN_SIG_CM is not set
 # end of Hardware Abstraction Layer (HAL) and Low Level (LL)
 
 #
@@ -1283,189 +1023,6 @@ CONFIG_LOG_TIMESTAMP_SOURCE_RTOS=y
 # end of Format
 # end of Log
 
-#
-# LWIP
-#
-CONFIG_LWIP_ENABLE=y
-CONFIG_LWIP_LOCAL_HOSTNAME="espressif"
-# CONFIG_LWIP_NETIF_API is not set
-CONFIG_LWIP_TCPIP_TASK_PRIO=18
-# CONFIG_LWIP_TCPIP_CORE_LOCKING is not set
-# CONFIG_LWIP_CHECK_THREAD_SAFETY is not set
-CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
-# CONFIG_LWIP_L2_TO_L3_COPY is not set
-# CONFIG_LWIP_IRAM_OPTIMIZATION is not set
-# CONFIG_LWIP_EXTRA_IRAM_OPTIMIZATION is not set
-CONFIG_LWIP_TIMERS_ONDEMAND=y
-CONFIG_LWIP_ND6=y
-# CONFIG_LWIP_FORCE_ROUTER_FORWARDING is not set
-CONFIG_LWIP_MAX_SOCKETS=10
-# CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set
-# CONFIG_LWIP_SO_LINGER is not set
-CONFIG_LWIP_SO_REUSE=y
-CONFIG_LWIP_SO_REUSE_RXTOALL=y
-# CONFIG_LWIP_SO_RCVBUF is not set
-# CONFIG_LWIP_NETBUF_RECVINFO is not set
-CONFIG_LWIP_IP_DEFAULT_TTL=64
-CONFIG_LWIP_IP4_FRAG=y
-CONFIG_LWIP_IP6_FRAG=y
-# CONFIG_LWIP_IP4_REASSEMBLY is not set
-# CONFIG_LWIP_IP6_REASSEMBLY is not set
-CONFIG_LWIP_IP_REASS_MAX_PBUFS=10
-# CONFIG_LWIP_IP_FORWARD is not set
-# CONFIG_LWIP_STATS is not set
-CONFIG_LWIP_ESP_GRATUITOUS_ARP=y
-CONFIG_LWIP_GARP_TMR_INTERVAL=60
-CONFIG_LWIP_ESP_MLDV6_REPORT=y
-CONFIG_LWIP_MLDV6_TMR_INTERVAL=40
-CONFIG_LWIP_TCPIP_RECVMBOX_SIZE=32
-CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y
-# CONFIG_LWIP_DHCP_DOES_ACD_CHECK is not set
-# CONFIG_LWIP_DHCP_DOES_NOT_CHECK_OFFERED_IP is not set
-# CONFIG_LWIP_DHCP_DISABLE_CLIENT_ID is not set
-CONFIG_LWIP_DHCP_DISABLE_VENDOR_CLASS_ID=y
-# CONFIG_LWIP_DHCP_RESTORE_LAST_IP is not set
-CONFIG_LWIP_DHCP_OPTIONS_LEN=68
-CONFIG_LWIP_NUM_NETIF_CLIENT_DATA=0
-CONFIG_LWIP_DHCP_COARSE_TIMER_SECS=1
-
-#
-# DHCP server
-#
-CONFIG_LWIP_DHCPS=y
-CONFIG_LWIP_DHCPS_LEASE_UNIT=60
-CONFIG_LWIP_DHCPS_MAX_STATION_NUM=8
-CONFIG_LWIP_DHCPS_STATIC_ENTRIES=y
-CONFIG_LWIP_DHCPS_ADD_DNS=y
-# end of DHCP server
-
-# CONFIG_LWIP_AUTOIP is not set
-CONFIG_LWIP_IPV4=y
-CONFIG_LWIP_IPV6=y
-# CONFIG_LWIP_IPV6_AUTOCONFIG is not set
-CONFIG_LWIP_IPV6_NUM_ADDRESSES=3
-# CONFIG_LWIP_IPV6_FORWARD is not set
-# CONFIG_LWIP_NETIF_STATUS_CALLBACK is not set
-CONFIG_LWIP_NETIF_LOOPBACK=y
-CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8
-
-#
-# TCP
-#
-CONFIG_LWIP_MAX_ACTIVE_TCP=16
-CONFIG_LWIP_MAX_LISTENING_TCP=16
-CONFIG_LWIP_TCP_HIGH_SPEED_RETRANSMISSION=y
-CONFIG_LWIP_TCP_MAXRTX=12
-CONFIG_LWIP_TCP_SYNMAXRTX=12
-CONFIG_LWIP_TCP_MSS=1440
-CONFIG_LWIP_TCP_TMR_INTERVAL=250
-CONFIG_LWIP_TCP_MSL=60000
-CONFIG_LWIP_TCP_FIN_WAIT_TIMEOUT=20000
-CONFIG_LWIP_TCP_SND_BUF_DEFAULT=5760
-CONFIG_LWIP_TCP_WND_DEFAULT=5760
-CONFIG_LWIP_TCP_RECVMBOX_SIZE=6
-CONFIG_LWIP_TCP_ACCEPTMBOX_SIZE=6
-CONFIG_LWIP_TCP_QUEUE_OOSEQ=y
-CONFIG_LWIP_TCP_OOSEQ_TIMEOUT=6
-CONFIG_LWIP_TCP_OOSEQ_MAX_PBUFS=4
-# CONFIG_LWIP_TCP_SACK_OUT is not set
-CONFIG_LWIP_TCP_OVERSIZE_MSS=y
-# CONFIG_LWIP_TCP_OVERSIZE_QUARTER_MSS is not set
-# CONFIG_LWIP_TCP_OVERSIZE_DISABLE is not set
-CONFIG_LWIP_TCP_RTO_TIME=1500
-# end of TCP
-
-#
-# UDP
-#
-CONFIG_LWIP_MAX_UDP_PCBS=16
-CONFIG_LWIP_UDP_RECVMBOX_SIZE=6
-# end of UDP
-
-#
-# Checksums
-#
-# CONFIG_LWIP_CHECKSUM_CHECK_IP is not set
-# CONFIG_LWIP_CHECKSUM_CHECK_UDP is not set
-CONFIG_LWIP_CHECKSUM_CHECK_ICMP=y
-# end of Checksums
-
-CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=3072
-CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
-# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set
-CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF
-CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE=3
-CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS=5
-CONFIG_LWIP_IPV6_ND6_NUM_PREFIXES=5
-CONFIG_LWIP_IPV6_ND6_NUM_ROUTERS=3
-CONFIG_LWIP_IPV6_ND6_NUM_DESTINATIONS=10
-# CONFIG_LWIP_PPP_SUPPORT is not set
-# CONFIG_LWIP_SLIP_SUPPORT is not set
-
-#
-# ICMP
-#
-CONFIG_LWIP_ICMP=y
-# CONFIG_LWIP_MULTICAST_PING is not set
-# CONFIG_LWIP_BROADCAST_PING is not set
-# end of ICMP
-
-#
-# LWIP RAW API
-#
-CONFIG_LWIP_MAX_RAW_PCBS=16
-# end of LWIP RAW API
-
-#
-# SNTP
-#
-CONFIG_LWIP_SNTP_MAX_SERVERS=1
-# CONFIG_LWIP_DHCP_GET_NTP_SRV is not set
-CONFIG_LWIP_SNTP_UPDATE_DELAY=3600000
-CONFIG_LWIP_SNTP_STARTUP_DELAY=y
-CONFIG_LWIP_SNTP_MAXIMUM_STARTUP_DELAY=5000
-# end of SNTP
-
-#
-# DNS
-#
-CONFIG_LWIP_DNS_MAX_HOST_IP=1
-CONFIG_LWIP_DNS_MAX_SERVERS=3
-# CONFIG_LWIP_FALLBACK_DNS_SERVER_SUPPORT is not set
-# CONFIG_LWIP_DNS_SETSERVER_WITH_NETIF is not set
-# end of DNS
-
-CONFIG_LWIP_BRIDGEIF_MAX_PORTS=7
-CONFIG_LWIP_ESP_LWIP_ASSERT=y
-
-#
-# Hooks
-#
-# CONFIG_LWIP_HOOK_TCP_ISN_NONE is not set
-CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT=y
-# CONFIG_LWIP_HOOK_TCP_ISN_CUSTOM is not set
-CONFIG_LWIP_HOOK_IP6_ROUTE_NONE=y
-# CONFIG_LWIP_HOOK_IP6_ROUTE_DEFAULT is not set
-# CONFIG_LWIP_HOOK_IP6_ROUTE_CUSTOM is not set
-CONFIG_LWIP_HOOK_ND6_GET_GW_NONE=y
-# CONFIG_LWIP_HOOK_ND6_GET_GW_DEFAULT is not set
-# CONFIG_LWIP_HOOK_ND6_GET_GW_CUSTOM is not set
-CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_NONE=y
-# CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_DEFAULT is not set
-# CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_CUSTOM is not set
-CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE=y
-# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_DEFAULT is not set
-# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_CUSTOM is not set
-CONFIG_LWIP_HOOK_DNS_EXT_RESOLVE_NONE=y
-# CONFIG_LWIP_HOOK_DNS_EXT_RESOLVE_CUSTOM is not set
-# CONFIG_LWIP_HOOK_IP6_INPUT_NONE is not set
-CONFIG_LWIP_HOOK_IP6_INPUT_DEFAULT=y
-# CONFIG_LWIP_HOOK_IP6_INPUT_CUSTOM is not set
-# end of Hooks
-
-# CONFIG_LWIP_DEBUG is not set
-# end of LWIP
-
 #
 # mbedTLS
 #
@@ -1519,6 +1076,7 @@ CONFIG_MBEDTLS_HAVE_TIME=y
 # CONFIG_MBEDTLS_PLATFORM_TIME_ALT is not set
 # CONFIG_MBEDTLS_HAVE_TIME_DATE is not set
 CONFIG_MBEDTLS_ECDSA_DETERMINISTIC=y
+CONFIG_MBEDTLS_SHA1_C=y
 CONFIG_MBEDTLS_SHA512_C=y
 # CONFIG_MBEDTLS_SHA3_C is not set
 CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y
@@ -1599,25 +1157,9 @@ CONFIG_MBEDTLS_ECP_NIST_OPTIM=y
 # CONFIG_MBEDTLS_HKDF_C is not set
 # CONFIG_MBEDTLS_THREADING_C is not set
 CONFIG_MBEDTLS_ERROR_STRINGS=y
-CONFIG_MBEDTLS_FS_IO=y
+# CONFIG_MBEDTLS_ALLOW_WEAK_CERTIFICATE_VERIFICATION is not set
 # end of mbedTLS
 
-#
-# ESP-MQTT Configurations
-#
-CONFIG_MQTT_PROTOCOL_311=y
-# CONFIG_MQTT_PROTOCOL_5 is not set
-CONFIG_MQTT_TRANSPORT_SSL=y
-CONFIG_MQTT_TRANSPORT_WEBSOCKET=y
-CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=y
-# CONFIG_MQTT_MSG_ID_INCREMENTAL is not set
-# CONFIG_MQTT_SKIP_PUBLISH_IF_DISCONNECTED is not set
-# CONFIG_MQTT_REPORT_DELETED_MESSAGES is not set
-# CONFIG_MQTT_USE_CUSTOM_CONFIG is not set
-# CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED is not set
-# CONFIG_MQTT_CUSTOM_OUTBOX is not set
-# end of ESP-MQTT Configurations
-
 #
 # Newlib
 #
@@ -1634,34 +1176,6 @@ CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC_HRT=y
 # CONFIG_NEWLIB_TIME_SYSCALL_USE_NONE is not set
 # end of Newlib
 
-#
-# NVS
-#
-# CONFIG_NVS_ENCRYPTION is not set
-# CONFIG_NVS_ASSERT_ERROR_CHECK is not set
-# CONFIG_NVS_LEGACY_DUP_KEYS_COMPATIBILITY is not set
-# end of NVS
-
-#
-# OpenThread
-#
-# CONFIG_OPENTHREAD_ENABLED is not set
-
-#
-# OpenThread Spinel
-#
-# CONFIG_OPENTHREAD_SPINEL_ONLY is not set
-# end of OpenThread Spinel
-# end of OpenThread
-
-#
-# Protocomm
-#
-CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_0=y
-CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_1=y
-CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_2=y
-# end of Protocomm
-
 #
 # PThreads
 #
@@ -1701,6 +1215,7 @@ CONFIG_SPI_FLASH_BROWNOUT_RESET=y
 # CONFIG_SPI_FLASH_AUTO_SUSPEND is not set
 CONFIG_SPI_FLASH_SUSPEND_TSUS_VAL_US=50
 # CONFIG_SPI_FLASH_FORCE_ENABLE_XMC_C_SUSPEND is not set
+# CONFIG_SPI_FLASH_FORCE_ENABLE_C6_H2_SUSPEND is not set
 # end of Optional and Experimental Features (READ DOCS FIRST)
 # end of Main Flash configuration
 
@@ -1744,55 +1259,6 @@ CONFIG_SPI_FLASH_SUPPORT_TH_CHIP=y
 CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE=y
 # end of SPI Flash driver
 
-#
-# SPIFFS Configuration
-#
-CONFIG_SPIFFS_MAX_PARTITIONS=3
-
-#
-# SPIFFS Cache Configuration
-#
-CONFIG_SPIFFS_CACHE=y
-CONFIG_SPIFFS_CACHE_WR=y
-# CONFIG_SPIFFS_CACHE_STATS is not set
-# end of SPIFFS Cache Configuration
-
-CONFIG_SPIFFS_PAGE_CHECK=y
-CONFIG_SPIFFS_GC_MAX_RUNS=10
-# CONFIG_SPIFFS_GC_STATS is not set
-CONFIG_SPIFFS_PAGE_SIZE=256
-CONFIG_SPIFFS_OBJ_NAME_LEN=32
-# CONFIG_SPIFFS_FOLLOW_SYMLINKS is not set
-CONFIG_SPIFFS_USE_MAGIC=y
-CONFIG_SPIFFS_USE_MAGIC_LENGTH=y
-CONFIG_SPIFFS_META_LENGTH=4
-CONFIG_SPIFFS_USE_MTIME=y
-
-#
-# Debug Configuration
-#
-# CONFIG_SPIFFS_DBG is not set
-# CONFIG_SPIFFS_API_DBG is not set
-# CONFIG_SPIFFS_GC_DBG is not set
-# CONFIG_SPIFFS_CACHE_DBG is not set
-# CONFIG_SPIFFS_CHECK_DBG is not set
-# CONFIG_SPIFFS_TEST_VISUALISATION is not set
-# end of Debug Configuration
-# end of SPIFFS Configuration
-
-#
-# TCP Transport
-#
-
-#
-# Websocket
-#
-CONFIG_WS_TRANSPORT=y
-CONFIG_WS_BUFFER_SIZE=1024
-# CONFIG_WS_DYNAMIC_BUFFER is not set
-# end of Websocket
-# end of TCP Transport
-
 #
 # Unity unit testing library
 #
@@ -1805,43 +1271,6 @@ CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=y
 # CONFIG_UNITY_ENABLE_BACKTRACE_ON_FAIL is not set
 # end of Unity unit testing library
 
-#
-# Virtual file system
-#
-CONFIG_VFS_SUPPORT_IO=y
-CONFIG_VFS_SUPPORT_DIR=y
-CONFIG_VFS_SUPPORT_SELECT=y
-CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=y
-# CONFIG_VFS_SELECT_IN_RAM is not set
-CONFIG_VFS_SUPPORT_TERMIOS=y
-CONFIG_VFS_MAX_COUNT=8
-
-#
-# Host File System I/O (Semihosting)
-#
-CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS=1
-# end of Host File System I/O (Semihosting)
-
-CONFIG_VFS_INITIALIZE_DEV_NULL=y
-# end of Virtual file system
-
-#
-# Wear Levelling
-#
-# CONFIG_WL_SECTOR_SIZE_512 is not set
-CONFIG_WL_SECTOR_SIZE_4096=y
-CONFIG_WL_SECTOR_SIZE=4096
-# end of Wear Levelling
-
-#
-# Wi-Fi Provisioning Manager
-#
-CONFIG_WIFI_PROV_SCAN_MAX_ENTRIES=16
-CONFIG_WIFI_PROV_AUTOSTOP_TIMEOUT=30
-CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y
-# CONFIG_WIFI_PROV_STA_FAST_SCAN is not set
-# end of Wi-Fi Provisioning Manager
-
 #
 # Relay Channel Driver Configuration
 #
@@ -1885,17 +1314,9 @@ CONFIG_STACK_CHECK_NONE=y
 # CONFIG_STACK_CHECK_STRONG is not set
 # CONFIG_STACK_CHECK_ALL is not set
 # CONFIG_WARN_WRITE_STRINGS is not set
-# CONFIG_ESP32_APPTRACE_DEST_TRAX is not set
-CONFIG_ESP32_APPTRACE_DEST_NONE=y
-CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y
-# CONFIG_EXTERNAL_COEX_ENABLE is not set
-# CONFIG_ESP_WIFI_EXTERNAL_COEXIST_ENABLE is not set
 # CONFIG_EVENT_LOOP_PROFILING is not set
 CONFIG_POST_EVENTS_FROM_ISR=y
 CONFIG_POST_EVENTS_FROM_IRAM_ISR=y
-CONFIG_GDBSTUB_SUPPORT_TASKS=y
-CONFIG_GDBSTUB_MAX_TASKS=32
-# CONFIG_OTA_ALLOW_HTTP is not set
 # CONFIG_ESP_SYSTEM_PD_FLASH is not set
 CONFIG_ESP32C3_LIGHTSLEEP_GPIO_RESET_WORKAROUND=y
 CONFIG_ESP32C3_RTC_CLK_SRC_INT_RC=y
@@ -1903,12 +1324,6 @@ CONFIG_ESP32C3_RTC_CLK_SRC_INT_RC=y
 # CONFIG_ESP32C3_RTC_CLK_SRC_EXT_OSC is not set
 # CONFIG_ESP32C3_RTC_CLK_SRC_INT_8MD256 is not set
 CONFIG_ESP32C3_RTC_CLK_CAL_CYCLES=1024
-CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE=y
-# CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION is not set
-CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER=20
-CONFIG_ESP32_PHY_MAX_TX_POWER=20
-# CONFIG_REDUCE_PHY_TX_POWER is not set
-# CONFIG_ESP32_REDUCE_PHY_TX_POWER is not set
 CONFIG_ESP_SYSTEM_PM_POWER_DOWN_CPU=y
 # CONFIG_ESP32C3_DEFAULT_CPU_FREQ_80 is not set
 CONFIG_ESP32C3_DEFAULT_CPU_FREQ_160=y
@@ -1936,7 +1351,6 @@ CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=y
 CONFIG_ESP32C3_DEBUG_OCDAWARE=y
 CONFIG_BROWNOUT_DET=y
 CONFIG_ESP32C3_BROWNOUT_DET=y
-CONFIG_ESP32C3_BROWNOUT_DET=y
 CONFIG_BROWNOUT_DET_LVL_SEL_7=y
 CONFIG_ESP32C3_BROWNOUT_DET_LVL_SEL_7=y
 # CONFIG_BROWNOUT_DET_LVL_SEL_6 is not set
@@ -1953,68 +1367,11 @@ CONFIG_BROWNOUT_DET_LVL=7
 CONFIG_ESP32C3_BROWNOUT_DET_LVL=7
 CONFIG_IPC_TASK_STACK_SIZE=1024
 CONFIG_TIMER_TASK_STACK_SIZE=3584
-CONFIG_ESP32_WIFI_ENABLED=y
-CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=10
-CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=32
-# CONFIG_ESP32_WIFI_STATIC_TX_BUFFER is not set
-CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER=y
-CONFIG_ESP32_WIFI_TX_BUFFER_TYPE=1
-CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM=32
-# CONFIG_ESP32_WIFI_CSI_ENABLED is not set
-CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED=y
-CONFIG_ESP32_WIFI_TX_BA_WIN=6
-CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y
-CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y
-CONFIG_ESP32_WIFI_RX_BA_WIN=6
-CONFIG_ESP32_WIFI_RX_BA_WIN=6
-CONFIG_ESP32_WIFI_NVS_ENABLED=y
-CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752
-CONFIG_ESP32_WIFI_MGMT_SBUF_NUM=32
-CONFIG_ESP32_WIFI_IRAM_OPT=y
-CONFIG_ESP32_WIFI_RX_IRAM_OPT=y
-CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE=y
-CONFIG_ESP32_WIFI_ENABLE_WPA3_OWE_STA=y
-CONFIG_WPA_MBEDTLS_CRYPTO=y
-CONFIG_WPA_MBEDTLS_TLS_CLIENT=y
-# CONFIG_WPA_WAPI_PSK is not set
-# CONFIG_WPA_SUITE_B_192 is not set
-# CONFIG_WPA_11KV_SUPPORT is not set
-# CONFIG_WPA_MBO_SUPPORT is not set
-# CONFIG_WPA_DPP_SUPPORT is not set
-# CONFIG_WPA_11R_SUPPORT is not set
-# CONFIG_WPA_WPS_SOFTAP_REGISTRAR is not set
-# CONFIG_WPA_WPS_STRICT is not set
-# CONFIG_WPA_DEBUG_PRINT is not set
-# CONFIG_WPA_TESTING_OPTIONS is not set
-# CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH is not set
-# CONFIG_ESP32_ENABLE_COREDUMP_TO_UART is not set
-CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y
 CONFIG_TIMER_TASK_PRIORITY=1
 CONFIG_TIMER_TASK_STACK_DEPTH=2048
 CONFIG_TIMER_QUEUE_LENGTH=10
 # CONFIG_ENABLE_STATIC_TASK_CLEAN_UP_HOOK is not set
 # CONFIG_HAL_ASSERTION_SILIENT is not set
-# CONFIG_L2_TO_L3_COPY is not set
-CONFIG_ESP_GRATUITOUS_ARP=y
-CONFIG_GARP_TMR_INTERVAL=60
-CONFIG_TCPIP_RECVMBOX_SIZE=32
-CONFIG_TCP_MAXRTX=12
-CONFIG_TCP_SYNMAXRTX=12
-CONFIG_TCP_MSS=1440
-CONFIG_TCP_MSL=60000
-CONFIG_TCP_SND_BUF_DEFAULT=5760
-CONFIG_TCP_WND_DEFAULT=5760
-CONFIG_TCP_RECVMBOX_SIZE=6
-CONFIG_TCP_QUEUE_OOSEQ=y
-CONFIG_TCP_OVERSIZE_MSS=y
-# CONFIG_TCP_OVERSIZE_QUARTER_MSS is not set
-# CONFIG_TCP_OVERSIZE_DISABLE is not set
-CONFIG_UDP_RECVMBOX_SIZE=6
-CONFIG_TCPIP_TASK_STACK_SIZE=3072
-CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
-# CONFIG_TCPIP_TASK_AFFINITY_CPU0 is not set
-CONFIG_TCPIP_TASK_AFFINITY=0x7FFFFFFF
-# CONFIG_PPP_SUPPORT is not set
 CONFIG_ESP32C3_TIME_SYSCALL_USE_RTC_SYSTIMER=y
 # CONFIG_ESP32C3_TIME_SYSCALL_USE_RTC is not set
 # CONFIG_ESP32C3_TIME_SYSCALL_USE_SYSTIMER is not set
@@ -2027,7 +1384,4 @@ CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT="pthread"
 CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS=y
 # CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_FAILS is not set
 # CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ALLOWED is not set
-CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT=y
-CONFIG_SUPPORT_TERMIOS=y
-CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS=1
 # End of deprecated options

test_apps/sdkconfig.defaults

@@ -0,0 +1,4 @@
+# Relay Channel Driver Default Configuration for Testing
+CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS=200
+CONFIG_RELAY_CHN_COUNT=2
+CONFIG_RELAY_CHN_ENABLE_TILTING=y