写在前面
芯片型号：stm32f030c8t6
2 A; v# w# F  E# b说明：便宜，用量大
要点说明：初始化、主函数调用串口接收callback、串口接收空闲中断，串口接收中断
这种API封装方式可以拓展到其他单片机，但需要注意单片机是否支持接收空闲中断
1 C. f& i1 m# @& P8 z  D+ V本文注意介绍空闲中断的应用，这样就不用在定时器中计时来检测接收超时中断了
( Y/ V( ]  G/ |8 _3 R7 n4 b
一、应用
3 P- Z9 W! G* H& R1 P外部定义串口接收回调
% T+ o6 ]# g7 [7 }* o当串口数据接收完成后，在该回调中处理串口数据即可
7 c, q9 M/ b# @6 G, o9 c# Q; t

1. void Uart_recvCallBack(void *buf, int len)
   
2. {
   
3. 
   # ]7 a0 J' @" n! j1 |3 s; P
4. }

复制代码

! U8 r! W8 ]4 D$ p! D外部初始化串口
0 s8 Z! a8 w7 s7 f1 |

1. myUart_initialize(115200,
   
2.                                         USART_WordLength_8b,
   
3.                                         USART_StopBits_1,
   & W+ B. X. q  A$ t
4.                                         USART_Parity_No,
   
5.                                         Uart_recvCallBack);

复制代码

6 E" V: j7 b6 N( J6 U0 n二、源码
myUart.h

1. #ifndef __myUart_H
   
2. #define        __myUart_H
   
3. 
   
4. #include "stm32f0xx.h"
   ' e" d% s6 L+ O- o$ D  ]
5. #include "stm32f0xx_usart.h"
   
6. #include "stm32f0xx_gpio.h"
   
7. #include "stm32f0xx_rcc.h"
   $ x+ a' b6 c$ @: y
8. #include "stm32f0xx_misc.h"
   
9. 
   
10. #define USART_REC_LEN                          200          //定义最大接收字节数
    8 N% ]6 b6 i6 y8 h% O- F
11. 
    
12. typedef void (*myUart_cb)(void *buf, int len);
    
13. 
    " d' C% @# R  y. _: n
14. void myUart_initialize(   uint32_t USART_BaudRate,
    / F  r; w0 v  X3 Y
15.                                                         uint32_t USART_WordLength,
    
16.                                                         uint32_t USART_StopBits,
    
17.                                                         uint32_t USART_Parity,
    ; y! d* K' [% F$ e  s
18.                                                         myUart_cb cb);
    9 }' I4 e  d- Q0 E. ]
19. void myUart_setBaudRate(uint32_t USART_BaudRate);
    
20. void myUart_sendByte(uint8_t byte);
    5 x7 x. [; s. z+ E% z' Z: a2 Y- z4 e3 R
21. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length);
    
22. uint8_t myUart_recvByte(void);
    , W9 M( [% H' G+ _) Q# {
23. int fputc(int ch, FILE *f);
    ! X* C: d: Y! C5 q, H, D9 L
24. 
    
25. #endif /* __UART_H */
    " L! m1 v- m' f3 U" }* w

复制代码

myUart.c
8 }" m0 t1 [) x

1. #include "myUart.h"
   
2. 
   
3. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   ; A: Z' u8 Y0 t
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;
   9 J7 R  e8 d; B/ |% u3 E
8. /* Private functions ---------------------------------------------------------*/
   
9. 
   % y7 Z2 ]! w9 l( S
10. USART_InitTypeDef USART_InitStructure;
    - L/ L9 Y5 A& D4 L* d
11. 
    0 N: \# c. B9 Q! u; _" w5 N
12. void myUart_initialize(   uint32_t USART_BaudRate,
    
13.                                                         uint32_t USART_WordLength,
    5 u1 |! u5 p( ~
14.                                                         uint32_t USART_StopBits,
    
15.                                                         uint32_t USART_Parity,
    
16.                                                         myUart_cb cb)
    # n$ {" o6 S% |) n: s
17. {  
    $ p! z: z- v9 K$ Q
18. 
    2 z% y/ M- s8 C& f. C8 A5 d8 Z
19.         GPIO_InitTypeDef  GPIO_InitStructure;
    
20.         NVIC_InitTypeDef NVIC_InitStructure;
    
21. 
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE );
    9 F8 u. x) h4 E5 q& F) n
23. 
    : \" y8 l0 i2 i0 d" O; I" L6 J
24.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
    6 C6 ^  d3 ^+ o, p3 I6 b6 N& o/ v- U
25.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);        
    
26.         /*
      [4 d8 p3 b# K" z( b# N
27.         *  USART1_TX -> PA9 , USART1_RX ->        PA10
    
28.         */                                
    # n) Z9 l9 Z4 ~6 W0 N. z2 |
29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;                 
    
30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
31.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      o  B' w' ?  x: I) T# j
32.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    : ?- Z0 m+ ]0 E1 K# {
33.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      w% q3 N' O/ \% @1 Q- p
34.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
    
35. 
    0 s9 V" |2 Y1 g) a- h2 e7 ]2 x
36.         //Usart1 NVIC 配置
    ! y+ \; M7 Z8 o- a. F( x" w- n5 A
37.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
38.         NVIC_InitStructure.NVIC_IRQChannelPriority=1 ;//抢占优先级3
    4 t7 X" ^) ]+ J9 u! j( v3 l
39.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    $ h" y6 f! s# r# g& c
40.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    7 F( I% o7 s1 k& }3 l
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;//设置效验位
    + ]0 Q, E. M# N$ {
46.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//设置流控制
    
47.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//设置工作模式
    
48.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    
49. 
    
50.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    ! _' p6 K3 P* e2 g
51.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接受超时中断
    4 x6 t! U  y. b7 f0 r" J
52.         USART_Cmd(USART1, ENABLE);//使能串口1
    
53. 
    4 M7 b/ [) K# g6 h6 i
54.         myUart_callBack = cb;
    
55. }                        
    ( I% F! U& I! g) [- I
56. void myUart_setBaudRate(uint32_t USART_BaudRate)
    # @  g' T5 u( l7 r5 I, Z8 ?
57. {
    
58.         USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
    
59.         USART_ITConfig(USART1, USART_IT_IDLE, DISABLE);
    
60.         USART_Cmd(USART1, DISABLE);
    
61. 
    $ i4 V+ N% p- t2 O& z
62.         USART_InitStructure.USART_BaudRate = USART_BaudRate;//设置串口波特率
    
63.         USART_Init(USART1, &USART_InitStructure); //配置入结构体
    
64. 
    0 j# o# {6 a* c' t$ W; l
65.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接收中断
    
66.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口接收超时中断
    . f0 q( e, s; \
67.         USART_Cmd(USART1, ENABLE);//使能串口1
    
68. }
    2 m+ H3 E: J6 w# J
69. void myUart_sendByte(uint8_t byte) //发送1字节数据
    * j8 ]; D! x% N6 P! T' n2 s+ o
70. {
    
71. while(!((USART1->ISR)&(1<<7)));
    5 t0 c6 G& }: N* A  }, e
72. USART1->TDR=byte;        
    
73. }               
    
74. 
    
75. void myUart_sendBytes(uint8_t *Buffer, uint32_t Length)
    # p3 M4 N6 f* m1 R& u
76. {
    2 c, u' T" j* f! P
77.         while(Length != 0)
    % u3 d4 i* k; O' A- o
78.         {
    
79.                 while(!((USART1->ISR)&(1<<7)));//等待发送完
    / ~. j3 \9 k- r2 l3 I6 ~0 v8 h
80.                 USART1->TDR= *Buffer;
    
81.                 Buffer++;
    " u% U) d2 i5 S3 f$ B8 Y
82.                 Length--;
    
83.         }
    & {' M2 ~7 X9 i! h; D8 @& x5 v8 |
84. }
    $ v7 z9 o! J$ e: Y1 X* j
85. 
    2 e, Z+ H* q, L8 w0 Q& b
86. uint8_t myUart_recvByte(void)
    
87. {        
    
88.         while(!(USART1->ISR & (1<<5)));//等待接收到数据
    ; r8 g  o7 _) F. U% s; {8 L* P
89.         return(USART1->RDR);                         //读出数据
    
90. }
    ! }- C0 M2 O* Q& L- A' a  @% \
91. 
    
92. 
    ! a; [( f8 C! P" @, b$ K3 m' s
93. PUTCHAR_PROTOTYPE
    5 g9 b; F& `/ F8 l$ {
94. {
    
95. /* 将Printf内容发往串口 */
    
96.   USART_SendData(USART1,(uint8_t)  ch);
      S  W. Z; [0 {6 c, Y! ~: ?! [
97.   while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    
98.         {}
    3 w( b) Q- m) g* m- T2 C5 T
99. 
    
100.   return (ch);
     
101. }
     
102. 
     1 D0 _. n; l2 K2 g1 _! c5 W
103. void USART1_IRQHandler(void)                        //串口1中断服务程序
     ' U; i' O9 f1 a7 N8 M
104. {
     
105.         uint8_t Res;
     
106. 
     ( D; U3 U; F$ k1 S4 q6 }
107.         if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
     $ G3 p. @; W( ~& F" X+ X
108.         {
     
109.                 USART_ClearITPendingBit(USART1, USART_IT_IDLE);//USART_IT_IDLE需要手动清除
     
110.                 if (USART_RX_count)
     : f$ }' I% u# j" w9 q; ~# ]
111.                 {
     4 a; ]& n7 ~* \( D! H
112.                         if (myUart_callBack)
     ( U" l. a: s2 F  d: c$ \
113.                         {
     5 F( K( |/ n# z$ d
114.                                 myUart_callBack(USART_RX_BUF, USART_RX_count);
     ! H! `  A2 @4 a9 e
115.                         }
     2 X$ u/ U: N% K
116.                 }
     0 C$ z+ ^9 x- \" T5 |
117.                 USART_RX_count = 0;
     
118.         }
     , Y( l& s% x, A
119.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断
     , o1 e0 m) m5 k0 [2 Y3 S
120.         {
     
121.                 USART_RX_BUF[USART_RX_count] = USART_ReceiveData(USART1);        //读取接收到的数据，自动清除USART_IT_RXNE中断标志
     
122.                 USART_RX_count ++;
     
123.         }
     
124. }
     
125. 
     1 a$ q* S' B( X

复制代码

. ?' a& |+ g3 H1 \. C8 E