PX4 Bootloader解析

1 引言

半年前入手了Pixhawk V2全套硬件,编译好的开源固件也下了,四轴也飞了,一直想对这套开源飞控进行一个系统地解析,由于工作原因一直没时间。最近翻开了PX4飞控源代码,它基于NUTTX操作系统,在github上更新十分迅速。为了能够全面地掌握这套软硬件设计思想,同时对硬件系统有全面的认识,我决定对PX4 Bootloader进行详细解析。凡涉及到硬件相关的部分,本文以Pixhawk V2的主控STM32F427和IO协处理器STM32F100为基础进行解析,其他硬件可参照此方法进行类比,基本结构都是相似的。

感谢韦东山老师u-boot视频,我用同样的方法对PX4 Bootloader采用类似的方法进行了分析。针对我解析中存在的问题,希望同行和前辈们能够不吝赐教,谢谢。

2 PX4 Bootloader系统架构

从github上下载之后,打开Bootloader文件夹,可以看到libopencm3和Tools共2个文件夹和一共30个文件。

libopencm3和Tools这两个文件夹的主要功能如下:

  • Tools文件夹主要用于coding style和git submodule的检查,不需要太注意。
  • libopencm3是github上针对STM32系列芯片的开源库,Bootloader使用其中的库函数对相应型号的芯片进行操作,用到的地方将对库函数功能作简要说明,这里并不展开讨论。

其余30个文件主要功能如下:

  • 工程文件:包括Bootloader.sublime-project共1个文件,为sublime编辑器的工程文件。
  • Readme:包括Readme.md文件共1个,自己看,都能看懂。
  • License:包括LISENCE.md文件1个,权限文件,自己看。
  • Makefile文件:包括Makefile、Makefile.f1、Makefile.f2、Makefile.f3、Makefile.f4、Makefile.f7共5个文件,为系统的编译过程提供了依据。
  • Jtag配置文件:以.cfg结尾,包括jig_px4fmu.cfg、stm32f1x.cfg、stm32f3x.cfg、stm32f4x.cfg、stm32f102.cfg共5个文件,分别对应不同的Jtag烧写器、不同芯片使用openocd进行烧写时的配置。根据原理图可知,PX4 Bootloader可以使用Jtag接口进行程序烧写,某宝上买的Pixhawk V2拆开后在板上可以看到两个Jtag接口(分别对应主控STM32F427和协处理STM32F100),但是没有焊接出来,如需烧写bootloader程序可自行焊接。
  • 硬件配置头函数:包括hw_config.h共1个文件,规定了各类可运行PX4开源飞控程序的硬件配置,可与原理图对应查看。
  • 通用bootloader调用函数集:包括bl.h和bl.c共2个文件。提供了bootloader的main函数中需要调用的通用函数,这些函数与具体硬件无关,属顶层调用函数。
  • USB调试接口函数集:包括cdcacm.h和cdcacm.c共2个文件。提供了bootloader程序基于USB接口进行调试时所需的输入输出函数。
  • 串口调试接口集:包括usart.h和usart.c共2个文件。提供了bootloader程序基于串口进行调试时所需的输入输出函数。
  • main函数:包括main_f1.c、main_f3.c、main_f4.c、main_f7.c共4个文件。分别对应STM32F1、STM32F3、STM32F4和STM32F7芯片上运行的Bootloader的主函数。
  • 链接文件:以.ld结尾,包括stm32f1.ld、stm32f3.ld、stm32f4.ld、stm32f7.ld共4个文件。分别对应STM32F1、STM32F3、STM32F4和STM32F7芯片上Bootloader程序的链接方式。
  • PX固件生成脚本:包括px_mkfw.py共1个文件。根据文件说明,PX4固件为基于JSON编码的python对象,此脚本用于生成包含额外编码域的压缩文件固件,类似于u-boot中mkimage程序,生成的固件上传前需要用此脚本进行打包。PX4的固件本身已经具有这项功能,这个脚本应该不再需要了,应该很快会被丢弃。
  • PX固件上传脚本:包括px_uploader.py共1个文件。根据说明,此文件不再使用,已被固件中的上传脚本取代。

综上所述,这里需要重点分析的文件包括Makefile文件,链接文件,main函数文件,硬件配置头文件(hw_config.h),通用bootloader调用函数集文件(bl.h和bl.c),USB虚拟串口函数集文件(cdcacm.h和cdcacm.c),串口函数集文件(包括usart.h和usart.c)。

3 Makefile文件解析

PX4 Bootloader工程包含5个Makefile文件。其中Makefile是make命令的入口文件,将根据不同的编译对象,调用不同的Makefile.*文件。为了更清晰地了解Bootloader的编译过程,本节将对工程的Makefile进行详细注释。

3.1 主Makefile文件注释

Bootloader编译的make命令入口为根目录下的Makefile,这是所有编译命令开始的文件。


Makefile

#
# Paths to common dependencies
#
export BL_BASE		?= $(wildcard .)              #获取Bootloader本地工程所在目录,并赋给变量BL_BASE
export LIBOPENCM3	?= $(wildcard libopencm3)     #获取开源库libopencm3所在目录,并赋给变量LIBOPENCM3

#
# Tools
#
export CC	 	 = arm-none-eabi-gcc              #定义交叉编译工具链变量CC
export OBJCOPY		 = arm-none-eabi-objcopy      #定义二进制生成工具链变量OBJCOPY

#
# Common configuration
#
export FLAGS	 =  -std=gnu99 \                      #使用GNU99的优化C语言标准
				-Os \                             #专门针对生成目标文件大小进行
				-g \                              #生成调试信息
				-Wundef \                         #当没有定义的符号出现在#if中时警告
				-Wall \                           #打开一些有用的警告选项
				-fno-builtin \                    #不接受没有__buildin__前缀的函数作为内建函数
				-I$(LIBOPENCM3)/include \         #包含开源库libopencm3的头文件
				-ffunction-sections \             #要求编译器为每个function分配独立的section
				-nostartfiles \                   #链接时不使用标准的启动文件
				-lnosys \                         #链接libnosys.a文件
				-Wl,-gc-sections \                #传递-gc-sections给连接器,删除没有使用的section
				-Wl,-g \                          #传递-g选项给链接器,兼容其他工具
				-Werror                           #把警告当错误,出现警告就放弃编译

export COMMON_SRCS	 = bl.c cdcacm.c  usart.c    #定义通用源文件变量COMMON_SRCS

#
# Bootloaders to build
#
TARGETS	= \             #定义编译目标
	aerofcv1_bl \
	auavx2v1_bl \
	crazyflie_bl \
	mindpxv2_bl \
	px4aerocore_bl \
	px4discovery_bl \
	px4flow_bl \
	px4fmu_bl \
	px4fmuv2_bl \
	px4fmuv4_bl \
	px4fmuv4pro_bl \
	px4fmuv5_bl \
	px4io_bl \
	px4iov3_bl \
	tapv1_bl

all:	$(TARGETS)     #编译目标all=$(TARGETS)


clean:      #定义清理工程的操作(即make clean)
	cd libopencm3 && make --no-print-directory clean && cd ..  # 从Bootloader本地工程目录进入libopencm3文件夹,执行make clean清理命令,然后回到上一级目录。
	rm -f *.elf *.bin      #删除.efl和.bin文件

#
# Specific bootloader targets.
# 各编译目标的具体操作,主要规定了编译需要使用的Makefile文件,硬件目标TARGET_HW,链接脚本LINKER_FILE,编译目标TARGET_FILE_NAME
#

auavx2v1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=AUAV_X2V1  LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

px4fmu_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_FMU_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

px4fmuv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_FMU_V2  LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

px4fmuv4_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_FMU_V4  LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

px4fmuv4pro_bl:$(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_FMU_V4_PRO LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@ EXTRAFLAGS=-DSTM32F469

px4fmuv5_bl:$(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f7 TARGET_HW=PX4_FMU_V5 LINKER_FILE=stm32f7.ld TARGET_FILE_NAME=$@

mindpxv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=MINDPX_V2 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

px4discovery_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_DISCOVERY_V1  LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

px4flow_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_FLOW_V1  LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

px4aerocore_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_AEROCORE_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

crazyflie_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=CRAZYFLIE LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

# Default bootloader delay is *very* short, just long enough to catch
# the board for recovery but not so long as to make restarting after a
# brownout problematic.
#
px4io_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f1 TARGET_HW=PX4_PIO_V1 LINKER_FILE=stm32f1.ld TARGET_FILE_NAME=$@

px4iov3_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f3 TARGET_HW=PX4_PIO_V3 LINKER_FILE=stm32f3.ld TARGET_FILE_NAME=$@

tapv1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=TAP_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

aerofcv1_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=AEROFC_V1 LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

#
# Binary management
# 二进制文件压缩操作:deploy命令
#
.PHONY: deploy
deploy:
	zip Bootloader.zip *.bin

#
# Submodule management
# 子模块libopencm3操作与管理,进行的操作如下:
# 1. 更新git子工程libopencm3。
# 2. 调用Tools/check_submodules.sh检查当前libopencm3的版本信息是否正确。
# 3. 编译libopencm3工程,生成库文件,供bootloader使用。
#

$(LIBOPENCM3): checksubmodules
	make -C $(LIBOPENCM3) lib

.PHONY: checksubmodules
checksubmodules: updatesubmodules
	$(Q) ($(BL_BASE)/Tools/check_submodules.sh)

.PHONY: updatesubmodules
updatesubmodules:
	$(Q) (git submodule init)
	$(Q) (git submodule update)

3.2 主控Makefile.f4文件注释

由主Makefile中目标生成语句可以看出,Pixhawk V2硬件系统的主控stm32f427对应的bootloader调用了如下语句:


Makefile

px4fmuv2_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f4 TARGET_HW=PX4_FMU_V2  LINKER_FILE=stm32f4.ld TARGET_FILE_NAME=$@

因此,目标px4fmuv2_bl生成的Makefile脚本为Makefile.f4,同时,它还定义了如下变量

  • 硬件目标:$(TARGET_HW)=PX4_FMU_V2
  • 链接文件:$(LINKER_FILE)=stm32f4.ld
  • 目标名称:$(TARGET_FILE_NAME)=$@=px4fmuv2_bl

同时,在主Makefile中规定的全局变量BL_BASE、LIBOPENCM3、CC、OBJCOPY、FLAGS、COMMON_SRCS在Makefile.f4中同样有效。下面将对Makefile.f4进行详细注释。


Makefile.f4

OPENOCD		?= openocd     #定义OPENOCD命令

JTAGCONFIG ?= interface/olimex-jtag-tiny.cfg        #定义openocd对应的jtag烧写器配置文件
#JTAGCONFIG ?= interface/jtagkey-tiny.cfg

# 5 seconds / 5000 ms default delay
PX4_BOOTLOADER_DELAY	?= 5000            #定义启动变量PX4_BOOTLOADER_DELAY为5000ms

SRCS		 = $(COMMON_SRCS) main_f4.c   #定义编译源文件为bl.c cdcacm.c usart.c和main_f4.c

FLAGS		+= -mthumb\                   #使用thumb指令集
		-mcpu=cortex-m4\                  #使用cortex m4对应的CPU指令
		-mfloat-abi=hard\                 #浮点为硬件浮点运算
		-mfpu=fpv4-sp-d16 \               #浮点运算协处理器为fpv4-sp-d16
		-DTARGET_HW_$(TARGET_HW) \        #定义变量TARGET_HW_PX4_FMU_V2为1
		-DSTM32F4 \                       #定义变量STM32F4为1
		-T$(LINKER_FILE) \                #使用链接文件stm32f4.ld
		-L$(LIBOPENCM3)/lib \             #添加库文件搜索目录libopencm3/lib
		-lopencm3_stm32f4 \               #链接库文件libopencm3_stm32f4.a
        $(EXTRAFLAGS)

ELF		 = $(TARGET_FILE_NAME).elf          #定义目标变量ELF=px4fmuv2_bl.elf
BINARY		 = $(TARGET_FILE_NAME).bin      #定义目标二进制变量BINARY=px4fmuv2_bl.bin

all:		$(ELF) $(BINARY)                  #定义目标all,为px4fmuv2_bl.elf和px4fmuv2_bl.bin

#px4fmuv2_bl.elf的生成规则:
#px4fmuv2_bl.elf: bl.c cdcacm.c usart.c main_f4.c Makefile
#    arm-none-eabi-gcc -o px4fmuv2_bl.elf bl.c cdcacm.c usart.c main_f4.c $(FLAGS)
$(ELF):		$(SRCS) $(MAKEFILE_LIST)
	$(CC) -o $@ $(SRCS) $(FLAGS)

#px4fmuv2_bl.bin的生成规则:
#px4fmuv2_bl.bin: px4fmuv2_bl.elf
#   arm-none-eabi-objcopy -O binary px4fmuv2_bl.elf px4fmuv2_bl.bin
$(BINARY):	$(ELF)
	$(OBJCOPY) -O binary $(ELF) $(BINARY)

#upload: all flash flash-bootloader
#定义upload目标,依赖于all flash-bootloader
upload: all flash-bootloader

#定义flash-bootloader目标的命令规则
#执行openocd命令,查找与本工程目录平行的px4_bootloader目录中interface/olimex-jtag-tiny.cfg文件作为jtag烧写器的配置文件,以stm32f4x.cfg作为主控stm32f427的SOC配置文件。然后在openocd环境下依次执行init, reset halt, flash write_image erase px4fmuv2_bl.bin 0x08000000, reset run, shutdown命令进行烧写。
flash-bootloader:
	$(OPENOCD) --search ../px4_bootloader -f $(JTAGCONFIG) -f stm32f4x.cfg -c init -c "reset halt" -c "flash write_image erase $(BINARY) 0x08000000" -c "reset run" -c shutdown

# Use to upload to a stm32f4-discovery devboard, requires the latest version of openocd (from git)
# build openocd with "cd openocd; ./bootstrap; ./configure --enable-maintainer-mode --enable-stlink"
#定义upload-discovery目标的命令规则
#执行openocd命令,默认使用stlink烧写器及其配置文件,查找board/stm32f4discovery.cfg配置文件,在openocd环境下依次执行init, reset halt, flash probe 0, stm32f2x mass_erase 0, flash write_image erase px4fmuv2_bl.bin 0x08000000, reset, shutdown命令进行烧写。
upload-discovery: 
	$(OPENOCD) --search ../px4_bootloader -f board/stm32f4discovery.cfg -c init -c "reset halt" -c "flash probe 0" -c "stm32f2x mass_erase 0" -c "flash write_image erase $(BINARY) 0x08000000" -c "reset" -c shutdown

3.3 IO协处理器Makefile.f1文件注释

由主Makefile中目标生成语句可以看出,Pixhawk V2硬件系统的IO协处理器stm32f100对应的bootloader调用了如下语句:


Makefile

px4io_bl: $(MAKEFILE_LIST) $(LIBOPENCM3)
	make -f Makefile.f1 TARGET_HW=PX4_PIO_V1 LINKER_FILE=stm32f1.ld TARGET_FILE_NAME=$@

因此,目标px4io_bl生成的Makefile脚本为Makefile.f1,同时,它还定义了如下变量

  • 硬件目标:$(TARGET_HW)=PX4_PIO_V1
  • 链接文件:$(LINKER_FILE)=stm32f1.ld
  • 目标名称:$(TARGET_FILE_NAME)=$@=px4io_bl

同理,在主Makefile中规定的全局变量BL_BASE、LIBOPENCM3、CC、OBJCOPY、FLAGS、COMMON_SRCS在Makefile.f1中同样有效。下面将对Makefile.f1进行详细注释。


Makefile.f1

OPENOCD		?= ../../sat/bin/openocd           #定义openocd命令变量

JTAGCONFIG ?= interface/olimex-jtag-tiny.cfg    #定义Jtag烧写器配置文件
#JTAGCONFIG ?= interface/jtagkey-tiny.cfg

# 3 seconds / 3000 ms default delay
PX4_BOOTLOADER_DELAY	?= 3000                    #定义bootloader延时3000ms

SRCS		 = $(COMMON_SRCS) main_f1.c           #定义源文件为bl.c cdcacm.c usart.c和main_f1.c

FLAGS		+= -mthumb\                       #使用thumb指令集
		-mcpu=cortex-m3\                      #使用cortex m3指令集
		-DTARGET_HW_$(TARGET_HW) \            #定义TARGET_HW_PX4_PIO_V1变量为1
		-DSTM32F1 \                           #定义STM32F1变量为1
		-T$(LINKER_FILE) \                    #使用链接脚本stm32f1.ld
		-L$(LIBOPENCM3)/lib \                 #增加库文件搜索目录libopencm3/lib
		-lopencm3_stm32f1                     #链接库文件libopencm3_stm32f1.a

ELF		 = $(TARGET_FILE_NAME).elf              #定义ELF目标变量px4io_bl.elf
BINARY		 = $(TARGET_FILE_NAME).bin          #定义BINARY目标变量px4io_bl.bin

all:		$(ELF) $(BINARY)                    #定义目标all为px4io_bl.elf和px4io_bl.bin

#px4io_bl.elf生成规则
#px4io_bl.elf: bl.c cdcacm.c usart.c main_f1.c Makefile
#   arm-none-eabi-gcc -o px4io_bl.elf bl.c cdcacm.c usart.c main_f1.c $(FLAGS)
$(ELF):		$(SRCS) $(MAKEFILE_LIST)
	$(CC) -o $@ $(SRCS) $(FLAGS)

#px4io_bl.bin生成规则
#px4io_bl.bin: px4io_bl.elf
#   arm-none-eabi-objcopy -O binary px4io_bl.elf px4io_bl.bin
$(BINARY):	$(ELF)
	$(OBJCOPY) -O binary $(ELF) $(BINARY)

#upload: all flash flash-bootloader
#定义upload目标,依赖于all flash-bootloader
upload: all flash-bootloader

#flash-bootloader目标生成命令
#执行openocd命令,查找与本工程目录平行的px4_bootloader目录中interface/olimex-jtag-tiny.cfg文件作为jtag烧写器的配置文件,以stm32f1.cfg作为IO协处理器stm32f100的SOC配置文件。然后在openocd环境下依次执行init, reset halt, flash write_image erase px4io_bl.bin, reset run, shutdown命令进行烧写。
flash-bootloader:
	$(OPENOCD) --search ../px4_bootloader -f $(JTAGCONFIG) -f stm32f1.cfg -c init -c "reset halt" -c "flash write_image erase $(BINARY)" -c "reset run" -c shutdown

4 链接文件解析

PX4 Bootloader中包含4个链接文件stm32f1.ld、stm32f3.ld、stm32f4.ld和stm32f7.ld。与pixhawk V2硬件相关的为主控stm32f4.ld和IO协处理器stm32f1.ld两个链接脚本,它们将作为本文的分析重点。

PX4 Bootloader的链接文件可分为如下4个部分:

  • 声明可使用存储结构变量
  • 声明向量表名称
  • 定义段区
  • 定义栈顶地址变量值

4.1 主控链接脚本stm32f4.ld解析

链接脚本stm32f4.ld和libopencm3/lib/cm3/vector.c文件之间的关系十分密切。stm32f4.ld中定义了一系列在vector.c文件中使用的变量,包括_data_loadaddr,_data,_edata,_ebss,_stack,__preinit_array_start,__preinit_array_end,__init_array_start,__init_array_end,__fini_array_start,__fini_array_end,这些变量被用于Cortex M4的向量表初始化,主要是第一项的堆栈指针初始化和第二项的reset_handler函数的初始化。链接脚本stm32f4.ld中声明的向量表变量vector_table的定义在vector.c文件中。

与其它常见的链接脚本不同,stm32f4.ld中没有关键字ENTRY来规定程序的入口地址,在这种情况下程序就是从代码段(text)开始的。代码段最开始位置的是向量表,且ST公司的Cortex M4内核默认入口首地址(0x0)为堆栈指针(SP寄存器)的值;第二字为入口地址,因此reset_handler函数被调用为程序入口地址。


stm32f4.ld

/* Define memory regions. */
/* 声明存储区域,分为rom和ram两部分 */
MEMORY
{
	rom (rx)  : ORIGIN = 0x08000000, LENGTH = 16K  /* 定义rom区,即片内flash的部分区域,权限可读可执行,起始于flash起始地址0x08000000,使用前16K(即Section 0) */
	ram (rwx) : ORIGIN = 0x20000000, LENGTH = 128K /* 定义ram区,即片内SRAM的部分区域,权限可读可写可执行,起始于SRAM1起始地址0x20000000,包含SRAM1和SRAM2的全部区域(128K) */
}

/* Enforce emmission of the vector table. */
/* 声明外部定义的vector_table变量,此变量被定义在libopencm3/lib/cm3/vector.c中 */
EXTERN (vector_table)

/* Define sections. */
SECTIONS                    /* 定义段 */
{
	. = ORIGIN(rom);        /* 链接器指针定位于rom区起始地址 */

	.text : {               /* 定义代码段text */
			*(.vectors)     /* Vector table 中断向量表,定义于libopencm3/lib/cm3/vector.c文件中,仅包含vector_table变量 */
			*(.text*)       /* Program code 程序代码段 */
			. = ALIGN(4);   /* 4字节对齐 */
			*(.rodata*)     /* Read-only data 程序只读数据段 */
			. = ALIGN(4);   /* 4字节对齐 */
			_etext = .;     /* 定义变量_etext为当前地址 */
	} >rom                  /* 代码段text的程序地址位于rom中 */

	/* C++ Static constructors/destructors, also used for __attribute__
	 * ((constructor)) and the likes */
	.preinit_array : {                 /* 定义C++构造函数段preinit_array */
		. = ALIGN(4);                  /* 4字节对齐 */
		__preinit_array_start = .;     /* 定义变量__preinit_array_start为当前地址 */
		KEEP (*(.preinit_array))       /* 强制链接器保留preinit_array段 */
		__preinit_array_end = .;       /* 定义变量__preinit_array_end为当前地址 */
	} >rom                             /* C++构造函数段preinit_array的程序地址位于rom中 */
	.init_array : {                    /* 定义C++构造函数段init_array */
		. = ALIGN(4);                  /* 4字节对齐 */
		__init_array_start = .;        /* 定义变量__init_array_start为当前地址 */
		KEEP (*(SORT(.init_array.*)))  /* 强制链接器保留init_array.* 段,并对满足字符串模式的内容进行升序排列 */
		KEEP (*(.init_array))          /* 强制链接器保留init_array段 */
		__init_array_end = .;          /* 定义变量__init_array_end为当前地址 */
	} >rom                             /* C++构造函数段init_array的程序地址位于rom中 */
	.fini_array : {                    /* 定义C++析构函数段fini_array */
		. = ALIGN(4);                  /* 4字节对齐 */
		__fini_array_start = .;        /* 定义变量__fini_array_start为当前地址 */
		KEEP (*(.fini_array))          /* 强制链接器保留fini_array段 */
		KEEP (*(SORT(.fini_array.*)))  /* 强制链接器保留fini_array.*段,并对满足字符串模式的内容进行排序 */
		__fini_array_end = .;          /* 定义变量__fini_array_end为当前地址 */
	} >rom                             /* C++析构函数段fini_array的程序地址位于rom中 */

	. = ORIGIN(ram);                   /* 链接器指针定位于ram区起始地址 */

	.data : AT(_etext) {               /* 定义数据段data,加载地址位于变量_etext定义的位置 */
			_data = .;                 /* 定义变量_data为当前地址 */
			*(.data*)                  /* Read-write initialized data,程序数据段 */
			. = ALIGN(4);              /* 4字节对齐 */
			_edata = .;                /* 定义变量_edata为当前地址 */
	} >ram                             /* 数据段data的程序地址位于ram中 */
	_data_loadaddr = LOADADDR(.data);  /* 定义变量_data_loadaddr为数据段加载地址的起始位置 */

	.bss : {                           /* 定义bss段 */
		*(.bss*)                       /* Read-write zero initialized data,程序bss段 */
		*(COMMON)                      /* COMMON段 */
		. = ALIGN(4);                  /* 4字节对齐 */
		_ebss = .;                     /* 定义变量_ebss为当前地址 */
	} >ram AT >rom                     /* bss段的程序地址位于ram中,加载地址位于rom中 */

	/*
	* The .eh_frame section appears to be used for C++ exception handling.
	* You may need to fix this if you're using C++.
	*/
	/DISCARD/ : { *(.eh_frame) }    /* 被丢弃段eh_frame不会出现在输出文件中 */

	. = ALIGN(4);                   /* 4字节对齐 */
	end = .;                        /* 定义变量end为当前地址 */
}

PROVIDE(_stack = 0x20020000);       /* 定义变量_stack,仅在被使用时生效,堆栈指针指向ram区最高地址 */

4.2 IO协处理器链接脚本stm32f1.ld解析

链接脚本stm32f1.ld与stm32f4.ld情况十分相近,不再复述,这里仅对其进行注释。


stm32f1.ld

/* Define memory regions. */
/* 声明存储区域,分为rom和ram两部分 */
MEMORY
{
	rom (rx)  : ORIGIN = 0x08000000, LENGTH = 4K  /* 定义rom区,即片内flash的部分区域,权限可读可执行,起始于flash起始地址0x08000000,使用前4K(即Page 0~3) */
	ram (rwx) : ORIGIN = 0x20000000, LENGTH = 8K  /* 定义ram区,即片内SRAM的部分区域,权限可读可写可执行,起始于SRAM1起始地址0x20000000,使用全部8K(注意F100系列片内RAM最高为8K) */
}

/* Enforce emmission of the vector table. */
/* 声明外部定义的vector_table变量,此变量被定义在libopencm3/lib/cm3/vector.c中 */
EXTERN (vector_table)

/* Define sections. */
SECTIONS                       /* 定义段 */
{
	. = ORIGIN(rom);           /* 链接器指针定位于rom区起始地址 */

	.text : {                  /* 定义代码段text */
			*(.vectors)        /* Vector table 中断向量表,定义于libopencm3/lib/cm3/vector.c文件中,仅包含vector_table变量 */
			*(.text*)          /* Program code 程序代码段 */
			. = ALIGN(4);      /* 4字节对齐 */
			*(.rodata*)        /* Read-only data 程序只读数据段 */
			. = ALIGN(4);      /* 4字节对齐 */
			_etext = .;        /* 定义变量_etext为当前地址 */
	} >rom                     /* 代码段text的程序地址位于rom中 */

	/* C++ Static constructors/destructors, also used for __attribute__
	 * ((constructor)) and the likes */
	.preinit_array : {                 /* 定义C++构造函数段preinit_array */
		. = ALIGN(4);                  /* 4字节对齐 */
		__preinit_array_start = .;     /* 定义变量__preinit_array_start为当前地址 */
		KEEP (*(.preinit_array))       /* 强制链接器保留preinit_array段 */
		__preinit_array_end = .;       /* 定义变量__preinit_array_end为当前地址 */
	} >rom                             /* C++构造函数段preinit_array的程序地址位于rom中 */
	.init_array : {                    /* 定义C++构造函数段init_array */
		. = ALIGN(4);                  /* 4字节对齐 */
		__init_array_start = .;        /* 定义变量__init_array_start为当前地址 */
		KEEP (*(SORT(.init_array.*)))  /* 强制链接器保留init_array.* 段,并对满足字符串模式的内容进行升序排列 */
		KEEP (*(.init_array))          /* 强制链接器保留init_array段 */
		__init_array_end = .;          /* 定义变量__init_array_end为当前地址 */
	} >rom                             /* C++构造函数段init_array的程序地址位于rom中 */
	.fini_array : {                    /* 定义C++析构函数段fini_array */
		. = ALIGN(4);                  /* 4字节对齐 */
		__fini_array_start = .;        /* 定义变量__fini_array_start为当前地址 */
		KEEP (*(.fini_array))          /* 强制链接器保留fini_array段 */
		KEEP (*(SORT(.fini_array.*)))  /* 强制链接器保留fini_array.* 段,并对满足字符串模式的内容进行升序排列 */
		__fini_array_end = .;          /* 定义变量__fini_array_end为当前地址 */
	} >rom                             /* C++析构函数段fini_array的程序地址位于rom中 */

	. = ORIGIN(ram);                   /* 链接器指针定位于ram区起始地址 */

	.data : AT(_etext) {               /* 定义数据段data,加载地址位于变量_etext定义的位置 */
			_data = .;                 /* 定义变量_data为当前地址 */
			*(.data*)                  /* Read-write initialized data 程序数据段 */
			. = ALIGN(4);              /* 4字节对齐 */
			_edata = .;                /* 定义变量_edata为当前地址 */
	} >ram                             /* 数据段data的程序地址位于ram中 */
	_data_loadaddr = LOADADDR(.data);  /* 定义变量_data_loadaddr为数据段加载地址的起始位置 */

	.bss : {                           /* 定义bss段 */
		*(.bss*)                       /* Read-write zero initialized data 程序bss段 */
		*(COMMON)                      /* COMMON段 */
		. = ALIGN(4);                  /* 4字节对齐 */
		_ebss = .;                     /* 定义变量_ebss为当前地址 */
	} >ram AT >rom                     /* bss段的程序地址位于ram中,加载地址位于rom中 */

	/*
	* The .eh_frame section appears to be used for C++ exception handling.
	* You may need to fix this if you're using C++.
	*/
	/DISCARD/ : { *(.eh_frame) }       /* 被丢弃段eh_frame不会出现在输出文件中 */

	. = ALIGN(4);                      /* 4字节对齐 */
	end = .;                           /* 定义变量end为当前地址 */
}

PROVIDE(_stack = 0x20002000);          /* 定义变量_stack,仅在被使用时生效,堆栈指针指向ram区最高地址 */

5 硬件配置头文件

PX4 Bootloader的硬件配置头文件仅有一个,hw_config.h。这套代码支持的所有硬件板配置均可在这里找到。它的结构很简单,针对不同的硬件配置使用#if-#elif-#end宏条件编译语句进行配置。针对Pixhawk V2这套硬件,仅涉及其中TARGET_HW_PX4_FMU_V2和TARGET_HW_PX4_PIO_V1两个条件编译块中的内容。由于本节将涉及具体的硬件信息,将结合芯片手册和原理图对这两部分内容进行详细解析。

5.1 主控宏TARGET_HW_PX4_FMU_V2对应的配置

在Makefile.f4的FLAGS变量中定义了TARGET_HW_PX4_FMU_V2和STM32F4两个变量,这两个变量主要用于宏条件编译分支的判断上,对硬件板载配置的时候起到了决定性的作用。


Makefile.f4

FLAGS		+= -mthumb\                   #使用thumb指令集
		-mcpu=cortex-m4\                  #使用cortex m4对应的CPU指令
		-mfloat-abi=hard\                 #浮点为硬件浮点运算
		-mfpu=fpv4-sp-d16 \               #浮点运算协处理器为fpv4-sp-d16
		-DTARGET_HW_$(TARGET_HW) \        #定义变量TARGET_HW_PX4_FMU_V2为1
		-DSTM32F4 \                       #定义变量STM32F4为1
		-T$(LINKER_FILE) \                #使用链接文件stm32f4.ld
		-L$(LIBOPENCM3)/lib \             #添加库文件搜索目录libopencm3/lib
		-lopencm3_stm32f4 \               #链接库文件libopencm3_stm32f4.a
        $(EXTRAFLAGS)

hw_config.h文件中对应主控宏TARGET_HW_PX4_FMU_V2的代码如下:


hw_config.h

#elif  defined(TARGET_HW_PX4_FMU_V2)                        /* 若TARGET_HW_PX4_FMU_V2为真,下面的宏定义有效 */
# define APP_LOAD_ADDRESS               0x08004000          /* APP_LOAD_ADDRESS,为Bootloader初始化完成后的飞控固件跳转地址(实际入口地址在0x08004004,这一点在bl.c文件的源代码中可以看到,0x08004000被用于标识后面的代码是否有效) */
# define BOOTLOADER_DELAY               5000                /* BOOTLOADER_DELAY,为Bootloader初始化完毕到跳转到飞控固件需等待的时间 */
# define BOARD_FMUV2                                        /* BOARD_FMUV2,在全部代码中没有用到 */
# define INTERFACE_USB                  1                   /* INTERFACE_USB,表示Bootloader可采用USB口与上位机通信 */
# define INTERFACE_USART                1                   /* INTERFACE_USART,表示Bootloader可采用串口与上位机通信 */
# define USBDEVICESTRING                "PX4 BL FMU v2.x"   /* USBDEVICESTRING,表示对应USB ID的字符串 */
# define USBPRODUCTID                   0x0011              /* USBPRODUCTID,USB接口的PID */
# define BOOT_DELAY_ADDRESS             0x000001a0          /* BOOT_DELAY_ADDRESS,flash上对应存放Bootloader等待时间的内存地址 */

# define BOARD_TYPE                     9                   /* BOARD_TYPE,对应不同硬件配置板子上处理器的编号,每个不同的处理器对应不同的值 */
# define _FLASH_KBYTES                  (*(uint16_t *)0x1fff7a22)   /* _FLASH_KBYTES,程序运行期间flash以KB计的大小的存储地址(为何位于Reserved地址?) */
# define BOARD_FLASH_SECTORS            ((_FLASH_KBYTES == 0x400) ? 11 : 23)    /* BOARD_FLASH_SECTORS,STM32F4芯片若片内flash为1M,则Sector数量为11;若不为1M(2M),则Sector数量为23,详见芯片手册 */
# define BOARD_FLASH_SIZE               (_FLASH_KBYTES * 1024)      /* BOARD_FLASH_SIZE,flash总大小 */

# define OSC_FREQ                       24                  /* OSC_FREQ,外部晶振频率24kHz */

/* 主控FMU指示灯在板上一共有2个,FMU的PWR和B/E;PWR(LED704)为绿色常亮,上电即亮,B/E(LED701)由FMU的GPIOE12控制,为闪烁红色 */
# define BOARD_PIN_LED_ACTIVITY         0                   // no activity LED,无命令处理显示LED灯
# define BOARD_PIN_LED_BOOTLOADER       GPIO12              /* BOARD_PIN_LED_BOOTLOADER,主控Bootloader的LED指示灯为GPIOE12 */
# define BOARD_PORT_LEDS                GPIOE               /* BOARD_PORT_LEDS,主控FMU的LED指示灯控制引脚在GPIO Port E */
# define BOARD_CLOCK_LEDS               RCC_AHB1ENR_IOPEEN  /* BOARD_CLOCK_LEDS,RCC_AHB1ENR_IOPEEN被libopencm3/include/libopencm3/stm32/f4/rcc.h定义为(1<<4),对应RCC_AHB1ENR寄存器的第4位,GPIOE的时钟使能位 */
# define BOARD_LED_ON                   gpio_clear          /* BOARD_LED_ON,gpio_clear函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中,实际为GPIO pin清零功能 */
# define BOARD_LED_OFF                  gpio_set            /* BOARD_LED_OFF,gpio_set函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中,实际为GPIO pin置1功能 */

# define BOARD_USART  					USART2             /* BOARD_USART,通信串口,USART2被libopencm3/include/libopencm3/stm32/common/usart_common_all.h定义为USART2_BASE(0x40004400) */
# define BOARD_USART_CLOCK_REGISTER 	RCC_APB1ENR            /* BOARD_USART_CLOCK_REGISTER,被定义为RCC_APB1ENR寄存器,用于使能USART2的时钟 */
# define BOARD_USART_CLOCK_BIT      	RCC_APB1ENR_USART2EN   /* BOARD_USART_CLOCK_BIT,RCC_APB1ENR_USART2EN被libopencm3/include/libopencm3/stm32/f4/rcc.h定义为(1<<17),对应RCC_APB1ENR的17位,用于使能USART2的时钟 */

# define BOARD_PORT_USART   			GPIOD                  /* BOARD_PORT_USART,USART2的引脚位于GPIO Port D */
# define BOARD_PORT_USART_AF 			GPIO_AF7           /* BOARD_PORT_USART_AF,GPIO_AF7被libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h定义为0x7,对应AF7的alternative function功能为USART1~3 */
# define BOARD_PIN_TX     				GPIO5              /* BOARD_PIN_TX,USART2的发送引脚为GPIOD5 */
# define BOARD_PIN_RX		     		GPIO6              /* BOARD_PIN_RX,USART2的接收引脚为GPIOD6 */
# define BOARD_USART_PIN_CLOCK_REGISTER RCC_AHB1ENR         /* BOARD_USART_PIN_CLOCK_REGISTER,被定义为RCC_AHB1ENR寄存器,用于使能USART2引脚的时钟 */
# define BOARD_USART_PIN_CLOCK_BIT  	RCC_AHB1ENR_IOPDEN     /* BOARD_USART_PIN_CLOCK_BIT,RCC_AHB1ENR_IOPDEN被libopencm3/include/libopencm3/stm32/f4/rcc.h定义为(1<<3),对应RCC_AHB1ENR寄存器的第3位,用于使能GPIOD的时钟 */

5.2 IO协处理器宏TARGET_HW_PX4_PIO_V1对应的配置

在Makefile.f1的FLAGS变量中定义了TARGET_HW_PX4_PIO_V1和STM32F1两个变量,这两个变量主要用于宏条件编译分支的判断上,对硬件板载配置的时候起到了决定性的作用。


Makefile.f1

FLAGS		+= -mthumb\                       #使用thumb指令集
		-mcpu=cortex-m3\                      #使用cortex m3指令集
		-DTARGET_HW_$(TARGET_HW) \            #定义TARGET_HW_PX4_PIO_V1变量为1
		-DSTM32F1 \                           #定义STM32F1变量为1
		-T$(LINKER_FILE) \                    #使用链接脚本stm32f1.ld
		-L$(LIBOPENCM3)/lib \                 #增加库文件搜索目录libopencm3/lib
		-lopencm3_stm32f1                     #链接库文件libopencm3_stm32f1.a

hw_config.h文件中对应主控宏TARGET_HW_PX4_PIO_V1的代码如下:


hw_config.h

#elif  defined(TARGET_HW_PX4_PIO_V1) ||  defined(TARGET_HW_PX4_PIO_V2)      /* 若TARGET_HW_PX4_FMU_V2为真,下面的宏定义有效 */

# define APP_LOAD_ADDRESS               0x08001000      /* APP_LOAD_ADDRESS,为bootloader初始化完成后的飞控固件跳转地址(实际入口地址在0x08001004,这一点在bl.c文件的源代码中可以看到,0x08001000被用于标识后面的代码是否有效) */
# define APP_SIZE_MAX                   0xf000          /* APP_SIZE_MAX,板载系统程序(Bootloader)大小上限 */
# define BOOTLOADER_DELAY               200             /* BOOTLOADER_DELAY,为Bootloader初始化完毕到跳转到飞控固件需等待的时间 */
# define BOARD_PIO                                      /* 未见引用 */
# define INTERFACE_USB                	0              /* INTERFACE_USB,表示Bootloader不能用USB与上位机通信 */
# define INTERFACE_USART                1               /* INTERFACE_USART,表示Bootloader可以用串口与上位机通信 */
# define USBDEVICESTRING                ""              /* USBDEVICESTRING,因INTERFACE_USB为0,不使用USB与上位机通信,故USB ID的字符串设置为空 */
# define USBPRODUCTID                   -1              /* USBPRODUCTID,因INTERFACE_USB为0,不使用USB与上位机通信,故USB设备ID设为非法值 */

# define OSC_FREQ                       24              /* OSC_FREQ,外部晶振频率24kHz */

/* IO协处理器指示灯在板上一共有3个,IO的PWR、B/E和ACT;PWR(LED702)为绿色常亮,上电即亮,B/E(LED703)由IO协处理器的GPIOB15控制,为闪烁红色,ACT(LED705)由IO协处理器的GPIOB14控制,为闪烁蓝色 */
# define BOARD_PIN_LED_ACTIVITY         GPIO14          /* BOARD_PIN_LED_ACTIVITY,Bootloader有命令要处理时亮起,由IO协处理器的GPIOB14控制 */
# define BOARD_PIN_LED_BOOTLOADER       GPIO15          /* BOARD_PIN_LED_BOOTLOADER,IO协处理器Bootloader的LED指示灯为GPIOB15 */
# define BOARD_PORT_LEDS                GPIOB           /* BOARD_PORT_LEDS,IO协处理器的LED指示灯控制引脚在GPIO Port B */
# define BOARD_CLOCK_LEDS_REGISTER      RCC_APB2ENR     /* BOARD_CLOCK_LEDS_REGISTER,被定义为RCC_APB2ENR寄存器,用于使能LED时钟 */
# define BOARD_CLOCK_LEDS               RCC_APB2ENR_IOPBEN  /* BOARD_CLOCK_LEDS,RCC_APB2ENR_IOPBEN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为(1<<3),对应RCC_APB2ENR寄存器的第3,GPIOB的时钟使能位 */
# define BOARD_LED_ON                   gpio_clear      /* BOARD_LED_ON,gpio_clear函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中,实际为GPIO pin清零功能 */
# define BOARD_LED_OFF                  gpio_set        /* BOARD_LED_OFF,gpio_set函数定义在libopencm3/lib/stm32/common/gpio_common_all.c中,实际为GPIO pin置1功能 */

/* IO协处理器的通信串口为USART2,与主控FMU的USART6通信 */
# define BOARD_USART                    USART2          /* BOARD_USART,通信串口,USART2被libopencm3/include/libopencm3/stm32/common/usart_common_all.h定义为USART2_BASE(0x40004400) */
# define BOARD_USART_CLOCK_REGISTER     RCC_APB1ENR     /* BOARD_USART_CLOCK_REGISTER,被定义为RCC_APB1ENR寄存器,用于使能USART2的时钟 */
# define BOARD_USART_CLOCK_BIT          RCC_APB1ENR_USART2EN    /* BOARD_USART_CLOCK_BIT,RCC_APB1ENR_USART2EN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为(1<<17),对应RCC_APB1ENR的17位,用于使能USART2的时钟 */

# define BOARD_PORT_USART               GPIOA           /* BOARD_PORT_USART,USART2的引脚位于GPIO Port A */
# define BOARD_PIN_TX                   GPIO_USART2_TX  /* BOARD_PIN_TX,GPIO_USART2_TX被libopencm3/include/libopencm3/stm32/f1/gpio.h中定义为GPIO2,PA2 */
# define BOARD_PIN_RX                   GPIO_USART2_RX  /* BOARD_PIN_RX,GPIO_USART2_RX被libopencm3/include/libopencm3/stm32/f1/gpio.h中定义为GPIO3,PA3 */
# define BOARD_USART_PIN_CLOCK_REGISTER RCC_APB2ENR     /* BOARD_USART_PIN_CLOCK_REGISTER,被定义为寄存器RCC_APB2ENR,用于使能USART2引脚的时钟 */
# define BOARD_USART_PIN_CLOCK_BIT      RCC_APB2ENR_IOPAEN  /* BOARD_USART_PIN_CLOCK_BIT,RCC_APB2ENR_IOPAEN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为(1<<2),对应RCC_APB2ENR的第2位,用于使能GPIOA的时钟 */

/* IO协处理器的GPIOB5接J702安全开关 */
# define BOARD_FORCE_BL_PIN             GPIO5           /* BOARD_FORCE_BL_PIN,板载强制Bootloader引脚为GPIOB5 */
# define BOARD_FORCE_BL_PORT            GPIOB           /* BOARD_FORCE_BL_PIN,板载强制Bootloader引脚在GPIOB中 */
# define BOARD_FORCE_BL_CLOCK_REGISTER  RCC_APB2ENR     /* BOARD_FORCE_BL_CLOCK_REGISTER,被定义为RCC_APB2ENR,用于使能GPIOB5的时钟 */
# define BOARD_FORCE_BL_CLOCK_BIT       RCC_APB2ENR_IOPBEN  /* BOARD_FORCE_BL_CLOCK_BIT,RCC_APB2ENR_IOPBEN被libopencm3/include/libopencm3/stm32/f1/rcc.h定义为(1<<3),对应RCC_APB2ENR寄存器的第3,GPIOB的时钟使能位 */
# define BOARD_FORCE_BL_PULL            GPIO_CNF_INPUT_FLOAT // depend on external pull BOARD_FORCE_BL_PULL,GPIO_CNF_INPUT_FLOAT被libopencm3/include/libopencm3/stm32/f1/gpio.h定义为0x01,根据芯片手册表示GPIOB5为浮动输入状态,其值取决于外部硬件输入,即安全开关的状态
# define BOARD_FORCE_BL_VALUE           BOARD_FORCE_BL_PIN  /* BOARD_FORCE_BL_VALUE,BOARD_FORCE_BL_PIN为GPIO5的值,用于判定IO协处理器是否永远进入Bootloader的循环状态 */

# define BOARD_FLASH_SECTORS            60              /* BOARD_FLASH_SECTORS,STM32F1片内flash页数,Bootloader认为片内flash的前60页有效 */
# define BOARD_TYPE                     10              /* BOARD_TYPE,对应不同硬件配置板子上处理器的编号,每个不同的处理器对应不同的值 */
# define FLASH_SECTOR_SIZE              0x400           /* FLASH_SECTOR_SIZE,STM32F1片内flash每页大小为1KB */

6 核心数据结构

与u-boot类似,PX4 Bootloader运行时需要一些核心数据结构的支持。这些数据结构一般是全局变量,它们的值能够充分反映整个程序运行的状态。Pixhawk V2板上有两个处理器分别跑着各自的Bootloader,因此各自维持这自己的核心数据结构。无论主控FMU还是IO协处理器的Bootloader程序都是从向量表开始的,而且PX4 Bootloader对所有处理器的向量表处理方式完全相同,因此本节将向量表数据结构单独拿出来分析。

6.1 向量表vector_table_t

STM32的Cortex M核心启动时均需要中断向量表支持,因此这个数据结构对程序的启动至关重要。这个数据结构在库文件libopencm3/include/libopencm3/cm3/vector.h中定义,宏NVIC_IRQ_COUNT在libopencm3/include/libopencm3/dispatch/nvic.h中被定义为0,故一般中断向量irq数量为0,可理解为不启用一般中断。


vector.h

typedef void (*vector_table_entry_t)(void);            /* 定义向量表函数指针类型 */

typedef struct {
	unsigned int *initial_sp_value;                    /* 初始堆栈指针地址 */
	vector_table_entry_t reset;                        /* 重启reset向量函数指针 */
	vector_table_entry_t nmi;                          /* 不可屏蔽中断NMI向量函数指针 */
	vector_table_entry_t hard_fault;                   /* 硬件错误hard_fault向量函数指针 */
	vector_table_entry_t memory_manage_fault;          /* 内存管理错误memory_manage_fault向量函数指针,Cortex M0核心不含此项 */
	vector_table_entry_t bus_fault;                    /* 总线错误bus_fault向量函数指针,Cortex M0核心不含此项 */
	vector_table_entry_t usage_fault;                  /* 指令使用错误usage_fault向量函数指针,Cortex M0核心不含此项 */
	vector_table_entry_t reserved_x001c[4];            /* 预留 */
	vector_table_entry_t sv_call;                      /* 管理模式sv_call向量函数指针 */
	vector_table_entry_t debug_monitor;                /* 调试监控debug_monitor向量函数指针,Cortex M0核心不含此项(手册显示M4和M3也没有) */
	vector_table_entry_t reserved_x0034;               /* 预留 */
	vector_table_entry_t pend_sv;                      /* pend_sv向量函数指针 */
	vector_table_entry_t systick;                      /* 系统时钟systick向量函数指针 */
	vector_table_entry_t irq[NVIC_IRQ_COUNT];          /* 一般中断irq向量函数指针数组,宏NVIC_IRQ_COUNT被定义为0 */
} vector_table_t;

vector_table_t数据结构在文件libopencm3/lib/cm3/vector.c中实体化为变量vector_table并被初始化,单独构成vectors段,被链接脚本规定放在代码段最开始位置。初始化的重点时栈指针initial_sp_value和重启reset向量函数reset_handler,其余或者被初始化为什么都不做的null_handler,或者被初始化为死循环函数blocking_handler。null_handler和blocking_handler的定义均在vector.c文件中。宏IRQ_HANDLERS在文件libopencm3/lib/dispatch/vector_nvic.c中被定义为空,说明Bootloader不含中断处理函数。

vector.c中,向量函数的初始化函数均被定义为弱属性(weak),表示若外部没有同名函数定义,则用此弱属性函数;若有其他定义,则采用其他定义的函数。从这一点也可看到,对Bootloader的向量函数进行重写时十分方便,不需要修改软件框架。由于reset_handeler作为入口函数,因此还增加了裸属性(naked)。


vector.c

__attribute__ ((section(".vectors")))          /* 变量vector_table属于vectors段 *
vector_table_t vector_table = {
	.initial_sp_value = &_stack,               /* 栈指针指向的地址,_stack在链接脚本中被定义为ram区最高地址 */
	.reset = reset_handler,                    /* 重启reset向量函数,reset_handler被定义在vector.c中 */
	.nmi = nmi_handler,                        /* 不可屏蔽中断nmi向量函数,nmi_handeler在vector.c中被定义为什么都不做的函数null_handler */
	.hard_fault = hard_fault_handler,          /* 硬件错误hard_fault向量函数,hard_fault_handler在vector.c中被定义为死循环函数blocking_handler */

/* Those are defined only on CM3 or CM4 */
#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)   /* 若为CM3和CM4 */
	.memory_manage_fault = mem_manage_handler, /* 内存管理错误memory_manage_fault向量函数,mem_manage_handler在vector.c中被定义为死循环函数blocking_handler */
	.bus_fault = bus_fault_handler,            /* 总线错误bus_fault向量函数,bus_fault_handler在vector.c中被定义为死循环函数blocking_handler */
	.usage_fault = usage_fault_handler,        /* 指令使用错误usage_fault向量函数,usage_fault_handler在vector.c中被定义为死循环函数blocking_handler */
	.debug_monitor = debug_monitor_handler,    /* 调试监控debug_monitor向量函数,debug_monitor_handler在vector.c中被定义为什么都不做的函数null_handler */
#endif

	.sv_call = sv_call_handler,                /* 调试监控debug_monitor向量函数,sv_call_handler在vector.c中被定义为什么都不做的函数null_handler */
	.pend_sv = pend_sv_handler,                /* pend_sv向量函数,pend_sv_handler在vector.c中被定义为什么都不做的函数null_handler */
	.systick = sys_tick_handler,               /* 系统时钟systick向量函数,sys_tick_handler在vector.c中被定义为什么都不做的函数null_handler */
                                               /* 由于sys_tick_handler被vector.c定义为弱属性(weak),该函数在bl.c中被重新定义,实际定义在bl.c中。 */
	.irq = {
		IRQ_HANDLERS                           /* IRQ_HANDLERS,在vector_nvic.c中被定义为空 */
	}
};

6.2 主控FMU核心数据结构

除向量表vector外,主控FMU的核心数据结构包括boardinfo,flash_sector,mcu_des_t和mcu_rev_t,它们均为全局变量,表示板载FMU的基本配置情况。

6.2.1 结构体boardinfo

结构体boardinfo被定义在bl.h文件中,在main_f4.c中被初始化,用于描述运行此Bootloader的板载系统的最基本配置。


bl.h

struct boardinfo {
	uint32_t board_type;      /* 板载处理器编号 */
	uint32_t	 board_rev;       /* 修订版本,程序中几乎没有用到 */
	uint32_t	 fw_size;         /* 飞控固件大小的最大值 */
    	uint32_t	 systick_mhz;     /* 系统时钟的输入值,即CPU主频 */
} __attribute__((packed));    /* 编译时使用紧凑数据模式,不进行优化对齐,即使用1字节对齐模式 */


main_f4.c

struct boardinfo board_info = {
	.board_type	= BOARD_TYPE,       /* board_type,BOARD_TYPE板载处理器编号在hw_config.h中定义,主控为9。 */
	.board_rev	= 0,                /* board_rev,修订版本为0 */
	.fw_size	= 0,                    /* fw_size,飞控固件大小的最大值,这里的0没有意义,在board_init函数中被重新初始化 */
	.systick_mhz	= 168,              /* systick_mhz,系统时钟输入,即CPU主频168MHz */
};

6.2.2 结构体flash_sector

结构体flash_sector用于描述STM32F4芯片内部flash的结构,它被定义并初始化在main_f4.c中。根据芯片手册,STM32F4片内flash大小为1M或2M两种,具体参见芯片手册。


main_f4.c

static struct {
	uint32_t	 sector_number;
	uint32_t size;
} flash_sectors[] = {
	{0x01, 16 * 1024},
	{0x02, 16 * 1024},
	{0x03, 16 * 1024},
	{0x04, 64 * 1024},
	{0x05, 128 * 1024},
	{0x06, 128 * 1024},
	{0x07, 128 * 1024},
	{0x08, 128 * 1024},
	{0x09, 128 * 1024},
	{0x0a, 128 * 1024},
	{0x0b, 128 * 1024},
	/* flash sectors only in 2MiB devices */
	{0x10, 16 * 1024},
	{0x11, 16 * 1024},
	{0x12, 16 * 1024},
	{0x13, 16 * 1024},
	{0x14, 64 * 1024},
	{0x15, 128 * 1024},
	{0x16, 128 * 1024},
	{0x17, 128 * 1024},
	{0x18, 128 * 1024},
	{0x19, 128 * 1024},
	{0x1a, 128 * 1024},
	{0x1b, 128 * 1024},
};

6.2.3 结构体mcu_des_t

结构体mcu_des_t存储了STM32F4类MCU的所有型号信息,它被定义在main_f4.c文件中,并被实体化为变量数组mcu_descriptions,此结构用于程序中自动识别当前MCU类型。MCU类型信息被存储在DBGMCU_IDCODE寄存器中,地址为0xE0042000。此结构体在check_silicon函数中使用。


main_f4.c

// address of MCU IDCODE
#define DBGMCU_IDCODE	0xE0042000
#define STM32_UNKNOWN	0
#define STM32F40x_41x	0x413
#define STM32F42x_43x	0x419
#define STM32F42x_446xx	0x421

typedef struct mcu_des_t {
	uint16_t mcuid;
	const char *desc;
	char  rev;
} mcu_des_t;

mcu_des_t mcu_descriptions[] = {
	{ STM32_UNKNOWN,	"STM32F???",    '?'},
	{ STM32F40x_41x, 	"STM32F40x",	'?'},
	{ STM32F42x_43x, 	"STM32F42x",	'?'},
	{ STM32F42x_446xx, 	"STM32F446XX",	'?'},
};

6.2.4 结构体mcu_rev_t

结构体mcu_rev_t存储了MCU的版本信息,它被定义在main_f4.c文件中,并被实体化为变量数组silicon_revs,此结构除了可以识别处理器版本外,还可以据此判断MCU的内部flash信息。


main_f4.c

typedef enum mcu_rev_e {               /* 版本号枚举定义,感觉不全啊, */
	MCU_REV_STM32F4_REV_A = 0x1000,    /* REV A for STM32F405/407/415/417/42X/43X */
	MCU_REV_STM32F4_REV_Z = 0x1001,    /* REV Z for STM32F405/407/415/417 */
	MCU_REV_STM32F4_REV_Y = 0x1003,    /* REV Y for STM32F42X/43X */
	MCU_REV_STM32F4_REV_1 = 0x1007,    /* REV 1 for STM32F42X/43X */
	MCU_REV_STM32F4_REV_3 = 0x2001     /* REV 3 for STM32F42X/43X */
} mcu_rev_e;

typedef struct mcu_rev_t {
	mcu_rev_e revid;
	char  rev;
} mcu_rev_t;

const mcu_rev_t silicon_revs[] = {
	{MCU_REV_STM32F4_REV_3, '3'}, /* Revision 3 */

	{MCU_REV_STM32F4_REV_A, 'A'}, /* Revision A */  // FIRST_BAD_SILICON_OFFSET (place good ones above this line and update the FIRST_BAD_SILICON_OFFSET accordingly)
	{MCU_REV_STM32F4_REV_Z, 'Z'}, /* Revision Z */
	{MCU_REV_STM32F4_REV_Y, 'Y'}, /* Revision Y */
	{MCU_REV_STM32F4_REV_1, '1'}, /* Revision 1 */
};

6.3 IO协处理器核心数据结构

除向量表vector外,IO协处理器的核心数据结构仅有结构体boardinfo,它表征了IO协处理器的运行状态。它同样定义在bl.h中,在main_f1.c中被初始化。


main_f1.c

struct boardinfo board_info = {
	.board_type	= BOARD_TYPE,       /* board_type,BOARD_TYPE板载处理器编号在hw_config.h中定义,IO协处理器为10。 */
	.board_rev	= 0,                /* board_rev,修订版本为0 */
	.fw_size	= APP_SIZE_MAX,         /* fw_size,APP_SIZE_MAX飞控固件大小的最大值,在hw_config.h中被定义为0xf000,60KB */
	.systick_mhz	= OSC_FREQ,         /* systick_mhz,系统时钟输入等于OSC_FREQ,在hw_config.h中被定义为24MHz */
};

7 PX4 Bootloader主线程序

铺垫了这么多,重点终于来了。与u-boot类似,无论是在主控FMU还是IO协处理器上,PX4 Bootloader本身只是一个规模较大的单片机程序,它的主要功能有:

  • 初始化板载芯片并跳转到飞控固件入口
  • 提供板载调试功能,便于系统调试

由于Pixhawk V2硬件的主控FMU和IO协处理器分别运行着自己的那套Bootloader代码,因此它将有2个Bootloader主线。这两个主线程序的引导(main函数之前)由libopencm3库提供支持,premain阶段的代码是相同的。

7.1 初始化阶段(reset_handler函数)程序

Pixhawk V2的主控FMU芯片型号为STM32F427,内核为Cortex M4;IO协处理器芯片的型号为STM32F100,内核为Cortex M3,因此它们启动后MCU的入口地址为向量表的第二项。向量表的内容参见本文“核心数据结构”一节中关于向量表的内容(文件libopencm3/lib/cm3/vector.c),本节的重点是reset_handler函数的详细解析。

reset_handler函数的主要功能如下:

  • 用数据段存储的参数初始化内存空间
  • 清零BSS段
  • 设置异常处理堆栈指针对齐模式
  • 调用与架构相关的pre_main函数
  • 运行所有构造函数
  • 调用main函数
  • 调用所有析构函数

libopencm3/lib/cm3/vector.c

/* 变量声明 */
extern unsigned _data_loadaddr, _data, _edata, _ebss, _stack;		/* 段初始化变量,定义在链接脚本中 */
typedef void (*funcp_t) (void);									/* 定义函数指针类型funcp_t,其原型为void (*functionname) (void) */
extern funcp_t __preinit_array_start, __preinit_array_end;		/* C++构造函数地址变量 */
extern funcp_t __init_array_start, __init_array_end;				/* C++构造函数地址变量 */
extern funcp_t __fini_array_start, __fini_array_end;				/* C++析构函数地址变量 */

/* 定义为弱属性,可直接在其他地方重写此函数;定义为裸属性,确保编译器对reset_handler函数不添加任何加载和卸载代码 */
void __attribute__ ((weak, naked)) reset_handler(void)
{
	volatile unsigned *src, *dest;
	funcp_t *fp;

	/* 用数据段存储的参数初始化内存空间,变量定义见链接脚本。 */
	/* _data_loadaddr:数据段的起始加载地址,即在flash上的首地址 */
	/* _data:数据段的起始运行地址,即在RAM中的首地址 */
	/* _edata:数据段的截止运行地址,即在RAM中的末地址 */
	for (src = &_data_loadaddr, dest = &_data; dest < &_edata; src++, dest++) {
		*dest = *src;
	}

	/* BSS段清零,变量定义见各自的链接脚本 */
	/* _ebss:bss段的截止运行地址,其起始运行地址紧接数据段的末地址 */
	while (dest < &_ebss) {
		*dest++ = 0;
	}

	/* 确保进入异常模式时堆栈指针8字节对齐。此设置对M3和R1架构不起作用 */
	SCB_CCR |= SCB_CCR_STKALIGN;

	/* 调用与架构相关的pre_main函数(主控FMU在文件libopencm3/lib/stm32/f4/vector_chipset.c中;IO协处理器在文件libopencm3/lib/cm3/vector.c中,且为空函数)。 */
	pre_main();

	/* 依次调用所有C++定义的构造函数,变量定义见链接脚本。 */
	/* __preinit_array_start:preinit_array段首地址 */
	/* __preinit_array_end:preinit_array段末地址 */
	/* __init_array_start:init_array段首地址 */
	/* __init_array_end:init_array段末地址 */
	for (fp = &__preinit_array_start; fp < &__preinit_array_end; fp++) {
		(*fp)();
	}
	for (fp = &__init_array_start; fp < &__init_array_end; fp++) {
		(*fp)();
	}

	/* 调用main函数(主控FMU在文件main_f4.c中,IO协处理器在文件main_f1.c中)。 */
	main();

	/* 依次调用所有C++定义的析构函数,变量定义见链接脚本 */
	/* __fini_array_start:fini_array段首地址 */
	/* __fini_array_end:fini_array段末地址 */
	for (fp = &__fini_array_start; fp < &__fini_array_end; fp++) {
		(*fp)();
	}
}

本小节结束前,再简单提一下pre_main函数。该函数只对主控FMU有意义,被定义在文件libopencm3/lib/stm32/f4/vector_chipset.c中,IO协处理器中的pre_main是个空函数。

主控FMU的pre_main函数只做了一件事:使能硬件浮点运算


libopencm3/lib/stm32/f4/vector_chipset.c

static void pre_main(void)
{
	/* 使能硬件浮点运算 */
	SCB_CPACR |= SCB_CPACR_FULL * (SCB_CPACR_CP10 | SCB_CPACR_CP11);
}

7.2 主控FMU的main函数

主控FMU的主线程序的核心是main函数,它被入口函数reset_handler调用。main函数的主要功能是初始化主控FMU芯片并启动飞控固件;若成功代码将永远运行飞控程序,若失败则可与上位机通信方便调试飞控板。主控FMU的main函数流程如下:

  1. 开启浮点运算功能(premain函数中已开启)。
  2. 调用board_init函数来初始化board_info结构体、GPIOA9(VBUS)端口、USART2端口、LED灯等。
  3. 调用clock_init函数来设置时钟、flash访问。
  4. 检查寄存器BOOT_RTC_REG中的值是否与宏BOOT_RTC_SIGNATURE相同。若相同则停留在bootloader。中,若不相同则可以跳转至飞控固件
  5. 通过检查飞控固件在flash地址0x080041a0和0x080041a4的值,来判定是否停留在bootloader中。
  6. 检查USB是否连接,若连接则必须等待timeout再跳转到飞控固件。
  7. 检测串口是否收到break信号(字节0),若收到需等待timeout时间再跳转到飞控固件。
  8. 若运行到此处try_boot依然为真,则调用函数jump_to_app启动飞控固件---------------------------------------------跳转,若函数返回(跳转失败)则继续9步。
  9. 若函数jump_to_app返回,跳转失败;设置寄存器BOOT_RTC_REG值确保下次启动能够检测到,设置timeout使程序永远停留在bootloader中。
  10. 现在bootloader首次启动飞控固件失败,初始化上位机通信接口(USB和USART2)。
  11. 调用bootloader函数与上位机通信,可运行各种调试命令、烧写新的固件等。
  12. 若串口USART2收到break信号(0字节),跳转到11步。
  13. 调用函数jump_to_app启动飞控固件---------------------------------------------跳转,若函数返回(跳转失败)则timeout赋值为0且跳到11步。

值得注意的是,main函数调用的jump_to_app函数依然有很多操作。这部分代码在bl.c文件中定义,其流程具有通用性,但jump_to_app调用的函数又与架构相关,因此这部分将放在后续中。


main_f4.c

#if INTERFACE_USART		/* 宏INTERFACE_USART定义为1,代码有效,hw_config.h */
# define BOARD_INTERFACE_CONFIG_USART	(void *)BOARD_USART		/* 宏BOARD_USART定义为USART2,hw_config.h */
#endif
#if INTERFACE_USB		/* 宏INTERFACE_USB定义为1,代码有效,hw_config.h */
# define BOARD_INTERFACE_CONFIG_USB  	NULL
#endif

int main(void)
{
	bool try_boot = true;					/* bootloader是否立即跳转到飞控固件入口的标志(不等待timeout) */
	unsigned timeout = BOOTLOADER_DELAY;		/* bootloader初始化完毕后跳转到飞控固件入口地址时,所需等待的时间,以ms计算。宏BOOTLOADER_DELAY在hw_config.h中被定义为5000 */

	SCB_CPACR |= ((3UL << 10 * 2) | (3UL << 11 * 2)); /* 使能浮点运算,其功能与pre_main函数相同,实际上可以去掉。 */

#if defined(BOARD_POWER_PIN_OUT)				/* 宏BOARD_POWER_PIN_OUT未定义,下面函数不编译 */
	if (board_get_rtc_signature() == POWER_DOWN_RTC_SIGNATURE) {
		board_set_rtc_signature(0);
		while (1);
	}
#endif

	/* 调用board_init函数,此函数在main_f4.c中被定义,功能如下: */
	/* 1. 赋值board_info.fw_size,确定飞控固件size允许的最大值 */
	/* 2. 初始化USB端口GPIOA9(VBUS) */
	/* 3. 初始化串口USART2 */
	/* 4. 初始化LED并点亮(B/E,LED701) */
	/* 5. 使能能耗控制器时钟 */
	board_init();

	/* 调用clock_init函数,此函数在main_f4.c中被定义,功能如下: */
	/* 1. PLL时钟设置,并选择main PLL作为系统时钟sysclk,fsysclk=fPLL=168MHz,fUSBSDRNG=48MHz */
	/* 2. AHB、APB1、APB2时钟设置,fAHB=fsysclk=168MHz,fAPB1=42MHz,fAPB2=84MHz */
	/* 3. 选择高能耗模式(Scale 2 mode) */
	/* 4. flash访问控制设置,启动Icache和Dcache,并设置等待时间5周期 */
	/* 5. 更新库libopencm3中AHB,APB1,APB2对应的全局变量 */
	clock_init();

	/* 检查寄存器BOOT_RTC_REG中的值是否与宏BOOT_RTC_SIGNATURE相同,若相同则停留在bootloader中,若不相同则可以跳转至飞控固件 */
	/* BOOT_RTC_REG:RTC_BKPxR的第一个32位寄存器,重启不改变存储值,定义在main_f4.c */
	/* BOOT_RTC_SIGNATURE:值0xb007b007,被定义在main_f4.c中 */
	/* board_get_rtc_signature:被定义在main_f4.c中,用于获取寄存器BOOT_RTC_REG的存储值 */
	/* board_set_rtc_signature:被定义在main_f4.c中,设置寄存器BOOT_RTC_REG的值 */
	if (board_get_rtc_signature() == BOOT_RTC_SIGNATURE) {
		/* bootloader跳转标志为假,不再立即跳转到飞控固件 */
		try_boot = false;
		/* timeout清零,若无新的飞控固件上传,不再跳转至飞控固件 */
		timeout = 0;
		/* 寄存器BOOT_RTC_REG清零,确保下次重启可以跳转至飞控固件 */
		board_set_rtc_signature(0);
	}

#ifdef BOOT_DELAY_ADDRESS		/* 宏BOOT_DELAY_ADDRESS在hw_config.h中有定义,下列代码有效 */
	{
		/* 这里给定一个机会,通过飞控固件自身的设置可以影响bootloader的行为。 */
		/* 设置地址在0x080041a0和0x080041a4的flash值满足一系列逻辑要求,可以防止bootloader自动跳转到飞控固件,给调试工作带来方便。 */
		/* BOOT_DELAY_ADDRESS:值0x000001a0,定义在hw_config.h */
		/* flash_func_read_word:定义在main_f4.c,用于读取飞控固件内某地址 */
		/* 这里,sig1为flash中地址在0x080041a0的32位值,sig2为flash中地址在0x080041a4的32位地址值,在飞控固件地址范围内 */
		uint32_t sig1 = flash_func_read_word(BOOT_DELAY_ADDRESS);
		uint32_t sig2 = flash_func_read_word(BOOT_DELAY_ADDRESS + 4);

		/* BOOT_DELAY_SIGNATURE1:值0x92c2ecff,定义在bl.h */
		/* BOOT_DELAY_SIGNATURE2:值0xc5057d5d,定义在bl.h */
		/* BOOT_DELAY_MAX:值30,定义在bl.h */
		/* 在满足一系列逻辑下,设定try_boot为假,且重新设置timeout,保证跳转到飞控固件前等待timeout时间 */
		if (sig2 == BOOT_DELAY_SIGNATURE2 && (sig1 & 0xFFFFFF00) == (BOOT_DELAY_SIGNATURE1 & 0xFFFFFF00)) {
			unsigned boot_delay = sig1 & 0xFF;
			if (boot_delay <= BOOT_DELAY_MAX) {
				try_boot = false;
				if (timeout < boot_delay * 1000) {
					timeout = boot_delay * 1000;
				}
			}
		}
	}
#endif

	/* board_test_force_pin:定义在main_f4.c,若bootloader引脚为真,则设置try_boot为假,程序不立即跳转至飞控固件,需等待timeout时间 */
	/* 由于函数中条件编译的3个宏(BOARD_FORCE_BL_PIN_OUT、BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN)均未被定义,此函数返回恒为假 */
	if (board_test_force_pin()) {
		try_boot = false;
	}

	/* 检查USB是否连接,若连接则必须等待timeout再跳转到飞控固件,否则立即跳转。这样的设置为飞控固件烧写以及调试带来极大方便。 */
#if INTERFACE_USB		/* 宏INTERFACE_USB定义在hw_config.h,以下代码有效 */
#if defined(BOARD_USB_VBUS_SENSE_DISABLED)	/* 宏BOARD_USB_VBUS_SENSE_DISABLED未定义 */
	try_boot = false;
#else
	/* GPIOA:地址为0x40020000的寄存器(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO9:值1<<9(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* gpio_get:获取某GPIO组的值,定义在libopencm3/lib/stm32/common/gpio_common_all.c */
	/* 根据原理图,GPIOA9对应VBUS/3.1A,高电平表示USB已连接,低电平表示USB未接 */
	if (gpio_get(GPIOA, GPIO9) != 0) {
		/* 设置try_boot为假,bootloader不会立即跳转至飞控固件,需等待timeout时间 */
		try_boot = false;
	}
#endif
#endif

	/* 检测串口是否收到break信号(字节0),若收到置try_boot为假,需等待timeout时间再跳转到飞控固件 */
#if INTERFACE_USART		/* 宏INTERFACE_USB定义在hw_config.h,以下代码有效 */
	/* board_test_usart_receiving_break:定义在main_f4.c,连续接收3个字符,若串口上受到字节0则返回真,否则返回假 */
	if (board_test_usart_receiving_break()) {
		try_boot = false;
	}
#endif

	/* 若运行到此处try_boot依然为真,则立即跳转到飞控固件(实际上jump_to_app函数代码依然不短,这里可以近似这样认为); */
	/* 若跳转未成功,则设置RTC备份寄存器BOOT_RTC_REG为预定值,确保下次重启若不更新飞控固件依然无法跳转。 */
	if (try_boot) {
#ifdef BOARD_BOOT_FAIL_DETECT		/* 宏BOARD_BOOT_FAIL_DETECT未定义,以下代码无效 */
		board_set_rtc_signature(BOOT_RTC_SIGNATURE);
#endif
		/* jump_to_app:定义在bl.c,跳转到飞控固件 */
		jump_to_app();
		/* BOOT_RTC_SIGNATURE: */
		/* board_set_rtc_signature: */
		/* 设置RTC备份寄存器BOOT_RTC_REG值为BOOT_RTC_SIGNATURE,下次重启检测到后若不更新飞控固件则不跳转,程序一直运行在bootloader中。 */
		board_set_rtc_signature(BOOT_RTC_SIGNATURE);
		/* 置timeout为0,程序一直在bootloader中 */
		timeout = 0;
	}

	/* 现在bootloader首次启动飞控固件失败,初始化上位机通信接口(USB和USART2) */
#if INTERFACE_USART		/* 宏INTERFACE_USART定义在hw_config.h,下列代码有效 */
	/* BOARD_INTERFACE_CONFIG_USART:值USART2(值0x40004400,指向USART2寄存器首地址)。 */
	/* BOARD_INTERFACE_CONFIG_USART在main_f4.c中被定义为BOARD_USART,BOARD_USART在hw_config.h中被定义为USART2。*/
	/* USART2被定义为USART2_BASE,值0x40004400,指向USART2寄存器首地址(libopencm3/include/libopencm3/stm32/common/usart_common_all.h)。 */
	/* USART:值1,枚举型,定义在bl.h */
	/* cinit:定义在bl.c,用于初始化通信端口 */
	/* 初始化串口USART2为与上位机的通信接口 */
	cinit(BOARD_INTERFACE_CONFIG_USART, USART);
#endif
#if INTERFACE_USB		/* 宏INTERFACE_USB定义在hw_config.h,下列代码有效 */
	/* BOARD_INTERFACE_CONFIG_USB:值NULL,定义在main_f4.c */
	/* USB:值2,枚举型,定义在bl.h */
	/* cinit:定义在bl.c,用于初始化通信端口 */
	/* 初始化USB为虚拟串口作为与上位机的通信接口 */
	cinit(BOARD_INTERFACE_CONFIG_USB, USB);
#endif

#if 0		/* 下列代码无效 */
	// MCO1/02
	gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8);
	gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO8);
	gpio_set_af(GPIOA, GPIO_AF0, GPIO8);
	gpio_mode_setup(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9);
	gpio_set_af(GPIOC, GPIO_AF0, GPIO9);
#endif

	while (1) {
		/* bootloader:bootloader与上位机的命令处理函数,烧写新的固件或者timeout(不为0)时间到返回,定义在bl.c中 */
		bootloader(timeout);

		/* board_test_force_pin:定义在main_f4.c,若bootloader引脚为真,则继续循环 */
		/* 由于函数中条件编译的3个宏(BOARD_FORCE_BL_PIN_OUT、BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN)均未被定义,此函数返回恒为假 */
		if (board_test_force_pin()) {
			continue;
		}

#if INTERFACE_USART			/* 宏INTERFACE_USART定义在hw_config.h,下列代码有效 */
		/* board_test_usart_receiving_break:连续接收3个字节的内容,如果收到一个0字节则返回真,否则返回假。定义在main_f4.c */
		/* 若串口USART2收到break信号(0字节),继续循环 */
		if (board_test_usart_receiving_break()) {
			continue;
		}
#endif

#ifdef BOARD_BOOT_FAIL_DETECT		/* 宏BOARD_BOOT_FAIL_DETECT未定义,下列代码无效 */
		board_set_rtc_signature(BOOT_RTC_SIGNATURE);
#endif

		/* jump_to_app:跳转至飞控固件 */
		jump_to_app();
		/* 跳转失败,timeout设置为0,永久停留在bootloader中 */
		timeout = 0;
	}
}

7.2 IO协处理器的main函数

IO协处理器的主线程序的核心是main函数,它被入口函数reset_handler调用。main函数的主要功能是初始化主控FMU芯片并启动飞控固件;若成功代码将永远运行飞控程序,若失败则可与上位机通信方便调试飞控板。IO协处理器的main函数流程如下:

  1. 调用board_init函数初始化,包括LED灯、强制Bootloader引脚GPIOB5、准备RTC备份寄存器、设置引脚GPIOA2为USART2-TX
  2. 判定,若RTC备份寄存器BKP_DR1中存储了预定值,则timeout赋值为200ms
  3. 若GPIO5为高电平,则timeout赋值为0xffffffff,永久停留在bootloader中
  4. 若timeout为0,则调用jump_to_app立即启动飞控固件---------------------------------------------启动;若jump_to_app函数返回,则timeout赋值为0
  5. 现在bootloader首次启动飞控固件失败,初始化系统时钟为PLL(使用HSI)
  6. 函数初始化串口USART2
  7. 调用bootloader函数与上位机通信,可运行各种调试命令、烧写新的固件等
  8. 调用函数jump_to_app启动飞控固件---------------------------------------------跳转,若函数返回(跳转失败)则timeout赋值为0且跳到7步。

值得注意的是,main函数调用的jump_to_app函数依然有很多操作。这部分代码在bl.c文件中定义,其流程具有通用性,但jump_to_app调用的函数又与架构相关,因此这部分将放在后续中。


#ifdef INTERFACE_USART		/* 宏INTERFACE_USART定义为1,代码有效,hw_config.h */
# define BOARD_INTERFACE_CONFIG		(void *)BOARD_USART		/* 宏BOARD_USART定义为USART2,hw_config.h */
#else
# define BOARD_INTERFACE_CONFIG		NULL
#endif

int main(void)
{
	unsigned timeout = 0;		/* bootloader初始化完毕后跳转到飞控固件入口地址时,所需等待的时间,以ms计算。 */

	/* 调用board_init函数,此函数在main_f1.c中被定义,功能如下 */
	/* 1. 初始化LED控制并点亮LED灯 */
	/* 2. 设置强制Bootloader引脚GPIOB5为浮动输入模式,方便采集安全开关的状态 */
	/* 3. 使能能源接口时钟和备份接口时钟,准备RTC备份寄存器 */
	/* 4. 设置USART2-TX引脚GPIOA2,对应原理图SERIAL_IO_TO_FMU,用于IO协处理器发送信息到主控FMU */
	board_init();

#if defined(INTERFACE_USART) | defined (INTERFACE_USB)		/* 宏INTERFACE_USART和INTERFACE_USB分别被定义为1和0,代码有效,hw_config.h */
	timeout = BOOTLOADER_DELAY;		/* BOOTLOADER_DELAY:值200,表示200ms,hw_config.h */
#endif

#ifdef INTERFACE_I2C				/* 宏INTERFACE_I2C未定义,代码无效 */
# error I2C bootloader detection logic not implemented
#endif

	/* 若RTC备份寄存器BKP_DR1中存储了预定值,则timeout赋值为200ms */
	/* should_wait:判定RTC备份寄存器BKP_DR1中是否存储了预定值。若存储了返回真,未存储则返回假 */
	/* BOOTLOADER_DELAY:值200,表示200ms,hw_config.h */
	if (should_wait()) {
		timeout = BOOTLOADER_DELAY;
	}

#ifdef BOARD_FORCE_BL_PIN		/* 宏BOARD_FORCE_BL_PIN定义为GPIO5,代码有效,hw_config.h */
	/* 若GPIO5为高电平,则timeout赋值为0xffffffff,永久停留在bootloader中 */
	/* BOARD_FORCE_BL_VALUE:被定义为GPIO5(1<<5),hw_config.h */
	/* BOARD_FORCE_BL_PORT:被定义为GPIOB(GPIOB的首寄存器),hw_config.h */
	/* BOARD_FORCE_BL_PIN:被定义为GPIO5(1<<5),hw_config.h */
	/* gpio_get:获取某GPIO组的值,定义在libopencm3/lib/stm32/common/gpio_common_all.c */
	if (BOARD_FORCE_BL_VALUE == gpio_get(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN)) {
		timeout = 0xffffffff;
	}
#endif

	/* 若timeout为0,则调用jump_to_app立即启动飞控固件。 */
	/* 若jump_to_app函数返回,则timeout赋值为0 */
	if (timeout == 0) {
		jump_to_app();
		timeout = 0;
	}

	/* 初始化系统时钟为PLL(使用HSI) */
	/* clock_init:使用HSI将MCU的系统时钟为PLL,频率48MHz,定义在main_f1.c */
	clock_init();

	/* 函数初始化串口USART2 */
	/* BOARD_INTERFACE_CONFIG:定义为BOARD_USART(USART2),main_f1.c */
	/* USART:值1,枚举型,定义在bl.h中 */
	cinit(BOARD_INTERFACE_CONFIG, USART);

	while (1) {
		/* bootloader:bootloader与上位机的命令处理函数,烧写新的固件或者timeout(不为0)时间到返回,定义在bl.c中 */
		bootloader(timeout);
		/* jump_to_app:跳转至飞控固件 */
		jump_to_app();
		/* 跳转失败,timeout设置为0,永久停留在bootloader中 */
		timeout = 0;
	}
}

7.3 飞控固件启动函数jump_to_app

主控FMU或IO协处理器的main函数的一个目标就是调用jump_to_app函数来启动对应的飞控固件。jump_to_app函数定义在文件bl.c中,它的主要功能如下:

  • 通过飞控固件的烧写约定,检测固件是否有效。若无效函数返回,跳转失败
  • 若飞控固件有效,反向初始化MCU外设,准备将外设的控制权交给飞控固件
  • 更改向量表地址至飞控固件的向量表(通过向量表偏移寄存器SCB_VTOR)
  • 重置堆栈并跳转至飞控固件

bl.c

/* do_jump函数,重置堆栈指针并跳转至飞控固件入口的函数,jump_to_app函数的终极目标 */
static void do_jump(uint32_t stacktop, uint32_t entrypoint)
{
	/* 汇编嵌入C语言代码 */
	asm volatile(			/* 汇编代码声明 */
		"msr msp, %0	\n"		/* msr:无条件赋值指令,msp:主堆栈寄存器,%0:0号输入(stacktop)。将stacktop赋值给msp */
		"bx	%1	\n"			/* bx:寄存器寻址跳转指令,%1:1号输入(entrypoint)。程序跳转至寄存器entrypoint */
		: : "r"(stacktop), "r"(entrypoint) :);	/* 定义汇编代码中%0代表stacktop,%1代表entrypoint */

	/* 程序应该不会运行到这里,如果不幸到了,进入死循环 */
	for (;;) ;
}

/* jump_to_app函数 */
void jump_to_app()
{
	/* APP_LOAD_ADDRESS,值0x08004000(主控FMU)0x08001000(IO协处理器),飞控固件起始地址(hw_config.h) */
	const uint32_t *app_base = (const uint32_t *)APP_LOAD_ADDRESS;

	/* 1. 根据飞控固件的烧写约定,检测固件是否有效 */
	/* 飞控固件烧写时,我们特意约定最后烧写固件的首地址(飞控固件使用的堆栈首地址)。若固件首地址为0xffffffff,表明固件烧写未完成(或固件无效)无法跳转,函数直接返回 */
	if (app_base[0] == 0xffffffff) {
		return;
	}
	/* 飞控固件的第二个32位代表飞控固件的入口地址。若此地址未在固件指定的地址范围内,则表示固件有问题无法跳转,函数直接返回 */
	if (app_base[1] < APP_LOAD_ADDRESS) {
		return;
	}
	if (app_base[1] >= (APP_LOAD_ADDRESS + board_info.fw_size)) {
		return;
	}

	/* 2. 现在飞控固件有效,反向初始化以便把外设控制权交给飞控固件 */
	/* flash_lock:主控FMU,锁定flash,操作寄存器FLASH_CR的域LOCK(bit31),定义libopencm3/lib/stm32/common/flash_common_f234.c */
	/* flash_lock:IO协处理器,锁定flash,操作寄存器FLASH_CR的域LOCK(bit7),定义libopencm3/lib/stm32/common/flash_common_f01.c */
	/* bootloader程序中可能解锁flash进行固件烧写功能,这里确保flash上锁 */
	flash_lock();
	/* 关闭systick中断 */
	systick_interrupt_disable();		/* 关闭systick中断(libopencm3/lib/cm3/systick.c) */
	systick_counter_disable();		/* systick倒计时关闭(libopencm3/lib/cm3/systick.c) */
	/* 关闭串口USART2和USB虚拟串口,配置不变 */
	/* cfini:串口反向初始化函数,即关闭串口和USB虚拟串口,定义在main_f?.c */
	cfini();
	/* 关闭时钟源,将所有内部时钟设置为重启后的初始状态 */
	/* clock_deinit:时钟反向初始化函数,定义在main_f?.c */
	clock_deinit();
	/* 反向初始化板载外设(包括USART2、LED控制) */
	/* board_deinit:板载外设反向初始化函数,定义在main_f?.c */
	board_deinit();

	/* 3. 更改向量表地址至飞控固件的向量表 */
	/* SCB_VTOR:寄存器,向量表偏移地址,地址0xE000ED08 */
	/* APP_LOAD_ADDRESS:飞控固件起始地址。0x08004000(主控FMU),0x08001000(IO协处理器) */
	SCB_VTOR = APP_LOAD_ADDRESS;

	/* 4. 重置堆栈并跳转至飞控固件 */
	do_jump(app_base[0], app_base[1]);
}

7.4 命令处理函数bootloader

主控FMU或IO协处理器的main函数调用jump_to_app函数失败(返回)后,就会调用bootloader函数来与上位机进行通信,bootloader定义在文件bl.c中,它的主要功能如下:

  • 1.(重新)启动systick定时器和中断,周期为1ms
  • 2.若timeout不为0,启动0号时钟(TIMER_BL_WAIT),周期为timeout,单位ms
  • 3.设置闪烁B/E LED灯(主控FMU为LED701,IO协处理器为LED703)
  • 4.进入命令处理循环
    • 4.1 关闭ACT LED灯(主控FMU没有,IO协处理器为LED705)
    • 4.2 死循环读取串口数据(1字节),只有读到数据方可跳出循环;此处判断timeout有效且到时函数返回----------------------------------->bootloader函数返回
    • 4.3 读到串口数据(命令),开启ACT LED灯
    • 4.4 处理获取到的指令字
      • (1)若为同步命令PROTO_GET_SYNC
        • 指令非法跳转到cmd_bad
        • 运行正常跳转4.5
      • (2)若为获取设备ID命令PROTO_GET_DEVICE
        • 指令非法跳转到cmd_bad
        • 运行正常输出信息并跳转到4.5
      • (3)若为擦除flash与准备烧写飞控固件指令PROTO_CHIP_ERASE
        • 指令非法跳转到cmd_bad
        • 芯片版本错误跳转到bad_silicon
        • 运行错误跳转到cmd_fail
        • 运行正常跳转到4.5
      • (4)若为flash烧写命令PROTO_PROG_MULTI
        • 指令非法跳转到cmd_bad
        • 芯片版本错误跳转到bad_silicon
        • 运行错误跳转到cmd_fail
        • 运行正常跳转到4.5
      • (5)若为CRC32校验命令PROTO_GET_CRC
        • 指令非法跳转到cmd_bad
        • 运行正常输出校验值并跳转到4.5
      • (6)若为读取OTP区域命令PROTO_GET_OTP
        • 指令非法跳转到cmd_bad
        • 运行正常输出OTP区信息并跳转到4.5
      • (7)若为获取MCU的UDID PROTO_GET_SN
        • 指令非法跳转到cmd_bad
        • 运行正常输出UDID并跳转到4.5
      • (8)若为获取芯片ID和版本信息PROTO_GET_CHIP
        • 指令非法跳转到cmd_bad
        • 运行正常输出芯片ID和版本信息并跳转到4.5
      • (9)若为获取芯片描述信息PROTO_GET_CHIP_DES
        • 指令非法跳转到cmd_bad
        • 运行正常输出芯片描述信息(长度+信息本身)并跳转到4.5
      • (10)若为设置飞控固件启动延时PROTO_SET_DELAY
        • 指令非法跳转到cmd_bad
        • 运行错误跳转到cmd_fail
        • 运行正常跳转到4.5
      • (11)若为完成烧写并启动飞控固件PROTO_BOOT
        • 指令非法跳转到cmd_bad
        • 运行错误跳转到cmd_fail
        • 运行正常发送PROTO_INSYNC+PROTO_OK,等待100ms,函数返回----------------------------------->bootloader函数返回
      • (12)若为输出调试信息(命令暂未完成)PROTO_DEBUG
        • 跳转至4.5
      • 若为其他指令字
        • 跳转至4
    • 4.5 命令处理完毕,运行成功后的处理,发送PROTO_INSYNC+PROTO_OK,跳转至4
    • cmd_bad:指令非法,发送PROTO_INSYNC+PROTO_INVALID,跳转至4
    • cmd_fail:指令错误,发送PROTO_INSYNC+PROTO_FAILED,跳转至4
    • bad_silicon:芯片版本错误,发送PROTO_INSYNC+PROTO_BAD_SILICON_REV,跳转至4

bl.c

#define BL_PROTOCOL_VERSION 		5		/* Bootloader协议版本信息 */
/* 协议字 */
#define PROTO_INSYNC				0x12		/* 同步字 */
#define PROTO_EOC				0x20		/* 命令终止字 */
/* 回告字(https://pixhawk.org/help/errata) */
#define PROTO_OK					0x10		/* 指令运行成功回告字 */
#define PROTO_FAILED				0x11		/* 指令运行错误回告字 */
#define PROTO_INVALID			0x13		/* 非法指令回告字 */
#define PROTO_BAD_SILICON_REV 	0x14		/* 主控MCU(F4芯片)版本错误回告字 */
/* 命令字 */
#define PROTO_GET_SYNC			0x21		/* 获取同步命令 */
#define PROTO_GET_DEVICE			0x22		/* 获取设备ID命令 */
#define PROTO_CHIP_ERASE			0x23		/* 擦除flash与准备烧写飞控固件命令 */
#define PROTO_PROG_MULTI			0x27		/* 烧写flash命令 */
#define PROTO_GET_CRC			0x29		/* 计算CRC32校验命令 */
#define PROTO_GET_OTP			0x2a		/* 读取OTP区域某地址的1字节 */
#define PROTO_GET_SN				0x2b		/* 读取MCU的UDID(Unique Device ID) */
#define PROTO_GET_CHIP			0x2c		/* 读取芯片ID和版本 */
#define PROTO_SET_DELAY			0x2d		/* 设置飞控固件启动等待时间 */
#define PROTO_GET_CHIP_DES		0x2e		/* 获取芯片描述信息 */
#define PROTO_BOOT				0x30		/* 完成烧写并启动飞控固件 */
#define PROTO_DEBUG				0x31		/* 输出调试信息(未完成) */

/* 命令PROTO_GET_DEVICE后跟的参数 */
#define PROTO_DEVICE_BL_REV		1		/* Bootloader协议版本 */
#define PROTO_DEVICE_BOARD_ID	2		/* 板载处理器编号 */
#define PROTO_DEVICE_BOARD_REV	3		/* 修订版本 */
#define PROTO_DEVICE_FW_SIZE		4		/* 飞控固件大小的最大值 */
#define PROTO_DEVICE_VEC_AREA	5		/* 飞控固件向量表7-10项的函数地址(debug_monitor、sv_call、pend_sv、systick) */

/* 全局变量 */
volatile unsigned timer[NTIMERS];		/* NTIMERS:值4,通用倒计时器数量,定义在bl.h;timer:通用计时器数组变量 */
static enum led_state {LED_BLINK, LED_ON, LED_OFF} _led_state;	/* _led_state:LED状态枚举型变量 */
static uint8_t bl_type;					/* bl_type:接口类型静态全局变量,被bootloader函数定义 */
static uint8_t last_input;				/* last_input:静态全局变量,上次获取串口数据的方式 */
static volatile unsigned cin_count;		/* cin_count:串口和USB虚拟串口接收到的数据数量,全局变量 */

/* BL_PROTOCOL_VERSION:值5,表示Bootloader协议版本 */
static const uint32_t bl_proto_rev = BL_PROTOCOL_VERSION;		/* bl_proto_rev:全局变量,存储Bootloader的版本号,是获取设备ID命令参数PROTO_DEVICE_BL_REV的回告值 */

/* 根据输入设置LED状态的函数,被bootloader函数调用,功能如下: */
/* 若输入为LED_OFF,则关闭B/E LED灯 */
/* 若输入为LED_ON,则关闭B/E LED灯 */
/* 若输入为LED_BLINK,则2号计时器(TIMER_LED)清零,systick中断函数立即,准备闪烁B/E LED灯 */
static void led_set(enum led_state state)
{
	/* 更改全局变量_led_state为当前LED状态 */
	_led_state = state;

	/* LED_OFF:值2,led_state枚举型,定义在bl.c */
	/* LED_ON:值1,led_state枚举型,定义在bl.c */
	/* LED_BLINK:值0,led_state枚举型,定义在bl.c */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* TIMER_LED:值2,定义在bl.h */
	/* timer:通用计时器数组变量,定义在bl.c */
	/* led_off:关闭LED灯,定义在main_f?.c */
	/* led_on:开启LED灯,定义在main_f?.c */
	switch (state) {
	case LED_OFF:
		led_off(LED_BOOTLOADER);
		break;
	case LED_ON:
		led_on(LED_BOOTLOADER);
		break;
	case LED_BLINK:
		timer[TIMER_LED] = 0;
		break;
	}
}


/* systick时钟的中断处理函数,向量表中systick域的赋值在libopencm3/lib/cm3/vector.c */
void sys_tick_handler(void)
{
	unsigned i;

	/* tick到来,各时钟减1 */
	/* NTIMERS:值4,通用倒计时器数量,定义在bl.h */
	/* timer:通用计时器数组变量,定义在bl.c */
	for (i = 0; i < NTIMERS; i++)
		if (timer[i] > 0) {
			timer[i]--;
		}

	/* 处理B/E LED(主控FMU为LED701,IO协处理器为LED703)闪烁功能 */
	/* 时钟设为50ms,每个周期就是100ms。 */
	/* _led_state:全局LED状态枚举(led_state枚举型)变量,存储B/E LED的状态,定义在bl.c */
	/* TIMER_LED:值2,定义在bl.h */
	/* LED_BLINK:值0,led_state枚举型,定义在bl.c */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* led_toggle:使输入的LED反向,定义在main_f?.c */
	if ((_led_state == LED_BLINK) && (timer[TIMER_LED] == 0)) {
		led_toggle(LED_BOOTLOADER);
		timer[TIMER_LED] = 50;
	}
}


/* 延时函数,被bootloader函数调用 */
void delay(unsigned msec)
{
	/* timer:通用计时器数组变量,定义在bl.c */
	/* TIMER_DELAY:值3,定义在bl.h */
	timer[TIMER_DELAY] = msec;
	/* 若TIMER_DELAY时钟未到,一直停留在此函数中,确保延时 */
	while (timer[TIMER_DELAY] > 0);
}


/* 获取串口数据函数,可为USART和USB虚拟串口 */
inline int cin(void)
{
#if INTERFACE_USB		/* 对主控FMU,宏INTERFACE_USART定义为1,代码有效,hw_config.h */
						/* 对IO协处理器,宏INTERFACE_USART定义为0,代码无效,hw_config.h */
	/* 通过串口获取调试数据,若返回的数据值有效(>=0),则返回获取的数据值,并更新全局变量last_input */
	/* NONE:值0,枚举类,定义在bl.h */
	/* USB:值2,枚举类,定义在bl.h */
	/* bl_type:输入接口类型全局静态变量,被bootloader函数赋值 */
	/* last_input:全局变量上次获取串口数据的方式 */
	/* usb_cin:从USB模拟串口读入1个字,定义在cdcacm.c */
	if (bl_type == NONE || bl_type == USB) {
		int usb_in = usb_cin();
		if (usb_in >= 0) {
			last_input = USB;
			return usb_in;
		}
	}
#endif
#if INTERFACE_USART		/* 宏INTERFACE_USART定义为1,代码有效,hw_config.h */
	/* 通过串口获取调试数据,若返回的数据值有效(>=0),则返回获取的数据值,并更新全局变量last_input */
	/* NONE:值0,枚举类,定义在bl.h */
	/* USART:值1,枚举类,定义在bl.h */
	/* bl_type:输入接口类型全局静态变量,被bootloader函数赋值 */
	/* last_input:全局变量上次获取串口数据的方式 */
	/* uart_cin:从串口读入1个字,定义在usart.c */
	if (bl_type == NONE || bl_type == USART) {
		int	uart_in = uart_cin();
		if (uart_in >= 0) {
			last_input = USART;
			return uart_in;
		}
	}
#endif
	return -1;		/* 返回错误 */
}


/* 串口或模拟串口输出特定内容的函数 */
inline void cout(uint8_t *buf, unsigned len)
{
#if INTERFACE_USB		/* 对主控FMU,宏INTERFACE_USART定义为1,代码有效,hw_config.h */
						/* 对IO协处理器,宏INTERFACE_USART定义为0,代码无效,hw_config.h */
	/* USB:值2,枚举类,定义在bl.h */
	/* bl_type:启动接口类型全局静态变量,被bootloader函数赋值 */
	/* usb_cout:USB模拟串口输出特定内容的函数,定义在usart.c */
	if (bl_type == USB) {
		usb_cout(buf, len);
	}

#endif
#if INTERFACE_USART				/* 宏INTERFACE_USART定义为1,代码有效,hw_config.h */
	/* USART:值1,枚举类,定义在bl.h */
	/* bl_type:启动接口类型全局静态变量,被bootloader函数赋值 */
	/* uart_cout:USART串口输出特定内容的函数,定义在usart.c */
	if (bl_type == USART) {
		uart_cout(buf, len);
	}
#endif
}


/* 发送同步命令函数,是bootloader函数中命令运行成功后调用的函数 */
static void sync_response(void)
{
	/* PROTO_INSYNC:值0x12,同步指令字,定义在bl.c */
	/* PROTO_OK:值0x10,指令运行成功回告字,定义在bl.c */
	/* cout:串口或模拟串口输出特定内容的函数,定义在bl.c */
	uint8_t data[] = {
		PROTO_INSYNC,
		PROTO_OK	
	};
	cout(data, sizeof(data));
}


/* 当MCU型号错误处理函数,串口或USB模拟串口输出非法响应(PROTO_INSYNC+PROTO_BAD_SILICON_REV),是bootloader函数中bad_silicon标号对应的函数 */
#if defined(TARGET_HW_PX4_FMU_V4)		/* 对主控FMU,TARGET_HW_PX4_FMU_V4定义为1,代码有效,Makefile.f4 */
										/* 对IO协处理器,TARGET_HW_PX4_FMU_V4未定义,代码无效 */
static void bad_silicon_response(void)
{
	/* PROTO_INSYNC:值0x12,同步指令字,定义在bl.c */
	/* PROTO_BAD_SILICON_REV:值0x14,主控MCU型号错误命令字,定义在bl.c */
	/* cout:串口或模拟串口输出特定内容的函数,定义在bl.c */
	uint8_t data[] = {
		PROTO_INSYNC,
		PROTO_BAD_SILICON_REV
	};
	cout(data, sizeof(data));
}
#endif


/* 当指令非法时的处理函数,串口或USB模拟串口输出非法响应(PROTO_INSYNC+PROTO_INVALID),是bootloader函数中cmd_bad标号对应的函数 */
static void invalid_response(void)
{
	/* PROTO_INSYNC:值0x12,同步指令字,定义在bl.c */
	/* PROTO_INVALID:值0x13,非法指令字,定义在bl.c */
	/* cout:串口或模拟串口输出特定内容的函数,定义在bl.c */
	uint8_t data[] = {
		PROTO_INSYNC,
		PROTO_INVALID
	};
	cout(data, sizeof(data));
}


/* 当指令运行失败时的处理函数,串口或USB模拟串口输出运行失败响应(PROTO_INSYNC+PROTO_FAILED),是bootloader函数中cmd_fail标号对应的函数 */
static void failure_response(void)
{
	/* PROTO_INSYNC:值0x12,同步指令字,定义在bl.c */
	/* PROTO_FAILED:值0x11,运行失败指令字,定义在bl.c */
	/* cout:串口或模拟串口输出特定内容的函数,定义在bl.c */
	uint8_t data[] = {
		PROTO_INSYNC,
		PROTO_FAILED	
	};
	cout(data, sizeof(data));
}


/* 在给定的时间timeout内读到串口数据,则返回数据;若超时返回-1 */
static int cin_wait(unsigned timeout)
{
	int c = -1;

	/* 设置1号定时器(TIMER_CIN)周期为输入值(此处为0) */
	/* TIMER_CIN:值1,定义在bl.h */
	/* timer:通用计时器数组变量,定义在bl.c */
	timer[TIMER_CIN] = timeout;

	/* 一直读取串口获得数据。若要返回,或者读取到数据,或者若定时器(TIMER_CIN)到时。 */
	/* cin_count:串口和USB虚拟串口接收到的数据总量,定义在bl.c */
	/* cin:获取串口数据函数,定义在bl.c */
	do {
		c = cin();
		if (c >= 0) {
			cin_count++;
			break;
		}
	} while (timer[TIMER_CIN] > 0);

	return c;
}


/* 串口或USB模拟串口输出1个字 */
static void cout_word(uint32_t val)
{
	/* cout:串口或模拟串口输出特定内容的函数,定义在bl.c */
	cout((uint8_t *)&val, 4);
}


/* 串口或USB模拟串口读入1个字,具有超时检测功能 */
static int cin_word(uint32_t *wp, unsigned timeout)
{
	/* 由于USB串口每次只能读入1字节,而结果需要的是1个字,故定义联合体u长度4字节适用于两种操作 */
	union {
		uint32_t w;
		uint8_t b[4];
	} u;

	/* 连续4此读取串口,并将其拼接成1个字(小端);若读取过程中超时则返回-1 */
	/* cin_wait:在给定的时间timeout内读到串口数据,则返回数据;若超时返回-1,定义在bl.c */
	for (unsigned i = 0; i < 4; i++) {
		int c = cin_wait(timeout);
		if (c < 0) {
			return c;
		}
		u.b[i] = c & 0xff;
	}

	*wp = u.w;
	return 0;
}


/* 在给定的等待时间内,下一条获取到的命令是否为终止字PROTO_EOC;若是返回真,不是返回假 */
inline static bool wait_for_eoc(unsigned timeout)
{
	/* PROTO_EOC:值0x20,命令终止字,定义在bl.c */
	/* cin_wait:在给定的输入时间内读到串口数据,则返回数据;若超时返回-1,bl.c */
	return cin_wait(timeout) == PROTO_EOC;
}


/* 给出数据src的crc32校验结果 */
static uint32_t crc32(const uint8_t *src, unsigned len, unsigned state)
{
	static uint32_t crctab[256];

	/* 检查是否已生成crc32校验表(按照定义肯定是未生成的),若未生成则立刻生成 */
	if (crctab[1] == 0) {
		for (unsigned i = 0; i < 256; i++) {
			uint32_t c = i;
			for (unsigned j = 0; j < 8; j++) {
				if (c & 1) {
					c = 0xedb88320U ^ (c >> 1);
				} else {
					c = c >> 1;
				}
			}
			crctab[i] = c;
		}
	}

	/* 对于从src开始的len长度字节进行crc32校验 */
	for (unsigned i = 0; i < len; i++) {
		state = crctab[(state ^ src[i]) & 0xff] ^ (state >> 8);
	}

	return state;
}


void bootloader(unsigned timeout)
{
	/* bl_type:全局接口类型变量。NONE:值0,枚举类,定义在bl.h */
	/* 若使bootloader实际上能够起作用,必须设置bl_type的类型,不能按照默认值NONE */
	bl_type = NONE;

	uint32_t address = board_info.fw_size;	/* flash当前编写逻辑地址变量,初始化为board_info.fw_size,确保在不执行擦除条件下无法编写 */
	uint32_t first_word = 0xffffffff;

	/* 1.(重新)启动systick定时器和中断,周期为1ms */
	/* STK_CSR_CLKSOURCE_AHB:值1<<2,选取AHB作为systick的时钟源,libopencm3/include/libopencm3/cm3/systick.h */
	/* board_info.systick_mhz:值168(主控FMU,main_f4.c),24(IO协处理器,main_f1.c) */
	/* systick_set_clocksource:选取systick的时钟源,libopencm3/lib/cm3/systick.c */
	/* systick_set_reload:设置systick时钟倒计时(寄存器STK_VAL),libopencm3/lib/cm3/systick.c */
	/* systick_interrupt_enable:开启systick中断,libopencm3/lib/cm3/systick.c */
	/* systick_counter_enable:systick倒计时开启,libopencm3/lib/cm3/systick.c */
	systick_set_clocksource(STK_CSR_CLKSOURCE_AHB);
	systick_set_reload(board_info.systick_mhz * 1000);	/* 1ms tick, magic number */
	systick_interrupt_enable();
	systick_counter_enable();

	/* 2. 若timeout不为0,启动0号时钟(TIMER_BL_WAIT),周期为timeout,单位ms */
	/* timeout为0则不启动时钟,永远停留在本函数中 */
	/* TIMER_BL_WAIT:值0,定义在bl.h */
	/* timer:unsigned型全局数组,成员有4个,定义在bl.c */
	if (timeout) {
		timer[TIMER_BL_WAIT] = timeout;
	}

	/* 3. 设置闪烁B/E LED灯(主控FMU为LED701,IO协处理器为LED703) */
	/* B/E LED灯闪烁表示程序处于闲置状态,通过systick时钟的中断处理函数来实现 */
	/* LED_BLINK:值0,led_state枚举成员,定义在bl.c */
	/* led_set:LED灯状态设置函数,定义在bl.c */
	led_set(LED_BLINK);

	/* 4. 进入命令处理循环 */
	while (true) {
		volatile int c;
		int arg;
		static union {
			uint8_t c[256];
			uint32_t w[64];
		} flash_buffer;

		/* 4.1 关闭ACT LED灯(主控FMU没有,IO协处理器为LED705) */
		/* LED_ACTIVITY:值1,led_state枚举成员,定义在bl.c */
		/* led_off:关闭LED灯,定义在main_f?.c */
		led_off(LED_ACTIVITY);

		/* 4.2 死循环读取串口数据(1字节),只有读到数据方可跳出循环 */
		do {
			/* 若timeout非零,0号时钟(TIMER_BL_WAIT)倒计时至0,则timeout时间到返回。 */
			/* TIMER_BL_WAIT:值0,定义在bl.h */
			/* timeout:bootloader跳转到飞控固件所需等待的时间,bootloader函数输入 */
			/* timer:通用计时器数组变量,定义在bl.c */
			if (timeout && !timer[TIMER_BL_WAIT]) {
				return;
			}
			/* 不等待,立即读取串口一个数据(cin_wait输入为0) */
			/* cin_wait:在给定的输入时间timeout内读到串口数据,则返回数据;若超时返回-1,定义在bl.c */
			c = cin_wait(0);
		} while (c < 0);

		/* 4.3 读到串口数据(命令),开启ACT LED灯 */
		/* LED_ACTIVITY:值1,led_state枚举成员,定义在bl.c */
		/* led_off:开启LED灯,定义在main_f?.c */
		led_on(LED_ACTIVITY);

		/* 4.4 处理获取到的命令字 */
		switch (c) {
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (1) 同步命令PROTO_GET_SYNC(0x21),命令结构PROTO_GET_SYNC+PROTO_EOC */
		/*   * 收到PROTO_GET_SYNC的2ms内未接收到命令终止字,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 运行成功,(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* 接收到同步命令PROTO_GET_SYNC的2ms内位需收到终止字PROTO_EOC(0x20),否则进行错误指令处理 */
		/* PROTO_GET_SYNC:值0x21,同步命令字,定义在bl.c */
		/* PROTO_EOC:值0x20,命令终止字,定义在bl.c */
		/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
		case PROTO_GET_SYNC:
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为终止字PROTO_EOC;若是返回真,不是返回假 */
			/* cmd_bad:标号 */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (2)获取设备ID命令PROTO_GET_DEVICE(0x22),它后面通常还会跟随一个参数(用于指示具体获取设备的哪个内容),命令结构:PROTO_GET_DEVICE+arg(1byte)+PROTO_EOC */
		/*   * 若为无效参数或参数后2ms内未接收到命令终止字,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 若为PROTO_DEVICE_BL_REV(值1),则返回bootloader协议版本号BL_PROTOCOL_VERSION(值5),回告结构:rev(4byte)+(PROTO_INSYNC+PROTO_OK) */
		/*   * 若为PROTO_DEVICE_BOARD_ID(值2),则返回板载处理器编号board_info.board_type(BOARD_TYPE,主控FMU值9,IO协处理器值10),回告结构:board_type(4byte)+(PROTO_INSYNC+PROTO_OK) */
		/*   * 若为PROTO_DEVICE_BOARD_REV(值3),则返回修订版本board_info.board_rev(值0),回告结构:board_rev(4byte)+(PROTO_INSYNC+PROTO_OK) */
		/*   * 若为PROTO_DEVICE_FW_SIZE(值4),则返回飞控固件的最大值(单位KB)board_info.fw_size(主控值2000,IO协处理器APP_SIZE_MAX=0xf000),回告结构:fw_size(4byte)+(PROTO_INSYNC+PROTO_OK) */
		/*   * 若为PROTO_DEVICE_VEC_AREA(值5),则返回飞控固件向量表7-10项的函数地址(debug_monitor、sv_call、pend_sv、systick),回告结构:vectors(4*4byte)+(PROTO_INSYNC+PROTO_OK) */
		/*   * 若为其他参数,则进行非法指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 运行成功,(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_GET_DEVICE:		/* PROTO_GET_DEVICE:值0x22,获取设备ID命令,定义在bl.c */
			/* cin_wait:在给定的1s时间内读到串口数据,则返回数据;若超时返回-1,定义在bl.c */
			arg = cin_wait(1000);
			/* 判定若获取的参数无效(<0)或获取到命令终止,则返回报错 */
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (arg < 0) {
				goto cmd_bad;
			}
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}
			/* 判定命令PROTO_GET_DEVICE的参数 */
			/* PROTO_DEVICE_BL_REV:值1,命令PROTO_GET_DEVICE的参数,表示获取Bootloader协议版本,定义在bl.c */
			/* PROTO_DEVICE_BOARD_ID:值2,命令PROTO_GET_DEVICE的参数,表示获取板载处理器编号(对应board_info.board_type=BOARD_TYPE),定义在bl.c */
			/* PROTO_DEVICE_BOARD_REV:值3,命令PROTO_GET_DEVICE的参数,表示获取修订版本(对应board_info.board_rev=0),定义在bl.c */
			/* PROTO_DEVICE_FW_SIZE:值4,命令PROTO_GET_DEVICE的参数,表示飞控固件的最大值(对应board_info.fw_size),定义在bl.c */
			/* PROTO_DEVICE_VEC_AREA:值5,命令PROTO_GET_DEVICE的参数,表示获取飞控固件向量表7-10项的函数地址(debug_monitor、sv_call、pend_sv、systick),定义在bl.c */
			/* bl_proto_rev:全局变量,存储Bootloader的版本号(BL_PROTOCOL_VERSION值5),是获取设备ID命令参数PROTO_DEVICE_BL_REV的回告值,定义在bl.c */
			/* cout:串口(包括USB虚拟串口)输出特定内容的函数,定义在bl.c */
			/* flash_func_read_word:读取flash特定地址1个字的函数,定义在main_f?.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			switch (arg) {
			case PROTO_DEVICE_BL_REV:
				cout((uint8_t *)&bl_proto_rev, sizeof(bl_proto_rev));
				break;
			case PROTO_DEVICE_BOARD_ID:
				cout((uint8_t *)&board_info.board_type, sizeof(board_info.board_type));
				break;
			case PROTO_DEVICE_BOARD_REV:
				cout((uint8_t *)&board_info.board_rev, sizeof(board_info.board_rev));
				break;
			case PROTO_DEVICE_FW_SIZE:
				cout((uint8_t *)&board_info.fw_size, sizeof(board_info.fw_size));
				break;
			case PROTO_DEVICE_VEC_AREA:
				for (unsigned p = 7; p <= 10; p++) {
					uint32_t bytes = flash_func_read_word(p * 4);
					cout((uint8_t *)&bytes, sizeof(bytes));
				}
				break;
			default:
				goto cmd_bad;
			}
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (3)擦除flash与准备烧写飞控固件指令PROTO_CHIP_ERASE(0x23),命令结构:PROTO_CHIP_ERASE+PROTO_EOC */
		/*   * 收到PROTO_CHIP_ERASE的2ms内未收到命令终止字,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */ */
		/*   * 若为主控FMU芯片(F4),调用check_silicon函数判断MCU版本是否正确(是否为revision 3) */
		/*       * 若主控FMU版本不正确(revision 3以下),跳转进行bad_silicon处理,回告结构:(PROTO_INSYNC+PROTO_BAD_SILICON_REV) */
		/*   * 点亮B/E灯,指示正在擦除flash,逐段、页(sector)擦除flash */
		/*   * 关闭B/E灯,指示擦除flash已完成,取每KB的首字检查flash擦除操作是否成功 */
		/*       * 若flash擦除操作失败,进行指令运行失败处理,回告结构:(PROTO_INSYNC+PROTO_FAILED) */
		/*   * 重置flash编写逻辑地址变量address为0,恢复B/E灯闪烁 */
		/*   * 运行成功,(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_CHIP_ERASE:		/* PROTO_CHIP_ERASE:值0x23,擦除flash与准备烧写飞控固件命令 */
			/* 接收到PROTO_CHIP_ERASE命令后2ms内应该接收到终止字PROTO_EOC(0x20),否则进行非法指令处理 */
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cmd_bad:指令非法处理函数的标号,在bootloader函数末尾 */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}
#if defined(TARGET_HW_PX4_FMU_V4)		/* 对主控FMU,宏TARGET_HW_PX4_FMU_V4定义为1,代码有效,Makefile.F4 */
										/* 对UI协处理器,宏TARGET_HW_PX4_FMU_V4未定义,代码无效 */
			/* check_silicon:函数自动辨识MCU的版本,默认STM32F427的revision 3返回0,其余返回-1 */
			/* bad_silicon:MCU版本错误处理函数的标号,在bootloader函数末尾 */
			if (check_silicon()) {
				goto bad_silicon;
			}
#endif
			/* 点亮B/E灯 */
			/* LED_ON: 值1,led_state枚举成员,定义在bl.c*/
			/* led_set:LED灯状态设置函数,定义在bl.c */
			led_set(LED_ON);

			/* flash_unlock:解锁flash的库函数,定义在libopencm3/lib/stm32/common/flash_common_f234.c(主控FMU),libopencm3/lib/stm32/common/flash_common_f01.c(IO协处理器) */
			flash_unlock();
			/* 逐段擦除flash */
			/* flash_func_sector_size:返回MCU的flash在某sector的大小值,若无此sector则返回0,定义在main_f?.c */
			/* flash_func_erase_sector: */
			for (int i = 0; flash_func_sector_size(i) != 0; i++) {
				flash_func_erase_sector(i);
			}

			/* 关闭B/E灯 */
			/* LED_OFF: 值2,led_state枚举成员,定义在bl.c*/
			/* led_set:LED灯状态设置函数,定义在bl.c */
			led_set(LED_OFF);

			/* 取每KB的首字检查flash擦除操作是否正确,即是否有擦除成功 */
			/* board_info.fw_size:飞控固件的最大值(单位KB) */
			/* flash_func_read_word:读取某flash地址的数据,定义在main_f?.c */
			/* cmd_fail:指令运行错误处理的标号,在bootloader函数末尾 */
			for (address = 0; address < board_info.fw_size; address += 4)
				if (flash_func_read_word(address) != 0xffffffff) {
					goto cmd_fail;
				}
			address = 0;

			/* B/E灯闪烁 */
			/* LED_BLINK: 值0,led_state枚举成员,定义在bl.c*/
			/* led_set:LED灯状态设置函数,定义在bl.c */
			led_set(LED_BLINK);
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (4)flash烧写命令PROTO_PROG_MULTI(0x27),命令结构:PROTO_PROG_MULTI+arg(1byte)+c(len bytes)+PROTO_EOC */
		/*   * 收到PROTO_PROG_MULTI的50ms内未收到第一个参数(长度arg),按照错误命令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 若收到的第一个参数(长度arg)不是4字节对齐,按照错误命令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 若当前编写地址(address)+第一个参数(长度arg)超出飞控固件最大范围board_info.fw_size,按照错误命令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 若收到的第一个参数(长度arg)超出缓冲区长度,按照错误命令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 根据长度arg逐字节接收数据,并存放在缓冲区flash_buffer中;若其中任何1个字节超时1s,按照错误命令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 接收完有效数据后,若200ms内未接收到命令终止字(PROTO_EOC),按照错误命令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 若当前编写地址address为0,则将烧写缓冲区flash_buffer首个32位保存在变量first_word中,并将缓冲区首改为0xFFFFFFFF */
		/*       * 对于主控FMU,若MCU版本检查失败,按照MCU版本错误处理,回告结构:(PROTO_INSYNC+PROTO_BAD_SILICON_REV) */
		/*   * 逐字烧写flash地址,若写入与读出不一致,进行命令失败处理,回告结构:(PROTO_INSYNC+PROTO_FAILED) */
		/*   * 运行成功,(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_PROG_MULTI:		/* PROTO_PROG_MULTI:值0x27,烧写flash命令 */
			/* 50ms内获取第一个参数 */
			/* cin_wait:在给定的时间内读到串口数据,则返回数据;若超时返回-1,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			/* board_info.fw_size:飞控固件的最大值 */
			/* flash_buffer:共同体,代表接收缓冲区(256字节或32字) */
			arg = cin_wait(50);
			if (arg < 0) {
				goto cmd_bad;
			}
			if (arg % 4) {
				goto cmd_bad;
			}
			if ((address + arg) > board_info.fw_size) {
				goto cmd_bad;
			}
			if (arg > sizeof(flash_buffer.c)) {
				goto cmd_bad;
			}

			/* 逐字节接收串口数据并存放在缓冲区内,数据延时不超过1s */
			/* cin_wait:在给定的时间内读到串口数据,则返回数据;若超时返回-1,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			/* flash_buffer:共同体,代表接收缓冲区(256字节或32字) */
			for (int i = 0; i < arg; i++) {
				c = cin_wait(1000);
				if (c < 0) {
					goto cmd_bad;
				}
				flash_buffer.c[i] = c;
			}

			/* 接收完有效数据后,200ms内必须接收到命令终止字 */
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (!wait_for_eoc(200)) {
				goto cmd_bad;
			}

			/* 若当前编写逻辑地址为0,(对主控FMU,若MCU版本检查失败,跳转到bad_silicon,进行错误MCU版本处理),则将烧写缓冲区flash_buffer首个32位保存在变量first_word中,并将缓冲区首改为0xFFFFFFFF */
			/* check_silicon:函数自动辨识MCU的版本,默认STM32F427的revision 3返回0,其余返回-1 */
			/* bad_silicon:MCU版本错误处理函数的标号,在bootloader函数末尾 */
			/* first_word:首字保存变量,定义在bootloader函数中 */
			/* flash_buffer:共同体,代表接收缓冲区(256字节或32字) */
			if (address == 0) {
#if defined(TARGET_HW_PX4_FMU_V4)			/* 对主控FMU,宏TARGET_HW_PX4_FMU_V4定义为1,代码有效,Makefile.f4 */
											/* 对IO协处理器,宏TARGET_HW_PX4_FMU_V4未定义,代码无效 */
				if (check_silicon()) {
					goto bad_silicon;
				}
#endif
				first_word = flash_buffer.w[0];
				flash_buffer.w[0] = 0xffffffff;
			}

			/* 逐字烧写flash地址,若写入与读出不一致,跳转到cmd_fail,进行命令失败处理,返回PROTO_INSYNC+PROTO_FAILED */
			/* flash_func_write_word:烧写flash某地址起始为特定内容,4位烧写,定义在main_f?.c */
			/* flash_func_read_word:读取flash某特定地址内容,4位读取,定义在main_f?.c */
			/* cmd_fail:指令运行错误处理的标号,在bootloader函数末尾 */
			arg /= 4;
			for (int i = 0; i < arg; i++) {
				flash_func_write_word(address, flash_buffer.w[i]);
				if (flash_func_read_word(address) != flash_buffer.w[i]) {
					goto cmd_fail;
				}
				address += 4;
			}
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (5)CRC32校验命令PROTO_GET_CRC(0x29),命令结构:PROTO_GET_CRC+PROTO_EOC */
		/*   * 收到PROTO_GET_CRC的2ms内未接收到命令终止字,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 计算CRC32结果,输出crcsum(4byte),(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_GET_CRC:		/* PROTO_GET_CRC:值0x29,CRC32校验命令 */
			/* 2ms内必须收到命令终止字PROTO_EOC */
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}

			/* 计算烧写区域的CRC32值,注意飞控固件首地址的处理 */
			/* board_info.fw_size:飞控固件的最大值 */
			/* flash_func_read_word:读取flash某特定地址内容,4位读取,定义在main_f?.c */
			/* crc32:计算给定数据的crc32校验结果 */
			uint32_t sum = 0;
			for (unsigned p = 0; p < board_info.fw_size; p += 4) {
				uint32_t bytes;
				if ((p == 0) && (first_word != 0xffffffff)) {
					bytes = first_word;
				} else {
					bytes = flash_func_read_word(p);
				}
				sum = crc32((uint8_t *)&bytes, sizeof(bytes), sum);
			}
			/* cout_word:串口或模拟串口输出1个字的函数,定义在bl.c */
			cout_word(sum);
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (6)读取OTP区域命令PROTO_GET_OTP(0x2a),命令结构:PROTO_GET_OTP+index(4byte)+PROTO_EOC */
		/*   * 收到PROTO_GET_OTP后未在允许延时(100ms)内收到有效的地址信息,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 收到地址后2ms内未收到命令终止字,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 运行成功,输出OTP地址数值val(4byte),(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_GET_OTP:			/* PROTO_GET_OTP:值0x2a,读取OTP区域某地址的1字节指令 */
			uint32_t index = 0;
			/* cin_word:串口或USB模拟串口读入1个字,具有超时检测功能,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (cin_word(&index, 100)) {
				goto cmd_bad;
			}
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cout_word:串口或模拟串口输出1个字的函数,定义在bl.c */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}
			cout_word(flash_func_read_otp(index));
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (7)获取MCU的UDID(Unique Device ID,或称为序列号)PROTO_GET_SN(0x2b),命令结构PROTO_GET_SN+index(4byte)+PROTO_EOC */
		/*   * 收到PROTO_GET_SN后未在允许延时(100ms)内收到有效的地址信息,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 收到地址后2ms内未收到命令终止字,则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 运行成功,输出UDID数值val(4byte),(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_GET_SN:		/* PROTO_GET_SN:值0x2b,获取MCU的UDID命令 */
			uint32_t index = 0;
			/* cin_word:串口或USB模拟串口读入1个字,具有超时检测功能,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (cin_word(&index, 100)) {
				goto cmd_bad;
			}
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cout_word:串口或模拟串口输出1个字的函数,定义在bl.c */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}
			cout_word(flash_func_read_sn(index));
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (8)获取芯片ID和版本信息PROTO_GET_CHIP(0x2c),命令结构PROTO_GET_CHIP+PROTO_EOC */
		/*   * 收到命令PROTO_GET_CHIP后2ms内未收到命令终止字,进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 运行成功,输出芯片ID和版本信息数值val(4byte),(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_GET_CHIP:			/* PROTO_GET_CHIP:值0x2c,获取芯片ID和版本信息 */
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* get_mcu_id:读取寄存器DBGMCU_IDCODE值,表示芯片ID和版本 */
			/* cout_word:串口或模拟串口输出1个字的函数,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}
			cout_word(get_mcu_id());
			break;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (9)获取芯片描述信息PROTO_GET_CHIP_DES(0x2e),命令结构PROTO_GET_CHIP_DES+PROTO_EOC */
		/*   * 收到命令PROTO_GET_CHIP后2ms内未收到命令终止字,进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*   * 运行成功,输出芯片描述信息len(4byte)+buffer(len byte),(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_GET_CHIP_DES:			/* PROTO_GET_CHIP_DES:值0x2e,获取芯片的描述信息 */
			/* MAX_DES_LENGTH:值20,芯片描述信息最大长度,定义在bl.c */
			uint8_t buffer[MAX_DES_LENGTH];
			unsigned len = MAX_DES_LENGTH;
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}
			/* get_mcu_desc:返回MCU的型号和版本描述信息,定义在main_f?.c */
			/* cout_word:串口或模拟串口输出1个字的函数,定义在bl.c */
			/* cout:串口(包括USB虚拟串口)输出特定内容的函数,定义在bl.c */
			len = get_mcu_desc(len, buffer);
			cout_word(len);
			cout(buffer, len);
			break;

#ifdef BOOT_DELAY_ADDRESS			/* 对主控FMU,BOOT_DELAY_ADDRESS定义为0x1a0,代码有效,hw_config.h */
									/* 对IO协处理器,BOOT_DELAY_ADDRESS未定义,代码无效 */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (10)设置飞控固件启动延时PROTO_SET_DELAY(0x2d),命令结构:PROTO_SET_DELAY+v(4byte)+PROTO_EOC */
		/*    * 收到PROTO_SET_DELAY后100ms内未收到延时v,或延时时间为负数,进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*    * 取延时v的最低字节为时延boot_delay有效信息(单位s),若此值大于允许最大值BOOT_DELAY_MAX,进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*    * 收到延时v的2ms内未收到命令终止字,进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*    * 读取BOOT_DELAY_ADDRESS起始的显示延时信息有效性的2个关键字,通过与预定的关键字对比,若不一致则进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*    * 根据延时boot_delay和关键字BOOT_DELAY_SIGNATURE1确定需存放在地址BOOT_DELAY_ADDRESS的数据,并写入以更新延时参数 */
		/*    * 再次读取地址BOOT_DELAY_ADDRESS的数据与需写入的数据进行对比,若不一致(写入失败),则进行命令失败处理,回告结构:(PROTO_INSYNC+PROTO_FAILED) */
		/*    * 运行成功,(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_SET_DELAY:			/* PROTO_SET_DELAY:值0x2d,设置飞控固件启动延时 */
			/* cin_wait:在给定的时间内读到串口数据,则返回数据;若超时返回-1,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			int v = cin_wait(100);
			if (v < 0) {
				goto cmd_bad;
			}

			/* 取v的低字节作为时延boot_delay的有效信息(时延最大255s) */
			/* BOOT_DELAY_MAX:值30,飞控固件启动最大时延,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			uint8_t boot_delay = v & 0xFF;
			if (boot_delay > BOOT_DELAY_MAX) {
				goto cmd_bad;
			}

			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (!wait_for_eoc(2)) {
				goto cmd_bad;
			}

			/* 读取BOOT_DELAY_ADDRESS起始的2个字,提取显示延时信息有效性的2个关键字,通过对比来判断信息是否有效 */
			/* BUG?sig1的最低字节是延时参数,不应作为判断依据,这里有问题 */
			/* BOOT_DELAY_ADDRESS:值0x000001a0,飞控固件启动延时信息在flash中的存储地址,仅对主控FMU有效,定义在hw_config.h */
			/* BOOT_DELAY_SIGNATURE1:值0x92c2ecff,飞控固件启动延时信息有效的关键字1,定义在bl.h */
			/* BOOT_DELAY_SIGNATURE2:值0xc5057d5d,飞控固件启动延时信息有效的关键字2,定义在bl.h */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			uint32_t sig1 = flash_func_read_word(BOOT_DELAY_ADDRESS);
			uint32_t sig2 = flash_func_read_word(BOOT_DELAY_ADDRESS + 4);
			if (sig1 != BOOT_DELAY_SIGNATURE1 || sig2 != BOOT_DELAY_SIGNATURE2) {
				goto cmd_bad;
			}

			/* 根据延时boot_delay和关键字BOOT_DELAY_SIGNATURE1确定需存放在地址BOOT_DELAY_ADDRESS的数据,并写入 */
			/* BOOT_DELAY_SIGNATURE1:值0x92c2ecff,飞控固件启动延时信息有效的关键字1,定义在bl.h */
			/* BOOT_DELAY_ADDRESS:值0x000001a0,飞控固件启动延时信息在flash中的存储地址,仅对主控FMU有效,定义在hw_config.h */
			/* flash_func_write_word:烧写flash某地址起始为特定内容,4位烧写,定义在main_f?.c */
			uint32_t value = (BOOT_DELAY_SIGNATURE1 & 0xFFFFFF00) | boot_delay;
			flash_func_write_word(BOOT_DELAY_ADDRESS, value);

			/* 再次读取地址BOOT_DELAY_ADDRESS的数据与需写入的数据进行对比,若不一致则跳转到cmd_fail,运行失败 */
			/* BOOT_DELAY_ADDRESS:值0x000001a0,飞控固件启动延时信息在flash中的存储地址,仅对主控FMU有效,定义在hw_config.h */
			/* flash_func_read_word:读取flash某特定地址内容,4位读取,定义在main_f?.c */
			/* cmd_fail:指令运行错误处理的标号,在bootloader函数末尾 */
			if (flash_func_read_word(BOOT_DELAY_ADDRESS) != value) {
				goto cmd_fail;
			}
		break;
#endif

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (11)完成烧写并启动飞控固件PROTO_BOOT(0x30),命令结构:PROTO_BOOT+PROTO_EOC */
		/*    * 收到启动命令PROTO_BOOT的1s内未收到命令终止字,进行错误指令处理,回告结构:(PROTO_INSYNC+PROTO_INVALID) */
		/*    * 若变量first_word(飞控固件首字保存变量)中有内容 */
		/*         * 烧写飞控固件首字first_word */
		/*         * 读取飞控固件首字并与first_word对比,若不同则进行命令失败处理,回告结构:(PROTO_INSYNC+PROTO_FAILED) */
		/*         * 烧写首字成功,将first_word变量置为无效(0xffffffff) */
		/*    * 运行成功,发送PROTO_INSYNC+PROTO_OK,延时100ms,bootloader函数返回 */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_BOOT:			/* PROTO_BOOT:值0x30,完成烧写并启动飞控固件 */
			/* wait_for_eoc:在给定的时间内,下一条获取到的命令是否为命令终止字PROTO_EOC;若是返回真,不是返回假,定义在bl.c */
			/* cmd_bad:错误命令处理函数的标号,在bootloader函数末尾 */
			if (!wait_for_eoc(1000)) {
				goto cmd_bad;
			}
			/* 若变量first_word内容有效,烧写飞控固件首字并判断是否烧写成功 */
			/* first_word:飞控固件首字保存变量,定义在bootloader函数中 */
			/* flash_func_write_word:烧写flash某地址起始为特定内容,4位烧写,定义在main_f?.c */
			/* flash_func_read_word:读取flash某特定地址内容,4位读取,定义在main_f?.c */
			/* cmd_fail:指令运行错误处理的标号,在bootloader函数末尾 */
			if (first_word != 0xffffffff) {
				flash_func_write_word(0, first_word);
				/* 读取飞控固件首字并与first_word对比,若不同则跳转到cmd_fail,进行命令失败处理 */
				if (flash_func_read_word(0) != first_word) {
					goto cmd_fail;
				}
				/* 将first_word变量置为无效(0xffffffff) */
				first_word = 0xffffffff;
			}
			/* sync_response:发送同步命令函数,表示运行成功,定义在bl.c */
			/* delay:延时函数,定义在bl.c */
			sync_response();
			delay(100);

			// quiesce and jump to the app
			return;

		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* (12)输出调试信息(命令暂未完成)PROTO_DEBUG(0x31),直接按运行成功处理,(发送PROTO_INSYNC+PROTO_OK,变量timeout和bl_type重新赋值,继续新的命令处理) */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		case PROTO_DEBUG:		/* PROTO_DEBUG:值0x31,输出调试信息 */
			break;

		default:
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
		/* 其他命令,直接进入接收新的命令循环 */
		/* ------------------------------------------------------------------------------------------------------------------------------------------------------------ */
			continue;
		}

		/* 4.5 命令处理完毕,运行成功后的处理(变量timeout初始化和bl_type重新赋值,调用sync_response函数发送PROTO_INSYNC+PROTO_OK表示运行成功),继续接收下一条指令。 */
		/* timeout:bootloader跳转到飞控固件所需等待的时间,bootloader函数输入 */
		/* bl_type:静态全局接口类型变量, */
		/* NONE:值0,枚举类,定义在bl.h */
		/* last_input:静态全局变量,上次获取串口数据的方式 */
		/* sync_response:发送同步命令函数,表示运行成功,定义在bl.c */
		timeout = 0;
		if (bl_type == NONE) {
			bl_type = last_input;
		}
		sync_response();
		continue;

cmd_bad:			/* cmd_bad:错误指令处理标号,发送PROTO_INSYNC+PROTO_INVALID,并准备接收下一条指令 */
		/* invalid_response:指令非法的处理函数,发送PROTO_INSYNC+PROTO_INVALID,定义在bl.c */
		invalid_response();
		continue;

cmd_fail:		/* cmd_fail:指令运行失败,发送PROTO_INSYNC+PROTO_FAILED,并准备接收下一条指令 */
		/* failure_response:指令运行失败的处理函数,发送PROTO_INSYNC+PROTO_FAILED,定义在bl.c */
		failure_response();
		continue;

#if defined(TARGET_HW_PX4_FMU_V4)			/* 对主控FMU,宏TARGET_HW_PX4_FMU_V4定义为1,代码有效,Makefile.f4 */
											/* 对IO协处理器,宏TARGET_HW_PX4_FMU_V4未定义,代码无效 */
bad_silicon:		/* bad_silicon:MCU版本错误处理函数的标号,发送PROTO_INSYNC+PROTO_BAD_SILICON_REV,并准备接收下一条指令 */
		/* bad_silicon_response:MCU型号错误处理函数,发送PROTO_INSYNC+PROTO_BAD_SILICON_REV,定义在bl.c */
		bad_silicon_response();
		continue;
#endif
	}
}

8 主控FMU主线程序调用的函数

本节汇总了被主控FMU主线程序(main、jump_to_app和bootloader)调用的函数。

8.1 板载初始化相关函数

板载初始化相关函数包括board_init和反向初始化函数board_deinit,它们分别被main函数和jump_to_app函数调用。

8.1.1 board_init函数

board_init函数主要的功能如下:

  • 赋值board_info.fw_size,确定飞控固件size允许的最大值
  • 初始化USB端口GPIOA9(VBUS)
  • 初始化串口USART2
  • 初始化LED并点亮(B/E,LED701)
  • 使能能耗控制器时钟

main_f4.c

static void board_init(void)
{
	/* 1. 赋值board_info.fw_size,确定飞控固件size允许的最大值*/
	/* 修改fw_size值为APP_SIZE_MAX,宏APP_SIZE_MAX被main_f4.c定义为 BOARD_FLASH_SIZE-(BOOTLOADER_RESERVATION_SIZE+APP_RESERVATION_SIZE) */
	/* BOARD_FLASH_SIZE:被定义在hw_config.h中,BOARD_FLASH_SIZE=_FLASH_KBYTES*1024,_FLASH_KBYTES通过读取地址0x1FFF7A22的低16位寄存器得到,此寄存器值代表以KB为单位的芯片的flash大小,属性只读 */
	/* BOOTLOADER_RESERVATION_SIZE:被定义在main_f4.c中,BOOTLOADER_RESERVATION_SIZE=16*1024,代表16KB(1个sector) */
	/* APP_RESERVATION_SIZE:被定义在hw_config.h中,APP_RESERVATION_SIZE=2*16*1024,代表32KB(2个sector) */
	/* 对于STM32F427VIT6,BOARD_FLASH_SIZE=2048KB,APP_SIZE_MAX=2000KB */
	board_info.fw_size = APP_SIZE_MAX;
#if defined(TARGET_HW_PX4_FMU_V2) || defined(TARGET_HW_PX4_FMU_V4)	/* 定义了宏TARGET_HW_PX4_FMU_V2,因此下列代码有效 */
	/* check_silicon函数自动辨识MCU的版本,默认STM32F427的revision 3返回0,其余返回-1 */
	/* fw_size的值为APP_SIZE_MAX=2000KB,第二项判断语句肯定为假 */
	/* 因此该if语句不为真,fw_size不被重新赋值,其值保持为2000KB */
	if (check_silicon() && board_info.fw_size == (2 * 1024 * 1024) - BOOTLOADER_RESERVATION_SIZE) {
		board_info.fw_size = (1024 * 1024) - BOOTLOADER_RESERVATION_SIZE;
	}
#endif

#if defined(BOARD_POWER_PIN_OUT)		/* 宏BOARD_POWER_PIN_OUT未定义,下列语句无效 */
	/* Configure the Power pins */
	rcc_peripheral_enable_clock(&BOARD_POWER_CLOCK_REGISTER, BOARD_POWER_CLOCK_BIT);
	gpio_mode_setup(BOARD_POWER_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_POWER_PIN_OUT);
	gpio_set_output_options(BOARD_POWER_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, BOARD_POWER_PIN_OUT);
	BOARD_POWER_ON(BOARD_POWER_PORT, BOARD_POWER_PIN_OUT);
#endif

	/* 2. 初始化USB端口GPIOA9(VBUS) */
#if INTERFACE_USB		/* 宏INTERFACE_USB在hw_config.h中被定义为1,下列代码有效 */
	/* RCC_AHB1ENR:寄存器(libopencm3/include/libopencm3/stm32/f4/rcc.h,地址0x40023830) */
	/* RCC_AHB1ENR_IOPAEN:值为1<<0(libopencm3/include/libopencm3/stm32/f4/rcc.h),bit0 */
	/* rcc_peripheral_enable_clock:使能特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* 使能GPIOA的时钟,对应原理图中主控FMU连接USB接口芯片(U302,NUF2042VX6)的3个引脚GPIOA9(VBUS/3.1A),GPIOA11(OTG_FS_DM/3.1B),GPIOA12(OTG_FS_DP/3.1A) */
	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
#endif

	/* 3. 初始化串口USART2 */
#if INTERFACE_USART		/* 宏INTERFACE_USART在hw_config.h中被定义为1,下列代码有效 */
	/* BOARD_USART_PIN_CLOCK_REGISTER:被hw_config.h定义为寄存器RCC_AHB1ENR(libopencm3/include/libopencm3/stm32/f4/rcc.h,地址0x40023830) */
	/* BOARD_USART_PIN_CLOCK_BIT:被hw_config.h定义为RCC_AHB1ENR_IOPDEN(libopencm3/include/libopencm3/stm32/f4/rcc.h),值1<<3,bit3 */
	/* rcc_peripheral_enable_clock:使能特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* 使能GPIOD的时钟,对应原理图中主控FMU串口USART2的4个引脚GPIOD3(FMU-USART2_CTS/2.1B),GPIOD4(FMU-USART2_RTS/2.1B),GPIOD5(FMU-USART2_TX/2.1A),GPIOD6(FMU-USART2_RX/2.1A) */
	rcc_peripheral_enable_clock(&BOARD_USART_PIN_CLOCK_REGISTER, BOARD_USART_PIN_CLOCK_BIT);

	/* BOARD_PORT_USART:被hw_config.h定义为GPIOD,对应寄存器GPIOD_MODER(地址0x40020C00) */
	/* GPIO_MODE_AF:值为0x2(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_PUPD_PULLUP:值为0x1(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* BOARD_PIN_TX:被hw_config.h定义为GPIO5,值1<<5(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* BOARD_PIN_RX:被hw_config.h定义为GPIO6,值1<<6(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* gpio_mode_setup:定义在libopencm3/lib/stm32/common/gpio_common_f0234.c,功能为设置GPIO引脚的功能 */
	/* 设置GPIOD5(USART2-TX)和GPIOD6(USART2-RX)为AF(MODER=GPIO_MODE_AF=10)模式,片内上拉push-pull(PUPDR=GPIO_PUPD_PULLUP=01) */
	gpio_mode_setup(BOARD_PORT_USART, GPIO_MODE_AF, GPIO_PUPD_PULLUP, BOARD_PIN_TX | BOARD_PIN_RX);

	/* BOARD_PORT_USART:被hw_config.h定义为GPIOD,对应寄存器GPIOD_MODER(地址0x40020C00) */
	/* BOARD_PORT_USART_AF:被hw_config.h定义为GPIO_AF7,值0x7 */
	/* BOARD_PIN_TX:被hw_config.h定义为GPIO5,值1<<5(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* BOARD_PIN_RX:被hw_config.h定义为GPIO6,值1<<6(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* gpio_set_af:定义在libopencm3/lib/stm32/common/gpio_common_f0234.c,功能为设置GPIO的具体AF功能 */
	/* 设置GPIOD5(USART2-TX)和GPIOD6(USART2-RX)为USART1~3功能(具体为USART2) */
	gpio_set_af(BOARD_PORT_USART, BOARD_PORT_USART_AF, BOARD_PIN_TX);
	gpio_set_af(BOARD_PORT_USART, BOARD_PORT_USART_AF, BOARD_PIN_RX);

	/* BOARD_USART_CLOCK_REGISTER:被hw_config.h定义为寄存器RCC_APB1ENR(地址0x40023840) */
	/* BOARD_USART_CLOCK_BIT:被hw_config.h定义为RCC_APB1ENR_USART2EN,值1<<17(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* rcc_peripheral_enable_clock:使能特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* 使能USART2的时钟,寄存器RCC_APB1ENR的bit17 */
	rcc_peripheral_enable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif

#if defined(BOARD_FORCE_BL_PIN_IN) && defined(BOARD_FORCE_BL_PIN_OUT)		/* 宏BOARD_FORCE_BL_PIN_IN与BOARD_FORCE_BL_PIN_OUT均未被定义,以下代码无效 */
	/* configure the force BL pins */
	rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT);
	gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN_IN);
	gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT);
	gpio_set_output_options(BOARD_FORCE_BL_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, BOARD_FORCE_BL_PIN_OUT);
#endif

#if defined(BOARD_FORCE_BL_PIN)			/* 宏BOARD_FORCE_BL_PIN未定义,下列代码无效 */
	/* configure the force BL pins */
	rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT);
	gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN);
#endif

	/* 4. 初始化LED并点亮(B/E,LED701) */
	/* RCC_AHB1ENR:寄存器(地址0x40023830) */
	/* BOARD_CLOCK_LEDS:被hw_config.h定义为RCC_AHB1ENR_IOPEEN,值1<<4,bit4 */
	/* rcc_peripheral_enable_clock:使能特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* 使能GPIOE的时钟,对应原理图中主控FMU的LED控制引脚GPIOE12(FMU-LED_AMBER/7.5B),低电平点亮发光二极管LED701 */
	rcc_peripheral_enable_clock(&RCC_AHB1ENR, BOARD_CLOCK_LEDS);

	/* BOARD_PORT_LEDS:被hw_config.h定义为GPIOE,值为GPIOE控制寄存器组起始地址0x40021000 */
	/* GPIO_MODE_OUTPUT:值0x1(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_PUPD_NONE:值0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* BOARD_PIN_LED_BOOTLOADER:被hw_config.h定义为GPIO12,值1<<12(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* BOARD_PIN_LED_ACTIVITY:被hw_config.h定义为0,代表主控FMU无ACT指示灯 */
	/* gpio_mode_setup:定义在libopencm3/lib/stm32/common/gpio_common_f0234.c,功能为设置GPIO引脚的功能 */
	/* 设置GPIOE12(FMU-LED_AMBER/7.5B)为输出模式(MODER=GPIO_MODE_OUTPUT=01),push-pull模式(PUPDR=GPIO_PUPD_NONE=00) */
	gpio_mode_setup(BOARD_PORT_LEDS, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);

	/* BOARD_PORT_LEDS:被hw_config.h定义为GPIOE,值为GPIOE控制寄存器组起始地址0x40021000 */
	/* GPIO_OTYPE_PP:值0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_OSPEED_2MHZ:值0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* BOARD_PIN_LED_BOOTLOADER:被hw_config.h定义为GPIO12,值1<<12(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* BOARD_PIN_LED_ACTIVITY:被hw_config.h定义为0,代表主控FMU无ACT指示灯 */
	/* gpio_set_output_options:定义在libopencm3/lib/stm32/common/gpio_common_f0234.c,功能为设置GPIO的输出模式 */
	/* 设置GPIOE12(FMU-LED_AMBER/7.5B)的输出模式为push-pull(OTYPER=GPIO_OTYPE_PP=0),GPIO时钟为2MHz(OSPEEDR=GPIO_OSPEED_2MHZ=00) */
	gpio_set_output_options(BOARD_PORT_LEDS, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);

	/* BOARD_PORT_LEDS:被hw_config.h定义为GPIOE,值为GPIOE控制寄存器组起始地址0x40021000 */
	/* BOARD_PIN_LED_BOOTLOADER:被hw_config.h定义为GPIO12,值1<<12(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* BOARD_PIN_LED_ACTIVITY:被hw_config.h定义为0,代表主控FMU无ACT指示灯 */
	/* BOARD_LED_ON:被hw_config.h定义为函数gpio_clear(libopencm3/lib/stm32/common/gpio_common_all.c),功能为置某GPIO组中的引脚输出为低电平 */
	/* 设置GPIOE12(FMU-LED_AMBER/7.5B)为低电平,点亮B/E(LED701) */
	BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);

	/* 5. 使能能耗控制器时钟 */
	/* RCC_APB1ENR:寄存器(地址0x40023840) */
	/* RCC_APB1ENR_PWREN:值1<<28(libopencm3/include/libopencm3/stm32/f4/rcc.h),bit28 */
	/* rcc_peripheral_enable_clock:使能特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* 使能电源接口时钟 */
	rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN);
}

8.1.2 board_deinit函数

board_deinit函数用于板载设备的反向初始化:主要的功能如下:

  • 无效化串口USART2
  • 无效化LED时钟引脚
  • 关闭电源接口时钟
  • 恢复AHB1外部时钟为默认值

main_f4.c

void board_deinit(void)
{

#if INTERFACE_USART			/* 宏INTERFACE_USART定义为1,在hw_config.h,下列代码有效 */
	/* 1. 无效化串口USART2 */
	/* 设置USART2的输入输出引脚为输入状态 */
	/* BOARD_PORT_USART:被hw_config.h定义为GPIOD,对应寄存器GPIOD_MODER(地址0x40020C00) */
	/* GPIO_MODE_INPUT:值为0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_PUPD_NONE:值为0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* BOARD_PIN_TX:被hw_config.h定义为GPIO5,值1<<5(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* BOARD_PIN_RX:被hw_config.h定义为GPIO6,值1<<6(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* gpio_mode_setup:定义在libopencm3/lib/stm32/common/gpio_common_f0234.c,功能为设置GPIO引脚的功能 */
	/* 设置GPIOD5(USART2-TX)和GPIOD6(USART2-RX)为输入模式(MODER=GPIO_MODE_INPUT=00),浮动状态(PUPDR=GPIO_PUPD_NONE=00) */
	gpio_mode_setup(BOARD_PORT_USART, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_PIN_TX | BOARD_PIN_RX);

	/* 关闭USART2的时钟 */
	/* BOARD_USART_CLOCK_REGISTER:被hw_config.h定义为寄存器RCC_APB1ENR(地址0x40023840) */
	/* BOARD_USART_CLOCK_BIT:被hw_config.h定义为RCC_APB1ENR_USART2EN,值1<<17(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* rcc_peripheral_disable_clock:关闭特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	rcc_peripheral_disable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif

#if defined(BOARD_FORCE_BL_PIN_IN) && defined(BOARD_FORCE_BL_PIN_OUT)		/* 宏BOARD_FORCE_BL_PIN_IN和BOARD_FORCE_BL_PIN_OUT未定义,下列代码无效 */
	gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT);
	gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_IN);
#endif

#if defined(BOARD_FORCE_BL_PIN)		/* 宏BOARD_FORCE_BL_PIN未定义,下列代码无效 */
	gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN);
#endif

#if defined(BOARD_POWER_PIN_OUT) && defined(BOARD_POWER_PIN_RELEASE)			/* 宏BOARD_POWER_PIN_OUT和BOARD_POWER_PIN_RELEASE未定义,下列代码无效 */
	gpio_mode_setup(BOARD_POWER_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_POWER_PIN);
#endif

	/* 2. 无效化LED时钟引脚(设为输入模式) */
	/* BOARD_PORT_LEDS:被hw_config.h定义为GPIOE,值为GPIOE控制寄存器组起始地址0x40021000 */
	/* GPIO_MODE_INPUT:值为0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* BOARD_PIN_LED_BOOTLOADER:被hw_config.h定义为GPIO12,值1<<12(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* BOARD_PIN_LED_ACTIVITY:被hw_config.h定义为0,代表主控FMU无ACT指示灯 */
	/* BOARD_LED_ON:被hw_config.h定义为函数gpio_clear(libopencm3/lib/stm32/common/gpio_common_all.c),功能为置某GPIO组中的引脚输出为低电平 */
	/* 设置GPIOE12(FMU-LED_AMBER/7.5B)为输入模式(MODER=GPIO_MODE_INPUT=00),浮动模式(PUPDR=GPIO_PUPD_NONE=00) */
	gpio_mode_setup(BOARD_PORT_LEDS, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);

	/* 3. 关闭电源接口时钟 */
	/* RCC_APB1ENR:寄存器(地址0x40023840) */
	/* RCC_APB1ENR_PWREN:值1<<28(libopencm3/include/libopencm3/stm32/f4/rcc.h),bit28 */
	/* rcc_peripheral_disable_clock:关闭特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	rcc_peripheral_disable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN);

	/* 4. 恢复AHB1外部时钟为默认值 */
	/* RCC_AHB1ENR:AHB1外部时钟使能寄存器 */
	RCC_AHB1ENR = 0x00100000; // XXX Magic reset number from STM32F4x reference manual
}

8.2 时钟初始化相关函数

板载初始化相关函数包括clock_init和反向初始化函数clock_deinit,它们分别被main函数和jump_to_app函数调用。

8.2.1 clock_init函数

clock_init函数用到了一个数据结构rcc_clock_scale,它被定义在libopencm3/include/libopencm3/stm32/f4/rcc.h中。


libopencm3/include/libopencm3/stm32/f4/rcc.h

truct rcc_clock_scale {
	uint8_t pllm;				/* 寄存器RCC_PLLCFGR中的PLLM信息(5:0) */
	uint16_t plln;				/* 寄存器RCC_PLLCFGR中的PLLN信息(14:6) */
	uint8_t pllp;				/* 寄存器RCC_PLLCFGR中的PLLP信息(17:16) */
	uint8_t pllq;				/* 寄存器RCC_PLLCFGR中的PLLQ信息(27:24) */
	uint8_t pllr;				/* 仅STM32F446/469包含此项 */
	uint32_t flash_config;		/* flash访问控制,对应寄存器FLASH_ACR */
	uint8_t hpre;				/* 寄存器RCC_CFGR中的HPRE信息(7:4) */
	uint8_t ppre1;				/* 寄存器RCC_CFGR中的PPRE1信息(12:10) */
	uint8_t ppre2;				/* 寄存器RCC_CFGR中的PPRE2信息(15:13) */
	uint8_t power_save;			/* 0:高能耗模式(scale 1,11),1:节能模式(scale 3,01);对应寄存器PWR_CR的VOS信息(15:14) */
	uint32_t ahb_frequency;		/* AHB时钟频率 */
	uint32_t apb1_frequency;		/* APB1时钟频率 */
	uint32_t apb2_frequency;		/* APB2时钟频率 */
};

通过设置数据结构rcc_clock_scale中域的值,可实现如下功能:

  • PLL时钟设置,并选择main PLL作为系统时钟sysclk,fsysclk=fPLL=168MHz,fUSBSDRNG=48MHz
  • AHB、APB1、APB2时钟设置,fAHB=fsysclk=168MHz,fAPB1=42MHz,fAPB2=84MHz
  • 选择高能耗模式(Scale 2 mode)
  • flash访问控制设置,启动Icache和Dcache,并设置等待时间5周期
  • 更新库libopencm3中AHB,APB1,APB2对应的全局变量

main_f4.c

static const struct rcc_clock_scale clock_setup = {
	/* PLL时钟设置 */
	.pllm = OSC_FREQ,							/* PLLM=OSC_FREQ=24(hw_config.h) */
	.plln = 336,									/* PLLN=336 */
	.pllp = 2,									/* PLLP=2 */
	.pllq = 7,									/* PLLQ=7 */
#if defined(STM32F446) || defined(STM32F469)		/* 未定义宏STM32F446和STM32F469,pllr域不初始化 */
	.pllr = 2,
#endif
	/* AHB、APB1、APB2时钟设置 */
	.hpre = RCC_CFGR_HPRE_DIV_NONE,				/* HPRE=RCC_CFGR_HPRE_DIV_NONE=0(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	.ppre1 = RCC_CFGR_PPRE_DIV_4,				/* PPRE1=RCC_CFGR_PPRE_DIV_4=0x5(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	.ppre2 = RCC_CFGR_PPRE_DIV_2,				/* PPRE1=RCC_CFGR_PPRE_DIV_2=0x4(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* 能耗模式 */
	.power_save = 0,								/* VOS=10,默认为11 */
	/* flash访问控制 */
	.flash_config = FLASH_ACR_ICE | FLASH_ACR_DCE | FLASH_ACR_LATENCY_5WS,	/* 寄存器FLASH_ACR的ICEN(9),DCEN(10),LATENCY(3:0) */
	/* 更新APB1、APB2时钟全局变量值 */
	.apb1_frequency = 42000000,					/*  */
	.apb2_frequency = 84000000,
};

/* rcc_clock_setup_hse_3v3:被定义在libopencm3/lib/stm32/f4/rcc.c,用于启动后各系统时钟的初始化、能耗模式配置、flash访问控制 */
/* 1. PLL时钟设置(寄存器RCC_PLLCFGR) */
/* fVCO=fPLLin*(PLLN/PLLM)=24*(336/24)=336MHz,(根据原理图,主控FMU的外部晶振频率为24MHz) */
/* fPLL=fVCO/PLLP=168MHz */
/* fUSBSDRNG=fVCO/PLLQ=48MHz */
/* 2. AHB、APB1、APB2时钟设置(寄存器RCC_CFGR) */
/* fAHB=fsysclk=fPLL=168MHz,域HPRE=0,不分频,系统时钟由调用的rcc_set_sysclk_source函数设置为fPLL */
/* fAPB1=fAHB/4=42MHz,域PPRE1=101,分频倍率为4 */
/* fAPB2=fAHB/2=84MHz,域PPRE2=100,分频倍率为2 */
/* 3. 能耗模式 */
/* 寄存器PWR_CR的域VOS=10,对应Scale 2 mode */
/* 4. flash访问控制 */
/* ICEN=FLASH_ACR_ICE=1,bit9,使能I cache */
/* DCEN=FLASH_ACR_DCE=1,bit10,使能D cache */
/* LATENCY=FLASH_ACR_LATENCY_5WS=0x5,访问等待5周期 */
/* 5. 更新库libopencm3中定义的全局变量rcc_apb1_frequency=apb1_frequency=42000000,rcc_apb2_frequency=apb2_frequency=84000000 */
static inline void clock_init(void)
{
	rcc_clock_setup_hse_3v3(&clock_setup);
}

8.2.2 clock_deinit函数

clock_deinit函数关闭时钟源,将所有内部时钟设置为重启后的初始状态,为飞控固件的运行提供良好的初始环境,主要操作如下:

  • 开启内部高速时钟并等待其稳定
  • 清除所有时钟配置
  • 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统(CSS),此时切换为HSI
  • 恢复PLL配置寄存器为默认值
  • 关闭HSE旁路功能
  • 清除所有时钟中断

void clock_deinit(void)
{
	/* 1. 开启内部高速时钟并等待其稳定 */
	/* RCC_HSI:值4,rcc_osc枚举变量,定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* rcc_osc_on:开启某内部时钟,操作寄存器RCC_CR。rcc_osc_on(RCC_HSI)操作HSION域(bit0),定义在libopencm3/lib/stm32/f4/rcc.c */
	/* rcc_wait_for_osc_ready:等待某内部时钟稳定,读取寄存器RCC_CR。rcc_wait_for_osc_ready(RCC_HSI)读取HSIRDY(bit1),定义在libopencm3/lib/stm32/f4/rcc.c */
	rcc_osc_on(RCC_HSI);
	rcc_wait_for_osc_ready(RCC_HSI);

	/* 2. 清除所有时钟配置 */
	/* RCC_CFGR:时钟配置寄存器寄存器,libopencm3/include/libopencm3/stm32/f4/rcc.h */
	RCC_CFGR = 0x000000;

	/* 3. 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统(CSS),此时切换为HSI */
	/* RCC_HSE:值3,rcc_osc枚举变量,定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* RCC_PLL:值0,rcc_osc枚举变量,定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* rcc_osc_off:关闭某内部时钟,操作寄存器RCC_CR。定义在libopencm3/lib/stm32/f4/rcc.c */
	/* rcc_css_disable:关闭时钟安全系统,操作寄存器RCC_CR的域CSSON(bit19)。定义在libopencm3/lib/stm32/f4/rcc.c */
	/* rcc_osc_off(RCC_HSE)操作HSEON域(bit16),rcc_osc_off(RCC_PLL)操作PLLON域(bit24)。定义在libopencm3/lib/stm32/f4/rcc.c */
	rcc_osc_off(RCC_HSE);
	rcc_osc_off(RCC_PLL);
	rcc_css_disable();

	/* 4. 恢复PLL配置寄存器为默认值 */
	/* RCC_PLLCFGR:RCC PLL配置寄存器 */
	RCC_PLLCFGR = 0x24003010;

	/* 5. 关闭HSE旁路功能 */
	/* RCC_HSE:值3,rcc_osc枚举变量,定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* rcc_osc_bypass_disable:关闭HSE的旁路功能,操作寄存器RCC_CR的HSEBYP域(bit18) */
	rcc_osc_bypass_disable(RCC_HSE);

	/* 6. 清除所有时钟中断 */
	/* RCC_CIR:RCC时钟中断寄存器 */
	RCC_CIR = 0x000000;
}

8.3 RTC备份寄存器操作函数

RTC备份寄存器操作函数board_get_rtc_signature和board_set_rtc_signature这两个函数都被定义在main_f4.c中。这两个函数分别用于获取和设置RTC_BKPxR的第一个32位寄存器(被定义为BOOT_RTC_REG)的值。

这里的源代码中有BUG,未选择时钟源,正确的操作应当是选择HSE并且分频系数为24,确保RTC时钟为1MHz。根据STM32f427芯片手册,访问RTC寄存器(含16个RTC_BKPxR寄存器组)的操作如下:

  • 使能电源接口时钟(此步骤已在board_init函数中操作,这里可以省略):寄存器RCC_APB1ENR的PWREN位(bit28)置1
  • 取消写保护:寄存器PWR_CR的DBP位(bit8)置1,使寄存器RCC_BDCR、RTC寄存器(含RTC_BKPxR)和寄存器PWR_CSR的BRE位可写
  • 选择RTC时钟源(BUG关键点,未选择时钟源):设置寄存器RCC_BDCR的域RTCSEL(9:8)来选择RTC的时钟源(默认00:无,01:LSE,10:LSI,11:HSE+RTCPRE);若选择HSE+RTCPRE,还需设置寄存器RCC_CFGR的域RTCPRE(20:16)来确定分频系数(默认00000:无,00001:无,00010:HSE/2,00011:HSE/3,……,11111:HSE/31)
  • 使能RTC时钟源:寄存器RCC_BDCR的RTCEN位(bit15)置1

经过上述操作就可以访问RTC寄存器了。访问完毕之后,一般需反向操作关闭访问权限。

8.3.1 board_get_rtc_signature函数


main_f4.c

/* BOOT_RTC_REG:定义强制bootloader寄存器,地址为0x40002850,对应16个RTC_BKPxR的第一个32位寄存器,它们不受芯片重启reset影响 */
#define BOOT_RTC_REG		MMIO32(RTC_BASE + 0x50)

static uint32_t board_get_rtc_signature()
{
	/* 1. 修改相关寄存器选项,使BOOT_RTC_REG可以被访问 */
	/* PWR_CR:能耗控制寄存器 */
	/* PWR_CR_DBP:值1<<8(libopencm3/include/libopencm3/stm32/common/pwr_common_all.h) */
	/* 芯片重启后,寄存器RCC_BDCR、RTC备份寄存器(如BOOT_RTC_REG)和寄存器PWR_CSR的BRE位都处于写保护状态,寄存器PWR_CR的bit8置1解除写保护 */
	PWR_CR |= PWR_CR_DBP;
	/* RCC_BDCR:备份域控制寄存器 */
	/* RCC_BDCR_RTCEN:值1<<15(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* 使能RTC时钟,BOOT_RTC_REG可以访问,还未选择时钟源?BUG? */
	RCC_BDCR |= RCC_BDCR_RTCEN;

	/* 2. 读取BOOT_RTC_REG寄存器值 */
	uint32_t result = BOOT_RTC_REG;

	/* 3. 修改寄存器选项,禁止访问BOOT_RTC_REG */
	/* RCC_BDCR:备份域控制寄存器 */
	/* RCC_BDCR_RTCEN:值1<<15(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* 这里应反向关闭RTC时钟,正确代码应该如下。源代码不但没有关闭RTC时钟,还会,BUG? */
	/* RCC_BDCR &= ~RCC_BDCR_RTCEN */
	RCC_BDCR &= RCC_BDCR_RTCEN;
	/* PWR_CR:能耗控制寄存器 */
	/* PWR_CR_DBP:值1<<8(libopencm3/include/libopencm3/stm32/common/pwr_common_all.h) */
	/* 此句为RTC寄存器加上写保护 */
	PWR_CR &= ~PWR_CR_DBP;

	return result;
}

8.3.2 board_set_rtc_signature函数


main_f4.c

static void board_set_rtc_signature(uint32_t sig)
{
	/* 1. 修改相关寄存器选项,使BOOT_RTC_REG可以被访问 */
	/* PWR_CR:能耗控制寄存器 */
	/* PWR_CR_DBP:值1<<8(libopencm3/include/libopencm3/stm32/common/pwr_common_all.h) */
	/* 芯片重启后,寄存器RCC_BDCR、RTC备份寄存器(如BOOT_RTC_REG)和寄存器PWR_CSR的BRE位都处于写保护状态,寄存器PWR_CR的bit8置1解除写保护 */
	PWR_CR |= PWR_CR_DBP;
	/* RCC_BDCR:备份域控制寄存器 */
	/* RCC_BDCR_RTCEN:值1<<15(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* 使能RTC时钟,BOOT_RTC_REG可以访问,还未选择时钟源?BUG? */
	RCC_BDCR |= RCC_BDCR_RTCEN;

	/* 2. 设置BOOT_RTC_REG寄存器值 */
	BOOT_RTC_REG = sig;

	/* 3. 修改寄存器选项,禁止访问BOOT_RTC_REG */
	/* RCC_BDCR:备份域控制寄存器 */
	/* RCC_BDCR_RTCEN:值1<<15(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* 这里应反向关闭RTC时钟,正确代码应该如下。源代码不但没有关闭RTC时钟,还会,BUG? */
	/* RCC_BDCR &= ~RCC_BDCR_RTCEN */
	RCC_BDCR &= RCC_BDCR_RTCEN;
	/* PWR_CR:能耗控制寄存器 */
	/* PWR_CR_DBP:值1<<8(libopencm3/include/libopencm3/stm32/common/pwr_common_all.h) */
	/* 此句为RTC寄存器加上写保护 */
	PWR_CR &= ~PWR_CR_DBP;
}

8.4 flash操作函数

这里的flash操作是针对飞控固件部分flash的。

8.4.1 flash_func_read_word函数

flash_func_read_word函数返回飞控固件flash域内某地址的值,输入的地址值自动加上APP_LOAD_ADDRESS(0x08004000)。


main_f4.c

uint32_t flash_func_read_word(uint32_t address)
{
	/* 若地址非4字节对齐,返回0 */
	if (address & 3) {
		return 0;
	}
	/* 否则返回地址为(address+APP_LOAD_ADDRESS)对应的值,这个地址在飞控固件内 */
	/* APP_LOAD_ADDRESS:值0x08004000,定义在hw_config.h */
	return *(uint32_t *)(address + APP_LOAD_ADDRESS);
}

8.4.2 flash_func_sector_size函数

flash_func_sector_size函数返回MCU的flash在某sector的大小值,若无此sector则返回0。


main_f4.c

/* BOARD_FLASH_SECTORS:STM32F4芯片若片内flash为1M,则Sector数量为11;若不为1M(2M),则Sector数量为23,定义在hw_config.h */
/* flash_sectors:结构体全局变量,表示flash内部各sector的size分布,定义在main_f4.c */
uint32_t flash_func_sector_size(unsigned sector)
{
	if (sector < BOARD_FLASH_SECTORS) {
		return flash_sectors[sector].size;
	}
	return 0;
}


8.4.3 flash_func_erase_sector函数

flash_func_erase_sector函数用于擦除指定的sector。根据当前段中有无有效数据而被擦写,若有就擦写;若无有效数据(全为0xFFFFFFFF),则不用擦写。


void flash_func_erase_sector(unsigned sector)
{
	/* 判定输入参数sector是否合法,若不合法直接返回 */
	/* BOARD_FLASH_SECTORS:STM32F4芯片若片内flash为1M,则Sector数量为11;若不为1M(2M),则Sector数量为23,定义在hw_config.h */
	/* BOARD_FIRST_FLASH_SECTOR_TO_ERASE:值0,定义在hw_config.h */
	if (sector >= BOARD_FLASH_SECTORS || sector < BOARD_FIRST_FLASH_SECTOR_TO_ERASE) {
		return;
	}

	/* 计算当前sector相对于APP_LOAD_ADDRESS(0x08004000)的相对地址(即逻辑地址) */
	/* BOARD_FIRST_FLASH_SECTOR_TO_ERASE:值0,定义在hw_config.h */
	/* flash_func_sector_size:函数返回MCU的flash在某sector的大小值,若无此sector则返回0,定义在main_f4.c */
	uint32_t address = 0;
	for (unsigned i = BOARD_FIRST_FLASH_SECTOR_TO_ERASE; i < sector; i++) {
		address += flash_func_sector_size(i);
	}

	/* 获取当前段的大小,扫描当前段的内容,若存在不为0xffffffff的非空字节,说明本段内容不为空;置blank变量为假,表示本段写入过数据,应被擦写。 */
	/* flash_func_sector_size:函数返回MCU的flash在某sector的大小值,若无此sector则返回0,定义在main_f4.c */
	/* blank:当前段是否为空的标记 */
	unsigned size = flash_func_sector_size(sector);
	bool blank = true;
	/* flash_func_read_word:函数返回飞控固件flash域内某地址的值,输入的地址值自动加上APP_LOAD_ADDRESS(0x08004000),定义在main_f4.c */
	for (unsigned i = 0; i < size; i += sizeof(uint32_t)) {
		if (flash_func_read_word(address + i) != 0xffffffff) {
			blank = false;
			break;
		}
	}

	/* 根据blank的取值进行标记确定是否擦除当前段 */
	/* blank:当前段是否为空的标记 */
	/* FLASH_CR_PROGRAM_X32:值2,表示flash写入的并行度为32位,定义在libopencm3/include/libopencm3/stm32/common/flash_common_f24.h */
	/* flash_erase_sector:擦除某段的库函数,定义在libopencm3/lib/stm32/common/flash_common_f24.c */
	if (!blank) {
		flash_erase_sector(flash_sectors[sector].sector_number, FLASH_CR_PROGRAM_X32);
	}
}

8.4.4 flash_func_write_word函数

flash_func_write_word函数用于编写特定地址的flash,以4字节编写,输入地址自动加上APP_LOAD_ADDRESS(0x08004000)。


main_f4.c

void flash_func_write_word(uint32_t address, uint32_t word)
{
	/* flash_program_word:在某地址编写flash字的库函数,定义在libopencm3/lib/stm32/common/flash_common_f24.c */
	flash_program_word(address + APP_LOAD_ADDRESS, word);
}

8.4.5 flash_func_read_otp函数

flash_func_read_otp函数读取OTP区的一个字,输入地址为相对地址(相对于OTP区基地址)。


main_f4.c

#define OTP_BASE			0x1fff7800		/* OTP区基地址 */
#define OTP_SIZE			512				/* OTP区大小 */

uint32_t flash_func_read_otp(uint32_t address)
{
	/* 若给定地址不是4字节对齐或者超出OTP区的范围,返回0 */
	/* OTP_SIZE:值512,OTP区的大小(byte),定义在main_f4.c */
	/* OTP_BASE:值0x1fff7800,OTP区基地址,定义在main_f4.c */
	if (address & 3) {
		return 0;
	}
	if (address > OTP_SIZE) {
		return 0;
	}
	return *(uint32_t *)(address + OTP_BASE);
}

8.4.6 flash_func_read_sn函数

flash_func_read_sn函数读取MCU的UDID(Unique Device ID)某字(共12byte,3字)。


main_f4.c

#define UDID_START		        0x1FFF7A10		/* UDID_START:UDID寄存器基地址,值0x1FFF7A10,定义在main_f4.c */

uint32_t flash_func_read_sn(uint32_t address)
{
	return *(uint32_t *)(address + UDID_START);
}

8.5 board_test_usart_receiving_break函数

board_test_usart_receiving_break没有使用USART控制器来接收信息,而是使用systick时钟来软件模拟串口的接收。程序看起来复杂,实质非常简单。它的功能就是:连续接收3个字节的内容,如果收到一个0字节则返回真,否则返回假。break字符为字节0。


main_f4.c

static bool board_test_usart_receiving_break()
{
#if !defined(SERIAL_BREAK_DETECT_DISABLED)		/* 宏SERIAL_BREAK_DETECT_DISABLED未定义,下列代码有效 */
	/* 启动systick定时器 */
	systick_interrupt_disable();		/* 关闭systick中断(libopencm3/lib/cm3/systick.c) */
	systick_counter_disable();		/* systick倒计时关闭(libopencm3/lib/cm3/systick.c) */
	systick_set_clocksource(STK_CSR_CLKSOURCE_AHB);		/* 选取AHB作为systick的时钟源,STK_CSR_CLKSOURCE_AHB=1<<2(libopencm3/include/libopencm3/cm3/systick.h) */

	/* board_info.systick_mhz:值168,定义在main_f4.c */
	/* USART_BAUDRATE:值115200,定义在hw_config.h */
	/* 设置systick时钟倒计时(寄存器STK_VAL)约为729,为串口波特率的一半 */
	systick_set_reload(((board_info.systick_mhz * 1000000) / USART_BAUDRATE) >> 1);
	systick_counter_enable();		/* systick倒计时开启(libopencm3/lib/cm3/systick.c) */

	uint8_t cnt_consecutive_low = 0;
	uint8_t cnt = 0;

	/* 检测连续3个字节,若有1个字节值为0,则跳出循环。每个传播周期包含10位(1起始+8数据+1停止)。 */
	while (cnt < 60) {
		/* BOARD_PORT_USART:值GPIOD,定义在hw_config.h */
		/* BOARD_PIN_RX:值GPIO6,定义在hw_config.h */
		/* systick_get_countflag:定义在libopencm3/lib/cm3/systick.c,当systick倒计时为0时返回1,否则返回0。库中定义的寄存器STK_CSR即为寄存器STK_CTRL */
		/* gpio_get:定义在libopencm3/lib/stm32/common/gpio_common_all.c,功能为获取某GPIO组的值 */
		if (systick_get_countflag() == 1) {
			if (gpio_get(BOARD_PORT_USART, BOARD_PIN_RX) == 0) {
				cnt_consecutive_low++;	// Increment the consecutive low counter
			} else {
				cnt_consecutive_low = 0; // Reset the consecutive low counter
			}
			cnt++;
		}
		// 若连续收到9个低电平(1起始+8数据),即一个字节0,则跳出循环
		if (cnt_consecutive_low >= 18) {
			break;
		}
	}

	systick_counter_disable();		/* systick倒计时关闭(libopencm3/lib/cm3/systick.c) */

	/* 如果检测到9个低电平(1起始+8数据),则返回真,否则返回假 */
	if (cnt_consecutive_low >= 18) {
		return true;
	}
#endif // !defined(SERIAL_BREAK_DETECT_DISABLED)

	return false;
}

8.6 LED操作函数

LED操作函数包含点亮led_on、熄灭led_off和反向led_toggle三个函数。

8.6.1 led_on函数


main_f4.c

void led_on(unsigned led)
{
	/* LED_ACTIVITY:值1,定义在bl.h */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* BOARD_PORT_LEDS:值GPIOE(指向GPIOE首寄存器),定义在hw_config.h */
	/* BOARD_PIN_LED_ACTIVITY:值0,无此LED,定义在hw_config.h */
	/* BOARD_PIN_LED_BOOTLOADER:值GPIO12(1<<12),定义在hw_config.h */
	/* BOARD_LED_ON:被hw_config.h定义为gpio_clear函数,功能为置某GPIO组中的引脚输出为低电平(libopencm3/lib/stm32/common/gpio_common_all.c) */
	switch (led) {
	case LED_ACTIVITY:
		BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
		break;
	case LED_BOOTLOADER:
		BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
		break;
	}
}

8.6.2 led_off函数


main_f4.c

void led_off(unsigned led)
{
	/* LED_ACTIVITY:值1,定义在bl.h */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* BOARD_PORT_LEDS:值GPIOE(指向GPIOE首寄存器),定义在hw_config.h */
	/* BOARD_PIN_LED_ACTIVITY:值0,无此LED,定义在hw_config.h */
	/* BOARD_PIN_LED_BOOTLOADER:值GPIO12(1<<12),定义在hw_config.h */
	/* BOARD_LED_OFF:被hw_config.h定义为gpio_set函数,功能为置某GPIO组中的引脚输出为高电平(libopencm3/lib/stm32/common/gpio_common_all.c) */
	switch (led) {
	case LED_ACTIVITY:
		BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
		break;
	case LED_BOOTLOADER:
		BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
		break;
	}
}

8.6.3 led_toggle函数


main_f4.c

	/* LED_ACTIVITY:值1,定义在bl.h */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* BOARD_PORT_LEDS:值GPIOE(指向GPIOE首寄存器),定义在hw_config.h */
	/* BOARD_PIN_LED_ACTIVITY:值0,无此LED,定义在hw_config.h */
	/* BOARD_PIN_LED_BOOTLOADER:值GPIO12(1<<12),定义在hw_config.h */
	/* gpio_toggle:反向函数,定义在libopencm3/lib/stm32/common/gpio_common_all.c */
void led_toggle(unsigned led)
{
	switch (led) {
	case LED_ACTIVITY:
		gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
		break;
	case LED_BOOTLOADER:
		gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
		break;
	}
}

8.7 获取芯片信息函数

获取芯片信息函数包括:get_mcu_id函数取包含芯片ID和版本的寄存器DBGMCU_IDCODE值,get_mcu_desc函数返回MCU的型号和版本描述信息。

8.7.1 get_mcu_id函数

get_mcu_id函数读取包含芯片ID和版本的寄存器DBGMCU_IDCODE值。


main_f4.c

#define DBGMCU_IDCODE		0xE0042000		/* DBGMCU_IDCODE,寄存器,存放芯片ID和版本信息 */

uint32_t get_mcu_id(void)
{
	return *(uint32_t *)DBGMCU_IDCODE;
}

8.7.2 get_mcu_desc函数

get_mcu_desc函数返回MCU的型号和版本描述信息。


main_f4.c

#define DBGMCU_IDCODE		0xE0042000		/* DBGMCU_IDCODE,寄存器,存放芯片ID和版本信息 */
#define DEVID_MASK			0xFFF			/* MCU的ID存放在DBGMCU_IDCODE寄存器的低12位 */
#define STM32_UNKNOWN		0				/* 未知芯片描述的index */

int get_mcu_desc(int max, uint8_t *revstr)
{
	/* 获取MCU的ID和版本,分别存放在变量mcuid和revid中 */
	uint32_t idcode = (*(uint32_t *)DBGMCU_IDCODE);
	int32_t mcuid = idcode & DEVID_MASK;
	mcu_rev_e revid = (idcode & REVID_MASK) >> 16;

	/* 初始化MCU描述信息为未知 */
	mcu_des_t des = mcu_descriptions[STM32_UNKNOWN];

	/* 根据mcuid依次查找数组mcu_descriptions中匹配项,若匹配则找到该MCU的型号描述 */
	/* mcu_descriptions:mcu_des_t型数组,用于存放MCU的型号描述信息,定义在main_f4.c */
	/* arraySize:以宏形式定义的函数,用于计算数组的成员个数,定义在bl.h */
	for (int i = 0; i < arraySize(mcu_descriptions); i++) {
		if (mcuid == mcu_descriptions[i].mcuid) {
			des = mcu_descriptions[i];
			break;
		}
	}

	/* 根据revid依次查找数组mcu_descriptions中匹配项,若匹配则找到该MCU的版本 */
	/* silicon_revs:mcu_rev_t型数组,用于存放MCU版本信息,定义在main_f4.c */
	/* arraySize:以宏形式定义的函数,用于计算数组的成员个数,定义在bl.h */
	for (int i = 0; i < arraySize(silicon_revs); i++) {
		if (silicon_revs[i].revid == revid) {
			des.rev = silicon_revs[i].rev;
		}
	}

	/* 按位字符操作,将MCU的描述和版本信息存储到缓冲区,中间用“,”隔开 */
	uint8_t *endp = &revstr[max - 1];
	uint8_t *strp = revstr;
	while (strp < endp && *des.desc) {
		*strp++ = *des.desc++;
	}
	if (strp < endp) {
		*strp++ = ',';
	}
	if (strp < endp) {
		*strp++ = des.rev;
	}
	return  strp - revstr;
}

8.8 check_silicon函数

check_silicon函数自动辨识运新的MCU版本是否为FIRST_BAD_SILICON_OFFSET序号以后的silicon_revs(mcu_rev_t型结构体数组)成员。在不改变代码的情况下,STM32F427型芯片REV_ID为0x2001时(Revision 3)返回0,其余均返回-1。


main_f4.c

int check_silicon(void)
{
#if defined(TARGET_HW_PX4_FMU_V2) || defined(TARGET_HW_PX4_FMU_V4)		/* 定义了宏TARGET_HW_PX4_FMU_V2,因此下列代码有效,将被编译。 */
	/* 宏DBGMCU_IDCODE被定义在main_f4.c中,代表地址为0xE0042000的寄存器。变量idcode包含信息REV_ID(31:16)和DEV_ID(11:0) */
	uint32_t idcode = (*(uint32_t *)DBGMCU_IDCODE);
	/* 宏REVID_MASK被定义在main_f4.c中,值为0xFFFF0000。变量revid为REV_ID的值 */
	mcu_rev_e revid = (idcode & REVID_MASK) >> 16;

	/* 宏FIRST_BAD_SILICON_OFFSET被main_f4.c定义为1,代表第1块sector(从0开始编号) */
	/* 变量silicon_revs为mcu_rev_t型结构体数组,存储MCU版本号与其代码的对应信息 */
	/* 以宏形式定义的函数arraySize()在bl.h中,其功能为求解数组的成员个数 */
	/* 此循环的功能是,若使用自FIRST_BAD_SILICON_OFFSET序号以后的MCU版本(REV_ID),则函数返回-1,否则返回0 */
	for (int i = FIRST_BAD_SILICON_OFFSET; i < arraySize(silicon_revs); i++) {
		if (silicon_revs[i].revid == revid) {
			return -1;
		}
	}
#endif
	return 0;
}

9 IO协处理器主线流程调用的函数

本节汇总了被主控FMU主线程序(main、jump_to_app和bootloader)调用的函数。

9.1 板载初始化相关函数

板载初始化相关函数包括board_init和反向初始化函数board_deinit,它们分别被main函数和jump_to_app函数调用。

9.1.1 board_init函数

board_init函数主要的功能如下:

  • 初始化LED控制并点亮LED灯
  • 设置强制Bootloader引脚GPIOB5为浮动输入模式,方便采集安全开关的状态
  • 使能能源接口时钟和备份接口时钟,准备备份寄存器
  • 设置USART2-TX引脚GPIOA2,对应原理图SERIAL_IO_TO_FMU,用于IO协处理器发送信息到主控FMU

main_f1.c

static void board_init(void)
{
	/* 1. 初始化LED控制并点亮LED灯 */
	/* 根据原理图,GPIOB14(IO-LED_BLUE)和GPIOB15(IO-LED_AMBER)分别控制IO协处理器的B/E(LED703)和ACT(LED705),低电平有效 */
	/* BOARD_CLOCK_LEDS_REGISTER:被定义为寄存器RCC_APB2ENR,hw_config.h */
	/* BOARD_CLOCK_LEDS:被hw_config.h定义为RCC_APB2ENR_IOPBEN,值1<<3(bit3),定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* BOARD_PORT_LEDS:被定义为GPIOB(GPIOB寄存器首地址0x40010C00),hw_config.h */
	/* GPIO_MODE_OUTPUT_50_MHZ:值0x03,定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* GPIO_CNF_OUTPUT_PUSHPULL:值0x00,定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_PIN_LED_BOOTLOADER:被定义为GPIO15,值1<<15,定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
	/* BOARD_PIN_LED_ACTIVITY:被定义为GPIO14,值1<<14,定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
	/* rcc_peripheral_enable_clock:使能外部特定时钟,定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* gpio_set_mode:设置GPIO引脚工作模式,定义在libopencm3/lib/stm32/f1/gpio.c */
	/* BOARD_LED_ON:被hw_config.h定义为gpio_clear(libopencm3/lib/stm32/common/gpio_common_all.c) */
	/* 第一行,启动GPIOB时钟,通过操作RCC_APB2ENR寄存器的域IOPBEN(bit3) */
	/* 第二行,设置GPIOB14和GPIOB15为最大频率50MHz输出(MODE=GPIO_MODE_OUTPUT_50_MHZ=11),push-pull模式(CNF=GPIO_CNF_OUTPUT_PUSHPULL=00) */
	/* 第三行,设置GPIOB13和GPIOB15为低电平,点亮两个LED灯 */
	rcc_peripheral_enable_clock(&BOARD_CLOCK_LEDS_REGISTER, BOARD_CLOCK_LEDS);
	gpio_set_mode(BOARD_PORT_LEDS, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);
	BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);

	/* if we have one, enable the force-bootloader pin */
#ifdef BOARD_FORCE_BL_PIN		/* 宏BOARD_FORCE_BL_PIN有定义,代码有效 */
	/* 2. 设置强制Bootloader引脚GPIOB5为浮动输入模式,方便采集安全开关的状态 */
	/* 根据原理图,GPIOB5(IO-LED_SAFETY)连接安全开关,程序默认设置为高电平。采集到安全开关闭合(电平拉低)有效 */
	/* BOARD_FORCE_BL_CLOCK_REGISTER:被定义为寄存器RCC_APB2ENR,hw_config.h */
	/* BOARD_FORCE_BL_CLOCK_BIT:被hw_config.h定义为RCC_APB2ENR_IOPBEN,值1<<3(bit3),定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* BOARD_FORCE_BL_PORT:被定义为GPIOB(GPIOB寄存器首地址0x40010C00),hw_config.h */
	/* BOARD_FORCE_BL_PIN:被定义为GPIO5,值1<<5,定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
	/* GPIO_MODE_INPUT:值0x00,libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_FORCE_BL_PULL:被hw_config.h定义为GPIO_CNF_INPUT_FLOAT,值0x01,定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* rcc_peripheral_enable_clock:使能外部特定时钟,定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* gpio_set:设置GPIO引脚电平,置1(set位),定义在libopencm3/lib/stm32/common/gpio_common_all.c */
	/* gpio_set_mode:设置GPIO引脚工作模式,libopencm3/lib/stm32/f1/gpio.c */
	/* 第一行,启动GPIOB时钟,通过操作RCC_APB2ENR寄存器的域IOPBEN(bit3) */
	/* 第二行,设置GPIOB5(IO-LED_SAFETY)为高电平 */
	/* 第三行,设置GPIOB5(IO-LED_SAFETY)为输入模式(MODE=GPIO_MODE_INPUT=00),浮动模式(CNF=BOARD_FORCE_BL_PULL=01) */
	rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT);
	gpio_set(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN);
	gpio_set_mode(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN);
#endif

	/* 3. 使能能源接口时钟和备份接口时钟,准备备份寄存器 */
	/* RCC_APB1ENR:APB1寄存器,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* RCC_APB1ENR_PWREN:值1<<28,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* RCC_APB1ENR_BKPEN:值1<<27,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* rcc_peripheral_enable_clock:使能外部特定时钟,定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN);

#ifdef INTERFACE_USART			/* 宏INTERFACE_USART定义为USART2,hw_config.h,代码有效 */
	/* 4. 设置USART2-TX引脚GPIOA2,对应原理图SERIAL_IO_TO_FMU,用于IO协处理器发送信息到主控FMU */
	/* BOARD_USART_PIN_CLOCK_REGISTER:被定义为寄存器RCC_APB2ENR,hw_config.h */
	/* BOARD_USART_PIN_CLOCK_BIT:被hw_config.h定义为RCC_APB2ENR_IOPAEN,值1<<2(bit2,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h) */
	/* BOARD_PORT_USART:被定义为GPIOA(GPIOA寄存器首地址0x40010800),hw_config.h */
	/* GPIO_MODE_OUTPUT_50_MHZ:值0x03,定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* GPIO_CNF_OUTPUT_ALTFN_PUSHPULL:值0x02,定义在libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_PIN_TX:被hw_config.h定义为GPIO_USART2_TX,值GPIO2(1<<2),libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_USART_CLOCK_REGISTER:被定义为寄存器RCC_APB1ENR,hw_config.h */
	/* BOARD_USART_CLOCK_BIT:被hw_config.h定义为RCC_APB1ENR_USART2EN,值1<<17,libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* rcc_peripheral_enable_clock:使能外部特定时钟,定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* gpio_set_mode:设置GPIO引脚工作模式,libopencm3/lib/stm32/f1/gpio.c */
	/* 第一行,使能USART2所在的GPIOA时钟 */
	/* 第二行,设置USART2的发送引脚GPIOA2为50MHz输出模式(MODE=GPIO_MODE_OUTPUT_50_MHZ=11),特殊功能push-pull模式(CNF=GPIO_CNF_OUTPUT_ALTFN_PUSHPULL=10) */
	/* 第三行,重置USART2时钟 */
	rcc_peripheral_enable_clock(&BOARD_USART_PIN_CLOCK_REGISTER, BOARD_USART_PIN_CLOCK_BIT);
	gpio_set_mode(BOARD_PORT_USART, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, BOARD_PIN_TX);
	rcc_peripheral_enable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif
#ifdef INTERFACE_I2C			/* 宏INTERFACE_I2C未定义,代码无效 */
# error I2C GPIO config not handled yet
#endif
}

9.1.2 board_deinit函数

board_deinit函数用于板载设备的反向初始化,主要的功能如下:

  • 无效化LED控制引脚GPIOB14和GPIOB15
  • 无效化强制Bootloader引脚GPIOB5
  • 关闭能源接口时钟和备份接口时钟,不可访问备份寄存器
  • 无效化USART2-TX引脚GPIOA2
  • 设置APB2寄存器为默认值,关闭所有外部时钟

main_f1.c

void board_deinit(void)
{
	/* 1. 无效化LED控制引脚GPIOB14和GPIOB15 */
	/* 根据原理图,GPIOB14(IO-LED_BLUE)和GPIOB15(IO-LED_AMBER)分别控制IO协处理器的B/E(LED703)和ACT(LED705),低电平有效 */
	/* BOARD_PORT_LEDS:被定义为GPIOB(GPIOB寄存器首地址0x40010C00),hw_config.h */
	/* GPIO_MODE_INPUT:值0x00,libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* GPIO_CNF_INPUT_FLOAT:值0x01,libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_PIN_LED_BOOTLOADER:被定义为GPIO15,值1<<15,定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
	/* BOARD_PIN_LED_ACTIVITY:被定义为GPIO14,值1<<14,定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
	/* gpio_set_mode:设置GPIO引脚工作模式,定义在libopencm3/lib/stm32/f1/gpio.c */
	/* 设置GPIOB14和GPIOB15为输入模式(MODE=GPIO_MODE_INPUT=00),浮动模式(CNF=GPIO_CNF_INPUT_FLOAT=01) */
	gpio_set_mode(BOARD_PORT_LEDS, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY);

#ifdef BOARD_FORCE_BL_PIN		/* 宏BOARD_FORCE_BL_PIN定义为GPIO5,代码有效,hw_config.h */
	/* 2. 无效化强制Bootloader引脚GPIOB5 */
	/* BOARD_FORCE_BL_PORT:被定义为GPIOB(GPIOB寄存器首地址0x40010C00),hw_config.h */
	/* GPIO_MODE_INPUT:值0x00,libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* GPIO_CNF_INPUT_FLOAT:值0x01,libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_FORCE_BL_PIN:被定义为GPIO5,值1<<5,定义在libopencm3/include/libopencm3/stm32/common/gpio_common_all.h */
	/* gpio_set_mode:设置GPIO引脚工作模式,libopencm3/lib/stm32/f1/gpio.c */
	/* gpio_clear:设置GPIO引脚电平,清0(reset位),定义在libopencm3/lib/stm32/common/gpio_common_all.c */
	/* 第一行,设置GPIOB5(IO-LED_SAFETY)为输入模式(MODE=GPIO_MODE_INPUT=00),浮动模式(CNF=BOARD_FORCE_BL_PULL=01) */
	/* 第二行,设置GPIOB5(IO-LED_SAFETY)为低电平 */
	gpio_set_mode(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_FORCE_BL_PIN);
	gpio_clear(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN);
#endif

	/* 3. 关闭能源接口时钟和备份接口时钟,不可访问备份寄存器 */
	/* RCC_APB1ENR:APB1寄存器,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* RCC_APB1ENR_PWREN:值1<<28,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* RCC_APB1ENR_BKPEN:值1<<27,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* rcc_peripheral_enable_clock:使能外部特定时钟,定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	rcc_peripheral_disable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN);

#ifdef INTERFACE_USART		/* 宏INTERFACE_USART定义为1,代码有效 */
	/* 4. 无效化USART2-TX引脚GPIOA2 */
	/* BOARD_PORT_USART:被定义为GPIOA(GPIOA寄存器首地址0x40010800),hw_config.h */
	/* GPIO_MODE_INPUT:值0x00,libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* GPIO_CNF_INPUT_FLOAT:值0x01,libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_PIN_TX:被hw_config.h定义为GPIO_USART2_TX,值GPIO2(1<<2),libopencm3/include/libopencm3/stm32/f1/gpio.h */
	/* BOARD_USART_CLOCK_REGISTER:被定义为寄存器RCC_APB1ENR,hw_config.h */
	/* BOARD_USART_CLOCK_BIT:被hw_config.h定义为RCC_APB1ENR_USART2EN,值1<<17,libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* rcc_peripheral_enable_clock:使能外部特定时钟,定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* gpio_set_mode:设置GPIO引脚工作模式,libopencm3/lib/stm32/f1/gpio.c */
	/* 第一行,设置USART2的发送引脚GPIOA2为输入(MODE=GPIO_MODE_INPUT=00),浮动模式(CNF=GPIO_CNF_INPUT_FLOAT=01) */
	/* 第二行,关闭USART2时钟 */
	gpio_set_mode(BOARD_PORT_USART, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BOARD_PIN_TX);
	rcc_peripheral_disable_clock(&BOARD_USART_CLOCK_REGISTER, BOARD_USART_CLOCK_BIT);
#endif

#ifdef INTERFACE_I2C			/* 宏INTERFACE_I2C未定义,代码无效 */
# error I2C GPIO config not handled yet
#endif

	/* 5. 设置APB2寄存器为默认值,关闭所有外部时钟 */
	/* RCC_APB2ENR:寄存器,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	RCC_APB2ENR = 0x00000000; // XXX Magic reset number from STM32F1x reference manual
}

9.2 时钟初始化相关函数

板载初始化相关函数包括clock_init和反向初始化函数clock_deinit,它们分别被main函数和jump_to_app函数调用。

9.2.1 clock_init函数

clock_init函数调用库函数,使用HSI将MCU的系统时钟为PLL,频率48MHz(BUG?应该设置为24MHz,对应board_info.systick_mhz)。


main_f1.c

static inline void clock_init(void)
{
#if defined(INTERFACE_USB)		/* 宏INTERFACE_USB定义为0,代码有效 */
	/* rcc_clock_setup_in_hsi_out_48mhz:使用HSI设置MCU的系统时钟为PLL,48MHz,定义在libopencm3/lib/stm32/f1/rcc.c */
	rcc_clock_setup_in_hsi_out_48mhz();
#else
	rcc_clock_setup_in_hsi_out_24mhz();
#endif
}

9.2.2 clock_deinit函数

clock_deinit函数关闭时钟源,将所有内部时钟设置为重启后的初始状态,为飞控固件的运行提供良好的初始环境,主要操作如下:

  • 使能HSI时钟
  • 重置寄存器RCC_CFGR,清空时钟配置
  • 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统(CSS),此时切换为HSI
  • 关闭HSE旁路功能
  • 清除所有时钟中断

main_f1.c

void clock_deinit(void)
{
	/* 1. 使能HSI时钟 */
	/* RCC_HSI:值4,rcc_osc枚举型,libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* rcc_osc_on:开启某内部时钟,操作寄存器RCC_CR。rcc_osc_on(RCC_HSI)操作HSION域(bit0),定义在libopencm3/lib/stm32/f1/rcc.c */
	/* rcc_wait_for_osc_ready:等待某内部时钟稳定,读取寄存器RCC_CR。rcc_wait_for_osc_ready(RCC_HSI)读取HSIRDY(bit1),定义在libopencm3/lib/stm32/f1/rcc.c */
	rcc_osc_on(RCC_HSI);
	rcc_wait_for_osc_ready(RCC_HSI);

	/* 2. 重置寄存器RCC_CFGR,清空时钟配置 */
	/* RCC_CFGR:寄存器,libopencm3/include/libopencm3/stm32/f1/rcc.h */
	RCC_CFGR = 0x000000;

	/* 3. 关闭时钟HSE、PLL、PLLI2S、PLLSAI并关闭时钟安全系统(CSS),此时切换为HSI */
	/* RCC_HSE:值3,rcc_osc枚举变量,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* RCC_PLL:值0,rcc_osc枚举变量,定义在libopencm3/include/libopencm3/stm32/f1/rcc.h */
	/* rcc_osc_off:关闭某内部时钟,操作寄存器RCC_CR。定义在libopencm3/lib/stm32/f1/rcc.c */
	/* rcc_css_disable:关闭时钟安全系统,操作寄存器RCC_CR的域CSSON(bit19)。定义在libopencm3/lib/stm32/f1/rcc.c */
	/* rcc_osc_off(RCC_HSE)操作HSEON域(bit16),rcc_osc_off(RCC_PLL)操作PLLON域(bit24)。定义在libopencm3/lib/stm32/f1/rcc.c */
	/* Stop the HSE, CSS, PLL, PLLI2S, PLLSAI */
	rcc_osc_off(RCC_HSE);
	rcc_osc_off(RCC_PLL);
	rcc_css_disable();

	/* 4. 关闭HSE旁路功能 */
	/* RCC_HSE:值3,rcc_osc枚举变量,定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* rcc_osc_bypass_disable:关闭HSE的旁路功能,操作寄存器RCC_CR的HSEBYP域(bit18) */
	rcc_osc_bypass_disable(RCC_HSE);

	/* 5. 清除所有时钟中断 */
	/* RCC_CIR:RCC时钟中断寄存器 */
	RCC_CIR = 0x000000;
}

9.3 LED操作函数

LED操作函数包含点亮led_on、熄灭led_off和反向led_toggle三个函数。

9.3.1 led_on函数


main_f1.c

void led_on(unsigned led)
{
	/* LED_ACTIVITY:值1,定义在bl.h */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* BOARD_PORT_LEDS:值GPIOB(指向GPIOB首寄存器),定义在hw_config.h */
	/* BOARD_PIN_LED_ACTIVITY:值GPIO14(1<<14),定义在hw_config.h */
	/* BOARD_PIN_LED_BOOTLOADER:值GPIO12(1<<15),定义在hw_config.h */
	/* BOARD_LED_ON:被hw_config.h定义为gpio_clear函数,功能为置某GPIO组中的引脚输出为低电平(libopencm3/lib/stm32/common/gpio_common_all.c) */
	switch (led) {
	case LED_ACTIVITY:
		BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
		break;
	case LED_BOOTLOADER:
		BOARD_LED_ON(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
		break;
	}
}

9.3.2 led_off函数


main_f1.c

void led_off(unsigned led)
{
	/* LED_ACTIVITY:值1,定义在bl.h */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* BOARD_PORT_LEDS:值GPIOB(指向GPIOB首寄存器),定义在hw_config.h */
	/* BOARD_PIN_LED_ACTIVITY:值GPIO14(1<<14),定义在hw_config.h */
	/* BOARD_PIN_LED_BOOTLOADER:值GPIO12(1<<15),定义在hw_config.h */
	/* BOARD_LED_OFF:被hw_config.h定义为gpio_set函数,功能为置某GPIO组中的引脚输出为高电平(libopencm3/lib/stm32/common/gpio_common_all.c) */
	switch (led) {
	case LED_ACTIVITY:
		BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
		break;
	case LED_BOOTLOADER:
		BOARD_LED_OFF(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
		break;
	}
}

9.3.3 led_off函数


void led_toggle(unsigned led)
{
	/* LED_ACTIVITY:值1,定义在bl.h */
	/* LED_BOOTLOADER:值2,定义在bl.h */
	/* BOARD_PORT_LEDS:值GPIOB(指向GPIOB首寄存器),定义在hw_config.h */
	/* BOARD_PIN_LED_ACTIVITY:值GPIO14(1<<14),定义在hw_config.h */
	/* BOARD_PIN_LED_BOOTLOADER:值GPIO12(1<<15),定义在hw_config.h */
	/* gpio_toggle:反向函数,定义在libopencm3/lib/sam/common/gpio_common_all.c */
	switch (led) {
	case LED_ACTIVITY:
		gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_ACTIVITY);
		break;
	case LED_BOOTLOADER:
		gpio_toggle(BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER);
		break;
	}
}

9.4 flash操作函数

这里的flash操作是针对飞控固件部分flash的。

9.4.1 flash_func_read_word函数

flash_func_read_word函数返回飞控固件flash域内某地址的值,输入的地址值需加上APP_LOAD_ADDRESS(0x08001000)。


main_f1.c

uint32_t flash_func_read_word(uint32_t address)
{
	/* APP_LOAD_ADDRESS:值0x08001000,定义在hw_config.h */
	return *(uint32_t *)(address + APP_LOAD_ADDRESS);
}

9.4.2 flash_func_sector_size函数

flash_func_sector_size函数返回MCU的flash在某sector的大小值,若无此sector,则返回0。对于STM32F1芯片,片内以页计算,无sector概念,故这里的sector表示页。


main_f1.c

/* BOARD_FLASH_SECTORS:STM32F1片内flash页数,Bootloader认为片内flash的前60页有效,定义在hw_config.h */
/* FLASH_SECTOR_SIZE:STM32F1片内flash每页大小为1KB,定义在hw_config.h */
uint32_t flash_func_sector_size(unsigned sector)
{
	if (sector < BOARD_FLASH_SECTORS) {
		return FLASH_SECTOR_SIZE;
	}
	return 0;
}


9.4.3 flash_func_erase_sector函数

flash_func_erase_sector函数擦除当前页。


main_f1.c

void flash_func_erase_sector(unsigned sector)
{
	/* BOARD_FLASH_SECTORS:值60,表示MCU中flash的页数,定义在hw_config.h */
	/* APP_LOAD_ADDRESS:值0x08001000,表示飞控固件起始地址,定义在hw_config.h */
	/* FLASH_SECTOR_SIZE:值0x400,表示MCU中每页flash的大小均为1KB,定义在hw_config.h */
	/* flash_erase_page:库函数擦写当前地址所在的页,定义在libopencm3/lib/stm32/f1/flash.c */
	if (sector < BOARD_FLASH_SECTORS) {
		flash_erase_page(APP_LOAD_ADDRESS + (sector * FLASH_SECTOR_SIZE));
	}
}

9.4.4 flash_func_write_word函数

flash_func_write_word函数用于编写特定地址的flash,以4字节编写,输入地址自动加上APP_LOAD_ADDRESS(0x08004000)。


main_f1.c

void flash_func_write_word(uint32_t address, uint32_t word)
{
	/* flash_program_word:在某地址编写flash字的库函数,定义在libopencm3/lib/stm32/common/flash_common_f01.c */
	flash_program_word(address + APP_LOAD_ADDRESS, word);
}

9.4.5 flash_func_read_otp函数

STM32F1芯片无OTP区,函数直接返回0。


main_f1.c

uint32_t flash_func_read_otp(uint32_t address)
{
	return 0;
}

9.4.6 flash_func_read_sn函数

flash_func_read_sn函数读取MCU的UDID(Unique Device ID)某字(共12byte,3字)。


main_f1.c

#define UDID_START      0x1FFFF7E8		/* UDID_START:UDID寄存器基地址,值0x1FFFF7E8,定义在main_f1.c */

uint32_t flash_func_read_sn(uint32_t address)
{
	return *(uint32_t *)(address + UDID_START);
}

9.5 获取芯片信息函数

9.5.1 get_mcu_id函数

get_mcu_id函数读取包含芯片ID和版本的寄存器DBGMCU_IDCODE值。


main_f1.c

#define DBGMCU_IDCODE		0xE0042000		/* DBGMCU_IDCODE:寄存器,存放芯片ID和版本信息 */

uint32_t get_mcu_id(void)
{
	return *(uint32_t *)DBGMCU_IDCODE;
}

9.5.2 get_mcu_desc函数

get_mcu_desc函数直接返回MCU型号描述和版本信息,为固定值"STM32F1xxx,?"


main_f1.c

int get_mcu_desc(int max, uint8_t *revstr)
{
	const char none[] = "STM32F1xxx,?";
	int i;
	for (i = 0; none[i] && i < max - 1; i++) {
		revstr[i] = none[i];
	}
	return i;
}

9.6 should_wait函数

should_wait函数被main函数调用,判定RTC备份寄存器BKP_DR1中是否存储了预定值,如果存储了就返回真,否则返回假。


main_f1.c

static bool should_wait(void)
{
	bool result = false;		/* 默认返回假 */

	/* 打开RTC备份寄存器访问 */
	/* PWR_CR:功率控制寄存器,定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
	/* PWR_CR_DBP:值1<<8(bit8),定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
	PWR_CR |= PWR_CR_DBP;

	/* 若RTC备份寄存器BKP_DR1的值等于预定值0x19710317,则返回真且清零寄存器 */
	/* BKP_DR1:RTC备份寄存器1,定义在libopencm3/include/libopencm3/stm32/f1/bkp.h */
	/* BL_WAIT_MAGIC:值0x19710317,定义在bl.h */
	if (BKP_DR1 == BL_WAIT_MAGIC) {
		result = true;
		BKP_DR1 = 0;
	}

	/* 关闭RTC备份寄存器访问 */
	/* PWR_CR:功率控制寄存器,定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
	/* PWR_CR_DBP:值1<<8(bit8),定义在libopencm3/include/libopencm3/stm32/common/pwr_common_all.h */
	PWR_CR &= ~PWR_CR_DBP;

	return result;
}

10 串口和USB虚拟串口函数

串口和USB虚拟串口用于PX4 Bootloader与上位机的通信,可用于固件烧写和程序调试。除此之外,本节还包括对应的反初始化函数,它们被jump_to_app函数调用,使Bootloader放弃串口的控制权。

10.1 串口和USB虚拟串口初始化相关函数

串口和USB虚拟串口初始化包括cinit、uart_cinit和usb_cinit共3个函数

10.1.1 cinit函数

cinit函数是串口和USB虚拟串口初始化的主要函数,初始化后Bootloader可与上位机的通信接口,根据输入命令对Bootloader进行调试。cinit函数根据输入interface的值决定具体调用的初始化函数;uart_cinit用于初始化串口,usb_cinit用于初始化USB接口。


bl.c

/* USART:值为1,枚举类,定义在bl.h */
/* USB:值为2,枚举类,定义在bl.h */
inline void cinit(void *config, uint8_t interface)
{
#if INTERFACE_USB		/* 主控FMU:宏INTERFACE_USB值为1,代码有效,定义在hw_config.h */
						/* IO协处理器:宏INTERFACE_USB值为0,代码无效,定义在hw_config.h */
	if (interface == USB) {
		return usb_cinit();
	}
#endif
#if INTERFACE_USART		/* 宏INTERFACE_USART值为1,代码有效,定义在hw_config.h */
	if (interface == USART) {
		return uart_cinit(config);
	}
#endif
}

10.1.2 uart_cinit函数

usart初始化函数uart_cinit,输入参数config为void*型指针,值为USART寄存器基地址。此函数使用SOC上的串口寄存器进行设置,功能为115200@8N1,收发通信,无硬件流控制。在pixahwk V2硬件和PX4代码使用USART作为上位机通信串口,config值USART2的寄存器基地址(0x40004400)。


usart.c

uint32_t usart;		/* 全局变量,uart_cinit函数中被赋值为USART2 */

void uart_cinit(void *config)
{
	/* 全局变量usart指向串口寄存器基地址 */
	usart = (uint32_t)config;

	/* 引脚和时钟初始化 */
	/* USART_CR1:根据给定的USART寄存器首地址移位0x0c来获取寄存器USART_CR1。 */
	/* 寄存器USART_CR1的bit15为OVER8域,控制串口的过采样模式。默认值0:16次过采样,值1:8次过采样。 */
	//USART_CR1(usart) |= (1 << 15);	/* libopencm3不支持USART_CR1寄存器的OVER8位操作 */
	/* USART_BAUDRATE:值115200,定义在hw_config.h */
	/* usart_set_baudrate:用于设置串口波特率,操作寄存器USART_BRR,定义在libopencm3/lib/stm32/common/usart_common_all.c */
	/* 库函数usart_set_baudrate用到了库全局变量rcc_apb1_frequency作为时钟输入。 */
	usart_set_baudrate(usart, USART_BAUDRATE);
	/* usart_set_databits:用于设置串口数据位数(8或9),操作寄存器USART_CR1域M(bit12),定义在libopencm3/lib/stm32/common/usart_common_all.c */
	usart_set_databits(usart, 8);
	/* USART_STOPBITS_1:值0x00<<12,表示停止位1(libopencm3/include/libopencm3/stm32/common/usart_common_all.h) */
	/* usart_set_stopbits:用于设置串口停止位数,操作寄存器USART_CR2域STOP(bit13:12),定义在libopencm3/lib/stm32/common/usart_common_all.c */
	usart_set_stopbits(usart, USART_STOPBITS_1);
	/* USART_MODE_TX_RX:值USART_CR1_RE|USART_CR1_TE,表示收+发(libopencm3/include/libopencm3/stm32/common/usart_common_all.h) */
	/* USART_CR1_RE:值1<<2(libopencm3/include/libopencm3/stm32/common/usart_common_f124.h) */
	/* USART_CR1_TE:值1<<3(libopencm3/include/libopencm3/stm32/common/usart_common_f124.h) */
	/* usart_set_mode:用于设置串口传输模式(单收,单发,收+发),操作寄存器USART_CR1域TE(bit3)和域RE(bit2),定义在libopencm3/lib/stm32/common/usart_common_all.c */
	usart_set_mode(usart, USART_MODE_TX_RX);
	/* USART_PARITY_NONE:值0x00,表示无校验(libopencm3/include/libopencm3/stm32/common/usart_common_all.h) */
	/* usart_set_parity:用于设置串口校验模式(无、奇、偶),操作寄存器USART_CR1域PCE(bit10)和域PS(bit9),定义在libopencm3/lib/stm32/common/usart_common_all.c */
	usart_set_parity(usart, USART_PARITY_NONE);
	/* USART_FLOWCONTROL_NONE:值0x00,表示无硬件流控制(libopencm3/include/libopencm3/stm32/common/usart_common_all.h) */
	/* usart_set_flow_control:用于设置硬件流控制(无、RTS、CTS、RTS+CTS),操作寄存器USART_CR3的CTSE(bit9)和RTSE(bit8) */
	usart_set_flow_control(usart, USART_FLOWCONTROL_NONE);

	/* usart_enable:用于使能串口,操作寄存器USART_CR1的域UE(bit13),定义在libopencm3/lib/stm32/common/usart_common_all.c */
	usart_enable(usart);
}

10.1.3 usb_cinit函数

USB虚拟串口初始化函数usb_cinit,根据CDC ACM虚拟串口协议对板载USB OTG FS进行设备初始化,115200@8N1,收发通信。本函数使用了USB的设备描述符(usb_device_descriptor)、配置描述符(usb_config_descriptor)、接口描述符(usb_interface_descriptor)、端点描述符(usb_endpoint_descriptor),这些描述符的定义都在libopencm3/include/libopencm3/usb/usbstd.h中。这些描述符支撑了一个全局使用的_usbd_device型结构体指针usbd_dev,它包含了USB的所有配置信息和操作函数,对它成员的配置就是本函数的核心。配置完成后USB接口的操作就非常方便了。


cdcacm.c

#define USB_CDC_REQ_GET_LINE_CODING		0x21

#define OTG_CID_HAS_VBDEN		0x00002000
#define OTG_GCCFG_VBDEN			(1 << 21)

/* USB设备字符串列表,下标从1开始 */
static const char *usb_strings[] = {
	USBMFGSTRING,		/* USBMFGSTRING:值"3D Robotics",生产厂家名称,INDEX 1。(hw_config.h) */
	USBDEVICESTRING,		/* USBDEVICESTRING:"PX4 BL FMU v2.x",USB设备名称,INDEX2。(hw_config.h) */
	"0",					/* 设备序号,INDEX 3 */
};
#define NUM_USB_STRINGS (sizeof(usb_strings)/sizeof(usb_strings[0]))		/* 上面定义的字符串数组usb_strings的成员个数 */

static usbd_device *usbd_dev;		/* _usbd_device型结构体全局指针变量,包含一系列USB信息与操作函数(libopencm3/lib/usb/usb_private.h) */

/* Buffer to be used for control requests. */
static uint8_t usbd_control_buffer[128];

/* 标准的USB设备描述符结构体变量dev,属性packed,定义在libopencm3/include/libopencm3/usb/usbstd.h */
static const struct usb_device_descriptor dev = {	
	.bLength = USB_DT_DEVICE_SIZE,		/* USB_DT_DEVICE_SIZE:值18,本结构体的大小(libopencm3/include/libopencm3/usb/usbstd.h) */
	.bDescriptorType = USB_DT_DEVICE,	/* USB_DT_DEVICE:值1,本结构体为USB设备描述符(libopencm3/include/libopencm3/usb/usbstd.h) */
	.bcdUSB = 0x0200,					/* USB接口版本,0x0200表示符合USB2.0规范 */
	.bDeviceClass = USB_CLASS_CDC,		/* USB_CLASS_CDC:值0x2,设备群组码(libopencm3/include/libopencm3/usb/cdc.h) */
	.bDeviceSubClass = 0,				/* 设备次群组码 */
	.bDeviceProtocol = 0,				/* 通信设备协议,0表示无群组特定协议 */
	.bMaxPacketSize0 = 64,				/* 设备最大信息包大小为64字节(只能为8、16、32、64) */
	.idVendor = USBVENDORID,				/* USBVENDORID:值0x26AC,USB设备厂家ID,这里是默认值(hw_config.h) */
	.idProduct = USBPRODUCTID,			/* USBPRODUCTID:值0x0011,USB产品ID(hw_config.h) */
	.bcdDevice = 0x0101,					/* USB设备发行序号,0x0101表示1.01版,为了兼容NuttX */
	.iManufacturer = 1,					/* USB设备厂家字符串下标,1代表USBMFGSTRING("3D Robotics"),数组usb_strings */
	.iProduct = 2,						/* USB产品字符串下标,2代表USBDEVICESTRING("PX4 BL FMU v2.x"),数组usb_strings */
	.iSerialNumber = 3,					/* USB设备序号下标,3代表空("0") */
	.bNumConfigurations = 1,				/* USB设备配置的数目为1个(config) */
};

/* USB通信端点描述符结构体数组变量comm_endp,属性packed,定义在libopencm3/include/libopencm3/usb/usbstd.h */
/* 这里仅对端点描述符的内容进行了赋值,结构体规定的额外内容在UNIX环境中被默认为0 */
static const struct usb_endpoint_descriptor comm_endp[] = {{
		.bLength = USB_DT_ENDPOINT_SIZE,					/* USB_DT_ENDPOINT_SIZE:值7,端点描述符大小(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bDescriptorType = USB_DT_ENDPOINT,				/* USB_DT_ENDPOINT:值5,表示本结构体为USB端点描述符(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bEndpointAddress = 0x83,						/* 通信端点地址为0x83 */
		.bmAttributes = USB_ENDPOINT_ATTR_INTERRUPT,		/* USB_ENDPOINT_ATTR_INTERRUPT:值0x03,本通信端点为中断传输(libopencm3/include/libopencm3/usb/usbstd.h) */
		.wMaxPacketSize = 16,							/* 数据包最大16字节 */
		.bInterval = 255,								/* 轮询间隔255ms */
	}
};

/* USB数据端点描述符结构体数组变量data_endp(2个,一般称为DATA0和DATA1),属性packed,定义在libopencm3/include/libopencm3/usb/usbstd.h */
/* 这里仅对端点描述符的内容进行了赋值,结构体规定的额外内容在UNIX环境中被默认为0 */
static const struct usb_endpoint_descriptor data_endp[] = {{
		.bLength = USB_DT_ENDPOINT_SIZE,					/* USB_DT_ENDPOINT_SIZE:值7,端点描述符大小(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bDescriptorType = USB_DT_ENDPOINT,				/* USB_DT_ENDPOINT:值5,表示本结构体为USB端点描述符(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bEndpointAddress = 0x01,						/* 此数据端点的地址为0x01 */
		.bmAttributes = USB_ENDPOINT_ATTR_BULK,			/* USB_ENDPOINT_ATTR_BULK:值0x2,本数据端点为批量传输(libopencm3/include/libopencm3/usb/usbstd.h) */
		.wMaxPacketSize = 64,							/* 数据包最大64字节 */
		.bInterval = 1,									/* 轮询间隔1ms */
	}, {
		.bLength = USB_DT_ENDPOINT_SIZE,					/* USB_DT_ENDPOINT_SIZE:值7,端点描述符大小(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bDescriptorType = USB_DT_ENDPOINT,				/* USB_DT_ENDPOINT:值5,表示本结构体为USB端点描述符(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bEndpointAddress = 0x82,						/* 此数据端点的地址为0x82 */
		.bmAttributes = USB_ENDPOINT_ATTR_BULK,			/* USB_ENDPOINT_ATTR_BULK:值0x2,本数据端点为批量传输(libopencm3/include/libopencm3/usb/usbstd.h) */
		.wMaxPacketSize = 64,							/* 数据包最大64字节 */
		.bInterval = 1,									/* 轮询间隔1ms */
	}
};

/* 对USB CDC通信需要额外提供的信息进行汇总,用于到关联通信接口描述符comm_iface */
static const struct {
	struct usb_cdc_header_descriptor header;
	struct usb_cdc_call_management_descriptor call_mgmt;
	struct usb_cdc_acm_descriptor acm;
	struct usb_cdc_union_descriptor cdc_union;
} __attribute__((packed)) cdcacm_functional_descriptors = {
	.header = {
		.bFunctionLength = sizeof(struct usb_cdc_header_descriptor),
		.bDescriptorType = CS_INTERFACE,
		.bDescriptorSubtype = USB_CDC_TYPE_HEADER,
		.bcdCDC = 0x0110,
	},
	.call_mgmt = {
		.bFunctionLength = sizeof(struct usb_cdc_call_management_descriptor),
		.bDescriptorType = CS_INTERFACE,
		.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
		.bmCapabilities = 0,
		.bDataInterface = 1,
	},
	.acm = {
		.bFunctionLength = sizeof(struct usb_cdc_acm_descriptor),
		.bDescriptorType = CS_INTERFACE,
		.bDescriptorSubtype = USB_CDC_TYPE_ACM,
		.bmCapabilities = 0,
	},
	.cdc_union = {
		.bFunctionLength = sizeof(struct usb_cdc_union_descriptor),
		.bDescriptorType = CS_INTERFACE,
		.bDescriptorSubtype = USB_CDC_TYPE_UNION,
		.bControlInterface = 0,
		.bSubordinateInterface0 = 1,
	}
};

/* USB通信接口描述符结构体变量comm_iface,属性packed,定义在libopencm3/include/libopencm3/usb/usbstd.h */
static const struct usb_interface_descriptor comm_iface[] = {{
		.bLength = USB_DT_INTERFACE_SIZE,			/* USB_DT_INTERFACE_SIZE:值9,接口描述符大小(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bDescriptorType = USB_DT_INTERFACE,			/* USB_DT_INTERFACE:值4,表示本结构体为USB接口描述符(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bInterfaceNumber = 0,						/* 接口数目1个,以0为基准开始计数 */
		.bAlternateSetting = 0,						/* 交互设置值为0 */
		.bNumEndpoints = 1,							/* 端点数目1个(comm_endp) */
		.bInterfaceClass = USB_CLASS_CDC,			/* USB_CLASS_CDC:值0x02,接口群组(libopencm3/include/libopencm3/usb/cdc.h) */
		.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,	/* USB_CDC_SUBCLASS_ACM:值0x02,接口次群组(libopencm3/include/libopencm3/usb/cdc.h) */
		.bInterfaceProtocol = USB_CDC_PROTOCOL_AT,	/* USB_CDC_PROTOCOL_AT:值0x01,接口协议(libopencm3/include/libopencm3/usb/cdc.h) */
		.iInterface = 0,								/* 接口的字符串描述符索引为0 */

		/* 以下内容不再属于USB接口描述符信息,为程序内部使用的变量 */
		.endpoint = comm_endp,						/* 此接口对应的端点为comm_endp */
		.extra = &cdcacm_functional_descriptors,		/* 通信接口额外信息域为cdcacm_functional_descriptors */
		.extralen = sizeof(cdcacm_functional_descriptors)		/* 额外信息域长度 */
	}
};

/* USB数据接口描述符结构体变量data_iface,属性packed,定义在libopencm3/include/libopencm3/usb/usbstd.h */
/* 这里仅进行了部分赋值,结构体规定的额外内容在UNIX环境中被默认为0 */
static const struct usb_interface_descriptor data_iface[] = {{
		.bLength = USB_DT_INTERFACE_SIZE,			/* USB_DT_INTERFACE_SIZE:值9,接口描述符大小(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bDescriptorType = USB_DT_INTERFACE,			/* USB_DT_INTERFACE:值4,表示本结构体为USB接口描述符(libopencm3/include/libopencm3/usb/usbstd.h) */
		.bInterfaceNumber = 1,						/* 接口数目2个,以0为基准开始计数 */
		.bAlternateSetting = 0,						/* 交互设置值为0 */
		.bNumEndpoints = 2,							/* 端点数目2个(data_endp) */
		.bInterfaceClass = USB_CLASS_DATA,			/* USB_CLASS_DATA:值0x0a,接口群组(libopencm3/include/libopencm3/usb/cdc.h) */
		.bInterfaceSubClass = 0,						/* 接口次群组为0 */
		.bInterfaceProtocol = 0,						/* 接口协议,0表示无特定协议 */
		.iInterface = 0,								/* 接口的字符串描述符索引为0,无效 */

		/* 以下内容不再属于USB接口描述符信息,为程序内部使用的变量 */
		.endpoint = data_endp,						/* 此接口对应的端点为data_endp */
	}
};

/* 变量ifaces对接口描述符进行了统计(共2个),用于关联到配置描述符中 */
static const struct usb_interface ifaces[] = {{
		.num_altsetting = 1,
		.altsetting = comm_iface,
	}, {
		.num_altsetting = 1,
		.altsetting = data_iface,
	}
};

/* USB配置描述符结构体变量config,属性packed,定义在libopencm3/include/libopencm3/usb/usbstd.h */
static const struct usb_config_descriptor config = {
	.bLength = USB_DT_CONFIGURATION_SIZE,		/* USB_DT_CONFIGURATION_SIZE:值9,配置描述符大小(libopencm3/include/libopencm3/usb/usbstd.h) */
	.bDescriptorType = USB_DT_CONFIGURATION,		/* USB_DT_CONFIGURATION:值2,表示本结构体为USB配置描述符(libopencm3/include/libopencm3/usb/usbstd.h) */
	.wTotalLength = 0,							/* 描述符的总长度为0(是否应该为32字节?接口描述符9+配置描述符9+端点描述符7*2) */
	.bNumInterfaces = 2,							/* 该配置支持的接口数目2个(comm_iface和data_iface) */
	.bConfigurationValue = 1,					/* 配置值为1,作为set configuration请求的配置值 */
	.iConfiguration = 0,							/* 配置字符串描述符索引为0,无效 */
	.bmAttributes = 0x80,						/* 配置的属性为0x80 */
	.bMaxPower = 0xFA,							/* 当USB设备操作时,它从总线上获得的最大电源(单位2mA,0xFA=250,500mA) */

	/* 以下内容不再属于USB配置描述符信息,为程序内部使用的变量 */
	.interface = ifaces,							/* 此配置对应的接口 */
};

/* USB虚拟串口属性结构体变量line_coding,属性packed,定义在libopencm3/include/libopencm3/usb/cdc.h */
static const struct usb_cdc_line_coding line_coding = {
	.dwDTERate = 115200,						/* 波特率115200 */
	.bCharFormat = USB_CDC_1_STOP_BITS,		/* USB_CDC_1_STOP_BITS:值0,1位停止位(libopencm3/include/libopencm3/usb/cdc.h) */
	.bParityType = USB_CDC_NO_PARITY,		/* USB_CDC_NO_PARITY:值0,无校验(libopencm3/include/libopencm3/usb/cdc.h) */
	.bDataBits = 0x08						/* 数据8位 */
};

/* USB虚拟串口请求控制函数,被配置函数cdcacm_set_config函数使用 */
static int cdcacm_control_request(usbd_device *usbd_dev, struct usb_setup_data *req, uint8_t **buf, uint16_t *len,
								void (**complete)(usbd_device *usbd_dev, struct usb_setup_data *req))
{
	(void)complete;
	(void)buf;
	(void)usbd_dev;

	switch (req->bRequest) {		/* 请求类型 */
	case USB_CDC_REQ_SET_CONTROL_LINE_STATE: {	/* USB_CDC_REQ_SET_CONTROL_LINE_STATE:值0x22,请求设置命令行状态,定义在libopencm3/include/libopencm3/usb/cdc.h */
			return 1;			/* 不操作,直接返回1 */
		}
	case USB_CDC_REQ_SET_LINE_CODING:			/* USB_CDC_REQ_SET_LINE_CODING:值0x20,请求设置虚拟串口属性,定义在libopencm3/include/libopencm3/usb/cdc.h */
		if (*len < sizeof(struct usb_cdc_line_coding)) {		/* 若配置的参数长度小于usb_cdc_line_coding的大小,返回0 */
			return 0;
		}
		return 1;				/* 不操作,返回1 */
	case USB_CDC_REQ_GET_LINE_CODING:			/* USB_CDC_REQ_GET_LINE_CODING:值0x21,请求读取虚拟串口属性,定义在cdcacm.c中 */
		*buf = (uint8_t *)&line_coding;			/* buf指向虚拟串口属性变量line_coding(115200@8N1),定义在cdcacm.c中 */
		return 1;
	}
	return 0;
}

/* USB虚拟串口数据接收函数,被配置函数cdcacm_set_config函数使用 */
static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep)
{
	(void)ep;

	char buf[64];
	unsigned i;
	/* usbd_ep_read_packet:去读USB设备usbd_dev在端点地址0x01的数据到缓冲区buf中,并返回读取到数据的个数。定义在libopencm3/lib/usb/usb.c */
	unsigned len = usbd_ep_read_packet(usbd_dev, 0x01, buf, sizeof(buf));

	/* 将数据赋值给接收数据缓冲区rx_buf */
	/* buf_put:将数据写入到缓冲区的函数,定义在bl.c */
	for (i = 0; i < len; i++) {
		buf_put(buf[i]);	
	}
}

/* USB虚拟串口配置函数,被usb_cinit中的库函数usbd_register_set_config_callback引用 */
static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue)
{
	(void)wValue;

	/* USB_ENDPOINT_ATTR_BULK:值0x2,批量传输(libopencm3/include/libopencm3/usb/usbstd.h) */
	/* USB_ENDPOINT_ATTR_INTERRUPT:值0x03,中断传输(libopencm3/include/libopencm3/usb/usbstd.h) */
	/* cdcacm_data_rx_cb:USB虚拟串口数据接收函数,将数据赋值给接收数据缓冲区rx_buf(bl.c),定义在cdcacm.c */
	/* usbd_ep_setup:设置USB端点地址、类型、FIFO存储空间和回调函数 */
	/* 第一行:地址为0x01的USB端点类型为批量传输模式(USB_ENDPOINT_ATTR_BULK),缓冲区长度64字节,回调函数为cdcacm_data_rx_cb,用于接收USB数据 */
	/* 第二行:地址为0x82的USB端点类型为批量传输模式(USB_ENDPOINT_ATTR_BULK),缓冲区长度64字节,无回调函数,用于发送USB数据 */
	/* 第三行:地址为0x83的USB端点类型为中断传输模式(USB_ENDPOINT_ATTR_INTERRUPT),缓冲区长度16字节,无回调函数,用于USB传输控制 */
	usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb);
	usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, NULL);
	usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);

	/* USB_REQ_TYPE_CLASS:值0x20(libopencm3/include/libopencm3/usb/usbstd.h) */
	/* USB_REQ_TYPE_INTERFACE:值0x01(libopencm3/include/libopencm3/usb/usbstd.h) */
	/* USB_REQ_TYPE_TYPE:值0x60(libopencm3/include/libopencm3/usb/usbstd.h) */
	/* USB_REQ_TYPE_RECIPIENT:值0x1F(libopencm3/include/libopencm3/usb/usbstd.h) */
	/* cdcacm_control_request:USB虚拟串口请求控制函数,功能为处理各种USB请求信息,定义在cdcacm.c */
	/* usbd_register_control_callback:USB寄存器控制请求回调函数,定义在libopencm3/lib/usb/usb_control.c */
	usbd_register_control_callback(usbd_dev, USB_REQ_TYPE_CLASS|USB_REQ_TYPE_INTERFACE, USB_REQ_TYPE_TYPE|USB_REQ_TYPE_RECIPIENT, cdcacm_control_request);
}

/* USB OTG FS中断处理函数 */
void otg_fs_isr(void)
{
	if (usbd_dev) {
		/* usbd_poll:USB设备的POLL操作;定义在libopencm3/lib/usb/usb.c */
		usbd_poll(usbd_dev);
	}
}

/* USB虚拟串口通信初始化函数 */
void usb_cinit(void)
{
#if defined(STM32F4)			/* 宏STM32F4值为1,定义在Makefile.f4中,下列代码有效 */
	/* 1. 启动USB接口时钟,对应原理图中GPIOA9(VBUS/3.1A),GPIOA11(OTG_FS_DM/3.1B),GPIOA12(OTG_FS_DP/3.1A) */
	/* RCC_AHB1ENR:寄存器(地址0x40023830),定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* RCC_AHB2ENR:寄存器(地址0x40023834),定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* RCC_AHB1ENR_IOPAEN:值1<<0(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* RCC_AHB2ENR_OTGFSEN:值1<<7(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* rcc_peripheral_enable_clock:使能特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* 第一行代码使能GPIOA的时钟,操作寄存器RCC_AHB1ENR的域GPIOAEN(bit0) */
	/* 第二行代码使能USB OTG FS时钟,操作寄存器RCC_AHB2ENR的域OTGFSEN(bit7) */
	rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN);
	rcc_peripheral_enable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);

#if defined(USB_FORCE_DISCONNECT)		/* 宏USB_FORCE_DISCONNECT未定义,下列代码无效 */
	gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_OTYPE_OD, GPIO12);
	gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO12);
	gpio_clear(GPIOA, GPIO12);
	systick_set_clocksource(STK_CSR_CLKSOURCE_AHB);
	systick_set_reload(board_info.systick_mhz * 1000);	/* 1ms tick, magic number */
	systick_interrupt_enable();
	systick_counter_enable();
	/* Spec is 2-2.5 uS */
	delay(1);
	systick_interrupt_disable();
	systick_counter_disable(); // Stop the timer
#endif

	/* 2. 配置GPIOA11和GPIOA12分别USB数据通信功能 */
	/* GPIOA:地址为0x40020000的寄存器(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_MODE_AF:值0x2(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_PUPD_NONE:值0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO11:值1<<11(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* GPIO12:值1<<12(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* GPIO_AF10:值0xa(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* gpio_mode_setup:设置引脚工作模式,定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */
	/* gpio_set_af:设置引脚具体的AF功能,定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */
	/* 第一行代码设置GPIOA11(OTG_FS_DM/3.1B)和GPIOA12(OTG_FS_DP/3.1A)为AF功能(MODER=GPIO_MODE_AF=10),push-pull模式(PUPDR=GPIO_PUPD_NONE=0x0) */
	/* 第二行代码设置GPIOA11和GPIOA12的具体AF功能为OTGFS/OTGHS(AFRH10=AFRH9=GPIO_AF10=0xa) */
	gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11 | GPIO12);
	gpio_set_af(GPIOA, GPIO_AF10, GPIO11 | GPIO12);

#if defined(BOARD_USB_VBUS_SENSE_DISABLED)	/* 宏BOARD_USB_VBUS_SENSE_DISABLED未定义,下列代码无效 */
	OTG_FS_GCCFG |= OTG_GCCFG_NOVBUSSENS;
#endif

	/* 3. USB设备的初始化配置 */
	/* usbd_dev:_usbd_device型结构体全局指针变量,包含一系列USB信息与操作函数(libopencm3/lib/usb/usb_private.h) */
	/* otgfs_usb_driver:_usbd_driver型结构体变量stm32f107_usb_driver,包含一系列USBFS驱动函数(libopencm3/lib/usb/usb_f107.c) */
	/* dev:USB设备描述符usb_device_descriptor,包含USB设备的基本信息(libopencm3/include/libopencm3/usb/usbstd.h),初始化在cdcacm.c */
	/* config:USB配置描述符usb_config_descriptor,包含USB设备的配置信息(libopencm3/include/libopencm3/usb/usbstd.h),初始化在cdcacm.c */
	/* usb_strings:USB设备字符串列表,定义并被初始化在cdcacm.c */
	/* NUM_USB_STRINGS:值3,usb_strings的数量,宏定义在cdcacm.c */
	/* usbd_control_buffer:控制操作请求缓冲区,128字节,定义在cdcacm.c */
	/* usbd_init:usb接口初始化函数,目的是填写结构体变量usbd_dev,定义在libopencm3/lib/usb/usb.c */
	usbd_dev = usbd_init(&otgfs_usb_driver, &dev, &config, usb_strings, NUM_USB_STRINGS, usbd_control_buffer, sizeof(usbd_control_buffer));

#elif defined(STM32F1)		/* 宏STM32F1未定义(IO协处理器不执行usb_cinit),下列代码无效 */
	rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);
	gpio_set(GPIOA, GPIO8);
	gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO8);
	usbd_dev = usbd_init(&st_usbfs_v1_usb_driver, &dev, &config, usb_strings, NUM_USB_STRINGS, usbd_control_buffer, sizeof(usbd_control_buffer));
#endif

	/* 4. USB传输回调函数设置 */
	/* usbd_dev:_usbd_device型结构体全局指针变量,包含一系列USB信息与操作函数(libopencm3/lib/usb/usb_private.h) */
	/* cdcacm_set_config:USB虚拟串口配置函数,配置USB端点的操作函数和USB寄存器的请求操作函数,定义在cdcmca.c */
	/* usbd_register_set_config_callback:追加回调函数cdcacm_set_config到设备描述符usbd_dev中 */
	usbd_register_set_config_callback(usbd_dev, cdcacm_set_config);

#if defined(STM32F4)			/* 宏STM32F4值为1,定义在Makefile.f4中,下列代码有效 */

	/* 5. 若USB产品的ID号为0x00002000,启动USB连接功能 */
	/* OTG_FS_CID:寄存器,用于存储USB产品ID,软件可更改(libopencm3/include/libopencm3/stm32/otg_fs.h) */
	/* OTG_CID_HAS_VBDEN:值0x00002000,定义在cdcacm.c */
	/* OTG_FS_GCCFG:寄存器(libopencm3/include/libopencm3/stm32/otg_fs.h) */
	/* OTG_GCCFG_VBDEN:值1<<21,置该位认为VBUS一直有效,不再受外围电路影响(cdcacm.c) */
	/* OTG_GCCFG_PWRDWN:值1<<16,置该位开启收发功能(libopencm3/include/libopencm3/stm32/otg_common.h) */
	/* OTG_FS_DCTL:寄存器(libopencm3/include/libopencm3/stm32/otg_fs.h) */
	/* OTG_DCTL_SDIS:值1<<1,该位由软件控制USB核心开启软件连接功能(libopencm3/include/libopencm3/stm32/otg_common.h) */
	if (OTG_FS_CID == OTG_CID_HAS_VBDEN) {
		OTG_FS_GCCFG |= OTG_GCCFG_VBDEN | OTG_GCCFG_PWRDWN;
		/* 对于STM32F446/469,启动后需要进行软件连接 */
		OTG_FS_DCTL &= ~OTG_DCTL_SDIS;
	}

	/* 6. 使能USB OTG FS中断 */
	/* NVIC_OTG_FS_IRQ:值67,对应USB OTG FS的全局中断向量号,libopencm3/include/libopencm3/stm32/f4/nvic.h(编译时自动生成文件) */
	/* nvic_enable_irq:使能中断向量,定义在libopencm3/lib/cm3/nvic.c */
	nvic_enable_irq(NVIC_OTG_FS_IRQ);
#endif
}

USB串口读取数据后存放到缓冲区的函数,被cdcacm_data_rx_cb函数调用


bl.c

static unsigned head, tail;		/* 头、尾指针 */
static uint8_t rx_buf[256];		/* 缓冲区长度 */

void buf_put(uint8_t b)
{
	unsigned next = (head + 1) % sizeof(rx_buf);
	if (next != tail) {
		rx_buf[head] = b;
		head = next;
	}
}

10.2 串口和USB虚拟串口反向初始化相关函数

串口和USB虚拟串口反向初始化包括cfini、uart_cfini和usb_cfini共3个函数。

10.2.1 cfini函数

cfini函数是串口和USB虚拟串口初始化的主要函数,使Bootloader主动放弃通信串口的控制权。cfini函数根据输入interface的值决定具体调用的初始化函数;uart_cfini用于反向初始化串口,usb_cfini用于反向初始化USB接口。


bl.c

inline void cfini(void)
{
#if INTERFACE_USB		/* 主控FMU:宏INTERFACE_USB定义为1,代码有效,hw_config.h */
						/* IO协处理器:宏INTERFACE_USB定义为0,代码无效,hw_config.h */
	usb_cfini();
#endif
#if INTERFACE_USART		/* 宏INTERFACE_USART定义为1,hw_config.h */
	uart_cfini();
#endif
}

10.2.2 uart_cfini函数

uart_cfini函数的草组很简单,直接调用库函数usart_disable关闭串口,USART2串口的配置并不改变。


usart.c

uint32_t usart;		/* 全局变量,uart_cinit函数中被赋值为USART2 */

void uart_cfini(void)
{
	/* usart_disable:关闭串口,操作寄存器USART_CR1的域UE(bit13)(libopencm3/lib/stm32/common/usart_common_all.c) */
	usart_disable(usart);
}

10.2.3 usb_cfini函数

USB虚拟串口反向初始化函数usb_cfini,并未改变USB的接口配置,主要操作如下:

  • 关闭USB OTG FS中断
  • 关闭USB软连接,并清空usbd_dev指针
  • 配置USB数据引脚GPIOA11和GPIOA12的工作模式
  • 关闭USB OTG FS时钟

void usb_cfini(void)
{
#if defined(STM32F4)			/* 宏STM32F4值为1,定义在Makefile.f4中,下列代码有效 */
	/* 1. 关闭USB OTG FS中断 */
	/* NVIC_OTG_FS_IRQ:值67,对应USB OTG FS的全局中断向量号,libopencm3/include/libopencm3/stm32/f4/nvic.h(编译时自动生成文件) */
	/* nvic_disable_irq:使能中断向量,定义在libopencm3/lib/cm3/nvic.c */
	nvic_disable_irq(NVIC_OTG_FS_IRQ);
#endif

	/* 2.关闭USB软连接,并清空usbd_dev指针 */
	/* usbd_dev:usbd_device型全局变量指针,指向USB的配置信息和操作函数,被usbd_init库函数初始化,cdcacm.c */
	/* usbd_disconnect:断开USB软连接(不是所有的MCU都支持)。定义在libopencm3/lib/usb/usb.c */
	if (usbd_dev) {
		usbd_disconnect(usbd_dev, true);
		usbd_dev = NULL;
	}

#if defined(STM32F4)		/* 宏STM32F4值为1,定义在Makefile.f4中,下列代码有效 */
	/* 3. 配置USB数据引脚GPIOA11和GPIOA12为输入 */
	/* GPIOA:地址为0x40020000的寄存器(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_MODE_INPUT:值0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO_PUPD_NONE:值0x0(libopencm3/include/libopencm3/stm32/common/gpio_common_f234.h) */
	/* GPIO11:值1<<11(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* GPIO12:值1<<12(libopencm3/include/libopencm3/stm32/common/gpio_common_all.h) */
	/* gpio_mode_setup:设置引脚工作模式,定义在libopencm3/lib/stm32/common/gpio_common_f0234.c */
	/* 设置GPIOA11(OTG_FS_DM/3.1B)和GPIOA12(OTG_FS_DP/3.1A)为输入功能(MODER=GPIO_MODE_AF=00),浮空模式(PUPDR=GPIO_PUPD_NONE=0x0) */
	gpio_mode_setup(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO11 | GPIO12);

	/* 4. 关闭USB OTG FS时钟 */
	/* RCC_AHB2ENR:寄存器(地址0x40023834),定义在libopencm3/include/libopencm3/stm32/f4/rcc.h */
	/* RCC_AHB2ENR_OTGFSEN:值1<<7(libopencm3/include/libopencm3/stm32/f4/rcc.h) */
	/* rcc_peripheral_disable_clock:关闭特定的外部时钟,被定义在libopencm3/lib/stm32/common/rcc_common_all.c */
	/* 关闭USB OTG FS时钟,操作寄存器RCC_AHB2ENR的域OTGFSEN(bit7) */
	rcc_peripheral_disable_clock(&RCC_AHB2ENR, RCC_AHB2ENR_OTGFSEN);

#elif defined(STM32F1)		/* 宏STM32F1未定义(IO协处理器不执行usb_cfini),下列代码无效 */
	/* Reset the USB pins to being floating inputs */
	gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO8);
	gpio_clear(GPIOA, GPIO8);
#endif
}

10.3 读取串口和USB虚拟串口内容函数

读取串口和USB虚拟串口内容函数包括uart_cin和usb_cin两个,分别对应USART读取和USB模拟串口读取函数,这两个函数均被cin函数调用。

10.3.1 uart_cin函数

uart_cin函数用于读取USART串口的1个字。


usart.c

uint32_t usart;		/* 全局变量,uart_cinit函数中被赋值为USART2 */

int uart_cin(void)
{
	int c = -1;		/* 默认返回值-1 */

	/* 若串口数据寄存器不为空,调用库函数读取接收到的数据 */
	/* USART_SR:USART状态寄存器,定义在libopencm3/include/libopencm3/stm32/common/usart_common_f124.h */
	/* USART_SR_RXNE:值1<<5,定义在libopencm3/include/libopencm3/stm32/common/usart_common_f124.h */
	/* usart:值USART2(USART2基地址),定义在usart.c */
	/* usart_recv:接收串口数据的库函数,定义在libopencm3/lib/stm32/common/usart_common_f124.c */
	if (USART_SR(usart) & USART_SR_RXNE) {
		c = usart_recv(usart);
	}

	return c;
}

10.3.2 usb_cin函数

usb_cin函数用于读取USB模拟串口的1个字,该函数仅对主控FMU有效。


cdcacm.c

int usb_cin(void)
{
	/* 若usbd_dev为空指针,则USB设备未被初始化,返回错误 */
	/* usbd_dev:_usbd_device型结构体全局指针变量,包含一系列USB信息与操作函数,定义在cdcacm.c */
	if (usbd_dev == NULL) { return -1; }
#if defined(STM32F1)			/* 主控FMU未定义,代码无效 */
	usbd_poll(usbd_dev);
#endif
	/* buf_get:从串口缓冲区内读取1个字的内容,定义在bl.c */
	return buf_get();
}


bl.c

static unsigned head, tail;		/* 头、尾指针 */
static uint8_t rx_buf[256];		/* 串口串口缓冲区 */

int buf_get(void)
{
	int	ret = -1;
	if (tail != head) {
		ret = rx_buf[tail];
		tail = (tail + 1) % sizeof(rx_buf);
	}
	return ret;
}

10.4 串口和USB虚拟串口内容输出函数

串口和USB虚拟串口输出函数包括uart_cout和usb_cout两个,分别对应USART读取和USB模拟串口输出函数,这两个函数均被cout函数调用。

10.4.1 uart_cout函数


usart.c

uint32_t usart;		/* 全局变量,uart_cinit函数中被赋值为USART2 */

void uart_cout(uint8_t *buf, unsigned len)
{
	/* usart_send_blocking:USART串口发送库函数,仅当串口数据缓存为空时再发送下一个数据,定义在libopencm3/lib/stm32/common/usart_common_all.c */
	while (len--) {
		usart_send_blocking(usart, *buf++);
	}
}

10.4.2 usb_cout函数


cdcacm.c

void usb_cout(uint8_t *buf, unsigned count)
{
	if (usbd_dev) {		/* 若USB设备有效 */
		/* 将需要写入的数据分成64字节1包,逐包写入到地址为0x82的端点中 */
		while (count) {
			unsigned len = (count > 64) ? 64 : count;
			unsigned sent;
			/* usbd_ep_write_packet:向USB模拟串口写入数据的库函数,返回写入的字节数,定义在libopencm3/lib/usb/usb.c */
			sent = usbd_ep_write_packet(usbd_dev, 0x82, buf, len);
			count -= sent;
			buf += sent;
		}
	}
}

11 结论

不知不觉,就写了这么多,我最怕写结尾了,因为不知道写什么好。写博客的时候发现,github上bootloader的原始代码也更新了。幸好只是改变了Makefile的结构,对软件结构影响不大,因此上述内容依然有参考价值。博客写完之后没有进行详细地推敲,希望各位看官多多批评指正,大家共同进步。

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

[email protected]

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

开源万岁!!!

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

你可能感兴趣的:(PX4 Bootloader解析)