在STM32中执行中断主要分三部分：
1.配置NVIC_Config()函数
% `8 k6 t  p: G0 j, R2.配置EXTI_Config()函数
3.编写中断服务函数
, P2 Y* Z% Q0 S0 V（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）

配置NVIC_Config()函数
% O# |, V: P1 ~1 X' j6 `7 ?NVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
& P" `' `, j& m6 a! w0 WNVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   
4.         
   - a! I' |7 K/ S# y
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   $ e4 m+ e' U; z
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   1 S' }1 L" d$ d+ U3 v
7.         
   
8.         /* 配置初始化结构体 在misc.h中 */
   
9.         /* 配置中断源 在stm32f10x.h中 */
   
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    
11.         /* 配置抢占优先级 */
    6 z# S6 j3 p! G; X) [9 S. W
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    ' r0 d6 i7 f. \# q( A$ ^" m- t
13.         /* 配置子优先级 */
    
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    
15.         /* 使能中断通道 */
    
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    4 u" L. z8 ^8 H) _! _
17.         /* 调用初始化函数 */
    + q! V- e7 x* E# R5 G3 f# C
18.         NVIC_Init(&NVIC_InitStruct) ;
    
19.         
    
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    # p; P; F$ t6 v6 i  o
25.         NVIC_Init(&NVIC_InitStruct) ;
    
26.         
    
27. }
    

复制代码

& f$ ^( `8 `' g配置NVIC_Config()的目的是选择中断源的优先级以及打开中断通道，主要功能通过配置NVIC初始化结构体NVIC_InitStruct来完成。通俗的讲，STM32中有很多中断，而当有多个中断同时发生时就涉及到中断执行的先后问题了，所以引入了中断优先级的概念，中断优先级越高中断就越先执行。在这里我们只讨论外部中断的优先级，在 NVIC 有一个专门的寄存器：中断优先级寄存器 NVIC_IPRx，用来配置外部中断的优先级。优先级高低的比较包括抢占优先级和子优先级，先比较抢占优先级，如果抢占优先级相同就比较子优先级，从而得出中断之间的优先级高低。NVIC的主要任务就是给对应的中断源分配中断优先级。 中断优先级分配的原理繁杂，但固件库编程的好处就是化繁为简，我们只需要按照NVIC_InitStruct（）中的内容进行配置就行。

接下来简单讲解一下NVIC_Config()函数的内容：
9 u2 _, {; f+ s7 u1 A0 x6 Z1.首先设置中断优先级分组
/ K- }! t! |" U  M. h9 _8 q4 m中断优先级分组其实是确立一个大纲，中断优先级寄存器 NVIC_IPRx中有4个位用来确定优先级，中断优先级的分组就是把这4个位分配在抢占优先级和子优先级中。比如设定一个位配置抢占优先级，其余三个位配置子优先级。通过函数NVIC_PriorityGroupConfig() ; 实现分组，详细代码如下：
7 E0 ^! g, N9 j+ C

1. 1 /**
   ( a$ o- F; W! n# a: ~& ?' Y
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   
3. 3 * 形参如下：
   
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   
5. 5 *                                      4 bits for 子优先级
   9 P& Q+ I. V1 S; D: C% b% L0 I
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   
7. 7 *                            3 bits for 子优先级
   0 D; g9 h& j& Q: U, ^
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   
9. 9 *                            2 bits for 子优先级
   
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    
11. 11 *                           1 bits for 子优先级
    * E: ?0 x; t( H$ Q( {3 B- ?; Y
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    5 M1 |: Q4 y1 i7 K
13. 13 *                           0 bits for 子优先级
    
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    " T# Q% t9 F3 ~- ]; |; J- f
15. 15 */
    
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    
17. 17 {
    
18. 18 // 设置优先级分组
    & F. g' Z$ r8 W0 ^$ t
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    4 {, m& q; n1 n* j0 {
20. 20 }
    

复制代码

4 q7 _2 m( D: d* b! d* ^2.优先级分组完毕后，是配置NVIC初始化结构体
2 @9 q) A+ J6 g: K+ H

1. typedef struct {
   $ l8 I# ^- ]; M1 r# g& K  E5 L1 d$ H
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   / `7 p: t  l# s4 Z0 l: o' d
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   8 z1 g5 e3 Y% Q) [' N; V
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   ' u/ T6 ^  ^) \6 S& T# S/ l
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   
6. 6 } NVIC_InitTypeDef;
   

复制代码

+ i' d5 w) n8 C8 x初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
NVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
; n- d" }0 S# M: BNVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
% @8 F% r. x) @3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）
$ V8 K+ U! ?& a" {1 ?: q  {3 @5 b

7 r5 ^; j( Q7 [6 D- X/ g配置EXTI_Config()函数
6 D4 ~& k/ j8 B: Y" gEXTI（External interrupt/event controller）：外部中断/事件控制器，管理了控制器的 20个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置，可以单独配置为中断或者事件，以及触发事件的属性。
8 g6 A3 y- V; [+ T8 k按我的理解，EXTI是一个有着多达20个接口的控制器，它可以为每一个接入接口的信号源配置中断（或事件）线、设置信号的检测方式、设置触发事件的性质，也就是说，传入EXTI的仅仅是一个信号，EXTI的功能就是根据信号传入的“线”对信号做出相应的处理，然后将处理后的信号转向NVIC。 就像一个分拣机器，传入的东**过筛选处理被送往不同的地方，只是EXTI分拣的是信号罢了。 如果说NVIC是配置中断源，那么EXTI就是向NVIC传送中断信号。
; k" a: T- X6 G3 F! W) Q
1 r8 b. q- y& TEXTI功能框图：

4 C2 R) d$ N0 ^, ~5 [; j: |8 h
  l& z4 |  ~, }; l  _: d2 q' f
+ ^7 M% W$ A5 p9 h  a
. r4 c( E2 b" i8 ?$ UEXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。
! S0 t3 v) l* G+ X) N: u- T) s

7 o- \1 ]& y" z- v# a& \7 Q$ x接下来讲解一下EXTI_Config()函数代码：

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   7 I# M- F. u+ C( Z
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   9 Y3 v" x, O; F
5.         
   5 L) T% z/ [* R1 x
6.         NVIC_Config();
   
7. 
   
8.         /* 初始化要与EXTI连接的GPIO */
   6 I- y8 ?+ F, i8 j8 |; d
9.         /* 开启GPIOA与GPIOC的时钟 */
   * \" t' O0 L: {4 S9 E, }% p( [
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    
11.         
    
12.         GPIO_InitStruct.GPIO_Pin = KEY1_EXTI_GPIO_PIN ;
    
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    % \0 ?* Z, d. v& B- O
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    
15.         
    : ^& k9 o7 k8 J# K9 ^, R
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    ' F  C! @, e  k7 M% c. {& V- e
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    & ?$ F/ s. i) A; L, A- W  k
19.         
    
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    ' F& W: l( j; r' |( E
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    ! t# X, G, |1 p6 h4 _/ a& v
23.         /* 选择作为EXTI线的GPIO引脚 */
    
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    - m2 p4 O0 o! `
25.         /* 配置中断or事件线 */
    4 `$ I* r. k* p# k& A; z& S
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    
27.         /* 使能EXTI线 */
    
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
29.         /* 配置模式：中断or事件 */
    4 U2 O$ Y3 v& K) ?9 U
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    8 _: u& L! y  j- |: ]
31.         /* 配置边沿触发 上升or下降 */
    , K* s( ^  X8 C: Z, C' q# i
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    
33.         EXTI_Init(&EXTI_InitStruct) ;
    * H- W# y) y. f( V1 {
34.         
    " f$ [6 ~. x* B- G5 @" X
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    ; ]7 N0 ^3 G0 M0 H
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    " Q1 Z% ?  |6 g
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    
40.         EXTI_Init(&EXTI_InitStruct);
    6 J( i& @* a8 A& O# H( L
41. }
    $ {* O1 T5 i! x( }8 y) Y8 H
42. 
    2 j3 }, C8 F+ k2 z) o+ G

复制代码

代码可大体分为三部分：
配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
/ \: ]" d1 b) m( x6 c1.配置GPIO相应引脚
该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
/ v4 s% l" \6 S2 l- g2.配置EXTI并连接GPIO引脚
3 \3 c+ V3 Z7 g; r要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下

1. /**
   6 {( ^' R8 W  w) a5 Y
2.   * @brief  Selects the GPIO pin used as EXTI Line.
   - P- W7 k" w4 ]( |  j# o  L
3.   * @param  GPIO_PortSource: selects the GPIO port to be used as source for EXTI lines.
   
4.   *   This parameter can be GPIO_PortSourceGPIOx where x can be (A..G).
   
5.   * @param  GPIO_PinSource: specifies the EXTI line to be configured.
   # u! F3 N; D% Q8 J, h' S" ~" l1 |
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   0 ~5 T3 k" [$ R% l( B
7.   * @retval None
   0 e) _+ b& L, q3 ?2 V' O
8.   */
   ; u8 ?* L) |( {0 e
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   4 R8 \6 L9 K$ D
10. {
    7 q. @; b% [4 ~2 t) p
11.   uint32_t tmp = 0x00;
    * |3 u' P/ X' }1 o6 f6 F9 h6 L. ^! y
12.   /* Check the parameters */
    & k; V% s- P7 ^8 h  u+ K3 a
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    
15.   
    
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    ' j$ l7 f( ~  n& D
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
      E- I9 Q" G8 ~/ Y
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    
19. }
    . ]8 o' n# [0 q8 r+ e/ i

复制代码

其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：
' ^5 n/ W7 i1 `  I: ]) e

1. typedef struct
   
2. {
   : F& E! u3 M0 p2 J$ D6 J
3.          uint32_t EXTI_Line; // 中断/事件线
   
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   3 }  z$ I- F% O
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   7 I5 R9 i0 @- B, R
7. } EXTI_InitTypeDef;
   5 Y) ^1 z5 P5 A" M( `# v

复制代码

, N1 s) I& {' ]7 t. y* u1 S0 G配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
EXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
! y$ h! D8 v% ^4 TEXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
EXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
" p/ l0 T" `- n3.传入NVIC_Config()
之后就自动传入NVIC中了。。。

编写中断服务函数
4 _; [: m' W: J, Q( ^! N5 e到这里就万事俱备只欠东风了，中断的触发与处理及优先级定义都已经安排上了，最后一步就是编写中断函数的内容了，只要进入中断就会执行中断函数中的代码，所以这是收尾工作。STM32的中断服务函数不同于51单片机中的中断服务函数，STM32的所有中断函数都被偷偷安排了，每个中断都有其固定的名字，只有找到这个名字，在这个固定的函数名下编写中断服务函数才是有效的，所有中断函数的编写都要在stm32f10x_it.c 中，如示：


- t; X- F6 g0 }" ?0 h3 [2 A
) X+ e* ?. [: p$ l6 ?3 Z从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：



  B8 L, O  S$ x7 D, }
, g9 j' Z( I3 _( @7 B( w, X1 B可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。
, R4 m+ ?! J: K. }4 e9 j& a$ P
6 L( e/ x0 ?- s" n! W我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：

1. void EXTI0_IRQHandler(void)
   
2. {
   
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   
4.         {
   
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   7 g2 y0 S7 i. _3 {  N+ d% U7 e
6.         }
   
7.                
   0 c  g  N, h0 ^8 y) u9 w
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   4 m3 g* E3 \0 H4 U/ a
9.                
   , X/ x5 r1 v" l
10. }
    
11. 
    
12. 
    ( g7 Y. a2 N, _; `, G
13. void EXTI15_10_IRQHandler(void)
    
14. {
    
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    0 L/ n5 v7 Y7 h; {! e4 y
16.         {
    
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    ; I: C. G$ U' J0 v& C
18.         }
    ( T$ A! A1 g4 j, m5 b1 c
19.                
    
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    
21.                
    
22. }
    
23. 
    

复制代码

每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断
; }: L. `+ v0 [( ^' v$ \* P' L  ^
0 j4 l" |* @* I% R
5 B( K0 T9 D, ~大功告成
) z1 u* I$ F: ]到此完整的中断系统就已经完成，主函数只需调用即可！！！

1. #include "stm32f10x.h"
   3 J0 P* C3 V  Y* e
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
   
4. 
   : N/ F1 x8 B5 g$ R
5. int main(void)
   , Q( o0 V) K: `
6. {
   6 C" g/ A# X/ y2 ?
7.         LED_GPIO_Config();
   7 e% R' x9 V; ?4 C
8.         EXTI_Config();
   ' a- s6 Q$ f( S% r! r2 j5 [
9.         
   
10.         while(1)
    0 ?* x  A1 n5 I; a' |* f4 d/ H7 d& f
11.         {
    
12.         }
    ; z! W' ]$ _7 F- N
13. }
    
14. 
    : u) d- [6 c5 h+ U
15. 
    # Y* o$ P& p# p9 H  {. a

复制代码

1. #ifndef __BSP_KEY_H
   
2. #define __BSP_KEY_H
   , R* D) r1 t5 ^+ S1 R  F! A+ f, r
3. 
   
4. #include "stm32f10x.h"
   6 i* U5 E( B$ V
5. 
   * L3 @; M! Y' f2 g% y  q, j2 }
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   * y' A6 F( [2 ?) p
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   8 B0 |- J; A- r  s8 A* ?
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    9 I9 ~% b! d8 |
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    " h6 g! M8 J3 T
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    $ Y  T. p3 j0 }. J6 c
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    0 }! G2 s, P+ i  }
14. 
    1 ?: @  K: g; ]3 J$ _3 ?  l6 Y1 P, O
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    : k2 y: c$ \7 `" d. x# F: T4 K" S
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    ) S3 s# d+ O' t
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    
19. #define KEY2_EXTI_LINE          EXTI_Line13
    ' {* w; ]3 |, m+ B2 H
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    
23. 
    
24. 
    
25. void EXTI_Config(void);
    / v4 C" z! |& J: I" T' k6 ^
26.         
    
27. #endif
    ( u# `  s% `6 N1 r. I
28. 
    / T1 n" u6 b7 Z

复制代码

1. #ifndef __BSP_LED_H
   
2. #define __BSP_LED_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   # b, Z" @4 [! ~
6. 
   ( n6 |: B! |6 k6 D* N0 r4 S) D7 v: Q
7. 
   
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    2 }9 h8 c" y" `# F
11. 
    
12. 
    
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    * ]! _4 J' l  M% _; W% {  h
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    
15. #define LED2_GPIO_PORT  GPIOC
    
16. 
    - G, b# d, P  g/ N, F( d  Q. C
17. #define digitalTOGGLE(p,i)     {p->ODR ^=i;}
    1 O, r; ], U8 P. F1 [0 n
18. #define LED1_TOGGLE            digitalTOGGLE(LED1_GPIO_PORT,LED1_GPIO_PIN)
    
19. #define LED2_TOGGLE            digitalTOGGLE(LED2_GPIO_PORT,LED2_GPIO_PIN)  /* LED状态反转 */
    
20. void LED_GPIO_Config(void);                  
    
21. 
    * f# ]$ D% V4 p; y6 {
22. #endif
    
23. 
    . X4 ]: J, w5 `1 l5 J0 w
24. 
    

复制代码

————————————————
; ?2 p5 g) n. d3 a5 A版权声明：Aspirant-GQ
% W- H2 R% D. x如有侵权请联系删除