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

Squash of branch setup

Browse Source
This commit is contained in:
GW_MC
2026-01-27 19:15:44 +08:00
parent 64fe528abc
commit 3ce135a028
66 changed files with 10798 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
main/display/constants.h Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
#include "driver/spi_master.h"
#include "driver/gpio.h"
#define PIN_TOUCH_IRQ GPIO_NUM_4
#define PIN_TOUCH_SDA GPIO_NUM_5
#define PIN_TOUCH_SCL GPIO_NUM_6
#define PIN_BUSY GPIO_NUM_7
#define PIN_RST GPIO_NUM_8
#define PIN_DC GPIO_NUM_9
#define PIN_CS GPIO_NUM_10
#define PIN_MOSI GPIO_NUM_11
#define PIN_SCK GPIO_NUM_12
#define PIN_TOUCH_RST GPIO_NUM_13

199
main/display/display.cpp.old Normal file
View File

@@ -0,0 +1,199 @@
#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;
}
}

42
main/display/display.h.old Normal file
View File

@@ -0,0 +1,42 @@
#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);
};

942
main/display/eink_display_handler.cpp Normal file
View File

@@ -0,0 +1,942 @@
#include "display/eink_display_handler.h"
#include "display/constants.h"
#include "common/constants.h"
#include "esp_lcd_touch_gt911.h"
#include "esp_log.h"
#include <driver/i2c.h>
#include <vector>
#include "common/semaphore_guard.h"
#define TAG "EInkDisplayHandler"
#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 BUSY_ACTIVE_LEVEL 0 // BUSY pin is active low
#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]; // 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");
}
spi_transaction_mutex_ = xSemaphoreCreateMutex();
if (spi_transaction_mutex_ == nullptr) {
ESP_LOGE(TAG, "Failed to create SPI transaction mutex");
}
refresh_mutex_ = xSemaphoreCreateMutex();
if (refresh_mutex_ == nullptr) {
ESP_LOGE(TAG, "Failed to create refresh mutex");
}
}
EInkDisplayHandler::~EInkDisplayHandler() {
if (spi_mutex_ != nullptr) {
vSemaphoreDelete(spi_mutex_);
}
if (spi_transaction_mutex_ != nullptr) {
vSemaphoreDelete(spi_transaction_mutex_);
}
if (refresh_mutex_ != nullptr) {
vSemaphoreDelete(refresh_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_);
}
}
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;
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) {
ESP_LOGE(TAG, "Failed to begin transaction for display refresh: %s", esp_err_to_name(err));
return err;
}
wait_for_idle();
ESP_LOGI(TAG, "Starting display refresh...");
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;
}
err = epd_write_cmd(0x12, transaction_guard.transaction_id()); // display refresh
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send display refresh command: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS)); // at least 200us delay
wait_for_idle();
}
{
SemaphoreGuard guard(refresh_mutex_);
if (guard.take(pdMS_TO_TICKS(5000)) != pdTRUE) {
ESP_LOGE(TAG, "Refresh mutex timeout in refresh_display");
return ESP_ERR_TIMEOUT;
}
partial_refresh_count_ = 0;
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, 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));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to begin transaction for full refresh: %s", esp_err_to_name(err));
return err;
}
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());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send old data command: %s", esp_err_to_name(err));
return err;
}
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;
}
}
// Step 2: Write new data (0x13)
{
err = epd_write_cmd(0x13, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send new data command: %s", esp_err_to_name(err));
return err;
}
err = transfer_spi_data(framebuffer, DISPLAY_BUFFER_SIZE, transaction_guard.transaction_id()); // Send new framebuffer data
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send framebuffer data for new data: %s", esp_err_to_name(err));
return err;
}
}
// Step 3: Trigger display refresh (DRF)
err = epd_write_cmd(0x12, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send display refresh command: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS)); // at least 200us delay
ESP_LOGI(TAG, "Display refresh triggered, BUSY pin: %d", gpio_get_level(PIN_BUSY));
// Wait for refresh to complete
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;
}
esp_err_t EInkDisplayHandler::partial_refresh(const uint8_t* partial_framebuffer, const RefreshArea& area) {
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));
if (err != ESP_OK) {
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
std::vector<uint8_t> vcom_data = { 0xA9, 0x07 };
err = epd_write_cmd_with_data(0x50, vcom_data, transaction_guard.transaction_id()); // VCOM for partial refresh
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to set VCOM for partial refresh: %s", esp_err_to_name(err));
return err;
}
// Step 2: Enter partial refresh mode
err = epd_write_cmd(0x91, transaction_guard.transaction_id()); // Enter partial mode
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enter partial refresh mode: %s", esp_err_to_name(err));
return err;
}
// Step 3: Set partial window
{
if (area.x1 % 8 != 0 || area.x2 % 8 != 7) {
ESP_LOGE(TAG, "Partial refresh area x1 and x2 must be byte-aligned (x1 %% 8 == 0 and x2 %% 8 == 7)");
return ESP_ERR_INVALID_ARG;
}
// ------DD
// DDDDD000
// ------DD
// DDDDD111
// ------DD
// DDDDDDDD
// ------DD
// DDDDDDDD
// -------D
// area should be multiple of 8 in x direction
const int32_t x_bank_start = area.x1 >> 3;
const int32_t x_bank_end = area.x2 >> 3;
std::vector<uint8_t> window_data = {
// x start, [9:8] bit -> 6 and 7 bits of x_bank_start
static_cast<uint8_t>((x_bank_start >> 5) & 0x03),
// x start, [7:3] bit + 3 bits of 0 -> 5 bits of x_bank_start and pad 3 LSBs as 0
static_cast<uint8_t>((x_bank_start & 0x1F) << 3),
// x end, [9:8] bit
static_cast<uint8_t>((x_bank_end >> 5) & 0x03),
// x end, [7:3] bit + 3 bits of 1
static_cast<uint8_t>(((x_bank_end & 0x1F) << 3) | 0x07),
// y start, [9:8] bit
static_cast<uint8_t>((area.y1 >> 8) & 0x03),
// y start, [7:0] bit
static_cast<uint8_t>(area.y1 & 0xFF),
// y end, [9:8] bit
static_cast<uint8_t>((area.y2 >> 8) & 0x03),
// y end, [7:0] bit
static_cast<uint8_t>(area.y2 & 0xFF),
0x01 // Gates scan both inside and outside of the partial window
};
ESP_LOGI(TAG, "Setting partial window: x1=%d, y1=%d, x2=%d, y2=%d",
area.x1, area.y1, area.x2, area.y2);
ESP_LOGI(TAG, "Partial window data: %02X %02X %02X %02X %02X %02X %02X %02X",
window_data[0], window_data[1], window_data[2], window_data[3], window_data[4],
window_data[5], window_data[6], window_data[7]);
err = epd_write_cmd_with_data(0x90, window_data, transaction_guard.transaction_id()); // Set partial window
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send set partial window command: %s", esp_err_to_name(err));
return err;
}
}
// Step 4: Write new data (0x13)
{
err = epd_write_cmd(0x13, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send new data command for partial refresh: %s", esp_err_to_name(err));
return err;
}
// 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) 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;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS)); // at least 200us delay
wait_for_idle();
// Step 6: Exit partial mode
err = epd_write_cmd(0x92, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to exit partial refresh mode: %s", esp_err_to_name(err));
return err;
}
}
ESP_LOGI(TAG, "Partial refresh complete");
if (force_full_refresh_) {
ESP_LOGI(TAG, "Full refresh already requested, skipping partial refresh count increment");
err = refresh_display();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to perform forced full refresh: %s", esp_err_to_name(err));
return err;
}
return ESP_OK;
}
{
SemaphoreGuard guard(refresh_mutex_);
if (guard.take(pdMS_TO_TICKS(5000)) != pdTRUE) {
ESP_LOGE(TAG, "Refresh mutex timeout in partial_refresh");
return ESP_ERR_TIMEOUT;
}
if (partial_refresh_count_ < UINT32_MAX) {
partial_refresh_count_++;
}
if (partial_refresh_count_ >= PARTIAL_REFRESH_THRESHOLD) {
ESP_LOGI(TAG, "Partial refresh count %u reached threshold %u, next refresh will be full",
partial_refresh_count_, PARTIAL_REFRESH_THRESHOLD);
force_full_refresh_ = true;
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(black_data, false);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to clear display: %s", esp_err_to_name(err));
return err;
}
ESP_LOGI(TAG, "Display cleared to all white");
return ESP_OK;
}
// Request a full refresh on next flush
void EInkDisplayHandler::request_full_refresh(void) {
SemaphoreGuard guard(refresh_mutex_);
if (guard.take(pdMS_TO_TICKS(100))) {
force_full_refresh_ = true;
partial_refresh_count_ = 0;
ESP_LOGI(TAG, "Full refresh requested");
} else {
ESP_LOGE(TAG, "Failed to take refresh mutex to request full refresh");
}
}
// Check if display is busy (refreshing)
bool EInkDisplayHandler::is_busy(void) const {
return gpio_get_level(PIN_BUSY) == BUSY_ACTIVE_LEVEL; // BUSY is active LOW
}
void EInkDisplayHandler::wait_for_idle(void) const {
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;
}
while (gpio_get_level(PIN_BUSY) != BUSY_INACTIVE_LEVEL) {
vTaskDelay(pdMS_TO_TICKS(10));
}
ESP_LOGI(TAG, "Display is now ready (BUSY pin = 1)");
}
esp_err_t EInkDisplayHandler::init_devices(EventGroupHandle_t system_event_group) {
esp_err_t err;
err = init_display_pins_();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize display pins: %s", esp_err_to_name(err));
return err;
}
err = epd_init_();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize EPD: %s", esp_err_to_name(err));
return err;
}
err = init_touch_();
if (err != ESP_OK) {
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) {
// Indicate that display is ready
xEventGroupSetBits(system_event_group, DISPLAY_READY_BIT | TOUCH_CALIBRATED_BIT);
ESP_LOGI(TAG, "Display marked as ready");
}
return ESP_OK;
}
esp_err_t EInkDisplayHandler::init_display_pins_(void) {
ESP_LOGI(TAG, "Initializing E-Ink display handler...");
esp_err_t ret;
// 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;
ret = gpio_config(&io_conf);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to configure GPIO pins: %s", esp_err_to_name(ret));
return ret;
}
// 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;
io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
ret = gpio_config(&io_conf);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to configure BUSY pin: %s", esp_err_to_name(ret));
return ret;
}
// 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;
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 ret;
}
// Add SPI device
spi_device_interface_config_t devcfg = {};
devcfg.clock_speed_hz = 10 * 1000 * 1000; // 10 MHz
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 ret;
}
return ESP_OK;
}
// required to be called by inheriting class after SPI device is created
esp_err_t EInkDisplayHandler::epd_init_(void) {
ESP_LOGI(TAG, "Initializing EPD...");
esp_err_t err;
{
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;
}
// 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. Initialization Sequence
std::vector<uint8_t> panel_setting_data = { 0x1F };
err = epd_write_cmd_with_data(0x00, panel_setting_data, transaction_guard.transaction_id()); // Panel Setting
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));
std::vector<uint8_t> vcom_data = { 0x10, 0x07 };
err = epd_write_cmd_with_data(0x50, vcom_data, transaction_guard.transaction_id()); // VCOM
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send VCOM command: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS));
err = epd_write_cmd(0x04, transaction_guard.transaction_id()); // Power ON
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 power on
// Check BUSY pin with detailed logging
ESP_LOGI(TAG, "Waiting for EPD to be ready after power on...");
ESP_LOGI(TAG, "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(MINIMUM_PIN_SETUP_DELAY_MS));
busy_timeout++;
if (busy_timeout > 500) { // 5 second timeout
ESP_LOGE(TAG, "EPD power on timeout! BUSY pin stuck at 0");
return ESP_ERR_TIMEOUT;
}
if (busy_timeout % 50 == 0) { // Log every 500ms
ESP_LOGW(TAG, "Still waiting for EPD power on, timeout: %d/500", busy_timeout);
}
}
ESP_LOGI(TAG, "EPD power on complete after %d * 10ms, BUSY pin: %d", busy_timeout, gpio_get_level(PIN_BUSY));
std::vector<uint8_t> booster_data = { 0x27, 0x27, 0x18, 0x17 };
err = epd_write_cmd_with_data(0x06, booster_data, transaction_guard.transaction_id()); // Booster Soft Start
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send Booster Soft Start command: %s", esp_err_to_name(err));
return err;
}
vTaskDelay(pdMS_TO_TICKS(MINIMUM_PIN_SETUP_DELAY_MS));
// Enhanced display drive commands
std::vector<uint8_t> e0_data = { 0x02 };
err = epd_write_cmd_with_data(0xE0, e0_data, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send Enhanced Display Drive command: %s", esp_err_to_name(err));
return err;
}
std::vector<uint8_t> e5_data = { 0x5A };
err = epd_write_cmd_with_data(0xE5, e5_data, transaction_guard.transaction_id());
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to send Enhanced Display Drive command: %s", esp_err_to_name(err));
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...");
esp_err_t err;
// 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;
err = i2c_param_config(I2C_NUM_0, &conf);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to configure I2C parameters: %s", esp_err_to_name(err));
return err;
}
err = i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to install I2C driver: %s", esp_err_to_name(err));
return err;
}
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 = DISPLAY_WIDTH;
tp_cfg.y_max = DISPLAY_HEIGHT;
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
err = esp_lcd_touch_new_i2c_gt911(tp_io_handle_, &tp_cfg, &tp_handle_);
if (err == 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(err));
tp_handle_ = nullptr;
}
return err;
}
esp_err_t EInkDisplayHandler::epd_write_cmd(const uint8_t cmd, uint32_t transaction_id) {
ESP_LOGI(TAG, "epd_write_cmd: waiting to send 0x%02X", cmd);
SemaphoreGuard transaction_guard(spi_transaction_mutex_);
esp_err_t err =
wait_for_transaction_end_(pdMS_TO_TICKS(5000), transaction_id, transaction_guard);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to wait for previous transaction end before sending cmd 0x%02X: %s",
cmd, esp_err_to_name(err));
return err;
}
SemaphoreGuard guard(spi_mutex_);
if (!guard.take(pdMS_TO_TICKS(5000))) {
ESP_LOGE(TAG, "SPI mutex timeout for cmd 0x%02X", cmd);
return ESP_ERR_TIMEOUT;
}
err = dangerous_epd_write_cmd_without_lock_(cmd);
ESP_LOGI(TAG, "epd_write_cmd: 0x%02X done", cmd);
return err;
}
esp_err_t EInkDisplayHandler::epd_write_data(const uint8_t data, uint32_t transaction_id) {
ESP_LOGI(TAG, "epd_write_data: waiting to send 0x%02X", data);
SemaphoreGuard transaction_guard(spi_transaction_mutex_);
esp_err_t err =
wait_for_transaction_end_(pdMS_TO_TICKS(5000), transaction_id, transaction_guard);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to wait for previous transaction end before sending data 0x%02X: %s",
data, esp_err_to_name(err));
return err;
}
SemaphoreGuard guard(spi_mutex_);
if (!guard.take(pdMS_TO_TICKS(5000))) {
ESP_LOGE(TAG, "SPI mutex timeout for data 0x%02X", data);
return ESP_ERR_TIMEOUT;
}
err = dangerous_epd_write_data_without_lock_(data);
ESP_LOGI(TAG, "epd_write_data: 0x%02X done", data);
return err;
}
esp_err_t EInkDisplayHandler::epd_write_cmd_with_data(const uint8_t cmd, std::vector<uint8_t>& data, uint32_t transaction_id) {
const size_t data_len = data.size();
ESP_LOGI(TAG, "epd_write_cmd_with_data: waiting to send cmd 0x%02X with %u bytes of data", cmd, data_len);
SemaphoreGuard transaction_guard(spi_transaction_mutex_);
esp_err_t err =
wait_for_transaction_end_(pdMS_TO_TICKS(5000), transaction_id, transaction_guard);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to wait for previous transaction end before sending cmd 0x%02X: %s, with data",
cmd, esp_err_to_name(err));
return err;
}
SemaphoreGuard guard(spi_mutex_);
if (!guard.take(pdMS_TO_TICKS(5000))) {
ESP_LOGE(TAG, "SPI mutex timeout for cmd with data 0x%02X", cmd);
return ESP_ERR_TIMEOUT;
}
err = dangerous_epd_write_cmd_without_lock_(cmd);
if (err != ESP_OK) {
return err;
};
for (size_t i = 0; i < data_len; ++i) {
err = dangerous_epd_write_data_without_lock_(data[i]);
if (err != ESP_OK) {
return err;
}
}
ESP_LOGI(TAG, "epd_write_cmd_with_data: cmd 0x%02X with %u bytes of data done", cmd, data_len);
return ESP_OK;
}
esp_err_t EInkDisplayHandler::dangerous_epd_write_cmd_without_lock_(const uint8_t cmd) {
ESP_LOGI(TAG, "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(TAG, "Failed to send data 0x%02X", cmd);
} else {
ESP_LOGI(TAG, "dangerous_epd_write_cmd_without_lock_: 0x%02X sent", cmd);
}
return err;
}
esp_err_t EInkDisplayHandler::dangerous_epd_write_data_without_lock_(const uint8_t data) {
ESP_LOGI(TAG, "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(TAG, "Failed to send data 0x%02X", data);
} else {
ESP_LOGI(TAG, "dangerous_epd_write_data_without_lock_: 0x%02X sent", data);
}
return err;
}
esp_err_t EInkDisplayHandler::transfer_spi_data(const uint8_t* data, const size_t& length, uint32_t transaction_id) {
ESP_LOGI(TAG, "transfer_spi_data: waiting to send %zu bytes of data", length);
SemaphoreGuard transaction_guard(spi_transaction_mutex_);
esp_err_t err =
wait_for_transaction_end_(pdMS_TO_TICKS(5000), transaction_id, transaction_guard);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to wait for previous transaction end before sending data of %zu bytes: %s",
length, esp_err_to_name(err));
return err;
}
SemaphoreGuard guard(spi_mutex_);
if (!guard.take(pdMS_TO_TICKS(5000))) {
ESP_LOGE(TAG, "SPI mutex timeout for data transfer of %zu bytes", length);
return ESP_ERR_TIMEOUT;
}
ESP_LOGI(TAG, "transfer_spi_data: starting to send %zu bytes of data", length);
size_t offset = 0;
size_t remaining = length;
gpio_set_level(PIN_DC, 1); // Data mode
while (remaining > 0) {
size_t transfer_size = (remaining < DMA_TRANSFER_CHUNK_SIZE) ? remaining : DMA_TRANSFER_CHUNK_SIZE;
spi_transaction_t t = {};
t.length = transfer_size * 8; // Length in bits
t.tx_buffer = data + 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));
return ret;
}
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 sent, yielding...", offset, length);
vTaskDelay(pdMS_TO_TICKS(1));
}
}
ESP_LOGI(TAG, "transfer_spi_data: completed sending %zu bytes of data", length);
return ESP_OK;
}
esp_err_t EInkDisplayHandler::begin_transaction_(TickType_t timeout, uint32_t& out_id) {
ESP_LOGI(TAG, "begin_transaction_: waiting to obtain transaction mutex");
if (xSemaphoreTake(spi_transaction_mutex_, timeout) != pdTRUE) {
ESP_LOGE(TAG, "begin_transaction_: transaction mutex timeout");
return ESP_ERR_TIMEOUT;
}
out_id = ++spi_transaction_id;
ESP_LOGI(TAG, "begin_transaction_: transaction mutex obtained");
return ESP_OK;
}
esp_err_t EInkDisplayHandler::end_transaction_(void) {
ESP_LOGI(TAG, "end_transaction_: releasing transaction mutex");
if (xSemaphoreGive(spi_transaction_mutex_) != pdTRUE) {
ESP_LOGE(TAG, "end_transaction_: failed to release transaction mutex");
return ESP_FAIL;
}
ESP_LOGI(TAG, "end_transaction_: transaction mutex released");
return ESP_OK;
}
esp_err_t EInkDisplayHandler::wait_for_transaction_end_(TickType_t timeout, uint32_t awaiting_transaction_id, SemaphoreGuard& out_transaction_guard) {
// Validate transaction ID if provided
if (awaiting_transaction_id != 0 && awaiting_transaction_id != spi_transaction_id) {
// Invalid transaction ID
ESP_LOGE(TAG, "Invalid transaction ID 0x%08X while waiting, current transaction ID: 0x%08X",
awaiting_transaction_id, spi_transaction_id);
return ESP_ERR_INVALID_ARG;
}
SemaphoreGuard transaction_guard(spi_transaction_mutex_);
if (awaiting_transaction_id == 0) {
// wait for current transaction to complete
ESP_LOGV(TAG, "Waiting for current transaction 0x%08X to complete",
spi_transaction_id);
// take the mutex to ensure no transaction is active
if (!transaction_guard.take(timeout)) {
ESP_LOGE(TAG, "SPI transaction mutex timeout while waiting for transaction end");
return ESP_ERR_TIMEOUT;
}
}
// awaited_transaction_id is valid and matches current transaction ID or 0
out_transaction_guard = std::move(transaction_guard);
return ESP_OK;
}

661
main/display/eink_display_handler.cpp.old Normal file
View File

@@ -0,0 +1,661 @@
#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);
}

126
main/display/eink_display_handler.h Normal file
View File

@@ -0,0 +1,126 @@
#pragma once
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#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
#define DISPLAY_WIDTH 800
#define DISPLAY_HEIGHT 480
// forward declarations
class EInkDisplayHandler;
struct RefreshArea {
public:
RefreshArea(int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end)
: x1(x_start), y1(y_start), x2(x_end), y2(y_end) { }
int32_t x1;
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 {
public:
EInkDisplayHandler();
virtual ~EInkDisplayHandler();
esp_err_t init_devices(EventGroupHandle_t system_event_group = nullptr);
esp_err_t refresh_display(void);
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);
// Check if display is busy (refreshing)
bool is_busy(void) const;
void wait_for_idle(void) const;
esp_lcd_touch_handle_t get_touch_handle() const { return tp_handle_; }
protected:
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);
private:
esp_err_t init_display_pins_(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);
esp_err_t begin_transaction_(TickType_t timeout, uint32_t& out_id);
esp_err_t end_transaction_(void);
// given a transaction ID, wait for current transaction to complete. The transaction ID will determine if the wait is needed.
esp_err_t wait_for_transaction_end_(TickType_t timeout, uint32_t awaiting_transaction_id, SemaphoreGuard& out_transaction_guard);
friend class TransactionGuard;
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;
SemaphoreHandle_t refresh_mutex_ = nullptr;
uint32_t spi_transaction_id = 0; // For tracking SPI transactions
spi_device_handle_t spi_ = nullptr;
esp_lcd_panel_io_handle_t tp_io_handle_ = nullptr;
esp_lcd_touch_handle_t tp_handle_ = nullptr;
};
class TransactionGuard {
public:
TransactionGuard(EInkDisplayHandler& handler, TickType_t timeout = portMAX_DELAY)
: handler_(handler) { }
~TransactionGuard() { if (transaction_id_) handler_.end_transaction_(); }
esp_err_t begin(TickType_t timeout = portMAX_DELAY) {
esp_err_t err = handler_.begin_transaction_(timeout, transaction_id_);
return err;
}
uint32_t transaction_id() const { return transaction_id_; }
bool is_active() const { return transaction_id_ != 0; }
private:
// delete copy constructor and assignment operator
TransactionGuard(const TransactionGuard&) = delete;
TransactionGuard& operator=(const TransactionGuard&) = delete;
EInkDisplayHandler& handler_;
uint32_t transaction_id_ = 0;
};

66
main/display/eink_display_handler.h.old Normal file
View File

@@ -0,0 +1,66 @@
#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);
};

390
main/display/lvgl_handler.cpp Normal file
View File

@@ -0,0 +1,390 @@
#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 LV_DISPLAY_RENDER_MODE LV_DISPLAY_RENDER_MODE_PARTIAL
#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) {
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 || handler->framebuffer_ == nullptr) {
ESP_LOGE(TAG, "Invalid handler or framebuffer 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) {
// 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(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_->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);
// 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);
//
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;
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];
}
}
esp_err_t err = handler->display_handler_->partial_refresh(partial_buffer,
handler->refresh_area_);
delete[] partial_buffer;
if (err != ESP_OK) {
ESP_LOGE(TAG, "Partial refresh request failed: %s", esp_err_to_name(err));
}
handler->refresh_area_.reset();
}
}
//
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(5000))) {
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");
lvgl_port_unlock();
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");
lv_display_delete(lvgl_display_);
lvgl_display_ = nullptr;
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");
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);
//
// 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
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");
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;
}

40
main/display/lvgl_handler.h Normal file
View File

@@ -0,0 +1,40 @@
#pragma once
#include "lvgl.h"
#include "esp_lvgl_port.h"
#include "display/eink_display_handler.h"
#include "freertos/semphr.h"
#include "freertos/event_groups.h"
#include "esp_err.h"
#include <memory>
class LVGLHandler {
public:
LVGLHandler(
// an owning pointer to the display handler
// The display handler must outlive the LVGLHandler
// The display handler must be fully initialized before calling initLVGLDisplay
std::unique_ptr<EInkDisplayHandler> display_handler_in
);
~LVGLHandler();
esp_err_t initLVGL(EventGroupHandle_t system_event_group = nullptr);
private:
void rounder_cb_(lv_display_t* disp, lv_area_t* area);
void flush_cb_(lv_display_t* disp, const lv_area_t* area, uint8_t* px_map);
void touch_read_cb_(lv_indev_t* indev, lv_indev_data_t* data);
esp_err_t initLVGLDisplay_();
esp_err_t registerLVGLTouch_();
esp_err_t initLVGLPort_();
std::unique_ptr<EInkDisplayHandler> display_handler_ = nullptr;
lv_display_t* lvgl_display_ = nullptr;
lv_indev_t* lvgl_touch_indev_ = nullptr;
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;
};