前言
! e4 V4 t& Q  j" y本文参考了网上的博文，并加以归纳总结，帮助新手从入门到放弃 。
$ ?- W) O7 G+ ]8 u
+ V6 i) H! X* t7 y7 b- J  O1 Z$ K提示：以下是本篇文章正文内容

$ f3 f; D- h" U  x% q7 y一、串口
7 {5 a2 N7 Q% d" i串口是什么？
串口通信（Serial Communications）的概念非常简单，串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。它很简单并且能够实现远距离通信。比如IEEE488定义并行通行状态时，规定设备线总长不得超过20米，并且任意两个设备间的长度不得超过2米；而对于串口而言，长度可达1200米。典型地，串口用于ASCII码字符的传输。通信使用3根线完成，分别是地线、发送、接收。由于串口通信是异步的，端口能够在一根线上发送数据同时在另一根线上接收数据。其他线用于握手，但不是必须的。串口通信最重要的参数是波特率、数据位、停止位和奇偶校验。对于两个进行通信的端口，这些参数必须匹配。
; O; s- C% K; w( `
/ N8 g5 Q# k& l( Q0 Y串口通信的方式又分为并行通信和串行通信两种；
) ~' B/ W0 L# x9 ]( O! `0 }  g
0 T: c& i- L" r  H- p: p并行通信
并行通信通常是用多条数据线同时传送数据字节，如图11.1所示。
. Y2 R2 l$ h- u
' }" Q+ Q% o6 {* Z- z$ `
/ A0 e  [2 i1 s4 V3 U0 z
发送设备输出的8位数据，以并行的方式同一时间发送到接收设备上。下面的两根线分别作为询问和应答。询问在发送数据时给接收设备发一个信息，询问接收设备准备好了没有，如果接收设备回一个信息，说准备好了，那么发送设备就把8位数据发送过去。这就是并行通信的工作流程。

$ h* E  y5 {0 g1 ~2 S1 E并行通信的特点： 把数据字节用几条线同时进行传输，传输速度快，信息率高。但使用的传输线多，在长距离传输时成本高。

- o" m+ J5 t1 ^; T& A4 d串行通信
串口通信是将数据字节分成一位一位的形式在一条传输线上逐个传送，如图11.2所示.



从低位开始传送过去，首先传送的是低位的D0，然后是D1、D2，一直到D7，接收位都收齐之后，再还原成一个字节。这种传送方式就是串行通信。

串行通信的特点： 使用的传输线少，布线比较简单，再远距离通信时成本较低，速度没有并行通信快。
$ O& c- z& N% b( i$ @# p2 y& [$ C& Z
3 _" Q1 D/ a& @8 q3 \" e8 t6 L/ P串行通信（按照数据传送方向）还可以分类为：单工、半双工和全双工；
6 U+ a# |$ ]' ?$ X$ I
: p; N7 v7 J5 ~, c) |+ k% @9 ^
7 ~# ?/ \- N2 R) u1 [& ?
5 u6 F1 v- D, b  q
/ t6 U# i0 e+ ?
* R8 T8 V  r5 l2 a  d! x
串行通信（按照通信方式）还可以分类为：异步通信和同步通信。
+ [9 X4 Y$ j9 Y9 b! A
3 }' z4 K* K* {( y
; Y- y4 F; E8 V1 V- K. G5 X

" n1 m: L& f- M( R


/ L0 K  k% \! ?在异步通讯中不使用时钟信号进行数据同步，它们直接在数据信号中穿插一些用于同步的信号位，或者将主题数据进行打包，以数据帧的格式传输数据。通讯中还需要双方规约好数据的传输速率（也就是波特率）等，以便更好地同步。常用的波特率有4800bps、9600bps、115200bps等。
) J" D: W. r5 w8 K* l
& x7 a9 x1 G0 U: V5 r上图为异步通信，下图为同步通信；

! I# h* ]& x1 q  g9 E3 N. m
9 U/ A6 ^) e) w8 K
在同步通讯中，收发设备上方会使用一根信号线传输信号，在时钟信号的驱动下双方进行协调，同步数据。例如，通讯中通常双方会统一规定在时钟信号的上升沿或者下降沿对数据线进行采样。数据信号所传输的内容绝大部分是有效数据，而异步通讯中会则会包含数据帧的各种标识符，所以同步通讯效率高，但是同步通讯双方的时钟允许误差小，稍稍时钟出错就可能导致数据错乱，异步通讯双方的时钟允许误差较大。
  J$ I- {7 I7 o! I上面的这些东西我就不细讲了，感兴趣的小伙伴可以了解一下。
  v% F. T3 F- ~$ [* l
8 j5 c9 P& a! s常见的串行通信接口


- }0 u5 ^" u$ ]

二、 STM32串口通信基础
UART 和 USART
. u& R+ ?, D) rSTM32的串口通信接口有两种，分别是：UART（通用异步收发器）、USART（通用同步异步收发器）。而对于大容量STM32F10x系列芯片，分别有3个USART和2个UART。
6 C0 {3 K( ?6 A( `7 F6 E9 G
UART引脚连接方法



. b/ q, ~* T$ c$ h+ u; r. RRXD：数据输入引脚，数据接受；TXD：数据发送引脚，数据发送。
9 \5 Y- I5 B3 H: L对于两个芯片之间的连接，两个芯片GND共地，同时TXD和RXD交叉连接。这里的交叉连接的意思就是，芯片1的RxD连接芯片2的TXD，芯片2的RXD连接芯片1的TXD。这样，两个芯片之间就可以进行TTL电平通信了。
0 ~$ ^/ Q) V# j% ^6 s- z
: {* G0 o) {. u. s0 Z
+ g# Y  y9 O- C  C! c
  A, l7 ~! o; }  M+ ]
  ]$ p+ ?: g" g% p; n* X
2 G. x: `$ b" f% O) i
3 r( m- {0 ~0 C6 fUSART主要特性
4 ?0 _  i/ M7 l4 F  l6 a+ T% u' B- ^, e4 m
; v2 L( @, i) S* g/ g

/ T0 J9 ^4 a  q9 A. ]+ O
" T/ d* \& n! C/ U+ {5 w
+ {6 g3 l- I& T6 l
7 g3 i' {" h% ^我们对这些讲解就讲到这里。现在开始我们的实验，代码按照正点原子而来。
1 e1 N6 K3 d; e9 h: m! [9 d
9 r% l7 b2 k2 K) }三、实验部分
实验步骤
1. 串口时钟使能， GPIO 时钟使能
5 j8 P& V; i4 h4 G) y( B5 w2. 串口复位
7 H( W$ t, f; T$ N! |1 q3. GPIO 端口模式设置
4. 串口参数初始化
$ Y1 T+ Z& s; k$ J$ I! Z7 g5. 开启中断并且初始化 NVIC（如果需要开启中断才需要这个步骤）
6. 使能串口
7. 编写中断处理函数
5 L* C/ M' r8 R4 E9 q
1.串口时钟使能。 串口是挂载在 APB2 下面的外设，所以使能函数为：
& m! B' J( B' I6 l
4 P+ i# d" K" G  n0 u* h+ i1 J6 j

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1)；

复制代码

1 j1 z9 Q7 i/ c+ D2.串口复位。 当外设出现异常的时候可以通过复位设置，实现该外设的复位，然后重新配置这个外设达到让其重新工作的目的。一般在系统刚开始配置外设的时候，都会先执行复位该外设的操作。 复位的是在函数 USART_DeInit()中完成：

1. //void USART_DeInit(USART_TypeDef* USARTx);串口复位
   : J9 B9 M! d; U+ m& D  j8 @
2. USART_DeInit(USART1); //复位串口 1

复制代码

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

6 S9 [+ B6 e  t% R1 m7 s

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

复制代码

这个函数的第一个入口参数是指定初始化的串口标号，这里选择 USART1。
第二个入口参数是一个 USART_InitTypeDef 类型的结构体指针， 这个结构体指针的成员变量用来设置串口的一些参数。 一般的实现格式为：

! O' }. s' B* H

1. USART_InitStructure.USART_BaudRate = bound; //波特率设置;
     x/ @2 F/ ?0 V- k
2. USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为 8 位数据格式
   ; }3 S& U- E5 R4 q# i* f
3. USART_InitStructure.USART_StopBits = USART_StopBits_1; //一个停止位
   
4. USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位
   " r0 {* o* I& ]
5. USART_InitStructure.USART_HardwareFlowControl= USART_HardwareFlowControl_None; //无硬件数据流控制
   ! `/ P" U0 t+ H) q7 n9 G3 G6 v
6. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
   ! |4 ]! B( r9 }' E: z
7. USART_Init(USART1, &USART_InitStructure); //初始化串口

复制代码

$ D* r) F& Q7 J: q# X# t' V" t从上面的初始化格式可以看出初始化需要设置的参数为：波特率，字长，停止位，奇偶校验位，硬件数据流控制，模式（收，发）。 我们可以根据需要设置这些参数。
% {4 c% D% F& z- {4 H5 x
; F. \6 ]4 d  p" r( V& V* H9 C4.数据发送与接收。 STM32 的发送与接收是通过数据寄存器 USART_DR 来实现的，这是一个双寄存器，包含了 TDR 和 RDR。当向该寄存器写数据的时候，串口就会自动发送，当收到数据的时候，也是存在该寄存器内。
STM32 库函数操作 USART_DR 寄存器发送与接收数据的函数是：

! ]; a" P0 ?- G7 |2 I+ M: G

1. void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);
   , D( M6 M" S4 F2 l' [. X
2. uint16_t USART_ReceiveData(USART_TypeDef* USARTx);

复制代码

5.串口状态。 串口的状态可以通过状态寄存器 USART_SR 读取。 USART_SR 的各位描述如图 9.1.1 所示：



, c3 s) ?, y# m1 r( ]
RXNE（读数据寄存器非空），当该位被置 1 的时候，就是提示已经有数据被接收到了，并且可以读出来了。这时候我们要做的就是尽快去读取 USART_DR，通过读 USART_DR 可以将该位清零，也可以向该位写 0，直接清除。

TC（发送完成），当该位被置位的时候，表示 USART_DR 内的数据已经被发送完成了。如果设置了这个位的中断，则会产生中断。该位也有两种清零方式： 1）读 USART_SR，写USART_DR。 2）直接向该位写 0。

" {- K  c% H3 H/ E状态寄存器的其他位我们这里就不做过多讲解，大家需要可以查看中文参考手册。
( ?) x: g7 K6 R# M- x  r在我们固件库函数里面，读取串口状态的函数是：

- H  G0 N% @! v7 i

1. FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG)；

复制代码

1 z0 ~' `! t" A6 |! S& K  O这个函数的第二个入口参数非常关键， 它是标示我们要查看串口的哪种状态， 比如上面讲解的RXNE(读数据寄存器非空)以及 TC(发送完成)。例如我们要判断读寄存器是否非空(RXNE)， 操作库函数的方法是：
0 l1 C: r( W* ?8 O- F% B
+ n  T- ^1 m' {, ]4 M

1. USART_GetFlagStatus(USART1, USART_FLAG_RXNE);

复制代码

我们要判断发送是否完成(TC)，操作库函数的方法是：
' h3 p( ~2 |; p+ v

1. USART_GetFlagStatus(USART1, USART_FLAG_TC);//这些标识号在 MDK 里面是通过宏定义定义的
   
2. #define USART_IT_PE ((uint16_t)0x0028)
   3 J' g4 D% T+ T
3. #define USART_IT_TXE ((uint16_t)0x0727)
   " V% ?8 E' _! Y4 U
4. #define USART_IT_TC ((uint16_t)0x0626)
   
5. #define USART_IT_RXNE ((uint16_t)0x0525)
   
6. #define USART_IT_IDLE ((uint16_t)0x0424)
   - F: x# q  h& T1 }: e# t' p4 q5 B
7. #define USART_IT_LBD ((uint16_t)0x0846)
     m6 V' A& O9 r& F! w4 F  z, c
8. #define USART_IT_CTS ((uint16_t)0x096A)
   
9. #define USART_IT_ERR ((uint16_t)0x0060)
   
10. #define USART_IT_ORE ((uint16_t)0x0360)
    " I8 v8 W8 O! @  T
11. #define USART_IT_NE ((uint16_t)0x0260)
    ' J1 h' x3 b& C$ p1 q" _
12. #define USART_IT_FE ((uint16_t)0x0160)

复制代码

6.串口使能。 串口使能是通过函数 USART_Cmd()来实现的，这个很容易理解，使用方法是：

- _) }* r+ [9 ?+ C6 l: X) k

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

复制代码

+ L- M! j2 c: m% K9 C) e7.开启串口响应中断。 有些时候当我们还需要开启串口中断，那么我们还需要使能串口中断，使能串口中断的函数是：
; H& Y0 k' l+ S- m) \

1. void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT,
   + ?- C$ h7 v5 x* M8 z
2. FunctionalState NewState)

复制代码

这个函数的第二个入口参数是标示使能串口的类型， 也就是使能哪种中断， 因为串口的中断类型有很多种。 比如在接收到数据的时候（RXNE 读数据寄存器非空），我们要产生中断，那么我们开启中断的方法是：
, r4 F( P1 f! d: U

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

复制代码

我们在发送数据结束的时候（TC， 发送完成） 要产生中断，那么方法是：
# D" _5 h4 T1 T( o7 Y$ I9 D4 t
* K+ g* y* t4 J8 F

1. USART_ITConfig(USART1， USART_IT_TC， ENABLE);

复制代码

8.获取相应中断状态。 当我们使能了某个中断的时候，当该中断发生了，就会设置状态寄存器中的某个标志位。 经常我们在中断处理函数中，要判断该中断是哪种中断，使用的函数是：
8 F' N* s* K" S8 T
3 b! N8 U$ ^$ e% D# y5 L, h

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

复制代码

比如我们使能了串口发送完成中断，那么当中断发生了， 我们便可以在中断处理函数中调用这个函数来判断到底是否是串口发送完成中断，方法是：

9 q. ]7 d1 O# L, U1 G6 W# h2 n8 N

1. USART_GetITStatus(USART1, USART_IT_TC)

复制代码

返回值是 SET，说明是串口发送完成中断发生。
' T  Y5 {9 I% R7 n通过以上的讲解，我们就可以达到串口最基本的配置了，关于串口更详细的介绍，请参考
《STM32 参考手册》第 516 页至 548 页，通用同步异步收发器一章。

1 q# O6 P8 v, R% \我们也要看一下IO的设置：


2 g0 I9 Y! k& g% ]# A
5 i2 f4 D# L  _! Q8 Zusart.c

1. //初始化 IO 串口 1
   / O" ]. b; K* K0 L& ~0 m" u) S
2. //bound:波特率
   
3. void uart_init(u32 bound)
   
4. {
   
5. GPIO_InitTypeDef GPIO_InitStructure;
   
6. USART_InitTypeDef USART_InitStructure;
   
7. NVIC_InitTypeDef NVIC_InitStructure;
   # J: I+ o" R- w2 d" l
8. //①串口时钟使能， GPIO 时钟使能，复用时钟使能
   6 f7 h6 t+ q; }- |9 W. p
9. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|
   
10. RCC_APB2Periph_GPIOA, ENABLE); //使能 USART1,GPIOA 时钟
    
11. //②串口复位
    
12. USART_DeInit(USART1); //复位串口 1
    2 ~1 O1 X& F3 L& ^+ T
13. //③GPIO 端口模式设置
    * {- K5 K# \- B) \0 l
14. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //ISART1_TX PA.9
    
15. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
16. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
    
17. GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化 GPIOA.9
    # b6 `7 r1 c2 G
18. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //USART1_RX PA.10
    
19. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
    
20. GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化 GPIOA.10
    
21. //④串口参数初始化
    
22. USART_InitStructure.USART_BaudRate = bound; //波特率设置
    
23. USART_InitStructure.USART_WordLength = USART_WordLength_8b; //字长为 8 位
    
24. USART_InitStructure.USART_StopBits = USART_StopBits_1; //一个停止位
    * }: J, C3 m! p9 S0 c; ?. Q
25. USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位
    
26. USART_InitStructure.USART_HardwareFlowControl
    * I  |+ P$ g8 M, y- x$ {
27. = USART_HardwareFlowControl_None; //无硬件数据流控制
    % _- k) v& }) U: W: n# e  Z. v! S. u
28. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//收发模式
    * n! A+ F) P, v$ p9 ~9 n
29. USART_Init(USART1, &USART_InitStructure); //初始化串口
    0 i+ ?8 u0 a# j+ x! i2 K4 w
30. #if EN_USART1_RX //如果使能了接收
    $ ?. t/ |4 ^% j7 G8 R6 j
31. //⑤初始化 NVIC
    2 i1 u; ^6 c7 S6 v# w
32. NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
33. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ; //抢占优先级 3
    7 I# f7 D" ]& ?6 S0 h
34. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级 3
    
35. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ 通道使能
    : ?$ B$ [) f+ o( v3 y
36. NVIC_Init(&NVIC_InitStructure); //中断优先级初始化
    2 Q8 y3 ]0 d+ f* O; }) x/ \3 c
37. //⑤开启中断
    9 W" C6 ^, ^6 D
38. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //开启中断
    ' x  B- U  B; l. \3 L' i: P' \4 c8 C
39. #endif
    # j6 Q; k# P& F5 U% q& B' i$ E
40. //⑥使能串口
    $ J: D& J' z( ]+ Z; x: L
41. USART_Cmd(USART1, ENABLE); //使能串口
    5 n* k  M: A% N0 |4 Z1 v( C7 Q
42. }

复制代码

/ \) t  R+ @  X2 Hmain.c

1. #include "led.h"
   7 V. q' ^9 q* D- C
2. #include "delay.h"
   
3. #include "key.h"
   
4. #include "sys.h"
   
5. #include "usart.h"
   
6. int main(void)
   4 I3 q" I+ L# o' Q
7. {
   5 Z) @5 E2 A2 q7 D" M/ K
8.         u8 t;
   
9.         u8 len;
   ( A1 r, c+ O" }& O" J
10.         u16 times=0;
    / Z6 Y4 l$ w' M) z9 K5 D& K
11.         delay_init(); //延时函数初始化
    0 q9 n9 m8 @3 _
12.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 设 置 NVIC 中 断 分 组 2
    
13.         uart_init(115200); //串口初始化波特率为 115200
    , K* Z/ ~! B5 ?& y
14.         LED_Init(); //LED 端口初始化
    4 b1 C) W  R" e$ ?! O3 E1 Q
15.         KEY_Init(); //初始化与按键连接的硬件接口
    
16.         while(1)
    
17.         {
    5 C' D, O% Y% e: n  q$ {
18.                 if(USART_RX_STA&0x8000)
    & c( \$ A4 O, a: Z' T3 N" Q3 a
19.                 {
    7 P9 a; R6 {2 r% a
20.                         len=USART_RX_STA&0x3f; //得到此次接收到的数据长度
    
21.                         printf("\r\n 您发送的消息为:\r\n\r\n");
    
22.                         for(t=0;t<len;t++)
    / d2 p8 C2 N7 p: ]. E& ^. }' `0 h
23.                         {
    
24.                                  USART_SendData(USART1, USART_RX_BUF[t]); //向串口 1 发送数据
    , h/ w. v2 Y7 \6 B
25.                                 while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);
    0 {2 R2 {. l2 ~$ {4 n- H2 q
26.                         //等待发送结束
    6 M3 n7 h- c1 ~+ Y
27.                         }
    " S; Q$ }7 u% i7 H5 c. P3 E
28.                         printf("\r\n\r\n"); //插入换行
    : l4 A5 y( |. F; ]+ U5 C7 I- R
29.                         USART_RX_STA=0;
    
30.                 }else
    $ A* ~) F' H# V8 I0 u4 ^
31.                 {
    
32.                         times++;
    
33.                         if(times%5000==0)
    + X7 J- G) S% M) t, M8 y
34.                         {
    
35.                                 printf("\r\n 战舰 STM32 开发板 串口实验\r\n");
    ) T) I4 O* }( `' v
36.                                 printf("正点原子@ALIENTEK\r\n\r\n");
    
37.                         }
    3 n" B& S, \4 m; D8 |5 F' X( [
38.                         if(times%200==0)printf("请输入数据,以回车键结束\n");
    , Q: Z- d0 f& h3 D
39.                         if(times%30==0)LED0=!LED0; //闪烁 LED,提示系统正在运行.
    1 A* N, |3 C' S3 ?& D
40.                         delay_ms(10);
    
41.                 }
    
42.         }

复制代码

& m2 N! H6 [( W% t
5 T* m5 c9 h5 t

# d; c1 I; J8 {" T" }7 i9 y7 u