FreeRTOS任务切换过程深层解析

吾爱技术圈

已于 2023-05-23 14:17:26 修改

阅读量4.7k

点赞数 13

分类专栏： FreeRTOS 文章标签：嵌入式

于 2022-12-09 17:19:13 首次发布

本文链接：https://blog.csdn.net/weixin_44788542/article/details/128240215

版权

FreeRTOS 专栏收录该内容

4 篇文章 5 订阅

订阅专栏

FreeRTOS 系统的任务切换最终都是在 PendSV 中断服务函数中完成的，uCOS 也是在 PendSV 中断中完成任务切换的。

为什么用PendSV异常来做任务切换

PendSV 可以像普通中断一样被 Pending（往 NVIC 的 PendSV 的 Pend 寄存器写 1），常用的场合是 OS 进行上下文切换；它可以手动拉起后，等到比他优先级更高的中断完成后，再执行；

假设，带 OS 系统的 CM3 中有两个就绪的任务，上下文切换可以发生在 SYSTICK 中断中：
在这里插入图片描述
这里展现的是两个任务 A 和 B 轮转调度的过程；但是，如果在产生 SYSTICK 异常时，系统正在响应一个中断，则 SYSTICK 异常会抢占其他 ISR。在这种情况下 OS 是不能执行上下文切换的，否则将使得中断请求被延迟；

而且，如果在 SYSTICK 中做任务切换，那么就会尝试切入线程模式，将导致用法 fault 异常；因为正常来说，即使SYSTICK优先级比IRQ高，当SYSTICK执行完后，也应该是回到低优先级的中断处理函数IRQ里而不是直接切换到任务去运行了，这时候IRQ都没运行完呢，怎么能中断函数都没处理完就去运行主程序呢？自然是不允许这样的。
在这里插入图片描述
为了解决这种问题，早期的 OS 在上下文切换的时候，检查是否有中断需要响应，没有的话，采取切换上下文，然而这种方法的问题在于，可能会将任务切换的动作拖延很久（如果此次的 SYSTICK 无法切换上下文，那么要等到下一次 SYSTICK 再来切换），严重的情况下，如果某 IRQ 来的频率和 SYSTICK 来的频率比较接近的时候，会导致上下文切换迟迟得不到进行；
引入 PendSV 以后，可以将 PendSV 的异常优先级设置为最低，在 PendSV 中去切换上下文，PendSV 会在其他 ISR 得到相应后，立马执行：
在这里插入图片描述
上图的过程可以描述为：

1、任务 A 呼叫 SVC 请求任务切换；

2、OS 收到请求，准备切换上下文，手动 Pending 一个 PendSV；

3、CPU 退出 SVC 的 ISR 后，发现没有其他 IRQ 请求，便立即进入 PendSV 执行上下文切换；

4、正确的切换到任务 B；

5、此刻发生了一个中断，开始执行此中断的 ISR；

6、ISR 执行一半，SYSTICK 来了，抢占了该 IRQ；

7、OS 执行一些逻辑，并手动 Pending PendSV 准备上下文切换；

8、退出 SYSTICK 的 ISR 后，由于之前的 IRQ 优先级高于 PendSV，所以之前的 ISR 继续执行；

9、ISR 执行完毕退出，此刻没有优先级更高的 IRQ，那么执行 PendSV 进行上下文切换；

10、PendSV 执行完毕，顺利切到任务 A，同时进入线程模式；

以上部分摘自：https://www.cnblogs.com/god-of-death/p/14856578.html

如何设定PendSV优先级

在这里插入图片描述
往地址为0xE000ED22的寄存器PRI_14写入PendSV优先级

NVIC_SYSPRI14   EQU     0xE000ED22
NVIC_PENDSV_PRI EQU           0xFF
    
    LDR     R1, =NVIC_PENDSV_PRI    
    LDR     R0, =NVIC_SYSPRI14    
    STRB    R1, [R0]  ;将r1 中的 [7:0]存储到 r0 对应的内存
    BX      LR   ;返回

如何触发PendSV异常

在这里插入图片描述
往ICSR第28位写1，即可将PendSV异常挂起。若是当前没有高优先级中断产生，那么程序将会进入PendSV handler

NVIC_INT_CTRL   EQU     0xE000ED04                              
NVIC_PENDSVSET  EQU     0x10000000                              

    LDR     R0, =NVIC_INT_CTRL                                 
    LDR     R1, =NVIC_PENDSVSET
    STR     R1, [R0]
    BX      LR

测试PendSV异常handler实现任务切换

如何实现任务切换？三个步骤：

步骤一：在进入中断前先设置PSP。

步骤二：将当前寄存器的内容保存到当前任务堆栈中。进入ISR时，cortex-m3会自动保存八个寄存器到PSP中，剩下的几个需要我们手动保存。

步骤三：在Handler中将下一个任务的堆栈中的内容加载到寄存器中，并将PSP指向下一个任务的堆栈。这样就完成了任务切换。

要在PendSV 的ISR中完成这两个步骤，我们先需了解下在进入PendSV ISR时，cortex-M3做了什么？

1，入栈。会有8个寄存器自动入栈。入栈内容及顺序如下：
在这里插入图片描述
在步骤一中，我们已经设置了PSP，那这8个寄存器就会自动入栈到PSP所指地址处。

2，取向量。找到PendSV ISR的入口地址，这样就能跳到ISR了。

3，更新寄存器内容。

做完这三步后，程序就进入ISR了。

进入ISR前，我们已经完成了步骤一，cortex-M3已经帮我们完成了步骤二的一部分，剩下的需要我们手动完成。

在ISR中添加代码如下：

MRS R0, PSP

保存PSP到R0。为什么是PSP而不是MSP。因为在OS启动的时候，我们已经把SP设置为PSP了。这样使得用户程序使用任务堆栈，OS使用主堆栈，不会互相干扰。不会因为用户程序导致OS崩溃。

STMDB R0!,{R4-R11}

保存R4-R11到PSP中。C语言表达是*(–R0)={R4-R11}，R0中值先自减1，然后将R4-R11的值保存到该值所指向的地址中，即PSP中。

STMDB Rd!，{寄存器列表} 连续存储多个字到Rd中的地址值所指地址处。每次存储前，Rd先自减一次。

若是ISR是从从task0进来，那么此时task0的堆栈中已经保存了该任务的寄存器参数。保存完成后，当前任务堆栈中的内容如下(假设是task0)
在这里插入图片描述
左边表格是预期值，右边是keil调试的实际值。可以看出，是一致的。在任务初始化时(步骤一)，我们将PSP指向任务0的栈顶0x20000080。在进入PendSV之前，cortex-M3自动入栈八个值，此时PSP指向了0x20000060。然后我们再保存R4-R11到0x20000040~0x2000005C。

这样很容易看明白，如果需要下次再切换到task0，只需恢复R4~R11，再将PSP指向0x20000060即可。

测试例程：

#define HW32_REG(ADDRESS)  (*((volatile unsigned long  *)(ADDRESS)))
void USART1_Init(void);
void task0(void) ; 

uint32_t  curr_task=0;     // 当前执行任务
uint32_t  next_task=1;     // 下一个任务
uint32_t task0_stack[17];
uint32_t task1_stack[17];
uint32_t  PSP_array[4];

u8 task0_handle=1;
u8 task1_handle=1;

void task0(void) 
{ 
    while(1)
    {
        if(task0_handle==1)
        {
            printf("task0\n");
            task0_handle=0;
            task1_handle=1;
        }
    }
}

void task1(void)
{
    while(1)
    {
        if(task1_handle==1)
        {
            printf("task1\n");
            task1_handle=0;
            task0_handle=1;
        }
    }
}

__asm void SetPendSVPro(void)
{
NVIC_SYSPRI14   EQU     0xE000ED22
NVIC_PENDSV_PRI EQU           0xFF
    
    LDR     R1, =NVIC_PENDSV_PRI    
    LDR     R0, =NVIC_SYSPRI14    
    STRB    R1, [R0]
    BX      LR
}

__asm void TriggerPendSV(void)
{
NVIC_INT_CTRL   EQU     0xE000ED04                              
NVIC_PENDSVSET  EQU     0x10000000                              

    LDR     R0, =NVIC_INT_CTRL                                 
    LDR     R1, =NVIC_PENDSVSET
    STR     R1, [R0]
    BX      LR
}

int main(void)
{
    SetPendSVPro();
    LED_Init();
    uart_init(115200);
    
    printf("OS test\n");
    
    PSP_array[0] = ((unsigned int) task0_stack) + (sizeof task0_stack) - 16*4;
    //PSP_array中存储的为task0_stack数组的尾地址-16*4, 即task0_stack[1]的地址
    HW32_REG((PSP_array[0] + (14*4))) = (unsigned long) task0; /* PC */
    //task0的PC存储在task0_stack[1]地址+14*4, 即task0_stack[15]的地址中
    HW32_REG((PSP_array[0] + (15*4))) = 0x01000000;            /* xPSR */
  
    PSP_array[1] = ((unsigned int) task1_stack) + (sizeof task1_stack) - 16*4;
    HW32_REG((PSP_array[1] + (14*4))) = (unsigned long) task1; /* PC */
    HW32_REG((PSP_array[1] + (15*4))) = 0x01000000;            /* xPSR */    
    
    /* 任务0先执行 */
    curr_task = 0; 
     
    /* 设置PSP指向任务0堆栈的栈顶 */
    __set_PSP((PSP_array[curr_task] + 16*4)); 
    
    SysTick_Config(9000000);
    SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);//72/8=9MHZ     
    /* 使用堆栈指针，非特权级状态 */
    __set_CONTROL(0x3);
    
    /* 改变CONTROL后执行ISB (architectural recommendation) */
    __ISB();
    
    /* 启动任务0 */
    task0();  
    //LED0=0;
    while(1);
}

__asm void PendSV_Handler(void)
{ 
    // 保存当前任务的寄存器内容
    MRS    R0, PSP     // 得到PSP  R0 = PSP
                       // xPSR, PC, LR, R12, R0-R3已自动保存
    STMDB  R0!,{R4-R11}// 保存R4-R11共8个寄存器得到当前任务堆栈
    
    // 加载下一个任务的内容
    LDR    R1,=__cpp(&curr_task)
    LDR    R3,=__cpp(&PSP_array)
    LDR    R4,=__cpp(&next_task)
    LDR    R4,[R4]     // 得到下一个任务的ID
    STR    R4,[R1]     // 设置 curr_task = next_task
    LDR    R0,[R3, R4, LSL #2] // 从PSP_array中获取PSP的值
    LDMIA  R0!,{R4-R11}// 将任务堆栈中的数值加载到R4-R11中
  //ADDS   R0, R0, #0x20
    MSR    PSP, R0     // 设置PSP指向此任务
 // ORR     LR, LR, #0x04   
    BX     LR          // 返回
                       // xPSR, PC, LR, R12, R0-R3会自动的恢复
    ALIGN  4
}

void SysTick_Handler(void)
{
    LED0=!LED0;//位带操作
    if(curr_task==0)
        next_task=1;
    else
        next_task=0;
    TriggerPendSV();
}

串口输出：
在这里插入图片描述
可以看到在任务0和任务1之间来回切换。

FreeRTOS任务切换源码分析

上下文(任务)切换被触发的场合大致分为：
● 可以执行一个系统调用
● 系统滴答定时器(SysTick)中断。

执行系统调用就是执行 FreeRTOS 系统提供的相关 API 函数，比如任务切换函数taskYIELD()，这些 API 函数和任务切换函数
taskYIELD()都统称为系统调用。

函数 taskYIELD()其实就是个宏，在文件 task.h 中有如下定义：
#define taskYIELD() portYIELD()

函数 portYIELD()也是个宏，在文件 portmacro.h 中有如下定义

#define portYIELD()  \
{  \
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; \   //通过向中断控制和壮态寄存器 ICSR 的 bit28 写入 1 挂起 PendSV 来启动 PendSV 中断。这样就可以在 PendSV 中断服务函数中进行任务切换了。
\
__dsb( portSY_FULL_READ_WRITE );  \
__isb( portSY_FULL_READ_WRITE );  \
}

中断级的任务切换函数为 portYIELD_FROM_ISR()，定义如下：

#define portYIELD_FROM_ISR( x ) portEND_SWITCHING_ISR( x )

#define portEND_SWITCHING_ISR( xSwitchRequired ) \
	if( xSwitchRequired != pdFALSE ) portYIELD()   //可以看出 portYIELD_FROM_ISR()最终也是通过调用函数 portYIELD()来完成任务切换的。

系统滴答定时器(SysTick)中断

void SysTick_Handler(void)
{
	if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
	{
		xPortSysTickHandler();
	}
}

xPortSysTickHandler()源码如下：

void xPortSysTickHandler( void )
{
	vPortRaiseBASEPRI(); //关闭中断
	{
		if( xTaskIncrementTick() != pdFALSE )  //增加时钟计数器 xTickCount 的值
		{
			portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; //通过向中断控制和壮态寄存器 ICSR 的 bit28 写入 1 挂起 PendSV 来启动 PendSV 中断。这样就可以在 PendSV 中断服务函数中进行任务切换了。
		}
	}
	vPortClearBASEPRIFromISR(); //打开中断
}

真正的任务切换代码在PendSV中断函数中，
FreeRTOS做了如下函数重定义
#define xPortPendSVHandler PendSV_Handler

xPortPendSVHandler函数如下 (汇编 port.c)

__asm void xPortPendSVHandler( void )
{
	extern uxCriticalNesting;
	extern pxCurrentTCB;
	extern vTaskSwitchContext;
	
	PRESERVE8
	
	mrs r0, psp  //读取进程栈指针，保存在寄存器 R0 里面。
	isb
	
	ldr r3, =pxCurrentTCB //获取当前任务的任务控制块
	ldr r2, [r3]  //接上，并将任务控制块的地址保存在寄存器 R2 里面
	
	tst r14, #0x10 //判断任务是否使用了 FPU，如果任务使用了 FPU 的话在进行任务切换的时候就
	it eq          //需要将 FPU 寄存器 s16~s31 手动保存到任务堆栈中，其中 s0~s15 和 FPSCR 是自动保存的
	
	vstmdbeq r0!, {s16-s31} //保存 s16~s31 这 16 个 FPU 寄存器
	stmdb r0!, {r4-r11, r14} //保存 r4~r11 和 R14 这几个寄存器的值
	str r0, [r2]  //将寄存器 R0 的值写入到寄存器 R2 所保存的地址中去，也就是将新的栈顶保存在任务控制块的第一个字段中。
	stmdb sp!, {r3} //将寄存器 R3 的值临时压栈，寄存器 R3 中保存了当前任务的任务控制块
	mov r0, #configMAX_SYSCALL_INTERRUPT_PRIORITY //关闭中断，进入临界区
	msr basepri, r0  							  //关闭中断，进入临界区
	dsb
	isb
	bl vTaskSwitchContext //调用函数 vTaskSwitchContext()，此函数用来获取下一个要运行的任务，并将pxCurrentTCB 更新为这个要运行的任务
	mov r0, #0  //打开中断，退出临界区。
	msr basepri, r0  //打开中断，退出临界区。
	ldmia sp!, {r3} //刚刚保存的寄存器 R3 的值出栈，恢复寄存器 R3 的值
	ldr r1, [r3]  //获取新的要运行的任务的任务堆栈栈顶,
	ldr r0, [r1]  //接上，并将栈顶保存在寄存器 R0 中
	ldmia r0!, {r4-r11, r14} //R4~R11,R14 出栈，也就是即将运行的任务的现场
	tst r14, #0x10 //判断即将运行的任务是否有使用到 FPU，如果有的话还需要手工恢复 FPU的 s16~s31 寄存器。
	it eq          //同上
	vldmiaeq r0!, {s16-s31} //同上
	msr psp, r0 //更新进程栈指针 PSP 的值
	isb
	bx r14  //执行此行代码以后硬件自动恢复寄存器 R0~R3、R12、LR、PC 和 xPSR 的值，确定
			//异常返回以后应该进入处理器模式还是进程模式，使用主栈指针(MSP)还是进程栈指针(PSP)。
			//很明显这里会进入进程模式，并且使用进程栈指针(PSP)，寄存器 PC 值会被恢复为即将运行的
			//任务的任务函数，新的任务开始运行！至此，任务切换成功。
}

补充：

SysTick和PendSV的优先级实际到底是多少

https://zhuge.blog.csdn.net/article/details/124830031

在FreeRTOS中，
一般来说，我们在main函数最后，是开启调度器：vTaskStartScheduler()
然后这个函数中调用了xPortStartScheduler()，这才是真正做开启调度器相关操作，在port.c中
xPortStartScheduler()中对pendsv和SysTick的优先级进行了设置。
在这里插入图片描述
portNVIC_SYSPRI2_REG是内核的寄存器，高16位的两个字节分别是PendSV和SysTick的优先级设置

#define portNVIC_SYSPRI2_REG				( * ( ( volatile uint32_t * ) 0xe000ed20 ) )

在这里插入图片描述
然后portNVIC_PENDSV_PRI 和 portNVIC_SYSTICK_PRI 分别的定义：
#define portNVIC_PENDSV_PRI ( ( ( uint32_t ) configKERNEL_INTERRUPT_PRIORITY ) << 16UL )
#define portNVIC_SYSTICK_PRI ( ( ( uint32_t ) configKERNEL_INTERRUPT_PRIORITY ) << 24UL )

那么关键看configKERNEL_INTERRUPT_PRIORITY这个宏定义：
#ifndef configKERNEL_INTERRUPT_PRIORITY
#define configKERNEL_INTERRUPT_PRIORITY 255
#endif
如果用户没有定义默认是255，其实是最低优先级，但这不实际，因为255是内核设计的最低优先级，但实际芯片没有给做那么多优先级

所以在FreeRTOSConfig.h文件中定义了：

#ifdef __NVIC_PRIO_BITS
	#define configPRIO_BITS       		__NVIC_PRIO_BITS
#else
	#define configPRIO_BITS       		4                  
#endif

#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY			15                      //中断最低优先级
#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY	5                       //系统可管理的最高中断优先级
#define configKERNEL_INTERRUPT_PRIORITY 		( configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
#define configMAX_SYSCALL_INTERRUPT_PRIORITY 	( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )

左移(8 - configPRIO_BITS)是因为只用了高4bit做优先级，这样看下来，实际PendSV和SysTick的优先级都设置成了15，而FreeRTOS要求用第四组优先级分组，所以15就是最低优先级。

以下对SysTick和PendSV的优先级设为最低的释疑：
【既然SysTick优先级最低，根本不会触发第一节说的SysTick抢别的低优先级IRQ在SysTick中断直接切任务导致IRQ没处理完就切回任务的用法fault，那还用PendSV有什么意义，直接在SysTick切换任务不就行？】

单从切任务这个事情来说，如果SysTick为最低优先级，确实可以在SysTick中直接切任务。但是OS并不止SysTick这一种情况需要切换任务，还在其他情况也要突然切任务。那如果把切任务这个事情只放在SysTick，那岂不是在临时要切任务时还得直接触发SysTick的中断，显然是不行的，SysTick作为按时按点中断的心跳，肯定不能随时进。所以单独把切任务的事情放在PendSV中，这样如果遇到临时要切任务的情况。只触发PendSV就行。SysTick依然不会乱（SysTick里有计数，必须定时进中断才能保证计数符合时间）

【PendSV用最低优先级这没什么说的，这关乎fault问题，第一节已经明确了，但是SysTick优先级如果最低，那么如果有频繁的高优先级IRQ中断怎么保证SysTick的节拍准时呢】
答：无解
操作系统的心跳节拍本质上讲，就是一个保证操作系统正常运行的节拍而已，就像人的心跳一样，有的人60次/分，有的人70次/分，有的人80次/分，没有唯一答案，你肯定也不会想着要让自己的心跳整齐划一的一直是66次/分。有个大概正常稳定的范围就可以了。嵌入式OS的时钟节拍，压根就不是精准的，也不需要太准，大概准就可以了，因为只要有周期性的节拍，就能保证周期性的调度。软件定时器也不是特别准的，一般用于【短时间】、对时间要求不严苛的场景。如果非要对时间要求的特别准，还是需要用硬件定时器实现的。

【针对上个问题，如果把SysTick优先级提高行吗？】
先看SysTick和PendSV的优先级都设为最低优先级的情况：
在这里插入图片描述
然后看Systick高优先级，PendSV低优先级的情况：

在这里插入图片描述因为SysTick的优先级最高，而且又是周期性的触发，会导致经常抢占外部IRQ，这就会导致外部IRQ响应变慢，这在一些对实时性要求高的，比如按键、断电中断等待，是不能接受的，你肯定不希望你的按键扫描体验卡顿。
所以，没有十全十美的解决方案，关键是要看我们更关注什么？对于CPU来说，嵌入式OS也是一个程序，跟普通的裸机程序是一样的，无非就是复杂一些，涉及到了手动切换堆栈、PC等高级操作而已，OS的优先级天生就没有外部中断的优先级高。

上述释疑观点部分参考【猪哥-嵌入式】：https://zhuge.blog.csdn.net/article/details/124789418
https://zhuge.blog.csdn.net/article/details/124830031

参考：
https://www.cnblogs.com/WeyneChen/p/4891885.html

https://www.cnblogs.com/god-of-death/p/14856578.html

吾爱技术圈

关注

13
点赞
踩
51

收藏

觉得还不错? 一键收藏
打赏
2
评论
FreeRTOS任务切换过程深层解析

为了解决这种问题，早期的 OS 在上下文切换的时候，检查是否有中断需要响应，没有的话，采取切换上下文，然而这种方法的问题在于，可能会将任务切换的动作拖延很久（如果此次的 SYSTICK 无法切换上下文，那么要等到下一次 SYSTICK 再来切换），严重的情况下，如果某 IRQ 来的频率和 SYSTICK 来的频率比较接近的时候，会导致上下文切换迟迟得不到进行；可以看出，是一致的。C语言表达是*(–R0)={R4-R11}，R0中值先自减1，然后将R4-R11的值保存到该值所指向的地址中，即PSP中。
复制链接

扫一扫