1 什么是 GPIO ？
, x& X$ }9 D; \# s- z6 w4 M1.1 GPIO 简介
GPIO 即 通用型输入输出端口（General-Purose Input / Output）的简称，简单来说就是 STM32 单片机的可控制的引脚，功能类似于 8051 系列单片机的 P0-P3 端口。STM32 芯片的 GPIO 引脚与外部设备连接起来，从而实现与外部的通讯、控制以及数据采集的功能。STM32 芯片的 GPIO 被分为很多组，每组 16 个引脚，例如型号为 STM32F103VET6 型号的芯片有 GPIOA、GPIOB 至 GPIOE 一共 5 组 GPIO ，芯片一共有 100 个引脚，其中 GPIO 就占了很大一部分，所有的 GPIO 引脚都具有基本的输入输出功能。
* _- ]5 J- W; ~' ^+ s+ z9 d9 v: j
. j( l/ t* e/ v5 [% M最基本的输出功能是由 STM32 控制引脚输出高、底电平，实现开关控制，例如把 GPIO 引脚接入到 LED 灯上，就可以用来控制 LED 灯的亮灭，引脚接入到继电器或者三极管，那就可以通过继电器或者三极管来控制外部大功率电路的推断，实现电气隔离。

4 m/ Q) @/ a8 v! V+ `, f最基本的输入功能是检测外部输入的电平，如把 GPIO 引脚连接到轻触按键上，通过引脚电平的高低来区分按键是否按下。
2 h- E1 k' l7 @+ P: s  s0 i# G
; [' _' d" g+ @4 c& r7 _2 I6 U; {1.2 GPIO 硬件解析
STM32 芯片 GPIO 接口内部原理如下：
# m) L# [; Y! [+ l
6 s3 l' u% l+ i' G

通过 GPIO 硬件结构图，就可以从整体上深入的了解 GPIO 外设以及它的各种应用模式。从图的最右端看，最右端代表的是 STM32 芯片引出的 GPIO 引脚，其余部件都位于芯片内部。
7 r" P% I9 ?  }' e  Q6 \8 u# S. S
1.2.1 保护二极管
0 B) I6 w: v) r' D# T引脚上的两个保护二级管用于防止引脚外部过高或过低的电压输入，当引脚电压高于 Vdd 时,上方的二极管导通，当引脚电压低于 Vss 时，下方的二极管导通，防止不正常电压引入芯片导致芯片烧毁。
6 W5 a; }- e9 G; J. ^, p7 g# {
尽管有这样的保护，并不意味着 STM32 的引脚能直接外接大功率驱动器件，如直接驱动电机，强制驱动要么电机不转，要么导致芯片烧坏，必须要加大功率及隔离电路驱动。
% e. ^/ l+ n. p) m
1.2.2 P-MOS、N-MOS 管
GPIO引脚线路经过两个保护二极管后,向上流向“输入模式”结构,向下流向“输出模式”结构。先看输出模式部分,线路经过一个由 P-MOS 和 N-MOS 管组成的单元电路。这个结构使 GPIO 具有了“推挽输出”和“开漏输出”两种模式。

& ^" z5 D' u& F. P$ ~. b. }/ n所谓的推挽输出模式,是根据这两个 MOS 管的工作方式来命名的。在该结构中输人高电平时，经过反向后，上方的 P-MOS 导通，下方的 N-MOS 关闭,对外输出高电平，即“推”；而在该结构中输入低电平时，经过反向后， N-MOS 管导通，P-MOS 关闭，对外输出低电平，即“挽”。当引脚高低电平切换时，两个管子轮流导通，P 管负责灌电流，N管负责拉电流，使其负载能力和开关速度都比普通的方式有很大的提高。推挽输出的低电平为0伏，高电平为3.3伏。推挽模式的等效电路如下：
  L5 L" f# e4 f* r2 v4 e
% m3 J1 N- k6 g) X  _
! g' P" u3 C- `) v9 Z" o
: Y7 F2 H# z) o% J2 _' a而在开漏输出模式时，上方的 P-MOS 管完全不工作。如果我们控制输出为 0（低电平）时，则 P-MOS 管关闭，N-MOS 管导通，使输出接地，若控制输出为 1（无法直接输出高电平）时，则 P-MOS 管、N-MOS 管都关闭，所以引脚既不输出高电平，也不输出低电平，为高阻态。为正常使用时必须外部接上拉电阻（例如传统 51 单片机的 P0 口），参考下图。它具有“线与”的特性，也就是说，若有很多个开漏模式的引脚连接到一起时，只有当所有的引脚都输出高阻态，才由上拉电阻提供高电平，此高电平的电压为外部上拉电阻所接的电源电压。若其中一个引脚为低电平，那线路就相当于短路接地，使得整条线路都为低电平（0V）。
  K0 \- |/ F8 J/ r5 k; S7 P
3 p7 f, [0 g. ]' O, z

& A+ s0 p! w+ F$ `推挽输出模式一般应用在输出电平为 0V 和 3.3V 而且需要高速切换开关状态的场合。在使用 STM32 的过程中，除了必须使用开漏输出模式的场合，我们基本上都是使用推挽输出模式。

开漏输出我们一般应用于 I2C、SMBUS 通讯等需要“线与”功能的场合。除此之外，还应用于电路电压不匹配的场合，如需要输出 5V 的高电平，就可以在外部接一个上拉电阻，上拉电源为 5V ，并且把 GPIO 设置为开漏输出模式，当输出高阻态时，由上拉电阻和电源向外输出 5V 的电平，具体见下图：
0 o0 x" s9 U' M/ h9 U) x6 J
7 {9 B, N: ]4 \


1.2.3 数据输入输出寄存器
前面提到的双 MOS 管结构电路的输入信号，是由 GPIO“输出数据寄存器 GPIOx_ODR”提供的，因此我们通过修改输出数据寄存器的值就可以修改 GPIO 引脚的输出电平。而“置位/复位寄存器GPIOx_BSRR”可以通过修改输出数据寄存器的值从而影响电路的输出。
0 J( O+ E) r9 s% m
看 GPIO 结构框图的上半部分，GPIO 引脚经过内部的上、下拉电阻，可以配置成上/下拉输入，然后再连接到施密特触发器，信号经过触发器后，模拟信号转化为 0、1 的数字信号，然后存储在“输入数据寄存器 GPIOx_IDR”中，通过读取该寄存器就可以了解 GPIO 引脚的电平状态。
# q5 J9 Q# d# @, \3 M! W% O
1.2.4 复用功能输出
" d) p) \( C- {2 u+ Z6 Y) l“复用功能输出”中的“复用”是指 STM32 的其它片上外设对 GPIO 引脚进行控制，此时 GPIO 引脚用作该外设功能的一部分，算作第二用途（例如传统 51 单片机的 P3_0、P3_1 引脚可以用来进行 UART 通信）。从其他外设引出来的“复位功能输出信号”与 GPIO 本身的数据寄存器都连接到双 MOS 管结构的输入中，通过梯形结构作为开关切换选择。
& i% l  c' U; I
1 B' a, P$ x/ T6 ~  y例如我们使用 USART 串口通讯，需要用到某个 GPIO 引脚作为通讯发送引脚，这个时候就可以把该 GPIO 引脚配置成 USART 串口复用功能，由该串口外设控制该引脚，发送数据。
7 y; `. J  D+ U4 O% u
1.2.5 模拟输入输出
9 c* z/ k# N, j9 Z: G8 c" B6 T  w当 GPIO 引脚用于 ADC 采集电压的输入通道时，用作“模拟输入”功能，此时信号是不经过施密特触发器的，因为经过施密特触发器后信号只有 0、1 两种状态，所以 ADC 外设要采集到原始的模拟信号，信号源输入必须在施密特触发器之前。类似地，当 GPIO 引脚用于 DAC 作为模拟电压输出通道时，此时作为“模拟输出”功能，DAC 的模拟信号输出就不经过双 MOS 管结构，模拟信号直接输出到引脚。
( H  E/ w/ v$ g' W# Q" `1 p
1.3 GPIO 的工作模式
由上节可知，GPIO 的结构决定了 GPIO 可以配置成以下模式：
/ ^! c" I+ P, B9 m( p

1. typedef enum
   " x+ w  O' _/ f
2. {
   
3.         GPIO_Mode_AIN = 0x00,          // 模拟输入
   6 X, p) G# Y" m3 A/ o( \: i0 {
4.         GPIO_Mode_IN_FLOATING = 0x04,  // 浮空输入
   
5.         GPIO_Mode_IPD = 0x28,          // 下拉输入
   " _/ T; p' ]/ m/ X$ A% N
6.         GPIO_Mode_IPU = 0x48,          // 上拉输入
   9 I* s/ j! E' {& C+ J9 k: {* }
7.         GPIO_Mode_Out_OD = 0x14,       // 开漏输出
   
8.         GPIO_Mode_Out_PP = 0x10,       // 推挽输出
   
9.         GPIO_Mode_AF_OD = 0x1C,        // 复用开漏输出
   
10.         GPIO_Mode_AF_PP = 0x18         // 复用推挽输出
    ) M( S# g/ Z( p6 _/ k
11. } GPIOMode_TypeDef;
    1 z; [8 q( P* _( a. l

复制代码

. G/ g; n$ e+ Y$ v" t! _8 \! I在固件库中，GPIO 总共有 8 种细分的工作模式，稍加整理可以大致归类为以下三类：

1.3.1 输入模式 (模拟/浮空/上拉/下拉)
8 E( U* `$ A  M) n: V8 D在输入模式时，施密特触发器打开，输出被禁止，可通过输入数据寄存器 GPIOx_IDR 读取 I/O 状态。其中输入模式，可设置为上拉、下拉、浮空和模拟输入四种。上拉和下拉输入很好理解，默认的电平由上拉或者下拉决定。浮空输入的电平是不确定的，完全由外部的输入决定，一般接按键的时候用的是这个模式。模拟输入则用于 ADC 采集。

) z7 O- C- V& R" F! t/ D& Z1.3.2 输出模式 (推挽/开漏)
% F3 A: }' t1 d8 Z- a/ y/ [在输出模式中，推挽模式时双 MOS 管以轮流方式工作，输出数据寄存器 GPIOx_ODR 可控制 I/O输出高低电平。开漏模式时，只有 N-MOS 管工作，输出数据寄存器可控制 I/O 输出高阻态或低电平。输出速度可配置，有 2MHz、10MHz、50MHz 的选项。此处的输出速度即 I/O 支持的高低电平状态最高切换频率，支持的频率越高，功耗越大，如果功耗要求不严格，把速度设置成最大即可。在输出模式时施密特触发器是打开的，即输入可用，通过输入数据寄存器 GPIOx_IDR 可读取 I/O的实际状态。
( f$ a: q: Q; @0 u
1 c; d+ m- R8 `% c1.3.3 复用功能 (推挽/开漏)
复用功能模式中，输出使能，输出速度可配置，可工作在开漏及推挽模式，但是输出信号源于其它外设，输出数据寄存器 GPIOx_ODR 无效；输入可用，通过输入数据寄存器可获取 I/O 实际状态，但一般直接用外设的寄存器来获取该数据信号。
# J6 F4 z3 n6 P/ y% M
) k' j) I+ b/ B- u6 M通过对 GPIO 寄存器写入不同的参数，就可以改变 GPIO 的工作模式，要了解具体寄存器时一定要查阅 《STM32F10X-中文参考手册》 中对应外设的寄存器说明。在 GPIO 外设中，控制端口高低控制寄存器 CRH 和 CRL 可以配置每个 GPIO 的工作模式和工作的速度，每 4 个位控制一个 IO，CRH 控制端口的高八位，CRL 控制端口的低 8 位，具体的看 CRH 和 CRL 的寄存器描述。
) c6 ~3 Y& d4 ?! {* C8 ]' N: L
1.3.4 总结
每个 I/O 端口可以自由编程，但 I/O 端口寄存器必须按 32 位被访问。 STM32 的很多 I/O 端口都兼容 5V 的，这些 I/O 端口在与 5V 电压的外设连接时很有优势，具体哪些 I/O 端口是兼容 5V 的，可以从芯片的数据手册引脚描述章节查到。

1 P$ t. m  O0 V) t+ w5 C3 m" vSTM32 的每个 I/O 端口都有 7 个寄存器来控制。常用的 I/O 端口寄存器只有 4 个，分别为 CRL、CRH、IDR、ODR。CRL 和 CRH 控制着每个 I/O 端口的模式及输出速率。STM32 的端口配置表如下图所示：
" w$ s4 N7 F# B% l0 _5 z" @  f

5 k' _; ?+ H; B& N0 C- H6 k! o

2 GPIO 端口的配置
  X) O+ b0 y" L, E2.1 端口配置低寄存器（CRL）
端口配置低寄存器（GPIOx_CRL）(x = A…E)，如下图所示：



( U/ }1 I6 C9 P配置方法：
: w5 b/ J% T7 p# t" z$ ^
7 H" D8 P5 c$ o) b5 @! j/ k
$ i7 ^7 |. H- w+ E# n% c% N
2.2 端口配置高寄存器（CRH）
端口配置高寄存器(GPIOx_CRH) (x=A…E)，如下图所示：
$ L0 m7 y! A1 h' O) r
5 [& j1 G7 f- k% m, B$ ^' J* h
8 u9 _/ K6 W& A/ N
配置方法：



例如，使用 GPIOA 控制的是一个 Led 灯，可以选择通用推挽输出，设置速度为 10MHz，实现代码为：
* `( z/ O* `4 S0 c$ j
5 o5 u, r  T1 Y# q% F' |) d, z

1. GPIOA -> CRH = 0x01010101;
   3 g3 q6 y) K' s5 H1 O( r

复制代码

9 F' _! |3 k% c/ s2.3 端口输入数据寄存器（IDR）
/ D) s2 C! M. b& Y' e端口输入数据寄存器(GPIOx_IDR) (x=A…E)，如下图所示：

! `  [! l) \4 Y


配置方法：
5 W4 U9 H9 ?* K" O! m: e
( \& x$ F' C$ J. s


" d+ }% f' U% u/ P. ?/ G2.4 端口输出数据寄存器（ODR）
端口输出数据寄存器(GPIOx_ODR) (x=A…E)，如下图所示：

! ~5 c# Y+ `! Q$ ?# R' u8 L: p
' r. s5 p, O  J  l  C, j. p: V
* }+ N- j) U0 ~0 t5 F  A" n配置方法：

( X3 P2 {$ \" w. r! i

' e% X$ J* ]% `+ ^7 [2 J. Y
例如：

1. GPIOA -> ODR = 0x0000; // 灯灭
   
2. GPIOA -> ODR = 0xFFFF; // 灯亮
   5 a5 ~0 ^) ^2 }7 y, e8 Y  r6 x) C

复制代码

3 寄存器点亮 LED 灯
5 y0 `+ ?5 f: A' \5 F2 T3.1 硬件连接
在本文中 STM32 芯片与 LED 灯的连接见下图：
. z9 g6 \7 a% A5 l2 z+ B, K


+ m% m% ]8 v( t; }, Z- W这是一个 RGB 灯，里面由红蓝绿三个小灯构成，使用 PWM 控制时可以混合成 256 不同的颜色。

图中从 3 个 LED 灯的阳极引出连接到 3.3V 电源，阴极各经过 1 个限流电阻引入至 STM32 的 3 个GPIO 引脚中，所以我们只要控制这三个引脚输出高低电平，即可控制其所连接 LED 灯的亮灭。如果您的实验板 STM32 连接到 LED 灯的引脚或极性不一样，只需要修改程序到对应的 GPIO 引脚即可，工作原理都是一样的。

我们的目标是把 GPIO 的引脚设置成推挽输出模式并且默认下拉，输出低电平，这样就能让 LED灯亮起来了。

6 ^0 ]7 T! [# _3 d: T/ Y2 [3.2 启动文件
3 G/ o6 M8 c4 X名为“startup_stm32f10x_hd.s”的文件，它里边使用汇编语言写好了基本程序，当 STM32 芯片上电启动的时候，首先会执行这里的汇编程序，从而建立起 C 语言的运行环境，所以我们把这个文件称为启动文件。该文件使用的汇编指令是 Cortex-M3 内核支持的指令，可参考 《Cortex-M3 权威指南》 中指令集章节。

1 m  G$ J- ^1 c; Nstartup_stm32f10x_hd.s 文件由官方提供，一般有需要也是在官方的基础上修改，不会自己完全重写。该文件从 ST 固件库里面找到，找到该文件后把启动文件添加到工程里面即可。不同型号的芯片以及不同编译环境下使用的汇编文件是不一样的，但功能相同。

其功能如下
初始化堆栈指针 SP;
初始化程序计数器指针 PC;
设置堆、栈的大小;
初始化中断向量表;
配置外部 SRAM 作为数据存储器（这个由用户配置，一般的开发板可没有外部 SRAM）;
调用 SystemIni() 函数配置 STM32 的系统时钟。
设置 C 库的分支入口“__main”（最终用来调用 main 函数）;
8 n. ?" D& n1 W. W: O% j& W6 e$ Q/ ^
4 u' e. B$ z4 D9 G& Y! |* {
, ~* }/ t( }& ^( W

1. ;Reset handler
   
2. Reset_Handler        PROC
     Z2 V3 `' T9 d- C3 x8 m
3.                                 EXPORT Reset_Handler [WEAK]
   
4.         IMPORT SystemInit
   
5.         IMPORT __main
   
6. 
   : t+ X, @$ |) ~/ r$ `- Y
7.          LDR R0, = SystemInit
   5 `- i9 v& r, b/ ^( L2 R, N
8.         BLX R0
   " [8 E- U6 ~7 @& y8 g
9.         LDR R0, = __main
   
10.         BX R0
    
11.         ENDP
    

复制代码

开头的是程序注释，在汇编里面注释用的是“;”，相当于 C 语言的“//”注释符
) p; E: C1 |! z  u! [
第二行是定义了一个子程序：Reset_Handler。PROC 是子程序定义伪指令。这里就相当于 C 语言里定义了一个函数，函数名为 Reset_Handler。

第三行 EXPORT 表示 Reset_Handler 这个子程序可供其他模块调用。相当于 C 语言的函数声明。关键字 [WEAK] 表示弱定义，如果编译器发现在别处定义了同名的函数，则在链接时用别处的地址进行链接，如果其它地方没有定义，编译器也不报错，以此处地址进行链接。

第四行和第五行 IMPORT 说明 SystemInit 和 __main 这两个标号在其他文件，在链接的时候需要到其他文件去寻找。相当于 C 语言中，从其它文件引入函数声明。以便下面对外部函数进行调用。

SystemInit 需要由我们自己实现，即我们要编写一个具有该名称的函数，用来初始化 STM32 芯片的时钟，一般包括初始化 AHB、APB 等各总线的时钟，需要经过一系列的配置 STM32 才能达到稳定运行的状态。其实这个函数在固件库里面有提供，官方已经为我们写好。

' h% b5 H+ g7 L/ P! u__main 其实不是我们定义的 (不要与 C 语言中的 main 函数混淆)，这是一个 C 库函数，当编译器编译时，只要遇到这个标号就会定义这个函数，该函数的主要功能是：负责初始化栈、堆，配置系统环境，并在函数的最后调用用户编写的 main 函数，从此来到 C 的世界。
7 s- M/ Y4 q, X$ ^
+ T* s2 C+ q0 I; s, U7 T$ z- n2 i5 ]第六行把 SystemInit 的地址加载到寄存器 R0。
( M1 q" m$ _: L4 R- Y
第七行程序跳转到 R0 中的地址执行程序，即执行 SystemInit 函数的内容。
+ S. w' l/ X" ^+ [( @3 T# U5 y
第八行把 __main 的地址加载到寄存器 R0。
$ S$ O7 {( ~- C. F& p
* ^  ], w! b0 l0 n2 q% C: q第九行程序跳转到 R0 中的地址执行程序，即执行 __main 函数，执行完毕之后就去到我们熟知的 C 世界，进入 main 函数。
  |1 L/ O" R& K8 e! G- T
, S/ Z" ?* w2 n/ X6 z% |2 E第十行表示子程序的结束。
7 y$ t  o* M' K7 s+ j! E& y0 S
  n9 o" D% Z: q9 V) h" W总之，看完这段代码后，了解到如下内容即可：我们需要在外部定义一个 SystemInit 函数设置 STM32 的时钟；STM32 上电后，会执行 SystemInit 函数，最后执行我们 C 语言中的 main 函数。

3.3 stm32f10x.h 文件
看完启动文件，那我们立即写 SystemInit 和 main 函数吧？别着急，定义好了 SystemInit 函数和 main 我们又能写什么内容？连接 LED 灯的 GPIO 引脚，是要通过读写寄存器来控制的，就这样空着手，如何控制寄存器。我们知道寄存器就是给一个已经分配好地址的特殊的内存空间取的一个别名，这个特殊的内存空间可以通过指针来操作。在编程之前我们要先实现寄存器映射，有关寄存器映射的代码都统一写在 stm32f10x.h 文件中。
( K6 s$ {# f+ T/ S

1. /* 片上外设基地址 */
   
2. #define PERIPH_BASE         ((unsigned int)0x40000000)
   ) M1 N. g/ L1 |; P2 m. j# ?( Q
3. 
   * q1 G0 r" Z$ |2 p3 S) c1 F
4. /* 总线基地址，GPIO 都挂载到 APB2 上 */
   ! P5 R3 |  o* {; S) j/ U2 W: e3 y
5. #define APB2PERIPH_BASE     (PERIPH_BASE + 0x10000)
   
6. /* AHB 总线基地址 */
   $ r: ^% I. i- c8 K' A, M3 ^$ A
7. #define AHBPERIPH_BASE      (PERIPH_BASE + 0x20000)
   ; z- U3 ?! n! U, \# P  O7 Z7 P5 B
8. 
   , a% ?* J. T$ b
9. /*GPIOB 外设基地址 */
   
10. #define GPIOB_BASE          (APB2PERIPH_BASE + 0x0C00)
    - N2 X: c! [, K) ]! }
11. 
    
12. /* GPIOB 寄存器地址, 强制转换成指针 */
    1 J( q% E2 h* \; a4 k% E4 a: S
13. #define GPIOB_CRL           *(unsigned int*)(GPIOB_BASE+0x00)
    ( S. X6 Z) J, U5 R
14. #define GPIOB_CRH           *(unsigned int*)(GPIOB_BASE+0x04)
    $ F8 h% o. x- L9 e. M* _( w
15. #define GPIOB_IDR           *(unsigned int*)(GPIOB_BASE+0x08)
    
16. #define GPIOB_ODR           *(unsigned int*)(GPIOB_BASE+0x0C)
    % M0 a1 R, P  e9 @: |
17. #define GPIOB_BSRR          *(unsigned int*)(GPIOB_BASE+0x10)
    7 m: o  I; _$ ^1 x/ L* S- a: ~
18. #define GPIOB_BRR           *(unsigned int*)(GPIOB_BASE+0x14)
    & ^0 t) s- t2 s( E
19. #define GPIOB_LCKR          *(unsigned int*)(GPIOB_BASE+0x18)
    , d4 Z: ]) E& u$ C/ [7 z
20. 
    5 {' T6 @  {% I4 `' j. j
21. /*RCC 外设基地址 */
    ( b$ l% H% L: ~* V8 y) @! u
22. #define RCC_BASE           (AHBPERIPH_BASE + 0x1000)
    6 y1 w5 F/ s$ M4 ]
23. /*RCC 的 AHB1 时钟使能寄存器地址, 强制转换成指针 */
    6 H" I! C. T8 Z/ t) s
24. #define RCC_APB2ENR         *(unsigned int*)(RCC_BASE+0x18)
    , A+ E+ {& y* U1 Y' O& B

复制代码

* t  D7 D. b- t3 {# O1 H/ P" ?代码的最后两段是 RCC 外设寄存器的地址定义，RCC 外设是用来设置时钟的，本实验中只要了解到使用 GPIO 外设必须开启它的时钟即可。
, m9 W% [: K  `/ F
3.4 main 文件
6 q. g& W( b  ^9 f; V5 d现在就可以开始编写程序，在 main 文件中先编写一个 main 函数，里面什么都没有，暂时为空。
. G6 S) f$ q: `8 ^) _+ f! m

1. int main (void)
   
2. {
   ) F. i' X. @. H  i
3. }
   

复制代码

此时直接编译的话，会出现如下错误：
Error: L6218E: Undefined symbol SystemInit (referred from startup_stm32f10x.o)
  {5 m/ N4 c4 c2 z+ Q
" X/ [  I) k' ?错误提示 SystemInit 没有定义。从分析启动文件时我们知道，Reset_Handler 调用了该函数用来始化 SMT32 系统时钟，为了简单起见，我们在 main 文件里面定义一个 SystemInit 空函数，什么也不做，为的是骗过编译器，把这个错误去掉。关于配置系统时钟我们在后面再写。当我们不配置系统时钟时，STM32 会把 HSI 当作系统时钟，HSI=8M，由芯片内部的振荡器提供。我们在main 中添加如下函数：

1. // 函数为空，目的是为了骗过编译器不报错
   
2. void SystemInit(void)
   
3. {
     G( V6 x4 D0 y% P" W4 p7 M0 Y0 A9 n
4. }
   5 b! y7 A+ g8 ]( I& Z6 l9 T0 T

复制代码

( S. y) @0 m2 N( K  F: \$ R3.5 GPIO 模式
首先我们把连接到 LED 灯的 GPIO 引脚 PB0 配置成输出模式，即配置 GPIO 的端口配置低寄存器 CRL，见图： GPIO 端口控制低寄存器 CRL 。

% n( r! y$ `- x& G, jCRL 中包含 0-7 号引脚，每个引脚占用 4 个寄存器位。MODE 位用来配置输出的速度，CNF 位用来配置各种输入输出模式。在这里我们把 PB0 配置为通用推挽输出，输出的速度为 10M。

1. // 清空控制 PB0 的端口位
   ! x. ^* Z3 P2 d% }$ N* ^
2. GPIOB_CRL &= ~( 0x0F<< (4*0));
   8 s. s# c' |: x! W
3. // 配置 PB0 为通用推挽输出，速度为 10M
   
4. GPIOB_CRL |= (1<<4*0);
   

复制代码

0 V6 z# V  z& Q6 y3.6 控制引脚输出电平
' G' f1 x$ i: n! t' ^在输出模式时，对端口位设置/清除寄存器 BSRR 寄存器、端口位清除寄存器 BRR 和 ODR 寄存器写入参数即可控制引脚的电平状态，其中操作 BSRR 和 BRR 最终影响的都是 ODR 寄存器，然后再通过 ODR 寄存器的输出来控制 GPIO。为了一步到位，我们在这里直接操作 ODR 寄存器来控制 GPIO 的电平。

6 E8 s8 }3 c. Y; i5 X! f
& M! f; q  _, o& Y

1. // PB0 输出低电平
   ; G: n* o5 C- X/ }7 l
2. GPIOB_ODR &= ~(1<<0);
   " Y  X( ^$ f2 c2 h, U

复制代码

3.7 开启外设时钟
设置完 GPIO 的引脚，控制电平输出，以为现在总算可以点亮 LED 了吧，其实还差最后一步。由于 STM32 的外设很多，为了降低功耗，每个外设都对应着一个时钟，在芯片刚上电的时候这些时钟都是被关闭的，如果想要外设工作，必须把相应的时钟打开。
3 o/ d, F8 b9 R8 W) o3 P
/ S. D# S: N0 W3 u; VSTM32 的所有外设的时钟由一个专门的外设来管理，叫 RCC（reset and clockcontrol），RCC 在《STM32 中文参考手册》的第六章。
  G% D- t" n* Q, v# A
+ H: o6 b" K0 L$ z2 M' ?: D; T所有的 GPIO 都挂载到 APB2 总线上，具体的时钟由 APB2 外设时钟使能寄存器 (RCC_ APB2ENR)来控制。
0 L- H4 d/ J+ E. x% y

1. // 开启 GPIOB 端口 时钟
   # A% t5 w% u$ M* l/ v
2. RCC_APB2ENR |= (1<<3);
   

复制代码

+ d$ ^, A1 D$ B8 d3.8 总结
使用寄存器来控制 GPIO 主要涉及几个寄存器，RCC -> APB2ENR，GPIOB -> CRH，GPIOB -> ODR 。STM32 普通 GPIO 端口的使用大至步骤如下：
1.先开启对应 GPIO 端口时钟（RCC -> APB2ENR）；
2.配置 GPIO 端口（GPIOB -> CRH）；
+ ?% p5 w6 u; _8 O- z0 h3.给 GPIO 端口赋值 （GPIOB -> ODR）
) G6 h0 F, ?; r% K4 g, {4 {3 v7 Y
这 3 步完成一个 GPIO 端口的最基本操作，代码如下所示：

1. int main()
   + s6 C2 R8 n$ e) I
2. {
   6 p8 t5 o4 }* q2 s
3.         // 开启 GPIOB 端口 时钟
   
4.         RCC_APB2ENR |= (1<<3);
   
5.        
   
6.         // 清空控制 PB0 的端口位
   5 E$ o. {- U' }: l1 Q
7.         GPIOB_CRL &= ~( 0x0F<< (4*0));
   
8.         // 配置 PB0 为通用推挽输出，速度为 10M
     d( W: u% G; r/ r* d5 V
9.         GPIOB_CRL |= (1<<4*0);
   1 ~; e. M- W1 ~! ^) ^# y
10.        
    
11.         // PB0 输出低电平
    5 r  Y* ]! d( O9 v0 Z. Q
12.         GPIOB_ODR &= ~(1<<0);
    
13.         while (1);
    
14. }
    ( c1 {! D, R/ v1 N, z; ^( x; \

复制代码

4 固件库函数驱动 LED 点灯
% i& f/ T% q% m2 |. W3 C# ]4.1 什么是固件库函数？
固件库是指“STM32 标准函数库”，它是由 ST 公司针对 STM32 提供的函数接口，即API (Application Program Interface)，开发者可调用这些函数接口来配置 STM32 的寄存器，使开发人员得以脱离最底层的寄存器操作，有开发快速，易于阅读，维护成本低等优点。
* t& ?( K8 _$ I9 }# x, ?
9 l6 c1 C8 i. N9 Z4 z9 G- g# _% ]! V当我们调用库 API 的时候不需要挖空心思去了解库底层的寄存器操作，就像当年我们刚开始学习 C 语言的时候，用 prinft() 函数时只是学习它的使用格式，并没有去研究它的源码实现，但需要深入研究的时候，经过千锤百炼的库源码就是最佳学习范例。

实际上，库是架设在寄存器与用户驱动层之间的代码，向下处理与寄存器直接相关的配置，向上为用户提供配置寄存器的接口。库开发方式与直接配置寄存器方式的区别见图：

* D& _5 c' {. j! c1 A  g" H- Q+ U& x


5 M1 W! D" \2 E: n. z1 H; `7 d4.2 为什么要学库函数
在以前 8 位机时代的程序开发中，一般直接配置芯片的寄存器，控制芯片的工作方式，如中断，定时器等。配置的时候，常常要查阅寄存器表，看用到哪些配置位，为了配置某功能，该置 1 还是置 0。这些都是很琐碎的、机械的工作，因为 8 位机的软件相对来说较简单，而且资源很有限，所以可以直接配置寄存器的方式来开发。
; K( R. E7 U1 T% E9 {& K- W' R% g
; Z" p, y( W" q; a5 b9 n. @8 C对于 STM32，因为外设资源丰富，带来的必然是寄存器的数量和复杂度的增加，这时直接配置寄存器方式的缺陷就突显出来了：
: ?  _' m) n; i6 [1.开发速度慢
4 a8 X( g; S; d- z$ M1 X2.程序可读性差
3.维护复杂

这些缺陷直接影响了开发效率，程序维护成本，交流成本。库开发方式则正好弥补了这些缺陷。而坚持采用直接配置寄存器的方式开发的程序员，会列举以下原因：
1.具体参数更直观
8 t3 }- w2 f0 R2.程序运行占用资源少

相对于库开发的方式，直接配置寄存器方式生成的代码量的确会少一点，但因为 STM32 有充足的资源，权衡库的优势与不足，绝大部分时候，我们愿意牺牲一点 CPU 资源，选择库开发。一般只有在对代码运行时间要求极苛刻的地方，才用直接配置寄存器的方式代替，如频繁调用的中断服务函数。
$ u/ F0 f" o1 j5 k
对于库开发与直接配置寄存器的方式，就好比编程是用汇编好还是用 C 好一样。在 STM32F1 系列刚推出函数库时引起程序员的激烈争论，但是，随着 ST 库的完善与大家对库的了解，更多的程序员选择了库开发。现在 STM32F1 系列和 STM32F4 系列各有一套自己的函数库，但是它们大部分是兼容的，F1 和 F4 之间的程序移植，只需要小修改即可。而如果要移植用寄存器写的程序，那简直跟脱胎换骨差不多。

) E& G# X; y) [! m6 `6 q5 n用库来进行开发，市场已有定论，用户群说明了一切，但对于 STM32 的学习仍然有人认为用寄存器好，而且汇编不是还没退出大学教材么？认为这种方法直观，能够了解到是配置了哪些寄存器，怎样配置寄存器。事实上，库函数的底层实现恰恰是直接配置寄存器方式的最佳例子，它代替我们完成了寄存器配置的工作，而想深入了解芯片是如何工作的话，只要直接查看库函数的最底层实现就能理解，相信你会为它严谨、优美的实现方式而陶醉，要想修炼 C 语言，就从 ST 的库开始吧。所以在以后的章节中，使用软件库是我们的重点，而且通过讲解库 API 去高效地学习 STM32 的寄存器，并不至于因为用库学习，就不会用寄存器控制 STM32 芯片。

4.3 软件设计
$ i! M2 ~% s, f! X/ }为了使工程更加有条理，我们把 LED 灯控制相关的代码独立分开存储，方便以后移植。在“工程模板”之上新建“bsp_led.c”及“bsp_led.h”文件，其中的“bsp”即 Board Support Packet 的缩写 (板级支持包)，这些文件也可根据您的喜好命名，这些文件不属于 STM32 标准库的内容，是由我们自己根据应用需要编写的。
  }8 y) ]$ r& H& B7 |$ G6 x
" D& S, F8 J( v$ _0 b: u  k1 V4.3.1 编程要点
4 Y( F& A7 a& I( l6 @& L5 _0 D  ?使能 GPIO 端口时钟；
8 E, x2 p2 s; C# k- F初始化 GPIO 目标引脚为推挽输出模式；
* P7 t1 u/ c  J; w编写简单测试程序，控制 GPIO 引脚输出高、低电平。
1 d3 V# M! B; c# \
4.4 代码分析
4.4.1 LED 引脚宏定义
# @) L+ a% q, J) w( m/ F在编写应用程序的过程中，要考虑更改硬件环境的情况，例如 LED 灯的控制引脚与当前的不一样，我们希望程序只需要做最小的修改即可在新的环境正常运行。这个时候一般把硬件相关的部分使用宏来封装，若更改了硬件环境，只修改这些硬件相关的宏即可，这些定义一般存储在头文件，即本例子中的“bsp_led.h”文件中

1. #define LED_GPIO_PORT       GPIOB
   
2. #define LED_GPIO_PIN_0      GPIO_Pin_0
   
3. #define LED_GPIO_PIN_1      GPIO_Pin_1
   
4. #define LED_GPIO_PIN_5      GPIO_Pin_5
   " X* g7 r2 ^& G- j
5. 
   
6. #define LED_GPIO_CLK        RCC_APB2Periph_GPIOB
   

复制代码

以上代码分别把控制 LED 灯的 GPIO 端口、GPIO 引脚号以及 GPIO 端口时钟封装起来了。在实际控制的时候我们就直接用这些宏，以达到应用代码硬件无关的效果。

- P/ `% w3 v. l3 R$ E其中的 GPIO 时钟宏“RCC_APB2Periph_GPIOB”是 STM32 标准库定义的 GPIO 端口时钟相关的宏，它的作用与“GPIO_Pin_x”这类宏类似，是用于指示寄存器位的，方便库函数使用，下面初始化 GPIO 时钟的时候可以看到它的用法。
& B! [4 l" I% D8 L' t
! w9 B# U% o+ g+ s! ~4.4.2 LED GPIO 初始化函数
利用上面的宏，编写 LED 灯的初始化函数（LED_Congif()）。
$ g) p! w* J( x8 R# U5 W& j

1. void Led_Config(void)
   ' G; `6 J' h9 b$ Y
2. {
   * _) f3 ]! I% d$ \0 I& o/ S
3.         GPIO_InitTypeDef GPIO_InitStruct1;
   9 |' u) D. C$ |; i- G4 f0 W, k3 W
4.        
   . W5 H2 s. G+ `& F' {5 M0 L
5.         RCC_APB2PeriphClockCmd(LED_GPIO_CLK,ENABLE);
   
6.        
   $ r! [7 M: X9 u1 R! c
7.         GPIO_InitStruct1.GPIO_Pin = LED_GPIO_PIN_0;
   % X  q, R+ Q: W  \
8.         GPIO_InitStruct1.GPIO_Mode = GPIO_Mode_Out_PP;
   
9.         GPIO_InitStruct1.GPIO_Speed = GPIO_Speed_50MHz;
   
10.        
    
11.         GPIO_Init(LED_GPIO_PORT,&GPIO_InitStruct1);
    
12. }
    / x* G6 J- ]8 x$ c2 m; ~

复制代码

整个函数与“构建库函数雏形”章节中的类似，主要区别是硬件相关的部分使用宏来代替，初始化 GPIO 端口时钟时也采用了 STM32 库函数，函数执行流程如下：
$ y+ n4 l; a2 c6 {9 W' s1.使用 GPIO_InitTypeDef 定义 GPIO 初始化结构体变量，以便下面用于存储 GPIO 配置。
8 p% I5 I2 R. |1 q+ O7 z6 a" c; I2.调用库函数 RCC_APB2PeriphClockCmd 来使能 LED 灯的 GPIO 端口时钟，在前面的章节中我们是直接向 RCC 寄存器赋值来使能时钟的，不如这样直观。该函数有两个输入参数，第一个参数用于指示要配置的时钟，如本例中的“RCC_APB2Periph_GPIOB”；函数的第二个参数用于设置状态，可输入“Disable”关闭或“Enable”使能时钟。
& G* C) p5 c$ U3 B0 f! ]% {3.向 GPIO 初始化结构体赋值，把引脚初始化成推挽输出模式，其中的 GPIO_Pin 使用宏“LEDx_GPIO_PIN”来赋值，使函数的实现方便移植。
4.使用以上初始化结构体的配置，调用 GPIO_Init 函数向寄存器写入参数，完成 GPIO 的初始化，这里的 GPIO 端口使用“LEDx_GPIO_PORT”宏来赋值，也是为了程序移植方便。
5.使用同样的初始化结构体，只修改控制的引脚和端口，初始化其它 LED 灯使用的 GPIO 引脚。

4.4.3 主函数

1. #include <stm32f10x.h>
     S' `: o1 H1 i
2. #include "BSP_LED.h"
   
3. 
   " J% {8 ^# L1 c' R5 Z( x
4. void Delay (uint32_t n)
   & P, Z2 i8 M1 U4 i6 Q
5. {
   
6.         while(n --);
   
7. }
   , \0 m; V6 S" I) Y5 h& M# g
8. 
   
9. int main(void)
   
10. {
    , w5 L7 C$ l; N
11.         Led_Config();
    $ p9 F7 Q5 M3 }: V
12.         while(1)
    
13.         {
    * i* h: N& D: D) N/ P0 {6 `
14.                 GPIO_SetBits(LED_GPIO_PORT,LED_GPIO_PIN_0);
    
15.                 Delay(0x2FFFFF);
    
16.                 GPIO_ResetBits(LED_GPIO_PORT,LED_GPIO_PIN_0);
    9 W/ V( T$ b: j+ ?% U9 d
17.                 Delay(0x2FFFFF);
    
18.         }
    
19. }
    " l# S$ i# ]7 p2 `2 J) B* J% z
20. 
    

复制代码

在 main 函数中，调用我们前面定义的 LED_GPIO_Config 初始化好 LED 的控制引脚，然后直接调用各种控制 LED 灯亮灭的函数来实现 LED 灯的控制。
' d0 i/ r/ I$ g3 [' Y8 |8 E. x
5 a+ e2 K9 B0 G5 M以上，就是一个使用 STM32 标准软件库开发应用的流程。
/ K3 {- [$ Z2 d————————————————
版权声明：倾晨灬雨曦
) f' ]2 n; H. K4 \( t

3 {4 \0 x3 A, B& j3 i. G