Merge branch 'feature/rgb_panel_example' into 'master'

lcd: add rgb panel example

Closes IDF-4429

See merge request espressif/esp-idf!16459

components/esp_lcd/include/esp_lcd_panel_rgb.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -64,7 +64,7 @@ typedef struct {
         unsigned int hsync_idle_low: 1;  /*!< The hsync signal is low in IDLE state */
         unsigned int vsync_idle_low: 1;  /*!< The vsync signal is low in IDLE state */
         unsigned int de_idle_high: 1;    /*!< The de signal is high in IDLE state */
-        unsigned int pclk_active_neg: 1; /*!< The display will write data lines when there's a falling edge on PCLK */
+        unsigned int pclk_active_neg: 1; /*!< Whether the display data is clocked out at the falling edge of PCLK */
         unsigned int pclk_idle_high: 1;  /*!< The PCLK stays at high level in IDLE phase */
     } flags;
 } esp_lcd_rgb_timing_t;
@@ -92,6 +92,8 @@ typedef struct {
     lcd_clock_source_t clk_src;   /*!< Clock source for the RGB LCD peripheral */
     esp_lcd_rgb_timing_t timings; /*!< RGB timing parameters */
     size_t data_width;            /*!< Number of data lines */
+    size_t sram_trans_align;      /*!< Alignment for framebuffer that allocated in SRAM */
+    size_t psram_trans_align;     /*!< Alignment for framebuffer that allocated in PSRAM */
     int hsync_gpio_num;           /*!< GPIO used for HSYNC signal */
     int vsync_gpio_num;           /*!< GPIO used for VSYNC signal */
     int de_gpio_num;              /*!< GPIO used for DE signal, set to -1 if it's not used */

components/esp_lcd/src/esp_lcd_rgb_panel.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -65,6 +65,8 @@ struct esp_rgb_panel_t {
     int panel_id;          // LCD panel ID
     lcd_hal_context_t hal; // Hal layer object
     size_t data_width;     // Number of data lines (e.g. for RGB565, the data width is 16)
+    size_t sram_trans_align;  // Alignment for framebuffer that allocated in SRAM
+    size_t psram_trans_align; // Alignment for framebuffer that allocated in PSRAM
     int disp_gpio_num;     // Display control GPIO, which is used to perform action like "disp_off"
     intr_handle_t intr;    // LCD peripheral interrupt handle
     esp_pm_lock_handle_t pm_lock; // Power management lock
@@ -125,12 +127,17 @@ esp_err_t esp_lcd_new_rgb_panel(const esp_lcd_rgb_panel_config_t *rgb_panel_conf
         }
 #endif
     }
+    size_t psram_trans_align = rgb_panel_config->psram_trans_align ? rgb_panel_config->psram_trans_align : 64;
+    size_t sram_trans_align = rgb_panel_config->sram_trans_align ? rgb_panel_config->sram_trans_align : 4;
     if (alloc_from_psram) {
-        rgb_panel->fb = heap_caps_calloc(1, fb_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+        // the low level malloc function will help check the validation of alignment
+        rgb_panel->fb = heap_caps_aligned_calloc(psram_trans_align, 1, fb_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
     } else {
-        rgb_panel->fb = heap_caps_calloc(1, fb_size, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+        rgb_panel->fb = heap_caps_aligned_calloc(sram_trans_align, 1, fb_size, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
     }
     ESP_GOTO_ON_FALSE(rgb_panel->fb, ESP_ERR_NO_MEM, err, TAG, "no mem for frame buffer");
+    rgb_panel->psram_trans_align = psram_trans_align;
+    rgb_panel->sram_trans_align = sram_trans_align;
     rgb_panel->fb_size = fb_size;
     rgb_panel->flags.fb_in_psram = alloc_from_psram;
     // semaphore indicates new frame trans done
@@ -379,8 +386,11 @@ static esp_err_t lcd_rgb_panel_configure_gpio(esp_rgb_panel_t *panel, const esp_
 {
     int panel_id = panel->panel_id;
     // check validation of GPIO number
-    bool valid_gpio = (panel_config->hsync_gpio_num >= 0) && (panel_config->vsync_gpio_num >= 0) &&
-                      (panel_config->pclk_gpio_num >= 0);
+    bool valid_gpio = (panel_config->pclk_gpio_num >= 0);
+    if (panel_config->de_gpio_num < 0) {
+        // Hsync and Vsync are required in HV mode
+        valid_gpio = valid_gpio && (panel_config->hsync_gpio_num >= 0) && (panel_config->vsync_gpio_num >= 0);
+    }
     for (size_t i = 0; i < panel_config->data_width; i++) {
         valid_gpio = valid_gpio && (panel_config->data_gpio_nums[i] >= 0);
     }
@@ -394,14 +404,18 @@ static esp_err_t lcd_rgb_panel_configure_gpio(esp_rgb_panel_t *panel, const esp_
         esp_rom_gpio_connect_out_signal(panel_config->data_gpio_nums[i],
                                         lcd_periph_signals.panels[panel_id].data_sigs[i], false, false);
     }
-    gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[panel_config->hsync_gpio_num], PIN_FUNC_GPIO);
-    gpio_set_direction(panel_config->hsync_gpio_num, GPIO_MODE_OUTPUT);
-    esp_rom_gpio_connect_out_signal(panel_config->hsync_gpio_num,
-                                    lcd_periph_signals.panels[panel_id].hsync_sig, false, false);
-    gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[panel_config->vsync_gpio_num], PIN_FUNC_GPIO);
-    gpio_set_direction(panel_config->vsync_gpio_num, GPIO_MODE_OUTPUT);
-    esp_rom_gpio_connect_out_signal(panel_config->vsync_gpio_num,
-                                    lcd_periph_signals.panels[panel_id].vsync_sig, false, false);
+    if (panel_config->hsync_gpio_num >= 0) {
+        gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[panel_config->hsync_gpio_num], PIN_FUNC_GPIO);
+        gpio_set_direction(panel_config->hsync_gpio_num, GPIO_MODE_OUTPUT);
+        esp_rom_gpio_connect_out_signal(panel_config->hsync_gpio_num,
+                                        lcd_periph_signals.panels[panel_id].hsync_sig, false, false);
+    }
+    if (panel_config->vsync_gpio_num >= 0) {
+        gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[panel_config->vsync_gpio_num], PIN_FUNC_GPIO);
+        gpio_set_direction(panel_config->vsync_gpio_num, GPIO_MODE_OUTPUT);
+        esp_rom_gpio_connect_out_signal(panel_config->vsync_gpio_num,
+                                        lcd_periph_signals.panels[panel_id].vsync_sig, false, false);
+    }
     gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[panel_config->pclk_gpio_num], PIN_FUNC_GPIO);
     gpio_set_direction(panel_config->pclk_gpio_num, GPIO_MODE_OUTPUT);
     esp_rom_gpio_connect_out_signal(panel_config->pclk_gpio_num,
@@ -471,8 +485,8 @@ static esp_err_t lcd_rgb_panel_create_trans_link(esp_rgb_panel_t *panel)
     ESP_GOTO_ON_ERROR(ret, err, TAG, "alloc DMA channel failed");
     gdma_connect(panel->dma_chan, GDMA_MAKE_TRIGGER(GDMA_TRIG_PERIPH_LCD, 0));
     gdma_transfer_ability_t ability = {
-        .psram_trans_align = 64,
-        .sram_trans_align = 4,
+        .psram_trans_align = panel->psram_trans_align,
+        .sram_trans_align = panel->sram_trans_align,
     };
     gdma_set_transfer_ability(panel->dma_chan, &ability);
     // the start of DMA should be prior to the start of LCD engine

components/esp_lcd/test/test_rgb_panel.c

@@ -100,71 +100,5 @@ TEST_CASE("lcd rgb lcd panel", "[lcd]")
 #undef TEST_IMG_SIZE
 }
 
-// The following test shows a porting example of LVGL GUI library
-// To run the LVGL tests, you need to clone the LVGL library into components directory firstly
-#if CONFIG_LV_USE_USER_DATA
-#include "test_lvgl_port.h"
-
-static bool notify_lvgl_ready_to_flush(esp_lcd_panel_handle_t panel, esp_lcd_rgb_panel_event_data_t *edata, void *user_ctx)
-{
-    lv_disp_t *disp = *(lv_disp_t **)user_ctx;
-    lv_disp_flush_ready(&disp->driver);
-    return false;
-}
-
-TEST_CASE("lvgl gui with rgb interface", "[lcd][lvgl][ignore]")
-{
-    // initialize LVGL graphics library
-    lv_disp_t *disp = NULL;
-    lv_init();
-
-    esp_lcd_panel_handle_t panel_handle = NULL;
-    esp_lcd_rgb_panel_config_t panel_config = {
-        .data_width = 16,
-        .disp_gpio_num = -1,
-        .pclk_gpio_num = TEST_LCD_PCLK_GPIO,
-        .vsync_gpio_num = TEST_LCD_VSYNC_GPIO,
-        .hsync_gpio_num = TEST_LCD_HSYNC_GPIO,
-        .de_gpio_num = TEST_LCD_DE_GPIO,
-        .data_gpio_nums = {
-            TEST_LCD_DATA0_GPIO,
-            TEST_LCD_DATA1_GPIO,
-            TEST_LCD_DATA2_GPIO,
-            TEST_LCD_DATA3_GPIO,
-            TEST_LCD_DATA4_GPIO,
-            TEST_LCD_DATA5_GPIO,
-            TEST_LCD_DATA6_GPIO,
-            TEST_LCD_DATA7_GPIO,
-            TEST_LCD_DATA8_GPIO,
-            TEST_LCD_DATA9_GPIO,
-            TEST_LCD_DATA10_GPIO,
-            TEST_LCD_DATA11_GPIO,
-            TEST_LCD_DATA12_GPIO,
-            TEST_LCD_DATA13_GPIO,
-            TEST_LCD_DATA14_GPIO,
-            TEST_LCD_DATA15_GPIO,
-        },
-        .timings = {
-            .pclk_hz = 6000000,
-            .h_res = TEST_LCD_H_RES,
-            .v_res = TEST_LCD_V_RES,
-            .hsync_back_porch = 43,
-            .hsync_front_porch = 2,
-            .hsync_pulse_width = 1,
-            .vsync_back_porch = 12,
-            .vsync_front_porch = 1,
-            .vsync_pulse_width = 1,
-        },
-        .flags.fb_in_psram = 1,
-        .on_frame_trans_done = notify_lvgl_ready_to_flush,
-        .user_ctx = &disp,
-    };
-    TEST_ESP_OK(esp_lcd_new_rgb_panel(&panel_config, &panel_handle));
-    TEST_ESP_OK(esp_lcd_panel_reset(panel_handle));
-    TEST_ESP_OK(esp_lcd_panel_init(panel_handle));
-
-    test_lvgl_task_loop(panel_handle, TEST_LCD_H_RES, TEST_LCD_V_RES, &disp);
-}
-#endif // CONFIG_LV_USE_USER_DATA
 #endif // CONFIG_SPIRAM_USE_MALLOC
 #endif // SOC_LCD_RGB_SUPPORTED

docs/en/api-reference/peripherals/lcd.rst

@@ -25,6 +25,7 @@ LCD examples are located under: :example:`peripherals/lcd`:
 * Jpeg decoding and LCD display - :example:`peripherals/lcd/tjpgd`
 * i80 controller based LCD and LVGL animation UI - :example:`peripherals/lcd/i80_controller`
 * GC9A01 user customized driver and dash board UI - :example:`peripherals/lcd/gc9a01`
+* RGB panel example with scatter chart UI - :example:`peripherals/lcd/rgb_panel`
 
 API Reference
 -------------

examples/peripherals/lcd/gc9a01/README.md

@@ -4,7 +4,7 @@
 
 `esp_lcd` allows user to add their own panel drivers in the project scope (i.e. panel driver can live outside of esp-idf), so that the upper layer code like LVGL porting code can be reused without any modifications, as long as user-implemented panel driver follows the interface defined in the `esp_lcd` component.
 
-This example shows how to add the GC9A01 driver in the project folder but still use the API provided by `esp_lcd` component. As GC9A01 is famous in the form of a circular screen, this example will draw a fancy dash board with the LVGL library. For more information about porting the LVGL library, you can also refer to another [lvgl porting example](../i80_controller/README.md).
+This example shows how to add the GC9A01 driver in the project folder but still use the API provided by `esp_lcd` component. As GC9A01 is famous in the form of a circular screen, this example will draw a fancy dash board with the LVGL library. For more information about porting the LVGL library, you can also refer to [another lvgl porting example](../i80_controller/README.md).
 
 ## How to use the example
 
@@ -39,8 +39,8 @@ The connection between ESP Board and the LCD is as follows:
 └──────────────────────┘              └────────────────────┘
 ```
 
-The GPIO number used by this example can be changed in [lvgl_example_main.c](main/lvgl_example_main.c).
-Especially, please pay attention to the level used to turn on the LCD backlight, some LCD module needs a low level to turn it on, while others take a high level. You can change the backlight level macro `EXAMPLE_LCD_BK_LIGHT_ON_LEVEL` in [lvgl_example_main.c](main/lvgl_example_main.c).
+The GPIO number used by this example can be changed in [lvgl_example_main.c](main/gc9a01_example_main.c).
+Especially, please pay attention to the level used to turn on the LCD backlight, some LCD module needs a low level to turn it on, while others take a high level. You can change the backlight level macro `EXAMPLE_LCD_BK_LIGHT_ON_LEVEL` in [lvgl_example_main.c](main/gc9a01_example_main.c).
 
 ### Build and Flash
 

examples/peripherals/lcd/gc9a01/main/CMakeLists.txt

@@ -1,2 +1,2 @@
-idf_component_register(SRCS "esp_lcd_panel_gc9a01.c" "lvgl_example_main.c" "lvgl_demo_ui.c"
+idf_component_register(SRCS "esp_lcd_panel_gc9a01.c" "gc9a01_example_main.c" "lvgl_demo_ui.c"
                        INCLUDE_DIRS ".")

examples/peripherals/lcd/gc9a01/main/lvgl_example_main.c → examples/peripherals/lcd/gc9a01/main/gc9a01_example_main.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: CC0-1.0
  */

examples/peripherals/lcd/gc9a01/main/lvgl_demo_ui.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: CC0-1.0
  */
@@ -17,7 +17,7 @@ static void set_value(void *indic, int32_t v)
 
 void example_lvgl_demo_ui(lv_obj_t *scr)
 {
-    meter = lv_meter_create(lv_scr_act());
+    meter = lv_meter_create(scr);
     lv_obj_center(meter);
     lv_obj_set_size(meter, 200, 200);
 

examples/peripherals/lcd/i80_controller/main/i80_controller_example_main.c

@@ -98,6 +98,7 @@ void app_main(void)
     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_PLL160M,
         .dc_gpio_num = EXAMPLE_PIN_NUM_DC,
         .wr_gpio_num = EXAMPLE_PIN_NUM_PCLK,
         .data_gpio_nums = {

examples/peripherals/lcd/rgb_panel/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(rgb_panel)
+
+# As the upstream LVGL library has build warnings in esp-idf build system, this is only for temporarily workaround
+# Will remove this workaround when upstream LVGL fixes the warnings in the next release
+idf_component_get_property(lvgl_lib lvgl__lvgl COMPONENT_LIB)
+target_compile_options(${lvgl_lib} PRIVATE "-Wno-empty-body" "-Wno-strict-prototypes")

examples/peripherals/lcd/rgb_panel/README.md

@@ -0,0 +1,88 @@
+| Supported Targets | ESP32-S3 |
+| ----------------- | -------- |
+# RGB panel example
+
+[esp_lcd](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/lcd.html) supports RGB interfaced LCD panel, with a frame buffer managed by the driver itself.
+
+This example shows the general process of installing an RGB panel driver, and displays a scatter chart on the screen based on the LVGL library. For more information about porting the LVGL library, please refer to [another lvgl porting example](../i80_controller/README.md).
+
+## How to use the example
+
+### Hardware Required
+
+* An ESP development board, which has RGB LCD peripheral supported and PSRAM onboard
+* A general RGB panel, 16 bit-width, with HSYNC, VSYNC and DE signal
+* An USB cable for power supply and programming
+
+### Hardware Connection
+
+The connection between ESP Board and the LCD is as follows:
+
+```
+       ESP Board                           RGB  Panel
++-----------------------+              +-------------------+
+|                   GND +--------------+GND                |
+|                       |              |                   |
+|                   3V3 +--------------+VCC                |
+|                       |              |                   |
+|                   PCLK+--------------+PCLK               |
+|                       |              |                   |
+|             DATA[15:0]+--------------+DATA[15:0]         |
+|                       |              |                   |
+|                  HSYNC+--------------+HSYNC              |
+|                       |              |                   |
+|                  VSYNC+--------------+VSYNC              |
+|                       |              |                   |
+|                     DE+--------------+DE                 |
+|                       |              |                   |
+|               BK_LIGHT+--------------+BLK                |
++-----------------------+              |                   |
+                               3V3-----+DISP_EN            |
+                                       |                   |
+                                       +-------------------+
+```
+
+The GPIO number used by this example can be changed in [lvgl_example_main.c](main/rgb_lcd_example_main.c).
+
+Especially, please pay attention to the level used to turn on the LCD backlight, some LCD module needs a low level to turn it on, while others take a high level. You can change the backlight level macro `EXAMPLE_LCD_BK_LIGHT_ON_LEVEL` in [lvgl_example_main.c](main/rgb_lcd_example_main.c).
+
+If the RGB LCD panel only supports DE mode, you can bypass the `HSYNC` and `VSYNC` signals, by assigning `EXAMPLE_PIN_NUM_HSYNC` and `EXAMPLE_PIN_NUM_VSYNC` with `-1`.
+
+### Build and Flash
+
+Run `idf.py -p PORT build flash monitor` to build, flash and monitor the project. A scatter chart will show up on the LCD as expected.
+
+The first time you run `idf.py` for the example will cost extra time as the build system needs to address the component dependencies and downloads the missing components from registry into `managed_components` folder.
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
+
+### Example Output
+
+```bash
+...
+I (0) cpu_start: Starting scheduler on APP CPU.
+I (731) spiram: Reserving pool of 32K of internal memory for DMA/internal allocations
+I (731) example: Turn off LCD backlight
+I (731) gpio: GPIO[39]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
+I (731) example: Install RGB panel driver
+I (741) example: Turn on LCD backlight
+I (741) example: Initialize LVGL library
+I (741) example: Register display driver to LVGL
+I (741) example: Install LVGL tick timer
+I (741) example: Display LVGL Scatter Chart
+...
+```
+
+## Troubleshooting
+
+* Why the LCD doesn't light up?
+  * Check the backlight's turn-on level, and update it in `EXAMPLE_LCD_BK_LIGHT_ON_LEVEL`
+* No memory for frame buffer
+  * The frame buffer of RGB panel is located in ESP side (unlike other controller based LCDs, where the frame buffer is located in external chip). As the frame buffer usually consumes much RAM (depends on the LCD resolution and color depth), we recommend to put the frame buffer into PSRAM (like what we do in this example). However, putting frame buffer in PSRAM will limit the PCLK to around 12MHz (due to the bandwidth of PSRAM).
+* LCD screen drift
+  * Slow down the PCLK frequency
+  * Adjust other timing parameters like PCLK clock edge (by `pclk_active_neg`), sync porches like HBP (by `hsync_back_porch`) according to your LCD spec
+
+For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.

examples/peripherals/lcd/rgb_panel/main/CMakeLists.txt

@@ -0,0 +1,2 @@
+idf_component_register(SRCS "rgb_lcd_example_main.c" "lvgl_demo_ui.c"
+                       INCLUDE_DIRS ".")

examples/peripherals/lcd/rgb_panel/main/idf_component.yml

@@ -0,0 +1,3 @@
+dependencies:
+  idf: ">=4.4"
+  lvgl/lvgl: "~8.0.2"

examples/peripherals/lcd/rgb_panel/main/lvgl_demo_ui.c

@@ -0,0 +1,66 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+// This demo UI is adapted from LVGL official example: https://docs.lvgl.io/master/examples.html#scatter-chart
+
+#include "lvgl.h"
+
+static void draw_event_cb(lv_event_t *e)
+{
+    lv_obj_draw_part_dsc_t *dsc = lv_event_get_draw_part_dsc(e);
+    if (dsc->part == LV_PART_ITEMS) {
+        lv_obj_t *obj = lv_event_get_target(e);
+        lv_chart_series_t *ser = lv_chart_get_series_next(obj, NULL);
+        uint32_t cnt = lv_chart_get_point_count(obj);
+        /*Make older value more transparent*/
+        dsc->rect_dsc->bg_opa = (LV_OPA_COVER *  dsc->id) / (cnt - 1);
+
+        /*Make smaller values blue, higher values red*/
+        lv_coord_t *x_array = lv_chart_get_x_array(obj, ser);
+        lv_coord_t *y_array = lv_chart_get_y_array(obj, ser);
+        /*dsc->id is the tells drawing order, but we need the ID of the point being drawn.*/
+        uint32_t start_point = lv_chart_get_x_start_point(obj, ser);
+        uint32_t p_act = (start_point + dsc->id) % cnt; /*Consider start point to get the index of the array*/
+        lv_opa_t x_opa = (x_array[p_act] * LV_OPA_50) / 200;
+        lv_opa_t y_opa = (y_array[p_act] * LV_OPA_50) / 1000;
+
+        dsc->rect_dsc->bg_color = lv_color_mix(lv_palette_main(LV_PALETTE_RED),
+                                               lv_palette_main(LV_PALETTE_BLUE),
+                                               x_opa + y_opa);
+    }
+}
+
+static void add_data(lv_timer_t *timer)
+{
+    lv_obj_t *chart = timer->user_data;
+    lv_chart_set_next_value2(chart, lv_chart_get_series_next(chart, NULL), lv_rand(0, 200), lv_rand(0, 1000));
+}
+
+void example_lvgl_demo_ui(lv_obj_t *scr)
+{
+    lv_obj_t *chart = lv_chart_create(scr);
+    lv_obj_set_size(chart, 200, 150);
+    lv_obj_align(chart, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_add_event_cb(chart, draw_event_cb, LV_EVENT_DRAW_PART_BEGIN, NULL);
+    lv_obj_set_style_line_width(chart, 0, LV_PART_ITEMS);   /*Remove the lines*/
+
+    lv_chart_set_type(chart, LV_CHART_TYPE_SCATTER);
+
+    lv_chart_set_axis_tick(chart, LV_CHART_AXIS_PRIMARY_X, 5, 5, 5, 1, true, 30);
+    lv_chart_set_axis_tick(chart, LV_CHART_AXIS_PRIMARY_Y, 10, 5, 6, 5, true, 50);
+
+    lv_chart_set_range(chart, LV_CHART_AXIS_PRIMARY_X, 0, 200);
+    lv_chart_set_range(chart, LV_CHART_AXIS_PRIMARY_Y, 0, 1000);
+
+    lv_chart_set_point_count(chart, 50);
+
+    lv_chart_series_t *ser = lv_chart_add_series(chart, lv_palette_main(LV_PALETTE_RED), LV_CHART_AXIS_PRIMARY_Y);
+    for (int i = 0; i < 50; i++) {
+        lv_chart_set_next_value2(chart, ser, lv_rand(0, 200), lv_rand(0, 1000));
+    }
+
+    lv_timer_create(add_data, 100, chart);
+}

examples/peripherals/lcd/rgb_panel/main/rgb_lcd_example_main.c

@@ -0,0 +1,186 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+#include <stdio.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_timer.h"
+#include "esp_lcd_panel_ops.h"
+#include "esp_lcd_panel_rgb.h"
+#include "driver/gpio.h"
+#include "esp_err.h"
+#include "esp_log.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     (10 * 1000 * 1000)
+#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_BK_LIGHT       39
+#define EXAMPLE_PIN_NUM_HSYNC          47
+#define EXAMPLE_PIN_NUM_VSYNC          48
+#define EXAMPLE_PIN_NUM_DE             45
+#define EXAMPLE_PIN_NUM_PCLK           21
+#define EXAMPLE_PIN_NUM_DATA0          3  // B0
+#define EXAMPLE_PIN_NUM_DATA1          4  // B1
+#define EXAMPLE_PIN_NUM_DATA2          5  // B2
+#define EXAMPLE_PIN_NUM_DATA3          6  // B3
+#define EXAMPLE_PIN_NUM_DATA4          7  // B4
+#define EXAMPLE_PIN_NUM_DATA5          8  // G0
+#define EXAMPLE_PIN_NUM_DATA6          9  // G1
+#define EXAMPLE_PIN_NUM_DATA7          10 // G2
+#define EXAMPLE_PIN_NUM_DATA8          11 // G3
+#define EXAMPLE_PIN_NUM_DATA9          12 // G4
+#define EXAMPLE_PIN_NUM_DATA10         13 // G5
+#define EXAMPLE_PIN_NUM_DATA11         14 // R0
+#define EXAMPLE_PIN_NUM_DATA12         15 // R1
+#define EXAMPLE_PIN_NUM_DATA13         16 // R2
+#define EXAMPLE_PIN_NUM_DATA14         17 // R3
+#define EXAMPLE_PIN_NUM_DATA15         18 // R4
+#define EXAMPLE_PIN_NUM_DISP_EN        -1
+
+// The pixel number in horizontal and vertical
+#define EXAMPLE_LCD_H_RES              480
+#define EXAMPLE_LCD_V_RES              272
+
+#define EXAMPLE_LVGL_TICK_PERIOD_MS    2
+
+extern void example_lvgl_demo_ui(lv_obj_t *scr);
+
+static bool example_notify_lvgl_flush_ready(esp_lcd_panel_handle_t panel, esp_lcd_rgb_panel_event_data_t *event_data, void *user_data)
+{
+    lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_data;
+    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);
+}
+
+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
+
+    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));
+
+    ESP_LOGI(TAG, "Install RGB panel driver");
+    esp_lcd_panel_handle_t panel_handle = NULL;
+    esp_lcd_rgb_panel_config_t panel_config = {
+        .data_width = 16, // RGB565 in parallel mode, thus 16bit in width
+        .psram_trans_align = 64,
+        .clk_src = LCD_CLK_SRC_PLL160M,
+        .disp_gpio_num = EXAMPLE_PIN_NUM_DISP_EN,
+        .pclk_gpio_num = EXAMPLE_PIN_NUM_PCLK,
+        .vsync_gpio_num = EXAMPLE_PIN_NUM_VSYNC,
+        .hsync_gpio_num = EXAMPLE_PIN_NUM_HSYNC,
+        .de_gpio_num = EXAMPLE_PIN_NUM_DE,
+        .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,
+            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,
+        },
+        .timings = {
+            .pclk_hz = EXAMPLE_LCD_PIXEL_CLOCK_HZ,
+            .h_res = EXAMPLE_LCD_H_RES,
+            .v_res = EXAMPLE_LCD_V_RES,
+            // The following parameters should refer to LCD spec
+            .hsync_back_porch = 68,
+            .hsync_front_porch = 20,
+            .hsync_pulse_width = 5,
+            .vsync_back_porch = 18,
+            .vsync_front_porch = 4,
+            .vsync_pulse_width = 1,
+            .flags.pclk_active_neg = 1, // RGB data is clocked out on falling edge
+        },
+        .flags.fb_in_psram = 1, // allocate frame buffer in PSRAM
+        .on_frame_trans_done = example_notify_lvgl_flush_ready,
+        .user_ctx = &disp_drv,
+    };
+    ESP_ERROR_CHECK(esp_lcd_new_rgb_panel(&panel_config, &panel_handle));
+
+    ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
+    ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
+
+    ESP_LOGI(TAG, "Turn on LCD backlight");
+    gpio_set_level(EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_ON_LEVEL);
+
+    ESP_LOGI(TAG, "Initialize LVGL library");
+    lv_init();
+    // alloc draw buffers used by LVGL from PSRAM
+    lv_color_t *buf1 = heap_caps_malloc(EXAMPLE_LCD_H_RES * 100 * sizeof(lv_color_t), MALLOC_CAP_SPIRAM);
+    assert(buf1);
+    lv_color_t *buf2 = heap_caps_malloc(EXAMPLE_LCD_H_RES * 100 * sizeof(lv_color_t), MALLOC_CAP_SPIRAM);
+    assert(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));
+
+    ESP_LOGI(TAG, "Display LVGL Scatter Chart");
+    lv_obj_t *scr = lv_disp_get_scr_act(disp);
+    example_lvgl_demo_ui(scr);
+
+    while (1) {
+        // raise the task priority of LVGL and/or reduce the handler period can improve the performance
+        vTaskDelay(pdMS_TO_TICKS(10));
+        // The task running lv_timer_handler should have lower priority than that running `lv_tick_inc`
+        lv_timer_handler();
+    }
+}

examples/peripherals/lcd/rgb_panel/sdkconfig.defaults

@@ -0,0 +1,4 @@
+CONFIG_LV_MEM_CUSTOM=y
+CONFIG_LV_MEMCPY_MEMSET_STD=y
+CONFIG_LV_USE_USER_DATA=y
+CONFIG_LV_USE_CHART=y

examples/peripherals/lcd/rgb_panel/sdkconfig.defaults.esp32s3

@@ -0,0 +1,5 @@
+CONFIG_ESP32S3_SPIRAM_SUPPORT=y
+CONFIG_SPIRAM_MODE_OCT=y
+CONFIG_SPIRAM_SPEED_80M=y
+# Can't set the FPS too high due to the limitation of PSRAM bandwidth
+CONFIG_LV_DISP_DEF_REFR_PERIOD=100