/* * LVGL GIF display for ESP32-S3 Touch AMOLED 1.8" (SH8601) * Ported from ST7789 to SH8601 QSPI AMOLED display */ #include #include #include "esp_err.h" #include "esp_log.h" #include "esp_check.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 "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/semphr.h" #include "esp_heap_caps.h" #include "lvgl.h" #include "src/extra/libs/gif/lv_gif.h" #include "emotions/facetestLCD.h" #include "esp_lcd_sh8601.h" #include "esp_lcd_touch_ft5x06.h" #include "esp_io_expander_tca9554.h" #include "../assets/logoIro.c" /* Re-enable input devices after splash timeout */ static void reenable_input_cb(lv_timer_t * t) { lv_indev_t *indev = lv_indev_get_next(NULL); while (indev) { lv_indev_enable(indev, true); indev = lv_indev_get_next(indev); } lv_timer_del(t); } /* Helper to animate screen background color (exec callback for lv_anim) */ static void scr_bg_anim(void * var, int32_t v) { lv_obj_t *scr = (lv_obj_t *)var; lv_color_t c = lv_color_hex((uint32_t)v); lv_obj_set_style_bg_color(scr, c, LV_PART_MAIN); } /* Timer callback started after fade-in completes; starts fade-out and background animation */ static void fadeout_start_cb(lv_timer_t * t) { lv_obj_t *logo = (lv_obj_t *)t->user_data; if (!logo) { lv_timer_del(t); return; } /* Start image fade-out (750 ms) */ lv_obj_fade_out(logo, 750, 0); /* Animate screen background color from sampled bg to black over 750 ms */ lv_obj_t *scr = lv_obj_get_parent(logo); uint32_t from_hex = 0x000000; /* Try to sample from the image data if available */ if (logoIro_img.data && logoIro_img.data_size >= 2) { const uint8_t *d = (const uint8_t *)logoIro_img.data; uint16_t pix = (uint16_t)(d[0] | (d[1] << 8)); uint8_t r5 = (pix >> 11) & 0x1F; uint8_t g6 = (pix >> 5) & 0x3F; uint8_t b5 = pix & 0x1F; uint8_t r8 = (r5 * 255) / 31; uint8_t g8 = (g6 * 255) / 63; uint8_t b8 = (b5 * 255) / 31; from_hex = (r8 << 16) | (g8 << 8) | b8; } lv_anim_t a; lv_anim_init(&a); lv_anim_set_var(&a, scr); lv_anim_set_exec_cb(&a, scr_bg_anim); lv_anim_set_values(&a, (int)from_hex, 0x000000); lv_anim_set_time(&a, 750); lv_anim_start(&a); lv_timer_del(t); } static const char *TAG __attribute__((unused)) = "LVGL_AMOLED"; /* LCD Host */ #define LCD_HOST SPI2_HOST #define TOUCH_HOST I2C_NUM_0 /* Color depth configuration */ #if CONFIG_LV_COLOR_DEPTH == 32 #define LCD_BIT_PER_PIXEL (24) #elif CONFIG_LV_COLOR_DEPTH == 16 #define LCD_BIT_PER_PIXEL (16) #else #define LCD_BIT_PER_PIXEL (16) #endif /* LCD settings for ESP32-S3 Touch AMOLED 1.8" */ #define LCD_H_RES (368) #define LCD_V_RES (448) /* LCD QSPI pins */ #define PIN_NUM_LCD_CS (GPIO_NUM_12) #define PIN_NUM_LCD_PCLK (GPIO_NUM_11) #define PIN_NUM_LCD_DATA0 (GPIO_NUM_4) #define PIN_NUM_LCD_DATA1 (GPIO_NUM_5) #define PIN_NUM_LCD_DATA2 (GPIO_NUM_6) #define PIN_NUM_LCD_DATA3 (GPIO_NUM_7) #define PIN_NUM_LCD_RST (-1) /* Reset via IO expander */ #define PIN_NUM_BK_LIGHT (-1) /* Backlight via IO expander */ /* Touch I2C pins */ #define PIN_NUM_TOUCH_SCL (GPIO_NUM_14) #define PIN_NUM_TOUCH_SDA (GPIO_NUM_15) #define PIN_NUM_TOUCH_RST (-1) /* Reset via IO expander */ #define PIN_NUM_TOUCH_INT (GPIO_NUM_21) /* Enable touch support */ #define USE_TOUCH 1 /* LVGL configuration */ #define LVGL_BUF_HEIGHT (LCD_V_RES / 4) #define LVGL_TICK_PERIOD_MS 2 #define LVGL_TASK_MAX_DELAY_MS 500 #define LVGL_TASK_MIN_DELAY_MS 1 #define LVGL_TASK_STACK_SIZE (8 * 1024) #define LVGL_TASK_PRIORITY 4 /* LCD IO and panel handles */ static esp_lcd_panel_io_handle_t lcd_io __attribute__((unused)) = NULL; static esp_lcd_panel_handle_t lcd_panel __attribute__((unused)) = NULL; #if USE_TOUCH static esp_lcd_touch_handle_t tp __attribute__((unused)) = NULL; #endif /* LVGL mutex for thread safety */ static SemaphoreHandle_t lvgl_mux = NULL; static lv_obj_t *g_lvgl_gif __attribute__((unused)) = NULL; static const lv_img_dsc_t g_lvgl_gif_src __attribute__((unused)) = { .header.always_zero = 0, .header.w = 240, .header.h = 135, .header.cf = LV_IMG_CF_RAW, .data_size = sizeof(facetestLCD), .data = facetestLCD, }; /* LCD initialization commands for SH8601 */ 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}, /* Column address: 0-367 */ {0x2B, (uint8_t[]){0x00, 0x00, 0x01, 0xBF}, 4, 0}, /* Row address: 0-447 */ {0x51, (uint8_t[]){0x00}, 1, 10}, {0x29, (uint8_t[]){0x00}, 0, 10}, {0x51, (uint8_t[]){0xFF}, 1, 0}, /* Max brightness */ }; /* LVGL display driver variable (for flush callback) */ static lv_disp_drv_t disp_drv; static bool 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 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 /* Convert LVGL color format to RGB888 for 24-bit mode */ uint8_t *to = (uint8_t *)color_map; uint8_t temp = 0; uint16_t pixel_num = (offsetx2 - offsetx1 + 1) * (offsety2 - offsety1 + 1); temp = color_map[0].ch.blue; *to++ = color_map[0].ch.red; *to++ = color_map[0].ch.green; *to++ = temp; 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 esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map); } static void 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: esp_lcd_panel_swap_xy(panel_handle, false); esp_lcd_panel_mirror(panel_handle, false, false); break; case LV_DISP_ROT_90: esp_lcd_panel_swap_xy(panel_handle, true); esp_lcd_panel_mirror(panel_handle, false, false); break; case LV_DISP_ROT_180: esp_lcd_panel_swap_xy(panel_handle, false); esp_lcd_panel_mirror(panel_handle, true, false); break; case LV_DISP_ROT_270: esp_lcd_panel_swap_xy(panel_handle, true); esp_lcd_panel_mirror(panel_handle, true, false); break; } } void lvgl_rounder_cb(struct _lv_disp_drv_t *disp_drv, lv_area_t *area) { /* Round coordinates to even numbers (required by SH8601) */ uint16_t x1 = area->x1; uint16_t x2 = area->x2; uint16_t y1 = area->y1; uint16_t y2 = area->y2; area->x1 = (x1 >> 1) << 1; area->y1 = (y1 >> 1) << 1; area->x2 = ((x2 >> 1) << 1) + 1; area->y2 = ((y2 >> 1) << 1) + 1; } #if USE_TOUCH static void lvgl_touch_cb(lv_indev_drv_t *drv, lv_indev_data_t *data) { esp_lcd_touch_handle_t touch_handle = (esp_lcd_touch_handle_t)drv->user_data; assert(touch_handle); uint16_t tp_x; uint16_t tp_y; uint8_t tp_cnt = 0; esp_lcd_touch_read_data(touch_handle); bool tp_pressed = esp_lcd_touch_get_coordinates(touch_handle, &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 increase_lvgl_tick(void *arg) { lv_tick_inc(LVGL_TICK_PERIOD_MS); } static bool lvgl_lock(int timeout_ms) { assert(lvgl_mux && "LVGL mutex not initialized"); const TickType_t timeout_ticks = (timeout_ms == -1) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms); return xSemaphoreTake(lvgl_mux, timeout_ticks) == pdTRUE; } static void lvgl_unlock(void) { assert(lvgl_mux && "LVGL mutex not initialized"); xSemaphoreGive(lvgl_mux); } static void lvgl_port_task(void *arg) { ESP_LOGI(TAG, "Starting LVGL task"); uint32_t task_delay_ms = LVGL_TASK_MAX_DELAY_MS; while (1) { if (lvgl_lock(-1)) { task_delay_ms = lv_timer_handler(); lvgl_unlock(); } if (task_delay_ms > LVGL_TASK_MAX_DELAY_MS) { task_delay_ms = LVGL_TASK_MAX_DELAY_MS; } else if (task_delay_ms < LVGL_TASK_MIN_DELAY_MS) { task_delay_ms = LVGL_TASK_MIN_DELAY_MS; } vTaskDelay(pdMS_TO_TICKS(task_delay_ms)); } } void app_main(void) { ESP_LOGI(TAG, "Starting LVGL AMOLED application"); /* Suppress some verbose logging */ 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; /* Initialize I2C bus for touch and IO expander */ ESP_LOGI(TAG, "Initialize I2C bus"); const i2c_config_t i2c_conf = { .mode = I2C_MODE_MASTER, .sda_io_num = PIN_NUM_TOUCH_SDA, .sda_pullup_en = GPIO_PULLUP_ENABLE, .scl_io_num = 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)); /* Initialize IO expander (TCA9554) for LCD/Touch reset and backlight */ ESP_LOGI(TAG, "Initialize IO expander"); esp_io_expander_handle_t io_expander = NULL; ESP_ERROR_CHECK(esp_io_expander_new_i2c_tca9554(TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander)); /* Configure IO expander pins as outputs */ 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); /* Reset sequence: pull low then high */ 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); /* Initialize QSPI bus for LCD */ ESP_LOGI(TAG, "Initialize QSPI bus"); const spi_bus_config_t buscfg = SH8601_PANEL_BUS_QSPI_CONFIG( PIN_NUM_LCD_PCLK, PIN_NUM_LCD_DATA0, PIN_NUM_LCD_DATA1, PIN_NUM_LCD_DATA2, PIN_NUM_LCD_DATA3, LCD_H_RES * LCD_V_RES * LCD_BIT_PER_PIXEL / 8 ); ESP_ERROR_CHECK(spi_bus_initialize(LCD_HOST, &buscfg, SPI_DMA_CH_AUTO)); /* Install panel IO */ ESP_LOGI(TAG, "Install panel IO"); const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG( PIN_NUM_LCD_CS, notify_lvgl_flush_ready, &disp_drv ); ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST, &io_config, &lcd_io)); /* Configure vendor-specific settings */ 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, }, }; /* Install SH8601 panel driver */ ESP_LOGI(TAG, "Install SH8601 panel driver"); const esp_lcd_panel_dev_config_t panel_config = { .reset_gpio_num = PIN_NUM_LCD_RST, .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB, .bits_per_pixel = LCD_BIT_PER_PIXEL, .vendor_config = &vendor_config, }; ESP_ERROR_CHECK(esp_lcd_new_panel_sh8601(lcd_io, &panel_config, &lcd_panel)); ESP_ERROR_CHECK(esp_lcd_panel_reset(lcd_panel)); ESP_ERROR_CHECK(esp_lcd_panel_init(lcd_panel)); ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(lcd_panel, true)); #if USE_TOUCH /* Initialize touch controller */ ESP_LOGI(TAG, "Initialize touch controller"); 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(); 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 = LCD_H_RES, .y_max = LCD_V_RES, .rst_gpio_num = PIN_NUM_TOUCH_RST, .int_gpio_num = PIN_NUM_TOUCH_INT, .levels = { .reset = 0, .interrupt = 0, }, .flags = { .swap_xy = 0, .mirror_x = 0, .mirror_y = 0, }, }; ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_ft5x06(tp_io_handle, &tp_cfg, &tp)); #endif /* Initialize LVGL */ ESP_LOGI(TAG, "Initialize LVGL library"); lv_init(); /* Allocate draw buffers in DMA-capable memory */ lv_color_t *buf1 = heap_caps_malloc(LCD_H_RES * LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA); assert(buf1); lv_color_t *buf2 = heap_caps_malloc(LCD_H_RES * LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA); assert(buf2); lv_disp_draw_buf_init(&disp_buf, buf1, buf2, LCD_H_RES * LVGL_BUF_HEIGHT); /* Register display driver */ ESP_LOGI(TAG, "Register display driver"); lv_disp_drv_init(&disp_drv); disp_drv.hor_res = LCD_H_RES; disp_drv.ver_res = LCD_V_RES; disp_drv.flush_cb = lvgl_flush_cb; disp_drv.rounder_cb = lvgl_rounder_cb; disp_drv.drv_update_cb = lvgl_update_cb; disp_drv.draw_buf = &disp_buf; disp_drv.user_data = lcd_panel; lv_disp_t *disp = lv_disp_drv_register(&disp_drv); /* Install LVGL tick timer */ ESP_LOGI(TAG, "Install LVGL tick timer"); const esp_timer_create_args_t lvgl_tick_timer_args = { .callback = &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, LVGL_TICK_PERIOD_MS * 1000)); #if USE_TOUCH /* Register touch input device */ ESP_LOGI(TAG, "Register touch input device"); static lv_indev_drv_t indev_drv; lv_indev_drv_init(&indev_drv); indev_drv.type = LV_INDEV_TYPE_POINTER; indev_drv.disp = disp; indev_drv.read_cb = lvgl_touch_cb; indev_drv.user_data = tp; lv_indev_drv_register(&indev_drv); #endif /* Create LVGL mutex and task */ lvgl_mux = xSemaphoreCreateMutex(); assert(lvgl_mux); xTaskCreate(lvgl_port_task, "LVGL", LVGL_TASK_STACK_SIZE, NULL, LVGL_TASK_PRIORITY, NULL); /* Create a splash screen: sample the image background color, fit image inside * the display (no cropping), disable interaction, and render pixel-perfect * by using LVGL's zoom. */ if (lvgl_lock(-1)) { lv_obj_t *scr = lv_scr_act(); /* Sample first pixel from embedded RGB565 image to use as background. * Assume `logoIro_img.data` contains RGB565 (little-endian) bytes. */ uint32_t bg_hex = 0x848a5d; /* fallback */ if (logoIro_img.data && logoIro_img.data_size >= 2) { const uint8_t *d = (const uint8_t *)logoIro_img.data; uint16_t pix = (uint16_t)(d[0] | (d[1] << 8)); uint8_t r5 = (pix >> 11) & 0x1F; uint8_t g6 = (pix >> 5) & 0x3F; uint8_t b5 = pix & 0x1F; uint8_t r8 = (r5 * 255) / 31; uint8_t g8 = (g6 * 255) / 63; uint8_t b8 = (b5 * 255) / 31; bg_hex = (r8 << 16) | (g8 << 8) | b8; } lv_obj_set_style_bg_color(scr, lv_color_hex(bg_hex), LV_PART_MAIN); lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, LV_PART_MAIN); /* Create and display the logo image (scaled to fit screen, centered) */ lv_obj_t *logo_img = lv_img_create(scr); lv_img_set_src(logo_img, &logoIro_img); /* Fit the image inside the screen (no crop) using LVGL zoom (256 == 1.0×). * Temporarily disable input devices to prevent scrolling during the splash. */ { const lv_img_dsc_t *dsc = &logoIro_img; int orig_w = dsc->header.w; int orig_h = dsc->header.h; int scr_w = lv_disp_get_hor_res(NULL); int scr_h = lv_disp_get_ver_res(NULL); /* Compute separate scale factors for width and height (256 == 1.0×) */ int scale_w = (scr_w * 256) / orig_w; int scale_h = (scr_h * 256) / orig_h; /* Use the smaller scale so the image fits inside the screen (no crop) */ uint16_t zoom = (uint16_t)((scale_w < scale_h) ? scale_w : scale_h); if (zoom == 0) zoom = 1; lv_img_set_zoom(logo_img, zoom); /* Make the image and screen non-interactive / non-scrollable */ lv_obj_clear_flag(logo_img, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE); lv_obj_clear_flag(scr, LV_OBJ_FLAG_SCROLLABLE | LV_OBJ_FLAG_CLICKABLE); /* Center the image */ lv_obj_align(logo_img, LV_ALIGN_CENTER, 0, 0); /* Disable all input devices temporarily to prevent user scroll/input */ lv_indev_t *indev = lv_indev_get_next(NULL); while (indev) { lv_indev_enable(indev, false); indev = lv_indev_get_next(indev); } /* Re-enable inputs after 1500 ms */ lv_timer_create(reenable_input_cb, 1500, NULL); } lvgl_unlock(); } ESP_LOGI(TAG, "LVGL AMOLED application running"); }