1、概述

使用DMA发送数据，首先我们要确认使用的串口有没有DMA。
' ?4 t+ {) p) P" f1 U  o4 C1 O
8 n2 |/ p3 r4 k( P9 r我们使用USART1串口外设，从数据手册中可以查到，USART1的发送和接收都是支持DMA的，使用的是DMA2.

% K' _6 Z5 O! v" _6 G- x

( F; _# \& c: x接下来就是撸代码的时刻了

02、代码
DMA串口发送的代码是在上一篇文章DMA串口接收的基础上修改的。

2 m- v, p- q& E( B5 v3 C/ H

1. void UART_Init(void)
   
2. {
   $ c7 ~/ M; N7 D9 E# u: J7 _7 b
3.   USART_InitTypeDef USART_InitStructure;
   
4.   GPIO_InitTypeDef GPIO_InitStructure;
   ; F% d1 G( G# u2 \; S, K& {
5.   NVIC_InitTypeDef NVIC_InitStructure;
   ) X, S9 N  F, v3 s
6. 
   
7.   /* Enable GPIO clock */
   
8.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
   
9.   /* Enable UART1 clock */
   ) P) q6 O4 o. E; e  Z$ L
10.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
      W" p" V3 f; Y2 O3 m9 y
11.   /* Connect PXx to USARTx_Tx*/
    / n! h1 c  n' H
12.   GPIO_PinAFConfig(GPIOA, 9, GPIO_AF_USART1);
    1 p0 j5 j+ q  E( K% o( @
13. 
    3 `, Y+ G) Q1 s4 w  p
14.   /* Connect PXx to USARTx_Rx*/
    
15.   GPIO_PinAFConfig(GPIOA, 10, GPIO_AF_USART1);
    
16. 
    
17.   /* Configure USART Tx as alternate function  */
    
18.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
19.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
21. 
    ' a2 r2 l5 f- l3 d. ]% K/ \
22.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    5 l+ r" p9 c7 T: G. I
23.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
24.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
25. 
    
26.   /* Configure USART Rx as alternate function  */
    
27.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    / o! G% U8 L% t( c/ l
28.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    ) W- k, E" U% Q/ ~! N
29.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
30. 
    
31.   USART_InitStructure.USART_BaudRate = 115200;
    
32.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
33.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
    & P9 X/ b1 a* `
34.   USART_InitStructure.USART_Parity = USART_Parity_No;
    9 f. J# X0 X5 `9 f
35.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
36.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
37. 
    : [4 x4 I: D3 R( F+ E
38.   /* USART configuration */
    
39.   USART_Init(USART1, &USART_InitStructure);
    / j* H1 v' u7 d. _3 w
40. 
    
41.   USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
    
42. 
    
43.   /* Enable the USARTx Interrupt */
    - ?$ |6 k2 r/ |: [6 o' r$ t
44.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    ' F2 P3 {6 Q6 t' Y4 g- e, A" W
45.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority =0;
    & C; \9 B. P0 ]% G/ M. Q; D
46.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    * Z8 N7 }% k0 L% X9 W& f
47.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
48.   NVIC_Init(&NVIC_InitStructure);
    ) Q9 }, f$ v* J/ r5 V9 `9 K
49. 
    ) c. w  W( r& A0 m) t, E
50.   /*使能串口DMA接收*/
    
51.   USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
    
52.   /*使能串口DMA发送*/
      q  [$ q' E1 I3 C0 \
53.   USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
    & W7 V3 |+ h: k1 n$ i
54. 
    : R- |# v# q' I
55.   /* Enable USART */
    
56.   USART_Cmd(USART1, ENABLE);
    + t) M8 ~" ?) r  s" e4 a
57. }

复制代码

( O3 G1 H4 w$ m- c在这里除了常规的串口配置，我们需要配置串口的DMA发送，和串口DMA接收一样的API函数，参数修改为USART_DMAReq_Tx即可。
* y9 g* D) x3 S, x4 b" t
' l: @6 b3 ^& o& ~0 z串口DMA发送配置

1. void Uart_Send_DMA_Config(void)
   # {1 f* D" N4 I3 I9 X
2. {
   
3.   DMA_InitTypeDef  DMA_InitStructure;
     C; D! A( \+ D9 F9 M
4. 
   * A& M! ~0 J" G" d! m; `( H3 x$ J: x
5.   /* Enable DMA clock */
   ! L+ G9 v. p0 s7 z) N- ?+ e0 U- t
6.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
   
7. 
   / _9 @' J4 R# i. G4 Q0 o1 |' {
8.   /* Reset DMA Stream registers (for debug purpose) */
   
9.   DMA_DeInit(DMA2_Stream7);
   ( Y0 L  x+ q/ J: l5 x' a
10. 
    5 G+ @# W5 X' ]& d: g$ k
11.   /* Check if the DMA Stream is disabled before enabling it.
    
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
    0 e8 v5 I* B# T& ^  K! c
14.      will be effective only at the end of the ongoing data transfer and it will
    
15.      not be possible to re-configure it before making sure that the Enable bit
    ) _# Y* f, q7 Q. s2 Z
16.      has been cleared by hardware. If the Stream is used only once, this step might
    
17.      be bypassed. */
    
18.   while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE)
    7 E) y# D# d. o) D% j7 l/ z
19.   {
    ' M# h5 Y9 Z0 P. h, W$ B, q* V
20.   }
    
21. 
    # T( y$ I9 q2 k' d
22.   /* Configure DMA Stream */
    
23.   DMA_InitStructure.DMA_Channel = DMA_Channel_4;  //DMA请求发出通道
    
24.   DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;//配置外设地址
    
25.   DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)UART_Buffer;//配置存储器地址
    
26.   DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;//传输方向配置
    
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地址自增
    " {& Y1 \- G, f  j& P' a% I" A
30.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;//外设地址数据单位
    
31.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;//memory地址数据单位
    ' V% ]1 U5 z) ~+ Q
32.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;//DMA模式：正常模式
    
33.   DMA_InitStructure.DMA_Priority = DMA_Priority_High;//优先级：高
    
34.   DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;//FIFO 模式不使能.         
    
35.   DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;// FIFO 阈值选择
    7 i+ A) n1 J/ n- e2 y" V0 Y
36.   DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;//存储器突发模式选择，可选单次模式、 4 节拍的增量突发模式、 8 节拍的增量突发模式或 16 节拍的增量突发模式。
    7 `; S: ^5 n, P* b. N3 P
37.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;//外设突发模式选择，可选单次模式、 4 节拍的增量突发模式、 8 节拍的增量突发模式或 16 节拍的增量突发模式。
    
38.   DMA_Init(DMA2_Stream7, &DMA_InitStructure);
    ( u- d2 ~6 t9 M  `" M9 c9 p
39. 
    
40.   /* DMA Stream enable */
    - B* _  u1 P0 i0 R/ W
41. //  DMA_Cmd(DMA2_Stream7, ENABLE);
    
42. }

复制代码

  L: `8 X/ ?6 s, x5 s这里也是常规的DMA配置流程，不明白的同学请看文章《STM32DMA详解》，这里值得注意的是，配置完成并没有使能DMA2_Stream7，使能了就会立即将UART_Buffer的数据发送出去。

& `: s/ {5 y" K' ]7 b' q$ K其他代码处理

. F- P0 h! q2 ^

1. void USART1_IRQHandler(void)
   # q2 a2 f! x7 H, `
2. {
     U$ Q, w6 s  o) ~8 [  G- h/ }
3.   uint8_t temp;
   ( I, X5 Z0 P, m+ Q- `. Y% j/ d' u
4.   if(USART_GetFlagStatus(USART1, USART_FLAG_IDLE) == SET)
   0 X8 l+ X& |6 E2 P/ v
5.   {
   
6.     DealWith_UartData();
   
7. //    USART_ClearFlag(USART1, USART_FLAG_IDLE);
   % l! [6 p  L7 P% A! \( q
8.     temp = USART1->SR;  
   
9.     temp = USART1->DR; //清USART_IT_IDLE标志  
   
10.   }
    
11. }
    
12. 
    
13. void DealWith_UartData()
    
14. {
    4 V+ c# U' @9 N5 _1 D( C* p
15.   DMA_Cmd(DMA2_Stream2, DISABLE);
    
16.   UART_Receive_flg = 1;
    
17.   UART_Receive_len = UART_RX_LEN - DMA_GetCurrDataCounter(DMA2_Stream2);
    1 S; P1 t+ @* z8 t- t/ |
18.   UART_Buffer[UART_Receive_len] = 0;
    % f( q. c' H0 d8 S0 z! _& x
19.   DMA_SetCurrDataCounter(DMA2_Stream2,UART_RX_LEN);
    
20.   DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2);
    
21.   DMA_Cmd(DMA2_Stream2, ENABLE);
    
22. }
    
23. 
    4 S& O( T; D: {. M
24. int main(void)
    3 o% E# `5 J; K
25. {
    
26.   UART_Receive_flg = 0;
    7 Y) d# a3 H$ I3 C( R3 I
27. 
    
28.   Uart_Reveice_DMA_Config();
    / o0 O6 M3 Z  v" V( b; G
29.   Uart_Send_DMA_Config();
    
30.   UART_Init();
    ; S. Q3 @* C* B% b! B
31. 
    ( L6 s( P3 i5 }; ]6 Q2 x) s! D
32.   while (1)
    ) K  v$ P' x, g# f! ?  z8 \
33.   {
    ! ^1 L7 O% C( s, C
34.     if(UART_Receive_flg)
      f) k0 i: S! l8 M/ W
35.     {
    
36.       UART_Receive_flg = 0;
    - z' Y* i  E: [: @5 v# S
37.       Uart_Send_DMA_Start();
    6 g* S7 R+ s  A: K
38.     }
    7 S3 _5 G+ N; G& v+ b6 ~
39.   }
    9 K4 L8 f3 v- A5 a
40. }
    ; \: f/ }% K( K

复制代码

* I/ r5 E  {" Q* X; I+ n! b: ]9 ?上面3个函数，简单逻辑就是，当串口使用DMA接收了一定量的数据，就会通过串口DMA发送出去，串口DMA发送的代码如下：
. B  B$ q' u8 a  ^; l: ^0 ], h
; }* L8 Q1 @* s# h0 Z5 n" F

1. void Uart_Send_DMA_Start(void)
   
2. {
   5 \  j( X! s6 Y
3.   DMA_SetCurrDataCounter(DMA2_Stream7,UART_Receive_len);
   ! d2 z6 t1 L4 z6 `% M
4.   DMA_ClearFlag(DMA2_Stream7, DMA_FLAG_TCIF7);
   
5.   /* DMA Stream enable */
   ' m& V+ ~. T5 I1 |( W3 }
6.   DMA_Cmd(DMA2_Stream7, ENABLE);
   
7. }

复制代码

03、后记
这一篇很简单，就是DMA使用的一个延伸，上面说了这么多，也贴了很多代码，不可能将所有代码全部贴出来，作为软件工程师，还是在IDE里看代码方便，如果感兴趣的话，可以到下面github链接下载代码，Keil和IAR的工程文件都有。
, x3 U7 T* E; ^1 B; |' A
+ ]7 B; p2 f. t3 @+ Y7 n