基于STM32的简易RTOS

之前看过一篇卢晓铭写的简易RTOS设计,自己也实践了一下,感觉多任务运行起来毫无压力,在此做份笔记以备他日之需也为他人提供一份参考

要想完成一个RTOS,我们核心任务是需要编写任务调度。

所以,我们需要知道,任务到底什么地方会被调度。

1.        我们开始OSStart();时,肯定需要调度一次任务。这样才能进入第一个最高优先级就绪任务中。

2.        在任务中的OSTimeDly();延时函数中,我们需要进行任务调度。当前任务延时了,肯定就要换一个别的任务来运行呀。

3.        在中断退出时,需要进行任务调度(该处主要指定时器中断),可以理解为每个时钟周期都在进行任务最高优先级别的检验。

 

任务状态的标志,我想我们可以用1bit来代表,0:代表任务挂起或不存在,1:代表任务就绪。

U32 OSRdyTbl;        这是一个32bit的任务就绪表,每一位代表任务的状态.

/*在就绪表中登记任务*/

__inline void OSSetPrioRdy(u8 prio)                                      //__inline是内联函数,用在该处是为了提高效率。关于内联函数的详情和使用,可以百度。

{

        OSRdyTbl|= 1 << prio;

}

 

/*在就绪表中删除任务*/

__inline void OSDelPrioRdy(u8 prio)

{

        OSRdyTbl&= ~(1<<prio);

}

 

在每个任务调度前,肯定需要知道当前最高优先级的就绪任务是什么,所以我们需要一个查找函数

/*在就绪表中查找更高级的就绪任务*/

__inline void OSGetHighRdy(void)

{

        u8OSNextTaskPrio = 0;                           /*任务优先级*/

 

        for(OSNextTaskPrio = 0; (OSNextTaskPrio < OS_TASKS) &&(!(OSRdyTbl&(0x01<<OSNextTaskPrio))); OSNextTaskPrio++ );  //注意for最后有个分号

        OSPrioHighRdy= OSNextTaskPrio;        //获得最高优先级,OSPrioHighRdy是一个全局变量

}

 

根据分析,我们知道我们的简易RTOS有3个地方会出现任务调度

首先是任务刚开始时.

我们先定义几个全局变量:

1.        OSRunning指示OS是否开始运行

2.        OSPrioCur指示当前任务优先级

3.        OSPrioHighRdy指示当前已就绪的最高优先级任务,由OSGetHighRdy函数更新

void OSStart(void)

{

        if(OSRunning== 0)                     //OSRuning是一个全局变量

        {

                      OSRunning= 1;

                     

        //先不忙讲任务创建 OSTaskCreate(IdleTask, (void *)0,(u32 *)&IDELTASK_STK[31], IdelTask_Prio);             //创建空闲任

 

                      OSGetHighRdy();                                       /*获得最高级的就绪任务*/

                      OSPrioCur= OSPrioHighRdy;                  /*获得最高优先级就绪任务ID*/

                      p_OSTCBCur= &TCB[OSPrioCur];

                      p_OSTCBHighRdy= &TCB[OSPrioHighRdy];

                      OSStartHighRdy();                       //在汇编语句中

        }

}

其次出现任务调度的地方是延时函数OSTimeDly()

在这个函数前,要先介绍一个结构体TCB,这是任务控制怪(Task Control Block)

每一个任务都有一个任务控制块,这个控制块记录着任务的重要信息,由于该处是简易OS设计,所以仅仅有两种

typedef struct TaskCtrBlockHead                 /*任务控制块数据结构*/

{

        u32OSTCBStkPtr;                                                    /*保存任务栈顶地址*/

        u32OSTCBDly;                                                                       /*任务延时时钟*/

}TaskCtrBlock;

#define OS_TASKS 32                                                    //最多任务数

TaskCtrBlock TCB[OS_TASKS];                                       //定义任务TCB,由于最多有32个任务,所以该处定义32个TCB

 

 

void OSTimeDly(u32 ticks)

{

        if(ticks> 0)

        {

                      OS_ENTER_CRITICAL();                                                         //进入临界区

                      OSDelPrioRdy(OSPrioCur);                                   //将任务挂起

                      TCB[OSPrioCur].OSTCBDly= ticks;                      //设置TCB中任务延时节拍数

                      OS_EXIT_CRITICAL();                                               //退出临界区

                      OSSched();                                                                //任务调度

        }

}

/*任务切换*/

void OSSched(void)

{

        OSGetHighRdy();                                                                   //找出任务就绪表中优先级最高的任务

        if(OSPrioHighRdy!=OSPrioCur)              //如果不是当前运行任务,进行任务调度

        {

                      p_OSTCBCur= &TCB[OSPrioCur];                       //以便在汇编中引用,可以理解为用于将现在的任务环境保存在该指针指向的堆栈中

//直接把当前任务的堆栈指针保存到当前任务的TCB(TCB的OSTCBStkPtr)

                      p_OSTCBHighRdy= &TCB[OSPrioHighRdy];     //以便在汇编中引用,可以理解为用于将该指针中的数据释放出来,恢复指定任务环境

//直接把最高优先级就绪任务的TCB(TCB的OSTCBStkPtr)设为当前任务的堆栈指针

                      OSPrioCur= OSPrioHighRdy;                                //更新OSPrio

                      OSCtxSw();                                                                //调度任务,在汇编中引用

        }

}

 

最后是在时钟中断中出现

由于每次时钟中断我们都需要解决任务时钟延时问题,所以我们需要一个函数

/*定时器中断对任务延时处理函数*/

void TicksInterrupt(void)

{

        static u8i;

 

        OSTime++;

        for(i=0;i<OS_TASKS;i++)                                       

        {

                      if(TCB[i].OSTCBDly)

                      {

                                    TCB[i].OSTCBDly--;

                                    if(TCB[i].OSTCBDly==0)             //延时时钟到达

                                    {

                                                  OSSetPrioRdy(i);            //任务重新就绪

                                    }            

                      }

        }

}

 

//系统时钟中断服务函数

void SysTick_Handler(void)

{

        OS_ENTER_CRITICAL();                             //进入临界区

   OSIntNesting++;                         //任务前套数

   OS_EXIT_CRITICAL();                  //退出临界区

   TicksInterrupt();                          //

    OSIntExit();                                   //在中断中处理任务调度

}

void OSIntExit(void)

{

        OS_ENTER_CRITICAL();                             //进入临界区

       

        if(OSIntNesting> 0)

        OSIntNesting--;

        if(OSIntNesting== 0)                               //没有中断嵌套时,才可以进行任务调度

        {

                      OSGetHighRdy();                                                                   /*找出任务优先级最高的就绪任务*/

                      if(OSPrioHighRdy!=OSPrioCur)              /*当前任务并非优先级最高的就绪任务*/

                      {

                                    p_OSTCBCur= &TCB[OSPrioCur];

                                    p_OSTCBHighRdy= &TCB[OSPrioHighRdy];

                                    OSPrioCur= OSPrioHighRdy;

                                    OSIntCtxSw();                                             /*中断级任务调度,注意这里和OSCtxSw不一样,但是作用是一样的*/

                      }

        }

OS_EXIT_CRITICAL();                   //退出临界区

}

 

现在任务调度已经写完了,那么应该要创建任务了吧,这里使用创建任务函数

/*任务创建*/

void OSTaskCreate(void (*Task)(void  *parg), void *parg,u32 *p_Stack, u8 TaskID)

{

        if(TaskID<= OS_TASKS)

        {

            *(p_Stack) = (u32)0x01000000L;                                                        /*  xPSR                        */

            *(--p_Stack) = (u32)Task;                                                          /*  Entry Point of the task  任务入口地址   */

            *(--p_Stack) = (u32)0xFFFFFFFEL;                                                         /*  R14 (LR) (init value will  */

                                                                                   

            *(--p_Stack) = (u32)0x12121212L;                                                     /*  R12                         */

            *(--p_Stack) = (u32)0x03030303L;                                                     /*  R3                          */

            *(--p_Stack) = (u32)0x02020202L;                                                     /*  R2                          */

            *(--p_Stack) = (u32)0x01010101L;                                                     /*  R1                          */

            *(--p_Stack) = (u32)parg;                                                         /*  R0 : argument 输入参数    */

 

            *(--p_Stack) = (u32)0x11111111L;                                                     /*  R11                         */

            *(--p_Stack) = (u32)0x10101010L;                                                     /*  R10                         */

            *(--p_Stack) = (u32)0x09090909L;                                                     /*  R9                          */

            *(--p_Stack) = (u32)0x08080808L;                                                     /*  R8                          */

            *(--p_Stack) = (u32)0x07070707L;                                                     /*  R7                          */

            *(--p_Stack) = (u32)0x06060606L;                                                     /*  R6                          */

            *(--p_Stack) = (u32)0x05050505L;                                                     /*  R5                          */

            *(--p_Stack) = (u32)0x04040404L;                                                     /*  R4                         */

 

                      TCB[TaskID].OSTCBStkPtr= (u32)p_Stack;                                    /*保存堆栈地址*/

                      TCB[TaskID].OSTCBDly= 0;                                                                              /*初始化任务延时*/

                      OSSetPrioRdy(TaskID);                                                                                     /*在任务就绪表中登记*/

        }

}

这里主要是入栈寄存器地址

 

为了保证系统的正常运行,我们需要一个空闲任务,空闲任务可以什么事情都不做,也可以随便做点什么简单的事。

/*系统空闲任务*/

void IdleTask(void *pdata)

{

        u32IdleCount = 0;

        while(1)

        {

                      IdleCount++;

        }

}

 

既然如此,那么系统开始前应该申请一个空闲任务,所以OSStart()函数改为

void OSStart(void)

{

        if(OSRunning== 0)

        {

                      OSRunning= 1;

                     

                      OSTaskCreate(IdleTask,(void *)0, (u32 *)&IDELTASK_STK[31], IdelTask_Prio);             //创建空闲任务

 

                      OSGetHighRdy();                                                                   /*获得最高级的就绪任务*/

                      OSPrioCur= OSPrioHighRdy;                  /*获得最高优先级就绪任务ID*/

                      p_OSTCBCur= &TCB[OSPrioCur];

                      p_OSTCBHighRdy= &TCB[OSPrioHighRdy];

                      OSStartHighRdy();

        }

}

 

以上就是任务调度器的核心.

至于汇编代码,可以直接参考ucosii在STM32上的汇编代码。

 

文件RTOS.c

/*********************** (C) COPYRIGHT 2013 Libraworks *************************
* File Name	    : RTOS.c
* Author		: 卢晓铭 
* Version		: V1.0
* Date			: 01/26/2013
* Description	: LXM-RTOS 任务管理
*******************************************************************************/

#include"RTOS.h"

TaskCtrBlock TCB[OS_TASKS - 1];	/*任务控制块定义*/
TaskCtrBlock *p_OSTCBCur;		/*指向当前任务控制块的指针*/
TaskCtrBlock *p_OSTCBHighRdy;	/*指向最高优先级就绪任务控制块的指针*/
u8 OSPrioCur;					/*当前执行任务*/
u8 OSPrioHighRdy;				/*最高优先级*/
u8 OSRunning;					/*多任务运行标志0:为运行,1:运行*/

u32 OSInterruptSum;				/*进入中断次数*/

u32 OSTime;						/*系统时间(进入时钟中断次数)*/

u32 OSRdyTbl;					/*任务就绪表,0表示挂起,1表示就绪*/

u32 OSIntNesting;				/*任务嵌套数*/

/*在就绪表中登记任务*/
void OSSetPrioRdy(u8 prio)
{
	OSRdyTbl |= 1 << prio;
}

/*在就绪表中删除任务*/
void OSDelPrioRdy(u8 prio)
{
	OSRdyTbl &= ~(1<<prio);
}

/*在就绪表中查找更高级的就绪任务*/
void OSGetHighRdy(void)
{
	u8 OSNextTaskPrio = 0;		/*任务优先级*/

	for (OSNextTaskPrio = 0; (OSNextTaskPrio < OS_TASKS) && (!(OSRdyTbl&(0x01<<OSNextTaskPrio))); OSNextTaskPrio++ );
	OSPrioHighRdy = OSNextTaskPrio;	
}

/*设置任务延时时间*/
void OSTimeDly(u32 ticks)
{
	if(ticks > 0)
	{
		OS_ENTER_CRITICAL();				//进入临界区
		OSDelPrioRdy(OSPrioCur);			//将任务挂起
		TCB[OSPrioCur].OSTCBDly = ticks;	//设置TCB中任务延时节拍数
		OS_EXIT_CRITICAL();					//退出临界区
		OSSched();
	}
}

/*定时器中断对任务延时处理函数*/
void TicksInterrupt(void)
{
	static u8 i;

	OSTime++;
	for(i=0;i<OS_TASKS;i++)
	{
		if(TCB[i].OSTCBDly)
		{
			TCB[i].OSTCBDly--;
			if(TCB[i].OSTCBDly==0)	//延时时钟到达
			{
				OSSetPrioRdy(i);	//任务重新就绪
			}	
		}
	}
}

/*任务切换*/
void OSSched(void)
{
	OSGetHighRdy();					//找出任务就绪表中优先级最高的任务
	if(OSPrioHighRdy!=OSPrioCur)	//如果不是当前运行任务,进行任务调度
	{
		p_OSTCBCur = &TCB[OSPrioCur];				//汇编中引用			
		p_OSTCBHighRdy = &TCB[OSPrioHighRdy];		//汇编中引用
		OSPrioCur = OSPrioHighRdy;	//更新OSPrio
		OSCtxSw();					//调度任务
	}
}
/*任务创建*/
void OSTaskCreate(void  (*Task)(void  *parg), void *parg, u32 *p_Stack, u8 TaskID)
{
	if(TaskID <= OS_TASKS)
	{
		*(p_Stack) = (u32)0x01000000L;					/*  xPSR                        */ 
	    *(--p_Stack) = (u32)Task;						/*  Entry Point of the task  任务入口地址   */
	    *(--p_Stack) = (u32)0xFFFFFFFEL;				/*  R14 (LR)  (init value will  */
	                                                                           
	    *(--p_Stack) = (u32)0x12121212L;				/*  R12                         */
	    *(--p_Stack) = (u32)0x03030303L;				/*  R3                          */
	    *(--p_Stack) = (u32)0x02020202L;				/*  R2                          */
	    *(--p_Stack) = (u32)0x01010101L;				/*  R1                          */
		*(--p_Stack) = (u32)parg;						/*  R0 : argument  输入参数     */

		*(--p_Stack) = (u32)0x11111111L;				/*  R11                         */
	    *(--p_Stack) = (u32)0x10101010L;				/*  R10                         */
	    *(--p_Stack) = (u32)0x09090909L;				/*  R9                          */
	    *(--p_Stack) = (u32)0x08080808L;				/*  R8                          */
	    *(--p_Stack) = (u32)0x07070707L;				/*  R7                          */
	    *(--p_Stack) = (u32)0x06060606L;				/*  R6                          */
	    *(--p_Stack) = (u32)0x05050505L;				/*  R5                          */
	    *(--p_Stack) = (u32)0x04040404L;				/*  R4                          */

		TCB[TaskID].OSTCBStkPtr = (u32)p_Stack;			/*保存堆栈地址*/
		TCB[TaskID].OSTCBDly = 0;						/*初始化任务延时*/
		OSSetPrioRdy(TaskID);							/*在任务就绪表中登记*/
	}
}

void OSTaskSuspend(u8 prio)
{
	OS_ENTER_CRITICAL();		/*进入临界区*/
	TCB[prio].OSTCBDly = 0;
	OSDelPrioRdy(prio);			/*挂起任务*/
	OS_EXIT_CRITICAL();			/*退出临界区*/

	if(OSPrioCur == prio)		/*挂起的任务为当前运行的任务*/
	{
		OSSched();				/*重新调度*/
	}
}

void OSTaskResume(u8 prio)
{
	OS_ENTER_CRITICAL();
	TCB[prio].OSTCBDly = 0;		/*设置任务延时时间为0*/
	OSSetPrioRdy(prio);			/*就绪任务*/
	OS_EXIT_CRITICAL();

	if(OSPrioCur > prio)		/*当前任务优先级小于恢复的任务优先级*/
	{
		OSSched();
	}
}

u32 IDELTASK_STK[32];

void OSStart(void)
{
	if(OSRunning == 0)
	{
		OSRunning = 1;
		
		OSTaskCreate(IdleTask, (void *)0, (u32 *)&IDELTASK_STK[31], IdelTask_Prio);	//创建空闲任务

		OSGetHighRdy();					/*获得最高级的就绪任务*/
		OSPrioCur = OSPrioHighRdy;		/*获得最高优先级就绪任务ID*/
		p_OSTCBCur = &TCB[OSPrioCur];
		p_OSTCBHighRdy = &TCB[OSPrioHighRdy];
		OSStartHighRdy();
	}
}

void OSIntExit(void)
{
	OS_ENTER_CRITICAL();
	
	if(OSIntNesting > 0)
		OSIntNesting--;
	if(OSIntNesting == 0)
	{
		OSGetHighRdy();					/*找出任务优先级最高的就绪任务*/
		if(OSPrioHighRdy!=OSPrioCur)	/*当前任务并非优先级最高的就绪任务*/
		{
			p_OSTCBCur = &TCB[OSPrioCur];
			p_OSTCBHighRdy = &TCB[OSPrioHighRdy];
			OSPrioCur = OSPrioHighRdy;
			OSIntCtxSw();				/*中断级任务调度*/
		}
	}

	OS_EXIT_CRITICAL();
}

/*系统空闲任务*/
void IdleTask(void *pdata)
{
	u32 IdleCount = 0;
	while(1)
	{
		IdleCount++;
	}
}

void OSTaskSwHook(void)
{
}


文件RTOS.h
;/*********************** (C) COPYRIGHT 2013 Libraworks *************************
;* File Name	: RTOS.h
;* Author		: 卢晓铭 
;* Version		: V1.0
;* Date			: 01/26/2013
;* Description	: LXM-RTOS asm port
;*******************************************************************************/
#ifndef __RTOS_H
#define __RTOS_H
#include "stm32f10x.h"//加入头文件

typedef struct TaskCtrBlockHead		/*任务控制块数据结构*/
{
	u32 OSTCBStkPtr;				/*保存任务栈顶*/
	u32 OSTCBDly;					/*任务延时时钟*/
}TaskCtrBlock;

#define OS_TASKS 32				/*总任务数*/
#define IdelTask_Prio 31		/*空闲任务优先级*/

extern TaskCtrBlock TCB[OS_TASKS - 1];	/*任务控制块定义*/
extern TaskCtrBlock *p_OSTCBCur;		/*指向当前任务控制块的指针*/
extern TaskCtrBlock *p_OSTCBHighRdy;	/*指向最高优先级就绪任务控制块的指针*/
extern u8 OSPrioCur;					/*当前执行任务*/
extern u8 OSPrioHighRdy;				/*最高优先级*/
extern u8 OSRunning;					/*多任务运行标志0:为运行,1:运行*/
extern u32 OSInterruptSum;				/*进入中断次数*/
extern u32 OSTime;						/*系统时间(进入时钟中断次数)*/
extern u32 OSRdyTbl;					/*任务就绪表,0表示挂起,1表示就绪*/
extern u32 OSIntNesting;				/*任务嵌套数*/


void OSTimeDly(u32 ticks);		/*设置任务延时时间*/
void TicksInterrupt(void);		/*定时器中断对任务延时处理函数*/
void IdleTask(void *pdata);		/*系统空闲任务*/
void OSSched(void);				/*任务切换*/
void OSStart(void);				/*多任务系统开始*/
void OSIntExit(void);			/*中断退出函数*/

void OSTaskCreate(void  (*Task)(void  *parg), void *parg, u32 *p_Stack, u8 TaskID);	/*创建任务函数*/
void OSTaskSuspend(u8 prio);	/*挂起指定任务*/
void OSTaskResume(u8 prio);		/*回复指定的挂起任务*/

void OSTaskSwHook(void);		/*空函数*/
/*in asm function*/
void OS_EXIT_CRITICAL(void);	/*退出临界区*/
void OS_ENTER_CRITICAL(void);	/*进入临界区*/
void OSStartHighRdy(void);		/*调度第一个任务*/
void OSCtxSw(void);				/*函数级任务切换*/
void OSIntCtxSw(void);			/*中断级任务切换*/

#endif

文件RTOS_ASM.s

;/*********************** (C) COPYRIGHT 2013 Libraworks *************************
;* File Name	: RTOS_ASM.s
;* Author		: 卢晓铭 
;* Version		: V1.0
;* Date			: 01/26/2013
;* Description	: LXM-RTOS asm port
;*******************************************************************************/
	IMPORT OSInterruptSum
	IMPORT OSRunning
	IMPORT p_OSTCBCur
	IMPORT p_OSTCBHighRdy
	IMPORT OSTaskSwHook
	IMPORT OSPrioCur
	IMPORT OSPrioHighRdy

	EXPORT OS_ENTER_CRITICAL
	EXPORT OS_EXIT_CRITICAL
	EXPORT OSStartHighRdy
	EXPORT OSCtxSw
	EXPORT OSIntCtxSw
	EXPORT PendSV_Handler

NVIC_INT_CTRL   	EQU     0xE000ED04  ; 中断控制寄存器
NVIC_SYSPRI2    	EQU     0xE000ED20  ; 系统优先级寄存器(2)
NVIC_PENDSV_PRI 	EQU     0xFFFF0000  ; 软件中断和系统节拍中断
                                        ; (都为最低,0xff).
NVIC_PENDSVSET  	EQU     0x10000000  ; 触发软件中断的值.

		PRESERVE8 
        SECTION .text:CODE:NOROOT(2)
        THUMB 
;/***************************************************************************************
;* 函数名称: OS_ENTER_CRITICAL
;*
;* 功能描述: 进入临界区 
;*            
;* 参    数: None
;*
;* 返 回 值: None
;*****************************************************************************************/ 

OS_ENTER_CRITICAL
 
		CPSID   I                       ; Disable all the interrupts
                                                                        
		PUSH 	{R1,R2}      

		LDR 	R1, =OSInterruptSum	    ; OSInterrputSum++
        LDRB 	R2, [R1]
        ADD   	R2, R2, #1
        STRB 	R2, [R1]
		POP     {R1,R2}
  		BX LR

;/***************************************************************************************
;* 函数名称: OS_EXIT_CRITICAL
;*
;* 功能描述: 退出临界区 
;*            
;* 参    数: None
;*
;* 返 回 值: None
;*****************************************************************************************/

OS_EXIT_CRITICAL
		PUSH    {R1, R2}
		LDR     R1, =OSInterruptSum     ; OSInterrputSum--
        LDRB    R2, [R1]
        SUB     R2, R2, #1
        STRB    R2, [R1]
		MOV     R1,  #0	      
		CMP     R2,  #0			        ; if OSInterrputSum=0,enable 
                                        ; interrupts如果OSInterrputSum=0,
		;MSREQ  PRIMASK, R1   
        CPSIE   I
	    POP   	{R1, R2}
		BX LR
;/**************************************************************************************
;* 函数名称: OSStartHighRdy
;*
;* 功能描述: 使用调度器运行第一个任务
;* 
;* 参    数: None
;*
;* 返 回 值: None
;**************************************************************************************/  

OSStartHighRdy
        LDR     R4, =NVIC_SYSPRI2      ; set the PendSV exception priority
        LDR     R5, =NVIC_PENDSV_PRI
        STR     R5, [R4]

        MOV     R4, #0                 ; set the PSP to 0 for initial context switch call
        MSR     PSP, R4

        LDR     R4, =OSRunning         ; OSRunning = TRUE
        MOV     R5, #1
        STRB    R5, [R4]

                                       ;切换到最高优先级的任务
        LDR     R4, =NVIC_INT_CTRL     ;rigger the PendSV exception (causes context switch)
        LDR     R5, =NVIC_PENDSVSET
        STR     R5, [R4]

        CPSIE   I                      ;enable interrupts at processor level
OSStartHang
        B       OSStartHang            ;should never get here

;/**************************************************************************************
;* 函数名称: OSCtxSw
;*
;* 功能描述: 函数级任务切换         
;*
;* 参    数: None
;*
;* 返 回 值: None
;***************************************************************************************/
  
OSCtxSw
		PUSH    {R4, R5}
        LDR     R4, =NVIC_INT_CTRL  	;触发PendSV异常 (causes context switch)
        LDR     R5, =NVIC_PENDSVSET
        STR     R5, [R4]
		POP     {R4, R5}
        BX      LR
;/**************************************************************************************
;* 函数名称: OSIntCtxSw
;*
;* 功能描述: 中断级任务切换
;*
;* 参    数: None
;*
;* 返 回 值: None
;***************************************************************************************/

OSIntCtxSw
		PUSH    {R4, R5}
        LDR     R4, =NVIC_INT_CTRL      ;触发PendSV异常 (causes context switch)
        LDR     R5, =NVIC_PENDSVSET
        STR     R5, [R4]
		POP     {R4, R5}
        BX      LR
        NOP

;/**************************************************************************************
;* 函数名称: OSPendSV
;*
;* 功能描述: OSPendSV is used to cause a context switch.
;*
;* 参    数: None
;*
;* 返 回 值: None
;***************************************************************************************/

PendSV_Handler
    CPSID   I                                                   ; Prevent interruption during context switch
    MRS     R0, PSP                                             ; PSP is process stack pointer 如果在用PSP堆栈,则可以忽略保存寄存器,参考CM3权威中的双堆栈-白菜注
    CBZ     R0, PendSV_Handler_Nosave		                    ; Skip register save the first time

    SUBS    R0, R0, #0x20                                       ; Save remaining regs r4-11 on process stack
    STM     R0, {R4-R11}

    LDR     R1, =p_OSTCBCur                                     ; OSTCBCur->OSTCBStkPtr = SP;
    LDR     R1, [R1]
    STR     R0, [R1]                                            ; R0 is SP of process being switched out

                                                                ; At this point, entire context of process has been saved
PendSV_Handler_Nosave
    PUSH    {R14}                                               ; Save LR exc_return value
    LDR     R0, =OSTaskSwHook                                   ; OSTaskSwHook();
    BLX     R0
    POP     {R14}

    LDR     R0, =OSPrioCur                                      ; OSPrioCur = OSPrioHighRdy;
    LDR     R1, =OSPrioHighRdy
    LDRB    R2, [R1]
    STRB    R2, [R0]

    LDR     R0, =p_OSTCBCur                                     ; OSTCBCur  = OSTCBHighRdy;
    LDR     R1, =p_OSTCBHighRdy
    LDR     R2, [R1]
    STR     R2, [R0]

    LDR     R0, [R2]                                            ; R0 is new process SP; SP = OSTCBHighRdy->OSTCBStkPtr;
    LDM     R0, {R4-R11}                                        ; Restore r4-11 from new process stack
    ADDS    R0, R0, #0x20
    MSR     PSP, R0                                             ; Load PSP with new process SP
    ORR     LR, LR, #0x04                                       ; Ensure exception return uses process stack
    CPSIE   I
    BX      LR                                                  ; Exception return will restore remaining context


;************************************************************

END


评论 9
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值