在STM32中执行中断主要分三部分：
, y1 k+ Q- E6 D$ Z1.配置NVIC_Config()函数
2.配置EXTI_Config()函数
4 m9 u3 C) i# Z1 S/ [% Q) B5 m9 ~7 |- z3.编写中断服务函数
9 m; i" r# D3 h  q（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）

2 m% H3 h# Y. p* D! \! i/ n配置NVIC_Config()函数
NVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
NVIC_Config()函数代码如下：
( Q5 C. {/ j) J7 l' R

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   
2. {
   & E) p6 y* E: s7 }, _
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   ' z& u" H6 e9 L& L; o
4.         
   
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   * A, ]$ a3 b5 Y$ g
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   
7.         
   ' w" [6 r' _6 e% n1 s7 L$ a
8.         /* 配置初始化结构体 在misc.h中 */
   1 C* q0 ]& W, ^  j# a  r& ~* }1 k
9.         /* 配置中断源 在stm32f10x.h中 */
   9 U# G' [6 D& h) \& |( e
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    / l/ m4 I, i2 H; f( ]* j9 K& K
11.         /* 配置抢占优先级 */
    
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    1 S/ |4 P+ l; r/ g7 z& p3 R; j
13.         /* 配置子优先级 */
    
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    
15.         /* 使能中断通道 */
    " v4 h  u& e( o) i: v! g
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    , ~& Y2 q6 U8 G4 u
17.         /* 调用初始化函数 */
    
18.         NVIC_Init(&NVIC_InitStruct) ;
    $ B0 e+ }  U, v% ?
19.         
    
20.         /* 对key2执行相同操作 */
    
21.         NVIC_InitStruct.NVIC_IRQChannel = KEY2_EXTI_IRQN ;
    
22.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
23.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1 ;
    
24.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    - s' `5 {$ [4 X) e$ b6 v- Z
25.         NVIC_Init(&NVIC_InitStruct) ;
    
26.         
    , e+ k- S) w# y
27. }
    4 b! o' i; w" {. |9 h# J

复制代码

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

: {$ d2 p8 Y8 `. [! r* A, V) W接下来简单讲解一下NVIC_Config()函数的内容：
& U$ G* [) l, ^' L$ O1.首先设置中断优先级分组
* C% B$ {/ c8 J/ H  @中断优先级分组其实是确立一个大纲，中断优先级寄存器 NVIC_IPRx中有4个位用来确定优先级，中断优先级的分组就是把这4个位分配在抢占优先级和子优先级中。比如设定一个位配置抢占优先级，其余三个位配置子优先级。通过函数NVIC_PriorityGroupConfig() ; 实现分组，详细代码如下：

1. 1 /**
   
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
   
3. 3 * 形参如下：
   ; F( h1 b* l7 Z2 l7 R2 Z
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   
5. 5 *                                      4 bits for 子优先级
   
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   0 l1 e0 e$ M; L( L; X& t$ a: b5 M
7. 7 *                            3 bits for 子优先级
   
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   
9. 9 *                            2 bits for 子优先级
   - Z, F! m1 k/ j" q% u6 g& o
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    
11. 11 *                           1 bits for 子优先级
    
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    " l* L& \8 |- G
13. 13 *                           0 bits for 子优先级
    ; R' D# M) ~! p' Z8 h( d
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    4 f6 j- c7 U2 h9 U4 D; S7 Z* m0 s
15. 15 */
    . N- G. H7 [9 S$ a: X
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    
17. 17 {
    
18. 18 // 设置优先级分组
      A- b  g2 y" p% Q
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    " {( m  M* L- M1 f) G* P: y, f
20. 20 }
    

复制代码

2.优先级分组完毕后，是配置NVIC初始化结构体
+ o2 @) c7 t6 f9 k

1. typedef struct {
   $ J5 P8 z7 L5 p0 w: Z5 [' T
2. 2 uint8_t NVIC_IRQChannel; // 中断源
   
3. 3 uint8_t NVIC_IRQChannelPreemptionPriority; // 抢占优先级
   / m( g6 [$ ^' a
4. 4 uint8_t NVIC_IRQChannelSubPriority; // 子优先级
   
5. 5 FunctionalState NVIC_IRQChannelCmd; // 中断使能或者失能
   
6. 6 } NVIC_InitTypeDef;
   * @+ [( p! N2 W0 @  A! w

复制代码

( Q' y3 x* g$ c: e9 G& Q# y初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
NVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
4 f2 W' |, o9 GNVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
NVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）
) g( l- Y0 X: U9 x0 ?  a. k
+ s, k/ b; l+ c$ M2 x! t/ d* J# f
6 `* k+ X, M# e) V: z2 A配置EXTI_Config()函数
; r' Q9 }2 V" P5 W; w+ ZEXTI（External interrupt/event controller）：外部中断/事件控制器，管理了控制器的 20个中断/事件线。每个中断/事件线都对应有一个边沿检测器，可以实现输入信号的上升沿检测和下降沿的检测。 EXTI 可以实现对每个中断/事件线进行单独配置，可以单独配置为中断或者事件，以及触发事件的属性。
" p/ I- y" W/ V按我的理解，EXTI是一个有着多达20个接口的控制器，它可以为每一个接入接口的信号源配置中断（或事件）线、设置信号的检测方式、设置触发事件的性质，也就是说，传入EXTI的仅仅是一个信号，EXTI的功能就是根据信号传入的“线”对信号做出相应的处理，然后将处理后的信号转向NVIC。 就像一个分拣机器，传入的东**过筛选处理被送往不同的地方，只是EXTI分拣的是信号罢了。 如果说NVIC是配置中断源，那么EXTI就是向NVIC传送中断信号。
: I- v6 B) u7 ]$ K$ h6 r# z
EXTI功能框图：

( ?0 t6 A6 U, P
% ^  l8 x8 q; b9 ~

/ {0 L0 N* K3 hEXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。
& o5 T# k  [0 n# r9 p+ f

接下来讲解一下EXTI_Config()函数代码：
2 y- C! W- R9 S* _

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   ) j' B2 a, R: S
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   
5.         
   
6.         NVIC_Config();
   
7. 
   ( Z0 Q/ r+ ?8 O
8.         /* 初始化要与EXTI连接的GPIO */
   ' q- n1 F9 ]! G4 }# g" Z
9.         /* 开启GPIOA与GPIOC的时钟 */
   1 |$ d$ T+ D3 M; i
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    , P7 o$ Q' A3 r1 p8 T5 |
11.         
    . H7 d3 z- J- S" ^5 H
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) ;
    
15.         
    
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    - B% U1 z- h/ M8 Z: |+ F; w% i& F
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    " T  @- L( w/ x, b; J1 g
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    9 O8 Y0 i7 ]9 s% a& I
19.         
    
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    & G) O3 H  @0 W6 l  w! A" a
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    
23.         /* 选择作为EXTI线的GPIO引脚 */
    ) l$ t% n6 q  k
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    
25.         /* 配置中断or事件线 */
    0 e8 c; @: f/ m) g
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    
27.         /* 使能EXTI线 */
    , s; X7 I5 t$ ^
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    ! \6 X4 z6 L; @/ H" `, W" @. t
29.         /* 配置模式：中断or事件 */
    
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    
31.         /* 配置边沿触发 上升or下降 */
    
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    ( D! P+ V. v% m1 w, i
33.         EXTI_Init(&EXTI_InitStruct) ;
    
34.         
    
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    & k9 D. j4 ?: ?" n
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    
40.         EXTI_Init(&EXTI_InitStruct);
    8 j8 y9 \. ?" r' c; A1 W1 g
41. }
    7 B! B- Q" z* y  ~1 A
42. 
    

复制代码

代码可大体分为三部分：
配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
, u" R6 z5 C* f  O/ R* I8 R) H1.配置GPIO相应引脚
, C8 c1 y6 g4 E3 `该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
# z' c$ ?  J1 i2.配置EXTI并连接GPIO引脚
1 ?4 |: ~( p/ x要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下

1. /**
   ; n0 r1 C; U) Q7 m+ i7 J
2.   * @brief  Selects the GPIO pin used as EXTI Line.
   ! O" N8 I7 q- T) O, F7 {0 G
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).
   ) L. H- j$ I# @' R- p8 c
7.   * @retval None
   
8.   */
     @) b# F4 d3 r0 e4 `! t* L
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   
10. {
    * Y6 z' {8 K+ U2 e% z
11.   uint32_t tmp = 0x00;
    
12.   /* Check the parameters */
    
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    4 ~# ~  v/ s2 X
15.   
    & m% I8 D  y* y/ Z/ y
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    ! i7 G' z# L5 \" H0 e6 a
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    ! J8 T3 u2 }( I/ T  S4 q. X. V2 U: R
19. }
    

复制代码

9 l( o& R5 s2 D% y( A8 H; L1 Z5 n其实对应的EXTI线就对应GPIO引脚号，这样看起来还比较直观。
连接好GPIO引脚与EXTI后就该配置EXTI的初始化结构体了，结构体如下：
' t% q( V4 I2 R. Z/ R0 {

1. typedef struct
   : P; g9 W0 v$ A" I$ }3 e
2. {
   ( z3 Y* q& v5 q  a1 t
3.          uint32_t EXTI_Line; // 中断/事件线
   3 m6 p3 i4 F1 ^  y* h
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   - j; w- G. Q8 U+ j" H/ D
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
   
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   
7. } EXTI_InitTypeDef;
   3 q) |) |- U2 L3 |

复制代码

配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
EXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
EXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
  D6 \6 p3 J" ~EXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
/ s) @$ X6 c1 PEXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
3.传入NVIC_Config()
8 a- S* v) S2 T6 {- L之后就自动传入NVIC中了。。。

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

% r+ U1 X+ W) F  i, N
2 I% I# L  O: J$ w; Z" c
从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：


& p/ m* K7 ]) G6 ?! W: Y& N

可知EXTI线0到EXTI线4线都是单独的中断函数名、EXTI线5到EXTI线9共用一个中断函数名、EXTI线10线到EXTI线15线共用一个中断函数名。
4 n$ @0 s: n" m
/ a8 @- C+ N4 ~( y, I: Y' e我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：
' Z9 O" `- N/ Y6 V# {

1. void EXTI0_IRQHandler(void)
   
2. {
   
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
     q* U: k( k" Q4 G8 m3 B) w
4.         {
   
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   5 s& r! g$ |9 g5 d0 {
6.         }
   * T, H5 y3 ?% k4 f3 Y
7.                
   
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   
9.                
   - Z6 s6 \6 u6 K
10. }
    
11. 
    
12. 
    $ a- _5 ]/ t* [% f
13. void EXTI15_10_IRQHandler(void)
    
14. {
    6 z8 F% u" v* ?
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    
16.         {
    4 h# y% A) A1 O! d$ {5 h; R
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    , F) B! ?7 q4 A( \# f5 H
18.         }
    
19.                
    
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    1 Z0 q, K* c2 |2 C  m  O
21.                
    
22. }
    
23. 
    . U' x3 j0 q  W3 u: }( I8 o

复制代码

0 e8 o& Q$ z/ A! y- [每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断


大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！

1. #include "stm32f10x.h"
   - s  i1 w  \0 w: c: A  x9 C0 U! M7 C
2. #include "bsp_led.h"
   7 D& `+ F2 L1 z1 ~+ z' E6 y) e
3. #include "bsp_key.h"
   " o! F2 }( Y" d8 b# O
4. 
   7 m7 d9 E) Y9 r
5. int main(void)
   8 ~$ Y4 S  ~* E5 G2 ]- y
6. {
   
7.         LED_GPIO_Config();
   
8.         EXTI_Config();
   $ ~4 J9 ?  K: P, o' B1 I( g1 q7 T
9.         
   
10.         while(1)
    ; y$ p, L8 F% A9 A+ X
11.         {
    / l$ x6 I+ x( p
12.         }
    2 Y9 C4 ?  Q9 \* e
13. }
    ) A' v( \5 _  z4 D' Z
14. 
      z$ |, K  A+ S
15. 
    ( d; I  b  m7 ~3 ~$ o4 P! a( g

复制代码

1. #ifndef __BSP_KEY_H
   - D1 N5 n! v, w0 Q% ]: U% w8 h
2. #define __BSP_KEY_H
   
3. 
   
4. #include "stm32f10x.h"
   * B9 N& [7 v4 \0 o4 [' J& I
5. 
   
6. #define KEY1_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOA
   4 T2 ^/ p* S+ b2 z$ {
7. #define KEY1_EXTI_GPIO_PORT     GPIOA
   
8. #define KEY1_EXTI_GPIO_PIN      GPIO_Pin_0
   
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   ' K4 `" h5 o: c5 B
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    2 \* f$ [" a% w$ O$ V6 |9 x
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    . j# B* h/ n; D
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    
14. 
    
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    5 T/ W, _! Y8 J
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
      X+ a1 f9 A! ^2 w
19. #define KEY2_EXTI_LINE          EXTI_Line13
    
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    3 U7 P" _/ r, a+ K
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    ) A. U6 J1 b  v- ^
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    6 T0 G, R" \: T3 V. z& y0 g$ s
23. 
    
24. 
    
25. void EXTI_Config(void);
    
26.         
    
27. #endif
    $ \/ P9 I5 X7 I' D& K; H) G. H
28. 
    8 k2 j# B3 s. u; G9 t5 H# Z

复制代码

1. #ifndef __BSP_LED_H
   * J# z" U. k  C  C& }
2. #define __BSP_LED_H
   9 a2 T+ [2 O0 @! k5 @
3. 
   
4. #include "stm32f10x.h"
   % O( d' Z% A/ ?# z4 S6 ^: s- A
5. 
   
6. 
   
7. 
   
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   + V( s+ r! _; w" F
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    8 s* {2 T1 j+ n7 s
11. 
    
12. 
    
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    ( d/ `6 f7 c" c, w% i. I5 p7 n) [
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    7 F; v" ?% e9 d6 _, f) o
15. #define LED2_GPIO_PORT  GPIOC
    ) F/ f! `- p- ]$ s# c+ b
16. 
    
17. #define digitalTOGGLE(p,i)     {p->ODR ^=i;}
    ) N1 t1 H5 ?* f. z
18. #define LED1_TOGGLE            digitalTOGGLE(LED1_GPIO_PORT,LED1_GPIO_PIN)
    3 j5 q  b; |  p5 E! R
19. #define LED2_TOGGLE            digitalTOGGLE(LED2_GPIO_PORT,LED2_GPIO_PIN)  /* LED状态反转 */
    
20. void LED_GPIO_Config(void);                  
    % u9 G' z* w$ X6 N1 n
21. 
    ' W, l# N& s5 M6 G
22. #endif
    
23. 
    3 b! W. }- t2 b1 k
24. 
    + E) g+ I+ R* L5 E" \

复制代码

————————————————
版权声明：Aspirant-GQ
, G* C$ ?% ]8 L. n如有侵权请联系删除