EASY EAI灵眸科技
直播中

ALSET

3年用户 269经验值
擅长:可编程逻辑,电源/新能源,嵌入式技术,处理器/DSP
私信 关注
[经验]

【EASY EAI Nano开源套件试用体验】6. LVGL软件的移植与测试

LVGL BenchMark 测试

【EASY EAI Nano开源套件试用体验】6. LVGL软件的移植与测试
大信(QQ:8125036)

       电子发烧友和灵眸科技推出EASY EAI Nano开发板的试用。该开发板采用的是Rockchip 的RV1126处理器，该处理器拥有四核32位Cortex®-A7架构，集成2.0 TOPs AI算力的NPU。能够广泛适用物联网边缘计算以及智能应用，如人脸闸机、车载录像、安防监控等方面。
       EASY EAI Nano所带的SDK带有QT图形界面，QT是一个应用非常广泛的界面库。开发板上的人脸识别门禁应用就是使用QT做为图形界面。在移植一个我的一款QT应用时发现，该开发板虽然有QT，但没有QTSVG等库，也就是并没有支持完全，导致移植失败。而在QT上开发，矢量图形是常用的资源，能够解决不同屏幕尺寸的适配问题。
因而转向尝试在EASYEAI Nano上移植LVGL 用户图形库,在EASY EAI Nano上测试LVGL图形应用。
1.png

一、LVGL简介

      LVGL(Light and VersatileGraphics Library，轻巧而多功能的图形库)是一个免费的开放源代码图形库LVGL的作者是来自匈牙利的Gabor Kiss-Vamosikisvegabor，LVGL用C语言编写，以实现最大的兼容性（与C ++兼容），模拟器可在没有嵌入式硬件的PC上启动嵌入式GUI设计，同时LVGL作为一个图形库，它自带着接近三十多种小工具可以供开发者使用。这些强大的构建块按钮搭配上带有非常丝滑的动画以及可以做到平滑滚动的高级图形，同时兼具着不高的配置要求以及开源属性，显著的优势使得LVGL蔚然成风，成为广大开发者在选择GUI时的第一选择。

二、LVGL主要特性
     强大的UI组件，如按钮，图表，列表，滑块，图像等。
高级图形动画，抗锯齿，不透明度，平滑滚动
各种输入设备，如触摸板、鼠标、键盘、编码器等
多语言支持与UTF-8编码
多显示器支持，即使用更多的TFT，单色显示器同时
完全可定制的图形元素与css类样式
硬件独立与任何微控制器或显示器使用
可扩展，使用少量内存(64kb Flash, 16kb RAM)
支持操作系统、外部内存和GPU，但不是必需的
单帧缓冲操作，甚至与高级图形效果
用C编写的最大兼容性(c++兼容)
模拟器在没有嵌入式硬件的PC上开始嵌入式GUI设计
绑定到MicroPython
教程，例子，快速GUI设计的主题
文档可以在线和PDF格式获取
MIT许可下的免费和开源

三．运行硬件要求
配置要求
基本上，每个能够驱动显示器的现代控制器都适合运行 LVGL。最低要求是：
16、32 或64 位微控制器或处理器
建议使用 16MHz 时钟速度
闪存/ROM：> 64 kB 用于非常重要的组件 (> 建议使用 180 kB)
RAM:
静态 RAM 使用量：0~2 kB，取决于使用的功能和对象类型
堆: >2kB (> 建议使用 8 kB)
动态数据（堆）:> 2 KB (> 如果使用多个对象，建议使用 16 kB). 在 lv_conf.h 文件中配置 LV_MEM_SIZE 生效。
显示缓冲区：>“水平分辨率”像素（推荐> 10 × 10ד水平分辨率”）
MCU 或外部显示控制器中的一个帧缓冲器
C99 或更新的编译器

四、移植适配预编译

LVGL 是由三个工程组成的，分别是核心库，驱动库，演示应用程序库。
1．从github上拉取最新lvgl 核心库源码
2.png
2.从github上拉取最新驱动库源码
3.png
3.从github上拉取演示例子源码
4.png
2.查看工程代码结构
5.png
3.重新整理工程目录
重新整理工程目录，把三个工程都放到src子目录下，形成一个新的完整的工程
6.png
4. 编写项目编译配置脚本
编写总工程的CMake脚本，内容如下:
7.png
5.编写各个子模块编译配置脚本
进入src目录，编写项目cmakefile文件，内容如下
8.png
lvgl子模块的cmake脚本
9.png
lv_drivers子模块的cmake脚本
10.png
lv_demos子模块的cmake脚本
11.png
6. 初始化软件配置文件
把 lvgl/lv_conf_template.h模板复制到上层目录，并且改名lv_conf.h
把 lv_drivers/lv_drv_conf_template.h模板复制到上层目录，并且改名lv_drv_conf.h
把lv_demos/ lv_ex_conf_template.h 模板复制到上层目录，并且改名 lv_ex_conf.h
这两个文件是LVGL移植的头文件，所有与移植有关的参数都在这两个文件里定义。
7.修改模型的头文件里的配置
修改lv_conf.h里如下的配置，主要是与屏幕有关，屏幕大小，屏幕DPI，图像内存分配有关的参数
12.png
修改lv_drv_conf.h文件，配置屏幕显示使用的设备和触摸屏输入使用的设备参数：
13.png
修改lv_ex_conf.h文件，配置打开哪个演示程序，为防止冲突，一次最好打开一个，变化设置设置轮番测试。
14.png
8.添加一些外部的代码
添加 main.cpp ，用于启动一个LVGL例子，可以从lvgl/example里复制一个例程出来。
  1. #include "lvgl.h"
  2. #include
  3. #include "lv_port_disp.h"
  4. #include "lv_port_indev.h"
  5. #include "lv_demo_widgets.h"
  6. #include "lv_demo_music.h"
  7. #include "lv_demos/lv_examples.h"

  9. void lvgl_first_demo_start(void);

  11. int main(void)
  12. {                       
  13.         lv_init(); //lvgl 系统初始化
  14.         lv_port_disp_init(); //lvgl 显示接口初始化,放在 lv_init()的后面
  15.         lv_port_indev_init(); //lvgl 输入接口初始化,放在 lv_init()的后面

  17.         //lvgl_first_demo_start(); //打开这个注释就是一个画button的简单demo 注意注释掉下面的lv_demo_widgets
  18.         lv_demo_widgets();
  19.         //lv_demo_music();
  20.         //lv_demo_benchmark();
  21.         printf("start demo n");
  22.         while(1)
  23.         {
  24.                 lv_task_handler();
  25.         }
  26. }

  28. void tim_lv_tick()
  29. {
  30.         lv_tick_inc(1);//lvgl 的 1ms 心跳
  31. }

  33. static void btn_event_cb(lv_obj_t * btn, lv_event_t event)
  34. {
  35.     if(event == LV_EVENT_CLICKED) {
  36.         static uint8_t cnt = 0;
  37.         cnt++;

  39.         /*Get the first child of the button which is the label and change its text*/
  40.         lv_obj_t * label = lv_obj_get_child(btn, NULL);
  41.         lv_label_set_text_fmt(label, "Button: %d", cnt);
  42.     }
  43.    
  44. }
  45. void lvgl_first_demo_start(void)
  46. {
  47.     lv_obj_t * btn = lv_btn_create(lv_scr_act(), NULL);     /*Add a button the current screen*/
  48.     lv_obj_set_pos(btn, 10, 10);                            /*Set its position*/
  49.     lv_obj_set_size(btn, 120, 50);                          /*Set its size*/
  50.     lv_obj_set_event_cb(btn, btn_event_cb);                 /*Assign a callback to the button*/

  52.     lv_obj_t * label = lv_label_create(btn, NULL);          /*Add a label to the button*/
  53.     lv_label_set_text(label, "Button");                     /*Set the labels text*/


  56.         lv_obj_t * label1 = lv_label_create(lv_scr_act(), NULL);
  57.         lv_label_set_text(label1, "Hello world!");
  58.         lv_obj_align(label1, NULL, LV_ALIGN_CENTER, 0, 0);
  59.         lv_obj_align(btn, label1, LV_ALIGN_OUT_TOP_MID, 0, -10);
  60. }
添加系统时钟的实现，LVGL需要调用。添加sys_tick.c, sys_tick.h
  1. #include "sys_tick.h"
  2. #include

  4. uint32_t custom_tick_get(void)
  5. {
  6.     static uint64_t start_ms = 0;
  7.     if(start_ms == 0) {
  8.         struct timeval tv_start;
  9.         gettimeofday(&tv_start, NULL);
  10.         start_ms = (tv_start.tv_sec * 1000000 + tv_start.tv_usec) / 1000;
  11.     }
  12.     struct timeval tv_now;
  13.     gettimeofday(&tv_now, NULL);
  14.     uint64_t now_ms;
  15.     now_ms = (tv_now.tv_sec * 1000000 + tv_now.tv_usec) / 1000;
  16.     uint32_t time_ms = now_ms - start_ms;
  17.     return time_ms;
  18. }
  1. #ifndef __SYS_TICK__H
  2. #define __SYS_TICK__H

  4. #include
  5. #include
  6. #include
  7. extern uint32_t custom_tick_get(void);
  8. #endif
9.开始进行编译
做完上面的修改和代码添加后，可以进行初步的编译，进入工程根目录，进行cmake配置编译:
mkdirbuild
cdbuild
cmake..
15.png
cmake脚本执行完毕后，会产生makefile文件，然后就可以进行编译，执行
make–j4
16.png
经过检查，目标文件已经编译成功。
五、适配层代码开发
       把上面编译出的目标文件传动到板子里运行时，发现屏幕是黑的，什么都看不到，但是程序没有报出错或者退出。说明LVGL已经基本的运行起来了，只是显示的代码没有生效。
      经过分析代码后发现，LVGL为了适配多种硬件，因此它把显示的驱动代码放在lv_drivers/lv_port_disp.c 里，需要移植者根据硬件来完成这个适配。
      经过研究，只需要做小的开发修改，即可完成适配的代码，主要修改为在输出化时，调用drm的初始化，并且规划好双缓冲的屏显方式，并且分配好显存空间，分别修改 lv_port_disp_init、disp_init、disp_flush这三个函数即可。
修改后的代码如下：

  1. /**
  2. * [url=home.php?mod=space&uid=1455510]@file[/url] lv_port_disp_templ.c
  3. *
  4. */

  6. /*Copy this file as "lv_port_disp.c" and set this value to "1" to enable content*/
  7. #if 1

  9. /*********************
  10. *      INCLUDES
  11. *********************/
  12. #include "lv_port_disp.h"
  13. #include "display/drm.h"
  14. /*********************
  15. *      DEFINES
  16. *********************/

  18. /**********************
  19. *      TYPEDEFS
  20. **********************/

  22. /**********************
  23. *  STATIC PROTOTYPES
  24. **********************/
  25. static void disp_init(void);

  27. static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);

  29. #if LV_USE_GPU
  30. static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
  31. static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
  32.         const lv_area_t * fill_area, lv_color_t color);
  33. #endif

  35. /**********************
  36. *  STATIC VARIABLES
  37. **********************/

  39. /**********************
  40. *      MACROS
  41. **********************/

  43. /**********************
  44. *   GLOBAL FUNCTIONS
  45. **********************/

  47. void lv_port_disp_init(void)
  48. {
  49.     /*-------------------------
  50.      * Initialize your display
  51.      * -----------------------*/
  52.     disp_init();

  54.     /*-----------------------------
  55.      * Create a buffer for drawing
  56.      *----------------------------*/

  58.     /* LVGL requires a buffer where it internally draws the widgets.
  59.      * Later this buffer will passed your display drivers `flush_cb` to copy its content to your display.
  60.      * The buffer has to be greater than 1 display row
  61.      *
  62.      * There are three buffering configurations:
  63.      * 1. Create ONE buffer with some rows:
  64.      *      LVGL will draw the display's content here and writes it to your display
  65.      *
  66.      * 2. Create TWO buffer with some rows:
  67.      *      LVGL will draw the display's content to a buffer and writes it your display.
  68.      *      You should use DMA to write the buffer's content to the display.
  69.      *      It will enable LVGL to draw the next part of the screen to the other buffer while
  70.      *      the data is being sent form the first buffer. It makes rendering and flushing parallel.
  71.      *
  72.      * 3. Create TWO screen-sized buffer:
  73.      *      Similar to 2) but the buffer have to be screen sized. When LVGL is ready it will give the
  74.      *      whole frame to display. This way you only need to change the frame buffer's address instead of
  75.      *      copying the pixels.
  76.      * */
  77. #if 0
  78.     /* Example for 1) */
  79.     static lv_disp_buf_t draw_buf_dsc_1;
  80.     static lv_color_t draw_buf_1[LV_HOR_RES_MAX * 10];                          /*A buffer for 10 rows*/
  81.     lv_disp_buf_init(&draw_buf_dsc_1, draw_buf_1, NULL, LV_HOR_RES_MAX * 10);   /*Initialize the display buffer*/

  83.     /* Example for 2) */
  84.     static lv_disp_buf_t draw_buf_dsc_2;
  85.     static lv_color_t draw_buf_2_1[LV_HOR_RES_MAX * 10];                        /*A buffer for 10 rows*/
  86.     static lv_color_t draw_buf_2_2[LV_HOR_RES_MAX * 10];                        /*An other buffer for 10 rows*/
  87.     lv_disp_buf_init(&draw_buf_dsc_2, draw_buf_2_1, draw_buf_2_2, LV_HOR_RES_MAX * 10);   /*Initialize the display buffer*/
  88. #endif
  89.     /* Example for 3) */
  90.     static lv_disp_buf_t draw_buf_dsc_3;
  91.     static lv_color_t draw_buf_3_1[LV_HOR_RES_MAX * LV_VER_RES_MAX];            /*A screen sized buffer*/
  92.     static lv_color_t draw_buf_3_2[LV_HOR_RES_MAX * LV_VER_RES_MAX];            /*An other screen sized buffer*/
  93.     lv_disp_buf_init(&draw_buf_dsc_3, draw_buf_3_1, draw_buf_3_2, LV_HOR_RES_MAX * LV_VER_RES_MAX);   /*Initialize the display buffer*/

  95.     /*-----------------------------------
  96.      * Register the display in LVGL
  97.      *----------------------------------*/

  99.     lv_disp_drv_t disp_drv;                         /*Descriptor of a display driver*/
  100.     lv_disp_drv_init(&disp_drv);                    /*Basic initialization*/

  102.     /*Set up the functions to access to your display*/
  103.     lv_coord_t w=0,h=0;
  104.     uint32_t d=0;
  105.     drm_get_sizes(&w,&h,&d);
  106.     //LV_LOG_INFO("drm_get_sizes %d x %d , dpi %d n", w, h, d );
  107.     /*Set the resolution of the display*/
  108.     disp_drv.hor_res = 1280;
  109.     disp_drv.ver_res = 720;
  110.                
  111.     /*Used to copy the buffer's content to the display*/
  112.     disp_drv.flush_cb = disp_flush;

  114.     /*Set a display buffer*/
  115.     disp_drv.buffer = &draw_buf_dsc_3;

  117. #if LV_USE_GPU
  118.     /*Optionally add functions to access the GPU. (Only in buffered mode, LV_VDB_SIZE != 0)*/

  120.     /*Blend two color array using opacity*/
  121.     disp_drv.gpu_blend_cb = gpu_blend;

  123.     /*Fill a memory array with a color*/
  124.     disp_drv.gpu_fill_cb = gpu_fill;
  125. #endif

  127.     /*Finally register the driver*/
  128.     lv_disp_t *disp=lv_disp_drv_register(&disp_drv);
  129.     lv_disp_set_default(disp);
  130.    // lv_disp_set_rotation(disp, LV_DISP_ROT_90);
  131. }

  133. /**********************
  134. *   STATIC FUNCTIONS
  135. **********************/

  137. /* Initialize your display and the required peripherals. */
  138. static void disp_init(void)
  139. {
  140.           LV_LOG_INFO("disp_init....");
  141.     /*You code here*/
  142.     drm_init();
  143. }

  145. /* Flush the content of the internal buffer the specific area on the display
  146. * You can use DMA or any hardware acceleration to do this operation in the background but
  147. * 'lv_disp_flush_ready()' has to be called when finished. */
  148. static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area)
  149. {
  150.     /*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/
  151. #if 0
  152.     int32_t x;
  153.     int32_t y;
  154.     for(y = area->y1; y <= area->y2; y++) {
  155.         for(x = area->x1; x <= area->x2; x++) {
  156.             /* Put a pixel to the display. For example: */
  157.             /* put_px(x, y, *color_p)*/
  158.            // color_p++;
  159.         }
  160.     }
  161. #endif
  162.     //lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_p);
  163.     drm_flush(disp_drv , area , color_p);
  164.     /* IMPORTANT!!!
  165.      * Inform the graphics library that you are ready with the flushing*/
  166.    // LV_LOG_INFO("....disp_flush....");
  167.     lv_disp_flush_ready(disp_drv);
  168. }

  170. /*OPTIONAL: GPU INTERFACE*/
  171. #if LV_USE_GPU

  173. /* If your MCU has hardware accelerator (GPU) then you can use it to blend to memories using opacity
  174. * It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/
  175. static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
  176. {
  177.     /*It's an example code which should be done by your GPU*/
  178.     uint32_t i;
  179.     for(i = 0; i < length; i++) {
  180.         dest[i] = lv_color_mix(dest[i], src[i], opa);
  181.     }
  182.      LV_LOG_INFO("....gpu_blend....");
  183. }

  185. /* If your MCU has hardware accelerator (GPU) then you can use it to fill a memory with a color
  186. * It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/
  187. static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
  188.                     const lv_area_t * fill_area, lv_color_t color)
  189. {
  190.     /*It's an example code which should be done by your GPU*/
  191.     int32_t x, y;
  192.     dest_buf += dest_width * fill_area->y1; /*Go to the first line*/

  194.     for(y = fill_area->y1; y <= fill_area->y2; y++) {
  195.         for(x = fill_area->x1; x <= fill_area->x2; x++) {
  196.             dest_buf[x] = color;
  197.         }
  198.         dest_buf+=dest_width;    /*Go to the next line*/
  199.     }
  200. }

  202. #endif  /*LV_USE_GPU*/

  204. #else /* Enable this file at the top */

  206. /* This dummy typedef exists purely to silence -Wpedantic. */
  207. typedef int keep_pedantic_happy;
  208. #endif

同样修改触摸屏的适配代码lv_port_indev.c，主要修改
touchpad_init，touchpad_read，完成触摸屏事件转换为图形系统的坐标，实现代码如下：
  1. /**
  2. * @file lv_port_indev_templ.c
  3. *
  4. */

  6. /*Copy this file as "lv_port_indev.c" and set this value to "1" to enable content*/
  7. #if 1

  9. /*********************
  10. *      INCLUDES
  11. *********************/
  12. #include "lv_port_indev.h"
  13. #include "../lv_drv_conf.h" //添加依赖的头文件
  14. #include "../tslib.h" //添加tslib库头文件
  15. #include
  16. #include
  17. #include
  18. #include
  19. #include
  20. #include
  21. #include //如果你用了epoll 或者select可添加此头文件
  22. #include
  23. #include
  24. #include
  25. #include //如果你是自己处理去抖动那直接读取触摸屏事件可以添加此头文件
  26. #include

  28. #include "indev/evdev.h"
  29. /*********************
  30. *      DEFINES
  31. *********************/

  33. /**********************
  34. *      TYPEDEFS
  35. **********************/

  37. /**********************
  38. *  STATIC PROTOTYPES
  39. **********************/

  41. static void touchpad_init(void);
  42. static bool touchpad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
  43. static bool touchpad_is_pressed(void);
  44. static void touchpad_get_xy(lv_coord_t * x, lv_coord_t * y);

  46. static void mouse_init(void);
  47. static bool mouse_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
  48. static bool mouse_is_pressed(void);
  49. static void mouse_get_xy(lv_coord_t * x, lv_coord_t * y);

  51. static void keypad_init(void);
  52. static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
  53. static uint32_t keypad_get_key(void);

  55. static void encoder_init(void);
  56. static bool encoder_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
  57. //static void encoder_handler(void);

  59. static void button_init(void);
  60. static bool button_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
  61. static int8_t button_get_pressed_id(void);
  62. static bool button_is_pressed(uint8_t id);

  64. /**********************
  65. *  STATIC VARIABLES
  66. **********************/
  67. lv_indev_t * indev_touchpad;
  68. lv_indev_t * indev_mouse;
  69. lv_indev_t * indev_keypad;
  70. lv_indev_t * indev_encoder;
  71. lv_indev_t * indev_button;

  73. static int32_t encoder_diff;
  74. static lv_indev_state_t encoder_state;

  76. /**********************
  77. *      MACROS
  78. **********************/

  80. /**********************
  81. *   GLOBAL FUNCTIONS
  82. **********************/

  84. void lv_port_indev_init(void)
  85. {
  86.     /* Here you will find example implementation of input devices supported by LittelvGL:
  87.      *  - Touchpad
  88.      *  - Mouse (with cursor support)
  89.      *  - Keypad (supports GUI usage only with key)
  90.      *  - Encoder (supports GUI usage only with: left, right, push)
  91.      *  - Button (external buttons to press points on the screen)
  92.      *
  93.      *  The `..._read()` function are only examples.
  94.      *  You should shape them according to your hardware
  95.      */

  97.     lv_indev_drv_t indev_drv;

  99.     /*------------------
  100.      * Touchpad
  101.      * -----------------*/

  103.     /*Initialize your touchpad if you have*/
  104.     touchpad_init();

  106.     /*Register a touchpad input device*/
  107.     lv_indev_drv_init(&indev_drv);
  108.     indev_drv.type = LV_INDEV_TYPE_POINTER;
  109.     indev_drv.read_cb = touchpad_read;
  110.     indev_touchpad = lv_indev_drv_register(&indev_drv);

  112.     /*------------------
  113.      * Mouse
  114.      * -----------------*/

  116.     /*Initialize your touchpad if you have*/
  117.     mouse_init();

  119.     /*Register a mouse input device*/
  120.     lv_indev_drv_init(&indev_drv);
  121.     indev_drv.type = LV_INDEV_TYPE_POINTER;
  122.     indev_drv.read_cb = mouse_read;
  123.     indev_mouse = lv_indev_drv_register(&indev_drv);

  125.     /*Set cursor. For simplicity set a HOME symbol now.*/
  126.     lv_obj_t * mouse_cursor = lv_img_create(lv_disp_get_scr_act(NULL), NULL);
  127.     lv_img_set_src(mouse_cursor, (const void *)LV_SYMBOL_HOME);
  128.     lv_indev_set_cursor(indev_mouse, mouse_cursor);

  130.     /*------------------
  131.      * Keypad
  132.      * -----------------*/

  134.     /*Initialize your keypad or keyboard if you have*/
  135.     keypad_init();

  137.     /*Register a keypad input device*/
  138.     lv_indev_drv_init(&indev_drv);
  139.     indev_drv.type = LV_INDEV_TYPE_KEYPAD;
  140.     indev_drv.read_cb = keypad_read;
  141.     indev_keypad = lv_indev_drv_register(&indev_drv);

  143.     /* Later you should create group(s) with `lv_group_t * group = lv_group_create()`,
  144.      * add objects to the group with `lv_group_add_obj(group, obj)`
  145.      * and assign this input device to group to navigate in it:
  146.      * `lv_indev_set_group(indev_keypad, group);` */

  148.     /*------------------
  149.      * Encoder
  150.      * -----------------*/

  152.     /*Initialize your encoder if you have*/
  153.     encoder_init();

  155.     /*Register a encoder input device*/
  156.     lv_indev_drv_init(&indev_drv);
  157.     indev_drv.type = LV_INDEV_TYPE_ENCODER;
  158.     indev_drv.read_cb = encoder_read;
  159.     indev_encoder = lv_indev_drv_register(&indev_drv);

  161.     /* Later you should create group(s) with `lv_group_t * group = lv_group_create()`,
  162.      * add objects to the group with `lv_group_add_obj(group, obj)`
  163.      * and assign this input device to group to navigate in it:
  164.      * `lv_indev_set_group(indev_encoder, group);` */

  166.     /*------------------
  167.      * Button
  168.      * -----------------*/

  170.     /*Initialize your button if you have*/
  171.     button_init();

  173.     /*Register a button input device*/
  174.     lv_indev_drv_init(&indev_drv);
  175.     indev_drv.type = LV_INDEV_TYPE_BUTTON;
  176.     indev_drv.read_cb = button_read;
  177.     indev_button = lv_indev_drv_register(&indev_drv);

  179.     /*Assign buttons to points on the screen*/
  180.     static const lv_point_t btn_points[2] = {
  181.             {10, 10},   /*Button 0 -> x:10; y:10*/
  182.             {40, 100},  /*Button 1 -> x:40; y:100*/
  183.     };
  184.     lv_indev_set_button_points(indev_button, btn_points);
  185. }

  187. /**********************
  188. *   STATIC FUNCTIONS
  189. **********************/

  191. /*------------------
  192. * Touchpad
  193. * -----------------*/

  195. /*Initialize your touchpad*/
  196. static void touchpad_init(void)
  197. {
  198.     /*Your code comes here*/
  199.     evdev_init();
  200. }

  202. /* Will be called by the library to read the touchpad */
  203. static bool touchpad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
  204. {
  205.           static lv_coord_t last_a = 0;
  206.     static lv_coord_t last_b = 0;
  207.    
  208.     static lv_coord_t last_x = 0;
  209.     static lv_coord_t last_y = 0;
  210.                 //static lv_coord_t tmp;
  211.     /*Save the pressed coordinates and the state*/
  212.     if(touchpad_is_pressed()) {
  213.               printf("is_pressed !n");
  214.         touchpad_get_xy(&last_x, &last_y);
  215.         data->state = LV_INDEV_STATE_PR;
  216.     } else {
  217.         data->state = LV_INDEV_STATE_REL;
  218.     }

  220.     /*Set the last pressed coordinates*/
  221.     data->point.x = last_x;
  222.     data->point.y = last_y;
  223.    
  224.     evdev_read(indev_drv,data);
  225.    
  226.     if(data->point.x != last_a || data->point.y != last_b)
  227.     {
  228.                     last_a = data->point.x; last_b = data->point.y;
  229.               //printf("evdev x,y=%d,%dn", data->point.x, data->point.y);
  230.     }
  231.   
  232.    // tmp = data->point.x;
  233.     //data->point.x = data->point.y ;
  234.     //data->point.y = 719-tmp;
  235.     /*Return `false` because we are not buffering and no more data to read*/
  236.     return false;
  237. }

  239. /*Return true is the touchpad is pressed*/
  240. static bool touchpad_is_pressed(void)
  241. {
  242.     /*Your code comes here*/

  244.     return false;
  245. }

  247. /*Get the x and y coordinates if the touchpad is pressed*/
  248. static void touchpad_get_xy(lv_coord_t * x, lv_coord_t * y)
  249. {
  250.     /*Your code comes here*/

  252.     (*x) = 0;
  253.     (*y) = 0;
  254. }

  256. /*------------------
  257. * Mouse
  258. * -----------------*/

  260. /* Initialize your mouse */
  261. static void mouse_init(void)
  262. {
  263.     /*Your code comes here*/
  264. }

  266. /* Will be called by the library to read the mouse */
  267. static bool mouse_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
  268. {
  269.     /*Get the current x and y coordinates*/
  270.     mouse_get_xy(&data->point.x, &data->point.y);

  272.     /*Get whether the mouse button is pressed or released*/
  273.     if(mouse_is_pressed()) {
  274.         data->state = LV_INDEV_STATE_PR;
  275.     } else {
  276.         data->state = LV_INDEV_STATE_REL;
  277.     }

  279.     /*Return `false` because we are not buffering and no more data to read*/
  280.     return false;
  281. }

  283. /*Return true is the mouse button is pressed*/
  284. static bool mouse_is_pressed(void)
  285. {
  286.     /*Your code comes here*/

  288.     return false;
  289. }

  291. /*Get the x and y coordinates if the mouse is pressed*/
  292. static void mouse_get_xy(lv_coord_t * x, lv_coord_t * y)
  293. {
  294.     /*Your code comes here*/

  296.     (*x) = 0;
  297.     (*y) = 0;
  298. }

  300. /*------------------
  301. * Keypad
  302. * -----------------*/

  304. /* Initialize your keypad */
  305. static void keypad_init(void)
  306. {
  307.     /*Your code comes here*/
  308. }

  310. /* Will be called by the library to read the mouse */
  311. static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
  312. {
  313.     static uint32_t last_key = 0;

  315.     /*Get the current x and y coordinates*/
  316.     mouse_get_xy(&data->point.x, &data->point.y);

  318.     /*Get whether the a key is pressed and save the pressed key*/
  319.     uint32_t act_key = keypad_get_key();
  320.     if(act_key != 0) {
  321.         data->state = LV_INDEV_STATE_PR;

  323.         /*Translate the keys to LVGL control characters according to your key definitions*/
  324.         switch(act_key) {
  325.         case 1:
  326.             act_key = LV_KEY_NEXT;
  327.             break;
  328.         case 2:
  329.             act_key = LV_KEY_PREV;
  330.             break;
  331.         case 3:
  332.             act_key = LV_KEY_LEFT;
  333.             break;
  334.         case 4:
  335.             act_key = LV_KEY_RIGHT;
  336.             break;
  337.         case 5:
  338.             act_key = LV_KEY_ENTER;
  339.             break;
  340.         }

  342.         last_key = act_key;
  343.     } else {
  344.         data->state = LV_INDEV_STATE_REL;
  345.     }

  347.     data->key = last_key;

  349.     /*Return `false` because we are not buffering and no more data to read*/
  350.     return false;
  351. }

  353. /*Get the currently being pressed key.  0 if no key is pressed*/
  354. static uint32_t keypad_get_key(void)
  355. {
  356.     /*Your code comes here*/

  358.     return 0;
  359. }

  361. /*------------------
  362. * Encoder
  363. * -----------------*/

  365. /* Initialize your keypad */
  366. static void encoder_init(void)
  367. {
  368.     /*Your code comes here*/
  369. }

  371. /* Will be called by the library to read the encoder */
  372. static bool encoder_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
  373. {

  375.     data->enc_diff = encoder_diff;
  376.     data->state = encoder_state;

  378.     /*Return `false` because we are not buffering and no more data to read*/
  379.     return false;
  380. }

  382. /*Call this function in an interrupt to process encoder events (turn, press)*/
  383. //static void encoder_handler(void)
  384. //{
  385.     /*Your code comes here*/
  386. //    encoder_diff += 0;
  387. //    encoder_state = LV_INDEV_STATE_REL;
  388. //}

  390. /*------------------
  391. * Button
  392. * -----------------*/

  394. /* Initialize your buttons */
  395. static void button_init(void)
  396. {
  397.     /*Your code comes here*/
  398. }

  400. /* Will be called by the library to read the button */
  401. static bool button_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
  402. {

  404.     static uint8_t last_btn = 0;

  406.     /*Get the pressed button's ID*/
  407.     int8_t btn_act = button_get_pressed_id();

  409.     if(btn_act >= 0) {
  410.         data->state = LV_INDEV_STATE_PR;
  411.         last_btn = btn_act;
  412.     } else {
  413.         data->state = LV_INDEV_STATE_REL;
  414.     }

  416.     /*Save the last pressed button's ID*/
  417.     data->btn_id = last_btn;

  419.     /*Return `false` because we are not buffering and no more data to read*/
  420.     return false;
  421. }

  423. /*Get ID  (0, 1, 2 ..) of the pressed button*/
  424. static int8_t button_get_pressed_id(void)
  425. {
  426.     uint8_t i;

  428.     /*Check to buttons see which is being pressed (assume there are 2 buttons)*/
  429.     for(i = 0; i < 2; i++) {
  430.         /*Return the pressed button's ID*/
  431.         if(button_is_pressed(i)) {
  432.             return i;
  433.         }
  434.     }

  436.     /*No button pressed*/
  437.     return -1;
  438. }

  440. /*Test if `id` button is pressed or not*/
  441. static bool button_is_pressed(uint8_t id)
  442. {

  444.     /*Your code comes here*/

  446.     return false;
  447. }

  449. #else /* Enable this file at the top */

  451. /* This dummy typedef exists purely to silence -Wpedantic. */
  452. typedef int keep_pedantic_happy;
  453. #endif

把修改完的代码合并到工程，然后再执行编译，可以得到完成适配的开发板上的可执行文件。
六、板上测试运行把文件传到目标板上运行，即可看道LVGL的界面了，这是一个lv_demo_widgets 的演示，界面显示效果如下：
17.png
18.png
同样可以修改demo的定义，跑起一个lv_demo_benchmark来全面测试该硬件运行LVGL的效果，后面附带一个视频，即为运行该GUI的效果，可见实测能跑到 22fps，运行非常流程，响应也很灵敏。界面非常漂亮。
19.png

七、屏幕旋转显示
       在开始的测试中，显示是竖屏的，因为这个开发板系统底层显示驱动模型是 720X1280的显示。跟一些LVGL演示的界面不和谐。
      因此需要把显示进行旋转，开始尝试使用LVGLdisp自带的旋转函数 lv_disp_set_rotation(disp, LV_DISP_ROT_90);发现界面虽然旋转了90度，是横向显示，但是屏幕输出仍然是纵向，造成界面只显示坐厕，屏幕下方是黑的。显然这个旋转是界面的方向，不是显示的方向。
    显示的旋转应需要在 DRM的驱动里去修改屏幕的输出的方向，经过一番研究，没找找到DRM直接修改显示方向的方法，因时间有限，于是使用了一个简单粗暴的方法，即在刷屏时，把刷屏的数据进行重新调整顺序，达到“旋转”的目标，代码实现在drm.c里，如下：
20.png
同样在显示旋转后，触摸屏的坐标也需要“旋转”，除了打开上面配置的交换x,y坐标后，测试时发现，虽然x,y坐标交换了，但是y坐标的方向错了，应该是左上角为原点，向下为正，但实际是左下角为原点，向上为正了，导致屏幕上所有控件无法或得正确的触摸消息。
修改方法很简单，修改lv_drivers/indev/evdev.c,把y坐标掉个头。代码如下：
21.png
坐标修改下面的代码是对坐标加以保护，防止触摸到边界时，出现负的坐标，而导致系统异常。经过上面修改后，再在板上测试，所有显示和触摸都正确了，界面也显示了横屏的效果，但是因为DRM旋转的方法比较低效，导致刷新帧率明显降低，由GUI的30fps,降低到20fps左右。
同样，对屏幕上的UI显示的大小，可以通过修改lv_conf.h里的DIP来调整，计算方法很简单。
比如这个屏是6英寸，对720x1280这个分辨率是约为1468像素，即每英寸 1468/6 = 245, 即可得标准的DIP ，设置为245,显示最佳。一下是几个界面拍照图：
22.png
23.png
24.png

八、LVGL移植总结
        经过在EASY-EAI-Nano(RV1126)开发板成功移植LVGL图形库，进一步了解该开发板的性能，同时也了解LVGL软件的一些特点，工程代码结构简洁，结构合理，容易理解。各个地方的注释也非常丰富，模块结构划分清晰，移植适配起来非常方便。
        同时也测试得LVGl在该开发板上运行非常流畅，由于是纯C实现的界面，板上执行效率非常高。并且具有良好的界面的适配性，不同尺寸的屏幕的LVGL图形应用非常方便的移植。而且LVGL界面提供大量可直接使用的组件，这些组件也很美观。之后就可以方便把大量LVGL的UI应用移植到该平台上了。

LVGL移植横屏测试

回帖（1）

李加宁

2023-5-29 13:57:17
您好，请问移植后的lvgl工程方便分享下吗
举报

更多回帖

1 0 0

相关帖子

GUI LVGL
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分