os_core.c

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

*********************************************************************************************************
*/

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


	OSTimeTickHook();   								   /* Call user definable hook  			   */
#if OS_TIME_GET_SET_EN > 0   
	OS_ENTER_CRITICAL();								   /* Update the 32-bit tick counter		   */
	OSTime++;
	OS_EXIT_CRITICAL();
#endif
	if (OSRunning == TRUE)
	{
		ptcb = OSTCBList;   							   /* Point at first TCB in TCB list		   */
		while (ptcb->OSTCBPrio != OS_IDLE_PRIO)
		{
			/* Go through all TCBs in TCB list  		*/
			OS_ENTER_CRITICAL();
			if (ptcb->OSTCBDly != 0)
			{
				/* Delayed or waiting for event with TO 	*/
				if (--ptcb->OSTCBDly == 0)
				{
					/* Decrement nbr of ticks to end of delay   */
					if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY)
					{
						/* Is task suspended?    */
						OSRdyGrp |= ptcb->OSTCBBitY; /* No,  Make task R-to-R (timed out)*/
						OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
					}
					else
					{
						/* Yes, Leave 1 tick to prevent ... 		*/
						ptcb->OSTCBDly = 1; 			   /* ... loosing the task when the ... 	   */
					}   								   /* ... suspension is removed.			   */
				}
			}
			ptcb = ptcb->OSTCBNext; 					   /* Point at next TCB in TCB list 		   */
			OS_EXIT_CRITICAL();
		}
	}
}
/*$PAGE*/
/*
*********************************************************************************************************
*   										  GET VERSION
*
* Description: This function is used to return the version number of uC/OS-II.  The returned value
*   		   corresponds to uC/OS-II's version number multiplied by 100.  In other words, version 2.00
*   		   would be returned as 200.
*
* Arguments  : none
*
* Returns    : the version number of uC/OS-II multiplied by 100.
*********************************************************************************************************
*/

INT16U OSVersion(void)
{
	return (OS_VERSION);
}

/*$PAGE*/
/*
*********************************************************************************************************
*   										 DUMMY FUNCTION
*
* Description: This function doesn't do anything.  It is called by OSTaskDel().
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

#if OS_TASK_DEL_EN > 0
void OS_Dummy(void)
{
}
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*   						  MAKE TASK READY TO RUN BASED ON EVENT OCCURING
*
* Description: This function is called by other uC/OS-II services and is used to ready a task that was
*   		   waiting for an event to occur.
*
* Arguments  : pevent    is a pointer to the event control block corresponding to the event.
*
*   		   msg  	 is a pointer to a message.  This pointer is used by message oriented services
*   					 such as MAILBOXEs and QUEUEs.  The pointer is not used when called by other
*   					 service functions.
*
*   		   msk  	 is a mask that is used to clear the status byte of the TCB.  For example,
*   					 OSSemPost() will pass OS_STAT_SEM, OSMboxPost() will pass OS_STAT_MBOX etc.
*
* Returns    : none
*
* Note  	 : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if OS_EVENT_EN > 0
INT8U OS_EventTaskRdy(OS_EVENT *pevent, void *msg, INT8U msk)
{
	OS_TCB *ptcb;
	INT8U   x;
	INT8U   y;
	INT8U   bitx;
	INT8U   bity;
	INT8U   prio;


	y = OSUnMapTbl[pevent->OSEventGrp]; 		   /* Find highest prio. task waiting for message   */
	bity = OSMapTbl[y];
	x = OSUnMapTbl[pevent->OSEventTbl[y]];
	bitx = OSMapTbl[x];
	prio = (INT8U) ((y << 3) + x);  				   /* Find priority of task getting the msg 		*/
	if ((pevent->OSEventTbl[y] &= ~bitx) == 0x00)
	{
		/* Remove this task from the waiting list   	 */
		pevent->OSEventGrp &= ~bity;				  /* Clr group bit if this was only task pending   */
	}
	ptcb = OSTCBPrioTbl[prio];  	 /* Point to this task's OS_TCB                   */
	ptcb->OSTCBDly = 0; 					   /* Prevent OSTimeTick() from readying task   	*/
	ptcb->OSTCBEventPtr = (OS_EVENT *) 0;   		  /* Unlink ECB from this task  				   */
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0)
	ptcb->OSTCBMsg = msg;   					/* Send message directly to waiting task		 */
#else
	msg = msg;  					 /* Prevent compiler warning if not used		  */
#endif
	ptcb->OSTCBStat &= ~msk;					  /* Clear bit associated with event type   	   */
	if (ptcb->OSTCBStat == OS_STAT_RDY)
	{
		/* See if task is ready (could be susp'd)        */
		OSRdyGrp |= bity;   				  /* Put task in the ready to run list  		   */
		OSRdyTbl[y] |= bitx;
	}
	return (prio);
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   								MAKE TASK WAIT FOR EVENT TO OCCUR
*
* Description: This function is called by other uC/OS-II services to suspend a task because an event has
*   		   not occurred.
*
* Arguments  : pevent   is a pointer to the event control block for which the task will be waiting for.
*
* Returns    : none
*
* Note  	 : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if OS_EVENT_EN > 0
void OS_EventTaskWait(OS_EVENT *pevent)
{
	OSTCBCur->OSTCBEventPtr = pevent;   		 /* Store pointer to event control block in TCB 	   */
	if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0x00)
	{
		/* Task no longer ready 	 */
		OSRdyGrp &= ~OSTCBCur->OSTCBBitY;   	 /* Clear event grp bit if this was only task pending  */
	}
	pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;		  /* Put task in waiting list  */
	pevent->OSEventGrp |= OSTCBCur->OSTCBBitY;
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   						   MAKE TASK READY TO RUN BASED ON EVENT TIMEOUT
*
* Description: This function is called by other uC/OS-II services to make a task ready to run because a
*   		   timeout occurred.
*
* Arguments  : pevent   is a pointer to the event control block which is readying a task.
*
* Returns    : none
*
* Note  	 : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if OS_EVENT_EN > 0
void OS_EventTO(OS_EVENT *pevent)
{
	if ((pevent->OSEventTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0x00)
	{
		pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY;
	}
	OSTCBCur->OSTCBStat = OS_STAT_RDY;  	 /* Set status to ready 							   */
	OSTCBCur->OSTCBEventPtr = (OS_EVENT *) 0;     /* No longer waiting for event						*/
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   							  INITIALIZE EVENT CONTROL BLOCK'S WAIT LIST
*
* Description: This function is called by other uC/OS-II services to initialize the event wait list.
*
* Arguments  : pevent    is a pointer to the event control block allocated to the event.
*
* Returns    : none
*
* Note  	 : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0)
void OS_EventWaitListInit(OS_EVENT *pevent)
{
	INT8U  *ptbl;


	pevent->OSEventGrp = 0x00;  				 /* No task waiting on event						   */
	ptbl = &pevent->OSEventTbl[0];

#if OS_EVENT_TBL_SIZE > 0
	*ptbl++ = 0x00;
#endif

#if OS_EVENT_TBL_SIZE > 1
	*ptbl++ = 0x00;
#endif

#if OS_EVENT_TBL_SIZE > 2
	*ptbl++ = 0x00;
#endif

#if OS_EVENT_TBL_SIZE > 3
	*ptbl++ = 0x00;
#endif

#if OS_EVENT_TBL_SIZE > 4
	*ptbl++ = 0x00;
#endif

#if OS_EVENT_TBL_SIZE > 5
	*ptbl++ = 0x00;
#endif

#if OS_EVENT_TBL_SIZE > 6
	*ptbl++ = 0x00;
#endif

#if OS_EVENT_TBL_SIZE > 7
	*ptbl = 0x00;
#endif
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   										  INITIALIZATION
*   						INITIALIZE THE FREE LIST OF EVENT CONTROL BLOCKS
*
* Description: This function is called by OSInit() to initialize the free list of event control blocks.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

static  void OS_InitEventList(void)
{
#if (OS_EVENT_EN > 0) && (OS_MAX_EVENTS > 0)
#if (OS_MAX_EVENTS > 1)
	INT16U     i;
	OS_EVENT  *pevent1;
	OS_EVENT  *pevent2;


	pevent1 = &OSEventTbl[0];
	pevent2 = &OSEventTbl[1];
	for (i = 0; i < (OS_MAX_EVENTS - 1); i++)
	{
		/* Init. list of free EVENT control blocks  */
		pevent1->OSEventType = OS_EVENT_TYPE_UNUSED;
		pevent1->OSEventPtr = pevent2;
		pevent1++;
		pevent2++;
	}
	pevent1->OSEventType = OS_EVENT_TYPE_UNUSED;
	pevent1->OSEventPtr = (OS_EVENT *) 0;
	OSEventFreeList = &OSEventTbl[0];
#else
	OSEventFreeList = &OSEventTbl[0];   			/* Only have ONE event control block		*/
	OSEventFreeList->OSEventType = OS_EVENT_TYPE_UNUSED;
	OSEventFreeList->OSEventPtr = (OS_EVENT *) 0;
#endif
#endif
}
/*$PAGE*/
/*
*********************************************************************************************************
*   										  INITIALIZATION
*   								 INITIALIZE MISCELLANEOUS VARIABLES
*
* Description: This function is called by OSInit() to initialize miscellaneous variables.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

static  void OS_InitMisc(void)
{
#if OS_TIME_GET_SET_EN > 0   
	OSTime = 0L;										  /* Clear the 32-bit system clock  		  */
#endif

	OSIntNesting = 0;   										/* Clear the interrupt nesting counter  	*/
	OSLockNesting = 0;  										 /* Clear the scheduling lock counter   	 */

	OSTaskCtr = 0;  										 /* Clear the number of tasks   			 */

	OSRunning = FALSE;  									 /* Indicate that multitasking not started   */

	OSCtxSwCtr = 0; 										  /* Clear the context switch counter   	  */
	OSIdleCtr = 0L; 										 /* Clear the 32-bit idle counter   		 */

#if (OS_TASK_STAT_EN > 0) && (OS_TASK_CREATE_EXT_EN > 0)
	OSIdleCtrRun = 0L;
	OSIdleCtrMax = 0L;
	OSStatRdy = FALSE;  									 /* Statistic task is not ready 			 */
#endif
}
/*$PAGE*/
/*
*********************************************************************************************************
*   										  INITIALIZATION
*   									INITIALIZE THE READY LIST
*
* Description: This function is called by OSInit() to initialize the Ready List.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

static  void OS_InitRdyList(void)
{
	INT16U   i;
	INT8U   *prdytbl;


	OSRdyGrp = 0x00;										/* Clear the ready list 					*/
	prdytbl = &OSRdyTbl[0];
	for (i = 0; i < OS_RDY_TBL_SIZE; i++)
	{
		*prdytbl++ = 0x00;
	}

	OSPrioCur = 0;
	OSPrioHighRdy = 0;

	OSTCBHighRdy = (OS_TCB *) 0;								 
	OSTCBCur = (OS_TCB *) 0;
}

/*$PAGE*/
/*
*********************************************************************************************************
*   										  INITIALIZATION
*   									  CREATING THE IDLE TASK
*
* Description: This function creates the Idle Task.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/