os_core.c

lpc2368-keil环境下的ucos的移植例程

static  void OS_InitTaskIdle(void)
{
#if OS_TASK_CREATE_EXT_EN > 0
#if OS_STK_GROWTH == 1
	(void) OSTaskCreateExt(OS_TaskIdle, (void *) 0, /* No arguments passed to OS_TaskIdle() */ & OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Top-Of-Stack					 */
						  OS_IDLE_PRIO, /* Lowest priority level   			 */
						  OS_TASK_IDLE_ID, &OSTaskIdleStk[0], /* Set Bottom-Of-Stack 				 */
						  OS_TASK_IDLE_STK_SIZE, (void *) 0, /* No TCB extension   				  */
						  OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
#else
	(void) OSTaskCreateExt(OS_TaskIdle, (void *) 0, /* No arguments passed to OS_TaskIdle() */ & OSTaskIdleStk[0], /* Set Top-Of-Stack					 */
						  OS_IDLE_PRIO, /* Lowest priority level   			 */
						  OS_TASK_IDLE_ID, &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Bottom-Of-Stack 				 */
						  OS_TASK_IDLE_STK_SIZE, (void *) 0, /* No TCB extension   				  */
						  OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
#endif
#else
#if OS_STK_GROWTH == 1
	(void) OSTaskCreate(OS_TaskIdle, (void *) 0, &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], OS_IDLE_PRIO);
#else
	(void) OSTaskCreate(OS_TaskIdle, (void *) 0, &OSTaskIdleStk[0], OS_IDLE_PRIO);
#endif
#endif
}
/*$PAGE*/
/*
*********************************************************************************************************
*   										  INITIALIZATION
*   								   CREATING THE STATISTIC TASK
*
* Description: This function creates the Statistic Task.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

#if OS_TASK_STAT_EN > 0
static  void OS_InitTaskStat(void)
{
#if OS_TASK_CREATE_EXT_EN > 0
#if OS_STK_GROWTH == 1
	(void) OSTaskCreateExt(OS_TaskStat, (void *) 0, /* No args passed to OS_TaskStat()*/ & OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1], /* Set Top-Of-Stack  			 */
						  OS_STAT_PRIO, /* One higher than the idle task  */
						  OS_TASK_STAT_ID, &OSTaskStatStk[0], /* Set Bottom-Of-Stack   		 */
						  OS_TASK_STAT_STK_SIZE, (void *) 0, /* No TCB extension 			  */
						  OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
#else
	(void) OSTaskCreateExt(OS_TaskStat, (void *) 0, /* No args passed to OS_TaskStat()*/ & OSTaskStatStk[0], /* Set Top-Of-Stack  			 */
						  OS_STAT_PRIO, /* One higher than the idle task  */
						  OS_TASK_STAT_ID, &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1], /* Set Bottom-Of-Stack   		 */
						  OS_TASK_STAT_STK_SIZE, (void *) 0, /* No TCB extension 			  */
						  OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
#endif
#else
#if OS_STK_GROWTH == 1
	(void) OSTaskCreate(OS_TaskStat, (void *) 0, /* No args passed to OS_TaskStat()*/ & OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1], /* Set Top-Of-Stack   			*/
					   OS_STAT_PRIO);   							   /* One higher than the idle task  */
#else
	(void) OSTaskCreate(OS_TaskStat, (void *) 0, /* No args passed to OS_TaskStat()*/ & OSTaskStatStk[0], /* Set Top-Of-Stack   			*/
					   OS_STAT_PRIO);   							   /* One higher than the idle task  */
#endif
#endif
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   										  INITIALIZATION
*   						 INITIALIZE THE FREE LIST OF TASK CONTROL BLOCKS
*
* Description: This function is called by OSInit() to initialize the free list of OS_TCBs.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

static  void OS_InitTCBList(void)
{
	INT8U    i;
	OS_TCB  *ptcb1;
	OS_TCB  *ptcb2;


	OSTCBList = (OS_TCB *) 0;   							  /* TCB Initialization 					  */
	for (i = 0; i < (OS_LOWEST_PRIO + 1); i++)
	{
		/* Clear the priority table 				*/
		OSTCBPrioTbl[i] = (OS_TCB *) 0;
	}
	ptcb1 = &OSTCBTbl[0];
	ptcb2 = &OSTCBTbl[1];
	for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++)
	{
		/* Init. list of free TCBs  				*/
		ptcb1->OSTCBNext = ptcb2;
		ptcb1++;
		ptcb2++;
	}
	ptcb1->OSTCBNext = (OS_TCB *) 0;							  /* Last OS_TCB							  */
	OSTCBFreeList = &OSTCBTbl[0];
}
/*$PAGE*/
/*
*********************************************************************************************************
*   										   SCHEDULER
*
* Description: This function is called by other uC/OS-II services to determine whether a new, high
*   		   priority task has been made ready to run.  This function is invoked by TASK level code
*   		   and is not used to reschedule tasks from ISRs (see OSIntExit() for ISR rescheduling).
*
* Arguments  : none
*
* Returns    : none
*
* Notes 	 : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
*   		   2) Rescheduling is prevented when the scheduler is locked (see OS_SchedLock())
*********************************************************************************************************
*/

void OS_Sched(void)
{
#if OS_CRITICAL_METHOD == 3 						   /* Allocate storage for CPU status register     */
	OS_CPU_SR  cpu_sr;
#endif    
	INT8U      y;


	OS_ENTER_CRITICAL();
	if ((OSIntNesting == 0) && (OSLockNesting == 0))
	{
		/* Sched. only if all ISRs done & not locked	*/
		y = OSUnMapTbl[OSRdyGrp];   	   /* Get pointer to HPT ready to run   		   */
		OSPrioHighRdy = (INT8U) ((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);
		if (OSPrioHighRdy != OSPrioCur)
		{
			/* No Ctx Sw if current task is highest rdy 	*/
			OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
			OSCtxSwCtr++;   						   /* Increment context switch counter  		   */
			OS_TASK_SW();   						   /* Perform a context switch  				   */
		}
	}
	OS_EXIT_CRITICAL();
}
/*$PAGE*/
/*
*********************************************************************************************************
*   										   IDLE TASK
*
* Description: This task is internal to uC/OS-II and executes whenever no other higher priority tasks
*   		   executes because they are ALL waiting for event(s) to occur.
*
* Arguments  : none
*
* Returns    : none
*
* Note(s)    : 1) OSTaskIdleHook() is called after the critical section to ensure that interrupts will be
*   			  enabled for at least a few instructions.  On some processors (ex. Philips XA), enabling
*   			  and then disabling interrupts didn't allow the processor enough time to have interrupts
*   			  enabled before they were disabled again.  uC/OS-II would thus never recognize
*   			  interrupts.
*   		   2) This hook has been added to allow you to do such things as STOP the CPU to conserve 
*   			  power.
*********************************************************************************************************
*/

void OS_TaskIdle(void *pdata)
{
#if OS_CRITICAL_METHOD == 3 					 /* Allocate storage for CPU status register		   */
	OS_CPU_SR  cpu_sr;
#endif    


	pdata = pdata;  							 /* Prevent compiler warning for not using 'pdata'     */
	for (; ;)
	{
		OS_ENTER_CRITICAL();
		OSIdleCtr++;
		OS_EXIT_CRITICAL();
		OSTaskIdleHook();   					 /* Call user definable HOOK						   */
	}
}
/*$PAGE*/
/*
*********************************************************************************************************
*   										 STATISTICS TASK
*
* Description: This task is internal to uC/OS-II and is used to compute some statistics about the
*   		   multitasking environment.  Specifically, OS_TaskStat() computes the CPU usage.
*   		   CPU usage is determined by:
*
*   									   OSIdleCtr
*   			  OSCPUUsage = 100 * (1 - ------------) 	(units are in %)
*   									  OSIdleCtrMax
*
* Arguments  : pdata	 this pointer is not used at this time.
*
* Returns    : none
*
* Notes 	 : 1) This task runs at a priority level higher than the idle task.  In fact, it runs at the
*   			  next higher priority, OS_IDLE_PRIO-1.
*   		   2) You can disable this task by setting the configuration #define OS_TASK_STAT_EN to 0.
*   		   3) We delay for 5 seconds in the beginning to allow the system to reach steady state and
*   			  have all other tasks created before we do statistics.  You MUST have at least a delay
*   			  of 2 seconds to allow for the system to establish the maximum value for the idle
*   			  counter.
*********************************************************************************************************
*/

#if OS_TASK_STAT_EN > 0
void OS_TaskStat(void *pdata)
{
#if OS_CRITICAL_METHOD == 3 					 /* Allocate storage for CPU status register		   */
	OS_CPU_SR  cpu_sr;
#endif    
	INT32U     run;
	INT32U     max;
	INT8S      usage;


	pdata = pdata;  							 /* Prevent compiler warning for not using 'pdata'     */
	while (OSStatRdy == FALSE)
	{
		OSTimeDly(2 * OS_TICKS_PER_SEC);		 /* Wait until statistic task is ready  			   */
	}
	max = OSIdleCtrMax / 100L;
	for (; ;)
	{
		OS_ENTER_CRITICAL();
		OSIdleCtrRun = OSIdleCtr;   			 /* Obtain the of the idle counter for the past second */
		run = OSIdleCtr;
		OSIdleCtr = 0L; 					  /* Reset the idle counter for the next second 		*/
		OS_EXIT_CRITICAL();
		if (max > 0L)
		{
			usage = (INT8S) (100L - run / max);
			if (usage >= 0)
			{
				/* Make sure we don't have a negative percentage      */
				OSCPUUsage = usage;
			}
			else
			{
				OSCPUUsage = 0;
			}
		}
		else
		{
			OSCPUUsage = 0;
			max = OSIdleCtrMax / 100L;
		}
		OSTaskStatHook();   					 /* Invoke user definable hook  					   */
		OSTimeDly(OS_TICKS_PER_SEC);			 /* Accumulate OSIdleCtr for the next second		   */
	}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   										 INITIALIZE TCB
*
* Description: This function is internal to uC/OS-II and is used to initialize a Task Control Block when
*   		   a task is created (see OSTaskCreate() and OSTaskCreateExt()).
*
* Arguments  : prio 		 is the priority of the task being created
*
*   		   ptos 		 is a pointer to the task's top-of-stack assuming that the CPU registers
*   						 have been placed on the stack.  Note that the top-of-stack corresponds to a
*   						 'high' memory location is OS_STK_GROWTH is set to 1 and a 'low' memory
*   						 location if OS_STK_GROWTH is set to 0.  Note that stack growth is CPU
*   						 specific.
*
*   		   pbos 		 is a pointer to the bottom of stack.  A NULL pointer is passed if called by
*   						 'OSTaskCreate()'.
*
*   		   id   		 is the task's ID (0..65535)
*
*   		   stk_size 	 is the size of the stack (in 'stack units').  If the stack units are INT8Us
*   						 then, 'stk_size' contains the number of bytes for the stack.  If the stack
*   						 units are INT32Us then, the stack contains '4 * stk_size' bytes.  The stack
*   						 units are established by the #define constant OS_STK which is CPU
*   						 specific.  'stk_size' is 0 if called by 'OSTaskCreate()'.
*
*   		   pext 		 is a pointer to a user supplied memory area that is used to extend the task
*   						 control block.  This allows you to store the contents of floating-point
*   						 registers, MMU registers or anything else you could find useful during a
*   						 context switch.  You can even assign a name to each task and store this name
*   						 in this TCB extension.  A NULL pointer is passed if called by OSTaskCreate().
*
*   		   opt  		 options as passed to 'OSTaskCreateExt()' or,
*   						 0 if called from 'OSTaskCreate()'.
*
* Returns    : OS_NO_ERR		 if the call was successful
*   		   OS_NO_MORE_TCB    if there are no more free TCBs to be allocated and thus, the task cannot
*   							 be created.
*
* Note  	 : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/

INT8U OS_TCBInit(INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt)
{
#if OS_CRITICAL_METHOD == 3 							   /* Allocate storage for CPU status register */
	OS_CPU_SR  cpu_sr;
#endif    
	OS_TCB    *ptcb;


	OS_ENTER_CRITICAL();
	ptcb = OSTCBFreeList;   							   /* Get a free TCB from the free TCB list    */
	if (ptcb != (OS_TCB *) 0)
	{
		OSTCBFreeList = ptcb->OSTCBNext;			/* Update pointer to free TCB list  		*/
		OS_EXIT_CRITICAL();
		ptcb->OSTCBStkPtr = ptos;   					/* Load Stack pointer in TCB				*/
		ptcb->OSTCBPrio = (INT8U) prio; 			   /* Load task priority into TCB   		   */
		ptcb->OSTCBStat = OS_STAT_RDY;  			  /* Task is ready to run   				  */
		ptcb->OSTCBDly = 0; 						 /* Task is not delayed 					 */

#if OS_TASK_CREATE_EXT_EN > 0
		ptcb->OSTCBExtPtr = pext;   					/* Store pointer to TCB extension   		*/
		ptcb->OSTCBStkSize = stk_size;  				 /* Store stack size						 */
		ptcb->OSTCBStkBottom = pbos;					   /* Store pointer to bottom of stack  	   */
		ptcb->OSTCBOpt = opt;   					 /* Store task options  					 */
		ptcb->OSTCBId = id; 						/* Store task ID							*/
#else
		pext = pext;					   /* Prevent compiler warning if not used     */
		stk_size = stk_size;
		pbos = pbos;
		opt = opt;
		id = id;
#endif

#if OS_TASK_DEL_EN > 0
		ptcb->OSTCBDelReq = OS_NO_ERR;
#endif

		ptcb->OSTCBY = prio >> 3;   			   /* Pre-compute X, Y, BitX and BitY   	   */
		ptcb->OSTCBBitY = OSMapTbl[ptcb->OSTCBY];
		ptcb->OSTCBX = prio & 0x07;
		ptcb->OSTCBBitX = OSMapTbl[ptcb->OSTCBX];

#if OS_EVENT_EN > 0
		ptcb->OSTCBEventPtr = (OS_EVENT *) 0;   		   /* Task is not pending on an event   	   */
#endif

#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0) && (OS_TASK_DEL_EN > 0)
		ptcb->OSTCBFlagNode = (OS_FLAG_NODE *) 0;   	   /* Task is not pending on an event flag     */
#endif

#if (OS_MBOX_EN > 0) || ((OS_Q_EN > 0) && (OS_MAX_QS > 0))
		ptcb->OSTCBMsg = (void *) 0;				  /* No message received					  */
#endif

#if OS_VERSION >= 204
		OSTCBInitHook(ptcb);
#endif

		OSTaskCreateHook(ptcb); 						   /* Call user defined hook				   */

		OS_ENTER_CRITICAL();
		OSTCBPrioTbl[prio] = ptcb;
		ptcb->OSTCBNext = OSTCBList;					/* Link into TCB chain  					*/
		ptcb->OSTCBPrev = (OS_TCB *) 0;
		if (OSTCBList != (OS_TCB *) 0)
		{
			OSTCBList->OSTCBPrev = ptcb;
		}
		OSTCBList = ptcb;
		OSRdyGrp |= ptcb->OSTCBBitY;		 /* Make task ready to run  				 */
		OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
		OS_EXIT_CRITICAL();
		return (OS_NO_ERR);
	}
	OS_EXIT_CRITICAL();
	return (OS_NO_MORE_TCB);
}