本文将以STM32F10x为例，对标准库开发进行概览。主要分为三块内容：
+ a1 o9 F$ T8 d·STM32系统结构
·寄存器
2 B2 r% a7 [( l" P/ J( I# D·通过点灯案例，详解如何基于标准库构建STM32工程

% ~9 Z. T) M" i4 B- G; i（文末有STM32、物联网开发相关的网盘资料，包括物联网开发从基础到实战、IoT-ARM结构下的各类智能产品的设计、STM32的开发、全国电赛优秀作品分析等，如有需要请自行领取）

STM32系统结构



5 Y5 |7 I3 B: `7 C9 oSTM32f10xxx系统结构

内核IP
+ b( T. s2 Y6 f) X! e! w从结构框图上看，Cortex-M3内部有若干个总线接口，以使CM3能同时取址和访内（访问内存），它们是：指令存储区总线（两条）、系统总线、私有外设总线。有两条代码存储区总线负责对代码存储区（即 FLASH 外设）的访问，分别是 I-Code 总线和 D-Code 总线。
+ V5 f: w, e, i& L/ i; b2 z
( H8 E/ V3 C, N2 e2 J0 xI-Code用于取指，D-Code用于查表等操作，它们按最佳执行速度进行优化。

9 v5 q2 ]! E9 \# E7 v系统总线（System）用于访问内存和外设，覆盖的区域包括SRAM，片上外设，片外RAM，片外扩展设备，以及系统级存储区的部分空间。

私有外设总线负责一部分私有外设的访问，主要就是访问调试组件。它们也在系统级存储区。
1 Y$ r& ~0 o$ p* [% z3 ?
* g2 I: t% G4 c还有一个DMA总线，从字面上看，DMA是data memory access的意思，是一种连接内核和外设的桥梁，它可以访问外设、内存，传输不受CPU的控制，并且是双向通信。简而言之，这个家伙就是一个速度很快的且不受老大控制的数据搬运工。
' D1 P+ a4 @1 t7 I3 x1 M+ P/ s# ^1 t

处理器外设（内核之外的外设）
从结构框图上看，STM32的外设有串口、定时器、IO口、FSMC、SDIO、SPI、I2C等，这些外设按照速度的不同，分别挂载到AHB、APB2、APB1这三条总线上。
* v" V8 L  a: M5 _7 z

2 ~$ y2 d8 ~7 n9 S4 M# y: @寄存器
) P3 Z: N+ F2 l+ b, N) U什么是寄存器？寄存器是内置于各个IP外设中，是一种用于配置外设功能的存储器，并且有想对应的地址。一切库的封装始于映射。
$ s, w9 D. b  l/ v+ A1 s- h
0 l$ a! y! r/ F/ l

! T6 ^7 o4 W/ H- }

) G7 q' _+ p9 m) m7 r是不是看的眼都花了，如果进行寄存器开发，就需要怼地址以及对寄存器进行字节赋值，不仅效率低而且容易出错。

4 D4 d5 z. S4 N' L9 T库的存在就是为了解决这类问题，将代码语义化。语义化思想不仅仅是嵌入式有的，前端代码也在追求语义特性。
- U" \6 v# ~8 Q2 f; W
6 L: s* d1 k9 |( A# a从点灯开始学习STM32
) g- M. W3 `( V

% ?) X, {& D* F" j- W  X0 ?
内核库文件分析
& u+ m( J2 o- [3 o* u. ccor_cm3.h
这个头文件实现了：
, a& k2 b) g& Y! t- o9 E1、内核结构体寄存器定义。
0 `: H' h6 T; M" S2、内核寄存器内存映射。
3、内存寄存器位定义。跟处理器相关的头文件stm32f10x.h实现的功能一样，一个是针对内核的寄存器，一个是针对内核之外，即处理器的寄存器。

9 T* _0 e& F% W2 k9 i: c  v+ Smisc.h
内核应用函数库头文件，对应stm32f10x_xxx.h。
7 n) t2 Y/ S8 J
$ ~, t& G" \; B! Q  qmisc.c
9 s, g% z* b) d7 O7 O内核应用函数库文件，对应stm32f10x_xxx.c。在CM3这个内核里面还有一些功能组件，如NVIC、SCB、ITM、MPU、CoreDebug，CM3带有非常丰富的功能组件，但是芯片厂商在设计MCU的时候有一些并不是非要不可的，是可裁剪的，比如MPU、ITM等在STM32里面就没有。

: ?* w8 {; R7 m. M6 n6 N其中NVIC在每一个CM3内核的单片机中都会有，但都会被裁剪，只能是CM3 NVIC的一个子集。在NVIC里面还有一个SysTick，是一个系统定时器，可以提供时基，一般为操作系统定时器所用。misc.h和mics.c这两个文件提供了操作这些组件的函数，并可以在CM3内核单片机直接移植。

  u5 @/ d5 k. p) y* L处理器外设库文件分析
! q2 C" y+ q2 k; f. e4 Y- Ystartup_stm32f10x_hd.s
这个是由汇编编写的启动文件，是STM32上电启动的第一个程序，启动文件主要实现了
! S7 V( X' \1 r/ t初始化堆栈指针 SP；
: S& P7 f" m# J4 d  W/ ^  u设置 PC 指针=Reset_Handler ；
设置向量表的地址，并 初始化向量表，向量表里面放的是 STM32 所有中断函数的入口地址
' w+ [3 V7 n4 w3 ^! V6 v调用库函数 SystemInit，把系统时钟配置成 72M，SystemInit 在库文件 stytem_stm32f10x.c 中定义；
7 j: z% K) }+ b& d* ]  u/ d跳转到标号_main，最终去到 C 的世界。
+ J( ~0 K/ D" N% B8 X% k% B
system_stm32f10x.c
这个文件的作用是里面实现了各种常用的系统时钟设置函数，有72M，56M，48， 36，24，8M，我们使用的是是把系统时钟设置成72M。

) P) |5 X+ |" _/ c8 \7 [) JStm32f10x.h
8 a' k5 l: p- z6 H7 z4 {7 l2 }这个头文件非常重要，这个头文件实现了：
, o0 j! G2 B) ~: {$ O) c1、处理器外设寄存器的结构体定义。
5 T( I$ }7 M$ [) h0 ?7 C. F2、处理器外设的内存映射。
' e1 W9 \: D7 i6 T1 Y7 G7 J3、处理器外设寄存器的位定义。
  E1 Q# H* S8 v. c8 ?2 R* A$ W
5 c1 e6 q9 |& i  i0 m6 R关于 1 和 2 我们在用寄存器点亮 LED 的时候有讲解。
" Y( X; v  v+ ?$ s  r& Z/ P
其中 3：处理器外设寄存器的位定义，这个非常重要，具体是什么意思？

我们知道一个寄存器有很多个位，每个位写 1 或者写 0 的功能都是不一样的，处理器外设寄存器的位定义就是把外设的每个寄存器的每一个位写 1 的 16 进制数定义成一个宏，宏名即用该位的名称表示，如果我们操作寄存器要开启某一个功能的话，就不用自己亲自去算这个值是多少，可以直接到这个头文件里面找。

) Q  t# n9 a) g我们以片上外设 ADC 为例，假设我们要启动 ADC 开始转换，根据手册我们知道是要控制 ADC_CR2 寄存器的位 0：ADON，即往位 0 写 1，即：

( X1 F: I! r8 y# E+ FADC->CR2=0x00000001;
- w% u1 Y& o1 A( V* F& B, Y- h
这是一般的操作方法。现在这个头文件里面有关于 ADON 位的位定义：

9 U  q) s6 q# O9 U#define ADC_CR2_ADON ((uint32_t)0x00000001)
. B& Y+ z4 X; f5 S" {
* C8 i* q1 v; ~( S有了这个位定义，我们刚刚的代码就变成了：

ADC->CR2=ADC_CR2_ADON


stm32f10x_xxx.h
外设 xxx 应用函数库头文件，这里面主要定义了实现外设某一功能的结构体，比如通用定时器有很多功能，有定时功能，有输出比较功能，有输入捕捉功能，而通用定时器有非常多的寄存器要实现某一个功能。
2 t0 ]4 @, I8 ?* _
比如定时功能，我们根本不知道具体要操作哪些寄存器，这个头文件就为我们打包好了要实现某一个功能的寄存器，是以机构体的形式定义的，比如通用定时器要实现一个定时的功能，我们只需要初始化 TIM_TimeBaseInitTypeDef 这个结构体里面的成员即可，里面的成员就是定时所需要操作的寄存器。

有了这个头文件，我们就知道要实现某个功能需要操作哪些寄存器，然后再回手册中精度这些寄存器的说明即可。
5 o' \% P: Z4 d) l2 o) N: Z

stm32f10x_xxx.c
stm32f10x_xxx.c：外设 xxx 应用函数库，这里面写好了操作 xxx 外设的所有常用的函数，我们使用库编程的时候，使用的最多的就是这里的函数。

3 J% g8 Y2 L( G# Q' q) lSystemInit
工程中新建main.c 。
7 f; `$ j& o; x8 p" d3 T
: t; h7 r5 W, m/ r$ d在此文件中编写main函数后直接编译会报错：
/ z+ U% K( R  @/ P" |2 a7 O1 W% M9 R
Undefined symbol SystemInit (referred from startup_stm32f10x_hd.o).
! l, V9 T  W' }: V; ?
8 P% T+ o$ a* W# w: [错误提示说SystemInit没有定义。从分析启动文件startup_stm32f10x_hd.s时我们知道，
: B# a/ z6 e1 p% ?( U+ m$ Q
" z9 p; S4 M$ s5 t" m2 c;Reset handler

+ O$ v  N6 z' t! b* G+ v, ~4 t2 ZReset_Handler PROC

, t) w/ [# Q: lEXPORT Reset_Handler [WEAK]
- B7 {: m1 p$ E  _0 ~$ Y
IMPORT __main

;IMPORT SystemInit

;LDR R0, =SystemInit

BLX R0

LDR R0, =__main
# O, F7 l( L4 y+ K7 X' n
BX R0

+ O( D) M4 Y# ]% T1 SENDP

3 d: {; K- o  Y" \3 t' k* h4 i汇编中；分号是注释的意思
; y3 w0 Q: M; o7 \2 G- p2 {8 Z
第五行第六行代码Reset_Handler调用了SystemInit该函数用来初始化系统时钟，而该函数是在库文件system_stm32f10x.c中实现的。我们重新写一个这样的函数也可以，把功能完整实现一遍，但是为了简单起见，我们在main文件里面定义一个SystemInit空函数，为的是骗过编译器，把这个错误去掉。
6 t' T5 p- @- A0 u
关于配置系统时钟之后会出文章RCC时钟树详细介绍，主要配置时钟控制寄存器(RCC_CR)和时钟配置寄存器(RCC_CFGR)这两个寄存器，但最好是直接使用CubeMX直接生成，因为它的配置过程有些冗长。

如果我们用的是库，那么有个库函数SystemInit，会帮我们把系统时钟设置成72M。
* C0 ^6 ^$ G& D7 a  k  A. l
, _5 n( U& Y( y, I# L  g6 r4 e" T现在我们没有使用库，那现在时钟是多少？答案是8M，当外部HSE没有开启或者出现故障的时候，系统时钟由内部低速时钟LSI提供，现在我们是没有开启HSE，所以系统默认的时钟是LSI=8M。

- R$ ]. ~1 r* t8 C9 n
/ q8 Q. e. A& @+ g/ k! L库封装层级
( P, L5 h/ S: g. e& `2 U$ I& b0 U
/ ?7 t2 ?: _2 m) y0 ]
* |/ j4 P; C" s, K& Z
如图，达到第四层级便是我们所熟知的固件库或HAL库的效果。当然库的编写还需要考虑许多问题，不止于这些内容。我们需要的是了解库封装的大概过程。
  o  G+ A( c) X) {! E+ G4 i' e
将库封装等级分为四级来介绍是为了有层次感，就像打怪升级一样，进行认知理解的升级。

我们都知道，操作GPIO输出分三大步：
( E4 T9 w$ Y# T, Y2 E3 p. C+ v
" Z+ W5 C5 s$ i$ O
- Q! v4 Z5 b* r2 B# c2 A0 g# z! d/ h时钟控制：
STM32 外设很多，为了降低功耗，每个外设都对应着一个时钟，在系统复位的时候这些时钟都是被关闭的，如果想要外设工作，必须把相应的时钟打开。

" S% L: e. C2 l+ `4 _$ jSTM32 的所有外设的时钟由一个专门的外设来管理，叫RCC（reset and clockcontrol），RCC 在STM32 参考手册的第六章。
' l3 G& [% R: T3 J4 |# A# _' \
STM32 的外设因为速率的不同，分别挂载到三条总系上：AHB、APB2、APB1，AHB为高速总线，APB2 次之，APB1 再次之。所以的IO 口都挂载到APB2 总线上，属于高速外设。

5 H0 G: O) e4 W6 U3 L6 V) ]: u
2 C2 l# }* }; t& w3 H模式配置：
$ ^. ]9 I" G3 N& x/ Q' ^这个由端口配置寄存器来控制。端口配置寄存器分为高低两个，每4bit 控制一个IO 口，所以端口配置低寄存器：CRL 控制这IO 口的低8 位，端口配置高寄存器：CRH控制这IO 口的高8bit。

在4 位一组的控制位中，CNFy[1:0] 用来控制端口的输入输出，MODEy[1:0]用来控制输出模式的速率，又称驱动电路的响应速度，注意此处速率与程序无关，GPIO引脚速度、翻转速度、输出速度区别输入有4种模式，输出有4种模式，我们在控制LED 的时候选择通用推挽输出。
* ]' {) N# h9 V, w
输出速率有三种模式：2M、10M、50M，这里我们选择2M。
& Y9 F' m$ I1 ]  ^
电平控制：
STM32的IO口比较复杂，如果要输出1和0，则要通过控制：端口输出数据寄存器ODR来实现，ODR 是：Output data register的简写，在STM32里面，其寄存器的命名名称都是英文的简写，很容易记住。

从手册上我们知道ODR是一个32位的寄存器，低16位有效，高16位保留。低16位对应着IO0~IO16，只要往相应的位置写入0或者1就可以输出低或者高电平。

. |# g! D9 y+ u% h# g  V3 }第一层级：基地址宏定义


* }  r1 r" c3 A  D/ r. t( c
时钟控制：

9 V. J( w2 E& _2 ^8 `3 n
6 q' D5 n# X5 e
在STM32中，每个外设都有一个起始地址，叫做外设基地址，外设的寄存器就以这个基地址为标准按照顺序排列，且每个寄存器32位，（后面作为结构体里面的成员正好内存对齐）。

查表看到时钟由APB2外设时钟使能寄存器(RCC_APB2ENR)来控制，其中PB端口的时钟由该寄存器的位3写1使能。我们可以通过基地址+偏移量0x18，算出RCC_APB2ENR的地址为：0x40021018。那么使能PB口的时钟代码则如下所示：
#define RCC_APB2ENR *(volatile unsigned long *)0x40021018
( N$ w' W* w4 e0 o% x// 开启端口B 时钟
RCC_APB2ENR |= 1<<3;
( b2 ?1 N* o# ]( o6 x7 ^. a% i

模式配置：
. G/ \% Q. M; ]# ~$ L% ~! a9 z6 \

* e. l1 X9 m6 y. \; T
同RCC_APB2ENR一样，GPIOB的起始地址是：0X4001 0C00，我们也可以算出GPIO_CRL的地址为：0x40010C00。那么设置PB0为通用推挽输出，输出速率为2M的代码则如下所示：
9 X- h& K/ }# |* v4 n: ^
& H. c/ j; ?& G! k

同上，从手册中我们看到ODR寄存器的地址偏移是：0CH，可以算出GPIOB_ODR寄存器的地址是：0X4001 0C00 + 0X0C = 0X4001 0C0C。现在我们就可以定义GPIOB_ODR这个寄存器了，代码如下：
1 W* _  G/ T1 @

1. #define GPIOB_ODR *(volatile unsigned long *)0x40010C0C
   
2. //PB0 输出低电平
   $ n/ F( l2 e0 a' J8 d" o
3. GPIOB_ODR = 0<<0;

复制代码

第一层级：基地址宏定义完成用STM32控制一个LED的完整代码：

1. #define RCC_APB2ENR *(volatile unsigned long *)0x40021018
   
2. #define GPIOB_CRL *(volatile unsigned long *)0x40010C00
   0 v3 g! ]) `. B7 U
3. #define GPIOB_ODR *(volatile unsigned long *)0x40010C0C
   
4. 
   ) n3 K8 T8 ~3 `) L+ T- d
5. int main(void)
   
6. {
   
7. // 开启端口B 的时钟
   . A0 ?( ~: ^  M
8. RCC_APB2ENR |= 1<<3;
   ! K, D+ R" N! y2 Q* {0 M
9. 
   
10. 
      h9 O: s3 R( x" C2 M1 a
11. // 配置PB0 为通用推挽输出模式，速率为2M
    / y. g, @+ s+ j7 ^* i
12. GPIOB_CRL = (2<<0) | (0<<2);
    
13. 
    
14. 
    
15. // PB0 输出低电平，点亮LED
    
16. GPIOB_ODR = 0<<0;
    
17. }
    ( N* N+ ~, H) N3 M- p' y
18. 
    
19. 
    
20. void SystemInit(void)
    ; }% j6 p/ m. u
21. {
    7 ~- F9 O* f4 u: G  M
22. }

复制代码

. C7 M2 E% A* D( @6 {第二层级：基地址宏定义+结构体封装
* v5 k! T% C, E9 e' a& _

外设寄存器结构体封装
- S  j& L) h4 l- f上面我们在操作寄存器的时候，操作的是寄存器的绝对地址，如果每个寄存器都这样操作，那将非常麻烦。我们考虑到外设寄存器的地址都是基于外设基地址的偏移地址，都是在外设基地址上逐个连续递增的，每个寄存器占32个或者16个字节，这种方式跟结构体里面的成员类似。

' e' J- T; Z( Q  Y# G1 l( l( E所以我们可以定义一种外设结构体，结构体的地址等于外设的基地址，结构体的成员等于寄存器，成员的排列顺序跟寄存器的顺序一样。这样我们操作寄存器的时候就不用每次都找到绝对地址，只要知道外设的基地址就可以操作外设的全部寄存器，即操作结构体的成员即可。

下面我们先定义一个GPIO寄存器结构体，结构体里面的成员是GPIO的寄存器，成员的顺序按照寄存器的偏移地址从低到高排列，成员类型跟寄存器类型一样。
. B. H  I$ j4 i, r) j- s

1. typedef struct
   
2. {
   
3. volatile uint32_t CRL;
   9 q. X5 U  S0 n0 W
4. volatile uint32_t CRH;
   
5. volatile uint32_t IDR;
   8 {. s, o2 z- P: u$ H
6. volatile uint32_t ODR;
   9 ^+ m) G0 D" i  m) E3 W& c( F
7. volatile uint32_t BSRR;
   2 ~. G/ J: K6 @
8. volatile uint32_t BRR;
   
9. volatile uint32_t LCKR;
   
10. } GPIO_TypeDef;

复制代码

在《STM32 中文参考手册》8.2 寄存器描述章节，我们可以找到结构体里面的7个寄存器描述。在点亮LED的时候我们只用了CRL和ODR这两个寄存器，至于其他寄存器的功能大家可以自行看手册了解。

在GPIO结构体里面我们用了两个数据类型，一个是uint32_t，表示无符号的32位整型，因为GPIO的寄存器都是32位的。这个类型声明在标准头文件stdint.h 里面使用typedef对unsigned int重命名，我们在程序上只要包含这个头文件即可。
, U+ G; ^! O0 z6 ?5 b
另外一个是volatile作用就是告诉编译器这里的变量会变化不因优化而省略此指令，必须每次都直接读写其值，这样就能确保每次读或者写寄存器都真正执行到位。


外设封装
  n. m+ \8 {; h1 o: q+ Q" o6 `
. h3 t  W# _  _6 W

STM32F1系列的GPIO端口分A~G，即GPIOA、GPIOB。。。。。。GPIOG。每个端口都含有GPIO_TypeDef结构体里面的寄存器，我们可以根据手册各个端口的基地址把GPIO的各个端口定义成一个GPIO_TypeDef类型指针，然后我们就可以根据端口名（实际上现在是结构体指针了）来操作各个端口的寄存器，代码实现如下：
1 ~7 R# k% o8 W0 v
$ Q. n. ^' m* f, D8 q

1. #define GPIOA ((GPIO_TypeDef *) 0X4001 0800)
   
2. #define GPIOB ((GPIO_TypeDef *) 0X4001 0C00)
   % W5 E0 }- D$ @( Y" d" z# W7 u
3. #define GPIOC ((GPIO_TypeDef *) 0X4001 1000)
   
4. #define GPIOD ((GPIO_TypeDef *) 0X4001 1400)
   + m! e: @8 ~% w. d- V3 p  ]) c8 ~
5. #define GPIOE ((GPIO_TypeDef *) 0X4001 1800)
   
6. #define GPIOF ((GPIO_TypeDef *) 0X4001 1C00)
   
7. #define GPIOG ((GPIO_TypeDef *) 0X4001 2000)

复制代码

/ _# a. [9 R1 i6 O) b: h外设内存映射
4 }; D) f5 d* w讲到基地址的时候我们再引人一个知识点：Cortex-M3存储器系统，这个知识点在《Cortex-M3权威指南》第5章里面讲到。CM3的地址空间是4GB，如下图所示：

/ ~) G& C! s8 T( Y0 S" l; T) P我们这里要讲的是片上外设，就是我们所说的寄存器的根据地，其大小总共有512MB，512MB是其极限空间，并不是每个单片机都用得完，实际上各个MCU厂商都只是用了一部分而已。STM32F1系列用到了：0x4000 0000 ~0x5003 FFFF。现在我们说的STM32的寄存器就是位于这个区域

# I& ~1 k7 A+ O+ ?5 I* p
3 W' M$ u/ N4 P5 k% m8 u) [APB1、APB2、AHB 总线基地址
1 {( J& z& y7 e  [9 Q% b现在我们说的STM32的寄存器就是位于这个区域，这里面ST设计了三条总线：AHB、APB2和APB1，其中AHB和APB2是高速总线，APB1是低速总线。不同的外设根据速度不同分别挂载到这三条总线上。

从下往上依次是：APB1、APB2、AHB，每个总线对应的地址分别是：APB1：0x40000000，APB2：0x4001 0000，AHB：0x4001 8000。

. K- a# H6 q% h- A4 N, \这三条总线的基地址我们是从《STM32 中文参考手册》2.3小节—存储器映像得到的：APB1的基地址是TIM2定时器的起始地址，APB2的基地址是AFIO的起始地址，AHB的基地址是SDIO的起始地址。其中APB1地址又叫做外设基地址，是所有外设的基地址，叫做PERIPH_BASE。

现在我们把这三条总线地址用宏定义出来，以后我们在定义其他外设基地址的时候，只需要在这三条总线的基址上加上偏移地址即可，代码如下：

1. #define PERIPH_BASE ((uint32_t)0x40000000)
   
2. #define APB1PERIPH_BASE PERIPH_BASE
   ! G( Q' N# C, m5 m  G* Y
3. #define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
   
4. #define AHBPERIPH_BASE (PERIPH_BASE + 0x20000)
   & E0 S: a) ?+ Y# z, O

复制代码

8 S# O1 |( I0 }# q  E
, }( Z8 S; t0 p, z8 c7 dGPIO 端口基地址
$ ?$ ?. t) G5 b2 k8 [( s因为GPIO挂载到APB2总线上，那么现在我们就可以根据APB2的基址算出各个GPIO端口的基地址，用宏定义实现代码如下：

1. #define GPIOA_BASE (APB2PERIPH_BASE + 0x0800)
   $ W6 f4 |$ W4 x) j, G2 T- d2 I- I/ o
2. #define GPIOB_BASE (APB2PERIPH_BASE + 0x0C00)
   
3. #define GPIOC_BASE (APB2PERIPH_BASE + 0x1000)
   
4. #define GPIOD_BASE (APB2PERIPH_BASE + 0x1400)
   
5. #define GPIOE_BASE (APB2PERIPH_BASE + 0x1800)
   , A2 u6 Z$ ]4 k
6. #define GPIOF_BASE (APB2PERIPH_BASE + 0x1C00)
   & m2 w' H# e% Z& a) U; D
7. #define GPIOG_BASE (APB2PERIPH_BASE + 0x2000)

复制代码

第二层级：基地址宏定义+结构体封装完成用STM32控制一个LED的完整代码：
. P: }/ l' b1 [

1. #include <stdint.h>
   - J3 ^) U; O. e5 C
2. #define __IO volatile
   - H3 `/ l- _$ [
3. typedef struct
   5 ?/ y$ \# K( @
4. {
   
5. __IO uint32_t CRL;
   
6. __IO uint32_t CRH;
   0 C7 w! o9 s4 c7 u4 R* O! k: r
7. __IO uint32_t IDR;
   
8. __IO uint32_t ODR;
   # M$ {1 M9 W7 ?$ r8 e" r& n& ^
9. __IO uint32_t BSRR;
   8 O" A/ c( O7 y8 X
10. __IO uint32_t BRR;
    2 {* @6 |( O$ o* d5 _6 N
11. __IO uint32_t LCKR;
    
12. } GPIO_TypeDef;
    
13. typedef struct
    , a3 z9 k9 u" I2 D2 f* M9 w: m
14. {
    , J  T0 S# K2 D3 \3 U+ C
15. __IO uint32_t CR;
    
16. __IO uint32_t CFGR;
    
17. __IO uint32_t CIR;
    
18. __IO uint32_t APB2RSTR;
    . U! y* p( s* T2 i
19. __IO uint32_t APB1RSTR;
    4 _) p+ n4 t( \8 H
20. __IO uint32_t AHBENR;
    
21. __IO uint32_t APB2ENR;
    ; [: ^! P7 r7 Z5 P! \. {2 p8 q
22. __IO uint32_t APB1ENR;
    
23. __IO uint32_t BDCR;
    
24. __IO uint32_t CSR;
    + k: M  _2 u2 T
25. } RCC_TypeDef;
    $ {1 x- O0 _. i
26. #define PERIPH_BASE ((uint32_t)0x40000000)
    
27. #define APB1PERIPH_BASE PERIPH_BASE
    
28. #define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
    
29. #define AHBPERIPH_BASE (PERIPH_BASE + 0x20000)
    
30. #define GPIOA_BASE (APB2PERIPH_BASE + 0x0800)
    - f: _+ @2 Y3 j9 Z" k
31. #define GPIOB_BASE (APB2PERIPH_BASE + 0x0C00)
    ! @4 a0 z# f) Y% J6 m
32. #define GPIOC_BASE (APB2PERIPH_BASE + 0x1000)
    - {9 q7 w' t0 K3 r
33. #define GPIOD_BASE (APB2PERIPH_BASE + 0x1400)
    
34. #define GPIOE_BASE (APB2PERIPH_BASE + 0x1800)
    
35. #define GPIOF_BASE (APB2PERIPH_BASE + 0x1C00)
    
36. #define GPIOG_BASE (APB2PERIPH_BASE + 0x2000)
    & ]) l% X* x% X; }  G+ P* d
37. #define RCC_BASE (AHBPERIPH_BASE + 0x1000)
    
38. #define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
    * R1 J9 ]4 _) B; D) B
39. #define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
    6 r: j& W, D4 o$ h- n, V( w' |
40. #define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
    
41. #define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
    
42. #define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
    
43. #define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
    ) {1 i3 H% ?' J" u1 ?; ?
44. #define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
    : E" X- `) A7 T. C3 U% M. G! l. B. d
45. #define RCC ((RCC_TypeDef *) RCC_BASE)
    
46. #define RCC_APB2ENR *(volatile unsigned long *)0x40021018
    4 d: x- j5 I! b9 ^2 u; M" b3 [: M
47. #define GPIOB_CRL *(volatile unsigned long *)0x40010C00
    
48. #define GPIOB_ODR *(volatile unsigned long *)0x40010C0C
    ; z" i+ C0 j% s1 [& ~/ t
49. int main(void)
    . b; B; t9 K0 W! z/ p
50. {
    
51. // 开启端口B 的时钟
    1 J# h! q% G; [
52. RCC->APB2ENR |= 1<<3;
    
53. // 配置PB0 为通用推挽输出模式，速率为2M
    5 ?4 M" t6 \5 k) M/ [
54. GPIOB->CRL = (2<<0) | (0<<2);
    0 F& g2 q( E" h  M% T  z5 |
55. // PB0 输出低电平，点亮LED
    
56. GPIOB->ODR = 0<<0;
    
57. }
    + ]" J( |! j! m2 g
58. void SystemInit(void)
    
59. {
    
60. }

复制代码

第二层级变化：
①、定义一个外设（GPIO）寄存器结构体，结构体的成员包含该外设的所有寄存器，成员的排列顺序跟寄存器偏移地址一样，成员的数据类型跟寄存器的一样。

②外设内存映射，即把地址跟外设建立起一一对应的关系。
8 H  q9 |5 u& U* A, \& A: {8 R
1 {& e1 H# G! C③外设声明，即把外设的名字定义成一个外设寄存器结构体类型的指针。
2 K2 e+ C" E6 k, ^6 E+ n
④通过结构体操作寄存器，实现点亮LED。

* `4 O% j8 a0 {" w8 b: S$ a( b第三层级：基地址宏定义+结构体封装+“位封装”（每一位的对应字节封装）
. o/ S( M1 _+ C: U上面我们在控制GPIO输出内容的时候控制的是ODR（Output data register）寄存器，ODR是一个16位的寄存器，必须以字的形式控制其实我们还可以控制BSRR和BRR这两个寄存器来控制IO的电平，下面我们简单介绍下BRR寄存器的功能，BSRR自行看手册研究。
7 d* {2 x3 Q! {/ ^- w$ G: J
+ r+ u( v% `! m

7 p  r$ C3 x4 Q" t$ z8 D. \4 c- R位清除寄存器BRR只能实现位清0操作，是一个32位寄存器，低16位有效，写0没影响，写1清0。现在我们要使PB0输出低电平，点亮LED，则只要往BRR的BR0位写1即可，其他位为0，代码如下：

% J0 s7 Z, y) W. wGPIOB->BRR = 0X0001;
/ }0 e7 y+ H1 ^; R7 ^, c
# `( _9 A+ k$ n# c' T0 N" i这时PB0就输出了低电平，LED就被点亮了。
5 ?! B; x& o! F( _3 x9 \
: [1 H# g# X/ V如果要PB2输出低电平，则是：
9 \, y) ~; l* Z0 t1 N
( e2 @8 e4 U) p0 K- HGPIOB->BRR = 0X0004;

如果要PB3/4/5/6。。。。。。这些IO输出低电平呢？
2 o6 h( }+ m& f) D) H9 \; A
& F, V9 v0 r) K$ A; V道理是一样的，只要往BRR的相应位置赋不同的值即可。因为BRR是一个16位的寄存器，位数比较多，赋值的时候容易出错，而且从赋值的16进制数字我们很难清楚的知道控制的是哪个IO。

5 |  {# v) [( j7 l这时，我们是否可以把BRR的每个位置1都用宏定义来实现，如GPIO_Pin_0就表示0X0001，GPIO_Pin_2就表示0X0004。只要我们定义一次，以后都可以使用，而且还见名知意。“位封装”（每一位的对应字节封装） 代码如下：
" N# n6 h% T5 u3 u

1. #define GPIO_Pin_0 ((uint16_t)0x0001) /*!< Pin 0 selected */
   
2. 
   
3. #define GPIO_Pin_1 ((uint16_t)0x0002) /*!< Pin 1 selected */
   
4. 
   : k% h1 {& t4 T  ^: z& e: u0 T
5. #define GPIO_Pin_2 ((uint16_t)0x0004) /*!< Pin 2 selected */
     A  v$ {  Z( X% T
6. 
   " G" r1 U* N) N6 ~& A, X8 o" B
7. #define GPIO_Pin_3 ((uint16_t)0x0008) /*!< Pin 3 selected */
   + ~% u" w/ v% H0 J
8. 
   0 G* ?7 l6 H5 C8 h" |6 a
9. #define GPIO_Pin_4 ((uint16_t)0x0010) /*!< Pin 4 selected */
   
10. 
    
11. #define GPIO_Pin_5 ((uint16_t)0x0020) /*!< Pin 5 selected */
      h: ]- U: d9 b; I  o; h) ^$ O. P
12. 
    
13. #define GPIO_Pin_6 ((uint16_t)0x0040) /*!< Pin 6 selected */
    - O, F' \) q1 P) A& l6 a/ d2 ]
14. 
    
15. #define GPIO_Pin_7 ((uint16_t)0x0080) /*!< Pin 7 selected */
    : P$ Z1 K3 w( X! m4 R$ n1 J# z
16. 
    / @' }4 u& z4 ~) k
17. #define GPIO_Pin_8 ((uint16_t)0x0100) /*!< Pin 8 selected */
    * x, X/ B- Y+ q: q$ M
18. 
    
19. #define GPIO_Pin_9 ((uint16_t)0x0200) /*!< Pin 9 selected */
    6 n+ z4 g% r. k$ Q
20. 
    5 |; y6 y8 z6 U1 x
21. #define GPIO_Pin_10 ((uint16_t)0x0400) /*!< Pin 10 selected */
    & X4 G. H# I# K2 R$ @& w- j0 A+ C$ u
22. 
    
23. #define GPIO_Pin_11 ((uint16_t)0x0800) /*!< Pin 11 selected */
    * H- t$ ^$ ~  @( V9 M
24. 
    
25. #define GPIO_Pin_12 ((uint16_t)0x1000) /*!< Pin 12 selected */
    
26. 
    
27. #define GPIO_Pin_13 ((uint16_t)0x2000) /*!< Pin 13 selected */
    ' U2 z& K# p! o1 h8 k
28. 
    " g- N+ @" o1 |% G7 G
29. #define GPIO_Pin_14 ((uint16_t)0x4000) /*!< Pin 14 selected */
    
30. 
    
31. #define GPIO_Pin_15 ((uint16_t)0x8000) /*!< Pin 15 selected */
    1 N$ a- B) @  Q( |  ]1 \, P
32. 
    
33. #define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< All pins selected */
    
34. 
    7 }; M/ k8 X+ [

复制代码

, H! u# h0 \" L$ d! d. t$ H  a这时PB0就输出了低电平的代码就变成了：
' m# C# Q. A5 \GPIOB->BRR = GPIO_Pin_0;
# G6 }6 M1 [3 w, d, c% k. Y
7 I+ {7 M" g' ^% W" n' u（如果同时让PB0/PB15输出低电平，用或运算，代码：
/ E) }9 |  P. o% N4 l" HGPIOB->BRR = GPIO_Pin_0|GPIO_Pin_15;

% c& t9 _- Y3 ?, W/ _8 h为了不使main函数看起来冗余，上述库封装 的代码不应该放在main里面，因为其是跟GPIO相关的，我们可以把这些宏放在一个单独的头文件里面。
, ]* x4 V# t  V6 E
在工程目录下新建stm32f10x_gpio.h，把封装代码放里面，然后把这个文件添加到工程里面。这时我们只需要在main.c里面包含这个头文件即可。

第四层级：基地址宏定义+结构体封装+“位封装”+函数封装
: L" z! B" L6 X: b我们点亮LED的时候，控制的是PB0这个IO，如果LED接到的是其他IO，我们就需要把GPIOB修改成其他的端口，其实这样修改起来也很快很方便。
* S% B% W$ a& ^' X$ d! F# t. S
4 e* Q1 }& A0 S3 A4 i3 U# k9 S/ R但是为了提高程序的可读性和可移植性，我们是否可以编写一个专门的函数用来复位GPIO的某个位，这个函数有两个形参，一个是GPIOX（X=A...G），另外一个是GPIO_Pin（0...15），函数的主体则是根据形参GPIOX 和GPIO_Pin来控制BRR寄存器，代码如下：

1. void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   0 ~7 D  C; W1 H) ~- P* b& T$ R
2. {
   ) ]1 o4 r3 U* o  ?7 j
3. GPIOx->BRR = GPIO_Pin;
   
4. }
   

复制代码

# ^6 I; c  @8 W' \# l3 A这时，PB0输出低电平，点亮LED的代码就变成了：
5 S: ?- X" G+ w' A% K% U! hGPIO_ResetBits(GPIOB,GPIO_Pin_0);

同理， 我们可以控制BSRR这个寄存器来实现关闭LED，代码如下：
# B; [+ q, q: R6 d' P

1. // GPIO 端口置位函数
   3 |) ]5 \5 f% k
2. void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   
3. {
   2 b; F; s% H% b5 G
4. GPIOx->BSRR = GPIO_Pin;
   2 B2 Y7 r! t0 Z6 m( }
5. }

复制代码

这时，PB0输出高电平，关闭LED的代码就变成了：
+ q; O5 b7 f$ s4 NGPIO_SetBits(GPIOB,GPIO_Pin_0);

. t( U% }; _2 X' n+ U( J+ C: P& x同样，因为这个函数是控制GPIO的函数，我们可以新建一个专门的文件来放跟gpio有关的函数。

在工程目录下新建stm32f10x_gpio.c，把GPIO相关的函数放里面。这时我们是否发现刚刚新建了一个头文件stm32f10x_gpio.h，这两个文件存放的都是跟外设GPIO相关的。

C文件里面的函数会用到h头文件里面的定义，这两个文件是相辅相成的，故我们在stm32f10x_gpio.c 文件中也包含stm32f10x_gpio.h这个头文件。别忘了把stm32f10x.h这个头文件也包含进去，因为有关寄存器的所有定义都在这个头文件里面。
1 D. I7 G4 u2 G
如果我们写其他外设的函数，我们也应该跟GPIO一样，新建两个文件专门来存函数，比如RCC这个外设我们可以新建stm32f10x_rcc.c和stm32f10x_rcc.h。其他外依葫芦画瓢即可。
( h; Q% ]7 ]- ]

/ P( B9 Q7 v7 J# R实例编写
, S/ O% e+ B% [以上，是对库封住过程的概述，下面我们正在地使用库函数编写LED程序
2 q1 D" C: m' N4 f3 k+ L* y4 D  I
①管理库的头文件
) @- w" t4 o4 t* k; {- f% V4 q' P6 w当我们开始调用库函数写代码的时候，有些库我们不需要，在编译的时候可以不编译，可以通过一个总的头文件stm32f10x_conf.h来控制，该头文件主要代码如下：

1. //#include "stm32f10x_adc.h"
   , i# K; d4 y8 y
2. 
   
3. //#include "stm32f10x_bkp.h"
   : s. C2 ]/ J! y: M
4. 
   ! k) ~' L+ ?2 b1 M1 S
5. //#include "stm32f10x_can.h"
   
6. 
   
7. //#include "stm32f10x_cec.h"
   $ \2 g5 G. |0 C1 n1 S
8. 
   + ~  \  B8 k9 J; n  x
9. //#include "stm32f10x_crc.h"
   8 w9 i+ t+ a$ d1 N# h: N
10. 
    
11. //#include "stm32f10x_dac.h"
    / w* ^+ k8 j4 e2 M8 r' L7 S
12. 
    
13. //#include "stm32f10x_dbgmcu.h"
    0 k0 h" ~* o* V% E7 h$ R  I7 I
14. 
    ' j4 m$ h. Y* r1 t* `5 e5 v
15. //#include "stm32f10x_dma.h"
    
16. 
    0 o4 J2 \, j2 \) v
17. //#include "stm32f10x_exti.h"
    - t! d- q" p! X; d/ [: J- K
18. 
      L9 o  N% N4 P8 T. u9 z/ v
19. //#include "stm32f10x_flash.h"
    
20. 
    
21. //#include "stm32f10x_fsmc.h"
    
22. 
    
23. #include "stm32f10x_gpio.h"
    
24. 
    7 m' d8 h* P9 l/ F4 Q
25. //#include "stm32f10x_i2c.h"
    
26. 
    ' R% ]6 G3 Q% g& P; O: `
27. //#include "stm32f10x_iwdg.h"
    
28. 
    
29. //#include "stm32f10x_pwr.h"
    6 M( U9 O" t" x: I7 N
30. 
    
31. #include "stm32f10x_rcc.h"
    
32. 
    
33. //#include "stm32f10x_rtc.h"
    
34. 
    
35. //#include "stm32f10x_sdio.h"
    
36. 
    
37. //#include "stm32f10x_spi.h"
    
38. 
    5 u& a3 O" O7 |/ p/ P
39. //#include "stm32f10x_tim.h"
    ( X# O7 e- s6 w
40. 
    
41. //#include "stm32f10x_usart.h"
    
42. 
    
43. //#include "stm32f10x_wwdg.h"
    5 [1 H) V1 V/ s* @, m& L" X
44. 
    
45. //#include "misc.h"
    
46. 
    ! }& ^7 ^! Y. K$ L" ^* u3 n

复制代码

这里面包含了全部外设的头文件，点亮一个LED我们只需要RCC和GPIO 这两个外设的库函数即可，其中RCC控制的是时钟，GPIO控制的具体的IO口。所以其他外设库函数的头文件我们注释掉，当我们需要的时候就把相应头文件的注释去掉即可。
3 a# g' N+ Z- ~  W  A
stm32f10x_conf.h这个头文件在stm32f10x.h这个头文件的最后面被包含，在第8296行：
* U8 d. j4 A4 h. u
& ^( \5 k7 Z( @

1. #ifdef USE_STDPERIPH_DRIVER
   
2. 
   
3. #include "stm32f10x_conf.h"
   4 P0 s  I" `4 D7 W  W
4. 
     C7 H* t9 b. {9 B) v3 ?
5. #endif

复制代码

) `9 P3 V# t1 b; I代码的意思是，如果定义了USE_STDPERIPH_DRIVER这个宏的话，就包含stm32f10x_conf.h这个头文件。
: K. k* }6 R& q' p! f5 X# [, m
我们在新建工程的时候，在魔术棒选项卡C/C++中，我们定义了USE_STDPERIPH_DRIVER 这个宏，所以stm32f10x_conf.h 这个头文件就被stm32f10x.h包含了，我们在写程序的时候只需要调用一个头文件：stm32f10x.h即可。
& {! e0 l* n$ \: H. B
# q. r+ W1 P1 L" J+ j3 Q; Y
' p" A9 `/ T+ R. p1 }7 b0 P②编写LED初始化函数
经过寄存器点亮LED的操作，我们知道操作一个GPIO输出的编程要点大概如下：
1、开启GPIO的端口时钟
7 @9 C6 \) Q& s8 X6 ^2、选择要具体控制的IO口，即pin
3、选择IO口输出的速率，即speed
/ v9 U1 z. L/ x; g4、选择IO口输出的模式，即mode
5、输出高/低电平

STM32的时钟功能非常丰富，配置灵活，为了降低功耗，每个外设的时钟都可以独自的关闭和开启。STM32中跟时钟有关的功能都由RCC这个外设控制，RCC中有三个寄存器控制着所以外设时钟的开启和关闭：RCC_APHENR、RCC_APB2ENR和RCC_APB1ENR，AHB、APB2和APB1代表着三条总线，所有的外设都是挂载到这三条总线上，GPIO属于高速的外设，挂载到APB2总线上，所以其时钟有RCC_APB2ENR控制。
2 X8 V/ [# [9 `. U& I1 J' p

GPIO 时钟控制
( b) i8 [5 }8 R固件库函数：
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE)函数的

2 A/ ]& [8 v" `5 ]: ]0 n原型为：
8 J. H: M+ G& K) l2 n8 ~

1. void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph,
   
2. 
   
3. FunctionalState NewState)
   
4. 
   6 o( I1 Y4 X4 e, F' j# [! G
5. {
   4 i, l# y+ ~, A, ~) S
6. 
   
7. /* Check the parameters */
   : X" _, K* P0 W! a! j3 i# u4 c
8. 
   * Y! p9 T. N$ {* I
9. assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph));
   
10. 
    
11. assert_param(IS_FUNCTIONAL_STATE(NewState));
    
12. 
    
13. if (NewState != DISABLE)
    
14. 
    
15. {
    
16. 
    
17. RCC->APB2ENR |= RCC_APB2Periph;
    
18. 
    
19. }
      |8 x, ~3 D; b# K
20. 
    4 y  y2 `5 m0 K# r) M% J1 m& X9 h  K
21. else
    
22. 
    
23. {
    
24. 
    
25. RCC->APB2ENR &= ~RCC_APB2Periph;
    
26. 
    , T. A4 f8 F3 A) P, U
27. }
    
28. 
    
29. }

复制代码

当程序编译一次之后，把光标定位到函数/变量/宏定义处，按键盘的F12或鼠标右键的Go to definition of，就可以找到原型。固件库的底层操作的就是RCC外设的APB2ENR这个寄存器，宏RCC_APB2Periph_GPIOB的原型是：0x00000008，即（1<<3），还原成存器操作就是：RCC->APB2ENR |= 1<<<3。相比固件库操作，寄存器操作的代码可读性就很差，只有才查阅寄存器配置才知道具体代码的功能，而固件库操作恰好相反，见名知意。
6 z1 `- Z8 m5 [, `
' H) e7 d: L! E- O' n* O) ^
- p6 m$ I9 x: HGPIO 端口配置
1 m7 Q2 r9 I% G+ `/ {! vGPIO的pin，速度，模式，都由GPIO的端口配置寄存器来控制，其中IO0~IO7由端口配置低寄存器CRL控制，IO8~IO15由端口配置高寄存器CRH配置。固件库把端口配置的pin，速度和模式封装成一个结构体：
& v" |" t6 V: B0 ^7 o9 A

1. typedef struct
   
2. 
   
3. {
   3 S* t; p( r$ ?0 ]0 C8 @( S3 F8 d
4. 
   
5. uint16_t GPIO_Pin;
   
6. 
   
7. GPIOSpeed_TypeDef GPIO_Speed;
   ( t  n/ _. m& n$ @1 f) a6 E) e" [
8. 
   
9. GPIOMode_TypeDef GPIO_Mode;
   
10. 
    
11. } GPIO_InitTypeDef;

复制代码

! j# i) k# z  E" l' [pin可以是GPIO_Pin_0~GPIO_Pin_15或者是GPIO_Pin_All，这些都是库预先定义好的宏。speed也被封装成一个结构体：

1. typedef enum
   
2. 
   
3. {
   6 W# s% V  X4 A9 k2 L
4. 
   2 N, u" a' R& j7 {& n0 G9 ?, @$ w
5. GPIO_Speed_10MHz = 1,
   
6. 
   ( k, l4 ?, F+ l4 H( O3 U0 a
7. GPIO_Speed_2MHz,
   
8. 
   # }9 Q- O7 K! Q- h8 W
9. GPIO_Speed_50MHz
   - |9 d- i+ c+ O$ M: i* B1 |
10. 
    ) A2 A/ d& e: m6 W! Y" b
11. } GPIOSpeed_TypeDef;

复制代码

速度可以是10M，2M或者50M，这个由端口配置寄存器的MODE位控制，速度是针对IO口输出的时候而言，在输入的时候可以不用设置。mode也被封装成一个结构体：
' `. Z( H' I# ]3 C1 C( k9 ~8 ~1 r" @$ {

1. typedef enum
   
2. 
   
3. {
   
4. 
   
5. GPIO_Mode_AIN = 0x0, // 模拟输入
   ( h) _* s( T, |) x' g
6. 
   
7. GPIO_Mode_IN_FLOATING = 0x04, // 浮空输入（复位后的状态）
   % o, G0 @( a$ I
8. 
   
9. GPIO_Mode_IPD = 0x28, // 下拉输入
     }1 R2 D7 ]6 ~. ?& n
10. 
    
11. GPIO_Mode_IPU = 0x48, // 上拉输入
    / }9 a( h2 f2 O( G, c) [
12. 
    4 l. v; o5 k' c1 b( `
13. GPIO_Mode_Out_OD = 0x14, // 通用开漏输出
    " ?8 Y4 @4 X6 J4 w  h' h- @
14. 
    0 b% u/ }! E. _# n8 B
15. GPIO_Mode_Out_PP = 0x10, // 通用推挽输出
    ( e, G7 d5 b! P) T+ Y; d& r
16. 
    
17. GPIO_Mode_AF_OD = 0x1C, // 复用开漏输出
    
18. 
    
19. GPIO_Mode_AF_PP = 0x18 // 复用推挽输出
    
20. 
    ( f1 P9 Y9 d7 h' u
21. } GPIOMode_TypeDef;
    ! E5 Y; b3 r8 `
22. 
    

复制代码

+ q  ]7 H' h! M7 g- rIO口的模式有8种，输入输出各4种，由端口配置寄存器的CNF配置。平时用的最多的就是通用推挽输出，可以输出高低电平，驱动能力大，一般用于接数字器件。

# n" }+ k3 m1 [6 a6 }) U& `/ f最终用固件库实现就变成这样：

1. // 定义一个GPIO_InitTypeDef 类型的结构体
   
2. 
   : ]; k- q8 A3 k4 r
3. GPIO_InitTypeDef GPIO_InitStructure;
   & x, S8 i& K. A2 c
4. 
   
5. // 选择要控制的IO 口
   7 Z1 y1 t* Q/ q/ q  |# B) E  q3 B& s
6. 
   5 l$ U5 e% E: E  }) R6 M+ o
7. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
   ( _8 [3 J2 v2 S" I! O( h: t( [
8. 
   ! s2 ~) Q! h$ x+ Y; a
9. // 设置引脚为推挽输出
   
10. 
    
11. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
12. 
    
13. // 设置引脚速率为50MHz
    
14. 
    9 O& ^( b- U" U  R: ]
15. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    4 g4 \2 o; i( _0 ~. `$ p
16. 
    
17. /*调用库函数，初始化GPIOB0*/
    1 o0 Z4 s1 ~: @3 q1 R  `1 ?
18. 
    . K: |8 x; c- M$ Y, t9 H
19. GPIO_Init(GPIOB, &GPIO_InitStructure);
    4 |! i7 O/ ?1 w" [2 P9 x

复制代码

倘若同一端口下不同引脚有不同的模式配置，每次对每个引脚配置完成后都要调用GPIO初始化函数，代码如下：

1. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   1 t1 g, R' G; e" n- B/ }
2. 
   ) `$ K. k* v/ C- e5 y" ?
3. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 ;
   : ?5 r  G' l, K& P
4. 
   5 O8 {, @4 y& z: q, w
5. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入
   
6. 
   
7. GPIO_Init(GPIOB, &GPIO_InitStructure);
   2 R# z8 K/ `( V; X) Y* B) j
8. 
   ; g! g1 c7 _) j- j
9. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 ;
   & i' R' z) G# M! }% U. x+ M" y# x
10. 
    . b$ q) e# M, o1 M5 P( O" [; ^, S1 U
11. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推挽输出
    $ d( x& H  _6 g& j6 @$ J- K2 z
12. 
    # F' o7 O) V; t
13. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    ! m$ A6 H5 ^* K# P) G% M: ?$ ~- l
14. 
    ' f! G3 n6 K& z8 A; t
15. GPIO_Init(GPIOB, &GPIO_InitStructure);
    1 Q) T' Z/ l$ F2 a5 e6 f5 l

复制代码

. U3 e/ Y$ O- S( L) Q0 MGPIO 输出控制
2 e) Q. n$ W6 l! s1 U) pGPIO输出控制，可以通过端口数据输出寄存器ODR、端口位设置/清除寄存器BSRR和端口位清除寄存器BRR这三个来控制。端口输出寄存器ODR是一个32位的寄存器，低16位有效，对应着IO0~IO15，只能以字的形式操作，一般使用寄存器操作。

# q5 Z& x  k6 p: n2 [$ m// PB0 输出高电平，点亮LED
  i" z% _" _4 |& C  M5 S- D5 mGPIOB->ODR = 1<<0;
' s- H$ A) a& W; {# ~! ?$ W
& ]* h) R4 S3 l- ?& _) r8 V$ C端口位清除寄存器BRR是一个32位的寄存器，低十六位有效，对应着IO0~IO15，只能以字的形式操作，可以单独对某一个位操作，写1清0。

// PB0 输出低电平，点亮LED
GPIO_ResetBits(GPIOB, GPIO_Pin_0);
) V5 I  o% m1 A% s7 r, B* R
; W9 o4 t0 Q( g$ A, [+ k
BSRR是一个32位的寄存器，低16位用于置位，写1有效，高16位用于复位，写1有效，相当于BRR寄存器。高16位我们一般不用，而是操作BRR这个寄存器，所以BSRR这个寄存器一般用来置位操作。

" i( z* C* O1 c  C0 Z8 X* w/ [. u// PB0 输出高电平，熄灭LED
GPIO_SetBits(GPIOB, GPIO_Pin_0);
4 u! ?: o. U: L- U% W7 a
: S! s8 |9 \) G* ^9 g综上：固件库LED GPIO初始化函数
0 ?8 ~& S0 n0 n, d, q& G

1. void LED_GPIO_Config(void)
   9 f6 B8 v) P$ V) X* E
2. 
   
3. {
   / K* y: ^8 M7 |9 |( Z" e* v- c
4. 
   
5. // 定义一个GPIO_InitTypeDef 类型的结构体
   
6. 
   0 f; a' F# x; o  N! N0 t
7. GPIO_InitTypeDef GPIO_InitStructure;
   
8. 
   
9. // 开启GPIOB 的时钟
   
10. 
    
11. RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE);
    9 h1 s+ A: o' \% b* ^- K: u3 f" J9 z  f
12. 
    5 \; Q" A9 z9 |) c( D
13. // 选择要控制的IO 口
    
14. 
    
15. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    5 m* W  _5 C  E3 e, V
16. 
    ' |+ u% z5 K# F% W4 C* ^, n
17. // 设置引脚为推挽输出
    
18. 
    
19. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    + ^  W  d3 ^- V( ]9 x6 Q
20. 
    
21. // 设置引脚速率为50MHz
    
22. 
    ( [1 W% H+ A6 m! v1 U8 I
23. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
24. 
    
25. /*调用库函数，初始化GPIOB0*/
    " k; Z5 o: i, s+ C, Z& P. c6 ^
26. 
    
27. GPIO_Init(GPIOB, &GPIO_InitStructure);
    $ r0 j, P3 g1 ^
28. 
    % Z2 m) N3 N3 T$ L/ l
29. // 关闭LED
    
30. 
    + r6 r% q4 w) U2 ]
31. GPIO_SetBits(GPIOB, GPIO_Pin_0);
    
32. 
    
33. }
    
34. 
    0 J% y" e5 v" g1 f; R: V0 \

复制代码

主函数

1. #include "stm32f10x.h"
   
2. 
   + U1 C- ]/ c+ I( T
3. void SOFT_Delay(__IO uint32_t nCount);
   8 a( i, m( V! Z- x0 ~
4. 
   5 m2 j6 @" F7 K  }' l7 |2 d
5. void LED_GPIO_Config(void);
   
6. 
   # b% E* m+ m. r2 s6 E3 K
7. int main(void)
   
8. 
   ( J- x% t' ?4 Q  k! H: w
9. {
   
10. 
    # F. K2 f5 f- g" n$ p
11. // 程序来到main 函数之前，启动文件：statup_stm32f10x_hd.s 已经调用
    0 H+ \- Y6 b7 \* v" u$ S# t0 t. E
12. 
    7 Q+ m6 E. N$ B# D6 I- w
13. // SystemInit()函数把系统时钟初始化成72MHZ
    4 V7 R! q2 x( k) `& g: c
14. 
    9 W, P- c3 v: ~$ |; {+ n% S
15. // SystemInit()在system_stm32f10x.c 中定义
    0 `" t# R  u1 i1 H
16. 
    
17. // 如果用户想修改系统时钟，可自行编写程序修改
    ) w) K) i  e/ H; p+ P
18. 
    
19. LED_GPIO_Config();
    
20. 
    
21. while ( 1 )
    ; u* P, b5 l" ]; h, D& i
22. 
    
23. {
    4 J4 p  }4 Z: V- n  S* }" S& d
24. 
    
25. // 点亮LED
    
26. 
    
27. GPIO_ResetBits(GPIOB, GPIO_Pin_0);
    ( h! o# P0 Y8 F! A4 z" n6 Q
28. 
    
29. Time_Delay(0x0FFFFF);
    
30. 
    
31. // 熄灭LED
    . z- F3 y, M( v
32. 
    
33. GPIO_SetBits(GPIOB, GPIO_Pin_0);
    ! e  K% X: P3 g% i1 v, J
34. 
    0 P4 x9 n/ \) T) }1 X  h, M
35. Time_Delay(0x0FFFFF);
    
36. 
      @# J+ l8 e- L7 D
37. }
    
38. 
    ! p+ r4 E' H+ U6 p' y. Q& e4 W
39. }
    # N6 P% |; V5 A5 C6 ]
40. 
    8 @5 R# ~, u; Q. Q4 ^7 t+ `/ t+ w
41. // 简陋的软件延时函数
    / O% A* B6 {9 T" G! W. }
42. 
    ) M9 J7 I! c9 v
43. void Time_Delay(volatile uint32_t Count)
    3 r4 q: }; m- i3 v
44. 
    / x9 a. t4 n( o8 y0 ^) Q
45. {
    % i0 _4 W( j8 x2 }
46. 
    9 G7 Y9 P: ?& k
47. for (; Count != 0; Count--);
    
48. 
    
49. }
    
50. 
    * u) G4 F4 U0 c7 |* I6 u) ^

复制代码

% `5 B" o7 }' f; z& h* G1 L注意void Time_Delay(volatile uint32_t Count)只是一个简陋的软件延时函数，如果小伙伴们有兴趣可以看一看MultiTimer，它是一个软件定时器扩展模块，可无限扩展所需的定时器任务，取代传统的标志位判断方式， 更优雅更便捷地管理程序的时间触发时序。
* ]# y/ B6 d+ p/ M+ A% I0 ~' X————————————————
/ q7 U. T5 i" j5 z+ x( y/ S版权声明：被大佬糊弄的只会点灯的小菜鸡
如有侵权请联系删除