Ink-Board/ink-board
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Enhance EInkDisplayHandler and LVGLHandler with deep sleep functionality and partial refresh improvements

Browse Source
This commit is contained in:
GW_MC
2026-01-27 19:12:37 +08:00
parent dc2a76e131
commit de2f166151
5 changed files with 343 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

184
main/display/eink_display_handler.cpp
View File

@@ -15,9 +15,12 @@
#define BUSY_INACTIVE_LEVEL 1
#define DMA_TRANSFER_CHUNK_SIZE 4096 // 4KB chunk size for DMA transfers
static uint8_t white_data[DISPLAY_BUFFER_SIZE] = { 0xFF }; // all white data
static uint8_t white_data[DISPLAY_BUFFER_SIZE]; // all white data
static uint8_t black_data[DISPLAY_BUFFER_SIZE]; // all black data
EInkDisplayHandler::EInkDisplayHandler() {
memset(white_data, 0xFF, sizeof(white_data));
memset(black_data, 0x00, sizeof(black_data));
spi_mutex_ = xSemaphoreCreateMutex();
if (spi_mutex_ == nullptr) {
ESP_LOGE(TAG, "Failed to create SPI mutex");
@@ -52,10 +55,52 @@ EInkDisplayHandler::~EInkDisplayHandler() {
}
}
esp_err_t EInkDisplayHandler::deep_sleep_display(void) {
ESP_LOGI(TAG, "Putting display into deep sleep mode...");
if (is_deep_sleep_) {
ESP_LOGI(TAG, "Display is already in deep sleep mode");
return ESP_OK;
}
{
esp_err_t err = ESP_OK;
TransactionGuard transaction_guard(*this);
err = transaction_guard.begin(pdMS_TO_TICKS(5000));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to begin transaction for deep sleep: %s", esp_err_to_name(err));
return err;
}
wait_for_idle();
err = epd_write_cmd(0x02, transaction_guard.transaction_id()); // power off
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send power off command: %s", esp_err_to_name(err));
return err;
}
wait_for_idle();
err = epd_write_cmd(0x07, transaction_guard.transaction_id()); //deep sleep
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send deep sleep command: %s", esp_err_to_name(err));
return err;
}
err = epd_write_data(0xA5, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send deep sleep data: %s", esp_err_to_name(err));
return err;
}
is_deep_sleep_ = true;
return err;
}
}
esp_err_t EInkDisplayHandler::refresh_display() {
esp_err_t err = ESP_OK;
ESP_LOGI(TAG, "Waiting for display to be idle...");
if (is_deep_sleep_) {
epd_init_();
}
{
ESP_LOGI(TAG, "Waiting for display to be idle...");
TransactionGuard transaction_guard(*this);
err = transaction_guard.begin(pdMS_TO_TICKS(10000));
if (err != ESP_OK) {
@@ -88,13 +133,24 @@ esp_err_t EInkDisplayHandler::refresh_display() {
force_full_refresh_ = false;
}
err = deep_sleep_display();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enter deep sleep after refresh: %s", esp_err_to_name(err));
return err;
}
ESP_LOGI(TAG, "Refresh complete");
return ESP_OK;
}
esp_err_t EInkDisplayHandler::full_write(const uint8_t* framebuffer) {
esp_err_t EInkDisplayHandler::full_write(const uint8_t* framebuffer, const bool white_basemap) {
ESP_LOGI(TAG, "Starting full refresh (3 seconds)...");
esp_err_t err = ESP_OK;
if (is_deep_sleep_) {
epd_init_();
}
{
TransactionGuard transaction_guard(*this);
err = transaction_guard.begin(pdMS_TO_TICKS(10000));
@@ -104,7 +160,12 @@ esp_err_t EInkDisplayHandler::full_write(const uint8_t* framebuffer) {
}
wait_for_idle();
// Step 0: Enter normal mode
err = epd_write_cmd(0x92, transaction_guard.transaction_id()); // enter normal mode
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enter normal mode: %s", esp_err_to_name(err));
return err;
}
// Step 1: Write old data (0x10) - Arduino uses 0xFF (all white) for base map
{
err = epd_write_cmd(0x10, transaction_guard.transaction_id());
@@ -112,7 +173,7 @@ esp_err_t EInkDisplayHandler::full_write(const uint8_t* framebuffer) {
ESP_LOGE(TAG, "Failed to send old data command: %s", esp_err_to_name(err));
return err;
}
err = transfer_spi_data(white_data, DISPLAY_BUFFER_SIZE, transaction_guard.transaction_id()); // Send all white data
err = transfer_spi_data(white_basemap ? white_data : black_data, DISPLAY_BUFFER_SIZE, transaction_guard.transaction_id()); // Send all white data (0xFF)
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send all white data for old data: %s", esp_err_to_name(err));
return err;
@@ -147,6 +208,12 @@ esp_err_t EInkDisplayHandler::full_write(const uint8_t* framebuffer) {
wait_for_idle();
}
err = deep_sleep_display();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enter deep sleep after full refresh: %s", esp_err_to_name(err));
return err;
}
ESP_LOGI(TAG, "Full refresh complete");
return ESP_OK;
}
@@ -155,6 +222,11 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* partial_framebuffer
ESP_LOGI(TAG, "Starting partial refresh (0.3 seconds)...");
esp_err_t err = ESP_OK;
// Calculate partial buffer size based on the refresh area
const uint32_t area_width_bytes = (area.x2 - area.x1 + 1) / 8;
const uint32_t area_height = area.y2 - area.y1 + 1;
const size_t partial_buffer_size = area_width_bytes * area_height;
{
TransactionGuard transaction_guard(*this);
err = transaction_guard.begin(pdMS_TO_TICKS(5000));
@@ -162,6 +234,16 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* partial_framebuffer
ESP_LOGE(TAG, "Failed to begin transaction for partial refresh: %s", esp_err_to_name(err));
return err;
}
// Wake display from deep sleep INSIDE the transaction to prevent race conditions
if (is_deep_sleep_) {
err = epd_init_partial_internal_(transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize EPD for partial refresh: %s", esp_err_to_name(err));
return err;
}
}
wait_for_idle();
// Step 1 VCOM setting
@@ -235,15 +317,18 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* partial_framebuffer
return err;
}
err = transfer_spi_data(partial_framebuffer, DISPLAY_BUFFER_SIZE, transaction_guard.transaction_id()); // Send new framebuffer data
// Send only the partial area data, not the full display buffer
ESP_LOGI(TAG, "Sending partial buffer: %zu bytes (area: %dx%d)",
partial_buffer_size, area_width_bytes * 8, area_height);
err = transfer_spi_data(partial_framebuffer, partial_buffer_size, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send partial_framebuffer data for partial refresh: %s", esp_err_to_name(err));
return err;
}
}
// Step 5: Trigger partial display refresh (DRF)
err = epd_write_cmd(0x12, transaction_guard.transaction_id());
// Step 5: Trigger partial display refresh (DRF) by ending the data write
err = epd_write_cmd(0x11, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send display refresh command for partial refresh: %s", esp_err_to_name(err));
return err;
@@ -286,13 +371,20 @@ esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* partial_framebuffer
partial_refresh_count_ = 0;
}
}
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;
}
return ESP_OK;
}
esp_err_t EInkDisplayHandler::clear_display(void) {
ESP_LOGI(TAG, "Clearing display to all white...");
esp_err_t err = full_write(white_data);
esp_err_t err = full_write(black_data, false);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to clear display: %s", esp_err_to_name(err));
return err;
@@ -301,6 +393,8 @@ esp_err_t EInkDisplayHandler::clear_display(void) {
return ESP_OK;
}
// Request a full refresh on next flush
void EInkDisplayHandler::request_full_refresh(void) {
SemaphoreGuard guard(refresh_mutex_);
@@ -351,6 +445,11 @@ esp_err_t EInkDisplayHandler::init_devices(EventGroupHandle_t system_event_group
ESP_LOGE(TAG, "Failed to initialize touch: %s", esp_err_to_name(err));
return err;
}
err = deep_sleep_display();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to put display into deep sleep: %s", esp_err_to_name(err));
return err;
}
// if system_event_group is provided, set display ready bits
if (system_event_group != nullptr) {
@@ -510,9 +609,76 @@ esp_err_t EInkDisplayHandler::epd_init_(void) {
return err;
}
}
is_deep_sleep_ = false;
return err;
}
esp_err_t EInkDisplayHandler::epd_init_partial_(void) {
TransactionGuard transaction_guard(*this);
esp_err_t begin_err = transaction_guard.begin();
if (begin_err != ESP_OK) {
ESP_LOGE(TAG, "Failed to begin transaction: %s", esp_err_to_name(begin_err));
return begin_err;
}
return epd_init_partial_internal_(transaction_guard.transaction_id());
}
// Internal version that uses an existing transaction (no separate TransactionGuard)
esp_err_t EInkDisplayHandler::epd_init_partial_internal_(uint32_t transaction_id) {
ESP_LOGI(TAG, "Initializing EPD for partial refresh (internal)...");
esp_err_t err = ESP_OK;
// 1. Hardware Reset
err = gpio_set_level(PIN_RST, 0);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to set PIN_RST low: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS));
err = gpio_set_level(PIN_RST, 1);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to set PIN_RST high: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS));
// 2. Panel Setting
std::vector<uint8_t> panel_setting_data = { 0x1F };
err = epd_write_cmd_with_data(0x00, panel_setting_data, transaction_id);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send Panel Setting command: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS));
// 3. Power ON
err = epd_write_cmd(0x04, transaction_id);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send Power ON command: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_POWER_ON_DELAY_MS));
wait_for_idle();
// 4. Partial initialization sequence - Enhanced Display Drive
std::vector<uint8_t> e0_data = { 0x02 };
err = epd_write_cmd_with_data(0xE0, e0_data, transaction_id);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send Enhanced Display Drive command (E0): %s", esp_err_to_name(err));
return err;
}
std::vector<uint8_t> e5_data = { 0x6E };
err = epd_write_cmd_with_data(0xE5, e5_data, transaction_id);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send Enhanced Display Drive command (E5): %s", esp_err_to_name(err));
return err;
}
is_deep_sleep_ = false;
ESP_LOGI(TAG, "EPD partial init (internal) complete");
return ESP_OK;
}
esp_err_t EInkDisplayHandler::init_touch_() {
ESP_LOGI(TAG, "Initializing touch...");

31
main/display/eink_display_handler.h
View File

@@ -4,6 +4,7 @@
#include "esp_lcd_touch_gt911.h"
#include "common/semaphore_guard.h"
#include <vector>
#include <atomic>
// Refresh mode configuration
#define PARTIAL_REFRESH_THRESHOLD 10 // Full refresh every N partial refreshes
@@ -21,6 +22,28 @@ public:
int32_t y1;
int32_t x2;
int32_t y2;
// reset to empty area
void reset() {
x1 = y1 = x2 = y2 = 0;
}
// expand area to include another area
void expand_to_include(const RefreshArea& other) {
expand_to_include(other.x1, other.y1, other.x2, other.y2);
}
void expand_to_include(int32_t x1, int32_t y1, int32_t x2, int32_t y2) {
const bool force_update = is_empty();
if (x1 < this->x1 || force_update) this->x1 = x1;
if (y1 < this->y1 || force_update) this->y1 = y1;
if (x2 > this->x2 || force_update) this->x2 = x2;
if (y2 > this->y2 || force_update) this->y2 = y2;
}
bool is_empty() const {
return (x1 == 0 && y1 == 0 && x2 == 0 && y2 == 0);
}
uint32_t area() const {
if (is_empty()) return 0;
return (x2 - x1 + 1) * (y2 - y1 + 1);
}
};
class EInkDisplayHandler {
@@ -32,9 +55,10 @@ public:
esp_err_t refresh_display(void);
esp_err_t full_write(const uint8_t* framebuffer);
esp_err_t full_write(const uint8_t* framebuffer, const bool white_basemap = true);
esp_err_t partial_refresh(const uint8_t* framebuffer, const RefreshArea& area);
esp_err_t clear_display(void);
esp_err_t deep_sleep_display(void);
// Request a full refresh on next flush
void request_full_refresh(void);
@@ -53,7 +77,9 @@ protected:
private:
esp_err_t init_display_pins_(void);
esp_err_t epd_init_(void);
esp_err_t epd_init_(void); // full fast refresh init
esp_err_t epd_init_partial_(void); // partial refresh init (standalone)
esp_err_t epd_init_partial_internal_(uint32_t transaction_id); // partial refresh init (within existing transaction)
esp_err_t init_touch_(void);
esp_err_t dangerous_epd_write_cmd_without_lock_(const uint8_t cmd);
esp_err_t dangerous_epd_write_data_without_lock_(const uint8_t data);
@@ -67,6 +93,7 @@ private:
uint32_t partial_refresh_count_ = 0;
bool force_full_refresh_ = false;
std::atomic<bool> is_deep_sleep_ { false };
SemaphoreHandle_t spi_mutex_ = nullptr;
SemaphoreHandle_t spi_transaction_mutex_ = nullptr;

140
main/display/lvgl_handler.cpp
View File

@@ -6,6 +6,7 @@
#define DISPLAY_BUFFER_SIZE (DISPLAY_WIDTH * DISPLAY_HEIGHT) / 8 // 1 bit per pixels
#define LVGL_BUFFER_SIZE (DISPLAY_BUFFER_SIZE + 8) // 1 bit per pixels + 8 bytes for palette
#define LV_DISPLAY_RENDER_MODE LV_DISPLAY_RENDER_MODE_PARTIAL
#define TAG "LVGLHandler"
LVGLHandler::LVGLHandler(
@@ -96,9 +97,14 @@ void LVGLHandler::rounder_cb_(lv_display_t* disp, lv_area_t* area) {
}
void LVGLHandler::flush_cb_(lv_display_t* disp, const lv_area_t* area, uint8_t* px_map) {
if (disp == nullptr || area == nullptr || px_map == nullptr) {
ESP_LOGE(TAG, "Null parameters in flush callback");
if (disp != nullptr) lv_display_flush_ready(disp);
return;
}
LVGLHandler* handler = static_cast<LVGLHandler*>(lv_display_get_user_data(disp));
if (handler == nullptr || handler->display_handler_ == nullptr) {
ESP_LOGE(TAG, "Invalid handler in flush callback");
if (handler == nullptr || handler->display_handler_ == nullptr || handler->framebuffer_ == nullptr) {
ESP_LOGE(TAG, "Invalid handler or framebuffer in flush callback");
lv_display_flush_ready(disp);
return;
}
@@ -117,60 +123,81 @@ void LVGLHandler::flush_cb_(lv_display_t* disp, const lv_area_t* area, uint8_t*
int32_t area_w = lv_area_get_width(area);
int32_t area_h = lv_area_get_height(area);
if (area->x1 == 0 && area->y1 == 0 && area_w == DISPLAY_WIDTH && area_h == DISPLAY_HEIGHT) {
// Check if content actually changed before triggering expensive e-ink refresh
if (memcmp(handler->framebuffer_, pixel_data, DISPLAY_BUFFER_SIZE) == 0) {
ESP_LOGD(TAG, "Full screen flush with no changes - skipping e-ink refresh");
lv_display_flush_ready(disp);
return;
}
ESP_LOGI(TAG, "Full screen update");
memcpy(framebuffer_, pixel_data, DISPLAY_BUFFER_SIZE);
memcpy(handler->framebuffer_, pixel_data, DISPLAY_BUFFER_SIZE);
// invert the framebuffer for e-ink display
for (size_t i = 0; i < DISPLAY_BUFFER_SIZE; ++i) {
handler->framebuffer_[i] = ~handler->framebuffer_[i];
}
// request full refresh
esp_err_t err = handler->display_handler_->refresh_display();
esp_err_t err = handler->display_handler_->full_write(handler->framebuffer_, true);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Full refresh request failed: %s", esp_err_to_name(err));
}
} else {
// partial update
ESP_LOGI(TAG, "Partial update: x1=%d, y1=%d, w=%d, h=%d", area->x1, area->y1, area_w, area_h);
// 1. Calculate Strides
int32_t fb_stride_bytes = DISPLAY_WIDTH / 8; // Stride of the full framebuffer
int32_t src_stride_bytes = area_w / 8; // Stride of the LVGL partial buffer
// 2. Safety: Ensure we don't write out of bounds
// (The rounder_cb should prevent this, but clipping is safe practice)
int32_t safe_h = area_h;
if (area->y1 + safe_h > DISPLAY_HEIGHT) {
safe_h = DISPLAY_HEIGHT - area->y1;
ESP_LOGW(TAG, "Clipping height to %d to prevent OOB", safe_h);
// update the framebuffer with the partial data
for (int32_t row = 0; row < area_h; ++row) {
int32_t fb_y = area->y1 + row;
int32_t fb_x_byte_start = area->x1 / 8;
int32_t fb_x_byte_end = area->x2 / 8;
uint8_t* fb_ptr = &handler->framebuffer_[fb_y * (DISPLAY_WIDTH / 8) + fb_x_byte_start];
const uint8_t* src_ptr = &pixel_data[row * (area_w / 8)];
// invert the partial framebuffer data for e-ink display
for (int32_t i = 0; i < (fb_x_byte_end - fb_x_byte_start + 1); ++i) {
fb_ptr[i] = ~src_ptr[i];
}
}
// update the refresh area
handler->refresh_area_.expand_to_include(area->x1, area->y1, area->x2, area->y2);
//
// 3. Iterate Rows
uint8_t* partial_buffer = new uint8_t[src_stride_bytes * safe_h];
if (partial_buffer == nullptr) {
ESP_LOGE(TAG, "Failed to allocate partial buffer for refresh");
lv_display_flush_ready(disp);
return;
}
for (int32_t y = 0; y < safe_h; y++) {
// Calculate Absolute Y in Framebuffer
int32_t fb_y = area->y1 + y;
if (lv_display_flush_is_last(disp) && !handler->refresh_area_.is_empty()) {
ESP_LOGI(TAG, "Last flush in batch - performing partial refresh");
ESP_LOGI(TAG, "Refresh area: x1=%d, y1=%d, x2=%d, y2=%d",
handler->refresh_area_.x1, handler->refresh_area_.y1,
handler->refresh_area_.x2, handler->refresh_area_.y2);
// copy the area to refresh
uint8_t* partial_buffer = new uint8_t[handler->refresh_area_.area() / 8];
if (partial_buffer == nullptr) {
ESP_LOGE(TAG, "Failed to allocate partial buffer for refresh");
lv_display_flush_ready(disp);
return;
}
// loop the refresh area and copy data
uint32_t x1 = handler->refresh_area_.x1;
uint32_t x2 = handler->refresh_area_.x2;
uint32_t y1 = handler->refresh_area_.y1;
uint32_t y2 = handler->refresh_area_.y2;
uint32_t height = y2 - y1 + 1;
uint32_t width = x2 - x1 + 1;
// Calculate Source Pointer (Start of current line in partial buffer)
// NOTE: Use src_stride_bytes, NOT fb_stride_bytes
uint8_t* src_line = pixel_data + (y * src_stride_bytes);
for (uint32_t row = 0; row < height; ++row) {
uint32_t fb_y = y1 + row;
uint32_t fb_x_byte_start = x1 / 8;
uint32_t fb_x_byte_end = x2 / 8;
uint8_t* fb_ptr = &handler->framebuffer_[fb_y * (DISPLAY_WIDTH / 8) + fb_x_byte_start];
uint8_t* dest_ptr = &partial_buffer[row * (width / 8)];
for (uint32_t i = 0; i < (fb_x_byte_end - fb_x_byte_start + 1); ++i) {
dest_ptr[i] = ~fb_ptr[i];
}
}
// Calculate Destination Pointer (Start of current line in full framebuffer)
// Offset = (Row * Stride) + (X_Start_Byte)
uint8_t* dst_line = handler->framebuffer_ + (fb_y * fb_stride_bytes) + (area->x1 / 8);
esp_err_t err = handler->display_handler_->partial_refresh(partial_buffer,
handler->refresh_area_);
delete[] partial_buffer;
// 4. Block Copy
// Since x1 is byte-aligned by rounder_cb, we can copy the whole row directly.
memcpy(dst_line, src_line, src_stride_bytes);
// also copy to partial_buffer for refresh
memcpy(partial_buffer + (y * src_stride_bytes), src_line, src_stride_bytes);
}
// 5. Request partial refresh
esp_err_t err = handler->display_handler_->partial_refresh(partial_buffer,
RefreshArea(area->x1, area->y1, area->x2, area->y2));
delete[] partial_buffer;
if (err != ESP_OK) {
ESP_LOGE(TAG, "Partial refresh request failed: %s", esp_err_to_name(err));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Partial refresh request failed: %s", esp_err_to_name(err));
}
handler->refresh_area_.reset();
}
}
//
@@ -228,7 +255,7 @@ esp_err_t LVGLHandler::initLVGLDisplay_() {
esp_err_t err = ESP_OK;
// Lock LVGL to prevent the timer task from accessing partially initialized display
if (!lvgl_port_lock(pdMS_TO_TICKS(1000))) {
if (!lvgl_port_lock(pdMS_TO_TICKS(5000))) {
ESP_LOGE(TAG, "Failed to lock LVGL port for display initialization");
return ESP_ERR_TIMEOUT;
}
@@ -237,6 +264,7 @@ esp_err_t LVGLHandler::initLVGLDisplay_() {
lvgl_display_ = lv_display_create(DISPLAY_WIDTH, DISPLAY_HEIGHT);
if (lvgl_display_ == nullptr) {
ESP_LOGE(TAG, "Failed to create LVGL display");
lvgl_port_unlock();
return ESP_FAIL;
}
@@ -251,6 +279,8 @@ esp_err_t LVGLHandler::initLVGLDisplay_() {
framebuffer_in_psram_ = false;
if (framebuffer_ == nullptr) {
ESP_LOGE(TAG, "Failed to allocate framebuffer");
lv_display_delete(lvgl_display_);
lvgl_display_ = nullptr;
lvgl_port_unlock();
return ESP_FAIL;
}
@@ -261,20 +291,16 @@ esp_err_t LVGLHandler::initLVGLDisplay_() {
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");
heap_caps_free(framebuffer_);
framebuffer_ = nullptr;
lv_display_delete(lvgl_display_);
lvgl_display_ = nullptr;
lvgl_port_unlock();
return ESP_FAIL;
}
lv_display_set_draw_buffers(lvgl_display_, lvgl_draw_buf_, nullptr);
lv_display_set_render_mode(lvgl_display_, LV_DISPLAY_RENDER_MODE_DIRECT);
lv_display_set_render_mode(lvgl_display_, LV_DISPLAY_RENDER_MODE);
//
ESP_LOGI(TAG, "Performing initial display write...");
err = display_handler_->full_write(framebuffer_);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Initial display write failed: %d", err);
} else {
ESP_LOGI(TAG, "Initial display write complete");
}
// Configure LVGL display
lv_display_set_color_format(lvgl_display_, LV_COLOR_FORMAT_I1);
lv_display_set_user_data(lvgl_display_, this);
@@ -299,6 +325,16 @@ esp_err_t LVGLHandler::initLVGLDisplay_() {
});
// Unlock LVGL now that display is fully initialized
ESP_LOGI(TAG, "Performing initial display write...");
// err = display_handler_->full_write(framebuffer_, false);
err = display_handler_->clear_display();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Initial display write failed: %d", err);
} else {
ESP_LOGI(TAG, "Initial display write complete");
}
lvgl_port_unlock();
ESP_LOGI(TAG, "LVGL display registered");

3
main/display/lvgl_handler.h
View File

@@ -7,7 +7,6 @@
#include "esp_err.h"
#include <memory>
class LVGLHandler {
public:
LVGLHandler(
@@ -34,6 +33,8 @@ private:
lv_draw_buf_t* lvgl_draw_buf_ = nullptr;
uint8_t* framebuffer_ = nullptr;
bool framebuffer_in_psram_ = false;
RefreshArea refresh_area_ = { 0, 0, 0, 0 };
SemaphoreHandle_t lvgl_mutex_ = nullptr;
};