你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

【经验分享】FreeRTOS任务挂起和恢复示例

[复制链接]
STMCU小助手 发布时间：2022-3-26 14:00
01. 概述# g  ?6 F% x5 ~; e0 _
任务挂起和恢复，当某个任务要停止运行一段时间就可以将这个任务挂起，当要重新运行这个任务的话就恢复这个任务的运行。$ i  j7 {" G5 T3 i% B4 }1 S
8 o. k* H( ]  j2 a: Z) h" k- Y
02. 功能描述
0 C* j& q, F+ f" C. @( e, F设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：6 Z8 u3 b6 i5 C- f) p! E

, m" Z# C! e, }, c! {start_task: 用来创建其它两个任务。
3 ^% u! u/ \/ |# s; G% G, T0 F& E$ l2 ]' S4 X$ Y! J! K$ x8 I
task1_task: 当此任务运行5秒以后就会调用函数vTaskSuspend()挂起任务task2_task，当此任务运行10秒以后就会调用函数vTaskResume()恢复任务task2_task该任务控制LED0的闪烁，并且周期性的输出信息到串口中。, e" F3 U2 ]2 \7 c
. T! V) V) P4 ^( r( n
task2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。1 a2 W' \) ~1 P$ H0 }8 E
8 k* @, @2 u. ~* E
03. 任务设计9 E2 T4 }, Q; n& O" s% v
任务优先级，堆栈大小，任务句柄和任务函数6 o0 Q" A( L) y! j6 x% O; [

$ \/ C5 N: ?7 X0 o
  1. //任务优先级
    " s6 O0 \! f7 k* f* r1 r0 ?
  2. #define START_TASK_PRIO                1
    - j* h; B7 h7 K: s. i
  3. //任务堆栈大小        
    - {  `4 D9 P$ t& M
  4. #define START_STK_SIZE                 128  - o2 w2 D. T) y) n
  5. //任务句柄! U. e3 n. ?2 ~1 q' M
  6. TaskHandle_t StartTask_Handler;
    6 t" q! t3 i7 U$ e; B; p. U7 ^  T
  7. //任务函数* r7 B. S$ _! i& s9 t# J
  8. void start_task(void *pvParameters);2 F  h- H+ `3 F0 n$ s

  9. - x8 Y- C! _$ F6 F
  10. //任务优先级0 }( W0 T1 s4 X! M! ]4 ^
  11. #define TASK1_TASK_PRIO                2* p) w8 K4 _% L
  12. //任务堆栈大小        1 b) K; w7 C. f* }9 W1 Q
  13. #define TASK1_STK_SIZE                 50  
    - X) y+ c" l; W$ ]# e
  14. //任务句柄
    ; e# J" a  D& Y# s: G* L
  15. TaskHandle_t Task1Task_Handler;
    3 Z' S2 K7 [3 R2 g0 M2 X! M/ `5 |
  16. //任务函数
    2 y0 E1 E# r5 l1 P  A! N2 Y
  17. void task1_task(void *pvParameters);8 g( I" {( k" n( m3 n& C3 Y5 M
  18. / }, k. x; O+ h0 `8 [% ]3 j0 y
  19. //任务优先级5 G2 U  l, p6 u% ]2 u3 S+ \5 x) W  t
  20. #define TASK2_TASK_PRIO                3
    - S6 Y! {0 v+ r; Y; \' W  g
  21. //任务堆栈大小        
    & d$ S, ~1 u9 S% y9 C! ~8 E( R
  22. #define TASK2_STK_SIZE                 50  
    % E/ M0 D& L1 C
  23. //任务句柄
    2 p" k$ D+ ?% W& x# ^. n
  24. TaskHandle_t Task2Task_Handler;# d% N+ Y; ]$ M8 c
  25. //任务函数
    1 J( z/ K% F3 _5 u8 i3 V
  26. void task2_task(void *pvParameters);
    2 o# p, w! h5 x; s7 b; U
复制代码
& X2 s0 N$ Z" ~' ]9 V. h
start_task函数
, N9 i$ B7 c) G5 c+ x
- |; V4 n1 w/ w1 Z: p0 L2 p
  1. //开始任务任务函数0 w' r) c) g" \( o, n2 ?  A
  2. void start_task(void *pvParameters), A0 s0 ?; E' y& L& k
  3. {
    * H. H  O$ E1 K' `" V" S( }
  4.     taskENTER_CRITICAL();           //进入临界区4 Z+ v1 _. X, k% E# C
  5.         
    2 p# Z( K! A- _8 F( I
  6.     //创建TASK1任务
    ) L7 \( p; x2 A, P0 g! j3 D/ i" N  J
  7.     xTaskCreate((TaskFunction_t )task1_task,             $ E: W# V0 {) e# Z
  8.                 (const char*    )"task1_task",           ( Y0 C2 X! H9 d' C3 `' B
  9.                 (uint16_t       )TASK1_STK_SIZE,
    / y( [, r* E& r/ Q
  10.                 (void*          )NULL,                                $ y4 h' L" j( i! j8 K* u
  11.                 (UBaseType_t    )TASK1_TASK_PRIO,        * r6 f- i& L& q$ L- h8 o5 p
  12.                 (TaskHandle_t*  )&Task1Task_Handler);   
    : {0 N$ \/ n+ g" c+ X5 }; c
  13.     //创建TASK2任务1 n  n2 K# G, l& h- f% Z
  14.     xTaskCreate((TaskFunction_t )task2_task,     
    ) t* i& |  d, E
  15.                 (const char*    )"task2_task",   . U( v0 }, I/ ^+ Z
  16.                 (uint16_t       )TASK2_STK_SIZE,
      y7 R- V* H& ~
  17.                 (void*          )NULL,
    0 e, Q. t+ v( z  ~& g
  18.                 (UBaseType_t    )TASK2_TASK_PRIO,
      Z! `/ Z6 v; v. O/ u& b3 \
  19.                 (TaskHandle_t*  )&Task2Task_Handler);        
    7 O! ^7 q/ Y: s: C
  20. + c( n0 @6 D( B" Z5 z2 n
  21.     vTaskDelete(StartTask_Handler); //删除开始任务, ]) {! ^( m8 Y* q/ X7 ~
  22.                                 6 R" X# c3 f. R
  23.     taskEXIT_CRITICAL();            //退出临界区* Z; Q1 \9 O9 \4 |! w* i! t7 M2 @- `
  24. }
    ' h! {( A% X& V0 R
复制代码
% f  I- m# z1 z* N- A" g8 B
task1_task函数# W# \8 |+ W! P+ T- U% |7 |: K4 q

' N, m3 M$ Q% R$ X, i: V, [0 O
  1. //任务10 j3 z5 c  z9 o5 z
  2. void task1_task(void *pvParameters)
    & y) U$ X) m0 a. b/ o
  3. {+ @# M9 F! N, ~, |5 E
  4.         u8 task1_num = 0;% S0 x0 `5 t2 F. ?  I
  5.         
    # b2 K: g" [/ z9 {& s% a
  6.         while(1)
    + }( F" L% C/ V) Z
  7.         {
    ) d# d, n* ]; F( _
  8.                 task1_num++;
    . h- a9 W- |* X% J6 z
  9.                 LED0 = !LED0;
    7 z/ ~; D9 M9 t
  10.                 printf("任务1已经运行%d次\r\n", task1_num);
    5 v) L  {' O! z" q9 ]7 t9 u
  11.         7 {6 g! Q; N! g2 z1 x3 H
  12.                 if (5 == task1_num)5 m9 ?4 S$ d1 j; b& m
  13.                 {
    " Q  U- i; ~( Z
  14.                         //任务1挂起任务2
    2 f& }8 |: E" ~& P# a4 d5 b% U: b9 l* d
  15.                         vTaskSuspend( Task2Task_Handler);' z1 Y2 a' M. C% p$ f  s1 @9 u
  16.                         printf("任务1挂起了任务2\r\n");
    ' F4 {0 N7 Z. p- a# O
  17.                 }9 w8 J5 E" i) L4 B/ Y1 I
  18.                
    * z. r* `8 M7 Q
  19.                 if(10 == task1_num), ?9 ?, h3 v' N6 O$ B
  20.                 {
    ) Z. B+ F7 Q  v
  21.                         //任务1恢复任务2# E5 v. w8 t& |1 U. _
  22.                         vTaskResume(Task2Task_Handler);4 A8 A. p6 }1 W+ B% t
  23.                         printf("任务1恢复了任务2\r\n");
    ( _+ A6 ^( v& Y( ]
  24.                 }
    : J4 @. h% X4 O" I0 @
  25.                
    2 ~8 q' q# _' J! F1 O( k, c' ~4 m
  26.                 //延时1秒 1000个时钟节拍
    5 i3 X* R/ ?4 t5 C
  27.                 vTaskDelay(1000);9 g4 T/ l5 C& d: `; |
  28.         }) p$ j/ `- g. m" {" r& ?& k9 N
  29. }
    5 A8 l8 ~. `4 F4 ~5 a
复制代码
- ]; p) A; J6 [9 z" ?3 G
task2_task函数
, W2 U$ t! `4 n9 ]6 z) N! R! F. C4 T9 g! h5 t- D) {
  1. //任务24 N2 k/ I4 d1 j! z+ |6 m; U0 f  u9 V
  2. void task2_task(void *pvParameters)% X# b; v1 x4 m! h% g; k8 [
  3. {
    + C# O: c: q& J0 g& d
  4.         u8 task2_num = 0;
    % L) ~9 @9 X0 _# l3 C( x
  5.         " G; c' ^: `( a+ [- c  ~
  6.         while(1)
    : a7 G, l1 c# M" g4 f- N
  7.         {
    9 v2 \( t9 }. n. Q7 r! R; t
  8.                 task2_num++;* g/ z! v4 n  z% q1 h( X* ~/ Q
  9.                 LED1 = !LED1;
    . _4 k/ k" M( Y& ^1 X
  10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    5 \; o+ ?% k. A2 s
  11.                
    ) z) O! j7 H" ?. T# Y8 u0 @# D
  12.                 //延时1秒 1000个时钟节拍8 Z: p8 m2 b, l7 p1 _6 q' \; l
  13.                 vTaskDelay(1000);! j7 Z7 [6 {, m. b" a
  14.         }
    ' |' ]! R8 I% ?* }& N- H' Y) F" D
  15. }
复制代码

, g) g3 K5 i6 u1 W+ A: `; h5 W; }04. 程序设计
* g% ]5 P) z9 G3 {2 \4 Nmain.c文件$ W" u/ `$ d. C  P7 j- H$ v' T+ |
' H- y7 x& t* ?: ?
  1. #include "sys.h"
    7 X/ f, {0 \9 c+ z- a/ A
  2. #include "delay.h"
    ( j4 z. Q( l( v7 a9 [; r# I
  3. #include "usart.h": v( R& Q  A: L: v! I
  4. #include "led.h"& ]$ U* O: l. o4 F; k  z' c# F
  5. #include "FreeRTOS.h"% |& }& g  n" Z/ P, g
  6. #include "task.h"
    + @4 x" n9 E! h
  7. . a" \+ g# ?( w6 Y+ L, b8 _

  8. . G4 w. G0 ]  }8 F" x
  9. //任务优先级+ A/ g! E6 I- v( U! }  i
  10. #define START_TASK_PRIO                1
    ; f: P" I% }# R) e3 e
  11. //任务堆栈大小        1 J  d/ I, v! K; e+ Z
  12. #define START_STK_SIZE                 128  
    ! T, K2 O" d5 Z; H
  13. //任务句柄% `" i, Z$ ^% [1 }) C0 l
  14. TaskHandle_t StartTask_Handler;8 L& v" i. N4 p6 Y+ o
  15. //任务函数
    ) o0 \* w7 |4 Q1 u  H! m
  16. void start_task(void *pvParameters);! ?. \9 k5 k4 V

  17. 5 V- ^9 m7 ]  ]8 N
  18. //任务优先级  _# `- t5 f9 r# C& d7 w$ V3 _, `
  19. #define TASK1_TASK_PRIO                2
    " g. C# k' D# g9 w9 P
  20. //任务堆栈大小        9 q5 z$ K8 I( T  f: ]9 D) e7 K8 b
  21. #define TASK1_STK_SIZE                 50  5 }; ?0 H, \, E! x7 }: j( P7 m. B
  22. //任务句柄
    : H! B. s, {& H) X6 {
  23. TaskHandle_t Task1Task_Handler;
    & Q9 e1 \' e3 b, N
  24. //任务函数8 n+ N& Z8 c+ M* V9 _
  25. void task1_task(void *pvParameters);' @* z7 K4 Y, i' L( e
  26. ! H; ~. b. s& s  W
  27. //任务优先级% u" S2 A5 p- s' J- _* \
  28. #define TASK2_TASK_PRIO                3: U1 @* w2 |  u
  29. //任务堆栈大小        + \  b; I5 d3 Y9 t
  30. #define TASK2_STK_SIZE                 50  + a4 D6 Q, q4 g9 {7 |1 X
  31. //任务句柄
    * z/ J6 J- u+ z# y6 M4 u
  32. TaskHandle_t Task2Task_Handler;5 ]* O4 J8 r/ l; x! [- f% d# o
  33. //任务函数
    & j8 O7 ~4 w+ ?
  34. void task2_task(void *pvParameters);4 m. E. s! z" ]! |# U* n/ S' o

  35. / [/ @2 h7 D# W0 t
  36. 2 z0 K# H1 q8 f- x) r$ c9 Y
  37. //主函数
    # f+ s4 L7 O. ~7 ~
  38. int main(void)
    ( q' E" A! `/ ^7 B
  39. { + `& W+ I7 [8 e3 T# c" p! P1 {
  40.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    ' y3 x" n, H) E" Q
  41.         delay_init(168);                //初始化延时函数
    , E2 t$ X; `# _; A, ~6 ~+ R
  42.         uart_init(115200);             //初始化串口! C! }8 F5 T7 h. E" M
  43.         LED_Init();                        //初始化LED端口
    5 i& g' Z' |/ G  k9 y
  44.         8 d  R- Q) p6 p; n; x% ^. `
  45.         //创建开始任务4 Z1 K" y% t9 c9 V! }2 ]) ~! k" i
  46.     xTaskCreate((TaskFunction_t )start_task,            //任务函数4 D6 V3 B  B! g' {
  47.                 (const char*    )"start_task",          //任务名称, P( [: u/ b$ P* u  b+ B% z9 L) U
  48.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小- J6 G" M  ]4 r
  49.                 (void*          )NULL,                  //传递给任务函数的参数
    3 E1 l) Y% ^; X& Y: W
  50.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级4 V0 @, W6 i. \  @- ~( J( R) g( z
  51.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    # |* Z( f6 I% a/ K* X. L$ E
  52.     vTaskStartScheduler();          //开启任务调度$ n" x2 Z/ C  s0 F4 ~8 ~) G% a% F
  53. }
      U6 y# v( o( H. Z
  54. , Y0 R4 i6 E3 T
  55. //开始任务任务函数& ]( k5 U% L! X# d" p. L
  56. void start_task(void *pvParameters)
    ! C0 y5 `  |% H4 [! w, @0 f- a" r$ f+ q
  57. {
    ' I4 Q6 m$ x$ v1 d$ [
  58.     taskENTER_CRITICAL();           //进入临界区  J. \8 z. J: P) v
  59.         
    * Z% y+ i3 B  \7 F! h0 C
  60.     //创建TASK1任务
    * n% z% u- z. @8 L' e3 J  k4 C
  61.     xTaskCreate((TaskFunction_t )task1_task,             / F+ q& q) s( e- Q( G7 w# ]
  62.                 (const char*    )"task1_task",           5 f6 C3 W0 ~  i- h. m
  63.                 (uint16_t       )TASK1_STK_SIZE,
    2 E3 }. D. s. `8 Y
  64.                 (void*          )NULL,                                9 ]) \+ h1 }. w  D+ V
  65.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    ; |, R' i. c1 A& q' |8 |8 J
  66.                 (TaskHandle_t*  )&Task1Task_Handler);   
    , `4 T& s8 [  K2 O  r
  67.     //创建TASK2任务
    / L, m9 {, }, `
  68.     xTaskCreate((TaskFunction_t )task2_task,     
    & ~0 O2 q! [5 q
  69.                 (const char*    )"task2_task",   
      z! g/ F+ Y: s3 \
  70.                 (uint16_t       )TASK2_STK_SIZE, 2 Q7 j% S! v/ j, d7 u: z
  71.                 (void*          )NULL,+ K+ A& H  @9 h" X
  72.                 (UBaseType_t    )TASK2_TASK_PRIO,# P: t, B# ~/ n) r( D3 ?( K; Q+ ^
  73.                 (TaskHandle_t*  )&Task2Task_Handler);        
    ' I4 P/ P. O0 P4 C9 E

  74. : G: n1 |0 Q" f" n1 |& n
  75.     vTaskDelete(StartTask_Handler); //删除开始任务' q8 \7 @, t) s9 o2 N; f  @
  76.                                 
    1 A0 |4 y" R7 @( B
  77.     taskEXIT_CRITICAL();            //退出临界区
      p: u' h, P8 m" x( }; E- A6 S& x
  78. }8 X9 n7 d+ ^# o6 S( D3 z, c

  79. 6 B( C. F( {3 P7 @4 V7 M9 v* U$ G
  80. //任务1
    . U0 [4 W0 y5 i" f) C( v
  81. void task1_task(void *pvParameters); G% o7 n1 u- P5 m  w
  82. {
    . v) I* j! f3 m- Y2 K
  83.         u8 task1_num = 0;6 l! a) _2 w9 t# V& z/ i9 f9 a# {. H
  84.         , H% {! A% ^0 q2 Z" O
  85.         while(1)
    ' N! |+ `) V9 F. i0 s6 Y. F
  86.         {( I) t3 J% v% Q9 j$ D
  87.                 task1_num++;. ~6 l7 M+ v% G: x( h  J' A
  88.                 LED0 = !LED0;8 j4 q1 R8 y9 d" K# B4 X
  89.                 printf("任务1已经运行%d次\r\n", task1_num);
    5 P* |1 g; ^# z# o3 g; }2 Y: a( z
  90.         
    ' S: O, k4 q7 ]0 v0 [2 ~7 {( e. f
  91.                 if (5 == task1_num)' d. X8 y- b9 n3 Z7 a
  92.                 {7 Y+ v! R- Y: d, |. Q$ u( k! w" \
  93.                         //任务1挂起任务2
    ! X' T) }/ }9 i2 }* \
  94.                         vTaskSuspend( Task2Task_Handler);; y7 ^0 t1 o* y
  95.                         printf("任务1挂起了任务2\r\n");" p' G+ E6 r+ `, ~4 b# ]
  96.                 }
    % y8 }# y) g1 M0 b* y6 M
  97.                
    * f% L% G$ H; K0 x
  98.                 if(10 == task1_num)
    4 s4 w/ ^. D6 @( U
  99.                 {
    - q3 ^5 S& |+ [8 q: V( X
  100.                         //任务1恢复任务2
    $ Z  r. U  S* n% ^5 R7 z- b
  101.                         vTaskResume(Task2Task_Handler);
    3 p' w+ }+ j; w5 \
  102.                         printf("任务1恢复了任务2\r\n");
    * ^' i/ f# C) B0 m& x3 ^
  103.                 }) B2 L+ {" p. Y# t, B# z7 \1 z
  104.                   W  p/ Y+ N' c! ]. ~
  105.                 //延时1秒 1000个时钟节拍
    * Y7 c( ~/ A, _0 C
  106.                 vTaskDelay(1000);* \, w5 B- s' \3 P0 J% k9 p
  107.         }
    8 j# s9 K% P" C; b8 o* {6 h4 z  u
  108. }, y7 {5 }4 d1 B$ b" j
  109. - }% \1 k' h2 A3 o
  110. //任务2% C5 K& ~7 C, d& ]: r0 l& y: X7 v, c
  111. void task2_task(void *pvParameters)
    * g' s4 k# g; @' X8 [1 w" A
  112. {
    6 P. C+ [' _& H9 M% m) L/ y3 I
  113.         u8 task2_num = 0;
    - C# O, J- \; F
  114.         
    7 s4 i+ n. g& V" E
  115.         while(1)
    % N: d$ V7 R8 v7 d/ |$ a5 }
  116.         {- Y3 b: [' Z8 q9 O0 G5 m+ g
  117.                 task2_num++;6 D' z' R7 }. G. w
  118.                 LED1 = !LED1;- U, `8 |! G1 R  X" `5 A2 j
  119.                 printf("任务2已经执行了%d次\r\n", task2_num);
    ( }% F. \" m3 k. Z2 C- \' A
  120.                 0 \8 e) g6 j; \& M
  121.                 //延时1秒 1000个时钟节拍
    $ O' m8 e: K5 C) i8 D5 Q* p" W; c
  122.                 vTaskDelay(1000);
    $ n/ p; n  b$ d) s. ]  r0 R
  123.         }
    : H) \2 C2 y: C6 w8 ]
  124. }
复制代码
6 a- R/ Y3 @5 g0 f' S# U0 _' N
05. 执行结果
/ N2 r1 X* d) N" b) Q1 T' ?
  1. 任务2已经执行了1次
    * g+ F9 L, G6 i, ]* g( @3 ~
  2. 任务1已经运行1次* w+ {  d5 w6 P* T( n7 s' r
  3. 任务2已经执行了2次9 y3 X5 r. U4 r' Y
  4. 任务1已经运行2次
    6 d- v# Q7 @$ @$ N
  5. 任务2已经执行了3次2 r& ~0 P0 L7 Q5 s5 O. u
  6. 任务1已经运行3次
    ' g8 l  ?6 _3 X& @0 v
  7. 任务2已经执行了4次0 t, A' |" }( [2 j- O: |; b
  8. 任务1已经运行4次
    2 q+ V1 T: T+ J5 j" e; l6 v
  9. 任务2已经执行了5次
    + h% }4 i) w3 G2 y" Q1 [' w; u
  10. 任务1已经运行5次
    6 v% _' W$ R/ ~
  11. 任务1挂起了任务2$ C( E5 ^" L" l0 M
  12. 任务1已经运行6次7 C+ l8 l' W7 q& v
  13. 任务1已经运行7次4 V$ Z' C" N: [7 ?4 u5 l) ^
  14. 任务1已经运行8次& J1 s2 J) ^& d) f* f$ `7 Z5 V9 e
  15. 任务1已经运行9次1 ~5 M/ @7 ^! v( ]* J$ c3 f. I* T
  16. 任务1已经运行10次
    ( U- z8 H6 H% _
  17. 任务2已经执行了6次- r4 A- V" t) @) m/ K
  18. 任务2已经执行了7次
    3 a( a# o# e8 D
  19. 任务1已经运行11次% ~7 Z: U( p6 |  U; K7 m
  20. 任务2已经执行了8次
    1 c$ [# M* c0 T1 }+ f: F

  21. 1 F! x: f6 R. _
复制代码
) e( U# V' l( `! G& i/ K, C( p

/ O2 M% u! \8 ~5 h; @3 y6 b* {7 N+ ~3 A* u% Z3 D
赞 收藏 评论0 发布时间：2022-3-26 14:00

举报

0个回答

所属标签

STM32团队

STM32团队

意法半导体微控制器和微处理器拥有广泛的产品线，包含低成本的8位单片机和基于ARM® Cortex®-M0、M0+、M3、M4、M33、M7及A7内核并具备丰富外设选择的32位微控制器及微处理器。关注该话题即可发布文章！

最新内容

相似技术帖

官网相关资源

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电（SPD）
区域控制单元（ZCU）与分区架构
关注我们
st-img 微信公众号
st-img 手机版