1、概述

! r$ H' T2 q7 n; |6 d. |使用DMA发送数据，首先我们要确认使用的串口有没有DMA。
2 \& E6 g! U0 J
我们使用USART1串口外设，从数据手册中可以查到，USART1的发送和接收都是支持DMA的，使用的是DMA2.

/ ?/ a4 c" {% o1 ~3 T

7 ?0 H4 `. b  E; t接下来就是撸代码的时刻了
& Z7 M2 d4 g5 `7 e% i
02、代码
DMA串口发送的代码是在上一篇文章DMA串口接收的基础上修改的。
7 W- b3 l- s3 `  ^! X! u9 i3 K! Y7 m' U

1. void UART_Init(void)
   $ H6 Q5 u% `2 M; @+ H
2. {
   
3.   USART_InitTypeDef USART_InitStructure;
   . d& ^" n. x0 v9 I" p& V/ \! b0 T
4.   GPIO_InitTypeDef GPIO_InitStructure;
     w5 H) G& E9 F) ?' f
5.   NVIC_InitTypeDef NVIC_InitStructure;
   
6. 
   
7.   /* Enable GPIO clock */
   , [' D0 Y1 R  ^
8.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
   + {) h6 Q& s$ C/ G& d' O8 p5 c
9.   /* Enable UART1 clock */
   5 Y+ A2 T$ M. n4 Z
10.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    ' q2 I4 @' ]1 U2 X( {' \: O
11.   /* Connect PXx to USARTx_Tx*/
    8 p; b9 ?* W+ K
12.   GPIO_PinAFConfig(GPIOA, 9, GPIO_AF_USART1);
    ! b' `* E5 H# \' W* j4 O
13. 
    $ V2 ]( e, p7 F
14.   /* Connect PXx to USARTx_Rx*/
    - J0 i+ e( h( A4 `- C4 p5 @& N
15.   GPIO_PinAFConfig(GPIOA, 10, GPIO_AF_USART1);
    
16. 
    
17.   /* Configure USART Tx as alternate function  */
    
18.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    9 k. j* x2 V$ Y; J5 R& i4 H( W
19.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    4 [& z7 W; V: F0 X7 e
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
21. 
    / {. ]9 i: H, Q$ U
22.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
23.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
24.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    4 F7 S+ E( F  Z* ^- Z% p
25. 
    $ _; h  M. c& A
26.   /* Configure USART Rx as alternate function  */
    9 x0 H( v1 m1 K% e
27.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
28.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    / m, b# O, F( I# y1 [
29.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    1 v  A% l) Y4 x& r2 n8 ]; B0 b6 h
30. 
    " B, m8 i# B8 Q! s9 z: N# x1 Q
31.   USART_InitStructure.USART_BaudRate = 115200;
    
32.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
33.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
34.   USART_InitStructure.USART_Parity = USART_Parity_No;
    0 E- h. O. T; M+ |: x
35.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
36.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
37. 
    
38.   /* USART configuration */
    $ {; ~) f+ c5 J  r1 ^+ n
39.   USART_Init(USART1, &USART_InitStructure);
    
40. 
    
41.   USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
    
42. 
    8 u# R% h7 v+ \
43.   /* Enable the USARTx Interrupt */
    
44.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
45.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority =0;
    8 t: x) v5 _0 ^" @
46.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    7 Q6 }% x, i# H# _( A* Z: {$ ]* i; v
47.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    3 y$ {5 j* e2 u% \) r9 X1 G& ^
48.   NVIC_Init(&NVIC_InitStructure);
      Y! W% d  l, t4 U3 e) F0 V- a- E
49. 
    
50.   /*使能串口DMA接收*/
    
51.   USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
    5 z, p" Q2 Y# n+ f
52.   /*使能串口DMA发送*/
    2 A% ~# `& w* f: u# P1 @. W
53.   USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
    6 o8 Z9 y7 c2 i7 S
54. 
    
55.   /* Enable USART */
    
56.   USART_Cmd(USART1, ENABLE);
    
57. }

复制代码

0 D: l$ F* r" G4 T4 a
2 E/ G+ X/ H5 Y' ?/ N  S; ~在这里除了常规的串口配置，我们需要配置串口的DMA发送，和串口DMA接收一样的API函数，参数修改为USART_DMAReq_Tx即可。
. W6 _" B' k% i. Z4 H, a9 u
. F8 D3 C+ M$ ?/ b& n4 r  ]串口DMA发送配置

/ z% i/ _. b; _5 A

1. void Uart_Send_DMA_Config(void)
   ' d* c  x* A" A! l7 L/ G
2. {
   7 A3 u- t, g( O/ Q# L  E7 n
3.   DMA_InitTypeDef  DMA_InitStructure;
   
4. 
   
5.   /* Enable DMA clock */
   
6.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
   2 V% T# U% v; e: X) v! d
7. 
   8 b* \, |8 d4 v# g$ P
8.   /* Reset DMA Stream registers (for debug purpose) */
   
9.   DMA_DeInit(DMA2_Stream7);
   6 t9 T7 @3 \  \& g
10. 
    2 H2 ^; V" y8 U0 h* n0 I3 c
11.   /* Check if the DMA Stream is disabled before enabling it.
    " V0 O! x- u0 f
12.      Note that this step is useful when the same Stream is used multiple times:
    
13.      enabled, then disabled then re-enabled... In this case, the DMA Stream disable
    1 r) f  i- r  y) P6 W* [# I
14.      will be effective only at the end of the ongoing data transfer and it will
    + Z6 y$ U, S( }/ b. R
15.      not be possible to re-configure it before making sure that the Enable bit
    
16.      has been cleared by hardware. If the Stream is used only once, this step might
    6 Q4 T- e# k4 z6 |- q  e" }7 O
17.      be bypassed. */
    6 g, Y" T) A( I: T& {' D# h
18.   while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE)
    " Q( M* s3 _0 e5 I& O1 G/ S0 ]
19.   {
    
20.   }
    $ o  m) V' v  }1 N6 ~* X
21. 
    
22.   /* Configure DMA Stream */
    
23.   DMA_InitStructure.DMA_Channel = DMA_Channel_4;  //DMA请求发出通道
    0 u3 [# T' a+ z, g
24.   DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;//配置外设地址
    
25.   DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)UART_Buffer;//配置存储器地址
    % J( f; r* _3 ?2 H
26.   DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;//传输方向配置
    7 j+ r" O/ g9 w% X& \/ R
27.   DMA_InitStructure.DMA_BufferSize = (uint32_t)UART_RX_LEN;//传输大小
    
28.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外设地址不变
    
29.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//memory地址自增
    / B1 a& `. Z- L, P5 B) Z
30.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;//外设地址数据单位
    9 U$ Z. J7 |2 K- Y: f" ~: g
31.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;//memory地址数据单位
    
32.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;//DMA模式：正常模式
    1 n- |/ G4 k8 g. O. a
33.   DMA_InitStructure.DMA_Priority = DMA_Priority_High;//优先级：高
    
34.   DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;//FIFO 模式不使能.         
    " R* H" E- `' P3 I/ |0 x
35.   DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;// FIFO 阈值选择
    
36.   DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;//存储器突发模式选择，可选单次模式、 4 节拍的增量突发模式、 8 节拍的增量突发模式或 16 节拍的增量突发模式。
    3 A. `: i" E4 x8 c1 y
37.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;//外设突发模式选择，可选单次模式、 4 节拍的增量突发模式、 8 节拍的增量突发模式或 16 节拍的增量突发模式。
    ' v, g( Z' p) o* }, O; n$ Z5 U
38.   DMA_Init(DMA2_Stream7, &DMA_InitStructure);
    
39. 
    # O9 I% S8 ], k- N0 s
40.   /* DMA Stream enable */
    
41. //  DMA_Cmd(DMA2_Stream7, ENABLE);
    
42. }

复制代码

$ A$ Y7 A5 S+ m% M
这里也是常规的DMA配置流程，不明白的同学请看文章《STM32DMA详解》，这里值得注意的是，配置完成并没有使能DMA2_Stream7，使能了就会立即将UART_Buffer的数据发送出去。
$ C3 I- r! A9 I0 l/ O6 M
其他代码处理
! G9 O( o: O& S( a

1. void USART1_IRQHandler(void)
   
2. {
   1 {: y- v# H2 Q- I
3.   uint8_t temp;
   
4.   if(USART_GetFlagStatus(USART1, USART_FLAG_IDLE) == SET)
   & ~. M* U! i5 k# n. E: j2 G
5.   {
   
6.     DealWith_UartData();
   
7. //    USART_ClearFlag(USART1, USART_FLAG_IDLE);
   2 i, Z2 _# n, d
8.     temp = USART1->SR;  
   % U; H# i' G0 u  ^$ I2 w
9.     temp = USART1->DR; //清USART_IT_IDLE标志  
   
10.   }
    
11. }
    
12. 
    
13. void DealWith_UartData()
    5 u$ K2 g: b' S, y# q
14. {
    
15.   DMA_Cmd(DMA2_Stream2, DISABLE);
    
16.   UART_Receive_flg = 1;
    - w( e( e- q) V! e6 W
17.   UART_Receive_len = UART_RX_LEN - DMA_GetCurrDataCounter(DMA2_Stream2);
    6 c2 E' Z) ~7 z, A9 k
18.   UART_Buffer[UART_Receive_len] = 0;
    
19.   DMA_SetCurrDataCounter(DMA2_Stream2,UART_RX_LEN);
    ( o. t* q) ^; ^1 o& K. B2 H1 ~
20.   DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2);
    # w% ]: {% W, H- C
21.   DMA_Cmd(DMA2_Stream2, ENABLE);
    
22. }
    ( g, U! l# W7 u- ^. [1 ~
23. 
    
24. int main(void)
    
25. {
    9 `: }) K; J2 H1 u2 ?8 a
26.   UART_Receive_flg = 0;
    % ]9 C3 C) @* G, @! U# Q( e( v" d
27. 
    
28.   Uart_Reveice_DMA_Config();
    
29.   Uart_Send_DMA_Config();
    3 Q$ e/ l* H% `( T
30.   UART_Init();
    $ K+ j$ g5 U& _4 {( V' T* y
31. 
    
32.   while (1)
    / f0 p: a2 R5 Q7 p: Z: v
33.   {
    4 E; n, Y: ]5 h. I$ M
34.     if(UART_Receive_flg)
    
35.     {
    
36.       UART_Receive_flg = 0;
    
37.       Uart_Send_DMA_Start();
    
38.     }
    ; Z' T: V+ F8 ]0 r/ d( Z
39.   }
    4 l& w7 z; v' z& Q7 m
40. }
    1 Z$ |& f  G# U8 [8 K1 G! _! t" @

复制代码

上面3个函数，简单逻辑就是，当串口使用DMA接收了一定量的数据，就会通过串口DMA发送出去，串口DMA发送的代码如下：

8 K4 j/ w' ]! u. T

1. void Uart_Send_DMA_Start(void)
   : ]& L' f2 S) W& B) ^
2. {
   4 h& G; z" z/ O5 J: o" r' M
3.   DMA_SetCurrDataCounter(DMA2_Stream7,UART_Receive_len);
     s* E4 s% a# b& L9 C9 @( J2 z
4.   DMA_ClearFlag(DMA2_Stream7, DMA_FLAG_TCIF7);
   
5.   /* DMA Stream enable */
   8 H8 ^: Y: _6 j& U; i2 o% ^& f
6.   DMA_Cmd(DMA2_Stream7, ENABLE);
   
7. }

复制代码

03、后记
! W" d4 K, e* ]/ a! y, \1 c这一篇很简单，就是DMA使用的一个延伸，上面说了这么多，也贴了很多代码，不可能将所有代码全部贴出来，作为软件工程师，还是在IDE里看代码方便，如果感兴趣的话，可以到下面github链接下载代码，Keil和IAR的工程文件都有。