【FreeRTOS】FreeRTOS 动态创建任务与删除

已于 2024-01-22 11:21:58 修改
阅读量907 收藏 5
点赞数 1
分类专栏： FreeRTOS stm32 文章标签： 单片机 嵌入式硬件 stm32
于 2023-06-19 00:15:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FuckerGod/article/details/131277422
版权

0. 实验准备

正点原子 STM32407ZG 探索者开发板
FreeRTOS 例程模板（可以在这一篇文章找到：STM32F407 移植 FreeRTOS）

1. 动态创建任务函数 API

1.1 函数简介

动态创建任务需要使用到 BaseType_t xTaskCreate函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转

在这里插入图片描述

根据上方的描述我们可以得知，此函数将会创建一个新任务，并将其添加到就绪任务列表中。在 FreeRTOSConfig.h 中，configSUPPORT_DYNAMIC_ALLOCATION 必须设置为 1，或者不定义(在这种情况下，它将默认为1)，以便此函数可以使用。
每个任务都需要用于保存任务状态的 RAM，并被任务用作其堆栈。如果使用 xTaskCreate() 创建任务，则会从 FreeRTOS 堆中自动分配所需的 RAM。如果使用 xTaskCreateStatic() （静态创建任务的函数，后续会讲）创建任务，则 RAM 由应用程序编写者提供，因此可以在编译时静态分配。

1.2 入参详解

同样是在官方文档的下面可以查看到下图的文字

在这里插入图片描述

  • pvTaskCode：
  • pcName：
  • usStackDepth：
  • pvParameters：
  • uxPriority：
  • pxCreatedTask：

2. 动态创建任务步骤

根据上面的描述，我们可以整理出动态创建任务的步骤有三步：

  1. 将宏 configSUPPORT_DYNAMIC_ALLOCATION 配置为 1
  2. 定义函数入口参数
  3. 编写任务函数

3. 删除任务函数 API

3.1 函数简介

在这里插入图片描述
根据上方的描述我们可以得知，INCLUDE_vTaskDelete 必须定义为1才能使用此函数。此函数可以从 RTOS 内核管理中删除一个任务。被删除的任务将从所有就绪、阻塞、挂起和事件列表中删除。

注意：空闲任务负责从已删除的任务中释放 RTOS 内核分配的内存。因此，如果您的应用程序调用 vTaskDelete()，那么空闲任务需要处理器的时间是很重要的。由任务代码分配的内存不会自动释放，应该在删除任务之前释放。

3.2 入参详解

在这里插入图片描述

  • xTask：要删除的任务句柄。传递NULL将导致调用任务（自身）被删除。

4. 编程实战

4.1 实验设计

实现如下的功能：

  • 设计四个任务：start_task、task1、task2、task3
  • start_task：用来创建其他的三个任务
  • task1：实现 LED0 每 500ms 闪烁一次
  • task2：实现 LED1 每 500ms 闪烁一次
  • task3：判断按键 KEY0 是否按下，按下则删掉 task1

4.2 编写代码

首先打开我们的 FreeRTOS 例程模板（在文章顶部的实验准备中可以找到），打开 FREERTOS_config.h ，找到 configSUPPORT_DYNAMIC_ALLOCATION 配置为 1 ，如下图所示

在这里插入图片描述
然后打开 freertos_demo.c ，如下图所示

在这里插入图片描述
此时的 freertos_demo.c 是测试 FreeRTOS 是否移植成功的代码，这里全部进行删除，替换为如下的代码，然后从头开始编写创建任务的代码

#include "freertos_demo.h"
#include "./SYSTEM/usart/usart.h"
#include "./BSP/LED/led.h"
#include "./BSP/LCD/lcd.h"
/*FreeRTOS*********************************************************************************************/
#include "FreeRTOS.h"
#include "task.h"

/******************************************************************************************************/
/*FreeRTOS配置*/


/******************************************************************************************************/

/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
    vTaskStartScheduler();                              /* 开启任务调度器 */
}

其中 freertos_demo 会在主函数中进行调用，这里进行保留

4.2.1 start_task 的动态创建任务的编写

我们可以从官网获取到 xTaskCreate 的模板，也可以根据官网的描述在 task. h 中获取到 xTaskCreate 的函数原型。下面是 xTaskCreate 的函数原型

BaseType_t xTaskCreate(    TaskFunction_t pvTaskCode,
                            const char * const pcName,
                            configSTACK_DEPTH_TYPE usStackDepth,
                            void *pvParameters,
                            UBaseType_t uxPriority,
                            TaskHandle_t *pxCreatedTask
                          );

下面将以 start_task 为例来讲解任务创建的流程：

  1. TaskFunction_t pvTaskCode 是任务函数，这里是需要我们执行的任务函数的代码，所以我们可以在代码开始的部分对任务函数进行声明，如下所示
void start_task(void *pvParameters);        /* 任务函数 */
  1. const char * const pcName 是任务名字，这里和任务函数的名字保持一致即也是 "start_task"
  2. configSTACK_DEPTH_TYPE usStackDepth 是任务堆栈大小，这里我们可以参考官方的方式也定义一个宏定义，后续可以通过修改宏定义的方式来更改堆栈大小，方便维护
#define START_STK_SIZE  128                 /* 任务堆栈大小 */
  1. void *pvParameters 是函数传参，这里暂时没有于是写 NULL
  2. UBaseType_t uxPriority 是任务优先级，数值越大优先级越靠前，这里也使用宏定义的方式，然后将 start_task 的优先级设置为 1，即最低优先级
#define START_TASK_PRIO 1                   /* 任务优先级 */
  1. TaskHandle_t *pxCreatedTask 是任务句柄，需要我们在开头定义一个 TaskHandle_t 类型的句柄作为参数传入
TaskHandle_t            StartTask_Handler;  /* 任务句柄 */
  1. 然后在 freertos_demo 中调用，完整的代码如下所示
/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO 1                   /* 任务优先级 */
#define START_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            StartTask_Handler;  /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
    xTaskCreate((TaskFunction_t )start_task,            /* 任务函数 */
                (const char*    )"start_task",          /* 任务名称 */
                (uint16_t       )START_STK_SIZE,        /* 任务堆栈大小 */
                (void*          )NULL,                  /* 传入给任务函数的参数 */
                (UBaseType_t    )START_TASK_PRIO,       /* 任务优先级 */
                (TaskHandle_t*  )&StartTask_Handler);   /* 任务句柄 */
    vTaskStartScheduler();                              /* 开启任务调度器 */
}

4.2.2 start_task 的任务编写

start_task 任务的使命是创建 task1、task2、task3 这三个任务，而创建 task1、task2、task3 这三个任务和创建 start_task 的方式一模一样。由于我们只希望 start_task 里的代码执行一次，所以希望他执行后销毁掉自己的任务，所以在 start_task 函数的末尾增加下面的代码来删除掉自己。

vTaskDelete(StartTask_Handler); /* 删除开始任务 */

分别设置 task1-3 的任务优先级为 2-4 ，堆栈大小都为 128，有了 start_task 任务的创建经验，如法炮制的在 start_task 函数中编写出以下的代码，

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO 1                   /* 任务优先级 */
#define START_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            StartTask_Handler;  /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/* TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK1_PRIO      2                   /* 任务优先级 */
#define TASK1_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task1Task_Handler;  /* 任务句柄 */
void task1(void *pvParameters);             /* 任务函数 */

/* TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK2_PRIO      3                   /* 任务优先级 */
#define TASK2_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task2Task_Handler;  /* 任务句柄 */
void task2(void *pvParameters);             /* 任务函数 */

/* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO      4                   /* 任务优先级 */
#define TASK3_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task3Task_Handler;  /* 任务句柄 */
void task3(void *pvParameters);             /* 任务函数 */

/******************************************************************************************************/

/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
    xTaskCreate((TaskFunction_t )start_task,            /* 任务函数 */
                (const char*    )"start_task",          /* 任务名称 */
                (uint16_t       )START_STK_SIZE,        /* 任务堆栈大小 */
                (void*          )NULL,                  /* 传入给任务函数的参数 */
                (UBaseType_t    )START_TASK_PRIO,       /* 任务优先级 */
                (TaskHandle_t*  )&StartTask_Handler);   /* 任务句柄 */
    vTaskStartScheduler();                              /* 开启任务调度器 */
}

/**
 * @brief       start_task
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void start_task(void *pvParameters)
{
    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task1,
                (const char*    )"task1",
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_PRIO,
                (TaskHandle_t*  )&Task1Task_Handler);
    /* 创建任务2 */
    xTaskCreate((TaskFunction_t )task2,
                (const char*    )"task2",
                (uint16_t       )TASK2_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler);
    /* 创建任务3 */
    xTaskCreate((TaskFunction_t )task3,
                (const char*    )"task3",
                (uint16_t       )TASK3_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK3_PRIO,
                (TaskHandle_t*  )&Task3Task_Handler);
    vTaskDelete(StartTask_Handler); /* 删除开始任务 */
}

4.2.3 task1、task2、task3 的任务编写

task1/2 的任务为 500ms 翻转一次 LED0/1，需要注意的是，在这里不能调用普通的延时函数，需要使用 FreeRTOS 提供的延时函数 vTaskDelay（后续会讲解） 来实现延时功能。下面是具体的代码（加入了串口打印的部分，后面会用于查看任务执行顺序）

/* 任务一，实现LED0每500ms翻转一次 */
void task1( void * pvParameters )
{
    while(1)
    {
        printf("task1正在运行！！！\r\n");
        LED0_TOGGLE();
        vTaskDelay(500);
    }
}

/* 任务二，实现LED1每500ms翻转一次 */
void task2( void * pvParameters )
{
    while(1)
    {
        printf("task2正在运行！！！\r\n");
        LED1_TOGGLE();
        vTaskDelay(500);
    }
}

task3 的任务需要使用到按键，按键的头文件需要在开头导入一下，由于按下按键我们希望删除 task1 ，但是如果当 task1 已经被删除了，再次按下按键就会出现不可预估的后果，所以在删除 task1 前，我们先对他的句柄进行一个非空判断，在删除 task1 后，将 task1 的句柄设置为空。编写的代码如下所示

#include "./BSP/KEY/key.h"

/* 任务三，判断按键KEY0，按下KEY0删除task1 */
void task3( void * pvParameters )
{
    uint8_t key = 0;
    while(1)
    {
        printf("task3正在运行！！！\r\n");
        key = key_scan(0);
        if(key == KEY0_PRES)
        {
            if(Task1Task_Handler != NULL)
            {
                printf("删除task1任务\r\n");
                vTaskDelete(Task1Task_Handler);
                Task1Task_Handler = NULL;
            }
        }
        vTaskDelay(10);
    }
}

至此，全部的代码已经编写完毕，完整的 freertos_demo.c 代码如下所示

#include "freertos_demo.h"
#include "./SYSTEM/usart/usart.h"
#include "./BSP/LED/led.h"
#include "./BSP/LCD/lcd.h"
#include "./BSP/KEY/key.h"
/*FreeRTOS*********************************************************************************************/
#include "FreeRTOS.h"
#include "task.h"

/******************************************************************************************************/
/*FreeRTOS配置*/

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO 1                   /* 任务优先级 */
#define START_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            StartTask_Handler;  /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/* TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK1_PRIO      2                   /* 任务优先级 */
#define TASK1_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task1Task_Handler;  /* 任务句柄 */
void task1(void *pvParameters);             /* 任务函数 */

/* TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK2_PRIO      3                   /* 任务优先级 */
#define TASK2_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task2Task_Handler;  /* 任务句柄 */
void task2(void *pvParameters);             /* 任务函数 */

/* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO      4                   /* 任务优先级 */
#define TASK3_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task3Task_Handler;  /* 任务句柄 */
void task3(void *pvParameters);             /* 任务函数 */

/******************************************************************************************************/

/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
    xTaskCreate((TaskFunction_t )start_task,            /* 任务函数 */
                (const char*    )"start_task",          /* 任务名称 */
                (uint16_t       )START_STK_SIZE,        /* 任务堆栈大小 */
                (void*          )NULL,                  /* 传入给任务函数的参数 */
                (UBaseType_t    )START_TASK_PRIO,       /* 任务优先级 */
                (TaskHandle_t*  )&StartTask_Handler);   /* 任务句柄 */
    vTaskStartScheduler();                              /* 开启任务调度器 */
}

/**
 * @brief       start_task
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void start_task(void *pvParameters)
{
    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task1,
                (const char*    )"task1",
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_PRIO,
                (TaskHandle_t*  )&Task1Task_Handler);
    /* 创建任务2 */
    xTaskCreate((TaskFunction_t )task2,
                (const char*    )"task2",
                (uint16_t       )TASK2_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler);
    /* 创建任务3 */
    xTaskCreate((TaskFunction_t )task3,
                (const char*    )"task3",
                (uint16_t       )TASK3_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK3_PRIO,
                (TaskHandle_t*  )&Task3Task_Handler);
    vTaskDelete(StartTask_Handler); /* 删除开始任务 */
}

/* 任务一，实现LED0每500ms翻转一次 */
void task1( void * pvParameters )
{
    while(1)
    {
        printf("task1正在运行！！！\r\n");
        LED0_TOGGLE();
        vTaskDelay(500);
    }
}

/* 任务二，实现LED1每500ms翻转一次 */
void task2( void * pvParameters )
{
    while(1)
    {
        printf("task2正在运行！！！\r\n");
        LED1_TOGGLE();
        vTaskDelay(500);
    }
}

/* 任务三，判断按键KEY0，按下KEY0删除task1 */
void task3( void * pvParameters )
{
    uint8_t key = 0;
    while(1)
    {
        printf("task3正在运行！！！\r\n");
        key = key_scan(0);
        if(key == KEY0_PRES)
        {
            if(Task1Task_Handler != NULL)
            {
                printf("删除task1任务\r\n");
                vTaskDelete(Task1Task_Handler);
                Task1Task_Handler = NULL;
            }

        }
        vTaskDelay(10);
    }
}

4.2.4 验证

下载编译完成后的代码到开发板上，可以看到 LED0 和 1 以同样的频率进行闪烁，按下 KEY0 后 LED0 停止闪烁，和预计效果一致。将开发板的串口连接到电脑上，连接到串口，重新开机查看串口打印的信息，注意任务的执行顺序，如下图所示
在这里插入图片描述
可以看到先执行了 task1 先执行了，然后是 task2 和 task3，这与我们设置的优先级的顺序并不一致，这是因为在下图的函数中，打开了任务调度器，任务调度器会在就绪列表中选择任务执行，而在 start_task 函数中，我们依次创建了 task1、2、3 ，在刚创建完成 task1 时，task1 就被放入到了就绪列表（这里在上面的动态创建函数地方有讲解到），立马就被调度了，所以 task1 虽然优先级最低但是最先被执行了
在这里插入图片描述
如果我们想要在创建任务的时候不被打断（这里是希望不要被调度），可以在创建任务之前添加如下的代码

taskENTER_CRITICAL();           /* 进入临界区 */

在创建任务之后添加如下的代码

taskEXIT_CRITICAL();            /* 退出临界区 */

上面的两行代码的作用可以理解为，在这两行代码之间的操作不希望被打断，是可以被连续执行的，添加完成这两行代码后，代码执行的逻辑就应该为：
进入临界区，创建 task1 进入就绪队列，创建 task2 进入就绪队列，创建 task3 进入就绪队列，退出临界区，开始任务调度—选择优先级最高的任务也就是 task3 进入运行

4.2.5 修改代码

根据上面一小节的逻辑，我们在 start_task 函数中进行修改。修改完成后的代码如下所示

void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           /* 进入临界区 */
    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task1,
                (const char*    )"task1",
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_PRIO,
                (TaskHandle_t*  )&Task1Task_Handler);
    /* 创建任务2 */
    xTaskCreate((TaskFunction_t )task2,
                (const char*    )"task2",
                (uint16_t       )TASK2_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler);
    /* 创建任务3 */
    xTaskCreate((TaskFunction_t )task3,
                (const char*    )"task3",
                (uint16_t       )TASK3_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK3_PRIO,
                (TaskHandle_t*  )&Task3Task_Handler);
    vTaskDelete(StartTask_Handler); /* 删除开始任务 */
    taskEXIT_CRITICAL();            /* 退出临界区 */
}

4.2.6 再次验证

把修改后的代码再次烧录进开发板，然后查看任务执行顺序，发现按照我们设定的优先级顺序进行执行了
在这里插入图片描述

天地神仙
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
（免费）FreeRTOS动态创建删除任务
02-03
- **内存管理**：动态创建任务需要动态分配内存，因此了解FreeRTOS的内存分配机制（如`pvPortMalloc()`和`vPortFree()`）是必要的。 - **任务同步与通信**：FreeRTOS提供了信号量、互斥锁、消息队列等机制，用于任务...
（免费）FreeRTOS静态创建删除任务
02-03
FreeRTOS提供了两种任务创建方式：静态创建和动态创建。静态创建是在编译时确定任务的堆栈大小和任务体，从而节省内存资源，提高系统效率。动态创建则在运行时分配资源，更灵活但可能增加内存碎片。 静态创建任务时...
【FreeRTOS】——API函数&任务创建与删除&挂起与恢复
weixin_51658186的博客
05-13 959
本段时间学习的实时操作系统都是基础知识，目的在于对于FreeRTOS有个整体的理论构架，暂且不涉及实操，后续实操会专门撰写记录笔记！
[FreeRTOS 内部实现] 创建任务 xTaskCreate函数解析
weixin_43564241的博客
06-23 830
（16）STR r0, [sp, #0x190]: 将r0寄存器的值再次存储到栈指针sp地址偏移0x190的位置。（12）STR r0, [sp, #0x190]: 将r0寄存器的值存储到栈指针sp地址偏移0x190的位置。（10）STR r0, [sp, #0x00]: 将r0寄存器的值存储到栈指针sp地址偏移0的位置。（17）STR r0, [r4, #0x00]: 将r0寄存器的值存储到r4寄存器指向的地址。（11）LDR r0, [r4, #0x00]: 从r4寄存器指向的地址加载数据到r0。
FreeRTOS动态 / 静态创建和删除任务
m0_73931287的博客
02-03 1216
FreeRTOS的动态 / 静态创建和删除任务
FreeRTOS之动态创建任务与删除任务
qq_43213240的博客
04-18 497
FreeRTOS之动态创建任务和删除任务。
二、FreeRTOS动态创建任务
Holy的博客
06-06 642
FreeRTOS常用动态任务创建。FreeRTOS 做法是在 SRAM 里面定义一个大数组， 也就是堆内存，供 FreeRTOS 的动态内存分配函数使用，在第一次使用的时候，系统会将 定义的堆内存进行初始化，这些代码在 FreeRTOS 提供的内存管理方案中实现（heap_1.c、 heap_2.c、 heap_4.c 等）在使用动态创建任务时必须关闭宏定义 configSUPPORT_STATIC_ALLOCATION同时打开宏定义 configSUPPORT_DYNAMIC_ALLOCATION动态任务
Freertos创建（动态和静态）任务与删除任务，延时函数
电子第一课，点亮LED；第二课，点亮钽电容；第三课，点亮MOS管
07-13 398
FreeRTOS 中，任务的创建有两种方法，一种是使用动态创建，一种是使用静态创建。动态创建时，任务控制块和栈的内存是创建任务时动态分配的，任务删除时，内存可以释放。静态创建时，任务控制块和栈的内存需要事先定义好，是静态的内 存 ，任务删除时 ，内存不能释放。更具需求使用这两种创建方法。
【FreeRTOS】FreeRTOS 静态创建任务与删除
FuckerGod的博客
06-27 668
动态创建任务需要使用到函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转根据上方的描述我们可以得知，此函数将会创建一个新任务，并将其添加到就绪任务列表中。在中，必须设置为 1，或者不定义(在这种情况下，它将默认为1)，以便此函数可以使用。每个任务都需要用于保存任务状态的 RAM，并被任务用作其堆栈。如果使用创建任务，则从 FreeRTOS 堆中自动分配所需的 RAM。如果使用创建任务，则 RAM 由应用程序编写者提供，因此可以在编译时静态分配。根据上方的描述我们可以得知，
FreeRTOS 的任务创建和删除
ma123456542的博客
03-13 1318
在 FreeRTOSConfig.h 中。/* START_TASK 任务 配置* 包括: 任务句柄 任务优先级 堆栈大小 创建任务*/ # define START_TASK_PRIO 1 /* 任务优先级 */ # define START_TASK_STACK_SIZE 128 /* 堆栈大小,单位字,乘以 4 变成字节 */ TaskHandle_t start_task_handler;/* 任务句柄 */ void start_task(void * pvParameters);
1263_FreeRTOS的动态任务创建分析
小灰笔记
06-07 326
全部学习汇总： GreyZhang/g_FreeRTOS: learning notes about FreeRTOS. (github.com)前面简单分析了FreeRTOS中的链表结构以及处理，OS的一个基础的操作信息基本就有了。这一次看看比较常用的任务创建接口的实现，同时找一下跟之前看过的信息是否有什么关联性。这是FreeRTOS中动态创建一个task的接口调用。顺便说一下：不得不说，Source Insight在代码语义分析上的功能的确是非常强的。虽然，作为编辑器本身的编辑效率不是最高的，但是如果自
FreeRTOS（1）----动态与静态创建任务，删除任务
weixin_63032791的博客
05-15 1159
解释：当其他的运行的任务执行到vTaskDelay();这个函数的时候，空闲任务就可以切进来，释放掉删除任务分配的内存空。因为是静态内存分配空间，所以需要用户主动去分配内存空间给创建的任务栈。空闲任务在删除任务函数结束之后，会自动释放掉删除任务分配的内存空间。当系统的其它任务转为“就绪态”，则会“抢占”空闲任务进行执行。，确保不会影响到当前系统其他的任务的运行，空闲任务一直处于。启用freertos任务调度器时内核自动生成。的，确保系统内至少存在一个任务正在运行。空闲任务的优先级永远是最低的。
FreeRTOS动态任务创建.zip
07-30
2. **任务调度**：动态创建的任务将与系统中其他已存在的任务一同参与调度。合理设置任务优先级，避免优先级反转和死锁。 3. **资源管理**：创建任务时要考虑资源分配，如共享资源的互斥锁，防止资源冲突。 4. **...
FreeRTOS任务创建和删除实验(动态方法)
06-12
动态创建任务涉及`xTaskCreate()`函数。这个函数接受一系列参数，包括任务函数指针、任务名、优先级、堆栈大小、任务参数以及任务句柄的指针。例如，我们可能会有以下代码创建一个任务： ```c TaskHandle_t xHandle...
NXP i.MX RT1052 FreeRTOS实战：SRAM动态创建多任务
12-01
为了动态创建任务，我们需要使用FreeRTOS提供的`xTaskCreate()`函数。这个函数接收任务函数指针、任务名称、优先级、栈大小、任务参数和任务句柄作为参数。在i.MX RT1052上，我们需要确保有足够未分配的SRAM来为新的...
常用传感器讲解十五--触摸传感器（KY-036）
最新发布
weixin_47567401的博客
07-29 2015
这篇文章主要简单介绍触摸传感器，以及围绕着arduino展开的简单示例
基于STM32F103的FreeRTOS系列（一）·单片机设计模式介绍·裸机程序的设计模式
时光の尘的博客
07-22 1265
裸机程序的设计模式可以分为：轮询、前后台、定时器驱动、基于状态机。：周期性地查询各个模块或函数的状态，适用于简单且响应时间要求不高的系统，但无法有效解决复杂函数之间的相互影响问题。：通过将关键任务放在前台处理，而非关键任务放在后台，以确保关键任务的优先执行。这种方式对优先级管理有效，但复杂函数之间的相互影响仍可能存在。：通过定时器周期性地触发任务执行，适合需要定期执行任务的场景，但不能解决函数间相互影响的问题。：将系统的各种状态和状态转移定义清晰，通过状态切换来控制系统行为。
51 单片机的Keil5软件
m0_74194018的博客
07-25 665
要在电脑上成功安装 KEIL C51，首先必须要有安装包，我们可以通过万能的百度，搜索关键字“KEIL C51 下载”，上面会有很多下载渠道。提取码：4211。
freertos动态创建多任务
08-18
需要注意的是，动态创建的任务需要手动管理任务句柄的分配与释放。可以定义一个任务句柄指针，通过函数返回的任务句柄来进行赋值，以便后续操作任务。 以下是一个示例代码，用于动态创建两个任务： ```c TaskHandle...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天地神仙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值