写在前面
芯片型号：stm32f030c8t6
5 B; b4 A4 o5 k0 M$ y* a8 e( \说明：便宜，用量大
3 x/ r1 t7 D+ d) _* f要点说明：初始化、主函数调用串口接收callback、串口接收空闲中断，串口接收中断
- @# M0 r4 L1 G" R( N4 a这种API封装方式可以拓展到其他单片机，但需要注意单片机是否支持接收空闲中断
本文注意介绍空闲中断的应用，这样就不用在定时器中计时来检测接收超时中断了
5 V! _$ |: J" v7 D; A8 g3 R
一、应用
! P9 W# M! [, r外部定义串口接收回调
当串口数据接收完成后，在该回调中处理串口数据即可

1. void Uart_recvCallBack(void *buf, int len)
   ) m) v$ m/ i4 K0 [( @
2. {
   
3. 
   
4. }

复制代码

0 e4 E% w8 I7 V3 f' A, W  A外部初始化串口

1. myUart_initialize(115200,
   ! H" S" }3 r. a$ a5 D
2.                                         USART_WordLength_8b,
   8 D! G% W+ M& E  i( f. u) ?
3.                                         USART_StopBits_1,
   & F7 D7 p; A! K4 n
4.                                         USART_Parity_No,
   
5.                                         Uart_recvCallBack);

复制代码

二、源码
myUart.h

1. #ifndef __myUart_H
   6 O" E. a/ k% [# c; O/ T
2. #define        __myUart_H
   1 |: q. N8 n! U7 Y* ^) _3 p
3. 
   
4. #include "stm32f0xx.h"
   
5. #include "stm32f0xx_usart.h"
   4 U! K8 Q. q- D! r
6. #include "stm32f0xx_gpio.h"
   ) P! b: t. C' Y# ?+ P4 @  c
7. #include "stm32f0xx_rcc.h"
   # J# q" R9 `+ q' b8 r2 y0 l9 A
8. #include "stm32f0xx_misc.h"
   0 h# g! J& d% f/ _( S
9. 
   $ m) r  }0 T( A: w! o
10. #define USART_REC_LEN                          200          //定义最大接收字节数
    * [7 t; C7 ?: X( R
11. 
    8 Y# V7 R* ?7 }4 G6 d
12. typedef void (*myUart_cb)(void *buf, int len);
    6 G1 a. i% D3 r0 ?
13. 
    8 B3 f7 p0 h; W# C
14. void myUart_initialize(   uint32_t USART_BaudRate,
    
15.                                                         uint32_t USART_WordLength,
    " s6 g4 {  M$ e- y& g' F' P
16.                                                         uint32_t USART_StopBits,
    
17.                                                         uint32_t USART_Parity,
    ; I" y9 M9 `' O* r1 t+ O
18.                                                         myUart_cb cb);
    
19. void myUart_setBaudRate(uint32_t USART_BaudRate);
    
20. void myUart_sendByte(uint8_t byte);
    ' y! j1 T" D4 H- V1 u- |" \, c0 l0 t
21. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length);
    4 O/ M& o4 a# L* n
22. uint8_t myUart_recvByte(void);
    
23. int fputc(int ch, FILE *f);
    
24. 
    
25. #endif /* __UART_H */
    

复制代码

myUart.c

1. #include "myUart.h"
   . V. V5 E0 T8 G) J/ m( E
2. 
   
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;       //接收状态标记               
   
7. myUart_cb myUart_callBack;
   ; K) ^/ |# h* p! d1 ^! F1 ?
8. /* Private functions ---------------------------------------------------------*/
   
9. 
   
10. USART_InitTypeDef USART_InitStructure;
    5 T, o8 Z; }% N" i" _- S! @+ |
11. 
    
12. void myUart_initialize(   uint32_t USART_BaudRate,
    0 Z0 {* ]" a) b. B) S% ~' F
13.                                                         uint32_t USART_WordLength,
    / M4 u9 d4 q) R1 u3 q0 Z
14.                                                         uint32_t USART_StopBits,
    $ ~! l% j! `( _# D. Q
15.                                                         uint32_t USART_Parity,
    
16.                                                         myUart_cb cb)
    
17. {  
    $ `/ w: R" B  R% p
18. 
    
19.         GPIO_InitTypeDef  GPIO_InitStructure;
    
20.         NVIC_InitTypeDef NVIC_InitStructure;
    
21. 
    . v+ o3 i! q7 l  Z8 y
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE );
    
23. 
    
24.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
    1 Y- S& d  K* f" M
25.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);        
    ! k6 F2 A7 {8 A, M! P
26.         /*
    ( J) c5 R$ [, A0 n2 X7 |) c
27.         *  USART1_TX -> PA9 , USART1_RX ->        PA10
    
28.         */                                
    , _, ?5 J+ Q: O7 Z8 m' E8 Q
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;                 
    ! n6 T3 ~9 \9 }# s% g8 `2 s
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    6 E# _0 t# \" e) Z7 g
32.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    . i0 J( d4 t# ]9 I1 f' F7 t  y- h
33.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
34.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
    
35. 
    
36.         //Usart1 NVIC 配置
    
37.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    4 Q# s5 s8 m1 V- ^
38.         NVIC_InitStructure.NVIC_IRQChannelPriority=1 ;//抢占优先级3
    / X  U) k: {* ?% i' E4 T9 A
39.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
40.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    , k1 F9 `6 @7 @/ [5 R4 _- T9 I7 s
41. 
    ( l" I& X' c, A" X( H
42.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    ( L- {9 _: K( T$ n% h9 X
43.         USART_InitStructure.USART_WordLength = USART_WordLength;//设置数据位
    
44.         USART_InitStructure.USART_StopBits = USART_StopBits;//设置停止位
    : E. Y& v5 C. o! ]( z  x! A6 U
45.         USART_InitStructure.USART_Parity = USART_Parity;//设置效验位
    
46.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//设置流控制
    3 A; w6 T2 b  [2 [
47.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//设置工作模式
    
48.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    / A% M5 `6 F6 S; S) L
49. 
    ) h  Y, K- o+ C( W: t1 t
50.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    $ L$ E* f+ \6 B+ w" _
51.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接受超时中断
    : X' V& k* v1 ~, l7 Q
52.         USART_Cmd(USART1, ENABLE);//使能串口1
    . G! _1 x6 v  V* F5 A
53. 
    
54.         myUart_callBack = cb;
    
55. }                        
    . G: C: R" x$ ]& h
56. void myUart_setBaudRate(uint32_t USART_BaudRate)
    ) K" N1 Z  k, V$ Y+ W& g3 S  {
57. {
    ( d9 ?6 K0 S6 H: r+ B) |1 g7 G
58.         USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
    * _5 ~) [! A1 w
59.         USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);
    ) \- \! H) l6 l" X
60.         USART_Cmd(USART1, DISABLE);
    & U2 H4 e# _6 k2 K+ \* m; g* Q" z
61. 
    % c' x, p4 D, ^& W3 o" {5 p
62.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    
63.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    
64. 
    2 m$ J' y* Y  d% R- o3 u
65.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接收中断
    
66.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接收超时中断
    0 q& q+ n6 j) I! {$ ~8 y
67.         USART_Cmd(USART1, ENABLE);//使能串口1
    1 p; R: Z, y; q) @- K* D8 B3 y
68. }
    
69. void myUart_sendByte(uint8_t byte) //发送1字节数据
    + D+ X. G0 i: `! D- z' a# b
70. {
    
71. while(!((USART1->ISR)&(1<<7)));
    
72. USART1->TDR=byte;        
    
73. }               
    7 F* @$ M, A" ^, @, Z
74. 
    . i7 S" ?1 ]# p# r
75. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length)
    
76. {
    
77.         while(Length != 0)
    ! ]5 t' g1 x$ u. H  ~6 E
78.         {
    
79.                 while(!((USART1->ISR)&(1<<7)));//等待发送完
    
80.                 USART1->TDR= *Buffer;
    
81.                 Buffer++;
    - ]+ Y( `/ k2 Y3 n# u- e- Z8 r( ?
82.                 Length--;
    : S) ~( f, R  |) O5 T
83.         }
    ' L! {. e6 g$ O% K0 _" q
84. }
    / _. o! i: |2 Y
85. 
    
86. uint8_t myUart_recvByte(void)
    
87. {        
    
88.         while(!(USART1->ISR & (1<<5)));//等待接收到数据
    
89.         return(USART1->RDR);                         //读出数据
    
90. }
    # r7 \! F( B2 N7 }& q
91. 
    
92. 
    
93. PUTCHAR_PROTOTYPE
    
94. {
    
95. /* 将Printf内容发往串口 */
    
96.   USART_SendData(USART1,(uint8_t)  ch);
    
97.   while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    
98.         {}
    
99. 
    ( \* }) M8 `+ B6 |% t3 F
100.   return (ch);
     
101. }
     ; b) {9 M/ c/ a5 g4 E
102. 
     
103. void USART1_IRQHandler(void)                        //串口1中断服务程序
     
104. {
     
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)
     ( p* `- d& G  X2 G7 ]
111.                 {
     - }# E0 ?, D& C  C
112.                         if (myUart_callBack)
     
113.                         {
     
114.                                 myUart_callBack(USART_RX_BUF, USART_RX_count);
     - q$ u# x0 g! U: u
115.                         }
     
116.                 }
     
117.                 USART_RX_count = 0;
     1 V- \# U3 i1 k3 Q; r
118.         }
     ; t# @: j4 F7 A8 `, L
119.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断
     
120.         {
     ! f( }; v9 f) y* V8 l
121.                 USART_RX_BUF[USART_RX_count] = USART_ReceiveData(USART1);        //读取接收到的数据，自动清除USART_IT_RXNE中断标志
     
122.                 USART_RX_count ++;
     
123.         }
     + s2 B9 o* N8 ]. h
124. }
     " A+ R6 L3 `' a: C# M
125. 
     0 O5 B9 n5 F' n

复制代码

% E- L8 m6 }, k: ]8 w" x# q# Y