在STM32中执行中断主要分三部分：
1.配置NVIC_Config()函数
) g) {* ~8 I3 C* M. A; r: N( Z2.配置EXTI_Config()函数
) V8 }* S; T6 @3 L2 M" W0 x3.编写中断服务函数
% p8 Q+ L- n& E  i1 n/ Y( I5 D" z; B（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）


配置NVIC_Config()函数
8 J& E% r, t3 y; h) hNVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
3 D) ?% \0 o( T$ xNVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   
2. {
   * O4 R8 m( n- j5 v4 S' E
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   
4.        
   ' {1 O# L3 ]' J, [; H, j3 j
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   / p2 l& p6 l: [" a6 c+ C  k
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   
7.        
   
8.         /* 配置初始化结构体 在misc.h中 */
   
9.         /* 配置中断源 在stm32f10x.h中 */
   * e8 J5 r; o( D4 U9 }3 T
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    
11.         /* 配置抢占优先级 */
    7 r$ H8 s: a5 l( W7 n) v
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
13.         /* 配置子优先级 */
    
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    / ~! @  i+ x$ {
15.         /* 使能中断通道 */
    & M/ E$ ?/ g: B+ D2 v; d) N5 A: I
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    ) h5 N( `8 t2 i) d; v+ |( m* R2 [1 M
17.         /* 调用初始化函数 */
    0 w; M* B" |4 r
18.         NVIC_Init(&NVIC_InitStruct) ;
    
19.        
    
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    0 O3 W) M8 v, {0 O0 h2 a$ u
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    
25.         NVIC_Init(&NVIC_InitStruct) ;
    
26.        
    
27. }
    

复制代码

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

1. 1 /**
   4 b* \, S% |& M+ @! R
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   
3. 3 * 形参如下：
   ( N! Z7 Z+ L1 _' J3 o/ T3 x) A
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   4 J* A  d: Q# K, Q5 v; d
5. 5 *                                      4 bits for 子优先级
   . d3 p# G  a0 V7 w
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   8 a! g5 z1 `9 f
7. 7 *                            3 bits for 子优先级
   % Q( K' W6 ~7 A0 Z/ }$ }5 v
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   : _5 H4 N. x8 U2 C
9. 9 *                            2 bits for 子优先级
   % _& |4 u6 w+ J/ M4 c& Y
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    6 N" H7 B) P& j. C5 _; P" e+ W$ t
11. 11 *                           1 bits for 子优先级
    + h$ T% Q, {& M/ }' o, \
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    
13. 13 *                           0 bits for 子优先级
    # q) v% a" [8 p* k" d
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    ' V+ @: o* b/ g5 \  M: ^$ u
15. 15 */
    2 K1 F. V" D/ P9 s1 M% ~+ s
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    : a0 _) B7 [- @! R0 p# L2 l# G7 r
17. 17 {
    
18. 18 // 设置优先级分组
    
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    
20. 20 }
    

复制代码

. s# e' E0 u. }2.优先级分组完毕后，是配置NVIC初始化结构体

1. typedef struct {
   
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   - `+ p4 E. D2 R( x5 P% Z
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   4 M/ F( a. |* j4 c6 R
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   0 G1 {5 L* Y+ t
6. 6 } NVIC_InitTypeDef;
   # _9 t$ B. n: e) e/ _7 ~' C

复制代码

& Q; ?2 S  i" d* i8 N2 J初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
; g7 b. L  u% ^' WNVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
" n# m2 a! b  x" U7 S/ h* b" f3 J' wNVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
. C* z7 ^* [( j% M" g; k+ o2 k3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）
1 v( w& P. S5 `  m7 h

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

( f) l5 m; P: U# M- j# SEXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。


接下来讲解一下EXTI_Config()函数代码：
  Z- j4 N1 {3 T* C# u

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   : A4 W; s4 X9 T" r, s0 H
2. {
   0 W8 \, f' h" h. _  s( p
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   1 M6 f8 |3 i  r; f7 H- a
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   ( e/ Z4 d: c0 V
5.        
   
6.         NVIC_Config();
   & r0 U( L9 C4 ^% [$ `! M8 h) G' r
7. 
   / L: A( y% l. [; \. J9 R: c
8.         /* 初始化要与EXTI连接的GPIO */
   
9.         /* 开启GPIOA与GPIOC的时钟 */
   - c2 u+ b( [2 y0 V$ g! m
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    
11.        
    4 T! K8 G( u) g: x0 C  y# h
12.         GPIO_InitStruct.GPIO_Pin = KEY1_EXTI_GPIO_PIN ;
    : o3 o6 F5 o; ~; E( V
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    , {, T1 Q- o8 C+ G
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    
15.        
    0 H( |& i3 j  e3 E
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    ' \* V& r* K; O0 C. i# e
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    - X6 d+ \5 }$ }" `% a/ F0 c7 v
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    
19.        
    
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    - n, o0 |$ V1 Z  e" \* F# b
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    
23.         /* 选择作为EXTI线的GPIO引脚 */
    * J' U4 J* t" T* ?4 ]
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    
25.         /* 配置中断or事件线 */
    
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    
27.         /* 使能EXTI线 */
    + j# X! r/ h* B2 T/ b' ^! {6 t& V4 k
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
29.         /* 配置模式：中断or事件 */
    % `" h- ^# @+ h0 E
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    
31.         /* 配置边沿触发 上升or下降 */
    
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    
33.         EXTI_Init(&EXTI_InitStruct) ;
    ' A) L  w0 i9 |1 o; [! f
34.        
    
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    0 O" U5 L2 ?$ h( N* ~9 k
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    * U+ s. t5 A+ {; L! f
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    4 Y- F1 O$ |" B" `* e) I6 q" J
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    2 M3 f& }/ D  q; Z0 {
40.         EXTI_Init(&EXTI_InitStruct);
    ! C. T8 l0 w" e9 b, {2 ]
41. }
    
42. 
    3 J* v" r' g) W2 H3 r2 J3 V

复制代码

代码可大体分为三部分：
3 s! O' y8 N" H( }& C1 t5 @配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
1.配置GPIO相应引脚
. B% U/ d$ A8 D) a5 W( S该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
, [7 B/ N7 J4 T( o$ j2.配置EXTI并连接GPIO引脚
要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下

1. /**
   4 u4 |8 Y4 m1 Q. K
2.   * @brief  Selects the GPIO pin used as EXTI Line.
   ; C5 a" j2 O0 [
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.
   % E. b* p& q* R
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   0 u7 e4 T" n/ j* @' c4 t
7.   * @retval None
   ; ]4 u( y; y$ W
8.   */
   ) }  @* s  h4 a. h1 M, O+ L
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   
10. {
    
11.   uint32_t tmp = 0x00;
    
12.   /* Check the parameters */
    ! }  C8 B5 g# y* L/ H* M' i
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    + P* |- i! U' ]8 v
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    
15.   
    " W: F6 l1 [$ i7 R
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    7 W7 _5 F. a' n1 D7 V
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    $ T. n2 R& Q9 i  u
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    4 a* J2 i$ g" N0 I! P: S" m: b
19. }
    5 f( k& O: b, D2 S3 F# J4 b& [; z

复制代码

其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：
( B$ L/ K% ?7 l' r( p1 p. O

1. typedef struct
   : k7 k+ g. m/ y# q+ i
2. {
   $ e5 J( Q- U1 U3 g% L$ J# c# C+ a
3.          uint32_t EXTI_Line; // 中断/事件线
   5 j' R8 p& T( u2 h) d
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   0 f' K- ]2 o3 w
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   " _& {! j; `9 n, t
7. } EXTI_InitTypeDef;
   

复制代码

配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
. [4 b2 @  c4 s7 \0 E- [3 bEXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
EXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
2 C' Y3 K, S. N* T- C8 OEXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
0 S' C' m$ }+ f6 E初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
3.传入NVIC_Config()
1 `2 G6 w7 s: g8 r: r8 `. A* ?之后就自动传入NVIC中了。。。
4 h4 k4 n. P1 I" D

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


从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：

% g" T2 r! j* s2 V
/ c9 z6 L# i- P+ ?' C
! T: [, w, z' k# L  v6 d" I
可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。
我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：
6 b1 F) \$ o8 b# p

1. void EXTI0_IRQHandler(void)
   
2. {
   7 Z2 z' ]1 V2 C
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   
4.         {
   , T! x% U7 s) h
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   
6.         }
   
7.                
   
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   ! o$ }8 P4 g1 Q( C! E0 X2 L
9.                
   
10. }
    . J3 Q8 v4 a8 H5 ~: @
11. 
    9 C8 ^  c8 p/ R3 s
12. 
    
13. void EXTI15_10_IRQHandler(void)
    / {! {, O" r( ]1 n: Q/ T
14. {
    
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    
16.         {
    
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    
18.         }
      a* \) n0 B! g
19.                
    
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    - r9 W  [( r& u6 n, K+ e
21.                
    + O3 S6 ]. d: o6 b+ w. w
22. }
    
23. 
    

复制代码

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

大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！
  V/ H: O9 y3 P5 e3 m: a  g

1. #include "stm32f10x.h"
   
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
   
4. 
   
5. int main(void)
   . _3 W* F$ i! k2 ~$ T" I! O
6. {
   
7.         LED_GPIO_Config();
   - {2 q1 I! y' I2 y' S
8.         EXTI_Config();
   
9.        
   
10.         while(1)
    
11.         {
    
12.         }
    
13. }
    
14. 
    & J+ H7 E1 l  W8 q
15. 
    ! E/ J7 x3 [$ n

复制代码

1. #ifndef __BSP_KEY_H
   + X8 q8 Y* M- H% u
2. #define __BSP_KEY_H
   + G: @8 w8 D8 [! F7 I/ z" ?3 a
3. 
   
4. #include "stm32f10x.h"
   4 @2 f; Q2 h% I' P
5. 
   
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   ( H5 t: L3 `; I  _) q
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    - T3 f) H$ }$ r$ a
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    # D; O7 i2 |2 ]6 B& N
14. 
    8 l7 W. s! F* p; `: C/ D; |2 R
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    ' H( \8 \& n, d4 h& S/ y
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    
19. #define KEY2_EXTI_LINE          EXTI_Line13
    
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    7 B- V; W  Z# C8 M0 D0 ?
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    9 R0 ^7 c6 G* I) q
23. 
    % ^1 q$ M2 [( j) q
24. 
    
25. void EXTI_Config(void);
    9 d& _* f( Y  w  G5 M& a
26.        
    
27. #endif
    
28. 
    

复制代码

1. #ifndef __BSP_LED_H
   9 {% D/ k7 i! [6 n; D
2. #define __BSP_LED_H
   
3. 
   
4. #include "stm32f10x.h"
   & X# I+ H6 T: ?& d
5. 
   
6. 
   
7. 
   
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   * L; T. y7 G2 \
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   8 j% q, W6 n' V; j
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    
11. 
    - k9 x- M+ G* ~- H6 w* Y( Q
12. 
    
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    
15. #define LED2_GPIO_PORT  GPIOC
    
16. 
    # l5 N( R) K$ j% q2 k) ]& Y
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);                  
    ( e6 c2 n" L; S; a7 f$ F
21. 
    
22. #endif
    
23. 
    
24. 
    

复制代码

————————————————
版权声明：Aspirant-GQ
$ }: j& }2 [! Y+ W' x: }
! F% ]6 u' S9 P* B. d' d
9 e( \: q5 p, V$ u( t