Optimize logging, improve UART/WebSocket tasks, and update configuration.

Signed-off-by: YoungSoo Shin <shinys000114@gmail.com>

main/service/control.c

@@ -8,15 +8,11 @@
 #include "freertos/semphr.h"
 #include "esp_timer.h"
 
-static const char *TAG = "CONTROL";
-
-// --- GPIO 핀 정의 ---
 #define GPIO_12V_SWITCH CONFIG_GPIO_SW_12V
 #define GPIO_5V_SWITCH  CONFIG_GPIO_SW_5V
 #define GPIO_POWER_TRIGGER CONFIG_GPIO_TRIGGER_POWER
 #define GPIO_RESET_TRIGGER CONFIG_GPIO_TRIGGER_RESET
 
-// --- 상태 변수, 뮤텍스 및 타이머 핸들 ---
 static bool status_12v_on = false;
 static bool status_5v_on = false;
 static SemaphoreHandle_t state_mutex;
@@ -30,14 +26,12 @@ static void trigger_off_callback(void* arg)
 {
     gpio_num_t gpio_pin = (int) arg;
     gpio_set_level(gpio_pin, 1); // 핀을 다시 HIGH로 복구
-    ESP_LOGI(TAG, "GPIO %d trigger finished.", gpio_pin);
 }
 
 static void update_gpio_switches()
 {
     gpio_set_level(GPIO_12V_SWITCH, status_12v_on);
     gpio_set_level(GPIO_5V_SWITCH, status_5v_on);
-    ESP_LOGI(TAG, "Switches updated: 12V=%s, 5V=%s", status_12v_on ? "ON" : "OFF", status_5v_on ? "ON" : "OFF");
 }
 
 static esp_err_t control_get_handler(httpd_req_t *req)
@@ -77,7 +71,6 @@ static esp_err_t control_post_handler(httpd_req_t *req)
         return ESP_FAIL;
     }
     buf[ret] = '\0';
-    ESP_LOGI(TAG, "Received JSON: %s", buf);
 
     cJSON *root = cJSON_Parse(buf);
     if (root == NULL) {
@@ -107,7 +100,6 @@ static esp_err_t control_post_handler(httpd_req_t *req)
 
     cJSON *power_trigger = cJSON_GetObjectItem(root, "power_trigger");
     if (cJSON_IsTrue(power_trigger)) {
-        ESP_LOGI(TAG, "Triggering GPIO %d LOW for 3 seconds...", GPIO_POWER_TRIGGER);
         gpio_set_level(GPIO_POWER_TRIGGER, 0);
         esp_timer_stop(power_trigger_timer); // Stop timer if it's already running
         ESP_ERROR_CHECK(esp_timer_start_once(power_trigger_timer, 3000000)); // 3초
@@ -115,7 +107,6 @@ static esp_err_t control_post_handler(httpd_req_t *req)
 
     cJSON *reset_trigger = cJSON_GetObjectItem(root, "reset_trigger");
     if (cJSON_IsTrue(reset_trigger)) {
-        ESP_LOGI(TAG, "Triggering GPIO %d LOW for 3 seconds...", GPIO_RESET_TRIGGER);
         gpio_set_level(GPIO_RESET_TRIGGER, 0);
         esp_timer_stop(reset_trigger_timer); // Stop timer if it's already running
         ESP_ERROR_CHECK(esp_timer_start_once(reset_trigger_timer, 3000000)); // 3초
@@ -166,7 +157,6 @@ static void control_module_init(void)
     };
     ESP_ERROR_CHECK(esp_timer_create(&reset_timer_args, &reset_trigger_timer));
 
-    ESP_LOGI(TAG, "Control module initialized");
 }
 
 void register_control_endpoint(httpd_handle_t server)
@@ -188,5 +178,4 @@ void register_control_endpoint(httpd_handle_t server)
     };
     httpd_register_uri_handler(server, &post_uri);
 
-    ESP_LOGI(TAG, "Registered /api/control endpoints (GET, POST)");
 }

main/service/webserver.c

@@ -1,26 +1,16 @@
 #include "webserver.h"
 #include <stdio.h>
 #include <string.h>
-#include <sys/param.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "freertos/queue.h"
-#include "esp_system.h"
 #include "esp_wifi.h"
-#include "esp_event.h"
 #include "esp_log.h"
-#include "nvs_flash.h"
-#include "esp_netif.h"
-#include "driver/uart.h"
 #include "esp_http_server.h"
-#include "indicator.h"
 #include "nconfig.h"
 #include "monitor.h"
-#include "wifi.h"
 #include "datalog.h"
 
 #include "lwip/err.h"
-#include "lwip/sockets.h"
 #include "lwip/sys.h"
 
 static const char *TAG = "WEBSERVER";

main/service/ws.c

@@ -9,6 +9,7 @@
 #include "esp_log.h"
 #include "nconfig.h"
 #include "driver/uart.h"
+#include "freertos/semphr.h"
 
 #define UART_NUM UART_NUM_1
 #define BUF_SIZE (4096)
@@ -19,23 +20,39 @@
 static const char *TAG = "ws-uart";
 
 static int client_fd = -1;
+static SemaphoreHandle_t client_fd_mutex;
 
 struct status_message
 {
     cJSON *data;
 };
 
+struct uart_to_ws_message
+{
+    uint8_t *data;
+    size_t len;
+};
+
 QueueHandle_t status_queue;
+static QueueHandle_t uart_to_ws_queue;
 
 // Status task
 static void status_task(void *arg)
 {
     httpd_handle_t server = (httpd_handle_t)arg;
     struct status_message msg;
+    const TickType_t PING_INTERVAL = pdMS_TO_TICKS(5000);
 
     while (1) {
-        if (xQueueReceive(status_queue, &msg, portMAX_DELAY)) {
+        if (xQueueReceive(status_queue, &msg, PING_INTERVAL)) {
-            if (client_fd <= 0) continue;
+            xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
+            int fd = client_fd;
+            xSemaphoreGive(client_fd_mutex);
+
+            if (fd <= 0) {
+                cJSON_Delete(msg.data);
+                continue;
+            }
 
             char *json_string = cJSON_Print(msg.data);
             httpd_ws_frame_t ws_pkt;
@@ -43,69 +60,149 @@ static void status_task(void *arg)
             ws_pkt.payload = (uint8_t *)json_string;
             ws_pkt.len = strlen(json_string);
             ws_pkt.type = HTTPD_WS_TYPE_TEXT;
-            esp_err_t err = httpd_ws_send_frame_async(server, client_fd, &ws_pkt);
+            esp_err_t err = httpd_ws_send_frame_async(server, fd, &ws_pkt);
             free(json_string);
             cJSON_Delete(msg.data);
 
             if (err != ESP_OK)
             {
-                // try close...
+                ESP_LOGW(TAG, "status_task: async send failed for fd %d, error: %s", fd, esp_err_to_name(err));
-                httpd_ws_frame_t close_frame = {
+                xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
-                    .final = true,
+                if (client_fd == fd) {
-                    .fragmented = false,
+                    client_fd = -1;
-                    .type = HTTPD_WS_TYPE_CLOSE,
+                }
-                    .payload = NULL,
+                xSemaphoreGive(client_fd_mutex);
-                    .len = 0
+            }
-                };
+        } else {
+            // Queue receive timed out, send a PING to keep connection alive
+            xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
+            int fd = client_fd;
+            xSemaphoreGive(client_fd_mutex);
 
-                httpd_ws_send_frame_async(server, client_fd, &close_frame);
+            if (fd > 0) {
-                client_fd = -1;
+                httpd_ws_frame_t ping_pkt;
+                memset(&ping_pkt, 0, sizeof(httpd_ws_frame_t));
+                ping_pkt.type = HTTPD_WS_TYPE_PING;
+                ping_pkt.final = true;
+                if (httpd_ws_send_frame_async(server, fd, &ping_pkt) != ESP_OK) {
+                    ESP_LOGW(TAG, "Failed to send PING frame, closing connection for fd %d", fd);
+                    xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
+                    if (client_fd == fd) {
+                        client_fd = -1;
+                    }
+                    xSemaphoreGive(client_fd_mutex);
+                }
             }
         }
-        vTaskDelay(1);
     }
 }
 
-// UART task
+static void ws_sender_task(void *arg)
-static void uart_read_task(void *arg) {
+{
     httpd_handle_t server = (httpd_handle_t)arg;
+    struct uart_to_ws_message msg;
 
-    uint8_t data[RD_BUF_SIZE];
     while (1) {
-        int len = uart_read_bytes(UART_NUM, data, RD_BUF_SIZE, 10 / portTICK_PERIOD_MS);
+        if (xQueueReceive(uart_to_ws_queue, &msg, portMAX_DELAY)) {
-        if (len > 0 && client_fd != -1) {
+            xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
-            httpd_ws_frame_t ws_pkt;
+            int fd = client_fd;
-            memset(&ws_pkt, 0, sizeof(httpd_ws_frame_t));
+            xSemaphoreGive(client_fd_mutex);
-            ws_pkt.payload = data;
-            ws_pkt.len = len;
-            ws_pkt.type = HTTPD_WS_TYPE_BINARY;
 
-            esp_err_t err = httpd_ws_send_frame_async(server, client_fd, &ws_pkt);
+            if (fd > 0) {
-            if (err != ESP_OK)
+                httpd_ws_frame_t ws_pkt;
-            {
+                memset(&ws_pkt, 0, sizeof(httpd_ws_frame_t));
-                // try close...
+                ws_pkt.payload = msg.data;
-                httpd_ws_frame_t close_frame = {
+                ws_pkt.len = msg.len;
-                    .final = true,
+                ws_pkt.type = HTTPD_WS_TYPE_BINARY;
-                    .fragmented = false,
-                    .type = HTTPD_WS_TYPE_CLOSE,
-                    .payload = NULL,
-                    .len = 0
-                };
 
-                httpd_ws_send_frame_async(server, client_fd, &close_frame);
+                esp_err_t err = httpd_ws_send_frame_async(server, fd, &ws_pkt);
-                client_fd = -1;
+                if (err != ESP_OK) {
+                    ESP_LOGW(TAG, "ws_sender_task: async send failed for fd %d, error: %s", fd, esp_err_to_name(err));
+                    xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
+                    if (client_fd == fd) {
+                        client_fd = -1;
+                    }
+                    xSemaphoreGive(client_fd_mutex);
+                }
+            }
+            free(msg.data);
+        }
+    }
+}
+
+static void uart_polling_task(void *arg)
+{
+    uint8_t* data_buf = (uint8_t*) malloc(RD_BUF_SIZE);
+    if (data_buf == NULL) {
+        ESP_LOGE(TAG, "Failed to allocate memory for UART polling buffer");
+        vTaskDelete(NULL);
+        return;
+    }
+
+    const TickType_t POLLING_INTERVAL = pdMS_TO_TICKS(10);
+
+    while(1) {
+        size_t available_len;
+        uart_get_buffered_data_len(UART_NUM, &available_len);
+
+        if (available_len > 0) {
+            xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
+            int current_fd = client_fd;
+            xSemaphoreGive(client_fd_mutex);
+
+            if (current_fd > 0) {
+                // Read a chunk of data, up to the buffer size
+                size_t read_size = available_len > RD_BUF_SIZE ? RD_BUF_SIZE : available_len;
+                int bytes_read = uart_read_bytes(UART_NUM, data_buf, read_size, POLLING_INTERVAL);
+
+                if (bytes_read > 0) {
+                    struct uart_to_ws_message msg;
+                    msg.data = malloc(bytes_read);
+                    if (msg.data) {
+                        memcpy(msg.data, data_buf, bytes_read);
+                        msg.len = bytes_read;
+                        // Use a small timeout to apply back-pressure if the queue is full
+                        if (xQueueSend(uart_to_ws_queue, &msg, pdMS_TO_TICKS(10)) != pdPASS) {
+                            ESP_LOGW(TAG, "ws sender queue full, dropping data");
+                            free(msg.data);
+                        }
+                    } else {
+                         ESP_LOGE(TAG, "Failed to allocate memory for uart ws msg");
+                    }
+                }
+            } else {
+                // No client connected, just discard the data
+                uart_flush_input(UART_NUM);
             }
         }
-        vTaskDelay(1);
+        vTaskDelay(POLLING_INTERVAL);
     }
+    free(data_buf);
+    vTaskDelete(NULL);
 }
 
 // 웹소켓 처리 핸들러
 static esp_err_t ws_handler(httpd_req_t *req) {
     if (req->method == HTTP_GET) {
-        ESP_LOGI(TAG, "Accept websocket connection");
+        xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
-        client_fd = httpd_req_to_sockfd(req);
+        if (client_fd > 0) {
+            // A client is already connected. Reject the new connection.
+            ESP_LOGW(TAG, "Another client tried to connect, but a session is already active. Rejecting.");
+            xSemaphoreGive(client_fd_mutex);
+            httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Another client is already connected");
+            return ESP_FAIL;
+        }
+
+        // No client is connected. Accept the new one.
+        int new_fd = httpd_req_to_sockfd(req);
+        ESP_LOGI(TAG, "Accepting new websocket connection: %d", new_fd);
+        client_fd = new_fd;
+        xSemaphoreGive(client_fd_mutex);
+
+        // Reset queues and flush UART buffer for the new session
         xQueueReset(status_queue);
+        xQueueReset(uart_to_ws_queue);
+        uart_flush_input(UART_NUM);
         return ESP_OK;
     }
 
@@ -117,7 +214,12 @@ static esp_err_t ws_handler(httpd_req_t *req) {
 
     esp_err_t ret = httpd_ws_recv_frame(req, &ws_pkt, BUF_SIZE);
     if (ret != ESP_OK) {
-        ESP_LOGI(TAG, "웹소켓 프레임 수신 실패");
+        ESP_LOGW(TAG, "httpd_ws_recv_frame failed with error: %s", esp_err_to_name(ret));
+        xSemaphoreTake(client_fd_mutex, portMAX_DELAY);
+        if (httpd_req_to_sockfd(req) == client_fd) {
+            client_fd = -1;
+        }
+        xSemaphoreGive(client_fd_mutex);
         return ret;
     }
 
@@ -145,7 +247,7 @@ void register_ws_endpoint(httpd_handle_t server)
 
     ESP_ERROR_CHECK(uart_param_config(UART_NUM, &uart_config));
     ESP_ERROR_CHECK(uart_set_pin(UART_NUM, UART_TX_PIN, UART_RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
-    ESP_ERROR_CHECK(uart_driver_install(UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 0, NULL, ESP_INTR_FLAG_IRAM));
+    ESP_ERROR_CHECK(uart_driver_install(UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 0, NULL, 0));
 
     httpd_uri_t ws = {
         .uri       = "/ws",
@@ -156,10 +258,13 @@ void register_ws_endpoint(httpd_handle_t server)
     };
     httpd_register_uri_handler(server, &ws);
 
+    client_fd_mutex = xSemaphoreCreateMutex();
     status_queue = xQueueCreate(10, sizeof(struct status_message));
+    uart_to_ws_queue = xQueueCreate(50, sizeof(struct uart_to_ws_message));
 
-    xTaskCreate(uart_read_task, "uart_read_task", 1024*6, server, 8, NULL);
+    xTaskCreate(uart_polling_task, "uart_polling_task", 1024*4, NULL, 8, NULL);
-    xTaskCreate(status_task, "status_task", 4096, server, 7, NULL);
+    xTaskCreate(status_task, "status_task", 4096, server, 8, NULL);
+    xTaskCreate(ws_sender_task, "ws_sender_task", 1024*6, server, 9, NULL);
 }
 
 void push_data_to_ws(cJSON *data)

sdkconfig

@@ -315,9 +315,9 @@ CONFIG_BOOTLOADER_PROJECT_VER=1
 # end of Bootloader manager
 
 CONFIG_BOOTLOADER_OFFSET_IN_FLASH=0x0
-CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
+# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE is not set
 # CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_DEBUG is not set
-# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF is not set
+CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF=y
 # CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_NONE is not set
 
 #
@@ -418,9 +418,9 @@ CONFIG_BOOT_ROM_LOG_ALWAYS_ON=y
 # Serial flasher config
 #
 # CONFIG_ESPTOOLPY_NO_STUB is not set
-# CONFIG_ESPTOOLPY_FLASHMODE_QIO is not set
+CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
 # CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set
-CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
+# CONFIG_ESPTOOLPY_FLASHMODE_DIO is not set
 # CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set
 CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y
 CONFIG_ESPTOOLPY_FLASHMODE="dio"
@@ -1032,21 +1032,21 @@ CONFIG_ESP_TIMER_IMPL_SYSTIMER=y
 # Wi-Fi
 #
 CONFIG_ESP_WIFI_ENABLED=y
-CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM=10
+CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM=20
-CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM=32
+CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM=40
 # 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_DYNAMIC_TX_BUFFER_NUM=40
 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_TX_BA_WIN=32
 CONFIG_ESP_WIFI_AMPDU_RX_ENABLED=y
-CONFIG_ESP_WIFI_RX_BA_WIN=6
+CONFIG_ESP_WIFI_RX_BA_WIN=32
 CONFIG_ESP_WIFI_NVS_ENABLED=y
 CONFIG_ESP_WIFI_SOFTAP_BEACON_MAX_LEN=752
 CONFIG_ESP_WIFI_MGMT_SBUF_NUM=32
@@ -1290,7 +1290,8 @@ 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_TCPIP_CORE_LOCKING=y
+CONFIG_LWIP_TCPIP_CORE_LOCKING_INPUT=y
 # CONFIG_LWIP_CHECK_THREAD_SAFETY is not set
 CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
 # CONFIG_LWIP_L2_TO_L3_COPY is not set
@@ -1318,7 +1319,7 @@ 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_TCPIP_RECVMBOX_SIZE=64
 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
@@ -1361,9 +1362,9 @@ 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_SND_BUF_DEFAULT=40960
-CONFIG_LWIP_TCP_WND_DEFAULT=5760
+CONFIG_LWIP_TCP_WND_DEFAULT=40960
-CONFIG_LWIP_TCP_RECVMBOX_SIZE=6
+CONFIG_LWIP_TCP_RECVMBOX_SIZE=64
 CONFIG_LWIP_TCP_ACCEPTMBOX_SIZE=6
 CONFIG_LWIP_TCP_QUEUE_OOSEQ=y
 CONFIG_LWIP_TCP_OOSEQ_TIMEOUT=6
@@ -1379,7 +1380,7 @@ CONFIG_LWIP_TCP_RTO_TIME=1500
 # UDP
 #
 CONFIG_LWIP_MAX_UDP_PCBS=16
-CONFIG_LWIP_UDP_RECVMBOX_SIZE=6
+CONFIG_LWIP_UDP_RECVMBOX_SIZE=64
 # end of UDP
 
 #
@@ -1867,6 +1868,13 @@ CONFIG_GPIO_TRIGGER_RESET=3
 # end of GPIO
 # end of ODROID-MONITOR
 
+#
+# tamp
+#
+CONFIG_TAMP_ESP32=y
+# CONFIG_TAMP_ESP32_AUTO_RESET_TASK_WDT is not set
+# end of tamp
+
 #
 # CMake Utilities
 #
@@ -1937,9 +1945,9 @@ CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y
 CONFIG_LOG_BOOTLOADER_LEVEL=3
 # CONFIG_APP_ROLLBACK_ENABLE is not set
 # CONFIG_FLASH_ENCRYPTION_ENABLED is not set
-# CONFIG_FLASHMODE_QIO is not set
+CONFIG_FLASHMODE_QIO=y
 # CONFIG_FLASHMODE_QOUT is not set
-CONFIG_FLASHMODE_DIO=y
+# CONFIG_FLASHMODE_DIO is not set
 # CONFIG_FLASHMODE_DOUT is not set
 CONFIG_MONITOR_BAUD=115200
 CONFIG_OPTIMIZATION_LEVEL_DEBUG=y
@@ -2026,19 +2034,19 @@ 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_STATIC_RX_BUFFER_NUM=20
-CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=32
+CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=40
 # 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_DYNAMIC_TX_BUFFER_NUM=40
 # 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_TX_BA_WIN=32
 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=32
-CONFIG_ESP32_WIFI_RX_BA_WIN=6
+CONFIG_ESP32_WIFI_RX_BA_WIN=32
 CONFIG_ESP32_WIFI_NVS_ENABLED=y
 CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752
 CONFIG_ESP32_WIFI_MGMT_SBUF_NUM=32
@@ -2069,19 +2077,19 @@ CONFIG_TIMER_QUEUE_LENGTH=10
 # CONFIG_L2_TO_L3_COPY is not set
 CONFIG_ESP_GRATUITOUS_ARP=y
 CONFIG_GARP_TMR_INTERVAL=60
-CONFIG_TCPIP_RECVMBOX_SIZE=32
+CONFIG_TCPIP_RECVMBOX_SIZE=64
 CONFIG_TCP_MAXRTX=12
 CONFIG_TCP_SYNMAXRTX=12
 CONFIG_TCP_MSS=1440
 CONFIG_TCP_MSL=60000
-CONFIG_TCP_SND_BUF_DEFAULT=5760
+CONFIG_TCP_SND_BUF_DEFAULT=40960
-CONFIG_TCP_WND_DEFAULT=5760
+CONFIG_TCP_WND_DEFAULT=40960
-CONFIG_TCP_RECVMBOX_SIZE=6
+CONFIG_TCP_RECVMBOX_SIZE=64
 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_UDP_RECVMBOX_SIZE=64
 CONFIG_TCPIP_TASK_STACK_SIZE=3072
 CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
 # CONFIG_TCPIP_TASK_AFFINITY_CPU0 is not set

sdkconfig.defaults

@@ -2,7 +2,36 @@
 # Espressif IoT Development Framework (ESP-IDF) 5.4.0 Project Minimal Configuration
 #
 CONFIG_IDF_TARGET="esp32c3"
+CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF=y
 CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
 CONFIG_PARTITION_TABLE_CUSTOM=y
 CONFIG_UART_ISR_IN_IRAM=y
 CONFIG_HTTPD_WS_SUPPORT=y
+CONFIG_LWIP_SNTP_MAX_SERVERS=3
+
+
+CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM=20
+CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM=40
+CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM=40
+CONFIG_ESP_WIFI_AMPDU_TX_ENABLED=y
+CONFIG_ESP_WIFI_TX_BA_WIN=32
+CONFIG_ESP_WIFI_AMPDU_RX_ENABLED=y
+CONFIG_ESP_WIFI_RX_BA_WIN=32
+
+CONFIG_LWIP_TCP_SND_BUF_DEFAULT=40960
+CONFIG_LWIP_TCP_WND_DEFAULT=40960
+CONFIG_LWIP_TCP_RECVMBOX_SIZE=64
+CONFIG_LWIP_UDP_RECVMBOX_SIZE=64
+CONFIG_LWIP_TCPIP_RECVMBOX_SIZE=64
+
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160=y
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ=160
+
+CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
+CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
+
+CONFIG_LWIP_TCPIP_CORE_LOCKING=y
+CONFIG_LWIP_TCPIP_CORE_LOCKING_INPUT=y
+
+CONFIG_FREERTOS_UNICORE=n
+CONFIG_FREERTOS_HZ=1000