用定时器生成PWM波

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

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

1. void TIM3_IRQHandler(void)  
   
2. {
   
3.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  
   
4.         if(counter==255)            
   3 p$ J0 J1 {+ e+ \
5.             counter = 0;
   
6.         else
   
7.             counter +=1;
   ) E! e- |$ q( x  Y
8.         if(mode == 0){
   
9.             if(counter < pwm)              
   
10.                 GPIO_SetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);
    
11.             else
    
12.                 GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);   
    8 f0 E9 o4 F+ J
13.         }
    / O9 W6 I& s4 C! r6 O" i- g
14.         if(mode == 1)
    
15.         {
    , c) K9 `4 Y) L1 A& V% v' l6 A
16.             if(counter < pwm)              
    
17.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);
    
18.             else
    
19.                 GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     
    
20.         }  
    $ T0 G+ a+ ?; S& o  |$ @9 @
21.         if(mode ==2){
    
22.             if(counter < pwm)              
    
23.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    ) g- H4 e) r0 X& Z& q) P2 N0 }
24.             else
    , j2 r- h& J0 S' `* F/ H
25.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    1 u  [4 m1 \5 L' W
26.         }
    1 t$ N1 }; ?9 G! i1 E7 z
27. }

复制代码

程序流程

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

1. void RCC_Configuration(void)               
   
2. {
   
3.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);                                                      
   
4.      RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE);
   
5. }

复制代码

• 配置GPIO
• 配置时钟, 使能中断（计数阈值，预分频，时钟分频，计数模式）
  
    |8 \/ i( w3 r

1. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
   + I; y' ]) f: o  A9 P8 w
2. {
   " Z9 U, k8 J& U$ g/ T/ J
3. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
   * o  x( T6 v5 ?
4. TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
   ! Y$ d/ a% m  n  C% E# |
5. TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
   
6. TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // 时钟分频倍数
   ) ~: B- f: T- j  G
7. TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 计数方式为向上计数
   ; U  {4 d' C! [2 ?' p
8. TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);      //  初始化tim3
   
9. TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIM3溢出中断标志
   ! d+ d4 J4 y& u
10. TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
    6 A' `' n; }1 e9 f3 e
11. TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
    / X: m( c4 D: K1 \. i; X1 h7 x' ?- N1 m9 y
12. }

复制代码

• 配置中断优先级
  
  

1. void nvic()                                 //配置中断优先级
   
2. {   
   
3. NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
   1 [) ]! }* [5 }# y7 _
4. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
   ' L" y# p9 o6 Y
5. NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
   ) I4 {5 w/ A0 e' x4 y
6. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
   / o6 [- }2 b; ?3 ~& @
7. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
   
8. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
   
9. NVIC_Init(&NVIC_InitStructure);                        //  初始化
   
10. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
    # L0 N2 `' r* F6 Y: w0 d
11. NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
    0 W* p& s  e0 m. \/ h  D' ?9 P
12. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
    6 L! F. n- Z1 }7 e; Z- P
13. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
    
14. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
15. NVIC_Init(&NVIC_InitStructure);
    4 L8 v" l. g; m
16. }

复制代码

• 写中断服务函数
  

9 S+ `; r- F; y$ |0 P5 B- L

代码实现

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

1. #include "stm32f10x.h"
   
2. #include "math.h"
   # ]% ~0 n, f7 C$ V/ ~3 }9 K
3. #include "stdio.h"
   
4. 
   5 {) F0 Q. v! S3 V3 q: `) G
5. u8  counter=0;
   9 \+ O$ R" q& N- a! H! k
6. int  pwm=100;
   / k6 v8 U% L, I# D. h, O/ m7 e, Q
7. int flag=0;
   
8. int mode =0;
   
9. int velocity =0;
   
10. int turning=1;
    
11. 
    
12. void RCC_Configuration(void);    //时钟初始化，开启外设时钟
    
13. void GPIO_Configuration(void);   //IO口初始化，配置其功能
    
14. void tim3(void);                 //定时器tim4初始化配置
    1 t. Q3 m( U# `1 H
15. void tim4(void);                 //定时器tim4初始化配置
    , u6 E, |# X5 Y3 [& D7 t
16. void nvic(void);                 //中断优先级等配置
    ' [% t# l+ K0 t, ^3 Y3 R' B' X
17. void exti(void);                 //外部中断配置
    3 o8 ?$ c% M8 h, M4 ?
18. void delay_nus(u32);           //72M时钟下，约延时us
      s  N( k" l: z! L1 P2 K
19. void delay_nms(u32);            //72M时钟下，约延时ms
    
20. void breathing(int velocity){
    
21.         switch(velocity){
    4 w% k; I: B. q# f4 K
22.                 case 0:
    
23.                     if(flag)
    ( D* g+ ?& v4 M. K. Y6 s" A
24.                             pwm +=1;
    
25.                             if(pwm>240) flag=0;
    6 J& d. o, q" M
26.                     if(flag == 0){
    # ?. _+ @- C6 ]/ Z! \' K  Q, x  z" Y
27.                             pwm -=1;
    
28.                             if(pwm<10) flag=1;
    
29.                     }
    + ?/ y1 ]" E* e' {( t
30.                     break;
    5 v8 y( ~5 k% t) |1 O4 _
31.                 case 1:
    
32.                     if(flag)
    
33.                             pwm +=2;
    
34.                             if(pwm>240) flag=0;
    
35.                     if(flag == 0){
    
36.                             pwm -=2;
    - c9 N3 B* {9 T6 q+ y( \
37.                             if(pwm<10) flag=1;
    ; G& _3 @, N8 {7 D9 x
38.                     }
    : M7 L3 g3 C) m8 \$ x+ W
39.                     break;
    6 S! s: b# t" Q, ]+ L2 H% D
40.                 case 2:
    
41.                     if(flag)
    " m  ?* T3 I6 I8 s, x
42.                             pwm +=3;
    ( W! r! R1 W$ q3 _% H) U! t
43.                             if(pwm>240) flag=0;
    1 R; ]' Z" D5 ~: u/ w( B
44.                     if(flag == 0){
    " H" Q1 G, N( ?6 u! e
45.                             pwm -=3;
    
46.                             if(pwm<10) flag=1;
    
47.                     }
    
48.                     break;
    
49.         }
    
50. }
    
51. 
    7 W' E0 y4 W5 i; ^  M
52. 
    + ]% G1 |* I* j- N  {* F% k- x
53. void assert_failed(uint8_t* file, uint32_t line)
    & \8 e2 O* _0 F; o6 V$ T
54. {
    
55.     printf("Wrong parameters value: file %s on line %d\r\n", file, line);
    ( W* f4 h2 P; b7 J3 ?4 }" f
56.     while(1);
    
57. }
    
58. 
    + f/ V8 }& v2 h2 p
59. void TIM4_IRQHandler(void)   //TIM4的溢出更新中断响应函数 ，读取按键输入值，根据输入控制pwm波占空比
    
60. {
    9 H9 o+ }, d1 r# O: B! q7 ?
61.         u8 key_in1=0x01,key_in2=0x01;
    
62.         TIM_ClearITPendingBit(TIM4,TIM_IT_Update);//     清空TIM4溢出中断响应函数标志位
    ) ?- }3 L! E3 B' ~3 j& ^4 V
63.         key_in1= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_12);  // 读PC12的状态
    
64.         key_in2= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_13);// 读PC13的状态
    $ }2 u& c1 K8 l  o. [9 ?
65.         if(key_in1 && key_in2) turning =1;
    
66.         breathing(velocity);
    , V4 k+ c5 B5 `& Q
67.         if(key_in1==0 && turning){
    
68.                 turning =0;
    
69.         velocity = (velocity + 1) % 3;
    
70.     }//调速度
    1 W5 I% a( F( T9 h
71.     if(key_in2==0 && turning){
    8 _& n& ^6 F8 ?3 U9 p( K
72.                 turning =0;
    
73.         mode = (mode + 1) % 3;
    
74.     }//调颜色
    " U4 J, O9 j9 y+ L
75. }   
    % e& ~- o' l8 e& L1 a/ ?3 Y
76. 
    
77. 
    8 }& S9 a) ^. Z: q' B6 w' }( X
78. void TIM3_IRQHandler(void)      //    //TIM3的溢出更新中断响应函数，产生pwm波
    
79. {
    
80.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //   //  清空TIM3溢出中断响应函数标志位
    
81.         if(counter==255)            //counter 从0到255累加循环计数，每进一次中断，counter加一
    3 h4 p. |( }9 u( A" a: Y1 q7 Z/ q
82.             counter = 0;
    $ [4 t$ v8 l* n; ?) P
83.         else
    
84.             counter +=1;
    7 y' b# k( y3 M
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置为高电平
    * Y4 u3 [, T3 L7 Z
88.             else
    
89.                         GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);     // 将PC14 PC15置为低电平
    ) l) F! d  U* k) x: o, M+ X! ~
90.         }
    
91.         if(mode == 1)
    
92.         {
    9 ^' T% w8 e+ d5 b
93.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    : T3 F) b4 t; |6 H
94.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2); //将PC14 PC15置为高电平
    
95.             else
    ' R8 R: ?0 `+ q% b
96.                         GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     // 将PC14 PC15置为低电平
    
97.         }  
    8 r0 K  M. w% ]5 Z
98.         if(mode ==2){
      `; x9 c9 n$ ^4 _1 e3 `4 o# n7 p0 @& A
99.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    
100.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); //将PC14 PC15置为高电平
     6 D* ^* }1 b" T/ Y6 C' L
101.             else
     ( O' ^  v5 P* D
102.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); // 将PC14 PC15置为低电平
     3 [! |% A  M6 Y$ i. O4 w$ g! e
103.         }
     
104. }   
     + `9 S. X0 v7 G* @7 W
105. 
     % L6 j- }0 J2 ?: m) }6 F
106. 
     
107. int main(void)
     
108. {
     . E6 }0 z: r+ P; x, j
109.     RCC_Configuration();                                                                    
     / G8 v$ Y# B1 N+ r' v% c
110.   GPIO_Configuration();                        
     2 X6 x0 |7 k$ }! z' z/ n
111.     tim4();
     & W9 f) J6 \) K& Z3 v% u
112.     tim3();
     
113.   nvic();
     , l, s) E: T- O, K
114.     while(1)
     8 A( l* E' K" \3 _* c9 r$ m% q! t
115.     {
     & c# A, L7 x+ F' c& o4 d8 F1 A; W
116.     }   
     1 u1 k5 W( C# O
117. }   
     . K& k9 ~" H+ R5 A6 _: r
118. 
     
119. void delay_nus(u32 n)       //72M时钟下，约延时us
       k8 b0 t0 N2 G6 G0 \4 f
120. {
     
121.   u8 i;
     $ n. N, {2 s6 O  q2 U
122.   while(n--)
     ' y( q0 [, z; @# v! o! F
123.   {
     
124.     i=7;
     $ A# l: }! i- e0 g
125.     while(i--);
     . |# Q9 ?- Z: {0 T& [, A) G' a0 j
126.   }
     
127. }
     8 ^; i6 M  ~4 ~' ]
128. 
     9 B3 Q  b0 Q/ y+ M! f2 R+ v( z
129. 
     
130. void delay_nms(u32 n)     //72M时钟下，约延时ms
     
131. {
     
132.     while(n--)
     0 s+ q# W5 u& M( x  t1 A& ?
133.       delay_nus(1000);
     / \. B/ M( f6 {$ v& e% D) i' a% r& l
134. }
     
135. 
     . _2 r% J3 \/ i+ T! p2 J; T
136. 
     , k( C6 M. y+ o1 ~3 A7 l
137. void RCC_Configuration(void)                 //使用任何一个外设时，务必开启其相应的时钟
     
138. {
     
139.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);    //使能APB2控制外设的时钟，包括GPIOC, 功能复用时钟AFIO等，                                                                              
     ! F. F- g& B2 S3 p
140.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE); //使能APB1控制外设的时钟，定时器tim3、4，其他外设详见手册            
     3 o5 {0 M; W- k" l
141. }
     
142. 
     
143. 
     
144. void GPIO_Configuration(void)            //使用某io口输入输出时，请务必对其初始化配置
     
145. {
     3 N' ~( R' y# q. Q: T  g" Z
146.     GPIO_InitTypeDef GPIO_InitStructure;   //定义格式为GPIO_InitTypeDef的结构体的名字为GPIO_InitStructure  
     $ P7 l2 O- F( X
147.                                           //typedef struct { u16 GPIO_Pin; GPIOSpeed_TypeDef GPIO_Speed; GPIOMode_TypeDef GPIO_Mode; } GPIO_InitTypeDef;
     : p2 p7 \  z" a) }3 g) `
148.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;    //配置IO口的工作模式为上拉输入（该io口内部外接电阻到电源）
     
149.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //配置IO口最高的输出速率为50M
     3 @  G  N. e; ]) O) l1 @) ~/ F
150.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13;  //配置被选中的管脚，|表示同时被选中
     : ]$ F" K; s" i
151.     GPIO_Init(GPIOC, &GPIO_InitStructure);                  //初始化GPIOC的相应IO口为上述配置，用于按键检测
       i4 X* q$ s, j% D
152.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;       //配置IO口工作模式为 推挽输出（有较强的输出能力）
     
153.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;      //配置IO口最高的输出速率为50M
     
154.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2;  //配置被选的管脚，|表示同时被选中
     9 s; B" I6 ^- L. \; ~0 N& U6 V
155.     GPIO_Init(GPIOA, &GPIO_InitStructure);        //初始化GPIOA的相应IO口为上述配置
     - l  F0 M. M0 C' E' z7 r
156.     GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //失能STM32 JTAG烧写功能，只能用SWD模式烧写，解放出PA15和PB中部分IO口
     
157. }
     
158. 
     
159. 
     # s, D' B* C. Y2 I' p) w8 ?" [
160. void tim4()                           //配置TIM4为基本定时器模式,约10ms触发一次，触发频率约100Hz
     
161. {
     
162.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     
163.     TIM_TimeBaseStructure. TIM_Period =9999;          // 配置计数阈值为9999，超过时，自动清零，并触发中断
     9 l: A4 s( y9 ?: k! |* L0 Z
164.     TIM_TimeBaseStructure.TIM_Prescaler =71;         //  时钟预分频值，除以多少
     
165.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 时钟分频倍数
     
166.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 计数方式为向上计数
     
167.     TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);      //  初始化tim4
     $ \- l2 w6 U0 A7 Q1 U
168.     TIM_ClearITPendingBit(TIM4,TIM_IT_Update); //清除TIM4溢出中断标志
     ( R' b! Q+ K6 U. `& ?
169.     TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);   //  使能TIM4的溢出更新中断
     ( h' G$ H+ e! v* `( g9 Q3 N
170.     TIM_Cmd(TIM4,ENABLE);                //        使能TIM4
     ' y0 y( P9 H2 c) C
171. }
     
172. 
     ) W  W/ t; S0 \  d/ l+ B
173. 
     
174. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
     % Y/ A9 {9 m0 q
175. {
     3 h1 J: N( C4 ~& ^
176.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     
177.     TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
     
178.     TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
     ' {2 P% W* f' Z# k4 L$ |8 U0 _
179.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // 时钟分频倍数
     
180.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 计数方式为向上计数
     
181.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);      //  初始化tim3
     . N( L' g9 Q7 H) y* u0 b" n4 J. U
182.     TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIM3溢出中断标志
     
183.     TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
     4 y( _# ^1 l$ ?2 _1 u" `
184.     TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
     % t1 X5 [1 _5 O& _
185. }
     
186. 
     0 m# M' t8 t1 P. g) r2 w" T/ W! y: T
187. 
     $ f+ ?3 C% P, U* \( N
188. void nvic()                                 //配置中断优先级
     , d; z6 q- O: \4 l: e6 _" `
189. {   
     0 g, W) L# D9 l+ p3 }
190.      NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
     - c' e6 s6 u; d& I1 f+ R: n% S1 z
191.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
     , L+ }$ S0 R1 _9 f/ w
192.      NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
     
193.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
     6 Y. j; Z3 Z* W
194.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
     # b0 M2 g5 P6 V  A. I7 w- m/ P
195.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
       M- l  ^' Q3 Y( J& f& X3 l
196.      NVIC_Init(&NVIC_InitStructure);                        //  初始化
     8 s5 S7 V% C3 j% f% A! q7 V
197.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
     - O) V' I2 `' m+ z; {
198.      NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
     
199.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
     
200.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
     
201.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
202.      NVIC_Init(&NVIC_InitStructure);
     : [; \* @( K0 X5 y/ D" D$ n
203. }

复制代码

" b4 q% b) C. O% C转载自：单片机与嵌入式
如有侵权请联系删除

6 _$ f( H' u0 L" y  s  F+ x, H

8 _; O, I, C# B8 N; c  g* m
4 S  M$ r* Q, z9 ~4 M