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_blall:  $(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=-DSTM32F469px4fmuv5_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): checksubmodulesmake -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为5000msSRCS       = $(COMMON_SRCS) main_f4.c   #定义编译源文件为bl.c cdcacm.c usart.c和main_f4.cFLAGS        += -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.binall:      $(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延时3000msSRCS        = $(COMMON_SRCS) main_f1.c           #定义源文件为bl.c cdcacm.c usart.c和main_f1.cFLAGS      += -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.aELF       = $(TARGET_FILE_NAME).elf              #定义ELF目标变量px4io_bl.elf
BINARY       = $(TARGET_FILE_NAME).bin          #定义BINARY目标变量px4io_bl.binall:      $(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 0x421typedef 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
#endifint 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/02gpio_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);
#endifwhile (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步。

#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
#endifint 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
- 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;}}
#endifreturn -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;}
#endiffirst_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 appreturn;/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ *//* （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;}}
#endifreturn 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();
#elsercc_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的结构，对软件结构影响不大，因此上述内容依然有参考价值。博客写完之后没有进行详细地推敲，希望各位看官多多批评指正，大家共同进步。

希望详细讨论的看官，可以发邮件至我的邮箱：

zhaowei19841211@gmail.com

只要我知道的，有求必应。

开源万岁！！！

转载于:https://my.oschina.net/zhaowei19841211/blog/1547605

PX4 Bootloader解析相关推荐

PX4代码解析（5）
一.前言我所讨论的PX4代码是基于v1.11版本,该版本与之前的版本有不少不同,其中一个比较大的区别在于新版本大部分用到了C++中模板,使得代码没有以前那么容易理解,因此我在后面介绍PX4的姿态估计 ...
PX4代码解析(6)
一.前言上一节介绍了PX4姿态估计调用函数的流程,这一节分享一下我对PX4姿态解算的解读.首先,要理解PX4姿态解算的程序,要先从传感器的特性入手,这里主要介绍的传感器有加速度计,磁力计,陀螺仪. ...
px4代码解析(3)
前言在使用PX4飞控时,我们难免要对其进行二次开发,例如修改控制算法,添加新的传感器,这时需要在代码中定义属于自己的消息.本节主要分享一下如何在PX4代码中添加自己的消息一.消息添加与配置从代码 ...
PX4代码解析(1)
前言做pixhawk飞控有一段时间了,但在学习过程中遇到许多困难,目前网上找不到比较完整的PX4学习笔记,我打算结合自己理解,写写自己对PX4源码的理解,不一定对,只是希望与各位大佬交流交流,同时梳 ...
PX4代码解析(4)
一.引言 PX4程序是基于实时操作系统(Real-time operating system, RTOS)的上层应用程序,PX4飞控程序的很多重要模块都是在Nuttx操作系统的调度下运行的.因此,想要 ...
PX4代码解析(2)
前言在大致了解PX4代码架构后,我们需要了解PX4的通信机制.在PX4代码架构中,每通信总线主要分为两个部分,一是内部通信总线uORB,即PX4内部进程通信采用的协议,例如PX4内部姿态控制需要获取 ...
PX4代码解析：振动分析
本篇文章首发于公众号:无人机系统技术.更多无人机技术相关文章请关注此公众号一.前言前面的文章主要都是一些理论知识为主,很多读者朋友看了之后可能会有点枯燥,里面很多公式看起来也比较晦涩,今天起给大家 ...
PX4装机教程（三）直升机
文章目录前言一.装机二.PX4直升机解析前言硬件:KDS600直升机,pixhawk4飞控软件:px4 1.11.0 QGC地面站参考链接 https://docs.px4.io/mas ...
研究基于PX4平台的Ardupilot代码工程的makefile结构
最近有空,于是想花时间好好研究下ardupilot的软件架构,经过对ardupilot一段时间的熟悉和使用后,对其软件架构已经有了一定的理解,但还称不上特别完备,所以想把每一部分的细节都弄清楚. ma ...
Pixhawk遥控器无法检测bootloader烧写
Pixhawk"detected 0 radio channel" 导火索:最近毕设想用pixhawk来做个东西.于是跟着官方的wiki,搭建起了编译环境.但是奇怪的事情突然发生了 ...