1 引言
半年前入手了Pixhawk V2全套硬件，编译好的开源固件也下了，四轴也飞了，一直想对这套开源飞控进行一个系统地解析，由于工作原因一直没时间。最近翻开了PX4飞控源代码，它基于NUTTX操作系统，在github上更新十分迅速。为了能够全面地掌握这套软硬件设计思想，同时对硬件系统有全面的认识，我决定对PX4 Bootloader进行详细解析。凡涉及到硬件相关的部分，本文以Pixhawk V2的主控STM32F427和IO协处理器STM32F100为基础进行解析，其他硬件可参照此方法进行类比，基本结构都是相似的。
感谢韦东山老师u-boot视频，我用同样的方法对PX4 Bootloader采用类似的方法进行了分析。针对我解析中存在的问题，希望同行和前辈们能够不吝赐教，谢谢。
2 PX4 Bootloader系统架构
从github上下载之后，打开Bootloader文件夹，可以看到libopencm3和Tools共2个文件夹和一共30个文件。
libopencm3和Tools这两个文件夹的主要功能如下：
- Tools文件夹主要用于coding style和git submodule的检查，不需要太注意。
- libopencm3是github上针对STM32系列芯片的开源库，Bootloader使用其中的库函数对相应型号的芯片进行操作，用到的地方将对库函数功能作简要说明，这里并不展开讨论。
其余30个文件主要功能如下：
- 工程文件：包括Bootloader.sublime-project共1个文件，为sublime编辑器的工程文件。
- Readme：包括Readme.md文件共1个，自己看，都能看懂。
- License：包括LISENCE.md文件1个，权限文件，自己看。
- Makefile文件：包括Makefile、Makefile.f1、Makefile.f2、Makefile.f3、Makefile.f4、Makefile.f7共5个文件，为系统的编译过程提供了依据。
- Jtag配置文件：以.cfg结尾，包括jig_px4fmu.cfg、stm32f1x.cfg、stm32f3x.cfg、stm32f4x.cfg、stm32f102.cfg共5个文件，分别对应不同的Jtag烧写器、不同芯片使用openocd进行烧写时的配置。根据原理图可知，PX4 Bootloader可以使用Jtag接口进行程序烧写，某宝上买的Pixhawk V2拆开后在板上可以看到两个Jtag接口（分别对应主控STM32F427和协处理STM32F100），但是没有焊接出来，如需烧写bootloader程序可自行焊接。
- 硬件配置头函数：包括hw_config.h共1个文件，规定了各类可运行PX4开源飞控程序的硬件配置，可与原理图对应查看。
- 通用bootloader调用函数集：包括bl.h和bl.c共2个文件。提供了bootloader的main函数中需要调用的通用函数，这些函数与具体硬件无关，属顶层调用函数。
- USB调试接口函数集：包括cdcacm.h和cdcacm.c共2个文件。提供了bootloader程序基于USB接口进行调试时所需的输入输出函数。
- 串口调试接口集：包括usart.h和usart.c共2个文件。提供了bootloader程序基于串口进行调试时所需的输入输出函数。
- main函数：包括main_f1.c、main_f3.c、main_f4.c、main_f7.c共4个文件。分别对应STM32F1、STM32F3、STM32F4和STM32F7芯片上运行的Bootloader的主函数。
- 链接文件：以.ld结尾，包括stm32f1.ld、stm32f3.ld、stm32f4.ld、stm32f7.ld共4个文件。分别对应STM32F1、STM32F3、STM32F4和STM32F7芯片上Bootloader程序的链接方式。
- PX固件生成脚本：包括px_mkfw.py共1个文件。根据文件说明，PX4固件为基于JSON编码的python对象，此脚本用于生成包含额外编码域的压缩文件固件，类似于u-boot中mkimage程序，生成的固件上传前需要用此脚本进行打包。PX4的固件本身已经具有这项功能，这个脚本应该不再需要了，应该很快会被丢弃。
- PX固件上传脚本：包括px_uploader.py共1个文件。根据说明，此文件不再使用，已被固件中的上传脚本取代。
综上所述，这里需要重点分析的文件包括Makefile文件，链接文件，main函数文件，硬件配置头文件（hw_config.h），通用bootloader调用函数集文件（bl.h和bl.c），USB虚拟串口函数集文件（cdcacm.h和cdcacm.c），串口函数集文件（包括usart.h和usart.c）。
3 Makefile文件解析
PX4 Bootloader工程包含5个Makefile文件。其中Makefile是make命令的入口文件，将根据不同的编译对象，调用不同的Makefile.*文件。为了更清晰地了解Bootloader的编译过程，本节将对工程的Makefile进行详细注释。
3.1 主Makefile文件注释
Bootloader编译的make命令入口为根目录下的Makefile，这是所有编译命令开始的文件。
Makefile
#
# Paths to common dependencies
#
export BL_BASE ?= $(wildcard .) #获取Bootloader本地工程所在目录，并赋给变量BL_BASE
export LIBOPENCM3 ?= $(wildcard libopencm3) #获取开源库libopencm3所在目录，并赋给变量LIBOPENCM3
#
# Tools
#
export CC = arm-none-eabi-gcc #定义交叉编译工具链变量CC
export OBJCOPY = arm-none-eabi-objcopy #定义二进制生成工具链变量OBJCOPY
#
# Common configuration
#
export FLAGS = -std=gnu99 \ #使用GNU99的优化C语言标准
-Os \ #专门针对生成目标文件大小进行
-g \ #生成调试信息
-Wundef \ #当没有定义的符号出现在#if中时警告
-Wall \ #打开一些有用的警告选项
-fno-builtin \ #不接受没有__buildin__前缀的函数作为内建函数
-I$(LIBOPENCM3)/include \ #包含开源库libopencm3的头文件
-ffunction-sections \ #要求编译器为每个function分配独立的section
-nostartfiles \ #链接时不使用标准的启动文件
-lnosys \ #链接libnosys.a文件
-Wl,-gc-sections \ #传递-gc-sections给连接器，删除没有使用的section
-Wl,-g \ #传递-g选项给链接器，兼容其他工具
-Werror #把警告当错误，出现警告就放弃编译
export COMMON_SRCS = bl.c cdcacm.c usart.c #定义通用源文件变量COMMON_SRCS
#
# Bootloaders to build
#
TARGETS = \ #定义编译目标
aerofcv1_bl \
auavx2v1_bl \
crazyflie_bl \
mindpxv2_bl \
px4aerocore_bl \
px4discovery_bl \
px4flow_bl \
px4fmu_bl \
px4fmuv2_bl \
px4fmuv4_bl \
px4fmuv4pro_bl \
px4fmuv5_bl \
px4io_bl \
px4iov3_bl \
tapv1_bl
all: $(TARGETS) #编译目标all=$(TARGETS)
clean: #定义清理工程的操作（即make clean）
cd libopencm3 && make --no-print-directory clean && cd .. # 从Bootloader本地工程目录进入libopencm3文件夹，执行make clean清理命令，然后回到上一级目录。
rm -f *.elf *.bin #删除.efl和.bin文件
#
# Specific bootloader targets.
# 各编译目标的具体操作，主要规定了编译需要使用的Makefile文件，硬件目标TARGET_HW，链接脚本LINKER_FILE，编译目标TARGET_FILE_NAME
#
auavx2v1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=AUAV_X2V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
px4fmu_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_FMU_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
px4fmuv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_FMU_V2 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
px4fmuv4_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_FMU_V4 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
px4fmuv4pro_bl:$(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_FMU_V4_PRO LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ EXTRAFLAGS=-DSTM32F469
px4fmuv5_bl:$(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f7 TARGET_HW=PX4_FMU_V5 LINKER_FILE=stm32f7.ld TARGET_FILE_NAME=$@
mindpxv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=MINDPX_V2 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
px4discovery_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_DISCOVERY_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
px4flow_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_FLOW_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
px4aerocore_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_AEROCORE_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
crazyflie_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=CRAZYFLIE LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
# Default bootloader delay is *very* short, just long enough to catch
# the board for recovery but not so long as to make restarting after a
# brownout problematic.
#
px4io_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f1 TARGET_HW=PX4_PIO_V1 LINKER_FILE=stm32f1.ld TARGET_FILE_NAME=$@
px4iov3_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f3 TARGET_HW=PX4_PIO_V3 LINKER_FILE=stm32f3.ld TARGET_FILE_NAME=$@
tapv1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=TAP_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
aerofcv1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=AEROFC_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
#
# Binary management
# 二进制文件压缩操作：deploy命令
#
.PHONY: deploy
deploy:
zip Bootloader.zip *.bin
#
# Submodule management
# 子模块libopencm3操作与管理，进行的操作如下：
# 1. 更新git子工程libopencm3。
# 2. 调用Tools/check_submodules.sh检查当前libopencm3的版本信息是否正确。
# 3. 编译libopencm3工程，生成库文件，供bootloader使用。
#
$(LIBOPENCM3): checksubmodules
make -C $(LIBOPENCM3) lib
.PHONY: checksubmodules
checksubmodules: updatesubmodules
$(Q) ($(BL_BASE)/Tools/check_submodules.sh)
.PHONY: updatesubmodules
updatesubmodules:
$(Q) (git submodule init)
$(Q) (git submodule update)
3.2 主控Makefile.f4文件注释
由主Makefile中目标生成语句可以看出，Pixhawk V2硬件系统的主控stm32f427对应的bootloader调用了如下语句：
Makefile
px4fmuv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f4 TARGET_HW=PX4_FMU_V2 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@
因此，目标px4fmuv2_bl生成的Makefile脚本为Makefile.f4，同时，它还定义了如下变量
- 硬件目标：$(TARGET_HW)=PX4_FMU_V2
- 链接文件：$(LINKER_FILE)=stm32f4.ld
- 目标名称：$(TARGET_FILE_NAME)=$@=px4fmuv2_bl
同时，在主Makefile中规定的全局变量BL_BASE、LIBOPENCM3、CC、OBJCOPY、FLAGS、COMMON_SRCS在Makefile.f4中同样有效。下面将对Makefile.f4进行详细注释。
Makefile.f4
OPENOCD ?= openocd #定义OPENOCD命令
JTAGCONFIG ?= interface/olimex-jtag-tiny.cfg #定义openocd对应的jtag烧写器配置文件
#JTAGCONFIG ?= interface/jtagkey-tiny.cfg
# 5 seconds / 5000 ms default delay
PX4_BOOTLOADER_DELAY ?= 5000 #定义启动变量PX4_BOOTLOADER_DELAY为5000ms
SRCS = $(COMMON_SRCS) main_f4.c #定义编译源文件为bl.c cdcacm.c usart.c和main_f4.c
FLAGS += -mthumb\ #使用thumb指令集
-mcpu=cortex-m4\ #使用cortex m4对应的CPU指令
-mfloat-abi=hard\ #浮点为硬件浮点运算
-mfpu=fpv4-sp-d16 \ #浮点运算协处理器为fpv4-sp-d16
-DTARGET_HW_$(TARGET_HW) \ #定义变量TARGET_HW_PX4_FMU_V2为1
-DSTM32F4 \ #定义变量STM32F4为1
-T$(LINKER_FILE) \ #使用链接文件stm32f4.ld
-L$(LIBOPENCM3)/lib \ #添加库文件搜索目录libopencm3/lib
-lopencm3_stm32f4 \ #链接库文件libopencm3_stm32f4.a
$(EXTRAFLAGS)
ELF = $(TARGET_FILE_NAME).elf #定义目标变量ELF=px4fmuv2_bl.elf
BINARY = $(TARGET_FILE_NAME).bin #定义目标二进制变量BINARY=px4fmuv2_bl.bin
all: $(ELF) $(BINARY) #定义目标all，为px4fmuv2_bl.elf和px4fmuv2_bl.bin
#px4fmuv2_bl.elf的生成规则：
#px4fmuv2_bl.elf: bl.c cdcacm.c usart.c main_f4.c Makefile
# arm-none-eabi-gcc -o px4fmuv2_bl.elf bl.c cdcacm.c usart.c main_f4.c $(FLAGS)
$(ELF): $(SRCS) $(MAKEFILE_LIST)
$(CC) -o $@ $(SRCS) $(FLAGS)
#px4fmuv2_bl.bin的生成规则：
#px4fmuv2_bl.bin: px4fmuv2_bl.elf
# arm-none-eabi-objcopy -O binary px4fmuv2_bl.elf px4fmuv2_bl.bin
$(BINARY): $(ELF)
$(OBJCOPY) -O binary $(ELF) $(BINARY)
#upload: all flash flash-bootloader
#定义upload目标，依赖于all flash-bootloader
upload: all flash-bootloader
#定义flash-bootloader目标的命令规则
#执行openocd命令，查找与本工程目录平行的px4_bootloader目录中interface/olimex-jtag-tiny.cfg文件作为jtag烧写器的配置文件，以stm32f4x.cfg作为主控stm32f427的SOC配置文件。然后在openocd环境下依次执行init, reset halt, flash write_image erase px4fmuv2_bl.bin 0x08000000, reset run, shutdown命令进行烧写。
flash-bootloader:
$(OPENOCD) --search ../px4_bootloader -f $(JTAGCONFIG) -f stm32f4x.cfg -c init -c "reset halt" -c "flash write_image erase $(BINARY) 0x08000000" -c "reset run" -c shutdown
# Use to upload to a stm32f4-discovery devboard, requires the latest version of openocd (from git)
# build openocd with "cd openocd; ./bootstrap; ./configure --enable-maintainer-mode --enable-stlink"
#定义upload-discovery目标的命令规则
#执行openocd命令，默认使用stlink烧写器及其配置文件，查找board/stm32f4discovery.cfg配置文件，在openocd环境下依次执行init, reset halt, flash probe 0, stm32f2x mass_erase 0, flash write_image erase px4fmuv2_bl.bin 0x08000000, reset, shutdown命令进行烧写。
upload-discovery:
$(OPENOCD) --search ../px4_bootloader -f board/stm32f4discovery.cfg -c init -c "reset halt" -c "flash probe 0" -c "stm32f2x mass_erase 0" -c "flash write_image erase $(BINARY) 0x08000000" -c "reset" -c shutdown
3.3 IO协处理器Makefile.f1文件注释
由主Makefile中目标生成语句可以看出，Pixhawk V2硬件系统的IO协处理器stm32f100对应的bootloader调用了如下语句：
Makefile
px4io_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
make -f Makefile.f1 TARGET_HW=PX4_PIO_V1 LINKER_FILE=stm32f1.ld TARGET_FILE_NAME=$@
因此，目标px4io_bl生成的Makefile脚本为Makefile.f1，同时，它还定义了如下变量
- 硬件目标：$(TARGET_HW)=PX4_PIO_V1
- 链接文件：$(LINKER_FILE)=stm32f1.ld
- 目标名称：$(TARGET_FILE_NAME)=$@=px4io_bl
同理，在主Makefile中规定的全局变量BL_BASE、LIBOPENCM3、CC、OBJCOPY、FLAGS、COMMON_SRCS在Makefile.f1中同样有效。下面将对Makefile.f1进行详细注释。
Makefile.f1
OPENOCD ?= ../../sat/bin/openocd #定义openocd命令变量
JTAGCONFIG ?= interface/olimex-jtag-tiny.cfg #定义Jtag烧写器配置文件
#JTAGCONFIG ?= interface/jtagkey-tiny.cfg
# 3 seconds / 3000 ms default delay
PX4_BOOTLOADER_DELAY ?= 3000 #定义bootloader延时3000ms
SRCS = $(COMMON_SRCS) main_f1.c #定义源文件为bl.c cdcacm.c usart.c和main_f1.c
FLAGS += -mthumb\ #使用thumb指令集
-mcpu=cortex-m3\ #使用cortex m3指令集
-DTARGET_HW_$(TARGET_HW) \ #定义TARGET_HW_PX4_PIO_V1变量为1
-DSTM32F1 \ #定义STM32F1变量为1
-T$(LINKER_FILE) \ #使用链接脚本stm32f1.ld
-L$(LIBOPENCM3)/lib \ #增加库文件搜索目录libopencm3/lib
-lopencm3_stm32f1 #链接库文件libopencm3_stm32f1.a
ELF = $(TARGET_FILE_NAME).elf #定义ELF目标变量px4io_bl.elf
BINARY = $(TARGET_FILE_NAME).bin #定义BINARY目标变量px4io_bl.bin
all: $(ELF) $(BINARY) #定义目标all为px4io_bl.elf和px4io_bl.bin
#px4io_bl.elf生成规则
#px4io_bl.elf: bl.c cdcacm.c usart.c main_f1.c Makefile
# arm-none-eabi-gcc -o px4io_bl.elf bl.c cdcacm.c usart.c main_f1.c $(FLAGS)
$(ELF): $(SRCS) $(MAKEFILE_LIST)
$(CC) -o $@ $(SRCS) $(FLAGS)
#px4io_bl.bin生成规则
#px4io_bl.bin: px4io_bl.elf
# arm-none-eabi-objcopy -O binary px4io_bl.elf px4io_bl.bin
$(BINARY): $(ELF)
$(OBJCOPY) -O binary $(ELF) $(BINARY)
#upload: all flash flash-bootloader
#定义upload目标，依赖于all flash-bootloader
upload: all flash-bootloader
#flash-bootloader目标生成命令
#执行openocd命令，查找与本工程目录平行的px4_bootloader目录中interface/olimex-jtag-tiny.cfg文件作为jtag烧写器的配置文件，以stm32f1.cfg作为IO协处理器stm32f100的SOC配置文件。然后在openocd环境下依次执行init, reset halt, flash write_image erase px4io_bl.bin, reset run, shutdown命令进行烧写。
flash-bootloader:
$(OPENOCD) --search ../px4_bootloader -f $(JTAGCONFIG) -f stm32f1.cfg -c init -c "reset halt" -c "flash write_image erase $(BINARY)" -c "reset run" -c shutdown
4 链接文件解析
PX4 Bootloader中包含4个链接文件stm32f1.ld、stm32f3.ld、stm32f4.ld和stm32f7.ld。与pixhawk V2硬件相关的为主控stm32f4.ld和IO协处理器stm32f1.ld两个链接脚本,它们将作为本文的分析重点。
PX4 Bootloader的链接文件可分为如下4个部分：
- 声明可使用存储结构变量
- 声明向量表名称
- 定义段区
- 定义栈顶地址变量值
4.1 主控链接脚本stm32f4.ld解析
链接脚本stm32f4.ld和libopencm3/lib/cm3/vector.c文件之间的关系十分密切。stm32f4.ld中定义了一系列在vector.c文件中使用的变量，包括_data_loadaddr，_data，_edata，_ebss，_stack，__preinit_array_start，__preinit_array_end，__init_array_start，__init_array_end，__fini_array_start，__fini_array_end，这些变量被用于Cortex M4的向量表初始化，主要是第一项的堆栈指针初始化和第二项的reset_handler函数的初始化。链接脚本stm32f4.ld中声明的向量表变量vector_table的定义在vector.c文件中。
与其它常见的链接脚本不同，stm32f4.ld中没有关键字ENTRY来规定程序的入口地址，在这种情况下程序就是从代码段（text）开始的。代码段最开始位置的是向量表，且ST公司的Cortex M4内核默认入口首地址（0x0）为堆栈指针（SP寄存器）的值；第二字为入口地址，因此reset_handler函数被调用为程序入口地址。
stm32f4.ld
/* Define memory regions. */
/* 声明存储区域，分为rom和ram两部分 */
MEMORY
{
rom (rx) : ORIGIN = 0x08000000, LENGTH = 16K /* 定义rom区，即片内flash的部分区域，权限可读可执行，起始于flash起始地址0x08000000，使用前16K（即Section 0） */
ram (rwx) : ORIGIN = 0x20000000, LENGTH = 128K /* 定义ram区，即片内SRAM的部分区域，权限可读可写可执行，起始于SRAM1起始地址0x20000000，包含SRAM1和SRAM2的全部区域（128K） */
}
/* Enforce emmission of the vector table. */
/* 声明外部定义的vector_table变量，此变量被定义在libopencm3/lib/cm3/vector.c中 */
EXTERN (vector_table)
/* Define sections. */
SECTIONS /* 定义段 */
{
. = ORIGIN(rom); /* 链接器指针定位于rom区起始地址 */
.text : { /* 定义代码段text */
*(.vectors) /* Vector table 中断向量表，定义于libopencm3/lib/cm3/vector.c文件中，仅包含vector_table变量 */
*(.text*) /* Program code 程序代码段 */
. = ALIGN(4); /* 4字节对齐 */
*(.rodata*) /* Read-only data 程序只读数据段 */
. = ALIGN(4); /* 4字节对齐 */
_etext = .; /* 定义变量_etext为当前地址 */
} >rom /* 代码段text的程序地址位于rom中 */
/* C++ Static constructors/destructors, also used for __attribute__
* ((constructor)) and the likes */
.preinit_array : { /* 定义C++构造函数段preinit_array */
. = ALIGN(4); /* 4字节对齐 */
__preinit_array_start = .; /* 定义变量__preinit_array_start为当前地址 */
KEEP (*(.preinit_array)) /* 强制链接器保留preinit_array段 */
__preinit_array_end = .; /* 定义变量__preinit_array_end为当前地址 */
} >rom /* C++构造函数段preinit_array的程序地址位于rom中 */
.init_array : { /* 定义C++构造函数段init_array */
. = ALIGN(4); /* 4字节对齐 */
__init_array_start = .; /* 定义变量__init_array_start为当前地址 */
KEEP (*(SORT(.init_array.*))) /* 强制链接器保留init_array.* 段，并对满足字符串模式的内容进行升序排列 */
KEEP (*(.init_array)) /* 强制链接器保留init_array段 */
__init_array_end = .; /* 定义变量__init_array_end为当前地址 */
} >rom /* C++构造函数段init_array的程序地址位于rom中 */
.fini_array : { /* 定义C++析构函数段fini_array */
. = ALIGN(4); /* 4字节对齐 */
__fini_array_start = .; /* 定义变量__fini_array_start为当前地址 */
KEEP (*(.fini_array)) /* 强制链接器保留fini_array段 */
KEEP (*(SORT(.fini_array.*))) /* 强制链接器保留fini_array.*段，并对满足字符串模式的内容进行排序 */
__fini_array_end = .; /* 定义变量__fini_array_end为当前地址 */
} >rom /* C++析构函数段fini_array的程序地址位于rom中 */
. = ORIGIN(ram); /* 链接器指针定位于ram区起始地址 */
.data : AT(_etext) { /* 定义数据段data，加载地址位于变量_etext定义的位置 */
_data = .; /* 定义变量_data为当前地址 */
*(.data*) /* Read-write initialized data，程序数据段 */
. = ALIGN(4); /* 4字节对齐 */
_edata = .; /* 定义变量_edata为当前地址 */
} >ram /* 数据段data的程序地址位于ram中 */
_data_loadaddr = LOADADDR(.data); /* 定义变量_data_loadaddr为数据段加载地址的起始位置 */
.bss : { /* 定义bss段 */
*(.bss*) /* Read-write zero initialized data，程序bss段 */
*(COMMON) /* COMMON段 */
. = ALIGN(4); /* 4字节对齐 */
_ebss = .; /* 定义变量_ebss为当前地址 */
} >ram AT >rom /* bss段的程序地址位于ram中，加载地址位于rom中 */
/*
* The .eh_frame section appears to be used for C++ exception handling.
* You may need to fix this if you're using C++.
*/
/DISCARD/ : { *(.eh_frame) } /* 被丢弃段eh_frame不会出现在输出文件中 */
. = ALIGN(4); /* 4字节对齐 */
end = .; /* 定义变量end为当前地址 */
}
PROVIDE(_stack = 0x20020000); /* 定义变量_stack，仅在被使用时生效，堆栈指针指向ram区最高地址 */
4.2 IO协处理器链接脚本stm32f1.ld解析
链接脚本stm32f1.ld与stm32f4.ld情况十分相近，不再复述，这里仅对其进行注释。
stm32f1.ld
/* Define memory regions. */
/* 声明存储区域，分为rom和ram两部分 */
MEMORY
{
rom (rx) : ORIGIN = 0x08000000, LENGTH = 4K /* 定义rom区，即片内flash的部分区域，权限可读可执行，起始于flash起始地址0x08000000，使用前4K（即Page 0~3） */
ram (rwx) : ORIGIN = 0x20000000, LENGTH = 8K /* 定义ram区，即片内SRAM的部分区域，权限可读可写可执行，起始于SRAM1起始地址0x20000000，使用全部8K（注意F100系列片内RAM最高为8K） */
}
/* Enforce emmission of the vector table. */
/* 声明外部定义的vector_table变量，此变量被定义在libopencm3/lib/cm3/vector.c中 */
EXTERN (vector_table)
/* Define sections. */
SECTIONS /* 定义段 */
{
. = ORIGIN(rom); /* 链接器指针定位于rom区起始地址 */
.text : { /* 定义代码段text */
*(.vectors) /* Vector table 中断向量表，定义于libopencm3/lib/cm3/vector.c文件中，仅包含vector_table变量 */
*(.text*) /* Program code 程序代码段 */
. = ALIGN(4); /* 4字节对齐 */
*(.rodata*) /* Read-only data 程序只读数据段 */
. = ALIGN(4); /* 4字节对齐 */
_etext = .; /* 定义变量_etext为当前地址 */
} >rom /* 代码段text的程序地址位于rom中 */
/* C++ Static constructors/destructors, also used for __attribute__
* ((constructor)) and the likes */
.preinit_array : { /* 定义C++构造函数段preinit_array */
. = ALIGN(4); /* 4字节对齐 */
__preinit_array_start = .; /* 定义变量__preinit_array_start为当前地址 */
KEEP (*(.preinit_array)) /* 强制链接器保留preinit_array段 */
__preinit_array_end = .; /* 定义变量__preinit_array_end为当前地址 */
} >rom /* C++构造函数段preinit_array的程序地址位于rom中 */
.init_array : { /* 定义C++构造函数段init_array */
. = ALIGN(4); /* 4字节对齐 */
__init_array_start = .; /* 定义变量__init_array_start为当前地址 */
KEEP (*(SORT(.init_array.*))) /* 强制链接器保留init_array.* 段，并对满足字符串模式的内容进行升序排列 */
KEEP (*(.init_array)) /* 强制链接器保留init_array段 */
__init_array_end = .; /* 定义变量__init_array_end为当前地址 */
} >rom /* C++构造函数段init_array的程序地址位于rom中 */
.fini_array : { /* 定义C++析构函数段fini_array */
. = ALIGN(4); /* 4字节对齐 */
__fini_array_start = .; /* 定义变量__fini_array_start为当前地址 */
KEEP (*(.fini_array)) /* 强制链接器保留fini_array段 */
KEEP (*(SORT(.fini_array.*))) /* 强制链接器保留fini_array.* 段，并对满足字符串模式的内容进行升序排列 */
__fini_array_end = .; /* 定义变量__fini_array_end为当前地址 */
} >rom /* C++析构函数段fini_array的程序地址位于rom中 */
. = ORIGIN(ram); /* 链接器指针定位于ram区起始地址 */
.data : AT(_etext) { /* 定义数据段data，加载地址位于变量_etext定义的位置 */
_data = .; /* 定义变量_data为当前地址 */
*(.data*) /* Read-write initialized data 程序数据段 */
. = ALIGN(4); /* 4字节对齐 */
_edata = .; /* 定义变量_edata为当前地址 */
} >ram /* 数据段data的程序地址位于ram中 */
_data_loadaddr = LOADADDR(.data); /* 定义变量_data_loadaddr为数据段加载地址的起始位置 */
.bss : { /* 定义bss段 */
*(.bss*) /* Read-write zero initialized data 程序bss段 */
*(COMMON) /* COMMON段 */
. = ALIGN(4); /* 4字节对齐 */
_ebss = .; /* 定义变量_ebss为当前地址 */
} >ram AT >rom /* bss段的程序地址位于ram中，加载地址位于rom中 */
/*
* The .eh_frame section appears to be used for C++ exception handling.
* You may need to fix this if you're using C++.
*/
/DISCARD/ : { *(.eh_frame) } /* 被丢弃段eh_frame不会出现在输出文件中 */
. = ALIGN(4); /* 4字节对齐 */
end = .; /* 定义变量end为当前地址 */
}
PROVIDE(_stack = 0x20002000); /* 定义变量_stack，仅在被使用时生效，堆栈指针指向ram区最高地址 */
5 硬件配置头文件
PX4 Bootloader的硬件配置头文件仅有一个，hw_config.h。这套代码支持的所有硬件板配置均可在这里找到。它的结构很简单，针对不同的硬件配置使用#if-#elif-#end宏条件编译语句进行配置。针对Pixhawk V2这套硬件，仅涉及其中TARGET_HW_PX4_FMU_V2和TARGET_HW_PX4_PIO_V1两个条件编译块中的内容。由于本节将涉及具体的硬件信息，将结合芯片手册和原理图对这两部分内容进行详细解析。
5.1 主控宏TARGET_HW_PX4_FMU_V2对应的配置
在Makefile.f4的FLAGS变量中定义了TARGET_HW_PX4_FMU_V2和STM32F4两个变量，这两个变量主要用于宏条件编译分支的判断上，对硬件板载配置的时候起到了决定性的作用。
Makefile.f4
FLAGS += -mthumb\ #使用thumb指令集
-mcpu=cortex-m4\ #使用cortex m4对应的CPU指令
-mfloat-abi=hard\ #浮点为硬件浮点运算
-mfpu=fpv4-sp-d16 \ #浮点运算协处理器为fpv4-sp-d16
-DTARGET_HW_$(TARGET_HW) \ #定义变量TARGET_HW_PX4_FMU_V2为1
-DSTM32F4 \ #定义变量STM32F4为1
-T$(LINKER_FILE) \ #使用链接文件stm32f4.ld
-L$(LIBOPENCM3)/lib \ #添加库文件搜索目录libopencm3/lib
-lopencm3_stm32f4 \ #链接库文件libopencm3_stm32f4.a
$(EXTRAFLAGS)
hw_config.h文件中对应主控宏TARGET_HW_PX4_FMU_V2的代码如下：
hw_config.h
#elif defined(TARGET_HW_PX4_FMU_V2) /* 若TARGET_HW_PX4_FMU_V2为真，下面的宏定义有效 */
# define APP_LOAD_ADDRESS 0x08004000 /* APP_LOAD_ADDRESS，为Bootloader初始化完成后的飞控固件跳转地址（实际入口地址在0x08004004，这一点在bl.c文件的源代码中可以看到,0x08004000被用于标识后面的代码是否有效） */
# define BOOTLOADER_DELAY 5000 /* BOOTLOADER_DELAY，为Bootloader初始化完毕到跳转到飞控固件需等待的时间 */
# define BOARD_FMUV2 /* BOARD_FMUV2，在全部代码中没有用到 */
# define INTERFACE_USB 1 /* INTERFACE_USB，表示Bootloader可采用USB口与上位机通信 */
# define INTERFACE_USART 1 /* INTERFACE_USART，表示Bootloader可采用串口与上位机通信 */
# define USBDEVICESTRING "PX4 BL FMU v2.x" /* USBDEVICESTRING，表示对应USB ID的字符串 */
# define USBPRODUCTID 0x0011 /* USBPRODUCTID，USB接口的PID */
# define BOOT_DELAY_ADDRESS 0x000001a0 /* BOOT_DELAY_ADDRESS，flash上对应存放Bootloader等待时间的内存地址 */
# define BOARD_TYPE 9 /* BOARD_TYPE，对应不同硬件配置板子上处理器的编号，每个不同的处理器对应不同的值 */
# define _FLASH_KBYTES (*(uint16_t *)0x1fff7a22) /* _FLASH_KBYTES，程序运行期间flash以KB计的大小的存储地址（为何位于Reserved地址？） */
# define BOARD_FLASH_SECTORS ((_FLASH_KBYTES == 0x400) ? 11 : 23) /* BOARD_FLASH_SECTORS，STM32F4芯片若片内flash为1M，则Sector数量为11；若不为1M（2M），则Sector数量为23，详见芯片手册 */
# define BOARD_FLASH_SIZE (_FLASH_KBYTES * 1024) /* BOARD_FLASH_SIZE，flash总大小 */
# define OSC_FREQ 24 /* OSC_FREQ，外部晶振频率24kHz */
/* 主控FMU指示灯在板上一共有2个，FMU的PWR和B/E；PWR（LED704）为绿色常亮，上电即亮，B/E（LED701）由FMU的GPIOE12控制，为闪烁红色 */
# define BOARD_PIN_LED_ACTIVITY 0 // no activity LED，无命令处理显示LED灯
# define BOARD_PIN_LED_BOOTLOADER GPIO12 /* BOARD_PIN_LED_BOOTLOADER，主控Bootloader的LED指示灯为GPIOE12 */
# define BOARD_PORT_LEDS GPIOE /* BOARD_PORT_LEDS，主控FMU的LED指示灯控制引脚在GPIO Port E */
# define BOARD_CLOCK_LEDS RCC_AHB1ENR_IOPEEN /* BOARD_CLOCK_LEDS，RCC_AHB1ENR_IOPEEN被libopencm3/include/libopencm3/stm32/f4/rcc.h定义为(1<<4)，对应RCC_AHB1ENR寄存器的第4位，GPIOE的时钟使能位 */
# define BOARD_LED_ON gpio_clear /* BOARD_LED_ON，gpio_clear函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin清零功能 */
# define BOARD_LED_OFF gpio_set /* BOARD_LED_OFF，gpio_set函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin置1功能 */
# define BOARD_USART USART2 /* BOARD_USART，通信串口，USART2被libopencm3/include/libopencm3/stm32/common/usart_common_all.h定义为USART2_BASE（0x40004400） */
# define BOARD_USART_CLOCK_REGISTER RCC_APB1ENR /* BOARD_USART_CLOCK_REGISTER，被定义为RCC_APB1ENR寄存器，用于使能USART2的时钟 */
# define BOARD_USART_CLOCK_BIT RCC_APB1ENR_USART2EN /* BOARD_USART_CLOCK_BIT，RCC_APB1ENR_USART2EN被libopencm3/include/libopencm3/stm32/f4/rcc.h定义为(1<<17)，对应RCC_APB1ENR的17位，用于使能USART2的时钟 */
# define BOARD_PORT_USART GPIOD /* BOARD_PORT_USART，USART2的引脚位于GPIO Port D */
# define BOARD_PORT_USART_AF GPIO_AF7 /* BOARD_PORT_USART_AF，GPIO_AF7被libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h定义为0x7，对应AF7的alternative function功能为USART1～3 */
# define BOARD_PIN_TX GPIO5 /* BOARD_PIN_TX，USART2的发送引脚为GPIOD5 */
# define BOARD_PIN_RX GPIO6 /* BOARD_PIN_RX，USART2的接收引脚为GPIOD6 */
# define BOARD_USART_PIN_CLOCK_REGISTER RCC_AHB1ENR /* BOARD_USART_PIN_CLOCK_REGISTER，被定义为RCC_AHB1ENR寄存器，用于使能USART2引脚的时钟 */
# define BOARD_USART_PIN_CLOCK_BIT RCC_AHB1ENR_IOPDEN /* BOARD_USART_PIN_CLOCK_BIT，RCC_AHB1ENR_IOPDEN被libopencm3/include/libopencm3/stm32/f4/rcc.h定义为(1<<3)，对应RCC_AHB1ENR寄存器的第3位，用于使能GPIOD的时钟 */
5.2 IO协处理器宏TARGET_HW_PX4_PIO_V1对应的配置
在Makefile.f1的FLAGS变量中定义了TARGET_HW_PX4_PIO_V1和STM32F1两个变量，这两个变量主要用于宏条件编译分支的判断上，对硬件板载配置的时候起到了决定性的作用。
Makefile.f1
FLAGS += -mthumb\ #使用thumb指令集
-mcpu=cortex-m3\ #使用cortex m3指令集
-DTARGET_HW_$(TARGET_HW) \ #定义TARGET_HW_PX4_PIO_V1变量为1
-DSTM32F1 \ #定义STM32F1变量为1
-T$(LINKER_FILE) \ #使用链接脚本stm32f1.ld
-L$(LIBOPENCM3)/lib \ #增加库文件搜索目录libopencm3/lib
-lopencm3_stm32f1 #链接库文件libopencm3_stm32f1.a
hw_config.h文件中对应主控宏TARGET_HW_PX4_PIO_V1的代码如下：
hw_config.h
#elif defined(TARGET_HW_PX4_PIO_V1) || defined(TARGET_HW_PX4_PIO_V2) /* 若TARGET_HW_PX4_FMU_V2为真，下面的宏定义有效 */
# define APP_LOAD_ADDRESS 0x08001000 /* APP_LOAD_ADDRESS，为bootloader初始化完成后的飞控固件跳转地址（实际入口地址在0x08001004，这一点在bl.c文件的源代码中可以看到,0x08001000被用于标识后面的代码是否有效） */
# define APP_SIZE_MAX 0xf000 /* APP_SIZE_MAX，板载系统程序（Bootloader）大小上限 */
# define BOOTLOADER_DELAY 200 /* BOOTLOADER_DELAY，为Bootloader初始化完毕到跳转到飞控固件需等待的时间 */
# define BOARD_PIO /* 未见引用 */
# define INTERFACE_USB 0 /* INTERFACE_USB，表示Bootloader不能用USB与上位机通信 */
# define INTERFACE_USART 1 /* INTERFACE_USART，表示Bootloader可以用串口与上位机通信 */
# define USBDEVICESTRING "" /* USBDEVICESTRING，因INTERFACE_USB为0，不使用USB与上位机通信，故USB ID的字符串设置为空 */
# define USBPRODUCTID -1 /* USBPRODUCTID，因INTERFACE_USB为0，不使用USB与上位机通信，故USB设备ID设为非法值 */
# define OSC_FREQ 24 /* OSC_FREQ，外部晶振频率24kHz */
/* IO协处理器指示灯在板上一共有3个，IO的PWR、B/E和ACT；PWR（LED702）为绿色常亮，上电即亮，B/E（LED703）由IO协处理器的GPIOB15控制，为闪烁红色，ACT（LED705）由IO协处理器的GPIOB14控制，为闪烁蓝色 */
# define BOARD_PIN_LED_ACTIVITY GPIO14 /* BOARD_PIN_LED_ACTIVITY，Bootloader有命令要处理时亮起，由IO协处理器的GPIOB14控制 */
# define BOARD_PIN_LED_BOOTLOADER GPIO15 /* BOARD_PIN_LED_BOOTLOADER，IO协处理器Bootloader的LED指示灯为GPIOB15 */
# define BOARD_PORT_LEDS GPIOB /* BOARD_PORT_LEDS，IO协处理器的LED指示灯控制引脚在GPIO Port B */
# define BOARD_CLOCK_LEDS_REGISTER RCC_APB2ENR /* BOARD_CLOCK_LEDS_REGISTER，被定义为RCC_APB2ENR寄存器，用于使能LED时钟 */
# define BOARD_CLOCK_LEDS RCC_APB2ENR_IOPBEN /* BOARD_CLOCK_LEDS，RCC_APB2ENR_IOPBEN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为(1<<3)，对应RCC_APB2ENR寄存器的第3，GPIOB的时钟使能位 */
# define BOARD_LED_ON gpio_clear /* BOARD_LED_ON，gpio_clear函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin清零功能 */
# define BOARD_LED_OFF gpio_set /* BOARD_LED_OFF，gpio_set函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin置1功能 */
/* IO协处理器的通信串口为USART2，与主控FMU的USART6通信 */
# define BOARD_USART USART2 /* BOARD_USART，通信串口，USART2被libopencm3/include/libopencm3/stm32/common/usart_common_all.h定义为USART2_BASE（0x40004400） */
# define BOARD_USART_CLOCK_REGISTER RCC_APB1ENR /* BOARD_USART_CLOCK_REGISTER，被定义为RCC_APB1ENR寄存器，用于使能USART2的时钟 */
# define BOARD_USART_CLOCK_BIT RCC_APB1ENR_USART2EN /* BOARD_USART_CLOCK_BIT，RCC_APB1ENR_USART2EN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为(1<<17)，对应RCC_APB1ENR的17位，用于使能USART2的时钟 */
# define BOARD_PORT_USART GPIOA /* BOARD_PORT_USART，USART2的引脚位于GPIO Port A */
# define BOARD_PIN_TX GPIO_USART2_TX /* BOARD_PIN_TX，GPIO_USART2_TX被libopencm3/include/libopencm3/stm32/f1/gpio.h中定义为GPIO2，PA2 */
# define BOARD_PIN_RX GPIO_USART2_RX /* BOARD_PIN_RX，GPIO_USART2_RX被libopencm3/include/libopencm3/stm32/f1/gpio.h中定义为GPIO3，PA3 */
# define BOARD_USART_PIN_CLOCK_REGISTER RCC_APB2ENR /* BOARD_USART_PIN_CLOCK_REGISTER，被定义为寄存器RCC_APB2ENR，用于使能USART2引脚的时钟 */
# define BOARD_USART_PIN_CLOCK_BIT RCC_APB2ENR_IOPAEN /* BOARD_USART_PIN_CLOCK_BIT，RCC_APB2ENR_IOPAEN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为(1<<2)，对应RCC_APB2ENR的第2位，用于使能GPIOA的时钟 */
/* IO协处理器的GPIOB5接J702安全开关 */
# define BOARD_FORCE_BL_PIN GPIO5 /* BOARD_FORCE_BL_PIN，板载强制Bootloader引脚为GPIOB5 */
# define BOARD_FORCE_BL_PORT GPIOB /* BOARD_FORCE_BL_PIN，板载强制Bootloader引脚在GPIOB中 */
# define BOARD_FORCE_BL_CLOCK_REGISTER RCC_APB2ENR /* BOARD_FORCE_BL_CLOCK_REGISTER，被定义为RCC_APB2ENR，用于使能GPIOB5的时钟 */
# define BOARD_FORCE_BL_CLOCK_BIT RCC_APB2ENR_IOPBEN /* BOARD_FORCE_BL_CLOCK_BIT，RCC_APB2ENR_IOPBEN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为（1<<3），对应RCC_APB2ENR寄存器的第3，GPIOB的时钟使能位 */
# define BOARD_FORCE_BL_PULL GPIO_CNF_INPUT_FLOAT // depend on external pull BOARD_FORCE_BL_PULL，GPIO_CNF_INPUT_FLOAT被libopencm3/include/libopencm3/stm32/f1/gpio.h定义为0x01，根据芯片手册表示GPIOB5为浮动输入状态，其值取决于外部硬件输入，即安全开关的状态
# define BOARD_FORCE_BL_VALUE BOARD_FORCE_BL_PIN /* BOARD_FORCE_BL_VALUE，BOARD_FORCE_BL_PIN为GPIO5的值，用于判定IO协处理器是否永远进入Bootloader的循环状态 */
# define BOARD_FLASH_SECTORS 60 /* BOARD_FLASH_SECTORS，STM32F1片内flash页数，Bootloader认为片内flash的前60页有效 */
# define BOARD_TYPE 10 /* BOARD_TYPE，对应不同硬件配置板子上处理器的编号，每个不同的处理器对应不同的值 */
# define FLASH_SECTOR_SIZE 0x400 /* FLASH_SECTOR_SIZE，STM32F1片内flash每页大小为1KB */
6 核心数据结构
与u-boot类似，PX4 Bootloader运行时需要一些核心数据结构的支持。这些数据结构一般是全局变量，它们的值能够充分反映整个程序运行的状态。Pixhawk V2板上有两个处理器分别跑着各自的Bootloader，因此各自维持这自己的核心数据结构。无论主控FMU还是IO协处理器的Bootloader程序都是从向量表开始的，而且PX4 Bootloader对所有处理器的向量表处理方式完全相同，因此本节将向量表数据结构单独拿出来分析。
6.1 向量表vector_table_t
STM32的Cortex M核心启动时均需要中断向量表支持，因此这个数据结构对程序的启动至关重要。这个数据结构在库文件libopencm3/include/libopencm3/cm3/vector.h中定义，宏NVIC_IRQ_COUNT在libopencm3/include/libopencm3/dispatch/nvic.h中被定义为0，故一般中断向量irq数量为0，可理解为不启用一般中断。
vector.h
typedef void (*vector_table_entry_t)(void); /* 定义向量表函数指针类型 */
typedef struct {
unsigned int *initial_sp_value; /* 初始堆栈指针地址 */
vector_table_entry_t reset; /* 重启reset向量函数指针 */
vector_table_entry_t nmi; /* 不可屏蔽中断NMI向量函数指针 */
vector_table_entry_t hard_fault; /* 硬件错误hard_fault向量函数指针 */
vector_table_entry_t memory_manage_fault; /* 内存管理错误memory_manage_fault向量函数指针，Cortex M0核心不含此项 */
vector_table_entry_t bus_fault; /* 总线错误bus_fault向量函数指针，Cortex M0核心不含此项 */
vector_table_entry_t usage_fault; /* 指令使用错误usage_fault向量函数指针，Cortex M0核心不含此项 */
vector_table_entry_t reserved_x001c[4]; /* 预留 */
vector_table_entry_t sv_call; /* 管理模式sv_call向量函数指针 */
vector_table_entry_t debug_monitor; /* 调试监控debug_monitor向量函数指针，Cortex M0核心不含此项（手册显示M4和M3也没有） */
vector_table_entry_t reserved_x0034; /* 预留 */
vector_table_entry_t pend_sv; /* pend_sv向量函数指针 */
vector_table_entry_t systick; /* 系统时钟systick向量函数指针 */
vector_table_entry_t irq[NVIC_IRQ_COUNT]; /* 一般中断irq向量函数指针数组，宏NVIC_IRQ_COUNT被定义为0 */
} vector_table_t;
vector_table_t数据结构在文件libopencm3/lib/cm3/vector.c中实体化为变量vector_table并被初始化，单独构成vectors段，被链接脚本规定放在代码段最开始位置。初始化的重点时栈指针initial_sp_value和重启reset向量函数reset_handler，其余或者被初始化为什么都不做的null_handler，或者被初始化为死循环函数blocking_handler。null_handler和blocking_handler的定义均在vector.c文件中。宏IRQ_HANDLERS在文件libopencm3/lib/dispatch/vector_nvic.c中被定义为空，说明Bootloader不含中断处理函数。
vector.c中，向量函数的初始化函数均被定义为弱属性（weak），表示若外部没有同名函数定义，则用此弱属性函数；若有其他定义，则采用其他定义的函数。从这一点也可看到，对Bootloader的向量函数进行重写时十分方便，不需要修改软件框架。由于reset_handeler作为入口函数，因此还增加了裸属性（naked）。
vector.c
__attribute__ ((section(".vectors"))) /* 变量vector_table属于vectors段 *
vector_table_t vector_table = {
.initial_sp_value = &_stack, /* 栈指针指向的地址，_stack在链接脚本中被定义为ram区最高地址 */
.reset = reset_handler, /* 重启reset向量函数，reset_handler被定义在vector.c中 */
.nmi = nmi_handler, /* 不可屏蔽中断nmi向量函数，nmi_handeler在vector.c中被定义为什么都不做的函数null_handler */
.hard_fault = hard_fault_handler, /* 硬件错误hard_fault向量函数，hard_fault_handler在vector.c中被定义为死循环函数blocking_handler */
/* Those are defined only on CM3 or CM4 */
#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) /* 若为CM3和CM4 */
.memory_manage_fault = mem_manage_handler, /* 内存管理错误memory_manage_fault向量函数，mem_manage_handler在vector.c中被定义为死循环函数blocking_handler */
.bus_fault = bus_fault_handler, /* 总线错误bus_fault向量函数，bus_fault_handler在vector.c中被定义为死循环函数blocking_handler */
.usage_fault = usage_fault_handler, /* 指令使用错误usage_fault向量函数，usage_fault_handler在vector.c中被定义为死循环函数blocking_handler */
.debug_monitor = debug_monitor_handler, /* 调试监控debug_monitor向量函数，debug_monitor_handler在vector.c中被定义为什么都不做的函数null_handler */
#endif
.sv_call = sv_call_handler, /* 调试监控debug_monitor向量函数，sv_call_handler在vector.c中被定义为什么都不做的函数null_handler */
.pend_sv = pend_sv_handler, /* pend_sv向量函数，pend_sv_handler在vector.c中被定义为什么都不做的函数null_handler */
.systick = sys_tick_handler, /* 系统时钟systick向量函数，sys_tick_handler在vector.c中被定义为什么都不做的函数null_handler */
/* 由于sys_tick_handler被vector.c定义为弱属性（weak），该函数在bl.c中被重新定义，实际定义在bl.c中。 */
.irq = {
IRQ_HANDLERS /* IRQ_HANDLERS，在vector_nvic.c中被定义为空 */
}
};
6.2 主控FMU核心数据结构
除向量表vector外，主控FMU的核心数据结构包括boardinfo，flash_sector，mcu_des_t和mcu_rev_t，它们均为全局变量，表示板载FMU的基本配置情况。
6.2.1 结构体boardinfo
结构体boardinfo被定义在bl.h文件中，在main_f4.c中被初始化，用于描述运行此Bootloader的板载系统的最基本配置。
bl.h
struct boardinfo {
uint32_t board_type; /* 板载处理器编号 */
uint32_t board_rev; /* 修订版本，程序中几乎没有用到 */
uint32_t fw_size; /* 飞控固件大小的最大值 */
uint32_t systick_mhz; /* 系统时钟的输入值，即CPU主频 */
} __attribute__((packed)); /* 编译时使用紧凑数据模式，不进行优化对齐，即使用1字节对齐模式 */
main_f4.c
struct boardinfo board_info = {
.board_type = BOARD_TYPE, /* board_type，BOARD_TYPE板载处理器编号在hw_config.h中定义，主控为9。 */
.board_rev = 0, /* board_rev，修订版本为0 */
.fw_size = 0, /* fw_size，飞控固件大小的最大值，这里的0没有意义，在board_init函数中被重新初始化 */
.systick_mhz = 168, /* systick_mhz，系统时钟输入，即CPU主频168MHz */
};
6.2.2 结构体flash_sector
结构体flash_sector用于描述STM32F4芯片内部flash的结构，它被定义并初始化在main_f4.c中。根据芯片手册，STM32F4片内flash大小为1M或2M两种，具体参见芯片手册。
main_f4.c
static struct {
uint32_t sector_number;
uint32_t size;
} flash_sectors[] = {
{0x01, 16 * 1024},
{0x02, 16 * 1024},
{0x03, 16 * 1024},
{0x04, 64 * 1024},
{0x05, 128 * 1024},
{0x06, 128 * 1024},
{0x07, 128 * 1024},
{0x08, 128 * 1024},
{0x09, 128 * 1024},
{0x0a, 128 * 1024},
{0x0b, 128 * 1024},
/* flash sectors only in 2MiB devices */
{0x10, 16 * 1024},
{0x11, 16 * 1024},
{0x12, 16 * 1024},
{0x13, 16 * 1024},
{0x14, 64 * 1024},
{0x15, 128 * 1024},
{0x16, 128 * 1024},
{0x17, 128 * 1024},
{0x18, 128 * 1024},
{0x19, 128 * 1024},
{0x1a, 128 * 1024},
{0x1b, 128 * 1024},
};
6.2.3 结构体mcu_des_t
结构体mcu_des_t存储了STM32F4类MCU的所有型号信息，它被定义在main_f4.c文件中，并被实体化为变量数组mcu_descriptions，此结构用于程序中自动识别当前MCU类型。MCU类型信息被存储在DBGMCU_IDCODE寄存器中，地址为0xE0042000。此结构体在check_silicon函数中使用。
main_f4.c
// address of MCU IDCODE
#define DBGMCU_IDCODE 0xE0042000
#define STM32_UNKNOWN 0
#define STM32F40x_41x 0x413
#define STM32F42x_43x 0x419
#define STM32F42x_446xx 0x421
typedef struct mcu_des_t {
uint16_t mcuid;
const char *desc;
char rev;
} mcu_des_t;
mcu_des_t mcu_descriptions[] = {
{ STM32_UNKNOWN, "STM32F???", '?'},
{ STM32F40x_41x, "STM32F40x", '?'},
{ STM32F42x_43x, "STM32F42x", '?'},
{ STM32F42x_446xx, "STM32F446XX", '?'},
};
6.2.4 结构体mcu_rev_t
结构体mcu_rev_t存储了MCU的版本信息，它被定义在main_f4.c文件中，并被实体化为变量数组silicon_revs，此结构除了可以识别处理器版本外，还可以据此判断MCU的内部flash信息。
main_f4.c
typedef enum mcu_rev_e { /* 版本号枚举定义，感觉不全啊， */
MCU_REV_STM32F4_REV_A = 0x1000, /* REV A for STM32F405/407/415/417/42X/43X */
MCU_REV_STM32F4_REV_Z = 0x1001, /* REV Z for STM32F405/407/415/417 */
MCU_REV_STM32F4_REV_Y = 0x1003, /* REV Y for STM32F42X/43X */
MCU_REV_STM32F4_REV_1 = 0x1007, /* REV 1 for STM32F42X/43X */
MCU_REV_STM32F4_REV_3 = 0x2001 /* REV 3 for STM32F42X/43X */
} mcu_rev_e;
typedef struct mcu_rev_t {
mcu_rev_e revid;
char rev;
} mcu_rev_t;
const mcu_rev_t silicon_revs[] = {
{MCU_REV_STM32F4_REV_3, '3'}, /* Revision 3 */
{MCU_REV_STM32F4_REV_A, 'A'}, /* Revision A */ // FIRST_BAD_SILICON_OFFSET (place good ones above this line and update the FIRST_BAD_SILICON_OFFSET accordingly)
{MCU_REV_STM32F4_REV_Z, 'Z'}, /* Revision Z */
{MCU_REV_STM32F4_REV_Y, 'Y'}, /* Revision Y */
{MCU_REV_STM32F4_REV_1, '1'}, /* Revision 1 */
};
6.3 IO协处理器核心数据结构
除向量表vector外，IO协处理器的核心数据结构仅有结构体boardinfo，它表征了IO协处理器的运行状态。它同样定义在bl.h中，在main_f1.c中被初始化。
main_f1.c
struct boardinfo board_info = {
.board_type = BOARD_TYPE, /* board_type，BOARD_TYPE板载处理器编号在hw_config.h中定义，IO协处理器为10。 */
.board_rev = 0, /* board_rev，修订版本为0 */
.fw_size = APP_SIZE_MAX, /* fw_size，APP_SIZE_MAX飞控固件大小的最大值，在hw_config.h中被定义为0xf000，60KB */
.systick_mhz = OSC_FREQ, /* systick_mhz，系统时钟输入等于OSC_FREQ，在hw_config.h中被定义为24MHz */
};
7 PX4 Bootloader主线程序
铺垫了这么多，重点终于来了。与u-boot类似，无论是在主控FMU还是IO协处理器上，PX4 Bootloader本身只是一个规模较大的单片机程序，它的主要功能有：
- 初始化板载芯片并跳转到飞控固件入口
- 提供板载调试功能，便于系统调试
由于Pixhawk V2硬件的主控FMU和IO协处理器分别运行着自己的那套Bootloader代码，因此它将有2个Bootloader主线。这两个主线程序的引导（main函数之前）由libopencm3库提供支持，premain阶段的代码是相同的。
7.1 初始化阶段（reset_handler函数）程序
Pixhawk V2的主控FMU芯片型号为STM32F427，内核为Cortex M4；IO协处理器芯片的型号为STM32F100，内核为Cortex M3，因此它们启动后MCU的入口地址为向量表的第二项。向量表的内容参见本文“核心数据结构”一节中关于向量表的内容（文件libopencm3/lib/cm3/vector.c），本节的重点是reset_handler函数的详细解析。
reset_handler函数的主要功能如下：
- 用数据段存储的参数初始化内存空间
- 清零BSS段
- 设置异常处理堆栈指针对齐模式
- 调用与架构相关的pre_main函数
- 运行所有构造函数
- 调用main函数
- 调用所有析构函数
libopencm3/lib/cm3/vector.c
/* 变量声明 */
extern unsigned _data_loadaddr, _data, _edata, _ebss, _stack; /* 段初始化变量，定义在链接脚本中 */
typedef void (*funcp_t) (void); /* 定义函数指针类型funcp_t，其原型为void (*functionname) (void) */
extern funcp_t __preinit_array_start, __preinit_array_end; /* C++构造函数地址变量 */
extern funcp_t __init_array_start, __init_array_end; /* C++构造函数地址变量 */
extern funcp_t __fini_array_start, __fini_array_end; /* C++析构函数地址变量 */
/* 定义为弱属性，可直接在其他地方重写此函数；定义为裸属性，确保编译器对reset_handler函数不添加任何加载和卸载代码 */
void __attribute__ ((weak, naked)) reset_handler(void)
{
volatile unsigned *src, *dest;
funcp_t *fp;
/* 用数据段存储的参数初始化内存空间，变量定义见链接脚本。 */
/* _data_loadaddr：数据段的起始加载地址，即在flash上的首地址 */
/* _data：数据段的起始运行地址，即在RAM中的首地址 */
/* _edata：数据段的截止运行地址，即在RAM中的末地址 */
for (src = &_data_loadaddr, dest = &_data; dest < &_edata; src++, dest++) {
*dest = *src;
}
/* BSS段清零，变量定义见各自的链接脚本 */
/* _ebss：bss段的截止运行地址，其起始运行地址紧接数据段的末地址 */
while (dest < &_ebss) {
*dest++ = 0;
}
/* 确保进入异常模式时堆栈指针8字节对齐。此设置对M3和R1架构不起作用 */
SCB_CCR |= SCB_CCR_STKALIGN;
/* 调用与架构相关的pre_main函数（主控FMU在文件libopencm3/lib/stm32/f4/vector_chipset.c中；IO协处理器在文件libopencm3/lib/cm3/vector.c中，且为空函数）。 */
pre_main();
/* 依次调用所有C++定义的构造函数，变量定义见链接脚本。 */
/* __preinit_array_start：preinit_array段首地址 */
/* __preinit_array_end：preinit_array段末地址 */
/* __init_array_start：init_array段首地址 */
/* __init_array_end：init_array段末地址 */
for (fp = &__preinit_array_start; fp < &__preinit_array_end; fp++) {
(*fp)();
}
for (fp = &__init_array_start; fp < &__init_array_end; fp++) {
(*fp)();
}
/* 调用main函数（主控FMU在文件main_f4.c中，IO协处理器在文件main_f1.c中）。 */
main();
/* 依次调用所有C++定义的析构函数，变量定义见链接脚本 */
/* __fini_array_start：fini_array段首地址 */
/* __fini_array_end：fini_array段末地址 */
for (fp = &__fini_array_start; fp < &__fini_array_end; fp++) {
(*fp)();
}
}
本小节结束前，再简单提一下pre_main函数。该函数只对主控FMU有意义，被定义在文件libopencm3/lib/stm32/f4/vector_chipset.c中，IO协处理器中的pre_main是个空函数。
主控FMU的pre_main函数只做了一件事：使能硬件浮点运算
libopencm3/lib/stm32/f4/vector_chipset.c
static void pre_main(void)
{
/* 使能硬件浮点运算 */
SCB_CPACR |= SCB_CPACR_FULL * (SCB_CPACR_CP10 | SCB_CPACR_CP11);
}
7.2 主控FMU的main函数
主控FMU的主线程序的核心是main函数，它被入口函数reset_handler调用。main函数的主要功能是初始化主控FMU芯片并启动飞控固件；若成功代码将永远运行飞控程序，若失败则可与上位机通信方便调试飞控板。主控FMU的main函数流程如下：
- 开启浮点运算功能（premain函数中已开启）。
- 调用board_init函数来初始化board_info结构体、GPIOA9（VBUS）端口、USART2端口、LED灯等。
- 调用clock_init函数来设置时钟、flash访问。
- 检查寄存器BOOT_RTC_REG中的值是否与宏BOOT_RTC_SIGNATURE相同。若相同则停留在bootloader。中，若不相同则可以跳转至飞控固件
- 通过检查飞控固件在flash地址0x080041a0和0x080041a4的值，来判定是否停留在bootloader中。
- 检查USB是否连接，若连接则必须等待timeout再跳转到飞控固件。
- 检测串口是否收到break信号（字节0），若收到需等待timeout时间再跳转到飞控固件。
- 若运行到此处try_boot依然为真，则调用函数jump_to_app启动飞控固件---------------------------------------------跳转，若函数返回（跳转失败）则继续9步。
- 若函数jump_to_app返回，跳转失败；设置寄存器BOOT_RTC_REG值确保下次启动能够检测到，设置timeout使程序永远停留在bootloader中。
- 现在bootloader首次启动飞控固件失败，初始化上位机通信接口（USB和USART2）。
- 调用bootloader函数与上位机通信，可运行各种调试命令、烧写新的固件等。
- 若串口USART2收到break信号（0字节），跳转到11步。
- 调用函数jump_to_app启动飞控固件---------------------------------------------跳转，若函数返回（跳转失败）则timeout赋值为0且跳到11步。
值得注意的是，main函数调用的jump_to_app函数依然有很多操作。这部分代码在bl.c文件中定义，其流程具有通用性，但jump_to_app调用的函数又与架构相关，因此这部分将放在后续中。
main_f4.c
#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */
# define BOARD_INTERFACE_CONFIG_USART (void *)BOARD_USART /* 宏BOARD_USART定义为USART2，hw_config.h */
#endif
#if INTERFACE_USB /* 宏INTERFACE_USB定义为1，代码有效，hw_config.h */
# define BOARD_INTERFACE_CONFIG_USB NULL
#endif
int main(void)
{
bool try_boot = true; /* bootloader是否立即跳转到飞控固件入口的标志（不等待timeout） */
unsigned timeout = BOOTLOADER_DELAY; /* bootloader初始化完毕后跳转到飞控固件入口地址时，所需等待的时间，以ms计算。宏BOOTLOADER_DELAY在hw_config.h中被定义为5000 */
SCB_CPACR |= ((3UL << 10 * 2) | (3UL << 11 * 2)); /* 使能浮点运算，其功能与pre_main函数相同，实际上可以去掉。 */
#if defined(BOARD_POWER_PIN_OUT) /* 宏BOARD_POWER_PIN_OUT未定义，下面函数不编译 */
if (board_get_rtc_signature() == POWER_DOWN_RTC_SIGNATURE) {
board_set_rtc_signature(0);
while (1);
}
#endif
/* 调用board_init函数，此函数在main_f4.c中被定义，功能如下： */
/* 1. 赋值board_info.fw_size，确定飞控固件size允许的最大值 */
/* 2. 初始化USB端口GPIOA9（VBUS） */
/* 3. 初始化串口USART2 */
/* 4. 初始化LED并点亮（B/E，LED701） */
/* 5. 使能能耗控制器时钟 */
board_init();
/* 调用clock_init函数，此函数在main_f4.c中被定义，功能如下： */
/* 1. PLL时钟设置，并选择main PLL作为系统时钟sysclk，fsysclk=fPLL=168MHz，fUSBSDRNG=48MHz */
/* 2. AHB、APB1、APB2时钟设置，fAHB=fsysclk=168MHz，fAPB1=42MHz，fAPB2=84MHz */
/* 3. 选择高能耗模式（Scale 2 mode） */
/* 4. flash访问控制设置，启动Icache和Dcache，并设置等待时间5周期 */
/* 5. 更新库libopencm3中AHB，APB1，APB2对应的全局变量 */
clock_init();
/* 检查寄存器BOOT_RTC_REG中的值是否与宏BOOT_RTC_SIGNATURE相同，若相同则停留在bootloader中，若不相同则可以跳转至飞控固件 */
/* BOOT_RTC_REG：RTC_BKPxR的第一个32位寄存器，重启不改变存储值，定义在main_f4.c */
/* BOOT_RTC_SIGNATURE：值0xb007b007，被定义在main_f4.c中 */
/* board_get_rtc_signature：被定义在main_f4.c中，用于获取寄存器BOOT_RTC_REG的存储值 */
/* board_set_rtc_signature：被定义在main_f4.c中，设置寄存器BOOT_RTC_REG的值 */
if (board_get_rtc_signature() == BOOT_RTC_SIGNATURE) {
/* bootloader跳转标志为假，不再立即跳转到飞控固件 */
try_boot = false;
/* timeout清零，若无新的飞控固件上传，不再跳转至飞控固件 */
timeout = 0;
/* 寄存器BOOT_RTC_REG清零，确保下次重启可以跳转至飞控固件 */
board_set_rtc_signature(0);
}
#ifdef BOOT_DELAY_ADDRESS /* 宏BOOT_DELAY_ADDRESS在hw_config.h中有定义，下列代码有效 */
{
/* 这里给定一个机会，通过飞控固件自身的设置可以影响bootloader的行为。 */
/* 设置地址在0x080041a0和0x080041a4的flash值满足一系列逻辑要求，可以防止bootloader自动跳转到飞控固件，给调试工作带来方便。 */
/* BOOT_DELAY_ADDRESS：值0x000001a0，定义在hw_config.h */
/* flash_func_read_word：定义在main_f4.c，用于读取飞控固件内某地址 */
/* 这里，sig1为flash中地址在0x080041a0的32位值，sig2为flash中地址在0x080041a4的32位地址值，在飞控固件地址范围内 */
uint32_t sig1 = flash_func_read_word(BOOT_DELAY_ADDRESS);
uint32_t sig2 = flash_func_read_word(BOOT_DELAY_ADDRESS + 4);
/* BOOT_DELAY_SIGNATURE1：值0x92c2ecff，定义在bl.h */
/* BOOT_DELAY_SIGNATURE2：值0xc5057d5d，定义在bl.h */
/* BOOT_DELAY_MAX：值30，定义在bl.h */
/* 在满足一系列逻辑下，设定try_boot为假，且重新设置timeout，保证跳转到飞控固件前等待timeout时间 */
if (sig2 == BOOT_DELAY_SIGNATURE2 && (sig1 & 0xFFFFFF00) == (BOOT_DELAY_SIGNATURE1 & 0xFFFFFF00)) {
unsigned boot_delay = sig1 & 0xFF;
if (boot_delay <= BOOT_DELAY_MAX) {
try_boot = false;
if (timeout < boot_delay * 1000) {
timeout = boot_delay * 1000;
}
}
}
}
#endif
/* board_test_force_pin：定义在main_f4.c，若bootloader引脚为真，则设置try_boot为假，程序不立即跳转至飞控固件，需等待timeout时间 */
/* 由于函数中条件编译的3个宏（BOARD_FORCE_BL_PIN_OUT、BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN）均未被定义，此函数返回恒为假 */
if (board_test_force_pin()) {
try_boot = false;
}
/* 检查USB是否连接，若连接则必须等待timeout再跳转到飞控固件，否则立即跳转。这样的设置为飞控固件烧写以及调试带来极大方便。 */
#if INTERFACE_USB /* 宏INTERFACE_USB定义在hw_config.h，以下代码有效 */
#if defined(BOARD_USB_VBUS_SENSE_DISABLED) /* 宏BOARD_USB_VBUS_SENSE_DISABLED未定义 */
try_boot = false;
#else
/* GPIOA：地址为0x40020000的寄存器（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO9：值1<<9（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* gpio_get：获取某GPIO组的值，定义在libopencm3/lib/stm32/common/gpio_common_all.c */
/* 根据原理图，GPIOA9对应VBUS/3.1A，高电平表示USB已连接，低电平表示USB未接 */
if (gpio_get(GPIOA, GPIO9) != 0) {
/* 设置try_boot为假，bootloader不会立即跳转至飞控固件，需等待timeout时间 */
try_boot = false;
}
#endif
#endif
/* 检测串口是否收到break信号（字节0），若收到置try_boot为假，需等待timeout时间再跳转到飞控固件 */
#if INTERFACE_USART /* 宏INTERFACE_USB定义在hw_config.h，以下代码有效 */
/* board_test_usart_receiving_break：定义在main_f4.c，连续接收3个字符，若串口上受到字节0则返回真，否则返回假 */
if (board_test_usart_receiving_break()) {
try_boot = false;
}
#endif
/* 若运行到此处try_boot依然为真，则立即跳转到飞控固件（实际上jump_to_app函数代码依然不短，这里可以近似这样认为）； */
/* 若跳转未成功，则设置RTC备份寄存器BOOT_RTC_REG为预定值，确保下次重启若不更新飞控固件依然无法跳转。 */
if (try_boot) {
#ifdef BOARD_BOOT_FAIL_DETECT /* 宏BOARD_BOOT_FAIL_DETECT未定义，以下代码无效 */
board_set_rtc_signature(BOOT_RTC_SIGNATURE);
#endif
/* jump_to_app：定义在bl.c，跳转到飞控固件 */
jump_to_app();
/* BOOT_RTC_SIGNATURE： */
/* board_set_rtc_signature： */
/* 设置RTC备份寄存器BOOT_RTC_REG值为BOOT_RTC_SIGNATURE，下次重启检测到后若不更新飞控固件则不跳转，程序一直运行在bootloader中。 */
board_set_rtc_signature(BOOT_RTC_SIGNATURE);
/* 置timeout为0，程序一直在bootloader中 */
timeout = 0;
}
/* 现在bootloader首次启动飞控固件失败，初始化上位机通信接口（USB和USART2） */
#if INTERFACE_USART /* 宏INTERFACE_USART定义在hw_config.h，下列代码有效 */
/* BOARD_INTERFACE_CONFIG_USART：值USART2（值0x40004400，指向USART2寄存器首地址）。 */
/* BOARD_INTERFACE_CONFIG_USART在main_f4.c中被定义为BOARD_USART，BOARD_USART在hw_config.h中被定义为USART2。*/
/* USART2被定义为USART2_BASE，值0x40004400，指向USART2寄存器首地址（libopencm3/include/libopencm3/stm32/common/usart_common_all.h）。 */
/* USART：值1，枚举型，定义在bl.h */
/* cinit：定义在bl.c，用于初始化通信端口 */
/* 初始化串口USART2为与上位机的通信接口 */
cinit(BOARD_INTERFACE_CONFIG_USART, USART);
#endif
#if INTERFACE_USB /* 宏INTERFACE_USB定义在hw_config.h，下列代码有效 */
/* BOARD_INTERFACE_CONFIG_USB：值NULL，定义在main_f4.c */
/* USB：值2，枚举型，定义在bl.h */
/* cinit：定义在bl.c，用于初始化通信端口 */
/* 初始化USB为虚拟串口作为与上位机的通信接口 */
cinit(BOARD_INTERFACE_CONFIG_USB, USB);
#endif
#if 0 /* 下列代码无效 */
// MCO1/02
gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8);
gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO8);
gpio_set_af(GPIOA, GPIO_AF0, GPIO8);
gpio_mode_setup(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9);
gpio_set_af(GPIOC, GPIO_AF0, GPIO9);
#endif
while (1) {
/* bootloader：bootloader与上位机的命令处理函数，烧写新的固件或者timeout（不为0）时间到返回，定义在bl.c中 */
bootloader(timeout);
/* board_test_force_pin：定义在main_f4.c，若bootloader引脚为真，则继续循环 */
/* 由于函数中条件编译的3个宏（BOARD_FORCE_BL_PIN_OUT、BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN）均未被定义，此函数返回恒为假 */
if (board_test_force_pin()) {
continue;
}
#if INTERFACE_USART /* 宏INTERFACE_USART定义在hw_config.h，下列代码有效 */
/* board_test_usart_receiving_break：连续接收3个字节的内容，如果收到一个0字节则返回真，否则返回假。定义在main_f4.c */
/* 若串口USART2收到break信号（0字节），继续循环 */
if (board_test_usart_receiving_break()) {
continue;
}
#endif
#ifdef BOARD_BOOT_FAIL_DETECT /* 宏BOARD_BOOT_FAIL_DETECT未定义，下列代码无效 */
board_set_rtc_signature(BOOT_RTC_SIGNATURE);
#endif
/* jump_to_app：跳转至飞控固件 */
jump_to_app();
/* 跳转失败，timeout设置为0，永久停留在bootloader中 */
timeout = 0;
}
}
7.2 IO协处理器的main函数
IO协处理器的主线程序的核心是main函数，它被入口函数reset_handler调用。main函数的主要功能是初始化主控FMU芯片并启动飞控固件；若成功代码将永远运行飞控程序，若失败则可与上位机通信方便调试飞控板。IO协处理器的main函数流程如下：
- 调用board_init函数初始化，包括LED灯、强制Bootloader引脚GPIOB5、准备RTC备份寄存器、设置引脚GPIOA2为USART2-TX
- 判定，若RTC备份寄存器BKP_DR1中存储了预定值，则timeout赋值为200ms
- 若GPIO5为高电平，则timeout赋值为0xffffffff，永久停留在bootloader中
- 若timeout为0，则调用jump_to_app立即启动飞控固件---------------------------------------------启动；若jump_to_app函数返回，则timeout赋值为0
- 现在bootloader首次启动飞控固件失败，初始化系统时钟为PLL（使用HSI）
- 函数初始化串口USART2
- 调用bootloader函数与上位机通信，可运行各种调试命令、烧写新的固件等
- 调用函数jump_to_app启动飞控固件---------------------------------------------跳转，若函数返回（跳转失败）则timeout赋值为0且跳到7步。
值得注意的是，main函数调用的jump_to_app函数依然有很多操作。这部分代码在bl.c文件中定义，其流程具有通用性，但jump_to_app调用的函数又与架构相关，因此这部分将放在后续中。
#ifdef INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */
# define BOARD_INTERFACE_CONFIG (void *)BOARD_USART /* 宏BOARD_USART定义为USART2，hw_config.h */
#else
# define BOARD_INTERFACE_CONFIG NULL
#endif
int main(void)
{
unsigned timeout = 0; /* bootloader初始化完毕后跳转到飞控固件入口地址时，所需等待的时间，以ms计算。 */
/* 调用board_init函数，此函数在main_f1.c中被定义，功能如下 */
/* 1. 初始化LED控制并点亮LED灯 */
/* 2. 设置强制Bootloader引脚GPIOB5为浮动输入模式，方便采集安全开关的状态 */
/* 3. 使能能源接口时钟和备份接口时钟，准备RTC备份寄存器 */
/* 4. 设置USART2-TX引脚GPIOA2，对应原理图SERIAL_IO_TO_FMU，用于IO协处理器发送信息到主控FMU */
board_init();
#if defined(INTERFACE_USART) | defined (INTERFACE_USB) /* 宏INTERFACE_USART和INTERFACE_USB分别被定义为1和0，代码有效，hw_config.h */
timeout = BOOTLOADER_DELAY; /* BOOTLOADER_DELAY：值200，表示200ms，hw_config.h */
#endif
#ifdef INTERFACE_I2C /* 宏INTERFACE_I2C未定义，代码无效 */
# error I2C bootloader detection logic not implemented
#endif
/* 若RTC备份寄存器BKP_DR1中存储了预定值，则timeout赋值为200ms */
/* should_wait：判定RTC备份寄存器BKP_DR1中是否存储了预定值。若存储了返回真，未存储则返回假 */
/* BOOTLOADER_DELAY：值200，表示200ms，hw_config.h */
if (should_wait()) {
timeout = BOOTLOADER_DELAY;
}
#ifdef BOARD_FORCE_BL_PIN /* 宏BOARD_FORCE_BL_PIN定义为GPIO5，代码有效，hw_config.h */
/* 若GPIO5为高电平，则timeout赋值为0xffffffff，永久停留在bootloader中 */
/* BOARD_FORCE_BL_VALUE：被定义为GPIO5（1<<5），hw_config.h */
/* BOARD_FORCE_BL_PORT：被定义为GPIOB（GPIOB的首寄存器），hw_config.h */
/* BOARD_FORCE_BL_PIN：被定义为GPIO5（1<<5），hw_config.h */
/* gpio_get：获取某GPIO组的值，定义在libopencm3/lib/stm32/common/gpio_common_all.c */
if (BOARD_FORCE_BL_VALUE == gpio_get(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN)) {
timeout = 0xffffffff;
}
#endif
/* 若timeout为0，则调用jump_to_app立即启动飞控固件。 */
/* 若jump_to_app函数返回，则timeout赋值为0 */
if (timeout == 0) {
jump_to_app();
timeout = 0;
}
/* 初始化系统时钟为PLL（使用HSI） */
/* clock_init：使用HSI将MCU的系统时钟为PLL，频率48MHz，定义在main_f1.c */
clock_init();
/* 函数初始化串口USART2 */
/* BOARD_INTERFACE_CONFIG：定义为BOARD_USART（USART2），main_f1.c */
/* USART：值1，枚举型，定义在bl.h中 */
cinit(BOARD_INTERFACE_CONFIG, USART);
while (1) {
/* bootloader：bootloader与上位机的命令处理函数，烧写新的固件或者timeout（不为0）时间到返回，定义在bl.c中 */
bootloader(timeout);
/* jump_to_app：跳转至飞控固件 */
jump_to_app();
/* 跳转失败，timeout设置为0，永久停留在bootloader中 */
timeout = 0;
}
}
7.3 飞控固件启动函数jump_to_app
主控FMU或IO协处理器的main函数的一个目标就是调用jump_to_app函数来启动对应的飞控固件。jump_to_app函数定义在文件bl.c中，它的主要功能如下：
- 通过飞控固件的烧写约定，检测固件是否有效。若无效函数返回，跳转失败
- 若飞控固件有效，反向初始化MCU外设，准备将外设的控制权交给飞控固件
- 更改向量表地址至飞控固件的向量表（通过向量表偏移寄存器SCB_VTOR）
- 重置堆栈并跳转至飞控固件
bl.c
/* do_jump函数，重置堆栈指针并跳转至飞控固件入口的函数，jump_to_app函数的终极目标 */
static void do_jump(uint32_t stacktop, uint32_t entrypoint)
{
/* 汇编嵌入C语言代码 */
asm volatile( /* 汇编代码声明 */
"msr msp, %0 \n" /* msr：无条件赋值指令，msp：主堆栈寄存器，%0：0号输入（stacktop）。将stacktop赋值给msp */
"bx %1 \n" /* bx：寄存器寻址跳转指令，%1：1号输入（entrypoint）。程序跳转至寄存器entrypoint */
: : "r"(stacktop), "r"(entrypoint) :); /* 定义汇编代码中%0代表stacktop，%1代表entrypoint */
/* 程序应该不会运行到这里，如果不幸到了，进入死循环 */
for (;;) ;
}
/* jump_to_app函数 */
void jump_to_app()
{
/* APP_LOAD_ADDRESS，值0x08004000（主控FMU）0x08001000（IO协处理器），飞控固件起始地址（hw_config.h） */
const uint32_t *app_base = (const uint32_t *)APP_LOAD_ADDRESS;
/* 1. 根据飞控固件的烧写约定，检测固件是否有效 */
/* 飞控固件烧写时，我们特意约定最后烧写固件的首地址（飞控固件使用的堆栈首地址）。若固件首地址为0xffffffff，表明固件烧写未完成（或固件无效）无法跳转，函数直接返回 */
if (app_base[0] == 0xffffffff) {
return;
}
/* 飞控固件的第二个32位代表飞控固件的入口地址。若此地址未在固件指定的地址范围内，则表示固件有问题无法跳转，函数直接返回 */
if (app_base[1] < APP_LOAD_ADDRESS) {
return;
}
if (app_base[1] >= (APP_LOAD_ADDRESS + board_info.fw_size)) {
return;
}
/* 2. 现在飞控固件有效，反向初始化以便把外设控制权交给飞控固件 */
/* flash_lock：主控FMU，锁定flash，操作寄存器FLASH_CR的域LOCK（bit31），定义libopencm3/lib/stm32/common/flash_common_f234.c */
/* flash_lock：IO协处理器，锁定flash，操作寄存器FLASH_CR的域LOCK（bit7），定义libopencm3/lib/stm32/common/flash_common_f01.c */
/* bootloader程序中可能解锁flash进行固件烧写功能，这里确保flash上锁 */
flash_lock();
/* 关闭systick中断 */
systick_interrupt_disable(); /* 关闭systick中断（libopencm3/lib/cm3/systick.c） */
systick_counter_disable(); /* systick倒计时关闭（libopencm3/lib/cm3/systick.c） */
/* 关闭串口USART2和USB虚拟串口，配置不变 */
/* cfini：串口反向初始化函数，即关闭串口和USB虚拟串口，定义在main_f?.c */
cfini();
/* 关闭时钟源，将所有内部时钟设置为重启后的初始状态 */
/* clock_deinit：时钟反向初始化函数，定义在main_f?.c */
clock_deinit();
/* 反向初始化板载外设（包括USART2、LED控制） */
/* board_deinit：板载外设反向初始化函数，定义在main_f?.c */
board_deinit();
/* 3. 更改向量表地址至飞控固件的向量表 */
/* SCB_VTOR：寄存器，向量表偏移地址，地址0xE000ED08 */
/* APP_LOAD_ADDRESS：飞控固件起始地址。0x08004000（主控FMU），0x08001000（IO协处理器） */
SCB_VTOR = APP_LOAD_ADDRESS;
/* 4. 重置堆栈并跳转至飞控固件 */
do_jump(app_base[0], app_base[1]);
}
7.4 命令处理函数bootloader
主控FMU或IO协处理器的main函数调用jump_to_app函数失败（返回）后，就会调用bootloader函数来与上位机进行通信，bootloader定义在文件bl.c中，它的主要功能如下：
- 1.（重新）启动systick定时器和中断，周期为1ms
- 2.若timeout不为0，启动0号时钟（TIMER_BL_WAIT），周期为timeout，单位ms
- 3.设置闪烁B/E LED灯（主控FMU为LED701，IO协处理器为LED703）
- 4.进入命令处理循环
- 4.1 关闭ACT LED灯（主控FMU没有，IO协处理器为LED705）
- 4.2 死循环读取串口数据（1字节），只有读到数据方可跳出循环；此处判断timeout有效且到时函数返回----------------------------------->bootloader函数返回
- 4.3 读到串口数据（命令），开启ACT LED灯
- 4.4 处理获取到的指令字
- （1）若为同步命令PROTO_GET_SYNC
- 指令非法跳转到cmd_bad
- 运行正常跳转4.5
- （2）若为获取设备ID命令PROTO_GET_DEVICE
- 指令非法跳转到cmd_bad
- 运行正常输出信息并跳转到4.5
- （3）若为擦除flash与准备烧写飞控固件指令PROTO_CHIP_ERASE
- 指令非法跳转到cmd_bad
- 芯片版本错误跳转到bad_silicon
- 运行错误跳转到cmd_fail
- 运行正常跳转到4.5
- （4）若为flash烧写命令PROTO_PROG_MULTI
- 指令非法跳转到cmd_bad
- 芯片版本错误跳转到bad_silicon
- 运行错误跳转到cmd_fail
- 运行正常跳转到4.5
- （5）若为CRC32校验命令PROTO_GET_CRC
- 指令非法跳转到cmd_bad
- 运行正常输出校验值并跳转到4.5
- （6）若为读取OTP区域命令PROTO_GET_OTP
- 指令非法跳转到cmd_bad
- 运行正常输出OTP区信息并跳转到4.5
- （7）若为获取MCU的UDID PROTO_GET_SN
- 指令非法跳转到cmd_bad
- 运行正常输出UDID并跳转到4.5
- （8）若为获取芯片ID和版本信息PROTO_GET_CHIP
- 指令非法跳转到cmd_bad
- 运行正常输出芯片ID和版本信息并跳转到4.5
- （9）若为获取芯片描述信息PROTO_GET_CHIP_DES
- 指令非法跳转到cmd_bad
- 运行正常输出芯片描述信息（长度+信息本身）并跳转到4.5
- （10）若为设置飞控固件启动延时PROTO_SET_DELAY
- 指令非法跳转到cmd_bad
- 运行错误跳转到cmd_fail
- 运行正常跳转到4.5
- （11）若为完成烧写并启动飞控固件PROTO_BOOT
- 指令非法跳转到cmd_bad
- 运行错误跳转到cmd_fail
- 运行正常发送PROTO_INSYNC+PROTO_OK，等待100ms，函数返回----------------------------------->bootloader函数返回
- （12）若为输出调试信息（命令暂未完成）PROTO_DEBUG
- 跳转至4.5
- 若为其他指令字
- 跳转至4
- （1）若为同步命令PROTO_GET_SYNC
- 4.5 命令处理完毕，运行成功后的处理，发送PROTO_INSYNC+PROTO_OK，跳转至4
- cmd_bad：指令非法，发送PROTO_INSYNC+PROTO_INVALID，跳转至4
- cmd_fail：指令错误，发送PROTO_INSYNC+PROTO_FAILED，跳转至4
- bad_silicon：芯片版本错误，发送PROTO_INSYNC+PROTO_BAD_SILICON_REV，跳转至4
bl.c
#define BL_PROTOCOL_VERSION 5 /* Bootloader协议版本信息 */
/* 协议字 */
#define PROTO_INSYNC 0x12 /* 同步字 */
#define PROTO_EOC 0x20 /* 命令终止字 */
/* 回告字（https://pixhawk.org/help/errata） */
#define PROTO_OK 0x10 /* 指令运行成功回告字 */
#define PROTO_FAILED 0x11 /* 指令运行错误回告字 */
#define PROTO_INVALID 0x13 /* 非法指令回告字 */
#define PROTO_BAD_SILICON_REV 0x14 /* 主控MCU（F4芯片）版本错误回告字 */
/* 命令字 */
#define PROTO_GET_SYNC 0x21 /* 获取同步命令 */
#define PROTO_GET_DEVICE 0x22 /* 获取设备ID命令 */
#define PROTO_CHIP_ERASE 0x23 /* 擦除flash与准备烧写飞控固件命令 */
#define PROTO_PROG_MULTI 0x27 /* 烧写flash命令 */
#define PROTO_GET_CRC 0x29 /* 计算CRC32校验命令 */
#define PROTO_GET_OTP 0x2a /* 读取OTP区域某地址的1字节 */
#define PROTO_GET_SN 0x2b /* 读取MCU的UDID（Unique Device ID） */
#define PROTO_GET_CHIP 0x2c /* 读取芯片ID和版本 */
#define PROTO_SET_DELAY 0x2d /* 设置飞控固件启动等待时间 */
#define PROTO_GET_CHIP_DES 0x2e /* 获取芯片描述信息 */
#define PROTO_BOOT 0x30 /* 完成烧写并启动飞控固件 */
#define PROTO_DEBUG 0x31 /* 输出调试信息（未完成） */
/* 命令PROTO_GET_DEVICE后跟的参数 */
#define PROTO_DEVICE_BL_REV 1 /* Bootloader协议版本 */
#define PROTO_DEVICE_BOARD_ID 2 /* 板载处理器编号 */
#define PROTO_DEVICE_BOARD_REV 3 /* 修订版本 */
#define PROTO_DEVICE_FW_SIZE 4 /* 飞控固件大小的最大值 */
#define PROTO_DEVICE_VEC_AREA 5 /* 飞控固件向量表7-10项的函数地址（debug_monitor、sv_call、pend_sv、systick） */
/* 全局变量 */
volatile unsigned timer[NTIMERS]; /* NTIMERS：值4，通用倒计时器数量，定义在bl.h；timer：通用计时器数组变量 */
static enum led_state {LED_BLINK, LED_ON, LED_OFF} _led_state; /* _led_state：LED状态枚举型变量 */
static uint8_t bl_type; /* bl_type：接口类型静态全局变量，被bootloader函数定义 */
static uint8_t last_input; /* last_input：静态全局变量，上次获取串口数据的方式 */
static volatile unsigned cin_count; /* cin_count：串口和USB虚拟串口接收到的数据数量，全局变量 */
/* BL_PROTOCOL_VERSION：值5，表示Bootloader协议版本 */
static const uint32_t bl_proto_rev = BL_PROTOCOL_VERSION; /* bl_proto_rev：全局变量，存储Bootloader的版本号，是获取设备ID命令参数PROTO_DEVICE_BL_REV的回告值 */
/* 根据输入设置LED状态的函数，被bootloader函数调用，功能如下： */
/* 若输入为LED_OFF，则关闭B/E LED灯 */
/* 若输入为LED_ON，则关闭B/E LED灯 */
/* 若输入为LED_BLINK，则2号计时器（TIMER_LED）清零，systick中断函数立即，准备闪烁B/E LED灯 */
static void led_set(enum led_state state)
{
/* 更改全局变量_led_state为当前LED状态 */
_led_state = state;
/* LED_OFF：值2，led_state枚举型，定义在bl.c */
/* LED_ON：值1，led_state枚举型，定义在bl.c */
/* LED_BLINK：值0，led_state枚举型，定义在bl.c */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* TIMER_LED：值2，定义在bl.h */
/* timer：通用计时器数组变量，定义在bl.c */
/* led_off：关闭LED灯，定义在main_f?.c */
/* led_on：开启LED灯，定义在main_f?.c */
switch (state) {
case LED_OFF:
led_off(LED_BOOTLOADER);
break;
case LED_ON:
led_on(LED_BOOTLOADER);
break;
case LED_BLINK:
timer[TIMER_LED] = 0;
break;
}
}
/* systick时钟的中断处理函数，向量表中systick域的赋值在libopencm3/lib/cm3/vector.c */
void sys_tick_handler(void)
{
unsigned i;
/* tick到来，各时钟减1 */
/* NTIMERS：值4，通用倒计时器数量，定义在bl.h */
/* timer：通用计时器数组变量，定义在bl.c */
for (i = 0; i < NTIMERS; i++)
if (timer[i] > 0) {
timer[i]--;
}
/* 处理B/E LED（主控FMU为LED701，IO协处理器为LED703）闪烁功能 */
/* 时钟设为50ms，每个周期就是100ms。 */
/* _led_state：全局LED状态枚举（led_state枚举型）变量，存储B/E LED的状态，定义在bl.c */
/* TIMER_LED：值2，定义在bl.h */
/* LED_BLINK：值0，led_state枚举型，定义在bl.c */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* led_toggle：使输入的LED反向，定义在main_f?.c */
if ((_led_state == LED_BLINK) && (timer[TIMER_LED] == 0)) {
led_toggle(LED_BOOTLOADER);
timer[TIMER_LED] = 50;
}
}
/* 延时函数，被bootloader函数调用 */
void delay(unsigned msec)
{
/* timer：通用计时器数组变量，定义在bl.c */
/* TIMER_DELAY：值3，定义在bl.h */
timer[TIMER_DELAY] = msec;
/* 若TIMER_DELAY时钟未到，一直停留在此函数中，确保延时 */
while (timer[TIMER_DELAY] > 0);
}
/* 获取串口数据函数，可为USART和USB虚拟串口 */
inline int cin(void)
{
#if INTERFACE_USB /* 对主控FMU，宏INTERFACE_USART定义为1，代码有效，hw_config.h */
/* 对IO协处理器，宏INTERFACE_USART定义为0，代码无效，hw_config.h */
/* 通过串口获取调试数据，若返回的数据值有效（>=0），则返回获取的数据值，并更新全局变量last_input */
/* NONE：值0，枚举类，定义在bl.h */
/* USB：值2，枚举类，定义在bl.h */
/* bl_type：输入接口类型全局静态变量，被bootloader函数赋值 */
/* last_input：全局变量上次获取串口数据的方式 */
/* usb_cin：从USB模拟串口读入1个字，定义在cdcacm.c */
if (bl_type == NONE || bl_type == USB) {
int usb_in = usb_cin();
if (usb_in >= 0) {
last_input = USB;
return usb_in;
}
}
#endif
#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */
/* 通过串口获取调试数据，若返回的数据值有效（>=0），则返回获取的数据值，并更新全局变量last_input */
/* NONE：值0，枚举类，定义在bl.h */
/* USART：值1，枚举类，定义在bl.h */
/* bl_type：输入接口类型全局静态变量，被bootloader函数赋值 */
/* last_input：全局变量上次获取串口数据的方式 */
/* uart_cin：从串口读入1个字，定义在usart.c */
if (bl_type == NONE || bl_type == USART) {
int uart_in = uart_cin();
if (uart_in >= 0) {
last_input = USART;
return uart_in;
}
}
#endif
return -1; /* 返回错误 */
}
/* 串口或模拟串口输出特定内容的函数 */
inline void cout(uint8_t *buf, unsigned len)
{
#if INTERFACE_USB /* 对主控FMU，宏INTERFACE_USART定义为1，代码有效，hw_config.h */
/* 对IO协处理器，宏INTERFACE_USART定义为0，代码无效，hw_config.h */
/* USB：值2，枚举类，定义在bl.h */
/* bl_type：启动接口类型全局静态变量，被bootloader函数赋值 */
/* usb_cout：USB模拟串口输出特定内容的函数，定义在usart.c */
if (bl_type == USB) {
usb_cout(buf, len);
}
#endif
#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */
/* USART：值1，枚举类，定义在bl.h */
/* bl_type：启动接口类型全局静态变量，被bootloader函数赋值 */
/* uart_cout：USART串口输出特定内容的函数，定义在usart.c */
if (bl_type == USART) {
uart_cout(buf, len);
}
#endif
}
/* 发送同步命令函数，是bootloader函数中命令运行成功后调用的函数 */
static void sync_response(void)
{
/* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */
/* PROTO_OK：值0x10，指令运行成功回告字，定义在bl.c */
/* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */
uint8_t data[] = {
PROTO_INSYNC,
PROTO_OK
};
cout(data, sizeof(data));
}
/* 当MCU型号错误处理函数，串口或USB模拟串口输出非法响应（PROTO_INSYNC+PROTO_BAD_SILICON_REV），是bootloader函数中bad_silicon标号对应的函数 */
#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.f4 */
/* 对IO协处理器，TARGET_HW_PX4_FMU_V4未定义，代码无效 */
static void bad_silicon_response(void)
{
/* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */
/* PROTO_BAD_SILICON_REV：值0x14，主控MCU型号错误命令字，定义在bl.c */
/* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */
uint8_t data[] = {
PROTO_INSYNC,
PROTO_BAD_SILICON_REV
};
cout(data, sizeof(data));
}
#endif
/* 当指令非法时的处理函数，串口或USB模拟串口输出非法响应（PROTO_INSYNC+PROTO_INVALID），是bootloader函数中cmd_bad标号对应的函数 */
static void invalid_response(void)
{
/* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */
/* PROTO_INVALID：值0x13，非法指令字，定义在bl.c */
/* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */
uint8_t data[] = {
PROTO_INSYNC,
PROTO_INVALID
};
cout(data, sizeof(data));
}
/* 当指令运行失败时的处理函数，串口或USB模拟串口输出运行失败响应（PROTO_INSYNC+PROTO_FAILED），是bootloader函数中cmd_fail标号对应的函数 */
static void failure_response(void)
{
/* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */
/* PROTO_FAILED：值0x11，运行失败指令字，定义在bl.c */
/* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */
uint8_t data[] = {
PROTO_INSYNC,
PROTO_FAILED
};
cout(data, sizeof(data));
}
/* 在给定的时间timeout内读到串口数据，则返回数据；若超时返回-1 */
static int cin_wait(unsigned timeout)
{
int c = -1;
/* 设置1号定时器（TIMER_CIN）周期为输入值（此处为0） */
/* TIMER_CIN：值1，定义在bl.h */
/* timer：通用计时器数组变量，定义在bl.c */
timer[TIMER_CIN] = timeout;
/* 一直读取串口获得数据。若要返回，或者读取到数据，或者若定时器（TIMER_CIN）到时。 */
/* cin_count：串口和USB虚拟串口接收到的数据总量，定义在bl.c */
/* cin：获取串口数据函数，定义在bl.c */
do {
c = cin();
if (c >= 0) {
cin_count++;
break;
}
} while (timer[TIMER_CIN] > 0);
return c;
}
/* 串口或USB模拟串口输出1个字 */
static void cout_word(uint32_t val)
{
/* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */
cout((uint8_t *)&val, 4);
}
/* 串口或USB模拟串口读入1个字，具有超时检测功能 */
static int cin_word(uint32_t *wp, unsigned timeout)
{
/* 由于USB串口每次只能读入1字节，而结果需要的是1个字，故定义联合体u长度4字节适用于两种操作 */
union {
uint32_t w;
uint8_t b[4];
} u;
/* 连续4此读取串口，并将其拼接成1个字（小端）；若读取过程中超时则返回-1 */
/* cin_wait：在给定的时间timeout内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */
for (unsigned i = 0; i < 4; i++) {
int c = cin_wait(timeout);
if (c < 0) {
return c;
}
u.b[i] = c & 0xff;
}
*wp = u.w;
return 0;
}
/* 在给定的等待时间内，下一条获取到的命令是否为终止字PROTO_EOC；若是返回真，不是返回假 */
inline static bool wait_for_eoc(unsigned timeout)
{
/* PROTO_EOC：值0x20，命令终止字，定义在bl.c */
/* cin_wait：在给定的输入时间内读到串口数据，则返回数据；若超时返回-1，bl.c */
return cin_wait(timeout) == PROTO_EOC;
}
/* 给出数据src的crc32校验结果 */
static uint32_t crc32(const uint8_t *src, unsigned len, unsigned state)
{
static uint32_t crctab[256];
/* 检查是否已生成crc32校验表（按照定义肯定是未生成的），若未生成则立刻生成 */
if (crctab[1] == 0) {
for (unsigned i = 0; i < 256; i++) {
uint32_t c = i;
for (unsigned j = 0; j < 8; j++) {
if (c & 1) {
c = 0xedb88320U ^ (c >> 1);
} else {
c = c >> 1;
}
}
crctab[i] = c;
}
}
/* 对于从src开始的len长度字节进行crc32校验 */
for (unsigned i = 0; i < len; i++) {
state = crctab[(state ^ src[i]) & 0xff] ^ (state >> 8);
}
return state;
}
void bootloader(unsigned timeout)
{
/* bl_type：全局接口类型变量。NONE：值0，枚举类，定义在bl.h */
/* 若使bootloader实际上能够起作用，必须设置bl_type的类型，不能按照默认值NONE */
bl_type = NONE;
uint32_t address = board_info.fw_size; /* flash当前编写逻辑地址变量，初始化为board_info.fw_size，确保在不执行擦除条件下无法编写 */
uint32_t first_word = 0xffffffff;
/* 1.（重新）启动systick定时器和中断，周期为1ms */
/* STK_CSR_CLKSOURCE_AHB：值1<<2，选取AHB作为systick的时钟源，libopencm3/include/libopencm3/cm3/systick.h */
/* board_info.systick_mhz：值168（主控FMU，main_f4.c），24（IO协处理器，main_f1.c） */
/* systick_set_clocksource：选取systick的时钟源，libopencm3/lib/cm3/systick.c */
/* systick_set_reload：设置systick时钟倒计时（寄存器STK_VAL），libopencm3/lib/cm3/systick.c */
/* systick_interrupt_enable：开启systick中断，libopencm3/lib/cm3/systick.c */
/* systick_counter_enable：systick倒计时开启，libopencm3/lib/cm3/systick.c */
systick_set_clocksource(STK_CSR_CLKSOURCE_AHB);
systick_set_reload(board_info.systick_mhz * 1000); /* 1ms tick, magic number */
systick_interrupt_enable();
systick_counter_enable();
/* 2. 若timeout不为0，启动0号时钟（TIMER_BL_WAIT），周期为timeout，单位ms */
/* timeout为0则不启动时钟，永远停留在本函数中 */
/* TIMER_BL_WAIT：值0，定义在bl.h */
/* timer：unsigned型全局数组，成员有4个，定义在bl.c */
if (timeout) {
timer[TIMER_BL_WAIT] = timeout;
}
/* 3. 设置闪烁B/E LED灯（主控FMU为LED701，IO协处理器为LED703） */
/* B/E LED灯闪烁表示程序处于闲置状态，通过systick时钟的中断处理函数来实现 */
/* LED_BLINK：值0，led_state枚举成员，定义在bl.c */
/* led_set：LED灯状态设置函数，定义在bl.c */
led_set(LED_BLINK);
/* 4. 进入命令处理循环 */
while (true) {
volatile int c;
int arg;
static union {
uint8_t c[256];
uint32_t w[64];
} flash_buffer;
/* 4.1 关闭ACT LED灯（主控FMU没有，IO协处理器为LED705） */
/* LED_ACTIVITY：值1，led_state枚举成员，定义在bl.c */
/* led_off：关闭LED灯，定义在main_f?.c */
led_off(LED_ACTIVITY);
/* 4.2 死循环读取串口数据（1字节），只有读到数据方可跳出循环 */
do {
/* 若timeout非零，0号时钟（TIMER_BL_WAIT）倒计时至0，则timeout时间到返回。 */
/* TIMER_BL_WAIT：值0，定义在bl.h */
/* timeout：bootloader跳转到飞控固件所需等待的时间，bootloader函数输入 */
/* timer：通用计时器数组变量，定义在bl.c */
if (timeout && !timer[TIMER_BL_WAIT]) {
return;
}
/* 不等待，立即读取串口一个数据（cin_wait输入为0） */
/* cin_wait：在给定的输入时间timeout内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */
c = cin_wait(0);
} while (c < 0);
/* 4.3 读到串口数据（命令），开启ACT LED灯 */
/* LED_ACTIVITY：值1，led_state枚举成员，定义在bl.c */
/* led_off：开启LED灯，定义在main_f?.c */
led_on(LED_ACTIVITY);
/* 4.4 处理获取到的命令字 */
switch (c) {
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* (1) 同步命令PROTO_GET_SYNC（0x21），命令结构PROTO_GET_SYNC+PROTO_EOC */
/* * 收到PROTO_GET_SYNC的2ms内未接收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* 接收到同步命令PROTO_GET_SYNC的2ms内位需收到终止字PROTO_EOC（0x20），否则进行错误指令处理 */
/* PROTO_GET_SYNC：值0x21，同步命令字，定义在bl.c */
/* PROTO_EOC：值0x20，命令终止字，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
case PROTO_GET_SYNC:
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为终止字PROTO_EOC；若是返回真，不是返回假 */
/* cmd_bad：标号 */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （2）获取设备ID命令PROTO_GET_DEVICE（0x22），它后面通常还会跟随一个参数（用于指示具体获取设备的哪个内容），命令结构：PROTO_GET_DEVICE+arg(1byte)+PROTO_EOC */
/* * 若为无效参数或参数后2ms内未接收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 若为PROTO_DEVICE_BL_REV（值1），则返回bootloader协议版本号BL_PROTOCOL_VERSION（值5），回告结构：rev(4byte)+(PROTO_INSYNC+PROTO_OK) */
/* * 若为PROTO_DEVICE_BOARD_ID（值2），则返回板载处理器编号board_info.board_type（BOARD_TYPE，主控FMU值9，IO协处理器值10），回告结构：board_type(4byte)+(PROTO_INSYNC+PROTO_OK) */
/* * 若为PROTO_DEVICE_BOARD_REV（值3），则返回修订版本board_info.board_rev（值0），回告结构：board_rev(4byte)+(PROTO_INSYNC+PROTO_OK) */
/* * 若为PROTO_DEVICE_FW_SIZE（值4），则返回飞控固件的最大值（单位KB）board_info.fw_size（主控值2000，IO协处理器APP_SIZE_MAX=0xf000），回告结构：fw_size(4byte)+(PROTO_INSYNC+PROTO_OK) */
/* * 若为PROTO_DEVICE_VEC_AREA（值5），则返回飞控固件向量表7-10项的函数地址（debug_monitor、sv_call、pend_sv、systick），回告结构：vectors(4*4byte)+(PROTO_INSYNC+PROTO_OK) */
/* * 若为其他参数，则进行非法指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_GET_DEVICE: /* PROTO_GET_DEVICE：值0x22，获取设备ID命令，定义在bl.c */
/* cin_wait：在给定的1s时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */
arg = cin_wait(1000);
/* 判定若获取的参数无效（<0）或获取到命令终止，则返回报错 */
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (arg < 0) {
goto cmd_bad;
}
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
/* 判定命令PROTO_GET_DEVICE的参数 */
/* PROTO_DEVICE_BL_REV：值1，命令PROTO_GET_DEVICE的参数，表示获取Bootloader协议版本，定义在bl.c */
/* PROTO_DEVICE_BOARD_ID：值2，命令PROTO_GET_DEVICE的参数，表示获取板载处理器编号（对应board_info.board_type=BOARD_TYPE），定义在bl.c */
/* PROTO_DEVICE_BOARD_REV：值3，命令PROTO_GET_DEVICE的参数，表示获取修订版本（对应board_info.board_rev=0），定义在bl.c */
/* PROTO_DEVICE_FW_SIZE：值4，命令PROTO_GET_DEVICE的参数，表示飞控固件的最大值（对应board_info.fw_size），定义在bl.c */
/* PROTO_DEVICE_VEC_AREA：值5，命令PROTO_GET_DEVICE的参数，表示获取飞控固件向量表7-10项的函数地址（debug_monitor、sv_call、pend_sv、systick），定义在bl.c */
/* bl_proto_rev：全局变量，存储Bootloader的版本号（BL_PROTOCOL_VERSION值5），是获取设备ID命令参数PROTO_DEVICE_BL_REV的回告值，定义在bl.c */
/* cout：串口（包括USB虚拟串口）输出特定内容的函数，定义在bl.c */
/* flash_func_read_word：读取flash特定地址1个字的函数，定义在main_f?.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
switch (arg) {
case PROTO_DEVICE_BL_REV:
cout((uint8_t *)&bl_proto_rev, sizeof(bl_proto_rev));
break;
case PROTO_DEVICE_BOARD_ID:
cout((uint8_t *)&board_info.board_type, sizeof(board_info.board_type));
break;
case PROTO_DEVICE_BOARD_REV:
cout((uint8_t *)&board_info.board_rev, sizeof(board_info.board_rev));
break;
case PROTO_DEVICE_FW_SIZE:
cout((uint8_t *)&board_info.fw_size, sizeof(board_info.fw_size));
break;
case PROTO_DEVICE_VEC_AREA:
for (unsigned p = 7; p <= 10; p++) {
uint32_t bytes = flash_func_read_word(p * 4);
cout((uint8_t *)&bytes, sizeof(bytes));
}
break;
default:
goto cmd_bad;
}
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （3）擦除flash与准备烧写飞控固件指令PROTO_CHIP_ERASE（0x23），命令结构：PROTO_CHIP_ERASE+PROTO_EOC */
/* * 收到PROTO_CHIP_ERASE的2ms内未收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ */
/* * 若为主控FMU芯片（F4），调用check_silicon函数判断MCU版本是否正确（是否为revision 3） */
/* * 若主控FMU版本不正确（revision 3以下），跳转进行bad_silicon处理，回告结构：(PROTO_INSYNC+PROTO_BAD_SILICON_REV) */
/* * 点亮B/E灯，指示正在擦除flash，逐段、页（sector）擦除flash */
/* * 关闭B/E灯，指示擦除flash已完成，取每KB的首字检查flash擦除操作是否成功 */
/* * 若flash擦除操作失败，进行指令运行失败处理，回告结构：(PROTO_INSYNC+PROTO_FAILED) */
/* * 重置flash编写逻辑地址变量address为0，恢复B/E灯闪烁 */
/* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_CHIP_ERASE: /* PROTO_CHIP_ERASE：值0x23，擦除flash与准备烧写飞控固件命令 */
/* 接收到PROTO_CHIP_ERASE命令后2ms内应该接收到终止字PROTO_EOC（0x20），否则进行非法指令处理 */
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cmd_bad：指令非法处理函数的标号，在bootloader函数末尾 */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，宏TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.F4 */
/* 对UI协处理器，宏TARGET_HW_PX4_FMU_V4未定义，代码无效 */
/* check_silicon：函数自动辨识MCU的版本，默认STM32F427的revision 3返回0，其余返回-1 */
/* bad_silicon：MCU版本错误处理函数的标号，在bootloader函数末尾 */
if (check_silicon()) {
goto bad_silicon;
}
#endif
/* 点亮B/E灯 */
/* LED_ON： 值1，led_state枚举成员，定义在bl.c*/
/* led_set：LED灯状态设置函数，定义在bl.c */
led_set(LED_ON);
/* flash_unlock：解锁flash的库函数，定义在libopencm3/lib/stm32/common/flash_common_f234.c（主控FMU），libopencm3/lib/stm32/common/flash_common_f01.c（IO协处理器） */
flash_unlock();
/* 逐段擦除flash */
/* flash_func_sector_size：返回MCU的flash在某sector的大小值，若无此sector则返回0，定义在main_f?.c */
/* flash_func_erase_sector： */
for (int i = 0; flash_func_sector_size(i) != 0; i++) {
flash_func_erase_sector(i);
}
/* 关闭B/E灯 */
/* LED_OFF： 值2，led_state枚举成员，定义在bl.c*/
/* led_set：LED灯状态设置函数，定义在bl.c */
led_set(LED_OFF);
/* 取每KB的首字检查flash擦除操作是否正确，即是否有擦除成功 */
/* board_info.fw_size：飞控固件的最大值（单位KB） */
/* flash_func_read_word：读取某flash地址的数据，定义在main_f?.c */
/* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */
for (address = 0; address < board_info.fw_size; address += 4)
if (flash_func_read_word(address) != 0xffffffff) {
goto cmd_fail;
}
address = 0;
/* B/E灯闪烁 */
/* LED_BLINK： 值0，led_state枚举成员，定义在bl.c*/
/* led_set：LED灯状态设置函数，定义在bl.c */
led_set(LED_BLINK);
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （4）flash烧写命令PROTO_PROG_MULTI（0x27），命令结构：PROTO_PROG_MULTI+arg(1byte)+c(len bytes)+PROTO_EOC */
/* * 收到PROTO_PROG_MULTI的50ms内未收到第一个参数（长度arg），按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 若收到的第一个参数（长度arg）不是4字节对齐，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 若当前编写地址（address）+第一个参数（长度arg）超出飞控固件最大范围board_info.fw_size，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 若收到的第一个参数（长度arg）超出缓冲区长度，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 根据长度arg逐字节接收数据，并存放在缓冲区flash_buffer中；若其中任何1个字节超时1s，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 接收完有效数据后，若200ms内未接收到命令终止字（PROTO_EOC），按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 若当前编写地址address为0，则将烧写缓冲区flash_buffer首个32位保存在变量first_word中，并将缓冲区首改为0xFFFFFFFF */
/* * 对于主控FMU，若MCU版本检查失败，按照MCU版本错误处理，回告结构：(PROTO_INSYNC+PROTO_BAD_SILICON_REV) */
/* * 逐字烧写flash地址，若写入与读出不一致，进行命令失败处理，回告结构：（PROTO_INSYNC+PROTO_FAILED） */
/* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_PROG_MULTI: /* PROTO_PROG_MULTI：值0x27，烧写flash命令 */
/* 50ms内获取第一个参数 */
/* cin_wait：在给定的时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
/* board_info.fw_size：飞控固件的最大值 */
/* flash_buffer：共同体，代表接收缓冲区（256字节或32字） */
arg = cin_wait(50);
if (arg < 0) {
goto cmd_bad;
}
if (arg % 4) {
goto cmd_bad;
}
if ((address + arg) > board_info.fw_size) {
goto cmd_bad;
}
if (arg > sizeof(flash_buffer.c)) {
goto cmd_bad;
}
/* 逐字节接收串口数据并存放在缓冲区内，数据延时不超过1s */
/* cin_wait：在给定的时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
/* flash_buffer：共同体，代表接收缓冲区（256字节或32字） */
for (int i = 0; i < arg; i++) {
c = cin_wait(1000);
if (c < 0) {
goto cmd_bad;
}
flash_buffer.c[i] = c;
}
/* 接收完有效数据后，200ms内必须接收到命令终止字 */
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (!wait_for_eoc(200)) {
goto cmd_bad;
}
/* 若当前编写逻辑地址为0，（对主控FMU，若MCU版本检查失败，跳转到bad_silicon，进行错误MCU版本处理），则将烧写缓冲区flash_buffer首个32位保存在变量first_word中，并将缓冲区首改为0xFFFFFFFF */
/* check_silicon：函数自动辨识MCU的版本，默认STM32F427的revision 3返回0，其余返回-1 */
/* bad_silicon：MCU版本错误处理函数的标号，在bootloader函数末尾 */
/* first_word：首字保存变量，定义在bootloader函数中 */
/* flash_buffer：共同体，代表接收缓冲区（256字节或32字） */
if (address == 0) {
#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，宏TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.f4 */
/* 对IO协处理器，宏TARGET_HW_PX4_FMU_V4未定义，代码无效 */
if (check_silicon()) {
goto bad_silicon;
}
#endif
first_word = flash_buffer.w[0];
flash_buffer.w[0] = 0xffffffff;
}
/* 逐字烧写flash地址，若写入与读出不一致，跳转到cmd_fail，进行命令失败处理，返回PROTO_INSYNC+PROTO_FAILED */
/* flash_func_write_word：烧写flash某地址起始为特定内容，4位烧写，定义在main_f?.c */
/* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */
/* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */
arg /= 4;
for (int i = 0; i < arg; i++) {
flash_func_write_word(address, flash_buffer.w[i]);
if (flash_func_read_word(address) != flash_buffer.w[i]) {
goto cmd_fail;
}
address += 4;
}
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （5）CRC32校验命令PROTO_GET_CRC（0x29），命令结构：PROTO_GET_CRC+PROTO_EOC */
/* * 收到PROTO_GET_CRC的2ms内未接收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 计算CRC32结果，输出crcsum(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_GET_CRC: /* PROTO_GET_CRC：值0x29，CRC32校验命令 */
/* 2ms内必须收到命令终止字PROTO_EOC */
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
/* 计算烧写区域的CRC32值，注意飞控固件首地址的处理 */
/* board_info.fw_size：飞控固件的最大值 */
/* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */
/* crc32：计算给定数据的crc32校验结果 */
uint32_t sum = 0;
for (unsigned p = 0; p < board_info.fw_size; p += 4) {
uint32_t bytes;
if ((p == 0) && (first_word != 0xffffffff)) {
bytes = first_word;
} else {
bytes = flash_func_read_word(p);
}
sum = crc32((uint8_t *)&bytes, sizeof(bytes), sum);
}
/* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */
cout_word(sum);
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （6）读取OTP区域命令PROTO_GET_OTP（0x2a），命令结构：PROTO_GET_OTP+index(4byte)+PROTO_EOC */
/* * 收到PROTO_GET_OTP后未在允许延时（100ms）内收到有效的地址信息，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 收到地址后2ms内未收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 运行成功，输出OTP地址数值val(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_GET_OTP: /* PROTO_GET_OTP：值0x2a，读取OTP区域某地址的1字节指令 */
uint32_t index = 0;
/* cin_word：串口或USB模拟串口读入1个字，具有超时检测功能，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (cin_word(&index, 100)) {
goto cmd_bad;
}
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
cout_word(flash_func_read_otp(index));
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （7）获取MCU的UDID（Unique Device ID，或称为序列号）PROTO_GET_SN（0x2b），命令结构PROTO_GET_SN+index(4byte)+PROTO_EOC */
/* * 收到PROTO_GET_SN后未在允许延时（100ms）内收到有效的地址信息，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 收到地址后2ms内未收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 运行成功，输出UDID数值val(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_GET_SN: /* PROTO_GET_SN：值0x2b，获取MCU的UDID命令 */
uint32_t index = 0;
/* cin_word：串口或USB模拟串口读入1个字，具有超时检测功能，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (cin_word(&index, 100)) {
goto cmd_bad;
}
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
cout_word(flash_func_read_sn(index));
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （8）获取芯片ID和版本信息PROTO_GET_CHIP（0x2c），命令结构PROTO_GET_CHIP+PROTO_EOC */
/* * 收到命令PROTO_GET_CHIP后2ms内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 运行成功，输出芯片ID和版本信息数值val(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_GET_CHIP: /* PROTO_GET_CHIP：值0x2c，获取芯片ID和版本信息 */
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* get_mcu_id：读取寄存器DBGMCU_IDCODE值，表示芯片ID和版本 */
/* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
cout_word(get_mcu_id());
break;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （9）获取芯片描述信息PROTO_GET_CHIP_DES（0x2e），命令结构PROTO_GET_CHIP_DES+PROTO_EOC */
/* * 收到命令PROTO_GET_CHIP后2ms内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 运行成功，输出芯片描述信息len（4byte）+buffer(len byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_GET_CHIP_DES: /* PROTO_GET_CHIP_DES：值0x2e，获取芯片的描述信息 */
/* MAX_DES_LENGTH：值20，芯片描述信息最大长度，定义在bl.c */
uint8_t buffer[MAX_DES_LENGTH];
unsigned len = MAX_DES_LENGTH;
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
/* get_mcu_desc：返回MCU的型号和版本描述信息，定义在main_f?.c */
/* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */
/* cout：串口（包括USB虚拟串口）输出特定内容的函数，定义在bl.c */
len = get_mcu_desc(len, buffer);
cout_word(len);
cout(buffer, len);
break;
#ifdef BOOT_DELAY_ADDRESS /* 对主控FMU，BOOT_DELAY_ADDRESS定义为0x1a0，代码有效，hw_config.h */
/* 对IO协处理器，BOOT_DELAY_ADDRESS未定义，代码无效 */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （10）设置飞控固件启动延时PROTO_SET_DELAY（0x2d），命令结构：PROTO_SET_DELAY+v(4byte)+PROTO_EOC */
/* * 收到PROTO_SET_DELAY后100ms内未收到延时v，或延时时间为负数，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 取延时v的最低字节为时延boot_delay有效信息（单位s），若此值大于允许最大值BOOT_DELAY_MAX，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 收到延时v的2ms内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 读取BOOT_DELAY_ADDRESS起始的显示延时信息有效性的2个关键字，通过与预定的关键字对比，若不一致则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 根据延时boot_delay和关键字BOOT_DELAY_SIGNATURE1确定需存放在地址BOOT_DELAY_ADDRESS的数据，并写入以更新延时参数 */
/* * 再次读取地址BOOT_DELAY_ADDRESS的数据与需写入的数据进行对比，若不一致（写入失败），则进行命令失败处理，回告结构：（PROTO_INSYNC+PROTO_FAILED） */
/* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_SET_DELAY: /* PROTO_SET_DELAY：值0x2d，设置飞控固件启动延时 */
/* cin_wait：在给定的时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
int v = cin_wait(100);
if (v < 0) {
goto cmd_bad;
}
/* 取v的低字节作为时延boot_delay的有效信息（时延最大255s） */
/* BOOT_DELAY_MAX：值30，飞控固件启动最大时延，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
uint8_t boot_delay = v & 0xFF;
if (boot_delay > BOOT_DELAY_MAX) {
goto cmd_bad;
}
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (!wait_for_eoc(2)) {
goto cmd_bad;
}
/* 读取BOOT_DELAY_ADDRESS起始的2个字，提取显示延时信息有效性的2个关键字，通过对比来判断信息是否有效 */
/* BUG?sig1的最低字节是延时参数，不应作为判断依据，这里有问题 */
/* BOOT_DELAY_ADDRESS：值0x000001a0，飞控固件启动延时信息在flash中的存储地址，仅对主控FMU有效，定义在hw_config.h */
/* BOOT_DELAY_SIGNATURE1：值0x92c2ecff，飞控固件启动延时信息有效的关键字1，定义在bl.h */
/* BOOT_DELAY_SIGNATURE2：值0xc5057d5d，飞控固件启动延时信息有效的关键字2，定义在bl.h */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
uint32_t sig1 = flash_func_read_word(BOOT_DELAY_ADDRESS);
uint32_t sig2 = flash_func_read_word(BOOT_DELAY_ADDRESS + 4);
if (sig1 != BOOT_DELAY_SIGNATURE1 || sig2 != BOOT_DELAY_SIGNATURE2) {
goto cmd_bad;
}
/* 根据延时boot_delay和关键字BOOT_DELAY_SIGNATURE1确定需存放在地址BOOT_DELAY_ADDRESS的数据，并写入 */
/* BOOT_DELAY_SIGNATURE1：值0x92c2ecff，飞控固件启动延时信息有效的关键字1，定义在bl.h */
/* BOOT_DELAY_ADDRESS：值0x000001a0，飞控固件启动延时信息在flash中的存储地址，仅对主控FMU有效，定义在hw_config.h */
/* flash_func_write_word：烧写flash某地址起始为特定内容，4位烧写，定义在main_f?.c */
uint32_t value = (BOOT_DELAY_SIGNATURE1 & 0xFFFFFF00) | boot_delay;
flash_func_write_word(BOOT_DELAY_ADDRESS, value);
/* 再次读取地址BOOT_DELAY_ADDRESS的数据与需写入的数据进行对比，若不一致则跳转到cmd_fail，运行失败 */
/* BOOT_DELAY_ADDRESS：值0x000001a0，飞控固件启动延时信息在flash中的存储地址，仅对主控FMU有效，定义在hw_config.h */
/* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */
/* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */
if (flash_func_read_word(BOOT_DELAY_ADDRESS) != value) {
goto cmd_fail;
}
break;
#endif
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （11）完成烧写并启动飞控固件PROTO_BOOT（0x30），命令结构：PROTO_BOOT+PROTO_EOC */
/* * 收到启动命令PROTO_BOOT的1s内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */
/* * 若变量first_word（飞控固件首字保存变量）中有内容 */
/* * 烧写飞控固件首字first_word */
/* * 读取飞控固件首字并与first_word对比，若不同则进行命令失败处理，回告结构：（PROTO_INSYNC+PROTO_FAILED） */
/* * 烧写首字成功，将first_word变量置为无效（0xffffffff） */
/* * 运行成功，发送PROTO_INSYNC+PROTO_OK，延时100ms，bootloader函数返回 */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_BOOT: /* PROTO_BOOT：值0x30，完成烧写并启动飞控固件 */
/* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */
/* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */
if (!wait_for_eoc(1000)) {
goto cmd_bad;
}
/* 若变量first_word内容有效，烧写飞控固件首字并判断是否烧写成功 */
/* first_word：飞控固件首字保存变量，定义在bootloader函数中 */
/* flash_func_write_word：烧写flash某地址起始为特定内容，4位烧写，定义在main_f?.c */
/* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */
/* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */
if (first_word != 0xffffffff) {
flash_func_write_word(0, first_word);
/* 读取飞控固件首字并与first_word对比，若不同则跳转到cmd_fail，进行命令失败处理 */
if (flash_func_read_word(0) != first_word) {
goto cmd_fail;
}
/* 将first_word变量置为无效（0xffffffff） */
first_word = 0xffffffff;
}
/* sync_response：发送同步命令函数，表示运行成功，定义在bl.c */
/* delay：延时函数，定义在bl.c */
sync_response();
delay(100);
// quiesce and jump to the app
return;
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* （12）输出调试信息（命令暂未完成）PROTO_DEBUG（0x31），直接按运行成功处理，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
case PROTO_DEBUG: /* PROTO_DEBUG：值0x31，输出调试信息 */
break;
default:
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
/* 其他命令，直接进入接收新的命令循环 */
/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
continue;
}
/* 4.5 命令处理完毕，运行成功后的处理（变量timeout初始化和bl_type重新赋值，调用sync_response函数发送PROTO_INSYNC+PROTO_OK表示运行成功），继续接收下一条指令。 */
/* timeout：bootloader跳转到飞控固件所需等待的时间，bootloader函数输入 */
/* bl_type：静态全局接口类型变量， */
/* NONE：值0，枚举类，定义在bl.h */
/* last_input：静态全局变量，上次获取串口数据的方式 */
/* sync_response：发送同步命令函数，表示运行成功，定义在bl.c */
timeout = 0;
if (bl_type == NONE) {
bl_type = last_input;
}
sync_response();
continue;
cmd_bad: /* cmd_bad：错误指令处理标号，发送PROTO_INSYNC+PROTO_INVALID，并准备接收下一条指令 */
/* invalid_response：指令非法的处理函数，发送PROTO_INSYNC+PROTO_INVALID，定义在bl.c */
invalid_response();
continue;
cmd_fail: /* cmd_fail：指令运行失败，发送PROTO_INSYNC+PROTO_FAILED，并准备接收下一条指令 */
/* failure_response：指令运行失败的处理函数，发送PROTO_INSYNC+PROTO_FAILED，定义在bl.c */
failure_response();
continue;
#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，宏TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.f4 */
/* 对IO协处理器，宏TARGET_HW_PX4_FMU_V4未定义，代码无效 */
bad_silicon: /* bad_silicon：MCU版本错误处理函数的标号，发送PROTO_INSYNC+PROTO_BAD_SILICON_REV，并准备接收下一条指令 */
/* bad_silicon_response：MCU型号错误处理函数，发送PROTO_INSYNC+PROTO_BAD_SILICON_REV，定义在bl.c */
bad_silicon_response();
continue;
#endif
}
}
8 主控FMU主线程序调用的函数
本节汇总了被主控FMU主线程序（main、jump_to_app和bootloader）调用的函数。
8.1 板载初始化相关函数
板载初始化相关函数包括board_init和反向初始化函数board_deinit，它们分别被main函数和jump_to_app函数调用。
8.1.1 board_init函数
board_init函数主要的功能如下：
- 赋值board_info.fw_size，确定飞控固件size允许的最大值
- 初始化USB端口GPIOA9（VBUS）
- 初始化串口USART2
- 初始化LED并点亮（B/E，LED701）
- 使能能耗控制器时钟
main_f4.c
static void board_init(void)
{
/* 1. 赋值board_info.fw_size，确定飞控固件size允许的最大值*/
/* 修改fw_size值为APP_SIZE_MAX，宏APP_SIZE_MAX被main_f4.c定义为 BOARD_FLASH_SIZE-(BOOTLOADER_RESERVATION_SIZE+APP_RESERVATION_SIZE) */
/* BOARD_FLASH_SIZE：被定义在hw_config.h中，BOARD_FLASH_SIZE=_FLASH_KBYTES*1024，_FLASH_KBYTES通过读取地址0x1FFF7A22的低16位寄存器得到，此寄存器值代表以KB为单位的芯片的flash大小，属性只读 */
/* BOOTLOADER_RESERVATION_SIZE：被定义在main_f4.c中，BOOTLOADER_RESERVATION_SIZE=16*1024，代表16KB（1个sector） */
/* APP_RESERVATION_SIZE：被定义在hw_config.h中，APP_RESERVATION_SIZE=2*16*1024，代表32KB（2个sector） */
/* 对于STM32F427VIT6，BOARD_FLASH_SIZE=2048KB，APP_SIZE_MAX=2000KB */
board_info.fw_size = APP_SIZE_MAX;
#if defined(TARGET_HW_PX4_FMU_V2) || defined(TARGET_HW_PX4_FMU_V4) /* 定义了宏TARGET_HW_PX4_FMU_V2，因此下列代码有效 */
/* check_silicon函数自动辨识MCU的版本，默认STM32F427的revision 3返回0，其余返回-1 */
/* fw_size的值为APP_SIZE_MAX=2000KB，第二项判断语句肯定为假 */
/* 因此该if语句不为真，fw_size不被重新赋值，其值保持为2000KB */
if (check_silicon() && board_info.fw_size == (2 * 1024 * 1024) - BOOTLOADER_RESERVATION_SIZE) {
board_info.fw_size = (1024 * 1024) - BOOTLOADER_RESERVATION_SIZE;
}
#endif
#if defined(BOARD_POWER_PIN_OUT) /* 宏BOARD_POWER_PIN_OUT未定义，下列语句无效 */
/* Configure the Power pins */
rcc_peripheral_enable_clock(&BOARD_POWER_CLOCK_REGISTER, BOARD_POWER_CLOCK_BIT);
gpio_mode_setup(BOARD_POWER_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_POWER_PIN_OUT);
gpio_set_output_options(BOARD_POWER_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, BOARD_POWER_PIN_OUT);
BOARD_POWER_ON(BOARD_POWER_PORT, BOARD_POWER_PIN_OUT);
#endif
/* 2. 初始化USB端口GPIOA9（VBUS） */
#if INTERFACE_USB /* 宏INTERFACE_USB在hw_config.h中被定义为1，下列代码有效 */
/* RCC_AHB1ENR：寄存器（libopencm3/include/libopencm3/stm32/f4/rcc.h，地址0x40023830） */
/* RCC_AHB1ENR_IOPAEN：值为1<<0（libopencm3/include/libopencm3/stm32/f4/rcc.h），bit0 */
/* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* 使能GPIOA的时钟，对应原理图中主控FMU连接USB接口芯片（U302，NUF2042VX6）的3个引脚GPIOA9(VBUS/3.1A)，GPIOA11(OTG_FS_DM/3.1B)，GPIOA12(OTG_FS_DP/3.1A) */
rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
#endif
/* 3. 初始化串口USART2 */
#if INTERFACE_USART /* 宏INTERFACE_USART在hw_config.h中被定义为1，下列代码有效 */
/* BOARD_USART_PIN_CLOCK_REGISTER：被hw_config.h定义为寄存器RCC_AHB1ENR（libopencm3/include/libopencm3/stm32/f4/rcc.h，地址0x40023830） */
/* BOARD_USART_PIN_CLOCK_BIT：被hw_config.h定义为RCC_AHB1ENR_IOPDEN（libopencm3/include/libopencm3/stm32/f4/rcc.h），值1<<3，bit3 */
/* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* 使能GPIOD的时钟，对应原理图中主控FMU串口USART2的4个引脚GPIOD3(FMU-USART2_CTS/2.1B)，GPIOD4(FMU-USART2_RTS/2.1B)，GPIOD5(FMU-USART2_TX/2.1A)，GPIOD6(FMU-USART2_RX/2.1A) */
rcc_peripheral_enable_clock(&BOARD_USART_PIN_CLOCK_REGISTER, BOARD_USART_PIN_CLOCK_BIT);
/* BOARD_PORT_USART：被hw_config.h定义为GPIOD，对应寄存器GPIOD_MODER（地址0x40020C00） */
/* GPIO_MODE_AF：值为0x2（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_PUPD_PULLUP：值为0x1（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* BOARD_PIN_TX：被hw_config.h定义为GPIO5，值1<<5（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* BOARD_PIN_RX：被hw_config.h定义为GPIO6，值1<<6（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* gpio_mode_setup：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO引脚的功能 */
/* 设置GPIOD5（USART2-TX）和GPIOD6（USART2-RX）为AF（MODER=GPIO_MODE_AF=10）模式，片内上拉push-pull（PUPDR=GPIO_PUPD_PULLUP=01） */
gpio_mode_setup(BOARD_PORT_USART, GPIO_MODE_AF, GPIO_PUPD_PULLUP, BOARD_PIN_TX | BOARD_PIN_RX);
/* BOARD_PORT_USART：被hw_config.h定义为GPIOD，对应寄存器GPIOD_MODER（地址0x40020C00） */
/* BOARD_PORT_USART_AF：被hw_config.h定义为GPIO_AF7，值0x7 */
/* BOARD_PIN_TX：被hw_config.h定义为GPIO5，值1<<5（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* BOARD_PIN_RX：被hw_config.h定义为GPIO6，值1<<6（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* gpio_set_af：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO的具体AF功能 */
/* 设置GPIOD5（USART2-TX）和GPIOD6（USART2-RX）为USART1~3功能（具体为USART2） */
gpio_set_af(BOARD_PORT_USART, BOARD_PORT_USART_AF, BOARD_PIN_TX);
gpio_set_af(BOARD_PORT_USART, BOARD_PORT_USART_AF, BOARD_PIN_RX);
/* BOARD_USART_CLOCK_REGISTER：被hw_config.h定义为寄存器RCC_APB1ENR（地址0x40023840） */
/* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* 使能USART2的时钟，寄存器RCC_APB1ENR的bit17 */
rcc_peripheral_enable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif
#if defined(BOARD_FORCE_BL_PIN_IN) && defined(BOARD_FORCE_BL_PIN_OUT) /* 宏BOARD_FORCE_BL_PIN_IN与BOARD_FORCE_BL_PIN_OUT均未被定义，以下代码无效 */
/* configure the force BL pins */
rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT);
gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN_IN);
gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT);
gpio_set_output_options(BOARD_FORCE_BL_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, BOARD_FORCE_BL_PIN_OUT);
#endif
#if defined(BOARD_FORCE_BL_PIN) /* 宏BOARD_FORCE_BL_PIN未定义，下列代码无效 */
/* configure the force BL pins */
rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT);
gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN);
#endif
/* 4. 初始化LED并点亮（B/E，LED701） */
/* RCC_AHB1ENR：寄存器（地址0x40023830） */
/* BOARD_CLOCK_LEDS：被hw_config.h定义为RCC_AHB1ENR_IOPEEN，值1<<4，bit4 */
/* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* 使能GPIOE的时钟，对应原理图中主控FMU的LED控制引脚GPIOE12（FMU-LED_AMBER/7.5B），低电平点亮发光二极管LED701 */
rcc_peripheral_enable_clock(&RCC_AHB1ENR, BOARD_CLOCK_LEDS);
/* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */
/* GPIO_MODE_OUTPUT：值0x1（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_PUPD_NONE：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */
/* gpio_mode_setup：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO引脚的功能 */
/* 设置GPIOE12（FMU-LED_AMBER/7.5B）为输出模式（MODER=GPIO_MODE_OUTPUT=01），push-pull模式（PUPDR=GPIO_PUPD_NONE=00） */
gpio_mode_setup(BOARD_PORT_LEDS, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
/* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */
/* GPIO_OTYPE_PP：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_OSPEED_2MHZ：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */
/* gpio_set_output_options：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO的输出模式 */
/* 设置GPIOE12（FMU-LED_AMBER/7.5B）的输出模式为push-pull（OTYPER=GPIO_OTYPE_PP=0），GPIO时钟为2MHz（OSPEEDR=GPIO_OSPEED_2MHZ=00） */
gpio_set_output_options(BOARD_PORT_LEDS, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
/* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */
/* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */
/* BOARD_LED_ON：被hw_config.h定义为函数gpio_clear（libopencm3/lib/stm32/common/gpio_common_all.c）,功能为置某GPIO组中的引脚输出为低电平 */
/* 设置GPIOE12（FMU-LED_AMBER/7.5B）为低电平，点亮B/E（LED701） */
BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
/* 5. 使能能耗控制器时钟 */
/* RCC_APB1ENR：寄存器（地址0x40023840） */
/* RCC_APB1ENR_PWREN：值1<<28（libopencm3/include/libopencm3/stm32/f4/rcc.h），bit28 */
/* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* 使能电源接口时钟 */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN);
}
8.1.2 board_deinit函数
board_deinit函数用于板载设备的反向初始化：主要的功能如下：
- 无效化串口USART2
- 无效化LED时钟引脚
- 关闭电源接口时钟
- 恢复AHB1外部时钟为默认值
main_f4.c
void board_deinit(void)
{
#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，在hw_config.h，下列代码有效 */
/* 1. 无效化串口USART2 */
/* 设置USART2的输入输出引脚为输入状态 */
/* BOARD_PORT_USART：被hw_config.h定义为GPIOD，对应寄存器GPIOD_MODER（地址0x40020C00） */
/* GPIO_MODE_INPUT：值为0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_PUPD_NONE：值为0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* BOARD_PIN_TX：被hw_config.h定义为GPIO5，值1<<5（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* BOARD_PIN_RX：被hw_config.h定义为GPIO6，值1<<6（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* gpio_mode_setup：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO引脚的功能 */
/* 设置GPIOD5（USART2-TX）和GPIOD6（USART2-RX）为输入模式（MODER=GPIO_MODE_INPUT=00），浮动状态（PUPDR=GPIO_PUPD_NONE=00） */
gpio_mode_setup(BOARD_PORT_USART, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_PIN_TX | BOARD_PIN_RX);
/* 关闭USART2的时钟 */
/* BOARD_USART_CLOCK_REGISTER：被hw_config.h定义为寄存器RCC_APB1ENR（地址0x40023840） */
/* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* rcc_peripheral_disable_clock：关闭特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
rcc_peripheral_disable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif
#if defined(BOARD_FORCE_BL_PIN_IN) && defined(BOARD_FORCE_BL_PIN_OUT) /* 宏BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN_OUT未定义，下列代码无效 */
gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT);
gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_IN);
#endif
#if defined(BOARD_FORCE_BL_PIN) /* 宏BOARD_FORCE_BL_PIN未定义，下列代码无效 */
gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN);
#endif
#if defined(BOARD_POWER_PIN_OUT) && defined(BOARD_POWER_PIN_RELEASE) /* 宏BOARD_POWER_PIN_OUT和BOARD_POWER_PIN_RELEASE未定义，下列代码无效 */
gpio_mode_setup(BOARD_POWER_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_POWER_PIN);
#endif
/* 2. 无效化LED时钟引脚（设为输入模式） */
/* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */
/* GPIO_MODE_INPUT：值为0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */
/* BOARD_LED_ON：被hw_config.h定义为函数gpio_clear（libopencm3/lib/stm32/common/gpio_common_all.c）,功能为置某GPIO组中的引脚输出为低电平 */
/* 设置GPIOE12（FMU-LED_AMBER/7.5B）为输入模式（MODER=GPIO_MODE_INPUT=00），浮动模式（PUPDR=GPIO_PUPD_NONE=00） */
gpio_mode_setup(BOARD_PORT_LEDS, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
/* 3. 关闭电源接口时钟 */
/* RCC_APB1ENR：寄存器（地址0x40023840） */
/* RCC_APB1ENR_PWREN：值1<<28（libopencm3/include/libopencm3/stm32/f4/rcc.h），bit28 */
/* rcc_peripheral_disable_clock：关闭特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
rcc_peripheral_disable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN);
/* 4. 恢复AHB1外部时钟为默认值 */
/* RCC_AHB1ENR：AHB1外部时钟使能寄存器 */
RCC_AHB1ENR = 0x00100000; // XXX Magic reset number from STM32F4x reference manual
}
8.2 时钟初始化相关函数
板载初始化相关函数包括clock_init和反向初始化函数clock_deinit，它们分别被main函数和jump_to_app函数调用。
8.2.1 clock_init函数
clock_init函数用到了一个数据结构rcc_clock_scale，它被定义在libopencm3/include/libopencm3/stm32/f4/rcc.h中。
libopencm3/include/libopencm3/stm32/f4/rcc.h
truct rcc_clock_scale {
uint8_t pllm; /* 寄存器RCC_PLLCFGR中的PLLM信息（5:0） */
uint16_t plln; /* 寄存器RCC_PLLCFGR中的PLLN信息（14:6） */
uint8_t pllp; /* 寄存器RCC_PLLCFGR中的PLLP信息（17:16） */
uint8_t pllq; /* 寄存器RCC_PLLCFGR中的PLLQ信息（27:24） */
uint8_t pllr; /* 仅STM32F446/469包含此项 */
uint32_t flash_config; /* flash访问控制，对应寄存器FLASH_ACR */
uint8_t hpre; /* 寄存器RCC_CFGR中的HPRE信息（7:4） */
uint8_t ppre1; /* 寄存器RCC_CFGR中的PPRE1信息（12:10） */
uint8_t ppre2; /* 寄存器RCC_CFGR中的PPRE2信息（15:13） */
uint8_t power_save; /* 0：高能耗模式（scale 1，11），1：节能模式（scale 3，01）；对应寄存器PWR_CR的VOS信息（15:14） */
uint32_t ahb_frequency; /* AHB时钟频率 */
uint32_t apb1_frequency; /* APB1时钟频率 */
uint32_t apb2_frequency; /* APB2时钟频率 */
};
通过设置数据结构rcc_clock_scale中域的值，可实现如下功能：
- PLL时钟设置，并选择main PLL作为系统时钟sysclk，fsysclk=fPLL=168MHz，fUSBSDRNG=48MHz
- AHB、APB1、APB2时钟设置，fAHB=fsysclk=168MHz，fAPB1=42MHz，fAPB2=84MHz
- 选择高能耗模式（Scale 2 mode）
- flash访问控制设置，启动Icache和Dcache，并设置等待时间5周期
- 更新库libopencm3中AHB，APB1，APB2对应的全局变量
main_f4.c
static const struct rcc_clock_scale clock_setup = {
/* PLL时钟设置 */
.pllm = OSC_FREQ, /* PLLM=OSC_FREQ=24（hw_config.h） */
.plln = 336, /* PLLN=336 */
.pllp = 2, /* PLLP=2 */
.pllq = 7, /* PLLQ=7 */
#if defined(STM32F446) || defined(STM32F469) /* 未定义宏STM32F446和STM32F469，pllr域不初始化 */
.pllr = 2,
#endif
/* AHB、APB1、APB2时钟设置 */
.hpre = RCC_CFGR_HPRE_DIV_NONE, /* HPRE=RCC_CFGR_HPRE_DIV_NONE=0（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
.ppre1 = RCC_CFGR_PPRE_DIV_4, /* PPRE1=RCC_CFGR_PPRE_DIV_4=0x5（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
.ppre2 = RCC_CFGR_PPRE_DIV_2, /* PPRE1=RCC_CFGR_PPRE_DIV_2=0x4（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* 能耗模式 */
.power_save = 0, /* VOS=10，默认为11 */
/* flash访问控制 */
.flash_config = FLASH_ACR_ICE | FLASH_ACR_DCE | FLASH_ACR_LATENCY_5WS, /* 寄存器FLASH_ACR的ICEN(9)，DCEN(10)，LATENCY(3:0) */
/* 更新APB1、APB2时钟全局变量值 */
.apb1_frequency = 42000000, /* */
.apb2_frequency = 84000000,
};
/* rcc_clock_setup_hse_3v3：被定义在libopencm3/lib/stm32/f4/rcc.c，用于启动后各系统时钟的初始化、能耗模式配置、flash访问控制 */
/* 1. PLL时钟设置（寄存器RCC_PLLCFGR） */
/* fVCO=fPLLin*(PLLN/PLLM)=24*(336/24)=336MHz，（根据原理图，主控FMU的外部晶振频率为24MHz） */
/* fPLL=fVCO/PLLP=168MHz */
/* fUSBSDRNG=fVCO/PLLQ=48MHz */
/* 2. AHB、APB1、APB2时钟设置（寄存器RCC_CFGR） */
/* fAHB=fsysclk=fPLL=168MHz，域HPRE=0，不分频，系统时钟由调用的rcc_set_sysclk_source函数设置为fPLL */
/* fAPB1=fAHB/4=42MHz，域PPRE1=101，分频倍率为4 */
/* fAPB2=fAHB/2=84MHz，域PPRE2=100，分频倍率为2 */
/* 3. 能耗模式 */
/* 寄存器PWR_CR的域VOS=10，对应Scale 2 mode */
/* 4. flash访问控制 */
/* ICEN=FLASH_ACR_ICE=1，bit9，使能I cache */
/* DCEN=FLASH_ACR_DCE=1，bit10，使能D cache */
/* LATENCY=FLASH_ACR_LATENCY_5WS=0x5，访问等待5周期 */
/* 5. 更新库libopencm3中定义的全局变量rcc_apb1_frequency=apb1_frequency=42000000，rcc_apb2_frequency=apb2_frequency=84000000 */
static inline void clock_init(void)
{
rcc_clock_setup_hse_3v3(&clock_setup);
}
8.2.2 clock_deinit函数
clock_deinit函数关闭时钟源，将所有内部时钟设置为重启后的初始状态，为飞控固件的运行提供良好的初始环境，主要操作如下：
- 开启内部高速时钟并等待其稳定
- 清除所有时钟配置
- 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI
- 恢复PLL配置寄存器为默认值
- 关闭HSE旁路功能
- 清除所有时钟中断
void clock_deinit(void)
{
/* 1. 开启内部高速时钟并等待其稳定 */
/* RCC_HSI：值4，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* rcc_osc_on：开启某内部时钟，操作寄存器RCC_CR。rcc_osc_on(RCC_HSI)操作HSION域（bit0），定义在libopencm3/lib/stm32/f4/rcc.c */
/* rcc_wait_for_osc_ready：等待某内部时钟稳定，读取寄存器RCC_CR。rcc_wait_for_osc_ready(RCC_HSI)读取HSIRDY（bit1），定义在libopencm3/lib/stm32/f4/rcc.c */
rcc_osc_on(RCC_HSI);
rcc_wait_for_osc_ready(RCC_HSI);
/* 2. 清除所有时钟配置 */
/* RCC_CFGR：时钟配置寄存器寄存器，libopencm3/include/libopencm3/stm32/f4/rcc.h */
RCC_CFGR = 0x000000;
/* 3. 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI */
/* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* RCC_PLL：值0，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* rcc_osc_off：关闭某内部时钟，操作寄存器RCC_CR。定义在libopencm3/lib/stm32/f4/rcc.c */
/* rcc_css_disable：关闭时钟安全系统，操作寄存器RCC_CR的域CSSON（bit19）。定义在libopencm3/lib/stm32/f4/rcc.c */
/* rcc_osc_off(RCC_HSE)操作HSEON域（bit16），rcc_osc_off(RCC_PLL)操作PLLON域（bit24）。定义在libopencm3/lib/stm32/f4/rcc.c */
rcc_osc_off(RCC_HSE);
rcc_osc_off(RCC_PLL);
rcc_css_disable();
/* 4. 恢复PLL配置寄存器为默认值 */
/* RCC_PLLCFGR：RCC PLL配置寄存器 */
RCC_PLLCFGR = 0x24003010;
/* 5. 关闭HSE旁路功能 */
/* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* rcc_osc_bypass_disable：关闭HSE的旁路功能，操作寄存器RCC_CR的HSEBYP域（bit18） */
rcc_osc_bypass_disable(RCC_HSE);
/* 6. 清除所有时钟中断 */
/* RCC_CIR：RCC时钟中断寄存器 */
RCC_CIR = 0x000000;
}
8.3 RTC备份寄存器操作函数
RTC备份寄存器操作函数board_get_rtc_signature和board_set_rtc_signature这两个函数都被定义在main_f4.c中。这两个函数分别用于获取和设置RTC_BKPxR的第一个32位寄存器（被定义为BOOT_RTC_REG）的值。
这里的源代码中有BUG，未选择时钟源，正确的操作应当是选择HSE并且分频系数为24，确保RTC时钟为1MHz。根据STM32f427芯片手册，访问RTC寄存器（含16个RTC_BKPxR寄存器组）的操作如下：
- 使能电源接口时钟(此步骤已在board_init函数中操作，这里可以省略)：寄存器RCC_APB1ENR的PWREN位（bit28）置1
- 取消写保护：寄存器PWR_CR的DBP位（bit8）置1，使寄存器RCC_BDCR、RTC寄存器（含RTC_BKPxR）和寄存器PWR_CSR的BRE位可写
- 选择RTC时钟源（BUG关键点，未选择时钟源）：设置寄存器RCC_BDCR的域RTCSEL(9:8)来选择RTC的时钟源（默认00:无，01:LSE，10:LSI，11:HSE+RTCPRE）；若选择HSE+RTCPRE，还需设置寄存器RCC_CFGR的域RTCPRE(20:16)来确定分频系数（默认00000:无，00001:无，00010:HSE/2，00011:HSE/3，……，11111:HSE/31）
- 使能RTC时钟源：寄存器RCC_BDCR的RTCEN位（bit15）置1
经过上述操作就可以访问RTC寄存器了。访问完毕之后，一般需反向操作关闭访问权限。
8.3.1 board_get_rtc_signature函数
main_f4.c
/* BOOT_RTC_REG：定义强制bootloader寄存器，地址为0x40002850，对应16个RTC_BKPxR的第一个32位寄存器，它们不受芯片重启reset影响 */
#define BOOT_RTC_REG MMIO32(RTC_BASE + 0x50)
static uint32_t board_get_rtc_signature()
{
/* 1. 修改相关寄存器选项，使BOOT_RTC_REG可以被访问 */
/* PWR_CR：能耗控制寄存器 */
/* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */
/* 芯片重启后，寄存器RCC_BDCR、RTC备份寄存器（如BOOT_RTC_REG）和寄存器PWR_CSR的BRE位都处于写保护状态，寄存器PWR_CR的bit8置1解除写保护 */
PWR_CR |= PWR_CR_DBP;
/* RCC_BDCR：备份域控制寄存器 */
/* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* 使能RTC时钟，BOOT_RTC_REG可以访问，还未选择时钟源？BUG？ */
RCC_BDCR |= RCC_BDCR_RTCEN;
/* 2. 读取BOOT_RTC_REG寄存器值 */
uint32_t result = BOOT_RTC_REG;
/* 3. 修改寄存器选项，禁止访问BOOT_RTC_REG */
/* RCC_BDCR：备份域控制寄存器 */
/* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* 这里应反向关闭RTC时钟，正确代码应该如下。源代码不但没有关闭RTC时钟，还会，BUG? */
/* RCC_BDCR &= ~RCC_BDCR_RTCEN */
RCC_BDCR &= RCC_BDCR_RTCEN;
/* PWR_CR：能耗控制寄存器 */
/* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */
/* 此句为RTC寄存器加上写保护 */
PWR_CR &= ~PWR_CR_DBP;
return result;
}
8.3.2 board_set_rtc_signature函数
main_f4.c
static void board_set_rtc_signature(uint32_t sig)
{
/* 1. 修改相关寄存器选项，使BOOT_RTC_REG可以被访问 */
/* PWR_CR：能耗控制寄存器 */
/* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */
/* 芯片重启后，寄存器RCC_BDCR、RTC备份寄存器（如BOOT_RTC_REG）和寄存器PWR_CSR的BRE位都处于写保护状态，寄存器PWR_CR的bit8置1解除写保护 */
PWR_CR |= PWR_CR_DBP;
/* RCC_BDCR：备份域控制寄存器 */
/* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* 使能RTC时钟，BOOT_RTC_REG可以访问，还未选择时钟源？BUG？ */
RCC_BDCR |= RCC_BDCR_RTCEN;
/* 2. 设置BOOT_RTC_REG寄存器值 */
BOOT_RTC_REG = sig;
/* 3. 修改寄存器选项，禁止访问BOOT_RTC_REG */
/* RCC_BDCR：备份域控制寄存器 */
/* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* 这里应反向关闭RTC时钟，正确代码应该如下。源代码不但没有关闭RTC时钟，还会，BUG? */
/* RCC_BDCR &= ~RCC_BDCR_RTCEN */
RCC_BDCR &= RCC_BDCR_RTCEN;
/* PWR_CR：能耗控制寄存器 */
/* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */
/* 此句为RTC寄存器加上写保护 */
PWR_CR &= ~PWR_CR_DBP;
}
8.4 flash操作函数
这里的flash操作是针对飞控固件部分flash的。
8.4.1 flash_func_read_word函数
flash_func_read_word函数返回飞控固件flash域内某地址的值，输入的地址值自动加上APP_LOAD_ADDRESS（0x08004000）。
main_f4.c
uint32_t flash_func_read_word(uint32_t address)
{
/* 若地址非4字节对齐，返回0 */
if (address & 3) {
return 0;
}
/* 否则返回地址为(address+APP_LOAD_ADDRESS)对应的值，这个地址在飞控固件内 */
/* APP_LOAD_ADDRESS：值0x08004000，定义在hw_config.h */
return *(uint32_t *)(address + APP_LOAD_ADDRESS);
}
8.4.2 flash_func_sector_size函数
flash_func_sector_size函数返回MCU的flash在某sector的大小值，若无此sector则返回0。
main_f4.c
/* BOARD_FLASH_SECTORS：STM32F4芯片若片内flash为1M，则Sector数量为11；若不为1M（2M），则Sector数量为23，定义在hw_config.h */
/* flash_sectors：结构体全局变量，表示flash内部各sector的size分布，定义在main_f4.c */
uint32_t flash_func_sector_size(unsigned sector)
{
if (sector < BOARD_FLASH_SECTORS) {
return flash_sectors[sector].size;
}
return 0;
}
8.4.3 flash_func_erase_sector函数
flash_func_erase_sector函数用于擦除指定的sector。根据当前段中有无有效数据而被擦写，若有就擦写；若无有效数据（全为0xFFFFFFFF），则不用擦写。
void flash_func_erase_sector(unsigned sector)
{
/* 判定输入参数sector是否合法，若不合法直接返回 */
/* BOARD_FLASH_SECTORS：STM32F4芯片若片内flash为1M，则Sector数量为11；若不为1M（2M），则Sector数量为23，定义在hw_config.h */
/* BOARD_FIRST_FLASH_SECTOR_TO_ERASE：值0，定义在hw_config.h */
if (sector >= BOARD_FLASH_SECTORS || sector < BOARD_FIRST_FLASH_SECTOR_TO_ERASE) {
return;
}
/* 计算当前sector相对于APP_LOAD_ADDRESS（0x08004000）的相对地址（即逻辑地址） */
/* BOARD_FIRST_FLASH_SECTOR_TO_ERASE：值0，定义在hw_config.h */
/* flash_func_sector_size：函数返回MCU的flash在某sector的大小值，若无此sector则返回0，定义在main_f4.c */
uint32_t address = 0;
for (unsigned i = BOARD_FIRST_FLASH_SECTOR_TO_ERASE; i < sector; i++) {
address += flash_func_sector_size(i);
}
/* 获取当前段的大小，扫描当前段的内容，若存在不为0xffffffff的非空字节，说明本段内容不为空；置blank变量为假，表示本段写入过数据，应被擦写。 */
/* flash_func_sector_size：函数返回MCU的flash在某sector的大小值，若无此sector则返回0，定义在main_f4.c */
/* blank：当前段是否为空的标记 */
unsigned size = flash_func_sector_size(sector);
bool blank = true;
/* flash_func_read_word：函数返回飞控固件flash域内某地址的值，输入的地址值自动加上APP_LOAD_ADDRESS（0x08004000），定义在main_f4.c */
for (unsigned i = 0; i < size; i += sizeof(uint32_t)) {
if (flash_func_read_word(address + i) != 0xffffffff) {
blank = false;
break;
}
}
/* 根据blank的取值进行标记确定是否擦除当前段 */
/* blank：当前段是否为空的标记 */
/* FLASH_CR_PROGRAM_X32：值2，表示flash写入的并行度为32位，定义在libopencm3/include/libopencm3/stm32/common/flash_common_f24.h */
/* flash_erase_sector：擦除某段的库函数，定义在libopencm3/lib/stm32/common/flash_common_f24.c */
if (!blank) {
flash_erase_sector(flash_sectors[sector].sector_number, FLASH_CR_PROGRAM_X32);
}
}
8.4.4 flash_func_write_word函数
flash_func_write_word函数用于编写特定地址的flash，以4字节编写，输入地址自动加上APP_LOAD_ADDRESS（0x08004000）。
main_f4.c
void flash_func_write_word(uint32_t address, uint32_t word)
{
/* flash_program_word：在某地址编写flash字的库函数，定义在libopencm3/lib/stm32/common/flash_common_f24.c */
flash_program_word(address + APP_LOAD_ADDRESS, word);
}
8.4.5 flash_func_read_otp函数
flash_func_read_otp函数读取OTP区的一个字，输入地址为相对地址（相对于OTP区基地址）。
main_f4.c
#define OTP_BASE 0x1fff7800 /* OTP区基地址 */
#define OTP_SIZE 512 /* OTP区大小 */
uint32_t flash_func_read_otp(uint32_t address)
{
/* 若给定地址不是4字节对齐或者超出OTP区的范围，返回0 */
/* OTP_SIZE：值512，OTP区的大小（byte），定义在main_f4.c */
/* OTP_BASE：值0x1fff7800，OTP区基地址，定义在main_f4.c */
if (address & 3) {
return 0;
}
if (address > OTP_SIZE) {
return 0;
}
return *(uint32_t *)(address + OTP_BASE);
}
8.4.6 flash_func_read_sn函数
flash_func_read_sn函数读取MCU的UDID（Unique Device ID）某字（共12byte，3字）。
main_f4.c
#define UDID_START 0x1FFF7A10 /* UDID_START：UDID寄存器基地址，值0x1FFF7A10，定义在main_f4.c */
uint32_t flash_func_read_sn(uint32_t address)
{
return *(uint32_t *)(address + UDID_START);
}
8.5 board_test_usart_receiving_break函数
board_test_usart_receiving_break没有使用USART控制器来接收信息，而是使用systick时钟来软件模拟串口的接收。程序看起来复杂，实质非常简单。它的功能就是：连续接收3个字节的内容，如果收到一个0字节则返回真，否则返回假。break字符为字节0。
main_f4.c
static bool board_test_usart_receiving_break()
{
#if !defined(SERIAL_BREAK_DETECT_DISABLED) /* 宏SERIAL_BREAK_DETECT_DISABLED未定义，下列代码有效 */
/* 启动systick定时器 */
systick_interrupt_disable(); /* 关闭systick中断（libopencm3/lib/cm3/systick.c） */
systick_counter_disable(); /* systick倒计时关闭（libopencm3/lib/cm3/systick.c） */
systick_set_clocksource(STK_CSR_CLKSOURCE_AHB); /* 选取AHB作为systick的时钟源，STK_CSR_CLKSOURCE_AHB=1<<2（libopencm3/include/libopencm3/cm3/systick.h） */
/* board_info.systick_mhz：值168，定义在main_f4.c */
/* USART_BAUDRATE：值115200，定义在hw_config.h */
/* 设置systick时钟倒计时（寄存器STK_VAL）约为729，为串口波特率的一半 */
systick_set_reload(((board_info.systick_mhz * 1000000) / USART_BAUDRATE) >> 1);
systick_counter_enable(); /* systick倒计时开启（libopencm3/lib/cm3/systick.c) */
uint8_t cnt_consecutive_low = 0;
uint8_t cnt = 0;
/* 检测连续3个字节，若有1个字节值为0，则跳出循环。每个传播周期包含10位（1起始+8数据+1停止）。 */
while (cnt < 60) {
/* BOARD_PORT_USART：值GPIOD，定义在hw_config.h */
/* BOARD_PIN_RX：值GPIO6，定义在hw_config.h */
/* systick_get_countflag：定义在libopencm3/lib/cm3/systick.c，当systick倒计时为0时返回1，否则返回0。库中定义的寄存器STK_CSR即为寄存器STK_CTRL */
/* gpio_get：定义在libopencm3/lib/stm32/common/gpio_common_all.c，功能为获取某GPIO组的值 */
if (systick_get_countflag() == 1) {
if (gpio_get(BOARD_PORT_USART, BOARD_PIN_RX) == 0) {
cnt_consecutive_low++; // Increment the consecutive low counter
} else {
cnt_consecutive_low = 0; // Reset the consecutive low counter
}
cnt++;
}
// 若连续收到9个低电平（1起始+8数据），即一个字节0，则跳出循环
if (cnt_consecutive_low >= 18) {
break;
}
}
systick_counter_disable(); /* systick倒计时关闭（libopencm3/lib/cm3/systick.c） */
/* 如果检测到9个低电平（1起始+8数据），则返回真，否则返回假 */
if (cnt_consecutive_low >= 18) {
return true;
}
#endif // !defined(SERIAL_BREAK_DETECT_DISABLED)
return false;
}
8.6 LED操作函数
LED操作函数包含点亮led_on、熄灭led_off和反向led_toggle三个函数。
8.6.1 led_on函数
main_f4.c
void led_on(unsigned led)
{
/* LED_ACTIVITY：值1，定义在bl.h */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* BOARD_PORT_LEDS：值GPIOE（指向GPIOE首寄存器），定义在hw_config.h */
/* BOARD_PIN_LED_ACTIVITY：值0，无此LED，定义在hw_config.h */
/* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<12），定义在hw_config.h */
/* BOARD_LED_ON：被hw_config.h定义为gpio_clear函数,功能为置某GPIO组中的引脚输出为低电平（libopencm3/lib/stm32/common/gpio_common_all.c） */
switch (led) {
case LED_ACTIVITY:
BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
break;
case LED_BOOTLOADER:
BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
break;
}
}
8.6.2 led_off函数
main_f4.c
void led_off(unsigned led)
{
/* LED_ACTIVITY：值1，定义在bl.h */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* BOARD_PORT_LEDS：值GPIOE（指向GPIOE首寄存器），定义在hw_config.h */
/* BOARD_PIN_LED_ACTIVITY：值0，无此LED，定义在hw_config.h */
/* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<12），定义在hw_config.h */
/* BOARD_LED_OFF：被hw_config.h定义为gpio_set函数,功能为置某GPIO组中的引脚输出为高电平（libopencm3/lib/stm32/common/gpio_common_all.c） */
switch (led) {
case LED_ACTIVITY:
BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
break;
case LED_BOOTLOADER:
BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
break;
}
}
8.6.3 led_toggle函数
main_f4.c
/* LED_ACTIVITY：值1，定义在bl.h */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* BOARD_PORT_LEDS：值GPIOE（指向GPIOE首寄存器），定义在hw_config.h */
/* BOARD_PIN_LED_ACTIVITY：值0，无此LED，定义在hw_config.h */
/* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<12），定义在hw_config.h */
/* gpio_toggle：反向函数，定义在libopencm3/lib/stm32/common/gpio_common_all.c */
void led_toggle(unsigned led)
{
switch (led) {
case LED_ACTIVITY:
gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
break;
case LED_BOOTLOADER:
gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
break;
}
}
8.7 获取芯片信息函数
获取芯片信息函数包括：get_mcu_id函数取包含芯片ID和版本的寄存器DBGMCU_IDCODE值，get_mcu_desc函数返回MCU的型号和版本描述信息。
8.7.1 get_mcu_id函数
get_mcu_id函数读取包含芯片ID和版本的寄存器DBGMCU_IDCODE值。
main_f4.c
#define DBGMCU_IDCODE 0xE0042000 /* DBGMCU_IDCODE，寄存器，存放芯片ID和版本信息 */
uint32_t get_mcu_id(void)
{
return *(uint32_t *)DBGMCU_IDCODE;
}
8.7.2 get_mcu_desc函数
get_mcu_desc函数返回MCU的型号和版本描述信息。
main_f4.c
#define DBGMCU_IDCODE 0xE0042000 /* DBGMCU_IDCODE，寄存器，存放芯片ID和版本信息 */
#define DEVID_MASK 0xFFF /* MCU的ID存放在DBGMCU_IDCODE寄存器的低12位 */
#define STM32_UNKNOWN 0 /* 未知芯片描述的index */
int get_mcu_desc(int max, uint8_t *revstr)
{
/* 获取MCU的ID和版本，分别存放在变量mcuid和revid中 */
uint32_t idcode = (*(uint32_t *)DBGMCU_IDCODE);
int32_t mcuid = idcode & DEVID_MASK;
mcu_rev_e revid = (idcode & REVID_MASK) >> 16;
/* 初始化MCU描述信息为未知 */
mcu_des_t des = mcu_descriptions[STM32_UNKNOWN];
/* 根据mcuid依次查找数组mcu_descriptions中匹配项，若匹配则找到该MCU的型号描述 */
/* mcu_descriptions：mcu_des_t型数组，用于存放MCU的型号描述信息，定义在main_f4.c */
/* arraySize：以宏形式定义的函数，用于计算数组的成员个数，定义在bl.h */
for (int i = 0; i < arraySize(mcu_descriptions); i++) {
if (mcuid == mcu_descriptions[i].mcuid) {
des = mcu_descriptions[i];
break;
}
}
/* 根据revid依次查找数组mcu_descriptions中匹配项，若匹配则找到该MCU的版本 */
/* silicon_revs：mcu_rev_t型数组，用于存放MCU版本信息，定义在main_f4.c */
/* arraySize：以宏形式定义的函数，用于计算数组的成员个数，定义在bl.h */
for (int i = 0; i < arraySize(silicon_revs); i++) {
if (silicon_revs[i].revid == revid) {
des.rev = silicon_revs[i].rev;
}
}
/* 按位字符操作，将MCU的描述和版本信息存储到缓冲区，中间用“,”隔开 */
uint8_t *endp = &revstr[max - 1];
uint8_t *strp = revstr;
while (strp < endp && *des.desc) {
*strp++ = *des.desc++;
}
if (strp < endp) {
*strp++ = ',';
}
if (strp < endp) {
*strp++ = des.rev;
}
return strp - revstr;
}
8.8 check_silicon函数
check_silicon函数自动辨识运新的MCU版本是否为FIRST_BAD_SILICON_OFFSET序号以后的silicon_revs（mcu_rev_t型结构体数组）成员。在不改变代码的情况下，STM32F427型芯片REV_ID为0x2001时（Revision 3）返回0，其余均返回-1。
main_f4.c
int check_silicon(void)
{
#if defined(TARGET_HW_PX4_FMU_V2) || defined(TARGET_HW_PX4_FMU_V4) /* 定义了宏TARGET_HW_PX4_FMU_V2，因此下列代码有效，将被编译。 */
/* 宏DBGMCU_IDCODE被定义在main_f4.c中，代表地址为0xE0042000的寄存器。变量idcode包含信息REV_ID(31:16)和DEV_ID(11:0) */
uint32_t idcode = (*(uint32_t *)DBGMCU_IDCODE);
/* 宏REVID_MASK被定义在main_f4.c中，值为0xFFFF0000。变量revid为REV_ID的值 */
mcu_rev_e revid = (idcode & REVID_MASK) >> 16;
/* 宏FIRST_BAD_SILICON_OFFSET被main_f4.c定义为1，代表第1块sector（从0开始编号） */
/* 变量silicon_revs为mcu_rev_t型结构体数组，存储MCU版本号与其代码的对应信息 */
/* 以宏形式定义的函数arraySize()在bl.h中，其功能为求解数组的成员个数 */
/* 此循环的功能是，若使用自FIRST_BAD_SILICON_OFFSET序号以后的MCU版本（REV_ID），则函数返回-1，否则返回0 */
for (int i = FIRST_BAD_SILICON_OFFSET; i < arraySize(silicon_revs); i++) {
if (silicon_revs[i].revid == revid) {
return -1;
}
}
#endif
return 0;
}
9 IO协处理器主线流程调用的函数
本节汇总了被主控FMU主线程序（main、jump_to_app和bootloader）调用的函数。
9.1 板载初始化相关函数
板载初始化相关函数包括board_init和反向初始化函数board_deinit，它们分别被main函数和jump_to_app函数调用。
9.1.1 board_init函数
board_init函数主要的功能如下：
- 初始化LED控制并点亮LED灯
- 设置强制Bootloader引脚GPIOB5为浮动输入模式，方便采集安全开关的状态
- 使能能源接口时钟和备份接口时钟，准备备份寄存器
- 设置USART2-TX引脚GPIOA2，对应原理图SERIAL_IO_TO_FMU，用于IO协处理器发送信息到主控FMU
main_f1.c
static void board_init(void)
{
/* 1. 初始化LED控制并点亮LED灯 */
/* 根据原理图，GPIOB14（IO-LED_BLUE）和GPIOB15（IO-LED_AMBER）分别控制IO协处理器的B/E（LED703）和ACT（LED705），低电平有效 */
/* BOARD_CLOCK_LEDS_REGISTER：被定义为寄存器RCC_APB2ENR，hw_config.h */
/* BOARD_CLOCK_LEDS：被hw_config.h定义为RCC_APB2ENR_IOPBEN，值1<<3（bit3），定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* BOARD_PORT_LEDS：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */
/* GPIO_MODE_OUTPUT_50_MHZ：值0x03，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* GPIO_CNF_OUTPUT_PUSHPULL：值0x00，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_PIN_LED_BOOTLOADER：被定义为GPIO15，值1<<15，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
/* BOARD_PIN_LED_ACTIVITY：被定义为GPIO14，值1<<14，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
/* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* gpio_set_mode：设置GPIO引脚工作模式，定义在libopencm3/lib/stm32/f1/gpio.c */
/* BOARD_LED_ON：被hw_config.h定义为gpio_clear（libopencm3/lib/stm32/common/gpio_common_all.c） */
/* 第一行，启动GPIOB时钟，通过操作RCC_APB2ENR寄存器的域IOPBEN（bit3） */
/* 第二行，设置GPIOB14和GPIOB15为最大频率50MHz输出（MODE=GPIO_MODE_OUTPUT_50_MHZ=11），push-pull模式（CNF=GPIO_CNF_OUTPUT_PUSHPULL=00） */
/* 第三行，设置GPIOB13和GPIOB15为低电平，点亮两个LED灯 */
rcc_peripheral_enable_clock(&BOARD_CLOCK_LEDS_REGISTER, BOARD_CLOCK_LEDS);
gpio_set_mode(BOARD_PORT_LEDS, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
/* if we have one, enable the force-bootloader pin */
#ifdef BOARD_FORCE_BL_PIN /* 宏BOARD_FORCE_BL_PIN有定义，代码有效 */
/* 2. 设置强制Bootloader引脚GPIOB5为浮动输入模式，方便采集安全开关的状态 */
/* 根据原理图，GPIOB5（IO-LED_SAFETY）连接安全开关，程序默认设置为高电平。采集到安全开关闭合（电平拉低）有效 */
/* BOARD_FORCE_BL_CLOCK_REGISTER：被定义为寄存器RCC_APB2ENR，hw_config.h */
/* BOARD_FORCE_BL_CLOCK_BIT：被hw_config.h定义为RCC_APB2ENR_IOPBEN，值1<<3（bit3），定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* BOARD_FORCE_BL_PORT：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */
/* BOARD_FORCE_BL_PIN：被定义为GPIO5，值1<<5，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
/* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_FORCE_BL_PULL：被hw_config.h定义为GPIO_CNF_INPUT_FLOAT，值0x01，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* gpio_set：设置GPIO引脚电平，置1（set位），定义在libopencm3/lib/stm32/common/gpio_common_all.c */
/* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */
/* 第一行，启动GPIOB时钟，通过操作RCC_APB2ENR寄存器的域IOPBEN（bit3） */
/* 第二行，设置GPIOB5（IO-LED_SAFETY）为高电平 */
/* 第三行，设置GPIOB5（IO-LED_SAFETY）为输入模式（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=BOARD_FORCE_BL_PULL=01） */
rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT);
gpio_set(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN);
gpio_set_mode(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN);
#endif
/* 3. 使能能源接口时钟和备份接口时钟，准备备份寄存器 */
/* RCC_APB1ENR：APB1寄存器，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* RCC_APB1ENR_PWREN：值1<<28，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* RCC_APB1ENR_BKPEN：值1<<27，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN);
#ifdef INTERFACE_USART /* 宏INTERFACE_USART定义为USART2，hw_config.h，代码有效 */
/* 4. 设置USART2-TX引脚GPIOA2，对应原理图SERIAL_IO_TO_FMU，用于IO协处理器发送信息到主控FMU */
/* BOARD_USART_PIN_CLOCK_REGISTER：被定义为寄存器RCC_APB2ENR，hw_config.h */
/* BOARD_USART_PIN_CLOCK_BIT：被hw_config.h定义为RCC_APB2ENR_IOPAEN，值1<<2（bit2，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h） */
/* BOARD_PORT_USART：被定义为GPIOA（GPIOA寄存器首地址0x40010800），hw_config.h */
/* GPIO_MODE_OUTPUT_50_MHZ：值0x03，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* GPIO_CNF_OUTPUT_ALTFN_PUSHPULL：值0x02，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_PIN_TX：被hw_config.h定义为GPIO_USART2_TX，值GPIO2（1<<2），libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_USART_CLOCK_REGISTER：被定义为寄存器RCC_APB1ENR，hw_config.h */
/* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17，libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */
/* 第一行，使能USART2所在的GPIOA时钟 */
/* 第二行，设置USART2的发送引脚GPIOA2为50MHz输出模式（MODE=GPIO_MODE_OUTPUT_50_MHZ=11），特殊功能push-pull模式（CNF=GPIO_CNF_OUTPUT_ALTFN_PUSHPULL=10） */
/* 第三行，重置USART2时钟 */
rcc_peripheral_enable_clock(&BOARD_USART_PIN_CLOCK_REGISTER, BOARD_USART_PIN_CLOCK_BIT);
gpio_set_mode(BOARD_PORT_USART, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, BOARD_PIN_TX);
rcc_peripheral_enable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif
#ifdef INTERFACE_I2C /* 宏INTERFACE_I2C未定义，代码无效 */
# error I2C GPIO config not handled yet
#endif
}
9.1.2 board_deinit函数
board_deinit函数用于板载设备的反向初始化，主要的功能如下：
- 无效化LED控制引脚GPIOB14和GPIOB15
- 无效化强制Bootloader引脚GPIOB5
- 关闭能源接口时钟和备份接口时钟，不可访问备份寄存器
- 无效化USART2-TX引脚GPIOA2
- 设置APB2寄存器为默认值，关闭所有外部时钟
main_f1.c
void board_deinit(void)
{
/* 1. 无效化LED控制引脚GPIOB14和GPIOB15 */
/* 根据原理图，GPIOB14（IO-LED_BLUE）和GPIOB15（IO-LED_AMBER）分别控制IO协处理器的B/E（LED703）和ACT（LED705），低电平有效 */
/* BOARD_PORT_LEDS：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */
/* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* GPIO_CNF_INPUT_FLOAT：值0x01，libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_PIN_LED_BOOTLOADER：被定义为GPIO15，值1<<15，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
/* BOARD_PIN_LED_ACTIVITY：被定义为GPIO14，值1<<14，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
/* gpio_set_mode：设置GPIO引脚工作模式，定义在libopencm3/lib/stm32/f1/gpio.c */
/* 设置GPIOB14和GPIOB15为输入模式（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=GPIO_CNF_INPUT_FLOAT=01） */
gpio_set_mode(BOARD_PORT_LEDS, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
#ifdef BOARD_FORCE_BL_PIN /* 宏BOARD_FORCE_BL_PIN定义为GPIO5，代码有效，hw_config.h */
/* 2. 无效化强制Bootloader引脚GPIOB5 */
/* BOARD_FORCE_BL_PORT：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */
/* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* GPIO_CNF_INPUT_FLOAT：值0x01，libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_FORCE_BL_PIN：被定义为GPIO5，值1<<5，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
/* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */
/* gpio_clear：设置GPIO引脚电平，清0（reset位），定义在libopencm3/lib/stm32/common/gpio_common_all.c */
/* 第一行，设置GPIOB5（IO-LED_SAFETY）为输入模式（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=BOARD_FORCE_BL_PULL=01） */
/* 第二行，设置GPIOB5（IO-LED_SAFETY）为低电平 */
gpio_set_mode(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_FORCE_BL_PIN);
gpio_clear(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN);
#endif
/* 3. 关闭能源接口时钟和备份接口时钟，不可访问备份寄存器 */
/* RCC_APB1ENR：APB1寄存器，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* RCC_APB1ENR_PWREN：值1<<28，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* RCC_APB1ENR_BKPEN：值1<<27，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */
rcc_peripheral_disable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN);
#ifdef INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效 */
/* 4. 无效化USART2-TX引脚GPIOA2 */
/* BOARD_PORT_USART：被定义为GPIOA（GPIOA寄存器首地址0x40010800），hw_config.h */
/* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* GPIO_CNF_INPUT_FLOAT：值0x01，libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_PIN_TX：被hw_config.h定义为GPIO_USART2_TX，值GPIO2（1<<2），libopencm3/include/libopencm3/stm32/f1/gpio.h */
/* BOARD_USART_CLOCK_REGISTER：被定义为寄存器RCC_APB1ENR，hw_config.h */
/* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17，libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */
/* 第一行，设置USART2的发送引脚GPIOA2为输入（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=GPIO_CNF_INPUT_FLOAT=01） */
/* 第二行，关闭USART2时钟 */
gpio_set_mode(BOARD_PORT_USART, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_PIN_TX);
rcc_peripheral_disable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif
#ifdef INTERFACE_I2C /* 宏INTERFACE_I2C未定义，代码无效 */
# error I2C GPIO config not handled yet
#endif
/* 5. 设置APB2寄存器为默认值，关闭所有外部时钟 */
/* RCC_APB2ENR：寄存器，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
RCC_APB2ENR = 0x00000000; // XXX Magic reset number from STM32F1x reference manual
}
9.2 时钟初始化相关函数
板载初始化相关函数包括clock_init和反向初始化函数clock_deinit，它们分别被main函数和jump_to_app函数调用。
9.2.1 clock_init函数
clock_init函数调用库函数，使用HSI将MCU的系统时钟为PLL，频率48MHz（BUG？应该设置为24MHz，对应board_info.systick_mhz）。
main_f1.c
static inline void clock_init(void)
{
#if defined(INTERFACE_USB) /* 宏INTERFACE_USB定义为0，代码有效 */
/* rcc_clock_setup_in_hsi_out_48mhz：使用HSI设置MCU的系统时钟为PLL，48MHz，定义在libopencm3/lib/stm32/f1/rcc.c */
rcc_clock_setup_in_hsi_out_48mhz();
#else
rcc_clock_setup_in_hsi_out_24mhz();
#endif
}
9.2.2 clock_deinit函数
clock_deinit函数关闭时钟源，将所有内部时钟设置为重启后的初始状态，为飞控固件的运行提供良好的初始环境，主要操作如下：
- 使能HSI时钟
- 重置寄存器RCC_CFGR，清空时钟配置
- 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI
- 关闭HSE旁路功能
- 清除所有时钟中断
main_f1.c
void clock_deinit(void)
{
/* 1. 使能HSI时钟 */
/* RCC_HSI：值4，rcc_osc枚举型，libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* rcc_osc_on：开启某内部时钟，操作寄存器RCC_CR。rcc_osc_on(RCC_HSI)操作HSION域（bit0），定义在libopencm3/lib/stm32/f1/rcc.c */
/* rcc_wait_for_osc_ready：等待某内部时钟稳定，读取寄存器RCC_CR。rcc_wait_for_osc_ready(RCC_HSI)读取HSIRDY（bit1），定义在libopencm3/lib/stm32/f1/rcc.c */
rcc_osc_on(RCC_HSI);
rcc_wait_for_osc_ready(RCC_HSI);
/* 2. 重置寄存器RCC_CFGR，清空时钟配置 */
/* RCC_CFGR：寄存器，libopencm3/include/libopencm3/stm32/f1/rcc.h */
RCC_CFGR = 0x000000;
/* 3. 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI */
/* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* RCC_PLL：值0，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
/* rcc_osc_off：关闭某内部时钟，操作寄存器RCC_CR。定义在libopencm3/lib/stm32/f1/rcc.c */
/* rcc_css_disable：关闭时钟安全系统，操作寄存器RCC_CR的域CSSON（bit19）。定义在libopencm3/lib/stm32/f1/rcc.c */
/* rcc_osc_off(RCC_HSE)操作HSEON域（bit16），rcc_osc_off(RCC_PLL)操作PLLON域（bit24）。定义在libopencm3/lib/stm32/f1/rcc.c */
/* Stop the HSE, CSS, PLL, PLLI2S, PLLSAI */
rcc_osc_off(RCC_HSE);
rcc_osc_off(RCC_PLL);
rcc_css_disable();
/* 4. 关闭HSE旁路功能 */
/* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* rcc_osc_bypass_disable：关闭HSE的旁路功能，操作寄存器RCC_CR的HSEBYP域（bit18） */
rcc_osc_bypass_disable(RCC_HSE);
/* 5. 清除所有时钟中断 */
/* RCC_CIR：RCC时钟中断寄存器 */
RCC_CIR = 0x000000;
}
9.3 LED操作函数
LED操作函数包含点亮led_on、熄灭led_off和反向led_toggle三个函数。
9.3.1 led_on函数
main_f1.c
void led_on(unsigned led)
{
/* LED_ACTIVITY：值1，定义在bl.h */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* BOARD_PORT_LEDS：值GPIOB（指向GPIOB首寄存器），定义在hw_config.h */
/* BOARD_PIN_LED_ACTIVITY：值GPIO14（1<<14），定义在hw_config.h */
/* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<15），定义在hw_config.h */
/* BOARD_LED_ON：被hw_config.h定义为gpio_clear函数,功能为置某GPIO组中的引脚输出为低电平（libopencm3/lib/stm32/common/gpio_common_all.c） */
switch (led) {
case LED_ACTIVITY:
BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
break;
case LED_BOOTLOADER:
BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
break;
}
}
9.3.2 led_off函数
main_f1.c
void led_off(unsigned led)
{
/* LED_ACTIVITY：值1，定义在bl.h */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* BOARD_PORT_LEDS：值GPIOB（指向GPIOB首寄存器），定义在hw_config.h */
/* BOARD_PIN_LED_ACTIVITY：值GPIO14（1<<14），定义在hw_config.h */
/* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<15），定义在hw_config.h */
/* BOARD_LED_OFF：被hw_config.h定义为gpio_set函数,功能为置某GPIO组中的引脚输出为高电平（libopencm3/lib/stm32/common/gpio_common_all.c） */
switch (led) {
case LED_ACTIVITY:
BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
break;
case LED_BOOTLOADER:
BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
break;
}
}
9.3.3 led_off函数
void led_toggle(unsigned led)
{
/* LED_ACTIVITY：值1，定义在bl.h */
/* LED_BOOTLOADER：值2，定义在bl.h */
/* BOARD_PORT_LEDS：值GPIOB（指向GPIOB首寄存器），定义在hw_config.h */
/* BOARD_PIN_LED_ACTIVITY：值GPIO14（1<<14），定义在hw_config.h */
/* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<15），定义在hw_config.h */
/* gpio_toggle：反向函数，定义在libopencm3/lib/sam/common/gpio_common_all.c */
switch (led) {
case LED_ACTIVITY:
gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
break;
case LED_BOOTLOADER:
gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
break;
}
}
9.4 flash操作函数
这里的flash操作是针对飞控固件部分flash的。
9.4.1 flash_func_read_word函数
flash_func_read_word函数返回飞控固件flash域内某地址的值，输入的地址值需加上APP_LOAD_ADDRESS（0x08001000）。
main_f1.c
uint32_t flash_func_read_word(uint32_t address)
{
/* APP_LOAD_ADDRESS：值0x08001000，定义在hw_config.h */
return *(uint32_t *)(address + APP_LOAD_ADDRESS);
}
9.4.2 flash_func_sector_size函数
flash_func_sector_size函数返回MCU的flash在某sector的大小值，若无此sector，则返回0。对于STM32F1芯片，片内以页计算，无sector概念，故这里的sector表示页。
main_f1.c
/* BOARD_FLASH_SECTORS：STM32F1片内flash页数，Bootloader认为片内flash的前60页有效，定义在hw_config.h */
/* FLASH_SECTOR_SIZE：STM32F1片内flash每页大小为1KB，定义在hw_config.h */
uint32_t flash_func_sector_size(unsigned sector)
{
if (sector < BOARD_FLASH_SECTORS) {
return FLASH_SECTOR_SIZE;
}
return 0;
}
9.4.3 flash_func_erase_sector函数
flash_func_erase_sector函数擦除当前页。
main_f1.c
void flash_func_erase_sector(unsigned sector)
{
/* BOARD_FLASH_SECTORS：值60，表示MCU中flash的页数，定义在hw_config.h */
/* APP_LOAD_ADDRESS：值0x08001000，表示飞控固件起始地址，定义在hw_config.h */
/* FLASH_SECTOR_SIZE：值0x400，表示MCU中每页flash的大小均为1KB，定义在hw_config.h */
/* flash_erase_page：库函数擦写当前地址所在的页，定义在libopencm3/lib/stm32/f1/flash.c */
if (sector < BOARD_FLASH_SECTORS) {
flash_erase_page(APP_LOAD_ADDRESS + (sector * FLASH_SECTOR_SIZE));
}
}
9.4.4 flash_func_write_word函数
flash_func_write_word函数用于编写特定地址的flash，以4字节编写，输入地址自动加上APP_LOAD_ADDRESS（0x08004000）。
main_f1.c
void flash_func_write_word(uint32_t address, uint32_t word)
{
/* flash_program_word：在某地址编写flash字的库函数，定义在libopencm3/lib/stm32/common/flash_common_f01.c */
flash_program_word(address + APP_LOAD_ADDRESS, word);
}
9.4.5 flash_func_read_otp函数
STM32F1芯片无OTP区，函数直接返回0。
main_f1.c
uint32_t flash_func_read_otp(uint32_t address)
{
return 0;
}
9.4.6 flash_func_read_sn函数
flash_func_read_sn函数读取MCU的UDID（Unique Device ID）某字（共12byte，3字）。
main_f1.c
#define UDID_START 0x1FFFF7E8 /* UDID_START：UDID寄存器基地址，值0x1FFFF7E8，定义在main_f1.c */
uint32_t flash_func_read_sn(uint32_t address)
{
return *(uint32_t *)(address + UDID_START);
}
9.5 获取芯片信息函数
9.5.1 get_mcu_id函数
get_mcu_id函数读取包含芯片ID和版本的寄存器DBGMCU_IDCODE值。
main_f1.c
#define DBGMCU_IDCODE 0xE0042000 /* DBGMCU_IDCODE：寄存器，存放芯片ID和版本信息 */
uint32_t get_mcu_id(void)
{
return *(uint32_t *)DBGMCU_IDCODE;
}
9.5.2 get_mcu_desc函数
get_mcu_desc函数直接返回MCU型号描述和版本信息，为固定值"STM32F1xxx,?"
main_f1.c
int get_mcu_desc(int max, uint8_t *revstr)
{
const char none[] = "STM32F1xxx,?";
int i;
for (i = 0; none[i] && i < max - 1; i++) {
revstr[i] = none[i];
}
return i;
}
9.6 should_wait函数
should_wait函数被main函数调用，判定RTC备份寄存器BKP_DR1中是否存储了预定值，如果存储了就返回真，否则返回假。
main_f1.c
static bool should_wait(void)
{
bool result = false; /* 默认返回假 */
/* 打开RTC备份寄存器访问 */
/* PWR_CR：功率控制寄存器，定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
/* PWR_CR_DBP：值1<<8（bit8），定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
PWR_CR |= PWR_CR_DBP;
/* 若RTC备份寄存器BKP_DR1的值等于预定值0x19710317，则返回真且清零寄存器 */
/* BKP_DR1：RTC备份寄存器1，定义在libopencm3/include/libopencm3/stm32/f1/bkp.h */
/* BL_WAIT_MAGIC：值0x19710317，定义在bl.h */
if (BKP_DR1 == BL_WAIT_MAGIC) {
result = true;
BKP_DR1 = 0;
}
/* 关闭RTC备份寄存器访问 */
/* PWR_CR：功率控制寄存器，定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
/* PWR_CR_DBP：值1<<8（bit8），定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
PWR_CR &= ~PWR_CR_DBP;
return result;
}
10 串口和USB虚拟串口函数
串口和USB虚拟串口用于PX4 Bootloader与上位机的通信，可用于固件烧写和程序调试。除此之外，本节还包括对应的反初始化函数，它们被jump_to_app函数调用，使Bootloader放弃串口的控制权。
10.1 串口和USB虚拟串口初始化相关函数
串口和USB虚拟串口初始化包括cinit、uart_cinit和usb_cinit共3个函数
10.1.1 cinit函数
cinit函数是串口和USB虚拟串口初始化的主要函数，初始化后Bootloader可与上位机的通信接口，根据输入命令对Bootloader进行调试。cinit函数根据输入interface的值决定具体调用的初始化函数；uart_cinit用于初始化串口，usb_cinit用于初始化USB接口。
bl.c
/* USART：值为1，枚举类，定义在bl.h */
/* USB：值为2，枚举类，定义在bl.h */
inline void cinit(void *config, uint8_t interface)
{
#if INTERFACE_USB /* 主控FMU：宏INTERFACE_USB值为1，代码有效，定义在hw_config.h */
/* IO协处理器：宏INTERFACE_USB值为0，代码无效，定义在hw_config.h */
if (interface == USB) {
return usb_cinit();
}
#endif
#if INTERFACE_USART /* 宏INTERFACE_USART值为1，代码有效，定义在hw_config.h */
if (interface == USART) {
return uart_cinit(config);
}
#endif
}
10.1.2 uart_cinit函数
usart初始化函数uart_cinit，输入参数config为void*型指针，值为USART寄存器基地址。此函数使用SOC上的串口寄存器进行设置，功能为115200@8N1，收发通信，无硬件流控制。在pixahwk V2硬件和PX4代码使用USART作为上位机通信串口，config值USART2的寄存器基地址（0x40004400）。
usart.c
uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */
void uart_cinit(void *config)
{
/* 全局变量usart指向串口寄存器基地址 */
usart = (uint32_t)config;
/* 引脚和时钟初始化 */
/* USART_CR1：根据给定的USART寄存器首地址移位0x0c来获取寄存器USART_CR1。 */
/* 寄存器USART_CR1的bit15为OVER8域，控制串口的过采样模式。默认值0：16次过采样，值1：8次过采样。 */
//USART_CR1(usart) |= (1 << 15); /* libopencm3不支持USART_CR1寄存器的OVER8位操作 */
/* USART_BAUDRATE：值115200，定义在hw_config.h */
/* usart_set_baudrate：用于设置串口波特率，操作寄存器USART_BRR，定义在libopencm3/lib/stm32/common/usart_common_all.c */
/* 库函数usart_set_baudrate用到了库全局变量rcc_apb1_frequency作为时钟输入。 */
usart_set_baudrate(usart, USART_BAUDRATE);
/* usart_set_databits：用于设置串口数据位数（8或9），操作寄存器USART_CR1域M（bit12），定义在libopencm3/lib/stm32/common/usart_common_all.c */
usart_set_databits(usart, 8);
/* USART_STOPBITS_1：值0x00<<12，表示停止位1（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */
/* usart_set_stopbits：用于设置串口停止位数，操作寄存器USART_CR2域STOP（bit13:12），定义在libopencm3/lib/stm32/common/usart_common_all.c */
usart_set_stopbits(usart, USART_STOPBITS_1);
/* USART_MODE_TX_RX：值USART_CR1_RE|USART_CR1_TE，表示收+发（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */
/* USART_CR1_RE：值1<<2（libopencm3/include/libopencm3/stm32/common/usart_common_f124.h） */
/* USART_CR1_TE：值1<<3（libopencm3/include/libopencm3/stm32/common/usart_common_f124.h） */
/* usart_set_mode：用于设置串口传输模式（单收，单发，收+发），操作寄存器USART_CR1域TE（bit3）和域RE（bit2），定义在libopencm3/lib/stm32/common/usart_common_all.c */
usart_set_mode(usart, USART_MODE_TX_RX);
/* USART_PARITY_NONE：值0x00，表示无校验（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */
/* usart_set_parity：用于设置串口校验模式（无、奇、偶），操作寄存器USART_CR1域PCE（bit10）和域PS（bit9），定义在libopencm3/lib/stm32/common/usart_common_all.c */
usart_set_parity(usart, USART_PARITY_NONE);
/* USART_FLOWCONTROL_NONE：值0x00，表示无硬件流控制（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */
/* usart_set_flow_control：用于设置硬件流控制（无、RTS、CTS、RTS+CTS），操作寄存器USART_CR3的CTSE（bit9）和RTSE（bit8） */
usart_set_flow_control(usart, USART_FLOWCONTROL_NONE);
/* usart_enable：用于使能串口，操作寄存器USART_CR1的域UE（bit13），定义在libopencm3/lib/stm32/common/usart_common_all.c */
usart_enable(usart);
}
10.1.3 usb_cinit函数
USB虚拟串口初始化函数usb_cinit，根据CDC ACM虚拟串口协议对板载USB OTG FS进行设备初始化，115200@8N1，收发通信。本函数使用了USB的设备描述符（usb_device_descriptor）、配置描述符（usb_config_descriptor）、接口描述符（usb_interface_descriptor）、端点描述符（usb_endpoint_descriptor），这些描述符的定义都在libopencm3/include/libopencm3/usb/usbstd.h中。这些描述符支撑了一个全局使用的_usbd_device型结构体指针usbd_dev，它包含了USB的所有配置信息和操作函数，对它成员的配置就是本函数的核心。配置完成后USB接口的操作就非常方便了。
cdcacm.c
#define USB_CDC_REQ_GET_LINE_CODING 0x21
#define OTG_CID_HAS_VBDEN 0x00002000
#define OTG_GCCFG_VBDEN (1 << 21)
/* USB设备字符串列表，下标从1开始 */
static const char *usb_strings[] = {
USBMFGSTRING, /* USBMFGSTRING：值"3D Robotics"，生产厂家名称，INDEX 1。（hw_config.h） */
USBDEVICESTRING, /* USBDEVICESTRING："PX4 BL FMU v2.x"，USB设备名称，INDEX2。（hw_config.h） */
"0", /* 设备序号，INDEX 3 */
};
#define NUM_USB_STRINGS (sizeof(usb_strings)/sizeof(usb_strings[0])) /* 上面定义的字符串数组usb_strings的成员个数 */
static usbd_device *usbd_dev; /* _usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数（libopencm3/lib/usb/usb_private.h） */
/* Buffer to be used for control requests. */
static uint8_t usbd_control_buffer[128];
/* 标准的USB设备描述符结构体变量dev，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */
static const struct usb_device_descriptor dev = {
.bLength = USB_DT_DEVICE_SIZE, /* USB_DT_DEVICE_SIZE：值18，本结构体的大小（libopencm3/include/libopencm3/usb/usbstd.h） */
.bDescriptorType = USB_DT_DEVICE, /* USB_DT_DEVICE：值1，本结构体为USB设备描述符（libopencm3/include/libopencm3/usb/usbstd.h） */
.bcdUSB = 0x0200, /* USB接口版本，0x0200表示符合USB2.0规范 */
.bDeviceClass = USB_CLASS_CDC, /* USB_CLASS_CDC：值0x2，设备群组码（libopencm3/include/libopencm3/usb/cdc.h） */
.bDeviceSubClass = 0, /* 设备次群组码 */
.bDeviceProtocol = 0, /* 通信设备协议，0表示无群组特定协议 */
.bMaxPacketSize0 = 64, /* 设备最大信息包大小为64字节（只能为8、16、32、64） */
.idVendor = USBVENDORID, /* USBVENDORID：值0x26AC，USB设备厂家ID，这里是默认值（hw_config.h） */
.idProduct = USBPRODUCTID, /* USBPRODUCTID：值0x0011，USB产品ID（hw_config.h） */
.bcdDevice = 0x0101, /* USB设备发行序号，0x0101表示1.01版，为了兼容NuttX */
.iManufacturer = 1, /* USB设备厂家字符串下标，1代表USBMFGSTRING（"3D Robotics"），数组usb_strings */
.iProduct = 2, /* USB产品字符串下标，2代表USBDEVICESTRING（"PX4 BL FMU v2.x"），数组usb_strings */
.iSerialNumber = 3, /* USB设备序号下标，3代表空（"0"） */
.bNumConfigurations = 1, /* USB设备配置的数目为1个（config） */
};
/* USB通信端点描述符结构体数组变量comm_endp，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */
/* 这里仅对端点描述符的内容进行了赋值，结构体规定的额外内容在UNIX环境中被默认为0 */
static const struct usb_endpoint_descriptor comm_endp[] = {{
.bLength = USB_DT_ENDPOINT_SIZE, /* USB_DT_ENDPOINT_SIZE：值7，端点描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */
.bDescriptorType = USB_DT_ENDPOINT, /* USB_DT_ENDPOINT：值5，表示本结构体为USB端点描述符（libopencm3/include/libopencm3/usb/usbstd.h） */
.bEndpointAddress = 0x83, /* 通信端点地址为0x83 */
.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT, /* USB_ENDPOINT_ATTR_INTERRUPT：值0x03，本通信端点为中断传输（libopencm3/include/libopencm3/usb/usbstd.h） */
.wMaxPacketSize = 16, /* 数据包最大16字节 */
.bInterval = 255, /* 轮询间隔255ms */
}
};
/* USB数据端点描述符结构体数组变量data_endp（2个，一般称为DATA0和DATA1），属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */
/* 这里仅对端点描述符的内容进行了赋值，结构体规定的额外内容在UNIX环境中被默认为0 */
static const struct usb_endpoint_descriptor data_endp[] = {{
.bLength = USB_DT_ENDPOINT_SIZE, /* USB_DT_ENDPOINT_SIZE：值7，端点描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */
.bDescriptorType = USB_DT_ENDPOINT, /* USB_DT_ENDPOINT：值5，表示本结构体为USB端点描述符（libopencm3/include/libopencm3/usb/usbstd.h） */
.bEndpointAddress = 0x01, /* 此数据端点的地址为0x01 */
.bmAttributes = USB_ENDPOINT_ATTR_BULK, /* USB_ENDPOINT_ATTR_BULK：值0x2，本数据端点为批量传输（libopencm3/include/libopencm3/usb/usbstd.h） */
.wMaxPacketSize = 64, /* 数据包最大64字节 */
.bInterval = 1, /* 轮询间隔1ms */
}, {
.bLength = USB_DT_ENDPOINT_SIZE, /* USB_DT_ENDPOINT_SIZE：值7，端点描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */
.bDescriptorType = USB_DT_ENDPOINT, /* USB_DT_ENDPOINT：值5，表示本结构体为USB端点描述符（libopencm3/include/libopencm3/usb/usbstd.h） */
.bEndpointAddress = 0x82, /* 此数据端点的地址为0x82 */
.bmAttributes = USB_ENDPOINT_ATTR_BULK, /* USB_ENDPOINT_ATTR_BULK：值0x2，本数据端点为批量传输（libopencm3/include/libopencm3/usb/usbstd.h） */
.wMaxPacketSize = 64, /* 数据包最大64字节 */
.bInterval = 1, /* 轮询间隔1ms */
}
};
/* 对USB CDC通信需要额外提供的信息进行汇总，用于到关联通信接口描述符comm_iface */
static const struct {
struct usb_cdc_header_descriptor header;
struct usb_cdc_call_management_descriptor call_mgmt;
struct usb_cdc_acm_descriptor acm;
struct usb_cdc_union_descriptor cdc_union;
} __attribute__((packed)) cdcacm_functional_descriptors = {
.header = {
.bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
.bDescriptorType = CS_INTERFACE,
.bDescriptorSubtype = USB_CDC_TYPE_HEADER,
.bcdCDC = 0x0110,
},
.call_mgmt = {
.bFunctionLength = sizeof(struct usb_cdc_call_management_descriptor),
.bDescriptorType = CS_INTERFACE,
.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
.bmCapabilities = 0,
.bDataInterface = 1,
},
.acm = {
.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
.bDescriptorType = CS_INTERFACE,
.bDescriptorSubtype = USB_CDC_TYPE_ACM,
.bmCapabilities = 0,
},
.cdc_union = {
.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
.bDescriptorType = CS_INTERFACE,
.bDescriptorSubtype = USB_CDC_TYPE_UNION,
.bControlInterface = 0,
.bSubordinateInterface0 = 1,
}
};
/* USB通信接口描述符结构体变量comm_iface，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */
static const struct usb_interface_descriptor comm_iface[] = {{
.bLength = USB_DT_INTERFACE_SIZE, /* USB_DT_INTERFACE_SIZE：值9，接口描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */
.bDescriptorType = USB_DT_INTERFACE, /* USB_DT_INTERFACE：值4，表示本结构体为USB接口描述符（libopencm3/include/libopencm3/usb/usbstd.h） */
.bInterfaceNumber = 0, /* 接口数目1个，以0为基准开始计数 */
.bAlternateSetting = 0, /* 交互设置值为0 */
.bNumEndpoints = 1, /* 端点数目1个（comm_endp） */
.bInterfaceClass = USB_CLASS_CDC, /* USB_CLASS_CDC：值0x02，接口群组（libopencm3/include/libopencm3/usb/cdc.h） */
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM, /* USB_CDC_SUBCLASS_ACM：值0x02，接口次群组（libopencm3/include/libopencm3/usb/cdc.h） */
.bInterfaceProtocol = USB_CDC_PROTOCOL_AT, /* USB_CDC_PROTOCOL_AT：值0x01，接口协议（libopencm3/include/libopencm3/usb/cdc.h） */
.iInterface = 0, /* 接口的字符串描述符索引为0 */
/* 以下内容不再属于USB接口描述符信息，为程序内部使用的变量 */
.endpoint = comm_endp, /* 此接口对应的端点为comm_endp */
.extra = &cdcacm_functional_descriptors, /* 通信接口额外信息域为cdcacm_functional_descriptors */
.extralen = sizeof(cdcacm_functional_descriptors) /* 额外信息域长度 */
}
};
/* USB数据接口描述符结构体变量data_iface，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */
/* 这里仅进行了部分赋值，结构体规定的额外内容在UNIX环境中被默认为0 */
static const struct usb_interface_descriptor data_iface[] = {{
.bLength = USB_DT_INTERFACE_SIZE, /* USB_DT_INTERFACE_SIZE：值9，接口描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */
.bDescriptorType = USB_DT_INTERFACE, /* USB_DT_INTERFACE：值4，表示本结构体为USB接口描述符（libopencm3/include/libopencm3/usb/usbstd.h） */
.bInterfaceNumber = 1, /* 接口数目2个，以0为基准开始计数 */
.bAlternateSetting = 0, /* 交互设置值为0 */
.bNumEndpoints = 2, /* 端点数目2个（data_endp） */
.bInterfaceClass = USB_CLASS_DATA, /* USB_CLASS_DATA：值0x0a，接口群组（libopencm3/include/libopencm3/usb/cdc.h） */
.bInterfaceSubClass = 0, /* 接口次群组为0 */
.bInterfaceProtocol = 0, /* 接口协议，0表示无特定协议 */
.iInterface = 0, /* 接口的字符串描述符索引为0，无效 */
/* 以下内容不再属于USB接口描述符信息，为程序内部使用的变量 */
.endpoint = data_endp, /* 此接口对应的端点为data_endp */
}
};
/* 变量ifaces对接口描述符进行了统计（共2个），用于关联到配置描述符中 */
static const struct usb_interface ifaces[] = {{
.num_altsetting = 1,
.altsetting = comm_iface,
}, {
.num_altsetting = 1,
.altsetting = data_iface,
}
};
/* USB配置描述符结构体变量config，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */
static const struct usb_config_descriptor config = {
.bLength = USB_DT_CONFIGURATION_SIZE, /* USB_DT_CONFIGURATION_SIZE：值9，配置描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */
.bDescriptorType = USB_DT_CONFIGURATION, /* USB_DT_CONFIGURATION：值2，表示本结构体为USB配置描述符（libopencm3/include/libopencm3/usb/usbstd.h） */
.wTotalLength = 0, /* 描述符的总长度为0（是否应该为32字节？接口描述符9+配置描述符9+端点描述符7*2） */
.bNumInterfaces = 2, /* 该配置支持的接口数目2个（comm_iface和data_iface） */
.bConfigurationValue = 1, /* 配置值为1，作为set configuration请求的配置值 */
.iConfiguration = 0, /* 配置字符串描述符索引为0，无效 */
.bmAttributes = 0x80, /* 配置的属性为0x80 */
.bMaxPower = 0xFA, /* 当USB设备操作时，它从总线上获得的最大电源（单位2mA，0xFA=250，500mA） */
/* 以下内容不再属于USB配置描述符信息，为程序内部使用的变量 */
.interface = ifaces, /* 此配置对应的接口 */
};
/* USB虚拟串口属性结构体变量line_coding，属性packed，定义在libopencm3/include/libopencm3/usb/cdc.h */
static const struct usb_cdc_line_coding line_coding = {
.dwDTERate = 115200, /* 波特率115200 */
.bCharFormat = USB_CDC_1_STOP_BITS, /* USB_CDC_1_STOP_BITS：值0，1位停止位（libopencm3/include/libopencm3/usb/cdc.h） */
.bParityType = USB_CDC_NO_PARITY, /* USB_CDC_NO_PARITY：值0，无校验（libopencm3/include/libopencm3/usb/cdc.h） */
.bDataBits = 0x08 /* 数据8位 */
};
/* USB虚拟串口请求控制函数，被配置函数cdcacm_set_config函数使用 */
static int cdcacm_control_request(usbd_device *usbd_dev, struct usb_setup_data *req, uint8_t **buf, uint16_t *len,
void (**complete)(usbd_device *usbd_dev, struct usb_setup_data *req))
{
(void)complete;
(void)buf;
(void)usbd_dev;
switch (req->bRequest) { /* 请求类型 */
case USB_CDC_REQ_SET_CONTROL_LINE_STATE: { /* USB_CDC_REQ_SET_CONTROL_LINE_STATE：值0x22，请求设置命令行状态，定义在libopencm3/include/libopencm3/usb/cdc.h */
return 1; /* 不操作，直接返回1 */
}
case USB_CDC_REQ_SET_LINE_CODING: /* USB_CDC_REQ_SET_LINE_CODING：值0x20，请求设置虚拟串口属性，定义在libopencm3/include/libopencm3/usb/cdc.h */
if (*len < sizeof(struct usb_cdc_line_coding)) { /* 若配置的参数长度小于usb_cdc_line_coding的大小，返回0 */
return 0;
}
return 1; /* 不操作，返回1 */
case USB_CDC_REQ_GET_LINE_CODING: /* USB_CDC_REQ_GET_LINE_CODING：值0x21，请求读取虚拟串口属性，定义在cdcacm.c中 */
*buf = (uint8_t *)&line_coding; /* buf指向虚拟串口属性变量line_coding（115200@8N1），定义在cdcacm.c中 */
return 1;
}
return 0;
}
/* USB虚拟串口数据接收函数，被配置函数cdcacm_set_config函数使用 */
static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep)
{
(void)ep;
char buf[64];
unsigned i;
/* usbd_ep_read_packet：去读USB设备usbd_dev在端点地址0x01的数据到缓冲区buf中，并返回读取到数据的个数。定义在libopencm3/lib/usb/usb.c */
unsigned len = usbd_ep_read_packet(usbd_dev, 0x01, buf, sizeof(buf));
/* 将数据赋值给接收数据缓冲区rx_buf */
/* buf_put：将数据写入到缓冲区的函数，定义在bl.c */
for (i = 0; i < len; i++) {
buf_put(buf[i]);
}
}
/* USB虚拟串口配置函数，被usb_cinit中的库函数usbd_register_set_config_callback引用 */
static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue)
{
(void)wValue;
/* USB_ENDPOINT_ATTR_BULK：值0x2，批量传输（libopencm3/include/libopencm3/usb/usbstd.h） */
/* USB_ENDPOINT_ATTR_INTERRUPT：值0x03，中断传输（libopencm3/include/libopencm3/usb/usbstd.h） */
/* cdcacm_data_rx_cb：USB虚拟串口数据接收函数，将数据赋值给接收数据缓冲区rx_buf（bl.c），定义在cdcacm.c */
/* usbd_ep_setup：设置USB端点地址、类型、FIFO存储空间和回调函数 */
/* 第一行：地址为0x01的USB端点类型为批量传输模式（USB_ENDPOINT_ATTR_BULK），缓冲区长度64字节，回调函数为cdcacm_data_rx_cb，用于接收USB数据 */
/* 第二行：地址为0x82的USB端点类型为批量传输模式（USB_ENDPOINT_ATTR_BULK），缓冲区长度64字节，无回调函数，用于发送USB数据 */
/* 第三行：地址为0x83的USB端点类型为中断传输模式（USB_ENDPOINT_ATTR_INTERRUPT），缓冲区长度16字节，无回调函数，用于USB传输控制 */
usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb);
usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, NULL);
usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
/* USB_REQ_TYPE_CLASS：值0x20（libopencm3/include/libopencm3/usb/usbstd.h） */
/* USB_REQ_TYPE_INTERFACE：值0x01（libopencm3/include/libopencm3/usb/usbstd.h） */
/* USB_REQ_TYPE_TYPE：值0x60（libopencm3/include/libopencm3/usb/usbstd.h） */
/* USB_REQ_TYPE_RECIPIENT：值0x1F（libopencm3/include/libopencm3/usb/usbstd.h） */
/* cdcacm_control_request：USB虚拟串口请求控制函数，功能为处理各种USB请求信息，定义在cdcacm.c */
/* usbd_register_control_callback：USB寄存器控制请求回调函数，定义在libopencm3/lib/usb/usb_control.c */
usbd_register_control_callback(usbd_dev, USB_REQ_TYPE_CLASS|USB_REQ_TYPE_INTERFACE, USB_REQ_TYPE_TYPE|USB_REQ_TYPE_RECIPIENT, cdcacm_control_request);
}
/* USB OTG FS中断处理函数 */
void otg_fs_isr(void)
{
if (usbd_dev) {
/* usbd_poll：USB设备的POLL操作；定义在libopencm3/lib/usb/usb.c */
usbd_poll(usbd_dev);
}
}
/* USB虚拟串口通信初始化函数 */
void usb_cinit(void)
{
#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */
/* 1. 启动USB接口时钟，对应原理图中GPIOA9(VBUS/3.1A)，GPIOA11(OTG_FS_DM/3.1B)，GPIOA12(OTG_FS_DP/3.1A) */
/* RCC_AHB1ENR：寄存器（地址0x40023830），定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* RCC_AHB2ENR：寄存器（地址0x40023834），定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* RCC_AHB1ENR_IOPAEN：值1<<0（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* RCC_AHB2ENR_OTGFSEN：值1<<7（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* 第一行代码使能GPIOA的时钟，操作寄存器RCC_AHB1ENR的域GPIOAEN(bit0) */
/* 第二行代码使能USB OTG FS时钟，操作寄存器RCC_AHB2ENR的域OTGFSEN(bit7) */
rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
#if defined(USB_FORCE_DISCONNECT) /* 宏USB_FORCE_DISCONNECT未定义，下列代码无效 */
gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_OTYPE_OD, GPIO12);
gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO12);
gpio_clear(GPIOA, GPIO12);
systick_set_clocksource(STK_CSR_CLKSOURCE_AHB);
systick_set_reload(board_info.systick_mhz * 1000); /* 1ms tick, magic number */
systick_interrupt_enable();
systick_counter_enable();
/* Spec is 2-2.5 uS */
delay(1);
systick_interrupt_disable();
systick_counter_disable(); // Stop the timer
#endif
/* 2. 配置GPIOA11和GPIOA12分别USB数据通信功能 */
/* GPIOA：地址为0x40020000的寄存器（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_MODE_AF：值0x2（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_PUPD_NONE：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO11：值1<<11（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* GPIO12：值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* GPIO_AF10：值0xa（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* gpio_mode_setup：设置引脚工作模式，定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */
/* gpio_set_af：设置引脚具体的AF功能，定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */
/* 第一行代码设置GPIOA11（OTG_FS_DM/3.1B）和GPIOA12（OTG_FS_DP/3.1A）为AF功能（MODER=GPIO_MODE_AF=10），push-pull模式（PUPDR=GPIO_PUPD_NONE=0x0） */
/* 第二行代码设置GPIOA11和GPIOA12的具体AF功能为OTGFS/OTGHS（AFRH10=AFRH9=GPIO_AF10=0xa） */
gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11 | GPIO12);
gpio_set_af(GPIOA, GPIO_AF10, GPIO11 | GPIO12);
#if defined(BOARD_USB_VBUS_SENSE_DISABLED) /* 宏BOARD_USB_VBUS_SENSE_DISABLED未定义，下列代码无效 */
OTG_FS_GCCFG |= OTG_GCCFG_NOVBUSSENS;
#endif
/* 3. USB设备的初始化配置 */
/* usbd_dev：_usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数（libopencm3/lib/usb/usb_private.h） */
/* otgfs_usb_driver：_usbd_driver型结构体变量stm32f107_usb_driver，包含一系列USBFS驱动函数（libopencm3/lib/usb/usb_f107.c） */
/* dev：USB设备描述符usb_device_descriptor，包含USB设备的基本信息（libopencm3/include/libopencm3/usb/usbstd.h），初始化在cdcacm.c */
/* config：USB配置描述符usb_config_descriptor，包含USB设备的配置信息（libopencm3/include/libopencm3/usb/usbstd.h），初始化在cdcacm.c */
/* usb_strings：USB设备字符串列表，定义并被初始化在cdcacm.c */
/* NUM_USB_STRINGS：值3，usb_strings的数量，宏定义在cdcacm.c */
/* usbd_control_buffer：控制操作请求缓冲区，128字节，定义在cdcacm.c */
/* usbd_init：usb接口初始化函数，目的是填写结构体变量usbd_dev，定义在libopencm3/lib/usb/usb.c */
usbd_dev = usbd_init(&otgfs_usb_driver, &dev, &config, usb_strings, NUM_USB_STRINGS, usbd_control_buffer, sizeof(usbd_control_buffer));
#elif defined(STM32F1) /* 宏STM32F1未定义（IO协处理器不执行usb_cinit），下列代码无效 */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);
gpio_set(GPIOA, GPIO8);
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO8);
usbd_dev = usbd_init(&st_usbfs_v1_usb_driver, &dev, &config, usb_strings, NUM_USB_STRINGS, usbd_control_buffer, sizeof(usbd_control_buffer));
#endif
/* 4. USB传输回调函数设置 */
/* usbd_dev：_usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数（libopencm3/lib/usb/usb_private.h） */
/* cdcacm_set_config：USB虚拟串口配置函数，配置USB端点的操作函数和USB寄存器的请求操作函数，定义在cdcmca.c */
/* usbd_register_set_config_callback：追加回调函数cdcacm_set_config到设备描述符usbd_dev中 */
usbd_register_set_config_callback(usbd_dev, cdcacm_set_config);
#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */
/* 5. 若USB产品的ID号为0x00002000，启动USB连接功能 */
/* OTG_FS_CID：寄存器，用于存储USB产品ID，软件可更改（libopencm3/include/libopencm3/stm32/otg_fs.h） */
/* OTG_CID_HAS_VBDEN：值0x00002000，定义在cdcacm.c */
/* OTG_FS_GCCFG：寄存器（libopencm3/include/libopencm3/stm32/otg_fs.h） */
/* OTG_GCCFG_VBDEN：值1<<21，置该位认为VBUS一直有效，不再受外围电路影响（cdcacm.c） */
/* OTG_GCCFG_PWRDWN：值1<<16，置该位开启收发功能（libopencm3/include/libopencm3/stm32/otg_common.h） */
/* OTG_FS_DCTL：寄存器（libopencm3/include/libopencm3/stm32/otg_fs.h） */
/* OTG_DCTL_SDIS：值1<<1，该位由软件控制USB核心开启软件连接功能（libopencm3/include/libopencm3/stm32/otg_common.h） */
if (OTG_FS_CID == OTG_CID_HAS_VBDEN) {
OTG_FS_GCCFG |= OTG_GCCFG_VBDEN | OTG_GCCFG_PWRDWN;
/* 对于STM32F446/469，启动后需要进行软件连接 */
OTG_FS_DCTL &= ~OTG_DCTL_SDIS;
}
/* 6. 使能USB OTG FS中断 */
/* NVIC_OTG_FS_IRQ：值67，对应USB OTG FS的全局中断向量号，libopencm3/include/libopencm3/stm32/f4/nvic.h（编译时自动生成文件） */
/* nvic_enable_irq：使能中断向量，定义在libopencm3/lib/cm3/nvic.c */
nvic_enable_irq(NVIC_OTG_FS_IRQ);
#endif
}
USB串口读取数据后存放到缓冲区的函数，被cdcacm_data_rx_cb函数调用
bl.c
static unsigned head, tail; /* 头、尾指针 */
static uint8_t rx_buf[256]; /* 缓冲区长度 */
void buf_put(uint8_t b)
{
unsigned next = (head + 1) % sizeof(rx_buf);
if (next != tail) {
rx_buf[head] = b;
head = next;
}
}
10.2 串口和USB虚拟串口反向初始化相关函数
串口和USB虚拟串口反向初始化包括cfini、uart_cfini和usb_cfini共3个函数。
10.2.1 cfini函数
cfini函数是串口和USB虚拟串口初始化的主要函数，使Bootloader主动放弃通信串口的控制权。cfini函数根据输入interface的值决定具体调用的初始化函数；uart_cfini用于反向初始化串口，usb_cfini用于反向初始化USB接口。
bl.c
inline void cfini(void)
{
#if INTERFACE_USB /* 主控FMU：宏INTERFACE_USB定义为1，代码有效，hw_config.h */
/* IO协处理器：宏INTERFACE_USB定义为0，代码无效，hw_config.h */
usb_cfini();
#endif
#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，hw_config.h */
uart_cfini();
#endif
}
10.2.2 uart_cfini函数
uart_cfini函数的草组很简单，直接调用库函数usart_disable关闭串口，USART2串口的配置并不改变。
usart.c
uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */
void uart_cfini(void)
{
/* usart_disable：关闭串口，操作寄存器USART_CR1的域UE（bit13）（libopencm3/lib/stm32/common/usart_common_all.c） */
usart_disable(usart);
}
10.2.3 usb_cfini函数
USB虚拟串口反向初始化函数usb_cfini，并未改变USB的接口配置，主要操作如下：
- 关闭USB OTG FS中断
- 关闭USB软连接，并清空usbd_dev指针
- 配置USB数据引脚GPIOA11和GPIOA12的工作模式
- 关闭USB OTG FS时钟
void usb_cfini(void)
{
#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */
/* 1. 关闭USB OTG FS中断 */
/* NVIC_OTG_FS_IRQ：值67，对应USB OTG FS的全局中断向量号，libopencm3/include/libopencm3/stm32/f4/nvic.h（编译时自动生成文件） */
/* nvic_disable_irq：使能中断向量，定义在libopencm3/lib/cm3/nvic.c */
nvic_disable_irq(NVIC_OTG_FS_IRQ);
#endif
/* 2.关闭USB软连接，并清空usbd_dev指针 */
/* usbd_dev：usbd_device型全局变量指针，指向USB的配置信息和操作函数，被usbd_init库函数初始化，cdcacm.c */
/* usbd_disconnect：断开USB软连接（不是所有的MCU都支持）。定义在libopencm3/lib/usb/usb.c */
if (usbd_dev) {
usbd_disconnect(usbd_dev, true);
usbd_dev = NULL;
}
#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */
/* 3. 配置USB数据引脚GPIOA11和GPIOA12为输入 */
/* GPIOA：地址为0x40020000的寄存器（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_MODE_INPUT：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO_PUPD_NONE：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */
/* GPIO11：值1<<11（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* GPIO12：值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */
/* gpio_mode_setup：设置引脚工作模式，定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */
/* 设置GPIOA11（OTG_FS_DM/3.1B）和GPIOA12（OTG_FS_DP/3.1A）为输入功能（MODER=GPIO_MODE_AF=00），浮空模式（PUPDR=GPIO_PUPD_NONE=0x0） */
gpio_mode_setup(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO11 | GPIO12);
/* 4. 关闭USB OTG FS时钟 */
/* RCC_AHB2ENR：寄存器（地址0x40023834），定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
/* RCC_AHB2ENR_OTGFSEN：值1<<7（libopencm3/include/libopencm3/stm32/f4/rcc.h） */
/* rcc_peripheral_disable_clock：关闭特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
/* 关闭USB OTG FS时钟，操作寄存器RCC_AHB2ENR的域OTGFSEN(bit7) */
rcc_peripheral_disable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);
#elif defined(STM32F1) /* 宏STM32F1未定义（IO协处理器不执行usb_cfini），下列代码无效 */
/* Reset the USB pins to being floating inputs */
gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO8);
gpio_clear(GPIOA, GPIO8);
#endif
}
10.3 读取串口和USB虚拟串口内容函数
读取串口和USB虚拟串口内容函数包括uart_cin和usb_cin两个，分别对应USART读取和USB模拟串口读取函数，这两个函数均被cin函数调用。
10.3.1 uart_cin函数
uart_cin函数用于读取USART串口的1个字。
usart.c
uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */
int uart_cin(void)
{
int c = -1; /* 默认返回值-1 */
/* 若串口数据寄存器不为空，调用库函数读取接收到的数据 */
/* USART_SR：USART状态寄存器，定义在libopencm3/include/libopencm3/stm32/common/usart_common_f124.h */
/* USART_SR_RXNE：值1<<5，定义在libopencm3/include/libopencm3/stm32/common/usart_common_f124.h */
/* usart：值USART2（USART2基地址），定义在usart.c */
/* usart_recv：接收串口数据的库函数，定义在libopencm3/lib/stm32/common/usart_common_f124.c */
if (USART_SR(usart) & USART_SR_RXNE) {
c = usart_recv(usart);
}
return c;
}
10.3.2 usb_cin函数
usb_cin函数用于读取USB模拟串口的1个字，该函数仅对主控FMU有效。
cdcacm.c
int usb_cin(void)
{
/* 若usbd_dev为空指针，则USB设备未被初始化，返回错误 */
/* usbd_dev：_usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数，定义在cdcacm.c */
if (usbd_dev == NULL) { return -1; }
#if defined(STM32F1) /* 主控FMU未定义，代码无效 */
usbd_poll(usbd_dev);
#endif
/* buf_get：从串口缓冲区内读取1个字的内容，定义在bl.c */
return buf_get();
}
bl.c
static unsigned head, tail; /* 头、尾指针 */
static uint8_t rx_buf[256]; /* 串口串口缓冲区 */
int buf_get(void)
{
int ret = -1;
if (tail != head) {
ret = rx_buf[tail];
tail = (tail + 1) % sizeof(rx_buf);
}
return ret;
}
10.4 串口和USB虚拟串口内容输出函数
串口和USB虚拟串口输出函数包括uart_cout和usb_cout两个，分别对应USART读取和USB模拟串口输出函数，这两个函数均被cout函数调用。
10.4.1 uart_cout函数
usart.c
uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */
void uart_cout(uint8_t *buf, unsigned len)
{
/* usart_send_blocking：USART串口发送库函数，仅当串口数据缓存为空时再发送下一个数据，定义在libopencm3/lib/stm32/common/usart_common_all.c */
while (len--) {
usart_send_blocking(usart, *buf++);
}
}
10.4.2 usb_cout函数
cdcacm.c
void usb_cout(uint8_t *buf, unsigned count)
{
if (usbd_dev) { /* 若USB设备有效 */
/* 将需要写入的数据分成64字节1包，逐包写入到地址为0x82的端点中 */
while (count) {
unsigned len = (count > 64) ? 64 : count;
unsigned sent;
/* usbd_ep_write_packet：向USB模拟串口写入数据的库函数，返回写入的字节数，定义在libopencm3/lib/usb/usb.c */
sent = usbd_ep_write_packet(usbd_dev, 0x82, buf, len);
count -= sent;
buf += sent;
}
}
}
11 结论
不知不觉，就写了这么多，我最怕写结尾了，因为不知道写什么好。写博客的时候发现，github上bootloader的原始代码也更新了。幸好只是改变了Makefile的结构，对软件结构影响不大，因此上述内容依然有参考价值。博客写完之后没有进行详细地推敲，希望各位看官多多批评指正，大家共同进步。
希望详细讨论的看官，可以发邮件至我的邮箱：
只要我知道的，有求必应。
开源万岁！！！
