前言
2 z% r. ?# ~/ Z  h" ^( W* QGPU即图形处理器，是现代显卡的核心。在没有GPU的时代，所有图形的绘制都是由CPU来完成的，CPU需要计算图形的边界、颜色等数据，并且负责将数据写入显存。简单的图形还没有什么问题，但随着计算机的发展（尤其是游戏的发展），需要显示的图形图像越来越复杂，CPU也就越来越力不从心。所以后来GPU应运而生，将CPU从繁重的图形计算任务中拯救了出来，大大加速了图形的显示速度。

8 h8 e# \; v( m$ f
而单片机这边也有类似的发展历程。在早期的单片机使用场景中，极少有图形显示的需求。即使有，也只是简单的12864之类的显示设备，运算量不大，单片机的CPU可以很好的处理。但是随着嵌入式图形的发展，单片机需要承担的图形计算和显示任务越来越多，嵌入式系统的显示分辨率和色彩也一路飙升。慢慢地，单片机的CPU对这些计算就开始力不从心了。所以，自STM32F429开始，一个类似GPU的外设开始加入到STM32的单片机中，ST称之为Chrom-ART Accelerator，也叫DMA2D（本文将使用此名称）。DMA2D可以在很多2D绘图的场合提供加速，完美嵌合了现代显卡中“GPU”的功能。


虽然这个“GPU”只能提供2D加速，而且功能非常简单，与PC中的GPU不可同日而语。但是它已经可以满足大多数嵌入式开发中的图形显示加速需求，只要用好了DMA2D，我们在单片机上也可以做出流畅、华丽的UI效果。


6 c5 R9 g4 @( d! ?# U4 h: x本文将从实例出发，介绍DMA2D在嵌入式图形开发中的可以发挥的作用。目的是使读者能简单、快速地对DAM2D的建立最基本的概念并且学会最基本的用法。为了防止内容过于晦涩和难懂，本文不会对DMA2D的高级功能和特性进行深入地刨析（如详细介绍DMA2D的架构、全部的寄存器等等）。如果需要更加详细、专业地学习DAM2D，可以在阅读完本文后参考《STM32H743中文编程手册》。


阅读本文之前需要对STM32中的TFT液晶控制器（LTDC）和基本的图形知识（如帧缓冲framebuffer、像素、颜色格式等概念）有一定的了解。
' ~, p! v) d* T" J3 [2 q# E( r% |

. }1 s; h- w, C; `; N8 {2 ?另，除了ST之外，其他不少厂商生产的MCU中也存在类似功能的外设（如NXP在RT系列中设计的的PxP），不过这些不在本文的讨论范围内，有兴趣的朋友可以自行了解。
2 e5 [  C% k( u3 N
# i( q' g0 g+ X9 O& d& M7 A/ @
准备工作
硬件准备
可以使用任何的，带有DMA2D外设的STM32开发板来验证本文中的例子，如STM32F429，STM32F746，STM32H750等MCU的开发板。本文中使用的开发板是ART-Pi 。ART-Pi是由RT-Thread官方出品的开发板，采用了主频高达480MHz的STM32H750XB+32MB SDRAM的强悍配置。而且板载了调试器（ST-Link V2.1），使用起来非常方便，特别适合各种技术方案的验证，用来作为本文的硬件演示平台再合适不过了。

. E- O& r# V' {
显示屏可以是任意的彩色TFT显示屏，推荐使用16位或24位颜色的RGB接口显示屏。本文中使用的是一块 3.5‘’ 的TFT液晶显示屏，接口为RGB666，分辨率为320x240（QVGA）。在LTDC中，配置使用的颜色格式为RGB565
* o. }8 s2 ~' H3 W% s  B% y# i* ]: y

% C  i& C& B1 ?, I. F4 L- S. O4 p
  G1 `4 |+ G* o

8 _0 @/ W# F* ^& n4 W! d! \# D开发环境准备
/ p( k0 ?" _  Z- Y4 b. t本文中介绍的内容和出现的代码可以在任何你喜欢的开发环境中使用，如RT-Thread Studio，MDK，IAR等。

8 }8 R0 F2 x$ [* _. T1 N" L1 Y
开始本文的实验前你需要一个以framebuffer技术驱动LCD显示屏的基本工程。运行本文中所有的代码前都需要预先使能DMA2D。


; ~) O/ _' Z7 ^- _- h6 g: r使能DMA2D可以通过这个宏来实现（硬件初始化时使能一次即可）：

" s$ h( k) c5 X
% p8 e# t7 u( V, U: U" p$ |" W

1. <font face="微软雅黑" size="3">1// 使用DMA2D之前一定要先使能DMA2D外设
   
2. 
   
3. 2__HAL_RCC_DMA2D_CLK_ENABLE();
   
4. 
   
5. </font>

复制代码

5 s2 _! q/ M4 q7 ~7 D6 l( MDMA2D的简介
2 w8 \- V1 c; ~$ X7 i我们先来看看ST是怎么描述DMA2D的
$ |: |4 m( h( \6 j5 g4 A. {

3 t4 a4 F' p' b$ ~, G( W5 u. ]
  I0 v; Q3 U  e- {% J5 a: f; s

( I* b; z, ?1 ?4 B  o" _7 `乍一看有点晦涩，但其实说白了就以下几个功能:
4 K9 w2 u' K$ m( B- Y3 C

• 颜色填充（矩形区域）
• 图像（内存）复制
• 颜色格式转换（如YCbCr转RGB或RGB888转RGB565）
• 透明度混合（Alpha Blend）
  

前两种都是针对内存的操作，后两个则是运算加速操作。其中，透明度混合、颜色格式转换可以和图像复制一起进行，这样就带来了较大的灵活性。
. h$ {' _- @' ?- M" _. r5 x* G5 _

( @& z$ A: I8 p3 s  ~( r: P可以看到，ST对DMA2D的定位就像它的名字一样，是一个针对图像处理功能强化过的DMA。而在实际开发的过程中，我们会发现DMA2D的使用方式也非常类似传统的DMA控制器。在某些非图形处理场合，DMA2D甚至也可以代替传统的DMA来发挥作用。
# J8 I4 k/ W2 |1 V- @

. A& ]# P1 M" E  T3 |- c! V需要注意的是，ST的不同产品线的DMA2D加速器是有微小区别的，比如STM32F4系列MCU的DMA2D就没有ARGB和AGBR颜色格式互转的功能，所以具体需要用到某个功能的时候，最好先查看编程手册看所需的功能是否被支持。
/ R7 D4 j8 ^+ X) C
9 A* R4 ?( T4 X! U' @
$ u! {3 a- \) b5 o+ r本文只介绍所有平台的DMA2D共有的功能。
$ x+ K: [+ d5 T& ^4 S, J. j

  {4 A6 G1 c: }  U7 u# G3 z5 cDMA2D的工作模式
就像传统DMA有外设到外设，外设到存储器，存储器到外设三种工作模式一样，DMA2D作为一个DMA，也分为以下四种工作模式：

  H( N7 h2 @  w, u+ W6 y3 G2 f5 }- o! h
寄存器到存储器


9 X% }( {0 k' n% P: N! h- W存储器到存储器


0 _) L+ n. E6 e7 ?存储器到存储器并执行像素颜色格式转换
" S3 r' ]- v  o0 O

存储器到存储器且支持像素颜色格式转换和透明度混合
- m' ]7 p  ?9 |" H2 S

# b  }' k# Y/ N& u可以看出，前两种模式起始就是简单的内存操作，而后面两种模式，则是在进行内存复制时，根据需要同时进行颜色格式转换或/和透明度混合。


DMA2D和HAL库
大多数情况下，使用HAL库可以简化代码编写，提高可移植性。但是在DMA2D的使用时则是个例外。因为HAL库存在的最大问题就是嵌套层数再加上各种安全检测过多效率不够高。在操作别的外设时，使用HAL库损失的效率并不会有多大的影响。但是对于DMA2D这种以计算和加速为目的的外设，考虑到相关的操作会在一个屏幕的绘制周期内被多次调用，此时再使用HAL库就会导致DAM2D的加速效率严重下降。
3 E1 U2 ?: k+ `; T

所以，我们大多时候都不会用HAL库中的相关函数来对DMA2D进行操作。为了效率，我们会直接操作寄存器，这样才能起到最大化的加速效果。


因为我们使用DMA2D的大多数场合都会频繁变更工作模式，所以CubeMX中对DMA2D的图形化配置也失去了意义。


DMA2D场景实例
! h7 c, q2 |5 h4 b" q0 M7 {1 u8 G1. 颜色填充
0 u7 e, |7 j% K/ Z: a下图是一个简单的柱状图：
& ?3 R* M5 n' _: \0 O! j) g
: M/ \4 A$ v1 f, Y0 f* T9 r9 L# `

+ W5 m9 F, }8 k) l6 ^0 C$ Q1 Y
7 l  ?' M& x4 F
1 Q: @8 i1 g: a3 B7 S我们来思考一下如何把它绘制出来。


首先，我们需要使用白色来填充屏幕，作为图案的背景。这个过程是不能忽略的，否则屏幕上原来显示的图案会对我们的主体产生干扰。然后，柱状图其实是由4个蓝色的矩形方块和一条线段构成的，而线段也可以视作一个特殊的，高度为1的矩形。所以，这个图形的绘制可以分解为一系列“矩形填充”操作：
& Q( i/ ~+ s1 {, t
" i% A1 a3 G6 V0 s0 Z8 n; a' G

• 使用白色填充一个大小等于屏幕大小的的矩形
• 使用蓝色填充四个数据条
• 使用黑色填充一根高度为1的线段
  

& M6 n+ [% R8 S1 a1 o0 j. ]/ K
在画布中实现任意位置绘制任意大小的矩形的本质就是将内存区域中对应像素位置的数据设定为指定的颜色。但是因为framebuffer在内存中的存储是线性的，所以除非矩形的宽度正好和显示区域的宽度重合，否看似连续的矩形的区域在内存中的地址是不连续的。
* t! d, K! m8 |, F

: [$ u3 b$ `. U. C0 W* u6 o下图展示了典型的内存分布情况，其中的数字表示了frame buffer中每个像素的内存地址（相对首地址的偏移，这里忽略掉了一个像素占多个字节的情况），蓝色区域是我们要填充的矩形。可以看出矩形区域的内存地址是不连续的。

4 F, i/ N7 v1 ?+ s$ h: ]: y- z
; z7 \. h3 X8 z- C3 n" C( c) G# Z
% X5 [8 s4 \- F- o$ q% a! a9 b  {framebuffer的这种特性使得我们不能简单使用memset这类高效的操作来实现矩形区域的填充。通常情况下，我们会使用以下方式的双重循环来填充任意矩形，其中xs和ys是矩形左上角在屏幕上的坐标，width和height表示矩形的宽和高，color表示需要填充的颜色：


; Q% e+ e4 ^5 b' Y/ s% ]9 p' t7 s

1. <font face="微软雅黑" size="3">1for(int y = ys; y < ys + height; y++){
   
2. 
   5 y6 c" w: d# d/ L
3. 2    for(int x = xs; x < xs + width; x++){
   
4. 
   
5. 3        framebuffer[y][x] = color;        
   
6. 
   
7. 4    }
   7 m0 ]0 N( o' h8 P
8. 
   . v/ ?# W# z9 F4 I" ?
9. 5}</font>

复制代码

代码虽然简单，但实际执行时，大量的CPU周期浪费在了判断、寻址、自增等的操作，实际写内存的时间占比很少。这样一来，效率就会下降。
# ]) X8 q1 S0 L, v
  B% S$ A- D' R6 j* o  I
8 u3 W! `' W' H' z9 g这时候DMA2D的寄存器到存储器工作模式就可以发挥用场了，DAM2D可以以极高的速度填充矩形的内存区域，即使这些区域在内存中实际是不连续的。
$ F0 m: ]2 ?+ a+ z( j2 r1 w2 l. `1 V
: q9 Y/ ^) k- u- ]& W, Z. r* `
依然以这张图中演示的情况为例，我们来看它是如何实现的：
$ l4 b* j2 X. L5 n% p1 }


! d& Q" N& \7 m4 W8 o5 r

& Z0 K7 i3 D" E$ b- h首先，因为我们只是进行内存填充，而不需要进行内存拷贝，所以我们要让DAM2D工作在寄存器到存储器模式。这通过设置DMA2D的CR寄存器的[17:16]位为11来实现，代码如下：

1. <font face="微软雅黑" size="3">1DMA2D->CR = 0x00030000UL;</font>

复制代码

然后，我们要告诉DAM2D要填充的矩形的属性，比如区域的起始地址在哪里，矩形的宽度有多少像素，矩形的高度有多少。
$ W3 S6 y' Y; A/ [( Z  C% \" |9 y* t

区域起始地址是矩形区域左上角第一个像素的内存地址（图中红色像素的地址），这个地址由DAM2D的OMAR寄存器管理。而矩形的宽度和高度都是以像素为单位的，分别由NLR寄存器的高16位（宽度）和低16位（高度）来进行管理，具体的代码如下：


0 c" Z8 C* ?1 G- [# G1 R

1. <font face="微软雅黑" size="3">1DMA2D->OMAR = (uint32_t)(&framebuffer[y][x]); // 设置填充区域的起始像素内存地址
   
2. 
   
3. 2DMA2D->NLR  = (uint32_t)(width << 16) | (uint16_t)height; // 设置矩形区域的宽高
   ' x; w6 ]+ B6 X* ?1 C8 t3 V9 b2 F
4. 
   
5. </font>

复制代码

4 Z, O- R) p2 O+ h" T& N" }$ Z& k
接着，因为矩形在内存中的地址不连续，所以我们要告诉DMA2D在填充完一行的数据后，需要跳过多少个像素（即图中黄色区域的长度）。这个值由OOR寄存器管理。计算跳过的像素数量有一个简单的方法，即显示区域的宽度减去矩形的宽度即可。具体实现代码如下：
- Y; K( y' t( F  X- I2 t2 }

1. <font face="微软雅黑" size="3">1DMA2D->OOR = screenWidthPx - width; // 设置行偏移，即跳过的像素</font>

复制代码

最后，我们需要告知DAM2D，你将使用什么颜色来进行填充，颜色的格式是什么。这分别由OCOLR和OPFCCR寄存器来管理，其中颜色格式由LTDC_PIXEL_FORMAT_XXX宏来定义，具体代码如下：


: }; t0 ~" S; M7 Y4 I$ Q5 ~

1. <font face="微软雅黑" size="3">1DMA2D->OCOLR   = color; // 设置填充使用的颜色
   % z( ~4 }% r, j% |5 e
2. 
   
3. 2DMA2D->OPFCCR  = pixelFormat; // 设置颜色格式，比如想设置成RGB565，就可以使用宏LTDC_PIXEL_FORMAT_RGB565</font>

复制代码

7 q5 w! q% N/ l, @


( @) {  \. U; J% Q( j, e) A9 p一切都设置完毕，DMA2D已经获取到了填充这个矩形所需要的全部信息，接下来，我们要开启DMA2D的传输，这通过将DMA2D的CR寄存器的第0位设置为1来实现：
' P& H" J' m' |
0 r) b2 ~" u6 W7 L/ L
, t) U: P4 V( Z( U- G" y( k

1. <font face="微软雅黑" size="3">1DMA2D->CR |= DMA2D_CR_START; // 开启DMA2D的数据传输，DMA2D_CR_START是一个宏，其值为0x01</font>

复制代码

) y5 J# [5 ?) i: }6 x
, f8 s, ?' J, C2 l  x/ Z
" Y, x; ]* p  G* U+ T
等DMA2D传输开始后，我们只需要等待它传输完毕即可。DAM2D传输完成后，会自动把CR寄存器的第0位设置为0，所以我们可以通过以下代码来等待DAM2D传输完成：

1 Z3 V* A" S* S( D2 S

1. <font face="微软雅黑" size="3">1while (DMA2D->CR & DMA2D_CR_START) {} // 等待DMA2D传输完成</font>

复制代码

tips0：如果你使用了OS，则可以使能DMA2D的传输完毕中断。然后我们可以创建一个信号量并且在开启传输后等待它，随后在DMA2D的传输完毕中断服务函数中释放该信号量。这样的话CPU就可以在DMA2D工作的时候去干点别的事儿而不是在此处傻等。
& E) H/ j& u9 r. @

: p1 z8 J+ C$ `tips1：当然，由于实际执行时，DMA2D进行内存填充的速度实在是太快了，以至于OS切换任务的开销都比这个时间要长，所以即便使用了OS，我们还是会选择死等 。
. [- S$ D# ^1 b# n

9 c6 W8 H0 w0 x8 E- h为了函数的通用性考虑，起始传输地址和行偏移都在函数外计算完毕后传入，我们抽出的完整的函数代码如下：

1. <font face="微软雅黑" size="3">1static inline void DMA2D_Fill( void * pDst, uint32_t width, uint32_t height, uint32_t lineOff, uint32_t pixelFormat,  uint32_t color) {
   
2. 2
   
3. 3    /* DMA2D配置 */  
   ) E2 `# r; w( b4 @7 [# }; A
4. 4    DMA2D->CR      = 0x00030000UL;                                  // 配置为寄存器到储存器模式
   
5. 5    DMA2D->OCOLR   = color;                                         // 设置填充使用的颜色，格式应该与设置的颜色格式相同
   
6. 6    DMA2D->OMAR    = (uint32_t)pDst;                                // 填充区域的起始内存地址
   - ~# ?3 E# r5 e/ W2 R
7. 7    DMA2D->OOR     = lineOff;                                       // 行偏移，即跳过的像素，注意是以像素为单位
   
8. 8    DMA2D->OPFCCR  = pixelFormat;                                   // 设置颜色格式
   ! I- O9 ~( ]- o  u5 V1 x
9. 9    DMA2D->NLR     = (uint32_t)(width << 16) | (uint16_t)height;    // 设置填充区域的宽和高，单位是像素
   
10. 10
    
11. 11    /* 启动传输 */
    0 u$ s0 C! X& h) i5 z
12. 12    DMA2D->CR   |= DMA2D_CR_START;   
    ! |- b7 B( |( Y: E# J' Y" j
13. 13
    
14. 14    /* 等待DMA2D传输完成 */
    7 R# ~. S, O5 P  V
15. 15    while (DMA2D->CR & DMA2D_CR_START) {}
    1 p2 \* F" [- h# P0 |$ V
16. 16}</font>

复制代码

为了方便编写代码，我们再包装一个针对所使用屏幕坐标系的矩形填充函数：


) e: d9 U; m7 m* R9 s

1. <font face="微软雅黑" size="3">1void FillRect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color){
   
2. 
   
3. 2    void* pDist = &(((uint16_t*)framebuffer)[y*320 + x]);
   $ _7 Y2 a% ?. N3 ~+ L; x4 C
4. 
   
5. 3    DMA2D_Fill(pDist, w, h, 320 - w, LTDC_PIXEL_FORMAT_RGB565, color);
   
6. 
   8 u+ Q; P4 M( ~  O+ D, L
7. 4}
   
8. 
   
9. </font>

复制代码

最后我们尝试用代码把本小节刚开始的示例图表画出来：
% A5 T( f, K- G+ [" R( M8 D
  T, q2 |: L' E
- T+ |: `1 V2 \* @! p1 @$ b8 P

1. <font face="微软雅黑" size="3">1  // 填充背景色
   ( G: L5 l8 ^; g+ x* Z' |
2. 
   : g& x+ B' N3 J: w$ W+ K2 D) n
3. 2  FillRect(0,   0,   320, 240,  0xFFFF);
   5 K# M+ r( n/ m( X& }
4. 
     k3 z3 d. m$ L- G, V# A1 U" n
5. 3  // 绘制数据条
   / h* Z8 [5 d8 o3 H# s; b4 _- r
6. 
   
7. 4  FillRect(80,  80,  20,  120,  0x001f);
   # \; a1 [. ~4 S8 {1 z4 [
8. 
   
9. 5  FillRect(120, 100, 20,  100,  0x001f);
   
10. 
    2 G& Y% w( I( s; Z+ V# Q) S/ Z2 \
11. 6  FillRect(160, 40,  20,  160,  0x001f);
    6 S9 }% R" h( d* O
12. 
    
13. 7  FillRect(200, 60,  20,  140,  0x001f);
    / w- ~4 Y) ^, `% V7 m2 L# [
14. 
    0 C2 [. l( ~: T- B; A
15. 8  // 绘制X轴
    
16. 
    
17. 9  FillRect(40,  200, 240, 1,    0x0000);
    * O. M5 Z# C6 ^- R) i
18. 
    5 T. R3 g" e% g( k
19. </font>

复制代码

代码运行效果：
% z7 X+ k0 E: G6 i  k9 U" r4 A+ q4 z# I


7 }1 y# i# C/ d$ q4 y
, `" Q# ?0 O$ U0 P) E9 ~
0 m: Z; P: T1 E3 O2 m1 ~2.图片显示(内存复制)
假设我们现在要开发一个游戏，然后想在屏幕上显示一团跳动的火焰。一般是由美工先把火焰的每一帧都画出来，然后放到同一张图片素材里面，如下图所示：



然后我们以一定的间隔轮流显示每一帧图像，就可以在屏幕上实现“跳动的火焰”这个效果了。

# I3 F6 ]) Y9 d# L* b9 F
我们现在略过素材文件加载到内存的过程，假设这张素材图片已经在内存中了。然后我们来考虑如何将其中的一帧图片显示到屏幕上。通常情况下，我们会这样实现：先计算得出每一帧的数据在内存中的地址，然后将这一帧图片的数据复制到framebuffer中相应的位置即可。代码类似于这样：
  L) ^8 q+ }- {7 d7 r

1. <font face="微软雅黑" size="3">1/**
   , h% h# x6 `7 i! Y* n
2. 2 * 将素材中的一帧画面复制到framebuffer中的对应位置
   % p. }" s; R4 E+ u
3. 3 * index为画面在帧序列中的索引
   % B7 K3 C  f. C; Q
4. 4 */
   
5. 5static void General_DisplayFrameAt(uint16_t index) {
   ( B7 @, S+ }& L9 O9 ]- N
6. 6    // 宏说明
   
7. 7    // #define FRAME_COUNTS     25  // 帧数量
   - V9 N- J! Y+ H7 V' N9 _' P- ]. Y
8. 8    // #define TILE_WIDTH_PIXEL 96  // 每一帧画面的宽度（等于高度）
   
9. 9    // #define TILE_COUNT_ROW   5   // 素材中每一行有多少帧
   % j0 ^0 e3 ]6 f1 z/ \" z# o$ q
10. 10
    : x! L  q$ Y+ g3 x# b
11. 11    // 计算帧起始地址
    
12. 12    uint16_t *pStart = (uint16_t *) img_fireSequenceFrame;
    
13. 13    pStart += (index / TILE_COUNT_ROW) * (TILE_WIDTH_PIXEL * TILE_WIDTH_PIXEL * TILE_COUNT_ROW);
    % K% G/ L! ?' c
14. 14    pStart += (index % TILE_COUNT_ROW) * TILE_WIDTH_PIXEL;
    
15. 15
    
16. 16    // 计算素材地址偏移
    
17. 17    uint32_t offlineSrc = (TILE_COUNT_ROW - 1) * TILE_WIDTH_PIXEL;
    ; u& d/ z2 Q  V4 p6 \
18. 18    // 计算framebuffer地址偏移（320是屏幕宽度）
    
19. 19    uint32_t offlineDist = 320 - TILE_WIDTH_PIXEL;
    
20. 20
    
21. 21    // 将数据复制到framebuffer
    - U6 E: J3 Z6 N' ^9 x
22. 22    uint16_t* pFb = (uint16_t*) framebuffer;
    4 z3 @+ ~4 ]. R8 Q( j# H" d* @
23. 23    for (int y = 0; y < TILE_WIDTH_PIXEL; y++) {
    ( `" k4 ?- o/ {4 @$ K
24. 24        memcpy(pFb, pStart, TILE_WIDTH_PIXEL * sizeof(uint16_t));
    
25. 25        pStart += offlineSrc + TILE_WIDTH_PIXEL;
    9 T& J" C3 `- A: |/ L; c) J& N
26. 26        pFb += offlineDist + TILE_WIDTH_PIXEL;
    4 s- v! O& |7 D% a  E7 ~
27. 27    }
    
28. 28}</font>

复制代码

可见要实现这个效果需要大量的内存复制操作。在嵌入式系统中，需要大量数据复制的时候，硬件DMA的效率是最高的。但是硬件DMA只能搬运地址连续的数据，而这里，需要复制的数据在源图片和frambuffer中的地址都是不连续的，这引来了额外的开销（与第一小节中出现的问题相同），也导致我们无法使用硬件DMA来进行高效的数据复制。


9 H1 g" }! t& k9 E7 C  R所以，虽然我们实现了目标，但是效率不高（或者说没有达到最高）。
9 T8 e; i+ H! l: C, d! s5 b$ F+ Z
. K4 a/ e4 P1 ]3 n, Z; ]& s7 {
为了以最快的速度把素材图片中的某一块数据搬运到帧缓冲中，我们来看如何使用DMA2D来实现。
& g, Y; j1 l7 _- v. F; Y0 J
& |$ x6 N2 J2 W7 X7 q! u+ M# R
+ K+ ?% R7 r0 k. b& [首先，因为这次是要在存储器中进行数据复制，所以我们要把DMA2D的工作模式设定为“存储器到存储器模式”，这通过设置DMA2D的CR寄存器的[17:16]位为00来实现，代码如下：

. u) b$ y/ c/ z: m! D. t8 p+ b

1. <font face="微软雅黑" size="3">1DMA2D->CR      = 0x00000000UL;</font>

复制代码

$ o. p% i  o! |8 x3 J  V& d! S
然后我们要分别设置源和目标的内存地址，与第一节中不同，因为数据源也存在内存偏移，所以我们要同时设定源和目标位置的数据偏移

1. <font face="微软雅黑" size="3">
   9 j- B" g4 }( d# g
2. 1DMA2D->FGMAR   = (uint32_t)pSrc; // 源地址
   
3. 
   5 R  E. O1 u) J
4. 2DMA2D->OMAR    = (uint32_t)pDst; // 目标地址
   , k$ n+ P: }; C2 O! G
5. 
   & R& @, v& h7 c* S
6. 3DMA2D->FGOR    = OffLineSrc;     // 源数据偏移（像素）
   8 B  ^+ o: s* V5 V, H. _
7. 
   
8. 4DMA2D->OOR     = OffLineDst;     // 目标地址偏移（像素）
   % y2 h, {- L4 x4 L; I! F8 N
9. </font>

复制代码

( k, O) \4 N& Y% L然后依然是设置要复制的图像的宽和高，以及颜色格式，这点与第一小节中的相同
  K& S) r% {6 B, [/ L* U' `

& j7 l- F( `) r3 @" |5 P

1. <font face="微软雅黑" size="3">1DMA2D->FGPFCCR = pixelFormat;
   - ]( q7 \& ?' q. s& C  ^9 ~( @1 Y
2. 
   5 o0 B9 k3 \1 y( [8 _, w' n
3. 2DMA2D->NLR     = (uint32_t)(xSize << 16) | (uint16_t)ySize;</font>

复制代码

同样的方式，我们开启DMA2D的传输，并等待传输完成：
1 [8 J- L# x6 f4 `7 C' }6 u

1. <font face="微软雅黑" size="3">1/* 启动传输 */
   ) P+ x1 X6 d" T4 [1 d/ L
2. 
   * f$ {* d$ ~, T' J
3. 2DMA2D->CR   |= DMA2D_CR_START;
   * B6 ^4 j7 @. O1 a/ ?3 H4 a
4. 
   ! J6 i- @7 T6 N; F' ^
5. 3
   $ _! a5 P& y2 N  t  T
6. 
   ' B  R2 |, v, Z& ^$ V, A7 Z1 n
7. 4/* 等待DMA2D传输完成 */
   ! {- h" f: s* A" V7 }6 y+ D
8. 
   
9. 5while (DMA2D->CR & DMA2D_CR_START) {}
   
10. </font>

复制代码

最终我们抽出的函数如下：

$ O; `2 `2 d8 |- ^& z
7 }7 ~% m" J- ?

1. <font face="微软雅黑" size="3"> 1static void DMA2D_MemCopy(uint32_t pixelFormat, void * pSrc, void * pDst, int xSize, int ySize, int OffLineSrc, int OffLineDst)
   
2. 
   ( q  z" ^9 f- S: [( h1 f
3. 2{
   
4. 
   
5. 3    /* DMA2D配置 */
   
6. 
   
7. 4    DMA2D->CR      = 0x00000000UL;
   
8. 
   
9. 5    DMA2D->FGMAR   = (uint32_t)pSrc;
   
10. 
    
11. 6    DMA2D->OMAR    = (uint32_t)pDst;
    % E) F8 Z7 I# U) q9 }" Z, y
12. 
    
13. 7    DMA2D->FGOR    = OffLineSrc;
    # l0 ]6 j: |2 k; S
14. 
    
15. 8    DMA2D->OOR     = OffLineDst;
    4 W6 p0 h9 M- X6 T  F. x: a/ }
16. 
    ' y1 p( B1 P" p/ @/ l4 s' {5 J/ x
17. 9    DMA2D->FGPFCCR = pixelFormat;
    
18. 
    
19. 10    DMA2D->NLR     = (uint32_t)(xSize << 16) | (uint16_t)ySize;
    
20. 
    & @. ~; r( k, {: A
21. 11
    8 ^, c9 k1 e# `& L) ?  i: N
22. 
    
23. 12    /* 启动传输 */
    
24. 
    
25. 13    DMA2D->CR   |= DMA2D_CR_START;
    
26. 
    ; l% v6 G$ f, Y$ n% d
27. 14
    : p$ K- F; x' P0 Y
28. 
    , v) o) p& V* N+ M
29. 15    /* 等待DMA2D传输完成 */
    " G, m1 p$ U; ]; i
30. 
    
31. 16    while (DMA2D->CR & DMA2D_CR_START) {}
      p+ B  i+ J3 i- x7 A7 l$ W9 ^
32. 
    0 U4 c# W  O8 n. N7 P' s' C
33. 17}
    
34. 
    
35. </font>

复制代码

% ^& W5 F9 d: K* H% A: q% e为了方便，我们包装一个调用它的函数：
, N& W# ?3 V4 P* f4 a; F

1. <font face="微软雅黑" size="3">1static void DMA2D_DisplayFrameAt(uint16_t index){
   - c  P2 o# I$ T# G  l6 [7 A) W9 @
2. 
   
3. 2
   , W8 T3 @  H/ ~% M
4. 
   
5. 3    uint16_t *pStart = (uint16_t *)img_fireSequenceFrame;
   / G. |$ h- x( L& C+ N6 [& T. N
6. 
   
7. 4    pStart += (index / TILE_COUNT_ROW) * (TILE_WIDTH_PIXEL * TILE_WIDTH_PIXEL * TILE_COUNT_ROW);
   ' F; A# ^% v, c% v7 z
8. 
   5 a" p5 Q3 D0 ^' a+ Z
9. 5    pStart += (index % TILE_COUNT_ROW) * TILE_WIDTH_PIXEL;
   * t0 `, R5 U* A+ a
10. 
    . I/ S/ A3 H$ e
11. 6    uint32_t offlineSrc = (TILE_COUNT_ROW - 1) * TILE_WIDTH_PIXEL;
    
12. 
    
13. 7
    
14. 
    , f8 q4 V8 y1 c- G: O
15. 8
    
16. 
    4 o  s$ Z: {5 \/ K
17. 9    DMA2D_MemCopy(LTDC_PIXEL_FORMAT_RGB565, (void*) pStart, pDist, TILE_WIDTH_PIXEL, TILE_WIDTH_PIXEL, offlineSrc, offlineDist);
    ! l8 |/ C; X! c6 |3 S, l' K
18. 
    
19. 10}</font>

复制代码

然后轮流播放每一帧图片，这里设置的帧间隔是50毫秒，并且将目标地址定义到了frambuffer的中央：

. R* n$ }$ z  E5 A* i) S! |8 L
0 S6 P. p0 w: n+ `) V1 ^

1. <font face="微软雅黑" size="3">1while(1){
   
2. 
   
3. 2    for(int i = 0; i < FRAME_COUNTS; i++){
   
4. 
   
5. 3        DMA2D_DisplayFrameAt(i);
   
6. 
   7 I, w. l1 W; l; y( D0 X. Q6 d# K2 Y
7. 4        HAL_Delay(FRAME_TIME_INTERVAL);
   
8. 
   
9. 5    }
   
10. 
    
11. 6}</font>

复制代码

: E- V7 c5 N( y0 S4 M" d
最终运行的效果：





+ g6 j% X; x- Y- [+ v! S8 m5 ~3.图片渐变切换
/ `7 T6 q$ f2 t! I/ ?0 p6 L8 @假设我们要开发一个看图应用，在两张图片进行切换时，直接进行切换会显得比较生硬，所以我们要加入切换时的动态效果，而渐变切换（淡入淡出）是一个很经常使用的，而且看起来还不错的效果。
' B# D( X. i  r0 F$ d

$ O' h4 `8 o2 p# Q9 ]就用这两张图片好了：




; ^9 c- u$ `0 I" I( J
6 n; y: W& R$ S* i2 E6 a这里我们需要先了解一下透明度混合（Alpha Blend）的基本概念。首先透明度混合需要有一个前景，一个背景。而混合的结果就相当于透过前景看背景时的效果。如果前景完全不透明，那么就完全看不到背景，反之如果前景完全透明，那么就只能看到背景。而如果前景是半透明的，则结果就是两者根据前景色的透明度按照一定的规则进行混合。
4 h# g4 a1 m/ I

& R8 L& A. Y( N1 Q+ J如果1表示完全透明，0表示不透明，则透明度的混合公式如下，其中A是背景色，B是前景色：
! F( d+ }+ C  T

1. <font face="微软雅黑" size="3">1X(C)=(1-alpha)*X(B) + alpha*X(A)</font>

复制代码

* B' c2 d7 g- r
$ o- ?8 R) r/ Y  w  _5 Z因为颜色有RGB三个通道，所以我们需要对三通道都进行计算，计算完成后在进行组合：
7 V7 w# B3 ~' a5 ^. r- X
0 B% \, @+ q8 F3 g8 \! d6 x: V

1. <font face="微软雅黑" size="3">1R(C)=(1-alpha)*R(B) + alpha*R(A)
   
2. 
   
3. 2G(C)=(1-alpha)*G(B) + alpha*G(A)
   ' K9 ]/ H8 @9 U- P* n/ [( X
4. 
   
5. 3B(C)=(1-alpha)*B(B) + alpha*B(A)</font>

复制代码

; F# L5 ]( ^, ]9 l& p
而在程序中为了效率起见（CPU对于浮点的运算速度很慢），我们并不用0~1这个范围的值。通常情况下我们一般会使用一个8bit的数值来表示透明度，范围从0~255。需要注意的是，这个数值越大表示越不透明，也就是说255是完全不透明，而0表示完全透明（所以也叫不透明度），然后我们可以得到最终的公式：


0 ~! X- Z. h4 P  U0 o% ~) r, V

1. <font face="微软雅黑" size="3">1outColor = ((int) (fgColor * alpha) + (int) (bgColor) * (256 - alpha)) >> 8;</font>

复制代码

实现RGB565颜色格式像素的透明度混合代码：
9 h: \9 `; Q' L1 M4 {' ~

7 L1 I( P+ ?; l6 C6 {
6 m: `) G2 h5 t! U! _( h0 z: K  W

1. <font face="微软雅黑" size="3">1typedef struct{
   
2. 
   
3. 2    uint16_t r:5;
   
4. 
   6 K/ \) \. x- Z* v
5. 3    uint16_t g:6;
   
6. 
   
7. 4    uint16_t b:5;
   , Y8 o% k$ \. N4 F# N; U1 I
8. 
   
9. 5}RGB565Struct;
   / v; i8 m+ @- Z
10. 
    
11. 6
    
12. 
    / B4 t& u: o. k/ e% F- ~
13. 7static inline uint16_t AlphaBlend_RGB565_8BPP(uint16_t fg, uint16_t bg, uint8_t alpha) {
    
14. 
    
15. 8    RGB565Struct *fgColor = (RGB565Struct*) (&fg);
    
16. 
    4 Q2 t  {5 }) `+ e+ G0 `6 G, e
17. 9    RGB565Struct *bgColor = (RGB565Struct*) (&bg);
    
18. 
    % F$ J) m$ C* |0 q) q9 m3 Y
19. 10    RGB565Struct outColor;
    & l( Z% t2 P- K- U
20. 
    2 R: a7 ~5 C9 `8 F' o5 n
21. 11
    - u* b- o. e! F/ k, k
22. 
    8 A9 B/ _/ G$ s; E! ^, o( M' w
23. 12    outColor.r = ((int) (fgColor->r * alpha) + (int) (bgColor->r) * (256 - alpha)) >> 8;
    8 e* \3 M; G; r2 l: a1 b
24. 
    
25. 13    outColor.g = ((int) (fgColor->g * alpha) + (int) (bgColor->g) * (256 - alpha)) >> 8;
    8 }- {4 O& ]* D( v0 n) N6 D
26. 
    
27. 14    outColor.b = ((int) (fgColor->b * alpha) + (int) (bgColor->b) * (256 - alpha)) >> 8;
    # `& W7 x, x2 N' m* R% ?- _- X
28. 
    7 `3 n8 o6 q& u# U
29. 15
    : _" r6 q: k0 G
30. 
    6 o' e; W8 T( a( Y) U6 Q. {) D
31. 16
    8 {& [* L6 h# q- \
32. 
    ; h" @  o/ r: O9 |
33. 17    return *((uint16_t*)&outColor);
    ! i' y* U- p6 Q
34. 
    
35. 18}</font>

复制代码

了解了透明度混合的概念，也实现了单个像素的透明度混合后，我们来看如何实现图片的渐变切换。
, L  Y( x. o- `, A, ?$ x( ~. A3 m$ y
5 {. L) J* M/ v, ?
) E& m% F6 b: v; T+ Q假设整个渐变在30帧内完成，我们需要在内存中开辟一块儿大小等于图片的缓冲区。然后我们以第一张图片（当前显示的图片）为背景，第二张图片（接下来显示的图片）为前景，然后为前景设置一个透明度，对每个像素进行透明度混合，并且将混合结果暂存至缓冲区中。待混合结束后，将缓冲区中的数据复制到framebuffer中即完成了一帧的显示。接下来继续进行第二帧、第三帧……逐渐增大前景的不透明度，直到前景色的变为不透明，即完成了图片的渐变切换。

7 A1 k+ G! L2 T+ x' X7 ^, m
3 M' \) V+ H9 F( F因为每一帧都需要对两张图片中的每一个像素都进行混合运算，这带了来巨大的运算量。交给CPU实现是很不明智的行为，所以我们还是把这些工作交给DMA2D来实现吧。
( [6 _* G- ^* P; Q
- {8 N( {" N6 Q& y9 I* W
; ]8 E: P0 V5 Z! @这次用到了DMA2D的混合功能，所以我们要使能DAM2D的带颜色混合的存储器到存储器模式，对应CR寄存器[17:16]位的值为10，即：

# N; ?9 |8 R% w! A+ |  c% M: H2 \

1. <font face="微软雅黑" size="3">1DMA2D->CR    = 0x00020000UL;                // 设置工作模式为存储器到存储器并带颜色混合
   * @( U2 j( t  y
2. </font>

复制代码

0 G2 O9 Y5 Z/ A2 \: O. ]1 v/ x. g然后分别设置前景、背景和输出数据的内存地址和数据传输偏移、传输图像的宽和高：
4 B/ j: N, _# ^4 J

1. <font face="微软雅黑" size="3">1DMA2D->FGMAR = (uint32_t)pFg;               // 设置前景数据内存地址
   
2. 
   
3. 2DMA2D->BGMAR = (uint32_t)pBg;               // 设置背景数据内存地址
   
4. 
   
5. 3DMA2D->OMAR  = (uint32_t)pDst;              // 设置数据输出内存地址
   2 ]* T5 S* A! k2 w3 B) i
6. 
   
7. 4
   , A- M. G0 D& g' m8 h! ~* ?$ i
8. 
   . L7 z2 w8 k. p# }: f
9. 5DMA2D->FGOR  = offlineFg;                   // 设置前景数据传输偏移
   / I9 T+ N. e3 z8 G& h1 o6 S. `
10. 
    
11. 6DMA2D->BGOR  = offlineBg;                   // 设置背景数据传输偏移
    $ F( S: I# f9 q
12. 
    
13. 7DMA2D->OOR   = offlineDist;                 // 设置数据输出传输偏移
    
14. 
    
15. 8
    
16. 
    9 o" I/ R6 e# i9 i
17. 9DMA2D->NLR = (uint32_t)(xSize << 16) | (uint16_t)ySize; // 设置图像数据宽高（像素）</font>

复制代码

; U! g# E; t4 J7 H6 H设置颜色格式。这里设置前景色的颜色格式时需要注意，因为如果使用的是ARGB这样的颜色格式，那么我们进行透明度混合时，颜色数据中本身的alpha通道就会对混合结果产生影响，所以我们这里要设定在进行混合操作时，忽略前景色自身的alpha通道。并强制设定混合时的透明度。


输出颜色格式和背景颜色格式
# Y& a: @" F! K9 E/ N, z5 o5 r

1. <font face="微软雅黑" size="3">1DMA2D->FGPFCCR = pixelFormat                // 设置前景色颜色格式
   
2. 
   
3. 2        | (1UL << 16)                       // 忽略前景颜色数据中的Alpha通道
   
4. 
   
5. 3        | ((uint32_t)opa << 24);            // 设置前景色不透明度
   7 K) s8 |; J/ c
6. 
   
7. 4
   
8. 
   
9. 5DMA2D->BGPFCCR = pixelFormat;               // 设置背景颜色格式
   
10. 
    7 I  H' [% Y% f( V# Z
11. 6DMA2D->OPFCCR = pixelFormat;                // 设置输出颜色格式</font>

复制代码

tips0：有时我们会遇到一张带有透明通道的图片与背景叠加显示的情况，此时就不应该禁用颜色本身的alpha通道

) s1 W% [" U* m% ?) Q" O2 J
4 N% {3 D! b4 K. _+ j/ N! C0 O3 Mtips1：这个模式下，我们不仅可以进行颜色混合，还可以同时转换颜色格式，可以根据需要设置前景和背景以及输出的颜色格式
* z* Y- k' a+ g7 ~
4 x6 Z. U1 n' @5 S3 J% f
最后，启动传输即可：
5 f/ u- f  p5 W7 E

1. <font face="微软雅黑" size="3">1/* 启动传输 */
   
2. 2DMA2D->CR   |= DMA2D_CR_START;
   
3. 3
   ( z$ X1 P* ^& G! s
4. 4/* 等待DMA2D传输完成 */
   5 |" H% |# P0 i/ q" A. z
5. 5while (DMA2D->CR & DMA2D_CR_START) {}</font>

复制代码

完整代码如下：
! [; F$ D# w' R7 P! S2 v

1. <font face="微软雅黑" size="3">1void _DMA2D_MixColors(void* pFg, void* pBg, void* pDst,
   2 K& Z7 w8 W6 d" O- }7 k
2. 2        uint32_t offlineFg, uint32_t offlineBg, uint32_t offlineDist,
   * [3 u4 z0 u8 y4 i1 C6 B4 ~
3. 3        uint16_t xSize, uint16_t ySize,
   
4. 4        uint32_t pixelFormat, uint8_t opa) {
   ) D3 }7 C% z! N& X8 |2 k0 n
5. 5
   
6. 6    DMA2D->CR    = 0x00020000UL;                // 设置工作模式为存储器到存储器并带颜色混合
     f7 I/ ^, W6 U% E
7. 7
   % q/ g6 M% ?: b7 h" F2 q
8. 8    DMA2D->FGMAR = (uint32_t)pFg;               // 设置前景数据内存地址
   : P+ Z# y' S% c: x) X8 {  }6 a4 t! Q
9. 9    DMA2D->BGMAR = (uint32_t)pBg;               // 设置背景数据内存地址
   : j/ R, n& N9 K' \' I
10. 10    DMA2D->OMAR  = (uint32_t)pDst;              // 设置数据输出内存地址
    
11. 11
    
12. 12    DMA2D->FGOR  = offlineFg;                   // 设置前景数据传输偏移
    
13. 13    DMA2D->BGOR  = offlineBg;                   // 设置背景数据传输偏移
    5 u$ C7 {+ ?0 t. l6 [
14. 14    DMA2D->OOR   = offlineDist;                 // 设置数据输出传输偏移
    9 D& \' s+ j0 @5 D' h' S" [
15. 15
    % {1 |# z, t$ ^2 Y& G3 }
16. 16    DMA2D->NLR = (uint32_t)(xSize << 16) | (uint16_t)ySize; // 设置图像数据宽高（像素）
    & I7 h# ]1 v4 |0 L" k
17. 17
    6 |: \( E. s( I# z$ q6 h8 t
18. 18    DMA2D->FGPFCCR = pixelFormat                // 设置前景色颜色格式
    
19. 19            | (1UL << 16)                       // 忽略前景颜色数据中的Alpha通道
    
20. 20            | ((uint32_t)opa << 24);            // 设置前景色不透明度
    + E$ B, T8 _' P) P0 L* z4 t9 u
21. 21
    ; C; x. C2 }2 p
22. 22    DMA2D->BGPFCCR = pixelFormat;               // 设置背景颜色格式
    
23. 23    DMA2D->OPFCCR  = pixelFormat;                // 设置输出颜色格式
    0 w) z5 Z2 S# v& U. z. g# f
24. 24
    % r& x7 f! @2 x+ |2 C! |
25. 25    /* 启动传输 */
    
26. 26    DMA2D->CR   |= DMA2D_CR_START;
    , G# e. Y# T; P- Z9 ?
27. 27
    : |  u: ~! E* Z$ V+ T  u# K
28. 28    /* 等待DMA2D传输完成 */
    
29. 29    while (DMA2D->CR & DMA2D_CR_START) {}
    : ^5 o; N5 W  a
30. 30}</font>

复制代码

编写测试代码，这次不需要二次包装函数了：

1. <font face="微软雅黑" size="3">1void DMA2D_AlphaBlendDemo(){
   
2. 2
   4 ^; L1 ]: D+ |# P
3. 3    const uint16_t lcdXSize = 320, lcdYSize = 240;
   
4. 4    const uint8_t cnvFrames = 60; // 60帧完成切换
   2 c( R- u! V8 d# L/ m# r2 O0 ]
5. 5    const uint32_t interval = 33; // 每秒30帧
   
6. 6    uint32_t time = 0;
   
7. 7
   
8. 8    // 计算输出位置的内存地址
   
9. 9    uint16_t distX = (lcdXSize - DEMO_IMG_WIDTH) / 2;
   
10. 10    uint16_t distY = (lcdYSize - DEMO_IMG_HEIGHT) / 2;
    2 K8 W( j7 O: [/ U0 o, ^6 Z+ @
11. 11    uint16_t* pFb = (uint16_t*) framebuffer;
    
12. 12    uint16_t* pDist = pFb + distX + distY * lcdYSize;
    
13. 13    uint16_t offlineDist = lcdXSize - DEMO_IMG_WIDTH;
    
14. 14
    - d, m2 F; B2 {+ }# Q) T5 E
15. 15    uint8_t nextImg = 1;
    
16. 16    uint16_t opa = 0;
    
17. 17    void* pFg = 0;
    
18. 18    void* pBg = 0;
    
19. 19    while(1){
    
20. 20        // 切换前景/背景图片
    
21. 21        if(nextImg){
    8 D3 X- |3 k' z' `! m. Y
22. 22            pFg = (void*)img_cat;
    
23. 23            pBg = (void*)img_fox;
    % q1 L/ t* e$ y$ t* N: J
24. 24        }
    
25. 25        else{
    + Q- ^# x7 ~, g: ~0 [; F
26. 26            pFg = (void*)img_fox;
    8 m6 _# W/ d. b5 J5 Y  n
27. 27            pBg = (void*)img_cat;
    ' c) g+ j# |4 C/ T' ~- `! `
28. 28        }
    
29. 29
    
30. 30        // 完成切换
    ; L/ W" Z. J, ~. l. J1 y
31. 31        for(int i = 0; i < cnvFrames; i++){
    
32. 32            time = HAL_GetTick();
    
33. 33            opa = 255 * i / (cnvFrames-1);
    
34. 34            _DMA2D_MixColors(pFg, pBg, pDist,
    
35. 35                    0,0,offlineDist,
    
36. 36                    DEMO_IMG_WIDTH, DEMO_IMG_HEIGHT,
    
37. 37                    LTDC_PIXEL_FORMAT_RGB565, opa);
    
38. 38            time = HAL_GetTick() - time;
    % s( B1 c& }. M& U* f1 G
39. 39            if(time < interval){
    
40. 40                HAL_Delay(interval - time);
    
41. 41            }
    
42. 42        }
    
43. 43        nextImg = !nextImg;
      e9 H) m2 k2 l6 k6 S* S/ [3 p
44. 44        HAL_Delay(5000);
    
45. 45    }
    * ~& X3 P# [. \
46. 46}</font>

复制代码

最终效果：



7 x( C( T) F9 \0 D/ O; y) \% Z性能对比
前面介绍了三种嵌入式图形开发种的实例，并对分别介绍了通过传统和DMA2D实现的方法。这时候肯定有朋友会问，DMA2D实现，比起传统方法实现，到底能快多少呢？我们来实际测试一下。
  q5 [1 i. v5 w8 x0 {! ]: D2 I% y

6 m3 L/ Q6 y6 t. t. i共同的测试条件如下：
! t! N" }- S! c) A) I

5 p8 i/ X! v7 r+ \' y# r  kframebuffer放置在SDRAM中，320x240，RGB565


/ Y7 g& Y0 G) m& B' C% XSDRAM工作频率100MHz，CL2，16位带宽。

' @! s4 y! n( y
MCU为STM32H750XB，主频400MHz，开启I-Cache和D-Cache
3 U, I( l: k0 q9 R* S( H; P

代码和资源在内部Flash上，64位AXI总线，速度为200MHz。
% o9 {" C! J/ _
4 A* ]  |4 j+ E
GCC编译器（版本：arm-atollic-eabi-gcc-6.3.1）


6 \, V8 u3 }" w! z. P, k测试项目：矩形填充

4 h; U/ B0 Z0 O1 \( T, B1 m+ }
绘制上一章第1节中的图表，绘制10000次，统计结果


! i# x- ~4 |% |, z5 O) d* J测试结果：

测试项目：内存复制
绘制上一章第2节中的序列帧10000帧，统计结果


测试结果:


$ l  }) _4 U; A, t5 V8 l7 ^
- B  ~2 ~6 C" O- @: x* a( O6 ]) f
1 _; O- C& P8 y/ M9 B
. J0 q% \, d" a# T2 R9 x3 ^1 k测试项目：透明度混合
1 Q! c8 E/ i0 E5 }1 e! L4 [! R渐变切换上一章第3小节中的两张图片100次，每次30帧完成，共计3000帧


混合结果直接输出到framebuffer，不再通过缓冲区缓冲

) l- T! H3 N: [
9 c3 n3 l8 o$ \% L% M' J- ^4 m测试结果：
$ v' s* o! e' q( l- R0 ~6 Z" E
  m. E2 R' [: Q

7 r1 w/ I1 L0 {# a/ |: M) k9 |' q' A
- B7 v3 y/ \! f+ j  x; j
4 j+ @3 D; ~) b3 }$ Y" J
性能测试总结
1 J4 [" U: ]: o由上面的测试结果可以看出，DAM2D至少有2个优势：
0 e$ v" T% D) o# g1 N# y3 I

6 m9 q1 P, S* x* O- E. _, g一是速度更快：在部分项目中，DMA2D实现的速度相比纯软件实现最高可以达到30倍的差距！这还是在主频高达400MHz还带L1-Cache的STM32H750平台上测试的结果，如果是在无cache且主频较低的STM32F4平台上进行测试，差距会进一步拉大。
7 `3 v9 g1 m, y- j- N  U. {2 ^8 D
# [0 d( ], y6 N' C! X
$ V/ V6 m1 i2 P2 c- C二是性能更加稳定：由测试结果可以看出，DMA2D实现的方式受编译器优化等级的影响非常小，几乎可以忽略不计，这意味着，无论你使用IAR，GCC或是MDK，使用DMA2D都可以达到相同的性能表现。不会出现同一段代码移植后性能相差很大的情况。


: b) b# _' C( V0 X除这两个直观的结果外，其实还有第三点优势，那就是代码编写更加简单。DMA2D的寄存器不多，而且比较直观。在某些场合，使用起来要比软件实现方便的多。

1 \( m9 C2 r: c  i9 [+ U) Z6 {
结语
本文中的三个实例，都是我本人在嵌入式图形开发中经常遇到的情况。实际上，DMA2D的用法还有很多，有兴趣的话可以参考《STM32H743中文编程手册》中的相关内容，相信有了本文的基础，在阅读里面的内容时一定会事半功倍。

' ^7 a& o$ ]7 z; {% @  n
: d- t/ B4 F( x) V4 d4 l
, V/ T3 y# y1 Z3 u/ l1 a4 D受限于作者的技术，文章中的内容无法做到100%的正确，如果存在错误，请大家指出，谢谢。
5 g6 L5 c* J0 `
& j5 O) k& `; w& G5 A6 Z
/ ]  O7 o6 J0 B( U, A) b
, \5 ?1 W# p/ G2 y- j7 @
5 B, V8 R! ]( p1 I1 l' u3 Z" Y

很全面和详尽。直接就是学习教程啊。
, O  M5 Y* S5 y5 P; f3 p! d