Continue work on the new timer implementation. Nearly complete.

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@1294 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

diff --git a/Source/include/FreeRTOS.h b/Source/include/FreeRTOS.h
index a6e1035c4582f7b90f52c28560acee0dd07080f0..b19fbaeba3bd5c191a55d78d1c6be60a3ab87034 100644 (file)
--- a/Source/include/FreeRTOS.h
+++ b/Source/include/FreeRTOS.h
@@ -181,6 +181,10 @@ typedef portBASE_TYPE (*pdTASK_HOOK_CODE)( void * );
        #define INCLUDE_xTaskResumeFromISR 1\r
 #endif\r
 \r
+#ifndef configASSERT\r
+       #define configASSERT( x )\r
+#endif\r
+\r
 /* The timers module relies on xTaskGetSchedulerState(). */\r
 #if configUSE_TIMERS == 1\r
 \r

diff --git a/Source/include/timers.h b/Source/include/timers.h
index 95431e464f45a25b71a09e0299a8fa2d604905a1..7e30f1ce5c20ec3079804d53dd4ea2aa7c71c79e 100644 (file)
--- a/Source/include/timers.h
+++ b/Source/include/timers.h
@@ -67,11 +67,10 @@ extern "C" {
 #endif\r
 \r
 /* IDs for commands that can be sent/received on the timer queue. */\r
-#define trmCOMMAND_PROCESS_TIMER_OVERFLOW      0 /* For use by the kernel only! */\r
-#define tmrCOMMAND_START                                       1\r
-#define tmrCOMMAND_STOP                                                2\r
-#define tmrCOMMAND_CHANGE_PERIOD                       3\r
-#define tmrCOMMAND_DELETE                                      4\r
+#define tmrCOMMAND_START                                       0\r
+#define tmrCOMMAND_STOP                                                1\r
+#define tmrCOMMAND_CHANGE_PERIOD                       2\r
+#define tmrCOMMAND_DELETE                                      3\r
 \r
 /*-----------------------------------------------------------\r
  * MACROS AND DEFINITIONS\r

diff --git a/Source/queue.c b/Source/queue.c
index 806413071b7e10d677df714bc0990d334937d794..c08d4c174ed8063476233c17ef576d29f632a297 100644 (file)
--- a/Source/queue.c
+++ b/Source/queue.c
@@ -1469,20 +1469,27 @@ signed portBASE_TYPE xReturn;
 \r
        void vQueueWaitForMessageRestricted( xQueueHandle pxQueue, portTickType xTicksToWait )\r
        {\r
-               /* This function should not be called by application code hence the \r
-               'Restricted' in its name.  It is not part of the public API.  It is designed\r
-               for use by kernel code, and has special calling requirements - it should be\r
-               called from a critical section, and then a yield performed after it is\r
-               called.  Also, the call tree makes use of vListInsert() which should normally\r
-               not be called from a critical section - so an assumption is made that the list\r
-               being inserted into is empty and therefore the insertion will be fast. */\r
-\r
-               /* Only do anything if there are no message in the queue. */\r
+               /* This function should not be called by application code hence the\r
+               'Restricted' in its name.  It is not part of the public API.  It is \r
+               designed for use by kernel code, and has special calling requirements.\r
+               It can result in vListInsert() being called on a list that can only\r
+               possibly ever have one item in it, so the list will be fast, but even\r
+               so it should be called with the scheduler locked and not from a critical\r
+               section. */\r
+\r
+               /* Only do anything if there are no messages in the queue.  This function\r
+               will not actually cause the task to block, just place it on a blocked\r
+               list.  It will not block until the scheduler is unlocked - at which\r
+               time a yield will be performed.  If an item is added to the queue while\r
+               the queue is locked, and the calling task blocks on the queue, then the\r
+               calling task will be immediately unblocked when the queue is unlocked. */\r
+               prvLockQueue( pxQueue );\r
                if( pxQueue->uxMessagesWaiting == ( unsigned portBASE_TYPE ) 0U )\r
                {\r
                        /* There is nothing in the queue, block for the specified period. */\r
                        vTaskPlaceOnEventListRestricted( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );\r
                }\r
+               prvUnlockQueue( pxQueue );\r
        }\r
 \r
 #endif\r

diff --git a/Source/tasks.c b/Source/tasks.c
index 3e4fb525cea4944f0017410f3487c0adb55a1e70..70b629d3f02bc6cca4e6945beaf440a33d2c0e99 100644 (file)
--- a/Source/tasks.c
+++ b/Source/tasks.c
@@ -754,7 +754,7 @@ tskTCB *pxTCB = ( tskTCB * ) pxTask;
 \r
        /* This function is not intended to be a public API function and definitely\r
        is not for generic use as it assumes pxTask is not the running task and not\r
-       suspended, does not remove the task from any event lists it might be \r
+       suspended, does not remove the task from any event lists it might be\r
        blocked on, and does not take care of mutual exclusion. */\r
        vListRemove( &( pxTCB->xGenericListItem ) );\r
        prvAddTaskToReadyQueue( pxTCB );\r
@@ -1444,19 +1444,13 @@ void vTaskIncrementTick( void )
                        /* Tick count has overflowed so we need to swap the delay lists.\r
                        If there are any items in pxDelayedTaskList here then there is\r
                        an error! */\r
+                       configASSERT( ( listLIST_IS_EMPTY( pxDelayedTaskList ) ) );\r
+                       \r
                        pxTemp = pxDelayedTaskList;\r
                        pxDelayedTaskList = pxOverflowDelayedTaskList;\r
                        pxOverflowDelayedTaskList = pxTemp;\r
                        xNumOfOverflows++;\r
-                       \r
-                       #if configUSE_TIMERS == 1\r
-                       {\r
-                               /* The timer service task needs to know to switch its lists\r
-                               too. */\r
-                               xTimerGenericCommand( NULL, trmCOMMAND_PROCESS_TIMER_OVERFLOW, 0, 0 );\r
-                       }\r
-                       #endif\r
-                       \r
+       \r
                        if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )\r
                        {\r
                                /* The delayed list is empty.  Set xNextTaskUnblockTime to the\r
@@ -1756,9 +1750,9 @@ portTickType xTimeToWake;
        {\r
        portTickType xTimeToWake;\r
 \r
-               /* This function should not be called by application code hence the \r
-               'Restricted' in its name.  It is not part of the public API.  It is \r
-               designed for use by kernel code, and has special calling requirements - \r
+               /* This function should not be called by application code hence the\r
+               'Restricted' in its name.  It is not part of the public API.  It is\r
+               designed for use by kernel code, and has special calling requirements -\r
                it should be called from a critical section. */\r
 \r
        \r
@@ -1769,7 +1763,7 @@ portTickType xTimeToWake;
                vListInsertEnd( ( xList * ) pxEventList, ( xListItem * ) &( pxCurrentTCB->xEventListItem ) );\r
 \r
                /* We must remove this task from the ready list before adding it to the\r
-               blocked list as the same list item is used for both lists.  This \r
+               blocked list as the same list item is used for both lists.  This\r
                function is called form a critical section. */\r
                vListRemove( ( xListItem * ) &( pxCurrentTCB->xGenericListItem ) );\r
 \r

diff --git a/Source/timers.c b/Source/timers.c
index 2a6b8fe0e6078f6ea22ba573226dbe530fadfb6b..c9d592c283f97f9a07a9cc20bb23c2592b970c47 100644 (file)
--- a/Source/timers.c
+++ b/Source/timers.c
@@ -117,25 +117,45 @@ static void prvTimerTask( void *pvParameters ) PRIVILEGED_FUNCTION;
  * Called by the timer service task to interpret and process a command it\r
  * received on the timer queue.\r
  */\r
-static void    prvProcessReceivedCommands( portTickType xAssumedTimeNow ) PRIVILEGED_FUNCTION;\r
+static void    prvProcessReceivedCommands( void ) PRIVILEGED_FUNCTION;\r
 \r
 /*\r
- * Insert the timer into either xActiveTimerList1, or xActiveTimerList2, \r
- * depending on if the expire time causes a timer counter overflow. \r
+ * Insert the timer into either xActiveTimerList1, or xActiveTimerList2,\r
+ * depending on if the expire time causes a timer counter overflow.\r
  */\r
-static void prvInsertTimerInActiveList( xTIMER *pxTimer, portTickType xNextExpiryTime, portTickType xAssumedTimeNow ) PRIVILEGED_FUNCTION;\r
+static void prvInsertTimerInActiveList( xTIMER *pxTimer, portTickType xNextExpiryTime, portTickType xTimeNow ) PRIVILEGED_FUNCTION;\r
 \r
 /*\r
  * An active timer has reached its expire time.  Reload the timer if it is an\r
  * auto reload timer, then call its callback.\r
  */\r
-static void prvProcessExpiredTimer( portTickType xNextExpireTime, portTickType xAssumedTimeNow ) PRIVILEGED_FUNCTION;\r
+static void prvProcessExpiredTimer( portTickType xNextExpireTime, portTickType xTimeNow ) PRIVILEGED_FUNCTION;\r
 \r
 /*\r
  * The tick count has overflowed.  Switch the timer lists after ensuring the\r
  * current timer list does not still reference some timers.\r
  */\r
-static void prvSwitchTimerLists( portTickType xAssumedTimeNow ) PRIVILEGED_FUNCTION;\r
+static void prvSwitchTimerLists( portTickType xTimeNow, portTickType xLastTime ) PRIVILEGED_FUNCTION;\r
+\r
+/*\r
+ * Obtain the current tick count, setting *pxTimerListsWereSwitched to pdTRUE\r
+ * if a tick count overflow occurred since prvSampleTimeNow() was last called.\r
+ */\r
+static portTickType prvSampleTimeNow( portBASE_TYPE *pxTimerListsWereSwitched ) PRIVILEGED_FUNCTION;\r
+\r
+/*\r
+ * If the timer list contains any active timers then return the expire time of\r
+ * the timer that will expire first and set *pxListWasEmpty to false.  If the\r
+ * timer list does not contain any timers then return 0 and set *pxListWasEmpty\r
+ * to pdTRUE.\r
+ */\r
+static portTickType prvLookForExpiredTimer( portBASE_TYPE *pxListWasEmpty ) PRIVILEGED_FUNCTION;\r
+\r
+/*\r
+ * If a timer has expired, process it.  Otherwise, block the timer service task\r
+ * until either a timer does expire or a command is received.\r
+ */\r
+static void prvProcessTimerOrBlockTask( portTickType xNextExpireTime, portBASE_TYPE xListWasEmpty ) PRIVILEGED_FUNCTION;\r
 \r
 /*-----------------------------------------------------------*/\r
 \r
@@ -151,7 +171,7 @@ portBASE_TYPE xReturn = pdFAIL;
 \r
        if( xTimerQueue != NULL )\r
        {\r
-               xReturn = xTaskCreate( prvTimerTask, ( const signed char * ) "Timer Service", configTIMER_TASK_STACK_DEPTH, NULL, configTIMER_TASK_PRIORITY, NULL );\r
+               xReturn = xTaskCreate( prvTimerTask, ( const signed char * ) "Tmr Svc", configTIMER_TASK_STACK_DEPTH, NULL, configTIMER_TASK_PRIORITY, NULL);\r
        }\r
 \r
        return xReturn;\r
@@ -183,7 +203,7 @@ xTIMER *pxNewTimer;
 }\r
 /*-----------------------------------------------------------*/\r
 \r
-portBASE_TYPE xTimerGenericCommand( xTimerHandle xTimer, portBASE_TYPE xCommandID, portTickType xOptionalValue, portTickType xBlockTime )\r
+portBASE_TYPE xTimerGenericCommand( xTimerHandle xTimer, portBASE_TYPE xCommandID, portTickType xOptionalValue, portBASE_TYPE *pxHigherPriorityTaskWoken, portTickType xBlockTime )\r
 {\r
 portBASE_TYPE xReturn = pdFAIL;\r
 xTIMER_MESSAGE xMessage;\r
@@ -197,13 +217,20 @@ xTIMER_MESSAGE xMessage;
                xMessage.xMessageValue = xOptionalValue;\r
                xMessage.pxTimer = ( xTIMER * ) xTimer;\r
 \r
-               if( xTaskGetSchedulerState() == taskSCHEDULER_RUNNING )\r
+               if( pxHigherPriorityTaskWoken == NULL )\r
                {\r
-                       xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xBlockTime );\r
+                       if( xTaskGetSchedulerState() == taskSCHEDULER_RUNNING )\r
+                       {\r
+                               xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xBlockTime );\r
+                       }\r
+                       else\r
+                       {\r
+                               xReturn = xQueueSendToBack( xTimerQueue, &xMessage, tmrNO_DELAY );\r
+                       }\r
                }\r
                else\r
                {\r
-                       xReturn = xQueueSendToBack( xTimerQueue, &xMessage, tmrNO_DELAY );\r
+                       xReturn = xQueueSendToBackFromISR( xTimerQueue, &xMessage, pxHigherPriorityTaskWoken );\r
                }\r
        }\r
 \r
@@ -211,128 +238,155 @@ xTIMER_MESSAGE xMessage;
 }\r
 /*-----------------------------------------------------------*/\r
 \r
-static void prvProcessExpiredTimer( portTickType xNextExpireTime, portTickType xAssumedTimeNow )\r
+static void prvProcessExpiredTimer( portTickType xNextExpireTime, portTickType xTimeNow )\r
 {\r
 xTIMER *pxTimer;\r
 \r
-       if( listLIST_IS_EMPTY( pxCurrentTimerList ) == pdFALSE )\r
-       {\r
-               /* Remove the timer from the list of active timers. */\r
-               pxTimer = ( xTIMER * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );\r
-               vListRemove( &( pxTimer->xTimerListItem ) );\r
-\r
-               /* If the timer is an auto reload timer then calculate the next\r
-               expiry time and re-insert the timer in the list of active timers. */\r
-               if( pxTimer->uxAutoReload == pdTRUE )\r
-               {\r
-                       /* This is the only time a timer is inserted into a list using\r
-                       a time relative to anything other than the current time.  It\r
-                       will therefore be inserted into the correct list relative to\r
-                       the time this task thinks it is now, even if a command to\r
-                       switch lists due to a tick count overflow is already waiting in\r
-                       the timer queue. */\r
-                       prvInsertTimerInActiveList( pxTimer, ( xNextExpireTime + pxTimer->xTimerPeriodInTicks ), xAssumedTimeNow );\r
-               }\r
+       /* Remove the timer from the list of active timers.  A check has already\r
+       been performed to ensure the list is not empty. */\r
+       pxTimer = ( xTIMER * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );\r
+       vListRemove( &( pxTimer->xTimerListItem ) );\r
 \r
-               /* Call the timer callback. */\r
-               pxTimer->pxCallbackFunction( ( xTimerHandle ) pxTimer );\r
+       /* If the timer is an auto reload timer then calculate the next\r
+       expiry time and re-insert the timer in the list of active timers. */\r
+       if( pxTimer->uxAutoReload == pdTRUE )\r
+       {\r
+               /* This is the only time a timer is inserted into a list using\r
+               a time relative to anything other than the current time.  It\r
+               will therefore be inserted into the correct list relative to\r
+               the time this task thinks it is now, even if a command to\r
+               switch lists due to a tick count overflow is already waiting in\r
+               the timer queue. */\r
+               prvInsertTimerInActiveList( pxTimer, ( xNextExpireTime + pxTimer->xTimerPeriodInTicks ), xTimeNow );\r
        }\r
+\r
+       /* Call the timer callback. */\r
+       pxTimer->pxCallbackFunction( ( xTimerHandle ) pxTimer );\r
 }\r
 /*-----------------------------------------------------------*/\r
 \r
 static void prvTimerTask( void *pvParameters )\r
 {\r
-portTickType xNextExpireTime, xTimeNow, xFrozenTimeNow;\r
+portTickType xNextExpireTime;\r
+portBASE_TYPE xListWasEmpty;\r
 \r
        /* Just to avoid compiler warnings. */\r
        ( void ) pvParameters;\r
 \r
        for( ;; )\r
        {\r
-               /* Take a snapshot of the time to use while assessing expiry and auto\r
-               reload times. */\r
-               xFrozenTimeNow = xTaskGetTickCount();\r
-\r
-               /* Timers are listed in expiry time order, with the head of the list\r
-               referencing the task that will expire first.  Obtain the time at which\r
-               the timer with the nearest expiry time will expire.  If there are no\r
-               active timers then just set the next expire time to the maximum possible\r
-               time to ensure this task does not run unnecessarily.  */\r
-               if( listLIST_IS_EMPTY( pxCurrentTimerList ) == pdFALSE )\r
-               {\r
-                       xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );\r
-               }\r
-               else\r
-               {\r
-                       xNextExpireTime = portMAX_DELAY;\r
-               }\r
+               /* Query the timers list to see if it contains any timers, and if so,\r
+               obtain the time at which the next timer will expire. */\r
+               xNextExpireTime = prvLookForExpiredTimer( &xListWasEmpty );\r
+\r
+               /* If a timer has expired, process it.  Otherwise, block this task\r
+               until either a timer does expire, or a command is received. */\r
+               prvProcessTimerOrBlockTask( xNextExpireTime, xListWasEmpty );\r
+               \r
+               /* Empty the command queue. */\r
+               prvProcessReceivedCommands();           \r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
 \r
-               /* Has the timer expired?  This expiry time is relative to the snapshot\r
-               of the time taken to be used in this loop iteration - so it doesn't \r
-               matter at this point if a tick count overflows here. */\r
-               if( xNextExpireTime <= xFrozenTimeNow )\r
-               {\r
-                       prvProcessExpiredTimer( xNextExpireTime, xFrozenTimeNow );\r
-               }\r
-               else\r
+static void prvProcessTimerOrBlockTask( portTickType xNextExpireTime, portBASE_TYPE xListWasEmpty )\r
+{\r
+portTickType xTimeNow;\r
+portBASE_TYPE xTimerListsWereSwitched;\r
+\r
+       vTaskSuspendAll();\r
+       {\r
+               /* Obtain the time now to make an assessment as to whether the timer\r
+               has expired or not.  If obtaining the time causes the lists to switch\r
+               then don't process this timer as any timers that remained in the list\r
+               when the lists were switched will have been processed within the\r
+               prvSampelTimeNow() function. */\r
+               xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );\r
+               if( xTimerListsWereSwitched == pdFALSE )\r
                {\r
-                       /* Block this task until the next timer expires, or a command is\r
-                       received. */\r
-                       vTaskSuspendAll();\r
+                       /* The tick count has not overflowed, has the timer expired? */\r
+                       if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) )\r
                        {\r
-                               /* Has the tick overflowed since a time snapshot was taken? */\r
-                               xTimeNow = xTaskGetTickCount();\r
-                               if( xTimeNow >= xFrozenTimeNow )\r
-                               {\r
-                                       /* Has the expire not still not been met?  The tick count\r
-                                       may be greater now than when the time snapshot was taken. */\r
-                                       if( xNextExpireTime <= xTimeNow )\r
-                                       {\r
-                                               prvProcessExpiredTimer( xNextExpireTime, xFrozenTimeNow );\r
-                                       }\r
-                                       else\r
-                                       {\r
-                                               /* The tick count has not overflowed since the time \r
-                                               snapshot, and the next expire time has not been reached\r
-                                               since the last snapshot was taken.  This task should\r
-                                               therefore block to wait for the next expire time. */\r
-                                               vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ) );\r
-                                       }\r
-                               }\r
-                               else\r
-                               {\r
-                                       /* The tick count has overflowed since the time snapshot\r
-                                       was taken, therefore, the task should not block but continue\r
-                                       with another loop.  The command queue should contain a\r
-                                       command to switch lists. */\r
-                               }\r
+                               prvProcessExpiredTimer( xNextExpireTime, xTimeNow );\r
                        }\r
-                       if( xTaskResumeAll() == pdFALSE )\r
+                       else\r
                        {\r
-                               /* Yield to wait for either a command to arrive, or the block time\r
-                               to expire.  If a command arrived between the critical section being\r
-                               exited and this yield then the yield will just return to the same\r
-                               task. */\r
-                               portYIELD_WITHIN_API();\r
+                               /* The tick count has not overflowed, and the next expire \r
+                               time has not been reached yet.  This task should therefore \r
+                               block to wait for the next expire time or a command to be \r
+                               received - whichever comes first.  The following line cannot\r
+                               be reached unless xNextExpireTime > xTimeNow, except in the \r
+                               case when the current timer list is empty. */\r
+                               vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ) );\r
                        }\r
+               }\r
+       }\r
+       if( xTaskResumeAll() == pdFALSE )\r
+       {\r
+               /* Yield to wait for either a command to arrive, or the block time\r
+               to expire.  If a command arrived between the critical section being\r
+               exited and this yield then the yield will not cause the task\r
+               to block. */\r
+               portYIELD_WITHIN_API();\r
+       }\r
+}\r
+/*-----------------------------------------------------------*/\r
 \r
-                       /* Take a snapshot of the time now for use in this iteration of the\r
-                       task loop. */\r
-                       xFrozenTimeNow = xTaskGetTickCount();\r
+static portTickType prvLookForExpiredTimer( portBASE_TYPE *pxListWasEmpty )\r
+{\r
+portTickType xNextExpireTime;\r
 \r
-                       /* Empty the command queue, if it contains any commands. */\r
-                       prvProcessReceivedCommands( xFrozenTimeNow );\r
-               }\r
+       /* Timers are listed in expiry time order, with the head of the list\r
+       referencing the task that will expire first.  Obtain the time at which\r
+       the timer with the nearest expiry time will expire.  If there are no\r
+       active timers then just set the next expire time to 0.  That will cause\r
+       this task to unblock when the tick count overflows, at which point the\r
+       timer lists will be switched and the next expiry time can be \r
+       re-assessed.  */\r
+       *pxListWasEmpty = listLIST_IS_EMPTY( pxCurrentTimerList );\r
+       if( *pxListWasEmpty == pdFALSE )\r
+       {\r
+               xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );\r
+       }\r
+       else\r
+       {\r
+               /* Ensure the task unblocks when the tick count rolls over. */\r
+               xNextExpireTime = ( portTickType ) 0U;\r
+       }\r
+\r
+       return xNextExpireTime;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static portTickType prvSampleTimeNow( portBASE_TYPE *pxTimerListsWereSwitched )\r
+{\r
+portTickType xTimeNow;\r
+static portTickType xLastTime = ( portTickType ) 0U;\r
+\r
+       xTimeNow = xTaskGetTickCount();\r
+       \r
+       if( xTimeNow < xLastTime )\r
+       {\r
+               prvSwitchTimerLists( xTimeNow, xLastTime );\r
+               *pxTimerListsWereSwitched = pdTRUE;\r
+       }\r
+       else\r
+       {\r
+               *pxTimerListsWereSwitched = pdFALSE;\r
        }\r
+       \r
+       xLastTime = xTimeNow;\r
+       \r
+       return xTimeNow;\r
 }\r
 /*-----------------------------------------------------------*/\r
 \r
-static void prvInsertTimerInActiveList( xTIMER *pxTimer, portTickType xNextExpiryTime, portTickType xAssumedTimeNow )\r
+static void prvInsertTimerInActiveList( xTIMER *pxTimer, portTickType xNextExpiryTime, portTickType xTimeNow )\r
 {\r
        listSET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ), xNextExpiryTime );\r
        listSET_LIST_ITEM_OWNER( &( pxTimer->xTimerListItem ), pxTimer );\r
        \r
-       if( xNextExpiryTime < xAssumedTimeNow )\r
+       if( xNextExpiryTime < xTimeNow )\r
        {\r
                vListInsert( pxOverflowTimerList, &( pxTimer->xTimerListItem ) );\r
        }\r
@@ -343,11 +397,16 @@ static void prvInsertTimerInActiveList( xTIMER *pxTimer, portTickType xNextExpir
 }\r
 /*-----------------------------------------------------------*/\r
 \r
-static void    prvProcessReceivedCommands( portTickType xAssumedTimeNow )\r
+static void    prvProcessReceivedCommands( void )\r
 {\r
 xTIMER_MESSAGE xMessage;\r
 xTIMER *pxTimer;\r
-portBASE_TYPE xSwitchListsOnExit = pdFALSE;\r
+portBASE_TYPE xTimerListsWereSwitched;\r
+portTickType xTimeNow;\r
+\r
+       /* In this case the xTimerListsWereSwitched parameter is not used, but it\r
+       must be present in the function call. */\r
+       xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );\r
 \r
        while( xQueueReceive( xTimerQueue, &xMessage, tmrNO_DELAY ) != pdFAIL )\r
        {\r
@@ -369,7 +428,7 @@ portBASE_TYPE xSwitchListsOnExit = pdFALSE;
                {\r
                        case tmrCOMMAND_START : \r
                                /* Start or restart a timer. */\r
-                               prvInsertTimerInActiveList( pxTimer,  xAssumedTimeNow + pxTimer->xTimerPeriodInTicks, xAssumedTimeNow );\r
+                               prvInsertTimerInActiveList( pxTimer,  xTimeNow + pxTimer->xTimerPeriodInTicks, xTimeNow );\r
                                break;\r
 \r
                        case tmrCOMMAND_STOP :  \r
@@ -379,7 +438,7 @@ portBASE_TYPE xSwitchListsOnExit = pdFALSE;
 \r
                        case tmrCOMMAND_CHANGE_PERIOD :\r
                                pxTimer->xTimerPeriodInTicks = xMessage.xMessageValue;\r
-                               prvInsertTimerInActiveList( pxTimer, ( xAssumedTimeNow + pxTimer->xTimerPeriodInTicks ), xAssumedTimeNow );\r
+                               prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow );\r
                                break;\r
 \r
                        case tmrCOMMAND_DELETE :\r
@@ -387,39 +446,32 @@ portBASE_TYPE xSwitchListsOnExit = pdFALSE;
                                just free up the memory. */\r
                                vPortFree( pxTimer );\r
                                break;\r
-                               \r
-                       case trmCOMMAND_PROCESS_TIMER_OVERFLOW :\r
-                               /* Hold this pending until all the other messages have been \r
-                               processed. */\r
-                               xSwitchListsOnExit = pdTRUE;\r
-                               break;\r
 \r
                        default :                       \r
                                /* Don't expect to get here. */\r
                                break;\r
                }\r
        }\r
-\r
-       if( xSwitchListsOnExit == pdTRUE )\r
-       {\r
-               prvSwitchTimerLists( xAssumedTimeNow );\r
-       }\r
 }\r
 /*-----------------------------------------------------------*/\r
 \r
-static void prvSwitchTimerLists( portTickType xAssumedTimeNow )\r
+static void prvSwitchTimerLists( portTickType xTimeNow, portTickType xLastTime )\r
 {\r
 portTickType xNextExpireTime;\r
 xList *pxTemp;\r
 \r
-       /* The tick count has overflowed.  The timer lists must be switched.  \r
-       If there are any timers still referenced from the current timer list \r
-       then they must have expired and should be processed before the lists \r
+       /* Remove compiler warnings if configASSERT() is not defined. */\r
+       ( void ) xLastTime;\r
+       \r
+       /* The tick count has overflowed.  The timer lists must be switched.\r
+       If there are any timers still referenced from the current timer list\r
+       then they must have expired and should be processed before the lists\r
        are switched. */\r
        while( listLIST_IS_EMPTY( pxCurrentTimerList ) == pdFALSE )\r
        {\r
                xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );\r
-               prvProcessExpiredTimer( xNextExpireTime, xAssumedTimeNow );\r
+               configASSERT( ( xNextExpireTime >= xLastTime ) );\r
+               prvProcessExpiredTimer( xNextExpireTime, xTimeNow );\r
        }\r
 \r
        pxTemp = pxCurrentTimerList;\r