01. 外部中断简介
外部中断的代码主要分布在固件库的 stm32f4xx_exti.h 和 stm32f4xx_exti.c 文件中。

STM32F4 的每个 IO 都可以作为外部中断的中断输入口，这点也是 STM32F4 的强大之处。STM32F407 的中断控制器支持 22
" z6 j8 P) A& |7 n- P8 y7 i个外部中断/事件请求。每个中断设有状态位，每个中断/事件都有独立的触发和屏蔽设置。

STM32F407 的 22 个外部中断为：
( S, s, x* I9 P+ H5 C
EXTI 线 0~15：对应外部 IO 口的输入中断。
EXTI 线 16：连接到 PVD 输出。
: K- ]! B* t/ u" b0 iEXTI 线 17：连接到 RTC 闹钟事件。
EXTI 线 18：连接到 USB OTG FS 唤醒事件。
EXTI 线 19：连接到以太网唤醒事件。
EXTI 线 20：连接到 USB OTG HS(在 FS 中配置)唤醒事件。
7 {$ [; y! B) L* r" A- P5 @/ kEXTI 线 21：连接到 RTC 入侵和时间戳事件。
EXTI 线 22：连接到 RTC 唤醒事件。
3 B9 Q: I* G* b9 M9 M从上面可以看出，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跟中断线的映射关系图：


# y2 \: k8 {; w9 Z  g
' N( B8 g$ [$ z4 p- t* E  S: I" j8 m4 l02. 外部中断配置
2.1 使能 IO口时钟，初始化 IO
- s7 U- G. P, W. T
我们要使用 IO 口作为中断输入，所以我们要使能相应的 IO 口时钟，以及初始化相应的 IO 口为输入模式
$ b8 Z# e: p- Y* p( E
' L: _* ?: g5 t9 k2.2 开启 SYSCFG 时钟，设置 IO 口与中断线的映射关系
. a( ]9 A2 E! T* R; o3 H  B
8 g; W8 O2 v7 [% @. _0 j  X2 j只要我们使用到外部中断，就必须打开 SYSCFG 时钟。
; x4 d- \# o" J

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

复制代码

配置 GPIO 与中断线的映射关系。在库函数中，配置 GPIO 与中断线的映射关系的函数 SYSCFG_EXTILineConfig ()来实现的：
( R0 ~/ `# `0 q
7 I' t# p4 q* H" X. z  [

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

复制代码

% G" u2 d1 m" ]' d% S# `4 u该函数将 GPIO 端口与中断线映射起来，程序示例：

1. SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);

复制代码

2.3 初始化线上中断，设置触发条件
1 X% g  V- L8 y8 a
( ]- F7 m+ \; F$ d% ?9 w中断线上中断的初始化是通过函数 EXTI_Init()实现的。EXTI_Init()函数的定义是：

0 M5 x9 A8 O8 V

1. void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct);

复制代码

程序示例

2 q* \: P% {- \' y) a, S0 A3 o5 o

1. EXTI_InitTypeDef EXTI_InitStructure;
   
2. EXTI_InitStructure.EXTI_Line= EXTI_Line4;
   8 G$ P6 l' q: j! |
3. EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
   
4. EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
   
5. EXTI_InitStructure.EXTI_LineCmd = ENABLE;
   ) N* j6 w/ ^5 Z
6. EXTI_Init(&EXTI_InitStructure); //初始化外设 EXTI 寄存器

复制代码

0 J0 W# O( G' Q2.4 配置中断分组（NVIC ），并使能中断

6 G2 B: ]6 h, n+ c; T9 y; n1 i我们设置好中断线和 GPIO 映射关系，然后又设置好了中断的触发模式等初始化参数。既然是外部中断，涉及到中断我们当然还要设置 NVIC 中断优先级。

1. NVIC_InitTypeDef NVIC_InitStructure;
   
2. NVIC_InitStructure.NVIC_IRQChannel = EXTI2_IRQn; //使能按键外部中断通道
   
3. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02; //抢占优先级 2，
   
4. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;  //响应优先级 2
   * Z9 |) q- o0 g; P6 b
5. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
   ' M2 N) ?$ }% ~# Z  t( t, m
6. NVIC_Init(&NVIC_InitStructure); //中断优先级分组初始化

复制代码

2.5 编写中断服务函数
; {$ O4 T) G: I8 d, `
& C. g1 @0 [6 K6 n4 d% A我们配置完中断优先级之后，接着要做的就是编写中断服务函数。中断服务函数的名字是在 MDK 中事先有定义的。这里需要说明一下，STM32F4 的 IO 口外部中断函数只有 7 个，分别为：

* f# o! E+ P8 j: R6 X% ^0 X

1. DCD     EXTI0_IRQHandler                  ; EXTI Line0                                             
   - X. m# }; {! |: G+ R7 T( U* U8 }
2. DCD     EXTI1_IRQHandler                  ; EXTI Line1                                             
   : Y' h, p3 X- c3 W! L1 j# c
3. DCD     EXTI2_IRQHandler                  ; EXTI Line2                                             
   ! E8 y$ q+ J2 o3 E+ @
4. DCD     EXTI3_IRQHandler                  ; EXTI Line3                                             
   % K2 L$ R( b$ c6 S8 i* I
5. DCD     EXTI4_IRQHandler                  ; EXTI Line4   
   
6. DCD     EXTI9_5_IRQHandler                ; External Line[9:5]s   
   8 W# c+ }/ f& U8 A$ d2 K* ~2 n: w
7. DCD     EXTI15_10_IRQHandler              ; External Line[15:10]s  
   

复制代码

- @! V2 R( h- a( e5 u% X, T中断线 0-4 每个中断线对应一个中断函数，中断线 5-9 共用中断函数 EXTI9_5_IRQHandler，中断线 10-15 共用中断函数EXTI15_10_IRQHandler。在编写中断服务函数的时候会经常使用到两个函数，第一个函数是判断某个中断线上的中断是否发生（标志位是否置位）

1. ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)；

复制代码

这个函数一般使用在中断服务函数的开头判断中断是否发生。另一个函数是清除某个中断线上的中断标志位：
5 F1 C& ~: Z- e7 Q

1. void EXTI_ClearITPendingBit(uint32_t EXTI_Line)；

复制代码

这个函数一般应用在中断服务函数结束之前，清除中断标志位。

1 r8 z  q/ s& f$ S5 N% t2 h! u6 l03. 外部中断步骤
2 v! A& D; d8 ^! |4 E  A使用 IO 口外部中断的一般步骤：
. B6 R# ?* b- E& S6 a1）使能 IO 口时钟，初始化 IO 口为输入。
! M5 i7 O3 F0 X; t; h2）使能 SYSCFG 时钟，设置 IO 口与中断线的映射关系。
4 q+ t5 y7 q( d2 r( h6 t/ L3）初始化线上中断，设置触发条件等。
1 b$ S' D1 X6 M" U$ X4）配置中断分组（NVIC），并使能中断。
5）编写中断服务函数。
+ {" U* N: Y: o4 ^0 Q
04. 硬件设计
9 C. T  j: S+ s! a' i探索者 STM32F4 开发板上载有的 4 个按钮（KEY_UP、KEY0、KEY1 和 KEY2），来控制板上的 2 个 LED（DS0 和 DS1）和蜂鸣器，其中 KEY_UP 控制蜂鸣器，按一次叫，再按一次停；KEY0 控制 DS0，按一次亮，再按一次灭；KEY1 控制 DS1，
效果同 KEY2；KEY2 则同时控制 DS0 和 DS1，按一次，它们的状态就翻转一次。

; v8 _0 R' p3 p; O* [" h; A$ r

" i% E0 a1 T1 f' M/ x05. 程序示例一
KEY0控制LED1的翻转

exti.h文件

8 p9 p8 a( @6 [1 s& t! L* q( Y

1. #ifndef __EXTI_H__
   + q7 X6 E& j2 [& J+ ?( `/ t' a4 t
2. #define __EXTI_H__
   
3. 
   
4. #include "sys.h"
   
5. 
   ' D8 }) `2 R, Q3 @
6. //中断初始化函数
   - r2 b$ c. z3 `+ ~
7. void EXTIX_Init(void);
   8 N4 Q2 ~2 [8 t3 E" R, |
8. 
   
9. #endif /*__EXTI_H__*/

复制代码

exti.c文件
+ U* B  U9 f1 ~) t( s) i
0 d: L" C! B; T

1. #include "exti.h"
   
2. #include "key.h"
   7 M+ L' C% K# d2 I
3. #include "led.h"
   ; P/ y8 ]! |3 S. I. B8 M) t
4. #include "delay.h"
   
5. #include "usart.h"
   
6. 
   
7. //中断初始化函数
   
8. void EXTIX_Init(void)
   
9. {
   
10.          EXTI_InitTypeDef EXTI_InitStruct;
    
11.          
    , }3 w2 ]- i2 C& Z
12.          NVIC_InitTypeDef NVIC_InitStruct;
    
13.          
    7 ]8 E) T8 E6 F- Q# G: }
14.          //按键初始化
    # C" x8 b) q( M: H
15.          KEY_Init();
    
16.          
    
17.          //初始化SYSCFG时钟
    
18.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    
19.          
    . D' x: Y# w' W* J, ?
20.          //KEY0 --> PE4
    
21.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource4);
    
22.          
    
23.          //配置中断
    
24.          EXTI_InitStruct.EXTI_Line = EXTI_Line4;
    
25.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    
26.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
    - }. o6 F9 D! G; m! E3 ~
27.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    , I2 R- I3 P! Y
28.          EXTI_Init(&EXTI_InitStruct);
    
29.          
    
30.          //配置中断分组
    ; z. B: ?3 X6 W' P9 g6 ^9 E1 L
31.          NVIC_InitStruct.NVIC_IRQChannel = EXTI4_IRQn;
    
32.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    + p/ g- [5 V) r) E& x0 P6 y
33.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    0 a0 l( q' r, e6 @" l' q8 O
34.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    ) p( R! S# _7 Q- i. M0 j2 W
35. 
    7 Z0 |' A2 s. J
36.          NVIC_Init(&NVIC_InitStruct);
    ) P$ F! v$ D% G
37. }
    
38. 
    
39. //中断线4处理函数
    
40. void EXTI4_IRQHandler(void)
    
41. {
    - p! u) U, a! t; y9 S
42.         printf("KEY0按下啦....\r\n");
    / q) [8 ~; d8 [) K" ~
43.         //消抖
    
44.         delay_ms(10);
    
45.         
    3 l- r& C6 A  p: {+ N9 b* U4 q
46.         if (0 == KEY0)
    ) F# e) a% X2 l. u' M$ f
47.         {
    ; T. s; W- ~6 s5 n
48.                 LED1 = !LED1;
    
49.         }
    $ v# }' P8 M+ U5 E, H( a- h
50. 
    
51.         //清中断
    2 L1 x+ x3 f4 I% G0 r+ o
52.         EXTI_ClearITPendingBit(EXTI_Line4);
    
53. }

复制代码

0 s, D( s+ n2 _# P( f3 V+ ]main.c文件
  E; n3 k. ]9 g/ N1 ~% @

1. #include "sys.h"
   ' j- l/ P0 z. \1 A
2. #include "delay.h"
   1 T- a; y; {4 z6 v9 S! u2 a
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "beep.h"
   : l: J/ x/ R  x2 Q0 u$ {
6. #include "key.h"
   # |3 D  N; b9 X/ q# S+ t
7. #include "exti.h"
   
8. 
   
9. int main(void)
   
10. {
    6 P$ G7 s/ g! T6 a% J& e' D. b
11.         
    " P3 V# T( x# I2 V* m0 c. p
12.         BEEP = 0;
    2 r  l, J& o8 {9 Y
13.         LED1 = 0;
    6 }0 `3 _  p: Y) _2 j" D
14.         
    
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
16.         
    1 z7 C8 r6 b$ I
17.         BEEP_Init();
    
18.         LED_Init();
    
19.         
      P* P/ J3 M3 C* h0 x- E$ Q
20.         delay_init(168);
    
21.         uart_init(115200);
    
22. 
    : c( I0 ]$ c  r4 c2 Q  R, K- i" H  b
23. 
    ' @& ?9 ?* g) {9 y! W3 @
24.         //外部中断初始化
    
25.         EXTIX_Init();
    
26.         
    5 j8 i3 O* j$ q6 V% t" J; O$ y3 z
27.         while(1)
    
28.         {
      Q' s0 E3 x+ |) |( b
29.                 printf("程序正在运行.....\r\n");
    ; n0 m8 J0 h4 I  r# C9 w! P6 [; H8 m; ?
30.                
    4 L* e3 P" {1 ^# z3 b
31.                 delay_ms(1000);
    
32.         }        
    
33. }

复制代码

06. 程序示例二
exti.h文件

1. #ifndef __EXTI_H__
   % o% T" G2 ~- i( @% a/ L" r* @8 W
2. #define __EXTI_H__
   
3. 
     r# |. M( }# @2 {$ x/ u
4. #include "sys.h"
   # w0 v" h" |* f- r
5. 
   
6. //中断初始化函数
   
7. void EXTIX_Init(void);
   
8. 
   1 s$ ]1 \4 W; S9 G* s4 Y
9. #endif /*__EXTI_H__*/

复制代码

$ ]; x' c" g$ b/ f& {exti.c文件
/ W! l- p/ L* ?* k
- `. `, G2 o* ]) l, O0 m0 Z

1. #include "exti.h"
   
2. #include "key.h"
   
3. #include "led.h"
   - r9 n2 t4 h6 K1 B+ G
4. #include "beep.h"
   
5. #include "delay.h"
   " s& c8 a, y* d, L
6. #include "usart.h"
   5 x2 n- U) s6 e! V) D
7. 
   + h* w8 j2 G, ~& l
8. //中断初始化函数
   9 x* `- w" ^1 t: \8 s. h
9. void EXTIX_Init(void)
   , q' Z' |% q! n, s: G  s( c4 ?$ ?
10. {
      j6 Q) c! }5 d; d
11.          EXTI_InitTypeDef EXTI_InitStruct;
    + W2 m+ p( K- y. @; S- K
12.          
    
13.          NVIC_InitTypeDef NVIC_InitStruct;
    
14.          
    + y1 X) r$ k0 o: v
15.          //按键初始化
    ' W3 b0 z7 L" B) ^6 S; z
16.          KEY_Init();
    3 \3 V9 u4 P0 a' t0 s6 d6 V
17.          
    % Z* N3 m$ M# V
18.          //初始化SYSCFG时钟
    : V0 }; T5 W2 m' P( C% ~
19.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    " L1 j2 t! c* w
20.          
    , m# _5 A6 m: q9 |4 J5 T
21.          //KEY0 --> PE4
    
22.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource4);
    
23.          
    ) c% P" T/ k' C
24.          //KEY1 --> PE3
    $ i5 e( X# F- e% _- v  Q8 z
25.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource3);
    
26.          
    " _. E9 w8 h6 x) R0 ^, E- d! {
27.          //KEY1 --> PE2
      X* f& X( n/ {* b! d1 n/ H
28.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource2);
    
29.          
    
30.          //KEY_UP --> PA0
    3 W* Y! w; `: c5 p5 T
31.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);
    
32.          
    
33.          //配置中断 KEY0 KEY1 KEY2
    ; z& o! R! k: K! s$ E/ H( j/ o! }
34.          EXTI_InitStruct.EXTI_Line = EXTI_Line4 | EXTI_Line3 | EXTI_Line2;
    , k8 C4 Q2 h# R% _, Q& @, B* T
35.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    7 G) O- A2 k! n. a2 x
36.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;
    
37.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    
38.          EXTI_Init(&EXTI_InitStruct);
    ( i$ e0 g) T9 a9 H
39.          
    " @& o; p. s0 Q1 v; L# ?8 V* Y" I
40. 
    
41.          //配置中断 KEY_UP
    
42.          EXTI_InitStruct.EXTI_Line = EXTI_Line0;
    6 e9 y- U$ O# _) D9 D: S+ |
43.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    9 Z. u' u. I( N  d# B+ D" z
44.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
    # a; U* K* L) B. k# }
45.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    ' [6 S9 V3 L) I
46.          EXTI_Init(&EXTI_InitStruct);
    ; j2 s9 m! ]# h' \* C  |" k0 L
47.          
    5 q+ B3 @7 G9 ]) X& t
48.          
    
49.          //配置中断分组 KEY0
    
50.          NVIC_InitStruct.NVIC_IRQChannel = EXTI4_IRQn;
    
51.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
52.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    , @, I! W( N2 [9 v$ l3 t& i0 m
53.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
54. 
    
55.          NVIC_Init(&NVIC_InitStruct);
    
56.          
    
57.          //配置中断分组 KEY1
    0 e5 n4 H. x* C* ^
58.          NVIC_InitStruct.NVIC_IRQChannel = EXTI3_IRQn;
    8 B9 g/ ^0 _( {9 y" n
59.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
60.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    1 a" B# f1 t1 h  O6 \0 |
61.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
62. 
    3 `* q2 j5 g. Q! v5 y1 N; q( G
63.          NVIC_Init(&NVIC_InitStruct);
    ) @; Z4 ?& o2 Q
64.          
    0 V' j# F5 W+ y4 O! q$ S$ X- a  b
65.          //配置中断分组 KEY2
    
66.          NVIC_InitStruct.NVIC_IRQChannel = EXTI2_IRQn;
    * t0 @, o9 D& `' e' a( o
67.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
68.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    
69.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
70. 
    
71.          NVIC_Init(&NVIC_InitStruct);
    " Q' A3 A# |* \. Q) m
72.          
    
73.          //配置中断分组 WK_UP
    4 A$ ^  v' F/ a
74.          NVIC_InitStruct.NVIC_IRQChannel = EXTI0_IRQn;
    
75.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    " o, N( z& }+ U. ?
76.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    - g; L" G+ a1 f% h; K( d
77.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
78. 
    8 N, m4 J2 ?! \/ m7 m  ]6 a" \9 |7 M
79.          NVIC_Init(&NVIC_InitStruct);
    
80. }
    
81. 
    
82. //中断线4处理函数
    
83. void EXTI4_IRQHandler(void)
    
84. {
    " R8 Y( ^5 T+ ~# Y; U
85.         printf("KEY0按下啦....\r\n");
    
86.         //消抖
    6 ]/ Y. j8 e7 G, O1 f2 ^
87.         delay_ms(10);
    $ s) I/ K  Q7 L9 t* H- a
88.         
    
89.         if (0 == KEY0)
    5 J$ Z6 b2 M) B8 o; D& ^7 E; ^  B$ J. [$ d
90.         {
    
91.                 LED1 = !LED1;
    
92.         }
    : S% r. v: y0 Q( L
93. 
    . l; j- {( w& j3 _+ H$ h
94.         //清中断
    
95.         EXTI_ClearITPendingBit(EXTI_Line4);
    
96. }
    
97. 
    , E' b3 ?% C; x! O0 w( m
98. 
    
99. //中断线3处理函数
    . L5 e. x  x, J
100. void EXTI3_IRQHandler(void)
     
101. {
     
102.         printf("KEY1按下啦....\r\n");
     
103.         //消抖
     9 X, s4 N8 ~, L2 A" p4 Y
104.         delay_ms(10);
     
105.         
     1 A4 e; ^( m: x- f$ p# A
106.         if (0 == KEY1)
     , F* V4 m' ^  y
107.         {
     
108.                 LED2 = !LED2;
     # F7 J! H' H& U6 Y6 ?
109.         }
     
110. 
     
111.         //清中断
     
112.         EXTI_ClearITPendingBit(EXTI_Line3);
     
113. }
     
114. 
     
115. 
     & M1 K, c+ i, M& H: ~' `4 j: Q
116. //中断线2处理函数
     ) `4 a7 ~7 p$ B$ ?  o' p
117. void EXTI2_IRQHandler(void)
     
118. {
     
119.         printf("KEY2按下啦....\r\n");
     1 J' _$ F' `  W
120.         //消抖
     
121.         delay_ms(10);
     
122.         
     
123.         if (0 == KEY2)
     
124.         {
     # p6 C! ^# R  h' ~. `
125.                 LED1 = !LED1;
     
126.                 LED2 = !LED2;
     
127.         }
     0 M0 V5 V; w& t& o& }5 q9 V0 b- ?
128. 
     
129.         //清中断
     3 d5 G: ?" j: O# I6 C, S
130.         EXTI_ClearITPendingBit(EXTI_Line2);
     9 j& T! T8 G8 Q) q- ~0 I
131. }
     4 F4 {+ X- c* X
132. 
     
133. 
     % i$ p, z" x. t& S' [, x% p
134. //中断线0处理函数
     9 [" k0 b8 u9 u$ y, Y
135. void EXTI0_IRQHandler(void)
     
136. {
     
137.         printf("KEY_UP按下啦....\r\n");
     
138.         //消抖
     
139.         delay_ms(10);
     
140.         
     
141.         if (1 == WK_UP)
     
142.         {
     
143.                 BEEP = !BEEP;
     
144.         }
     0 f+ d- L; K: P& L
145. 
     9 o3 _7 J5 _& [
146.         //清中断
     
147.         EXTI_ClearITPendingBit(EXTI_Line0);
     
148. }

复制代码

0 K0 l5 N% |% M2 {, h# umain.c文件
# w* n: C) w! {/ ]2 ^0 }

1. #include "sys.h"
   - R$ l" H* d& G" S0 a) S& r: Y6 N+ ?
2. #include "delay.h"
   
3. #include "usart.h"
   2 h) P6 S  ~, Q1 w
4. #include "led.h"
   . T9 v+ P; s! N, ^5 m) h
5. #include "beep.h"
   
6. #include "key.h"
   
7. #include "exti.h"
   & A' N* z* W8 R; ~
8. 
   ! a0 X  E- K& C) f
9. int main(void)
   
10. {
    1 L9 l; f5 W+ ~' h& w) u3 k
11.         
    
12.         BEEP = 0;
    
13.         LED1 = 0;
    
14.         LED2 = 0;
    
15.         
      ]3 R# c' V. b! {- p  N
16.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
17.         
    8 E7 A) K( A. T6 A5 Z( E; y9 U9 D
18.         BEEP_Init();
    
19.         LED_Init();
    
20.         
    $ N$ w+ J2 A% w" a. l
21.         delay_init(168);
    
22.         uart_init(115200);
    
23. 
    
24. 
    0 Y" S8 N3 d, D) k) _6 s
25.         //外部中断初始化
    - Q+ L( s* N# u
26.         EXTIX_Init();
    0 v3 i0 O& b. o) Q& T
27.         
    8 b3 ]7 B% @/ D2 _1 ?' Z
28.         while(1)
    
29.         {
    4 F$ f4 V( ^' K4 J2 u6 y' L. U- t; n
30.                 printf("程序正在运行.....\r\n");
    
31.                
    : P. ]' B) v; @, N9 b
32.                 delay_ms(1000);
    
33.         }        
    * s' b2 Y8 g: J" |6 A+ F( m7 K' T* M
34. }

复制代码

8 R3 c5 E9 M5 _