在STM32中执行中断主要分三部分：
$ ~& ^4 G! q0 X9 X7 o1.配置NVIC_Config()函数
2.配置EXTI_Config()函数
3.编写中断服务函数
! ^! ^& K8 T* h% c7 f/ ~6 g（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）
. `" c/ X/ r7 U/ G' G) i
配置NVIC_Config()函数
* a  \9 c# J3 x! ONVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
NVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   , Y( [$ s8 p) |  \
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   ( g6 g. X2 u) k
4.         
   
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   % |; ]2 T5 _) W3 P% c1 @0 ~
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   * S( f6 l" C) R+ [0 Y+ E& F/ c
7.         
     l8 D' f+ q: p9 E
8.         /* 配置初始化结构体 在misc.h中 */
   - f/ {, |$ B+ X# X  P$ `# K+ b4 f
9.         /* 配置中断源 在stm32f10x.h中 */
   
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    
11.         /* 配置抢占优先级 */
    
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
13.         /* 配置子优先级 */
    $ _: R! c* l( Q4 X) `5 r
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    
15.         /* 使能中断通道 */
    " a7 j7 J1 R/ E
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    3 P* T: h. j8 W2 T1 k
17.         /* 调用初始化函数 */
    7 a  n6 `7 `6 T/ l$ E
18.         NVIC_Init(&NVIC_InitStruct) ;
    
19.         
    
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    ! \3 u& Y3 x* }( R9 i5 B$ w. M1 Y
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    8 T  g) a  V# x5 ~, A
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    ; f/ G1 Y7 A9 H, d/ r6 g8 @
25.         NVIC_Init(&NVIC_InitStruct) ;
    ! A' J. e: [% l
26.         
    
27. }
    9 W7 Z  d' u4 z$ ~  U. _5 R

复制代码

1 @0 ]4 p8 n8 Z$ D' n! [配置NVIC_Config()的目的是选择中断源的优先级以及打开中断通道，主要功能通过配置NVIC初始化结构体NVIC_InitStruct来完成。通俗的讲，STM32中有很多中断，而当有多个中断同时发生时就涉及到中断执行的先后问题了，所以引入了中断优先级的概念，中断优先级越高中断就越先执行。在这里我们只讨论外部中断的优先级，在 NVIC 有一个专门的寄存器：中断优先级寄存器 NVIC_IPRx，用来配置外部中断的优先级。优先级高低的比较包括抢占优先级和子优先级，先比较抢占优先级，如果抢占优先级相同就比较子优先级，从而得出中断之间的优先级高低。NVIC的主要任务就是给对应的中断源分配中断优先级。 中断优先级分配的原理繁杂，但固件库编程的好处就是化繁为简，我们只需要按照NVIC_InitStruct（）中的内容进行配置就行。
. f3 i- @" L4 P& X
接下来简单讲解一下NVIC_Config()函数的内容：
1.首先设置中断优先级分组
中断优先级分组其实是确立一个大纲，中断优先级寄存器 NVIC_IPRx中有4个位用来确定优先级，中断优先级的分组就是把这4个位分配在抢占优先级和子优先级中。比如设定一个位配置抢占优先级，其余三个位配置子优先级。通过函数NVIC_PriorityGroupConfig() ; 实现分组，详细代码如下：

1. 1 /**
   8 i: H! b' J; C( S4 g
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   
3. 3 * 形参如下：
   
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   : F/ v* G, ?2 e9 n2 K
5. 5 *                                      4 bits for 子优先级
   % u0 l5 X9 Z! P7 x2 a. s% J4 z5 x' {) U/ q
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   
7. 7 *                            3 bits for 子优先级
   $ ~. U- b0 K- [: F2 d2 z2 u/ ]  \
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   
9. 9 *                            2 bits for 子优先级
   ' z: w5 o+ b, |
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    
11. 11 *                           1 bits for 子优先级
    * U$ G% T4 X; E9 W. B: h  ~
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    ) G9 k( u; W$ |( C" V  C% ]3 Y
13. 13 *                           0 bits for 子优先级
    + u5 `+ ?& k7 E
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    " O7 K  l7 ?: D/ ]- h8 F( L
15. 15 */
    
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    0 h, R. P$ E5 _5 e) `- ]5 V# q) f
17. 17 {
    ( e: n+ V3 |4 ]
18. 18 // 设置优先级分组
    
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    
20. 20 }
    

复制代码

3 \" |! J8 G0 o& @. Z2.优先级分组完毕后，是配置NVIC初始化结构体

1. typedef struct {
   
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   4 J2 T9 [- o5 m2 Y3 s
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   * n( r4 g9 g4 R, U. r% q, z
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   
6. 6 } NVIC_InitTypeDef;
   1 q6 }9 }( L4 ?- t. }5 Q% }5 @; N# Z

复制代码

初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
$ b  ^+ s/ A, M; V! DNVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
NVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
NVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
) y  h( E# B% Q, Q' K- ]6 M3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）

3 |* Z2 n; o! h' H! `% ]7 K. H
  k' d4 T3 d5 t$ \  R配置EXTI_Config()函数
EXTI（External interrupt/event controller）：外部中断/事件控制器，管理了控制器的 20个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置，可以单独配置为中断或者事件，以及触发事件的属性。
& Q) G, e0 `- {  h: O) i按我的理解，EXTI是一个有着多达20个接口的控制器，它可以为每一个接入接口的信号源配置中断（或事件）线、设置信号的检测方式、设置触发事件的性质，也就是说，传入EXTI的仅仅是一个信号，EXTI的功能就是根据信号传入的“线”对信号做出相应的处理，然后将处理后的信号转向NVIC。 就像一个分拣机器，传入的东**过筛选处理被送往不同的地方，只是EXTI分拣的是信号罢了。 如果说NVIC是配置中断源，那么EXTI就是向NVIC传送中断信号。
$ o6 J8 i+ j& P; y# z3 r. C
EXTI功能框图：
. b/ V7 k, [$ M5 q
0 V+ g5 S6 r. U$ R8 h, X, p9 o/ g


EXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。
. m' ?5 O8 w! _/ Z! G; ?- K

- ~3 u( C; C* M接下来讲解一下EXTI_Config()函数代码：

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   1 _7 _8 y/ Z& G& g3 i
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   . L! U8 i# u- C
5.         
   7 S" ^1 ]. p. f
6.         NVIC_Config();
   : q5 V& e' s/ i6 d2 L4 i- ~
7. 
   " I+ X  G+ J4 M" F/ Z
8.         /* 初始化要与EXTI连接的GPIO */
   ) `% v; s$ h3 e$ @
9.         /* 开启GPIOA与GPIOC的时钟 */
   
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    + `6 m: M9 I+ l( Q. g- h8 a
11.         
    / Q) p( \' s9 {1 A  @2 ~% B
12.         GPIO_InitStruct.GPIO_Pin = KEY1_EXTI_GPIO_PIN ;
    
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    " u) D$ i9 a5 X, I" s7 V
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    
15.         
    
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    ! p* X5 U) s7 M0 `( r" l# s" S
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    
19.         
    - o5 R! t4 Y1 h
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    6 u1 r0 c' n, k- J
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    ; j8 v+ P- q( Q' ?7 W
23.         /* 选择作为EXTI线的GPIO引脚 */
    
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    
25.         /* 配置中断or事件线 */
    
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    . Y0 Z0 t1 l  o/ i( c# x! ?) I
27.         /* 使能EXTI线 */
    ) x+ \. [, J- o6 D7 @
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    : v2 b% P$ O4 j- _$ Q" l
29.         /* 配置模式：中断or事件 */
    
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    ; A" l) i! m; S2 s0 R
31.         /* 配置边沿触发 上升or下降 */
    
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    ) ?% J* [. N& a% l& P- Y
33.         EXTI_Init(&EXTI_InitStruct) ;
    
34.         
    
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    ( l" g, a( k# j4 T, e, D' r
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
      g& Q. O: I* R& |! i; k1 j
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    
40.         EXTI_Init(&EXTI_InitStruct);
    2 P! j" O7 _# u! L' H. t
41. }
    4 l. A# R/ [- a( \5 m$ h' E
42. 
    

复制代码

9 e* ^8 t8 u/ }4 t代码可大体分为三部分：
1 W7 z$ @9 G9 P  C/ u9 `配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
3 h' s/ b" \& h$ L1.配置GPIO相应引脚
) \, J2 y) W% `9 p. f; o3 h该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
; E& N+ l- I  V9 k1 p  V2.配置EXTI并连接GPIO引脚
要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下

1. /**
   / w- l; d+ u' J  H/ @8 B
2.   * @brief  Selects the GPIO pin used as EXTI Line.
   " q$ C0 h! }# I& Y
3.   * @param  GPIO_PortSource: selects the GPIO port to be used as source for EXTI lines.
   - K) W" ]# h2 Z( Q, `; q
4.   *   This parameter can be GPIO_PortSourceGPIOx where x can be (A..G).
   
5.   * @param  GPIO_PinSource: specifies the EXTI line to be configured.
   
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   
7.   * @retval None
   , n# M) |0 |6 j) E' H! R2 d
8.   */
   
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   6 `8 Z! X3 }4 I
10. {
    : R  V: Y1 |; ?
11.   uint32_t tmp = 0x00;
    
12.   /* Check the parameters */
    7 u4 a5 b. r# L
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    2 p; `; `. ^- n/ R# x( @3 i8 _, k
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    
15.   
    ) _3 a. w* X1 W% L  t0 A6 c
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    1 a% |0 u5 @2 \; c% R: b+ a. `5 R
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    
19. }
    . `8 F5 H; O; k

复制代码

其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
, L+ u* p+ x* i连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：

1. typedef struct
   
2. {
   , T9 M" m- S. N2 }6 y2 \
3.          uint32_t EXTI_Line; // 中断/事件线
   & O# O+ v! r$ x% V
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   ; ?3 s2 R$ Y: {( s' x
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   
7. } EXTI_InitTypeDef;
   3 C4 D1 E( ~, h# m' e

复制代码

1 a- s- _( }7 s# V0 v配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
) P# V5 {1 T) R# I/ fEXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
$ S" B7 Y' y+ u+ @EXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
1 C# V" g7 {7 e; i/ REXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
EXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
3.传入NVIC_Config()
之后就自动传入NVIC中了。。。

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



; g) a4 ?7 B" X* P从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：




可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。
& ~2 P$ v7 ^: y; u
+ U% U+ l+ j! R3 r. t( ~我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：

1. void EXTI0_IRQHandler(void)
   ) b% h: f' R: R6 A6 n' [7 k
2. {
   + P* C9 S8 B% A# d5 D
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   0 H0 n# H+ {. ]  a
4.         {
   
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   
6.         }
     V1 u, }1 V7 p' R. J
7.                
   
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   
9.                
   2 {- t- W# e7 g' O3 L
10. }
    
11. 
    . z5 f6 @" q: @1 }, y
12. 
    
13. void EXTI15_10_IRQHandler(void)
    
14. {
    
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    3 B# G; I. y: S2 J4 X" J
16.         {
    
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    ! X& i7 H. C+ I2 o; Z% m" w3 P2 S
18.         }
    + E7 q" j* Q$ J& H7 O1 [
19.                
    
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
      H6 y6 E- t2 e2 Q7 F
21.                
    8 {; I; w; G) ?' s! h/ v
22. }
    + g3 W9 I2 \( a
23. 
    

复制代码

- |/ r% F3 {- @# w  ~7 ]每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断
; r* B# D2 n' `7 @! w: X

大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！
# }$ V# [, V$ d: j7 Q1 h" v5 Z

1. #include "stm32f10x.h"
   
2. #include "bsp_led.h"
   . n+ j2 Z* ?( A8 F
3. #include "bsp_key.h"
   ) T6 J( j. V8 I# `. y: @
4. 
   8 v3 ~6 d# H2 M! w. x
5. int main(void)
   
6. {
   * [9 r# }+ w' j5 Z8 t6 \$ z
7.         LED_GPIO_Config();
   $ ^! Q2 l' p% L$ \. d" R; V
8.         EXTI_Config();
   
9.         
     z: `6 `6 a+ z4 V- k+ w6 E' F
10.         while(1)
    8 B' J: Y) G9 _( t: l
11.         {
    
12.         }
    $ d& p* O! U1 F* i
13. }
    
14. 
    
15. 
    9 \' b% h4 `1 ^' C- l

复制代码

1. #ifndef __BSP_KEY_H
   
2. #define __BSP_KEY_H
   & h$ b8 r$ e- s
3. 
   1 h+ {3 B1 D+ I& n, }/ Q; K0 E
4. #include "stm32f10x.h"
   
5. 
   # S5 ?( ~& U' K& j5 c( ~
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   $ l! l8 ~* L7 O7 L& a
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    0 ?! S% y/ ?  [1 X
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    
14. 
    3 ?5 ~2 ^! J' J7 N* ^/ j3 Q5 e+ a% V" M
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    7 `7 a4 t0 Z" g  G# n  ~. l
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
      u0 r0 U: x9 ]3 @) Y
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    
19. #define KEY2_EXTI_LINE          EXTI_Line13
    
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    . I' r! _; w( l$ E( ]0 ?6 k* z
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    ) z) c7 h8 J) H. i6 _( _( J
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    ' O2 Q( \! _9 H) c
23. 
    1 X7 O% c% L' B/ T+ p! h/ }
24. 
    & |. ]3 A. o/ {) _1 q$ G
25. void EXTI_Config(void);
      p4 b7 C0 `; d! F* j, g
26.         
    
27. #endif
    2 H1 U6 J& D3 F+ n0 t
28. 
    1 D. ?) [& k2 f8 `1 R* X9 X

复制代码

1. #ifndef __BSP_LED_H
   
2. #define __BSP_LED_H
   
3. 
   1 x6 U6 t" z6 `$ m. ]
4. #include "stm32f10x.h"
   
5. 
   
6. 
   
7. 
   
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    
11. 
    
12. 
    - ^0 r6 }, q. T- T, X
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    
15. #define LED2_GPIO_PORT  GPIOC
    0 v" N& v+ O4 n5 V7 {8 ^
16. 
    
17. #define digitalTOGGLE(p,i)     {p->ODR ^=i;}
    3 W+ a4 D$ P# E4 M
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);                  
    ! s/ r: I1 Z) g9 r
21. 
    * z6 B% c4 R  S; [3 J
22. #endif
    ; c. p  P: S% R
23. 
    ' s4 S( v4 Y! W6 e
24. 
    2 w) y" p6 N0 l7 H& v

复制代码

————————————————
; F0 f) e8 i: e9 {9 X  F1 N, P; K版权声明：Aspirant-GQ
1 Y& C- q( F9 z& l! A; ~如有侵权请联系删除

0 w4 E" Y% |! n! M