383 lines
15 KiB
C
383 lines
15 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: CC0-1.0
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/semphr.h"
|
|
#include "esp_timer.h"
|
|
#include "esp_err.h"
|
|
#include "esp_log.h"
|
|
#include "esp_lcd_panel_io.h"
|
|
#include "esp_lcd_panel_vendor.h"
|
|
#include "esp_lcd_panel_ops.h"
|
|
#include "esp_spiffs.h"
|
|
#include "driver/gpio.h"
|
|
#include "lvgl.h"
|
|
|
|
static const char *TAG = "example";
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////// Please update the following configuration according to your LCD spec //////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#define EXAMPLE_LCD_PIXEL_CLOCK_HZ CONFIG_EXAMPLE_LCD_PIXEL_CLOCK_HZ
|
|
|
|
#define EXAMPLE_LCD_BK_LIGHT_ON_LEVEL 1
|
|
#define EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL !EXAMPLE_LCD_BK_LIGHT_ON_LEVEL
|
|
#define EXAMPLE_PIN_NUM_DATA0 6
|
|
#define EXAMPLE_PIN_NUM_DATA1 7
|
|
#define EXAMPLE_PIN_NUM_DATA2 8
|
|
#define EXAMPLE_PIN_NUM_DATA3 9
|
|
#define EXAMPLE_PIN_NUM_DATA4 10
|
|
#define EXAMPLE_PIN_NUM_DATA5 11
|
|
#define EXAMPLE_PIN_NUM_DATA6 12
|
|
#define EXAMPLE_PIN_NUM_DATA7 13
|
|
#if CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH > 8
|
|
#define EXAMPLE_PIN_NUM_DATA8 14
|
|
#define EXAMPLE_PIN_NUM_DATA9 15
|
|
#define EXAMPLE_PIN_NUM_DATA10 16
|
|
#define EXAMPLE_PIN_NUM_DATA11 17
|
|
#define EXAMPLE_PIN_NUM_DATA12 18
|
|
#define EXAMPLE_PIN_NUM_DATA13 19
|
|
#define EXAMPLE_PIN_NUM_DATA14 20
|
|
#define EXAMPLE_PIN_NUM_DATA15 21
|
|
#endif
|
|
#define EXAMPLE_PIN_NUM_PCLK 5
|
|
#define EXAMPLE_PIN_NUM_CS 3
|
|
#define EXAMPLE_PIN_NUM_DC 4
|
|
#define EXAMPLE_PIN_NUM_RST 2
|
|
#define EXAMPLE_PIN_NUM_BK_LIGHT 1
|
|
|
|
// The pixel number in horizontal and vertical
|
|
#define EXAMPLE_LCD_H_RES 240
|
|
#define EXAMPLE_LCD_V_RES 280
|
|
// Bit number used to represent command and parameter
|
|
#if CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ST7789
|
|
#define EXAMPLE_LCD_CMD_BITS 8
|
|
#define EXAMPLE_LCD_PARAM_BITS 8
|
|
#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_NT35510
|
|
#define EXAMPLE_LCD_CMD_BITS 16
|
|
#define EXAMPLE_LCD_PARAM_BITS 16
|
|
#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ILI9341
|
|
#define EXAMPLE_LCD_CMD_BITS 8
|
|
#define EXAMPLE_LCD_PARAM_BITS 8
|
|
#endif
|
|
|
|
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
|
|
#define EXAMPLE_LVGL_TASK_MAX_DELAY_MS 500
|
|
#define EXAMPLE_LVGL_TASK_MIN_DELAY_MS 1
|
|
#define EXAMPLE_LVGL_TASK_STACK_SIZE (4 * 1024)
|
|
#define EXAMPLE_LVGL_TASK_PRIORITY 2
|
|
|
|
#define EXAMPLE_DMA_BURST_SIZE 64 // 16, 32, 64. Higher burst size can improve the performance when the DMA buffer comes from PSRAM
|
|
|
|
static SemaphoreHandle_t lvgl_mux = NULL;
|
|
|
|
extern void example_lvgl_demo_ui(lv_disp_t *disp);
|
|
|
|
static bool example_notify_lvgl_flush_ready(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
|
|
{
|
|
lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;
|
|
lv_disp_flush_ready(disp_driver);
|
|
return false;
|
|
}
|
|
|
|
static void example_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
|
|
{
|
|
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t) drv->user_data;
|
|
int offsetx1 = area->x1;
|
|
int offsetx2 = area->x2;
|
|
int offsety1 = area->y1;
|
|
int offsety2 = area->y2;
|
|
// copy a buffer's content to a specific area of the display
|
|
esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map);
|
|
}
|
|
|
|
static void example_increase_lvgl_tick(void *arg)
|
|
{
|
|
/* Tell LVGL how many milliseconds has elapsed */
|
|
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
|
|
}
|
|
|
|
bool example_lvgl_lock(int timeout_ms)
|
|
{
|
|
// Convert timeout in milliseconds to FreeRTOS ticks
|
|
// If `timeout_ms` is set to -1, the program will block until the condition is met
|
|
const TickType_t timeout_ticks = (timeout_ms == -1) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms);
|
|
return xSemaphoreTakeRecursive(lvgl_mux, timeout_ticks) == pdTRUE;
|
|
}
|
|
|
|
void example_lvgl_unlock(void)
|
|
{
|
|
xSemaphoreGiveRecursive(lvgl_mux);
|
|
}
|
|
|
|
static void example_lvgl_port_task(void *arg)
|
|
{
|
|
ESP_LOGI(TAG, "Starting LVGL task");
|
|
uint32_t task_delay_ms = EXAMPLE_LVGL_TASK_MAX_DELAY_MS;
|
|
while (1) {
|
|
// Lock the mutex due to the LVGL APIs are not thread-safe
|
|
if (example_lvgl_lock(-1)) {
|
|
task_delay_ms = lv_timer_handler();
|
|
// Release the mutex
|
|
example_lvgl_unlock();
|
|
}
|
|
if (task_delay_ms > EXAMPLE_LVGL_TASK_MAX_DELAY_MS) {
|
|
task_delay_ms = EXAMPLE_LVGL_TASK_MAX_DELAY_MS;
|
|
} else if (task_delay_ms < EXAMPLE_LVGL_TASK_MIN_DELAY_MS) {
|
|
task_delay_ms = EXAMPLE_LVGL_TASK_MIN_DELAY_MS;
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(task_delay_ms));
|
|
}
|
|
}
|
|
|
|
#if CONFIG_EXAMPLE_LCD_IMAGE_FROM_FILE_SYSTEM
|
|
void example_init_filesystem(void)
|
|
{
|
|
ESP_LOGI(TAG, "Initializing filesystem");
|
|
esp_vfs_spiffs_conf_t conf = {
|
|
.base_path = "/spiffs",
|
|
.partition_label = "storage",
|
|
.max_files = 5,
|
|
.format_if_mount_failed = true
|
|
};
|
|
|
|
// Use settings defined above to initialize and mount SPIFFS filesystem.
|
|
// Note: esp_vfs_spiffs_register is an all-in-one convenience function.
|
|
esp_err_t ret = esp_vfs_spiffs_register(&conf);
|
|
|
|
if (ret != ESP_OK) {
|
|
if (ret == ESP_FAIL) {
|
|
ESP_LOGE(TAG, "Failed to mount or format filesystem");
|
|
} else if (ret == ESP_ERR_NOT_FOUND) {
|
|
ESP_LOGE(TAG, "Failed to find SPIFFS partition");
|
|
} else {
|
|
ESP_LOGE(TAG, "Failed to initialize SPIFFS (%s)", esp_err_to_name(ret));
|
|
}
|
|
return;
|
|
}
|
|
|
|
size_t total = 0, used = 0;
|
|
ret = esp_spiffs_info(conf.partition_label, &total, &used);
|
|
if (ret != ESP_OK) {
|
|
ESP_LOGE(TAG, "Failed to get SPIFFS partition information (%s). Formatting...", esp_err_to_name(ret));
|
|
esp_spiffs_format(conf.partition_label);
|
|
return;
|
|
} else {
|
|
ESP_LOGI(TAG, "Partition size: total: %zu, used: %zu", total, used);
|
|
}
|
|
}
|
|
#endif // CONFIG_EXAMPLE_LCD_IMAGE_FROM_FILE_SYSTEM
|
|
|
|
void example_init_i80_bus(esp_lcd_panel_io_handle_t *io_handle, void *user_ctx)
|
|
{
|
|
ESP_LOGI(TAG, "Initialize Intel 8080 bus");
|
|
esp_lcd_i80_bus_handle_t i80_bus = NULL;
|
|
esp_lcd_i80_bus_config_t bus_config = {
|
|
.clk_src = LCD_CLK_SRC_DEFAULT,
|
|
.dc_gpio_num = EXAMPLE_PIN_NUM_DC,
|
|
.wr_gpio_num = EXAMPLE_PIN_NUM_PCLK,
|
|
.data_gpio_nums = {
|
|
EXAMPLE_PIN_NUM_DATA0,
|
|
EXAMPLE_PIN_NUM_DATA1,
|
|
EXAMPLE_PIN_NUM_DATA2,
|
|
EXAMPLE_PIN_NUM_DATA3,
|
|
EXAMPLE_PIN_NUM_DATA4,
|
|
EXAMPLE_PIN_NUM_DATA5,
|
|
EXAMPLE_PIN_NUM_DATA6,
|
|
EXAMPLE_PIN_NUM_DATA7,
|
|
#if CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH > 8
|
|
EXAMPLE_PIN_NUM_DATA8,
|
|
EXAMPLE_PIN_NUM_DATA9,
|
|
EXAMPLE_PIN_NUM_DATA10,
|
|
EXAMPLE_PIN_NUM_DATA11,
|
|
EXAMPLE_PIN_NUM_DATA12,
|
|
EXAMPLE_PIN_NUM_DATA13,
|
|
EXAMPLE_PIN_NUM_DATA14,
|
|
EXAMPLE_PIN_NUM_DATA15,
|
|
#endif
|
|
},
|
|
.bus_width = CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH,
|
|
.max_transfer_bytes = EXAMPLE_LCD_H_RES * 100 * sizeof(uint16_t),
|
|
.dma_burst_size = EXAMPLE_DMA_BURST_SIZE,
|
|
};
|
|
ESP_ERROR_CHECK(esp_lcd_new_i80_bus(&bus_config, &i80_bus));
|
|
|
|
esp_lcd_panel_io_i80_config_t io_config = {
|
|
.cs_gpio_num = EXAMPLE_PIN_NUM_CS,
|
|
.pclk_hz = EXAMPLE_LCD_PIXEL_CLOCK_HZ,
|
|
.trans_queue_depth = 10,
|
|
.dc_levels = {
|
|
.dc_idle_level = 0,
|
|
.dc_cmd_level = 0,
|
|
.dc_dummy_level = 0,
|
|
.dc_data_level = 1,
|
|
},
|
|
.flags = {
|
|
.swap_color_bytes = !LV_COLOR_16_SWAP, // Swap can be done in LvGL (default) or DMA
|
|
},
|
|
.on_color_trans_done = example_notify_lvgl_flush_ready,
|
|
.user_ctx = user_ctx,
|
|
.lcd_cmd_bits = EXAMPLE_LCD_CMD_BITS,
|
|
.lcd_param_bits = EXAMPLE_LCD_PARAM_BITS,
|
|
};
|
|
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i80(i80_bus, &io_config, io_handle));
|
|
}
|
|
|
|
void example_init_lcd_panel(esp_lcd_panel_io_handle_t io_handle, esp_lcd_panel_handle_t *panel)
|
|
{
|
|
esp_lcd_panel_handle_t panel_handle = NULL;
|
|
#if CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ST7789
|
|
ESP_LOGI(TAG, "Install LCD driver of st7789");
|
|
esp_lcd_panel_dev_config_t panel_config = {
|
|
.reset_gpio_num = EXAMPLE_PIN_NUM_RST,
|
|
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
|
|
.bits_per_pixel = 16,
|
|
};
|
|
ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(io_handle, &panel_config, &panel_handle));
|
|
|
|
esp_lcd_panel_reset(panel_handle);
|
|
esp_lcd_panel_init(panel_handle);
|
|
// Set inversion, x/y coordinate order, x/y mirror according to your LCD module spec
|
|
// the gap is LCD panel specific, even panels with the same driver IC, can have different gap value
|
|
esp_lcd_panel_invert_color(panel_handle, true);
|
|
esp_lcd_panel_set_gap(panel_handle, 0, 20);
|
|
#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_NT35510
|
|
ESP_LOGI(TAG, "Install LCD driver of nt35510");
|
|
esp_lcd_panel_dev_config_t panel_config = {
|
|
.reset_gpio_num = EXAMPLE_PIN_NUM_RST,
|
|
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_BGR,
|
|
.bits_per_pixel = 16,
|
|
};
|
|
ESP_ERROR_CHECK(esp_lcd_new_panel_nt35510(io_handle, &panel_config, &panel_handle));
|
|
|
|
esp_lcd_panel_reset(panel_handle);
|
|
esp_lcd_panel_init(panel_handle);
|
|
// Set inversion, x/y coordinate order, x/y mirror according to your LCD module spec
|
|
// the gap is LCD panel specific, even panels with the same driver IC, can have different gap value
|
|
esp_lcd_panel_swap_xy(panel_handle, true);
|
|
esp_lcd_panel_mirror(panel_handle, true, false);
|
|
#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ILI9341
|
|
// ILI9341 is NOT a distinct driver, but a special case of ST7789
|
|
// (essential registers are identical). A few lines further down in this code,
|
|
// it's shown how to issue additional device-specific commands.
|
|
ESP_LOGI(TAG, "Install LCD driver of ili9341 (st7789 compatible)");
|
|
esp_lcd_panel_dev_config_t panel_config = {
|
|
.reset_gpio_num = EXAMPLE_PIN_NUM_RST,
|
|
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_BGR,
|
|
.bits_per_pixel = 16,
|
|
};
|
|
ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(io_handle, &panel_config, &panel_handle));
|
|
|
|
esp_lcd_panel_reset(panel_handle);
|
|
esp_lcd_panel_init(panel_handle);
|
|
// Set inversion, x/y coordinate order, x/y mirror according to your LCD module spec
|
|
// the gap is LCD panel specific, even panels with the same driver IC, can have different gap value
|
|
esp_lcd_panel_swap_xy(panel_handle, true);
|
|
esp_lcd_panel_invert_color(panel_handle, false);
|
|
// ILI9341 is very similar to ST7789 and shares the same driver.
|
|
// Anything unconventional (such as this custom gamma table) can
|
|
// be issued here in user code and need not modify the driver.
|
|
esp_lcd_panel_io_tx_param(io_handle, 0xF2, (uint8_t[]) {
|
|
0
|
|
}, 1); // 3Gamma function disable
|
|
esp_lcd_panel_io_tx_param(io_handle, 0x26, (uint8_t[]) {
|
|
1
|
|
}, 1); // Gamma curve 1 selected
|
|
esp_lcd_panel_io_tx_param(io_handle, 0xE0, (uint8_t[]) { // Set positive gamma
|
|
0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00
|
|
}, 15);
|
|
esp_lcd_panel_io_tx_param(io_handle, 0xE1, (uint8_t[]) { // Set negative gamma
|
|
0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F
|
|
}, 15);
|
|
#endif
|
|
*panel = panel_handle;
|
|
}
|
|
|
|
void app_main(void)
|
|
{
|
|
static lv_disp_draw_buf_t disp_buf; // contains internal graphic buffer(s) called draw buffer(s)
|
|
static lv_disp_drv_t disp_drv; // contains callback functions
|
|
|
|
#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0
|
|
ESP_LOGI(TAG, "Turn off LCD backlight");
|
|
gpio_config_t bk_gpio_config = {
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
.pin_bit_mask = 1ULL << EXAMPLE_PIN_NUM_BK_LIGHT
|
|
};
|
|
ESP_ERROR_CHECK(gpio_config(&bk_gpio_config));
|
|
gpio_set_level(EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL);
|
|
#endif // EXAMPLE_PIN_NUM_BK_LIGHT >= 0
|
|
|
|
#if CONFIG_EXAMPLE_LCD_IMAGE_FROM_FILE_SYSTEM
|
|
example_init_filesystem();
|
|
#endif // CONFIG_EXAMPLE_LCD_IMAGE_FROM_FILE_SYSTEM
|
|
|
|
esp_lcd_panel_io_handle_t io_handle = NULL;
|
|
example_init_i80_bus(&io_handle, &disp_drv);
|
|
|
|
esp_lcd_panel_handle_t panel_handle = NULL;
|
|
example_init_lcd_panel(io_handle, &panel_handle);
|
|
|
|
// Stub: user can flush pre-defined pattern to the screen before we turn on the screen or backlight
|
|
|
|
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));
|
|
|
|
#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0
|
|
ESP_LOGI(TAG, "Turn on LCD backlight");
|
|
gpio_set_level(EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_ON_LEVEL);
|
|
#endif // EXAMPLE_PIN_NUM_BK_LIGHT >= 0
|
|
|
|
ESP_LOGI(TAG, "Initialize LVGL library");
|
|
lv_init();
|
|
// alloc draw buffers used by LVGL
|
|
// it's recommended to choose the size of the draw buffer(s) to be at least 1/10 screen sized
|
|
uint32_t draw_buf_alloc_caps = 0;
|
|
#if CONFIG_EXAMPLE_LCD_I80_COLOR_IN_PSRAM
|
|
draw_buf_alloc_caps |= MALLOC_CAP_SPIRAM;
|
|
#endif
|
|
lv_color_t *buf1 = esp_lcd_i80_alloc_draw_buffer(io_handle, EXAMPLE_LCD_H_RES * 100 * sizeof(lv_color_t), draw_buf_alloc_caps);
|
|
lv_color_t *buf2 = esp_lcd_i80_alloc_draw_buffer(io_handle, EXAMPLE_LCD_H_RES * 100 * sizeof(lv_color_t), draw_buf_alloc_caps);
|
|
assert(buf1);
|
|
assert(buf2);
|
|
ESP_LOGI(TAG, "buf1@%p, buf2@%p", buf1, buf2);
|
|
// initialize LVGL draw buffers
|
|
lv_disp_draw_buf_init(&disp_buf, buf1, buf2, EXAMPLE_LCD_H_RES * 100);
|
|
|
|
ESP_LOGI(TAG, "Register display driver to LVGL");
|
|
lv_disp_drv_init(&disp_drv);
|
|
disp_drv.hor_res = EXAMPLE_LCD_H_RES;
|
|
disp_drv.ver_res = EXAMPLE_LCD_V_RES;
|
|
disp_drv.flush_cb = example_lvgl_flush_cb;
|
|
disp_drv.draw_buf = &disp_buf;
|
|
disp_drv.user_data = panel_handle;
|
|
lv_disp_t *disp = lv_disp_drv_register(&disp_drv);
|
|
|
|
ESP_LOGI(TAG, "Install LVGL tick timer");
|
|
// Tick interface for LVGL (using esp_timer to generate 2ms periodic event)
|
|
const esp_timer_create_args_t lvgl_tick_timer_args = {
|
|
.callback = &example_increase_lvgl_tick,
|
|
.name = "lvgl_tick"
|
|
};
|
|
esp_timer_handle_t lvgl_tick_timer = NULL;
|
|
ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));
|
|
ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000));
|
|
|
|
lvgl_mux = xSemaphoreCreateRecursiveMutex();
|
|
assert(lvgl_mux);
|
|
ESP_LOGI(TAG, "Create LVGL task");
|
|
xTaskCreate(example_lvgl_port_task, "LVGL", EXAMPLE_LVGL_TASK_STACK_SIZE, NULL, EXAMPLE_LVGL_TASK_PRIORITY, NULL);
|
|
|
|
ESP_LOGI(TAG, "Display LVGL animation");
|
|
// Lock the mutex due to the LVGL APIs are not thread-safe
|
|
if (example_lvgl_lock(-1)) {
|
|
example_lvgl_demo_ui(disp);
|
|
// Release the mutex
|
|
example_lvgl_unlock();
|
|
}
|
|
}
|