-
FreeRTOS多任务管理
文章目录
1、任务
1.1 任务简介
(1) 在裸机系统中，系统的主体就是 main 函数里面顺序执行的无限循环，这个无限循环里面 CPU 按照顺序完成各种事情。
(2) 在FreeRTOS中，根据功能的不同，把整个系统分割成一个个独立且无限循环、无法返回的函数，这个函数就称为 任务。
1.2 任务调度
任何时刻，只有一个任务得到运行，FreeRTOS调度器 决定运行哪个任务。调度器会不断的启动、停止每一个任务，宏观看上去所有的任务都在同时在执行。
FreeRTOS 中的任务是 抢占式 调度机制，高优先级的任务可打断 低优先级任务，低优先级任务必须在高优先级任务阻塞或结束后 才能得到调度。
1.3 任务的状态 (就绪态 / 运行态 / 阻塞态 / 挂起态)
任务状态通常分为以下四种：
就绪态 (ready)：该任务在就绪列表中，就绪的任务已经具备执行的能力，只等待调度器进行调度，新创建的任务会初始化为就绪态。运行态 (running)：该状态表明任务正在执行，此时它占用处理器，FreeRTOS调度器选择运行的永远是处于最高优先级的 就绪态任务，当任务被运行的一刻，它的任务状态就变成了运行态。
阻塞态 (blocked)：正在运行的任务发生阻塞 (延时、读信号量等待、读写队列或者等待读写事件) 时，该任务会从就绪列表中删除，任务状态由运行态变成阻塞态。
挂起态 (suspended)：处于挂起态的任务 对调度器而言是不可见的，让一个任务进入挂起状态的唯一办法就是调用 vTaskSuspend() 函数；而把一个挂起状态的任务恢复 的唯一途径 就是调用 vTaskResume() 或 vTaskResumeFromISR() 函数。
挂起态与阻塞态的区别：
当任务有较长的时间不允许运行的时候，我们可以挂起任务，这样 调度器就不会管这个任务的任何信息，直到我们调用恢复任务的 API 函数；
而任务处于阻塞态的时候，系统还需要判断 阻塞态的任务是否超时，是否可以解除阻塞。他们之间的转换关系如下图：
(1)：创建任务→就绪态 (ready)：任务创建完成后进入就绪态，表明任务已准备就绪，随时可以运行，只等待调度器进行调度。
(2)：就绪态→运行态 (running)：发生任务切换时，就绪列表中 最高优先级的任务被执行，从而进入运行态。
(3)：运行态→就绪态：有更高优先级任务创建或者恢复后，会发生 任务调度，此刻就绪列表中最高优先级任务变为运行态，那么原先运行的任务由运行态变为就绪态，依然在就绪列表中，等待最高优先级的任务运行完毕继续运行原来的任务 (此处可以看做是 CPU使用权被更高优先级的任务抢占了)。
(4)：运行态→阻塞态 (blocked)：正在运行的任务发生阻塞 (延时、读信号量等待) 时，该任务会从就绪列表中删除，任务状态由运行态变成阻塞态，然后发生任务切换，运行就绪列表中当前最高优先级任务。
(5)：阻塞态→就绪态：阻塞的任务被恢复后 (任务恢复、延时时间超时、读信号量超时或读到信号量等)，此时被恢复的任务会被加入就绪列表，从而由阻塞态变成就绪态；如果此时被恢复任务的优先级高于正在运行任务的优先级，则会发生任务切换，将该任务将再次转换任务状态，由就绪态变成运行态。
(6) (7) (8)：就绪态、阻塞态、运行态→挂起态 (suspended)：任务可以通过调用 vTaskSuspend() API 函数都可以将处于任何状态的任务挂起，被挂起的任务得不到CPU的使用权，也不会参与调度，除非它从挂起态中解除。
(9)：挂起态→就绪态：把一个挂起状态的任务 恢复的唯一途径就是调用 vTaskResume() 或 vTaskResumeFromISR() API 函数，如果此时被恢复任务的优先级高于正在运行任务的优先级，则会发生 任务切换，将该任务将再次转换任务状态，由就绪态 变成 运行态。
1.4 空闲任务
空闲任务是系统在 启动调度器的时候，创建的优先级最低的任务，空闲任务主体主要是做一些系统内存的清理工作。如果没有其它任务可以运行，这个时候CPU就运行空闲任务。
2、动态创建两个任务
2.1 定义动态内存空间的堆
使用动态内存，即 堆(heap)，也属于 SRAM。
FreeRTOS 做法是在SRAM里面定义一个大数组，也就是堆内存，供 FreeRTOS的动态内存分配函数使用，在第一次使用的时候，系统会将定义的堆内存进行初始化。//系统所有总的堆大小 #define configTOTAL_HEAP_SIZE ((size_t)(36*1024)) (1) static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; (2)- 1
- 2
- 3
(1) 堆内存的大小为 configTOTAL_HEAP_SIZE，在 FreeRTOSConfig.h 中，由用户自己定义，
configSUPPORT_DYNAMIC_ALLOCATION这个宏定义在使用FreeRTOS操作系统的时候必须开启。
(2) 从内部SRAM 里面定义一个静态数组 ucHeap，大小由configTOTAL_HEAP_SIZE这个宏决定，目前定义为 36KB。
2.2 定义任务函数
创建两个任务，分别 让 LED 灯以 500ms / 1000ms的频率闪烁，具体实现见代码清单：
static void LED1_Task(void* parameter) { while (1) { LED1_ON; vTaskDelay(500); /* 延时500个tick */ LED1_OFF; vTaskDelay(500); /* 延时500个tick */ } } static void LED2_Task(void* parameter) { while (1) { (1) LED2_ON; vTaskDelay(1000); /* 延时1000个tick */ (2) LED2_OFF; vTaskDelay(1000); /* 延时1000个tick */ } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
(1) ：任务必须是一个死循环。
(2) ：任务里面的延时函数必须使用 FreeRTOS 里面提供的延时函数 vTaskDelay()。
调用 vTaskDelay() 函数的时候，当前任务进入阻塞状态，调度器会切换到其它就绪的任务，从而实现多任务。
2.3 定义 任务控制块 指针
任务控制块 (TCB) 是在任务创建的时候分配内存空间创建，任务创建函数会返回一个指针，用于指向 任务控制块，所以要预先为任务栈定义一个任务控制块指针，也就是 任务句柄。
任务句柄的数据类型为 TaskHandle_t，在 task.h 中定义，实际上就是一个 空指针，具体实现见代码清单：
/* 任务句柄 */ typedef void * TaskHandle_t;- 1
- 2
定义任务句柄：
/**************************** 任务句柄 ********************************/ /* * 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄 * 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么 * 这个句柄可以为 NULL。 */ static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */ static TaskHandle_t LED1_Task_Handle = NULL; /* LED1 任务句柄 */ static TaskHandle_t LED2_Task_Handle = NULL; /* LED2 任务句柄 */- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
2.4 动态创建任务 xTaskCreate()
使用动态内存的时候，使用 xTaskCreate() 函数来创建一个任务。
/* 创建 AppTaskCreate 任务 */ xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate, /* 任务入口函数 */ (1) (const char* )"AppTaskCreate", /* 任务名字 */ (2) (uint16_t )512, /* 任务栈大小 */ (3) (void* )NULL, /* 任务入口函数参数 */ (4) (UBaseType_t )1, /* 任务的优先级 */ (5) (TaskHandle_t* )&AppTaskCreate_Handle); /* 任务控制块 指针 */ (6) /* 启动任务调度 */ if (pdPASS == xReturn) vTaskStartScheduler(); /* 启动任务，开启调度 */- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
(1) ：任务入口函数，即任务函数的名称。(用户自定义，用于创建任务)
(2) ：任务名字，字符串形式， 最大长度由 FreeRTOSConfig .h 中定义的configMAX_TASK_NAME_LEN宏指定，多余部分会被自动截掉，这里任务名字最好要与 任务函数入口名字一致，方便进行调试。
(3) ：任务堆栈大小，单位为字，在32位的处理器下，一个字等于4个字节，那么任务大小就为 512*4 = 2048 字节。
(4) ：任务入口函数形参，不用的时候配置为 0 或者 NULL即可。
(5) ：任务的优先级。 优先级范围根据 FreeRTOSConfig .h 中的宏configMAX_PRIORITIES决定：- 如果使能
configUSE_PORT_OPTIMISED_TASK_SELECTION这个宏定义，则最多支持 32 个优先级； - 如果不用特殊方法查找下一个运行的任务，那么则不强制要求限制最大可用优先级数目。
在 FreeRTOS 中，数值越大 优先级越高，0代表最低优先级。
(6) ：任务控制块 指针。 在使用动态内存的时候，任务创建函数 xTaskCreate() 会返回一个指针 指向 任务控制块，该任务控制块是 xTaskCreate() 函数里面动态分配的一块内存。
任务创建好后，是处于 任务就绪 (ready)，在就绪态的任务可以参与操作系统的调度。
说明：
为了方便管理，任务的创建都通过 AppTaskCreate() 任务创建函数来执行：static void AppTaskCreate(void) { BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */ taskENTER_CRITICAL(); //进入临界区 /* 创建 LED1_Task 任务 */ xReturn = xTaskCreate((TaskFunction_t )LED1_Task, /* 任务入口函数 */ (const char* )"LED1_Task", /* 任务名字 */ (uint16_t )512, /* 任务栈大小 */ (void* )NULL, /* 任务入口函数参数 */ (UBaseType_t )2, /* 任务的优先级 */ (TaskHandle_t* )&LED1_Task_Handle); /* 任务控制块指针 */ if (pdPASS == xReturn) printf("创建 LED1_Task 任务成功!\r\n"); /* 创建 LED2_Task 任务 */ xReturn = xTaskCreate((TaskFunction_t )LED2_Task, /* 任务入口函数 */ (const char* )"LED2_Task", /* 任务名字 */ (uint16_t )512, /* 任务栈大小 */ (void* )NULL, /* 任务入口函数参数 */ (UBaseType_t )3, /* 任务的优先级 */ (TaskHandle_t* )&LED2_Task_Handle); /* 任务控制块指针 */ if (pdPASS == xReturn) printf("创建 LED2_Task 任务成功!\r\n"); vTaskDelete(AppTaskCreate_Handle); //删除 AppTaskCreate 任务 taskEXIT_CRITICAL(); //退出临界区 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
2.5 启动任务 vTaskStartScheduler()
在创建完任务的时候，我们需要 开启调度器，因为创建仅仅是把任务添加到系统中，还没真正调度，并且空闲任务也没实现，定时器任务也没实现，这些都是在开启调度函数 vTaskStartScheduler() 中实现的。
任务调度器只启动一次，之后就不会再次执行了。从此，任务管理都由 FreeRTOS 管理，此时是真正进入 实时操作系统。
/***************************************************************** * @brief 主函数 * @param 无 * @retval 无 * @note 第一步：开发板硬件初始化 第二步：创建 APP 应用任务 第三步：启动 FreeRTOS，开始多任务调度 ****************************************************************/ int main(void) { BaseType_t xReturn = pdPASS; /* 定义一个创建信息返回值，默认为 pdPASS */ /* 第1步 开发板硬件初始化 */ BSP_Init(); /* 第2步 创建 AppTaskCreate 任务 */ xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate, /* 任务入口函数 */ (1) (const char* )"AppTaskCreate", /* 任务名字 */ (2) (uint16_t )512, /* 任务栈大小 */ (3) (void* )NULL, /* 任务入口函数参数 */ (4) (UBaseType_t )1, /* 任务的优先级 */ (5) (TaskHandle_t* )&AppTaskCreate_Handle); /* 任务控制块指针 */ (6) /* 第3步 启动任务调度 */ if (pdPASS == xReturn) vTaskStartScheduler(); /* 启动任务，开启调度 */ else return -1; while (1); /* 正常不会执行到这里 */ }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
3、常用的任务函数
3.1 任务挂起 vTaskSuspend()
任务可以通过调用 vTaskSuspend() 函数都可以将处于任何状态的任务挂起，被挂起的任务得不到 CPU 的使用权，也不会参与调度，它相对于调度器而言是不可见的，除非它从挂起态中解除。
注：任务可以调用 vTaskSuspend() 这个函数来挂起任务自身，但是在挂起自身的时候会进行一次任务上下文切换，需要 挂起自身就将 xTaskToSuspend 设置为 NULL 传递进来即可。
无论任务是什么状态都可以被挂起，只要调用了 vTaskSuspend() 这个函数就会挂起成功，不论是挂起其他任务还是挂起任务自身。代码示例：
static TaskHandle_t LED_Task_Handle = NULL; /*LED任务句柄*/ static void KEY_Task(void* parameter) { while (1) { if ( Key_Scan(KEY1_GPIO_PORT, KEY1_GPIO_PIN) == KEY_ON ) { /*K1被按下*/ printf("挂起 LED 任务！\n"); vTaskSuspend(LED_Task_Handle); /*挂起LED任务*/ } vTaskDelay(20); /*延时20个tick*/ } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
3.2 任务恢复 vTaskResume()
任务恢复 就是让挂起的任务 重新进入就绪状态，恢复的任务会保留挂起前 的状态信息，在恢复的时候 根据挂起时的状态，继续运行。
如果被恢复任务在所有就绪态任务中，处于最高优先级列表的第一位，那么系统将进行任务上下文的切换。代码示例：
static TaskHandle_t LED_Task_Handle = NULL; /* LED 任务句柄 */ static void KEY_Task(void* parameter) { while (1) { if ( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON ) { /* K2 被按下 */ printf("恢复 LED 任务！\n"); vTaskResume(LED_Task_Handle); /* 恢复LED任务！*/ } vTaskDelay(20); /* 延时20个tick */ } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
3.3 任务删除 vTaskDelete()
vTaskDelete() 用于删除一个任务。
(1) 当一个任务 删除另外一个任务时，形参为 要删除任务 创建时返回的任务句柄；
(2) 如果是删除自身， 则形参为 NULL。要想使用该函数必须在 FreeRTOSConfig.h 中把
INCLUDE_vTaskDelete定义为 1，删除的任务将从所有 就绪，阻塞，挂起和事件列表中删除。代码示例：
/* 删除任务本身 */ vTaskDelete( NULL ); /* 在其他任务删除 DeleteTask 任务 */ vTaskDelete( DeleteHandle );- 1
- 2
- 3
- 4
- 5
- 6
3.4 阻塞延时函数
3.4.1 相对延时函数 vTaskDelay()
阻塞延时的阻塞,是指任务调用该延时函数后，任务会被剥离 CPU 使用权，然后进入阻塞状态，直到延时结束，任务重新获取 CPU 使用权才可以继续运行。在任务阻塞的这段时间，CPU可以去执行其它的任务，如果其它的任务也在延时状态，那么 CPU就将运行空闲任务。延时的时长由形参
xTicksToDelay决定，单位为系统节拍周期， 比如系统的时钟节拍周期为 1ms，那么调用 vTaskDelay(1) 的延时时间则为 1ms。vTaskDelay() 延时是相对性的延时，它指定的延时时间是从调用 vTaskDelay() 结束后开始计算的，经过指定的时间后延时结束。
比如 vTaskDelay(100)， 从调用 vTaskDelay() 结束后，任务进入阻塞状态，经过 100 个系统时钟节拍周期后，任务解除阻塞。因此，vTaskDelay() 并不适用与周期性执行任务的场合。此外，其它任务和中断活动，也会影响到 vTaskDelay() 的调用（比如调用前，高优先级任务抢占了当前任务），进而影响到任务的下一次执行的时间。任务的延时在实际中运用特别多，因为需要暂停一个任务，让任务放弃 CPU，延时结束后再继续运行该任务，如果任务中没有阻塞的话，比该任务优先级低的任务 则无法得到CPU的使用权，就无法运行。
代码示例：
void vTaskA( void * pvParameters ) { while (1) { // ... // 这里为任务主体代码 // ... /* 调用相对延时函数, 阻塞 1000 个 个 tick */ vTaskDelay( 1000 ); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
3.4.2 绝对延时函数 vTaskDelayUntil()
在 FreeRTOS 中，除了相对延时函数，还有绝对延时函数 vTaskDelayUntil()，这个绝对延时常用于较精确的周期运行任务，比如我有一个任务，希望它以 固定频率定期执行，而不受外部的影响，任务从上一次运行开始到下一次运行开始的时间间隔是绝对的，而不是相对的。
函数原型：
void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement );- 1
代码实例：
void vTaskA( void * pvParameters ) { /* 用于保存上次时间。调用后系统自动更新 */ static portTickType PreviousWakeTime; /* 设置延时时间，将时间转为节拍数 */ const portTickType TimeIncrement = pdMS_TO_TICKS(1000); /* 获取当前系统时间 */ PreviousWakeTime = xTaskGetTickCount(); while (1) { /* 调用绝对延时函数, 任务时间间隔为 1000 个 个 tick */ vTaskDelayUntil( &PreviousWakeTime ，TimeIncrement ); // ... // 这里为任务主体代码 // ... } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
注意：在使用的时候要将延时时间转化为系统节拍，在任务主体之前要调用延时函数。
任务会先调用 vTaskDelayUntil() 使任务进入 阻塞态，等到时间到了就从阻塞中解除，然后执行主体代码，任务主体代码执行完毕。会继续调用 vTaskDelayUntil() 使任务进入阻塞态，然后就是循环这样子执行。即使任务在执行过程中发生中断，那么也不会影响这个任务的运行周期，仅仅是缩短了阻塞的时间而已，到了要唤醒的时间依旧会将任务唤醒。
-
相关阅读:
直播系统开发：基于Nginx与Nginx-rtmp-module实现
Java基础知识回顾
【OpenCV图像处理10】图像直方图
Conda包依赖侦探：conda inspect命令全解析
NoSQL数据库介绍
这次，听人大教授讲讲分布式数据库的多级一致性｜TDSQL 关键技术突破
你10点钟还在做数据报表？套用模板，让你提前下班3小时
云原生 PostgreSQL - CrunchyData PGO 教程：创建、连接、删除 Postgres 集群
使用电销外呼系统的回拨线路真的不会封号吗？
RK3568平台开发系列讲解（调试篇）系统运行相关频率设置
- 原文地址：https://blog.csdn.net/Hongwei_1990/article/details/126695228
