01. 概述
在FreeRTOS中优先级低于configMAX_SYSCALL_INTERRUPT_PRIORITY的中断会被屏蔽掉，高于的就不会。我们使用两个定时器，一个优先级为4，一个优先级为5，两个定时器每隔1秒通过串口输出一串字符串。然后在某个任务中关闭中断一段时间，查看两个定时器的输出情况。
$ n1 @$ @& u- S  W5 M& }5 L
0 O3 n2 @! h' I( {5 q02. 函数设计
! h4 a* {+ |' J* n( t( D' l设计两个任务start_task()和interrupt_task(),这两个任务的功能如下：
' e0 E4 @, E1 A: C
- ~% E' e+ Z4 W( {start_task():创建另外一个任务。
6 L/ ~& @3 Y3 {: }
interrupt_task()：中断测试任务，任务中会调用FreeRTOS的关中断函数将中断关闭一段时间。

03. 程序设计与分析
任务设置
  G9 S% \4 ?: h1 i1 r4 m( Q
$ {4 a' N+ l6 u$ G3 f

1. //任务优先级
   
2. #define START_TASK_PRIO                        1
   
3. //任务堆栈大小        
   
4. #define START_STK_SIZE                         256  
   
5. //任务句柄
   
6. TaskHandle_t StartTask_Handler;
   ' ?- v, o* c& y7 ~+ @* U1 W
7. //任务函数
   
8. void start_task(void *pvParameters);
   
9. 
   
10. //任务优先级
    
11. #define INTERRUPT_TASK_PRIO                2
    
12. //任务堆栈大小        
    
13. #define INTERRUPT_STK_SIZE                 256  
    
14. //任务句柄
    3 W! W2 c* G( A' h& }, w4 l8 Z
15. TaskHandle_t INTERRUPTTask_Handler;
    
16. //任务函数
    
17. void interrupt_task(void *p_arg);

复制代码

主函数设计

1. int main(void)
   
2. {
   
3.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
   
4.         delay_init(168);                                        //初始化延时函数
   $ b3 V% F5 f' Z
5.         uart_init(115200);                                     //初始化串口
   
6.         LED_Init();                                                //初始化LED端口
   
7.         TIM3_Int_Init(10000-1,8400-1);                //初始化定时器3，定时器周期1S
   1 q" g1 J% K) a( j' t# d
8.         TIM5_Int_Init(10000-1,8400-1);                //初始化定时器5，定时器周期1S
   
9.         
   2 l. v$ j; Q) v/ d
10.         //创建开始任务
    6 `  m7 i) P9 K
11.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    $ Q! `1 J$ w; L3 |8 x
12.                 (const char*    )"start_task",          //任务名称
    % {; H  t* a, K$ w( P0 Q' a
13.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
14.                 (void*          )NULL,                  //传递给任务函数的参数
      o0 ]4 O4 k+ ^& _9 s- W# l. h
15.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    ' A* ]& M. S1 D0 ]# R
16.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
17.     vTaskStartScheduler();          //开启任务调度
    , E  ]' S; c4 O
18. }

复制代码

任务函数设计

1. //开始任务任务函数
   
2. void start_task(void *pvParameters)
     Y" A/ P' T: g# J6 ^$ X
3. {
   
4.     taskENTER_CRITICAL();           //进入临界区
   
5.     //创建中断测试任务
   - H" ]" s! w% _4 H% E; Q, @
6.     xTaskCreate((TaskFunction_t )interrupt_task,                          //任务函数
   ' ]7 Z" k# [" a9 D9 ~( a9 p6 l' x+ z
7.                 (const char*    )"interrupt_task",                         //任务名称
   # f/ W# e$ Y/ a) d' F& {4 L
8.                 (uint16_t       )INTERRUPT_STK_SIZE,                //任务堆栈大小
   
9.                 (void*          )NULL,                                                //传递给任务函数的参数
   
10.                 (UBaseType_t    )INTERRUPT_TASK_PRIO,                //任务优先级
    
11.                 (TaskHandle_t*  )&INTERRUPTTask_Handler);         //任务句柄
    9 Z9 W8 d, a2 T  }/ V
12.         vTaskDelete(StartTask_Handler); //删除开始任务
    & G. E6 Z9 p7 g/ O4 j
13.     taskEXIT_CRITICAL();            //退出临界区
    
14. }
    
15. 
    
16. //中断测试任务函数
    7 H! ?& \8 R% ], `6 ?
17. void interrupt_task(void *pvParameters)
    8 J0 n7 Y: d" @! K
18. {
    
19.         static u32 total_num=0;
    " {2 Z* L/ w0 i) J$ Q
20.     while(1)
    
21.     {
    
22.                 total_num+=1;
    8 w6 J" K, B. `; _
23.                 if(total_num==5)
    
24.                 {
    3 j" u4 e; m4 O) @% x) R0 B
25.                         printf("关闭中断.............\r\n");
    6 `! V5 {4 O& L+ R' Q
26.                         portDISABLE_INTERRUPTS();                                //关闭中断
    0 ]1 s/ ^% E, `2 G1 ?. I
27.                         delay_xms(5000);                                                //延时5s
    
28.                         printf("打开中断.............\r\n");        //打开中断
    
29.                         portENABLE_INTERRUPTS();
    
30.                 }
    
31.         LED0=~LED0;
    0 X( V' U! X) s0 L# a! `* e
32.         vTaskDelay(1000);
    - V1 M% g1 d3 n) o3 ~9 M
33.     }
    8 p% e* i7 {0 q( K$ p% o
34. }  

复制代码

0 G4 L, g4 r3 @. H/ j. N5 n3 s$ G! g04. 中断初始化

1. //通用定时器3中断初始化
   
2. //arr：自动重装值。
   
3. //psc：时钟预分频数
   
4. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
   , l6 {; Q# W" H( H
5. //Ft=定时器工作频率,单位:Mhz
   : |4 m% c4 U6 g: k# Q
6. //这里使用的是定时器3!
   
7. void TIM3_Int_Init(u16 arr,u16 psc)
   
8. {
   
9.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
   
10.         NVIC_InitTypeDef NVIC_InitStructure;
    2 V: d) B5 G4 V- H- U: b' i
11.         
    0 ~" u+ q9 D  C; n$ H7 {( r
12.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);  ///使能TIM3时钟
    - y7 R# a  D' p7 q
13.         
    
14.         TIM_TimeBaseInitStructure.TIM_Period = arr;         //自动重装载值
    # S8 I( |$ E8 m4 Y0 h; l' y% V) F
15.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;  //定时器分频
    
16.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
17.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
18.         
    $ d9 `* ^" \( ]9 t# I0 b0 @. c
19.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitStructure);//初始化TIM3
    * |/ |) M8 k# @4 q# G5 N
20.         
    3 Q' T9 `9 ~6 k: x9 d4 f, _
21.         TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //允许定时器3更新中断
    1 @, t4 G3 O  M. o  f9 X
22.         TIM_Cmd(TIM3,ENABLE); //使能定时器3
    % s# }, ~2 c6 i$ z) @( _2 r- I
23.         
    5 F2 J5 w7 z+ t- W- B
24.         NVIC_InitStructure.NVIC_IRQChannel=TIM3_IRQn; //定时器3中断
    4 E' \% D5 X7 H7 T2 l' Y+ Y
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x04; //抢占优先级4
    2 g1 A; Q0 Q& T; {; M
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00; //子优先级0
    $ }' D& y0 O+ k! G) e. r
27.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
28.         NVIC_Init(&NVIC_InitStructure);
    . F. g) t& L0 C6 u0 l* _$ m
29. }
    
30. 
    ! i5 F/ Y5 e9 _- x5 c
31. //通用定时器5中断初始化
    ' g: ]- T4 g0 Z9 b
32. //arr：自动重装值。
    3 S& j7 ?3 A' p0 p& c- X$ ?
33. //psc：时钟预分频数
    8 c3 s# G. l/ W# u
34. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    ; [! K+ r9 j4 b7 q
35. //Ft=定时器工作频率,单位:Mhz
    * K3 l, m6 C! R3 Q7 V
36. //这里使用的是定时器5!
    
37. void TIM5_Int_Init(u16 arr,u16 psc)
    
38. {
      E# w5 D/ t! [- E8 F6 s$ V' c
39.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    
40.         NVIC_InitTypeDef NVIC_InitStructure;
    
41.         
    
42.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5,ENABLE);        //使能TIM5时钟
    
43.         
    0 A3 p" y7 T. N, c% _6 p) m
44.         TIM_TimeBaseInitStructure.TIM_Period = arr;                 //自动重装载值
    
45.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;                  //定时器分频
    
46.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    2 O# P3 {0 D" V3 O- {# T1 q
47.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
48.         
    % `2 P. K  A# K6 F3 o
49.         TIM_TimeBaseInit(TIM5,&TIM_TimeBaseInitStructure);        //初始化TIM5
    3 {% T" I+ Q! P
50.         
    # s1 ?# \8 Y  D6 I6 {& y- \$ ~! i; e
51.         TIM_ITConfig(TIM5,TIM_IT_Update,ENABLE);                         //允许定时器5更新中断
    
52.         TIM_Cmd(TIM5,ENABLE);                                                                 //使能定时器5
    " Q! A8 x; V3 b! w, F
53.         
    
54.         NVIC_InitStructure.NVIC_IRQChannel=TIM5_IRQn;                 //定时器5中断
    
55.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x05;         //抢占优先级5
    
56.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;                 //子优先级0
    
57.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    # C% ?/ {( Z' _' t$ C# r4 M
58.         NVIC_Init(&NVIC_InitStructure);
    # m7 J( V1 Y5 b7 u% a+ W# t
59. }
    ; B. ]6 r9 t* a) {& P$ `
60. 
    
61. //定时器3中断服务函数
    8 L! \) {; M: k' C
62. void TIM3_IRQHandler(void)
    , b5 p" C3 a- J& r
63. {
    
64.         if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET) //溢出中断
    0 p& R. H  e/ f3 l; S
65.         {
    
66.                 printf("TIM3输出.......\r\n");
    
67.         }
    
68.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //清除中断标志位
    
69. }
    ' l% ?# s: u9 f9 n& X8 ~' b' \$ `
70. 
    
71. 
    0 p) H6 q( g1 n; Z5 Z' c
72. //定时器5中断服务函数
    
73. void TIM5_IRQHandler(void)
    
74. {
    
75.         if(TIM_GetITStatus(TIM5,TIM_IT_Update)==SET) //溢出中断
    # r  g" M( ~2 K* F
76.         {
    
77.                 printf("TIM5输出.......\r\n");
    $ j8 m3 A) p6 C; O5 N0 \/ Y" @$ p
78.         }
    5 w& f. m( E, ~" ?5 N3 ~- K% h
79.         TIM_ClearITPendingBit(TIM5,TIM_IT_Update);  //清除中断标志位
    
80. }

复制代码

05. 程序设计
main.c文件

1. 
   
2. //任务优先级
   0 ~; j/ \8 q8 ^
3. #define START_TASK_PRIO                        1
   , k8 P! O0 X8 t6 ^3 S  g% M% i
4. //任务堆栈大小        
   3 _2 a5 D8 r0 I1 C
5. #define START_STK_SIZE                         256  
   ( Z1 Y5 X' d/ N' I3 i
6. //任务句柄
   9 @+ x; S  L! q& j% q
7. TaskHandle_t StartTask_Handler;
   ) Q' A4 J" r6 c% Y! ]
8. //任务函数
   " s- I6 W0 H1 y+ c7 U2 K
9. void start_task(void *pvParameters);
   
10. 
    ! c6 E; k- ~% @
11. //任务优先级
    
12. #define INTERRUPT_TASK_PRIO                2
    
13. //任务堆栈大小        
    
14. #define INTERRUPT_STK_SIZE                 256  
    
15. //任务句柄
    
16. TaskHandle_t INTERRUPTTask_Handler;
    0 V5 z7 t) C9 }8 I6 s
17. //任务函数
    - R/ _) L1 k: Q
18. void interrupt_task(void *p_arg);
    
19. 
    
20. int main(void)
    
21. {
    * k7 s# {9 i4 S9 b2 M$ M: F
22.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    
23.         delay_init(168);                                        //初始化延时函数
    . u* {2 `# n4 J$ V8 l3 `7 ~- k
24.         uart_init(115200);                                     //初始化串口
    0 t/ p8 T9 ]6 Q' g
25.         LED_Init();                                                //初始化LED端口
    # }1 h) z3 a. C; S/ K
26.         TIM3_Int_Init(10000-1,8400-1);                //初始化定时器3，定时器周期1S
    
27.         TIM5_Int_Init(10000-1,8400-1);                //初始化定时器5，定时器周期1S
    
28.         
    5 \7 l$ \9 D5 c8 z7 c4 _" B
29.         //创建开始任务
    4 G  E2 K% K1 E
30.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    
31.                 (const char*    )"start_task",          //任务名称
    
32.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    . k- ~: w3 n9 J
33.                 (void*          )NULL,                  //传递给任务函数的参数
    ) |. D% O) A  F9 K+ V( q2 J
34.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
35.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    0 _4 P% W9 K+ m/ O
36.     vTaskStartScheduler();          //开启任务调度
    
37. }
    
38. 
    % u, ~2 F( j5 t3 m4 w8 J( l: H8 C
39. //开始任务任务函数
    ( X  _1 D1 O. D, C8 }
40. void start_task(void *pvParameters)
    - K9 A1 f, t( x! c1 ]  G
41. {
    
42.     taskENTER_CRITICAL();           //进入临界区
    . L; C  b+ z  R) @0 K
43.     //创建中断测试任务
    5 h  @5 ^6 i- O7 ~
44.     xTaskCreate((TaskFunction_t )interrupt_task,                          //任务函数
    
45.                 (const char*    )"interrupt_task",                         //任务名称
    
46.                 (uint16_t       )INTERRUPT_STK_SIZE,                //任务堆栈大小
    
47.                 (void*          )NULL,                                                //传递给任务函数的参数
    * L+ l  f+ f1 j; k& I* A( S! ^
48.                 (UBaseType_t    )INTERRUPT_TASK_PRIO,                //任务优先级
    
49.                 (TaskHandle_t*  )&INTERRUPTTask_Handler);         //任务句柄
    
50.         vTaskDelete(StartTask_Handler); //删除开始任务
    
51.     taskEXIT_CRITICAL();            //退出临界区
    
52. }
    
53. 
    8 P+ X  X+ f) L; H
54. //中断测试任务函数
    # M& F. @+ g6 P* F2 {+ O& d* S+ f7 ]
55. void interrupt_task(void *pvParameters)
    4 m# Z( P+ B2 t. g* g! e; {* p$ \
56. {
    
57.         static u32 total_num=0;
    9 o/ k5 O2 U" N* z
58.     while(1)
    3 ~4 b$ M9 E6 x  |0 U1 {
59.     {
    
60.                 total_num+=1;
    / F; R- m* L, `% \
61.                 if(total_num==5)
    
62.                 {
    $ ?7 {# z! y# C; K( Z/ }& \! F; Q) w
63.                         printf("关闭中断.............\r\n");
    * P& L% {/ q/ }1 }) [  m
64.                         portDISABLE_INTERRUPTS();                                //关闭中断
    - x4 J4 f) |4 }7 N7 {! z
65.                         delay_xms(5000);                                                //延时5s
    
66.                         printf("打开中断.............\r\n");        //打开中断
    1 A# T/ T; i: m& |
67.                         portENABLE_INTERRUPTS();
    0 w( _* Q7 K1 J4 Q! `  D/ H
68.                 }
    1 Q! {( E! k1 u5 ]5 J) T; ~: `
69.         LED0=~LED0;
    / h" N/ b+ {* B) q# `
70.         vTaskDelay(1000);
    + {! H: R# ]: F7 N" [1 s  V" |2 ?
71.     }
    5 H, @+ x4 ^- c6 X, F
72. }  

复制代码

$ S! t: m, c1 X3 Ntimer.c文件

, k4 \/ A! ~7 \# e5 N8 b

1. 
   
2. //通用定时器3中断初始化
   
3. //arr：自动重装值。
   ) e8 i& P* l& m7 o& N1 ^2 ?
4. //psc：时钟预分频数
   & b( f/ ]& t; J- U  m
5. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
   
6. //Ft=定时器工作频率,单位:Mhz
   $ v9 e; P' f8 F1 Q# w# }6 u( ?( k
7. //这里使用的是定时器3!
   & j/ |$ m5 E' B2 N  `
8. void TIM3_Int_Init(u16 arr,u16 psc)
   % w5 ]5 J) y  F8 o
9. {
   
10.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    " Q& R. }: B7 `' |
11.         NVIC_InitTypeDef NVIC_InitStructure;
    
12.         
    % n) L' q, R; ~! [! [
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);  ///使能TIM3时钟
    + d' R' ]6 C, j8 M* g5 i# X, V( [" w
14.         
    
15.         TIM_TimeBaseInitStructure.TIM_Period = arr;         //自动重装载值
    % f# D4 U6 x5 k6 S2 z) [4 D# p
16.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;  //定时器分频
    
17.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    / x+ \5 u2 r( j4 j4 b0 g
18.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
19.         
    
20.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitStructure);//初始化TIM3
    
21.         
    
22.         TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //允许定时器3更新中断
    ' j- L: V6 x" w) m1 t7 @
23.         TIM_Cmd(TIM3,ENABLE); //使能定时器3
    
24.         
    - z4 U8 I3 t/ J
25.         NVIC_InitStructure.NVIC_IRQChannel=TIM3_IRQn; //定时器3中断
    
26.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x04; //抢占优先级4
    
27.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00; //子优先级0
    ) s3 \3 s6 F2 ~' J9 i  {
28.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
29.         NVIC_Init(&NVIC_InitStructure);
    
30. }
    
31. 
    
32. //通用定时器5中断初始化
    $ `/ x, X1 z3 g5 C* Q6 S: d8 Z6 m9 Z
33. //arr：自动重装值。
    0 Y; Y5 Y. y. ?4 G! V
34. //psc：时钟预分频数
    
35. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    ' }. d0 F! l+ c3 m! l
36. //Ft=定时器工作频率,单位:Mhz
    5 F+ b7 \/ l+ b. d3 A
37. //这里使用的是定时器5!
    
38. void TIM5_Int_Init(u16 arr,u16 psc)
    # o, @5 e; c1 z( c1 l+ G
39. {
    
40.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    + [+ Z; E; L( s7 L/ z, |
41.         NVIC_InitTypeDef NVIC_InitStructure;
    
42.         
    
43.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5,ENABLE);        //使能TIM5时钟
    
44.         
    
45.         TIM_TimeBaseInitStructure.TIM_Period = arr;                 //自动重装载值
    
46.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;                  //定时器分频
    / y  F7 _8 Y# Z2 P2 e1 C9 T# _
47.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    # t. a7 Z+ s# ]$ B0 C# K! O
48.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    ' f" F: n+ {! [9 I  z
49.         
    : y$ ]+ k7 P2 \0 y+ k; C
50.         TIM_TimeBaseInit(TIM5,&TIM_TimeBaseInitStructure);        //初始化TIM5
    
51.         
    " i: P) h9 L4 K  J
52.         TIM_ITConfig(TIM5,TIM_IT_Update,ENABLE);                         //允许定时器5更新中断
    * P8 Z" s/ Q) A8 Z. R% Q) T. s
53.         TIM_Cmd(TIM5,ENABLE);                                                                 //使能定时器5
    
54.         
    % s+ ~0 ?; ]. S& B
55.         NVIC_InitStructure.NVIC_IRQChannel=TIM5_IRQn;                 //定时器5中断
    ; G; A2 E6 s, F
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x05;         //抢占优先级5
    6 ~2 e. R6 l8 s7 Z; p; b( Z% l
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;                 //子优先级0
    
58.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
59.         NVIC_Init(&NVIC_InitStructure);
    
60. }
    
61. 
    
62. //定时器3中断服务函数
    
63. void TIM3_IRQHandler(void)
    
64. {
    3 J5 f. [. z- u  b3 ^+ A
65.         if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET) //溢出中断
    
66.         {
    - g, P8 g6 z) O8 M
67.                 printf("TIM3输出.......\r\n");
    
68.         }
    # l$ o. a- f: U
69.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //清除中断标志位
    
70. }
    3 a) z7 c: V5 a
71. 
    
72. 
    
73. //定时器5中断服务函数
    ; Q# B) }% a' Q) e/ I. y
74. void TIM5_IRQHandler(void)
      H! U2 G% V' H! ?# s  Y, d
75. {
    
76.         if(TIM_GetITStatus(TIM5,TIM_IT_Update)==SET) //溢出中断
    
77.         {
    
78.                 printf("TIM5输出.......\r\n");
    ' [, f. w3 M% V
79.         }
    ; U& \1 ~8 _' J. D# v6 A
80.         TIM_ClearITPendingBit(TIM5,TIM_IT_Update);  //清除中断标志位
    # \/ k2 o( b+ n
81. }

复制代码

5 T. W9 @3 z- S8 i