跑马灯实验
0 Q$ ^  L0 U: R# _( _" y本章将通过一个经典的跑马灯程序，带大家开启STM32H750之旅。通过本章的学习，我们将了解到STM32H750的IO口作为输出使用的方法。我们将通过代码控制开发板上的RGB灯：LED0、LED1和LED2交替闪烁，实现类似跑马灯的效果。
0 o3 A7 Q* n" v7 A3 i  i9 E+ W
8 I4 @! r  s/ v# f1 L13.1 STM32H7 GPIO简介
GPIO是控制或者采集外部器件的信息的外设，既负责输入输出。它按组分配，每组16个IO口，组数视芯片而定。STM32H750VBT6芯片是100脚的芯片，它的IO口有82个，IO分为5组，分别是GPIOA-GPIOE。这里GPIOA-GPIOE，16*5=80个IO口，少了两个，还有两个就是PH0和PH1。PH0和PH1用于连接外部高速晶振。
这里重点说一下STM32H750的IO电平兼容性问题，STM32H750的绝大部分IO口，都兼容5V，至于到底哪些是兼容5V的，请看STM32H750VBT6.pdf的数据手册（注意是数据手册，不是中文参考手册），见表：Table 7 STM32H750xB pin/ball definition，凡是有FT标志的，都是兼容5V电平的IO口，可以直接接5V的外设（注意：如果引脚设置的是模拟输入模式，则不能接5V！)，凡是不是FT标志的，大家就不要接5V了，可能烧坏MCU。对 Table 7符号的描述如下：


* i4 @2 q0 h+ n0 @& x
表13.1.1 IO口属性缩写符号表
13.1.1 GPIO功能模式
GPIO有八种工作模式，分别是：
) ]( C! m! B/ x9 k6 F2 P1、输入浮空
/ F0 ]7 z5 u' [: p' i, t2、输入上拉
3、输入下拉
4、模拟
7 K3 A* |9 e- n) _1 B5、开漏输出
6、推挽输出
7、开漏式复用功能
3 U" f- L9 |  E) V/ S& e9 z( H8、推挽式复用功能
2 O5 u* X5 e' P2 Z& U1 `3 k! b
13.1.2 GPIO基本结构分析
我们知道了GPIO有八种工作模式，具体这些模式是怎么实现的？下面我们通过GPIO的基本结构图来分别进行详细分析，先看看总的框图，如图13.1.2.1 所示。
3 z3 a- [) j3 A1 W. I4 K; _  \6 p
3 u# z+ e9 F& H( P: X' Q, E

图13.1.2.1 GPIO的基本结构图
如上图所示，可以看到右边只有I/O引脚，这个I/O引脚就是我们可以看到的芯片实物的引脚，其他部分都是GPIO的内部结构。
; F% @9 X+ \$ Y1 X" k4 g6 N" K① 保护二极管
; R0 {' [6 x* T) I, |) ~) B( g保护二极管共有两个，用于保护引脚外部过高或过低的电压输入。当引脚输入电压高于VDD时，上面的二极管导通，当引脚输入电压低于VSS时，下面的二极管导通，从而使输入芯片内部的电压处于比较稳定的值。虽然有二极管的保护，但这样的保护却很有限，大电压大电流的接入很容易烧坏芯片。所以在实际的设计中我们要考虑设计引脚的保护电路。
% |5 H/ b3 j. g- P# U② 上拉、下拉电阻
它们阻值大概在30~50K欧之间，可以通过上、下两个对应的开关控制，这两个开关由寄存器控制。当引脚外部的器件没有干扰引脚的电压时，即没有外部的上、下拉电压，引脚的电平由引脚内部上、下拉决定，开启内部上拉电阻工作，引脚电平为高，开启内部下拉电阻工作，则引脚电平为低。同样，如果内部上、下拉电阻都不开启，这种情况就是我们所说的浮空模式。浮空模式下，引脚的电平是不可确定的。引脚的电平可以由外部的上、下拉电平决定。需要注意的是，STM32的内部上拉是一种“弱上拉”，这样的上拉电流很弱，如果有要求大电流还是得外部上拉。
③ 施密特触发器
7 ~( U& I- g0 t' o对于标准施密特触发器，当输入电压高于正向阈值电压，输出为高；当输入电压低于负向阈值电压，输出为低；当输入在正负向阈值电压之间，输出不改变，也就是说输出由高电准位翻转为低电准位，或是由低电准位翻转为高电准位对应的阈值电压是不同的。只有当输入电压发生足够的变化时，输出才会变化，因此将这种元件命名为触发器。这种双阈值动作被称为迟滞现象，表明施密特触发器有记忆性。从本质上来说，施密特触发器是一种双稳态多谐振荡器。
施密特触发器可作为波形整形电路，能将模拟信号波形整形为数字电路能够处理的方波波形，而且由于施密特触发器具有滞回特性，所以可用于抗干扰，其应用包括在开回路配置中用于抗扰，以及在闭回路正回授/负回授配置中用于实现多谐振荡器。
下面看看比较器跟施密特触发器的作用的比较，就清楚的知道施密特触发器对外部输入信号具有一定抗干扰能力，如图13.1.2.2所示。

1 g, ^! k# |- U( t& E- x, A

图13.1.2.2 比较器的（A）和施密特触发器（B）作用比较
④ P-MOS管和N-MOS管
1 \) v3 m4 S1 I$ C6 ~9 [这个结构控制GPIO的开漏输出和推挽输出两种模式。开漏输出：输出端相当于三极管的集电极，要得到高电平状态需要上拉电阻才行。推挽输出：这两只对称的MOS管每次只有一只导通，所以导通损耗小、效率高。输出既可以向负载灌电流，也可以从负载拉电流。推拉式输出既能提高电路的负载能力，又能提高开关速度。
上面我们对GPIO的基本结构图中的关键器件做了介绍，下面分别介绍GPIO八种工作模式对应结构图的工作情况。
1、输入浮空
输入浮空模式：上拉/下拉电阻为断开状态，施密特触发器打开，输出被禁止。输入浮空模式下，IO口的电平完全是由外部电路决定。如果IO引脚没有连接其他的设备，那么检测其输入电平是不确定的。该模式可以用于按键检测，RX1等。
. H& ]7 {. @* d+ |1 h/ Q( w) S& n
) ]7 j' s9 N* V
: _. O7 U$ Z6 I/ A& X
# Z2 ]0 m/ z( d6 H% S( R" |图13.1.2.3 输入浮空模式
' F% x5 f$ \0 T" i! P& b& E7 |" A2、输入上拉
  d1 J- y; t: k9 Y, Z9 i# ~% S输入上拉模式：上拉电阻导通，施密特触发器打开，输出被禁止。在需要外部上拉电阻的时候，可以使用内部上拉电阻，这样可以节省一个外部电阻，但是内部上拉电阻的阻值较大，所以只是“弱上拉”，不适合做电流型驱动。

6 U" S9 A, c6 C( {: @; c7 C

$ F. b0 E/ i, t' E; k5 D  K图13.1.2.4 输入上拉模式
9 m9 U: ~- m' \- T1 F  ~& P3、输入下拉
" ^4 ~8 |2 s  x1 a输入下拉模式：下拉电阻导通，施密特触发器打开，输出被禁止。在需要外部下拉电阻的时候，可以使用内部下拉电阻，这样可以节省一个外部电阻，但是内部下拉电阻的阻值较大，所以不适合做电流型驱动。
6 ^$ @& _5 n( e' g5 w! J, A


9 `" i8 `. x! i$ _* P1 z图13.1.2.5 输入下拉模式
4、模拟功能
模拟功能：上下拉电阻断开，施密特触发器关闭，双MOS管也关闭。该模式用于ADC采集或者DAC输出，或者低功耗下省电。


/ {4 Z" P" I1 f; W7 B- p, W- s8 n
4 w, W! o" d+ \0 I图13.1.2.6 模拟功能
5、开漏输出
开漏输出模式：STM32的开漏输出模式是数字电路输出的一种，从结果上看它只能输出低电平Vss或者高阻态。根据《STM32H7xx参考手册_V3（中文版）.pdf》第451页关于“GPIO输出配置”的描述，我们可以推知开漏模式下输出电路大致是这样工作的：
P-MOS被“输出控制”控制在截止状态，因此IO的状态取决于N-MOS的导通状况。
只有N-MOS还受控制于输出寄存器，“输出控制器”对输入信号进行了逻辑非的操作。
IO到输入电路的采样电路仍被打开，且可以选择是否使用上下拉电阻。
3 M: i: Z; K& G9 T7 `3 x根据参考手册的描述，我们替换了“输出控制”部分，作出了如图13.1.2.7的开漏模式下的简化等效图，图中①的输入对应的②的输出是我们最关心的开漏输出的结果。简化后的图13.1.2.7能更好地表示开漏输出模式的输出关系。
开漏输出的具体的理解描述如下：
. X. [; m5 x- @2 K! i开漏模式下，P-MOS管是一直截止的，所以P-MOS管的栅极一直接VSS。如果输出数据寄存器设置为0时，经过“输出控制”的逻辑非操作后，输出逻辑1到N-MOS管的栅极，这时N-MOS管就会导通，使得I/O引脚接到VSS，即输出低电平。
如果输出数据寄存器设置为1时，经过“输出控制器”的逻辑非操作后，输出逻辑0到N-MOS管的栅极，这时N-MOS管就会截止。因为P-MOS管是一直截止的，使得I/O引脚呈现高阻态，即不输出低电平，也不输出高电平。因此要I/O引脚输出高电平就必须接上拉电阻。这时可以接内部上拉电阻，或者接一个外部上拉电阻。由于内部上拉电阻的阻值较大，所以只是“弱上拉”。需要大电流驱动，请接外部的上拉电阻。此外，上拉电阻具有线与特性，即如果有很多开漏模式的引脚连在一起的时候，只有当所有引脚都输出高阻态，电平才为1，只要有其中一个为低电平时，就等于接地，使得整条线路都为低电平0。我们的IIC通信（IIC_SDA）就用到这个原理。
9 ?1 Z& c; `* S9 b4 C另外在开漏输出模式下，施密特触发器是打开的，所以IO口引脚的电平状态会被采集到输入数据寄存器中，如果对输入数据寄存器进行读访问可以得到IO口的状态。也就是说开漏输出模式下，我们可以对IO口进行读数据。


9 t- y5 X. {& O2 |2 H% z9 g7 }
图13.1.2.7 开漏输出模式
! R! a4 r: O3 L$ S1 \6、推挽输出
3 U8 |' x8 V; K6 C# H推挽输出模式：STM32的推挽输出模式，从结果上看它会输出低电平VSS或者高电平VDD。推挽输出跟开漏输出不同的是，推挽输出模式P-MOS管和N-MOS管都用上。同样地，我们根据参考手册推挽模式下的输出描述，列出等效原理如图13.1.2.8所示，根据手册描述可以把“输出控制”简单地等效为一个非门。
推挽输出的具体的理解描述如下：
% \5 I" N& M! j; Q# b+ D3 S4 ^如果输出数据寄存器设置为0时，经过“输出控制”的逻辑非操作后，输出逻辑1到P-MOS管的栅极，这时P-MOS管就会截止，同时也会输出逻辑1到N-MOS管的栅极，这时N-MOS管就会导通，使得I/O引脚接到VSS，即输出低电平。
2 `5 S+ j0 T! j4 S: Y如果输出数据寄存器设置为1时，经过“输出控制”的逻辑非操作后，输出逻辑0到N-MOS管的栅极，这时N-MOS管就会截止，同时也会输出逻辑0到P-MOS管的栅极，这时P-MOS管就会导通，使得I/O引脚接到VDD，即输出高电平。
上面的描述可以知道，推挽输出模式下，P-MOS管和N-MOS管同一时间只能有一个MOS管是导通的。当引脚高低电平切换时，两个管子轮流导通，一个负责灌电流，一个负责拉电流，使其负载能力和开关速度都有很大的提高。
4 |( \- {2 n0 B( ?) L另外在推挽输出模式下，施密特触发器也是打开的，我们可以读取IO口的电平状态。
由于推挽输出模式输出高电平时，是直接连接VDD ，所以驱动能力较强，可以做电流型驱动，驱动电流最大可达25mA。该模式也是最常用的输出模式。
, w: n  l* o8 @5 \6 f
# M& R! Z8 S/ u. Z
2 E& ]( R! e9 l
图13.1.2.8 推挽输出模式
7、开漏式复用功能
开漏式复用功能：一个IO口可以是通用的IO口功能，还可以是其他外设的特殊功能引脚，这就是IO口的复用功能。一个IO口可以是多个外设的功能引脚，我们需要选择作为其中一个外设的功能引脚。当选择复用功能时，引脚的状态是由对应的外设控制，而不是输出数据寄存器。除了复用功能外，其他的结构分析请参考开漏输出模式。
另外在开漏式复用功能模式下，施密特触发器也是打开的，我们可以读取IO口的电平状态，同时外设可以读取IO口的信息。
4 V% C* a) G# \
! K/ K; s/ P& A4 a
. m* u; K: ]5 x4 ]' [5 t
, b- y, d. P9 l图13.1.2.9 开漏式复用功能
8、推挽式复用功能
推挽式复用功能：复用功能介绍请查看开漏式复用功能，结构分析请参考推挽输出模式，这里不再赘述。
0 Y" m  k! Z& Q  u, q, j5 m6 x0 f
3 u. f1 w( K5 e0 \, ?

, z6 q2 v2 k' a; Z图13.1.2.10 推挽式复用功能

, [; ~/ c/ i, t, O13.1.3 GPIO寄存器介绍
STM32H7每组（这里是A~E）通用GPIO口有10个32位寄存器控制，包括 ：
4 个 32 位配置寄存器（MODER、OTYPER、OSPEEDR 和 PUPDR）
2 个 32 位数据寄存器（IDR 和 ODR）
& k' c( e, p$ Q6 r; [/ t1 个 32 位置位/复位寄存器 (BSRR)
/ J( E; [0 {; n0 M% z( l$ S) h7 k  z0 P1 个 32 位锁定寄存器 (LCKR)
( k" g& g' K% n1 P* G- G$ y2 个 32 位复用功能选择寄存器（AFRH 和 AFRL）
4 d! t1 w2 f5 d下面我们将带大家理解本章用到的寄存器，没有介绍到的寄存器后面用到会继续介绍。这里主要是带大家学会怎么理解这些寄存器的方法，其他寄存器理解方法是一样的。因为寄存器太多不可能一个个列出来讲，以后基本就是只会把重要的寄存器拿出来讲述，希望大家尽快培养自己学会看手册的能力。下面先看GPIO的4个32位配置寄存器：
: \5 \" I" Y" _' @" \% ]GPIO端口模式寄存器 (GPIOx_MODER) (x =A…K)
该寄存器是GPIO口模式控制寄存器，用于控制GPIOx（STM32H7最多有11组IO，用大写字母表示，即x=A/B/C/D/E/F/G/H/I/J/K，下同）的工作模式，寄存器描述如图13.1.3.1所示。
, ^! h+ F# I# c' p, o1 l, B- g& O
3 u! s' D1 P4 [

9 v( ~  V" Y) i- l( I! y/ M图13.1.3.1 MODER寄存器描述
每组GPIO下有16个IO口，该寄存器共32位，每2个位控制1个IO。我们看看这个寄存器的复位值，然后用复位值举例说明一下这样的配置值代表什么意思。比如GPIOA的复位值是0xABFF FFFF，低16位都是1，也就是PA0PA7默认都是模拟模式。高16位的值是0xABFF，也就是PA8PA12默认是模拟模式，PA13\PA14\PA15则默认是复用功能模式。而GPIOB的复位值是0xFFFF FEBF，只有PB3默认是复用功能模式，其他默认都是模拟模式。这四个默认是复用功能模式的IO口都是JTAG功能对应的IO口。
) N: \8 k2 q) h+ c( EGPIO端口输出类型寄存器 (GPIOx_OTYPER) (x = A…K)
该寄存器用于控制GPIOx的输出类型，寄存器描述如图13.1.3.2所示。
- H8 R& E6 A( ]0 ?9 y
. w$ v2 t* ?2 ~  O
7 |- S1 N6 j2 r/ x# E$ \
图13.1.3.2 GPIOx OTYPER寄存器描述
$ |# F4 {( h* N该寄存器仅用于输出模式，在输入模式（MODER[1:0]=00/11时）下不起作用。该寄存器低16位有效，每一个位控制一个IO口，复位后，该寄存器值均为0，也就是在输出模式下IO口默认为推挽输出。
; P3 `5 }* a4 \4 `2 p3 O6 SGPIO端口输出速度寄存器 (GPIOx_OSPEEDR) (x = A…K)
该寄存器用于控制GPIOx的输出速度，寄存器描述如图13.1.3.3所示。



% I) _4 N2 J- N" }% v图13.1.3.3 GPIOx OSPEEDR寄存器描述
该寄存器仅用于输出模式，在输入模式（MODER[1:0]=00/11时）下不起作用。该寄存器低16位有效，每两个位控制一个IO口。
( D; s8 k# e+ P( P' {5 PGPIO端口上拉/下拉寄存器 (GPIOx_PUPDR) (x = A…K)
7 l  r( }2 j' J5 D/ }该寄存器用于控制GPIOx的上拉/下拉，寄存器描述如图13.1.3.4所示。

6 P5 J7 G) f! L, ^( H

. ~- U1 Y# l0 Y: c  E: W* N: o图13.1.3.4 GPIOx PUPDR寄存器描述
该寄存器每两个位控制一个IO口，用于设置上下拉，复位后，该寄存器值一般为0，即无上拉或下拉。
' i( ]6 h6 a% ^2 K) P+ T, c上面这4个配置寄存器就是用来配置GPIO的相关模式和状态，它们通过不同的配置组合方法，就决定我们所说的8种工作模式。下面，我们来列表阐述，如表13.1.3.1所示。
& t% c' j' v/ R6 m7 P: i/ t4 ]
# F! J0 x; ~% R  h: t

/ ?7 o! F$ X+ ?表13.1.3.1 4个配置寄存器组合下的8种工作模式
因为本章需要GPIO作为输出口使用，所以我们再来看看端口输出数据寄存器。
端口输出数据寄存器（ODR）
该寄存器用于控制GPIOx的输出高电平或者低电平，寄存器描述如图13.1.3.5所示。


9 P- k7 Z! z% m! v7 f' G/ ^; b  e
图13.1.3.5 GPIOx ODR寄存器描述
该寄存器低16位有效，分别对应每一组GPIO的16个引脚。当CPU写访问该寄存器，如果对应的某位写0(ODRy=0)，则表示设置该IO口输出的是低电平，如果写1(ODRy=1)，则表示设置该IO口输出的是高电平，y=0~15。
除了ODR寄存器，还有一个寄存器也是用于控制GPIO输出的，它就是BSRR寄存器。
端口置位/复位寄存器（BSRR）
$ C2 q+ e! Z# G1 T该寄存器也用于控制GPIOx的输出高电平或者低电平，寄存器描述如图13.1.3.6所示。
( r* L: M0 u& S3 L" W7 d
9 L! ~' C, ^9 @0 q: g1 p# g9 K
- T0 b: K7 x: U. ?+ p
图13.1.3.6 GPIOx BSRR寄存器描述
  m  V+ h" j5 Z) h. \  Y: o为什么有了ODR寄存器，还要这个BDRR寄存器呢？我们先看看BSRR的寄存器描述，首先BSRR是只写权限，而ODR是可读可写权限。BSRR寄存器32位有效，对于低16位（0-15），我们往相应的位写1(BSy=1)，那么对应的IO口会输出高电平，往相应的位写0(BSy=0)，对IO口没有任何影响，高16位（16-31）作用刚好相反，对相应的位写1(BRy=1)会输出低电平，写0(BRy=0)没有任何影响，y=0~15。
4 [2 h# m1 k* I. O6 ]! A. G也就是说，对于BSRR寄存器，你写0的话，对IO口电平是没有任何影响的。我们要设置某个IO口电平，只需要相关位设置为1即可。而ODR寄存器，我们要设置某个IO口电平，我们首先需要读出来ODR寄存器的值，然后对整个ODR寄存器重新赋值来达到设置某个或者某些IO口的目的，而BSRR寄存器，我们就不需要先读，而是直接设置即可，这在多任务实时操作系统中作用很大。BSRR寄存器还有一个好处，就是BSRR寄存器改变引脚状态的时候，不会被中断打断，而ODR寄存器有被中断打断的风险。

13.2 硬件设计
1.例程功能
RGB灯：LED0（红）、LED1（绿）和LED2（蓝）每过500ms一次交替闪烁，实现类似跑马灯的效果。
2.硬件资源
1）RGB灯
LEDR : LED0 - PB4（红）
5 @  U/ w5 C; M0 _+ B1 ZLEDG : LED1 - PE6（绿）
LEDB : LED2 - PE5（蓝）
7 Q4 \5 d0 T. x  Q3.原理图
本章用到的硬件用到RGB灯：LEDR、LEDG和LEDB。电路在开发板上已经连接好，所以在硬件上不需要动任何东西，直接下载代码就可以测试使用。其连接原理图如图13.2.1所示：


- O2 l$ E1 g/ |: [0 l" S2 y
7 V1 v5 W$ s1 }6 C( \3 A7 y) g) m图13.2.1 LED与STM32H750连接原理图
9 h4 W( z: F3 V0 _7 {下面，给大家介绍一下LED灯的压降和额定电流，供大家设计硬件参考。
6 R# k' n$ y  J2 f直插超亮发光二极管压降，主要有三种颜色，然而三种发光二极管的压降都不相同，具体压降参考值如下：
红色发光二极管的压降为2.0V-2.2V。
黄色发光二极管的压降为1.8V-2.0V。
绿色发光二极管的压降为3.0V-3.2V。
0 y' \% l& j! Z+ e4 l  V$ C* ]正常发光时的额定电流约为20mA。
贴片LED压降：
红色的压降为1.82-1.88V，电流5-8mA。
绿色的压降为1.75-1.82V，电流3-5mA。
橙色的压降为1.7-1.8V，电流3-5mA。
蓝色的压降为3.1-3.3V，电流8-10mA。
3 ?3 |6 h/ E/ k) i2 e$ m  h白色的压降为3-3.2V，电流10-15mA。
( U* n! r1 w' @: @: Q4 `LED发光颜色的不同，需要的驱动电压也有差异。我们使用的LED0和LED1是红绿两个颜色的贴片灯珠，它的正常工作驱动电流典型值约为25mA/1.8V。而STM32的GPIO的输出电流也大概是25mA/3.3V，所以可以直接用STM32的IO驱动这种LED。但STM32对总的输出电流有限制，为了经过LED的电流更稳定，我们一般不用STM32的IO直接输出电流驱动LED，而是通过外接电阻的方式限制灌入STM32的电流。如我们使用红灯时灌到IO口的最大电流约为（3.3-1.8）V/510R≈2.94mA。
: U" A/ p* E0 i3 W
, w& v# m$ V& C0 J: i: ^$ {
% F4 }& D- p3 M6 e& Q' ]' L
图13.2.2 STM32 IO的电气参数
7 ^+ g2 F. R# h3 v! ]0 _
# N+ F$ r) C: X9 h% E) p+ ?$ k. B" ?13.3 程序设计
# w* l- V: z  {/ t# W了解了GPIO的结构原理和寄存器，还有我们的实验功能，下面开始设计程序。
13.3.1 GPIO的HAL库驱动分析
" T3 I5 u1 o2 ?  a9 S( w8 ?1 IHAL库中关于GPIO的驱动程序在stm32h7xx_hal_gpio.c文件以及其对应的头文件。
1.HAL_GPIO_Init函数
0 L" L+ x7 C0 W) }& |- ]! O要使用一个外设我们首先要对它进行初始化，所以我们先看外设GPIO的初始化函数。其声明如下：
: [% A  r5 v  N; _$ Jvoid HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init);
函数描述：
- W/ p, X) U5 ?- i用于配置GPIO功能模式，还可以设置EXTI功能。
函数形参：
- R! ~1 A6 `/ c; u1 U- i形参1是端口号，可以有以下的选择：
8 O' B. h- Z; T0 ]1 X* n" p( L: O

1. #define GPIOA               ((GPIO_TypeDef *) GPIOA_BASE)
   
2. #define GPIOB               ((GPIO_TypeDef *) GPIOB_BASE)
   , M5 G( f+ ^3 J4 H9 I
3. #define GPIOC               ((GPIO_TypeDef *) GPIOC_BASE)
   
4. #define GPIOD               ((GPIO_TypeDef *) GPIOD_BASE)
   
5. #define GPIOE               ((GPIO_TypeDef *) GPIOE_BASE)
   ' X7 j' l8 b# {+ P: ~
6. #define GPIOF               ((GPIO_TypeDef *) GPIOF_BASE)
   3 ^& g" p& D. L% I
7. #define GPIOG               ((GPIO_TypeDef *) GPIOG_BASE)
   - X7 v3 z1 U! h2 R. i+ D
8. #define GPIOH               ((GPIO_TypeDef *) GPIOH_BASE)
   ! B- w; \6 @$ L
9. #define GPIOI               ((GPIO_TypeDef *) GPIOI_BASE)
   6 P; D  ?5 F+ t. g0 Y# w6 _. A
10. #define GPIOJ               ((GPIO_TypeDef *) GPIOJ_BASE)
    
11. #define GPIOK               ((GPIO_TypeDef *) GPIOK_BASE)

复制代码

  i8 N5 R/ a- n  @这是库里面的选择项，实际上我们的芯片只能从GPIOA~GPIOE，因为我们只有5组IO口。
形参2是GPIO_InitTypeDef类型的结构体指针变量，其定义如下：

3 g7 G! f3 l8 |; r

1. typedef struct
   # b8 M# x4 S( w/ Q( A1 q* K
2. {
   
3.   uint32_t Pin;               /* 引脚号 */
   # p) R5 L$ i$ G8 c
4.   uint32_t Mode;              /* 模式设置 */
   
5.   uint32_t Pull;              /* 上拉下拉设置 */
   
6.   uint32_t Speed;             /* 速度设置 */
   
7.   uint32_t Alternate;        /* 复用功能 */
   
8. } GPIO_InitTypeDef;

复制代码

$ ?, s8 M% p3 r% G) f1 W7 [# A( ]: S该结构体很重要，下面对每个成员介绍一下。
成员Pin表示引脚号，范围：GPIO_PIN_0到 GPIO_PIN_15，另外还有GPIO_PIN_All和GPIO_PIN_MASK可选。
成员Mode是GPIO的模式选择，有以下选择项：

1. #define  GPIO_MODE_INPUT                  (0x00000000U)          /* 输入模式 */
   1 o* f, z6 l- F8 }$ H* P9 a$ U6 o
2. #define  GPIO_MODE_OUTPUT_PP             (0x00000001U)          /* 推挽输出 */
   9 \  `5 s( ]6 Y
3. #define  GPIO_MODE_OUTPUT_OD             (0x00000011U)          /* 开漏输出 */
   
4. #define  GPIO_MODE_AF_PP                  (0x00000002U)          /* 推挽式复用 */
   9 n# O- I5 `5 R) c& i4 A% q+ y
5. #define  GPIO_MODE_AF_OD                  (0x00000012U)          /* 开漏式复用 */
   
6. 
   8 {5 t! W/ w, Q4 C" K3 h2 p% \
7. #define  GPIO_MODE_ANALOG                 (0x00000003U)         /* 模拟模式 */
   
8. 
   
9. #define  GPIO_MODE_IT_RISING             (0x11110000U)  /* 外部中断，上升沿触发检测 */
   - U( I7 H4 z. n: O; q
10. #define  GPIO_MODE_IT_FALLING            (0x11210000U)  /* 外部中断，下降沿触发检测 */
    
11. /* 外部中断，上升和下降双沿触发检测 */
    0 h7 V# x+ y3 W  c* O& F. z5 ?
12. #define  GPIO_MODE_IT_RISING_FALLING    (0x11310000U)  
    
13. 
    + j, t3 c* L: y# o1 G2 n4 A# q
14. #define  GPIO_MODE_EVT_RISING            (0x11120000U) /* 外部事件，上升沿触发检测 */
    & p8 }+ X1 g- Y; I# }  ?$ O
15. #define  GPIO_MODE_EVT_FALLING           (0x11220000U) /* 外部事件，下降沿触发检测 */
    6 b( a/ {! T. N* d9 z$ |: m
16. /* 外部事件，上升和下降双沿触发检测 */
    
17. #define  GPIO_MODE_EVT_RISING_FALLING   (0x11320000U)
    & P/ \8 q: w0 w% p, d# ?
18. 成员Pull用于配置上下拉电阻，有以下选择项：
    
19. #define  GPIO_NOPULL        (0x00000000U)           /* 无上下拉 */
    ! n/ I6 d1 }' D( P$ p: c+ D* l
20. #define  GPIO_PULLUP        (0x00000001U)           /* 上拉 */
    3 v5 v0 @' S& P# h2 |" o
21. #define  GPIO_PULLDOWN      (0x00000002U)          /* 下拉 */
    
22. 成员Speed用于配置GPIO的速度，有以下选择项：
    7 Q; K6 V9 f- n0 S/ f1 k7 b" B
23. #define  GPIO_SPEED_FREQ_LOW         (0x00000000U)          /* 低速 */
    " F( [' W$ k: z% t9 `9 r
24. #define  GPIO_SPEED_FREQ_MEDIUM      (0x00000001U)          /* 中速 */
    
25. #define  GPIO_SPEED_FREQ_HIGH        (0x00000002U)          /* 快速 */
    
26. #define  GPIO_SPEED_FREQ_VERY_HIGH  (0x00000003U)          /* 高速 */

复制代码

9 R- W, c* T" N' G8 v: z/ }成员Alternate用于配置具体的复用功能，不同的GPIO口可以复用的功能不同，具体可参考数据手册《STM32H750VBT6.pdf》。复用功能的选择在stm32h7xx_hal_gpio_ex.h文件里进行了定义，后面具体用到了，我们在进行讲解。
函数返回值：
7 E  h" A' v: X, H无
注意事项：
) y. N  U0 \3 @2 S* f3 N) pHAL库的EXTI外部中断的设置功能整合到此函数里面，而不是单独独立一个文件。这个我们到外部中断实验再细讲。
- D# j% |6 t! j3 g% e2. HAL_GPIO_WritePin函数
HAL_GPIO_WritePin函数是GPIO口的写引脚函数。其声明如下：
; i  R, V2 M! J9 K# Q' E: Evoid HAL_GPIO_WritePin(GPIO_TypeDef *GPIOx,
uint16_t GPIO_Pin, GPIO_PinState PinState);
函数描述：
5 x. y5 D- H  P8 `% u3 j用于设置引脚输出高电平或者低电平，通过BSRR寄存器复位或者置位操作。
函数形参：
5 O: K: L8 v# n  S形参1是端口号，可以选择范围：GPIOA~GPIOK。
; G' J  u% i7 M0 g9 t5 J' T, b形参2是引脚号，可以选择范围：GPIO_PIN_0到 GPIO_PIN_15。
/ a& B7 Y( d, \3 N形参3是要设置输出的状态，是枚举型有两个选择：GPIO_PIN_SET 表示高电平，GPIO_PIN_RESET表示低电平。
8 n; Q& Y. y" _2 E) q函数返回值：
! Z# A$ ^- ^! J& P2 _" m无
3. HAL_GPIO_TogglePin函数
HAL_GPIO_TogglePin函数是GPIO口的电平翻转函数。其声明如下：
, ]0 [! n: S% n/ f; l/ ^( O1 }void HAL_GPIO_TogglePin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);
$ Y5 g2 ~3 q5 y6 o函数描述：
. {2 Q0 a1 D; y) S  u用于设置引脚的电平翻转，也是通过BSRR寄存器复位或者置位操作。
函数形参：
( E1 r1 ^4 y+ }6 o% c形参1是端口号，可以选择范围：GPIOA~GPIOK。
形参2是引脚号，可以选择范围：GPIO_PIN_0到 GPIO_PIN_15。
函数返回值：
  w' }0 t5 S5 A/ v3 Z* \无
本实验我们用到上面三个函数，其他的API函数后面用到再进行讲解。
GPIO输出配置步骤
" B# ^! \1 @+ ]0 _" U) A; I+ D6 M1）使能对应GPIO时钟
STM32在使用任何外设之前，我们都要先使能其时钟（下同）。本实验用到PB5和PE5两个IO口，因此需要先使能GPIOB和GPIOE的时钟，代码如下:
  ^% n# n4 {* U; ?: L7 U3 m__HAL_RCC_GPIOB_CLK_ENABLE();
; d1 }% s# j2 o- b+ \5 B7 }- y__HAL_RCC_GPIOE_CLK_ENABLE();
2）设置对应GPIO工作模式（推挽输出）
9 i! _7 ]0 g7 N6 L9 ?& T7 e本实验GPIO使用推挽输出模式，控制LED亮灭，通过函数HAL_GPIO_Init设置实现。
3）控制GPIO引脚输出高低电平
在配置好GPIO工作模式后，我们就可以通过HAL_GPIO_WritePin函数控制GPIO引脚输出高低电平，从而控制LED的亮灭了。
+ }/ h$ j) _) a7 D. A13.3.2 程序流程图
; l- x+ A& d! d3 F6 A7 d. m' n程序流程图能帮助我们更好的理解一个工程的功能和实现的过程，对学习和设计工程有很好的主导作用。
9 |3 u  f8 D# K$ x2 o0 X下面看看本实验的程序流程图：



. R" i& v' N# [4 N* g0 l2 z! A图13.3.2.1 跑马灯实验程序流程图
: O$ Q/ Z! B9 T. x# p, F13.3.3 程序解析
+ @+ E8 b  M: s3 S/ Q2 t0 O1.led驱动代码
; }& n- t6 g( x" t/ V! K& c  _这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。LED驱动源码包括两个文件：led.c和led.h。
& ]/ d4 L4 `2 }) E6 x$ V下面我们先解析led.h的程序，我们把它分两部分功能进行讲解。
4 B3 L; N3 u# v( ~$ V由硬件设计小节，我们知道RGB灯在硬件上分别连接到PB4、PE5、PE6，再结合HAL库，我们做了下面的引脚定义。

1. /*****************************************************************************/
   
2. /* 引脚 定义 */
   $ A8 E* L# v. D* t1 u
3. 
   
4. #define LED0_GPIO_PORT                GPIOB
   
5. #define LED0_GPIO_PIN                 GPIO_PIN_4
   % p+ w8 }8 u! h7 K% `
6. /* PB口时钟使能 */
   : F, ^  V1 \( `* V/ ]
7. #define LED0_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)
   
8. 
   / _& m1 K; ^, s7 i7 ~! F
9. #define LED1_GPIO_PORT                GPIOE
   
10. #define LED1_GPIO_PIN                 GPIO_PIN_6
    
11. /* PE口时钟使能 */
    
12. #define LED1_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)
    $ X7 N# `3 w& [' V& {' _7 I
13. 
    9 c" D9 Q7 I+ H9 l/ s; d1 G7 T" A
14. #define LED2_GPIO_PORT                GPIOE
    
15. #define LED2_GPIO_PIN                 GPIO_PIN_5
    , d6 n! l' [  O' F: Z; t
16. /* PE口时钟使能 */
    
17. #define LED2_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)
    
18. /*****************************************************************************/
    0 s! U. |: ~; K4 t/ q& `

复制代码

0 ^" B0 |2 X7 [! O这样的好处是进一步隔离底层函数操作，移植更加方便，函数命名更亲近实际的开发板。比如：当我们看到LED0_GPIO_PORT这个宏定义，我们就知道这是灯LED0的端口号；看到LED0_GPIO_PIN这个宏定义，就知道这是灯LED0的引脚号；看到LED0_GPIO_CLK_ENABLE这个宏定义，就知道这是灯LED0的时钟使能函数。大家后面学习时间长了就会慢慢熟悉这样的命名方式。
: g1 h7 n& v2 \, k% Y) k* H3 i特别注意：这里的时钟使能函数宏定义，使用了do{ }while(0)结构，是为了避免在某些使用场景出错的问题（下同），详见《嵌入式单片机 C代码规范与风格》第六章第2点。
__HAL_RCC_GPIOx_CLK_ENABLE函数是HAL库的IO口时钟使能函数，x=A到K。
为了后续对RGB灯进行便捷的操作，我们为RGB灯操作函数做了下面的定义。

8 n" B0 C) s3 U( t: s8 m, o

1. /* LED端口定义 */
   # T5 [4 H/ C* I, k
2. #define LED0(x)   do{ x ? \
   : P& z- C- b. z0 g# B! n6 `6 s" H2 \
3.                           HAL_GPIO_WritePin(LED0_GPIO_PORT,
   
4. LED0_GPIO_PIN, GPIO_PIN_SET) : \
   ) X6 m. Q: |7 L
5.                           HAL_GPIO_WritePin(LED0_GPIO_PORT,
   + o1 {& l7 o* |
6.                                           LED0_GPIO_PIN, GPIO_PIN_RESET); \
   
7.                      }while(0)       /* LED0 = RED */
   3 S; w2 w8 M, M. V+ n  _
8. 
   : f7 g" o& L! r% z0 Y/ H
9. #define LED1(x)   do{ x ? \
   
10.                           HAL_GPIO_WritePin(LED1_GPIO_PORT,
    
11. LED1_GPIO_PIN, GPIO_PIN_SET) : \
    ' W% Y: ]$ r( H$ K# {
12.                           HAL_GPIO_WritePin(LED1_GPIO_PORT,
    
13. LED1_GPIO_PIN, GPIO_PIN_RESET); \
    0 A- P2 k& f7 Y5 m
14.                      }while(0)       /* LED1 = GREEN */
    
15. 
    
16. #define LED2(x)   do{ x ? \
    # U/ e2 C: V& l8 Z, n  A. b- m- s, s. z
17.                           HAL_GPIO_WritePin(LED2_GPIO_PORT,
    
18. LED2_GPIO_PIN, GPIO_PIN_SET) : \
    
19.                           HAL_GPIO_WritePin(LED2_GPIO_PORT,
    6 U! b& g1 k; @
20. LED2_GPIO_PIN, GPIO_PIN_RESET); \
    
21.                      }while(0)       /* LED2 = BLUE */
    
22. 
      {7 ^2 ~7 y0 V4 \# T
23. /* LED取反定义 */
    
24. #define LED0_TOGGLE()    do{ HAL_GPIO_TogglePin(LED0_GPIO_PORT,
    
25. LED0_GPIO_PIN); }while(0)   /* LED0 = !LED0 */
    0 [, m. B; p7 {0 U7 r3 ?
26. #define LED1_TOGGLE()    do{ HAL_GPIO_TogglePin(LED1_GPIO_PORT,
    
27. LED1_GPIO_PIN); }while(0)   /* LED1 = !LED1 */
    
28. #define LED2_TOGGLE()    do{ HAL_GPIO_TogglePin(LED2_GPIO_PORT,
    
29. LED2_GPIO_PIN); }while(0)   /* LED2 = !LED2 */

复制代码

: i/ \( f8 b0 h$ [7 ^5 C3 }& mLED0、LED1和LED2这三个宏定义，分别是控制LED0、LED1和LED2的亮灭。例如：对于宏定义标识符LED0(x)，它的值是通过条件运算符来确定：当x=0时，宏定义的值为HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_RESET)，也就是设置PB4输出低电平，当n!=0时，宏定义的值为HAL_GPIO_WritePin (LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_SET)，也就是设置PB4输出高电平。所以如果要设置LED0输出低电平，那么调用宏定义LED0(0)即可，如果要设置LED0输出高电平，调用宏定义LED0(1)即可。宏定义LED1(x)和LED0(x)同理。
因为STM32H7不支持位带操作，所以这里我们并没有像F1/F4一样通过位带操作来实现IO口输出输入电平控制。
" l# o  {8 r3 T3 W6 M. \LED0_TOGGLE、LED1_TOGGLE和LED2_TOGGLE这三个宏定义，分别是控制LED0、LED1和LED2的翻转。这里利用HAL_GPIO_TogglePin函数实现IO口输出电平取反操作。
: U% C! ]  j% c9 J1 Z+ B& Q1 h下面我们再解析led.c的程序，这里只有一个函数led_init，这是RGB灯的初始化函数，其定义如下：

1. /**
   " {: n. f# l% V6 n' B
2. * @brief       初始化LED相关IO口, 并使能时钟
   , u8 t  A$ t# Y6 x. S
3. * @param       无
   
4. * @retval      无
   7 q% Y' t6 t9 v/ E" Y. R7 Z
5. */
   
6. void led_init(void)
   
7. {
   
8.     GPIO_InitTypeDef gpio_init_struct;
   
9.     LED0_GPIO_CLK_ENABLE(); /* LED0时钟使能 */
   5 S* t& L$ b3 |7 P' z1 }
10.     LED1_GPIO_CLK_ENABLE(); /* LED1时钟使能 */
    $ e' w3 A% n) f. [+ }/ _
11.     LED2_GPIO_CLK_ENABLE(); /* LED2时钟使能 */
    
12. 
    7 L7 q/ x/ W; q" \& f/ A
13.     gpio_init_struct.Pin = LED0_GPIO_PIN;                 /* LED0引脚 */
    
14.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;                /* 推挽输出 */
    
15.     gpio_init_struct.Pull = GPIO_PULLUP;                          /* 上拉 */
    $ J/ P$ k3 t% H; A& f
16.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;           /* 中速 */
    ( u/ F( i4 m$ L. `0 E+ a5 ^. s! q
17.     HAL_GPIO_Init(LED0_GPIO_PORT, &gpio_init_struct);         /* 初始化LED0引脚 */
    
18. 
    ; c+ D- f( q# G+ A  [8 t7 f. i
19.     gpio_init_struct.Pin = LED1_GPIO_PIN;                 /* LED1引脚 */
    
20.     HAL_GPIO_Init(LED1_GPIO_PORT, &gpio_init_struct);          /* 初始化LED1引脚 */
    + M8 q! E. F2 K4 x7 }" _
21. 
    
22.     gpio_init_struct.Pin = LED2_GPIO_PIN;                 /* LED2引脚 */
    
23.     HAL_GPIO_Init(LED2_GPIO_PORT, &gpio_init_struct);          /* 初始化LED2引脚 */
    , f) K! @' E) P. {
24. 
    ! o. h+ L; M4 _, T2 k2 ^
25.     LED0(1);    /* 关闭 LED0 */
    
26.     LED1(1);    /* 关闭 LED1 */
    
27.     LED2(1);    /* 关闭 LED2 */
    
28. }

复制代码

+ m0 k4 H8 i( z& e- x( g对RGB灯的三个引脚都设置为中速上拉的推挽输出。最后关闭RGB的三个LED灯，防止没有操作就亮了。
8 i- l# b4 j! a( B+ t$ l2 x& r6 O2. main.c代码
9 c" @, H2 Q8 h8 Z6 G在main.c里面编写如下代码：

1. #include "./SYSTEM/sys/sys.h"
     s7 w+ D* }$ ]
2. #include "./SYSTEM/usart/usart.h"
   
3. #include "./SYSTEM/delay/delay.h"
   $ \: k# d' s. N/ T7 }4 Q6 d0 M% ]( y8 [0 u
4. #include "./BSP/LED/led.h"
   & V! p* V  c4 A5 e
5. int main(void)
   
6. {
   
7.     sys_cache_enable();                             /* 打开L1-Cache */
   : w. \+ o9 J4 V- C
8.     HAL_Init();                                       /* 初始化HAL库 */
   1 O( X! G$ y) I# O6 c3 r
9.     sys_stm32_clock_init(240, 2, 2, 4);          /* 设置时钟, 480Mhz */
   
10.     delay_init(480);                                 /* 延时初始化 */
    ' {- F) h' Z* y# \
11.     led_init();                                       /* 初始化LED */
    
12. 
    # G) q5 a2 g% O2 T
13.     while (1)
    : |1 u* n1 k+ G
14.     {
    + h  j; c' `# b4 n3 j7 K
15.         LED2(1);                         /* LED2(BLUE)  灭 */
    
16.         LED0(0);                         /* LED0(RED)   亮 */
    
17.         delay_ms(500);
    9 H) V4 p$ J4 L8 F/ c% ^( }- b: M5 ]
18.         LED0(1);                         /* LED0(RED)   灭 */
    
19.         LED1(0);                         /* LED1(GREEN) 亮 */
    
20.         delay_ms(500);
    3 `- o4 L; L; A: ~+ v. U' @1 M6 z
21.         LED1(1);                         /* LED1(GREEN) 灭 */
    % _5 [( [7 m$ F7 v
22.         LED2(0);                         /* LED2(BLUE)  亮 */
    ! m& R3 \: u( r; H
23.         delay_ms(500);
    % j3 q: r2 p+ s1 ^( i
24.     }
    
25. }

复制代码

首先是调用系统级别的初始化：sys_cache_enable函数使能I-Cache和D-Cache，然后初始化 HAL库、系统时钟和延时函数。接下来，调用led_init来初始化RGB灯。最后在无限循环里面实现LED0、LED1和LED2间隔500ms交替闪烁一次。
+ H% J! P8 \4 o13.4 下载验证
我们先来看看编译结果，如图13.4.1所示。
" V+ Y5 ~; Z( s0 [  j3 V* S
0 s- N1 @, X# V: f; q7 a9 B

& K# V$ n+ @+ b% c3 y9 f' e* i图13.4.1 编译结果
可以看到没有0错误，0警告。从编译信息可以看出，我们的代码占用FLASH大小为：13364字节（12874+714），所用的SRAM大小为：2424个字节（32+2392）。这里我们解释一下，编译结果里面的几个数据的意义：
6 d" D0 J6 X0 ICode：表示程序所占用FLASH的大小（FLASH）。
RO-data：即Read Only-data，表示程序定义的常量（FLASH）。
! h: K% k# ?1 \, z! g7 C9 ZRW-data：即Read Write-data，表示已被初始化的变量（SRAM）
ZI-data：即Zero Init-data，表示未被初始化的变量(SRAM)
有了这个就可以知道你当前使用的flash和sram大小了，所以，一定要注意的是程序的大小不是.hex文件的大小，而是编译后的Code和RO-data之和。
$ A5 G6 k) U0 ?' X. j, `接下来，大家就可以下载验证了。这里我们使用DAP仿真器下载（也可以通过其他仿真器下载，如果是JLINK，必须是V9或者以上版本，才可以支持STM32H750!! 下同）。
下载完之后，可以看到RGB灯的LED0（红）、LED1（绿）和LED2（蓝）轮流亮。
, r: l0 F' \9 v0 N至此，我们的跑马灯实验的学习就结束了，本章介绍了STM32H750的IO口的使用及注意事项，是后面学习的基础，希望大家好好理解。
& L$ j2 U# d4 B; _; |! j0 I0 z————————————————
版权声明：正点原子
) f! J4 g) w4 @
; P7 d* R4 p" ?: @
6 m( c# m) T. A5 ?, I) n2 C