显示接口

要为 LVGL 注册一个显示器，需要初始化 lv_disp_draw_buf_t 和 lv_disp_drv_t 变量。

• lv_disp_draw_buf_t 包含内部图形缓冲区，称为绘图缓冲区。

• lv_disp_drv_t 包含与显示器交互和操作低级绘图行为的回调函数。

绘图缓冲区

绘图缓冲区是 LVGL 用来渲染屏幕内容的简单数组。 渲染完成后，绘图缓冲区的内容会通过显示驱动程序中设置的 flush_cb 函数发送到显示器（见下文）。

可以通过 lv_disp_draw_buf_t 变量初始化绘图缓冲区，如下所示：

/*用于存储缓冲区的静态或全局变量*/
static lv_disp_draw_buf_t disp_buf;

/*静态或全局缓冲区。第二个缓冲区是可选的*/
static lv_color_t buf_1[MY_DISP_HOR_RES * 10];
static lv_color_t buf_2[MY_DISP_HOR_RES * 10];

/*使用缓冲区初始化 `disp_buf`。如果只有一个缓冲区，使用 NULL 替代 buf_2 */
lv_disp_draw_buf_init(&disp_buf, buf_1, buf_2, MY_DISP_HOR_RES*10);

注意，lv_disp_draw_buf_t 必须是静态、全局或动态分配的变量。它不能是局部变量，因为局部变量在作用域结束时会被销毁。

如上所示，绘图缓冲区可以小于屏幕。在这种情况下，较大的区域会被分成适合绘图缓冲区的小段进行重绘。 如果只有一个小区域发生变化（例如按下按钮），则只会刷新该区域。

较大的缓冲区会带来更好的性能，但当缓冲区大小超过屏幕的 1/10 时，性能提升并不显著。 因此，建议将绘图缓冲区的大小设置为至少屏幕的 1/10。

缓冲模式

可以通过多种设置调整绘图缓冲区的数量以及缓冲/刷新模式。

可以使用 基准测试示例 测量不同配置的性能。

单缓冲区

如果只使用一个缓冲区，LVGL 会将屏幕内容绘制到该缓冲区并发送到显示器。 LVGL 需要等待缓冲区内容发送到显示器后才能在缓冲区中绘制新内容。

双缓冲区

如果使用两个缓冲区，LVGL 可以在一个缓冲区中绘制内容，同时将另一个缓冲区的内容在后台发送到显示器。 应使用 DMA 或其他硬件将数据传输到显示器，以便 MCU 可以继续绘制。 这样，显示的渲染和刷新操作可以并行进行。

全屏刷新

在显示驱动程序（lv_disp_drv_t）中启用 full_refresh 位会强制 LVGL 始终重绘整个屏幕。这在 单缓冲区 和 双缓冲区 模式下都适用。 如果启用了 full_refresh 并提供了两个屏幕大小的绘图缓冲区，LVGL 的显示处理将像“传统”双缓冲一样工作。 这意味着 flush_cb 回调只需更新帧缓冲区的地址（color_p 参数）。 如果 MCU 有 LCD 控制器外设，应使用此配置，而不应使用通过串行链接访问的外部显示控制器（例如 ILI9341 或 SSD1963）。后者通常太慢，无法在全屏重绘时保持高帧率。

直接模式

如果在显示驱动程序中启用了 direct_mode 标志，LVGL 将直接绘制到 屏幕大小的帧缓冲区。即绘图缓冲区需要是屏幕大小。 在这种情况下，flush_cb 只会在所有脏区域重绘完成后调用一次。 使用 direct_mode 时，帧缓冲区始终包含应显示在屏幕上的当前帧。 如果提供了 2 个帧缓冲区作为绘图缓冲区，LVGL 将交替使用缓冲区，但始终只绘制脏区域。 因此，需要在 flush_cb 中同步这两个缓冲区，如下所示：

1. 显示由 color_p 指向的帧缓冲区。

2. 将重绘区域从 color_p 复制到另一个缓冲区。

要获取需要复制的重绘区域，请使用以下函数： _lv_refr_get_disp_refreshing() 返回正在刷新的显示器。 disp->inv_areas[LV_INV_BUF_SIZE] 包含无效区域。 disp->inv_area_joined[LV_INV_BUF_SIZE] 如果为 1，则该区域已合并到另一个区域，应忽略。 disp->inv_p 表示 inv_areas 中有效元素的数量。

显示驱动程序

缓冲区初始化完成后，需要：

1. 使用 lv_disp_drv_init(&disp_drv) 初始化 lv_disp_drv_t 显示驱动程序。

2. 设置其字段。

3. 使用 lv_disp_drv_register(&disp_drv) 在 LVGL 中注册。

注意，lv_disp_drv_t 也需要是静态、全局或动态分配的变量。

必须字段

在最简单的情况下，只需设置 lv_disp_drv_t 的以下字段：

• draw_buf 指向已初始化的 lv_disp_draw_buf_t 变量的指针。

• hor_res 显示器的水平分辨率（像素）。

• ver_res 显示器的垂直分辨率（像素）。

• flush_cb 一个回调函数，用于将缓冲区的内容复制到显示器的特定区域。 在刷新完成时需要调用 lv_disp_flush_ready(&disp_drv)。 LVGL 可能会分块渲染屏幕，因此可能多次调用 flush_cb。要查看当前是否为渲染的最后一块，可以使用 lv_disp_flush_is_last(&disp_drv)。

可选字段

有一些可选的显示驱动程序数据字段：

• physical_hor_res 全屏/物理显示器的水平分辨率（像素）。仅在不使用全屏时设置（默认为 -1 / 与 hor_res 相同）。

• physical_ver_res 全屏/物理显示器的垂直分辨率（像素）。仅在不使用全屏时设置（默认为 -1 / 与 ver_res 相同）。

• offset_x 全屏/物理显示器的水平偏移量（像素）。仅在不使用全屏时设置（默认为 0）。

• offset_y 全屏/物理显示器的垂直偏移量（像素）。仅在不使用全屏时设置（默认为 0）。

• color_chroma_key 在色度键图像上绘制为透明的颜色。默认设置为 lv_conf.h 中的 LV_COLOR_CHROMA_KEY。

• anti_aliasing 使用抗锯齿（边缘平滑）。如果 lv_conf.h 中的 LV_COLOR_DEPTH 设置为至少 16，则默认启用。

• rotated 和 sw_rotate 请参阅下面的 旋转 部分。

• screen_transp 如果为 1，屏幕本身也可以具有透明性。lv_conf.h 中必须启用 LV_COLOR_SCREEN_TRANSP，并且 LV_COLOR_DEPTH 必须为 32。

• user_data 驱动程序的自定义 void 用户数据。

• full_refresh 始终重绘整个屏幕（见上文）。

• direct_mode 直接绘制到帧缓冲区（见上文）。

一些其他可选回调使得与单色、灰度或其他非标准 RGB 显示器的工作更容易和更优化：

• rounder_cb 将要重绘的区域的坐标四舍五入。例如，2x2 像素可以转换为 2x8。 如果显示控制器只能刷新具有特定高度或宽度的区域（通常是单色显示器的 8 像素高度），可以使用它。

• set_px_cb 一个自定义函数，用于写入绘图缓冲区。如果显示器具有特殊的颜色格式（例如 1 位单色、2 位灰度等），可以使用它以更紧凑的方式存储像素在绘图缓冲区中。 这样，lv_disp_draw_buf_t 中使用的缓冲区可以更小，只需容纳给定区域大小所需的位数。注意，使用 set_px_cb 渲染比正常渲染更慢。

• monitor_cb 一个回调函数，告诉刷新了多少像素以及用了多长时间。当最后一块渲染并发送到显示器时调用。

• clean_dcache_cb 一个用于清除与显示器相关的任何缓存的回调。

• render_start_cb 一个回调函数，通知显示驱动程序渲染已开始。如果渲染比 VSYNC 周期快，则也可以用它来等待 VSYNC 开始渲染。

LVGL 内置支持多个 GPU（请参阅 lv_conf.h），但如果需要其他功能，可以使用这些函数使 LVGL 使用 GPU：

• gpu_fill_cb 用颜色填充内存中的一个区域。

• gpu_wait_cb 如果任何 GPU 函数在 GPU 仍在工作时返回，LVGL 将在需要时使用此函数以确保 GPU 渲染已准备好。

示例

综合起来如下所示：

static lv_disp_drv_t disp_drv;          /*用于保存驱动程序的变量。必须是静态或全局的。*/
lv_disp_drv_init(&disp_drv);            /*基本初始化*/
disp_drv.draw_buf = &disp_buf;          /*设置已初始化的缓冲区*/
disp_drv.flush_cb = my_flush_cb;        /*设置一个刷新回调以绘制到显示器*/
disp_drv.hor_res = 320;                 /*设置水平分辨率（像素）*/
disp_drv.ver_res = 240;                 /*设置垂直分辨率（像素）*/

lv_disp_t * disp;
disp = lv_disp_drv_register(&disp_drv); /*注册驱动程序并保存创建的显示对象*/

以下是一些简单的回调示例：

void my_flush_cb(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
    /*最简单的情况（但也是最慢的），将所有像素逐个放到屏幕上
     *`put_px` 只是一个示例，需要由您实现。*/
    int32_t x, y;
    for(y = area->y1; y <= area->y2; y++) {
        for(x = area->x1; x <= area->x2; x++) {
            put_px(x, y, *color_p);
            color_p++;
        }
    }

    /* 重要!!!
     * 通知图形库您已完成刷新*/
    lv_disp_flush_ready(disp_drv);
}

void my_gpu_fill_cb(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, const lv_area_t * dest_area, const lv_area_t * fill_area, lv_color_t color);
{
    /*这是一个示例代码，应该由您的 GPU 完成*/
    uint32_t x, y;
    dest_buf += dest_width * fill_area->y1; /*转到第一行*/

    for(y = fill_area->y1; y < fill_area->y2; y++) {
        for(x = fill_area->x1; x < fill_area->x2; x++) {
            dest_buf[x] = color;
        }
        dest_buf+=dest_width;    /*转到下一行*/
    }
}


void my_rounder_cb(lv_disp_drv_t * disp_drv, lv_area_t * area)
{
  /* 根据需要更新区域。
   * 例如，它使区域仅从第 8 行开始，并具有 Nx8 像素高度。*/
   area->y1 = area->y1 & 0x07;
   area->y2 = (area->y2 & 0x07) + 8;
}

void my_set_px_cb(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa)
{
   /* 根据显示器的要求写入缓冲区。
    * 例如，它仅为垂直映射的单色显示器写入 1 位。*/
   buf += buf_w * (y >> 3) + x;
   if(lv_color_brightness(color) > 128) (*buf) |= (1 << (y % 8));
   else (*buf) &= ~(1 << (y % 8));
}

void my_monitor_cb(lv_disp_drv_t * disp_drv, uint32_t time, uint32_t px)
{
  printf("%d px refreshed in %d ms\n", time, ms);
}

void my_clean_dcache_cb(lv_disp_drv_t * disp_drv, uint32)
{
  /* Cortex-M (CMSIS) 的示例 */
  SCB_CleanInvalidateDCache();
}

其他选项

旋转

LVGL 支持以 90 度为增量旋转显示器。您可以选择使用软件旋转或硬件旋转。

如果选择软件旋转（sw_rotate 标志设置为 1），LVGL 将为您执行旋转。您的驱动程序可以并且应该假设屏幕宽度和高度没有变化。只需正常将像素刷新到显示器即可。软件旋转不需要在 flush_cb 回调中添加额外逻辑。

执行软件旋转会有明显的开销。硬件旋转可用于避免不必要的减速。在这种模式下，LVGL 绘制到缓冲区中，就像您的屏幕宽度和高度已交换一样。您需要自己旋转提供的像素。

显示器初始化时的默认旋转可以使用 rotated 标志设置。可用选项为 LV_DISP_ROT_NONE、LV_DISP_ROT_90、LV_DISP_ROT_180 或 LV_DISP_ROT_270。旋转值是相对于您顺时针旋转物理显示器的方向。因此，LV_DISP_ROT_90 表示您将硬件顺时针旋转 90 度，显示器逆时针旋转 90 度以补偿。

（对于从 7.10.0 及更早版本升级的用户：这些新的旋转枚举值与旧的 0/1 系统匹配，用于旋转 90 度，因此旧代码应继续按预期工作。默认情况下，软件旋转也被禁用以保持兼容性。）

可以使用 lv_disp_set_rotation(disp, rot) API 在运行时更改显示旋转。

软件旋转是一个新功能，因此根据您的配置可能会出现一些故障/错误。如果您遇到问题，请在 GitHub 上打开一个问题。

解耦显示刷新计时器

通常，每 LV_DISP_DEF_REFR_PERIOD 毫秒（在 lv_conf.h 中设置）检查并重绘脏区域（即无效区域）。 但是，在某些情况下，您可能需要更精确地控制显示刷新时间，例如与 VSYNC 或 TE 信号同步渲染。

您可以通过以下方式实现：

/*删除原始显示刷新计时器*/
lv_timer_del(disp->refr_timer);
disp->refr_timer = NULL;


/*在需要刷新脏区域的任何地方调用此函数*/
_lv_disp_refr_timer(NULL);

如果您有多个显示器，请在 _lv_disp_refr_timer(NULL); 之前调用 lv_disp_set_deafult(disp1); 选择要刷新的显示器。

注意，lv_timer_handler() 和 _lv_disp_refr_timer() 不能同时运行。

如果启用了性能监视器，则需要将 LV_DISP_DEF_REFR_PERIOD 的值设置为与显示器的刷新周期一致，以确保统计结果正确。

进一步阅读

• lv_port_disp_template.c 用于您自己的驱动程序的模板。

• 绘图 了解有关 LVGL 中渲染工作原理的更多信息。

• 显示功能 了解有关更高级显示功能的更多信息。

API

@description Display Driver HAL interface header file

Typedefs

typedef struct _lv_disp_draw_buf_t lv_disp_draw_buf_t

Structure for holding display buffer information.

typedef struct _lv_disp_drv_t lv_disp_drv_t

Display Driver structure to be registered by HAL. Only its pointer will be saved in lv_disp_t so it should be declared as static lv_disp_drv_t my_drv or allocated dynamically.

typedef struct _lv_disp_t lv_disp_t

Display structure.

Note

lv_disp_drv_t should be the first member of the structure.

Enums

enum lv_disp_rot_t

Values:

enumerator LV_DISP_ROT_NONE

enumerator LV_DISP_ROT_90

enumerator LV_DISP_ROT_180

enumerator LV_DISP_ROT_270

Functions

void lv_disp_drv_init(lv_disp_drv_t *driver)

Initialize a display driver with default values. It is used to have known values in the fields and not junk in memory. After it you can safely set only the fields you need.

Parameters

driver -- pointer to driver variable to initialize

void lv_disp_draw_buf_init(lv_disp_draw_buf_t *draw_buf, void *buf1, void *buf2, uint32_t size_in_px_cnt)

Initialize a display buffer

Parameters

• draw_buf -- pointer lv_disp_draw_buf_t variable to initialize

• buf1 -- A buffer to be used by LVGL to draw the image. Always has to specified and can't be NULL. Can be an array allocated by the user. E.g. static lv_color_t disp_buf1[1024 * 10] Or a memory address e.g. in external SRAM

• buf2 -- Optionally specify a second buffer to make image rendering and image flushing (sending to the display) parallel. In the disp_drv->flush you should use DMA or similar hardware to send the image to the display in the background. It lets LVGL to render next frame into the other buffer while previous is being sent. Set to NULL if unused.

• size_in_px_cnt -- size of the buf1 and buf2 in pixel count.

lv_disp_t *lv_disp_drv_register(lv_disp_drv_t *driver)

Register an initialized display driver. Automatically set the first display as active.

Parameters

driver -- pointer to an initialized 'lv_disp_drv_t' variable. Only its pointer is saved!

Returns

pointer to the new display or NULL on error

void lv_disp_drv_update(lv_disp_t *disp, lv_disp_drv_t *new_drv)

Update the driver in run time.

Parameters

• disp -- pointer to a display. (return value of lv_disp_drv_register)

• new_drv -- pointer to the new driver

void lv_disp_remove(lv_disp_t *disp)

Remove a display

Parameters

disp -- pointer to display

void lv_disp_set_default(lv_disp_t *disp)

Set a default display. The new screens will be created on it by default.

Parameters

disp -- pointer to a display

lv_disp_t *lv_disp_get_default(void)

Get the default display

Returns

pointer to the default display

lv_coord_t lv_disp_get_hor_res(lv_disp_t *disp)

Get the horizontal resolution of a display

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

the horizontal resolution of the display

lv_coord_t lv_disp_get_ver_res(lv_disp_t *disp)

Get the vertical resolution of a display

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

the vertical resolution of the display

lv_coord_t lv_disp_get_physical_hor_res(lv_disp_t *disp)

Get the full / physical horizontal resolution of a display

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

the full / physical horizontal resolution of the display

lv_coord_t lv_disp_get_physical_ver_res(lv_disp_t *disp)

Get the full / physical vertical resolution of a display

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

the full / physical vertical resolution of the display

lv_coord_t lv_disp_get_offset_x(lv_disp_t *disp)

Get the horizontal offset from the full / physical display

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

the horizontal offset from the full / physical display

lv_coord_t lv_disp_get_offset_y(lv_disp_t *disp)

Get the vertical offset from the full / physical display

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

the horizontal offset from the full / physical display

bool lv_disp_get_antialiasing(lv_disp_t *disp)

Get if anti-aliasing is enabled for a display or not

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

true: anti-aliasing is enabled; false: disabled

lv_coord_t lv_disp_get_dpi(const lv_disp_t *disp)

Get the DPI of the display

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

dpi of the display

void lv_disp_set_rotation(lv_disp_t *disp, lv_disp_rot_t rotation)

Set the rotation of this display.

Parameters

• disp -- pointer to a display (NULL to use the default display)

• rotation -- rotation angle

lv_disp_rot_t lv_disp_get_rotation(lv_disp_t *disp)

Get the current rotation of this display.

Parameters

disp -- pointer to a display (NULL to use the default display)

Returns

rotation angle

lv_disp_t *lv_disp_get_next(lv_disp_t *disp)

Get the next display.

Parameters

disp -- pointer to the current display. NULL to initialize.

Returns

the next display or NULL if no more. Give the first display when the parameter is NULL

lv_disp_draw_buf_t *lv_disp_get_draw_buf(lv_disp_t *disp)

Get the internal buffer of a display

Parameters

disp -- pointer to a display

Returns

pointer to the internal buffers

void lv_disp_drv_use_generic_set_px_cb(lv_disp_drv_t *disp_drv, lv_img_cf_t cf)

struct _lv_disp_draw_buf_t

#include <lv_hal_disp.h>

Structure for holding display buffer information.

Public Members

void *buf1

First display buffer.

void *buf2

Second display buffer.

void *buf_act

uint32_t size

volatile int flushing

volatile int flushing_last

volatile uint32_t last_area

volatile uint32_t last_part

struct _lv_disp_drv_t

#include <lv_hal_disp.h>

Display Driver structure to be registered by HAL. Only its pointer will be saved in lv_disp_t so it should be declared as static lv_disp_drv_t my_drv or allocated dynamically.

Public Members

lv_coord_t hor_res

Horizontal resolution.

lv_coord_t ver_res

Vertical resolution.

lv_coord_t physical_hor_res

Horizontal resolution of the full / physical display. Set to -1 for fullscreen mode.

lv_coord_t physical_ver_res

Vertical resolution of the full / physical display. Set to -1 for fullscreen mode.

lv_coord_t offset_x

Horizontal offset from the full / physical display. Set to 0 for fullscreen mode.

lv_coord_t offset_y

Vertical offset from the full / physical display. Set to 0 for fullscreen mode.

lv_disp_draw_buf_t *draw_buf

Pointer to a buffer initialized with lv_disp_draw_buf_init(). LVGL will use this buffer(s) to draw the screens contents

uint32_t direct_mode

1: Use screen-sized buffers and draw to absolute coordinates

uint32_t full_refresh

1: Always make the whole screen redrawn

uint32_t sw_rotate

1: use software rotation (slower)

uint32_t antialiasing

1: anti-aliasing is enabled on this display.

uint32_t rotated

1: turn the display by 90 degree.

Warning

Does not update coordinates for you!

uint32_t screen_transp

uint32_t dpi

Handle if the screen doesn't have a solid (opa == LV_OPA_COVER) background. Use only if required because it's slower.

void (*flush_cb)(struct _lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p)

DPI (dot per inch) of the display. Default value is LV_DPI_DEF. MANDATORY: Write the internal buffer (draw_buf) to the display. 'lv_disp_flush_ready()' has to be called when finished

void (*rounder_cb)(struct _lv_disp_drv_t *disp_drv, lv_area_t *area)

OPTIONAL: Extend the invalidated areas to match with the display drivers requirements E.g. round y to, 8, 16 ..) on a monochrome display

void (*set_px_cb)(struct _lv_disp_drv_t *disp_drv, uint8_t *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa)

OPTIONAL: Set a pixel in a buffer according to the special requirements of the display Can be used for color format not supported in LittelvGL. E.g. 2 bit -> 4 gray scales

Note

Much slower then drawing with supported color formats.

void (*clear_cb)(struct _lv_disp_drv_t *disp_drv, uint8_t *buf, uint32_t size)

void (*monitor_cb)(struct _lv_disp_drv_t *disp_drv, uint32_t time, uint32_t px)

OPTIONAL: Called after every refresh cycle to tell the rendering and flushing time + the number of flushed pixels

void (*wait_cb)(struct _lv_disp_drv_t *disp_drv)

OPTIONAL: Called periodically while lvgl waits for operation to be completed. For example flushing or GPU User can execute very simple tasks here or yield the task

void (*clean_dcache_cb)(struct _lv_disp_drv_t *disp_drv)

OPTIONAL: Called when lvgl needs any CPU cache that affects rendering to be cleaned

void (*drv_update_cb)(struct _lv_disp_drv_t *disp_drv)

OPTIONAL: called when driver parameters are updated

void (*render_start_cb)(struct _lv_disp_drv_t *disp_drv)

OPTIONAL: called when start rendering

lv_color_t color_chroma_key

On CHROMA_KEYED images this color will be transparent. LV_COLOR_CHROMA_KEY by default. (lv_conf.h)

lv_draw_ctx_t *draw_ctx

void (*draw_ctx_init)(struct _lv_disp_drv_t *disp_drv, lv_draw_ctx_t *draw_ctx)

void (*draw_ctx_deinit)(struct _lv_disp_drv_t *disp_drv, lv_draw_ctx_t *draw_ctx)

size_t draw_ctx_size

void *user_data

Custom display driver user data

struct _lv_disp_t

#include <lv_hal_disp.h>

Display structure.

Note

lv_disp_drv_t should be the first member of the structure.

Public Members

struct _lv_disp_drv_t *driver

< Driver to the display A timer which periodically checks the dirty areas and refreshes them

lv_timer_t *refr_timer

The theme assigned to the screen

struct _lv_theme_t *theme

struct _lv_obj_t **screens

Screens of the display Array of screen objects.

struct _lv_obj_t *act_scr

Currently active screen on this display

struct _lv_obj_t *prev_scr

Previous screen. Used during screen animations

struct _lv_obj_t *scr_to_load

The screen prepared to load in lv_scr_load_anim

struct _lv_obj_t *top_layer

See

lv_disp_get_layer_top

struct _lv_obj_t *sys_layer

See

lv_disp_get_layer_sys

uint32_t screen_cnt

uint8_t draw_prev_over_act

1: Draw previous screen over active screen

uint8_t del_prev

1: Automatically delete the previous screen when the screen load animation is ready

uint8_t rendering_in_progress

1: The current screen rendering is in progress

lv_opa_t bg_opa

Opacity of the background color or wallpaper

lv_color_t bg_color

Default display color when screens are transparent

const void *bg_img

An image source to display as wallpaper

lv_area_t inv_areas[LV_INV_BUF_SIZE]

Invalidated (marked to redraw) areas

uint8_t inv_area_joined[LV_INV_BUF_SIZE]

uint16_t inv_p

int32_t inv_en_cnt

uint32_t last_activity_time

Last time when there was activity on this display