在STM32中执行中断主要分三部分：
8 X  |+ c% T' |- p1.配置NVIC_Config()函数
2.配置EXTI_Config()函数
3.编写中断服务函数
' b, }) u: M0 O+ K: d（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）
, r: T) r: B5 z0 ?
. A. L8 K% W- F" F$ s7 I配置NVIC_Config()函数
  u7 z! r5 X, z% sNVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
" a/ F# t1 }/ f, m: w4 w$ UNVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   0 M8 t0 V0 J. k' ^
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   6 z0 F2 Y/ i+ a: S& z  u
4.         
   2 A# g2 X! r* v6 Z. ^2 Q
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   4 r7 u2 B6 U  O, k+ I- G, k. k: A
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   
7.         
   ; z5 j9 H9 C+ _
8.         /* 配置初始化结构体 在misc.h中 */
   ) y9 h/ ~4 E0 ~; w& `/ B4 M
9.         /* 配置中断源 在stm32f10x.h中 */
   / Y' i2 a8 j6 Q/ n3 B+ s3 F, g
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    9 r6 h( n* y4 i1 i% L% V' Y
11.         /* 配置抢占优先级 */
    % h* h0 W. {2 _) ?4 `
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    * r0 _- w% I6 d( z! u* {% j
13.         /* 配置子优先级 */
    
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    
15.         /* 使能中断通道 */
    
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    
17.         /* 调用初始化函数 */
    
18.         NVIC_Init(&NVIC_InitStruct) ;
    - N) q4 _( t- Y0 X- X. E
19.         
    - S8 p$ n; ?4 `7 s3 p) P2 H
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    # o0 i6 H! B0 h' C* V7 y
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    - P/ n% }) Z2 W: d8 p( K. c
25.         NVIC_Init(&NVIC_InitStruct) ;
    
26.         
      \* W0 O7 g! l) }, a' U! q7 k
27. }
    

复制代码

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

接下来简单讲解一下NVIC_Config()函数的内容：
1.首先设置中断优先级分组
中断优先级分组其实是确立一个大纲，中断优先级寄存器 NVIC_IPRx中有4个位用来确定优先级，中断优先级的分组就是把这4个位分配在抢占优先级和子优先级中。比如设定一个位配置抢占优先级，其余三个位配置子优先级。通过函数NVIC_PriorityGroupConfig() ; 实现分组，详细代码如下：
+ e- l1 S* R0 G

1. 1 /**
   
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   
3. 3 * 形参如下：
   
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   ! V# A: u, V: m0 s' i
5. 5 *                                      4 bits for 子优先级
   7 |9 O# |. U9 Y0 [" l& o* @
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   : m! n9 v- }; @' P  j
7. 7 *                            3 bits for 子优先级
   ! o5 h1 Y1 a" J" u& c1 i/ G
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   " k$ N/ R: \$ o$ e6 R1 }
9. 9 *                            2 bits for 子优先级
   
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    # M8 N: u$ |9 x( l
11. 11 *                           1 bits for 子优先级
    " ?0 w5 C. @$ P* t6 w* w
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    " b$ b9 [: S1 I. m, n/ c* W9 P
13. 13 *                           0 bits for 子优先级
    ; t$ u/ |  m+ w
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    & G, t6 K+ O4 N/ ]
15. 15 */
    
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    3 G# P' O) c6 ?$ f" O( }) F! P% I; v
17. 17 {
    
18. 18 // 设置优先级分组
    3 P. B: f5 a1 r* H& l' p) k
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    
20. 20 }
    

复制代码

2.优先级分组完毕后，是配置NVIC初始化结构体
! s3 X  I9 L# w$ a% a3 `6 c

1. typedef struct {
   5 V. T  D) t8 g3 G- s1 X" P6 n
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   # {. G7 F& K5 @
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   2 L5 N$ M3 c/ S& `0 K9 u# P( T$ N; z
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   
6. 6 } NVIC_InitTypeDef;
   & U" _  Q+ D0 Q2 N* z9 B6 ~+ z' K

复制代码

初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
/ T+ W/ y/ L: z& D, x$ XNVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
NVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
- L4 l$ X- s4 J4 B3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）


配置EXTI_Config()函数
EXTI（External interrupt/event controller）：外部中断/事件控制器，管理了控制器的 20个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置，可以单独配置为中断或者事件，以及触发事件的属性。
按我的理解，EXTI是一个有着多达20个接口的控制器，它可以为每一个接入接口的信号源配置中断（或事件）线、设置信号的检测方式、设置触发事件的性质，也就是说，传入EXTI的仅仅是一个信号，EXTI的功能就是根据信号传入的“线”对信号做出相应的处理，然后将处理后的信号转向NVIC。 就像一个分拣机器，传入的东**过筛选处理被送往不同的地方，只是EXTI分拣的是信号罢了。 如果说NVIC是配置中断源，那么EXTI就是向NVIC传送中断信号。

- J  K2 O$ V8 j: ]EXTI功能框图：




$ V/ Z3 n) M4 oEXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。
, _5 @. `2 W* G( W! O

接下来讲解一下EXTI_Config()函数代码：

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   8 R" x/ D5 e; `8 O1 `
2. {
   2 e" Y$ U5 ~0 u% w
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   ' [, n& u* B7 ?- O& G- [* A; o
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   4 I: N4 W; b) X/ z4 U, k7 h
5.         
   
6.         NVIC_Config();
   
7. 
   * _8 G6 B6 T' w
8.         /* 初始化要与EXTI连接的GPIO */
   
9.         /* 开启GPIOA与GPIOC的时钟 */
   5 P- M( i( I% N- l& Q/ K3 z
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    : G% Z5 N* J& }1 R: o
11.         
    
12.         GPIO_InitStruct.GPIO_Pin = KEY1_EXTI_GPIO_PIN ;
    6 v% Y! ?' W2 ^
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    & s7 X3 ~, w  ^8 N) {5 I8 w
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    . B, n4 I7 o6 U0 z# Q) I6 ?! Q
15.         
    + F0 {1 i5 R: w4 `( {& ?$ R
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    0 y, H6 h* q# x
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    , T& X" t. G' A* E
19.         
    , K7 }# w" R2 g0 w  o" e) w
20.         /* 初始化EXTI外设 */
    6 g* a2 ^' Y( ]8 k0 [. E
21.         /* EXTI的时钟要设置AFIO寄存器 */
    % z6 T3 k  o' s4 r# h8 X
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    / Q, O0 N+ u, Y. P5 Y
23.         /* 选择作为EXTI线的GPIO引脚 */
    9 @) l1 d1 h! u/ y4 S1 E: d. y
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    
25.         /* 配置中断or事件线 */
    $ C6 @) t9 M! m# V) n$ P5 H
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    
27.         /* 使能EXTI线 */
    . M3 w) t, U' h' A
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    * Z# |' [7 W: H; x+ Q3 l  R
29.         /* 配置模式：中断or事件 */
    ) Y* U- ?% ]( N0 d3 {5 r2 X% v8 ~
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    
31.         /* 配置边沿触发 上升or下降 */
      d' I3 y) w% o- L
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    5 l6 z6 S1 u( D. i4 \
33.         EXTI_Init(&EXTI_InitStruct) ;
    
34.         
    1 }/ L; E8 \) G
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    6 s; d: }- F9 u! P4 p9 N& v7 l* h
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    0 S% f9 v9 W+ Y5 q) V
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    1 L9 }( t5 X3 R
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    ) i: h1 @5 r$ g' S! _5 q4 Q
40.         EXTI_Init(&EXTI_InitStruct);
    - m0 E& |* E- M' o1 m+ ~
41. }
    
42. 
    , T  b3 @; u. q) ~  z! q  D2 {# z

复制代码

8 H+ f( ]5 d3 y, R代码可大体分为三部分：
9 F; ]; r0 A2 }: Z- n; b  U# z配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
# j9 o* P$ N7 N) @0 i1.配置GPIO相应引脚
" ~8 ?  ]& U, @1 F8 w该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
. O6 X% G0 V4 q5 X/ m2.配置EXTI并连接GPIO引脚
; j; T# p6 m# h要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下
& M5 y4 j0 u/ e$ a3 a5 o7 p

1. /**
   0 Y0 R. s# B) {# R
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.
   $ _4 O% c; n# n* n9 B! Y+ l4 y* a
4.   *   This parameter can be GPIO_PortSourceGPIOx where x can be (A..G).
     W! J  M0 _9 r0 L* x( W2 y! h
5.   * @param  GPIO_PinSource: specifies the EXTI line to be configured.
   " m+ Q2 t+ W+ m2 ^6 p, \
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   
7.   * @retval None
   
8.   */
   1 Q8 h+ W! q6 j. ~1 N, v
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   : B& d# R+ A4 W' p) x3 o+ U
10. {
    4 n* w6 c3 N$ a' Q6 U  A
11.   uint32_t tmp = 0x00;
    7 y; J4 k! W5 @/ O- T; Y7 \2 N( l
12.   /* Check the parameters */
    ) e8 w/ W) `& _4 p# W% m
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    1 G" e3 z  J' M% E3 w4 F( M
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    
15.   
    
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    
19. }
    

复制代码

) O- _+ [% P/ {$ j% [8 F9 C2 E其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：
5 z, e" S3 u4 n) x1 v( S& G/ N* n

1. typedef struct
   , h2 _* ^; K/ N  R0 X
2. {
   
3.          uint32_t EXTI_Line; // 中断/事件线
   
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   
7. } EXTI_InitTypeDef;
   ; |0 M0 ~$ F* R. C6 P

复制代码

% S* x, @/ v7 G配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
EXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
EXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
$ r) X4 m7 N* y( s1 HEXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
3.传入NVIC_Config()
6 U: G0 `* a5 a! q6 i之后就自动传入NVIC中了。。。
% L( O+ N- G/ O$ G0 {0 C5 v
1 q1 N4 H! V1 v& P9 ?5 `9 b. Z编写中断服务函数
到这里就万事俱备只欠东风了，中断的触发与处理及优先级定义都已经安排上了，最后一步就是编写中断函数的内容了，只要进入中断就会执行中断函数中的代码，所以这是收尾工作。STM32的中断服务函数不同于51单片机中的中断服务函数，STM32的所有中断函数都被偷偷安排了，每个中断都有其固定的名字，只有找到这个名字，在这个固定的函数名下编写中断服务函数才是有效的，所有中断函数的编写都要在stm32f10x_it.c 中，如示：
1 B+ O- [' d2 i0 n! ?
5 W. f; f6 c' I6 Q9 f
& U! c! x/ a" j1 ]; _8 s
从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：
9 Y4 O, }4 i% v5 ^* K" b+ ^
+ q( W' ~: P/ u4 h0 c


可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。

; \1 h: A1 Y2 R" B, }我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：

1. void EXTI0_IRQHandler(void)
   # h& p1 R( V7 s* \2 d
2. {
   
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   
4.         {
   
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   7 G/ L: @9 p+ f- n
6.         }
   
7.                
   0 k9 h; J* G/ T+ z: x) D5 E5 A
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   / ^7 Q0 N2 @' T: m! E: h' D
9.                
   
10. }
    3 e6 c! V1 ?" Y" t8 ]- \
11. 
    
12. 
    , n- s( D: B* `9 p, V5 C1 L4 ^
13. void EXTI15_10_IRQHandler(void)
    3 M2 d" e0 J- H+ Q
14. {
    
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    
16.         {
    $ n' k. i; b4 x  G% P$ J; v( p& ]
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    0 S" B0 {; s1 K  ]5 H; {4 n
18.         }
    
19.                
    1 y) I1 t$ T! Q* }2 v- ?* I
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    
21.                
    ; ^6 ~+ b* F% u- X9 v) b
22. }
    - m& P1 T, s  G4 ?
23. 
    + @. l# Q8 O7 n5 _( I' u' o  @

复制代码

4 d$ y6 @0 v& _# ], H  _4 k每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断


5 _0 r3 ~  W# }% D: @! t0 }3 m大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！

1. #include "stm32f10x.h"
   % ~9 O' F2 g' L0 N/ y/ J* Z
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
     ]" N! ^# Y; P- H  E5 y/ Y
4. 
   
5. int main(void)
   
6. {
   
7.         LED_GPIO_Config();
   
8.         EXTI_Config();
   
9.         
   , _8 ]0 |* ?* E, l0 A9 e
10.         while(1)
    
11.         {
    & y( q# A- }% p) N( T) e4 p
12.         }
    
13. }
    1 ~+ S" r8 Z; k$ x$ H6 d* S
14. 
    
15. 
    ) J  r) r9 o/ f2 v, n

复制代码

1. #ifndef __BSP_KEY_H
   
2. #define __BSP_KEY_H
   
3. 
   
4. #include "stm32f10x.h"
   9 m6 |& u1 b) {
5. 
   ! G. g7 w: C; j9 c
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   3 r; F* @% k$ S4 x
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   & N8 _) E: l- L( [: V0 ]2 c
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   ! W  g) G* f7 B& X4 k- m0 X8 h4 p
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
      ^" m& E& h2 J
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    
14. 
    % T  l  Q4 m  S1 l
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    , l* C/ b7 _/ j" v; r
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    5 q" E+ n: m8 |# ^  w
19. #define KEY2_EXTI_LINE          EXTI_Line13
    . Q1 E7 {5 B2 r1 ~
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    3 p( s! e8 l7 D4 \5 H" c" u8 u" L
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    ) g1 i: k! |$ Q% ~1 @/ I
23. 
    
24. 
    4 k: Y- _+ x$ i: Y; E5 W8 f/ K
25. void EXTI_Config(void);
    . W  ?0 R, M# b3 Y
26.         
    
27. #endif
    + z1 E' H$ q, ~
28. 
    + Z3 y1 t+ S$ k  B# V

复制代码

1. #ifndef __BSP_LED_H
   / w0 ~& f4 r+ c7 s9 y
2. #define __BSP_LED_H
   " o+ b) m! c; F
3. 
   
4. #include "stm32f10x.h"
   
5. 
   
6. 
   
7. 
   " z& e! [1 M1 W8 d! }. G
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   # l  K( d/ K; T  a# N
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    8 ~' R) l7 g/ [/ O  X1 _  h- T
11. 
    
12. 
    $ i* T& V7 N7 K8 I& G
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    
15. #define LED2_GPIO_PORT  GPIOC
    ! J0 I& G, K4 U/ |+ V% ?
16. 
    1 X% d+ C) g( t- B
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状态反转 */
    9 S' }# e. O4 e0 b6 c* G
20. void LED_GPIO_Config(void);                  
    ' k2 \7 K2 r) L1 X1 f9 l
21. 
    # a1 \, L7 N) a3 J. b
22. #endif
    
23. 
    
24. 
    

复制代码

————————————————
版权声明：Aspirant-GQ
( o3 O* R& f+ k' e如有侵权请联系删除