突然想测试一下STM32单片机ADC采样速率问题，按照常规方法，可以通过ADC采样，然后将采样值打印出来。但是这种方法在处理和打印数据的时候会占用很多时间，导致处理数据的时间超过了ADC的采样时间。于是想到了ADC采样的数据用DMA功能存储，并通过串口打印。但是串口打印依然要占用单片机时间，那能不能串口数据的输出也采用 DMA功能呢？这样ADC采样的数据通过DMA直接存储，然后串口通过DMA功能直接输出采样到的数据。这样速度程序执行速度不就极大的提升了吗？说干就干，使用STM32F103C8T6单片机，标准库函数，keil5软件，编写一个测试程序。
; |4 P) S: Y5 A. w9 p
7 H0 a8 B9 x$ M6 [3 K( _      首先实现ADC采样并通过DMA存储
, `+ d5 v. G% W9 @6 j4 P

1. #ifndef __ADC_H
   
2. #define        __ADC_H
   + l% G6 b2 J* c" H, C4 }
3. 
   
4. #include "stm32f10x.h"
   4 B% D" P$ p7 a5 i( x2 V+ K
5. // 注意：用作ADC采集的IO必须没有复用，否则采集电压会有影响
   
6. /********************ADC1输入通道（引脚）配置**************************/
   
7. #define    ADC_APBxClock_FUN             RCC_APB2PeriphClockCmd
   $ A, Y( z" q1 u+ v3 G" Z
8. #define    ADC_CLK                       RCC_APB2Periph_ADC1
   
9. 
   & |# u4 X9 C- b& O4 ?3 K1 i: g  T+ f
10. #define    ADC_GPIO_APBxClock_FUN        RCC_APB2PeriphClockCmd
    
11. #define    ADC_GPIO_CLK                  RCC_APB2Periph_GPIOA
    
12. #define    ADC_PORT                      GPIOA
    9 h8 \2 H  g2 Y/ [! [6 u
13. 
    + S5 X; l5 M: J4 }
14. #define    NOFCHANEL                                         1                                                        //使用一个通道测试
    
15. 
    
16. #define    ADC_PIN1                      GPIO_Pin_0
    
17. #define    ADC_CHANNEL1                  ADC_Channel_0
    & O) i# g% y! C3 @6 x
18. 
    
19. // ADC1 对应 DMA1通道1，ADC3对应DMA2通道5，ADC2没有DMA功能
    5 v8 [( \$ _7 W
20. #define    ADC_x                         ADC1
    & I9 J( \. n. s% ^6 A
21. #define    ADC_DMA_CHANNEL               DMA1_Channel1
    & \7 u8 n* Y" I
22. #define    ADC_DMA_CLK                   RCC_AHBPeriph_DMA1
    
23. 
    + d1 A. Q1 X: R9 P8 r
24. // ADC1转换的电压值通过MDA方式传到SRAM
    - Z6 P* [, y6 e* m7 R
25. extern __IO uint16_t ADC_ConvertedValue[NOFCHANEL];
    
26. 
    
27. /**************************函数声明********************************/
    
28. void               ADCx_Init                               ( void );
    * L/ o! J# w9 Q# |: P
29. #endif /* __ADC_H */

复制代码

5 u; ]0 x# Z/ g" `; J/ I首先在头文件中定义用到的时钟和端口,如果要修改采样的AD口时，直接在头文件中修改就行，程序中就不需要修改了，方便代码的移植。下面编写ADC代码。

/ ^' ?. ]; o1 |

1. #include "bsp_adc.h"
   ; D- p- @2 c5 D* a0 }. i
2. __IO uint16_t ADC_ConvertedValue[NOFCHANEL] = {1000};
   % j2 L; J, b! b. [( @- E% L
3. /**
   5 W$ g- u- \& e1 l8 B+ O
4.   * @brief  ADC GPIO 初始化
   
5.   * @param  无
   
6.   * @retval 无
   3 U# j8 O# v8 _* _( [& g
7.   */
   
8. static void ADCx_GPIO_Config( void )
   8 w* M+ J+ H) k
9. {
   . p0 |' t( [0 F
10.     GPIO_InitTypeDef GPIO_InitStructure;
    
11.     // 打开 ADC IO端口时钟
    
12.     ADC_GPIO_APBxClock_FUN ( ADC_GPIO_CLK, ENABLE );
    2 B5 ]  `. x8 z' \
13.     // 配置 ADC IO 引脚模式
    
14.     GPIO_InitStructure.GPIO_Pin =         ADC_PIN1;
    
15.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
    
16.     // 初始化 ADC IO
    * F! c0 U5 Y. a$ W: W/ y
17.     GPIO_Init( ADC_PORT, &GPIO_InitStructure );
    ' c3 L, ^7 V3 v" S
18. }
    
19. /**
    
20.   * @brief  配置ADC工作模式
    1 h! B1 b  G  U+ E! v8 E) n3 f
21.   * @param  无
    ! e# E# i  {  r+ \& `9 W) T
22.   * @retval 无
      F) a& ~# }. L! e
23.   */
    , f- @) c& k/ ^0 G
24. static void ADCx_Mode_Config( void )
    
25. {
    ) N8 i3 g5 O( n7 i, r; s8 b  C
26.     DMA_InitTypeDef DMA_InitStructure;
    
27.     ADC_InitTypeDef ADC_InitStructure;
    
28. 
    . }- b0 u+ c3 {1 B9 m
29.     // 打开DMA时钟
    * r, ~& `3 [$ `% Y) _$ R! q. }; R
30.     RCC_AHBPeriphClockCmd( ADC_DMA_CLK, ENABLE );
    " |0 p! w/ C) z8 l
31.     // 打开ADC时钟
    9 j' e1 h' u" Z9 \9 z/ J/ \" b
32.     ADC_APBxClock_FUN ( ADC_CLK, ENABLE );
    
33.     // 复位DMA控制器
    6 Q, L; u4 P4 P! k* [
34.     DMA_DeInit( ADC_DMA_CHANNEL );
    . q0 j% j( T% x' f+ z
35.     // 配置 DMA 初始化结构体
    : h0 Q& @# X* h" Y7 ~; g
36.     // 外设基址为：ADC 数据寄存器地址
    / q& c( W; G% D* i8 F+ a
37.     DMA_InitStructure.DMA_PeripheralBaseAddr = ( u32 ) ( & ( ADC_x->DR ) );
    
38.     // 存储器地址
    
39.     DMA_InitStructure.DMA_MemoryBaseAddr = ( u32 )ADC_ConvertedValue;
    
40.     // 数据源来自外设
    - |' @" }" q" g# e' \1 h. {
41.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    % ^) ]# N. T; A+ }  _! Z
42.     // 缓冲区大小，应该等于数据目的地的大小
    
43.     DMA_InitStructure.DMA_BufferSize = NOFCHANEL;
    
44.     // 外设寄存器只有一个，地址不用递增
    
45.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    
46.     // 存储器地址递增
    
47.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    ) ~" f8 C5 E5 q* e* n& y
48.     // 外设数据大小为半字，即两个字节
    
49.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    
50.     // 内存数据大小也为半字，跟外设数据大小相同
    
51.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    
52.     // 循环传输模式
    
53.     DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    * O7 m/ p3 y/ u& W6 u
54.     // DMA 传输通道优先级为高，当使用一个DMA通道时，优先级设置不影响
    
55.     DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    
56.     // 禁止存储器到存储器模式，因为是从外设到存储器
    
57.     DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    
58.     // 初始化DMA
    8 @5 m  X. M6 {# ?0 G
59.     DMA_Init( ADC_DMA_CHANNEL, &DMA_InitStructure );
    7 V3 R# `1 w% s( v8 M
60.     // 使能 DMA 通道
    
61.     DMA_Cmd( ADC_DMA_CHANNEL, ENABLE );
    
62.     // ADC 模式配置
    : G2 Q3 H6 i/ B7 q  X$ Y
63.     // 只使用一个ADC，属于单模式
    0 }- s( ?7 ?4 p& O5 t
64.     ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
    
65.     // 扫描模式
    % R: y' B7 E2 F- |8 r0 I
66.     ADC_InitStructure.ADC_ScanConvMode = ENABLE ;
    
67.     // 连续转换模式
    
68.     ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
    / U$ \9 `7 C  b. V$ i
69.     // 不用外部触发转换，软件开启即可
    " K7 s! B, e9 a6 V# G% Y
70.     ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    9 j; k# V. H0 p
71.     // 转换结果右对齐
    
72.     ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    
73.     // 转换通道个数
    2 M% M" w& |  ?. |7 `, s
74.     ADC_InitStructure.ADC_NbrOfChannel = NOFCHANEL;
    7 M+ D$ Q5 C) O+ e4 l5 p
75.     // 初始化ADC
    + ^$ l* h7 ~$ b6 f3 G" d  L7 r
76.     ADC_Init( ADC_x, &ADC_InitStructure );
    
77.     // 配置ADC时钟Ｎ狿CLK2的8分频，即9MHz
    
78.     RCC_ADCCLKConfig( RCC_PCLK2_Div8 );
    6 D% e! w0 m& B0 C5 D1 Q5 @
79.     // 配置ADC 通道的转换顺序和采样时间
    
80.     ADC_RegularChannelConfig( ADC_x, ADC_CHANNEL1, 1, ADC_SampleTime_55Cycles5 );
    + I' o: z0 I7 q$ s- G6 D5 C
81.     // 使能ADC DMA 请求
    3 f/ K' E" ]1 S: R
82.     ADC_DMACmd( ADC_x, ENABLE );
      b9 s5 ]+ r& V$ w. V, x1 w5 c' n( N
83.     // 开启ADC ，并开始转换
    
84.     ADC_Cmd( ADC_x, ENABLE );
    7 H3 {! G2 G8 c
85.     // 初始化ADC 校准寄存器
    & I2 ]& [. b. l2 c% [
86.     ADC_ResetCalibration( ADC_x );
    , ~- J8 a- q. }
87.     // 等待校准寄存器初始化完成
    % R, `! a0 M% p# g
88.     while( ADC_GetResetCalibrationStatus( ADC_x ) );
    
89.     // ADC开始校准
    " N! _) E3 v0 T- Y2 V
90.     ADC_StartCalibration( ADC_x );
    2 e% I3 x& g: G* S
91.     // 等待校准完成
    
92.     while( ADC_GetCalibrationStatus( ADC_x ) );
    
93.     // 由于没有采用外部触发，所以使用软件触发ADC转换
    9 L) K: V' [! r& |
94.     ADC_SoftwareStartConvCmd( ADC_x, ENABLE );
    
95. }
    
96. /**
    ' m, D6 I. a+ x; _- G
97.   * @brief  ADC初始化
    1 h' A" R# N6 {, b; [" K
98.   * @param  无
    
99.   * @retval 无
    
100.   */
     
101. void ADCx_Init( void )
     " T+ u/ r  z7 {+ z
102. {
     
103.     ADCx_GPIO_Config();
     
104.     ADCx_Mode_Config();
     
105. }
     
106. /*********************************************END OF FILE**********************/

复制代码

+ `) r; a% I3 o! ]        设置ADC为DMA传输，将采样的数据由DMA自动存储到 ADC_ConvertedValue[ ] 数组中，这里虽然只使用了一个ADC采样通道，但是定义了一个数组来存放采样结果，如果想要实现多通道采样值，只需要将其他通道的初始化代码添加上，同时将数组长度，也就是通道数修改一下就可以使用了。初始化ADC和DMA后，ADC采样并通过 DMA传输的功能就可使用了。然后串口输出数据的时候直接从ADC的采样结果的数组中取值就可以了。
5 g. g  m$ J: M& F
      下面编写串口相关代码

1. #ifndef __USART_H
   
2. #define        __USART_H
   
3. 
   ; N0 ^: j: _+ j* O
4. #include "stm32f10x.h"
   
5. #include <stdio.h>
   . u0 m* b2 l) [+ t( A3 I
6. // 串口1-USART1
   , m4 V* i6 P  q* _" Q
7. #define  DEBUG_USARTx                   USART1
   
8. #define  DEBUG_USART_CLK                RCC_APB2Periph_USART1
   
9. #define  DEBUG_USART_APBxClkCmd         RCC_APB2PeriphClockCmd
   . v, {/ q( d) A. H: y" }0 o
10. #define  DEBUG_USART_BAUDRATE           921600
      \' c7 ?7 i8 e! y& G7 q/ V: S$ u
11. 
    
12. // USART GPIO 引脚宏定义
    7 j% h7 n" H% D- E" z$ P4 i
13. #define  DEBUG_USART_GPIO_CLK           (RCC_APB2Periph_GPIOA)
    ) O. q7 _9 @) j! F6 C
14. #define  DEBUG_USART_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
    
15. 
    
16. #define  DEBUG_USART_TX_GPIO_PORT       GPIOA
    
17. #define  DEBUG_USART_TX_GPIO_PIN        GPIO_Pin_9
    
18. #define  DEBUG_USART_RX_GPIO_PORT       GPIOA
    5 `% v% X' n; j/ o. |) k
19. #define  DEBUG_USART_RX_GPIO_PIN        GPIO_Pin_10

复制代码

将串口的端口和时钟也使用宏定义的方式，如果要改为其他串口输出时，直接修改头文件就行。下来初始化串口。

3 F! {5 R4 B) e3 G

1. void USART_Config( void )
   4 @5 y3 T. j: h, q3 e4 {; z: B: C
2. {
   . |/ E# s' x6 d  a
3.     GPIO_InitTypeDef GPIO_InitStructure;
   
4.     USART_InitTypeDef USART_InitStructure;
   
5. 
   - O# Y+ h7 @$ p$ `
6.     // 打开串口GPIO的时钟
   
7.     DEBUG_USART_GPIO_APBxClkCmd( DEBUG_USART_GPIO_CLK, ENABLE );
   ! M" D/ P( ~6 g4 \/ ^: {3 F! e& B  j
8. 
   
9.     // 打开串口外设的时钟
   
10.     DEBUG_USART_APBxClkCmd( DEBUG_USART_CLK, ENABLE );
    # z8 W8 |: J0 X
11. 
    
12.     // 将USART Tx的GPIO配置为推挽复用模式
    & S' a! K& ^* i" Z  U
13.     GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
    ) `6 e) F+ U3 a$ _8 d
14.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    * K  \. c8 m* `/ K
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    % ]# o, c' w5 q2 R* ^) ?- y, J7 a  |
16.     GPIO_Init( DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure );
    5 u3 Z" k$ |& w; e0 X( A% W
17. 
    : b4 q0 z5 X! ^- U& N- K
18.     // 将USART Rx的GPIO配置为浮空输入模式
    
19.     GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
    ) W/ A% C# s: o' S! m, Y
20.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
21.     GPIO_Init( DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure );
    
22. 
    
23.     // 配置串口的工作参数
    6 m% O" \" p) p% ^- E" ?3 J$ w
24.     // 配置波特率
    
25.     USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
    
26.     // 配置 针数据字长
    ( ]$ i- P- }9 s9 u' I
27.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    2 S( q: U" H" ?; e8 }0 f6 x
28.     // 配置停止位
    8 J( y( ?9 ]& Z4 w9 Z8 p
29.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
30.     // 配置校验位
    1 K( a1 ], Y8 Y/ o
31.     USART_InitStructure.USART_Parity = USART_Parity_No ;
    & a! r+ U5 ]2 G
32.     // 配置硬件流控制
    
33.     USART_InitStructure.USART_HardwareFlowControl =
    ( X/ s& G/ Y( `+ J0 |: n) ]% |
34.         USART_HardwareFlowControl_None;
    + e1 L2 x% b( }" q
35.     // 配置工作模式，收发一起
    ; [/ q3 J) V/ H' J% f
36.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
37.     // 完成串口的初始化配置
    9 i, G# t. e  @5 H4 e
38.     USART_Init( DEBUG_USARTx, &USART_InitStructure );
    
39. 
    
40.     // 使能串口
    6 ^& s9 [5 F! Y: E
41.     USART_Cmd( DEBUG_USARTx, ENABLE );
    
42. }

复制代码

: a* u& V% d- p下来设置串口为DMA输出
- Z' U# G3 e5 r! Q, f

1. #ifndef __DMA_H
   $ a  _9 _$ x4 O/ }
2. #define __DMA_H
   9 P* Z* D/ [1 U6 [
3. #include "stm32f10x.h"
   * C. ]& F/ b! `# t2 \: O6 _) j" {4 t5 v
4. // 串口对应的DMA请求通道
   ; B4 e" f- A: q5 P3 K# o
5. #define  USART_TX_DMA_CHANNEL     DMA1_Channel4
   - q: _! u; P5 o) I
6. // 外设寄存器地址
   8 Z7 ^  I9 u3 t5 l: E* Z2 N
7. //#define  USART_DR_ADDRESS        (USART1_BASE+0x04)                        //使用地址偏移值
   6 I* }( A& v' T/ V
8. #define  USART_DR_ADDRESS        ((u32)&USART1->DR)                                //直接使用寄存器地址
   : ?" p& c: |5 V- f
9. // 一次发送的数据量
   & V! z$ F' ^& u3 {7 O
10. #define  SENDBUFF_SIZE            6
    
11. extern  uint8_t SendBuff[SENDBUFF_SIZE];
    3 ]  T) [6 S1 n( }( L# c
12. void USARTx_DMA_Config(void);
    
13. void USARTx_DMA_Restart( void );
    3 n' D. C: U* i) v4 v5 @' Z
14. #endif

复制代码

; w6 h1 m* `0 [) \/ i       在头文件中定义串口发送端的 DMA通道，将串口数据寄存器作为DMA源地址，将SendBuff[ ]数组中的内容作为内存地址，数据方向为内存到源，这样就直接将SendBuff[ ]数组中的数据通过DMA直接传输到了串口中。

: g' e, ?/ H/ [( w! G4 j. B0 F: i

1. void USARTx_DMA_Config(void)
   * O/ X4 e/ w; S1 u
2. {
   1 g0 c. \4 g4 J! _& O5 C
3.                 DMA_InitTypeDef DMA_InitStructure;        
   % g; j& B3 l" N. V
4.                 // 开启DMA时钟
   + J3 p: l! k, _. ]
5.                 RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
   
6.                 // 设置DMA源地址：串口数据寄存器地址*/
   8 [( a6 U1 `! l) d3 V; q- U
7.         DMA_InitStructure.DMA_PeripheralBaseAddr = USART_DR_ADDRESS;
   
8.                 // 内存地址(要传输的变量的指针)
   2 s3 b( V2 b6 y, B: X  L$ S  `! f3 X8 H
9.                 DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
   
10.                 // 方向：从内存到外设        
    
11.                 DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    ( V- p" Q( b. |7 D9 h" _
12.                 // 传输大小         
    ' z2 x7 r* i; Q! \4 y+ j
13.                 DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE ;
    ; x5 c' d4 a! ^) B7 @- S
14.                 // 外设地址不增            
    
15.                 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    
16.                 // 内存地址自增
    ! ~! x6 {. p9 v( j! {
17.                 DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    
18.                 // 外设数据单位        
    & A% |; v; [* S( w7 u" u) k+ r
19.                 DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    # a, v  J. H& G! ?- F
20.                 // 内存数据单位
    " h6 O- U: N: e. d
21.                 DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;         
    
22.                 // DMA模式，一次或者循环模式
    
23.                 DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;                                                        //发送一次数据
    
24.                 //DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;                                                //循环发送数据
    ( ^1 k8 f# E, F2 l0 S+ [) W
25.                 // 优先级：中        
    ( u; A8 O! ?+ n1 i& |
26.                 DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
    
27.                 // 禁止内存到内存的传输
    5 F% S+ _9 b: H( I$ G! T6 d
28.                 DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    6 L' e5 t+ K9 _& S) |$ E
29.                 // 配置DMA通道                  
    5 q9 O$ T( h; X0 D) r# ^$ f
30.                 DMA_Init(USART_TX_DMA_CHANNEL, &DMA_InitStructure);               
    
31.                 // 使能DMA
    4 x) a1 C3 ^. Q  f" [8 q
32.                 DMA_Cmd (USART_TX_DMA_CHANNEL,ENABLE);
    ' d" v* a1 r( x( u" r7 Q5 s, q
33. }
    7 R% B' H0 F! E5 e
34. //重新启动串口 DMA
    
35. void USARTx_DMA_Restart( void )
    
36. {
    
37.     //重新开启DMA传输
    , p! S/ V3 ~) a2 F* h! ?
38.     DMA_Cmd( USART_TX_DMA_CHANNEL, DISABLE );
    4 v! R1 f8 p1 ]+ }- \1 k
39.     DMA_SetCurrDataCounter( USART_TX_DMA_CHANNEL, SENDBUFF_SIZE ); //重新设置传输的数据数量
    
40.     DMA_Cmd( USART_TX_DMA_CHANNEL, ENABLE );                       //开启DMA传输
    
41. }

复制代码

, _+ c2 V" b! P- H) j        将DMA传输设置为单次传输模式，因为转换后的数据为16进制数据，为了方便在串口助手上观看数据，需要将16进制转换为字符串打印出来，所以每次每次在串口DMA传输数据的前，将数据转换为字符串，然后再打开 DMA传输功能，将数据通过串口发送出去。所以DMA传输时不能设置为循环发送，需要每次将数据格式转换完成后才能发送。发送完一次数据后，需要重新设置DMA传输数据的数量，然后重新启动一次 DMA传输。

1. int main( void )
   ! N) b. J) i3 I7 u6 K! J. |% \
2. {
   
3.     char str[5];
   % g7 Z7 L6 [, F/ g. t) I
4.     /* LED 端口初始化 */
   ' I6 \) C8 C* L/ _6 d1 y
5.     LED_GPIO_Config();
   
6.     /*初始化USART 配置模式为 115200 8-N-1，中断接收*/
   : W% w: ?) F" E
7.     USART_Config();
   
8.     ADCx_Init();
   
9.     /* DMA传输配置 */
   
10.     USARTx_DMA_Config();
    $ q7 G) E2 K1 v2 ]
11. 
    
12.     /* USART1 向 DMA发出TX请求  单次发送模式 */
    
13.     USART_DMACmd( DEBUG_USARTx, USART_DMAReq_Tx, ENABLE );
    & P+ f- N9 }* h+ t; K
14.     //串口发送缓冲区后面添加回车换行符
    - ]- q& m" X( \! N
15.     SendBuff[4] = '\r';
    
16.     SendBuff[5] = '\n';
    7 |7 s( W5 [! w' b5 C) ~; v, i4 F
17.     while ( 1 )
    4 j& i0 d6 q- {% U0 U
18.     {
    
19.         //填充数据 只打印通道1数据
    
20.         sprintf( str, "%d", ADC_ConvertedValue[0] );                //将通道1采样值转换为字符串类型
    
21.         SendBuff[0] = str[0];                                                                                                                //将字符串数据存入串口DMA发送缓存区
    
22.         SendBuff[1] = str[1];
    
23.         SendBuff[2] = str[2];
    3 w* F4 {( s* g8 T8 q4 m
24.         SendBuff[3] = str[3];
    ; k0 L) _6 }5 [- G
25.         USARTx_DMA_Restart();
    5 j; ]* k# J- Q9 I& x7 i
26. 
    # V* X7 h! g% a! Q8 d- @$ k# b
27.         SysTick_Delay_Us( 45 );
    
28.     }
    
29. }

复制代码

) K/ B( z& v- T5 C( A& Y: P. [        STM32F103单片机的AD为12位，采样值的范围为0---4095，转换为字符串后最多为4位，再加上回车换行符，总共6个字符。这样串口DMA传输数据的长度就为6位。

为了测试 DMA传输的最大速度，将串口波特率设置为921600。下面开始测试代码，用函数发生器产生一个0--2V的正弦波，频率为100HZ。然后通过串口助手观察采样的数据。
3 E+ b1 _# X+ t6 ]" c
/ p4 }" G9 i$ D$ y+ Z6 |" O# o
9 f+ N1 |, s! {6 [% o8 q$ Q
通过串口波形显示助手观察输出的数据波形如下


# i/ F) b5 @& D1 G$ k
通过上面测试可以看出，在STM32F103C8T6单片机上成功实现了ADC的 DMA采集，和串口DMA发送功能。
. ]- R) v+ j7 l$ D$ E: W
  u2 S/ U6 u( {& s, ~