写在前面
( a+ z% J; `4 `+ \芯片型号：stm32f030c8t6
  I5 l$ Z* z; @6 C说明：便宜，用量大
9 A% M; r7 E, s# z要点说明：初始化、主函数调用串口接收callback、串口接收空闲中断，串口接收中断
这种API封装方式可以拓展到其他单片机，但需要注意单片机是否支持接收空闲中断
本文注意介绍空闲中断的应用，这样就不用在定时器中计时来检测接收超时中断了
  g% R' ^8 _# b% |# \1 w" M: J
" Z# w1 n" |7 C4 b4 S  i6 J# h- P  }' T  s一、应用
! F' w! j; x+ l9 F$ L1 D7 T外部定义串口接收回调
  _6 S, y, {2 j3 T  A6 ~/ V当串口数据接收完成后，在该回调中处理串口数据即可
  g3 i  u, R$ [; [7 W# e

1. void Uart_recvCallBack(void *buf, int len)
   
2. {
   
3. 
   
4. }

复制代码

; ^( w) T  d3 Z8 K# [- y外部初始化串口

1. myUart_initialize(115200,
   / h; u) F6 t; J: ]9 d
2.                                         USART_WordLength_8b,
   
3.                                         USART_StopBits_1,
   7 P2 F& W5 G' `* k! h1 c
4.                                         USART_Parity_No,
   
5.                                         Uart_recvCallBack);

复制代码

% E) L9 s8 k8 v1 K  d  ?6 ~+ R/ G二、源码
  o7 N1 V2 C9 c6 Z! QmyUart.h

1. #ifndef __myUart_H
   
2. #define        __myUart_H
   , g" ?/ P8 E& _5 P
3. 
   . u2 E& ^* j- w; H
4. #include "stm32f0xx.h"
   
5. #include "stm32f0xx_usart.h"
   
6. #include "stm32f0xx_gpio.h"
   : T  ]8 ]0 ?. L1 {. o
7. #include "stm32f0xx_rcc.h"
   ' x; t2 O1 G9 _6 T
8. #include "stm32f0xx_misc.h"
   ; E% o+ r3 z% M  D
9. 
   0 H' T5 y* Q: x4 v( {' @0 t
10. #define USART_REC_LEN                          200          //定义最大接收字节数
    
11. 
    / `; q4 r& }* b/ f8 f# ~2 @* E- U( g+ y' H
12. typedef void (*myUart_cb)(void *buf, int len);
    
13. 
    
14. void myUart_initialize(   uint32_t USART_BaudRate,
    ; X4 |# ?: J- G9 L: C7 V! D
15.                                                         uint32_t USART_WordLength,
    0 L8 c9 C$ s2 ~) @: M
16.                                                         uint32_t USART_StopBits,
    
17.                                                         uint32_t USART_Parity,
    
18.                                                         myUart_cb cb);
    6 g/ A- F5 N% |4 ?
19. void myUart_setBaudRate(uint32_t USART_BaudRate);
    
20. void myUart_sendByte(uint8_t byte);
    
21. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length);
    % d$ w$ z2 A. \$ d
22. uint8_t myUart_recvByte(void);
    
23. int fputc(int ch, FILE *f);
    
24. 
    ; ]! K- |0 l( P+ r5 y" ]
25. #endif /* __UART_H */
    

复制代码

5 g& ~4 c3 H$ r: [9 }) E" YmyUart.c
, p+ g4 Z# s8 R: N6 L

1. #include "myUart.h"
   4 T8 \) K  ?2 y. S' p
2. 
   2 e. s! e. s. V
3. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   0 b) W" B- M6 e( x
4. 
   ' ?8 ^$ E( F4 E( {1 N0 N
5. uint8_t USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
   
6. uint16_t USART_RX_count = 0;       //接收状态标记               
   ! I2 q. z3 K1 {& m
7. myUart_cb myUart_callBack;
   9 `! Q; g6 c8 @8 d8 a( [3 t9 P/ c5 l& G
8. /* Private functions ---------------------------------------------------------*/
   
9. 
   2 v4 Q( L3 B* _) t
10. USART_InitTypeDef USART_InitStructure;
    
11. 
    
12. void myUart_initialize(   uint32_t USART_BaudRate,
    
13.                                                         uint32_t USART_WordLength,
    
14.                                                         uint32_t USART_StopBits,
    6 K" E: j: k7 _1 a3 R, C
15.                                                         uint32_t USART_Parity,
    1 g: {( _( i4 Y; _- J3 |5 I
16.                                                         myUart_cb cb)
    7 X. D' q7 Z) _- u, \7 g6 _
17. {  
    ) h5 }- N! n4 k! |5 f# c
18. 
    5 @6 D# R) |$ ^% s+ n
19.         GPIO_InitTypeDef  GPIO_InitStructure;
    : ^6 J, l$ ~" A2 G+ X) p
20.         NVIC_InitTypeDef NVIC_InitStructure;
    
21. 
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE );
    8 [" o+ H/ A6 K6 _# @8 i
23. 
    
24.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
    0 ?8 U! i8 M+ U! ~7 W
25.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);        
    
26.         /*
    
27.         *  USART1_TX -> PA9 , USART1_RX ->        PA10
    9 u2 {2 Z, K. L1 X
28.         */                                
    3 k( O& W! d4 @" Y, n% \
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;                 
    : ^) t- ^8 m$ m" G- m0 }
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    ( Z5 Q9 L) k. V9 B* ^+ V) f2 E# Q( ?
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    , ]8 D) Q4 W$ A0 j1 n4 B8 J
32.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
33.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
34.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
    " Z2 b" t- u7 r. Q" Y" T8 O
35. 
    & U0 D( n- L2 D3 \
36.         //Usart1 NVIC 配置
    + S1 |% ~5 e" F3 }" l
37.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    % d. d/ m8 f( Z. j3 `
38.         NVIC_InitStructure.NVIC_IRQChannelPriority=1 ;//抢占优先级3
    
39.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
40.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    5 R% V  E2 c- z, q, R
41. 
    : @4 ~/ P9 i3 i7 w) w% L/ @
42.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    
43.         USART_InitStructure.USART_WordLength = USART_WordLength;//设置数据位
    ' E4 F! ]" s8 @3 V0 ]
44.         USART_InitStructure.USART_StopBits = USART_StopBits;//设置停止位
    
45.         USART_InitStructure.USART_Parity = USART_Parity;//设置效验位
    # K4 G! P2 F/ q
46.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//设置流控制
    0 I9 K- `& L" J/ `3 h
47.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//设置工作模式
    + G+ V3 F7 f# P8 e- o
48.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    6 g  T7 o4 l; N  ]9 \* q
49. 
    9 S$ O; m& X3 v. v  k+ ~
50.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    
51.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接受超时中断
    . D, b" N% H  k' g; a1 r7 W
52.         USART_Cmd(USART1, ENABLE);//使能串口1
    $ Y' v$ a( Y$ G- }1 }7 H
53. 
      r  w5 b9 z& d* O' N
54.         myUart_callBack = cb;
    8 _4 O. \/ k, d$ {/ ]
55. }                        
    
56. void myUart_setBaudRate(uint32_t USART_BaudRate)
    
57. {
    9 b8 a5 S6 @5 Q% F( ]- [
58.         USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
    
59.         USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);
    
60.         USART_Cmd(USART1, DISABLE);
    , J; `; s. p: p8 i5 Q
61. 
    5 j6 }+ t7 F& _7 Y+ K; y
62.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    
63.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    
64. 
    0 Z0 F0 r  Q+ ~* I
65.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接收中断
    
66.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接收超时中断
    
67.         USART_Cmd(USART1, ENABLE);//使能串口1
    
68. }
    ) O7 p+ A! m  |1 p5 U1 V
69. void myUart_sendByte(uint8_t byte) //发送1字节数据
    2 ]% b$ W6 f2 d( b* I7 X  H
70. {
    
71. while(!((USART1->ISR)&(1<<7)));
    # w. S$ X% Y5 R5 I- |
72. USART1->TDR=byte;        
      J& e1 x8 ^+ B! X; D
73. }               
    
74. 
    * G, C  R: u* l2 n, f  w. y5 L; b
75. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length)
    ! b# e8 T/ |& ~; g7 ^: \  k1 z- B
76. {
    
77.         while(Length != 0)
    / N! X) a! g/ m% \: j  X2 N
78.         {
    
79.                 while(!((USART1->ISR)&(1<<7)));//等待发送完
    
80.                 USART1->TDR= *Buffer;
    
81.                 Buffer++;
    7 G2 ~" M; n; {! X
82.                 Length--;
    " L$ d/ J8 h' \- e( M2 q" G$ ^$ s, ]
83.         }
    2 S+ O* H) b4 q7 G' Q1 x
84. }
    $ r6 l! V/ a- h# c' Y# E
85. 
    
86. uint8_t myUart_recvByte(void)
    
87. {        
    9 O" [4 B9 [$ x" S. p4 }+ J/ B
88.         while(!(USART1->ISR & (1<<5)));//等待接收到数据
    
89.         return(USART1->RDR);                         //读出数据
    % ]6 v8 W9 X2 X9 i8 p9 b
90. }
    
91. 
      R/ g8 T$ g7 V. Y& O
92. 
    
93. PUTCHAR_PROTOTYPE
    
94. {
    
95. /* 将Printf内容发往串口 */
    7 \, e" K! l* n$ [
96.   USART_SendData(USART1,(uint8_t)  ch);
    * o1 A: Y1 e2 Q
97.   while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    ( e( n% q( N5 e
98.         {}
    $ t# o3 @0 ]1 ?) @3 `
99. 
    0 i; ^: N4 x* i2 |+ S
100.   return (ch);
     - B% L4 c- H% r0 C8 J- O, r
101. }
     $ g6 M& U# M4 r+ r- P5 Q
102. 
     5 {3 e, ^* W; w+ v4 U' x  |9 @' m
103. void USART1_IRQHandler(void)                        //串口1中断服务程序
     
104. {
     
105.         uint8_t Res;
     
106. 
     : r! C* ]' M8 U9 V: p6 Q3 O
107.         if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
     
108.         {
     
109.                 USART_ClearITPendingBit(USART1, USART_IT_IDLE);//USART_IT_IDLE需要手动清除
     ; ~- ?# ]0 X$ O; q1 b: [
110.                 if (USART_RX_count)
     
111.                 {
     
112.                         if (myUart_callBack)
     6 ?6 x) X/ \( h
113.                         {
     
114.                                 myUart_callBack(USART_RX_BUF, USART_RX_count);
     
115.                         }
     
116.                 }
     4 u: l7 E4 d2 C! F' _
117.                 USART_RX_count = 0;
     
118.         }
     
119.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断
     
120.         {
     7 _: C3 D( B2 X4 d* Z+ f* P
121.                 USART_RX_BUF[USART_RX_count] = USART_ReceiveData(USART1);        //读取接收到的数据，自动清除USART_IT_RXNE中断标志
     
122.                 USART_RX_count ++;
     
123.         }
     2 i" j, O5 N6 E6 O/ d+ D
124. }
     
125. 
     

复制代码

' T% ], N: w2 f9 m6 n- h