02_FreeRTOS任务调度策略与挂起

最新推荐文章于 2025-02-11 15:45:43 发布
最新推荐文章于 2025-02-11 15:45:43 发布
阅读量1.1k 收藏 9
点赞数 27
分类专栏： FreeRTOS 文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Zero_092/article/details/144934139
版权

目录

0. 前言

硬件平台：

  • STM32F103

1. 任务调度策略

什么是任务调度？

  • 任务调度是FreeRTOS实时操作系统中确保系统实时性的一种机制。
  • FreeRTOS通过任务调度器对任务进行调度与管理，从而确保任务在指定的时间内执行。

FreeRTOS中的任务调度机制：

  1. 抢占式调度策略：在FreeRTOS中，任务分为不同的优先级，高优先级的任务可以打断低优先级的任务，从而执行高优先级的任务。
  2. 时间片轮询策略：在FreeRTOS中，如果相同优先级的任务，采用时间片轮询的机制进行调度管理，时间片即FreeRTOS系统分配给任务的执行时间，当执行时间消耗完后，切换下一个任务进行执行。

1.1 抢占式调度示例

示例说明：

  1. 在起始任务中创建两个任务
    1. Task1
    2. Task2
  2. 任务1的优先级设置为3，每500ms打印一次Task1，这里让高优先级的任务1s后再执行
  3. 任务2的优先级设置为2，每500ms打印一次Task2

FreeRTOSConfig配置文件：
![[Pasted image 20250104120456.png]]

起始任务相关配置：

/* 起始任务相关配置 */
void startFunc(void *args);                         /* 起始任务的执行函数 */
#define START_NAME "Start"                          /* 起始任务的名称 */
#define START_STACK_DEPTH 128                       /* 起始任务执行函数的参数 */
#define START_PRIORITY 5                            /* 起始任务优先级 */
TaskHandle_t startHandle;                           /* 起始任务代码控制块结构体：存放起始任务的信息 */

Task1相关配置：

/* Task1相关配置 */
void task1Func(void *args);                         /* Task1任务的执行函数 */
#define TASK1_NAME "Start"                          /* Task1任务的名称 */
#define TASK1_STACK_DEPTH 128                       /* Task1任务执行函数的参数 */
#define TASK1_PRIORITY 3                            /* Task1任务优先级 */
TaskHandle_t task1Handle;                           /* Task1任务代码控制块结构体：存放起始任务的信息 */

Task2相关配置：

/* Task2相关配置 */
void task2Func(void *args);                         /* Task2任务的执行函数 */
#define TASK2_NAME "Start"                          /* Task2任务的名称 */
#define TASK2_STACK_DEPTH 128                       /* Task2任务执行函数的参数 */
#define TASK2_PRIORITY 2                            /* Task2任务优先级 */
TaskHandle_t task2Handle;                           /* Task2任务代码控制块结构体：存放起始任务的信息 */

系统启动函数：

  1. 创建起始任务
  2. 启动任务调度器
/* 启动操作系统 */
void FreeRTOS_Start(void)
{
    /* 1. 创建起始任务 */
    xTaskCreate(
        startFunc,                              
        START_NAME,                             
        START_STACK_DEPTH,                      
        NULL,                                   
        START_PRIORITY,                         
        &startHandle                            
    );

    /* 2. 启动任务调度器 */
    vTaskStartScheduler();
}

起始任务执行函数：

  1. 让代码进入临界区，进入临界区确保代码执行的时候不被中断打断
  2. 创建任务1和任务2
  3. 代码退出临界区
  4. 回收起始任务，参数为NULL表示回收任务本身，也可以输入任务的控制块结构体
void startFunc(void *args)                          /* 起始任务的执行函数 */
{
    /* 1. 让代码进入临界区，防止中断被打断 */
    vPortEnterCritical();
    debug_printfln("起始任务开始执行...");

    /* 2. 创建Task1和Task2 */
    xTaskCreate(                                    /* Task1 */
        task1Func,                              
        TASK1_NAME,                             
        TASK1_STACK_DEPTH,                      
        NULL,                                   
        TASK1_PRIORITY,                         
        &task1Handle                            
    );
    xTaskCreate(                                    /* Task2 */
        task2Func,                              
        TASK2_NAME,                             
        TASK2_STACK_DEPTH,                      
        NULL,                                   
        TASK2_PRIORITY,                         
        &task2Handle                            
    );

    /* 3. 代码退出临界区 */
    debug_printfln("起始任务执行完毕...");
    portEXIT_CRITICAL();

    /* 4. 回收起始任务 */
    vTaskDelete(NULL);
}

任务1与任务2执行函数：

  • Delay_ms与vTaskDelay的区别：
    1. Delay_ms是自己写的延时函数，本质是让cpu计算计数，达到指定时间，占用cpu资源
    2. vTaskDelay是FreeRTOS提供的延时函数，让任务进入阻塞状态，暂停程序的运行
void task1Func(void *args)                          /* Task1任务的执行函数 */
{
    vTaskDelay(1000);                               /* 延时1s后再执行 */
    while (1)
    {
        debug_printfln("Task1...");
        Delay_ms(500);
    }
    
}

void task2Func(void *args)                          /* Task2任务的执行函数 */
{
    while (1)
    {
        debug_printfln("Task2...");
        Delay_ms(500);
    }
    
}

在main函数中调用系统启动函数：
![[Pasted image 20250104120550.png]]

执行状况：

  • 1s之前执行低优先级任务2
  • 1s之后执行高优先级任务1
    ![[Pasted image 20250104115800.png]]

1.2 时间片轮询调度示例

在抢占式调度示例中的代码保持不变，只将对应的任务优先级都改为2

  • 同时删除任务1的延时1s
    ![[Pasted image 20250104120725.png]]

执行状况：

  • 每个任务根据时间片进行轮询执行
    这里可以看到，代码在答应的时候，时间片轮询时间到了，暂停输出打印另外的任务。
    ![[Pasted image 20250104121630.png]]

解决方法：

  • 将打印函数放入临界区内执行
    ![[Pasted image 20250104121811.png]]

![[Pasted image 20250104121839.png]]

FreeRTOS_Demo.h

#ifndef __FREERTOS_DEMO_H
#define __FREERTOS_DEMO_H

#include "FreeRTOS.h"
#include "task.h"

/* 调式 */
#include "Common_Debug.h"
#include "Common_Delay.h"

/* 1. 启动操作系统 */
void FreeRTOS_Start(void);

#endif

FreeRTOSDemo.c

#include "FreeRTOS_Demo.h"

/* 起始任务相关配置 */
void startFunc(void *args);                         /* 起始任务的执行函数 */
#define START_NAME "Start"                          /* 起始任务的名称 */
#define START_STACK_DEPTH 128                       /* 起始任务执行函数的参数 */
#define START_PRIORITY 5                            /* 起始任务优先级 */
TaskHandle_t startHandle;                           /* 起始任务代码控制块结构体：存放起始任务的信息 */

/* Task1相关配置 */
void task1Func(void *args);                         /* Task1任务的执行函数 */
#define TASK1_NAME "Start"                          /* Task1任务的名称 */
#define TASK1_STACK_DEPTH 128                       /* Task1任务执行函数的参数 */
#define TASK1_PRIORITY 2                            /* Task1任务优先级 */
TaskHandle_t task1Handle;                           /* Task1任务代码控制块结构体：存放起始任务的信息 */

/* Task2相关配置 */
void task2Func(void *args);                         /* Task2任务的执行函数 */
#define TASK2_NAME "Start"                          /* Task2任务的名称 */
#define TASK2_STACK_DEPTH 128                       /* Task2任务执行函数的参数 */
#define TASK2_PRIORITY 2                            /* Task2任务优先级 */
TaskHandle_t task2Handle;                           /* Task2任务代码控制块结构体：存放起始任务的信息 */

/* 启动操作系统 */
void FreeRTOS_Start(void)
{
    /* 1. 创建起始任务 */
    xTaskCreate(
        startFunc,                              
        START_NAME,                             
        START_STACK_DEPTH,                      
        NULL,                                   
        START_PRIORITY,                         
        &startHandle                            
    );

    /* 2. 启动任务调度器 */
    vTaskStartScheduler();
}

void startFunc(void *args)                          /* 起始任务的执行函数 */
{
    /* 1. 让代码进入临界区，防止中断被打断 */
    vPortEnterCritical();
    debug_printfln("起始任务开始执行...");

    /* 2. 创建Task1和Task2 */
    xTaskCreate(                                    /* Task1 */
        task1Func,                              
        TASK1_NAME,                             
        TASK1_STACK_DEPTH,                      
        NULL,                                   
        TASK1_PRIORITY,                         
        &task1Handle                            
    );
    xTaskCreate(                                    /* Task2 */
        task2Func,                              
        TASK2_NAME,                             
        TASK2_STACK_DEPTH,                      
        NULL,                                   
        TASK2_PRIORITY,                         
        &task2Handle                            
    );

    /* 3. 代码退出临界区 */
    debug_printfln("起始任务执行完毕...");
    portEXIT_CRITICAL();

    /* 4. 回收起始任务 */
    vTaskDelete(NULL);
}

void task1Func(void *args)                          /* Task1任务的执行函数 */
{
    while (1)
    {
        portENTER_CRITICAL();
        debug_printfln("Task1...");
        portEXIT_CRITICAL();
        Delay_ms(500);
    }
    
}

void task2Func(void *args)                          /* Task2任务的执行函数 */
{
    while (1)
    {
        portENTER_CRITICAL();
        debug_printfln("Task2...");
        portEXIT_CRITICAL();
        Delay_ms(500);
    }
    
}

extern void xPortSysTickHandler(void);
void  SysTick_Handler(void)
{
    if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)
    {
        xPortSysTickHandler();
    }
}

2. 任务挂起与恢复

什么是任务挂起？

  • 任务挂起是FreeRTOS提供的一中让任务进入暂停状态的机制，方便开发者在指定情况下对任务进行挂起以等待其他时间的发生。

2.1 任务挂起与恢复相关API

任务挂起与恢复常用API：

  • vTaskSuspend：挂起任务API
  • vTaskResume：恢复任务API
  • xTaskResumeFromISR：在中断中恢复任务API

2.1.1 挂起任务API - vTaskSuspend

函数说明：

  • 注意实现： 宏定义INCLUDE_vTaskSuspend设置为1
  • 参数：挂起任务的控制块结构体
void vTaskSuspend( TaskHandle_t xTaskToSuspend );

2.1.2 恢复任务API - vTaskResume

函数说明：

  • 注意实现： 宏定义INCLUDE_vTaskSuspend设置为1
  • 参数：恢复任务的控制块结构体
void vTaskResume( TaskHandle_t xTaskToResume );

2.1.3 在中断中恢复任务API - xTaskResumeFromISR

函数说明：

  • 注意实现： 宏定义INCLUDE_vTaskSuspend与INCLUDE_xTaskResumeFromISR均设置为1
  • 参数：恢复任务的控制块结构体
  • return：
    • pdTRUE：恢复任务同时切换上下文
    • pdFALSE：ISR 使用此信息来确定 ISR 之后是否需要上下文切换。
BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume );

2.2 挂起与恢复示例

示例说明：

  • 使用时间片轮询调度策略的代码进行修改
  • 添加任务3：
    • 对按键进行扫描，KEY1挂起任务1，KEY2恢复任务1

Task3相关配置：

/* Task3相关配置 */
void task3Func(void *args);                         /* Task3任务的执行函数 */
#define TASK3_NAME "Start"                          /* Task3任务的名称 */
#define TASK3_STACK_DEPTH 128                       /* Task3任务执行函数的参数 */
#define TASK3_PRIORITY 3                            /* Task3任务优先级 */
TaskHandle_t task3Handle;                           /* Task3任务代码控制块结构体：存放起始任务的信息 */

起始任务执行函数：

  • 创建任务3
void startFunc(void *args)                          /* 起始任务的执行函数 */
{
    /* 1. 让代码进入临界区，防止中断被打断 */
    vPortEnterCritical();
    debug_printfln("起始任务开始执行...");

    /* 2. 创建Task1和Task2 */
    xTaskCreate(                                    /* Task1 */
        task1Func,                              
        TASK1_NAME,                             
        TASK1_STACK_DEPTH,                      
        NULL,                                   
        TASK1_PRIORITY,                         
        &task1Handle                            
    );
    xTaskCreate(                                    /* Task2 */
        task2Func,                              
        TASK2_NAME,                             
        TASK2_STACK_DEPTH,                      
        NULL,                                   
        TASK2_PRIORITY,                         
        &task2Handle                            
    );
    xTaskCreate(                                    /* Task3 */
        task3Func,                              
        TASK3_NAME,                             
        TASK3_STACK_DEPTH,                      
        NULL,                                   
        TASK3_PRIORITY,                         
        &task3Handle                            
    );

    /* 3. 代码退出临界区 */
    debug_printfln("起始任务执行完毕...");
    portEXIT_CRITICAL();

    /* 4. 回收起始任务 */
    vTaskDelete(NULL);
}

任务3执行代码；

  • 带按键进行扫描
  • 每50ms进行扫描一次
void task3Func(void *args)                         /* Task3任务的执行函数 */
{
    uint8_t key;
    while (1)
    {
        key = Inf_Key_Detect();
        switch (key)
        {
        case KEY1_PRESS:                            /* 按键1被按下 */
            debug_printfln("Task1挂起...");
            vTaskSuspend(task1Handle);              /* 挂起任务 */
            break;
        case KEY2_PRESS:                            /* 按键2被按下 */
            debug_printfln("Task1恢复...");
            vTaskResume(task1Handle);               /* 恢复任务 */
            break;
        }
        vTaskDelay(50);
    }
    
}

执行状况：

  • 按下key1，任务1挂起，剩下任务2在打印信息
  • 按下key2，任务1恢复，恢复任务1执行，继续打印信息
    ![[Pasted image 20250104123130.png]]

3. 结语

FreeRTOS通过任务调度器对任务进行调度，从而确保系统的实时性，FreeRTOS的调度策略分为抢占式调度和时间片轮询调度，抢占式调度是高优先级打断低优先级任务，执行高优先级任务，时间片轮询为相同任务优先级，每个任务执行相同的时间片。

文章声明：

  • 本文章为作者学习FreeRTOS实时操作系统的笔记与巩固输出，欢迎同行交流与指教，文章借鉴来源小破站的某谷RTOS教程。

FreeRTOSDemo.h文件代码

#ifndef __FREERTOS_DEMO_H
#define __FREERTOS_DEMO_H

#include "FreeRTOS.h"
#include "task.h"

/* 调式 */
#include "Common_Debug.h"
#include "Common_Delay.h"

/* 按键驱动 */
#include "Inf_Key.h"

/* 1. 启动操作系统 */
void FreeRTOS_Start(void);

#endif

FreeRTOSDemo.c文件代码

#include "FreeRTOS_Demo.h"

/* 起始任务相关配置 */
void startFunc(void *args);                         /* 起始任务的执行函数 */
#define START_NAME "Start"                          /* 起始任务的名称 */
#define START_STACK_DEPTH 128                       /* 起始任务执行函数的参数 */
#define START_PRIORITY 5                            /* 起始任务优先级 */
TaskHandle_t startHandle;                           /* 起始任务代码控制块结构体：存放起始任务的信息 */

/* Task1相关配置 */
void task1Func(void *args);                         /* Task1任务的执行函数 */
#define TASK1_NAME "Start"                          /* Task1任务的名称 */
#define TASK1_STACK_DEPTH 128                       /* Task1任务执行函数的参数 */
#define TASK1_PRIORITY 2                            /* Task1任务优先级 */
TaskHandle_t task1Handle;                           /* Task1任务代码控制块结构体：存放起始任务的信息 */

/* Task2相关配置 */
void task2Func(void *args);                         /* Task2任务的执行函数 */
#define TASK2_NAME "Start"                          /* Task2任务的名称 */
#define TASK2_STACK_DEPTH 128                       /* Task2任务执行函数的参数 */
#define TASK2_PRIORITY 2                            /* Task2任务优先级 */
TaskHandle_t task2Handle;                           /* Task2任务代码控制块结构体：存放起始任务的信息 */

/* Task3相关配置 */
void task3Func(void *args);                         /* Task3任务的执行函数 */
#define TASK3_NAME "Start"                          /* Task3任务的名称 */
#define TASK3_STACK_DEPTH 128                       /* Task3任务执行函数的参数 */
#define TASK3_PRIORITY 3                            /* Task3任务优先级 */
TaskHandle_t task3Handle;                           /* Task3任务代码控制块结构体：存放起始任务的信息 */

/* 启动操作系统 */
void FreeRTOS_Start(void)
{
    /* 1. 创建起始任务 */
    xTaskCreate(
        startFunc,                              
        START_NAME,                             
        START_STACK_DEPTH,                      
        NULL,                                   
        START_PRIORITY,                         
        &startHandle                            
    );

    /* 2. 启动任务调度器 */
    vTaskStartScheduler();
}

void startFunc(void *args)                          /* 起始任务的执行函数 */
{
    /* 1. 让代码进入临界区，防止中断被打断 */
    vPortEnterCritical();
    debug_printfln("起始任务开始执行...");

    /* 2. 创建Task1和Task2 */
    xTaskCreate(                                    /* Task1 */
        task1Func,                              
        TASK1_NAME,                             
        TASK1_STACK_DEPTH,                      
        NULL,                                   
        TASK1_PRIORITY,                         
        &task1Handle                            
    );
    xTaskCreate(                                    /* Task2 */
        task2Func,                              
        TASK2_NAME,                             
        TASK2_STACK_DEPTH,                      
        NULL,                                   
        TASK2_PRIORITY,                         
        &task2Handle                            
    );
    xTaskCreate(                                    /* Task3 */
        task3Func,                              
        TASK3_NAME,                             
        TASK3_STACK_DEPTH,                      
        NULL,                                   
        TASK3_PRIORITY,                         
        &task3Handle                            
    );

    /* 3. 代码退出临界区 */
    debug_printfln("起始任务执行完毕...");
    portEXIT_CRITICAL();

    /* 4. 回收起始任务 */
    vTaskDelete(NULL);
}

void task1Func(void *args)                          /* Task1任务的执行函数 */
{
    while (1)
    {
        portENTER_CRITICAL();
        debug_printfln("Task1...");
        portEXIT_CRITICAL();
        Delay_ms(500);
    }
    
}

void task2Func(void *args)                          /* Task2任务的执行函数 */
{
    while (1)
    {
        portENTER_CRITICAL();
        debug_printfln("Task2...");
        portEXIT_CRITICAL();
        Delay_ms(500);
    }
    
}

void task3Func(void *args)                         /* Task3任务的执行函数 */
{
    uint8_t key;
    while (1)
    {
        key = Inf_Key_Detect();
        switch (key)
        {
        case KEY1_PRESS:                            /* 按键1被按下 */
            debug_printfln("Task1挂起...");
            vTaskSuspend(task1Handle);              /* 挂起任务 */
            break;
        case KEY2_PRESS:                            /* 按键2被按下 */
            debug_printfln("Task1恢复...");
            vTaskResume(task1Handle);               /* 恢复任务 */
            break;
        }
        vTaskDelay(50);
    }
    
}

extern void xPortSysTickHandler(void);
void  SysTick_Handler(void)
{
    if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)
    {
        xPortSysTickHandler();
    }
}
FreeRTOS任务调度(抢占式、协作式、时间片轮转)
戚晨夕的博客
09-08 2878
FreeRTOS 是一个开源的实时操作系统，它支持多种调度策略，包括协作式（cooperative）和抢占式（preemptive）调度。可以看出，开启了抢占式和时间片轮转两种调度算法时，高优先级的任务一旦就绪，就能抢占低优先级的CPU执行权；如果有两个同优先级的任务都可以运行，则它们之间是时间片轮转方式调度。抢占式调度和时间片轮转两种任务的切换方式，可以说是FreeRTOS系统最核心的功能。
FreeRTOS任务挂起和恢复实验
06-12
“FreeRTOS学习笔记——FreeRTOS任务挂起和恢复实验”博客所用代码
4. FreeRTOS任务调度和任务状态
最新发布
weixin_74473465的博客
02-11 955
在本章节中，我们会涉及以下内容：FreeRTOS调度任务调度器、FreeRTOS的任务调度方式 、FreeRTOS的四种任务状态
FreeRTOS任务挂起和恢复
qq_23852045的博客
09-26 513
挂起和恢复函数： /* 功能：挂起一个任务; 参数：xTaskToSuspend xTaskToSuspend = xTaskCreate(); xTaskToSuspend = xTaskCreateStatic(); xTaskToSuspend = xTaskGetHandle(); 或通过xTaskCreate & xTaskCreateStatic两个函数的最后一个形参 这四种方式获得要挂起任务的句柄。 若xTaskToSuspend = NULL 挂起任务本身 */ vo
【FreeRTOS】FreeRTOS 任务挂起与恢复（包括在中断中恢复）
FuckerGod的博客
06-28 2407
动态创建任务需要使用到函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转根据上方的描述我们可以得知，必须将定义为 1 才能使用此函数。暂停任意任务，无论任务优先级如何，任务被暂停后将无法获取任何微控制器处理时间。对的调用不会累积次数，例如：若在同一任务上调用两次，将仍然仅需调用一次，即可恢复暂停的任务。
【3】STM32·FreeRTOS·任务挂起和恢复
Cute758的博客
05-09 1273
形参描述待挂起任务的任务句柄1、此函数用于挂起任务，使用时需将宏 INCLUDE_vTaskSuspend 配置为 12、当传入的参数为NULL，则代表挂起任务自身（当前正在运行的任务）无论优先级如何，被挂起的任务都将不再被执行，直到任务被恢复形参描述待恢复任务的任务句柄使用该函数注意宏：INCLUDE_vTaskSuspend 必须定义为 1任务无论被 vTaskSuspend() 挂起多少次，只需在任务中调用 vTaskResume() 恢复一次，就可以继续运行。且被恢复的任务会进入就绪态！
FreeRTOS 任务的挂起与恢复
上山的月的博客
07-22 1417
在FreeRTOS中，任务的挂起与恢复是控制任务执行状态的重要手段，通过这两个操作可以实现任务的灵活调度和管理。本篇内容关于任务挂起与恢复解释、使用、说明了其他博客未曾注意到的抢占优先级和中断优先级的详细说明
FreeRTOS任务管理_FreeRTOS任务管理_freertos_freertos任务_任务管理_野火freertos_
10-04
4. **任务调度（Task Scheduling）**：FreeRTOS使用抢占式调度策略，这意味着如果一个高优先级任务变为可运行状态，即使当前运行的是低优先级任务，系统也会立即切换到高优先级任务。此外，FreeRTOS还支持时间片轮转...
FreeRTOS实时内核使用指南-中文.zip_FREERTOS 中文_FreeRTOS中文_freertos_stm32f10
09-22
理解任务的状态（运行、阻塞、挂起）和上下文切换的过程。 3. **同步与通信**：学习信号量、互斥锁、事件标志组的用法，这些同步机制可以防止多个任务同时访问共享资源，确保数据的一致性。 4. **内存管理**：了解...
FreeRTOS_Reference_Manual_V10.0.0.pdf_freertos_
09-29
FreeRTOS的调度策略是基于优先级的抢占式调度，意味着高优先级的任务一旦就绪，会立即抢占正在运行的低优先级任务。FreeRTOS也支持时间片轮转，允许低优先级任务在一定时间内运行。 FreeRTOS提供了丰富的API接口，...
FreeRTOS_实用指南_freertos_freertos编程指南_
10-01
FreeRTOS 还提供了任务挂起、恢复和删除等功能，以便在运行时动态调整任务状态。 2. **同步机制**：在多任务环境中，同步是至关重要的。FreeRTOS 提供了信号量、互斥锁和事件标志组用于任务间的同步。例如，信号量...
FreeRTOS实验FreeRTOS任务挂起和恢复实验.zip
06-19
本实验“FreeRTOS任务挂起和恢复实验”着重于理解FreeRTOS中的两个关键操作：任务挂起与恢复，这对于优化系统资源管理和控制流程至关重要。本文将详细讲解这两个概念以及它们在STM32微控制器中的应用。 首先，我们...
FreeRTOS任务的挂起和恢复
qq_45973003的博客
04-15 1126
4：如果挂起的是任务自身 【调度器正在运行，强制进行一次任务切换】，调度器没有运行【是：代表任务均被挂起，则当前的控制块赋值为NULL】【否：通过函数vTaskSwitchContext寻找下一个最高优先级任务】3：判断任务调度器是否在运行，如果在运行，更新下一次阻塞时间，防止被挂起任务为下一次阻塞超时。1：根据任务句柄来挂起任务控制块，如果热虐句柄为NULL表示要挂起任务自身。2：将要挂起的任务从相应的状态列表中移除。
FreeRTOS之任务挂起和恢复函数
linuxweiyh的博客
10-10 3582
1.任务挂起和恢复相关的函数如下 vTaskSuspend()：挂起一个任务 vTaskResume()：恢复一个任务的运行 vTaskResumeFromISR()：中断服务函数中恢复一个任务的运行2.函数的详细描述 (1)函数vTaskSuspend() 该函数用于将某个任务设置为挂起态。 进入挂起态的任务永远都不会进入运行态，退出挂起态的唯一方法就是调用任务恢复函数vTaskRes
FreeRTOS任务的挂起和恢复 | FreeRTOS四
qq_57663276的博客
02-01 2727
FreeRTOS任务的挂起和恢复
FreeRTOS实时操作系统（三）任务挂起与恢复
贾saisai的博客
06-18 2165
继续跟着正点原子学习FreeRTOS之任务挂起与恢复。
【04】FreeRTOS的任务挂起与恢复
小浪宝宝的博客
01-18 2002
参数介绍：待挂起任务的任务句柄（想挂起哪个任务，就传入哪个任务的任务句柄此函数用于挂起任务，使用时需要将FreeRTOSCofig.h中的宏配置为1。无论优先级多高，被挂起的任务都将不再执行，直到任务被恢复。注意：当传入的参数为NULL，则代表挂起任务自身（当前正在运行的任务），和删除任务类似。任务中恢复挂起函数如下所示（在任务函数中被调用：待恢复任务的任务句柄。使用此函数需要将FreeRTOSConfig.h中的宏配置为1，和挂起任务需要配置的宏是同一个。注意：任务无论被。
FreeRTOS系列|任务挂起和恢复
安迪西_嵌入式攻城狮
01-05 2039
任务挂起和恢复
FreeRTOS操作系统——任务挂起与恢复（二）
戚晨夕的博客
01-16 2381
FreeRTOS操作系统学习 文章目录FreeRTOS操作系统学习前言一、任务挂起与恢复二、任务挂起与恢复1.代码实战总结 前言 功能：有时候我们需要暂停某个任务的运行，过一段时间以后在重新运行。这个时候要是使用任 务删除和重建的方法的话那么任务中变量保存的值肯定丢失了！FreeRTOS 给我们提供了解决 这种问题的方法，那就是任务挂起和恢复，当某个任务要停止运行一段时间的话就将这个任务 挂起，当要重新运行这个任务的话就恢复这个任务的运行。 一、任务挂起与恢复 API函数： vTaskSuspend()
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值