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

一.仅向上位机打印调试信息
单纯利用串口向上位机打印调试信息，程序如下：
/ Z  G1 G8 D$ T" y  `

1. void USART1_Init( uint32_t btl )
   
2. {
   
3.         GPIO_InitTypeDef  GPIO_InitStruct;
   2 |* l2 ^: e. l, O# r  P3 q
4.         USART_InitTypeDef USART_InitStruct;
   $ v% S8 ~: }2 l
5.        
   7 N4 E7 f9 j, l% a
6.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE );
   % G" U- N$ ^5 H, `4 W* B+ n
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;
    
11.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    
12.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;//Rx
    . z% S) x! n$ I
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    , v7 p7 J9 t2 {/ c" A
14.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    
15.        
    6 s4 e& O9 p! W# U: d+ r
16.         USART_InitStruct.USART_BaudRate = btl;
    
17.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    $ d6 b, X; e: I
18.         USART_InitStruct.USART_Mode = USART_Mode_Tx;
    
19.         USART_InitStruct.USART_Parity = USART_Parity_No;
    & \. g1 J2 ]; C7 C$ T, \
20.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
    7 A, Y5 `& [+ ~4 h/ v* w
21.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    4 O, w5 D6 O  |# s- f
22.         USART_Init( USART1, &USART_InitStruct );
    
23.        
    1 b  _! g5 q. s! G
24.         USART_Cmd( USART1, ENABLE );
    9 w' A& b  G$ c$ l/ C
25.        
    
26. }
    
27. 
    + K1 r& o' M) {1 {. K; r2 P0 s
28. //串口重定向，直接利用printf函数输出调试信息
    4 N. P9 }  p. ^' U4 }
29. int fputc( int ch, FILE *f )
    4 P; Y# J7 e' U4 O* {9 ^  u( T
30. {
    1 m6 |) E+ G7 f5 i3 J& a' u, i
31.         USART_SendData( USART1, ( uint8_t )ch );
    6 K  ~: ?: w2 t4 v0 f
32.         while( USART_GetFlagStatus( USART1, USART_FLAG_TXE )!=SET );
    
33.         return ch;
    
34. }
      `* c) A0 i0 r- l0 l
35. 
    : v- X: G8 V  C5 z
36. 
    & ^* r. A, g* [/ ?

复制代码

记得包含头文件，勾选Use MicroLIB，以使用printf等函数
) l/ R2 N8 @/ \) S
' M( Q: L1 d8 x% d

1 B0 s# l) D* O* u& \2 d' P
+ }+ P- Q) \  _; {. S' {二.与上位机交互信息
相比于上面的单向通信，有时候需要从上位机接收信息，然后进行反馈，这个时候就使用到串口的中断了。
9 W/ K& o7 q. C: y2 Y  }上位机向单片机发送字符串，接收后再发送给上位机：

1. 
   
2. void USART1_Init( uint32_t btl )
   
3. {
   
4.         /* 结构体声明 */
   
5.         GPIO_InitTypeDef  GPIO_InitStruct;
   
6.         USART_InitTypeDef USART_InitStruct;
   
7.         NVIC_InitTypeDef NVIC_InitStruct;
   
8.        
   
9.         /* 打开时钟 */
   
10.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    
11.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1, ENABLE );
    . F' p7 R1 k, O9 k: K6 w% }
12.        
    
13.         /* GPIO配置 */
    
14.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    
15.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;//Tx
    
16.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
17.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    
18.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;//Rx
    
19.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
      a/ ^( S0 q  N7 j1 M; f
20.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    
21.        
    : R! K& t# c! }6 X7 G6 o
22.         /* 串口配置 */
    , c) @) h2 L. W0 V% m
23.         USART_InitStruct.USART_BaudRate = btl;
    
24.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    " q7 p+ ~) h/ ~4 I1 s) P
25.         USART_InitStruct.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;//收发模式
    4 p4 i* q9 ?# w  M# ^' h% d7 `
26.         USART_InitStruct.USART_Parity = USART_Parity_No;
    
27.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
    % |' Q6 M* s  n+ E, D- D# b6 m) X
28.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    2 r% _) N3 z, S! }. M$ I0 H7 K
29.         USART_Init( USART1, &USART_InitStruct );
    6 ~0 [1 Z" q4 B
30.        
    & g  x2 c3 B; i* m0 Z9 Q
31.         /* 中断配置 */
    
32.         NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
    
33.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=3 ;
    
34.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 3;               
    
35.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;                       
    
36.         NVIC_Init(&NVIC_InitStruct);       
    
37.         USART_ITConfig( USART1, USART_IT_RXNE, ENABLE );//接收寄存器非空触发中断
    , N! C  c$ j) i8 J" H' U; z# y
38.        
    , P, x  Y5 }, `# u. U/ ^( ?. e; Q
39.         /* 使能串口 */
    
40.         USART_Cmd( USART1, ENABLE );
    
41.        
    
42. }
    & |3 K" ], Z4 R
43. 
    : x4 [- ^  g- a+ ~9 L* N" U
44. 
    ! D7 T. y. Y# n& S# A9 a) p
45. volatile uint8_t n=0;
    
46. //接收缓冲区
    
47. uint8_t USART1_Rx_Buf[100];
    
48. void USART1_IRQHandler( void )
    4 S& ]! Q- u# ~7 u7 ?
49. {
    # e2 A$ o+ y6 ^
50.         if( USART_GetITStatus( USART1, USART_IT_RXNE )==SET )
    0 W: C7 T) P$ N- v) j
51.         {
    
52.                         USART1_Rx_Buf[n]=USART_ReceiveData( USART1 );
    * Q  e9 O: c1 F  k; {! P/ a
53.                         n++;
    & T' t3 U5 ~9 ^: ^) k
54.         }       
    
55.         USART_ClearFlag( USART1, USART_IT_RXNE );
    
56. }
    

复制代码

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

( V* k) _) w2 G, a0 Y6 J  _# G
5 U$ t) ?) }0 F三.作为驱动接口
一些模块的驱动接口就是串口，这个时候就需要单片机从模块中读取指定格式的数据，比如GPS模块，将定位信息从串口发出，单片机解析串口数据，显示在上位机中。
& g/ S3 C  G, ^' M3 c8 D- A  husart3用来与GPS模块通信，从GPS模块接收数据，认为10ms内的数据属于一次数据，所以就需要定时器来控制时间。
; B# j, d. _  E+ ?6 L$ Musart3：

1. //串口1中断服务程序
   
2. //注意,读取USARTx->SR能避免莫名其妙的错误          
   
3. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
   
4. //接收状态
   
5. //bit15，        接收完成标志
     W3 ]* S7 X! |) j
6. //bit14，        接收到0x0d
   0 t1 {2 _7 Y! r* n+ _. i0 S
7. //bit13~0，        接收到的有效字节数目
   
8. u16 USART_RX_STA=0;       //接收状态标记          
   . S" s: D, [6 F2 s/ h$ f
9.   
   - x6 H* M, d* \+ E# k
10. void uart_init(u32 bound){
    
11.   //GPIO端口设置
    
12.   GPIO_InitTypeDef GPIO_InitStructure;
    
13.         USART_InitTypeDef USART_InitStructure;
    / p1 x6 {, \, x0 n9 W6 H
14.         NVIC_InitTypeDef NVIC_InitStructure;
    
15.        
    0 X, w- B; l# g  _. C+ Y: U
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    
17.   
    
18.         //USART1_TX   GPIOA.9
    
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    
20.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
21.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    ; m( `( B- h, T) |3 L+ r0 T1 E8 c7 _$ q
22.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
23.    
    
24.   //USART1_RX          GPIOA.10初始化
    
25.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    
26.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    
27.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    
28. 
    & A2 |$ W% Z$ x7 D, L' t4 w
29.   //Usart1 NVIC 配置
    % H2 v6 y- t3 t* I
30.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    ! y5 x' y9 }& N7 y
31.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    
32.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    / G+ U: g" n" E
33.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
34.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    ! I" s% L/ N7 m$ R9 R1 ?( K
35.   
    4 O; d  M8 ]% ]9 }6 T, B
36.    //USART 初始化设置
    % R* b' M/ m, ?1 b/ }2 N2 U4 X
37. 
    
38.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    ' R# O6 k' |& i, e. y0 f& {9 h4 Y
39.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
40.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    - J# W, s" j" D& G8 F; e6 Z4 R
41.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
42.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
43.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    9 j) y0 d. l) O+ S" O( w4 h
44. 
    * \$ w* T: i+ z2 U# s% x9 u
45.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    
46.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    
47.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    ) Y7 {( M+ h- g! S9 Z. b6 L! E
48. 
    
49. }
    1 ?- u+ w) N0 ?- o1 @% l
50. 
    
51. void USART1_IRQHandler(void)                        //串口1中断服务程序
    
52.         {
    + \. y+ o3 o) q; U3 K
53.         u8 Res;
      s+ u8 Q  Z& u5 Q# P
54. 
    % e- y# k) M  a
55.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    
56.                 {
    8 u# D( p* U, b+ u2 {# o
57.                 Res =USART_ReceiveData(USART1);        //读取接收到的数据
    * l' Y4 r5 T; T8 `& f2 m& x
58.                
    
59.                 if((USART_RX_STA&0x8000)==0)//接收未完成
    
60.                         {
    7 ]6 x7 f7 M3 l3 u1 f
61.                         if(USART_RX_STA&0x4000)//接收到了0x0d
    . ~6 }0 Y+ m  C
62.                                 {
    
63.                                 if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
    
64.                                 else USART_RX_STA|=0x8000;        //接收完成了
    ! l# j; e  [4 x( n
65.                                 }
    4 \8 d' \0 D" i( H
66.                         else //还没收到0X0D
    , t; l5 I" L6 A) X
67.                                 {       
    
68.                                 if(Res==0x0d)USART_RX_STA|=0x4000;
    + H5 a8 o1 M. T. V; r
69.                                 else
    
70.                                         {
    
71.                                         USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
    
72.                                         USART_RX_STA++;
    $ T3 _$ J2 @0 L  P9 [6 G
73.                                         if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收          
    8 }8 `! j* ?. t+ X' o* `" ?% U' [
74.                                         }                 
    " y5 C9 V4 f4 e  P! H8 L
75.                                 }
    # |  |" y: l) V6 U
76.                         }                    
    : D0 Y1 o# Q+ g( d0 L! H
77.      }
    + b; c6 x5 k5 K8 q/ p) d( G
78. }
    
79. 
    $ K" R" |8 a4 A, B! R9 \" y. h

复制代码

time7：

1. 
   
2. extern vu16 USART3_RX_STA;
   
3. 
   
4. //定时器7中断服务程序                    
   
5. void TIM7_IRQHandler(void)
   
6. {        
   
7.         if (TIM_GetITStatus(TIM7, TIM_IT_Update) != RESET)//是更新中断
   
8.         {                                   
   
9.                 USART3_RX_STA|=1<<15;        //标记接收完成
   3 y( p0 u& A2 ^- }$ b: Y; B
10.                 TIM_ClearITPendingBit(TIM7, TIM_IT_Update  );  //清除TIM7更新中断标志   
    
11.                 TIM_Cmd(TIM7, DISABLE);  //关闭TIM7
    
12.         }            
    
13. }
    ) t' |9 L3 y' e9 h: W5 p: e
14. 
    
15. //通用定时器7中断初始化
    
16. //这里时钟选择为APB1的2倍，而APB1为42M
    . X/ \9 V. r- O* m
17. //arr：自动重装值。
    0 X$ ~- j% L; x) P
18. //psc：时钟预分频数
    
19. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    1 i4 N8 t7 K* E1 }
20. //Ft=定时器工作频率,单位:Mhz
    # c  l2 |# a1 ?& h3 ~; Z
21. //通用定时器中断初始化
    6 U0 N& p" Q" k9 V
22. //这里始终选择为APB1的2倍，而APB1为36M
    
23. //arr：自动重装值。
    + ~. p' V: a0 C& _3 r5 o4 ]
24. //psc：时钟预分频数                 
    4 c; C# F, _4 B, n
25. void TIM7_Int_Init(u16 arr,u16 psc)
    
26. {       
    
27.         NVIC_InitTypeDef NVIC_InitStructure;
    8 O, J( r% g( a6 M
28.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    
29. 
    
30.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE);//TIM7时钟使能   
    
31.        
    : a& m( w5 _! x7 D# u
32.         //定时器TIM7初始化
    
33.         TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值       
    
34.         TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值
    
35.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
    
36.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    
37.         TIM_TimeBaseInit(TIM7, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位
    
38. 
    ( U+ ~: N8 U  V0 s" C1 J
39.         TIM_ITConfig(TIM7,TIM_IT_Update,ENABLE ); //使能指定的TIM7中断,允许更新中断
    
40.        
    
41.         TIM_Cmd(TIM7,ENABLE);//开启定时器7
    
42.        
    
43.         NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn;
    3 r1 g; l' i; `" g& m; L1 [
44.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级0
    0 \' q! `) D/ _& b
45.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                //子优先级2
    " B/ K+ Y1 {$ A) M
46.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
47.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
48.        
    
49. }
    
50.          
    

复制代码

四.结合DMA接收数据帧
当单片机从串口上接收数据时，一般我们都是接收一个字节数据，进入一次中断，在中断中处理数据或者做标记，这种方法虽然简单，但是对于大量数据的情况，频繁地进入中断处理数据就占有了CPU的宝贵资源。
这个时候我们可以使用DMA来接收数据，DMA接收数据的好处就是省CPU资源，DMA仅仅在初始化的时候占用一下CPU资源，其他操作都是在DMA的控制器来完成的。
$ S" L& u7 {5 K  X# Q( N
0 _4 z6 d* f: b' e0 I使用背景：单片机从USART2中接收传感器传回的数据帧（12字节），传感器每秒上报一次数据，要求单片机可以收到完整数据并且可以对数据进行处理。

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

/ ~, s7 |# }0 @代码：
8 B( B2 [4 c2 U' V8 G1 `+ k3 i7 t

1. 
   ; t2 G) h. u' p
2. uint8_t USART2_Rx_Buf[12];
   % r1 |6 r5 j$ U; Z, r
3. 
   
4. void USART2_Config( void )
   
5. {
   
6.         /* 声明各结构体 */
   2 N* B4 _3 k0 ?1 v& J
7.         GPIO_InitTypeDef GPIO_InitStruct;
     ]0 K! |8 U7 l! V% Y; K
8.         USART_InitTypeDef USART_InitStruct;
   3 c/ Q* b* s1 S4 u8 o2 {! |* r
9.         NVIC_InitTypeDef NVIC_InitStruct;
   7 R% b3 ~* P0 s$ s! I
10.         DMA_InitTypeDef DMA_InitStruct;
    
11.        
    
12.         /* 打开时钟 */
    
13.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
    3 x/ F2 S$ Q. v' b1 ]4 K: v! E: t0 y
14.         RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE );
    - l. e. D- Y+ |# g% ~
15.         RCC_AHBPeriphClockCmd( RCC_AHBPeriph_DMA1, ENABLE );
    
16.        
    
17.         /* GPIO配置 */
    1 i0 }4 E4 n1 \) e
18.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    
19.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;                 //USART2_Tx:PA2
    ) O8 ^0 \% t5 b4 ^; ?0 m  {8 ?# L
20.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    # c) E! c' T! Q, a0 J2 n3 O
22.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    0 Y5 K( l# N+ x9 Y
23.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3;                //USART2_Rx:PA3
    
24.         GPIO_Init( GPIOA, &GPIO_InitStruct );
    9 B8 G' P5 p" L0 B, I5 r3 `
25.        
    : L; e. \; g! g
26.         /* 串口配置 */
    4 p3 F' x6 I8 U# l0 ?+ V$ Z
27.         USART_DeInit( USART2 );
    ' w. O! N* [6 ]3 Z2 z9 M, {' ]% N- f
28.         USART_InitStruct.USART_BaudRate = 9600;                //波特率:9600
    ) P8 O' U- n, a" W" w
29.         USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    ( {" G) D4 S9 L. w1 Q1 U, L
30.         USART_InitStruct.USART_Mode = USART_Mode_Tx|USART_Mode_Rx;
    4 ^! X8 f2 w" J: j
31.         USART_InitStruct.USART_Parity = USART_Parity_No;
    7 I1 ?2 |" L# [/ J) l
32.         USART_InitStruct.USART_StopBits = USART_StopBits_1;
    
33.         USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    ( ~% B, f. H/ R' D0 F
34.         USART_Init( USART2, &USART_InitStruct);
    ' E" m% t" J2 n7 x: D! s! q- o
35.        
    
36.         /* 中断配置 */
    
37.         NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
    
38.         NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
    ( Y3 I# E* T" L" y) c( Y9 T; I
39.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
40.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    2 a0 k# o% p% C1 t! [$ d% X' S! }
41.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    
42.         NVIC_Init( &NVIC_InitStruct );
    * z4 f9 _7 E3 C# |/ p$ L* ]9 n
43.         USART_ITConfig( USART2, USART_IT_IDLE, ENABLE );      //空闲中断
    
44.         USART_DMACmd( USART2, USART_DMAReq_Rx, ENABLE );   //开启DMA接收
    
45.        
    + b% h6 z0 t6 C9 p- x" n
46.        
    0 \1 H, S; W8 P/ Z/ F1 }2 E) Q
47.         /* 配置DMA传输数据 USART2对应DMA1的通道6 方向：外设到存储器*/       
    
48.     DMA_InitStruct.DMA_PeripheralBaseAddr = USART2_BASE+0x04;              // 设置DMA源地址：串口数据寄存器地址*/       
    
49.         DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)USART2_Rx_Buf;           // 内存地址(要传输的变量的指针)       
    ; M  l& _( e% J# E' ^2 H/ F
50.         DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;                        // 方向：从外设到内存               
    
51.         DMA_InitStruct.DMA_BufferSize = 12;                                    // 传输大小        一帧数据12字节                            
    
52.         DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;          // 外设地址不增               
    
53.         DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;                                    // 内存地址自增               
    6 {4 t; ~9 c% g& y$ ~3 V
54.         DMA_InitStruct.DMA_PeripheralDataSize =         DMA_PeripheralDataSize_Byte; // 外设数据单位               
    1 S/ a0 w' b9 ]: ?- m- G+ Q
55.         DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;           // 内存数据单位         
    
56.         DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;                               //正常 DMA模式，一次或者循环模式
    . P0 n% I  g5 Y: @) j- [: k
57.         DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;                     // 优先级：中
    7 o& a0 r3 |1 B0 C$ d
58.         DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;                              // 禁止内存到内存的传输
      i, e( Q, \7 Z6 T$ M, f! Q
59.         DMA_Init( DMA1_Channel6, &DMA_InitStruct );
    
60.         DMA_ClearFlag(DMA1_FLAG_TC5);
    5 H9 y! Z+ H; G, ]& z6 s% f
61.         DMA_Cmd( DMA1_Channel6, ENABLE );//使能DMA
    
62.        
    
63.        
    ; V: b& s- {- f
64.         /* 使能串口 容易忽略 */
    
65.         USART_Cmd( USART2, ENABLE);
    
66.        
    ; ]$ {" L. ?  ^6 }: j1 j, ]
67. }
    " T) j0 R! l: \
68. 
    4 Q$ @" \- z  o
69. 
    
70. 
    8 n/ X! O; U( y* O* }% C
71. /* 串口空闲中断服务函数 */
    9 j" m) l+ d$ T; l, R, i
72. void USART2_IRQHandler( void )
    " s7 P& B0 n6 N7 Q* g# I' g
73. {
    
74.         if( USART_GetITStatus( USART2, USART_IT_IDLE ) != RESET )
    & Q2 T6 V+ d6 V# ?: k7 [
75.         {
    : e5 q( |5 o% y6 v
76.                 USART_ReceiveData( USART2 );//象征性接收数据
    
77.                 USART_ClearITPendingBit( USART2, USART_IT_IDLE );//清除标志位
    
78.                
    , h8 a" B7 d- b
79.         }
    - i% [  t$ k, t$ D# Y9 R
80. }
    
81. //也可以在中断服务函数中扩展更多的功能
    

复制代码

$ Q* f' x9 t* w9 Z- H; I9 Y5 R" q, ?要点：
要开启串口的空闲中断
3 o! i5 E4 U1 N( C" A串口的空闲中断中要象征性读取数据和清除标志位
" a( I% q& P$ S) @* D3 z0 r要开启串口的DMA接收请求
) o6 q' m) f: f; O+ M9 ?4 h————————————————
- t8 a9 I! s( X3 b  r- l5 g版权声明：Aspirant-GQ
! `. Q; ~* \% G' ]如有侵权请联系删除
0 N1 ?% C4 Z: X: L7 Q
% i: c* b  g6 `3 s3 v! W2 x