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
1# 2# Paths to common dependencies 3# 4export BL_BASE ?= $(wildcard .) #获取Bootloader本地工程所在目录，并赋给变量BL_BASE 5export LIBOPENCM3 ?= $(wildcard libopencm3) #获取开源库libopencm3所在目录，并赋给变量LIBOPENCM3 6 7# 8# Tools 9# 10export CC = arm-none-eabi-gcc #定义交叉编译工具链变量CC 11export OBJCOPY = arm-none-eabi-objcopy #定义二进制生成工具链变量OBJCOPY 12 13# 14# Common configuration 15# 16export FLAGS = -std=gnu99 \ #使用GNU99的优化C语言标准 17 -Os \ #专门针对生成目标文件大小进行 18 -g \ #生成调试信息 19 -Wundef \ #当没有定义的符号出现在#if中时警告 20 -Wall \ #打开一些有用的警告选项 21 -fno-builtin \ #不接受没有__buildin__前缀的函数作为内建函数 22 -I$(LIBOPENCM3)/include \ #包含开源库libopencm3的头文件 23 -ffunction-sections \ #要求编译器为每个function分配独立的section 24 -nostartfiles \ #链接时不使用标准的启动文件 25 -lnosys \ #链接libnosys.a文件 26 -Wl,-gc-sections \ #传递-gc-sections给连接器，删除没有使用的section 27 -Wl,-g \ #传递-g选项给链接器，兼容其他工具 28 -Werror #把警告当错误，出现警告就放弃编译 29 30export COMMON_SRCS = bl.c cdcacm.c usart.c #定义通用源文件变量COMMON_SRCS 31 32# 33# Bootloaders to build 34# 35TARGETS = \ #定义编译目标 36 aerofcv1_bl \ 37 auavx2v1_bl \ 38 crazyflie_bl \ 39 mindpxv2_bl \ 40 px4aerocore_bl \ 41 px4discovery_bl \ 42 px4flow_bl \ 43 px4fmu_bl \ 44 px4fmuv2_bl \ 45 px4fmuv4_bl \ 46 px4fmuv4pro_bl \ 47 px4fmuv5_bl \ 48 px4io_bl \ 49 px4iov3_bl \ 50 tapv1_bl 51 52all: $(TARGETS) #编译目标all=$(TARGETS) 53 54 55clean: #定义清理工程的操作（即make clean） 56 cd libopencm3 && make --no-print-directory clean && cd .. # 从Bootloader本地工程目录进入libopencm3文件夹，执行make clean清理命令，然后回到上一级目录。 57 rm -f *.elf *.bin #删除.efl和.bin文件 58 59# 60# Specific bootloader targets. 61# 各编译目标的具体操作，主要规定了编译需要使用的Makefile文件，硬件目标TARGET_HW，链接脚本LINKER_FILE，编译目标TARGET_FILE_NAME 62# 63 64auavx2v1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 65 make -f Makefile.f4 TARGET_HW=AUAV_X2V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 66 67px4fmu_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 68 make -f Makefile.f4 TARGET_HW=PX4_FMU_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 69 70px4fmuv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 71 make -f Makefile.f4 TARGET_HW=PX4_FMU_V2 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 72 73px4fmuv4_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 74 make -f Makefile.f4 TARGET_HW=PX4_FMU_V4 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 75 76px4fmuv4pro_bl:$(MAKEFILE_LIST) $(LIBOPENCM3) 77 make -f Makefile.f4 TARGET_HW=PX4_FMU_V4_PRO LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ EXTRAFLAGS=-DSTM32F469 78 79px4fmuv5_bl:$(MAKEFILE_LIST) $(LIBOPENCM3) 80 make -f Makefile.f7 TARGET_HW=PX4_FMU_V5 LINKER_FILE=stm32f7.ld TARGET_FILE_NAME=$@ 81 82mindpxv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 83 make -f Makefile.f4 TARGET_HW=MINDPX_V2 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 84 85px4discovery_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 86 make -f Makefile.f4 TARGET_HW=PX4_DISCOVERY_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 87 88px4flow_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 89 make -f Makefile.f4 TARGET_HW=PX4_FLOW_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 90 91px4aerocore_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 92 make -f Makefile.f4 TARGET_HW=PX4_AEROCORE_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 93 94crazyflie_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 95 make -f Makefile.f4 TARGET_HW=CRAZYFLIE LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 96 97# Default bootloader delay is *very* short, just long enough to catch 98# the board for recovery but not so long as to make restarting after a 99# brownout problematic. 100# 101px4io_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 102 make -f Makefile.f1 TARGET_HW=PX4_PIO_V1 LINKER_FILE=stm32f1.ld TARGET_FILE_NAME=$@ 103 104px4iov3_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 105 make -f Makefile.f3 TARGET_HW=PX4_PIO_V3 LINKER_FILE=stm32f3.ld TARGET_FILE_NAME=$@ 106 107tapv1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 108 make -f Makefile.f4 TARGET_HW=TAP_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 109 110aerofcv1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 111 make -f Makefile.f4 TARGET_HW=AEROFC_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ 112 113# 114# Binary management 115# 二进制文件压缩操作：deploy命令 116# 117.PHONY: deploy 118deploy: 119 zip Bootloader.zip *.bin 120 121# 122# Submodule management 123# 子模块libopencm3操作与管理，进行的操作如下： 124# 1. 更新git子工程libopencm3。 125# 2. 调用Tools/check_submodules.sh检查当前libopencm3的版本信息是否正确。 126# 3. 编译libopencm3工程，生成库文件，供bootloader使用。 127# 128 129$(LIBOPENCM3): checksubmodules 130 make -C $(LIBOPENCM3) lib 131 132.PHONY: checksubmodules 133checksubmodules: updatesubmodules 134 $(Q) ($(BL_BASE)/Tools/check_submodules.sh) 135 136.PHONY: updatesubmodules 137updatesubmodules: 138 $(Q) (git submodule init) 139 $(Q) (git submodule update)
3.2 主控Makefile.f4文件注释
由主Makefile中目标生成语句可以看出，Pixhawk V2硬件系统的主控stm32f427对应的bootloader调用了如下语句：
Makefile
1px4fmuv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 2 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
1OPENOCD ?= openocd #定义OPENOCD命令 2 3JTAGCONFIG ?= interface/olimex-jtag-tiny.cfg #定义openocd对应的jtag烧写器配置文件 4#JTAGCONFIG ?= interface/jtagkey-tiny.cfg 5 6# 5 seconds / 5000 ms default delay 7PX4_BOOTLOADER_DELAY ?= 5000 #定义启动变量PX4_BOOTLOADER_DELAY为5000ms 8 9SRCS = $(COMMON_SRCS) main_f4.c #定义编译源文件为bl.c cdcacm.c usart.c和main_f4.c 10 11FLAGS += -mthumb\ #使用thumb指令集 12 -mcpu=cortex-m4\ #使用cortex m4对应的CPU指令 13 -mfloat-abi=hard\ #浮点为硬件浮点运算 14 -mfpu=fpv4-sp-d16 \ #浮点运算协处理器为fpv4-sp-d16 15 -DTARGET_HW_$(TARGET_HW) \ #定义变量TARGET_HW_PX4_FMU_V2为1 16 -DSTM32F4 \ #定义变量STM32F4为1 17 -T$(LINKER_FILE) \ #使用链接文件stm32f4.ld 18 -L$(LIBOPENCM3)/lib \ #添加库文件搜索目录libopencm3/lib 19 -lopencm3_stm32f4 \ #链接库文件libopencm3_stm32f4.a 20 $(EXTRAFLAGS) 21 22ELF = $(TARGET_FILE_NAME).elf #定义目标变量ELF=px4fmuv2_bl.elf 23BINARY = $(TARGET_FILE_NAME).bin #定义目标二进制变量BINARY=px4fmuv2_bl.bin 24 25all: $(ELF) $(BINARY) #定义目标all，为px4fmuv2_bl.elf和px4fmuv2_bl.bin 26 27#px4fmuv2_bl.elf的生成规则： 28#px4fmuv2_bl.elf: bl.c cdcacm.c usart.c main_f4.c Makefile 29# arm-none-eabi-gcc -o px4fmuv2_bl.elf bl.c cdcacm.c usart.c main_f4.c $(FLAGS) 30$(ELF): $(SRCS) $(MAKEFILE_LIST) 31 $(CC) -o $@ $(SRCS) $(FLAGS) 32 33#px4fmuv2_bl.bin的生成规则： 34#px4fmuv2_bl.bin: px4fmuv2_bl.elf 35# arm-none-eabi-objcopy -O binary px4fmuv2_bl.elf px4fmuv2_bl.bin 36$(BINARY): $(ELF) 37 $(OBJCOPY) -O binary $(ELF) $(BINARY) 38 39#upload: all flash flash-bootloader 40#定义upload目标，依赖于all flash-bootloader 41upload: all flash-bootloader 42 43#定义flash-bootloader目标的命令规则 44#执行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命令进行烧写。 45flash-bootloader: 46 $(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 47 48# Use to upload to a stm32f4-discovery devboard, requires the latest version of openocd (from git) 49# build openocd with "cd openocd; ./bootstrap; ./configure --enable-maintainer-mode --enable-stlink" 50#定义upload-discovery目标的命令规则 51#执行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命令进行烧写。 52upload-discovery: 53 $(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
1px4io_bl: $(MAKEFILE_LIST) $(LIBOPENCM3) 2 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
1OPENOCD ?= ../../sat/bin/openocd #定义openocd命令变量 2 3JTAGCONFIG ?= interface/olimex-jtag-tiny.cfg #定义Jtag烧写器配置文件 4#JTAGCONFIG ?= interface/jtagkey-tiny.cfg 5 6# 3 seconds / 3000 ms default delay 7PX4_BOOTLOADER_DELAY ?= 3000 #定义bootloader延时3000ms 8 9SRCS = $(COMMON_SRCS) main_f1.c #定义源文件为bl.c cdcacm.c usart.c和main_f1.c 10 11FLAGS += -mthumb\ #使用thumb指令集 12 -mcpu=cortex-m3\ #使用cortex m3指令集 13 -DTARGET_HW_$(TARGET_HW) \ #定义TARGET_HW_PX4_PIO_V1变量为1 14 -DSTM32F1 \ #定义STM32F1变量为1 15 -T$(LINKER_FILE) \ #使用链接脚本stm32f1.ld 16 -L$(LIBOPENCM3)/lib \ #增加库文件搜索目录libopencm3/lib 17 -lopencm3_stm32f1 #链接库文件libopencm3_stm32f1.a 18 19ELF = $(TARGET_FILE_NAME).elf #定义ELF目标变量px4io_bl.elf 20BINARY = $(TARGET_FILE_NAME).bin #定义BINARY目标变量px4io_bl.bin 21 22all: $(ELF) $(BINARY) #定义目标all为px4io_bl.elf和px4io_bl.bin 23 24#px4io_bl.elf生成规则 25#px4io_bl.elf: bl.c cdcacm.c usart.c main_f1.c Makefile 26# arm-none-eabi-gcc -o px4io_bl.elf bl.c cdcacm.c usart.c main_f1.c $(FLAGS) 27$(ELF): $(SRCS) $(MAKEFILE_LIST) 28 $(CC) -o $@ $(SRCS) $(FLAGS) 29 30#px4io_bl.bin生成规则 31#px4io_bl.bin: px4io_bl.elf 32# arm-none-eabi-objcopy -O binary px4io_bl.elf px4io_bl.bin 33$(BINARY): $(ELF) 34 $(OBJCOPY) -O binary $(ELF) $(BINARY) 35 36#upload: all flash flash-bootloader 37#定义upload目标，依赖于all flash-bootloader 38upload: all flash-bootloader 39 40#flash-bootloader目标生成命令 41#执行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命令进行烧写。 42flash-bootloader: 43 $(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
1/* Define memory regions. */ 2/* 声明存储区域，分为rom和ram两部分 */ 3MEMORY 4{ 5 rom (rx) : ORIGIN = 0x08000000, LENGTH = 16K /* 定义rom区，即片内flash的部分区域，权限可读可执行，起始于flash起始地址0x08000000，使用前16K（即Section 0） */ 6 ram (rwx) : ORIGIN = 0x20000000, LENGTH = 128K /* 定义ram区，即片内SRAM的部分区域，权限可读可写可执行，起始于SRAM1起始地址0x20000000，包含SRAM1和SRAM2的全部区域（128K） */ 7} 8 9/* Enforce emmission of the vector table. */ 10/* 声明外部定义的vector_table变量，此变量被定义在libopencm3/lib/cm3/vector.c中 */ 11EXTERN (vector_table) 12 13/* Define sections. */ 14SECTIONS /* 定义段 */ 15{ 16 . = ORIGIN(rom); /* 链接器指针定位于rom区起始地址 */ 17 18 .text : { /* 定义代码段text */ 19 *(.vectors) /* Vector table 中断向量表，定义于libopencm3/lib/cm3/vector.c文件中，仅包含vector_table变量 */ 20 *(.text*) /* Program code 程序代码段 */ 21 . = ALIGN(4); /* 4字节对齐 */ 22 *(.rodata*) /* Read-only data 程序只读数据段 */ 23 . = ALIGN(4); /* 4字节对齐 */ 24 _etext = .; /* 定义变量_etext为当前地址 */ 25 } >rom /* 代码段text的程序地址位于rom中 */ 26 27 /* C++ Static constructors/destructors, also used for __attribute__ 28 * ((constructor)) and the likes */ 29 .preinit_array : { /* 定义C++构造函数段preinit_array */ 30 . = ALIGN(4); /* 4字节对齐 */ 31 __preinit_array_start = .; /* 定义变量__preinit_array_start为当前地址 */ 32 KEEP (*(.preinit_array)) /* 强制链接器保留preinit_array段 */ 33 __preinit_array_end = .; /* 定义变量__preinit_array_end为当前地址 */ 34 } >rom /* C++构造函数段preinit_array的程序地址位于rom中 */ 35 .init_array : { /* 定义C++构造函数段init_array */ 36 . = ALIGN(4); /* 4字节对齐 */ 37 __init_array_start = .; /* 定义变量__init_array_start为当前地址 */ 38 KEEP (*(SORT(.init_array.*))) /* 强制链接器保留init_array.* 段，并对满足字符串模式的内容进行升序排列 */ 39 KEEP (*(.init_array)) /* 强制链接器保留init_array段 */ 40 __init_array_end = .; /* 定义变量__init_array_end为当前地址 */ 41 } >rom /* C++构造函数段init_array的程序地址位于rom中 */ 42 .fini_array : { /* 定义C++析构函数段fini_array */ 43 . = ALIGN(4); /* 4字节对齐 */ 44 __fini_array_start = .; /* 定义变量__fini_array_start为当前地址 */ 45 KEEP (*(.fini_array)) /* 强制链接器保留fini_array段 */ 46 KEEP (*(SORT(.fini_array.*))) /* 强制链接器保留fini_array.*段，并对满足字符串模式的内容进行排序 */ 47 __fini_array_end = .; /* 定义变量__fini_array_end为当前地址 */ 48 } >rom /* C++析构函数段fini_array的程序地址位于rom中 */ 49 50 . = ORIGIN(ram); /* 链接器指针定位于ram区起始地址 */ 51 52 .data : AT(_etext) { /* 定义数据段data，加载地址位于变量_etext定义的位置 */ 53 _data = .; /* 定义变量_data为当前地址 */ 54 *(.data*) /* Read-write initialized data，程序数据段 */ 55 . = ALIGN(4); /* 4字节对齐 */ 56 _edata = .; /* 定义变量_edata为当前地址 */ 57 } >ram /* 数据段data的程序地址位于ram中 */ 58 _data_loadaddr = LOADADDR(.data); /* 定义变量_data_loadaddr为数据段加载地址的起始位置 */ 59 60 .bss : { /* 定义bss段 */ 61 *(.bss*) /* Read-write zero initialized data，程序bss段 */ 62 *(COMMON) /* COMMON段 */ 63 . = ALIGN(4); /* 4字节对齐 */ 64 _ebss = .; /* 定义变量_ebss为当前地址 */ 65 } >ram AT >rom /* bss段的程序地址位于ram中，加载地址位于rom中 */ 66 67 /* 68 * The .eh_frame section appears to be used for C++ exception handling. 69 * You may need to fix this if you're using C++. 70 */ 71 /DISCARD/ : { *(.eh_frame) } /* 被丢弃段eh_frame不会出现在输出文件中 */ 72 73 . = ALIGN(4); /* 4字节对齐 */ 74 end = .; /* 定义变量end为当前地址 */ 75} 76 77PROVIDE(_stack = 0x20020000); /* 定义变量_stack，仅在被使用时生效，堆栈指针指向ram区最高地址 */
4.2 IO协处理器链接脚本stm32f1.ld解析
链接脚本stm32f1.ld与stm32f4.ld情况十分相近，不再复述，这里仅对其进行注释。
stm32f1.ld
1/* Define memory regions. */ 2/* 声明存储区域，分为rom和ram两部分 */ 3MEMORY 4{ 5 rom (rx) : ORIGIN = 0x08000000, LENGTH = 4K /* 定义rom区，即片内flash的部分区域，权限可读可执行，起始于flash起始地址0x08000000，使用前4K（即Page 0~3） */ 6 ram (rwx) : ORIGIN = 0x20000000, LENGTH = 8K /* 定义ram区，即片内SRAM的部分区域，权限可读可写可执行，起始于SRAM1起始地址0x20000000，使用全部8K（注意F100系列片内RAM最高为8K） */ 7} 8 9/* Enforce emmission of the vector table. */ 10/* 声明外部定义的vector_table变量，此变量被定义在libopencm3/lib/cm3/vector.c中 */ 11EXTERN (vector_table) 12 13/* Define sections. */ 14SECTIONS /* 定义段 */ 15{ 16 . = ORIGIN(rom); /* 链接器指针定位于rom区起始地址 */ 17 18 .text : { /* 定义代码段text */ 19 *(.vectors) /* Vector table 中断向量表，定义于libopencm3/lib/cm3/vector.c文件中，仅包含vector_table变量 */ 20 *(.text*) /* Program code 程序代码段 */ 21 . = ALIGN(4); /* 4字节对齐 */ 22 *(.rodata*) /* Read-only data 程序只读数据段 */ 23 . = ALIGN(4); /* 4字节对齐 */ 24 _etext = .; /* 定义变量_etext为当前地址 */ 25 } >rom /* 代码段text的程序地址位于rom中 */ 26 27 /* C++ Static constructors/destructors, also used for __attribute__ 28 * ((constructor)) and the likes */ 29 .preinit_array : { /* 定义C++构造函数段preinit_array */ 30 . = ALIGN(4); /* 4字节对齐 */ 31 __preinit_array_start = .; /* 定义变量__preinit_array_start为当前地址 */ 32 KEEP (*(.preinit_array)) /* 强制链接器保留preinit_array段 */ 33 __preinit_array_end = .; /* 定义变量__preinit_array_end为当前地址 */ 34 } >rom /* C++构造函数段preinit_array的程序地址位于rom中 */ 35 .init_array : { /* 定义C++构造函数段init_array */ 36 . = ALIGN(4); /* 4字节对齐 */ 37 __init_array_start = .; /* 定义变量__init_array_start为当前地址 */ 38 KEEP (*(SORT(.init_array.*))) /* 强制链接器保留init_array.* 段，并对满足字符串模式的内容进行升序排列 */ 39 KEEP (*(.init_array)) /* 强制链接器保留init_array段 */ 40 __init_array_end = .; /* 定义变量__init_array_end为当前地址 */ 41 } >rom /* C++构造函数段init_array的程序地址位于rom中 */ 42 .fini_array : { /* 定义C++析构函数段fini_array */ 43 . = ALIGN(4); /* 4字节对齐 */ 44 __fini_array_start = .; /* 定义变量__fini_array_start为当前地址 */ 45 KEEP (*(.fini_array)) /* 强制链接器保留fini_array段 */ 46 KEEP (*(SORT(.fini_array.*))) /* 强制链接器保留fini_array.* 段，并对满足字符串模式的内容进行升序排列 */ 47 __fini_array_end = .; /* 定义变量__fini_array_end为当前地址 */ 48 } >rom /* C++析构函数段fini_array的程序地址位于rom中 */ 49 50 . = ORIGIN(ram); /* 链接器指针定位于ram区起始地址 */ 51 52 .data : AT(_etext) { /* 定义数据段data，加载地址位于变量_etext定义的位置 */ 53 _data = .; /* 定义变量_data为当前地址 */ 54 *(.data*) /* Read-write initialized data 程序数据段 */ 55 . = ALIGN(4); /* 4字节对齐 */ 56 _edata = .; /* 定义变量_edata为当前地址 */ 57 } >ram /* 数据段data的程序地址位于ram中 */ 58 _data_loadaddr = LOADADDR(.data); /* 定义变量_data_loadaddr为数据段加载地址的起始位置 */ 59 60 .bss : { /* 定义bss段 */ 61 *(.bss*) /* Read-write zero initialized data 程序bss段 */ 62 *(COMMON) /* COMMON段 */ 63 . = ALIGN(4); /* 4字节对齐 */ 64 _ebss = .; /* 定义变量_ebss为当前地址 */ 65 } >ram AT >rom /* bss段的程序地址位于ram中，加载地址位于rom中 */ 66 67 /* 68 * The .eh_frame section appears to be used for C++ exception handling. 69 * You may need to fix this if you're using C++. 70 */ 71 /DISCARD/ : { *(.eh_frame) } /* 被丢弃段eh_frame不会出现在输出文件中 */ 72 73 . = ALIGN(4); /* 4字节对齐 */ 74 end = .; /* 定义变量end为当前地址 */ 75} 76 77PROVIDE(_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
1FLAGS += -mthumb\ #使用thumb指令集 2 -mcpu=cortex-m4\ #使用cortex m4对应的CPU指令 3 -mfloat-abi=hard\ #浮点为硬件浮点运算 4 -mfpu=fpv4-sp-d16 \ #浮点运算协处理器为fpv4-sp-d16 5 -DTARGET_HW_$(TARGET_HW) \ #定义变量TARGET_HW_PX4_FMU_V2为1 6 -DSTM32F4 \ #定义变量STM32F4为1 7 -T$(LINKER_FILE) \ #使用链接文件stm32f4.ld 8 -L$(LIBOPENCM3)/lib \ #添加库文件搜索目录libopencm3/lib 9 -lopencm3_stm32f4 \ #链接库文件libopencm3_stm32f4.a 10 $(EXTRAFLAGS)
hw_config.h文件中对应主控宏TARGET_HW_PX4_FMU_V2的代码如下：
hw_config.h
1#elif defined(TARGET_HW_PX4_FMU_V2) /* 若TARGET_HW_PX4_FMU_V2为真，下面的宏定义有效 */ 2# define APP_LOAD_ADDRESS 0x08004000 /* APP_LOAD_ADDRESS，为Bootloader初始化完成后的飞控固件跳转地址（实际入口地址在0x08004004，这一点在bl.c文件的源代码中可以看到,0x08004000被用于标识后面的代码是否有效） */ 3# define BOOTLOADER_DELAY 5000 /* BOOTLOADER_DELAY，为Bootloader初始化完毕到跳转到飞控固件需等待的时间 */ 4# define BOARD_FMUV2 /* BOARD_FMUV2，在全部代码中没有用到 */ 5# define INTERFACE_USB 1 /* INTERFACE_USB，表示Bootloader可采用USB口与上位机通信 */ 6# define INTERFACE_USART 1 /* INTERFACE_USART，表示Bootloader可采用串口与上位机通信 */ 7# define USBDEVICESTRING "PX4 BL FMU v2.x" /* USBDEVICESTRING，表示对应USB ID的字符串 */ 8# define USBPRODUCTID 0x0011 /* USBPRODUCTID，USB接口的PID */ 9# define BOOT_DELAY_ADDRESS 0x000001a0 /* BOOT_DELAY_ADDRESS，flash上对应存放Bootloader等待时间的内存地址 */ 10 11# define BOARD_TYPE 9 /* BOARD_TYPE，对应不同硬件配置板子上处理器的编号，每个不同的处理器对应不同的值 */ 12# define _FLASH_KBYTES (*(uint16_t *)0x1fff7a22) /* _FLASH_KBYTES，程序运行期间flash以KB计的大小的存储地址（为何位于Reserved地址？） */ 13# define BOARD_FLASH_SECTORS ((_FLASH_KBYTES == 0x400) ? 11 : 23) /* BOARD_FLASH_SECTORS，STM32F4芯片若片内flash为1M，则Sector数量为11；若不为1M（2M），则Sector数量为23，详见芯片手册 */ 14# define BOARD_FLASH_SIZE (_FLASH_KBYTES * 1024) /* BOARD_FLASH_SIZE，flash总大小 */ 15 16# define OSC_FREQ 24 /* OSC_FREQ，外部晶振频率24kHz */ 17 18/* 主控FMU指示灯在板上一共有2个，FMU的PWR和B/E；PWR（LED704）为绿色常亮，上电即亮，B/E（LED701）由FMU的GPIOE12控制，为闪烁红色 */ 19# define BOARD_PIN_LED_ACTIVITY 0 // no activity LED，无命令处理显示LED灯 20# define BOARD_PIN_LED_BOOTLOADER GPIO12 /* BOARD_PIN_LED_BOOTLOADER，主控Bootloader的LED指示灯为GPIOE12 */ 21# define BOARD_PORT_LEDS GPIOE /* BOARD_PORT_LEDS，主控FMU的LED指示灯控制引脚在GPIO Port E */ 22# 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的时钟使能位 */ 23# define BOARD_LED_ON gpio_clear /* BOARD_LED_ON，gpio_clear函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin清零功能 */ 24# define BOARD_LED_OFF gpio_set /* BOARD_LED_OFF，gpio_set函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin置1功能 */ 25 26# define BOARD_USART USART2 /* BOARD_USART，通信串口，USART2被libopencm3/include/libopencm3/stm32/common/usart_common_all.h定义为USART2_BASE（0x40004400） */ 27# define BOARD_USART_CLOCK_REGISTER RCC_APB1ENR /* BOARD_USART_CLOCK_REGISTER，被定义为RCC_APB1ENR寄存器，用于使能USART2的时钟 */ 28# 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的时钟 */ 29 30# define BOARD_PORT_USART GPIOD /* BOARD_PORT_USART，USART2的引脚位于GPIO Port D */ 31# 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 */ 32# define BOARD_PIN_TX GPIO5 /* BOARD_PIN_TX，USART2的发送引脚为GPIOD5 */ 33# define BOARD_PIN_RX GPIO6 /* BOARD_PIN_RX，USART2的接收引脚为GPIOD6 */ 34# define BOARD_USART_PIN_CLOCK_REGISTER RCC_AHB1ENR /* BOARD_USART_PIN_CLOCK_REGISTER，被定义为RCC_AHB1ENR寄存器，用于使能USART2引脚的时钟 */ 35# 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
1FLAGS += -mthumb\ #使用thumb指令集 2 -mcpu=cortex-m3\ #使用cortex m3指令集 3 -DTARGET_HW_$(TARGET_HW) \ #定义TARGET_HW_PX4_PIO_V1变量为1 4 -DSTM32F1 \ #定义STM32F1变量为1 5 -T$(LINKER_FILE) \ #使用链接脚本stm32f1.ld 6 -L$(LIBOPENCM3)/lib \ #增加库文件搜索目录libopencm3/lib 7 -lopencm3_stm32f1 #链接库文件libopencm3_stm32f1.a
hw_config.h文件中对应主控宏TARGET_HW_PX4_PIO_V1的代码如下：
hw_config.h
1#elif defined(TARGET_HW_PX4_PIO_V1) || defined(TARGET_HW_PX4_PIO_V2) /* 若TARGET_HW_PX4_FMU_V2为真，下面的宏定义有效 */ 2 3# define APP_LOAD_ADDRESS 0x08001000 /* APP_LOAD_ADDRESS，为bootloader初始化完成后的飞控固件跳转地址（实际入口地址在0x08001004，这一点在bl.c文件的源代码中可以看到,0x08001000被用于标识后面的代码是否有效） */ 4# define APP_SIZE_MAX 0xf000 /* APP_SIZE_MAX，板载系统程序（Bootloader）大小上限 */ 5# define BOOTLOADER_DELAY 200 /* BOOTLOADER_DELAY，为Bootloader初始化完毕到跳转到飞控固件需等待的时间 */ 6# define BOARD_PIO /* 未见引用 */ 7# define INTERFACE_USB 0 /* INTERFACE_USB，表示Bootloader不能用USB与上位机通信 */ 8# define INTERFACE_USART 1 /* INTERFACE_USART，表示Bootloader可以用串口与上位机通信 */ 9# define USBDEVICESTRING "" /* USBDEVICESTRING，因INTERFACE_USB为0，不使用USB与上位机通信，故USB ID的字符串设置为空 */ 10# define USBPRODUCTID -1 /* USBPRODUCTID，因INTERFACE_USB为0，不使用USB与上位机通信，故USB设备ID设为非法值 */ 11 12# define OSC_FREQ 24 /* OSC_FREQ，外部晶振频率24kHz */ 13 14/* IO协处理器指示灯在板上一共有3个，IO的PWR、B/E和ACT；PWR（LED702）为绿色常亮，上电即亮，B/E（LED703）由IO协处理器的GPIOB15控制，为闪烁红色，ACT（LED705）由IO协处理器的GPIOB14控制，为闪烁蓝色 */ 15# define BOARD_PIN_LED_ACTIVITY GPIO14 /* BOARD_PIN_LED_ACTIVITY，Bootloader有命令要处理时亮起，由IO协处理器的GPIOB14控制 */ 16# define BOARD_PIN_LED_BOOTLOADER GPIO15 /* BOARD_PIN_LED_BOOTLOADER，IO协处理器Bootloader的LED指示灯为GPIOB15 */ 17# define BOARD_PORT_LEDS GPIOB /* BOARD_PORT_LEDS，IO协处理器的LED指示灯控制引脚在GPIO Port B */ 18# define BOARD_CLOCK_LEDS_REGISTER RCC_APB2ENR /* BOARD_CLOCK_LEDS_REGISTER，被定义为RCC_APB2ENR寄存器，用于使能LED时钟 */ 19# 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的时钟使能位 */ 20# define BOARD_LED_ON gpio_clear /* BOARD_LED_ON，gpio_clear函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin清零功能 */ 21# define BOARD_LED_OFF gpio_set /* BOARD_LED_OFF，gpio_set函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中，实际为GPIO pin置1功能 */ 22 23/* IO协处理器的通信串口为USART2，与主控FMU的USART6通信 */ 24# define BOARD_USART USART2 /* BOARD_USART，通信串口，USART2被libopencm3/include/libopencm3/stm32/common/usart_common_all.h定义为USART2_BASE（0x40004400） */ 25# define BOARD_USART_CLOCK_REGISTER RCC_APB1ENR /* BOARD_USART_CLOCK_REGISTER，被定义为RCC_APB1ENR寄存器，用于使能USART2的时钟 */ 26# 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的时钟 */ 27 28# define BOARD_PORT_USART GPIOA /* BOARD_PORT_USART，USART2的引脚位于GPIO Port A */ 29# define BOARD_PIN_TX GPIO_USART2_TX /* BOARD_PIN_TX，GPIO_USART2_TX被libopencm3/include/libopencm3/stm32/f1/gpio.h中定义为GPIO2，PA2 */ 30# define BOARD_PIN_RX GPIO_USART2_RX /* BOARD_PIN_RX，GPIO_USART2_RX被libopencm3/include/libopencm3/stm32/f1/gpio.h中定义为GPIO3，PA3 */ 31# define BOARD_USART_PIN_CLOCK_REGISTER RCC_APB2ENR /* BOARD_USART_PIN_CLOCK_REGISTER，被定义为寄存器RCC_APB2ENR，用于使能USART2引脚的时钟 */ 32# 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的时钟 */ 33 34/* IO协处理器的GPIOB5接J702安全开关 */ 35# define BOARD_FORCE_BL_PIN GPIO5 /* BOARD_FORCE_BL_PIN，板载强制Bootloader引脚为GPIOB5 */ 36# define BOARD_FORCE_BL_PORT GPIOB /* BOARD_FORCE_BL_PIN，板载强制Bootloader引脚在GPIOB中 */ 37# define BOARD_FORCE_BL_CLOCK_REGISTER RCC_APB2ENR /* BOARD_FORCE_BL_CLOCK_REGISTER，被定义为RCC_APB2ENR，用于使能GPIOB5的时钟 */ 38# 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的时钟使能位 */ 39# 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为浮动输入状态，其值取决于外部硬件输入，即安全开关的状态 40# define BOARD_FORCE_BL_VALUE BOARD_FORCE_BL_PIN /* BOARD_FORCE_BL_VALUE，BOARD_FORCE_BL_PIN为GPIO5的值，用于判定IO协处理器是否永远进入Bootloader的循环状态 */ 41 42# define BOARD_FLASH_SECTORS 60 /* BOARD_FLASH_SECTORS，STM32F1片内flash页数，Bootloader认为片内flash的前60页有效 */ 43# define BOARD_TYPE 10 /* BOARD_TYPE，对应不同硬件配置板子上处理器的编号，每个不同的处理器对应不同的值 */ 44# 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
1typedef void (*vector_table_entry_t)(void); /* 定义向量表函数指针类型 */ 2 3typedef struct { 4 unsigned int *initial_sp_value; /* 初始堆栈指针地址 */ 5 vector_table_entry_t reset; /* 重启reset向量函数指针 */ 6 vector_table_entry_t nmi; /* 不可屏蔽中断NMI向量函数指针 */ 7 vector_table_entry_t hard_fault; /* 硬件错误hard_fault向量函数指针 */ 8 vector_table_entry_t memory_manage_fault; /* 内存管理错误memory_manage_fault向量函数指针，Cortex M0核心不含此项 */ 9 vector_table_entry_t bus_fault; /* 总线错误bus_fault向量函数指针，Cortex M0核心不含此项 */ 10 vector_table_entry_t usage_fault; /* 指令使用错误usage_fault向量函数指针，Cortex M0核心不含此项 */ 11 vector_table_entry_t reserved_x001c[4]; /* 预留 */ 12 vector_table_entry_t sv_call; /* 管理模式sv_call向量函数指针 */ 13 vector_table_entry_t debug_monitor; /* 调试监控debug_monitor向量函数指针，Cortex M0核心不含此项（手册显示M4和M3也没有） */ 14 vector_table_entry_t reserved_x0034; /* 预留 */ 15 vector_table_entry_t pend_sv; /* pend_sv向量函数指针 */ 16 vector_table_entry_t systick; /* 系统时钟systick向量函数指针 */ 17 vector_table_entry_t irq[NVIC_IRQ_COUNT]; /* 一般中断irq向量函数指针数组，宏NVIC_IRQ_COUNT被定义为0 */ 18} 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
1__attribute__ ((section(".vectors"))) /* 变量vector_table属于vectors段 * 2vector_table_t vector_table = { 3 .initial_sp_value = &_stack, /* 栈指针指向的地址，_stack在链接脚本中被定义为ram区最高地址 */ 4 .reset = reset_handler, /* 重启reset向量函数，reset_handler被定义在vector.c中 */ 5 .nmi = nmi_handler, /* 不可屏蔽中断nmi向量函数，nmi_handeler在vector.c中被定义为什么都不做的函数null_handler */ 6 .hard_fault = hard_fault_handler, /* 硬件错误hard_fault向量函数，hard_fault_handler在vector.c中被定义为死循环函数blocking_handler */ 7 8/* Those are defined only on CM3 or CM4 */ 9#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) /* 若为CM3和CM4 */ 10 .memory_manage_fault = mem_manage_handler, /* 内存管理错误memory_manage_fault向量函数，mem_manage_handler在vector.c中被定义为死循环函数blocking_handler */ 11 .bus_fault = bus_fault_handler, /* 总线错误bus_fault向量函数，bus_fault_handler在vector.c中被定义为死循环函数blocking_handler */ 12 .usage_fault = usage_fault_handler, /* 指令使用错误usage_fault向量函数，usage_fault_handler在vector.c中被定义为死循环函数blocking_handler */ 13 .debug_monitor = debug_monitor_handler, /* 调试监控debug_monitor向量函数，debug_monitor_handler在vector.c中被定义为什么都不做的函数null_handler */ 14#endif 15 16 .sv_call = sv_call_handler, /* 调试监控debug_monitor向量函数，sv_call_handler在vector.c中被定义为什么都不做的函数null_handler */ 17 .pend_sv = pend_sv_handler, /* pend_sv向量函数，pend_sv_handler在vector.c中被定义为什么都不做的函数null_handler */ 18 .systick = sys_tick_handler, /* 系统时钟systick向量函数，sys_tick_handler在vector.c中被定义为什么都不做的函数null_handler */ 19 /* 由于sys_tick_handler被vector.c定义为弱属性（weak），该函数在bl.c中被重新定义，实际定义在bl.c中。 */ 20 .irq = { 21 IRQ_HANDLERS /* IRQ_HANDLERS，在vector_nvic.c中被定义为空 */ 22 } 23};
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
1struct boardinfo { 2 uint32_t board_type; /* 板载处理器编号 */ 3 uint32_t board_rev; /* 修订版本，程序中几乎没有用到 */ 4 uint32_t fw_size; /* 飞控固件大小的最大值 */ 5 uint32_t systick_mhz; /* 系统时钟的输入值，即CPU主频 */ 6} __attribute__((packed)); /* 编译时使用紧凑数据模式，不进行优化对齐，即使用1字节对齐模式 */
main_f4.c
1struct boardinfo board_info = { 2 .board_type = BOARD_TYPE, /* board_type，BOARD_TYPE板载处理器编号在hw_config.h中定义，主控为9。 */ 3 .board_rev = 0, /* board_rev，修订版本为0 */ 4 .fw_size = 0, /* fw_size，飞控固件大小的最大值，这里的0没有意义，在board_init函数中被重新初始化 */ 5 .systick_mhz = 168, /* systick_mhz，系统时钟输入，即CPU主频168MHz */ 6};
6.2.2 结构体flash_sector
结构体flash_sector用于描述STM32F4芯片内部flash的结构，它被定义并初始化在main_f4.c中。根据芯片手册，STM32F4片内flash大小为1M或2M两种，具体参见芯片手册。
main_f4.c
1static struct { 2 uint32_t sector_number; 3 uint32_t size; 4} flash_sectors[] = { 5 {0x01, 16 * 1024}, 6 {0x02, 16 * 1024}, 7 {0x03, 16 * 1024}, 8 {0x04, 64 * 1024}, 9 {0x05, 128 * 1024}, 10 {0x06, 128 * 1024}, 11 {0x07, 128 * 1024}, 12 {0x08, 128 * 1024}, 13 {0x09, 128 * 1024}, 14 {0x0a, 128 * 1024}, 15 {0x0b, 128 * 1024}, 16 /* flash sectors only in 2MiB devices */ 17 {0x10, 16 * 1024}, 18 {0x11, 16 * 1024}, 19 {0x12, 16 * 1024}, 20 {0x13, 16 * 1024}, 21 {0x14, 64 * 1024}, 22 {0x15, 128 * 1024}, 23 {0x16, 128 * 1024}, 24 {0x17, 128 * 1024}, 25 {0x18, 128 * 1024}, 26 {0x19, 128 * 1024}, 27 {0x1a, 128 * 1024}, 28 {0x1b, 128 * 1024}, 29};
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
1// address of MCU IDCODE 2#define DBGMCU_IDCODE 0xE0042000 3#define STM32_UNKNOWN 0 4#define STM32F40x_41x 0x413 5#define STM32F42x_43x 0x419 6#define STM32F42x_446xx 0x421 7 8typedef struct mcu_des_t { 9 uint16_t mcuid; 10 const char *desc; 11 char rev; 12} mcu_des_t; 13 14mcu_des_t mcu_descriptions[] = { 15 { STM32_UNKNOWN, "STM32F???", '?'}, 16 { STM32F40x_41x, "STM32F40x", '?'}, 17 { STM32F42x_43x, "STM32F42x", '?'}, 18 { STM32F42x_446xx, "STM32F446XX", '?'}, 19};
6.2.4 结构体mcu_rev_t
结构体mcu_rev_t存储了MCU的版本信息，它被定义在main_f4.c文件中，并被实体化为变量数组silicon_revs，此结构除了可以识别处理器版本外，还可以据此判断MCU的内部flash信息。
main_f4.c
1typedef enum mcu_rev_e { /* 版本号枚举定义，感觉不全啊， */ 2 MCU_REV_STM32F4_REV_A = 0x1000, /* REV A for STM32F405/407/415/417/42X/43X */ 3 MCU_REV_STM32F4_REV_Z = 0x1001, /* REV Z for STM32F405/407/415/417 */ 4 MCU_REV_STM32F4_REV_Y = 0x1003, /* REV Y for STM32F42X/43X */ 5 MCU_REV_STM32F4_REV_1 = 0x1007, /* REV 1 for STM32F42X/43X */ 6 MCU_REV_STM32F4_REV_3 = 0x2001 /* REV 3 for STM32F42X/43X */ 7} mcu_rev_e; 8 9typedef struct mcu_rev_t { 10 mcu_rev_e revid; 11 char rev; 12} mcu_rev_t; 13 14const mcu_rev_t silicon_revs[] = { 15 {MCU_REV_STM32F4_REV_3, '3'}, /* Revision 3 */ 16 17 {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) 18 {MCU_REV_STM32F4_REV_Z, 'Z'}, /* Revision Z */ 19 {MCU_REV_STM32F4_REV_Y, 'Y'}, /* Revision Y */ 20 {MCU_REV_STM32F4_REV_1, '1'}, /* Revision 1 */ 21};
6.3 IO协处理器核心数据结构
除向量表vector外，IO协处理器的核心数据结构仅有结构体boardinfo，它表征了IO协处理器的运行状态。它同样定义在bl.h中，在main_f1.c中被初始化。
main_f1.c
1struct boardinfo board_info = { 2 .board_type = BOARD_TYPE, /* board_type，BOARD_TYPE板载处理器编号在hw_config.h中定义，IO协处理器为10。 */ 3 .board_rev = 0, /* board_rev，修订版本为0 */ 4 .fw_size = APP_SIZE_MAX, /* fw_size，APP_SIZE_MAX飞控固件大小的最大值，在hw_config.h中被定义为0xf000，60KB */ 5 .systick_mhz = OSC_FREQ, /* systick_mhz，系统时钟输入等于OSC_FREQ，在hw_config.h中被定义为24MHz */ 6};
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
1/* 变量声明 */ 2extern unsigned _data_loadaddr, _data, _edata, _ebss, _stack; /* 段初始化变量，定义在链接脚本中 */ 3typedef void (*funcp_t) (void); /* 定义函数指针类型funcp_t，其原型为void (*functionname) (void) */ 4extern funcp_t __preinit_array_start, __preinit_array_end; /* C++构造函数地址变量 */ 5extern funcp_t __init_array_start, __init_array_end; /* C++构造函数地址变量 */ 6extern funcp_t __fini_array_start, __fini_array_end; /* C++析构函数地址变量 */ 7 8/* 定义为弱属性，可直接在其他地方重写此函数；定义为裸属性，确保编译器对reset_handler函数不添加任何加载和卸载代码 */ 9void __attribute__ ((weak, naked)) reset_handler(void) 10{ 11 volatile unsigned *src, *dest; 12 funcp_t *fp; 13 14 /* 用数据段存储的参数初始化内存空间，变量定义见链接脚本。 */ 15 /* _data_loadaddr：数据段的起始加载地址，即在flash上的首地址 */ 16 /* _data：数据段的起始运行地址，即在RAM中的首地址 */ 17 /* _edata：数据段的截止运行地址，即在RAM中的末地址 */ 18 for (src = &_data_loadaddr, dest = &_data; dest < &_edata; src++, dest++) { 19 *dest = *src; 20 } 21 22 /* BSS段清零，变量定义见各自的链接脚本 */ 23 /* _ebss：bss段的截止运行地址，其起始运行地址紧接数据段的末地址 */ 24 while (dest < &_ebss) { 25 *dest++ = 0; 26 } 27 28 /* 确保进入异常模式时堆栈指针8字节对齐。此设置对M3和R1架构不起作用 */ 29 SCB_CCR |= SCB_CCR_STKALIGN; 30 31 /* 调用与架构相关的pre_main函数（主控FMU在文件libopencm3/lib/stm32/f4/vector_chipset.c中；IO协处理器在文件libopencm3/lib/cm3/vector.c中，且为空函数）。 */ 32 pre_main(); 33 34 /* 依次调用所有C++定义的构造函数，变量定义见链接脚本。 */ 35 /* __preinit_array_start：preinit_array段首地址 */ 36 /* __preinit_array_end：preinit_array段末地址 */ 37 /* __init_array_start：init_array段首地址 */ 38 /* __init_array_end：init_array段末地址 */ 39 for (fp = &__preinit_array_start; fp < &__preinit_array_end; fp++) { 40 (*fp)(); 41 } 42 for (fp = &__init_array_start; fp < &__init_array_end; fp++) { 43 (*fp)(); 44 } 45 46 /* 调用main函数（主控FMU在文件main_f4.c中，IO协处理器在文件main_f1.c中）。 */ 47 main(); 48 49 /* 依次调用所有C++定义的析构函数，变量定义见链接脚本 */ 50 /* __fini_array_start：fini_array段首地址 */ 51 /* __fini_array_end：fini_array段末地址 */ 52 for (fp = &__fini_array_start; fp < &__fini_array_end; fp++) { 53 (*fp)(); 54 } 55}
本小节结束前，再简单提一下pre_main函数。该函数只对主控FMU有意义，被定义在文件libopencm3/lib/stm32/f4/vector_chipset.c中，IO协处理器中的pre_main是个空函数。
主控FMU的pre_main函数只做了一件事：使能硬件浮点运算
libopencm3/lib/stm32/f4/vector_chipset.c
1static void pre_main(void) 2{ 3 /* 使能硬件浮点运算 */ 4 SCB_CPACR |= SCB_CPACR_FULL * (SCB_CPACR_CP10 | SCB_CPACR_CP11); 5}
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
1#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */ 2# define BOARD_INTERFACE_CONFIG_USART (void *)BOARD_USART /* 宏BOARD_USART定义为USART2，hw_config.h */ 3#endif 4#if INTERFACE_USB /* 宏INTERFACE_USB定义为1，代码有效，hw_config.h */ 5# define BOARD_INTERFACE_CONFIG_USB NULL 6#endif 7 8int main(void) 9{ 10 bool try_boot = true; /* bootloader是否立即跳转到飞控固件入口的标志（不等待timeout） */ 11 unsigned timeout = BOOTLOADER_DELAY; /* bootloader初始化完毕后跳转到飞控固件入口地址时，所需等待的时间，以ms计算。宏BOOTLOADER_DELAY在hw_config.h中被定义为5000 */ 12 13 SCB_CPACR |= ((3UL << 10 * 2) | (3UL << 11 * 2)); /* 使能浮点运算，其功能与pre_main函数相同，实际上可以去掉。 */ 14 15#if defined(BOARD_POWER_PIN_OUT) /* 宏BOARD_POWER_PIN_OUT未定义，下面函数不编译 */ 16 if (board_get_rtc_signature() == POWER_DOWN_RTC_SIGNATURE) { 17 board_set_rtc_signature(0); 18 while (1); 19 } 20#endif 21 22 /* 调用board_init函数，此函数在main_f4.c中被定义，功能如下： */ 23 /* 1. 赋值board_info.fw_size，确定飞控固件size允许的最大值 */ 24 /* 2. 初始化USB端口GPIOA9（VBUS） */ 25 /* 3. 初始化串口USART2 */ 26 /* 4. 初始化LED并点亮（B/E，LED701） */ 27 /* 5. 使能能耗控制器时钟 */ 28 board_init(); 29 30 /* 调用clock_init函数，此函数在main_f4.c中被定义，功能如下： */ 31 /* 1. PLL时钟设置，并选择main PLL作为系统时钟sysclk，fsysclk=fPLL=168MHz，fUSBSDRNG=48MHz */ 32 /* 2. AHB、APB1、APB2时钟设置，fAHB=fsysclk=168MHz，fAPB1=42MHz，fAPB2=84MHz */ 33 /* 3. 选择高能耗模式（Scale 2 mode） */ 34 /* 4. flash访问控制设置，启动Icache和Dcache，并设置等待时间5周期 */ 35 /* 5. 更新库libopencm3中AHB，APB1，APB2对应的全局变量 */ 36 clock_init(); 37 38 /* 检查寄存器BOOT_RTC_REG中的值是否与宏BOOT_RTC_SIGNATURE相同，若相同则停留在bootloader中，若不相同则可以跳转至飞控固件 */ 39 /* BOOT_RTC_REG：RTC_BKPxR的第一个32位寄存器，重启不改变存储值，定义在main_f4.c */ 40 /* BOOT_RTC_SIGNATURE：值0xb007b007，被定义在main_f4.c中 */ 41 /* board_get_rtc_signature：被定义在main_f4.c中，用于获取寄存器BOOT_RTC_REG的存储值 */ 42 /* board_set_rtc_signature：被定义在main_f4.c中，设置寄存器BOOT_RTC_REG的值 */ 43 if (board_get_rtc_signature() == BOOT_RTC_SIGNATURE) { 44 /* bootloader跳转标志为假，不再立即跳转到飞控固件 */ 45 try_boot = false; 46 /* timeout清零，若无新的飞控固件上传，不再跳转至飞控固件 */ 47 timeout = 0; 48 /* 寄存器BOOT_RTC_REG清零，确保下次重启可以跳转至飞控固件 */ 49 board_set_rtc_signature(0); 50 } 51 52#ifdef BOOT_DELAY_ADDRESS /* 宏BOOT_DELAY_ADDRESS在hw_config.h中有定义，下列代码有效 */ 53 { 54 /* 这里给定一个机会，通过飞控固件自身的设置可以影响bootloader的行为。 */ 55 /* 设置地址在0x080041a0和0x080041a4的flash值满足一系列逻辑要求，可以防止bootloader自动跳转到飞控固件，给调试工作带来方便。 */ 56 /* BOOT_DELAY_ADDRESS：值0x000001a0，定义在hw_config.h */ 57 /* flash_func_read_word：定义在main_f4.c，用于读取飞控固件内某地址 */ 58 /* 这里，sig1为flash中地址在0x080041a0的32位值，sig2为flash中地址在0x080041a4的32位地址值，在飞控固件地址范围内 */ 59 uint32_t sig1 = flash_func_read_word(BOOT_DELAY_ADDRESS); 60 uint32_t sig2 = flash_func_read_word(BOOT_DELAY_ADDRESS + 4); 61 62 /* BOOT_DELAY_SIGNATURE1：值0x92c2ecff，定义在bl.h */ 63 /* BOOT_DELAY_SIGNATURE2：值0xc5057d5d，定义在bl.h */ 64 /* BOOT_DELAY_MAX：值30，定义在bl.h */ 65 /* 在满足一系列逻辑下，设定try_boot为假，且重新设置timeout，保证跳转到飞控固件前等待timeout时间 */ 66 if (sig2 == BOOT_DELAY_SIGNATURE2 && (sig1 & 0xFFFFFF00) == (BOOT_DELAY_SIGNATURE1 & 0xFFFFFF00)) { 67 unsigned boot_delay = sig1 & 0xFF; 68 if (boot_delay <= BOOT_DELAY_MAX) { 69 try_boot = false; 70 if (timeout < boot_delay * 1000) { 71 timeout = boot_delay * 1000; 72 } 73 } 74 } 75 } 76#endif 77 78 /* board_test_force_pin：定义在main_f4.c，若bootloader引脚为真，则设置try_boot为假，程序不立即跳转至飞控固件，需等待timeout时间 */ 79 /* 由于函数中条件编译的3个宏（BOARD_FORCE_BL_PIN_OUT、BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN）均未被定义，此函数返回恒为假 */ 80 if (board_test_force_pin()) { 81 try_boot = false; 82 } 83 84 /* 检查USB是否连接，若连接则必须等待timeout再跳转到飞控固件，否则立即跳转。这样的设置为飞控固件烧写以及调试带来极大方便。 */ 85#if INTERFACE_USB /* 宏INTERFACE_USB定义在hw_config.h，以下代码有效 */ 86#if defined(BOARD_USB_VBUS_SENSE_DISABLED) /* 宏BOARD_USB_VBUS_SENSE_DISABLED未定义 */ 87 try_boot = false; 88#else 89 /* GPIOA：地址为0x40020000的寄存器（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 90 /* GPIO9：值1<<9（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 91 /* gpio_get：获取某GPIO组的值，定义在libopencm3/lib/stm32/common/gpio_common_all.c */ 92 /* 根据原理图，GPIOA9对应VBUS/3.1A，高电平表示USB已连接，低电平表示USB未接 */ 93 if (gpio_get(GPIOA, GPIO9) != 0) { 94 /* 设置try_boot为假，bootloader不会立即跳转至飞控固件，需等待timeout时间 */ 95 try_boot = false; 96 } 97#endif 98#endif 99 100 /* 检测串口是否收到break信号（字节0），若收到置try_boot为假，需等待timeout时间再跳转到飞控固件 */ 101#if INTERFACE_USART /* 宏INTERFACE_USB定义在hw_config.h，以下代码有效 */ 102 /* board_test_usart_receiving_break：定义在main_f4.c，连续接收3个字符，若串口上受到字节0则返回真，否则返回假 */ 103 if (board_test_usart_receiving_break()) { 104 try_boot = false; 105 } 106#endif 107 108 /* 若运行到此处try_boot依然为真，则立即跳转到飞控固件（实际上jump_to_app函数代码依然不短，这里可以近似这样认为）； */ 109 /* 若跳转未成功，则设置RTC备份寄存器BOOT_RTC_REG为预定值，确保下次重启若不更新飞控固件依然无法跳转。 */ 110 if (try_boot) { 111#ifdef BOARD_BOOT_FAIL_DETECT /* 宏BOARD_BOOT_FAIL_DETECT未定义，以下代码无效 */ 112 board_set_rtc_signature(BOOT_RTC_SIGNATURE); 113#endif 114 /* jump_to_app：定义在bl.c，跳转到飞控固件 */ 115 jump_to_app(); 116 /* BOOT_RTC_SIGNATURE： */ 117 /* board_set_rtc_signature： */ 118 /* 设置RTC备份寄存器BOOT_RTC_REG值为BOOT_RTC_SIGNATURE，下次重启检测到后若不更新飞控固件则不跳转，程序一直运行在bootloader中。 */ 119 board_set_rtc_signature(BOOT_RTC_SIGNATURE); 120 /* 置timeout为0，程序一直在bootloader中 */ 121 timeout = 0; 122 } 123 124 /* 现在bootloader首次启动飞控固件失败，初始化上位机通信接口（USB和USART2） */ 125#if INTERFACE_USART /* 宏INTERFACE_USART定义在hw_config.h，下列代码有效 */ 126 /* BOARD_INTERFACE_CONFIG_USART：值USART2（值0x40004400，指向USART2寄存器首地址）。 */ 127 /* BOARD_INTERFACE_CONFIG_USART在main_f4.c中被定义为BOARD_USART，BOARD_USART在hw_config.h中被定义为USART2。*/ 128 /* USART2被定义为USART2_BASE，值0x40004400，指向USART2寄存器首地址（libopencm3/include/libopencm3/stm32/common/usart_common_all.h）。 */ 129 /* USART：值1，枚举型，定义在bl.h */ 130 /* cinit：定义在bl.c，用于初始化通信端口 */ 131 /* 初始化串口USART2为与上位机的通信接口 */ 132 cinit(BOARD_INTERFACE_CONFIG_USART, USART); 133#endif 134#if INTERFACE_USB /* 宏INTERFACE_USB定义在hw_config.h，下列代码有效 */ 135 /* BOARD_INTERFACE_CONFIG_USB：值NULL，定义在main_f4.c */ 136 /* USB：值2，枚举型，定义在bl.h */ 137 /* cinit：定义在bl.c，用于初始化通信端口 */ 138 /* 初始化USB为虚拟串口作为与上位机的通信接口 */ 139 cinit(BOARD_INTERFACE_CONFIG_USB, USB); 140#endif 141 142#if 0 /* 下列代码无效 */ 143 // MCO1/02 144 gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8); 145 gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO8); 146 gpio_set_af(GPIOA, GPIO_AF0, GPIO8); 147 gpio_mode_setup(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9); 148 gpio_set_af(GPIOC, GPIO_AF0, GPIO9); 149#endif 150 151 while (1) { 152 /* bootloader：bootloader与上位机的命令处理函数，烧写新的固件或者timeout（不为0）时间到返回，定义在bl.c中 */ 153 bootloader(timeout); 154 155 /* board_test_force_pin：定义在main_f4.c，若bootloader引脚为真，则继续循环 */ 156 /* 由于函数中条件编译的3个宏（BOARD_FORCE_BL_PIN_OUT、BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN）均未被定义，此函数返回恒为假 */ 157 if (board_test_force_pin()) { 158 continue; 159 } 160 161#if INTERFACE_USART /* 宏INTERFACE_USART定义在hw_config.h，下列代码有效 */ 162 /* board_test_usart_receiving_break：连续接收3个字节的内容，如果收到一个0字节则返回真，否则返回假。定义在main_f4.c */ 163 /* 若串口USART2收到break信号（0字节），继续循环 */ 164 if (board_test_usart_receiving_break()) { 165 continue; 166 } 167#endif 168 169#ifdef BOARD_BOOT_FAIL_DETECT /* 宏BOARD_BOOT_FAIL_DETECT未定义，下列代码无效 */ 170 board_set_rtc_signature(BOOT_RTC_SIGNATURE); 171#endif 172 173 /* jump_to_app：跳转至飞控固件 */ 174 jump_to_app(); 175 /* 跳转失败，timeout设置为0，永久停留在bootloader中 */ 176 timeout = 0; 177 } 178}
7.2 IO协处理器的main函数
IO协处理器的主线程序的核心是main函数，它被入口函数reset_handler调用。main函数的主要功能是初始化主控FMU芯片并启动飞控固件；若成功代码将永远运行飞控程序，若失败则可与上位机通信方便调试飞控板。IO协处理器的main函数流程如下：
- 调用board_init函数初始化，包括LED灯、强制Bootloader引脚GPIOB5、准备RTC备份寄存器、设置引脚GPIOA2为USART2-TX
- 判定，若RTC备份寄存器BKP_DR1中存储了预定值，则timeout赋值为200ms
- 若GPIO5为高电平，则timeout赋值为0xffffffff，永久停留在bootloader中
- 若timeout为0，则调用jump_to_app立即启动飞控固件---------------------------------------------启动；若jump_to_app函数返回，则timeout赋值为0
- 现在bootloader首次启动飞控固件失败，初始化系统时钟为PLL（使用HSI）
- 函数初始化串口USART2
- 调用bootloader函数与上位机通信，可运行各种调试命令、烧写新的固件等
- 调用函数jump_to_app启动飞控固件---------------------------------------------跳转，若函数返回（跳转失败）则timeout赋值为0且跳到7步。
值得注意的是，main函数调用的jump_to_app函数依然有很多操作。这部分代码在bl.c文件中定义，其流程具有通用性，但jump_to_app调用的函数又与架构相关，因此这部分将放在后续中。
1#ifdef INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */ 2# define BOARD_INTERFACE_CONFIG (void *)BOARD_USART /* 宏BOARD_USART定义为USART2，hw_config.h */ 3#else 4# define BOARD_INTERFACE_CONFIG NULL 5#endif 6 7int main(void) 8{ 9 unsigned timeout = 0; /* bootloader初始化完毕后跳转到飞控固件入口地址时，所需等待的时间，以ms计算。 */ 10 11 /* 调用board_init函数，此函数在main_f1.c中被定义，功能如下 */ 12 /* 1. 初始化LED控制并点亮LED灯 */ 13 /* 2. 设置强制Bootloader引脚GPIOB5为浮动输入模式，方便采集安全开关的状态 */ 14 /* 3. 使能能源接口时钟和备份接口时钟，准备RTC备份寄存器 */ 15 /* 4. 设置USART2-TX引脚GPIOA2，对应原理图SERIAL_IO_TO_FMU，用于IO协处理器发送信息到主控FMU */ 16 board_init(); 17 18#if defined(INTERFACE_USART) | defined (INTERFACE_USB) /* 宏INTERFACE_USART和INTERFACE_USB分别被定义为1和0，代码有效，hw_config.h */ 19 timeout = BOOTLOADER_DELAY; /* BOOTLOADER_DELAY：值200，表示200ms，hw_config.h */ 20#endif 21 22#ifdef INTERFACE_I2C /* 宏INTERFACE_I2C未定义，代码无效 */ 23# error I2C bootloader detection logic not implemented 24#endif 25 26 /* 若RTC备份寄存器BKP_DR1中存储了预定值，则timeout赋值为200ms */ 27 /* should_wait：判定RTC备份寄存器BKP_DR1中是否存储了预定值。若存储了返回真，未存储则返回假 */ 28 /* BOOTLOADER_DELAY：值200，表示200ms，hw_config.h */ 29 if (should_wait()) { 30 timeout = BOOTLOADER_DELAY; 31 } 32 33#ifdef BOARD_FORCE_BL_PIN /* 宏BOARD_FORCE_BL_PIN定义为GPIO5，代码有效，hw_config.h */ 34 /* 若GPIO5为高电平，则timeout赋值为0xffffffff，永久停留在bootloader中 */ 35 /* BOARD_FORCE_BL_VALUE：被定义为GPIO5（1<<5），hw_config.h */ 36 /* BOARD_FORCE_BL_PORT：被定义为GPIOB（GPIOB的首寄存器），hw_config.h */ 37 /* BOARD_FORCE_BL_PIN：被定义为GPIO5（1<<5），hw_config.h */ 38 /* gpio_get：获取某GPIO组的值，定义在libopencm3/lib/stm32/common/gpio_common_all.c */ 39 if (BOARD_FORCE_BL_VALUE == gpio_get(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN)) { 40 timeout = 0xffffffff; 41 } 42#endif 43 44 /* 若timeout为0，则调用jump_to_app立即启动飞控固件。 */ 45 /* 若jump_to_app函数返回，则timeout赋值为0 */ 46 if (timeout == 0) { 47 jump_to_app(); 48 timeout = 0; 49 } 50 51 /* 初始化系统时钟为PLL（使用HSI） */ 52 /* clock_init：使用HSI将MCU的系统时钟为PLL，频率48MHz，定义在main_f1.c */ 53 clock_init(); 54 55 /* 函数初始化串口USART2 */ 56 /* BOARD_INTERFACE_CONFIG：定义为BOARD_USART（USART2），main_f1.c */ 57 /* USART：值1，枚举型，定义在bl.h中 */ 58 cinit(BOARD_INTERFACE_CONFIG, USART); 59 60 while (1) { 61 /* bootloader：bootloader与上位机的命令处理函数，烧写新的固件或者timeout（不为0）时间到返回，定义在bl.c中 */ 62 bootloader(timeout); 63 /* jump_to_app：跳转至飞控固件 */ 64 jump_to_app(); 65 /* 跳转失败，timeout设置为0，永久停留在bootloader中 */ 66 timeout = 0; 67 } 68}
7.3 飞控固件启动函数jump_to_app
主控FMU或IO协处理器的main函数的一个目标就是调用jump_to_app函数来启动对应的飞控固件。jump_to_app函数定义在文件bl.c中，它的主要功能如下：
- 通过飞控固件的烧写约定，检测固件是否有效。若无效函数返回，跳转失败
- 若飞控固件有效，反向初始化MCU外设，准备将外设的控制权交给飞控固件
- 更改向量表地址至飞控固件的向量表（通过向量表偏移寄存器SCB_VTOR）
- 重置堆栈并跳转至飞控固件
bl.c
1/* do_jump函数，重置堆栈指针并跳转至飞控固件入口的函数，jump_to_app函数的终极目标 */ 2static void do_jump(uint32_t stacktop, uint32_t entrypoint) 3{ 4 /* 汇编嵌入C语言代码 */ 5 asm volatile( /* 汇编代码声明 */ 6 "msr msp, %0 \n" /* msr：无条件赋值指令，msp：主堆栈寄存器，%0：0号输入（stacktop）。将stacktop赋值给msp */ 7 "bx %1 \n" /* bx：寄存器寻址跳转指令，%1：1号输入（entrypoint）。程序跳转至寄存器entrypoint */ 8 : : "r"(stacktop), "r"(entrypoint) :); /* 定义汇编代码中%0代表stacktop，%1代表entrypoint */ 9 10 /* 程序应该不会运行到这里，如果不幸到了，进入死循环 */ 11 for (;;) ; 12} 13 14/* jump_to_app函数 */ 15void jump_to_app() 16{ 17 /* APP_LOAD_ADDRESS，值0x08004000（主控FMU）0x08001000（IO协处理器），飞控固件起始地址（hw_config.h） */ 18 const uint32_t *app_base = (const uint32_t *)APP_LOAD_ADDRESS; 19 20 /* 1. 根据飞控固件的烧写约定，检测固件是否有效 */ 21 /* 飞控固件烧写时，我们特意约定最后烧写固件的首地址（飞控固件使用的堆栈首地址）。若固件首地址为0xffffffff，表明固件烧写未完成（或固件无效）无法跳转，函数直接返回 */ 22 if (app_base[0] == 0xffffffff) { 23 return; 24 } 25 /* 飞控固件的第二个32位代表飞控固件的入口地址。若此地址未在固件指定的地址范围内，则表示固件有问题无法跳转，函数直接返回 */ 26 if (app_base[1] < APP_LOAD_ADDRESS) { 27 return; 28 } 29 if (app_base[1] >= (APP_LOAD_ADDRESS + board_info.fw_size)) { 30 return; 31 } 32 33 /* 2. 现在飞控固件有效，反向初始化以便把外设控制权交给飞控固件 */ 34 /* flash_lock：主控FMU，锁定flash，操作寄存器FLASH_CR的域LOCK（bit31），定义libopencm3/lib/stm32/common/flash_common_f234.c */ 35 /* flash_lock：IO协处理器，锁定flash，操作寄存器FLASH_CR的域LOCK（bit7），定义libopencm3/lib/stm32/common/flash_common_f01.c */ 36 /* bootloader程序中可能解锁flash进行固件烧写功能，这里确保flash上锁 */ 37 flash_lock(); 38 /* 关闭systick中断 */ 39 systick_interrupt_disable(); /* 关闭systick中断（libopencm3/lib/cm3/systick.c） */ 40 systick_counter_disable(); /* systick倒计时关闭（libopencm3/lib/cm3/systick.c） */ 41 /* 关闭串口USART2和USB虚拟串口，配置不变 */ 42 /* cfini：串口反向初始化函数，即关闭串口和USB虚拟串口，定义在main_f?.c */ 43 cfini(); 44 /* 关闭时钟源，将所有内部时钟设置为重启后的初始状态 */ 45 /* clock_deinit：时钟反向初始化函数，定义在main_f?.c */ 46 clock_deinit(); 47 /* 反向初始化板载外设（包括USART2、LED控制） */ 48 /* board_deinit：板载外设反向初始化函数，定义在main_f?.c */ 49 board_deinit(); 50 51 /* 3. 更改向量表地址至飞控固件的向量表 */ 52 /* SCB_VTOR：寄存器，向量表偏移地址，地址0xE000ED08 */ 53 /* APP_LOAD_ADDRESS：飞控固件起始地址。0x08004000（主控FMU），0x08001000（IO协处理器） */ 54 SCB_VTOR = APP_LOAD_ADDRESS; 55 56 /* 4. 重置堆栈并跳转至飞控固件 */ 57 do_jump(app_base[0], app_base[1]); 58}
7.4 命令处理函数bootloader
主控FMU或IO协处理器的main函数调用jump_to_app函数失败（返回）后，就会调用bootloader函数来与上位机进行通信，bootloader定义在文件bl.c中，它的主要功能如下：
- 1.（重新）启动systick定时器和中断，周期为1ms
- 2.若timeout不为0，启动0号时钟（TIMER_BL_WAIT），周期为timeout，单位ms
- 3.设置闪烁B/E LED灯（主控FMU为LED701，IO协处理器为LED703）
- 4.进入命令处理循环
- 4.1 关闭ACT LED灯（主控FMU没有，IO协处理器为LED705）
- 4.2 死循环读取串口数据（1字节），只有读到数据方可跳出循环；此处判断timeout有效且到时函数返回----------------------------------->bootloader函数返回
- 4.3 读到串口数据（命令），开启ACT LED灯
- 4.4 处理获取到的指令字
- （1）若为同步命令PROTO_GET_SYNC
- 指令非法跳转到cmd_bad
- 运行正常跳转4.5
- （2）若为获取设备ID命令PROTO_GET_DEVICE
- 指令非法跳转到cmd_bad
- 运行正常输出信息并跳转到4.5
- （3）若为擦除flash与准备烧写飞控固件指令PROTO_CHIP_ERASE
- 指令非法跳转到cmd_bad
- 芯片版本错误跳转到bad_silicon
- 运行错误跳转到cmd_fail
- 运行正常跳转到4.5
- （4）若为flash烧写命令PROTO_PROG_MULTI
- 指令非法跳转到cmd_bad
- 芯片版本错误跳转到bad_silicon
- 运行错误跳转到cmd_fail
- 运行正常跳转到4.5
- （5）若为CRC32校验命令PROTO_GET_CRC
- 指令非法跳转到cmd_bad
- 运行正常输出校验值并跳转到4.5
- （6）若为读取OTP区域命令PROTO_GET_OTP
- 指令非法跳转到cmd_bad
- 运行正常输出OTP区信息并跳转到4.5
- （7）若为获取MCU的UDID PROTO_GET_SN
- 指令非法跳转到cmd_bad
- 运行正常输出UDID并跳转到4.5
- （8）若为获取芯片ID和版本信息PROTO_GET_CHIP
- 指令非法跳转到cmd_bad
- 运行正常输出芯片ID和版本信息并跳转到4.5
- （9）若为获取芯片描述信息PROTO_GET_CHIP_DES
- 指令非法跳转到cmd_bad
- 运行正常输出芯片描述信息（长度+信息本身）并跳转到4.5
- （10）若为设置飞控固件启动延时PROTO_SET_DELAY
- 指令非法跳转到cmd_bad
- 运行错误跳转到cmd_fail
- 运行正常跳转到4.5
- （11）若为完成烧写并启动飞控固件PROTO_BOOT
- 指令非法跳转到cmd_bad
- 运行错误跳转到cmd_fail
- 运行正常发送PROTO_INSYNC+PROTO_OK，等待100ms，函数返回----------------------------------->bootloader函数返回
- （12）若为输出调试信息（命令暂未完成）PROTO_DEBUG
- 跳转至4.5
- 若为其他指令字
- 跳转至4
- （1）若为同步命令PROTO_GET_SYNC
- 4.5 命令处理完毕，运行成功后的处理，发送PROTO_INSYNC+PROTO_OK，跳转至4
- cmd_bad：指令非法，发送PROTO_INSYNC+PROTO_INVALID，跳转至4
- cmd_fail：指令错误，发送PROTO_INSYNC+PROTO_FAILED，跳转至4
- bad_silicon：芯片版本错误，发送PROTO_INSYNC+PROTO_BAD_SILICON_REV，跳转至4
bl.c
1#define BL_PROTOCOL_VERSION 5 /* Bootloader协议版本信息 */ 2/* 协议字 */ 3#define PROTO_INSYNC 0x12 /* 同步字 */ 4#define PROTO_EOC 0x20 /* 命令终止字 */ 5/* 回告字（https://pixhawk.org/help/errata） */ 6#define PROTO_OK 0x10 /* 指令运行成功回告字 */ 7#define PROTO_FAILED 0x11 /* 指令运行错误回告字 */ 8#define PROTO_INVALID 0x13 /* 非法指令回告字 */ 9#define PROTO_BAD_SILICON_REV 0x14 /* 主控MCU（F4芯片）版本错误回告字 */ 10/* 命令字 */ 11#define PROTO_GET_SYNC 0x21 /* 获取同步命令 */ 12#define PROTO_GET_DEVICE 0x22 /* 获取设备ID命令 */ 13#define PROTO_CHIP_ERASE 0x23 /* 擦除flash与准备烧写飞控固件命令 */ 14#define PROTO_PROG_MULTI 0x27 /* 烧写flash命令 */ 15#define PROTO_GET_CRC 0x29 /* 计算CRC32校验命令 */ 16#define PROTO_GET_OTP 0x2a /* 读取OTP区域某地址的1字节 */ 17#define PROTO_GET_SN 0x2b /* 读取MCU的UDID（Unique Device ID） */ 18#define PROTO_GET_CHIP 0x2c /* 读取芯片ID和版本 */ 19#define PROTO_SET_DELAY 0x2d /* 设置飞控固件启动等待时间 */ 20#define PROTO_GET_CHIP_DES 0x2e /* 获取芯片描述信息 */ 21#define PROTO_BOOT 0x30 /* 完成烧写并启动飞控固件 */ 22#define PROTO_DEBUG 0x31 /* 输出调试信息（未完成） */ 23 24/* 命令PROTO_GET_DEVICE后跟的参数 */ 25#define PROTO_DEVICE_BL_REV 1 /* Bootloader协议版本 */ 26#define PROTO_DEVICE_BOARD_ID 2 /* 板载处理器编号 */ 27#define PROTO_DEVICE_BOARD_REV 3 /* 修订版本 */ 28#define PROTO_DEVICE_FW_SIZE 4 /* 飞控固件大小的最大值 */ 29#define PROTO_DEVICE_VEC_AREA 5 /* 飞控固件向量表7-10项的函数地址（debug_monitor、sv_call、pend_sv、systick） */ 30 31/* 全局变量 */ 32volatile unsigned timer[NTIMERS]; /* NTIMERS：值4，通用倒计时器数量，定义在bl.h；timer：通用计时器数组变量 */ 33static enum led_state {LED_BLINK, LED_ON, LED_OFF} _led_state; /* _led_state：LED状态枚举型变量 */ 34static uint8_t bl_type; /* bl_type：接口类型静态全局变量，被bootloader函数定义 */ 35static uint8_t last_input; /* last_input：静态全局变量，上次获取串口数据的方式 */ 36static volatile unsigned cin_count; /* cin_count：串口和USB虚拟串口接收到的数据数量，全局变量 */ 37 38/* BL_PROTOCOL_VERSION：值5，表示Bootloader协议版本 */ 39static const uint32_t bl_proto_rev = BL_PROTOCOL_VERSION; /* bl_proto_rev：全局变量，存储Bootloader的版本号，是获取设备ID命令参数PROTO_DEVICE_BL_REV的回告值 */ 40 41/* 根据输入设置LED状态的函数，被bootloader函数调用，功能如下： */ 42/* 若输入为LED_OFF，则关闭B/E LED灯 */ 43/* 若输入为LED_ON，则关闭B/E LED灯 */ 44/* 若输入为LED_BLINK，则2号计时器（TIMER_LED）清零，systick中断函数立即，准备闪烁B/E LED灯 */ 45static void led_set(enum led_state state) 46{ 47 /* 更改全局变量_led_state为当前LED状态 */ 48 _led_state = state; 49 50 /* LED_OFF：值2，led_state枚举型，定义在bl.c */ 51 /* LED_ON：值1，led_state枚举型，定义在bl.c */ 52 /* LED_BLINK：值0，led_state枚举型，定义在bl.c */ 53 /* LED_BOOTLOADER：值2，定义在bl.h */ 54 /* TIMER_LED：值2，定义在bl.h */ 55 /* timer：通用计时器数组变量，定义在bl.c */ 56 /* led_off：关闭LED灯，定义在main_f?.c */ 57 /* led_on：开启LED灯，定义在main_f?.c */ 58 switch (state) { 59 case LED_OFF: 60 led_off(LED_BOOTLOADER); 61 break; 62 case LED_ON: 63 led_on(LED_BOOTLOADER); 64 break; 65 case LED_BLINK: 66 timer[TIMER_LED] = 0; 67 break; 68 } 69} 70 71 72/* systick时钟的中断处理函数，向量表中systick域的赋值在libopencm3/lib/cm3/vector.c */ 73void sys_tick_handler(void) 74{ 75 unsigned i; 76 77 /* tick到来，各时钟减1 */ 78 /* NTIMERS：值4，通用倒计时器数量，定义在bl.h */ 79 /* timer：通用计时器数组变量，定义在bl.c */ 80 for (i = 0; i < NTIMERS; i++) 81 if (timer[i] > 0) { 82 timer[i]--; 83 } 84 85 /* 处理B/E LED（主控FMU为LED701，IO协处理器为LED703）闪烁功能 */ 86 /* 时钟设为50ms，每个周期就是100ms。 */ 87 /* _led_state：全局LED状态枚举（led_state枚举型）变量，存储B/E LED的状态，定义在bl.c */ 88 /* TIMER_LED：值2，定义在bl.h */ 89 /* LED_BLINK：值0，led_state枚举型，定义在bl.c */ 90 /* LED_BOOTLOADER：值2，定义在bl.h */ 91 /* led_toggle：使输入的LED反向，定义在main_f?.c */ 92 if ((_led_state == LED_BLINK) && (timer[TIMER_LED] == 0)) { 93 led_toggle(LED_BOOTLOADER); 94 timer[TIMER_LED] = 50; 95 } 96} 97 98 99/* 延时函数，被bootloader函数调用 */ 100void delay(unsigned msec) 101{ 102 /* timer：通用计时器数组变量，定义在bl.c */ 103 /* TIMER_DELAY：值3，定义在bl.h */ 104 timer[TIMER_DELAY] = msec; 105 /* 若TIMER_DELAY时钟未到，一直停留在此函数中，确保延时 */ 106 while (timer[TIMER_DELAY] > 0); 107} 108 109 110/* 获取串口数据函数，可为USART和USB虚拟串口 */ 111inline int cin(void) 112{ 113#if INTERFACE_USB /* 对主控FMU，宏INTERFACE_USART定义为1，代码有效，hw_config.h */ 114 /* 对IO协处理器，宏INTERFACE_USART定义为0，代码无效，hw_config.h */ 115 /* 通过串口获取调试数据，若返回的数据值有效（>=0），则返回获取的数据值，并更新全局变量last_input */ 116 /* NONE：值0，枚举类，定义在bl.h */ 117 /* USB：值2，枚举类，定义在bl.h */ 118 /* bl_type：输入接口类型全局静态变量，被bootloader函数赋值 */ 119 /* last_input：全局变量上次获取串口数据的方式 */ 120 /* usb_cin：从USB模拟串口读入1个字，定义在cdcacm.c */ 121 if (bl_type == NONE || bl_type == USB) { 122 int usb_in = usb_cin(); 123 if (usb_in >= 0) { 124 last_input = USB; 125 return usb_in; 126 } 127 } 128#endif 129#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */ 130 /* 通过串口获取调试数据，若返回的数据值有效（>=0），则返回获取的数据值，并更新全局变量last_input */ 131 /* NONE：值0，枚举类，定义在bl.h */ 132 /* USART：值1，枚举类，定义在bl.h */ 133 /* bl_type：输入接口类型全局静态变量，被bootloader函数赋值 */ 134 /* last_input：全局变量上次获取串口数据的方式 */ 135 /* uart_cin：从串口读入1个字，定义在usart.c */ 136 if (bl_type == NONE || bl_type == USART) { 137 int uart_in = uart_cin(); 138 if (uart_in >= 0) { 139 last_input = USART; 140 return uart_in; 141 } 142 } 143#endif 144 return -1; /* 返回错误 */ 145} 146 147 148/* 串口或模拟串口输出特定内容的函数 */ 149inline void cout(uint8_t *buf, unsigned len) 150{ 151#if INTERFACE_USB /* 对主控FMU，宏INTERFACE_USART定义为1，代码有效，hw_config.h */ 152 /* 对IO协处理器，宏INTERFACE_USART定义为0，代码无效，hw_config.h */ 153 /* USB：值2，枚举类，定义在bl.h */ 154 /* bl_type：启动接口类型全局静态变量，被bootloader函数赋值 */ 155 /* usb_cout：USB模拟串口输出特定内容的函数，定义在usart.c */ 156 if (bl_type == USB) { 157 usb_cout(buf, len); 158 } 159 160#endif 161#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效，hw_config.h */ 162 /* USART：值1，枚举类，定义在bl.h */ 163 /* bl_type：启动接口类型全局静态变量，被bootloader函数赋值 */ 164 /* uart_cout：USART串口输出特定内容的函数，定义在usart.c */ 165 if (bl_type == USART) { 166 uart_cout(buf, len); 167 } 168#endif 169} 170 171 172/* 发送同步命令函数，是bootloader函数中命令运行成功后调用的函数 */ 173static void sync_response(void) 174{ 175 /* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */ 176 /* PROTO_OK：值0x10，指令运行成功回告字，定义在bl.c */ 177 /* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */ 178 uint8_t data[] = { 179 PROTO_INSYNC, 180 PROTO_OK 181 }; 182 cout(data, sizeof(data)); 183} 184 185 186/* 当MCU型号错误处理函数，串口或USB模拟串口输出非法响应（PROTO_INSYNC+PROTO_BAD_SILICON_REV），是bootloader函数中bad_silicon标号对应的函数 */ 187#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.f4 */ 188 /* 对IO协处理器，TARGET_HW_PX4_FMU_V4未定义，代码无效 */ 189static void bad_silicon_response(void) 190{ 191 /* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */ 192 /* PROTO_BAD_SILICON_REV：值0x14，主控MCU型号错误命令字，定义在bl.c */ 193 /* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */ 194 uint8_t data[] = { 195 PROTO_INSYNC, 196 PROTO_BAD_SILICON_REV 197 }; 198 cout(data, sizeof(data)); 199} 200#endif 201 202 203/* 当指令非法时的处理函数，串口或USB模拟串口输出非法响应（PROTO_INSYNC+PROTO_INVALID），是bootloader函数中cmd_bad标号对应的函数 */ 204static void invalid_response(void) 205{ 206 /* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */ 207 /* PROTO_INVALID：值0x13，非法指令字，定义在bl.c */ 208 /* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */ 209 uint8_t data[] = { 210 PROTO_INSYNC, 211 PROTO_INVALID 212 }; 213 cout(data, sizeof(data)); 214} 215 216 217/* 当指令运行失败时的处理函数，串口或USB模拟串口输出运行失败响应（PROTO_INSYNC+PROTO_FAILED），是bootloader函数中cmd_fail标号对应的函数 */ 218static void failure_response(void) 219{ 220 /* PROTO_INSYNC：值0x12，同步指令字，定义在bl.c */ 221 /* PROTO_FAILED：值0x11，运行失败指令字，定义在bl.c */ 222 /* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */ 223 uint8_t data[] = { 224 PROTO_INSYNC, 225 PROTO_FAILED 226 }; 227 cout(data, sizeof(data)); 228} 229 230 231/* 在给定的时间timeout内读到串口数据，则返回数据；若超时返回-1 */ 232static int cin_wait(unsigned timeout) 233{ 234 int c = -1; 235 236 /* 设置1号定时器（TIMER_CIN）周期为输入值（此处为0） */ 237 /* TIMER_CIN：值1，定义在bl.h */ 238 /* timer：通用计时器数组变量，定义在bl.c */ 239 timer[TIMER_CIN] = timeout; 240 241 /* 一直读取串口获得数据。若要返回，或者读取到数据，或者若定时器（TIMER_CIN）到时。 */ 242 /* cin_count：串口和USB虚拟串口接收到的数据总量，定义在bl.c */ 243 /* cin：获取串口数据函数，定义在bl.c */ 244 do { 245 c = cin(); 246 if (c >= 0) { 247 cin_count++; 248 break; 249 } 250 } while (timer[TIMER_CIN] > 0); 251 252 return c; 253} 254 255 256/* 串口或USB模拟串口输出1个字 */ 257static void cout_word(uint32_t val) 258{ 259 /* cout：串口或模拟串口输出特定内容的函数，定义在bl.c */ 260 cout((uint8_t *)&val, 4); 261} 262 263 264/* 串口或USB模拟串口读入1个字，具有超时检测功能 */ 265static int cin_word(uint32_t *wp, unsigned timeout) 266{ 267 /* 由于USB串口每次只能读入1字节，而结果需要的是1个字，故定义联合体u长度4字节适用于两种操作 */ 268 union { 269 uint32_t w; 270 uint8_t b[4]; 271 } u; 272 273 /* 连续4此读取串口，并将其拼接成1个字（小端）；若读取过程中超时则返回-1 */ 274 /* cin_wait：在给定的时间timeout内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */ 275 for (unsigned i = 0; i < 4; i++) { 276 int c = cin_wait(timeout); 277 if (c < 0) { 278 return c; 279 } 280 u.b[i] = c & 0xff; 281 } 282 283 *wp = u.w; 284 return 0; 285} 286 287 288/* 在给定的等待时间内，下一条获取到的命令是否为终止字PROTO_EOC；若是返回真，不是返回假 */ 289inline static bool wait_for_eoc(unsigned timeout) 290{ 291 /* PROTO_EOC：值0x20，命令终止字，定义在bl.c */ 292 /* cin_wait：在给定的输入时间内读到串口数据，则返回数据；若超时返回-1，bl.c */ 293 return cin_wait(timeout) == PROTO_EOC; 294} 295 296 297/* 给出数据src的crc32校验结果 */ 298static uint32_t crc32(const uint8_t *src, unsigned len, unsigned state) 299{ 300 static uint32_t crctab[256]; 301 302 /* 检查是否已生成crc32校验表（按照定义肯定是未生成的），若未生成则立刻生成 */ 303 if (crctab[1] == 0) { 304 for (unsigned i = 0; i < 256; i++) { 305 uint32_t c = i; 306 for (unsigned j = 0; j < 8; j++) { 307 if (c & 1) { 308 c = 0xedb88320U ^ (c >> 1); 309 } else { 310 c = c >> 1; 311 } 312 } 313 crctab[i] = c; 314 } 315 } 316 317 /* 对于从src开始的len长度字节进行crc32校验 */ 318 for (unsigned i = 0; i < len; i++) { 319 state = crctab[(state ^ src[i]) & 0xff] ^ (state >> 8); 320 } 321 322 return state; 323} 324 325 326void bootloader(unsigned timeout) 327{ 328 /* bl_type：全局接口类型变量。NONE：值0，枚举类，定义在bl.h */ 329 /* 若使bootloader实际上能够起作用，必须设置bl_type的类型，不能按照默认值NONE */ 330 bl_type = NONE; 331 332 uint32_t address = board_info.fw_size; /* flash当前编写逻辑地址变量，初始化为board_info.fw_size，确保在不执行擦除条件下无法编写 */ 333 uint32_t first_word = 0xffffffff; 334 335 /* 1.（重新）启动systick定时器和中断，周期为1ms */ 336 /* STK_CSR_CLKSOURCE_AHB：值1<<2，选取AHB作为systick的时钟源，libopencm3/include/libopencm3/cm3/systick.h */ 337 /* board_info.systick_mhz：值168（主控FMU，main_f4.c），24（IO协处理器，main_f1.c） */ 338 /* systick_set_clocksource：选取systick的时钟源，libopencm3/lib/cm3/systick.c */ 339 /* systick_set_reload：设置systick时钟倒计时（寄存器STK_VAL），libopencm3/lib/cm3/systick.c */ 340 /* systick_interrupt_enable：开启systick中断，libopencm3/lib/cm3/systick.c */ 341 /* systick_counter_enable：systick倒计时开启，libopencm3/lib/cm3/systick.c */ 342 systick_set_clocksource(STK_CSR_CLKSOURCE_AHB); 343 systick_set_reload(board_info.systick_mhz * 1000); /* 1ms tick, magic number */ 344 systick_interrupt_enable(); 345 systick_counter_enable(); 346 347 /* 2. 若timeout不为0，启动0号时钟（TIMER_BL_WAIT），周期为timeout，单位ms */ 348 /* timeout为0则不启动时钟，永远停留在本函数中 */ 349 /* TIMER_BL_WAIT：值0，定义在bl.h */ 350 /* timer：unsigned型全局数组，成员有4个，定义在bl.c */ 351 if (timeout) { 352 timer[TIMER_BL_WAIT] = timeout; 353 } 354 355 /* 3. 设置闪烁B/E LED灯（主控FMU为LED701，IO协处理器为LED703） */ 356 /* B/E LED灯闪烁表示程序处于闲置状态，通过systick时钟的中断处理函数来实现 */ 357 /* LED_BLINK：值0，led_state枚举成员，定义在bl.c */ 358 /* led_set：LED灯状态设置函数，定义在bl.c */ 359 led_set(LED_BLINK); 360 361 /* 4. 进入命令处理循环 */ 362 while (true) { 363 volatile int c; 364 int arg; 365 static union { 366 uint8_t c[256]; 367 uint32_t w[64]; 368 } flash_buffer; 369 370 /* 4.1 关闭ACT LED灯（主控FMU没有，IO协处理器为LED705） */ 371 /* LED_ACTIVITY：值1，led_state枚举成员，定义在bl.c */ 372 /* led_off：关闭LED灯，定义在main_f?.c */ 373 led_off(LED_ACTIVITY); 374 375 /* 4.2 死循环读取串口数据（1字节），只有读到数据方可跳出循环 */ 376 do { 377 /* 若timeout非零，0号时钟（TIMER_BL_WAIT）倒计时至0，则timeout时间到返回。 */ 378 /* TIMER_BL_WAIT：值0，定义在bl.h */ 379 /* timeout：bootloader跳转到飞控固件所需等待的时间，bootloader函数输入 */ 380 /* timer：通用计时器数组变量，定义在bl.c */ 381 if (timeout && !timer[TIMER_BL_WAIT]) { 382 return; 383 } 384 /* 不等待，立即读取串口一个数据（cin_wait输入为0） */ 385 /* cin_wait：在给定的输入时间timeout内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */ 386 c = cin_wait(0); 387 } while (c < 0); 388 389 /* 4.3 读到串口数据（命令），开启ACT LED灯 */ 390 /* LED_ACTIVITY：值1，led_state枚举成员，定义在bl.c */ 391 /* led_off：开启LED灯，定义在main_f?.c */ 392 led_on(LED_ACTIVITY); 393 394 /* 4.4 处理获取到的命令字 */ 395 switch (c) { 396 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 397 /* (1) 同步命令PROTO_GET_SYNC（0x21），命令结构PROTO_GET_SYNC+PROTO_EOC */ 398 /* * 收到PROTO_GET_SYNC的2ms内未接收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 399 /* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 400 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 401 /* 接收到同步命令PROTO_GET_SYNC的2ms内位需收到终止字PROTO_EOC（0x20），否则进行错误指令处理 */ 402 /* PROTO_GET_SYNC：值0x21，同步命令字，定义在bl.c */ 403 /* PROTO_EOC：值0x20，命令终止字，定义在bl.c */ 404 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 405 case PROTO_GET_SYNC: 406 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为终止字PROTO_EOC；若是返回真，不是返回假 */ 407 /* cmd_bad：标号 */ 408 if (!wait_for_eoc(2)) { 409 goto cmd_bad; 410 } 411 break; 412 413 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 414 /* （2）获取设备ID命令PROTO_GET_DEVICE（0x22），它后面通常还会跟随一个参数（用于指示具体获取设备的哪个内容），命令结构：PROTO_GET_DEVICE+arg(1byte)+PROTO_EOC */ 415 /* * 若为无效参数或参数后2ms内未接收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 416 /* * 若为PROTO_DEVICE_BL_REV（值1），则返回bootloader协议版本号BL_PROTOCOL_VERSION（值5），回告结构：rev(4byte)+(PROTO_INSYNC+PROTO_OK) */ 417 /* * 若为PROTO_DEVICE_BOARD_ID（值2），则返回板载处理器编号board_info.board_type（BOARD_TYPE，主控FMU值9，IO协处理器值10），回告结构：board_type(4byte)+(PROTO_INSYNC+PROTO_OK) */ 418 /* * 若为PROTO_DEVICE_BOARD_REV（值3），则返回修订版本board_info.board_rev（值0），回告结构：board_rev(4byte)+(PROTO_INSYNC+PROTO_OK) */ 419 /* * 若为PROTO_DEVICE_FW_SIZE（值4），则返回飞控固件的最大值（单位KB）board_info.fw_size（主控值2000，IO协处理器APP_SIZE_MAX=0xf000），回告结构：fw_size(4byte)+(PROTO_INSYNC+PROTO_OK) */ 420 /* * 若为PROTO_DEVICE_VEC_AREA（值5），则返回飞控固件向量表7-10项的函数地址（debug_monitor、sv_call、pend_sv、systick），回告结构：vectors(4*4byte)+(PROTO_INSYNC+PROTO_OK) */ 421 /* * 若为其他参数，则进行非法指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 422 /* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 423 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 424 case PROTO_GET_DEVICE: /* PROTO_GET_DEVICE：值0x22，获取设备ID命令，定义在bl.c */ 425 /* cin_wait：在给定的1s时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */ 426 arg = cin_wait(1000); 427 /* 判定若获取的参数无效（<0）或获取到命令终止，则返回报错 */ 428 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 429 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 430 if (arg < 0) { 431 goto cmd_bad; 432 } 433 if (!wait_for_eoc(2)) { 434 goto cmd_bad; 435 } 436 /* 判定命令PROTO_GET_DEVICE的参数 */ 437 /* PROTO_DEVICE_BL_REV：值1，命令PROTO_GET_DEVICE的参数，表示获取Bootloader协议版本，定义在bl.c */ 438 /* PROTO_DEVICE_BOARD_ID：值2，命令PROTO_GET_DEVICE的参数，表示获取板载处理器编号（对应board_info.board_type=BOARD_TYPE），定义在bl.c */ 439 /* PROTO_DEVICE_BOARD_REV：值3，命令PROTO_GET_DEVICE的参数，表示获取修订版本（对应board_info.board_rev=0），定义在bl.c */ 440 /* PROTO_DEVICE_FW_SIZE：值4，命令PROTO_GET_DEVICE的参数，表示飞控固件的最大值（对应board_info.fw_size），定义在bl.c */ 441 /* PROTO_DEVICE_VEC_AREA：值5，命令PROTO_GET_DEVICE的参数，表示获取飞控固件向量表7-10项的函数地址（debug_monitor、sv_call、pend_sv、systick），定义在bl.c */ 442 /* bl_proto_rev：全局变量，存储Bootloader的版本号（BL_PROTOCOL_VERSION值5），是获取设备ID命令参数PROTO_DEVICE_BL_REV的回告值，定义在bl.c */ 443 /* cout：串口（包括USB虚拟串口）输出特定内容的函数，定义在bl.c */ 444 /* flash_func_read_word：读取flash特定地址1个字的函数，定义在main_f?.c */ 445 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 446 switch (arg) { 447 case PROTO_DEVICE_BL_REV: 448 cout((uint8_t *)&bl_proto_rev, sizeof(bl_proto_rev)); 449 break; 450 case PROTO_DEVICE_BOARD_ID: 451 cout((uint8_t *)&board_info.board_type, sizeof(board_info.board_type)); 452 break; 453 case PROTO_DEVICE_BOARD_REV: 454 cout((uint8_t *)&board_info.board_rev, sizeof(board_info.board_rev)); 455 break; 456 case PROTO_DEVICE_FW_SIZE: 457 cout((uint8_t *)&board_info.fw_size, sizeof(board_info.fw_size)); 458 break; 459 case PROTO_DEVICE_VEC_AREA: 460 for (unsigned p = 7; p <= 10; p++) { 461 uint32_t bytes = flash_func_read_word(p * 4); 462 cout((uint8_t *)&bytes, sizeof(bytes)); 463 } 464 break; 465 default: 466 goto cmd_bad; 467 } 468 break; 469 470 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 471 /* （3）擦除flash与准备烧写飞控固件指令PROTO_CHIP_ERASE（0x23），命令结构：PROTO_CHIP_ERASE+PROTO_EOC */ 472 /* * 收到PROTO_CHIP_ERASE的2ms内未收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ */ 473 /* * 若为主控FMU芯片（F4），调用check_silicon函数判断MCU版本是否正确（是否为revision 3） */ 474 /* * 若主控FMU版本不正确（revision 3以下），跳转进行bad_silicon处理，回告结构：(PROTO_INSYNC+PROTO_BAD_SILICON_REV) */ 475 /* * 点亮B/E灯，指示正在擦除flash，逐段、页（sector）擦除flash */ 476 /* * 关闭B/E灯，指示擦除flash已完成，取每KB的首字检查flash擦除操作是否成功 */ 477 /* * 若flash擦除操作失败，进行指令运行失败处理，回告结构：(PROTO_INSYNC+PROTO_FAILED) */ 478 /* * 重置flash编写逻辑地址变量address为0，恢复B/E灯闪烁 */ 479 /* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 480 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 481 case PROTO_CHIP_ERASE: /* PROTO_CHIP_ERASE：值0x23，擦除flash与准备烧写飞控固件命令 */ 482 /* 接收到PROTO_CHIP_ERASE命令后2ms内应该接收到终止字PROTO_EOC（0x20），否则进行非法指令处理 */ 483 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 484 /* cmd_bad：指令非法处理函数的标号，在bootloader函数末尾 */ 485 if (!wait_for_eoc(2)) { 486 goto cmd_bad; 487 } 488#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，宏TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.F4 */ 489 /* 对UI协处理器，宏TARGET_HW_PX4_FMU_V4未定义，代码无效 */ 490 /* check_silicon：函数自动辨识MCU的版本，默认STM32F427的revision 3返回0，其余返回-1 */ 491 /* bad_silicon：MCU版本错误处理函数的标号，在bootloader函数末尾 */ 492 if (check_silicon()) { 493 goto bad_silicon; 494 } 495#endif 496 /* 点亮B/E灯 */ 497 /* LED_ON： 值1，led_state枚举成员，定义在bl.c*/ 498 /* led_set：LED灯状态设置函数，定义在bl.c */ 499 led_set(LED_ON); 500 501 /* flash_unlock：解锁flash的库函数，定义在libopencm3/lib/stm32/common/flash_common_f234.c（主控FMU），libopencm3/lib/stm32/common/flash_common_f01.c（IO协处理器） */ 502 flash_unlock(); 503 /* 逐段擦除flash */ 504 /* flash_func_sector_size：返回MCU的flash在某sector的大小值，若无此sector则返回0，定义在main_f?.c */ 505 /* flash_func_erase_sector： */ 506 for (int i = 0; flash_func_sector_size(i) != 0; i++) { 507 flash_func_erase_sector(i); 508 } 509 510 /* 关闭B/E灯 */ 511 /* LED_OFF： 值2，led_state枚举成员，定义在bl.c*/ 512 /* led_set：LED灯状态设置函数，定义在bl.c */ 513 led_set(LED_OFF); 514 515 /* 取每KB的首字检查flash擦除操作是否正确，即是否有擦除成功 */ 516 /* board_info.fw_size：飞控固件的最大值（单位KB） */ 517 /* flash_func_read_word：读取某flash地址的数据，定义在main_f?.c */ 518 /* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */ 519 for (address = 0; address < board_info.fw_size; address += 4) 520 if (flash_func_read_word(address) != 0xffffffff) { 521 goto cmd_fail; 522 } 523 address = 0; 524 525 /* B/E灯闪烁 */ 526 /* LED_BLINK： 值0，led_state枚举成员，定义在bl.c*/ 527 /* led_set：LED灯状态设置函数，定义在bl.c */ 528 led_set(LED_BLINK); 529 break; 530 531 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 532 /* （4）flash烧写命令PROTO_PROG_MULTI（0x27），命令结构：PROTO_PROG_MULTI+arg(1byte)+c(len bytes)+PROTO_EOC */ 533 /* * 收到PROTO_PROG_MULTI的50ms内未收到第一个参数（长度arg），按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 534 /* * 若收到的第一个参数（长度arg）不是4字节对齐，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 535 /* * 若当前编写地址（address）+第一个参数（长度arg）超出飞控固件最大范围board_info.fw_size，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 536 /* * 若收到的第一个参数（长度arg）超出缓冲区长度，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 537 /* * 根据长度arg逐字节接收数据，并存放在缓冲区flash_buffer中；若其中任何1个字节超时1s，按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 538 /* * 接收完有效数据后，若200ms内未接收到命令终止字（PROTO_EOC），按照错误命令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 539 /* * 若当前编写地址address为0，则将烧写缓冲区flash_buffer首个32位保存在变量first_word中，并将缓冲区首改为0xFFFFFFFF */ 540 /* * 对于主控FMU，若MCU版本检查失败，按照MCU版本错误处理，回告结构：(PROTO_INSYNC+PROTO_BAD_SILICON_REV) */ 541 /* * 逐字烧写flash地址，若写入与读出不一致，进行命令失败处理，回告结构：（PROTO_INSYNC+PROTO_FAILED） */ 542 /* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 543 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 544 case PROTO_PROG_MULTI: /* PROTO_PROG_MULTI：值0x27，烧写flash命令 */ 545 /* 50ms内获取第一个参数 */ 546 /* cin_wait：在给定的时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */ 547 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 548 /* board_info.fw_size：飞控固件的最大值 */ 549 /* flash_buffer：共同体，代表接收缓冲区（256字节或32字） */ 550 arg = cin_wait(50); 551 if (arg < 0) { 552 goto cmd_bad; 553 } 554 if (arg % 4) { 555 goto cmd_bad; 556 } 557 if ((address + arg) > board_info.fw_size) { 558 goto cmd_bad; 559 } 560 if (arg > sizeof(flash_buffer.c)) { 561 goto cmd_bad; 562 } 563 564 /* 逐字节接收串口数据并存放在缓冲区内，数据延时不超过1s */ 565 /* cin_wait：在给定的时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */ 566 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 567 /* flash_buffer：共同体，代表接收缓冲区（256字节或32字） */ 568 for (int i = 0; i < arg; i++) { 569 c = cin_wait(1000); 570 if (c < 0) { 571 goto cmd_bad; 572 } 573 flash_buffer.c[i] = c; 574 } 575 576 /* 接收完有效数据后，200ms内必须接收到命令终止字 */ 577 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 578 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 579 if (!wait_for_eoc(200)) { 580 goto cmd_bad; 581 } 582 583 /* 若当前编写逻辑地址为0，（对主控FMU，若MCU版本检查失败，跳转到bad_silicon，进行错误MCU版本处理），则将烧写缓冲区flash_buffer首个32位保存在变量first_word中，并将缓冲区首改为0xFFFFFFFF */ 584 /* check_silicon：函数自动辨识MCU的版本，默认STM32F427的revision 3返回0，其余返回-1 */ 585 /* bad_silicon：MCU版本错误处理函数的标号，在bootloader函数末尾 */ 586 /* first_word：首字保存变量，定义在bootloader函数中 */ 587 /* flash_buffer：共同体，代表接收缓冲区（256字节或32字） */ 588 if (address == 0) { 589#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，宏TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.f4 */ 590 /* 对IO协处理器，宏TARGET_HW_PX4_FMU_V4未定义，代码无效 */ 591 if (check_silicon()) { 592 goto bad_silicon; 593 } 594#endif 595 first_word = flash_buffer.w[0]; 596 flash_buffer.w[0] = 0xffffffff; 597 } 598 599 /* 逐字烧写flash地址，若写入与读出不一致，跳转到cmd_fail，进行命令失败处理，返回PROTO_INSYNC+PROTO_FAILED */ 600 /* flash_func_write_word：烧写flash某地址起始为特定内容，4位烧写，定义在main_f?.c */ 601 /* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */ 602 /* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */ 603 arg /= 4; 604 for (int i = 0; i < arg; i++) { 605 flash_func_write_word(address, flash_buffer.w[i]); 606 if (flash_func_read_word(address) != flash_buffer.w[i]) { 607 goto cmd_fail; 608 } 609 address += 4; 610 } 611 break; 612 613 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 614 /* （5）CRC32校验命令PROTO_GET_CRC（0x29），命令结构：PROTO_GET_CRC+PROTO_EOC */ 615 /* * 收到PROTO_GET_CRC的2ms内未接收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 616 /* * 计算CRC32结果，输出crcsum(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 617 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 618 case PROTO_GET_CRC: /* PROTO_GET_CRC：值0x29，CRC32校验命令 */ 619 /* 2ms内必须收到命令终止字PROTO_EOC */ 620 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 621 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 622 if (!wait_for_eoc(2)) { 623 goto cmd_bad; 624 } 625 626 /* 计算烧写区域的CRC32值，注意飞控固件首地址的处理 */ 627 /* board_info.fw_size：飞控固件的最大值 */ 628 /* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */ 629 /* crc32：计算给定数据的crc32校验结果 */ 630 uint32_t sum = 0; 631 for (unsigned p = 0; p < board_info.fw_size; p += 4) { 632 uint32_t bytes; 633 if ((p == 0) && (first_word != 0xffffffff)) { 634 bytes = first_word; 635 } else { 636 bytes = flash_func_read_word(p); 637 } 638 sum = crc32((uint8_t *)&bytes, sizeof(bytes), sum); 639 } 640 /* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */ 641 cout_word(sum); 642 break; 643 644 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 645 /* （6）读取OTP区域命令PROTO_GET_OTP（0x2a），命令结构：PROTO_GET_OTP+index(4byte)+PROTO_EOC */ 646 /* * 收到PROTO_GET_OTP后未在允许延时（100ms）内收到有效的地址信息，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 647 /* * 收到地址后2ms内未收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 648 /* * 运行成功，输出OTP地址数值val(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 649 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 650 case PROTO_GET_OTP: /* PROTO_GET_OTP：值0x2a，读取OTP区域某地址的1字节指令 */ 651 uint32_t index = 0; 652 /* cin_word：串口或USB模拟串口读入1个字，具有超时检测功能，定义在bl.c */ 653 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 654 if (cin_word(&index, 100)) { 655 goto cmd_bad; 656 } 657 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 658 /* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */ 659 if (!wait_for_eoc(2)) { 660 goto cmd_bad; 661 } 662 cout_word(flash_func_read_otp(index)); 663 break; 664 665 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 666 /* （7）获取MCU的UDID（Unique Device ID，或称为序列号）PROTO_GET_SN（0x2b），命令结构PROTO_GET_SN+index(4byte)+PROTO_EOC */ 667 /* * 收到PROTO_GET_SN后未在允许延时（100ms）内收到有效的地址信息，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 668 /* * 收到地址后2ms内未收到命令终止字，则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 669 /* * 运行成功，输出UDID数值val(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 670 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 671 case PROTO_GET_SN: /* PROTO_GET_SN：值0x2b，获取MCU的UDID命令 */ 672 uint32_t index = 0; 673 /* cin_word：串口或USB模拟串口读入1个字，具有超时检测功能，定义在bl.c */ 674 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 675 if (cin_word(&index, 100)) { 676 goto cmd_bad; 677 } 678 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 679 /* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */ 680 if (!wait_for_eoc(2)) { 681 goto cmd_bad; 682 } 683 cout_word(flash_func_read_sn(index)); 684 break; 685 686 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 687 /* （8）获取芯片ID和版本信息PROTO_GET_CHIP（0x2c），命令结构PROTO_GET_CHIP+PROTO_EOC */ 688 /* * 收到命令PROTO_GET_CHIP后2ms内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 689 /* * 运行成功，输出芯片ID和版本信息数值val(4byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 690 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 691 case PROTO_GET_CHIP: /* PROTO_GET_CHIP：值0x2c，获取芯片ID和版本信息 */ 692 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 693 /* get_mcu_id：读取寄存器DBGMCU_IDCODE值，表示芯片ID和版本 */ 694 /* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */ 695 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 696 if (!wait_for_eoc(2)) { 697 goto cmd_bad; 698 } 699 cout_word(get_mcu_id()); 700 break; 701 702 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 703 /* （9）获取芯片描述信息PROTO_GET_CHIP_DES（0x2e），命令结构PROTO_GET_CHIP_DES+PROTO_EOC */ 704 /* * 收到命令PROTO_GET_CHIP后2ms内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 705 /* * 运行成功，输出芯片描述信息len（4byte）+buffer(len byte)，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 706 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 707 case PROTO_GET_CHIP_DES: /* PROTO_GET_CHIP_DES：值0x2e，获取芯片的描述信息 */ 708 /* MAX_DES_LENGTH：值20，芯片描述信息最大长度，定义在bl.c */ 709 uint8_t buffer[MAX_DES_LENGTH]; 710 unsigned len = MAX_DES_LENGTH; 711 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 712 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 713 if (!wait_for_eoc(2)) { 714 goto cmd_bad; 715 } 716 /* get_mcu_desc：返回MCU的型号和版本描述信息，定义在main_f?.c */ 717 /* cout_word：串口或模拟串口输出1个字的函数，定义在bl.c */ 718 /* cout：串口（包括USB虚拟串口）输出特定内容的函数，定义在bl.c */ 719 len = get_mcu_desc(len, buffer); 720 cout_word(len); 721 cout(buffer, len); 722 break; 723 724#ifdef BOOT_DELAY_ADDRESS /* 对主控FMU，BOOT_DELAY_ADDRESS定义为0x1a0，代码有效，hw_config.h */ 725 /* 对IO协处理器，BOOT_DELAY_ADDRESS未定义，代码无效 */ 726 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 727 /* （10）设置飞控固件启动延时PROTO_SET_DELAY（0x2d），命令结构：PROTO_SET_DELAY+v(4byte)+PROTO_EOC */ 728 /* * 收到PROTO_SET_DELAY后100ms内未收到延时v，或延时时间为负数，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 729 /* * 取延时v的最低字节为时延boot_delay有效信息（单位s），若此值大于允许最大值BOOT_DELAY_MAX，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 730 /* * 收到延时v的2ms内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 731 /* * 读取BOOT_DELAY_ADDRESS起始的显示延时信息有效性的2个关键字，通过与预定的关键字对比，若不一致则进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 732 /* * 根据延时boot_delay和关键字BOOT_DELAY_SIGNATURE1确定需存放在地址BOOT_DELAY_ADDRESS的数据，并写入以更新延时参数 */ 733 /* * 再次读取地址BOOT_DELAY_ADDRESS的数据与需写入的数据进行对比，若不一致（写入失败），则进行命令失败处理，回告结构：（PROTO_INSYNC+PROTO_FAILED） */ 734 /* * 运行成功，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 735 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 736 case PROTO_SET_DELAY: /* PROTO_SET_DELAY：值0x2d，设置飞控固件启动延时 */ 737 /* cin_wait：在给定的时间内读到串口数据，则返回数据；若超时返回-1，定义在bl.c */ 738 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 739 int v = cin_wait(100); 740 if (v < 0) { 741 goto cmd_bad; 742 } 743 744 /* 取v的低字节作为时延boot_delay的有效信息（时延最大255s） */ 745 /* BOOT_DELAY_MAX：值30，飞控固件启动最大时延，定义在bl.c */ 746 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 747 uint8_t boot_delay = v & 0xFF; 748 if (boot_delay > BOOT_DELAY_MAX) { 749 goto cmd_bad; 750 } 751 752 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 753 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 754 if (!wait_for_eoc(2)) { 755 goto cmd_bad; 756 } 757 758 /* 读取BOOT_DELAY_ADDRESS起始的2个字，提取显示延时信息有效性的2个关键字，通过对比来判断信息是否有效 */ 759 /* BUG?sig1的最低字节是延时参数，不应作为判断依据，这里有问题 */ 760 /* BOOT_DELAY_ADDRESS：值0x000001a0，飞控固件启动延时信息在flash中的存储地址，仅对主控FMU有效，定义在hw_config.h */ 761 /* BOOT_DELAY_SIGNATURE1：值0x92c2ecff，飞控固件启动延时信息有效的关键字1，定义在bl.h */ 762 /* BOOT_DELAY_SIGNATURE2：值0xc5057d5d，飞控固件启动延时信息有效的关键字2，定义在bl.h */ 763 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 764 uint32_t sig1 = flash_func_read_word(BOOT_DELAY_ADDRESS); 765 uint32_t sig2 = flash_func_read_word(BOOT_DELAY_ADDRESS + 4); 766 if (sig1 != BOOT_DELAY_SIGNATURE1 || sig2 != BOOT_DELAY_SIGNATURE2) { 767 goto cmd_bad; 768 } 769 770 /* 根据延时boot_delay和关键字BOOT_DELAY_SIGNATURE1确定需存放在地址BOOT_DELAY_ADDRESS的数据，并写入 */ 771 /* BOOT_DELAY_SIGNATURE1：值0x92c2ecff，飞控固件启动延时信息有效的关键字1，定义在bl.h */ 772 /* BOOT_DELAY_ADDRESS：值0x000001a0，飞控固件启动延时信息在flash中的存储地址，仅对主控FMU有效，定义在hw_config.h */ 773 /* flash_func_write_word：烧写flash某地址起始为特定内容，4位烧写，定义在main_f?.c */ 774 uint32_t value = (BOOT_DELAY_SIGNATURE1 & 0xFFFFFF00) | boot_delay; 775 flash_func_write_word(BOOT_DELAY_ADDRESS, value); 776 777 /* 再次读取地址BOOT_DELAY_ADDRESS的数据与需写入的数据进行对比，若不一致则跳转到cmd_fail，运行失败 */ 778 /* BOOT_DELAY_ADDRESS：值0x000001a0，飞控固件启动延时信息在flash中的存储地址，仅对主控FMU有效，定义在hw_config.h */ 779 /* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */ 780 /* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */ 781 if (flash_func_read_word(BOOT_DELAY_ADDRESS) != value) { 782 goto cmd_fail; 783 } 784 break; 785#endif 786 787 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 788 /* （11）完成烧写并启动飞控固件PROTO_BOOT（0x30），命令结构：PROTO_BOOT+PROTO_EOC */ 789 /* * 收到启动命令PROTO_BOOT的1s内未收到命令终止字，进行错误指令处理，回告结构：(PROTO_INSYNC+PROTO_INVALID) */ 790 /* * 若变量first_word（飞控固件首字保存变量）中有内容 */ 791 /* * 烧写飞控固件首字first_word */ 792 /* * 读取飞控固件首字并与first_word对比，若不同则进行命令失败处理，回告结构：（PROTO_INSYNC+PROTO_FAILED） */ 793 /* * 烧写首字成功，将first_word变量置为无效（0xffffffff） */ 794 /* * 运行成功，发送PROTO_INSYNC+PROTO_OK，延时100ms，bootloader函数返回 */ 795 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 796 case PROTO_BOOT: /* PROTO_BOOT：值0x30，完成烧写并启动飞控固件 */ 797 /* wait_for_eoc：在给定的时间内，下一条获取到的命令是否为命令终止字PROTO_EOC；若是返回真，不是返回假，定义在bl.c */ 798 /* cmd_bad：错误命令处理函数的标号，在bootloader函数末尾 */ 799 if (!wait_for_eoc(1000)) { 800 goto cmd_bad; 801 } 802 /* 若变量first_word内容有效，烧写飞控固件首字并判断是否烧写成功 */ 803 /* first_word：飞控固件首字保存变量，定义在bootloader函数中 */ 804 /* flash_func_write_word：烧写flash某地址起始为特定内容，4位烧写，定义在main_f?.c */ 805 /* flash_func_read_word：读取flash某特定地址内容，4位读取，定义在main_f?.c */ 806 /* cmd_fail：指令运行错误处理的标号，在bootloader函数末尾 */ 807 if (first_word != 0xffffffff) { 808 flash_func_write_word(0, first_word); 809 /* 读取飞控固件首字并与first_word对比，若不同则跳转到cmd_fail，进行命令失败处理 */ 810 if (flash_func_read_word(0) != first_word) { 811 goto cmd_fail; 812 } 813 /* 将first_word变量置为无效（0xffffffff） */ 814 first_word = 0xffffffff; 815 } 816 /* sync_response：发送同步命令函数，表示运行成功，定义在bl.c */ 817 /* delay：延时函数，定义在bl.c */ 818 sync_response(); 819 delay(100); 820 821 // quiesce and jump to the app 822 return; 823 824 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 825 /* （12）输出调试信息（命令暂未完成）PROTO_DEBUG（0x31），直接按运行成功处理，(发送PROTO_INSYNC+PROTO_OK，变量timeout和bl_type重新赋值，继续新的命令处理) */ 826 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 827 case PROTO_DEBUG: /* PROTO_DEBUG：值0x31，输出调试信息 */ 828 break; 829 830 default: 831 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 832 /* 其他命令，直接进入接收新的命令循环 */ 833 /* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */ 834 continue; 835 } 836 837 /* 4.5 命令处理完毕，运行成功后的处理（变量timeout初始化和bl_type重新赋值，调用sync_response函数发送PROTO_INSYNC+PROTO_OK表示运行成功），继续接收下一条指令。 */ 838 /* timeout：bootloader跳转到飞控固件所需等待的时间，bootloader函数输入 */ 839 /* bl_type：静态全局接口类型变量， */ 840 /* NONE：值0，枚举类，定义在bl.h */ 841 /* last_input：静态全局变量，上次获取串口数据的方式 */ 842 /* sync_response：发送同步命令函数，表示运行成功，定义在bl.c */ 843 timeout = 0; 844 if (bl_type == NONE) { 845 bl_type = last_input; 846 } 847 sync_response(); 848 continue; 849 850cmd_bad: /* cmd_bad：错误指令处理标号，发送PROTO_INSYNC+PROTO_INVALID，并准备接收下一条指令 */ 851 /* invalid_response：指令非法的处理函数，发送PROTO_INSYNC+PROTO_INVALID，定义在bl.c */ 852 invalid_response(); 853 continue; 854 855cmd_fail: /* cmd_fail：指令运行失败，发送PROTO_INSYNC+PROTO_FAILED，并准备接收下一条指令 */ 856 /* failure_response：指令运行失败的处理函数，发送PROTO_INSYNC+PROTO_FAILED，定义在bl.c */ 857 failure_response(); 858 continue; 859 860#if defined(TARGET_HW_PX4_FMU_V4) /* 对主控FMU，宏TARGET_HW_PX4_FMU_V4定义为1，代码有效，Makefile.f4 */ 861 /* 对IO协处理器，宏TARGET_HW_PX4_FMU_V4未定义，代码无效 */ 862bad_silicon: /* bad_silicon：MCU版本错误处理函数的标号，发送PROTO_INSYNC+PROTO_BAD_SILICON_REV，并准备接收下一条指令 */ 863 /* bad_silicon_response：MCU型号错误处理函数，发送PROTO_INSYNC+PROTO_BAD_SILICON_REV，定义在bl.c */ 864 bad_silicon_response(); 865 continue; 866#endif 867 } 868}
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
1static void board_init(void) 2{ 3 /* 1. 赋值board_info.fw_size，确定飞控固件size允许的最大值*/ 4 /* 修改fw_size值为APP_SIZE_MAX，宏APP_SIZE_MAX被main_f4.c定义为 BOARD_FLASH_SIZE-(BOOTLOADER_RESERVATION_SIZE+APP_RESERVATION_SIZE) */ 5 /* BOARD_FLASH_SIZE：被定义在hw_config.h中，BOARD_FLASH_SIZE=_FLASH_KBYTES*1024，_FLASH_KBYTES通过读取地址0x1FFF7A22的低16位寄存器得到，此寄存器值代表以KB为单位的芯片的flash大小，属性只读 */ 6 /* BOOTLOADER_RESERVATION_SIZE：被定义在main_f4.c中，BOOTLOADER_RESERVATION_SIZE=16*1024，代表16KB（1个sector） */ 7 /* APP_RESERVATION_SIZE：被定义在hw_config.h中，APP_RESERVATION_SIZE=2*16*1024，代表32KB（2个sector） */ 8 /* 对于STM32F427VIT6，BOARD_FLASH_SIZE=2048KB，APP_SIZE_MAX=2000KB */ 9 board_info.fw_size = APP_SIZE_MAX; 10#if defined(TARGET_HW_PX4_FMU_V2) || defined(TARGET_HW_PX4_FMU_V4) /* 定义了宏TARGET_HW_PX4_FMU_V2，因此下列代码有效 */ 11 /* check_silicon函数自动辨识MCU的版本，默认STM32F427的revision 3返回0，其余返回-1 */ 12 /* fw_size的值为APP_SIZE_MAX=2000KB，第二项判断语句肯定为假 */ 13 /* 因此该if语句不为真，fw_size不被重新赋值，其值保持为2000KB */ 14 if (check_silicon() && board_info.fw_size == (2 * 1024 * 1024) - BOOTLOADER_RESERVATION_SIZE) { 15 board_info.fw_size = (1024 * 1024) - BOOTLOADER_RESERVATION_SIZE; 16 } 17#endif 18 19#if defined(BOARD_POWER_PIN_OUT) /* 宏BOARD_POWER_PIN_OUT未定义，下列语句无效 */ 20 /* Configure the Power pins */ 21 rcc_peripheral_enable_clock(&BOARD_POWER_CLOCK_REGISTER, BOARD_POWER_CLOCK_BIT); 22 gpio_mode_setup(BOARD_POWER_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_POWER_PIN_OUT); 23 gpio_set_output_options(BOARD_POWER_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, BOARD_POWER_PIN_OUT); 24 BOARD_POWER_ON(BOARD_POWER_PORT, BOARD_POWER_PIN_OUT); 25#endif 26 27 /* 2. 初始化USB端口GPIOA9（VBUS） */ 28#if INTERFACE_USB /* 宏INTERFACE_USB在hw_config.h中被定义为1，下列代码有效 */ 29 /* RCC_AHB1ENR：寄存器（libopencm3/include/libopencm3/stm32/f4/rcc.h，地址0x40023830） */ 30 /* RCC_AHB1ENR_IOPAEN：值为1<<0（libopencm3/include/libopencm3/stm32/f4/rcc.h），bit0 */ 31 /* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 32 /* 使能GPIOA的时钟，对应原理图中主控FMU连接USB接口芯片（U302，NUF2042VX6）的3个引脚GPIOA9(VBUS/3.1A)，GPIOA11(OTG_FS_DM/3.1B)，GPIOA12(OTG_FS_DP/3.1A) */ 33 rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN); 34#endif 35 36 /* 3. 初始化串口USART2 */ 37#if INTERFACE_USART /* 宏INTERFACE_USART在hw_config.h中被定义为1，下列代码有效 */ 38 /* BOARD_USART_PIN_CLOCK_REGISTER：被hw_config.h定义为寄存器RCC_AHB1ENR（libopencm3/include/libopencm3/stm32/f4/rcc.h，地址0x40023830） */ 39 /* BOARD_USART_PIN_CLOCK_BIT：被hw_config.h定义为RCC_AHB1ENR_IOPDEN（libopencm3/include/libopencm3/stm32/f4/rcc.h），值1<<3，bit3 */ 40 /* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 41 /* 使能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) */ 42 rcc_peripheral_enable_clock(&BOARD_USART_PIN_CLOCK_REGISTER, BOARD_USART_PIN_CLOCK_BIT); 43 44 /* BOARD_PORT_USART：被hw_config.h定义为GPIOD，对应寄存器GPIOD_MODER（地址0x40020C00） */ 45 /* GPIO_MODE_AF：值为0x2（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 46 /* GPIO_PUPD_PULLUP：值为0x1（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 47 /* BOARD_PIN_TX：被hw_config.h定义为GPIO5，值1<<5（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 48 /* BOARD_PIN_RX：被hw_config.h定义为GPIO6，值1<<6（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 49 /* gpio_mode_setup：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO引脚的功能 */ 50 /* 设置GPIOD5（USART2-TX）和GPIOD6（USART2-RX）为AF（MODER=GPIO_MODE_AF=10）模式，片内上拉push-pull（PUPDR=GPIO_PUPD_PULLUP=01） */ 51 gpio_mode_setup(BOARD_PORT_USART, GPIO_MODE_AF, GPIO_PUPD_PULLUP, BOARD_PIN_TX | BOARD_PIN_RX); 52 53 /* BOARD_PORT_USART：被hw_config.h定义为GPIOD，对应寄存器GPIOD_MODER（地址0x40020C00） */ 54 /* BOARD_PORT_USART_AF：被hw_config.h定义为GPIO_AF7，值0x7 */ 55 /* BOARD_PIN_TX：被hw_config.h定义为GPIO5，值1<<5（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 56 /* BOARD_PIN_RX：被hw_config.h定义为GPIO6，值1<<6（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 57 /* gpio_set_af：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO的具体AF功能 */ 58 /* 设置GPIOD5（USART2-TX）和GPIOD6（USART2-RX）为USART1~3功能（具体为USART2） */ 59 gpio_set_af(BOARD_PORT_USART, BOARD_PORT_USART_AF, BOARD_PIN_TX); 60 gpio_set_af(BOARD_PORT_USART, BOARD_PORT_USART_AF, BOARD_PIN_RX); 61 62 /* BOARD_USART_CLOCK_REGISTER：被hw_config.h定义为寄存器RCC_APB1ENR（地址0x40023840） */ 63 /* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 64 /* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 65 /* 使能USART2的时钟，寄存器RCC_APB1ENR的bit17 */ 66 rcc_peripheral_enable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT); 67#endif 68 69#if defined(BOARD_FORCE_BL_PIN_IN) && defined(BOARD_FORCE_BL_PIN_OUT) /* 宏BOARD_FORCE_BL_PIN_IN与BOARD_FORCE_BL_PIN_OUT均未被定义，以下代码无效 */ 70 /* configure the force BL pins */ 71 rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT); 72 gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN_IN); 73 gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT); 74 gpio_set_output_options(BOARD_FORCE_BL_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, BOARD_FORCE_BL_PIN_OUT); 75#endif 76 77#if defined(BOARD_FORCE_BL_PIN) /* 宏BOARD_FORCE_BL_PIN未定义，下列代码无效 */ 78 /* configure the force BL pins */ 79 rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT); 80 gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN); 81#endif 82 83 /* 4. 初始化LED并点亮（B/E，LED701） */ 84 /* RCC_AHB1ENR：寄存器（地址0x40023830） */ 85 /* BOARD_CLOCK_LEDS：被hw_config.h定义为RCC_AHB1ENR_IOPEEN，值1<<4，bit4 */ 86 /* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 87 /* 使能GPIOE的时钟，对应原理图中主控FMU的LED控制引脚GPIOE12（FMU-LED_AMBER/7.5B），低电平点亮发光二极管LED701 */ 88 rcc_peripheral_enable_clock(&RCC_AHB1ENR, BOARD_CLOCK_LEDS); 89 90 /* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */ 91 /* GPIO_MODE_OUTPUT：值0x1（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 92 /* GPIO_PUPD_NONE：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 93 /* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 94 /* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */ 95 /* gpio_mode_setup：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO引脚的功能 */ 96 /* 设置GPIOE12（FMU-LED_AMBER/7.5B）为输出模式（MODER=GPIO_MODE_OUTPUT=01），push-pull模式（PUPDR=GPIO_PUPD_NONE=00） */ 97 gpio_mode_setup(BOARD_PORT_LEDS, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); 98 99 /* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */ 100 /* GPIO_OTYPE_PP：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 101 /* GPIO_OSPEED_2MHZ：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 102 /* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 103 /* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */ 104 /* gpio_set_output_options：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO的输出模式 */ 105 /* 设置GPIOE12（FMU-LED_AMBER/7.5B）的输出模式为push-pull（OTYPER=GPIO_OTYPE_PP=0），GPIO时钟为2MHz（OSPEEDR=GPIO_OSPEED_2MHZ=00） */ 106 gpio_set_output_options(BOARD_PORT_LEDS, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); 107 108 /* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */ 109 /* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 110 /* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */ 111 /* BOARD_LED_ON：被hw_config.h定义为函数gpio_clear（libopencm3/lib/stm32/common/gpio_common_all.c）,功能为置某GPIO组中的引脚输出为低电平 */ 112 /* 设置GPIOE12（FMU-LED_AMBER/7.5B）为低电平，点亮B/E（LED701） */ 113 BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); 114 115 /* 5. 使能能耗控制器时钟 */ 116 /* RCC_APB1ENR：寄存器（地址0x40023840） */ 117 /* RCC_APB1ENR_PWREN：值1<<28（libopencm3/include/libopencm3/stm32/f4/rcc.h），bit28 */ 118 /* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 119 /* 使能电源接口时钟 */ 120 rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN); 121}
8.1.2 board_deinit函数
board_deinit函数用于板载设备的反向初始化：主要的功能如下：
- 无效化串口USART2
- 无效化LED时钟引脚
- 关闭电源接口时钟
- 恢复AHB1外部时钟为默认值
main_f4.c
1void board_deinit(void) 2{ 3 4#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，在hw_config.h，下列代码有效 */ 5 /* 1. 无效化串口USART2 */ 6 /* 设置USART2的输入输出引脚为输入状态 */ 7 /* BOARD_PORT_USART：被hw_config.h定义为GPIOD，对应寄存器GPIOD_MODER（地址0x40020C00） */ 8 /* GPIO_MODE_INPUT：值为0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 9 /* GPIO_PUPD_NONE：值为0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 10 /* BOARD_PIN_TX：被hw_config.h定义为GPIO5，值1<<5（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 11 /* BOARD_PIN_RX：被hw_config.h定义为GPIO6，值1<<6（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 12 /* gpio_mode_setup：定义在libopencm3/lib/stm32/common/gpio_common_f0234.c，功能为设置GPIO引脚的功能 */ 13 /* 设置GPIOD5（USART2-TX）和GPIOD6（USART2-RX）为输入模式（MODER=GPIO_MODE_INPUT=00），浮动状态（PUPDR=GPIO_PUPD_NONE=00） */ 14 gpio_mode_setup(BOARD_PORT_USART, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_PIN_TX | BOARD_PIN_RX); 15 16 /* 关闭USART2的时钟 */ 17 /* BOARD_USART_CLOCK_REGISTER：被hw_config.h定义为寄存器RCC_APB1ENR（地址0x40023840） */ 18 /* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 19 /* rcc_peripheral_disable_clock：关闭特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 20 rcc_peripheral_disable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT); 21#endif 22 23#if defined(BOARD_FORCE_BL_PIN_IN) && defined(BOARD_FORCE_BL_PIN_OUT) /* 宏BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN_OUT未定义，下列代码无效 */ 24 gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT); 25 gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_IN); 26#endif 27 28#if defined(BOARD_FORCE_BL_PIN) /* 宏BOARD_FORCE_BL_PIN未定义，下列代码无效 */ 29 gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN); 30#endif 31 32#if defined(BOARD_POWER_PIN_OUT) && defined(BOARD_POWER_PIN_RELEASE) /* 宏BOARD_POWER_PIN_OUT和BOARD_POWER_PIN_RELEASE未定义，下列代码无效 */ 33 gpio_mode_setup(BOARD_POWER_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_POWER_PIN); 34#endif 35 36 /* 2. 无效化LED时钟引脚（设为输入模式） */ 37 /* BOARD_PORT_LEDS：被hw_config.h定义为GPIOE，值为GPIOE控制寄存器组起始地址0x40021000 */ 38 /* GPIO_MODE_INPUT：值为0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 39 /* BOARD_PIN_LED_BOOTLOADER：被hw_config.h定义为GPIO12，值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 40 /* BOARD_PIN_LED_ACTIVITY：被hw_config.h定义为0，代表主控FMU无ACT指示灯 */ 41 /* BOARD_LED_ON：被hw_config.h定义为函数gpio_clear（libopencm3/lib/stm32/common/gpio_common_all.c）,功能为置某GPIO组中的引脚输出为低电平 */ 42 /* 设置GPIOE12（FMU-LED_AMBER/7.5B）为输入模式（MODER=GPIO_MODE_INPUT=00），浮动模式（PUPDR=GPIO_PUPD_NONE=00） */ 43 gpio_mode_setup(BOARD_PORT_LEDS, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); 44 45 /* 3. 关闭电源接口时钟 */ 46 /* RCC_APB1ENR：寄存器（地址0x40023840） */ 47 /* RCC_APB1ENR_PWREN：值1<<28（libopencm3/include/libopencm3/stm32/f4/rcc.h），bit28 */ 48 /* rcc_peripheral_disable_clock：关闭特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 49 rcc_peripheral_disable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN); 50 51 /* 4. 恢复AHB1外部时钟为默认值 */ 52 /* RCC_AHB1ENR：AHB1外部时钟使能寄存器 */ 53 RCC_AHB1ENR = 0x00100000; // XXX Magic reset number from STM32F4x reference manual 54}
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
1truct rcc_clock_scale { 2 uint8_t pllm; /* 寄存器RCC_PLLCFGR中的PLLM信息（5:0） */ 3 uint16_t plln; /* 寄存器RCC_PLLCFGR中的PLLN信息（14:6） */ 4 uint8_t pllp; /* 寄存器RCC_PLLCFGR中的PLLP信息（17:16） */ 5 uint8_t pllq; /* 寄存器RCC_PLLCFGR中的PLLQ信息（27:24） */ 6 uint8_t pllr; /* 仅STM32F446/469包含此项 */ 7 uint32_t flash_config; /* flash访问控制，对应寄存器FLASH_ACR */ 8 uint8_t hpre; /* 寄存器RCC_CFGR中的HPRE信息（7:4） */ 9 uint8_t ppre1; /* 寄存器RCC_CFGR中的PPRE1信息（12:10） */ 10 uint8_t ppre2; /* 寄存器RCC_CFGR中的PPRE2信息（15:13） */ 11 uint8_t power_save; /* 0：高能耗模式（scale 1，11），1：节能模式（scale 3，01）；对应寄存器PWR_CR的VOS信息（15:14） */ 12 uint32_t ahb_frequency; /* AHB时钟频率 */ 13 uint32_t apb1_frequency; /* APB1时钟频率 */ 14 uint32_t apb2_frequency; /* APB2时钟频率 */ 15};
通过设置数据结构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
1static const struct rcc_clock_scale clock_setup = { 2 /* PLL时钟设置 */ 3 .pllm = OSC_FREQ, /* PLLM=OSC_FREQ=24（hw_config.h） */ 4 .plln = 336, /* PLLN=336 */ 5 .pllp = 2, /* PLLP=2 */ 6 .pllq = 7, /* PLLQ=7 */ 7#if defined(STM32F446) || defined(STM32F469) /* 未定义宏STM32F446和STM32F469，pllr域不初始化 */ 8 .pllr = 2, 9#endif 10 /* AHB、APB1、APB2时钟设置 */ 11 .hpre = RCC_CFGR_HPRE_DIV_NONE, /* HPRE=RCC_CFGR_HPRE_DIV_NONE=0（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 12 .ppre1 = RCC_CFGR_PPRE_DIV_4, /* PPRE1=RCC_CFGR_PPRE_DIV_4=0x5（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 13 .ppre2 = RCC_CFGR_PPRE_DIV_2, /* PPRE1=RCC_CFGR_PPRE_DIV_2=0x4（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 14 /* 能耗模式 */ 15 .power_save = 0, /* VOS=10，默认为11 */ 16 /* flash访问控制 */ 17 .flash_config = FLASH_ACR_ICE | FLASH_ACR_DCE | FLASH_ACR_LATENCY_5WS, /* 寄存器FLASH_ACR的ICEN(9)，DCEN(10)，LATENCY(3:0) */ 18 /* 更新APB1、APB2时钟全局变量值 */ 19 .apb1_frequency = 42000000, /* */ 20 .apb2_frequency = 84000000, 21}; 22 23/* rcc_clock_setup_hse_3v3：被定义在libopencm3/lib/stm32/f4/rcc.c，用于启动后各系统时钟的初始化、能耗模式配置、flash访问控制 */ 24/* 1. PLL时钟设置（寄存器RCC_PLLCFGR） */ 25/* fVCO=fPLLin*(PLLN/PLLM)=24*(336/24)=336MHz，（根据原理图，主控FMU的外部晶振频率为24MHz） */ 26/* fPLL=fVCO/PLLP=168MHz */ 27/* fUSBSDRNG=fVCO/PLLQ=48MHz */ 28/* 2. AHB、APB1、APB2时钟设置（寄存器RCC_CFGR） */ 29/* fAHB=fsysclk=fPLL=168MHz，域HPRE=0，不分频，系统时钟由调用的rcc_set_sysclk_source函数设置为fPLL */ 30/* fAPB1=fAHB/4=42MHz，域PPRE1=101，分频倍率为4 */ 31/* fAPB2=fAHB/2=84MHz，域PPRE2=100，分频倍率为2 */ 32/* 3. 能耗模式 */ 33/* 寄存器PWR_CR的域VOS=10，对应Scale 2 mode */ 34/* 4. flash访问控制 */ 35/* ICEN=FLASH_ACR_ICE=1，bit9，使能I cache */ 36/* DCEN=FLASH_ACR_DCE=1，bit10，使能D cache */ 37/* LATENCY=FLASH_ACR_LATENCY_5WS=0x5，访问等待5周期 */ 38/* 5. 更新库libopencm3中定义的全局变量rcc_apb1_frequency=apb1_frequency=42000000，rcc_apb2_frequency=apb2_frequency=84000000 */ 39static inline void clock_init(void) 40{ 41 rcc_clock_setup_hse_3v3(&clock_setup); 42}
8.2.2 clock_deinit函数
clock_deinit函数关闭时钟源，将所有内部时钟设置为重启后的初始状态，为飞控固件的运行提供良好的初始环境，主要操作如下：
- 开启内部高速时钟并等待其稳定
- 清除所有时钟配置
- 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI
- 恢复PLL配置寄存器为默认值
- 关闭HSE旁路功能
- 清除所有时钟中断
1void clock_deinit(void) 2{ 3 /* 1. 开启内部高速时钟并等待其稳定 */ 4 /* RCC_HSI：值4，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 5 /* rcc_osc_on：开启某内部时钟，操作寄存器RCC_CR。rcc_osc_on(RCC_HSI)操作HSION域（bit0），定义在libopencm3/lib/stm32/f4/rcc.c */ 6 /* rcc_wait_for_osc_ready：等待某内部时钟稳定，读取寄存器RCC_CR。rcc_wait_for_osc_ready(RCC_HSI)读取HSIRDY（bit1），定义在libopencm3/lib/stm32/f4/rcc.c */ 7 rcc_osc_on(RCC_HSI); 8 rcc_wait_for_osc_ready(RCC_HSI); 9 10 /* 2. 清除所有时钟配置 */ 11 /* RCC_CFGR：时钟配置寄存器寄存器，libopencm3/include/libopencm3/stm32/f4/rcc.h */ 12 RCC_CFGR = 0x000000; 13 14 /* 3. 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI */ 15 /* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 16 /* RCC_PLL：值0，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 17 /* rcc_osc_off：关闭某内部时钟，操作寄存器RCC_CR。定义在libopencm3/lib/stm32/f4/rcc.c */ 18 /* rcc_css_disable：关闭时钟安全系统，操作寄存器RCC_CR的域CSSON（bit19）。定义在libopencm3/lib/stm32/f4/rcc.c */ 19 /* rcc_osc_off(RCC_HSE)操作HSEON域（bit16），rcc_osc_off(RCC_PLL)操作PLLON域（bit24）。定义在libopencm3/lib/stm32/f4/rcc.c */ 20 rcc_osc_off(RCC_HSE); 21 rcc_osc_off(RCC_PLL); 22 rcc_css_disable(); 23 24 /* 4. 恢复PLL配置寄存器为默认值 */ 25 /* RCC_PLLCFGR：RCC PLL配置寄存器 */ 26 RCC_PLLCFGR = 0x24003010; 27 28 /* 5. 关闭HSE旁路功能 */ 29 /* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 30 /* rcc_osc_bypass_disable：关闭HSE的旁路功能，操作寄存器RCC_CR的HSEBYP域（bit18） */ 31 rcc_osc_bypass_disable(RCC_HSE); 32 33 /* 6. 清除所有时钟中断 */ 34 /* RCC_CIR：RCC时钟中断寄存器 */ 35 RCC_CIR = 0x000000; 36}
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
1/* BOOT_RTC_REG：定义强制bootloader寄存器，地址为0x40002850，对应16个RTC_BKPxR的第一个32位寄存器，它们不受芯片重启reset影响 */ 2#define BOOT_RTC_REG MMIO32(RTC_BASE + 0x50) 3 4static uint32_t board_get_rtc_signature() 5{ 6 /* 1. 修改相关寄存器选项，使BOOT_RTC_REG可以被访问 */ 7 /* PWR_CR：能耗控制寄存器 */ 8 /* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */ 9 /* 芯片重启后，寄存器RCC_BDCR、RTC备份寄存器（如BOOT_RTC_REG）和寄存器PWR_CSR的BRE位都处于写保护状态，寄存器PWR_CR的bit8置1解除写保护 */ 10 PWR_CR |= PWR_CR_DBP; 11 /* RCC_BDCR：备份域控制寄存器 */ 12 /* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 13 /* 使能RTC时钟，BOOT_RTC_REG可以访问，还未选择时钟源？BUG？ */ 14 RCC_BDCR |= RCC_BDCR_RTCEN; 15 16 /* 2. 读取BOOT_RTC_REG寄存器值 */ 17 uint32_t result = BOOT_RTC_REG; 18 19 /* 3. 修改寄存器选项，禁止访问BOOT_RTC_REG */ 20 /* RCC_BDCR：备份域控制寄存器 */ 21 /* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 22 /* 这里应反向关闭RTC时钟，正确代码应该如下。源代码不但没有关闭RTC时钟，还会，BUG? */ 23 /* RCC_BDCR &= ~RCC_BDCR_RTCEN */ 24 RCC_BDCR &= RCC_BDCR_RTCEN; 25 /* PWR_CR：能耗控制寄存器 */ 26 /* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */ 27 /* 此句为RTC寄存器加上写保护 */ 28 PWR_CR &= ~PWR_CR_DBP; 29 30 return result; 31}
8.3.2 board_set_rtc_signature函数
main_f4.c
1static void board_set_rtc_signature(uint32_t sig) 2{ 3 /* 1. 修改相关寄存器选项，使BOOT_RTC_REG可以被访问 */ 4 /* PWR_CR：能耗控制寄存器 */ 5 /* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */ 6 /* 芯片重启后，寄存器RCC_BDCR、RTC备份寄存器（如BOOT_RTC_REG）和寄存器PWR_CSR的BRE位都处于写保护状态，寄存器PWR_CR的bit8置1解除写保护 */ 7 PWR_CR |= PWR_CR_DBP; 8 /* RCC_BDCR：备份域控制寄存器 */ 9 /* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 10 /* 使能RTC时钟，BOOT_RTC_REG可以访问，还未选择时钟源？BUG？ */ 11 RCC_BDCR |= RCC_BDCR_RTCEN; 12 13 /* 2. 设置BOOT_RTC_REG寄存器值 */ 14 BOOT_RTC_REG = sig; 15 16 /* 3. 修改寄存器选项，禁止访问BOOT_RTC_REG */ 17 /* RCC_BDCR：备份域控制寄存器 */ 18 /* RCC_BDCR_RTCEN：值1<<15（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 19 /* 这里应反向关闭RTC时钟，正确代码应该如下。源代码不但没有关闭RTC时钟，还会，BUG? */ 20 /* RCC_BDCR &= ~RCC_BDCR_RTCEN */ 21 RCC_BDCR &= RCC_BDCR_RTCEN; 22 /* PWR_CR：能耗控制寄存器 */ 23 /* PWR_CR_DBP：值1<<8（libopencm3/include/libopencm3/stm32/common/pwr_common_all.h） */ 24 /* 此句为RTC寄存器加上写保护 */ 25 PWR_CR &= ~PWR_CR_DBP; 26}
8.4 flash操作函数
这里的flash操作是针对飞控固件部分flash的。
8.4.1 flash_func_read_word函数
flash_func_read_word函数返回飞控固件flash域内某地址的值，输入的地址值自动加上APP_LOAD_ADDRESS（0x08004000）。
main_f4.c
1uint32_t flash_func_read_word(uint32_t address) 2{ 3 /* 若地址非4字节对齐，返回0 */ 4 if (address & 3) { 5 return 0; 6 } 7 /* 否则返回地址为(address+APP_LOAD_ADDRESS)对应的值，这个地址在飞控固件内 */ 8 /* APP_LOAD_ADDRESS：值0x08004000，定义在hw_config.h */ 9 return *(uint32_t *)(address + APP_LOAD_ADDRESS); 10}
8.4.2 flash_func_sector_size函数
flash_func_sector_size函数返回MCU的flash在某sector的大小值，若无此sector则返回0。
main_f4.c
1/* BOARD_FLASH_SECTORS：STM32F4芯片若片内flash为1M，则Sector数量为11；若不为1M（2M），则Sector数量为23，定义在hw_config.h */ 2/* flash_sectors：结构体全局变量，表示flash内部各sector的size分布，定义在main_f4.c */ 3uint32_t flash_func_sector_size(unsigned sector) 4{ 5 if (sector < BOARD_FLASH_SECTORS) { 6 return flash_sectors[sector].size; 7 } 8 return 0; 9} 10
8.4.3 flash_func_erase_sector函数
flash_func_erase_sector函数用于擦除指定的sector。根据当前段中有无有效数据而被擦写，若有就擦写；若无有效数据（全为0xFFFFFFFF），则不用擦写。
1void flash_func_erase_sector(unsigned sector) 2{ 3 /* 判定输入参数sector是否合法，若不合法直接返回 */ 4 /* BOARD_FLASH_SECTORS：STM32F4芯片若片内flash为1M，则Sector数量为11；若不为1M（2M），则Sector数量为23，定义在hw_config.h */ 5 /* BOARD_FIRST_FLASH_SECTOR_TO_ERASE：值0，定义在hw_config.h */ 6 if (sector >= BOARD_FLASH_SECTORS || sector < BOARD_FIRST_FLASH_SECTOR_TO_ERASE) { 7 return; 8 } 9 10 /* 计算当前sector相对于APP_LOAD_ADDRESS（0x08004000）的相对地址（即逻辑地址） */ 11 /* BOARD_FIRST_FLASH_SECTOR_TO_ERASE：值0，定义在hw_config.h */ 12 /* flash_func_sector_size：函数返回MCU的flash在某sector的大小值，若无此sector则返回0，定义在main_f4.c */ 13 uint32_t address = 0; 14 for (unsigned i = BOARD_FIRST_FLASH_SECTOR_TO_ERASE; i < sector; i++) { 15 address += flash_func_sector_size(i); 16 } 17 18 /* 获取当前段的大小，扫描当前段的内容，若存在不为0xffffffff的非空字节，说明本段内容不为空；置blank变量为假，表示本段写入过数据，应被擦写。 */ 19 /* flash_func_sector_size：函数返回MCU的flash在某sector的大小值，若无此sector则返回0，定义在main_f4.c */ 20 /* blank：当前段是否为空的标记 */ 21 unsigned size = flash_func_sector_size(sector); 22 bool blank = true; 23 /* flash_func_read_word：函数返回飞控固件flash域内某地址的值，输入的地址值自动加上APP_LOAD_ADDRESS（0x08004000），定义在main_f4.c */ 24 for (unsigned i = 0; i < size; i += sizeof(uint32_t)) { 25 if (flash_func_read_word(address + i) != 0xffffffff) { 26 blank = false; 27 break; 28 } 29 } 30 31 /* 根据blank的取值进行标记确定是否擦除当前段 */ 32 /* blank：当前段是否为空的标记 */ 33 /* FLASH_CR_PROGRAM_X32：值2，表示flash写入的并行度为32位，定义在libopencm3/include/libopencm3/stm32/common/flash_common_f24.h */ 34 /* flash_erase_sector：擦除某段的库函数，定义在libopencm3/lib/stm32/common/flash_common_f24.c */ 35 if (!blank) { 36 flash_erase_sector(flash_sectors[sector].sector_number, FLASH_CR_PROGRAM_X32); 37 } 38}
8.4.4 flash_func_write_word函数
flash_func_write_word函数用于编写特定地址的flash，以4字节编写，输入地址自动加上APP_LOAD_ADDRESS（0x08004000）。
main_f4.c
1void flash_func_write_word(uint32_t address, uint32_t word) 2{ 3 /* flash_program_word：在某地址编写flash字的库函数，定义在libopencm3/lib/stm32/common/flash_common_f24.c */ 4 flash_program_word(address + APP_LOAD_ADDRESS, word); 5}
8.4.5 flash_func_read_otp函数
flash_func_read_otp函数读取OTP区的一个字，输入地址为相对地址（相对于OTP区基地址）。
main_f4.c
1#define OTP_BASE 0x1fff7800 /* OTP区基地址 */ 2#define OTP_SIZE 512 /* OTP区大小 */ 3 4uint32_t flash_func_read_otp(uint32_t address) 5{ 6 /* 若给定地址不是4字节对齐或者超出OTP区的范围，返回0 */ 7 /* OTP_SIZE：值512，OTP区的大小（byte），定义在main_f4.c */ 8 /* OTP_BASE：值0x1fff7800，OTP区基地址，定义在main_f4.c */ 9 if (address & 3) { 10 return 0; 11 } 12 if (address > OTP_SIZE) { 13 return 0; 14 } 15 return *(uint32_t *)(address + OTP_BASE); 16}
8.4.6 flash_func_read_sn函数
flash_func_read_sn函数读取MCU的UDID（Unique Device ID）某字（共12byte，3字）。
main_f4.c
1#define UDID_START 0x1FFF7A10 /* UDID_START：UDID寄存器基地址，值0x1FFF7A10，定义在main_f4.c */ 2 3uint32_t flash_func_read_sn(uint32_t address) 4{ 5 return *(uint32_t *)(address + UDID_START); 6}
8.5 board_test_usart_receiving_break函数
board_test_usart_receiving_break没有使用USART控制器来接收信息，而是使用systick时钟来软件模拟串口的接收。程序看起来复杂，实质非常简单。它的功能就是：连续接收3个字节的内容，如果收到一个0字节则返回真，否则返回假。break字符为字节0。
main_f4.c
1static bool board_test_usart_receiving_break() 2{ 3#if !defined(SERIAL_BREAK_DETECT_DISABLED) /* 宏SERIAL_BREAK_DETECT_DISABLED未定义，下列代码有效 */ 4 /* 启动systick定时器 */ 5 systick_interrupt_disable(); /* 关闭systick中断（libopencm3/lib/cm3/systick.c） */ 6 systick_counter_disable(); /* systick倒计时关闭（libopencm3/lib/cm3/systick.c） */ 7 systick_set_clocksource(STK_CSR_CLKSOURCE_AHB); /* 选取AHB作为systick的时钟源，STK_CSR_CLKSOURCE_AHB=1<<2（libopencm3/include/libopencm3/cm3/systick.h） */ 8 9 /* board_info.systick_mhz：值168，定义在main_f4.c */ 10 /* USART_BAUDRATE：值115200，定义在hw_config.h */ 11 /* 设置systick时钟倒计时（寄存器STK_VAL）约为729，为串口波特率的一半 */ 12 systick_set_reload(((board_info.systick_mhz * 1000000) / USART_BAUDRATE) >> 1); 13 systick_counter_enable(); /* systick倒计时开启（libopencm3/lib/cm3/systick.c) */ 14 15 uint8_t cnt_consecutive_low = 0; 16 uint8_t cnt = 0; 17 18 /* 检测连续3个字节，若有1个字节值为0，则跳出循环。每个传播周期包含10位（1起始+8数据+1停止）。 */ 19 while (cnt < 60) { 20 /* BOARD_PORT_USART：值GPIOD，定义在hw_config.h */ 21 /* BOARD_PIN_RX：值GPIO6，定义在hw_config.h */ 22 /* systick_get_countflag：定义在libopencm3/lib/cm3/systick.c，当systick倒计时为0时返回1，否则返回0。库中定义的寄存器STK_CSR即为寄存器STK_CTRL */ 23 /* gpio_get：定义在libopencm3/lib/stm32/common/gpio_common_all.c，功能为获取某GPIO组的值 */ 24 if (systick_get_countflag() == 1) { 25 if (gpio_get(BOARD_PORT_USART, BOARD_PIN_RX) == 0) { 26 cnt_consecutive_low++; // Increment the consecutive low counter 27 } else { 28 cnt_consecutive_low = 0; // Reset the consecutive low counter 29 } 30 cnt++; 31 } 32 // 若连续收到9个低电平（1起始+8数据），即一个字节0，则跳出循环 33 if (cnt_consecutive_low >= 18) { 34 break; 35 } 36 } 37 38 systick_counter_disable(); /* systick倒计时关闭（libopencm3/lib/cm3/systick.c） */ 39 40 /* 如果检测到9个低电平（1起始+8数据），则返回真，否则返回假 */ 41 if (cnt_consecutive_low >= 18) { 42 return true; 43 } 44#endif // !defined(SERIAL_BREAK_DETECT_DISABLED) 45 46 return false; 47}
8.6 LED操作函数
LED操作函数包含点亮led_on、熄灭led_off和反向led_toggle三个函数。
8.6.1 led_on函数
main_f4.c
1void led_on(unsigned led) 2{ 3 /* LED_ACTIVITY：值1，定义在bl.h */ 4 /* LED_BOOTLOADER：值2，定义在bl.h */ 5 /* BOARD_PORT_LEDS：值GPIOE（指向GPIOE首寄存器），定义在hw_config.h */ 6 /* BOARD_PIN_LED_ACTIVITY：值0，无此LED，定义在hw_config.h */ 7 /* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<12），定义在hw_config.h */ 8 /* BOARD_LED_ON：被hw_config.h定义为gpio_clear函数,功能为置某GPIO组中的引脚输出为低电平（libopencm3/lib/stm32/common/gpio_common_all.c） */ 9 switch (led) { 10 case LED_ACTIVITY: 11 BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY); 12 break; 13 case LED_BOOTLOADER: 14 BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER); 15 break; 16 } 17}
8.6.2 led_off函数
main_f4.c
1void led_off(unsigned led) 2{ 3 /* LED_ACTIVITY：值1，定义在bl.h */ 4 /* LED_BOOTLOADER：值2，定义在bl.h */ 5 /* BOARD_PORT_LEDS：值GPIOE（指向GPIOE首寄存器），定义在hw_config.h */ 6 /* BOARD_PIN_LED_ACTIVITY：值0，无此LED，定义在hw_config.h */ 7 /* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<12），定义在hw_config.h */ 8 /* BOARD_LED_OFF：被hw_config.h定义为gpio_set函数,功能为置某GPIO组中的引脚输出为高电平（libopencm3/lib/stm32/common/gpio_common_all.c） */ 9 switch (led) { 10 case LED_ACTIVITY: 11 BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY); 12 break; 13 case LED_BOOTLOADER: 14 BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER); 15 break; 16 } 17}
8.6.3 led_toggle函数
main_f4.c
1 /* LED_ACTIVITY：值1，定义在bl.h */ 2 /* LED_BOOTLOADER：值2，定义在bl.h */ 3 /* BOARD_PORT_LEDS：值GPIOE（指向GPIOE首寄存器），定义在hw_config.h */ 4 /* BOARD_PIN_LED_ACTIVITY：值0，无此LED，定义在hw_config.h */ 5 /* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<12），定义在hw_config.h */ 6 /* gpio_toggle：反向函数，定义在libopencm3/lib/stm32/common/gpio_common_all.c */ 7void led_toggle(unsigned led) 8{ 9 switch (led) { 10 case LED_ACTIVITY: 11 gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY); 12 break; 13 case LED_BOOTLOADER: 14 gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER); 15 break; 16 } 17}
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
1#define DBGMCU_IDCODE 0xE0042000 /* DBGMCU_IDCODE，寄存器，存放芯片ID和版本信息 */ 2 3uint32_t get_mcu_id(void) 4{ 5 return *(uint32_t *)DBGMCU_IDCODE; 6}
8.7.2 get_mcu_desc函数
get_mcu_desc函数返回MCU的型号和版本描述信息。
main_f4.c
1#define DBGMCU_IDCODE 0xE0042000 /* DBGMCU_IDCODE，寄存器，存放芯片ID和版本信息 */ 2#define DEVID_MASK 0xFFF /* MCU的ID存放在DBGMCU_IDCODE寄存器的低12位 */ 3#define STM32_UNKNOWN 0 /* 未知芯片描述的index */ 4 5int get_mcu_desc(int max, uint8_t *revstr) 6{ 7 /* 获取MCU的ID和版本，分别存放在变量mcuid和revid中 */ 8 uint32_t idcode = (*(uint32_t *)DBGMCU_IDCODE); 9 int32_t mcuid = idcode & DEVID_MASK; 10 mcu_rev_e revid = (idcode & REVID_MASK) >> 16; 11 12 /* 初始化MCU描述信息为未知 */ 13 mcu_des_t des = mcu_descriptions[STM32_UNKNOWN]; 14 15 /* 根据mcuid依次查找数组mcu_descriptions中匹配项，若匹配则找到该MCU的型号描述 */ 16 /* mcu_descriptions：mcu_des_t型数组，用于存放MCU的型号描述信息，定义在main_f4.c */ 17 /* arraySize：以宏形式定义的函数，用于计算数组的成员个数，定义在bl.h */ 18 for (int i = 0; i < arraySize(mcu_descriptions); i++) { 19 if (mcuid == mcu_descriptions[i].mcuid) { 20 des = mcu_descriptions[i]; 21 break; 22 } 23 } 24 25 /* 根据revid依次查找数组mcu_descriptions中匹配项，若匹配则找到该MCU的版本 */ 26 /* silicon_revs：mcu_rev_t型数组，用于存放MCU版本信息，定义在main_f4.c */ 27 /* arraySize：以宏形式定义的函数，用于计算数组的成员个数，定义在bl.h */ 28 for (int i = 0; i < arraySize(silicon_revs); i++) { 29 if (silicon_revs[i].revid == revid) { 30 des.rev = silicon_revs[i].rev; 31 } 32 } 33 34 /* 按位字符操作，将MCU的描述和版本信息存储到缓冲区，中间用“,”隔开 */ 35 uint8_t *endp = &revstr[max - 1]; 36 uint8_t *strp = revstr; 37 while (strp < endp && *des.desc) { 38 *strp++ = *des.desc++; 39 } 40 if (strp < endp) { 41 *strp++ = ','; 42 } 43 if (strp < endp) { 44 *strp++ = des.rev; 45 } 46 return strp - revstr; 47}
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
1int check_silicon(void) 2{ 3#if defined(TARGET_HW_PX4_FMU_V2) || defined(TARGET_HW_PX4_FMU_V4) /* 定义了宏TARGET_HW_PX4_FMU_V2，因此下列代码有效，将被编译。 */ 4 /* 宏DBGMCU_IDCODE被定义在main_f4.c中，代表地址为0xE0042000的寄存器。变量idcode包含信息REV_ID(31:16)和DEV_ID(11:0) */ 5 uint32_t idcode = (*(uint32_t *)DBGMCU_IDCODE); 6 /* 宏REVID_MASK被定义在main_f4.c中，值为0xFFFF0000。变量revid为REV_ID的值 */ 7 mcu_rev_e revid = (idcode & REVID_MASK) >> 16; 8 9 /* 宏FIRST_BAD_SILICON_OFFSET被main_f4.c定义为1，代表第1块sector（从0开始编号） */ 10 /* 变量silicon_revs为mcu_rev_t型结构体数组，存储MCU版本号与其代码的对应信息 */ 11 /* 以宏形式定义的函数arraySize()在bl.h中，其功能为求解数组的成员个数 */ 12 /* 此循环的功能是，若使用自FIRST_BAD_SILICON_OFFSET序号以后的MCU版本（REV_ID），则函数返回-1，否则返回0 */ 13 for (int i = FIRST_BAD_SILICON_OFFSET; i < arraySize(silicon_revs); i++) { 14 if (silicon_revs[i].revid == revid) { 15 return -1; 16 } 17 } 18#endif 19 return 0; 20}
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
1static void board_init(void) 2{ 3 /* 1. 初始化LED控制并点亮LED灯 */ 4 /* 根据原理图，GPIOB14（IO-LED_BLUE）和GPIOB15（IO-LED_AMBER）分别控制IO协处理器的B/E（LED703）和ACT（LED705），低电平有效 */ 5 /* BOARD_CLOCK_LEDS_REGISTER：被定义为寄存器RCC_APB2ENR，hw_config.h */ 6 /* BOARD_CLOCK_LEDS：被hw_config.h定义为RCC_APB2ENR_IOPBEN，值1<<3（bit3），定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 7 /* BOARD_PORT_LEDS：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */ 8 /* GPIO_MODE_OUTPUT_50_MHZ：值0x03，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */ 9 /* GPIO_CNF_OUTPUT_PUSHPULL：值0x00，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */ 10 /* BOARD_PIN_LED_BOOTLOADER：被定义为GPIO15，值1<<15，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */ 11 /* BOARD_PIN_LED_ACTIVITY：被定义为GPIO14，值1<<14，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */ 12 /* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 13 /* gpio_set_mode：设置GPIO引脚工作模式，定义在libopencm3/lib/stm32/f1/gpio.c */ 14 /* BOARD_LED_ON：被hw_config.h定义为gpio_clear（libopencm3/lib/stm32/common/gpio_common_all.c） */ 15 /* 第一行，启动GPIOB时钟，通过操作RCC_APB2ENR寄存器的域IOPBEN（bit3） */ 16 /* 第二行，设置GPIOB14和GPIOB15为最大频率50MHz输出（MODE=GPIO_MODE_OUTPUT_50_MHZ=11），push-pull模式（CNF=GPIO_CNF_OUTPUT_PUSHPULL=00） */ 17 /* 第三行，设置GPIOB13和GPIOB15为低电平，点亮两个LED灯 */ 18 rcc_peripheral_enable_clock(&BOARD_CLOCK_LEDS_REGISTER, BOARD_CLOCK_LEDS); 19 gpio_set_mode(BOARD_PORT_LEDS, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); 20 BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); 21 22 /* if we have one, enable the force-bootloader pin */ 23#ifdef BOARD_FORCE_BL_PIN /* 宏BOARD_FORCE_BL_PIN有定义，代码有效 */ 24 /* 2. 设置强制Bootloader引脚GPIOB5为浮动输入模式，方便采集安全开关的状态 */ 25 /* 根据原理图，GPIOB5（IO-LED_SAFETY）连接安全开关，程序默认设置为高电平。采集到安全开关闭合（电平拉低）有效 */ 26 /* BOARD_FORCE_BL_CLOCK_REGISTER：被定义为寄存器RCC_APB2ENR，hw_config.h */ 27 /* BOARD_FORCE_BL_CLOCK_BIT：被hw_config.h定义为RCC_APB2ENR_IOPBEN，值1<<3（bit3），定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 28 /* BOARD_FORCE_BL_PORT：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */ 29 /* BOARD_FORCE_BL_PIN：被定义为GPIO5，值1<<5，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */ 30 /* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */ 31 /* BOARD_FORCE_BL_PULL：被hw_config.h定义为GPIO_CNF_INPUT_FLOAT，值0x01，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */ 32 /* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 33 /* gpio_set：设置GPIO引脚电平，置1（set位），定义在libopencm3/lib/stm32/common/gpio_common_all.c */ 34 /* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */ 35 /* 第一行，启动GPIOB时钟，通过操作RCC_APB2ENR寄存器的域IOPBEN（bit3） */ 36 /* 第二行，设置GPIOB5（IO-LED_SAFETY）为高电平 */ 37 /* 第三行，设置GPIOB5（IO-LED_SAFETY）为输入模式（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=BOARD_FORCE_BL_PULL=01） */ 38 rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT); 39 gpio_set(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN); 40 gpio_set_mode(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN); 41#endif 42 43 /* 3. 使能能源接口时钟和备份接口时钟，准备备份寄存器 */ 44 /* RCC_APB1ENR：APB1寄存器，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 45 /* RCC_APB1ENR_PWREN：值1<<28，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 46 /* RCC_APB1ENR_BKPEN：值1<<27，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 47 /* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 48 rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN); 49 50#ifdef INTERFACE_USART /* 宏INTERFACE_USART定义为USART2，hw_config.h，代码有效 */ 51 /* 4. 设置USART2-TX引脚GPIOA2，对应原理图SERIAL_IO_TO_FMU，用于IO协处理器发送信息到主控FMU */ 52 /* BOARD_USART_PIN_CLOCK_REGISTER：被定义为寄存器RCC_APB2ENR，hw_config.h */ 53 /* BOARD_USART_PIN_CLOCK_BIT：被hw_config.h定义为RCC_APB2ENR_IOPAEN，值1<<2（bit2，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h） */ 54 /* BOARD_PORT_USART：被定义为GPIOA（GPIOA寄存器首地址0x40010800），hw_config.h */ 55 /* GPIO_MODE_OUTPUT_50_MHZ：值0x03，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */ 56 /* GPIO_CNF_OUTPUT_ALTFN_PUSHPULL：值0x02，定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */ 57 /* BOARD_PIN_TX：被hw_config.h定义为GPIO_USART2_TX，值GPIO2（1<<2），libopencm3/include/libopencm3/stm32/f1/gpio.h */ 58 /* BOARD_USART_CLOCK_REGISTER：被定义为寄存器RCC_APB1ENR，hw_config.h */ 59 /* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17，libopencm3/include/libopencm3/stm32/f1/rcc.h */ 60 /* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 61 /* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */ 62 /* 第一行，使能USART2所在的GPIOA时钟 */ 63 /* 第二行，设置USART2的发送引脚GPIOA2为50MHz输出模式（MODE=GPIO_MODE_OUTPUT_50_MHZ=11），特殊功能push-pull模式（CNF=GPIO_CNF_OUTPUT_ALTFN_PUSHPULL=10） */ 64 /* 第三行，重置USART2时钟 */ 65 rcc_peripheral_enable_clock(&BOARD_USART_PIN_CLOCK_REGISTER, BOARD_USART_PIN_CLOCK_BIT); 66 gpio_set_mode(BOARD_PORT_USART, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, BOARD_PIN_TX); 67 rcc_peripheral_enable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT); 68#endif 69#ifdef INTERFACE_I2C /* 宏INTERFACE_I2C未定义，代码无效 */ 70# error I2C GPIO config not handled yet 71#endif 72}
9.1.2 board_deinit函数
board_deinit函数用于板载设备的反向初始化，主要的功能如下：
- 无效化LED控制引脚GPIOB14和GPIOB15
- 无效化强制Bootloader引脚GPIOB5
- 关闭能源接口时钟和备份接口时钟，不可访问备份寄存器
- 无效化USART2-TX引脚GPIOA2
- 设置APB2寄存器为默认值，关闭所有外部时钟
main_f1.c
1void board_deinit(void) 2{ 3 /* 1. 无效化LED控制引脚GPIOB14和GPIOB15 */ 4 /* 根据原理图，GPIOB14（IO-LED_BLUE）和GPIOB15（IO-LED_AMBER）分别控制IO协处理器的B/E（LED703）和ACT（LED705），低电平有效 */ 5 /* BOARD_PORT_LEDS：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */ 6 /* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */ 7 /* GPIO_CNF_INPUT_FLOAT：值0x01，libopencm3/include/libopencm3/stm32/f1/gpio.h */ 8 /* BOARD_PIN_LED_BOOTLOADER：被定义为GPIO15，值1<<15，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */ 9 /* BOARD_PIN_LED_ACTIVITY：被定义为GPIO14，值1<<14，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */ 10 /* gpio_set_mode：设置GPIO引脚工作模式，定义在libopencm3/lib/stm32/f1/gpio.c */ 11 /* 设置GPIOB14和GPIOB15为输入模式（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=GPIO_CNF_INPUT_FLOAT=01） */ 12 gpio_set_mode(BOARD_PORT_LEDS, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); 13 14#ifdef BOARD_FORCE_BL_PIN /* 宏BOARD_FORCE_BL_PIN定义为GPIO5，代码有效，hw_config.h */ 15 /* 2. 无效化强制Bootloader引脚GPIOB5 */ 16 /* BOARD_FORCE_BL_PORT：被定义为GPIOB（GPIOB寄存器首地址0x40010C00），hw_config.h */ 17 /* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */ 18 /* GPIO_CNF_INPUT_FLOAT：值0x01，libopencm3/include/libopencm3/stm32/f1/gpio.h */ 19 /* BOARD_FORCE_BL_PIN：被定义为GPIO5，值1<<5，定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */ 20 /* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */ 21 /* gpio_clear：设置GPIO引脚电平，清0（reset位），定义在libopencm3/lib/stm32/common/gpio_common_all.c */ 22 /* 第一行，设置GPIOB5（IO-LED_SAFETY）为输入模式（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=BOARD_FORCE_BL_PULL=01） */ 23 /* 第二行，设置GPIOB5（IO-LED_SAFETY）为低电平 */ 24 gpio_set_mode(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_FORCE_BL_PIN); 25 gpio_clear(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN); 26#endif 27 28 /* 3. 关闭能源接口时钟和备份接口时钟，不可访问备份寄存器 */ 29 /* RCC_APB1ENR：APB1寄存器，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 30 /* RCC_APB1ENR_PWREN：值1<<28，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 31 /* RCC_APB1ENR_BKPEN：值1<<27，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 32 /* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 33 rcc_peripheral_disable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN); 34 35#ifdef INTERFACE_USART /* 宏INTERFACE_USART定义为1，代码有效 */ 36 /* 4. 无效化USART2-TX引脚GPIOA2 */ 37 /* BOARD_PORT_USART：被定义为GPIOA（GPIOA寄存器首地址0x40010800），hw_config.h */ 38 /* GPIO_MODE_INPUT：值0x00，libopencm3/include/libopencm3/stm32/f1/gpio.h */ 39 /* GPIO_CNF_INPUT_FLOAT：值0x01，libopencm3/include/libopencm3/stm32/f1/gpio.h */ 40 /* BOARD_PIN_TX：被hw_config.h定义为GPIO_USART2_TX，值GPIO2（1<<2），libopencm3/include/libopencm3/stm32/f1/gpio.h */ 41 /* BOARD_USART_CLOCK_REGISTER：被定义为寄存器RCC_APB1ENR，hw_config.h */ 42 /* BOARD_USART_CLOCK_BIT：被hw_config.h定义为RCC_APB1ENR_USART2EN，值1<<17，libopencm3/include/libopencm3/stm32/f1/rcc.h */ 43 /* rcc_peripheral_enable_clock：使能外部特定时钟，定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 44 /* gpio_set_mode：设置GPIO引脚工作模式，libopencm3/lib/stm32/f1/gpio.c */ 45 /* 第一行，设置USART2的发送引脚GPIOA2为输入（MODE=GPIO_MODE_INPUT=00），浮动模式（CNF=GPIO_CNF_INPUT_FLOAT=01） */ 46 /* 第二行，关闭USART2时钟 */ 47 gpio_set_mode(BOARD_PORT_USART, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_PIN_TX); 48 rcc_peripheral_disable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT); 49#endif 50 51#ifdef INTERFACE_I2C /* 宏INTERFACE_I2C未定义，代码无效 */ 52# error I2C GPIO config not handled yet 53#endif 54 55 /* 5. 设置APB2寄存器为默认值，关闭所有外部时钟 */ 56 /* RCC_APB2ENR：寄存器，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 57 RCC_APB2ENR = 0x00000000; // XXX Magic reset number from STM32F1x reference manual 58}
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
1static inline void clock_init(void) 2{ 3#if defined(INTERFACE_USB) /* 宏INTERFACE_USB定义为0，代码有效 */ 4 /* rcc_clock_setup_in_hsi_out_48mhz：使用HSI设置MCU的系统时钟为PLL，48MHz，定义在libopencm3/lib/stm32/f1/rcc.c */ 5 rcc_clock_setup_in_hsi_out_48mhz(); 6#else 7 rcc_clock_setup_in_hsi_out_24mhz(); 8#endif 9}
9.2.2 clock_deinit函数
clock_deinit函数关闭时钟源，将所有内部时钟设置为重启后的初始状态，为飞控固件的运行提供良好的初始环境，主要操作如下：
- 使能HSI时钟
- 重置寄存器RCC_CFGR，清空时钟配置
- 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI
- 关闭HSE旁路功能
- 清除所有时钟中断
main_f1.c
1void clock_deinit(void) 2{ 3 /* 1. 使能HSI时钟 */ 4 /* RCC_HSI：值4，rcc_osc枚举型，libopencm3/include/libopencm3/stm32/f1/rcc.h */ 5 /* rcc_osc_on：开启某内部时钟，操作寄存器RCC_CR。rcc_osc_on(RCC_HSI)操作HSION域（bit0），定义在libopencm3/lib/stm32/f1/rcc.c */ 6 /* rcc_wait_for_osc_ready：等待某内部时钟稳定，读取寄存器RCC_CR。rcc_wait_for_osc_ready(RCC_HSI)读取HSIRDY（bit1），定义在libopencm3/lib/stm32/f1/rcc.c */ 7 rcc_osc_on(RCC_HSI); 8 rcc_wait_for_osc_ready(RCC_HSI); 9 10 /* 2. 重置寄存器RCC_CFGR，清空时钟配置 */ 11 /* RCC_CFGR：寄存器，libopencm3/include/libopencm3/stm32/f1/rcc.h */ 12 RCC_CFGR = 0x000000; 13 14 /* 3. 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统（CSS），此时切换为HSI */ 15 /* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 16 /* RCC_PLL：值0，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */ 17 /* rcc_osc_off：关闭某内部时钟，操作寄存器RCC_CR。定义在libopencm3/lib/stm32/f1/rcc.c */ 18 /* rcc_css_disable：关闭时钟安全系统，操作寄存器RCC_CR的域CSSON（bit19）。定义在libopencm3/lib/stm32/f1/rcc.c */ 19 /* rcc_osc_off(RCC_HSE)操作HSEON域（bit16），rcc_osc_off(RCC_PLL)操作PLLON域（bit24）。定义在libopencm3/lib/stm32/f1/rcc.c */ 20 /* Stop the HSE, CSS, PLL, PLLI2S, PLLSAI */ 21 rcc_osc_off(RCC_HSE); 22 rcc_osc_off(RCC_PLL); 23 rcc_css_disable(); 24 25 /* 4. 关闭HSE旁路功能 */ 26 /* RCC_HSE：值3，rcc_osc枚举变量，定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 27 /* rcc_osc_bypass_disable：关闭HSE的旁路功能，操作寄存器RCC_CR的HSEBYP域（bit18） */ 28 rcc_osc_bypass_disable(RCC_HSE); 29 30 /* 5. 清除所有时钟中断 */ 31 /* RCC_CIR：RCC时钟中断寄存器 */ 32 RCC_CIR = 0x000000; 33}
9.3 LED操作函数
LED操作函数包含点亮led_on、熄灭led_off和反向led_toggle三个函数。
9.3.1 led_on函数
main_f1.c
1void led_on(unsigned led) 2{ 3 /* LED_ACTIVITY：值1，定义在bl.h */ 4 /* LED_BOOTLOADER：值2，定义在bl.h */ 5 /* BOARD_PORT_LEDS：值GPIOB（指向GPIOB首寄存器），定义在hw_config.h */ 6 /* BOARD_PIN_LED_ACTIVITY：值GPIO14（1<<14），定义在hw_config.h */ 7 /* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<15），定义在hw_config.h */ 8 /* BOARD_LED_ON：被hw_config.h定义为gpio_clear函数,功能为置某GPIO组中的引脚输出为低电平（libopencm3/lib/stm32/common/gpio_common_all.c） */ 9 switch (led) { 10 case LED_ACTIVITY: 11 BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY); 12 break; 13 case LED_BOOTLOADER: 14 BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER); 15 break; 16 } 17}
9.3.2 led_off函数
main_f1.c
1void led_off(unsigned led) 2{ 3 /* LED_ACTIVITY：值1，定义在bl.h */ 4 /* LED_BOOTLOADER：值2，定义在bl.h */ 5 /* BOARD_PORT_LEDS：值GPIOB（指向GPIOB首寄存器），定义在hw_config.h */ 6 /* BOARD_PIN_LED_ACTIVITY：值GPIO14（1<<14），定义在hw_config.h */ 7 /* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<15），定义在hw_config.h */ 8 /* BOARD_LED_OFF：被hw_config.h定义为gpio_set函数,功能为置某GPIO组中的引脚输出为高电平（libopencm3/lib/stm32/common/gpio_common_all.c） */ 9 switch (led) { 10 case LED_ACTIVITY: 11 BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY); 12 break; 13 case LED_BOOTLOADER: 14 BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER); 15 break; 16 } 17}
9.3.3 led_off函数
1void led_toggle(unsigned led) 2{ 3 /* LED_ACTIVITY：值1，定义在bl.h */ 4 /* LED_BOOTLOADER：值2，定义在bl.h */ 5 /* BOARD_PORT_LEDS：值GPIOB（指向GPIOB首寄存器），定义在hw_config.h */ 6 /* BOARD_PIN_LED_ACTIVITY：值GPIO14（1<<14），定义在hw_config.h */ 7 /* BOARD_PIN_LED_BOOTLOADER：值GPIO12（1<<15），定义在hw_config.h */ 8 /* gpio_toggle：反向函数，定义在libopencm3/lib/sam/common/gpio_common_all.c */ 9 switch (led) { 10 case LED_ACTIVITY: 11 gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY); 12 break; 13 case LED_BOOTLOADER: 14 gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER); 15 break; 16 } 17}
9.4 flash操作函数
这里的flash操作是针对飞控固件部分flash的。
9.4.1 flash_func_read_word函数
flash_func_read_word函数返回飞控固件flash域内某地址的值，输入的地址值需加上APP_LOAD_ADDRESS（0x08001000）。
main_f1.c
1uint32_t flash_func_read_word(uint32_t address) 2{ 3 /* APP_LOAD_ADDRESS：值0x08001000，定义在hw_config.h */ 4 return *(uint32_t *)(address + APP_LOAD_ADDRESS); 5}
9.4.2 flash_func_sector_size函数
flash_func_sector_size函数返回MCU的flash在某sector的大小值，若无此sector，则返回0。对于STM32F1芯片，片内以页计算，无sector概念，故这里的sector表示页。
main_f1.c
1/* BOARD_FLASH_SECTORS：STM32F1片内flash页数，Bootloader认为片内flash的前60页有效，定义在hw_config.h */ 2/* FLASH_SECTOR_SIZE：STM32F1片内flash每页大小为1KB，定义在hw_config.h */ 3uint32_t flash_func_sector_size(unsigned sector) 4{ 5 if (sector < BOARD_FLASH_SECTORS) { 6 return FLASH_SECTOR_SIZE; 7 } 8 return 0; 9} 10
9.4.3 flash_func_erase_sector函数
flash_func_erase_sector函数擦除当前页。
main_f1.c
1void flash_func_erase_sector(unsigned sector) 2{ 3 /* BOARD_FLASH_SECTORS：值60，表示MCU中flash的页数，定义在hw_config.h */ 4 /* APP_LOAD_ADDRESS：值0x08001000，表示飞控固件起始地址，定义在hw_config.h */ 5 /* FLASH_SECTOR_SIZE：值0x400，表示MCU中每页flash的大小均为1KB，定义在hw_config.h */ 6 /* flash_erase_page：库函数擦写当前地址所在的页，定义在libopencm3/lib/stm32/f1/flash.c */ 7 if (sector < BOARD_FLASH_SECTORS) { 8 flash_erase_page(APP_LOAD_ADDRESS + (sector * FLASH_SECTOR_SIZE)); 9 } 10}
9.4.4 flash_func_write_word函数
flash_func_write_word函数用于编写特定地址的flash，以4字节编写，输入地址自动加上APP_LOAD_ADDRESS（0x08004000）。
main_f1.c
1void flash_func_write_word(uint32_t address, uint32_t word) 2{ 3 /* flash_program_word：在某地址编写flash字的库函数，定义在libopencm3/lib/stm32/common/flash_common_f01.c */ 4 flash_program_word(address + APP_LOAD_ADDRESS, word); 5}
9.4.5 flash_func_read_otp函数
STM32F1芯片无OTP区，函数直接返回0。
main_f1.c
1uint32_t flash_func_read_otp(uint32_t address) 2{ 3 return 0; 4}
9.4.6 flash_func_read_sn函数
flash_func_read_sn函数读取MCU的UDID（Unique Device ID）某字（共12byte，3字）。
main_f1.c
1#define UDID_START 0x1FFFF7E8 /* UDID_START：UDID寄存器基地址，值0x1FFFF7E8，定义在main_f1.c */ 2 3uint32_t flash_func_read_sn(uint32_t address) 4{ 5 return *(uint32_t *)(address + UDID_START); 6}
9.5 获取芯片信息函数
9.5.1 get_mcu_id函数
get_mcu_id函数读取包含芯片ID和版本的寄存器DBGMCU_IDCODE值。
main_f1.c
1#define DBGMCU_IDCODE 0xE0042000 /* DBGMCU_IDCODE：寄存器，存放芯片ID和版本信息 */ 2 3uint32_t get_mcu_id(void) 4{ 5 return *(uint32_t *)DBGMCU_IDCODE; 6}
9.5.2 get_mcu_desc函数
get_mcu_desc函数直接返回MCU型号描述和版本信息，为固定值"STM32F1xxx,?"
main_f1.c
1int get_mcu_desc(int max, uint8_t *revstr) 2{ 3 const char none[] = "STM32F1xxx,?"; 4 int i; 5 for (i = 0; none[i] && i < max - 1; i++) { 6 revstr[i] = none[i]; 7 } 8 return i; 9}
9.6 should_wait函数
should_wait函数被main函数调用，判定RTC备份寄存器BKP_DR1中是否存储了预定值，如果存储了就返回真，否则返回假。
main_f1.c
1static bool should_wait(void) 2{ 3 bool result = false; /* 默认返回假 */ 4 5 /* 打开RTC备份寄存器访问 */ 6 /* PWR_CR：功率控制寄存器，定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */ 7 /* PWR_CR_DBP：值1<<8（bit8），定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */ 8 PWR_CR |= PWR_CR_DBP; 9 10 /* 若RTC备份寄存器BKP_DR1的值等于预定值0x19710317，则返回真且清零寄存器 */ 11 /* BKP_DR1：RTC备份寄存器1，定义在libopencm3/include/libopencm3/stm32/f1/bkp.h */ 12 /* BL_WAIT_MAGIC：值0x19710317，定义在bl.h */ 13 if (BKP_DR1 == BL_WAIT_MAGIC) { 14 result = true; 15 BKP_DR1 = 0; 16 } 17 18 /* 关闭RTC备份寄存器访问 */ 19 /* PWR_CR：功率控制寄存器，定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */ 20 /* PWR_CR_DBP：值1<<8（bit8），定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */ 21 PWR_CR &= ~PWR_CR_DBP; 22 23 return result; 24}
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
1/* USART：值为1，枚举类，定义在bl.h */ 2/* USB：值为2，枚举类，定义在bl.h */ 3inline void cinit(void *config, uint8_t interface) 4{ 5#if INTERFACE_USB /* 主控FMU：宏INTERFACE_USB值为1，代码有效，定义在hw_config.h */ 6 /* IO协处理器：宏INTERFACE_USB值为0，代码无效，定义在hw_config.h */ 7 if (interface == USB) { 8 return usb_cinit(); 9 } 10#endif 11#if INTERFACE_USART /* 宏INTERFACE_USART值为1，代码有效，定义在hw_config.h */ 12 if (interface == USART) { 13 return uart_cinit(config); 14 } 15#endif 16}
10.1.2 uart_cinit函数
usart初始化函数uart_cinit，输入参数config为void*型指针，值为USART寄存器基地址。此函数使用SOC上的串口寄存器进行设置，功能为115200@8N1，收发通信，无硬件流控制。在pixahwk V2硬件和PX4代码使用USART作为上位机通信串口，config值USART2的寄存器基地址（0x40004400）。
usart.c
1uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */ 2 3void uart_cinit(void *config) 4{ 5 /* 全局变量usart指向串口寄存器基地址 */ 6 usart = (uint32_t)config; 7 8 /* 引脚和时钟初始化 */ 9 /* USART_CR1：根据给定的USART寄存器首地址移位0x0c来获取寄存器USART_CR1。 */ 10 /* 寄存器USART_CR1的bit15为OVER8域，控制串口的过采样模式。默认值0：16次过采样，值1：8次过采样。 */ 11 //USART_CR1(usart) |= (1 << 15); /* libopencm3不支持USART_CR1寄存器的OVER8位操作 */ 12 /* USART_BAUDRATE：值115200，定义在hw_config.h */ 13 /* usart_set_baudrate：用于设置串口波特率，操作寄存器USART_BRR，定义在libopencm3/lib/stm32/common/usart_common_all.c */ 14 /* 库函数usart_set_baudrate用到了库全局变量rcc_apb1_frequency作为时钟输入。 */ 15 usart_set_baudrate(usart, USART_BAUDRATE); 16 /* usart_set_databits：用于设置串口数据位数（8或9），操作寄存器USART_CR1域M（bit12），定义在libopencm3/lib/stm32/common/usart_common_all.c */ 17 usart_set_databits(usart, 8); 18 /* USART_STOPBITS_1：值0x00<<12，表示停止位1（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */ 19 /* usart_set_stopbits：用于设置串口停止位数，操作寄存器USART_CR2域STOP（bit13:12），定义在libopencm3/lib/stm32/common/usart_common_all.c */ 20 usart_set_stopbits(usart, USART_STOPBITS_1); 21 /* USART_MODE_TX_RX：值USART_CR1_RE|USART_CR1_TE，表示收+发（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */ 22 /* USART_CR1_RE：值1<<2（libopencm3/include/libopencm3/stm32/common/usart_common_f124.h） */ 23 /* USART_CR1_TE：值1<<3（libopencm3/include/libopencm3/stm32/common/usart_common_f124.h） */ 24 /* usart_set_mode：用于设置串口传输模式（单收，单发，收+发），操作寄存器USART_CR1域TE（bit3）和域RE（bit2），定义在libopencm3/lib/stm32/common/usart_common_all.c */ 25 usart_set_mode(usart, USART_MODE_TX_RX); 26 /* USART_PARITY_NONE：值0x00，表示无校验（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */ 27 /* usart_set_parity：用于设置串口校验模式（无、奇、偶），操作寄存器USART_CR1域PCE（bit10）和域PS（bit9），定义在libopencm3/lib/stm32/common/usart_common_all.c */ 28 usart_set_parity(usart, USART_PARITY_NONE); 29 /* USART_FLOWCONTROL_NONE：值0x00，表示无硬件流控制（libopencm3/include/libopencm3/stm32/common/usart_common_all.h） */ 30 /* usart_set_flow_control：用于设置硬件流控制（无、RTS、CTS、RTS+CTS），操作寄存器USART_CR3的CTSE（bit9）和RTSE（bit8） */ 31 usart_set_flow_control(usart, USART_FLOWCONTROL_NONE); 32 33 /* usart_enable：用于使能串口，操作寄存器USART_CR1的域UE（bit13），定义在libopencm3/lib/stm32/common/usart_common_all.c */ 34 usart_enable(usart); 35}
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
1#define USB_CDC_REQ_GET_LINE_CODING 0x21 2 3#define OTG_CID_HAS_VBDEN 0x00002000 4#define OTG_GCCFG_VBDEN (1 << 21) 5 6/* USB设备字符串列表，下标从1开始 */ 7static const char *usb_strings[] = { 8 USBMFGSTRING, /* USBMFGSTRING：值"3D Robotics"，生产厂家名称，INDEX 1。（hw_config.h） */ 9 USBDEVICESTRING, /* USBDEVICESTRING："PX4 BL FMU v2.x"，USB设备名称，INDEX2。（hw_config.h） */ 10 "0", /* 设备序号，INDEX 3 */ 11}; 12#define NUM_USB_STRINGS (sizeof(usb_strings)/sizeof(usb_strings[0])) /* 上面定义的字符串数组usb_strings的成员个数 */ 13 14static usbd_device *usbd_dev; /* _usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数（libopencm3/lib/usb/usb_private.h） */ 15 16/* Buffer to be used for control requests. */ 17static uint8_t usbd_control_buffer[128]; 18 19/* 标准的USB设备描述符结构体变量dev，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */ 20static const struct usb_device_descriptor dev = { 21 .bLength = USB_DT_DEVICE_SIZE, /* USB_DT_DEVICE_SIZE：值18，本结构体的大小（libopencm3/include/libopencm3/usb/usbstd.h） */ 22 .bDescriptorType = USB_DT_DEVICE, /* USB_DT_DEVICE：值1，本结构体为USB设备描述符（libopencm3/include/libopencm3/usb/usbstd.h） */ 23 .bcdUSB = 0x0200, /* USB接口版本，0x0200表示符合USB2.0规范 */ 24 .bDeviceClass = USB_CLASS_CDC, /* USB_CLASS_CDC：值0x2，设备群组码（libopencm3/include/libopencm3/usb/cdc.h） */ 25 .bDeviceSubClass = 0, /* 设备次群组码 */ 26 .bDeviceProtocol = 0, /* 通信设备协议，0表示无群组特定协议 */ 27 .bMaxPacketSize0 = 64, /* 设备最大信息包大小为64字节（只能为8、16、32、64） */ 28 .idVendor = USBVENDORID, /* USBVENDORID：值0x26AC，USB设备厂家ID，这里是默认值（hw_config.h） */ 29 .idProduct = USBPRODUCTID, /* USBPRODUCTID：值0x0011，USB产品ID（hw_config.h） */ 30 .bcdDevice = 0x0101, /* USB设备发行序号，0x0101表示1.01版，为了兼容NuttX */ 31 .iManufacturer = 1, /* USB设备厂家字符串下标，1代表USBMFGSTRING（"3D Robotics"），数组usb_strings */ 32 .iProduct = 2, /* USB产品字符串下标，2代表USBDEVICESTRING（"PX4 BL FMU v2.x"），数组usb_strings */ 33 .iSerialNumber = 3, /* USB设备序号下标，3代表空（"0"） */ 34 .bNumConfigurations = 1, /* USB设备配置的数目为1个（config） */ 35}; 36 37/* USB通信端点描述符结构体数组变量comm_endp，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */ 38/* 这里仅对端点描述符的内容进行了赋值，结构体规定的额外内容在UNIX环境中被默认为0 */ 39static const struct usb_endpoint_descriptor comm_endp[] = {{ 40 .bLength = USB_DT_ENDPOINT_SIZE, /* USB_DT_ENDPOINT_SIZE：值7，端点描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */ 41 .bDescriptorType = USB_DT_ENDPOINT, /* USB_DT_ENDPOINT：值5，表示本结构体为USB端点描述符（libopencm3/include/libopencm3/usb/usbstd.h） */ 42 .bEndpointAddress = 0x83, /* 通信端点地址为0x83 */ 43 .bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT, /* USB_ENDPOINT_ATTR_INTERRUPT：值0x03，本通信端点为中断传输（libopencm3/include/libopencm3/usb/usbstd.h） */ 44 .wMaxPacketSize = 16, /* 数据包最大16字节 */ 45 .bInterval = 255, /* 轮询间隔255ms */ 46 } 47}; 48 49/* USB数据端点描述符结构体数组变量data_endp（2个，一般称为DATA0和DATA1），属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */ 50/* 这里仅对端点描述符的内容进行了赋值，结构体规定的额外内容在UNIX环境中被默认为0 */ 51static const struct usb_endpoint_descriptor data_endp[] = {{ 52 .bLength = USB_DT_ENDPOINT_SIZE, /* USB_DT_ENDPOINT_SIZE：值7，端点描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */ 53 .bDescriptorType = USB_DT_ENDPOINT, /* USB_DT_ENDPOINT：值5，表示本结构体为USB端点描述符（libopencm3/include/libopencm3/usb/usbstd.h） */ 54 .bEndpointAddress = 0x01, /* 此数据端点的地址为0x01 */ 55 .bmAttributes = USB_ENDPOINT_ATTR_BULK, /* USB_ENDPOINT_ATTR_BULK：值0x2，本数据端点为批量传输（libopencm3/include/libopencm3/usb/usbstd.h） */ 56 .wMaxPacketSize = 64, /* 数据包最大64字节 */ 57 .bInterval = 1, /* 轮询间隔1ms */ 58 }, { 59 .bLength = USB_DT_ENDPOINT_SIZE, /* USB_DT_ENDPOINT_SIZE：值7，端点描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */ 60 .bDescriptorType = USB_DT_ENDPOINT, /* USB_DT_ENDPOINT：值5，表示本结构体为USB端点描述符（libopencm3/include/libopencm3/usb/usbstd.h） */ 61 .bEndpointAddress = 0x82, /* 此数据端点的地址为0x82 */ 62 .bmAttributes = USB_ENDPOINT_ATTR_BULK, /* USB_ENDPOINT_ATTR_BULK：值0x2，本数据端点为批量传输（libopencm3/include/libopencm3/usb/usbstd.h） */ 63 .wMaxPacketSize = 64, /* 数据包最大64字节 */ 64 .bInterval = 1, /* 轮询间隔1ms */ 65 } 66}; 67 68/* 对USB CDC通信需要额外提供的信息进行汇总，用于到关联通信接口描述符comm_iface */ 69static const struct { 70 struct usb_cdc_header_descriptor header; 71 struct usb_cdc_call_management_descriptor call_mgmt; 72 struct usb_cdc_acm_descriptor acm; 73 struct usb_cdc_union_descriptor cdc_union; 74} __attribute__((packed)) cdcacm_functional_descriptors = { 75 .header = { 76 .bFunctionLength = sizeof(struct usb_cdc_header_descriptor), 77 .bDescriptorType = CS_INTERFACE, 78 .bDescriptorSubtype = USB_CDC_TYPE_HEADER, 79 .bcdCDC = 0x0110, 80 }, 81 .call_mgmt = { 82 .bFunctionLength = sizeof(struct usb_cdc_call_management_descriptor), 83 .bDescriptorType = CS_INTERFACE, 84 .bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT, 85 .bmCapabilities = 0, 86 .bDataInterface = 1, 87 }, 88 .acm = { 89 .bFunctionLength = sizeof(struct usb_cdc_acm_descriptor), 90 .bDescriptorType = CS_INTERFACE, 91 .bDescriptorSubtype = USB_CDC_TYPE_ACM, 92 .bmCapabilities = 0, 93 }, 94 .cdc_union = { 95 .bFunctionLength = sizeof(struct usb_cdc_union_descriptor), 96 .bDescriptorType = CS_INTERFACE, 97 .bDescriptorSubtype = USB_CDC_TYPE_UNION, 98 .bControlInterface = 0, 99 .bSubordinateInterface0 = 1, 100 } 101}; 102 103/* USB通信接口描述符结构体变量comm_iface，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */ 104static const struct usb_interface_descriptor comm_iface[] = {{ 105 .bLength = USB_DT_INTERFACE_SIZE, /* USB_DT_INTERFACE_SIZE：值9，接口描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */ 106 .bDescriptorType = USB_DT_INTERFACE, /* USB_DT_INTERFACE：值4，表示本结构体为USB接口描述符（libopencm3/include/libopencm3/usb/usbstd.h） */ 107 .bInterfaceNumber = 0, /* 接口数目1个，以0为基准开始计数 */ 108 .bAlternateSetting = 0, /* 交互设置值为0 */ 109 .bNumEndpoints = 1, /* 端点数目1个（comm_endp） */ 110 .bInterfaceClass = USB_CLASS_CDC, /* USB_CLASS_CDC：值0x02，接口群组（libopencm3/include/libopencm3/usb/cdc.h） */ 111 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM, /* USB_CDC_SUBCLASS_ACM：值0x02，接口次群组（libopencm3/include/libopencm3/usb/cdc.h） */ 112 .bInterfaceProtocol = USB_CDC_PROTOCOL_AT, /* USB_CDC_PROTOCOL_AT：值0x01，接口协议（libopencm3/include/libopencm3/usb/cdc.h） */ 113 .iInterface = 0, /* 接口的字符串描述符索引为0 */ 114 115 /* 以下内容不再属于USB接口描述符信息，为程序内部使用的变量 */ 116 .endpoint = comm_endp, /* 此接口对应的端点为comm_endp */ 117 .extra = &cdcacm_functional_descriptors, /* 通信接口额外信息域为cdcacm_functional_descriptors */ 118 .extralen = sizeof(cdcacm_functional_descriptors) /* 额外信息域长度 */ 119 } 120}; 121 122/* USB数据接口描述符结构体变量data_iface，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */ 123/* 这里仅进行了部分赋值，结构体规定的额外内容在UNIX环境中被默认为0 */ 124static const struct usb_interface_descriptor data_iface[] = {{ 125 .bLength = USB_DT_INTERFACE_SIZE, /* USB_DT_INTERFACE_SIZE：值9，接口描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */ 126 .bDescriptorType = USB_DT_INTERFACE, /* USB_DT_INTERFACE：值4，表示本结构体为USB接口描述符（libopencm3/include/libopencm3/usb/usbstd.h） */ 127 .bInterfaceNumber = 1, /* 接口数目2个，以0为基准开始计数 */ 128 .bAlternateSetting = 0, /* 交互设置值为0 */ 129 .bNumEndpoints = 2, /* 端点数目2个（data_endp） */ 130 .bInterfaceClass = USB_CLASS_DATA, /* USB_CLASS_DATA：值0x0a，接口群组（libopencm3/include/libopencm3/usb/cdc.h） */ 131 .bInterfaceSubClass = 0, /* 接口次群组为0 */ 132 .bInterfaceProtocol = 0, /* 接口协议，0表示无特定协议 */ 133 .iInterface = 0, /* 接口的字符串描述符索引为0，无效 */ 134 135 /* 以下内容不再属于USB接口描述符信息，为程序内部使用的变量 */ 136 .endpoint = data_endp, /* 此接口对应的端点为data_endp */ 137 } 138}; 139 140/* 变量ifaces对接口描述符进行了统计（共2个），用于关联到配置描述符中 */ 141static const struct usb_interface ifaces[] = {{ 142 .num_altsetting = 1, 143 .altsetting = comm_iface, 144 }, { 145 .num_altsetting = 1, 146 .altsetting = data_iface, 147 } 148}; 149 150/* USB配置描述符结构体变量config，属性packed，定义在libopencm3/include/libopencm3/usb/usbstd.h */ 151static const struct usb_config_descriptor config = { 152 .bLength = USB_DT_CONFIGURATION_SIZE, /* USB_DT_CONFIGURATION_SIZE：值9，配置描述符大小（libopencm3/include/libopencm3/usb/usbstd.h） */ 153 .bDescriptorType = USB_DT_CONFIGURATION, /* USB_DT_CONFIGURATION：值2，表示本结构体为USB配置描述符（libopencm3/include/libopencm3/usb/usbstd.h） */ 154 .wTotalLength = 0, /* 描述符的总长度为0（是否应该为32字节？接口描述符9+配置描述符9+端点描述符7*2） */ 155 .bNumInterfaces = 2, /* 该配置支持的接口数目2个（comm_iface和data_iface） */ 156 .bConfigurationValue = 1, /* 配置值为1，作为set configuration请求的配置值 */ 157 .iConfiguration = 0, /* 配置字符串描述符索引为0，无效 */ 158 .bmAttributes = 0x80, /* 配置的属性为0x80 */ 159 .bMaxPower = 0xFA, /* 当USB设备操作时，它从总线上获得的最大电源（单位2mA，0xFA=250，500mA） */ 160 161 /* 以下内容不再属于USB配置描述符信息，为程序内部使用的变量 */ 162 .interface = ifaces, /* 此配置对应的接口 */ 163}; 164 165/* USB虚拟串口属性结构体变量line_coding，属性packed，定义在libopencm3/include/libopencm3/usb/cdc.h */ 166static const struct usb_cdc_line_coding line_coding = { 167 .dwDTERate = 115200, /* 波特率115200 */ 168 .bCharFormat = USB_CDC_1_STOP_BITS, /* USB_CDC_1_STOP_BITS：值0，1位停止位（libopencm3/include/libopencm3/usb/cdc.h） */ 169 .bParityType = USB_CDC_NO_PARITY, /* USB_CDC_NO_PARITY：值0，无校验（libopencm3/include/libopencm3/usb/cdc.h） */ 170 .bDataBits = 0x08 /* 数据8位 */ 171}; 172 173/* USB虚拟串口请求控制函数，被配置函数cdcacm_set_config函数使用 */ 174static int cdcacm_control_request(usbd_device *usbd_dev, struct usb_setup_data *req, uint8_t **buf, uint16_t *len, 175 void (**complete)(usbd_device *usbd_dev, struct usb_setup_data *req)) 176{ 177 (void)complete; 178 (void)buf; 179 (void)usbd_dev; 180 181 switch (req->bRequest) { /* 请求类型 */ 182 case USB_CDC_REQ_SET_CONTROL_LINE_STATE: { /* USB_CDC_REQ_SET_CONTROL_LINE_STATE：值0x22，请求设置命令行状态，定义在libopencm3/include/libopencm3/usb/cdc.h */ 183 return 1; /* 不操作，直接返回1 */ 184 } 185 case USB_CDC_REQ_SET_LINE_CODING: /* USB_CDC_REQ_SET_LINE_CODING：值0x20，请求设置虚拟串口属性，定义在libopencm3/include/libopencm3/usb/cdc.h */ 186 if (*len < sizeof(struct usb_cdc_line_coding)) { /* 若配置的参数长度小于usb_cdc_line_coding的大小，返回0 */ 187 return 0; 188 } 189 return 1; /* 不操作，返回1 */ 190 case USB_CDC_REQ_GET_LINE_CODING: /* USB_CDC_REQ_GET_LINE_CODING：值0x21，请求读取虚拟串口属性，定义在cdcacm.c中 */ 191 *buf = (uint8_t *)&line_coding; /* buf指向虚拟串口属性变量line_coding（115200@8N1），定义在cdcacm.c中 */ 192 return 1; 193 } 194 return 0; 195} 196 197/* USB虚拟串口数据接收函数，被配置函数cdcacm_set_config函数使用 */ 198static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep) 199{ 200 (void)ep; 201 202 char buf[64]; 203 unsigned i; 204 /* usbd_ep_read_packet：去读USB设备usbd_dev在端点地址0x01的数据到缓冲区buf中，并返回读取到数据的个数。定义在libopencm3/lib/usb/usb.c */ 205 unsigned len = usbd_ep_read_packet(usbd_dev, 0x01, buf, sizeof(buf)); 206 207 /* 将数据赋值给接收数据缓冲区rx_buf */ 208 /* buf_put：将数据写入到缓冲区的函数，定义在bl.c */ 209 for (i = 0; i < len; i++) { 210 buf_put(buf[i]); 211 } 212} 213 214/* USB虚拟串口配置函数，被usb_cinit中的库函数usbd_register_set_config_callback引用 */ 215static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue) 216{ 217 (void)wValue; 218 219 /* USB_ENDPOINT_ATTR_BULK：值0x2，批量传输（libopencm3/include/libopencm3/usb/usbstd.h） */ 220 /* USB_ENDPOINT_ATTR_INTERRUPT：值0x03，中断传输（libopencm3/include/libopencm3/usb/usbstd.h） */ 221 /* cdcacm_data_rx_cb：USB虚拟串口数据接收函数，将数据赋值给接收数据缓冲区rx_buf（bl.c），定义在cdcacm.c */ 222 /* usbd_ep_setup：设置USB端点地址、类型、FIFO存储空间和回调函数 */ 223 /* 第一行：地址为0x01的USB端点类型为批量传输模式（USB_ENDPOINT_ATTR_BULK），缓冲区长度64字节，回调函数为cdcacm_data_rx_cb，用于接收USB数据 */ 224 /* 第二行：地址为0x82的USB端点类型为批量传输模式（USB_ENDPOINT_ATTR_BULK），缓冲区长度64字节，无回调函数，用于发送USB数据 */ 225 /* 第三行：地址为0x83的USB端点类型为中断传输模式（USB_ENDPOINT_ATTR_INTERRUPT），缓冲区长度16字节，无回调函数，用于USB传输控制 */ 226 usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb); 227 usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, NULL); 228 usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL); 229 230 /* USB_REQ_TYPE_CLASS：值0x20（libopencm3/include/libopencm3/usb/usbstd.h） */ 231 /* USB_REQ_TYPE_INTERFACE：值0x01（libopencm3/include/libopencm3/usb/usbstd.h） */ 232 /* USB_REQ_TYPE_TYPE：值0x60（libopencm3/include/libopencm3/usb/usbstd.h） */ 233 /* USB_REQ_TYPE_RECIPIENT：值0x1F（libopencm3/include/libopencm3/usb/usbstd.h） */ 234 /* cdcacm_control_request：USB虚拟串口请求控制函数，功能为处理各种USB请求信息，定义在cdcacm.c */ 235 /* usbd_register_control_callback：USB寄存器控制请求回调函数，定义在libopencm3/lib/usb/usb_control.c */ 236 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); 237} 238 239/* USB OTG FS中断处理函数 */ 240void otg_fs_isr(void) 241{ 242 if (usbd_dev) { 243 /* usbd_poll：USB设备的POLL操作；定义在libopencm3/lib/usb/usb.c */ 244 usbd_poll(usbd_dev); 245 } 246} 247 248/* USB虚拟串口通信初始化函数 */ 249void usb_cinit(void) 250{ 251#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */ 252 /* 1. 启动USB接口时钟，对应原理图中GPIOA9(VBUS/3.1A)，GPIOA11(OTG_FS_DM/3.1B)，GPIOA12(OTG_FS_DP/3.1A) */ 253 /* RCC_AHB1ENR：寄存器（地址0x40023830），定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 254 /* RCC_AHB2ENR：寄存器（地址0x40023834），定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 255 /* RCC_AHB1ENR_IOPAEN：值1<<0（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 256 /* RCC_AHB2ENR_OTGFSEN：值1<<7（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 257 /* rcc_peripheral_enable_clock：使能特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 258 /* 第一行代码使能GPIOA的时钟，操作寄存器RCC_AHB1ENR的域GPIOAEN(bit0) */ 259 /* 第二行代码使能USB OTG FS时钟，操作寄存器RCC_AHB2ENR的域OTGFSEN(bit7) */ 260 rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN); 261 rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN); 262 263#if defined(USB_FORCE_DISCONNECT) /* 宏USB_FORCE_DISCONNECT未定义，下列代码无效 */ 264 gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_OTYPE_OD, GPIO12); 265 gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO12); 266 gpio_clear(GPIOA, GPIO12); 267 systick_set_clocksource(STK_CSR_CLKSOURCE_AHB); 268 systick_set_reload(board_info.systick_mhz * 1000); /* 1ms tick, magic number */ 269 systick_interrupt_enable(); 270 systick_counter_enable(); 271 /* Spec is 2-2.5 uS */ 272 delay(1); 273 systick_interrupt_disable(); 274 systick_counter_disable(); // Stop the timer 275#endif 276 277 /* 2. 配置GPIOA11和GPIOA12分别USB数据通信功能 */ 278 /* GPIOA：地址为0x40020000的寄存器（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 279 /* GPIO_MODE_AF：值0x2（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 280 /* GPIO_PUPD_NONE：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 281 /* GPIO11：值1<<11（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 282 /* GPIO12：值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 283 /* GPIO_AF10：值0xa（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 284 /* gpio_mode_setup：设置引脚工作模式，定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */ 285 /* gpio_set_af：设置引脚具体的AF功能，定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */ 286 /* 第一行代码设置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） */ 287 /* 第二行代码设置GPIOA11和GPIOA12的具体AF功能为OTGFS/OTGHS（AFRH10=AFRH9=GPIO_AF10=0xa） */ 288 gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11 | GPIO12); 289 gpio_set_af(GPIOA, GPIO_AF10, GPIO11 | GPIO12); 290 291#if defined(BOARD_USB_VBUS_SENSE_DISABLED) /* 宏BOARD_USB_VBUS_SENSE_DISABLED未定义，下列代码无效 */ 292 OTG_FS_GCCFG |= OTG_GCCFG_NOVBUSSENS; 293#endif 294 295 /* 3. USB设备的初始化配置 */ 296 /* usbd_dev：_usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数（libopencm3/lib/usb/usb_private.h） */ 297 /* otgfs_usb_driver：_usbd_driver型结构体变量stm32f107_usb_driver，包含一系列USBFS驱动函数（libopencm3/lib/usb/usb_f107.c） */ 298 /* dev：USB设备描述符usb_device_descriptor，包含USB设备的基本信息（libopencm3/include/libopencm3/usb/usbstd.h），初始化在cdcacm.c */ 299 /* config：USB配置描述符usb_config_descriptor，包含USB设备的配置信息（libopencm3/include/libopencm3/usb/usbstd.h），初始化在cdcacm.c */ 300 /* usb_strings：USB设备字符串列表，定义并被初始化在cdcacm.c */ 301 /* NUM_USB_STRINGS：值3，usb_strings的数量，宏定义在cdcacm.c */ 302 /* usbd_control_buffer：控制操作请求缓冲区，128字节，定义在cdcacm.c */ 303 /* usbd_init：usb接口初始化函数，目的是填写结构体变量usbd_dev，定义在libopencm3/lib/usb/usb.c */ 304 usbd_dev = usbd_init(&otgfs_usb_driver, &dev, &config, usb_strings, NUM_USB_STRINGS, usbd_control_buffer, sizeof(usbd_control_buffer)); 305 306#elif defined(STM32F1) /* 宏STM32F1未定义（IO协处理器不执行usb_cinit），下列代码无效 */ 307 rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN); 308 gpio_set(GPIOA, GPIO8); 309 gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO8); 310 usbd_dev = usbd_init(&st_usbfs_v1_usb_driver, &dev, &config, usb_strings, NUM_USB_STRINGS, usbd_control_buffer, sizeof(usbd_control_buffer)); 311#endif 312 313 /* 4. USB传输回调函数设置 */ 314 /* usbd_dev：_usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数（libopencm3/lib/usb/usb_private.h） */ 315 /* cdcacm_set_config：USB虚拟串口配置函数，配置USB端点的操作函数和USB寄存器的请求操作函数，定义在cdcmca.c */ 316 /* usbd_register_set_config_callback：追加回调函数cdcacm_set_config到设备描述符usbd_dev中 */ 317 usbd_register_set_config_callback(usbd_dev, cdcacm_set_config); 318 319#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */ 320 321 /* 5. 若USB产品的ID号为0x00002000，启动USB连接功能 */ 322 /* OTG_FS_CID：寄存器，用于存储USB产品ID，软件可更改（libopencm3/include/libopencm3/stm32/otg_fs.h） */ 323 /* OTG_CID_HAS_VBDEN：值0x00002000，定义在cdcacm.c */ 324 /* OTG_FS_GCCFG：寄存器（libopencm3/include/libopencm3/stm32/otg_fs.h） */ 325 /* OTG_GCCFG_VBDEN：值1<<21，置该位认为VBUS一直有效，不再受外围电路影响（cdcacm.c） */ 326 /* OTG_GCCFG_PWRDWN：值1<<16，置该位开启收发功能（libopencm3/include/libopencm3/stm32/otg_common.h） */ 327 /* OTG_FS_DCTL：寄存器（libopencm3/include/libopencm3/stm32/otg_fs.h） */ 328 /* OTG_DCTL_SDIS：值1<<1，该位由软件控制USB核心开启软件连接功能（libopencm3/include/libopencm3/stm32/otg_common.h） */ 329 if (OTG_FS_CID == OTG_CID_HAS_VBDEN) { 330 OTG_FS_GCCFG |= OTG_GCCFG_VBDEN | OTG_GCCFG_PWRDWN; 331 /* 对于STM32F446/469，启动后需要进行软件连接 */ 332 OTG_FS_DCTL &= ~OTG_DCTL_SDIS; 333 } 334 335 /* 6. 使能USB OTG FS中断 */ 336 /* NVIC_OTG_FS_IRQ：值67，对应USB OTG FS的全局中断向量号，libopencm3/include/libopencm3/stm32/f4/nvic.h（编译时自动生成文件） */ 337 /* nvic_enable_irq：使能中断向量，定义在libopencm3/lib/cm3/nvic.c */ 338 nvic_enable_irq(NVIC_OTG_FS_IRQ); 339#endif 340}
USB串口读取数据后存放到缓冲区的函数，被cdcacm_data_rx_cb函数调用
bl.c
1static unsigned head, tail; /* 头、尾指针 */ 2static uint8_t rx_buf[256]; /* 缓冲区长度 */ 3 4void buf_put(uint8_t b) 5{ 6 unsigned next = (head + 1) % sizeof(rx_buf); 7 if (next != tail) { 8 rx_buf[head] = b; 9 head = next; 10 } 11}
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
1inline void cfini(void) 2{ 3#if INTERFACE_USB /* 主控FMU：宏INTERFACE_USB定义为1，代码有效，hw_config.h */ 4 /* IO协处理器：宏INTERFACE_USB定义为0，代码无效，hw_config.h */ 5 usb_cfini(); 6#endif 7#if INTERFACE_USART /* 宏INTERFACE_USART定义为1，hw_config.h */ 8 uart_cfini(); 9#endif 10}
10.2.2 uart_cfini函数
uart_cfini函数的草组很简单，直接调用库函数usart_disable关闭串口，USART2串口的配置并不改变。
usart.c
1uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */ 2 3void uart_cfini(void) 4{ 5 /* usart_disable：关闭串口，操作寄存器USART_CR1的域UE（bit13）（libopencm3/lib/stm32/common/usart_common_all.c） */ 6 usart_disable(usart); 7}
10.2.3 usb_cfini函数
USB虚拟串口反向初始化函数usb_cfini，并未改变USB的接口配置，主要操作如下：
- 关闭USB OTG FS中断
- 关闭USB软连接，并清空usbd_dev指针
- 配置USB数据引脚GPIOA11和GPIOA12的工作模式
- 关闭USB OTG FS时钟
1void usb_cfini(void) 2{ 3#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */ 4 /* 1. 关闭USB OTG FS中断 */ 5 /* NVIC_OTG_FS_IRQ：值67，对应USB OTG FS的全局中断向量号，libopencm3/include/libopencm3/stm32/f4/nvic.h（编译时自动生成文件） */ 6 /* nvic_disable_irq：使能中断向量，定义在libopencm3/lib/cm3/nvic.c */ 7 nvic_disable_irq(NVIC_OTG_FS_IRQ); 8#endif 9 10 /* 2.关闭USB软连接，并清空usbd_dev指针 */ 11 /* usbd_dev：usbd_device型全局变量指针，指向USB的配置信息和操作函数，被usbd_init库函数初始化，cdcacm.c */ 12 /* usbd_disconnect：断开USB软连接（不是所有的MCU都支持）。定义在libopencm3/lib/usb/usb.c */ 13 if (usbd_dev) { 14 usbd_disconnect(usbd_dev, true); 15 usbd_dev = NULL; 16 } 17 18#if defined(STM32F4) /* 宏STM32F4值为1，定义在Makefile.f4中，下列代码有效 */ 19 /* 3. 配置USB数据引脚GPIOA11和GPIOA12为输入 */ 20 /* GPIOA：地址为0x40020000的寄存器（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 21 /* GPIO_MODE_INPUT：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 22 /* GPIO_PUPD_NONE：值0x0（libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h） */ 23 /* GPIO11：值1<<11（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 24 /* GPIO12：值1<<12（libopencm3/include/libopencm3/stm32/common/gpio_common_all.h） */ 25 /* gpio_mode_setup：设置引脚工作模式，定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */ 26 /* 设置GPIOA11（OTG_FS_DM/3.1B）和GPIOA12（OTG_FS_DP/3.1A）为输入功能（MODER=GPIO_MODE_AF=00），浮空模式（PUPDR=GPIO_PUPD_NONE=0x0） */ 27 gpio_mode_setup(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO11 | GPIO12); 28 29 /* 4. 关闭USB OTG FS时钟 */ 30 /* RCC_AHB2ENR：寄存器（地址0x40023834），定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */ 31 /* RCC_AHB2ENR_OTGFSEN：值1<<7（libopencm3/include/libopencm3/stm32/f4/rcc.h） */ 32 /* rcc_peripheral_disable_clock：关闭特定的外部时钟，被定义在libopencm3/lib/stm32/common/rcc_common_all.c */ 33 /* 关闭USB OTG FS时钟，操作寄存器RCC_AHB2ENR的域OTGFSEN(bit7) */ 34 rcc_peripheral_disable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN); 35 36#elif defined(STM32F1) /* 宏STM32F1未定义（IO协处理器不执行usb_cfini），下列代码无效 */ 37 /* Reset the USB pins to being floating inputs */ 38 gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO8); 39 gpio_clear(GPIOA, GPIO8); 40#endif 41}
10.3 读取串口和USB虚拟串口内容函数
读取串口和USB虚拟串口内容函数包括uart_cin和usb_cin两个，分别对应USART读取和USB模拟串口读取函数，这两个函数均被cin函数调用。
10.3.1 uart_cin函数
uart_cin函数用于读取USART串口的1个字。
usart.c
1uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */ 2 3int uart_cin(void) 4{ 5 int c = -1; /* 默认返回值-1 */ 6 7 /* 若串口数据寄存器不为空，调用库函数读取接收到的数据 */ 8 /* USART_SR：USART状态寄存器，定义在libopencm3/include/libopencm3/stm32/common/usart_common_f124.h */ 9 /* USART_SR_RXNE：值1<<5，定义在libopencm3/include/libopencm3/stm32/common/usart_common_f124.h */ 10 /* usart：值USART2（USART2基地址），定义在usart.c */ 11 /* usart_recv：接收串口数据的库函数，定义在libopencm3/lib/stm32/common/usart_common_f124.c */ 12 if (USART_SR(usart) & USART_SR_RXNE) { 13 c = usart_recv(usart); 14 } 15 16 return c; 17}
10.3.2 usb_cin函数
usb_cin函数用于读取USB模拟串口的1个字，该函数仅对主控FMU有效。
cdcacm.c
1int usb_cin(void) 2{ 3 /* 若usbd_dev为空指针，则USB设备未被初始化，返回错误 */ 4 /* usbd_dev：_usbd_device型结构体全局指针变量，包含一系列USB信息与操作函数，定义在cdcacm.c */ 5 if (usbd_dev == NULL) { return -1; } 6#if defined(STM32F1) /* 主控FMU未定义，代码无效 */ 7 usbd_poll(usbd_dev); 8#endif 9 /* buf_get：从串口缓冲区内读取1个字的内容，定义在bl.c */ 10 return buf_get(); 11}
bl.c
1static unsigned head, tail; /* 头、尾指针 */ 2static uint8_t rx_buf[256]; /* 串口串口缓冲区 */ 3 4int buf_get(void) 5{ 6 int ret = -1; 7 if (tail != head) { 8 ret = rx_buf[tail]; 9 tail = (tail + 1) % sizeof(rx_buf); 10 } 11 return ret; 12}
10.4 串口和USB虚拟串口内容输出函数
串口和USB虚拟串口输出函数包括uart_cout和usb_cout两个，分别对应USART读取和USB模拟串口输出函数，这两个函数均被cout函数调用。
10.4.1 uart_cout函数
usart.c
1uint32_t usart; /* 全局变量，uart_cinit函数中被赋值为USART2 */ 2 3void uart_cout(uint8_t *buf, unsigned len) 4{ 5 /* usart_send_blocking：USART串口发送库函数，仅当串口数据缓存为空时再发送下一个数据，定义在libopencm3/lib/stm32/common/usart_common_all.c */ 6 while (len--) { 7 usart_send_blocking(usart, *buf++); 8 } 9}
10.4.2 usb_cout函数
cdcacm.c
1void usb_cout(uint8_t *buf, unsigned count) 2{ 3 if (usbd_dev) { /* 若USB设备有效 */ 4 /* 将需要写入的数据分成64字节1包，逐包写入到地址为0x82的端点中 */ 5 while (count) { 6 unsigned len = (count > 64) ? 64 : count; 7 unsigned sent; 8 /* usbd_ep_write_packet：向USB模拟串口写入数据的库函数，返回写入的字节数，定义在libopencm3/lib/usb/usb.c */ 9 sent = usbd_ep_write_packet(usbd_dev, 0x82, buf, len); 10 count -= sent; 11 buf += sent; 12 } 13 } 14}
11 结论
不知不觉，就写了这么多，我最怕写结尾了，因为不知道写什么好。写博客的时候发现，github上bootloader的原始代码也更新了。幸好只是改变了Makefile的结构，对软件结构影响不大，因此上述内容依然有参考价值。博客写完之后没有进行详细地推敲，希望各位看官多多批评指正，大家共同进步。
希望详细讨论的看官，可以发邮件至我的邮箱：
只要我知道的，有求必应。
开源万岁！！！