01. 概述
在FreeRTOS中优先级低于configMAX_SYSCALL_INTERRUPT_PRIORITY的中断会被屏蔽掉，高于的就不会。我们使用两个定时器，一个优先级为4，一个优先级为5，两个定时器每隔1秒通过串口输出一串字符串。然后在某个任务中关闭中断一段时间，查看两个定时器的输出情况。

/ t" i- I  E9 C) w; r/ R6 q4 ?02. 函数设计
8 d2 r6 f: T( b1 p( a设计两个任务start_task()和interrupt_task(),这两个任务的功能如下：

start_task():创建另外一个任务。
, R; ]5 H* I: W! ?# ^
interrupt_task()：中断测试任务，任务中会调用FreeRTOS的关中断函数将中断关闭一段时间。

03. 程序设计与分析
任务设置
. x8 L9 Z' v& R( L
$ U5 d: X/ l" Q- q) v& Y/ [

1. //任务优先级
   - E' ~0 S+ o( a, x
2. #define START_TASK_PRIO                        1
   & M  F. I& k: E) c# j- q
3. //任务堆栈大小        
   ' V5 s+ R0 |/ S- V/ S+ d
4. #define START_STK_SIZE                         256  
   * o$ a% Y+ x5 x
5. //任务句柄
   
6. TaskHandle_t StartTask_Handler;
   
7. //任务函数
   
8. void start_task(void *pvParameters);
   
9. 
   : w2 d7 P5 W" H0 c4 ?
10. //任务优先级
    
11. #define INTERRUPT_TASK_PRIO                2
    
12. //任务堆栈大小        
    
13. #define INTERRUPT_STK_SIZE                 256  
    
14. //任务句柄
    " J& Y. A7 h  Q, e2 o* f. V
15. TaskHandle_t INTERRUPTTask_Handler;
    # ?6 Q8 \. r  [6 d3 }* [) i3 T0 ]
16. //任务函数
    # A6 W. p/ _6 P" ^% g6 Z% G
17. void interrupt_task(void *p_arg);

复制代码

主函数设计

1. int main(void)
   
2. {
   
3.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
   
4.         delay_init(168);                                        //初始化延时函数
   
5.         uart_init(115200);                                     //初始化串口
   
6.         LED_Init();                                                //初始化LED端口
   
7.         TIM3_Int_Init(10000-1,8400-1);                //初始化定时器3，定时器周期1S
   
8.         TIM5_Int_Init(10000-1,8400-1);                //初始化定时器5，定时器周期1S
   " ]9 v9 w0 A! l
9.         
   
10.         //创建开始任务
      I- Q4 V# w8 @4 ]
11.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    * V& v- f' l8 S  C9 C: \- n
12.                 (const char*    )"start_task",          //任务名称
    9 H$ C# _  d7 z0 ~4 y7 s. n: v; _
13.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
14.                 (void*          )NULL,                  //传递给任务函数的参数
    3 O  w+ ~% W# u/ i) H' W2 T
15.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    ' @  v% O" h3 N- j+ W! S3 d% Y5 A
16.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    $ S! t+ @* z) J9 E% j
17.     vTaskStartScheduler();          //开启任务调度
    
18. }

复制代码

( y- N& S3 b* f$ R. q1 m任务函数设计
3 t5 a/ t$ h# N
2 o3 O" u$ {2 A- H

1. //开始任务任务函数
   7 h) a& \, z; u7 i
2. void start_task(void *pvParameters)
   
3. {
   , @/ [! J" n" y- g$ e6 `
4.     taskENTER_CRITICAL();           //进入临界区
   
5.     //创建中断测试任务
   
6.     xTaskCreate((TaskFunction_t )interrupt_task,                          //任务函数
   
7.                 (const char*    )"interrupt_task",                         //任务名称
     S0 _! v1 K+ z+ g/ A3 \4 c
8.                 (uint16_t       )INTERRUPT_STK_SIZE,                //任务堆栈大小
   
9.                 (void*          )NULL,                                                //传递给任务函数的参数
   
10.                 (UBaseType_t    )INTERRUPT_TASK_PRIO,                //任务优先级
    ) \' }) V2 C, i+ C/ {1 _
11.                 (TaskHandle_t*  )&INTERRUPTTask_Handler);         //任务句柄
    
12.         vTaskDelete(StartTask_Handler); //删除开始任务
    - R' s7 R8 k) [) o4 r3 q
13.     taskEXIT_CRITICAL();            //退出临界区
    # [  q" r. w0 t2 G
14. }
    
15. 
    
16. //中断测试任务函数
    5 G3 G  G9 h4 l, _! y( b$ W
17. void interrupt_task(void *pvParameters)
    
18. {
    ' a$ m5 t# I2 {7 X  W! S
19.         static u32 total_num=0;
    ) j; _9 t6 E+ U, C' H  ^, H- o8 r
20.     while(1)
    
21.     {
    
22.                 total_num+=1;
    
23.                 if(total_num==5)
    . I& y) |; d! P. J* [- O  B& w3 {
24.                 {
    
25.                         printf("关闭中断.............\r\n");
    
26.                         portDISABLE_INTERRUPTS();                                //关闭中断
    % J- U: c5 d+ N4 E" H
27.                         delay_xms(5000);                                                //延时5s
    
28.                         printf("打开中断.............\r\n");        //打开中断
    
29.                         portENABLE_INTERRUPTS();
    ( y, B* l& r9 l7 L
30.                 }
    ! y2 D7 Q# \3 R1 d9 H
31.         LED0=~LED0;
    
32.         vTaskDelay(1000);
    5 J/ ?) O( u! c; a7 G! _* R" H
33.     }
    
34. }  

复制代码

1 Y/ u$ @. |7 F: k5 Q04. 中断初始化
3 o7 U( r" x0 r3 V2 H; a/ [3 Z
, C+ d0 W# Q( q4 d; Z% H. t

1. //通用定时器3中断初始化
   3 V  [+ S7 C0 F9 h
2. //arr：自动重装值。
   / M  x! d: b5 e! E2 r$ n
3. //psc：时钟预分频数
   : ]: |) ^8 H+ j3 z9 C
4. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
     B4 G! C6 m, M" F
5. //Ft=定时器工作频率,单位:Mhz
   * [! n2 ^/ u- S6 P: N8 o$ y
6. //这里使用的是定时器3!
   
7. void TIM3_Int_Init(u16 arr,u16 psc)
   
8. {
   3 y/ r# Z* {; ?) i1 D2 g2 P) S
9.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
   ( m( E$ r; f0 k3 r
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11.         
      r( j" k$ d$ j. N, G" n
12.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);  ///使能TIM3时钟
    4 d9 F) j! A* q8 T0 `
13.         
    . V0 `1 p: f  _/ C" Z' P
14.         TIM_TimeBaseInitStructure.TIM_Period = arr;         //自动重装载值
    - i* |# S& e# D" C2 L' \5 D! K
15.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;  //定时器分频
    + g! _  D0 [5 l' `3 q( e
16.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    0 ~$ H) H$ \/ f& o& N8 ~0 M! ]' T
17.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    ; H0 o- \) g$ O1 r+ P& s
18.         
    / ?  d' F% u* O" T' t
19.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitStructure);//初始化TIM3
    3 ~# X3 n/ U% y4 I5 f
20.         
    - m. t/ H8 |+ w
21.         TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //允许定时器3更新中断
    
22.         TIM_Cmd(TIM3,ENABLE); //使能定时器3
    . T1 N% n% Z$ Y+ S; U1 Q) ]
23.         
    $ v: ]; o% g9 J; H- ?
24.         NVIC_InitStructure.NVIC_IRQChannel=TIM3_IRQn; //定时器3中断
    
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x04; //抢占优先级4
    
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00; //子优先级0
    
27.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    ; `% O8 p2 S7 P
28.         NVIC_Init(&NVIC_InitStructure);
    5 {$ j) |! g# T+ S; w
29. }
    5 D+ w/ ?+ b# H' D3 A
30. 
    ' k8 ^0 R, t, G! V4 F3 ~8 _+ D
31. //通用定时器5中断初始化
    
32. //arr：自动重装值。
    " B/ B8 l: K* Y6 J: L& f: K
33. //psc：时钟预分频数
    
34. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    % ~, I8 B$ k& h/ B3 h2 b
35. //Ft=定时器工作频率,单位:Mhz
    
36. //这里使用的是定时器5!
    : O6 {- M9 X  \
37. void TIM5_Int_Init(u16 arr,u16 psc)
    
38. {
    1 \$ V- p- b  N; h/ @: x
39.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    4 Q4 n! _' b9 {
40.         NVIC_InitTypeDef NVIC_InitStructure;
    ( q; G8 m. z0 H/ s5 y
41.         
    
42.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5,ENABLE);        //使能TIM5时钟
    * z! ?, C- J! e, B* u% T/ ~
43.         
    
44.         TIM_TimeBaseInitStructure.TIM_Period = arr;                 //自动重装载值
    
45.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;                  //定时器分频
    
46.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
47.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
48.         
    ( D% y( q/ ~+ J3 Q8 Z- k, d) s. k
49.         TIM_TimeBaseInit(TIM5,&TIM_TimeBaseInitStructure);        //初始化TIM5
    ; R: c$ ^8 S" K# \
50.         
    ' H) {+ ^4 ]5 p0 C6 D" M4 K- ]& h
51.         TIM_ITConfig(TIM5,TIM_IT_Update,ENABLE);                         //允许定时器5更新中断
    
52.         TIM_Cmd(TIM5,ENABLE);                                                                 //使能定时器5
    
53.         
    2 e" |* w2 J$ g3 A8 t8 p, n* n9 I; Z
54.         NVIC_InitStructure.NVIC_IRQChannel=TIM5_IRQn;                 //定时器5中断
    
55.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x05;         //抢占优先级5
    $ `9 ^4 y( `8 n4 n
56.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;                 //子优先级0
    
57.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    $ |" a* t6 @7 S: ^6 f
58.         NVIC_Init(&NVIC_InitStructure);
    
59. }
    4 i& A. X1 \* ^. I( M
60. 
    9 K0 s* q& g) X9 m! o3 n
61. //定时器3中断服务函数
    
62. void TIM3_IRQHandler(void)
    , v3 M0 G$ \  G2 q0 _
63. {
    + s# m( S: n5 B7 r9 k" r+ l" G
64.         if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET) //溢出中断
    2 B% H' Z' \0 \% a; l# f; {
65.         {
    
66.                 printf("TIM3输出.......\r\n");
    : a. A" e* V. D& `
67.         }
      ?2 z. d' u" q. w3 O( V& q- s
68.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //清除中断标志位
    
69. }
    
70. 
    5 v4 ?, t# w& D0 K
71. 
    
72. //定时器5中断服务函数
    - t+ p9 b; t5 C/ q  ~$ C  R4 z
73. void TIM5_IRQHandler(void)
    ; e! }) a  U, D- t7 J; J
74. {
    
75.         if(TIM_GetITStatus(TIM5,TIM_IT_Update)==SET) //溢出中断
    
76.         {
    / G0 ~! X1 s, w% \; z
77.                 printf("TIM5输出.......\r\n");
    # G" L- R, H: p4 @
78.         }
    $ C9 B$ P1 o/ O9 U. Y# X$ A& M' g
79.         TIM_ClearITPendingBit(TIM5,TIM_IT_Update);  //清除中断标志位
    
80. }

复制代码

05. 程序设计
) k1 H0 T7 F% K# ]! m# I: b, @  emain.c文件

1. 
   5 V3 ]0 b6 t- x* D
2. //任务优先级
   
3. #define START_TASK_PRIO                        1
   
4. //任务堆栈大小        
   
5. #define START_STK_SIZE                         256  
   6 \0 a# e6 r' G) y8 f0 n
6. //任务句柄
   
7. TaskHandle_t StartTask_Handler;
   
8. //任务函数
   
9. void start_task(void *pvParameters);
   
10. 
    8 I  ?. n. b, B
11. //任务优先级
    " w, B, c& F& Y; C" g  ^
12. #define INTERRUPT_TASK_PRIO                2
    . `' w4 k6 L( P  y. t4 R
13. //任务堆栈大小        
    7 _: V: q! j, u0 g0 O
14. #define INTERRUPT_STK_SIZE                 256  
    
15. //任务句柄
    
16. TaskHandle_t INTERRUPTTask_Handler;
    , H) k/ l: X5 @$ e/ c. T) o% F/ C
17. //任务函数
      g0 u! x- ~2 X. w! d# Y
18. void interrupt_task(void *p_arg);
    4 b- Q: N' D; |  I# |9 F+ e8 }$ N& C
19. 
    - s6 f: M  ~$ G3 b5 U. G
20. int main(void)
    
21. {
    4 N8 i0 p; ?% E. \; I8 p( S+ s. ?# Q
22.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    ' G& E$ {- W* f
23.         delay_init(168);                                        //初始化延时函数
    , b4 F, S* v" G% o5 e
24.         uart_init(115200);                                     //初始化串口
    4 F+ _  A# I+ }- p% b# U
25.         LED_Init();                                                //初始化LED端口
    
26.         TIM3_Int_Init(10000-1,8400-1);                //初始化定时器3，定时器周期1S
    4 Q6 E% |+ ^( Y8 y6 T& k2 ~
27.         TIM5_Int_Init(10000-1,8400-1);                //初始化定时器5，定时器周期1S
    ! `2 I( G8 i5 r6 p/ G# h
28.         
    " e, m$ H) P& m  v. v
29.         //创建开始任务
    
30.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    1 _2 D. X* b& W8 f7 |
31.                 (const char*    )"start_task",          //任务名称
    % }$ l; o8 p$ M: ~4 @- [
32.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    ) K/ X1 Y6 S4 x$ C6 u: A2 d7 M
33.                 (void*          )NULL,                  //传递给任务函数的参数
    
34.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
35.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
36.     vTaskStartScheduler();          //开启任务调度
    7 s) t: O- d7 y0 Q' E1 e. {& C
37. }
    / G7 n9 H. m2 o, h
38. 
    
39. //开始任务任务函数
    3 }/ b+ m% n' A/ d1 i+ ?! f$ c
40. void start_task(void *pvParameters)
    
41. {
    
42.     taskENTER_CRITICAL();           //进入临界区
    8 M. y2 b* |+ S. n' T0 a2 O
43.     //创建中断测试任务
    0 t' J# r6 U) c+ R# Q. e% d0 r' u6 a5 y
44.     xTaskCreate((TaskFunction_t )interrupt_task,                          //任务函数
    
45.                 (const char*    )"interrupt_task",                         //任务名称
    
46.                 (uint16_t       )INTERRUPT_STK_SIZE,                //任务堆栈大小
    
47.                 (void*          )NULL,                                                //传递给任务函数的参数
    
48.                 (UBaseType_t    )INTERRUPT_TASK_PRIO,                //任务优先级
    # Q; `) r. `( {: V% u' l; E! e
49.                 (TaskHandle_t*  )&INTERRUPTTask_Handler);         //任务句柄
    
50.         vTaskDelete(StartTask_Handler); //删除开始任务
    
51.     taskEXIT_CRITICAL();            //退出临界区
    
52. }
      E: M5 P' H  J; c- R
53. 
    
54. //中断测试任务函数
    
55. void interrupt_task(void *pvParameters)
    
56. {
    1 L9 s$ n" [& {' x" O
57.         static u32 total_num=0;
    / x8 S% P( C8 j% `2 j
58.     while(1)
    
59.     {
    4 g- G( g& ]$ t+ @; h
60.                 total_num+=1;
    
61.                 if(total_num==5)
    0 \+ n1 s( ~# V, S% F% y! q
62.                 {
    0 O, d  }. [) o- D) o6 y
63.                         printf("关闭中断.............\r\n");
    
64.                         portDISABLE_INTERRUPTS();                                //关闭中断
    1 `2 z/ T. X+ ~: X& O, ]. B% g
65.                         delay_xms(5000);                                                //延时5s
    
66.                         printf("打开中断.............\r\n");        //打开中断
    
67.                         portENABLE_INTERRUPTS();
    
68.                 }
    
69.         LED0=~LED0;
    3 _9 t- x5 S" p% g, k  I
70.         vTaskDelay(1000);
    & e7 F$ g: a( w0 V" X
71.     }
    # R* F. e" Z' \! _6 S$ X7 E
72. }  

复制代码

timer.c文件
; [3 P, f7 P0 H8 H9 x: P
) }  H& d3 L  g: E0 w  Y

1. 
   ; k3 R5 n( G1 c
2. //通用定时器3中断初始化
   
3. //arr：自动重装值。
   ) M& o3 Q$ s6 b  r
4. //psc：时钟预分频数
   
5. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
   
6. //Ft=定时器工作频率,单位:Mhz
   8 B. t. L, |1 D& |( T
7. //这里使用的是定时器3!
   
8. void TIM3_Int_Init(u16 arr,u16 psc)
   % u2 p- L; b9 }) T: x
9. {
   
10.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    3 J! Y& e2 o8 t0 L+ _
11.         NVIC_InitTypeDef NVIC_InitStructure;
    * M* v+ W: z5 P6 w  K5 m. A1 _9 e
12.         
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);  ///使能TIM3时钟
    
14.         
    
15.         TIM_TimeBaseInitStructure.TIM_Period = arr;         //自动重装载值
    
16.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;  //定时器分频
    ) O% I$ H6 f$ ]
17.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
18.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
19.         
    + \  C: v4 f4 J" j
20.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitStructure);//初始化TIM3
    6 \. @; f8 O3 t2 M
21.         
    
22.         TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //允许定时器3更新中断
    
23.         TIM_Cmd(TIM3,ENABLE); //使能定时器3
    * y! w& W& I# W1 B/ q/ O- X3 o
24.         
    
25.         NVIC_InitStructure.NVIC_IRQChannel=TIM3_IRQn; //定时器3中断
    
26.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x04; //抢占优先级4
    
27.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00; //子优先级0
    , y# \( ?; d! G. P4 m
28.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
29.         NVIC_Init(&NVIC_InitStructure);
    9 Y7 S( k& C$ R) [! f' T1 M$ S7 w1 |6 i
30. }
    * ~& k7 _4 n6 L! V
31. 
    
32. //通用定时器5中断初始化
    * t6 c) X" K7 L% W/ C2 U! g
33. //arr：自动重装值。
    5 p* r8 G: u' ]# z. y4 ]' r+ e# T5 l: t
34. //psc：时钟预分频数
    6 {" [7 X. U3 p$ i5 o% z6 H$ m% [
35. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    
36. //Ft=定时器工作频率,单位:Mhz
    
37. //这里使用的是定时器5!
    : m' Q4 [, B4 H
38. void TIM5_Int_Init(u16 arr,u16 psc)
    
39. {
    
40.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    8 i/ @9 q6 D9 C' G
41.         NVIC_InitTypeDef NVIC_InitStructure;
    
42.         
      x! f0 u+ Z3 V
43.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5,ENABLE);        //使能TIM5时钟
    4 S! G$ X0 g1 b3 R  H. g7 T
44.         
    9 T, t& O! w' v2 Z5 b+ K' t
45.         TIM_TimeBaseInitStructure.TIM_Period = arr;                 //自动重装载值
    ( m% U/ S, H% l
46.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;                  //定时器分频
    
47.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
48.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    # E! T# C5 o6 p2 N: L  @$ n
49.         
    
50.         TIM_TimeBaseInit(TIM5,&TIM_TimeBaseInitStructure);        //初始化TIM5
    ( S& r, q' T& ~: i( v
51.         
    
52.         TIM_ITConfig(TIM5,TIM_IT_Update,ENABLE);                         //允许定时器5更新中断
    8 z0 V1 X* G9 t" q, X; X( k
53.         TIM_Cmd(TIM5,ENABLE);                                                                 //使能定时器5
    ' J1 S5 V; @! C- ~4 I+ L
54.         
    . B0 Q7 d: m: E0 _7 I3 {- S3 W" J
55.         NVIC_InitStructure.NVIC_IRQChannel=TIM5_IRQn;                 //定时器5中断
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x05;         //抢占优先级5
    $ s5 m: H+ \& k3 X. N, D
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;                 //子优先级0
    
58.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    7 _7 Z. H6 Y, }6 t/ n# n
59.         NVIC_Init(&NVIC_InitStructure);
    
60. }
    
61. 
    
62. //定时器3中断服务函数
    
63. void TIM3_IRQHandler(void)
    
64. {
    8 ?# V5 d2 D2 s$ b/ Y' q" [
65.         if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET) //溢出中断
    
66.         {
    
67.                 printf("TIM3输出.......\r\n");
    
68.         }
    
69.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //清除中断标志位
    * Z! j& E3 c4 _# e+ u( v* g
70. }
    
71. 
    
72. 
    
73. //定时器5中断服务函数
    
74. void TIM5_IRQHandler(void)
    , q% z* Q$ ~' Y$ O6 o
75. {
    
76.         if(TIM_GetITStatus(TIM5,TIM_IT_Update)==SET) //溢出中断
    9 c' }+ e# y& o* [0 U  C
77.         {
    
78.                 printf("TIM5输出.......\r\n");
    
79.         }
    
80.         TIM_ClearITPendingBit(TIM5,TIM_IT_Update);  //清除中断标志位
    # H& E+ I6 g& A: O- O
81. }

复制代码

& [1 [2 M! ]2 }7 m5 b
/ x; C$ s; z! J5 d$ Q5 A