STM32F4系列-外部中断管理-四

[复制链接]

STMCU小助手发布时间：2022-10-24 16:20

文章
文章封面:
文章简介:	STM32F4系列-外部中断管理-四

STM32F4 的每个 IO 都可以作为外部中断的中断输入口，这点也是 STM32F4 的强大之处。STM32F429 的中断控制器支持 22个外部中断/事件请求。每个中断设有状态位，每个中断/事件都有独立的触发和屏蔽设置。
STM32F429有22个外部中断，我们这里只看IO口的16个外部中断：EXTI 线 0~15：对应外部 IO 口的输入中断。

STM32F4 供 IO 口使用的中断线只有 16 个，但是 STM32F4 的 IO 口却远远不止 16 个，那么 STM32F4 是怎么把 16 个中断线和 IO 口一一对应起来的呢？于是 STM32就这样设计，GPIO 的引脚 GPIOx.0-GPIOx.15(x=A,B,C,D,E，F,G,H,I)分别对应中断线 0~15。这样每个中断线对应了最多 9 个 IO 口，以线 0 为例：它对应了

GPIOA.0,GPIOB.0,GPIOC.0,GPIOD.0,GPIOE.0,GPIOF.0,GPIOG.0,GPIOH.0,GPIOI.0。而中断线每次只能连接到 1 个 IO口上，这样就需要通过配置来决定对应的中断线配置到哪个 GPIO 上了。

我举一个例子：我们一个学校（对应一个单片机）有16个老师（对应16根中断线）。但是我们现在有9个班级（GPIOA.0-GPIOI）。每个班级有16个同学(GPIOA_0…..GPIOA_15)。如何让这16位老师负责9个班级一共9X16=144个学生呢？现在的方法就是：让第1个老师负责每个班级的第1位同学。让第2个老师负责每个班级的第2位同学………….,让第16个老师负责每个班级的第16位同学这样就可以了对吧。

下面我们看看 GPIO跟中断线的映射关系图就容易理解多了：
微信图片_20221024162024.png

中断线的映射关系图

哈哈哈是不是通俗易懂！！！

接下来就是写程序了。

程序配置：

1.第一步当然是初始化你的IO口了对吧。比如我们开始写按键的时候是这样写的。

void KEY_Init(void)0 Q! c; h9 J" f- k! y. t, p
{
5 n! _) P) r' U
GPIO_InitTypeDef GPIO_InitStructure;
# |7 Z2 A- W% q; P0 |/ K2 J
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能PA端口时钟
; s- S4 ?( y% J( ?
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; //端口配置. \3 R5 H E# B' s- Z# V/ \: b! t
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入" T# i* R9 b6 I! u' X. x$ `
GPIO_Init(GPIOC, &GPIO_InitStructure); //根据设定参数初始化GPIOC
4 L4 }7 S* b6 c, v
}

复制代码

2.初始化了IO口，接下来我们要干嘛呢？你不是要让按键按下了之后去干别的事吗？那就打开IO口的复用功能：使能EXTI外设对应的时钟。注意：当使用EXTI外设时，使能的是AFIO时钟，而不是EXTI外设时钟

RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);

复制代码

3.现在就是要把中断线和对应的IO口的关系给连接上！
打开stm32f4xx_gpio.h。就看到下面这每个班的16个学生了，整整齐齐的排在这里。因为每一个GPIO都有16个管脚，所以这里最大是从GPIO_PinSource0到GPIO_PinSource15。

微信图片_20221024162016.png

利用GPIO_EXTILineConfig()将EXTI线0连接到端口GPIOA的第0个针脚上
具体代码：

GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource0);

复制代码

注意：如果配置的针脚是4号，那么参数必须是GPIO_PinSource4 如果配置的针脚是3号，那么参数必须是GPIO_PinSource3

4.接下来就是初始化EXTI了：打开stm32f42x_exti.h。就看到这16个老师高兴的站在那里，等待着他的学生(还有几个老师也站在那里但是不是负责GPIO的我们先不管他们)。我们要做的就是让第1个老师去负责第一个班级(GPIOA)的第一个同学(GPIOA_0)。因为你是第一个老师要负责第1个班级自然就是负责班级1的第1个同学啦。

typedef enum
+ l# ~2 s0 K; i J, O
{
! `/ U: F2 e4 w& j1 E
EXTI_Mode_Interrupt = 0x00, //中断触发, L& j- h2 q# }2 r- @, N( `
EXTI_Mode_Event = 0x04 //事件触发5 }+ C4 K& ?) f2 d4 J% n. a& I
}EXTIMode_TypeDef;
4 ~& i7 ?+ x' C
typedef enum# s2 B- `% x5 B& T3 U9 c
{
\1 A$ ]" k3 u1 M/ v
EXTI_Trigger_Rising = 0x08, //上升沿触发- P5 {4 l& Y; R: `$ G! T) \$ W2 z9 w
EXTI_Trigger_Falling = 0x0C, //下降沿触发
+ r$ D1 ` h4 B& o
EXTI_Trigger_Rising_Falling = 0x10 //高低电平触发! s) A) k% t2 \% K) g: F. b0 P
}EXTITrigger_TypeDef;9 H, ^9 K. f& q n
#define EXTI_Line0 ((uint32_t)0x00001) /*!< External interrupt line 0 */
$ Q5 i) x7 l7 `% U5 I; P
#define EXTI_Line1 ((uint32_t)0x00002) /*!< External interrupt line 1 */3 l7 i" q8 y4 `
#define EXTI_Line2 ((uint32_t)0x00004) /*!< External interrupt line 2 */
1 `/ F- X. w( c( y$ l2 S2 h/ c
#define EXTI_Line3 ((uint32_t)0x00008) /*!< External interrupt line 3 */
4 L, a, y/ U. z* k7 `
#define EXTI_Line4 ((uint32_t)0x00010) /*!< External interrupt line 4 */$ f- N- r0 l* N7 r3 m
#define EXTI_Line5 ((uint32_t)0x00020) /*!< External interrupt line 5 */
0 E+ y0 f' b0 t) i u
#define EXTI_Line6 ((uint32_t)0x00040) /*!< External interrupt line 6 */- Y, A' w/ U! |* h0 b& A% N) B
#define EXTI_Line7 ((uint32_t)0x00080) /*!< External interrupt line 7 */0 K0 i2 }) v: Z8 f3 _
#define EXTI_Line8 ((uint32_t)0x00100) /*!< External interrupt line 8 */
. U C d7 h, ?/ p$ d, ^9 V
#define EXTI_Line9 ((uint32_t)0x00200) /*!< External interrupt line 9 */
) h* o% U7 V4 K6 l1 t
#define EXTI_Line10 ((uint32_t)0x00400) /*!< External interrupt line 10 */
! \4 Q; |2 u' T: E- m
#define EXTI_Line11 ((uint32_t)0x00800) /*!< External interrupt line 11 */) d: P2 Q& h+ `. W+ M/ f; Z
#define EXTI_Line12 ((uint32_t)0x01000) /*!< External interrupt line 12 */' U; W, b1 V0 ?4 U
#define EXTI_Line13 ((uint32_t)0x02000) /*!< External interrupt line 13 */
2 `! m1 A9 g, i$ w/ b8 C; u
#define EXTI_Line14 ((uint32_t)0x04000) /*!< External interrupt line 14 */
9 Z F; E& X1 T7 e+ M8 X
#define EXTI_Line15 ((uint32_t)0x08000) /*!< External interrupt line 15 */
. \) K4 A' n5 k5 n
#define EXTI_Line16 ((uint32_t)0x10000) /*!< External interrupt line 16 Connected to the PVD Output */
- u/ l5 {& n" K5 i1 ]7 X
#define EXTI_Line17 ((uint32_t)0x20000) /*!< External interrupt line 17 Connected to the RTC Alarm event */* _; \: l* |2 p( D
#define EXTI_Line18 ((uint32_t)0x40000) /*!< External interrupt line 18 Connected to the USB Device/USB OTG FS Wakeup from suspend event */
1 O2 F% P( B' X$ [& k$ d& e" y. Y
#define EXTI_Line19 ((uint32_t)0x80000) /*!< External interrupt line 19 Connected to the Ethernet Wakeup event */

复制代码

那具体的代码就是下面这样的：

void exti_Init(void); Y; r& }3 |$ r
{
# u* x! v% |# k
EXTI_InitTypeDef EXTI_InitStructure;& G1 Y/ O2 K! M0 }8 m
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); //外部中断，需要使能AFIO时钟* U2 r) E- w- ?- U/ ?5 z! ]
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource0);//将EXTI线连接到对应的IO端口上
1 R i6 }. n5 Y6 p0 W; m _
EXTI_InitStructure.EXTI_Line = EXTI_Line0; //常用的就是EXTI_Line0-EXTI_Line015负责gpio管脚的那几个
( b) K. s) [& m( a* N0 j
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
; w4 h- S3 d( R, M$ c1 b3 W
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿触发; Q }; }) v2 }% X
EXTI_InitStructure.EXTI_LineCmd = ENABLE; //中断线使能
) C7 o+ i0 P, ? i7 Z
EXTI_Init(&EXTI_InitStructure); //初始化中断+ C& ]2 x7 Y2 t) ]8 x; X
}

复制代码

到此为止外部中断就写好了。当然这些函数你可以放在一起，就是下面这样：

void key_exti_init(void)- W* S' q# G, n6 W' [2 o2 v
{ # z/ v7 f M. T: i: |
GPIO_InitTypeDef GPIO_InitStructure;% G6 y2 b6 V# a7 q% @, k7 I5 {( Y4 Z# e
EXTI_InitTypeDef EXTI_InitStructure;& j+ x9 |( o( Z, E" B. Z: ^
L3 U7 J' ^$ C9 z" h
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); //外部中断，需要使能AFIO时钟" e4 ^! L# J- b. Q( q
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能PA端口时钟
* l& _" }9 S# C6 P( O u3 f8 b2 o
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; //端口配置- J l* N7 p; L+ K) g/ U& `. R
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入
9 S% h9 \' h0 H1 r" |- C1 Q& U
GPIO_Init(GPIOA, &GPIO_InitStructure); //根据设定参数初始化GPIOA 2 {1 x4 W+ z* R% I
# M4 @, |6 S" Y- [7 T9 S8 h
//注意：如果配置的针脚是0号，那么参数必须是GPIO_PinSource0 如果配置的针脚是3号，那么参数必须是GPIO_PinSource3 ' \) u) {2 s6 E0 y$ x. d
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource0);//将EXTI线连接到对应的IO端口上9 ^) d( R9 i/ g2 F2 k
//注意：如果配置的0号针脚，那么EXTI_Line0是必须的如果配置的针脚是3号，那么参数必须是EXTI_Line37 e9 D/ H6 I9 E$ B1 p1 P: \
EXTI_InitStructure.EXTI_Line = EXTI_Line0; //常用的就是EXTI_Line0-EXTI_Line015负责gpio管脚的那几个3 E% `3 n. O) X% s5 n# {5 f1 X3 u
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
) S, ~# m$ t. k4 w0 t
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿触发
* R/ N% [' d- f! ?7 |! R
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
; B# j1 I0 z `0 j. x3 Q
EXTI_Init(&EXTI_InitStructure); //初始化中断+ v8 C# { j7 A) M2 V: M
}

复制代码

你以为到次就结束了吗？当然没有。既然有了中断就要有中断优先级。同一时间你爸爸叫你吃饭，正在这时候你女朋友给你打电话。你是先去吃饭了还是先接电话？当然是先接电话对吧。但是单片机可是不知道要先去干嘛。你就必须给他配一下中断优先级。所以就引出了NVIC中断优先级。你要问我NVIC干嘛的，我就告诉你NVIC就是你在同一时间有两个事件来了先干哪一个。这回就有人说了假如我现在有100个事件同时来了先干哪一个呢？不要着急待我细细道来！！！

优先级的定义
在 NVIC 有一个专门的寄存器：中断优先级寄存器 NVIC_IPRx（在 F429 中，x=0…90）用来配置外部中断的优先级，IPR宽度为 8bit，原则上每个外部中断可配置的优先级为0~255，数值越小，优先级越高。但是绝大多数 CM4芯片都会精简设计，以致实际上支持的优先级数减少，在 F429 中，只使用了高 4bit，就是每个外部中断可配置的优先级为0-15。如下所示：

用于表达优先级的这 4bit，又被分组成抢占优先级和子优先级。如果有多个中断同时响应，抢占优先级高的就会抢占抢占优先级低的优先得到执行，如果抢占优先级相同，就比较子优先级。如果抢占优先级和子优先级都相同的话，就比较他们的硬件中断编号，编号越小，优先级越高。

优先级的分组

微信图片_20221024161832.png

这里我们用阶级来表示抢占优先级，用阶层来表示子优先级。通常我们把响应优先级也叫作子优先级。
1.如果我们按照NVIC_PriorityGroup_4这样分组的话，系统就分配了4位抢占优先级。0位响应优先级。就分了16个阶级（2^4=16），0个阶层。

比如我来了一个中断叫做外部中断1(EXTI1_IRQn)。他的抢占优先级就可以设置为0-15.响应优先级就只能设置为0,假如在这个时候又来了一个中断叫做外部中断2(EXTI2_IRQn)。他的抢占优先级就可以设置为0-15.响应优先级就只能设置为0。t他们的优先级可以设置为一样的，也可以设置为不一样的。如果假如都设置抢占优先级为4，那么系统就看哪一个中断先发生，先发生就先执行。

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); //设置NVIC中断分组4:4位抢占优先级，0位响应优先级
; k: K$ [7 ?% B
NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;//使能外部中断通道
; a4 q5 q/ m8 _5 ?# W! U
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 4; //抢占优先级4 因为为分组为4 这里可以设置为0-15) x) q9 R3 q+ r4 B, Q
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //响应优先级0 ; n( ]- \7 V3 D* J" ~ A
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道' }' ^1 O6 G; i4 h3 E, [$ K% @
NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器

复制代码

' Y5 c4 B# I- Y0 `

2.如果我们按照NVIC_PriorityGroup_2这样分组的话，系统就分配了2位抢占优先级。2位响应优先级。就分了4个阶级（2^2=4），4个阶层。

比如我来了一个中断叫做外部中断1(EXTI1_IRQn)。他的抢占优先级就不能设置为0-15，范围应该是0-3，响应优先级范围设置为0-3,假如在这个时候又来了一个中断叫做外部中断2(EXTI2_IRQn)。他的抢占优先级就可以设置为0-3.响应优先级范围也是0-3。同样的他们优先级可以设置为一样的，也可以设置为不一样的。如果外部中断1的抢占优先级为2，子优先级为1，外部中断2的抢占优先级为2，子优先级为0。那么当两个中断同时发生的时候就会首先响应外部中断2，因为外部中断2子优先级高于外部中断1的子优先级.数值越小优先级越高。

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
: O! o5 e% `0 J8 r
NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;//使能外部中断通道7 Y1 H6 t; ]% J1 |, V' {* ~
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //抢占优先级2 因为为分组为2 这里可以设置为0-31 y. z, G7 p% M# n. k5 E: Q
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //响应优先级0
C, N' x0 P: v1 l6 {/ V4 P
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
& R0 v. ~) k9 m
NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
1 X5 C2 c5 B z3 c; L. a; i! b
+ X$ p4 M7 e6 ]. c& V+ j
NVIC_InitStructure.NVIC_IRQChannel = EXTI2_IRQn; //使能外部中断通道/ }- V1 V3 e3 | u2 p' y, i
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;//抢占优先级2 因为为分组为4 这里可以设置为0-3, q9 v& m4 R D6 |% [2 [- S2 r1 q# v5 T
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //响应优先级0 3 R4 J: `. H. W
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
, k, i a; n7 |% v# P7 `' [
NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器

复制代码

一般情况下，系统代码执行过程中，只设置一次中断优先级分组，比如分组2，设置好分组之后一般不会再改变分组。随意改变分组会导致中断管理混乱，程序出现意想不到的执行结果。换句话说NVIC_PriorityGroupConfig();这个函数在你的整个程序中只能设置一次，这个要切记！！！
. v0 z9 @) ^# y% P- @0 _

3.上面我们说到来了一个外部中断1(EXTI1_IRQn)和外部中断2(EXTI2_IRQn)。根据我在最前面讲的一个故事也就是说，用到的管脚与中断线的序号是要一一对应的，不管A--H用的哪一组的管脚，PIN1就要对应EXTI1--PIN15就要对应EXTI15.同时也要对应相应的中断函数,在库函数中EXTI0_IRQn,EXTI1_IRQn,EXTI2_IRQn,EXTI3_IRQn,EXTI4_IRQn,EXTI9_5_IRQn（EXTI5-EXTI9都对应这个中断）,EXTI15_10_IRQn（EXITI10-EXTI15都对应这个中断函数）。这些中断通道全都在stm32f4xx.h中用了一个枚举结构体包起来了。想用哪一个找到对应的通道写上就可以了。

typedef enum IRQn$ y# G4 B9 Z) `" |! ?# ^
{
1 `, d) M; d# d
/****** Cortex-M4处理器异常数 ****************************************************************/
( T+ t' d. \) M
NonMaskableInt_IRQn = -14, /*!< 2 Non Maskable Interrupt */
/ I( j2 @ P' G3 ^3 G
MemoryManagement_IRQn = -12, /*!< 4 Cortex-M4 Memory Management Interrupt */
4 f" J8 |% Z J
BusFault_IRQn = -11, /*!< 5 Cortex-M4 Bus Fault Interrupt */
* ?$ @+ `9 |4 k! g7 F9 Z
UsageFault_IRQn = -10, /*!< 6 Cortex-M4 Usage Fault Interrupt */
# y) v, f, a1 M
SVCall_IRQn = -5, /*!< 11 Cortex-M4 SV Call Interrupt */- c9 o R7 E, j
DebugMonitor_IRQn = -4, /*!< 12 Cortex-M4 Debug Monitor Interrupt */
5 ~# r& K- x. O, l
PendSV_IRQn = -2, /*!< 14 Cortex-M4 Pend SV Interrupt */
1 l5 u! k P3 M1 ^! m7 Z
SysTick_IRQn = -1, /*!< 15 Cortex-M4 System Tick Interrupt */6 m. M4 F( F6 k1 P
/****** STM32 特定的中断数量 **********************************************************************/
( b3 B) m# b9 a& q
WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */2 y& ^* V/ j. V% F- X
PVD_IRQn = 1, /*!< PVD through EXTI Line detection Interrupt */
+ E( f v+ b+ V' G1 C
TAMP_STAMP_IRQn = 2, /*!< Tamper and TimeStamp interrupts through the EXTI line */
/ H# B2 J) J; j% Z, R
RTC_WKUP_IRQn = 3, /*!< RTC Wakeup interrupt through the EXTI line */
* `& y5 Q4 r+ K" X5 d- V
FLASH_IRQn = 4, /*!< FLASH global Interrupt */
3 J2 d* w% i) m% \1 f
RCC_IRQn = 5, /*!< RCC global Interrupt */
2 O2 m' J2 {. T. {
EXTI0_IRQn = 6, /*!< EXTI Line0 Interrupt */
1 B8 X/ x, }' F% ^% X
EXTI1_IRQn = 7, /*!< EXTI Line1 Interrupt */9 X( K% H$ S! k; t; E2 l# B5 l
EXTI2_IRQn = 8, /*!< EXTI Line2 Interrupt */
4 N8 ]( ^7 |" X. L* Q+ g9 z6 A
EXTI3_IRQn = 9, /*!< EXTI Line3 Interrupt */
5 B/ ?8 V7 m. ]/ v. a
EXTI4_IRQn = 10, /*!< EXTI Line4 Interrupt */( H a6 e( G1 {& ~* w) Z3 {
DMA1_Stream0_IRQn = 11, /*!< DMA1 Stream 0 global Interrupt */% O0 U% y/ j# G; K2 M$ F. w
DMA1_Stream1_IRQn = 12, /*!< DMA1 Stream 1 global Interrupt */
1 _/ R( W9 {3 B6 n: N2 F2 v
DMA1_Stream2_IRQn = 13, /*!< DMA1 Stream 2 global Interrupt */
_/ P/ F6 y* G7 o' F6 S
DMA1_Stream3_IRQn = 14, /*!< DMA1 Stream 3 global Interrupt */
, ?6 \$ c# {$ w% f* L) J5 y* B5 @
DMA1_Stream4_IRQn = 15, /*!< DMA1 Stream 4 global Interrupt */# \ @- G& E7 l# A. d
DMA1_Stream5_IRQn = 16, /*!< DMA1 Stream 5 global Interrupt */' J5 `% c {$ e
DMA1_Stream6_IRQn = 17, /*!< DMA1 Stream 6 global Interrupt */8 s+ u9 R4 O* i, G, E! M
ADC_IRQn = 18, /*!< ADC1, ADC2 and ADC3 global Interrupts */
% c7 r% ^+ f9 \7 } N( x
#if defined(STM32F429_439xx)
: Q- |2 g, D2 N% M$ K% k8 U8 y
CAN1_TX_IRQn = 19, /*!< CAN1 TX Interrupt */, L5 P* Z0 j6 L3 ?
CAN1_RX0_IRQn = 20, /*!< CAN1 RX0 Interrupt */# a' ^0 e$ Q0 \* A
CAN1_RX1_IRQn = 21, /*!< CAN1 RX1 Interrupt */
8 x9 i) w( t( E1 q
CAN1_SCE_IRQn = 22, /*!< CAN1 SCE Interrupt */. |# X, ^) o! V# p
EXTI9_5_IRQn = 23, /*!< External Line[9:5] Interrupts */
; x* n' V6 J1 a
TIM1_BRK_TIM9_IRQn = 24, /*!< TIM1 Break interrupt and TIM9 global interrupt */" h U( T# }, ^9 k: h R
TIM1_UP_TIM10_IRQn = 25, /*!< TIM1 Update Interrupt and TIM10 global interrupt */3 X' E7 {- q* w s1 b0 q' t
TIM1_TRG_COM_TIM11_IRQn = 26, /*!< TIM1 Trigger and Commutation Interrupt and TIM11 global interrupt */
0 f3 V$ G/ L# r% h
TIM1_CC_IRQn = 27, /*!< TIM1 Capture Compare Interrupt */* ?# r u7 r$ c; G
TIM2_IRQn = 28, /*!< TIM2 global Interrupt */
/ w5 W- f, t9 p0 o
TIM3_IRQn = 29, /*!< TIM3 global Interrupt */( D% S/ F: ^* D' a9 p- m
TIM4_IRQn = 30, /*!< TIM4 global Interrupt */
2 Q5 @8 K0 c5 \( ^
I2C1_EV_IRQn = 31, /*!< I2C1 Event Interrupt */
: n& d6 T" k! Y2 |( i3 J6 P
I2C1_ER_IRQn = 32, /*!< I2C1 Error Interrupt */" K6 w( `) B U0 G; l9 d- ^$ Z) ]
I2C2_EV_IRQn = 33, /*!< I2C2 Event Interrupt */( y) Y: [) O3 V+ j
I2C2_ER_IRQn = 34, /*!< I2C2 Error Interrupt */: B& h. ^& n5 i' ^/ d" z
SPI1_IRQn = 35, /*!< SPI1 global Interrupt */
- D) K+ W( o& \- p
SPI2_IRQn = 36, /*!< SPI2 global Interrupt */* U3 e8 c, q/ }
USART1_IRQn = 37, /*!< USART1 global Interrupt */
, w" {, k0 c; E3 q
USART2_IRQn = 38, /*!< USART2 global Interrupt */
8 q) d5 D D; v% p8 N
USART3_IRQn = 39, /*!< USART3 global Interrupt */0 T, b1 g. h1 |1 I, ^ i/ m, h
EXTI15_10_IRQn = 40, /*!< External Line[15:10] Interrupts */
' P9 s! W5 c& Q; S1 @! J( }
RTC_Alarm_IRQn = 41, /*!< RTC Alarm (A and B) through EXTI Line Interrupt */, \1 K7 Q* |! }# A* m& q
OTG_FS_WKUP_IRQn = 42, /*!< USB OTG FS Wakeup through EXTI line interrupt */
" P1 G5 i+ a* ^4 O" k/ a
TIM8_BRK_TIM12_IRQn = 43, /*!< TIM8 Break Interrupt and TIM12 global interrupt */7 @' C4 o6 r3 \% A$ j2 m7 v
TIM8_UP_TIM13_IRQn = 44, /*!< TIM8 Update Interrupt and TIM13 global interrupt */3 L; q2 {: C/ f
TIM8_TRG_COM_TIM14_IRQn = 45, /*!< TIM8 Trigger and Commutation Interrupt and TIM14 global interrupt */( u ?( [* f1 K( l
TIM8_CC_IRQn = 46, /*!< TIM8 Capture Compare Interrupt */
9 K& e$ U8 ?# n3 M
DMA1_Stream7_IRQn = 47, /*!< DMA1 Stream7 Interrupt */, g( I* E6 }$ K" _8 \) M
FMC_IRQn = 48, /*!< FMC global Interrupt */
/ J# f ^1 ^. R. z8 [, u
SDIO_IRQn = 49, /*!< SDIO global Interrupt */
, e. X0 Z5 a/ M4 M. o" j' W* m: n
TIM5_IRQn = 50, /*!< TIM5 global Interrupt */' v: ^/ N, C: |, q8 F
SPI3_IRQn = 51, /*!< SPI3 global Interrupt */0 w/ r; K# Q4 ~2 i
UART4_IRQn = 52, /*!< UART4 global Interrupt */9 n# H3 N9 w' x! P9 O# V
UART5_IRQn = 53, /*!< UART5 global Interrupt */8 G* R! \$ F4 [8 l1 F9 q* Z
TIM6_DAC_IRQn = 54, /*!< TIM6 global and DAC1&2 underrun error interrupts */8 j/ l& ~# U8 a! Q9 Z: E
TIM7_IRQn = 55, /*!< TIM7 global interrupt */
: {$ j8 w' h& x- A. O/ ~
DMA2_Stream0_IRQn = 56, /*!< DMA2 Stream 0 global Interrupt */7 D: b( B' U8 s3 v- v
DMA2_Stream1_IRQn = 57, /*!< DMA2 Stream 1 global Interrupt */
2 Z: I$ Z2 N& R& ]' ?
DMA2_Stream2_IRQn = 58, /*!< DMA2 Stream 2 global Interrupt */
+ V2 n. M# H6 o% ?& T
DMA2_Stream3_IRQn = 59, /*!< DMA2 Stream 3 global Interrupt */
, y$ L% d) v5 ?( O1 d- }" G3 p
DMA2_Stream4_IRQn = 60, /*!< DMA2 Stream 4 global Interrupt */
3 ^! J: g' \; S# ^1 y
ETH_IRQn = 61, /*!< Ethernet global Interrupt */: z7 T7 z4 y/ v# {$ e$ I `
ETH_WKUP_IRQn = 62, /*!< Ethernet Wakeup through EXTI line Interrupt */! j7 s! T' L* _/ ?4 I% I
CAN2_TX_IRQn = 63, /*!< CAN2 TX Interrupt */1 m3 P" W) C2 Q K+ j0 [8 n
CAN2_RX0_IRQn = 64, /*!< CAN2 RX0 Interrupt */0 D5 {( f- ^: j7 z
CAN2_RX1_IRQn = 65, /*!< CAN2 RX1 Interrupt */
4 I. y, C6 |& d2 l: n4 d* [# T2 S
CAN2_SCE_IRQn = 66, /*!< CAN2 SCE Interrupt */7 T2 `) p. i9 N$ q6 A
OTG_FS_IRQn = 67, /*!< USB OTG FS global Interrupt */4 @# s" C. D8 Z c+ B
DMA2_Stream5_IRQn = 68, /*!< DMA2 Stream 5 global interrupt */
. w- w' C/ Y7 Q# x x, Y8 a( L, r' D
DMA2_Stream6_IRQn = 69, /*!< DMA2 Stream 6 global interrupt */
* O4 m/ y( u1 n% z9 Y
DMA2_Stream7_IRQn = 70, /*!< DMA2 Stream 7 global interrupt */$ I; X+ l( g' S( J% q5 a9 `$ M7 T
USART6_IRQn = 71, /*!< USART6 global interrupt */
. y6 {2 I) K5 }" i3 a* k
I2C3_EV_IRQn = 72, /*!< I2C3 event interrupt */
+ K3 B0 l* P: Y* m2 v( o
I2C3_ER_IRQn = 73, /*!< I2C3 error interrupt */3 u: I7 D- t) |% `* D1 K7 R8 z* m
OTG_HS_EP1_OUT_IRQn = 74, /*!< USB OTG HS End Point 1 Out global interrupt */. w3 W+ E1 ^5 T/ z
OTG_HS_EP1_IN_IRQn = 75, /*!< USB OTG HS End Point 1 In global interrupt */% y7 _4 U# j' e6 w% M3 s
OTG_HS_WKUP_IRQn = 76, /*!< USB OTG HS Wakeup through EXTI interrupt */3 [1 e% k9 t) {" y2 E" E9 b3 N
OTG_HS_IRQn = 77, /*!< USB OTG HS global interrupt */
/ g$ @( T+ V* u) r( ?
DCMI_IRQn = 78, /*!< DCMI global interrupt */
0 A1 _, t" e2 V
CRYP_IRQn = 79, /*!< CRYP crypto global interrupt */9 Q4 Y% O( H D* d
HASH_RNG_IRQn = 80, /*!< Hash and Rng global interrupt */9 v1 M# [+ M/ H4 Q. ?/ A* u: V- `
FPU_IRQn = 81, /*!< FPU global interrupt */% \8 d: c0 x, a" B3 p( z% _
UART7_IRQn = 82, /*!< UART7 global interrupt */) x; z1 x) l+ B* N1 j- _. ^3 g
UART8_IRQn = 83, /*!< UART8 global interrupt */. a) P7 h* b9 Y+ _7 D( K
SPI4_IRQn = 84, /*!< SPI4 global Interrupt */
! U! D1 @. K2 L& _! X& U
SPI5_IRQn = 85, /*!< SPI5 global Interrupt */6 r. t N \! V5 o e {' b+ [( X# O
SPI6_IRQn = 86, /*!< SPI6 global Interrupt */
/ @- |/ \ P1 t$ G
SAI1_IRQn = 87, /*!< SAI1 global Interrupt */
! i+ q3 ~/ q \" |& z* O+ Q% Q1 p
LTDC_IRQn = 88, /*!< LTDC global Interrupt */, c) X( c9 ?. P k
LTDC_ER_IRQn = 89, /*!< LTDC Error global Interrupt */
( B* l& j O; t5 o H7 u
DMA2D_IRQn = 90 /*!< DMA2D global Interrupt */" R3 b7 x" i, @) H) v _# \
#endif /* STM32F429_439xx */
% \8 S8 q& o/ a. J' U
} IRQn_Type;

复制代码

所以我们结合EXTI和NVIC的代码，就可以整理为

void key_exti_init(void)
* l9 a) B9 |) ^0 P
{
6 u7 Z# L- Y+ H9 \; r% j
GPIO_InitTypeDef GPIO_InitStructure;
* U2 S2 J& K! \$ o, |0 B* N! |5 `3 N
EXTI_InitTypeDef EXTI_InitStructure; 6 {+ P2 s) x3 p1 a( f
NVIC_InitTypeDef NVIC_InitStructure;& W8 R6 N' J+ m# k5 R! J' M
& P9 a% p7 b" g3 w# _4 `) p8 a
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); //外部中断，需要使能AFIO时钟
5 S" p/ G" f- [" m% `- j
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能PA端口时钟
}# s& v1 C6 d) ]- Y/ v
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; //端口配置
v# A3 V" k9 q8 G( R
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入9 ?1 Q1 W6 I! T; N& }
GPIO_Init(GPIOA, &GPIO_InitStructure); //根据设定参数初始化GPIOA
3 x% s) h( `% [% M) f; ]" b
2 O% \1 \0 Q# I1 G9 F5 J
//注意：如果配置的针脚是0号，那么参数必须是GPIO_PinSource0 如果配置的针脚是3号，那么参数必须是GPIO_PinSource3 - y( |5 C. u, t4 Q9 r
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource0);//将EXTI线连接到对应的IO端口上
! \+ h" ~1 S1 D$ m1 r
//注意：如果配置的0号针脚，那么EXTI_Line0是必须的如果配置的针脚是3号，那么参数必须是EXTI_Line3
" T# l6 J/ x9 J1 e! h8 Z$ F
EXTI_InitStructure.EXTI_Line = EXTI_Line0; //常用的就是EXTI_Line0-EXTI_Line015负责gpio管脚的那几个
; {$ R: p2 |# {( P( R8 a, R
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
. k } I( x4 G4 k c' S
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿触发
" W Z" f& u6 n4 { ~
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
) O1 m- ?) l/ m
EXTI_Init(&EXTI_InitStructure); //初始化中断% i' c% Q* e& T
3 n) G: [7 K" y: b2 R
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级 }- t) C, G# _% ~' [4 D" f7 Y, h
NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;//使能外部中断通道
3 f- [6 L [# }5 `' E
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //抢占优先级2 因为为分组为2 这里可以设置为0-3/ D* z# ^9 S: b8 F! g
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //响应优先级0
$ u {/ D1 N; o: {
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
7 _1 k- O9 l, `7 {
NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器$ v! x9 l' ^+ ?6 [* T
}