三.Free RTOS任务

已于 2023-10-28 22:07:09 修改
阅读量67 收藏
点赞数
分类专栏： Free RTOS 文章标签： 单片机 stm32
于 2023-10-28 22:06:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58575898/article/details/134091039
版权

一.任务创建和删除

<一>.任务创建和删除的API函数

任务的创建和删除的本质就是调用FreeRTOS的API函数。

API函数描述
xTaskCreate()动态方式创建任务
xTaskCreateStatic()静态方式创建任务
vTaskDelete()删除任务
  • 动态创建任务：任务的任务控制块以及任务的栈空间所需的内存，均由FreeRTOS从FreeRTOS管理的堆中分配；
  • 静态创建任务：任务的任务控制块以及任务的栈空间所需的内存，需用户分配提供。 

1.动态创建函数 

动态创建任务函数：

返回值描述
pdPASS任务创建成功
errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY任务创建失败

实现动态创建任务流程：

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

此函数创建的任务会立刻进入就绪态，由任务调度器调度运行。

动态创建任务函数内部实现：

  1. 申请堆栈内存&任务控制块内存；
  2. TCB结构体成员赋值；
  3. 添加新任务到就绪列表中。 

任务控制块结构体成员介绍： 

typedef struct  tskTaskControlBlock       
{
    	volatile StackType_t 		* pxTopOfStack; 					/* 任务栈栈顶，必须为TCB的第一个成员 */
   	ListItem_t 			xStateListItem;           					/* 任务状态列表项 */      
	ListItem_t 			xEventListItem;					/* 任务事件列表项 */     
    	UBaseType_t 			uxPriority;                					/* 任务优先级，数值越大，优先级越大 */
    	StackType_t 			* pxStack;						/* 任务栈起始地址 */
    	char 				pcTaskName[ configMAX_TASK_NAME_LEN ]; 	/* 任务名字 */		
	…
	省略很多条件编译的成员
} tskTCB;

 注意：

  • 任务栈栈顶，在任务切换时的任务上下文保存、任务恢复息息相关；
  • 每个任务都有属于自己的任务控制块，类似身份证。 

2.静态创建函数 

静态创建任务函数：

TaskHandle_t xTaskCreateStatic
(
    	TaskFunction_t		pxTaskCode,				/* 指向任务函数的指针 */
    	const char * const		pcName,				/* 任务函数名 */
    	const uint32_t			ulStackDepth, 			/* 任务堆栈大小注意字为单位 */
    	void * const			pvParameters, 			/* 传递的任务函数参数 */
    	UBaseType_t			uxPriority, 				/* 任务优先级 */
    	StackType_t * const		puxStackBuffer, 			/* 任务堆栈，一般为数组，由用户分配 */
    	StaticTask_t * const		pxTaskBuffer				/* 任务控制块指针，由用户分配 */
);
返回值描述
NULL用户没有提供相应的内存，任务创建失败
其他值任务句柄，任务创建成功

 静态创建任务使用流程：

3.任务删除函数 

void vTaskDelete(TaskHandle_t xTaskToDelete);

形参描述
xTaskToDelete待删除任务的任务句柄

用于删除已被创建的任务；

被删除的任务将从就绪态任务列表、阻塞态任务列表、挂起态任务列表和事件列表中移除。 

注意：

  • 当传入的参数为NULL，则代表删除任务自身（当前正在运行的任务）；
  • 空闲任务会负责释放被删除任务中由系统分配的内存，但是由用户在任务删除前申请的内存， 则需要由用户在任务被删除前提前释放，否则将导致内存泄露 。 

 删除任务流程：

<二>.任务创建和删除（动态方法）

 demo.c

#include "demo.h"
#include "./SYSTEM/usart/usart.h"
#include "./BSP/LED/led.h"
/*FreeRTOS*********************************************************************************************/
#include "FreeRTOS.h"
#include "task.h"

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

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

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

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

 /* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO					25		 /* 定义任务优先级 */
#define TASK3_STACK_SIZE		128  /*创建任务堆栈大小*/
TaskHandle_t 										task3_handler; 	/* 定义任务句柄 */
void task3( void * pvParameters );

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


/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
	xTaskCreate(  (TaskFunction_t					)		 start_task,
								(const char * 								) 	 "start_task", 
								(configSTACK_DEPTH_TYPE )	   START_TASK_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 START_TASK_PRIO,
								(TaskHandle_t * 				)		 &start_task_handler );
  vTaskStartScheduler();/* 开启任务调度器 */
}

void start_task( void * pvParameters )
{
	taskENTER_CRITICAL();				/* 进入临界区，关闭中断 */
 xTaskCreate(  (TaskFunction_t					)		 task1,
								(const char *								) 	 "task1", 
								(configSTACK_DEPTH_TYPE )	   TASK1_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 TASK1_PRIO,
								(TaskHandle_t * 				)		 &task1_handler );
								
 xTaskCreate(  (TaskFunction_t					)		 task2,
								(const char *								) 	 "task2", 
								(configSTACK_DEPTH_TYPE )	   TASK2_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 TASK2_PRIO,
								(TaskHandle_t * 				)		 &task2_handler );
								
 xTaskCreate(  (TaskFunction_t					)		 task3,
								(const char *								) 	 "task3", 
								(configSTACK_DEPTH_TYPE )	   TASK3_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 TASK3_PRIO,
								(TaskHandle_t * 				)		 &task3_handler );
								
 vTaskDelete(NULL);
	taskEXIT_CRITICAL();              /* 退出临界区 */
}

/* 任务一，实现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 )
{
	
	while(1)
	{
		printf("TASK3正在运行！\r\n");
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11) == 1)
		{
			if(task1_handler != 0)
			{
				printf("删除TASK1!\r\n");
				vTaskDelete(task1_handler);
			}
		}
		vTaskDelay(10);
	}
}

demo.h

#ifndef _DEMO_H
#define _DEMO_H

void freertos_demo(void);

#endif

 main.c

#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./BSP/LED/led.h"
#include "demo.h"

int main(void)
{
    HAL_Init();                         /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
    delay_init(72);                     /* 延时初始化 */
    usart_init(115200);                 /* 串口初始化为115200 */
    led_init();                         /* 初始化LED */

    
    freertos_demo();                    /* 运行FreeRTOS例程 */
}

临界区保护，就是保护哪些不想被打断的程序段。 

<三>.任务创建和删除（静态方法）

FreeRTOSConfig.h：设置静态申请内存为1

#include "demo.h"
#include "./SYSTEM/usart/usart.h"
#include "./BSP/LED/led.h"
/*FreeRTOS*********************************************************************************************/
#include "FreeRTOS.h"
#include "task.h"

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

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO					1		 /* 定义任务优先级 */
#define START_TASK_STACK_SIZE		128  /*创建任务堆栈大小*/
TaskHandle_t 										start_task_handler; 	/* 定义任务句柄 */
StackType_t											start_task_stack[START_TASK_STACK_SIZE];
StaticTask_t										start_task_tcb;
void start_task( void * pvParameters );

/* TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK1_PRIO					2		 /* 定义任务优先级 */
#define TASK1_STACK_SIZE		128  /*创建任务堆栈大小*/
TaskHandle_t 										task1_handler; 	/* 定义任务句柄 */
StackType_t											task1_stack[TASK1_STACK_SIZE];
StaticTask_t										task1_tcb;
void task1( void * pvParameters );

 /* TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK2_PRIO					3		 /* 定义任务优先级 */
#define TASK2_STACK_SIZE		128  /*创建任务堆栈大小*/
TaskHandle_t 										task2_handler; 	/* 定义任务句柄 */
StackType_t											task2_stack[TASK2_STACK_SIZE];
StaticTask_t										task2_tcb;
void task2( void * pvParameters );

 /* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO					25		 /* 定义任务优先级 */
#define TASK3_STACK_SIZE		128  /*创建任务堆栈大小*/
TaskHandle_t 										task3_handler; 	/* 定义任务句柄 */
StackType_t											task3_stack[TASK3_STACK_SIZE];
StaticTask_t										task3_tcb;
void task3( void * pvParameters );

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

/* 空闲任务配置 */
StaticTask_t	idle_task_tcb;
StackType_t		idle_task_stack[configMINIMAL_STACK_SIZE];

/* 软件定时器任务配置 */
StaticTask_t	timer_task_tcb;
StackType_t		timer_task_stack[configTIMER_TASK_STACK_DEPTH];

/* 空闲任务内存分配 */
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;
}
/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
	start_task_handler = xTaskCreateStatic(   (TaskFunction_t )  				start_task,
																						( char * )							  "start_task", 
																						( uint32_t )							START_TASK_STACK_SIZE,
																						(void * ) 								NULL,
																						(UBaseType_t )					  START_TASK_PRIO,
																						(StackType_t * )				  start_task_stack,
																						(StaticTask_t * ) 				&start_task_tcb );
											
											
  vTaskStartScheduler();/* 开启任务调度器 */
}

void start_task( void * pvParameters )
{
	taskENTER_CRITICAL();				/* 进入临界区，关闭中断 */
 	task1_handler = xTaskCreateStatic(  (TaskFunction_t )  				task1,
																			( char * )							  "task1", 
																			( uint32_t )							TASK1_STACK_SIZE,
																			(void * ) 								NULL,
																			(UBaseType_t )					  TASK1_PRIO,
																			(StackType_t * )				  task1_stack,
																			(StaticTask_t * ) 				&task1_tcb );
											
		task2_handler = xTaskCreateStatic(  (TaskFunction_t )  			task2,
																				( char * )							  "task2", 
																				( uint32_t )							TASK2_STACK_SIZE,
																				(void * ) 								NULL,
																				(UBaseType_t )					  TASK2_PRIO,
																				(StackType_t * )				  task2_stack,
																				(StaticTask_t * ) 				&task2_tcb );
											
		task3_handler = xTaskCreateStatic(  (TaskFunction_t )  			task3,
																				( char * )							  "task3", 
																				( uint32_t )							TASK3_STACK_SIZE,
																				(void * ) 								NULL,
																				(UBaseType_t )					  TASK3_PRIO,
																				(StackType_t * )				  task3_stack,
																				(StaticTask_t * ) 				&task3_tcb );
								
		vTaskDelete(start_task_handler);
		taskEXIT_CRITICAL();              /* 退出临界区 */
}

/* 任务一，实现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 )
{
	
	while(1)
	{
		printf("TASK3正在运行！\r\n");
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11) == 1)
		{
			if(task1_handler != 0)
			{
				printf("删除TASK1!\r\n");
				vTaskDelete(task1_handler);
			}
		}
		vTaskDelay(10);
	}
}

 main.c和demo.h文件和动态的一样，以后也最常使用动态创建任务。

 <四>.动态任务创建和删除的API函数解析（暂不学习）

二.FreeRTOS的任务挂起与恢复

<一>.任务的挂起与恢复的API函数

API函数描述
vTaskSuspend()挂起任务
vTaskResume()恢复被挂起的任务
xTaskResumeFromISR()在中断恢复被挂起的任务
  • 挂起：挂起任务类似暂停，可恢复；删除任务，无法恢复，类似“人死两清”；
  • 恢复：恢复被挂起的任务；
  • FromISR：带FromISR后缀是在中断函数中专用的API函数。

1.任务挂起函数介绍 

void vTaskSuspend(TaskHandle_t xTaskToSuspend)

形参描述
xTaskToSuspend待挂起任务的任务句柄
  • 此函数用于挂起任务，使用时需将宏 INCLUDE_vTaskSuspend  配置为 1；
  •  无论优先级如何，被挂起的任务都将不再被执行，直到任务被恢复 ；

注意：当传入的参数为NULL，则代表挂起任务自身（当前正在运行的任务）。

2.任务恢复函数介绍（任务中恢复） 

 任务中恢复被挂起函数：void vTaskResume(TaskHandle_t xTaskToResume)

形参描述
xTaskToResume 待恢复任务的任务句柄

使用该函数注意宏：INCLUDE_vTaskSuspend必须定义为 1；

 注意：任务无论被 vTaskSuspend() 挂起多少次，只需在任务中调用  vTakResume() 恢复一次，就可以继续运行。且被恢复的任务会进入就绪态！

3.任务恢复函数介绍（中断中恢复） 

中断中恢复被挂起函数： BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume) 

形参描述
xTaskToResume待恢复任务的任务句柄

函数：xTaskResumeFromISR返回值描述如下：

返回值描述
pdTRUE 任务恢复后需要进行任务切换
pdFALSE 任务恢复后不需要进行任务切换
  •  使用该函数注意宏：INCLUDE_vTaskSuspend 和 INCLUDE_xTaskResumeFromISR 必须定义为 1；
  • 该函数专用于中断服务函数中，用于解挂被挂起任务；

注意：中断服务程序中要调用freeRTOS的API函数则中断优先级不能高于FreeRTOS所管理的最高优先级。

<二>.任务挂起与恢复实验

 demo.c

#include "demo.h"
#include "./SYSTEM/usart/usart.h"
#include "./BSP/LED/led.h"
/*FreeRTOS*********************************************************************************************/
#include "FreeRTOS.h"
#include "task.h"

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

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

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

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

 /* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO					25		 /* 定义任务优先级 */
#define TASK3_STACK_SIZE		128  /*创建任务堆栈大小*/
TaskHandle_t 										task3_handler; 	/* 定义任务句柄 */
void task3( void * pvParameters );

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


/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
	xTaskCreate(  (TaskFunction_t					)		 start_task,
								(const char * 								) 	 "start_task", 
								(configSTACK_DEPTH_TYPE )	   START_TASK_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 START_TASK_PRIO,
								(TaskHandle_t * 				)		 &start_task_handler );
  vTaskStartScheduler();/* 开启任务调度器 */
}

void start_task( void * pvParameters )
{
	taskENTER_CRITICAL();				/* 进入临界区，关闭中断 */
 xTaskCreate(  (TaskFunction_t					)		 task1,
								(const char *								) 	 "task1", 
								(configSTACK_DEPTH_TYPE )	   TASK1_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 TASK1_PRIO,
								(TaskHandle_t * 				)		 &task1_handler );
								
 xTaskCreate(  (TaskFunction_t					)		 task2,
								(const char *								) 	 "task2", 
								(configSTACK_DEPTH_TYPE )	   TASK2_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 TASK2_PRIO,
								(TaskHandle_t * 				)		 &task2_handler );
								
 xTaskCreate(  (TaskFunction_t					)		 task3,
								(const char *								) 	 "task3", 
								(configSTACK_DEPTH_TYPE )	   TASK3_STACK_SIZE,
								(void * 								)		 NULL,
								(UBaseType_t 						)		 TASK3_PRIO,
								(TaskHandle_t * 				)		 &task3_handler );
								
 vTaskDelete(NULL);
	taskEXIT_CRITICAL();              /* 退出临界区 */
}

/* 任务一，实现LED0每500ms翻转一次 */
void task1( void * pvParameters )
{
	uint32_t task1_num = 0;
	while(1)
	{
		printf("task1_num:%d\r\n",++task1_num);
		LED0_TOGGLE();
		vTaskDelay(500);
	}
}

/* 任务二，实现LED1每500ms翻转一次 */
void task2( void * pvParameters )
{
	uint32_t task2_num = 0;
	while(1)
	{
		
		printf("task2_num:%d\r\n",++task2_num);
		LED1_TOGGLE();
		vTaskDelay(500);
	}
}

/* 任务三，判断按键KEY0,按下KEY0删除task1 */
void task3( void * pvParameters )
{
	
	while(1)
	{
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11) == 1)
		{
				vTaskSuspend(task1_handler);
		}
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12) == 1)
		{
				vTaskResume(task1_handler);
		}
		vTaskDelay(10);
	}	
}

 demo.h 和 main.c和之前的一样。

<三>.任务挂起和恢复API函数解析（暂不学习）

逃与桃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Free RTOS脑图文件之任务通知
05-02
自己总结的Free RTOS脑图文件，方便查询记忆。
FreeRTOS----debug之任务的挂起和恢复实验,任务无法切换
JC_gogo的博客
07-16 1063
** 任务的挂起和恢复----debug： ** 背景 ： 有两个Task, Task1为LED闪烁任务,Task2为挂起恢复LED任务 调试程序遇到的问题：LED灯闪烁任务不能正常执行,一直常亮 原因： LED闪烁任务优先级为2,低于任务恢复挂起优先级3,所以当LED任务调用vTaskDelay函数后,程序就进入阻塞态,将cpu使用权交出叫给优先级比他更高的Task2,而Task2中没有调用vT...
FreeRTOS任务的创建（动态方法和静态方法）
m0_49476241的博客
04-30 4829
本篇文章将介绍FreeRTOS任务的创建（动态方法和静态方法），了解什么是任务和任务的具体创建方法。本篇文章我们详细的介绍了FreeRTOS任务的创建，并介绍了这两种方法创建任务的区别，希望大家好好理解并多加练习。
FreeRTOS实时操作系统任务参数传递
最新发布
Gary_Dengxh的博客
03-26 163
【代码】FreeRTOS实时操作系统任务参数传递。
Freertos 创建任务（动态）
m0_54797575的博客
05-25 652
Freertos 中portSTACK_GROWTH>0表明栈是向下增长的，arm就是向下增长的，所以进入。事件链表是根据优先级设置链表项的值的，优先级越高（号小的优先级高），值越大。刚创建的任务还没有放入就绪链表，Container指向就绪链表（等）将任务的状态链表插入当前链表项的后面。（就是链表的最后）。任务句柄会获得任务控制块，这样就可以通过任务句柄控制任务。给任务控制块分配空间（回传给任务句柄）。每一个链表都有链表指针，指示当前的链表想。根据传入的指针，pxList就是就绪链表。
FreeRTOS 创建任务
weixin_50212044的博客
06-21 1465
freeRTOS，创建任务，实时操作系统，xTaskCreate，系统调度，操作系统，删除任务，任务优先级
学习FreeRTOS(二) - 任务创建
weixin_46734801的博客
06-10 970
如果在这种轮询系统加上中断处理呢， 比如说，在main（）中初始化中断，设置中断函数（interrupt service routine）, 那样不就是一个简单的实时系统嘛？是的，在我之前碰到过的数字信号处理芯片（DSP）中，用的都是这种简单的机制，我们称之为前后台系统。[1] 如果configUSE_PREEMPTION设置为1，则RTOS调度程序将始终运行能够运行的最高优先级任务，因此调用taskYIELD（）不会导致切换到更高优先级的任务。任务的描述名称，方便调试，不用的话可以设为。
FreeRTOS基础教程第一章创建任务
热门推荐
qq_61672347的博客
06-30 7万+
FreeRTOS如何创建任务详细介绍
free_rtos的任务创建与删除
04-11
or RTOS), and the de-facto standard solution for microcontrollers and small microprocessors. With millions of deployments in all market sectors, blue chip companies trust FreeRTOS because it is ...
Free RTOS脑图文件之事件组
05-02
事件组是Free RTOS中的一种事件机制，允许任务之间进行通信和同步。下面是事件组的特点和相关函数： 事件组特点 1. 具有广播功能：事件组可以广播事件给多个任务。 2. 被唤醒的任务有两个选择：事件保留不动或清除...
基于pic32mx单片机的FREE RTOS编程，涉及串口，显示LCD驱动，多任务操作，按键处理，菜单处理等
07-17
基于FREE RTOS的多任务编程，代码量较大，RTOS框架清晰，代码量较大是通讯协议的内容。
RTOS_rm.rar
05-01
stm32搭载Free RTOS多任务处理程序，
FreeRTOS学习记录（3）——任务创建与启动总结
m0_52673128的博客
01-25 912
FreeRTOS任务的创建与启动的简单总结
FreeRTOS任务创建
qq_50548080的博客
10-27 981
FreeRTOS任务创建 使用FreeRTOS V9.0版本，感想野火和韦东山老师
FreeRTOS创建任务
zhanglianzhu_91的博客
05-14 1294
CPU有这些寄存器。R0-R12为通用寄存器。R13为栈顶指针，在OS时候中断函数的R13使用MSP的指针（内核态）。非中断里面使用PSP指针（用户态）。 正是有双堆栈指针可以保证OS切换任务不会盖用户程序的堆栈状态。对于OS和任务都是C语言编译的逻辑。OS可不知道任务在要切换时候运行的指令，对于OS来说也不需要关心任务执行的指令。只要确保以下就可以保证任务切换出去后再切换回来时候保持不变。 1.剥夺任务CPU后运行其他指令不会覆盖任务用的内存空间。TCB、栈空间等。 2.任务切换回来的时候能把任务切换前
FreeRTOS-任务创建和删除
qq_51315444的博客
04-08 150
直接在main函数中调用freertos_demo函数即可。
【FreeRTOS】FreeRTOS 动态创建任务与删除
FuckerGod的博客
06-19 829
动态创建任务需要使用到函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转根据上方的描述我们可以得知，此函数将会创建一个新任务，并将其添加到就绪任务列表中。在中，必须设置为 1，或者不定义(在这种情况下，它将默认为1)，以便此函数可以使用。每个任务都需要用于保存任务状态的 RAM，并被任务用作其堆栈。如果使用创建任务，则会==从 FreeRTOS 堆中自动分配所需的 RAM ==。如果使用。
FreeRTOS学习-创建任务
qq_43525512的博客
01-06 1507
目前我们只创建了一个任务，当任务进行延时的时候，没有其他就绪的用户任务，系统会进入空闲任务。空闲任务是FreeRTOS系统自己启动的一个任务，优先级最低。整个系统没有就绪任务的时候，系统必须保证有一个任务运行，空闲任务就是为这个设计的。当用户任务延时到期，又会从空闲任务切换到用户任务。在FreeRTOS系统中，每一个任务都是独立的，运行时环境都单独保存在相应的栈空间。我们使用的时静态内存创建任务，定义任务的栈大小的时候，需要定义一个独立的全局变量。
free RTOS学习
06-02
1. 了解实时操作系统（RTOS）的基础知识，包括任务、调度器、中断和同步等概念。 2. 下载并安装FreeRTOS，可以从官方网站或GitHub获取。 3. 阅读FreeRTOS的文档，包括用户手册、API文档和示例代码等。 4. 学习...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值