写在前面
% d; M8 c4 o7 w! F$ S- ?9 b& o芯片型号：stm32f030c8t6
说明：便宜，用量大
要点说明：初始化、主函数调用串口接收callback、串口接收空闲中断，串口接收中断
这种API封装方式可以拓展到其他单片机，但需要注意单片机是否支持接收空闲中断
本文注意介绍空闲中断的应用，这样就不用在定时器中计时来检测接收超时中断了
: U, @" \1 p' P: p8 N9 w
一、应用
' O( y  }7 K* c+ @外部定义串口接收回调
当串口数据接收完成后，在该回调中处理串口数据即可

1. void Uart_recvCallBack(void *buf, int len)
   8 g( ^: T- K% g! o! f4 G
2. {
   
3. 
   $ c2 M- d: b* P$ b+ y2 ]
4. }

复制代码

外部初始化串口

1. myUart_initialize(115200,
   
2.                                         USART_WordLength_8b,
   
3.                                         USART_StopBits_1,
   
4.                                         USART_Parity_No,
   0 a5 a7 J( C$ h+ M: V# N7 C
5.                                         Uart_recvCallBack);

复制代码

% k: T/ F  v" F. n二、源码
myUart.h
* `& Z/ q  D( K4 h1 \1 h

1. #ifndef __myUart_H
   4 U4 E8 F/ }& i- @% q% J* s/ A
2. #define        __myUart_H
   
3. 
   
4. #include "stm32f0xx.h"
   
5. #include "stm32f0xx_usart.h"
   
6. #include "stm32f0xx_gpio.h"
   
7. #include "stm32f0xx_rcc.h"
   + ?6 M6 {- b5 q, d" h
8. #include "stm32f0xx_misc.h"
   1 e: [0 t% f1 d0 k8 |
9. 
     [+ Q. f% V# \2 s
10. #define USART_REC_LEN                          200          //定义最大接收字节数
    ' |0 F3 t( n# U% e7 ]# |7 x
11. 
    9 n! V% Z4 p, i
12. typedef void (*myUart_cb)(void *buf, int len);
    
13. 
    
14. void myUart_initialize(   uint32_t USART_BaudRate,
    3 H6 W6 K1 s5 {) i5 I5 Q4 F
15.                                                         uint32_t USART_WordLength,
    
16.                                                         uint32_t USART_StopBits,
    1 q  {0 N0 d1 b7 F( [/ Y
17.                                                         uint32_t USART_Parity,
    ! ^2 q$ ?  b5 `8 z. H0 L
18.                                                         myUart_cb cb);
    2 u/ N- X. R9 c/ o* y
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);
    
22. uint8_t myUart_recvByte(void);
    
23. int fputc(int ch, FILE *f);
    
24. 
    ! Y6 o" t3 H# o
25. #endif /* __UART_H */
    

复制代码

myUart.c

1. #include "myUart.h"
   
2. 
   / V0 g+ Z$ f. x
3. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   
4. 
   
5. uint8_t USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
   
6. uint16_t USART_RX_count = 0;       //接收状态标记               
     R* X; {8 h' Y3 w! b7 {
7. myUart_cb myUart_callBack;
   
8. /* Private functions ---------------------------------------------------------*/
   
9. 
   1 \% M2 j; y+ `/ w: a
10. USART_InitTypeDef USART_InitStructure;
    
11. 
    
12. void myUart_initialize(   uint32_t USART_BaudRate,
    
13.                                                         uint32_t USART_WordLength,
      p' L/ T/ t& E2 ?) }2 \2 o
14.                                                         uint32_t USART_StopBits,
    
15.                                                         uint32_t USART_Parity,
    
16.                                                         myUart_cb cb)
    
17. {  
    
18. 
    0 Q9 E5 ]) u0 g' W
19.         GPIO_InitTypeDef  GPIO_InitStructure;
    , `; p7 s) q! z  o& J
20.         NVIC_InitTypeDef NVIC_InitStructure;
    ) x) I% O* j) W0 I7 I
21. 
    ' U% i8 C8 Y+ Y1 e+ X
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE );
    * S. G9 V; D4 _, U
23. 
    / m: ?. o* X' a
24.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
    
25.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);        
    
26.         /*
    
27.         *  USART1_TX -> PA9 , USART1_RX ->        PA10
    6 _0 w. s# Z* `2 ^! Y8 Z
28.         */                                
    
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;                 
    
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    . I( A- }- @# w  ]4 L6 J- ~
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    # H; t7 x" f/ T- ^' A8 K
32.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    9 k: b; n& v8 W* S- f" V: B
33.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
34.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
    
35. 
    
36.         //Usart1 NVIC 配置
    8 W) f3 Y! s5 w" O" C: [
37.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    ; s- n+ l4 J- Q! @. e  e' w/ o
38.         NVIC_InitStructure.NVIC_IRQChannelPriority=1 ;//抢占优先级3
    
39.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
40.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
41. 
    
42.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    
43.         USART_InitStructure.USART_WordLength = USART_WordLength;//设置数据位
    
44.         USART_InitStructure.USART_StopBits = USART_StopBits;//设置停止位
    
45.         USART_InitStructure.USART_Parity = USART_Parity;//设置效验位
    
46.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//设置流控制
    
47.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//设置工作模式
    6 N9 v8 M8 w; o5 X+ S; g
48.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    
49. 
    
50.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    
51.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接受超时中断
    
52.         USART_Cmd(USART1, ENABLE);//使能串口1
    ! v5 d/ Y% ^3 e0 F% z* R
53. 
    
54.         myUart_callBack = cb;
    
55. }                        
    
56. void myUart_setBaudRate(uint32_t USART_BaudRate)
    
57. {
    
58.         USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
    
59.         USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);
    
60.         USART_Cmd(USART1, DISABLE);
    1 Z, {( Y# X; ?
61. 
    
62.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    
63.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    
64. 
    
65.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接收中断
    
66.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接收超时中断
    ( o; w. e: f1 p6 v2 o8 K$ ?
67.         USART_Cmd(USART1, ENABLE);//使能串口1
    
68. }
    + E% ^0 H/ w9 J7 n6 d* [. q2 j
69. void myUart_sendByte(uint8_t byte) //发送1字节数据
    & x# {* ?6 o- ^- ~
70. {
    , z. P7 A8 @0 i) y3 o
71. while(!((USART1->ISR)&(1<<7)));
    * b: [% h; G0 B! y( C9 {* P8 g
72. USART1->TDR=byte;        
    
73. }               
    * c; O1 E- ~2 u  n. R' L# y
74. 
    
75. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length)
    0 j# N: y8 W' F* \! L9 N- E
76. {
    
77.         while(Length != 0)
    
78.         {
    
79.                 while(!((USART1->ISR)&(1<<7)));//等待发送完
    6 Z. y1 I8 {% R* M, {- m8 e2 N0 `
80.                 USART1->TDR= *Buffer;
    
81.                 Buffer++;
    
82.                 Length--;
    9 @' ^5 O9 n) G( l4 c: Q
83.         }
    
84. }
    
85. 
    
86. uint8_t myUart_recvByte(void)
    # \, @4 K+ i/ }: T" ^
87. {        
    
88.         while(!(USART1->ISR & (1<<5)));//等待接收到数据
    ) _2 {) b0 l+ s5 K( C& Y
89.         return(USART1->RDR);                         //读出数据
      }$ W  u6 ^9 j
90. }
    
91. 
    . t$ E+ A1 Q" r7 e
92. 
    
93. PUTCHAR_PROTOTYPE
    
94. {
    ( J1 A  h& z. s3 i
95. /* 将Printf内容发往串口 */
    
96.   USART_SendData(USART1,(uint8_t)  ch);
    : @( u4 F" n) T
97.   while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    
98.         {}
    : a: e6 _8 i9 h
99. 
    7 n" I# z; c: A6 M  d2 D
100.   return (ch);
     
101. }
       \. ?( k. r/ v3 H9 b' Z! z
102. 
     & R' x& I! |1 C: ]
103. void USART1_IRQHandler(void)                        //串口1中断服务程序
     9 q0 H9 w$ ^) ~! A( V4 O5 v
104. {
     2 s- l- G3 J2 }0 J# Z
105.         uint8_t Res;
     
106. 
     
107.         if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
     
108.         {
     
109.                 USART_ClearITPendingBit(USART1, USART_IT_IDLE);//USART_IT_IDLE需要手动清除
     
110.                 if (USART_RX_count)
     
111.                 {
     % ~0 S! c- j4 ^6 `
112.                         if (myUart_callBack)
       q: K0 G1 ?) R( a: E4 d0 D
113.                         {
       z% y0 r% h! n4 a2 f
114.                                 myUart_callBack(USART_RX_BUF, USART_RX_count);
     
115.                         }
     ' f) q' Z& [5 t+ y- r! I- \6 N
116.                 }
     9 a- Q: M0 s7 r. ]1 a# X* h
117.                 USART_RX_count = 0;
     . Y- l4 }8 Q' K2 v0 F+ I& [, w
118.         }
     5 D* B3 L" E* [$ ~6 e3 e1 Q
119.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断
     , u0 P6 F9 J5 w6 n. t7 m
120.         {
     
121.                 USART_RX_BUF[USART_RX_count] = USART_ReceiveData(USART1);        //读取接收到的数据，自动清除USART_IT_RXNE中断标志
     
122.                 USART_RX_count ++;
     
123.         }
     - n! ?# P" t+ Z  h/ T
124. }
     . O3 m& P* o5 d8 j
125. 
     

复制代码

8 i+ }5 `' _% j