认识HAL库
. t" Y5 ~$ c$ c! \8 p第四章生成的工程是基于HAL库的，这点我们在前面有提过，在第四章的操作中，我们通过第一个工程实验熟悉了STM32CubeIDE的基本使用方法。本章节，我们来认识HAL库。HAL库文件夹是STM32Cube固件包中重要的一部分，因为HAL库比较特殊，所以我们将其作为独立的章节来专门讲解。
在讲解之前我们需要说明一点，分析HAL库中的源码或者工程中的文件，不管它有多么复杂，无非就是一些.c源文件和.h头文件，还有一些类似.s的启动文件，而头文件中遇见比较多的就是一些宏定义和函数声明，.c文件比较常见的就是一些函数的定义。在分析过程中，我们去理解这些文件重要的宏定义和函数的作用，然后把这些函数和文件的关系弄清楚，在日后的项目开发中，我们才可以亲手操刀去打造属于自己的项目设计，在使用HAL库的时候才不至于逻辑混乱，犹如庖丁解牛，游刃有余。
. ^1 m* K& b# `
  a. f! t0 _6 \- a7.1 HAL库初识
* s6 D4 v$ Q' u7.1.1 获取HAL库
, k. F% i! G7 E! U, `% |  r6 G在STM32Cube固件包中有一个STM32MP1xx_HAL_Driver文件夹，该文件夹下存放的就是HAL库，我们所说的HAL库就是指里边的库文件。



图7.1.1. 1 HAL库在固件包中
, q* f; n( J4 n! e* P) z6 T在介绍HAL库文件前，我们先来理解下面几个概念。
( [, `: B2 i: E- e: _9 x% k. N  }7.1.2 什么是HAL库
3 i1 u( |; c7 H4 ?在介绍HAL库之前，我们先来理解两个概念，什么是API？什么是句柄（Handle）？
: r0 u* |) Z* k* ?' @7 f- L前面我们多次提到API这个词，API 全称Application Programming Interface，翻译过来就是应用程序编程接口。接口，可以理解为是一些已经封装好了的可以被调用的功能函数或者方法，我们把这些函数放到我们的工程中，当我们要实现某个功能时，就可以在工程中找到对应的函数，然后进行调用。
: o- n" @% S1 z# @) b句柄（Handle），在STM32的手册上经常看到这个词，可以理解为它是一个指针，或者是一些表的索引，或者是用于描述和标记某些资源的的标识，这些资源可以是函数、可以是一段内存、可以是一组数字、可以是一个外设等等，总之很广泛，通过句柄我们可以访问到打开的资源。我们在调用API函数的时候，可以利用句柄来说明要操作哪些资源。
4 Y! i% I- z8 D3 Z( X: S/ kHAL的含义，ST官方手册里的解释是Hardware abstraction layer，即硬件抽象层，单词的首字母组合起来就是HAL。HAL库是一些封装好的驱动程序，向下可以操作硬件，向上可以给用户提供可操作的接口。



6 X; V) h* U1 B! p4 k. t6 z图7.1.2. 1 HAL库属于驱动程序
: H7 I9 G: V" e2 k7 j4 sHAL库，笔者的理解是，ST把对不同系列MCU的操作经过一层一层的封装，将硬件进行抽象化表达出来，最后呈现给我们的就是HAL库。硬件抽象化，也就是将对寄存器的操作做了一系列封装，将外设抽象组织为句柄，使我们看不到寄存器的影子，最后分离出可以调用的API，使用者可以不去关注底层、不必关注复杂的硬件寄存器就可以进行编程，通过调用API和句柄操作可以实现对MCU的大部分外设进行操作，使用起来非常方便，而且很容易进行移植。
7.1.3 HAL库能做什么
STM32开发方式中，可以直接配置寄存器或者可以使用官方的库来实现。
, L% N0 ]6 M& C我们在51单片机开发的时候就直接配置寄存器，但是到了32位单片机开发，如果开发大型项目，需要的功能外设很多，再使用这种方式就已经力不从心了。因为STM32的外设资源丰富，寄存器数量是51单片机寄存器的数十倍，那么多的寄存器根本无法记忆，而且开发中需要不停查找芯片手册，开发过程就显得机械和费力，完成的程序代码可读性差，可移植性不高，程序的维护成本变高了。当然了，采用直接配置寄存器方式开发会显得更直观，程序运行占用资源少。如果项目中只用少数几个外设，或者同一系列的芯片，项目组内部有一套成熟、可移植性高的祖传代码，开发起来就没那么困难了。
' R1 `) h6 r$ L# d为了简化开发人员的工作，减少开发工作时间和成本，针对STM32 系列芯片，ST官方推出了标准外设库(STD库)、HAL 库和LL 库 。在这些库中，有很多用结构体封装好的寄存器参数，有常用的表示参数的宏，还有封装好的对寄存器操作的API，开发者可以调用这些资源实现配置相应的寄存器，效率大大提高了。使用库的框架来开发，程序控制语句结构化，程序单元模块化，贴近人的思维，易于阅读，易于移植和维护。
" L! Y* @  ]3 Y/ y$ ]可以这么说，库是架设于寄存器与用户驱动层之间的代码，向下是直达硬件相关的寄存器，向上为用户提供配置寄存器的接口，用户代码通过这些接口来间接操作寄存器。



  k0 s: O2 ?$ D; Y1 E图7.1.3. 1库和直接操作寄存器对比
7.1.4 HAL库和其它库有什么不同
7 L' Z% O! x$ A* l$ E0 |; p前面我们提到，针对STM32 系列芯片，ST官方推出了标准外设库(STD库)、HAL 库和LL 库 ，那么HAL库和其它两种库有什么差别？下图是三种库对STM32系列产品的支持，目前STM32MP1仅支持HAL库。

! b; ^% a0 R! w, v) v, M) I2 C8 J

图7.1.4. 1 HAL库对ST系列产品的支持情况

. ]$ ]$ J% u2 n/ |, B7 p% m+ F1.标准外设库
! J* t6 P4 }! |% M! \7 P/ GSTD（Standard Peripheral Libraries）标准外设库，它把实现功能中需要配置的寄存器以结构体的形式封装起来，使用者只需要配置结构体变量成员就可以修改外设的配置寄存器，比直接操作寄存器方便了不少。但标准外设库仍然接近于寄存器操作，它的方便也是针对某一系列芯片而言的，在不同系列芯片上使用标准外设库开发的程序可移植性比较差，例如，在F4上开发的程序移植到F3上，使用标准库是不通用的。目前STM32系列产品中仅F0-F4以及L1系列支持标准外设库。
, X, z. J2 F* W; ~- d  q2.HAL库
为了解决标准库存在的问题，ST 在标准库的基础上又推出了 HAL 库。个人认为，HAL库是用来取代之前的标准库的，因为这几年ST官方大力推广HAL 库，而且在ST新出的 STM32 芯片中， ST 直接只提供 HAL 库。
HAL库在设计的时候更注重软硬件分离，HAL库的目的应该就是尽量抽离物理层，HAL库的API集中关注各个外设的公共函数功能，以便定义通用性更好的API函数接口，从而具有更好的可移植性。HAL库写的代码在不同的STM32产品上移植，非常方便，效率得到提升。目前HAL库支持STM32各个系列产品。
3.LL库
LL库（Low Layer）是 ST 继HAL库之后新增的库，与 HAL 库捆绑发布，在前面的STM32CubeIDE第一个工程实验中，我们看到在STM32CubeMX插件里有选择使用HAL库还是LL库的选项。
$ t( f' S9 X  {LL库的英文名字翻译过来就是底层的意思，实际上LL 库更接近硬件层，它和STD库类似，都是直接操作的寄存器，只不过LL库可以在STM32Cube中实现。LL库提供一组轻量级、优化、面向专家的API，具有最佳的性能和运行时效率。LL库可以完全独立使用，也可以结合HAL库一起使用。当HAL库需要优化运行时，可以调用LL库来处理，而对于复杂的外设（例如：USB驱动），两者混合使用，才能正常驱动这个复杂的外设。


( }9 v: \0 y7 \# s, y$ @9 q. q
1 L" z, T6 b: E" w8 [* ?; v9 Z图7.1.4. 2 HAL库和LL库
7.1.5 怎样学习HAL库
（1）不管HAL库封装的有多好，本质上还是通过配置MCU/MPU的寄存器来实现我们想要的功能。所以我们学习HAL库的同时，还需要学习外设的工作原理和寄存器的配置方法，通过原理来理解HAL库是怎样实现我们想要的功能，要知其然更要知其所以然。
（2）HAL库不仅仅是底层驱动，它更是一套行业内可以公开和认可的架构。学习HAL库，我们要了解它的架构，了解库中每个文件夹下大概有哪些文件，文件之间的关系是什么，函数之间的调用关系是什么，调用条件是什么，常见的数据结构怎么用。
: C* I0 z7 X3 W8 F4 [/ ]3 ?4 \（3）学习HAL库，遇到疑问的地方可以查HAL的帮助文档，可以上网上查询相关说明，可以在Wiki上对共同的主题进行扩展或者探讨，多看相关的例程，跟着例程操作，多总结。
（4）要学会使用ST提供的优秀的开发工具，掌握STM32Cube工具套件的使用方法，熟话说得好，磨刀不误砍柴工。
5 m& _% y+ S& L% t1 G不管怎样，我们的目的就是为了使用HAL库来开发，学会调用HAL库的API函数，配置对应外设按照我们的要求来工作，实现想要的功能。
下面，我们进入主题，分析HAL库。
7.2 HAL库文件夹结构
STM32MP1xx_HAL_Driver文件下的Src（Source的简写）文件夹存放是所有外设的驱动程序源码，Inc（Include的简写）文件夹存放的是对应源码的头文件。Release_Notes.html是HAL库的版本更新说明信息。STM32MP157Cxx_CM4_User_Manual.chm是HAL库的用户手册。
! ^4 U3 F: m; Y


图7.2. 1 HAL库文件夹
1 z5 `( J+ C& @9 |# G$ t- p打开Inc文件夹，里边是一些以stm32mp1xx_hal和stm32mp1xx_ll_开头的.h文件，对应地，在Src下也有一堆以stm32mp1xx_hal和stm32mp1xx_ll_开头的.c文件，其中stm32f1xx_hal_开头的是HAL库文件， stm32f1xx_ll_开头的文件是LL库文件。
0 z, Y$ M' z2 h& v1 J


. }$ x$ r4 w% P0 [5 G6 D0 x1 b图7.2. 2 HAL库文件
HAL库下的文件很多，有一部分文件的功能可以归为一类，例如stm32mp1xx_hal_i2c.h/c、stm32mp1xx_hal_adc.h/c、stm32mp1xx_hal_dma.h/c等等这些文件，他们属于一些外设的配置文件，那么我们后面会以stm32mp1xx_hal_ppp.h/c来统称这些文件。有的是特殊文件，我们会重点介绍。HAL库关键文件介绍如下表：

# R. i0 ?' P8 @; ^; @; g4 e

% B. g- `0 h' L: {# g表7.2. 1 HAL库关键文件介绍
除了HAL库的文件命名有规则以外，库中的函数以及句柄等的命名均有规律，如下表所示，其中PPP表示某个外设名。
7 y6 {% J( Z. n8 ^* b. T/ S
: g, e: O+ U# [+ h2 t2 i
6 B- `: v1 m9 V  t1 ~1 n
1 t: P1 C8 J! ?' e1 y" Y4 H. L表7.2. 2 HAL库的句柄和函数命名规律
例如I2C相关的，如stm32mp1xx_hal_i2c.h、stm32mp1xx_hal_i2c.c、I2C_HandleTypeDef、HAL_I2C_Init()等。对于HAL的API函数，常见的有以下几种：
初始化/反初始化函数：HAL_PPP_Init()，HAL_PPP_DeInit()
% L" I& M0 _+ ~7 z2 }( P外设读写数：HAL_PPP_Read()，HAL_PPP_Write()，HAL_PPP_Transmit()和HAL_PPP_Receive()
; Y5 t1 K# n! C6 ]* S5 v; C控制函数：HAL_PPP_Set ()，HAL_PPP_Get ()
状态和错误：HAL_PPP_GetState ()， HAL_PPP_GetError ()
HAL库封装的很多函数都是通过定义好的结构体将参数一次性传给所需的函数，参数也有一定的规律，主要有以下三种：
$ ]  N$ y% d0 V6 t! E+ M配置和初始化用的结构体
一般为PPP_InitTypeDef或PPP_ ConfTypeDef的结构体类型，根据外设的寄存器封装成易于理解和记忆的结构体成员。
' A/ Y0 r5 s4 w3 R% X- q! [* G特殊处理的结构体
专为不同外设而设置的，带有“Process”的字样，实现一些特异化的中间处理操作等。
外设控制句柄（PPP_Handler）
HAL驱动的重要参数，可以同时定义多个句柄结构以支持多外设多模式，HAL驱动的操作结果也可以通过这个句柄获得。有些HAL驱动的头文件中还定义了一些跟这个句柄相关的一些外设操作。如用外设结构体句柄与HAL定义的一些宏操作配合，即可实现一些常用的寄存器位操作，即可实现对外设的操作。
  w4 l$ N+ p5 Q4 G: e


表7.2. 3 HAL库驱动部分与外设句柄相关的宏
但对于SYSTICK/NVIC/RCC/ GPIO这些外设，不使用PPP_HandleTypedef这类外设句柄进行控制，如HAL_GPIO_Init() 只需要初始化的GPIO编号和具体的初始化参数。
HAL_StatusTypeDef HAL_GPIO_Init (GPIO_TypeDef* GPIOx, GPIO_InitTypeDef *Init)
{
% c/ O" \0 T4 W2 D! T% d/GPIO 初始化程序……/
, {& Z$ w2 F) y( z5 X9 i}
此外，HAL库中很多地方使用了回调函数，前面我们解释过回调函数可以被用户重定义，HAL库中的回调函数很多命名如下：

5 p; e$ q+ e* q* \6 R2 B! C

表7.2. 4 HAL库驱动中常用的回调函数API
至此，我们大概对HAL库驱动文件的一些通用格式和命名规则有了初步印象，记住这些规则可以帮助我们快速对HAL库的驱动进行归类和判定这些驱动函数的用法。
7.3 如何使用HAL库
HAL库下的文件实在是太多了，而且每个文件里的API函数也很多，我们学习的时候该从哪里看起呢？虽然文件多，API函数也多，不过我们可以将其进行分类，先将重要的配置文件了解一遍，然后再去学习某几个外设文件，只要学会了其中某部分外设，其它外设的就很类似了。
针对庞大的HAL库，ST官方提供了HAL库的用户手册，例如STM32MP157系列的芯片，ST在HAL库里提供了STM32MP157Cxx_CM4_User_Manual.chm，我们双击打开此文件：
5 T0 b: C. T8 {3 {4 D目录结构下有Modules、Data Structures、Files和Directories共4个主题，我们先来查看Modules。
Modules下有STM32MP1xx HAL_ Driver和STM32MP1xx_LL_Driver，分别对应HAL库和LL库的驱动，我们看HAL库下的驱动部分。
打开GPIO列表下的IO operation functions / functions，查看里面的API函数接口描述，我们选择查看HAL_GPIO_WritePin函数，双击即可以打开此函数的说明，如下图所示。可以看到函数的定义、函数的作用、函数注意事项、参数说明以及函数在哪个文件，位置是在哪里等等：


  a. V# |4 j0 g. l
图7.3. 1 HAL库用户手册
5 K( v) Q* l3 [+ c0 ^通过说明，函数是viod类型，没有返回值。第一个形参GPIO_TypeDef *GPIOx，x可以是A~K，通过此参数来选择对应的GPIO外围设备。第二个形参uint16_t GPIO_Pin是指定要写入的端口位（某个pin），这个参数可以是GPIO_PIN_x中的一个，其中x可以是0~15。第三个形参GPIO_PinState PinState是指定要写入到所选位的值，GPIO_PinState参数可以是枚举类型中的GPIO_PIN_RESET（复位）或者GPIO_PIN_SET（置位）之一。
. \* L. c& `& t! M2 w4 X' q提示中说明，这个函数使用GPIOx_BSRR寄存器来允许原子的读/修改访问，即操作的是GPIOx_BSRR寄存器，关于此寄存器，我们可以查看参考手册中的说明。
' w$ Y/ ]/ X0 c所以，如果我们要将某个GPIO的某个pin置1的话，例如GPIOA的第2位，可以这样调用此函数：
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);
: U4 z3 [' X" a1 q% A4 V9 n/ k如果要查找某个函数或者参数，可以直接在搜索框中进行搜索，如下图查找GPIO_PIN_RESET：

6 d- I% o) R- w- n7 u5 M* \

; @5 h* M- ?0 s# Z图7.3. 2查找功能
. L$ q" A: x, _7 x8 Q1 B其它的主题，例如Data Structures、Files和Directories也可以给我们提供更多的帮助信息：



4 j# u4 [3 j& t% S0 [7 l* o图7.3. 3其它主题
关于此用户手册的使用就讲解到这里，在后面的实验中，遇见不明白的地方也可以查看此手册。
* D* R  ~0 h. A% O/ {4 R
7.4 HAL库重要文件分析
& F& O- p2 e3 O( @, T9 g$ J; H下面我们先分析2个非常重要的文件：stm32mp1xx_hal_conf.h和stm32mp1xx_hal.c文件。其它文件，我们会在后面对应的实验章节做专门的讲解。
7.4.1 stm32mp1xx_hal_conf.h文件
0 e! J' v" M/ h8 n! Q. b" Mstm32mp1xx_hal_conf_template.h是HAL库的配置文件模板，用于用户自定义驱动。如果使用MDK来开发，用户可以复制此文件到自己的工程目录，然后将其改名字为stm32mp1xx_hal_conf.h，STM32CubeIDE在生成工程的时候已经自动为我们做好了这一步，我们不用管。下面我们将stm32mp1xx_hal_conf_template.h文件的代码分为3部分进行讲解。
2 b0 v1 g1 ^9 b! ~' j9 v) F

1. 1   #ifndef STM32MP1xx_HAL_CONF_H
   2 X7 R. _' |8 i9 v; D
2. 2   #define STM32MP1xx_HAL_CONF_H
   
3. 3  
   / o) z: y1 Q0 f& j2 R8 }# T2 v
4. 4   #ifdef __cplusplus
   : b7 t; ^# |( H/ k  ?
5. 5    extern "C" {
   
6. 6   #endif
   
7. 7   /*
   9 X' |/ u4 I7 K. U
8. 8   * 模块选择
   . ~/ W2 l5 L- R6 ~4 R% @
9. 9   */
   
10. 10  #define HAL_MODULE_ENABLED
    
11. 11  #define HAL_ADC_MODULE_ENABLED
    
12. 12  #define HAL_CEC_MODULE_ENABLED
    
13. 13  ......
    ; t4 }5 r# _, T2 B% N6 ?
14. 14  #define HAL_USART_MODULE_ENABLED
    
15. 15  #define HAL_WWDG_MODULE_ENABLED
    
16. 16  /*
    * s3 L$ I: G( ~$ y' y5 e3 |' W
17. 17  * 注册回调函数选择
    
18. 18  */
    
19. 19  #define USE_HAL_ADC_REGISTER_CALLBACKS    0u
    / s) Q. r8 q9 H
20. 20  #define USE_HAL_CEC_REGISTER_CALLBACKS    0u
    ) t. V) h& y* |
21. 21  ......
    / B+ J) J) v/ O; I$ h
22. 22  #define USE_HAL_USART_REGISTER_CALLBACKS  0u
    6 ~( t; c% N0 l# j
23. 23  #define USE_HAL_WWDG_REGISTER_CALLBACKS   0u
    
24. 24  /*
    
25. 25  * 在HAL SPI驱动中激活CRC功能
    1 f. k3 M$ ?. w3 \9 Q& }. _8 K
26. 26  */
    ! R7 r) c+ m/ L0 M
27. 27  #define USE_SPI_CRC                     1U
    # i0 L% _& F3 a* U

复制代码

第4行到第6行，对这个语法我们前面有讲解，这里不讲。
第10行到第15行，这是将在HAL驱动程序中使用的模块列表，一旦使用了某个模块，那么就要使能相应的模块。例如，如果要使用TIMER功能，就在文件里添加：

#define HAL_TIM_MODULE_ENABLED
- S1 F/ ~7 F+ `, Q) g相应的，在stm32mp1xx_hal_conf.h文件最后也要加载对应模块的头文件。如果的是在在STM32CubeIDE上通过图形界面来配置的话，生成的工程已经自动为我们处理好了，如需要修改，可以再返回配置界面重新配置。

* {9 f7 y8 `* c0 G' B9 [+ m0 R

1. #ifdef HAL_TIM_MODULE_ENABLED
   6 d+ M% t0 n+ @' Y% R
2. #include "stm32mp1xx_hal_tim.h"
   + o) F" r% C- e, x8 _- d; m2 t
3. #endif /* HAL_TIM_MODULE_ENABLED */

复制代码

第19行到第23行，这段代码也是一些宏定义，表示将某个宏定义为0。这些宏定义有什么作用呢？例如USE_HAL_USART_REGISTER_CALLBACKS带有USART，应该和USART有关。打开Inc下的stm32mp1xx_hal_usart.h和stm32mp1xx_hal_usart.c文件，可以找到很多条件编译选项#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)。例如stm32mp1xx_hal_usart.h文件中声明的函数指针，void (* TxHalfCpltCallback)(struct __USART_HandleTypeDef *husart)中，TxHalfCpltCallback是一个指向函数的指针，(* TxHalfCpltCallback)是一个带有参数*husart、返回类型为void的函数，参数husart也是一个指针：
' o, T0 S" c; d' {) m# v
5 i3 m( ?( I( i- d

1. 1   #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
   
2. 2     void (* TxHalfCpltCallback)(struct __USART_HandleTypeDef *husart);
   ( Q( k" n% N3 ~" I
3. 3     void (* TxCpltCallback)(struct __USART_HandleTypeDef *husart);      
   - R( Y) h9 n1 z3 g& m$ Y
4. 4     void (* RxHalfCpltCallback)(struct __USART_HandleTypeDef *husart);  
   9 r- ^- T& O$ W) Q
5. 5     void (* RxCpltCallback)(struct __USART_HandleTypeDef *husart);      
   
6. 6     void (* TxRxCpltCallback)(struct __USART_HandleTypeDef *husart);   
   , w$ f0 ?( V2 v( \9 ~  ^3 R
7. 7     void (* ErrorCallback)(struct __USART_HandleTypeDef *husart);      
   
8. 8     void (* AbortCpltCallback)(struct __USART_HandleTypeDef *husart);  
   ( o( }& a+ r) O( l0 z% |
9. 9     void (* RxFifoFullCallback)(struct __USART_HandleTypeDef *husart);  
   & a" X+ I% A8 O7 F0 ^
10. 10    void (* TxFifoEmptyCallback)(struct __USART_HandleTypeDef *husart);
    
11. 11
    ' A" |9 j! h0 n! b1 [. f2 _+ A6 W
12. 12    void (* MspInitCallback)(struct __USART_HandleTypeDef *husart);      
    
13. 13    void (* MspDeInitCallback)(struct __USART_HandleTypeDef *husart);   
    
14. 14  #endif  /* USE_HAL_USART_REGISTER_CALLBACKS */

复制代码

$ K9 l5 C& W' rstm32mp1xx_hal_usart.c文件中USART_InitCallbacksToDefault函数的参数就是stm32mp1xx_hal_usart.h文件中的函数的指针，例如TxHalfCpltCallback就是它的参数（别忘了，TxHalfCpltCallback有自己的参数）
( Q& V+ w$ p3 N+ f
2 m/ ~9 m6 T' H7 d4 f

1. 1   #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
   
2. 2   void USART_InitCallbacksToDefault(USART_HandleTypeDef *husart)
   
3. 3   {
   
4. 4     /* Init the USART Callback settings */
   
5. 5     husart->TxHalfCpltCallback        = HAL_USART_TxHalfCpltCallback;     
   9 h+ v: z0 L! N' I
6. 6     husart->TxCpltCallback             = HAL_USART_TxCpltCallback;         
   
7. 7     husart->RxHalfCpltCallback        = HAL_USART_RxHalfCpltCallback;      
   
8. 8     husart->RxCpltCallback             = HAL_USART_RxCpltCallback;           
   
9. 9     husart->TxRxCpltCallback          = HAL_USART_TxRxCpltCallback;         
   
10. 10    husart->ErrorCallback              = HAL_USART_ErrorCallback;            
    
11. 11    husart->AbortCpltCallback         = HAL_USART_AbortCpltCallback;        
    
12. 12    husart->RxFifoFullCallback        = HAL_USARTEx_RxFifoFullCallback;     
    7 [; |. Q+ L2 a6 q& Q+ g  |  Z; ^
13. 13    husart->TxFifoEmptyCallback       = HAL_USARTEx_TxFifoEmptyCallback;     
    1 r- M& q* W! z4 @2 \1 {/ L7 ]& r
14. 14  }
    # s- n* I/ k$ t
15. 15  #endif /* USE_HAL_USART_REGISTER_CALLBACKS */

复制代码

上面的就是回调（Callback）过程。(* TxHalfCpltCallback)叫做回调函数。回调函数就是一个通过函数指针调用的函数。以上的过程可以这么形容：
) ~3 Q8 F) w, yA是回调函数，B是调用函数。A函数有参数a，B函数有参数b。参数b是一个指向A的函数指针，这样一来，就是B调用A，A有参数a，既然有参数就要给参数赋值，所以B函数内部给A的参数a赋值。那么，就是B调用A，A又利用B给A的参数a赋值，这个过程就叫做回调。
3 i. K2 Z; E( n总之，第19行到第23行，我们可以通过将0U改为1U来改变条件编译选项，从而实现我们前面说的回调过程。关于回调函数的使用，我们后面会进行讲解。
我们继续往下看剩下的代码，这部分主要是时钟配置：
. Z$ G6 r1 X; [6 F: Q7 `
7 z& M) @0 w5 @( [

1. 28  /*
   - z' ?( k  I4 F4 {
2. 29  * 时钟配置
   " e, e5 |* m0 ?/ y+ x
3. 30  */
   " Y% \* Z9 J" T- e* P5 _
4. 31  #if !defined  (HSE_VALUE)
   
5. 32    #define HSE_VALUE    24000000U                  /*高速外部振荡器HSE的值，24MHz */
   1 }% J" f7 A. H+ k- R- |
6. 33  #endif
   & y6 h7 R& T( l& C8 n; K% d
7. 34  
   ' ^( w4 \4 h' R/ k; B* W/ C$ T3 i
8. 35  #if !defined  (HSE_STARTUP_TIMEOUT)
   
9. 36    #define HSE_STARTUP_TIMEOUT  100U          /* HSE启动超时，100ms*/
   # ]# U; T' `) K0 e; B
10. 37  #endif /* HSE_STARTUP_TIMEOUT */
    + `$ i" J, a5 r  u, X) p
11. 38
    ) f/ d& @& {: Z5 N
12. 39  #if !defined  (HSI_VALUE)
    
13. 40    #define HSI_VALUE            64000000U  /*高速内部振荡器HSI的值，64MHz */
    
14. 41  #endif
    
15. 42
    : |+ }) [! G+ M% B
16. 43  #if !defined  (HSI_STARTUP_TIMEOUT)
    
17. 44    #define HSI_STARTUP_TIMEOUT  5000U          /*HSI启动超时，5000ms */
    $ g) t  o) x7 ]3 A5 Q
18. 45  #endif /* HSI_STARTUP_TIMEOUT */  
    
19. 46
    
20. 47  #if !defined  (LSI_VALUE)
    
21. 48    #define LSI_VALUE    32000U                           /*低速内部振荡器LSI的值，32KHz */
    0 i. Y" |3 b& ?% n0 L9 E7 k
22. 49  #endif      
    ( [4 J4 u' J9 k  _: ]
23. 50  
    
24. 51  #if !defined  (LSE_VALUE)
      m" z! v  E$ Z6 c2 U! \* s
25. 52    #define LSE_VALUE     32768U    /*低速外部振荡器LSE的值，32.768KHz */
    - y3 o! f& \9 t& q
26. 53  #endif
    
27. 54
    
28. 55  #if !defined  (LSE_STARTUP_TIMEOUT)
    
29. 56    #define LSE_STARTUP_TIMEOUT  5000U          /*LSE启动超时，5000ms */
    
30. 57  #endif /* LSE_STARTUP_TIMEOUT */
    
31. 58
    3 g( |+ t& K/ n# g% K3 v
32. 59  #if !defined  (CSI_VALUE)
    1 @' N# z' n( Q* o: S8 r2 W2 R
33. 60    #define CSI_VALUE    4000000U                         /*低功耗内部振荡器CSI的值，4MHz */
    6 b& W, r% r0 q& R% k2 c
34. 61  #endif
    
35. 62
    
36. 63  #if !defined  (EXTERNAL_CLOCK_VALUE)
    
37. 64    #define EXTERNAL_CLOCK_VALUE    12288000U /*外部时钟的值，单位是Hz */
    
38. 65  #endif

复制代码

* D- {' ]$ \2 ASTM32MP157的M4内核有5个时钟可以用：2个外部振荡器HSE、LSE和3个内部振荡器HSI、CSI、LSI。
HSE (High-speed external oscillator)是高速外部振荡器，可通过外接有源晶振驱动。官方HSE_VALUE默认是配置24Hz，这个参数表示外部高速晶振的频率，如果要使用外部晶振，请根据板子上外部焊接的晶振频率来配置，正点原子STM32MP157开发板的核心板上外接了24MHz有源晶振。
8 u7 D. j2 G+ f. BLSE (Low-speed external oscillator)是低速外部振荡器，通过外接有源或者无源晶振驱动，官方默认配置32.768 kHz。正点原子STM32MP157开发板的核心板上外接了32.768KHz无源晶振，主要用于驱动RTC 实时时钟。
' z5 N3 E  X2 K# n  l- uHSI (High-speed internal oscillator)是高速内部振荡器，频率可以是8、16、32、64 MHz。这里默认配置为64MHz。
# v2 u/ f- Q5 R. f- T! XCSI (Low-power internal oscillator)是低功耗内部振荡器，这里频率默认配置为 4MHz。
6 b5 x' {+ t9 u5 y3 aLSI是内部低速振荡器，这里频率默认配置为32 kHz，实际值可能会因为电压和温度而变化。使用内部时钟优势是成本低，缺点是精度差。
. Q( w5 o1 K- ]6 c这里是默认的值，如果我们不配置时钟，M4内核会默认采用HSI作为时钟源，频率为64MHz。如果我们配置时钟，可以直接在STM32CubeIDE的Clock Configuration图形界面来配置，配置好以后保存，然后生成工程，在生成的stm32mp1xx_hal_conf.h文件中，这里的值就会跟着变。关于时钟的配置，我们后面会有专门的章节来讲解。
. {; `! y0 N% }4 n7 ?( s* I下面我们看最后部分代码：

6 G4 D$ e( Y# f  d& p- |: n3 s2 ~% _9 }

1. 66  /*
   / O* U8 W" R  n, u" S' V: B
2. 67  * HAL系统配置
   1 Z! r. F, }/ G+ n% @9 b( L# H0 g
3. 68  */
   
4. 69  #define  VDD_VALUE                                    3300U                  /* VDD的值，单位是mv */  
   , W9 O5 t8 O7 a2 e! a
5. 70  /*  滴答定时器初始中断优先级 */
   
6. 71  #define  TICK_INT_PRIORITY   ((uint32_t)(1U<<4U) - 1U)                        
   
7. 72  
   
8. 73  #define  USE_RTOS                      0U
   / G# g6 q. {  {' n7 X. i# P& r6 I1 D
9. 74  #define  PREFETCH_ENABLE              0U
   
10. 75  #define  INSTRUCTION_CACHE_ENABLE   0U
    
11. 76  #define  DATA_CACHE_ENABLE            0U
    : ~7 p. q8 a# p
12. 77  /*
    * x) \* Z  W) E
13. 78  * 模块库文件引用
    7 P% B* j" @1 C! w1 o) B6 P
14. 79  */
    - \$ u9 U7 o6 L9 z+ `. q
15. 80  #ifdef HAL_RCC_MODULE_ENABLED
    ) i/ f( C  D3 @9 c$ k+ M/ G' j
16. 81   #include "stm32mp1xx_hal_rcc.h"
    8 I! u  U- c) W: Y
17. 82  #endif /* HAL_RCC_MODULE_ENABLED */
    0 f. o3 H( f  b
18. 83  ......
    5 _+ a6 S) ^( q7 c% y
19. 84  #ifdef HAL_WWDG_MODULE_ENABLED
    ) l* J8 R3 W3 D& }; E
20. 85   #include "stm32mp1xx_hal_wwdg.h"
    
21. 86  #endif /* HAL_WWDG_MODULE_ENABLED */
    4 L% s+ z- n, B/ g
22. 87  /*
    
23. 88  * 断言配置
    
24. 89  */
    
25. 90  #ifdef  USE_FULL_ASSERT
    
26. 91    #define assert_param(expr) ((expr) ? (void)0U : \                                                                                                 assert_failed((uint8_t *)__FILE__, __LINE__))
    9 m+ n/ i, Q  y2 C
27. 92    void assert_failed(uint8_t* file, uint32_t line);
    # G* |. f  L2 _+ V' j# _4 Q" P1 h
28. 93  #else
    
29. 94    #define assert_param(expr) ((void)0U)
    
30. 95  #endif /* USE_FULL_ASSERT */   
    ' |5 Z) o# ^$ x% D9 K
31. 96      
    
32. 97  #ifdef __cplusplus
    
33. 98  }
    5 l: j/ K9 g  E# l2 _  f& s; J2 |
34. 99  #endif
    
35. 100
    2 c: {' r2 C" R( h! m" S
36. 101 #endif /* STM32MP1xx_HAL_CONF_H */

复制代码

2 u6 M+ Y/ d- v3 p, X6 @第69行表示VDD值3.3V；
第71行，表示Systick（滴答定时器）的中断优先级(默认最低为15)，((uint32_t)(1U<<4U) - 1U)为0X0F（十进制的值为15）。这里插入一些内容，Systick属于M4内核外设，在前面的core_cm4.h文件中有定义。内核外设和其它片上外设不一样，它们的中断优先级有所差别，内核外设的中断优先级等级为0~15，数值越低，中断优先级越高。片上外设也有自己的中断优先等级，数值越低等级越高。
以上是stm32mp1xx_hal_conf_template.h文件中的配置，如果用STM32CubeMX生成的工程，此值为0，也就是说STM32CubeMX默认配置Systick为最高优先级0（数值越低优先级越高）。

- Q$ ^" ^9 i5 Q& M  A( O
+ e+ u' }" x) f7 v) q: G$ b6 g) o+ a
, a  p! d2 h* E4 L- L3 r图7.4.1. 1 STM32CubeMX生成的代码
6 {, u$ |/ R' Y/ Y; O% m' \不因为Systick是内核外设，中断优先级就比片上外设的外部中断优先级高，所以，如果工程里有用到Systick和其它的中断，例如工程中某个中断A调用了HAL_Delay函数，而HAL_Delay函数是通过Systick来实现计时的，如果中断A优先级比Systick高，就会导致A中断优先执行，而Systick中断服务函数一直未能执行，就会导致程序卡死的情况，所以应该设置Systick的中断优先级比A中断要高，可以在第71行处设置（注意范围，内核外设的中断优先级等级是0~15），如果是STM32CubeIDE，可以直接在STM32CubeMX上采用图形界面来配置：



2 S1 `! H+ g0 t- X; m图7.4.1. 2 STM32CubeMX插件上配置中断优先级
% d+ m. {8 O, E" [如上图，在之前的第一个工程实验中配置，Time base:System tick timer就是Systick的中断选项，勾选此项以后使能中断，然后再将Systick的中断的Preemption Priority（抢占优先）设置为1，修改好后按下“Ctrl+S”保存工程，在生成工程的stm32mp1xx_hal_conf.h文件中TICK_INT_PRIORITY值已经变为1。


3 I8 t/ H6 B; c6 a" J$ g. X
$ j+ r/ t; |* a; P/ Z9 @  m2 m图7.4.1. 3中断优先级变了
4 k8 X4 `4 r- p* e. M关于Systick我们后面有专门的章节做讲解。
第73行，表示是否使用RTOS操作系统，目前HAL库不支持RTOS，所以这里默认配置为0。
) L3 l; y7 f! v2 ?* i) q( m7 S第74行到第75行，表示分别配置Flash预读取使能、指令缓存使能和数据缓存使能。M4内核没有可用的Flash，这里配置为0。
第80到第85行，和最前面第10行到第15行介绍的相关，一旦使能了某个模块，就要加载对应的模块头文件。
. f% }" l7 }- ]4 ^; g第90行到95行，表示断言。
断言，就是一种代码调试技术，可以在调试阶段，帮助程序员选择满足规定范围的参数。比如某个参数只能选0或1两种，如果程序员写了3，那么在运行程序的时候就会给出报错提示。工程代码中加入了断言以后，虽然降低了程序的运行效率，但是方便了代码调试。一般程序在调试阶段采用Dubug版本，等项目开发完成以后，会给用户提供Release版本，Release版本的代码经过了各种优化，也去掉了所有的断言assert_param检验，最终的代码大小和运行速度都是最优的。
6 S) r# _$ x2 F1 U( c: H! A第91行：
#define assert_param(expr) ((expr) ? (void)0U :assert_failed((uint8_t \ *)FILE, LINE))
包含了3目运算符，表示如果expr大于0，则assert_param(expr)为0，如果expr小于或等于0，则assert_param(expr)为函数assert_failed((uint8_t )FILE, LINE)，其中__FILE__、__LINE__这两个是宏定义，表示当前所在的文件名和行号, 用来指示出错的行数和文件。
第91行，表示声明一个函数void assert_failed(uint8_t file, uint32_t line)，函数的实体在STM32CubeIDE生成的工程的main.c函数有定义，或者在官方的模板文件main.c中也可以找到，如下是之前第一个工程实验的main.c函数，可以看到有定义assert_failed函数，函数的参数file表示发生错误的文件名，line表示发生错误的行号。
" c# f! _# v4 H& I
' U$ f8 J  \4 ]2 K
7 e- C( s" l9 y: P& S  o: w
( W' v# p+ t/ Z  g' S图7.4.1. 4断言相关函数
上图虽然main.c函数中有断言的代码，但是还没有开启断言，所以看到#ifdef USE_FULL_ASSERT和#endif /* USE_FULL_ASSERT */之间的代码背景颜色呈现灰暗色。
0 X" j# U2 j5 h! E$ w. G6 h, o第94行，#define assert_param(expr) ((void)0U)中((void)0U)表示不执行任何操作。
' z: ?. h( b. Z: x0 e0 y默认情况下宏USE_FULL_ASSERT是没有定义的，也就是没有开启断言功能，如果有定义，我们就可以在代码中使用断言assert_param来检验程序中的参数是否正确了。我们打开第一个工程，在STM32CubeMX插件的Project Manager配置界面中选中Enable Full Assert开启断言，此操作方法我们在前面的4.2.5的第1小节有讲解，如图：



图7.4.1. 5在CubeMX插件上开启断言
8 |) e/ W' @1 s2 B选中以后按下“Ctrl+S”保存并重新生成工程代码，系统会自动开启断言功能。
+ ?9 B, I' X6 W1 E或者可以在M4工程的Properties中添加USE_FULL_ASSERT宏定义开启断言：

' L/ l  ^0 s+ x4 G  @

4 A6 L+ d  A# \8 G  p: D. r图7.4.1. 6通过定义宏开启断言
启用断言以后，main.c函数的断言部分的代码背景颜色不再是灰暗的颜色。可以在assert_failed函数内部添加以下代码，使错误的文件名和对应的行号可以通过串口打印出来（如果要用串口打印，工程中必须先配置好串口的功能才可以打印信息）。
printf(“Wrong parameters value: file %s on line %ld\r\n”, file, line);
3 D* m; x9 |8 C% ~
0 E  d3 G5 w6 e0 N

: `! R' ^! W: k图7.4.1. 7添加判断函数
下面我们分析HAL库中另一个重要的文件：stm32mp1xx_hal.c文件。
7.4.2 stm32mp1xx_hal.c文件
5 N5 ~! @- [. n7 a  H3 nstm32mp1xx_hal.c文件对应的头文件是Inc下的stm32mp1xx_hal.h文件。
stm32mp1xx_hal.c文件的内容比较多，它包括HAL库的初始化、系统滴答、基准电压配置、IO补偿、低功耗、EXTI配置等，下面我们分几个小节对该文件进行介绍。
% s& o' e. m( {2 R
; x( k; G4 t* P% Q) V1 r5 rHAL_Init函数
HAL_Init函数主要用于初始化HAL库，该函数在程序中必须优先调用，在生成的工程中，main函数优先调用了HAL_Init 函数。

1. 1   HAL_StatusTypeDef HAL_Init(void)
   . N7 R2 l! f4 _5 u
2. 2   {
   
3. 3     /* 设置中断优先级分组为4 */
   " H; V- w' y' \' |9 i" a
4. 4   #if defined (CORE_CM4)
   
5. 5     HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
   " Z- J. G) ^) X" O$ G5 ^+ Z8 r
6. 6   #endif
   
7. 7
   2 i' x0 K/ ~; A  {  X% S' C3 a) F
8. 8     /* 更新SystemCoreClock全局变量 */
   
9. 9     SystemCoreClock = HAL_RCC_GetSystemCoreClockFreq();
   
10. 10
    : R7 U  T5 z: k
11. 11    /* 使用滴答定时器作为时钟基准，配置1ms滴答（重置后默认的时钟源为HSI）*/
    
12. 12    if(HAL_InitTick(TICK_INT_PRIORITY) != HAL_OK)
    
13. 13    {
    
14. 14      return HAL_ERROR;
    ) L" l; y9 J5 d& m; K
15. 15    }
    + k$ {6 n/ x9 L6 L% r) r
16. 16
    / z) k2 b5 z; O) Q. S; t8 C9 b* f
17. 17    /* 初始化底层硬件 */
    
18. 18    HAL_MspInit();
    
19. 19
    
20. 20    /*返回 HAL_OK */
    ! s$ c3 N/ V( p- c; o& u  @, Z
21. 21    return HAL_OK;
    
22. 22  }

复制代码

- A- a- o, e1 o6 ~+ U+ W2 cHAL_Init 函数主要实现如下功能：
（1）默认设置NVIC优先级分组为4。可以在IDE上通过配置来改变此优先级，后面的实验章节会详细介绍这部分。
' ?9 m9 ~; P8 f! ]3 |+ t（2）配置SysTick（滴答定时器）每1ms产生一个中断。
（3）系统复位以后，在跳到主程序main之前先执行startup_stm32mp1xx.s启动文件，启动文件显示调用了SystemInit函数，然后才跳到main函数，SystemInit函数主要是初始化FPU设置、配置SRAM中的向量表和禁用所有中断和事件，并没有初始化RCC。所以，在进入main函数以后，系统还是默认使用内部高速时钟源HSI在跑程序，HSI的频率默认是64MHz。直到调用系统时钟配置函数以后，时钟才会发生变化。
（4）调用HAL_MspInit函数初始化底层硬件，HAL_MspInit函数在stm32mp1xx_hal.c文件里面做了弱定义：
* u3 {( U# O* r( T$ b' z  t__weak void HAL_MspInit(void)
. z3 S  B- s/ e0 @% b0 N( r; K{
/* 注意:这个函数不应该修改，当需要回调时，HAL_MspInit可以在用户文件中实现* /
}
HAL_MspInit函数前有一个weak，表示对HAL_MspInit进行弱（weak）定义。弱就是表示此函数可以进行重写（重新定义），如果用户在其它地方重新定义一个同名函数，最终编译器编译的时候，就会选择用户定义的函数，如果用户没有重新定义这个函数（或者函数名字写错了），那么编译器就会默认执行弱定义的函数，并且编译器不会报错。是弱定义的函数都可以进行重写。关于弱定义的函数怎么使用，我们后面会有专门的例程进行讲解。
我们用STM32CubeIDE创建的工程会生成stm32mp1xx_hal_msp.c文件，此文件中会重会新定义HAL_MspInit函数，此函数一般会打开AHB3外设的时钟，初始化中断优先级等，没有使用HAL_MspInit函数去初始化全部的底层硬件。而系统时钟初始化或者外设时钟初始化等操作其实是在main.c文件以及外设驱动文件中完成的。
HAL_Init 函数的返回值是HAL_OK，表示成功。返回值是枚举常量，在stm32mp1xx_hal_def.h文件中有定义：

1. typedef enum
   0 z) V0 s7 V' w* O% H
2. {
   ' N; d+ X  I! z; p5 G
3.   HAL_OK       = 0x00U,
   
4.   HAL_ERROR    = 0x01U,
   9 d7 k6 D) i2 Z; f
5.   HAL_BUSY     = 0x02U,
   , T; e" r# Y& y& ?: z
6.   HAL_TIMEOUT  = 0x03U
   
7. } HAL_StatusTypeDef;

复制代码

( D$ |* o% W% k* g0 X, C3 w, FHAL_DeInit函数
HAL_DeInit函数主要用于复位HAL库的，不过函数中没有实现什么功能，如果有需要，可以在里边添加相应的代码。
- b5 x/ U" m  j$ w$ z

1. 1   HAL_StatusTypeDef HAL_DeInit(void)
   
2. 2   {
   % H# v7 [: {" C. s3 l  e# w, B5 Z
3. 3     /*重置所有外设*/
   8 L* s4 u9 _& c- T2 X
4. 4     
   ! `9 K* n: b3 F
5. 5     /*对底层硬件进行初始化*/
   ( i% d/ R. X4 e$ f1 Z4 y  e2 r
6. 6     HAL_MspDeInit();
   
7. 7
   ; N' t& x/ F0 M/ v6 }1 u8 q# F! r
8. 8     /*返回功能状态*/
   
9. 9     return HAL_OK;
   
10. 10  }

复制代码

6 q; P: k- h& h, e, \: ^9 AHAL_MspDeInit函数主要是对底层硬件初始化进行复位，和HAL_Init里面调用的HAL_MspInit函数是一对，它在stm32mp1xx_hal.c文件中有定义，只不过是弱定义，如果用户需要使用该函数，可以在用户文件中进行重写。

__weak void HAL_MspInit(void)
2 b/ p( J) I. t" M9 d- D{
/* 注意:这个函数不应该修改，当需要回调时，HAL_MspInit可以在用户文件中实现* /
8 B" l7 v5 u& X/ @}
$ A- `: v+ Q8 y' b* V1 r3. HAL_InitTick函数
HAL_InitTick函数主要用于初始化SysTick（系统滴答定时器）的时钟基准为1ms。函数前有weak弱定义，表示此函数可以被用户重新定义。STM32MP1有A7内核和M4内核，第4行到第48行是针对A7内核的代码，第51行到第73行是针对M4内核的代码。

1. 1   __weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
   " e8 L/ j% ]* ~2 M) z% F
2. 2   {
   : |, e  b, {' G2 t6 z7 l4 K! @
3. 3     /* 配置SysTick在1ms的时间产生一次中断 */
   , `* e5 l/ U5 {; j9 o+ |
4. 4   #if defined (CORE_CA7)
   
5. 5   #if defined(USE_ST_CASIS)
   
6. 6     HAL_SYSTICK_Config(SystemCoreClock/1000);
   % {) W7 p$ }8 f1 u
7. 7   #elif defined (USE_PL1_SecurePhysicalTimer_IRQ)
   
8. 8     /* 停止计时器 */
   8 G" @- \& |; g) v+ ~* I/ [# e; e* `
9. 9     PL1_SetControl(0x0);
   0 B; C, o( M$ Q
10. 10
    
11. 11    PL1_SetCounterFrequency(HSI_VALUE);
    6 ?* }4 a# i( v5 `
12. 12
    
13. 13    /* 初始化计数器 */
    ! {7 v5 G$ D" \+ w
14. 14    PL1_SetLoadValue(HSI_VALUE/1000);
    
15. 15
    6 A- _3 s9 _& Z
16. 16    /* 禁用相应的中断 */
    
17. 17    IRQ_Disable(SecurePhysicalTimer_IRQn);
    
18. 18    IRQ_ClearPending(SecurePhysicalTimer_IRQn);
    
19. 19
    ; P' h: [, o  D, Y
20. 20    /* 将定时器优先级设置为最低 (在MP1的A7的GIC中断中，只有7:3位可以实现) */
    
21. 21    /* TickPriority基于16级优先级(来自MCUs)，因此在7:4中设置，且位3=0 */
    
22. 22    if (TickPriority < (1UL << 4))
    $ Q& m3 i0 D4 W' @% v8 R9 ]6 c" A
23. 23    {
    2 i9 d5 U6 H- Q0 Z7 v. O: X+ e
24. 24      IRQ_SetPriority(SecurePhysicalTimer_IRQn, TickPriority << 4);
    
25. 25      uwTickPrio = TickPriority;
    # Y+ `6 e: ]& Y1 _( H
26. 26    }
    % y/ Z& N5 P3 S
27. 27    else
    * n$ O! `% ^0 d6 @- E0 A9 r- e7 ^
28. 28    {
    
29. 29      return HAL_ERROR;
    ! \1 [% L, _4 x2 h* p0 ?
30. 30    }
    : R. Q# a% g5 k# c2 a! ~
31. 31
    
32. 32    /* 设置边沿触发的中断请求 */
    $ V. C4 P& H5 W# i4 A, C
33. 33    IRQ_SetMode(SecurePhysicalTimer_IRQn, IRQ_MODE_TRIG_EDGE);
    3 i/ X" m8 \( [' w& G; v
34. 34
    2 c, x/ Q; A5 v) ?! W4 [( r! H( _
35. 35    /* 启用相应的中断 */
    7 L' c  }+ b' P2 Q# r% v; T$ b
36. 36    IRQ_Enable(SecurePhysicalTimer_IRQn);
    
37. 37
    
38. 38    /* 启动定时器 */
    
39. 39    PL1_SetControl(0x1);
    ( W" M: l7 F; t
40. 40  #else
    % B+ T# _2 P+ l2 V
41. 41    /* 设置计数器频率 */
    
42. 42    PL1_SetCounterFrequency(HSI_VALUE);
    $ e6 D+ w+ U, x
43. 43   // __set_CNTFRQ(HSI_VALUE);
    ' P* u+ H# {" R% P
44. 44    /* 初始化计数器 */
    
45. 45    PL1_SetLoadValue(0x1);
    9 v9 E" ~* u. E8 g' A" N& n
46. 46   // __set_CNTP_TVAL(0x1);
    , f, U/ D5 M+ g# O1 p
47. 47  #endif
    
48. 48  #endif /* CORE_CA7 */
    + L8 a% L. F$ j- w3 E
49. 49
    
50. 50
    
51. 51  #if defined (CORE_CM4)
    
52. 52  /* uwTickFreq是个枚举类型，如果检测到uwTickFreq为零，则返回1 */
    
53. 53    if ((uint32_t)uwTickFreq == 0U)
    ( r# b% [* U( R9 |) h) K6 Y8 X! y
54. 54    {
      Y8 {. g6 Q! `! a6 Y; c! h
55. 55      return HAL_ERROR;
    
56. 56    }
    
57. 57
    # d9 E" u# w/ H4 v
58. 58    /* 将SysTick配置为在1ms的时间产生一次中断 */
    " F3 [7 D/ x5 Q) b
59. 59    if (HAL_SYSTICK_Config(SystemCoreClock /(1000U / uwTickFreq)) > 0U)
    $ `2 l, E# p) W
60. 60    {
    
61. 61      return HAL_ERROR;
    & _* |/ K& z1 X6 ^
62. 62    }
    9 c/ U/ U' J7 m: P' u) c
63. 63    /* 配置 SysTick的中断优先级 */
    
64. 64    if (TickPriority < (1UL << __NVIC_PRIO_BITS))
    
65. 65    {
    " @9 p% m) p6 `$ Z+ e$ q) I
66. 66      HAL_NVIC_SetPriority(SysTick_IRQn, TickPriority, 0U);
    
67. 67      uwTickPrio = TickPriority;
    8 D5 c9 T0 H9 i. f% j' j6 o4 c
68. 68    }
    
69. 69    else
    
70. 70    {
    
71. 71      return HAL_ERROR;
    
72. 72    }
    
73. 73  #endif /* CORE_CM4 */
    
74. 74
    " d5 w% ]& i& c) Q/ @5 P
75. 75    /* 返回函数状态 */
    / h! b7 n/ h* `" E4 h2 }) o
76. 76    return HAL_OK;
    * Z* c( B: t) Q' f9 v5 s
77. 77  }

复制代码

本教程主要是介绍M4相关的实验，对于A7部分我们这里只是简单介绍。
9 N& A0 K5 f3 N2 B. v$ P第4和第5行是条件编译选项，如果同时定义CORE_CA7和USE_ST_CASIS宏，则调用函数HAL_SYSTICK_Config(SystemCoreClock/1000)。其中SystemCoreClock在system_stm32mp1xx.c文件中有定义：
, S0 K4 K0 I: U) f4 q* h
  N$ h2 o& f8 P. ]: s9 |uint32_t SystemCoreClock = HSI_VALUE;
HSI_VALUE 在文件stm32mp1xx_hal_conf.h文件中有定义：
; z& w+ u) ]' R  Z! P& ]$ y
- O8 K+ D# z7 g7 D

1. #if !defined  (HSI_VALUE)
   
2.     #define HSI_VALUE            64000000U  /* 内部高速振荡器HSI的值，64MHz */
   
3.   #endif
   , B% S6 J4 ^% g. Z7 D0 f
4.         HSI_VALUE为64MHz，则SystemCoreClock/1000等于64000Hz。
     ~  ^# ~# l( L* H! G
5.         HAL_SYSTICK_Config函数在stm32mp1xx_hal_cortex.c文件中有定义：
   
6. uint32_t HAL_SYSTICK_Config(uint32_t TicksNumb)
   * @4 W- B2 o/ O. O
7. {
   7 B8 |1 r6 n8 D1 U4 `
8.    return SysTick_Config(TicksNumb);
   
9. }
   
10.         SysTick_Config函数在core_cm4.h文件中定义（SysTick属于内核的外设）：
    - a/ k0 x' C% N+ T3 u
11. #if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
    
12. 
    
13. __STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
      K4 e4 m9 o" e) D: o
14. {
    
15.   if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
    
16.   {
    ; _* `/ `- z! e% A, T0 `
17.     return (1UL);  /* 函数非正常终止，退出，递减计数器不会再重载 */                                               
    ; P6 S+ o% g# ?/ k. E" M
18.   }
    ' z; y, F# z  F" M
19. 
    : r+ x2 f& ]7 [# j$ P* b8 U
20.   SysTick->LOAD  = (uint32_t)(ticks - 1UL);         /* 重新加载寄存器 */  
    
21. /* 设置Systick中断的优先级 */
    ' I4 s" O6 b! J6 K+ J7 ~; e
22.   NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL);
    
23.   SysTick->VAL   = 0UL;                                                    /* 加载SysTick计数器值 */   
    ) }1 x- u7 c& Z' O3 n
24. /*启用SysTick中断和SysTick定时器 */  
    7 ]% ^; k  h3 ]: ?
25.   SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
      F% |9 Y. F; R
26.                            SysTick_CTRL_TICKINT_Msk   |
    
27.                            SysTick_CTRL_ENABLE_Msk;                        
    3 A( q5 A0 {( k, C$ n
28.   return (0UL);                                                                           /* 函数正常终止 */   
    4 p3 n) n0 H& e6 g" w
29. }

复制代码

我们简单分析此段代码，SysTick定时器是一个24位向下递减计数器，启动后，LOAD寄存器的值赋给VAL 寄存器，VAL寄存器递减，当递减到0的时候，会产生一次中断，然后再从LOAD寄存器取值，然后再从所得值开始递减，递减到0的时候又产生一次中断，如此反复，从而实现计时。LOAD寄存器的值是从SysTick_Config函数的参数ticks获取的，根据上述分析，ticks值默认为64000，复位后，系统默认工作采用64MHz的内部高速时钟源HSI来工作，可以计算SysTick产生一次中断的时间为：(1/64MHz)*64000=1ms。关于SysTick定时器我们后面会有专门的章节进行讲解。
第7行到第39行，如果A7内核使用Secure PL1 physical timer来计时的话，则先停止A7的计时、初始化计数器、禁用相应中断、设置中断优先级和触发条件、启动中断、启动定时器等操作。
我们重点看M4部分。
第51行，如果定义CORE_CM4宏，则初始化SysTick配置。
( S2 a6 b% Z! R/ y5 O2 R; C第53行到第56行，主要是判断参数uwTickFreq是否为零。
9 _- ~' D+ t# \+ p2 ystm32mp1xx_hal.c文件中有定义：
1 L5 O. O! P) w
2 F, B& p1 k4 B* \9 O! s+ [: S- r

1. HAL_TickFreqTypeDef uwTickFreq = HAL_TICK_FREQ_DEFAULT;
   
2.         而stm32mp1xx_hal.h文件中定义：
   + h0 }; X! A% \* ~7 S% v1 M
3. typedef enum
   & d. H; {; J; w+ q
4. {
   5 n5 h& s6 \" A+ ^3 R% O. j; s5 o. [
5.   HAL_TICK_FREQ_10HZ         = 100U,
   2 [3 Y; J1 J. c0 ~
6.   HAL_TICK_FREQ_100HZ        = 10U,
   ! l! z; q" l3 f
7.   HAL_TICK_FREQ_1KHZ         = 1U,
   
8.   HAL_TICK_FREQ_DEFAULT      = HAL_TICK_FREQ_1KHZ
   
9. } HAL_TickFreqTypeDef;

复制代码

所以，第59行到第62中的uwTickFreq值为1。根据前面的分析，SystemCoreClock的值为64000 000，所以HAL_SYSTICK_Config函数的参数是64000，HAL_SYSTICK_Config(64000))按照前面计算方法就是1ms，表示配置SysTick每隔1ms产生一次中断。至此，不管是A7内核还是M4内核，默认情况下，SysTick中断配置的都是1ms。
第64到68行，形参TickPriority用于设置滴答定时器优先级。
& q( b& S5 k& t/ Y" T
% k, O  k5 o  \$ B. t" P% z% c8 k2 GHAL_InitTick函数可以通过HAL_Init()或者HAL_RCC_ClockConfig()重置时钟。在默认情况下，滴答定时器是时间基准的来源，这里再次强调，如果其他中断服务函数调用了HAL_Delay()，要注意，滴答定时器中断必须具有比调用了HAL_Delay()函数的其他中断服务函数的优先级高(数值较低)，否则会导致滴答定时器中断服务函数一直得不到执行，从而卡死在这里。
9 a! G4 o/ J. `6 i& J1 O6 D, k4. 滴答定时器相关的函数
$ u$ }0 {) P' H4 y( x) q（1）HAL_IncTick函数
0 Y$ u! p( H( l% ]" K__weak void HAL_IncTick(void)
{
uwTick += (uint32_t)uwTickFreq;
}
函数前面有weak 定义，表示用户可以在别的文件中进行重定义。
3 g( x, ~8 @( mHAL_IncTick函数在滴答定时器时钟中断服务函数 SysTick_Handler中被调用，滴答定时器每隔1ms中断一次，所以此函数每1ms让全局变量uwTick计数值加1 。滴答定时器时钟中断服务函数在ST官方的工程模板中，文件名是stm32mp1xx_it.c。

" R2 [% k( p6 z7 r2 G; R, k

图7.4.2. 1 ST官方模板的中断函数文件
1 r3 H( t! g  Y4 c# |0 `或者在前面第一个工程实验中找到，SysTick_Handler函数就是处理SysTick定时器中断服务函数。


9 o% ?5 d3 Q7 \9 _; J' q1 q' m
图7.4.2. 2CubeIDE中的中断服务函数
（2）HAL_GetTick函数
. {" Q0 ?1 ]: G

1. /* 获取全局变量uwTick当前计算值 */
   
2. 
   1 f" a; w+ p) q* z6 E9 m
3. __weak uint32_t HAL_GetTick(void)
   . q& g; }$ A% ^8 Z1 |  x. q- b
4. {
   
5. #if defined (CORE_CA7)
   
6. #if defined (USE_ST_CASIS)
   8 J0 P4 a# k9 ~" |, Q( |& M! t
7.   return ( Gen_Timer_Get_PhysicalCount() / (HSI_VALUE/1000));
   
8. #elif defined (USE_PL1_SecurePhysicalTimer_IRQ)
   
9.   /* tick在SecurePhysicalTimer_IRQ处理程序中递增 */
   5 u$ ~3 L* \4 _& P  P' D1 \
10.   return uwTick;
    8 d0 Y8 X) _5 @( O
11. #else
    + D! p4 [0 `3 D" f& R! X
12.   /* 直接从64位CA7寄存器得到的tick值 */
    
13.   return ( PL1_GetCurrentPhysicalValue() / (HSI_VALUE/1000));
    
14. #endif
    
15. #endif /* CORE_CA7 */
    
16. 
    
17. 
    
18. #if defined (CORE_CM4)
      {6 Y3 F& E1 `
19.   /* tick在systick处理程序中递增 */
    
20.   return uwTick;
    
21. #endif /* CORE_CM4 */
    ! E/ |# E2 W2 ^: d/ D6 {
22. }

复制代码

# O/ U0 W" r$ s  \/ |! f2 ?. r函数前面有weak 定义，表示用户可以在别的文件中进行重定义。
* k* v5 z3 \* j3 n( WHAL_GetTick函数用于获取32位的全局变量 uwTick 当前的值，这个值每1ms加1，那么HAL_GetTick() 应该返回的就是自启动以来经过的毫秒数。uwTick可以以毫秒为单位提供时间，那么可以用它来计时，事实上很多HAL函数都依赖它来计时的，例如我们之前使用的HAL_Delay函数。
2 K7 z) E: q( J0 E

1. __weak void HAL_Delay(uint32_t Delay)
   
2. {
   & |6 M) t0 J* g2 v8 O
3.   uint32_t tickstart = HAL_GetTick();
   $ o& S+ V! i, }* b! L6 S8 F! [
4.   uint32_t wait = Delay;
   
5. 
   
6.   /* Add a freq to guarantee minimum wait */
   - l. I: T7 r$ q2 K- f. ~9 F7 n
7.   if (wait < HAL_MAX_DELAY)
   
8.   {
   
9.     wait += (uint32_t)(uwTickFreq);
   
10.   }
      V" d, ~5 H% E5 I, c* E) b
11. 
    & Y+ R9 L7 |5 n/ o- w; G
12.   while ((HAL_GetTick() - tickstart) < wait)
    2 U! L! t& ~& s& x' Z0 C+ s
13.   {
    
14.   }
    / a) X3 e1 v0 Q  {  G' W" u7 J
15. }

复制代码

) R: r6 a4 k- JSysTick中断服务函数 SysTick_Handler 通过调用 HAL_IncTick 实现 uwTick的值每隔 1ms增加 1。HAL_GetTick返回uwTick的值，在进入HAL_Delay函数时，先记录当前 uwTick 的值，并标记为tickstart，然后不断在循环中读取uwTick 的当前值，再与记录的tickstart进行减运算，当(HAL_GetTick() - tickstart)的差值等于或大于wait的时候，跳出空循环，此时(HAL_GetTick() - tickstart)得出的差值就是延时的毫秒数。

（3）HAL_GetTickPrio函数

1. 
   : F4 c- }4 W/ S6 r) P. f% ]. B
2.         #if defined (CORE_CM4)
   " c  |# e3 D/ g: L5 A
3. uint32_t HAL_GetTickPrio(void)
   
4. {
   
5.   return uwTickPrio;
   3 O% g( U. e) l1 r6 v  P! Q8 `' y
6. }

复制代码

此函数就是获取滴答时钟优先级，可以在图形界面上配置好SysTick的优先级，然后在主函数中通过一个静态变量获取此优先级，例如下图，先配置SysTick的Preemption Priority（抢占优先）为2，保存配置重新生成工程：
4 `5 b9 C; S* _4 Z1 m0 j( D$ O# X
5 G/ i+ C; M$ C/ X

图7.4.2. 3配置SysTick的优先级
  \, t/ a3 m) X: D- z然后生成的工程的主函数中添加如下代码，表示把滴答时钟优先级赋值给static变量priority：
static uint32_t priority = 0;
- M- V( m; e* x* b9 bpriority = HAL_GetTickPrio();
保存工程，编译无报错，进入Debug配置界面，此时箭头指在HAL_Init();的地方，表示从此处开始运行，此时，priority变量显示值为0。
6 B/ Z, e! q2 k9 [2 ^


# U0 y; {6 O# H8 b" i图7.4.2. 4观察变量
我们在while处添加断点，然后点击Step Over单步调试，当箭头经过whlie以后，可以看到priority变量显示值为2，此值正是我们之前设置的优先级。
6 p  [% E% V2 s' `6 |4 T
# ?! L3 R- v7 e4 W+ c) W

图7.4.2. 5单步调试
# H8 x, `& o* Q4 ~& D% S" zHAL库中有很多的获取某个变量的函数，例如获取系统时钟频率的函数HAL_RCC_GetSystemCoreClockFreq，我们前面介绍的HAL_GetTick函数，获取定时器的计时数值函数__HAL_TIM_GET_COUNTER，还有获取串口中断标志位状态函数USART_GetFlagStatus，获取当前 RTC 时间HAL_RTC_GetTime等众多函数，我们可以利用这些函数获取我们想要的信息。
（4）HAL_SetTickFreq和HAL_GetTickFreq函数
HAL_SetTickFreq 函数用于重新配置滴答定时器中断中断频率，HAL_GetTickFreq函数用于获取滴答定时器中断频率。
( v. @% J) \( G  j& |# h

1. 1   /* 设置滴答定时器中断频率 */
   , V0 k7 T4 |9 g& B$ x2 `$ S
2. 2   HAL_StatusTypeDef HAL_SetTickFreq(HAL_TickFreqTypeDef Freq)
   2 m( c3 d9 d  j( ?7 z! T/ o; J
3. 3   {
   
4. 4     HAL_StatusTypeDef status  = HAL_OK;
   , f3 e; E; R& y1 o( M
5. 5     HAL_TickFreqTypeDef prevTickFreq;
   , r* \2 d* e/ m  R1 b$ E( [2 r
6. 6     assert_param(IS_TICKFREQ(Freq));
     h! a' G. X0 b3 {
7. 7
   
8. 8     if (uwTickFreq != Freq)
   " a+ V  G1 W/ Q  v/ k- I
9. 9     {
   
10. 10      /* 备份备份滴答定时器中断频率频率 */
    * ]% |/ q) ~' S  c' q: f- E
11. 11      prevTickFreq = uwTickFreq;
    . r- j5 e$ i( I- e
12. 12
    ' q4 R) e, Z4 T* _5 _2 \
13. 13      /* 更新被HAL_InitTick()使用的全局变量uwTickFreq */
    
14. 14      uwTickFreq = Freq;
    0 e0 O; f/ K2 }# \8 o
15. 15
    1 G" y6 m/ @* n: r' T5 |
16. 16      /* 应用新的滴答定时器中断频率  */
    6 A) h; p8 ^7 U2 L. K
17. 17      status = HAL_InitTick(uwTickPrio);
    , L% Q! |/ T$ Z
18. 18
    . y) L# f; G, v: w; c
19. 19      if (status != HAL_OK)
    
20. 20      {
    
21. 21        /* 恢复以前的滴答定时器中断频率 */
    - M* q, n; @1 Q& d. V# @( [
22. 22        uwTickFreq = prevTickFreq;
    & z* I; o# S; g- g5 B2 v" X
23. 23      }
    
24. 24    }
    & K. r" g1 U5 U/ D/ O& Z
25. 25
    . @4 x8 N6 r0 p9 q
26. 26    return status;
    ; w$ `* }! G" t3 p6 F4 a% J( Q
27. 27  }
    3 L1 {/ _9 S6 @/ u, g
28. 28  /* 获取滴答定时器中断频率 */
    
29. 29  HAL_TickFreqTypeDef HAL_GetTickFreq(void)
    
30. 30  {
    & l' Z# Y. ?8 a# B6 S# |
31. 31    return uwTickFreq;
    
32. 32  }

复制代码

7 F) G4 r0 o- ~- A: C' ?) ^6 B在前面的HAL_InitTick函数介绍中，uwTickFreq的值默认为1，滴答定时器中断频率默认为1KHz（中断周期是1ms），如果我们要更改滴答定时器中断频率，可以通过HAL_SetTickFreq 函数来实现。我们先分析该函数的实现过程。
5 L9 B* a: C8 s- b4 \: M参数Freq是枚举类型，可选值是100、10和1，它是我们要设置的滴答定时器中断频率。
4 Y9 @3 A3 T7 m. h4 F8 j7 r* a% d第5行，定义一个枚举类型变量prevTickFreq，表示频率，值可以是100、10和1。
第6行，使用断言assert_param检查我们设置的参数Freq是否有效（参数Freq可以是100或10或1）
) R) a: E; {# p) d$ l第8到第24行，比较设置的参数Freq的值是否等于默认为1的uwTickFreq，如果不等于1，先备份uwTickFreq的值到新定义的uwTickFreq变量中，然后再将Freq赋值给uwTickFreq，如果此时HAL_InitTick返回状态正常，频率修改成功，如果此时HAL_InitTick返回状态不正常，那么uwTickFreq的值将不变，此时不能进行修改频率。
+ g. j/ {! b6 @) Y7 e第29行到32行表示获取此时的uwTickFreq值，即获取滴答定时器中断频率。
& g( i3 b, E! S: J* o过程分析完了，是否如此？我们用前面单步调试的方法测试一下就知道。设置一个static局部变量freq，使用HAL_GetTickFreq函数获取此时滴答定时器中断频率的值，将此值赋值给freq：

static uint32_t freq = 0; /* 定义一个static局部变量 /
freq = HAL_GetTickFreq(); / 读取此时滴答定时器中断频率 */
保存并编译工程，然后单步调试，观察变量freq的变化，如下freq默认值为1：
. j5 E3 k4 b" Z; {: |) V
. d: k2 _: y( Z

* }0 y$ x  c8 Y* k- M. I' \$ ^. p图7.4.2. 6 uwTickFreq值默认为1
& i, A4 D& s9 _, T: i我们在添加如下语句：

, c+ g. [$ _2 d( O- v8 m

1. HAL_SetTickFreq(10);                        /* 设置滴答定时器中断频率为10KHz */
   
2. static uint32_t freq = 0;        /* 定义一个static局部变量 */
   & ^( v/ F& z4 {/ T9 F
3. freq = HAL_GetTickFreq();        /* 读取此时滴答定时器中断频率 */

复制代码

重新编译工程，此时freq的值变成了10，说明设置成功，证实了我们前面的分析。

# l: [( y/ S9 o  U
: C7 R0 L0 s1 G7 l4 z
5 Y+ d' L5 g, I* n; L2 l图7.4.2. 7成功修改uwTickFreq值
( Z+ t/ S. G- ^3 q; E0 c- ?* |/* 挂起滴答定时器中断，全局变量uwTick计数停止 */

1. __weak void HAL_SuspendTick(void)
   & g" x& G, {+ F
2. {
   
3. #if defined (CORE_CA7)
   # |, i% v* q- i+ ]! W4 V
4. #elif defined (CORE_CM4)
   . M' W% N' s; w7 l  K2 D) t
5.   /* 禁止滴答定时器中断 */
   ' y* P/ Y5 W8 R8 }3 J
6.   SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
   + A3 @6 c/ v8 l: n1 Z
7. #endif
     E9 B4 T* B9 i8 I& A$ W
8. }
   
9. /* 恢复滴答定时器中断，恢复全局变量uwTick计数 */
     s) u% l3 y5 V6 ?
10. __weak void HAL_ResumeTick(void)
    
11. {
    
12. #if defined (CORE_CA7)
    ! e! u. ]8 J" H5 s6 J( I7 L
13. #elif defined (CORE_CM4)
    6 {( j+ v: P& X7 q  s2 ^7 A
14.   /* 使能滴答定时器中断 */
    & U' `( I( Q' k- ?" b
15.   SysTick->CTRL  |= SysTick_CTRL_TICKINT_Msk;
    1 i8 O1 g. H  X: e
16. #endif
    
17. }

复制代码

, C* ~+ ]; F: C+ ~默认情况，SysTick计时器是时间基的来源，它以固定的时间间隔产生中断，一旦HAL_SuspendTick函数被调用时，SysTick中断将被禁用，因此Tick增量被暂停。函数被声明为弱函数，可以在其他函数中被覆盖时使用。
6 A* B# s' p( s* g# N: b3 V8 M7 C
HAL库版本相关的函数
相关函数声明如下，这些函数了解一下就好了，用得不多。

1. uint32_t HAL_GetHalVersion(void); /* 获取HAL库驱动程序版本 */
   
2. uint32_t HAL_GetREVID(void);       /* 获取设备修订标识符 */
   
3. uint32_t HAL_GetDEVID(void);       /* 获取设备标识符 */

复制代码

HAL库调试功能相关函数
这些是调试功能相关的函数，可以在不同模式下使能或者关闭调试器。将对应函数添加到代码中就支持DEBUG在各种模式下，比如，

1. HAL_EnableDBGStopMode，就可以在stop模式下进行调试。源码可在stm32mp1xx_hal.c文件中查看，函数声明如下：
   , k: ?/ N/ l, S; F! I2 X- o9 i+ D
2. void HAL_EnableDBGWakeUp(void)                        /* 启用调试模块(唤醒模式下) */
   
3. void HAL_DisableDBGWakeUp(void)                        /* 关闭调试模块(唤醒模式下) */
   # [# ~1 A  y7 ]/ ]1 ]5 l2 `, K1 T
4. void HAL_EnableDBGSleepMode(void)                /* 启用调试模块(休眠模式下) */
   & P- r/ I+ r' T0 \: V
5. void HAL_DisableDBGSleepMode(void)                /* 关闭调试模块(休眠模式下) */
   
6. void HAL_EnableDBGStopMode(void)                /* 启用调试模块(停止模式下) */
   
7. void HAL_DisableDBGStopMode(void)                /* 关闭调试模块(停止模式下) */
   
8. void HAL_EnableDBGStandbyMode(void)        /* 启用调试模块(待机模式下) */
   4 S) `; d$ r( G& z2 O7 }) b
9. void HAL_DisableDBGStandbyMode(void)        /* 关闭调试模块(待机模式下) */

复制代码

芯片内部电压基准相关函数
+ v5 q  T0 ^6 `$ m$ c源码可在stm32mp1xx_hal.c文件中查看，函数声明如下：

1. void HAL_SYSCFG_VREFBUF_VoltageScalingConfig(uint32_t VoltageScaling);
   
2. void HAL_SYSCFG_VREFBUF_HighImpedanceConfig(uint32_t Mode);
   
3. void HAL_SYSCFG_VREFBUF_TrimmingConfig(uint32_t TrimmingValue);
   $ C: ~* T7 }8 [: P. h
4. HAL_StatusTypeDef HAL_SYSCFG_EnableVREFBUF(void);
   5 y1 _# Q7 r* E; t  h' A
5. void HAL_SYSCFG_DisableVREFBUF(void);

复制代码

HAL_SYSCFG_VREFBUF_VoltageScalingConfig函数用于配置芯片内部电压基准大小，形参有四个值可以选择：
0 O/ h: {+ U% M1 g. h( |& [1）当形参为SYSCFG_VREFBUF_VOLTAGE_SCALE0时，
电压输出基准为2.048V，条件是VDDA >= 2.4V。
6 X, z8 I1 w. Z; B& p9 Y+ [  z( u2）当形参为SYSCFG_VREFBUF_VOLTAGE_SCALE1时，
' Y; q/ ^( i$ W( r电压输出基准为2.5V，条件是VDDA >= 2.8V。
3）当形参为SYSCFG_VREFBUF_VOLTAGE_SCALE2时，
电压输出基准为1.5V，条件是VDDA >= 1.8V。
. k: \9 U$ F$ C& v3 B4）当形参为SYSCFG_VREFBUF_VOLTAGE_SCALE3时，
电压输出基准为1.8V，条件是VDDA >= 2.1V。
HAL_SYSCFG_VREFBUF_HighImpedanceConfig函数用于配置芯片内部电压是否与VREF+引脚连接，即是否选择高阻抗模式，有两个形参选择：
- M& _: e) P( M" Z1）当形参为SYSCFG_VREFBUF_HIGH_IMPEDANCE_DISABLE，表示导通。
% F% f% k1 }" d2）当形参为SYSCFG_VREFBUF_HIGH_IMPEDANCE_ENABLE，表示高阻抗，即不导通。
HAL_SYSCFG_VREFBUF_TrimmingConfig函数用于调整校准内部电压基准。
2 b: a( W( n# o1 aHAL_SYSCFG_EnableVREFBUF函数用于使能内部电压基准参考。
HAL_SYSCFG_DisableVREFBUF函数用于禁止内部电压基准参考。
: Z1 p; t  j* x: J1 {4 t8. 以太网PHY接口选择函数
该函数用于以太网PHY接口的选择，可以是MII或RMII接口。
5 t) H3 l; ~1 U4 ]2 _. yvoid HAL_SYSCFG_ETHInterfaceSelect(uint32_t SYSCFG_ETHInterface)
) u( G+ l4 R. W9 z  W9. HAL_SYSCFG_AnalogSwitchConfig()函数
当PA0、PA1引脚复用为ADC的时候，还有一组对应的可选引脚ANA0、ANA1。该函数的作用就是用于模拟开关控制，用于切换这些可选的引脚。源码可在stm32mp1xx_hal.c文件中查看，函数声明如下：
, B, ^7 s$ w6 F+ Avoid HAL_SYSCFG_AnalogSwitchConfig(uint32_t SYSCFG_AnalogSwitch , uint32_t SYSCFG_SwitchState )
: J% ~( O0 f) {3 Q3 \参数SYSCFG_AnalogSwitch表示选择模拟开关，可以选：
5 i+ v! X( s, }SYSCFG_SWITCH_PA0：选择PA0模拟开关
# i0 M4 q+ H( v: mSYSCFG_SWITCH_PA1：选择PA1模拟开关
! G8 E# X( v! T. ~4 H, q  d! I* Q参数SYSCFG_SwitchState表示打开或关闭双垫之间的模拟开关，此参数可以是以下值之一或组合：
; a+ D$ C1 _& \0 [SYSCFG_SWITCH_PA0_OPEN
SYSCFG_SWITCH_PA0_CLOSE
; t; D$ e( c# l( b6 `% U. [9 fSYSCFG_SWITCH_PA1_OPEN
/ Z5 @8 x; q% {) Q  Q" QSYSCFG_SWITCH_PA1_CLOSE
* o. q4 N# y/ N" Q2 N% Q& S. O5 m
5 J, @8 D0 L- _7 g$ Y
$ {/ q% Q0 l6 Q- k! ^
( ^$ k8 K! W  U# \8 d图7.4.2. 8模拟开关控制
6 V8 ?8 t. K0 M$ g$ j该函数操作了SYSCFG_PMCR寄存器，可以查看参考手册第14.3.2节了解有关配置模拟开关的详细信息。
10. Booster的使能和禁止函数（用于ADC）
源码可在stm32mp1xx_hal.c文件中查看，函数声明如下：
: F# z% h0 r8 A) k0 R
8 }! f1 O/ V% W0 V

1. void HAL_SYSCFG_EnableBOOST(void)                /* 使能Booster */
   
2. void HAL_SYSCFG_DisableBOOST(void)                /* 禁止Booster */

复制代码

如果使能Booster，当供电电压低于2.7V时，能够减少模拟开关总的谐波失真。这样就使得模拟开关的性能和供电正常的情况时一样，能够正常工作。
; P8 R! G: X+ Z+ f6 r11. 启用或者禁止IO补偿函数
' v4 [: R. x. x2 _2 a4 ^源码可在stm32mp1xx_hal.c文件中查看，函数声明如下：
* Y! m! e( j; g9 Q" \! k

1. void HAL_EnableCompensationCell(void)     /* 使能IO补偿单元 */
   
2. void HAL_DisableCompensationCell(void)    /* 关闭IO补偿单元，默认下是关闭的 */

复制代码

这两个函数用于使能或者禁止IO补偿。I / O补偿单元仅可在设备供电时使用，且在电源电压为2.4V~3.6V时，使用IO补偿功能才有意义。默认情况下，不使用I / O补偿单元，当I / O输出缓冲区速度配置为50 MHz以上模式时，建议开启I/O补偿单元来减少对电源带来的噪音。
12. IO补偿、优化IO速度以及低功耗等相关函数
IO补偿、优化IO速度以及低功耗等相关函数，这里先不进行讲解了，后面用到我们再进行说明。
) ]! T, u+ I: D/ ^( X
; Y; L- h8 G: ^7.5 章节小结
本章节是认识HAL库的重要环节，或许分析的过程有点枯燥，代码比较多，让人看得眼花缭乱。即使HAL库的文件和函数再多，我们通过去分析一些共性的东西，先挨个分析重要的文件以及函数，然后把他们串起来，脑海里形成最初的认识，在以后的学习和实验过程中，我们还可以回过头来再看看，加深理解。通过认识、理解、实践、再理解的过程，我们可以逐渐掌握必备的知识点。
. v  O, q4 B% q8 O本章节我们重点讲解了HAL库的两个重要的文件：stm32mp1xx_hal_conf.h和 stm32mp1xx_hal.c文件，结合前面的第六章节的实验，下面我们将固件库的文件关系用一张简图来描述（图中省略了部分.c文件和.h文件），其中箭头指向的文件表示要调用某个头文件的文件，例如箭头由stm32mp1xx_hal_conf.h指向stm32mp1xx_hal.h，表示stm32mp1xx_hal.h调用stm32mp1xx_hal_conf.h。



图7.4.2. 9 固件库头文件关系
stm32mp1xx_hal_conf.h头文件基本上是一些宏定义和条件编译，用于用户自定义驱动，外设驱动配置文件可以根据需要include相关的外设头文件，不过在STM32CubeIDE上开发的话，此文件一般不需要我们手动去改，一般是通过STM32CubeMX插件完成配置。
! h  Z7 p. k1 l/ ostm32mp1xx_hal.c文件主要包括HAL库的初始化、系统滴答、基准电压配置、IO补偿、低功耗、EXTI配置、调试相关等函数的定义，其中weak定义的函数可以根据需要被用户在其它文件中进行重新定义。stm32mp1xx_hal.h头文件包含了HAL模型的所有驱动，用户的驱动文件或者main.h文件可以直接include此文件。
————————————————
  ?: z2 R3 c7 d版权声明：正点原子

3 Q: f. G" v, B( n8 q- Z
6 M5 D. d2 \% e/ `