6.1 STM32结构
从“2.2 ARM与STM32的关系”可知，ARM公司负责设计内核，半导体芯片厂商拿到内核授权后，根据产品需求，添加各类组件，生产芯片售卖。如图 6.1.1 所示，为STM32的组成示意图，其中Cortex-M3内核、调试系统都是ARM公司设计，内部总线、外设、存储、时钟复位等都由ST公司开发。

" c6 O5 L6 \" G6 v- T1 H在编程之前，对STM32的总线结构、存储结构、外设寄存器等有个大致了解，有助于理解编程中的一些操作。此外，中断与异常（Nested Vectored Interrupt Controller，NVIC）、时钟复位（Reset and Clock，RCC）也很重要，且与编程紧密相关，在后面相关实验章节里再专门讲解。
; t5 D) |: K" V; k
/ l. a) H" j$ O, C: m5 w对于开发者，掌握一款MCU的开发需要重点关注四大模块：时钟复位、中断异常、存储映射和外设寄存器组。      

6 b* d/ h9 [' ~2 ]' t; C& K, Q$ M
7 e) L# d  U, `: b8 M5 ?& [
图 6.1.1 STM32组成示意图

- F! t, i( d+ K5 |8 G2 n7 m
) d- Q: Z$ {5 j. r" N3 t6.1.1 STM32总线结构
* a" U$ g$ j  \6 F7 [/ B9 b* ~总线（Bus）是各种信号线的集合，是嵌入式系统中各部件之间传输数据信息、地址信息和控制信息的公共通道。
/ ^  ^$ i( a( h: W3 f
! T- Y5 W0 c, V2 R与总线相关的主要参数有总线宽度、总线频率和总线带宽。总线宽度是指总线能同时传输的数据位数，如8位、32位、64位；总线频率是指总线的工作速度，频率越高，速度越快；总线带宽用来描述总线传输数据的快慢，总线带宽=总线宽度x总线频率/8，单位为MB/s。

STM32的总线结构如图 6.1.2 所示，可以分为6部分。

( G* {) S  M, U" {6 i" G1 A
7 b2 b& h) u7 M* l
图 6.1.2 STM32总线结构框图

$ H- j8 L) Z! t; }) b( r/ V
, o1 Z/ n* N+ |0 o4 I①ICode总线（Instruction bus）：用于访问存储空间里指令的总线；
0 [) m- }* e8 W! O* d  @6 f7 R
3 i7 F( T/ t. S) A! @3 i6 C②DCode总线（Data bus）：用于访问存储空间里数据的总线；

③System总线：用于访问指令、数据以及调试模块接口；

④DMA总线：用于内存与外设之间的数据传输；

⑤Bus matrix（总线矩阵）：用于总线之间的访问优先级管理控制；
6 U* R9 ?- Z5 G+ G
( D( h' X6 _9 V  w⑥APB总线：用于外设接口的数据传输；ARM公司推出AMBA片上总线结构，该总线主要包含先进高速总线（Advanced High-speed  Bus，AHB）和先进外设总线（Advanced Peripheral Bus，APB），分别连接高速设备和低速设备。基于这个总线结构，ICode、Dcode、System Bus都是AHB总线。这里AHB系统总线经过两个AHB-APB桥转换成了两个APB总线。APB1上挂接有DAC、UART等外设，其最高频率可达36MHz；APB2上挂接有ADC、GPIO等外设，其最高频率可达72MHz。

' S8 U7 g; p4 z& p在MCU每次复位后，所有的外设时钟都会默认处于关闭状态。因此，在使用外设前需要操作复位和时钟寄存器(Reset and Clock Control，RCC)开启所需外设的时钟。

' f$ R+ X+ |, V1 Y" o# X
; K# h+ p6 F" K. A' j6 `0 v6.1.2 STM32存储结构
CPU通过总线访问各个外设，现在通往外设的“路”已经铺好，还需要规定各个外设的“门牌号”，以便精准控制每个外设。ARM Cortex-M3系列的处理器，采用存储器与I/O设备（外设）统一编址的方式，将部分存储器地址范围用于外设，这种通过存储器地址访问外设的方式，称为存储器地址映射。

对于32位的处理器，可寻址的范围为232字节，即，也就是0x00000000至0xFFFFFFFF。ARM将这4G空间从低地址到高地址依次划分为代码区（Code）、片上SRAM区（SRAM）、片上外设（Peripheral）、片外RAM（External RAM）、片外外设（External Device）和系统级（System level），如图 6.1.3 所示。
% n; _3 E; x+ b) ^+ R/ {3 j0 r% X

图 6.1.3 ARM Cortex-M3存储器映射结构图

5 U6 g! P3 C, v2 A+ F9 ^2 G" O ARM公司只是大概的规定了存储器空间的映射，允许各芯片厂商在指定范围内自行定义和使用这些存储空间，未分配的空间为保留的地址空间。
, H6 V) y6 o: O- k" `( ~
STM32在ARM规定的基础上，将4G空间分为了Block0、Block1、Block2、……、Block7，共8块，每块大小为512MB，如下表 6.1.1 所示，详细结构如图 6.1.4 所示。
# U3 K, n/ \; S. @' I0 r

* R) p' r* s2 V) P7 z
0 D5 n0 O( ?. M: q; {表 6.1.1 STM32存储器映射结构
% o; a2 a- p' d3 ^1 l
) V. j5 s. o$ X6 @$ I
2 [  }3 g4 B, J' s7 V
图 6.1.4 STM32存储器映射结构
: q9 N5 H$ |) z. C% y0 J0 X
. k) A& }2 i/ J' U  ~. \( u①0x0000 0000 ~ 0x1FFF FFFF(512MB)：作为代码区，用于存放下载的代码。系统上电后，将从该部分读取代码；
* A( X8 y: h, c4 ?3 `
& ?; O  n, ~# O- C$ \# a$ c②0x2000 0000 ~ 0x3FFF FFFF(512MB)：作为SRAM区，用于存放运行代码。系统上电后，将从Flash读取代码，放到SRAM里，CPU再从SRAM读取代码运行；

2 X7 t7 ?+ x+ L2 |0 L7 {③0x4000 0000 ~ 0x5FFF FFFF(512MB)：作为片上外设区，用于存放厂商外设寄存器。要操作外设，即修改这里对应的外设寄存器；注意这里的RCC和Port B外设的地址范围，后面很快就会用到；
7 J2 a* d0 F2 V' @! |, _
④0x6000 0000 ~ 0x9FFF FFFF(1GB)：作为片外RAM，用于扩展RAM。当SRAM或者Flash不够用时，MCU通过FSMC外接其它IC芯片，则在这个地址范围读写IC芯片数据；
  E* |8 z" z" k- |, V# I* j
⑤0xA000 0000 ~ 0xDFFF FFFF(1GB)：作为片外外设区，用于读写扩展IC芯片的寄存器。ST只用了这里的一半空间，另外一空间未使用；

& s! n" |- T: e3 q1 D⑥0xE000 0000 ~ 0xFFFF FFFF(512MB)：作为内核外设区，用于存放Cortex-M3内核的内部外设。Cortex-M3内核的内部外设有NVIC、Systick等；

7 ~* a$ }3 Y& O在Block0、Block1圈出的三个范围，分别对应前面介绍的三个启动模式。当从主存储器启动，则是从Flash启动；当从系统存储器启动，则是从System memory启动；当从SARM启动，则是从SRAM启动。
' v9 w! V, g1 R- B+ L
对于开发人员，通常就是对Block2的片上外设寄存器进行读写操作，以控制外设资源，实现所需效果。
5 U5 F1 h% N# r6 O% b

1 \1 }8 z. q. t) P3 g: J6.1.3 STM32寄存器
寄存器是用来存储二进制数据的时序逻辑电路，由众多晶体管组成。
0 |+ ^$ F) o& H% d5 D$ i8 g  N2 {
前面提到的寄存器，都是外设寄存器。这些外设寄存器由芯片厂商设计，与存储器统一编址，常用C语言的指针来表示外设寄存器地址，实现对外设寄存器的访问和操作。
. x. ^8 L& r; L! D* x; R
6 v; h) I, q# I; o7 A: S在嵌入式系统中，除了外设寄存器，还有一类叫CPU内部寄存器。这些内部寄存器由ARM设计，在CPU内部，常用汇编语言直接操作，用于暂存参与运算的数据和内核的一些控制。
, e4 y/ k2 c( Y9 T. G7 Y+ B8 [
开发人员，通常只操作外设寄存器实现需求功能，后面实验会详细讲解外设寄存器。而内部寄存器在实际开发中接触会比较少，后面汇编点灯实验会涉及部分相关知识，本小结简单介绍下内部寄存器。

ARM Cortex-M3微处理器的内部寄存器，又分为普通寄存器和特殊功能寄存器。普通寄存器如图 6.1.5 所示。



3 ^+ O& U3 G1 p3 E& }. g, @图 6.1.5 Cortex-M3通用寄存器
* H  _. w1 f5 Y: X0 ^: v
! `2 p6 |# N8 ^' \) \
1 @: b; G, Z; z2 B' _! }R0-R12（General-Purpose Registers）：用于数据操作的32位通用寄存器；一些16位的Thumb指令，只能访问低寄存器（R0~R7）；

% X: G% M. d0 F# Y' C  s# `R13（Stack Pointers，SP）Cortex-M3包含两个堆栈指针寄存器；同一时刻只能看到其中一个；
' H. x3 F5 Y" p4 c- @
主堆栈指针寄存器（Main Stack Pointer，MSP）：操作系统（OS）内核和异常处理程序使用的默认堆栈指针；

进程堆栈指针寄存器（Process Stack Pointer，PSP）：用于用户代码；

R14（Link Register，LR）：链接寄存器；调用子例程时，返回地址将存储在链接寄存器中；

R15（Program Counter，PC）：程序计数器；总是指向下一条指令所在单元的地址，可以写入该寄存器以控制程序流；

Cortex-M3处理器还具有许多特殊寄存器，如图 6.1.6 所示。
2 [9 J  K; K) ]9 j  @' ]4 ~/ [
7 s& S2 ~* `6 x+ V

图 6.1.6 Cortex-M3特殊寄存器


: e7 _- c4 x3 @& o2 X3 BxPSR（Program Status registers）：程序状态寄存器；用于存放程序运作中的各种状态信息以及中断等状态；由应用状态寄存器（APSR）、中断状态寄存器（IPSR）和执行状态寄存器（EPSR）组成；

PRIMASK、FAULTMASK和BASEPRI：中断屏蔽寄存器；用于控制异常和中断的屏蔽；
1 a" u1 R% `; M
. w  T) x8 ]% z/ h, j# }CONTROL：控制寄存器；用于定义特权状态和当前使用哪一个堆栈指针；
- E/ m- m2 x3 n, _2 O9 G
3 O) @8 @" l' A6 L3 S! t# }3 N
& a& c+ b, V- }* c# M【总结】
( s0 i! J* ?3 z# ^; S9 L2 {: Q
7 y% \2 A# ?  A: w+ _STM32由ARM公司设计的Cortex-M3内核与ST公司开发的外设资源组成。

Cortex-M3内核有内部寄存器，主要用于运算和内核的控制，这块对于初学者较难，暂时了解即可。
) C+ Q+ i5 c1 I, [
Cortex-M3内核通过总线和外设连接，重点了解大部分外设都挂载APB即可。

" G, g+ A( p3 V/ }+ ]. ZSTM32采用存储器与外设统一编址的方式，控制外设，则对应操作指定地址的外设寄存器即可，这是后续实验的重点。
. E$ h. f2 c( Z. u
% ~- z; V  z3 Z* t. o4 G
  q- U7 U6 N% z. E# m
1 G% h. v" o  R; _0 M6.2 使用汇编开发
汇编语言（Assembly Language）是一种用于电子计算机、微处理器、微控制器或其它可编程器件的低级语言。

% K0 }: \$ o, R' G% x9 b$ z( R在单片机出现之初，由于性能限制，都是使用汇编进行开发。随着技术的发展，制程工艺的提升，单片机的处理速度越来越快，越来越多的单片机使用C语言开发。如今，一些低端MCU还在使用汇编开发；一些高要求程序优化的场合也会使用汇编；MCU/MPU的启动初始化部分也是汇编。本小结就带领读者感受下如何使用汇编操作开发板LED灯。
: p) @! w3 C2 d9 W2 q
在编写代码前，本应该分析《开发板原理图》和《参考手册》，从而得知需要操作哪些外设寄存器，但这不是本小结主要内容，具体的分析方法放在后面对应的实验章节，读者暂时无需深入理解以下内容的由来：
+ \5 z( |( M6 w2 `& H: Z" Z& W$ S
+ U  ^6 c. f$ |4 a0 a3 M' _1. 从《开发板原理图》可知，控制GPIOB 0引脚，即可控制开发板三色灯的红色灯；

2. 从前面STM32总线结构分析可知，GPIOA挂载APB2上，由RCC控制；
: L" V4 J9 J, f3 l2 b" G5 }
3. 从前面STM32存储结构分析可知，RCC起始地址为0x4002 1000，再仔细查看《参考手册》RCC寄存器部分，可知寄存器RCC_APB2ENR（偏移地址：0x18）的第2位（IOPAEN），设置为1则GPIO A组的使能；

6 T# F/ y! S' `2 [5 i" z! W4. 从前面STM32存储结构分析可知，GPIO A起始地址为0x4001 0800，再仔细查看《参考手册》GPIO寄存器部分，可知寄存器GPIOx_CRL（偏移地址：0x00）的第4:5位（MODEy），设置为1则GPIO A1为输出，寄存器GPIOx_ODR（偏移地址：0x0C）的第1位（ODRy），设置为1则GPIO A1为输出高，设置为0则GPIO A1为输出低；
8 H8 u" h9 V/ k

有了以上基础，就可以编程控制LED灯了，本章涉及的代码位于100ASK_STM32F103_MINI开发板资料的“5_程序源码\0_单片机开发模式的发展\1_使用汇编开发\”。

0 o' S4 |' t/ V& R/ g1 G5 H如代码段 6.2.1 所示。汇编代码对初学者不友好，读者对代码内容不理解也正常，也无需深入理解汇编指令，这里主要目的是展示如何用汇编操作寄存器。
6 P5 g/ B0 M$ Y7 E' S
1 C3 [  E3 |5 i$ u代码段 6.2.1 汇编操作寄存器（startup_stm32f10x_md.s）
$ s8 C3 g* \; ~' j" k* Q/ ~
4 B8 J, X! C3 h5 R0 t" Q" S* s+ R

1. ; Reset handler
   
2. 
   ) X6 T* E% k+ f" l5 r6 T6 X
3. Reset_Handler   PROC
   
4. 
   ( C0 Z/ f0 ^' e4 M, l2 Z
5. 
   
6. 
   
7.     ; 使能GPIOA
   + V: H! V8 O( p
8. 
   
9.     LDR R0, =(0x40021000 + 0x18)  ; RCC_APB2ENR
   / _, D/ ?9 u5 Y* Z. J0 k! V
10. 
      o6 M0 N2 H. I/ ^+ D8 F: |
11.     LDR R1, [R0]
    ) W0 f1 {! F( O! M% V, O. H
12. 
    9 R6 Z" V8 N5 H- j# B) w
13.     ORR R1, R1, #(1<<2)
    
14. 
    * O* y1 C1 v9 W: M4 g
15.     STR R1, [R0]
    
16. 
    
17. 
    
18. 
    . X5 F/ X; B0 h
19.     ; 设置GPIOA1为输出引脚
    % \4 q# i6 o, g3 l( q3 a% p
20. 
    
21.     LDR R0, =(0x40010C00 + 0)  ; GPIOA_ CRL
    $ Q( R3 U, v0 [! R
22. 
    / ?; v2 x7 V% a( |+ K% K. `' o
23.     LDR R1, [R0]
    9 V; b& e2 N- Q- F3 T, b$ \8 i' N
24. 
    
25.     ORR R1, R1, #(1<<4)
    
26. 
    & W& r* \  Z2 p- {$ D
27.     STR R1, [R0]
    ' ^( S0 J) ^# L- U  [1 l
28. 
    7 f* ~, }* L4 ?
29. 
    * ~. H+ ?: F; l4 l
30. 
    4 |, m* D0 ~0 Q2 Z: O( y2 f
31. MainLoop
    - W4 i6 r4 C; l3 P+ Y2 N4 c2 W
32. 
    - M: @5 p/ `  n# C' d; K
33.     ; 设置GPIOA1输出高电平
    
34. 
    
35.     LDR R0, =(0x40010800 + 0xC)  ; GPIOA_ODR
      y$ Y8 j* R4 \
36. 
    
37. 
    
38. 
    $ i- m1 B% @! ~5 Q+ l7 f
39.     LDR R1, [R0]
    & L+ B' K' `- w' u+ y
40. 
    
41.     ORR R1, R1, #(1<<1)
    5 j0 ?% ?1 t+ u8 f  y( G9 S( b2 W
42. 
    
43.     STR R1, [R0]
    
44. 
    
45.     BL Delay
    
46. 
    3 h+ r- ?/ _. O6 _, O( R6 E  `
47. 
    
48. 
    ! f/ a! K. \5 l
49.     ; 设置GPIIOA1输出低电平
    
50. 
      Z* s6 C" A# p4 }4 ?
51.     LDR R0, =(0x40010800 + 0xC)  ; GPIOA_ODR
    
52. 
    : |! O4 i- a! K: u7 d7 Z" P
53.     LDR R1, [R0]
    
54. 
    0 K  |( L1 L3 y3 K
55.     BIC R1, R1, #(1<<1)
    7 @4 |# f* a/ r' l  j* Y' q
56. 
    ' w0 \5 Z4 `6 k5 w* U' P
57.     STR R1, [R0]
    2 o4 z! L3 D: M3 ~8 u; W
58. 
    
59.     BL Delay
    
60. 
    
61.     B MainLoop
      q0 _2 B% Q/ N  \8 Z# E4 H
62. 
    3 n' |8 A; s  X: D. q
63. 
    
64. 
    / B7 A; G# ]" P, T# Q' {
65. Delay
    
66. 
    
67.     LDR R0, =300000
    ' z; F/ y% \; o! v. Q: z0 K% ?
68. 
      l' e6 p7 {7 y! P- i
69. DelayLoop
    4 H6 i% d# W. `! w* Z: ^
70. 
    
71.     SUBS R0, #1
    
72. 
    1 ]" w! Z/ d9 X# {+ I9 L
73.     BNE DelayLoop
    
74. 
    
75.     BX LR
    
76. 
    
77.     NOP
    % V6 Y9 G7 y! v0 h, M$ x
78. 
    ' u* v$ D" }- q* O1 E
79.     ENDP
    , [/ X' F1 j9 H
80. 
    - J, s( N/ r' @) G
81.     END

复制代码

4~8行：设置外部寄存器RCC_APB2ENR的第2位（IOPAEN）为1，使能GPIO A组的时钟；

. O5 O: k4 n6 ~% i, W5行：将0x40021018（RCC_APB2ENR的基地址+偏移地址）放入内部寄存器R0中；
2 S: v: I) M5 s
# `! B) D$ c2 v6行：将0x40021018地址的值（此时RCCC_APB2ENR寄存器的值），放入内部寄存器R1；

. q: Y/ [1 g6 t7行：将R1的Bit2设置为1，并将设置后的结果放入R1；

8行：将R1的内容，放入R0所指向的地址，也就是将修改后的数据放入RCCC_APB2ENR寄存器；
2 ?6 _# E8 q8 `2 T: a8 ]# ?$ G
10~14行：设置外部寄存器GPIOA_ CRL的第4:5位（MODE）为1，让GPIO A1为输出模式；

16~30行：设置外部寄存器GPIOA_ODR的第0位（ODR）先后为1和0，让GPIO A1为输出高、低电平；

32~40行：循环减R0实现延时效果；
6 h) B6 M. ?0 |+ h! N& p; C5 @
以上汇编代码就实现了开发板用户LED灯（蓝色）交替闪烁效果，读者可以打开配套资料的“5_程序源码\0_单片机开发模式的发展\1_使用汇编开发\ Project\Led_Reg.uvprojx”工程，编译、下载，体验效果。
* n9 x6 `2 y7 k2 G9 l
& r) j0 h. b7 Q2 q3 _可以感受到，使用汇编编写程序，生涩难懂，因此越来越少的单片机使用汇编来编写代码，下面再来体验下C语言实现一样的效果。
8 f& u! t2 A+ T: j) X
9 m6 k" Y/ D$ ]6 k7 O; w" z
6.3 C语言操作寄存器开发
在使用C语言操作寄存器前，仍需要先分析《开发板原理图》和《参考手册》，从而得知需要操作哪些外设寄存器，假设读者已经了解需要操作哪些外设寄存器。

本章涉及的代码位于100ASK_STM32F103_MINI开发板资料的“5_程序源码\0_单片机开发模式的发展\2_C语言操作寄存器开发\”。

使用C语言之前，需要先设置栈，如代码段 6.3.1 所示，在上电复位后立即设置栈，随后跳入main函数执行。

代码段 6.3.1 设置栈（startup_stm32f10x_md.s）

) w; `( c- S7 I

1. ; Reset handler
   9 G1 R8 J- Q- c
2. 
   
3. Reset_Handler   PROC
   
4. 
   
5.                 IMPORT  main
   8 b6 f9 ~7 d; n/ h
6. 
   - F& Q0 h$ _, z4 V2 z
7.                 LDR     SP, =0x20000000+0x100
   
8. 
   
9.                 BL      main
   ! g5 O4 H3 y5 Y' \! ^
10. 
    1 L0 Z, n" e) {3 z; b
11.                 ENDP
    6 t* @. f8 C2 b, H% t) g; `  X
12. 
    
13.                 END

复制代码

代码段 6.3.2 C语言操作寄存器（main.c）

1. #define RCC_APB2ENR  (0x40021000 + 0x18)
   * ?" u  H- {# t+ X0 S/ O, G# R
2. 
   
3. #define GPIOA_BASE   (0x40010800)
   
4. 
   
5. #define GPIOA_CRL    (GPIOA_BASE + 0)
   3 {: r. o% p: v6 c( E2 E* z
6. 
   
7. #define GPIOA_ODR    (GPIOA_BASE + 0X0c)
   ; M+ C1 Y1 [" `3 B: T+ e: g' f  `2 l
8. 
   2 q" s* ]3 u- I0 `8 O; O6 a
9. 
   0 c9 ]+ P1 i; u; s* l
10. 
    8 x% H# C* V5 v5 c" E
11. void delay(volatile long i)
    " @' |0 R. }; ?% e* P
12. 
    
13. {
    
14. 
    & c1 _2 @6 i% R& R9 k; j2 m
15.     while (i--);
    
16. 
    8 O- |2 r$ H. C1 {: m( z- [
17. }
    
18. 
      P) J" q6 C0 O9 x% ^) N- a
19. 
    
20. 
    
21. int main(void)
    
22. 
    
23. {
    & L- a! N% d  [7 c: O
24. 
    2 T7 S4 d& x. K! Y6 Z
25.     volatile unsigned int *pRccApb2Enr;
      t7 a9 [+ K  E& N
26. 
    ( ?5 i2 F2 k+ k" `- `* F! b# t+ ^5 {
27.     volatile unsigned int *pGpioaCrl;
    ! m, \! S8 C" r- ?, u/ e; i( P# ]$ {
28. 
    
29.     volatile unsigned int *pGpioaOdr;
    
30. 
    
31. 
    / o+ j  }, l+ ?% m, k% {
32. 
    4 K) {) o! s. _
33.     pRccApb2Enr = (volatile unsigned int *)RCC_APB2ENR;
    
34. 
    ; d2 I5 o4 D3 v/ A
35.     pGpioaCrl   = (volatile unsigned int *)GPIOA_CRL;
    $ Q8 U( D* c. J) g8 }5 C( [
36. 
    
37.     pGpioaOdr   = (volatile unsigned int *)GPIOA_ODR;
    2 m8 S4 O& X/ }" k
38. 
    
39. 
    
40. 
    
41.     /* 1. 使能GPIOB的时钟
    . h/ C) V+ D3 m8 I6 q
42. 
    
43.       * GPIO是挂载在APB2上的，所以我们要使能APB2的外设时钟使能位
    # T9 A& ~5 f2 M3 e3 e7 y4 x, I
44. 
    . Y! Q( ^  w- ?
45.       * 从RCC_APB2ENR寄存器描述中我们可以看到APB2ENR[8:2]是GPIO[G:A]时钟的控制位，控制GPIO时钟是失能或者使能
    + m" w8 t. Z1 @
46. 
    
47.       * 开发板上的LED的GPIO组是使用的GPIOA，即要使能APB2ENR[2]位，为其赋值“1”即可打开GPIOA的时钟 */
    ; ^& ]% ~8 S8 P- L* T
48. 
    
49.     *pRccApb2Enr |= (1<<2);
    , R- \% k. }; l5 u+ e  w
50. 
    
51. 
    
52. 
    
53.     /* 2. 设置GPIO为输出功能:
    
54. 
    
55.      * MODE_0=1,PB0输出模式，输出速率最大10MHz
    
56. 
      G; @7 T! P, ^* M* g8 }" i$ q
57.      */
    3 r0 w* R1 e8 p3 q
58. 
    
59.   *pGpioaCrl |= (1<<4);
    # W4 D1 K; i4 e/ I5 _# `5 U0 s
60. 
    
61. 
    * u! z# i. K5 K9 Q* `8 P- t* B  I, B
62. 
    9 @5 d' d; u5 i; J) W6 }4 Z
63.     while (1)
    
64. 
      e' S3 z4 i1 ?# {
65.     {
      V5 P  {- m8 A/ o) c
66. 
    
67.     *pGpioaOdr |= (1<<0);
    5 D) f$ ?3 Z3 G. ]: N9 m
68. 
    
69.         delay(1000000);
    
70. 
    
71.     *pGpioaOdr &= ~(1<<0);
    3 `- f( P' E0 {, T% D
72. 
    $ C! X# f: X3 C* [, d" `. R9 i2 C; B
73.         delay(1000000);
    # _. w8 B2 U8 H1 Y. c. T6 A  Q
74. 
    
75.     }
    
76. 
    0 @, w* T7 o9 j- W* C4 @" j- Z; f# d
77. }

复制代码

5 j1 n6 M6 L8 _) z3 C
主函数如代码段 6.3.2 所示。
% l! }  J0 Z2 }7 A1 k4 q. O2 _* R5 ~
1~4行：用宏定义了需要用到的各外设寄存器地址：RCC_APB2ENR、GPIOA_ CRL、GPIOA_ODR；
6 k, O  s, V6 M& [9 \
! F: p3 o* L- h0 I. r4 B0 J6~9行：循环递减传入的变量i，实现延时效果；

7 ?3 i' s" h$ H8 [0 ]) p/ Q) f13~15行：定义指针变量；
: Y' X0 F* }! a
17~19行：设置指针指向对应寄存器；
% W! `. x2 i( r" l: g  I
25~30行：设置RCC_APB2ENR、GPIOA_ CRL对应位；
. l: j, i, t1 I4 L1 f
32~38行：循环修改GPIOA_ODR实现LED灯交替闪烁；
5 G! [% ~4 R" `( N* K( H
( ~7 u4 N3 Z) K2 L4 j  b以上代码就实现了开发板用户LED灯（蓝色）交替闪烁效果，读者可以打开配套资料的“5_程序源码\0_单片机编程模式的发展\ 2_C语言操作寄存器开发\ Project\Led_Reg.uvprojx”工程，编译、下载，体验效果。
) r5 `' T! n* r; U0 i
使用C语言后，只需定义指针变量指向对应寄存器，修改该指针变量的值，即可修改对应寄存器，操作上方便了很多。


4 h3 H& R, p9 n+ P
3 f& t$ P9 ^6 F8 _6.4 C语言使用标准库开发
! \" }+ J8 }2 J( O) G4 |$ f* i前面的两种开发方式，适用于任何一款芯片，但需要仔细阅读《参考手册》找到对应寄存器，然后用指针变量指向寄存器。

ST公司为了让用户更快上手开发，产生用户粘性，将外设寄存器提前定义好，准备一些常用接口函数供用户使用，这就是标准库的雏形。

8 G; h; d& Z: E! X! b4 d下面来感受下使用标准库的简便性。使用标准库通常不需要知道外设寄存器地址，只需要分析《开发板原理图》得知会用到哪一个引脚。

$ X3 p: H4 s* c本章涉及的代码位于100ASK_STM32F103_MINI开发板资料的“5_程序源码\0_单片机开发模式的发展\2_C语言使用标准库开发\”。

首先使用C语言需要设置栈，这些初始化操作标准库已经帮忙完成了，我们只需要编写主函数即可，如代码段 6.4.1 所示。

7 `, K. u, M# s; \7 o, V9 Z1 E代码段 6.4.1 C语言使用标准库开发（main.c）

! o5 T  A- a6 i' a# ~

1. #include "main.h"
   1 d2 F" a' I  l
2. 
   
3. #include "stm32f10x.h"
   * e* J/ C* h! D* y5 B
4. 
   
5. #include "driver_led.h"
   
6. 
   & V0 a% g3 b* n3 {% q
7. 
   ; |' p- m: g0 f; }8 _
8. 
   
9. void delay(volatile long i)
   % L6 O, }- T, Q
10. 
    7 S5 ]! l/ g& V/ p0 F$ o$ M
11. {
    
12. 
    0 R5 S1 [. s/ N. U- [
13.     while (i--);
    ( ~4 w  ]3 a" I3 i- e  Z* G
14. 
    - u9 A6 Y6 Y' \$ t+ s9 a  {, a
15. }
    " O0 v, I( |( A" ^0 c; v/ m
16. 
    
17. 
    
18. 
    $ {9 `/ i0 f% k- b$ D
19. int main(void)
    4 G. w" l9 _$ M+ m. n% Z8 [+ ]
20. 
    
21. {
    
22. 
    
23. 
    
24. 
    
25.     // 初始化LED
    7 Y# D; g8 i9 g/ A
26. 
    ; V" j, D. j2 [: L) M6 t" Y) \
27.     LedGpioInit();
    
28. 
    9 ?% d  I4 d: N
29. 
    ) a" K/ |7 ~( z/ u! i" v" V1 V
30. 
    ; i2 y$ w+ k/ ^- Y# O3 n4 d
31.     // 点亮LED灯
    
32. 
    ( s3 l- F9 `) Y: a( }: a; o2 u/ s
33.         while(1)
    ! V3 {& o9 l+ X7 ~; Z! G
34. 
    
35.         {
    
36. 
    
37.             GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
    
38. 
    
39.             delay(1000000);
    5 g2 ~6 a# g1 G4 [
40. 
    - }! u) m6 C& `' t# ?
41.             GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_RESET);
    
42. 
    7 U0 _: g+ V9 ^7 x% T
43.             delay(1000000);
    ) H# J# L' m4 @' [1 I& X( N, `' |
44. 
    4 O6 L! ]0 Q8 w$ X
45.         }
    8 t% i+ k4 @: p! Q6 }
46. 
    
47. }
    8 r5 A7 y8 L! [* d8 o

复制代码

1 ]6 r9 e% I3 M9 K1 F6 q
; O+ T$ ~7 T% k- _5 N' Q, g5~8行：循环递减传入的变量i，实现延时效果；

2 g9 p; p- T$ a$ {8 ?$ k14行：调用编写的“LedGpioInit()”函数，初始化需要的GPIO，该函数定义在“driver_led.c”里，如代码段 6.4.2 所示；
* I& f- S* Y! {
3 `1 v! q' I6 ?" Q1 y. _7 ?5 n17~23行：循环修改GPIOA_ODR实现LED灯交替闪烁；这里不再涉及寄存器操作，只需要调用标准库提供的“GPIO_WriteBit()”函数即可，该函数需要三个参数，分别是：GPIO端口、该端口引脚号、电平高低。这里操作GPIOA 1引脚，因此传入“GPIOA”、“GPIO_Pin_1”、“Bit_SET”或“Bit_RESET”，使用这些宏定义，用户基本就无须查阅《参考手册》，上手相对容易很多；
. i$ A4 @* D' J) _
代码段 6.4.2 GPIO初始化（driver_led.c）
2 w+ o' a9 `% q. U- ]. i/ b, G# |
; g* `4 }0 `3 ?8 `# q2 m, I

1. #include "driver_led.h"
   
2. 
   % K5 P3 l& A! T3 v3 o6 L6 T
3. 
   4 B  m/ j; H8 X) R. c9 i( L
4. 
     ^5 }+ O) i9 ]) r) X
5. /*
   
6. 
   / Q3 [6 D, k5 w) c
7. *  函数名：void LedGpioInit(void)
   ! [: r7 x0 F/ F9 W
8. 
   
9. *  输入参数：无
   . F: K5 A( [1 a9 f6 I9 O& c* J! z
10. 
    0 E8 E" j' h. W5 O% s% M& T
11. *  输出参数：无
    
12. 
    
13. *  返回值：无
    3 ?' T$ T/ T( e9 G8 z" x
14. 
    & ]- \; M# }( f2 b+ G2 F5 x- a
15. *  函数作用：初始化LED的引脚，配置为推挽输出
    
16. 
    
17. */
    
18. 
    4 F, C5 k, g9 n" @* Z
19. void LedGpioInit(void)
    
20. 
    ! X+ [+ L$ ^+ W- {0 D5 U$ X' @
21. {
    ( O& _4 Y0 i. d
22. 
    
23.     // 定义GPIO的结构体变量
    
24. 
    6 O3 u" l- u4 W( C5 s6 s
25.     GPIO_InitTypeDef GPIO_InitStructure;
    
26. 
    
27.     // 使能LED的GPIO对应的时钟
    ( w1 c' z2 j( r8 ^" L% m
28. 
    
29.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
30. 
    . x& ^  g3 a# x9 ]; Y4 @* l
31. 
    . a2 O% n' V/ H2 o* _! e! L" b
32. 
    
33.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;         // 选择LED的引脚
    
34. 
    
35.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  // 设置为推挽输出模式
    
36. 
    
37.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 引脚反转速度设置为快
    
38. 
    
39. 
    6 M, e3 b$ D4 Y0 D
40. 
    . r8 F( ]/ Q: X0 D. m! F# Y! F! C8 x/ X
41.     // 初始化引脚配置
    
42. 
    
43.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    / Y. I2 ?# h( h! Z0 x5 b! r
44. 
    " R) e$ [* m$ `8 r7 K" e9 |
45. }

复制代码

0 a8 y7 K; K7 ]15行：使用标准库提供的“RCC_APB2PeriphClockCmd()”，传入需要设置的外设名字、是否使能；

13~22行：将GPIO属性封装为结构体，通过设置结构体成员的属性，完成对GPIO的设置；
, b4 }, U4 V' Z: m
. s1 S) R+ Q7 o1 R" i: \0 ]$ r/ c
# F% v2 ]6 g1 J# d/ V" o. G
以上代码就实现了开发板用户LED灯（蓝色）交替闪烁效果，读者可以打开配套资料的“5_程序源码\0_单片机编程模式的发展\ 3_C语言使用标准库开发\ Project\ Led_Standard.uvprojx”工程，编译、下载，体验效果。

9 C! ~& p1 J2 \2 _使用标准库后，基本不涉及外设寄存器的地址，同时提供很多函数实现相关功能的操作，用户只要熟悉之后，很快就能举一反三，修改相关传入参数，实现自定义需求。
+ u8 L; u3 Z2 G+ w- p' @

  r; L7 _9 f- C  ^/ @% M3 ?( T
6.5 C语言使用HAL库开发
ST公司先后推出了两套主要库：标准外设库（Standard Peripherals Library）和HAL库（Hardware Abstraction Layer）。标准外设库是STM32最早发布的固件库，对STM32芯片进行了完整的封装，包含所有外设的性能特征，每个外设驱动都由一组函数组成，这组函数覆盖了该外设所有功能。因为发布比较早，教程比较多，目前仍有不少开发者使用。标准外设库是针对某一系列STM32芯片而设计的，没有可移植性，目前该库已将停止了更新、研发，最近几年发布的新STM32芯片已经不再支持。

/ q' F* I6 E, g7 r& y; w9 g5 }HAL库是ST公司这几年极力推荐的官方库，目前支持STM32全系产品，可以说HAL库就是用来取代之前的标准外设库的。相比标准外设库，HAL库具有更高的抽象整合水平，API集中关注外设的公共函数功能，使得可以轻松实现从一个STM32产品移植到另一个不同的STM32系列产品。此外还有LL库（Low Layer），相比其它固件库更接近硬件层，一般和HAL库结合使用，可以看作是HAL库的补充。

本章涉及的代码位于100ASK_STM32F103_MINI开发板资料的“5_程序源码\0_单片机开发模式的发展\2_C语言使用HAL库开发\”。
5 s5 E9 j& I& U
HAL库和标准库的使用区别不大，也无需知道外设寄存器地址，主函数如代码段 6.5.1 所示。

代码段 6.5.1 C语言使用HAL库开发（main.c）
; J. @) |' I9 f% c) s% j. u8 [1 x

1. #include "main.h"
   
2. 
   
3. #include "driver_led.h"
   
4. 
   
5. 
   
6. 
   
7. int main(void)
   ( ^& d) e$ q+ r) C" R1 S
8. 
   2 g8 G. \7 |# K- Y
9. {
   
10. 
    
11.     // 初始化HAL库函数必须要调用此函数
    
12. 
    
13.     HAL_Init();
    
14. 
    / E/ z$ k: p$ p( c
15.     // 系统时钟即AHB/APB时钟配置
    
16. 
    
17.     SystemClock_Config();
    
18. 
    * I/ w/ S5 u( D1 Q
19. 
    1 R& ^; m0 V9 N
20. 
    % K4 ]  }' v+ {' A6 @& ?# V
21.     // 初始化LED
    3 K- x/ }7 }# B' C% m& ]
22. 
    
23.     LedGpioInit();
    0 p' O; [3 c4 B" d. i
24. 
    
25. 
    
26. 
    
27.     // 点亮LED灯
    0 U4 ?  F8 ]$ n; b% h' K
28. 
    
29.     while(1)
    4 ~- x- u3 O$ x0 Z$ e  `
30. 
    " C7 I8 O4 {& f$ m9 l% \; y! N2 y
31.     {
    
32. 
    
33.       HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);
    * `3 n! t4 g8 A+ s
34. 
    3 j/ l; ~9 A3 {# k. }4 `# i+ y
35.       HAL_Delay(1000);
    + y" C+ ?' r+ q( \8 S8 J' p4 f
36. 
    ( [; w% P, \  F  B9 {/ I
37.       HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);
    ; K3 a5 N! [  `# Y0 k; C
38. 
    
39.       HAL_Delay(1000);
    + d3 b$ k+ |  s
40. 
    
41.     }
    
42. 
    - ?! _% T9 w7 p" p; u' S& G
43. }

复制代码

; _. J- b) U# t# Y/ L3 A2 k6~9行：使用HAL的一些初始化操作；
3 X0 N! Q/ h1 O0 U. U1 [
; z  L- X' ?( j' C+ V' v4 e7 y* i" C11~12行：调用编写的“LedGpioInit()”函数，初始化需要的GPIO，该函数定义在“driver_led.c”里，如代码段 6.5.2 所示；
$ Z# @1 y7 Z9 h9 I' O% B
. `/ p6 ^: ^2 O4 p/ [& J) t- P7 a, Y15~21行：通过调用HAL提供的“HAL_GPIO_WritePin”函数控制引脚输出的电平高低；HAL库还提供延时函数“HAL_Delay()”，用户不用再自己编写延时函数；
( K: U! M/ P: H
+ y6 ?# c) T, d) H6 f* {代码段 6.5.2 GPIO初始化（driver_led.c）

1. #include "driver_led.h"
   
2. 
   " ~/ y* s4 _# q+ A8 |0 x
3. 
   - r/ ?$ }/ e: {( i6 y7 }. N
4. 
   5 M5 c9 V! M* U, W: p6 C
5. /*
   8 a1 W% I1 H9 T( H0 _3 C
6. 
   
7. *  函数名：void LedGpioInit(void)
   
8. 
   ' J5 j- ^4 J! L/ j- e. l6 f
9. *  输入参数：无
   6 v! b; z7 J% b5 `' U" I
10. 
    ! E) {7 n5 E/ a0 e; Y
11. *  输出参数：无
    ' K- g8 V! x- [; h8 R3 Y
12. 
    - {: I) |: o) E. C. u+ t
13. *  返回值：无
      G' O- b* K3 x
14. 
    
15. *  函数作用：初始化LED的引脚，配置为上拉推挽输出
    
16. 
    
17. */
    
18. 
    / \" w4 {5 l# B; q$ d: j" a+ b8 T6 Z0 d
19. void LedGpioInit(void)
    
20. 
    
21. {
    
22. 
    ! B$ R. K( w0 ^( J
23.     // 定义GPIO的结构体变量
    
24. 
    ' @  L. ?: X- Q) r4 A. I
25.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
26. 
    ! q: Q6 ^% a; j) R; e- f# h! y8 [) G
27.     // 使能LED的GPIO对应的时钟
    
28. 
    & k8 g, k( n: L2 l  x$ _
29.     __HAL_RCC_GPIOA_CLK_ENABLE();
    
30. 
    : Z. z( @4 J9 y7 U/ X4 M' _
31. 
    ( V& @6 N% X+ K/ G8 f
32. 
    
33.     GPIO_InitStruct.Pin = GPIO_PIN_1;         // 选择LED的引脚
    0 [' q3 {0 y+ ]* z, ^
34. 
    9 Y* B; N* e1 O7 p1 r( j
35.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // 设置为推挽输出模式
    1 V- }8 F6 h3 e0 \% e
36. 
    
37.     GPIO_InitStruct.Pull = GPIO_PULLUP;         // 默认上拉
    
38. 
    
39.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;// 引脚反转速度设置为快
    , l$ ?% |. q* k5 ~9 K2 l) O
40. 
    ( K. Z6 f( J3 M4 ?
41. 
    . A$ D& Z: V1 h" _
42. 
    8 }8 ?" m7 Q# Z
43.     // 初始化引脚配置
    % b( ?! E5 B" j1 T, ^2 X( N
44. 
    
45.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    - |9 B) p3 u: U' {
46. 
    
47. 
    % {  i3 d  b. q* ~
48. 
    2 b) ]* D2 {9 [2 k. {* P% g
49. }
    

复制代码

' c; ]% |' g4 X, o. |
15行：使用HAL库提供的“__HAL_RCC_GPIOB_CLK_ENABLE()”使能GPIO A端口时钟；
9 }  A5 u( f, ?1 a+ I
/ ?2 Y. O' `% z13~23行：将GPIO属性封装为结构体，通过设置结构体成员的属性，完成对GPIO的设置；

; h( Y- x5 k0 C0 o$ e3 M
2 _5 `/ U; t2 D! Z5 p1 v  I
) y2 h" ]) N: V以上代码就实现了开发板用户LED灯（蓝色）交替闪烁效果，读者可以打开配套资料的“5_程序源码\0_单片机编程模式的发展\ 4_C语言使用HAL库开发\ Project\ Led_Hal.uvprojx”工程，编译、下载，体验效果。

使用HAL库的体验和标准库差不多，但HAL兼顾了其它ST芯片，用户可以无缝过渡到ST其它芯片的使用。各开发模式之间的差异如表 6.5.1 所示。
5 J2 u; U. P8 g% Q


1 {9 _+ c) p, k9 W( y# F! J表 6.5.1 各开发模式差异
. g+ n- O7 C7 [  e4 o5 h

【总结】

# B- _7 \% l4 h本章开始讲解了一些STM32结构的基础知识，这些知识对STM32的整体理解会有很大帮助，读者应多理解。

随后介绍的四种开发模式，读者重点理解C语言操作寄存器开发和使用HAL库开发。后续的实验会以HAL库为主，但读者也应理解HAL库的本质也是操作寄存器，因此理解如何操作寄存器，对以后学习、调试，都会有帮助。     
1 S3 N6 E4 U; k( x
8 w* U! g. r& a) O' U