STM32Cube固件包
$ N2 |2 i! L+ [9 H6 U; {第四章我们通过STM32CubeIDE在线下载了一个STM32Cube固件包，STM32CubeMX插件就是利用这个固件包来生成初始化代码的，大家肯定好奇这个固件包里有什么？是做什么用的？和HAL库有什么关系？本章节我们就来分析这个固件包。
本章将分为如下几个小节：

6.1 获取STM32Cube固件包
6 q( ^0 S0 q& {2 T% o/ T4 Y% ZSTM32Cube是ST公司提供的一套免费的开发工具和STM32Cube 固件包，覆盖了整个STM32产品，可在STM32平台上进行快速轻松的开发，从而简化了开发人员的工作。STM32Cube由以下组件组成，这些组件可以一起使用或独立使用：
允许用户通过图形化向导来生成C语言工程的图形配置工具STM32CubeMX。
1 J2 S$ d8 u- J) X适用于每个STM32 MCU和MPU系列的STM32Cube MCU和MPU软件包（也叫STM32Cube 固件包或者STM32Cube包）。
在前面STM32CubeIDE第一个工程实验的创建工程环节，STM32CubeIDE已经自动在C:\Users\自己的用户名称\STM32Cube\Repository\STM32Cube_FW_MP1_V1.2.0路径中下载好了STM32Cube_FW_MP1_V1.2.0包，这个包就是STM32MP1的固件包，此固件包也可以从ST官网上下载，目前最新版本是1.2.0版本。

3 X& P* f$ J+ ], q5 O" {: B

图6.1. 1搜索STM32CubeMP1固件包
在开发板光盘A-基础资料\7、STM32MP1参考资料\STM32MP157 Cube包中我们也有提供STM32MP1的固件包：

# c, M4 t& K4 N
: I. P6 s* t( ~  T9 _+ _
图6.1. 2A盘中下载好的固件包
我们打开Drivers文件夹，看到的STM32MP1xx_HAL_Driver就是HAL库。

; R" F3 \! e! N8 x6 _* S$ c

图6.1. 3 HAL库
0 ]0 [3 g8 }* o6.2 STM32CubeMP1固件包目录结构
8 F) r! L" T) [/ p  n接下来，我们看看前面下载好的STM32CubeMP1固件包目录结构，打开STM32Cube_FW_MP1_V1.2.0固件包，目录结构如下图。

' P0 t, E/ _3 P9 s
* U; a& X, [" ^+ r: _4 L: @( ^
# L6 x4 a1 r. \) ~$ B图6.1. 4固件包目录结构
- P: U4 V2 y2 o_htmresc文件夹下是ST公司的LOGO图片和一些网站的资料，其实是用不到的，我们不去关注。对比较重要的文件夹，我们按照顺序进行介绍：
6.2.1 Drivers文件夹
Drivers文件夹包含BSP，CMSIS和STM32MP1xx_HAL_Driver三个子文件夹。三个子文件夹具体说明请参考下表
* i) x$ l5 f! M# r% j8 W4 NBSP
7 v7 L6 d( F& T: v& @: J文件夹 BSP也叫板级支持包，此支持包提供的是直接与硬件打交道的API，例如触摸屏，LCD，SRAM以及EEPROM等板载硬件资源等驱动。目前在STM32cubeMP1固件包中，ST还未添加这部分内容（目前有LED、COM端口以及按钮相关的API），后期ST应该会逐渐添加这些文件。
BSP文件夹下还给了ST官方DISCO和EVAL开发板的硬件驱动API文件，每一种板对应一个文件夹。可以打开开发板文件夹，根据里边帮助文档查看API文件都有什么内容
CMSIS
0 E4 j  N1 X' E, W$ k文件夹 CMSIS文件夹用于存放符合CMSIS标准的文件，包括STM32启动文件、ARM Cortex内核文件和对应外设头文件。关于CMSIS文件夹里的文件，我们后面会专门讲解。
Core 用于Cortex-M处理器内核和外围设备的API
Core_A 用于Cortex-A5 / A7 / A9处理器内核和外围设备的API
Device 微控制器专用头文件/启动代码/专用系统文件
DSP 适用于各种数据类型的DSP库集合
# p$ v8 b$ M2 M  DInclude STM32MP1xx外围设备访问层头文件
Lib ARM、GCC 和 IAR格式的 DSP 库文件
; a& T3 d, }& w) ^) r, }NN 神经网络库集合，目的是在Cortex-M处理器内核上最大化神经网络的性能并最​​小化其内存占用
6 r* d, q* V+ B, [3 u* uRTOS 实时操作系统通用API相关文件（V1版本），兼容RTX4
* |/ o5 J$ \1 s* y# T+ mRTOS2 对RTOS V1的拓展，兼容RTX5
STM32MP1xx_HAL_Driver文件夹 HAL库文件夹，处理STM32“内部”设备,它包含了所有的STM32MP1xx系列HAL库头文件和源文件，也就是所有底层硬件抽象层API声明和定义。它的作用是屏蔽了复杂的硬件寄存器操作，统一了外设的接口函数。该文件夹包含Src和Inc两个子文件夹，其中Src子文件夹存放的是.c源文件，Inc子文件夹存放的是与之对应的.h头文件。每个.c源文件对应一个.h头文件。在前面的STM32CubeIDE第一个工程实验中就有用到该文件夹的文件，我们后面会重点介绍该文件夹的文件。
" k, u9 \+ H3 e4 [
1 W7 z- q2 ^7 O, R0 E5 c. f. o8 d
8 P6 r3 p: B3 X3 `) d
表6.2.1. 1 Drivers文件夹简介
7 c( G& ]/ v: P6 x6.2.2 Middlewares文件夹
& P; x- O) j) @7 `1 p- M- S7 {Middlewares（中间件）文件夹下目前只有Third_Party文件夹，是提供一组服务的库，目前里边只有FreeRTOS实时系统支持包和OpenAMP文件夹。


- n6 W1 H. u* A8 C, i7 ?( v8 `6 H
( b$ Y& R9 M% ~1 F& o8 z  p6 n图6.2.2. 1 Middlewares文件夹
4 s8 U! r) p7 ]" [$ B4 E. yFreeRTOS是一个免费的实时操作系统（RTOS），它同时支持抢占优先级和协作优先级，具有非常弹性的任务优先级分配，可以快速响应中断，在实时性要求较高的产品开发中应用很广泛。关于FreeRTOS的学习，感兴趣的可以查看正点原子《STM32F429 FreeRTOS开发手册》。 在FreeRTOS文件夹下，其具有FreeRTOS实时系统支持包，Source目录包含每个端口共有的三个文件list.c，queue.c和tasks.c，内核包含在这三个文件中。Source/Portable目录包含用于于特定微控制器和/或编译器的文件。Source/include目录包含实时内核头文件。Source/CMSIS_RTOS和Source/CMSIS_RTOS_V2下是FreeRTOS实时系统API文件，一个是V1版本一个是V2版本。



图6.2.2. 2 FreeRTOS支持包
2 c/ q) M) m" fAMP是指非对称多处理, 非对称多处理是指各核的结构并非对称，例如STM32MP1是两个Cortex-A7内核加一个Cortex-M4内核的组合，各个核结构并非对称。OpenAMP常用于处理器间通信，OpenAMP软件框架为开发AMP系统提供了必要的API函数，可以实现核间通信。
4 q9 e8 c/ C! q; E. i6.2.3 Projects文件夹
该文件夹存放的是一些可以直接编译的实例工程，是STM32MP1xx系列的STM32CubeMP1固件示例。每个文件夹对应一个ST官方的Demo板。比如我们要查看STM32mp157相关工程，我们直接打开子文件夹STM32MP157C-DK2即可，里面有很多实例供我们参考。每个Demo板下都会有以下4个文件夹：
  b* U; ?1 s) T0 ^# PApplications： OpenAMP、FreeRTOS和CoproSync应用程序示例。
Demonstrations：AI相关示例。
, d- j# @0 `9 f& K- `Examples：外围设备的功能和用法示例。
Templates：固件库工程模板，允许用户在给定的板上快速构建任何固件应用程序。
  ?" Y  x2 X/ t  H$ D( L我们查看其中的示例的时候，工程下面有MDK-ARM和STM32CubeIDE子文件夹，双击MDK-ARM子文件夹内部的Project.uvprojx的工程文件，可以在MDK中打开工程，双击STM32CubeIDE子文件夹下的.project工程文件，可以在STM32CubeIDE中打开工程。

( {( J# x2 Z$ Q9 d! B

0 |2 f" m2 y: a& e$ z# t图6.2.3. 1 STM32CubeIDE工程文件
6 d/ X. F: H/ m' H. Q! C! }9 T, K3 s关于Projects文件夹的整体介绍，可以打开里边的STM32CubeProjectsList.html文件了解更加详细内容。在查看工程文件的时候，可以打开里边的readme.txt查看介绍内容。
* M' O4 ]2 Y, u& ?# N( _0 e+ c6.2.4 Utilities文件夹
该文件夹中的文件介绍了如何配置STM32MP1xx的资源管理器，例如文件中提供了共享内存中的虚拟表地址、在ETZPC控制下的设备寄存器地址表、共享资源ID等，这些文件由ST官网提供，一般不能修改文件中的内容。
6.2.5 其它文件
5 [9 |* Y8 T8 @# OReadme.md简单介绍STM32CubeMP1固件文件的内容。Release_Notes.html文件是固件库版本更新说明，关于STM32CubeMP1固件版本详细更新内容，我们可以查看此文件。License.md和package.xml文件只是协议说明和固件包版本的说明，不用怎么管。

6.3 CMSIS文件夹关键文件介绍
随着32位处理器在嵌入式市场需求量逐渐增多，各家芯片公司推出新型芯片，伴随而来的是开发工具、软件兼容以及代码移植等问题。在这种情况下，各个硬件平台的供应商都寻求易于使用且高效的解决方案，其中，ARM与Atmel、IAR、KEIL、SEGGER和ST等诸多芯片和软件工具厂商合作，发布了一套CMSIS标准。
CMSIS（Cortex Microcontroller Software Interface Standard），即ARM Cortex微控制器软件接口标准。CMSIS标准提供了内核和外围设备、实时操作系统和中间组件之间的通用API接口，从而简化了软件的重复使用，缩短了微控制器开发人员的学习时间，并缩短了新设备的上市时间。下图是ARM公司的CMSIS标准结构框图：



2 J) A; f" ?2 z$ w2 v5 P% |图6.3. 1CMSIS标准结构框图
其中，CMSIS-CORE层定义了Cortex-M以及Cortex-A处理器（Cortex-A5/A7/A9）内核和外围设备的标准化API。CMSIS-Pack层包含了CMSIS-Driver驱动框架、CMSIS-DSP相关库、CMSIS-RTOS操作系统API、中间件API和Peripheral HAL层API等。根据CMSIS的标准，ARM公司整合并提供了CMSIS 软件包模板，目前最新的是5.7.0版本
基于ARM提供的CMSIS 软件包模板，ST官方结合自己芯片的差异进行了修改，并将其整合到了STM32Cube固件包中的CMSIS文件夹里。
& |  b; t/ m4 _  q" d. g/ i打开固件包中STM32Cube_FW_MP1_V1.2.0\Drivers\CMSIS目录，其中，Device文件夹和Include文件夹是每个工程都要用到的。
' p. Z- Q: q( m+ ]4 o7 a0 `" ?0 Z' ]; a


8 n( `* t0 \4 Y; G8 q6 @图6.3. 2 CMSIS目录
5 Q; c1 M3 O+ X. W- e' E- MDevice文件夹下是具体芯片直接相关的文件，里边是ST官方的STM32MP1xx器件专用的头文件、启动代码文件和专用系统文件，此文件夹下我们重点介绍这几个文件：stm32mp1xx.h、system_stm32mp1xx.c、startup_stm32mp15xx.s和stm32mp15xx_m4.ld文件。
8 q; b. ~, Y2 iInclude文件夹下是符合CMSIS标准的内核头文件，主要是核内外设文件，我们会重点介绍core_cm4.h文件。
6.3.1 stm32mp1xx.h文件
文件路径：Device\ST\STM32MP1xx\Include\stm32mp1xx.h
, A  F8 R2 \; z* O7 B5 kstm32mp1xx.h文件在工程中是一定要有的，文件的内容看起来不多，却非常重要。该文件主要就是确定代码中是否使用或者不使用某个底层驱动文件，我们简单分析stm32mp1xx.h文件。抛开文件中的主体代码，如下代码是笔者将主体部分代码删掉以后所看到的整体框架，其它的头文件框架也类似：
& C) g1 X3 N, [
# D4 ~- T0 L9 S1 v

1. 1   #ifndef __STM32MP1xx_H
   
2. 2   #define __STM32MP1xx_H
   
3. 3  
   
4. 4   #ifdef __cplusplus /* c++编译环境中才会定义__cplusplus (plus即"+"的意思) */
   7 Q# r& n8 [. P& ?$ g2 S, t  @! u
5. 5    extern "C" {                 /* 告诉编译器下面程序采用c方式编译 */
   
6. 6   #endif                 /* __cplusplus */
   . |& Y3 y! j3 e3 T- p6 v% q. y
7. 7   
   
8. 8   /****** 省略的代码 ******/
   & f( h) ~. K3 }7 f# o/ b
9. 9  
   
10. 10  #ifdef __cplusplus
    
11. 11  }
    
12. 12  #endif         /* __cplusplus */
      P4 T5 p& W' n2 I& r8 X
13. 13  #endif         /* __STM32MP1xx_H */

复制代码

  c, M9 k& h' e4 M( ^学过C++的朋友应该很熟悉，上面第4行到第12行代码是为了在C++中尽可能的支持C代码和C库。意思是，如果这是一段C的代码，那么加入"extern "C"{" 和 " }"处理其中的代码，因为C++和C对产生的函数名字的处理是不一样的，C++中存在重载，C中没有重载，为了在C++代码中调用C写成的库文件，就需要用extern"C"来告诉编译器:这是一个用C写成的库文件，请用C的方式来链接它们。如果不这样处理，在C++中编译后会出现链接错误。这么做其实也是为了方便代码移植。
/ k3 f( a2 p9 Q$ D3 ^) N下面我们分析stm32mp1xx.h文件的主要代码实现部分。

1. 1   #if !defined (STM32MP1)
   
2. 2   #define STM32MP1
     L# ?* O: @) |# R
3. 3   #endif                 /* STM32MP1 */
   - R/ Z5 J4 \6 l0 b
4. 4
   3 `. \4 t' G  E) f5 `4 o; V4 a
5. 5   #if !defined  (USE_HAL_DRIVER)
   ) [- W* j7 \, m( e# [/ s
6. 6   #endif                 /* USE_HAL_DRIVER */
   
7. 7
   & u! ^6 x2 T7 X. G7 X- `2 S. U
8. 8   /****** 省略了CMSIS设备版本号相关代码 ******/
   
9. 9                                    
   
10. 10  #if defined(CORE_CM4)
    0 }0 O/ c; P0 A* {5 C& ~
11. 11  /* keep for backward compatibility STM32MP15xx = STM32MP157Cxx */
    
12. 12  #if defined(STM32MP15xx)  
    
13. 13    #include "stm32mp157cxx_cm4.h"
    
14. 14  #elif defined(STM32MP157Axx)
    5 g4 ?" t7 `, E4 M
15. 15    #include "stm32mp157axx_cm4.h"
    
16. 16  #elif defined(STM32MP157Cxx)
    * o7 ^: v( G. C9 o1 ?* g
17. 17    #include "stm32mp157cxx_cm4.h"
    ; H1 o, B. I% p" A5 v  r
18. 18  /****** 此处省略部分内容 ******/
    
19. 19  #elif defined(STM32MP151Fxx)
    
20. 20    #include "stm32mp151fxx_cm4.h"
    - q. X! o8 X8 m* r0 S4 @3 d
21. 21  #else
    
22. 22   #error "Please select first the target STM32MP1xx device used in your application (in stm32mp1xx.h file)"
    0 F& ~6 S9 e+ V) G- M  s
23. 23  #endif
    
24. 24  #endif
    / f3 v' l0 e( @
25. 25

复制代码

如上图代码，大部分是一些条件编译，如果条件编译的宏有被定义，那么就参加编译。我们先看第10行到24行间的代码，第10行到13行，如果定义了CORE_CM4这个宏，当再定义STM32MP15xx这个宏的时候，就会包含stm32mp157cxx_cm4.h头文件，同理第14行到20行也是类似的宏定义，只要有定义某个宏，就会包含对应的头文件。
第37和38行，在定义宏CORE_CM4以后，没有定义其它宏，那么就会提示：Please select first the target STM32MP1xx device used in your application (in stm32mp1xx.h file)，提示要在stm32mp1xx.h文件中定义这个宏。
/ @4 c1 E7 k4 u2 U% t包含的stm32mp157cxx_cm4.h这些头文件也在Device\ST\STM32MP1xx\Include\目录下，里边有很多stm32mp151Pxx_cm4.h、stm32mp153Pxx_cm4.h和stm32mp157Pxx_cm4.h文件（这里的P是一个代号，表示a、c、d和f）。这些文件是干嘛用的呢？我们打开其中一个文件大概看看，例如stm32mp157dxx_cm4.h这个文件，文件中的内容很多，有上万行的代码，根据里边的注释，了解到这个文件主要就是对STM32MP1XX系列器件的Cortex-M处理器和核心外设的配置，例如中断号定义、外设寄存器结构体声明、外设寄存器位定义和寄存器的操作的宏定义以及外围设备内存映射等等。
我们接着往下看后面的代码。
& o7 G  o* ?% U% G8 a

1. 1   #if defined(CORE_CA7)
   
2. 2   /* keep for backward compatibility STM32MP15xx = STM32MP157Cxx */
   
3. 3   #if defined(STM32MP15xx)  
   
4. 4     #include "stm32mp157cxx_ca7.h"
   ( L  a' |0 K' G% A& a
5. 5   #elif defined(STM32MP157Axx)
   0 x) W/ x( _6 u. O* v
6. 6     #include "stm32mp157axx_ca7.h"
   
7. 7   #elif defined(STM32MP157Cxx)
   : t- \! E# x' F
8. 8     #include "stm32mp157cxx_ca7.h"
   + p, o" X8 x6 b9 z3 d
9. 9   /****** 此处省略部分内容 ******/
   . Q$ o; [3 f3 `; F2 \" s2 P
10. 10  #elif defined(STM32MP151Fxx)
    
11. 11    #include "stm32mp151fxx_ca7.h"
    
12. 12  #else
    ' a4 t, |, |" Q1 y
13. 13   #error "Please select first the target STM32MP1xx device used in your application (in stm32mp1xx.h file)"
    
14. 14  #endif
    
15. 15  #endif

复制代码

第1行先定义一个宏CORE_CA7，在这个宏的基础上，如果有定义其它的宏就会包含对应的头文件，如果没有定义宏将提示Please select first the target STM32MP1xx device used in your application (in stm32mp1xx.h file)。这些包含的头文件，例如stm32mp157cxx_ca7.h文件和前面的stm32mp157cxx_cm4.h头文件作用类似，只不过stm32mp157cxx_ca7.h文件是针对Cortex-A内核的。
$ R$ z) B/ ?7 C) J) t- ?经过前面的分析，正点原子的开发板使用的是STM32MP157DAA1这颗芯片，根据前面的分析应该是要包含stm32mp157dxx_cm4.h和stm32mp157dxx_ca7.h文件，则需要定义宏STM32MP157Dxx。
我们查看最后的代码：

1. 1   typedef enum                                 /* 布尔形变量定义 */
   
2. 2   {
   
3. 3     RESET = 0,
   0 _  }2 z$ _0 N5 O" H
4. 4     SET = !RESET
   
5. 5   } FlagStatus, ITStatus;
   : z7 H/ l5 b6 k1 O3 ^# Z7 F
6. 6
   6 @; }3 O! p8 ~4 m" g6 h
7. 7   typedef enum                                 /* 功能型状态变量 */
   
8. 8   {
   
9. 9     DISABLE = 0,
   # }; B, |5 O" \' I& @& m
10. 10    ENABLE = !DISABLE
    $ b  F7 B' I5 Q: Q" [( h$ E8 B) p
11. 11  } FunctionalState;
    
12. 12  #define IS_FUNCTIONAL_STATE(STATE) (((STATE) == DISABLE) || ((STATE) == ENABLE))
    
13. 13
    , @4 K2 v$ q! Q: c& c, P  G
14. 14  typedef enum                                 /* 错误型状态变量 */
    
15. 15  {
    
16. 16    ERROR = 0,
    
17. 17    SUCCESS = !ERROR
    
18. 18  } ErrorStatus;
    2 D- A+ E( M( Z2 F) W; {: ?
19. 19  
    
20. 20  /******一些位操作定义******/
    
21. 21  #define SET_BIT(REG, BIT)      ((REG) |= (BIT))
    - W1 d0 C: w1 _
22. 22
    3 S& q% C* s$ n
23. 23  #define CLEAR_BIT(REG, BIT)    ((REG) &= ~(BIT))
    
24. 24
    
25. 25  #define READ_BIT(REG, BIT)     ((REG) & (BIT))
    
26. 26
    * }& v/ W$ h4 Z7 g( c& n% E
27. 27  #define CLEAR_REG(REG)          ((REG) = (0x0))
    * Y3 ~1 F3 n  w- I9 k& n1 B: }8 _
28. 28
    + j7 s3 x4 V( q, \" w- _2 S
29. 29  #define WRITE_REG(REG, VAL)    ((REG) = (VAL))
    
30. 30
    
31. 31  #define READ_REG(REG)                 ((REG))
    1 b5 M. }9 I: t5 p: j) j3 L
32. 32
    ) V+ b+ k# k% V2 k* f
33. 33  #define MODIFY_REG(REG, CLEARMASK, SETMASK)  WRITE_REG((REG), \                                                         (((READ_REG(REG)) & (~(CLEARMASK))) | (SETMASK)))
    8 H& C' s6 p" Z1 L9 S6 u
34. 34
    
35. 35  #define POSITION_VAL(VAL)       (__CLZ(__RBIT(VAL)))
    ' Y7 P% ?; m! ?: W& R* N# N- e
36. 36
    
37. 37  #if defined (USE_HAL_DRIVER)
    " v" [& @' x' d; `. W9 T+ m  k
38. 38   #include "stm32mp1xx_hal_conf.h"
    $ \3 ]; d* [: u- ^/ v; C
39. 39  #endif /* USE_HAL_DRIVER */

复制代码

4 q8 _% V( I! c; x/ N; U- {第1行到第18行是一些通过枚举类型定义变量，例如FlagStatus有RESET和SET两个状态，分别为0和1，ITStatus也是有两个状态0和1。这些枚举类型变量会大量地用于HAL库的文件中只要遇见这些变量，我们想到的是它的值要么是0要么是1。
第12行是用于参数检查的，如果输入的参数是DISABLE和ENABLE其中的一个，那么(((STATE) == DISABLE) || ((STATE) == ENABLE))的值始终为1，否则为0。
3 X; w! z# M- p2 u9 l6 g3 ~6 n- T第21到35行表示一些位操作定义，例如21行#define SET_BIT(REG, BIT)     ((REG) |= (BIT))中有两个参数REG和BIT，REG是一个寄存器，BIT表示这个寄存器的第几位，这个宏表示将寄存器REG的第BIT位置1。这些位定义也大量用于HAL库的文件中。
) g# K6 C! s- o8 h& p/ {) H第37、38行表示如果定义了USE_HAL_DRIVER这个宏，就包含stm32mp1xx_hal_conf.h头文件，此头文件是HAL库的头文件集，一旦使用了相应的模块，就要定义相关的模块使能，然后相应模块的头文件才会被包含。
. b7 I3 J3 l& h" L; Z2 D$ P8 jstm32mp1xx.h文件内容就这么多，经过前面的分析，如果要操作CM4的外设，我们需要定义CORE_CM4、STM32MP157Dxx和USE_HAL_DRIVER这3个宏定义，这3个宏定义在哪里定义呢？如果是用MDK来编译，点击Keil的魔术棒，在C/C++配置栏的Preprocessor Symbols（预处理器符号）的Dfine（定义）处加上CORE_CM4,USE_HAL_DRIVER,STM32MP157Dxx就可以了（注意，用英文格式的逗号隔开）。

5 W1 l4 ^- k: \* l' |
& x3 [  F. q: g1 @
图6.3.1. 1 MDK上添加宏
( H1 P5 j7 z' r. t" A6 s* r4 m如果是用STM32CubeIDE来编译，我们不需再进行配置，STM32CubeIDE已经自动为我们配置好了，不过我们还是需要知道在哪里配置。打开STM32CubeIDE第一个工程的工程文件，选中HAL_LED_CM4(in CM4)工程，右键选择Properties，打开CM4工程属性以后，找到Paths and Symbols下的Symbols选项，里边的就是符号定义。
9 i0 M7 z3 [: d& a1 @- T

" H: d& s2 t$ F/ O: C
7 }" }+ x3 ~, m7 u4 I+ ?& |图6.3.1. 2CubeIDE上添加宏
也可以在C/C++ BuildSettingsTool SettingsMCU GCC CompilerPreprocessor中看到添加了哪些宏定义。



图6.3.1. 3查看添加了那些宏
6.3.2 stm32mp157dxx_cm4.h
" h. \5 ?/ i- f9 U0 c& ]3 {: A, M文件路径：Device\ST\STM32MP1xx\Include\stm32mp157dxx_cm4.h
在stm32mp1xx.h文件中有介绍到，通过同时定义CORE_CM4和STM32MP157Dxx宏来加载stm32mp157dxx_cm4.h文件。前面我们也有介绍到stm32mp157dxx_cm4.h文件，打开文件进行浏览，文件中的内容很多，有上万行的代码，根据里边的注释，了解到这个文件主要就是对STM32MP157dxx系列器件的Cortex-M处理器和外设（GPIO、DMA、TTFD、ETH、CRC、TIM、UART、I2C等等）的设备资源定义，例如外设中断号定义、外设寄存器结构体声明、外设寄存器位定义和寄存器的操作的宏定义以及外围设备内存映射等等。
; }0 ~! Y) W; D+ b0 p8 K里边使用了大量的结构体来对寄存器进行封装，如果我们要访问某个寄存器，只需要定义一个结构体指针，然后通过指针来读写对应的寄存器（结构体成员）。下面我们以GPIO为例子介绍：
% _- z& l, B0 Q0 R# j' g
, a. ]* r4 z5 Q( s% v( Y# N

1. typedef struct
   " m) a# }- ^0 r$ l
2. {
   5 R: ~: Y2 R8 D+ {5 X0 B' A* _$ w! z/ _
3.   __IO uint32_t MODER;                   /* GPIO端口模式寄存器，地址偏移量：0x000 */
   
4.   __IO uint32_t OTYPER;                  /* GPIO端口输出类型寄存器，地址偏移量：0x004 */
   
5.   __IO uint32_t OSPEEDR;         /* GPIO端口输出速度寄存器，地址偏移量：0x008 */
   # {- c+ D: Q0 ]+ B  ^1 @0 H! g
6.   __IO uint32_t PUPDR;                   /* GPIO端口上拉/下拉寄存器，地址偏移量：0x00C */
   
7.   __IO uint32_t IDR;                    /* GPIO端口输入数据寄存器，地址偏移量：0x010 */
   # E$ R3 N+ y3 V! }; h
8.   __IO uint32_t ODR;                    /* GPIO端口输出数据寄存器，地址偏移量：0x014 */
   
9.   __IO uint32_t BSRR;                  /* GPIO端口位设置/重置寄存器，地址偏移量：0x018*/        
   ' l5 p8 J& g' e2 d: N# L$ j) I
10.   __IO uint32_t LCKR;                  /*GPIO端口配置锁定寄存器，地址偏移量：0x01C*/        
    
11.   __IO uint32_t AFR[2];                 /* GPIO备用功能寄存器，地址偏移量：0x020-0x024*/      
    / i  l. g9 `7 {2 A
12.   __IO uint32_t BRR;                   /* GPIO端口位复位寄存器，地址偏移量：0x028 */         
    
13.        uint32_t RESERVED0;          /* 保留，地址偏移量：0x02C */     
    & u+ p+ K2 z) U7 x) e
14.   __IO uint32_t SECCFGR; /*用于GPIOZ的GPIO安全配置寄存器，地址偏移量：0x030*/        
    
15.        uint32_t RESERVED1[229];  /* 保留，地址偏移量：0x034-0x3C4*/
    / S8 n! n& Z9 b; [/ A1 `
16.   __IO uint32_t HWCFGR10;                  /* GPIO硬件配置寄存器10，地址偏移量：0x3C8*/      
    & t4 `7 R0 b$ ~7 c9 J0 S$ z
17.   __IO uint32_t HWCFGR9;                 /* GPIO硬件配置寄存器9，地址偏移量：0x3CC*/      
    
18.   __IO uint32_t HWCFGR8;                 /* GPIO硬件配置寄存器8，地址偏移量：0x3D0*/        
    4 M( B* d  j5 i- p* n/ ?9 V  W
19.   __IO uint32_t HWCFGR7;                 /* GPIO硬件配置寄存器7，地址偏移量：0x3D4*/      
    3 }4 i4 c* N4 j5 l( p
20.   __IO uint32_t HWCFGR6;                 /* GPIO硬件配置寄存器6，地址偏移量：0x3D8*/      
    1 v& z; P9 P; i* \
21.   __IO uint32_t HWCFGR5;                 /* GPIO硬件配置寄存器5，地址偏移量：0x3DC*/        
    6 Q0 s$ z% e+ G4 n& G
22.   __IO uint32_t HWCFGR4;                   /*GPIO硬件配置寄存器4，地址偏移：0x3E0*/      
    2 B9 Z8 f' W" n3 |$ X" w
23.   __IO uint32_t HWCFGR3;                 /* GPIO硬件配置寄存器3，地址偏移量：0x3E4*/        
    0 k" q4 g& n' j- N4 K# g5 Q
24.   __IO uint32_t HWCFGR2;          /* GPIO硬件配置寄存器2，地址偏移量：0x3E8*/      
    
25.   __IO uint32_t HWCFGR1;          /* GPIO硬件配置寄存器1，地址偏移量：0x3EC*/        
    
26.   __IO uint32_t HWCFGR0;           /*GPIO硬件配置寄存器0，地址偏移量：0x3F0*/      
    
27.   __IO uint32_t VERR;                   /*GPIO版本寄存器，地址偏移量：0x3F4*/         
    7 r0 \+ _& Q2 P/ g
28.   __IO uint32_t IPIDR;                  /* GPIO识别寄存器，地址偏移量：0x3F8 */
    " t& T. ^/ b: B2 y9 G& D
29.   __IO uint32_t SIDR;                   /* GPIO大小识别寄存器，地址偏移量：0x3FC */
    
30. } GPIO_TypeDef;

复制代码

这段代码中，typedef是类型定义以及结构体定义的基本语法，我们在前面5.1.5小节和5.1.6小节有讲解。__IO表示volatile ，在core_cm4.h文件中有定义。其中，结构体成员MODER、OTYPER、和SIDR这些是GPIOx（x等于A~K和Z）对应的寄存器名称。
4 `* {: _4 g% V  [" J% w这里，每个结构体成员均定义为uint32_t，即相邻每个成员偏移4个字节，寄存器MODER偏移地址为0x000，寄存器OTYPER偏移地址为0x004，以此类推。
通过结构体，我们知道了偏移地址，要确定一个寄存器的实际地址，我们还需要知道基地址。通过参考手册我们知道GPIOI挂在了AHB总线上，且AHB总线的基地址是0x50000000，

GPIOI的基地址就是0x5000A000，这个基地址在代码的哪里定义了呢？
/ P/ b, ?6 n  u/ Y% u* v# Z
7 M' G: V1 ^1 Q( Q; m. v6 x
4 }( P) E0 k- a- J3 d
! q2 M/ P% I* q图6.3.2. 1参考手册部分截图
也是在stm32mp157dxx_cm4.h头文件中可以找到如下的代码：
9 H9 L/ z8 A! e
% B0 L# z+ I( X

1. 1   /*外围内存映射 */
   6 J6 B  n1 y; Q! _
2. 2   #define MCU_AHB_SRAM             ((uint32_t)0x10000000)
   
3. 3   #define MCU_AHB_RETRAM          ((uint32_t)0x00000000)
   5 q" d! w( w4 h4 N
4. 4
   
5. 5   #define SYSRAM_BASE             ((uint32_t)0x2FFC0000)
   
6. 6   #define RETRAM_BASE             MCU_AHB_RETRAM
   
7. 7   #define SRAM_BASE                MCU_AHB_SRAM
   + t3 i/ D( {% |2 S2 E, a
8. 8   #define PERIPH_BASE             ((uint32_t)0x40000000)
   
9. 9   #define MPU_AXI_BUS_MEMORY_BASE ((uint32_t)0x60000000)
   ( R. n5 ]9 t! j6 ]9 m$ l! B
10. 10
    9 W. h4 m2 y% h9 G+ d
11. 11  #define FMC_NOR_MEM_BASE        (MPU_AXI_BUS_MEMORY_BASE)              
    5 T" A! D6 v0 A7 o8 z9 m
12. 12  #define QSPI_MEM_BASE           (MPU_AXI_BUS_MEMORY_BASE + 0x10000000)
    8 M& _0 u% }' B* B# b
13. 13  #define FMC_NAND_MEM_BASE       (MPU_AXI_BUS_MEMORY_BASE + 0x20000000)
    / J- W! g% H: y$ \& E4 `! ^' X
14. 14  #define STM_DATA_BASE           (MPU_AXI_BUS_MEMORY_BASE + 0x30000000)
    
15. 15  #define DRAM_MEM_BASE           (MPU_AXI_BUS_MEMORY_BASE + 0x60000000)
    
16. 16
    9 E% D' g7 u, i' }2 y1 ]- h7 N
17. 17  /*设备电子签名内存映射 */
    
18. 18  #define UID_BASE                  (0x5C005234L)           
    4 Q6 h7 h" g8 L2 v1 B
19. 19  #define PACKAGE_BASE             (0x5C005240L)            
    
20. 20  #define RPN_BASE                  (0x5C005204L)           
    7 h/ y9 P! b) C* c
21. 21  #define DV_BASE                   (0x50081000L)           
    & Y* V1 e1 V# k7 N* K2 v% o
22. 22
    
23. 23  /* 外围内存映射 */
    ! Y5 d- {9 B) a3 ~& i
24. 24  #define MCU_APB1_PERIPH_BASE        (PERIPH_BASE + 0x00000000)
    
25. 25  #define MCU_APB2_PERIPH_BASE        (PERIPH_BASE + 0x04000000)
    : _) ~$ w$ k% ]6 z( o
26. 26  #define MCU_AHB2_PERIPH_BASE        (PERIPH_BASE + 0x08000000)
    1 w/ [; h/ |* ^& J9 q# Y+ h  f$ x
27. 27  #define MCU_AHB3_PERIPH_BASE        (PERIPH_BASE + 0x0C000000)
    & p0 u# \3 ]4 {8 g+ p
28. 28  #define MCU_AHB4_PERIPH_BASE        (PERIPH_BASE + 0x10000000)
    
29. 29  #define MCU_APB3_PERIPH_BASE        (PERIPH_BASE + 0x10020000)
    ' g* {* \( _1 @. b8 J
30. 30  #define APB_DEBUG_PERIPH_BASE       (PERIPH_BASE + 0x10080000)
    
31. 31  #define MPU_AHB5_PERIPH_BASE        (PERIPH_BASE + 0x14000000)
    
32. 32  #define GPV_PERIPH_BASE              (PERIPH_BASE + 0x17000000)
    
33. 33  #define MPU_AHB6_PERIPH_BASE        (PERIPH_BASE + 0x18000000)
    
34. 34  #define MPU_APB4_PERIPH_BASE        (PERIPH_BASE + 0x1A000000)
    
35. 35  #define MPU_APB5_PERIPH_BASE        (PERIPH_BASE + 0x1C000000)
    + q5 ]9 c0 t. {7 u) ~8 w  @, P" U( F! Z
36. 36  /******省略APB1、APB2、AHB2、AHB3相关代码******/
    8 P* l4 v' {) K' X
37. 37  /*!< MCU_AHB4 */
    
38. 38  #define RCC_BASE              (MCU_AHB4_PERIPH_BASE + 0x0000)
    
39. 39  #define PWR_BASE              (MCU_AHB4_PERIPH_BASE + 0x1000)
    8 L* k9 D" y5 A4 i
40. 40  #define GPIOA_BASE            (MCU_AHB4_PERIPH_BASE + 0x2000)
    ) _( F4 E. T" |
41. 41  #define GPIOB_BASE            (MCU_AHB4_PERIPH_BASE + 0x3000)
    
42. 42  #define GPIOC_BASE            (MCU_AHB4_PERIPH_BASE + 0x4000)
    3 w8 @& ?2 v8 D$ L- y
43. 43  #define GPIOD_BASE            (MCU_AHB4_PERIPH_BASE + 0x5000)
    # C1 \$ A- U$ o, J6 Q  F. r
44. 44  #define GPIOE_BASE            (MCU_AHB4_PERIPH_BASE + 0x6000)
    
45. 45  #define GPIOF_BASE            (MCU_AHB4_PERIPH_BASE + 0x7000)
    3 W* @5 u) p5 y: d
46. 46  #define GPIOG_BASE            (MCU_AHB4_PERIPH_BASE + 0x8000)
    7 N6 a" O7 X- p* _: |- K  l
47. 47  #define GPIOH_BASE            (MCU_AHB4_PERIPH_BASE + 0x9000)
    
48. 48  #define GPIOI_BASE            (MCU_AHB4_PERIPH_BASE + 0xA000)
    
49. 49  #define GPIOJ_BASE            (MCU_AHB4_PERIPH_BASE + 0xB000)
    
50. 50  #define GPIOK_BASE            (MCU_AHB4_PERIPH_BASE + 0xC000)
    
51. 51  #define AIEC_BASE             (MCU_AHB4_PERIPH_BASE + 0xD000)
    
52. 52  #define AIEC_C1_BASE          (AIEC_BASE + 0x0080)
    
53. 53  #define AIEC_C2_BASE          (AIEC_BASE + 0x00C0)
    
54. 54  /* Alias EXTI_BASE defined because HAL code not yet reworked with new name AIEC*/
    9 X  `9 [0 R) D& k
55. 55  #define EXTI_BASE               AIEC_BASE
    
56. 56  #define EXTI_C1_BASE           AIEC_C1_BASE
    ! o, f, A7 [$ e/ ?, H
57. 57  #define EXTI_C2_BASE           AIEC_C2_BASE

复制代码

这部分代码是内存映射相关的宏定义。如上代码，第8行定义PERIPH_BASE宏为0x40000000，第28行宏MCU_AHB4_PERIPH_BASE为(PERIPH_BASE + 0x10000000)，计算得出0x5000 0000，此值刚好表示AHB4总线的基地址。第48行宏GPIOI_BASE为(MCU_AHB4_PERIPH_BASE + 0xA000)，计算得出0x5000 A000，此值刚好是GPIOI的基地址。同样的，其它的总线以及外设的基地址在stm32mp157dxx_cm4.h头文件中均有定义。
总线或者外设的偏移地址找到了，基地址也找到了，基地址+偏移地址就等于实际地址。如果我们要操作某个外设，也就是操作对应外设的寄存器，那么，这些寄存器的地址又怎么得来的呢？在stm32mp157dxx_cm4.h头文件中找到如下部分代码：
#define GPIOI               ((GPIO_TypeDef *) GPIOI_BASE)
2 P  A' K3 y/ q% W' [6 \, W. {) N这里表示将宏GPIOI定义为((GPIO_TypeDef *) GPIOI_BASE)。
GPIOI_BASE 是一个uint32_t类型，我们已经计算得出0x5000 A000。GPIO_TypeDef结构体我们在前面有列出代码，(GPIO_TypeDef *)里边加了一个*号，表示结构体指针类型。((GPIO_TypeDef *) GPIOI_BASE)表示将uint32_t类型的GPIOI_BASE强制转化成结构体指针类型。
上面这一行代码就表示：将GPIOI变成GPIO_typedef 类型的结构体指针，并且默认指向了基地址GPIOI_BASE，即从GPIOI_BASE开始，长度为RCC_TypeDef这个类型的长度。这样一来，每个寄存器的地址也就确定下来了，通过指针即可访问结构体的成员（寄存器）。
在以后，我们要操作GPIOI中的某个寄存器，例如操作ODR寄存器，只需要通过指针操作结构体成员就可以了：
& n  O' s5 t- p9 E# C. MGPIOI->ODR = 0XFFFF;
上面，GPIOI->ODR也可以改写为(*GPIOI).ODR。这段代码表示将GPIOI中的ODR寄存器赋值为0XFFFF。
" ^# k0 q3 e- N; Q, w" ]实际上，在HAL库中很多函数里就是这么用的，例如在HAL库的stm32mp1xx_hal_gpio.c文件中，就有很多这样的代码：

; o! M2 ?& t5 T8 m! `5 p, q8 _) |
2 B( i4 L, l, Y$ [
. H0 k4 f+ E6 S, N: @图6.3.2. 2 HAL库函数部分截图
6.3.3 stm32mp157dxx_ca7.h文件
文件路径：Device\ST\STM32MP1xx\Include\stm32mp157dxx_ca7.h
8 S5 J* T6 {' x6 ]: u和stm32mp157dxx_cm4.h文件类似，只不过是对Cortex-A7处理器和核心外设的配置。
6.3.4 system_stm32mp1xx.c文件
文件路径：
1 X7 O* ~4 ?( bDevice\ST\STM32MP1xx\Include\system_stm32mp1xx.h
Device\ST\STM32MP1xx\Source\Templates\system_stm32mp1xx.c
, p' K/ c; D5 T/ B6 I8 S这两个文件提供了两个函数和一个全局变量：系统初始化函数SystemInit、系统时钟更新函数SystemCoreClockUpdate和SystemCoreClock全局变量。
SystemInit函数在系统复位后，在跳到主程序main.c之前被startup_stm32mp1xx.s文件调用。SystemInit函数中主要是初始化FPU设置、配置SRAM中的向量表和禁用所有中断和事件。我们简单分析一下代码。
9 y2 _/ e% g, F% e1 A" U

1. 1   void SystemInit (void)
   + |$ U5 T$ x& `( _
2. 2   {
   
3. 3     /* FPU settings */
   
4. 4   #if defined (CORE_CM4)
   
5. 5     #if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
   
6. 6    /* set CP10 and CP11 Full Access */
   
7. 7      SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2));  
   - g" D5 h/ w& d9 }
8. 8     #endif
   
9. 9
   9 `- O! f/ i  c: f9 ]1 o1 @) r
10. 10  /* 配置中断向量表地址=基地址+偏移地址 */
    & Z" M- {  _# b
11. 11  #if defined (VECT_TAB_SRAM)                         /* 向量表存储在 SRAM */
    - L5 ^! U3 s! g3 l0 P
12. 12  /* Vector Table Relocation in Internal SRAM */
    
13. 13    SCB->VTOR = MCU_AHB_SRAM | VECT_TAB_OFFSET;
    
14. 14  #endif
    3 x" M; [: [2 \$ i/ P, P
15. 15    /* Disable all interrupts and events */
    2 S2 {! P" b3 n  ?$ Q1 H4 [
16. 16    CLEAR_REG(EXTI_C2->IMR1);
    
17. 17    CLEAR_REG(EXTI_C2->IMR2);
    6 D1 b: o& `: D7 h+ \7 V
18. 18    CLEAR_REG(EXTI_C2->IMR3);
    ' @$ X$ c! Y- o1 r1 i& o
19. 19    CLEAR_REG(EXTI_C2->EMR1);
    
20. 20    CLEAR_REG(EXTI_C2->EMR2);
    
21. 21    CLEAR_REG(EXTI_C2->EMR3);
    
22. 22  #else
    
23. 23  #error Please #define CORE_CM4
    * k5 D# M  D, f! [+ t& _
24. 24  #endif                           
    
25. 25  }

复制代码

FPU（Floating Point Unit，浮点单元）即用于处理浮点数运算的单元，可以大大加速浮点运算的处理速度。STM32MP1系列器件的Cortex-M4 内核是具有FPU单元的，支持浮点指令集，处理数学运算能力得以大大提高。
! v- `, L$ k# \3 a第4到第8行表示使用条件编译来设置FPU，如果定义了CORE_CM4宏，当__FPU_PRESENT和__FPU_USED同时为1时，就使能FPU单元，编译时就加入启动FPU 的代码，CPU 也就能正确高效的使用FPU 进行简单的加减乘除运算了。第12行表示设置 CPACR 寄存器的 20~23 位为 1，以开启STM32MP1的硬件 FPU 功能。
+ l( i& F4 T( v根据前面的分析，如果我们要开启FPU，只需要定义CORE_CM4宏，并将__FPU_PRESENT和__FPU_USED同时设置为1就可以了，在前面我们已经知道定义CORE_CM4宏了，剩下的__FPU_PRESENT和__FPU_USED将怎么设置呢？
$ d1 l0 e7 t% h- \$ ~6 A7 a如果使用的是MDK的朋友，使用的是keil5的话，只需要在点击魔术棒，然后再Floating Point Hardware里选择Use Single Presicion就可以了。
6 A- l+ v) @3 j& f


图6.3.4. 1 MDK中开启FPU
2 \7 ~# G1 v. p' ^/ Y. c8 b# Z如果使用的是STM32CubeIED的话，可以打开STM32CubeIDE第一个工程的工程文件，选中HAL_LED_CM4(in CM4)工程，右键选择Properties，打开CM4工程属性，找到C/C++ Build SettingsTool SettingsMCU Settings，可以看到系统已经自动为我们设置好了支持FPU了。Floating-point ABI选择的是硬件浮点单元，浮点运算处理方式为FPv4-SP-D16，其中d16表示有16个64位的单精度寄存器，指令集选的是Thumb2。最后我们看到Use float with printf from newlib-nano(-u _printf_float) 和Use float with printf from newlib-nano(-u_scanf_float)选项，这两个选项通常是用于串口打印的时候设置的，在串口实验中设置这两项以后，串口支持浮点类型数据打印。
" v# g+ l- x, S( A  B9 P3 A

- g1 u* m% I0 A
. o! Q) E% [3 j8 l4 ?4 j& O4 h图6.3.4. 2 CubeIDE中设置FPU
第11到第14行，这段代码表示表示如果定义VECT_TAB_SRAM，则内部SRAM中的向量表被重定位。MCU_AHB_SRAM表示向量表基地址，其值为0x10000000（在stm32mp157dxx_cm4.h文件中定义），VECT_TAB_OFFSET表示向量表偏移量，可以修改它的值，修改的时候，其值必须是0x400的倍数。VTOR 寄 存 器 存 放 的 是 中 断 向 量 表 的 起 始 地 址（其有一个默认值），默 认 情 况，VECT_TAB_SRAM 是没有定义的。在system_stm32mp1xx.c文件的最前面有#define VECT_TAB_OFFSET 0x00这句，已经定义了向量表偏移量为0x00，如果将0x00修改0x10，同时也定义VECT_TAB_SRAM这个宏，那么：
% h3 f3 y2 t! O. @8 U# F: A) rSCB->VTOR=0x10000000|0x10=0x10000010
9 R3 `1 T1 V  d& g: r2 E这样就设置了中断向量表偏移。不过一般尽量不要修改system_stm32mp1xx.c这样的系统级别文件，如果要改的话，尽量在其他文件中进行修改。
$ ~/ \7 \% v$ |第16到第21行，表示清除中断屏蔽寄存器EXTI_IMR1、EXTI_IMR2和EXTI_IMR3以屏蔽中断请求，即禁用所有中断和事件。
接下来我们查看SystemCoreClockUpdate函数。SystemCoreClockUpdate函数的代码比较多，注释也比较详细，为了不占用篇幅，我们这里省略部分代码：
% ~0 @' A2 G" i/ T# G4 S: h- N
/ b- b) ^9 `% W! S3 `: ~; e) ?

1. 1   uint32_t SystemCoreClock = HSI_VALUE;
   : I0 P# k. ~/ D) e, o8 n1 I
2. 2
   
3. 3   void SystemCoreClockUpdate (void)
   
4. 4   {
   3 X" j7 ~. v9 g/ k+ I# L
5. 5     uint32_t   pllsource, pll3m, pll3fracen;
   9 A; s5 Q; w" T' M9 q+ Y1 S  ]" t( R
6. 6     float fracn1, pll3vco;
   
7. 7
   - f, q0 o, [7 m1 G7 s% O
8. 8     switch (RCC->MSSCKSELR & RCC_MSSCKSELR_MCUSSRC)
   2 a  }4 ~3 h6 w
9. 9     {
   2 N6 Z$ x0 S# ]  A
10. 10    case 0x00:  /* HSI used as system clock source */
    ' t7 Q. O% \) q
11. 11      SystemCoreClock = (HSI_VALUE >> (RCC->HSICFGR & \                                                                                                                                 RCC_HSICFGR_HSIDIV));
    7 v5 E; M! v3 ~7 n  V, \! G
12. 12      break;
    3 l. I3 }; G) B+ @* a6 z
13. 13
    
14. 14    case 0x01:  /* HSE used as system clock source */
    ! B6 T: v/ {+ \; }" X) b+ G
15. 15      SystemCoreClock = HSE_VALUE;
    
16. 16      break;
    ! K9 I" Y2 H! |
17. 17
    % X& d5 X& _  x
18. 18    case 0x02:  /* CSI used as system clock source */
    . X7 k1 y) W; j: O' H
19. 19      SystemCoreClock = CSI_VALUE;
    8 J0 i5 _! y: T/ h
20. 20      break;
    5 V9 m) ?" I6 G) y
21. 21
    
22. 22    case 0x03:  /* PLL3_P used as system clock source */
    1 b! }. I" V  d; d
23. 23     /*******省略部分代码*******/
    0 e9 |) E2 {7 I% V4 e
24. 24      break;
    
25. 25    }
    
26. 26
    # N0 s' z" l/ `4 Z2 T) |' t
27. 27    /* Compute mcu_ck */
    $ O+ y- }' R: ?! Q& y$ p
28. 28    SystemCoreClock = SystemCoreClock >> (RCC->MCUDIVR & \                                                                                                                                 RCC_MCUDIVR_MCUDIV);
    $ f, J" j7 e1 m& Q) e" c
29. 29  }
    

复制代码

根据注释，System Clock 的时钟源有：HSI（默认值64 MHz）、HSE（默认值为24 MHz）、CSI（默认值为4 MHz）和PLL3_P。在文件前面有一行uint32_t SystemCoreClock = HSI_VALUE，其中HSI_VALUE的值为64000000（在stm32mp1xx_hal_conf.h文件中定义）。根据代码的注释，SystemCoreClock是一个全局变量，系统复位以后，系统时钟默认采用HSI_VALUE，即为64MHz。在本篇的CM4裸机实验中，如果我们没有配置时钟树，那么MCU内核时钟就默认64Hz的时钟（在前面STM32CubeIDE第一个工程章节有介绍）。
SystemCoreClockUpdate函数的作用就是，根据时钟寄存器的值来更新SystemCoreClock变量。SystemCoreClock变量包含核心时钟频率（HCLK），用户应用程序可以使用它来设置SysTick定时器或配置其他参数。在程序执行期间，每次内核时钟改变时，都必须调用SystemCoreClockUpdate函数来更新SystemCoreClock变量值，如果不这样，SystemCoreClock变量值将会不准确，任何基于SystemCoreClock变量的配置都是不正确的。这么做也就是为了保证SystemCoreClock的准确性。
时钟部分在STM32中比较复杂，也不是三言两语能说的清楚，我们后面会分出专门的章节来讲解，并结合对应的实验来加深理解。

6.3.5 startup_stm32mp15xx.s文件
6 t1 C) }5 ?( N/ Z1.启动文件在哪
文件路径：Device\ST\STM32MP1xx\Source\Templates\gcc\startup_stm32mp15xx.s
$ {- k9 @' i; ~startup_stm32mp15xx.s是由ST官方提供的，一般直接拿来用，有需要的时候才会改写。它主要是用汇编语言编写，是系统上电后第一个运行的程序文件，属于启动文件。Device\ST\STM32MP1xx\Source\Templates下面有3个文件夹，每个文件夹下均有一个startup_stm32mp15xx.s文件，不同的开发环境使用不同文件夹下的startup_stm32mp15xx.s文件，STM32CubeIDE软件使用的是gcc下的文件，MDK软件使用的是arm下的文件，每个文件夹下的文件内容均不相同，但是他们的功能是一样的。
1 a! b( j. U/ C6 T
# Z+ s$ _( x* t7 S8 H

1 V7 w. a$ I7 s3 e- _+ ~+ |! O图6.3.5. 1 Templates文件夹
2. 启动文件中的部分指令
在分析启动文件前，我们先来了解几个汇编语法：


- u5 R; o8 ?) t' s9 E& N$ F
+ K. v# ?- ~6 B4 ^表6.3.5. 1部分汇编指令
4 K! H3 o: }" d# _& J% [+ [3. 启动文件分析
上表列举了STM32启动文件的一些汇编和编译器指令，关于其他更多的ARM汇编指令，大家可以查阅汇编语法的书籍。下面，我们借助文件中的注释，我们来分析一下startup_stm32mp15xx.s文件做了些什么工作。
1）设置栈指针SP；
2）设置初始PC= Reset_Handler；
2）设置中断向量表入口地址，并初始化向量表；
3）初始化.data 和 .bss 段；
4）跳转到C库中的main（最终调用main函数）。
; H0 S9 D; t1 n/ L# J在线程模式下复位了Cortex-M处理器后，优先级为Privileged（特权模式），栈顶设置为主函数。
我们将启动文件startup_stm32mp15xx.s的代码分成几个小段，简单分析一下代码实现的功能，代码中已经附上详细的注释，大家可以根据注释大概了解启动文件的整个工作过程。

5 X" O1 F4 j5 X5 ~

1. 1     .syntax unified               /* 指令使用统一的语法 ，提示下面是ARM+THUMB */
   
2. 2     .cpu cortex-m4                /* 指定处理器为Cortex-M4 */
   
3. 3     .fpu softvfp                  /* 使用软浮点 */
   : ?3 }, Z. f* v) G
4. 4     .thumb                        /* 指定汇编代码为Thumb指令集 */
   
5. 5  
   
6. 6   /* 使用.global定义全局符号g_pfnVectors 和Default_Handler */
   
7. 7   .global g_pfnVectors            /* g_pfnVectors其实是文件末尾定义的中断向量 */
   , p# N1 l5 _/ U, Q
8. 8   .global Default_Handler         /* Default_Handler是死循环，用来处理异常情况 */
   9 O) @8 K4 n. Z2 J
9. 9   
   6 {8 i' F3 w; L4 M: i+ t
10. 10  /*
    
11. 11   * 这里给出data段与bss段起始与结束地址，data段用来存
      N. D6 I, W4 E, ~7 p. G: ?
12. 12   * 储已经初始化的全局变量，bss段用来存储未初始化的全局
    
13. 13   */
    
14. 14  .word _sidata           /* 初始化.data 块的起始地址，此地址在链接脚本中被定义 */
    " e4 T2 w+ m# r) w% t6 @3 h
15. 15  .word _sdata            /* .data块的起始地址，此地址在链接脚本中被定义 */   
    & M7 g; f+ ]+ q& P+ r5 ^! b2 a' q! R
16. 16  .word _edata            /* .data块的结束地址，此地址在链接脚本中被定义 */   
    ! E+ D# X  b+ p
17. 17  .word _sbss             /* .bss块的起始地址，此地址在链接脚本中被定义 */
    . t0 b/ f+ t5 s  t+ C
18. 18  .word _ebss             /* .bss块的结束地址，此地址在链接脚本中被定义 */
    
19. 19  
    
20. 20  /* 定义了一个代码段，该段可分配(a)，可执行(x) */
    
21. 21    .section .startup_copro_fw.Reset_Handler,"ax"
    7 U& r4 V' z1 \, K; t/ u! Q1 `' I$ N
22. 22    .weak Reset_Handler     /* 弱定义一个符号，名字为Reset_Handler */
    
23. 23    /* 声明Reset_Handler是一个函数类型*/
    
24. 24    .type Reset_Handler, %function
      m/ o9 l0 A7 m! N- p( e0 w" T! J
25. 25     Reset_Handler:                 /* 标记 Reset_Handler符号位置 */
    
26. 26    ldr   sp, =_estack      /* 设置栈指针 */
    0 a9 d7 I; w' S3 r3 y- a4 [

复制代码

# I$ g: T9 L6 Y0 ?2 i第1行，.syntax命令是ARM架构独有的命令，指定按照怎样的语法规则进行汇编，.syntax unified表示下面的指令是ARM和THUMB通用格式。
6 \1 k4 d5 Y7 B4 \9 J第2行指定处理器为Cortex-M4。
$ ?' s- w, U5 t$ J第7和第8行定义两个全局符号，g_pfnVectors和Default_Handler。
7 x2 \2 U' _9 p. o' _9 _第14到18行，给出data段与bss段起始与结束地址。data段用来存储已经初始化的全局变量，bss段用来存储未初始化的全局变量。
+ d2 M+ {& M% I0 P. H1 T第25行，表示标志Reset Handler符号的位置，Reset_Handler（复位中断函数）就是复位之后首先执行的那段代码。接下来我们查看Reset_Handler都做了些什么。
& @0 \$ s! B! e( ]) S* n* {

1. 1   /*   
   2 s: G# a  t0 _3 c/ U5 ?3 p
2. 2    * 循环将数据从只读存储器复制到RAM。范围由以下在
   : u* ?5 U' _' y
3. 3    * 链接描述文件中评估的符号指定。
   ; e1 |% t" W3 ]
4. 4    * _sidata：代码段的结尾，即要复制的数据段的开头。
   
5. 5    * _sdata / _edata：应将数据复制到的RAM地址范围。
   . X- p9 s8 s, t, q, h) B
6. 6    * 两者都必须对齐4个字节的边界。
   
7. 7    */
   
8. 8     movs  r1, #0             /* 将立即数0赋值给r1寄存器 */
   6 Y! h! a7 y. c) T6 r6 z
9. 9     b  LoopCopyDataInit     /* 程序转移到LoopCopyDataInit处 */
   , I# E" m- n" @/ x0 E  z+ z7 e9 B
10. 10   /* 下面一段初始化在用户程序中指定初始值的全局变量 */
    - y5 [# M! D9 L3 |3 a
11. 11  CopyDataInit:   
    1 t+ v$ `) X" @- K# x7 ~
12. 12    ldr  r3, =_sidata      /* 使用ldr伪指令将初始数据地址加载到r3中 */
    $ X* x  S6 G  \$ {) {+ t- d5 x+ t1 r
13. 13  /* 从地址r3+r1处读取一个字（32bit）到r3中,r3为基地址，r1为偏移地址 */
    
14. 14    ldr  r3, [r3, r1]  
    
15. 15    str  r3, [r0, r1]          /* 把寄存器r3的值存储到存储器中地址为r0+r1地址处 */
    
16. 16    adds  r1, r1, #4           /*将r1地址中的内容写入r1，然后令r1 + 4 */
    
17. 17      
    
18. 18  LoopCopyDataInit:            /* 循环拷贝数据 */
    ; x: B2 Q0 J2 j
19. 19    ldr  r0, =_sdata           /*使用ldr伪指令，在r0中写入.data的起始地址 */
    2 m# E0 n1 y# y- ?7 ~" G% c
20. 20    ldr  r3, =_edata           /*在r3中写入.data的末尾地址 */
    1 x$ H0 m& Z# c" }, n0 n5 _
21. 21    adds  r2, r0, r1           /* r2=r0+r1 */
    
22. 22    cmp  r2, r3                   /* 计算r2 - r3,若小于0，标志位为0，反之为1 */
    
23. 23  /* 如果标志位为0（无借位）即r2<r3，则跳转到CopyDataInit处 */
    1 m: v8 N; D3 ?% w/ W8 h
24. 24    bcc  CopyDataInit
    
25. 25    ldr  r2, =_sbss                         /* r2中存储.bss数据区的首地址 */
    $ C+ H% {2 C- @5 T/ Y5 T( V
26. 26    b  LoopFillZerobss                 /* 无条件跳转到LoopFillZerobss */
    
27. 27   
    
28. 28  FillZerobss:
    4 m& o5 b$ J/ W9 m6 Q
29. 29    movs  r3, #0                         /*将立即数0存入寄存器r3 */
    7 {2 M6 z; n8 D% W$ T) l
30. 30  /* 将寄存器r3的值存储到地址为r2寄存器值得地址处后，r2 = r2 + 4 */
    
31. 31    str  r3, [r2], #4                 /* 将r3中的值写入r2，，然后r2自加4 */
    
32. 32      
    
33. 33  LoopFillZerobss:
    
34. 34    ldr  r3, = _ebss          /* 将bss数据区的末尾地址写入r3 */
    ' v/ d0 D, z# ~, T; N: t% Z
35. 35    cmp  r2, r3                    /* 比较r2,r3，然后更新标志位 */
    
36. 36    bcc  FillZerobss          /* 如果标志位为0（无借位），则跳转到FillZerobss处 */   
    9 `# x+ d5 D* J8 |
37. 37   
    . C4 M. u7 }* Z( @3 Y
38. 38  /* 调用时钟系统初始化函数 */
    
39. 39    bl  SystemInit                                  /* 跳转到SystemInit函数起始处 */
    8 R  _. m! X" P  s. S
40. 40   // ldr r0, =SystemInit
    
41. 41   // blx r0
    
42. 42  /* 调用静态构造函数 */
    / _+ K% x! y  v- S( I% H* ?) q. W
43. 43   bl __libc_init_array
    
44. 44   // ldr r0, =__libc_init_array
    / X) c3 y2 j6 F3 A- H! X) O
45. 45   // blx r0
    : h8 V; n0 P- }2 }: R1 Y1 n
46. 46  /* 调用应用程序的入口点 */
    8 R: {& C2 I7 h2 G7 D! T
47. 47    bl main                                            /* 转跳main函数执行 */
    
48. 48    //ldr r0, =main
    
49. 49    //blx r0
    ! Q* \+ p* S- O# n  l) r3 S
50. 50
    
51. 51  LoopForever:
    
52. 52      b LoopForever
    , K, f: A  L7 Z  E
53. 53
    ( J8 `' O" w4 k: f0 o1 B
54. 54     /* 计算.Reset_Handler段的长度，同时表示.Reset_Handler段结束 */
    
55. 55  .size Reset_Handler, .-Reset_Handler
    

复制代码

: C0 F, L  r# p以上就是Reset_Handler所做的工作，包括data段与bss段初始化过程。
第39行，转移到SystemInit函数起始处，SystemInit函数是在system_stm32mp1xx.c文件中定义的，它在主程序main.c执行之前被startup_stm32mp1xx.s文件调用，主要作用就是初始化FPU设置、配置SRAM中的向量表和禁用所有中断和事件，我们在前面已经有介绍。
第47行，在调用SystemInit函数以后，跳转到main函数中。
到这里终于明白了，原来，Reset_Handler所做的工作就是：先跳到SystemInit函数起始处，执行完SystemInit函数以后再跳转到main函数处，这么说，main函数并不是程序执行的第一段代码，只能说，main函数是应用程序的入口函数。
- m9 ]/ f* o8 q' c
; l" p7 s9 d; H/ w( N. L; e

1. 1   /* 这是当处理器收到意外中断时调用的代码。这只是
   
2. 2    * 进入一个无限循环，保留系统状态以供调试器检查
   ' G9 K  y' X: Z0 Q8 [1 P
3. 3    */
   
4. 4       .section .text.Default_Handler,"ax",%progbits
   0 D% Q( r4 R' p& K' I. ^( v6 L
5. 5   Default_Handler:          /* 默认中断向量(未重写的中断向量)，进入后一直死循环 */
   
6. 6   Infinite_Loop:
   
7. 7     b Infinite_Loop          /* 无条件跳转到Infinite_Loop，即无限循环 */
   6 |: l" I5 X# G7 l& ]
8. 8     .size Default_Handler, .-Default_Handler
   
9. 9   /*
   : W* k8 Y: V! U- x: v) \
10. 10   * 这个部分的作用是定义了Cortex M4的最小向量
    
11. 11   * 表，然后以字的形式分别填入了中断的指针
    ! L$ p5 P) p3 V2 \
12. 12  */
    5 K2 Q# V3 b- V5 \4 A/ ^
13. 13  /* 定义了一个中断向量表的段，该段可分配(a),段内包含数据 */
    
14. 14     .section .isr_vector,"a",%progbits  
    
15. 15  /* 声明 g_pfnVectors是一个数据对象 ,同时表示段以 g_pfnVectors符号位开始 */
    
16. 16    .type g_pfnVectors, %object
    
17. 17  /* 计算.isr_vector，同时表示.isr_vector段结束 */
    ' c' i6 P9 K, U3 a5 ^1 I$ |
18. 18    .size g_pfnVectors, .-g_pfnVectors  
    8 a) L4 h* L7 K& P
19. 19
    
20. 20        /* 下面部分是STM32MP1内部指定的中断向量 */
    4 M5 d8 R5 j: Q3 R1 C
21. 21  g_pfnVectors:                                   /* 标记 g_pfnVectors符号位置 */
    - ?: T2 j7 C1 w3 C5 d
22. 22  /*
    
23. 23   * 堆栈顶部，在当前位置放置一个word型的值，这个值为_estack；以下同理
    
24. 24   * 栈顶指针置于中断向量表首，Reset后读取中断向量表第一个值赋给sp指针
    
25. 25   */
    
26. 26    .word  _estack                            /* 堆栈顶部地址，复位后首先装载堆栈 */      
    2 G3 l& W% A1 v! x  V( w
27. 27    .word  Reset_Handler                  /* Reset Handler */
    3 [8 z! Z, |1 r, q( ~
28. 28    .word  NMI_Handler                     /* NMI Handler */
    
29. 29   
    
30. 30   /******此处省略部分代码******/
    
31. 31   
    
32. 32    .word  SysTick_Handler      /* SysTick Handler */
    % M: s, [# n1 t
33. 33
    2 a, W; j0 n+ @9 {! ?
34. 34    /****** 外部中断 ******/
    
35. 35   
    
36. 36    .word  WWDG1_IRQHandler    /* Window WatchDog 1 */
    ! w2 c2 S, H, ?  |2 p: d
37. 37    .word  PVD_AVD_IRQHandler                       
    * Y  C  I! L7 H5 ?
38. 38   /****** 此处省略部分代码******/
    1 v  H  Z5 Y+ O* d
39. 39    .word  RESERVED148_IRQHandler
    
40. 40    .word  WAKEUP_PIN_IRQHandler   
    $ M% ~6 q: `9 ]1 U
41. 41
    
42. 42  /*
    
43. 43   *此部分的作用是给中断服务定义了一个weak（弱）别名，这个弱别名的
    
44. 44   * 作用就是在有中断被触发后，如果没有重写对应的弱别名，那
    ) f  D; _* x0 U+ \, o" ^
45. 45   * 么程序就默认执行中断处理函数（Default_Handler），
    
46. 46   * 反之则执行用户重写了的中断处理函数。
    
47. 47  */
    7 f" L5 g% W$ Y) }2 X7 a9 J6 u( i
48. 48  /* weak，表示弱定义一个符号，符号名字叫 NMI_Handler */
    
49. 49    .weak      NMI_Handler   
    2 |$ }% S9 e. O/ T* ~. U( {1 c
50. 50    /* 如果没有重写这个弱定义的符号，则执行 Default_Handler，
    
51. 51    * 反之则执行重写的NMI_Handler，以下其它中断函数同理
    : e( L  D6 l$ M1 W) ]# C
52. 52    */
    , c0 Q# f+ |- I$ A: x3 Z  V+ q/ N% g
53. 53    .thumb_set NMI_Handler,Default_Handler
    - K# E6 P/ f& _5 ~- j2 D8 [
54. 54   
    ) i" ^( l) c. `
55. 55    .weak      HardFault_Handler
    
56. 56    .thumb_set HardFault_Handler,Default_Handler
    
57. 57   
    
58. 58   /****** 此处省略部分代码 ******/
    ! k7 p7 Y. |0 r) E+ W0 A
59. 59    .weak      WAKEUP_PIN_IRQHandler
    
60. 60    .thumb_set WAKEUP_PIN_IRQHandler,Default_Handler

复制代码

/ ]9 K! V+ _. `  G# k3 O- N第4到第8行，表示Default_Handler是一个无限空循环。
第14行表示定义了一个中断向量表的段，该段可分配，段内包含数据，这个表将会放置在地址为0x0000 0000处（也就是堆栈顶的地址），Cortex-M4复位后从此处取出数据用于初始化MSP寄存器。地址为0x0000 0004的表示复位向量（哪里得来的这些地址的？下面会结合一个Cortex-M4内核的中断映射表来讲解）。
第21到40行，定义了一个段来存放中断向量表，然后以字的形式分别填入了中断的指针。
, p7 c( N, X  e5 {$ l8 c4 c第49到59行，startup_stm32mp15xx.s文件中已经帮我们写好所有中断的中断服务函数了，不过这些中断服务函数都是空的，什么也不运行，即无限空循环。真正的中断服务函数需要我们自己去实现。其中，中断服务函数前面定义了一个弱（weak）符号，弱，就是表示此函数可以进行重写（重新定义），表示如果用户在其它地方重新定义一个同名函数，最终编译器编译的时候，就会选择用户定义的函数，如果用户没有重新定义这个函数（或者函数名字写错了），那么编译器就会默认执行带有弱符号的函数，并且编译器不会报错。带有弱符号的函数都可以进行重写。
什么意思呢，例如我们看到有很多类似的代码，如这部分代码：
. ~. |- X& k! m  [0 G.weak UART4_IRQHandler
: U2 q, A2 V3 g( g$ c8 Z% H.thumb_set UART4_IRQHandler,Default_Handler
.weak UART4_IRQHandler表示有一个中断处理函数，它的别名是UART4_IRQHandler，在前面有一个词weak（弱），表示此中断函数UART4_IRQHandler可以被用户进行重写（必须正确重写才会有效），重写的函数代替了这个函数。
; e" N+ N  p3 @- J2 q.thumb_set UART4_IRQHandler表示如果不重写UART4_IRQHandler函数的话，那么默认执行Default_Handler函数，也就是执行死循环。weak的作用其实是为了防止用户使能了中断而没有编写中断服务函数，从而造成程序崩溃。
* [: y9 K6 _. J- S8 b5 ^) m例如用户开启了串口4中断，根据前面中断向量表得出此中断服务函数名字为UART4_IRQHandler，如果用户只是开启中断，并没有去按照中断向量表给的中断函数名UART4_IRQHandler重写一个对应的中断处理函数（或者把中断函数名字写错了），那么，中断开启以后，系统默认执行Default_Handler，也就是一直执行死循环。如果按照中断向量表给的中断函数名UART4_IRQHandler重写了一个串口4的中断服务函数，那么中断向量表中的处理函数的地址就会更新为用户写的那个函数的地址了，即执行用户写的串口4中断函数，不会进入死循环。这点我们要注意，后面在中断有关实验章节会进行讲解怎么编写中断服务函数。
3 b. ~% d. l: o7 }+ M从第26到第40行是STM32MP157内部指定的中断向量表，我们也可以通过查看《STM32MP157参考手册》来了解Cortex-M4内核的中断映射关系，STM32MP157的M4内核中断管理器叫做NVIC，其系统中断（也叫内部中断）有10个，外部中断有150个，下图只是截图了一部分。
从表中了解到，地址0x0000 0000 是保留的，但其实是reset后MSP（主堆栈指针）的地址，Reset 中断的地址为0x0000 0004，NMI中断的地址是0x0000 0008。M4的中断映射范围0x0000 0000~00000x00000294。表中，priority 一列表示中断优先级，参数越小表示中断优先级越高。Fixed表示此中断优先级是固定的，不可更改，Settable表示中断优先级是可编程的，可以通过编程来更改。Acronym一列表示中断的名称，Description表示中断的说明，Address表示中断的地址。
# f) _! l1 h. X. L

& T6 G/ k+ V: Z
图6.3.5. 2参考手册部分截图
4 U3 ?' ~9 U/ c' w, b7 ]2 f* q0 W根据上表了解到，M4内核的中断向量表是从地址0x0000 0000开始的，位于BOOT区的RETRAM(64kB)，我们在用MDK或者STM32CubeIDE来调试程序的时候，M4的代码其实是放到了SRAM中运行了，其中M4可运行的SRAM是SRAM1(128kB)、SRAM2(128kB)、SRAM3(64kB)和SRAM4(64kB)，地址范围是0X10000000~0X1005FFFF，共384KB。如下的内存映射表可以清楚的看出内存映射关系：



图6.3.5. 3内存映射关系图
3 @; r, C: U0 N5 H' s讲到这里发现还有一个疑问，在startup_stm32mp15xx.s文件中并没有看到有关设置堆和栈大小的代码，它是在哪里设置的呢？我们知道，栈一般是存放函数的参数值和局部变量的值，由编译器自动分配释放，而堆用于存放进程运行中被动态分配的内存段，一般由程序员分配和释放。若工程中使用的局部变量较多，定义的数据长度较大时，如果不调整栈的空间大小，会导致程序出现栈溢出，程序运行异常。在STM32CubeIDE中，堆和栈是在Project Manager配置窗口进行配置的。如下图，默认堆512B，栈1KB，用户可以在此处设置堆和栈的大小。
( W7 q. e  L2 ]2 ~2 l* J. L6 _0 Y
, m( ]) F" b# n

图6.3.5. 4 CubeIDE中设置堆栈
8 d1 Y7 C: G1 h" B' r; L下面我们来捋一下启动文件的工作过程：
上电复位后，硬件会自动根据向量表偏移地址找到向量表，首先从0x0000 0000地址处加载初始MSP，然后从偏移为4的地址（0x0000 0004）处加载PC，0x0000 0004地址处存放的是Reset_Handler，即执行复位中断服务程，Reset_Handler主要做了两件事，一个是跳转到SystemInit函数完成必要的系统初始化，另外一个是跳转到main函数。然后，如果有中断发生，如果此中断对应的中断服务函数没有被用户重写，则系统进入无限空循环，如果此中断对应的中断函数被用户重写了，则执行用户重写的中断服务函数。
4. 系统启动流程
; u0 [8 u0 s! _$ |CM4内核启动，需要将拨码开关BOOT0、BOOT1和BOOT2设置为001，这个是芯片设计的时候就已经定好了的。STM32MP157 支持从多种不同的设备启动，通过设置拨码开关可以选择从指定的设备启动，启动方式如表：
4 p) |" G0 {' N2 T, o1 r- m
2 \- M0 v5 M- K; Z4 J6 t

0 Y: ^. H9 I$ f2 R# n" `表6.3.5. 2 STM32MP157启动模式
正点原子 STM32MP157 开发板上支持 USB、SD 卡、EMMC 以及 M4 内核这 4 种启动方式。
) z# w/ j/ [! i! \7 d& P我们知道启动模式不同，启动的起始地址是不一样的，例如STM32F4系列的芯片，CM4内核有可用的FLASH，代码下载到内部FLASH时，代码从地址0x0800 0000开始被执行的。当产生复位，并且离开复位状态后，CM4内核做的第一件事就是读取下列两个32位整数的值：
（1）从地址 0x0800 0000 处取出堆栈指针MSP 的初始值，该值就是栈顶地址。
3 W9 R7 N- {8 A1 I1 j, n- ~（2）从地址 0x0800 0004 处取出程序计数器指针PC的初始值，该值指向中断服务程序 Reset_Handler。下面用示意图表示，如下图所示。
0 w5 }' j, e; T# d# ]" d2 A
% S: D9 D+ k; k1 \* V/ f/ A
( y# R" @. r8 t0 M
图6.3.5. 5 STM32F4 FLASH启动
& r. i0 J. O7 l( Q& M换做STM32MP157，因为CM4内核没有可用的FLASH，所以在MDK或者STM32CubeIDE上仿真的时候，是将程序放到了SRAM中运行了。根据前面的分析，开发板从MCU启动，当产生复位，并且离开复位状态后，CM4内核做的第一件事：
（1）位于BOOT启动代码区RETRAM(64kB)的地址 0x0000 0000 处取出初始堆栈指针MSP 的初始值，该值就是栈顶地址。
8 H- q8 A" J- W" w7 y; `（2）从地址0x00000004 处取出程序计数器指针PC的初始值，该值指向中断服务程序 Reset_Handler。下面用示意图表示，如下图所示。

, i7 B( y" r/ D5 K" ]
6 F+ w1 U7 ]6 j8 G
, B0 J' m$ Z8 R图6.3.5. 6 STM32MP1 M4内核启动
上述过程中，内核是从0x0000 0000和0x0000 0004两个的地址获取堆栈指针MSP和程序计数器指针PC。事实上，0x0000 0000和0x0000 0004两个的地址可以被重映射到其他的地址空间，因为可以通过修改定义宏VECT_TAB_SRAM以及修改向量表偏移VECT_TAB_OFFSET来实现，前面在system_stm32mp1xx.c文件中有介绍。
下面，我们看看第一个工程实验，在STM32CubeIDE上仿真的时候，MSP和PC的值是多少（注意，此值不再是初始值，已经发生变化了）。
" t. H2 s4 N& i) ]进入Debug调试界面，然后打开Memmory窗口：
+ g) X1 `+ R7 G; ?3 x6 _. Z( T: [
) `3 t/ F/ Q4 {! k

图6.3.5. 7打开Memmory窗口
0 G- i6 t/ L4 `1 {" w添加观察地址0x00000000：
$ }; m) h, Y! z& {0 k
3 ~! u4 N" X$ }* k+ v  H

( K! R  c8 g0 C图6.3.5. 8 添加观察地址0x00000000
要注意，CM4内核是小端模式，所以读取下面的参数的时候，要倒着来读。0x0000 0000地址处的值是0x1004 0000，0x0000 0004的值是0x1000 3271，即堆栈指针 SP =0x1004 0000，程序计数器指针PC = 0x1000 3271（即复位中断服务程序Reset_Handler的入口地址）。
7 l: f7 D0 V% u# ~# O& H


图6.3.5. 9查看地址
当芯片上电后采样到BOOT0、BOOT1和BOOT2引脚电平为001，地址0x00000000和0x00000004被映射到内部SRAM的首地址0x1004 0000和0x1000 3271，内核从SRAM空间获取内容。在实际应用中，由启动文件startup_stm32mp15xx.s决定了0x00000000和0x00000004地址存储什么内容，编译后，在链接时，由stm32mp15xx_m4.ld链接脚本决定这些内容的绝对地址，即分配SRAM的哪个位置。下面我们来看看这个链接脚本stm32mp15xx_m4.ld。
9 u, n0 r" @: l  a3 `6.3.6 stm32mp15xx_m4.ld链接脚本
3 P% H! Z' {. v9 N6 k1 D前面我们通过启动文件了解了系统复位后做了些什么工作，但我们并不知道内存的分配信息是怎样的，当然很多时候我们不需关心这些，只要确保程序能正常运行就可以。关于内存排布，我们这里会介绍一个重要的文件：链接脚本。
本小节中，在介绍链接脚本的时候，我们也会介绍两个和链接脚本关系比较重要的文件，一个是链接时产生的map文件，另一个是编译后生成的反汇编文件。本小节只是作为一个了解性的内容，如感兴趣可以了解一下，也可以跳过本小节。
/ v/ A8 K$ _7 S( k# c1 v. ^
链接脚本
链接脚本路径：Device\ST\STM32MP1xx\Source\Templates\gcc\linker\stm32mp15xx_m4.ld
8 `- `0 c! t, v1 G


0 `' t5 p' G9 H$ |图6.3.6. 1链接脚本路径
在Device\ST\STM32MP1xx\Source\Templates\下的arm、gcc和iar下均有一个文件夹linker，里边放的就是STM32MP1系列的链接描述文件，其中，在STM32CubeIDE下，链接脚本为.ld文件，在KEIL中，链接脚本为.sct文件，在IAR中，链接脚本为.icf文件。
! n9 y/ D9 J; |8 b9 a
* {/ x" o* e+ e. z: i' J当构建工程的时候，STM32CubeIDE会按照我们选择的芯片型号生成一个.ld的链接脚本，
  T6 a# z8 x/ S& ]4 i9 u/ I, O: {链接脚本是用于描述文件应该如何被链接在一起形成最终的可执行文件的脚本，其主要目的是描述输入文件中的段（section）如何被映射到输出文件中，并且控制在输出文件中的内存排布。利用链接脚本我们可以控制代码的加载区以及执行区的位置。
, V5 a% m, X" M0 V! {程序的编译一般分为预处理、汇编、编译和链接这4个步骤，我们在STM32CubeIDE上只需点击编译图标就一次性完成了这4个步骤，其中的操作细节IDE已经通过层层封装屏蔽掉了。在编译过程中，编译器将.c和.s源文件编译生成很多以.o结尾的中间文件，这些中间文件包含了只读数据段、代码段、数据段、未初始化数据段等机器码信息，但是这些信息是放在最终可执行文件的哪个位置并没有确定下来，于是，链接脚本会告诉链接器，把所有的中间文件链接起来，并重定向它们的数据，然后链接生成可以被单片机运行的.elf文件。如果要生成.bin格式的文件，只需要通过格式转换就可以完成。



图6.3.6. 2程序编译过程
我们先回顾一下前面的STM32CubeIDE第一个工程编译信息，可以打开工程重新编译，然后将编译的信息拷贝到一个.txt文本文件中，这样方便浏览信息。如下图是删除部分编译信息后的内容：

$ G6 T! V- G2 e. ~; n) U

图6.3.6. 3编译信息
编译生成的文件在工程的CM4\Debug下，在里边的文件夹中有生成的中间文件。编译结束后提示Build Finished. 0 errors, 0 warnings，没有报错，最终生成HAL_LED_CM4.elf二进制文件。如果有配置编译生成其它格式的执行文件，那么编译器会执行相应的指令以生成对应的文件，这些配置可以在STM32CubeIDE中设置。
3 [2 `+ X0 [! w! v  S  x
0 O! Y: H; m! P' w9 P& D; G8 \
' v" a: P: q: ^* n% v
图6.3.6. 4配置编译生成的文件
如上图，设置编译生成.bin格式文件和反汇编文件，那么编译器在生成HAL_LED_CM4.elf文件以后，还会再执行以下指令：
0 R; T* f2 d, K: X5 Earm-none-eabi-objdump -h -S HAL_LED_CM4.elf > “HAL_LED_CM4.list”
* X0 e! @- ?; c2 K0 Rarm-none-eabi-objcopy -O binary HAL_LED_CM4.elf “HAL_LED_CM4.bin”
arm-none-eabi-objdump是反汇编指令，将 HAL_LED_CM4.elf文件进行反汇编，并生成HAL_LED_CM4.list文件。arm-none-eabi-objcopy命令表示复制一个目标文件的内容到另一个文件中，可用于不同文件之间的格式转换，最后将HAL_LED_CM4.elf格式转换成HAL_LED_CM4.bin文件。
1 _' b4 ~5 e" ^9 ?STM32CubeIDE的这些编译过程都是由一个makefile文件来控制的，makefile里边是一些shell脚本，描控制工程的编译过程。关于makefile我们这里不做专门讲解，感兴趣的话，可以在网上查询更详细的说明，或者看正点原子的《STM32MP1嵌入式Linux驱动开发指南》或《I.MX6U嵌入式Linux驱动开发指南V1.5》这两个教程，这两个教程是基于Linux操作系统的，对makefile有做部分介绍。

+ V) ^# K3 E1 @: @2 H2 j5 q

图6.3.6. 5编译生成的文件
' I: C# G: f( |& r  |C语言程序编译完成以后，编译出来的代码一般都包含text、data、bss 和 rodata 这四个段（section）。已初始化的全局变量保存在.data 段中，未初始化的全局变量保存在.bss 段中。text和data段都在可执行文件中，程序运行的时候，由系统从可执行文件中加载。而bss段不在可执行文件中，由系统初始化并清零。四个段以及堆和栈的简单说明如下：
; s6 o9 j# N" l; q! J. `: L
6 r$ z+ @: k2 A7 F# r/ m
/ Y5 B& T3 k. ~% R9 c9 p4 m
表6.3.6. 1代码中各个段简介


4 G$ t9 v8 n3 k8 J1 n
% Z' w- F3 f6 ~. z8 Y表6.3.6. 2堆栈简介
前面有看到通过STM32MP157DAAX_RAM.ld链接脚本，生成了HAL_LED_CM4.elf文件，这个链接脚本是怎样工作的呢？我们先看几个链接脚本的语法，然后再去查看链接脚本的代码实现过程。
# |, }4 z1 P. p5 ]- v- T1）入口地址
ENTRY(SYMBOL)
) z- L) H* T6 e2 x) Z2 @ENTRY(SYMBOL) ，表示将符号SYMBOL的值设置成入口地址，即程序执行的第一条指令的地址。
2）内存区域定义
3 ~* I/ `5 d1 y4 C1 B' b链接器在默认状态下可以为section 分配任意位置的存储区域，使用MEMORY命令可以用它来描述哪些内存区域可以被链接器使用，哪些内存区域避免使用。一个链接脚本最多可以包含一次MEMORY命令。

1. 1   MEMORY
   5 a3 B( n! H+ `* I
2. 2   {/* 名称  权限          起始地址            长度 */
   # _2 p- _, c3 e7 k) I) D0 Q, ~
3. 3     NAME [(ATTR)] : ORIGIN = ORIGIN, LENGTH = LEN
   
4. 4   }

复制代码

+ f' T* r4 s2 o$ \( TNAME 是在链接脚本中引用内存区域的名字，每块内存区域有一个唯一的名字。ORIGIN是起始地址，LENGTH是地址的长度。ATTR字符串是该内存区域的属性，其中：
r表示读section
2 H7 r9 C3 a6 x3 ]7 qw表示写section
; z( d: d3 z: ^3 Vx表示执行section
9 A5 L; Z3 v+ F* Sa可表示分配的section
- Q. m0 n( y& [5 T* m+ L7 xl（L）表示初始化了的section
! 表示不满足该字符之后的任何一个属性的section
/ f' w" f& d0 B" V7 R$ c9 @一旦定义了一个内存区域，就可以指示链接器把指定的输出段放入到这个内存区域中，方法是：通过使用’>region区域’。例如已经描述一个名为’mem’的内存区域，可以在输出段定义中使用’>mem’。
3）段链接定义
7 ?/ r' w4 h0 C' L: ^6 hSECTIONS 命令是链接脚本里非常重要的命令，它的作用是：告诉链接器，如何把输入文件的sections映射到输出文件的各个section，如何把输出section放入地址空间。跟MEMORY命令一样，一个链接脚本里只有一个SECTIONS 命令。如果整个链接脚本内没有SECTIONS命令, 那么链接器将所有同名输入section合成一个输出section内, 各输入section的顺序为它们被链接器发现的顺序。

1. 1   SECTIONS
   
2. 2   {
   , B5 a) [7 A# \3 E" p, T1 F: `- M) b
3. 3       .text :
   1 T* i3 W# k  N/ f, b
4. 4       {
   
5. 5       start.o (.text)
   
6. 6       *(.text*)
   & T( ^7 l2 ?$ v4 I
7. 7   } >region
   
8. 8        }

复制代码

第 1 行先写了一个关键字“SECTIONS”，后面跟了一个大括号，这个大括号和第 8行
4 X2 n+ q3 K3 X( v
的大括号是一对，这是必须的。看起来就跟 C 语言里面的函数一样。
' n7 D) c# X! W1 G第3行，“.text”表示段名，段名后面先空2个空格，然后再有一个冒号，表示段定义。例如.text :表示定义一个.text段，这个段定义可以自己定，段名可以自己取。
第4行到第7行就是段的内容，这部分内容比较复杂。start.o (.text)表示将工程文件中的start.o的.text段（即代码段）链接到MEMORY定义的region中。(.text)中的是通配符，表示将工程中所有目标文件的.text段链接到region中，在链接(.text*) 时，不会重复链接start.o的.text段。
3 Z* C) P* y1 S0 @- o第7行的’>region’就表示指示链接器把上面花括号中指定的输出段放入到这个region内存区域中（内存区域是在前面的MEMORY中定义的）。
段的内容比较复杂，下面是一些常见的用法：
. = ALIGN(4)：表示4字节地址对齐。也就是说段的起始地址要能被 4 整除，一般常见的都是 ALIGN(4)或者 ALIGN(8)，也就是 4 字节或者 8 字节对齐。
PROVIDE和PROVIDE_HIDDEN关键字：表示在链接脚本文件中定义一个符号，这个符号没有被目标文件定义，但是被目标文件引用。
" S: o, A$ @* Q/ A& I  XKEEP()关键字：KEEP() 的作用是当启用连接器的–gc-sections垃圾回收选项时，这部分不能被回收。如KEEP(*(.text))表示不能将所有的.text段当做垃圾回收。
/DISCARD/：是一个特殊的段名，如果使用这个段名作为输出，那么所有符合条件的段都被丢弃。
下面我们将stm32mp15xx_m4.ld文件的代码分为几个部分，查看链接脚本是怎样实现链接的。

' [- ]8 U/ Z: D; _' c

1. 1   /* 程序入口，程序将从Reset Handler开始执行 */
   
2. 2   ENTRY(Reset_Handler)
   
3. 3  
   . ?2 u$ u3 H7 K
4. 4   /* 用户模式栈的最高地址，声明内存末尾地址 */
   
5. 5   _estack = 0x10040000;                    /* 堆栈末尾 = RAM起始地址 + RAM空间大小 */
   
6. 6   /* 定义了堆和栈的最小空间大小 */
   
7. 7   _Min_Heap_Size  = 0x200;          /* 堆大小 */
   
8. 8   _Min_Stack_Size = 0x400;         /* 栈大小 */
   + B5 G! d/ C$ G+ i6 ]8 m
9. 9  
   * \8 z( V. Y- _/ A. U2 p
10. 10  /* 内存定义，‘MEMORY’ 命令描述目标平台上内存块的位置与长度 */
    0 C* v! Y# w9 z0 C
11. 11  MEMORY
    
12. 12  {/* 名称   权限（读R/写W/执行X）  起始地址            长度 */
    5 ]/ e4 m. f0 V) d5 x
13. 13    m_interrupts (RX)  : ORIGIN = 0x00000000, LENGTH = 0x00000298
    & O8 W, X( t! G( L5 d
14. 14    m_text       (RX)  : ORIGIN = 0x10000000, LENGTH = 0x00020000
    $ K( i( U8 x( v: ~* ]2 f
15. 15    m_data       (RW)  : ORIGIN = 0x10020000, LENGTH = 0x00020000
    
16. 16    m_ipc_shm    (RW)  : ORIGIN = 0x10040000, LENGTH = 0x00008000
    
17. 17  }
    # s) G4 D0 A1 g  M( Q. s( r: V6 h1 v
18. 18
    
19. 19   /* OpenAMP启用rpmsg所需的符号 */
    $ _: ?6 F' f2 F# a% e. e$ n" h
20. 20  __OPENAMP_region_start__  = ORIGIN(m_ipc_shm);
    
21. 21  __OPENAMP_region_end__ =

复制代码

; @1 K( }0 ~6 O3 j, c' ~, E& VORIGIN(m_ipc_shm)+LENGTH(m_ipc_shm);
0 l5 y. X+ N3 m3 `/ k第2行，程序入口，程序将从Reset Handler函数开始执行，该函数在启动文件startup_stm32mp15xx.s中有定义。
# @* R( h: m9 ?7 A2 _第5行，设置堆栈的最高地址为0x10040000，这里注意了，它决定了SP的位置，0x10040000就是我们前面分析startup_stm32mp15xx.s文件时系统启动流程小节里仿真时得到的SP地址，即0x0000 0000映射到内部SRAM的地址。
第7、8行，定义了堆和栈的最小空间大小，其中，设置堆大小为512B，栈大小为1KB。
第11到17行，以MEMORY命令定义了系统中可用于放置代码和数据的内存区域：
( q7 @4 t5 C% a# o0 X0 i' s①区域名为m_interrupts的地址范围是0x00000000~0x00000298，这个范围也就是M4内核中断向量表的范围，对应前面内存映射关系图中的RETRAM区域；
②m_text区域的地址范围是0x10000000~0x10020000，刚好对应内存映射关系图中的SRAM1区域，链接的是tex代码段（Code）；
3 T( W9 r5 |( c4 E③m_data区域的范围是0x10020000~0x10040000，对应内存映射关系图中的SRAM2区域，链接的是数据段（Data）；
④m_ipc_shm区域的范围是0x10040000~0x10048000，此范围落在了SRAM3中，ipc（Inter Process Communicaton）即进程通信，这个区域可以作为IPC缓冲区（IPC Buffers），也可以用于其它用途。
以上的链接地址就是程序的执行地址，找到链接地址了就知道程序是在哪里执行了。我们前面有提到内存映射关系图，在IDE中调试程序的时候，M4的代码其实是放到了SRAM中运行了，其中M4可用的SRAM是SRAM1(128kB)、SRAM2(128kB)、SRAM3(64kB)和SRAM4(64kB)，地址范围是0x100000000x1005FFFF，共384KB，如果只是M4跑裸机或者RTOS，不运行A7的话，这SRAM1SRAM4可以全部分配给M4，那如果要同时运行M4和A7的话，这些地址分配就要注意了：根据MEMORY命令定义的地址范围，我们知道m_text、m_data和m_ipc_shm占用了SRAM1SRAM3，SRAM1、SRAM2是完全分配给M4了，这里注意，如果要运行A7的话，M4并不是完全占用SRAM3，具体占用多少需要根据Linux下的设备树配置来决定，在A7和M4双核通信中，默认A7和M4共同占用SRAM3的0x100400000x10046000，这部分地址作为A7和M4通信的内存交换区，内核下的设备树如下：
1 e6 j* Q, m8 Z1 |. ^" v& ^  O) Z# e- }

9 a8 R& F. p1 R2 f+ M7 `9 c1 ~, W
) N  s4 l& _5 U9 H* V8 j6 d" y  f- w6 K图6.3.6. 6 设备树部分截图
) A$ ~+ h1 ~5 a) [而m_interrupts其实是在RETRAM里，剩下的SRAM4用于做什么呢？如果不跑Linux操作系统，只是跑M4裸机程序的话，M4内核完全可以使用这部分区域，由用户来指定。如果跑Linux操作系统，在Linux设备树下已经默认将SRAM4当做了Linux功能的DMA了，如果要释放这部分区域，在设备树下将对应节点删除释放即可（但不建议这么做，A7可能会异常）。
; O; E& s8 k7 Z7 Y( q根据上述描述，这几个区域对应关系如下图，从图中可以明显看出SRAM的地址分配情况：

- b) h- ]1 `" j1 s( M

4 u& d$ L, ?7 k) @4 o图6.3.6. 7 几个SRAM区域
( }: x' i9 M8 V& t. d综合以上分析，总结如下：
. H9 y( q! l) w9 C如果不跑A7，只运行M4（M4可以跑裸机、RTOS）：SRAM1~SRAM4可以完全分配给M4；
. _( D. q) _  w3 q9 f+ P5 K如果同时跑A7和M4（例如双核通信）：SRAM1和SRAM2是单独给M4用的，SRAM3的部分地址是M4和A7一起使用的，SRAM4在Linux下单独配置了DMA，即被A7占用了。
9 `6 @% D( g" F9 [  e如果要修改MEMORY中的地址区域范围，一定要联系内存映射表的地址范围来修改。
接下来是SECTIONS段链接定义，内容比较多已经省略部分：

1. 1   /* SECTIONS关键字，用来描述输出文件各个section的布局 */
   
2. 2   SECTIONS
   
3. 3   {
   4 w* `, B- n5 q0 {9 ^! X
4. 4   /* 将中断向量的内容链接到m_interrupts地址 */
   5 J( B3 n+ y# ?- X
5. 5     .isr_vector :         /*.isr_vector在startup_stm32mp15xx.s文件中有定义 */
   . Q5 F7 e- v: o  {$ x. a
6. 6     {
   4 i5 S  }& Y8 g' i) v
7. 7       . = ALIGN(4);    /* 4字节对齐，要求段的起始地址要能被4整除 */
   1 {3 `0 W0 @4 j& T/ a( p
8. 8       KEEP(*(.isr_vector)) /* 此处KEEP保证isr_vector的输出段不会被删除 */
   ) `- X# }1 o% H3 C' {" r
9. 9       . = ALIGN(4);
   
10. 10    } > m_interrupts                 /* 地址为0x00000000-0x00000298*/
    ' o1 U$ V( n: n3 n$ j
11. 11  /* 将程序代码和其他数据链接到m_text区域 */
    & d- i: s6 B9 \
12. 12    .text :                                          /* .text对应程序的可执行代码 */
    9 T: w# V! ^. h
13. 13    {
    $ ]8 _- Y( ]5 g3 i8 x
14. 14      . = ALIGN(4);
    
15. 15      *(.text)                  /* 将所有输入文件.o的代码段链接到MEMORY定义的m_text */
    ' W5 |% m* T9 V8 H5 a
16. 16      *(.text*)          /*将所有目标文件的.text段链接到 m_text中 */
    
17. 17      *(.glue_7)     /* glue arm to thumb code */
    # I, P) N- `9 `2 d% @
18. 18      *(.glue_7t)    /* glue thumb to arm code */
    2 ~7 W* ~* P& W: n( M( H
19. 19      *(.eh_frame)   /* .eh_frame 用于处理异常 */
    
20. 20      KEEP (*(.init))
    " v7 o; @# E7 ~: V8 Y) z
21. 21      KEEP (*(.fini))
    9 ~1 u* x+ ~0 L% G
22. 22      . = ALIGN(4);
    * d& \+ ], h  h( d& d6 N$ r+ u
23. 23  /* _etext是链接器的预定义变量，代表程序正文段结束的第一个地址 */
    
24. 24      _etext = .;                    /* 在代码末尾定义一个全局符号 */
    + f7 ]7 g; I7 R$ S* y$ [. }/ u
25. 25    } > m_text
    8 G6 r8 c# v/ Q# r8 G- X/ X* A
26. 26  /* 将常量数据链接到m_text */
    
27. 27    .rodata :
    
28. 28    {
    % \/ G; k) x1 l+ _) v
29. 29      . = ALIGN(4);
    1 g* L0 s# R8 n% G# O" r
30. 30      *(.rodata)                       /* .rodata 段 (常亮、字符串等) */
    
31. 31      *(.rodata*)                      /* .rodata* 段 (常亮、字符串等) */
    
32. 32      . = ALIGN(4);
    " E) W. y% j8 W) U" s& }6 k% e
33. 33    } > m_text
    
34. 34  /******* 省略部分代码 *******/
    
35. 35  /* 初始化数据段 */
    ; _3 X; o+ e, \* V* o1 l" j
36. 36    .data :  AT(__DATA_ROM)
    
37. 37    {
    
38. 38      . = ALIGN(4);
    5 T0 f' F/ ]& k! M8 W2 K" l
39. 39      _sdata = .;                /* 创建全局符号 */
    
40. 40      *(.data)                          /* .data 段 */
    
41. 41      *(.data*)                          /* .data* 段 */
    ) ]6 _* d; W2 w% U1 _7 ]- b* I2 q
42. 42      . = ALIGN(4);
    8 ~. k0 ^# Q( B! s6 A2 u
43. 43      _edata = .;  
    
44. 44    } > m_data
    
45. 45  /******* 省略部分代码 *******/
    
46. 46  /* 将程序中未初始化的全局变量链接到m_data中 */
    # b$ G* t& A# U- \
47. 47    . = ALIGN(4);
    * @( Z" u8 ?" {# u; [
48. 48    .bss :   
    
49. 49    {
    & l" K2 _% v* ]' ~  ~, r3 Y
50. 50  /******* 省略部分代码 *******/
    8 T# R& J! c) f
51. 51    } > m_data
    " F/ b( v, |7 ~; c) T& v/ q
52. 52    /*用于检查剩余的RAM是否足够 */
    ; y6 g) ]" O0 i. ~8 T; A
53. 53    ._user_heap_stack :
    2 @# w* W" S' z, G
54. 54    {
    
55. 55  /******* 省略部分代码 *******/
    : V, S) {/ D' d) m8 u) j
56. 56    } > m_data
    
57. 57  /* 从编译器库中删除以下信息 */  
    
58. 58    /DISCARD/ :
    
59. 59    {
    
60. 60  /******* 省略部分代码 *******/
    
61. 61    }
    ! e6 b; \% T5 _
62. 62    .ARM.attributes 0 : { *(.ARM.attributes) }
    
63. 63  }

复制代码

根据注释以及前面讲解的语法，整个链接脚本也很容易看懂。
第5到第10行，表示中断向量的内容，地址为0x00000000~0x00000298，这个区域是RETRAM。
第24行，_etext = .;中的小数点.表示当前地址，意思是_etext =的地址就是.text段的地址。
一般的程序中包含常见的几个段：text、rodata、data和bss段，这一部分实际上指定了程序的各个内容该如何放置在SRAM上。
; V! o) H6 c5 r2 c' `2 L. _在STM32CubeIDE上可以直接查看这些段的信息。例如第一个工程实验HAL_LED，编译完成以后，点击Window菜单Show ViewBuild Analyzer打开Build Analyzer窗口查看（注意，此时不是在Debug调试看的，是编译后查看的）：
1 d- [1 X2 \; @/ K+ D0 }1 q


图6.3.6. 8选择打开Build Analyzer窗口
在Build Analyzer窗口中可以查看内存使用情况。其中在Memory Regions处可以看到m_interrupts、m_text、m_data和m_ipc_shm的起始地址和结束地址，范围大小，以及使用量和剩余量。
3 w+ f; s, K* w) M+ y7 \# L. |4 \
. E- L; v" F; f0 I% s& \" E

6 T2 e0 d0 q. {) k; m# C' F图6.3.6. 9 Memory Regions窗口
在Memory Details处可以查看更详细的信息，VMA是虚拟地址，一般是RAM位置这里指运行地址，LMA一般是加载地址，即ROM位置。
) U  s) z1 d) a; |7 O( g2 M, [
$ _# C/ C5 m# ^

, B" T% t/ O: S# }# Q8 v图6.3.6. 10 Memory Details信息
通过链接脚本的内容，我们大概知道每段链接到了哪段内存区域，程序的链接地址一般也就等于运行地址（这点大家要记住）。其实我们也可以通过查看.map文件和反汇编文件来进一步研究我们链接脚本和代码的实现，下面我们分两个部分来讲解这两个文件。
5 n, N# ~: l/ t3 s; Y% T8 u3 w2. MAP（地图）文件
我们编写的代码，在IDE上经过编译和链接以后会生成一个.elf格式的文件，同时也会生成一个.map格式的文件，如前面我们看到的HAL_LED_CM4.map文件。map就是地图、示意图的意思，map文件是链接器的输出，提供有关所生成的.elf文件中的符号、地址和分配的内存的信息，当试图了解调试的程序大小和内存使用情况时，map文件非常有用。
我们打开前面的HAL_LED_CM4.map文件，查看文件中都有什么内容，下面的截图中，由于文件路径比较长，于是只截图了一部分。
4 ^: v  R) L: ^& H3 PArchive member included to satisfy reference by file (symbol)部分：
' J& F  u# r8 H5 ^) f6 f
0 \; r: G3 Z0 M4 }9 P, K
: j; Z) M# J2 C2 n0 j9 B
图6.3.6. 11 存档文件部分
* u& w( `' f% ~此部分属于存档文件，通常存储目录结构，包含系统中各种归档文件中包含的所有成员，以满足文件(符号)的引用，这些信息并不是特别有用，但是可以看到所有的系统功能。
& D* s# C: l3 NAllocating common symbols部分：



图6.3.6. 12符号分配部分
此部分是常见的符号分配，显示了已在程序中分配的全局符号（即全局变量）的名称和大小，这是检查所有全局变量是否具有预期大小的好地方。一个常见的错误可能是在不知情的情况下，分配了一个大的全局变量，这会消耗大量内存空间。通过此处可以了解到工程中使用的全局变量的名称和大小，如果大小不合理，可以在工程中稍微调整。
7 O. P- P1 v$ U  U; C8 j- ]- \Discarded input sections部分：


7 J% B2 W. W( @' C
图6.3.6. 13丢弃的输入部分
* v" Y. V+ J3 D& X9 @此部分是丢弃的输入部分，很多时候可以不用管。
4 e- f2 _2 x$ F  I( mMemory Configuration部分：

/ g! d  q7 p. C( H1 d0 n' g
8 C6 l3 _( o+ V4 y
图6.3.6. 14内存配置信息部分
! B9 L7 ^$ G; e2 m) P% @$ n此部分属于内存配置信息，这部分的信息应该与链接脚本中的内存配置范围相同。
/ t* f& D( @, P' F9 o/ }Linker script and memory map部分：
$ {8 v% x( [2 B4 s6 ?
# `( l' h+ ?3 z5 L
: a6 p9 Q0 l+ F
图6.3.6. 15内存映射
此部分详细说明了按链接脚本文件中定义的部分而划分的内存映射，其提供了有关程序中所有内容映射位置的大量信息。每个顶级节（例如.text）都具有内存映射中的起始地址以及列出的大小（以字节为单位）。然后，将每个部分细分为各个目标文件，并列出起始地址和大小。最后，每个目标文件都分解为目标文件中的各个功能，并列出了每个功能的起始地址。这可以帮助我们能够了解哪些目标文件可能包含程序执行不必要的大功能。当查看程序中的指针地址时，它也可以提供上下文。
我们可以通过配置IDE来选择是否生成.map文件，选中工程，打开Properties配置项，点击C/C++ Build–Settings–MCU GCC Linker找到链接器的配置项General，如下图是系统默认的配置项，其中：
  b4 H& U# B0 _" k- uLinker Script(-T)是配置用哪个链接脚本，如果您有自己的链接脚本，也可以在此处配置以选择使用自己的链接脚本。
Generate map file (-Wl,-Map=)此项表示是否要生成.map文件，一般是默认选择的，如果不需要生成.map文件，可以去掉此项。
Do not use standard start files (-nostartfiles)表示链接时不要使用标准的启动文件(-nostartfiles)，此项一般不选，因为我们要用到启动文件。
No startup or default libs(-nostdlib)表示没有启动库或默认库（-nostdlib）。
Do not use default libraries(-nodefaultlibs)表示不要使用默认库（-nodefaultlibs）。
2 W9 R4 k+ o4 [* F! o' Z$ p! {


图6.3.6. 16 CubeIDE配置
$ |3 e: R! F# ~/ v+ l! B  N6 @其它选项一般不需要再配置，如果有必要，可以尝试配置，例如Add symbol cross reference table to map file(-Wl–cref)表示将符号打印出来，并按名称排序。如果勾选此项，对于每个符号，会给出一个文件名列表，如果定义了符号，则列出的第一个文件是定义的位置，其余文件包含对该符号的引用。

  B. c9 A6 M: V2 T3 {6 Q

5 s9 b* r9 ?/ P) r  l2 Q) I图6.3.6. 17其它配置
调试程序时，map文件是信息的重要来源，它记录项目中每一个Symbol的地址、每个段的区域范围、各区段的大小等重要信息，可以通过map文件查看程序段或数据段的大小，查看高地址数据范围等等。尽管map文件的信息非常密集并且有些令人生畏，但理解和使用map文件可以为我们提供很多有用的信息。
9 m' o( U* _0 |# I$ D2 u$ V3. 反汇编文件
( h6 ^- }  E7 u" u7 s把机器语言转换为汇编语言代码的过程，我们叫反汇编(Disassembly)。反汇编常用于软件破解、软件汉化、病毒分析等。理解反汇编语言，对C语言代码理解、软件调试、程序漏洞分析是很有帮助的，大多数情况下我们都是用 C 语言写试验例程的，有时候需要查看其汇编代码来进行调试。STM32CubeIDE已经自动将HAL_LED_CM4.elf文件反汇编得到HAL_LED_CM4.list文件了，我们打开此文件大概浏览一下：
2 ]) y) M( {$ J& q+ L
+ X" o- e* ]# v/ {; N

1. 1       HAL_LED_CM4.elf:     file format elf32-littlearm
   & f- ]) ^% W3 S
2. 2   
   ) @5 ~% \+ L  g5 n9 N" p+ c
3. 3       Sections:
   ; Z/ |$ ^0 S' |, t
4. 4       Idx Name          Size      VMA       LMA       File off  Algn
   
5. 5         0 .isr_vector   00000298  00000000  00000000  00010000  2**0
   1 I* D4 N" e& o' c3 ~
6. 6                         CONTENTS, ALLOC, LOAD, READONLY, DATA
   ; _: S7 ~3 w, Z6 [
7. 7         1 .text         0000255c  10000000  10000000  00020000  2**2
   5 f$ ^1 e8 K6 x" x
8. 8                         CONTENTS, ALLOC, LOAD, READONLY, CODE

复制代码

如上是反汇编文件开头的部分代码，第1行表示由HAL_LED_CM4.elf文件反汇编得到文件，文件格式是elf32位的，且是小端模式存放。第3行表示要列出段，接下来第4段到第8端列出段，其中Idx表示索引，Name表示段名，Size表示该段的大小。VMA是虚拟地址，一般是RAM位置，LMA一般是加载地址，即ROM位置。File off表示段所在位置（指距离.elf文件的 Header 00000000）的偏移。
! O+ v8 u1 z3 _. G3 ACONTENTS、ALLOC、LOAD、READONLY、DATA这些表示段的属性。
- G8 O, {; V3 R% b! v$ r
  x. z9 c' F$ r! i! XCONTENTS表示该段在文件中具有相应的内容；
( S  v" W/ s0 v9 W, R' aALLOC表示该部分占用内存；
9 ~5 L* a  y: g$ `% j6 fLOAD表示该段在可加载段中，当创建进程时，其内容可以从文件读入存储器；
READONLY表示该段不可执行，也不可写；
DATA表示该段不可执行，但可写；
" Q+ Q! i4 y! QCODE表示包含要执行的指令。
例如.text这段，它包含程序可执行的代码，所以显示CONTENTS；该部分占用内存，所以显示ALLOC；它的内容从文件中加载，所以显示LOAD；编译好的程序代码是不可修改的，它放置在只读存储器中，所以显示READONLY；.text段包含要执行的指令，因此显示CODE。
: [* L6 ?- i, g9 n: S" b) V我们再看之后的反汇编部分：

1. 1       Disassembly of section .text:
   
2. 2   
   
3. 3       10000000 <__do_global_dtors_aux>:
   
4. 4       10000000:   b510        push    {r4, lr}
   " v% G5 f( w. }9 @3 G
5. 5       10000002:   4c05        ldr r4, [pc, #20]   ; (10000018 <__do_global_dtors_aux+0x18>)
   
6. 6       10000004:   7823        ldrb    r3, [r4, #0]

复制代码

" ^% c, D1 B' w* S3 L第1行，说明反汇编文件是.text段。
第3行，10000000表示指令地址。
第4行，10000000表示指令地址，b510表示指令机器码，push  {r4, lr}表示指令机器码反汇编得到的指令。



在反汇编文件中找到如上图代码，Reset_Handler处指令地址是0x10003270，和我们前面分析startup_stm32mp15xx.s文件时系统启动流程小节里仿真时得到的PC = 0x1000 3271很相近，说明和我们前面猜想的一样。
查看反汇编代码，里边的地址从低到高排列，最高地址是0x10040000，这个是因为链接脚本里有定义栈的最高地址为_estack = 0x10040000，如果将_estack = 0x10040000改为_estack = 0x10020000，再编译工程，可以看到反汇编文件中最高的地址变成了0x10020000（也就是SP地址有原来的0x10040000变成了0x10020000），可以看到.text段的VMA(SRAM的地址)地址是0x10000000，这是前面的链接脚本中定义的m_text区域的起始地址，如果把m_text区域的地址进行调整，例如起始地址改为0x10000100，编译后，汇编文件中.text段的VMA地址就变成了0x10000100。
# ]' p* y9 e( r% Y( r* L) j1 {反汇编的好处是可以帮助我们理解链接脚本，有时候可能我们会自己写链接脚本，通过查看反汇编文件可以帮助我们检查链接脚本的错误。

6.3.7 Include文件夹
1 Z3 X4 a  V. j  r4 V8 U8 v% zInclude文件夹下是符合CMSIS标准的内核头文件，我们在使用STM32CubeIDE创建工程的时候，系统会自动为我们添加这部分文件。
' f2 c( J1 F! v& F, W5 B* }


% y" P8 y* O% V# d8 o图6.3.7. 1 Include文件夹内容
在这些文件中，以cmsis开头的是和CMSIS编译器相关的文件，core开头的是和 Cortex-M 内核相关的文件， MPU开头的是和MPU相关的文件。普通的工程我们只需要cmsis_compiler.h、cmsis_gcc.h、cmsis_version.h、core_cm4.h和mpu_armv7.h就可以了，如果是特殊的工程，则还会需要其它文件，例如和TrustZone安全方面相关的工程，那就需要tz_context.h文件。在这些文件中，我们这里稍微关注core_cm4.h 内核文件，至于其它文件，如果有想要深入学习内核的朋友可以配合内核相关的手册去学习。下面，我们简单介绍core_cm4.h这个文件。
如下，我们看到core_cm4.h文件包含了stdint.h文件：
#include <stdint.h>
9 ~: F' R/ p, T$ mstdint.h是C99 （C语言规范）中引进的一个标准C库的头文件，其定义了几种扩展的整数类型和宏。现在编译器对C99的支持已经做的很好了，大部分单片机C编译器均支持C99标准，例如IAR、MDK和STM32CubeIDE等，linux 系统下的编译器也支持。在STM32CubeIDE安装目录\plugins\com.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.7-2018-q2-update.win32_1.4.0.202007081208\tools\arm-none-eabi\include下就有stdint.h文件。stdint.h的作用就是提供了类型定义，其包含了_intsup.h和_stdint.h文件。

1. 1   #ifndef _STDINT_H
   
2. 2   #define _STDINT_H
   ; B) {: D) D! J8 \! O- h1 y" O
3. 3
   * d# g8 c0 ~) ?; ?' {! {9 X
4. 4   #include <machine/_default_types.h>
   
5. 5   #include <sys/_intsup.h>
   
6. 6   #include <sys/_stdint.h>

复制代码

这些文件中定义了我们程序中用到的部分类型，在IDE上可以找到这些定义的实际类型，例如，通过查找，得出__UINT32_TYPE__表示long unsigned int，而：

1. 1   typedef __UINT32_TYPE__ __uint32_t;
   
2. 2   typedef __uint32_t uint32_t ;

复制代码

8 A  B* B" N9 B& y' b/ \所以，今后我们在程序中看到的uint32_t实际上表示long unsigned int（无符号长整型），而uint8_t表示unsigned char（无符号字符型），int8_t表示signed char等。
6 {" t) \1 Q. G4 l6 ~( a# {在core_cm4.h文件中，我们还看到很多关于中断相关的函数定义和类型定义，例如，开启中断函数NVIC_EnableIRQ、禁止中断函数NVIC_DisableIRQ、设置中断优先级分组函数NVIC_SetPriorityGrouping和中断优先级函数NVIC_SetPriority，这些函数会在HAL库中调用以实现中断功能。此外，还有内核的外设相关定义，如SysTick实时系统内核时钟相关寄存器和函数都在core_cm4.h文件中定义。如下是中断控制器(NVIC)类型定义。
  }; |* V2 p7 F9 J# P

! p. S$ b2 v3 g' R( N& x6 U
图6.3.7. 2中断控制器(NVIC)类型定义
# i# X) A9 @# ~( x9 R, mcore_cm4.h文件就介绍到这里了，在这里我们不对core_cm4.h文件的内容做深入的讲解，相关的介绍我们后面会结合实验例程来加深理解。
6.4 章节小结
9 F' a6 [4 N1 Y% n) f$ Y1 u$ q本章节洋洋洒洒地写了几十页，并不是为了“拉长战线和故意占用篇幅”， 实际上，要好好学习HAL库，要分析的东西还不仅仅这些。大家都知道，ST提供的这个固件库已经封装好了，在开发中我们只需要调用对应的API就可以实现想要的功能。不管它封装的多好，本质上还是操作寄存器。我们在学习过程中，不能只停留在理解的表面上，应该尝试去理解它的本质上的东西，通过分析，我们可以理解它的架构，这有助于日后的学习和开发。
本章节主要对STM32CubeMP1固件包的架构以及CMSIS文件夹中的部分重要文件做了介绍，重点对我们后面会用的CMSIS文件夹下的Device文件夹以及Include文件夹中的部分文件做了介绍。
9 j) F7 N) C' L& b; Q0 f; }  K通过分析stm32mp1xx.h文件，我们可以确定代码中是否使用或者不使用某个底层驱动文件。通过定义宏CORE_CM4、STM32MP157Dxx和USE_HAL_DRIVER，我们可以在工程中包含必要的头文件，如果换了另一款STM32芯片，我们同样可以通过分析对应头文件来确定这些信息。

$ N1 Z" |) c& L& o, e8 H4 N2 ~

图6.3.7. 3几个宏定义
通过分析stm32mp157dxx_cm4.h头文件，我们知道了固件库中对STM32MP157dxx系列器件的设备资源采用结构体的形式进行了封装，如果我们要访问某个寄存器，只需要定义一个结构体指针，然后通过指针来读写对应的寄存器（结构体成员）就可以了，HAL库中就是采用这样的方式来操作外设的寄存器的。
6 V7 s2 S/ E5 g- C3 n6 ]通过分析system_stm32mp1xx.c文件，我们认识了系统初始化函数SystemInit、系统时钟更新函数SystemCoreClockUpdate和SystemCoreClock全局变量，同时也了解了怎么开启STM32MP1的硬件 FPU 功能。
- a& w5 [: O9 g) ~6 O通过分析startup_stm32mp15xx.s启动文件，我们知道了main函数并不是程序执行的第一段代码。上电后，通过boot引脚设置可以将中断向量表定位于起始地址0x0000 0000，同时复位后PC指针位于0x00000004地址处（Reset_Handler），Reset_Handler主要做了两件事，一个是跳转到SystemInit函数完成必要的系统初始化，另外一个是跳转到main函数入口。

+ P# c) `* S' b: S& L2 T
7 `  T% \, H( h( p
图6.3.7. 4系统启动过程
' v( }0 W1 j& o* L% f* @1 S5 S6 e通过分析stm32mp15xx_m4.ld链接脚本，我们知道了编译好的输入文件中的每个段是如何被映射到输出文件中的，其中，text代码段位于SRAM1，data数据段位于SRAM2。此外，我们还分析了HAL_LED_CM4.map地图文件和HAL_LED_CM4.list反汇编文件，编译生成的.elf文件中的符号、地址和分配的内存的信息都可以在地图文件中查看。反汇编文件可以辅助我们检查代码的缺陷，在实际项目开发中，这些文件是非常重要的。



! o: g& q. w$ t图6.3.7. 5M4内核可用的SRAM
4 U9 P# N1 h+ P+ M/ }) KInclue文件夹下主要是符合CMSIS标准的内核头文件，在M4裸机开发中，我们主要用的是core_cm4.h文件，此文件中主要是关于中断相关的函数定义和类型定义，还有内核的外设相关寄存器的定义，例如核外设SysTick。
  g7 u! B+ q9 \  K————————————————
" g4 `2 F" r( x版权声明：正点原子
. J; V# J; L/ B7 |! l6 i* t2 n* b: G
/ X2 j4 Z2 l/ d. w2 R+ |. F