Art_Pi学习笔记5.1：优化LVGL软件包提高刷屏的速度

发布于 2020-12-31 15:02:00 浏览：11119 订阅该版

使用littlevgl2rtt软件包成功点亮Art-Pi多媒体扩展版之后，一直心心念RGB屏幕接口。于是兴冲冲的下单了一块正点原子的4.3寸RGB触摸屏来用。收到屏幕之后，一路轻车熟路，配置，编译，下载，一看傻了，怎么刷屏的速度比多媒体扩展板的SPI屏还慢。有多慢，是眼见一行一行的刷新的慢！

于是，论坛翻贴，QQ群请教大佬，经过三天三夜的摸索，总算优化到一个自己比较满意的结果了。再此，要感谢各位大佬无私的提供技术支持，帮忙解决问题。现在我把过程记录下来，方便后来的小伙伴遇到相同问题的时候有解决的思路。当然，也希望有更好的方法的小伙伴们提出更好的优化方案。

开发工具：
RT-Thread Studio
OS版本：
4.0.3
开发板：
Art-Pi + 正点原子4.3寸RGB屏
软件包：
Littlevgl2rtt（latest）
温馨提示：
下面的优化方案是基于该软件包的优化，如果是自己一直lvgl的不再此讨论范围。

首先是软件包配置
硬件上要打开LCD和SDRAM
 ![image.png](/uploads/20201231/adf817d140a6a534de24dce2735769b7.png)

软件包配置，这里打开sample，就可以先用软件包的演示查看效果
 ![image.png](/uploads/20201231/591a84eb2030cae5d34e222e6f8ce9c9.png)

正常情况下，这样配置后保存，编译通过，下载。就可以正常工作了。不过会发现图像切换速度非常慢，非常卡。

下面就来谈谈如何优化，RGB屏使用的是LTDC接口推屏的，这部分驱动其实rtt已经帮我们做好了，将LTDC接口封装为lcd设备，lvgl调用lcd设备接口对设备进行读写。该函数位于drv_lcd.c文件中，首先想要优化的是这个函数，不过暂时没想到要怎么优化。后面根据大佬的建议，lvlg不要通过这个接口来刷屏，而是直接刷屏，而且要开启DMA2D，用DMA2D来刷。

开启DMA2D，在stm32h7xx_hal_conf.h文件中，打开宏定义
 ![image.png](/uploads/20201231/5bfe3ea142845239a4c351d7ac51e224.png)

在stm32h7xx_hal_msp.c文件中添加，硬件层初始化代码。
 ![image.png](/uploads/20201231/a36f802a0eaed5d8c8cbd7703bd582f9.png)

然后在drv_lcd.c文件中添加DMA2D软件层面的初始化代码
 ![image.png](/uploads/20201231/ce9bef960dd2f716fa1c600d19dcef08.png)

并且在drv_lcd_hw_init()函数中调用该初始化函数
 ![image.png](/uploads/20201231/a37cd4c3a10c2326e760ea99babc82f2.png)

到这里，DMA2D的初始化就算是完成了，接下来要怎么用呢？
去软件包内修改littlevgl2rtt.c文件，
首先修改littlevgl2rtt_init()函数。
屏蔽掉原有的缓存buf，因为该buf取值较小，而art-pi上有使用SDRAM，拥有较大的内存空间，我们可以直接申请和屏幕像素相对应大小的缓存空间，而且申请两个，因为lvgl支持双刷buffer。
 ![image.png](/uploads/20201231/4acb87a734ca5bf470407659acc01be3.png)

记得屏蔽掉原来buf申请内存空间的代码
 ![image.png](/uploads/20201231/06db5a279dd95416374aa8ff0a041a2c.png)

接下来改单刷buffer为双刷buffer
 ![image.png](/uploads/20201231/c4fe960ce0108bc4cdebd3f00bbccd40.png)

然后改刷屏的函数，lcd_fb_flush()，将函数中的内容全部屏蔽掉，改成一下代码。
 ![image.png](/uploads/20201231/b8fd0e67abd097da2ba0bfe47b56f9a1.png)

这里提供了两种DMA2D的方式，一种是中断方式，一种是轮询方式。如果使用中断方式，需要添加DMA2D中断处理函数。
 ![image.png](/uploads/20201231/b546e713f40c3f68210fd6eca2c348cd.png)

两者的区别就是，
采用轮询方式的，则一直等待DMA2D传输结束，然后通过函数lv_disp_flush_ready()函数通过LVGL已经完成刷屏。
采用中断方式的，则是在中断处理函数中调用函数lv_disp_flush_ready()函数通过LVGL已经完成刷屏。

通过上述优化之后，刷屏速度大大提高。个人已经比较满意了，可以达到项目应用的要求了。当然还有更好的方法，比如自己移植LVGL而不是使用软件包，或者是直接用DMA2D寄存器操作来刷屏，这些操作都比较高级，作为初学者的我还没学会。哪天我学会了，再来分享。或者有大佬可以共享一下教程，众乐乐一下。

再次，感谢在问题解决过程中给我提供帮助的各位大佬们！

参考文档：

LVGL 优化帧率技巧_无人等人的博客-CSDN博客
[https://blog.csdn.net/weixin_43862847/article/details/109318017]

f429 discovery开发版 LVGL移植（带操作系统）_无人等人的博客-CSDN博客
[https://blog.csdn.net/weixin_43862847/article/details/109056321]

stm32 DMA2D使用中断LVGL,提高LVGL帧率_紫枫洛天的博客-CSDN博客
[https://blog.csdn.net/a2267542848/article/details/111163633]

LVGL在rt-thread上的移植 - hechunc的个人空间 - OSCHINA - 中文开源技术交流社区
https://my.oschina.net/hechunc/blog/4535663

**相关文章：**
[Art-Pi学习笔记10：优化多媒体扩展板的音频驱动添加录音功能](https://club.rt-thread.org/ask/article/2872.html)
[Art-Pi学习笔记9：如何使用art-pi的多媒体扩展板播放TF卡中的音乐文件](https://club.rt-thread.org/ask/article/2849.html)
[Art-Pi学习笔记9：如何为Art-pi的内部flash设置读保护](https://club.rt-thread.org/ask/article/2568.html)
[Art_Pi学习笔记8：使用AHT10温湿度模块](https://club.rt-thread.org/ask/article/2543.html)
[Art_Pi学习笔记7：自己添加硬件定时器设备HWTIMER](https://club.rt-thread.org/ask/article/2492.html)
[Art_Pi学习笔记6：驱动PWM输出](https://club.rt-thread.org/ask/article/2483.html)
[Art-Pi学习笔记5_4：在littlevgl中显示二维码](https://club.rt-thread.org/ask/article/2698.html)
[Art-Pi学习笔记5_3：在littlevgl软件包中显示中文字体](https://club.rt-thread.org/ask/article/2695.html)
[Art_Pi学习笔记5.2：LVGL模拟器安装在VS2019上的避坑指南](https://club.rt-thread.org/ask/article/2470.html)
[Art_Pi学习笔记5.1：优化LVGL软件包提高刷屏的速度](https://club.rt-thread.org/ask/article/2464.html)
[Art_Pi学习笔记5：移植LittleVGL2RTT软件包驱动多媒体扩展屏](https://club.rt-thread.org/ask/article/2434.html)
[Art_Pi学习笔记4：驱动多媒体扩展版的LCD和触摸功能](https://club.rt-thread.org/ask/article/2436.html)
[Art_Pi学习笔记3：学习驱动wifi模块AP6212](https://club.rt-thread.org/ask/article/2429.html)
[Art_Pi学习笔记2：驱动片外SPI_FLASH_W25Q128](https://club.rt-thread.org/ask/article/2423.html)
[Art-Pi学习笔记1：驱动SDIO和USB设备做TF读卡器](https://club.rt-thread.org/ask/article/2417.html)

15 条评论

muecn 2021-01-24

这家伙很懒，什么也没写！

adaphoto 2021-01-25

这家伙很懒，什么也没写！

solomon 2021-01-26

这家伙很懒，什么也没写！

adaphoto 2021-01-28

这家伙很懒，什么也没写！

MCU1680 2021-02-04

这家伙很懒，什么也没写！

adaphoto 2021-02-05

这家伙很懒，什么也没写！

adaphoto 2021-02-05

这家伙很懒，什么也没写！

wirano 2021-02-06

这家伙很懒，什么也没写！

FranHawk 2021-08-13

这家伙很懒，什么也没写！

adaphoto 2021-08-16

这家伙很懒，什么也没写！

@FranHawk 你参考一下吧，这是代码内容，注释部分转码的时候搞丢了。所以中文部分变乱码。代码倒是没问题。
```
#include "littlevgl2rtt.h"
#include "lvgl.h"

static rt_device_t device;
static struct rt_device_graphic_info info;
static struct rt_messagequeue *input_mq;
static int _lv_init = 0;
static lv_disp_drv_t disp_drv;
static lv_disp_buf_t disp_buf;

static void color_to16_maybe(lv_color16_t *dst, lv_color_t *src)
{
#if (LV_COLOR_DEPTH == 16)
    dst->full = src->full;
#else
    dst->ch.blue = src->ch.blue;
    dst->ch.green = src->ch.green;
    dst->ch.red = src->ch.red;
#endif
}

/* Todo: add gpu */
// ʵ��ʹ��lcd_fb_flushˢ���ģ��������Դ��еĴ��롣
#include "board.h"

extern DMA2D_HandleTypeDef hdma2d;
extern LTDC_HandleTypeDef LtdcHandle;

static lv_disp_drv_t *disp_drv_p;

void DMA2D_IRQHandler(void)
{
    rt_enter_critical();

lv_disp_flush_ready( disp_drv_p);

HAL_DMA2D_IRQHandler(&hdma2d);

rt_exit_critical();
}

static void lcd_fb_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
   /*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/
    int16_t w = (area->x2 - area->x1 + 1);
    int16_t h = (area->y2 - area->y1 + 1);
    uint32_t size = w * h;
    disp_drv_p = disp_drv;

hdma2d.Init.Mode         = DMA2D_M2M;
   hdma2d.Init.ColorMode    = DMA2D_OUTPUT_RGB565;
   hdma2d.Init.OutputOffset = (LV_HOR_RES_MAX-w);

hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
   hdma2d.LayerCfg[1].InputAlpha = 0xFF;
   hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565 ;
   hdma2d.LayerCfg[1].InputOffset = 0;

hdma2d.Instance          = DMA2D;

/*##-4- DMA2D Initialization ###############################################*/
   if(HAL_DMA2D_Init(&hdma2d) != HAL_OK)
   {
     Error_Handler();
   }

if(HAL_DMA2D_ConfigLayer(&hdma2d, 1) != HAL_OK)
   {
     /* Initialization Error */
     Error_Handler();
   }

// DMA2D�ж�
     if(HAL_DMA2D_Start_IT(&hdma2d, (uint32_t)color_p, (uint32_t) (LtdcHandle.LayerCfg[0].FBStartAdress) + 2*(LV_HOR_RES_MAX *area->y1 + area->x1), w, h) != HAL_OK)
    {
      /* Initialization Error */
      Error_Handler();
    }

// DMA2D��ѯ
//   if(HAL_DMA2D_Start(&hdma2d, (uint32_t)color_p, (uint32_t) (LtdcHandle.LayerCfg[0].FBStartAdress) + 2*(LV_HOR_RES_MAX *area->y1 + area->x1), w, h) != HAL_OK)
//   {
//     /* Initialization Error */
//     Error_Handler();
//   }
//    HAL_DMA2D_PollForTransfer(&hdma2d,100);
//    lv_disp_flush_ready(disp_drv);
}
//static void lcd_fb_flush(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p)
//{
//    int x1, x2, y1, y2;
//
//    x1 = area->x1;
//    x2 = area->x2;
//    y1 = area->y1;
//    y2 = area->y2;
//
//    /*Return if the area is out the screen*/
//    if (x2 < 0)
//        return;
//    if (y2 < 0)
//        return;
//    if (x1 > info.width - 1)
//        return;
//    if (y1 > info.height - 1)
//        return;
//
//    /*Truncate the area to the screen*/
//    int32_t act_x1 = x1 < 0 ? 0 : x1;
//    int32_t act_y1 = y1 < 0 ? 0 : y1;
//    int32_t act_x2 = x2 > info.width - 1 ? info.width - 1 : x2;
//    int32_t act_y2 = y2 > info.height - 1 ? info.height - 1 : y2;
//
//    uint32_t x;
//    uint32_t y;
//    long int location = 0;
//
//    /* 8 bit per pixel */
//    if (info.bits_per_pixel == 8)
//    {
//        uint8_t *fbp8 = (uint8_t *)info.framebuffer;
//        //TODO color convert maybe
//        for (y = act_y1; y <= act_y2; y++)
//        {
//            for (x = act_x1; x <= act_x2; x++)
//            {
//                location = (x) + (y)*info.width;
//                fbp8[location] = color_p->full;
//                color_p++;
//            }
//
//            color_p += x2 - act_x2;
//        }
//    }
//
//    /* 16 bit per pixel */
//    else if (info.bits_per_pixel == 16)
//    {
//        lv_color16_t *fbp16 = (lv_color16_t *)info.framebuffer;
//
//        for (y = act_y1; y <= act_y2; y++)
//        {
//            for (x = act_x1; x <= act_x2; x++)
//            {
//                location = (x) + (y)*info.width;
//                color_to16_maybe(&fbp16[location], color_p);
//                color_p++;
//            }
//
//            color_p += x2 - act_x2;
//        }
//    }
//
//    /* 24 or 32 bit per pixel */
//    else if (info.bits_per_pixel == 24 || info.bits_per_pixel == 32)
//    {
//        uint32_t *fbp32 = (uint32_t *)info.framebuffer;
//        //TODO
//        for (y = act_y1; y <= act_y2; y++)
//        {
//            for (x = act_x1; x <= act_x2; x++)
//            {
//                location = (x) + (y)*info.width;
//                fbp32[location] = color_p->full;
//                color_p++;
//            }
//
//            color_p += x2 - act_x2;
//        }
//    }
//
//    struct rt_device_rect_info rect_info;
//
//    rect_info.x = x1;
//    rect_info.y = y1;
//    rect_info.width = x2 - x1 + 1;
//    rect_info.height = y2 - y1 + 1;
//    rt_device_control(device, RTGRAPHIC_CTRL_RECT_UPDATE, &rect_info);
//
//    lv_disp_flush_ready(disp_drv);
//}

static void lcd_flush(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p)
{
    int x1, x2, y1, y2;

x1 = area->x1;
    x2 = area->x2;
    y1 = area->y1;
    y2 = area->y2;

/*Return if the area is out the screen*/
    if (x2 < 0)
        return;
    if (y2 < 0)
        return;
    if (x1 > info.width - 1)
        return;
    if (y1 > info.height - 1)
        return;

/*Truncate the area to the screen*/
    int32_t act_x1 = x1 < 0 ? 0 : x1;
    int32_t act_y1 = y1 < 0 ? 0 : y1;
    int32_t act_x2 = x2 > info.width - 1 ? info.width - 1 : x2;
    int32_t act_y2 = y2 > info.height - 1 ? info.height - 1 : y2;

uint32_t x;
    uint32_t y;

//TODO color convert
    for (y = act_y1; y <= act_y2; y++)
    {
        rt_graphix_ops(device)->blit_line((const char *)color_p, act_x1, y, act_x2 - act_x1 + 1);
        color_p += (x2 - x1 + 1);
    }
}

static rt_bool_t touch_down = RT_FALSE;
static rt_int16_t last_x = 0;
static rt_int16_t last_y = 0;

static bool input_read(lv_indev_drv_t *indev_drv, lv_indev_data_t *data)
{
    data->point.x = last_x;
    data->point.y = last_y;
    data->state = (touch_down == RT_TRUE) ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL;

return false;
}

static void lvgl_tick_run(void *p)
{
    while (_lv_init)
    {
        lv_tick_inc(1);
        rt_thread_delay(1);
    }
}

static int lvgl_tick_handler_init(void)
{
    rt_thread_t thread = RT_NULL;
    int ret;

thread = rt_thread_create("lv_tick", lvgl_tick_run, RT_NULL, 512, 6, 10);
    if (thread == RT_NULL)
    {
        return RT_ERROR;
    }
    ret = rt_thread_startup(thread);

return ret;
}

// lv_task_handler ��� API �ӿ��Ƿǳ���Ҫ��,littleVGL �ڲ�����������
// ����ͨ������ӿ��������,�����ҳ���Ϊ��������,����Ҫ���ϵı������Ե���
static void lvgl_task_run(void *p)
{
    // �����Ĭ�ϵ���ʱ��ʽ
    void *buf1 = disp_buf.buf1;

while (_lv_init)    // _lv_init��littlevgl2rtt_init()������ʼ�����֮��ᱻ��λ
    {
        rt_thread_mdelay(10);   // �̶���ʱ10ms
        lv_task_handler();      // �������lvgl���������
    }

// ���Դ��еķ�ʽ����ʱ���̶�����𲻻�̫��
//    rt_uint32_t tick = 10;
//    rt_uint32_t rc = 10;
//    while(_lv_init)
//    {
//        tick = rt_tick_get();
//
//        rc = lv_task_handler();
//        if (rc<10)
//        {
//            rc = 10;
//        }
//        rt_thread_mdelay(rc);
//
//        tick = rt_tick_get()-tick;
//        lv_tick_inc(tick);
//    }

#if (LV_ENABLE_GC == 1)
    lv_deinit();
#endif
    rt_free(buf1);
}

static int lvgl_task_handler_init(void)
{
    rt_err_t ret = RT_EOK;
    rt_thread_t thread = RT_NULL;

/* littleGL demo gui thread */
    thread = rt_thread_create("lv-task", lvgl_task_run, RT_NULL, 10 * 1024, 5, 10);
    if (thread == RT_NULL)
    {
        return RT_ERROR;
    }
    ret = rt_thread_startup(thread);

return ret;
}

void littlevgl2rtt_send_input_event(rt_int16_t x, rt_int16_t y, rt_uint8_t state)
{
    switch (state)
    {
    case LITTLEVGL2RTT_INPUT_UP:
        touch_down = RT_FALSE;
        break;
    case LITTLEVGL2RTT_INPUT_DOWN:
        last_x = x;
        last_y = y;
        touch_down = RT_TRUE;
        break;
    case LITTLEVGL2RTT_INPUT_MOVE:
        last_x = x;
        last_y = y;
        break;
    }
}

#if USE_LV_LOG
void littlevgl2rtt_log_register(lv_log_level_t level, const char *file, uint32_t line, const char *dsc)
{
    if (level >= LV_LOG_LEVEL)
    {
        //Show the log level if you want
        if (level == LV_LOG_LEVEL_TRACE)
        {
            rt_kprintf("Trace:");
        }

rt_kprintf("%s\n", dsc);
        //You can write 'file' and 'line' too similary if required.
    }
}
#endif

rt_err_t littlevgl2rtt_init(const char *name)
{
//    lv_color_t *fbuf;
    void *buf1 = rt_malloc(sizeof(lv_color_t)*LV_HOR_RES_MAX * LV_VER_RES_MAX);
    rt_memset(buf1,0,sizeof(lv_color_t)*LV_HOR_RES_MAX * LV_VER_RES_MAX);

//    void *buf2 = rt_malloc(sizeof(lv_color_t)*LV_HOR_RES_MAX * LV_VER_RES_MAX);
//    rt_memset(buf2,0,sizeof(lv_color_t)*LV_HOR_RES_MAX * LV_VER_RES_MAX);

RT_ASSERT(name != RT_NULL);
    if (_lv_init == 1)
        return 0;

/* LCD Device Init */
    device = rt_device_find(name);
    RT_ASSERT(device != RT_NULL);
    if (rt_device_open(device, RT_DEVICE_OFLAG_RDWR) == RT_EOK)
    {
        rt_device_control(device, RTGRAPHIC_CTRL_GET_INFO, &info);
    }

RT_ASSERT(info.bits_per_pixel == 8 || info.bits_per_pixel == 16 ||
              info.bits_per_pixel == 24 || info.bits_per_pixel == 32);
#if 0
    if ((info.bits_per_pixel != LV_COLOR_DEPTH) && (info.bits_per_pixel != 32 && LV_COLOR_DEPTH != 24))
    {
        rt_kprintf("Error: framebuffer color depth mismatch! (Should be %d to match with LV_COLOR_DEPTH)",
                   info.bits_per_pixel);
        return RT_ERROR;
    }
#endif
//    fbuf = rt_malloc(info.width * 10 * sizeof(*fbuf));
//    if (!fbuf)
//    {
//        rt_kprintf("Error: alloc disp buf fail\n");
//        return -1;
//    }

/* littlevgl Init */
    // lv_init�������ʹ�� littleVGL ֮ǰ�ȵ���һ�Ρ�
    lv_init();

#if USE_LV_LOG
    /* littlevgl Log Init */
    lv_log_register_print(littlevgl2rtt_log_register);
#endif

/* littlevGL Display device interface */
    lv_disp_drv_init(&disp_drv);
    disp_drv.hor_res = info.width;
    disp_drv.ver_res = info.height;

if (info.framebuffer == RT_NULL)
    {
        disp_drv.flush_cb = lcd_flush;
    }
    else
    {
        disp_drv.flush_cb = lcd_fb_flush; //ʵ��ʹ�øú���
    }

//lv_disp_buf_init(&disp_buf, buf1, buf2, LV_HOR_RES_MAX*LV_VER_RES_MAX);
    lv_disp_buf_init(&disp_buf, buf1, NULL, LV_HOR_RES_MAX*LV_VER_RES_MAX);

//    lv_disp_buf_init(&disp_buf, fbuf, NULL, info.width * 10);
    disp_drv.buffer = &disp_buf;
    lv_disp_drv_register(&disp_drv);

static lv_indev_drv_t indev_drv;
    lv_indev_drv_init(&indev_drv);

indev_drv.type = LV_INDEV_TYPE_POINTER;
    indev_drv.read_cb = input_read;

lv_indev_drv_register(&indev_drv);
    _lv_init = 1;

/* littlevGL Tick thread */
    //lvgl_tick_handler_init();   // ����߳����ṩlvgl������ʱ��
    lvgl_task_handler_init();   // ����߳����ṩlvgl���������

/* Info Print */
    rt_kprintf("[littlevgl2rtt] Welcome to the littlevgl2rtt.\n");
    rt_kprintf("[littlevgl2rtt] You can find latest ver from https://github.com/liu2guang/LittlevGL2RTT.\n");

return RT_EOK;
}

void littlevgl2rtt_deinit(void)
{
    _lv_init = 0;
}
```