在STM32中执行中断主要分三部分：
! ~6 o+ d% v  ~1 r& R* N, l! P+ X1.配置NVIC_Config()函数
2.配置EXTI_Config()函数
3.编写中断服务函数
3 X' ^; o; Z, [( A（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）

0 s8 a! j. u! u, \
配置NVIC_Config()函数
; ^) D; v* h/ |: d" jNVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
; a3 t* g; k: ]  t, oNVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   7 U6 V" t+ o8 U
4.        
   
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   $ t( S* K$ D3 }6 {
7.        
   8 X# H+ G' i2 m  P. k" m- T
8.         /* 配置初始化结构体 在misc.h中 */
   % g* U2 z/ |- P  T& v
9.         /* 配置中断源 在stm32f10x.h中 */
   5 ~$ P) y  m6 [& l
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    
11.         /* 配置抢占优先级 */
    
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    3 o- g  _4 u( x3 k6 h' P3 v
13.         /* 配置子优先级 */
    2 q$ O$ ]* k2 q8 q
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    
15.         /* 使能中断通道 */
    
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    : ~) w& v, K6 }7 B; D  Q
17.         /* 调用初始化函数 */
    
18.         NVIC_Init(&NVIC_InitStruct) ;
    * a( N% t: Y2 F# ^6 J3 D& K
19.        
    ; S% p  A! M+ c% \3 ]
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    " y2 Y$ |, S+ [" ^+ y
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    
25.         NVIC_Init(&NVIC_InitStruct) ;
    
26.        
    & C1 q, w; `1 y# M8 y1 D" F& ^
27. }
    

复制代码

配置NVIC_Config()的目的是选择中断源的优先级以及打开中断通道，主要功能通过配置NVIC初始化结构体NVIC_InitStruct来完成。通俗的讲，STM32中有很多中断，而当有多个中断同时发生时就涉及到中断执行的先后问题了，所以引入了中断优先级的概念，中断优先级越高中断就越先执行。在这里我们只讨论外部中断的优先级，在 NVIC 有一个专门的寄存器：中断优先级寄存器 NVIC_IPRx，用来配置外部中断的优先级。优先级高低的比较包括抢占优先级和子优先级，先比较抢占优先级，如果抢占优先级相同就比较子优先级，从而得出中断之间的优先级高低。NVIC的主要任务就是给对应的中断源分配中断优先级。 中断优先级分配的原理繁杂，但固件库编程的好处就是化繁为简，我们只需要按照NVIC_InitStruct（）中的内容进行配置就行。
8 H0 T- `; }" k
  c- G. S5 T, ]; X  c6 l9 S
! G& F+ T$ J+ x$ T- b  |8 x接下来简单讲解一下NVIC_Config()函数的内容：
$ T6 O% |2 |3 I+ X* \7 o+ [4 X3 c$ P1.首先设置中断优先级分组
1 F! Q1 F1 p* h中断优先级分组其实是确立一个大纲，中断优先级寄存器 NVIC_IPRx中有4个位用来确定优先级，中断优先级的分组就是把这4个位分配在抢占优先级和子优先级中。比如设定一个位配置抢占优先级，其余三个位配置子优先级。通过函数NVIC_PriorityGroupConfig() ; 实现分组，详细代码如下：
: E$ q- A2 s3 T6 w3 R# [

1. 1 /**
   
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   
3. 3 * 形参如下：
   
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   ; G0 W# ^, l. ]' z! S2 |
5. 5 *                                      4 bits for 子优先级
   5 D5 z$ x/ N0 ?' I% Z& G
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   / W2 ^1 w) g1 h& u0 {1 J# z  X
7. 7 *                            3 bits for 子优先级
   
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   5 F: Q* S$ b0 Z8 H
9. 9 *                            2 bits for 子优先级
   $ N' o0 g; h. W" t% e
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    / A( R* F$ N1 _1 G# R; r
11. 11 *                           1 bits for 子优先级
    # o- v: P9 ~" L$ ?: P
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    
13. 13 *                           0 bits for 子优先级
    
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    
15. 15 */
    
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    
17. 17 {
    * W# n, W+ S6 o0 ?
18. 18 // 设置优先级分组
    3 j* o) v6 }% l9 Q! R
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    
20. 20 }
    

复制代码

/ v* v5 `4 K! ], z2 m* I* R7 L; c2.优先级分组完毕后，是配置NVIC初始化结构体
, E7 R% v  g0 S! l- K8 ^. R- A

1. typedef struct {
   / X% Z* K& Z; L. c$ u% I
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   
6. 6 } NVIC_InitTypeDef;
   

复制代码

5 U, q4 b# E4 L% Z+ s0 @初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
NVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
NVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
  @) e4 h! N0 ?3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）
( J1 j  T( Y* N; q, M& e

2 D) N( D# L3 Y  N$ L% p配置EXTI_Config()函数
EXTI（External interrupt/event controller）：外部中断/事件控制器，管理了控制器的 20个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置，可以单独配置为中断或者事件，以及触发事件的属性。
$ R% w8 ]3 ?5 Z6 L, O9 ~5 F! j按我的理解，EXTI是一个有着多达20个接口的控制器，它可以为每一个接入接口的信号源配置中断（或事件）线、设置信号的检测方式、设置触发事件的性质，也就是说，传入EXTI的仅仅是一个信号，EXTI的功能就是根据信号传入的“线”对信号做出相应的处理，然后将处理后的信号转向NVIC。 就像一个分拣机器，传入的东**过筛选处理被送往不同的地方，只是EXTI分拣的是信号罢了。 如果说NVIC是配置中断源，那么EXTI就是向NVIC传送中断信号。
/ i% S7 B3 e- K/ z9 H6 H3 j
EXTI功能框图：

. A! I- ^  J( p; ^0 M9 hEXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。
! y8 L9 i* m# U4 v$ x; Z: g8 q
/ F. v1 ~5 Q9 `, Z: \+ k. ?
接下来讲解一下EXTI_Config()函数代码：
8 ^' N) A7 s& P3 K

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   1 O: d, g4 x. @3 h4 }0 ?+ q
2. {
   $ c( o$ S* a9 b% G
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   * i2 Q; G, n0 u8 {: c$ _. M
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   $ `6 c: D6 n3 l( g  i
5.        
   
6.         NVIC_Config();
   $ z2 y* @! `! b: u: O8 t- P" R
7. 
   
8.         /* 初始化要与EXTI连接的GPIO */
   2 b# h# ]9 @% Z4 S! O4 @$ h( w- U6 \" y
9.         /* 开启GPIOA与GPIOC的时钟 */
   ! f) [8 e: V3 f4 c/ \- A
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) ;
    + O2 ^, K7 M" f& g% f9 N2 x8 p
15.        
    5 s9 O. P8 [6 n
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    8 v: M% L# |; j' N! u7 s4 G
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    : L1 u' L& X' A
19.        
    & k5 b# U4 y0 Q4 z# e
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    ' q4 B! W) d/ N7 `3 ~+ P/ J
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    % C4 R: ^/ J0 i. U& p
23.         /* 选择作为EXTI线的GPIO引脚 */
    . h& c8 g/ P% l/ O
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    & h) U/ o. Z' l, ~( L+ L1 y2 j
25.         /* 配置中断or事件线 */
    
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    
27.         /* 使能EXTI线 */
    2 L( t. e9 g( G6 P% Z6 K8 z5 _8 n$ Q
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    ) j# k* Z1 J6 ?# D/ ]: D& Z
29.         /* 配置模式：中断or事件 */
    
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    + P2 E, Q7 `8 U# x  q8 r
31.         /* 配置边沿触发 上升or下降 */
      B9 G2 @8 c) V0 w8 K% Y' F! N
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    
33.         EXTI_Init(&EXTI_InitStruct) ;
    * C9 r- n1 x0 H" c& C
34.        
    5 F0 w9 A+ @- c/ Y; q
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    3 e6 v. p3 a% ~; [6 @! S
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    4 z7 g/ d2 P9 ^( k: z/ u: g
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    ) \# m# P8 L5 `- R7 q. O+ S/ n
40.         EXTI_Init(&EXTI_InitStruct);
    0 ]7 X% m4 Y6 o7 U( v' y8 [2 C
41. }
    
42. 
    . w# n  g/ E5 K: Q) U6 N  L

复制代码

9 b" l3 r, i( k+ I% y+ C代码可大体分为三部分：
1 l7 \) ]2 }/ ?: V配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
1.配置GPIO相应引脚
该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
2.配置EXTI并连接GPIO引脚
, |, C" h5 k0 d4 ?  Q3 T要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下
+ I) j9 J% ]# [) ^7 I

1. /**
   
2.   * @brief  Selects the GPIO pin used as EXTI Line.
   8 P, i+ Y5 _8 W3 w  d7 @% x
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.
   
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   
7.   * @retval None
   7 [6 F4 g! j$ R8 M. f% ?2 z( \
8.   */
   
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   
10. {
    
11.   uint32_t tmp = 0x00;
    ) c/ d$ ?$ Z8 q# T# j
12.   /* Check the parameters */
    8 B: E1 n- e' ^3 ~
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    $ C% D8 h1 o1 U: H" q5 Y
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    
15.   
    # k; C6 U; e1 c7 ?8 q
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. }
    

复制代码

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

1. typedef struct
   6 h  t+ S4 C* w
2. {
   % Q1 x; z! K- \2 }- d& \) P" m& M
3.          uint32_t EXTI_Line; // 中断/事件线
   - h) S. Z( o1 N5 n8 @' K
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   ; b) \  E+ C+ ^6 ^# ~5 |, d
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   ; L& I. q4 O3 d. `1 O
7. } EXTI_InitTypeDef;
   

复制代码

# N8 _* N8 @0 w! T4 }配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
3 Z1 l, q& V0 K8 D8 X0 J# g" Q: yEXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
EXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
) ]4 u$ D. I2 s$ ]4 wEXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
) b( f3 a) r: b3 O) }# o$ x初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
/ U7 B; U7 {7 s, t, l1 G  h8 e3.传入NVIC_Config()
之后就自动传入NVIC中了。。。


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


7 `) p& B# T( f4 @
从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：


, v! q. I* O, H- ]

9 G' C& p7 G7 u7 u* W可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。
6 x- J: f: z4 O) x, ]1 h" K% o我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：
" {& k) V9 x& ]9 ^

1. void EXTI0_IRQHandler(void)
   # F7 |6 c4 }5 _! Z0 y
2. {
     Q" s* I+ t- F: [# A5 Q1 c5 n
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   7 {! z& [; [3 y& x$ X! Q3 Y
4.         {
   $ @# t! V3 s3 x$ G# g
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   
6.         }
   
7.                
   ; ]! o9 W5 o. [$ W; z2 g
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   # B' s$ l2 p; C4 X4 H5 s, p
9.                
   
10. }
    / Z  |4 r/ \  u! z. B1 d2 R
11. 
    & j9 x# o7 Q% ]  k7 Z  c& S9 D
12. 
    
13. void EXTI15_10_IRQHandler(void)
    - m$ v9 l+ N9 ]: G/ L. P& j; F" D
14. {
    ) D' b! b+ {" ^: o+ L5 y
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    ( h" T4 u; T/ ?. Q+ J7 T$ N2 Z
16.         {
    ' N) E# A) _4 j4 f3 o6 ~- O! U
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    
18.         }
    
19.                
    
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    . z9 u1 \4 z/ c/ c
21.                
      k/ h6 h2 t* b. M
22. }
    
23. 
    

复制代码

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

! ^- @5 l( v! v% }; R$ P& o
  H5 V7 X4 W! d0 b/ i大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！
% g/ g' e: L7 r* b* m

1. #include "stm32f10x.h"
   
2. #include "bsp_led.h"
   - N* ^3 {+ W; [1 l, h5 X; I
3. #include "bsp_key.h"
   , L# E) W! ]7 T" h2 H, r
4. 
   2 r- t. i6 {6 u0 n; l1 G) R
5. int main(void)
   
6. {
   
7.         LED_GPIO_Config();
   ; V, R; s2 z# ]6 i& T: S
8.         EXTI_Config();
   ! t; n2 A* q% h+ R; y. `9 T- l
9.        
   
10.         while(1)
    
11.         {
    / [  M$ Y, k$ K8 b) u
12.         }
    
13. }
    
14. 
    
15. 
    

复制代码

1. #ifndef __BSP_KEY_H
   
2. #define __BSP_KEY_H
   
3. 
   
4. #include "stm32f10x.h"
   8 H8 ]7 }+ a  W( E! P, h
5. 
   ) M2 f( ?4 r# V6 K- |
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   / W. v4 H0 Q* B2 I1 i
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   5 S7 l/ N# ?' S; c9 H8 ?7 \- R
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   5 z2 j( \- _; U; x+ ^( m$ q! m( }
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    " v8 {8 q/ A% o7 F* u
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
      b; G1 L2 e2 V- Y
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    
14. 
    $ p$ R% |6 k# B0 C) D3 q' Q2 y$ H9 O
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    8 r+ p6 f7 ?% S# Z: x) |% _
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    $ S0 @, k( z7 g: R" S. Z# r
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    , R. G4 c( y: [! ~% N/ N
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    
19. #define KEY2_EXTI_LINE          EXTI_Line13
    8 V+ q9 [/ m# b  C2 |
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    ; {; G% l3 R9 t  ]# `
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    
23. 
    5 E9 _: A* i2 N) X- Z
24. 
    4 U+ U+ }" W8 P% T
25. void EXTI_Config(void);
    " ]7 X0 E; C) Q  T
26.        
    
27. #endif
    , w( F) F% @  a4 e6 r* G2 n: c/ u# c
28. 
    

复制代码

1. #ifndef __BSP_LED_H
   
2. #define __BSP_LED_H
   9 U# F$ Q& l$ A5 n
3. 
   + X+ S9 `: j$ a: g
4. #include "stm32f10x.h"
   % |# C5 n- S% E) ~0 K+ l
5. 
   / X( S0 g/ E! s/ ]' i- l
6. 
   9 E* C6 }% x9 k6 q0 N5 p+ T0 m
7. 
   : z. W# b- W: e4 i9 F8 U
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   0 h# n$ ~6 \4 D2 N
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    
11. 
    
12. 
    2 j2 Z4 s5 c+ W" W' y9 {( [
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    
15. #define LED2_GPIO_PORT  GPIOC
    
16. 
    
17. #define digitalTOGGLE(p,i)     {p->ODR ^=i;}
    2 ?8 R9 W% \5 `6 g( O, f+ ]
18. #define LED1_TOGGLE            digitalTOGGLE(LED1_GPIO_PORT,LED1_GPIO_PIN)
    4 y& V6 g2 f; n# W$ m
19. #define LED2_TOGGLE            digitalTOGGLE(LED2_GPIO_PORT,LED2_GPIO_PIN)  /* LED状态反转 */
    
20. void LED_GPIO_Config(void);                  
    ) R: N! z* X  ]( _- i2 n$ H) O
21. 
    ) x# s# c, F7 A$ r( J2 y2 u4 J
22. #endif
    
23. 
    ; C) b  b) Q5 D4 ?" e; V6 h! h
24. 
    

复制代码

- S* q8 A3 S5 l/ e, k0 g* E/ T7 h7 D

1 ]6 x7 `+ f6 j8 H; T/ }; g/ A' Y————————————————
3 w7 q$ R& R% F- ~版权声明：Aspirant-GQ
- f3 X# i$ y5 x0 s2 x) ?