写在前面
芯片型号：stm32f030c8t6
% G% m6 L0 @0 X/ r/ t说明：便宜，用量大
) E6 V7 O1 T! ?/ q) q! T+ l要点说明：初始化、主函数调用串口接收callback、串口接收空闲中断，串口接收中断
5 b- E! O1 w; ?8 ^: [( W4 J& D这种API封装方式可以拓展到其他单片机，但需要注意单片机是否支持接收空闲中断
9 h' b$ b/ {* ^: L. d本文注意介绍空闲中断的应用，这样就不用在定时器中计时来检测接收超时中断了
5 W# ?& \, x3 S# N9 c. C
; M" S! f: G/ ?5 N2 o0 I一、应用
* [0 D: O. `$ ^外部定义串口接收回调
当串口数据接收完成后，在该回调中处理串口数据即可
* [$ @; {1 S8 y9 U; F

1. void Uart_recvCallBack(void *buf, int len)
   
2. {
   
3. 
   0 Z2 R" d$ S" H% I7 G
4. }

复制代码

8 O7 R1 L9 J+ k: a+ T外部初始化串口

1. myUart_initialize(115200,
   
2.                                         USART_WordLength_8b,
   
3.                                         USART_StopBits_1,
   3 N; h" o/ K+ E& c0 ^: v! I" I
4.                                         USART_Parity_No,
   2 L& ?' }+ f7 D& l9 ?- H" \( `0 g
5.                                         Uart_recvCallBack);

复制代码

/ c) K7 g3 f! A' l' F二、源码
) I% b3 e1 B% [1 K9 K+ J9 ZmyUart.h
0 ]9 n7 d4 U( Y! h4 _* x2 j3 W7 e

1. #ifndef __myUart_H
   ) y  o& J/ p9 }1 L& U) L6 N% a
2. #define        __myUart_H
   . `$ {" A- _5 j& G" V0 S! ?
3. 
   * K5 h2 h' Q; y. e6 [
4. #include "stm32f0xx.h"
   / b8 t9 W* E$ B0 I
5. #include "stm32f0xx_usart.h"
   
6. #include "stm32f0xx_gpio.h"
   ' I8 N1 Y$ e. L: @
7. #include "stm32f0xx_rcc.h"
   7 ?2 K5 c+ m9 n7 |% _1 C
8. #include "stm32f0xx_misc.h"
   
9. 
   
10. #define USART_REC_LEN                          200          //定义最大接收字节数
    3 O* Y$ y: T0 Z3 F" k5 B$ t
11. 
    
12. typedef void (*myUart_cb)(void *buf, int len);
    
13. 
    ) A' W  A! z/ u3 B3 S- y
14. void myUart_initialize(   uint32_t USART_BaudRate,
    
15.                                                         uint32_t USART_WordLength,
    % \5 b9 j+ i0 L( q
16.                                                         uint32_t USART_StopBits,
    0 p: }" s, ^: y9 D/ c
17.                                                         uint32_t USART_Parity,
    0 ^) u0 l6 K: a$ S2 y6 N$ z0 _
18.                                                         myUart_cb cb);
    ' E+ S0 B& b" L" o$ a) e& T
19. void myUart_setBaudRate(uint32_t USART_BaudRate);
    
20. void myUart_sendByte(uint8_t byte);
    . u' q- F; ]% ?2 c. ?
21. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length);
    
22. uint8_t myUart_recvByte(void);
    
23. int fputc(int ch, FILE *f);
    
24. 
    2 \7 D7 K7 r) {  o8 y- j
25. #endif /* __UART_H */
    

复制代码

myUart.c

1. #include "myUart.h"
   / R+ T. I) I7 j3 {% m
2. 
   
3. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   
4. 
   $ K8 q0 F! O6 F; u" S
5. uint8_t USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
   
6. uint16_t USART_RX_count = 0;       //接收状态标记               
   7 b# z. `1 D0 c1 _0 {% e
7. myUart_cb myUart_callBack;
   3 I# D! I+ ~2 ~5 p8 c" B& x! m7 G2 }- a
8. /* Private functions ---------------------------------------------------------*/
   
9. 
   ; o' i3 G2 _! I1 E
10. USART_InitTypeDef USART_InitStructure;
    
11. 
    
12. void myUart_initialize(   uint32_t USART_BaudRate,
    " Z& @$ L$ o" ]6 B
13.                                                         uint32_t USART_WordLength,
    
14.                                                         uint32_t USART_StopBits,
    
15.                                                         uint32_t USART_Parity,
    2 k7 ], U- N( C4 `0 b. x6 ?
16.                                                         myUart_cb cb)
    
17. {  
    
18. 
    * X4 Z% r* b* v6 m2 @0 G3 P+ D) I7 q
19.         GPIO_InitTypeDef  GPIO_InitStructure;
    
20.         NVIC_InitTypeDef NVIC_InitStructure;
    * k: C; J0 t& V( i# `0 M/ S
21. 
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE );
    
23. 
    
24.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
    $ ]; N: [( x  g9 l" i
25.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);        
    & h/ Z" B  X. W3 E! q- s& z
26.         /*
    
27.         *  USART1_TX -> PA9 , USART1_RX ->        PA10
    
28.         */                                
      s) z3 p; C+ [7 m
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;                 
    / ~, B/ p) g( m6 ?3 |/ K  P1 d
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    6 T. B$ A' k& w% z2 U
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
32.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
33.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
34.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
    
35. 
    
36.         //Usart1 NVIC 配置
    " k& a  K' c3 s# J6 A
37.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
38.         NVIC_InitStructure.NVIC_IRQChannelPriority=1 ;//抢占优先级3
    
39.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    ; P4 A5 t. ~, |; A# \
40.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
41. 
    
42.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    % [- P, `$ l3 w$ [) a$ ?& E
43.         USART_InitStructure.USART_WordLength = USART_WordLength;//设置数据位
    
44.         USART_InitStructure.USART_StopBits = USART_StopBits;//设置停止位
    
45.         USART_InitStructure.USART_Parity = USART_Parity;//设置效验位
    & Q1 ]) f* w1 J" r* c9 R
46.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//设置流控制
    
47.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//设置工作模式
    7 [2 ?9 r  [! Q/ i) ?% @! \
48.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    5 k/ V% o) {! @
49. 
    
50.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    8 W( [& d  H9 F% S  ~
51.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接受超时中断
    
52.         USART_Cmd(USART1, ENABLE);//使能串口1
    ! |" H  L/ @# R  c
53. 
    : }7 d2 X0 f1 T& I
54.         myUart_callBack = cb;
    ( r6 i, F3 D% r3 _8 u
55. }                        
    8 s% T/ ~  Y8 J3 B. c
56. void myUart_setBaudRate(uint32_t USART_BaudRate)
    ' F& h! J  i, o7 H
57. {
    9 N& e1 \" I4 g5 {
58.         USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
    . X6 F' {+ W( C0 S, X
59.         USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);
      V2 ^% H$ {4 `# y9 ~* P
60.         USART_Cmd(USART1, DISABLE);
    
61. 
    
62.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    
63.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    
64. 
    2 L' [) y) Z6 H% x3 c8 W5 F
65.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接收中断
    
66.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接收超时中断
    
67.         USART_Cmd(USART1, ENABLE);//使能串口1
    , B" A, {& E! H- G1 z2 q' a
68. }
    % Z, ^+ Z9 j0 o* k
69. void myUart_sendByte(uint8_t byte) //发送1字节数据
    
70. {
    
71. while(!((USART1->ISR)&(1<<7)));
    + ~4 s! N7 ~. e, \6 H
72. USART1->TDR=byte;        
    ) ?. S+ O' ?" ~( r' `& L+ K
73. }               
    
74. 
    - h$ `$ l: ]! [9 J
75. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length)
    + W; s  J; b3 r
76. {
    
77.         while(Length != 0)
    * }9 g) |# m( X; o( Y7 z7 y
78.         {
    : t$ a0 d! K6 K( ^4 I' i3 G8 `2 W
79.                 while(!((USART1->ISR)&(1<<7)));//等待发送完
    
80.                 USART1->TDR= *Buffer;
    
81.                 Buffer++;
    9 F2 o1 a4 ]4 \% F! I6 W3 G6 [! u
82.                 Length--;
    1 i1 l, a# Z# ~( |. i
83.         }
    
84. }
    % X$ B' i. k, U' G8 @  f
85. 
    
86. uint8_t myUart_recvByte(void)
    8 o) i8 J- E, t, N5 o0 ?
87. {        
    ! `& o, Q0 b5 g! Y" ~
88.         while(!(USART1->ISR & (1<<5)));//等待接收到数据
    / F8 M2 `) D8 a" ^
89.         return(USART1->RDR);                         //读出数据
    ' M* K- y7 B* f) F$ Y: D4 D
90. }
    
91. 
    $ b# s* O' _! E$ Q/ x5 K& Y
92. 
    
93. PUTCHAR_PROTOTYPE
    
94. {
    1 t0 o" Q. v, u( M
95. /* 将Printf内容发往串口 */
    
96.   USART_SendData(USART1,(uint8_t)  ch);
    
97.   while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    . Q0 J/ d5 Q4 M* \4 e7 F* F) W. Q) E
98.         {}
    
99. 
    , _7 V4 Q7 X. b! U1 L
100.   return (ch);
     4 l/ Y& H9 g$ ^  n+ C7 ^
101. }
     
102. 
     5 g1 H) R$ d- h7 Y! K8 ]9 ]% t
103. void USART1_IRQHandler(void)                        //串口1中断服务程序
     
104. {
     
105.         uint8_t Res;
     6 N* i/ Y* E* T5 n' k% {
106. 
     & `* K& E8 e) E4 N2 c2 O9 H
107.         if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
     
108.         {
     
109.                 USART_ClearITPendingBit(USART1, USART_IT_IDLE);//USART_IT_IDLE需要手动清除
     . H9 h) e$ x% K4 x8 D. t
110.                 if (USART_RX_count)
     6 G8 Q/ [1 t! Y$ X
111.                 {
     
112.                         if (myUart_callBack)
     + {5 }$ ?" }% H. l
113.                         {
     
114.                                 myUart_callBack(USART_RX_BUF, USART_RX_count);
     
115.                         }
     
116.                 }
     
117.                 USART_RX_count = 0;
     
118.         }
     / b0 P' N7 z  O6 o' x3 N
119.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断
     ) @$ V8 A: c) ~4 ?
120.         {
     - t; h7 _& M) I; P% x6 }1 K$ E2 m8 H: q
121.                 USART_RX_BUF[USART_RX_count] = USART_ReceiveData(USART1);        //读取接收到的数据，自动清除USART_IT_RXNE中断标志
     : B# L* h& l& v* q! U) J
122.                 USART_RX_count ++;
     
123.         }
     
124. }
     4 v/ U$ {! [8 u' ]# Z0 j& n
125. 
     

复制代码

& V. r, a+ }9 C4 h9 M; a