用定时器生成PWM波

    PWM全称是Pulse Width Modulation，通过控制高频信号的占空比，眼睛当成低通滤波器，可以控制亮暗。再循环更改pwm的阈值，就弄出了呼吸的效果。

    这里采用一个比较简单的方法生成PWM波：设置定时器中断然后根据阈值判断置高和置低。

1. void TIM3_IRQHandler(void)  
   
2. {
   
3.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  
   
4.         if(counter==255)            
   
5.             counter = 0;
   ' U2 r$ z7 J: g  [
6.         else
   ( L: r) `2 U1 j6 D- ]# G3 s& @# I& {9 w2 u
7.             counter +=1;
   
8.         if(mode == 0){
   
9.             if(counter < pwm)              
   ) w0 i6 a6 D+ V  F7 ^! N
10.                 GPIO_SetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);
    
11.             else
    
12.                 GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);   
    
13.         }
    : ~3 A7 e: _: ]: A
14.         if(mode == 1)
    5 J1 b, n: b- x
15.         {
    
16.             if(counter < pwm)              
    
17.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);
    & e* b. Y/ U$ x+ I3 K# M5 ~# g
18.             else
    
19.                 GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     
    
20.         }  
    . L" ]2 B3 A$ [# |- _. w  B% p" Z
21.         if(mode ==2){
    
22.             if(counter < pwm)              
    $ U, e$ d4 H8 @1 b
23.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    
24.             else
    
25.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    
26.         }
    ( x! M: j  W3 M9 |) m
27. }

复制代码

程序流程

• 开启外设时钟（GPIO和TIM）
  
  

1. void RCC_Configuration(void)               
   ( k8 G9 Z6 {; _1 O
2. {
   . s% I5 @7 M6 Q) h7 y( N. `. b- o
3.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);                                                      
   
4.      RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE);
   
5. }

复制代码

& E% M' p  {. x9 n
& D+ E5 N2 B: n. l* d1 A

• 配置GPIO
• 配置时钟, 使能中断（计数阈值，预分频，时钟分频，计数模式）
  
  ! ?, Z: E; T% S- b+ M' h+ N% \0 O

1. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
   : y: e) s7 G$ o  C! m/ P  _
2. {
   
3. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
   / v, W( A, }+ g% i; T  h' P6 F
4. TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
   
5. TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
   + V2 I" S# K7 l' p3 D9 q% |
6. TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // 时钟分频倍数
   
7. TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 计数方式为向上计数
   & ?, q# Q5 x0 g, w/ m& X3 P
8. TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);      //  初始化tim3
   . V2 Q9 F5 @7 t+ M3 X. M) S+ o
9. TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIM3溢出中断标志
   
10. TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
    ) f4 N; q+ c* ?6 H1 f9 y: W
11. TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
    
12. }

复制代码

; i- ]& N) `  h1 K0 U

• 配置中断优先级
  
  & d- g( t0 U& O: P

1. void nvic()                                 //配置中断优先级
   6 Q7 q3 k4 b/ q; R2 A' \" i
2. {   
   ' e2 u2 J/ e+ E4 `" C
3. NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
   
4. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
   
5. NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
   
6. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
   
7. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
   - s* J5 p& C* O' y! v, F
8. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
   
9. NVIC_Init(&NVIC_InitStructure);                        //  初始化
   
10. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
    9 G, \# j5 l( u# D# P0 F& A
11. NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
    2 M  s% _; w# \/ [' p7 ?
12. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
    4 Z$ z8 [2 p) k
13. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
    - }# K0 K# h. ^
14. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
15. NVIC_Init(&NVIC_InitStructure);
    
16. }

复制代码

" Y! Q; A; i5 M; V* o  R+ a2 z
! i# |& Y$ y$ G4 Z$ ^

• 写中断服务函数
  ( R) O2 k. H5 C

1 q5 Q1 j3 f2 P: ?: o

代码实现

    为了方便按键检测，除了TIM3配置PWM波之外，TIM4用来检测是否有输入。由于使用开漏输出，这里使用5V电源。

1. #include "stm32f10x.h"
   
2. #include "math.h"
   
3. #include "stdio.h"
   4 Y1 l+ N( I4 @. T! Q( w/ ]
4. 
   ( X) F8 n; M8 d& i) J8 o; J
5. u8  counter=0;
   
6. int  pwm=100;
   8 Y. ]7 H8 f, c& E4 j, n8 ~6 X
7. int flag=0;
   - }1 e: j4 T7 C+ M$ l
8. int mode =0;
   
9. int velocity =0;
   
10. int turning=1;
    0 P: ?% i1 N" R" w2 s
11. 
    # u; W3 Z6 y9 O7 y" L. z5 u
12. void RCC_Configuration(void);    //时钟初始化，开启外设时钟
    / g( W% _8 @' D9 v0 T% p$ N
13. void GPIO_Configuration(void);   //IO口初始化，配置其功能
    9 E1 f6 A, _8 l0 i
14. void tim3(void);                 //定时器tim4初始化配置
    
15. void tim4(void);                 //定时器tim4初始化配置
    
16. void nvic(void);                 //中断优先级等配置
    3 Y4 t" J8 I) x4 n+ B
17. void exti(void);                 //外部中断配置
    ! P5 S" Q" j5 y9 b1 m
18. void delay_nus(u32);           //72M时钟下，约延时us
    
19. void delay_nms(u32);            //72M时钟下，约延时ms
    : {9 l# ~2 `) `) I' b3 [, F( b
20. void breathing(int velocity){
    1 U4 J! c% t* F2 r; @% P. A
21.         switch(velocity){
    * R6 `" z# v8 j1 Y4 }
22.                 case 0:
    
23.                     if(flag)
    
24.                             pwm +=1;
    9 p! R# [/ F2 S& W/ n
25.                             if(pwm>240) flag=0;
    
26.                     if(flag == 0){
    ; ]* F! R2 T/ y, A4 |4 W7 ^  F8 W
27.                             pwm -=1;
    , A) i6 q9 Y6 N9 Z2 Z6 J4 v7 ?
28.                             if(pwm<10) flag=1;
    , j& g+ _  |" f
29.                     }
    
30.                     break;
    
31.                 case 1:
    
32.                     if(flag)
    " Q. @0 H$ o$ H+ U* d* h
33.                             pwm +=2;
    - Z$ i5 k* ?( |' A! e
34.                             if(pwm>240) flag=0;
    
35.                     if(flag == 0){
    
36.                             pwm -=2;
    
37.                             if(pwm<10) flag=1;
    
38.                     }
    
39.                     break;
    
40.                 case 2:
    
41.                     if(flag)
    ) R& j1 [0 ]) G1 \/ P
42.                             pwm +=3;
    : ?% }0 o' R/ |- X
43.                             if(pwm>240) flag=0;
    
44.                     if(flag == 0){
    # `; h1 i: c0 b+ P# P4 w
45.                             pwm -=3;
    
46.                             if(pwm<10) flag=1;
    
47.                     }
    ; `1 e+ s% j* `, Q. p7 p
48.                     break;
    % \# G. w7 n" a$ X( u2 X' K. Z+ I( y
49.         }
    1 D. |0 A/ [& c2 _/ z. S2 G) e# g
50. }
    
51. 
    
52. 
    % M, q: W2 f' B1 J+ I- w# }
53. void assert_failed(uint8_t* file, uint32_t line)
    
54. {
    
55.     printf("Wrong parameters value: file %s on line %d\r\n", file, line);
    
56.     while(1);
    
57. }
    , ^2 F% B7 M, \% t9 E
58. 
    
59. void TIM4_IRQHandler(void)   //TIM4的溢出更新中断响应函数 ，读取按键输入值，根据输入控制pwm波占空比
    
60. {
    ! \- y# [. L$ k3 @% r( Y
61.         u8 key_in1=0x01,key_in2=0x01;
    ! c' Q% h% k* G) H, q! v
62.         TIM_ClearITPendingBit(TIM4,TIM_IT_Update);//     清空TIM4溢出中断响应函数标志位
    2 \' `. I6 a, H' O% M
63.         key_in1= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_12);  // 读PC12的状态
    
64.         key_in2= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_13);// 读PC13的状态
    
65.         if(key_in1 && key_in2) turning =1;
    
66.         breathing(velocity);
    7 t* t3 O- }6 G* X
67.         if(key_in1==0 && turning){
    
68.                 turning =0;
    
69.         velocity = (velocity + 1) % 3;
    , b/ {, y( Z! E- l/ o5 d3 V
70.     }//调速度
    
71.     if(key_in2==0 && turning){
    
72.                 turning =0;
    
73.         mode = (mode + 1) % 3;
    , c! d8 @+ @7 ?# ]" n
74.     }//调颜色
    
75. }   
    
76. 
    
77. 
    ( m% R2 s7 R" Z
78. void TIM3_IRQHandler(void)      //    //TIM3的溢出更新中断响应函数，产生pwm波
    3 o2 R% H! q: ~& s" j& [
79. {
    ( X8 ~2 D# z( `
80.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //   //  清空TIM3溢出中断响应函数标志位
    6 V" ^3 g! h. T( i& k& T  c
81.         if(counter==255)            //counter 从0到255累加循环计数，每进一次中断，counter加一
    ; T. l  r( A" v* X* {. s$ \
82.             counter = 0;
      D1 J( f( I9 a3 x+ J) ?0 a( f
83.         else
    , S8 i9 P1 ~0 v: \' ]
84.             counter +=1;
    % q; \: N( u$ j% v/ y
85.         if(mode == 0){
    
86.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    
87.                 GPIO_SetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1); //将PC14 PC15置为高电平
    
88.             else
    
89.                         GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);     // 将PC14 PC15置为低电平
    ! L+ l! L+ v  P$ T$ ?. L& |( U6 @# r2 N
90.         }
    
91.         if(mode == 1)
    5 ?" l( l, t1 K9 V7 r; w0 T0 q
92.         {
    6 j/ E$ S, L! R! v6 W& u
93.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    7 K' P: [' E+ [2 [3 F6 w/ e
94.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2); //将PC14 PC15置为高电平
    
95.             else
    
96.                         GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     // 将PC14 PC15置为低电平
    
97.         }  
    
98.         if(mode ==2){
    
99.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    % H4 o# B$ t7 g) x0 i
100.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); //将PC14 PC15置为高电平
     
101.             else
     9 U6 v: ?( n5 A; v+ J' X! I- Z
102.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); // 将PC14 PC15置为低电平
     # c3 Y' E. |& }! R; k( G
103.         }
     # u: E+ [$ `9 P5 }
104. }   
     
105. 
     ( b, c' _' w1 i  V. X! m
106. 
     5 ?# L- t( N9 C" H# w" D
107. int main(void)
     
108. {
     5 o" [- `+ H7 @/ m. U
109.     RCC_Configuration();                                                                    
     & L) ?0 g: l0 R- D0 k' J4 E
110.   GPIO_Configuration();                        
     1 j8 J) i6 y" z3 @4 R! j( ~8 n$ s6 p
111.     tim4();
     ! Q5 y! o9 q7 ]. o2 t, j5 S$ G6 u
112.     tim3();
     
113.   nvic();
     
114.     while(1)
     
115.     {
     
116.     }   
     
117. }   
     
118. 
     , E- a& D) N% d3 e, ~/ F5 [
119. void delay_nus(u32 n)       //72M时钟下，约延时us
     3 o, I+ O  x) w1 {
120. {
     9 z, j4 M* S* u. C. ~# N- y
121.   u8 i;
     % ~1 H6 E7 Y* R4 Q* A
122.   while(n--)
     $ {& z0 {+ l6 s# |1 E8 s9 k
123.   {
     
124.     i=7;
     ( L6 d. i7 X( L& Y8 ?. [  o7 u! e
125.     while(i--);
     
126.   }
     
127. }
     ! r! T0 ?' M; {) c) k" j
128. 
     ! c3 e( V8 C% [1 I- I" Q9 E
129. 
     # K9 b6 G5 H9 ?+ o0 \% i
130. void delay_nms(u32 n)     //72M时钟下，约延时ms
     , c) Y+ @5 }. m& Q
131. {
     6 b% n) P" v) t7 @2 c9 b
132.     while(n--)
     
133.       delay_nus(1000);
     
134. }
     
135. 
     * Z0 ^& `; @; J/ [. G  `0 Z0 c
136. 
     
137. void RCC_Configuration(void)                 //使用任何一个外设时，务必开启其相应的时钟
     
138. {
     
139.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);    //使能APB2控制外设的时钟，包括GPIOC, 功能复用时钟AFIO等，                                                                              
     
140.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE); //使能APB1控制外设的时钟，定时器tim3、4，其他外设详见手册            
     5 I7 }  H8 x- ^- H& L9 h) k
141. }
     
142. 
     
143. 
     ) G% A# f% O4 C4 o3 [. ?8 N, b7 b3 X: c
144. void GPIO_Configuration(void)            //使用某io口输入输出时，请务必对其初始化配置
     
145. {
     . G! P& L" k; f& L4 \
146.     GPIO_InitTypeDef GPIO_InitStructure;   //定义格式为GPIO_InitTypeDef的结构体的名字为GPIO_InitStructure  
     
147.                                           //typedef struct { u16 GPIO_Pin; GPIOSpeed_TypeDef GPIO_Speed; GPIOMode_TypeDef GPIO_Mode; } GPIO_InitTypeDef;
     , J4 T1 f- w+ m7 P
148.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;    //配置IO口的工作模式为上拉输入（该io口内部外接电阻到电源）
     
149.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //配置IO口最高的输出速率为50M
     
150.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13;  //配置被选中的管脚，|表示同时被选中
     
151.     GPIO_Init(GPIOC, &GPIO_InitStructure);                  //初始化GPIOC的相应IO口为上述配置，用于按键检测
     1 t, a8 }/ D& u1 u$ \1 a+ w
152.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;       //配置IO口工作模式为 推挽输出（有较强的输出能力）
     * T2 l3 i9 @$ S9 e# N& H
153.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;      //配置IO口最高的输出速率为50M
     
154.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2;  //配置被选的管脚，|表示同时被选中
     
155.     GPIO_Init(GPIOA, &GPIO_InitStructure);        //初始化GPIOA的相应IO口为上述配置
     / }# Z/ a4 }; ~. X! w+ `8 x
156.     GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //失能STM32 JTAG烧写功能，只能用SWD模式烧写，解放出PA15和PB中部分IO口
     - o4 v9 w" o8 [- q- l
157. }
     
158. 
     
159. 
     
160. void tim4()                           //配置TIM4为基本定时器模式,约10ms触发一次，触发频率约100Hz
     " T" N, G6 J! A3 O
161. {
     ! G7 a% D4 M# }9 U
162.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     
163.     TIM_TimeBaseStructure. TIM_Period =9999;          // 配置计数阈值为9999，超过时，自动清零，并触发中断
     9 M3 Y$ P4 I& b6 u/ l/ `
164.     TIM_TimeBaseStructure.TIM_Prescaler =71;         //  时钟预分频值，除以多少
     
165.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 时钟分频倍数
     , ?1 H: F/ `* n" F+ R9 Q
166.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 计数方式为向上计数
     
167.     TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);      //  初始化tim4
     ' k, J: g; I0 J7 P" D  s8 i" L! w
168.     TIM_ClearITPendingBit(TIM4,TIM_IT_Update); //清除TIM4溢出中断标志
     . Z* X1 u8 u' |9 \$ k- _1 c
169.     TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);   //  使能TIM4的溢出更新中断
     
170.     TIM_Cmd(TIM4,ENABLE);                //        使能TIM4
     5 j' t' ?8 r& A8 X6 Z# X
171. }
     / `/ R/ Y  ]8 U* i$ _; Q
172. 
     5 R! Y1 K0 O( b6 P
173. 
     
174. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
     
175. {
     
176.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     
177.     TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
     3 d8 Z6 U' n% u* r8 k
178.     TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
     
179.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // 时钟分频倍数
     
180.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 计数方式为向上计数
     
181.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);      //  初始化tim3
     
182.     TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIM3溢出中断标志
     7 B" k8 p$ D7 s0 w- F3 l+ g
183.     TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
     ) M# U2 R; L5 }3 z, V
184.     TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
     - n$ C  M. g* x2 c
185. }
     & O. o' `7 B9 `4 }
186. 
     
187. 
     ! H# c1 @% A. z# U& W  @  [
188. void nvic()                                 //配置中断优先级
     % h6 f$ l/ R$ U) P
189. {   
     8 l/ T- @/ T* w1 u+ G
190.      NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
     2 C" A' P" v  F: z6 \3 M; H
191.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
     2 e( u6 C8 E+ ]! w8 g- a
192.      NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
     
193.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
     
194.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
     ' L* a- ~! D' s
195.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
     
196.      NVIC_Init(&NVIC_InitStructure);                        //  初始化
     % a* `* U* h3 T; u: O/ Z/ i" r
197.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
     . z7 P0 O0 ]+ Y- Z+ k
198.      NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
     1 {" K8 e" Z; Z$ _
199.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
     
200.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
     1 X7 |3 h# q3 h
201.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
202.      NVIC_Init(&NVIC_InitStructure);
     " f: {9 H4 O# Q. {4 o
203. }

复制代码

* A: p0 O+ Z  ^转载自：单片机与嵌入式
8 F/ L1 t% c7 t* ]如有侵权请联系删除

! F& |0 l  K+ |$ t6 U
# A/ |. u; [; v* ]  T1 K, ]5 {# T
3 y( U, W. t4 M% T3 j3 x
# ?* r) q. V+ \