在STM32中执行中断主要分三部分：
1.配置NVIC_Config()函数
2 I$ i5 l5 f8 s8 z, N" A2.配置EXTI_Config()函数
; V. u! w( |. e% I3.编写中断服务函数
; _0 E3 f" p' M& u/ T& V4 k（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）

配置NVIC_Config()函数
( W5 W% E4 d# A( Q8 ~! j. U& K. t! \NVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
; O- h5 S% _- l, k& cNVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   ! p: L. u' s/ d; [0 L+ p
4.         
   
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   
7.         
   & R7 C& y. G0 ?: ]  |7 C
8.         /* 配置初始化结构体 在misc.h中 */
   
9.         /* 配置中断源 在stm32f10x.h中 */
   
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    
11.         /* 配置抢占优先级 */
    
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    ' z2 y" ~+ T* U; `3 _
13.         /* 配置子优先级 */
    ! V( z) @  _2 M9 Y+ p* D  D: x
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    ) T3 O- o6 @5 X. @: E
15.         /* 使能中断通道 */
    
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    2 y  T! \( X6 {' G; z3 {
17.         /* 调用初始化函数 */
    / C- o0 i+ X$ x$ X' c* K
18.         NVIC_Init(&NVIC_InitStruct) ;
    
19.         
    
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    2 S2 ~* m; |: [9 ]8 e
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    2 |) W% S$ A% I0 B
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    * f8 ]  p& q5 c# p4 M  u
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    
25.         NVIC_Init(&NVIC_InitStruct) ;
    1 U: l! L) Z1 G" C2 S) G( h( M0 {, L
26.         
    4 r" `; {0 X4 k: Q1 [; w
27. }
    

复制代码

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

1. 1 /**
   
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   5 f$ ^) A* e0 n
3. 3 * 形参如下：
   1 E7 B9 t6 B1 T
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   
5. 5 *                                      4 bits for 子优先级
   
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   - x4 x: }1 N$ Z6 |+ i, J+ F6 z( ^9 u
7. 7 *                            3 bits for 子优先级
   2 {% _$ U& j" e3 T
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
     C/ R1 _1 y1 {
9. 9 *                            2 bits for 子优先级
   
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    " E% {. K( O% B7 D
11. 11 *                           1 bits for 子优先级
    
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    2 s& V( v; R/ z- H2 z* [
13. 13 *                           0 bits for 子优先级
    ; z" Z- W, z3 u& b$ ]4 A' p! u$ t
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    
15. 15 */
    
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    # {6 D! W* K( s0 k( K4 f
17. 17 {
    9 x$ @; f: m; T; r! F" n1 q
18. 18 // 设置优先级分组
    , N. M1 \/ s7 @. f" w  I
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    ( h/ E2 b0 q' {: K3 S8 y0 B4 `
20. 20 }
    

复制代码

/ p2 x8 [7 C7 S6 v2 k  `2.优先级分组完毕后，是配置NVIC初始化结构体

1. typedef struct {
   
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   & Y, z) f' Z+ [* N. v; G
6. 6 } NVIC_InitTypeDef;
   $ L% h' o+ [( F1 G+ @1 |- x

复制代码

$ ?. z7 c$ o# _3 ?" R初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
! m7 k) y7 N+ }  U8 R! ?NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
: `5 b/ W! {( FNVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
NVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）


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

! ?' e4 W) k" qEXTI功能框图：
  F& U+ M% A1 Y, N9 v1 n# d
" ~! b( d9 e$ D+ E3 V9 S. A
) F9 I+ F9 y0 m
5 N% k5 _# v9 J3 J! Y) I
EXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。


接下来讲解一下EXTI_Config()函数代码：
+ E# Q0 C/ s7 \% p

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   
5.         
   ) h9 |6 ~3 o; }- [# B
6.         NVIC_Config();
   4 H8 ]% u0 D* r+ n6 O1 }; N/ n; h
7. 
   
8.         /* 初始化要与EXTI连接的GPIO */
   8 `. D$ C7 ]$ B3 ^6 @5 \
9.         /* 开启GPIOA与GPIOC的时钟 */
   
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    
11.         
    9 P9 p. M6 ?$ o
12.         GPIO_InitStruct.GPIO_Pin = KEY1_EXTI_GPIO_PIN ;
    
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    2 ]6 v3 R& ~! W! a% Z
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    7 [6 ?' W. U& o; C, p0 E
15.         
    
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    ' q" d3 O7 Z+ c5 D% D' Y
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    2 A6 H" X% A( i$ @% r% V3 A  P
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    " m; q5 F! V, w& d, d6 l
19.         
    - I: Y' g2 P9 I" B+ w. `! |
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
      _. F8 a& [- r; \7 x
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    
23.         /* 选择作为EXTI线的GPIO引脚 */
    5 k3 b- w# p/ [" [
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    
25.         /* 配置中断or事件线 */
    ' K/ ~$ Q2 C* C/ _! q- H" f% }
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    4 j) m# i9 o4 b0 i/ A) K, R
27.         /* 使能EXTI线 */
      X# {7 |1 j) _* w0 F* V
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
29.         /* 配置模式：中断or事件 */
    " @* K3 J* z$ g9 I& w# l( Z
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    
31.         /* 配置边沿触发 上升or下降 */
    - f1 f2 I$ `5 i; U( Y
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    
33.         EXTI_Init(&EXTI_InitStruct) ;
    
34.         
    
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    $ H0 W& t/ j  H, \" w8 R
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    8 x% |/ u; b8 C4 \! ~
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    
40.         EXTI_Init(&EXTI_InitStruct);
    
41. }
    
42. 
    

复制代码

) x9 D; m8 F" W/ }代码可大体分为三部分：
配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
1.配置GPIO相应引脚
# u8 b8 E, p9 n该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
2.配置EXTI并连接GPIO引脚
- W1 x( C6 Q- w要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下

1. /**
   
2.   * @brief  Selects the GPIO pin used as EXTI Line.
   . p5 ^3 i! c1 U& g" R/ o
3.   * @param  GPIO_PortSource: selects the GPIO port to be used as source for EXTI lines.
   & x0 n6 J* G$ {1 Y8 M
4.   *   This parameter can be GPIO_PortSourceGPIOx where x can be (A..G).
   : E$ x+ o% q/ T/ N( i: U, E* D, t
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
   8 _! Z, {0 d! J, Q& j1 r8 z) |
8.   */
   & L  c  L1 k+ t4 O# s
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   6 I! r/ C, C4 ]2 [
10. {
    
11.   uint32_t tmp = 0x00;
    8 [* {" _7 I! F+ O1 P
12.   /* Check the parameters */
    2 k& f2 ~& D) b) o* q" x
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    2 _2 M$ K# i: ~/ t( T* E" b
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    
15.   
    6 l8 i' Z% S) Q# [2 M" q% Q
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    " Q9 s' q% \- |" F; d# e3 f* U! ~
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    0 O7 c/ Z; h( H8 }
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    ( W* F2 l% R. ]/ R0 Z/ x! F
19. }
    , O& l* l1 N% D& u+ X

复制代码

9 _+ t* @; l8 C8 s其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：
: ?7 F+ ^) {3 _2 u6 ~
7 A8 H3 Z; S+ m: J

1. typedef struct
   $ f* H* L" I/ j9 J
2. {
   
3.          uint32_t EXTI_Line; // 中断/事件线
   ) H* x# X4 q/ _1 x( {! d* G
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
     f2 w! B6 C$ A
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   " F* N" `& y% W) o6 I9 T) ?0 k
7. } EXTI_InitTypeDef;
   

复制代码

; z# Y5 Q6 O7 ~配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
1 ]* A- P8 E) {4 ~EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
EXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
$ H+ Y! P, _" _EXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
EXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
# k. c( \" z: C  k& G0 |初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
3.传入NVIC_Config()
  q5 M1 W0 E# U之后就自动传入NVIC中了。。。

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

2 q! P. K1 I, ^6 C" w
; h! i$ B" Z% A  i
  K$ g: _9 _/ d8 _  Y' B* @从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：

) P2 x- [  S2 g$ f/ C% o" X: Q- \+ x1 J3 b
) B& U6 n. l8 x0 _

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

我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：
! u2 H5 K* w4 r, u) K; o

1. void EXTI0_IRQHandler(void)
   
2. {
   ( \/ _6 ?* d- D6 _) Q
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   
4.         {
   3 X7 a1 p8 g3 u: ?+ @4 S$ j  F% p
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   " Q9 [' b2 s3 j; @" p
6.         }
   , y. N) q1 l* V2 G" ~
7.                
   & i( K9 N3 e, Z/ I& R
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   ( M0 N  ^! y! x
9.                
   : K! K) G2 u2 U0 }8 B
10. }
    . l" u8 h3 I: k" b9 w& k# h
11. 
    . i3 B( `1 o, y2 _
12. 
    
13. void EXTI15_10_IRQHandler(void)
    
14. {
    % d  P$ P" I( ?+ w8 `. ^8 @5 _- l
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    
16.         {
    0 n2 K3 g5 T) A1 ], Y! T
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    8 i5 B& z, X% c
18.         }
    
19.                
    - `+ w0 l7 l6 B
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    
21.                
    2 S6 w' u: a6 T. G) |
22. }
    3 f& P6 p+ G+ i2 I1 d
23. 
    ! ?( W$ o, ^' {+ s  @. J3 ]  B0 }% `

复制代码

6 ?- T9 r4 q9 |% a; }  n每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断


0 _. \. i6 [  [& j- A) L- ]# D大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！
) T* k2 L; L4 L# a" |! u0 J3 e  o

1. #include "stm32f10x.h"
   
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
   , {) c2 v2 G0 k+ I$ ?/ b5 c# u, a9 ^
4. 
   0 \# O& a9 p& I; p  M
5. int main(void)
   
6. {
   
7.         LED_GPIO_Config();
   
8.         EXTI_Config();
   
9.         
   
10.         while(1)
    & Y" L+ r( k7 q- s
11.         {
    % Q, G1 }3 V* a7 ~' \9 t* l
12.         }
    . E/ j" U- r  Z& H
13. }
    * f/ o1 m/ e$ {, K9 k
14. 
    . t$ z" Q* d  @0 c0 x
15. 
    

复制代码

1. #ifndef __BSP_KEY_H
   
2. #define __BSP_KEY_H
   4 u+ P* P, I$ t* D; O! W+ g
3. 
   . J, Q! Q& {! J$ Q  j
4. #include "stm32f10x.h"
   . }: e5 [% s1 p4 i
5. 
   
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   0 s1 l# W8 n( I1 O" O  U
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   0 j; S7 x* n' c6 z2 E; e
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    $ m% I7 g( u9 I6 V; I) z+ ^0 W. M
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    
14. 
    
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    : r3 {& m& O0 b* z! j8 O+ O- b
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    , d( [# p" p: c5 d
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    
19. #define KEY2_EXTI_LINE          EXTI_Line13
    
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    - ?6 Q3 [: [$ W) o
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    
23. 
    
24. 
    
25. void EXTI_Config(void);
    
26.         
    ) J: ~7 R' s4 n1 R% J; A
27. #endif
    0 b1 N1 X( D4 X9 J# z+ H1 C3 H. {
28. 
    

复制代码

1. #ifndef __BSP_LED_H
   
2. #define __BSP_LED_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   
6. 
   # l0 @' m. P0 m& P: u* H; l
7. 
   1 @" M' ?/ h2 D/ ?# f( n" b9 t. Q
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   $ g# a! F5 n) l8 W# l
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   ! n: P* I) K3 y  T: R5 V
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    7 g0 h8 g* w- P1 c; ]! e1 ?
11. 
    8 M' _' D* F' t0 c
12. 
    
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    9 L& s* f8 p) j5 V; K
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    
15. #define LED2_GPIO_PORT  GPIOC
    $ r! c3 A( |* l  i3 X4 \2 A/ G
16. 
    ( D" t( o4 _4 J- k* O' k
17. #define digitalTOGGLE(p,i)     {p->ODR ^=i;}
    1 ~3 d: h1 X. W) N
18. #define LED1_TOGGLE            digitalTOGGLE(LED1_GPIO_PORT,LED1_GPIO_PIN)
    6 W0 X: P* M( X  r; {, A- X, ?. N
19. #define LED2_TOGGLE            digitalTOGGLE(LED2_GPIO_PORT,LED2_GPIO_PIN)  /* LED状态反转 */
    : c# j6 N, [, s% ^$ p" l3 }6 i
20. void LED_GPIO_Config(void);                  
    " B, \1 j* y! h+ a, x, `
21. 
    0 ~3 d4 s, Q" D5 _3 @% j. `2 y: b
22. #endif
    
23. 
    4 t- j5 Q3 a0 N
24. 
    : Q7 f+ K5 T4 p

复制代码

————————————————
版权声明：Aspirant-GQ
, s5 L- O. C  s) x9 |# `如有侵权请联系删除
, z2 I( s. B3 z7 b: a% ?