Initial import of FreeRTOS code for OpenPICC

git-svn-id: https://svn.openpcd.org:2342/trunk@311 6dc7ffe9-61d6-0310-9af1-9938baff3ed1

1 files changed, 1988 insertions, 0 deletions

diff --git a/openpicc/os/core/tasks.c b/openpicc/os/core/tasks.c
new file mode 100644
index 0000000..68a0dd9
--- /dev/null
+++ b/openpicc/os/core/tasks.c
@@ -0,0 +1,1988 @@
+/*
+	FreeRTOS.org V4.2.1 - Copyright (C) 2003-2007 Richard Barry.
+
+	This file is part of the FreeRTOS.org distribution.
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	FreeRTOS.org is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with FreeRTOS.org; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+	A special exception to the GPL can be applied should you wish to distribute
+	a combined work that includes FreeRTOS.org, without being obliged to provide
+	the source code for any proprietary components.  See the licensing section
+	of http://www.FreeRTOS.org for full details of how and when the exception
+	can be applied.
+
+	***************************************************************************
+	See http://www.FreeRTOS.org for documentation, latest information, license
+	and contact details.  Please ensure to read the configuration and relevant
+	port sections of the online documentation.
+
+	Also see http://www.SafeRTOS.com for an IEC 61508 compliant version, along
+	with development and support options.
+	***************************************************************************
+*/
+
+/*
+Changes from V1.00:
+	
+	+ Call to portRESTORE_CONTEXT has been removed.  The first context
+	  switch is now performed within sPortStartScheduler().
+
+Changes from V1.01:
+
+	+ More use of 8bit data types.
+	+ Function name prefixes changed where the data type returned has changed.
+	+ configUSE_TRACE_FACILITY is no longer defined by default.
+
+Changes from V1.2.0
+
+	+ Introduced ucTopReadyPriority.  This tracks the highest priority ready
+	  queue that contains a valid TCB and thus makes the context switch
+	  slightly faster.
+
+	+ prvAddTaskToReadyQueue() has been made a macro.
+
+Changes from V1.2.6
+
+	+ Added conditional compilation directives.
+	+ Extended API.
+	+ Rearranged function order.
+	+ Creating a task now causes a context switch if the task being created
+	  has a higher priority than the calling task - assuming the kernel is
+	  running.
+	+ vTaskDelete() now only causes a context switch if the calling task is
+	  the task being deleted.
+
+Changes from V2.0.0
+
+	+ Allow the type of the tick count to be 16 or 32 bits.
+	+ Introduce xPendingReadyList feature to allow the time interrupts have to
+	  be disabled to be minimised.
+	+ Remove the #if( INCLUDE_vTaskSuspendAll ) statements.  vTaskSuspendAll()
+	  is now always included as it is used by the scheduler itself.
+
+Changes from V2.1.0
+
+	+ Bug fix - pxCurrentTCB is now initialised before the call to
+	  prvInitializeTaskLists().  Previously pxCurrentTCB could be accessed
+	  while null.
+
+Changed from V2.1.1
+
+	+ Change to where lStackSize is declared within sTaskCreate() to prevent
+	  compiler warnings with 8051 port.
+
+Changes from V2.2.0
+
+	+ Explicit use of 'signed' qualifier on portCHAR types added.
+	+ Changed odd calculation of initial pxTopOfStack value when
+	  portSTACK_GROWTH < 0.
+	+ Removed pcVersionNumber definition.
+
+Changes from V2.5.3
+
+	+ cTaskResumeAll() modified to ensure it can be called prior to the task
+	  lists being initialised.
+
+Changes from V2.5.5
+
+	+ Added API function vTaskDelayUntil().
+	+ Added INCLUDE_vTaskDelay conditional compilation.
+
+Changes from V2.6.0
+
+ 	+ Updated the vWriteTraceToBuffer macro to always be 4 byte aligned so it
+	  can be used on ARM architectures.
+	+ tskMAX_TASK_NAME_LEN definition replaced with the port specific
+	  configMAX_TASK_NAME_LEN definition.
+	+ Removed the call to strcpy when copying across the task name into the
+	  TCB.
+	+ Added ucTasksDeleted variable to prevent vTaskSuspendAll() being called
+	  too often in the idle task.
+
+Changes between V3.0.0 and V2.6.1
+
+	+ When resuming the scheduler a yield is performed if either a tick has
+	  been missed, or a task is moved from the pending ready list into a ready
+	  list.  Previously a yield was not performed on this second condition.
+	+ Introduced the type portBASE_TYPE.  This necessitates several API
+	  changes.
+	+ Removed the sUsingPreemption variable.  The constant defined in
+	  portmacro.h is now used directly.
+	+ The idle task can now include an optional hook function - and no longer
+	  completes its time slice if other tasks with equal priority to it are
+	  ready to run.
+	+ See the FreeRTOS.org documentation for more information on V2.x.x to
+	  V3.x.x modifications.
+
+Changes from V3.1.1
+
+	+ Modified vTaskPrioritySet() and vTaskResume() to allow these functions to
+	  be called while the scheduler is suspended.
+	+ Corrected the task ordering within event lists.
+
+Changes from V3.2.0
+
+	+ Added function xTaskGetCurrentTaskHandle().
+
+Changes from V3.2.4
+
+	+ Changed the volatile declarations on some variables to reflect the 
+	  changes to the list definitions.
+	+ Changed the order of the TCB definition so there is commonality between
+	  the task control block and a co-routine control block.
+	+ Allow the scheduler to be started even if no tasks other than the idle
+	  task has been created.  This allows co-routines to run even when no tasks
+	  have been created.
+	+ The need for a context switch is now signalled if a task woken by an 
+	  event has a priority greater or equal to the currently running task.
+	  Previously this was only greater than.
+
+Changes from V4.0.0
+
+	+ Added the xMissedYield handling.
+
+Changes from V4.0.1
+
+	+ The function vTaskList() now suspends the scheduler rather than disabling
+	  interrupts during the creation of the task list.  
+	+ Allow a task to delete itself by passing in its own handle.  Previously 
+	  this could only be done by passing in NULL.
+	+ The tick hook function is now called only within a tick isr.  Previously
+	  it was also called when the tick function was called during the scheduler
+	  unlocking process.
+
+Changes from V4.0.3
+
+	+ Extra checks have been placed in vTaskPrioritySet() to avoid unnecessary
+	  yields.
+
+Changed from V4.0.4
+
+	+ Bug fix:  The 'value' of the event list item is updated when the priority
+	  of a task is changed.  Previously only the priority of the TCB itself was
+	  changed.
+	+ When resuming a task a check is first made to see if the task is actually
+	  suspended.
+	+ vTaskPrioritySet() and vTaskResume() no longer use the event list item.
+	  This has not been necessary since V4.0.1 when the xMissedYield handling
+	  was added.
+	+ Implement xTaskResumeFromISR().
+
+Changes from V4.0.5
+
+	+ Added utility functions and xOverflowCount variable to facilitate the
+	  queue.c changes.
+
+Changes from V4.1.2
+	
+	+ Tasks that block on events with a timeout of portMAX_DELAY are now
+	  blocked indefinitely if configINCLUDE_vTaskSuspend is defined. 
+	  Previously portMAX_DELAY was just the longest block time possible.
+
+Changes from V4.1.3
+
+	+ Very small change made to xTaskCheckForTimeout() as a result of the 
+	SafeRTOS testing.  This corrects the case where the function can return an
+	invalid value - but only in an extremely unlikely scenario.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+/*
+ * Macro to define the amount of stack available to the idle task.
+ */
+#define tskIDLE_STACK_SIZE	configMINIMAL_STACK_SIZE
+
+
+/*
+ * Default a definitions for backwards compatibility with old
+ * portmacro.h files.
+ */
+#ifndef configMAX_TASK_NAME_LEN
+#define configMAX_TASK_NAME_LEN 16
+#endif
+
+#ifndef INCLUDE_xTaskGetCurrentTaskHandle
+#define INCLUDE_xTaskGetCurrentTaskHandle 0
+#endif
+
+#ifndef configIDLE_SHOULD_YIELD
+#define configIDLE_SHOULD_YIELD		1
+#endif
+
+#if configMAX_TASK_NAME_LEN < 1
+#undef configMAX_TASK_NAME_LEN
+#define configMAX_TASK_NAME_LEN 1
+#endif
+
+#ifndef INCLUDE_xTaskResumeFromISR
+#define INCLUDE_xTaskResumeFromISR 1
+#endif
+
+/*
+ * Task control block.  A task control block (TCB) is allocated to each task,
+ * and stores the context of the task.
+ */
+typedef struct tskTaskControlBlock
+{
+  volatile portSTACK_TYPE *pxTopOfStack;	/*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE STRUCT. */
+  xListItem xGenericListItem;	/*< List item used to place the TCB in ready and blocked queues. */
+  xListItem xEventListItem;	/*< List item used to place the TCB in event lists. */
+  unsigned portBASE_TYPE uxPriority;	/*< The priority of the task where 0 is the lowest priority. */
+  portSTACK_TYPE *pxStack;	/*< Points to the start of the stack. */
+  unsigned portBASE_TYPE uxTCBNumber;	/*< This is used for tracing the scheduler and making debugging easier only. */
+  signed portCHAR pcTaskName[configMAX_TASK_NAME_LEN];	/*< Descriptive name given to the task when created.  Facilitates debugging only. */
+  unsigned portSHORT usStackDepth;	/*< Total depth of the stack (when empty).  This is defined as the number of variables the stack can hold, not the number of bytes. */
+} tskTCB;
+
+/*lint -e956 */
+
+tskTCB *volatile pxCurrentTCB = NULL;
+
+/* Lists for ready and blocked tasks. --------------------*/
+
+static xList pxReadyTasksLists[configMAX_PRIORITIES];	/*< Prioritised ready tasks. */
+static xList xDelayedTaskList1;	/*< Delayed tasks. */
+static xList xDelayedTaskList2;	/*< Delayed tasks (two lists are used - one for delays that have overflowed the current tick count. */
+static xList *volatile pxDelayedTaskList;	/*< Points to the delayed task list currently being used. */
+static xList *volatile pxOverflowDelayedTaskList;	/*< Points to the delayed task list currently being used to hold tasks that have overflowed the current tick count. */
+static xList xPendingReadyList;	/*< Tasks that have been readied while the scheduler was suspended.  They will be moved to the ready queue when the scheduler is resumed. */
+
+#if ( INCLUDE_vTaskDelete == 1 )
+
+static volatile xList xTasksWaitingTermination;	/*< Tasks that have been deleted - but the their memory not yet freed. */
+static volatile unsigned portBASE_TYPE uxTasksDeleted =
+  (unsigned portBASE_TYPE) 0;
+
+#endif
+
+#if ( INCLUDE_vTaskSuspend == 1 )
+
+static xList xSuspendedTaskList;	/*< Tasks that are currently suspended. */
+
+#endif
+
+/* File private variables. --------------------------------*/
+static volatile unsigned portBASE_TYPE uxCurrentNumberOfTasks =
+  (unsigned portBASE_TYPE) 0;
+static volatile portTickType xTickCount = (portTickType) 0;
+static unsigned portBASE_TYPE uxTopUsedPriority = tskIDLE_PRIORITY;
+static volatile unsigned portBASE_TYPE uxTopReadyPriority = tskIDLE_PRIORITY;
+static volatile signed portBASE_TYPE xSchedulerRunning = pdFALSE;
+static volatile unsigned portBASE_TYPE uxSchedulerSuspended =
+  (unsigned portBASE_TYPE) pdFALSE;
+static volatile unsigned portBASE_TYPE uxMissedTicks =
+  (unsigned portBASE_TYPE) 0;
+static volatile portBASE_TYPE xMissedYield = (portBASE_TYPE) pdFALSE;
+static volatile portBASE_TYPE xNumOfOverflows = (portBASE_TYPE) 0;
+/* Debugging and trace facilities private variables and macros. ------------*/
+
+/*
+ * The value used to fill the stack of a task when the task is created.  This
+ * is used purely for checking the high water mark for tasks.
+ */
+#define tskSTACK_FILL_BYTE	( 0xa5 )
+
+/*
+ * Macros used by vListTask to indicate which state a task is in.
+ */
+#define tskBLOCKED_CHAR		( ( signed portCHAR ) 'B' )
+#define tskREADY_CHAR		( ( signed portCHAR ) 'R' )
+#define tskDELETED_CHAR		( ( signed portCHAR ) 'D' )
+#define tskSUSPENDED_CHAR	( ( signed portCHAR ) 'S' )
+
+/*
+ * Macros and private variables used by the trace facility.
+ */
+#if ( configUSE_TRACE_FACILITY == 1 )
+
+#define tskSIZE_OF_EACH_TRACE_LINE			( ( unsigned portLONG ) ( sizeof( unsigned portLONG ) + sizeof( unsigned portLONG ) ) )
+static volatile signed portCHAR *volatile pcTraceBuffer;
+static signed portCHAR *pcTraceBufferStart;
+static signed portCHAR *pcTraceBufferEnd;
+static signed portBASE_TYPE xTracing = pdFALSE;
+
+#endif
+
+/*
+ * Macro that writes a trace of scheduler activity to a buffer.  This trace
+ * shows which task is running when and is very useful as a debugging tool.
+ * As this macro is called each context switch it is a good idea to undefine
+ * it if not using the facility.
+ */
+#if ( configUSE_TRACE_FACILITY == 1 )
+
+#define vWriteTraceToBuffer()																	\
+	{																								\
+		if( xTracing )																				\
+		{																							\
+			static unsigned portBASE_TYPE uxPreviousTask = 255;										\
+																									\
+			if( uxPreviousTask != pxCurrentTCB->uxTCBNumber )										\
+			{																						\
+				if( ( pcTraceBuffer + tskSIZE_OF_EACH_TRACE_LINE ) < pcTraceBufferEnd )				\
+				{																					\
+					uxPreviousTask = pxCurrentTCB->uxTCBNumber;										\
+					*( unsigned portLONG * ) pcTraceBuffer = ( unsigned portLONG ) xTickCount;		\
+					pcTraceBuffer += sizeof( unsigned portLONG );									\
+					*( unsigned portLONG * ) pcTraceBuffer = ( unsigned portLONG ) uxPreviousTask;	\
+					pcTraceBuffer += sizeof( unsigned portLONG );									\
+				}																					\
+				else																				\
+				{																					\
+					xTracing = pdFALSE;																\
+				}																					\
+			}																						\
+		}																							\
+	}
+
+#else
+
+#define vWriteTraceToBuffer()
+
+#endif
+
+
+/*
+ * Place the task represented by pxTCB into the appropriate ready queue for
+ * the task.  It is inserted at the end of the list.  One quirk of this is
+ * that if the task being inserted is at the same priority as the currently
+ * executing task, then it will only be rescheduled after the currently
+ * executing task has been rescheduled.
+ */
+#define prvAddTaskToReadyQueue( pxTCB )																			\
+{																												\
+	if( pxTCB->uxPriority > uxTopReadyPriority )																\
+	{																											\
+		uxTopReadyPriority = pxTCB->uxPriority;																	\
+	}																											\
+	vListInsertEnd( ( xList * ) &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) );	\
+}
+
+/*
+ * Macro that looks at the list of tasks that are currently delayed to see if
+ * any require waking.
+ *
+ * Tasks are stored in the queue in the order of their wake time - meaning
+ * once one tasks has been found whose timer has not expired we need not look
+ * any further down the list.
+ */
+#define prvCheckDelayedTasks()																						\
+{																													\
+register tskTCB *pxTCB;																								\
+																													\
+	while( ( pxTCB = ( tskTCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList ) ) != NULL )						\
+	{																												\
+		if( xTickCount < listGET_LIST_ITEM_VALUE( &( pxTCB->xGenericListItem ) ) )									\
+		{																											\
+			break;																									\
+		}																											\
+		vListRemove( &( pxTCB->xGenericListItem ) );																\
+		/* Is the task waiting on an event also? */																	\
+		if( pxTCB->xEventListItem.pvContainer )																		\
+		{																											\
+			vListRemove( &( pxTCB->xEventListItem ) );																\
+		}																											\
+		prvAddTaskToReadyQueue( pxTCB );														\
+	}																												\
+}
+
+/*
+ * Several functions take an xTaskHandle parameter that can optionally be NULL,
+ * where NULL is used to indicate that the handle of the currently executing
+ * task should be used in place of the parameter.  This macro simply checks to
+ * see if the parameter is NULL and returns a pointer to the appropriate TCB.
+ */
+#define prvGetTCBFromHandle( pxHandle ) ( ( pxHandle == NULL ) ? ( tskTCB * ) pxCurrentTCB : ( tskTCB * ) pxHandle )
+
+
+/* File private functions. --------------------------------*/
+
+/*
+ * Utility to ready a TCB for a given task.  Mainly just copies the parameters
+ * into the TCB structure.
+ */
+static void prvInitialiseTCBVariables (tskTCB * pxTCB,
+				       unsigned portSHORT usStackDepth,
+				       const signed portCHAR * const pcName,
+				       unsigned portBASE_TYPE uxPriority);
+
+/*
+ * Utility to ready all the lists used by the scheduler.  This is called
+ * automatically upon the creation of the first task.
+ */
+static void prvInitialiseTaskLists (void);
+
+/*
+ * The idle task, which as all tasks is implemented as a never ending loop.
+ * The idle task is automatically created and added to the ready lists upon
+ * creation of the first user task.
+ *
+ * The portTASK_FUNCTION_PROTO() macro is used to allow port/compiler specific
+ * language extensions.  The equivalent prototype for this function is:
+ *
+ * void prvIdleTask( void *pvParameters );
+ *
+ */
+static portTASK_FUNCTION_PROTO (prvIdleTask, pvParameters);
+
+/*
+ * Utility to free all memory allocated by the scheduler to hold a TCB,
+ * including the stack pointed to by the TCB.
+ *
+ * This does not free memory allocated by the task itself (i.e. memory
+ * allocated by calls to pvPortMalloc from within the tasks application code).
+ */
+#if ( ( INCLUDE_vTaskDelete == 1 ) || ( INCLUDE_vTaskCleanUpResources == 1 ) )
+static void prvDeleteTCB (tskTCB * pxTCB);
+#endif
+
+/*
+ * Used only by the idle task.  This checks to see if anything has been placed
+ * in the list of tasks waiting to be deleted.  If so the task is cleaned up
+ * and its TCB deleted.
+ */
+static void prvCheckTasksWaitingTermination (void);
+
+/*
+ * Allocates memory from the heap for a TCB and associated stack.  Checks the
+ * allocation was successful.
+ */
+static tskTCB *prvAllocateTCBAndStack (unsigned portSHORT usStackDepth);
+
+/*
+ * Called from vTaskList.  vListTasks details all the tasks currently under
+ * control of the scheduler.  The tasks may be in one of a number of lists.
+ * prvListTaskWithinSingleList accepts a list and details the tasks from
+ * within just that list.
+ *
+ * THIS FUNCTION IS INTENDED FOR DEBUGGING ONLY, AND SHOULD NOT BE CALLED FROM
+ * NORMAL APPLICATION CODE.
+ */
+#if ( configUSE_TRACE_FACILITY == 1 )
+
+static void prvListTaskWithinSingleList (signed portCHAR * pcWriteBuffer,
+					 xList * pxList,
+					 signed portCHAR cStatus);
+
+#endif
+
+/*
+ * When a task is created, the stack of the task is filled with a known value.
+ * This function determines the 'high water mark' of the task stack by
+ * determining how much of the stack remains at the original preset value.
+ */
+#if ( configUSE_TRACE_FACILITY == 1 )
+
+unsigned portSHORT usTaskCheckFreeStackSpace (const unsigned portCHAR *
+					      pucStackByte);
+
+#endif
+
+/*lint +e956 */
+
+
+
+
+
+/*-----------------------------------------------------------
+ * TASK CREATION API documented in task.h
+ *----------------------------------------------------------*/
+
+signed portBASE_TYPE
+xTaskCreate (pdTASK_CODE pvTaskCode, const signed portCHAR * const pcName,
+	     unsigned portSHORT usStackDepth, void *pvParameters,
+	     unsigned portBASE_TYPE uxPriority, xTaskHandle * pxCreatedTask)
+{
+  signed portBASE_TYPE xReturn;
+  tskTCB *pxNewTCB;
+  static unsigned portBASE_TYPE uxTaskNumber = 0;	/*lint !e956 Static is deliberate - this is guarded before use. */
+
+  /* Allocate the memory required by the TCB and stack for the new task.
+     checking that the allocation was successful. */
+  pxNewTCB = prvAllocateTCBAndStack (usStackDepth);
+
+  if (pxNewTCB != NULL)
+    {
+      portSTACK_TYPE *pxTopOfStack;
+
+      /* Setup the newly allocated TCB with the initial state of the task. */
+      prvInitialiseTCBVariables (pxNewTCB, usStackDepth, pcName, uxPriority);
+
+      /* Calculate the top of stack address.  This depends on whether the
+         stack grows from high memory to low (as per the 80x86) or visa versa.
+         portSTACK_GROWTH is used to make the result positive or negative as
+         required by the port. */
+#if portSTACK_GROWTH < 0
+      {
+	pxTopOfStack = pxNewTCB->pxStack + (pxNewTCB->usStackDepth - 1);
+      }
+#else
+      {
+	pxTopOfStack = pxNewTCB->pxStack;
+      }
+#endif
+
+      /* Initialize the TCB stack to look as if the task was already running,
+         but had been interrupted by the scheduler.  The return address is set
+         to the start of the task function. Once the stack has been initialised
+         the  top of stack variable is updated. */
+      pxNewTCB->pxTopOfStack =
+	pxPortInitialiseStack (pxTopOfStack, pvTaskCode, pvParameters);
+
+      /* We are going to manipulate the task queues to add this task to a
+         ready list, so must make sure no interrupts occur. */
+      portENTER_CRITICAL ();
+      {
+	uxCurrentNumberOfTasks++;
+	if (uxCurrentNumberOfTasks == (unsigned portBASE_TYPE) 1)
+	  {
+	    /* As this is the first task it must also be the current task. */
+	    pxCurrentTCB = pxNewTCB;
+
+	    /* This is the first task to be created so do the preliminary
+	       initialisation required.  We will not recover if this call
+	       fails, but we will report the failure. */
+	    prvInitialiseTaskLists ();
+	  }
+	else
+	  {
+	    /* If the scheduler is not already running, make this task the
+	       current task if it is the highest priority task to be created
+	       so far. */
+	    if (xSchedulerRunning == pdFALSE)
+	      {
+		if (pxCurrentTCB->uxPriority <= uxPriority)
+		  {
+		    pxCurrentTCB = pxNewTCB;
+		  }
+	      }
+	  }
+
+	/* Remember the top priority to make context switching faster.  Use
+	   the priority in pxNewTCB as this has been capped to a valid value. */
+	if (pxNewTCB->uxPriority > uxTopUsedPriority)
+	  {
+	    uxTopUsedPriority = pxNewTCB->uxPriority;
+	  }
+
+	/* Add a counter into the TCB for tracing only. */
+	pxNewTCB->uxTCBNumber = uxTaskNumber;
+	uxTaskNumber++;
+
+	prvAddTaskToReadyQueue (pxNewTCB);
+
+	xReturn = pdPASS;
+      }
+      portEXIT_CRITICAL ();
+    }
+  else
+    {
+      xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
+    }
+
+  if (xReturn == pdPASS)
+    {
+      if ((void *) pxCreatedTask != NULL)
+	{
+	  /* Pass the TCB out - in an anonymous way.  The calling function/
+	     task can use this as a handle to delete the task later if
+	     required. */
+	  *pxCreatedTask = (xTaskHandle) pxNewTCB;
+	}
+
+      if (xSchedulerRunning != pdFALSE)
+	{
+	  /* If the created task is of a higher priority than the current task
+	     then it should run now. */
+	  if (pxCurrentTCB->uxPriority < uxPriority)
+	    {
+	      taskYIELD ();
+	    }
+	}
+    }
+
+  return xReturn;
+}
+
+/*-----------------------------------------------------------*/
+
+#if ( INCLUDE_vTaskDelete == 1 )
+
+void
+vTaskDelete (xTaskHandle pxTaskToDelete)
+{
+  tskTCB *pxTCB;
+
+  taskENTER_CRITICAL ();
+  {
+    /* Ensure a yield is performed if the current task is being 
+       deleted. */
+    if (pxTaskToDelete == pxCurrentTCB)
+      {
+	pxTaskToDelete = NULL;
+      }
+
+    /* If null is passed in here then we are deleting ourselves. */
+    pxTCB = prvGetTCBFromHandle (pxTaskToDelete);
+
+    /* Remove task from the ready list and place in the     termination list.
+       This will stop the task from be scheduled.  The idle task will check
+       the termination list and free up any memory allocated by the
+       scheduler for the TCB and stack. */
+    vListRemove (&(pxTCB->xGenericListItem));
+
+    /* Is the task waiting on an event also? */
+    if (pxTCB->xEventListItem.pvContainer)
+      {
+	vListRemove (&(pxTCB->xEventListItem));
+      }
+
+    vListInsertEnd ((xList *) & xTasksWaitingTermination,
+		    &(pxTCB->xGenericListItem));
+
+    /* Increment the ucTasksDeleted variable so the idle task knows
+       there is a task that has been deleted and that it should therefore
+       check the xTasksWaitingTermination list. */
+    ++uxTasksDeleted;
+  }
+  taskEXIT_CRITICAL ();
+
+  /* Force a reschedule if we have just deleted the current task. */
+  if (xSchedulerRunning != pdFALSE)
+    {
+      if ((void *) pxTaskToDelete == NULL)
+	{
+	  taskYIELD ();
+	}
+    }
+}
+
+#endif
+
+
+
+
+
+
+/*-----------------------------------------------------------
+ * TASK CONTROL API documented in task.h
+ *----------------------------------------------------------*/
+
+#if ( INCLUDE_vTaskDelayUntil == 1 )
+
+void
+vTaskDelayUntil (portTickType * pxPreviousWakeTime,
+		 portTickType xTimeIncrement)
+{
+  portTickType xTimeToWake;
+  portBASE_TYPE xAlreadyYielded, xShouldDelay = pdFALSE;
+
+  vTaskSuspendAll ();
+  {
+    /* Generate the tick time at which the task wants to wake. */
+    xTimeToWake = *pxPreviousWakeTime + xTimeIncrement;
+
+    if (xTickCount < *pxPreviousWakeTime)
+      {
+	/* The tick count has overflowed since this function was
+	   lasted called.  In this case the only time we should ever
+	   actually delay is if the wake time has also  overflowed,
+	   and the wake time is greater than the tick time.  When this
+	   is the case it is as if neither time had overflowed. */
+	if ((xTimeToWake < *pxPreviousWakeTime) && (xTimeToWake > xTickCount))
+	  {
+	    xShouldDelay = pdTRUE;
+	  }
+      }
+    else
+      {
+	/* The tick time has not overflowed.  In this case we will
+	   delay if either the wake time has overflowed, and/or the
+	   tick time is less than the wake time. */
+	if ((xTimeToWake < *pxPreviousWakeTime) || (xTimeToWake > xTickCount))
+	  {
+	    xShouldDelay = pdTRUE;
+	  }
+      }
+
+    /* Update the wake time ready for the next call. */
+    *pxPreviousWakeTime = xTimeToWake;
+
+    if (xShouldDelay)
+      {
+	/* We must remove ourselves from the ready list before adding
+	   ourselves to the blocked list as the same list item is used for
+	   both lists. */
+	vListRemove ((xListItem *) & (pxCurrentTCB->xGenericListItem));
+
+	/* The list item will be inserted in wake time order. */
+	listSET_LIST_ITEM_VALUE (&(pxCurrentTCB->xGenericListItem),
+				 xTimeToWake);
+
+	if (xTimeToWake < xTickCount)
+	  {
+	    /* Wake time has overflowed.  Place this item in the
+	       overflow list. */
+	    vListInsert ((xList *) pxOverflowDelayedTaskList,
+			 (xListItem *) & (pxCurrentTCB->xGenericListItem));
+	  }
+	else
+	  {
+	    /* The wake time has not overflowed, so we can use the
+	       current block list. */
+	    vListInsert ((xList *) pxDelayedTaskList,
+			 (xListItem *) & (pxCurrentTCB->xGenericListItem));
+	  }
+      }
+  }
+  xAlreadyYielded = xTaskResumeAll ();
+
+  /* Force a reschedule if xTaskResumeAll has not already done so, we may
+     have put ourselves to sleep. */
+  if (!xAlreadyYielded)
+    {
+      taskYIELD ();
+    }
+}
+
+#endif
+/*-----------------------------------------------------------*/
+
+#if ( INCLUDE_vTaskDelay == 1 )
+
+void
+vTaskDelay (portTickType xTicksToDelay)
+{
+  portTickType xTimeToWake;
+  signed portBASE_TYPE xAlreadyYielded = pdFALSE;
+
+  /* A delay time of zero just forces a reschedule. */
+  if (xTicksToDelay > (portTickType) 0)
+    {
+      vTaskSuspendAll ();
+      {
+	/* A task that is removed from the event list while the
+	   scheduler is suspended will not get placed in the ready
+	   list or removed from the blocked list until the scheduler
+	   is resumed.
+
+	   This task cannot be in an event list as it is the currently
+	   executing task. */
+
+	/* Calculate the time to wake - this may overflow but this is
+	   not a problem. */
+	xTimeToWake = xTickCount + xTicksToDelay;
+
+	/* We must remove ourselves from the ready list before adding
+	   ourselves to the blocked list as the same list item is used for
+	   both lists. */
+	vListRemove ((xListItem *) & (pxCurrentTCB->xGenericListItem));
+
+	/* The list item will be inserted in wake time order. */
+	listSET_LIST_ITEM_VALUE (&(pxCurrentTCB->xGenericListItem),
+				 xTimeToWake);
+
+	if (xTimeToWake < xTickCount)
+	  {
+	    /* Wake time has overflowed.  Place this item in the
+	       overflow list. */
+	    vListInsert ((xList *) pxOverflowDelayedTaskList,
+			 (xListItem *) & (pxCurrentTCB->xGenericListItem));
+	  }
+	else
+	  {
+	    /* The wake time has not overflowed, so we can use the
+	       current block list. */
+	    vListInsert ((xList *) pxDelayedTaskList,
+			 (xListItem *) & (pxCurrentTCB->xGenericListItem));
+	  }
+      }
+      xAlreadyYielded = xTaskResumeAll ();
+    }
+
+  /* Force a reschedule if xTaskResumeAll has not already done so, we may
+     have put ourselves to sleep. */
+  if (!xAlreadyYielded)
+    {
+      taskYIELD ();
+    }
+}
+
+#endif
+/*-----------------------------------------------------------*/
+
+#if ( INCLUDE_uxTaskPriorityGet == 1 )
+
+unsigned portBASE_TYPE
+uxTaskPriorityGet (xTaskHandle pxTask)
+{
+  tskTCB *pxTCB;
+  unsigned portBASE_TYPE uxReturn;
+
+  taskENTER_CRITICAL ();
+  {
+    /* If null is passed in here then we are changing the
+       priority of the calling function. */
+    pxTCB = prvGetTCBFromHandle (pxTask);
+    uxReturn = pxTCB->uxPriority;
+  }
+  taskEXIT_CRITICAL ();
+
+  return uxReturn;
+}
+
+#endif
+/*-----------------------------------------------------------*/
+
+#if ( INCLUDE_vTaskPrioritySet == 1 )
+
+void
+vTaskPrioritySet (xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority)
+{
+  tskTCB *pxTCB;
+  unsigned portBASE_TYPE uxCurrentPriority, xYieldRequired = pdFALSE;
+
+  /* Ensure the new priority is valid. */
+  if (uxNewPriority >= configMAX_PRIORITIES)
+    {
+      uxNewPriority = configMAX_PRIORITIES - 1;
+    }
+
+  taskENTER_CRITICAL ();
+  {
+    /* If null is passed in here then we are changing the
+       priority of the calling function. */
+    pxTCB = prvGetTCBFromHandle (pxTask);
+    uxCurrentPriority = pxTCB->uxPriority;
+
+    if (uxCurrentPriority != uxNewPriority)
+      {
+	/* The priority change may have readied a task of higher
+	   priority than the calling task. */
+	if (uxNewPriority > pxCurrentTCB->uxPriority)
+	  {
+	    if (pxTask != NULL)
+	      {
+		/* The priority of another task is being raised.  If we
+		   were raising the priority of the currently running task
+		   there would be no need to switch as it must have already
+		   been the highest priority task. */
+		xYieldRequired = pdTRUE;
+	      }
+	  }
+	else if (pxTask == NULL)
+	  {
+	    /* Setting our own priority down means there may now be another
+	       task of higher priority that is ready to execute. */
+	    xYieldRequired = pdTRUE;
+	  }
+
+	pxTCB->uxPriority = uxNewPriority;
+	listSET_LIST_ITEM_VALUE (&(pxTCB->xEventListItem),
+				 configMAX_PRIORITIES -
+				 (portTickType) uxNewPriority);
+
+	/* If the task is in the blocked or suspended list we need do
+	   nothing more than change it's priority variable. However, if
+	   the task is in a ready list it needs to be removed and placed
+	   in the queue appropriate to its new priority. */
+	if (listIS_CONTAINED_WITHIN
+	    (&(pxReadyTasksLists[uxCurrentPriority]),
+	     &(pxTCB->xGenericListItem)))
+	  {
+	    /* The task is currently in its ready list - remove before adding
+	       it to it's new ready list.  As we are in a critical section we
+	       can do this even if the scheduler is suspended. */
+	    vListRemove (&(pxTCB->xGenericListItem));
+	    prvAddTaskToReadyQueue (pxTCB);
+	  }
+
+	if (xYieldRequired == pdTRUE)
+	  {
+	    taskYIELD ();
+	  }
+      }
+  }
+  taskEXIT_CRITICAL ();
+}
+
+#endif
+/*-----------------------------------------------------------*/
+
+#if ( INCLUDE_vTaskSuspend == 1 )
+
+void
+vTaskSuspend (xTaskHandle pxTaskToSuspend)
+{
+  tskTCB *pxTCB;
+
+  taskENTER_CRITICAL ();
+  {
+    /* Ensure a yield is performed if the current task is being 
+       suspended. */
+    if (pxTaskToSuspend == pxCurrentTCB)
+      {
+	pxTaskToSuspend = NULL;
+      }
+
+    /* If null is passed in here then we are suspending ourselves. */
+    pxTCB = prvGetTCBFromHandle (pxTaskToSuspend);
+
+    /* Remove task from the ready/delayed list and place in the     suspended list. */
+    vListRemove (&(pxTCB->xGenericListItem));
+
+    /* Is the task waiting on an event also? */
+    if (pxTCB->xEventListItem.pvContainer)
+      {
+	vListRemove (&(pxTCB->xEventListItem));
+      }
+
+    vListInsertEnd ((xList *) & xSuspendedTaskList,
+		    &(pxTCB->xGenericListItem));
+  }
+  taskEXIT_CRITICAL ();
+
+  /* We may have just suspended the current task. */
+  if ((void *) pxTaskToSuspend == NULL)
+    {
+      taskYIELD ();
+    }
+}
+
+#endif
+/*-----------------------------------------------------------*/
+
+#if ( INCLUDE_vTaskSuspend == 1 )
+
+void
+vTaskResume (xTaskHandle pxTaskToResume)
+{
+  tskTCB *pxTCB;
+
+  /* Remove the task from whichever list it is currently in, and place
+     it in the ready list. */
+  pxTCB = (tskTCB *) pxTaskToResume;
+
+  /* The parameter cannot be NULL as it is impossible to resume the
+     currently executing task. */
+  if (pxTCB != NULL)
+    {
+      taskENTER_CRITICAL ();
+      {
+	/* Is the task we are attempting to resume actually suspended? */
+	if (listIS_CONTAINED_WITHIN
+	    (&xSuspendedTaskList, &(pxTCB->xGenericListItem)) != pdFALSE)
+	  {
+	    /* Has the task already been resumed from within an ISR? */
+	    if (listIS_CONTAINED_WITHIN
+		(&xPendingReadyList, &(pxTCB->xEventListItem)) != pdTRUE)
+	      {
+		/* As we are in a critical section we can access the ready 
+		   lists even if the scheduler is suspended. */
+		vListRemove (&(pxTCB->xGenericListItem));
+		prvAddTaskToReadyQueue (pxTCB);
+
+		/* We may have just resumed a higher priority task. */
+		if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority)
+		  {
+		    /* This yield may not cause the task just resumed to run, but
+		       will leave the lists in the correct state for the next yield. */
+		    taskYIELD ();
+		  }
+	      }
+	  }
+      }
+      taskEXIT_CRITICAL ();
+    }
+}
+
+#endif
+
+/*-----------------------------------------------------------*/
+
+#if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )
+
+portBASE_TYPE
+xTaskResumeFromISR (xTaskHandle pxTaskToResume)
+{
+  portBASE_TYPE xYieldRequired = pdFALSE;
+  tskTCB *pxTCB;
+
+  pxTCB = (tskTCB *) pxTaskToResume;
+
+  /* Is the task we are attempting to resume actually suspended? */
+  if (listIS_CONTAINED_WITHIN
+      (&xSuspendedTaskList, &(pxTCB->xGenericListItem)) != pdFALSE)
+    {
+      /* Has the task already been resumed from within an ISR? */
+      if (listIS_CONTAINED_WITHIN
+	  (&xPendingReadyList, &(pxTCB->xEventListItem)) != pdTRUE)
+	{
+	  if (uxSchedulerSuspended == (unsigned portBASE_TYPE) pdFALSE)
+	    {
+	      xYieldRequired =
+		(pxTCB->uxPriority >= pxCurrentTCB->uxPriority);
+	      vListRemove (&(pxTCB->xGenericListItem));
+	      prvAddTaskToReadyQueue (pxTCB);
+	    }
+	  else
+	    {
+	      /* We cannot access the delayed or ready lists, so will hold this
+	         task pending until the scheduler is resumed, at which point a 
+	         yield will be preformed if necessary. */
+	      vListInsertEnd ((xList *) & (xPendingReadyList),
+			      &(pxTCB->xEventListItem));
+	    }
+	}
+    }
+
+  return xYieldRequired;
+}
+
+#endif
+
+
+
+
+/*-----------------------------------------------------------
+ * PUBLIC SCHEDULER CONTROL documented in task.h
+ *----------------------------------------------------------*/
+
+
+void
+vTaskStartScheduler (void)
+{
+  portBASE_TYPE xReturn;
+
+  /* Add the idle task at the lowest priority. */
+  xReturn =
+    xTaskCreate (prvIdleTask, (signed portCHAR *) "IDLE", tskIDLE_STACK_SIZE,
+		 (void *) NULL, tskIDLE_PRIORITY, (xTaskHandle *) NULL);
+
+  if (xReturn == pdPASS)
+    {
+      /* Interrupts are turned off here, to ensure a tick does not occur
+         before or during the call to xPortStartScheduler().  The stacks of
+         the created tasks contain a status word with interrupts switched on
+         so interrupts will automatically get re-enabled when the first task
+         starts to run.
+
+         STEPPING THROUGH HERE USING A DEBUGGER CAN CAUSE BIG PROBLEMS IF THE
+         DEBUGGER ALLOWS INTERRUPTS TO BE PROCESSED. */
+      portDISABLE_INTERRUPTS ();
+
+      xSchedulerRunning = pdTRUE;
+      xTickCount = (portTickType) 0;
+
+      /* Setting up the timer tick is hardware specific and thus in the
+         portable interface. */
+      if (xPortStartScheduler ())
+	{
+	  /* Should not reach here as if the scheduler is running the
+	     function will not return. */
+	}
+      else
+	{
+	  /* Should only reach here if a task calls xTaskEndScheduler(). */
+	}
+    }
+}
+
+/*-----------------------------------------------------------*/
+
+void
+vTaskEndScheduler (void)
+{
+  /* Stop the scheduler interrupts and call the portable scheduler end
+     routine so the original ISRs can be restored if necessary.  The port
+     layer must ensure interrupts enable  bit is left in the correct state. */
+  portDISABLE_INTERRUPTS ();
+  xSchedulerRunning = pdFALSE;
+  vPortEndScheduler ();
+}
+
+/*----------------------------------------------------------*/
+
+void
+vTaskSuspendAll (void)
+{
+  portENTER_CRITICAL ();
+  ++uxSchedulerSuspended;
+  portEXIT_CRITICAL ();
+}
+
+/*----------------------------------------------------------*/
+
+signed portBASE_TYPE
+xTaskResumeAll (void)
+{
+  register tskTCB *pxTCB;
+  signed portBASE_TYPE xAlreadyYielded = pdFALSE;
+
+  /* It is possible that an ISR caused a task to be removed from an event
+     list while the scheduler was suspended.  If this was the case then the
+     removed task will have been added to the xPendingReadyList.  Once the
+     scheduler has been resumed it is safe to move all the pending ready
+     tasks from this list into their appropriate ready list. */
+  portENTER_CRITICAL ();
+  {
+    --uxSchedulerSuspended;
+
+    if (uxSchedulerSuspended == (unsigned portBASE_TYPE) pdFALSE)
+      {
+	if (uxCurrentNumberOfTasks > (unsigned portBASE_TYPE) 0)
+	  {
+	    portBASE_TYPE xYieldRequired = pdFALSE;
+
+	    /* Move any readied tasks from the pending list into the
+	       appropriate ready list. */
+	    while ((pxTCB =
+		    (tskTCB *)
+		    listGET_OWNER_OF_HEAD_ENTRY (((xList *) &
+						  xPendingReadyList))) !=
+		   NULL)
+	      {
+		vListRemove (&(pxTCB->xEventListItem));
+		vListRemove (&(pxTCB->xGenericListItem));
+		prvAddTaskToReadyQueue (pxTCB);
+
+		/* If we have moved a task that has a priority higher than
+		   the current task then we should yield. */
+		if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority)
+		  {
+		    xYieldRequired = pdTRUE;
+		  }
+	      }
+
+	    /* If any ticks occurred while the scheduler was suspended then
+	       they should be processed now.  This ensures the tick count does not
+	       slip, and that any delayed tasks are resumed at the correct time. */
+	    if (uxMissedTicks > (unsigned portBASE_TYPE) 0)
+	      {
+		while (uxMissedTicks > (unsigned portBASE_TYPE) 0)
+		  {
+		    vTaskIncrementTick ();
+		    --uxMissedTicks;
+		  }
+
+		/* As we have processed some ticks it is appropriate to yield
+		   to ensure the highest priority task that is ready to run is
+		   the task actually running. */
+		xYieldRequired = pdTRUE;
+	      }
+
+	    if ((xYieldRequired == pdTRUE) || (xMissedYield == pdTRUE))
+	      {
+		xAlreadyYielded = pdTRUE;
+		xMissedYield = pdFALSE;
+		taskYIELD ();
+	      }
+	  }
+      }
+  }
+  portEXIT_CRITICAL ();
+
+  return xAlreadyYielded;
+}
+
+
+
+
+
+
+/*-----------------------------------------------------------
+ * PUBLIC TASK UTILITIES documented in task.h
+ *----------------------------------------------------------*/
+
+
+
+portTickType
+xTaskGetTickCount (void)
+{
+  portTickType xTicks;
+
+  /* Critical section required if running on a 16 bit processor. */
+  taskENTER_CRITICAL ();
+  {
+    xTicks = xTickCount;
+  }
+  taskEXIT_CRITICAL ();
+
+  return xTicks;
+}
+
+/*-----------------------------------------------------------*/
+
+unsigned portBASE_TYPE
+uxTaskGetNumberOfTasks (void)
+{
+  unsigned portBASE_TYPE uxNumberOfTasks;
+
+  taskENTER_CRITICAL ();
+  uxNumberOfTasks = uxCurrentNumberOfTasks;
+  taskEXIT_CRITICAL ();
+
+  return uxNumberOfTasks;
+}
+
+/*-----------------------------------------------------------*/
+
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_vTaskDelete == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )
+
+void
+vTaskList (signed portCHAR * pcWriteBuffer)
+{
+  unsigned portBASE_TYPE uxQueue;
+
+  /* This is a VERY costly function that should be used for debug only.
+     It leaves interrupts disabled for a LONG time. */
+
+  vTaskSuspendAll ();
+  {
+    /* Run through all the lists that could potentially contain a TCB and
+       report the task name, state and stack high water mark. */
+
+    pcWriteBuffer[0] = (signed portCHAR) 0x00;
+    strcat ((portCHAR *) pcWriteBuffer, (const portCHAR *) "\r\n");
+
+    uxQueue = uxTopUsedPriority + 1;
+
+    do
+      {
+	uxQueue--;
+
+	if (!listLIST_IS_EMPTY (&(pxReadyTasksLists[uxQueue])))
+	  {
+	    prvListTaskWithinSingleList (pcWriteBuffer,
+					 (xList *) &
+					 (pxReadyTasksLists[uxQueue]),
+					 tskREADY_CHAR);
+	  }
+      }
+    while (uxQueue > (unsigned portSHORT) tskIDLE_PRIORITY);
+
+    if (!listLIST_IS_EMPTY (pxDelayedTaskList))
+      {
+	prvListTaskWithinSingleList (pcWriteBuffer,
+				     (xList *) pxDelayedTaskList,
+				     tskBLOCKED_CHAR);
+      }
+
+    if (!listLIST_IS_EMPTY (pxOverflowDelayedTaskList))
+      {
+	prvListTaskWithinSingleList (pcWriteBuffer,
+				     (xList *) pxOverflowDelayedTaskList,
+				     tskBLOCKED_CHAR);
+      }
+
+    if (!listLIST_IS_EMPTY (&xTasksWaitingTermination))
+      {
+	prvListTaskWithinSingleList (pcWriteBuffer,
+				     (xList *) & xTasksWaitingTermination,
+				     tskDELETED_CHAR);
+      }
+
+    if (!listLIST_IS_EMPTY (&xSuspendedTaskList))
+      {
+	prvListTaskWithinSingleList (pcWriteBuffer,
+				     (xList *) & xSuspendedTaskList,
+				     tskSUSPENDED_CHAR);
+      }
+  }
+  xTaskResumeAll ();
+}
+
+#endif
+/*----------------------------------------------------------*/
+
+#if ( configUSE_TRACE_FACILITY == 1 )
+
+void
+vTaskStartTrace (signed portCHAR * pcBuffer, unsigned portLONG ulBufferSize)
+{
+  portENTER_CRITICAL ();
+  {
+    pcTraceBuffer = (volatile signed portCHAR * volatile) pcBuffer;
+    pcTraceBufferStart = pcBuffer;
+    pcTraceBufferEnd = pcBuffer + (ulBufferSize - tskSIZE_OF_EACH_TRACE_LINE);
+    xTracing = pdTRUE;
+  }
+  portEXIT_CRITICAL ();
+}
+
+#endif
+/*----------------------------------------------------------*/
+
+#if ( configUSE_TRACE_FACILITY == 1 )
+
+unsigned portLONG
+ulTaskEndTrace (void)
+{
+  unsigned portLONG ulBufferLength;
+
+  portENTER_CRITICAL ();
+  xTracing = pdFALSE;
+  portEXIT_CRITICAL ();
+
+  ulBufferLength = (unsigned portLONG) (pcTraceBuffer - pcTraceBufferStart);
+
+  return ulBufferLength;
+}
+
+#endif
+
+
+
+/*-----------------------------------------------------------
+ * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
+ * documented in task.h
+ *----------------------------------------------------------*/
+
+
+inline void
+vTaskIncrementTick (void)
+{
+  /* Called by the portable layer each time a tick interrupt occurs.
+     Increments the tick then checks to see if the new tick value will cause any
+     tasks to be unblocked. */
+  if (uxSchedulerSuspended == (unsigned portBASE_TYPE) pdFALSE)
+    {
+      ++xTickCount;
+      if (xTickCount == (portTickType) 0)
+	{
+	  xList *pxTemp;
+
+	  /* Tick count has overflowed so we need to swap the delay lists.  
+	     If there are any items in pxDelayedTaskList here then there is 
+	     an error! */
+	  pxTemp = pxDelayedTaskList;
+	  pxDelayedTaskList = pxOverflowDelayedTaskList;
+	  pxOverflowDelayedTaskList = pxTemp;
+	  xNumOfOverflows++;
+	}
+
+      /* See if this tick has made a timeout expire. */
+      prvCheckDelayedTasks ();
+    }
+  else
+    {
+      ++uxMissedTicks;
+
+      /* The tick hook gets called at regular intervals, even if the 
+         scheduler is locked. */
+#if ( configUSE_TICK_HOOK == 1 )
+      {
+	extern void vApplicationTickHook (void);
+
+	vApplicationTickHook ();
+      }
+#endif
+    }
+
+#if ( configUSE_TICK_HOOK == 1 )
+  {
+    extern void vApplicationTickHook (void);
+
+    /* Guard against the tick hook being called when the missed tick
+       count is being unwound (when the scheduler is being unlocked. */
+    if (uxMissedTicks == 0)
+      {
+	vApplicationTickHook ();
+      }
+  }
+#endif
+}
+
+/*-----------------------------------------------------------*/
+
+#if ( ( INCLUDE_vTaskCleanUpResources == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )
+
+void
+vTaskCleanUpResources (void)
+{
+  unsigned portSHORT usQueue;
+  volatile tskTCB *pxTCB;
+
+  usQueue = (unsigned portSHORT) uxTopUsedPriority + (unsigned portSHORT) 1;
+
+  /* Remove any TCB's from the ready queues. */
+  do
+    {
+      usQueue--;
+
+      while (!listLIST_IS_EMPTY (&(pxReadyTasksLists[usQueue])))
+	{
+	  listGET_OWNER_OF_NEXT_ENTRY (pxTCB, &(pxReadyTasksLists[usQueue]));
+	  vListRemove ((xListItem *) & (pxTCB->xGenericListItem));
+
+	  prvDeleteTCB ((tskTCB *) pxTCB);
+	}
+    }
+  while (usQueue > (unsigned portSHORT) tskIDLE_PRIORITY);
+
+  /* Remove any TCB's from the delayed queue. */
+  while (!listLIST_IS_EMPTY (&xDelayedTaskList1))
+    {
+      listGET_OWNER_OF_NEXT_ENTRY (pxTCB, &xDelayedTaskList1);
+      vListRemove ((xListItem *) & (pxTCB->xGenericListItem));
+
+      prvDeleteTCB ((tskTCB *) pxTCB);
+    }
+
+  /* Remove any TCB's from the overflow delayed queue. */
+  while (!listLIST_IS_EMPTY (&xDelayedTaskList2))
+    {
+      listGET_OWNER_OF_NEXT_ENTRY (pxTCB, &xDelayedTaskList2);
+      vListRemove ((xListItem *) & (pxTCB->xGenericListItem));
+
+      prvDeleteTCB ((tskTCB *) pxTCB);
+    }
+
+  while (!listLIST_IS_EMPTY (&xSuspendedTaskList))
+    {
+      listGET_OWNER_OF_NEXT_ENTRY (pxTCB, &xSuspendedTaskList);
+      vListRemove ((xListItem *) & (pxTCB->xGenericListItem));
+
+      prvDeleteTCB ((tskTCB *) pxTCB);
+    }
+
+  while (!listLIST_IS_EMPTY (&xPendingReadyList))
+    {
+      listGET_OWNER_OF_NEXT_ENTRY (pxTCB, &xPendingReadyList);
+      vListRemove ((xListItem *) & (pxTCB->xGenericListItem));
+
+      prvDeleteTCB ((tskTCB *) pxTCB);
+    }
+}
+
+#endif
+/*-----------------------------------------------------------*/
+
+void
+vTaskSwitchContext (void)
+{
+  if (uxSchedulerSuspended != (unsigned portBASE_TYPE) pdFALSE)
+    {
+      /* The scheduler is currently suspended - do not allow a context
+         switch. */
+      xMissedYield = pdTRUE;
+      return;
+    }
+
+  /* Find the highest priority queue that contains ready tasks. */
+  while (listLIST_IS_EMPTY (&(pxReadyTasksLists[uxTopReadyPriority])))
+    {
+      --uxTopReadyPriority;
+    }
+
+  /* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the tasks of the
+     same priority get an equal share of the processor time. */
+  listGET_OWNER_OF_NEXT_ENTRY (pxCurrentTCB,
+			       &(pxReadyTasksLists[uxTopReadyPriority]));
+  vWriteTraceToBuffer ();
+}
+
+/*-----------------------------------------------------------*/
+
+void
+vTaskPlaceOnEventList (xList * pxEventList, portTickType xTicksToWait)
+{
+  portTickType xTimeToWake;
+
+  /* THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED OR THE
+     SCHEDULER SUSPENDED. */
+
+  /* Place the event list item of the TCB in the appropriate event list.
+     This is placed in the list in priority order so the highest priority task
+     is the first to be woken by the event. */
+  vListInsert ((xList *) pxEventList,
+	       (xListItem *) & (pxCurrentTCB->xEventListItem));
+
+  /* We must remove ourselves from the ready list before adding ourselves
+     to the blocked list as the same list item is used for both lists.  We have
+     exclusive access to the ready lists as the scheduler is locked. */
+  vListRemove ((xListItem *) & (pxCurrentTCB->xGenericListItem));
+
+
+#if ( INCLUDE_vTaskSuspend == 1 )
+  {
+    if (xTicksToWait == portMAX_DELAY)
+      {
+	/* Add ourselves to the suspended task list instead of a delayed task
+	   list to ensure we are not woken by a timing event.  We will block
+	   indefinitely. */
+	vListInsertEnd ((xList *) & xSuspendedTaskList,
+			(xListItem *) & (pxCurrentTCB->xGenericListItem));
+      }
+    else
+      {
+	/* Calculate the time at which the task should be woken if the event does
+	   not occur.  This may overflow but this doesn't matter. */
+	xTimeToWake = xTickCount + xTicksToWait;
+
+	listSET_LIST_ITEM_VALUE (&(pxCurrentTCB->xGenericListItem),
+				 xTimeToWake);
+
+	if (xTimeToWake < xTickCount)
+	  {
+	    /* Wake time has overflowed.  Place this item in the overflow list. */
+	    vListInsert ((xList *) pxOverflowDelayedTaskList,
+			 (xListItem *) & (pxCurrentTCB->xGenericListItem));
+	  }
+	else
+	  {
+	    /* The wake time has not overflowed, so we can use the current block list. */
+	    vListInsert ((xList *) pxDelayedTaskList,
+			 (xListItem *) & (pxCurrentTCB->xGenericListItem));
+	  }
+      }
+  }
+#else
+  {
+    /* Calculate the time at which the task should be woken if the event does
+       not occur.  This may overflow but this doesn't matter. */
+    xTimeToWake = xTickCount + xTicksToWait;
+
+    listSET_LIST_ITEM_VALUE (&(pxCurrentTCB->xGenericListItem), xTimeToWake);
+
+    if (xTimeToWake < xTickCount)
+      {
+	/* Wake time has overflowed.  Place this item in the overflow list. */
+	vListInsert ((xList *) pxOverflowDelayedTaskList,
+		     (xListItem *) & (pxCurrentTCB->xGenericListItem));
+      }
+    else
+      {
+	/* The wake time has not overflowed, so we can use the current block list. */
+	vListInsert ((xList *) pxDelayedTaskList,
+		     (xListItem *) & (pxCurrentTCB->xGenericListItem));
+      }
+  }
+#endif
+}
+
+/*-----------------------------------------------------------*/
+
+signed portBASE_TYPE
+xTaskRemoveFromEventList (const xList * pxEventList)
+{
+  tskTCB *pxUnblockedTCB;
+  portBASE_TYPE xReturn;
+
+  /* THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED OR THE
+     SCHEDULER SUSPENDED.  It can also be called from within an ISR. */
+
+  /* The event list is sorted in priority order, so we can remove the
+     first in the list, remove the TCB from the delayed list, and add
+     it to the ready list.
+
+     If an event is for a queue that is locked then this function will never
+     get called - the lock count on the queue will get modified instead.  This
+     means we can always expect exclusive access to the event list here. */
+  pxUnblockedTCB = (tskTCB *) listGET_OWNER_OF_HEAD_ENTRY (pxEventList);
+  vListRemove (&(pxUnblockedTCB->xEventListItem));
+
+  if (uxSchedulerSuspended == (unsigned portBASE_TYPE) pdFALSE)
+    {
+      vListRemove (&(pxUnblockedTCB->xGenericListItem));
+      prvAddTaskToReadyQueue (pxUnblockedTCB);
+    }
+  else
+    {
+      /* We cannot access the delayed or ready lists, so will hold this
+         task pending until the scheduler is resumed. */
+      vListInsertEnd ((xList *) & (xPendingReadyList),
+		      &(pxUnblockedTCB->xEventListItem));
+    }
+
+  if (pxUnblockedTCB->uxPriority >= pxCurrentTCB->uxPriority)
+    {
+      /* Return true if the task removed from the event list has
+         a higher priority than the calling task.  This allows
+         the calling task to know if it should force a context
+         switch now. */
+      xReturn = pdTRUE;
+    }
+  else
+    {
+      xReturn = pdFALSE;
+    }
+
+  return xReturn;
+}
+
+/*-----------------------------------------------------------*/
+
+void
+vTaskSetTimeOutState (xTimeOutType * pxTimeOut)
+{
+  pxTimeOut->xOverflowCount = xNumOfOverflows;
+  pxTimeOut->xTimeOnEntering = xTickCount;
+}
+
+/*-----------------------------------------------------------*/
+
+portBASE_TYPE
+xTaskCheckForTimeOut (xTimeOutType * pxTimeOut, portTickType * pxTicksToWait)
+{
+  portBASE_TYPE xReturn;
+
+  if ((xNumOfOverflows != pxTimeOut->xOverflowCount)
+      && (xTickCount >= pxTimeOut->xTimeOnEntering))
+    {
+      /* The tick count is greater than the time at which vTaskSetTimeout() 
+         was called, but has also overflowed since vTaskSetTimeOut() was called.
+         It must have wrapped all the way around and gone past us again. This
+         passed since vTaskSetTimeout() was called. */
+      xReturn = pdTRUE;
+    }
+  else if ((xTickCount - pxTimeOut->xTimeOnEntering) < *pxTicksToWait)
+    {
+      /* Not a genuine timeout. Adjust parameters for time remaining. */
+      *pxTicksToWait -= (xTickCount - pxTimeOut->xTimeOnEntering);
+      vTaskSetTimeOutState (pxTimeOut);
+      xReturn = pdFALSE;
+    }
+  else
+    {
+      xReturn = pdTRUE;
+    }
+
+  return xReturn;
+}
+
+/*-----------------------------------------------------------*/
+
+void
+vTaskMissedYield (void)
+{
+  xMissedYield = pdTRUE;
+}
+
+/*
+ * -----------------------------------------------------------
+ * The Idle task.
+ * ----------------------------------------------------------
+ *
+ * The portTASK_FUNCTION() macro is used to allow port/compiler specific
+ * language extensions.  The equivalent prototype for this function is:
+ *
+ * void prvIdleTask( void *pvParameters );
+ *
+ */
+static
+portTASK_FUNCTION (prvIdleTask, pvParameters)
+{
+  /* Stop warnings. */
+  (void) pvParameters;
+
+  for (;;)
+    {
+      /* See if any tasks have been deleted. */
+      prvCheckTasksWaitingTermination ();
+
+#if ( configUSE_PREEMPTION == 0 )
+      {
+	/* If we are not using preemption we keep forcing a task switch to
+	   see if any other task has become available.  If we are using
+	   preemption we don't need to do this as any task becoming available
+	   will automatically get the processor anyway. */
+	taskYIELD ();
+      }
+#endif
+
+#if ( ( configUSE_PREEMPTION == 1 ) && ( configIDLE_SHOULD_YIELD == 1 ) )
+      {
+	/* When using preemption tasks of equal priority will be
+	   timesliced.  If a task that is sharing the idle priority is ready
+	   to run then the idle task should yield before the end of the
+	   timeslice.
+
+	   A critical region is not required here as we are just reading from
+	   the list, and an occasional incorrect value will not matter.  If
+	   the ready list at the idle priority contains more than one task
+	   then a task other than the idle task is ready to execute. */
+	if (listCURRENT_LIST_LENGTH (&(pxReadyTasksLists[tskIDLE_PRIORITY])) >
+	    (unsigned portBASE_TYPE) 1)
+	  {
+	    taskYIELD ();
+	  }
+      }
+#endif
+
+#if ( configUSE_IDLE_HOOK == 1 )
+      {
+	extern void vApplicationIdleHook (void);
+
+	/* Call the user defined function from within the idle task.  This
+	   allows the application designer to add background functionality
+	   without the overhead of a separate task.
+	   NOTE: vApplicationIdleHook() MUST NOT, UNDER ANY CIRCUMSTANCES,
+	   CALL A FUNCTION THAT MIGHT BLOCK. */
+	vApplicationIdleHook ();
+      }
+#endif
+    }
+}				/*lint !e715 pvParameters is not accessed but all task functions require the same prototype. */
+
+
+
+
+
+
+
+/*-----------------------------------------------------------
+ * File private functions documented at the top of the file.
+ *----------------------------------------------------------*/
+
+
+
+static void
+prvInitialiseTCBVariables (tskTCB * pxTCB, unsigned portSHORT usStackDepth,
+			   const signed portCHAR * const pcName,
+			   unsigned portBASE_TYPE uxPriority)
+{
+  pxTCB->usStackDepth = usStackDepth;
+
+  /* Store the function name in the TCB. */
+  strncpy ((char *) pxTCB->pcTaskName, (const char *) pcName,
+	   (unsigned portSHORT) configMAX_TASK_NAME_LEN);
+  pxTCB->pcTaskName[(unsigned portSHORT) configMAX_TASK_NAME_LEN -
+		    (unsigned portSHORT) 1] = '\0';
+
+  /* This is used as an array index so must ensure it's not too large. */
+  if (uxPriority >= configMAX_PRIORITIES)
+    {
+      uxPriority = configMAX_PRIORITIES - 1;
+    }
+
+  pxTCB->uxPriority = uxPriority;
+
+  vListInitialiseItem (&(pxTCB->xGenericListItem));
+  vListInitialiseItem (&(pxTCB->xEventListItem));
+
+  /* Set the pxTCB as a link back from the xListItem.  This is so we can get
+     back to      the containing TCB from a generic item in a list. */
+  listSET_LIST_ITEM_OWNER (&(pxTCB->xGenericListItem), pxTCB);
+
+  /* Event lists are always in priority order. */
+  listSET_LIST_ITEM_VALUE (&(pxTCB->xEventListItem),
+			   configMAX_PRIORITIES - (portTickType) uxPriority);
+  listSET_LIST_ITEM_OWNER (&(pxTCB->xEventListItem), pxTCB);
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+prvInitialiseTaskLists (void)
+{
+  unsigned portBASE_TYPE uxPriority;
+
+  for (uxPriority = 0; uxPriority < configMAX_PRIORITIES; uxPriority++)
+    {
+      vListInitialise ((xList *) & (pxReadyTasksLists[uxPriority]));
+    }
+
+  vListInitialise ((xList *) & xDelayedTaskList1);
+  vListInitialise ((xList *) & xDelayedTaskList2);
+  vListInitialise ((xList *) & xPendingReadyList);
+
+#if ( INCLUDE_vTaskDelete == 1 )
+  {
+    vListInitialise ((xList *) & xTasksWaitingTermination);
+  }
+#endif
+
+#if ( INCLUDE_vTaskSuspend == 1 )
+  {
+    vListInitialise ((xList *) & xSuspendedTaskList);
+  }
+#endif
+
+  /* Start with pxDelayedTaskList using list1 and the pxOverflowDelayedTaskList
+     using list2. */
+  pxDelayedTaskList = &xDelayedTaskList1;
+  pxOverflowDelayedTaskList = &xDelayedTaskList2;
+}
+
+/*-----------------------------------------------------------*/
+
+static void
+prvCheckTasksWaitingTermination (void)
+{
+#if ( INCLUDE_vTaskDelete == 1 )
+  {
+    portBASE_TYPE xListIsEmpty;
+
+    /* ucTasksDeleted is used to prevent vTaskSuspendAll() being called
+       too often in the idle task. */
+    if (uxTasksDeleted > (unsigned portBASE_TYPE) 0)
+      {
+	vTaskSuspendAll ();
+	xListIsEmpty = listLIST_IS_EMPTY (&xTasksWaitingTermination);
+	xTaskResumeAll ();
+
+	if (!xListIsEmpty)
+	  {
+	    tskTCB *pxTCB;
+
+	    portENTER_CRITICAL ();
+	    {
+	      pxTCB =
+		(tskTCB *)
+		listGET_OWNER_OF_HEAD_ENTRY (((xList *) &
+					      xTasksWaitingTermination));
+	      vListRemove (&(pxTCB->xGenericListItem));
+	      --uxCurrentNumberOfTasks;
+	      --uxTasksDeleted;
+	    }
+	    portEXIT_CRITICAL ();
+
+	    prvDeleteTCB (pxTCB);
+	  }
+      }
+  }
+#endif
+}
+
+/*-----------------------------------------------------------*/
+
+static tskTCB *
+prvAllocateTCBAndStack (unsigned portSHORT usStackDepth)
+{
+  tskTCB *pxNewTCB;
+
+  /* Allocate space for the TCB.  Where the memory comes from depends on
+     the implementation of the port malloc function. */
+  pxNewTCB = (tskTCB *) pvPortMalloc (sizeof (tskTCB));
+
+  if (pxNewTCB != NULL)
+    {
+      /* Allocate space for the stack used by the task being created.
+         The base of the stack memory stored in the TCB so the task can
+         be deleted later if required. */
+      pxNewTCB->pxStack =
+	(portSTACK_TYPE *) pvPortMalloc (((size_t) usStackDepth) *
+					 sizeof (portSTACK_TYPE));
+
+      if (pxNewTCB->pxStack == NULL)
+	{
+	  /* Could not allocate the stack.  Delete the allocated TCB. */
+	  vPortFree (pxNewTCB);
+	  pxNewTCB = NULL;
+	}
+      else
+	{
+	  /* Just to help debugging. */
+	  memset (pxNewTCB->pxStack, tskSTACK_FILL_BYTE,
+		  usStackDepth * sizeof (portSTACK_TYPE));
+	}
+    }
+
+  return pxNewTCB;
+}
+
+/*-----------------------------------------------------------*/
+
+#if ( configUSE_TRACE_FACILITY == 1 )
+
+static void
+prvListTaskWithinSingleList (signed portCHAR * pcWriteBuffer, xList * pxList,
+			     signed portCHAR cStatus)
+{
+  volatile tskTCB *pxNextTCB, *pxFirstTCB;
+  static portCHAR pcStatusString[50];
+  unsigned portSHORT usStackRemaining;
+
+  /* Write the details of all the TCB's in pxList into the buffer. */
+  listGET_OWNER_OF_NEXT_ENTRY (pxFirstTCB, pxList);
+  do
+    {
+      listGET_OWNER_OF_NEXT_ENTRY (pxNextTCB, pxList);
+      usStackRemaining =
+	usTaskCheckFreeStackSpace ((unsigned portCHAR *) pxNextTCB->pxStack);
+      sprintf (pcStatusString, (portCHAR *) "%s\t\t%c\t%u\t%u\t%u\r\n",
+	       pxNextTCB->pcTaskName, cStatus,
+	       (unsigned int) pxNextTCB->uxPriority, usStackRemaining,
+	       (unsigned int) pxNextTCB->uxTCBNumber);
+      strcat ((portCHAR *) pcWriteBuffer, (portCHAR *) pcStatusString);
+
+    }
+  while (pxNextTCB != pxFirstTCB);
+}
+
+#endif
+/*-----------------------------------------------------------*/
+
+#if ( configUSE_TRACE_FACILITY == 1 )
+unsigned portSHORT
+usTaskCheckFreeStackSpace (const unsigned portCHAR * pucStackByte)
+{
+  register unsigned portSHORT usCount = 0;
+
+  while (*pucStackByte == tskSTACK_FILL_BYTE)
+    {
+      pucStackByte -= portSTACK_GROWTH;
+      usCount++;
+    }
+
+  usCount /= sizeof (portSTACK_TYPE);
+
+  return usCount;
+}
+#endif
+/*-----------------------------------------------------------*/
+
+
+
+#if ( ( INCLUDE_vTaskDelete == 1 ) || ( INCLUDE_vTaskCleanUpResources == 1 ) )
+
+static void
+prvDeleteTCB (tskTCB * pxTCB)
+{
+  /* Free up the memory allocated by the scheduler for the task.  It is up to
+     the task to free any memory allocated at the application level. */
+  vPortFree (pxTCB->pxStack);
+  vPortFree (pxTCB);
+}
+
+#endif
+
+
+/*-----------------------------------------------------------*/
+
+#if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )
+
+xTaskHandle
+xTaskGetCurrentTaskHandle (void)
+{
+  xTaskHandle xReturn;
+
+  portENTER_CRITICAL ();
+  {
+    xReturn = (xTaskHandle) pxCurrentTCB;
+  }
+  portEXIT_CRITICAL ();
+
+  return xReturn;
+}
+
+#endif