61.1 初学者重要提示
  MDMA位于D1域，使用的64位的AXI总线，可以操作TCM空间（前面章节讲解的DMA2D，通用DMA和BDMA不支持操作TCM空间）。
  对于本章节，重点要了解MDMA的buffer缓冲传输，block块传输和list列表模式的区别，详情见本章2.2小节。
( _# @0 a8 Q- j# ^, s+ e61.2 MDMA基础知识
* H# B0 c5 i1 }4 O4 b) O( }) A对于STM32H7的MDMA了解到以下几点即可：
: U6 {2 t2 K" c- m3 B) n- b# Q( n3 I
- D3 O9 U9 r# f5 Y6 m; e  由于总线矩阵的存在，各个主控的道路四通八达，从而可以让DMA和CPU同时开工，但是注意一点，如果他们同时访问的同一个外设，会有一点性能影响的。
0 s4 _5 }) `' v4 k$ F2 |  MDMA有两个主控总线接口，一个是AXI/AHB总线接口，主要用存储器或者外设访问，另一个是AHBS总线接口，仅用于TCM空间访问。
  有个16个通道，32个硬件触发源。每个通道都可以选择1个触发源，当然，也可以通过软件触发。
2 r; y& _9 ?" R/ P  [8 j; \  16个通道的传输请求，既可以外设，也可以来自DMA1或DMA2
  MDMA具有一个256级的DMA空间，被分为两个128级空间使用。
" Q& Q$ i0 [+ Q. k  j0 C) Q  MDMA的优先级可通过软件配置，支持very high, high, medium, low四个等级，如果配置的优先级相同，则由channel的序号决定，channel0最高，channel15最低
1 Y6 j; q- X; i+ {/ ]7 V  数据宽度可以设置字节，半字，字和双字。源地址和目的地址的数据宽度可不同。
7 d+ w" N5 y# S1 G, n) s: M  源地址和目标地址的大小和地址增量可以独立选择。
  数据的打包和拆解是采用的小端格式。
  支持突发模式，最大可传输128字节。
: o3 L1 {" j! z' X* x3 W+ k  当源地址和目的地址的增量和数据大小相同，且位宽小于等于32bit时，才允许TCM使用突发模式。
61.2.1 MDMA硬件框图
7 _9 {. r/ h1 K+ n, L$ k. P1 B认识一个外设，最好的方式就是看它的框图，方便我们快速地了解MDMA的基本功能，然后再看手册了解细节。框图如下所示：

! g$ M9 _% }( Q

通过这个框图，我们可以得到如下信息：

  mdma_it
- I, Z/ g" P. c% M7 k7 C; _' c5 nmdma的中断触发信号。

. c: ]/ `* j2 o$ N% u4 U: e) w/ c  mdma_str0到mdma_str31触发源
" C1 w, Y0 E7 v# r" Omdma的输入请求。

$ g7 R9 i0 V) ?& N4 A  mdma_hclk
MDMA的HCLK时钟。

61.2.2 MDMA块传输，缓冲传输和列表传输区别
初学MDMA，要搞清除MDMA支持的块传输，缓冲传输和列表传输的区别。
* r7 {( C% H' U% K# q
  缓冲传输（MDMA_BUFFER_TRANSFER）
这个模式主要用于QSPI，DCMI，硬件JPEG等外设上。每个请求都会触发BufferTransferLength（最大128字节）大小的数据传输，此大小由HAL_MDMA_Init调用的参数配置。

, Q0 V$ l0 R! X% |
  块传输（MDMA_BLOCK_TRANSFER）
此方式与DMA1和DMA2的数据传输相似，每次请求，触发一次块传输，块大小由 HAL_MDMA_Start/HAL_MDMA_Start_IT定义，或者列表模式里面的参数。

' X4 m# w1 G4 |# I
  多块传输（MDMA_REPEAT_BLOCK_TRANSFER）
顾名思义，多块传输就是执行多次块传输，每次请求，触发多次的块传输，块大小和块数由 HAL_MDMA_Start/HAL_MDMA_Start_IT定义，或者列表模式里面的参数。


  列表传输（MDMA_FULL_TRANSFER）
' N4 g5 K2 _) x这种模式可以方便的实现多种MDMA配置进行切换，轮番实现，而且可以实现列表的循环方式。每次请求，将触发所有块和节点的传输（如果用户调用了函数HAL_MDMA_LinkedList_CreateNode \ HAL_MDMA_LinkedList_AddNode），
' S% b4 ~  i) e% z- [# b
5 x' y  h$ Y7 u+ R61.2.3 MDMA列表模式及其循环方式
3 H3 E& |* \8 x+ t4 c* ]4 C( F6 F列表模式包含多种MDMA的配置表，每个表包含一组完整MDMA配置。用户可以使用函数HAL_MDMA_LinkedList_CreateNode创建节点，再通过函数HAL_MDMA_LinkedList_AddNode将节点添加到列表里面。
: o4 |- x: g% P- B
! R3 N' s4 y0 L( p  使用列表模式的话，函数HAL_MDMA_Init创建的是节点0。
  Q2 J1 S. Q# ]4 e9 `- p6 ]  使用函数HAL_MDMA_LinkedList_EnableCircularMode使能循环模式，注意是从节点1开始循环的，将节点1和末尾的节点相连，不包含HAL_MDMA_Init创建的节点0。
  节点0是初始配置，仅在初始化MDMA传输时使用一次，比如调用函数HAL_MDMA_Start_IT。
  如果要禁止循环模式，可以调用函数HAL_MDMA_LinkedList_DisableCircularMode。
  通过函数HAL_MDMA_LinkedList_RemoveNode还可以删除指定节点。
5 t  M5 Z8 [# t7 q" @/ @61.2.4 MDMA的触发源
MDMA支持的触发源如下，主要包含DMA1，DMA2，DMA2D，LTDC，JPEG，QSPI，DSI，SDMMC和软件触发：

1. #define MDMA_REQUEST_DMA1_Stream0_TC      ((uint32_t)0x00000000U)
   ! w% }- g! ]* D8 }; I8 D
2. #define MDMA_REQUEST_DMA1_Stream1_TC      ((uint32_t)0x00000001U)  
   ; B" e: j0 {3 l; J: r
3. #define MDMA_REQUEST_DMA1_Stream2_TC      ((uint32_t)0x00000002U)
   * N; v& I; _' W  U. V
4. #define MDMA_REQUEST_DMA1_Stream3_TC      ((uint32_t)0x00000003U)
   
5. #define MDMA_REQUEST_DMA1_Stream4_TC      ((uint32_t)0x00000004U)
   
6. #define MDMA_REQUEST_DMA1_Stream5_TC      ((uint32_t)0x00000005U)
   
7. #define MDMA_REQUEST_DMA1_Stream6_TC      ((uint32_t)0x00000006U)
   6 K+ e+ {4 c0 r
8. #define MDMA_REQUEST_DMA1_Stream7_TC      ((uint32_t)0x00000007U)
   . a2 ]# h( b8 F  ]+ t  ^; f
9. #define MDMA_REQUEST_DMA2_Stream0_TC      ((uint32_t)0x00000008U)  
   
10. #define MDMA_REQUEST_DMA2_Stream1_TC      ((uint32_t)0x00000009U)
    1 W/ n2 X  L8 M
11. #define MDMA_REQUEST_DMA2_Stream2_TC      ((uint32_t)0x0000000AU)  
    
12. #define MDMA_REQUEST_DMA2_Stream3_TC      ((uint32_t)0x0000000BU)
    
13. #define MDMA_REQUEST_DMA2_Stream4_TC      ((uint32_t)0x0000000CU)
    / M9 g: I9 ?. A' k
14. #define MDMA_REQUEST_DMA2_Stream5_TC      ((uint32_t)0x0000000DU)
    4 A2 r, i/ Y2 x: r# \; C" l! T/ @. c* u
15. #define MDMA_REQUEST_DMA2_Stream6_TC      ((uint32_t)0x0000000EU)  
    - Q( G# v) ^: }( t; @) q
16. #define MDMA_REQUEST_DMA2_Stream7_TC      ((uint32_t)0x0000000FU)
    3 q6 b+ @- m" T( g& c( _- ?
17. #define MDMA_REQUEST_LTDC_LINE_IT         ((uint32_t)0x00000010U)  
    
18. #define MDMA_REQUEST_JPEG_INFIFO_TH       ((uint32_t)0x00000011U)
    
19. #define MDMA_REQUEST_JPEG_INFIFO_NF       ((uint32_t)0x00000012U)
    2 R# M& Z) V) _
20. #define MDMA_REQUEST_JPEG_OUTFIFO_TH      ((uint32_t)0x00000013U)
    ' g4 I! M" k$ Q( G: w9 W+ K
21. #define MDMA_REQUEST_JPEG_OUTFIFO_NE      ((uint32_t)0x00000014U)  
    
22. #define MDMA_REQUEST_JPEG_END_CONVERSION  ((uint32_t)0x00000015U)  
    8 a  i4 C- x2 H/ W0 u' v
23. #define MDMA_REQUEST_QUADSPI_FIFO_TH      ((uint32_t)0x00000016U)  
    
24. #define MDMA_REQUEST_QUADSPI_TC           ((uint32_t)0x00000017U)
    , t) Z1 @, \1 H* C
25. #define MDMA_REQUEST_DMA2D_CLUT_TC        ((uint32_t)0x00000018U)
    ; Z- K4 `0 {2 p* g
26. #define MDMA_REQUEST_DMA2D_TC             ((uint32_t)0x00000019U)
    
27. #define MDMA_REQUEST_DMA2D_TW             ((uint32_t)0x0000001AU)
    & ~! Q9 K" f- e( H: A
28. 
    & x4 ^9 N0 v% I+ c1 [( ^% k
29. #if defined(DSI)
    - p- |; r$ f/ f/ x% \' [
30. #define MDMA_REQUEST_DSI_TEARINGE_FFECT   ((uint32_t)0x0000001BU)
    5 v7 n/ o$ M' u& D
31. #define MDMA_REQUEST_DSI_END_REFRESH      ((uint32_t)0x0000001CU)
    
32. #endif /* DSI */
    
33. 
    
34. #define MDMA_REQUEST_SDMMC1_ED_DATA      ((uint32_t)0x0000001DU)
    
35. 
    / [; Q7 M; n. m1 u
36. #define MDMA_REQUEST_SW                   ((uint32_t)0x40000000U)

复制代码

1 @0 i6 u. ~" W
1 L8 N3 p& R! B* |
! N; i7 U9 c6 q) K5 i0 h6 F% C4 @6 X61.2.5 MDMA的软件触发方式
. [* J+ w! }( _  Q: `2 Q2 nMDMA配置为MDMA_REQUEST_SW软件触发时，可以通过函数HAL_MDMA_GenerateSWRequest产生触发请求，使用此函数要注意以下两个问题：
* O- \$ K% Q4 t) K3 w0 Q
7 N8 r% _4 H1 k  如果传输结束或者传输还没有启动，调用此函数会返回error。
  Q1 s, O, c5 G  如果传输还在进行中断，调用此函数会返回error，这次请求会被忽略。

9 A  A8 ^5 M; t. Y) Q/ k, e
应用示例1：

1 R5 x" q2 j7 S5 p: `  MDMA配置为MDMA_BUFFER_TRANSFER模式，软件触发。
/ n! K& y# ^3 _: u+ |0 Q/ }  注册回调函数HAL_MDMA_XFER_BUFFERCPLT_CB_ID。
  调用函数HAL_MDMA_Start_IT会触发一次BufferTransferLength长度的数据传输。
  传输结束会进入回调函数，用户可以在回调函数里面再次调用HAL_MDMA_GenerateSWRequest启动传输。

! t  s  p$ O% m0 \7 d; l9 }
; c, C1 Q" W& f! g: L2 ?  ?( V应用示例2：

4 h! ^8 Q5 E4 l$ l$ E  MDMA配置为MDMA_BLOCK_TRANSFER模式，软件触发。
  注册回调函数HAL_MDMA_XFER_BLOCKCPLT_CB_ID。
/ T, [' n* ^& U  调用函数HAL_MDMA_Start_IT会触发一次块传输。
; F' y7 I# F! }3 y/ o' _  传输结束会进入回调函数，用户可以再回调函数里面再次调用HAL_MDMA_GenerateSWRequest再次启动传输。
61.3 MDMA的HAL库用法
MDMA的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置时钟，并根据需要配置NVIC、中断。下面我们逐一展开为大家做个说明。

1 f% b7 q; V, p7 N! i' x3 p9 m% O3 ^( }61.3.1 MDMA寄存器结构体MDMA_Channel_TypeDef和MDMA_TypeDef
1 k: m: q( n) F$ M; W$ m  i) s% Q5 SMDMA相关的寄存器是通过HAL库中的结构体MDMA_Channel_TypeDef和MDMA_TypeDef定义的，在stm32h743xx.h中可以找到它们的具体定义：
  A7 G+ C3 m3 T7 U  y0 h
8 [# q) R: p9 U, o

1. typedef struct
   
2. {
   
3.   __IO uint32_t  CISR;      /*!< MDMA channel x interrupt/status register,             Address offset: 0x40 */
   . Y$ W) A9 w' \/ d
4.   __IO uint32_t  CIFCR;     /*!< MDMA channel x interrupt flag clear register,         Address offset: 0x44 */
   
5.   __IO uint32_t  CESR;      /*!< MDMA Channel x error status register,                 Address offset: 0x48 */
   
6.   __IO uint32_t  CCR;       /*!< MDMA channel x control register,                      Address offset: 0x4C */
   
7.   __IO uint32_t  CTCR;      /*!< MDMA channel x Transfer Configuration register,       Address offset: 0x50 */
   0 h7 {  g8 O. M: Z: x8 F
8.   __IO uint32_t  CBNDTR;    /*!< MDMA Channel x block number of data register,         Address offset: 0x54 */
   
9.   __IO uint32_t  CSAR;      /*!< MDMA channel x source address register,               Address offset: 0x58 */
   + P& \7 D$ [" M
10.   __IO uint32_t  CDAR;      /*!< MDMA channel x destination address register,          Address offset: 0x5C */
    
11.   __IO uint32_t  CBRUR;     /*!< MDMA channel x Block Repeat address Update register,  Address offset: 0x60 */
    $ g$ m6 J7 z" `
12.   __IO uint32_t  CLAR;      /*!< MDMA channel x Link Address register,                 Address offset: 0x64 */
    
13.   __IO uint32_t  CTBR;      /*!< MDMA channel x Trigger and Bus selection Register,    Address offset: 0x68 */
    / f1 o7 ^/ N( G* I+ {* i/ V
14.   uint32_t     RESERVED0;   /*!< Reserved, 0x68                                                           */  
    
15. __IO uint32_t    CMAR;     /*!< MDMA channel x Mask address register,                Address offset: 0x70 */
    ( z3 Z* ~4 p2 \+ E( w! R
16. __IO uint32_t   CMDR;      /*!< MDMA channel x Mask Data register,                   Address offset: 0x74 */
    . n7 Q1 L8 K4 _% \& {
17. }MDMA_Channel_TypeDef;
    6 k7 S5 P" _3 h) j' H0 j
18. 
    
19. typedef struct
    , Z% E; ]( a* u' k) R" |7 D5 M
20. {
    
21.   __IO uint32_t  GISR0;   /*!< MDMA Global Interrupt/Status Register 0,          Address offset: 0x00 */
    
22. }MDMA_TypeDef;
    

复制代码

8 k' m. T; B' @/ |9 u2 L__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
$ R* W* v' ^, o6 y8 c

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   + q: N: i/ p1 m& q8 g  [
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

" w+ V& j& Y3 s. d* m4 ]2 L下面我们再看MDMA的定义，在stm32h743xx.h文件。
2 l* _( l/ |' d. V

1. #define PERIPH_BASE           ((uint32_t)0x40000000)
   9 }! k6 M- D7 P" s* N2 \9 \# T$ F
2. #define D1_AHB1PERIPH_BASE    (PERIPH_BASE + 0x12000000)
   - `5 O: N% M) H* w
3. #define MDMA_BASE             (D1_AHB1PERIPH_BASE + 0x0000)
   
4. 
   
5. #define MDMA_Channel0_BASE    (MDMA_BASE + 0x00000040)
   
6. #define MDMA_Channel1_BASE    (MDMA_BASE + 0x00000080)
   ) S0 c5 `6 U% f) v$ F
7. #define MDMA_Channel2_BASE    (MDMA_BASE + 0x000000C0)
   
8. #define MDMA_Channel3_BASE    (MDMA_BASE + 0x00000100)
   
9. #define MDMA_Channel4_BASE    (MDMA_BASE + 0x00000140)
   
10. #define MDMA_Channel5_BASE    (MDMA_BASE + 0x00000180)
    . W5 n: k/ F: [* h0 G2 E3 C0 s  D$ e
11. #define MDMA_Channel6_BASE    (MDMA_BASE + 0x000001C0)
    
12. #define MDMA_Channel7_BASE    (MDMA_BASE + 0x00000200)
    2 s8 Y9 W) X3 W
13. #define MDMA_Channel8_BASE    (MDMA_BASE + 0x00000240)
    * D, n; s2 z! `; L6 A% ~/ z
14. #define MDMA_Channel9_BASE    (MDMA_BASE + 0x00000280)
    
15. #define MDMA_Channel10_BASE   (MDMA_BASE + 0x000002C0)
    / s6 O9 O1 @, L! O' v9 y9 D
16. #define MDMA_Channel11_BASE   (MDMA_BASE + 0x00000300)
    
17. #define MDMA_Channel12_BASE   (MDMA_BASE + 0x00000340)
    
18. #define MDMA_Channel13_BASE   (MDMA_BASE + 0x00000380)
    
19. #define MDMA_Channel14_BASE   (MDMA_BASE + 0x000003C0)
    . H( a) [7 z  D0 M% ]& R
20. #define MDMA_Channel15_BASE   (MDMA_BASE + 0x00000400)
    $ S6 j$ b! o& S
21. 
    
22. #define MDMA                ((MDMA_TypeDef *)MDMA_BASE) <----- 展开这个宏，(MDMA_TypeDef *) 0x52000000
    . F* D! A4 N) W8 U
23. #define MDMA_Channel0       ((MDMA_Channel_TypeDef *)MDMA_Channel0_BASE)
    / C- d; K! U) |4 Z5 \& Y, q
24. #define MDMA_Channel1       ((MDMA_Channel_TypeDef *)MDMA_Channel1_BASE)
    
25. #define MDMA_Channel2       ((MDMA_Channel_TypeDef *)MDMA_Channel2_BASE)
    ; F: `% {! _: S! C4 j/ M
26. #define MDMA_Channel3       ((MDMA_Channel_TypeDef *)MDMA_Channel3_BASE)
    + p- ]) O7 e, Z7 H9 U
27. #define MDMA_Channel4       ((MDMA_Channel_TypeDef *)MDMA_Channel4_BASE)
    
28. #define MDMA_Channel5       ((MDMA_Channel_TypeDef *)MDMA_Channel5_BASE)
    
29. #define MDMA_Channel6       ((MDMA_Channel_TypeDef *)MDMA_Channel6_BASE)
    3 u2 V0 \, n' s  T) ^+ f, H
30. #define MDMA_Channel7       ((MDMA_Channel_TypeDef *)MDMA_Channel7_BASE)
    , b0 B) y& D2 T7 k* t: W
31. #define MDMA_Channel8       ((MDMA_Channel_TypeDef *)MDMA_Channel8_BASE)
    
32. #define MDMA_Channel9       ((MDMA_Channel_TypeDef *)MDMA_Channel9_BASE)
    
33. #define MDMA_Channel10      ((MDMA_Channel_TypeDef *)MDMA_Channel10_BASE)
    + B9 l" b" T* N: {
34. #define MDMA_Channel11      ((MDMA_Channel_TypeDef *)MDMA_Channel11_BASE)
    1 _+ ^: E& `& s/ R) {7 Z2 I
35. #define MDMA_Channel12      ((MDMA_Channel_TypeDef *)MDMA_Channel12_BASE)
    : g5 a$ \0 D& }& E$ I8 P2 Q8 r6 r
36. #define MDMA_Channel13      ((MDMA_Channel_TypeDef *)MDMA_Channel13_BASE)
    " t6 Q: M* ~! R  ^9 R" q/ R
37. #define MDMA_Channel14      ((MDMA_Channel_TypeDef *)MDMA_Channel14_BASE)
    % ]+ w) _- w9 T& t/ H
38. #define MDMA_Channel15      ((MDMA_Channel_TypeDef *)MDMA_Channel15_BASE)

复制代码

2 p9 @/ {, {& M+ s) ^* c6 F我们访问MDMA的GISR0寄存器可以采用这种形式：MDMA->GISR0 = 0。
; F7 a% x1 H6 ]& N% [+ m7 S7 x
* _. j7 p: J1 ^61.3.2 MDMA的参数结构体MDMA_InitTypeDef
6 x7 g% ~6 I& F: a此结构体用于MDMA的参数配置，具体定义如下：
* A5 h8 j9 ~7 T; ]

1. typedef struct
   
2. {
   
3.   uint32_t Request;                                                
   ' h& Y- r# T) a& ], ~
4.   uint32_t TransferTriggerMode;                                    
   
5.   uint32_t Priority;                                                     
   - C) _: Y' G: _$ B2 \5 n
6.   uint32_t Endianness;                                                
   4 x* e( K. z8 t! Q, Z2 c) z
7.   uint32_t SourceInc;                                             
   / X+ x. L6 I5 x
8.   uint32_t DestinationInc;                                       
   
9.   uint32_t SourceDataSize;                                         
   
10.   uint32_t DestDataSize;            
    # c$ w2 |; x; m8 s5 D- l( H
11.   uint32_t DataAlignment;         
    : ^; k3 ~% K6 l7 ~" e' K) f6 y
12.   uint32_t BufferTransferLength;   
    + E# i' w' K& |) f$ U5 Y
13.   uint32_t SourceBurst;                                            
    # W2 p1 B9 R3 [- S! G
14.   uint32_t DestBurst;               
    % t: [1 r& Y9 c  y& ~* L6 B  V
15.   int32_t SourceBlockAddressOffset;                                                                           
    
16.   int32_t DestBlockAddressOffset;      
    % W3 L) _# t* [  i: u$ {0 j* D
17. }MDMA_InitTypeDef;

复制代码

( K& {! {- _2 J1 j* ^- l" }
8 a$ w4 X. X4 O, L, q
9 n9 _! I5 x  Z! ]下面将这几个参数逐一为大家做个说明：

; m" W& f  P7 Y  h  uint32_t Request
触发MDMA的请求源，支持请求源如下：
4 V( D& ^! K1 x/ T/ Y/ z
1 [( t+ ^6 I- e/ p. w( x

1. #define MDMA_REQUEST_DMA1_Stream0_TC      ((uint32_t)0x00000000U)  
   & ~' l5 \6 h, Z! M$ P+ h) G
2. #define MDMA_REQUEST_DMA1_Stream1_TC      ((uint32_t)0x00000001U)  
   
3. #define MDMA_REQUEST_DMA1_Stream2_TC      ((uint32_t)0x00000002U)
   
4. #define MDMA_REQUEST_DMA1_Stream3_TC      ((uint32_t)0x00000003U)  
     t- f# u+ |. w
5. #define MDMA_REQUEST_DMA1_Stream4_TC      ((uint32_t)0x00000004U)  
   $ z$ S. W8 u+ }6 l
6. #define MDMA_REQUEST_DMA1_Stream5_TC      ((uint32_t)0x00000005U)
   ' B5 k; r- I$ a" u% z7 x9 K6 e
7. #define MDMA_REQUEST_DMA1_Stream6_TC      ((uint32_t)0x00000006U)  
   - u% Q2 S' a$ e  k9 j5 i* q9 m4 X
8. #define MDMA_REQUEST_DMA1_Stream7_TC      ((uint32_t)0x00000007U)  
   8 o; m) b7 |% S; S& ^
9. #define MDMA_REQUEST_DMA2_Stream0_TC      ((uint32_t)0x00000008U)  
   : D1 ]7 c6 V" ?) j- \7 q$ b5 c: e/ R
10. #define MDMA_REQUEST_DMA2_Stream1_TC      ((uint32_t)0x00000009U)  
    ; F2 O- o0 E& O" x# ~' m3 V
11. #define MDMA_REQUEST_DMA2_Stream2_TC      ((uint32_t)0x0000000AU)  
    - c7 ?* d' Q' v5 x) F
12. #define MDMA_REQUEST_DMA2_Stream3_TC      ((uint32_t)0x0000000BU)
    ' x+ F" r3 Q1 e- q
13. #define MDMA_REQUEST_DMA2_Stream4_TC      ((uint32_t)0x0000000CU)
    & Q% n  F1 a6 v5 n7 m
14. #define MDMA_REQUEST_DMA2_Stream5_TC      ((uint32_t)0x0000000DU)
    
15. #define MDMA_REQUEST_DMA2_Stream6_TC      ((uint32_t)0x0000000EU)  
    1 K4 Y5 u4 t7 |3 Y) F
16. #define MDMA_REQUEST_DMA2_Stream7_TC      ((uint32_t)0x0000000FU)  
    ) s: |4 k  h) u' K2 n
17. #define MDMA_REQUEST_LTDC_LINE_IT         ((uint32_t)0x00000010U)  
    4 V% X' Y" s  U: o
18. #define MDMA_REQUEST_JPEG_INFIFO_TH       ((uint32_t)0x00000011U)
    4 x% J2 _+ b, o# A; `! i6 X, g7 o
19. #define MDMA_REQUEST_JPEG_INFIFO_NF       ((uint32_t)0x00000012U)  
    
20. #define MDMA_REQUEST_JPEG_OUTFIFO_TH      ((uint32_t)0x00000013U)  
    ( i$ n. X( h7 _
21. #define MDMA_REQUEST_JPEG_OUTFIFO_NE      ((uint32_t)0x00000014U)  
    
22. #define MDMA_REQUEST_JPEG_END_CONVERSION  ((uint32_t)0x00000015U)  
    ; u- @- W4 S0 i, ?9 D
23. #define MDMA_REQUEST_QUADSPI_FIFO_TH      ((uint32_t)0x00000016U)  
    
24. #define MDMA_REQUEST_QUADSPI_TC           ((uint32_t)0x00000017U)  
    
25. #define MDMA_REQUEST_DMA2D_CLUT_TC        ((uint32_t)0x00000018U)  
    
26. #define MDMA_REQUEST_DMA2D_TC             ((uint32_t)0x00000019U)  
    , \2 G& }7 I* L" [1 U: w
27. #define MDMA_REQUEST_DMA2D_TW             ((uint32_t)0x0000001AU)  
    , [0 B! |. g& n/ `  N. l) c
28. 
    
29. #if defined(DSI)
    ' c. @- l9 }/ `! l. e1 a' k
30. #define MDMA_REQUEST_DSI_TEARINGE_FFECT   ((uint32_t)0x0000001BU)  
    : G5 @. n1 F4 U9 Q3 r) ^7 A2 N$ a
31. #define MDMA_REQUEST_DSI_END_REFRESH      ((uint32_t)0x0000001CU)  
    
32. #endif /* DSI */
    ( D1 @* t' p/ e/ h0 t5 v" |
33. 
    3 H/ D+ }6 p& B
34. #define MDMA_REQUEST_SDMMC1_END_DATA      ((uint32_t)0x0000001DU)
    
35. #define MDMA_REQUEST_SW                   ((uint32_t)0x40000000U)
    

复制代码

& z: A% \- B( Y- R7 |/ [* W
( D: G9 g; [9 {6 G; ?  uint32_t TransferTriggerMode
MDMA的传输模式，具体支持的参数如下：

' |2 m% L: H7 D" o$ }, \

1. #define MDMA_BUFFER_TRANSFER          ((uint32_t)0x00000000U)      /* 缓冲传输 */
   
2. #define MDMA_BLOCK_TRANSFER           ((uint32_t)MDMA_CTCR_TRGM_0) /* 块传输 */
   % ]  B# f0 ?' \0 D% h9 M% O8 O" v) j% L
3. #define MDMA_REPEAT_BLOCK_TRANSFER    ((uint32_t)MDMA_CTCR_TRGM_1) /* 多块传输 */
   $ \; S4 G# p5 R* p9 h
4. #define MDMA_FULL_TRANSFER            ((uint32_t)MDMA_CTCR_TRGM)   /* 链表传输 */

复制代码

; ~: |7 c+ u8 n* ~8 h6 Q+ N: j
* H! C! H4 U7 R# E  uint32_t Priority
5 q, Z; Y5 z& u% e# MMDMA通道的优先级设置，具体支持的参数如下：

1. #define MDMA_PRIORITY_LOW             ((uint32_t)0x00000000U)     
   
2. #define MDMA_PRIORITY_MEDIUM          ((uint32_t)MDMA_CCR_PL_0)  
   
3. #define MDMA_PRIORITY_HIGH            ((uint32_t)MDMA_CCR_PL_1)  
   2 @8 a* J+ L' G
4. #define MDMA_PRIORITY_VERY_HIGH       ((uint32_t)MDMA_CCR_PL)   

复制代码

6 K6 S: @: P: z  V

  uint32_t Endianness
6 i" A+ n0 Y7 x8 RMDMA数据传输格式，具体支持的参数如下：
' c3 b2 h4 l6 Y- P( p6 e7 {; v
2 r3 S, z$ S4 Z; l7 |  x

1. #define MDMA_LITTLE_ENDIANNESS_PRESERVE          ((uint32_t)0x00000000U)  
   / c4 \0 ?1 U% P. T8 a( V" t# y
2. #define MDMA_LITTLE_BYTE_ENDIANNESS_EXCHANGE     ((uint32_t)MDMA_CCR_BEX)  
   
3. #define MDMA_LITTLE_HALFWORD_ENDIANNESS_EXCHANGE ((uint32_t)MDMA_CCR_HEX)
   6 I3 v: y7 l" q6 K& _# e
4. #define MDMA_LITTLE_WORD_ENDIANNESS_EXCHANGE     ((uint32_t)MDMA_CCR_WEX)  

复制代码

MDMA_LITTLE_ENDIANNESS_PRESERVE：正常的小端格式。

7 @) C" N5 F: ~& c/ oMDMA_LITTLE_BYTE_ENDIANNESS_EXCHANGE：以半字为单位，交互高低字节。

" E$ F8 |; O" ?7 C( ~' eMDMA_LITTLE_HALFWORD_ENDIANNESS_EXCHANGE：以字为单位，交互半字。

MDMA_LITTLE_WORD_ENDIANNESS_EXCHANGE：以双字为单位，交换字。

9 q7 ?. v' }% G( }  ^4 o  uint32_t SourceInc
MDMA源数据自增或者自减模式，具体支持的参数如下：
9 D; G, D- S+ U/ `/ Z5 h* G

1. 
   2 A  P% C6 A6 Y7 w( F" O
2. #define MDMA_SRC_INC_DISABLE      ((uint32_t)0x00000000U)                                    
   8 @5 i" w/ Y$ U  i. F- {  p
3. #define MDMA_SRC_INC_BYTE         ((uint32_t)MDMA_CTCR_SINC_1)                                
   8 Y! `0 w: P* I, b6 ]! u
4. #define MDMA_SRC_INC_HALFWORD     ((uint32_t)MDMA_CTCR_SINC_1 | (uint32_t)MDMA_CTCR_SINCOS_0)
   / u' n, g+ h1 |& Z; C( B/ G6 `
5. #define MDMA_SRC_INC_WORD         ((uint32_t)MDMA_CTCR_SINC_1 | (uint32_t)MDMA_CTCR_SINCOS_1)
   
6. #define MDMA_SRC_INC_DOUBLEWORD   ((uint32_t)MDMA_CTCR_SINC_1 | (uint32_t)MDMA_CTCR_SINCOS)  
   / Q% y+ v: }) W, r9 L8 P7 x% x( }
7. #define MDMA_SRC_DEC_BYTE         ((uint32_t)MDMA_CTCR_SINC)                                 
   
8. #define MDMA_SRC_DEC_HALFWORD     ((uint32_t)MDMA_CTCR_SINC | (uint32_t)MDMA_CTCR_SINCOS_0)   
   
9. #define MDMA_SRC_DEC_WORD         ((uint32_t)MDMA_CTCR_SINC | (uint32_t)MDMA_CTCR_SINCOS_1)   
   
10. #define MDMA_SRC_DEC_DOUBLEWORD   ((uint32_t)MDMA_CTCR_SINC | (uint32_t)MDMA_CTCR_SINCOS)   

复制代码

) {% A& s7 B+ J+ X( V5 ]

, e9 i( X3 o/ C- y  DestinationInc
MDMA目的数据自增或者自减模式，具体支持的参数如下：
' Q" L1 F) R+ y5 w$ U9 o" B. {6 C- ~
7 K- B  S4 t- c6 _9 _& Y% p

1. #define MDMA_DEST_INC_DISABLE      ((uint32_t)0x00000000U)                                    
   
2. #define MDMA_DEST_INC_BYTE         ((uint32_t)MDMA_CTCR_DINC_1)                              
   
3. #define MDMA_DEST_INC_HALFWORD     ((uint32_t)MDMA_CTCR_DINC_1 | (uint32_t)MDMA_CTCR_DINCOS_0)
   ' z6 L1 a5 ~% F& I* V
4. #define MDMA_DEST_INC_WORD         ((uint32_t)MDMA_CTCR_DINC_1 | (uint32_t)MDMA_CTCR_DINCOS_1)
   
5. #define MDMA_DEST_INC_DOUBLEWORD   ((uint32_t)MDMA_CTCR_DINC_1 | (uint32_t)MDMA_CTCR_DINCOS)   
   
6. #define MDMA_DEST_DEC_BYTE         ((uint32_t)MDMA_CTCR_DINC)                                
   
7. #define MDMA_DEST_DEC_HALFWORD     ((uint32_t)MDMA_CTCR_DINC | (uint32_t)MDMA_CTCR_DINCOS_0)   
   : Y6 F0 W: n9 s5 w' T
8. #define MDMA_DEST_DEC_WORD         ((uint32_t)MDMA_CTCR_DINC | (uint32_t)MDMA_CTCR_DINCOS_1)   
   & `; W% @2 L2 u
9. #define MDMA_DEST_DEC_DOUBLEWORD   ((uint32_t)MDMA_CTCR_DINC | (uint32_t)MDMA_CTCR_DINCOS)  

复制代码

3 {( e$ }3 [0 }; o# l
/ K& p. T/ E7 Z* Y, q9 S: X2 X0 D
  SourceDataSize
3 K7 X1 t/ n) v& D) D; [7 R3 Z; jMDMA源数据带宽，具体支持的参数如下：
3 Z" x) h# F  N% k

1. #define MDMA_SRC_DATASIZE_BYTE        ((uint32_t)0x00000000U)        
   
2. #define MDMA_SRC_DATASIZE_HALFWORD    ((uint32_t)MDMA_CTCR_SSIZE_0)     
     P6 A* ?5 b2 R
3. #define MDMA_SRC_DATASIZE_WORD        ((uint32_t)MDMA_CTCR_SSIZE_1)  
   
4. #define MDMA_SRC_DATASIZE_DOUBLEWORD  ((uint32_t)MDMA_CTCR_SSIZE)   
   4 `9 w5 i4 E3 p; V

复制代码

1 W' S0 z; U( C! G  DestDataSize
MDMA目的数据带宽，具体支持的参数如下：

& q, p4 z  R. _8 z

1. #define MDMA_DEST_DATASIZE_BYTE        ((uint32_t)0x00000000U)        
   7 Z- {% ]! ]0 E
2. #define MDMA_DEST_DATASIZE_HALFWORD    ((uint32_t)MDMA_CTCR_DSIZE_0)   
   
3. #define MDMA_DEST_DATASIZE_WORD        ((uint32_t)MDMA_CTCR_DSIZE_1)  
   
4. #define MDMA_DEST_DATASIZE_DOUBLEWORD  ((uint32_t)MDMA_CTCR_DSIZE)     

复制代码

" _  j, `& y7 L# m4 |4 W
: e3 m: X3 c9 I2 H1 u  x  DataAlignment
4 }  o2 j# R# d0 H, W# V6 xMDMA的填充/对齐设置，具体支持的参数如下：

1. #define MDMA_DATAALIGN_PACKENABLE        (uint32_t)MDMA_CTCR_PKE)     
   ' }( w& ?; {2 T- }% i
2. #define MDMA_DATAALIGN_RIGHT            ((uint32_t)0x00000000U)     
   
3. #define MDMA_DATAALIGN_RIGHT_SIGNED     ((uint32_t)MDMA_CTCR_PAM_0)  
   0 `, v9 V$ j2 O; Y$ b2 f
4. #define MDMA_DATAALIGN_LEFT             ((uint32_t)MDMA_CTCR_PAM_1)  

复制代码

2 R; K" \0 a, `8 b' h
MDMA_DATAALIGN_PACKENABLE：

. H# e5 {- a* b6 n4 |% f将源数据封装/解封为目标数据大小。所有数据均右对齐（采用小端模式）。

MDMA_DATAALIGN_RIGHT
4 ]7 ?- T/ W: V$ b
右对齐，用 0 进行填充（默认值）

MDMA_DATAALIGN_RIGHT_SIGNED

9 r5 |: w( i5 r0 C1 c/ m右对齐，符号扩展

MDMA_DATAALIGN_LEFT
. ~1 u; u6 h% S9 Y, L# R4 Q/ b
- S7 A/ r  G* g' N$ X左对齐（用 0 进行填充）

# \* H, ]) m# s/ L" n8 x- B  BufferTransferLength
& \  A8 x. L8 U5 m8 k7 I6 f' Q+ ^- j单次传输长度设置，范围1-128，单位字节。

  SourceBurst
源数据端突发设置，特别注意突发传输的数量不能超过BufferTransferLength参数设置的大小，具体支持的参数如下：

. Z0 }- x9 N6 g( A( @

1. #define MDMA_SOURCE_BURST_SINGLE        ((uint32_t)0x00000000U)                                      
   1 \6 `/ t. J8 A7 x) h( A
2. #define MDMA_SOURCE_BURST_2BEATS        ((uint32_t)MDMA_CTCR_SBURST_0)                               #define MDMA_SOURCE_BURST_4BEATS        ((uint32_t)MDMA_CTCR_SBURST_1)                               #define MDMA_SOURCE_BURST_8BEATS        ((uint32_t)MDMA_CTCR_SBURST_0 | (uint32_t)MDMA_CTCR_SBURST_1)
   
3. #define MDMA_SOURCE_BURST_16BEATS       ((uint32_t)MDMA_CTCR_SBURST_2)                              
   
4. #define MDMA_SOURCE_BURST_32BEATS       ((uint32_t)MDMA_CTCR_SBURST_0 | (uint32_t)MDMA_CTCR_SBURST_2)
   9 v  ?  @8 K* m- c; l' }
5. #define MDMA_SOURCE_BURST_64BEATS       ((uint32_t)MDMA_CTCR_SBURST_1 | (uint32_t)MDMA_CTCR_SBURST_2)
   5 V. F: W7 p. x. i& S3 y
6. #define MDMA_SOURCE_BURST_128BEATS      ((uint32_t)MDMA_CTCR_SBURST)
   / j- F/ y3 l6 T' H# Q: I

复制代码

2 C: l. G7 a" r+ b! V
+ o8 Q$ Z2 b% U3 u1 S6 D; ]  DestBurst
目的数据端突发设置，特别注意突发传输的数量不能超过BufferTransferLength参数设置的大小，具体支持的参数如下
6 x6 Y8 D! n  V; I) g8 n

1. #define MDMA_DEST_BURST_SINGLE        ((uint32_t)0x00000000U)                                       
   & \# ?: g9 K, D8 \- s+ _0 C+ k
2. #define MDMA_DEST_BURST_2BEATS        ((uint32_t)MDMA_CTCR_DBURST_0)                                 
   : h! x1 g9 a/ s9 l
3. #define MDMA_DEST_BURST_4BEATS        ((uint32_t)MDMA_CTCR_DBURST_1)                                 #define MDMA_DEST_BURST_8BEATS        ((uint32_t)MDMA_CTCR_DBURST_0 | (uint32_t)MDMA_CTCR_DBURST_1)
   7 B! v# m/ X: N+ D: q$ K3 b
4. #define MDMA_DEST_BURST_16BEATS       ((uint32_t)MDMA_CTCR_DBURST_2)                                 
   . {* [" m1 D0 q
5. #define MDMA_DEST_BURST_32BEATS       ((uint32_t)MDMA_CTCR_DBURST_0 | (uint32_t)MDMA_CTCR_DBURST_2)  
   9 u8 o* H2 V  b4 F
6. #define MDMA_DEST_BURST_64BEATS       ((uint32_t)MDMA_CTCR_DBURST_1 | (uint32_t)MDMA_CTCR_DBURST_2)
   3 h+ T' P) M4 G) N+ R" ^/ u
7. #define MDMA_DEST_BURST_128BEATS      ((uint32_t)MDMA_CTCR_DBURST)  
   

复制代码

3 t7 \- }! E3 K9 _- |( `  SourceBlockAddressOffset
用于设置源地址端数据偏移。

  DestBlockAddressOffset
6 B5 ^. F( l' a0 _7 s2 @: U用于设置目的地址端数据偏移。
5 h1 G) ?1 n# ~1 j' O2 S% T1 l- Y0 Y
61.3.3 MDMA结构体句柄MDMA_HandleTypeDef
$ N# Z- Y( q& }( W6 a) PHAL库在MDMA_Channel_TypeDef和MDMA_InitTypeDef的基础上封装了一个结构体MDMA_HandleTypeDef，定义如下：

2 V7 m9 l) v* ]1 [  R) P

1. typedef struct __MDMA_HandleTypeDef
   
2. {
   % e/ {; ]3 U4 U4 [
3.   MDMA_Channel_TypeDef *Instance;                                                                                                                                                                                             
   
4.   MDMA_InitTypeDef      Init;                                                              
   % N. E  s8 a, W$ D
5.   HAL_LockTypeDef       Lock;                                                                  
   
6.   __IO HAL_MDMA_StateTypeDef  State;                                                           
   8 c# \9 Z( a- A2 N$ \1 f& ~) ^
7.   void                  *Parent;                                                               
   2 Y( y  ^9 O0 ~& R! ]
8.   void                  (* XferCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);           
   ) \3 {; G3 l9 z$ Z1 p" X5 @2 b7 h) u
9.   void                  (* XferBufferCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);     
   
10.   void                  (* XferBlockCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);      
    : q5 z) Y. C3 F7 u! z% J
11.   void                  (* XferRepeatBlockCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);
    
12.   void                  (* XferErrorCallback)( struct __MDMA_HandleTypeDef * hmdma);           
    . @/ a+ }$ ~5 H
13.   void                  (* XferAbortCallback)( struct __MDMA_HandleTypeDef * hmdma);           
    / n( l' Y7 a" E. \4 A' R
14.   MDMA_LinkNodeTypeDef *FirstLinkedListNodeAddress;                                             
    
15.   MDMA_LinkNodeTypeDef *LastLinkedListNodeAddress;                                             
    ( V7 Z; T% R: ~
16.   uint32_t LinkedListNodeCounter;                                                                                                                                                                                      
    
17.   __IO uint32_t          ErrorCode;                                                            
    
18. } MDMA_HandleTypeDef;

复制代码

4 \# ]" F, m: V$ L) K下面将这几个参数逐一做个说明。

! J& l) `+ q# A+ e9 d- b  z  MDMA_Channel_TypeDef  *Instance
0 A0 ^$ V( M; _, ~0 J" F) s这个参数MDMA通道的例化，方便操作寄存器，详见本章3.1小节。

% U. K# U2 [! ~  MDMA_InitTypeDef      Init
! Q" S5 I% v8 t( R% S这个参数用于MDMA的通道参数初始化，详见本章3.2小节。

  void   *Parent
4 m# u$ Z, ?- }( J! Z+ n用于记录MDMA关联的外设。

    void   (* XferCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);         
    void   (* XferBufferCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);   
    void   (* XferBlockCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);     
2 `" p( O( u9 D4 H( o, t9 B    void   (* XferRepeatBlockCpltCallback)( struct __MDMA_HandleTypeDef * hmdma);
: ^2 r3 l1 s$ l* m, L7 k' D    void   (* XferErrorCallback)( struct __MDMA_HandleTypeDef * hmdma);         
    void   (* XferAbortCallback)( struct __MDMA_HandleTypeDef * hmdma);   
MDMA的各种回调函数。   

  MDMA_LinkNodeTypeDef *FirstLinkedListNodeAddress;
  MDMA_LinkNodeTypeDef *LastLinkedListNodeAddress;
3 z1 J. p) ^6 z  R6 B: G' r  uint32_t LinkedListNodeCounter;
用于MDMA的列表模式。

  HAL_LockTypeDef          Lock           
* }6 K5 w1 L- `% W  __IO  HAL_DAC_STATETypeDef  State           
  __IO  uint32_t           ErrorCode      
这三个变量主要供函数内部使用。Lock用于设置锁状态，State用于设置DAC状态，而ErrorCode用于配置代码错误。
3 f* w4 V# Z- M! x& w1 i+ D
% V/ c! f! o. g3 U: B61.3.4 MDMA初始化流程总结
0 V3 W* [' j: r" z% q使用方法由HAL库提供：
8 j3 v( \. ]- c! ?) W/ f
: ^/ T7 V7 ?# }! M  第1步：基本的初始化。
# z5 W/ C, Z& O/ x6 ?3 z' H8 U, Y
# T( C. |4 k) [9 Q* d1 |) a  函数HAL_MDMA_Init配置MDMA的基本参数。
/ N# ^; E: d* Q. }$ [+ P9 R
7 `. n" b5 l$ u) H
- y) R- L  L% P  第2步：列表模式。
5 Z8 p5 i0 Z' P
0 k) M3 J* @) z如果使用列表模式，用户可以使用函数HAL_MDMA_LinkedList_CreateNode创建节点，再通过函数HAL_MDMA_LinkedList_AddNode将节点添加到列表里面。
6 r% ]) C0 L, [5 H# |  ^4 `
8 d; h! P" n6 v
  第3步：查询模式。

  函数HAL_MDMA_Start 启动传输。
* g# n/ V$ ^, t0 V2 Y' ?, V  函数HAL_MDMA_PollForTransfer 查询传输完成。
  函数HAL_MDMA_Abort 终止传输。

0 k2 G# Z/ q  M
) a; W! e2 \& ^5 K4 g6 K' u  第4步：中断方式。

函数HAL_NVIC_SetPriority设置MDMA中断优先级。
函数HAL_NVIC_EnableIRQ使能中断。
9 h4 h" @5 i4 Z: z; B. Z 函数HAL_MDMA_Start_IT启动中断传输。
MDMA的中断服务程序MDMA_IRQHandler里面调用HAL_MDMA_IRQHandler，如果用户注册了各种回调函数，会在此函数里面执行。
函数HAL_MDMA_Abort_IT可以终止MDMA中断传输，终止完成后，会调用回调函数XferAbortCallback（如果设置了的话）
( K5 q0 M3 _( x4 f# |
$ y# g' ^* X7 }2 |! }6 X2 _- o
  第5步：中断回调函数。

5 V# p" @) ~4 ?* \函数HAL_MDMA_RegisterCallback注册回调函数，函数HAL_MDMA_UnRegisterCallback取消注册回调函数。

  XferCpltCallback            : 传输完成回调。
  XferBufferCpltCallback      : buffer传输完成回调。
  XferBlockCpltCallback       : block 传输完成回调。
  XferRepeatBlockCpltCallback : repeated block传输完成回调。
; i. H/ z& U3 o; p+ f, O# M  XferErrorCallback           : 传输错误回调。
) o2 Z: z2 f# ~9 L  XferAbortCallback          : 传输终止回调。

. i( X) }7 l/ N4 m+ K; s3 [
61.4 源文件stm32h7xx_hal_mdma.c
这里把我们把如下几个常用到的函数做个说明：
3 C+ S" {/ \+ j5 m7 T* `2 C# I% V
& R/ @  }: ~) I  p3 ^  HAL_MDMA_Init
# N5 U3 V+ V& _5 x. m# N( |  l2 f  HAL_MDMA_Start_IT
61.4.1 函数HAL_MDMA_Init
" |2 x9 M1 g; T5 F- B3 ?函数原型：
+ S+ X1 O5 h% L8 x

1. HAL_StatusTypeDef HAL_MDMA_Init(MDMA_HandleTypeDef *hmdma)
   $ V; m* O  u* @" P/ N' \3 g
2. {
   
3.   uint32_t tickstart = HAL_GetTick();
   0 d( l4 v/ Y3 H# ^% T9 ]. Y5 }; Q+ g
4. 
   , l6 a' K( U7 G4 H* c; ?. d
5.   /* 检测句柄是否有效 */
   % f& A+ ?% c2 u1 i7 A2 c  r
6.   if(hmdma == NULL)
   6 X0 h) n. M1 i8 j) n; n/ J5 A
7.   {
   
8.     return HAL_ERROR;
   
9.   }
   
10. 
    
11.   /* 检测参数 */
    
12.   assert_param(IS_MDMA_STREAM_ALL_INSTANCE(hmdma->Instance));
    2 K: t* n. N, {
13.   assert_param(IS_MDMA_PRIORITY(hmdma->Init.Priority));
    8 {( K* ^  Q) H" Q
14.   assert_param(IS_MDMA_ENDIANNESS_MODE(hmdma->Init.Endianness));
    
15.   assert_param(IS_MDMA_REQUEST(hmdma->Init.Request));
    
16.   assert_param(IS_MDMA_SOURCE_INC(hmdma->Init.SourceInc));
    , R" a8 r+ t2 I
17.   assert_param(IS_MDMA_DESTINATION_INC(hmdma->Init.DestinationInc));
    $ k: x+ C7 x# w7 V! X
18.   assert_param(IS_MDMA_SOURCE_DATASIZE(hmdma->Init.SourceDataSize));
    3 ~2 b% C* x3 |2 k$ J
19.   assert_param(IS_MDMA_DESTINATION_DATASIZE(hmdma->Init.DestDataSize));
    ! ?& [- }: u0 \
20.   assert_param(IS_MDMA_DATA_ALIGNMENT(hmdma->Init.DataAlignment));
    & @. R+ ]& r* ~% c
21.   assert_param(IS_MDMA_SOURCE_BURST(hmdma->Init.SourceBurst));
    
22.   assert_param(IS_MDMA_DESTINATION_BURST(hmdma->Init.DestBurst));
    
23.   assert_param(IS_MDMA_BUFFER_TRANSFER_LENGTH(hmdma->Init.BufferTransferLength));
    
24.   assert_param(IS_MDMA_TRANSFER_TRIGGER_MODE(hmdma->Init.TransferTriggerMode));
    - i! O/ X! p$ J& e# X* o5 a. K
25.   assert_param(IS_MDMA_BLOCK_ADDR_OFFSET(hmdma->Init.SourceBlockAddressOffset));
    # `, h6 v/ a3 |$ e: j9 B" ~) ?
26.   assert_param(IS_MDMA_BLOCK_ADDR_OFFSET(hmdma->Init.DestBlockAddressOffset));
    # {% q/ k4 p$ O! E
27. 
    ( {/ G( K  E" G: d. P
28. 
    5 h. n4 A% f0 I8 U$ d+ d
29.   /* 解锁 */
    
30.   __HAL_UNLOCK(hmdma);
    7 C) ^0 t; G. }& F2 X
31. 
    
32.   /* Change MDMA peripheral state */
    
33.   hmdma->State = HAL_MDMA_STATE_BUSY;
    $ o0 Y5 E: x5 A) l, M! Z- ]
34. 
    # i) L8 V0 U3 g) x" {
35.   /* 禁止MDMA */
    
36.   __HAL_MDMA_DISABLE(hmdma);
    ! S0 v+ i) n: p0 n/ L
37. 
    
38.   /* 等待禁止成功 */
    ! W3 N8 I: h* J; {$ T
39.   while((hmdma->Instance->CCR & MDMA_CCR_EN) != RESET)
    
40.   {
    2 c6 G* `  T  \) U- Z4 z. s$ T
41.     if((HAL_GetTick() - tickstart ) > HAL_TIMEOUT_MDMA_ABORT)
    
42.     {
    # E& x- k. r# z- j6 v4 ]! A5 Z2 a
43.       hmdma->ErrorCode = HAL_MDMA_ERROR_TIMEOUT;
    
44. 
    8 c: E! s2 f; p! g
45.       hmdma->State = HAL_MDMA_STATE_ERROR;
    ( x2 E8 ]+ V( I  o
46. 
    $ K/ y" l, H8 Y: m: @+ y
47.       return HAL_ERROR;
    
48.     }
    
49.   }
    7 ?0 t+ ]- a, R; G
50. 
    
51.   /* 初始化 MDMA  */
    / z8 Z$ B  S+ b( v5 |1 |
52.   MDMA_Init(hmdma);
    
53. 
    
54.   /* 复位列表模式相关设置 */
    4 ^+ [0 K( M- o$ u3 \" E
55.   hmdma->FirstLinkedListNodeAddress  = 0;
    1 P; `1 y+ _  W, M
56.   hmdma->LastLinkedListNodeAddress   = 0;
    , W5 `& e2 N3 Q4 [
57.   hmdma->LinkedListNodeCounter  = 0;  
    
58. 
    
59.   /* 设置无错误 */
    * f. P' k& x. P/ d& U7 R6 W
60.   hmdma->ErrorCode = HAL_MDMA_ERROR_NONE;
    0 S: h$ @; n( K+ ~7 e% ]
61. 
    ) z* h  r8 S, r$ s
62.   /* 设置就绪 */
      V& u$ ?9 s9 M
63.   hmdma->State = HAL_MDMA_STATE_READY;
    & t- q$ K3 {, a/ r, [1 }  ^
64. 
    4 e& a+ f5 \/ I
65.   return HAL_OK;
    
66. }

复制代码

函数描述：
% ^; H, q3 p# \2 u% w
此函数用于初始化MDMA。
" e$ a& h, f5 h0 p' a6 J' b
& a* f5 w5 h1 A; d) y函数参数：

/ c8 K5 d/ V% P7 k0 B+ l; J. W  第1个参数是MDMA_HandleTypeDef类型结构体指针变量，结构体变量成员的详细介绍看本章3.3小节。
& a+ X' ]! c/ T2 J( E& p3 O  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：
" a) R# ?3 ^6 h( a1 d1 P& d
' u; t& b* M- T

1. MDMA_HandleTypeDef  MDMA_Handle;
   
2. 
   ' c7 }# N* J1 J7 V0 X
3. __HAL_RCC_MDMA_CLK_ENABLE();  
   : T- K  {8 r5 P$ t3 H
4. 
   - ^2 H. ?+ u1 j  K& X- X+ I
5. MDMA_Handle.Instance = MDMA_Channel0;  
   
6. 
   : {. o3 D7 E8 e4 s* g2 o1 x, {
7. MDMA_Handle.Init.Request              = MDMA_REQUEST_SW;         /* 软件触发 */
   ! _3 ~7 `" I* S) C* I/ W. t2 w9 S) K
8. MDMA_Handle.Init.TransferTriggerMode  = MDMA_BLOCK_TRANSFER;     /* 块传输 */
   3 @2 v, |6 C7 Y( H% I( p
9. MDMA_Handle.Init.Priority             = MDMA_PRIORITY_HIGH;      /* 优先级高*/
   
10. MDMA_Handle.Init.Endianness           = MDMA_LITTLE_ENDIANNESS_PRESERVE; /* 小端 */
    0 h% t+ _/ K% }0 ^2 g: ^
11. MDMA_Handle.Init.SourceInc            = MDMA_SRC_INC_DOUBLEWORD;         /* 源地址自增，双字，即8字节 */
    
12. MDMA_Handle.Init.DestinationInc       = MDMA_DEST_INC_DOUBLEWORD;        /* 目的地址自增，双字，即8字节 */
    
13. MDMA_Handle.Init.SourceDataSize       = MDMA_SRC_DATASIZE_DOUBLEWORD;    /* 源地址数据宽度双字，即8字节 */
    ; c8 @, L6 F, w! r+ h9 v
14. MDMA_Handle.Init.DestDataSize         = MDMA_DEST_DATASIZE_DOUBLEWORD;   /* 目的地址数据宽度双字，即8字节 */
    
15. MDMA_Handle.Init.DataAlignment        = MDMA_DATAALIGN_PACKENABLE;       /* 小端，右对齐 */                    
      s+ H: M2 l; L
16. MDMA_Handle.Init.SourceBurst          = MDMA_SOURCE_BURST_16BEATS;      /* 源数据突发传输 */
    4 ?: X* x4 M% |; s* l/ c0 N
17. MDMA_Handle.Init.DestBurst            = MDMA_DEST_BURST_16BEATS;        /* 目的数据突发传输 */
    
18. 
    
19. MDMA_Handle.Init.BufferTransferLength = 128;    /* 每次传输128个字节 */
    ) g9 a6 [: E7 i7 V5 @5 a" s
20. 
    
21. MDMA_Handle.Init.SourceBlockAddressOffset  = 0; /* 用于block传输，地址偏移0 */
    
22. MDMA_Handle.Init.DestBlockAddressOffset    = 0; /* 用于block传输，地址偏移0 */
    
23. 
    ( r" z/ {" a1 b+ U
24. /* 初始化MDMA */
    $ M! X6 T( O8 C5 p$ ]- I" k
25. if(HAL_MDMA_Init(&MDMA_Handle) != HAL_OK)
    # Q5 M% |  C. P3 E  {
26. {
    ' q+ c6 U5 O* S% i8 p5 y
27.      Error_Handler(__FILE__, __LINE__);
    
28. }
    ( z6 `  x' k4 O/ t! Y' U
29. 
    

复制代码

61.4.2 函数HAL_MDMA_Start_IT
函数原型：
7 F* C3 h+ p: [; t3 ~* b$ P0 o9 W1 A
% H  J# B$ \; Z- ]( d: D4 e

1. HAL_StatusTypeDef HAL_MDMA_Start_IT(MDMA_HandleTypeDef *hmdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t BlockDataLength, uint32_t BlockCount)
   
2. {
   
3.   /* 检测参数 */
   
4.   assert_param(IS_MDMA_TRANSFER_LENGTH(BlockDataLength));
   $ u9 a5 \6 d3 T8 Z& e  K& M. O
5.   assert_param(IS_MDMA_BLOCK_COUNT(BlockCount));
   
6. 
   
7.   /* 检测句柄是否有效 */
   
8.   if(hmdma == NULL)
   
9.   {
   . N# Y! L6 M8 O
10.     return HAL_ERROR;
    
11.   }
    
12. 
    
13.   /* 上锁 */
    
14.   __HAL_LOCK(hmdma);
    * F% s$ r9 N3 L
15. 
    ; L' J1 s, P4 _0 z
16.   if(HAL_MDMA_STATE_READY == hmdma->State)
    
17.   {
    / P7 Y1 w% ^; Y
18.     hmdma->State = HAL_MDMA_STATE_BUSY;
    
19. 
    % e! \  }: u3 N/ g
20.     hmdma->ErrorCode = HAL_MDMA_ERROR_NONE;     
    
21. 
    - Q: X" `5 L& E9 C* T! z
22.     __HAL_MDMA_DISABLE(hmdma);
    
23. 
    5 U, C' w  [4 k! |. w3 X! Y9 p  @
24.     /* 配置MDMA */
    ' C+ _: W" Y5 D# q
25.     MDMA_SetConfig(hmdma, SrcAddress, DstAddress, BlockDataLength, BlockCount);
    * ]  F) ?/ e0 V4 J( s
26. 
    $ m* k4 W1 m9 h4 N2 b1 t; P  J4 F
27.     /* 使能传输错误和传输完成中断 */
    2 y9 p6 X* `7 R4 O4 J
28.     __HAL_MDMA_ENABLE_IT(hmdma, (MDMA_IT_TE | MDMA_IT_CTC));
    + Z" d4 l- y" \7 |; k# I; w
29. 
    
30.     if(hmdma->XferBlockCpltCallback != NULL)
    
31.     {
    
32.       /* 使能块传输完成中断 */
    
33.       __HAL_MDMA_ENABLE_IT(hmdma, MDMA_IT_BT);   
    
34.     }
    
35. 
    
36.     if(hmdma->XferRepeatBlockCpltCallback != NULL)
    
37.     {
    + r- g- K" H1 `* |* o; U
38.       /* 使能多块传输完成中断 */      
    " J+ D9 [! L3 }2 J
39.       __HAL_MDMA_ENABLE_IT(hmdma, MDMA_IT_BRT);   
    
40.     }  
    1 z3 M# e) c: b/ X% C
41. 
    
42.     if(hmdma->XferBufferCpltCallback != NULL)
    ; w* ~5 x1 J0 T' B
43.     {
    2 X3 A  K9 k0 N, s! q3 T
44.       /* 使能传输完成中断 */
    
45.       __HAL_MDMA_ENABLE_IT(hmdma, MDMA_IT_BFTC);
    
46.     }
    
47. 
    
48.     /* 使能外设 */
    7 B' R& g: `9 |" K5 a  @
49.     __HAL_MDMA_ENABLE(hmdma);
    
50. 
    1 c. W, i5 _& T- }3 }% E
51.     if(hmdma->Init.Request == MDMA_REQUEST_SW)
    : f* d$ k  a' y& G1 F
52.     {
    
53.       /* 使能软件请求 */
    
54.       hmdma->Instance->CCR |=  MDMA_CCR_SWRQ;
    / B0 b# m! Y9 n* ^' v: g" p
55.     }  
    
56.   }
    $ b4 j$ y) r! Y2 @* D) r
57.   else
    
58.   {
    + y8 c. r$ c. b  k
59.     /* 解锁 */
    ( Q+ @1 C3 m& ~0 C, ^4 ]+ N6 N
60.     __HAL_UNLOCK(hmdma);
    : d9 z% m* {- S+ t) \" I
61. 
    
62.     /* 返回忙 */
    
63.     return HAL_BUSY;
    
64.   }
    
65. 
    
66.   return HAL_OK;
    
67. }

复制代码

& y7 k% A+ ~5 J6 U' ?' L. W

1 |& L5 i1 c4 O: L2 g函数描述：

此函数主要用于配置MDMA的中断方式传输。

( i, ^0 g" O  R* N9 G函数参数：

; m$ Z" X5 E+ B. `  第1个参数是MDMA_HandleTypeDef类型结构体指针变量，结构体变量成员的详细介绍看本章3.3小节。
" ?% k& b2 w, {8 G; j. o  第2个参数是源缓冲地址。
2 M5 {$ O* D1 f  第3个参数是目的地址。
* ^: ~- H; L# J+ N" i: M$ \  第4个参数是传输的块大小，单位字节，范围不可以超过65536字节。
  第5个参数是传输的块数，范围不可以超过4095块。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
/ {, `& X& M) R* A使用举例：
. ?$ G: B' W2 N. ^/ v2 d

1. /* 将地址0x24000000开始的64KB数据复制到地址0x24000000 + 64*1024 */
   0 }& P: w- R5 C, F4 n" p+ A
2. HAL_MDMA_Start_IT(&MDMA_Handle,
   
3.                   (uint32_t)0x24000000,
   0 Z3 g. [. _3 c# m& ^  U
4.                   (uint32_t)(0x24000000 + 64*1024),
   ) ]! _% t( w8 D) a7 J' G+ I
5.                   64*1024,
   
6.                   1);
   

复制代码

  \1 R- \" J2 [; T61.5 总结
0 P5 h9 y( a1 x, Z2 A) n本章节就为大家讲解这么多，MDMA功能用到的地方还是比较多的，后面的章节会为大家做讲解。


* Z! w9 h& X4 r. f