在STM32中执行中断主要分三部分：
: a; R7 ?* `/ L9 b  s; h1.配置NVIC_Config()函数
8 R5 U4 l, y- K. n8 s  w2.配置EXTI_Config()函数
5 F1 B- \3 L9 L3.编写中断服务函数
* y. {9 R" B9 S9 x. O. j（注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭）
9 t& y( T4 e% k1 V( |# d
" p5 y1 v; |* R# M6 Q1 A+ g配置NVIC_Config()函数
NVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。
' f7 l$ o% y) n  e. X9 DNVIC_Config()函数代码如下：

1. static void NVIC_Config(void) /* 主要是配置中断源的优先级与打开使能中断通道 */
   5 g  Z: w: ]& o; o. {7 n9 L
2. {
   
3.         NVIC_InitTypeDef NVIC_InitStruct ;
   
4.         
   
5.         /* 配置中断优先级分组(设置抢占优先级和子优先级的分配)，在函数在misc.c */
   
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1) ;
   
7.         
   
8.         /* 配置初始化结构体 在misc.h中 */
   
9.         /* 配置中断源 在stm32f10x.h中 */
   6 F; M7 N, _' U+ h
10.         NVIC_InitStruct.NVIC_IRQChannel = KEY1_EXTI_IRQN ;
    ' f2 J+ r- S6 P- C5 ]# J, A
11.         /* 配置抢占优先级 */
    
12.         NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1 ;
    
13.         /* 配置子优先级 */
    
14.         NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0 ;
    ( ?  i4 D3 m# j" @1 [* J- j; U! z* h
15.         /* 使能中断通道 */
    
16.         NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE ;
    3 M+ p+ F" X9 `; G5 E1 N+ M2 }  m
17.         /* 调用初始化函数 */
    7 k4 `+ y9 {+ e5 I; q
18.         NVIC_Init(&NVIC_InitStruct) ;
    
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 ;
    
25.         NVIC_Init(&NVIC_InitStruct) ;
    
26.         
    8 {% R1 F6 b* v. }1 b! K
27. }
    

复制代码

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

接下来简单讲解一下NVIC_Config()函数的内容：
1.首先设置中断优先级分组
中断优先级分组其实是确立一个大纲，中断优先级寄存器 NVIC_IPRx中有4个位用来确定优先级，中断优先级的分组就是把这4个位分配在抢占优先级和子优先级中。比如设定一个位配置抢占优先级，其余三个位配置子优先级。通过函数NVIC_PriorityGroupConfig() ; 实现分组，详细代码如下：

1. 1 /**
   2 P* V. m( X* o- ?3 C: [% X0 M
2. 2 * 配置中断优先级分组：抢占优先级和子优先级
     d' r& j5 n; E- ^
3. 3 * 形参如下：
   6 H% p8 C5 M# y  j) K8 [2 B* b
4. 4 * @arg NVIC_PriorityGroup_0: 0bit for 抢占优先级
   
5. 5 *                                      4 bits for 子优先级
   
6. 6 * @arg NVIC_PriorityGroup_1: 1 bit for 抢占优先级
   3 W. B0 m* ?# q% l$ ^; p$ e# m
7. 7 *                            3 bits for 子优先级
   - [- a2 x, K6 z+ J( n& K( D) i
8. 8 * @arg NVIC_PriorityGroup_2: 2 bit for
   : ^* u4 j; t8 M7 v" N% `
9. 9 *                            2 bits for 子优先级
   
10. 10 * @arg NVIC_PriorityGroup_3: 3 bit for 抢占优先级
    
11. 11 *                           1 bits for 子优先级
    
12. 12 * @arg NVIC_PriorityGroup_4: 4 bit for 抢占优先级
    + w; @& [0 [6 a
13. 13 *                           0 bits for 子优先级
    ; J6 q$ D6 P( m! U% C+ H
14. 14 * @注意 如果优先级分组为 0，则抢占优先级就不存在，优先级就全部由子优先级控制
    0 J& e& d3 R; m5 ?3 L
15. 15 */
    ! N( t3 A( ]% o/ m0 O  v
16. 16 void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
    . q& n8 q" }$ Z9 W/ l% ~
17. 17 {
    4 e1 r+ j2 U* O2 w: k1 N6 R
18. 18 // 设置优先级分组
    
19. 19 SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
    1 N$ _2 i/ s( u. t. u% a5 m3 [- ~
20. 20 }
    ; a- d' T  k! v2 g! u, f" v

复制代码

( s) k8 t9 C% h0 W2.优先级分组完毕后，是配置NVIC初始化结构体
2 {* F% d1 G; _

1. typedef struct {
   5 y3 p. ?! a; y
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;
   

复制代码

初始化结构体的作用是，收集中断源的信息（包括配置的是哪一个中断源、中断源的抢占优先级是多少、中断源的子优先级是多少、中断源的使能是否开启）。
* m, B6 s0 C% q% \, w- H9 hNVIC_IROChannel：用来设置中断源，不同的中断中断源不一样，且不可写错，即使写错了程序也不会报错，只会导致不响应中断。 stm32f10x.h 头文件里面的 IRQn_Type 结构体定义，这个结构体包含了所有的中断源。
NVIC_IRQChannelPreemptionPriority和NVIC_IRQChannelSubPriority 分别设置抢占优先级和子优先级，具体的值要根据中断优先级分组来确定。
; D3 K* U0 L8 L# Y; n# RNVIC_IRQChannelCmd：设置中断使能（ENABLE）或者失能（DISABLE），相当于一个电源总开关。
3.最后借助NVIC初始化函数将NVIC初始化结构体中的信息写入相应的寄存器中 （体现了固件库编程的优点，不需要我们深入到寄存器层次去，只需要掌握相应函数的配置即可）
& i, ?  ?( ~6 e0 r+ ^$ i# z

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

' Z9 {7 a6 F3 A5 X2 k0 @
) [( r% V1 x# J8 H- y8 e) n0 R9 vEXTI 可分为两大部分功能，一个是产生中断，另一个是产生事件，线路1-2-4-5是产生中断的流程，20/代表着有20条相同的线路。

& j. I+ ^3 q% _1 B, W
接下来讲解一下EXTI_Config()函数代码：
" C% |; @, l& C8 w$ v& n

1. void EXTI_Config() /* 主要是连接EXTI与GPIO */
   
2. {
   
3.         GPIO_InitTypeDef GPIO_InitStruct ;
   ; H4 p; \  Y3 w
4.         EXTI_InitTypeDef EXTI_InitStruct ;
   
5.         
   
6.         NVIC_Config();
   ) n' [% [7 b/ w* |7 O# B
7. 
   
8.         /* 初始化要与EXTI连接的GPIO */
   4 U- d' ]% a9 e4 n- A
9.         /* 开启GPIOA与GPIOC的时钟 */
   4 {9 R* I, [: l9 t  i; S- |
10.         RCC_APB2PeriphClockCmd(KEY1_EXTI_GPIO_CLK | KEY2_EXTI_GPIO_CLK, ENABLE) ;
    * [& l/ l; B( |( V$ ~
11.         
    + y$ I7 l4 e( M) z
12.         GPIO_InitStruct.GPIO_Pin = KEY1_EXTI_GPIO_PIN ;
    
13.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    . G6 j5 o! r) G- B4 S2 N
14.         GPIO_Init(KEY1_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    0 e% P" ~5 b, v0 [8 F
15.         
    , q% n* _7 S6 A7 i  E8 T- c# y
16.         GPIO_InitStruct.GPIO_Pin = KEY2_EXTI_GPIO_PIN ;
    ; U: U* x% K; d  z+ B
17.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ;
    8 w0 \5 _1 {  `/ ?% A0 \! H' U
18.         GPIO_Init(KEY2_EXTI_GPIO_PORT , &GPIO_InitStruct) ;
    
19.         
    ( o* J+ x7 R  W! z  N- E+ [
20.         /* 初始化EXTI外设 */
    
21.         /* EXTI的时钟要设置AFIO寄存器 */
    - ^# I8 @* ?/ k2 O, \
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE) ;
    
23.         /* 选择作为EXTI线的GPIO引脚 */
    
24.         GPIO_EXTILineConfig( KEY1_GPIO_PORTSOURCE , KEY1_GPIO_PINSOURCE) ;
    ; a+ I, {6 O, Z7 s. K/ a" A8 n
25.         /* 配置中断or事件线 */
    
26.         EXTI_InitStruct.EXTI_Line = KEY1_EXTI_LINE ;
    & o. z# Q; U) W3 _, o% m9 }
27.         /* 使能EXTI线 */
    , s6 _) ]- q5 W3 z' H1 e. V
28.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    ) s% M% }9 N  z+ m2 p1 O4 V( v
29.         /* 配置模式：中断or事件 */
    
30.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    3 s9 N- T5 S3 y
31.         /* 配置边沿触发 上升or下降 */
    ' @7 \0 x8 h, A  Q7 G9 ]
32.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising ;
    
33.         EXTI_Init(&EXTI_InitStruct) ;
    % f" h) p* x) c; |
34.         
    
35.         GPIO_EXTILineConfig( KEY2_GPIO_PORTSOURCE , KEY2_GPIO_PINSOURCE) ;
    / p9 H4 K4 f! X' b3 }
36.         EXTI_InitStruct.EXTI_Line = KEY2_EXTI_LINE ;
    
37.         EXTI_InitStruct.EXTI_LineCmd = ENABLE ;
    
38.         EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt ;
    0 y8 X. f. m2 h+ R* B$ R  s. e4 C
39.         EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling ;
    $ I" j  v. p+ w6 j
40.         EXTI_Init(&EXTI_InitStruct);
    $ W1 B1 @" J4 i5 O! r4 A$ Q; Y
41. }
    
42. 
    

复制代码

! w6 ~+ V/ r+ J: L8 B代码可大体分为三部分：
配置GPIO相应引脚、配置EXTI并连接GPIO引脚、传入NVIC_Config()
1.配置GPIO相应引脚
该代码是通过按键产生一个电平信号，然后经EXTI处理传入NVIC产生中断的，所以要配置连接按键的GPIO引脚，主要是设置相应的引脚模式为浮空输入 。老规矩，先开启相应GPIO的时钟，然后配置引脚初始化结构体，再利用初始化函数将初始化结构体写入寄存器中。
2.配置EXTI并连接GPIO引脚
  d( I4 A' ]4 N" c( V1 ~要操作外设，首先要打开相关的时钟，EXTI挂载在APB2总线上，并且开启时钟时要操作AFIO寄存器 ，准备工作就绪后连接GPIO相应的引脚到EXTI中，前面说了EXTI有20个接口，所以特定的引脚有特定的接口，所以要根据GPIO_EXTILineConfig()；函数选择用作EXTI线的GPIO引脚，函数说明如下
% _- v) Y# O" E3 k3 w! V9 X

1. /**
   % n7 x  a. [- e- _5 [# c& ]/ I
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).
   % A) b  O1 D! k# t  J
5.   * @param  GPIO_PinSource: specifies the EXTI line to be configured.
   
6.   *   This parameter can be GPIO_PinSourcex where x can be (0..15).
   - Z/ e1 \9 \: o
7.   * @retval None
   
8.   */
   
9. void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource)
   
10. {
    ! F3 S" K* c$ D* j- W
11.   uint32_t tmp = 0x00;
      O7 {* U) X/ b* n. b8 V
12.   /* Check the parameters */
    0 z2 H/ c$ O7 Z" A
13.   assert_param(IS_GPIO_EXTI_PORT_SOURCE(GPIO_PortSource));
    " j: ^  z0 ?3 {
14.   assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource));
    9 y! E) Z' t, Y* `) v
15.   
    
16.   tmp = ((uint32_t)0x0F) << (0x04 * (GPIO_PinSource & (uint8_t)0x03));
    # b5 S# g) H7 y; G  c
17.   AFIO->EXTICR[GPIO_PinSource >> 0x02] &= ~tmp;
    * t) \) U" g2 ^
18.   AFIO->EXTICR[GPIO_PinSource >> 0x02] |= (((uint32_t)GPIO_PortSource) << (0x04 * (GPIO_PinSource & (uint8_t)0x03)));
    
19. }
    ) L- d: `  Y  r/ p! }+ N  q

复制代码

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

1. typedef struct
   5 E: O; Z! F6 y. t
2. {
   
3.          uint32_t EXTI_Line; // 中断/事件线
   , I1 t% b5 m. w; b; \
4.          EXTIMode_TypeDef EXTI_Mode; // EXTI 模式
   $ ], a& I4 `8 t# K
5.          EXTITrigger_TypeDef EXTI_Trigger; // 触发类型
     j+ s0 s! y$ E2 y: Z5 A9 W
6.          FunctionalState EXTI_LineCmd; // EXTI 使能
   
7. } EXTI_InitTypeDef;
   0 e& W5 h- l5 R- P$ k

复制代码

; o* p+ p9 ^. ~9 q1 {配置此结构体主要是：选择相应的EXTI线 、选择触发模式、选择产生的结果（中断还是事件）、是否使能EXTI线。
$ A" @# ]& n- _& REXTI_Line：中断线选择，可选 EXTI_0 至 EXTI_19（一共20个）。既然刚才配置好了与GPIO引脚对应的EXTI线，所以初始化结构体中的EXTI线就是与GPIO连接的那个线。
EXTI_Mode： EXTI 模式选择，可选为产生中断或者产生事件。就是决定信号的发展方向，是产生中断呢？还是产生事件呢？此处是中断。
EXTI_Trigger： EXTI 边沿触发模式，可选上升沿触发、下降 沿 触 发 或 者 上 升 沿 和 下 降 沿 都 触 发。触发信号。
EXTI_LineCmd：控制是否使能 EXTI 线，可选使能 EXTI 线或禁用。
. x( p6 n, W/ r8 m* Y初始化结构体配置完毕后交由初始化函数写入相应的寄存器中。
: `: h" w- j0 O* X+ W+ x5 w& o3.传入NVIC_Config()
之后就自动传入NVIC中了。。。
' b1 e# H$ ]  l1 i% Z( T: W. x7 O
编写中断服务函数
0 k' o8 v# N/ V0 B2 n3 _2 ]( b& l到这里就万事俱备只欠东风了，中断的触发与处理及优先级定义都已经安排上了，最后一步就是编写中断函数的内容了，只要进入中断就会执行中断函数中的代码，所以这是收尾工作。STM32的中断服务函数不同于51单片机中的中断服务函数，STM32的所有中断函数都被偷偷安排了，每个中断都有其固定的名字，只有找到这个名字，在这个固定的函数名下编写中断服务函数才是有效的，所有中断函数的编写都要在stm32f10x_it.c 中，如示：
7 @* x4 K4 h0 X6 t9 J% N& \
( }) W& w3 ^8 f  w
2 X0 ]# d7 ~8 E0 ]
3 W! W' g; c$ _) n! w, Y3 w从所给的信息可得知外设的中断服务函数的名字都存放在startup_stm32f10x_xx.s 中，而且是由汇编语言编写，如示：

, I( E! M8 D9 r  I% g5 q+ V
' y1 H4 W, a- M4 M: c- g

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

" s% s* T7 }' i* C我们要做的就是以相应的EXTI线的中断函数名字在stm32f10x_it.c中编写中断函数 如下：
% I& [8 ^; d) W* v- V' I

1. void EXTI0_IRQHandler(void)
   ! M) q) l- i+ ^& J5 T
2. {
   
3.         if(  EXTI_GetITStatus(KEY1_EXTI_LINE)!=RESET)
   
4.         {
   6 W  A; D$ K% e. n6 L% P  R2 I
5.                 LED1_TOGGLE;   //LED1的亮灭状态反转
   - v, G. ?9 s$ {! {& a7 T, e5 N
6.         }
   
7.                
   
8.         EXTI_ClearITPendingBit(KEY1_EXTI_LINE);
   7 U' U  z* O& ]+ i
9.                
   8 c# s* j: [2 d' a, r
10. }
    * W; L5 |* N3 }
11. 
    
12. 
    6 f. m- L* _* j  j, k/ I' {' H
13. void EXTI15_10_IRQHandler(void)
    
14. {
    2 v- |9 x- V. M# b* k) ?8 h
15.         if(  EXTI_GetITStatus(KEY2_EXTI_LINE)!=RESET)
    
16.         {
    ; v1 x) S: r. ^* W
17.                 LED2_TOGGLE;   //LED2的亮灭状态反转
    
18.         }
    3 E9 Z' {% b' \: o( P7 n
19.                
    # w% Q# m& `" j- f
20.         EXTI_ClearITPendingBit(KEY2_EXTI_LINE);
    
21.                
    8 k, s# {  m" f- X4 Y9 C
22. }
    6 a! A$ X" Q4 S
23. 
    5 x; H; g/ P+ Q, c% U

复制代码

每次进入中断函数后，靠ITStatus EXTI_GetITStatus(uint32_t EXTI_Line)读取中断是否执行 ，执行完之后要利用void EXTI_ClearITPendingBit(uint32_t EXTI_Line)清除清除中断标志位，以免不断进入中断
/ K% ]& c1 ]/ ?0 h- B8 F) @

2 O; x0 j4 [  v! V0 n3 L/ t% ~- E大功告成
到此完整的中断系统就已经完成，主函数只需调用即可！！！

1. #include "stm32f10x.h"
   9 t# G9 y/ R: S
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
   / q5 U* Q, n9 o
4. 
   
5. int main(void)
   
6. {
   
7.         LED_GPIO_Config();
   7 v: L' u2 D( z8 P4 K
8.         EXTI_Config();
   
9.         
   
10.         while(1)
    
11.         {
    : U7 x% o3 E6 r9 G& u
12.         }
    
13. }
    ' T" r: C0 K3 I! g- Y
14. 
    , }* b9 J; ~' K" }! p2 x
15. 
    

复制代码

1. #ifndef __BSP_KEY_H
   * [  p: I  T% j
2. #define __BSP_KEY_H
   ; M; f% n4 @! L# B6 g
3. 
   
4. #include "stm32f10x.h"
   
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
   - @) U: o2 B/ B$ z9 c
9. #define KEY1_EXTI_IRQN          EXTI0_IRQn      /* 对应着引脚号 */
   + l: G; i) `% K
10. #define KEY1_EXTI_LINE          EXTI_Line0      /* 中断、事件线对应引脚号 */
    
11. #define KEY1_GPIO_PORTSOURCE    GPIO_PortSourceGPIOA
    7 l! p- Y9 z' [& _
12. #define KEY1_GPIO_PINSOURCE     GPIO_PinSource0
    
13. #define  KEY1_EXTI_IRQHANDLER       EXTI0_IRQHandler
    ' D1 [* {, a- H8 s9 H6 x
14. 
    
15. #define KEY2_EXTI_GPIO_CLK      RCC_APB2Periph_GPIOC
    . M& B. \  i) p
16. #define KEY2_EXTI_GPIO_PORT     GPIOC
    - Z* U3 U( w) z. H/ B, H: J- i
17. #define KEY2_EXTI_GPIO_PIN      GPIO_Pin_13
    
18. #define KEY2_EXTI_IRQN          EXTI15_10_IRQn
    ' l1 C: u/ @3 L0 L0 G2 ~
19. #define KEY2_EXTI_LINE          EXTI_Line13
    
20. #define KEY2_GPIO_PORTSOURCE    GPIO_PortSourceGPIOC
    
21. #define KEY2_GPIO_PINSOURCE     GPIO_PinSource13
    
22. #define  KEY2_EXTI_IRQHANDLER       EXTI15_10_IRQHandler
    
23. 
    
24. 
    $ }% S- Q5 k. X0 \9 X. X; D
25. void EXTI_Config(void);
    
26.         
    
27. #endif
    1 l( |' L# e0 X: x% M# p% c
28. 
    , x# N% L7 F" l7 t  [8 n5 ^$ c

复制代码

1. #ifndef __BSP_LED_H
   8 Q- B% k9 ]0 `* h% O9 F+ e: C
2. #define __BSP_LED_H
   
3. 
   : U" m$ O! ^' B" W" t7 R3 v" k& |- p* \
4. #include "stm32f10x.h"
   
5. 
   9 q! C! a) ?. k) B6 H6 Q. ]) V
6. 
   # ~9 e/ |, W2 F/ c* }
7. 
   9 T' Z7 E  M3 h2 ]9 k; `
8. #define LED1_GPIO_CLK   RCC_APB2Periph_GPIOC   /*时钟*/
   : p$ t' Z/ M( H& o$ i
9. #define LED1_GPIO_PORT  GPIOC                  /*端口*/
   7 x0 ]! ^1 ?* [4 `. y% A* s: b
10. #define LED1_GPIO_PIN   GPIO_Pin_2             /*引脚*/
    
11. 
    # Y( Z# M8 [1 l% a8 z$ H
12. 
    
13. #define LED2_GPIO_PIN   GPIO_Pin_3
    8 f5 L. b) {1 A7 `1 }% @
14. #define LED2_GPIO_CLK   RCC_APB2Periph_GPIOC
    
15. #define LED2_GPIO_PORT  GPIOC
    
16. 
    
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状态反转 */
    " j" d8 r0 h& L. y' g! R
20. void LED_GPIO_Config(void);                  
    5 \1 _% ^& K( K0 F, D
21. 
    * E+ F6 ~8 ~: E
22. #endif
    " h" C; k! m* r+ p
23. 
    2 q6 p' v1 `3 N6 ]
24. 
    

复制代码

————————————————
版权声明：Aspirant-GQ
$ G$ M( z! T5 k如有侵权请联系删除

5 ]( W! |2 V+ P( q: z) I