feat: add partition configuration and update SDK settings for improved hardware support

main/display/display.cpp.old

@@ -1,199 +0,0 @@
-#include "display/display.h"
-#include "common/constants.h"
-#include "esp_log.h"
-#include "esp_lcd_touch_gt911.h"
-
-#define BUSY_ACTIVE_LEVEL   0  // BUSY pin is active low
-#define BUSY_INACTIVE_LEVEL 1
-
-DisplayHandler::~DisplayHandler() {
-  if (_spi_mutex != nullptr) {
-    vSemaphoreDelete(_spi_mutex);
-  }
-  if (_spi != nullptr) {
-    spi_bus_remove_device(_spi);
-  }
-  if (_tp_handle != nullptr) {
-    esp_lcd_touch_del(_tp_handle);
-  }
-  if (_tp_io_handle != nullptr) {
-    esp_lcd_panel_io_del(_tp_io_handle);
-  }
-}
-
-void DisplayHandler::init_devices(bool set_display_ready /*= true*/) {
-  ESP_LOGI("DisplayHandler", "Initializing display and touch...");
-  _epd_init();
-  _touch_init();
-  ESP_LOGI("DisplayHandler", "Display and touch initialized.");
-  if (set_display_ready) {
-    ESP_LOGI("DisplayHandler", "Setting display ready bit.");
-    xEventGroupSetBits(_system_event_group, DISPLAY_READY_BIT | TOUCH_CALIBRATED_BIT);
-  }
-}
-
-
-void DisplayHandler::epd_write_cmd(uint8_t cmd) {
-  ESP_LOGI("DisplayHandler", "epd_write_cmd: waiting to send 0x%02X", cmd);
-  if (xSemaphoreTake(_spi_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) {
-    ESP_LOGE("DisplayHandler", "SPI mutex timeout for cmd 0x%02X", cmd);
-    return;
-  }
-  _dangerous_epd_write_cmd_without_lock(cmd);
-  xSemaphoreGive(_spi_mutex);
-  ESP_LOGI("DisplayHandler", "epd_write_cmd: 0x%02X done", cmd);
-}
-
-void DisplayHandler::epd_write_data(uint8_t data) {
-  ESP_LOGI("DisplayHandler", "epd_write_data: waiting to send 0x%02X", data);
-  if (xSemaphoreTake(_spi_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) {
-    ESP_LOGE("DisplayHandler", "SPI mutex timeout for data 0x%02X", data);
-    return;
-  }
-  _dangerous_epd_write_data_without_lock(data);
-  xSemaphoreGive(_spi_mutex);
-  ESP_LOGI("DisplayHandler", "epd_write_data: 0x%02X done", data);
-}
-
-void DisplayHandler::epd_write_cmd_with_data(uint8_t cmd, const uint8_t* data, size_t data_len) {
-  ESP_LOGI("DisplayHandler", "epd_write_cmd_with_data: waiting to send cmd 0x%02X with %u bytes of data", cmd, (unsigned)data_len);
-  if (xSemaphoreTake(_spi_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) {
-    ESP_LOGE("DisplayHandler", "SPI mutex timeout for cmd with data 0x%02X", cmd);
-    return;
-  }
-  _dangerous_epd_write_cmd_without_lock(cmd);
-  for (size_t i = 0; i < data_len; ++i) {
-    _dangerous_epd_write_data_without_lock(data[i]);
-  }
-  xSemaphoreGive(_spi_mutex);
-  ESP_LOGI("DisplayHandler", "epd_write_cmd_with_data: cmd 0x%02X with %u bytes of data done", cmd, (unsigned)data_len);
-}
-
-//
-// Private methods
-//
-
-void DisplayHandler::_dangerous_epd_write_cmd_without_lock(uint8_t cmd) {
-  ESP_LOGI("DisplayHandler", "_dangerous_epd_write_cmd_without_lock: sending 0x%02X", cmd);
-  gpio_set_level(PIN_DC, 0); // Command mode
-  spi_transaction_t t {};
-  t.length = 8;t.tx_buffer = &cmd;
-  esp_err_t err = spi_device_polling_transmit(_spi, &t);
-  if (err != ESP_OK) {
-    ESP_LOGE("DisplayHandler", "Failed to send data 0x%02X", cmd);
-  } else {
-    ESP_LOGI("DisplayHandler", "_dangerous_epd_write_cmd_without_lock: 0x%02X sent", cmd);
-  }
-}
-
-void DisplayHandler::_dangerous_epd_write_data_without_lock(uint8_t data) {
-  ESP_LOGI("DisplayHandler", "_dangerous_epd_write_data_without_lock: sending 0x%02X", data);
-  gpio_set_level(PIN_DC, 1); // Data mode
-  spi_transaction_t t = { };
-  t.length = 8; t.tx_buffer = &data;
-  esp_err_t err = spi_device_polling_transmit(_spi, &t);
-  if (err != ESP_OK) {
-    ESP_LOGE("DisplayHandler", "Failed to send data 0x%02X", data);
-  } else {
-    ESP_LOGI("DisplayHandler", "_dangerous_epd_write_data_without_lock: 0x%02X sent", data);
-  }
-}
-
-// required to be called by inheriting class after SPI device is created
-void DisplayHandler::_epd_init(void) {
-  ESP_LOGI("DisplayHandler", "Initializing EPD...");
-  // 1. Hardware Reset
-  gpio_set_level(PIN_RST, 0);
-  vTaskDelay(pdMS_TO_TICKS(10));
-  gpio_set_level(PIN_RST, 1);
-  vTaskDelay(pdMS_TO_TICKS(10));
-
-  // 2. Initialization Sequence
-  const uint8_t panel_setting_data[] = { 0x1F };
-  epd_write_cmd_with_data(0x00, panel_setting_data, 1); // Panel Setting
-  vTaskDelay(pdMS_TO_TICKS(10));
-  const uint8_t vcom_data[] = { 0x10, 0x07 };
-  epd_write_cmd_with_data(0x50, vcom_data, 2); // VCOM
-  vTaskDelay(pdMS_TO_TICKS(10));
-  epd_write_cmd(0x04); // Power ON
-  vTaskDelay(pdMS_TO_TICKS(100)); // Wait for power on
-
-  // Check BUSY pin with detailed logging
-  ESP_LOGI("DisplayHandler", "Waiting for EPD to be ready after power on...");
-  ESP_LOGI("DisplayHandler", "BUSY pin level after power on: %d (0=BUSY, 1=FREE)", gpio_get_level(PIN_BUSY));
-
-  int busy_timeout = 0;
-  while (gpio_get_level(PIN_BUSY) == BUSY_ACTIVE_LEVEL) {  // BUSY is active LOW
-    vTaskDelay(pdMS_TO_TICKS(10));
-    busy_timeout++;
-    if (busy_timeout > 500) {  // 5 second timeout
-      ESP_LOGE("DisplayHandler", "EPD power on timeout! BUSY pin stuck at 0");
-      break;
-    }
-    if (busy_timeout % 50 == 0) {  // Log every 500ms
-      ESP_LOGW("DisplayHandler", "Still waiting for EPD power on, timeout: %d/500", busy_timeout);
-    }
-  }
-  ESP_LOGI("DisplayHandler", "EPD power on complete after %d * 10ms, BUSY pin: %d", busy_timeout, gpio_get_level(PIN_BUSY));
-  const uint8_t booster_data[] = { 0x27, 0x27, 0x18, 0x17 };
-  epd_write_cmd_with_data(0x06, booster_data, 4); // Booster Soft Start
-  vTaskDelay(pdMS_TO_TICKS(10));
-
-  // Enhanced display drive commands
-  const uint8_t e0_data[] = { 0x02 };
-  epd_write_cmd_with_data(0xE0, e0_data, 1);
-  const uint8_t e5_data[] = { 0x5A };
-  epd_write_cmd_with_data(0xE5, e5_data, 1);
-}
-
-void DisplayHandler::_touch_init(void) {
-  ESP_LOGI("DisplayHandler", "Initializing touch...");
-
-  // 1. Initialize I2C Bus
-  i2c_config_t conf = {};
-  conf.mode = I2C_MODE_MASTER;
-  conf.sda_io_num = PIN_TOUCH_SDA;
-  conf.scl_io_num = PIN_TOUCH_SCL;
-  conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
-  conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
-  conf.master.clk_speed = 400000;
-
-  i2c_param_config(I2C_NUM_0, &conf);
-  i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0);
-  ESP_LOGI("DisplayHandler", "I2C driver installed");
-
-  // 2. Initialize GT911
-  ESP_LOGI("DisplayHandler", "Initializing GT911 touch controller...");
-  esp_lcd_panel_io_i2c_config_t tp_io_config = {};
-  // temporarily disable -Wmissing-field-initializers, as ESP_LCD_TOUCH_IO_I2C_GT911_CONFIG macro does not set all fields
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-  esp_lcd_panel_io_i2c_config_t default_tp_io_config = ESP_LCD_TOUCH_IO_I2C_GT911_CONFIG();
-#pragma GCC diagnostic pop
-  tp_io_config.dev_addr = default_tp_io_config.dev_addr;
-  tp_io_config.control_phase_bytes = default_tp_io_config.control_phase_bytes;
-  tp_io_config.dc_bit_offset = default_tp_io_config.dc_bit_offset;
-  tp_io_config.lcd_cmd_bits = default_tp_io_config.lcd_cmd_bits;
-  tp_io_config.flags = default_tp_io_config.flags;
-  esp_lcd_new_panel_io_i2c(I2C_NUM_0, &tp_io_config, &_tp_io_handle);
-
-  // GT911-specific config with I2C address (0x5D = INT low during reset)
-  static esp_lcd_touch_io_gt911_config_t gt911_config = {
-    .dev_addr = ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS  // 0x5D
-  };
-
-  esp_lcd_touch_config_t tp_cfg = {};
-  tp_cfg.x_max = 800;
-  tp_cfg.y_max = 480;
-  tp_cfg.rst_gpio_num = PIN_TOUCH_RST;
-  tp_cfg.int_gpio_num = PIN_TOUCH_IRQ;
-  tp_cfg.driver_data = &gt911_config;  // Pass GT911-specific config for automatic reset
-
-  esp_err_t touch_ret = esp_lcd_touch_new_i2c_gt911(_tp_io_handle, &tp_cfg, &_tp_handle);
-  if (touch_ret == ESP_OK && _tp_handle != nullptr) {
-    ESP_LOGI("DisplayHandler", "GT911 touch controller initialized successfully");
-  } else {
-    ESP_LOGE("DisplayHandler", "GT911 touch controller initialization failed: %s", esp_err_to_name(touch_ret));
-    _tp_handle = nullptr;
-  }
-}

main/display/display.h.old

@@ -1,42 +0,0 @@
-#pragma once
-#include "driver/spi_master.h"
-#include "driver/gpio.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "esp_lcd_touch_gt911.h"
-#include "display/constants.h"
-#include <driver/i2c.h>
-
-class DisplayHandler {
-public:
-  DisplayHandler(
-    EventGroupHandle_t system_event_group
-  ) : _system_event_group(system_event_group) { }
-  virtual ~DisplayHandler();
-  
-  // required to be called by inheriting class after SPI device is created
-  // set set_display_ready to false if further initialization is needed before marking display ready
-  virtual void init_devices(bool set_display_ready = true);
-
-protected:
-  // Allow derived classes to access touch handle
-  esp_lcd_touch_handle_t get_touch_handle() const { return _tp_handle; }
-
-  void epd_write_cmd(uint8_t cmd);
-  void epd_write_data(uint8_t data);
-
-  void epd_write_cmd_with_data(uint8_t cmd, const uint8_t* data, size_t data_len);
-
-protected:
-  SemaphoreHandle_t _spi_mutex = xSemaphoreCreateMutex();
-  spi_device_handle_t _spi = nullptr;
-  EventGroupHandle_t _system_event_group = nullptr;
-  esp_lcd_panel_io_handle_t _tp_io_handle = nullptr;
-  esp_lcd_touch_handle_t _tp_handle = nullptr;
-
-  void _dangerous_epd_write_cmd_without_lock(uint8_t cmd);
-  void _dangerous_epd_write_data_without_lock(uint8_t data);
-
-  void _epd_init(void);
-  void _touch_init(void);
-};

main/display/eink_display_handler.cpp

@@ -11,6 +11,7 @@
 #define DISPLAY_BUFFER_SIZE (EINK_HEIGHT* EINK_WIDTH) / 8 // 1 bit per pixels
 #define MINIMUM_PIN_SETUP_DELAY_MS 10
 #define MINIMUM_POWER_ON_DELAY_MS 100
+#define PARTIAL_REFRESH_THRESHOLD 5  // Full refresh every N partial refreshes
 
 static uint8_t* DRAW_BUFFER; // 1 bit per pixel
 static uint8_t* OLD_DRAW_BUFFER; // 1 bit per pixel
@@ -99,6 +100,16 @@ esp_err_t EInkDisplayHandler::deep_sleep_display(void) {
 esp_err_t EInkDisplayHandler::refresh_display() {
   esp_err_t err = ESP_OK;
 
+
+  if (is_deep_sleep_) {
+
+    err = full_write(draw_buffer_, true);
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Full write failed during refresh_display: %s", esp_err_to_name(err));
+      return err;
+    }
+  } else {
+    // refresh does not correctly work after recovering from deep sleep due to sram reset
     {
       ESP_LOGI(TAG, "Waiting for display to be idle...");
       TransactionGuard transaction_guard(this->epd_handler_);
@@ -126,6 +137,7 @@ esp_err_t EInkDisplayHandler::refresh_display() {
       vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS)); // at least 200us delay
       epd_handler_.wait_for_idle();
     }
+  }
 
   {
     SemaphoreGuard guard(refresh_mutex_);
@@ -235,6 +247,7 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* incoming_partial_fr
     ESP_LOGI(TAG, "Partial refresh skipped (not last partial update)");
     return ESP_OK;
   }
+
   {
     TransactionGuard transaction_guard(this->epd_handler_);
     err = transaction_guard.begin(pdMS_TO_TICKS(5000));
@@ -359,7 +372,7 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* incoming_partial_fr
       // Send only the partial area data, not the full display buffer
       ESP_LOGI(TAG, "Sending new partial buffer: %zu bytes (area: %dx%d)",
         partial_buffer_size, area_width_bytes * 8, area_height);
-      err = epd_handler_.transfer_spi_data(partial_buffer, partial_buffer_size, transaction_guard.transaction_id());
+      err = epd_handler_.transfer_spi_data(partial_buffer, partial_buffer_size, transaction_guard.transaction_id(), true); // Inverted for partial refresh
       if (err != ESP_OK) {
         ESP_LOGE(TAG, "Failed to send partial_buffer data for partial refresh: %s", esp_err_to_name(err));
         heap_caps_free(partial_buffer);
@@ -391,6 +404,13 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* incoming_partial_fr
     }
   }
   ESP_LOGI(TAG, "Partial refresh complete");
+
+  err = deep_sleep_display();
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to enter deep sleep after partial refresh: %s", esp_err_to_name(err));
+    return err;
+  }
+
   if (force_full_refresh_) {
     ESP_LOGI(TAG, "Full refresh already requested, skipping partial refresh count increment");
     err = refresh_display();
@@ -400,6 +420,7 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* incoming_partial_fr
     }
     return ESP_OK;
   }
+
   {
     SemaphoreGuard guard(refresh_mutex_);
     if (guard.take(pdMS_TO_TICKS(5000)) != pdTRUE) {
@@ -418,11 +439,6 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* incoming_partial_fr
     }
   }
 
-  err = deep_sleep_display();
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to enter deep sleep after partial refresh: %s", esp_err_to_name(err));
-    return err;
-  }
 
 
   refresh_area_.reset();

main/display/eink_display_handler.cpp.old

@@ -1,661 +0,0 @@
-#include "display/eink_display_handler.h"
-#include "display/constants.h"
-#include "common/constants.h"
-#include "esp_log.h"
-#include "esp_heap_caps.h"
-#include "esp_task_wdt.h"
-#include <cstring>
-
-#define TAG "EInkDisplayHandler"
-#define BUSY_ACTIVE_LEVEL   0  // BUSY pin is active low
-#define BUSY_INACTIVE_LEVEL 1
-
-EInkDisplayHandler::EInkDisplayHandler(EventGroupHandle_t system_event_group)
-  : DisplayHandler(system_event_group) {
-  _refresh_mutex = xSemaphoreCreateMutex();
-  if (_refresh_mutex == nullptr) {
-    ESP_LOGE(TAG, "Failed to create refresh mutex");
-  }
-}
-
-EInkDisplayHandler::~EInkDisplayHandler() {
-  if (_refresh_task_handle != nullptr) {
-    vTaskDelete(_refresh_task_handle);
-  }
-  if (_touch_task_handle != nullptr) {
-    vTaskDelete(_touch_task_handle);
-  }
-  if (_refresh_queue != nullptr) {
-    vQueueDelete(_refresh_queue);
-  }
-  if (_lvgl_display != nullptr) {
-    lv_display_delete(_lvgl_display);
-    _lvgl_display = nullptr;
-    if (_lvgl_draw_buf != nullptr) {
-      lv_draw_buf_destroy(_lvgl_draw_buf);
-      _lvgl_draw_buf = nullptr;
-    }
-  }
-  if (_lvgl_touch_indev != nullptr) {
-    lvgl_port_remove_touch(_lvgl_touch_indev);
-  }
-  if (_framebuffer != nullptr) {
-    heap_caps_free(_framebuffer);
-  }
-  if (_refresh_mutex != nullptr) {
-    vSemaphoreDelete(_refresh_mutex);
-  }
-}
-
-void EInkDisplayHandler::init() {
-  ESP_LOGI(TAG, "Initializing E-Ink display handler...");
-
-  // Initialize GPIO pins
-  gpio_config_t io_conf = {};
-  io_conf.pin_bit_mask = (1ULL << PIN_DC) | (1ULL << PIN_RST);
-  io_conf.mode = GPIO_MODE_OUTPUT;
-  io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
-  io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
-  io_conf.intr_type = GPIO_INTR_DISABLE;
-  gpio_config(&io_conf);
-
-  // Configure BUSY pin as input (no pull-up like sample code)
-  io_conf.pin_bit_mask = (1ULL << PIN_BUSY);
-  io_conf.mode = GPIO_MODE_INPUT;
-  io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
-  gpio_config(&io_conf);
-
-  // Initialize SPI bus
-  spi_bus_config_t buscfg = {};
-  buscfg.mosi_io_num = 11;  // MOSI pin
-  buscfg.miso_io_num = -1;  // No MISO for e-paper
-  buscfg.sclk_io_num = 12;  // SCK pin
-  buscfg.quadwp_io_num = -1;
-  buscfg.quadhd_io_num = -1;
-  buscfg.max_transfer_sz = DISPLAY_BUFFER_SIZE;
-
-  esp_err_t ret = spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO);
-  if (ret != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to initialize SPI bus: %s", esp_err_to_name(ret));
-    return;
-  }
-
-  // Add SPI device
-  spi_device_interface_config_t devcfg = {};
-  devcfg.clock_speed_hz = 6 * 1000 * 1000;  // 6 MHz (reduced for reliability)
-  devcfg.mode = 0;  // SPI mode 0
-  devcfg.spics_io_num = PIN_CS;
-  devcfg.queue_size = 7;  // Queue size for non-blocking transactions
-  devcfg.pre_cb = nullptr;
-
-  ret = spi_bus_add_device(SPI2_HOST, &devcfg, &_spi);
-  if (ret != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to add SPI device: %s", esp_err_to_name(ret));
-    return;
-  }
-
-  // Initialize base display and touch devices
-  init_devices(false);  // Don't set ready bit yet
-
-  // Create refresh queue (queue 5 refresh requests)
-  _refresh_queue = xQueueCreate(5, sizeof(bool));
-  if (_refresh_queue == nullptr) {
-    ESP_LOGE(TAG, "Failed to create refresh queue");
-    return;
-  }
-
-  // Create refresh task
-  BaseType_t ret_task = xTaskCreatePinnedToCore(
-    _refresh_task,
-    "eink_refresh",
-    8192,
-    this,
-    5,  // Priority - lower than LVGL task
-    &_refresh_task_handle,
-    1   // Pin to core 1
-  );
-  if (ret_task != pdPASS) {
-    ESP_LOGE(TAG, "Failed to create refresh task");
-    return;
-  }
-
-  // Allocate framebuffer - try PSRAM first, fallback to internal RAM
-  // Note: Internal framebuffer excludes the 8-byte palette (raw pixel data only)
-  const size_t fb_size = DISPLAY_BUFFER_SIZE - 8;  // Exclude palette from internal storage
-  _framebuffer = (uint8_t*)heap_caps_malloc(fb_size, MALLOC_CAP_SPIRAM);
-  if (_framebuffer != nullptr) {
-    _framebuffer_in_psram = true;
-    ESP_LOGI(TAG, "Framebuffer allocated in PSRAM (%zu bytes, LVGL buffer: %d bytes)",
-      fb_size, DISPLAY_BUFFER_SIZE);
-  } else {
-    ESP_LOGW(TAG, "PSRAM not available, allocating framebuffer in internal RAM");
-    _framebuffer = (uint8_t*)heap_caps_malloc(fb_size, MALLOC_CAP_INTERNAL);
-    _framebuffer_in_psram = false;
-    if (_framebuffer == nullptr) {
-      ESP_LOGE(TAG, "Failed to allocate framebuffer");
-      return;
-    }
-    ESP_LOGI(TAG, "Framebuffer allocated in internal RAM (%zu bytes, LVGL buffer: %d bytes)",
-      fb_size, DISPLAY_BUFFER_SIZE);
-  }
-  memset(_framebuffer, 0xFF, fb_size);  // Initialize to white
-
-  // Perform initial full refresh to clear display BEFORE creating LVGL display
-  // This prevents LVGL from trying to render during the initial clear
-  ESP_LOGI(TAG, "Performing initial display clear...");
-  _perform_full_refresh(_framebuffer);
-  ESP_LOGI(TAG, "Initial display clear complete");
-
-  // Create LVGL display manually (no esp_lcd panel for e-paper)
-  lv_display_t* disp = lv_display_create(DISPLAY_WIDTH, DISPLAY_HEIGHT);
-  if (disp == nullptr) {
-    ESP_LOGE(TAG, "Failed to create LVGL display");
-    return;
-  }
-
-  /* 1-bit e-paper display */
-  lv_display_set_color_format(disp, LV_COLOR_FORMAT_I1);
-
-  /* Disable antialiasing for monochrome display to ensure crisp 1px lines */
-  lv_display_set_antialiasing(disp, false);
-
-  /* Create a draw buffer covering ~40 lines */
-  _lvgl_draw_buf = lv_draw_buf_create(DISPLAY_WIDTH, DISPLAY_HEIGHT, LV_COLOR_FORMAT_I1, LV_STRIDE_AUTO);
-  if (_lvgl_draw_buf == nullptr) {
-    ESP_LOGE(TAG, "Failed to create LVGL draw buffer");
-    lv_display_delete(disp);
-    return;
-  }
-
-  lv_display_set_draw_buffers(disp, _lvgl_draw_buf, NULL);
-  lv_display_set_render_mode(disp, LV_DISPLAY_RENDER_MODE_DIRECT);
-
-  // Set custom flush callback and user data
-  lv_display_set_flush_cb(disp, _lvgl_flush_cb);
-  lv_display_set_user_data(disp, this);
-
-  _lvgl_display = disp;
-
-  ESP_LOGI(TAG, "LVGL display registered");
-
-  // Register GT911 touch input with LVGL, only if touch handle is valid
-  esp_lcd_touch_handle_t tp_handle = get_touch_handle();
-  if (tp_handle == nullptr) {
-    ESP_LOGE(TAG, "Touch handle is NULL — touch initialization failed; skipping LVGL touch registration");
-  } else {
-    const lvgl_port_touch_cfg_t touch_cfg = {
-      .disp = _lvgl_display,
-      .handle = tp_handle,
-      .scale = {}, // Default scaling
-    };
-
-    _lvgl_touch_indev = lvgl_port_add_touch(&touch_cfg);
-    if (_lvgl_touch_indev == nullptr) {
-      ESP_LOGE(TAG, "Failed to register LVGL touch input");
-      return;
-    }
-
-    // Override touch read callback to check BUSY pin
-    lv_indev_set_read_cb(_lvgl_touch_indev, _lvgl_touch_read_cb);
-    lv_indev_set_user_data(_lvgl_touch_indev, this);
-
-    ESP_LOGI(TAG, "LVGL touch input registered");
-  }
-
-  // Set display ready bits
-  xEventGroupSetBits(_system_event_group, DISPLAY_READY_BIT | TOUCH_CALIBRATED_BIT);
-  ESP_LOGI(TAG, "E-Ink display handler initialized successfully");
-}
-
-void EInkDisplayHandler::start_touch_task() {
-  // Note: With lvgl_port_add_touch, the ESP-IDF LVGL port handles touch reading internally
-  // We don't need a separate touch task unless we want custom processing
-  ESP_LOGI(TAG, "Touch input handled by LVGL port");
-}
-
-void EInkDisplayHandler::request_full_refresh() {
-  if (xSemaphoreTake(_refresh_mutex, pdMS_TO_TICKS(100)) == pdTRUE) {
-    _force_full_refresh = true;
-    _partial_refresh_count = 0;
-    xSemaphoreGive(_refresh_mutex);
-    ESP_LOGI(TAG, "Full refresh requested");
-  }
-}
-
-bool EInkDisplayHandler::is_busy() const {
-  return gpio_get_level(PIN_BUSY) == BUSY_ACTIVE_LEVEL;  // BUSY is active LOW
-}
-
-void EInkDisplayHandler::_lvgl_flush_cb(lv_display_t* disp, const lv_area_t* area, uint8_t* px_map) {
-  EInkDisplayHandler* handler = static_cast<EInkDisplayHandler*>(lv_display_get_user_data(disp));
-  if (handler == nullptr) {
-    ESP_LOGE(TAG, "Invalid handler in flush callback");
-    lv_display_flush_ready(disp);
-    return;
-  }
-
-  // Check if display is busy with detailed logging
-  int busy_level = gpio_get_level(PIN_BUSY);
-  ESP_LOGI(TAG, "Flush callback: BUSY pin = %d, is_busy() = %d", busy_level, handler->is_busy());
-
-  if (handler->is_busy()) {
-    ESP_LOGW(TAG, "Display busy (BUSY pin = 0), skipping flush");
-    lv_display_flush_ready(disp);
-    return;
-  }
-
-  // Wait for any ongoing refresh to complete
-  handler->_wait_for_busy();
-
-  bool perform_full_refresh = false;
-
-  if (xSemaphoreTake(handler->_refresh_mutex, pdMS_TO_TICKS(100)) == pdTRUE) {
-    // Check if full refresh is needed
-    if (handler->_force_full_refresh) {
-      perform_full_refresh = true;
-      handler->_force_full_refresh = false;
-      handler->_partial_refresh_count = 0;
-    } else {
-      handler->_partial_refresh_count++;
-      if (handler->_partial_refresh_count >= PARTIAL_REFRESH_THRESHOLD) {
-        perform_full_refresh = true;
-        handler->_partial_refresh_count = 0;
-      }
-    }
-    xSemaphoreGive(handler->_refresh_mutex);
-  }
-
-  // Copy LVGL buffer to framebuffer
-  // For 1-bit mode, LVGL provides data in packed format (8 pixels per byte)
-  // CRITICAL: Skip first 8 bytes (LVGL I1 palette) as per LVGL documentation
-  uint8_t* pixel_data = px_map + 8;  // Skip 8-byte palette
-  int32_t w = lv_area_get_width(area);
-  int32_t h = lv_area_get_height(area);
-
-  ESP_LOGI(TAG, "Flushing area: x=%d, y=%d, w=%d, h=%d, full_refresh=%d",
-    area->x1, area->y1, w, h, perform_full_refresh);
-  ESP_LOGI(TAG, "Buffer: px_map=%p, pixel_data=%p, palette skipped: %d bytes",
-    (void*)px_map, (void*)pixel_data, 8);
-
-  // Check if this is a full screen update - if so, simple copy
-  if (area->x1 == 0 && area->y1 == 0 && w == DISPLAY_WIDTH && h == DISPLAY_HEIGHT) {
-    ESP_LOGI(TAG, "Full screen update, direct copy (skipping palette)");
-    memcpy(handler->_framebuffer, pixel_data, DISPLAY_BUFFER_SIZE - 8);
-  } else {
-    ESP_LOGI(TAG, "Partial area update");
-    // In DIRECT render mode, px_map points to the full screen buffer
-    // The stride is always the full display width
-    const uint32_t stride = DISPLAY_WIDTH / 8;  // 800 / 8 = 100 bytes per row
-
-    // Check if we can do row-by-row copy (byte-aligned on both x1 and width)
-    bool byte_aligned = (area->x1 % 8 == 0) && (w % 8 == 0);
-
-    if (byte_aligned) {
-      // Optimized: byte-aligned row copy
-      ESP_LOGI(TAG, "Byte-aligned copy: x=%ld, y=%ld, w=%ld, h=%ld",
-        (long)area->x1, (long)area->y1, (long)w, (long)h);
-
-      uint32_t x_byte = area->x1 / 8;
-      uint32_t width_bytes = w / 8;
-
-      for (int32_t y = 0; y < h; y++) {
-        int32_t fb_y = area->y1 + y;
-        if (fb_y >= DISPLAY_HEIGHT) break;
-
-        uint8_t* src = pixel_data + (fb_y * stride + x_byte);
-        uint8_t* dst = handler->_framebuffer + (fb_y * stride + x_byte);
-        memcpy(dst, src, width_bytes);
-      }
-    } else {
-      // Bit-level copy for non-aligned regions
-      ESP_LOGI(TAG, "Bit-level copy: x=%ld, y=%ld, w=%ld, h=%ld",
-        (long)area->x1, (long)area->y1, (long)w, (long)h);
-
-      for (int32_t y = 0; y < h; y++) {
-        int32_t fb_y = area->y1 + y;
-        if (fb_y >= DISPLAY_HEIGHT) break;
-
-        for (int32_t x = 0; x < w; x++) {
-          int32_t fb_x = area->x1 + x;
-          if (fb_x >= DISPLAY_WIDTH) break;
-
-          // Get pixel from source buffer (using full screen coordinates)
-          size_t src_byte_idx = fb_y * stride + (fb_x / 8);
-          size_t src_bit_idx = fb_x % 8;
-          uint8_t src_bit = (pixel_data[src_byte_idx] >> (7 - src_bit_idx)) & 0x01;
-
-          // Set pixel in destination buffer
-          size_t dst_byte_idx = fb_y * stride + (fb_x / 8);
-          size_t dst_bit_idx = fb_x % 8;
-
-          if (dst_byte_idx < (DISPLAY_BUFFER_SIZE - 8)) {
-            if (src_bit) {
-              handler->_framebuffer[dst_byte_idx] |= (1 << (7 - dst_bit_idx));
-            } else {
-              handler->_framebuffer[dst_byte_idx] &= ~(1 << (7 - dst_bit_idx));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Queue refresh request (non-blocking)
-  if (handler->_refresh_queue != nullptr) {
-    if (xQueueSend(handler->_refresh_queue, &perform_full_refresh, 0) != pdPASS) {
-      ESP_LOGW(TAG, "Refresh queue full, skipping refresh");
-    } else {
-      ESP_LOGI(TAG, "Queued %s refresh", perform_full_refresh ? "full" : "partial");
-    }
-  }
-
-  lv_display_flush_ready(disp);
-}
-
-void EInkDisplayHandler::_lvgl_touch_read_cb(lv_indev_t* indev, lv_indev_data_t* data) {
-  EInkDisplayHandler* handler = static_cast<EInkDisplayHandler*>(lv_indev_get_user_data(indev));
-
-  // Disable touch input during display refresh (BUSY)
-  if (handler->is_busy()) {
-    data->state = LV_INDEV_STATE_RELEASED;
-    data->continue_reading = false;
-    return;
-  }
-
-  esp_lcd_touch_handle_t tp_handle = handler->get_touch_handle();
-  if (tp_handle == nullptr) {
-    data->state = LV_INDEV_STATE_RELEASED;
-    return;
-  }
-
-
-  // Read touch data from GT911
-  esp_err_t ret = esp_lcd_touch_read_data(tp_handle);
-  if (ret == ESP_OK) {
-    uint8_t touch_cnt = 0;
-    // Get touch data using new API
-    esp_lcd_touch_point_data_t point_data[1];
-    esp_lcd_touch_get_data(tp_handle, point_data, &touch_cnt, 1);
-
-    if (touch_cnt > 0) {
-      ESP_LOGI(TAG, "Touch data read successfully: x=%d, y=%d", point_data[0].x, point_data[0].y);
-      data->point.x = point_data[0].x;
-      data->point.y = point_data[0].y;
-      data->state = LV_INDEV_STATE_PRESSED;
-    } else {
-      data->state = LV_INDEV_STATE_RELEASED;
-    }
-  } else {
-    data->state = LV_INDEV_STATE_RELEASED;
-  }
-
-  data->continue_reading = false;
-}
-
-void EInkDisplayHandler::_perform_full_refresh(const uint8_t* framebuffer) {
-  ESP_LOGI(TAG, "Starting full refresh (3 seconds)...");
-
-  _wait_for_busy();
-
-  // Step 1: Write old data (0x10) - Arduino uses 0xFF (all white) for base map
-  epd_write_cmd(0x10);
-
-  if (xSemaphoreTake(_spi_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) {
-    ESP_LOGE(TAG, "SPI mutex timeout in full refresh step 1");
-    return;
-  }
-  gpio_set_level(PIN_DC, 1);  // Data mode
-
-  ESP_LOGI(TAG, "Starting SPI data transmission for old data (0x10)...");
-
-  // Send 0xFF (white) for all old data, matching Arduino EPD_SetRAMValue_BaseMap
-  // Use DMA transfers in chunks for better performance
-  static uint8_t white_buffer[4096];  // 4KB chunk buffer
-  memset(white_buffer, 0xFF, sizeof(white_buffer));
-
-  const size_t CHUNK_SIZE = sizeof(white_buffer);
-  size_t remaining = DISPLAY_BUFFER_SIZE - 8;  // Exclude palette from transmission
-  size_t offset = 0;
-
-  while (remaining > 0) {
-    size_t transfer_size = (remaining < CHUNK_SIZE) ? remaining : CHUNK_SIZE;
-
-    spi_transaction_t t = {};
-    t.length = transfer_size * 8;  // Length in bits
-    t.tx_buffer = white_buffer;
-
-    esp_err_t ret = spi_device_polling_transmit(_spi, &t);
-    if (ret != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to send SPI chunk at offset %zu: %s", offset, esp_err_to_name(ret));
-      break;
-    }
-
-    remaining -= transfer_size;
-    offset += transfer_size;
-
-    // Yield every 16KB to prevent watchdog timeout
-    if (offset % (16 * 1024) == 0) {
-      ESP_LOGI(TAG, "Old data progress: %zu/%zu bytes (%.1f%%)", offset, remaining,
-        (float)offset * 100.0f / (float)remaining);
-      vTaskDelay(pdMS_TO_TICKS(1));
-    }
-  }
-  ESP_LOGI(TAG, "Completed SPI data transmission for old data");
-  xSemaphoreGive(_spi_mutex);
-
-  // Step 2: Write new data (0x13)
-  epd_write_cmd(0x13);
-
-  if (xSemaphoreTake(_spi_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) {
-    ESP_LOGE(TAG, "SPI mutex timeout in full refresh step 2");
-    return;
-  }
-  gpio_set_level(PIN_DC, 1);  // Data mode
-
-  ESP_LOGI(TAG, "Starting SPI data transmission for new data (0x13)...");
-
-  // Send actual framebuffer data in chunks using DMA for better performance
-  offset = 0;
-  remaining = DISPLAY_BUFFER_SIZE - 8;  // Reset remaining for step 2
-
-  while (remaining > 0) {
-    size_t transfer_size = (remaining < CHUNK_SIZE) ? remaining : CHUNK_SIZE;
-
-    spi_transaction_t t = {};
-    t.length = transfer_size * 8;  // Length in bits
-    t.tx_buffer = framebuffer + offset;
-
-    esp_err_t ret = spi_device_polling_transmit(_spi, &t);
-    if (ret != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to send SPI chunk at offset %zu: %s", offset, esp_err_to_name(ret));
-      break;
-    }
-
-    remaining -= transfer_size;
-    offset += transfer_size;
-
-    // Yield every 16KB to prevent watchdog timeout
-    if (offset % (16 * 1024) == 0) {
-      ESP_LOGI(TAG, "New data progress: %zu/%zu bytes (%.1f%%)", offset, remaining,
-        (float)offset * 100.0f / (float)remaining);
-      vTaskDelay(pdMS_TO_TICKS(1));
-    }
-  }
-
-  ESP_LOGI(TAG, "Completed SPI data transmission for new data");
-  xSemaphoreGive(_spi_mutex);
-
-  // Step 3: Trigger display refresh (DRF)
-  epd_write_cmd(0x12);
-  // Critical delay - sample code says "!!!The delay here is necessary, 200uS at least!!!"
-  vTaskDelay(pdMS_TO_TICKS(10));
-  ESP_LOGI(TAG, "Display refresh triggered, BUSY pin: %d", gpio_get_level(PIN_BUSY));
-
-  // Wait for refresh to complete
-  _wait_for_busy();
-
-  ESP_LOGI(TAG, "Full refresh complete");
-}
-
-void EInkDisplayHandler::_perform_partial_refresh(const uint8_t* framebuffer) {
-  ESP_LOGI(TAG, "Starting partial refresh (0.3 seconds)...");
-
-  _wait_for_busy();
-
-  // Step 1: Configure VCOM for partial refresh
-  const uint8_t vcom_data[] = { 0xA9, 0x07 };
-  epd_write_cmd_with_data(0x50, vcom_data, 2);
-
-  // Step 2: Enter partial refresh mode
-  epd_write_cmd(0x91);
-
-  // Step 3: Define partial window (full screen for now)
-  // Format: 0x90 + 9 bytes (x_start_H, x_start_L, x_end_H, x_end_L, y_start_H, y_start_L, y_end_H, y_end_L, 0x01)
-  // For full screen: x=0 to 799 (0x031F), y=0 to 479 (0x01DF)
-  const uint8_t window_data[] = {
-    0x00, 0x00,  // x_start = 0
-    0x03, 0x1F,  // x_end = 799 (0x31F)
-    0x00, 0x00,  // y_start = 0
-    0x01, 0xDF,  // y_end = 479 (0x1DF)
-    0x01         // PT_SCAN
-  };
-  epd_write_cmd_with_data(0x90, window_data, 9);
-
-  // Step 4: Write new data (0x13 command)
-  epd_write_cmd(0x13);
-
-  if (xSemaphoreTake(_spi_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) {
-    ESP_LOGE(TAG, "SPI mutex timeout in partial refresh");
-    return;
-  }
-  gpio_set_level(PIN_DC, 1);  // Data mode
-
-  ESP_LOGI(TAG, "Starting SPI data transmission for partial refresh...");
-
-  // Send framebuffer data in chunks using DMA for better performance
-  const size_t CHUNK_SIZE = 4096;  // 4KB chunks
-  size_t remaining = DISPLAY_BUFFER_SIZE - 8;  // Exclude palette from transmission
-  size_t offset = 0;
-
-  while (remaining > 0) {
-    size_t transfer_size = (remaining < CHUNK_SIZE) ? remaining : CHUNK_SIZE;
-
-    spi_transaction_t t = {};
-    t.length = transfer_size * 8;  // Length in bits
-    t.tx_buffer = framebuffer + offset;
-
-    esp_err_t ret = spi_device_polling_transmit(_spi, &t);
-    if (ret != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to send SPI chunk at offset %zu: %s", offset, esp_err_to_name(ret));
-      break;
-    }
-
-    remaining -= transfer_size;
-    offset += transfer_size;
-
-    // Yield every 16KB to prevent watchdog timeout
-    if (offset % (16 * 1024) == 0) {
-      ESP_LOGI(TAG, "Partial refresh progress: %zu/%zu bytes (%.1f%%)", offset, remaining,
-        (float)offset * 100.0f / (float)remaining);
-      vTaskDelay(pdMS_TO_TICKS(1));
-    }
-  }
-  ESP_LOGI(TAG, "Completed SPI data transmission for partial refresh");
-  xSemaphoreGive(_spi_mutex);
-
-  // Step 5: Trigger partial display refresh (DRF)
-  epd_write_cmd(0x12);
-  // Critical delay - sample code says "!!!The delay here is necessary, 200uS at least!!!"
-  vTaskDelay(pdMS_TO_TICKS(10));
-  ESP_LOGI(TAG, "Partial refresh triggered, BUSY pin: %d", gpio_get_level(PIN_BUSY));
-
-  // Wait for refresh to complete
-  _wait_for_busy();
-
-  // Step 6: Exit partial refresh mode
-  epd_write_cmd(0x92);
-
-  ESP_LOGI(TAG, "Partial refresh complete");
-}
-
-void EInkDisplayHandler::_refresh_task(void* param) {
-  EInkDisplayHandler* handler = static_cast<EInkDisplayHandler*>(param);
-  bool perform_full_refresh = false;
-
-  ESP_LOGI(TAG, "Refresh task started");
-
-  while (true) {
-    // Wait for refresh request
-    if (xQueueReceive(handler->_refresh_queue, &perform_full_refresh, portMAX_DELAY) == pdTRUE) {
-      // Perform the requested refresh type
-      if (perform_full_refresh) {
-        ESP_LOGI(TAG, "Refresh task: Performing full refresh...");
-        handler->_perform_full_refresh(handler->_framebuffer);
-      } else {
-        ESP_LOGI(TAG, "Refresh task: Performing partial refresh...");
-        handler->_perform_partial_refresh(handler->_framebuffer);
-      }
-    }
-  }
-}
-
-void EInkDisplayHandler::_wait_for_busy() {
-  ESP_LOGI(TAG, "Waiting for display ready (BUSY pin)...");
-  int initial_level = gpio_get_level(PIN_BUSY);
-  ESP_LOGI(TAG, "Initial BUSY pin level: %d (0=BUSY, 1=FREE)", initial_level);
-
-  // If already free, no need to wait
-  if (initial_level == BUSY_INACTIVE_LEVEL) {
-    ESP_LOGI(TAG, "Display already ready (BUSY pin = 1)");
-    return;
-  }
-
-  int timeout = 0;
-  while (gpio_get_level(PIN_BUSY) == BUSY_ACTIVE_LEVEL) {  // 0=BUSY, 1=FREE
-    vTaskDelay(pdMS_TO_TICKS(100));
-    timeout++;
-    if (timeout > 100) {  // 10 second timeout
-      ESP_LOGE(TAG, "Display BUSY timeout! Pin level: %d", gpio_get_level(PIN_BUSY));
-      ESP_LOGW(TAG, "Attempting hardware reset...");
-
-      // Hardware reset sequence
-      gpio_set_level(PIN_RST, 0);
-      vTaskDelay(pdMS_TO_TICKS(10));
-      gpio_set_level(PIN_RST, 1);
-      vTaskDelay(pdMS_TO_TICKS(100));
-
-      // Re-initialize display
-      ESP_LOGI(TAG, "Re-initializing display after reset...");
-      _epd_init();
-
-      // Check if reset worked
-      int reset_timeout = 0;
-      while (gpio_get_level(PIN_BUSY) == BUSY_ACTIVE_LEVEL) {
-        vTaskDelay(pdMS_TO_TICKS(100));
-        reset_timeout++;
-        if (reset_timeout > 50) {  // 5 second timeout after reset
-          ESP_LOGE(TAG, "Display reset failed! Still busy after reset.");
-          break;
-        }
-      }
-
-      if (gpio_get_level(PIN_BUSY) != BUSY_ACTIVE_LEVEL) {
-        ESP_LOGI(TAG, "Display reset successful after %d tenths of a second", reset_timeout);
-      }
-      break;
-    }
-
-    // Log every 2 seconds to track progress
-    if (timeout % 20 == 0) {
-      ESP_LOGW(TAG, "Still waiting for BUSY pin, timeout: %d/100, level: %d",
-        timeout, gpio_get_level(PIN_BUSY));
-    }
-  }
-  ESP_LOGI(TAG, "Display ready after %d tenths of a second", timeout);
-}
-
-void EInkDisplayHandler::_convert_buffer_to_epaper(const uint8_t* lvgl_buf, uint8_t* epd_buf, size_t size) {
-  // LVGL 1-bit format is already compatible with e-paper
-  // Just copy directly
-  memcpy(epd_buf, lvgl_buf, size);
-}

main/display/eink_display_handler.h

@@ -8,7 +8,6 @@
 #include "epd_handler.h"
 
 // Refresh mode configuration
-#define PARTIAL_REFRESH_THRESHOLD 10  // Full refresh every N partial refreshes
 #define DISPLAY_WIDTH 800
 #define DISPLAY_HEIGHT 480
 

main/display/eink_display_handler.h.old

@@ -1,66 +0,0 @@
-#pragma once
-#include "display/display.h"
-#include "lvgl.h"
-#include "esp_lvgl_port.h"
-#include "freertos/semphr.h"
-
-// Refresh mode configuration
-#define PARTIAL_REFRESH_THRESHOLD 10  // Full refresh every N partial refreshes
-#define DISPLAY_WIDTH 800
-#define DISPLAY_HEIGHT 480
-#define DISPLAY_BUFFER_SIZE (((DISPLAY_WIDTH * DISPLAY_HEIGHT) / 8) + 8)  // 1-bit per pixel + 8-byte palette
-
-class EInkDisplayHandler : public DisplayHandler {
-public:
-  EInkDisplayHandler(EventGroupHandle_t system_event_group);
-  virtual ~EInkDisplayHandler();
-
-  void init();
-  void start_touch_task();
-
-  // Request a full refresh on next flush
-  void request_full_refresh();
-
-  // Check if display is busy (refreshing)
-  bool is_busy() const;
-
-private:
-  // LVGL display and input device handles
-  lv_display_t* _lvgl_display = nullptr;
-  lv_indev_t* _lvgl_touch_indev = nullptr;
-  lv_draw_buf_t* _lvgl_draw_buf = nullptr;
-
-  // Framebuffer
-  uint8_t* _framebuffer = nullptr;
-  bool _framebuffer_in_psram = false;
-
-  // Refresh tracking
-  uint32_t _partial_refresh_count = 0;
-  bool _force_full_refresh = false;
-  SemaphoreHandle_t _refresh_mutex = nullptr;
-
-  // Touch task
-  TaskHandle_t _touch_task_handle = nullptr;
-
-  // Refresh task and queue
-  TaskHandle_t _refresh_task_handle = nullptr;
-  QueueHandle_t _refresh_queue = nullptr;
-
-  // LVGL callbacks
-  static void _lvgl_flush_cb(lv_display_t* disp, const lv_area_t* area, uint8_t* px_map);
-  static void _lvgl_touch_read_cb(lv_indev_t* indev, lv_indev_data_t* data);
-
-  // Display operations
-  void _perform_full_refresh(const uint8_t* framebuffer);
-  void _perform_partial_refresh(const uint8_t* framebuffer);
-  void _wait_for_busy();
-
-  // Touch task
-  static void _touch_task(void* param);
-
-  // Refresh task
-  static void _refresh_task(void* param);
-
-  // Helper to convert LVGL 1-bit buffer to e-paper format
-  void _convert_buffer_to_epaper(const uint8_t* lvgl_buf, uint8_t* epd_buf, size_t size);
-};

main/display/epd_handler.cpp

@@ -191,7 +191,7 @@ esp_err_t EPDHandler::dangerous_epd_write_data_without_lock_(const uint8_t data)
   return err;
 }
 
-esp_err_t EPDHandler::transfer_spi_data(const uint8_t* data, const size_t& length, uint32_t transaction_id) {
+esp_err_t EPDHandler::transfer_spi_data(const uint8_t* data, const size_t& length, uint32_t transaction_id, bool inverted) {
   ESP_LOGI(TAG, "transfer_spi_data: waiting to send %zu bytes of data", length);
 
   SemaphoreGuard transaction_guard(spi_transaction_mutex_);
@@ -212,12 +212,37 @@ esp_err_t EPDHandler::transfer_spi_data(const uint8_t* data, const size_t& lengt
   size_t offset = 0;
   size_t remaining = length;
   gpio_set_level(PIN_DC, 1); // Data mode
+
+  // Allocate a temporary buffer for inverted data (only if inverted)
+  uint8_t* temp_transfer_buffer = nullptr;
+  if (inverted) {
+    temp_transfer_buffer = (uint8_t*)heap_caps_malloc(DMA_TRANSFER_CHUNK_SIZE, MALLOC_CAP_DMA);
+    if (temp_transfer_buffer == nullptr) {
+      ESP_LOGE(TAG, "Failed to allocate memory for inverted data transfer buffer");
+      ESP_LOGI(TAG, "Current free heap size: %u bytes", esp_get_free_heap_size());
+      ESP_LOGI(TAG, "Current free DMA-capable memory size: %u bytes",
+        heap_caps_get_free_size(MALLOC_CAP_DMA));
+      return ESP_ERR_NO_MEM;
+    }
+  }
+
   while (remaining > 0) {
     size_t transfer_size = (remaining < DMA_TRANSFER_CHUNK_SIZE) ? remaining : DMA_TRANSFER_CHUNK_SIZE;
 
+    const uint8_t* transfer_buffer = nullptr;
+    if (inverted) {
+      // Invert only the current chunk into the temporary buffer
+      for (size_t i = 0; i < transfer_size; ++i) {
+        temp_transfer_buffer[i] = ~data[offset + i];
+      }
+      transfer_buffer = temp_transfer_buffer;
+    } else {
+      transfer_buffer = data + offset;
+    }
+
     spi_transaction_t t = {};
     t.length = transfer_size * 8;  // Length in bits
-    t.tx_buffer = data + offset;
+    t.tx_buffer = transfer_buffer;
 
     esp_err_t ret = spi_device_polling_transmit(spi_, &t);
     if (ret != ESP_OK) {
@@ -227,6 +252,10 @@ esp_err_t EPDHandler::transfer_spi_data(const uint8_t* data, const size_t& lengt
         ESP_LOGE(TAG, "Current free DMA-capable memory size: %u bytes",
           heap_caps_get_free_size(MALLOC_CAP_DMA));
       }
+      if (inverted && temp_transfer_buffer != nullptr) {
+        // Free the temporary inverted buffer
+        heap_caps_free(temp_transfer_buffer);
+      }
       return ret;
     }
 
@@ -240,6 +269,11 @@ esp_err_t EPDHandler::transfer_spi_data(const uint8_t* data, const size_t& lengt
     }
   }
 
+  if (inverted && temp_transfer_buffer != nullptr) {
+    // Free the temporary inverted buffer
+    heap_caps_free(temp_transfer_buffer);
+  }
+
   ESP_LOGI(TAG, "transfer_spi_data: completed sending %zu bytes of data", length);
   return ESP_OK;
 }

main/display/epd_handler.h

@@ -15,7 +15,7 @@ public:
   esp_err_t epd_write_cmd(const uint8_t cmd, uint32_t transaction_id);
   esp_err_t epd_write_data(const uint8_t data, uint32_t transaction_id);
   esp_err_t epd_write_cmd_with_data(const uint8_t cmd, std::vector<uint8_t>& data, uint32_t transaction_id);
-  esp_err_t transfer_spi_data(const uint8_t* data, const size_t& length, uint32_t transaction_id);
+  esp_err_t transfer_spi_data(const uint8_t* data, const size_t& length, uint32_t transaction_id, bool inverted = false);
 
   bool is_busy(void) const;
   void wait_for_idle(void) const;

main/io/nvs_handler.cpp

@@ -20,6 +20,7 @@ NVSStorageHandler::~NVSStorageHandler() {
 void NVSStorageHandler::init(const EventGroupHandle_t& system_event_group) {
   esp_err_t err = nvs_flash_init();
   if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+    ESP_LOGW(TAG, "NVS Flash init failed with %s, erasing and retrying...", esp_err_to_name(err));
     nvs_flash_erase();
     err = nvs_flash_init();
   }
@@ -43,11 +44,26 @@ void NVSStorageHandler::put(const std::string& key, const std::string& value) {
   }
 
   esp_err_t err = nvs_set_str(this->nvsHandle, key.c_str(), value.c_str());
-  if (err != ESP_OK) {
+  if (err == ESP_ERR_NVS_NOT_ENOUGH_SPACE) {
-    ESP_LOGE(TAG, "Error (%s) setting key-value pair in NVS!", esp_err_to_name(err));
+    ESP_LOGE(TAG, "NVS storage full! Cannot store key '%s'. Consider clearing old data.", key.c_str());
-  } else {
+    ESP_LOGI(TAG, "Attempting to erase and retry...");
+    // Try to commit pending changes first
     nvs_commit(this->nvsHandle);
-    // ESP_LOGI(TAG, "Key-value pair (%s, %s) stored in NVS.", key.c_str(), value.c_str());
+    // Retry once
+    err = nvs_set_str(this->nvsHandle, key.c_str(), value.c_str());
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Retry failed: %s", esp_err_to_name(err));
+      return;
+    }
+  } else if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Error (%s) setting key-value pair in NVS!", esp_err_to_name(err));
+    return;
+  }
+
+  // Commit successful write
+  err = nvs_commit(this->nvsHandle);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Error (%s) committing to NVS!", esp_err_to_name(err));
   }
 }
 

main/main.cpp

@@ -42,9 +42,6 @@ void init_queues(
   EventGroupHandle_t& system_lifecycle_event_group
 );
 
-
-
-
 void app_main(void) {
   display_chip_info();
 
@@ -60,14 +57,14 @@ void app_main(void) {
   ESP_LOGI(TAG, "Queues initialized.\n");
 
   //
-  // KVStorageHandler* kv_storage_handler = new NVSStorageHandler(
+  KVStorageHandler* kv_storage_handler = new NVSStorageHandler(
-  //   DEFAULT_STORAGE_NAMESPACE
+    DEFAULT_STORAGE_NAMESPACE
-  // );
+  );
 
-  // auto wifi_handler = std::make_unique<WifiHandler>(
+  auto wifi_handler = std::make_unique<WifiHandler>(
-  //   std::unique_ptr<KVStorageHandler>(new NVSStorageHandler(WIFI_CREDENTIALS_STORAGE_NAMESPACE))
+    std::unique_ptr<KVStorageHandler>(new NVSStorageHandler(WIFI_CREDENTIALS_STORAGE_NAMESPACE))
-  // );
+  );
-  // NetworkHandler* network_handler = new NetworkHandler(std::move(wifi_handler));
+  NetworkHandler* network_handler = new NetworkHandler(std::move(wifi_handler));
   EInkDisplayHandler* display_handler = new EInkDisplayHandler();
   // Initialize display and touch
   // display_handler->init_devices(system_event_group);
@@ -84,8 +81,8 @@ void app_main(void) {
   }
 
   //
-  // kv_storage_handler->init(system_event_group);
+  kv_storage_handler->init(system_event_group);
-  // network_handler->init(system_event_group);
+  network_handler->init(system_event_group);
 
   //
   ESP_LOGI(TAG, "Waiting for system to be ready...\n");
@@ -100,63 +97,73 @@ void app_main(void) {
   );
   ESP_LOGI(TAG, "System is ready. Starting main application...\n");
 
+  DiscordAppDescriptor::instance();
+  UIHandler ui_handler;
+  err = ui_handler.init();
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to initialize UI handler: %s", esp_err_to_name(err));
+    vTaskDelay(5000 / portTICK_PERIOD_MS);
+    return esp_restart();
+  }
+  ESP_LOGI(TAG, "UI handler initialized.\n");
+
   // Allow LVGL system to stabilize before creating objects
   vTaskDelay(pdMS_TO_TICKS(100));
 
   // Create main screen and button for random rectangle demo
-  lv_obj_t* scr = lv_scr_act();
+  // lv_obj_t* scr = lv_scr_act();
 
-  // Create a button
+  // // Create a button
-  lv_obj_t* btn = lv_btn_create(scr);
+  // lv_obj_t* btn = lv_btn_create(scr);
-  lv_obj_set_size(btn, 200, 60);
+  // lv_obj_set_size(btn, 200, 60);
-  lv_obj_align(btn, LV_ALIGN_TOP_MID, 0, 20);
+  // lv_obj_align(btn, LV_ALIGN_TOP_MID, 0, 20);
-  lv_obj_set_style_border_width(btn, 2, 0);
+  // lv_obj_set_style_border_width(btn, 2, 0);
-  lv_obj_set_style_border_color(btn, lv_color_make(0, 0, 0), 0);
+  // lv_obj_set_style_border_color(btn, lv_color_make(0, 0, 0), 0);
 
-  // Add label to button
+  // // Add label to button
-  lv_obj_t* label = lv_label_create(btn);
+  // lv_obj_t* label = lv_label_create(btn);
-  lv_label_set_text(label, "Create Random Rect");
+  // lv_label_set_text(label, "Create Random Rect");
-  lv_obj_center(label);
+  // lv_obj_center(label);
-  lv_obj_set_style_text_color(label, lv_color_make(0, 0, 0), 0);
+  // lv_obj_set_style_text_color(label, lv_color_make(0, 0, 0), 0);
 
-  // Event handler for button - creates random rectangles
+  // // Event handler for button - creates random rectangles
-  auto btn_event_cb = [](lv_event_t* e) {
+  // auto btn_event_cb = [](lv_event_t* e) {
-    lv_obj_t* scr = lv_scr_act();
+  //   lv_obj_t* scr = lv_scr_act();
 
-    // Create a random rectangle
+  //   // Create a random rectangle
-    lv_obj_t* rect = lv_obj_create(scr);
+  //   lv_obj_t* rect = lv_obj_create(scr);
 
-    // Random size (30-100 pixels)
+  //   // Random size (30-100 pixels)
-    lv_coord_t width = 30 + (esp_random() % 70);
+  //   lv_coord_t width = 30 + (esp_random() % 70);
-    lv_coord_t height = 30 + (esp_random() % 70);
+  //   lv_coord_t height = 30 + (esp_random() % 70);
-    lv_obj_set_size(rect, width, height);
+  //   lv_obj_set_size(rect, width, height);
 
-    // Random position (avoid top 100px where button is)
+  //   // Random position (avoid top 100px where button is)
-    lv_coord_t x = esp_random() % (LV_HOR_RES - width);
+  //   lv_coord_t x = esp_random() % (LV_HOR_RES - width);
-    lv_coord_t y = 100 + (esp_random() % (LV_VER_RES - 100 - height));
+  //   lv_coord_t y = 100 + (esp_random() % (LV_VER_RES - 100 - height));
-    lv_obj_set_pos(rect, x, y);
+  //   lv_obj_set_pos(rect, x, y);
 
-    lv_obj_set_style_bg_color(rect, lv_color_make(0, 0, 0), 0);
+  //   lv_obj_set_style_bg_color(rect, lv_color_make(0, 0, 0), 0);
-    lv_obj_set_style_bg_opa(rect, LV_OPA_COVER, 0);
+  //   lv_obj_set_style_bg_opa(rect, LV_OPA_COVER, 0);
 
-    // Make rectangle clickable
+  //   // Make rectangle clickable
-    lv_obj_add_flag(rect, LV_OBJ_FLAG_CLICKABLE);
+  //   lv_obj_add_flag(rect, LV_OBJ_FLAG_CLICKABLE);
 
-    // Event handler to delete rectangle when clicked
+  //   // Event handler to delete rectangle when clicked
-    auto rect_event_cb = [](lv_event_t* e) {
+  //   auto rect_event_cb = [](lv_event_t* e) {
-      lv_obj_t* rect = static_cast<lv_obj_t*>(lv_event_get_target(e));
+  //     lv_obj_t* rect = static_cast<lv_obj_t*>(lv_event_get_target(e));
-      lv_obj_del(rect);
+  //     lv_obj_del(rect);
-      ESP_LOGI(TAG, "Rectangle deleted");
+  //     ESP_LOGI(TAG, "Rectangle deleted");
-      };
+  //     };
 
-    lv_obj_add_event_cb(rect, rect_event_cb, LV_EVENT_CLICKED, NULL);
+  //   lv_obj_add_event_cb(rect, rect_event_cb, LV_EVENT_CLICKED, NULL);
 
-    ESP_LOGI(TAG, "Created rectangle at (%d, %d) with size %dx%d", x, y, width, height);
+  //   ESP_LOGI(TAG, "Created rectangle at (%d, %d) with size %dx%d", x, y, width, height);
-    };
+  //   };
 
-  lv_obj_add_event_cb(btn, btn_event_cb, LV_EVENT_CLICKED, NULL);
+  // lv_obj_add_event_cb(btn, btn_event_cb, LV_EVENT_CLICKED, NULL);
 
-  ESP_LOGI(TAG, "Random rectangle demo initialized. Tap button to create rectangles.\n");
+  // ESP_LOGI(TAG, "Random rectangle demo initialized. Tap button to create rectangles.\n");
 
   // wait for shutdown signal
   ESP_LOGI(TAG, "Waiting for shutdown signal...\n");

main/network/wifi_handler.cpp

@@ -160,6 +160,7 @@ esp_err_t WifiHandler::connect(const std::string& ssid, const std::string& passw
     this->current_ssid.clear();
   }
   this->current_ssid = ssid;
+  this->current_password = password;
 
   //
   wifi_config_t wifi_config = {};
@@ -182,8 +183,8 @@ esp_err_t WifiHandler::connect(const std::string& ssid, const std::string& passw
     return err;
   }
 
-  // store credentials after successful connection attempt
+  // Note: Credentials will be stored in the event handler after successful connection
-  this->store_wifi_credentials(this->current_ssid, password);
+  // to avoid storing credentials for failed connection attempts
 
   return ESP_OK;
 }
@@ -305,6 +306,10 @@ void WifiHandler::wifi_event_handler(void* arg, esp_event_base_t event_base, int
         self->s_wifi_event_group,
         WIFI_CONNECTED_BIT
       );
+      // Store credentials only after successful connection
+      if (!self->current_ssid.empty() && !self->current_password.empty()) {
+        self->store_wifi_credentials(self->current_ssid, self->current_password);
+      }
       break;
     }
     default:
@@ -328,7 +333,11 @@ void WifiHandler::store_wifi_credentials(const std::string& ssid, const std::str
     ESP_LOGE(TAG, "Failed to take credential mutex");
     return;
   }
-  // store the password according to the JSON structure
+
+  // Store current SSID
+  kvs->put(WIFI_SSID_KEY, ssid);
+
+  // Store the password according to the JSON structure
   std::string password_key_store = kvs->get(WIFI_PASSWORD_STORE_KEY);
   cJSON* json = nullptr;
   if (password_key_store.empty()) {
@@ -348,17 +357,37 @@ void WifiHandler::store_wifi_credentials(const std::string& ssid, const std::str
     credentials = cJSON_CreateObject();
     cJSON_AddItemToObject(json, "credentials", credentials);
   }
+
+  // Limit stored credentials to prevent NVS overflow (keep max 10 SSIDs)
+  int credential_count = cJSON_GetArraySize(credentials);
+  if (credential_count >= 10) {
+    ESP_LOGW(TAG, "Too many stored credentials (%d), clearing old ones", credential_count);
+    // Keep only the current SSID's credentials, clear others
+    cJSON_DeleteItemFromObject(credentials, ssid.c_str()); // Remove if exists
+    cJSON* new_credentials = cJSON_CreateObject();
+    cJSON_ReplaceItemInObject(json, "credentials", new_credentials);
+    credentials = new_credentials;
+  }
+
+  // Remove existing entry for this SSID to update it
+  cJSON_DeleteItemFromObject(credentials, ssid.c_str());
+
   // create SSID object
   cJSON* ssid_item = cJSON_CreateObject();
   // add password field
   cJSON_AddStringToObject(ssid_item, "password", password.c_str());
   // add SSID object to credentials
   cJSON_AddItemToObject(credentials, ssid.c_str(), ssid_item);
+
   // store updated JSON string
   char* updated_json_str = cJSON_PrintUnformatted(json);
   if (updated_json_str) {
+    esp_err_t err = ESP_OK;
     kvs->put(WIFI_PASSWORD_STORE_KEY, std::string(updated_json_str));
+    // Note: Error handling is done in nvs_handler.cpp put() method
     cJSON_free(updated_json_str);
+  } else {
+    ESP_LOGE(TAG, "Failed to serialize WiFi credentials JSON");
   }
   cJSON_Delete(json);
 }

main/network/wifi_handler.h

@@ -51,6 +51,8 @@ private:
   SemaphoreHandle_t credential_mutex = nullptr;
   // current connected / preferred SSID
   std::string current_ssid;
+  // current password (temporarily stored for successful connection event)
+  std::string current_password;
   // prevent auto-reconnect on expected disconnection, e.g. when user calls disconnect()
   // should be reset to false after connect()
   bool expect_disconnected = false;

partitions.csv

@@ -0,0 +1,12 @@
+# Name,   Type, SubType,  Offset,   Size,       Flags
+# NVS 256KB
+nvs,      data, nvs,      ,         0x40000,
+# OTA Data 8KB
+otadata,  data, ota,      ,         0x2000,
+# PHY Init 4KB
+phy_init, data, phy,      ,         0x1000,
+# OTA Partitions 10MB
+ota_0,    app,  ota_0,    ,         0xA00000,
+ota_1,    app,  ota_1,    ,         0xA00000,
+# SPIFFS 11MB
+storage,  data, spiffs,   ,         0xB00000,

sdkconfig.default

@@ -430,9 +430,9 @@ CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y
 # end of Recovery Bootloader and Rollback
 
 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
 
 #
@@ -469,8 +469,7 @@ CONFIG_BOOTLOADER_LOG_MODE_TEXT=y
 # CONFIG_BOOTLOADER_FLASH_DC_AWARE is not set
 CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT=y
 CONFIG_BOOTLOADER_FLASH_32BIT_ADDR=y
-CONFIG_BOOTLOADER_FLASH_NEEDS_32BIT_FEAT=y
+CONFIG_BOOTLOADER_CACHE_32BIT_ADDR_OCTAL_FLASH=y
-CONFIG_BOOTLOADER_FLASH_NEEDS_32BIT_ADDR_QUAD_FLASH=y
 # end of Serial Flash Configurations
 
 CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V=y
@@ -552,14 +551,12 @@ CONFIG_BOOT_ROM_LOG_ALWAYS_ON=y
 # Serial flasher config
 #
 # CONFIG_ESPTOOLPY_NO_STUB is not set
-# CONFIG_ESPTOOLPY_OCT_FLASH is not set
+CONFIG_ESPTOOLPY_OCT_FLASH=y
 CONFIG_ESPTOOLPY_FLASH_MODE_AUTO_DETECT=y
-# CONFIG_ESPTOOLPY_FLASHMODE_QIO is not set
+CONFIG_ESPTOOLPY_FLASHMODE_OPI=y
-# CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set
-CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
-# CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set
 CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y
-CONFIG_ESPTOOLPY_FLASHMODE="dio"
+# CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_DTR is not set
+CONFIG_ESPTOOLPY_FLASHMODE="dout"
 # CONFIG_ESPTOOLPY_FLASHFREQ_120M is not set
 CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
 # CONFIG_ESPTOOLPY_FLASHFREQ_40M is not set
@@ -1108,14 +1105,14 @@ CONFIG_SPIRAM_SPEED=80
 CONFIG_SPIRAM_BOOT_HW_INIT=y
 CONFIG_SPIRAM_BOOT_INIT=y
 CONFIG_SPIRAM_PRE_CONFIGURE_MEMORY_PROTECTION=y
-CONFIG_SPIRAM_IGNORE_NOTFOUND=y
+# CONFIG_SPIRAM_IGNORE_NOTFOUND is not set
 # CONFIG_SPIRAM_USE_MEMMAP is not set
 # CONFIG_SPIRAM_USE_CAPS_ALLOC is not set
 CONFIG_SPIRAM_USE_MALLOC=y
-# CONFIG_SPIRAM_MEMTEST is not set
+CONFIG_SPIRAM_MEMTEST=y
 CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=16384
 CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP=y
-CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL=32768
+CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL=65536
 # CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY is not set
 # CONFIG_SPIRAM_ALLOW_NOINIT_SEG_EXTERNAL_MEMORY is not set
 # end of SPI RAM config
@@ -1269,9 +1266,9 @@ 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=y
-# CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER is not set
 CONFIG_ESP_WIFI_TX_BUFFER_TYPE=0
 CONFIG_ESP_WIFI_STATIC_TX_BUFFER_NUM=16
+CONFIG_ESP_WIFI_CACHE_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
@@ -1281,14 +1278,15 @@ 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_AMSDU_TX_ENABLED is not set
 CONFIG_ESP_WIFI_NVS_ENABLED=y
 # CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0 is not set
 CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_1=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_IRAM_OPT is not set
 # CONFIG_ESP_WIFI_EXTRA_IRAM_OPT is not set
-CONFIG_ESP_WIFI_RX_IRAM_OPT=y
+# CONFIG_ESP_WIFI_RX_IRAM_OPT is not set
 CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=y
 CONFIG_ESP_WIFI_ENABLE_SAE_PK=y
 CONFIG_ESP_WIFI_ENABLE_SAE_H2E=y
@@ -1568,6 +1566,7 @@ CONFIG_LWIP_TCP_OOSEQ_MAX_PBUFS=4
 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_WND_SCALE is not set
 CONFIG_LWIP_TCP_RTO_TIME=1500
 # end of TCP
 
@@ -1671,9 +1670,9 @@ CONFIG_LWIP_HOOK_IP6_INPUT_DEFAULT=y
 #
 # mbedTLS
 #
-CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC=y
+# CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC is not set
 # CONFIG_MBEDTLS_EXTERNAL_MEM_ALLOC is not set
-# CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC is not set
+CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC=y
 # CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC is not set
 CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y
 CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=16384
@@ -1835,7 +1834,7 @@ CONFIG_STDATOMIC_S32C1I_SPIRAM_WORKAROUND=y
 # CONFIG_NVS_ENCRYPTION is not set
 # CONFIG_NVS_ASSERT_ERROR_CHECK is not set
 # CONFIG_NVS_LEGACY_DUP_KEYS_COMPATIBILITY is not set
-# CONFIG_NVS_ALLOCATE_CACHE_IN_SPIRAM is not set
+CONFIG_NVS_ALLOCATE_CACHE_IN_SPIRAM=y
 # end of NVS
 
 #
@@ -1877,12 +1876,6 @@ CONFIG_SPI_FLASH_BROWNOUT_RESET=y
 #
 # Features here require specific hardware (READ DOCS FIRST!)
 #
-# CONFIG_SPI_FLASH_HPM_ENA is not set
-CONFIG_SPI_FLASH_HPM_AUTO=y
-# CONFIG_SPI_FLASH_HPM_DIS is not set
-CONFIG_SPI_FLASH_HPM_ON=y
-CONFIG_SPI_FLASH_HPM_DC_AUTO=y
-# CONFIG_SPI_FLASH_HPM_DC_DISABLE is not set
 # 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
@@ -1897,7 +1890,6 @@ CONFIG_SPI_FLASH_PLACE_FUNCTIONS_IN_IRAM=y
 # CONFIG_SPI_FLASH_VERIFY_WRITE is not set
 # CONFIG_SPI_FLASH_ENABLE_COUNTERS is not set
 CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y
-# CONFIG_SPI_FLASH_ROM_IMPL is not set
 CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y
 # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set
 # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set
@@ -2404,11 +2396,8 @@ CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y
 # CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set
 # CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set
 CONFIG_LOG_BOOTLOADER_LEVEL=3
+CONFIG_SPI_FLASH_OCTAL_32BIT_ADDR_ENABLE=y
 # CONFIG_FLASH_ENCRYPTION_ENABLED is not set
-# CONFIG_FLASHMODE_QIO is not set
-# CONFIG_FLASHMODE_QOUT is not set
-CONFIG_FLASHMODE_DIO=y
-# CONFIG_FLASHMODE_DOUT is not set
 CONFIG_MONITOR_BAUD=115200
 # CONFIG_OPTIMIZATION_LEVEL_DEBUG is not set
 # CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG is not set
@@ -2501,21 +2490,22 @@ 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=y
-# CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER is not set
 CONFIG_ESP32_WIFI_TX_BUFFER_TYPE=0
 CONFIG_ESP32_WIFI_STATIC_TX_BUFFER_NUM=16
+CONFIG_ESP32_WIFI_CACHE_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_RX_BA_WIN=6
+# CONFIG_ESP32_WIFI_AMSDU_TX_ENABLED is not set
 CONFIG_ESP32_WIFI_NVS_ENABLED=y
 # CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0 is not set
 CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_1=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_IRAM_OPT is not set
-CONFIG_ESP32_WIFI_RX_IRAM_OPT=y
+# CONFIG_ESP32_WIFI_RX_IRAM_OPT is not set
 CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE=y
 CONFIG_ESP32_WIFI_ENABLE_WPA3_OWE_STA=y
 CONFIG_WPA_MBEDTLS_CRYPTO=y