355 lines
12 KiB
C++
355 lines
12 KiB
C++
#include "display/lvgl_handler.h"
|
|
#include "esp_log.h"
|
|
#include "common/semaphore_guard.h"
|
|
#include "common/constants.h"
|
|
#include <portmacro.h>
|
|
|
|
#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 TAG "LVGLHandler"
|
|
|
|
LVGLHandler::LVGLHandler(
|
|
std::unique_ptr<EInkDisplayHandler> display_handler_in
|
|
) : display_handler_(std::move(display_handler_in)) {
|
|
lvgl_mutex_ = xSemaphoreCreateMutex();
|
|
if (lvgl_mutex_ == nullptr) {
|
|
ESP_LOGE(TAG, "Failed to create LVGL mutex");
|
|
}
|
|
}
|
|
|
|
LVGLHandler::~LVGLHandler() {
|
|
if (lvgl_display_ != nullptr) {
|
|
lv_display_delete(lvgl_display_);
|
|
lvgl_display_ = nullptr;
|
|
}
|
|
if (lvgl_touch_indev_ != nullptr) {
|
|
lvgl_port_remove_touch(lvgl_touch_indev_);
|
|
lvgl_touch_indev_ = nullptr;
|
|
}
|
|
if (lvgl_draw_buf_ != nullptr) {
|
|
lv_draw_buf_destroy(lvgl_draw_buf_);
|
|
lvgl_draw_buf_ = nullptr;
|
|
}
|
|
if (framebuffer_ != nullptr) {
|
|
heap_caps_free(framebuffer_);
|
|
framebuffer_ = nullptr;
|
|
}
|
|
if (lvgl_mutex_ != nullptr) {
|
|
vSemaphoreDelete(lvgl_mutex_);
|
|
lvgl_mutex_ = nullptr;
|
|
}
|
|
}
|
|
|
|
esp_err_t LVGLHandler::initLVGL(EventGroupHandle_t system_event_group) {
|
|
esp_err_t err = initLVGLPort_();
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
err = initLVGLDisplay_();
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
err = registerLVGLTouch_();
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
|
|
|
|
auto lvgl_tick_timer_callback = [](TimerHandle_t xTimer) {
|
|
lv_tick_inc(5);
|
|
};
|
|
TickType_t lvgl_tick_period = pdMS_TO_TICKS(5);
|
|
if (lvgl_tick_period == 0) {
|
|
lvgl_tick_period = 1; // ensure at least 1 tick to avoid FreeRTOS assert
|
|
}
|
|
ESP_LOGV(TAG, "Creating LVGL tick timer with period %u ticks...\n", (unsigned)lvgl_tick_period);
|
|
TimerHandle_t lvgl_tick_timer = xTimerCreate(
|
|
"lvgl_tick_timer",
|
|
lvgl_tick_period,
|
|
pdTRUE,
|
|
NULL,
|
|
lvgl_tick_timer_callback
|
|
);
|
|
if (lvgl_tick_timer == NULL) {
|
|
ESP_LOGE("Main", "Failed to create LVGL tick timer");
|
|
vTaskDelay(5000 / portTICK_PERIOD_MS);
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
ESP_LOGV(TAG, "Starting LVGL tick timer...\n");
|
|
xTimerStart(lvgl_tick_timer, 0);
|
|
|
|
if (system_event_group != nullptr) {
|
|
xEventGroupSetBits(system_event_group, DISPLAY_READY_BIT | TOUCH_CALIBRATED_BIT);
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
//
|
|
// Private methods
|
|
//
|
|
|
|
void LVGLHandler::rounder_cb_(lv_display_t* disp, lv_area_t* area) {
|
|
// align x to byte boundary
|
|
area->x1 = (area->x1 & ~0x7);
|
|
area->x2 = (area->x2 | 0x7);
|
|
}
|
|
|
|
void LVGLHandler::flush_cb_(lv_display_t* disp, const lv_area_t* area, uint8_t* px_map) {
|
|
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");
|
|
lv_display_flush_ready(disp);
|
|
return;
|
|
}
|
|
uint8_t* pixel_data = px_map + 8; // Skip palette
|
|
//
|
|
ESP_LOGI(TAG, "Flush callback: x1=%d, y1=%d, x2=%d, y2=%d", area->x1, area->y1, area->x2, area->y2);
|
|
// take mutex
|
|
SemaphoreGuard guard(handler->lvgl_mutex_);
|
|
if (!guard.take(pdMS_TO_TICKS(5000))) {
|
|
ESP_LOGE(TAG, "LVGL mutex timeout in flush callback");
|
|
lv_display_flush_ready(disp);
|
|
return;
|
|
}
|
|
|
|
// copy data to framebuffer
|
|
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) {
|
|
ESP_LOGI(TAG, "Full screen update");
|
|
memcpy(framebuffer_, pixel_data, DISPLAY_BUFFER_SIZE);
|
|
// request full refresh
|
|
esp_err_t err = handler->display_handler_->refresh_display();
|
|
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);
|
|
}
|
|
|
|
// 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;
|
|
|
|
// 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);
|
|
|
|
// 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);
|
|
|
|
// 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));
|
|
}
|
|
}
|
|
//
|
|
lv_display_flush_ready(disp);
|
|
}
|
|
|
|
void LVGLHandler::touch_read_cb_(lv_indev_t* indev, lv_indev_data_t* data) {
|
|
LVGLHandler* handler = static_cast<LVGLHandler*>(lv_indev_get_user_data(indev));
|
|
if (handler == nullptr || handler->display_handler_ == nullptr) {
|
|
data->state = LV_INDEV_STATE_RELEASED;
|
|
ESP_LOGE(TAG, "Invalid handler in touch read callback");
|
|
return;
|
|
}
|
|
|
|
// Disable touch input during display refresh (BUSY)
|
|
if (handler->display_handler_->is_busy()) {
|
|
data->state = LV_INDEV_STATE_RELEASED;
|
|
data->continue_reading = false;
|
|
return;
|
|
}
|
|
|
|
esp_lcd_touch_handle_t tp_handle = handler->display_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;
|
|
}
|
|
|
|
esp_err_t LVGLHandler::initLVGLDisplay_() {
|
|
if (display_handler_ == nullptr) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
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))) {
|
|
ESP_LOGE(TAG, "Failed to lock LVGL port for display initialization");
|
|
return ESP_ERR_TIMEOUT;
|
|
}
|
|
|
|
// Create LVGL display
|
|
lvgl_display_ = lv_display_create(DISPLAY_WIDTH, DISPLAY_HEIGHT);
|
|
if (lvgl_display_ == nullptr) {
|
|
ESP_LOGE(TAG, "Failed to create LVGL display");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
// set framebuffer
|
|
framebuffer_ = (uint8_t*)heap_caps_malloc(LVGL_BUFFER_SIZE, MALLOC_CAP_SPIRAM);
|
|
if (framebuffer_ != nullptr) {
|
|
framebuffer_in_psram_ = true;
|
|
ESP_LOGI(TAG, "Framebuffer allocated in PSRAM (%zu bytes)", LVGL_BUFFER_SIZE);
|
|
} else {
|
|
ESP_LOGW(TAG, "PSRAM not available, allocating framebuffer in internal RAM");
|
|
framebuffer_ = (uint8_t*)heap_caps_malloc(LVGL_BUFFER_SIZE, MALLOC_CAP_INTERNAL);
|
|
framebuffer_in_psram_ = false;
|
|
if (framebuffer_ == nullptr) {
|
|
ESP_LOGE(TAG, "Failed to allocate framebuffer");
|
|
lvgl_port_unlock();
|
|
return ESP_FAIL;
|
|
}
|
|
ESP_LOGI(TAG, "Framebuffer allocated in internal RAM (%zu bytes)", LVGL_BUFFER_SIZE);
|
|
}
|
|
memset(framebuffer_, 0xFF, LVGL_BUFFER_SIZE); // Initialize to white
|
|
// Create a draw buffer covering the entire display
|
|
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(lvgl_display_);
|
|
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);
|
|
//
|
|
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);
|
|
|
|
lv_display_add_event_cb(lvgl_display_, [](lv_event_t* e) {
|
|
LVGLHandler* handler = static_cast<LVGLHandler*>(lv_display_get_user_data(static_cast<lv_display_t*>(lv_event_get_target(e))));
|
|
if (handler != nullptr) {
|
|
handler->rounder_cb_(static_cast<lv_display_t*>(lv_event_get_target(e)),
|
|
static_cast<lv_area_t*>(lv_event_get_param(e)));
|
|
} else {
|
|
ESP_LOGE(TAG, "Invalid handler in rounder callback");
|
|
}
|
|
}, LV_EVENT_INVALIDATE_AREA, lvgl_display_);
|
|
|
|
lv_display_set_flush_cb(lvgl_display_, [](lv_display_t* disp, const lv_area_t* area, uint8_t* px_map) {
|
|
LVGLHandler* handler = static_cast<LVGLHandler*>(lv_display_get_user_data(disp));
|
|
if (handler != nullptr) {
|
|
handler->flush_cb_(disp, area, px_map);
|
|
} else {
|
|
lv_display_flush_ready(disp);
|
|
}
|
|
});
|
|
|
|
// Unlock LVGL now that display is fully initialized
|
|
lvgl_port_unlock();
|
|
|
|
ESP_LOGI(TAG, "LVGL display registered");
|
|
return err;
|
|
}
|
|
|
|
esp_err_t LVGLHandler::registerLVGLTouch_() {
|
|
if (display_handler_ == nullptr) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
esp_lcd_touch_handle_t tp_handle = display_handler_->get_touch_handle();
|
|
if (tp_handle == nullptr) {
|
|
ESP_LOGE(TAG, "Touch handle is NULL — touch initialization failed; skipping LVGL touch registration");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
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 ESP_FAIL;
|
|
}
|
|
|
|
lv_indev_set_user_data(lvgl_touch_indev_, this);
|
|
lv_indev_set_read_cb(lvgl_touch_indev_, [](lv_indev_t* indev, lv_indev_data_t* data) {
|
|
LVGLHandler* handler = static_cast<LVGLHandler*>(lv_indev_get_user_data(indev));
|
|
if (handler != nullptr) {
|
|
handler->touch_read_cb_(indev, data);
|
|
} else {
|
|
data->state = LV_INDEV_STATE_RELEASED;
|
|
}
|
|
});
|
|
|
|
ESP_LOGI(TAG, "LVGL touch input registered");
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t LVGLHandler::initLVGLPort_() {
|
|
const lvgl_port_cfg_t lvgl_cfg = ESP_LVGL_PORT_INIT_CONFIG();
|
|
esp_err_t err = lvgl_port_init(&lvgl_cfg);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG, "LVGL port initialization failed: %s", esp_err_to_name(err));
|
|
vTaskDelay(5000 / portTICK_PERIOD_MS);
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
ESP_LOGI(TAG, "LVGL port initialized successfully.\n");
|
|
return ESP_OK;
|
|
}
|