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

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

【经验分享】STM32 FreeRTOS创建和删除任务示例(动态方法)

[复制链接]
STMCU小助手 发布时间：2022-6-18 17:00
01. 概述
3 ?6 r; o- B/ j8 U4 ]8 MFreeRTOS中创建和删除任务API函数的应用。
. i" U$ @5 p( l- M, F/ P% I% T, R: W, R8 \3 Z$ v0 f
02. 功能描述& u0 k( n8 P1 m" F+ O8 e: z
设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：) p! @% ~9 ^6 F5 k

- ~0 u) u  u, Ostart_task: 用来创建其它两个任务。; c$ x% x$ ]$ A" ^/ G- d% |+ B/ b

# J+ L1 T# p3 m% k2 Etask1_task: 当此任务运行5秒以后就会调用函数vTaskDelete()删除任务task2_task，该任务控制LED0的闪烁，并且周期性的输出信息到串口中。
* G- @! \9 W3 ?3 A  g7 m' I7 z" I# g  a, ^/ ^
task2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。
# |  z, E$ t$ [" O1 h1 ?9 R: D  \8 [- S* S2 p8 |
03. 任务设计, z& k% o" f" s: t" Z3 G" X3 v
任务优先级，堆栈大小，任务句柄和任务函数
: }5 X+ E8 v4 O9 C" o; i3 L: O. @3 W9 X7 Y5 {- T  q0 f
  1. //任务优先级7 r3 t7 {* B. v2 H2 E
  2. #define START_TASK_PRIO                1( ]/ V! O0 W- \3 a/ G/ ]/ {
  3. //任务堆栈大小        : ?! }, K2 t) i  U$ l
  4. #define START_STK_SIZE                 128  
    , ]; j6 v% E1 l6 o. M4 A: x
  5. //任务句柄+ L+ _% |* u0 I+ R. P' ^+ J
  6. TaskHandle_t StartTask_Handler;% I+ u0 v4 w: @  y
  7. //任务函数
    , W7 N, h9 f: y8 O3 h" ^9 o
  8. void start_task(void *pvParameters);
    / g* s+ L+ x6 @) N
  9. 7 z% |5 x- o# k0 ~1 r
  10. //任务优先级* h8 x9 o! B0 l; V* g: g
  11. #define TASK1_TASK_PRIO                2% U6 b5 D/ T4 K# B7 j$ D, f
  12. //任务堆栈大小        ( V( i. {* C$ |; I9 N" \- }" t! g; j
  13. #define TASK1_STK_SIZE                 50  
    . k) @" M6 z# w5 o8 N1 {/ e# m4 M
  14. //任务句柄
    # W9 F# N4 g. g; p1 }# k8 S
  15. TaskHandle_t Task1Task_Handler;
    - E! i- U  d+ q- N% u
  16. //任务函数4 V- |8 z: k  _! A- O
  17. void task1_task(void *pvParameters);
    1 R- u& w7 g5 {  m

  18. + r; R1 O5 n. s  U) L" W3 Q
  19. //任务优先级
    : ^" N1 U/ L2 B7 y' u
  20. #define TASK2_TASK_PRIO                3
    5 f7 b$ v' X3 g9 x! b0 j1 ?1 X' Y
  21. //任务堆栈大小        + \1 P, b  q# i: O9 c$ @$ ^
  22. #define TASK2_STK_SIZE                 50  
    " o" ]% v3 p/ f
  23. //任务句柄* r% H5 V1 P! y* K6 h# M
  24. TaskHandle_t Task2Task_Handler;
    $ s6 Q1 p2 B: ^* m* J: Y- V
  25. //任务函数
    6 i' N3 [/ G, J# O8 a$ V9 ?
  26. void task2_task(void *pvParameters);
复制代码
: `9 p# k4 y/ L" `# ?
start_task函数4 M0 K8 p9 Y% p% j

5 ~5 q* ?# M3 T  X5 n3 _
  1. //开始任务任务函数- E' a) [  j5 d5 S
  2. void start_task(void *pvParameters). i$ R4 y( r4 e. e7 v" q+ I
  3. {
    ; B' c1 C: _) n/ d% Z& m7 M
  4.     taskENTER_CRITICAL();           //进入临界区, x8 f# r, M" s
  5.         
    . j* B* p9 J- [' G! |( ~
  6.     //创建TASK1任务
    * F9 S% y2 H; D' h. ^9 z" C) q
  7.     xTaskCreate((TaskFunction_t )task1_task,             9 V7 m7 x2 h- W" L
  8.                 (const char*    )"task1_task",           ' b" ^9 a4 T0 I
  9.                 (uint16_t       )TASK1_STK_SIZE, 9 m; w4 |8 U: e+ y
  10.                 (void*          )NULL,                                
    9 p% l9 g( o  J5 [
  11.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    . O0 x, l( F4 V+ `( Z
  12.                 (TaskHandle_t*  )&Task1Task_Handler);   
      s6 N. m. S& G3 [& @
  13.     //创建TASK2任务
    # h+ p' p) U% }' ~( C* {
  14.     xTaskCreate((TaskFunction_t )task2_task,     8 U; V1 p! t* ~2 U$ c3 A( J( R' W3 y
  15.                 (const char*    )"task2_task",   
    $ w* ]) Q6 a6 j! _
  16.                 (uint16_t       )TASK2_STK_SIZE, # A  m; U% @+ Z3 n4 k/ K0 I+ h9 v& s
  17.                 (void*          )NULL,
    ! l6 L; u4 a2 f0 m8 A
  18.                 (UBaseType_t    )TASK2_TASK_PRIO,: M$ |/ Z* F! ^
  19.                 (TaskHandle_t*  )&Task2Task_Handler);        6 W, g4 @7 o- p: h( _4 l! v8 L
  20. * r9 D. N7 Q  C# W7 j5 O
  21.     vTaskDelete(StartTask_Handler); //删除开始任务2 T) U/ ?7 z9 J# l
  22.                                 % J. ^& T' M( T
  23.     taskEXIT_CRITICAL();            //退出临界区! w# Z6 v2 W5 p8 S$ U
  24. }
复制代码
( x; p" D* b6 p- h* f
task1_task函数
7 A  D8 A4 ^5 l) }+ i
5 I% \9 M0 y, j/ k6 a
  1. //任务1
    - i% y3 J" T2 i( E7 a# Q
  2. void task1_task(void *pvParameters)
    ' x! M3 k+ X+ y2 k5 v7 P
  3. {
    " L/ K& `# p& u+ U- s
  4.         u8 task1_num = 0;7 M, g) ]  L+ ^& E- I
  5.         
    - C% Y, g7 v4 b( Y
  6.         while(1)
    % H4 t( t% y2 J0 E- o
  7.         {: @5 M1 K+ D0 ?) T6 S
  8.                 task1_num++;
    + _1 y8 I  e# Y5 L' M, x2 k
  9.                 LED0 = !LED0;
    2 Y( v" E8 K4 t0 r
  10.                 printf("任务1已经运行%d次\r\n", task1_num);
    3 }6 \7 \1 S' P' i
  11.         
    5 S: s% _! |0 }  i# t1 e0 h8 m3 O
  12.                 if (5 == task1_num)* Y; o7 [4 K) k  ?& T3 ]0 q! P2 T
  13.                 {$ f! b. q1 |% c. A/ k
  14.                         //任务1删除任务2
    4 S% U" a4 l: _8 D8 V& ]) y
  15.                         vTaskDelete(Task2Task_Handler);& H9 L: J1 f1 S% X+ l
  16.                         printf("任务1删除了任务2\r\n");
    1 J$ f3 ?. a$ a; r
  17.                 }* P( X5 ~5 j: N- Y5 a3 C
  18.                
    - e4 [, R5 s" W) `, }) W
  19.                 //延时1秒 1000个时钟节拍3 v: f; z% n# K1 S3 s& }) _
  20.                 vTaskDelay(1000);' U8 k- n2 t' q+ A1 a! o0 W' Z' e
  21.         }7 t* w  a4 r: p7 O! N
  22. }
复制代码

# P5 t5 ^, O) Y  M4 b5 G+ `' Btask2_task函数) f1 O8 ]4 k& m- `/ k& r4 R5 `# @

- {- H6 x# Q& `" c+ Q0 I1 e2 r
  1. //任务2' O0 w6 v8 O. H( z% k5 o) F
  2. void task2_task(void *pvParameters)
    7 T7 D: G  x& x. A# l
  3. {" v/ b. s* R/ o( N3 Z2 j2 \0 y% f: A
  4.         u8 task2_num = 0;* N$ O* t& D! U
  5.         
    6 j1 f4 w+ m4 E: ]+ t' I0 P" r& ?' q/ i
  6.         while(1)+ q' d( s- S5 }+ @" x/ n6 s$ ~
  7.         {. L2 M. d2 ^0 J: U5 z$ q2 h3 z
  8.                 task2_num++;
    . z" a! b5 v  Q4 L
  9.                 LED1 = !LED1;
    : k4 [8 ~7 ]1 V2 B0 C* z& t
  10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    " C2 W( p$ {0 Y! m* q# n0 m, P: V
  11.                
    4 C) O1 P3 y- U8 R! Z2 z' _% j2 A
  12.                 //延时1秒 1000个时钟节拍
    $ g: H$ W4 i  W
  13.                 vTaskDelay(1000);
    1 m! F& L# K4 Y; I0 f$ w5 Q! }- a
  14.         }8 C1 E, X% X+ r7 g
  15. }
复制代码

, O% s; ^& t! O/ Q' R6 L0 t7 G04. 程序设计
2 J$ l1 f; ?4 G2 k' Emain.c文件
3 \. S7 ?/ _7 g
: E- @* ]2 a- `, A! d
  1. #include "sys.h"7 S3 H- u9 l$ Q8 L
  2. #include "delay.h"
    & y/ z0 {' f7 M$ x9 e1 Z
  3. #include "usart.h"; Q! Z" v4 r' w- [
  4. #include "led.h"
    4 @" J  y4 U! p& ?
  5. #include "FreeRTOS.h"
    9 p; z+ X4 j, ^2 l
  6. #include "task.h"
    , g: m' f( L# b
  7. 4 M% U; i5 r- R' f5 ^' w
  8. 4 S, `: {1 j& X- ^
  9. //任务优先级3 P6 i7 |' Y. k  K2 }9 L
  10. #define START_TASK_PRIO                19 z3 y3 F" C# r0 t. x  Q
  11. //任务堆栈大小        / T1 d9 m' t! r, P) ?1 Z8 k
  12. #define START_STK_SIZE                 128  . ~* n$ |& f) ^: p( F
  13. //任务句柄5 H. ~# S) x0 a2 m+ I6 s9 d. i' Z" y1 ^& \
  14. TaskHandle_t StartTask_Handler;. D3 r* \: P7 C' F
  15. //任务函数9 Y0 c2 n- Q/ K% f0 T; R
  16. void start_task(void *pvParameters);
    " ]$ K$ I! A, q" b! Z, j" o! R
  17. ( d& M$ g" N7 e5 F% {. R
  18. //任务优先级9 W' s1 U) a4 ?- [3 n
  19. #define TASK1_TASK_PRIO                2
    ) a; L, g1 i! w
  20. //任务堆栈大小          Q7 u& c) }/ s. ^  _
  21. #define TASK1_STK_SIZE                 50  
    # a' Z: C1 j/ o: A5 D
  22. //任务句柄
    / D& T- E3 ?$ u& r0 P
  23. TaskHandle_t Task1Task_Handler;9 I: I0 t1 w! z
  24. //任务函数$ M+ A' M3 B& f1 F3 _
  25. void task1_task(void *pvParameters);' w) U* i3 p& K' W8 X
  26. ' q4 a) C' E% G; o
  27. //任务优先级
    ) p$ u- _9 |$ k+ k/ _0 ~7 b
  28. #define TASK2_TASK_PRIO                3
    0 ?9 [9 i% x+ D6 P+ \* h' ?, @
  29. //任务堆栈大小        ' ~6 \& o! M# F: `/ g& G
  30. #define TASK2_STK_SIZE                 50  1 u3 e" a2 D- {
  31. //任务句柄
    , y' \* [, w+ |9 t( \/ j
  32. TaskHandle_t Task2Task_Handler;' M) c9 s5 ~- b. d
  33. //任务函数: n! U  d  |- C- T: m4 e! R
  34. void task2_task(void *pvParameters);% J' }5 F! @" z1 R
  35. 0 j- l$ |- s0 O6 R! E

  36. 4 l# P1 a1 c$ E/ t3 {; e. o! B+ W; o
  37. //主函数6 K' o* n8 \7 Q2 A& C2 m- m7 |/ k. ~
  38. int main(void)
    + o/ T4 Y3 H; K; R! }$ o6 i
  39. {
    ) M! `2 ]& n8 j
  40.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    $ Q1 |4 q" G0 h% G
  41.         delay_init(168);                //初始化延时函数  `  M4 w7 \- C; }; S
  42.         uart_init(115200);             //初始化串口4 \3 J7 m4 E5 @* L) |
  43.         LED_Init();                        //初始化LED端口. H& [" F; ^) p! q2 M9 ^" q8 u
  44.         , }# n3 {% y" G  O
  45.         //创建开始任务7 r9 W& y3 G4 K  z6 d6 i
  46.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    + T7 P; m- p) s4 i' {
  47.                 (const char*    )"start_task",          //任务名称
    , W# R3 I1 q* {7 ^
  48.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    0 G) ?/ N$ y7 Y8 u
  49.                 (void*          )NULL,                  //传递给任务函数的参数
    6 O2 ^  T& o! r
  50.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    8 }. f$ T% o. z" ~" c7 {; }" y
  51.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    . n: P9 F" J( Q$ n- a% ^7 w7 H
  52.     vTaskStartScheduler();          //开启任务调度2 a# a( R, R# [: j
  53. }
    5 f  u8 T# H$ I+ @6 u* t

  54. . e- h$ w- u2 z. v1 f9 m- g
  55. //开始任务任务函数: Y  @/ q6 M9 p1 R) e
  56. void start_task(void *pvParameters)
    % }5 r6 \9 d' g* T! D
  57. {- o) r' ~6 u3 h4 U) a9 Y
  58.     taskENTER_CRITICAL();           //进入临界区! A* ]( i) c7 V# `) \7 F/ C
  59.         ! p3 u% B8 P0 P4 X3 K, e+ J
  60.     //创建TASK1任务
    ! r2 v9 Y  V* R
  61.     xTaskCreate((TaskFunction_t )task1_task,            
    3 m# [% n- v- R1 t4 R+ l
  62.                 (const char*    )"task1_task",           
    / o! Y9 Q/ N4 O% F/ L  F
  63.                 (uint16_t       )TASK1_STK_SIZE, : M) Q, g/ U8 U9 j
  64.                 (void*          )NULL,                                , L" ]% h, ?  B; S7 l
  65.                 (UBaseType_t    )TASK1_TASK_PRIO,        ' z  m& P% i1 z* ?2 Y' ^6 j; [
  66.                 (TaskHandle_t*  )&Task1Task_Handler);   
    1 ~  y8 a2 B0 ~0 s4 J1 `. J
  67.     //创建TASK2任务
    4 j; T( B* J) V/ Y
  68.     xTaskCreate((TaskFunction_t )task2_task,     
    0 C/ K6 \5 Z6 _5 Y# q7 Z  c
  69.                 (const char*    )"task2_task",   
    : A5 X* A1 }7 Y
  70.                 (uint16_t       )TASK2_STK_SIZE,
    ( j/ Y, x0 g( j4 L% T" j
  71.                 (void*          )NULL,
    3 R. s1 u1 v$ l! D
  72.                 (UBaseType_t    )TASK2_TASK_PRIO,3 V5 V7 Z6 o! H/ P8 g( K+ K
  73.                 (TaskHandle_t*  )&Task2Task_Handler);        7 \7 T% y; K& ^% K% A# ~2 H
  74. # [9 u. u! k( K5 M
  75.     vTaskDelete(StartTask_Handler); //删除开始任务( t# s; w+ p/ }
  76.                                 
    % z. n! j& `7 d' m9 F7 c' ]) k
  77.     taskEXIT_CRITICAL();            //退出临界区7 V' C4 y: t% a1 s
  78. }
    . C5 p$ H4 ]0 t- ~! l! f
  79. ! ~% H7 ?/ B  A! _9 w
  80. //任务1* b8 \0 v1 B! [2 s5 @
  81. void task1_task(void *pvParameters)6 J. ~, x" h, T& L5 H5 f
  82. {
    - L( T" t/ L- f+ }
  83.         u8 task1_num = 0;9 Z0 t7 H. O: I% |1 ?- U: H
  84.         6 n7 H, p) ?& S4 ~; c+ }4 t
  85.         while(1)
    ; \. d  x6 }! B; z6 J2 z+ o' }# R
  86.         {
    / S' {# w9 u9 v' R6 o  Z$ b
  87.                 task1_num++;
    & H' H& O% s  \2 v( \
  88.                 LED0 = !LED0;
    ! y& n' O1 A$ X* b' D9 e$ t
  89.                 printf("任务1已经运行%d次\r\n", task1_num);% s: ^% M. Z# f8 [' {
  90.           |6 [) X5 \/ a# L0 q
  91.                 if (5 == task1_num)
    + ~: O( }% t% J; \+ g5 U
  92.                 {0 [0 P1 I: l  ?# _& ~4 ]
  93.                         //任务1删除任务21 f5 y2 ~( C/ Z6 R! w: N
  94.                         vTaskDelete(Task2Task_Handler);* E( Y; V: g# y- }3 t: [6 d; Y
  95.                         printf("任务1删除了任务2\r\n");2 Q: V0 _7 V6 a8 N) ^5 t  k
  96.                 }
    $ s' r. Y; k: t/ V7 w$ Y; j% C, L2 o
  97.                 ' ^3 |8 E4 x4 \2 W
  98.                 //延时1秒 1000个时钟节拍
    : f2 D5 A: k  Y- D
  99.                 vTaskDelay(1000);/ k* P6 H3 g3 E' y& K
  100.         }1 u5 `" i. l2 Z$ `2 ]! _1 r
  101. }
    * u6 U* X) y* |1 [
  102. 5 O5 f( K0 G( o4 [% P/ X- X
  103. //任务2- U$ k0 `. `. c. z' R" j% W
  104. void task2_task(void *pvParameters)1 ~. X; n" g  m
  105. {
    & v4 J$ m5 K" y, S/ O
  106.         u8 task2_num = 0;
    " E% l" p4 G" U. v! V0 P4 f1 t
  107.         
    . ^; [. {* J" g- K0 D- J
  108.         while(1); h6 W8 ~# b. a, M0 _8 c, A
  109.         {5 \9 Y$ V+ A8 d; v) G6 \
  110.                 task2_num++;7 r, l4 M& _3 K& _+ E, T1 U8 G) G
  111.                 LED1 = !LED1;
    , ~& Y  f3 v, Y4 L* a& M2 G; T+ X
  112.                 printf("任务2已经执行了%d次\r\n", task2_num);
    6 c9 [+ r5 z( ]
  113.                
    2 o5 g  v. d- `1 h
  114.                 //延时1秒 1000个时钟节拍
    # l0 T7 [5 ~3 L3 P% I+ b
  115.                 vTaskDelay(1000);
      h, ^1 M+ S. y! E
  116.         }
    8 Y- y0 U( t7 H/ I3 {9 e+ O$ V5 v
  117. }
    # Y! _  R& p8 w( k
复制代码
* l+ U+ f" P4 v0 w  A5 U1 }" k1 v7 m6 w5 |

! v/ @% o9 ^: B
赞 收藏 评论0 发布时间：2022-6-18 17: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 手机版