在嵌入式系统中，需要同时处理多个任务的需求非常普遍。本文将介绍如何在STM32芯片上实现多任务处理，通过合理的任务调度和管理，充分发挥芯片的性能，提高系统的灵活性和效率。下面介绍两种多任务处理的实现方法

1. 时间片轮转调度机制

时间片轮转调度机制是利用定时器中断来实现的。设置一个定时器，当定时器中断发生时，切换到下一个任务的执行。下面是一个简单的时间片轮转调度机制的示例代码 定义不同的任务：定义任务的优先级、堆栈大小、维护一个任务列表，通过编写调度器代码，在合适的时机选择下一个任务来执行。
! Q/ p! t9 R* h- g8 K7 q- m& ~5 @! O

1. #include "stm32fxxx.h"
   7 r9 H9 t& y2 L8 Z
2. // 定义任务的优先级
   
3. #define TASK1_PRIORITY 1
   8 Y6 n. z  r* c
4. #define TASK2_PRIORITY 2
   
5. // 定义任务的堆栈大小
   6 e8 f% J- P( t( x. S/ w5 f) S
6. #define TASK_STACK_SIZE 128
   
7. // 定义任务堆栈空间
   
8. uint32_t task1_stack[TASK_STACK_SIZE];
   7 ~$ T  D0 I4 K; F1 E8 ~4 n
9. uint32_t task2_stack[TASK_STACK_SIZE];
   6 h: k) ?  v/ |% `: L2 Y5 Y
10. // 定义任务函数
    7 @# z2 l4 P, l4 Z
11. void task1(void);
    
12. void task2(void);
    
13. // 定义任务控制块结构
    
14. typedef struct {
    
15.   uint32_t* stack_ptr;
    * h! ]- I2 t# M3 i' R0 h, y
16. } TaskControlBlock;
    4 C7 X9 D: E5 _
17. // 定义任务控制块实例
    
18. TaskControlBlock tcb1;
    
19. TaskControlBlock tcb2;
    
20. // 定义当前任务指针
    % F! T, ?! j! x" o
21. TaskControlBlock* current_task;
    , f; z8 k# [% T) X8 ^6 s& P
22. // 任务1的函数
    
23. void task1(void) {
    # ~) w; r+ h; e7 x7 B, x3 H. X- G
24.   while (1) {
    
25.     // 任务1的处理逻辑
    3 l2 E5 E7 U; P- w
26.     // 切换任务
    
27.     __asm volatile("yield");
    
28.   }
    
29. }
    
30. // 任务2的函数
    ' K7 P3 L8 q, r
31. void task2(void) {
    9 u; f; y3 p- j- Y2 J
32.   while (1) {
    3 L2 N& l& o8 f& G: }- q1 N
33.     // 任务2的处理逻辑
    
34. 
    " |$ @! d8 h5 S7 a) L4 z6 v3 u; ]
35.     // 切换任务
    
36.     __asm volatile("yield");
    % e. A" L8 e( {5 |) F' j) r4 m  [5 D
37.   }
    6 U8 [2 Q) y4 `& {, }6 {
38. }

复制代码

定时器中断：在中断处理函数中切换任务，并保存当前任务的上下文（包括寄存器、堆栈等），然后加载下一个任务的上下文，使其开始执行。

1. // 定义定时器中断处理函数
   $ I' M5 w! G" y% k- A6 z6 v
2. void TIM_IRQHandler(void) {
   
3.   // 切换到下一个任务
   $ f' @# C6 \& {9 M7 m( A
4.   if (current_task == &tcb1) {
   ; E$ I+ H; t% M" y6 ~" u
5.     current_task = &tcb2;
   0 e0 [. E! r" k$ i0 z: j1 ^
6.   } else {
   
7.     current_task = &tcb1;
   ) a# s7 K  U$ F4 L) h4 a
8.   }
   3 c8 T3 s8 B7 d: a( D
9.   // 加载下一个任务的堆栈指针
   ! U' j9 K# i$ o; P- s
10.   __asm volatile("mov sp, %0" ::"r"(current_task->stack_ptr));
    
11. }

复制代码

9 i; \6 N+ N1 P4 J, L- [& Y0 t
多个任务之间可能需要进行通信和共享资源。可以使用全局变量或其他同步机制来实现任务间的数据传递和资源共享。
* O9 Q' j( m6 M1 V' R) B" Z

1. int main() {
   ! N6 U1 z' h) t8 I7 B
2.   // 初始化任务控制块
   $ E2 F- o) S& a
3.   tcb1.stack_ptr = task1_stack + TASK_STACK_SIZE - 1;
   ) D) M& w& m7 Q- J! h
4.   tcb2.stack_ptr = task2_stack + TASK_STACK_SIZE - 1;
   
5. 
   
6.   // 初始化定时器，设置定时器中断
   
7.   // 这里使用TIM3作为定时器，具体配置请根据实际情况进行修改
   
8.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
   1 T" ?. j( N; q5 `- ?. X! W
9.   TIM_TimeBaseInitTypeDef TIM_InitStruct;
     [. B3 k2 v) t) d: e! H$ _9 x
10.   TIM_InitStruct.TIM_Prescaler = 1000;
    4 F% q" G0 T( G( w
11.   TIM_InitStruct.TIM_Period = 1000;
    
12.   TIM_InitStruct.TIM_CounterMode = TIM_CounterMode_Up;
    
13.   TIM_InitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
    ) Z$ Y9 z( p) `' n+ V" Y
14.   TIM_TimeBaseInit(TIM3, &TIM_InitStruct);
    
15.   TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);
    . F' a' l1 i+ |  |; [: \4 O
16.   NVIC_EnableIRQ(TIM3_IRQn);
    
17.   TIM_Cmd(TIM3, ENABLE);
    " J1 s* H9 y9 |$ q: i
18. 
    " H7 A+ o1 m% `1 [/ v2 x/ s: Z
19.   // 初始化当前任务指针
    3 M& J) X1 x" t; p
20.   current_task = &tcb1;
    
21. 
    
22.   // 启动任务1
    " n0 N* a3 x% ^# g/ ~' b0 ]# R
23.   task1();
    
24. 
    
25.   while (1) {
    6 J/ y* E& [, f$ l* O
26.     // 主循环，任务在定时器中断中切换
    3 M" W  h* u% C& N$ y
27.   }
    
28. }

复制代码

1 e$ W6 x4 y9 N

这种简单的多任务处理方式适用于较简单的应用场景，但对于复杂的多任务应用，建议使用RTOS来提供更好的任务管理和调度机制。

; U* D, s" D0 p- Z

2. 使用RTOS（实时操作系统）

RTOS是一种常用的多任务处理解决方案，它提供了任务调度和管理机制，简化了多任务应用的开发。对于STM32芯片，常见的RTOS有FreeRTOS、uC/OS等。以下是实现多任务处理的基本步骤：

创建任务：使用RTOS的API，在应用程序中创建多个任务。每个任务都有自己的代码和优先级

1. void Task1(void* pvParameters)
   : J7 H1 E+ Q0 E5 o7 S$ P( ]2 r
2. {
   6 b: a/ d2 I5 A! u1 L& [
3.   while (1)
   
4.   {
   
5.     // Task1处理代码
   
6.   }
   
7. }
   
8. 
     ~  t; |- n3 J( g, L
9. void Task2(void* pvParameters)
   3 ~! L- b$ H& W  o* q* I" ?5 s+ I
10. {
    
11.   while (1)
    / s- c% Y9 X+ ^+ X* H
12.   {
    
13.     // Task2处理代码
    0 s0 O4 F6 q9 N3 P" R
14.   }
    2 n" [" p# p! M
15. }
    4 {+ W; U3 J( V0 A* Y
16. 
    3 ^4 B3 q% O: ^+ L& U( b
17. int main()
    * Q9 S, j# S) Y: r0 n0 ^" d2 g
18. {
    * ~  Q: z+ ?( \0 i5 }* `
19.   // 硬件初始化和其他配置
    , x6 L6 E: K/ W0 U
20.   // 创建任务
    
21.   xTaskCreate(Task1, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    : g- }/ {: G, B2 j. M, U) j% t  M
22.   xTaskCreate(Task2, "Task2", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
    ) q# Z+ _7 }' F- p
23. 
    
24.   // 启动调度器
    
25.   vTaskStartScheduler();
    - j$ ~. M& Q2 C4 Q. F/ F$ n
26. 
    7 D- B1 {9 _& Y0 S" I6 q
27.   // 代码永远不会执行到这里
    
28.   while (1)
    
29.   {
    
30.   }
    
31. }

复制代码

内核参数：配置RTOS内核的一些参数，例如时钟节拍和优先级。

1. int main()
   " b8 g" o; ?  J+ l
2. {
   5 ]* X; j1 b" D  \9 N. p
3.   // 硬件初始化和其他配置
   
4. 
   
5.   // 配置FreeRTOS内核
   9 r* c  g0 m( `/ s
6.   // 设置时钟节拍
   
7.   TickType_t tickRate = 1000 / configTICK_RATE_HZ;
   
8.   TickTypeSet(tickRate);
   ! m+ X, S, p, f/ O9 `5 \4 p
9. 
   * \) _  e8 O9 ?8 E. r! _8 X, Q! A) B
10.   // 配置优先级分组
    : l/ b# W4 q  K) N: I
11.   NVIC_SetPriorityGrouping(0);
    
12. 
    6 v8 [5 J7 ^8 e! G7 |5 N
13.   // 创建任务和启动调度器
    " J1 }) \5 e2 Q" w3 p
14.   // ...
    ( E, K2 H; _. v1 j4 _
15. 
    ! w+ T# P0 T9 B' I" J6 G: x
16.   // 代码永远不会执行到这里
    % p4 O8 N' c$ X% k3 p3 d$ P
17.   while (1)
    
18.   {
    , l/ A( p/ T0 @
19.   }
    
20. }

复制代码

" Y+ I- U' j( x% W+ \* I

任务处理代码：在任务的处理函数中，编写任务的实际处理代码。由于FreeRTOS采用抢占式调度，每个任务的处理函数应该是一个无限循环，确保任务不会结束。

1. void Task1(void* pvParameters)
   ; `; u# [( a/ l: ^
2. {
   * E* e$ R7 T" h& p- F( J
3.   while (1)
   
4.   {
   
5.     // Task1处理代码
   9 @' U1 _+ e  n' P5 C  u
6. 
   
7.     // 任务挂起一段时间，以便给其他任务执行机会
   - n0 N& u- `( g3 _8 }
8.     vTaskDelay(pdMS_TO_TICKS(100));
   
9.   }
   
10. }
    
11. 
    + Q9 m% G, T& z6 Z5 x7 `3 j% K
12. void Task2(void* pvParameters)
    # |( i0 |$ H# P. q1 Q, t! R
13. {
    
14.   while (1)
    " L& p5 A7 M1 k: t! y$ e
15.   {
    
16.     // Task2处理代码
    7 p4 R. q" c" X4 S. N2 n$ y3 D. ?5 X
17. 
    
18.     // 任务挂起一段时间，以便给其他任务执行机会
    6 l9 [5 _: j! u' \+ }  k
19.     vTaskDelay(pdMS_TO_TICKS(50));
    
20.   }
    ' e' X( q+ U, g
21. }

复制代码

/ y% Y& p% k/ d; |! _+ C6 \这是一个简单的示例代码，实现了两个任务(Task1和Task2)，每个任务都在一个无限循环中执行自己的处理代码，并使用vTaskDelay()函数挂起一段时间，以便给其他任务执行机会。使用RTOS可以提供较高的可靠性和灵活性，适用于复杂的多任务应用场景。

8 i) P% a0 }5 _: p7 b) t

! ]; a- }$ @: |9 m转载自：安迪西
如有侵权请联系删除