FreeRTOS内核学习笔记记录（二）——任务数据结构与任务创建-基于CortexM3

已于 2023-03-23 10:42:17 修改
阅读量364 收藏 3
点赞数 2
分类专栏： Freertos内核剖析 文章标签： 数据结构 学习 链表
于 2023-03-23 10:35:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41673690/article/details/129708872
版权

FreeRTOS任务

1、任务控制块TCB

任务控制块 一种基于ListItem链表结点的数据结构

typedef struct tskTaskControlBlock
{
    /*栈顶指针*/
	volatile StackType_t	*pxTopOfStack;	
    /*配置 内存保护MPU*/
	#if ( portUSING_MPU_WRAPPERS == 1 )
		xMPU_SETTINGS	xMPUSettings;		/*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */
	#endif
    /*任务管理的任务结点*/
	ListItem_t			xStateListItem;	
	/*事件管理的事件结点*/
	ListItem_t			xEventListItem;		
	/*任务优先级*/
	UBaseType_t			uxPriority;			
	/*任务堆栈指针 （栈起始地址）*/
	StackType_t			*pxStack;			
	/*任务名称*/
	char				pcTaskName[ configMAX_TASK_NAME_LEN ];
    /*栈生长方向 对于CortexM3内核栈是向下生长 的满栈模型
    即栈从高地址向低地址生长 portSTACK_GROWTH配置应<0
    对于CortexM3没有*pxEndofStack尾指针的定义
*/
	#if ( portSTACK_GROWTH > 0 )
		StackType_t		*pxEndOfStack;		
	#endif
    /*临界区 TCB嵌套 */
	#if ( portCRITICAL_NESTING_IN_TCB == 1 )
		UBaseType_t		uxCriticalNesting;	/*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */
	#endif
    /*启用系统性能跟踪 启用此宏用于调试*/
	#if ( configUSE_TRACE_FACILITY == 1 )
		UBaseType_t		uxTCBNumber;		/*< Stores a number that increments each time a TCB is created.  It allows debuggers to determine when a task has been deleted and then recreated. */
		UBaseType_t		uxTaskNumber;		/*< Stores a number specifically for use by third party trace code. */
	#endif
    /*使用互斥*/
	#if ( configUSE_MUTEXES == 1 )
		UBaseType_t		uxBasePriority;		
		UBaseType_t		uxMutexesHeld;
	#endif
    /*使用任务应用标志*/
	#if ( configUSE_APPLICATION_TASK_TAG == 1 )
		TaskHookFunction_t pxTaskTag;
	#endif
    /*启用线程本地指针*/
	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
		void *pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];
	#endif
    /*启用实时统计*/
	#if( configGENERATE_RUN_TIME_STATS == 1 )
		uint32_t		ulRunTimeCounter;	
	#endif
    /*使用一个新库 供开发者自己添加*/
	#if ( configUSE_NEWLIB_REENTRANT == 1 )
		struct	_reent xNewLib_reent;
	#endif
    /*开启任务通知 一种内核对象*/
	#if( configUSE_TASK_NOTIFICATIONS == 1 )
		volatile uint32_t ulNotifiedValue;
		volatile uint8_t ucNotifyState;
	#endif
    /*TCB的一个成员用于记录是否分配内存
堆栈和/或TCB是静态或动态分配
    tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE仅当它可能用于
使用静态或动态分配RAM创建的任务。请注意
如果portUSING_MPU_WRAPPERS为1，则可以使用它创建受保护任务
静态分配的堆栈和动态分配的TCB*/
	#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
		uint8_t	ucStaticallyAllocated; 		/*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */
	#endif
     /*是否取消任务延时 一般不启用 为0*/
	#if( INCLUDE_xTaskAbortDelay == 1 )
		uint8_t ucDelayAborted;
	#endif

} tskTCB;

在这里插入图片描述
任务控制块实际是基于list数据结构的一块内存，基本成员+#define可配置成员组成

2、任务创建xTaskCreate（…）

动态创建函数
xTaskCreate
(	
/*执行任务的函数 实际任务入口*/
TaskFunction_t pxTaskCode,
/*任务名称*/
const char * const pcName,
/*任务栈深度*/
const uint16_t usStackDepth,
/*任务形参*/
void * const pvParameters,
/*任务优先级*/
UBaseType_t uxPriority,
/*任务控制块指针*/
TaskHandle_t * const pxCreatedTask 
)

动态创建任务函数流程
在这里插入图片描述
分配任务堆栈、控制块堆栈；动态内存分配用的heap4模型-小内存分配模型；
初始化任务并将任务添加至就绪列表

BaseType_t xTaskCreate(	TaskFunction_t pxTaskCode,/*任务函数 真正的任务入口*/
							const char * const pcName,/*任务名称*/
							const uint16_t usStackDepth,/*任务堆栈深度*4Bytes*/
							void * const pvParameters,/*任务形参*/
							UBaseType_t uxPriority,/*任务优先级*/
							TaskHandle_t * const pxCreatedTask )/*任务控制块指针*/
	{
	TCB_t *pxNewTCB;
	BaseType_t xReturn;
		#if( portSTACK_GROWTH > 0 )
		{
			pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );
			if( pxNewTCB != NULL )
			{
				pxNewTCB->pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); 
				if( pxNewTCB->pxStack == NULL )
				{
					vPortFree( pxNewTCB );
					pxNewTCB = NULL;
				}
			}
		}
		#else /* CortexM3内核使用的是向下生长满栈模型 直接跳转到这里 */
		{
		StackType_t *pxStack;
		/*动态内存分配任务堆栈 大小为usStackDepth*4Bytes 
		动态内存分配有heap2和heap4模型 其中 heap2模型会产生内存小碎片 heap4模型会合并一些动态内存碎片
*/
			pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); 

			if( pxStack != NULL )
			{  /*任务栈初始化完成后再初始化TCB控制块，与向上生长堆栈模型相反，向上生长会先分配TCB控制块，再分配任务堆栈*/
				pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /
                /*TCB分配成功*/
				if( pxNewTCB != NULL )
				{
					/*保存任务堆栈的位置到TCB的堆栈指针*/
					pxNewTCB->pxStack = pxStack;
				}
				else
				{
					/*否则释放任务堆栈*/
					vPortFree( pxStack );
				}
			}
			else
			{
				pxNewTCB = NULL;
			}
		}
		#endif 
		if( pxNewTCB != NULL )
		{
			#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
			{
		
				pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;
			}
			#endif /* configSUPPORT_STATIC_ALLOCATION */
            /*初始化任务*/
			prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );
			/*添加任务到就绪列表*/
			prvAddNewTaskToReadyList( pxNewTCB );
			xReturn = pdPASS;
		}
		else
		{
			xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
		}

		return xReturn;
	}

在这里插入图片描述
这里借鉴了别人的图片；即要保证TCB在task[0][0]位置，需要在堆栈初始化时，对于向下生长模型，先从task[0][TASK_STK_SIZE-1]压入任务栈，然后再压入TCB；对于向上生长堆栈模型，需要先压入TCB，再压入任务堆栈。

prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );
/*初始化任务*/

```c
static void prvInitialiseNewTask( 	TaskFunction_t pxTaskCode,
									const char * const pcName,
									const uint32_t ulStackDepth,
									void * const pvParameters,
									UBaseType_t uxPriority,
									TaskHandle_t * const pxCreatedTask,
									TCB_t *pxNewTCB,
									const MemoryRegion_t * const xRegions )
{
StackType_t *pxTopOfStack;
UBaseType_t x;
    /*启用MPU保护*/
	#if( portUSING_MPU_WRAPPERS == 1 )
		/* Should the task be created in privileged mode? */
		BaseType_t xRunPrivileged;
		if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )
		{
			xRunPrivileged = pdTRUE;
		}
		else
		{
			xRunPrivileged = pdFALSE;
		}
		uxPriority &= ~portPRIVILEGE_BIT;
	#endif /* portUSING_MPU_WRAPPERS == 1 */
    /*配置栈溢出检测*/
	#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )
	{
		/* 填充已知的值到堆栈内再通过调试去读出 从而检查堆栈是否溢出 */
		( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );
	}
	#endif 
   /*确定pxTopofStack的位置=TCB的任务堆栈位置+堆栈深度即栈顶指针到了TCB的位置*/
	pxTopOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
	/*栈指针8字节对其 cortexm3也是8字节对齐的*/
		pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); 
	/**/	
	configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );
    /*保存任务名称*/
	for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
	{
		pxNewTCB->pcTaskName[ x ] = pcName[ x ];
		if( pcName[ x ] == 0x00 )
		{
			break;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';
	/*优先级限制不能超过最大优先级*/
	if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
	{
		uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
	pxNewTCB->uxPriority = uxPriority;
	/*启用RTOS的互斥*/
	#if ( configUSE_MUTEXES == 1 )
	{
		pxNewTCB->uxBasePriority = uxPriority;
		pxNewTCB->uxMutexesHeld = 0;
	}
	#endif /* configUSE_MUTEXES */
    /*初始化任务链表结点和事件列表结点 让其pvContainer指向NULL*/
	vListInitialiseItem( &( pxNewTCB->xStateListItem ) );
	vListInitialiseItem( &( pxNewTCB->xEventListItem ) );
    /*设置任务链表结点归属于此TCB*/
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );
	/*设置事件链表结点内的排序值*/
	listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority ); 
	/*设置事件链表结点归属于此TCB*/
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );
	#if ( portCRITICAL_NESTING_IN_TCB == 1 )
	{
		pxNewTCB->uxCriticalNesting = ( UBaseType_t ) 0U;
	}
	#endif /* portCRITICAL_NESTING_IN_TCB */
	#if ( configUSE_APPLICATION_TASK_TAG == 1 )
	{
		pxNewTCB->pxTaskTag = NULL;
	}
	#endif /* configUSE_APPLICATION_TASK_TAG */
	#if ( configGENERATE_RUN_TIME_STATS == 1 )
	{
		pxNewTCB->ulRunTimeCounter = 0UL;
	}
	#endif /* configGENERATE_RUN_TIME_STATS */
	#if ( portUSING_MPU_WRAPPERS == 1 )
	{
		vPortStoreTaskMPUSettings( &( pxNewTCB->xMPUSettings ), xRegions, pxNewTCB->pxStack, ulStackDepth );
	}
	#else
	{
		/* Avoid compiler warning about unreferenced parameter. */
		( void ) xRegions;
	}
	#endif
	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
	{
		for( x = 0; x < ( UBaseType_t ) configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )
		{
			pxNewTCB->pvThreadLocalStoragePointers[ x ] = NULL;
		}
	}
	#endif
	#if ( configUSE_TASK_NOTIFICATIONS == 1 )
	{
		pxNewTCB->ulNotifiedValue = 0;
		pxNewTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
	}
	#endif
	#if ( configUSE_NEWLIB_REENTRANT == 1 )
	{
		/* Initialise this task's Newlib reent structure. */
		_REENT_INIT_PTR( ( &( pxNewTCB->xNewLib_reent ) ) );
	}
	#endif
	#if( INCLUDE_xTaskAbortDelay == 1 )
	{
		pxNewTCB->ucDelayAborted = pdFALSE;
	}
	#endif
	#if( portUSING_MPU_WRAPPERS == 1 )
	{
		pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged );
	}
	#else /* portUSING_MPU_WRAPPERS */
	{
	   /*最重要的一步 初始化任务栈 与cortexm3内核相关 作用是将CPU寄存器压入任务堆栈*/
		pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );
	}
	#endif /* portUSING_MPU_WRAPPERS */
	if( ( void * ) pxCreatedTask != NULL )
	{
		/*成功创建TCB后 返回NewTCB地址*/
		*pxCreatedTask = ( TaskHandle_t ) pxNewTCB;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

``
在prvInitialiseNewTask最后需要调用pxPortInitialiseStack，将任务相关信息压入CPU的寄存器内，PC指针指向pxTaskCode也将被保存；当需要使用时会调回到pxTaskCode进入此任务。

StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters )
{
	pxTopOfStack--; /*已知pxTopofStack是已经指向TCB的指针*/
	*pxTopOfStack = portINITIAL_XPSR;	/* xPSR 的 bit24 必须置 1，即 0x01000000 */
	pxTopOfStack--;
	/*保存任务的入口地址到PC*/
	*pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK;	
	pxTopOfStack--;
	/*LR链接了一个错误处理入口*/
	*pxTopOfStack = ( StackType_t ) prvTaskExitError;	
    /*默认初始化R12 R3 R2 R1 这是CPU自动行为*/
	pxTopOfStack -= 5;	/* R12, R3, R2 and R1. */
	*pxTopOfStack = ( StackType_t ) pvParameters;	/* R0 */
	/*手动压入剩余寄存器*/
	pxTopOfStack -= 8;	/* R11, R10, R9, R8, R7, R6, R5 and R4. */
    /*最后的是R4也是pxTopofStack的位置*/
	return pxTopOfStack;
}

理解为栈顶压入了CPU寄存器的相关内容，用于能恢复现场。从栈顶开始到栈底依次是CPU寄存器 TCB 任务堆栈 所以R4的下一个位置时TCB的首地址。

static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )
{
	taskENTER_CRITICAL();
	{
		uxCurrentNumberOfTasks++;/*一个全局变量 当任务创建成功后 会自加*/
		/*当pxCurrentTCB是空表明这是第一个被创建的任务*/
		if( pxCurrentTCB == NULL )/*pxCurrentTCB也是一个全局的TCB指针*/
		{
			pxCurrentTCB = pxNewTCB;/*全局变量指针指向这个TCB*/
			if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )/*在这之前pxCurrentTCB都为空 所以只有一个任务*/
			{
				prvInitialiseTaskLists();/*第一个创建时需要初始化就绪列表*/
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else/*当至少有一个任务存在时*/
		{
			if( xSchedulerRunning == pdFALSE )
			{
				if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )
				{
					pxCurrentTCB = pxNewTCB;//如果调度器没打开 根据优先级进行任务切换
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		uxTaskNumber++;//任务总数++
		#if ( configUSE_TRACE_FACILITY == 1 )
		{
			pxNewTCB->uxTCBNumber = uxTaskNumber;
		}
		#endif /* configUSE_TRACE_FACILITY */
		traceTASK_CREATE( pxNewTCB );
		/*加入就绪列表*/
		prvAddTaskToReadyList( pxNewTCB );
		portSETUP_TCB( pxNewTCB );
	}
	taskEXIT_CRITICAL();

	if( xSchedulerRunning != pdFALSE )/*调度器已经启用*/
	{
		/* If the created task is of a higher priority than the current task
		then it should run now. */
		if( pxCurrentTCB->uxPriority < pxNewTCB->uxPriority )
		{
			taskYIELD_IF_USING_PREEMPTION();//任务调度
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

将任务的TCB添加到就绪列表去管理，就绪列表是List_t的根节点数据结构，允许有多少个优先级则有多少个这样的根节点数据结构，将ListItem的TCB链表数据结构挂载到就绪列表中实现任务调度。

xTaskCreate任务创建的函数框架

在这里插入图片描述

J_LIQ
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Cortex-M3扫盲
08-19
作为ARMv7-M架构的一部分，Cortex-M3与早期的ARM7（基于ARMv4T架构）不同，它带来了许多创新特性，比如更高效的指令集和更优化的硬件结构。 学习Cortex-M3的资源包括官方技术参考手册、专业书籍以及各半导体厂家...
FreeRTOS --（3）任务管理之创建任务
梁的愚见
03-02 1467
目录 1、描述任务的结构 2、任务创建 2.1、xTaskCreate 2.2、prvInitialiseNewTask 2.3、pxPortInitialiseStack 2.4、prvAddNewTaskToReadyList 在《FreeRTOS --（7）任务管理之入门篇》文章基本分析了任务相关的轮廓后，我们知道使用什么接口来创建一个任务、怎么去开启调度器、以及根据宏配置，选择调度器的行为；...
FreeRTOS学习（二）
Keitheasun的博客
01-09 675
前面已经大致了解了FreeRTOS的工作机制以及一些常用API的大致内容，接下来我打算从底层层面具体介绍一下任务创建和删除的API是如何实现的。
FreeRTOSMini
zhanglianzhu_91的博客
05-03 886
最近在研究实时操作系统FreeRTOS。FreeRTOS作为开源的RTOS，源码规模不大，可以供操作系统学习，加上我的STM32 Nano开发板正好可以学习OS。借着五一放假宅家里学习。 实现的FreeRTOSMini源码 FreeRTOS有很强的可配置性和硬件适配性。代码里面有大量的宏定义和宏代码分支，看着比较费解，还有一些汇编和关键操作比较费解。然后融合了其他功能增加开始学习难度。读和跟了源码很久才搞头，为了验证是否理解到位，阉割出一个Mini版的系统，只包含基本的任务调度。 本次开发基于FreeRTO
【学习日记】【FreeRTOS】任务句柄、任务控制块TCB、任务栈、任务、就绪表详解
Beihai_Van的博客
08-09 3413
本文是对FreeRTOS中任务句柄、任务控制块TCB、任务栈、任务、就绪表详解。
基于freertos的嵌入式系统开发（八）FreeRTOS的TCB
cyjbj的博客
09-26 935
freertos的任务控制卡TCB定义分析，给出了详细的代码分析和说明。
cortex m3 （lm3s1138） 学习 笔记
09-05
【Cortex-M3（LM3S1138）学习笔记】 Cortex-M3是ARM公司推出的基于ARMv7-M架构的微控制器内核，它以其高效能、低功耗和低成本的特点，广泛应用于嵌入式系统设计。LM3S1138是基于Cortex-M3核心的微控制器，由Texas ...
STM32 FreeRTOS 学习笔记，库函数总结，带目录
03-29
STM32是由意法半导体（STMicroelectronics）推出的基于ARM Cortex-M内核的微控制器系列，广泛应用于各种工业、消费电子和物联网(IoT)设备。FreeRTOS则是一款轻量级、开源的实时操作系统，特别适合资源有限的嵌入式...
freertos cortex M0+ HC32L130 华大
02-28
标题中的“freertos cortex M0+ HC32L130 华大”指的是将FreeRTOS操作系统移植到基于Cortex-M0+内核的华大半导体HC32L130微控制器上的过程。FreeRTOS是一款轻量级、实时操作系统（RTOS），常用于嵌入式系统，特别是...
STM32系列ARMCortex-M3微控制器原理与实践
03-24
STM32系列是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M3内核的高性能、低功耗微控制器。Cortex-M3是ARM公司设计的一种针对微控制器市场的32位处理器内核，它在提供高效能的同时，兼顾了低功耗和低...
FreeRTOS任务创建和删除
qq_41683305的博客
11-20 863
任务创建和删除的API函数 xTaskCreate()：使用动态方法创建一个任务 xTaskCreateStatic()：使用静态方法创建一个任务 xTaskCreateRestricated()：创建一个使用MPU进行限制的任务，相关内存使用动态内存分配 vTaskDelete()：删除一个任务 xTaskCreate 使用该函数，configSUPPORT_DYNAMIC_ALLOCATION要设置为1 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) B
【FreeRTOS】FreeRTOS 动态创建任务与删除
FuckerGod的博客
06-19 898
动态创建任务需要使用到函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转根据上方的描述我们可以得知，此函数将会创建一个新任务，并将其添加到就绪任务列表中。在中，必须设置为 1，或者不定义(在这种情况下，它将默认为1)，以便此函数可以使用。每个任务都需要用于保存任务状态的 RAM，并被任务用作其堆栈。如果使用创建任务，则会==从 FreeRTOS 堆中自动分配所需的 RAM ==。如果使用。
FreeRTOS 创建任务
m0_46579704的博客
11-21 1136
任务是死循环，但是使用AppTaskCreat任务，执行一次后就进行删除，不影响系统运行。任务中的延时函数必须是FreeRTOS中的延时函数，FreeRTOS 的延时函数会阻塞任务，调度器回切换其他任务，从而实现多任务。内核对象句柄：信号量，消息队列，事件标志组这些都属于内核的对象，要想使用这些内核对象，首先要创建，创建成功后会返回一个响应的句柄，实际上是一个指针，我们后续可以通过这个句柄才操作内核对象。
Cortex-M3的双堆栈MSP和PSP（学习）
Caramel_biscuit的博客
08-09 985
M3的栈，先进后出。是局部变量内存的开销，函数的调用都离不开栈。Cortex-M3内核使用了双堆栈，即MSP和PSP。MSP：Main_Stack_Pointer，即主栈。PSP：Process_Stack_Pointer，即任务栈。SP：SP是堆栈指针，指向最后一个被压入元素的地址。M3的压栈和弹栈过程。
RTOS--TCB任务控制块
最新发布
MHD0815的博客
03-21 1310
TCB是RTOS（实时操作系统）中的一个核心概念，它是一个数据结构，主要用于记录和管理任务的相关信息。每个已创建的任务在RTOS中都有一个与之对应的任务控制块，可以理解为任务的“身份证”。任务控制块中包含了很多成员变量，这些变量详细记录了任务的属性，如任务的堆栈栈顶指针、指向下一个任务控制块的指针、任务等待的延迟时间、任务的当前状态标志、任务的优先级别等。这些属性与任务管理密切相关，是系统调度任务和进行任务切换的重要依据。
五、FreeRTOS中任务控制块（TCB）、任务句柄和内核对象句柄
m0_63702526的博客
03-19 1946
FreeRTOS的任务控制块、任务句柄和内核对象句柄
FreeRTOS之TCB
zhanglianzhu_91的博客
05-07 1523
FreeRTOSMini实现了最小任务调度。现在分开介绍进程调度重要部分。进程调度的基础首先是定义任务调度的数据结构，来保存任务堆栈结构和任务状态所在状态列表，然后就是任务的优先级唯一号等。 最小Mini内核参照“FreeRTOSMini”篇，包含源码下载地址。 TCB重要信息有： 1.栈顶指针（pxTopOfStack并且告诉编译器不要优化，随时会变化），和芯片位数一致的整形指针指向任务栈顶。任务让出CPU时候要把寄存器R0-R15、程序计数器、程序状态寄存器等CPU执行上下文压到任务栈。任务被执行时候要
6、FreeRTOS - 列表、列表项、任务控制块TCB
wefaj的博客
10-15 182
最近在网上学习FreeRTOS 列表后做的一些笔记，仅供学习交流！！FreeRTOS 中任务有多种状态：就绪态、运行态、阻塞态、挂起态。当存在多个任务都处于某个状态时，为了方便处理这些任务，会把这些任务组成一个列表。
STM32 FreeRTOS学习——任务创建
weixin_48848862的博客
03-16 420
下面的任务分别定义的任务栈大小为:128和64,展通空间大小为1284字节和644字节//任务堆栈大小//任务堆栈大小//任务1函数while(1)LED1 = 0;LED1 = 1;//任务2函数while(1)LED2 = 0;LED2 = 1;vTaskDelay()为FreeRTOS提供的延时函数,在FreeRTOSConfig.h文件中进行了时钟节拍的配置,如下//RTOS系统节拍中断的频率。即一秒中断的次数，每次中断RTOS都会进行任务调度。
freeRTOS 内核结构
06-08
FreeRTOS 内核结构主要由以下几部分组成： 1. 任务管理器：FreeRTOS 内核中最重要的部分是任务管理器。任务是 FreeRTOS 中最基本的执行单元，任务有自己的堆栈空间、优先级和状态等属性。任务管理器负责管理任务的创建、删除、切换和调度等操作，以及处理任务之间的通信和同步。 2. 调度器：调度器是 FreeRTOS 内核中的核心组件，它负责决定哪个任务在当前时刻应该运行。调度器可以根据任务的优先级、时间片轮转等算法进行任务调度，以确保系统的可响应性和实时性。 3. 信号量和互斥量：FreeRTOS 提供了信号量和互斥量等同步机制，用于实现任务之间的通信和同步。信号量用于控制任务对共享资源的访问，互斥量用于确保同时只有一个任务能够访问共享资源。 4. 队列和消息传递：FreeRTOS 提供了队列和消息传递机制，用于实现任务之间的数据传递和通信。任务可以通过向队列中发送消息的方式来与其他任务进行通信，也可以通过接收队列中的消息来等待其他任务的响应。 5. 定时器服务：FreeRTOS 提供了定时器服务，可以用于实现定时任务、延时操作等。定时器服务可以在任务中创建和启动定时器，定时器到期后会触发回调函数，执行相应的操作。 总之，FreeRTOS 内核结构是由任务管理器、调度器、同步机制、通信机制和定时器服务等组件构成的，这些组件相互协作，共同实现了 FreeRTOS 的多任务调度和实时性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值