#include #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 "animated_eyes_demo.h" #include "esp_lcd_sh8601.h" #include "esp_lcd_touch_ft5x06.h" #include "esp_io_expander_tca9554.h" #include "splash_screen.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); // Lock the mutex due to the LVGL APIs are not thread-safe if (example_lvgl_lock(-1)) { // Show splash screen first ESP_LOGI(TAG, "Showing splash screen"); splash_screen_show(); // Start animated eyes demo ESP_LOGI(TAG, "Starting animated eyes"); animated_eyes_demo_start(); // Release the mutex example_lvgl_unlock(); } }