前言
# K1 |2 E$ l" _9 ]' Y本篇用库函数写个简单的串口收发，用的是 STM32F103RCT6 开发板（部分来自正点原子）。
) y1 B/ N: ^2 F+ uSTM32F103RCT6 最多可提供 5 路串口，有分数波特率发生器、支持同步单线通信和半双工
单线通讯、支持 LIN、支持调制解调器操作、智能卡协议和 IrDA SIR ENDEC 规范、具有 DMA
: M- E$ \% a6 F- J2 |. r3 i  ?等。
3 n- l8 H0 X0 k
串口设置的一般步骤可以总结为如下几个步骤：
) I9 _' q! L! q$ M3 G* d
4 Q7 G8 v! @" V7 T- ^串口时钟使能，GPIO 时钟使能
" B, A1 J2 ~, ~串口复位
( O0 r! Q2 S$ y$ k, y$ ?GPIO 端口模式设置
/ ?, ?0 q) B6 D" G* A) [串口参数初始化
开启中断并且初始化 NVIC（如果需要开启中断才需要这个步骤）
3 `" K- L$ s/ Q, f$ N* s使能串口
& f1 }4 R* ?- _' M& ~7 p7 m编写中断处理函数
3 q0 r8 W8 t5 `/ R% g$ K" [一、串口配置步骤
函数和定义主要分布在 stm32f10x_usart.h 和 stm32f10x_usart.c 文件中。

7 S$ x2 D5 \6 m0 ~1.串口时钟使能 串口是挂载在 APB2 下面的外设，所以使能函数为：
% K. M1 h- c9 j' X: P

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1)；

复制代码

. ?) x" E" D5 Y: Q2.串口复位 当外设出现异常的时候可以通过复位设置，实现该外设的复位，然后重新配置
这个外设达到让其重新工作的目的。
复位的是在函数 USART_DeInit()中完成：
, X/ g) G5 v3 Z9 c6 O

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

复制代码

( y: A. E  h, L- ?& @+ `复位串口 1，方法为：

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

复制代码

3.串口参数初始化 串口初始化是通过 USART_Init()函数实现的，
/ G( W6 _6 K% I. i5 m5 c* f

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

复制代码

5 E# z' _% g! m8 i6 |9 x% g9 f第二个入口参数是USART_InitTypeDef 类型的结构体指针，这个结构体指针的成员变量用
来设置串口的一些参数。
一般的实现格式为：

1. USART_InitStructure.USART_BaudRate = bound; //波特率;
   
2. USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为 8 位数据格式
   / K" R3 y* t4 S
3. USART_InitStructure.USART_StopBits = USART_StopBits_1; //一个停止位
   1 }4 O$ l5 d+ C# y9 c! F
4. USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位
   
5. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //无硬件数据流控制
   
6. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
   1 F- q9 S, P  g! j. V: h) ~
7. USART_Init(USART1, &USART_InitStructure); //初始化串口

复制代码

8 |' n4 G7 V2 i0 \- w0 e4.数据发送与接收 STM32 的发送与接收是通过数据寄存器 USART_DR 来实现的，这是
一个双寄存器，包含了 TDR 和 RDR。当向该寄存器写数据的时候，串口就会自动发送，当收
7 M7 R0 R) Y+ n1 r到收据的时候，也是存在该寄存器内。
/ a% j* a" R9 T# g5 l, ySTM32 库函数操作 USART_DR 寄存器发送数据的函数是：

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

复制代码

STM32 库函数操作 USART_DR 寄存器读取串口接收到的数据的函数是：

1. uint16_t USART_ReceiveData(USART_TypeDef* USARTx);

复制代码

6.串口使能 串口使能是通过函数 USART_Cmd()来实现的

1 l/ {; P6 c5 t: r8 @9 \. h

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

复制代码

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

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

复制代码

7 U. g5 R/ ?6 J# w& M6 O3 A% w6 c开启其中之一的中断的方法是：

9 c0 J: a: D: N2 W

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

复制代码

+ J7 ~% n8 d0 k0 E8 T发送数据结束的时候要产生中断：
9 H9 y; ?2 J8 L& ^) x7 v

1. USART_ITConfig(USART1，USART_IT_TC，ENABLE);

复制代码

  X' v' V2 u( U( _& ?) Z6 [' U8.获取相应中断状态 在中断处理函数中，要判断该中断是哪种中断，使用的函数是：
' ?2 H# n. h& Y. F6 ?! M1 i
. @2 j/ x5 q* p( c3 g

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

复制代码

; E- r- n: M$ \% f# {判断是否是串口发送完成中断：

1. USART_GetITStatus(USART1, USART_IT_TC)

复制代码

返回值是 SET，说明是串口发送完成中断发生。
2 M; _3 J) Q; m  G3 O, f# U
二、实际编写
0 e1 U5 I, d: c- O, Z" k1.代码部分
; S4 B% O9 }* L& L+ _8 C——uart.c 文件

①重定向fputc函数
使用串口1(USART1)输出Printf信息

; b0 J( Z" F9 c$ z: ]  A; X8 P: t" ^8 T

1. #if 1  
   
2. #pragma import(__use_no_semihosting)               
   % u! g) ~3 d# P. P
3. //标准库需要的支持函数                  
   % p0 s& E/ i* K6 b, o3 \
4. struct __FILE   
   $ L/ h, L! @3 {: Q' @! [
5. {   
   6 i$ j% f+ q5 d" y& U( n) F
6.     int handle;   
   
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. };   
    7 J* U/ U4 C: q- {9 Z8 r+ J
11. /* FILE is typedef’ d in stdio.h. */   
    4 W1 ], I# w0 p
12. FILE __stdout;         
    : `4 d4 H% T- c5 q
13. //定义_sys_exit()以避免使用半主机模式      
    ' S2 k' T* ?0 Q. n
14. void _sys_exit(int x)   
    ) ?0 e2 P; n# M- h5 \/ [! ]4 m+ M
15. {   
    
16.     x = x;   
    5 q  i% n4 u" ~
17. }   
    
18. //重定向fputc函数  
    . n# k' i. P8 Z- M. W' E; _
19. //printf的输出，指向fputc，由fputc输出到串口  
    
20. //这里使用串口1(USART1)输出printf信息  
    9 X& }& {% o3 s# U& [4 F: C
21. int fputc(int ch, FILE *f)  
    ( O; {( N+ Y5 A" ^3 r- e
22. {        
    ; j  t% {) Z2 u9 q" w* a) l
23.     while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    5 k4 ?* U' a0 c* o" r2 E
24.     USART1->DR = (u8) ch;
    7 h) z! i6 g3 y, J+ R4 I# r  H+ c
25.     return ch;  
    
26. }  
    
27. #endif

复制代码

②GPIO

1. u8 USART_RX_BUF[USART_REC_LEN] __attribute__ ((at(0X20001000)));
     u3 H- {1 I" M
2. //接收缓冲,最大USART_REC_LEN个字节,起始地址为0X20001000.
   3 N! Z* Q: d; X9 E
3. u16 USART_RX_STA=0;       //接收状态标记         
   " F- S  c4 R( f. s
4. u16 USART_RX_CNT=0;                        //接收的字节数         

复制代码

1. void uart_init(u32 bound){
   
2.   //GPIO端口设置（初始化）
   3 M. V, ]6 `& P. b) s
3.     GPIO_InitTypeDef GPIO_InitStructure;
   8 n, I" e4 G: r8 }% \  S
4.         USART_InitTypeDef USART_InitStructure;
   # W' i) S3 B& A( D
5.         NVIC_InitTypeDef NVIC_InitStructure;
   ) o% k/ V/ b0 W! {. e: \
6.          
   : S5 p- ?- X, ~( r3 R
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        
     d& a- {& ?: n% ?3 b
8.         //使能USART1，GPIOA时钟
   / |! Q" d# k. h( _' w4 Q6 ?
9. 
   
10.         //USART1_TX   GPIOA.9
    / t7 C# L% Y+ ^8 Y
11.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    5 ?8 u$ U# j( r: V2 |- M, x
12.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      t+ Q. u1 X# M, K9 C/ r
13.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    6 O2 X4 M6 t7 W  W% v
14.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    . m* Z: d& D( O& s, P: {
15. 
    % k! [. o$ U% P- p2 C1 k
16.   //USART1_RX          GPIOA.10初始化
    4 S# X+ ?" K+ Q0 f2 Z8 h
17.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    
18.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    
19.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    , y" V3 C5 W6 g: I! f: u% K' }! K
20. 
    
21.   //Usart1 NVIC 配置
    ' Z/ v$ ?3 Q! ~$ H
22.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    ) w6 q3 ?' `. s' G0 R, Q( `
23.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    
24.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    ( y5 ^/ n7 z- R4 @+ j  }, }) j
25.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    # u3 D+ C8 |- r5 V: O( [  R- d2 T
26.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
27. 
    ) z0 V/ V9 B) C6 Z! _
28.    //USART 初始化设置
    ( P  T( j1 a3 O* ~1 l: C
29. 
    
30.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    7 v. f8 v5 z% ]# L
31.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
      d& N5 r0 H, ]
32.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
33.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
34.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    4 U; l3 ]- U( @/ O% b! U7 ^, h
35.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
      o" P9 h4 Z* B! E
36. 
    
37.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    4 x0 W7 j- P8 s# v9 p5 ]9 u
38.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    
39.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    1 |, U1 }. {6 U1 m5 s+ H3 P
40. 
    
41. }

复制代码

1. #if EN_USART1_RX   //如果使能了接收
   
2. void USART1_IRQHandler(void)                        //串口1中断服务程序
   . c  m' v) _+ J$ f) U
3.         {
     p. Y7 l" r6 s- G
4.         u8 Res;
   
5. #if SYSTEM_SUPPORT_OS                 //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
   
6.         OSIntEnter();   
   ( f' y2 T" P% Z# s
7. #endif
   
8.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
   7 H; i1 `" F1 Z4 n5 j' h
9.                 {
   
10.                 Res =USART_ReceiveData(USART1);//(USART1->DR);        //读取接收到的数据
    % R: ?9 w2 c/ [0 Y6 _
11.                 if(USART_RX_CNT<USART_REC_LEN)
    
12.                 {
    % x: F6 |# q& c# C3 h, q0 n& d
13.                         USART_RX_BUF[USART_RX_CNT]=Res;
    " ]- j  X# a+ Y' p
14.                         USART_RX_CNT++;                                                                                                      
    " ~+ a% e: j- a
15.                 }                  
    . c  B( h0 D8 _" U! f' X5 u
16.      }
    
17. #if SYSTEM_SUPPORT_OS         //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
    6 C' F8 T. X" v  O
18.         OSIntExit();                                                                                          
    
19. #endif
    
20. }
    
21. #endif        

复制代码

% c0 n. G8 c5 y) S4 f7 S! G——uart.h 文件：

1. #define USART_REC_LEN                          41*1024         //定义最大接收字节数 41K
   
2. #define EN_USART1_RX                         1                //使能（1）/禁止（0）串口1接收
   
3.                   
   
4. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
   
5. extern u16 USART_RX_STA;                         //接收状态标记        
   
6. extern u16 USART_RX_CNT;                                //接收的字节数        
   + `+ k9 d' Q0 h' n2 Q0 r& v; b8 P
7. //如果想串口中断接收，请不要注释以下宏定义
   
8. 
   4 ^! w- N; r! V- q3 ~
9. void uart_init(u32 bound);
   
10. #endif

复制代码

! A( ~8 K. r1 M# g/ m——main.c 文件：
2 ^! H2 |( v  i( D7 e

1. int main(void)
   0 f( g; y- C0 \7 X# W
2. {        
   
3.         u8 t;
   
4.         u8 len;        
   ) r) y- B" d# G/ i. J5 ^/ w) n
5.         u16 times=0;
   
6. 
   ; f$ L. V7 @8 O2 d+ Z$ C' y
7.         delay_init();                     //延时函数初始化        
   
8.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2
   
9.         uart_init(115200);         //串口初始化为115200
   0 W* u7 P  z* O2 o9 g. q. K
10. 
    
11.         while(1)
    ' [' P7 |7 k* x# r+ p2 Y5 ~
12.         {
    
13.                 if(USART_RX_STA&0x8000)
    ' N; l7 w# m2 B2 g- x" H
14.                 {                                          
    # k  b8 ^9 m& z' L+ o* m! \4 L
15.                         len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
    5 S. m6 x: ~- ~0 C! s
16.                         printf("\r\n您发送的消息为:\r\n");
    
17.                         for(t=0;t<len;t++)
    
18.                         {
    
19.                                 USART1->DR=USART_RX_BUF[t];
    8 x" d' I  \# T
20.                                 while((USART1->SR&0X40)==0);//等待发送结束
    
21.                         }
    ; B+ G% ~6 k3 ^. P9 }: Z. O
22.                         printf("\r\n\r\n");//插入换行
    . ~. `/ P5 D( `% A6 e5 h& e* d
23.                         USART_RX_STA=0;
    
24.                 }else
    . m' K. b9 ~3 n# W8 Q0 o
25.                 {
    . g  \  k4 ]& I2 M9 A/ a) O
26.                         times++;
    
27.                         if(times%5000==0)
    ) Y9 `2 e. b" Z/ f/ C0 e
28.                         {
    6 f- R8 W( I. W
29.                                 printf("\r\n串口发送与接收\r\n");
    
30.                                 printf("\r\n123456\r\n\r\n");
    - i2 r6 J0 S; x# ~. ^$ L
31.                         }
    / _9 k; S3 H; Q  m
32.                
    
33.                         delay_ms(10);   
    6 V8 L% {) ?2 K* @. X
34.                 }
    
35.         }         
    . a! J% `: }- G( o' Y
36. }
    3 Q) ~$ m3 z; s/ k; m, j6 k

复制代码

- ]+ `- z9 T" [

- l2 V0 _7 Y) t. X
, O# d2 u# d3 q$ C8 C. S
+ Q6 j; _/ i* s2 }/ E+ P" U5 T% M