Introduced the 05_LVGL_WITH_RAM example project for ESP32 targets, including support for QSPI LCD panels (SPD1020, GC9B71, SH8601) and touch controllers. Added SH8601 LCD driver component, related documentation, initialization code, and test applications. Updated .gitignore to allow tracking of the new example directory.
408 lines
15 KiB
C
408 lines
15 KiB
C
#include <stdio.h>
|
|
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "driver/gpio.h"
|
|
#include "driver/i2c.h"
|
|
#include "driver/spi_master.h"
|
|
#include "esp_timer.h"
|
|
#include "esp_lcd_panel_io.h"
|
|
#include "esp_lcd_panel_vendor.h"
|
|
#include "esp_lcd_panel_ops.h"
|
|
#include "esp_err.h"
|
|
#include "esp_log.h"
|
|
|
|
#include "lvgl.h"
|
|
#include "lv_demos.h"
|
|
#include "esp_lcd_sh8601.h"
|
|
#include "esp_lcd_touch_ft5x06.h"
|
|
|
|
#include "esp_io_expander_tca9554.h"
|
|
|
|
static const char *TAG = "example";
|
|
static SemaphoreHandle_t lvgl_mux = NULL;
|
|
|
|
#define LCD_HOST SPI2_HOST
|
|
#define TOUCH_HOST I2C_NUM_0
|
|
|
|
#if CONFIG_LV_COLOR_DEPTH == 32
|
|
#define LCD_BIT_PER_PIXEL (24)
|
|
#elif CONFIG_LV_COLOR_DEPTH == 16
|
|
#define LCD_BIT_PER_PIXEL (16)
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////// Please update the following configuration according to your LCD spec //////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#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_LCD_CS (GPIO_NUM_12)
|
|
#define EXAMPLE_PIN_NUM_LCD_PCLK (GPIO_NUM_11)
|
|
#define EXAMPLE_PIN_NUM_LCD_DATA0 (GPIO_NUM_4)
|
|
#define EXAMPLE_PIN_NUM_LCD_DATA1 (GPIO_NUM_5)
|
|
#define EXAMPLE_PIN_NUM_LCD_DATA2 (GPIO_NUM_6)
|
|
#define EXAMPLE_PIN_NUM_LCD_DATA3 (GPIO_NUM_7)
|
|
#define EXAMPLE_PIN_NUM_LCD_RST (-1)
|
|
#define EXAMPLE_PIN_NUM_BK_LIGHT (-1)
|
|
|
|
// The pixel number in horizontal and vertical
|
|
#define EXAMPLE_LCD_H_RES 368
|
|
#define EXAMPLE_LCD_V_RES 448
|
|
|
|
#define EXAMPLE_USE_TOUCH 1
|
|
|
|
#if EXAMPLE_USE_TOUCH
|
|
#define EXAMPLE_PIN_NUM_TOUCH_SCL (GPIO_NUM_14)
|
|
#define EXAMPLE_PIN_NUM_TOUCH_SDA (GPIO_NUM_15)
|
|
#define EXAMPLE_PIN_NUM_TOUCH_RST (-1)
|
|
#define EXAMPLE_PIN_NUM_TOUCH_INT (GPIO_NUM_21)
|
|
|
|
esp_lcd_touch_handle_t tp = NULL;
|
|
#endif
|
|
|
|
#define EXAMPLE_LVGL_BUF_HEIGHT (EXAMPLE_LCD_V_RES / 4)
|
|
#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
|
|
|
|
static const sh8601_lcd_init_cmd_t lcd_init_cmds[] = {
|
|
{0x11, (uint8_t[]){0x00}, 0, 120},
|
|
{0x44, (uint8_t[]){0x01, 0xD1}, 2, 0},
|
|
{0x35, (uint8_t[]){0x00}, 1, 0},
|
|
{0x53, (uint8_t[]){0x20}, 1, 10},
|
|
{0x2A, (uint8_t[]){0x00, 0x00, 0x01, 0x6F}, 4, 0},
|
|
{0x2B, (uint8_t[]){0x00, 0x00, 0x01, 0xBF}, 4, 0},
|
|
{0x51, (uint8_t[]){0x00}, 1, 10},
|
|
{0x29, (uint8_t[]){0x00}, 0, 10},
|
|
{0x51, (uint8_t[]){0xFF}, 1, 0},
|
|
};
|
|
|
|
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;
|
|
const int offsetx1 = area->x1;
|
|
const int offsetx2 = area->x2;
|
|
const int offsety1 = area->y1;
|
|
const int offsety2 = area->y2;
|
|
|
|
#if LCD_BIT_PER_PIXEL == 24
|
|
uint8_t *to = (uint8_t *)color_map;
|
|
uint8_t temp = 0;
|
|
uint16_t pixel_num = (offsetx2 - offsetx1 + 1) * (offsety2 - offsety1 + 1);
|
|
|
|
// Special dealing for first pixel
|
|
temp = color_map[0].ch.blue;
|
|
*to++ = color_map[0].ch.red;
|
|
*to++ = color_map[0].ch.green;
|
|
*to++ = temp;
|
|
// Normal dealing for other pixels
|
|
for (int i = 1; i < pixel_num; i++)
|
|
{
|
|
*to++ = color_map[i].ch.red;
|
|
*to++ = color_map[i].ch.green;
|
|
*to++ = color_map[i].ch.blue;
|
|
}
|
|
#endif
|
|
|
|
// 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);
|
|
}
|
|
|
|
/* Rotate display and touch, when rotated screen in LVGL. Called when driver parameters are updated. */
|
|
static void example_lvgl_update_cb(lv_disp_drv_t *drv)
|
|
{
|
|
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
|
|
|
|
switch (drv->rotated)
|
|
{
|
|
case LV_DISP_ROT_NONE:
|
|
// Rotate LCD display
|
|
esp_lcd_panel_swap_xy(panel_handle, false);
|
|
esp_lcd_panel_mirror(panel_handle, true, false);
|
|
break;
|
|
case LV_DISP_ROT_90:
|
|
// Rotate LCD display
|
|
esp_lcd_panel_swap_xy(panel_handle, true);
|
|
esp_lcd_panel_mirror(panel_handle, true, true);
|
|
break;
|
|
case LV_DISP_ROT_180:
|
|
// Rotate LCD display
|
|
esp_lcd_panel_swap_xy(panel_handle, false);
|
|
esp_lcd_panel_mirror(panel_handle, false, true);
|
|
break;
|
|
case LV_DISP_ROT_270:
|
|
// Rotate LCD display
|
|
esp_lcd_panel_swap_xy(panel_handle, true);
|
|
esp_lcd_panel_mirror(panel_handle, false, false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void example_lvgl_rounder_cb(struct _lv_disp_drv_t *disp_drv, lv_area_t *area)
|
|
{
|
|
uint16_t x1 = area->x1;
|
|
uint16_t x2 = area->x2;
|
|
|
|
uint16_t y1 = area->y1;
|
|
uint16_t y2 = area->y2;
|
|
|
|
// round the start of coordinate down to the nearest 2M number
|
|
area->x1 = (x1 >> 1) << 1;
|
|
area->y1 = (y1 >> 1) << 1;
|
|
// round the end of coordinate up to the nearest 2N+1 number
|
|
area->x2 = ((x2 >> 1) << 1) + 1;
|
|
area->y2 = ((y2 >> 1) << 1) + 1;
|
|
}
|
|
|
|
#if EXAMPLE_USE_TOUCH
|
|
static void example_lvgl_touch_cb(lv_indev_drv_t *drv, lv_indev_data_t *data)
|
|
{
|
|
esp_lcd_touch_handle_t tp = (esp_lcd_touch_handle_t)drv->user_data;
|
|
assert(tp);
|
|
|
|
uint16_t tp_x;
|
|
uint16_t tp_y;
|
|
uint8_t tp_cnt = 0;
|
|
/* Read data from touch controller into memory */
|
|
esp_lcd_touch_read_data(tp);
|
|
/* Read data from touch controller */
|
|
bool tp_pressed = esp_lcd_touch_get_coordinates(tp, &tp_x, &tp_y, NULL, &tp_cnt, 1);
|
|
if (tp_pressed && tp_cnt > 0)
|
|
{
|
|
data->point.x = tp_x;
|
|
data->point.y = tp_y;
|
|
data->state = LV_INDEV_STATE_PRESSED;
|
|
ESP_LOGD(TAG, "Touch position: %d,%d", tp_x, tp_y);
|
|
}
|
|
else
|
|
{
|
|
data->state = LV_INDEV_STATE_RELEASED;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void example_increase_lvgl_tick(void *arg)
|
|
{
|
|
/* Tell LVGL how many milliseconds has elapsed */
|
|
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
|
|
}
|
|
|
|
static bool example_lvgl_lock(int timeout_ms)
|
|
{
|
|
assert(lvgl_mux && "bsp_display_start must be called first");
|
|
|
|
const TickType_t timeout_ticks = (timeout_ms == -1) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms);
|
|
return xSemaphoreTake(lvgl_mux, timeout_ticks) == pdTRUE;
|
|
}
|
|
|
|
static void example_lvgl_unlock(void)
|
|
{
|
|
assert(lvgl_mux && "bsp_display_start must be called first");
|
|
xSemaphoreGive(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));
|
|
}
|
|
}
|
|
|
|
void app_main(void)
|
|
{
|
|
esp_log_level_set("lcd_panel.io.i2c", ESP_LOG_NONE);
|
|
esp_log_level_set("FT5x06", ESP_LOG_NONE);
|
|
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
|
|
|
|
ESP_LOGI(TAG, "Initialize I2C bus");
|
|
const i2c_config_t i2c_conf = {
|
|
.mode = I2C_MODE_MASTER,
|
|
.sda_io_num = EXAMPLE_PIN_NUM_TOUCH_SDA,
|
|
.sda_pullup_en = GPIO_PULLUP_ENABLE,
|
|
.scl_io_num = EXAMPLE_PIN_NUM_TOUCH_SCL,
|
|
.scl_pullup_en = GPIO_PULLUP_ENABLE,
|
|
.master.clk_speed = 200 * 1000,
|
|
};
|
|
ESP_ERROR_CHECK(i2c_param_config(TOUCH_HOST, &i2c_conf));
|
|
ESP_ERROR_CHECK(i2c_driver_install(TOUCH_HOST, i2c_conf.mode, 0, 0, 0));
|
|
|
|
esp_io_expander_handle_t io_expander = NULL;
|
|
esp_io_expander_new_i2c_tca9554(TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander);
|
|
|
|
ESP_ERROR_CHECK(esp_io_expander_new_i2c_tca9554(TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander));
|
|
|
|
esp_io_expander_set_dir(io_expander, IO_EXPANDER_PIN_NUM_0 | IO_EXPANDER_PIN_NUM_1 | IO_EXPANDER_PIN_NUM_2, IO_EXPANDER_OUTPUT);
|
|
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 0);
|
|
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 0);
|
|
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 0);
|
|
vTaskDelay(pdMS_TO_TICKS(200));
|
|
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 1);
|
|
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 1);
|
|
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 1);
|
|
|
|
#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));
|
|
#endif
|
|
|
|
ESP_LOGI(TAG, "Initialize SPI bus");
|
|
const spi_bus_config_t buscfg = SH8601_PANEL_BUS_QSPI_CONFIG(EXAMPLE_PIN_NUM_LCD_PCLK,
|
|
EXAMPLE_PIN_NUM_LCD_DATA0,
|
|
EXAMPLE_PIN_NUM_LCD_DATA1,
|
|
EXAMPLE_PIN_NUM_LCD_DATA2,
|
|
EXAMPLE_PIN_NUM_LCD_DATA3,
|
|
EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES * LCD_BIT_PER_PIXEL / 8);
|
|
ESP_ERROR_CHECK(spi_bus_initialize(LCD_HOST, &buscfg, SPI_DMA_CH_AUTO));
|
|
|
|
ESP_LOGI(TAG, "Install panel IO");
|
|
esp_lcd_panel_io_handle_t io_handle = NULL;
|
|
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG(EXAMPLE_PIN_NUM_LCD_CS,
|
|
example_notify_lvgl_flush_ready,
|
|
&disp_drv);
|
|
sh8601_vendor_config_t vendor_config = {
|
|
.init_cmds = lcd_init_cmds,
|
|
.init_cmds_size = sizeof(lcd_init_cmds) / sizeof(lcd_init_cmds[0]),
|
|
.flags = {
|
|
.use_qspi_interface = 1,
|
|
},
|
|
};
|
|
// Attach the LCD to the SPI bus
|
|
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST, &io_config, &io_handle));
|
|
|
|
esp_lcd_panel_handle_t panel_handle = NULL;
|
|
const esp_lcd_panel_dev_config_t panel_config = {
|
|
.reset_gpio_num = EXAMPLE_PIN_NUM_LCD_RST,
|
|
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
|
|
.bits_per_pixel = LCD_BIT_PER_PIXEL,
|
|
.vendor_config = &vendor_config,
|
|
};
|
|
ESP_LOGI(TAG, "Install SH8601 panel driver");
|
|
ESP_ERROR_CHECK(esp_lcd_new_panel_sh8601(io_handle, &panel_config, &panel_handle));
|
|
ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
|
|
ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
|
|
// 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_USE_TOUCH
|
|
|
|
esp_lcd_panel_io_handle_t tp_io_handle = NULL;
|
|
const esp_lcd_panel_io_i2c_config_t tp_io_config = ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG();
|
|
// Attach the TOUCH to the I2C bus
|
|
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)TOUCH_HOST, &tp_io_config, &tp_io_handle));
|
|
|
|
const esp_lcd_touch_config_t tp_cfg = {
|
|
.x_max = EXAMPLE_LCD_H_RES,
|
|
.y_max = EXAMPLE_LCD_V_RES,
|
|
.rst_gpio_num = EXAMPLE_PIN_NUM_TOUCH_RST,
|
|
.int_gpio_num = EXAMPLE_PIN_NUM_TOUCH_INT,
|
|
.levels = {
|
|
.reset = 0,
|
|
.interrupt = 0,
|
|
},
|
|
.flags = {
|
|
.swap_xy = 0,
|
|
.mirror_x = 0,
|
|
.mirror_y = 0,
|
|
},
|
|
};
|
|
|
|
ESP_LOGI(TAG, "Initialize touch controller");
|
|
ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_ft5x06(tp_io_handle, &tp_cfg, &tp));
|
|
|
|
#endif
|
|
|
|
#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
|
|
|
|
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
|
|
lv_color_t *buf1 = heap_caps_malloc(EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
|
|
assert(buf1);
|
|
lv_color_t *buf2 = heap_caps_malloc(EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
|
|
assert(buf2);
|
|
// initialize LVGL draw buffers
|
|
lv_disp_draw_buf_init(&disp_buf, buf1, buf2, EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT);
|
|
|
|
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.rounder_cb = example_lvgl_rounder_cb;
|
|
disp_drv.drv_update_cb = example_lvgl_update_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));
|
|
|
|
#if EXAMPLE_USE_TOUCH
|
|
static lv_indev_drv_t indev_drv; // Input device driver (Touch)
|
|
lv_indev_drv_init(&indev_drv);
|
|
indev_drv.type = LV_INDEV_TYPE_POINTER;
|
|
indev_drv.disp = disp;
|
|
indev_drv.read_cb = example_lvgl_touch_cb;
|
|
indev_drv.user_data = tp;
|
|
lv_indev_drv_register(&indev_drv);
|
|
#endif
|
|
|
|
lvgl_mux = xSemaphoreCreateMutex();
|
|
assert(lvgl_mux);
|
|
xTaskCreate(example_lvgl_port_task, "LVGL", EXAMPLE_LVGL_TASK_STACK_SIZE, NULL, EXAMPLE_LVGL_TASK_PRIORITY, NULL);
|
|
|
|
ESP_LOGI(TAG, "Display LVGL demos");
|
|
// Lock the mutex due to the LVGL APIs are not thread-safe
|
|
if (example_lvgl_lock(-1))
|
|
{
|
|
|
|
// lv_demo_widgets(); /* A widgets example */
|
|
lv_demo_music(); /* A modern, smartphone-like music player demo. */
|
|
// lv_demo_stress(); /* A stress test for LVGL. */
|
|
// lv_demo_benchmark(); /* A demo to measure the performance of LVGL or to compare different settings. */
|
|
|
|
// Release the mutex
|
|
example_lvgl_unlock();
|
|
}
|
|
} |