254 lines
8.2 KiB
C
254 lines
8.2 KiB
C
/*#############################################################################
|
|
## Author: Shaun Reed ##
|
|
## Legal: All Content (c) 2025 Shaun Reed, all rights reserved ##
|
|
## ##
|
|
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com ##
|
|
##############################################################################
|
|
*/
|
|
#ifndef DISPLAY_H
|
|
#define DISPLAY_H
|
|
|
|
#include <lv_init.h>
|
|
#include <widgets/label/lv_label.h>
|
|
|
|
#include "i2c.h"
|
|
#include "panel_device.h"
|
|
|
|
#include <esp_lcd_panel_ops.h>
|
|
#include <esp_lcd_types.h>
|
|
|
|
struct LCD
|
|
{
|
|
esp_lcd_panel_handle_t esp_panel_;
|
|
|
|
esp_lcd_panel_io_handle_t esp_io_;
|
|
|
|
/// LVGL display handle.
|
|
lv_display_t* lv_display_;
|
|
|
|
lv_array_t lv_objs_;
|
|
|
|
struct IPanelDevice* device_;
|
|
};
|
|
|
|
/**
|
|
* Construct a new LCD using an object that implements IPanelDevice.
|
|
*
|
|
* @param device An object that implements the IPanelDevice interface.
|
|
*/
|
|
static struct LCD LCD_init(struct IPanelDevice* device)
|
|
{
|
|
struct LCD display;
|
|
ESP_LOGI(LCD_TAG, "Creating panel IO handle");
|
|
display.esp_io_ = NULL;
|
|
esp_lcd_panel_dev_config_t panel_config = {
|
|
.reset_gpio_num = (gpio_num_t)(-1),
|
|
.bits_per_pixel = 1,
|
|
.vendor_config = device->vendor_config_cb(),
|
|
};
|
|
esp_lcd_panel_io_i2c_config_t io_config = {
|
|
.dev_addr = I2C_HW_ADDR,
|
|
// User data to pass to the LVGL flush_ready callback.
|
|
// See IPanelDevice::lvgl_flush_ready_cb
|
|
.user_ctx = NULL,
|
|
.control_phase_bytes = 1,
|
|
.dc_bit_offset = 6,
|
|
.lcd_cmd_bits = LCD_CMD_BITS,
|
|
.lcd_param_bits = LCD_PARAM_BITS,
|
|
.scl_speed_hz = LCD_PIXEL_CLOCK_HZ,
|
|
};
|
|
ESP_ERROR_CHECK(
|
|
esp_lcd_new_panel_io_i2c(I2C_get(), &io_config, &display.esp_io_));
|
|
|
|
// If the passed handle is already allocated, delete it.
|
|
if (display.esp_panel_ != NULL)
|
|
{
|
|
ESP_LOGI(LCD_TAG, "Removing unused panel");
|
|
esp_lcd_panel_del(display.esp_panel_);
|
|
}
|
|
|
|
ESP_LOGI(LCD_TAG, "Installing vendor panel driver");
|
|
device->init_panel_cb(&panel_config, display.esp_io_, &display.esp_panel_);
|
|
|
|
ESP_LOGI(LCD_TAG, "Resetting panel display");
|
|
ESP_ERROR_CHECK(esp_lcd_panel_reset(display.esp_panel_));
|
|
ESP_LOGI(LCD_TAG, "Initializing panel display");
|
|
ESP_ERROR_CHECK(esp_lcd_panel_init(display.esp_panel_));
|
|
ESP_LOGI(LCD_TAG, "Turning on panel display");
|
|
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(display.esp_panel_, true));
|
|
|
|
if (!lv_is_initialized())
|
|
{
|
|
ESP_LOGI(LCD_TAG, "Initialize LVGL");
|
|
lv_init();
|
|
}
|
|
|
|
ESP_LOGI(LCD_TAG, "Creating LVGL display");
|
|
display.lv_display_ = lv_display_create(device->width_, device->height_);
|
|
assert(display.lv_display_);
|
|
|
|
// associate the i2c panel handle to the display
|
|
lv_display_set_user_data(display.lv_display_, display.esp_panel_);
|
|
|
|
device->register_rendering_data_cb(display.lv_display_, display.esp_io_,
|
|
device->lv_buf_, device->lv_buf_size_);
|
|
device->register_lvgl_tick_timer_cb();
|
|
ESP_LOGI(LCD_TAG, "Initializing LVGL array");
|
|
lv_array_init(&display.lv_objs_, 1, sizeof(lv_obj_t*));
|
|
return display;
|
|
}
|
|
|
|
/**
|
|
* Create a LVGL label with some given text on the current display.
|
|
* The name of the object can be reused to change text on this label later.
|
|
*
|
|
* @param display
|
|
* @param text Text to write to the display.
|
|
* @param long_mode LVGL long mode for text wider than the current display.
|
|
* @param align LVGL alignment to use for placing the label on the display.
|
|
* @return The index of the inserted label on the LVGL screen
|
|
*/
|
|
static uint32_t LCD_set_text_with_mode(struct LCD* display, const char* text,
|
|
lv_label_long_mode_t long_mode,
|
|
lv_align_t align)
|
|
{
|
|
// Lock the mutex due to the LVGL APIs are not thread-safe.
|
|
_lock_acquire(&lv_lock_);
|
|
|
|
ESP_LOGI(LCD_TAG, "Setting new text: %s", text);
|
|
lv_obj_t* scr = lv_display_get_screen_active(display->lv_display_);
|
|
|
|
lv_obj_t* new_object = lv_label_create(scr);
|
|
|
|
// Set text and long mode.
|
|
lv_label_set_long_mode(new_object, long_mode);
|
|
lv_label_set_text(new_object, text);
|
|
|
|
// Set the size of the screen.
|
|
// If you use rotation 90 or 270 use lv_display_get_vertical_resolution.
|
|
lv_obj_set_width(
|
|
new_object, lv_display_get_horizontal_resolution(display->lv_display_));
|
|
lv_obj_align(new_object, align, 0, 0);
|
|
|
|
uint32_t index = lv_array_size(&display->lv_objs_);
|
|
if (lv_array_push_back(&display->lv_objs_, &new_object) != LV_RESULT_OK)
|
|
{
|
|
ESP_LOGE(LCD_TAG, "Failed to add new object to array");
|
|
}
|
|
|
|
_lock_release(&lv_lock_);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Create a LVGL label with some given text on the current display.
|
|
* The name of the object can be reused to change text on this label later.
|
|
*
|
|
* @param display
|
|
* @param text Text to write to the display.
|
|
* @return The index of the inserted label on the LVGL screen
|
|
*/
|
|
static uint32_t LCD_set_text(struct LCD* display, const char* text)
|
|
{
|
|
return LCD_set_text_with_mode(display, text, LV_LABEL_LONG_SCROLL_CIRCULAR,
|
|
LV_ALIGN_TOP_MID);
|
|
}
|
|
|
|
static void LCD_set_text_at_with_mode(struct LCD* display, const char* text,
|
|
uint32_t i,
|
|
lv_label_long_mode_t long_mode,
|
|
lv_align_t align)
|
|
{
|
|
// Lock the mutex due to the LVGL APIs are not thread-safe.
|
|
_lock_acquire(&lv_lock_);
|
|
|
|
if (lv_array_is_empty(&display->lv_objs_))
|
|
{
|
|
ESP_LOGI(LCD_TAG, "Cannot set text at index %d; The array is empty.");
|
|
_lock_release(&lv_lock_);
|
|
return;
|
|
}
|
|
lv_obj_t** ptr = (lv_obj_t**)lv_array_at(&display->lv_objs_, i);
|
|
lv_obj_t* label = (lv_obj_t*)*ptr;
|
|
if (label == NULL)
|
|
{
|
|
ESP_LOGE(LCD_TAG, "Failed to set text at index %d; Label is null", i);
|
|
_lock_release(&lv_lock_);
|
|
return;
|
|
}
|
|
lv_label_set_text(label, text);
|
|
|
|
ESP_LOGI(LCD_TAG, "Setting text at index %d:", i);
|
|
// Set text and long mode.
|
|
lv_label_set_long_mode(label, long_mode);
|
|
lv_label_set_text(label, text);
|
|
|
|
// Set the size of the screen.
|
|
// If you use rotation 90 or 270 use lv_display_get_vertical_resolution.
|
|
lv_obj_set_width(
|
|
label, lv_display_get_horizontal_resolution(display->lv_display_));
|
|
lv_obj_align(label, align, 0, 0);
|
|
|
|
_lock_release(&lv_lock_);
|
|
}
|
|
|
|
static void LCD_set_text_at(struct LCD* display, const char* text, uint32_t i)
|
|
{
|
|
// Lock the mutex due to the LVGL APIs are not thread-safe.
|
|
_lock_acquire(&lv_lock_);
|
|
|
|
if (lv_array_is_empty(&display->lv_objs_))
|
|
{
|
|
ESP_LOGI(LCD_TAG, "Cannot set text at index %d; The array is empty.");
|
|
_lock_release(&lv_lock_);
|
|
return;
|
|
}
|
|
lv_obj_t** ptr = (lv_obj_t**)lv_array_at(&display->lv_objs_, i);
|
|
lv_obj_t* label = (lv_obj_t*)*ptr;
|
|
if (label == NULL)
|
|
{
|
|
ESP_LOGE(LCD_TAG, "Failed to set text at index %d; Label is null", i);
|
|
_lock_release(&lv_lock_);
|
|
return;
|
|
}
|
|
lv_label_set_text(label, text);
|
|
|
|
_lock_release(&lv_lock_);
|
|
}
|
|
|
|
|
|
static void LCD_clear(struct LCD* display)
|
|
{
|
|
_lock_acquire(&lv_lock_);
|
|
|
|
uint32_t size = lv_array_size(&display->lv_objs_);
|
|
ESP_LOGI(LCD_TAG, "Clearing %d LVGL objects", size);
|
|
for (uint32_t i = 0; i < size && size > 0; i++)
|
|
{
|
|
ESP_LOGI(LCD_TAG, "Checking array index %d", i);
|
|
lv_obj_t** ptr_to_delete =
|
|
(lv_obj_t**)lv_array_at(&display->lv_objs_, i);
|
|
lv_obj_t* to_delete = (lv_obj_t*)*ptr_to_delete;
|
|
if (to_delete == NULL)
|
|
{
|
|
ESP_LOGE(LCD_TAG, "Failed to clear all LVGL objects");
|
|
continue;
|
|
}
|
|
if (lv_obj_is_valid(to_delete))
|
|
{
|
|
ESP_LOGI(LCD_TAG, "Removing LVGL object");
|
|
lv_label_set_text(to_delete, "test");
|
|
lv_obj_delete(to_delete);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(LCD_TAG, "Error: LVGL object is not valid");
|
|
}
|
|
}
|
|
lv_array_clear(&display->lv_objs_);
|
|
|
|
_lock_release(&lv_lock_);
|
|
}
|
|
|
|
#endif // DISPLAY_H
|