一、使用CPU搬运数据到显存
7 S1 ^0 R# {" k5 `2 X6 D# i5 c' M3 M* ~在上一篇文章中讲述了如何配置 LTDC 驱动 RGB 屏幕：
  @& w. ~9 V- s; U) m

% r' A: e6 z/ b( ]! f, qSTM32CubeMX | 41-使用LTDC驱动TFT-LCD屏幕（RGB屏）。

8 \3 t4 C* a8 d3 m, V
: S( s0 C8 W% Z+ `本节中我们接着上一节的实验，讲述如何使用 DMA2D 实现打点、画线、填充等函数，只需要单层全屏即可，修改LTDC层配置如下：

+ T  `* s. P, D) F+ a: ]

* n$ d! _# e/ G; `4 I1. 编写lcd驱动头文件
创建lcd_rgb_ltdc_drv.h文件，存放关于操作LCD屏幕的一些宏定义配置和函数定义：
; H! F; ]% R' O) T. u4 I) ]

1. <font face="微软雅黑" size="3">#ifndef _LCD_RGB_LTDC_DRV_H_
   & s8 O. Q, j; j, c- \
2. #define _LCD_RGB_LTDC_DRV_H_
   1 |7 Q4 s  V9 p  n% x
3. 
   
4. #include "ltdc.h"
   ' y% M7 B# d# v' ^6 H7 b, |
5. 
   7 _) L" e* a9 a9 T( Q( m
6. /**
   
7. * @brief   Windows size on lcd.
   
8. */
   
9. #define LCD_WIDTH       1024
   . r( J* n/ b4 U/ F: W3 v/ ?/ C1 }
10. #define LCD_HEIGHT      600
    3 Q% R4 h+ w' w0 x) d
11. 
    $ {+ T/ u$ x) ^( ~6 S/ ~, {
12. /**
    
13. * @brief   Backlight control pin of lcd.
    
14. */
    ) `2 ?" k& X; W5 l, s1 o6 {2 g
15. #define LCD_BL_GPIO_PORT    GPIOB
    - S; Z& ^/ N4 f: g6 r" d1 M3 |2 S. e
16. #define LCD_BL_GPIO_PIN     GPIO_PIN_5
    9 p+ n( y3 W7 o) e7 j/ l
17. 
    0 J: p; a- L/ `$ e! ~$ l1 L
18. /**
    1 v' Z) k! ~) a& S
19. * @brief   start address of lcd framebuffer.
    " ?/ q8 ~' B# c& P& n3 {
20. */
    
21. #define LCD_FRAME_BUFFER    0xc0000000
    
22. 
    ; B# `* Q" \2 H. a! R
23. /**
    / C# L: u/ [$ e7 E/ d3 O
24. * @brief   color
    
25. * @note    rgb565   
    
26. */
    
27. #define BLACK   0x0000
    4 b0 i6 n* G8 C
28. #define BLUE    0x001F
    
29. #define GREEN   0x07E0
    
30. #define GBLUE   0X07FF
    3 y! Q* y) `0 B& Q- `, o
31. #define GRAY    0X8430
    ) y" P! G7 u' O0 y1 k# G
32. #define BROWN   0XBC40
    1 S3 D) `+ g7 w6 L* P
33. #define RED     0xF800
    ( d6 |8 o) B; h
34. #define PINK    0XF81F
    
35. #define BRRED   0XFC07
    4 m' F$ h2 j: V  j9 L3 `5 y
36. #define YELLOW  0xFFE0
    % F  [' \1 \4 G. G* ]* D7 ]( E
37. #define WHITE   0xFFFF
    0 {- w! T) n+ }: W% p
38. 
    - q/ J* f, b8 y) s8 Z9 I. w" n3 D) s
39. /**
    
40. * @brief       Control the lcd backlight.
    
41. * @param[in]   brightness  the value of lcd backlight.
    6 _+ e* b. ]. V
42. * @return      None
    
43. */
    5 g, k9 D5 N9 q( ]9 @$ m3 c1 q
44. void lcd_backlight_control(uint8_t bightness);
    2 G6 P  Y* i  J
45. 
    ( H4 m$ _6 Z" g5 Y& k
46. /**
    
47. * @brief       LCD initialization.
    ; ^- y- |) H* J
48. * @param       None
    
49. * @return      None
    
50. */
    
51. void lcd_init(void);
    7 C" o! q9 N4 Q3 _
52. 
    2 o  ~  _: P% Z: e# D' _/ P5 }0 z
53. /**
    
54. * @brief       Clear lcd.
    ( A/ t- p! {: p) r$ z5 O3 g
55. * @param[in]   color   rgb565.
    ( a, M  ?, N& R8 j& j
56. * @return      None
    
57. */
    2 @* X9 W. G. X0 w% V
58. void lcd_clear(uint16_t color);
    
59. 
    
60. #endif /* _LCD_RGB_LTDC_DRV_H_ */</font>

复制代码

0 ^$ f3 y. m7 M6 X2. lcd驱动实现
创建lcd_rgb_ltdc_drv.c文件，存放关于操作LCD屏幕的函数实现。
* ~8 v3 A; K& i; k) Y% g) r

首先是背光控制实现，应该使用pwm实现背光调节，本文中为了方便直接使用GPIO控制：

1. <font face="微软雅黑" size="3">void lcd_backlight_control(uint8_t bightness)
   
2. {
   
3.     // todo: use pwm to control backlight
   
4. 
   
5.     if (bightness) {   
   7 l' s6 a5 f& ^' u  ]( \
6.         // turn on the backlight
   , p( R+ m3 J" i. F: ^( ~
7.         HAL_GPIO_WritePin(LCD_BL_GPIO_PORT, LCD_BL_GPIO_PIN, GPIO_PIN_SET);
   ! ^+ Y% t7 H1 K  q
8.     } else {            
   
9.         // turn off the backlight
   
10.         HAL_GPIO_WritePin(LCD_BL_GPIO_PORT, LCD_BL_GPIO_PIN, GPIO_PIN_RESET);
    
11.     }
    
12. }</font>

复制代码

接着实现lcd清屏函数，使用CPU（循环）搬运数据到显存中：

1. <font face="微软雅黑" size="3">void lcd_clear(uint16_t color)
   4 S, Q6 Z: N7 }  |0 Q$ |, ~
2. {
   + R: I$ }* U5 k& \% u
3.     uint16_t *ptr = (uint16_t*)LCD_FRAME_BUFFER;
   7 u0 p% o% {8 [5 {
4.     uint32_t i = 0;
   
5. 
   
6.     while (i++ < LCD_WIDTH*LCD_HEIGHT) {
   $ \5 R) u" {% v! m& r3 T3 s
7.         *(ptr+i) = color;
   
8.     }
   , h2 |8 j# {0 E- ~' k+ _( r
9. }</font>

复制代码

最后实现lcd初始化函数，先刷显存，然后开背光，防止设备上电时屏幕闪烁：
  Z* U3 s7 F+ R! |2 y: f. \

1. <font face="微软雅黑" size="3">void lcd_init()
   
2. {
   0 {) N+ |( ~6 k3 s2 |  a8 {
3.     lcd_clear(BLACK);
   
4.     lcd_backlight_control(255);
   ) y7 N0 w( b2 N- L" Q: Q2 U$ y
5. }</font>

复制代码

3. lcd单次清屏时间测试
在main.c中包含驱动头文件：

1. <font face="微软雅黑" size="3">#include "lcd_rgb_ltdc_drv.h"</font>

复制代码

在main函数中的sdram初始化函数之后，添加lcd初始化函数，并使用HAL库自带的systick时间戳测量一次清屏的时间：

1. <font face="微软雅黑" size="3">/* USER CODE BEGIN 2 */
   5 g% D3 L0 L1 K' F, ?
2. printf("sdram test by mculover666\r\n");
   & M5 C- h! `* A6 z
3. SDRAM_Init();
   7 }( R: e  T$ b1 I5 F" G2 r: n
4. printf("sdram init success\r\n");
   ) \) h- l' J! q+ _% K
5. 
   0 u* b9 ]! Q) D3 ]
6. lcd_init();
   9 k' F$ Q5 I6 N6 `
7. 
   
8. start_time = HAL_GetTick();
     n" M" O8 ?: M
9. lcd_clear(PINK);
   
10. end_time = HAL_GetTick();
    
11. 
      e* }/ |; a  M' p
12. printf("lcd clear spend time:%ld ms\r\n", end_time - start_time);
    
13. /* USER CODE END 2 */</font>

复制代码

编译、运行，在串口助手可以看到使用CPU搬运数据到显存中，在-Og优化等级下单次清屏需要 155 ms左右，在-O0优化等级下单次清屏需要321ms左右：


) p  ~/ `  U) i
; O+ K9 R5 W  v; ^二、使用DMA2D加速显存数据搬运
% C) l. G+ B, t5 i1. DMA2D
在STM32中，DMA2D外设专门用来给LCD显示加速，有LTDC外设的型号中，通常也会配套有DMA2D。
# q0 k4 T/ J2 i2 G4 T. S! h' j
4 c! Z' G$ _1 M1 c3 n% o! v
$ s. N1 y3 @' H# cDMA2D外设主要提供了两个功能：
! F6 X! z1 G% u2 }
# b) c) d( g5 ]: O
- x' B+ O% W8 Q: C, oDMA数据搬运：常用从寄存器到存储器、存储器到存储器两种模式，快速高效，并且不占用cpu资源；
2 i8 |* \% ^9 V8 f2D图形加速：支持快速格式转换和混合；
本文中主要使用到DMA2D外设的数据搬运功能，使用起来也是比较简单。


2. 开启DMA2D

* T+ Y1 y# O9 s1 w重新生成工程，cubemx会自动生成并调用dma2d初始化函数，完成dma2d外设时钟使能以及dma2d传输模式配置。
  n+ y/ Z8 N9 [5 @* }4 @
# U  Z; F9 h* a9 P$ x5 v
3. 使用DMA2D实现lcd清屏函数
在lcd驱动头文件中添加一个宏定义，用于控制是否使能DMA2D：

1. <font face="微软雅黑" size="3">/**
   " F3 E3 C2 V# P
2. * @brief   whether use dma2d to transfer data to lcd framebuffer.
   
3. */
   
4. #define USE_DMA2D_EN        1</font>

复制代码

接着对DMA2D传输操作进行封装，编写一个DMA2D传输函数：
  L% i1 h: y) f3 b. H  i

1. <font face="微软雅黑" size="3">static void dma2d_transfer_data_r2m(uint32_t *addr, uint32_t xSize, uint32_t ySize, uint32_t offsetLine, uint16_t color)
   ( k1 I! B! f8 M6 b1 E
2. {
   4 ~2 r8 x9 P7 o  h, E1 M
3.     DMA2D->CR = DMA2D_R2M;   // dma2d mode: register to memory.
   ' P, O4 ?8 M! H8 J
4.     DMA2D->OPFCCR = DMA2D_OUTPUT_RGB565;
   . ]2 B  U. ~) o
5. 
   & z3 ]& K1 l* {7 w' B- I
6.     DMA2D->OCOLR = color;
   
7.     DMA2D->OMAR = (uint32_t)addr;
   
8.     DMA2D->OOR = offsetLine;
   
9.     DMA2D->NLR = (uint32_t)(xSize << 16) | (uint16_t)ySize;
   
10.    
    
11.     DMA2D->CR |= DMA2D_CR_START;
    
12.     while (DMA2D->CR & DMA2D_CR_START);
    
13. }</font>

复制代码

利用此DMA2D传输函数，重新添加清屏函数的实现：

1. <font face="微软雅黑" size="3">void lcd_clear(uint16_t color)
   
2. {
   
3. #if USE_DMA2D_EN
   ! ?5 T+ N9 q1 _3 F& u
4.     dma2d_transfer_data_r2m((uint32_t *)LCD_FRAME_BUFFER, LCD_WIDTH, LCD_HEIGHT, 0, color);
   
5. #else
   
6.     uint16_t *ptr = (uint16_t*)LCD_FRAME_BUFFER;
   * k$ w1 A; b8 ]& u! }
7.     uint32_t i = 0;
   
8. 
   
9.     while (i++ < LCD_WIDTH*LCD_HEIGHT) {
   2 ]9 J/ g  m$ D" {
10.         *(ptr+i) = color;
    
11.     }
    : d+ e: D: P# }3 h5 f
12. #endif /* USE_DMA2D_EN */
    " m" p! ~) i' u9 Y3 J6 ]
13. }</font>

复制代码

上层测试代码不变，确保控制dma2d的宏使能：

1. <font face="微软雅黑" size="3">
   9 o3 z0 b/ e% ]7 V+ k
2. #define USE_DMA2D_EN        1</font>

复制代码

编译、下载，在串口助手中查看清屏一次所需时间：

可以看到，刷屏一次只需31ms即可，并且在使用dma2d传输数据的情况下，数据传输时间和编译优化等级无关。
, O/ z" S+ Z( M2 c- a
/ f7 @! g# D$ T. Y" x' P+ `; ^) f2 _
& f& _! E: q% m三、LCD基本功能实现
# v/ p+ Q" X8 n. VLCD基本功能包括打点、读点、画线、绘图等函数。

6 r( J0 ]4 ?7 a
1. 打点函数
  ?- H% t  G! M; |  J$ y+ C打点函数的核心是计算当前用户给出的坐标位置在显存中的位置，两种实现如下：
; u+ x$ g, X3 g7 |) n( Q) V" l

1. <font face="微软雅黑" size="3">void lcd_draw_point(uint16_t x, uint16_t y, uint16_t color)
   ; e& n# `+ _  x$ e$ X4 f5 ]& x- h' Y
2. {
   0 V4 Y1 a) ^  D. E: F& |6 O  Y
3.     uint32_t pos;
   . p  E' J0 h. _1 _
4.     uint16_t *ptr;
   
5. 
   9 [5 O: u$ [$ n7 y6 P
6.     // check position.
   1 [1 R0 l; m* Z
7.     if (x > LCD_WIDTH || y > LCD_HEIGHT) {
   ( I8 o4 G' r1 f2 ~/ ]4 T, N9 d
8.         return;
   
9.     }
   # u$ T! C' w/ k' R
10. 
    
11.     // calculate the position offset in framebuffer.
    ' z7 a6 @$ ~/ \; `$ D7 H& t
12.     pos = x + y*LCD_WIDTH;
    0 m9 L- t% }1 e0 k- \
13.     ptr = (uint16_t*)LCD_FRAME_BUFFER;
    
14. 
    
15.     // modify the framebuffer.
    
16. #if USE_DMA2D_EN
    6 i* F3 \# P' m( c
17.     dma2d_transfer_data_r2m((uint32_t *)(ptr+pos), 1, 1, 0, color);
    
18. #else
    8 `" w. x! y) a7 y7 V
19.     *(ptr+pos) = color;
    , F# O5 W$ C- Y
20. #endif /* USE_DMA2D_EN */
    ' ^" o$ c7 B: I. I
21. }</font>

复制代码

2. 读点函数实现
% y8 Q* F- ?4 A! U0 q读点函数实现的核心也是计算出用户给出的坐标位置在显存中的位置：
+ m: j9 ~8 q: y% n) g
$ ]% \! @* I7 U  m3 y" H

1. <font face="微软雅黑" size="3">uint16_t lcd_read_point(uint16_t x, uint16_t y)
   
2. {
   
3.     uint32_t pos;
   
4.     uint16_t *ptr, data;
   * L6 |8 i+ c7 u& z
5. 
   
6.     // check position.
   6 b. @/ [( ^  a$ g" c# Z! l5 V
7.     if (x > LCD_WIDTH || y > LCD_HEIGHT) {
   # a9 R) i/ L7 V0 q6 E
8.         return 0;
   0 T. Q  E" @2 `0 D
9.     }
   ( m5 Z* R- |( e* o4 t
10. 
    & ]4 X0 ^6 h( c4 u# ^1 d& K
11.     // calculate the position offset in framebuffer.
    
12.     pos = x + y*LCD_WIDTH;
    
13.     ptr = (uint16_t*)LCD_FRAME_BUFFER;
    
14. 
    
15.     // read the framebuffer.
    
16.     data = *(ptr+pos);
    9 }3 k& F2 D; A4 J2 N: L0 R, Y
17. 
    ) I/ c+ T/ ?% W6 n
18.     return data;
    : k- U5 f* f. n8 V. G- \& A
19. }</font>

复制代码

3. 画线、画矩形、画圆
这三个功能都是基于打点函数，使用 Bresenham 算法，代码篇幅过多，如有兴趣可直接查看本篇源码。


4. 测试
6 L* L; J3 n- {  N9 \在main函数中添加测试代码：
- Y+ o/ @8 w! D3 N8 G: `( i
. T% P# x4 ]9 {! l' W2 P

1. <font face="微软雅黑" size="3">lcd_draw_line(0, 0, 1024, 600, GREEN);
   % H( O; q: y! a/ A
2. lcd_draw_line(0, 300, 1024, 300, RED);
   
3. lcd_draw_line(512, 0, 512, 600, BLUE);
   7 U# x. u0 U9 s
4. lcd_draw_line(1024, 0, 0, 600, YELLOW);
   ; b4 V5 \8 j( j, a! x
5. 
   
6. lcd_draw_rect(256, 150, 1024-256, 600-150, PINK);</font>

复制代码

编译，下载，结果如下图：
# f6 j( F7 m' O! z4 e, j