基于STM32的简易RTOS

最新推荐文章于 2024-09-06 03:33:53 发布
最新推荐文章于 2024-09-06 03:33:53 发布
阅读量6.2k 收藏 10
点赞数 2
分类专栏： 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


左氏浮夸
关注
专栏目录
最简单的stm32 RTOS
09-14
RTOS命名为HesOS,实现多任务切换，移植超简单，1ms调度一次， 实时性非常高
使用STM32编写一个简单的RTOS：1.调度(一、上下文）
Nuko的博客
06-11 3299
文章目录Cortex M3相关寄存器介绍寄存器组异常异常类型堆栈测试 实验平台：stm32f10x(cortex-m3)开发板，RTT3.0 资料来源：RTT官网文档及cortex-M3权威指南 关键字：分析RT-Thread源码、stm32、RTOS。 Cortex M3相关寄存器介绍 因为我要边学习RTT,边模仿RTT写一个简单的RTOS，所以需要先写调度、上下位切换部分。 关于调度的定义和作...
基于STM32的RTOS--freertos的使用（HAL实现多任务）
最新发布
tmk1234567890的博客
09-06 618
基于STM32的RTOS--freertos的使用（HAL实现多任务）
简单介绍STM32上的FreeRTOS实时操作系统
m0_64042324的博客
06-24 8866
FreeRTOS是一款广泛使用的开源实时操作系统（RTOS），它为嵌入式系统提供了可靠的任务调度和并发管理。在嵌入式领域中，STM32微控制器广受欢迎，并且与FreeRTOS的结合使用可以提供强大的功能和灵活性。在本篇博客中，我们将深入探究STM32上的FreeRTOS，并了解其核心概念、任务调度算法、任务通信机制以及在实际应用中的使用案例FreeRTOS（Free Real-Time Operating System）是一款开源的实时操作系统（RTOS），专为嵌入式系统设计。
STM32之FreeRTOS
weixin_49001476的博客
06-09 4900
Free即免费的，RTOS的全称是，中文就是实时操作系统。注意：RTOS不是指某一个确定的系统，而是指一类操作系统。比如：uc/OSFreeRTOSRTXRT-Thread等这些都是RTOS类操作系统。FreeRTOS是一个迷你的实时操作系统内核。作为一个轻量级的操作系统，功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等，可基本满足较小系统的需要。由于RTOS需占用一定的系统资源尤其是RAM资源，只有μC/OS-II。
嵌入式STM32深入之RTOS编程
huang_527的博客
11-06 3873
在之前的学习中，我们介绍了温度传感器的使用、OLED屏幕的显示，相当于学习了对于外设的基本使用，让我们学习不在仅仅限制于基本LED的使用，大家可以利用这种方式自己购买外设去实现一些功能，这种学习的方法才不会枯燥，就像我最开始购买了一块正点原子的STM32单片机mini的开发板自己学着实在是：因为最开始你学习的话没有系统的认知，只有先学习理论知识，但是对于芯片来说不是特别喜欢容易学崩，我当时就绷不住了。通过最小系统板学习，去开发你自己想做的事，你也不知道会出现什么有意思的事。
STM32移植FreeRTOS经验详细教程
weixin_49337111的博客
12-19 5056
当前RTOS已经广泛应用于各种嵌入式设备中，如智能可穿戴设备、智能家居设备等。且RTOS已成为嵌入式、物联网开发者的基础必备技能。对于应届生而言，掌握RTOS是求职应聘、参与产品项目开发的一个优势加分项。
STM32移植FreeRTOS操作系统
qq_38295600的博客
03-07 6119
STM32移植FreeRTOS操作系统
基于stm32的频率计设计
05-22
频率计是一种测量信号频率的设备，而基于STM32的频率计设计能够实现精确、实时的频率测量。 首先，我们需要了解STM32的基本结构。STM32系列涵盖多种型号，拥有不同的性能、存储和外设接口。它们通常包括高速嵌入式...
基于STM32的简易计算器设计源码.zip
11-07
在本项目中，我们关注的是一个基于STM32微控制器的简易计算器的设计。STM32是一种广泛应用的32位微控制器系列，由意法半导体（STMicroelectronics）开发，广泛用于嵌入式系统设计。这个设计的核心是使用STM32处理器...
基于STM32的电子书阅读器设计.docx
06-14
基于STM32的电子书阅读器设计是一种集成了微处理器技术、显示技术、存储技术和通信技术的智能设备，主要用于提供方便、高效的电子书籍阅读体验。STM32是意法半导体公司（STMicroelectronics）推出的一系列基于ARM ...
基于STM32单片机的电子秤
04-27
10. 软件框架：基于STM32的项目往往采用FreeRTOS、CMSIS等实时操作系统（RTOS）或软件框架，进行任务调度和管理。 通过以上知识点的介绍，我们可以了解到基于STM32的电子秤设计不仅涉及到硬件选型和系统集成，还...
STM32 相关RTOS
位文杰的博客
08-22 2058
特别是keil5之后，出现了RTE配置环境，实时操作系统原理基本都一样。但是RTX有它独特之处，就是它中断延时对M3/M4内核可以实现零等待，带有免版税，确定性的RTOS。话不多说，咱们开始创建RTX工程。前提是你得安装了keil5，我的是5.22版本。接着，必须在RTX_Config.c文件中做出必要的 修改来设置RTX内核以适应应用程序的需要。()三个函数为了避免函数名被重复定义，这三个函数必须注释掉，要不RTX就没法运行；2. 滴答定时器主频 72MHz，这个也是 STM32F103 的主频。
基于STM32的简易RTOS分析-抢占式调度
单片机开发
07-10 1080
抢占式调度一般是基于优先级（priority）的调度。《FreeRTOS的任务调度算法优化实现》这篇文章中提到FreeRTOS是通过循环遍历的方法查找最高优先级就绪态任务，而Ucos采用的是位图（bitmap）算法查找最高优先级任务。调度器是RTOS的核心模块运行频繁，因此其代码设计上要运行速度快开销少才能满足RTOS的实时性要求。 .........
stm32 freertos任务切换，多任务状态迁移，中断临界段，任务延时，中断过程，普通中断与任务切换的区别
weixin_42224577的博客
07-06 2320
arm中SP，LR，PC寄存器以及其它所有寄存器以及处理器运行模式介绍 一、xTaskCreate（） 1、prvInitialiseNewTask（） 2、prvAddNewTaskToReadyList（） (1)：全局任务计时器uxCurrentNumberOfTasks加一操作。uxCurrentNumberOfTasks 是一个在task.c中定义的静态变量，默认初始化为0 (2)：如果pxCurrentTCB为空，则将pxCurrentTCB指向新创建的任务。pxCurrentTCB 是一个在t
STM32F103C8T6移植FreeRTOS
u013012082的专栏
02-18 2365
STM32F103C8T6移植FreeRTOS
stm32——freeRTOS介绍
2302_76515999的博客
05-10 883
freeRTOS是一个迷你的实时操作系统内核，作为一个轻量级的操作系统，功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等，可基本满足较小系统的需要。比如uc/OS，freeRTOS，RTX，RT-Thread等这些都是RTOS类操作系统。3、很多半导体厂商产品的SDK软件开发工具包，就使用freeRTOS作为操作系统，尤其是wifi、蓝牙这些带有协议栈的芯片或模块。每个任务都是独立运行的，互补影响，由于切换的频率很快，就感觉像是同时运行的一样。
STM32（F103ZET6）第十九课：FreeRtos的移植和使用
2401_83971583的博客
08-28 1752
裸机执行流程：前后台系统操作系统执行流程：加入操作系统的作用：用户想要实现多个任务并行的效果，但是单片机只有一个核心，同时只能处理一件事，通过加入操作系统，可以实现任务快速的切换，给人一种多个任务同时在执行的错觉。
stm32智能小车(FreeRTOS项目练习)
热门推荐
qq_47775761的博客
05-05 1万+
看完了FreeRTOS的教程，想找个项目练手，淘宝或者网上少有基于FreeRTOS的项目，于是我就想用FreeRTOS做个智能小车，可能FreeRTOS不是做小车的最优解，但主要目的是用来练手。
基于STM32F103的嵌入式工程实现与简易操作系统
资源摘要信息:"STM32F103工程是一个综合性的嵌入式系统项目，该工程不仅集成了STM32F103系列单片机所有常用外设的驱动与接口，而且在其基础上嵌入了一个简易的操作系统（RTOS），以支持多任务处理和系统调度。...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值