01. 概述
. D6 R- g9 r2 R8 G* Z/ Q5 c0 u6 q8 T在FreeRTOS中优先级低于configMAX_SYSCALL_INTERRUPT_PRIORITY的中断会被屏蔽掉，高于的就不会。我们使用两个定时器，一个优先级为4，一个优先级为5，两个定时器每隔1秒通过串口输出一串字符串。然后在某个任务中关闭中断一段时间，查看两个定时器的输出情况。
1 y& }! H2 C# V( b: |  g& H5 |
02. 函数设计
6 Y. s: p/ c6 O$ R. H设计两个任务start_task()和interrupt_task(),这两个任务的功能如下：
' m+ B  q9 k( Q) X" i3 Q4 I
start_task():创建另外一个任务。

: J5 u3 r/ y. y, @$ E9 iinterrupt_task()：中断测试任务，任务中会调用FreeRTOS的关中断函数将中断关闭一段时间。

03. 程序设计与分析
任务设置

; g+ U9 o# h3 Y# v

1. //任务优先级
   
2. #define START_TASK_PRIO                        1
   * O6 x. {* f) v0 f  M. O+ D1 L
3. //任务堆栈大小        
   
4. #define START_STK_SIZE                         256  
   % c+ [# Y- ^% n7 {* G
5. //任务句柄
   ! T! k( y# S6 r- W& j4 x2 E- K
6. TaskHandle_t StartTask_Handler;
   8 U# z7 h4 V9 l9 h9 o
7. //任务函数
   * k! L% P3 V6 H# M+ O. r% c  E
8. void start_task(void *pvParameters);
   
9. 
   7 A! s* g. J) }. [/ F% z
10. //任务优先级
    
11. #define INTERRUPT_TASK_PRIO                2
    1 q( d! O/ e& V. K+ b' L9 ^, J; d$ i
12. //任务堆栈大小        
    
13. #define INTERRUPT_STK_SIZE                 256  
    
14. //任务句柄
    ( _* N0 Z- {& v/ K) r
15. TaskHandle_t INTERRUPTTask_Handler;
    
16. //任务函数
    ! J- t) q$ y8 P
17. void interrupt_task(void *p_arg);

复制代码

* {% e5 |- M2 M( U" ~7 X9 X& W主函数设计

1. int main(void)
   
2. {
   
3.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
   
4.         delay_init(168);                                        //初始化延时函数
   ; |/ M& U/ i1 c8 P
5.         uart_init(115200);                                     //初始化串口
   
6.         LED_Init();                                                //初始化LED端口
   . d/ m& q5 ~  G+ o) `) m& V, m! s
7.         TIM3_Int_Init(10000-1,8400-1);                //初始化定时器3，定时器周期1S
   6 F9 ]/ v$ B# y1 P$ M# {
8.         TIM5_Int_Init(10000-1,8400-1);                //初始化定时器5，定时器周期1S
   ) r8 G3 o& N* r+ |
9.         
   & M, R  h, n$ |+ A
10.         //创建开始任务
    5 D" [( N# y2 j: B" z
11.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    * [* m6 c! I# c. ~9 k+ z
12.                 (const char*    )"start_task",          //任务名称
    ! T; i- p; h! O$ W
13.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    % c. \8 ^1 Q5 V) a
14.                 (void*          )NULL,                  //传递给任务函数的参数
    , }/ H4 n5 b% v/ m8 z
15.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
16.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
17.     vTaskStartScheduler();          //开启任务调度
    
18. }

复制代码

任务函数设计

1. //开始任务任务函数
   ' o+ N+ a+ Z& a( c, w& {4 d
2. void start_task(void *pvParameters)
   
3. {
   
4.     taskENTER_CRITICAL();           //进入临界区
   
5.     //创建中断测试任务
   ' z1 }2 m9 I+ L1 M1 H- {
6.     xTaskCreate((TaskFunction_t )interrupt_task,                          //任务函数
   ! P4 o8 [! c4 S4 X( D
7.                 (const char*    )"interrupt_task",                         //任务名称
   $ e6 p" V7 Y. x: ^9 Z8 H; p
8.                 (uint16_t       )INTERRUPT_STK_SIZE,                //任务堆栈大小
   
9.                 (void*          )NULL,                                                //传递给任务函数的参数
     L: h& R! \5 L2 ^
10.                 (UBaseType_t    )INTERRUPT_TASK_PRIO,                //任务优先级
    + a, U$ t/ h+ k
11.                 (TaskHandle_t*  )&INTERRUPTTask_Handler);         //任务句柄
    
12.         vTaskDelete(StartTask_Handler); //删除开始任务
    # c- `) x3 i' k$ z  N5 O" V
13.     taskEXIT_CRITICAL();            //退出临界区
    ' g9 p* f  t: E& [2 W- w; W
14. }
    8 R& t0 e* Z# A/ j1 N. Y
15. 
    # \/ x) R9 h3 c2 P1 B
16. //中断测试任务函数
    
17. void interrupt_task(void *pvParameters)
    : ~, e1 ?9 L5 M) H) E% J1 p. {
18. {
    3 p2 ?: p  I. {- c" ?
19.         static u32 total_num=0;
    1 |4 [/ M" y9 i  a4 V9 u
20.     while(1)
    
21.     {
    
22.                 total_num+=1;
    
23.                 if(total_num==5)
    & @" Z% q8 D, G) D6 q7 R& D
24.                 {
    0 L) k3 {1 n) P
25.                         printf("关闭中断.............\r\n");
    
26.                         portDISABLE_INTERRUPTS();                                //关闭中断
    : T* B: u5 Z0 p: F$ p
27.                         delay_xms(5000);                                                //延时5s
    ; H: g: \* o1 r7 s( v/ r; ?
28.                         printf("打开中断.............\r\n");        //打开中断
    
29.                         portENABLE_INTERRUPTS();
    2 J* C* M! Z4 s) Q, O
30.                 }
    
31.         LED0=~LED0;
    
32.         vTaskDelay(1000);
    1 O2 d3 z! o$ x; g
33.     }
    
34. }  

复制代码

$ q6 g; V) V; @: `  ?04. 中断初始化
. i2 X  ~' [7 b
- I' F  Y- @! A' a

1. //通用定时器3中断初始化
   ; b* |& s9 S4 |1 J
2. //arr：自动重装值。
     g7 N4 M2 \; e* x# ^/ z; E5 B4 h
3. //psc：时钟预分频数
   $ z. K6 G) j2 j
4. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
   
5. //Ft=定时器工作频率,单位:Mhz
   
6. //这里使用的是定时器3!
   
7. void TIM3_Int_Init(u16 arr,u16 psc)
   
8. {
   
9.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
   ' u+ j! m6 x' c3 g, E$ K( K4 T; L. f) T
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11.         
    
12.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);  ///使能TIM3时钟
    3 ]3 r3 @' T# g
13.         
    
14.         TIM_TimeBaseInitStructure.TIM_Period = arr;         //自动重装载值
    
15.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;  //定时器分频
    7 a/ S# o" Y: v4 {" U' i0 y8 B
16.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
17.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
18.         
    ( K- q2 y" B- h* ]. g, H9 r
19.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitStructure);//初始化TIM3
    ' @, |) {; [1 J9 t
20.         
    
21.         TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //允许定时器3更新中断
    
22.         TIM_Cmd(TIM3,ENABLE); //使能定时器3
    
23.         
    
24.         NVIC_InitStructure.NVIC_IRQChannel=TIM3_IRQn; //定时器3中断
    ! o* ]* O; [" h& Z! b# v% o
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x04; //抢占优先级4
    ( A4 T. e- `, s( A( U
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00; //子优先级0
    
27.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
28.         NVIC_Init(&NVIC_InitStructure);
    
29. }
    
30. 
    $ a+ S) T! C" B( ~# y2 d
31. //通用定时器5中断初始化
    
32. //arr：自动重装值。
    
33. //psc：时钟预分频数
    
34. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    
35. //Ft=定时器工作频率,单位:Mhz
    $ S; S7 B4 C, K" y: ~) @
36. //这里使用的是定时器5!
    
37. void TIM5_Int_Init(u16 arr,u16 psc)
    
38. {
    8 e2 s- I% C% M
39.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    
40.         NVIC_InitTypeDef NVIC_InitStructure;
    - k6 {5 N$ r# J2 x0 @: Z' W
41.         
    7 _. P8 u1 x* O" ^8 v
42.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5,ENABLE);        //使能TIM5时钟
    0 R5 G5 x: h' [; X( ~
43.         
    ; y$ w9 `/ s8 v$ s7 A$ Z; u
44.         TIM_TimeBaseInitStructure.TIM_Period = arr;                 //自动重装载值
      c& S! c6 k) T- c
45.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;                  //定时器分频
    
46.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
47.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
48.         
    ; n5 m# V' q' k8 m& c/ u) l) S% ^& b. W
49.         TIM_TimeBaseInit(TIM5,&TIM_TimeBaseInitStructure);        //初始化TIM5
    
50.         
    % F" f% P, ]1 r9 U" u
51.         TIM_ITConfig(TIM5,TIM_IT_Update,ENABLE);                         //允许定时器5更新中断
    
52.         TIM_Cmd(TIM5,ENABLE);                                                                 //使能定时器5
    
53.         
    
54.         NVIC_InitStructure.NVIC_IRQChannel=TIM5_IRQn;                 //定时器5中断
    3 o- i1 |/ Y( T* l% x/ V
55.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x05;         //抢占优先级5
    & Z- P1 A* d  z8 H8 t0 h+ `3 k
56.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;                 //子优先级0
    + {$ K; O; c* x, N5 X" S5 j1 D
57.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    ' u- T/ N: k. C# [2 C  L
58.         NVIC_Init(&NVIC_InitStructure);
    + l$ w. ^6 o. Q7 I/ S5 D8 c$ U8 R8 |1 ~" K
59. }
    
60. 
    
61. //定时器3中断服务函数
    
62. void TIM3_IRQHandler(void)
    ( S, ~" u) a% ~# p, U" V  J
63. {
    1 `4 H8 z8 V9 d7 `* u1 ]
64.         if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET) //溢出中断
    
65.         {
    
66.                 printf("TIM3输出.......\r\n");
    3 G9 Z4 N2 s, x0 V5 Y' t' C4 R
67.         }
    
68.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //清除中断标志位
    
69. }
    
70. 
    ( T$ [; _; Z3 P+ q6 V
71. 
    ; Q' m/ z& g; W  \
72. //定时器5中断服务函数
    
73. void TIM5_IRQHandler(void)
    
74. {
    + x# B8 _: U0 n! ?6 A' Z1 P+ C1 C$ h+ `
75.         if(TIM_GetITStatus(TIM5,TIM_IT_Update)==SET) //溢出中断
    
76.         {
    / X! |+ \, Y; F8 D
77.                 printf("TIM5输出.......\r\n");
    + }  b! p3 `) ~* O% y
78.         }
    & U# B3 u3 Y: J/ x$ w. U
79.         TIM_ClearITPendingBit(TIM5,TIM_IT_Update);  //清除中断标志位
    ) b0 v$ |1 H3 c5 O5 g7 g
80. }

复制代码

05. 程序设计
( b) v% f# J# ]3 a: t/ Rmain.c文件

1. 
   * d/ k+ F& ^; R1 l- l0 c- e# s
2. //任务优先级
   - o& K" J/ W8 _' W) X$ D8 [
3. #define START_TASK_PRIO                        1
   , Z" f. l( K" Q( b% q
4. //任务堆栈大小        
   0 b# h8 }2 {3 y% B4 u
5. #define START_STK_SIZE                         256  
   
6. //任务句柄
   & B5 H* S) J2 `. d
7. TaskHandle_t StartTask_Handler;
   
8. //任务函数
   
9. void start_task(void *pvParameters);
   ; ?5 z4 N5 t. I2 N9 J+ e0 V
10. 
    ) [  u3 [- k1 H. G7 Z! H$ D, R
11. //任务优先级
    
12. #define INTERRUPT_TASK_PRIO                2
    # g0 M, \% l. d  {3 U. [4 x: M# a
13. //任务堆栈大小        
    4 o( x& Z, m: T* }% I1 s5 E
14. #define INTERRUPT_STK_SIZE                 256  
    
15. //任务句柄
    : {( M: q6 J1 e: _8 s
16. TaskHandle_t INTERRUPTTask_Handler;
    
17. //任务函数
    % f5 B" C. F! t, \( X0 Z% Y
18. void interrupt_task(void *p_arg);
    ' Z2 H3 J' F3 d- {
19. 
    
20. int main(void)
    7 F2 C, L3 X9 W" }  }$ N) y. m8 ]
21. {
    2 d' F8 X0 m4 m0 Q  n
22.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    
23.         delay_init(168);                                        //初始化延时函数
    0 L* P8 C$ c; k, l! u& t
24.         uart_init(115200);                                     //初始化串口
    , E5 d0 }( M; F+ F, ]2 H* T* Q. v, f
25.         LED_Init();                                                //初始化LED端口
    
26.         TIM3_Int_Init(10000-1,8400-1);                //初始化定时器3，定时器周期1S
    
27.         TIM5_Int_Init(10000-1,8400-1);                //初始化定时器5，定时器周期1S
    " {$ _* ]: }( v9 Y. g9 H& F
28.         
    
29.         //创建开始任务
    
30.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    , e/ e2 R8 Y" R/ l9 I6 v4 h
31.                 (const char*    )"start_task",          //任务名称
    - U6 l( b! r& [5 L  Y( R+ V6 k
32.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
33.                 (void*          )NULL,                  //传递给任务函数的参数
    
34.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    ! {2 E' ^* A) n  B/ M4 T+ F* Q* p
35.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    6 Q* s; L  f! d5 T2 c5 d' d
36.     vTaskStartScheduler();          //开启任务调度
    : w2 A; C7 S- Q  T1 |- r9 {2 X
37. }
    
38. 
    
39. //开始任务任务函数
    
40. void start_task(void *pvParameters)
    
41. {
    ( |0 D: I, ?! e2 j# o* w3 z
42.     taskENTER_CRITICAL();           //进入临界区
    
43.     //创建中断测试任务
    
44.     xTaskCreate((TaskFunction_t )interrupt_task,                          //任务函数
    
45.                 (const char*    )"interrupt_task",                         //任务名称
    
46.                 (uint16_t       )INTERRUPT_STK_SIZE,                //任务堆栈大小
    
47.                 (void*          )NULL,                                                //传递给任务函数的参数
    % _  Z" E6 ]. u: s, d/ q( s
48.                 (UBaseType_t    )INTERRUPT_TASK_PRIO,                //任务优先级
    
49.                 (TaskHandle_t*  )&INTERRUPTTask_Handler);         //任务句柄
    
50.         vTaskDelete(StartTask_Handler); //删除开始任务
    
51.     taskEXIT_CRITICAL();            //退出临界区
    * G( d" W0 Q1 s2 C9 u: |
52. }
    4 g  G7 c+ Q" l6 v# Y+ z
53. 
    1 G8 ]. q# N, r
54. //中断测试任务函数
    
55. void interrupt_task(void *pvParameters)
    % @0 k' _$ E. `3 T8 e* ]# q) H# {  Y
56. {
    
57.         static u32 total_num=0;
    & t7 v  U# r0 k5 r2 V
58.     while(1)
    
59.     {
    
60.                 total_num+=1;
    % f* w* a6 Z# g: o3 R
61.                 if(total_num==5)
    
62.                 {
    & O8 l/ F2 W  H
63.                         printf("关闭中断.............\r\n");
    
64.                         portDISABLE_INTERRUPTS();                                //关闭中断
    
65.                         delay_xms(5000);                                                //延时5s
    - A& g. D, O) O, H  Z
66.                         printf("打开中断.............\r\n");        //打开中断
    
67.                         portENABLE_INTERRUPTS();
    ' M# D& K; e. Q+ ]
68.                 }
    3 \0 g+ q7 a- H. O' O$ R: b
69.         LED0=~LED0;
    
70.         vTaskDelay(1000);
    * C0 G: s; ?8 H' c1 y, g8 ^
71.     }
    - y. t5 L- D, y1 l+ C0 i
72. }  

复制代码

timer.c文件

1. 
   
2. //通用定时器3中断初始化
   
3. //arr：自动重装值。
   
4. //psc：时钟预分频数
   $ Q, e; ?4 X4 R4 a
5. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
   + ~3 g1 [" G$ B5 \' f
6. //Ft=定时器工作频率,单位:Mhz
   
7. //这里使用的是定时器3!
   
8. void TIM3_Int_Init(u16 arr,u16 psc)
   
9. {
   
10.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    " t5 j/ Z, Z/ I% d3 ^, f
11.         NVIC_InitTypeDef NVIC_InitStructure;
    
12.         
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);  ///使能TIM3时钟
    
14.         
    
15.         TIM_TimeBaseInitStructure.TIM_Period = arr;         //自动重装载值
    0 I7 E9 [3 u9 N$ l( l. f
16.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;  //定时器分频
    
17.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    
18.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    
19.         
    . S3 x* C8 g0 W# V& M5 G, W
20.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitStructure);//初始化TIM3
    ) X: u$ F7 D% j) a# i* N  M" D- K+ j
21.         
    
22.         TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //允许定时器3更新中断
    1 P5 G- ^/ X+ V7 ?- `7 [8 n
23.         TIM_Cmd(TIM3,ENABLE); //使能定时器3
    
24.         
      M; K4 ?; ]- h* L! v1 |6 z3 E5 W
25.         NVIC_InitStructure.NVIC_IRQChannel=TIM3_IRQn; //定时器3中断
    2 [1 e: a# ]& Y3 M% w, c. z1 s- p
26.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x04; //抢占优先级4
    & O* l& d% V5 k/ s% k; h0 h( i& V4 h
27.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00; //子优先级0
    
28.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
29.         NVIC_Init(&NVIC_InitStructure);
    . F$ F: a1 w  R% x; `' Q6 [
30. }
    
31. 
    / }  r+ k9 p( Z) V
32. //通用定时器5中断初始化
    
33. //arr：自动重装值。
    
34. //psc：时钟预分频数
    ' J- \. o2 K- U2 j. w2 C# D* j
35. //定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.
    
36. //Ft=定时器工作频率,单位:Mhz
    
37. //这里使用的是定时器5!
    
38. void TIM5_Int_Init(u16 arr,u16 psc)
    
39. {
    9 }5 g8 x1 ^0 x; {% b8 o: z- W6 M
40.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
    8 M+ Y: V9 O! n) a' O1 ^6 |2 g
41.         NVIC_InitTypeDef NVIC_InitStructure;
    % n* i  [5 U- G" h+ w7 g
42.         
    
43.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5,ENABLE);        //使能TIM5时钟
    
44.         
    
45.         TIM_TimeBaseInitStructure.TIM_Period = arr;                 //自动重装载值
    
46.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;                  //定时器分频
    
47.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up; //向上计数模式
    ' `; r8 }* Y4 B5 }
48.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    6 b1 y8 G2 B8 g0 [; q! n/ }
49.         
    
50.         TIM_TimeBaseInit(TIM5,&TIM_TimeBaseInitStructure);        //初始化TIM5
    # c+ g, L1 q$ Q
51.         
    8 s# F- ]  q; A8 ~  D5 |; L4 I
52.         TIM_ITConfig(TIM5,TIM_IT_Update,ENABLE);                         //允许定时器5更新中断
    4 x  d+ _) g$ V" o( @* p
53.         TIM_Cmd(TIM5,ENABLE);                                                                 //使能定时器5
    + ~; g- `% c; E8 v; t& d
54.         
    / }8 Y# K( |; g: K
55.         NVIC_InitStructure.NVIC_IRQChannel=TIM5_IRQn;                 //定时器5中断
    $ h2 g7 {0 V+ D9 k9 @$ a
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x05;         //抢占优先级5
    
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;                 //子优先级0
    
58.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
59.         NVIC_Init(&NVIC_InitStructure);
    
60. }
    
61. 
    
62. //定时器3中断服务函数
    1 l$ G5 r9 i& V( Z. l
63. void TIM3_IRQHandler(void)
    ! ^' ]0 j# _( k6 A7 z! ?
64. {
    # [" p. u$ a1 ~. D* @
65.         if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET) //溢出中断
    
66.         {
    
67.                 printf("TIM3输出.......\r\n");
    / T0 q9 E/ x+ e6 {. ?" [8 g
68.         }
    0 m' h6 g& ?+ i/ n/ p
69.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //清除中断标志位
    ( g# P2 A) R7 E! r; \2 H3 m
70. }
    9 @4 F! b' f6 G6 Q) \; V- _% g
71. 
    ( o% R& a5 L, f
72. 
    
73. //定时器5中断服务函数
    5 D* n8 `8 i; b. R2 v$ K% H0 N1 ^
74. void TIM5_IRQHandler(void)
    8 }3 m/ }2 W' t5 s' m% l/ A* S
75. {
    
76.         if(TIM_GetITStatus(TIM5,TIM_IT_Update)==SET) //溢出中断
    
77.         {
    5 p5 C: y8 [: u; n
78.                 printf("TIM5输出.......\r\n");
    ) R% H2 c/ P( x) i& p
79.         }
    
80.         TIM_ClearITPendingBit(TIM5,TIM_IT_Update);  //清除中断标志位
    
81. }

复制代码

+ q* o* k7 Z- R
% e9 b/ Q* \3 y( l: i# Z0 l