01. 外部中断简介
外部中断的代码主要分布在固件库的 stm32f4xx_exti.h 和 stm32f4xx_exti.c 文件中。
( l  G% H6 V  r( i
% ^1 [: U8 S  ?% Y, H% N0 e! K$ |STM32F4 的每个 IO 都可以作为外部中断的中断输入口，这点也是 STM32F4 的强大之处。STM32F407 的中断控制器支持 22
个外部中断/事件请求。每个中断设有状态位，每个中断/事件都有独立的触发和屏蔽设置。
) u4 I% E! T; b4 p& g# P6 s
2 ?/ r$ }; ~8 I- eSTM32F407 的 22 个外部中断为：
( j# b3 a$ x, E8 u: i# x
. j1 P$ v& ~- U# c& ]EXTI 线 0~15：对应外部 IO 口的输入中断。
EXTI 线 16：连接到 PVD 输出。
1 O, W4 C/ N8 X. {% ?EXTI 线 17：连接到 RTC 闹钟事件。
EXTI 线 18：连接到 USB OTG FS 唤醒事件。
2 H8 f3 Y' q* V9 N2 ZEXTI 线 19：连接到以太网唤醒事件。
EXTI 线 20：连接到 USB OTG HS(在 FS 中配置)唤醒事件。
EXTI 线 21：连接到 RTC 入侵和时间戳事件。
( r& B! n7 {, K, d- r  tEXTI 线 22：连接到 RTC 唤醒事件。
2 h: m0 P0 L4 _2 Y从上面可以看出，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 上了。下面我们看看 GPIO跟中断线的映射关系图：

( ^$ c3 b: G) ]1 v1 L3 L
$ D# H; R! v" b" y7 V1 }. b
02. 外部中断配置
2.1 使能 IO口时钟，初始化 IO

+ t. I2 |9 V3 ?1 h' R& R4 Q( _" y我们要使用 IO 口作为中断输入，所以我们要使能相应的 IO 口时钟，以及初始化相应的 IO 口为输入模式
0 V& m* ^: G. P! w+ B  K: a
2.2 开启 SYSCFG 时钟，设置 IO 口与中断线的映射关系
; b+ F) }" y' P. {% p8 z
只要我们使用到外部中断，就必须打开 SYSCFG 时钟。

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);//使能 SYSCFG 时钟

复制代码

" h( j# d0 ]0 D: q6 T2 M" a6 a  @配置 GPIO 与中断线的映射关系。在库函数中，配置 GPIO 与中断线的映射关系的函数 SYSCFG_EXTILineConfig ()来实现的：
8 d- l. T' E; p% T3 Q

1. void SYSCFG_EXTILineConfig(uint8_t EXTI_PortSourceGPIOx, uint8_t EXTI_PinSourcex);

复制代码

- w# l: ^% Q0 ^% ~( O. z该函数将 GPIO 端口与中断线映射起来，程序示例：
2 p' E8 c- h% N7 V+ `9 v/ j
( i  P# O* G/ w/ [: u

1. SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);

复制代码

2.3 初始化线上中断，设置触发条件
0 j' ?7 S) W+ |9 A' u7 [
中断线上中断的初始化是通过函数 EXTI_Init()实现的。EXTI_Init()函数的定义是：

1. void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct);

复制代码

程序示例

1. EXTI_InitTypeDef EXTI_InitStructure;
   
2. EXTI_InitStructure.EXTI_Line= EXTI_Line4;
     t7 m' m5 ]  R; u1 o
3. EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
   # O6 y. z- A0 f
4. EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
   
5. EXTI_InitStructure.EXTI_LineCmd = ENABLE;
   
6. EXTI_Init(&EXTI_InitStructure); //初始化外设 EXTI 寄存器

复制代码

2.4 配置中断分组（NVIC ），并使能中断

' G; `8 C7 D9 z0 L1 O4 D  Z我们设置好中断线和 GPIO 映射关系，然后又设置好了中断的触发模式等初始化参数。既然是外部中断，涉及到中断我们当然还要设置 NVIC 中断优先级。

1. NVIC_InitTypeDef NVIC_InitStructure;
   / h( \9 s' A4 n9 z
2. NVIC_InitStructure.NVIC_IRQChannel = EXTI2_IRQn; //使能按键外部中断通道
   9 u- B# w- v9 K1 o: K1 f$ \- b4 o* m
3. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02; //抢占优先级 2，
   & y7 n, Q9 x( X7 i
4. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;  //响应优先级 2
   6 I1 [$ N4 M$ n6 O2 v
5. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
   
6. NVIC_Init(&NVIC_InitStructure); //中断优先级分组初始化

复制代码

4 V0 P2 d/ w$ D2.5 编写中断服务函数
* i  F0 v/ T8 M: `* E2 F9 A, o+ s
/ L7 H) s" _( d: y我们配置完中断优先级之后，接着要做的就是编写中断服务函数。中断服务函数的名字是在 MDK 中事先有定义的。这里需要说明一下，STM32F4 的 IO 口外部中断函数只有 7 个，分别为：

1. DCD     EXTI0_IRQHandler                  ; EXTI Line0                                             
   
2. DCD     EXTI1_IRQHandler                  ; EXTI Line1                                             
   4 u! S" y* N6 b* t# \5 O
3. DCD     EXTI2_IRQHandler                  ; EXTI Line2                                             
   & n* P- E7 N. T2 W- o9 l
4. DCD     EXTI3_IRQHandler                  ; EXTI Line3                                             
   / S+ {6 R+ _/ \
5. DCD     EXTI4_IRQHandler                  ; EXTI Line4   
   - ^  ]. w% c0 N( b0 W& |
6. DCD     EXTI9_5_IRQHandler                ; External Line[9:5]s   
   
7. DCD     EXTI15_10_IRQHandler              ; External Line[15:10]s  

复制代码

; Y6 e$ j( m& E( p% O中断线 0-4 每个中断线对应一个中断函数，中断线 5-9 共用中断函数 EXTI9_5_IRQHandler，中断线 10-15 共用中断函数EXTI15_10_IRQHandler。在编写中断服务函数的时候会经常使用到两个函数，第一个函数是判断某个中断线上的中断是否发生（标志位是否置位）
9 f- q' b2 {+ d1 y
) R5 p$ p! E  E* ^9 ?% m* I4 q

1. ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)；

复制代码

这个函数一般使用在中断服务函数的开头判断中断是否发生。另一个函数是清除某个中断线上的中断标志位：
6 {; {# W7 X  F8 x8 n* e
5 b" L! H6 `# Q. i0 k

1. void EXTI_ClearITPendingBit(uint32_t EXTI_Line)；

复制代码

这个函数一般应用在中断服务函数结束之前，清除中断标志位。
) y) h! \% A3 y- b" R9 [5 S
03. 外部中断步骤
: d) z7 u  c$ u( K( @# V使用 IO 口外部中断的一般步骤：
1）使能 IO 口时钟，初始化 IO 口为输入。
2）使能 SYSCFG 时钟，设置 IO 口与中断线的映射关系。
3）初始化线上中断，设置触发条件等。
4）配置中断分组（NVIC），并使能中断。
9 i/ w- Y- b9 i5 {2 ~) M+ y5）编写中断服务函数。
4 c1 w2 f( x7 b
04. 硬件设计
, Z' p" D% m0 g3 o探索者 STM32F4 开发板上载有的 4 个按钮（KEY_UP、KEY0、KEY1 和 KEY2），来控制板上的 2 个 LED（DS0 和 DS1）和蜂鸣器，其中 KEY_UP 控制蜂鸣器，按一次叫，再按一次停；KEY0 控制 DS0，按一次亮，再按一次灭；KEY1 控制 DS1，
% ?. Z- v! o- a3 O效果同 KEY2；KEY2 则同时控制 DS0 和 DS1，按一次，它们的状态就翻转一次。
2 D, C# g* m: z2 @( @3 v$ m! D6 y- u


5 J7 e( L- k7 n; q3 ~05. 程序示例一
2 y. W( ~! E  a8 r- w2 R9 KKEY0控制LED1的翻转
; Q. G. I: m/ O' @7 g3 E6 x4 P4 |
+ A) T6 q- c& N' p* o+ `exti.h文件

1. #ifndef __EXTI_H__
   / N  C! U# r0 H  i
2. #define __EXTI_H__
   
3. 
   
4. #include "sys.h"
   6 Y  N8 o& ]5 t$ G9 O
5. 
   
6. //中断初始化函数
   
7. void EXTIX_Init(void);
   3 F$ p+ U6 {) r) w& w4 s3 a
8. 
   
9. #endif /*__EXTI_H__*/

复制代码

; ^1 n' N7 g* J8 L9 ]$ [exti.c文件

9 `* R$ f, J6 t" V

1. #include "exti.h"
   # B6 M! h: {$ U2 m7 A% E6 \
2. #include "key.h"
   2 b; w" W. s1 Q3 |. s
3. #include "led.h"
   . \4 a0 a/ J2 O5 N" D
4. #include "delay.h"
   1 A- n2 L: j8 M$ ^
5. #include "usart.h"
   5 g& V& d( M# p  t" a7 M7 x9 A
6. 
   # ?) y$ k; O& r/ X$ i% d! K/ |
7. //中断初始化函数
   
8. void EXTIX_Init(void)
   
9. {
   
10.          EXTI_InitTypeDef EXTI_InitStruct;
    ( p: ]% ]. Z* F6 @. B: Y+ [
11.          
    
12.          NVIC_InitTypeDef NVIC_InitStruct;
    
13.          
    
14.          //按键初始化
    
15.          KEY_Init();
    6 a0 x6 a0 V/ `8 ~9 r* k
16.          
    $ e/ Z+ h4 i: \% n* Y
17.          //初始化SYSCFG时钟
    
18.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    
19.          
    * W& T9 k( m4 e
20.          //KEY0 --> PE4
    
21.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource4);
    
22.          
    ( y, t- c9 F5 k: v+ S# f
23.          //配置中断
    
24.          EXTI_InitStruct.EXTI_Line = EXTI_Line4;
    
25.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    
26.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
    7 M/ Q3 D% E) L, t
27.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    
28.          EXTI_Init(&EXTI_InitStruct);
    $ z% h. K) P% N8 E+ q
29.          
    5 q  e# V* m* {2 w( |8 v
30.          //配置中断分组
    & [( ?/ m1 J: j  ?1 F
31.          NVIC_InitStruct.NVIC_IRQChannel = EXTI4_IRQn;
    6 Z( D4 I4 l+ ]# E/ j" s  Y
32.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
33.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    
34.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
35. 
    % L$ ~' E& |- f8 B9 ~
36.          NVIC_Init(&NVIC_InitStruct);
    
37. }
    " z7 M, m: s( i8 A: [
38. 
    
39. //中断线4处理函数
    
40. void EXTI4_IRQHandler(void)
    ( |+ G- a" |/ R! I; G* R: J# e
41. {
    
42.         printf("KEY0按下啦....\r\n");
    
43.         //消抖
    % b, x: |* Z) f: D" {
44.         delay_ms(10);
    
45.         
    ; b) o1 b' V/ o8 H8 R5 O
46.         if (0 == KEY0)
    & y( }/ ?& |( b. J' p. r
47.         {
    
48.                 LED1 = !LED1;
    
49.         }
      c: I8 ?5 ]* T5 J) B
50. 
    ) W5 Q4 e( g: Q* M, w2 [" \
51.         //清中断
    6 `8 \' K. n, J
52.         EXTI_ClearITPendingBit(EXTI_Line4);
    6 ~# F$ k% K% H$ i/ F& C& s
53. }

复制代码

: h6 |- w- ~+ w% P$ W) e) t2 Dmain.c文件
1 O$ }( p6 U" _7 }; t

1. #include "sys.h"
   
2. #include "delay.h"
   - x1 \" s: x8 Z4 d0 e6 J4 c
3. #include "usart.h"
   % |* J8 d2 A* L6 v; k+ S% Q( U
4. #include "led.h"
   
5. #include "beep.h"
   
6. #include "key.h"
   
7. #include "exti.h"
   
8. 
   
9. int main(void)
   
10. {
    & d  a, C+ I$ H8 ^7 }. n0 ~
11.         
    & Q, g) |  d" |* x2 z
12.         BEEP = 0;
    5 f8 ?  k( H- e3 b3 ~3 ^
13.         LED1 = 0;
    2 [# K' |, t: r1 a# m
14.         
    
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    : C5 ^6 h+ \. N
16.         
    
17.         BEEP_Init();
    
18.         LED_Init();
    
19.         
    + U6 b5 D" [% `* {1 @
20.         delay_init(168);
    
21.         uart_init(115200);
    ( y7 j6 i2 R1 ~$ S
22. 
    ) P$ ~0 R0 t8 a8 P
23. 
    
24.         //外部中断初始化
    ( m$ R, H1 n4 u* W9 Y7 l4 G
25.         EXTIX_Init();
    
26.         
    
27.         while(1)
    
28.         {
    2 ~8 r' X- X6 |! T7 Y# A
29.                 printf("程序正在运行.....\r\n");
    $ }! O: m5 K6 }
30.                
    
31.                 delay_ms(1000);
    
32.         }        
    
33. }

复制代码

06. 程序示例二
exti.h文件
9 P/ t4 @+ g& c2 G, x( `% e
+ \/ w0 `3 W& Z" Z7 a

1. #ifndef __EXTI_H__
   . _! W, P6 l: e* L) }5 x
2. #define __EXTI_H__
   
3. 
   " j) w9 L9 @1 `7 {5 G
4. #include "sys.h"
   1 K" m! \  \) _  E0 G  `, @# F! q
5. 
   
6. //中断初始化函数
   # A. m$ D9 M% l9 p
7. void EXTIX_Init(void);
   ; S8 i  y9 d/ D! r' j
8. 
   $ O: s" B# O4 p: u2 {
9. #endif /*__EXTI_H__*/

复制代码

exti.c文件

1. #include "exti.h"
   
2. #include "key.h"
   , E. S2 ]0 g" \3 A$ t0 t, f
3. #include "led.h"
   ; \3 h6 o, V+ v% ^; J* p* |
4. #include "beep.h"
   6 e3 q/ w$ I) v$ J0 [: Q% x
5. #include "delay.h"
   
6. #include "usart.h"
   3 w+ r4 x+ b! ?# F3 k) M* o
7. 
     \4 _$ {( y+ G
8. //中断初始化函数
   * {$ g: j9 O# k1 y' l
9. void EXTIX_Init(void)
   6 d3 }3 E) ~1 x; V
10. {
    * h9 @1 B9 Q* [! o3 N
11.          EXTI_InitTypeDef EXTI_InitStruct;
    
12.          
    
13.          NVIC_InitTypeDef NVIC_InitStruct;
    
14.          
    
15.          //按键初始化
    
16.          KEY_Init();
    
17.          
    ) \+ w! s# K6 E
18.          //初始化SYSCFG时钟
    
19.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    - I3 I) C9 C9 X1 w  E" N+ e
20.          
    6 y# G  w! K- V" V; e  l5 e8 E
21.          //KEY0 --> PE4
    
22.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource4);
    2 g, P# M' \! {; }- P  V9 u9 u( s
23.          
    
24.          //KEY1 --> PE3
    
25.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource3);
    - e& ]5 {* A* K- \* c4 x1 X
26.          
    
27.          //KEY1 --> PE2
    
28.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource2);
    
29.          
    # I$ [( F- g' f/ d  Q+ l
30.          //KEY_UP --> PA0
    - }, [2 J6 t4 S/ Q+ V, ]
31.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);
    
32.          
    ; Z0 X& X8 U% w" y# X3 w4 [: K
33.          //配置中断 KEY0 KEY1 KEY2
    
34.          EXTI_InitStruct.EXTI_Line = EXTI_Line4 | EXTI_Line3 | EXTI_Line2;
    % Q4 U1 Q. b/ I) V
35.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    ! ~: k4 U5 t/ p/ V+ S/ h# n/ `
36.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;
    
37.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    
38.          EXTI_Init(&EXTI_InitStruct);
    
39.          
    ( F" ^3 G( h7 L6 U1 e7 z7 x3 P0 I7 d
40. 
    
41.          //配置中断 KEY_UP
    7 Z, v% K4 ?7 G& l5 y
42.          EXTI_InitStruct.EXTI_Line = EXTI_Line0;
    
43.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    
44.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
    / i; F+ R4 k: y  z% _1 }% d
45.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
      x1 K; g- ?  }, W7 v$ p- ?3 h. [
46.          EXTI_Init(&EXTI_InitStruct);
    5 P* |. U9 }6 [# f" x
47.          
    8 K7 T6 N* f9 z# d5 _2 s
48.          
    4 F) A) {$ l6 x, W) `
49.          //配置中断分组 KEY0
    % k9 T6 L" p3 r: D
50.          NVIC_InitStruct.NVIC_IRQChannel = EXTI4_IRQn;
    
51.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    6 y5 w9 ^% x* D8 C. ]
52.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    * ?( d+ u" o: N" _0 G& |0 B% u
53.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
54. 
    2 F  }$ O5 M+ c# n
55.          NVIC_Init(&NVIC_InitStruct);
    
56.          
    5 d6 m7 d4 l/ f, A7 u0 n% j
57.          //配置中断分组 KEY1
    # ?' L7 j3 s4 U
58.          NVIC_InitStruct.NVIC_IRQChannel = EXTI3_IRQn;
    
59.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
60.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    , B$ a/ C' I2 k6 G5 C7 ~0 _
61.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    ! B; U  l, J+ i  T8 i$ o, [- ?/ }1 H6 ~
62. 
    
63.          NVIC_Init(&NVIC_InitStruct);
    ' x, }( @) ~, Y6 R. y
64.          
    
65.          //配置中断分组 KEY2
    7 J2 S; D- U7 n/ x$ Z
66.          NVIC_InitStruct.NVIC_IRQChannel = EXTI2_IRQn;
    8 Q( Y1 M5 t! z6 K; [
67.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    1 b. ~" V7 k+ b. [- |8 x
68.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    
69.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
70. 
    
71.          NVIC_Init(&NVIC_InitStruct);
    * q* u4 X: K! |" l
72.          
    
73.          //配置中断分组 WK_UP
    8 ?) [* d, e" {2 {
74.          NVIC_InitStruct.NVIC_IRQChannel = EXTI0_IRQn;
    
75.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
76.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    
77.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    . F: z' ]+ h& w# b" Q9 O; w, b
78. 
    
79.          NVIC_Init(&NVIC_InitStruct);
    # }8 |- `# @0 K5 ~7 l; I' p
80. }
    
81. 
    
82. //中断线4处理函数
    5 E' T( u! L9 S6 V! t' }( }
83. void EXTI4_IRQHandler(void)
    
84. {
    ! O$ A( h0 D/ P1 \
85.         printf("KEY0按下啦....\r\n");
    
86.         //消抖
    
87.         delay_ms(10);
    + b! S% A/ s) l1 k) |, M
88.         
    
89.         if (0 == KEY0)
    7 Q, b+ R' l6 ?- m
90.         {
    
91.                 LED1 = !LED1;
    . @& r8 w: ?+ U( l
92.         }
    
93. 
    
94.         //清中断
    
95.         EXTI_ClearITPendingBit(EXTI_Line4);
    % I% F$ ~: v% Y. a( J' D) }
96. }
    
97. 
    5 O% Z. s) v& K! k* L) h' i
98. 
    & P8 v  h" Q* S9 Q" m
99. //中断线3处理函数
    " p- T# d; Z# i
100. void EXTI3_IRQHandler(void)
     ! M, V/ e" m) o& m/ p7 t' `
101. {
     
102.         printf("KEY1按下啦....\r\n");
       y& _  M$ O6 z1 d
103.         //消抖
     
104.         delay_ms(10);
     ' p0 i7 n# G$ Z9 h8 Y' R0 |1 y
105.         
     
106.         if (0 == KEY1)
     
107.         {
     : N  S7 m1 L! b4 {+ @
108.                 LED2 = !LED2;
     , g  Y, {4 ]4 S! [
109.         }
     
110. 
     
111.         //清中断
     ) v% V. b' \: ?0 s& @; T
112.         EXTI_ClearITPendingBit(EXTI_Line3);
     2 V' ^" F  I4 q6 f8 V; {* [: C
113. }
     
114. 
     
115. 
     
116. //中断线2处理函数
     
117. void EXTI2_IRQHandler(void)
     
118. {
     
119.         printf("KEY2按下啦....\r\n");
     * X$ ~& W0 B) ^+ G# O$ I7 G
120.         //消抖
     
121.         delay_ms(10);
     / i2 J! Y8 T. x! H& z% l  k
122.         
     + @/ `8 @$ L, Q
123.         if (0 == KEY2)
     + S% ]6 M( R# T+ m3 t$ ~% i
124.         {
     " s% h: h' z7 D
125.                 LED1 = !LED1;
     + j* n8 ^6 S. E7 }* N
126.                 LED2 = !LED2;
     ! `* S  }% }( S$ v, ?" Z( ]
127.         }
     $ |9 ]$ z5 Z3 A/ a, s
128. 
     
129.         //清中断
     
130.         EXTI_ClearITPendingBit(EXTI_Line2);
     + ]1 n0 E1 f+ ?5 {2 \
131. }
     
132. 
     / ?6 ~. U, M# u. T0 y& `6 P
133. 
     
134. //中断线0处理函数
     8 M* f. M6 J8 |# J! F1 }
135. void EXTI0_IRQHandler(void)
     
136. {
     $ D$ a* N4 l" j) U4 I" Z
137.         printf("KEY_UP按下啦....\r\n");
     2 g. M0 P$ Q' K( e
138.         //消抖
     
139.         delay_ms(10);
     
140.         
     
141.         if (1 == WK_UP)
     
142.         {
     
143.                 BEEP = !BEEP;
     
144.         }
     & `0 O7 e% a/ X0 B* v$ Y' v/ E7 c8 n
145. 
     
146.         //清中断
     
147.         EXTI_ClearITPendingBit(EXTI_Line0);
     
148. }
     

复制代码

4 t0 e8 `6 Q7 O* vmain.c文件
( r- `0 S) a/ M8 f, p9 O- P

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "beep.h"
   
6. #include "key.h"
   ! t5 V2 c0 r- x0 n  _* E% b
7. #include "exti.h"
   & P( t* P% ]; {/ |! z8 R
8. 
   
9. int main(void)
   
10. {
    4 O5 ]% j4 L- }+ q+ b& P$ N; z
11.         
    9 G* k* m# S$ [$ l# S
12.         BEEP = 0;
    
13.         LED1 = 0;
      {: a9 X& _- U- ?* _( z% S2 B
14.         LED2 = 0;
    
15.         
    
16.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    / I0 c( W- ?1 |# x
17.         
    3 B' |* X( ?5 j4 M4 T+ u7 V1 D! _
18.         BEEP_Init();
    1 i( d* f5 Q& o3 P, U- I
19.         LED_Init();
    
20.         
    5 Z! H; Z! i, e* {+ Q
21.         delay_init(168);
    
22.         uart_init(115200);
    
23. 
    4 c) q5 j1 k1 @! r- }$ T
24. 
    
25.         //外部中断初始化
    ' F$ Y  v4 O& q  }; u! T) Z9 F
26.         EXTIX_Init();
    
27.         
    ) J: k; m0 k/ k7 c3 l0 y- {
28.         while(1)
    2 v$ I0 l% W/ Z/ g7 \) w' x4 e) d
29.         {
    
30.                 printf("程序正在运行.....\r\n");
    2 `  P9 j9 O' p
31.                
    # }9 U0 K# Y: v( B. {9 q; v+ J+ r
32.                 delay_ms(1000);
    2 T4 a9 j9 f2 V. ^9 d# E# b* c' @
33.         }        
    - w# Z2 J4 m1 K; Q4 u) L
34. }

复制代码

; L: S" V+ f7 {% c! `7 `