刘火良FreeRTOS内核实现与应用学习之6——多优先级

在FreeRTOS中,数字优先级越小,逻辑优先级也越小;在任务创建时,会根据任务的优先级将任务插入就绪列表不同的位置。

List_t pxReadyTasksLists[ configMAX_PRIORITIES ] 就绪列表是一个数组,数组中存储的是就绪任务TCB(任务控制块通过自己的钩子<TCB中的xStateListItem节点>挂上了List_t)。

创建任务时,a. 会根据任务的优先级将任务插入就绪列表数组的不同的位置;

b. 相同优先级的任务插入就绪列表数组中的同一条链表中。

要想任务支持优先级,即只要实现在任务切换(taskYIELD)时,让pxCurrentTCB指向最高优先级的就绪任务的TCB既可以。

重要数据

0. 全局TCB指针

/* 当前正在运行的任务的任务控制块指针,默认初始化为NULL */

TCB_t * volatile pxCurrentTCB = NULL;

要想让任务支持优先级,即只要实现任务切换(portYIELD)时,让pxCurrentTCB指向最高优先级的就绪任务的TCB即可。

1. 静态变量:uxTopReadyPriority

位置:在task.c文件中定义;静态变量;

static volatile UBaseType_t uxTopReadyPriority = tskIDLE_PRIORITY;

表示创建的任务的最高优先级,默认初始化为0,即空闲任务的优先级。

数值越大,优先级越高;

2. 修改任务控制块:增加一变量

增加了一个变量:UBaseType_t uxPriority;

描述任务块的优先级。

复制代码
typedef struct tskTaskControlBlock
{
	volatile StackType_t    *pxTopOfStack;    /* 栈顶 */

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

    TickType_t xTicksToDelay;
    UBaseType_t			uxPriority;    
} tskTCB;
typedef tskTCB TCB_t;

3. 全局任务数

static volatile UBaseType_t uxCurrentNumberOfTasks = ( UBaseType_t ) 0U;

static UBaseType_t uxTaskNumber = ( UBaseType_t ) 0U;

此处有一个疑问:这个变量做什么用?

查找当前最高优先级的就绪任务,给uxTopReadyPriority 赋值,给pxCurrentTCB赋值,有两种方法。

两种方法

查找最高优先级的就绪任务有两种方法,具体由宏configUSE_PORT_OPTIMISED_TASK_SELECTION控制,定义为0选择通用方法,定义为1选择根据处理器优化的方法,该宏默认在portmacro.h文件中定义为1,即使用优化过的方法。

复制代码
#ifndef configUSE_PORT_OPTIMISED_TASK_SELECTION
	#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1
#endif

该功能主要是通过四个宏来实现:

taskRECORD_READY_PRIORITY( uxPriority ) :记录就绪最高优先级的就绪任务uxTopReadyPriority 赋值;

taskSELECT_HIGHEST_PRIORITY_TASK():在任务列表中寻找就绪最高优先级的就绪任务,获取优先级最高的就绪任务的TCB,然后更新到pxCurrentTCB;

taskRESET_READY_PRIORITY( uxPriority )

portRESET_READY_PRIORITY( uxPriority, uxTopReadyPriority )

通用方法

在通用方法中实现了上面的宏1、宏2;宏3~4为空。

两个宏定义

taskRECORD_READY_PRIORITY( uxPriority )

位置:在task.c文件中定义;

实现记录当前运行任务的优先级,直接得到优先级的序号,并更新到静态变量 uxTopReadyPriority 中;

复制代码
	#define taskRECORD_READY_PRIORITY( uxPriority )														\
	{																									\
		if( ( uxPriority ) > uxTopReadyPriority )														\
		{																								\
			uxTopReadyPriority = ( uxPriority );														\
		}																								\
	} /* taskRECORD_READY_PRIORITY */
taskSELECT_HIGHEST_PRIORITY_TASK()

位置:在task.c文件中定义;

复制代码
	#define taskSELECT_HIGHEST_PRIORITY_TASK()															\
	{																									\
	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 */

1)用于寻找优先级最高的就绪任务、更新静态变量 uxTopReadyPriority;调用宏:listLIST_IS_EMPTY( pxList )

复制代码
/* 判断链表是否为空 */
#define listLIST_IS_EMPTY( pxList )	( ( BaseType_t ) ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) )

此处有一个疑问:链表中的变量计数器(uxNumberOfItems)用来做什么用?

/* 链表结构体定义 */

typedef struct xLIST

{

UBaseType_t uxNumberOfItems; /* 链表节点计数器 */

ListItem_t * pxIndex; /* 链表节点索引指针 */

MiniListItem_t xListEnd; /* 链表最后一个节点 */

} List_t;

现在可以回答这个问题了,也就是这列链表中节点的个数,当任务的优先级一样的话,是插到就绪任务链表数组的同一位置的,所以同一优先级就绪任务需要计数:uxNumberOfItems;

a. 将节点从链表中删除:

UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove ) 函数会减1;

b. 将节点插入到链表的尾部 :void vListInsertEnd( List_t * const pxList, ListItem_t * const pxNewListItem ) 函数中加1;

2)更新全局变量pxCurrentTCB;调用宏:listGET_OWNER_OF_NEXT_ENTRY(..)

复制代码
/* 获取链表节点的OWNER,即TCB */
#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )										\
{																							\
	List_t * const pxConstList = ( pxList );											    \
	/* 节点索引指向链表第一个节点调整节点索引指针,指向下一个节点,
    如果当前链表有N个节点,当第N次调用该函数时,pxInedex则指向第N个节点 */\
	( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;							\
	/* 当前链表为空 */                                                                       \
	if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) )	\
	{																						\
		( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;						\
	}																						\
	/* 获取节点的OWNER,即TCB */                                                             \
	( pxTCB ) = ( pxConstList )->pxIndex->pvOwner;											 \
}

/* 节点结构体定义 */

struct xLIST_ITEM

{

TickType_t xItemValue; /* 辅助值,用于帮助节点做顺序排列 */

struct xLIST_ITEM * pxNext; /* 指向链表下一个节点 */

struct xLIST_ITEM * pxPrevious; /* 指向链表前一个节点 */
void * pvOwner; /* 指向拥有该节点的内核对象,通常是TCB */

void * pvContainer; /* 指向该节点所在的链表 */

};

typedef struct xLIST_ITEM ListItem_t; /* 节点数据类型重定义 */

3)继续更新静态变量 uxTopReadyPriority;

优化方法

Cortex-M 内核有一个计算前导零的指令:CLZ。用于计算一个变量从高位开始第一次出现1的位前面的0的个数。

__clz( ( uxReadyPriorities ):

a. uxReadyPriorities 为32位,每一个位号对应一个任务的优先级,1就绪,反之为0;

b. 32个优先级的任务: ( 31UL - ( uint32_t ) __clz( ( uxReadyPriorities ) ) )表示最高就绪任务的等级;

复制代码
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) __clz( ( uxReadyPriorities ) ) )

两个宏定义

taskRECORD_READY_PRIORITY( uxPriority )

位置:在task.c文件中定义;

复制代码
#define taskRECORD_READY_PRIORITY( uxPriority )	portRECORD_READY_PRIORITY( uxPriority, uxTopReadyPriority )

里头又涉及到两个宏:portRECORD_READY_PRIORITY 和 portRESET_READY_PRIORITY

位置:在portmacro.h文件中定义;

a. portRECORD_READY_PRIORITY 完成功能:任务就绪就把uxReadyPriorities相应的位置1;得到能够反应就绪的32位的变量uxReadyPriorities;

b.portRESET_READY_PRIORITY 功能相反;

复制代码
#if configUSE_PORT_OPTIMISED_TASK_SELECTION == 1

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

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

	#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) __clz( ( uxReadyPriorities ) ) )

#endif /* taskRECORD_READY_PRIORITY */
taskSELECT_HIGHEST_PRIORITY_TASK()

位置:在portmacro.h文件中定义;

就是利用前面提到的计算前导零的指令:CLZ 实现,算出就绪最高优先级任务的的级别出来;

复制代码
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) __clz( ( uxReadyPriorities ) ) )

从而实现宏:taskSELECT_HIGHEST_PRIORITY_TASK。

复制代码
	#define taskSELECT_HIGHEST_PRIORITY_TASK()														    \
	{																								    \
	UBaseType_t uxTopPriority;																		    \
																									    \
		/* 寻找最高优先级 */								                            \
		portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority );								    \
		/* 获取优先级最高的就绪任务的TCB,然后更新到pxCurrentTCB */                                       \
		listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );		    \
	} /* taskSELECT_HIGHEST_PRIORITY_TASK() */

有关任务操作重要函数

1. 修改:TaskHandle_t xTaskCreateStatic(...)

1)内部增加了将任务添加到就绪列表的功能:prvAddNewTaskToReadyList;

2)在原本的prvInitialiseNewTask中增加了设置优先级的功能;

prvInitialiseNewTask( pxTaskCode, pcName, ulStackDepth, pvParameters,uxPriority, &xReturn, pxNewTCB);

原来的函数,初始化与任务相关的列表,如就绪列表;

static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )

是一个带参宏,位置:在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();
}

完成如下功能:

a. 初始化任务链表(若是第一次):prvInitialiseTaskLists;

b. 把任务加到就绪列表:prvAddTaskToReadyList;

这个是通过前面的宏 (查找优先级)+ 列表插入函数实现(根据优先级将任务插入就绪列表pxReadyTasksLists[])

prvAddTaskToReadyList( pxNewTCB );

* 将任务添加到就绪列表 */

#define prvAddTaskToReadyList( pxTCB ) \

taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority ); \

vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) );

完成

a. 任务控制块的钩子(过自己的钩子<TCB中的xStateListItem节点>挂上了List_t)。);

b. 任务控制块的容纳者是链表数组的某一个;

c.该链表拥有的任务(控制块)的数量加一;

2. vTaskStartScheduler()维持不变

完成如下功能:

1)创建空闲任务;

2)启动任务调度器xPortStartScheduler;

3.修改:void vTaskDelay( const TickType_t xTicksToDelay )

位置:在task.c文件中定义;

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

此处的修改注意,以前是从任务列表中移除:uxListRemove( &( pxTCB->xStateListItem ) );

现在是通过函数(宏):taskRESET_READY_PRIORITY( pxTCB->uxPriority ) ;实现复位变量uxReadyPriorities相对于的位;

然后是调用任务切换taskYIELD,触发中断:vTaskSwitchContext;

4. 修改:void vTaskSwitchContext( void )

任务切换,即寻找优先级最高的就绪任务;

利用宏自动寻找优先级最高的就绪任务的TCB,然后更新到全局变量任务控制块指针pxCurrentTCB中;

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

5. 修改:void xTaskIncrementTick( void )

位置:在task.c文件中定义;

由定时中断xPortSysTickHandler调用;完成如下功能:

a. 实现全局变量xTickCount 计数操作;

此处有一个疑问:xTickCount 的加1为何这么麻烦,通过xConstTickCount常量来实现啊?

const TickType_t xConstTickCount = xTickCount + 1;
xTickCount = xConstTickCount;

可能的原因 这种写法可能是出于以下原因之一: 1. 调试方便:使用局部变量 xConstTickCount 可以方便地在调试时观察 xTickCount 自增后的值。 2. 代码风格:某些开发者可能倾向于通过局部变量来分离计算和赋值逻辑,以提高代码的可读性。 3. 历史遗留:这段代码可能是从更复杂的逻辑简化而来的,原本 xConstTickCount 可能有其他用途,但后来简化成了当前的形式。

b. 扫描所有的就绪列表的时间是否到了,到了记录:taskRECORD_READY_PRIORITY( pxTCB->uxPriority );

c. 扫描结束进行任务切换portYIELD,触发中断;

复制代码
void xTaskIncrementTick( void )
{
    TCB_t *pxTCB = NULL;
    BaseType_t i = 0;
    
    /* 更新系统时基计数器xTickCount,xTickCount是一个在port.c中定义的全局变量 */
    const TickType_t xConstTickCount = xTickCount + 1;
    xTickCount = xConstTickCount;

    
    /* 扫描就绪列表中所有线程的xTicksToDelay,如果不为0,则减1 */
	for(i=0; i<configMAX_PRIORITIES; i++)
	{
        pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &pxReadyTasksLists[i] ) );
		if(pxTCB->xTicksToDelay > 0)
		{
			pxTCB->xTicksToDelay --;
		}
	}
    
    /* 任务切换 */
    portYIELD();
}

6. 任务切换函数 portYIELD() 与taskYIELD

功能:设置 PendSV 的中断挂起位,产生上下文切换。

#define taskYIELD() portYIELD()

复制代码
#define portYIELD()																\
{																				\
	/* 设置 PendSV 的中断挂起位,产生上下文切换 */								\
	portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;								\
																				\
	/* Barriers are normally not required but do ensure the code is completely	\
	within the specified behaviour for the architecture. */						\
	__dsb( portSY_FULL_READ_WRITE );											\
	__isb( portSY_FULL_READ_WRITE );											\
}

主函数及其调试

重要文件

相关推荐
ddd...e_bug32 分钟前
常用天然地震链接
学习
yuanbenshidiaos42 分钟前
stm32面试
stm32·嵌入式硬件·面试
charlie1145141911 小时前
STM32F103C8T6单片机的起始点:使用GPIO输出点亮我们的第一个小灯(标准库篇)
stm32·单片机·嵌入式硬件
DOMINICHZL2 小时前
国产MCU替代STM32全解析:主流方案对比与实战指南
stm32·单片机·嵌入式硬件·gd32
杉之2 小时前
Java中的不可变集合
java·笔记·学习
-一杯为品-3 小时前
【STM32单片机】#4 OLED调试&外部中断
stm32·单片机·mongodb
viperrrrrrrrrr74 小时前
大数据学习(95)-谓词下推
大数据·sql·学习
不被定义的~wolf4 小时前
【STM32】编写程序控制开发板的RGB LED灯
stm32·单片机·嵌入式硬件
唔664 小时前
flutter 曲线学习 使用第三方插件实现左右滑动
javascript·学习·flutter
haoly19895 小时前
离散数学问题集--问题4.40
学习