FreeRTOS个人笔记-支持多优先级

Couvrir洪荒猛兽

已于 2022-07-19 16:43:49 修改

阅读量412

点赞数

分类专栏： # FreeRTOS 文章标签：操作系统 c语言 stm32 单片机

于 2022-07-17 18:37:27 首次发布

本文链接：https://blog.csdn.net/weixin_47077788/article/details/125833406

版权

FreeRTOS 专栏收录该内容

26 篇文章 21 订阅

订阅专栏

根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。

配套资料：FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！

支持多优先级

在FreeRTOS中，数字优先级越小，逻辑优先级也越小，这与隔壁的RT-Thread和uC/OS刚好相反。

就绪列表pxReadyTasksList[configMAX_PRIORITIES]是一个数组，数组存的是就绪任务TCB的xStateListItem节点，数组的下标对于任务的优先级，优先级越小对应的数组下标越小。

空闲任务的优先级最低，对应下标数字为0的链表。空闲任务自系统启动后会一直就绪，因为系统至少得保证有一个任务可以运行。

任务在创建时，会根据任务的优先级将任务插入到就绪列表不同的位置。相同优先级的任务插入到就绪列表里的同一条链表中。

pxCurrenTCB是一个全局的TCB指针，用于指向优先级最高的就绪任务TCB，即当前正在运行的TCB。

如果我们想让任务支持多优先级，只要解决在任务切换（taskYIELD）时,让pxCurrenTCB指向最高优先级的就绪任务TCB即可。

某些运行FreeRTOS的硬件有两种方法选择来获取下一个要执行的任务：

通用方法。获取下一个要执行的任务。

根据处理器架构优化后的方法。查找下一个要执行的任务。

实在是太长了，不好描述，分开写。

/* 查找最高优先级的就绪任务：通用方法 */                                    
#if ( configUSE_PORT_OPTIMISED_TASK_SELECTION == 0 )

	/* uxTopReadyPriority 存的是就绪任务的最高优先级 */
    /* 下面宏意在找出就绪任务的最高优先级，更新 uxTopReadyPriority 的值 */
	#define taskRECORD_READY_PRIORITY( uxPriority )		\
	{													\
		if( ( uxPriority ) > uxTopReadyPriority )		\
		{												\
			uxTopReadyPriority = ( uxPriority );		\
		}												\
	} /* taskRECORD_READY_PRIORITY */

	/*-----------------------------------------------------------*/
    /* 寻找包含就绪任务的最高优先级的队列 */                                
	#define taskSELECT_HIGHEST_PRIORITY_TASK()									\
	{	                                                                        \			
        /* uxTopReadyPriority 存的是就绪任务的最高优先级 */						\
	    UBaseType_t uxTopPriority = uxTopReadyPriority;							\
		                                                                        \
		/* 从最高优先级对应的就绪列表数组下标开始寻找当前链表下是否有任务存在 */      \
        /* 当列表为空时，执行循环内容 */                                          \
        while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopPriority ] ) ) )	\
		{																		\
			--uxTopPriority;													\
		}/* 找到了最高优先级的就绪任务 */											\
			                                                                    \
		/* 获取在就绪列表中优先级最高的任务TCB，然后更新到pxCurrentTCB */				\
		listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );	\
		/* 更新uxTopReadyPriority */                                            \
		uxTopReadyPriority = uxTopPriority;										\
	} /* taskSELECT_HIGHEST_PRIORITY_TASK */

	/*-----------------------------------------------------------*/

	/* 这两个宏定义只有在选择优化方法时才用，这里定义为空 */
	#define taskRESET_READY_PRIORITY( uxPriority )
	#define portRESET_READY_PRIORITY( uxPriority, uxTopReadyPriority )

上面为通用方法，主要写到了以下宏。

taskRECORD_READY_PRIORITY( uxPriority )意在找出就绪任务的最高优先级，拿uxPriority和uxTopReadyPriority比较，更新最高优先级 uxTopReadyPriority 的值。

taskSELECT_HIGHEST_PRIORITY_TASK()意在寻找包含就绪任务的最高优先级的队列。pxCurrentTCB已经更新为在就绪列表中优先级最高的任务TCB，也更新了最高优先级 uxTopReadyPriority 的值。

/* 获取pxList链表节点的OWNER，即pxTCB*/
#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )

列表操作函数，在第一节的时候末尾有写过，这里就运用到了。

处理器架构优化后的方法。这个方法得益于 Cortex-M 内核有一个计算前导零的指令 CLZ，所谓前导零就是计算一个变量（Cortex-M 内核单片机的变量为 32位）从高位开始第一次出现 1 的位的前面的零的个数。比如：一个 32 位的变量 uxTopReadyPriority，其位 0、位 24 和位 25 均置 1 ，其余位为 0 ，具体见。那么使用前导零指令 __CLZ (uxTopReadyPriority)可以很快的计算出 uxTopReadyPriority 的前导零的个数为 6。

如果 uxTopReadyPriority 的每个位号对应的是任务的优先级，任务就绪时，则将对应的位置 1 ，反之则清零。那么图 10-2 就表示优先级 0 、优先级 24 和优先级 25 这三个任务就绪，其中优先级为 25 的任务优先级最高。利用前导零计算指令可以很快计算出就绪任务中的最高优先级为：( 31UL - ( uint32_t ) __clz( ( uxReadyPriorities ) ) ) = ( 31UL - ( uint32_t ) 6 ) = 25。

只需要计算出 uxTopReadyPriority 的前导零个数就算找到了就绪任务的最高优先级。

/* 根据优先级uxPriority设置/清除优先级位图中相应的位，uxReadyPriorities为优先级表 */
#define portRECORD_READY_PRIORITY( uxPriority, uxReadyPriorities )  ( uxReadyPriorities ) |= ( 1UL << ( uxPriority ) )

/* 查找最高优先级的就绪任务：根据处理器架构优化后的方法 */
#else /* configUSE_PORT_OPTIMISED_TASK_SELECTION */

    /* 根据任务的优先级uxPriority将优先级位图uxTopReadyPriority的某个位置 1。 */
	#define taskRECORD_READY_PRIORITY( uxPriority )	portRECORD_READY_PRIORITY( uxPriority, uxTopReadyPriority )

	/*-----------------------------------------------------------*/

	#define taskSELECT_HIGHEST_PRIORITY_TASK()										\
	{																				\
	    UBaseType_t uxTopPriority;													\																									    
                                                                                    \
		/* 寻找最高优先级uxTopPriority，uxTopReadyPriority为优先级位图 */				\
		portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority );				\
                                                                                    \
		/* pxReadyTasksLists为就绪列表，获取在就绪列表中最高优先级的TCB，然后更新pxCurrentTCB */   \
		listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );		    \
	} /* taskSELECT_HIGHEST_PRIORITY_TASK() */

	/*-----------------------------------------------------------*/
#if 0
    /*taskRESET_READY_PRIORITY( uxPriority )与taskRECORD_READY_PRIORITY( uxPriority )相反*/
	#define taskRESET_READY_PRIORITY( uxPriority )														\
	{																									\
		if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ ( uxPriority ) ] ) ) == ( UBaseType_t ) 0 )	\
		{																								\
			portRESET_READY_PRIORITY( ( uxPriority ), ( uxTopReadyPriority ) );							\
		}																								\
	}
#else
    #define taskRESET_READY_PRIORITY( uxPriority )											            \
    {																							        \
            portRESET_READY_PRIORITY( ( uxPriority ), ( uxTopReadyPriority ) );					        \
    }
#endif
    
#endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */

上面为处理器架构优化后的方法，主要写到了以下宏。

taskRECORD_READY_PRIORITY( uxPriority )意在根据任务的优先级uxPriority将优先级位图uxTopReadyPriority的某个位置 1。

taskSELECT_HIGHEST_PRIORITY_TASK()意在寻找包含就绪任务的最高优先级的队列。pxCurrentTCB已经更新为在就绪列表中优先级最高的任务TCB。

TCB结构体再添成员，逐步完善。

typedef struct tskTaskControlBlock
{
	volatile StackType_t    *pxTopOfStack;    /* 栈顶 */

	ListItem_t			    xStateListItem;   /* 任务节点 */
    
    StackType_t             *pxStack;         /* 任务栈起始地址 */
	                                          
	char                    pcTaskName[ configMAX_TASK_NAME_LEN ];    /* 任务名称，字符串形式 */

    TickType_t              xTicksToDelay;    /* SysTick延时 */

    UBaseType_t			    uxPriority;       /* 优先级 */ 
} tskTCB;
typedef tskTCB TCB_t;

相应很多函数会增加内容。

xTaskCreateStatic()如下

#if( configSUPPORT_STATIC_ALLOCATION == 1 )

TaskHandle_t xTaskCreateStatic(	TaskFunction_t pxTaskCode,           /* 任务入口 */
					            const char * const pcName,           /* 任务名称，字符串形式 */
					            const uint32_t ulStackDepth,         /* 任务栈大小，单位为字 */
					            void * const pvParameters,           /* 任务形参 */
                                UBaseType_t uxPriority,              /* 任务优先级，数值越大，优先级越高 */
					            StackType_t * const puxStackBuffer,  /* 任务栈起始地址 */
					            TCB_t * const pxTaskBuffer )         /* 任务控制块 */
{
	TCB_t *pxNewTCB;
	TaskHandle_t xReturn;

	if( ( pxTaskBuffer != NULL ) && ( puxStackBuffer != NULL ) )
	{		
		pxNewTCB = ( TCB_t * ) pxTaskBuffer; 
		pxNewTCB->pxStack = ( StackType_t * ) puxStackBuffer;

		/* 创建新的任务 */
		prvInitialiseNewTask( pxTaskCode, pcName, ulStackDepth, pvParameters,uxPriority, &xReturn, pxNewTCB);
        
		/* 将任务添加到就绪列表 */
		prvAddNewTaskToReadyList( pxNewTCB );

	}
	else
	{
		xReturn = NULL;
	}

	return xReturn;
}

prvInitialiseNewTask()函数如下

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 )                       /* 任务控制块 */

{
	StackType_t *pxTopOfStack;
	UBaseType_t x;	
	
	/* 获取栈顶地址 */
	pxTopOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
	//pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
	/* 向下做8字节对齐 */
	pxTopOfStack = ( StackType_t * ) ( ( ( uint32_t ) pxTopOfStack ) & ( ~( ( uint32_t ) 0x0007 ) ) );	

	/* 将任务的名字存储在TCB中 */
	for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
	{
		pxNewTCB->pcTaskName[ x ] = pcName[ x ];

		if( pcName[ x ] == 0x00 )
		{
			break;
		}
	}
	/* 任务名字的长度不能超过configMAX_TASK_NAME_LEN */
	pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';
    
    /* 初始化TCB中的xStateListItem节点 */
    vListInitialiseItem( &( pxNewTCB->xStateListItem ) );
    /* 设置xStateListItem节点的拥有者 */
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );
	
    /* 初始化优先级 */
	if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
	{
		uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
	}
	pxNewTCB->uxPriority = uxPriority;
    
	/* 初始化任务栈 */
	pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters ); 
    
    /* 让任务句柄指向任务控制块 */
    if( ( void * ) pxCreatedTask != NULL )
	{		
		*pxCreatedTask = ( TaskHandle_t ) pxNewTCB;
	}
}

新增将任务添加到就绪列表的函数prvAddNewTaskToReadyList()函数，定义在task.c。

static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )
{
	/* 进入临界段 */
	taskENTER_CRITICAL();
	{
		/* 全局任务计时器加一操作 */
        uxCurrentNumberOfTasks++;
        
        /* 如果pxCurrentTCB为空，则将pxCurrentTCB指向新创建的任务 */
		if( pxCurrentTCB == NULL )
		{
			pxCurrentTCB = pxNewTCB;

			/* 如果是第一次创建任务，则需要初始化任务相关的列表 */
            if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )
			{
				/* 初始化任务相关的列表 */
                prvInitialiseTaskLists();
			}
		}
		else /* 如果pxCurrentTCB不为空，则根据任务的优先级将pxCurrentTCB指向最高优先级任务的TCB */
		{
				if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )
				{
					pxCurrentTCB = pxNewTCB;
				}
		}
		uxTaskNumber++;
        
		/* 将任务添加到就绪列表 */
        prvAddTaskToReadyList( pxNewTCB );

	}
	/* 退出临界段 */
	taskEXIT_CRITICAL();
}

prvAddTaskToReadyList()函数实际上是vListInsertEnd()函数的分化，宏定义如下

/* 将任务添加到就绪列表 */                                    
#define prvAddTaskToReadyList( pxTCB )																   \
	taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );												   \
	vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) ); \

vTaskStartScheduler()函数也增加了部分代码

void vTaskStartScheduler( void )
{
/*======================================创建空闲任务start==============================================*/     
    TCB_t *pxIdleTaskTCBBuffer = NULL;
    StackType_t *pxIdleTaskStackBuffer = NULL;
    uint32_t ulIdleTaskStackSize;
    
    /* 获取空闲任务的内存：任务栈和任务TCB */
    vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, 
                                   &pxIdleTaskStackBuffer, 
                                   &ulIdleTaskStackSize );    
    
    xIdleTaskHandle = xTaskCreateStatic( (TaskFunction_t)prvIdleTask,              /* 任务入口 */
					                     (char *)"IDLE",                           /* 任务名称，字符串形式 */
					                     (uint32_t)ulIdleTaskStackSize ,           /* 任务栈大小，单位为字 */
					                     (void *) NULL,                            /* 任务形参 */
                                         (UBaseType_t) tskIDLE_PRIORITY,           /* 任务优先级，数值越大，优先级越高 */
					                     (StackType_t *)pxIdleTaskStackBuffer,     /* 任务栈起始地址 */
					                     (TCB_t *)pxIdleTaskTCBBuffer );           /* 任务控制块 */
    /* 将任务添加到就绪列表 */                                 
    //vListInsertEnd( &( pxReadyTasksLists[0] ), &( ((TCB_t *)pxIdleTaskTCBBuffer)->xStateListItem ) );
/*======================================创建空闲任务end================================================*/
                                         
    /* 手动指定第一个运行的任务 */
    //pxCurrentTCB = &Task1TCB;
    
    /* 启动调度器 */
    if( xPortStartScheduler() != pdFALSE )
    {
        /* 调度器启动成功，则不会返回，即不会来到这里 */
    }
}

vTaskDelay()函数也增加了部分代码

void vTaskDelay( const TickType_t xTicksToDelay )
{
    TCB_t *pxTCB = NULL;
    
    /* 获取当前任务的TCB */
    pxTCB = pxCurrentTCB;
    
    /* 设置延时时间 */
    pxTCB->xTicksToDelay = xTicksToDelay;
    
    /* 将任务从就绪列表移除 */
    //uxListRemove( &( pxTCB->xStateListItem ) );
    taskRESET_READY_PRIORITY( pxTCB->uxPriority );    //将当前优先级的位 置0
    
    /* 任务切换 */
    taskYIELD();
}

在新的任务切换函数vTaskSwitchContext()中，不再是手动的让pxCurrenTCB指针在任务1、任务2和空闲任务中切换，而是直接调用函数taskSELECT_HIGHEST_PRIORITY_TASK寻找到优先级最高的就绪任务的TCB，然后更新到pxCurrenTCB。

vTaskSwitchContext()函数如下

/* 任务切换，即寻找优先级最高的就绪任务 */
void vTaskSwitchContext( void )
{
	/* 获取优先级最高的就绪任务的TCB，然后更新到pxCurrentTCB */
    taskSELECT_HIGHEST_PRIORITY_TASK();
}

taskSELECT_HIGHEST_PRIORITY_TASK在我们这节的“通用方法”那里出现了，可以往上翻翻。

当任务延时时间到，将任务就绪。xTaskIncrementTick函数如下

void xTaskIncrementTick( void )
{
    TCB_t *pxTCB = NULL;
    BaseType_t i = 0;
    
    const TickType_t xConstTickCount = xTickCount + 1;
    xTickCount = xConstTickCount;

    
    /* 扫描就绪列表中所有线程的remaining_tick，如果不为0，则减1 */
	for(i=0; i<configMAX_PRIORITIES; i++)
	{
        //获取就绪列表中第一个列表项所属的TCB
        //为什么是第一个列表项？因为FreeRTOS的列表是从小到大排序的，获得列表中的第一个列表项的xItemValue值总是最小，也就是优先级最高的任务！
        pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &pxReadyTasksLists[i] ) );
		if(pxTCB->xTicksToDelay > 0)
		{
			pxTCB->xTicksToDelay --;
            
            /* 延时时间到，将任务就绪 */
            if( pxTCB->xTicksToDelay ==0 )
            {
                //根据任务优先级uxPriority将优先级位图uxTopReadyPriority的某个位置 1。
                taskRECORD_READY_PRIORITY( pxTCB->uxPriority );
            }
		}
	}
    
    /* 任务切换 */
    portYIELD();
}

根据优先级将优先级位图表 uxTopReadyPriority 中对应的位置位。在刚刚修改的上下文切换函数 vTaskSwitchContext() 中，就是通过优先级位图表 uxTopReadyPriority 来寻找就绪任务的最高优先级的。

main()函数如下图

Couvrir洪荒猛兽

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
FreeRTOS个人笔记-支持多优先级

根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。配套资料FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
复制链接

扫一扫