在STM32中执行中断主要分三部分：
1 F& H* h5 W! f$ f( k1.配置NVIC_Config()函数
' g% P# t5 J$ |2.配置EXTI_Config()函数
* J% j" K$ m5 N! @3 G3.编写中断服务函数
（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）


- s) s5 @) ^  d( j3 B配置NVIC_Config()函数
# o, K: b# Q8 I) PNVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
  D- |0 b5 ?. b: G* E' [NVIC_Config()函数代码如下：
- S& c3 J$ P8 W

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   
4.        
   6 `- j9 i" T; l' o3 _+ T7 g
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   
7.        
   
8.         /* 配置初始化结构体 在misc.h中 */
   ' C! \2 e& g* g& X% i5 N- k
9.         /* 配置中断源 在stm32f10x.h中 */
   
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    
11.         /* 配置抢占优先级 */
    % C5 M& _& C2 {9 w. v
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
13.         /* 配置子优先级 */
    
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    
15.         /* 使能中断通道 */
    
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    
17.         /* 调用初始化函数 */
    3 m0 r- {$ f, l2 i
18.         NVIC_Init(&NVIC_InitStruct) ;
    " J# L1 D9 Z4 ^& K3 E0 T
19.        
    
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    - b3 C5 [+ K) z
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    
25.         NVIC_Init(&NVIC_InitStruct) ;
    2 u( U8 {% n/ k! ?9 g$ H$ t
26.        
    
27. }
    * {  J. C) ]% z' T, y" [

复制代码

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

2 m; I3 D. ]3 y9 _1 g4 Y
1 D+ }1 R) s5 U# _( T! ]: t接下来简单讲解一下NVIC_Config()函数的内容：
1.首先设置中断优先级分组
中断优先级分组其实是确立一个大纲，中断优先级寄存器 NVIC_IPRx中有4个位用来确定优先级，中断优先级的分组就是把这4个位分配在抢占优先级和子优先级中。比如设定一个位配置抢占优先级，其余三个位配置子优先级。通过函数NVIC_PriorityGroupConfig() ; 实现分组，详细代码如下：
) Z  [" n& k! F* ]& }

1. 1 /**
   2 w  F1 v  o( ^. U  ?+ E
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   2 E0 g2 i% A7 H7 h) @
3. 3 * 形参如下：
   # a1 k; J2 B, O" }& X$ `
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   & P% ^6 L! U% p9 {! y" m
5. 5 *                                      4 bits for 子优先级
   
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   4 t( d. o! K. S8 r2 n. m# b
7. 7 *                            3 bits for 子优先级
   2 H2 b6 M1 b' P' H  l( M; Y( M* F
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   ; [! s6 R1 c0 j/ H4 z. \
9. 9 *                            2 bits for 子优先级
   6 ^5 O- o3 A: a$ y! @) ^0 x
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    ! `3 P1 U6 u' ]- H4 a' ]/ F
11. 11 *                           1 bits for 子优先级
    7 {1 m, t( c9 F# d: L- ]
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    
13. 13 *                           0 bits for 子优先级
    
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    # @8 P6 o1 N: \3 h. D
15. 15 */
    
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    8 @5 ^* [0 U0 N; {: u5 H0 u+ r
17. 17 {
    
18. 18 // 设置优先级分组
    
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    
20. 20 }
    

复制代码

2.优先级分组完毕后，是配置NVIC初始化结构体
! j7 r& ^: {. Y1 T: l

1. typedef struct {
   . J) ]8 e7 C$ A; V
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   % H. @% o% p( d; e; L
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   
6. 6 } NVIC_InitTypeDef;
   * ^2 p4 R! x9 }: r* \3 M$ }

复制代码

+ d# a3 v( [$ p' Z初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
: N8 y4 |3 I  Q6 c0 yNVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
# `* }# O% L7 g! K  @# H3 ~& E$ jNVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
. _- L0 t; s7 |  J6 [+ o; }! V3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）
+ V7 J1 g$ j; A$ z( L8 p+ c

' N/ ^9 J/ f/ g# S9 f) ~9 P5 c配置EXTI_Config()函数
- Y. S5 d: |5 p5 zEXTI（External interrupt/event controller）：外部中断/事件控制器，管理了控制器的 20个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置，可以单独配置为中断或者事件，以及触发事件的属性。
按我的理解，EXTI是一个有着多达20个接口的控制器，它可以为每一个接入接口的信号源配置中断（或事件）线、设置信号的检测方式、设置触发事件的性质，也就是说，传入EXTI的仅仅是一个信号，EXTI的功能就是根据信号传入的“线”对信号做出相应的处理，然后将处理后的信号转向NVIC。 就像一个分拣机器，传入的东**过筛选处理被送往不同的地方，只是EXTI分拣的是信号罢了。 如果说NVIC是配置中断源，那么EXTI就是向NVIC传送中断信号。
' o' I7 o* s- |, v# I8 Y1 D' Y
7 }: C. k8 m+ `* H5 }EXTI功能框图：
& C$ c0 a2 B" k  v: i0 P9 h
EXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。

: F4 s) X/ C1 ^. @4 x0 F% ]
) N& O9 J0 E  \- Q% g( @接下来讲解一下EXTI_Config()函数代码：
7 O- ~1 l& G" H1 o4 ~# D% ]' A0 ]

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   ; m) `/ N, k; e+ S) R4 h
5.        
   
6.         NVIC_Config();
   
7. 
   ( K* Z& w/ R5 X) d! Y
8.         /* 初始化要与EXTI连接的GPIO */
   5 c% {. x7 v- \+ K8 e& G' x( m
9.         /* 开启GPIOA与GPIOC的时钟 */
   
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    
11.        
    3 K( _  @+ l5 @& L1 G- I
12.         GPIO_InitStruct.GPIO_Pin = KEY1_EXTI_GPIO_PIN ;
    ; `3 a' z$ I0 H( ]2 f3 R
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    & B5 O* h. p8 A3 n
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    % K9 |7 O& F# I+ B# O
15.        
    % ~; q7 A4 [- y: ?3 N* S6 d& y; k
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    # P2 v8 h7 ?; O" m
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
      G# ?) ?) o9 e  _) U" i
19.        
    
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    0 ?/ x4 p. f; Y5 L
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    
23.         /* 选择作为EXTI线的GPIO引脚 */
    
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    
25.         /* 配置中断or事件线 */
    
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    * `2 ^) z* \  h, K5 r* @
27.         /* 使能EXTI线 */
    % r$ k+ K) d6 r; p0 A8 w5 I
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    / V8 g$ Y# ~" m8 \( X, g2 D' l* k. B
29.         /* 配置模式：中断or事件 */
    
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    4 |& Z5 H+ A7 l' Z5 \
31.         /* 配置边沿触发 上升or下降 */
    1 A# K8 Z" l; ]' U8 U
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    + G7 T8 k7 W1 ~9 K
33.         EXTI_Init(&EXTI_InitStruct) ;
    
34.        
    6 _7 P$ s" D& ]0 \% ~
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    9 q& p7 a0 [, c$ ?7 I: {
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    / }' _! I- B1 B
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    ; E5 t' b4 r3 F* Y
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    
40.         EXTI_Init(&EXTI_InitStruct);
    - }* ?3 y' x- U1 q! ]
41. }
    
42. 
    

复制代码

2 ^6 Y* ~' q! u2 _' ^3 }代码可大体分为三部分：
配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
/ V) p+ M( k  M) d" z/ y% _1.配置GPIO相应引脚
该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
2.配置EXTI并连接GPIO引脚
要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下

1. /**
   
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.   *   This parameter can be GPIO_PortSourceGPIOx where x can be (A..G).
   - J2 K# [2 }4 Z" N
5.   * @param  GPIO_PinSource: specifies the EXTI line to be configured.
   
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   0 R0 n6 \" w, a7 u# i; Y) |
7.   * @retval None
   9 @; ^( P) R" ^; ]. s+ ~
8.   */
   
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   
10. {
    ; p& U" x2 j$ b3 ]  b8 M- h
11.   uint32_t tmp = 0x00;
    
12.   /* Check the parameters */
    ) g6 Q  m$ ~) ]" j$ x: Z
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));
    
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    3 f. z- Q6 i, C6 S- m# f/ c
19. }
    - {# |( L# M9 k7 M, h+ u" H

复制代码

1 E% }) s& I- X1 C其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
( n5 E/ r. D, k) G3 Y, j连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：

1. typedef struct
     h4 R6 [! F/ I. G: }
2. {
   
3.          uint32_t EXTI_Line; // 中断/事件线
   
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   8 [9 T. c: b! O* j
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   0 m8 X" C1 A0 j
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   . Z! A; Q" r" k! j; ?. p0 C
7. } EXTI_InitTypeDef;
   

复制代码

配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
. h1 T# z7 G" l  @1 ]3 Q5 M. v0 xEXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
4 c4 c" h4 T4 f4 i) J  XEXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
EXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
' {/ b7 `9 O: d# T初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
3.传入NVIC_Config()
之后就自动传入NVIC中了。。。


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


- c0 u* z. q- H. r- d4 z/ W
从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：
. ^% U* j+ @  l! A# C9 r
5 P- W  i+ Y$ M  d3 U

8 P8 i( p& t' D8 ^+ N. o
可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。
( u8 t+ d: }5 e$ ?" y我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：

1. void EXTI0_IRQHandler(void)
   5 h0 U3 N& @7 K! K2 Z
2. {
   
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   
4.         {
   
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   ; b4 z/ s9 k' E  z3 x4 P
6.         }
   
7.                
   % m2 j7 d: I& {% G! k6 e! }
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   8 Q2 B' T; r! G* w: h- |5 S
9.                
   
10. }
    
11. 
    . G: V' `2 b+ W9 v
12. 
    & B7 Z$ U# d  z: s0 `* v
13. void EXTI15_10_IRQHandler(void)
    * B1 h! p, E5 p; G  k
14. {
    5 r9 ~2 v4 I9 x) {2 q# J$ ~1 V
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    
16.         {
    + n& f  j! _9 I
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    
18.         }
    ) c, T: f7 R( c; `* l4 {  s
19.                
    ; u3 r9 Y( W* |. u; q7 n5 }
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
      k/ w+ ?  R9 v- i: Q6 P
21.                
    - H4 {# m+ X/ Y! d4 e3 V! {- Q
22. }
    5 i/ j/ h3 {4 Q" V! T* O
23. 
    1 k3 |) F( S2 ~  J4 o+ s

复制代码

: R* O' H  Q5 ~3 \0 Y6 S8 \6 _8 K9 p每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断

8 Q. O7 F; U/ a$ T7 E8 t: M1 H3 \/ \
大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！

1. #include "stm32f10x.h"
   / V# A  b/ d" }0 @- u7 X
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
   7 s1 ^4 F$ q* g" h; k& Q
4. 
   , l( Y% }0 ~/ ]$ O; s6 c# Y
5. int main(void)
   
6. {
   4 Q. T$ W& h' Z0 x
7.         LED_GPIO_Config();
   
8.         EXTI_Config();
   
9.        
   
10.         while(1)
    ) S. }: [$ M% O2 j% S0 o1 G! e, p
11.         {
    
12.         }
    # k7 _+ x6 _  i2 R  R4 l
13. }
    . g; f2 ~7 y, ]+ Q# g
14. 
    2 w3 i1 q# F4 X9 \6 j
15. 
    % j; n  U2 }" P+ b6 z6 ~$ Z

复制代码

1. #ifndef __BSP_KEY_H
   
2. #define __BSP_KEY_H
   4 K; T; e% m& o
3. 
   " H' U+ X; y& E8 L6 n9 g
4. #include "stm32f10x.h"
   , m7 W, d6 v) i8 A. H% l
5. 
   
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   * J% t2 I' h4 x2 Q! q! K
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   ' s- j( Y* x4 v) n1 U2 t# [
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    + S- v7 x5 c# h" X; N6 U& Z
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
      ?) {7 Y6 Z) R8 f5 d2 {
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    4 D% A8 {1 o7 S4 q3 S/ \/ @
14. 
    & {' `5 `) \" v6 F
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    / Z# w* P! Y6 C: Z" t
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    0 i2 |7 A& T5 r; _' x/ b% ?5 W
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    
19. #define KEY2_EXTI_LINE          EXTI_Line13
    ( l& ]! X! Y5 F1 b/ L. q% `
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    & W- D7 }8 e$ n! \- R- O
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    $ U' U. p! j2 x0 o- U# }) K
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    ! H3 N' o2 V# g9 j- t7 m( ^5 ]
23. 
    
24. 
    
25. void EXTI_Config(void);
    9 I9 U9 ~4 [. Y' p7 l2 r: i4 n
26.        
    7 H- [, ^! C( [% Q+ N) [! C/ p
27. #endif
    
28. 
    : S, M8 T3 m! A

复制代码

1. #ifndef __BSP_LED_H
   
2. #define __BSP_LED_H
   
3. 
   ( \" w. g( ?* ]
4. #include "stm32f10x.h"
   ! i- C4 Y# \& O; u9 `
5. 
   ' W9 K  F( o6 y
6. 
   
7. 
   
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   ; R! u7 P* S0 z+ ~" L
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   $ }, J2 q  i3 b& Q2 x1 |4 p
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    & Q9 p7 E9 Y- R" r& X
11. 
    
12. 
    ' C% h) N+ F  l0 _# K
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    2 E* m+ C% T1 k, D
15. #define LED2_GPIO_PORT  GPIOC
    4 \. ^5 \: N1 Y, U  x1 M
16. 
    ) r, b, n3 l% K2 Y8 t9 b* W$ p
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状态反转 */
    # ~8 g9 Q4 r- Y$ R
20. void LED_GPIO_Config(void);                  
    
21. 
    / ^  c) Y) h! c
22. #endif
    % K/ Y7 l5 |. Z* j; L/ k9 X
23. 
    / y1 P, T" f3 O" Q
24. 
    / D1 h# h& E& s' S2 }/ v& J2 r

复制代码

' I. b& A( u) \6 F. _
5 A) ?3 Z+ e( }: ]# H7 v————————————————
0 b1 ~/ W  Z- x6 {* j5 R/ O版权声明：Aspirant-GQ


( p, @( ?: X! x' ~# ]& K! j4 U