为开发者提供了非常方便的开发库：有标准外设库（SPL库）、HAL 库（Hardware Abstraction Layer，硬件抽象层库）、LL 库（Low-Layer，底层库）三种。前者是ST的老库已经停更了，后两者是ST现在主推的开发库。

' o' L9 t" V/ D) ]8 \7 z
+ J" @, {6 U6 r% f相比标准外设库，STM32Cube HAL库表现出更高的抽象整合水平，HAL API集中关注各外设的公共函数功能，这样便于定义一套通用的用户友好的API函数接口，从而可以轻松实现从一个STM32产品移植到另一个不同的STM32系列产品。HAL库是ST未来主推的库，ST新出的芯片已经没有STD库了，比如F7系列。目前，HAL库已经支持STM32全线产品。
# p9 S. R$ l% y

通过文字描述可以知道HAL库的几个点：
1.最大可移植性。
2.提供了一整套一致的中间件组件，如RTOS，USB，TCP / IP和图形等。
1 C+ S! Q. K& e7 b% u* K3.通用的用户友好的API函数接口。
4.ST新出的芯片已经没有标准库。
5.HAL库已经支持STM32全线产品。


/ p: o* O: ^: Z网友认为，“HAL我觉得是极好的，就是SPI接收时速度实在太慢，不用DMA的话，吃不消。“
4 n# x2 q* g/ v. v$ m
: f6 L6 x% S% r) j, Z1 G
) Q- x+ d: [+ }1 L: @3 u+ Q% ]# w通常新手在入门STM32的时候，首先都要先选择一种要用的开发方式，不同的开发方式会导致你编程的架构是完全不一样的。一般大多数都会选用标准库和HAL库，而极少部分人会通过直接配置寄存器进行开发。网上关于标准库、HAL库的描述相信是数不胜数。可是一个对于很多刚入门的朋友还是没法很直观的去真正了解这些不同开发方式彼此之间的区别，所以笔者想以一种非常直白的方式，用自己的理解去将这些东西表述出来，如果有描述的不对的地方或者是不同意见的也可以大家提出。


01、直接配置寄存器

不少先学了51的朋友可能会知道，会有一小部分人或是教程是通过汇编语言直接操作寄存器实现功能的，这种方法到了STM32就变得不太容易行得通了，因为STM32的寄存器数量是51单片机的十数倍，如此多的寄存器根本无法全部记忆，开发时需要经常的翻查芯片的数据手册，此时直接操作寄存器就变得非常的费力了。但还是会有很小一部分人，喜欢去直接操作寄存器，因为这样更接近原理，知其然也知其所以然。
! t" P6 |* w3 _4 D% G9 s, P

+ X/ d6 x* T  ^3 ^02、标准库
( b4 _9 e: K7 B) D

: `1 S. {7 @; D+ K3 |- @0 a上面也提到了，STM32有非常多的寄存器，而导致了开发困难，所以为此ST公司就为每款芯片都编写了一份库文件，也就是工程文件里stm32F1xx…之类的。在这些 .c .h文件中，包括一些常用量的宏定义，把一些外设也通过结构体变量封装起来，如GPIO口时钟等。所以我们只需要配置结构体变量成员就可以修改外设的配置寄存器，从而选择不同的功能。也是目前最多人使用的方式，也是学习STM32接触最多的一种开发方式，我也就不多阐述了。

$ m; C$ t4 u+ _) U
$ V6 R# c2 y0 x03、HAL库

. F8 o0 N$ m( x4 t
' K7 N6 T5 X; s) E6 j; uHAL库是ST公司目前主力推的开发方式，全称就是Hardware Abstraction Layer（抽象印象层）。库如其名，很抽象，一眼看上去不太容易知道他的作用是什么。它的出现比标准库要晚，但其实和标准库一样，都是为了节省程序开发的时期，而且HAL库尤其的有效，如果说标准库把实现功能需要配置的寄存器集成了，那么HAL库的一些函数甚至可以做到某些特定功能的集成。也就是说，同样的功能，标准库可能要用几句话，HAL库只需用一句话就够了。并且HAL库也很好的解决了程序移植的问题，不同型号的stm32芯片它的标准库是不一样的，例如在F4上开发的程序移植到F3上是不能通用的，而使用HAL库，只要使用的是相通的外设，程序基本可以完全复制粘贴，注意是相通外设，意思也就是不能无中生有，例如F7比F3要多几个定时器，不能明明没有这个定时器却非要配置，但其实这种情况不多，绝大多数都可以直接复制粘贴。是而且使用ST公司研发的STMcube软件，可以通过图形化的配置功能，直接生成整个使用HAL库的工程文件，可以说是方便至极，但是方便的同时也造成了它执行效率的低下，在各种论坛帖子真的是被吐槽的数不胜数。
( ^4 ]4 a$ G7 V7 {: m8 N  q. x; @6 Q

! g! I2 z7 _2 e) @0 V  |! f% W1 ]% E

HAL库和标准固件库区别

0 q: `- L1 Q0 N: o$ R1 M. R( F0 c: Y8 V
STM32的开发中，我们可以操作寄存器：

" \# o6 D( R8 U9 O
1 n3 s* L* I) [7 {) kGPIOF->BSRR=0x00000001;//这里是针对STM32F1系列

3 W" I9 {$ s* K
这种方法当然可以，但是这种方法的劣势是你需要去掌握每个寄存器的用法，你才能正确使用STM32，而对于STM32这种级别的MCU，数百个寄存器记起来又是谈何容易。于是ST(意法半导体)推出了官方标准固件库，标准固件库将这些寄存器底层操作都封装起来，提供一整套接口（API）供开发者调用，大多数场合下，你不需要去知道操作的是哪个寄存器，你只需要知道调用哪些函数即可。


% X2 K$ M, x+ h9 h3 ]比如上面的控制 BRR 寄存器实现电平控制，官方库封装了一个函数：

1. 
   & J* Q. R* v& ~& a7 R# ?
2. void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   
3. {
   
4. GPIOx->BRR= GPIO_Pin;
   
5. }

复制代码

这个时候你不需要再直接去操作 BRR 寄存器了，你只需要知道怎么使用 GPIO_ResetBits()这个函数就可以了。在你对外设的工作原理有一定的了解之后，你再去看标准库函数，基本上函数名字能告诉你这个函数的功能是什么，该怎么使用，这样开发就方便很多。

! `& T0 _( |' h! K6 X
标准固件库自推出以来受到广大工程师推崇，现在很多工程师和公司还在使用标准库函数开发。不过，ST官方已经不再更新STM32标准固件库，而是力推新的固件库:HAL库。
! x7 x7 `6 A  z4 i! X1 Z, {% e

) b8 e" L, a0 o: ]比如上面的控制BSRRL 寄存器实现电平控制，官方 HAL 库封装了一个函数：
; ?! n; P3 I& `8 d, _# J

1. 
   ) P# S, ~/ p* }! t
2. voidHAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin,
   9 h1 C2 I1 H; I' T9 |
3. GPIO_PinStatePinState)
   + G5 m6 b9 \# l  @
4. {
   " I9 Z5 t& ^4 f+ j
5. assert_param(IS_GPIO_PIN(GPIO_Pin));
   
6. assert_param(IS_GPIO_PIN_ACTION(PinState));
   : E# }) U; o) s  i( l5 Q& W5 P
7. if(PinState!= GPIO_PIN_RESET)
   
8. {
   ' v+ x' G7 P& z/ J5 r# z
9. GPIOx->BSRR= GPIO_Pin;
   
10. }
    ' f. F) I( o4 }1 A& c
11. else
    
12. {
    
13. GPIOx->BSRR= (uint32_t)GPIO_Pin << 16;
    5 ^  V0 Z& @9 w, o; @$ G
14. }
    1 g+ e. W6 f. F& N( i! Q
15. }

复制代码

这个时候你不需要再直接去操作BSRRL 寄存器了，你只需要知道怎么使用HAL_GPIO_WritePin这个函数就可以了。


' d; f: O- O" t! f, T. f4 D标准固件库和HAL库一样都是固件库函数，由ST官方硬件抽象层而设计的软件函数包，由程序、数据结构和宏组成，包括了STM32所有外设的性能特征。  这些固件库为开发者底层硬件提供了中间API，通过使用固件库，无需掌握底层细节，开发者就可以轻松应用每一个外设。
+ N+ A3 f& F( {; l

  ^9 {8 x6 e4 s) f* y# E* YHAL 库和标准库本质上是一样的，都是提供底层硬件操作 API，而且在使用上也是大同小异。有过标准库基础的同学对 HAL 库的使用也很容易入手。ST 官方之所以这几年大力推广 HAL 库，是因为 HAL 的结构更加容易整合 STM32Cube，而 STM32CubeMX 是 ST 这几年极力推荐的程序生成开发工具。所以这几年新出的 STM32 芯片，ST 直接只提供 HAL 库。
7 T/ l% h* ]5 u0 t+ t8 e. M# _- N
* G- {) }* F  ~9 G' t% S, N+ q" e
在ST的官方声明中，HAL库是大势所趋。ST最新开发的芯片中，只有HAL库没有标准库。标准库和HAL库虽然都是对外设进行操作的函数，但由于标准库官方已经停止更新，而且标准库在STM32创建工程和初始化时，不能由CubMX软件代码生成使用，也就是说CubMX软件在生产代码时，工程项目和初始化代码就自动生成，这个工程项目和初始化代码里面使用的库都是基于HAL库的。STM32CubeMX是一个图形化的工具，也是配置和初始化C代码生成器 ，与STM32CubeMX配合使用的是HAL库（硬件抽象层软件库）。


. `3 i+ a2 o% L# X+ b$ a- n

基本配置

1 D6 d  W9 H/ \5 G
工程创建

通过内核芯片的选择，创建相应的工程文件。

对时钟系统进行配置，对引脚及基本功能进行配置。


4 r0 Q1 p' [9 w( ~6 r1 ?# J# E8 R配置时钟系统我们首要思考的是：我们需要怎样的时钟系统，而不是如何配置时钟系统。
; |$ J, S0 j: O3 R0 @. a

配置SWD程序烧录接口，使用ST-Link进行烧录下载。
" f4 d6 y$ y% o: I

工程管理设置推荐图中所示配置，实现更快编译和更简洁的文件系统。
  m) c  m  y* N( I- z
  ~6 N1 g9 D" f, d( J+ Z7 C2 L
点击图中“GENERATE CODE”生成Keil工程文件

如果你已经安装了编译环境MDK了，可点击直接打开工程。
& V6 ~! R3 A( ?7 ]" ]2 r( K1 M/ |

/ d! r9 \* t1 M( x7 nGPIO使用
# f" j: f8 U% Y; S! E

  C6 E5 W2 y, g# ]( u* z: }6 L开发环境搭建好以后，可以依开始STM32的开发,下面是使用GPIO的例程，让LED灯每隔400ms闪烁一次
6 x8 C6 ^5 C0 [) N" C

打开STM32CubeMX新建工程，选择STM32F103ZET6芯片。选择外部高速晶振（HSE）。
5 x+ x0 i) F# ]/ N4 v& x( B6 s

根据下位机主控引脚分配图及原理图，选择LED引脚
3 L4 W% l. h% t" g

PD7为LED1输出控制管脚，选择GPIO_OUTPUT模式。

点击Clock Configuration配置系统时钟为72M最高速度。
: I) B( C) n. E; ^7 K' G

点击Configuration->GPIO配置管脚。LED管脚配置为低速推挽输出模式，既不上拉也不下拉（即默认的模式不用配置）。
$ z0 t8 [, d* k

点击图片生成报告，软件会提示新建工程，输入工程名，选择工程保存路径。IDE选择MDK-ARM V5。

在Code Generator中找到Generated files框，勾选Generated periphera initialization as a pair of '.c/.h'files per IP。外设初始化为独立的C文件和头文件。

点击图片生成代码。点击Open Project打开工程。到这里我们就配置好工程外设初始化。
2 W& A3 F8 ~4 u0 v3 a* h

点击Build按钮，然后等一会，Build Optput信息框会输出没有错误没有警告。
在main函数里添加如下代码

延时电平翻转函数，这样LED灯就能开始闪烁。
+ `3 O. c9 s, g1 q$ c. u
4 E5 F( @8 \6 H3 q; H/ t
再点击Build按钮，然后等一会，Build Optput信息框会输出没有错误没有警告。
7 N0 g% v- P& c( Z, P& q+ Y2 y% X代码烧写。
$ `+ H" F: C$ S  k$ {
  I( \8 q! M1 i. {, z; c5 }
! f: t# N2 Y, j0 [9 p& V现在开始烧写程序，烧写程序有两种，一种是使用ST-LINK工具烧写，一种是直接用与上位机通讯的串口1烧写。烧写工具使用mcuisp。


3 z5 @" D2 i( C$ H# H$ _) i图片，软件可自行网上搜索，下载配置如下。

选择好串口端口后，可以开始下载。
( T1 [7 \# S' [6 }  _8 {
/ W- r7 o* x+ y5 Q& O+ B
HAL库固件库安装与用户手册
  A$ c3 F$ {  U% I. ?7 \& U8 `


. h& I" A0 `# d7 r3 q8 C7 W
/ N* C; U. g+ l5 f8 E6 _2 w1.首先设置让Cube可以自动联网下载相关固件库选择updater Settings

" s! h7 f; o# L  r1 ~设置如下

2.根据芯片选择所需固件
版本是向下兼容的，可以直接选择最新版。但如果觉得最新版太大，可以阅读下面的Main Changes.能够支持你目前的芯片就好。
7 z8 _9 W+ p( d+ \

选好了，点击Install Now就行，过程可能有点长。建议直接官网下载到本地，再安装
2 Z8 m. T7 ~# z$ {; M. P  A( _& L

文件会被下载到如下位置，建议更改此目录，不要选在C盘！！！
3 e% ^# }# m; g8 T. w$ b

: k; X5 k3 W' ]) s1 V9 s. N
6 H! ^6 V( s: J5 m& B

查找帮助手册

3.寻找用户帮助手册进入固件所在文件夹，里面包含很多内容。
* u/ m/ t6 I, P% }1 N3 X

9 A! l0 d- q$ |4 G8 o比如说 官方提供的开发板程序

每个型号下面都有对应功能的实现
0 v& S$ O- X; ]5 ?

用户手册就在Drivers文件夹下面。
7 r5 s! N5 ~# P' F

8 n4 S" P3 i* P# r/ ~/ b
. v* D. c5 I. S! ?4 `( a+ lSTM32 HAL库与标准库的区别
——浅谈句柄、MSP函数、Callback函数
. Y. I8 ]" M* I, r* _
1 _4 x- f, x! ?2 C01
句柄
. M3 ^' f3 i1 B4 u6 Y! l

句柄（handle），有多种意义，其中第一种是指程序设计，第二种是指Windows编程。现在大部分都是指程序设计/程序开发这类。


6 V8 F4 W8 Q4 X3 A· 第一种解释：句柄是一种特殊的智能指针。当一个应用程序要引用其他系统（如数据库、操作系统）所管理的内存块或对象时，就要使用句柄。
· 第二种解释：整个Windows编程的基础。一个句柄是指使用的一个唯一的整数值，即一个4字节(64位程序中为8字节)长的数值，来标识应用程序中的不同对象和同类中的不同的实例，诸如，一个窗口，按钮，图标，滚动条，输出设备，控件或者文件等。应用程序能够通过句柄访问相应的对象的信息，但是句柄不是指针，程序不能利用句柄来直接阅读文件中的信息。如果句柄不在I/O文件中，它是毫无用处的。句柄是Windows用来标志应用程序中建立的或是使用的唯一整数，Windows大量使用了句柄来标识对象。
/ R; z& z, {! T
STM32的标准库中，句柄是一种特殊的指针，通常指向结构体！


在STM32的标准库中，假设我们要初始化一个外设（这里以USART为例），我们首先要初始化他们的各个寄存器。在标准库中，这些操作都是利用固件库结构体变量+固件库Init函数实现的：
. s" c, b+ M: K8 l7 W（向右滑动哦）
  F" M- X0 T$ `4 {6 P

1. 
   % D; I, |! p5 Q- W$ x1 S
2. USART_InitTypeDef USART_InitStructure;
   + T4 c) v$ G  C; H6 T4 |& L& r
3. 
   
4. USART_InitStructure.USART_BaudRate = bound;//串口波特率
   & ~( Z) v- [% H1 ~
5. USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
   
6. USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
   , k* T2 j& g4 w6 t& Q5 M5 P, ~
7. USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
   . {" C7 E3 ^2 t3 I. s' K$ _
8. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
   . n; P# u1 ^7 j2 c* q( w" ]3 |3 I# @! _& q' K
9. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//收发模式
   4 _+ N  z" Q/ p! t& ?4 d
10. 
    6 J' q1 w$ M1 X) r3 k
11. USART_Init(USART3, &USART_InitStructure); //初始化串口1

复制代码

可以看到，要初始化一个串口，需要：


6 {* T. I8 A, d+ c) P8 `$ u· 1、对六个位置进行赋值，
- m; ^+ t5 V, g4 g/ g4 b/ f· 2、然后引用Init函数，
2 R. i& x8 m# g) a2 K* i+ ~' C
USART_InitStructure并不是一个全局结构体变量，而是只在函数内部的局部变量，初始化完成之后，USART_InitStructure就失去了作用。
0 P4 w7 q8 M' f" B8 A
0 S' N. b# N% u: ]9 L$ u' v
* D6 W( r$ \9 }7 i9 D而在HAL库中，同样是USART初始化结构体变量，我们要定义为全局变量。

1. UART_HandleTypeDef UART1_Handler;

复制代码

右键查看结构体成员
0 J8 B+ \$ \2 m  A( k  V

1. typedef struct
   ) F5 s7 S2 s: ^% S9 U
2. {
   
3.   USART_TypeDef                 *Instance;        /*!< UART registers base address        */
   
4.   UART_InitTypeDef              Init;             /*!< UART communication parameters      */
   
5. uint8_t                       *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
   
6. uint16_t                      TxXferSize;       /*!< UART Tx Transfer size              */
   : n, {% `$ e. E
7. uint16_t                      TxXferCount;      /*!< UART Tx Transfer Counter           */
   6 G& @& d  b  H# u6 n9 D; x& f! V
8. uint8_t                       *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
   % c" Y& m5 D+ J+ E
9. uint16_t                      RxXferSize;       /*!< UART Rx Transfer size              */
   ! t7 v; j( j3 r
10. uint16_t                      RxXferCount;      /*!< UART Rx Transfer Counter           */
    ! K/ @1 \; `  T" s) j2 B
11.   DMA_HandleTypeDef             *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
12.   DMA_HandleTypeDef             *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    8 O8 z! x5 q- R/ k9 U2 N
13.   HAL_LockTypeDef               Lock;             /*!< Locking object                     */
    & G0 e1 N! D2 d
14.   __IO HAL_UART_StateTypeDef    State;            /*!< UART communication state           */
    
15.   __IO uint32_t                 ErrorCode;        /*!< UART Error code                    */
    9 m! M/ x4 Y0 ^# f5 }! A% _
16. }UART_HandleTypeDef;

复制代码

我们发现，与标准库不同的是，该成员不仅:


2 l- Q) h& N3 l· 1、包含了之前标准库就有的六个成员（波特率，数据格式等），
· 2、还包含过采样、（发送或接收的）数据缓存、数据指针、串口 DMA 相关的变量、各种标志位等等要在整个项目流程中都要设置的各个成员。该UART1_Handler就被称为串口的句柄，它被贯穿整个USART收发的流程，比如开启中断：
, q4 R1 J6 F0 P8 d! [) V

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

复制代码

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

1. void HAL_UART_MspInit(UART_HandleTypeDef *huart);
   + u; [: R9 T& \3 Q' F! `/ H5 n
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

复制代码

在这些函数中，只需要调用初始化时定义的句柄UART1_Handler就好。
8 Q5 o# t+ `* j. |) l6 p9 U8 |+ \
' W7 [. I8 @6 w: s, j( `- o: M# w
$ V/ g* \" r& F+ T% B: Q9 e
02
/ k$ v% R; z& h+ w! x, A- f. I" W$ uMSP函数

# R' r/ _' i# oMSP: MCU Specific Package 单片机的具体方案
: V6 O6 H% Q9 J  r
8 e8 T; t+ ^5 [" d& ^' ^, mMSP是指和MCU相关的初始化，引用一下正点原子的解释，个人觉得说的很明白：我们要初始化一个串口，首先要设置和 MCU 无关的东西，例如波特率，奇偶校验，停止位等，这些参数设置和 MCU 没有任何关系，可以使用 STM32F1，也可以是 STM32F2/F3/F4/F7上的串口。而一个串口设备它需要一个 MCU 来承载，例如用 STM32F4 来做承载，PA9 做为发送，PA10 做为接收，MSP 就是要初始化 STM32F4 的 PA9,PA10，配置这两个引脚。所以 HAL驱动方式的初始化流程就是：
, K. U0 R: h2 U3 m8 W& v& ?! n& T
1 |' @/ S# C0 M6 o) W
$ I4 @0 y- v/ U4 VHAL_USART_Init()—>HAL_USART_MspInit() ，先初始化与 MCU无关的串口协议，再初始化与 MCU 相关的串口引脚。
; L/ Z; L: {0 Q1 h  H; N
: b; {6 B, h' {* Z( ?8 w+ B2 w' w
在 STM32 的 HAL 驱动中HAL_PPP_MspInit()作为回调，HAL_PPP_Init()函数所调用。当我们需要移植程序到 STM32F1平台的时候，我们只需要修改 HAL_PPP_MspInit 函数内容而不需要修改 HAL_PPP_Init 入口参数内容。
* ]7 k7 \8 I1 W在HAL库中，几乎每初始化一个外设就需要设置该外设与单片机之间的联系，比如IO口，是否复用等等，可见，HAL库相对于标准库多了MSP函数之后，移植性非常强，但与此同时却增加了代码量和代码的嵌套层级。可以说各有利弊。
同样，MSP函数又可以配合句柄，达到非常强的移植性：
5 h  I" W# C+ ^6 T" k- {9 z. e

1. void HAL_UART_MspInit(UART_HandleTypeDef *huart);

复制代码

入口参数仅仅需要一个串口句柄，这样就能看出句柄的方便。
, m, o9 v  [: Y5 `0 N# L
03
Callback函数

3 T+ _3 o6 k8 K( i: s
类似于MSP函数，个人认为Callback函数主要帮助用户应用层的代码编写。
& ?- h* F9 U+ d3 u1 D  U
8 x% i% f2 F/ ?+ d) J* ?+ Q  J
还是以USART为例，在标准库中，串口中断了以后，我们要先在中断中判断是否是接收中断，然后读出数据，顺便清除中断标志位，然后再是对数据的处理，这样如果我们在一个中断函数中写这么多代码，就会显得很混乱：
* L( S  s: s: A, n7 L

1. 
   
2. void USART3_IRQHandler(void)                //串口1中断服务程序
   
3. {
   
4. u8 Res;
   
5. if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
   
6. {
   . `! j( j* A# G& g% t# i1 h! w1 r
7. Res =USART_ReceiveData(USART3);//读取接收到的数据
   0 p1 V. Y) j; p
8. /*数据处理区*/
   3 M0 n+ Q" M* ?% R: e7 x( {; h
9. }   
   
10.      }
    ! {' q  ~, Q3 V4 q/ X
11. }
    % n8 r; I; |1 g9 G5 F

复制代码

而在HAL库中，进入串口中断后，直接由HAL库中断函数进行托管：
  n3 F" h2 q  {2 `+ O

1. 
   
2. void USART1_IRQHandler(void)               
   
3. {
   5 w( B- Z7 L( R: O1 u' [4 i+ e9 f
4. HAL_UART_IRQHandler(&UART1_Handler);//调用HAL库中断处理公用函数
   1 R0 \$ v9 J1 _$ @8 @
5. /***************省略无关代码****************/
   " ?! o2 s+ r; A- k' v
6. }

复制代码

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

1. 
   * M1 i% f3 [; W3 K* D' ^6 O
2. /*HAL库使用的串口接收缓冲,处理逻辑由HAL库控制，接收完这个数组就会调用HAL_UART_RxCpltCallback进行处理这个数组*/
   
3. /*RXBUFFERSIZE=5*/
   ' }& B9 o7 f% \; |  Z" Q/ O
4. u8 aRxBuffer[RXBUFFERSIZE];

复制代码

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

1. 
   " K; B0 h1 k- h- [# s* C
2. /*该代码在HAL_UART_Receive_IT函数中，初始化时会引用*/
   : y1 \' i( H& V
3. huart->pRxBuffPtr = pData;//aRxBuffer
   
4.     huart->RxXferSize = Size;//RXBUFFERSIZE
   
5.     huart->RxXferCount = Size;//RXBUFFERSIZE

复制代码

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

1. 
   
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

复制代码

在这个Callback回调函数中，我们只需要对这接收到的五个字节（保存在aRxBuffer[]中）进行处理就好了，完全不用再去手动清除标志位等操作。所以说Callback函数是一个应用层代码的函数，我们在一开始只设置句柄里面的各个参数，然后就等着HAL库把自己安排好的代码送到手中就可以了~

综上，就是HAL库的三个与标准库不同的地方之个人见解。个人觉得从这三个小点就可以看出HAL库的可移植性之强大，并且用户可以完全不去理会底层各个寄存器的操作，代码也更有逻辑性。但与此带来的是复杂的代码量，极慢的编译速度，略微低下的效率。看怎么取舍了。
4 m; b/ s: N1 u' s8 |/ f' s

04
4 u5 `7 o/ n& `8 k& {2 E6 aSTM32 HAL库结构
9 g' F. S/ ?( D% I8 b3 L: [- D
4 T4 w, m$ p3 i5 K; J1 w  V说到STM32的HAL库，就不得不提STM32CubeMX，其作为一个可视化的配置工具，对于开发者来说，确实大大节省了开发时间。STM32CubeMX就是以HAL库为基础的，且目前仅支持HAL库及LL库！首先看一下，官方给出的HAL库的包含结构：
3 m! Q! r6 Y, Y8 D. C

· 4.1 stm32f4xx.h主要包含STM32同系列芯片的不同具体型号的定义，是否使用HAL库等的定义，接着，其会根据定义的芯片信号包含具体的芯片型号的头文件：
' F. V8 B$ {) F

1. #if defined(STM32F405xx)
   6 q! `' J9 v) B, w- S& s
2.   #include "stm32f405xx.h"
   ! d& v, X. @: q
3. #elif defined(STM32F415xx)
   0 i, a3 O* b- X8 S. W0 l! ]
4.   #include "stm32f415xx.h"
   # b4 W+ {4 B5 `! V" o3 g
5. #elif defined(STM32F407xx)
   ' n2 e2 S( [8 R& b7 i! X
6.   #include "stm32f407xx.h"
   , \6 _# R# B9 [% t3 A( o% L/ f
7. #elif defined(STM32F417xx)
   
8.   #include "stm32f417xx.h"
   
9. #else
   
10. #error "Please select first the target STM32F4xx device used in your application (in stm32f2xx.h file)"
    
11. #endif

复制代码

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

6 {% t6 C: p+ f" N
6 L2 ?  _: Q. W& |: i· 4.2 stm32f4xx_hal.h：stm32f4xx_hal.c/h 主要实现HAL库的初始化、系统滴答相关函数、及CPU的调试模式配置

$ X# e! N1 h! C· 4.3 stm32f4xx_hal_conf.h：该文件是一个用户级别的配置文件，用来实现对HAL库的裁剪，其位于用户文件目录，不要放在库目录中。
0 s# N  ^$ L# O) U( E
接下来对于HAL库的源码文件进行一下说明，HAL库文件名均以stm32f4xx_hal开头，后面加上_外设或者模块名（如：stm32f4xx_hal_adc.c）：
$ ^! j, _/ X7 W( R

· 4.4 库文件


: u- \/ F4 H% E4 A# ?; cstm32f4xx_hal_ppp.c/.h // 主要的外设或者模块的驱动源文件，包含了该外设的通用API
* s; U9 l( b% H, G( O

& s1 e) [# ~) B# M, C4 ~stm32f4xx_hal_ppp_ex.c/.h // 外围设备或模块驱动程序的扩展文件。这组文件中包含特定型号或者系列的芯片的特殊API。以及如果该特定的芯片内部有不同的实现方式，则该文件中的特殊API将覆盖_ppp中的通用API
5 ]/ P: ]8 C  t. D, y
/ Y/ m6 o3 j( \5 |
0 k2 {) \" n, q: I$ Ostm32f4xx_hal.c/.h // 此文件用于HAL初始化，并且包含DBGMCU、重映射和基于systick的时间延迟等相关的API

· 4.5 其他库文件


; m2 ?2 p8 ~" ^/ V8 O用户级别文件：


stm32f4xx_hal_msp_template.c // 只有.c没有.h。它包含用户应用程序中使用的外设的MSP初始化和反初始化（主程序和回调函数）。使用者复制到自己目录下使用模板。

& X2 Y/ p! V3 V- Z  Z
stm32f4xx_hal_conf_template.h // 用户级别的库配置文件模板。使用者复制到自己目录下使用
7 R/ h/ M4 _. S) U% j
  ?' b8 f9 S6 x2 z4 M
system_stm32f4xx.c // 此文件主要包含SystemInit()函数，该函数在刚复位及跳到main之前的启动过程中被调用。 它不在启动时配置系统时钟（与标准库相反）。 时钟的配置在用户文件中使用HAL API来完成。
$ F) m! ?2 q: f

: k+ \+ ^, p# \startup_stm32f4xx.s // 芯片启动文件，主要包含堆栈定义，终端向量表等stm32f4xx_it.c/.h // 中断处理函数的相关实现
# c( m& w+ k4 r" B1 X5 S
" D/ ^) g6 f6 Z( l- l# U8 c· 4.6 main.c/.h //
) L5 A- k9 y1 L& ^
( j. r4 I- x& D* [
7 I; G8 c* _8 F. d' y1 V5 J根据HAL库的命名规则，其API可以分为以下三大类：


  Z5 `1 d  v3 g- Q7 h/ b. k· 初始化/反初始化函数：HAL_PPP_Init(), HAL_PPP_DeInit()
; w* x+ G4 p. U

7 V$ Z& F+ Y* f+ K4 o0 Y6 H8 `( Y· IO 操作函数：HAL_PPP_Read(), HAL_PPP_Write(),HAL_PPP_Transmit(), HAL_PPP_Receive()
/ w' k1 R, A5 @: y

· 控制函数：HAL_PPP_Set (), HAL_PPP_Get ().
  B' c) H% v7 E& g& p. E- t
( o* \' B0 w  {/ d
· 状态和错误: ** HAL_PPP_GetState (), HAL_PPP_GetError ().

) A  H, h' V8 }1 Y1 q+ J注意：目前LL库是和HAL库捆绑发布的，所以在HAL库源码中，还有一些名为 stm32f2xx_ll_ppp的源码文件，这些文件就是新增的LL库文件。
9 a; Q, L" {  a( b1 q1 X& C% R
使用CubeMX生产项目时，可以选择LL库 

" D6 A9 T; |) E! `8 dHAL库最大的特点就是对底层进行了抽象。在此结构下，用户代码的处理主要分为三部分：
9 |9 l1 O# }1 h  ?) v

9 ^5 [+ Z  P. p  i7 V$ x· 处理外设句柄（实现用户功能）
· 处理MSP
0 v3 ]* K& @; v& I4 P· 处理各种回调函数
7 s5 g! F- o/ \) p0 j8 t0 O$ a


  p: c6 s: t: Q: x# i相关知识如下：


· (1) 外设句柄定义  用户代码的第一大部分：对于外设句柄的处理。HAL库在结构上，对每个外设抽象成了一个称为ppp_HandleTypeDef的结构体，其中ppp就是每个外设的名字。*所有的函数都是工作在ppp_HandleTypeDef指针之下。  
& |. X; `! y/ [" l

1. 多实例支持：每个外设/模块实例都有自己的句柄。因此，实例资源是独立的 
6 ^% k- p# N5 ^2. 外围进程相互通信：该句柄用于管理进程例程之间的共享数据资源。下面，以ADC为例
9 e5 M) M9 I' n- r+ v

1. 
   3 v% X- K5 U" A) V4 C
2. /**
   + k  u# H+ v8 t! {6 y3 x! m# m
3. * @brief  ADC handle Structure definition
   , T" {. g5 w, Z7 v
4. */
   
5. typedef struct
   , m5 S1 [; Z' i
6. {
   
7.   ADC_TypeDef                   *Instance;                   /*!< Register base address */
   $ j. f7 C- f6 l! u( J% A$ [6 u2 _" B  b
8.   ADC_InitTypeDef               Init;                        /*!< ADC required parameters */
   
9.   __IO uint32_t                 NbrOfCurrentConversionRank;  /*!< ADC number of current conversion rank */
   . ?/ l3 H6 t& |9 X
10.   DMA_HandleTypeDef             *DMA_Handle;                 /*!< Pointer DMA Handler */
    4 [7 q1 H) ^. j- ?
11.   HAL_LockTypeDef               Lock;                        /*!< ADC locking object */
    * x" n( E4 o' u& q
12.   __IO uint32_t                 State;                       /*!< ADC communication state */
    
13.   __IO uint32_t                 ErrorCode;                   /*!< ADC Error code */
    / T* G7 f- t& j
14. }ADC_HandleTypeDef;

复制代码

从上面的定义可以看出，ADC_HandleTypeDef中包含了ADC可能出现的所有定义，对于用户想要使用ADC只要定义一个ADC_HandleTypeDef的变量，给每个变量赋好值，对应的外设就抽象完了。接下来就是具体使用了。  
当然，对于那些共享型外设或者说系统外设来说，他们不需要进行以上这样的抽象，这些部分与原来的标准外设库函数基本一样。例如以下外设：
. e& @- Q9 q+ z$ ]* E, b- GPIO 
: ]0 G  V2 z7 j$ z- SYSTICK  
- NVIC  
- E, S" P7 G$ Z  [* l! g! W- RCC  
- FLASH
( h  F8 F' q+ _& B以GPIO为例，对于HAL_GPIO_Init() 函数，其只需要GPIO 地址以及其初始化参数即可。
+ \8 o! I+ {8 E3 V

6 s' @7 u, p4 u- O· (2) 三种编程方式  HAL库对所有的函数模型也进行了统一。在HAL库中，支持三种编程模式：轮询模式、中断模式、DMA模式（如果外设支持）。其分别对应如下三种类型的函数（以ADC为例）：

1. 
   6 D4 Q* x9 a; |4 N. u
2. HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc);
   
3. HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc);
   
4. 
   
5. HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc);
   
6. HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc);
   5 k% J! m& J2 S( j3 B
7. 
   : \: i# A9 Q' ]% n6 c2 A  T/ \+ ~9 i
8. HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length);
   
9. HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc);

复制代码

其中，带_IT的表示工作在中断模式下；带_DMA的工作在DMA模式下（注意：DMA模式下也是开中断的）；什么都没带的就是轮询模式（没有开启中断的）。至于使用者使用何种方式，就看自己的选择了。  此外，新的HAL库架构下统一采用宏的形式对各种中断等进行配置（原来标准外设库一般都是各种函数）。针对每种外设主要由以下宏：
& {7 T4 ^4 D2 B, X4 T& _
4 ^) ^" F! M& f7 D* p! {
, [" O. X1 U- n6 o' t  B$ ]: U__HAL_PPP_ENABLE_IT(HANDLE, INTERRUPT)： 使能一个指定的外设中断
__HAL_PPP_DISABLE_IT(HANDLE, INTERRUPT)：失能一个指定的外设中断
__HAL_PPP_GET_IT (HANDLE, __ INTERRUPT __)：获得一个指定的外设中断状态
$ @1 ?6 L. p1 e0 Q1 @2 O__HAL_PPP_CLEAR_IT (HANDLE, __ INTERRUPT __)：清除一个指定的外设的中断状态
__HAL_PPP_GET_FLAG (HANDLE, FLAG)：获取一个指定的外设的标志状态
6 Z. z. I( f. {; p& \" Y9 G8 X: S__HAL_PPP_CLEAR_FLAG (HANDLE, FLAG)：清除一个指定的外设的标志状态
7 K7 P& H# t4 y+ L__HAL_PPP_ENABLE(HANDLE) ：使能外设__HAL_PPP_DISABLE(HANDLE) ：失能外设
2 k- e$ T# u" f5 t- }. \) H__HAL_PPP_XXXX (HANDLE, PARAM) ：指定外设的宏定义
_HAL_PPP_GET IT_SOURCE (HANDLE, __ INTERRUPT __)：检查中断源
# }- q  Y6 ?! g4 u' V( z
( S: u8 A) g4 [+ b! ]' p6 T% \5 r
- N" Y7 \8 V! v· （3）三大回调函数  在HAL库的源码中，到处可见一些以__weak开头的函数，而且这些函数，有些已经被实现了，比如：

9 w) I2 v9 h" b! p( d1 I3 l

1. 
   
2. __weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
   1 S. K8 H( \, y
3. {
   6 ^7 T7 d, ]1 v' c! D0 `$ V2 l- l
4.   /*Configure the SysTick to have interrupt in 1ms time basis*/
   0 s" a7 H0 x: g# ?
5.   HAL_SYSTICK_Config(SystemCoreClock/1000U);
   
6.   /*Configure the SysTick IRQ priority */
   
7.   HAL_NVIC_SetPriority(SysTick_IRQn, TickPriority ,0U);
     J/ N2 o, R+ j) @
8.   /* Return function status */
   
9.   return HAL_OK;
   % \/ l/ _; |, f# ]- z4 z
10. }

复制代码

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

1. 
   / {! l( Q- s% n: H% f& q- X
2. __weak void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
   ! f9 D  [! f/ h) |! f
3. {
   
4.   /* Prevent unused argument(s) compilation warning */
   
5.   UNUSED(hspi);
   
6.   /* NOTE : This function should not be modified, when the callback is needed,the HAL_SPI_TxCpltCallback should be implemented in the user file
   ; ^$ w& @/ W1 s2 [3 C) M2 H
7.   */
   
8. }

复制代码

所有带有__weak关键字的函数表示，就可以由用户自己来实现。如果出现了同名函数，且不带__weak关键字，那么连接器就会采用外部实现的同名函数。通常来说，HAL库负责整个处理和MCU外设的处理逻辑，并将必要部分以回调函数的形式给出到用户，用户只需要在对应的回调函数中做修改即可。HAL库包含如下三种用户级别回调函数（PPP为外设名）：
+ P7 G  M. @( N* G1 ~/ C+ ]
9 @3 Q- V: }' [
) V+ m$ i& J& `% Q. a8 Q1. 外设系统级初始化/解除初始化回调函数（用户代码的第二大部分：对于MSP的处理）：
0 m) h6 ?, }5 e9 r4 _HAL_PPP_MspInit()和 HAL_PPP_MspDeInit** 例如：__weak void
HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)。在HAL_PPP_Init() 函数中被调用，用来初始化底层相关的设备（GPIOs, clock, DMA, interrupt）


- L/ y; B2 O# M$ c# [8 k2 M( L( Y2.处理完成回调函数：HAL_PPP_ProcessCpltCallback*（Process指具体某种处理，如UART的Tx），例如：__weak void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)。当外设或者DMA工作完成后时，触发中断，该回调函数会在外设中断处理函数或者DMA的中断处理函数中被调用

0 A5 b& U' T& g, i
. N( R$ W$ v0 C1 ^* |8 r% O3.错误处理回调函数：HAL_PPP_ErrorCallback例如：__weak void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)**。当外设或者DMA出现错误时，触发终端，该回调函数会在外设中断处理函数或者DMA的中断处理函数中被调用
, G: U5 @/ K  m3 j

0 b) k( @6 @% ^: g. G绝大多数用户代码均在以上三大回调函数中实现。


HAL库结构中，在每次初始化前（尤其是在多次调用初始化前），先调用对应的反初始化（DeInit）函数是非常有必要的。
- E2 [- W! d2 i8 a3 ]5 O某些外设多次初始化时不调用返回会导致初始化失败。完成回调函数有多种，例如串口的完成回调函数有HAL_UART_TxCpltCallback 和 HAL_UART_TxHalfCpltCallback等（用户代码的第三大部分：对于上面第二点和第三点的各种回调函数的处理）在实际使用中，发现HAL仍有不少问题，例如在使用USB时，其库配置存在问题
; u) ]3 W& {/ U8 U; V  D4 D9 E
/ z4 ~! ?9 n% O/ _( r+ D' W, M05
HAL库移植使用
% u1 q9 M% y- w# [
; z  f, G; w  W4 G4 V3 Y" Z! ]
基本步骤
( ]' t3 X# \' U0 L7 l4 _5 Y4 u1 W
* a6 _4 _9 a- H2 Z$ X' |% ~2 b
1.复制stm32f2xx_hal_msp_template.c，参照该模板，依次实现用到的外设的HAL_PPP_MspInit()和 HAL_PPP_MspDeInit。
9 R6 e8 |5 s) A* y( h; ?  k0 X
# t6 i* @. e- E
2.复制stm32f2xx_hal_conf_template.h，用户可以在此文件中自由裁剪，配置HAL库。

5 `1 x. |) J. E* ~
7 h: r0 ?" f/ ?' H+ g7 L3.在使用HAL库时，必须先调用函数：HAL_StatusTypeDef HAL_Init(void)（该函数在stm32f2xx_hal.c中定义，也就意味着第一点中，必须首先实现HAL_MspInit(void)和HAL_MspDeInit(void)）
5 y- x) @% g% H1 \/ L7 y
' ^0 @2 S! s* H: u# K; S
1 U" b& c2 ?0 i, p- O4.HAL库与STD库不同，HAL库使用RCC中的函数来配置系统时钟，用户需要单独写时钟配置函数（STD库默认在system_stm32f2xx.c中）
" l& M: U2 B9 Q5 w5 F7 I  x
  J0 Z6 z, c. |
5.关于中断，HAL提供了中断处理函数，只需要调用HAL提供的中断处理函数。用户自己的代码，不建议先写到中断中，而应该写到HAL提供的回调函数中。

5 t6 y" d0 s3 E7 c$ G: J2 r8 S
6.对于每一个外设，HAL都提供了回调函数，回调函数用来实现用户自己的代码。整个调用结构由HAL库自己完成。例如：Uart中，HAL提供了void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);函数，用户只需要触发中断后，用户只需要调用该函数即可，同时，自己的代码写在对应的回调函数中即可！如下：

1. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
   
2. void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);
   
3. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
   0 C: K, C1 F) a- d% Q( `' O% U  d
4. void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);
   ! u+ G7 T8 R" [) f' p3 H% i( U1 b0 L" D
5. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);

复制代码

使用了哪种就用哪个回调函数即可！
3 D$ J, L7 l4 T- L3 S! Q9 }0 }7 g( e5 S* O

* P3 A* T  n& \基本结构 
综上所述，使用HAL库编写程序（针对某个外设）的基本结构（以串口为例）如下：
$ O# H% K2 a' F/ x. N2 n

9 H8 P* v* D6 c5 V+ a% }% B1.配置外设句柄 例如，建立UartConfig.c，在其中定义串口句柄 UART_HandleTypeDef huart;，接着使用初始化句柄(HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef huart))


2.编写Msp 例如，建立UartMsp.c，在其中实现void HAL_UART_MspInit(UART_HandleTypeDef huart) 和 void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)


3.实现对应的回调函数 例如，建立UartCallBack.c，在其中实现上文所说明的三大回调函数中的完成回调函数和错误回调函数



) ^+ U7 r- p( x% Q6 G

( e3 V# s2 F( t1 s, i! u
% w3 g: U, L& S6 N, W

支持一下！！！！！

提笔画夕游 发表于 2021-9-14 08:34
支持一下！！！！！

& o8 F' |( p6 x. D5 X# M8 s感谢支持！
$ G5 \6 V) N' f" h) e1 ~  i& l) X1 ~