【经验分享】STM32标准库和HAL库有什么不同？我们怎么用？

[复制链接]

STMCU小助手发布时间：2021-11-7 16:19

技术帖
文章封面:
文章简介:	通常新手在入门STM32的时候，首先都要先选择一种要用的开发方式，不同的开发方式会导致你编程的架构是完全不一样的。一般大多数都会选用标准库和HAL库，而极少部分人会通过直接配置寄存器进行开发。

摘要：通常新手在入门STM32的时候，首先都要先选择一种要用的开发方式，不同的开发方式会导致你编程的架构是完全不一样的。一般大多数都会选用标准库和HAL库，而极少部分人会通过直接配置寄存器进行开发。
; q) o3 b* s" T, Z7 Q6 ]9 W

网上关于标准库、HAL库的描述相信是数不胜数。可是一个对于很多刚入门的朋友还是没法很直观的去真正了解这些不同开发发方式彼此之间的区别，所以笔者想以一种非常直白的方式，用自己的理解去将这些东西表述出来，如果有描述的不对的地方或者是不同意见的也可以大家提出。

一、配置寄存器

不少先学了51的朋友可能会知道，会有一小部分人或是教程是通过汇编语言直接操作寄存器实现功能的，这种方法到了STM32就变得不太容易行得通了。

因为STM32的寄存器数量是51单片机的十数倍，如此多的寄存器根本无法全部记忆，开发时需要经常的翻查芯片的数据手册，此时直接操作寄存器就变得非常的费力了。但还是会有很小一部分人，喜欢去直接操作寄存器，因为这样更接近原理，知其然也知其所以然。

二、标准库

上面也提到了，STM32有非常多的寄存器，而导致了开发困难，所以为此ST公司就为每款芯片都编写了一份库文件，也就是工程文件里stm32F1xx.....之类的。在这些.c .h文件中，包括一些常用量的宏定义，把一些外设也通过结构体变量封装起来，如GPIO口时钟等。

所以我们只需要配置结构体变量成员就可以修改外设的配置寄存器，从而选择不同的功能。也是目前最多人使用的方式，也是学习STM32接触最多的一种开发方式，我也就不多阐述了。

三、HAL库

HAL库是ST公司目前主力推的开发方式，全称就是Hardware Abstraction Layer（抽象印象层）。
/ u4 q1 s. u: ^8 u4 i* y

库如其名，很抽象，一眼看上去不太容易知道他的作用是什么。它的出现比标准库要晚，但其实和标准库一样，都是为了节省程序开发的时期，而且HAL库尤其的有效，如果说标准库把实现功能需要配置的寄存器集成了，那么HAL库的一些函数甚至可以做到某些特定功能的集成。! E2 o0 P( x# \ b/ Q

也就是说，同样的功能，标准库可能要用几句话，HAL库只需用一句话就够了。并且HAL库也很好的解决了程序移植的问题，不同型号的stm32芯片它的标准库是不一样的，例如在F4上开发的程序移植到F3上是不能通用的，而使用HAL库，只要使用的是相通的外设，程序基本可以完全复制粘贴，注意是相通外设，意思也就是不能无中生有。

例如F7比F3要多几个定时器，不能明明没有这个定时器却非要配置，但其实这种情况不多，绝大多数都可以直接复制粘贴。是而且使用ST公司研发的STMcube软件，可以通过图形化的配置功能，直接生成整个使用HAL库的工程文件，可以说是方便至极，但是方便的同时也造成了它执行效率的低下，在各种论坛帖子真的是被吐槽的数不胜数。

四、总结

综合上面说的，其实笔者还是强烈推荐HAL库的，理由有二：

第一、 F7系列开始 ST公司就已近开始停止更新标准库，也就是F7开始包括F7已经不能用标准库了，公司对于主打HAL库的目的已经非常明显了。

二、追求更方便、追求模块化向来是世界的潮流，更方便的HAL库一定会迅速发展，低效的短板迟早会被硬件高度集成化所弥补。

当然啦，不能只学习HAL库，底层的原理必需是要懂的，这是每个学有所成的人都公认的事实，HAL库也不是万能的，结合对底层的理解相信一定会让你的开发水准大大提高。

五、STM32 HAL库与标准库的区别1.句柄

在STM32的标准库中，假设我们要初始化一个外设（这里以USART为例）我们首先要初始化他们的各个寄存器。

在标准库中，这些操作都是利用固件库结构体变量+固件库Init函数实现的：

USART_InitTypeDef USART_InitStructure;2 e# m. e' ~7 L# A. q( J
2 g+ Q! k' c, s3 g4 f
USART_InitStructure.USART_BaudRate = bound;//串口波特率
1 ?# t2 B3 {/ a; |" g* ]
USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
# t/ { Q2 {2 g5 G* p# ]
USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位6 N% k) s( q& C6 o
USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
$ L! x3 @# {. m7 {
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
5 a8 s$ x0 M. l
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
7 H) l( ~' h! j t/ m' u
. ^4 j% l' M' T5 o7 \1 v% s' w
USART_Init(USART3, &USART_InitStructure); //初始化串口1

复制代码

可以看到，要初始化一个串口，需要对六个位置进行赋值，然后引用Init函数，并且USART_InitStructure并不是一个全局结构体变量，而是只在函数内部的局部变量，初始化完成之后，USART_InitStructure就失去了作用。

而在HAL库中，同样是USART初始化结构体变量，我们要定义为全局变量。

UART_HandleTypeDef UART1_Handler;

复制代码

右键查看结构体成员：

typedef struct |$ d9 E6 N2 \) @
{
& X. r% V9 H. ^
USART_TypeDef *Instance; /*!< UART registers base address */# `) M1 H4 O" y# W; J
UART_InitTypeDef Init; /*!< UART communication parameters */
& M0 [2 h: O' P7 q
uint8_t *pTxBuffPtr; /*!< Pointer to UART Tx transfer Buffer */
7 l; m! s% N8 ?' j' H
uint16_t TxXferSize; /*!< UART Tx Transfer size */
- @* S4 b; w, G- L& v
uint16_t TxXferCount; /*!< UART Tx Transfer Counter */
/ j. D" j4 w% d( X' q
uint8_t *pRxBuffPtr; /*!< Pointer to UART Rx transfer Buffer */
- U( s( i" j& \- W6 w; O
uint16_t RxXferSize; /*!< UART Rx Transfer size */
! D/ c4 z: v; C: g9 j" J
uint16_t RxXferCount; /*!< UART Rx Transfer Counter */
# n* U) o) J9 r) T: d2 ]8 B
DMA_HandleTypeDef *hdmatx; /*!< UART Tx DMA Handle parameters */
/ E* ?; _. h) g, Z, C
DMA_HandleTypeDef *hdmarx; /*!< UART Rx DMA Handle parameters */
/ D' B2 k# ?: p: ~9 w2 L
HAL_LockTypeDef Lock; /*!< Locking object */! r3 q! |" |/ S
__IO HAL_UART_StateTypeDef State; /*!< UART communication state */! J+ H G# V% |! r6 U
__IO uint32_t ErrorCode; /*!< UART Error code */4 s2 ]+ B* K4 k& B
}UART_HandleTypeDef;

复制代码

我们发现，与标准库不同的是，该成员不仅包含了之前标准库就有的六个成员（波特率，数据格式等），还包含过采样、（发送或接收的）数据缓存、数据指针、串口 DMA 相关的变量、各种标志位等等要在整个项目流程中都要设置的各个成员。

该UART1_Handler就被称为串口的句柄它被贯穿整个USART收发的流程，比如开启中断：

HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE);

复制代码

比如后面要讲到的MSP与Callback回调函数：

void HAL_UART_MspInit(UART_HandleTypeDef *huart);
7 ~- j( l6 g% [$ h
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

复制代码

在这些函数中，只需要调用初始化时定义的句柄UART1_Handler就好。

2.MSP函数

MCU Specific Package单片机的具体方案

MSP是指和MCU相关的初始化，引用一下正点原子的解释，个人觉得说的很明白：

“我们要初始化一个串口，首先要设置和 MCU 无关的东西，例如波特率，奇偶校验，停止位等，这些参数设置和 MCU 没有任何关系，可以使用 STM32F1，也可以是STM32F2/F3/F4/F7上的串口。而一个串口设备它需要一个 MCU 来承载，例如用 STM32F4 来做承载，PA9 做为发送，PA10 做为接收，MSP 就是要初始化 STM32F4 的 PA9,PA10，配置这两个引脚。所以 HAL驱动方式的初始化流程就是：HAL_USART_Init()—>HAL_USART_MspInit()，先初始化与 MCU无关的串口协议，再初始化与 MCU 相关的串口引脚。在 STM32 的 HAL 驱动中HAL_PPP_MspInit()作为回调，被HAL_PPP_Init()函数所调用。当我们需要移植程序到 STM32F1平台的时候，我们只需要修改 HAL_PPP_MspInit 函数内容而不需要修改 HAL_PPP_Init 入口参数内容。”
[size=3em]”

在HAL库中，几乎每初始化一个外设就需要设置该外设与单片机之间的联系，比如IO口，是否复用等等，可见，HAL库相对于标准库多了MSP函数之后，移植性非常强，但与此同时却增加了代码量和代码的嵌套层级。可以说各有利弊。

同样，MSP函数又可以配合句柄，达到非常强的移植性：

- |3 o: L; D/ h

void HAL_UART_MspInit(UART_HandleTypeDef *huart);

复制代码

3.Callback函数

类似于MSP函数，个人认为Callback函数主要帮助用户应用层的代码编写。还是以USART为例，在标准库中，串口中断了以后，我们要先在中断中判断是否是接收中断，然后读出数据，顺便清除中断标志位，然后再是对数据的处理，这样如果我们在一个中断函数中写这么多代码，就会显得很混乱：

void USART3_IRQHandler(void) //串口1中断服务程序
% \9 D. L- X* r+ J* f% Q
{' t& g: x8 a @$ h2 [0 D: I# S; V5 G
u8 Res;
& h) U- F+ I9 d5 `2 |9 F
if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)# Z6 X! t& |7 J% T( I% F
{
0 h; A# I$ O' U6 j0 h
Res =USART_ReceiveData(USART3); //读取接收到的数据
- ~. c9 G4 K$ ]. |- Q* \! K
/*数据处理区*/
' u z$ e$ ^; t" a, P5 Q
}
( A6 |5 X( ~7 }1 W7 W" ~# I# c
}

复制代码

而在HAL库中，进入串口中断后，直接由HAL库中断函数进行托管：

void USART1_IRQHandler(void)
7 f$ E+ A J0 X( \4 I9 M
{ 3 b) [, t9 v, ]2 a. `# V. C9 |1 U
HAL_UART_IRQHandler(&UART1_Handler); //调用HAL库中断处理公用函数
0 p% q2 R& j7 w" [+ a) x
/***************省略无关代码****************/ " s0 m" x) l% v- p& O6 w6 [
}

复制代码

HAL_UART_IRQHandler这个函数完成了判断是哪个中断（接收？发送？或者其他？），然后读出数据，保存至缓存区，顺便清除中断标志位等等操作。比如我提前设置了，串口每接收五个字节，我就要对这五个字节进行处理。在一开始我定义了一个串口接收缓存区：

/*HAL库使用的串口接收缓冲,处理逻辑由HAL库控制，接收完这个数组就会调用HAL_UART_RxCpltCallback进行处理这个数组*/# v- G/ U; e- i7 C
/*RXBUFFERSIZE=5*/8 R2 ~& D z- x1 E1 w
u8 aRxBuffer[RXBUFFERSIZE];

复制代码

在初始化中，我在句柄里设置好了缓存区的地址，缓存大小（五个字节）

/*该代码在HAL_UART_Receive_IT函数中，初始化时会引用*/
4 a3 g5 J ^& M" |3 ]! B8 s
huart->pRxBuffPtr = pData;//aRxBuffer0 E4 V7 A' M3 r4 @2 O
huart->RxXferSize = Size;//RXBUFFERSIZE8 ]# _) O( D; U* ?
huart->RxXferCount = Size;//RXBUFFERSIZE

复制代码

则在接收数据中，每接收完五个字节，HAL_UART_IRQHandler才会执行一次Callback函数：

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

在这个Callback回调函数中，我们只需要对这接收到的五个字节（保存在aRxBuffer[]中）进行处理就好了，完全不用再去手动清除标志位等操作。

所以说Callback函数是一个应用层代码的函数，我们在一开始只设置句柄里面的各个参数，然后就等着HAL库把自己安排好的代码送到手中就可以了~

综上，就是HAL库的三个与标准库不同的地方之个人见解。

个人觉得从这三个小点就可以看出HAL库的可移植性之强大，并且用户可以完全不去理会底层各个寄存器的操作，代码也更有逻辑性。但与此带来的是复杂的代码量，极慢的编译速度，略微低下的效率。看怎么取舍了。

五、HAL库结构

说到STM32 的HAL库，就不得不提STM32CubeMX，其作为一个可视化的配置工具，对于开发者来说，确实大大节省了开发时间。

STM32CubeMX 就是以 HAL 库为基础的，且目前仅支持 HAL 库及 LL 库！首先看一下，官方给出的 HAL 库的包含结构：

stm32f2xx.h 主要包含STM32同系列芯片的不同具体型号的定义，是否使用HAL库等的定义，接着，其会根据定义的芯片信号包含具体的芯片型号的头文件：

#if defined(STM32F205xx)
4 s# ~& t5 A: Z1 q f
#include "stm32f205xx.h"+ f6 ?: U% g [9 B- C" ~
#elif defined(STM32F215xx)$ D8 s2 M; K7 T N1 M; k% ]: C
#include "stm32f215xx.h"$ q" ~# i! w* d2 f
#elif defined(STM32F207xx)! P' W# q8 e* [$ Q1 {( y- M+ A, b7 K
#include "stm32f207xx.h"/ ?+ S% c K- j" @9 E' T( A8 d
#elif defined(STM32F217xx). U0 E; p5 [7 S2 ?& X/ B; k
#include "stm32f217xx.h" H. H2 W u6 @ ?6 m6 U- A
#else. T- G0 `8 [7 ?9 D C x
#error "Please select first the target STM32F2xx device used in your application (in stm32f2xx.h file)"
$ m0 }- \. h: L
#endif

复制代码

紧接着，其会包含 stm32f2xx_hal.h。

stm32f2xx_hal.h：stm32f2xx_hal.c/h 主要实现HAL库的初始化、系统滴答相关函数、及CPU的调试模式配置
stm32f2xx_hal_conf.h ：该文件是一个用户级别的配置文件，用来实现对HAL库的裁剪，其位于用户文件目录，不要放在库目录中。
: M' i9 @% f7 ]4 B# b6 Q( x

接下来对于HAL库的源码文件进行一下说明，HAL库文件名均以stm32f2xx_hal开头，后面加上_外设或者模块名（如：stm32f2xx_hal_adc.c）：

库文件：
# t) d9 Y, ^* T$ ^) l2 F0 F8 j
stm32f2xx_hal_ppp.c/.h // 主要的外设或者模块的驱动源文件，包含了该外设的通用API( k& D1 ?4 C$ Q& |/ X
stm32f2xx_hal_ppp_ex.c/.h // 外围设备或模块驱动程序的扩展文件。这组文件中包含特定型号或者系列的芯片的特殊API。以及如果该特定的芯片内部有不同的实现方式，则该文件中的特殊API将覆盖_ppp中的通用API。0 B/ h' d0 q0 c
stm32f2xx_hal.c/.h // 此文件用于HAL初始化，并且包含DBGMCU、重映射和基于systick的时间延迟等相关的API6 Y' Z+ L* k+ b6 h I3 u7 `" P
其他库文件
* E. \7 ^0 _7 Z
用户级别文件： X# A# S$ \- S& W
stm32f2xx_hal_msp_template.c // 只有.c没有.h。它包含用户应用程序中使用的外设的MSP初始化和反初始化（主程序和回调函数）。使用者复制到自己目录下使用模板。) @; m+ L8 X- S6 j; I
stm32f2xx_hal_conf_template.h // 用户级别的库配置文件模板。使用者复制到自己目录下使用4 O0 X) n' z% j s# J: p
system_stm32f2xx.c // 此文件主要包含SystemInit()函数，该函数在刚复位及跳到main之前的启动过程中被调用。 **它不在启动时配置系统时钟（与标准库相反）**。时钟的配置在用户文件中使用HAL API来完成。8 w9 I% m! [" L% \8 n( F* F$ j
startup_stm32f2xx.s // 芯片启动文件，主要包含堆栈定义，终端向量表等
! C, x/ c- |( y$ n. l
stm32f2xx_it.c/.h // 中断处理函数的相关实现; O* A8 y# `: T2 R8 j
main.c/.h

复制代码

根据HAL库的命名规则，其API可以分为以下三大类：

初始化/反初始化函数：HAL_PPP_Init(), HAL_PPP_DeInit()
IO 操作函数：HAL_PPP_Read(), HAL_PPP_Write(),HAL_PPP_Transmit(), HAL_PPP_Receive()
控制函数：HAL_PPP_Set (), HAL_PPP_Get ().
状态和错误：HAL_PPP_GetState (), HAL_PPP_GetError ().
; a$ y0 A# B5 g9 l

/ R! y% X, ]$ z2 f6 u9 i

“注意：目前 LL 库是和 HAL 库捆绑发布的，所以在 HAL 库源码中，还有一些名为 stm32f2xx_ll_ppp 的源码文件，这些文件就是新增的LL库文件。使用 CubeMX 生产项目时，可以选择LL库。”

5 u+ Z) c+ @7 a+ T# [
[size=3em]”

HAL 库最大的特点就是对底层进行了抽象。在此结构下，用户代码的处理主要分为三部分：

处理外设句柄（实现用户功能）处理MSP 处理各种回调函数外设句柄定义用户代码的第一大部分：对于外设句柄的处理。HAL库在结构上，对每个外设抽象成了一个称为ppp_HandleTypeDef的结构体，其中ppp就是每个外设的名字。*所有的函数都是工作在ppp_HandleTypeDef指针之下。

多实例支持：每个外设/模块实例都有自己的句柄。因此，实例资源是独立的
外围进程相互通信：该句柄用于管理进程例程之间的共享数据资源。

/ l: z m3 Q! h* \

下面，以ADC为例

/** . K2 {; W- N% S2 R
* @brief ADC handle Structure definition
+ V( ?# d0 M2 _
*/ 1 D% v& y9 X( B
typedef struct. c5 z5 i9 c9 Q" I. P6 P* D
{
+ z; m% g. E& O+ v
ADC_TypeDef *Instance; /*!< Register base address */
D9 |: H, w9 c B5 R! {) u
ADC_InitTypeDef Init; /*!< ADC required parameters */- F. X( X9 M2 e2 Q2 V. n N* s: }
__IO uint32_t NbrOfCurrentConversionRank; /*!< ADC number of current conversion rank */; A8 X' E% C! x) u# u
DMA_HandleTypeDef *DMA_Handle; /*!< Pointer DMA Handler */
0 b. Z: [% R( x3 s# z
HAL_LockTypeDef Lock; /*!< ADC locking object */
, A4 x ?; P: _+ O( [ s
__IO uint32_t State; /*!< ADC communication state */
) G7 H) N% B6 f2 A
__IO uint32_t ErrorCode; /*!< ADC Error code */. ^+ x9 N! }) S: u
}ADC_HandleTypeDef;

复制代码

从上面的定义可以看出，ADC_HandleTypeDef中包含了ADC可能出现的所有定义，对于用户想要使用ADC只要定义一个ADC_HandleTypeDef的变量，给每个变量赋好值，对应的外设就抽象完了。接下来就是具体使用了。

当然，对于那些共享型外设或者说系统外设来说，他们不需要进行以上这样的抽象，这些部分与原来的标准外设库函数基本一样。例如以下外设：

GPIO
SYSTICK
NVIC
RCC
FLASH
$ j9 o+ d& m/ j5 y4 o( V9 l

以GPIO 为例，对于HAL_GPIO_Init()函数，其只需要GPIO地址以及其初始化参数即可。

1. 三种编程方式

HAL库对所有的函数模型也进行了统一。在HAL库中，支持三种编程模式：轮询模式、中断模式、DMA模式（如果外设支持）。其分别对应如下三种类型的函数（以ADC为例）：

HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc);% N! U. H2 T5 A& P- v, d
HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc);4 F* r$ e( f' \# x8 b
2 x: y v: T) w1 z' C
HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc);; V8 d- A) i: ] o6 t: i* d' f
HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc);9 f/ H5 b9 x3 l4 g4 b* K
( _% I% i# G/ s) p( l
HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length);
5 }0 h: | y7 l2 O, J; v" ]
HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc);

复制代码

其中，带_IT的表示工作在中断模式下；带_DMA的工作在DMA模式下（注意：DMA模式下也是开中断的）；什么都没带的就是轮询模式（没有开启中断的）。至于使用者使用何种方式，就看自己的选择了。

此外，新的HAL库架构下统一采用宏的形式对各种中断等进行配置（原来标准外设库一般都是各种函数）。针对每种外设主要由以下宏：

__HAL_PPP_ENABLE_IT(HANDLE, INTERRUPT)：使能一个指定的外设中断
__HAL_PPP_DISABLE_IT(HANDLE, INTERRUPT)：失能一个指定的外设中断
__HAL_PPP_GET_IT (HANDLE, __ INTERRUPT __)：获得一个指定的外设中断状态
__HAL_PPP_CLEAR_IT (HANDLE, __ INTERRUPT __)：清除一个指定的外设的中断状态
__HAL_PPP_GET_FLAG (HANDLE, FLAG)：获取一个指定的外设的标志状态
__HAL_PPP_CLEAR_FLAG (HANDLE, FLAG)：清除一个指定的外设的标志状态
__HAL_PPP_ENABLE(HANDLE) ：使能外设
__HAL_PPP_DISABLE(HANDLE) ：失能外设
__HAL_PPP_XXXX (HANDLE, PARAM) ：指定外设的宏定义
_HAL_PPP_GET IT_SOURCE (HANDLE, __ INTERRUPT __)检查中断源
* s: h, t# @( _

2. 三大回调函数

在 HAL 库的源码中，到处可见一些以__weak开头的函数，而且这些函数，有些已经被实现了，比如：

__weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
6 ~( q7 P7 P* ` {6 j
{
' b- q, [/ f+ T( `+ }4 M: T
/*Configure the SysTick to have interrupt in 1ms time basis*/4 k5 V1 v: x5 [& n; R
HAL_SYSTICK_Config(SystemCoreClock/1000U);: |. y- ~; k% a2 V
/*Configure the SysTick IRQ priority */1 r0 y- x1 X7 a2 @( m: M. R
HAL_NVIC_SetPriority(SysTick_IRQn, TickPriority ,0U);
# k8 F. e t- b
/* Return function status */* I) {( o' a" L- B+ e7 n
return HAL_OK;& S) c9 r7 D) o1 {7 N+ i3 i4 X
}

复制代码

有些则没有被实现，例如：

__weak void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)2 b& F6 ~" l- @% P7 `/ } K9 q# \6 i- r
{
" [5 T5 `. K" I
/* Prevent unused argument(s) compilation warning */8 }; P0 |) V: t3 n# {, U, H
UNUSED(hspi);
) M& W- o- U* t; k3 Y
/* NOTE : This function should not be modified, when the callback is needed,the HAL_SPI_TxCpltCallback should be implemented in the user file
C0 Y. A4 |- F$ f; a- c/ {
*/
' r: a" D6 A6 L, {+ R$ d( Q# _1 p- H0 T
}

复制代码

所有带有__weak关键字的函数表示，就可以由用户自己来实现。如果出现了同名函数，且不带__weak关键字，那么连接器就会采用外部实现的同名函数。通常来说，HAL库负责整个处理和MCU外设的处理逻辑，并将必要部分以回调函数的形式给出到用户，用户只需要在对应的回调函数中做修改即可。HAL 库包含如下三种用户级别回调函数(PPP为外设名)：

外设系统级初始化/解除初始化回调函数（用户代码的第二大部分：对于MSP的处理）：HAL_PPP_MspInit()和HAL_PPP_MspDeInit 例如：__weak void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)。在HAL_PPP_Init() 函数中被调用，用来初始化底层相关的设备（GPIOs, clock, DMA, interrupt）
处理完成回调函数：HAL_PPP_ProcessCpltCallback（Process指具体某种处理，如UART的Tx），例如：__weak void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)。当外设或者DMA工作完成后时，触发中断，该回调函数会在外设中断处理函数或者DMA的中断处理函数中被调用
错误处理回调函数：HAL_PPP_ErrorCallback例如：__weak void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)。当外设或者DMA出现错误时，触发终端，该回调函数会在外设中断处理函数或者DMA的中断处理函数中被调用。

" s- Z- j$ m4 [( I7 z( d

~END~