前言
本篇用库函数写个简单的串口收发，用的是 STM32F103RCT6 开发板（部分来自正点原子）。
6 d! `$ V% u$ C8 F+ zSTM32F103RCT6 最多可提供 5 路串口，有分数波特率发生器、支持同步单线通信和半双工
# t$ j! @0 T# y单线通讯、支持 LIN、支持调制解调器操作、智能卡协议和 IrDA SIR ENDEC 规范、具有 DMA
' I3 h( }! z) n- B, J' M等。
0 X% z% p' j+ h
; \1 t3 H% u. @+ e* w( k, ]4 I" o串口设置的一般步骤可以总结为如下几个步骤：

串口时钟使能，GPIO 时钟使能
$ W: w- f# G+ b& z( V1 _5 R& J串口复位
GPIO 端口模式设置
串口参数初始化
开启中断并且初始化 NVIC（如果需要开启中断才需要这个步骤）
" }4 m+ r% d$ s' R0 M4 m使能串口
编写中断处理函数
一、串口配置步骤
函数和定义主要分布在 stm32f10x_usart.h 和 stm32f10x_usart.c 文件中。
. j9 T! t) C. n" P& s5 T3 o6 `, B- c$ V
+ j+ a- P$ u. B1 K# C' y1.串口时钟使能 串口是挂载在 APB2 下面的外设，所以使能函数为：
7 e( o9 J7 Z9 X& V8 P) ]7 Z9 x# F
& T2 G% s- n8 p

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1)；

复制代码

2.串口复位 当外设出现异常的时候可以通过复位设置，实现该外设的复位，然后重新配置
0 L- x$ g7 n( c# i$ u这个外设达到让其重新工作的目的。
复位的是在函数 USART_DeInit()中完成：
' a& [( M* t# y
% U5 Y/ x9 ^7 X

1. void USART_DeInit(USART_TypeDef* USARTx);//串口复位

复制代码

; C+ t) I" V' z7 E# {* F) o复位串口 1，方法为：

1. USART_DeInit(USART1); //复位串口 1

复制代码

3.串口参数初始化 串口初始化是通过 USART_Init()函数实现的，

* A  w) |! K( \. X( ?( G! q/ Q

1. void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)；

复制代码

9 v; S  Q7 B% v( V2 k' r+ K2 g第二个入口参数是USART_InitTypeDef 类型的结构体指针，这个结构体指针的成员变量用
来设置串口的一些参数。
一般的实现格式为：

1. USART_InitStructure.USART_BaudRate = bound; //波特率;
   1 u8 E3 |: p0 p3 p( ^
2. USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为 8 位数据格式
   
3. USART_InitStructure.USART_StopBits = USART_StopBits_1; //一个停止位
   0 g7 O9 R( ^3 `7 u2 I" E0 B" P7 r
4. USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位
   $ P4 d+ ~, J) r& U, X( y8 `) }6 L
5. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //无硬件数据流控制
   ! @+ D/ _6 I/ m
6. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
   
7. USART_Init(USART1, &USART_InitStructure); //初始化串口

复制代码

4.数据发送与接收 STM32 的发送与接收是通过数据寄存器 USART_DR 来实现的，这是
一个双寄存器，包含了 TDR 和 RDR。当向该寄存器写数据的时候，串口就会自动发送，当收
3 L6 M8 G8 F8 k8 n到收据的时候，也是存在该寄存器内。
STM32 库函数操作 USART_DR 寄存器发送数据的函数是：

5 q  v$ v3 V. T# X

1. void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

复制代码

) H9 h6 M, V8 zSTM32 库函数操作 USART_DR 寄存器读取串口接收到的数据的函数是：

1. uint16_t USART_ReceiveData(USART_TypeDef* USARTx);

复制代码

- M- Q, }- t1 [' f8 @0 w6.串口使能 串口使能是通过函数 USART_Cmd()来实现的
& b$ T! S9 U$ r
4 r5 O" [& n) [

1. USART_Cmd(USART1, ENABLE); //使能串口

复制代码

7.开启串口响应中断 使能串口中断的函数是：

1. void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState)

复制代码

开启其中之一的中断的方法是：

+ l" G0 v8 q5 N' l9 ?7 _( }

1. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启中断，接收到数据中断

复制代码

3 P- B2 L: l* G  o发送数据结束的时候要产生中断：
) f& W9 I. S' k) u6 E% d
9 H- M6 g. B: w( l: m) H

1. USART_ITConfig(USART1，USART_IT_TC，ENABLE);

复制代码

8.获取相应中断状态 在中断处理函数中，要判断该中断是哪种中断，使用的函数是：
! x" @. s: M/ Q$ ?6 P
& H2 f0 _. v) C* M5 c* r, X* F

1. ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT)

复制代码

判断是否是串口发送完成中断：

1. USART_GetITStatus(USART1, USART_IT_TC)

复制代码

返回值是 SET，说明是串口发送完成中断发生。
; i1 B: u3 p+ p
二、实际编写
9 _! K1 Q7 R+ l  l% M* Q- k2 l7 y2 I9 u1.代码部分
——uart.c 文件
6 T( ?. m; A3 H
' n. Q" z! @6 `9 h8 U7 s. T①重定向fputc函数
使用串口1(USART1)输出Printf信息
  C& w) m- I2 i; D
4 m# S' V" `. o

1. #if 1  
   
2. #pragma import(__use_no_semihosting)               
   : p5 t. K6 r: N' s2 p* T# v  ^* k
3. //标准库需要的支持函数                  
   * R- r' }, ?4 x9 p  D% Z9 P1 f
4. struct __FILE   
   6 C% ]' K+ [+ ^; u0 |) @/ E7 p( `4 b- q
5. {   
   
6.     int handle;   
   " \+ s/ T& P1 ^
7.     /* Whatever you require here. If the only file you are using is */   
   
8.     /* standard output using printf() for debugging, no file handling */   
   
9.     /* is required. */   
   
10. };   
    : \# @* [5 f6 b) j
11. /* FILE is typedef’ d in stdio.h. */   
    
12. FILE __stdout;         
    / W( I& ^) H' L3 k% y
13. //定义_sys_exit()以避免使用半主机模式      
    
14. void _sys_exit(int x)   
    
15. {   
    
16.     x = x;   
    $ m) _6 X; t7 C7 \
17. }   
    
18. //重定向fputc函数  
    / o: q- C; u, [8 N$ u
19. //printf的输出，指向fputc，由fputc输出到串口  
    / n6 ]+ _9 s2 j( Z" P0 I+ G7 I7 @/ P
20. //这里使用串口1(USART1)输出printf信息  
    
21. int fputc(int ch, FILE *f)  
    
22. {        
    % x. [- W% }3 r
23.     while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    ( ~, `3 B& ]* L
24.     USART1->DR = (u8) ch;
    - R/ S5 ~. i: `  F8 d
25.     return ch;  
    $ t1 h0 `2 [' ~0 r9 d$ u0 p% U
26. }  
    
27. #endif

复制代码

% X" P  @9 f4 J4 E" _$ s②GPIO

1. u8 USART_RX_BUF[USART_REC_LEN] __attribute__ ((at(0X20001000)));
   , k' Y2 V9 X6 U1 Q" D, y$ |
2. //接收缓冲,最大USART_REC_LEN个字节,起始地址为0X20001000.
   
3. u16 USART_RX_STA=0;       //接收状态标记         
   
4. u16 USART_RX_CNT=0;                        //接收的字节数         

复制代码

1. void uart_init(u32 bound){
   
2.   //GPIO端口设置（初始化）
   
3.     GPIO_InitTypeDef GPIO_InitStructure;
   
4.         USART_InitTypeDef USART_InitStructure;
   % u0 U3 w- H* F6 J- d; @2 a% K
5.         NVIC_InitTypeDef NVIC_InitStructure;
   5 P6 t. A! ~% `7 w7 B) Y+ B- u
6.          
   - `' Z, B/ `  Y8 Y0 y( D
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        
   
8.         //使能USART1，GPIOA时钟
     G& K" M! i8 z- E4 X
9. 
   ; n+ L1 H6 g2 g* D$ R9 c( ~
10.         //USART1_TX   GPIOA.9
    4 D: e$ r! L: U
11.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    3 y* X3 o6 X( g
12.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ) j8 ^1 g. O4 J0 F; F0 j
13.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    
14.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
15. 
    
16.   //USART1_RX          GPIOA.10初始化
    
17.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
      y1 h; U: x8 \, X. E6 A5 N, o
18.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    
19.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    ' h) M/ R' l0 i5 R: q1 a+ M+ A% ~
20. 
    
21.   //Usart1 NVIC 配置
    % u# x* |, ~7 o7 @7 x. e! j
22.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
23.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    + G, ]4 E5 N5 ~0 N- h
24.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    
25.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    ' S7 \: i  [9 E. n
26.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    9 A8 G4 n4 [' U
27. 
    # t2 T1 R8 [. G+ E* m( S
28.    //USART 初始化设置
    
29. 
    ; U5 p  x% D( `" i  A* v. _" @
30.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    7 V( @( Q: }  U2 H
31.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
32.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
33.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    2 b$ L: k' E( f  ?
34.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    " v4 m( B# D( X0 w# W/ V
35.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    
36. 
    * N/ Z+ K4 T8 }" E  `
37.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    . J4 d; L) l: v% b; k7 e, H
38.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    9 d. N  a" f+ j% }0 T
39.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    
40. 
    " M; L, t7 r9 q7 I1 X4 ?1 j) c
41. }

复制代码

1. #if EN_USART1_RX   //如果使能了接收
   & e% m3 T2 \. Y* K9 r4 P8 _
2. void USART1_IRQHandler(void)                        //串口1中断服务程序
   
3.         {
   
4.         u8 Res;
   
5. #if SYSTEM_SUPPORT_OS                 //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
   
6.         OSIntEnter();   
   # U1 o$ j8 H6 L2 ^  V# e
7. #endif
   
8.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
   
9.                 {
   " b. Y" A. K- H5 I# A4 O& C$ t
10.                 Res =USART_ReceiveData(USART1);//(USART1->DR);        //读取接收到的数据
    ; _( c) T0 S' l* r- [& Q. v
11.                 if(USART_RX_CNT<USART_REC_LEN)
    
12.                 {
    
13.                         USART_RX_BUF[USART_RX_CNT]=Res;
    * N4 N% w' b2 Y' S
14.                         USART_RX_CNT++;                                                                                                      
    
15.                 }                  
    
16.      }
    
17. #if SYSTEM_SUPPORT_OS         //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
    
18.         OSIntExit();                                                                                          
    
19. #endif
    ) K7 q) Y7 b" W) r
20. }
    ; K) z& u* ^& V4 H2 {& p) v2 A
21. #endif        

复制代码

——uart.h 文件：
5 T  t/ Z- x- _2 @( j% c
/ c  }* z& b2 \

1. #define USART_REC_LEN                          41*1024         //定义最大接收字节数 41K
   * L3 \; N8 z; _0 O
2. #define EN_USART1_RX                         1                //使能（1）/禁止（0）串口1接收
   ) n3 n: u( @) O8 d7 q" D
3.                   
   / L8 B# p6 {9 F5 d+ Y0 ^5 b  o8 r  g
4. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
   
5. extern u16 USART_RX_STA;                         //接收状态标记        
   
6. extern u16 USART_RX_CNT;                                //接收的字节数        
   
7. //如果想串口中断接收，请不要注释以下宏定义
   0 `) g& o; j  y; x! |" q- K
8. 
   1 n/ E) T* U: G/ e% u- ], {- k' P
9. void uart_init(u32 bound);
   
10. #endif

复制代码

0 e* \7 F7 A" T+ @——main.c 文件：
) M" b; ^' k) S- w9 p2 A* H& g$ I

1. int main(void)
   4 p9 {5 u9 ?0 O
2. {        
   
3.         u8 t;
   
4.         u8 len;        
   
5.         u16 times=0;
   
6. 
   + z4 O1 W7 b" a* ]
7.         delay_init();                     //延时函数初始化        
   
8.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2
   
9.         uart_init(115200);         //串口初始化为115200
   
10. 
    : z' }3 ~+ h( q' f
11.         while(1)
    ! ~; w+ Z' s+ p4 K, Z4 N! z
12.         {
    0 B. U: B, |& [' d- @
13.                 if(USART_RX_STA&0x8000)
    ! ^$ g4 F( F. s1 Y9 A  e0 B6 V
14.                 {                                          
    
15.                         len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
    
16.                         printf("\r\n您发送的消息为:\r\n");
    
17.                         for(t=0;t<len;t++)
    
18.                         {
    
19.                                 USART1->DR=USART_RX_BUF[t];
    * L0 L) H  o% [6 w$ x
20.                                 while((USART1->SR&0X40)==0);//等待发送结束
    # N6 ?. v! ?' p& p
21.                         }
    ; j' u0 G  }( z. D8 y
22.                         printf("\r\n\r\n");//插入换行
    0 \: x2 S5 ^9 ^2 t
23.                         USART_RX_STA=0;
    ; S, O" y6 g( a& |
24.                 }else
    
25.                 {
    
26.                         times++;
    
27.                         if(times%5000==0)
    . w4 m% Y& h5 H$ u
28.                         {
    
29.                                 printf("\r\n串口发送与接收\r\n");
    + g+ Y1 ^7 a- D! r; Y% ^9 Y
30.                                 printf("\r\n123456\r\n\r\n");
    
31.                         }
    3 f3 l/ i; d9 |: T; b& g
32.                
    . l: [- M9 F9 ~& f' ^
33.                         delay_ms(10);   
    
34.                 }
    " g, Q0 W* Q: Z) x
35.         }         
    
36. }
    

复制代码

+ O3 y+ d) M/ ^8 s5 t: v  U0 k, n
1 y& t  k2 l5 e6 e2 ?6 J
/ ~% ~& Q- P3 e6 j4 }