Update prototypes and macros for the new xQueueSendFromISR() function and the task...

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

diff --git a/Source/include/FreeRTOS.h b/Source/include/FreeRTOS.h
index 6c47cc0b43a32350f50396ef2215fab70d90368f..f69fc02f59b807b0456293a6c8f9bdac967a6dd4 100644 (file)
--- a/Source/include/FreeRTOS.h
+++ b/Source/include/FreeRTOS.h
@@ -66,6 +66,9 @@
 #include "portable.h"\r
 \r
 \r
+/* Defines the prototype to which the application task hook function must\r
+conform. */\r
+typedef portBASE_TYPE (*pdTASK_HOOK_CODE)( void * );\r
 \r
 \r
 \r
@@ -125,6 +128,10 @@
        #error Missing definition:  configUSE_16_BIT_TICKS should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.\r
 #endif\r
 \r
+#ifndef configUSE_APPLICATION_TASK_HOOK\r
+       #define configUSE_APPLICATION_TASK_HOOK 0\r
+#endif\r
+\r
 #ifndef INCLUDE_uxTaskGetStackHighWaterMark\r
        #define INCLUDE_uxTaskGetStackHighWaterMark 0\r
 #endif\r
@@ -149,6 +156,27 @@
        #define portCRITICAL_NESTING_IN_TCB 0\r
 #endif\r
 \r
+#ifndef configMAX_TASK_NAME_LEN\r
+       #define configMAX_TASK_NAME_LEN 16\r
+#endif\r
+\r
+#ifndef configIDLE_SHOULD_YIELD\r
+       #define configIDLE_SHOULD_YIELD         1\r
+#endif\r
+\r
+#if configMAX_TASK_NAME_LEN < 1\r
+       #undef configMAX_TASK_NAME_LEN\r
+       #define configMAX_TASK_NAME_LEN 1\r
+#endif\r
+\r
+#ifndef INCLUDE_xTaskResumeFromISR\r
+       #define INCLUDE_xTaskResumeFromISR 1\r
+#endif\r
+\r
+#ifndef INCLUDE_xTaskGetSchedulerState\r
+       #define INCLUDE_xTaskGetSchedulerState 0\r
+#endif\r
+\r
 #if ( configUSE_MUTEXES == 1 )\r
        /* xTaskGetCurrentTaskHandle is used by the priority inheritance mechanism\r
        within the mutex implementation so must be available if mutexes are used. */\r

diff --git a/Source/include/projdefs.h b/Source/include/projdefs.h
index 4c755bf8dfde55c2f1f4e539c791905ba2a908fd..9b78d4e7ffad5667c979aaad33d94d545e6d1a6b 100644 (file)
--- a/Source/include/projdefs.h
+++ b/Source/include/projdefs.h
@@ -50,7 +50,7 @@
 #ifndef PROJDEFS_H\r
 #define PROJDEFS_H\r
 \r
-/* Defines to prototype to which task functions must conform. */\r
+/* Defines the prototype to which task functions must conform. */\r
 typedef void (*pdTASK_CODE)( void * );\r
 \r
 #define pdTRUE         ( 1 )\r

diff --git a/Source/include/queue.h b/Source/include/queue.h
index 9e299aae3c4905ea6d55264010ad8270b806c0b2..6b1c4fd487591d56ffdc53bf1996a52672e5a27a 100644 (file)
--- a/Source/include/queue.h
+++ b/Source/include/queue.h
@@ -789,15 +789,14 @@ void vQueueDelete( xQueueHandle xQueue );
  * queue was created, so this many bytes will be copied from pvItemToQueue\r
  * into the queue storage area.\r
  *\r
- * @param cTaskPreviouslyWoken This is included so an ISR can post onto\r
- * the same queue multiple times from a single interrupt.  The first call\r
- * should always pass in pdFALSE.  Subsequent calls should pass in\r
- * the value returned from the previous call.  See the file serial .c in the\r
- * PC port for a good example of this mechanism.\r
+ * @param pxHigherPriorityTaskWoken xQueueSendToFrontFromISR() will set\r
+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task\r
+ * to unblock, and the unblocked task has a priority higher than the currently\r
+ * running task.  If xQueueSendToFromFromISR() sets this value to pdTRUE then\r
+ * a context switch should be requested before the interrupt is exited.\r
  *\r
- * @return pdTRUE if a task was woken by posting onto the queue.  This is\r
- * used by the ISR to determine if a context switch may be required following\r
- * the ISR.\r
+ * @return pdTRUE if the data was successfully sent to the queue, otherwise\r
+ * errQUEUE_FULL.\r
  *\r
  * Example usage for buffered IO (where the ISR can obtain more than one value\r
  * per call):\r
@@ -805,10 +804,10 @@ void vQueueDelete( xQueueHandle xQueue );
  void vBufferISR( void )\r
  {\r
  portCHAR cIn;\r
- portBASE_TYPE xTaskWokenByPost;\r
+ portBASE_TYPE xHigherPrioritTaskWoken;\r
 \r
     // We have not woken a task at the start of the ISR.\r
-    cTaskWokenByPost = pdFALSE;\r
+    xHigherPriorityTaskWoken = pdFALSE;\r
 \r
     // Loop until the buffer is empty.\r
     do\r
@@ -816,19 +815,13 @@ void vQueueDelete( xQueueHandle xQueue );
         // Obtain a byte from the buffer.\r
         cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );                                           \r
 \r
-        // Post the byte.  The first time round the loop cTaskWokenByPost\r
-        // will be pdFALSE.  If the queue send causes a task to wake we do\r
-        // not want the task to run until we have finished the ISR, so\r
-        // xQueueSendFromISR does not cause a context switch.  Also we\r
-        // don't want subsequent posts to wake any other tasks, so we store\r
-        // the return value back into cTaskWokenByPost so xQueueSendFromISR\r
-        // knows not to wake any task the next iteration of the loop.\r
-        xTaskWokenByPost = xQueueSendToFrontFromISR( xRxQueue, &cIn, cTaskWokenByPost );\r
+        // Post the byte.  \r
+        xQueueSendToFrontFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );\r
 \r
     } while( portINPUT_BYTE( BUFFER_COUNT ) );\r
 \r
     // Now the buffer is empty we can switch context if necessary.\r
-    if( cTaskWokenByPost )\r
+    if( xHigherPriorityTaskWoken )\r
     {\r
         taskYIELD ();\r
     }\r
@@ -838,7 +831,7 @@ void vQueueDelete( xQueueHandle xQueue );
  * \defgroup xQueueSendFromISR xQueueSendFromISR\r
  * \ingroup QueueManagement\r
  */\r
-#define xQueueSendToFrontFromISR( pxQueue, pvItemToQueue, xTaskPreviouslyWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, xTaskPreviouslyWoken, queueSEND_TO_FRONT )\r
+#define xQueueSendToFrontFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_FRONT )\r
 \r
 \r
 /**\r
@@ -867,15 +860,14 @@ void vQueueDelete( xQueueHandle xQueue );
  * queue was created, so this many bytes will be copied from pvItemToQueue\r
  * into the queue storage area.\r
  *\r
- * @param cTaskPreviouslyWoken This is included so an ISR can post onto\r
- * the same queue multiple times from a single interrupt.  The first call\r
- * should always pass in pdFALSE.  Subsequent calls should pass in\r
- * the value returned from the previous call.  See the file serial .c in the\r
- * PC port for a good example of this mechanism.\r
+ * @param pxHigherPriorityTaskWoken xQueueSendToBackFromISR() will set\r
+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task\r
+ * to unblock, and the unblocked task has a priority higher than the currently\r
+ * running task.  If xQueueSendToBackFromISR() sets this value to pdTRUE then\r
+ * a context switch should be requested before the interrupt is exited.\r
  *\r
- * @return pdTRUE if a task was woken by posting onto the queue.  This is\r
- * used by the ISR to determine if a context switch may be required following\r
- * the ISR.\r
+ * @return pdTRUE if the data was successfully sent to the queue, otherwise\r
+ * errQUEUE_FULL.\r
  *\r
  * Example usage for buffered IO (where the ISR can obtain more than one value\r
  * per call):\r
@@ -883,10 +875,10 @@ void vQueueDelete( xQueueHandle xQueue );
  void vBufferISR( void )\r
  {\r
  portCHAR cIn;\r
- portBASE_TYPE xTaskWokenByPost;\r
+ portBASE_TYPE xHigherPriorityTaskWoken;\r
 \r
     // We have not woken a task at the start of the ISR.\r
-    cTaskWokenByPost = pdFALSE;\r
+    xHigherPriorityTaskWoken = pdFALSE;\r
 \r
     // Loop until the buffer is empty.\r
     do\r
@@ -894,19 +886,13 @@ void vQueueDelete( xQueueHandle xQueue );
         // Obtain a byte from the buffer.\r
         cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );                                           \r
 \r
-        // Post the byte.  The first time round the loop cTaskWokenByPost\r
-        // will be pdFALSE.  If the queue send causes a task to wake we do\r
-        // not want the task to run until we have finished the ISR, so\r
-        // xQueueSendFromISR does not cause a context switch.  Also we\r
-        // don't want subsequent posts to wake any other tasks, so we store\r
-        // the return value back into cTaskWokenByPost so xQueueSendFromISR\r
-        // knows not to wake any task the next iteration of the loop.\r
-        xTaskWokenByPost = xQueueSendToBackFromISR( xRxQueue, &cIn, cTaskWokenByPost );\r
+        // Post the byte.\r
+        xQueueSendToBackFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );\r
 \r
     } while( portINPUT_BYTE( BUFFER_COUNT ) );\r
 \r
     // Now the buffer is empty we can switch context if necessary.\r
-    if( cTaskWokenByPost )\r
+    if( xHigherPriorityTaskWoken )\r
     {\r
         taskYIELD ();\r
     }\r
@@ -916,7 +902,7 @@ void vQueueDelete( xQueueHandle xQueue );
  * \defgroup xQueueSendFromISR xQueueSendFromISR\r
  * \ingroup QueueManagement\r
  */\r
-#define xQueueSendToBackFromISR( pxQueue, pvItemToQueue, xTaskPreviouslyWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, xTaskPreviouslyWoken, queueSEND_TO_BACK )\r
+#define xQueueSendToBackFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )\r
 \r
 /**\r
  * queue. h\r
@@ -947,15 +933,14 @@ void vQueueDelete( xQueueHandle xQueue );
  * queue was created, so this many bytes will be copied from pvItemToQueue\r
  * into the queue storage area.\r
  *\r
- * @param cTaskPreviouslyWoken This is included so an ISR can post onto\r
- * the same queue multiple times from a single interrupt.  The first call\r
- * should always pass in pdFALSE.  Subsequent calls should pass in\r
- * the value returned from the previous call.  See the file serial .c in the\r
- * PC port for a good example of this mechanism.\r
+ * @param pxHigherPriorityTaskWoken xQueueSendFromISR() will set\r
+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task\r
+ * to unblock, and the unblocked task has a priority higher than the currently\r
+ * running task.  If xQueueSendFromISR() sets this value to pdTRUE then\r
+ * a context switch should be requested before the interrupt is exited.\r
  *\r
- * @return pdTRUE if a task was woken by posting onto the queue.  This is\r
- * used by the ISR to determine if a context switch may be required following\r
- * the ISR.\r
+ * @return pdTRUE if the data was successfully sent to the queue, otherwise\r
+ * errQUEUE_FULL.\r
  *\r
  * Example usage for buffered IO (where the ISR can obtain more than one value\r
  * per call):\r
@@ -963,10 +948,10 @@ void vQueueDelete( xQueueHandle xQueue );
  void vBufferISR( void )\r
  {\r
  portCHAR cIn;\r
- portBASE_TYPE xTaskWokenByPost;\r
+ portBASE_TYPE xHigherPriorityTaskWoken;\r
 \r
     // We have not woken a task at the start of the ISR.\r
-    cTaskWokenByPost = pdFALSE;\r
+    xHigherPriorityTaskWoken = pdFALSE;\r
 \r
     // Loop until the buffer is empty.\r
     do\r
@@ -974,19 +959,13 @@ void vQueueDelete( xQueueHandle xQueue );
         // Obtain a byte from the buffer.\r
         cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );                                           \r
 \r
-        // Post the byte.  The first time round the loop cTaskWokenByPost\r
-        // will be pdFALSE.  If the queue send causes a task to wake we do\r
-        // not want the task to run until we have finished the ISR, so\r
-        // xQueueSendFromISR does not cause a context switch.  Also we\r
-        // don't want subsequent posts to wake any other tasks, so we store\r
-        // the return value back into cTaskWokenByPost so xQueueSendFromISR\r
-        // knows not to wake any task the next iteration of the loop.\r
-        xTaskWokenByPost = xQueueSendFromISR( xRxQueue, &cIn, cTaskWokenByPost );\r
+        // Post the byte.  \r
+        xTaskWokenByPost = xQueueSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );\r
 \r
     } while( portINPUT_BYTE( BUFFER_COUNT ) );\r
 \r
     // Now the buffer is empty we can switch context if necessary.\r
-    if( cTaskWokenByPost )\r
+    if( xHigherPriorityTaskWoken )\r
     {\r
         taskYIELD ();\r
     }\r
@@ -996,7 +975,7 @@ void vQueueDelete( xQueueHandle xQueue );
  * \defgroup xQueueSendFromISR xQueueSendFromISR\r
  * \ingroup QueueManagement\r
  */\r
-#define xQueueSendFromISR( pxQueue, pvItemToQueue, xTaskPreviouslyWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, xTaskPreviouslyWoken, queueSEND_TO_BACK )\r
+#define xQueueSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )\r
 \r
 /**\r
  * queue. h\r
@@ -1004,7 +983,7 @@ void vQueueDelete( xQueueHandle xQueue );
  portBASE_TYPE xQueueGenericSendFromISR(\r
                                            xQueueHandle pxQueue,\r
                                            const void *pvItemToQueue,\r
-                                           portBASE_TYPE xTaskPreviouslyWoken\r
+                                           portBASE_TYPE *pxHigherPriorityTaskWoken,\r
                                                                                   portBASE_TYPE xCopyPosition\r
                                        );\r
  </pre>\r
@@ -1027,19 +1006,18 @@ void vQueueDelete( xQueueHandle xQueue );
  * queue was created, so this many bytes will be copied from pvItemToQueue\r
  * into the queue storage area.\r
  *\r
- * @param cTaskPreviouslyWoken This is included so an ISR can post onto\r
- * the same queue multiple times from a single interrupt.  The first call\r
- * should always pass in pdFALSE.  Subsequent calls should pass in\r
- * the value returned from the previous call.  See the file serial .c in the\r
- * PC port for a good example of this mechanism.\r
+ * @param pxHigherPriorityTaskWoken xQueueGenericSendFromISR() will set\r
+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task\r
+ * to unblock, and the unblocked task has a priority higher than the currently\r
+ * running task.  If xQueueGenericSendFromISR() sets this value to pdTRUE then\r
+ * a context switch should be requested before the interrupt is exited.\r
  *\r
  * @param xCopyPosition Can take the value queueSEND_TO_BACK to place the\r
  * item at the back of the queue, or queueSEND_TO_FRONT to place the item\r
  * at the front of the queue (for high priority messages).\r
  *\r
- * @return pdTRUE if a task was woken by posting onto the queue.  This is\r
- * used by the ISR to determine if a context switch may be required following\r
- * the ISR.\r
+ * @return pdTRUE if the data was successfully sent to the queue, otherwise\r
+ * errQUEUE_FULL.\r
  *\r
  * Example usage for buffered IO (where the ISR can obtain more than one value\r
  * per call):\r
@@ -1047,10 +1025,10 @@ void vQueueDelete( xQueueHandle xQueue );
  void vBufferISR( void )\r
  {\r
  portCHAR cIn;\r
- portBASE_TYPE xTaskWokenByPost;\r
+ portBASE_TYPE xHigherPriorityTaskWokenByPost;\r
 \r
     // We have not woken a task at the start of the ISR.\r
-    cTaskWokenByPost = pdFALSE;\r
+    xHigherPriorityTaskWokenByPost = pdFALSE;\r
 \r
     // Loop until the buffer is empty.\r
     do\r
@@ -1058,21 +1036,16 @@ void vQueueDelete( xQueueHandle xQueue );
         // Obtain a byte from the buffer.\r
         cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );                                           \r
 \r
-        // Post the byte.  The first time round the loop cTaskWokenByPost\r
-        // will be pdFALSE.  If the queue send causes a task to wake we do\r
-        // not want the task to run until we have finished the ISR, so\r
-        // xQueueSendFromISR does not cause a context switch.  Also we\r
-        // don't want subsequent posts to wake any other tasks, so we store\r
-        // the return value back into cTaskWokenByPost so xQueueSendFromISR\r
-        // knows not to wake any task the next iteration of the loop.\r
-        xTaskWokenByPost = xQueueGenericSendFromISR( xRxQueue, &cIn, cTaskWokenByPost, queueSEND_TO_BACK );\r
+        // Post each byte.\r
+        xQueueGenericSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWokenByPost, queueSEND_TO_BACK );\r
 \r
     } while( portINPUT_BYTE( BUFFER_COUNT ) );\r
 \r
-    // Now the buffer is empty we can switch context if necessary.\r
-    if( cTaskWokenByPost )\r
+    // Now the buffer is empty we can switch context if necessary.  Note that the\r
+    // name of the yield function required is port specific.\r
+    if( xHigherPriorityTaskWokenByPost )\r
     {\r
-        taskYIELD ();\r
+        taskYIELD_YIELD_FROM_ISR();\r
     }\r
  }\r
  </pre>\r
@@ -1080,7 +1053,7 @@ void vQueueDelete( xQueueHandle xQueue );
  * \defgroup xQueueSendFromISR xQueueSendFromISR\r
  * \ingroup QueueManagement\r
  */\r
-signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE xTaskPreviouslyWoken, portBASE_TYPE xCopyPosition );\r
+signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition );\r
 \r
 /**\r
  * queue. h\r

diff --git a/Source/include/semphr.h b/Source/include/semphr.h
index e53dda77f8db482da26c22518b345ae0871bc0c2..accfa41a22324940bfc29e234e2f94c46d94b4bb 100644 (file)
--- a/Source/include/semphr.h
+++ b/Source/include/semphr.h
@@ -460,15 +460,13 @@ typedef xQueueHandle xSemaphoreHandle;
  * @param xSemaphore A handle to the semaphore being released.  This is the\r
  * handle returned when the semaphore was created.\r
  *\r
- * @param sTaskPreviouslyWoken This is included so an ISR can make multiple calls\r
- * to xSemaphoreGiveFromISR () from a single interrupt.  The first call\r
- * should always pass in pdFALSE.  Subsequent calls should pass in\r
- * the value returned from the previous call.  See the file serial .c in the\r
- * PC port for a good example of using xSemaphoreGiveFromISR ().\r
+ * @param pxHigherPriorityTaskWoken xSemaphoreGiveFromISR() will set\r
+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task\r
+ * to unblock, and the unblocked task has a priority higher than the currently\r
+ * running task.  If xSemaphoreGiveFromISR() sets this value to pdTRUE then\r
+ * a context switch should be requested before the interrupt is exited.\r
  *\r
- * @return pdTRUE if a task was woken by releasing the semaphore.  This is \r
- * used by the ISR to determine if a context switch may be required following\r
- * the ISR.\r
+ * @return pdTRUE if the semaphore was successfully given, otherwise errQUEUE_FULL.\r
  *\r
  * Example usage:\r
  <pre>\r
@@ -503,25 +501,25 @@ typedef xQueueHandle xSemaphoreHandle;
  void vTimerISR( void * pvParameters )\r
  {\r
  static unsigned portCHAR ucLocalTickCount = 0;\r
- static portBASE_TYPE xTaskWoken;\r
+ static portBASE_TYPE xHigherPriorityTaskWoken;\r
 \r
     // A timer tick has occurred.\r
 \r
     // ... Do other time functions.\r
 \r
     // Is it time for vATask () to run?\r
-       xTaskWoken = pdFALSE;\r
+       xHigherPriorityTaskWoken = pdFALSE;\r
     ucLocalTickCount++;\r
     if( ucLocalTickCount >= TICKS_TO_WAIT )\r
     {\r
         // Unblock the task by releasing the semaphore.\r
-        xTaskWoken = xSemaphoreGiveFromISR( xSemaphore, xTaskWoken );\r
+        xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );\r
 \r
         // Reset the count so we release the semaphore again in 10 ticks time.\r
         ucLocalTickCount = 0;\r
     }\r
 \r
-    if( xTaskWoken != pdFALSE )\r
+    if( xHigherPriorityTaskWoken != pdFALSE )\r
     {\r
         // We can force a context switch here.  Context switching from an\r
         // ISR uses port specific syntax.  Check the demo task for your port\r
@@ -532,7 +530,7 @@ typedef xQueueHandle xSemaphoreHandle;
  * \defgroup xSemaphoreGiveFromISR xSemaphoreGiveFromISR\r
  * \ingroup Semaphores\r
  */\r
-#define xSemaphoreGiveFromISR( xSemaphore, xTaskPreviouslyWoken )                      xQueueGenericSendFromISR( ( xQueueHandle ) xSemaphore, NULL, xTaskPreviouslyWoken, queueSEND_TO_BACK )\r
+#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )                 xQueueGenericSendFromISR( ( xQueueHandle ) xSemaphore, NULL, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )\r
 \r
 /**\r
  * semphr. h\r

diff --git a/Source/include/task.h b/Source/include/task.h
index fa5f6adbf68163096fb52db2582f6bc85b973a60..2341183953b3e00a1643104f1d3723b7ee9a6df4 100644 (file)
--- a/Source/include/task.h
+++ b/Source/include/task.h
@@ -66,7 +66,7 @@ extern "C" {
  * MACROS AND DEFINITIONS\r
  *----------------------------------------------------------*/\r
 \r
-#define tskKERNEL_VERSION_NUMBER "V4.7.2"\r
+#define tskKERNEL_VERSION_NUMBER "V5.0.0"\r
 \r
 /**\r
  * task. h\r
@@ -893,6 +893,29 @@ unsigned portLONG ulTaskEndTrace( void );
  */\r
 unsigned portBASE_TYPE uxTaskGetStackHighWaterMark( xTaskHandle xTask );\r
 \r
+/**\r
+ * task.h\r
+ * <pre>void vTaskSetApplicationTaskHook( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction );</pre>\r
+ *\r
+ * Sets pxHookFunction to be the task hook function used by the task xTask.\r
+ * Passing xTask as NULL has the effect of setting the calling tasks hook\r
+ * function.\r
+ */\r
+void vTaskSetApplicationTaskHook( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction );\r
+\r
+/**\r
+ * task.h\r
+ * <pre>portBASE_TYPE xTaskCallApplicationTaskHook( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction );</pre>\r
+ *\r
+ * Calls the hook function associated with xTask.  Passing xTask as NULL has\r
+ * the effect of calling the Running tasks (the calling task) hook function.\r
+ *\r
+ * pvParameter is passed to the hook function for the task to interpret as it\r
+ * wants.\r
+ */\r
+portBASE_TYPE xTaskCallApplicationTaskHook( xTaskHandle xTask, void *pvParameter );\r
+\r
+\r
 /*-----------------------------------------------------------\r
  * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES\r
  *----------------------------------------------------------*/\r