串口通讯(Serial Communication)是一种设备间非常常用的串行通讯方式，因为它简单便捷，因此大部分电子设备都支持该通讯方式，其通讯协议可分层为协议层和物理层。物理层规定通信协议中具有机械、电子功能的特性，从而确保原始数据在物理媒体的传播；协议层主要规定通讯逻辑，统一双方的数据打包、解包标准。通俗的讲物理层规定我们用嘴巴还是肢体交流，协议层规定我们用中文还是英文交流。下面分析一下串口通讯协议的物理层和协议层。

物理层
7 W& y+ p# E8 M" ^: V1.通讯结构
串口通讯的物理层的主要标准是RS-232标准，其规定了信号的用途、通讯接口及信号的电平标准，其通讯结构如下：
0 B7 x% ]: w) F& ~* D% k
. R+ C% w+ V5 X2 L4 K

在设备内部信号是以TTL电平标准传输的，设备之间是通过RS-232电平标准传输的，而且TTL电平需要经过电平转换芯片才能转化为RS-232电平，RS-232电平转TTL电平也是如此。
2.电平标准
% E! [7 x) h0 }& [7 g* g  B% T根据使用的电平标准不同，串口通讯可分为 RS-232标准 及TTL标准，具体标准如下：



在电子电路中常使用TTL的电平标准，但其抗干扰能力较弱，为了增加串口的通讯距离及抗干扰能力，使用RS-232电平标准在设备之间传输信息，经常使用MA3232芯片对TTL电平及RS-232电平进行相互转换。
& Y1 O5 n2 y' {& M
2 t7 ?6 D* u1 d6 m; s6 X6 E
4 f/ F+ F" T6 I* Q协议层
1.数据包
串口通讯的数据包由发送设备通过自身的TXD接口传输到接收设备得RXD接口，在协议层中规定了数据包的内容，具体包括起始位、主体数据（8位或9位）、校验位以及停止位，通讯的双方必须将数据包的格式约定一致才能正常收发数据。


  w+ P0 T0 e. ?% p& `7 n
, ]0 l; g- |6 `
/ d+ U( i5 E, a% h! O9 a. L2.波特率
由于异步通信中没有时钟信号，所以接收双方要约定好波特率，即每秒传输的码元个数，以便对信号进行解码，常见的波特率有4800、9600、115200等。STM32中波特率的设置通过串口初始化结构体来实现。
$ v. M4 i' s2 R; D& y
3.起始和停止信号
0 i, @- A1 x8 r  y数据包的首尾分别是起始位和停止位，数据包的起始信号由一个逻辑0的数据位表示，停止位信号可由0.5、1、1.5、2个逻辑1的数据位表示，双方需约定一致。STM32中起始和停止信号的设置也是通过串口初始化结构体来实现。
9 J: C; l: Y/ m) F: w' w* K
4.有效数据
+ I- V. q$ F' O9 P, x有效数据规定了主题数据的长度，一般为8或9位，其在STM32中也是通过串口初始化结构体来实现的。
5 z9 n& F8 S8 Q, u0 ?
' t2 m+ U& x" I% N5.数据校验
2 P: t1 x% \. Q8 a& b5 I; Q. t5 E在有效数据之后，有一个可选的数据校验位。由于数据通信相对更容易受到外部干扰导致传输数据出现偏差，可以在传输过程加上校验位来解决这个问题。校验方法有奇校验(odd)、偶校验(even)、 0 校验(space)、 1 校验(mark)以及无(noparity)。这些也都可以在串口初始化结构体中实现的。
  Q& b- {' {+ S4 U: T' |
, @5 P' I; z% o- LUSART简介
1 v9 U% _" l) \' z, KUSART(通用同步异步收发器)是一个串行通信设备，可以灵活地与外部设备进行全双工数据交换。有别于 USART 还有一个UART，它是在 USART 基础上裁剪掉了同步通信功能，只有异步通信。简单区分同步和异步就是看通信时需不需要对外提供时钟输出，我们平时用的串口通信基本都是 UART。USART 在 STM32 应用最多莫过于“打印”程序信息，一般在硬件设计时都会预留一USART 通信接口连接电脑，用于在调试程序是可以把一些调试信息“打印”在电脑端的串口调试助手工具上，从而了解程序运行是否正确、如果出错哪具体哪里出错等等。

STM32中一共有5个USART，如示：
5 s% \6 `4 x. y4 u7 ?% G5 Z; C$ \
8 [9 E% A7 c6 P3 }% t" u- R
6 S3 X! i  M/ E- q3 U  C
9 N$ O1 J7 @$ N# C# Z' y* S2 i1 a* CUSART的USB转串口原理图如下：



USART1的发送和接收端口是事先连接好的，如果要使用其他USART只需要将相应的发送接收端口按图连接好即可。


USART有多个中断请求事件：
6 s+ A$ h) o$ b. R6 n  C
/ m7 g, G0 j7 W" _5 m

开发板与上位机的连接
4 T" R3 @7 X% _$ V  Y开发板与上位机之间通过USB线连接，所以在上位机上要配置一个USB转串口 的驱动，以便把USB传输过来的电平转换为TTL电平，TTL电平才能与串口调试助手建立联系。一般使用CH341驱动作为win10下的USB转串口，驱动安装成功的情况下接入USB会在计算机的设备管理器的端口中发现串口：



（win7系统一般选择CH340作为USB转串口驱动。）
; n3 @5 [9 ~% ?# y# x5 O
! b" a( M4 i/ q& C6 `3 W& Y( N( K% a
代码讲解：
6 i; s# z) ]1 Y+ Q% K固件库编程的一大好处就是我们可以根据固件库函数来学习外设的相关知识，而且固件库函数的编写都是建立在对底层寄存器操作上的，所以通过讲解代码可以更好理解串口通讯相关知识。

- y. g7 T# d4 A! r$ m: b- K一.初始化结构体

1. typedef struct {
   7 w! {' k. O2 s8 ?
2. uint32_t USART_BaudRate; // 波特率
   4 \2 u- E$ Z/ F$ S. q
3. uint16_t USART_WordLength; // 字长
   
4. uint16_t USART_StopBits; // 停止位
   ; p. M; v# F$ k7 P+ k' `
5. uint16_t USART_Parity; // 校验位
   
6. uint16_t USART_Mode; // USART 模式
   , Z7 s5 e, Z+ m" T
7. uint16_t USART_HardwareFlowControl; // 硬件流控制
   
8. } USART_InitTypeDef;
   

复制代码

USART初始化结构体中的相应变量都对应着数据包中的相对内容。


1 {: s3 `6 u7 ?- D* Z二.NVIC配置中断优先级
我们在串口接收信息时采用了触发中断事件，所以要配置一下串口中断的优先级：
) H- g7 A* W2 @! c% M

1. NVIC_Configuration(void)
   1 z% e  N* i" o4 H
2. {
   : o. S( [, l& L
3.   NVIC_InitTypeDef NVIC_InitStructure;
   9 L! k7 L! ~6 D2 P3 \4 A
4.   
   
5.   /* 嵌套向量中断控制器组选择 */
   1 W9 g9 a5 _2 g8 u- T% F+ {5 I
6.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   " b6 W  |# m: J7 M& Q7 y/ e* t
7.   
   
8.   /* 配置USART为中断源 */
   
9.   NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART_IRQ;
   1 ]0 K* [6 \0 G
10.   /* 抢断优先级*/
    ; y. S- Y" v9 O2 w  e7 a
11.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
12.   /* 子优先级 */
    
13.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
14.   /* 使能中断 */
      h4 S; T- v7 t5 }, [- p- t) T8 t4 L
15.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
16.   /* 初始化配置NVIC */
    & F- Q& s; S' R! X9 D
17.   NVIC_Init(&NVIC_InitStructure);
    - o" z2 p7 z$ q8 C, J  J5 T
18. }
    

复制代码

三.USART配置函数讲解
6 j( A6 @5 I2 dUSART配置函数的主要作用是打开串口与相应的GPIO引脚，配置好相应串口信息与GPIO引脚的工作模式，以便信息的传输与接收。
# w% n5 c  o# r- H+ h$ C& t. }7 o

1. void DEBUG_USART_Config(void)
   - y3 w- e& V5 A
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStructure;
   # ^/ m5 f2 Z4 K+ @; P
4.         USART_InitTypeDef USART_InitStructure;
   
5.        
   
6.         /* 第一步：初始化GPIO */
   
7.                 // 打开串口GPIO的时钟
   7 |' z0 x# Y/ v9 l1 L( M3 m! j2 i- i
8.         DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
   % X2 W" r% q7 [* z
9.                 // 将USART Tx的GPIO配置为推挽复用模式
   ) d' ~8 x) |! S
10.         GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
    
11.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
12.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ) s( Q$ B- D$ v& ]
13.         GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
    $ M, N$ k- a' P$ L
14. 
    
15.   // 将USART Rx的GPIO配置为浮空输入模式
    5 X/ Z- E/ Q6 S, i
16.         GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
    
17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
18.         GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);       
    
19.        
    5 m0 K) w* x' Q7 d. S" H
20.         /* 第二步：配置串口的初始化结构体 */
    
21.                 // 打开串口外设的时钟
    
22.         DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
    / l. ^  o0 V) g* b, U$ @; t3 F. S! w
23.         // 配置串口的工作参数
    5 ~% A% p" P8 a2 N( m) K; H
24.         // 配置波特率
    
25.         USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
    
26.         // 配置 针数据字长
    
27.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    5 s5 \2 w) o) M; E, R  j
28.         // 配置停止位
    : g6 H4 E, w' \7 }& g6 m  J* b$ N
29.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    7 Y" T" r: o; I+ U! B" x) r
30.         // 配置校验位
    
31.         USART_InitStructure.USART_Parity = USART_Parity_No ;
    
32.         // 配置硬件流控制
    
33.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    . f3 N) z0 D/ A( T" G& U# g
34.         // 配置工作模式，收发一起
    
35.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    % w/ j7 b  E4 u1 |3 |/ e+ X% ?
36.         // 完成串口的初始化配置
    # O1 \+ x" I% N3 d1 T& @
37.         USART_Init(DEBUG_USARTx, &USART_InitStructure);
    / m7 q/ f5 R  k% y
38. 
    # }) |" W& g- K1 I! K$ ?. }
39. /*--------------------------------------------------------*/
    * u  e+ g6 j4 \! e9 v6 Z
40.         // 串口中断优先级配置
    
41.         NVIC_Configuration();
    
42.        
    ) s, _! b! w) J& i, W) g4 S
43.         // 使能串口接收中断
    
44.         USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);
    * C. J. w, B* _% y$ ^
45. /*--------------------------------------------------------*/
    5 w) v: W4 S3 d% Q6 l0 Z
46.        
    
47.         /* 第三步：使能串口 */       
    
48.                 // 使能串口
    7 r6 K% H' G! x% f
49.         USART_Cmd(DEBUG_USARTx, ENABLE);       
    % [+ i3 _  \( i
50. }
    8 b  h6 r, f: ^, T) d1 U+ J; }

复制代码

9 G$ `8 h3 ~. i5 P8 _第一步：打开了GPIO的时钟，设置发送和接收引脚的信息，将Tx（发送引脚）配置为推挽复用模式用来发送数据，Rx（接收引脚）配置为浮空输入模式用来接收数据。
) q2 J9 j8 F5 \) t" l% F( B
第二步：首先打开USART1 的时钟，根据USART初始化结构体成员配置相关的信息，之后利用初始化函数将初始化结构体中的信息写入相应寄存器中，然后的话就是引用NVIC_Configuration()函数配置串口中断优先级，打开相应的串口接收中断，中断接收函数的参数如下：

4 E, m& [+ v( u  F6 @

第三步 ：最后相当于打开总电源——使能串口
USART配置函数完成后代表，USART1 的接收和发送准备工作已经准备就绪，接下来就是，串口与上位机之间的信息传递了，信息的发送和接收都有相对于的函数。
6 c& ?  E7 Y8 O# F+ C# s5 i! [( c

6 t% Z9 c! J, w4 t' u7 a5 p四.传输数据的函数：
开发板与上位机之间的数据传输可以有多种方法，下面一一介绍：
7 t; N3 D9 m* D- B7 g) n! K7 p
1.发送一个字节
以USART_SendData(pUSARTx,ch); 函数为基础建立的函数可以向上位机发送一个字节的数据，利用FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG) 读取发送数据寄存器的状态来 等待发送寄存器将数据成功发送。

1. void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t ch)
   
2. {
   
3.         /* 发送一个字节数据到USART */
   
4.         USART_SendData(pUSARTx,ch);
   
5.                
   
6.         /* 等待发送数据寄存器为空 */
   ' O! V! }: c( w7 Z3 ~' `0 R
7.         while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);       
   
8. }
   9 G- \) q3 [/ \( S6 a

复制代码

2.发送字符串
5 R( u7 t4 M- f/ n* j( t本质是利用上面的字节发送函数逐位发送字符串中的内容
4 @" `& `- {3 u

1. void USART_SendString(USART_TypeDef * pUSARTx, char *str)
   
2. {
   
3.         unsigned int   k=0;
   " }9 U6 G3 b0 {! X: [3 B
4.         while(*(str+k)!='\0')
   + k; G8 G2 ~, U! K2 R; @5 G) o& B$ s# W
5.         {
   1 o2 D2 s, T, M
6.                 USART_SendData(pUSARTx, *(str+k));
   & ^5 d) R9 k2 ~- {9 C: W9 l0 K
7.                 /* 等待发送数据寄存器为空 */
   5 l/ ^$ F! c! y& k4 {" [
8.                 while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
   
9.                 k++;
   / F1 I) {9 }, d& B
10.         }
    
11.         while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET);   /* TC：传输完成标志 */
    
12. }
    $ B* l% H. i; g; ?3 ~, y' e* w

复制代码

: A; U, i$ {7 e/ v) Q2 ~0 Q- L5 p- ^1 g1 U3.重定向printf函数发送字符串
) C7 ~5 ]8 |7 j7 \4 P关于重定向的知识之前总结过，链接：重定向知识。重定向后的printf()函数功能强大，具有向串口调试助手打印数据的功能，使用方法和c语言时一样，比如printf("欢迎来到小全全的串口实验\n");就可以将“欢迎来到小全全的串口实验”这句话发送到上位机中，而且换行符“\n”还具有换行作用。

1. /* 重定向printf函数 */
   & n. Z- p' Z% _* q: b& w
2. int fputc(int ch, FILE *f)
   0 y% Z8 O4 P+ u! J, K9 j  w$ v/ ^
3. {
   ; i/ a' x; R# ^8 [. @. w) p+ ~
4.         USART_SendData( DEBUG_USARTx,  (uint8_t) ch);
   ! V4 _3 J6 D. _# f( d
5.         /* 等待发送完毕 */
   % W4 `% I# W  [$ W5 Y
6.         while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
   ! s8 d! l2 x$ Y5 O" W4 Z" J
7.         return ch;
   ; {% B& K, Q+ {- U' d
8. }
   2 w1 y4 Z) U7 s0 y

复制代码

1 C; ^/ X: f. v0 A/ C4 ]4.重定向getchar函数接收字符
具体操作与重定向后的printf函数类似，比如可以通过如下代码向上位机发送已经接收到的数据：

1. x=getchar();
   
2. printf("接收到的字符是：%c\n",x);
   + L2 x- T2 {9 t* S/ V; z4 q. C) d

复制代码

0 B: G2 J2 [4 v& d重定义如下：
, G$ E2 @% P# A, Z5 i

1. ///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
   
2. int fgetc(FILE *f)
   ! d3 p' w$ Y' `8 ~
3. {
   1 r5 x5 w* x$ H" K) [  u' r1 i
4.                 /* 等待串口输入数据 */
   9 T3 {( y* u, {: J' ?( M) h
5.                 while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);
   
6. 
   
7.                 return (int)USART_ReceiveData(DEBUG_USARTx);
   
8. }
   

复制代码

在使用此函数作为接收数据时记得关闭串口得接收中断！！！

, V; l! v' j4 ~& D$ W
' w4 ?7 m3 O: \: C% V" W3 p5.通过中断接收
) h- ^0 g4 |1 t) g8 Z6 x) S: s5 C在stm32f10x_it.c中编写USART1中断源相对应得中断函数，利用了固件库函数中的
USART_ReceiveData(DEBUG_USARTx);接收函数
USART_SendData(DEBUG_USARTx, x);发送函数
+ ^0 ]5 N! h. u9 R; ZUSART_GetITStatus(DEBUG_USARTx, USART_IT_RXNE)；判断标志位函数

1. /* #define  DEBUG_USART_IRQn         USART1_IRQn
   6 X2 p9 R" N* b4 K
2.    #define  DEBUG_USART_IRQHandler   USART1_IRQHandler */
   3 u& b8 t# c8 @+ Y+ y' J9 h
3. void DEBUG_USART_IRQHandler(void)
   ( q! s2 r) o, t$ H
4. {
   
5.         uint16_t  x;
   
6.         /* 判断是否收到中断信号 */
   
7.         if(USART_GetITStatus(DEBUG_USARTx, USART_IT_RXNE) == SET)
   ; u7 E+ D& ]8 R5 a8 z  L, r8 `
8.         {
   
9.                 x = USART_ReceiveData(DEBUG_USARTx);
   
10.                 USART_SendData(DEBUG_USARTx, x);
    
11.         }
    ) Z8 j# M; O2 k
12. 
    ' b$ d9 ~6 j( F. l
13. }
    

复制代码

/ T( y2 m- o( ^1 P结语
& x( o9 z% ~, \! A. V以固件库函数编程的思路讲解，未能顾及到众多寄存器的讲解，我认为进行固件库编程本身就是学习操作寄存器的过程，很多时候我们不需要知道如何操作寄存器，只要了解如何操作固件库函数即可。
$ c5 y: u( W4 V- c5 }————————————————
5 ?3 _3 J0 g5 I8 ~版权声明：Aspirant-GQ
% B# d1 S/ i" {
9 ~! S; H. l  }
8 X. t" O& E% ?. A2 h