FreeRTOS记录（三、RTOS任务调度原理解析_Systick、PendSV、SVC）_systick,pendsv 和 svc(2)

2401_85015466

于 2024-05-16 23:46:36 发布

阅读量985

点赞数 19

分类专栏： 2024年程序员学习文章标签：物联网嵌入式硬件面试

本文链接：https://blog.csdn.net/2401_85015466/article/details/138979139

版权

2024年程序员学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。

如果你需要这些资料，可以戳这里获取

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

在Cortex-M内核上，FreeRTOS使用Systick定时器作为心跳时钟，一般默认心跳时钟为1ms，进入Systick中断后，内核会进入处理模式进行处理，在Systick中断处理中，系统会在 ReadList 就绪链表从高优先级到低优先找需要执行的任务，进行调度，如果有任务的状态发生了变化，改变了状态链表，就会产生一个pendSV异常，进入pendSV异常，通过改变进程栈指针（PSP）切换到不同的任务。

对于相同优先级的任务，每隔一个Systick，运行过的任务被自动排放至该优先级链表的尾部（时间片调度）

用户也可以在线程模式下主动触发PendSV，进行任务切换。

在FreeRTOS中SVC只使用了一次（M0中没有使用），就是第一次。

FreeRTOS进入临界区是通过配置BASEPRI寄存器来进行的。

Systick

我们已经知道，在Cortex-M系列中 systick是作为FreeRTOS 的心跳时钟，是调度器的核心。

系统是在Systick中进行上下文切换。

那么他是如何进行上下文切换的呢，那就得来说说内核的中断管理了，记住一句话

操作系统的入口是中断（好像是废话，嵌入式所有程序的入口都是中断= =！）

Systick 源码解析

Systick 初始化

systick的初始化在port.c中， vPortSetupTimerInterrupt函数：

/\*
 \* Setup the systick timer to generate the tick interrupts at the required
 \* frequency.
 \*/
\_\_attribute\_\_(( weak )) void vPortSetupTimerInterrupt( void )
{
	/\* Calculate the constants required to configure the tick interrupt. \*/
	#if( configUSE\_TICKLESS\_IDLE == 1 )
	{
		ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ );
		xMaximumPossibleSuppressedTicks = portMAX_24_BIT_NUMBER / ulTimerCountsForOneTick;
		ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / ( configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ );
	}
	#endif /\* configUSE\_TICKLESS\_IDLE \*/

	/\* 
 Stop and clear the SysTick.
 清0，保证上电后的准确性 
 \*/
	portNVIC_SYSTICK_CTRL_REG = 0UL;
	portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
	/\* 
 Configure SysTick to interrupt at the requested rate.
 portNVIC\_SYSTICK\_LOAD\_REG systick装载值
 portNVIC\_SYSTICK\_CTRL\_REG systick控制寄存器 配置系统时钟源，开启中断，使能
 \*/
	portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
	portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );
}
/\*-----------------------------------------------------------\*/

Systick 中断服务函数

每一节拍进入一次Systick 中断，因为Systick 如果调度器返回true，触发pendSV异常：

/\*-----------------------------------------------------------\*/

void xPortSysTickHandler( void )
{
	/\* The SysTick runs at the lowest interrupt priority, so when this interrupt
 executes all interrupts must be unmasked. There is therefore no need to
 save and then restore the interrupt mask value as its value is already
 known.
 进入临界区，在上面一篇文章讲过，通过配置BASEPRI寄存器，关闭的中断等级在CubeMX中设置
 \*/
	portDISABLE\_INTERRUPTS();
	{
		/\* 
 Increment the RTOS tick. 
 操作系统调度接口
 如果调度器返回true，触发pendSV异常
 \*/
		if( xTaskIncrementTick() != pdFALSE )
		{
			/\* 
 A context switch is required. Context switching is performed in
 the PendSV interrupt. Pend the PendSV interrupt. 
 往中断控制及状态寄存器ICSR(地址：0xE000\_ED04)的bit28写1挂起一次PendSV中断
 触发pendSV
 \*/
			portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
		}
	}
	/\*
 开中断，执行pendSV
 \*/
	portENABLE\_INTERRUPTS();
}

Systick 任务调度

Systick中断中调用xTaskIncrementTick任务调度如下,源码注释：

/\*----------------------------------------------------------\*/

BaseType_t xTaskIncrementTick( void )
{
TCB_t \* pxTCB;
TickType_t xItemValue;
BaseType_t xSwitchRequired = pdFALSE;// 返回值，表示是否进行上下文切换

	/\* Called by the portable layer each time a tick interrupt occurs.
 Increments the tick then checks to see if the new tick value will cause any
 tasks to be unblocked. \*/
	traceTASK\_INCREMENT\_TICK( xTickCount );
	/\*
 uxSchedulerSuspended 表示内核调度器是否挂起
 pdFALSE 表示内核没有挂起
 \*/
	if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
	{
		/\* 
 Minor optimisation. The tick count cannot change in this
 block. 
 tick计数增加1
 \*/
		const TickType_t xConstTickCount = xTickCount + ( TickType_t ) 1;
		/\* Increment the RTOS tick, switching the delayed and overflowed
 delayed lists if it wraps to 0. \*/
		xTickCount = xConstTickCount;

		/\*
 判断tick是否溢出越界
 \*/
		if( xConstTickCount == ( TickType_t ) 0U ) /\*lint !e774 'if' does not always evaluate to false as it is looking for an overflow. \*/
		{
			taskSWITCH\_DELAYED\_LISTS();//如果溢出，要更新延时列表
		}
		else
		{
			mtCOVERAGE\_TEST\_MARKER();
		}

		/\* See if this tick has made a timeout expire. Tasks are stored in
 the queue in the order of their wake time - meaning once one task
 has been found whose block time has not expired there is no need to
 look any further down the list. 
 当前节拍大于时间片的锁定时间
 说明有任务需要进行调度了，时间片用完了
 \*/
		if( xConstTickCount >= xNextTaskUnblockTime )
		{
			/\*
 会一直遍历整个任务延时列表，
 找到时间片最短的任务，进行切换
 \*/
			for( ;; )
			{
				/\*
 判断任务延时列表中，是否为空，
 也就是说，有没有任务在等待调度
 \*/
				if( listLIST\_IS\_EMPTY( pxDelayedTaskList ) != pdFALSE )
				{
					/\* The delayed list is empty. Set xNextTaskUnblockTime
 to the maximum possible value so it is extremely
 unlikely that the
 if( xTickCount >= xNextTaskUnblockTime ) test will pass
 next time through. 
 如果没有任务等待，把时间片赋值为最大值，不再调度
 \*/
					xNextTaskUnblockTime = portMAX_DELAY; /\*lint !e961 MISRA exception as the casts are only redundant for some ports. \*/
					break;
				}
				else
				{
					/\* The delayed list is not empty, get the value of the
 item at the head of the delayed list. This is the time
 at which the task at the head of the delayed list must
 be removed from the Blocked state. 
 1、从任务延时列表中，获取第一个任务控制块
 2、延时列表，插入永远是把时间片最短的任务，放在第一个 
 3、获取任务控制块的延时时间
 \*/
					pxTCB = listGET\_OWNER\_OF\_HEAD\_ENTRY( pxDelayedTaskList ); /\*lint !e9079 void \* is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. \*/
					xItemValue = listGET\_LIST\_ITEM\_VALUE( &( pxTCB->xStateListItem ) );
					/\*
 再次判断，这个任务的时间片是否到达
 \*/
					if( xConstTickCount < xItemValue )
					{
						/\* It is not time to unblock this item yet, but the
 item value is the time at which the task at the head
 of the blocked list must be removed from the Blocked
 state - so record the item value in
 xNextTaskUnblockTime. 
 没有到达，把此任务的时间片更新为当前系统的时间片
 \*/
						xNextTaskUnblockTime = xItemValue;
						/\*
 直接退出，不用调度
 \*/
						break; /\*lint !e9011 Code structure here is deedmed easier to understand with multiple breaks. \*/
					}
					else
					{
						mtCOVERAGE\_TEST\_MARKER();
					}

					/\* 
 It is time to remove the item from the Blocked state.
 把任务从延时列表中移除
 \*/
					( void ) uxListRemove( &( pxTCB->xStateListItem ) );

					/\* 
 Is the task waiting on an event also? If so remove
 it from the event list.
 把任务从事件列表中移除
 \*/
					if( listLIST\_ITEM\_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
					{
						( void ) uxListRemove( &( pxTCB->xEventListItem ) );
					}
					else
					{
						mtCOVERAGE\_TEST\_MARKER();
					}

					/\* 
 Place the unblocked task into the appropriate ready
 list. 
 把任务添加到就绪列表中
 \*/
					prvAddTaskToReadyList( pxTCB );

					/\* A task being unblocked cannot cause an immediate
 context switch if preemption is turned off. 
 抢占式处理
 \*/
					#if ( configUSE\_PREEMPTION == 1 )
					{
						/\* Preemption is on, but a context switch should
 only be performed if the unblocked task has a
 priority that is equal to or higher than the
 currently executing task. 
 判断优先级是否大于当前任务
 大于则进行调度
 \*/
						if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
						{
							xSwitchRequired = pdTRUE;
						}
						else
						{
							mtCOVERAGE\_TEST\_MARKER();
						}
					}
					#endif /\* configUSE\_PREEMPTION \*/
				}
			}
		}

		/\* Tasks of equal priority to the currently running task will share
 processing time (time slice) if preemption is on, and the application
 writer has not explicitly turned time slicing off. 
 时间片处理机制
 1、获取就绪列表长度
 2、就绪列表指的是，当前任务优先级的列表
 3、如果有其他任务在就绪列表中，就开始调度
 \*/
		#if ( ( configUSE\_PREEMPTION == 1 ) && ( configUSE\_TIME\_SLICING == 1 ) )
		{	
			if( listCURRENT\_LIST\_LENGTH( &( pxReadyTasksLists[ pxCurrentTCB->uxPriority ] ) ) > ( UBaseType_t ) 1 )
			{
				xSwitchRequired = pdTRUE;
			}
			else
			{
				mtCOVERAGE\_TEST\_MARKER();
			}
		}
		#endif /\* ( ( configUSE\_PREEMPTION == 1 ) && ( configUSE\_TIME\_SLICING == 1 ) ) \*/

		#if ( configUSE\_TICK\_HOOK == 1 )
		{
			/\* Guard against the tick hook being called when the pended tick
 count is being unwound (when the scheduler is being unlocked). \*/
			if( uxPendedTicks == ( UBaseType_t ) 0U )
			{
				vApplicationTickHook();
			}
			else
			{
				mtCOVERAGE\_TEST\_MARKER();
			}
		}
		#endif /\* configUSE\_TICK\_HOOK \*/
	}
	else //内核调度器挂起了
	{
		++uxPendedTicks;//挂起的tick+1

		/\* The tick hook gets called at regular intervals, even if the
 scheduler is locked. \*/
		#if ( configUSE\_TICK\_HOOK == 1 )
		{
			vApplicationTickHook();
		}
		#endif
	}
	/\*
 如果是抢占模式，要开启调度
 \*/
	#if ( configUSE\_PREEMPTION == 1 )
	{
		if( xYieldPending != pdFALSE )
		{
			xSwitchRequired = pdTRUE;
		}
		else
		{
			mtCOVERAGE\_TEST\_MARKER();
		}
	}
	#endif /\* configUSE\_PREEMPTION \*/

	return xSwitchRequired;//返回调度器状态
}

Systick优先级分析

结合后面的中断管理和任务调度相关的内容，需要说明一下Systick优先级的问题。先来看一下简单的任务调度模型。

在这里插入图片描述

在上面图示中，可以看到优先级SysTick优先级最高！那么这和我们常听到的SysTick优先级需要设置为最低优先级怎么相互冲突呢？初学者往往在这个问题上感到困惑。

首先要明白：SysTick是中断，中断优先级和任务优先级没有任何关系，不管中断优先级是多少，中断的优先级永远高于任何线程任务的优先级

那么在上图中的线程，不管什么线程，SysTick中断来了肯定是需要去执行SysTick中断事件的。

上图中还有一个IRQ，比SysTick优先级低，这也是可能的，但是实际上我们应用过程中，一般都把SysTick优先级设置为最低，因为不想让SysTick中断打断用户的IRQ中断。

那么SysTick中断优先级和外设中断优先级是怎么确定的？

1、SysTick属于内核异常，用SHPRx（x=1.2.3）来设置其优先级；外设中断属于 ISR，用NVIC_IPRx来设置优先级。

SPRH1-SPRH3是一个32位的寄存器，只能通过字节访问，每8个字段控制着一个内核外设的中断优先级的配置。位7:4这高四位有效，所以可编程为0 ~ 15。如果软件优先级配置相同，那就根据他们在中断向量表里面的位置编号来决定优先级大小，编号越小，优先级越高。

对于SysTick的配置，系统默认配置为15，(1UL << __NVIC_PRIO_BITS) - 1UL) 在m3、m4中__NVIC_PRIO_BITS为4：

/\*
core\_cm0/3/4.h中关于SysTick\_Config
 m3 m4 中是 4 ，4位就是0~15
 #define \_\_NVIC\_PRIO\_BITS 4U
 m0 中是2， 2位就是 0 ~ 3 
 #endif
 \*/
__STATIC_INLINE uint32\_t SysTick\_Config(uint32\_t ticks)
{
  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
  {
    return (1UL);                                                   /\* Reload value impossible \*/
  }

  SysTick->LOAD  = (uint32\_t)(ticks - 1UL);                         /\* set reload register \*/
  NVIC\_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /\* set Priority for Systick Interrupt \*/
  SysTick->VAL   = 0UL;                                             /\* Load the SysTick Counter Value \*/
  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
                   SysTick_CTRL_TICKINT_Msk   |
                   SysTick_CTRL_ENABLE_Msk;                         /\* Enable SysTick IRQ and SysTick Timer \*/
  return (0UL);                                                     /\* Function successful \*/
}

/\*
NVIC\_SetPriority对中断分了类，分内核中断和外设中断，
内核外设中断枚举值小于0，普通外设>=0。其中，SysTick\_IRQn = -1。
\*/
__STATIC_INLINE void NVIC\_SetPriority(IRQn_Type IRQn, uint32\_t priority)
{
  if ((int32\_t)(IRQn) < 0)
  {
    SCB->SHP[(((uint32\_t)(int32\_t)IRQn) & 0xFUL)-4UL] = (uint8\_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32\_t)0xFFUL);
  }
  else
  {
    NVIC->IP[((uint32\_t)(int32\_t)IRQn)]               = (uint8\_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32\_t)0xFFUL);
  }
}

2、NVIC的中断优先级分组不仅对片上外设有效，同样对内核的外设也有效。

systick的优先级15转换成二进制值就是1111，又因为NVIC的优先级分组2，那么前两位的11就是3，3抢占，后两位的11也是3，3子优先级。这样就可以和外设的优先级进行对比。

如果外设中断的优先级也分成了15，无论怎么分组，SYSTICK优先级高于同优先级的外设（毕竟内核异常优先级高于外设中断，因为中断向量表里面的位置编号内核的靠前更小）。

3、设置systick优先级的方法NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 15); 即SCB->SHP[11] = 0x00;设置最高的话可以得到精准延时，但是会频繁打断用户使用的中断程序，不建议。

内核中断管理

中断是微处理器外部发送的，通过中断通道送入处理器内部，一般是硬件引起的；
而异常通常是微处理器内部发生的，大多是软件引起的，比如除法出错异常，特权调用异常。

Cortex-M的异常类型

如下图：

在这里插入图片描述

Cortex-M的寄存器

如下图：
在这里插入图片描述

这个图主要记住 R13 寄存器，有两个指针：MSP：主栈指针和 PSP：进程栈指针，相关说明如下：

在这里插入图片描述

Cortex-M的特殊寄存器

如下图：

在这里插入图片描述

xPSR

组合程序状态寄存器，该寄存器由三个程序状态寄存器组成

应用PSR（APSR）：包含前一条指令执行后的条件标志
中断PSR（IPSR）：包含当前ISR的异常编号
执行PSR（EPSR）：包含Thumb状态位

在这里插入图片描述

PRIMSK

PRIMSK：中断屏蔽特殊寄存器。

利用PRIMSK，可以禁止除HardFault 和 NMI外的所有异常。

在这里插入图片描述

BASEPRI

利用BASEPRI寄存器来选择屏蔽低于特定优先级的异常或中断。（在上一篇博文中的进入临界区所使用的寄存器就是这个寄存器）

在这里插入图片描述

CONTROL

CONTROL：控制寄存器，部分介绍如下：

在这里插入图片描述

Cortex-M的工作模式

Cortex-M有两种工作模式和两种工作状态：

线程模式（Thread Mode）：芯片复位后，进入线程模式，执行用户程序；

处理模式（Handler Mode）：当处理器发生了异常或者中断，则进入处理模式，处理完后返回线程模式。

Thumb状态：正常运行时处理器的状态

调试状态：调试程序时处理器的状态

在这里插入图片描述

进入Systick后，发生异常，则进入处理模式进行处理：

如果是裸机编程，从哪里进去就返回哪里

但是用了操作系统，该返回哪里呢？

所以这里就有必要单独讲解下MSP和PSP

影子栈指针

在上面的Cortex-M的寄存器图中我们标注过R13寄存器：

堆栈指针SP。

在处理模式下，只能使用主堆栈（MSP）。

在线程模式下，可以使用主堆栈也可以使用进程栈。

由 CONTROL 寄存器控制，如下：

在这里插入图片描述

PendSV和SVC异常

PendSV异常用于任务切换。

为了保证操作系统的实时性，除了使用Systick的时间片调度，还得加入pendSV异常加入抢占式调度。

PendSV（可挂起的系统调用），异常编号为14，可编程。可以写入中断控制和状态寄存器（ICSR）设置挂起位以触发 PendSV异常。它是不精确的。因此，它的挂起状态可以在更高优先级异常处理内设置，且会在高优先级处理完成后执行。

为什么需要 PendSV异常？

如下图所示，如果中断请求在Systick异常前产生，则Systick可能会抢占IRQ处理（图中的IRQ优先级小于Systick）。这样执行上下文切换会导致IRQ延时处理，这种行为在任何一种实时操作系统中都是不能容忍的，在CortexM3中如果OS在活跃时尝试切入线程模式，将触发Fault异常。

在这里插入图片描述

为了解决上面的问题，使用了 PendSV异常。 PendSV异常会自动延迟上下文切换的请求，直到其他的eISR都完成了处理后才放行。为实现这个机制，需要把 PendSV编程为最低优先级的异常。

在FreeRTOS中，每一次进入Systick中断，系统都会检测是否有新的进入就绪态的任务需要运行，如果有，则悬挂PendSV异常，来缓期执行上下文切换。

如下：

在这里插入图片描述

在Systick中会挂起一个PendSV异常用于上下文切换，每产生一个Systick，系统检测到任务链表变化都会触发一个PendSV如下图：

在这里插入图片描述

PendSV业务流程

中断过程中不但要像一般的C函数调用一样保存（R0-R3,R12,LR,PSR），还要保存中断返回地址(return address)。中断的硬件机制会把EXC_RETURN放进LR，在中断返回时触发中断返回。

如下图：

在这里插入图片描述
如何触发PendSV异常

触发PendSV异常，向PendSV中断寄存器写1，触发一次PendSV异常。用户可以主动调用portYIELD函数进行任务切换，portYIELD函数如下：

/\* Scheduler utilities. \*/
#define portYIELD() \
{ \
 /\* Set a PendSV to request a context switch. \*/ \
 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. \*/ \
 \_\_asm volatile( "dsb" ::: "memory" ); \
 \_\_asm volatile( "isb" ); \
}

PendSV源码简析

PendSV中断服务函数

我这里使用的是M0 内核中 FreeRTOS的源码xPortPendSVHandler：

void xPortPendSVHandler( void )
{
	/\* This is a naked function.
 1.产生PendSV中断，硬件自动保存栈帧到任务A的栈中
 2.读取当前任务A的栈指针PSP，手动把一些寄存器压栈到当前任务栈。
 3.把当前任务A栈顶指针保存到任务A的任务控制块中。
 4.找到下一个任务B的任务控制块。（查找下一个优先级最高的就绪任务）
 5.把任务B控制块的栈顶指针指向的数据弹出到寄存器中
 6.更新PSP为任务B的栈顶指针。
 7.跳出PendSV中断。
 8.硬件自动弹出任务B栈中的栈帧。
 \*/
	__asm volatile
	(
	" .syntax unified \n" 
	" mrs r0, psp \n"/\*将psp值放到r0,此时sp得值为msp\*/
	" \n"
	" ldr r3, pxCurrentTCBConst \n" /\* Get the location of the current TCB. 获取当前任务控制块，其实就获取任务栈顶 \*/
	" ldr r2, [r3] \n"/\*将r3寄存器值作为指针取内容存到r2，此时r2保存的为任务控制块首地址\*/
	" \n"
	" subs r0, r0, #32 \n" /\* Make space for the remaining low registers. \*/
	" str r0, [r2] \n" /\* Save the new top of stack. \*/
	" stmia r0!, {r4-r7} \n" /\* Store the low registers that are not saved automatically. \*/
	" mov r4, r8 \n" /\* Store the high registers. \*/
	" mov r5, r9 \n"
	" mov r6, r10 \n"
	" mov r7, r11 \n"
	" stmia r0!, {r4-r7} \n"
	" \n"
	" push {r3, r14} \n"
	" cpsid i \n"
	" bl vTaskSwitchContext \n"/\*执行上线文切换\*/
	" cpsie i \n"
	" pop {r2, r3} \n" /\* lr goes in r3. r2 now holds tcb pointer. \*/
	" \n"
	" ldr r1, [r2] \n"
	" ldr r0, [r1] \n" /\* The first item in pxCurrentTCB is the task top of stack. \*/
	" adds r0, r0, #16 \n" /\* Move to the high registers. \*/
	" ldmia r0!, {r4-r7} \n" /\* Pop the high registers. \*/
	" mov r8, r4 \n"
	" mov r9, r5 \n"
	" mov r10, r6 \n"
	" mov r11, r7 \n"
	" \n"
	" msr psp, r0 \n" /\* Remember the new top of stack for the task.记住新的栈顶指针 \*/
	" \n"
	" subs r0, r0, #32 \n" /\* Go back for the low registers that are not automatically restored. \*/
	" ldmia r0!, {r4-r7} \n" /\* Pop low registers. \*/
	" \n"
	" bx r3 \n"
	" \n"
	" .align 4 \n"
	"pxCurrentTCBConst: .word pxCurrentTCB "
	);
}

PendSV上下文切换函数

xPortPendSVHandler中调用的上下文切换vTaskSwitchContext，其核心任务就是找到当前处于就绪态的最高优先级的任务：

void vTaskSwitchContext( void )
{
	if( uxSchedulerSuspended != ( UBaseType_t ) pdFALSE )
	{
		/\* The scheduler is currently suspended - do not allow a context
 switch. 
 标记调度器状态
 \*/
		xYieldPending = pdTRUE;
	}
	else
	{
		xYieldPending = pdFALSE;
		traceTASK\_SWITCHED\_OUT();

		#if ( configGENERATE\_RUN\_TIME\_STATS == 1 )
		{
		}
		#endif /\* configGENERATE\_RUN\_TIME\_STATS \*/

		/\* 
 Check for stack overflow, if configured. 
 检查任务栈是否溢出
 \*/
		taskCHECK\_FOR\_STACK\_OVERFLOW();

		/\* 
 Select a new task to run using either the generic C or port
 optimised asm code. 
 选择优先级最高的任务，把当前的任务控制块进行赋值
 \*/
		taskSELECT\_HIGHEST\_PRIORITY\_TASK();
		traceTASK\_SWITCHED\_IN();

		#if ( configUSE\_NEWLIB\_REENTRANT == 1 )
		{
		}
		#endif /\* configUSE\_NEWLIB\_REENTRANT \*/
	}
}

寻找最高优先级函数

上下文切换vTaskSwitchContext中调用了taskSELECT_HIGHEST_PRIORITY_TASK()寻找最高优先级的任务：

taskSELECT_HIGHEST_PRIORITY_TASK()的硬件方式：

	/\*-----------------------------------------------------------\*/
	/\*
 这里注释解释
 #define portGET\_HIGHEST\_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32\_t ) ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )

 #define configASSERT( x ) if ((x) == 0) {taskDISABLE\_INTERRUPTS(); for( ;; );} 



![img](https://img-blog.csdnimg.cn/img_convert/812b28afc51bf231260f2ac2b33c479b.png)
![img](https://img-blog.csdnimg.cn/img_convert/a616bb8577a0903f6a1dec15927c723a.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**

**需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**



上下文切换`vTaskSwitchContext`中调用了`taskSELECT_HIGHEST_PRIORITY_TASK()`寻找最高优先级的任务：


`taskSELECT_HIGHEST_PRIORITY_TASK()`的硬件方式：

/\*-----------------------------------------------------------\*/
/\*

这里注释解释
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )

#define configASSERT( x ) if ((x) == 0) {taskDISABLE_INTERRUPTS(); for( ;; );}

[外链图片转存中…(img-AKnCjvpM-1715874374362)]
[外链图片转存中…(img-4rFaZ8LC-1715874374362)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

如果你需要这些资料，可以戳这里获取

2401_85015466

关注

19
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
FreeRTOS记录（三、RTOS任务调度原理解析_Systick、PendSV、SVC）_systick,pendsv 和 svc(2)

在Cortex-M内核上，FreeRTOS使用Systick定时器作为心跳时钟，一般默认心跳时钟为1ms，进入Systick中断后，内核会进入处理模式进行处理，在Systick中断处理中，系统会在 ReadList 就绪链表从高优先级到低优先找需要执行的任务，进行调度，如果有任务的状态发生了变化，改变了状态链表，就会产生一个pendSV异常，进入pendSV异常，通过改变进程栈指针（PSP）切换到不同的任务。
复制链接

扫一扫