【经验分享】STM32H7的DMA基础知识和HAL库API

[复制链接]

STMCU小助手发布时间：2021-10-30 22:46

文章
文章封面:
文章简介:	DMA1和DMA2均支持8路通道。虽然是8路，但这8路不是并行工作的，而是由DMA的仲裁器决定当前处理那一路。

42.1 初学者重要提示
  DMA1和DMA2均支持8路通道。虽然是8路，但这8路不是并行工作的，而是由DMA的仲裁器决定当前处理那一路。
  DMA最大传输次数65535次，每次传输单位可以是字节、半字和字。
  DMA的循环模式不可用于存储器到存储器模式。
  DMA1和DMA2带的FIFO是4个32bit的空间，即16字节。
  使用DMA的FIFO和突发需要注意的问题较多，详情可看本章2.7小节。
  STM32H7的参数手册DMA章节对存储器到存储器，外设到存储器，外设到存储器模式的传输过程进行了讲解，推荐大家看完本章节后读一下。
42.2 DMA基础知识
DMA的几个关键知识点放在开头说：

  由于总线矩阵的存在，各个主控的道路四通八达，从而可以让DMA和CPU同时开工，但是注意一点，如果他们同时访问的同一个外设，会有一点性能影响的。
  DMA支持存储器到外设，外设到存储器和存储器到存储器的传输，不支持外设到外设的传输，而BDMA是支持的，这个模式在低功耗模式下比较有用。
  DMA1和DMA2是有两个AHB总线主控，可以分别用于源地址和目的地址的传输。
  源地址和目的地址的数据宽度可以不同，但是数据地址必须要跟其数据类型对齐。比如源地址是uint32类型的，那么此数组的地址必须4字节对齐。
  DMA主要有两种模式，一个是Normal正常模式，传输一次后就停止传输；另一种是Circular循环模式，会一直循环的传输下去，即使有DMA中断，传输也是一直在进行的。
  DMA的数据流请求（Stream0 – Stream7）的优先级可编程，分为四级Very high priority，High priority，Medium priority和Low priority。通道的优先级配置相同的情况下，如果同时产生请求，会优先响应编号低的，即Stream0优先响应。
42.2.1 DMA硬件框图
认识一个外设，最好的方式就是看他的框图，方便我们快速的了解DMA的基本功能，然后再看手册了解细节。框图如下所示（DMA1和DMA2是一样的）：

aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2NvbW1vbi8xMzc5MTA3LzIwMjAwMS8xMzc5MTA3LTIw.png

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

  dma_str0 – dma_str7
这里是8路来自DMAMUX1的DMA请求信号。

  dma_it[0:7]接口
通道0 – 通道7的中断触发。

  dma_tcif[0:7]接口
通道0 – 通道7的传输完成标志，可以用于触发MDMA 。

  Arbiter仲裁器
用于仲裁当期要处理的DMA请求。通过这里我们可以看出虽然是8路，但这8路不是并行工作的，而是由DMA的仲裁器决定当前处理哪一路。

  AHB总线接口
DMA1和DMA2有两个接口，可以分别用于源地址和目的地址的传输。

42.2.2 DMA传输
DMA支持如下几种传输模式：

  存储器到外设。
  外设到存储器。
  存储器到存储器。

关于这几种传输方式要注意以下几个问题：

  源地址和目的地址的数据宽度可以不同，但是数据地址必须要跟其数据类型对齐。比如源地址是uint32类型的，那么此数组的地址必须4字节对齐。
  DMA1和DMA2是不支持外设到外设的传输，BDMA是支持的，这个模式在低功耗模式下比较有用。
  使用存储器到存储器模式不支持循环传输模式，同时必须开启FIFO，即不支持直接模式（关闭了FIFO就是直接模式Direct mode）。

42.2.3 DMA的循环模式和正常模式
BDMA主要有两种模式，一个是Normal正常模式，传输一次后就停止传输；另一种是Circular循环模式，会一直循环的传输下去，即使有DMA中断，传输也是一直在进行的。

这两种模式各有用途。

  Normal正常模式
适合用于单次传输，比如存储器到存储器的数据复制粘贴，又比如串口的数据单次发送，下次还需要发送的时候，使能下即可。

  Circular循环模式
适合用于需要连续传输的场合，比如定时器触发BDMA实现任意IO的PWM输出。

另外特别注意，循环模式不可用于存储器到存储器模式。

42.2.4 DMA数据封装和解封
DMA1和DMA2可以实现源和目标数据宽度不等时的传输，实现的关键是务必开启FIFO。无需像F1系列那样强行要求数据缓冲的4字节对齐。下面是各种源地址和目的地址数据宽度传输的效果，可以帮助大家更好的理解。

这里为大家说下这个图应该如何查看：

  首先看NDT（要传输的数据项目列），这一列跟外设传输的项目数是一样的。对应到外设端口地址列，PINCOS=1和PINCOS=0时的传输次数也是一致的。
注：PINGCOS=1表示外设地址偏移固定为4，PINCOS=0表示外设地址的偏移量由用户配置的外设数据宽度，即PSIZE决定。

  有了要传输的数据个数，外设端口宽度和存储器端口宽度后
存储器的传输数目 = NDT * 外设端口宽度 / 存储器端口宽度。

有了这两条，大家看上面的表格就方便很多了。最后就是注意PINCOS配置所代表的含义。

42.2.5 DMA双缓冲
DMA1和DMA2支持双缓冲模式的，双缓冲的含义是源地址或者目的地址可以设置两个缓冲区，这种方式的好处是一个缓冲区在接收或者发送数据的时候，另一个缓冲区可以动态更新数据或者处理已经接收到的数据。

当用户开启了DMA传输完成中断后，通过寄存器CCRx的CT位判断当前使用的是哪个缓冲区：

  如果CT = 1表示当前正在使用缓冲区1，即寄存器DMA_SxM1AR记录的地址。
  如果CT = 0表示当前正在使用缓冲区0，即寄存器DMA_SxM0AR记录的地址。

另外注意，存储器到存储器的DMA传输不支持双缓冲模式，仅可以用于存储器到外设或者外设到存储器。

42.2.6 DMA的FIFO和突发支持
使用DMA的FIFO主要有两个作用，一个是降低总线带宽的需求，另一个是前面说的源地址数据宽度和目的地址数据宽度不同时的数据传输。

而突发传输的含义是每个DMA请求后可以连续传输的数据项目数，支持4次，8次和16次。

了解到以上两点就够用了，现在重点讲解下使用中的注意事项，使用FIFO要注意的事项较多。

  禁止FIFO的情况下，即STM32H7参考手册里面所说的直接模式Direct Mode，务必要保证外设数据宽度和内存数据宽度是一样的，而且禁止了FIFO的情况下，不支持突发，即使配置了，也是无效的。
  禁止了FIFO的情况下，也不可用于存储器到存储器的数据传输，仅支持外设到存储器或者存储器到外设方式。
  使能FIFO的情况下，可以使用突发模式，也可以不使用。
  独立的源和目标传输宽度（字节、半字、字）：源和目标的数据宽度不相等时， DMA 自动封装/解封必要的传输数据来优化带宽。这个特性仅在 FIFO 模式下可用。这个特性非常重要，在H7使用 SDIO时要用到。无需像F1系列那样强行数据缓冲的4字节对齐要求。

最后要特别注意一点，一般应用中最好关闭FIFO，实际测试发现容易有一些比较奇怪的问题，大家测试的时候要注意。

42.2.7 DMA支持的各种配置
不像BDMA，配置DMA1和DMA2时要注意的事项较多，通过下面的图可以帮助大家方便的验证配置选项是否合理：

42.3 DMA的HAL库用法
DMA的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。

42.3.1 DMA寄存器结构体
DMA相关的寄存器是通过HAL库中的结构体DMA_TypeDef和DMA_Stream_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

typedef struct
2 G+ a/ z' B' ^$ s
{
3 S# G3 b% D& Q
__IO uint32_t LISR; /*!< DMA low interrupt status register, Address offset: 0x00 */
4 s5 r+ ~% x, B# Q9 [
__IO uint32_t HISR; /*!< DMA high interrupt status register, Address offset: 0x04 */
4 t' i) B, Y5 H4 e" Z
__IO uint32_t LIFCR; /*!< DMA low interrupt flag clear register, Address offset: 0x08 */
7 {) F# O( j( ~2 @
__IO uint32_t HIFCR; /*!< DMA high interrupt flag clear register, Address offset: 0x0C */- e& G+ D* V3 A1 y" c- a
} DMA_TypeDef;
' p u& e% n, G5 X
& L% ?) a, W/ a; O. e
typedef struct7 N0 @7 D" {7 s4 }4 V6 u
{
1 K5 p: s4 G9 Q; A
__IO uint32_t CR; /*!< DMA stream x configuration register */
1 j6 V( y b( E/ ^0 B% F0 v
__IO uint32_t NDTR; /*!< DMA stream x number of data register */
0 S- x: F! P5 t# j1 Z6 l2 G
__IO uint32_t PAR; /*!< DMA stream x peripheral address register */) _% K% e8 I7 v0 B8 L% F: |6 \' e$ q
__IO uint32_t M0AR; /*!< DMA stream x memory 0 address register */ F1 |6 w* V0 c) \( P9 A
__IO uint32_t M1AR; /*!< DMA stream x memory 1 address register */
" h; P5 }4 W' q1 d. l2 N' v6 n5 O8 |
__IO uint32_t FCR; /*!< DMA stream x FIFO control register */
4 Q6 ^( N6 l4 B* X5 o
} DMA_Stream_TypeDef;8 J+ L7 W' c5 d. F

复制代码

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

#define __O volatile /*!< Defines 'write only' permissions */- N5 I; ^6 O9 _$ }6 j
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

与其它外设的的定义方式不同，DMA有8组通道，每个通道都有一组DMA_Stream_TypeDef结构体所定义的寄存器。

解决这个问题的办法就是定义一套DMA1_Stream0 - DMA_Stream7来解决，定义在stm32h743xx.h文件。

#define PERIPH_BASE ((uint32_t)0x40000000)
- c. t3 w2 G: u; W
#define D2_AHB1PERIPH_BASE (PERIPH_BASE + 0x00020000)
# }7 e5 z( p# p$ m5 U/ \
#define DMA1_BASE (D2_AHB1PERIPH_BASE + 0x0000)
3 b8 h y% o* @# W0 T9 y* i5 q* J
#define DMA2_BASE (D2_AHB1PERIPH_BASE + 0x0400)
3 v! v0 i( R2 I) Q5 w/ a
#define DMA1 ((DMA_TypeDef *) DMA1_BASE)) e! a1 q: N& l1 u6 h
#define DMA2 ((DMA_TypeDef *) DMA2_BASE) H9 c3 u! `: R0 l
M0 _% b+ b! Y
#define DMA1_Stream0_BASE (DMA1_BASE + 0x010)0 A8 \% n5 N1 |: |9 s% `6 Z
#define DMA1_Stream1_BASE (DMA1_BASE + 0x028)
#define DMA1_Stream2_BASE (DMA1_BASE + 0x040)
! x$ J w0 l0 j: ?3 T
#define DMA1_Stream3_BASE (DMA1_BASE + 0x058)( {, i/ n0 i1 r, V
#define DMA1_Stream4_BASE (DMA1_BASE + 0x070)& b) X) G l/ j4 ^
#define DMA1_Stream5_BASE (DMA1_BASE + 0x088)
& [0 N$ o9 _" @" S3 J& X
#define DMA1_Stream6_BASE (DMA1_BASE + 0x0A0)
3 A8 r8 _3 }0 p0 K' D& l& y
#define DMA1_Stream7_BASE (DMA1_BASE + 0x0B8)7 R( Q: W$ j4 |9 k& C+ `4 Z
; h; S- ^0 R' v5 H& T
<-----展开下面DMA1_Stream0的宏定义，(DMA_Stream_TypeDef *) 0x40020010% C/ O, k; G; [% C. ?
#define DMA1_Stream0 ((DMA_Stream_TypeDef *) DMA1_Stream0_BASE)$ O2 S8 I, _2 g0 d. [- @! t
#define DMA1_Stream1 ((DMA_Stream_TypeDef *) DMA1_Stream1_BASE)0 v2 r4 [2 S" m3 J0 H7 M2 B
#define DMA1_Stream2 ((DMA_Stream_TypeDef *) DMA1_Stream2_BASE)8 O3 |! c2 f2 x
#define DMA1_Stream3 ((DMA_Stream_TypeDef *) DMA1_Stream3_BASE)2 g2 f9 }0 m" Q
#define DMA1_Stream4 ((DMA_Stream_TypeDef *) DMA1_Stream4_BASE): ] y: T+ L) s! w) f9 @( b' Y! ]; Y
#define DMA1_Stream5 ((DMA_Stream_TypeDef *) DMA1_Stream5_BASE)& r D) b; j) ^6 z0 }% i
#define DMA1_Stream6 ((DMA_Stream_TypeDef *) DMA1_Stream6_BASE)
- O1 B/ C6 F( l- w0 `# o
#define DMA1_Stream7 ((DMA_Stream_TypeDef *) DMA1_Stream7_BASE)
& `0 n$ T' p! n; j8 W) V" S+ l
! U; J+ ?8 s6 b" _+ `
#define DMA1_Stream0_BASE (DMA1_BASE + 0x010)% ], |$ ]% \+ S, I7 Y
#define DMA1_Stream1_BASE (DMA1_BASE + 0x028)
5 x& _# Z; M& f+ Z
#define DMA1_Stream2_BASE (DMA1_BASE + 0x040)$ P: c+ u* ], B& H0 o2 U0 e m( v
#define DMA1_Stream3_BASE (DMA1_BASE + 0x058)
9 m3 Z k0 B: a; I- l
#define DMA1_Stream4_BASE (DMA1_BASE + 0x070)
9 _. o; w* ]1 s8 [. w9 S. B
#define DMA1_Stream5_BASE (DMA1_BASE + 0x088)
2 K! L a- w; N8 C
#define DMA1_Stream6_BASE (DMA1_BASE + 0x0A0)
2 o' [3 Y; @- q+ O* }
#define DMA1_Stream7_BASE (DMA1_BASE + 0x0B8)
#define DMA2_Stream0 ((DMA_Stream_TypeDef *) DMA2_Stream0_BASE)1 U) r5 C! i; P I
#define DMA2_Stream1 ((DMA_Stream_TypeDef *) DMA2_Stream1_BASE)
, \" u" n. A% Z% o% D
#define DMA2_Stream2 ((DMA_Stream_TypeDef *) DMA2_Stream2_BASE)* z( G" {# [2 a. P2 N( d: |
#define DMA2_Stream3 ((DMA_Stream_TypeDef *) DMA2_Stream3_BASE)' c% f9 B2 `8 M! \
#define DMA2_Stream4 ((DMA_Stream_TypeDef *) DMA2_Stream4_BASE)2 @, F3 x7 r5 A- s
#define DMA2_Stream5 ((DMA_Stream_TypeDef *) DMA2_Stream5_BASE)
7 s/ }, \% n. [. r% _8 H
#define DMA2_Stream6 ((DMA_Stream_TypeDef *) DMA2_Stream6_BASE)
' }- v( r: Y! o
#define DMA2_Stream7 ((DMA_Stream_TypeDef *) DMA2_Stream7_BASE)

复制代码

我们访问DMA1的LISR寄存器可以采用这种形式：DMA1->LISR = 0，而访问DMA1 Stream0的CR就可以采用这种形式DMA1_Stream0->CR = 0。

42.3.2 DMA句柄结构体DMA_HandleTypeDef
HAL库在DMA_TypeDef的基础上封装了一个结构体DMA_HandleTypeDef，定义如下：

typedef struct __DMA_HandleTypeDef
9 e# g- q0 i. b
{
" b/ ^) w4 j2 J4 S
void *Instance;
2 E0 ]' W4 e4 }$ ^
DMA_InitTypeDef Init;
$ E2 l: \6 U( y7 F9 F! n
HAL_LockTypeDef Lock;
, z4 H9 A; f4 T. q: G4 u
__IO HAL_DMA_StateTypeDef State;
) a7 V6 g1 s0 l3 W6 z
void *Parent;
1 D; |$ U: h# ^3 j7 x
void (* XferCpltCallback)( struct __DMA_HandleTypeDef * hdma);
" w8 X, Q' |, z2 B5 j7 h _
void (* XferHalfCpltCallback)( struct __DMA_HandleTypeDef * hdma); 0 |0 g( r2 |$ e# }+ F
void (* XferM1CpltCallback)( struct __DMA_HandleTypeDef * hdma);
; V# |& c+ A0 q4 |, i
void (* XferM1HalfCpltCallback)( struct __DMA_HandleTypeDef * hdma); : e8 L: i. l' Y) l3 d. l
void (* XferErrorCallback)( struct __DMA_HandleTypeDef * hdma);
, n }/ |1 T7 |. w9 G
void (* XferAbortCallback)( struct __DMA_HandleTypeDef * hdma); ( f7 Y- T, f8 Y6 Z
__IO uint32_t ErrorCode;
" w, H) N# {; |6 D2 i( @
uint32_t StreamBaseAddress;
% D- _& s4 N4 x
uint32_t StreamIndex; 6 n( V. Q9 S ]$ }& j7 s- x) _, E3 e
DMAMUX_Channel_TypeDef *DMAmuxChannel;
/ g( f) s& R d9 G8 t
DMAMUX_ChannelStatus_TypeDef *DMAmuxChannelStatus; . I4 J8 C# }! p4 {
uint32_t DMAmuxChannelStatusMask; M1 X$ z- h P$ D- X
DMAMUX_RequestGen_TypeDef *DMAmuxRequestGen;
% f- m- ^5 i4 l3 W1 T
DMAMUX_RequestGenStatus_TypeDef *DMAmuxRequestGenStatus;
3 h. m6 |& u3 Z# W# i, E: @6 Q
uint32_t DMAmuxRequestGenStatusMask;
% E2 }% c8 s1 g! [% K. o
}DMA_HandleTypeDef;

复制代码

这里重点介绍前几个参数，其它参数主要是HAL库内部使用的。

void *Instance

用于BDMA，DMA1和DMA2的例化，主要是相关寄存器的操作。

因为DMA1，DMA2和BDMA都使用的这个结构体句柄，而DMA1，DMA2与BDMA的寄存器结构体封装是不同的，这里的定义比较巧妙，定义为void *空类型后，就可以直接使用DMA1，DMA2和BDMA的结构体定义了。

比如操作DMA1 Stream1的寄存器CR：

DMA_HandleTypeDef DMA_Handle;

DMA_Handle.Instance = DMA1_Stream1;

((DMA_Stream_TypeDef *) DMA_Handle ->Instance)->CR =0;

又比如操作BDMA Channel1的寄存器CCR：

DMA_HandleTypeDef BDMA_Handle;

BDMA_Handle.Instance = BDMA_Channel1;

((BDMA_Channel_TypeDef *) DMA_Handle ->Instance)->CCR =0;

DMA_InitTypeDef Init;

这个参数是用户接触最多的，用于配置DMA的基本参数，像波特率，奇偶校验，停止位等。DMA_InitTypeDef结构体的定义如下：

typedef struct( ^, \; d9 A& s V
{/ t2 D+ k( ]2 f
uint32_t Request; , L' \+ [, Z7 y2 U' f. [( |1 \
uint32_t Direction;
% b3 h/ ?" T/ g, ~6 S( y
uint32_t PeriphInc; + Q( L$ U# F) M4 A( m% I ]
uint32_t MemInc; ! l1 F% I: q4 F4 \7 a Y
uint32_t PeriphDataAlignment;
% P" D- w5 j o! {$ s
uint32_t MemDataAlignment; $ n6 ?! F2 @0 x
uint32_t Mode;
/ p; m3 y- O$ O1 G& `" @" h7 ]3 q
uint32_t Priority;
" b9 K4 d+ F+ g: R
uint32_t FIFOMode; % E* t( r/ v" ]" J1 i; P' k
uint32_t FIFOThreshold; ( F9 P/ n3 p4 e1 r
uint32_t MemBurst;
' k: p' v W# t$ ?
uint32_t PeriphBurst; 7 K% F1 ]; N4 y' X* ^
}DMA_InitTypeDef;' M. k, A6 i- j) O! s

复制代码

成员Request
用于设置支持的DMA请求，对于DMA来说，主要来自DMAMUX1。

/* D2 Domain : DMAMUX1 requests */& c3 J' _) t- H s5 n
#define DMA_REQUEST_MEM2MEM 0U /*!< memory to memory transfer */; H, T" J( ^2 x6 s4 L5 x
$ F0 ]; P2 t1 f8 y4 r
#define DMA_REQUEST_GENERATOR0 1U /*!< DMAMUX1 request generator 0 */
g2 p3 }, f+ r- o2 j9 D: V7 W
#define DMA_REQUEST_GENERATOR1 2U /*!< DMAMUX1 request generator 1 */
$ M+ b1 i$ @0 u6 ?0 U0 X
#define DMA_REQUEST_GENERATOR2 3U /*!< DMAMUX1 request generator 2 */4 r6 v+ y' `4 k& `& O& ^7 L
#define DMA_REQUEST_GENERATOR3 4U /*!< DMAMUX1 request generator 3 */
w2 I7 N# s, a7 j( N1 \0 G& C& U
#define DMA_REQUEST_GENERATOR4 5U /*!< DMAMUX1 request generator 4 */
4 g" D) B8 L$ Y1 F
#define DMA_REQUEST_GENERATOR5 6U /*!< DMAMUX1 request generator 5 */7 L* i3 m A+ z$ ~, V- `
#define DMA_REQUEST_GENERATOR6 7U /*!< DMAMUX1 request generator 6 */ G% s9 b l8 x
#define DMA_REQUEST_GENERATOR7 8U /*!< DMAMUX1 request generator 7 */+ N" k% o) x- \9 a5 w) W3 N
- c2 R: k! X' ^( X4 w* B. Y
#define DMA_REQUEST_ADC1 9U /*!< DMAMUX1 ADC1 request */
2 `" a$ r. q8 L4 Z# g, |% L/ Z- }
#define DMA_REQUEST_ADC2 10U /*!< DMAMUX1 ADC2 request */
- i' @' D1 y8 k/ F; i- |. Q1 d
2 t* N. U8 h1 k+ {' m5 k p" i: a
#define DMA_REQUEST_TIM1_CH1 11U /*!< DMAMUX1 TIM1 CH1 request */
) {, y7 C& l* o% D' J6 y7 [
#define DMA_REQUEST_TIM1_CH2 12U /*!< DMAMUX1 TIM1 CH2 request */
. T, c% T" K" K" w/ Y' I z
#define DMA_REQUEST_TIM1_CH3 13U /*!< DMAMUX1 TIM1 CH3 request */. V7 L) u4 }2 }4 z3 O: z6 Q
#define DMA_REQUEST_TIM1_CH4 14U /*!< DMAMUX1 TIM1 CH4 request */) c+ J+ i5 w. j) P
#define DMA_REQUEST_TIM1_UP 15U /*!< DMAMUX1 TIM1 UP request */4 Z: h/ ?8 m9 C b
#define DMA_REQUEST_TIM1_TRIG 16U /*!< DMAMUX1 TIM1 TRIG request */
- `$ S9 Y3 k) c7 M& N) J+ \
#define DMA_REQUEST_TIM1_COM 17U /*!< DMAMUX1 TIM1 COM request */
8 z5 r( D: L! y7 ]
" y5 Y3 j7 e3 c# ^
中间部分省略未写; D% K7 `, q- M9 I
1 F; N* g& ~5 h4 D( A0 F
#define DMA_REQUEST_TIM16_CH1 109U /*!< DMAMUX1 TIM16 CH1 request */
$ T: I% c/ _0 V2 ` P
#define DMA_REQUEST_TIM16_UP 110U /*!< DMAMUX1 TIM16 UP request */, W; H7 @0 X2 |( _/ m
1 R3 O% k) y5 {$ Y
#define DMA_REQUEST_TIM17_CH1 111U /*!< DMAMUX1 TIM17 CH1 request */
( H; b# M& e" M' W" v
#define DMA_REQUEST_TIM17_UP 112U /*!< DMAMUX1 TIM17 UP request */3 K6 K7 i$ L- `$ R3 i% S1 D% V
4 `5 ~# O8 z' B( E; ]
#define DMA_REQUEST_SAI3_A 113U /*!< DMAMUX1 SAI3 A request */7 C; e. i: S4 o" o8 D
#define DMA_REQUEST_SAI3_B 114U /*!< DMAMUX1 SAI3 B request */7 k0 t& j |. s2 C/ [0 i
! p% P9 I) Z1 h5 s9 h+ J
#define DMA_REQUEST_ADC3 115U /*!< DMAMUX1 ADC3 request */

复制代码

成员Direction
用于设置传输方向，外设到存储器，存储器到外设或者存储器到存储器，具体支持的参数如下：

#define DMA_PERIPH_TO_MEMORY ((uint32_t)0x00000000U) /*!< Peripheral to memory direction */1 p4 }; y: M. \3 x [4 p
#define DMA_MEMORY_TO_PERIPH ((uint32_t)DMA_SxCR_DIR_0) /*!< Memory to peripheral direction */- _. n3 x) M5 ~/ e" q
#define DMA_MEMORY_TO_MEMORY ((uint32_t)DMA_SxCR_DIR_1) /*!< Memory to memory direction */

复制代码

成员PeriphInc
用于设置外设地址是否使能递增，即每完成一次传输，外设地址自增，增加的大小由参数PeriphDataAlignment决定。具体支持的参数如下：

#define DMA_PINC_ENABLE ((uint32_t)DMA_SxCR_PINC) /*!< Peripheral increment mode enable */
+ a. V6 |1 G' g. l6 z( {' z
#define DMA_PINC_DISABLE ((uint32_t)0x00000000U) /*!< Peripheral increment mode disable */

复制代码

成员MemInc
用于设置存储器地址是否使能递增，即每完成一次传输，存储器地址自增，增加的大小由参数MemDataAlignment决定。具体支持的参数如下：

#define DMA_MINC_ENABLE ((uint32_t)DMA_SxCR_MINC) /*!< Memory increment mode enable */" q3 o" j3 ^5 n7 E( z( m' e" q
#define DMA_MINC_DISABLE ((uint32_t)0x00000000U) /*!< Memory increment mode disable */
) z+ a9 g# V- Q6 S/ H, j+ K7 ~* v8 S

复制代码

成员PeriphDataAlignment
用于设置外设支持的数据宽度，可以选择字节，半字和字进行传输。

#define DMA_PDATAALIGN_BYTE ((uint32_t)0x00000000U) /*!< Peripheral data alignment: Byte */
5 ?! {7 ^5 k# \* j
#define DMA_PDATAALIGN_HALFWORD (uint32_t)DMA_SxCR_PSIZE_0) /*!< Peripheral data alignment: HalfWord */! X9 S* c: _5 {
#define DMA_PDATAALIGN_WORD ((uint32_t)DMA_SxCR_PSIZE_1) /*!< Peripheral data alignment: Word */

复制代码

成员MemDataAlignment
用于设置存储器支持的数据宽度，可以选择字节，半字和字进行传输。

#define DMA_MDATAALIGN_BYTE ((uint32_t)0x00000000U) /*!< Memory data alignment: Byte */" N2 I8 |8 u) @
#define DMA_MDATAALIGN_HALFWORD ((uint32_t)DMA_SxCR_MSIZE_0) /*!< Memory data alignment: HalfWord */1 T( `& B1 t+ I1 D( h0 o
#define DMA_MDATAALIGN_WORD ((uint32_t)DMA_SxCR_MSIZE_1) /*!< Memory data alignment: Word */

复制代码

成员Mode
用于设置正常模式、循环模式和流控制，对于BDMA而言，仅支持正常模式和循环模式。

#define DMA_NORMAL ((uint32_t)0x00000000U) /*!< Normal mode */0 H, u! |) S+ {! x
#define DMA_CIRCULAR ((uint32_t)DMA_SxCR_CIRC) /*!< Circular mode */
7 R4 Y" h) B( ~( I8 i ?2 K
#define DMA_PFCTRL ((uint32_t)DMA_SxCR_PFCTRL) /*!< Peripheral flow control mode */( `1 |; a/ x p. p9 a

复制代码

成员Priority
用于DMA通道进行传输时的优先级设置，控制多通道同时请求时优先响应谁。支持四种优先级设置：

#define DMA_PRIORITY_LOW ((uint32_t)0x00000000U) /*!< Priority level: Low */! x! g& p( u- z6 o$ W( A0 _5 E
#define DMA_PRIORITY_MEDIUM ((uint32_t)DMA_SxCR_PL_0) /*!< Priority level: Medium */
3 Q, K0 B) d/ l/ V' g! U
#define DMA_PRIORITY_HIGH ((uint32_t)DMA_SxCR_PL_1) /*!< Priority level: High */7 x& I- L' T2 z* C4 F4 j
#define DMA_PRIORITY_VERY_HIGH ((uint32_t)DMA_SxCR_PL) /*!< Priority level: Very High */

复制代码

成员FIFOMode
用于配置是否使能FIFO，BDMA不支持FIFO，仅DMA1和DMA2支持。

z C3 I9 I. I# G3 z& S* O
#define DMA_FIFOMODE_DISABLE ((uint32_t)0x00000000U) /*!< FIFO mode disable */7 Y: m4 j4 R& H* Z& \: Z7 |5 t
#define DMA_FIFOMODE_ENABLE ((uint32_t)DMA_SxFCR_DMDIS) /*!< FIFO mode enable */

复制代码

成员FIFOThreshold
使能了FIFO后，用于FIFO阀值设置，BDMA不支持此参数，仅DMA1和DMA2支持。可以设置FIFO空间的四分之一，四分之二，四分之三和使用所有空间作为阀值（FIFO总大小是16字节）。

/*!< FIFO threshold 1 quart full configuration */; H4 }& a2 I" v' e
#define DMA_FIFO_THRESHOLD_1QUARTERFULL ((uint32_t)0x00000000U) $ ?. P1 H( q& m3 S
9 j+ k0 @8 |/ P ]$ ^0 [
/*!< FIFO threshold half full configuration */
- U% @! M' p, h' F3 M+ e
#define DMA_FIFO_THRESHOLD_HALFFULL ((uint32_t)DMA_SxFCR_FTH_0)
3 s9 t" \/ H( \% k$ Z
8 l$ l# O9 B# t
/*!< FIFO threshold 3 quarts full configuration */
# p6 T, D6 Z w% I- @
#define DMA_FIFO_THRESHOLD_3QUARTERSFULL ((uint32_t)DMA_SxFCR_FTH_1)
3 R# e2 [. W& \
7 k1 ^( Y% Q I7 z
/*!< FIFO threshold full configuration */* J! E; h/ ~2 s( B1 v
#define DMA_FIFO_THRESHOLD_FULL ((uint32_t)DMA_SxFCR_FTH)

复制代码

成员MemBurst
存储器突发配置，必须使能了FIFO才有效，否则设置此参数没有意义，BDMA不支持此参数，仅DMA1，DMA2支持。SINGLE表示每个DMA请求进行1次，INC4表示每个DMA请求进行4次DMA传输。

#define DMA_MBURST_SINGLE ((uint32_t)0x00000000U)& g+ [; @* S! v% _ q
#define DMA_MBURST_INC4 ((uint32_t)DMA_SxCR_MBURST_0)* t/ ]' f: |$ y/ W0 R# K
#define DMA_MBURST_INC8 ((uint32_t)DMA_SxCR_MBURST_1)8 Q5 w& g E1 ]8 o( j5 `( l
#define DMA_MBURST_INC16 ((uint32_t)DMA_SxCR_MBURST)

复制代码

成员PeriphBurst
外设突发配置，必须使能了FIFO才有效，否则设置此参数没有意义，BDMA不支持此参数，仅DMA1，DMA2支持。SINGLE表示每个DMA请求进行1次，INC4表示每个DMA请求进行4次DMA传输。

#define DMA_PBURST_SINGLE ((uint32_t)0x00000000U)1 B- x* a" s6 B" A, a% z
#define DMA_PBURST_INC4 ((uint32_t)DMA_SxCR_PBURST_0)# Q+ w" A0 X5 o
#define DMA_PBURST_INC8 ((uint32_t)DMA_SxCR_PBURST_1)5 r& y$ q- B l" z B: X1 G# |
#define DMA_PBURST_INC16 ((uint32_t)DMA_SxCR_PBURST)

复制代码

  HAL_LockTypeDef Lock

__IO HAL_DMA_StateTypeDef  State

这两个变量主要供函数内部使用。Lock用于设置锁状态，而State用于设置DMA状态。

void    (* XferCpltCallback)( struct __DMA_HandleTypeDef * hdma);

void    (* XferHalfCpltCallback)( struct __DMA_HandleTypeDef * hdma);

void    (* XferM1CpltCallback)( struct __DMA_HandleTypeDef * hdma);

void    (* XferM1HalfCpltCallback)( struct __DMA_HandleTypeDef * hdma);

void    (* XferErrorCallback)( struct __DMA_HandleTypeDef * hdma);

void    (* XferAbortCallback)( struct __DMA_HandleTypeDef * hdma);

这里是定义了六个回调函数指针，分别用于配置传输完成回调，半传输完成回调，Memory1传输完成回调，Memory1半传输完成回调，传输错误回调和传输终止回调。

42.3.3 DMA的状态标志清除问题
下面我们介绍__HAL_DMA_GET_FLAG函数。这个函数用来检查定时器标志位是否被设置。

/**
. ]$ t2 s" H4 R' H! W* V. S
* @brief Get the DMA Stream pending flags.8 r8 H/ ^ F a4 f* A H0 S7 u
* @param __HANDLE__: DMA handle
; d# E; p, S4 h: R
* @param __FLAG__: Get the specified flag.
3 `! ~; r9 l. n. Q7 i: g) _) w
* This parameter can be any combination of the following values:
$ u: R ?+ ]; ?, x9 p1 D6 j5 B# ]
* @arg DMA_FLAG_TCIFx: Transfer complete flag.7 R; R& m6 f2 Y; C+ M
* @arg DMA_FLAG_HTIFx: Half transfer complete flag., J! G! G m8 i: a! }* |! [1 N
* @arg DMA_FLAG_TEIFx: Transfer error flag.0 {/ K! l- v. {' `8 `
* @arg DMA_FLAG_DMEIFx: Direct mode error flag., m, l, Y) C4 U
* @arg DMA_FLAG_FEIFx: FIFO error flag.
* d0 v2 F( z+ X" B- R! _1 e
* Where x can be 0_4, 1_5, 2_6 or 3_7 to select the DMA Stream flag.4 Y; I: e; S9 R" G
* @retval The state of FLAG (SET or RESET).# e9 r! ?, V2 x& ~# @( z$ Z9 W- i
*/
+ x; e0 t6 ^3 J
#define __HAL_DMA_GET_FLAG(__HANDLE__, __FLAG__)\
: s9 Y- {1 p) h/ g* ?; o) \8 G5 L
(((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA2_Stream7)? (BDMA->ISR & (__FLAG__)) :\* U# s: c; F6 f$ ~# r
((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA2_Stream3)? (DMA2->HISR & (__FLAG__)) :\ d& m- ^& H8 P1 F' \3 M) m
((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA1_Stream7)? (DMA2->LISR & (__FLAG__)) :\# a% ~) i5 D+ e( \0 A
((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA1_Stream3)? (DMA1->HISR & (__FLAG__)) : (DMA1->LISR &
(__FLAG__)))
) G Y6 _7 f5 _8 u

复制代码

对于BDMA，主要是前三个中断标志。

  DMA_FLAG_TCIFx
传输完成标志。

  DMA_FLAG_HTIFx
半传输完成标志。

  DMA_FLAG_TEIFx
传输错误标志。

  DMA_FLAG_DMEIFx
直接模式错误标志。

  DMA_FLAG_FEIFx
FIFO错误标志。

DMA支持的标志参数如下：

/** @defgroup DMA_flag_definitions DMA flag definitions0 s$ F9 U+ x3 H* g( N4 k) V+ y
* @brief DMA flag definitions
! D0 f7 O8 [& s! h4 s& T
* @{2 \( j' Y; \1 O) j% D8 n+ H
*/* a! L! ? Q& B
#define DMA_FLAG_FEIF0_4 ((uint32_t)0x00800001U)
* g7 X% d1 M+ E" \0 O: V
#define DMA_FLAG_DMEIF0_4 ((uint32_t)0x00800004U)
5 U7 R5 ]3 O! {- ]( Z8 f3 M
#define DMA_FLAG_TEIF0_4 ((uint32_t)0x00000008U)
1 m; e1 e5 C/ G- p* C% A* G9 j
#define DMA_FLAG_HTIF0_4 ((uint32_t)0x00000010U)6 G' | O/ S4 p, y% K ]& r
#define DMA_FLAG_TCIF0_4 ((uint32_t)0x00000020U)
$ h2 o2 F. b! r
#define DMA_FLAG_FEIF1_5 ((uint32_t)0x00000040U)
8 x7 |5 A2 H# k- r5 I
#define DMA_FLAG_DMEIF1_5 ((uint32_t)0x00000100U)/ n( s0 o! T4 S* T# s5 z2 ?
#define DMA_FLAG_TEIF1_5 ((uint32_t)0x00000200U)
2 I6 _* Y9 [0 S9 r
#define DMA_FLAG_HTIF1_5 ((uint32_t)0x00000400U)
1 y3 [5 v! F0 r3 m8 X* M
#define DMA_FLAG_TCIF1_5 ((uint32_t)0x00000800U)
9 T: `4 d& C, [+ E; b8 B
#define DMA_FLAG_FEIF2_6 ((uint32_t)0x00010000U)* a1 y# Y0 W+ w2 S$ X. Y
#define DMA_FLAG_DMEIF2_6 ((uint32_t)0x00040000U)" j0 u2 `; r, U; C3 W. S' e
#define DMA_FLAG_TEIF2_6 ((uint32_t)0x00080000U)
4 x$ u6 h5 h0 f
#define DMA_FLAG_HTIF2_6 ((uint32_t)0x00100000U)
6 W" s- L0 ^9 P! @8 G
#define DMA_FLAG_TCIF2_6 ((uint32_t)0x00200000U)9 j: r) v- O8 _( A- f/ V8 i d
#define DMA_FLAG_FEIF3_7 ((uint32_t)0x00400000U)9 B) L9 C& m% n6 k0 X
#define DMA_FLAG_DMEIF3_7 ((uint32_t)0x01000000U)
* R* z! j, f7 g' a f% C; W5 A
#define DMA_FLAG_TEIF3_7 ((uint32_t)0x02000000U)& w! `. b& z( j9 c
#define DMA_FLAG_HTIF3_7 ((uint32_t)0x04000000U)4 u8 g0 u L6 U/ _
#define DMA_FLAG_TCIF3_7 ((uint32_t)0x08000000U)

复制代码

这里要注意以下几点：

  比如DMA_FLAG_FEIF0_4，表示DMA1或者DMA2的Stream0和Stream4的标志，而不是Stream0到Stream4，同理1和5就是Srteam1和Stream5。
  DMA1和DMA2的Stream0 到 Stream3标志是通过LISR寄存器查看（DMA1和DMA2的寄存器是相同的，只是位于不同的地址）。
Stream4 到 Stream7的标志是通过HISR寄存器查看。

  #define DMA_FLAG_FEIF0_4       ((uint32_t)0x00800001U)
#define DMA_FLAG_DMEIF0_4    ((uint32_t)0x00800004U)

置红的数字8是什么意义？看了参考手册，原来这个bit没有定义，实际上这bit在DMA的库代码中也没有被用到过。

与标志获取函数__HAL_TIM_GET_FLAG对应的清除函数是__HAL_LPTIM_CLEAR_FLAG：

/** P. ^) J* m6 k% K9 M/ k: V
* @brief Clear the DMA Stream pending flags.
5 K! a( a' i$ N+ v* x3 Y
* @param __HANDLE__: DMA handle5 |3 R* O( Y5 x. c* S0 \# B# |3 V. k
* @param __FLAG__: specifies the flag to clear.
5 V" Q m+ D* A3 D3 |( e
* This parameter can be any combination of the following values:+ L p: d# Y4 Y
* @arg DMA_FLAG_TCIFx: Transfer complete flag.! b8 C; W: ^$ ?, j1 n0 g' b
* @arg DMA_FLAG_HTIFx: Half transfer complete flag.6 S( V3 W- {6 \
* @arg DMA_FLAG_TEIFx: Transfer error flag.
* L( H- v8 X, T
* @arg DMA_FLAG_DMEIFx: Direct mode error flag.$ v9 n u- C2 ?' N/ }
* @arg DMA_FLAG_FEIFx: FIFO error flag.
* `. u9 ]6 a( H8 Y0 i& H
* Where x can be 0_4, 1_5, 2_6 or 3_7 to select the DMA Stream flag.% r+ d+ m6 ?$ C/ P, D8 l1 t! r* l
* @retval None
. I, j5 S; s/ L
*/
' S B3 H3 z/ x" ^+ N& X
#define __HAL_DMA_CLEAR_FLAG(__HANDLE__, __FLAG__) \: N+ m) |5 v! O# m( q
(((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA2_Stream7)? (BDMA->IFCR = (__FLAG__)) :\
" R) e8 V& w: n- ^
((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA2_Stream3)? (DMA2->HIFCR = (__FLAG__)) :\
6 z) ~: \4 B* p5 z" c8 }
((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA1_Stream7)? (DMA2->LIFCR = (__FLAG__)) :\
/ M8 O3 h) o# |3 {( }8 s; Z5 b' O0 L
((uint32_t)((__HANDLE__)->Instance) > (uint32_t)DMA1_Stream3)? (DMA1->HIFCR = (__FLAG__)) : (DMA1->LIFCR = (__FLAG__)))

复制代码

清除标志函数所支持的参数跟获取函数是一一对应的。除了这两个函数，还有DMA的中断开启和中断关闭函数，有时候也要用到。

- o6 I* B P* s9 D
/**
. ]$ x/ ^" D: n8 [
* @brief Enable the specified DMA Stream interrupts.) M' {9 I7 Z8 V& [
* @param __HANDLE__: DMA handle7 L6 R' e H& ]
* @param __INTERRUPT__: specifies the DMA interrupt sources to be enabled or disabled.
7 @9 w$ f( [! x; Z3 K) d
* This parameter can be one of the following values:0 `9 o I: Z. y% C
* @arg DMA_IT_TC: Transfer complete interrupt mask.
4 [* l4 X4 Q8 u* o+ L6 H; y# ?' u
* @arg DMA_IT_HT: Half transfer complete interrupt mask. o" o1 `) R# ?: Z
* @arg DMA_IT_TE: Transfer error interrupt mask.. C2 C" c2 c: C
* @arg DMA_IT_FE: FIFO error interrupt mask." B5 Q# ^% r$ G& t5 \4 H3 m
* @arg DMA_IT_DME: Direct mode error interrupt.
% d: S# ~) S- o$ T# Z' ] ~
* @retval None
. C% C @3 ~6 W1 g! Q! K
*/
4 Z: w7 \( p+ N8 M W8 z2 [: ~0 x7 k
#define __HAL_DMA_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((IS_D2_DMA_INSTANCE(__HANDLE__))?\( `8 D- R& j* T) j
(__HAL_DMA_D2_ENABLE_IT((__HANDLE__), (__INTERRUPT__))) :\
2 u# [+ x' K& C) Q
(__HAL_DMA_D3_ENABLE_IT((__HANDLE__), (__INTERRUPT__))))
% B" S) [; z: Z* v
! l6 V5 H9 j9 Y# }8 s
/**
) S( i1 P8 X/ \ S& Y
* @brief Disable the specified DMA Stream interrupts.
' J. v; S% S5 ]- p6 `+ \& K# R
* @param __HANDLE__: DMA handle" j- B: N+ i w* V
* @param __INTERRUPT__: specifies the DMA interrupt sources to be enabled or disabled.
# p( Z: W. f6 Q* i
* This parameter can be one of the following values:1 l# \9 m1 h$ }# I' }4 C& Y
* @arg DMA_IT_TC: Transfer complete interrupt mask.
g. m6 }& o6 O/ a% U2 M
* @arg DMA_IT_HT: Half transfer complete interrupt mask.
; o2 a' j- c5 x
* @arg DMA_IT_TE: Transfer error interrupt mask.' b- D$ `" ]+ }7 E" U- z" k
* @arg DMA_IT_FE: FIFO error interrupt mask.
% b" k% E) c( {! Z) K
* @arg DMA_IT_DME: Direct mode error interrupt. w* ?9 q1 I& ]
* @retval None
4 _: F9 ~( b1 h
*/
5 u/ \( I$ q+ b
#define __HAL_DMA_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((IS_D2_DMA_INSTANCE(__HANDLE__))?\7 D0 h2 I# P) k F0 }' R( k
(__HAL_DMA_D2_DISABLE_IT((__HANDLE__), (__INTERRUPT__))) :\
7 ?/ a0 h3 }7 {0 d" y; z8 W1 _: \ y
(__HAL_DMA_D3_DISABLE_IT((__HANDLE__), (__INTERRUPT__))))

复制代码

注意：操作DMA的寄存器不限制必须要用HAL库提供的API，比如要操作DMA1的寄存器LISR，直接调用DMA1->LISR操作即可。

42.3.4 DMA初始化流程总结
使用方法由HAL库提供：

  第1步：通过函数HAL_DMA_Init配置各项参数。
  第2步：DMA查询方式。

  配置了源地址、目的地址和数据长度后，调用函数HAL_DMA_Start()启动传输。
  使用函数HAL_DMA_PollForTransfer()查询当前传输是否结束，用户还可以给此函数配置超时等待时间。

  第3步：DMA中断方式。

  使用函数HAL_NVIC_SetPriority配置DMA优先级。
  使用函数HAL_NVIC_EnableIRQ使能DMA中断。
  配置了源地址、目的地址和数据长度后，调用函数HAL_DMA_Start_IT()可以启动传输（注，此函数会使能BDMA中断）。
  将函数HAL_DMA_IRQHandler()填到中断服务程序DMAx_Streamx_IRQHandler里面。
  传输结束后会调用函数HAL_DMA_IRQHandler()，此函数里面会执行回调函数，即用户需要为XferCpltCallback，XferErrorCallback等函数配置实体（如果用到的话）
  第4步：使用函数 HAL_DMA_GetState()可以获得DMA状态，函数HAL_DMA_GetError()获取获取错误类型。
  第5步：使用函数HAL_DMA_Abort()可以终止DMA传输。
  存储器到存储器方式，不支持循环模式。
  DMA FIFO的作用是降低对总线的需求和源地址，目的地址不同数据宽度的传输。
  当FIFO禁止后，不允许配置源数据和目的数据宽度不同，此时将统一使用外设数据宽度。
  第6步：下面是几个常用的DMA宏定义。

  __HAL_DMA_ENABLE:  使能指定的DMA Stream
  __HAL_DMA_DISABLE: 禁止指定的DMA Stream
  __HAL_DMA_GET_FS:  返回当前DMA Stream FIFO填充情况
  __HAL_DMA_ENABLE_IT: 使能指定的DMA Stream中断
  __HAL_DMA_DISABLE_IT: 禁止指定的DMA Stream中断
  __HAL_DMA_GET_IT_SOURCE: 检查指定的DMA Stream中断是否使能
42.4 源文件stm32h7xx_hal_dma.c
此文件涉及到的函数比较多，这里把我们几个常用的函数做个说明：
  HAL_DMA_Init
  HAL_DMA_Start
  HAL_DMA_Start_IT
  HAL_DMAEx_MultiBufferStart
  HAL_DMAEx_MultiBufferStart_IT

42.4.1 函数HAL_DMA_Init
函数原型：

HAL_StatusTypeDef HAL_DMA_Init(DMA_HandleTypeDef *hdma)
" o, O3 I L8 S2 r0 t9 c
{3 }$ ~- ]% c# } j
uint32_t registerValue = 0U;! K) b" F4 W5 Y3 H" k
uint32_t tickstart = HAL_GetTick();( f; \6 R" R- p4 c7 g3 n/ m
DMA_Base_Registers *regs = NULL;. H" F- W. |' U2 v
' z7 H$ W& M9 M
/* 省略 */$ G! P$ E& n" o" n# v! V5 G n- v
2 A5 r7 B& I! E
/* DMA1或者DMA2的初始化 */
. U5 r( F5 l& {# o+ K9 A: {) Y5 V
if(IS_D2_DMA_INSTANCE(hdma) != RESET) ; u% A8 j; [. v- J4 D. c
{7 C4 P7 b9 b; b; a' M* P: `
/* 省略 */4 d! g6 n* ]/ H) n E) y5 X1 N
}" ]8 J3 v% h& r+ |% W! h9 c5 Y
7 J7 J$ ~" e( ^$ L% }- ~
/* BDMA的初始 */" Z, H& E8 L- g. z% ^7 H+ ]
else if(IS_D3_DMA_INSTANCE(hdma) != RESET) /*<BDMA channel , D3 domain*/
3 j. L! f" b# ]5 v R+ Z: r
{& A, h' P9 v% L4 n- [
/* 省略 */
: N$ X1 ]1 c M4 N/ b
}
( G/ [! _1 M& E( \& z9 O
else
; |5 @# C. ?* s# x8 r
{7 x5 X! L3 E |& I
hdma->ErrorCode = HAL_DMA_ERROR_PARAM;3 [6 }! @$ v+ `# N3 H, V! D
hdma->State = HAL_DMA_STATE_ERROR;
3 J' r9 a8 p, Q
+ {7 ~! a# o! `
return HAL_ERROR;/ e0 H8 ^: v2 u8 c3 D4 [
}
6 A+ W6 b! c7 g
0 s- U8 K9 ^# X; O" ^
/* 初始化DMAMUX */. C+ w( R; ^7 y4 ?
DMA_CalcDMAMUXChannelBaseAndMask(hdma);
$ t3 o( Z* [& p; h" n+ M+ M
7 G! e, N" d( _7 u: i
if(hdma->Init.Direction == DMA_MEMORY_TO_MEMORY)9 l! |& Z. D% G _2 X* d
{
/ X6 o' M+ A% f! W" E& `2 _
/* 如果是内存到内存模式，强制使用请求DMA_REQUEST_MEM2MEM */
# |0 d& h$ M5 w6 s1 B, ^
hdma->Init.Request = DMA_REQUEST_MEM2MEM;
& K% Z3 a' P1 j1 E6 g' I, }
}
3 h% e* b, h3 n
5 ]- J. p. g9 e0 y% C8 G. J
& k! I( H% p+ d; \/ n- K$ y+ u7 o
/* 设置外设请求 */; h5 t4 p# Z8 h1 Y, R0 f' ^; V
hdma->DMAmuxChannel->CCR = (hdma->Init.Request & DMAMUX_CxCR_DMAREQ_ID);1 w4 f9 \2 {4 p7 p* T3 t% U0 ~# y
3 M3 ^3 U5 l7 O1 v0 B
/* 清除DMAMUX同步溢出标志 */- G! m# [7 A3 A- x$ B9 r: m# h9 p
hdma->DMAmuxChannelStatus->CFR = hdma->DMAmuxChannelStatusMask;6 |+ q% d: d3 l9 A& n+ G- ~# |
0 X( E' n: B% R- \- w) l9 Z
/* 如果请求类型是DMA_REQUEST_GENERATOR0 到 DMA_REQUEST_GENERATOR7，那么设置请求发生器 */
% K( r' U. T( P
if((hdma->Init.Request >= DMA_REQUEST_GENERATOR0) && (hdma->Init.Request <= DMA_REQUEST_GENERATOR7)), ^' {$ k+ U" \6 \6 l! b U
{
+ z/ C5 `( Q& R* L' h9 m2 P
/* 省略 */
' B7 s) i. m7 D6 C
}! X) n+ j1 p- `% D. V$ \+ n
else
# X6 j2 f, `% C% B
{0 }+ E5 d$ h; M* C# X, z
hdma->DMAmuxRequestGen = 0U;
& C' q- g% j* P# I
hdma->DMAmuxRequestGenStatus = 0U;
* _; G2 l* C2 Y! c, o: z K
hdma->DMAmuxRequestGenStatusMask = 0U;9 R: x( u) I0 i/ q
}7 l2 e; ?& B8 q
6 T$ {" {9 ^8 V: Y# ^3 Z& }4 `
/* 无错误 */
( |: i6 o; T5 M$ v W
hdma->ErrorCode = HAL_DMA_ERROR_NONE;- h4 h8 a8 b i* u
( S# V5 T+ J( x" b
/* 设置DMA就绪 */
6 a# `8 M9 ]5 }) Y
hdma->State = HAL_DMA_STATE_READY;- @& k2 B: a& v h
* V7 B" s" p' D& n
return HAL_OK;
) Y* @1 _2 Q& ?% }
}

复制代码

函数描述：

此函数用于初始化DMA1，DMA2和BDMA。

函数参数：

第1个参数是DMA_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。结构体变量成员的详细介绍看本章3.2小节。
返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

第1个参数的结构体成员介绍在本章的3.2小节进行了详细说明。
使用举例：

; q3 M6 K- [: T. f$ }* l- x5 K
DMA_HandleTypeDef DMA_Handle = {0};0 @; i2 D" o9 g2 X) V& L9 K/ x
4 B6 D4 Q- W4 Y) A8 b% h. K. [ k
DMA_Handle.Instance = BDMA_Channel0; /* 使用的BDMA通道0 */
, @6 _- u1 O, z/ Q7 Q
DMA_Handle.Init.Request = BDMA_REQUEST_GENERATOR0; /* 请求类型采用的DMAMUX请求发生器通道0 */
/ j% A- |& c X7 P* C+ l
DMA_Handle.Init.Direction = DMA_MEMORY_TO_PERIPH; /* 传输方向是从存储器到外设 */ 9 k# U, \* O! Z4 q% t
DMA_Handle.Init.PeriphInc = DMA_PINC_DISABLE; /* 外设地址自增禁止 */ + O7 L! P" V1 F7 t4 A* J( M; N
DMA_Handle.Init.MemInc = DMA_MINC_ENABLE; /* 存储器地址自增使能 */ , `6 P/ g2 R* u0 l. _
DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* 外设数据传输位宽选择字，即32bit */ 7 Z) A' f+ G' z8 w
DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; /* 存储器数据传输位宽选择字，即32bit */
! A% `( P$ Z/ o% c' T9 K
DMA_Handle.Init.Mode = DMA_CIRCULAR; /* 循环模式 */ & c( _ p/ z. y8 g
DMA_Handle.Init.Priority = DMA_PRIORITY_LOW; /* 优先级低 */ $ j9 M6 b- D+ W
DMA_Handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; /* BDMA不支持FIFO */
* [6 ]2 K# u$ ~( z' Z7 g6 u5 `
DMA_Handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; /* BDMA不支持FIFO阀值设置 */ 0 A4 u; C' a! G. }1 ?& O: X
DMA_Handle.Init.MemBurst = DMA_MBURST_SINGLE; /* BDMA不支持存储器突发 */
: m1 T8 p& ~* S* a z9 ?9 v4 I7 [
DMA_Handle.Init.PeriphBurst = DMA_PBURST_SINGLE; /* BDMA不支持外设突发 */ * ^+ x2 h! A6 X0 I
! R1 c# D7 z. |, P1 J" k
HAL_DMA_Init(&DMA_Handle);

复制代码

42.4.2 函数HAL_DMA_Start
函数原型：

HAL_StatusTypeDef HAL_DMA_Start(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
1 [) W8 k5 ~7 u
{
8 a* v, p+ c1 |- V. j8 y
HAL_StatusTypeDef status = HAL_OK;
+ W2 n; I0 G) R6 X( i5 m+ I
( X U( O* |! F6 z: A: `& ]
/* 检测参数 */
3 k5 m2 T' a# a
assert_param(IS_DMA_BUFFER_SIZE(DataLength));; C, G4 r# g3 K H
+ w! n% C& H6 ?
/* 检测句柄 */
- |) Q) A5 L6 E4 y, {1 Y
if(hdma == NULL)
3 s5 ~( d0 s9 ], e8 M( L' o
{# z! G6 n( w S' n
return HAL_ERROR;
, f% Y" p) U0 Q) ]$ G& h+ K: J
}3 u0 g* D! z4 O5 s( q/ D. @
5 e# S: a! P1 [$ j$ b& r/ J
/* 上锁 */
1 \' A* y' i, o/ B6 u9 r& |7 c
__HAL_LOCK(hdma);
4 P. N* }. c' u8 C4 W, {) f& {- L
5 E! o2 j/ d o# C; r8 g
if(HAL_DMA_STATE_READY == hdma->State)# p" e: J0 X: g5 X' f/ r! t
{% u! `+ o! _, O; }" R$ t+ S2 _4 i( j
/* 设置DMA状态 */
+ H/ B. v. x% M0 V0 k
hdma->State = HAL_DMA_STATE_BUSY;6 B( Z$ v4 ~& o! }2 T @ L$ P
}& D( E; a! B; k1 s* _
/* 无错误 */7 l s2 s# n2 T& b+ c4 V2 x
hdma->ErrorCode = HAL_DMA_ERROR_NONE;
7 d1 R: T. j4 T5 W3 ?0 k- `5 O
H$ w) Y$ ]: n" b
/* 禁止DMA */" ]1 a8 c/ ] `$ x' d* N
__HAL_DMA_DISABLE(hdma);
3 R/ s: I) C4 e
$ W+ K+ K M& z" U
/* 配置源地址，目的地址和数据长度 */
5 \! j! ]& T8 |
DMA_SetConfig(hdma, SrcAddress, DstAddress, DataLength);
" ^. I- I/ U5 m# {6 u6 T& q
# N- h6 S: i* H! r" c! M0 }
/* 使能DMA */: P$ B/ V4 M6 N$ r" f0 X
__HAL_DMA_ENABLE(hdma);0 D' g4 P5 c) B. G; x0 Q3 J
}% U# K0 d |* j; F, w/ g
else
$ m% @# [3 m$ X7 v7 Y
{5 L- L: s2 w5 M( t2 e; ^. U; P9 G
/* 解锁 */
" ^1 B, a7 N+ C+ s$ m% [, s
__HAL_UNLOCK(hdma);+ [, h0 t( K8 K; @
8 j- ?& `! I- ~7 [4 g3 w9 e- j% j6 w
/* 设置忙 */; E9 [( l- k8 ]" Q4 W4 N/ K! w1 ~
hdma->ErrorCode = HAL_DMA_ERROR_BUSY;
: w r( ^: M3 d8 G+ |# b1 o& W; e0 {
& A# L. G3 n7 D3 o
/* 返回HAL_ERROR */
0 h1 ~; V+ p. G+ s0 Q& ~- b% i# B
status = HAL_ERROR;+ e; s& n, M/ ~( g( e# M r Y5 T. Y
}! J. G4 q& Q0 l2 q8 e/ {, Q9 u
return status;
8 H/ a; @/ i( s) [* P0 y9 Y
}

复制代码

函数描述：

调用函数HAL_DMA_Init配置了基础功能后，就可以调用此函数启动DMA了。DMA1，DMA2和BDMA都是用的这个函数。

函数参数：

  第1个参数是DMA_HandleTypeDef类型结构体指针变量。
  第2个参数是DMA传输的源地址。
  第3个参数是DMA传输的目的地址。
  第4个参数是传输的数据长度。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

第1个参数的结构体成员介绍在本章的3.2小节进行了详细说明。
使用举例：

/*/ g+ r. g9 O$ C3 g$ Z' y/ ^1 ?
*********************************************************************************************************
+ V2 ^- B) b, Q
* 函数名: bsp_InitTimBDMA* v8 O8 _$ E9 j5 U; l
* 功能说明: 配置DMAMUX的定时器触+DMA控制任意IO做PWM和脉冲数控制! T: F6 x4 x2 V( N, N# d
* 形参: 无: o! i: P" r1 f4 J" Z' n* u6 \8 G
* 返回值: 无, n) \- {/ [" C3 S
*********************************************************************************************************8 p7 u* L! Z) g U) v
*/
7 @# n$ Y# Y8 S/ u# m
void bsp_InitTimBDMA(void)
" o- [; t" [+ Z
{
3 ]- `# G/ [; Z# _3 K- P
GPIO_InitTypeDef GPIO_InitStruct;
' V" ]4 `/ E# F8 u- W( `& w. p
DMA_HandleTypeDef DMA_Handle = {0};. Z+ G) h. T0 w
HAL_DMA_MuxRequestGeneratorConfigTypeDef dmamux_ReqGenParams ={0};; Y1 G& l: A* N; G y( F( t
- o6 G) a i2 ~; X
5 H4 y' z& I; e) Z+ [) K
/*##-1- 配置PB1用于PWM输出######################################*/ $ J" E8 u7 X( I8 g
__HAL_RCC_GPIOB_CLK_ENABLE();% Y- p5 `8 {2 |& d. C+ S
( p: F* f/ m6 g: @2 ]: W# ~
GPIO_InitStruct.Pin = GPIO_PIN_1;3 f& X9 y2 ] Z( ]7 b+ Z5 }
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;) b1 L, [- R2 `
GPIO_InitStruct.Pull = GPIO_NOPULL;
( h) p' ]# S3 [0 P+ c
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
# j. `" m0 Z4 r
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);- `: h9 ~, P( H2 o2 |. C8 f8 [: m
" J' m$ A7 q3 _" F
; J1 U" }7 a! R: V
/*##-2- 配置DMA ##################################################*/) G9 f6 w# m9 b0 i) k0 o. ], k9 K; f3 I
__HAL_RCC_BDMA_CLK_ENABLE();
3 y* j$ c; J5 }( u* J
2 h) F, U* ]: b M; u$ z X: g: i
DMA_Handle.Instance = BDMA_Channel0; /* 使用的BDMA通道0 */7 }3 {; l/ t( I6 @
DMA_Handle.Init.Request = BDMA_REQUEST_GENERATOR0; /* 请求类型采用的DMAMUX请求发生器通道0 */ ! w k" s% e: `
DMA_Handle.Init.Direction = DMA_MEMORY_TO_PERIPH; /* 传输方向是从存储器到外设 */
- I I3 R8 r0 h" @7 a+ x
DMA_Handle.Init.PeriphInc = DMA_PINC_DISABLE; /* 外设地址自增禁止 */
0 S3 d$ C9 _3 a! I
DMA_Handle.Init.MemInc = DMA_MINC_ENABLE; /* 存储器地址自增使能 */
. d/ h* |, l4 }" l1 y
DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* 外设数据传输位宽选择字，即32bit */ + ] b" d9 S% \' v
DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; /* 存储器数据传输位宽选择字，即32bit */ ) R& Q C8 x0 w4 G; I7 t
DMA_Handle.Init.Mode = DMA_CIRCULAR; /* 循环模式 */
' K) u1 }' i$ D, i3 t: f2 M
DMA_Handle.Init.Priority = DMA_PRIORITY_LOW; /* 优先级低 */ ) m6 }2 x1 b8 _% f! @. E
DMA_Handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; /* BDMA不支持FIFO */
+ W3 u5 r; d) ?! K0 C' u; ]: R
DMA_Handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; /* BDMA不支持FIFO阀值设置 */ & r" E; {" O$ W: q1 c- z' E
DMA_Handle.Init.MemBurst = DMA_MBURST_SINGLE; /* BDMA不支持存储器突发 */
" y" K @4 \0 ^1 \
DMA_Handle.Init.PeriphBurst = DMA_PBURST_SINGLE; /* BDMA不支持外设突发 */ ' }; T$ T3 V9 ]/ \4 }& B
- f% I4 g, v. W( @9 b0 v0 S' S
HAL_DMA_Init(&DMA_Handle);( l7 f4 E( `! E& {; Q* Y
L5 p& ^3 r; p% R8 e5 c: I
/* 开启BDMA Channel0的中断 */4 \- ^ e8 G8 ?5 e S
HAL_NVIC_SetPriority(BDMA_Channel0_IRQn, 2, 0);* [* s6 _% Z* t; S a1 s' l f/ t
HAL_NVIC_EnableIRQ(BDMA_Channel0_IRQn); " C) v& Q+ R+ R% u5 E4 v
+ ~# A1 V2 C& }" y
/*##-3- 配置DMAMUX #########################################################*/
! i; h0 I7 N' {8 C, J
dmamux_ReqGenParams.SignalID = HAL_DMAMUX2_REQ_GEN_LPTIM2_OUT; /* 请求触发器选择LPTIM2_OUT */" Y) @( m, M; y* N$ I- O: P6 z
dmamux_ReqGenParams.Polarity = HAL_DMAMUX_REQ_GEN_RISING_FALLING; /* LPTIM2输出的上升沿和下降沿均可触5 ]9 t3 V' R, m& j/ q
发 */
4 B/ @ J0 F' U, A
dmamux_ReqGenParams.RequestNumber = 1; /* 触发后，传输进行1次DMA传输 */
; R7 G# A/ s! N2 P
HAL_DMAEx_ConfigMuxRequestGenerator(&DMA_Handle, &dmamux_ReqGenParams); /* 配置DMAMUX */) p9 n: i/ \' E3 C7 S6 ^
HAL_DMAEx_EnableMuxRequestGenerator (&DMA_Handle); /* 使能DMAMUX请求发生器 */
1 m7 Q# m) F, R( j! G
5 n& N6 _" H3 p# m) h
/*##-4- 启动DMA传输 ################################################*/
" r) S" p# |# ^7 B% Q
HAL_DMA_Start(&DMA_Handle, (uint32_t)IO_Toggle, (uint32_t)&GPIOB->BSRRL, 8);
: ~2 K' Z. a; G, i& R, Q
}
5 S9 E) b. O4 f
2 t9 }" h" s& }2 G: H

复制代码

42.4.3 函数HAL_DMA_Start_IT
函数原型：

HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
$ g* ^9 h- V: A8 c* ~4 u
{
" C8 X' q3 j, _; j0 |1 g7 j# K
HAL_StatusTypeDef status = HAL_OK;( k X% s% n; {7 t" v0 v8 u+ Y
# z) e8 K. F# o! H
/* 检测参数 */1 f' }1 `0 Z+ o) L7 z& {
assert_param(IS_DMA_BUFFER_SIZE(DataLength));
0 p5 C$ J, Q; I% \3 @, d
- \( m0 o; o, x6 @
/* 检测句柄 */! w4 c q1 v7 [8 C
if(hdma == NULL)% K4 A# @6 L5 Q# Z
{
& {% F. o V: X; m) `, Q: K4 |
return HAL_ERROR;: k, h2 ~, Y7 q3 M5 `
}
& d6 w/ [0 N5 j, u, Q/ {' P
' m3 P- F' z9 L& d3 f E' }
/* 上锁 */
# e" ~0 p( K+ r
__HAL_LOCK(hdma);
9 |/ |$ Q" [4 a6 ~$ [
7 m5 ^, U; h4 i+ N6 `
if(HAL_DMA_STATE_READY == hdma->State)
2 l3 }" r2 w p/ C7 a/ B8 `
{
' X& }% J; z, P/ p2 _
/* 设置DMA忙 */% |6 V2 j" J+ N) ~7 K0 w
hdma->State = HAL_DMA_STATE_BUSY;0 d0 ?1 j! @7 J( O, x. d
5 A! [( ?- v/ B0 V; w* c) `
/* 设置无错误 */- V& P! e: D5 e+ C
hdma->ErrorCode = HAL_DMA_ERROR_NONE;& ?, u1 n0 K0 `4 U0 K
k7 j' ?/ F2 f
/* 禁止DMA */% I0 W3 A' ~) H
__HAL_DMA_DISABLE(hdma);
* `$ i2 W. a" n2 `
! \& u: l8 P) x/ |+ s! ?
/* 配置DMA源地址，目的地址和数据长度 */2 k! K X l& O* ?+ T% o5 ^8 [4 G
DMA_SetConfig(hdma, SrcAddress, DstAddress, DataLength);
3 \8 m* z+ s" E9 M
l9 I: L5 T2 V- Q6 a
/* DMA1和DMA2配置 */* i$ q8 G1 m" Q; z" @2 p3 _9 s9 R
if(IS_D2_DMA_INSTANCE(hdma) != RESET)
$ }; q: ]- @4 D( Y" |
{% ]* m; ^$ u3 @3 R% q' |. x4 H& h
/* 使能TC，TE和DME中断 */
% j! ~* `3 x+ x% N$ j* c8 g& d
MODIFY_REG(((DMA_Stream_TypeDef *)hdma->Instance)->CR, (DMA_IT_TC | DMA_IT_TE | DMA_IT_DME |) a' V' n% _- I' z4 z! {; W
DMA_IT_HT), (DMA_IT_TC | DMA_IT_TE | DMA_IT_DME));. O* l6 Y1 o/ w5 ~
((DMA_Stream_TypeDef *)hdma->Instance)->FCR |= DMA_IT_FE;, ?9 i* {( p7 g& c
7 a; c7 s, I9 f! f z" p- h) j
if(hdma->XferHalfCpltCallback != NULL)1 F" W( j3 E6 `5 m* B# C* L" y
{
* o3 W7 u+ ]3 J2 _. i# l( e4 [
/* 如何设置了半传输回调函数，同时开启半传输中断 */
: m3 M# b8 l9 H. c: k
((DMA_Stream_TypeDef *)hdma->Instance)->CR |= DMA_IT_HT;( x. Q' U$ }$ l8 G' e
}
7 d* x4 Y( Y2 Z+ C
}% J+ _4 f) j+ _, o# A5 P
else /* BDMA配置 */
3 S# X" Q! q! `+ U+ l# _
{
( o5 X0 p: |5 p" i. i1 V7 w
/* 使能TC和TC中断 */
5 j2 o% c1 i }9 c
MODIFY_REG(((BDMA_Channel_TypeDef *)hdma->Instance)->CCR, (BDMA_CCR_TCIE | BDMA_CCR_HTIE | - i/ `/ G- r% O$ J( z
BDMA_CCR_TEIE), (BDMA_CCR_TCIE | BDMA_CCR_TEIE));6 e/ s# k1 f- ]5 ~
, {# H/ X$ E, \: ? m
if(hdma->XferHalfCpltCallback != NULL)$ h! [. N8 A, l$ D1 r: j0 y4 ^
{
$ V! z* k$ c* B+ U( C" L
/* 如何设置了半传输回调函数，同时开启半传输中断 */
# ~0 m1 R/ W( O% W- T `
((BDMA_Channel_TypeDef *)hdma->Instance)->CCR |= BDMA_CCR_HTIE;
9 s& e$ g+ A2 ~, ?9 o5 z
}- Q6 K3 ?- d* I+ u' y# q
}* |+ \2 ^, }. S3 U0 U8 i
! t" ^8 ]8 |2 V3 ?, ?+ |! n/ o, R* a
/* 检测是否使能DMAMUX同步传输 */ ?4 ?4 | L d
if((hdma->DMAmuxChannel->CCR & DMAMUX_CxCR_SE) != 0U)) G0 M( o+ l8 A$ W$ ]+ v4 H
{ I4 }& n9 V; E* g! ?7 e" z, S
/* 使能了的话，开启同步溢出中断 */
; Q. ~+ g" i G+ l/ H0 _2 v6 C
hdma->DMAmuxChannel->CCR |= DMAMUX_CxCR_SOIE;/ Y3 D9 G$ T e9 R
}* N* {% {+ y4 O+ z7 D5 D
2 b' v$ J3 L7 ]
if(hdma->DMAmuxRequestGen != 0U)$ N+ F: q* E- S7 J4 k' b5 Y, }) F
{
2 ?4 z/ ]' x' N/ G
/* 如果使用了DMAMUX请求发生器，使能请求发生器溢出中断 */
, z/ ~+ l6 B0 q% G
hdma->DMAmuxRequestGen->RGCR |= DMAMUX_RGxCR_OIE;
: n' t8 N: w+ o; _" j+ P0 g4 E8 y
7 ^4 P( N% u& R, K7 L
}3 R1 g9 l5 ^8 v: X
, h$ a2 `- q5 ?& E; o) e( Y" G
/* 使能DMA */8 \, d& F. I9 K% ?
__HAL_DMA_ENABLE(hdma);
: O1 {" Z( l& }1 A
}( F3 {; m1 t/ ?0 h4 x9 P$ O
else
, J" C' Z# @. C& Q3 Q
{
K2 A1 J- r+ q+ a% x
/* 解锁 */
5 L2 r# p' ]) {: ]! c$ ?% C
__HAL_UNLOCK(hdma);$ v4 v, r% ?4 x9 m% P" S' l
+ N% B7 ^- r; J. c- L
/* 设置DMA忙 */
( ~' p5 d" I, j k
hdma->ErrorCode = HAL_DMA_ERROR_BUSY;1 O X2 \! a9 M& @4 C4 G& b
3 y `- b) M8 U/ r
/* 返回HAL_ERROR */
% o5 V0 S Q1 F8 r
status = HAL_ERROR;% j# [+ F- y& j5 w% u3 g6 d
}
! c% r& |4 O; ?! j: g3 Q' c, `$ z7 z
: ?& L! I( F/ B! k5 k
return status;
: C f) D& ?6 a
}

复制代码

* m$ S8 y, p' |: G) d5 q3 G* I. m
/*5 Q. n% H/ P4 v F* Q, V
*********************************************************************************************************
7 U- P5 K- Y& M h; v7 r( z# H8 A9 U
* 函数名: bsp_InitTimBDMA
; v% m0 `: p! h: l/ I% g
* 功能说明: 配置DMAMUX的定时器触+DMA控制任意IO做PWM和脉冲数控制
: x3 x. o; T6 K5 n( |
* 形参: 无
/ d% ]9 {/ [7 o* @3 @7 Q
* 返回值: 无
l0 V# ~# ]+ O5 F( \/ A1 l
*********************************************************************************************************; i5 g* k; ^) O* m( [
*/4 i! P4 b$ _! s8 z9 `. J
void bsp_InitTimBDMA(void)
* s6 T w4 w' }4 m
{
: X/ B' I. d# U
GPIO_InitTypeDef GPIO_InitStruct;
" W' c' C0 Y, {7 K2 `0 Q
DMA_HandleTypeDef DMA_Handle = {0};& ~5 [* V) H( k; L7 D. ^
HAL_DMA_MuxRequestGeneratorConfigTypeDef dmamux_ReqGenParams ={0};
$ w" [' b9 I5 v# `- d L/ c
$ e& U% j4 \$ o
1 M( ?6 I: ^6 A( F, W/ g2 ~6 I& I
/*##-1- 配置PB1用于PWM输出######################################*/ + V8 Y0 l& _' \3 T7 l
__HAL_RCC_GPIOB_CLK_ENABLE();
6 Y- h, ?- n8 E
9 O9 Z( C$ u% @% \
GPIO_InitStruct.Pin = GPIO_PIN_1;- M$ p/ U+ t; u9 z$ U1 H) W
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
0 m- ~! v7 E: b c
GPIO_InitStruct.Pull = GPIO_NOPULL;
2 J1 o, H8 _$ M7 L% I' R( R
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;" n0 T9 c0 Q* l9 i. r
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+ K% P9 o; t9 i% z
7 k7 k& p/ c. T: k6 x+ h r
9 w: @0 M. a f8 f9 ]. g2 J
/*##-2- 配置DMA ##################################################*/
: g4 Y( ]* x. W6 G( j8 }
__HAL_RCC_BDMA_CLK_ENABLE();* Z# o; r$ A% u+ j/ R; J$ O4 x
/ x2 p+ }9 `1 o/ o- ]
DMA_Handle.Instance = BDMA_Channel0; /* 使用的BDMA通道0 */
4 F5 ]% b0 T: P; U" Z
DMA_Handle.Init.Request = BDMA_REQUEST_GENERATOR0; /* 请求类型采用的DMAMUX请求发生器通道0 */
, v: q8 z; X6 |- c: g8 A6 U- g
DMA_Handle.Init.Direction = DMA_MEMORY_TO_PERIPH; /* 传输方向是从存储器到外设 */ 5 d' q. J, E: `! K+ P }
DMA_Handle.Init.PeriphInc = DMA_PINC_DISABLE; /* 外设地址自增禁止 */
" \! q1 M7 y; J3 N2 x
DMA_Handle.Init.MemInc = DMA_MINC_ENABLE; /* 存储器地址自增使能 */ 1 s4 `9 w8 N7 \ y' ?$ L' o
DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* 外设数据传输位宽选择字，即32bit */ 8 n; {' C7 G4 o2 R- e9 e: i% [
DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; /* 存储器数据传输位宽选择字，即32bit */
" o8 _1 L5 C; J+ }" |8 K; A
DMA_Handle.Init.Mode = DMA_CIRCULAR; /* 循环模式 */
8 G8 ^( m0 M" V6 O/ O; m2 v" a
DMA_Handle.Init.Priority = DMA_PRIORITY_LOW; /* 优先级低 */ 5 o3 |- W0 M3 l# _7 F, ` w
DMA_Handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; /* BDMA不支持FIFO */ 4 w4 Q, l8 R" N4 D: {8 D
DMA_Handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; /* BDMA不支持FIFO阀值设置 */
: K. u9 ^& s6 i5 Z% s) H/ S
DMA_Handle.Init.MemBurst = DMA_MBURST_SINGLE; /* BDMA不支持存储器突发 */
- U! K. {" i3 l: ?
DMA_Handle.Init.PeriphBurst = DMA_PBURST_SINGLE; /* BDMA不支持外设突发 */
/ d. B/ G5 V; `9 }( D# t
4 \: `$ {- ~8 \6 G' C
HAL_DMA_Init(&DMA_Handle);+ }/ W3 T5 D2 S; `: |5 L! I
" E& B a6 u @1 Y5 c3 q
/* 开启BDMA Channel0的中断 */( S0 {( i; {6 @ n5 [+ M1 V
HAL_NVIC_SetPriority(BDMA_Channel0_IRQn, 2, 0);+ @3 t1 Z }5 R
HAL_NVIC_EnableIRQ(BDMA_Channel0_IRQn); $ K& q3 u) Q! v( G4 n% S
& u2 i; s" Z: y E( h9 _
/*##-3- 配置DMAMUX #########################################################*/9 \" i/ ^0 c) o! z
dmamux_ReqGenParams.SignalID = HAL_DMAMUX2_REQ_GEN_LPTIM2_OUT; /* 请求触发器选择LPTIM2_OUT */% s; G- B* _2 e
dmamux_ReqGenParams.Polarity = HAL_DMAMUX_REQ_GEN_RISING_FALLING; /* LPTIM2输出的上升沿和下降沿均可触
" `2 x& V' p# j3 H
发 */
; H1 r7 [0 s5 R% c n7 A8 B) d
dmamux_ReqGenParams.RequestNumber = 1; /* 触发后，传输进行1次DMA传输 */
5 h) |5 u4 f$ Z3 V9 e& G
HAL_DMAEx_ConfigMuxRequestGenerator(&DMA_Handle, &dmamux_ReqGenParams); /* 配置DMAMUX */
. ?5 e% Y# K* I
HAL_DMAEx_EnableMuxRequestGenerator (&DMA_Handle); /* 使能DMAMUX请求发生器 */ 9 a3 I/ o; {- d& r2 }9 V* S
# U* q, S6 X# ^9 Z8 C& m
/*##-4- 启动DMA传输 ################################################*/2 W' ^% {: a5 a0 u$ z; ?0 d/ L
HAL_DMA_Start_IT(&DMA_Handle, (uint32_t)IO_Toggle, (uint32_t)&GPIOB->BSRRL, 8);
; V# W# ? d R! Q5 f/ P
}# x4 W0 Z- {% b a! `9 o
2 U+ r0 {' ~! O0 V; ^2 |. `

复制代码

42.4.4 函数HAL_DMAEx_MultiBufferStart
函数原型：

HAL_StatusTypeDef HAL_DMAEx_MultiBufferStart(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t SecondMemAddress, uint32_t DataLength)* [, {; `5 _ y9 Z5 R5 g' x
{0 z2 c# _/ v8 F f
HAL_StatusTypeDef status = HAL_OK;0 C+ U+ J! R6 M9 V/ p i$ A! r
__IO uint32_t *ifcRegister_Base = NULL;
4 Y0 @# }9 e' y
& f, j( x$ V) } Z: N8 b% I
/* 检测参数 */
0 ?8 p' g2 G! U
assert_param(IS_DMA_BUFFER_SIZE(DataLength));
6 Z+ U2 Q3 }0 i" l; f5 H; H
+ n* p/ ?2 U* w. O$ m3 s2 U
/* 如果是存储器到存储器的传输，不支持双缓冲 */
$ T- E/ Q. Q6 d
if ( (IS_D2_DMA_INSTANCE(hdma) == 0U) || (hdma->Init.Direction == DMA_MEMORY_TO_MEMORY))
: S$ r9 Z7 K+ _/ g$ N
{
. o+ j3 Z( z+ m. T, {. h, S* R
hdma->ErrorCode = HAL_DMA_ERROR_NOT_SUPPORTED;
4 Y0 u/ C' U" `- d, E
status = HAL_ERROR;
0 J8 j9 i# y# S T
}" T7 Y* g, ~, R4 ^0 K+ J* Y: p6 }
else
. Q2 R4 Y7 x4 b+ w6 `
{. s- D1 y+ f# u. H- y+ s+ r6 ?
/* 上锁 */9 ~5 ]& D W; W8 ~
__HAL_LOCK(hdma);
1 O/ D- `, v! m7 X* W. W
W4 s4 K* M9 c& r/ D# j/ |
if(HAL_DMA_STATE_READY == hdma->State), Z! ~4 v" t P( a- Y. n" E, P
{
: s3 A8 V/ ^1 A$ L! F1 y8 w- p
/* 设置DMA忙 */
/ E8 U3 d6 P2 s+ u
hdma->State = HAL_DMA_STATE_BUSY;
8 a+ b$ z8 V3 y" N& G
3 n7 S7 k8 j! o6 w
/* 设置无错误 */
, [& e9 F6 P/ E+ S! ~$ d2 i
hdma->ErrorCode = HAL_DMA_ERROR_NONE;
" a- r. B" Y- Q" K p: |
2 d8 L6 L# T3 X3 z; s9 Z# V% g
/* 使能DMA双缓冲 */
7 s' F p9 B0 ~. N" t
((DMA_Stream_TypeDef *)hdma->Instance)->CR |= (uint32_t)DMA_SxCR_DBM;
7 J! h+ p8 h2 ~* ]3 D2 N! a2 F
% w- p+ {7 `; w
/* 配置DMA Stream的另一个缓冲地址 */
# M$ x% d* \% E- u
((DMA_Stream_TypeDef *)hdma->Instance)->M1AR = SecondMemAddress;
7 X$ x/ }- i5 j* t( j
& Q9 t( {) d0 C/ u5 O: P
/* 配置源地址，目的地址和数据长度 */
' d- w# `6 M# f5 ?
DMA_MultiBufferSetConfig(hdma, SrcAddress, DstAddress, DataLength);
5 F B& d9 {, @* ]
7 H/ z+ J$ ~- C, q1 {
/* 计算寄存器IFCR地址，因为DMA1和DMA2的这寄存器地址不同，所以要获取下 */! @7 S2 G$ ]; ~. O$ n; ?6 r
ifcRegister_Base = (uint32_t *)((uint32_t)(hdma->StreamBaseAddress + 8U));* F* D4 h8 X1 M9 G% A2 F l2 ^
; c) e# q# ^+ N( B) T4 D
/* 清除所有标志 */. O$ l& G5 l2 y4 l9 T
*ifcRegister_Base = 0x3FU << hdma->StreamIndex;
9 S. d, A2 v- G4 j9 B
$ G' B3 S2 Z# b0 ^
/* 清除DMAMUX同步溢出标志 */& x2 [4 |! U" \
hdma->DMAmuxChannelStatus->CFR = hdma->DMAmuxChannelStatusMask;
; Q, z4 H2 g+ O! r: t+ R
0 s! o6 _8 S6 g8 `: d* H4 k4 u
if(hdma->DMAmuxRequestGen != 0U)
2 R5 A9 G4 M, F. K9 I5 x6 ?* q
{
! y, }4 M# x& ~
/* 如果使用了DMAMUX的请求发生器，清除请求发生器溢出标志 */, t% D. l7 a$ z
hdma->DMAmuxRequestGenStatus->RGCFR = hdma->DMAmuxRequestGenStatusMask;. m; T3 F/ X- h4 S% S
}
' c" L9 D4 [0 {. c/ v3 t
7 {2 D' V' F$ S2 }7 H
/* 使能DMA */6 T+ k( |( i" q+ u7 w
__HAL_DMA_ENABLE(hdma);
* N: T5 Q! f w, \. q+ C
}
; B Y6 T+ ]5 U+ r& g
else+ l+ b$ q- ?6 V9 _
{, O( [: s3 V1 H0 ~% z: C( T6 R
/* 设置DMA错误标志，DMA忙 */ O' K r. V* M/ K1 K2 R
hdma->ErrorCode = HAL_DMA_ERROR_BUSY;2 S7 p9 Y6 ?- g& j9 P. w% ?
* l7 p1 y) m7 w2 R9 L8 s% K7 A
/* 返回错误状态 */
; \9 w: J' J; `2 y- D
status = HAL_ERROR;
0 l$ w0 C3 p* Z! M9 B1 X7 U
}
1 C. U. a; l2 a! z) X+ s Z
}- I/ [0 P: k' _8 z& y
return status;
( n- ^( h/ V' m: b
}
6 y8 y6 P9 H& Z4 T% j3 ?, V
/ p' ~; e0 c# ?% {$ g& W& x

复制代码

函数描述：

调用函数HAL_DMA_Init配置了基础功能后，就可以调用此函数启动DMA双缓冲了。

函数参数：

  第1个参数是DMA_HandleTypeDef类型结构体指针变量。
  第2个参数是DMA传输的源地址。
  第3个参数是DMA传输的目的地址。
  第4个参数是双缓冲模式时，另一个缓冲的地址。
  第5个参数是传输的数据长度。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

第1个参数的结构体成员介绍在本章的3.2小节进行了详细说明。
存储器到存储器的传输方式不支持双缓冲，仅存储器到外设或者外设到存储器支持双缓冲。
当前的HAL库V1.3.0版本未支持BDMA的双缓冲，仅对DMA1和DMA2做了支持。
使用举例：

/*
% z( a% `9 Q, k+ e+ n
*********************************************************************************************************
/ d2 c$ z# q+ u; G. e0 k
* 函数名: bsp_InitTimDMA
# i0 Y0 B8 F, `9 l
* 功能说明: 配置DMAMUX的定时器触+DMA双缓冲控制任意IO做PWM和脉冲数控制
' t, \, ~7 h# [ \3 O4 I
* 形参: 无* |& _7 r2 [1 s( N+ C5 ~. b6 H
* 返回值: 无
- O1 a- n* T( M+ Z8 f( d+ s
*********************************************************************************************************
% M6 E* D- K w+ n
*/' i; M" q) S( X( ]% N
void bsp_InitTimDMA(void)9 Z! K# j/ c! @. A7 b
{/ c/ x- q) M" E1 f1 e i5 c
GPIO_InitTypeDef GPIO_InitStruct;
" A7 P+ Q. j! g$ Z" U9 f9 {6 @
DMA_HandleTypeDef DMA_Handle = {0};
5 w5 W# o* j; F) ^8 q* G
HAL_DMA_MuxRequestGeneratorConfigTypeDef dmamux_ReqGenParams = {0};
! ?% f( N- F+ h k% R- V& C
, a) ~( r0 f* s. `
/*##-1- 配置PB1用于PWM输出 ##################################################*/
* r) i O& A* `$ a
__HAL_RCC_GPIOB_CLK_ENABLE(); ~ M7 ?$ R. o- p( z0 U: i
GPIO_InitStruct.Pin = GPIO_PIN_1;' u$ d4 Z3 H3 r" {$ p
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
{+ L# j# ?2 |* r0 L/ I
GPIO_InitStruct.Pull = GPIO_NOPULL;8 ?, H( F2 K% w/ n1 [- W/ |
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
. W' Y6 R7 e8 S% k4 Y; X/ F
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
' e6 s/ l5 z3 r) p! p5 R$ r' f
8 O" A- f( \' U3 A+ B& h6 U z! J
/*##-2- 使能DMA1时钟并配置 ##################################################*/
7 G3 J1 Q$ f3 \& Q5 r* d" p
__HAL_RCC_DMA1_CLK_ENABLE();* q/ K4 T, t9 K2 i0 k4 x6 F( R5 K
DMA_Handle.Instance = DMA1_Stream1; /* 使用的DMA1 Stream1 */
8 _# |. {7 [9 \# @
DMA_Handle.Init.Request = DMA_REQUEST_GENERATOR0; /* 请求类型采用的DMAMUX请求发生器通道0 */ ; ^( a1 ` E( F$ `1 W
DMA_Handle.Init.Direction = DMA_MEMORY_TO_PERIPH; /* 传输方向是从存储器到外设 */
% ]) _- M) \) c9 l1 k
DMA_Handle.Init.PeriphInc = DMA_PINC_DISABLE; /* 外设地址自增禁止 */
9 R5 ~' i' @8 k" j: F7 O
DMA_Handle.Init.MemInc = DMA_MINC_ENABLE; /* 存储器地址自增使能 */ 9 o8 u+ ]: [4 o( g" |, x
DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* 外设数据传输位宽选择字，即32bit */ ' ^: f: M5 Z% x
DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; /* 存储器数据传输位宽选择字，即32bit */ 5 A7 w, d& {0 j1 z5 D( E2 s A
DMA_Handle.Init.Mode = DMA_CIRCULAR; /* 循环模式 */ " T K, o; G' A7 V+ k8 H
DMA_Handle.Init.Priority = DMA_PRIORITY_LOW; /* 优先级低 */
! d; Y+ ]/ ~& X3 P. K
DMA_Handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; /* 禁止FIFO*// E" h& z% ~2 Q1 V' Z: T
DMA_Handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; /* 禁止FIFO此位不起作用，用于设置阀值 */
( p! Z: J0 Q( p# W X
DMA_Handle.Init.MemBurst = DMA_MBURST_SINGLE; /* 禁止FIFO此位不起作用，用于存储器突发 */
. q8 q" l/ t& j; J- T& o3 H. u
DMA_Handle.Init.PeriphBurst = DMA_PBURST_SINGLE; /* 禁止FIFO此位不起作用，用于外设突发 */. D% q9 L3 e% G6 l" w" p0 ^
* R5 O$ f$ I, p7 q( Y+ b
/* 初始化DMA */& S) ?- i( K* a+ {5 I; q( [6 A
if(HAL_DMA_Init(&DMA_Handle) != HAL_OK)
$ j* S, Q; k/ b0 g* p/ m4 R1 x
{, k; u7 ?6 O0 z% \# V2 @
Error_Handler(__FILE__, __LINE__); / e! Z" G8 W" T5 a) r
}
0 n$ @* v2 B# f2 V4 x6 Q: F$ u
/ @" t: U. B: X
/* 开启DMA1 Stream1的中断 */
* n9 L$ @ t" K4 Y' z/ [" \
HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 2, 0);5 m0 q; e3 S4 T# p; Z: o4 M
HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn); $ C% U) t' \* K H1 l5 f
' E& ^0 K$ ]& j5 r/ D
. _3 m* t/ t( `
/*##-4- 配置DMAMUX ###########################################################*/2 x. f& s+ C% \- w" p
dmamux_ReqGenParams.SignalID = HAL_DMAMUX1_REQ_GEN_TIM12_TRGO; /* 请求触发器选择LPTIM2_OUT */( T' V/ r$ F- ~# X
dmamux_ReqGenParams.Polarity = HAL_DMAMUX_REQ_GEN_RISING; /* 上升沿触发 */, x. c% J, j8 Y7 }9 z0 h
dmamux_ReqGenParams.RequestNumber = 1; /* 触发后，传输进行1次DMA传输 */
) L0 }: C. @; @8 s+ M) f1 {
1 M: E5 L3 c* ~: ]5 t
HAL_DMAEx_ConfigMuxRequestGenerator(&DMA_Handle, &dmamux_ReqGenParams); /* 配置DMAMUX */$ h$ q3 g! z. ~+ V
HAL_DMAEx_EnableMuxRequestGenerator (&DMA_Handle); /* 使能DMAMUX请求发生器 */
: b T9 [; X) `% h
5 T9 M2 K0 U8 k8 G) C3 d
7 M V1 U/ a$ V; k. V& \
/*##-4- 启动DMA双缓冲传输 ################################################*/! l' V( a# j+ A" t) M" y: T2 q' C; {
/*
+ w) o+ q' s+ s; m7 x
1、此函数会开启DMA的TC，TE和DME中断, J# {; x/ D- E& l( c
2、如果用户配置了回调函数DMA_Handle.XferHalfCpltCallback，那么函数HAL_DMA_Init会开启半传输完成中断。
* J+ X3 r. m. h- ]. z( F' y
3、如果用户使用了DMAMUX的同步模式，此函数会开启同步溢出中断。' G! w" u' f6 W& e8 x2 j
4、如果用户使用了DMAMUX的请求发生器，此函数会开始请求发生器溢出中断。! B; V1 ~5 d) X* c
*/0 y& z9 W. T+ J- J6 h
HAL_DMAEx_MultiBufferStart(&DMA_Handle, (uint32_t)IO_Toggle, (uint32_t)&GPIOB->BSRRL,(uint32_t)IO_Toggle1, 8);4 G$ |( e) I' z
3 Y6 w) Q6 V) J, o' H# t' Y, y
}
& A* V: n! D7 i: D! l

复制代码

42.4.5 函数HAL_DMAEx_MultiBufferStart_IT
函数原型：

HAL_StatusTypeDef HAL_DMAEx_MultiBufferStart_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t SecondMemAddress, uint32_t DataLength)' s, D! Y7 r W5 \; q: q
{1 h3 o0 {; `' g8 H- V7 c
HAL_StatusTypeDef status = HAL_OK;) K. T' x; \* g
__IO uint32_t *ifcRegister_Base = NULL;6 K4 T6 k" z2 v" M5 B
: C r0 t) _: Y0 w7 @
/* 检测参数 */
& S2 ?7 a$ W/ w/ R8 z
assert_param(IS_DMA_BUFFER_SIZE(DataLength));$ _/ F( `6 y1 i3 O% K5 v
# Z! F; `7 `" j5 ]
/* 存储器到存储器的传输不支持双缓冲 */
5 p1 M8 e$ Y/ [: E) U8 _; @
if( (IS_D2_DMA_INSTANCE(hdma) == 0U) || (hdma->Init.Direction == DMA_MEMORY_TO_MEMORY)). ]2 o1 }7 _+ y. E& }
{
6 r3 y' V( _; U2 I1 l) g( w6 k
hdma->ErrorCode = HAL_DMA_ERROR_NOT_SUPPORTED;% p8 _/ s! L4 E8 g* b
return HAL_ERROR;0 X, [& ?% J# a I0 ]1 b( w
}. @7 O* N2 A7 g6 j; f' e+ o/ T. @$ Z
) @( f; @4 V( X$ d6 t; F
/* 上锁 */
8 R" \/ B% ]9 @0 P3 N0 v
__HAL_LOCK(hdma);& j! ~8 v5 }( J6 j( _! T+ m
; X* |$ g6 H4 G
if(HAL_DMA_STATE_READY == hdma->State)) E: }3 e" b& n$ I+ T
{& a- ~; \( }1 _7 o3 I
/* 设置DMA忙 */! p* i0 q4 |* J8 V* h( o: U5 G* z
hdma->State = HAL_DMA_STATE_BUSY;8 }2 `; A9 J( L7 u' ^
& e0 v* d1 ^$ w9 j& b
/* 设置无错误 */( V& N* N8 o# N- B( @
hdma->ErrorCode = HAL_DMA_ERROR_NONE;
) Z# ?; x6 g( w" L
; I/ K) d$ _- G- ~, a( l8 @
/* 使能双缓冲模式 */
, ?1 @* @7 a3 e- |, c' y
((DMA_Stream_TypeDef *)hdma->Instance)->CR |= (uint32_t)DMA_SxCR_DBM;5 n8 z( ]: y$ J
" D4 C$ K1 S2 I; W8 Z2 m
/* 设置DMA Stream另一个缓冲区地址 */
* B8 l! Y1 s' t3 \- Q ]
((DMA_Stream_TypeDef *)hdma->Instance)->M1AR = SecondMemAddress;% T2 u* D/ k- |2 i2 y
- Z* @+ l" r% E+ k0 c3 d, K
* 配置源地址，目的地址和数据长度 */$ ?8 y+ w" A$ j/ D {
DMA_MultiBufferSetConfig(hdma, SrcAddress, DstAddress, DataLength);% r: B+ d: a1 O, X% @
% M) r% e8 o- j( V0 G; t" d% ]
/* 计算寄存器IFCR地址，因为DMA1和DMA2的这寄存器地址不同，所以要获取下 */- w( K$ i6 f2 e' y8 z. X
ifcRegister_Base = (uint32_t *)((uint32_t)(hdma->StreamBaseAddress + 8U));! t8 r" }' x" U* b: Y- |$ I
. D3 J: J& z8 k/ J# u
/* 清除所有标志 */) B2 p. N# Y5 W2 g
*ifcRegister_Base = 0x3FU << hdma->StreamIndex;! X# [8 L' N( R( ^" \1 I* Y
+ B5 J+ d) E1 L! p
/* 清除DMAMUX同步溢出标志 */7 G9 h+ _6 Y; R, }
hdma->DMAmuxChannelStatus->CFR = hdma->DMAmuxChannelStatusMask;; n: F9 B" a3 T3 @ l+ v/ K5 K
% Y3 V# ]- `7 t9 _8 w( V7 p+ G
if(hdma->DMAmuxRequestGen != 0U)
# q8 z( a2 O5 G' y6 g
{
: [2 q+ W( ~# n) K: i3 O
/* 如果使用了DMAMUX的请求发生器，清除请求发生器溢出标志 */
$ `0 v* N$ [7 Z* S3 N% C7 d
hdma->DMAmuxRequestGenStatus->RGCFR = hdma->DMAmuxRequestGenStatusMask;! R& Y, }( u4 i5 E
}' b" m G0 z7 U) O* i. t2 m
1 d; ?8 Y0 o* Y
/* 使能TC，TE和DME中断 */# f" {. ?( D# A3 O N/ [2 t
MODIFY_REG(((DMA_Stream_TypeDef *)hdma->Instance)->CR, (DMA_IT_TC | DMA_IT_TE | DMA_IT_DME | DMA_IT_HT), (DMA_IT_TC | DMA_IT_TE | DMA_IT_DME));
. h% ?4 E4 C0 H1 K4 E6 p/ W3 J K
((DMA_Stream_TypeDef *)hdma->Instance)->FCR |= DMA_IT_FE;
" X' E' K% i3 U
( N4 Z% Y) }+ q) c' {
if(hdma->XferHalfCpltCallback != NULL)
' v! m" @) T0 [0 R
{
2 J* C* g" r# h# Q' c
/* 如何设置了半传输回调函数，同时开启半传输中断 */4 b7 [3 @0 _$ e
((DMA_Stream_TypeDef *)hdma->Instance)->CR |= DMA_IT_HT;3 d* g8 l6 F+ g% q$ E/ c
}
8 L6 w7 q3 T7 Z2 A; U$ N
( S% L1 J5 \/ U" X
/* 检测DMAMUX同步是否已经使能 */
- p2 @( U9 ~7 E4 [
if((hdma->DMAmuxChannel->CCR & DMAMUX_CxCR_SE) != 0)
5 K0 b* X" z, V9 k- ?
{% ~5 m* ^' I4 g2 d0 ?
/* 使能DMAMUX同步溢出中断 */, ?8 Z: Y5 h2 s" k3 J: I$ S! U0 f. W
hdma->DMAmuxChannel->CCR |= DMAMUX_CxCR_SOIE;
$ v; p' n( n$ t% h& j( y& Q- s, y# }
}2 i" a9 E$ F% K
6 i3 O6 \: j& v9 _0 b) d# @" E
if(hdma->DMAmuxRequestGen != 0U)& \' M- M. A8 g5 Q: | d
{3 p& S. T7 d, S- T
/* 如果使用DMAMUX请求发生器，使能DMAMUX请求发生器溢出中断 */5 Z( p8 A1 t% U4 O6 K# B: V) T
hdma->DMAmuxRequestGen->RGCR |= DMAMUX_RGxCR_OIE;: Z/ y/ y# V$ E0 S
}
( M# ~, `# f! i# d9 n0 }2 C
$ {! F" j4 C6 ^1 X1 e0 J0 z
/* 使能DMA */( s- h5 }) P) P2 H
__HAL_DMA_ENABLE(hdma);5 z6 H; i# N* H5 n/ g6 ?
}$ Q0 o! L. j( N
else
O4 V6 \% C8 V7 I. V
{
; o7 F' x/ M y* ]4 V
/* 设置错误代码，DMA忙 */9 r8 ?9 `- y& X
hdma->ErrorCode = HAL_DMA_ERROR_BUSY;
: E) w* f' |+ o) t, R+ \
/ {3 B0 z% o* ~8 V
/* 返回HAL_ERROR */
: z J0 c0 Y$ C; m9 l! M. s, A
status = HAL_ERROR;3 T& I: J4 o. k* Y+ d; q
}
/ }6 h2 b+ H. y
return status;
7 {# y4 K0 \# p
}

复制代码

函数描述：

调用函数HAL_DMA_Init配置了基础功能后，就可以调用此函数启动DMA双缓冲了，中断方式。

函数参数：

  第1个参数是DMA_HandleTypeDef类型结构体指针变量。
  第2个参数是DMA传输的源地址。
  第3个参数是DMA传输的目的地址。
  第4个参数是双缓冲模式时，另一个缓冲的地址。
  第5个参数是传输的数据长度。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

第1个参数的结构体成员介绍在本章的3.2小节进行了详细说明。
对于DMA1和DMA2，这个函数会开启TC，TE和MDE中断，如果注册了半传输完成回调函数，还会开启半传输中断。
如果使用了DMAMUX同步模式，还会开启同步溢出中断。
如果使用了DMAMUX请求发生器，会开启请求发生器溢出中断。
存储器到存储器的传输方式不支持双缓冲，仅存储器到外设或者外设到存储器支持双缓冲。
当前的HAL库V1.3.0版本未支持BDMA的双缓冲，仅对DMA1和DMA2做了支持。
使用举例：

/*
+ e$ f6 ^2 P7 G6 q
*********************************************************************************************************
4 v- C7 S0 Y) m
* 函数名: bsp_InitTimDMA
5 ^4 v+ F T- l' s
* 功能说明: 配置DMAMUX的定时器触+DMA双缓冲控制任意IO做PWM和脉冲数控制+ Y: N# B/ v4 {+ c% r
* 形参: 无
6 W( m* G; T/ D& M/ B7 U
* 返回值: 无
r1 h& K t( U" E. ~& e
*********************************************************************************************************
/ X7 v: q, D" Q+ c
*/+ y9 y" j, s/ l6 h
void bsp_InitTimDMA(void)
4 c* M/ H0 B6 a3 H6 ^+ Q6 F7 g, Y
{. h3 [$ `/ D n. o2 o. C( G
GPIO_InitTypeDef GPIO_InitStruct;
$ Y+ [+ `6 s# s3 x& B& b
DMA_HandleTypeDef DMA_Handle = {0};
8 R m) z4 X& i* `$ r, a& j
HAL_DMA_MuxRequestGeneratorConfigTypeDef dmamux_ReqGenParams = {0};
+ Z% w# m9 Q* o
1 b% m% p3 }. ]! \) E; z" x1 J# ]
/*##-1- 配置PB1用于PWM输出 ##################################################*/
2 U, V$ A; U: `8 V% }' l
__HAL_RCC_GPIOB_CLK_ENABLE();" M& v6 D2 V i0 k5 _6 J3 B
GPIO_InitStruct.Pin = GPIO_PIN_1;
9 b5 g* @+ P# O# E) C
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
2 W$ F- Q b0 O/ O% ~
GPIO_InitStruct.Pull = GPIO_NOPULL;
4 t8 K3 d$ o5 w
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;& E, N5 y7 C$ A8 t( _! O& u% R
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
, T8 Q, B" Y$ C. S" E+ k% y" w* y
% o, T7 G+ _# j4 \, w6 H- o
/*##-2- 使能DMA1时钟并配置 ##################################################*/
! x! V$ P; q1 [8 ~% R. `3 j1 ?
__HAL_RCC_DMA1_CLK_ENABLE();
0 \& [* u8 O" }1 F$ z" V
DMA_Handle.Instance = DMA1_Stream1; /* 使用的DMA1 Stream1 */; `2 v U+ P- e& E7 S: Q" p
DMA_Handle.Init.Request = DMA_REQUEST_GENERATOR0; /* 请求类型采用的DMAMUX请求发生器通道0 */ 8 T9 @1 Q* S1 C! B8 p
DMA_Handle.Init.Direction = DMA_MEMORY_TO_PERIPH; /* 传输方向是从存储器到外设 */
* f6 X. y0 @8 A% ]! l1 B. v
DMA_Handle.Init.PeriphInc = DMA_PINC_DISABLE; /* 外设地址自增禁止 */ % e9 \3 A/ |8 q2 c# a+ ]1 }
DMA_Handle.Init.MemInc = DMA_MINC_ENABLE; /* 存储器地址自增使能 */ $ ]) B# F( ]: o
DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* 外设数据传输位宽选择字，即32bit */
! }7 R6 t1 }% }; ~3 o+ F! S& S
DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; /* 存储器数据传输位宽选择字，即32bit */
. w9 X1 x& K' k- Z( z
DMA_Handle.Init.Mode = DMA_CIRCULAR; /* 循环模式 */ ; }% L) L5 a2 }! t
DMA_Handle.Init.Priority = DMA_PRIORITY_LOW; /* 优先级低 */
7 ~6 B C. V- |& O! H/ q0 g
DMA_Handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; /* 禁止FIFO*/" ]+ ~( B) H7 M. `: D5 z. e
DMA_Handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; /* 禁止FIFO此位不起作用，用于设置阀值 *// P2 X7 l8 ?6 D
DMA_Handle.Init.MemBurst = DMA_MBURST_SINGLE; /* 禁止FIFO此位不起作用，用于存储器突发 */
' P: g" i# p8 F; F3 P
DMA_Handle.Init.PeriphBurst = DMA_PBURST_SINGLE; /* 禁止FIFO此位不起作用，用于外设突发 */
+ m, Z# v7 |8 f: }: C
+ ]& o; j- C$ U+ H: w* p
/* 初始化DMA *// _- h# J3 M5 H- W# ?5 }: J
if(HAL_DMA_Init(&DMA_Handle) != HAL_OK)9 r4 @: q' s7 d
{) A9 a4 w/ w( w0 T( o! O
Error_Handler(__FILE__, __LINE__); ! g4 j. v% p' Z k& ?6 i k
}$ _! n" {2 R6 U' Z( @1 {% d6 [9 _
9 T' C/ W' d4 W8 @: T
/* 开启DMA1 Stream1的中断 */$ F: p' r' D. O0 V" ^
HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 2, 0);
5 i1 k. q- P$ y2 J5 W
HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
& v @5 t- `% B/ t! j* _
- C( a: I, v3 h0 d
+ \( `$ _2 K/ L" ^. x; K/ H7 E
/*##-4- 配置DMAMUX ###########################################################*/6 e0 r4 D. S5 q0 ?# Y# V
dmamux_ReqGenParams.SignalID = HAL_DMAMUX1_REQ_GEN_TIM12_TRGO; /* 请求触发器选择LPTIM2_OUT */
+ w" w, Z& E: b- A* J; Y5 C0 b
dmamux_ReqGenParams.Polarity = HAL_DMAMUX_REQ_GEN_RISING; /* 上升沿触发 */0 p3 D7 q, f4 d2 w
dmamux_ReqGenParams.RequestNumber = 1; /* 触发后，传输进行1次DMA传输 */
% U) t! X+ k; }3 V4 k
, R/ H. j+ ^' A
HAL_DMAEx_ConfigMuxRequestGenerator(&DMA_Handle, &dmamux_ReqGenParams); /* 配置DMAMUX */
( u) n6 B5 F( }- i4 l
HAL_DMAEx_EnableMuxRequestGenerator (&DMA_Handle); /* 使能DMAMUX请求发生器 */
+ a/ W% T" W2 |
. x- V1 W! i3 a0 T0 T( ~
. n) o# U9 e; q; f9 I) _! _/ s
/*##-4- 启动DMA双缓冲传输 ################################################*/# k6 l3 \- y/ i" g2 a0 g& r7 f) E' C) |
/*
/ }4 r* C0 p; o5 ]% {
1、此函数会开启DMA的TC，TE和DME中断1 L* X# K' F. z3 g: g
2、如果用户配置了回调函数DMA_Handle.XferHalfCpltCallback，那么函数HAL_DMA_Init会开启半传输完成中断。
+ X, p! t2 g; `1 H* b
3、如果用户使用了DMAMUX的同步模式，此函数会开启同步溢出中断。9 ?, q. `3 K- o9 j* U
4、如果用户使用了DMAMUX的请求发生器，此函数会开始请求发生器溢出中断。. v6 T3 m9 @" i% `# G& Y
*/
6 w- J8 c, t$ ]8 w) S: n u5 n
HAL_DMAEx_MultiBufferStart_IT(&DMA_Handle, (uint32_t)IO_Toggle, (uint32_t)&GPIOB->BSRRL,(uint32_t)IO_Toggle1, 8);
0 [8 Z. _% d) f4 P/ a
}+ t" Z7 z9 |$ x9 K+ C# I

复制代码

42.5 总结
本章节就为大家讲解这么多，BDMA作为一个重要的外设，务必要熟练掌握。另外注意DMA1，DMA2和BDMA的区别。

赞收藏评论0 发布时间：2021-10-30 22:46

0个回答

【经验分享】STM32H7的DMA基础知识和HAL库API

所属标签