01. 外部中断简介
* P+ o1 d7 W" u- w. ~5 X外部中断的代码主要分布在固件库的 stm32f4xx_exti.h 和 stm32f4xx_exti.c 文件中。
0 P, T7 x3 |4 u0 W8 z6 A/ l1 c
9 S( p, s2 \! F: ~6 S) YSTM32F4 的每个 IO 都可以作为外部中断的中断输入口，这点也是 STM32F4 的强大之处。STM32F407 的中断控制器支持 22
个外部中断/事件请求。每个中断设有状态位，每个中断/事件都有独立的触发和屏蔽设置。

STM32F407 的 22 个外部中断为：

EXTI 线 0~15：对应外部 IO 口的输入中断。
EXTI 线 16：连接到 PVD 输出。
. W5 l, ~, V1 Z& {EXTI 线 17：连接到 RTC 闹钟事件。
EXTI 线 18：连接到 USB OTG FS 唤醒事件。
% F) ]& N2 M- K* @# `+ k1 M! WEXTI 线 19：连接到以太网唤醒事件。
EXTI 线 20：连接到 USB OTG HS(在 FS 中配置)唤醒事件。
. C5 i% X9 C$ V, ^% S9 O! C% zEXTI 线 21：连接到 RTC 入侵和时间戳事件。
EXTI 线 22：连接到 RTC 唤醒事件。
8 b1 y1 U* P- V从上面可以看出，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跟中断线的映射关系图：
. z6 Q) _. z- E1 c

1 i: h, p/ F/ {7 z8 C3 y# s! D
02. 外部中断配置
2.1 使能 IO口时钟，初始化 IO
" }2 i. J  Z4 W2 D9 ~: ~/ U& g
我们要使用 IO 口作为中断输入，所以我们要使能相应的 IO 口时钟，以及初始化相应的 IO 口为输入模式
4 P, y% c( w" O
+ Y2 v1 }( r8 Q4 V) Z2.2 开启 SYSCFG 时钟，设置 IO 口与中断线的映射关系
  Z' X( s; s! y/ B4 d
只要我们使用到外部中断，就必须打开 SYSCFG 时钟。
8 A5 f; s2 |. ^. E4 J3 R

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

复制代码

配置 GPIO 与中断线的映射关系。在库函数中，配置 GPIO 与中断线的映射关系的函数 SYSCFG_EXTILineConfig ()来实现的：
! l( Y- O( f1 l- h  W3 P

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

复制代码

该函数将 GPIO 端口与中断线映射起来，程序示例：

1. SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);

复制代码

2.3 初始化线上中断，设置触发条件

中断线上中断的初始化是通过函数 EXTI_Init()实现的。EXTI_Init()函数的定义是：

1. void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct);

复制代码

程序示例

8 \& D1 H' S/ x: T7 K

1. EXTI_InitTypeDef EXTI_InitStructure;
   7 M: T/ p1 H" v3 T$ ?
2. EXTI_InitStructure.EXTI_Line= EXTI_Line4;
   
3. EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
   
4. EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
   ; Q. Z% c) r7 F: S
5. EXTI_InitStructure.EXTI_LineCmd = ENABLE;
   ' S( E2 K' E$ R" ^+ d
6. EXTI_Init(&EXTI_InitStructure); //初始化外设 EXTI 寄存器

复制代码

8 G9 u' C1 n; r; Y! _: d+ N2.4 配置中断分组（NVIC ），并使能中断

# h0 b0 x1 u# G, ~5 t我们设置好中断线和 GPIO 映射关系，然后又设置好了中断的触发模式等初始化参数。既然是外部中断，涉及到中断我们当然还要设置 NVIC 中断优先级。

1. NVIC_InitTypeDef NVIC_InitStructure;
   ( X  b# }. {/ v4 ~( {
2. NVIC_InitStructure.NVIC_IRQChannel = EXTI2_IRQn; //使能按键外部中断通道
   " q  k. n0 M2 O' a# w1 M$ D+ s/ m* L5 H
3. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02; //抢占优先级 2，
   0 I: [, _- J2 L, I1 `
4. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;  //响应优先级 2
   & H  l2 {/ }9 E: H
5. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
   
6. NVIC_Init(&NVIC_InitStructure); //中断优先级分组初始化

复制代码

2.5 编写中断服务函数

' D) \- p# p" e  [7 F$ q我们配置完中断优先级之后，接着要做的就是编写中断服务函数。中断服务函数的名字是在 MDK 中事先有定义的。这里需要说明一下，STM32F4 的 IO 口外部中断函数只有 7 个，分别为：
) c2 ~4 @$ Q/ a, D3 y
+ c/ G0 J; k( @" h' L

1. DCD     EXTI0_IRQHandler                  ; EXTI Line0                                             
   
2. DCD     EXTI1_IRQHandler                  ; EXTI Line1                                             
   $ i$ h, ]* _8 k" k: D
3. DCD     EXTI2_IRQHandler                  ; EXTI Line2                                             
   ' c# T9 J$ x2 i$ B0 \: r; U
4. DCD     EXTI3_IRQHandler                  ; EXTI Line3                                             
   % n" B3 {0 |4 Y
5. DCD     EXTI4_IRQHandler                  ; EXTI Line4   
   ! I2 z" r1 o1 f+ ?0 u0 K4 p
6. DCD     EXTI9_5_IRQHandler                ; External Line[9:5]s   
   $ S, s+ L% `' L4 Z5 f
7. DCD     EXTI15_10_IRQHandler              ; External Line[15:10]s  

复制代码

. z9 h* [, W3 W( F5 T中断线 0-4 每个中断线对应一个中断函数，中断线 5-9 共用中断函数 EXTI9_5_IRQHandler，中断线 10-15 共用中断函数EXTI15_10_IRQHandler。在编写中断服务函数的时候会经常使用到两个函数，第一个函数是判断某个中断线上的中断是否发生（标志位是否置位）

1. ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)；

复制代码

: x9 c" x2 A1 u( P5 M这个函数一般使用在中断服务函数的开头判断中断是否发生。另一个函数是清除某个中断线上的中断标志位：
3 M4 d7 c; l1 F) o$ _- Z

1. void EXTI_ClearITPendingBit(uint32_t EXTI_Line)；

复制代码

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

3 r( O. T& M  j# }03. 外部中断步骤
6 ?4 A' V' G9 R, Y; Z6 y使用 IO 口外部中断的一般步骤：
# P' i) _- M) d8 f1）使能 IO 口时钟，初始化 IO 口为输入。
7 |- O/ P, P) Z1 _. k1 f! \3 I2）使能 SYSCFG 时钟，设置 IO 口与中断线的映射关系。
1 Y: j- [! _9 u- P& [' Z: _* f3）初始化线上中断，设置触发条件等。
4）配置中断分组（NVIC），并使能中断。
5）编写中断服务函数。
+ U& t5 Y$ n# K% x
# T0 F' T4 ?: n+ {04. 硬件设计
0 u( d0 [9 X% d3 w% @$ F& n, }探索者 STM32F4 开发板上载有的 4 个按钮（KEY_UP、KEY0、KEY1 和 KEY2），来控制板上的 2 个 LED（DS0 和 DS1）和蜂鸣器，其中 KEY_UP 控制蜂鸣器，按一次叫，再按一次停；KEY0 控制 DS0，按一次亮，再按一次灭；KEY1 控制 DS1，
效果同 KEY2；KEY2 则同时控制 DS0 和 DS1，按一次，它们的状态就翻转一次。


% {8 a3 g4 l# x( k' b
05. 程序示例一
9 s7 z  k* T3 d7 M5 M. E0 BKEY0控制LED1的翻转

exti.h文件

1. #ifndef __EXTI_H__
   
2. #define __EXTI_H__
   + D0 f- _1 c" y
3. 
   - T0 N; M& R0 k' w/ L- [
4. #include "sys.h"
   % G+ ?* G) z9 {  w
5. 
   
6. //中断初始化函数
   
7. void EXTIX_Init(void);
   
8. 
   : K& M8 J4 Q1 E! a2 m' m
9. #endif /*__EXTI_H__*/

复制代码

exti.c文件
6 Q* {; Z0 M) B4 F# y3 D. z  T+ g& q

1. #include "exti.h"
   1 z/ r) p9 l* R/ Y" }
2. #include "key.h"
   3 A! R2 W" z1 x
3. #include "led.h"
   $ G5 D0 @6 u! B" h
4. #include "delay.h"
   
5. #include "usart.h"
   
6. 
   
7. //中断初始化函数
   
8. void EXTIX_Init(void)
   7 s" P% P: [( M5 y# o- m
9. {
   
10.          EXTI_InitTypeDef EXTI_InitStruct;
    
11.          
    
12.          NVIC_InitTypeDef NVIC_InitStruct;
    
13.          
    , F6 Y. l9 N) b2 Y6 u8 G
14.          //按键初始化
    
15.          KEY_Init();
    
16.          
    
17.          //初始化SYSCFG时钟
    5 ^& q6 ^$ y* N  @1 Y
18.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    : W+ R" @1 A7 }* m3 ~
19.          
    
20.          //KEY0 --> PE4
    
21.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource4);
    
22.          
    ( B9 E& y0 x1 b  M$ W* ]" v
23.          //配置中断
    
24.          EXTI_InitStruct.EXTI_Line = EXTI_Line4;
    
25.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    4 K' {  ]4 z! C/ X
26.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
    
27.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    
28.          EXTI_Init(&EXTI_InitStruct);
    
29.          
    
30.          //配置中断分组
    / v% ]: [0 A7 A+ x' G% _
31.          NVIC_InitStruct.NVIC_IRQChannel = EXTI4_IRQn;
    4 z8 l( U8 H3 w4 O* J/ z
32.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
33.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    
34.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
35. 
      h$ ~! }: [1 Y& ^2 R5 O. D
36.          NVIC_Init(&NVIC_InitStruct);
    - \# }$ S3 f, V# w3 d3 w0 X
37. }
    ; f# Q8 U. m2 g5 Z  G% }
38. 
    - j* f9 }* D1 A
39. //中断线4处理函数
    . n, K! p8 c2 R. C/ l
40. void EXTI4_IRQHandler(void)
    * f& w* p. `2 z9 W' H+ S2 s+ I
41. {
    
42.         printf("KEY0按下啦....\r\n");
    
43.         //消抖
    
44.         delay_ms(10);
    & ]) T6 Y5 X! K" P! R, g8 x# \  R
45.         
    1 c0 W! i2 O  _& n- t% p- |9 D6 E
46.         if (0 == KEY0)
    5 q% _5 U' G: R# N- z( Y) D9 ?8 O
47.         {
    
48.                 LED1 = !LED1;
    & X. B6 {6 [! s9 Y! g& u
49.         }
    * m+ {6 r  Q/ j+ t9 P2 B
50. 
    
51.         //清中断
    
52.         EXTI_ClearITPendingBit(EXTI_Line4);
    
53. }

复制代码

main.c文件
$ g  P/ A6 T/ s5 F& Q) S" e+ Q/ p

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   : `# {+ F( |& ^; }
4. #include "led.h"
   * q6 R! ~4 x: S0 l  W9 V/ j
5. #include "beep.h"
   
6. #include "key.h"
   
7. #include "exti.h"
   
8. 
   
9. int main(void)
   
10. {
    # z6 X/ O6 k5 j6 y* c; s  l
11.         
    ( }/ y6 `8 g) M$ t5 M. H, u
12.         BEEP = 0;
    
13.         LED1 = 0;
    
14.         
    
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
16.         
    
17.         BEEP_Init();
    
18.         LED_Init();
    
19.         
    
20.         delay_init(168);
    
21.         uart_init(115200);
    
22. 
    
23. 
    8 x  }# R$ D  h* m$ {" d: F: i
24.         //外部中断初始化
    
25.         EXTIX_Init();
    # R! [0 [0 k" M8 ~, L. v  C3 x
26.         
    
27.         while(1)
    
28.         {
    2 g$ @7 h7 x. n" s/ c/ K8 V! c8 @
29.                 printf("程序正在运行.....\r\n");
    ; z3 O  K# k& ^8 a+ ~6 U5 r2 Z
30.                
    * m, \- w/ |. d
31.                 delay_ms(1000);
    
32.         }        
    
33. }

复制代码

1 C) D0 A7 S/ c1 Q' y0 [06. 程序示例二
exti.h文件

1. #ifndef __EXTI_H__
   
2. #define __EXTI_H__
   
3. 
   
4. #include "sys.h"
   0 u  P: y  f# o5 [, A5 p
5. 
   
6. //中断初始化函数
   
7. void EXTIX_Init(void);
   
8. 
   5 _3 e3 p' T7 h: R
9. #endif /*__EXTI_H__*/

复制代码

exti.c文件
) D7 G' [4 e6 Y# ?
7 t  A/ F/ f- b  H- Z5 {; W# E3 [# y

1. #include "exti.h"
   7 h0 f) `  f" l% U9 Q
2. #include "key.h"
   
3. #include "led.h"
   & W5 K$ K4 N) v' E0 \
4. #include "beep.h"
   0 o5 e0 }- N1 P4 \( e
5. #include "delay.h"
   
6. #include "usart.h"
   / t  t$ w; a$ X. K' A9 ?* ]4 D- \4 |# G
7. 
   
8. //中断初始化函数
   
9. void EXTIX_Init(void)
   & |7 [; k6 Q7 i3 c* Y# T# U
10. {
    
11.          EXTI_InitTypeDef EXTI_InitStruct;
    
12.          
    1 ?$ I0 u3 \/ m& y: u3 c. Q. Q
13.          NVIC_InitTypeDef NVIC_InitStruct;
    $ r5 w1 b8 h0 ~: ~- H
14.          
    
15.          //按键初始化
    - Q: ]+ w  v/ T3 S! q( G( b- C
16.          KEY_Init();
    
17.          
    
18.          //初始化SYSCFG时钟
    
19.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    4 s$ O9 D8 M4 L
20.          
    
21.          //KEY0 --> PE4
    & }8 n# N; ]% T
22.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource4);
    3 q& L5 d9 E/ P; W" ]
23.          
    . c+ H) e  r% C3 u
24.          //KEY1 --> PE3
    
25.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource3);
    6 X" P1 F. x1 Q: `8 O
26.          
    " P0 W% R4 R* n. o+ b0 Z* y
27.          //KEY1 --> PE2
    
28.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOE, EXTI_PinSource2);
    
29.          
    * V- E" ]5 r2 H7 ?1 s4 A
30.          //KEY_UP --> PA0
    
31.          SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);
    
32.          
    6 N0 |0 o* ^: C9 t
33.          //配置中断 KEY0 KEY1 KEY2
    
34.          EXTI_InitStruct.EXTI_Line = EXTI_Line4 | EXTI_Line3 | EXTI_Line2;
    
35.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    , C; ^  e+ N9 B2 o6 v- W" r
36.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;
    , N& a+ w0 X: }/ x' u& W& B  y
37.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    
38.          EXTI_Init(&EXTI_InitStruct);
    
39.          
    5 v: H$ z) G" w1 f' Z* t/ S* b: x' f
40. 
    ; g) p% Z7 b2 k) i5 S0 M4 s$ Z
41.          //配置中断 KEY_UP
    
42.          EXTI_InitStruct.EXTI_Line = EXTI_Line0;
    
43.          EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    
44.          EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
    
45.          EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    ( K: S9 |! D8 ^3 L
46.          EXTI_Init(&EXTI_InitStruct);
    5 U( p8 M9 |3 ?# M$ s, {0 l
47.          
    ) Y5 Y8 \' Q4 {
48.          
      x# e- V+ v% q. A& Z
49.          //配置中断分组 KEY0
    # A( Z" Y9 [2 I- Z# M& g6 S% U
50.          NVIC_InitStruct.NVIC_IRQChannel = EXTI4_IRQn;
    ( H! D: K  ]0 M: z- ]* k' n3 L
51.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
52.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    & U( r0 b' v! {4 M3 |+ L
53.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    9 ?8 ]0 u& u1 n
54. 
    3 ~/ l0 ~) i* S' T* ~. q) z
55.          NVIC_Init(&NVIC_InitStruct);
    
56.          
    
57.          //配置中断分组 KEY1
    
58.          NVIC_InitStruct.NVIC_IRQChannel = EXTI3_IRQn;
    
59.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
      m. S) Y; x6 P0 G# ?) F2 N* b  A
60.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    
61.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    . s' ^' n' @# ], F
62. 
    2 T! d+ q3 \7 u/ S# Y
63.          NVIC_Init(&NVIC_InitStruct);
    
64.          
    
65.          //配置中断分组 KEY2
    5 ~  c4 g; X4 }7 I* ]% K# i) ^
66.          NVIC_InitStruct.NVIC_IRQChannel = EXTI2_IRQn;
    
67.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    
68.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    * U% M5 V2 Q7 j4 P
69.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    ( B* [& Z% H6 C, Z
70. 
    
71.          NVIC_Init(&NVIC_InitStruct);
    9 `/ V8 ^. q- ]- [# D
72.          
    
73.          //配置中断分组 WK_UP
    
74.          NVIC_InitStruct.NVIC_IRQChannel = EXTI0_IRQn;
    , S0 G3 g" \3 c, G
75.          NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 2;
    2 Q; @6 O2 _2 N" |+ v9 ?+ J' r  x3 W
76.          NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;
    ; {" {) T4 d" Q! W6 h
77.          NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
78. 
    
79.          NVIC_Init(&NVIC_InitStruct);
    1 i  s; o1 H$ Q' O6 y( Q
80. }
    
81. 
    
82. //中断线4处理函数
    
83. void EXTI4_IRQHandler(void)
    ( }9 e0 L* x; O  L6 }
84. {
    3 Y/ ]: p" I% M. e
85.         printf("KEY0按下啦....\r\n");
    6 T3 B: G+ P5 ]: O
86.         //消抖
    " l) ?0 d* {7 y% ^' k% {& s9 F4 Q1 z
87.         delay_ms(10);
    # y" a" l# F+ @# E7 G( M
88.         
    
89.         if (0 == KEY0)
    
90.         {
    
91.                 LED1 = !LED1;
    
92.         }
    
93. 
    
94.         //清中断
    
95.         EXTI_ClearITPendingBit(EXTI_Line4);
    : H+ ]7 T# k! O) }: s% U0 ?
96. }
    1 ~2 X) A' G- M: H* o
97. 
    " H$ E. p6 s. n! _3 ^$ J, X
98. 
    
99. //中断线3处理函数
    / O7 x  @: |+ b
100. void EXTI3_IRQHandler(void)
     
101. {
     & i- n/ |. s# A. \1 I% R" [
102.         printf("KEY1按下啦....\r\n");
     
103.         //消抖
     ! W2 d& A1 l: l+ n# ^1 d1 e
104.         delay_ms(10);
     / T9 \) |1 Z* i  l% s( {$ o% T
105.         
     
106.         if (0 == KEY1)
     
107.         {
     ( K1 ~: J" Y6 u, D. ~/ p6 G+ W
108.                 LED2 = !LED2;
     ! D: J$ k5 p; P) _& E. J
109.         }
     : q4 B7 u& z3 s& H; l
110. 
     
111.         //清中断
     
112.         EXTI_ClearITPendingBit(EXTI_Line3);
     
113. }
     
114. 
     
115. 
     + I7 W5 F0 {" C' b! ^
116. //中断线2处理函数
     4 s8 k* M5 C6 p  m
117. void EXTI2_IRQHandler(void)
     : Y. A5 N: Z) e6 J  S
118. {
     ; m, G' ~) m1 n0 _" x% S
119.         printf("KEY2按下啦....\r\n");
     
120.         //消抖
     
121.         delay_ms(10);
     
122.         
     
123.         if (0 == KEY2)
     
124.         {
     
125.                 LED1 = !LED1;
     
126.                 LED2 = !LED2;
     
127.         }
     
128. 
     
129.         //清中断
     
130.         EXTI_ClearITPendingBit(EXTI_Line2);
     - o) u" p2 o. `( B: ]% X+ p
131. }
     
132. 
     
133. 
     * ]; M1 x; f/ R5 s1 Q# \
134. //中断线0处理函数
     . O5 ]# J8 z* {/ ^5 @# j
135. void EXTI0_IRQHandler(void)
     4 L3 F3 u/ g% b: B1 `) c5 a
136. {
     
137.         printf("KEY_UP按下啦....\r\n");
     , c" y( _, [; Q0 D: j% T
138.         //消抖
     : I, D/ t6 |6 a' H7 Y$ y; f( J4 j
139.         delay_ms(10);
     
140.         
     / a& j& f% d# E: P  K/ p$ ~
141.         if (1 == WK_UP)
     3 K' K! J% u* b+ T3 K, X) T
142.         {
     ; z* g. e. {4 e
143.                 BEEP = !BEEP;
     0 ~. X& r& Y4 _+ G  S# z& C+ o" V
144.         }
     
145. 
     
146.         //清中断
     
147.         EXTI_ClearITPendingBit(EXTI_Line0);
     
148. }
     % g  M, b/ l5 J: d) _8 ^* f) ^$ |6 ]

复制代码

main.c文件
% G/ c! R7 e$ r4 H6 [

1. #include "sys.h"
   
2. #include "delay.h"
   ; A7 K$ k, g- b0 D% |
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "beep.h"
   . j  R& [# f+ l% y- W
6. #include "key.h"
   $ f0 f( k% n8 @# ?  i1 j
7. #include "exti.h"
   
8. 
   
9. int main(void)
   
10. {
    * q& s7 L; i) k- I3 U
11.         
    
12.         BEEP = 0;
    
13.         LED1 = 0;
    4 v" ^& K2 b9 A9 _2 `( Z1 ?
14.         LED2 = 0;
      N" Z+ R/ F6 J
15.         
    
16.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    9 [0 Q. j3 \8 @, Q8 M6 Q
17.         
    
18.         BEEP_Init();
    ( F' e6 c; y8 P* D) @& Q
19.         LED_Init();
    
20.         
      C7 V% j  {8 k: ]" E, q& A
21.         delay_init(168);
    
22.         uart_init(115200);
    
23. 
    8 e; k4 V  x$ i+ g
24. 
    ; b: S1 I# ?% V
25.         //外部中断初始化
    
26.         EXTIX_Init();
    0 V6 o" q0 y5 U' s- `
27.         
    # e9 q0 J9 G8 O* F5 `- X" o
28.         while(1)
    ; s# G: E: Z/ ]1 x9 z" o/ V
29.         {
    , A. B( P" a: _( ]2 }1 Q
30.                 printf("程序正在运行.....\r\n");
    3 o! B. w. k: b
31.                
    
32.                 delay_ms(1000);
    
33.         }        
    $ t! e' c) F+ K% ^0 f7 T' L" L
34. }

复制代码