1 STM32的三种开发方式
* B/ d$ Y! b) R/ f! u4 |3 A4 A1 V

通常新手在入门STM32的时候，首先都要先选择一种要用的开发方式，不同的开发方式会导致你编程的架构是完全不一样的。一般大多数都会选用标准库和HAL库，而极少部分人会通过直接配置寄存器进行开发。网上关于标准库、HAL库的描述相信是数不胜数。可是一个对于很多刚入门的朋友还是没法很直观的去真正了解这些不同开发发方式彼此之间的区别，所以笔者想以一种非常直白的方式，用自己的理解去将这些东西表述出来，如果有描述的不对的地方或者是不同意见的也可以大家提出。

& O; Z/ [! s6 g6 D6 E

) g/ e4 Y9 P1 c+ }

一、直接配置寄存器

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

* f! N) }: N! }! q8 h/ [" R

4 w# T5 L+ k& f" d9 `+ w4 v

二、标准库

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

* G) Q7 k8 X4 T. p# ^4 b& ]

9 v  {% y) |* E0 `, S1 p

三、HAL库

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

$ p: g0 {% n- r0 B/ T

2 HAL库固件库安装与 用户手册

1.首先设置让Cube可以自动联网下载相关固件库

选择updater Settings

% s/ k" I* l9 s! ^

设置如下

$ J+ V/ ?7 o0 b; i) i" S

2.根据芯片选择所需固件

0 [' S1 ]: U. v8 L2 ]

版本是向下兼容的，可以直接选择最新版。但如果觉得最新版太大，可以阅读下面的Main Changes.能够支持你目前的芯片就好。

9 C# F! g6 L+ ^* P, s' c

# X: s8 z: f$ W
5 N: ]- z( {& |. Q# ^( U" a

选好了，点击Install Now就行，过程可能有点长。建议直接官网下载到本地，再安装

文件会被下载到如下位置，建议更改此目录，不要选在C盘！！！

: G& j7 Y" S4 l/ o5 W

$ V3 j: \9 Z3 o% X, L( l; F查找帮助手册
+ q8 Y& i1 ~( _9 v5 k% Q! l

3.寻找用户帮助手册

进入固件所在文件夹，里面包含很多内容。

# A) ]6 s$ f* ]9 I0 p% b' s
比如说 官方提供的开发板程序
4 B( A3 Q1 r& V

, G  B( l/ K1 I7 \* y1 I) w

每个型号下面都有对应功能的实现

: ?" ]3 k4 k# r0 x0 `

用户手册就在Drivers文件夹下面。

% w* |' |) U5 K8 P0 w9 X  w8 P# W

3 STM32 HAL库与标准库的区别_浅谈句柄、MSP函数、Callback函数3.1.句柄

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

• 第一种解释：句柄是一种特殊的智能指针 。当一个应用程序要引用其他系统（如数据库、操作系统）所管理的内存块或对象时，就要使用句柄。
• 第二种解释：整个Windows编程的基础。一个句柄是指使用的一个唯一的整数值，即一个4字节(64位程序中为8字节)长的数值，来标识应用程序中的不同对象和同类中的不同的实例，诸如，一个窗口，按钮，图标，滚动条，输出设备，控件或者文件等。应用程序能够通过句柄访问相应的对象的信息，但是句柄不是指针，程序不能利用句柄来直接阅读文件中的信息。如果句柄不在I/O文件中，它是毫无用处的。 句柄是Windows用来标志应用程序中建立的或是使用的唯一整数，Windows大量使用了句柄来标识对象。
  - K9 y, D$ m  E( n! W' A6 @; X3 k* ?
  8 ?( Q0 ]4 E3 a4 f4 H3 x0 n5 k

1 O3 R( S3 I" ~

STM32的标准库中，句柄是一种特殊的指针，通常指向结构体！

; ]- G+ `. N4 _. A# d6 p1 E7 y

在STM32的标准库中，假设我们要初始化一个外设（这里以USART为例），我们首先要初始化他们的各个寄存器。在标准库中，这些操作都是利用固件库结构体变量+固件库Init函数实现的：

1. USART_InitTypeDef USART_InitStructure;
   0 n. {5 J3 R* W6 i& x
2. 
   
3. USART_InitStructure.USART_BaudRate = bound;//串口波特率
   8 c: {9 ^2 R( }- s
4. USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
   
5. USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
   
6. USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
   0 [) G4 w# Z/ b& `- j0 j. p. ^5 W" T
7. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
   
8. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
   3 v8 w5 n& u. Q1 |1 |
9. 
   & u* }5 u" N1 r4 A9 I  r
10. USART_Init(USART3, &USART_InitStructure); //初始化串口1

复制代码

- S, e& P6 D/ d) r3 \; k

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

• 1、对六个位置进行赋值，
• 2、然后引用Init函数，
  , R# }$ @/ b$ ^( x6 p4 F! |
  : y1 A5 L0 z: o: `# K$ U

% k, `* V. f' w! o
& ?: H% D5 A* f: G( [2 ]* D

USART_InitStructure并不是一个全局结构体变量，而是只在函数内部的局部变量，初始化完成之后，USART_InitStructure就失去了作用。

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

1. UART_HandleTypeDef UART1_Handler;

复制代码

$ p7 B8 I$ @7 \, G8 r, G' D

右键查看结构体成员

3 P6 y% H: |/ C' g, e% X

1. typedef struct
   - o; E4 G5 E+ s: k) G' K+ K* D( ?, |: A. Q) _
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              */
   
7.           uint16_t                      TxXferCount;      /*!< UART Tx Transfer Counter           */
   % m4 j5 D" N8 I. p! a% I& r2 B. d
8.           uint8_t                       *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
   
9.           uint16_t                      RxXferSize;       /*!< UART Rx Transfer size              */
   
10.           uint16_t                      RxXferCount;      /*!< UART Rx Transfer Counter           */  
    
11.           DMA_HandleTypeDef             *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    / F' H; m+ L' h* {. Q
12.           DMA_HandleTypeDef             *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    / _/ j9 B& }9 |0 s: a' B$ w% a0 C
13.           HAL_LockTypeDef               Lock;             /*!< Locking object                     */
    ( L/ B! g; @& d  |, z1 C: g
14.           __IO HAL_UART_StateTypeDef    State;            /*!< UART communication state           */
      p4 v+ O# G& s) t6 `
15.           __IO uint32_t                 ErrorCode;        /*!< UART Error code                    */
    
16. }UART_HandleTypeDef;

复制代码

0 G5 |5 G6 f3 c- v/ I
0 o7 B! l5 \0 U7 T, C' P
7 ?- G6 ~5 I9 R: ~% ?

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

• 1、包含了之前标准库就有的六个成员（波特率，数据格式等），
• 2、还包含过采样、（发送或接收的）数据缓存、数据指针、串口 DMA 相关的变量、各种标志位等等要在整个项目流程中都要设置的各个成员。
  ; [$ G* v) |! M& Y. I; s+ G

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

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

1. void HAL_UART_MspInit(UART_HandleTypeDef *huart);
   7 P7 k9 g& Y/ Y' u! D
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

复制代码

5 S& R; [' @" O/ M6 M

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

3.2.MSP函数
! M/ h9 f& ]* h; p% V3 L5 T& M- _

MSP: MCU Specific Package 单片机的具体方案

1 ?/ v$ J7 G$ D

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

6 b! U9 C8 H' S( I! h3 u( h1 W) K

我们要初始化一个串口，首先要设置和 MCU 无关的东西，例如波特率，奇偶校验，停止
' x, S* M4 y1 c位等，这些参数设置和 MCU 没有任何关系，可以使用 STM32F1，也可以是 STM32F2/F3/F4/F7
上的串口。而一个串口设备它需要一个 MCU 来承载，例如用 STM32F4 来做承载，PA9 做为发
送，PA10 做为接收，MSP 就是要初始化 STM32F4 的 PA9,PA10，配置这两个引脚。所以 HAL
# Q' \8 l. p3 p  d! T驱动方式的初始化流程就是：

HAL_USART_Init()—>HAL_USART_MspInit() ，先初始化与 MCU无关的串口协议，再初始化与 MCU 相关的串口引脚。

在 STM32 的 HAL 驱动中HAL_PPP_MspInit()作为回调，被 HAL_PPP_Init()函数所调用。当我们需要移植程序到 STM32F1平台的时候，我们只需要修改 HAL_PPP_MspInit 函数内容而不需要修改 HAL_PPP_Init 入口参数内容。

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

; L  ]4 h: k6 E  K0 h+ W

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

1. void HAL_UART_MspInit(UART_HandleTypeDef *huart);

复制代码

: k- T2 I1 D7 i0 u

入口参数仅仅需要一个串口句柄，这样有能看出句柄的方便。

3.3.Callback函数

类似于MSP函数，个人认为Callback函数主要帮助用户应用层的代码编写。

还是以USART为例，在标准库中，串口中断了以后，我们要先在中断中判断是否是接收中断，然后读出数据，顺便清除中断标志位，然后再是对数据的处理，这样如果我们在一个中断函数中写这么多代码，就会显得很混乱：

1. void USART3_IRQHandler(void)                        //串口1中断服务程序
   % t3 p' o9 N9 g: p- K
2. {
   5 e6 M# A& L2 D0 `; v
3.         u8 Res;
   
4.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
   - [- A) o  n, J
5.         {
   
6.                 Res =USART_ReceiveData(USART3);        //读取接收到的数据
   0 l; n) Z" Z) i0 k9 U
7.                 /*数据处理区*/
   
8.                 }                    
   
9.      }
   
10. }
    

复制代码

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

1. <span style="color: rgb(0, 0, 0); font-family: &quot;Source Code Pro&quot;, &quot;DejaVu Sans Mono&quot;, &quot;Ubuntu Mono&quot;, &quot;Anonymous Pro&quot;, &quot;Droid Sans Mono&quot;, Menlo, Monaco, Consolas, Inconsolata, Courier, monospace, &quot;PingFang SC&quot;, &quot;Microsoft YaHei&quot;, sans-serif; font-variant-ligatures: common-ligatures; white-space: pre; background-color: rgb(250, 250, 250);">void USART1_IRQHandler(void)                        
   
2. {
   
3.         HAL_UART_IRQHandler(&UART1_Handler);        //调用HAL库中断处理公用函数
   
4.         /***************省略无关代码****************/        
   
5. }</span>

复制代码

HAL_UART_IRQHandler这个函数完成了判断是哪个中断（接收？发送？或者其他？），然后读出数据，保存至缓存区，顺便清除中断标志位等等操作。

+ n% w% J2 u- e- S- u. `! V; b比如我提前设置了，串口每接收五个字节，我就要对这五个字节进行处理。

8 S* T+ h- P2 n  ]  a! r; x4 e8 B在一开始我定义了一个串口接收缓存区：

+ O+ B- [) T( q( W3 M! q( `' Q

1. /*HAL库使用的串口接收缓冲,处理逻辑由HAL库控制，接收完这个数组就会调用HAL_UART_RxCpltCallback进行处理这个数组*/
   * n+ A1 V7 a4 s9 U
2. /*RXBUFFERSIZE=5*/
   7 A. v8 w* {" @# H5 _) l; R2 Y3 @
3. u8 aRxBuffer[RXBUFFERSIZE];

复制代码

) ~: h; p8 M9 x" G: m4 t& E

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

( Z$ v0 a+ G1 f  w" \

1. /*该代码在HAL_UART_Receive_IT函数中，初始化时会引用*/
     E) d- J" S, m, N& U. y
2.         huart->pRxBuffPtr = pData;//aRxBuffer
   9 m" z# m' y" s/ d- W0 O$ L
3.     huart->RxXferSize = Size;//RXBUFFERSIZE
   " K: G1 y* Z: U+ o
4.     huart->RxXferCount = Size;//RXBUFFERSIZE

复制代码

" L4 q4 [- K* {& g- J8 h  Q+ _# c5 E

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

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

复制代码

8 t$ s5 _  e; r: p

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

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

! I" u% v& \. d

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

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

+ K2 K* t2 S$ y9 b0 i! B* {. V# h* `

4 STM32 HAL库结构

# Z8 m/ O6 f1 H, G+ a9 H

说到STM32的HAL库，就不得不提STM32CubeMX，其作为一个可视化的配置工具，对于开发者来说，确实大大节省了开发时间。STM32CubeMX就是以HAL库为基础的，且目前仅支持HAL库及LL库！首先看一下，官方给出的HAL库的包含结构：

5 n, s, }! q) H

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

1. #if defined(STM32F405xx)
   
2.   #include "stm32f405xx.h"
   
3. #elif defined(STM32F415xx)
   
4.   #include "stm32f415xx.h"
   1 M3 V3 l# D7 E# z( U0 _
5. #elif defined(STM32F407xx)
   5 r1 Q% \7 d0 e. V# r
6.   #include "stm32f407xx.h"
   # ?8 a; ^; G9 W$ k
7. #elif defined(STM32F417xx)
   
8.   #include "stm32f417xx.h"
   
9. #else
   6 X# P$ t* f+ l" g
10. #error "Please select first the target STM32F4xx device used in your application (in stm32f2xx.h file)"
    & }9 n7 ]! P- N5 i
11. #endif

复制代码

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

$ o1 b! F1 Y9 C: a' T6 ~

• 2、stm32f4xx_hal.h：stm32f4xx_hal.c/h 主要实现HAL库的初始化、系统滴答相关函数、及CPU的调试模式配置
• 3、stm32f4xx_hal_conf.h ：该文件是一个用户级别的配置文件，用来实现对HAL库的裁剪，其位于用户文件目录，不要放在库目录中。
  ; U# G: A, T# q' l: r3 Y
  % p6 c$ P' ^/ j: f4 d; ]" @: N

  ~" P  Q! F) ^1 S7 P/ ]
! B: m4 }3 m/ [5 R. e

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

' Z& h1 F- S4 |8 j2 c0 W+ i. v' M

• 4、库文件：
  9 v7 [) X( A5 ~$ p% i$ Q5 Astm32f4xx_hal_ppp.c/.h // 主要的外设或者模块的驱动源文件，包含了该外设的通用API
  stm32f4xx_hal_ppp_ex.c/.h // 外围设备或模块驱动程序的扩展文件。这组文件中包含特定型号或者系列的芯片的特殊API。以及如果该特定的芯片内部有不同的实现方式，则该文件中的特殊API将覆盖_ppp中的通用API。
  stm32f4xx_hal.c/.h // 此文件用于HAL初始化，并且包含DBGMCU、重映射和基于systick的时间延迟等相关的API
  

• 5、其他库文件
  用户级别文件：
  stm32f4xx_hal_msp_template.c // 只有.c没有.h。它包含用户应用程序中使用的外设的MSP初始化和反初始化（主程序和回调函数）。使用者复制到自己目录下使用模板。
  stm32f4xx_hal_conf_template.h // 用户级别的库配置文件模板。使用者复制到自己目录下使用
  ) {& e+ w# {. ^: K; J7 }system_stm32f4xx.c // 此文件主要包含SystemInit()函数，该函数在刚复位及跳到main之前的启动过程中被调用。 它不在启动时配置系统时钟（与标准库相反）。 时钟的配置在用户文件中使用HAL API来完成。
  5 U( g9 C5 S* tstartup_stm32f4xx.s // 芯片启动文件，主要包含堆栈定义，终端向量表等
  stm32f4xx_it.c/.h // 中断处理函数的相关实现
  

5 x! [, m! i: ~# H
4 Q. |" r; x8 E8 h

• 6 main.c/.h //
  ! h1 N& o- }) C
  

' v* q. ]1 W$ ]) a) E3 k
1 k' t( i# P, }; {

根据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 ().
  3 p6 r3 F- y$ t9 X5 c
  

注意：

目前LL库是和HAL库捆绑发布的，所以在HAL库源码中，还有一些名为 stm32f2xx_ll_ppp的源码文件，这些文件就是新增的LL库文件。

使用CubeMX生产项目时，可以选择LL库
    
4 C2 {- A! X4 h" U3 A    HAL库最大的特点就是对底层进行了抽象。在此结构下，用户代码的处理主要分为三部分：

• 处理外设句柄（实现用户功能）
• 处理MSP
• 处理各种回调函数
  
  

相关知识如下：

• (1) 外设句柄定义
    用户代码的第一大部分：对于外设句柄的处理。 HAL库在结构上，对每个外设抽象成了一个称为ppp_HandleTypeDef的结构体，其中ppp就是每个外设的名字。*所有的函数都是工作在ppp_HandleTypeDef指针之下。
  . |5 E  _. @7 j, U, u$ C  1. 多实例支持：每个外设/模块实例都有自己的句柄。 因此，实例资源是独立的
    2. 外围进程相互通信：该句柄用于管理进程例程之间的共享数据资源。
  下面，以ADC为例
  

1. /**
   & _9 ^! Y2 p8 @0 b( n# `& o
2. * @brief  ADC handle Structure definition
   % M  T" F/ |$ Q  a% a' W4 k9 ~! ?% y
3. */
   
4. typedef struct
   7 Z; q1 ^/ y4 ?
5. {
   ! Y' m2 O2 Y3 F2 k# M: p. X
6.         ADC_TypeDef                   *Instance;                   /*!< Register base address */
   
7.         ADC_InitTypeDef               Init;                        /*!< ADC required parameters */
   / {: x) X/ F" t$ d$ P
8.   __IO uint32_t                 NbrOfCurrentConversionRank;  /*!< ADC number of current conversion rank */
   $ j5 _# b# g9 ?0 t) s) a
9.         DMA_HandleTypeDef             *DMA_Handle;                 /*!< Pointer DMA Handler */
   5 R# A: ]2 b( M
10.         HAL_LockTypeDef               Lock;                        /*!< ADC locking object */
    1 f! x6 l6 n4 ?) I4 o+ \' s% v5 |5 R% m
11.         __IO uint32_t                 State;                       /*!< ADC communication state */
    : A' p: s1 L$ j0 l% i2 a  N
12.         __IO uint32_t                 ErrorCode;                   /*!< ADC Error code */
    
13. }ADC_HandleTypeDef;

复制代码

, L" p6 w3 \4 I5 u, p# w0 k

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

: d9 U% _  v4 y* b4 z: q  当然，对于那些共享型外设或者说系统外设来说，他们不需要进行以上这样的抽象，这些部分与原来的标准外设库函数基本一样。例如以下外设：
+ I* n9 W5 u/ |  - GPIO
! P! v7 B( y4 H# n  - SYSTICK
  - NVIC
  - RCC
0 D. M5 _. r# d8 e7 }  - FLASH
以GPIO为例，对于HAL_GPIO_Init() 函数，其只需要GPIO 地址以及其初始化参数即可。

% g6 J# |' G! i8 g3 x( G6 i' f  M

(2) 三种编程方式

* C2 C# o2 X/ U+ [# H& N  HAL库对所有的函数模型也进行了统一。在HAL库中，支持三种编程模式：轮询模式、中断模式、DMA模式（如果外设支持）。其分别对应如下三种类型的函数（以ADC为例）：

& j3 s+ R7 E; j2 ~3 Y

1. HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc);
   
2. HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc);
   
3. 
   & b* f' S( Z: g& E! a
4. HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc);
   
5. HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc);
   5 w  q( W  _8 {: D+ p1 y) s
6. 
   4 v, F1 G2 ^" w/ n$ e0 Q
7. HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length);
   * m4 t+ e* n6 p  }
8. HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc);

复制代码

2 `( l* q# l, z7 j' q. S* E& P其中，带_IT的表示工作在中断模式下；带_DMA的工作在DMA模式下（注意：DMA模式下也是开中断的）；什么都没带的就是轮询模式（没有开启中断的）。至于使用者使用何种方式，就看自己的选择了。
  

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

! r/ h/ H$ ]5 D, l2 ^

__HAL_PPP_ENABLE_IT(HANDLE, INTERRUPT)： 使能一个指定的外设中断
# c1 h" m3 a" x: i__HAL_PPP_DISABLE_IT(HANDLE, INTERRUPT)：失能一个指定的外设中断
__HAL_PPP_GET_IT (HANDLE, __ INTERRUPT __)：获得一个指定的外设中断状态
__HAL_PPP_CLEAR_IT (HANDLE, __ INTERRUPT __)：清除一个指定的外设的中断状态
7 `. b  r5 J0 Z2 W" W# g__HAL_PPP_GET_FLAG (HANDLE, FLAG)：获取一个指定的外设的标志状态
# Z9 |' @) b8 n4 ^__HAL_PPP_CLEAR_FLAG (HANDLE, FLAG)：清除一个指定的外设的标志状态
% W0 n4 G9 G2 t# I) ]7 ]+ S  u__HAL_PPP_ENABLE(HANDLE) ：使能外设
6 Z1 I6 e: q& c; E, q, F; e4 K__HAL_PPP_DISABLE(HANDLE) ：失能外设
__HAL_PPP_XXXX (HANDLE, PARAM) ：指定外设的宏定义
8 i" |1 h, _# h4 |& r_HAL_PPP_GET IT_SOURCE (HANDLE, __ INTERRUPT __)：检查中断源

  K: i+ C: J/ ]

（3）三大回调函数

2 f% y4 u9 `7 K# I6 H  在HAL库的源码中，到处可见一些以__weak开头的函数，而且这些函数，有些已经被实现了，比如：

1. __weak HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
   * z  H* h) Z0 J& @# v6 Q
2. {
   
3.         /*Configure the SysTick to have interrupt in 1ms time basis*/
   
4.         HAL_SYSTICK_Config(SystemCoreClock/1000U);
     \" A& f9 d' ~- X. |2 f2 B; a
5.         /*Configure the SysTick IRQ priority */
   * @9 V0 U0 _0 {& E, e. `) J6 z
6.         HAL_NVIC_SetPriority(SysTick_IRQn, TickPriority ,0U);
   
7.         /* Return function status */
   
8.         return HAL_OK;
   
9. }

复制代码

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

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

1. 外设系统级初始化/解除初始化回调函数（用户代码的第二大部分：对于MSP的处理）：HAL_PPP_MspInit()和 HAL_PPP_MspDeInit** 例如：__weak void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)。在HAL_PPP_Init() 函数中被调用，用来初始化底层相关的设备（GPIOs, clock, DMA, interrupt）
2.处理完成回调函数：HAL_PPP_ProcessCpltCallback*（Process指具体某种处理，如UART的Tx），例如：__weak void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)。当外设或者DMA工作完成后时，触发中断，该回调函数会在外设中断处理函数或者DMA的中断处理函数中被调用
, d% m( f3 z  K9 T) u0 W( P: n- ~
6 [  C- ~& [/ P8 f
; P" c" w5 t9 r3.错误处理回调函数：HAL_PPP_ErrorCallback例如：__weak void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)**。当外设或者DMA出现错误时，触发终端，该回调函数会在外设中断处理函数或者DMA的中断处理函数中被调用

绝大多数用户代码均在以上三大回调函数中实现。

: ^: b3 \0 o2 q2 h$ }9 R

HAL库结构中，在每次初始化前（尤其是在多次调用初始化前），先调用对应的反初始化（DeInit）函数是非常有必要的。

5 F' n! B! C$ h# ?+ Q某些外设多次初始化时不调用返回会导致初始化失败。完成回调函数有多中，例如串口的完成回调函数有HAL_UART_TxCpltCallback 和 HAL_UART_TxHalfCpltCallback等
  I" }% ^: K7 f0 {  u（用户代码的第三大部分：对于上面第二点和第三点的各种回调函数的处理）
* e* o9 a- k1 A# Y8 h) j4 ?' f在实际使用中，发现HAL仍有不少问题，例如在使用USB时，其库配置存在问题

5 HAL库移植使用

基本步骤

, {& e8 X' u, K5 o  Y! g1 }# a3 v2 x1.复制stm32f2xx_hal_msp_template.c，参照该模板，依次实现用到的外设的HAL_PPP_MspInit()和 HAL_PPP_MspDeInit。
' w# X0 i+ _$ I& K. z+ A2.复制stm32f2xx_hal_conf_template.h，用户可以在此文件中自由裁剪，配置HAL库。
- L$ S! H+ d" J6 M- H: w( d3.在使用HAL库时，必须先调用函数：HAL_StatusTypeDef HAL_Init(void)（该函数在stm32f2xx_hal.c中定义，也就意味着第一点中，必须首先实现HAL_MspInit(void)和HAL_MspDeInit(void)）
& D; l0 _2 \6 X4.HAL库与STD库不同，HAL库使用RCC中的函数来配置系统时钟，用户需要单独写时钟配置函数（STD库默认在system_stm32f2xx.c中）
5.关于中断，HAL提供了中断处理函数，只需要调用HAL提供的中断处理函数。用户自己的代码，不建议先写到中断中，而应该写到HAL提供的回调函数中。
6.对于每一个外设，HAL都提供了回调函数，回调函数用来实现用户自己的代码。整个调用结构由HAL库自己完成。例如：Uart中，HAL提供了void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);函数，用户只需要触发中断后，用户只需要调用该函数即可，同时，自己的代码写在对应的回调函数中即可！如下：

8 q2 x) n. O" m" [

1. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
   
2. void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);
   : l( O- ^% ~; V. w. ]
3. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
   
4. void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);
   $ B6 o4 F9 n1 [% \9 L' R
5. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);

复制代码

4 {& d6 m, ^$ y5 w; ^$ o
7 G$ p/ `8 k) e' ~* \) s" s

使用了哪种就用哪个回调函数即可！

$ b- L- |& _  ~

基本结构

/ l9 Y. ]% a0 c# o& F# c  综上所述，使用HAL库编写程序（针对某个外设）的基本结构（以串口为例）如下：

1, 配置外设句柄 例如，建立UartConfig.c，在其中定义串口句柄 UART_HandleTypeDef huart;，接着使用初始化句柄(HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef huart))

" N# S1 R- z  v! F- H2 W2,编写Msp 例如，建立UartMsp.c，在其中实现void HAL_UART_MspInit(UART_HandleTypeDef huart) 和 void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)

6 ~; }# R" ]& r& ^; e. N3 d9 ?3,实现对应的回调函数 例如，建立UartCallBack.c，在其中实现上文所说明的三大回调函数中的完成回调函数和错误回调函数

+ O7 n5 P+ `3 N! p2 W" Y


; \3 D3 s: S' ?3 k4 _
% P& G, c) @1 f' y$ T9 I