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

STM32芯片如何同时运行多个任务

[复制链接]
攻城狮Melo 发布时间:2023-6-28 13:47
在嵌入式系统中,需要同时处理多个任务的需求非常普遍。本文将介绍如何在STM32芯片上实现多任务处理,通过合理的任务调度和管理,充分发挥芯片的性能,提高系统的灵活性和效率。下面介绍两种多任务处理的实现方法
1. 时间片轮转调度机制
时间片轮转调度机制是利用定时器中断来实现的。设置一个定时器,当定时器中断发生时,切换到下一个任务的执行。下面是一个简单的时间片轮转调度机制的示例代码 定义不同的任务:定义任务的优先级、堆栈大小、维护一个任务列表,通过编写调度器代码,在合适的时机选择下一个任务来执行。, _# E8 [  }7 h$ Q1 U
  1. #include "stm32fxxx.h"
    # r3 B1 s5 |3 S* m" T
  2. // 定义任务的优先级
    7 ?3 J5 N8 D% e9 Q' h4 T8 H+ U2 O+ R
  3. #define TASK1_PRIORITY 1
    , Z- u- r" Q. }7 P0 h$ b
  4. #define TASK2_PRIORITY 2
    ' h; X! H9 E) K1 u4 \
  5. // 定义任务的堆栈大小; y! c2 q3 I9 A/ _7 z% n' e
  6. #define TASK_STACK_SIZE 128
    9 Y: f2 R9 }4 ]1 R6 Z5 \$ w4 @
  7. // 定义任务堆栈空间4 I) \. [2 o" F  |9 {
  8. uint32_t task1_stack[TASK_STACK_SIZE];( t* X6 W" W* u* k$ F
  9. uint32_t task2_stack[TASK_STACK_SIZE];4 Q7 h3 t1 K- Y6 s: F& E) ]% V- K7 H
  10. // 定义任务函数1 G5 @6 B9 n3 G  y' I5 D
  11. void task1(void);
    # V6 p/ X6 n5 U  C; |8 Q
  12. void task2(void);
    : s+ u! p% b! M, ?- J
  13. // 定义任务控制块结构
    + j6 x, J8 y+ D6 ~
  14. typedef struct {5 c( [5 P: \+ K# ^/ r2 x- a
  15.   uint32_t* stack_ptr;
    - G7 Y3 i6 ^! E/ W: a
  16. } TaskControlBlock;1 [. R0 [$ b* F% P9 k
  17. // 定义任务控制块实例! l: [' M# i# P7 I, q$ ^" r
  18. TaskControlBlock tcb1;' {; t6 `$ e/ A% i' c* K
  19. TaskControlBlock tcb2;' C0 P# D3 Y- m' g
  20. // 定义当前任务指针& p0 ~* Y. R- c8 S0 n5 i
  21. TaskControlBlock* current_task;
    * @3 H) ^& |3 \) y* Q
  22. // 任务1的函数! v  u: _6 i# B) s6 V9 c+ g
  23. void task1(void) {) D1 T; `/ [- C, b0 H3 w3 L
  24.   while (1) {
    8 o: D% {& P5 N4 p! Q
  25.     // 任务1的处理逻辑" Z' s8 h7 b. V* k4 Y9 w
  26.     // 切换任务+ H3 D5 i4 I! e6 Q
  27.     __asm volatile("yield");9 N9 w- {' }+ V% w# p
  28.   }
    $ U! V* C' w+ h& T2 `6 k
  29. }
    : g1 h% J  k- U8 ?
  30. // 任务2的函数& ^' i1 ^; ]6 K- X5 `
  31. void task2(void) {  m5 U: p: W+ A0 n' h3 n2 z
  32.   while (1) {
    4 y, A1 C( _" L& H
  33.     // 任务2的处理逻辑& s$ H' g) n3 J0 I

  34. 9 J" ?, x) b; |5 B! ^9 D/ g5 R
  35.     // 切换任务
      {$ O- s2 x" O% w
  36.     __asm volatile("yield");
    + l$ G) h- W. R1 k7 X  {
  37.   }2 j4 ~: M& |0 ^& m: t5 m2 p
  38. }
复制代码
2 h$ h! ^: X' g& w# l: v& L" C

5 ]/ h5 ~9 C( R- X! M
定时器中断:在中断处理函数中切换任务,并保存当前任务的上下文(包括寄存器、堆栈等),然后加载下一个任务的上下文,使其开始执行。
  1. // 定义定时器中断处理函数3 h5 Y$ r* ~. {
  2. void TIM_IRQHandler(void) {
    1 a4 }+ r/ \7 `5 U. K" }" g
  3.   // 切换到下一个任务, k5 J$ T5 S: K0 q
  4.   if (current_task == &tcb1) {
    0 q' S  g2 `( H3 j  n( Y4 y8 n. u
  5.     current_task = &tcb2;* n% L# Q3 n7 H3 O. x) o
  6.   } else {
    ( l' u. r6 F0 ?  M7 P' b, C% w
  7.     current_task = &tcb1;. y9 c# T. b( C& }9 L0 E! }. h* l
  8.   }0 [/ N5 {3 Z1 x( i3 F8 I) n- w: K
  9.   // 加载下一个任务的堆栈指针
    ; U; ~6 @) R: N, m
  10.   __asm volatile("mov sp, %0" ::"r"(current_task->stack_ptr));
    # _0 N7 w' b+ C3 B
  11. }
复制代码
9 i; g$ e# S. @  t) ~
/ B/ j7 o. D) G, e- U/ `, Z5 ]' t
多个任务之间可能需要进行通信和共享资源。可以使用全局变量或其他同步机制来实现任务间的数据传递和资源共享。

2 W, U' s/ W) v. W, }1 F( ~; y
  1. int main() {, A0 U* u! r) L& F  B
  2.   // 初始化任务控制块0 F1 Q: U, y% G1 O% U  E
  3.   tcb1.stack_ptr = task1_stack + TASK_STACK_SIZE - 1;- S# \* {$ v$ a1 E, e& U
  4.   tcb2.stack_ptr = task2_stack + TASK_STACK_SIZE - 1;
    1 M7 ?' s, Y2 Y& G, I/ b  f% k# H
  5. 9 D3 `7 Y' Z( k
  6.   // 初始化定时器,设置定时器中断6 Y5 c' d+ L6 l! }* I
  7.   // 这里使用TIM3作为定时器,具体配置请根据实际情况进行修改; u; O" p" K% t" ^, [
  8.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
    0 _- x7 b5 P' Y/ {! R/ N
  9.   TIM_TimeBaseInitTypeDef TIM_InitStruct;) z( x" j4 j. _) s# @) C& x
  10.   TIM_InitStruct.TIM_Prescaler = 1000;) R' q5 T/ _0 k5 n' C
  11.   TIM_InitStruct.TIM_Period = 1000;! P9 m$ B+ X) J' N( r
  12.   TIM_InitStruct.TIM_CounterMode = TIM_CounterMode_Up;, h# g8 w/ g+ Y7 z6 U' A! ]
  13.   TIM_InitStruct.TIM_ClockDivision = TIM_CKD_DIV1;8 _- |3 i$ X9 M/ h  O' Q
  14.   TIM_TimeBaseInit(TIM3, &TIM_InitStruct);
    & f6 ~1 E) h: d( g
  15.   TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);
    ( Z$ O. z3 c- \2 [! F- M7 J
  16.   NVIC_EnableIRQ(TIM3_IRQn);1 F2 x; w& o1 i* P1 J
  17.   TIM_Cmd(TIM3, ENABLE);2 }% x8 D! N8 D% ^8 y% H
  18. 7 n5 H; ~4 W* W: Q" w. k5 y
  19.   // 初始化当前任务指针
    : u( ]9 J0 I) v; |+ {
  20.   current_task = &tcb1;
    9 z' w1 W! A6 _1 U6 z- k: w
  21. 6 s- K  m9 E6 z2 @# a" ?3 s
  22.   // 启动任务1. P( p6 _9 L; S3 M- F9 m
  23.   task1();  {. q7 e, u) n/ I: S

  24. & a! A$ H6 C8 I2 b. e
  25.   while (1) {7 }1 f6 g! h8 V
  26.     // 主循环,任务在定时器中断中切换5 X4 f, F2 a; U% F2 W& @. p8 [
  27.   }
    7 _) Y# T* z& }/ j
  28. }
复制代码

8 t- i! R% J, j! j* u
, }* Q( h4 I1 E. v' J
这种简单的多任务处理方式适用于较简单的应用场景,但对于复杂的多任务应用,建议使用RTOS来提供更好的任务管理和调度机制。
8 ]9 z' F0 i+ q& P5 a
2. 使用RTOS(实时操作系统)
RTOS是一种常用的多任务处理解决方案,它提供了任务调度和管理机制,简化了多任务应用的开发。对于STM32芯片,常见的RTOS有FreeRTOS、uC/OS等。以下是实现多任务处理的基本步骤:
创建任务:使用RTOS的API,在应用程序中创建多个任务。每个任务都有自己的代码和优先级
  1. void Task1(void* pvParameters)3 j8 v3 P4 `$ S6 E3 N  c! g
  2. {
    6 U! z& S: `3 K* K  Y+ h4 b0 G
  3.   while (1)
    ! G' W, l; b0 O% `
  4.   {
    6 u% q) o. P# x3 b
  5.     // Task1处理代码
    ' F4 K) A' w) ~! G
  6.   }
    8 A7 C$ p1 C1 _- T
  7. }4 ~% X  p9 c" L# e# \( ]- v
  8. 7 m* e" ]# R& l
  9. void Task2(void* pvParameters)
    8 D1 W8 S: C+ X2 [/ e  h1 }9 r! b' R
  10. {
    ! ?; n7 a- F* x5 y5 B  N& ?* W5 @
  11.   while (1)
    3 s5 ]2 v* P( F- T. n
  12.   {  P: c; c% y3 D  S
  13.     // Task2处理代码
    : v) x! T$ ?* S9 G% j6 P
  14.   }
    + O( @) g; G( m* Q
  15. }
    % q4 x) X2 }$ s  ?, Q
  16. / j) h) K. R% d) j
  17. int main()
    + I0 K. r0 o  {0 Z; {: _& i, Z" T5 Y
  18. {
    ; J& j% V* A( l4 ]
  19.   // 硬件初始化和其他配置
    ! }0 D+ Q" P  S; E6 ]0 |( a
  20.   // 创建任务
    ' t' ^, m3 V: V% m1 Q
  21.   xTaskCreate(Task1, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    ; ]7 _# i8 t3 l2 c& {8 E
  22.   xTaskCreate(Task2, "Task2", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
    0 G. b( n' D5 T) C
  23. ) }$ J3 k- Z: t, k3 N( _9 J5 u3 q
  24.   // 启动调度器
    4 R" g) q1 Y' u# d5 E( W8 g' t* ?
  25.   vTaskStartScheduler();
    . U; L9 [$ R; ]* v
  26.   E( r6 W/ x! R/ L
  27.   // 代码永远不会执行到这里
    # J/ T( }' E, n
  28.   while (1)% O2 x2 X' h4 A# m6 S
  29.   {' p9 I& F" f! n1 z
  30.   }
    4 Q( C: s4 D7 B, G+ v* L$ C# y8 E3 q
  31. }
复制代码

5 X/ M$ d  o% y4 ~1 R, {
内核参数:配置RTOS内核的一些参数,例如时钟节拍和优先级。
  1. int main()
    " {) [8 j) l1 ^: g* O
  2. {3 A. f( {; @6 U
  3.   // 硬件初始化和其他配置
    3 W- c; C2 f1 q, t
  4. ! W5 B, Y/ T; t" g; X' `9 F+ Y
  5.   // 配置FreeRTOS内核: p5 z" {" s& q) Y  D- S: B
  6.   // 设置时钟节拍
    + `5 |1 ~2 [: T, Y) J) l6 G; P" `
  7.   TickType_t tickRate = 1000 / configTICK_RATE_HZ;
    $ k, Z. h) M9 R* P, p4 ]# W
  8.   TickTypeSet(tickRate);% P5 o& _, N7 l$ h
  9. + p) b& u, h$ E" q
  10.   // 配置优先级分组' R0 J# y6 R/ g8 Y
  11.   NVIC_SetPriorityGrouping(0);
      M. c0 R. U8 P, j% E

  12. ) `( q2 N& o# \/ @$ J
  13.   // 创建任务和启动调度器" a& W( y8 |0 p& c- |$ R6 @* B
  14.   // ...
    * h2 @) t! H" a- W4 d% T

  15. - w; A' `8 {, a- o
  16.   // 代码永远不会执行到这里$ [$ F4 T, f+ o, q1 E
  17.   while (1)2 ]( ]' Y+ i* k" D  @, m
  18.   {# f! W% l' s( c- k8 W
  19.   }% C4 N- Q. z  _6 k, z
  20. }
复制代码

7 N; q1 \$ I3 B/ d
任务处理代码:在任务的处理函数中,编写任务的实际处理代码。由于FreeRTOS采用抢占式调度,每个任务的处理函数应该是一个无限循环,确保任务不会结束。
  1. void Task1(void* pvParameters)
      W. E' y  J/ k7 ^4 p  k* R
  2. {8 C! M3 A1 ^2 F4 J
  3.   while (1)
    ( K8 p" M* d; O) R& g
  4.   {3 E0 i. P& i8 c8 H* X4 E' r; N& N
  5.     // Task1处理代码
    $ B/ n8 S9 j9 }
  6. . L. F5 Q/ `( p
  7.     // 任务挂起一段时间,以便给其他任务执行机会9 Y( }4 D& ]' E, \" r& Y
  8.     vTaskDelay(pdMS_TO_TICKS(100));* F3 P4 e5 h" s9 C. m
  9.   }
    ( K! G. {- a  G5 g& ^! B' g
  10. }( ~6 u6 a* U' y8 A) _

  11. ) ]. z, i, n" {7 g
  12. void Task2(void* pvParameters)
    # v2 {  j9 g$ x" p# r" V& i+ Z
  13. {6 w4 t- O$ }! R' U$ C9 p
  14.   while (1)" ~/ ]# q4 f9 O" h5 I+ T& H
  15.   {% @! ?2 E) A7 L; C; G3 f
  16.     // Task2处理代码$ y- J  y; _" z
  17. ! m/ X8 Z( Z/ P$ {+ d6 N1 q
  18.     // 任务挂起一段时间,以便给其他任务执行机会
    - t3 e6 j2 _1 k# T. O7 c  P9 s$ ]
  19.     vTaskDelay(pdMS_TO_TICKS(50));
    ( _" U0 G. Z( W) J0 f" x4 N
  20.   }& e' l( A5 s+ [' G- f
  21. }
复制代码
4 e" }) M* X. |
这是一个简单的示例代码,实现了两个任务(Task1和Task2),每个任务都在一个无限循环中执行自己的处理代码,并使用vTaskDelay()函数挂起一段时间,以便给其他任务执行机会。使用RTOS可以提供较高的可靠性和灵活性,适用于复杂的多任务应用场景。
; a3 E6 h% d7 u/ p7 T
- p8 |2 u; T, O  n# E! P/ H) Q7 Y& n8 n, k. E+ q
% S1 N2 M; L( L3 _* V! d0 Y
转载自:安迪西: f0 Y: {$ }5 n0 K$ m) q+ N
如有侵权请联系删除* ?, q. @* w3 |1 ]" U& Z) u/ y

9 K% {! R7 b+ S0 |1 R" r7 |- F1 |
赞 收藏 评论0 发布时间:2023-6-28 13:47

举报

0个回答

所属标签

相似技术帖

官网相关资源

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