原创 三、FreeRTOS 任务（创建、删除、挂起、恢复）

FreeRTOS任务特性

1 任务特性

2 任务状态（4种）

3 任务优先级

3 任务实现

在使用 FreeRTOS 的过程中，我们要使用函数 xTaskCreate()或 xTaskCreateStatic()来创建任务，需要创建任务函数。什么是任务函数？任务函数就是完成本任务工作的函数。我这个任务要干嘛？要做什么？要完成什么样的功能都是在这个任务函数中实现的。

1. void vATaskFunction(void *pvParameters)
2. {
3. for (;;)
4. {
5. /* 任务应用程序 */
6. vTaskDelay();
7. }
8. /*不能从任务函数中返回或退出，除非调用函数 vTaskDelete(NULL)删除任务。*/
9. vTaskDelete(NULL);
10. }

4 任务堆栈

堆栈大小：

可以看出 StackType_t 类型的变量为 4 个字节，那么任务的实际堆栈大小就应该是我们所定义的 4 倍。

函数实现：

任务创建和删除

1 任务创建 API 函数

动态创建任务函数 xTaxkCreate()

1. BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
2. const char * const pcName,
3. const uint16_t usStackDepth,
4. void * const pvParameters,
5. UBaseType_t uxPriority,
6. TaskHandle_t * const pxCreatedTask )

此函数用来创建一个任务，任务需要 RAM 来保存与任务有关的状态信息（任务控制块），任务也要一定的 RAM 来作为任务堆栈。如果使用函数 xTaskCreate()来创建任务，那么这些所需的 RAM 就会自动的从 FreeRTOS 的堆中分配，因此必须提供内存管理文件，默认我们使用heap_4.c 这个内存管理文件，而且宏 configSUPPORT_DYNAMIC_ALLOCATION 必须为 1。如果使用函数 xTaskCreateStatic()创建的话这些 RAM 就需要用户来提供。新创建的任务默认就是就绪态的，如果当前没有比它更高优先级的任务运行那么此任务就会立即进入运行态开始运行，不管在任务调度器启动前还是启动后，都可以创建任务。

在 FreeRTOS 源码中（task.h），给出了函数使用方法：

参数说明：

静态创建任务函数 xTaskCreateStatic()

1. #if (configSUPPORT_STATIC_ALLOCATION == 1)
3. TaskHandle_t xTaskCreateStatic(TaskFunction_t pxTaskCode,
4. const char *const pcName,
5. const uint32_t ulStackDepth,
6. void *const pvParameters,
7. UBaseType_t uxPriority,
8. StackType_t *const puxStackBuffer,
9. StaticTask_t *const pxTaskBuffer)

创建静态任务要复杂一些（要手动定义任务栈数组），如下所示：

删除任务函数 vTaskDelete() 

删除任务函数的注意事项：

实验1 动态创建和删除任务

目标：实现两个任务，任务1运行5次后删除任务2

程序主要部分如下所示：

1. void start_task(void *pvParameters);
2. void task1_task(void *pvParameters);
3. void task2_task(void *pvParameters);
5. #define START_TASK_SIZE 120
6. #define START_TASK_PRIO 1
7. TaskHandle_t Start_Task_Handle;
9. #define TASK1_TASK_SIZE 120
10. #define TASK1_TASK_PRIO 2
11. TaskHandle_t Task1_Handle;
13. #define TASK2_TASK_SIZE 120
14. #define TASK2_TASK_PRIO 3
15. TaskHandle_t Task2_Handle;
17. // 创建开始任务
18. xTaskCreate((TaskFunction_t ) start_task,
19. (char * ) "start_task",
20. (uint16_t ) START_TASK_SIZE,
21. (void * ) NULL,
22. (UBaseType_t ) START_TASK_PRIO,
23. (TaskHandle_t * ) &Start_Task_Handle);
25. vTaskStartScheduler(); // 开启调度器
27. void start_task(void *pvParameters)
28. {
29. // 创建任务1
30. xTaskCreate((TaskFunction_t ) task1_task,
31. (char * ) "task1_task",
32. (uint16_t ) TASK1_TASK_SIZE,
33. (void * ) NULL,
34. (UBaseType_t ) TASK1_TASK_PRIO,
35. (TaskHandle_t * ) &Task1_Handle);
36. // 创建任务2
37. xTaskCreate((TaskFunction_t )task2_task,
38. (char * )"task2_task",
39. (uint16_t )TASK2_TASK_SIZE,
40. (void * )NULL,
41. (UBaseType_t )TASK2_TASK_PRIO,
42. (TaskHandle_t * )&Task2_Handle);
43. // 删除开始任务
44. vTaskDelete(Start_Task_Handle);
45. }
47. void task1_task(void *pvParameters)
48. {
49. uint16_t cnt = 0;
50. for (;;)
51. {
52. cnt++;
53. LED_G_TOGGLE;
54. printf("Task1 running %d\r\n", cnt);
56. // 如果任务1执行5次，则删除任务2
57. if (cnt == 5)
58. {
59. printf("Delete task2!!!\r\n");
60. vTaskDelete(Task2_Handle);
61. }
62. vTaskDelay(500);
63. }
64. }
66. void task2_task(void *pvParameters)
67. {
68. uint16_t cnt = 0;
69. for (;;)
70. {
71. cnt++;
72. printf("Task2 running %d\r\n", cnt);
73. vTaskDelay(500);
74. }
75. }

程序执行结果如下：

静态创建任务

1 使用静态方法创建任务的时候需要将宏configSUPPORT_STATIC_ALLOCATION设置为1，在文件 FreeRTOSConfig.h 中设置，如下所示：

然后编译，有一个提示错误：

查看源码 task.c ，这个函数在外部声明，task.c 中引入并调用

2 实现这个 GetIdleTaskMemory() 函数，如下所示：

3 创建开始任务框架；

1. #define START_TASK_PRIO 1 // 开始任务优先级
2. #define START_TASK_SIZE 128 // 开始任务堆栈大小
3. StackType_t Start_Task_Stack[START_TASK_SIZE]; // 开始任务堆栈
4. StaticTask_t StartTaskTCB; // 开始任务控制块
5. TaskHandle_t Start_Task_Handle; // 开始任务句柄
6. void start_task(void *pvParameters); // 开始任务函数
8. // 创建开始任务
9. Start_Task_Handle = xTaskCreateStatic((TaskFunction_t ) start_task,
10. (char * ) "start_task",
11. (uint32_t ) START_TASK_SIZE,
12. (void * ) NULL,
13. (UBaseType_t ) START_TASK_PRIO,
14. (StackType_t * ) Start_Task_Stack,
15. (StaticTask_t * ) &StartTaskTCB);
17. void start_task(void *pvParameters)
18. {
19. for (;;)
20. {
22. }
23. }

3 创建2个任务，要求任务1执行5次后删除任务2，任务创建过程和开始任务类似。

1. // 任务1
2. #define TASK1_TASK_PRIO 2
3. #define TASK1_TASK_SIZE 128
4. StackType_t Task1_Stack[TASK1_TASK_SIZE];
5. StaticTask_t Task1TaskTCB;
6. TaskHandle_t Task1_Handle;
7. void task1_task(void *pvParameters);
9. // 任务2
10. #define TASK2_TASK_PRIO 3
11. #define TASK2_TASK_SIZE 128
12. StackType_t Task2_Stack[TASK2_TASK_SIZE];
13. StaticTask_t Task2TaskTCB;
14. TaskHandle_t Task2_Handle;
15. void task2_task(void *pvParameters);
17. void start_task(void *pvParameters)
18. {
19. // 创建任务1
20. Task1_Handle = xTaskCreateStatic((TaskFunction_t ) task1_task,
21. (char * ) "task1_task",
22. (uint32_t ) TASK1_TASK_SIZE,
23. (void * ) NULL,
24. (UBaseType_t ) TASK1_TASK_PRIO,
25. (StackType_t * ) Task1_Stack,
26. (StaticTask_t * ) &Task1TaskTCB);
28. // 创建任务2
29. Task2_Handle = xTaskCreateStatic((TaskFunction_t ) task2_task,
30. (char * ) "task2_task",
31. (uint32_t ) TASK2_TASK_SIZE,
32. (void * ) NULL,
33. (UBaseType_t ) TASK2_TASK_PRIO,
34. (StackType_t * ) Task2_Stack,
35. (StaticTask_t * ) &Task2TaskTCB);
37. vTaskDelete(Start_Task_Handle); // 删除开始任务
38. }
40. void task1_task(void *pvParameters)
41. {
42. uint16_t count1 = 0;
43. for (;;)
44. {
45. count1++;
46. LED_B_TOGGLE;
47. printf("Task1 running %d\n", count1);
48. if (count1 == 5)
49. {
50. vTaskDelete(Task2_Handle); // 任务1执行5次，则删除任务2
51. printf("delete task2!!!\n");
52. }
54. vTaskDelay(1000);
55. }
56. }
58. void task2_task(void *pvParameters)
59. {
60. uint16_t count2 = 0;
61. for (;;)
62. {
63. count2++;
64. printf("Task2 running %d\n", count2);
65. vTaskDelay(1000);
66. }
67. }

执行结果如下所示：

非常注意：

一开始创建2个任务时，没有特别注意任务优先级，都设置成了1，如下所示：

此时，得到的结果很奇怪，如下：

原因很简单，同一优先级下有多个任务，任务调度器采用时间片。

任务挂起和恢复

任务挂起和恢复的作用：

设计的实验：

1 包含3个任务，其中两个打印任务，一个按键1任务；

按键1任务中用于挂起 / 恢复任务1；

按键2配置为外部中断，在中断服务函数中恢复任务1；

程序如下所示：

1. // 按键任务
2. void key_task(void *pvParameters)
3. {
4. uint8_t key_status = 0, flag = 0;
5. for (; ;)
6. {
7. key_status = key_scan(KEY1_GPIO_Port, KEY1_Pin);
9. if (key_status)
10. {
11. flag = !flag;
12. printf("按键1按下\r\n");
13. if (flag)
14. {
15. printf("按键1挂起任务1\r\n");
16. vTaskSuspend(Task1_Handle);
17. }
18. else
19. {
20. printf("按键1恢复任务1\r\n");
21. vTaskResume(Task1_Handle);
22. }
23. }
25. vTaskDelay(10);
26. }
27. }
29. // 中断服务函数
30. void EXTI15_10_IRQHandler(void)
31. {
32. BaseType_t YieldRequired;
34. if (__HAL_GPIO_EXTI_GET_IT(KEY2_Pin) != 0x00u)
35. {
36. YieldRequired = xTaskResumeFromISR(Task1_Handle); // 恢复任务1
37. printf("按键2外部中断 -- 中断服务函数中恢复任务1\r\n");
38. if (YieldRequired == pdTRUE)
39. {
40. printf("要恢复的任务优先级 > 当前任务优先级，执行上下文切换\r\n");
41. portYIELD_FROM_ISR(YieldRequired); // 在中断服务函数中，进行任务切换
42. }
44. __HAL_GPIO_EXTI_CLEAR_IT(KEY2_Pin);
45. }
46. }

实验结果如下所示：

 转载于：https://blog.csdn.net/dingyc_ee/article/details/103961383