在日常中，串口经常作为和上位机通信的接口，进行打印信息方便调试程序，有时也会作为模块的驱动接口，所以总结一下串口的几种使用方法对以后的开发还是很有帮助的。

一.仅向上位机打印调试信息
5 l$ y5 `& Q0 @3 _6 ~9 L2 {2 ]7 z单纯利用串口向上位机打印调试信息，程序如下：
) s3 A- I9 K5 _3 G- p3 i0 e0 @! ]

1. void USART1_Init( uint32_t btl )
   
2. {
   
3.         GPIO_InitTypeDef  GPIO_InitStruct;
   
4.         USART_InitTypeDef USART_InitStruct;
   
5.        
   
6.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE );
   ) z/ N; H+ V% y2 n, X( `
7.        
   
8.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
   
9.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;//Tx
   
10.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    9 t1 H1 \8 ?) I; h
11.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    
12.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;//Rx
    , y$ ]! B8 B1 s5 B0 z
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
14.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    0 ~4 G2 d- T; _, b0 G# F
15.        
    . Q% G) @& W7 O0 j6 u. b
16.         USART_InitStruct.USART_BaudRate = btl;
    
17.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
18.         USART_InitStruct.USART_Mode = USART_Mode_Tx;
    2 [' T4 B8 ?9 W2 f2 m, L' c
19.         USART_InitStruct.USART_Parity = USART_Parity_No;
      q4 \, d- E) ^/ c& I0 x
20.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
    
21.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    
22.         USART_Init( USART1, &USART_InitStruct );
    
23.        
    3 j9 ~0 Q2 U  U8 z
24.         USART_Cmd( USART1, ENABLE );
    $ O2 Y2 f& w3 y
25.        
    
26. }
    + J* D- A& P& c# @$ q5 z
27. 
    
28. //串口重定向，直接利用printf函数输出调试信息
    $ C! O: y) W, |. b
29. int fputc( int ch, FILE *f )
    
30. {
    ) u( X( o& |; Z' F6 q4 i* q
31.         USART_SendData( USART1, ( uint8_t )ch );
    0 _, Q. ^8 `* P/ A
32.         while( USART_GetFlagStatus( USART1, USART_FLAG_TXE )!=SET );
    
33.         return ch;
    , {3 w- c+ {: Z- z
34. }
    
35. 
    
36. 
    * Y" H+ g7 X9 d( O2 l# w' d# \

复制代码

6 Q+ g# t% I& L记得包含头文件，勾选Use MicroLIB，以使用printf等函数
; d* ^5 Q% g4 l7 a

7 m9 v! M) w4 X0 G3 ]) i
2 E, d5 n% v* g# T# Q& N
二.与上位机交互信息
相比于上面的单向通信，有时候需要从上位机接收信息，然后进行反馈，这个时候就使用到串口的中断了。
9 |( _8 J6 P  x$ C上位机向单片机发送字符串，接收后再发送给上位机：

1. 
   9 r# k" N3 a0 W! Z
2. void USART1_Init( uint32_t btl )
   
3. {
   6 e2 A& M6 `  K4 h1 W* C. h
4.         /* 结构体声明 */
   ( ]& z6 R  w0 [, F! L$ s
5.         GPIO_InitTypeDef  GPIO_InitStruct;
   . Y4 _" \# \3 ?6 i* Z' y" v7 o$ Z
6.         USART_InitTypeDef USART_InitStruct;
   
7.         NVIC_InitTypeDef NVIC_InitStruct;
   ! S# {0 t3 M- U" _1 t* d. {% M
8.        
   ' C, ^! T9 ?8 u0 [- N3 P. v9 r5 h
9.         /* 打开时钟 */
   
10.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    
11.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1, ENABLE );
    
12.        
    " S: _0 t; l" P! |
13.         /* GPIO配置 */
    
14.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    
15.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;//Tx
    0 X$ P) H% j& B+ w0 A: C5 Z! t
16.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
17.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    3 `' r6 t6 W$ M; @+ r
18.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;//Rx
    
19.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    ' `4 ~7 c$ D4 ?$ T; n
20.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    3 p: D6 @7 q/ D% I* e
21.        
    
22.         /* 串口配置 */
    
23.         USART_InitStruct.USART_BaudRate = btl;
    , T3 x# m& f; A/ j8 g
24.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    2 [/ a7 |9 b% I# h
25.         USART_InitStruct.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;//收发模式
    
26.         USART_InitStruct.USART_Parity = USART_Parity_No;
    
27.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
    
28.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    
29.         USART_Init( USART1, &USART_InitStruct );
    
30.        
    4 L3 _# e7 a6 x
31.         /* 中断配置 */
    
32.         NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
    
33.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=3 ;
    
34.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 3;               
    % n& `! ^' e2 b: W& I, R, e
35.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;                       
    2 q1 f7 E3 X3 a, G4 y
36.         NVIC_Init(&NVIC_InitStruct);       
    % X% O+ f  e0 J/ D1 c
37.         USART_ITConfig( USART1, USART_IT_RXNE, ENABLE );//接收寄存器非空触发中断
    
38.        
    , f# M& w3 i" u  E' n5 @0 m+ x
39.         /* 使能串口 */
    
40.         USART_Cmd( USART1, ENABLE );
    
41.        
    
42. }
    
43. 
    
44. 
    
45. volatile uint8_t n=0;
    
46. //接收缓冲区
    
47. uint8_t USART1_Rx_Buf[100];
    
48. void USART1_IRQHandler( void )
    
49. {
    
50.         if( USART_GetITStatus( USART1, USART_IT_RXNE )==SET )
    
51.         {
    
52.                         USART1_Rx_Buf[n]=USART_ReceiveData( USART1 );
    
53.                         n++;
    " u) R; l/ `! v! |# y
54.         }       
    
55.         USART_ClearFlag( USART1, USART_IT_RXNE );
    5 q& p: t% @7 n9 ?
56. }
    

复制代码

每从上位机中接收一字节的数据，都将数据存储在串口的接收缓冲区USART1_Rx_Buf[100]中。

; J# M( U, d( s. G3 M# {
; I# H6 N( {9 W三.作为驱动接口
一些模块的驱动接口就是串口，这个时候就需要单片机从模块中读取指定格式的数据，比如GPS模块，将定位信息从串口发出，单片机解析串口数据，显示在上位机中。
usart3用来与GPS模块通信，从GPS模块接收数据，认为10ms内的数据属于一次数据，所以就需要定时器来控制时间。
, K+ M$ r% r2 rusart3：
' A4 T! S( v2 ?3 U! S! e

1. //串口1中断服务程序
   
2. //注意,读取USARTx->SR能避免莫名其妙的错误          
   ) p. O4 s7 f+ z2 f+ S( J' A
3. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
   2 y: U* l% e8 U% b4 _
4. //接收状态
   
5. //bit15，        接收完成标志
   9 A4 y3 k  T% h7 Q5 ]
6. //bit14，        接收到0x0d
   
7. //bit13~0，        接收到的有效字节数目
   
8. u16 USART_RX_STA=0;       //接收状态标记          
   # X9 @- ~4 `* n8 S7 k8 K" U: l' @5 @
9.   
   
10. void uart_init(u32 bound){
    4 d7 `4 s$ {6 J, w. l7 ^
11.   //GPIO端口设置
    
12.   GPIO_InitTypeDef GPIO_InitStructure;
    
13.         USART_InitTypeDef USART_InitStructure;
    6 k( K6 F( B2 ]# f. s2 O& }: |# x( Z! }
14.         NVIC_InitTypeDef NVIC_InitStructure;
    
15.        
    
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    
17.   
    
18.         //USART1_TX   GPIOA.9
    ) l% h# }, X9 _' ]+ @& t
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    9 o, Z7 G6 A. X
20.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
21.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    
22.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    6 ]1 b  G" g! Y3 H/ z% s
23.    
    
24.   //USART1_RX          GPIOA.10初始化
    
25.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    
26.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    6 Q5 `2 c2 A, ?! v/ G2 R: H
27.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    
28. 
    
29.   //Usart1 NVIC 配置
    : q( z* ]5 x' c1 X( W( r4 Y
30.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    # p( ~/ v( k. n8 |
31.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    2 c$ J) O) l  @" A; @
32.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    2 y/ x- ?9 U/ C: x6 |& b% K
33.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
      A: C" |5 _# q  |- ?
34.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
35.   
    0 Z% G7 [2 _0 P( I$ P/ a) I+ `4 }
36.    //USART 初始化设置
    5 ~$ i& P0 V% O+ X
37. 
    
38.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    + o0 ^. `9 X, Z- c; c; t
39.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    ( A3 `0 `0 r7 l- `: c% H9 f
40.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
41.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
42.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    + `8 F9 Y% y. S4 Z  ?
43.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    $ ]4 j, m+ `: V' X
44. 
    - N4 \5 r7 M; H! u. b
45.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    
46.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    + I0 v/ e. {" u; {6 x0 _
47.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    : _6 f6 K1 g* `, u( k8 V
48. 
    
49. }
    
50. 
    
51. void USART1_IRQHandler(void)                        //串口1中断服务程序
    
52.         {
    6 F; }# p7 E7 ^" k4 u
53.         u8 Res;
    
54. 
    6 V+ ~3 K1 T% Z4 P( e# v
55.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    
56.                 {
    , q& |$ V% e5 b* }5 @
57.                 Res =USART_ReceiveData(USART1);        //读取接收到的数据
    4 o( Q5 p; k" ~3 S! m# \
58.                
    ; u/ u$ P) m& i" W
59.                 if((USART_RX_STA&0x8000)==0)//接收未完成
      X: }7 [/ P; K7 Z
60.                         {
    
61.                         if(USART_RX_STA&0x4000)//接收到了0x0d
    / U) x$ r' `: k6 b( p
62.                                 {
    
63.                                 if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
    
64.                                 else USART_RX_STA|=0x8000;        //接收完成了
    8 P" z; d) u8 q. ?! `
65.                                 }
    
66.                         else //还没收到0X0D
    
67.                                 {       
    
68.                                 if(Res==0x0d)USART_RX_STA|=0x4000;
    
69.                                 else
    
70.                                         {
    
71.                                         USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
    
72.                                         USART_RX_STA++;
    
73.                                         if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收          
    ' R1 e3 G1 m$ E  c
74.                                         }                 
    
75.                                 }
    
76.                         }                    
    
77.      }
    
78. }
    
79. 
    

复制代码

6 ?7 x/ {& @9 D. T7 l% o; U  Btime7：

1. 
   
2. extern vu16 USART3_RX_STA;
   ; y  e# ^" p# Y5 w  Q+ `' \1 e
3. 
   $ G+ Y6 ]# i( z5 ~( j7 I( o9 G: m
4. //定时器7中断服务程序                    
   2 s5 j% {. i% ^, A+ Z" T
5. void TIM7_IRQHandler(void)
   * T1 I7 J, b7 D/ V; r/ R; y
6. {        
   6 h4 r3 G/ Q: F9 E2 f4 ?
7.         if (TIM_GetITStatus(TIM7, TIM_IT_Update) != RESET)//是更新中断
   4 C  M1 w9 g: K' I! `
8.         {                                   
   
9.                 USART3_RX_STA|=1<<15;        //标记接收完成
   
10.                 TIM_ClearITPendingBit(TIM7, TIM_IT_Update  );  //清除TIM7更新中断标志   
    
11.                 TIM_Cmd(TIM7, DISABLE);  //关闭TIM7
    
12.         }            
    * }# I% `' V. a0 B3 Y4 l
13. }
    
14. 
    " O7 n+ u  P4 o0 `1 B: `
15. //通用定时器7中断初始化
    
16. //这里时钟选择为APB1的2倍，而APB1为42M
    8 y& k- l/ X" b* a( e2 ]
17. //arr：自动重装值。
    
18. //psc：时钟预分频数
    
19. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    
20. //Ft=定时器工作频率,单位:Mhz
    * m: C3 X8 I1 C& D+ B  b( ~
21. //通用定时器中断初始化
    ; J5 C9 d% A: z
22. //这里始终选择为APB1的2倍，而APB1为36M
    
23. //arr：自动重装值。
    
24. //psc：时钟预分频数                 
    
25. void TIM7_Int_Init(u16 arr,u16 psc)
      L- ]$ `7 L% H
26. {       
    6 C4 P6 P+ v5 E
27.         NVIC_InitTypeDef NVIC_InitStructure;
    $ q- W8 e% D' U/ j" a
28.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    " C8 r' Q; _9 \
29. 
    
30.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE);//TIM7时钟使能   
    
31.        
    + |: r+ ]2 |. G
32.         //定时器TIM7初始化
    0 @' P# }) A. i2 X8 N
33.         TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值       
    
34.         TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值
    / \0 ~4 V) j$ X* W7 g
35.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
    " n5 I( z. V* y* T2 o1 {4 K
36.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    + }8 M5 F6 y9 U+ I, {1 }/ y
37.         TIM_TimeBaseInit(TIM7, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位
    # J0 J; ?* r! _  H# z) U8 M2 W' T! T
38. 
    
39.         TIM_ITConfig(TIM7,TIM_IT_Update,ENABLE ); //使能指定的TIM7中断,允许更新中断
    
40.        
    
41.         TIM_Cmd(TIM7,ENABLE);//开启定时器7
    7 ~/ }, C) x$ ^1 A7 h
42.        
    # v1 T' }6 w5 R" J
43.         NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn;
    
44.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级0
    
45.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                //子优先级2
      `. X# s8 q  h4 Q1 }. Q/ v2 k
46.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    2 Z. w- m6 B- n2 f
47.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
48.        
    6 ~! c  L) w5 V) D
49. }
    0 q* T4 X1 k% e& I4 c# t# G
50.          
    ' _, e5 g& \+ M4 E( ]

复制代码

四.结合DMA接收数据帧
+ g* `9 B3 o8 O当单片机从串口上接收数据时，一般我们都是接收一个字节数据，进入一次中断，在中断中处理数据或者做标记，这种方法虽然简单，但是对于大量数据的情况，频繁地进入中断处理数据就占有了CPU的宝贵资源。
  O6 x' P  i0 @+ K  n这个时候我们可以使用DMA来接收数据，DMA接收数据的好处就是省CPU资源，DMA仅仅在初始化的时候占用一下CPU资源，其他操作都是在DMA的控制器来完成的。
2 V$ k( y/ m% [9 d( [- L5 _+ m# U
6 V2 T$ [+ ~- J+ J% ^使用背景：单片机从USART2中接收传感器传回的数据帧（12字节），传感器每秒上报一次数据，要求单片机可以收到完整数据并且可以对数据进行处理。

程序框架：以往串口接收数据都是判断数据寄存器非空的，一字节一字节地接收，现在使用DMA，使每一次数据寄存器的值都自动传给内存指定地址（也就是指定的数据缓冲区），当串口接收完一帧数据后，会触发空闲中断，这意味着一帧数据的接收完成，我们只需要在数据缓冲区中对数据进行处理即可。

' \* T8 M1 l# w3 Q8 U' e/ I4 G6 d5 [代码：
% p# `! \$ D, {7 e0 G8 ?

1. 
   . i' o1 G4 s7 r! ~1 U6 @
2. uint8_t USART2_Rx_Buf[12];
   
3. 
   
4. void USART2_Config( void )
   / M0 m% u% r6 M+ U' g, a3 q
5. {
   7 r, O6 V/ w9 C* V- C# _6 ?! w
6.         /* 声明各结构体 */
   
7.         GPIO_InitTypeDef GPIO_InitStruct;
   
8.         USART_InitTypeDef USART_InitStruct;
   , I9 U5 \. V9 q4 Q
9.         NVIC_InitTypeDef NVIC_InitStruct;
   
10.         DMA_InitTypeDef DMA_InitStruct;
    
11.        
    2 x; [9 U4 y1 }+ E0 q- S: w
12.         /* 打开时钟 */
    
13.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    ; q+ |+ W: Q# F7 K/ I
14.         RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );
    ! V/ f7 G& X' ~$ B, |% f
15.         RCC_AHBPeriphClockCmd( RCC_AHBPeriph_DMA1, ENABLE );
    
16.        
    ! f: B5 v! n7 ]
17.         /* GPIO配置 */
    4 R$ q" o3 p- c! \* t" T0 A
18.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    
19.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;                 //USART2_Tx:PA2
    & s3 W6 `. f! x  O
20.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    # `% k" I! S7 S5 X8 Y7 h, w
22.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
23.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3;                //USART2_Rx:PA3
    
24.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    * _% Z/ p7 m( }4 P& H
25.        
    
26.         /* 串口配置 */
    3 t' z% P9 e9 l
27.         USART_DeInit( USART2 );
      V+ U; v. \& M6 H( K1 q
28.         USART_InitStruct.USART_BaudRate = 9600;                //波特率:9600
    
29.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    - n/ {# {. m1 k4 T6 L
30.         USART_InitStruct.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
    
31.         USART_InitStruct.USART_Parity = USART_Parity_No;
    
32.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
    
33.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    : Z2 ]% r5 l: G+ N
34.         USART_Init( USART2, &USART_InitStruct);
    
35.        
    ' g3 V  B1 u' E
36.         /* 中断配置 */
    
37.         NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
    " L1 r4 K* M+ \; r5 T
38.         NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
    0 `! k0 p+ f3 n" z9 O0 P$ o7 \8 G; b
39.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
      t  g& @! P% G! i4 l: I
40.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    
41.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    $ N% C+ m0 K6 W* {
42.         NVIC_Init( &NVIC_InitStruct );
    4 |" p2 X0 w/ m
43.         USART_ITConfig( USART2, USART_IT_IDLE, ENABLE );      //空闲中断
    
44.         USART_DMACmd( USART2, USART_DMAReq_Rx, ENABLE );   //开启DMA接收
    
45.        
    
46.        
    
47.         /* 配置DMA传输数据 USART2对应DMA1的通道6 方向：外设到存储器*/       
    
48.     DMA_InitStruct.DMA_PeripheralBaseAddr = USART2_BASE+0x04;              // 设置DMA源地址：串口数据寄存器地址*/       
    
49.         DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)USART2_Rx_Buf;           // 内存地址(要传输的变量的指针)       
    / N0 _) r9 `# Z- K# T7 L
50.         DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;                        // 方向：从外设到内存               
    
51.         DMA_InitStruct.DMA_BufferSize = 12;                                    // 传输大小        一帧数据12字节                            
    , l/ f; S$ U. T$ o' g
52.         DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;          // 外设地址不增               
    
53.         DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;                                    // 内存地址自增               
    
54.         DMA_InitStruct.DMA_PeripheralDataSize =         DMA_PeripheralDataSize_Byte; // 外设数据单位               
    
55.         DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;           // 内存数据单位         
    : [9 e, z- x% {" V( M
56.         DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;                               //正常 DMA模式，一次或者循环模式
    $ [$ Z2 |9 I7 K3 ?
57.         DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;                     // 优先级：中
    
58.         DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;                              // 禁止内存到内存的传输
    
59.         DMA_Init( DMA1_Channel6, &DMA_InitStruct );
    
60.         DMA_ClearFlag(DMA1_FLAG_TC5);
    % C* Q' ]" H- F$ F
61.         DMA_Cmd( DMA1_Channel6, ENABLE );//使能DMA
    " b0 I- B9 A) D
62.        
    4 S6 ~7 r- P/ K# b  h" ~4 D$ B+ T
63.        
    ! w% y- q. M, s
64.         /* 使能串口 容易忽略 */
    5 Y2 v% W/ d9 [; ~0 D9 u- Q" x! ^
65.         USART_Cmd( USART2, ENABLE);
    
66.        
    7 H: P0 g0 Q0 T5 J. n+ j
67. }
    
68. 
    8 `: v9 S) u* `
69. 
    & J4 _% @2 Q4 N3 j4 N
70. 
    
71. /* 串口空闲中断服务函数 */
    
72. void USART2_IRQHandler( void )
    0 `$ z) |- }- [! P, N' z; z) {9 I
73. {
    
74.         if( USART_GetITStatus( USART2, USART_IT_IDLE ) != RESET )
    
75.         {
    ) q: T- v. j1 H: D
76.                 USART_ReceiveData( USART2 );//象征性接收数据
    1 g/ X  Q- L! Y; T0 J
77.                 USART_ClearITPendingBit( USART2, USART_IT_IDLE );//清除标志位
    
78.                
    
79.         }
    5 Y! K0 a( ~0 [% l! x8 J6 F( b
80. }
    
81. //也可以在中断服务函数中扩展更多的功能
    ; ~, S( }( x% S8 E0 X

复制代码

, X$ V4 }" u" E/ t4 e0 x$ u/ I/ O要点：
$ C+ a6 g% s' Y, V/ a! `要开启串口的空闲中断
7 k& K2 R, M8 l9 A串口的空闲中断中要象征性读取数据和清除标志位
4 Y6 v9 ?! i& V3 O6 y0 ^要开启串口的DMA接收请求
* u/ x3 a2 I% j( e4 R% T————————————————
# X1 u5 g/ d& Z' Q# C. g$ ?版权声明：Aspirant-GQ
. q1 o1 W4 ]! P! U  k如有侵权请联系删除
8 H, q- V; W0 ~: `. P6 x  @& b! G- X
  f7 z8 w0 C( N2 i* b: x5 A