在STM32中执行中断主要分三部分：
1.配置NVIC_Config()函数
4 {2 W3 [" H2 e) X) g2.配置EXTI_Config()函数
3.编写中断服务函数
（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）

' s  Q" Z) U8 Q3 n  g配置NVIC_Config()函数
# \  o5 e! ~% I9 V( |! s2 KNVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
* B, B+ }. d6 SNVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   & A* ?. O: {5 A$ _6 S9 p
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   
4.         
   
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   * Q$ l+ e& _# a/ ^# j
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   
7.         
   
8.         /* 配置初始化结构体 在misc.h中 */
   
9.         /* 配置中断源 在stm32f10x.h中 */
   3 e( k5 Z7 x& t- O
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    
11.         /* 配置抢占优先级 */
    . N+ `& F8 j2 d; }, f
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    % L  p1 e1 b+ M8 c9 k/ r- W; f
13.         /* 配置子优先级 */
    
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    8 a: g8 u( }: N
15.         /* 使能中断通道 */
    % H$ P7 |7 ?: G  i: S' `1 q! s' @# }
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    3 D7 D/ K2 g, o% l* G" q
17.         /* 调用初始化函数 */
    
18.         NVIC_Init(&NVIC_InitStruct) ;
    
19.         
    
20.         /* 对key2执行相同操作 */
      E- F* U0 I5 L' Y% N
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    1 ^: Y) S  [6 W& Y' _' m4 u
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    " C; T% ?+ t0 \$ \2 A
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    . k. l( K: C0 [# Q1 C' Q& R
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    
25.         NVIC_Init(&NVIC_InitStruct) ;
    
26.         
    ; n2 Q" L+ i0 }- \; b  m( |$ q- ?
27. }
    

复制代码

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

1. 1 /**
   
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   % e0 Z+ j+ V# @6 j) m0 d+ L5 K
3. 3 * 形参如下：
   " ^6 [, m/ V) v
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   
5. 5 *                                      4 bits for 子优先级
   / v5 O0 j+ a4 _6 e$ P: |% h$ H0 z. J
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   ; i, G6 }# r) J* J
7. 7 *                            3 bits for 子优先级
   
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   ( W4 K2 z; T9 C
9. 9 *                            2 bits for 子优先级
   " D7 V. A  k6 V* y
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    * |4 w! F3 Q6 K8 v% G( G
11. 11 *                           1 bits for 子优先级
    9 F% q0 m# P+ v' E& P, w5 Q. N0 Q. D
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    
13. 13 *                           0 bits for 子优先级
    
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    4 t  m8 ^; n7 [  v' z
15. 15 */
    ; i; a4 u5 k1 H: D$ o+ F
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    
17. 17 {
    & H" X4 {$ W# ]$ N0 |) s% r& S  Q
18. 18 // 设置优先级分组
    
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    
20. 20 }
    / J6 T9 ?1 [9 u# i: k

复制代码

. U! e( P) \- t& m# R$ v, D2.优先级分组完毕后，是配置NVIC初始化结构体
7 c' h  e' C; S" a1 q5 K/ R

1. typedef struct {
   3 O* l' e& A+ N2 A9 h8 b
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   0 y! V0 [3 N' y9 v$ d" s. D
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   " w1 n- `& W( N( g& G
6. 6 } NVIC_InitTypeDef;
   : F% `0 C  p. d$ p

复制代码

; x2 `+ T8 r2 p8 j/ p  Z0 N  K3 g初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
NVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
' ^6 @8 \. Q1 v1 BNVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）
* y% g1 B2 ?4 o1 j, W
' @) c3 i* |* A1 ]+ d+ @  v
6 f) j) a6 S! Q8 n/ I配置EXTI_Config()函数
' J! {! A4 S! {4 a# F& YEXTI（External interrupt/event controller）：外部中断/事件控制器，管理了控制器的 20个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置，可以单独配置为中断或者事件，以及触发事件的属性。
按我的理解，EXTI是一个有着多达20个接口的控制器，它可以为每一个接入接口的信号源配置中断（或事件）线、设置信号的检测方式、设置触发事件的性质，也就是说，传入EXTI的仅仅是一个信号，EXTI的功能就是根据信号传入的“线”对信号做出相应的处理，然后将处理后的信号转向NVIC。 就像一个分拣机器，传入的东**过筛选处理被送往不同的地方，只是EXTI分拣的是信号罢了。 如果说NVIC是配置中断源，那么EXTI就是向NVIC传送中断信号。

EXTI功能框图：

+ d. v9 @1 n" k5 P) b: I
7 |' ]3 [0 L$ X) [+ O; z

EXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。

  x1 B. Y4 H/ q" U
, `7 M4 _, [  b; }- P' c& K; |. b接下来讲解一下EXTI_Config()函数代码：

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   $ Q" [8 S% f* ]7 ^* u
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   ! [9 q# M- R4 H% m  r' `
5.         
   
6.         NVIC_Config();
   . l& J! X- x6 ]+ u% D
7. 
   
8.         /* 初始化要与EXTI连接的GPIO */
   2 C6 S- h9 _* m$ X: k; c
9.         /* 开启GPIOA与GPIOC的时钟 */
   
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 ;
    
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    / D! G2 N* {! l  |% s7 n
15.         
    
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    ) F! b8 X* \. h# u$ G, h3 |' ]
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    
19.         
    
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    6 @8 h) ^6 N% L- ?9 b" r+ X
23.         /* 选择作为EXTI线的GPIO引脚 */
    
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    
25.         /* 配置中断or事件线 */
    * ]  G7 r8 Q# U; ^$ v5 Q. _% K
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    # X) J! I: r2 C2 e7 h; \! u
27.         /* 使能EXTI线 */
    
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
29.         /* 配置模式：中断or事件 */
    
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    ( A3 r7 @, v& M6 q! k- _7 K: W* Q
31.         /* 配置边沿触发 上升or下降 */
    
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    1 J- m1 O' q1 A% d" F: N
33.         EXTI_Init(&EXTI_InitStruct) ;
    
34.         
    
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    + V/ N( j; T( M
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    * s# Z# g+ e( [8 s$ \4 k
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    ; W! z5 M" T7 n% }  _9 B
40.         EXTI_Init(&EXTI_InitStruct);
      P. ]- r0 ]6 K' R( [6 W9 n' h
41. }
    0 q/ K1 e; c$ w+ r4 Z& d7 I
42. 
    

复制代码

9 r3 B: y. g# b! t8 B5 @3 X$ H代码可大体分为三部分：
配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
1.配置GPIO相应引脚
+ G$ h5 O/ G8 \1 z% v$ \- e该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
% Z+ a' i0 I: T/ ?3 B2.配置EXTI并连接GPIO引脚
要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下
8 F% a1 y( m8 C& G" y+ \

1. /**
   / U! D' @- X7 y
2.   * @brief  Selects the GPIO pin used as EXTI Line.
   
3.   * @param  GPIO_PortSource: selects the GPIO port to be used as source for EXTI lines.
   # u7 s& K% n" T/ [4 s
4.   *   This parameter can be GPIO_PortSourceGPIOx where x can be (A..G).
   
5.   * @param  GPIO_PinSource: specifies the EXTI line to be configured.
   0 y8 D; C4 p3 o
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   ; P# K4 ]0 M! h! u/ A; F+ {
7.   * @retval None
   
8.   */
   
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   
10. {
    
11.   uint32_t tmp = 0x00;
    ( `# d3 u; H1 u, k
12.   /* Check the parameters */
    , l# L9 _7 J7 T
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    2 O' |1 I  E) @/ P- l8 s3 {
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    
15.   
    
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    , c  n: ^4 V/ W4 R# V! I( P" d
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    * \! d9 h( `+ i# I4 p: y4 b
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    ! c( p5 ~# Z( ]; B
19. }
    

复制代码

+ v& {) E+ e. I2 }3 y' X  u& {其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：
. S6 x( V+ ]- H! E( r0 }" k, p

1. typedef struct
   * w! F3 k9 j2 H) R, P' B
2. {
   + b  B! j/ J, o( B
3.          uint32_t EXTI_Line; // 中断/事件线
   
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   ) s$ _5 _& j+ n+ U7 v
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   9 p4 s' D$ c- z2 i% E, ?
7. } EXTI_InitTypeDef;
   9 y0 u/ a5 [/ g# D. N! L; I

复制代码

配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
# J- p: x5 P( K0 B( T* r- V- _/ ?' NEXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
EXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
EXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
3.传入NVIC_Config()
9 ]4 Z* z! `0 f7 _7 c2 `4 ]7 u之后就自动传入NVIC中了。。。
) l7 }9 N4 D! t5 \+ E8 C: P
, h9 d" D: p$ F8 ~编写中断服务函数
到这里就万事俱备只欠东风了，中断的触发与处理及优先级定义都已经安排上了，最后一步就是编写中断函数的内容了，只要进入中断就会执行中断函数中的代码，所以这是收尾工作。STM32的中断服务函数不同于51单片机中的中断服务函数，STM32的所有中断函数都被偷偷安排了，每个中断都有其固定的名字，只有找到这个名字，在这个固定的函数名下编写中断服务函数才是有效的，所有中断函数的编写都要在stm32f10x_it.c 中，如示：
: q* B" ?$ M5 x! ]* @! s5 B/ t; N
! G) ^. a& K# ?/ s+ i3 J

从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：
8 ~4 n' f) v. B7 l
: u4 Q" z+ K, i0 U( W1 z' l
1 y, Y% \, S, C; N: M# O
0 H; G+ |  N1 m' V, B
可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。
6 q) D- R" s/ X0 y; J& ~8 a. y4 j
3 P: r( l  [! \% F我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：

1. void EXTI0_IRQHandler(void)
   
2. {
   9 w* I* D( z& D9 F/ O2 Y
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   * v: G3 }7 b# _+ s, V
4.         {
   " _8 I7 V9 Q$ g
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   6 i3 Q, _$ O+ m& h* N* l, x7 o
6.         }
     k. \  g! {5 ]! R( h
7.                
   
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   
9.                
   4 k% h+ S8 w: s& O; W  H/ @0 {
10. }
    
11. 
    1 S2 g: y- P9 k: u% [! F" h
12. 
    0 U0 W! ?6 b, b/ c  j) H' o
13. void EXTI15_10_IRQHandler(void)
    
14. {
      m7 u  F/ T) p; j
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    ) o9 Y7 K& z$ J! Q
16.         {
    
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    7 J. T3 F* e2 \0 @
18.         }
    5 e  c+ `5 P9 u* U+ `1 s5 O- V
19.                
    
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    9 N4 f/ ^% t4 ^
21.                
      \/ O) `% n# T- n6 Q
22. }
    
23. 
    : B2 R! ?: ^3 i4 Q# e2 n$ J

复制代码

每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断


& V4 W; Z  I9 Q; J大功告成
  o  H8 R* B1 q7 d4 [; [到此完整的中断系统就已经完成，主函数只需调用即可！！！

1. #include "stm32f10x.h"
   
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
   4 T8 v6 c/ O3 d8 ?
4. 
   9 o9 @; ~* H& p: e" R
5. int main(void)
   
6. {
   : b/ L  Y( x) C. S" p0 J- `3 q% X$ t
7.         LED_GPIO_Config();
   
8.         EXTI_Config();
   ' R% h; ^* A' Q0 q6 c  J* x7 }( C
9.         
   
10.         while(1)
    
11.         {
    
12.         }
    3 |: O5 _+ ?4 q7 C/ q, ?
13. }
    7 J% m+ k9 ]  Q% H+ o# ]
14. 
    
15. 
    0 [- K( H+ B/ g- Y( U5 K

复制代码

1. #ifndef __BSP_KEY_H
   
2. #define __BSP_KEY_H
   / J; t6 @2 X0 I' W* Z4 e
3. 
   
4. #include "stm32f10x.h"
   
5. 
   0 w8 h! w) W- |* J1 d( l
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   , H/ I/ X8 S3 Q1 P2 T, A
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   - v6 C; ]  T7 A# @- b8 F
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    + t6 R  z( C- N% D; V/ a
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    9 U) L1 U2 C" p# N
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    ; g' O, q0 I% d) Y
14. 
    0 l4 Y7 j, x/ L& ]& Z9 p
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    & v, g0 o8 E' ]7 V, T! r' b
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    8 T2 y' S8 F  o% l2 {
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    
19. #define KEY2_EXTI_LINE          EXTI_Line13
    
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    ; v; k. Y6 c7 ~4 l
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    
23. 
    
24. 
    5 p$ W0 |: @& e
25. void EXTI_Config(void);
    
26.         
    
27. #endif
    
28. 
    0 R1 B' J4 y" J0 M6 w  G

复制代码

1. #ifndef __BSP_LED_H
   
2. #define __BSP_LED_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   6 m$ v4 o1 r3 i
6. 
   
7. 
     B! R$ `7 y, @# t' I  P$ [
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   ; m8 D, P4 T" N& V
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    
11. 
    
12. 
    
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    * }; n! @4 ]* h  a
15. #define LED2_GPIO_PORT  GPIOC
    ; L9 `) s2 m+ c9 ?9 K
16. 
    
17. #define digitalTOGGLE(p,i)     {p->ODR ^=i;}
    
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);                  
    & i6 E& f5 D0 y& |4 i# T9 ]
21. 
    2 i" s  W6 H! v2 f
22. #endif
    
23. 
    2 c6 y/ h- }/ V+ k
24. 
    

复制代码

————————————————
版权声明：Aspirant-GQ
8 ?+ L( s- q1 N6 `( L如有侵权请联系删除
. {$ }" N7 k, F- w2 N4 y2 [