os_core.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

				OSCtxSwCtr++;   					   /* Increment context switch counter  		   */
				OS_TASK_SW();   					   /* Perform a context switch  				   */
			}
		}
	}
	OS_EXIT_CRITICAL();
}


/*
*********************************************************************************************************
*   						   FIND HIGHEST PRIORITY TASK READY TO RUN
*
* Description: This function is called by other uC/OS-II services to determine the highest priority task
*   		   that is ready to run.  The global variable 'OSPrioHighRdy' is changed accordingly.
*
* Arguments  : none
*
* Returns    : none
*
* Notes 	 : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
*   		   2) Interrupts are assumed to be disabled when this function is called.
*********************************************************************************************************
*/

static  void OS_SchedNew(void)
{
#if OS_LOWEST_PRIO <= 63						 /* See if we support up to 64 tasks				   */
	INT8U   y;


	y = OSUnMapTbl[OSRdyGrp];
	OSPrioHighRdy = (INT8U) ((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);
#else   										 /* We support up to 256 tasks  					   */
	INT8U   y;
	INT16U *ptbl;


	if ((OSRdyGrp & 0xFF) != 0)
	{
		y = OSUnMapTbl[OSRdyGrp & 0xFF];
	}
	else
	{
		y = OSUnMapTbl[(OSRdyGrp >> 8) & 0xFF] + 8;
	}
	ptbl = &OSRdyTbl[y];
	if ((*ptbl & 0xFF) != 0)
	{
		OSPrioHighRdy = (INT8U) ((y << 4) + OSUnMapTbl[(*ptbl & 0xFF)]);
	}
	else
	{
		OSPrioHighRdy = (INT8U) ((y << 4) + OSUnMapTbl[(*ptbl >> 8) & 0xFF] + 8);
	}
#endif
}

/*$PAGE*/
/*
*********************************************************************************************************
*   									 COPY AN ASCII STRING
*
* Description: This function is called by other uC/OS-II services to copy an ASCII string from a 'source'
*   		   string to a 'destination' string.
*
* Arguments  : pdest	is a pointer to the string that will be receiving the copy.  Note that there MUST
*   					be sufficient space in the destination storage area to receive this string.
*
*   		   psrc 	is a pointer to the source string.  The source string MUST NOT be greater than
*   					254 characters.
*
* Returns    : The size of the string (excluding the NUL terminating character)
*
* Notes 	 : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/

#if (OS_EVENT_NAME_SIZE > 1) || (OS_FLAG_NAME_SIZE > 1) || (OS_MEM_NAME_SIZE > 1) || (OS_TASK_NAME_SIZE > 1) || (OS_TMR_CFG_NAME_SIZE > 1)
INT8U OS_StrCopy(INT8U *pdest, INT8U *psrc)
{
	INT8U  len;


	len = 0;
	while (*psrc != OS_ASCII_NUL)
	{
		*pdest++ = *psrc++;
		len++;
	}
	*pdest = OS_ASCII_NUL;
	return (len);
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   							 DETERMINE THE LENGTH OF AN ASCII STRING
*
* Description: This function is called by other uC/OS-II services to determine the size of an ASCII string
*   		   (excluding the NUL character).
*
* Arguments  : psrc 	is a pointer to the string for which we need to know the size.
*
* Returns    : The size of the string (excluding the NUL terminating character)
*
* Notes 	 : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
*   		   2) The string to check must be less than 255 characters long.
*********************************************************************************************************
*/

#if (OS_EVENT_NAME_SIZE > 1) || (OS_FLAG_NAME_SIZE > 1) || (OS_MEM_NAME_SIZE > 1) || (OS_TASK_NAME_SIZE > 1) || (OS_TMR_CFG_NAME_SIZE > 1)
INT8U OS_StrLen(INT8U *psrc)
{
	INT8U  len;


	len = 0;
	while (*psrc != OS_ASCII_NUL)
	{
		psrc++;
		len++;
	}
	return (len);
}
#endif
/*$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 *p_arg)
{
#if OS_CRITICAL_METHOD == 3 					 /* Allocate storage for CPU status register		   */
	OS_CPU_SR  cpu_sr = 0;
#endif



	(void) p_arg;   							  /* Prevent compiler warning for not using 'parg'  	*/
	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  : parg 	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_TASK_IDLE_PRIO-1.
*   		   2) You can disable this task by setting the configuration #define OS_TASK_STAT_EN to 0.
*   		   3) You MUST have at least a delay of 2/10 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 *p_arg)
{
	INT32U     run;
	INT32U     max;
	INT8S      usage;
#if OS_CRITICAL_METHOD == 3 					 /* Allocate storage for CPU status register		   */
	OS_CPU_SR  cpu_sr = 0;
#endif



	p_arg = p_arg;  							 /* Prevent compiler warning for not using 'parg'      */
	while (OSStatRdy == OS_FALSE)
	{
		OSTimeDly(2 * OS_TICKS_PER_SEC / 10);    /* 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  					   */
#if (OS_TASK_STAT_STK_CHK_EN > 0) && (OS_TASK_CREATE_EXT_EN > 0)
		OS_TaskStatStkChk();					 /* Check the stacks for each task  				   */
#endif
		OSTimeDly(OS_TICKS_PER_SEC / 10);   	 /* Accumulate OSIdleCtr for the next 1/10 second      */
	}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*   								   CHECK ALL TASK STACKS
*
* Description: This function is called by OS_TaskStat() to check the stacks of each active task.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

#if (OS_TASK_STAT_STK_CHK_EN > 0) && (OS_TASK_CREATE_EXT_EN > 0)
void OS_TaskStatStkChk(void)
{
	OS_TCB  	*ptcb;
	OS_STK_DATA  stk_data;
	INT8U   	 err;
	INT8U   	 prio;


	for (prio = 0; prio <= OS_TASK_IDLE_PRIO; prio++)
	{
		err = OSTaskStkChk(prio, &stk_data);
		if (err == OS_ERR_NONE)
		{
			ptcb = OSTCBPrioTbl[prio];
			if (ptcb != (OS_TCB *) 0)
			{
				/* Make sure task 'ptcb' is ...   */
				if (ptcb != OS_TCB_RESERVED)
				{
					/* ... still valid. 			  */
#if OS_TASK_PROFILE_EN > 0
#if OS_STK_GROWTH == 1
					ptcb->OSTCBStkBase = ptcb->OSTCBStkBottom + ptcb->OSTCBStkSize;
#else
					ptcb->OSTCBStkBase = ptcb->OSTCBStkBottom - ptcb->OSTCBStkSize;
#endif
					ptcb->OSTCBStkUsed = stk_data.OSUsed;   		 /* Store the number of bytes used */
#endif
				}
			}
		}
	}
}
#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_ERR_NONE  	   if the call was successful
*   		   OS_ERR_TASK_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)
{
	OS_TCB    *ptcb;
#if OS_CRITICAL_METHOD == 3 							   /* Allocate storage for CPU status register */
	OS_CPU_SR  cpu_sr = 0;
#endif



	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 = prio; 					  /* Load task priority into TCB			  */
		ptcb->OSTCBStat = OS_STAT_RDY;  			  /* Task is ready to run   				  */
		ptcb->OSTCBStatPend = OS_STAT_PEND_OK;  		  /* Clear pend status  					  */
		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_ERR_NONE;
#endif

#if OS_LOWEST_PRIO <= 63
		ptcb->OSTCBY = (INT8U) (prio >> 3); 		/* Pre-compute X, Y, BitX and BitY  		*/
		ptcb->OSTCBBitY = (INT8U) (1 << ptcb->OSTCBY);
		ptcb->OSTCBX = (INT8U) (prio & 0x07);
		ptcb->OSTCBBitX = (INT8U) (1 << ptcb->OSTCBX);
#else
		ptcb->OSTCBY = (INT8U) ((prio >> 4) & 0xFF);/* Pre-compute X, Y, BitX and BitY  		*/
		ptcb->OSTCBBitY = (INT16U) (1 << ptcb->OSTCBY);
		ptcb->OSTCBX = (INT8U) (prio & 0x0F);
		ptcb->OSTCBBitX = (INT16U) (1 << ptcb->OSTCBX);
#endif

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

#if (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_TASK_PROFILE_EN > 0
		ptcb->OSTCBCtxSwCtr = 0L;   					/* Initialize profiling variables   		*/
		ptcb->OSTCBCyclesStart = 0L;
		ptcb->OSTCBCyclesTot = 0L;
		ptcb->OSTCBStkBase = (OS_STK *) 0;
		ptcb->OSTCBStkUsed = 0L;
#endif

#if OS_TASK_NAME_SIZE > 1
		ptcb->OSTCBTaskName[0] = '?';   				   /* Unknown name at task creation 		   */
		ptcb->OSTCBTaskName[1] = OS_ASCII_NUL;
#endif

		OSTCBInitHook(ptcb);

		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;
		OSTaskCtr++;									   /* Increment the #tasks counter  		   */
		OS_EXIT_CRITICAL();
		return (OS_ERR_NONE);
	}
	OS_EXIT_CRITICAL();
	return (OS_ERR_TASK_NO_MORE_TCB);
}