STM32MP1 M4裸机CubeIDE开发指南——串口通信实验

[复制链接]

STMCU小助手发布时间：2022-9-25 10:24

文章
文章封面:
文章简介:	STM32MP1 M4裸机CubeIDE开发指南——串口通信实验

串口通信实验
本章节我们来学习STM32MP1的串口使用方法，并通过串口发送和接收数据。

14.1 串口简介
在学习串口前，我们先来了解一下数据通信的一些基础概念。
14.1.1 数据通信的基础概念
在单片机的应用中，数据通信是必不可少的一部分，比如：单片机和上位机、单片机和外围器件之间，它们都有数据通信的需求。由于设备之间的电气特性、传输速率、可靠性要求各不相同，于是就有了各种通信类型、通信协议，我们最常见的有：USART、IIC、SPI、CAN、USB等。下面，我们先来学习数据通信的一些基础概念。

1.数据通信方式
按数据通信方式分类，可分为串行通信和并行通信两种。串行和并行的对比如下图所示：

图14.1.1. 1数据传输方式
串行通信的基本特征是数据逐位顺序依次传输，最少只需一根传输线即可完成，所需传输线少成本低，但每次只能传送1bit的信号，比如1Byte的信号需要8次才能发完，传输速率低。串行通讯抗干扰能力强，可用于远距离传输，传输距离可以从几米到几千米。
并行通信是数据各位可以通过多条线同时传输，一次传送8bit、16bit、32bit甚至更高的位数，相应地就需要8根、16根、32根甚至更多的信号线，优点是传输速率高，缺点就是线多成本就高了，抗干扰能力差，因而适用于短距离、高速率的通信。
2. 数据传输方向
根据数据传输方向，通信又可分为全双工、半双工和单工通信，它们的比较如下图所示：

图14.1.1. 2数据传输方式
单工是指数据传输仅能沿一个方向，不能实现反方向传输；
半双工是指数据传输可以沿着两个方向，但是需要分时进行；
全双工是指数据可以同时进行双向传输；
这里注意全双工和半双工通信的区别：半双工通信是共用一条线路实现双向通信（分时进行），而全双工是利用两条线路，一条用于发送数据，另一条用于接收数据。
3. 数据同步方式
根据数据同步方式，通信又可分为同步通信和异步通信。同步通信和异步通信比较如下图所示：

图14.1.1. 3数据同步方式
同步通信要求通信双方共用同一时钟信号，在总线上保持统一的时序和周期完成信息传输。其优点是：可以实现高速率、大容量的数据传输，以及点对多点传输。缺点是：要求发生时钟和接收时钟保持严格同步，收发双方时钟允许的误差较小，同时硬件复杂。
异步通信不需要时钟信号，而是在传输的数据信号中加入起始位和停止位等一些同步信号，以使接收端能够正确地将每一个字符接收下来，某些通信中还需要双方约定传输速率。其优点是：没有时钟信号硬件简单，双方时钟可允许一定误差。缺点是：通信速率较低，只适用点对点传输。
4. 通信速率
在数字通信系统中，通信速率（传输速率）指数据在信道中传输的速度，它分为两种：传信率和传码率。
传信率（Rb）：每秒钟传输的信息量，即每秒钟传输的二进制位数，通常用Rb表示，单位为bit/s（即比特每秒），因而又称为比特率。
传码率(RB)：每秒钟传输的码元个数，通常用RB表示，单位为Bd或Baud（即波特每秒），因而又称为波特率。
比特率和波特率这两个概念又常常被人们混淆。比特率很好理解，我们看看波特率。波特率被传输的是码元，码元是信息被调制后的概念，一个码元可以被表示成多个二进制的比特信息。它们的关系可以用公式Rb=RBlog2M表示，M表示M进制码元。
在二进制系统中，波特率在数值上和比特率相等，但是其意义上不同。例如：以每秒50个二进制位数的速率传输时，传信率为50bit/s，传码率也为50Bd。这是在无调制的情况下，比特率和波特率的数值相等。代入公式：Rb=RBlog2M=RB，M=2。
如果码元是在十六进制系统的话，即使用调制技术的情况下，代入公式：Rb=RBlog2M=4RB，M=16。比如波特率为100Bd，在二进制系统中，比特率为100 bit/s；那么在四进制系统中，比特率为400 bit/s，即1个十六进制码元表示4个二进制数，可见一个码元可以表示多个比特。
注：比特率的单位也常用bps来表示，表示每秒传输的比特数（bit per second）。波特率的单位是波特（Baud）
14.1.2 串口通信接口标准
常用的串行通信接口标准中，有RS-232、RS-422和RS-485接口。

1.接口
（1）RS-232
电脑机箱后面一般会有2个9芯或者25芯的接口，也分别叫DB9和DB25连接器，它们是符合RS-232C标准的串行接口，可用于连接MODEM设备或者工业仪器仪表等，实现设备与电脑相互通迅。我们先来看看RS232接口，下图是DB9针的连接头，左边公头的1脚接的母头的1脚，其它脚也按数字对应相连。

图14.1.2. 1 RS232接口
RS-232C定义了数据终端设备（DTE）和数据通信设备（DCE）之间串行二进制数据交换接口技术标准，我们以DB9连接器为例，此标准接口的主要引脚定义如下表：

表14.1.2. 1 RS232接口引脚信号
使用RS-232，对于一般双工通信，仅需要一条发送线、一条接收线和一条地线就可以实现，这3根线构成共地传输，容易产生共模干扰，抗噪声抗干扰性弱，所以使用RS-232最大通信距离为一般为15m。RS-232只允许一对一通信，以两个计算机通信为例，如果是近距离通信，两个接口可以直连：

图14.1.2. 2两台设备近距离通信
如果是长距离通信，则需要通过数据通信设备，如调制解调器来实现。调制解调器是实现数字信号和模拟信号相互转换的设备。当计算机通过电话线连入互联网时，发送方的计算机发出的数字信号，通过调制解调器转换成模拟信号在电话网上传输；接收方的计算机通过调制解调器将传输过来的模拟信号转换成数字信号。通过调制解调器，两台电脑实现通信。

图14.1.2. 3两台设备远距离通信
（2）RS-422
RS-422采用4线（2根发送、2根接收，如加上地线就5根）、差分方式传输，通过两对双绞线可以实现全双工工作收发。RS-422是一种单机发送、多机接收的双向、平衡传输，即总线上只允许一个主设备，可以有多个从设备，从设备之间不能通信。RS-422输出驱动器为双端平衡驱动器，具有电压放大的作用，且差分电路具有较强的抗干扰能力，所以RS-422的传输距离较长，可达几十米到上千米。
（3）RS-485
RS-485是RS-422的变形，RS-485使用的是一对双绞线，可实现半双工工作，不过，随着技术的发展，RS-485已经有4线方式的了，4线的通信和RS-422一样具有实现多点、双向通信的能力。RS-485采用平衡发送和差分接收的方式，抗噪声干扰性好，传输距离可以达几十米到上千米。

图14.1.2. 4 RS485通信
下表中列出RS-232、RS-422和RS-485的对比：
类型 RS-232 RS-422 RS-485 4线 RS-485 2线

表14.1.2. 2 RS-232、RS-422和RS-485通信对比
2. 电气标准
在电子设计中，要保证不同设备的信号之间的通讯，就会涉及到通信协议以及电平标准，电平标准有很多，常见的电平标准有TTL、RS232、RS485、COMS和LVDS等。TT（Transistor-Transistor Logic)，即晶体管逻辑集成电路，TTL电平是数字电路的一种通用接口电平标准，TTL电平信号直接与集成电路连接，下面我们以一张表格来区分串行通信的电平标准。

表14.1.2. 3电气标准
14.1.3 串口通信协议简介
串口通信是一种设备间常用的串行通信方式，串口按位（bit）发送和按位接收字节，一个字节（Byte）有8位，串口必须把这8位依次发送出去才可以完成一个字节的发送，比起按字节发送的并行通信速率要慢，效率较低，但是所需的线少，成本低，通信较稳定。

图14.1.3. 1串行通信和并行通信
串口通信协议是指规定了数据包的内容，双方需要约定一致的数据包格式才能正常收发数据。在串口通信中，常用的协议包括RS-232、RS-422和RS-485等。
随着科技的发展，RS-232在工业上还有广泛的使用，但是在商业技术上，已经慢慢的使用USB转串口了。现在的很多电脑已经没有DB9接口了，取而代之的是 USB 接口，所以就催生出了很多 USB转串口TTL 芯片，比如 CH340、PL2303 等。通过这些芯片就可以实现串口 TTL 转 USB。STM32的串口输出的是TTL电平信号，如果需要RS-232标准的信号可使用MAX3232芯片换成232电平以后，再通过一根USB转串口线与PC机的串口连接来实现通信。

图14.1.3. 2 USB转串口线
正点原子STM32MP157开发板就是用CH340C芯片来完成串口UART和电脑之间的通信的，开发板引出Type-C接口，硬件连接上非常方便，只需要一根Type-C 线就可以。理论上，USB2.0版本，Type-C接口最大传输速率为480Mbps，而USB3.0以上版本可以达到5Gbps或者更高的传输速率。如下图位号为USB_TTL的接口（Type-C接口）是我们后面串口实验要用到的接口。

图14.1.3. 3正点原子STM32MP157开发板USB_TTL接口
下面我们来学习串口通信协议，这里主要学习串口通信的协议层。
串口通信的数据包由发送设备的TXD接口传输到接收设备的RXD接口。在串口通信的协议层中，规定了数据包的内容，它由启始位、主体数据位、校验位以及停止位组成，通讯双方的数据包格式要约定一致才能正常收发数据，其组成如下图所示。

图14.1.3. 4串口通信协议数据帧格式
串口通信协议数据包组成可以分为波特率和数据帧格式两部分。

1.波特率
串口通信分为同步通信（UART）和异步通信（USART），本章主要讲解的是串口异步通信（USART），异步通信是不需要时钟信号的，但是需要约定两个设备的波特率一致才可以正常通信。波特率表示每秒钟传送的码元符号的个数，所以它决定了数据帧里面每一个位的时间长度。两个要通信的设备的波特率一定要设置相同，常见的波特率是4800、9600、115200等。
根据波特率可以计算出每帧内部数据位各位之间的时间间隔（不是帧与帧之间的时间间隔），1s除以波特率可得时间，例如波特率为115200的时间间隔为1s /115200（波特率） = 8.68us。如果是9600波特率，则时间间隔约为104.2us。
2.数据帧格式
数据帧格式需要我们提前约定好，串口通信的数据帧包括起始位、停止位、有效数据位以及校验位。我们来看看这些数据位：
起始位和停止位
串口通信的一个数据帧是从起始位开始，直到停止位，通信的双方要约定一致。
数据帧中的起始位是由一个逻辑0 的数据位表示，当发出一个逻辑 0 信号，表示传输字符的开始。
数据帧的停止位是数据的结束标志，它可以用 0.5、1、1.5或 2个逻辑1的数据位表示（高电平）。
有效数据位
数据帧的起始位之后，接着就是数据位，也称有效数据位，这就是我们真正需要的数据，有效数据位可以是5、6、7或者8个位长构成一个字符，通常采用ASCII码表示，有效数据位从最低位开始传送，低位（LSB）在前，高位（MSB）在后。
校验位
校验位可以认为是一个特殊的数据位。校验位一般用来判断接收的数据位有无错误，检验方法有：奇检验、偶检验、0检验、1检验以及无检验。下面分别介绍一下：
奇校验是指有效数据位和校验位中是“1”的个数为奇数，比如一个 8 位长的有效数据为：10101001，总共有 4 个“1”，为达到奇校验效果，校验位应设置为“1”，最后传输的数据是8位的有效数据加上 1 位的校验位总共 9位。
偶校验与奇校验要求刚好相反，要求帧数据和校验位中“1”的个数为偶数，比如数据帧：11001010，此时数据帧“1”的个数为 4 个，为达到偶校验效果，所以偶校验位为“0”。
0 校验是指不管有效数据中的内容是什么，校验位总为“0”。
1 校验是校验位总为“1”。
无校验是指数据帧中不包含校验位。
我们一般是使用无检验位的情况。
空闲位
这里还注意到，在数据帧与帧之间有空闲信号，我们也称之为空闲位，空闲位处于逻辑 1 状态（高电平），表示当前线路上没有数据在传送，空闲位的长度是不定的。如下图是异步串口通信中，帧与帧之间的空闲间隔是随机的。

图14.1.3. 5空闲信号是不定长的

14.2 STM32MP1串口简介
14.2.1 STM32MP157串口资源

1.串口功能
STM32MP157的串口资源相当丰富，功能也相当强劲：支持8/16倍过采样、支持自动波特率检测、支持Modbus通信、支持同步单线通信和半双工单线通讯、支持LIN（局域互连网络）、支持FIFO模式、支持调制解调器操作、智能卡协议和IrDA SIR ENDEC规范、具有DMA等等。支持的功能有很多，我们后面的实验主要是使用串口接收中断。
STM32MP1的串口分为两种：USART（即通用同步收发器）和UART（即通用异步收发器），其中USART有USART1/2/3/6，而UART有UART4/5/7/8。UART是在 USART基础上裁剪掉了同步通信功能，只剩下异步通信功能。简单区分同步和异步就是看通信时需不需要对外提供时钟输出，我们平时用串口通信基本都是异步通信。如下表是USART和UART的功能对比表。

图14.2.1. 1STM32MP157的USART和UART的功能对比
2. 串口时钟
STM32MP1的每一路串口的时钟均可以来自于HSE、CSI和HSI、PLL4Q。而USART1时钟还可以来源于APB5和PLL3Q，USART2/3以及UART4/5/7/8的时钟还可以来自于APB1，USART6的时钟还可以来自于APB2，如下时钟树的部分截图所示（图中USART和UART标注的不是很正确）

图14.2.1. 2 STM32MP157的串口时钟来源
USART1只供Cortex-A7使用，而其余的串口Cortex-A7和Cortex-M4均可以使用，其中USART1的频率最大为133MHz，其余的6个串口的时钟最大为104.5MHz。其中，UART2/3/4/5/7/8挂在APB1总线上，UART6挂在APB2总线上，UART1挂在APB5总线上。下图是参考手册中串口数据的部分截图。

图14.2.1. 3 STM32MP157的串口时钟来源
14.2.2 USART寄存器
STM32MP1的串口和其它STM32串口一样，只要你开启了串口时钟，并设置相应IO口的模式，然后配置波特率、数据位长度、奇偶校验位等信息，就可以使用了。下面，我们就简单介绍下几个与串口基本配置直接相关的寄存器。

1.串口时钟使能寄存器
串口作为STM32MP157的一个外设，其时钟由APB1外设时钟使能寄存器RCC_MC_APB1ENSETR控制，我们后面实验中用到的串口4是在RCC_MC_APB1ENSETR寄存器的第16位，只要对该位写1即可使能串口4的时钟。在后面的实验中，通过在STM32CubeMX上配置，系统会自动为我们完成这步操作。

图14.2.2. 1 APB1外设使能MCU设置寄存器
2. 串口波特率设置寄存器

图14.2.2. 2串口波特率设置寄存器
串口波特率由USART_BRR寄存器来设置，它属于可读可写寄存器，仅低0~15位有效，其它位保留，仅当禁用USART（UE = 0）时才能写入该寄存器，在自动波特率检测模式下，该位由硬件自动更新。前面我们也说了，USART_BRR寄存器的第4~15位，BRR[15:4] = USARTDIV[15:4]，剩下的第0~3位分情况：
当OVER8 = 0，BRR[3:0] = USARTDIV[3:0]。
当OVER8 = 1，BRR[2:0] = USARTDIV[3:0]，右移1位。（BRR [3]必须保持清除状态，即为0）。
3. 串口控制寄存器
参考手册中将串口控制寄存器USART_CR1分为两种情况来介绍，一种是在启用FIFO模式下，另一种是在禁用FIFO模式下。这里我们以启用FIFO模式下的情况来介绍。

图14.2.2. 3串口控制寄存器
串口控制寄存器32位可设，大部分位可以由软件置1或者清除，我们这里仅分析常用的几位，其它位需要的时候可以再根据参考手册来分析。
第0位，UE为USART使能位。将UE位置1表示使能串口，清0表示禁止USART输出，并进入低功耗模式。
第2位，RE接收器使能位。0：禁止接收器； 1：使能接收器并开始搜索起始位。
第3位，TE表示发送使能位。 0：禁止发送器； 1：使能发送器。
第4位，IDLE 中断使能。0：禁止中断；1：当 USART_ISR 寄存器中的 IDLE=“1”时，生成 USART 中断。
第5位，RXNEIE/RXFNEIE接收数据寄存器非空/RXFIFO 非空中断使能。0：禁止接收器；1：当 USART_ISR 寄存器中的 ORE=“1”或 RXNE/RXFNE=“1”时，生成 USART 中断。
第6位，TCIE表示传输完成中断使能位。0：禁止中断；1：当 USART_ISR 寄存器中的 TC=“1”时，生成 USART 中断。
第7位，TXFNFIE表示发送数据寄存器为空/TXFIFO 未满中断使能，0：禁止中断；1：每当USART_ISR寄存器中的TXFNF = 1时，都会产生USART中断。
第8位，PEIE属于PE中断使能。0：表示禁止中断；1：当 USART_ISR 寄存器中的 PE=“1”时，生成 USART 中断
第9位，PS为校验位选择位。0：偶校验；1：寄校验。仅当禁用USART（UE=0）时，才可以写此位。
第9位，PCE为奇偶校验控制使能位。0：禁止奇偶校验控制；1：使能奇偶校验控制。仅当禁用USART（UE=0）时，才可以写此位。
第10位，PCE表示校验启用位。0：禁用奇偶校验控制，1：启用奇偶校验控制。仅当禁用USART（UE = 0）时才能写入该位。这里，如果启用了奇偶校验位的话，将计算出的奇偶校验位插入到MSB位置（如果M = 1，则为第9位；如果M = 0，则为第8位），并在接收到的数据上检查奇偶校验。
第12和第28位，M0、M1为字长设置位，M[1：0]=00，表示1个起始位，8个数据位，n个停止位；M[1：0]=01，表示1个起始位，9个数据位，n个停止位；M [1：0] ='10’表示1个起始位，7个数据位，n停止位；该位只能在禁止USART（UE = 0）时才可以写入，这里，n个停止位，n的个数，由USART_CR2的[13:12]位控制。
第15位，OVER8为过采样模式设置位。0：16倍过采样；1：8倍过采样。
第29位，FIFOEN为FIFO 模式使能位，0：禁止 FIFO 模式；1：使能 FIFO 模式。只有在禁止 USART（UE=“0”）时才能写入此位。
第30位，TXFIFO 为空时中断使能位。0：禁止中断；1：当 USART_ISR 寄存器中的 TXFE=“1”时，生成 USART 中断。
第31位，RXFIFO 变满时中断使能位。0：禁止中断；1：当 USART_ISR 寄存器中的 RXFF=“1”时，生成 USART 中断。
4. 数据发送与接收寄存器
STM32MP157的串口数据发送和数据接收由两个不同的寄存器组成，发送的数据在USART_TDR寄存器中，接收的数据在USART_RDR寄存器中，我们来看看这两个寄存器

图14.2.2. 4数据发送与接收寄存器
USART_RDR的其它位保留，只有第08位可读，其包含接收到的数据字符，具体多少位，由前面介绍的M[1:0]决定。类似的，USART_TDR的第08位包含要传输的数据字符。当我们需要发送数据的时候，往USART_TDR寄存器写入想要发送的数据，就可以通过串口发送出去了。而当有串口数据接收到，需要读取出来的时候，则必须读取USART_RDR寄存器的置。
我们前面有说过，在有效数据位中，一般是低位（LSB）在前，高位（MSB）在后，在启用奇偶校验的情况下进行接收时，在MSB位中读取的值为接收的奇偶校验位，什么意思呢？即当使能校验位(USART_CR1中PCE位被置1)进行发送时，写到MSB的值会被后来的校验位取代，当使能校验位进行接收时，读到的MSB位是接收到的校验位。对于启用奇偶校验的情况，USART的数据帧格式如下表所示：

表14.2.2. 1串口数据帧格式表
例如M[1:0]=00，PCE=1，停止位为1位的时候，数据有8位，不过第7位的值被校验位改写了，第7位是校验位了。数据位为7位和9位的情况也是类似。

图14.2.2. 5 MSB位会被后来的校验位改写
5. 串口状态寄存器
串口状态通过状态寄存器USART_ISR读取，其各位描述如图所示：

图14.2.2. 6串口状态寄存器
注：
可以在启用FIFO模式和禁用FIFO模式中使用同一寄存器。其中，如果启用FIFO /智能卡模式，则X = 2，如果启用了FIFO并且禁用了智能卡模式，则X = 0。
关于USART_ISR，我们也是介绍常用的几位，其它位大家可以根据参考手册来查阅。
第0位，PE表示校验错误位。0：无奇偶校验错误；1：奇偶校验错误。当在接收器模式下发生奇偶校验错误时，此位由硬件设置，在USART_ICR寄存器的第0位PECF中写入1即可将此位软件清除。
第1位，FE表示帧错误位。0：未检测到帧错误；1：检测到帧错误或 break 字符。当检测到帧错误时，该位将由硬件置位，在USART_ICR寄存器的第1位FECF写入1即可将此位软件清除。
第4位，检测到空闲线路。0：未检测到空闲线路；1：检测到空闲线路。当检测到空闲线路时，该位由硬件置 1，如果响USART_CR1 寄存器中的IDLEIE写1，可以清除此位。
第5位，RXNE表示读取数据寄存器非空/RXFIFO 非空。0：未接收到数据；1：已准备好读取接收到的数据。当RXFIFO不为空时，硬件会将RXFNE位置1，表示已经有数据被接收到了，并且可以从USART_RDR寄存器中读取数据，当RXFIFO为空时，RXFNE的值被硬件清0，也可以软件上通过将1写入USART_RQR寄存器中的RXFRQ位来清除RXFNE标志。
第6位，TC（传输完成），当该位被置位的时候，表示USART_TDR内的数据已经被发送完成了（如果TE位被复位且没有正在进行的传输，则TC位将立即置1），如果为0，表示没有传输完成。该位也有两种软件清零方式：
1）读USART_ISR，写USART_TDR。
2）向USART_ICR寄存器的TCCF位写1。
寄存器的介绍就到此了，因为寄存器位数比较多，每位控制的功能还不一样，文档里不能把每一位都介绍一遍，而且也是记不住的，所以，我们在需要的时候再查看参考手册。
第7位，TXFNF表示发送数据寄存器为空/TXFIFO 未满。0：数据寄存器已满/发送 FIFO 已满；1：数据寄存器/发送 FIFO 未满。
第15位，ABRF表示：自动波特率标志。如果已设置自动波特率，或者自动波特率操
作未成功完成时，此位由硬件置 1。
第16位，BUSY表示忙标志。0：USART 处于空闲状态（无接收）；1：正在接收。
第23位，TXFIFO 为空。0：TXFIFO 非空；1：TXFIFO 为空。
第24位，RXFIFO 已满。0：RXFIFO 未满；1：RXFIFO 已满。
第26位，RXFT是RXFIFO 阈值标志。0：接收 FIFO 未达到编程的阈值；1：接收 FIFO 已达到编程的阈值。
第27位，TXFT为TXFIFO 阈值标志。0：TXFIFO 未达到编程的阈值；1：TXFIFO 已达到编程的阈值。
关于寄存器我们就介绍到这里了，遇到寄存器配置不要慌，HAL库都为我们处理好了底层驱动，我们只是从寄存器层面去理解USART是怎样控制串口工作的，下面，我们来看看USART的框图。
14.2.3 USART框图
下面我们先来学习USART框图，通过USART框图引出USART相关的知识点，对之后的编程也会有一个清晰的思路。

图14.2.3. 1 USART框图
为了方便大家理解，我们把整个框图用几根红线分成几个部分来介绍。

1.时钟与波特率
框图中①区域主要功能就是为USART提供时钟以及配置波特率。
时钟：
在USART框图中，可以看到有两个时钟域：usart_pclk 时钟域和usart_ker_ck 内核时钟域。（1）usart_pclk是外设总线时钟，需要访问 USART 寄存器时，该信号必须有效。
（2）usart_ker_ck是USART时钟源，独立于 usart_pclk，由RCC提供。因此，即使usart_ker_ck 时钟停止，也可以连续对 USART 寄存器进行读/写操作。
usart_pclk和usart_ker_ck之间没有约束，usart_ker_ck可以比usart_pclk更快或更慢，唯一的限制是软件足够快地管理通信的能力。当USART在SPI从模式下工作时，它使用从外部主SPI设备提供的外部SCLK信号得出的串行接口时钟来处理数据流，usart_ker_ck时钟必须至少比CK输入上的时钟快3倍。
波特率：
波特率，即每秒钟传输的码元个数，在二进制系统中（串口的数据帧就是二进制的形式），比特率与波特率的数值相等，所以我们今后在把串口波特率理解为每秒钟传输的二进制位数。波特率的计算公式分为16倍过采样和8倍过采样：
在16倍过采样（或者在LIN模式）的情况下，波特率通过以下公式得出：
在8倍过采样的情况下，波特率通过以下公式得出：

以上公式中，Tx/Rx baud表示串口的波特率；usart_ker_ckpres为真正到USART的时钟频率（uart_ker_ck_pres是UART输入时钟除以预分频值后的数值），在usart_ker_ck不分频的情况下，USART1的时钟频率最大为133MHz，其余6个串口的时钟频率最大为104.5MHz。
USARTDIV是一个存放在USART_BRR寄存器中的无符号定点数，其值和USART_CR1寄存器的第15位有关，USART_CR1寄存器的第15位为OVER8，用于设置采样模式。为了从噪声中提取到一个有效目标信号，一般会采用一个频率比较高的信号去采样目标信号，如8倍过采样和16倍过采样，倍数越高，采样的次数越多，采样速度越慢，但是采样后得到的数据越准确。如8倍过采样的速度高达：usart_ker_ck_pres/8。
当OVER8值为0时，表示16倍过采样，此时BRR = USARTDIV；
当OVER8值为1时，表示8倍过采样，此时BRR[2:0] = USARTDIV[3:0]，相对于OVER8值为0的情况，这里BRR右移了1位，变成BRR[2:0]，此时BRR[3]必须保持清零；
不管是16倍还是8倍，BRR[15:4]都等于USARTDIV[15:4]，且USARTDIV都必须大于或等于 16（10进制）。
下面举个例子说明来说明此公式：
当在16倍过采样时，如果需要得到 115200 的波特率，此时usart_ker_ckpre =104.5MHZ，那么可得：

计算出USARTDIV = 907（10进制），可解得 BRR = USARTDIV =388（16进制），那么需要设置USART_BRR 的值为 0x388。这里的USARTDIV是有余数的，我们用四舍五入进行取整，这样会导致波特率会有所偏差，而这样的小误差是可以被允许的。8倍过采样计算方法类似。
2. 收发数据
框图中②区域部分包含了USART双向通信需要的两个引脚：
TX：发送数据输出引脚。
RX：接收数据输入引脚。采用过采样技术进行数据恢复，用于区分有效输入数据和噪声。
USART_TDR是USART发送数据寄存器，要发送什么数据，就往这个寄存器里写数据即可，其低9位有效。USART_RDR是USART接收数据寄存器，包含接收到的数据字符，要接收什么数据，读这个寄存器即可，其低9位有效。
USART有一个发送 FIFO (TXFIFO) 和一个接收 FIFO (RXFIFO)，所以USART可以工作在FIFO 模式下，可以通过将 USART_CR1寄存器中的 FIFOEN（第29位）置 1 来使能 FIFO 模式。RXFIFO 的默认宽度为 12 位，即最大9位数据+1位奇偶校验位+1位噪声错误+1位帧错误标志。如果使能FIFO，写入到发送数据寄存器 (USART_TDR) 中的数据会在 TXFIFO 中排队，然后再通过TX移位寄存器发送到RX移位寄存器，再由RX移位寄存器发送到RxFIFO，然后USART_RDR寄存器从RxFIFO中获得数据。
向 USART_TDR 中写入要发送的数据前，发送使能位 (TE) 先置 1以激活发送器功能，发送移位寄存器(USART_TDR)中的数据在 TX 引脚输出，默认情况下，先发送数据的最低位（LSB），相应的时钟脉冲在SCLK 引脚输出。一旦向发送数据寄存器中写数据，UART的BUSY位开始有效，当从发送移位寄存器发送最后一个字符（包括停止位）才变无效。
RX接收字符时，如果已禁止 FIFO 模式，则,RXNE位置1，表明移位寄存器的内容已传送到 RDR，也就是说，已接收到并可读取数据；如果已使能 FIFO 模式，则RXFNE位置1，这表示 RXFIFO 非空，读取 USART_RDR会返回输入到 RXFIFO 中的最早数据。
发送器可发送 7 位、8 位或 9 位的数据字，具体取决于 M 位的设置，通USART控制寄存器1(USART_CR1)的 M位（M0：位 12，M1：位 28）来设置：
7 位字符长度：M[1:0] =“10”
8 位字符长度：M[1:0] =“00”
9 位字符长度：M[1:0] =“01”
每个字符从起始位开始到可配置数量的停止位终止，停止位的数量可配置为 0.5、1、1.5 或 2位。在默认情况下，信号（TX 或 RX）在起始位工作期间处于低电平状态。在停止位工作期间处于高电平状态。如果发送期间复位TE 位会冻结波特率计数器，当前发送的数据随即丢失，使能 TE 位时，将发送空闲帧，空闲帧发送将包括停止位。
3. 控制寄存器
框图中③区域部分，我们可以通过控制寄存器控制USART数据的发送、数据接收、各种通信模式的设置、中断、DMA 模式还有唤醒单元等。前面部分我们已经介绍了对应的寄存器。
4. DMA和IRQ中断功能
框图中④区域部分涉及两个接口：IRQ和DMA中断接口。
USART支持DMA传输，可以实现高速数据传输，具体我们会在DMA实验中为大家讲解。在 USART 通信过程中，中断可由不同事件生成，同时支持 USART 模块生成唤醒中断。常用的中断比如：发送数据寄存器为空、发送 FIFO 未满、发送完成、接收 FIFO 非空、接收 FIFO 已满等。有关所有 USART 中断请求的详细说明可以查看参考手册详细列表。
5. USART信号引脚
框图中⑤区域部分是USART信号的引脚。
在 RS232 硬件流控制模式下需要以下两个引脚：
CTS（清除以发送）：发送器在发送下一帧数据之前会检测 CTS 引脚，如果为低电平，表示可以发送数据，如果为高电平则在发送完当前数据帧之后停止发送。
RTS（请求以发送）：如果为低电平，则该信号用于指示 USART 已准备好接收数据。
在 RS485 硬件控制模式下需要下面这个引脚：
DE（驱动器使能）：该信号用于激活外部收发器的发送模式。
在同步主/从模式和智能卡模式下需要以下引脚：
CK：该引脚在同步主模式和智能卡模式下用作时钟输出，在同步从模式下用作时钟输入。
NSS：该引脚在同步从模式下用作从器件选择输入。
这些引脚我们暂时都没有用到，就给大家简单提一下。
注： DE和 RTS共用同一个引脚。
6. USART工作过程
前面我们分析了USART的框图和串口相关的寄存器，后面的开发中我们使用的是HAL库，HAL库中对这些寄存器的操作已经封装好了，这里我们从寄存器的层面大概了解USART的工作过程：
（1）USART发送器
要发送字符，需遵循以下步骤：
①设置USART_CR1 中的 M 位以配置字长；
②设置USART_BRR 寄存器以选择所需波特率；
③配置USART_CR2 中的STOP[1:0]位以配置停止位数；
④将USART_CR1 寄存器中的 UE 位写入 1 以使能 USART；
⑤如果必须进行多缓冲区通信，请选择 USART_CR3 中的 DMA 使能 (DMAT)；
⑥将 USART_CR1 中的 TE 位置 1 以使能发送器，在首次发送时发送一个空闲帧；
⑦在 USART_TDR 寄存器中写入要发送的数据。为每个要在单缓冲区模式下发送的数据重复这一步骤：
—禁止 FIFO 模式时，向 USART_TDR 写入数据会将 TXE 标志清零；
—使能 FIFO 模式时，向 USART_TDR 写入数据会为 TXFIFO 增添一个数据。当 TXFNF标志置 1 时，会对 USART_TDR 执行写操作。该标志会保持置 1，直到 TXFIFO已满。
⑧将最后一个数据写入 USART_TDR 寄存器后，等待 TC =1（表示传送已完成）。也是分为两种情况：
—禁止 FIFO 模式时，这表示最后一个帧的发送已完成；
—使能 FIFO 模式时，这表示 TXFIFO 和移位寄存器均为空。

图14.2.3. 2串口发送时TC/TXE的行为
注：
TXE位为1表示数据寄存器/发送 FIFO 未满，为0表示数据寄存器已满/发送 FIFO 已满；
TC位为1表示传送已完成，为0表示未发送完成。
（2）USART接收器
接收器采用过采样来判断接收到的数据是否准确。在空闲状态时，传送线为高电平状态（逻辑1），而数据的起始位是逻辑0。当接收器检测到一个从1到0的跳变沿的时候，便视为可能的起始位（可能是存在干扰引起跳变），接收器是怎么去判断接收到的数据是否有效呢？
它采用了起始位检测序列来判断，当以16或8倍过采样时，此序列均为：1110 X 0X0X0 000，其中 X表示电平任意，可以为0或者1。如果检测到的序列不完整，则起始位检测将中止，接收器返回空闲状态，在该状态中等待下降沿。如果针对第 3 位、第 5 位和第 7 位进行首次采样时检测到这3位均为“0”；针对第 8 位、第 9 位和第 10 位进行第二次采样时仍检测到这3位均为“0”，则表示起始位有效。如下图所示：

图14.2.3. 3串口过采样时检测有效位
USART 接收期间，首先通过 RX 引脚移出数据的最低有效位（默认配置）。
字符接收步骤：
①设置USART_CR1 中的M位以配置字长；
②设置USART_BRR 寄存器以选择所需波特率；
③配置USART_CR2 中的STOP[1:0]位以配置停止位数；
④将USART_CR1 寄存器中的UE位写入 1 以使能 USART；
⑤如果将进行多缓冲区通信，请选择 USART_CR3 中的 DMA 使能 (DMAR)。
⑥将USART_CR1的RE位置1以使能接收器开始搜索起始位。
14.2.4 GPIO引脚复用功能
芯片的外设有很多，而芯片的引脚资源却是有限的，如何在有限的引脚里拓展出更多的功能呢，这里就涉及到了复用。复用，就是说，一个引脚除了可以当做普通的IO口功能以外，还可以与一些外设关联起来，作为第二功能或者第三功能甚至更多的功能使用，不过在这些功能当中，在同一个时刻中只能选用其中一种功能来用，这样就不会导致冲突。

1.复用功能寄存器
前面我们是有介绍GPIO的部分寄存器，这里，我们再来熟悉和复用功能有关的两个寄存器：
GPIOx_AFRL和GPIOx_AFRH（复用功能高位寄存器和复用功能低位寄存器）
有两个32位的复用功能寄存器（或者称为多路复用器），AFRL和AFRH，每4个位配置一个IO口的复用功能，AFRL配置第0至第7个IO口，AFRH 配置第8至第15个IO口，总共16和IO口，每个IO口可以选择AF0至AF15中的某个复用功能（具体根据数据手册中的复用功能映射表来确定）。复位后，多路复用器选择为复用功能AF0，复位后的IO口工作模式由MODER和AFRL/H寄存器共同决定。

图14.2.4. 1 AFRL寄存器
2. 复用功能映射表
IO口并不是想复用什么功能都可以，是有规定的，每个 IO 引脚的复用可以通过查阅数据手册的复用功能映射表来确定，例如我们需要配置PG11复用为UART4_TX，即多路复用器选择为复用功能AF6，则配置寄存器GPIOG_AFRL的AFR11的第12至第15位为0110。虽然可以在STM32CubeMX插件上可以使用图形界面来配置IO口的复用功能，但是它是怎么配置的我们还是要知道的。

图14.2.4. 2 Port G引脚复用
3. 复用功能选择宏定义
我们的开发板上，USB_TTL这个接口使用的是PG11和PB12，他们复用成UART4来用了，从上表中看出PG11可以复用为UART4_TX，是在AF6这一列。在HAL库的stm32mp1xx_hal_gpio_ex.h文件中可以找到这些复用的宏定义：

/**
) P+ \7 l! H$ j4 K ]" n/ i' ~
* @brief AF 6选择$ }- u5 u9 s2 D0 n# q1 _. q
*/& J; i2 a4 w; c [7 L& K
#define GPIO_AF6_SPI3 ((uint8_t)0x06) /* SPI3复用功能映射 */( P* R2 W N8 d) o7 p. A/ b
#define GPIO_AF6_SAI1 ((uint8_t)0x06) /* SAI1复用功能映射 */
; h- G; l: Z+ Z* [. z$ N& g* W
#define GPIO_AF6_SAI3 ((uint8_t)0x06) /* SAI3复用功能映射 */4 ]3 Q- @) i$ g) ~3 |! v
#define GPIO_AF6_SAI4 ((uint8_t)0x06) /* SAI4复用功能映射 */
# M4 n$ g9 B( T2 r
#define GPIO_AF6_I2C4 ((uint8_t)0x06) /* I2C4复用功能映射 */; X' O* s9 w8 M9 O, M0 O( `( M0 e
#define GPIO_AF6_DFSDM1 ((uint8_t)0x06) /* DFSDM1复用功能映射 */4 I# j: h+ |1 k5 E- B$ A
#define GPIO_AF6_UART4 ((uint8_t)0x06) /* UART4复用功能映射 */

复制代码

AF6的宏定义的值都是一样的，即都是(uint8_t)0x06，这些宏名只是为了区分是当做哪个外设而已，例如我们开发板的外设是串口4，所以就很容易选择到我们要复用的功能对应的宏定义，就是GPIO_AF6_UART4。具体的场景应用会在我们后面的实验中有所体现。
/ A# _: M: c: [' D# W
14.3 HAL库中串口相关的API
为了更好地使用HAL库来实现串口功能，下面我们来介绍HAL库中和本实验相关的结构体和API函数。
14.3.1 结构体和句柄
我们先来看看和串口相关的结构体和句柄。我们在介绍HAL库的时候有提到句柄（Handle），句柄在HAL库中是一个指针，指针指向地址，在调用API函数的时候，可以利用句柄来说明要操作哪些资源。在stm32mp1xx_hal_uart.h中有定义句柄和结构体。

1.USART_TypeDef结构体
通过第5.2.3小节总线架构分析，我们知道UART4挂在APB1总线上，UART4的地址范围是0x40010000 ~ 0x400103FF，即UART4的基地址是0x40010000。我们前面也说过（第6.3.2小节），通过寄存器的基地址和偏移地址就可以访问一个寄存器，而HAL里边使用了大量的结构体来对寄存器进行了封装，如果我们要配置某个寄存器，只需要定义一个结构体指针，然后通过指针来配置这个结构体里面的成员变量，当结构体成员配置号以后，HAL库就会根据这些配置来初始化IO。USART_TypeDef结构体定义如下：

/* UART句柄结构定义 */3 ~+ |+ a/ E- {+ d) M4 M( A
typedef struct
5 T' j6 S. d& U! [& E$ Z: q
{. ~. v* b4 P" z5 w3 r% w8 r0 t
__IO uint32_t CR1; /* USART控制寄存器1，地址偏移量：0x00 */
- P( [" e5 z" w
__IO uint32_t CR2; /* USART控制寄存器2，地址偏移量：0x04 */
7 u8 }, u# F1 |" Q' G' @
__IO uint32_t CR3; /* USART控制寄存器3，地址偏移量：0x08 */% h' a1 _4 P+ w8 X
__IO uint32_t BRR; /* USART波特率寄存器，地址偏移量：0x0C *// J; z- k9 S% F* P. T* R
__IO uint16_t GTPR; /* USART保护时间和预分频器寄存器，地址偏移量：0x10 */
# H) X" {6 X5 y- W
uint16_t RESERVED2; /* 保留，0x12 */
4 ~3 [3 E& [) r3 t
__IO uint32_t RTOR; /* USART接收器超时寄存器，地址偏移量：0x14 */
7 F3 o3 w7 Z" P- A4 R
__IO uint16_t RQR; /* USART请求寄存器，地址偏移量：0x18 */
. e+ e" x l& B. b' K c) P8 P
uint16_t RESERVED3; /* 保留，0x1A */
& ]4 X. j$ |) P- }3 D- w$ C/ ?% Q4 i
__IO uint32_t ISR; /* USART中断和状态寄存器，地址偏移量：0x1C */
; R: w6 I6 ]6 u" B) C: @& m* Q
__IO uint32_t ICR; /* USART中断标志清除寄存器，地址偏移量：0x20 */
) S& F. S8 P9 |4 F
__IO uint16_t RDR; /* USART接收数据寄存器，地址偏移量：0x24*/
) ~( {* X7 O# B' p6 y j" }
uint16_t RESERVED4; /* 保留，0x26 */) B* |& O) [3 R7 I. {4 r6 g' B( w
__IO uint16_t TDR; /* USART发送数据寄存器，地址偏移量：0x28 */
$ Z& A4 p: K% J9 H
uint16_t RESERVED5; /* 保留，0x2A */
" O- I6 h" Y, a- Z* h" P4 t3 \
__IO uint32_t PRESC; /* USART时钟预分频器寄存器，地址偏移量：0x2C */4 k4 [5 V' _9 S- s
uint32_t RESERVED6[239]; /* 预留0x30-0x3E8 */% h1 T& X; ^' s) Q4 E, a: i R% j* s C
__IO uint32_t HWCFGR2; /* USART 配置2寄存器，地址偏移量：0x3EC */
3 u! d$ o* a: \: Y; B
__IO uint32_t HWCFGR1; /* USART 配置1寄存器，地址偏移量：0x3F0 */
5 U4 ]- k+ t2 W$ h' ~
__IO uint32_t VERR; /* USART版本寄存器，地址偏移量：0x3F4 */
# v6 ~4 ^, g& Q; d
__IO uint32_t IPIDR; /* USART标识寄存器，地址偏移量：0x3F8 */& {+ h' f/ S; l. _4 @ r' m
__IO uint32_t SIDR; /* USART时钟大小识别寄存器，地址偏移量：0x3FC */
' a1 c" N d4 x0 `2 g7 f7 d
} USART_TypeDef;

复制代码

我们在前面有分析过，__IO在core_m4.h 文件中有定义，表示volatile，volatile表示强制编译器减少优化，告诉编译器必须每次去内存中取变量值。

#define __IO volatile
2. UART_InitTypeDef结构体
UART_InitTypeDef结构体主要用于设置串口的波特率、数据位长度、停止位数、过采样倍数等信息，通过对结构体成员的写操作即可实现这些设置，其定义如下：

/* UART初始化结构定义 */
3 m& [, k% b+ I6 m
typedef struct
/ E4 e6 }" P! V! v: g: p2 l+ Z
{* F: F' H8 |: ^
uint32_t BaudRate; /* 该成员配置UART通信波特率 */3 q. i2 @; _; d5 h. U
uint32_t WordLength; /* 指定在一帧中发送或接收的数据位数 */7 v1 B p& t+ q$ _
uint32_t StopBits; /* 指定发送的停止位数 */
+ l& Q2 J5 {. i' R
uint32_t Parity; /* 指定奇偶校验模式 */( G c! Z9 @3 Y' f+ r D& P" p
uint32_t Mode; /* 指定启用还是禁用接收或发送模式 */ x8 X( r( u: h1 k
uint32_t HwFlowCtl; /* 指定启用还是禁用硬件流控制模式 *// x) ^# v5 Y0 |6 I+ ]1 y2 G9 ]
uint32_t OverSampling; /* 指定是否启用过采样8 */; I+ V { I+ m3 D
uint32_t OneBitSampling; /* 指定是选择单个样本还是三个样本 */1 S6 V( d! y1 u6 R# ]3 ~5 ^
uint32_t ClockPrescaler; /* 指定用于分频UART时钟源的预分频器值 */
( n, J% U6 P* L1 H
} UART_InitTypeDef;

复制代码

（1）BaudRate：设置波特率，一般设置为 2400、9600、19200、115200；
（2）WordLength：设置数据位数，可选 8 位或 9 位。后面的实验我们设置为8位字长；
（3）StopBits：设置停止位个数，可选0.5个、1个、1.5个和2个停止位，后面的实验我们选择1个停止位；
（4）Parity：设置奇偶校验位，我们设定为无奇偶校验位。
（5）Mode：设置UART模式选择，可以设置为只收模式、只发模式、或者收发模式。我们选择设置为全双工收发模式。
（6）HwFlowCtl：硬件流控制选择，我们选择为无硬件流控制。
（7）OverSampling：过采样选择，可选择8倍过采样或者16过采样，我们可以选择16过采样。
3. UART_AdvFeatureInitTypeDef结构体
如下是UART高级功能初始化结构定义，ST新出的芯片添加了一些新特性，其中：
自动波特率检测是指某一方可以自动检测对方传输数据时的波特率，从而自动采用与对方相同的波特率进行数据传输，而不需要人工去设置波特率。
是否交换TX和RX引脚是否反转是指：RXD和TXD管脚互换。有时候，我们在外接串口引脚时，可能会犯低级错误，会将RXD和TXD引脚的两根线接反了，只能拆下来重新接。不过STM32MP1以及STM32H7系列的串口是支持RXD和TXD管脚互换的，通过设置SWAP位即可将RXD和TXD管脚互换。
指定TX/RX引脚的活动电平是否反转：通常默认串口高电平为逻辑1，低电平为逻辑0，
而在STM32的USART新特性中是可以将高电平设置为逻辑0，低电平设置为逻辑1的。
关于串口的新特性我们就介绍到这里，感兴趣的小伙伴可以自行查阅参考手册的介绍。
/* UART高级功能初始化结构定义 */

typedef struct
% C/ q, ^% _7 C
{
0 v6 e0 m9 t. J; M! U
/* 指定初始化哪些高级UART功能，可同时初始化几个高级功能 */
$ F2 o/ Z; V; Q" Q
uint32_t AdvFeatureInit; , u, d. h7 n' h' [
uint32_t TxPinLevelInvert; /* 指定TX引脚的活动电平是否反转 */
+ L- S; f3 r( i& H
uint32_t RxPinLevelInvert; /* 指定RX引脚的活动电平是否反转 */. O2 b) T! r: y. T- W: A" R; i
uint32_t DataInvert; /* 指定是否反转数据（正逻辑/正逻辑与负逻辑/反逻辑）*/
4 U: L1 w1 m# N1 s3 `
uint32_t Swap; /* 指定是否交换TX和RX引脚 */
" H+ m& H$ C2 a6 c, e3 d! u
uint32_t OverrunDisable; /* 指定是否禁用接收溢出检测 */
4 h# P9 w, l, _- D1 C2 J; U
uint32_t DMADisableonRxError; /* 指定在接收错误的情况下是否禁用DMA */
% |: N1 e. a5 D5 r$ I% {: @& `
uint32_t AutoBaudRateEnable; /* 指定是否启用自动波特率检测 */ 3 G- Z2 L6 g- x$ O( i8 ?: ?
uint32_t AutoBaudRateMode;/* 如启用了自动波特率检测，请指定如何进行速率检测 */
, f6 B8 B4 V$ _( O5 W
uint32_t MSBFirst; /* 指定是否首先在UART线上发送MSB */ $ S$ |1 T$ H. i% W1 ]
} UART_AdvFeatureInitTypeDef;( J$ M& P j: [6 x0 C: x
4. UART_HandleTypeDef句柄
' ]0 u, `8 I8 O$ O& a
UART_HandleTypeDef句柄是基于以上结构体以及HAL库的函数封装后的，其定义如下：
' J# _: H0 L1 P% I0 s* Y
/* UART句柄结构定义 */
& |4 i6 F* M+ Y0 j! j6 _
typedef struct __UART_HandleTypeDef7 u1 L0 H6 s4 S# W5 ~1 p
{/ _( {. K& q1 Y% N' y% |
USART_TypeDef *Instance; /* UART寄存器基地址 */
3 Y( f( ] A" i! H; h0 j
UART_InitTypeDef Init; /* UART通讯参数 */
2 D4 C$ S: a' ?: Z- v- v
UART_AdvFeatureInitTypeDef AdvancedInit; /* UART高级功能初始化参数 */
" l2 }: W2 Y# U& o+ N. L6 P
uint8_t *pTxBuffPtr; /* 指向UART Tx传输缓冲区的指针 */
7 [$ K$ _2 L; r8 E; O& `2 e
uint16_t TxXferSize; /* UART Tx传输大小 */
+ q+ Z4 x* U9 i4 j+ g: A6 N1 h' g
__IO uint16_t TxXferCount; /* UART Tx传输计数器 */
' V2 `. P- J$ e
uint8_t *pRxBuffPtr; /* 指向UART Rx传输缓冲区的指针 */
+ h6 w1 [9 F5 I% `: |9 _& M w
uint16_t RxXferSize; /* UART Rx传输大小 */! n1 S- L6 o6 J9 ^( k6 R2 }
__IO uint16_t RxXferCount; /* UART Rx传输计数器 */
5 Y/ k( ~ t) P4 R# h* W2 U
uint16_t Mask; /* UART Rx RDR寄存器掩码 */
& k4 k9 M- n# ~3 s) R: ~
uint32_t FifoMode; /* 指定是否正在使用FIFO模式 */
; x- K7 s8 {4 S0 P1 G, ]
uint16_t NbRxDataToProcess; /* RX ISR执行期间要处理的数据数 */8 g& W3 n( k* _. V/ l
uint16_t NbTxDataToProcess; /* TX ISR执行期间要处理的数据数 */% \8 `, u% B7 D& ?, a
/* Rx IRQ处理程序上的函数指针 */6 r+ ?7 X0 @5 v! e5 r
void (*RxISR)(struct __UART_HandleTypeDef *huart); ! b* R2 o% |" \: V' N
/* Tx IRQ处理程序上的函数指针 */& P# b8 j4 y4 f5 C# \. E+ e
void (*TxISR)(struct __UART_HandleTypeDef *huart); " P% o0 s1 D1 t9 Y O3 ^8 y' v
DMA_HandleTypeDef *hdmatx; /* UART Tx DMA句柄参数 */, a7 e7 E! B. G" J. O) o
DMA_HandleTypeDef *hdmarx; /* UART Rx DMA句柄参数 */
8 t9 N# Z$ u7 q! [+ a0 ~% c
#ifdef HAL_MDMA_MODULE_ENABLED8 H% H$ o( L* h) k1 P* y+ |
MDMA_HandleTypeDef *hmdmatx; /* UART Tx MDMA句柄参数 */' u* `! V _" R, p
MDMA_HandleTypeDef *hmdmarx; /* UART Rx MDMA句柄参数 */
' H0 v, y; W# }. l! f3 _. H1 T* M
#endif /* HAL_MDMA_MODULE_ENABLED */
3 I, h" x& Q8 `8 o q
HAL_LockTypeDef Lock; /* 锁定对象 */
2 B3 W7 X: x8 ?% o7 @1 e) I3 |
/* 与全局句柄管理以及Tx操作有关的UART状态信息 */ 6 F4 P$ `$ d' b6 d( a: w1 e- C
__IO HAL_UART_StateTypeDef gState; /*与Tx操作有关的UART状态信息 */
5 Z) f+ f' u' ]) o, s. M6 s" e/ c
__IO HAL_UART_StateTypeDef RxState; /* 与Rx操作有关的UART状态信息 */ 9 G1 D6 T3 x5 m% k
__IO uint32_t ErrorCode; /* UART错误代码 */ Z" u% Q9 k& p4 W- }7 l
) r; `: X; ^9 m ]. C$ c
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
9 X0 r0 h S9 h( W
void (* TxHalfCpltCallback)(struct __UART_HandleTypeDef *huart); : \! `- u' m3 G. T# p5 C5 ^- [
void (* TxCpltCallback)(struct __UART_HandleTypeDef *huart);
8 r& ^% E. K% u3 h% b2 r" ?
void (* RxHalfCpltCallback)(struct __UART_HandleTypeDef *huart); , m) E6 Z" R* L7 k' `# e' h
void (* RxCpltCallback)(struct __UART_HandleTypeDef *huart);
. _7 x) d) q9 l1 m: }. a
void (* ErrorCallback)(struct __UART_HandleTypeDef *huart);
- b* y8 }: E% s, M
void (* AbortCpltCallback)(struct __UART_HandleTypeDef *huart);
1 Y* m/ N A3 C& ~4 ^0 U
void (* AbortTransmitCpltCallback)(struct __UART_HandleTypeDef *huart); - w2 U: q9 p+ G2 |4 Y) A4 X6 m
void (* AbortReceiveCpltCallback)(struct __UART_HandleTypeDef *huart); 8 q; g% n4 z- c* I0 S2 U: b. @' b
void (* WakeupCallback)(struct __UART_HandleTypeDef *huart); " B" y; u6 i4 L+ k
void (* RxFifoFullCallback)(struct __UART_HandleTypeDef *huart); + \7 i9 e. c& V0 O4 I) j/ Z) Q' m/ R; }
void (* TxFifoEmptyCallback)(struct __UART_HandleTypeDef *huart);
- W% B1 Q; h! }9 E! f
void (* MspInitCallback)(struct __UART_HandleTypeDef *huart); ) R5 n7 M# Z# x
void (* MspDeInitCallback)(struct __UART_HandleTypeDef *huart); ( x8 n. `3 l8 n7 z+ O) ?: f" n
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */: R# O5 A+ g L" {! k) l# n* |
} UART_HandleTypeDef;

复制代码

此句柄内容有很，我们先关注几个重要的：

（1）Instance
我们前面已经介绍了USART_TypeDef结构体，Instance是USART_TypeDef结构体指针变量，指向UART 寄存器基地址，通过此变量即可操作对应的结构体成员（寄存器）。
（2）Init
UART_InitTypeDef结构体我们前面也有介绍到，此处声明UART_InitTypeDef结构体变量Init，可以通过Init来设置串口的波特率、数据位长度、停止位数、过采样倍数等信息。
波特率的计算公式我们前面已经讲解了，套入前面的波特率计算公式中。
如果过采样为16或在LIN模式下：

如果过采样为8：$ Q8 @1 L4 e" G7 G" V
( ]3 I4 U3 X2 W6 }0 e' z
波特率寄存器[3] = 0

复制代码

（3）pTxBuffPtr
pTxBuffPtr、TxXferSize、TxXferCount分别是指向发送数据缓冲区的指针、发送数据的大小、发送数据的个数。
（4）pRxBuffPtr
pRxBuffPtr 、RxXferSize和RxXferCount分别是指向接收数据缓冲区的指针、接收数据的大小、接收数据的个数。
（5）Lock
Lock是对资源操作增加操作锁保护功能，可选HAL_UNLOCKED或者HAL_LOCKED两个参数。如果gState的值等于HAL_UART_STATE_RESET，则可认为串口未被初始化，此时，分配锁资源，并且调用HAL_UART_MspInit函数来对串口的GPIO和时钟进行初始化。
（6）最后的部分是一些回调函数，如果宏USE_HAL_UART_REGISTER_CALLBACKS的值为1，表示可以使用这些回调函数。
这里注意，结构体成员 gState 没有做初始状态。
14.3.2 HAL库中的API函数
STM32MP1串口有3种通信方式：轮询、中断、DMA，其中，轮询方式为阻塞模式，DMA和中断方式为非阻塞模式。阻塞和非阻塞指的是调用者（程序）在等待返回结果（或输入）时的状态。阻塞时，在调用结果返回前，当前的线程会被挂起，调用线程只有在得到结果之后才会返回。非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。在前面的按键实验中，一个采用了按键轮询的方式，一个是采用了中断的方式，前者也称为阻塞，后者称为非阻塞。
stm32mp1xx_hal_uart.c文件下有很多和USART相关的库函数，这里我们只介绍几个重要的函数，DMA相关的函数这里就不介绍了。

1.初始化USART模式
●函数功能：根据UART_InitTypeDef中指定的参数初始化USART模式，并初始化关联的句柄。
●函数参数：UART_InitTypeDef结构体指针变量，可以指定要使用的串口。（前面已经分析了串口句柄）
●函数返回值：枚举型，HAL_OK(成功)、HAL_ERROR（错误）、HAL_BUSY（串口忙碌）、HAL_TIMEOUT（超时）
具体的函数定义，我们这里就不列出来了。
HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
2.以查询的方式发送/接收函数
HAL_UART_Transmit函数以轮询（阻塞模式）的方式发送/接收指定字节，HAL_UART_Receive函数以查询的方式接收指定字节。
●函数功能：以查询的方式发送指定字节
●函数参数：
huart： UART_HandleTypeDef 类型结构体指针变量，可以指定要使用的串口；
pData：要发送的数据地址；
Size：要发送的数据大小（单位：字节）；
Timeout：超时，溢出时间（单位：ms），对于接收来说，串口在Timeout的时间内等待接收Size个字节。
●函数返回值：枚举型，HAL_OK(成功)、HAL_ERROR（错误）、HAL_BUSY（串口忙碌）、HAL_TIMEOUT（超时）
此函数以查询的方式发送/接收指定字节，主要是通过操作USART_TDR寄存器来实现发送数据的，具体的函数定义，我们这里就不列出来了。
HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout) /串口轮询模式发送，使用超时管理机/
HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout) /串口轮询模式接收，使用超时管理机/
3.以中断方式发送/接收函数
●函数功能：以中断的方式发送/接收指定字节
●函数参数：
huart： UART_HandleTypeDef 类型结构体指针变量，可以指定要使用的串口；
pData：要接收/发送的数据地址；
Size：要接收的数据大小（单位：字节）；
●函数返回值：枚举型，HAL_OK(成功)、HAL_ERROR（错误）、HAL_BUSY（串口忙碌）、HAL_TIMEOUT（超时）
此函数以中断的方式发送指定字节，数据发送在中断请求函数HAL_UART_IRQHandler中实现。可以使用FIFO相关中断来实现，主要是通过操作USART_CR1、USART_CR3、USART_ISR和USART_TDR寄存器来实现发送数据。
HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t pData, uint16_t Size) / 串口中断模式发送 */
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t pData, uint16_t Size) / 串口中断模式接收 */
4.中断请求函数
●函数功能：串口中断请求函数
●函数参数：huart，UART_HandleTypeDef 类型结构体指针变量，可以指定要使用的串口；
●函数返回值：枚举型，HAL_OK(成功)、HAL_ERROR（错误）、HAL_BUSY（串口忙碌）、HAL_TIMEOUT（超时）
此函数是串口中断请求函数，如果前面使用了轮询（阻塞）的方式发送和接收数据，那么此函数就会被串口中断服务函数调用来完成中断的功能。
void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
5.回调函数
在非阻止模式下提供了一组传输完成回调函数，这些回调函数都是weak弱定义的，可以被用户重新定义，以实现串口发送和接收的逻辑。
/* 数据完全发送完成后调用 */
__weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef huart)
/ 一半数据发送完成时调用 */
__weak void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef huart)
/ 数据完全接受完成后调用 */
__weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef huart)
/ 一半数据接收完成时调用 */
__weak void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef huart)
/ 传输出现错误时调用 */
__weak void HAL_UART_ErrorCallback(UART_HandleTypeDef huart)
/ UART中止完成时调用 */
__weak void HAL_UART_AbortCpltCallback(UART_HandleTypeDef huart)
/ UART中止完成回调函数 */
__weak void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef huart)
/ UART中止接收完整的回调函数 */
__weak void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
6.传输中断函数
以下是一些中止正在进行的发送/接收传输函数（中断模式和阻塞模式）。
/* 中止正在进行的传输(阻塞模式) */
HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef huart);
/ 中止正在进行的传输传输(阻塞模式) */
HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef huart);
/ 中止正在进行的接收传输(阻塞模式) */
HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef huart);
/ 中止正在进行的传输(中断模式) */
HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef huart);
/ 中止正在进行的传输(中断模式) */
HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef huart);
/ 中止正在进行的接收传输(中断模式) */
HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);

14.4 串口中断接收回显实验
本实验配置好的实验工程已经放到了开发板光盘中，路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 7-1 UART4。
14.4.1 硬件设计
7.例程功能
通过串口中断将发送出的数据打印出来。这里我们使用开发板上的UART4来实现。
8.硬件资源
本实验中我们会用到开发板底板的USB_TTL接口，此接口的引脚资源如下表所示，我们还需要一根配套的Type-C线来实现电脑和开发板进行串口通信。
UART4_TX UART4_RX
PG11 PB2
图14.4.1. 1硬件资源表
9.原理图
USB_TTL接口硬件部分的原理图如下图所示，其中UART4_TX发送端接的PG11，UART4_RX接收端接的PB2，实验中我们就配置这两个引脚。

图14.4.1. 2 UART4两个引脚
14.4.2 软件设计

程序流程图

图14.4.2. 1程序流程图
2. 生成初始化代码
我们新建一个工程UART，再STM32CubeMX插件上配置如下：
（1）引脚配置
配置PG11复用为UART4_TX，配置PB2复用为UART4_RX，如下图：

图14.4.2. 2复用为UART4
如上图，配置好复用以后，接下来配置IO口模式，进入System Core GPIOUART中，PG11和PB2均为上拉模式，且分别定义一个User Lable宏（宏可以定义或者不定义，这里是为了后面方便查看代码）UART4_TX和UART4_RX。

图14.4.2. 3设置User Lable宏
（3）UART4配置
我们用到UART4，进入System Core Connectivity UART4中，UART4通信模式配置为异步通信，Hardware Flow Control（硬件流控制）就不用配置了，我们这里用不到。在Parameter Settings（参数设置）处可以看到系统已经自动为我们配置好了默认的参数：
波特率为115200Bit/s；字长为8位；无校验位；1位停止位；数据方向为发和收；16倍过采样；Clock Prescaler（时钟预分频器）分频值为1。

图14.4.2. 4 UART4参数配置
上面的参数我们采用默认的配置，如果需要修改某个参数，鼠标选中要修改的选项后手动进行配置即可：

图14.4.2. 5可以手动配置参数
（2）NVIC配置
实验中会用到串口接收中断，所以要配置NVIC。我们先在NVIC Settings 处开启UART4全局中断，然后再返回到NVIC处配置中断的抢占优先级和子优先级。
如下图，使能UART4全局中断，我们注意到此时抢占优先级和子优先级默认都是0。其他的配置我们用不到，就不需要配置了，例如DMA Settings是配置DMA模式的，我们这里使用的是中断模式，不用DMA。

图14.4.2. 6开启串口全局中断使能
如下图，在NVIC处配置优先级，我们配置优先级分组为2，抢占优先级和子优先级均为3。当然也可以配置为其它的优先等级，不过要记住的是，如果中断中用到HAL_Delay函数的话，对应的中断优先级不能比SysTick的优先级高（SysTick的抢占优先级和子优先级默认为0，属于最高级别优先级），这点我们在前面的外部中断实验章节有详细分析过。

图14.4.2. 7设置优先级
Code generation的配置就保持默认，如下图：

图14.4.2. 8 Code generation的配置
（3）时钟配置
这里，我们默认采用外部晶振。在System CoreRCC处选择打开HSE，并选择Crystal/Ceramic Resonator 晶体/陶瓷谐振器选项。

图14.4.2. 9开启HSE
然后，配置UART4的时钟来自于APB1，且配置最大为104.5MHz。
MCU子系统的时钟最大只能为209MHz，如下图，手动输入209以后按下回车键，STM32CubeMX插件会自动计算分频和倍频系数，然后在APB1DIV、APB2DIV、APB3DIV处输入2，因为APB1、APB2、APB3时钟最大值只能为104.5MHz，所以我们要手动设置分频值。设置好后，如下图，UART4的时钟频率为1045.MHz。STM32CubeMX会根据此频率以及默认的波特率115200来计算USARTDIV的值（也就是USART_BRR的值，计算出十进制值为907）。

图14.4.2. 10动态配置时钟
（4）配置生成独立的.c和.h头文件，如下图：

图14.4.2. 11配置生成独立的文件
以上的配置检查无误后，按下键盘的“Ctrl+S”组合键保存配置并生成工程：

图14.4.2. 12生成工程
3. 添加用户代码
这里，我们先按照步骤添加用户代码，后面再来分析整个实验代码的实现过程。
生成的工程中，有usart.c和usart.h文件，我们在usart.h文件中添加如下代码：
uint8_t RxBuffer;
然后在usart.c文件后面的USER CODE BEGIN 1和USER CODE END 1之间添加如下代码：
/* USER CODE BEGIN 1 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef UartHandle)
{
HAL_UART_Transmit(&huart4,&RxBuffer,1,0);
HAL_UART_Receive_IT(&huart4,&RxBuffer,1);
}
/ USER CODE END 1 */
在main.c文件中添加如下标红的代码，添加的代码位置在成对出现的BEGIN和END之间，可以打开实验的工程来查看代码添加的位置（后面我们分析工程的时候会列出完整的代码）。

图14.4.2. 13添加的代码位置
/* USER CODE BEGIN 2 /
/ printf(“请输入字符，并按下回车键结束\r\n”); /
HAL_UART_Receive_IT(&huart4,&RxBuffer,1);
/ USER CODE END 2 */

/* USER CODE BEGIN 3 /
printf("\nPlease enter characters and press enter to end\r\n");
HAL_Delay(6000);
/ USER CODE END 3 */

/* USER CODE BEGIN 4 */
#ifdef GNUC
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE f)
#endif
PUTCHAR_PROTOTYPE
{
/ 本实验使用的是UART4，如果使用的是其它串口，则将UART4改为对应的串口即可 /
while ((UART4->ISR & 0X40) == 0);
UART4->TDR = (uint8_t) ch;
return ch;
}
/ USER CODE END 4 */
14.4.3 工程代码分析
我们来分析本工程的代码，理解串口是如何实现发送数据和接收数据的。

gpio.c文件
gpio.c文件的代码比较简单，主要是开启对应GPIO的时钟，这里注意，HSE的两个引脚PH0-OSC_IN和PH1-OSC_OUT挂在GPIOH上，所以也要开启GPIOH的时钟。

#include “gpio.h”- t: E0 i& Y2 V
void MX_GPIO_Init(void)
8 F" r4 p8 d% l& L `
{: Q" r7 \/ l+ I: s
/* 开启GPIOH时钟，因为HSE的两个引脚PH0-OSC_IN和PH1-OSC_OUT挂在GPIOH上 / __HAL_RCC_GPIOH_CLK_ENABLE();% q+ b% H% n5 m" U- a+ i; h, _+ W
__HAL_RCC_GPIOG_CLK_ENABLE(); / 开启GPIOG时钟 /
, m( Z0 d: G% A: l/ U* ^
__HAL_RCC_GPIOB_CLK_ENABLE(); / 开启GPIOB时钟 */% u t$ Z1 o7 c
}

复制代码

2. stm32mp1xx_hal_msp.c文件
stm32mp1xx_hal_msp.c文件我们前面也是分析过，用户可以在此文件中编写回调函数，这里主要就是开启HSEM时钟，HSEM用于管理一些共享资源的访问权限和同步，保护GPIO和外部中断EXTI配置免受并发访问。同时设置中断优先级分组为2，此优先级是用户在STM32CubeMx上设置的。关于优先级分组初始化，我们在外部中断实验有详细分析过。
#include “main.h”

void HAL_MspInit(void)
{
__HAL_RCC_HSEM_CLK_ENABLE(); /* 开启HSEM时钟，表示使能HSEM /
/ 设置中断优先级分组为2 */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_2);
}
3. stm32mp1xx_it.c文件
stm32mp1xx_it.c文件我们在外部中断实验章节也有详细分析过，这里就不贴出所有代码了。我们主要分析第19~22行，在前面，我们在STM32CubeMX上有开启了UART4全局中断，系统会自动生成中断服务函数UART4_IRQHandler，UART4_IRQHandler函数调用了函数HAL_UART_IRQHandler，我们来看看此函数做了些什么工作。

1 #include "main.h"
! h+ T+ G0 p1 v/ c, `" f
2 #include "stm32mp1xx_it.h"
, L6 @/ B/ r& \$ n5 b' x
3 4 `7 J" x- g9 x2 T4 n! d( B4 Q6 s' v' c
4 /************************************************/! C% k% A( _8 }; q
5 /* 省略掉部分 Cortex-M4处理器中断和异常处理程序 */
" m- ?% k+ b z5 Q* m) g
6 /************************************************/# [0 V6 z/ Y/ M
7 void SysTick_Handler(void)$ e, g; z- I! B4 a# G
8 {
- E# l: @- W6 \7 L
9 /* 此功能处理系统滴答计时器每隔1ms产生一次中断 */
2 O. z% @3 y6 o8 }9 Z
10 HAL_IncTick();. F- |: J. I. v& t
11 }
7 R8 a4 @* t9 e5 N
12 /*****************************************************************/
# R4 W6 W9 k( Q, T, z, d
13 /* STM32MP1xx外围设备中断处理程序 */
0 t# R- F z8 O& O/ r9 e8 F
14 /* 在此处添加所用外围设备的中断处理程序 */6 y9 s# f, }/ D, r
15 /* 有关可用的外设中断处理程序名称,请参阅启动文件（startup_stm32mp1xx.s）*/ 9 `9 b. u% b8 H' z, s
16 /*****************************************************************/- ?5 `' v4 O/ C7 h% a% Q0 V
17
0 m$ F& d! n1 {1 A( _% L0 ]4 O; ?0 u
18 /* 该函数处理UART4全局中断 */
& B& U, L& [7 ~$ R/ [1 |& J0 \
19 void UART4_IRQHandler(void)
8 |3 |7 B, \1 ]
20 {1 b5 c5 K/ S" I8 X1 ]4 m, T/ |
21 HAL_UART_IRQHandler(&huart4);
: i) D8 E8 T' C& E0 F3 U; x0 E& H
22 }- M B' y$ a8 }
HAL_UART_IRQHandler函数在文件stm32mp1xx_hal_uart.c中，我们省去部分代码，如下：
, c0 `3 h( y' N G
1 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)5 d- v9 e |- Q! M" H" F% A! ~5 ~
2 {8 A1 j" {7 P: k" ]- s
3 uint32_t isrflags = READ_REG(huart->Instance->ISR);
& f' ^2 X( V2 J. h
4 uint32_t cr1its = READ_REG(huart->Instance->CR1);& W) P$ ^" r8 e
5 uint32_t cr3its = READ_REG(huart->Instance->CR3);
7 U3 r1 t& a" Z5 `) o6 p
6 ( F N7 H) m: n( C: A: Q Z
7 uint32_t errorflags;3 [! F8 ?2 d \: ^/ ?# j; q. f
8 uint32_t errorcode;' D! y7 G4 N3 Z8 c" R1 b
9 $ d5 r9 m$ x4 T, e
10 /* 如果没有错误发生 */
* z, s: Z$ O( i) N# B
11 errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE | USART_ISR_RTOF));( M+ S, b. S: h* X4 W
12 if (errorflags == 0U)
" c, U, I+ E! {; s
13 {7 |/ `6 a0 F; [; x
14 /* UART模式接收器 */* ], k& H/ y$ c: c5 S( c% f0 J0 n
15 if (((isrflags & USART_ISR_RXNE_RXFNE) != 0U), B6 \; @8 v1 b; _5 W5 c6 W
16 && (((cr1its & USART_CR1_RXNEIE_RXFNEIE) != 0U)" w/ K4 B% y8 Z. O( F7 A5 r
17 || ((cr3its & USART_CR3_RXFTIE) != 0U)))
' X7 t' ?# ?9 W% R4 Y
18 {) L0 i u" `3 W, B, U! K
19 if (huart->RxISR != NULL)
* M F5 x1 O. Z, Y A
20 {
/ E8 Y/ l# J. t
21 huart->RxISR(huart);
2 ^; @" s- p& U; c* q k5 N" {
22 }
9 U; @# Q5 ]; F* U+ N! j. ]
23 return;
& R/ k! B) r) `; }$ G% g* u3 V- J% ]
24 }0 |9 u5 U8 P- m/ ~5 G/ h/ G( L
25 }
& j9 ~! {- z6 y1 V- [- e0 F
26 /****** 此处省略掉部分代码 ******/. V/ K$ J; ?& W/ i, ~+ ?
27 /* UART模式发送器 */
# ]; b& o. Y2 z* v' X- o+ `; ]
28 if (((isrflags & USART_ISR_TXE_TXFNF) != 0U)) u4 ?1 B: I5 Q, a: T) S% o+ o& U
29 && (((cr1its & USART_CR1_TXEIE_TXFNFIE) != 0U)5 Q0 }3 W8 t( J' M
30 || ((cr3its & USART_CR3_TXFTIE) != 0U)))9 B1 n) g& U1 f; ?2 N! f
31 {
% o* q% O# n) P0 @. h2 G
32 if (huart->TxISR != NULL)4 S. J! U6 v: F+ m& |) b, T7 j6 Y
33 {
4 D2 x4 o. D' N- M, Q6 j
34 huart->TxISR(huart);
- ~# O; A# t. i
35 }
( f B/ g: V d# C
36 return;- x+ s" P* b8 x2 _
37 }% w$ `7 p- C+ w4 d& s
38, E0 d" s; T# r$ V* a
39 /* UART模式发送器（发送结束）*/( q& f% L& w3 m( `" Q4 [1 l9 L4 e
40 if (((isrflags & USART_ISR_TC) != 0U) && ((cr1its & USART_CR1_TCIE) != 0U))
& b: S. o; q: J; |
41 {
1 @ Z6 A) r8 c* }% X# S5 h
42 UART_EndTransmit_IT(huart);: N. x2 _: |* l0 x1 y
43 return;
" z. o$ ]* q1 S1 W6 E" e0 O
44 }
7 T/ B& c/ H' g u$ N
45 /****** 此处省略掉部分代码 ******/" h' |- F% O P- S! n) A8 k+ T
46 }

复制代码

查看第20~25行之间的代码，通过检查几个标志位看看是否有错误发生，这几个位对应USART_ISR寄存器的某些位，在stm32mp157dxx_cm4.h文件中有定义。

USART_ISR_PE USART_ISR_FE USART_ISR_ORE USART_ISR_NE USART_ISR_RTOF
第0位：PE 第1位：FE 第3位：ORE 第2位：NE 第11位：RTOF
0：无奇偶校验错误
1：奇偶校验错误 0：未检测到帧错误
1：检测到帧错误或 break 字符 0：无溢出错误
1：检测到溢出错误 0：未检测到噪声
1：检测到噪声 0：未达到超值值
1：已达到超时值，未接收到任何数据
表14.5. 1USART_ISR寄存器的某些位
如果没有错误发生，则再检查USART_ISR寄存器RXFNE位、USART_CR1寄存器的RXNE位、USART_CR3寄存器的RXFTIE位是否都为0，如果都不为0，表示已经准备好要接收的数据，并开启了中断：
当USART_RDR 移位寄存器的内容已传输到 USART_RDR 寄存器时，RXNE 位由硬件置1 ，表示USART_RDR 移位寄存器的内容已传输到 USART_RDR 寄存器，此时可以对USART_RDR 寄存器执行读取操作。
USART_ISR_RXNE_RXFNE USART_CR1_RXNEIE_RXFNEIE USART_CR3_RXFTIE
0：未接收到数据
1：已准备好读取接收到的数据 0：禁止中断
1：当 USART_ISR 寄存器中的 ORE=“1”或 RXNE/RXFNE=“1”时，生成 USART 中断 0：禁止中断
1：当接收 FIFO 达到 RXFTCFG 中编程的阈值时，生成 USART 中断。
表14.5. 2串口寄存器
以上条件满足以后，就去判断函数指针RxISR是否非空，如果非空，就执行：
huart->RxISR(huart);
这句话是什么意思呢？RxISR是接收端Rx中断请求处理程序上的函数指针，其定义如下，RxISR是一个指向函数的指针，(*RxISR)是一个带有参数huart返回值类型为void的函数，参数huart也是一个指针。此函数最后会映射到HAL_UART_Receive_IT函数里，也就是会执行HAL_UART_Receive_IT函数。

void (*RxISR)(struct __UART_HandleTypeDef *huart);& d0 y& j- p6 c8 \/ X
我们来看看HAL_UART_Receive_IT函数：9 s; f0 s- U; y
1 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)/ q5 n" d" V% J6 V" n0 h, g
2 {
8 z+ U, R$ C0 t9 Z
3 if (huart->RxState == HAL_UART_STATE_READY)/*检查接收进程是否尚未进行*/
& Y! @+ ]! _& H5 Q$ l! u
4 { /****** 此处省略部分代码 ******/
6 N( |5 a1 s: j* W, r0 D6 n
5 __HAL_LOCK(huart);
2 m' [8 _3 M7 p. C
6 SET_BIT(huart->Instance->CR3, USART_CR3_EIE); /*打开UART错误中断*/
5 c0 P: ?3 J/ B+ ?3 h( u) S8 k7 y1 Q
7 /* 配置Rx中断处理----FIFO模式 */8 G6 I$ W% S$ W1 `
8 if ((huart->FifoMode == UART_FIFOMODE_ENABLE) && (Size >= huart->NbRxDataToProcess))
9 L- p6 p+ P" P% M8 V5 F& g Y
9 {) ^. a0 F# ~2 S) c4 b9 e
10 /* 根据数据字长设置Rx ISR功能指针 */' x+ `# ?" A+ X8 k6 s0 J, }7 Q
11 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))* `7 U2 u+ L a( V$ M% J# v0 E
12 {+ u* T: Y. Q% G \1 @5 ?& ^
13 huart->RxISR = UART_RxISR_16BIT_FIFOEN; /* 字长为9位 */
9 z- @ H0 [( n9 Q3 l
14 }
) N1 N6 M4 U# M& y( ~1 i
15 else
$ ]( d" k) ^" }( Z- m
16 {
0 g- H& o+ s$ \# O2 d9 E P3 N; g
17 huart->RxISR = UART_RxISR_8BIT_FIFOEN; /* 字长为7或者8位*/
( S7 m* r! K: s& m1 _7 L: R& `
18 }
. c5 Y1 y$ J' X. M* f) o1 M- Q1 b
19 __HAL_UNLOCK(huart);
5 N4 b% G \, e$ O
20 SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);% u! x+ P# M' t* [' e8 Y
21 SET_BIT(huart->Instance->CR3, USART_CR3_RXFTIE);
# T8 h0 y: h8 R+ E
22 }
7 ]/ V" K [! n/ l) z) G" |
23 else
& m0 j2 v! n: q. E$ q
24 {
c4 w; h: ~5 ^: F
25 /* 根据数据字长设置Rx ISR功能指针 */6 [ |4 }3 j" t+ v J2 Q
26 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
0 T7 R3 m7 u/ [0 n2 `" ] D
27 {$ F* C- y* o; Y+ Z: L
28 huart->RxISR = UART_RxISR_16BIT; /* 字长为9位*/
: C' d2 |2 t4 Z) [3 |& Z( R
29 } {& H; Z1 v, S
30 else2 d+ x2 M5 j' M4 {; u2 w; u
31 {4 T5 w+ ?1 w; |
32 huart->RxISR = UART_RxISR_8BIT; /* 字长为7或者8位 */" N# e9 u0 q8 x2 y% m( |
33 }
0 g# n* F1 Q% w
34% W5 K6 A# R( l z% @# T8 M
35 __HAL_UNLOCK(huart);0 i/ [% e" z+ F3 X' e
366 _% J1 y6 u) ~# J7 K: V$ H
37 /* 使能UART奇偶校验错误中断和数据寄存器非空中断 */( L5 ?" Q3 X6 L- }9 q, p. P C
38 SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE_RXFNEIE);# P" z4 Z/ C% s
39 }3 {. c; c: C$ N- N9 ]! Y+ V# H
40 return HAL_OK;
8 u o4 v8 H2 g* G6 B( t. I( y
41 }
/ D/ w" f# T; r* s
42 /****** 此处省略部分代码 ******/
0 ]1 _& [' [# E; e8 L; ]
43}

复制代码

以上代码，我们就关注标红的部分，第23行~33行，先判断字长，然后根据字长来映射到对应的中断处理函数，我们的实验使用的不是FIFO模式，字长设置为8位，所以会映射到UART_RxISR_8BIT函数。
第5、19和35行，看到调用了__HAL_LOCK和__HAL_UNLOCK这两个宏，在stm32mp1xx_hal_def.h文件中有定义：

#define __HAL_LOCK(__HANDLE__) \
$ [) u! `! {+ h/ f! ?0 [9 U
do{ \$ g& x; B* U# ?, H _: q; j
if((__HANDLE__)->Lock == HAL_LOCKED)\
6 I- N: M. R! X& H; d v
{ \
& i ?: @# ~% ^7 n% V- H
return HAL_BUSY; \) b2 e3 d! J- c9 O+ Y1 p" r' Y, r
} \( J& U) @, S* ?+ `8 Q
else \, s: T2 T7 \+ K" i
{ \
& _9 r5 N! E3 ]2 E& _
(__HANDLE__)->Lock = HAL_LOCKED; \( u: Y4 _2 [! e; i8 y" J. g; x
} \5 E/ H' s# c+ ^( X& N2 c# d
}while (0U)
3 k/ k' H1 s% u3 K3 d
: p: ~! v5 D6 {" ^* n4 m
#define __HAL_UNLOCK(__HANDLE__) \
L+ P' y6 ~! I/ r
do{ \
3 b- J$ n- K* X' O; r& y- k
(__HANDLE__)->Lock = HAL_UNLOCKED; \( L6 U m+ K, o$ H$ c/ f
}while (0U)
- M6 r B7 V2 Q N! i! H7 B

复制代码

HAL_UNLOCKED表示0，HAL_LOCKED表示1，在文件stm32mp1xx_hal_def.h中有定义。可以看到，__HAL_LOCK其实就是判断被操作的__HANDLE__（本实验中被操作的是串口4）是否已经上锁，如果没有上锁，则执行加锁，如果已经上锁，则返回繁忙HAL_BUSY，程序就立即退出所进入的函数，函数后面的代码就不会再被执行。__HAL_UNLOCK则表示解锁。程序是怎样的设计思路呢？我们来分析一下：
进入HAL_UART_Receive_IT函数以后，第5行，先执行__HAL_LOCK进行加锁，如果在解锁前再次调用HAL_UART_Receive_IT函数，则会返回HAL_BUSY，程序退出。第32行，通过函数指针调用UART_RxISR_8BIT来完成字符接收操作，所以第35行就调用__HAL_UNLOCK进行解锁，也就是说，必须执行接收数据操作以后，才可以再次调用HAL_UART_Receive_IT函数。
__HAL_LOCK和__HAL_UNLOCK在DMA、定时器、串口等HAL库驱动中比较常见，我们后面的实验还会遇见它们，如果是双工通信，这两个宏要格外注意。
我们来看看UART_RxISR_8BIT函数是怎么接收字符的：

1 static void UART_RxISR_8BIT(UART_HandleTypeDef *huart)
E) P; X, V, g# G0 e% A
2 {4 y0 i- n( m/ p3 r
3 uint16_t uhMask = huart->Mask;
- S( W+ x X! a4 F# B) t' f
4 uint16_t uhdata;
! A) I, F0 [7 Z+ q4 u4 v! [
5 ' R- d- K8 d! a( Z) _& E8 t" m% k
6 /* 检查接收过程是否正在进行*/' h) o! e/ ^6 }* _1 S4 u
7 if (huart->RxState == HAL_UART_STATE_BUSY_RX)2 z& |0 u5 g! l2 H
8 {- @' L" @; Z& W X- ]" v8 \. P
9 uhdata = (uint16_t) READ_REG(huart->Instance->RDR);. ?% b: P9 ~$ O$ F2 w
10 *huart->pRxBuffPtr = (uint8_t)(uhdata & (uint8_t)uhMask);
1 l" e$ i/ V7 g8 {
11 huart->pRxBuffPtr++;
' ]4 r5 ?! v: _" r
12 huart->RxXferCount--;0 f/ Z& K9 V5 X& ?9 S6 [
13
/ o, ~9 b$ X% y& I# q
14 if (huart->RxXferCount == 0U)
. l. r8 ?$ R! @- L# v
15 {
& F! T+ S: l1 C4 x# E6 {) b
16 /* 关闭UART奇偶校验错误中断和RXNE中断 */! K: x5 x: A% f2 @
17 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | \ USART_CR1_PEIE)); s; r# G% o9 \0 B2 @
18
/ j$ u" Q. K% v1 J! U
19 /* 关闭UART错误中断：（帧错误，噪声错误，溢出错误）*/
! y# O, j8 k6 V, E. u
20 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);- f% B; \4 ^; {' P+ b/ O2 R4 T
21+ v+ b' u3 P. Q9 A
22 /* Rx进程完成，将huart-> RxState还原为Ready */
7 J- l" d3 M/ t, K7 y9 @1 h* Y
23 huart->RxState = HAL_UART_STATE_READY;+ k: r! E1 e% s4 F
24
" r% W, H8 G. R1 Q! @
25 /* 清除RxISR函数指针 */
1 n& B5 Y" J3 h$ [+ X% g9 ?8 X
26 huart->RxISR = NULL;4 N' j; u* T: Z" a/ `! j; @
27
' e7 K* \/ G) u/ l$ t. x
28 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
3 n3 z; m7 m7 \" J) p( K- |
29 /* 调用注册的Rx完成回调函数 */
% d: U, n/ E" Q/ p. @- m5 }0 y
30 huart->RxCpltCallback(huart);
2 N7 r$ ^4 `5 {" i% |+ u
31 #else
& T7 A2 }5 Q) D o1 s
32 /* 调用旧版弱Rx完成回调函数*/
2 n4 G# f) r$ l, v% {4 B' `6 K
33 HAL_UART_RxCpltCallback(huart);
0 z0 b8 W2 `6 ]7 a: X
34 #endif
& y1 \. O$ J& x1 z7 E' \6 D: ~
35 }
$ S' f5 b, z. S% J
36 }
; i! D! s7 m) P6 z- p
37 else
7 s) n/ L' b) j: Z/ Y
38 {9 k3 n, n9 {1 M
39 /* 清除RXNE中断标志 */
" X- s( U/ t9 p3 L8 S7 g/ T+ k# w8 T
40 __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
2 R0 y7 L+ l9 H$ X1 G% J
41 }, Y1 y# e' a" y8 K& F# O7 y
42 }( n F. A) c) p- F4 t5 h

复制代码

以上代码，我们也是关注红色的部分，进入UART_RxISR_8BIT函数以后：
第17和第20行表示关闭串口接收中断；
第26行，清除RxISR函数指针；
第33行，调用HAL_UART_RxCpltCallback(huart)回调函数以完成中断，此回调函数是弱定义的函数，需要用户重新定义一个回调函数，后面我们会自己编写。这里注意，前面第17和20行已经关闭了串口接收中断，也就是说，在一次串口中断接收的最后，即串口接收完一组数据之后就关闭了串口接收中断了，程序只能完成一次中断接收，如果要下次还要接收数据的时候，就要再次打开串口，所以可以在回调函数中再次调用HAL_UART_Receive_IT函数来开启接收中断，从而实现继续接收数据。
我们注意到，HAL_UART_Receive_IT函数并不是用来接收串口数据的，而是根据条件打开对应的中断处理函数的，如前面标红的UART_RxISR_16BIT_FIFOEN和UART_RxISR_8BIT等函数，而打开的这些中断函数才是真正的串口中断接收处理函数。

usart.c文件
我们在usart.h文件中声明一个变量RxBuffer，此变量用于设置串口发送和接收缓冲区的大小。
uint8_t RxBuffer;
usart.c文件是UART4的初始化代码，因代码比较多，我们这里分成几部分列出。
usart.c文件代码1

1 #include "usart.h"
# i$ J, {9 w9 ~# `! ]7 P: v
2
6 V* w' y9 M, _/ Q, q
3 UART_HandleTypeDef huart4; /* UART句柄 */* d3 J3 l$ c8 r( F2 a4 P! O4 M
4 /**
; C1 ]/ n3 h3 `( q% p
5 * @brief 串口UART4初始化函数) p) ?2 n+ p2 X1 }
6 * @param 无( o# T$ t# e% Z$ S6 T
7 * @note 注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
" {% Z: k* X$ t- b
8 * 这里的UART4的时钟源在SystemClock_Config()函数中已经设置好了.
; l% _$ F2 y9 P4 R
9 * @retval 无
. ]0 G3 L) d- X' L$ d& g
10 */
11 void MX_UART4_Init(void)
6 W* y# A" G, ~- j) u
12 {
; U c. }8 S' w2 r, u4 q
13 huart4.Instance = UART4; /* USART4 */
14 huart4.Init.BaudRate = 115200; /* 波特率115200 */
, B1 B$ B1 f9 Q$ D5 d" n
15 huart4.Init.WordLength = UART_WORDLENGTH_8B; /* 字长为8位数据格式 */
. f+ o8 l! U6 t, i1 }* m
16 huart4.Init.StopBits = UART_STOPBITS_1; /* 1个停止位 */% F q+ T2 n- r! O
17 huart4.Init.Parity = UART_PARITY_NONE; /* 无奇偶校验位 */
( `9 y6 M; J* Q% x1 f. k
18 huart4.Init.Mode = UART_MODE_TX_RX; /* 收发模式 */* S) |# l- h0 ]- g6 N7 h
19 huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* 无硬件流控 */
" x6 Q( m9 H; S0 |. }
20 huart4.Init.OverSampling = UART_OVERSAMPLING_16;/* 16倍过采样 */0 W. P! E% d8 }1 x
21 /* 指定选择3个样本 */4 ~% s6 `. w' d$ m( d6 D* y
22 huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
! @0 t7 c9 k. B( K# D# ?
23 /* 指定用于分频UART时钟源的预分频器值为1 */* _) I" W+ u) ?2 o4 [- a
24 huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1;9 m }. C+ X. b% r7 x8 h
25 /* 不初始化UART的高级功能 */
! u5 ] j' @- W& u( i5 N
26 huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
3 ^0 ~8 I6 B, ?: R& T0 ^
27 /* HAL_UART_Init()会使能UART4 */. b+ H- E4 j/ i; C2 D9 j+ Y' W$ H
28 if (HAL_UART_Init(&huart4) != HAL_OK)# x; _4 R7 }+ n
29 {
1 |0 L" F. G. J; {5 t' S' R; n3 E
30 Error_Handler();
# \5 P4 X/ }6 Z7 J- U* a
31 }
& z2 G( L1 B5 s7 r# _( ^7 u, c* Q
32 if (HAL_UARTEx_SetTxFifoThreshold(&huart4, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
- Q& {, X1 @# I9 z/ [
33 {
3 R: {& Y8 g" l/ @' A6 n/ ^
34 Error_Handler();8 |& |& K7 ]. q q) C# g
35 }
3 Z8 k7 m3 @1 N3 _4 v- h2 y
36 if (HAL_UARTEx_SetRxFifoThreshold(&huart4, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)! g9 f7 C4 x# h
37 {
$ ? b G R' S! c$ Z8 e
38 Error_Handler();0 h3 Y: n6 u) f4 ^1 I, c X! I1 E
39 }
0 s+ o# U: v. k3 m
40 if (HAL_UARTEx_DisableFifoMode(&huart4) != HAL_OK)
- G4 Y- `. ]" G. A& i* S6 X' C% ?/ Z
41 {
' ]8 ]: M4 E9 D& M W+ q; f% J
42 Error_Handler();
* B1 i) v4 S1 L
43 }
$ O! C1 q! G3 T( d9 j
44
6 |. D% O! ^- W- z9 i+ C3 k5 [
45 }

复制代码

如上第一部分代码：
第4行，初始化串口句柄huart4，后面通过此句柄来完成串口的初始化。
剩下的部分代码，初始化UART4的重要参数：波特率为115200，字长8位，1个停止位，无奇偶校验位、收发模式、无硬件流、16倍过采样。
接下来我们看看第二部分代码：

usart.c文件代码2

46 /**% u, U/ S# n' f& z5 e
47 * @brief UART底层初始化函数/ i* R: H0 h, i2 w* ^' C. \
48 * @param huart: UART句柄类型指针! p3 ]" i! I% ^) D
49 * @note 此函数会被HAL_UART_Init()调用
6 v0 F/ e' R6 [
50 * 完成时钟使能、引脚配置、中断优先级配置( t$ t' q4 _: w8 K& r
51 * @retval 无
. l3 n8 e9 C) y: I4 E( z
52 */
: J: U. \3 t! m5 D4 E9 R+ L
53 void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)0 y6 \/ b( N5 S9 m6 ^7 K5 [
54 {8 t: V e# b' \5 i1 @" x( ~
55
2 B( P( q* L$ p
56 GPIO_InitTypeDef GPIO_InitStruct = {0};2 }$ ?1 S4 z3 |
57 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};* v5 n$ Q3 c- M! `8 J" B+ N
58 if(uartHandle->Instance==UART4)6 b9 `2 k/ e8 @! D s) q# s
59 {
. F$ g% R/ \, G$ L& D7 p
60 if(IS_ENGINEERING_BOOT_MODE())
: r7 g; k- E. ~% l: |( z
61 {
3 B" B" w- M& Z- {6 F6 f1 b
62 /* 指定UART24时钟源WEI PCLK1（APB1）设置UART4时钟源=APB1=104.5MHz */& n3 b) }8 g0 X6 i: W% [0 U
63 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_UART24;
8 F" Q; H- F* F# U: w
64 PeriphClkInit.Uart24ClockSelection = RCC_UART24CLKSOURCE_PCLK1;
" }% J. q, e3 }8 [9 p0 q
65 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)$ c6 g& i* O$ u& x4 ?! d+ l
66 {
0 o+ H3 \! J7 ?' C2 p
67 Error_Handler();$ X! T5 a) M; }" j/ u# w
68 }
/ c& ~2 s. W% S6 k* j' p5 K7 ^
69 0 _7 z( H9 y# E3 |0 H
70 }
* `2 Y! H6 O+ X3 [0 x
71 . Z c: r5 t* B9 [0 M. b* G( v6 m7 s4 X
72 /* UART4 时钟使能 */+ y1 x; E2 A- B4 d+ \& `
73 __HAL_RCC_UART4_CLK_ENABLE();, |% N) E" q% { E& w1 @
74 /* RX和TX引脚时钟使能时钟使能 */
% |: c e w6 V. E- l* I
75 __HAL_RCC_GPIOG_CLK_ENABLE();
- Z. E7 g- ^9 J
76 __HAL_RCC_GPIOB_CLK_ENABLE();% V6 ^! L1 d, W! k% ?. m X
77 /**UART4 GPIO Configuration6 v% j( }6 H" x; l1 }6 m
78 PG11 ------> UART4_TX
Y2 o9 z. \8 w4 W. v. Q: ~; `
79 PB2 ------> UART4_RX
6 t$ T6 {: t- j* d2 o2 G$ b# X( m
80 */
5 s& J2 |6 q/ y, n
81 GPIO_InitStruct.Pin = UART4_TX_Pin; /* TX引脚 */
( o$ _% L: [: m0 v) J h u
82 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; /* 复用推挽输出 */9 t& d3 H" y. a- p7 u1 G
83 GPIO_InitStruct.Pull = GPIO_PULLUP; /* 上拉 */
4 x5 ?: b5 Z$ j- U+ |* @* C
84 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;/* 高速 */
k. p$ p( y( X. Y z
85 GPIO_InitStruct.Alternate = GPIO_AF6_UART4; /* 复用为UART4 */
. L! q" k2 P; w# K' u3 e
86 /* 初始化发送引脚 */: e# ~* o6 f, r( g
87 HAL_GPIO_Init(UART4_TX_GPIO_Port, &GPIO_InitStruct);$ ]$ R' p! X# B$ B8 H
88
^( G p x9 A
89 GPIO_InitStruct.Pin = UART4_RX_Pin; /* RX引脚 */- \2 G9 K4 z# i) u! Y. y; J
90 GPIO_InitStruct.Mode = GPIO_MODE_AF; /* 复用为UART4 */! V- \/ z* {: m8 i6 x! Y: O
91 GPIO_InitStruct.Pull = GPIO_PULLUP; /* 上拉 */$ j- F/ [0 { Y! }# ?9 t1 A
92 GPIO_InitStruct.Alternate = GPIO_AF8_UART4; /* 初始化接收引脚 */* z) E$ M R7 e( o$ t1 L$ G4 o) {
93 /* 初始化接收引脚 */' ?* l. Q9 B2 Z, e2 [; z2 k
94 HAL_GPIO_Init(UART4_RX_GPIO_Port, &GPIO_InitStruct);
4 Y2 c0 D0 G! B6 X: o' s
95
( j! |" i+ r/ C+ E: W
96 /* UART4 中断优先级初始化 */. h* R. m/ n0 A- b7 G5 P
97 HAL_NVIC_SetPriority(UART4_IRQn, 3, 3);/* 抢占优先级3，子优先级3 */
3 |7 t* d* O; b! u$ \7 Z
98 HAL_NVIC_EnableIRQ(UART4_IRQn); /*使能UART4中断号为UART4_IRQn=52 */$ t, _6 |0 w5 Z6 w8 d: }- A3 a
99 }. e7 L0 v3 {( c3 U- h6 R9 w
100 }
: }& @ b# K) Z3 z) v

复制代码

以上代码主要是使能UART4时钟、配置UART4两个引脚的工作模式和设置中断优先级。
第53~76行，MX_UART4_Init函数用于开启UART4和两个引脚（TX和RX）的时钟，且时钟来源于APB1，设置最大为104.5MHz。当然也可以设置为其它的频率值，需要在STM32CubeMX上手动配置。
第81行~94行，配置UART的两个引脚的模式以及复用功能。两个引脚均复用为UART4，开启上拉。
第97行，设置UART4的抢占优先级和子优先级均为3。
第98行，使能UART4中断。
这里注意，UART4的中断号是固定的，在文件stm32mp157dxx_cm4.h中有定义，在前面的外部中断实验中我们有分析过中断号、中断向量表和中断服务函数的对应关系，如果不清除这些关系的，还可以回头看看中断服务函数章节的章节小结部分。
接下来是USART的去初始化的代码（也就是反初始化），即关闭UART4时钟，不初始化两个引脚，关闭中断。

usart.c文件代码3

101 1 x6 x# p+ o# G5 J5 X7 k
102 void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
' w% ?' z4 Z8 {9 R3 b0 O
103 {& v; D# F# B" n' W) B- T
104: G# k* q, l- A1 Y$ E/ U
105 if(uartHandle->Instance==UART4): u4 I( V. y# A; h9 \
106 {
: w9 M/ }6 L+ M" r- r/ u
107 /* 关闭UART4时钟 */) x9 r2 A9 _$ E1 O* `% C# D
108 __HAL_RCC_UART4_CLK_DISABLE();1 ^, _& b1 e7 b' c
109
. _% S' j, |* O% M2 r
110 /**UART4 GPIO Configuration# S7 }9 \- p$ R3 a% e8 u' N+ w) C
111 PG11 ------> UART4_TX% d" I# Y5 ]( a6 \9 X# u5 ]
112 PB2 ------> UART4_RX
4 }9 f$ e; L/ t# |5 {- r3 v! a0 A
113 */
' z0 j# ]) f- [5 b6 a, [
114 HAL_GPIO_DeInit(UART4_TX_GPIO_Port, UART4_TX_Pin);; A' I/ |7 I4 C, _
1157 c+ o2 M6 s$ V. x+ q9 G0 y, Y6 g
116 HAL_GPIO_DeInit(UART4_RX_GPIO_Port, UART4_RX_Pin);+ Q- p( Q9 D+ c' m+ d
117
/ s( y! G; X G6 ^# y/ x5 q
118 /* UART4 中断去初始化 *// b4 m: F! @* j
119 HAL_NVIC_DisableIRQ(UART4_IRQn);
% [& [: |" W, n2 r2 c
120 }
3 A3 ~" n$ l. P5 y( \; f' p4 R
121 }
( N/ v" I6 z7 q; E1 K4 w6 V: P
我们来看看最后部分的代码，这段代码是我们前面添加上去的：
: l6 `' B m$ f/ e0 P, P' N
usart.c文件代码4, n) n6 Q2 S5 y1 n/ z
1228 J+ p3 @; R7 M" H7 N
123 /* USER CODE BEGIN 1 */6 J; w2 h( P- s8 X; k2 O8 C
124 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
5 H3 V1 w- x3 Q( { ^
125 {9 C( v. o1 J$ ?, W9 I( E
126 HAL_UART_Transmit(&huart4,&RxBuffer,1,0); /* 以查询方式发送字符 */1 h2 [) \2 ~: w+ l
127 HAL_UART_Receive_IT(&huart4,&RxBuffer,1); /* 重新打开串口中断 */
l, n8 |- M4 H4 C! O+ _- ~
128 }
& Q& t1 o) A. P
129 /* USER CODE END 1 */* j# Q* \/ ]5 Z- f- @8 Y

复制代码

在没有编写回调函数的时候，串口只能完成一次发送和接收，前面我们分析了，串口在完成一次中断接收以后，就关闭串口中断了，如果想要实现字符的循环发送和接收的话，可以在回调函数里添加数据发送函数HAL_UART_Transmit和函数HAL_UART_Receive_IT来实现，这样，只要串口有数据在发送，就可以接收数据。
这里说明上面的重要参数：
第126行，参数一指定的串口是huart4；参数二，RxBuffer是一个发送缓存区的地址，电脑发送过来的数据会堆放在这个发送缓冲区里；参数三是指定发送缓存区域的大小，这里是1个字节，发送缓冲区满（达到1个字节）以后，串口就发送数据，这里注意，回车也表示1个字节，如果按下回车，串口就会发送数据（因为回车是一个字节，发送缓冲最大设置为1个字节）；参数四是指溢出时间，时间为0，溢出时间是通过Systick来计时的，我们前面也多次说过。
第127行，参数一，使用的串口为huart4；参数二，RxBuffer是接收缓存区的地址，huart4接收数据的时候会把它们放在这个区域中；参数三是指定接收缓存区域的大小为1个字节，也就是当接收缓冲区达到1个字节字符以后（表示接收结束），就会发生接收完成中断，也就调用一次回调函数进行相应处理，注意的是，接收到的回车也是一个字节，所以电脑只发送回车的话，会打印空行，后面的实验中我们会看到现象。

main.c文件
main.c函数的大部分代码我们都已经熟悉了，例如系统时钟配置部分，在前面的系统时钟实验部分我们已经分析过，这里就不再讲解了。我们来看看main.c文件的代码：

1 #include "main.h": G. ^" ]6 T0 t/ \- P9 _
2 #include "usart.h"
& F6 P' Y- {$ D8 K: E' ^! o+ j N
3 #include "gpio.h"$ N# O( C2 M/ a R4 t2 D
4 void SystemClock_Config(void);
( T9 O% B* r! o, |
5
$ {0 R \7 N ?; N
6 int main(void)
/ Q$ o2 N+ k$ ~" W1 X" V
7 {# M5 o4 E1 v6 _% o0 @% O ?
8 HAL_Init(); /* 初始化HAL库 */0 h- W- T1 c7 e1 ]. g/ G) o! p3 ^
9 + o3 Z) j, G: `
10 if(IS_ENGINEERING_BOOT_MODE())
0 b1 _+ p. a3 f
11 {
4 C- k0 z; g8 N. v7 m0 q* Y
12 /* 配置系统时钟 */( x- N" n8 \+ c+ P' d/ t
13 SystemClock_Config();3 g1 q. u0 @7 L
14 }
: U* ^; ?% ^2 H" P2 @' d+ N
15
3 w7 N* H" B$ a' u; k
16 MX_GPIO_Init(); /* 初始化已经配置的GPIO */
" r4 e( o8 P% m
17 MX_UART4_Init(); /* 初始化UART4 */. H- m2 a+ A4 x2 D
18 $ |& y; u# h8 B9 m/ H" m; J4 q
19 /* USER CODE BEGIN 2 */; ], K Z8 G& Z6 i
20 /* printf("请输入字符，并按下回车键结束\r\n"); */
# k, |! H$ i( j
21 HAL_UART_Receive_IT(&huart4,&RxBuffer,1);
$ a) N6 X+ J9 }- r4 y }9 _
22 /* USER CODE END 2 */# F7 q3 r2 z" A6 C+ b7 B" g
23 % w3 Z/ b' ~4 V$ @: \1 Q
24 while (1)
' a, u0 k( ~0 q+ q' o! @- q
25 {0 I5 d, w/ G, Q" P
26 /* USER CODE END WHILE */
$ s! A L( k* V t4 W; r9 ~; b
27 /* USER CODE BEGIN 3 */
; m0 @$ H5 J* `( d9 V1 {, d2 l
28 printf("\nPlease enter characters and press enter to end\r\n");; ` `0 n" ]4 P! ~
29 HAL_Delay(6000);' V$ U+ D7 ~3 j* B) e7 j# ~
30 }" c; O1 b# U1 B- v9 U5 N
31 /* USER CODE END 3 */: s7 z: h5 a8 r1 j3 `0 ^7 k* K) U' R
32 }: u3 {4 v0 r6 y2 ~* Q% \7 Y" g
33 /**
( j1 o j3 T3 v1 t# w+ m! K( a
34 * @brief M4主频时钟设置函数，也就是设置PLL3
- D D4 x e2 i
35 * @param plln: PLL3倍频系数(PLL倍频), 取值范围: 25~200.
# z: m6 m0 |: R" H9 e
36 * @param pllm: PLL3预分频系数(进PLL之前的分频), 取值范围: 1~64.8 c8 C b6 C- }' Z
37 * @param pllp: PLL3的p分频系数(PLL之后的分频), 分频后作为系统时钟, 取值范围: 1~128.(且必须是2的倍数)
* z( j8 U) m2 x% W6 |9 H. C W
38 * @param pllq: PLL3的q分频系数(PLL之后的分频), 取值范围: 1~128.
2 H1 y, _& @3 Z4 o
39 * @note
4 _, ]) a9 o; Z
40 * MP157使用HSE时钟的时候，默认最高配置为:; ?8 v% e/ X, T& `
41 * CPU频率(mcu_ck) = MLHCLK = PLL3P / 1 = 209Mhz0 c$ b8 M2 S' g! C0 M
42 * hclk = MLHCLK = 209Mhz1 q3 B. Z/ t* j( A. N7 o
43 * AHB1/2/3/4 = hclk = 209Mhz
+ U+ U2 h- H* t
44 * APB1/2/3 = MLHCLK / 2 = 104.5Mhz
6 ?5 g1 D9 N6 u, S6 `# S* @+ J4 a
45 * @retval 无;
! z& T! U; \( e/ G& ~
46 */
; i, d- p' f8 }6 J' g
47 void SystemClock_Config(void)- V% ]! j, g( s- S: `
48 {
' v/ a# F) h, f8 Q/ U u) R2 ~- m" w
49 /* 定义RCC_OscInitStruct、RCC_ClkInitStruct结构体变量，并初始化为0 */
) q+ K/ ]+ _3 j: v. }* r, W
50 RCC_OscInitTypeDef RCC_OscInitStruct = {0};& L; l8 g; D; C; w1 Q& d$ \
51 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
6 f# F4 d( A8 \! n( J* Z
52
4 T8 D6 ?5 g8 [' C+ s0 h
53 /*给RCC_OscInitTypeDef结构中的成员变量赋值完成初始化RCC振荡器 */
; v; c* l+ w: n9 c
54 RCC_OscInitStruct.OscillatorType = \ RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_LSI \
: i, T7 ^( m# I8 a; u
55 |RCC_OSCILLATORTYPE_HSE;: s1 p5 N2 L! {. P
56 RCC_OscInitStruct.HSEState = RCC_HSE_ON; /* 打开HSE */6 h& O, k0 ~" T+ q
57 RCC_OscInitStruct.HSIState = RCC_HSI_ON; /* 打开HSI */
# [. |# y8 {: r! [2 V- Q' F7 _( W8 ^
58 RCC_OscInitStruct.HSICalibrationValue = 16; /* 校准HSI值 */7 t$ f" T" a2 m5 y3 P' ?
59 RCC_OscInitStruct.HSIDivValue = RCC_HSI_DIV1;/* 设置HSI分频值为1 */
Z) }! U, @: b' x7 b
60 RCC_OscInitStruct.LSIState = RCC_LSI_ON; /* 开启LSI */
, Z& z6 d- C* D' M8 Y1 @
61 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE; /* 没有PLL的状态 */( E2 }" }' k! m4 h( K: v
62 RCC_OscInitStruct.PLL2.PLLState = RCC_PLL_NONE;/* 没有PLL2的状态 */$ Q6 b) }- n; @9 h
63 RCC_OscInitStruct.PLL3.PLLState = RCC_PLL_ON; /* 开启PLL3 */6 _5 Z/ k5 S/ j f7 i
64 /* PLL3输入时钟源为HSE */ - k& E% F# F" ~% T1 h7 U" M
65 RCC_OscInitStruct.PLL3.PLLSource = RCC_PLL3SOURCE_HSE;
4 @1 \9 U7 y: D8 \% |. d2 z7 o
66 /*) ? r# r2 r( \/ ]) g1 S
67 * 配置锁相环PLL3的分频和倍频参数，也就是：
7 j1 y+ I! v" D9 e' Z N+ n
68 * DIVM3=2，DIVN3=52，DIVP3=3，DIVQ3=2，DIVR3=2，FRACV=20489 a9 S/ G4 y: V5 `! d
69 * 则PLL3的pll3_p_ck输出频率为：- W$ ?, Z8 N, r0 K: ^9 v6 n( p
70 * pll3_p_ck=(hse_ck*(DIVN3+FRACV/2^13 ))/(DIVM3*DIVP3)=209MHz
8 d5 h" \+ `0 o- Z/ K
71 */
k5 M1 Y3 K/ O6 @& V; J; S
72 RCC_OscInitStruct.PLL3.PLLM = 2; /* DIVM3=2 */2 v" s$ ~3 k- g. c2 U: t1 R4 F5 C' |# W7 n
73 RCC_OscInitStruct.PLL3.PLLN = 52; /* DIVN3=52 */
& l' t; O* h+ V
74 RCC_OscInitStruct.PLL3.PLLP = 3; /* DIVP3=3 */( C" f+ Y6 F$ B: ^ F
75 RCC_OscInitStruct.PLL3.PLLQ = 2; /* DIVQ3=2 */
, e. ^7 b% D# [3 o
76 RCC_OscInitStruct.PLL3.PLLR = 2; /* DIVR3=2 */) \/ ^, N& ~3 G8 z
77 RCC_OscInitStruct.PLL3.PLLRGE = RCC_PLL3IFRANGE_1;& Z3 u# X5 \, A7 d+ ~0 _
78 RCC_OscInitStruct.PLL3.PLLFRACV = 2048; /* FRACV=2048 */8 O) K+ U. K. O9 i
79 RCC_OscInitStruct.PLL3.PLLMODE = RCC_PLL_FRACTIONAL;/* 分数模式 */) R0 _1 k( h2 h
80 RCC_OscInitStruct.PLL4.PLLState = RCC_PLL_NONE; /* PLL4没有状态 */
( e7 |1 l! R; D. |
81 /* 调用的HAL_RCC_OscConfig函数用于判断 HSE、HSI、LSI、LSE 和
$ Q* [. V2 v3 {4 L y
82 * PLL（PLL1、PLL2、PLL3和PLL4）是否配置完成，配置完成则返回HAL_OK。9 j E2 s5 |% |1 }; d0 O1 e
83 * 如果没有配置完成，发生错误的话就会进入Error_Handler函数（空循环）。5 Q& P- A; i) r* g, ^
84 */8 \: i0 y) R( @7 f1 N
85 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
& X& x! j4 I' b e$ a
86 {$ `) ?8 u2 @7 R* R1 b1 J" D7 }
87 Error_Handler();9 H9 E6 H: i! \
88 }
; u2 `6 r5 L8 V! R4 T: V/ r2 X
89 /*
, x* R* u1 u. e5 j5 w
90 * 给RCC_ClkInitStruct结构体成员赋值来配置RCC时钟，也就是：
9 t6 y$ z7 ~* N0 o
91 * 配置AXI的时钟源和分频器分频值（也就是配置ACLK）；; A; j8 N3 c3 ^5 a
92 * 配置MCU的时钟源和分频器分频值；- `- x7 K( I: R! n
93 * 配置APB1~APB5的分频值（也就是配置PCLK1~5）。
% i% A1 P, T; \5 T2 \# g+ a G4 \
94 */
- v# g& v( |+ Q7 v; Z
95 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_ACLK
9 `) l' v9 ~+ q, }! f, k$ @
96 |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
' w' ? f) o! d& K
97 |RCC_CLOCKTYPE_PCLK3|RCC_CLOCKTYPE_PCLK4
9 U1 i" n6 K6 O7 ~$ T" b7 h
98 |RCC_CLOCKTYPE_PCLK5;
3 P6 l3 x6 w5 p5 U2 u5 M
99 /* 配置AXI时钟源为HSI */
- x, X! _7 Q$ C% g- c. V' d
100 RCC_ClkInitStruct.AXISSInit.AXI_Clock = RCC_AXISSOURCE_HSI;
/ Z) Q8 y7 M1 n5 i
101 /* 配置AXI分频器为1分频=ACLK=64MHz */
8 F" f6 ^( `9 B7 P: M: V
102 RCC_ClkInitStruct.AXISSInit.AXI_Div = RCC_AXI_DIV1;% o6 A- z: J$ h T
103 /* 配置MCU时钟源来自PLL3=209MHz */
0 h4 T i, r4 T$ ^0 a% ?
104 RCC_ClkInitStruct.MCUInit.MCU_Clock = RCC_MCUSSOURCE_PLL3;3 k- W: z4 l9 w! W
105 /* 配置MCU分频器为1分频=MCU=209MHz */* ]5 b* k) W2 k7 r; l# M/ L
106 RCC_ClkInitStruct.MCUInit.MCU_Div = RCC_MCU_DIV1;1 ?; n" b" Y6 u9 B2 _" {; l* I' f
107 /* 配置APB4分频器为1分频=PCLK4=64MHz*/; }: y6 ?# M/ A1 H' C/ `
108 RCC_ClkInitStruct.APB4_Div = RCC_APB4_DIV1;
' X( @4 Z/ }& ]8 r
109 /* 配置APB5分频器为2分频=PCLK5=64MHz */
7 ]7 ~2 Y) R! A- S9 B6 k* y1 L
110 RCC_ClkInitStruct.APB5_Div = RCC_APB5_DIV1;
7 f3 J6 {' W& \' F5 f
111 /* 配置APB1分频器为2分频=PCLK1=104.5MHz */
+ k7 i! ^* Z, }9 u+ [/ l* l
112 RCC_ClkInitStruct.APB1_Div = RCC_APB1_DIV2;
- [& q! y: r, H, w4 F3 G2 ^/ @) |
113 /* 配置APB2分频器为2分频=PCLK2=104.5MHz */
! o2 i# ^6 i' |, x& C
114 RCC_ClkInitStruct.APB2_Div = RCC_APB2_DIV2;& H. b; v4 D5 m1 G7 J! V5 E
115 /* 配置APB3分频器为2分频=PCLK3=104.5MHz */# |+ h1 C$ g1 P8 E4 C
116 RCC_ClkInitStruct.APB3_Div = RCC_APB3_DIV2;! s9 ~4 [ \! s0 `0 J
117 /*
9 a' v+ F6 B, u
118 * 调用HAL_RCC_ClockConfig函数，根据RCC_ClkInitStruct中) }- l7 G2 H: F" R
119 * 指定的参数初始化MPU，AXI，AHB和APB总线时钟，如果初始化3 z* n, N: b: b" ~: `. k! F, P
120 * 不成功，则进入Error_Handler空循环函数。- X* q$ ?3 m7 [6 K
121 */
. h' e9 r. d6 B4 J
122 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct) != HAL_OK)% f/ {( s* ^ a$ g9 i: Y) m- c
123 {/ x' _- h6 E2 H6 f
124 Error_Handler();
" ?3 w! j) u$ _6 ]5 H4 Y, o p* M9 a
125 }
) |0 |# s# k/ Z6 q& h/ P# Y
126 /* 设置RTC时钟的HSE分频因子 */5 N3 `9 a. B: L* Y& d9 t& Q7 w
127 __HAL_RCC_RTC_HSEDIV(1); z; T7 {4 @1 t4 C6 |5 A
128 }! P9 M( u, B4 |
129& m( k: A; b0 b6 w4 w" R9 X# M/ q
130 /* USER CODE BEGIN 4 */) ?5 Y( S; P. J: J6 z! M) O2 Z; Y6 h" d
131 #ifdef __GNUC__( u2 V0 B# V' U6 i& A a; M* X6 `
132 #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
- C- Z1 O! S$ r- c4 f
133 #else- F& Q/ {& G1 y0 Y2 @+ M0 ^
134 #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
* h7 s- P9 g: |7 A, R
135 #endif
7 v7 p# G3 f$ c( g
136 PUTCHAR_PROTOTYPE
/ q3 A/ |' R1 }% @8 f9 e. i! s
137 {. Y0 h& h- G. d; y& R9 F
138 /* 本实验使用的是UART4，如果使用的是其它串口，则将UART4改为对应的串口即可 */
7 y- `6 W7 R! c# w
139 while ((UART4->ISR & 0X40) == 0); /* 等待上一个字符发送完成 */
" F% Z: H4 p" _; C$ V2 u9 s
140 UART4->TDR = (uint8_t) ch; /* 将要发送的字符 ch 写入到TDR寄存器 */
# A G/ m2 ` f
141 return ch;/* 返回要发送的字符 */
. @# g/ X8 y/ Q. L, K( o
142 }
8 M; D, L: `2 l3 [$ X4 }) S
143 /* USER CODE END 4 */' H# Y4 R6 J: n6 a8 J7 K9 t$ I
144" R8 s3 K+ O2 x: @1 i3 Z" S
145 /* 发生错误时执行此函数 */4 s; m2 U* }4 k4 m
146 void Error_Handler(void)
/ m8 m1 b) l' {, l9 i) k. v% R
147 {
S7 v, P' c& ]
148 + h! G$ p. X6 M+ D7 C
149 }+ w& r @; B; [7 f
150
7 T+ b* ]) r" \) M0 R
151 #ifdef USE_FULL_ASSERT* Z9 Y: n, K; O( c5 Y4 h$ E
152 /* 断言相关函数 */. ^6 i* ^; S6 W8 E
153 void assert_failed(uint8_t *file, uint32_t line)
9 N$ O7 _ m6 S0 N: r1 z* n
154 {- F- d. \: J/ \- v8 A/ i
155 - U9 c0 K1 F- Q
156 }
9 W3 I/ s Y& s9 j+ ^6 |7 V, a
157 #endif

复制代码

第21行的代码是我们前面手动添加的，调用HAL_UART_Receive_IT(&huart4,&RxBuffer,1)函数开启接收中断来完成一次串口接收。参数一指定串口huart4，参数二RxBuffer是串口接收缓冲区，参数三是1，表示缓冲区最大为1字节，也就是缓冲区达到1字节的时候就表示接收结束，然后进入回调函数HAL_UART_RxCpltCallback中，回调函数我们前面已经重新定义了，在前面的usart.c文件中我们已经分析了回调函数。通过回调函数，我们就可以实现字符的循环发送和接收。这里提一下，第21行的代码也可以直接放到while循环中执行。
第28和29行，通过printf输出流和HAL_Delay函数每隔6s的时间打印一句话。打印的字符尽量写成英文格式，因为STM32CubIDE上显示中文会出现乱码，其对中文兼容的不是很好，这个也是软件的一个bug。
直接通过printf函数的话，STM32是不能够输出字符的，要在嵌入式中使用此函数的话，需要通过重映射的方式，将printf函数重映射到STM32串口的寄存器上才可以，也就是我们手动添加的第131~142行的代码。首先，要使用printf函数的话，工程中要调用stdio.h文件，实际上工程里已经包含了stdio.h文件了。其次，printf函数实质上是操作__io_putchar或者fputc函数的，只需要改写或者重定向这两个函数即可。
第132和134行，将宏PUTCHAR_PROTOTYPE定义为__io_putchar和fputc函数，然后再重定义PUTCHAR_PROTOTYPE函数。第139~141行是PUTCHAR_PROTOTYPE函数的内容，通过查看USART_ISR寄存器的标志位，判断上一个字符发送完成以后，再将要发送的字符（也就是printf后面的字符）写入到TDR寄存器，然后通过串口打印出来。
printf函数使用很灵活，大家可以多尝试。例如，上面的PUTCHAR_PROTOTYPE函数是直接操作的寄存器来实现的，我们也可以改用HAL库来实现（两种方式本质一样）：

PUTCHAR_PROTOTYPE2 \! v% ^2 ?' L' G( P
- H& S: h( A7 J0 s% v8 c
{
1 C- ]4 z1 P* y4 e, |3 Y
/* 注意第一个参数是&husart4 */1 { C' Z9 U4 k ~( B% b
HAL_UART_Transmit(&huart4 , (uint8_t *)&ch, 1, HAL_MAX_DELAY);8 w8 A0 O: a; z+ X$ A" Y1 t
return ch;
5 J, S* R3 b2 j( V0 ?
}% j/ K9 u0 e6 A+ E: a: l$ F* p( P& Y
还记的我们前面第八章节实验中说的syscalls.c文件吗，我们也可以利用此文件中的_write函数来实现，_write函数有预留__io_putchar接口给我们使用，其代码如下：6 W4 @8 X8 c: k7 c2 @4 x3 p+ d
extern int __io_putchar(int ch) __attribute__((weak));
5 y. N# i, X$ @& S# \1 d
extern int __io_getchar(void) __attribute__((weak));
, {$ o n/ Q( v
__attribute__((weak)) int _write(int file, char *ptr, int len)4 d2 @. {% R$ x, o- j7 s( O
{
9 b+ L7 Q* l" l" B0 |
int DataIdx;' n1 L/ q5 d) s6 Q
- u0 O, y* u4 M `2 W4 V2 K
for (DataIdx = 0; DataIdx < len; DataIdx++)
' O2 P) }4 \1 k; i6 ? n1 y1 s
{
- c( P$ b ^" Y* @% M9 `
__io_putchar(*ptr++);
. Z) e8 S% L) C E& R' r
}
' Y2 Q- p" \' K
return len;
6 m T0 D7 m" X: m$ W! a
}# m4 Y1 A9 I% U% ^; K1 t
所以，我们前面第131~142的代码也可以用如下代码代替：8 S; q6 M2 Q3 \& G8 {) W
int __io_putchar(int ch)
+ x4 r8 P1 l) J9 d3 j E
{
' T9 k- j3 Y# O) }8 z" Q
/* 具体哪个串口可以更改USART1为其它串口 */4 t; \7 d- Y* U; M
while ((UART4->ISR & 0X40) == 0); /* 等待上一个字符发送完成*/
( {" k5 b& R M, X) Q3 g
UART4->TDR = (uint8_t) ch; /* 将要发送的字符 ch 写入到DR寄存器 */1 E2 r- l( `9 o0 B# m$ W$ \
return ch;
) f) A6 J2 T- Z- M( H. c% v
}' b, ~- G* [* ?% S) o5 ]

复制代码

14.4.4 编译和测试
以上代码添加完毕以后，编译工程无报错以后，用Type-C线接在开发板的USB_TTL接口上，线的一端接在电脑的USB口上，按照前面的步骤连接好ST-Link，同时注意开发板上的JP11处的跳线帽是否已经接好，如果跳线帽没接，那么UART4则无法正常通信，拨码开关拨成001，即MCU启动模式，进入Debug模式。

图14.4.2. 14开发板连接方式
双击开发板光盘A-基础资料\3、软件下的串口软件XCOM V2.0.exe将其打开：

图14.4.2. 15打开XCOM V2.0
打开XCOM V2.0以后，选择Type-C接口对应的串口（笔者的是com61），设置波特率为115200，停止位为1，数据位为8，无奇偶校验位，即保持和前面配置工程的时候一样的参数配置，在串口操作处选择打开串口（打开串口以后显示的字眼是关闭串口）：

图14.4.2. 16设置打开XCOM V2.0的参数
进入Debug以后，点击运行按钮，可以看到串口软件每隔6s的时间打印一句话：Please enter characters and press enter to end。

图14.4.2. 17串口输出printf的信息
我们在数据输入框中输入我们想要发送的字符，例如输入“好好学习，天天向上”，输入好以后鼠标点击发送，然后看到串口软件上显示我们发送的字符，串口中断接收回显实验验证完成：

图14.4.2. 18串口接收回显

14.5 串口中断发送实验
本实验配置好的实验工程已经放到了开发板光盘中，路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 7-2 UART5_TX。
前面我们使用UART4的发送端TX来发送数据，并使用接收端RX接收发送出的数据，然后可以通过串口中断打印出来，实验中我们使用HAL_UART_Transmit以查询方式发送字符，并使用HAL_UART_Receive_IT重新打开串口中断，因为串口在接收完成后就自动关闭中断了，所以要想连续发送和接收，我们就在串口接收完成回调函数中做文章，添加如下代码：
void HAL_UART_RxCpltCallback(UART_HandleTypeDef UartHandle)
{
HAL_UART_Transmit(&huart4,&RxBuffer,1,0); / 以查询方式发送字符 /
HAL_UART_Receive_IT(&huart4,&RxBuffer,1); / 重新打开串口中断 */
}
本节实验，我们来使用串口的发送中断来发送一串字符，上一章节的实验也可以测试本章的实验。
14.5.1 硬件设计

1.例程功能
有时候，可能我们只需要串口的发送功能，实验调试的时候可以配置好串口发送端，然后使串口发送端发送数据，上位机来接收数据。本实验将UART5的发送端的引脚TX接入到一个带有USB接口的串口模块的RX引脚中，然后通过串口中断发送数据，而串口模块接收数据，并将接收到的数据在串口终端软件中打印出来。本实验需要USB转TTL 串口(CH340)模块，例如正点原子的USB转TTL串口模块(CH340)：

图14.5.1. 1 USB转TTL串口模块(CH340)
或者手上有三合一USB串口转换器以及正点原子高速DAP仿真器都是可以的，这些模块都带了USB转TTL 串口(CH340)功能：

图14.5.1. 2 DAP仿真器
2. 硬件资源
本实验中我们会用到开发板底板的UART5的发送引脚TX来发送数据：UART5_TX—PB6。
3. 原理图
开发板的JP1排针引出了PB6引脚：

图14.5.1. 3 UART5发送端引脚
从数据手册可以看出，PB6引脚可以复用为UART5_TX，我们就使用该引脚来发送数据：

图14.5.1. 4 PB6可以复用为UART5_TX
14.5.2 软件设计
新建和配置工程
（1）配置引脚
新建工程UART5，然后配置PB6复用为UART5_TX：

图14.5.2. 1配置PB6复用为UART5_TX
配置UART5_TX后，UART5_RX也会自动配置了：

图14.5.2. 2UART5_RX自动配置
（2）配置UART5参数
UART5的参数我们选择默认配置：波特率为115200Bit/s；字长为8位；无校验位；1位停止位；数据方向为发和收；16倍过采样；Clock Prescaler（时钟预分频器）分频值为1。

图14.5.2. 3UART5参数配置
（3）配置GPIO
如下，配置UART5_TX为上拉和高速模式，其它就保持默认：

图14.5.2. 4UART5_RX引脚配置为上拉高速模式
（4）配置NVIC
本实验我们要使用串口发送中断，所以要配置NVIC，这里注意的是，如果串口中断程序（例如回调函数）中使用HAL_Delay延时函数（优先级默认为0）的话，要注意串口中断的优先级要比HAL_Delay的优先级要低，否则会出现程序卡死的情况，这点我们在上一章外部中断实验章节有详细介绍到。先开启串口全局中断，此时中断优先级默认为0：

图14.5.2. 5开启全局中断
如果串口中断程序中要使用HAL_Delay延时函数，或者其他中断程序（中断的嵌套）则在NVIC处配置中断优先级，这里我们配置串口中断优先级分组为2，抢占优先级和子优先级都是3，关于优先级怎么分配，我们在上一章的实验中有讲解过：

图14.5.2. 6配置中断优先级
（5）配置时钟
串口时钟最大可以是105MHz，我们就按照上一章节的配置方法来配置，先开启HSE，再手动配置时钟：

图14.5.2. 7配置时钟树
（6）配置生成独立的.c和.h头文件：

图14.5.2. 8配置生成独立的文件
（7）生成初始化代码
按下“Ctrl+S”保存配置，生成初始化代码：

图14.5.2. 9生成工程
2. 添加用户代码
（1）修改main.c文件
main.c文件代码如下，串口启动后，第一次发送的字符是“WWW.openedv.com”。
/* USER CODE BEGIN 2 /
/ 进入main.c文件时第一次发送的字符串 /
uint8_t Senbuff[] ={“WWW.openedv.com\r\n”};
/ 使用串口中断发送Senbuff里的字符串 */
HAL_UART_Transmit_IT(&huart5,(uint8_t )Senbuff, sizeof(Senbuff));
/ USER CODE END 2 */
（2）修改usart.c文件
usart.c文件的代码如下，串口第一次发送完成后会调用回调函数HAL_UART_TxCpltCallback，同时将串口中断关闭，如果想实现第二次或者更多次发送，可以在回调函数中再次执行发送，即再次执行HAL_UART_Transmit_IT函数，我们选择发送字符串ALIENTEK：

/* USER CODE BEGIN 1 */! y' U' U# \- ~" t( |7 w) |
uint8_t RxBuffer[] ={"ALIENTEK\r\n"};/* 要发送的字符串 */
5 L# @( m3 d2 k4 _5 F: p d
/*7 `7 i8 E9 s; u2 F8 u6 [
void delay_short(volatile unsigned int n)' T9 n. H8 w: t2 e1 R# J
{" b L! e8 S% ?1 i% X, d- {
while(n--){}/ x9 C w0 X- D* F' c
}
& ]% J5 J p. L- ^3 K2 ^
void delay(volatile unsigned int n)1 h! i( T, U P! S0 P+ P/ v
{/ m9 y* m2 p+ m/ a" w* p& j& p: m' |
while(n--); V# }5 l# `2 c8 u& @: X" O/ |0 d
{
: L( s. n% E4 [ s; \/ T5 E" z" |
delay_short(0x7fff);' P; g: _$ p P9 r% A1 W. x! }& y
}
6 B& I2 ?! ]9 C6 F- n$ ]
}
4 P3 [$ a% `5 n5 I4 b+ n
*/' B9 N1 l1 J9 j: r0 q1 t
/* 串口发送完成中断回调函数 */
' E, f. f# H/ P& [
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *UartHandle)
* p3 a$ E; Q! r9 t
{' S, g/ e6 h- r l' j0 m
HAL_Delay(3000); /* 延时3s，每隔3s发送一次 */5 ~- S! y# d( k' o" a; q& G$ y
/* 启动UART5串口发送中断 */9 b3 h8 u1 w" q% \3 T
HAL_UART_Transmit_IT(&huart5,(uint8_t *)RxBuffer, sizeof(RxBuffer));
) h9 M( \, p I2 }
}
1 @4 f2 q7 {( u4 @
/* USER CODE END 1 */

复制代码

以上代码每隔3s发送一次，回调函数中使用了HAL_Delay延时函数，所以前面我们配置串口的中断优先级比HAL_Delay的优先级低。当然，也可以使用其它空循环来达到延时的效果，如上面注释部分的函数delay_short。

14.5.3 编译和测试
保存修改，编译工程无报错后进行测试。将开发板的PB6用杜邦线接到USB转TTL 串口模块(CH340)的RX端，将开发板引出的地线接到USB转TTL 串口模块(CH340)的GND端：

图14.5.3. 1硬件接线
调试结果如下，可以看到串口接收到数据并打印出来了，第一条字符串是WWW.openedv.com，后续的字符串是ALIENTEK：

图14.5.3. 2测试结果

14.6 章节小结
14.6.1 程序设计总结
本小节我们对前面的串口中断接收回显实验程序实现的过程做一个简单的总结：
1）STM32CubeIDE对串口的初始化操作已经为我们做好了，并使能了UART4中断；
2）我们先指定大小固定的发送缓存区和接收缓存区；
3）电脑发送过来的数据会堆放在发送缓存区里，当达到用户指定的大小以后，TX就利用HAL_UART_Transmit函数发送接收缓存区的数据；
4）串口接收缓存区接收到TX发送过来的数据，当达到用户指定的接收缓存区大小以后，就开始调用函数HAL_UART_Receive_IT，此函数会根据有无FIFO以及字长是多少位等条件来调用对应的中断处理函数UART_RxISR_8BIT；
5）串口接收RX进入中断处理函数UART_RxISR_8BIT以后，发送完数据就自动将串口中断关闭了，然后调用回调函数HAL_UART_RxCpltCallback执行后续的操作；
6）回调函数本来是一个弱定义、无实际内容的函数，我们手动编写了回调函数，可以实现再次发送字符并重新打开串口中断，以实现继续接收下一次发送过来的字符。
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
{
HAL_UART_Transmit(&huart4,&RxBuffer,1,0);
HAL_UART_Receive_IT(&huart4,&RxBuffer,1);
}
这里说明一下函数HAL_UART_Receive_IT和HAL_UART_Receive的差别：HAL_UART_Receive函数没有回调函数，使用轮询（阻塞模式）的方式接收数据，其规定了一个接收超时机制，如果函数接收超时就返回。HAL_UART_Receive_IT函数并不接收数据，只是打开对应的串口中断，数据接收是在串口中断中进行的。在一个工程中不能同时使用这两个函数，如果同时使用这两个函数，那么HAL_UART_Receive不能进入阻塞模式，此函数就形同虚设了。

图14.5.1. 5几个文件的关系
14.6.2 串口中断过程
对于中断的过程，可以按照前面外部中断实验章节的来分析。
stm32mp1xx_hal_msp.c文件有配置中断优先级分组为2。

void HAL_MspInit(void)% o5 q( ]) D _& } Z
{
5 y* d* l. V0 S4 y1 s; [) g
__HAL_RCC_HSEM_CLK_ENABLE();
& R7 v0 s6 _) b) @
% t& x' c8 H! e* J- Z6 D
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_2);
* w# ^& o" n, y' Z; S, ^
}

复制代码

usart.c文件中有配置中断的优先级并开启UART4中断，其中UART4_IRQn是中断号，中断号为52，这是在stm32mp157dxx_cm4.h文件中定义好了的。

HAL_NVIC_SetPriority(UART4_IRQn, 3, 3);# \7 \* G0 ~4 u: p; y- k+ R; [
HAL_NVIC_EnableIRQ(UART4_IRQn);

复制代码

stm32mp1xx_it.c文件中有中断服务函数。UART4的中断服务函数UART4_IRQHandler会调用中断响应函数HAL_UART_IRQHandler，这里注意的是，所有的串口中断都会调用HAL_UART_IRQHandler函数来响应中断，具体是哪一个串口，参数里会指定，如上面的代码，参数是句柄huart4，所以会处理UART4的中断。

HAL_UART_IRQHandler函数会判断是什么中断，当判断是接收中断时，会调用HAL_UART_Receive_IT函数，接下来的操作就是我们前面介绍的部分了。
: {4 T, I$ i b8 Y9 Q1 x6 e
void UART4_IRQHandler(void)8 _9 @' E4 I" u3 W- m
{ s9 Q+ F& D& ?# l' z0 s* f! B! h
HAL_UART_IRQHandler(&huart4);
; y7 d- U$ j8 J4 r/ c; D
}

复制代码

CPU根据中断号判断是UART4中断以后，CPU会根据中断号找到启动文件中的中断服务程序的入口地址，根据此地址跳到中断服务函数。如果用户没有定义中断服务函数，发生中断以后则执行启动文件中预定义的空函数，如果用户有正确定义中断服务函数，发生中断后则执行用户定义的中断服务函数。如果有中断嵌套，要注意中断的优先级，例如串口中断回调函数中使用HAL_Delay延时函数时，串口中断的优先级不能比HAL_Delay的优先级高。
本篇实验我们只是涉及到了M4内核的中断控制器NVIC，到了A7内核使用的是GIC，中断的内容很庞大，中断的应用非常广，理解并学好中断对后续的实验以及项目的开发很有帮助。关于中断的处理流程我们就介绍到这里，在以后的实验中，遇见中断，大家就想到中断号、中断向量表和中断服务函数的对应关系就明白了，在以后的实验中我们不再花更多的篇幅去讲解这部分内容。