本文通过一个小的设计来进行讲解，将STM32内部存储的一个数组中的数据，通过DMA操作复制到第二个数组里，并用USART1串口将第二个数组中的数据输出到电脑端，进行检查，看是否复制成功。
) g' U7 ]$ C8 F* T1 ?' x
首先总结全文,，使用STM32进行DMA操作的主要过程如下：
1，初始化GPIO
2，初始化串口
- x; a0 F/ J% t1 j3，初始化DMA
& x, i- ?! X3 I& n1 F; h4，编写主函数

- |  u6 j" e& s( Z) d下面介绍详细步骤：

2 v9 L, {* V; q' A5 e  C1，初始化GPIO

1. void IO_Init()
   
2. {
   5 F) r( m+ o7 e! `. Z3 D: l/ X
3.         GPIO_InitTypeDef Uart_A; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
   3 b9 ~7 r# [- o6 r$ J
4.         Uart_A.GPIO_Pin = GPIO_Pin_9;
   
5.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
   
6.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
   5 d2 K) q1 C, R! z& J, U. n$ s: ]1 E
7.         GPIO_Init(GPIOA,&Uart_A);
   
8.        
   
9.         Uart_A.GPIO_Pin = GPIO_Pin_10;
   
10.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
      z3 f) I$ e# F9 f) f% a+ @
11.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING; //page 110
    
12.         GPIO_Init(GPIOA,&Uart_A);
    3 x% K' W+ _, J% g
13.        
    
14. }

复制代码

& q. u5 S0 G& f8 q; M2，初始化USART1

1. void Usart1_Init()
   : p  b1 e7 k8 E4 i2 ~0 n- o
2. {
   ( f) w' T! [8 z; r8 k/ ?2 s/ @
3.         USART_InitTypeDef Uart;
     t6 W" K7 M+ R
4.        
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   , w: N. w! |, |3 B
6.         Uart.USART_BaudRate = 115200;
   
7.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   $ X; j' S) @/ y; k0 l
8.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
   ) w# D  }/ _2 u! q# Y# c9 T* W
9.         Uart.USART_Parity = USART_Parity_No;
   : F. h1 t2 c* m" w
10.         Uart.USART_StopBits = USART_StopBits_1;
    9 I* c7 b0 Z4 W, L5 G
11.         Uart.USART_WordLength = USART_WordLength_8b;
    : k# R3 c1 x& i! g+ H" W) c% [
12.         USART_Init(USART1,&Uart);
    ( u; V/ f1 b! e2 K- N5 O
13.        
    
14.         USART_Cmd(USART1,ENABLE);
    " I' ~8 j- G5 D1 W" B+ o
15.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    
16. }

复制代码

3，初始化DMA
库函数中DMA的结构体如下：

1. typedef struct
   
2. {
   2 ^- d# |% z0 E3 b6 o5 c. K& m8 ~
3.   uint32_t DMA_PeripheralBaseAddr; /*!< Specifies the peripheral base address for DMAy Channelx. */
   $ K5 y0 O  [% K9 Z0 C: @. p
4. 
   3 X' f' }4 u! O2 F
5.   uint32_t DMA_MemoryBaseAddr;     /*!< Specifies the memory base address for DMAy Channelx. */
   0 L# F1 S+ _+ j/ j2 e9 @- s
6. 
   
7.   uint32_t DMA_DIR;                /*!< Specifies if the peripheral is the source or destination.
   " O  C2 o% M/ k3 T3 ~) f$ w( n7 {
8.                                         This parameter can be a value of @ref DMA_data_transfer_direction */
   3 C, \- I& _! H. r! s8 f+ E
9. 
   
10.   uint32_t DMA_BufferSize;         /*!< Specifies the buffer size, in data unit, of the specified Channel.
    
11.                                         The data unit is equal to the configuration set in DMA_PeripheralDataSize
    - h: q4 W' O( t  C2 T$ B
12.                                         or DMA_MemoryDataSize members depending in the transfer direction. */
    1 _+ z( U+ f" ~; L5 ~
13. 
    
14.   uint32_t DMA_PeripheralInc;      /*!< Specifies whether the Peripheral address register is incremented or not.
    
15.                                         This parameter can be a value of @ref DMA_peripheral_incremented_mode */
    
16. 
    
17.   uint32_t DMA_MemoryInc;          /*!< Specifies whether the memory address register is incremented or not.
    
18.                                         This parameter can be a value of @ref DMA_memory_incremented_mode */
    
19. 
    6 N. p3 K7 G0 i0 n$ ?9 q
20.   uint32_t DMA_PeripheralDataSize; /*!< Specifies the Peripheral data width.
    3 Z8 [2 {* K% s
21.                                         This parameter can be a value of @ref DMA_peripheral_data_size */
    * C7 o  @, W2 r" A! S6 J1 e& y5 ]
22. 
    
23.   uint32_t DMA_MemoryDataSize;     /*!< Specifies the Memory data width.
    
24.                                         This parameter can be a value of @ref DMA_memory_data_size */
    
25. 
    
26.   uint32_t DMA_Mode;               /*!< Specifies the operation mode of the DMAy Channelx.
    
27.                                         This parameter can be a value of @ref DMA_circular_normal_mode.
    % H- K( o; Y1 ^( B  s
28.                                         @note: The circular buffer mode cannot be used if the memory-to-memory
    
29.                                               data transfer is configured on the selected Channel */
    
30. 
    ) r8 Q# s* o4 U( h+ Y1 r1 I
31.   uint32_t DMA_Priority;           /*!< Specifies the software priority for the DMAy Channelx.
    
32.                                         This parameter can be a value of @ref DMA_priority_level */
    * L' U# F( j% G" J0 W$ A
33. 
    
34.   uint32_t DMA_M2M;                /*!< Specifies if the DMAy Channelx will be used in memory-to-memory transfer.
    7 g/ @; V) X1 H+ g* A  e
35.                                         This parameter can be a value of @ref DMA_memory_to_memory */
    
36. }DMA_InitTypeDef;

复制代码

1. DMA_DIR

复制代码

这个是定义DMA的传输方向，DMA传输总共有三个方向，外设到内存，内存到外设，内存到内存（关于外设和内存可以这样简单理解，相当于一条路的两头）

, E- I* m- B' J  Z库函数中有两个定义：

1. #define DMA_DIR_PeripheralDST              ((uint32_t)0x00000010)
   5 B& N" [: v2 H) x; N6 x
2. #define DMA_DIR_PeripheralSRC              ((uint32_t)0x00000000)

复制代码

以DST结尾的那个，表示，以外设为目的地，以SRC结尾的那个，表示，以外设为起始点。
9 E) p6 y0 |$ k3 U7 F4 Z) F4 U3 i uint32_t DMA_PeripheralBaseAddr;这个是用来定义外设地址的
uint32_t DMA_MemoryBaseAddr;这个是用来定义内存地址的
$ C" a& g9 ^* H6 zuint32_t DMA_BufferSize;这个是指DMA通道的DMA 缓存的大小，这是为了照顾，两边的速率不一致。
, i- C8 K' c: C& l' y1 j; wuint32_t DMA_PeripheralInc;这个是用来定义外设地址是否要自增
uint32_t DMA_MemoryInc; 这个是用来定义内存地址是否要自增
9 E  s4 o5 _! nuint32_t DMA_PeripheralDataSize;用来制定外设的数据宽度
uint32_t DMA_MemoryDataSize;

这个是用来制定内存的数据宽度，当外设和存储器之间传数据时，两边的数据宽度应该设置为一样大小

uint32_t DMA_Mode;
% j: e7 s. E+ x" Z; `, y7 @
, v# A  R. r: p这个是用来指定DMA的工作模式，有一次传输和循环传输模式，两种。
. a. Z- |2 {% G5 T; S* @
uint32_t DMA_Priority;
7 S8 k; D/ o+ |! G
这个是用来指定DMA的优先级，有非常高，高，中，低四种。

3 d! ~  p* B1 t0 Y: y, q& w% e0 h# k3 duint32_t DMA_M2M; 这个是用来设置是否进行 内存到内存传输

初始化函数如下：
; s' X3 B- Q* Z: I7 P2 `1 Z

1. void Dma_Init()
   1 D1 k& v$ l+ Z3 m5 |  I
2. {
   7 \: `5 }+ S6 j, C$ p
3.         DMA_InitTypeDef dma;
   8 }4 Y& q/ Y, Z! K% r! t
4.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);//老规矩，先开心脏
   
5.         dma.DMA_MemoryBaseAddr = (u32)zimu;内存地址
   
6.         dma.DMA_PeripheralBaseAddr = (u32)zimu_1;外设地址
   
7.         dma.DMA_DIR = DMA_DIR_PeripheralDST;外设为目的地，即zimu_1数组为目的地
   ; E# R, F! X7 x( Y) h
8.        
   
9.         dma.DMA_BufferSize = 26;缓冲区大小
   
10.         dma.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;数据宽度
    3 q/ v8 l( D; k7 l6 M7 A
11.         dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;同上
    
12.        
    
13.         dma.DMA_MemoryInc = DMA_MemoryInc_Enabl;内存地址自增
    9 Y# u9 y& a9 t/ O2 J, s5 p
14.         dma.DMA_PeripheralInc = DMA_PeripheralInc_Enable;外设地址自增
    
15.        
    
16.         dma.DMA_Mode = DMA_Mode_Normal;单次模式
    
17.         dma.DMA_Priority = DMA_Priority_High;优先级为高
    
18.         dma.DMA_M2M = DMA_M2M_Enable;设置为内存到内存传输
    , N; I& s8 e" A7 K+ p3 Z
19.        
    
20.         DMA_Init(DMA1_Channel6,&dma);寄存器初始化
    
21.         DMA_Cmd(DMA1_Channel6,ENABLE);DMA使能
    ; o1 V2 I1 D+ J# P& y$ b3 y4 ]' ~- e
22. }

复制代码

0 n. G" F1 C7 G9 L$ S4，编写主函数

1. int main()
   
2. {
   $ }" j( L0 S9 o! _- b% k/ `  M
3.         void printf_string(char* a);
   $ P# S4 j0 u. d1 n0 s5 }0 v/ I4 \
4.         IO_Init();GPIO初始化
   
5.         Usart1_Init();USART1初始化
   
6.         Dma_Init();DMA初始化
   
7.         while(DMA_GetFlagStatus(DMA1_FLAG_TC6) == RESET){}//等待DMA操作完成，在参考手册的149页可以仔细看这个寄存器
   
8.        
   ' y: @7 W" y- h$ [8 ?, J# N7 K' B( F
9.         while(1){
   " P7 X  {# ]0 T. k/ `9 O
10.             if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))判断是否能用串口输出
    9 M* M  O" O: V( L, r, j7 F
11.                 {
    
12.                     printf_string(zimu_1);输出zimu_1数组
    - w4 ?/ y1 y& d
13.                     delay(3000);延时
    2 ?- p9 y" X2 ]/ T( |, f. x, s
14.                 }
    8 _/ y% q. T. V- D: ~& I/ t' R
15.         }
    & k7 }  }, l, x9 x6 g' L- K
16. }
    : w2 E3 W2 K+ N, f7 }
17. void printf_string(char* a)
    
18. {
    
19.         while(*a != '\0')直到数组末尾
    
20.         {
    
21.                 USART1->DR = *a;赋值给USART的数据寄存器
    " F$ O( R# p( h; D" m
22.                 while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));等待发送成功
    
23.                 a++;地址加一
    
24.         }
    
25. }

复制代码

" x1 ]  Y- r% R+ _) W本文到此结束，因博主水平有限，如有错误，敬请指出，不胜感激！


$ |, C- c0 V- U& U( f亲测，可运行。详细代码如下：

1. #include<stm32f10x.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4.        
   / B5 d+ L3 f6 L9 u- P, X9 Q( `
5. char zimu[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
   * y  \' r* H/ }
6. char zimu_1[32]={'.'};
   
7. void delay(uint n)
   
8. {
   " U, ?+ F8 }! @% |. W! S
9.         int i,j;
   5 C) K; C3 U& U# p, _( X7 T
10.         for(i=0;i<n;i++)
      C# k2 p2 \7 w( C( a# I4 K- {' b' r
11.         for(j=0;j<8500;j++);
    
12. }
    
13. 
    % u# a1 s1 N& l3 ~& J" O* P
14. void IO_Init()
    
15. {
    
16.         GPIO_InitTypeDef Uart_A;
    ' N) L/ b3 N: t% H
17.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
18.        
    ( e! X0 a. m+ E' M' L, m
19.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    
20.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
22.         GPIO_Init(GPIOA,&Uart_A);
    ; r8 i9 Z; P, ?: u% Y
23.        
    
24.         Uart_A.GPIO_Pin = GPIO_Pin_10;
      z1 c& o, ~: ]7 {& [
25.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
26.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING; //page 110
    * J4 u7 E+ D, `( R
27.         GPIO_Init(GPIOA,&Uart_A);
    / ~# e$ W& `) h5 G; ?
28.        
    
29. }
    
30. void Usart1_Init()
    6 W; z7 P' r2 x+ ?) R1 y; p8 c) T) q
31. {
    
32.         USART_InitTypeDef Uart;
    
33.        
    . u! P* |; ^. ]( B; f$ D+ @
34.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    
35.         Uart.USART_BaudRate = 115200;
    
36.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
      y' e  m% T$ y
37.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
38.         Uart.USART_Parity = USART_Parity_No;
    
39.         Uart.USART_StopBits = USART_StopBits_1;
    , C9 c" }! p1 @3 d8 c' \
40.         Uart.USART_WordLength = USART_WordLength_8b;
    
41.         USART_Init(USART1,&Uart);
    
42.        
    & }8 ]/ e4 H3 \* H
43.         USART_Cmd(USART1,ENABLE);
    ! o' ]% D9 }  Q- I
44.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    
45. }
    + H* k2 T" n. C
46. 
    
47. void Dma_Init()
    
48. {
    
49.         DMA_InitTypeDef dma;
    " l  H7 N1 D5 @
50.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    / U) W  [& z+ J) L7 U/ ?+ Q
51.         dma.DMA_MemoryBaseAddr = (u32)zimu;
    : Y% b' d% O7 E, I  ?7 q
52.         dma.DMA_PeripheralBaseAddr = (u32)zimu_1;
    : d$ s- E9 `' q
53.         dma.DMA_DIR = DMA_DIR_PeripheralDST;
    
54.        
    ) q5 t! x8 v8 k" {# q# {
55.         dma.DMA_BufferSize = 26;
    
56.         dma.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
    
57.         dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    
58.        
    
59.         dma.DMA_MemoryInc = DMA_MemoryInc_Enable;
    $ D: u8 Z0 _7 B$ ?; q) i& J- H
60.         dma.DMA_PeripheralInc = DMA_PeripheralInc_Enable;
    # e4 `1 C' I. }8 o% w/ [
61.        
    
62.         dma.DMA_Mode = DMA_Mode_Normal;
    " W% _' }2 H, F% a6 L+ t7 w
63.         dma.DMA_Priority = DMA_Priority_High;
    
64.         dma.DMA_M2M = DMA_M2M_Enable;
    
65.        
    . m' O7 t: x9 x" f  x( p
66.         DMA_Init(DMA1_Channel6,&dma);
    0 Z9 S+ S; ?& z" o
67.         DMA_Cmd(DMA1_Channel6,ENABLE);
    
68. }
    3 b, \& k2 J0 b& u# j& g! ?
69. int main()
    : Y" r1 j* g5 d% _: T/ I7 D
70. {
      ~; y2 n4 A% q) @! o, x' p, V
71.         void printf_string(char* a);
    
72.         IO_Init();
    
73.         Usart1_Init();
    8 K" H  H% a- E9 v
74.         Dma_Init();
    3 @8 {. A+ C1 {) |$ |1 p! p" @
75.        
    
76.         GPIOC->BSRR = GPIO_Pin_13;
    $ L: h5 P2 Y: q4 G+ D
77.        
    ; d% ]* ~- n: f+ U; c: G) C( @' g
78.         while(DMA_GetFlagStatus(DMA1_FLAG_TC6) == RESET){}
    4 p: R0 A, X3 E& E- O
79.        
    
80.         while(1){
    
81.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))
    2 l2 c+ i+ D/ n7 ?
82.         {
    
83.                 printf_string(zimu_1);
    
84.                 delay(3000);
    5 S, V) A0 L$ E: C" Y) W
85.         }
    
86.         }
    
87. }
    
88. void printf_string(char* a)
    
89. {
    * j$ G1 U0 @+ O* L) |
90.         //USART1->CR1 &= ~USART_CR1_TXEIE;
    
91.         USART1->CR1 |= USART_CR1_TXEIE;
    + n* t% {7 Z, }7 w
92.         while(*a != '\0')
    6 V+ o4 k% w' X/ R6 X
93.         {
    & j$ ~8 p8 G8 ^8 P! D" P; Z
94.                 USART1->DR = *a;
    
95.                 while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    
96.                 a++;
    : F. o6 E; }4 Z( J5 H/ h# Z
97.         }
    
98. }

复制代码

: u& [: J* ?; L0 n————————————————
版权声明：家安

" g& N! d& }( \7 p! y3 {