FreeRTOS学习篇二：任务创建与操作流程

已于 2023-09-13 11:52:48 修改
阅读量1.3k 收藏 21
点赞数
分类专栏： 我学FreeRTOS 文章标签： 学习 stm32 嵌入式硬件
于 2023-09-07 19:37:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45647341/article/details/132744430
版权

FreeRTOS学习篇二：任务创建与操作流程

1.了解一些基本概念

1、任务：可以将任务看作是一个线程，多个任务就是多个线程，任务之间都是互相独立的，FreeRTOS 中，任务是竞争系统资源的最小运行单位。（在FreeRTOS中，线程（Thread）和任务（Task）的概念是相同的（有的系统叫任务，有的叫线程）。每个任务就是一个线程，有着自己的一个程序执行路径）

2、任务控制块：本质就是一个结构体，这个结构体用于存储着任务的一些信息，比如任务的栈指针、任务名称、任务的形参等。系统对任务的全部操作都可以通过这个任务控制块（结构体）来实现。

3、任务句柄：本质就是一个指向任务控制块的指针，通过指针来对任务控制块进行访问，通常句柄为void*型指针。

4、内核对象句柄：信号量、消息队列、事件标志组、软件定时器等都属于内核的对象，实际就是在内核代码中定义好的一些全局数据结构，调用FreeRTOS提供的函数去创建这些东西，创建完成后会返回一个指向这些东西的指针 —— 即内核对象句柄。

2.创建任务的两种方式

2.1任务创建方式

1、单任务系统：

  • 51、32位等单片机裸机中，如果未使用系统，那都是在main函数中通过while(1)死循环来不断依次执行各个处理程序的，对于一些突发处理事件有时会通过中断来完成。这种宏观上串行执行任务中程序的系统，称之为单任务系统，也称为前后台系统（死循环内的程序作为后台程序，而中断服务函数则作为前台程序）。

  • 缺点：前后台系统各个任务（应用程序）都是得排队来轮流执行的，因此系统的实时性差，不适合于大一点的嵌入式应用。

    实时性：如果有一个任务需要执行，CPU就能马上（在较短时间内）执行该任务，不会有较长的延时，这就是实时性。
    实时性可以保证各个任务的及时执行。

  • 优点：简单，资源消耗少。

2、多任务系统：宏观上，可以看成是并行地“同时”执行多个任务的系统。（调度器会不断地启动、停止每一个任务，宏观看上去所有的任务都是在同时执行）

3、FreeRTOS中任务的创建，有两种方式：

  • 静态创建：任务控制块和任务堆栈都事先定义好，即定义好全局变量（全局的都有静态存储期），任务删除时所占内存不会被释放，实际中使用较少。

    （线程占用的内存不可释放）

  • 动态创建：动态创建任务控制块和任务堆栈（由FreeRTOS动态分配），任务删除时占用的内存可释放，实际应用中使用最多。

    （线程占用的内存可释放）

2.2动态创建

介绍几个函数：

/* 用于创建任务 */
BaseType_t xTaskCreate(	TaskFunction_t pxTaskCode,
							const char* const pcName,
							const uint16_t usStackDepth,
							void * const pvParameters,
							UBaseType_t uxPriority,
							TaskHandle_t * const pxCreatedTask);
xTaskCreate(函数入口-即函数指针, 函数名称, 任务栈大小, 任务入口函数参数, 优先级, 任务句柄);
/* 用于删除任务：传入任务的句柄，将任务删除 */
void vTaskDelete( TaskHandle_t xTaskToDelete );
/* 进入临界区：调用其进入临界区，taskENTER_CRITICAL()是一个宏 */
taskENTER_CRITICAL()
/* 退出临界区：调用其退出临界区，taskEXIT_CRITICAL()是一个宏 */
taskEXIT_CRITICAL()
/* 启动调度器：调用即可启动调度器 */
void vTaskStartScheduler( void );

以点亮一个LED灯为例，展示动态创建操作的流程，动态创建是最常用的，示例代码都写在main.c里。
流程如下：
①首先就是开启动态支持，在FreeRTOSConfig.h配置文件中添加以下：

#define configSUPPORT_DYNAMIC_ALLOCATION 1

②定义任务与任务句柄：

/* 定义任务与任务句柄：TaskHandle_t就是`void*` */
static TaskHandle_t AppTaskCreate_Handle = NULL;
static TaskHandle_t LEDTask_Handle = NULL;
static void AppTaskCreate(void* pvParameters);
static void LEDTask(void* pvParameters);

static void AppTaskCreate(void* pvParameters)
{
    taskENTER_CRITICAL(); /* 进入临界区 */
    BaseType_t xReturn = pdPASS;
    xReturn = xTaskCreate(LEDTask,"LEDTask",512,NULL,3,LEDTask_Handle);
    if(xReturn == pdPASS)
        vTaskDelete(AppTaskCreate_Handle); /* 创建任务完成，任务App就已经结束使命了，删除以释放内存 */
    taskEXIT_CRITICAL();  /* 退出临界区 */
}
static void LEDTask(void* pvParameters)
{
    while(1){
        GPIO_SetBits(GPIOC, GPIO_Pin_13);
        vTaskDelay(1500);
        GPIO_ResetBits(GPIOC, GPIO_Pin_13);
		vTaskDelay(1500);
    }
}

③任务创建与FreeRTOS的启动：

/* GPIO初始化 */
static void LED_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
	GPIO_InitStructure.GPIO_Speed =  GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
}

int main(void){
    LED_Init();
    BaseType_t xReturn = pdPASS;
    xReturn = xTaskCreate(AppTaskCreate, "AppTaskCreate",512,NULL,2,AppTaskCreate_Handle);
    if(xReturn == pdPASS)
        vTaskStartScheduler();
    else
        return -1;
    while(1);
}

综合上面两个步骤，main.c全貌如下：

#include "stm32f10x.h"                  // Device header
#include "FreeRTOS.h"
#include "task.h"

/* GPIO初始化 */
static void LED_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
	GPIO_InitStructure.GPIO_Speed =  GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
}

/* 定义任务与任务句柄：TaskHandle_t就是`void*` */
static TaskHandle_t AppTaskCreate_Handle = NULL;
static TaskHandle_t LEDTask_Handle = NULL;
static void AppTaskCreate(void* pvParameters);
static void LEDTask(void* pvParameters);

int main(void){
    LED_Init();
    BaseType_t xReturn = pdPASS;
    xReturn = xTaskCreate(AppTaskCreate, "AppTaskCreate",512,NULL,2,AppTaskCreate_Handle);
    if(xReturn == pdPASS)
        vTaskStartScheduler();
    else
        return -1;
    while(1);
}
static void AppTaskCreate(void* pvParameters)
{
    taskENTER_CRITICAL(); /* 进入临界区 */
    BaseType_t xReturn = pdPASS;
    xReturn = xTaskCreate(LEDTask,"LEDTask",512,NULL,3,LEDTask_Handle);
    if(xReturn == pdPASS)
        vTaskDelete(AppTaskCreate_Handle); /* 创建任务完成，任务App就已经结束使命了，删除以释放内存 */
    taskEXIT_CRITICAL();  /* 退出临界区 */
}
static void LEDTask(void* pvParameters)
{
    while(1){
        GPIO_SetBits(GPIOC, GPIO_Pin_13);
        vTaskDelay(2000);
        GPIO_ResetBits(GPIOC, GPIO_Pin_13);
		vTaskDelay(2000);
    }
}

通常并不需要操作任务本身，上面可以简化为以下流程：（main.c）

#include "stm32f10x.h"                  // Device header
#include "FreeRTOS.h"
#include "task.h"

/* GPIO初始化 */
static void LED_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
	GPIO_InitStructure.GPIO_Speed =  GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
}

/* 定义任务：TaskHandle_t就是`void*` */
static void LEDTask(void* pvParameters);

int main(void){
    LED_Init();
    BaseType_t xReturn = pdPASS;
    taskENTER_CRITICAL();  /* 进入临界区 */
    xReturn = xTaskCreate(LEDTask, "LEDTask",512,NULL,2,NULL); /* 创建任务 */
    taskEXIT_CRITICAL();   /* 退出临界区 */
    if(xReturn == pdPASS)
        vTaskStartScheduler(); /* 启动调度器 */
    else
        return -1;
    while(1);
}

static void LEDTask(void* pvParameters)
{
    while(1){
        GPIO_SetBits(GPIOC, GPIO_Pin_13);
        vTaskDelay(500);
        GPIO_ResetBits(GPIOC, GPIO_Pin_13);
		vTaskDelay(500);
    }
}

这就是动态创建任务的基本使用。

2.3启动与执行流程

上面动态创建任务中，展示的就是两种流程：

  • 第一种流程是在一个任务中去创建其它的任务，就像是任务嵌套任务一样，当这个用于创建其它任务的任务创建完成后，就启动调度器使其运行去创建其它任务。
  • 而另一种流程是创建完所有的任务，然后再启动调度器调度执行。

这两种流程看自己习惯哪种，选用一种流程使用即可。

这些任务是如何执行的呢？

如果使用的是第二种流程，那么任务创建完成后并不会立刻执行，而是调度器开启后才开始调度执行，执行时优先级高的优先执行，如果是相同优先级的任务，那就是时间片轮转调度执行，任务执行过程中必须出现释放CPU执行权的状态，否则将会把CPU给霸占了。

如果使用的是第一种流程，那么当调度器启动就开始执行任务了，执行时从AppTaskCreate任务开始执行，执行过程中：

  • 使用临界区的情况下：当退出临界区，才开始调度执行那些由AppTaskCreate任务创建的任务，执行时也是高优先级的优先执行，同优先级的时间片轮转调度执行。
  • 不使用临界区的情况下：
    • ①：如果AppTaskCreate任务执行时创建的任务优先级比其高，那么创建的任务就会立刻执行。
    • ②：如果AppTaskCreate任务执行时创建的任务优先级比其低，那AppTaskCreate继续向下执行。
    • ③：如果AppTaskCreate任务执行时创建的任务优先级等于其本身的，那AppTaskCreate任务与这个同优先级的任务将按时间片轮转调度的方式执行。

2.4静态创建

以点亮一个LED灯为例，展示静态创建操作的流程，了解一下即可。
1、配置：静态创建，需要在FreeRTOSConfig.h配置文件中设置相关宏。

/* 在`FreeRTOSConfig.h`配置文件添加以下内容： */
#define configSUPPORT_STATIC_ALLOCATION 1 /* 设置为1，即开启静态支持 */
#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE*2) /* 设置定时器服务任务的任务堆栈大小 */

2、创建任务，具体步骤：
①引入#include "FreeRTOS.h"和#include "task.h"。
②空闲任务与定时器任务堆栈函数的实现：

/* 空闲任务与定时器任务：先定义好堆栈和控制块，再实现函数 */
static StackType_t Idle_Task_Stack[configMINIMAL_STACK_SIZE];      /* 空闲任务任务堆栈 */  
static StackType_t Timer_Task_Stack[configTIMER_TASK_STACK_DEPTH]; /* 定时器任务堆栈 */ 
static StaticTask_t Idle_Task_TCB;   /* 空闲任务控制块 */
static StaticTask_t Timer_Task_TCB;  /* 定时器任务控制块 */
/* 函数声明 */
void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, 
StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize);
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, 
StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize) ;
/* 函数实现 */
void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, 
StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize) 
{ 
    *ppxIdleTaskTCBBuffer = &Idle_Task_TCB;           /* 任务控制块内存 */ 
    *ppxIdleTaskStackBuffer = Idle_Task_Stack;        /* 任务堆栈内存 */ 
    *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; /* 任务堆栈大小 */ 
}
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, 
StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize) 
{ 
    *ppxTimerTaskTCBBuffer=&Timer_Task_TCB;              /* 任务控制块内存 */ 
    *ppxTimerTaskStackBuffer=Timer_Task_Stack;           /* 任务堆栈内存 */ 
    *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH; /* 任务堆栈大小 */ 
}

③定义任务：

/* 定义任务：句柄、堆栈、控制块、任务 */
static TaskHandle_t AppTaskCreate_Handle; /* 任务句柄 */
static TaskHandle_t LED_Task_Handle;

static StackType_t AppTaskCreate_Stack[128]; /* 任务堆栈 */
static StackType_t LED_Task_Stack[128];     

static StaticTask_t AppTaskCreate_TCB;  /* 任务控制块 */
static StaticTask_t LED_Task_TCB;      

static void LED_Task(void* parameter);  /* 任务声明*/
static void AppTaskCreate(void);

/* 任务函数实现： */
static void LED_Task(void* parameter)
{
    while(1){
         GPIO_SetBits(GPIOC, GPIO_Pin_13);
         vTaskDelay(500);
		GPIO_ResetBits(GPIOC, GPIO_Pin_13);
		vTaskDelay(500);
    }
}
/* 任务函数实现，该任务函数用于创建任务 */
static void AppTaskCreate(void)
{
    taskENTER_CRITICAL(); /* 进入临界区 */
    /* 创建 LED_Task 任务 */
    LED_Task_Handle = xTaskCreateStatic((TaskFunction_t)LED_Task, /*任务函数*/
    (const char*)"LED_Task",  /* 指定要创建的任务的名称，即任务函数名*/
    (uint32_t)128,            /* 任务堆栈大小*/
    (void* )NULL,             /* 传递给任务函数的参数*/
    (UBaseType_t)4,           /* 任务优先级设置*/
    (StackType_t*)LED_Task_Stack,  /* 任务堆栈*/
    (StaticTask_t*)&LED_Task_TCB); /* 任务控制块*/
    if (NULL != LED_Task_Handle)   /* 创建成功 */
        /* 创建完成 */;
    vTaskDelete(AppTaskCreate_Handle); /*删除 AppTaskCreate 任务*/
    taskEXIT_CRITICAL(); /*退出临界区*/
}

④任务创建与FreeRTOS的启动：

/* GPIO初始化 */
static void LED_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
	GPIO_InitStructure.GPIO_Speed =  GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
}
int main(void) 
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
    LED_Init();
	/* 静态创建任务 start */
    AppTaskCreate_Handle= xTaskCreateStatic((TaskFunction_t)AppTaskCreate,
    (const char*)"AppTaskCreate",(uint32_t)128,(void*)NULL,(UBaseType_t)3,
    (StackType_t*)AppTaskCreate_Stack,
    (StaticTask_t*)&AppTaskCreate_TCB);
    /* 静态创建任务 end */
    /* 启动FreeRTOS，即开启任务调度 */
    if (NULL != AppTaskCreate_Handle)
    vTaskStartScheduler();
	while(1);
}

3、总结：
静态创建的流程：

  1. 修改配置。
  2. 引入#include "FreeRTOS.h"和#include "task.h"。
  3. 空闲任务与定时器任务堆栈函数的实现。
    • 静态任务中需要实现vApplicationGetIdleTaskMemory()与 vApplicationGetTimerTaskMemory()，这两个函数是用户设定的空闲（Idle）任务与定时器（Timer）任务的堆栈大小，必须由用户自己分配，而不能是动态分配。
    • 先定义好空闲、定时器任务栈和空闲、定时器任务控制块，再实现函数这两个函数。
  4. 定义任务：句柄、堆栈、控制块、任务。
  5. 静态创建任务与启动。
  6. 静态创建方式需要自己去定义一大堆的东西。

代码全貌，main.c：（实现效果，PC13口的LED闪烁）

#include "stm32f10x.h"                  // Device header
#include "FreeRTOS.h"
#include "task.h"

/* GPIO初始化 */
static void LED_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
	GPIO_InitStructure.GPIO_Speed =  GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
}

/* 空闲任务与定时器任务：先定义好堆栈和控制块，再实现函数 */
static StackType_t Idle_Task_Stack[configMINIMAL_STACK_SIZE];      /* 空闲任务任务堆栈 */  
static StackType_t Timer_Task_Stack[configTIMER_TASK_STACK_DEPTH]; /* 定时器任务堆栈 */ 
static StaticTask_t Idle_Task_TCB;   /* 空闲任务控制块 */
static StaticTask_t Timer_Task_TCB;  /* 定时器任务控制块 */

/* 定义任务：句柄、堆栈、控制块、任务 */
static TaskHandle_t AppTaskCreate_Handle; /* 任务句柄 */
static TaskHandle_t LED_Task_Handle;

static StackType_t AppTaskCreate_Stack[128]; /* 任务堆栈 */
static StackType_t LED_Task_Stack[128];     

static StaticTask_t AppTaskCreate_TCB;  /* 任务控制块 */
static StaticTask_t LED_Task_TCB;      

static void LED_Task(void* parameter);  /* 任务声明*/
static void AppTaskCreate(void);

/* 函数声明 */
void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, 
StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize);
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, 
StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize) ;

int main(void) 
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
    LED_Init();
	/* 静态创建任务 start */
    AppTaskCreate_Handle= xTaskCreateStatic((TaskFunction_t)AppTaskCreate,
    (const char*)"AppTaskCreate",(uint32_t)128,(void*)NULL,(UBaseType_t)3,
    (StackType_t*)AppTaskCreate_Stack,
    (StaticTask_t*)&AppTaskCreate_TCB);
    /* 静态创建任务 end */
    /* 启动FreeRTOS，即开启任务调度 */
    if (NULL != AppTaskCreate_Handle)
    vTaskStartScheduler();
	while(1);
}

/* 任务函数实现： */
static void LED_Task(void* parameter)
{
    while(1){
         GPIO_SetBits(GPIOC, GPIO_Pin_13);
         vTaskDelay(500);
		GPIO_ResetBits(GPIOC, GPIO_Pin_13);
		vTaskDelay(500);
    }
}
/* 任务函数实现，该任务函数用于创建任务 */
static void AppTaskCreate(void)
{
    taskENTER_CRITICAL(); /* 进入临界区 */
    /* 创建 LED_Task 任务 */
    LED_Task_Handle = xTaskCreateStatic((TaskFunction_t)LED_Task, /*任务函数*/
    (const char*)"LED_Task",  /* 指定要创建的任务的名称，即任务函数名*/
    (uint32_t)128,            /* 任务堆栈大小*/
    (void* )NULL,             /* 传递给任务函数的参数*/
    (UBaseType_t)4,           /* 任务优先级设置*/
    (StackType_t*)LED_Task_Stack,  /* 任务堆栈*/
    (StaticTask_t*)&LED_Task_TCB); /* 任务控制块*/
    if (NULL != LED_Task_Handle)   /* 创建成功 */
        /* 创建完成 */;
    vTaskDelete(AppTaskCreate_Handle); /*删除 AppTaskCreate 任务*/
    taskEXIT_CRITICAL(); /*退出临界区*/
}

/* 函数实现 */
void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, 
StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize) 
{ 
    *ppxIdleTaskTCBBuffer = &Idle_Task_TCB;           /* 任务控制块内存 */ 
    *ppxIdleTaskStackBuffer = Idle_Task_Stack;        /* 任务堆栈内存 */ 
    *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; /* 任务堆栈大小 */ 
}
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, 
StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize) 
{ 
    *ppxTimerTaskTCBBuffer=&Timer_Task_TCB;              /* 任务控制块内存 */ 
    *ppxTimerTaskStackBuffer=Timer_Task_Stack;           /* 任务堆栈内存 */ 
    *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH; /* 任务堆栈大小 */ 
}

END
如果有理解错的地方、写错的地方，欢迎━(*｀∀´*)ノ亻!指出。

不似年少
关注
  • 0
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
FreeRTOS任务创建和删除实验(动态方法)
06-12
"FreeRTOS学习笔记——FreeRTOS任务创建和删除实验(动态方法)"博客所用代码
FreeRTOS任务切换流程说明
07-06
FreeRTOS 作为一个实时操作系统，任务管理是其核心，而任务管理的核心就是如何进行任务切换。本文将详细介绍 FreeRTOS 任务切换流程，包括任务基础知识、任务优先级、任务控制块、任务堆栈、任务切换流程等。 一、...
FreeRTOS 任务创建和调度器开启
Calmer_的博客
02-29 938
答案是为了隔离OS和应用程序，程序的运行少不了堆栈，因为我们CPU只有少量的通用寄存器，当我们使用的临时变量比较多得时候，就需要将这些临时变量存储到堆栈里，而堆栈的push和pop都是通过SP来实现的，所以通过MSP和PSP就能实现OS内核与应用程序的隔离，应用程序task用PSP，而OS用MSP，这样会非常安全。现在来看（1）、（2)、(3)这三步起始就是为了获取MSP的初始值。(7)和（8)、数据同步和指令同步屏障，这两个指令的详细内容请参考《权威指南》的“第 5章 指令集”的 5.6.13 小节。
三、FreeRTOS学习之 freertos的任务创建
m0_72750024的博客
08-23 1502
任务创建
【FreeRTOS】创建任务-声光色影
最新发布
weixin_63135906的博客
06-14 818
任务就是一个函数，任务就是工作这个函数不能返回同一个函数，可以用来创建多个任务；换句话说，多个任务可以运行同一个函数每个任务都有自己的栈每个任务运行这个函数时任务A的局部变量放在任务A的栈里、任务B的局部变量放在任务B的栈里不同任务的局部变量，有自己的副本函数使用全局变量、静态变量的话只有一个副本：多个任务使用的是同一个副本要防止冲突(后续会讲) 下面是一个示例：/* 对于不同的任务，局部变量放在任务的栈里，有各自的副本 *//* 任务函数通常实现为一个无限循环 */
【FreeRTOS学习】第10章 创建任务
weixin_50924397的博客
07-26 282
static void AppTaskCreate(void) //启动任务函数： static void BSP_Init(void) //初始化外设函数 static void LED_Task(void * parameter) //任务主体函数 {while(1) {LED1_ON;/* 延时500个tick */ printf("LED_Task Running,LED1_ON\r\n");LED1_OFF;
【FreeRTOS】02 任务的创建
小白白学电子
05-07 5805
本节我们将分析一下FreeRTOS任务创建的过程，并结合创建时需要的参数讲解一下FreeRTOS任务的一些特性。
freeRTOS创建任务
lovesjj_1011的博客
12-04 799
TCB结构体得事先分配好栈，栈要事先分配好定义一个数组。同时还要配置Idle线程。配置这个函数要先配置。
NXP i.MX RT1052 FreeRTOS实战：FreeRTOS启动流程
12-01
5. **任务调度**：一旦主任务运行并创建了其他任务，FreeRTOS的实时调度就开始了。调度器会根据任务的优先级和状态，决定哪个任务应该获得CPU执行权。 6. **中断处理**：在FreeRTOS中，中断服务例程（ISR）可以被...
FreeRTOS学习资料大全.rar
09-25
3. **实例分析**：通过简单的示例程序，例如LED闪烁，实践任务创建和调度。 4. **高级特性**：逐步深入到信号量、互斥量、定时器等高级功能的使用。 5. **项目实践**：参与或创建实际项目，将FreeRTOS应用于嵌入式...
STM32H562实现FreeRTOS任务创建与删除实验(静态方法)【支持STM32H系列单片机】.zip
06-03
9. **调试技巧**：利用IDE的调试功能，如断点、变量观察窗口，可以帮助理解和调试FreeRTOS任务的执行流程。 通过这个实验，开发者可以深入理解FreeRTOS在STM32H562上的工作原理，为后续开发复杂嵌入式系统奠定基础...
FreeRTOS内核使用指南（中文版）
09-14
FreeRTOS内核使用指南（中文版）在应用程序中，FreeRTOS 如何为各任务分配处理时间。  在任意给定时刻，FreeRTOS 如何选择任务投入运行。  任务优先级如何影响系统行为。  任务存在哪些状态。
STM32F429 FreeRTOS实战：实现FreeRTOS任务挂起和恢复【支持STM32F42X系列单片机】.zip
12-15
这个压缩包中的项目应该是提供了一套完整的STM32F429 FreeRTOS实例，涵盖了任务创建、挂起、恢复的实现，并且已经针对STM32F42X系列进行了优化。开发者可以通过分析和运行项目代码，深入理解FreeRTOS在STM32上的应用...
FreeRTOS（基于STM32）——任务创建
vizio.blog.csdn.net
10-28 1560
FreeRTOS笔记，任务的创建。
FreeRTOS任务创建过程详解
m0_73931287的博客
02-25 1393
FreeRTOS中关于任务创建的详细过程的了解
freertos 内部机制——任务的创建
qq_73482714的博客
09-16 97
与创建任务函数相比，TCB结构体中少了任务函数地址和函数参数。在上节知道函数被切换时会保留现场（即保存cpu的r0-r15到栈中），现在，在任务创建后，任务函数处于暂停态，任务函数地址和函数参数分别存储在pc和r0寄存器中，使函数恢复。在栈中会存贮LR寄存器的值用来返回也会占用空间,LR为函数结束后下一句代码的地址。而根据实验栈空间大小是估计分配的（通过观察任务中定义的变量和任务执行深度（即子函数））栈空间是定义了一个17*1024的数组，用来分配栈。6、TCB结构体（里面定义有创建任务的组成成分）
FreeRTOS入门（02）：任务基础使用与说明
Naisu的各种笔记
02-23 2546
任务（Task）是FreeRTOS中供用户使用的最核心的功能，本文将介绍任务创建与使用相关的基础内容。
FreeRTOS笔记【一】 任务的创建（动态方法和静态方法）
nullccc的博客
11-05 2022
使用函数是在 FreeRTOS 中创建任务的一种方法，使用该函数所需的 RAM 会自动从 FreeRTOS的堆中自动分配。因此需要开启 FreeRTOSConfig.h 中的一个宏定义为1，就可以创建任务了。#define configSUPPORT_DYNAMIC_ALLOCATION 1 //支持动态内存申请2.2 函数原型参数描述pxTaskCode任务函数pcName任务名字，一般用于追踪和调试，任务名字长度不能超过configMAX_TASK_NAME_LEN。
【FreeRTOS】任务创建/临界区
m0_63077733的博客
02-24 892
FreeRTOS基于STM32的任务创建
使用freertos在main函数中写出创建动态任务的完成流程
05-18
动态任务的创建流程如下： 1. 定义任务句柄和任务参数。 ```c TaskHandle_t xTaskHandle; TaskParameters_t xTaskParams; ``` 2. 设置任务参数。 ```c xTaskParams.pcName = "TaskName"; xTaskParams.usStackDepth = configMINIMAL_STACK_SIZE; xTaskParams.pvParameters = NULL; xTaskParams.uxPriority = tskIDLE_PRIORITY + 1; xTaskParams.pxCreatedTask = &xTaskHandle; ``` 3. 创建任务。 ```c xTaskCreateRestricted(&TaskFunction, "TaskName", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL, &xTaskHandle); ``` 完整代码如下： ```c #include "FreeRTOS.h" #include "task.h" void TaskFunction(void* pvParameters) { while (1) { // Task code here } } int main() { TaskHandle_t xTaskHandle; TaskParameters_t xTaskParams; /* Set task parameters */ xTaskParams.pcName = "TaskName"; xTaskParams.usStackDepth = configMINIMAL_STACK_SIZE; xTaskParams.pvParameters = NULL; xTaskParams.uxPriority = tskIDLE_PRIORITY + 1; xTaskParams.pxCreatedTask = &xTaskHandle; /* Create dynamic task */ xTaskCreateRestricted(&TaskFunction, "TaskName", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL, &xTaskHandle); /* Start scheduler */ vTaskStartScheduler(); /* Should never reach here */ while (1); } ``` 注意：以上代码仅为示例，具体的任务参数和任务代码需要根据实际需求进行设置和编写。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值