From cda22d9aaf553c420422cd6b3c5ecfc3ccc40a28 Mon Sep 17 00:00:00 2001 From: Ivan Grokhotkov Date: Fri, 1 Dec 2017 12:50:45 +0800 Subject: [PATCH 1/2] docs: add FreeRTOS API docs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Use `code` tags instead of a mix of `
` and
  `@verbatim .. @endverbatim`
- Remove manually added function prototypes from comment blocks
- Remove of grouping (`\defgroup`) — some extra work is needed
  to make groups compatible with the way we auto-generate API
  reference from Doxygen XML files. It's pretty easy to add the
  grouping directives back if/when we implement support for
  Doxygen groups in the later stages of documentation build
  process.
- Hide private APIs under `@cond .. @endcond`
- Convert some comments into Doxygen-compatible ones
- Fix various documentation issues: missing documentation for
  some parameters, mismatch between parameter names in comment
  block and in function prototype.
- Add doxygen comments for functions which didn't have them
  (thread local storage).
- Add [out] param tags where necessary
- Redefine `xTaskCreate` and `xTaskCreateStatic` as inline
  functions instead of macros.
---
 .../freertos/include/freertos/event_groups.h  |  617 +++----
 components/freertos/include/freertos/queue.h  | 1518 +++++++---------
 .../freertos/include/freertos/ringbuf.h       |  254 +--
 components/freertos/include/freertos/semphr.h |  876 +++++----
 components/freertos/include/freertos/task.h   | 1577 +++++++++--------
 components/freertos/include/freertos/timers.h |  125 +-
 docs/Doxyfile                                 |   23 +-
 docs/api-reference/system/freertos.rst        |   42 +
 docs/api-reference/system/hooks.rst           |    4 +-
 docs/api-reference/system/index.rst           |   11 +-
 10 files changed, 2420 insertions(+), 2627 deletions(-)
 create mode 100644 docs/api-reference/system/freertos.rst

diff --git a/components/freertos/include/freertos/event_groups.h b/components/freertos/include/freertos/event_groups.h
index a2d70a43f3..6b83e04e18 100644
--- a/components/freertos/include/freertos/event_groups.h
+++ b/components/freertos/include/freertos/event_groups.h
@@ -104,7 +104,6 @@ extern "C" {
  * used to create a synchronisation point between multiple tasks (a
  * 'rendezvous').
  *
- * \defgroup EventGroup
  */
 
 
@@ -116,7 +115,6 @@ extern "C" {
  * xEventGroupCreate() returns an EventGroupHandle_t variable that can then
  * be used as a parameter to other event group functions.
  *
- * \defgroup EventGroupHandle_t EventGroupHandle_t
  * \ingroup EventGroup
  */
 typedef void * EventGroupHandle_t;
@@ -126,17 +124,11 @@ typedef void * EventGroupHandle_t;
  * number of bits it holds is set by configUSE_16_BIT_TICKS (16 bits if set to 1,
  * 32 bits if set to 0. 
  *
- * \defgroup EventBits_t EventBits_t
  * \ingroup EventGroup
  */
 typedef TickType_t EventBits_t;
 
 /**
- * event_groups.h
- *
- EventGroupHandle_t xEventGroupCreate( void );
- 

- *
  * Create a new event group.
  *
  * Internally, within the FreeRTOS implementation, event groups use a [small]
@@ -162,25 +154,24 @@ typedef TickType_t EventBits_t;
  * event group then NULL is returned.  See http://www.freertos.org/a00111.html
  *
  * Example usage:
-   
-	// Declare a variable to hold the created event group.
-	EventGroupHandle_t xCreatedEventGroup;
-
-	// Attempt to create the event group.
-	xCreatedEventGroup = xEventGroupCreate();
-
-	// Was the event group created successfully?
-	if( xCreatedEventGroup == NULL )
-	{
-		// The event group was not created because there was insufficient
-		// FreeRTOS heap available.
-	}
-	else
-	{
-		// The event group was created.
-	}
-   

- * \defgroup xEventGroupCreate xEventGroupCreate
+ * @code{c}
+ * 	// Declare a variable to hold the created event group.
+ * 	EventGroupHandle_t xCreatedEventGroup;
+ *
+ * 	// Attempt to create the event group.
+ * 	xCreatedEventGroup = xEventGroupCreate();
+ *
+ * 	// Was the event group created successfully?
+ * 	if( xCreatedEventGroup == NULL )
+ * 	{
+ * 		// The event group was not created because there was insufficient
+ * 		// FreeRTOS heap available.
+ * 	}
+ * 	else
+ * 	{
+ * 		// The event group was created.
+ * 	}
+ * @endcode
  * \ingroup EventGroup
  */
 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
@@ -188,11 +179,6 @@ typedef TickType_t EventBits_t;
 #endif
 
 /**
- * event_groups.h
- *
- EventGroupHandle_t xEventGroupCreateStatic( EventGroupHandle_t * pxEventGroupBuffer );
- 

- *
  * Create a new event group.
  *
  * Internally, within the FreeRTOS implementation, event groups use a [small]
@@ -221,35 +207,26 @@ typedef TickType_t EventBits_t;
  * returned.  If pxEventGroupBuffer was NULL then NULL is returned.
  *
  * Example usage:
-   
-	// StaticEventGroup_t is a publicly accessible structure that has the same
-	// size and alignment requirements as the real event group structure.  It is
-	// provided as a mechanism for applications to know the size of the event
-	// group (which is dependent on the architecture and configuration file
-	// settings) without breaking the strict data hiding policy by exposing the
-	// real event group internals.  This StaticEventGroup_t variable is passed
-	// into the xSemaphoreCreateEventGroupStatic() function and is used to store
-	// the event group's data structures
-	StaticEventGroup_t xEventGroupBuffer;
-
-	// Create the event group without dynamically allocating any memory.
-	xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );
-   

+ * @code{c}
+ * 	// StaticEventGroup_t is a publicly accessible structure that has the same
+ * 	// size and alignment requirements as the real event group structure.  It is
+ * 	// provided as a mechanism for applications to know the size of the event
+ * 	// group (which is dependent on the architecture and configuration file
+ * 	// settings) without breaking the strict data hiding policy by exposing the
+ * 	// real event group internals.  This StaticEventGroup_t variable is passed
+ * 	// into the xSemaphoreCreateEventGroupStatic() function and is used to store
+ * 	// the event group's data structures
+ * 	StaticEventGroup_t xEventGroupBuffer;
+ *
+ * 	// Create the event group without dynamically allocating any memory.
+ * 	xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );
+ * @endcode
  */
 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
 	EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer ) PRIVILEGED_FUNCTION;
 #endif
 
 /**
- * event_groups.h
- *
-	EventBits_t xEventGroupWaitBits( 	EventGroupHandle_t xEventGroup,
-										const EventBits_t uxBitsToWaitFor,
-										const BaseType_t xClearOnExit,
-										const BaseType_t xWaitForAllBits,
-										const TickType_t xTicksToWait );
- 

- *
  * [Potentially] block to wait for one or more bits to be set within a
  * previously created event group.
  *
@@ -292,54 +269,48 @@ typedef TickType_t EventBits_t;
  * pdTRUE.
  *
  * Example usage:
-   
-   #define BIT_0	( 1 << 0 )
-   #define BIT_4	( 1 << 4 )
-
-   void aFunction( EventGroupHandle_t xEventGroup )
-   {
-   EventBits_t uxBits;
-   const TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
-
-		// Wait a maximum of 100ms for either bit 0 or bit 4 to be set within
-		// the event group.  Clear the bits before exiting.
-		uxBits = xEventGroupWaitBits(
-					xEventGroup,	// The event group being tested.
-					BIT_0 | BIT_4,	// The bits within the event group to wait for.
-					pdTRUE,			// BIT_0 and BIT_4 should be cleared before returning.
-					pdFALSE,		// Don't wait for both bits, either bit will do.
-					xTicksToWait );	// Wait a maximum of 100ms for either bit to be set.
-
-		if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
-		{
-			// xEventGroupWaitBits() returned because both bits were set.
-		}
-		else if( ( uxBits & BIT_0 ) != 0 )
-		{
-			// xEventGroupWaitBits() returned because just BIT_0 was set.
-		}
-		else if( ( uxBits & BIT_4 ) != 0 )
-		{
-			// xEventGroupWaitBits() returned because just BIT_4 was set.
-		}
-		else
-		{
-			// xEventGroupWaitBits() returned because xTicksToWait ticks passed
-			// without either BIT_0 or BIT_4 becoming set.
-		}
-   }
-   

- * \defgroup xEventGroupWaitBits xEventGroupWaitBits
+ * @code{c}
+ *    #define BIT_0	( 1 << 0 )
+ *    #define BIT_4	( 1 << 4 )
+ *
+ *    void aFunction( EventGroupHandle_t xEventGroup )
+ *    {
+ *    EventBits_t uxBits;
+ *    const TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
+ *
+ * 		// Wait a maximum of 100ms for either bit 0 or bit 4 to be set within
+ * 		// the event group.  Clear the bits before exiting.
+ * 		uxBits = xEventGroupWaitBits(
+ * 					xEventGroup,	// The event group being tested.
+ * 					BIT_0 | BIT_4,	// The bits within the event group to wait for.
+ * 					pdTRUE,			// BIT_0 and BIT_4 should be cleared before returning.
+ * 					pdFALSE,		// Don't wait for both bits, either bit will do.
+ * 					xTicksToWait );	// Wait a maximum of 100ms for either bit to be set.
+ *
+ * 		if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
+ * 		{
+ * 			// xEventGroupWaitBits() returned because both bits were set.
+ * 		}
+ * 		else if( ( uxBits & BIT_0 ) != 0 )
+ * 		{
+ * 			// xEventGroupWaitBits() returned because just BIT_0 was set.
+ * 		}
+ * 		else if( ( uxBits & BIT_4 ) != 0 )
+ * 		{
+ * 			// xEventGroupWaitBits() returned because just BIT_4 was set.
+ * 		}
+ * 		else
+ * 		{
+ * 			// xEventGroupWaitBits() returned because xTicksToWait ticks passed
+ * 			// without either BIT_0 or BIT_4 becoming set.
+ * 		}
+ *    }
+ * @endcode{c}
  * \ingroup EventGroup
  */
 EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
 /**
- * event_groups.h
- *
-	EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear );
- 

- *
  * Clear bits within an event group.  This function cannot be called from an
  * interrupt.
  *
@@ -352,51 +323,45 @@ EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits
  * @return The value of the event group before the specified bits were cleared.
  *
  * Example usage:
-   
-   #define BIT_0	( 1 << 0 )
-   #define BIT_4	( 1 << 4 )
-
-   void aFunction( EventGroupHandle_t xEventGroup )
-   {
-   EventBits_t uxBits;
-
-		// Clear bit 0 and bit 4 in xEventGroup.
-		uxBits = xEventGroupClearBits(
-								xEventGroup,	// The event group being updated.
-								BIT_0 | BIT_4 );// The bits being cleared.
-
-		if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
-		{
-			// Both bit 0 and bit 4 were set before xEventGroupClearBits() was
-			// called.  Both will now be clear (not set).
-		}
-		else if( ( uxBits & BIT_0 ) != 0 )
-		{
-			// Bit 0 was set before xEventGroupClearBits() was called.  It will
-			// now be clear.
-		}
-		else if( ( uxBits & BIT_4 ) != 0 )
-		{
-			// Bit 4 was set before xEventGroupClearBits() was called.  It will
-			// now be clear.
-		}
-		else
-		{
-			// Neither bit 0 nor bit 4 were set in the first place.
-		}
-   }
-   

- * \defgroup xEventGroupClearBits xEventGroupClearBits
+ * @code{c}
+ *    #define BIT_0	( 1 << 0 )
+ *    #define BIT_4	( 1 << 4 )
+ *
+ *    void aFunction( EventGroupHandle_t xEventGroup )
+ *    {
+ *    EventBits_t uxBits;
+ *
+ * 		// Clear bit 0 and bit 4 in xEventGroup.
+ * 		uxBits = xEventGroupClearBits(
+ * 								xEventGroup,	// The event group being updated.
+ * 								BIT_0 | BIT_4 );// The bits being cleared.
+ *
+ * 		if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
+ * 		{
+ * 			// Both bit 0 and bit 4 were set before xEventGroupClearBits() was
+ * 			// called.  Both will now be clear (not set).
+ * 		}
+ * 		else if( ( uxBits & BIT_0 ) != 0 )
+ * 		{
+ * 			// Bit 0 was set before xEventGroupClearBits() was called.  It will
+ * 			// now be clear.
+ * 		}
+ * 		else if( ( uxBits & BIT_4 ) != 0 )
+ * 		{
+ * 			// Bit 4 was set before xEventGroupClearBits() was called.  It will
+ * 			// now be clear.
+ * 		}
+ * 		else
+ * 		{
+ * 			// Neither bit 0 nor bit 4 were set in the first place.
+ * 		}
+ *    }
+ * @endcode
  * \ingroup EventGroup
  */
 EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
 
 /**
- * event_groups.h
- *
-	BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
- 

- *
  * A version of xEventGroupClearBits() that can be called from an interrupt.
  *
  * Setting bits in an event group is not a deterministic operation because there
@@ -420,28 +385,27 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBit
  * if the timer service queue was full.
  *
  * Example usage:
-   
-   #define BIT_0	( 1 << 0 )
-   #define BIT_4	( 1 << 4 )
-
-   // An event group which it is assumed has already been created by a call to
-   // xEventGroupCreate().
-   EventGroupHandle_t xEventGroup;
-
-   void anInterruptHandler( void )
-   {
-		// Clear bit 0 and bit 4 in xEventGroup.
-		xResult = xEventGroupClearBitsFromISR(
-							xEventGroup,	 // The event group being updated.
-							BIT_0 | BIT_4 ); // The bits being set.
-
-		if( xResult == pdPASS )
-		{
-			// The message was posted successfully.
-		}
-  }
-   

- * \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR
+ * @code{c}
+ *    #define BIT_0	( 1 << 0 )
+ *    #define BIT_4	( 1 << 4 )
+ *
+ *    // An event group which it is assumed has already been created by a call to
+ *    // xEventGroupCreate().
+ *    EventGroupHandle_t xEventGroup;
+ *
+ *    void anInterruptHandler( void )
+ *    {
+ * 		// Clear bit 0 and bit 4 in xEventGroup.
+ * 		xResult = xEventGroupClearBitsFromISR(
+ * 							xEventGroup,	 // The event group being updated.
+ * 							BIT_0 | BIT_4 ); // The bits being set.
+ *
+ * 		if( xResult == pdPASS )
+ * 		{
+ * 			// The message was posted successfully.
+ * 		}
+ *   }
+ * @endcode
  * \ingroup EventGroup
  */
 #if( configUSE_TRACE_FACILITY == 1 )
@@ -451,11 +415,6 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBit
 #endif
 
 /**
- * event_groups.h
- *
-	EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
- 

- *
  * Set bits within an event group.
  * This function cannot be called from an interrupt.  xEventGroupSetBitsFromISR()
  * is a version that can be called from an interrupt.
@@ -480,56 +439,50 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBit
  * event group value before the call to xEventGroupSetBits() returns.
  *
  * Example usage:
-   
-   #define BIT_0	( 1 << 0 )
-   #define BIT_4	( 1 << 4 )
-
-   void aFunction( EventGroupHandle_t xEventGroup )
-   {
-   EventBits_t uxBits;
-
-		// Set bit 0 and bit 4 in xEventGroup.
-		uxBits = xEventGroupSetBits(
-							xEventGroup,	// The event group being updated.
-							BIT_0 | BIT_4 );// The bits being set.
-
-		if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
-		{
-			// Both bit 0 and bit 4 remained set when the function returned.
-		}
-		else if( ( uxBits & BIT_0 ) != 0 )
-		{
-			// Bit 0 remained set when the function returned, but bit 4 was
-			// cleared.  It might be that bit 4 was cleared automatically as a
-			// task that was waiting for bit 4 was removed from the Blocked
-			// state.
-		}
-		else if( ( uxBits & BIT_4 ) != 0 )
-		{
-			// Bit 4 remained set when the function returned, but bit 0 was
-			// cleared.  It might be that bit 0 was cleared automatically as a
-			// task that was waiting for bit 0 was removed from the Blocked
-			// state.
-		}
-		else
-		{
-			// Neither bit 0 nor bit 4 remained set.  It might be that a task
-			// was waiting for both of the bits to be set, and the bits were
-			// cleared as the task left the Blocked state.
-		}
-   }
-   

- * \defgroup xEventGroupSetBits xEventGroupSetBits
+ * @code{c}
+ *    #define BIT_0	( 1 << 0 )
+ *    #define BIT_4	( 1 << 4 )
+ *
+ *    void aFunction( EventGroupHandle_t xEventGroup )
+ *    {
+ *    EventBits_t uxBits;
+ *
+ * 		// Set bit 0 and bit 4 in xEventGroup.
+ * 		uxBits = xEventGroupSetBits(
+ * 							xEventGroup,	// The event group being updated.
+ * 							BIT_0 | BIT_4 );// The bits being set.
+ *
+ * 		if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
+ * 		{
+ * 			// Both bit 0 and bit 4 remained set when the function returned.
+ * 		}
+ * 		else if( ( uxBits & BIT_0 ) != 0 )
+ * 		{
+ * 			// Bit 0 remained set when the function returned, but bit 4 was
+ * 			// cleared.  It might be that bit 4 was cleared automatically as a
+ * 			// task that was waiting for bit 4 was removed from the Blocked
+ * 			// state.
+ * 		}
+ * 		else if( ( uxBits & BIT_4 ) != 0 )
+ * 		{
+ * 			// Bit 4 remained set when the function returned, but bit 0 was
+ * 			// cleared.  It might be that bit 0 was cleared automatically as a
+ * 			// task that was waiting for bit 0 was removed from the Blocked
+ * 			// state.
+ * 		}
+ * 		else
+ * 		{
+ * 			// Neither bit 0 nor bit 4 remained set.  It might be that a task
+ * 			// was waiting for both of the bits to be set, and the bits were
+ * 			// cleared as the task left the Blocked state.
+ * 		}
+ *    }
+ * @endcode{c}
  * \ingroup EventGroup
  */
 EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
 
 /**
- * event_groups.h
- *
-	BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken );
- 

- *
  * A version of xEventGroupSetBits() that can be called from an interrupt.
  *
  * Setting bits in an event group is not a deterministic operation because there
@@ -561,39 +514,38 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_
  * if the timer service queue was full.
  *
  * Example usage:
-   
-   #define BIT_0	( 1 << 0 )
-   #define BIT_4	( 1 << 4 )
-
-   // An event group which it is assumed has already been created by a call to
-   // xEventGroupCreate().
-   EventGroupHandle_t xEventGroup;
-
-   void anInterruptHandler( void )
-   {
-   BaseType_t xHigherPriorityTaskWoken, xResult;
-
-		// xHigherPriorityTaskWoken must be initialised to pdFALSE.
-		xHigherPriorityTaskWoken = pdFALSE;
-
-		// Set bit 0 and bit 4 in xEventGroup.
-		xResult = xEventGroupSetBitsFromISR(
-							xEventGroup,	// The event group being updated.
-							BIT_0 | BIT_4   // The bits being set.
-							&xHigherPriorityTaskWoken );
-
-		// Was the message posted successfully?
-		if( xResult == pdPASS )
-		{
-			// If xHigherPriorityTaskWoken is now set to pdTRUE then a context
-			// switch should be requested.  The macro used is port specific and 
-			// will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() - 
-			// refer to the documentation page for the port being used.
-			portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
-		}
-  }
-   

- * \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR
+ * @code{c}
+ *    #define BIT_0	( 1 << 0 )
+ *    #define BIT_4	( 1 << 4 )
+ *
+ *    // An event group which it is assumed has already been created by a call to
+ *    // xEventGroupCreate().
+ *    EventGroupHandle_t xEventGroup;
+ *
+ *    void anInterruptHandler( void )
+ *    {
+ *    BaseType_t xHigherPriorityTaskWoken, xResult;
+ *
+ * 		// xHigherPriorityTaskWoken must be initialised to pdFALSE.
+ * 		xHigherPriorityTaskWoken = pdFALSE;
+ *
+ * 		// Set bit 0 and bit 4 in xEventGroup.
+ * 		xResult = xEventGroupSetBitsFromISR(
+ * 							xEventGroup,	// The event group being updated.
+ * 							BIT_0 | BIT_4   // The bits being set.
+ * 							&xHigherPriorityTaskWoken );
+ *
+ * 		// Was the message posted successfully?
+ * 		if( xResult == pdPASS )
+ * 		{
+ * 			// If xHigherPriorityTaskWoken is now set to pdTRUE then a context
+ * 			// switch should be requested.  The macro used is port specific and
+ * 			// will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() -
+ * 			// refer to the documentation page for the port being used.
+ * 			portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
+ * 		}
+ *   }
+ * @endcode
  * \ingroup EventGroup
  */
 #if( configUSE_TRACE_FACILITY == 1 )
@@ -603,14 +555,6 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_
 #endif
 
 /**
- * event_groups.h
- *
-	EventBits_t xEventGroupSync(	EventGroupHandle_t xEventGroup,
-									const EventBits_t uxBitsToSet,
-									const EventBits_t uxBitsToWaitFor,
-									TickType_t xTicksToWait );
- 

- *
  * Atomically set bits within an event group, then wait for a combination of
  * bits to be set within the same event group.  This functionality is typically
  * used to synchronise multiple tasks, where each task has to wait for the other
@@ -648,93 +592,87 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_
  * automatically cleared.
  *
  * Example usage:
- 
- // Bits used by the three tasks.
- #define TASK_0_BIT		( 1 << 0 )
- #define TASK_1_BIT		( 1 << 1 )
- #define TASK_2_BIT		( 1 << 2 )
-
- #define ALL_SYNC_BITS ( TASK_0_BIT | TASK_1_BIT | TASK_2_BIT )
-
- // Use an event group to synchronise three tasks.  It is assumed this event
- // group has already been created elsewhere.
- EventGroupHandle_t xEventBits;
-
- void vTask0( void *pvParameters )
- {
- EventBits_t uxReturn;
- TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
-
-	 for( ;; )
-	 {
-		// Perform task functionality here.
-
-		// Set bit 0 in the event flag to note this task has reached the
-		// sync point.  The other two tasks will set the other two bits defined
-		// by ALL_SYNC_BITS.  All three tasks have reached the synchronisation
-		// point when all the ALL_SYNC_BITS are set.  Wait a maximum of 100ms
-		// for this to happen.
-		uxReturn = xEventGroupSync( xEventBits, TASK_0_BIT, ALL_SYNC_BITS, xTicksToWait );
-
-		if( ( uxReturn & ALL_SYNC_BITS ) == ALL_SYNC_BITS )
-		{
-			// All three tasks reached the synchronisation point before the call
-			// to xEventGroupSync() timed out.
-		}
-	}
- }
-
- void vTask1( void *pvParameters )
- {
-	 for( ;; )
-	 {
-		// Perform task functionality here.
-
-		// Set bit 1 in the event flag to note this task has reached the
-		// synchronisation point.  The other two tasks will set the other two
-		// bits defined by ALL_SYNC_BITS.  All three tasks have reached the
-		// synchronisation point when all the ALL_SYNC_BITS are set.  Wait
-		// indefinitely for this to happen.
-		xEventGroupSync( xEventBits, TASK_1_BIT, ALL_SYNC_BITS, portMAX_DELAY );
-
-		// xEventGroupSync() was called with an indefinite block time, so
-		// this task will only reach here if the syncrhonisation was made by all
-		// three tasks, so there is no need to test the return value.
-	 }
- }
-
- void vTask2( void *pvParameters )
- {
-	 for( ;; )
-	 {
-		// Perform task functionality here.
-
-		// Set bit 2 in the event flag to note this task has reached the
-		// synchronisation point.  The other two tasks will set the other two
-		// bits defined by ALL_SYNC_BITS.  All three tasks have reached the
-		// synchronisation point when all the ALL_SYNC_BITS are set.  Wait
-		// indefinitely for this to happen.
-		xEventGroupSync( xEventBits, TASK_2_BIT, ALL_SYNC_BITS, portMAX_DELAY );
-
-		// xEventGroupSync() was called with an indefinite block time, so
-		// this task will only reach here if the syncrhonisation was made by all
-		// three tasks, so there is no need to test the return value.
-	}
- }
-
- 

- * \defgroup xEventGroupSync xEventGroupSync
+ * @code{c}
+ *  // Bits used by the three tasks.
+ *  #define TASK_0_BIT		( 1 << 0 )
+ *  #define TASK_1_BIT		( 1 << 1 )
+ *  #define TASK_2_BIT		( 1 << 2 )
+ *
+ *  #define ALL_SYNC_BITS ( TASK_0_BIT | TASK_1_BIT | TASK_2_BIT )
+ *
+ *  // Use an event group to synchronise three tasks.  It is assumed this event
+ *  // group has already been created elsewhere.
+ *  EventGroupHandle_t xEventBits;
+ *
+ *  void vTask0( void *pvParameters )
+ *  {
+ *  EventBits_t uxReturn;
+ *  TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
+ *
+ * 	 for( ;; )
+ * 	 {
+ * 		// Perform task functionality here.
+ *
+ * 		// Set bit 0 in the event flag to note this task has reached the
+ * 		// sync point.  The other two tasks will set the other two bits defined
+ * 		// by ALL_SYNC_BITS.  All three tasks have reached the synchronisation
+ * 		// point when all the ALL_SYNC_BITS are set.  Wait a maximum of 100ms
+ * 		// for this to happen.
+ * 		uxReturn = xEventGroupSync( xEventBits, TASK_0_BIT, ALL_SYNC_BITS, xTicksToWait );
+ *
+ * 		if( ( uxReturn & ALL_SYNC_BITS ) == ALL_SYNC_BITS )
+ * 		{
+ * 			// All three tasks reached the synchronisation point before the call
+ * 			// to xEventGroupSync() timed out.
+ * 		}
+ * 	}
+ *  }
+ *
+ *  void vTask1( void *pvParameters )
+ *  {
+ * 	 for( ;; )
+ * 	 {
+ * 		// Perform task functionality here.
+ *
+ * 		// Set bit 1 in the event flag to note this task has reached the
+ * 		// synchronisation point.  The other two tasks will set the other two
+ * 		// bits defined by ALL_SYNC_BITS.  All three tasks have reached the
+ * 		// synchronisation point when all the ALL_SYNC_BITS are set.  Wait
+ * 		// indefinitely for this to happen.
+ * 		xEventGroupSync( xEventBits, TASK_1_BIT, ALL_SYNC_BITS, portMAX_DELAY );
+ *
+ * 		// xEventGroupSync() was called with an indefinite block time, so
+ * 		// this task will only reach here if the syncrhonisation was made by all
+ * 		// three tasks, so there is no need to test the return value.
+ * 	 }
+ *  }
+ *
+ *  void vTask2( void *pvParameters )
+ *  {
+ * 	 for( ;; )
+ * 	 {
+ * 		// Perform task functionality here.
+ *
+ * 		// Set bit 2 in the event flag to note this task has reached the
+ * 		// synchronisation point.  The other two tasks will set the other two
+ * 		// bits defined by ALL_SYNC_BITS.  All three tasks have reached the
+ * 		// synchronisation point when all the ALL_SYNC_BITS are set.  Wait
+ * 		// indefinitely for this to happen.
+ * 		xEventGroupSync( xEventBits, TASK_2_BIT, ALL_SYNC_BITS, portMAX_DELAY );
+ *
+ * 		// xEventGroupSync() was called with an indefinite block time, so
+ * 		// this task will only reach here if the syncrhonisation was made by all
+ * 		// three tasks, so there is no need to test the return value.
+ * 	}
+ *  }
+ *
+ * @endcode
  * \ingroup EventGroup
  */
 EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
 
 /**
- * event_groups.h
- *
-	EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup );
- 

- *
  * Returns the current value of the bits in an event group.  This function
  * cannot be used from an interrupt.
  *
@@ -742,33 +680,22 @@ EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t u
  *
  * @return The event group bits at the time xEventGroupGetBits() was called.
  *
- * \defgroup xEventGroupGetBits xEventGroupGetBits
  * \ingroup EventGroup
  */
 #define xEventGroupGetBits( xEventGroup ) xEventGroupClearBits( xEventGroup, 0 )
 
 /**
- * event_groups.h
- *
-	EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
- 

- *
  * A version of xEventGroupGetBits() that can be called from an ISR.
  *
  * @param xEventGroup The event group being queried.
  *
  * @return The event group bits at the time xEventGroupGetBitsFromISR() was called.
  *
- * \defgroup xEventGroupGetBitsFromISR xEventGroupGetBitsFromISR
  * \ingroup EventGroup
  */
 EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
 
 /**
- * event_groups.h
- *
-	void xEventGroupDelete( EventGroupHandle_t xEventGroup );
- 

  *
  * Delete an event group that was previously created by a call to
  * xEventGroupCreate().  Tasks that are blocked on the event group will be
@@ -778,6 +705,8 @@ EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
  */
 void vEventGroupDelete( EventGroupHandle_t xEventGroup );
 
+/** @cond */
+
 /* For internal use only. */
 void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet );
 void vEventGroupClearBitsCallback( void *pvEventGroup, const uint32_t ulBitsToClear );
@@ -786,6 +715,8 @@ void vEventGroupClearBitsCallback( void *pvEventGroup, const uint32_t ulBitsToCl
 	UBaseType_t uxEventGroupGetNumber( void* xEventGroup );
 #endif
 
+/** @endcond */
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/components/freertos/include/freertos/queue.h b/components/freertos/include/freertos/queue.h
index 638157765a..e15152ee97 100644
--- a/components/freertos/include/freertos/queue.h
+++ b/components/freertos/include/freertos/queue.h
@@ -101,6 +101,7 @@ typedef void * QueueSetHandle_t;
  */
 typedef void * QueueSetMemberHandle_t;
 
+/** @cond */
 /* For internal use only. */
 #define	queueSEND_TO_BACK		( ( BaseType_t ) 0 )
 #define	queueSEND_TO_FRONT		( ( BaseType_t ) 1 )
@@ -114,15 +115,9 @@ typedef void * QueueSetMemberHandle_t;
 #define queueQUEUE_TYPE_BINARY_SEMAPHORE	( ( uint8_t ) 3U )
 #define queueQUEUE_TYPE_RECURSIVE_MUTEX		( ( uint8_t ) 4U )
 
+/** @endcond */
+
 /**
- * queue. h
- * 
- QueueHandle_t xQueueCreate(
-							  UBaseType_t uxQueueLength,
-							  UBaseType_t uxItemSize
-						  );
- * 

- *
  * Creates a new queue instance.  This allocates the storage required by the
  * new queue and returns a handle for the queue.
  *
@@ -138,36 +133,35 @@ typedef void * QueueSetMemberHandle_t;
  * returned.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- };
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
-
-	// Create a queue capable of containing 10 uint32_t values.
-	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-	if( xQueue1 == 0 )
-	{
-		// Queue was not created and must not be used.
-	}
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-	if( xQueue2 == 0 )
-	{
-		// Queue was not created and must not be used.
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueCreate xQueueCreate
+ * @code{c}
+ *  struct AMessage
+ *  {
+ *  char ucMessageID;
+ *  char ucData[ 20 ];
+ *  };
+ *
+ *  void vATask( void *pvParameters )
+ *  {
+ *  QueueHandle_t xQueue1, xQueue2;
+ *
+ *  // Create a queue capable of containing 10 uint32_t values.
+ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
+ *  if( xQueue1 == 0 )
+ *  {
+ *      // Queue was not created and must not be used.
+ *  }
+ *
+ *  // Create a queue capable of containing 10 pointers to AMessage structures.
+ *  // These should be passed by pointer as they contain a lot of data.
+ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ *  if( xQueue2 == 0 )
+ *  {
+ *      // Queue was not created and must not be used.
+ *  }
+ *
+ *  // ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
@@ -175,16 +169,6 @@ typedef void * QueueSetMemberHandle_t;
 #endif
 
 /**
- * queue. h
- * 
- QueueHandle_t xQueueCreateStatic(
-							  UBaseType_t uxQueueLength,
-							  UBaseType_t uxItemSize,
-							  uint8_t *pucQueueStorageBuffer,
-							  StaticQueue_t *pxQueueBuffer
-						  );
- * 

- *
  * Creates a new queue instance, and returns a handle by which the new queue
  * can be referenced.
  *
@@ -207,7 +191,7 @@ typedef void * QueueSetMemberHandle_t;
  * that will be copied for each posted item.  Each item on the queue must be
  * the same size.
  *
- * @param pucQueueStorageBuffer If uxItemSize is not zero then
+ * @param pucQueueStorage If uxItemSize is not zero then
  * pucQueueStorageBuffer must point to a uint8_t array that is at least large
  * enough to hold the maximum number of items that can be in the queue at any
  * one time - which is ( uxQueueLength * uxItemsSize ) bytes.  If uxItemSize is
@@ -220,40 +204,39 @@ typedef void * QueueSetMemberHandle_t;
  * returned.  If pxQueueBuffer is NULL then NULL is returned.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- };
-
- #define QUEUE_LENGTH 10
- #define ITEM_SIZE sizeof( uint32_t )
-
- // xQueueBuffer will hold the queue structure.
- StaticQueue_t xQueueBuffer;
-
- // ucQueueStorage will hold the items posted to the queue.  Must be at least
- // [(queue length) * ( queue item size)] bytes long.
- uint8_t ucQueueStorage[ QUEUE_LENGTH * ITEM_SIZE ];
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1;
-
-	// Create a queue capable of containing 10 uint32_t values.
-	xQueue1 = xQueueCreate( QUEUE_LENGTH, // The number of items the queue can hold.
-							ITEM_SIZE	  // The size of each item in the queue
-							&( ucQueueStorage[ 0 ] ), // The buffer that will hold the items in the queue.
-							&xQueueBuffer ); // The buffer that will hold the queue structure.
-
-	// The queue is guaranteed to be created successfully as no dynamic memory
-	// allocation is used.  Therefore xQueue1 is now a handle to a valid queue.
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueCreateStatic xQueueCreateStatic
+ * @code{c}
+ * struct AMessage
+ * {
+ *  char ucMessageID;
+ *  char ucData[ 20 ];
+ * };
+ *
+ * #define QUEUE_LENGTH 10
+ * #define ITEM_SIZE sizeof( uint32_t )
+ *
+ * // xQueueBuffer will hold the queue structure.
+ * StaticQueue_t xQueueBuffer;
+ *
+ * // ucQueueStorage will hold the items posted to the queue.  Must be at least
+ * // [(queue length) * ( queue item size)] bytes long.
+ * uint8_t ucQueueStorage[ QUEUE_LENGTH * ITEM_SIZE ];
+ *
+ * void vATask( void *pvParameters )
+ * {
+ *  QueueHandle_t xQueue1;
+ *
+ *  // Create a queue capable of containing 10 uint32_t values.
+ *  xQueue1 = xQueueCreate( QUEUE_LENGTH, // The number of items the queue can hold.
+ *                          ITEM_SIZE     // The size of each item in the queue
+ *                          &( ucQueueStorage[ 0 ] ), // The buffer that will hold the items in the queue.
+ *                          &xQueueBuffer ); // The buffer that will hold the queue structure.
+ *
+ *  // The queue is guaranteed to be created successfully as no dynamic memory
+ *  // allocation is used.  Therefore xQueue1 is now a handle to a valid queue.
+ *
+ *  // ... Rest of task code.
+ * }
+ * @endcode
  * \ingroup QueueManagement
  */
 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
@@ -261,15 +244,6 @@ typedef void * QueueSetMemberHandle_t;
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
- * queue. h
- * 
- BaseType_t xQueueSendToToFront(
-								   QueueHandle_t	xQueue,
-								   const void		*pvItemToQueue,
-								   TickType_t		xTicksToWait
-							   );
- * 

- *
  * This is a macro that calls xQueueGenericSend().
  *
  * Post an item to the front of a queue.  The item is queued by copy, not by
@@ -293,65 +267,55 @@ typedef void * QueueSetMemberHandle_t;
  * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-	// Create a queue capable of containing 10 uint32_t values.
-	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-	// ...
-
-	if( xQueue1 != 0 )
-	{
-		// Send an uint32_t.  Wait for 10 ticks for space to become
-		// available if necessary.
-		if( xQueueSendToFront( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
-		{
-			// Failed to post the message, even after 10 ticks.
-		}
-	}
-
-	if( xQueue2 != 0 )
-	{
-		// Send a pointer to a struct AMessage object.  Don't block if the
-		// queue is already full.
-		pxMessage = & xMessage;
-		xQueueSendToFront( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueSend xQueueSend
+ * @code{c}
+ *  struct AMessage
+ *  {
+ *  char ucMessageID;
+ *  char ucData[ 20 ];
+ *  } xMessage;
+ *
+ *  uint32_t ulVar = 10UL;
+ *
+ *  void vATask( void *pvParameters )
+ *  {
+ *  QueueHandle_t xQueue1, xQueue2;
+ *  struct AMessage *pxMessage;
+ *
+ *  // Create a queue capable of containing 10 uint32_t values.
+ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
+ *
+ *  // Create a queue capable of containing 10 pointers to AMessage structures.
+ *  // These should be passed by pointer as they contain a lot of data.
+ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ *
+ *  // ...
+ *
+ *  if( xQueue1 != 0 )
+ *  {
+ *      // Send an uint32_t.  Wait for 10 ticks for space to become
+ *      // available if necessary.
+ *      if( xQueueSendToFront( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
+ *      {
+ *          // Failed to post the message, even after 10 ticks.
+ *      }
+ *  }
+ *
+ *  if( xQueue2 != 0 )
+ *  {
+ *      // Send a pointer to a struct AMessage object.  Don't block if the
+ *      // queue is already full.
+ *      pxMessage = & xMessage;
+ *      xQueueSendToFront( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
+ *  }
+ *
+ *  // ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
 
 /**
- * queue. h
- * 
- BaseType_t xQueueSendToBack(
-								   QueueHandle_t	xQueue,
-								   const void		*pvItemToQueue,
-								   TickType_t		xTicksToWait
-							   );
- * 

- *
  * This is a macro that calls xQueueGenericSend().
  *
  * Post an item to the back of a queue.  The item is queued by copy, not by
@@ -375,65 +339,55 @@ typedef void * QueueSetMemberHandle_t;
  * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-	// Create a queue capable of containing 10 uint32_t values.
-	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-	// ...
-
-	if( xQueue1 != 0 )
-	{
-		// Send an uint32_t.  Wait for 10 ticks for space to become
-		// available if necessary.
-		if( xQueueSendToBack( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
-		{
-			// Failed to post the message, even after 10 ticks.
-		}
-	}
-
-	if( xQueue2 != 0 )
-	{
-		// Send a pointer to a struct AMessage object.  Don't block if the
-		// queue is already full.
-		pxMessage = & xMessage;
-		xQueueSendToBack( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueSend xQueueSend
+ * @code{c}
+ *  struct AMessage
+ *  {
+ *  char ucMessageID;
+ *  char ucData[ 20 ];
+ *  } xMessage;
+ *
+ *  uint32_t ulVar = 10UL;
+ *
+ *  void vATask( void *pvParameters )
+ *  {
+ *  QueueHandle_t xQueue1, xQueue2;
+ *  struct AMessage *pxMessage;
+ *
+ *  // Create a queue capable of containing 10 uint32_t values.
+ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
+ *
+ *  // Create a queue capable of containing 10 pointers to AMessage structures.
+ *  // These should be passed by pointer as they contain a lot of data.
+ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ *
+ *  // ...
+ *
+ *  if( xQueue1 != 0 )
+ *  {
+ *      // Send an uint32_t.  Wait for 10 ticks for space to become
+ *      // available if necessary.
+ *      if( xQueueSendToBack( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
+ *      {
+ *          // Failed to post the message, even after 10 ticks.
+ *      }
+ *  }
+ *
+ *  if( xQueue2 != 0 )
+ *  {
+ *      // Send a pointer to a struct AMessage object.  Don't block if the
+ *      // queue is already full.
+ *      pxMessage = & xMessage;
+ *      xQueueSendToBack( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
+ *  }
+ *
+ *  // ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
 
 /**
- * queue. h
- * 
- BaseType_t xQueueSend(
-							  QueueHandle_t xQueue,
-							  const void * pvItemToQueue,
-							  TickType_t xTicksToWait
-						 );
- * 

- *
  * This is a macro that calls xQueueGenericSend().  It is included for
  * backward compatibility with versions of FreeRTOS.org that did not
  * include the xQueueSendToFront() and xQueueSendToBack() macros.  It is
@@ -459,64 +413,55 @@ typedef void * QueueSetMemberHandle_t;
  * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-	// Create a queue capable of containing 10 uint32_t values.
-	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-	// ...
-
-	if( xQueue1 != 0 )
-	{
-		// Send an uint32_t.  Wait for 10 ticks for space to become
-		// available if necessary.
-		if( xQueueSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
-		{
-			// Failed to post the message, even after 10 ticks.
-		}
-	}
-
-	if( xQueue2 != 0 )
-	{
-		// Send a pointer to a struct AMessage object.  Don't block if the
-		// queue is already full.
-		pxMessage = & xMessage;
-		xQueueSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueSend xQueueSend
+ * @code{c}
+ *  struct AMessage
+ *  {
+ *  char ucMessageID;
+ *  char ucData[ 20 ];
+ *  } xMessage;
+ *
+ *  uint32_t ulVar = 10UL;
+ *
+ *  void vATask( void *pvParameters )
+ *  {
+ *  QueueHandle_t xQueue1, xQueue2;
+ *  struct AMessage *pxMessage;
+ *
+ *  // Create a queue capable of containing 10 uint32_t values.
+ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
+ *
+ *  // Create a queue capable of containing 10 pointers to AMessage structures.
+ *  // These should be passed by pointer as they contain a lot of data.
+ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ *
+ *  // ...
+ *
+ *  if( xQueue1 != 0 )
+ *  {
+ *      // Send an uint32_t.  Wait for 10 ticks for space to become
+ *      // available if necessary.
+ *      if( xQueueSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
+ *      {
+ *          // Failed to post the message, even after 10 ticks.
+ *      }
+ *  }
+ *
+ *  if( xQueue2 != 0 )
+ *  {
+ *      // Send a pointer to a struct AMessage object.  Don't block if the
+ *      // queue is already full.
+ *      pxMessage = & xMessage;
+ *      xQueueSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
+ *  }
+ *
+ *  // ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
 
 /**
- * queue. h
- * 
- BaseType_t xQueueOverwrite(
-							  QueueHandle_t xQueue,
-							  const void * pvItemToQueue
-						 );
- * 

- *
  * Only for use with queues that have a length of one - so the queue is either
  * empty or full.
  *
@@ -539,70 +484,59 @@ typedef void * QueueSetMemberHandle_t;
  * to the queue even when the queue is already full.
  *
  * Example usage:
-   
-
- void vFunction( void *pvParameters )
- {
- QueueHandle_t xQueue;
- uint32_t ulVarToSend, ulValReceived;
-
-	// Create a queue to hold one uint32_t value.  It is strongly
-	// recommended *not* to use xQueueOverwrite() on queues that can
-	// contain more than one value, and doing so will trigger an assertion
-	// if configASSERT() is defined.
-	xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
-
-	// Write the value 10 to the queue using xQueueOverwrite().
-	ulVarToSend = 10;
-	xQueueOverwrite( xQueue, &ulVarToSend );
-
-	// Peeking the queue should now return 10, but leave the value 10 in
-	// the queue.  A block time of zero is used as it is known that the
-	// queue holds a value.
-	ulValReceived = 0;
-	xQueuePeek( xQueue, &ulValReceived, 0 );
-
-	if( ulValReceived != 10 )
-	{
-		// Error unless the item was removed by a different task.
-	}
-
-	// The queue is still full.  Use xQueueOverwrite() to overwrite the
-	// value held in the queue with 100.
-	ulVarToSend = 100;
-	xQueueOverwrite( xQueue, &ulVarToSend );
-
-	// This time read from the queue, leaving the queue empty once more.
-	// A block time of 0 is used again.
-	xQueueReceive( xQueue, &ulValReceived, 0 );
-
-	// The value read should be the last value written, even though the
-	// queue was already full when the value was written.
-	if( ulValReceived != 100 )
-	{
-		// Error!
-	}
-
-	// ...
-}
- 

- * \defgroup xQueueOverwrite xQueueOverwrite
+ * @code{c}
+ *
+ *  void vFunction( void *pvParameters )
+ *  {
+ *  QueueHandle_t xQueue;
+ *  uint32_t ulVarToSend, ulValReceived;
+ *
+ *  // Create a queue to hold one uint32_t value.  It is strongly
+ *  // recommended *not* to use xQueueOverwrite() on queues that can
+ *  // contain more than one value, and doing so will trigger an assertion
+ *  // if configASSERT() is defined.
+ *  xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
+ *
+ *  // Write the value 10 to the queue using xQueueOverwrite().
+ *  ulVarToSend = 10;
+ *  xQueueOverwrite( xQueue, &ulVarToSend );
+ *
+ *  // Peeking the queue should now return 10, but leave the value 10 in
+ *  // the queue.  A block time of zero is used as it is known that the
+ *  // queue holds a value.
+ *  ulValReceived = 0;
+ *  xQueuePeek( xQueue, &ulValReceived, 0 );
+ *
+ *  if( ulValReceived != 10 )
+ *  {
+ *      // Error unless the item was removed by a different task.
+ *  }
+ *
+ *  // The queue is still full.  Use xQueueOverwrite() to overwrite the
+ *  // value held in the queue with 100.
+ *  ulVarToSend = 100;
+ *  xQueueOverwrite( xQueue, &ulVarToSend );
+ *
+ *  // This time read from the queue, leaving the queue empty once more.
+ *  // A block time of 0 is used again.
+ *  xQueueReceive( xQueue, &ulValReceived, 0 );
+ *
+ *  // The value read should be the last value written, even though the
+ *  // queue was already full when the value was written.
+ *  if( ulValReceived != 100 )
+ *  {
+ *      // Error!
+ *  }
+ *
+ *  // ...
+ * }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueOverwrite( xQueue, pvItemToQueue ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), 0, queueOVERWRITE )
 
 
 /**
- * queue. h
- * 
- BaseType_t xQueueGenericSend(
-									QueueHandle_t xQueue,
-									const void * pvItemToQueue,
-									TickType_t xTicksToWait
-									BaseType_t xCopyPosition
-								);
- * 

- *
  * It is preferred that the macros xQueueSend(), xQueueSendToFront() and
  * xQueueSendToBack() are used in place of calling this function directly.
  *
@@ -630,64 +564,55 @@ typedef void * QueueSetMemberHandle_t;
  * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-	// Create a queue capable of containing 10 uint32_t values.
-	xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-	// ...
-
-	if( xQueue1 != 0 )
-	{
-		// Send an uint32_t.  Wait for 10 ticks for space to become
-		// available if necessary.
-		if( xQueueGenericSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10, queueSEND_TO_BACK ) != pdPASS )
-		{
-			// Failed to post the message, even after 10 ticks.
-		}
-	}
-
-	if( xQueue2 != 0 )
-	{
-		// Send a pointer to a struct AMessage object.  Don't block if the
-		// queue is already full.
-		pxMessage = & xMessage;
-		xQueueGenericSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0, queueSEND_TO_BACK );
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueSend xQueueSend
+ * @code{c}
+ *  struct AMessage
+ *  {
+ *  char ucMessageID;
+ *  char ucData[ 20 ];
+ *  } xMessage;
+ *
+ *  uint32_t ulVar = 10UL;
+ *
+ *  void vATask( void *pvParameters )
+ *  {
+ *  QueueHandle_t xQueue1, xQueue2;
+ *  struct AMessage *pxMessage;
+ *
+ *  // Create a queue capable of containing 10 uint32_t values.
+ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
+ *
+ *  // Create a queue capable of containing 10 pointers to AMessage structures.
+ *  // These should be passed by pointer as they contain a lot of data.
+ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ *
+ *  // ...
+ *
+ *  if( xQueue1 != 0 )
+ *  {
+ *      // Send an uint32_t.  Wait for 10 ticks for space to become
+ *      // available if necessary.
+ *      if( xQueueGenericSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10, queueSEND_TO_BACK ) != pdPASS )
+ *      {
+ *          // Failed to post the message, even after 10 ticks.
+ *      }
+ *  }
+ *
+ *  if( xQueue2 != 0 )
+ *  {
+ *      // Send a pointer to a struct AMessage object.  Don't block if the
+ *      // queue is already full.
+ *      pxMessage = & xMessage;
+ *      xQueueGenericSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0, queueSEND_TO_BACK );
+ *  }
+ *
+ *  // ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
 
 /**
- * queue. h
- * 
- BaseType_t xQueuePeek(
-							 QueueHandle_t xQueue,
-							 void *pvBuffer,
-							 TickType_t xTicksToWait
-						 );

- *
  * This is a macro that calls the xQueueGenericReceive() function.
  *
  * Receive an item from a queue without removing the item from the queue.
@@ -719,70 +644,62 @@ BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQ
  * otherwise pdFALSE.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- } xMessage;
-
- QueueHandle_t xQueue;
-
- // Task to create a queue and post a value.
- void vATask( void *pvParameters )
- {
- struct AMessage *pxMessage;
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
-	if( xQueue == 0 )
-	{
-		// Failed to create the queue.
-	}
-
-	// ...
-
-	// Send a pointer to a struct AMessage object.  Don't block if the
-	// queue is already full.
-	pxMessage = & xMessage;
-	xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
-
-	// ... Rest of task code.
- }
-
- // Task to peek the data from the queue.
- void vADifferentTask( void *pvParameters )
- {
- struct AMessage *pxRxedMessage;
-
-	if( xQueue != 0 )
-	{
-		// Peek a message on the created queue.  Block for 10 ticks if a
-		// message is not immediately available.
-		if( xQueuePeek( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
-		{
-			// pcRxedMessage now points to the struct AMessage variable posted
-			// by vATask, but the item still remains on the queue.
-		}
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueReceive xQueueReceive
+ * @code{c}
+ *  struct AMessage
+ *  {
+ *  char ucMessageID;
+ *  char ucData[ 20 ];
+ *  } xMessage;
+ *
+ *  QueueHandle_t xQueue;
+ *
+ *  // Task to create a queue and post a value.
+ *  void vATask( void *pvParameters )
+ *  {
+ *  struct AMessage *pxMessage;
+ *
+ *  // Create a queue capable of containing 10 pointers to AMessage structures.
+ *  // These should be passed by pointer as they contain a lot of data.
+ *  xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ *  if( xQueue == 0 )
+ *  {
+ *      // Failed to create the queue.
+ *  }
+ *
+ *  // ...
+ *
+ *  // Send a pointer to a struct AMessage object.  Don't block if the
+ *  // queue is already full.
+ *  pxMessage = & xMessage;
+ *  xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
+ *
+ *  // ... Rest of task code.
+ *  }
+ *
+ *  // Task to peek the data from the queue.
+ *  void vADifferentTask( void *pvParameters )
+ *  {
+ *  struct AMessage *pxRxedMessage;
+ *
+ *  if( xQueue != 0 )
+ *  {
+ *      // Peek a message on the created queue.  Block for 10 ticks if a
+ *      // message is not immediately available.
+ *      if( xQueuePeek( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
+ *      {
+ *          // pcRxedMessage now points to the struct AMessage variable posted
+ *          // by vATask, but the item still remains on the queue.
+ *      }
+ *  }
+ *
+ *  // ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueuePeek( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )
 
 /**
- * queue. h
- * 
- BaseType_t xQueuePeekFromISR(
-									QueueHandle_t xQueue,
-									void *pvBuffer,
-								);

- *
  * A version of xQueuePeek() that can be called from an interrupt service
  * routine (ISR).
  *
@@ -803,7 +720,6 @@ BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQ
  * @return pdTRUE if an item was successfully received from the queue,
  * otherwise pdFALSE.
  *
- * \defgroup xQueuePeekFromISR xQueuePeekFromISR
  * \ingroup QueueManagement
  */
 BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void * const pvBuffer ) PRIVILEGED_FUNCTION;
@@ -845,73 +761,63 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void * const pvBuffer ) PRIV
  * otherwise pdFALSE.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- } xMessage;
-
- QueueHandle_t xQueue;
-
- // Task to create a queue and post a value.
- void vATask( void *pvParameters )
- {
- struct AMessage *pxMessage;
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
-	if( xQueue == 0 )
-	{
-		// Failed to create the queue.
-	}
-
-	// ...
-
-	// Send a pointer to a struct AMessage object.  Don't block if the
-	// queue is already full.
-	pxMessage = & xMessage;
-	xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
-
-	// ... Rest of task code.
- }
-
- // Task to receive from the queue.
- void vADifferentTask( void *pvParameters )
- {
- struct AMessage *pxRxedMessage;
-
-	if( xQueue != 0 )
-	{
-		// Receive a message on the created queue.  Block for 10 ticks if a
-		// message is not immediately available.
-		if( xQueueReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
-		{
-			// pcRxedMessage now points to the struct AMessage variable posted
-			// by vATask.
-		}
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueReceive xQueueReceive
+ * @code{c}
+ *  struct AMessage
+ *  {
+ * 	char ucMessageID;
+ * 	char ucData[ 20 ];
+ *  } xMessage;
+ *
+ *  QueueHandle_t xQueue;
+ *
+ *  // Task to create a queue and post a value.
+ *  void vATask( void *pvParameters )
+ *  {
+ *  struct AMessage *pxMessage;
+ *
+ * 	// Create a queue capable of containing 10 pointers to AMessage structures.
+ * 	// These should be passed by pointer as they contain a lot of data.
+ * 	xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ * 	if( xQueue == 0 )
+ * 	{
+ * 		// Failed to create the queue.
+ * 	}
+ *
+ * 	// ...
+ *
+ * 	// Send a pointer to a struct AMessage object.  Don't block if the
+ * 	// queue is already full.
+ * 	pxMessage = & xMessage;
+ * 	xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
+ *
+ * 	// ... Rest of task code.
+ *  }
+ *
+ *  // Task to receive from the queue.
+ *  void vADifferentTask( void *pvParameters )
+ *  {
+ *  struct AMessage *pxRxedMessage;
+ *
+ * 	if( xQueue != 0 )
+ * 	{
+ * 		// Receive a message on the created queue.  Block for 10 ticks if a
+ * 		// message is not immediately available.
+ * 		if( xQueueReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
+ * 		{
+ * 			// pcRxedMessage now points to the struct AMessage variable posted
+ * 			// by vATask.
+ * 		}
+ * 	}
+ *
+ * 	// ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueReceive( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )
 
 
 /**
- * queue. h
- * 
- BaseType_t xQueueGenericReceive(
-									   QueueHandle_t	xQueue,
-									   void	*pvBuffer,
-									   TickType_t	xTicksToWait
-									   BaseType_t	xJustPeek
-									);

- *
  * It is preferred that the macro xQueueReceive() be used rather than calling
  * this function directly.
  *
@@ -944,81 +850,73 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void * const pvBuffer ) PRIV
  * otherwise pdFALSE.
  *
  * Example usage:
-   
- struct AMessage
- {
-	char ucMessageID;
-	char ucData[ 20 ];
- } xMessage;
-
- QueueHandle_t xQueue;
-
- // Task to create a queue and post a value.
- void vATask( void *pvParameters )
- {
- struct AMessage *pxMessage;
-
-	// Create a queue capable of containing 10 pointers to AMessage structures.
-	// These should be passed by pointer as they contain a lot of data.
-	xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
-	if( xQueue == 0 )
-	{
-		// Failed to create the queue.
-	}
-
-	// ...
-
-	// Send a pointer to a struct AMessage object.  Don't block if the
-	// queue is already full.
-	pxMessage = & xMessage;
-	xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
-
-	// ... Rest of task code.
- }
-
- // Task to receive from the queue.
- void vADifferentTask( void *pvParameters )
- {
- struct AMessage *pxRxedMessage;
-
-	if( xQueue != 0 )
-	{
-		// Receive a message on the created queue.  Block for 10 ticks if a
-		// message is not immediately available.
-		if( xQueueGenericReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
-		{
-			// pcRxedMessage now points to the struct AMessage variable posted
-			// by vATask.
-		}
-	}
-
-	// ... Rest of task code.
- }
- 

- * \defgroup xQueueReceive xQueueReceive
+ * @code{c}
+ *  struct AMessage
+ *  {
+ * 	char ucMessageID;
+ * 	char ucData[ 20 ];
+ *  } xMessage;
+ *
+ *  QueueHandle_t xQueue;
+ *
+ *  // Task to create a queue and post a value.
+ *  void vATask( void *pvParameters )
+ *  {
+ *  struct AMessage *pxMessage;
+ *
+ * 	// Create a queue capable of containing 10 pointers to AMessage structures.
+ * 	// These should be passed by pointer as they contain a lot of data.
+ * 	xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
+ * 	if( xQueue == 0 )
+ * 	{
+ * 		// Failed to create the queue.
+ * 	}
+ *
+ * 	// ...
+ *
+ * 	// Send a pointer to a struct AMessage object.  Don't block if the
+ * 	// queue is already full.
+ * 	pxMessage = & xMessage;
+ * 	xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
+ *
+ * 	// ... Rest of task code.
+ *  }
+ *
+ *  // Task to receive from the queue.
+ *  void vADifferentTask( void *pvParameters )
+ *  {
+ *  struct AMessage *pxRxedMessage;
+ *
+ * 	if( xQueue != 0 )
+ * 	{
+ * 		// Receive a message on the created queue.  Block for 10 ticks if a
+ * 		// message is not immediately available.
+ * 		if( xQueueGenericReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
+ * 		{
+ * 			// pcRxedMessage now points to the struct AMessage variable posted
+ * 			// by vATask.
+ * 		}
+ * 	}
+ *
+ * 	// ... Rest of task code.
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeek ) PRIVILEGED_FUNCTION;
 
 /**
- * queue. h
- * 
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );

- *
  * Return the number of messages stored in a queue.
  *
  * @param xQueue A handle to the queue being queried.
  *
  * @return The number of messages available in the queue.
  *
- * \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting
  * \ingroup QueueManagement
  */
 UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
 
 /**
- * queue. h
- * 
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );

- *
  * Return the number of free spaces available in a queue.  This is equal to the
  * number of items that can be sent to the queue before the queue becomes full
  * if no items are removed.
@@ -1027,35 +925,21 @@ UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue ) PRIVILEGED_FUNC
  *
  * @return The number of spaces available in the queue.
  *
- * \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting
  * \ingroup QueueManagement
  */
 UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
 
 /**
- * queue. h
- * 
void vQueueDelete( QueueHandle_t xQueue );

- *
  * Delete a queue - freeing all the memory allocated for storing of items
  * placed on the queue.
  *
  * @param xQueue A handle to the queue to be deleted.
  *
- * \defgroup vQueueDelete vQueueDelete
  * \ingroup QueueManagement
  */
 void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
 
 /**
- * queue. h
- * 
- BaseType_t xQueueSendToFrontFromISR(
-										 QueueHandle_t xQueue,
-										 const void *pvItemToQueue,
-										 BaseType_t *pxHigherPriorityTaskWoken
-									  );
- 

- *
  * This is a macro that calls xQueueGenericSendFromISR().
  *
  * Post an item to the front of a queue.  It is safe to use this macro from
@@ -1072,7 +956,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
  * queue was created, so this many bytes will be copied from pvItemToQueue
  * into the queue storage area.
  *
- * @param pxHigherPriorityTaskWoken xQueueSendToFrontFromISR() will set
+ * @param[out] pxHigherPriorityTaskWoken xQueueSendToFrontFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
  * to unblock, and the unblocked task has a priority higher than the currently
  * running task.  If xQueueSendToFromFromISR() sets this value to pdTRUE then
@@ -1083,50 +967,39 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
  *
  * Example usage for buffered IO (where the ISR can obtain more than one value
  * per call):
-   
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPrioritTaskWoken;
-
-	// We have not woken a task at the start of the ISR.
-	xHigherPriorityTaskWoken = pdFALSE;
-
-	// Loop until the buffer is empty.
-	do
-	{
-		// Obtain a byte from the buffer.
-		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-		// Post the byte.
-		xQueueSendToFrontFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
-
-	} while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-	// Now the buffer is empty we can switch context if necessary.
-	if( xHigherPriorityTaskWoken )
-	{
-		portYIELD_FROM_ISR ();
-	}
- }
- 

+ * @code{c}
+ *  void vBufferISR( void )
+ *  {
+ *  char cIn;
+ *  BaseType_t xHigherPrioritTaskWoken;
  *
- * \defgroup xQueueSendFromISR xQueueSendFromISR
+ * 	// We have not woken a task at the start of the ISR.
+ * 	xHigherPriorityTaskWoken = pdFALSE;
+ *
+ * 	// Loop until the buffer is empty.
+ * 	do
+ * 	{
+ * 		// Obtain a byte from the buffer.
+ * 		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
+ *
+ * 		// Post the byte.
+ * 		xQueueSendToFrontFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
+ *
+ * 	} while( portINPUT_BYTE( BUFFER_COUNT ) );
+ *
+ * 	// Now the buffer is empty we can switch context if necessary.
+ * 	if( xHigherPriorityTaskWoken )
+ * 	{
+ * 		portYIELD_FROM_ISR ();
+ * 	}
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueSendToFrontFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )
 
 
 /**
- * queue. h
- * 
- BaseType_t xQueueSendToBackFromISR(
-										 QueueHandle_t xQueue,
-										 const void *pvItemToQueue,
-										 BaseType_t *pxHigherPriorityTaskWoken
-									  );
- 

- *
  * This is a macro that calls xQueueGenericSendFromISR().
  *
  * Post an item to the back of a queue.  It is safe to use this macro from
@@ -1143,7 +1016,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
  * queue was created, so this many bytes will be copied from pvItemToQueue
  * into the queue storage area.
  *
- * @param pxHigherPriorityTaskWoken xQueueSendToBackFromISR() will set
+ * @param[out] pxHigherPriorityTaskWoken xQueueSendToBackFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
  * to unblock, and the unblocked task has a priority higher than the currently
  * running task.  If xQueueSendToBackFromISR() sets this value to pdTRUE then
@@ -1154,49 +1027,38 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
  *
  * Example usage for buffered IO (where the ISR can obtain more than one value
  * per call):
-   
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPriorityTaskWoken;
-
-	// We have not woken a task at the start of the ISR.
-	xHigherPriorityTaskWoken = pdFALSE;
-
-	// Loop until the buffer is empty.
-	do
-	{
-		// Obtain a byte from the buffer.
-		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-		// Post the byte.
-		xQueueSendToBackFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
-
-	} while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-	// Now the buffer is empty we can switch context if necessary.
-	if( xHigherPriorityTaskWoken )
-	{
-		portYIELD_FROM_ISR ();
-	}
- }
- 

+ * @code{c}
+ *  void vBufferISR( void )
+ *  {
+ *  char cIn;
+ *  BaseType_t xHigherPriorityTaskWoken;
  *
- * \defgroup xQueueSendFromISR xQueueSendFromISR
+ * 	// We have not woken a task at the start of the ISR.
+ * 	xHigherPriorityTaskWoken = pdFALSE;
+ *
+ * 	// Loop until the buffer is empty.
+ * 	do
+ * 	{
+ * 		// Obtain a byte from the buffer.
+ * 		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
+ *
+ * 		// Post the byte.
+ * 		xQueueSendToBackFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
+ *
+ * 	} while( portINPUT_BYTE( BUFFER_COUNT ) );
+ *
+ * 	// Now the buffer is empty we can switch context if necessary.
+ * 	if( xHigherPriorityTaskWoken )
+ * 	{
+ * 		portYIELD_FROM_ISR ();
+ * 	}
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueSendToBackFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
 
 /**
- * queue. h
- * 
- BaseType_t xQueueOverwriteFromISR(
-							  QueueHandle_t xQueue,
-							  const void * pvItemToQueue,
-							  BaseType_t *pxHigherPriorityTaskWoken
-						 );
- * 

- *
  * A version of xQueueOverwrite() that can be used in an interrupt service
  * routine (ISR).
  *
@@ -1213,7 +1075,7 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
  * queue was created, so this many bytes will be copied from pvItemToQueue
  * into the queue storage area.
  *
- * @param pxHigherPriorityTaskWoken xQueueOverwriteFromISR() will set
+ * @param[out] pxHigherPriorityTaskWoken xQueueOverwriteFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
  * to unblock, and the unblocked task has a priority higher than the currently
  * running task.  If xQueueOverwriteFromISR() sets this value to pdTRUE then
@@ -1226,64 +1088,53 @@ void vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
  * the queue is already full.
  *
  * Example usage:
-   
-
- QueueHandle_t xQueue;
-
- void vFunction( void *pvParameters )
- {
- 	// Create a queue to hold one uint32_t value.  It is strongly
-	// recommended *not* to use xQueueOverwriteFromISR() on queues that can
-	// contain more than one value, and doing so will trigger an assertion
-	// if configASSERT() is defined.
-	xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
-}
-
-void vAnInterruptHandler( void )
-{
-// xHigherPriorityTaskWoken must be set to pdFALSE before it is used.
-BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-uint32_t ulVarToSend, ulValReceived;
-
-	// Write the value 10 to the queue using xQueueOverwriteFromISR().
-	ulVarToSend = 10;
-	xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );
-
-	// The queue is full, but calling xQueueOverwriteFromISR() again will still
-	// pass because the value held in the queue will be overwritten with the
-	// new value.
-	ulVarToSend = 100;
-	xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );
-
-	// Reading from the queue will now return 100.
-
-	// ...
-
-	if( xHigherPrioritytaskWoken == pdTRUE )
-	{
-		// Writing to the queue caused a task to unblock and the unblocked task
-		// has a priority higher than or equal to the priority of the currently
-		// executing task (the task this interrupt interrupted).  Perform a context
-		// switch so this interrupt returns directly to the unblocked task.
-		portYIELD_FROM_ISR(); // or portEND_SWITCHING_ISR() depending on the port.
-	}
-}
- 

- * \defgroup xQueueOverwriteFromISR xQueueOverwriteFromISR
+ * @code{c}
+ *  QueueHandle_t xQueue;
+ *
+ *  void vFunction( void *pvParameters )
+ *  {
+ *  	// Create a queue to hold one uint32_t value.  It is strongly
+ * 	// recommended *not* to use xQueueOverwriteFromISR() on queues that can
+ * 	// contain more than one value, and doing so will trigger an assertion
+ * 	// if configASSERT() is defined.
+ * 	xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
+ * }
+ *
+ * void vAnInterruptHandler( void )
+ * {
+ * // xHigherPriorityTaskWoken must be set to pdFALSE before it is used.
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+ * uint32_t ulVarToSend, ulValReceived;
+ *
+ * 	// Write the value 10 to the queue using xQueueOverwriteFromISR().
+ * 	ulVarToSend = 10;
+ * 	xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );
+ *
+ * 	// The queue is full, but calling xQueueOverwriteFromISR() again will still
+ * 	// pass because the value held in the queue will be overwritten with the
+ * 	// new value.
+ * 	ulVarToSend = 100;
+ * 	xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );
+ *
+ * 	// Reading from the queue will now return 100.
+ *
+ * 	// ...
+ *
+ * 	if( xHigherPrioritytaskWoken == pdTRUE )
+ * 	{
+ * 		// Writing to the queue caused a task to unblock and the unblocked task
+ * 		// has a priority higher than or equal to the priority of the currently
+ * 		// executing task (the task this interrupt interrupted).  Perform a context
+ * 		// switch so this interrupt returns directly to the unblocked task.
+ * 		portYIELD_FROM_ISR(); // or portEND_SWITCHING_ISR() depending on the port.
+ * 	}
+ * }
+ * @endcode
  * \ingroup QueueManagement
  */
 #define xQueueOverwriteFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueOVERWRITE )
 
 /**
- * queue. h
- * 
- BaseType_t xQueueSendFromISR(
-									 QueueHandle_t xQueue,
-									 const void *pvItemToQueue,
-									 BaseType_t *pxHigherPriorityTaskWoken
-								);
- 

- *
  * This is a macro that calls xQueueGenericSendFromISR().  It is included
  * for backward compatibility with versions of FreeRTOS.org that did not
  * include the xQueueSendToBackFromISR() and xQueueSendToFrontFromISR()
@@ -1303,7 +1154,7 @@ uint32_t ulVarToSend, ulValReceived;
  * queue was created, so this many bytes will be copied from pvItemToQueue
  * into the queue storage area.
  *
- * @param pxHigherPriorityTaskWoken xQueueSendFromISR() will set
+ * @param[out] pxHigherPriorityTaskWoken xQueueSendFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
  * to unblock, and the unblocked task has a priority higher than the currently
  * running task.  If xQueueSendFromISR() sets this value to pdTRUE then
@@ -1314,51 +1165,41 @@ uint32_t ulVarToSend, ulValReceived;
  *
  * Example usage for buffered IO (where the ISR can obtain more than one value
  * per call):
-   
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPriorityTaskWoken;
-
-	// We have not woken a task at the start of the ISR.
-	xHigherPriorityTaskWoken = pdFALSE;
-
-	// Loop until the buffer is empty.
-	do
-	{
-		// Obtain a byte from the buffer.
-		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-		// Post the byte.
-		xQueueSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
-
-	} while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-	// Now the buffer is empty we can switch context if necessary.
-	if( xHigherPriorityTaskWoken )
-	{
-		// Actual macro used here is port specific.
-		portYIELD_FROM_ISR ();
-	}
- }
- 

+ * @code{c}
+ *  void vBufferISR( void )
+ *  {
+ *  char cIn;
+ *  BaseType_t xHigherPriorityTaskWoken;
+ *
+ * 	// We have not woken a task at the start of the ISR.
+ * 	xHigherPriorityTaskWoken = pdFALSE;
+ *
+ * 	// Loop until the buffer is empty.
+ * 	do
+ * 	{
+ * 		// Obtain a byte from the buffer.
+ * 		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
+ *
+ * 		// Post the byte.
+ * 		xQueueSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
+ *
+ * 	} while( portINPUT_BYTE( BUFFER_COUNT ) );
+ *
+ * 	// Now the buffer is empty we can switch context if necessary.
+ * 	if( xHigherPriorityTaskWoken )
+ * 	{
+ * 		// Actual macro used here is port specific.
+ * 		portYIELD_FROM_ISR ();
+ * 	}
+ *  }
+ * @endcode
  *
- * \defgroup xQueueSendFromISR xQueueSendFromISR
  * \ingroup QueueManagement
  */
 #define xQueueSendFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
 
+/**@{*/
 /**
- * queue. h
- * 
- BaseType_t xQueueGenericSendFromISR(
-										   QueueHandle_t		xQueue,
-										   const	void	*pvItemToQueue,
-										   BaseType_t	*pxHigherPriorityTaskWoken,
-										   BaseType_t	xCopyPosition
-									   );
- 

- *
  * It is preferred that the macros xQueueSendFromISR(),
  * xQueueSendToFrontFromISR() and xQueueSendToBackFromISR() be used in place
  * of calling this function directly.  xQueueGiveFromISR() is an
@@ -1378,7 +1219,7 @@ uint32_t ulVarToSend, ulValReceived;
  * queue was created, so this many bytes will be copied from pvItemToQueue
  * into the queue storage area.
  *
- * @param pxHigherPriorityTaskWoken xQueueGenericSendFromISR() will set
+ * @param[out] pxHigherPriorityTaskWoken xQueueGenericSendFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
  * to unblock, and the unblocked task has a priority higher than the currently
  * running task.  If xQueueGenericSendFromISR() sets this value to pdTRUE then
@@ -1393,51 +1234,41 @@ uint32_t ulVarToSend, ulValReceived;
  *
  * Example usage for buffered IO (where the ISR can obtain more than one value
  * per call):
-   
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPriorityTaskWokenByPost;
-
-	// We have not woken a task at the start of the ISR.
-	xHigherPriorityTaskWokenByPost = pdFALSE;
-
-	// Loop until the buffer is empty.
-	do
-	{
-		// Obtain a byte from the buffer.
-		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-		// Post each byte.
-		xQueueGenericSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWokenByPost, queueSEND_TO_BACK );
-
-	} while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-	// Now the buffer is empty we can switch context if necessary.  Note that the
-	// name of the yield function required is port specific.
-	if( xHigherPriorityTaskWokenByPost )
-	{
-		taskYIELD_YIELD_FROM_ISR();
-	}
- }
- 

+ * @code{c}
+ *  void vBufferISR( void )
+ *  {
+ *  char cIn;
+ *  BaseType_t xHigherPriorityTaskWokenByPost;
  *
- * \defgroup xQueueSendFromISR xQueueSendFromISR
+ * 	// We have not woken a task at the start of the ISR.
+ * 	xHigherPriorityTaskWokenByPost = pdFALSE;
+ *
+ * 	// Loop until the buffer is empty.
+ * 	do
+ * 	{
+ * 		// Obtain a byte from the buffer.
+ * 		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
+ *
+ * 		// Post each byte.
+ * 		xQueueGenericSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWokenByPost, queueSEND_TO_BACK );
+ *
+ * 	} while( portINPUT_BYTE( BUFFER_COUNT ) );
+ *
+ * 	// Now the buffer is empty we can switch context if necessary.  Note that the
+ * 	// name of the yield function required is port specific.
+ * 	if( xHigherPriorityTaskWokenByPost )
+ * 	{
+ * 		taskYIELD_YIELD_FROM_ISR();
+ * 	}
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue, const void * const pvItemToQueue, BaseType_t * const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
 BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue, BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+/**@}*/
 
 /**
- * queue. h
- * 
- BaseType_t xQueueReceiveFromISR(
-									   QueueHandle_t	xQueue,
-									   void	*pvBuffer,
-									   BaseType_t *pxTaskWoken
-								   );
- * 

- *
  * Receive an item from a queue.  It is safe to use this function from within an
  * interrupt service routine.
  *
@@ -1447,7 +1278,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue, BaseType_t * const pxHigherP
  * @param pvBuffer Pointer to the buffer into which the received item will
  * be copied.
  *
- * @param pxTaskWoken A task may be blocked waiting for space to become
+ * @param[out] pxHigherPriorityTaskWoken A task may be blocked waiting for space to become
  * available on the queue.  If xQueueReceiveFromISR causes such a task to
  * unblock *pxTaskWoken will get set to pdTRUE, otherwise *pxTaskWoken will
  * remain unchanged.
@@ -1456,77 +1287,77 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue, BaseType_t * const pxHigherP
  * otherwise pdFALSE.
  *
  * Example usage:
-   
-
- QueueHandle_t xQueue;
-
- // Function to create a queue and post some values.
- void vAFunction( void *pvParameters )
- {
- char cValueToPost;
- const TickType_t xTicksToWait = ( TickType_t )0xff;
-
-	// Create a queue capable of containing 10 characters.
-	xQueue = xQueueCreate( 10, sizeof( char ) );
-	if( xQueue == 0 )
-	{
-		// Failed to create the queue.
-	}
-
-	// ...
-
-	// Post some characters that will be used within an ISR.  If the queue
-	// is full then this task will block for xTicksToWait ticks.
-	cValueToPost = 'a';
-	xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
-	cValueToPost = 'b';
-	xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
-
-	// ... keep posting characters ... this task may block when the queue
-	// becomes full.
-
-	cValueToPost = 'c';
-	xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
- }
-
- // ISR that outputs all the characters received on the queue.
- void vISR_Routine( void )
- {
- BaseType_t xTaskWokenByReceive = pdFALSE;
- char cRxedChar;
-
-	while( xQueueReceiveFromISR( xQueue, ( void * ) &cRxedChar, &xTaskWokenByReceive) )
-	{
-		// A character was received.  Output the character now.
-		vOutputCharacter( cRxedChar );
-
-		// If removing the character from the queue woke the task that was
-		// posting onto the queue cTaskWokenByReceive will have been set to
-		// pdTRUE.  No matter how many times this loop iterates only one
-		// task will be woken.
-	}
-
-	if( cTaskWokenByPost != ( char ) pdFALSE;
-	{
-		taskYIELD ();
-	}
- }
- 

- * \defgroup xQueueReceiveFromISR xQueueReceiveFromISR
+ * @code{c}
+ *  QueueHandle_t xQueue;
+ *
+ *  // Function to create a queue and post some values.
+ *  void vAFunction( void *pvParameters )
+ *  {
+ *  char cValueToPost;
+ *  const TickType_t xTicksToWait = ( TickType_t )0xff;
+ *
+ * 	// Create a queue capable of containing 10 characters.
+ * 	xQueue = xQueueCreate( 10, sizeof( char ) );
+ * 	if( xQueue == 0 )
+ * 	{
+ * 		// Failed to create the queue.
+ * 	}
+ *
+ * 	// ...
+ *
+ * 	// Post some characters that will be used within an ISR.  If the queue
+ * 	// is full then this task will block for xTicksToWait ticks.
+ * 	cValueToPost = 'a';
+ * 	xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
+ * 	cValueToPost = 'b';
+ * 	xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
+ *
+ * 	// ... keep posting characters ... this task may block when the queue
+ * 	// becomes full.
+ *
+ * 	cValueToPost = 'c';
+ * 	xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
+ *  }
+ *
+ *  // ISR that outputs all the characters received on the queue.
+ *  void vISR_Routine( void )
+ *  {
+ *  BaseType_t xTaskWokenByReceive = pdFALSE;
+ *  char cRxedChar;
+ *
+ * 	while( xQueueReceiveFromISR( xQueue, ( void * ) &cRxedChar, &xTaskWokenByReceive) )
+ * 	{
+ * 		// A character was received.  Output the character now.
+ * 		vOutputCharacter( cRxedChar );
+ *
+ * 		// If removing the character from the queue woke the task that was
+ * 		// posting onto the queue cTaskWokenByReceive will have been set to
+ * 		// pdTRUE.  No matter how many times this loop iterates only one
+ * 		// task will be woken.
+ * 	}
+ *
+ * 	if( cTaskWokenByPost != ( char ) pdFALSE;
+ * 	{
+ * 		taskYIELD ();
+ * 	}
+ *  }
+ * @endcode
  * \ingroup QueueManagement
  */
 BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue, void * const pvBuffer, BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
 
-/*
+/**@{*/
+/**
  * Utilities to query queues that are safe to use from an ISR.  These utilities
  * should be used only from witin an ISR, or within a critical section.
  */
 BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
 BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
 UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
+/**@}*/
 
-
-/*
+/** @cond */
+/**
  * xQueueAltGenericSend() is an alternative version of xQueueGenericSend().
  * Likewise xQueueAltGenericReceive() is an alternative version of
  * xQueueGenericReceive().
@@ -1578,16 +1409,20 @@ void* xQueueGetMutexHolder( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;
  */
 BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION;
+/** @endcond */
 
-/*
+/**
  * Reset a queue back to its original empty state.  pdPASS is returned if the
  * queue is successfully reset.  pdFAIL is returned if the queue could not be
  * reset because there are tasks blocked on the queue waiting to either
  * receive from the queue or send to the queue.
+ *
+ * @param xQueue The queue to reset
+ * @return always returns pdPASS
  */
 #define xQueueReset( xQueue ) xQueueGenericReset( xQueue, pdFALSE )
 
-/*
+/**
  * The registry is provided as a means for kernel aware debuggers to
  * locate queues, semaphores and mutexes.  Call vQueueAddToRegistry() add
  * a queue, semaphore or mutex handle to the registry if you want the handle
@@ -1613,7 +1448,7 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
 	void vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 #endif
 
-/*
+/**
  * The registry is provided as a means for kernel aware debuggers to
  * locate queues, semaphores and mutexes.  Call vQueueAddToRegistry() add
  * a queue, semaphore or mutex handle to the registry if you want the handle
@@ -1627,7 +1462,7 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
 	void vQueueUnregisterQueue( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
 #endif
 
-/*
+/**
  * @note This function has been back ported from FreeRTOS v9.0.0
  *
  * The queue registry is provided as a means for kernel aware debuggers to
@@ -1641,10 +1476,10 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
  * returned.
  */
 #if( configQUEUE_REGISTRY_SIZE > 0 )
-    const char *pcQueueGetName( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+	const char *pcQueueGetName( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 #endif
 
-/*
+/**
  * Generic version of the function used to creaet a queue using dynamic memory
  * allocation.  This is called by other functions and macros that create other
  * RTOS objects that use the queue structure as their base.
@@ -1653,7 +1488,7 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
 	QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
 #endif
 
-/*
+/**
  * Generic version of the function used to creaet a queue using dynamic memory
  * allocation.  This is called by other functions and macros that create other
  * RTOS objects that use the queue structure as their base.
@@ -1662,7 +1497,7 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
 	QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
 #endif
 
-/*
+/**
  * Queue sets provide a mechanism to allow a task to block (pend) on a read
  * operation from multiple queues or semaphores simultaneously.
  *
@@ -1712,7 +1547,7 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
  */
 QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength ) PRIVILEGED_FUNCTION;
 
-/*
+/**
  * Adds a queue or semaphore to a queue set that was previously created by a
  * call to xQueueCreateSet().
  *
@@ -1736,7 +1571,7 @@ QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength ) PRIVILE
  */
 BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
 
-/*
+/**
  * Removes a queue or semaphore from a queue set.  A queue or semaphore can only
  * be removed from a set if the queue or semaphore is empty.
  *
@@ -1755,7 +1590,7 @@ BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHan
  */
 BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
 
-/*
+/**
  * xQueueSelectFromSet() selects from the members of a queue set a queue or
  * semaphore that either contains data (in the case of a queue) or is available
  * to take (in the case of a semaphore).  xQueueSelectFromSet() effectively
@@ -1791,18 +1626,19 @@ BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueS
  */
 QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
-/*
+/**
  * A version of xQueueSelectFromSet() that can be used from an ISR.
  */
 QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
 
+/** @cond */
 /* Not public API functions. */
 void vQueueWaitForMessageRestricted( QueueHandle_t xQueue, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 BaseType_t xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue ) PRIVILEGED_FUNCTION;
 void vQueueSetQueueNumber( QueueHandle_t xQueue, UBaseType_t uxQueueNumber ) PRIVILEGED_FUNCTION;
 UBaseType_t uxQueueGetQueueNumber( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
 uint8_t ucQueueGetQueueType( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
-
+/** @endcond */
 
 #ifdef __cplusplus
 }
diff --git a/components/freertos/include/freertos/ringbuf.h b/components/freertos/include/freertos/ringbuf.h
index 23ea868680..88e570aa59 100644
--- a/components/freertos/include/freertos/ringbuf.h
+++ b/components/freertos/include/freertos/ringbuf.h
@@ -9,50 +9,58 @@
 extern "C" {
 #endif
 
-/*
-Header definitions for a FreeRTOS ringbuffer object
-
-A ringbuffer instantiated by these functions essentially acts like a FreeRTOS queue, with the
-difference that it's strictly FIFO and with the main advantage that you can put in randomly-sized
-items. The capacity, accordingly, isn't measured in the amount of items, but the amount of memory
-that is used for storing the items. Dependent on the size of the items, more or less of them will 
-fit in the ring buffer.
-
-This ringbuffer tries to be efficient with memory: when inserting an item, the item data will
-be copied to the ringbuffer memory. When retrieving an item, however, a reference to ringbuffer
-memory will be returned. The returned memory is guaranteed to be 32-bit aligned and contiguous.
-The application can use this memory, but as long as it does, ringbuffer writes that would write
-to this bit of memory will block.
-
-The requirement for items to be contiguous is slightly problematic when the only way to place
-the next item would involve a wraparound from the end to the beginning of the ringbuffer. This can
-be solved (or not) in a few ways:
-- type = RINGBUF_TYPE_ALLOWSPLIT: The insertion code will split the item in two items; one which fits
-in the space left at the end of the ringbuffer, one that contains the remaining data which is placed
-in the beginning. Two xRingbufferReceive calls will be needed to retrieve the data.
-- type = RINGBUF_TYPE_NOSPLIT: The insertion code will leave the room at the end of the ringbuffer
-unused and instead will put the entire item at the start of the ringbuffer, as soon as there is 
-enough free space.
-- type = RINGBUF_TYPE_BYTEBUF: This is your conventional byte-based ringbuffer. It does have no
-overhead, but it has no item contiguousness either: a read will just give you the entire written
-buffer space, or the space up to the end of the buffer, and writes can be broken up in any way 
-possible. Note that this type cannot do a 2nd read before returning the memory of the 1st.
-
-The maximum size of an item will be affected by this decision. When split items are allowed, it's
-acceptable to push items of (buffer_size)-16 bytes into the buffer. When it's not allowed, the
-maximum size is (buffer_size/2)-8 bytes. The bytebuf can fill the entire buffer with data, it has
-no overhead.
-*/
-
 #include 
 
 //An opaque handle for a ringbuff object.
 typedef void * RingbufHandle_t;
 
-//The various types of buffer
+/**
+ * @brief The various types of buffer
+ *
+ * A ringbuffer instantiated by these functions essentially acts like a
+ * FreeRTOS queue, with the difference that it's strictly FIFO and with
+ * the main advantage that you can put in randomly-sized items. The capacity,
+ * accordingly, isn't measured in the amount of items, but the amount of
+ * memory that is used for storing the items. Dependent on the size of
+ * the items, more or less of them will fit in the ring buffer.
+ *
+ * This ringbuffer tries to be efficient with memory: when inserting an item,
+ * the item data will be copied to the ringbuffer memory. When retrieving
+ * an item, however, a reference to ringbuffer memory will be returned.
+ * The returned memory is guaranteed to be 32-bit aligned and contiguous.
+ * The application can use this memory, but as long as it does, ringbuffer
+ * writes that would write to this bit of memory will block.
+ *
+ * The requirement for items to be contiguous is slightly problematic when
+ * the only way to place the next item would involve a wraparound from the end
+ * to the beginning of the ringbuffer. This can be solved (or not) in a few ways,
+ * see descriptions of possible ringbuf_type_t types below.
+ *
+ * The maximum size of an item will be affected by ringbuffer type.
+ * When split items are allowed, it is acceptable to push items of
+ * (buffer_size)-16 bytes into the buffer.
+ * When it's not allowed, the maximum size is (buffer_size/2)-8 bytes.
+ * The bytebuf can fill the entire buffer with data, it has no overhead.
+ */
 typedef enum {
+	/** The insertion code will leave the room at the end of the ringbuffer
+	 * unused and instead will put the entire item at the start of the ringbuffer,
+	 * as soon as there is enough free space.
+	 */
 	RINGBUF_TYPE_NOSPLIT = 0,
+	/** The insertion code will split the item in two items; one which fits
+	 * in the space left at the end of the ringbuffer, one that contains
+	 * the remaining data which is placed in the beginning.
+	 * Two xRingbufferReceive calls will be needed to retrieve the data.
+	 */
 	RINGBUF_TYPE_ALLOWSPLIT,
+	/** This is your conventional byte-based ringbuffer. It does have no
+	 * overhead, but it has no item contiguousness either: a read will just
+	 * give you the entire written buffer space, or the space up to the end
+	 * of the buffer, and writes can be broken up in any way possible.
+	 * Note that this type cannot do a 2nd read before returning the memory
+	 * of the 1st.
+	 */
 	RINGBUF_TYPE_BYTEBUF
 } ringbuf_type_t;
 
@@ -60,22 +68,19 @@ typedef enum {
 /**
  * @brief  Create a ring buffer
  *
- * @param  buf_length : Length of circular buffer, in bytes. Each entry will take up its own length, plus a header
- *                      that at the moment is equal to sizeof(size_t).
- * @param allow_split_items : pdTRUE if it is acceptable that item data is inserted as two
- *                            items instead of one.
+ * @param  buf_length  Length of circular buffer, in bytes. Each entry will
+ *                     take up its own length, plus a header that at the moment
+ *                     is equal to sizeof(size_t).
+ * @param  type  Type of ring buffer, see ringbuf_type_t.
  *
  * @return A RingbufHandle_t handle to the created ringbuffer, or NULL in case of error.
  */
 RingbufHandle_t xRingbufferCreate(size_t buf_length, ringbuf_type_t type);
 
-
 /**
  * @brief  Delete a ring buffer
  *
- * @param  ringbuf - Ring buffer to delete
- *
- * @return void
+ * @param  ringbuf  Ring buffer to delete
  */
 void vRingbufferDelete(RingbufHandle_t ringbuf);
 
@@ -83,7 +88,7 @@ void vRingbufferDelete(RingbufHandle_t ringbuf);
 /**
  * @brief  Get maximum size of an item that can be placed in the ring buffer
  *
- * @param  ringbuf - Ring buffer to query
+ * @param  ringbuf  Ring buffer to query
  *
  * @return Maximum size, in bytes, of an item that can be placed in a ring buffer.
  */
@@ -93,13 +98,15 @@ size_t xRingbufferGetMaxItemSize(RingbufHandle_t ringbuf);
 /**
  * @brief  Insert an item into the ring buffer
  *
- * @param  ringbuf - Ring buffer to insert the item into
- * @param  data - Pointer to data to insert. NULL is allowed if data_size is 0.
- * @param  data_size - Size of data to insert. A value of 0 is allowed.
- * @param  xTicksToWait - Ticks to wait for room in the ringbuffer.
+ * @param  ringbuf  Ring buffer to insert the item into
+ * @param  data  Pointer to data to insert. NULL is allowed if data_size is 0.
+ * @param  data_size  Size of data to insert. A value of 0 is allowed.
+ * @param  ticks_to_wait  Ticks to wait for room in the ringbuffer.
  *
- * @return pdTRUE if succeeded, pdFALSE on time-out or when the buffer is larger 
- *         than indicated by xRingbufferGetMaxItemSize(ringbuf).
+ * @return
+ *      - pdTRUE if succeeded
+ *      - pdFALSE on time-out or when the buffer is larger than indicated
+ *        by xRingbufferGetMaxItemSize(ringbuf).
  */
 BaseType_t xRingbufferSend(RingbufHandle_t ringbuf, void *data, size_t data_size, TickType_t ticks_to_wait);
 
@@ -107,11 +114,11 @@ BaseType_t xRingbufferSend(RingbufHandle_t ringbuf, void *data, size_t data_size
 /**
  * @brief  Insert an item into the ring buffer from an ISR
  *
- * @param  ringbuf - Ring buffer to insert the item into
- * @param  data - Pointer to data to insert. NULL is allowed if data_size is 0.
- * @param  data_size - Size of data to insert. A value of 0 is allowed.
- * @param  higher_prio_task_awoken - Value pointed to will be set to pdTRUE if the push woke up a higher
- *                                     priority task.
+ * @param  ringbuf  Ring buffer to insert the item into
+ * @param  data  Pointer to data to insert. NULL is allowed if data_size is 0.
+ * @param  data_size  Size of data to insert. A value of 0 is allowed.
+ * @param[out]  higher_prio_task_awoken  Value pointed to will be set to pdTRUE
+ *                                  if the push woke up a higher priority task.
  *
  * @return pdTRUE if succeeded, pdFALSE when the ring buffer does not have space.
  */
@@ -120,14 +127,18 @@ BaseType_t xRingbufferSendFromISR(RingbufHandle_t ringbuf, void *data, size_t da
 /**
  * @brief  Retrieve an item from the ring buffer
  *
- * @note A call to vRingbufferReturnItem() is required after this to free up the data received.
+ * @note A call to vRingbufferReturnItem() is required after this to free up
+ * the data received.
  *
- * @param  ringbuf - Ring buffer to retrieve the item from
- * @param  item_size - Pointer to a variable to which the size of the retrieved item will be written.
- * @param  xTicksToWait - Ticks to wait for items in the ringbuffer.
+ * @param  ringbuf  Ring buffer to retrieve the item from
+ * @param[out] item_size  Pointer to a variable to which the size of the
+ *                        retrieved item will be written.
+ * @param  ticks_to_wait  Ticks to wait for items in the ringbuffer.
  *
- * @return Pointer to the retrieved item on success; *item_size filled with the length of the 
- *         item. NULL on timeout, *item_size is untouched in that case.
+ * @return
+ *      - pointer to the retrieved item on success; *item_size filled with
+ *        the length of the item.
+ *      - NULL on timeout, *item_size is untouched in that case.
  */
 void *xRingbufferReceive(RingbufHandle_t ringbuf, size_t *item_size, TickType_t ticks_to_wait);
 
@@ -135,44 +146,58 @@ void *xRingbufferReceive(RingbufHandle_t ringbuf, size_t *item_size, TickType_t
 /**
  * @brief  Retrieve an item from the ring buffer from an ISR
  *
- * @note A call to vRingbufferReturnItemFromISR() is required after this to free up the data received
+ * @note A call to vRingbufferReturnItemFromISR() is required after this to
+ * free up the data received
  *
- * @param  ringbuf - Ring buffer to retrieve the item from
- * @param  item_size - Pointer to a variable to which the size of the retrieved item will be written.
+ * @param  ringbuf  Ring buffer to retrieve the item from
+ * @param[out] item_size  Pointer to a variable to which the size of the
+ *                        retrieved item will be written.
  *
- * @return Pointer to the retrieved item on success; *item_size filled with the length of the 
- *         item. NULL when the ringbuffer is empty, *item_size is untouched in that case.
+ * @return
+ *      - Pointer to the retrieved item on success; *item_size filled with
+ *        the length of the item.
+ *      - NULL when the ringbuffer is empty, *item_size is untouched in that case.
  */
 void *xRingbufferReceiveFromISR(RingbufHandle_t ringbuf, size_t *item_size);
 
 
 /**
- * @brief  Retrieve bytes from a ByteBuf type of ring buffer, specifying the maximum amount of bytes
- * to return
-
- * @note A call to vRingbufferReturnItem() is required after this to free up the data received.
+ * @brief  Retrieve bytes from a ByteBuf type of ring buffer,
+ * specifying the maximum amount of bytes to return
  *
- * @param  ringbuf - Ring buffer to retrieve the item from
- * @param  item_size - Pointer to a variable to which the size of the retrieved item will be written.
- * @param  xTicksToWait - Ticks to wait for items in the ringbuffer.
+ * @note A call to vRingbufferReturnItem() is required after this to free up
+ * the data received.
  *
- * @return Pointer to the retrieved item on success; *item_size filled with the length of the 
- *         item. NULL on timeout, *item_size is untouched in that case.
+ * @param  ringbuf  Ring buffer to retrieve the item from
+ * @param[out] item_size  Pointer to a variable to which the size
+ *                        of the retrieved item will be written.
+ * @param  ticks_to_wait  Ticks to wait for items in the ringbuffer.
+ * @param  wanted_size  Maximum number of bytes to return.
+ *
+ * @return
+ *      - Pointer to the retrieved item on success; *item_size filled with
+ *        the length of the item.
+ *      - NULL on timeout, *item_size is untouched in that case.
  */
 void *xRingbufferReceiveUpTo(RingbufHandle_t ringbuf, size_t *item_size, TickType_t ticks_to_wait, size_t wanted_size);
 
 
 /**
- * @brief  Retrieve bytes from a ByteBuf type of ring buffer, specifying the maximum amount of bytes
- * to return. Call this from an ISR.
+ * @brief  Retrieve bytes from a ByteBuf type of ring buffer,
+ * specifying the maximum amount of bytes to return. Call this from an ISR.
  *
- * @note A call to vRingbufferReturnItemFromISR() is required after this to free up the data received
+ * @note A call to vRingbufferReturnItemFromISR() is required after this
+ * to free up the data received.
  *
- * @param  ringbuf - Ring buffer to retrieve the item from
- * @param  item_size - Pointer to a variable to which the size of the retrieved item will be written.
+ * @param  ringbuf  Ring buffer to retrieve the item from
+ * @param[out] item_size  Pointer to a variable to which the size of the
+ *                        retrieved item will be written.
+ * @param  wanted_size  Maximum number of bytes to return.
  *
- * @return Pointer to the retrieved item on success; *item_size filled with the length of the 
- *         item. NULL when the ringbuffer is empty, *item_size is untouched in that case.
+ * @return
+ *      - Pointer to the retrieved item on success; *item_size filled with
+ *        the length of the item.
+ *      - NULL when the ringbuffer is empty, *item_size is untouched in that case.
  */
 void *xRingbufferReceiveUpToFromISR(RingbufHandle_t ringbuf, size_t *item_size, size_t wanted_size);
 
@@ -181,10 +206,8 @@ void *xRingbufferReceiveUpToFromISR(RingbufHandle_t ringbuf, size_t *item_size,
 /**
  * @brief  Return a previously-retrieved item to the ringbuffer
  *
- * @param  ringbuf - Ring buffer the item was retrieved from
- * @param  item - Item that was received earlier
- *
- * @return void
+ * @param  ringbuf  Ring buffer the item was retrieved from
+ * @param  item  Item that was received earlier
  */
 void vRingbufferReturnItem(RingbufHandle_t ringbuf, void *item);
 
@@ -193,34 +216,37 @@ void vRingbufferReturnItem(RingbufHandle_t ringbuf, void *item);
 /**
  * @brief  Return a previously-retrieved item to the ringbuffer from an ISR
  *
- * @param  ringbuf - Ring buffer the item was retrieved from
- * @param  item - Item that was received earlier
- * @param  higher_prio_task_awoken - Value pointed to will be set to pdTRUE if the push woke up a higher
- *                                     priority task.
- *
- * @return void
+ * @param  ringbuf  Ring buffer the item was retrieved from
+ * @param  item  Item that was received earlier
+ * @param[out]  higher_prio_task_awoken  Value pointed to will be set to pdTRUE
+ *                                  if the push woke up a higher priority task.
  */
 void vRingbufferReturnItemFromISR(RingbufHandle_t ringbuf, void *item, BaseType_t *higher_prio_task_awoken);
 
 
 /**
- * @brief  Add the ringbuffer to a queue set. This specifically adds the semaphore that indicates
- *         more space has become available in the ringbuffer.
+ * @brief  Add the ringbuffer to a queue set.
  *
- * @param  ringbuf - Ring buffer to add to the queue set
- * @param  xQueueSet - Queue set to add the ringbuffer to
+ * This specifically adds the semaphore that indicates more space
+ * has become available in the ringbuffer.
  *
- * @return pdTRUE on success, pdFALSE otherwise
+ * @param  ringbuf  Ring buffer to add to the queue set
+ * @param  xQueueSet  Queue set to add the ringbuffer to
+ *
+ * @return
+ *      - pdTRUE on success, pdFALSE otherwise
  */
 BaseType_t xRingbufferAddToQueueSetRead(RingbufHandle_t ringbuf, QueueSetHandle_t xQueueSet);
 
 
 /**
- * @brief  Add the ringbuffer to a queue set. This specifically adds the semaphore that indicates
- *         something has been written into the ringbuffer.
+ * @brief  Add the ringbuffer to a queue set.
  *
- * @param  ringbuf - Ring buffer to add to the queue set
- * @param  xQueueSet - Queue set to add the ringbuffer to
+ * This specifically adds the semaphore that indicates something has been
+ * written into the ringbuffer.
+ *
+ * @param  ringbuf  Ring buffer to add to the queue set
+ * @param  xQueueSet  Queue set to add the ringbuffer to
  *
  * @return pdTRUE on success, pdFALSE otherwise
  */
@@ -228,11 +254,13 @@ BaseType_t xRingbufferAddToQueueSetWrite(RingbufHandle_t ringbuf, QueueSetHandle
 
 
 /**
- * @brief  Remove the ringbuffer from a queue set. This specifically removes the semaphore that indicates
- *         more space has become available in the ringbuffer.
+ * @brief  Remove the ringbuffer from a queue set.
  *
- * @param  ringbuf - Ring buffer to remove from the queue set
- * @param  xQueueSet - Queue set to remove the ringbuffer from
+ * This specifically removes the semaphore that indicates more space
+ * has become available in the ringbuffer.
+ *
+ * @param  ringbuf  Ring buffer to remove from the queue set
+ * @param  xQueueSet  Queue set to remove the ringbuffer from
  *
  * @return pdTRUE on success, pdFALSE otherwise
  */
@@ -240,11 +268,13 @@ BaseType_t xRingbufferRemoveFromQueueSetRead(RingbufHandle_t ringbuf, QueueSetHa
 
 
 /**
- * @brief  Remove the ringbuffer from a queue set. This specifically removes the semaphore that indicates
- *         something has been written to the ringbuffer.
+ * @brief  Remove the ringbuffer from a queue set.
  *
- * @param  ringbuf - Ring buffer to remove from the queue set
- * @param  xQueueSet - Queue set to remove the ringbuffer from
+ * This specifically removes the semaphore that indicates something
+ * has been written to the ringbuffer.
+ *
+ * @param  ringbuf  Ring buffer to remove from the queue set
+ * @param  xQueueSet  Queue set to remove the ringbuffer from
  *
  * @return pdTRUE on success, pdFALSE otherwise
  */
@@ -254,9 +284,7 @@ BaseType_t xRingbufferRemoveFromQueueSetWrite(RingbufHandle_t ringbuf, QueueSetH
 /**
  * @brief  Debugging function to print the internal pointers in the ring buffer
  *
- * @param  ringbuf - Ring buffer to show
- *
- * @return void
+ * @param  ringbuf  Ring buffer to show
  */
 void xRingbufferPrintInfo(RingbufHandle_t ringbuf);
 
diff --git a/components/freertos/include/freertos/semphr.h b/components/freertos/include/freertos/semphr.h
index 049b994e53..abe3819f8f 100644
--- a/components/freertos/include/freertos/semphr.h
+++ b/components/freertos/include/freertos/semphr.h
@@ -82,11 +82,8 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #define semSEMAPHORE_QUEUE_ITEM_LENGTH		( ( uint8_t ) 0U )
 #define semGIVE_BLOCK_TIME					( ( TickType_t ) 0U )
 
-
+/** @cond */
 /**
- * semphr. h
- * 
vSemaphoreCreateBinary( SemaphoreHandle_t xSemaphore )

- *
  * This old vSemaphoreCreateBinary() macro is now deprecated in favour of the
  * xSemaphoreCreateBinary() function.  Note that binary semaphores created using
  * the vSemaphoreCreateBinary() macro are created in a state such that the
@@ -109,23 +106,22 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * @param xSemaphore Handle to the created semaphore.  Should be of type SemaphoreHandle_t.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore = NULL;
-
- void vATask( void * pvParameters )
- {
-    // Semaphore cannot be used before a call to vSemaphoreCreateBinary ().
-    // This is a macro so pass the variable in directly.
-    vSemaphoreCreateBinary( xSemaphore );
-
-    if( xSemaphore != NULL )
-    {
-        // The semaphore was created successfully.
-        // The semaphore can now be used.
-    }
- }
- 

- * \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Semaphore cannot be used before a call to vSemaphoreCreateBinary ().
+ *     // This is a macro so pass the variable in directly.
+ *     vSemaphoreCreateBinary( xSemaphore );
+ *
+ *     if( xSemaphore != NULL )
+ *     {
+ *         // The semaphore was created successfully.
+ *         // The semaphore can now be used.
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
@@ -138,11 +134,9 @@ typedef QueueHandle_t SemaphoreHandle_t;
 			}																																\
 		}
 #endif
+/** @endcond */
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateBinary( void )

- *
  * Creates a new binary semaphore instance, and returns a handle by which the
  * new semaphore can be referenced.
  *
@@ -181,23 +175,22 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * @return Handle to the created semaphore.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore = NULL;
-
- void vATask( void * pvParameters )
- {
-    // Semaphore cannot be used before a call to vSemaphoreCreateBinary ().
-    // This is a macro so pass the variable in directly.
-    xSemaphore = xSemaphoreCreateBinary();
-
-    if( xSemaphore != NULL )
-    {
-        // The semaphore was created successfully.
-        // The semaphore can now be used.
-    }
- }
- 

- * \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Semaphore cannot be used before a call to vSemaphoreCreateBinary ().
+ *     // This is a macro so pass the variable in directly.
+ *     xSemaphore = xSemaphoreCreateBinary();
+ *
+ *     if( xSemaphore != NULL )
+ *     {
+ *         // The semaphore was created successfully.
+ *         // The semaphore can now be used.
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
@@ -205,9 +198,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #endif
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuffer )

- *
  * Creates a new binary semaphore instance, and returns a handle by which the
  * new semaphore can be referenced.
  *
@@ -231,7 +221,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semaphore does not use a priority inheritance mechanism.  For an alternative
  * that does use priority inheritance see xSemaphoreCreateMutex().
  *
- * @param pxSemaphoreBuffer Must point to a variable of type StaticSemaphore_t,
+ * @param pxStaticSemaphore Must point to a variable of type StaticSemaphore_t,
  * which will then be used to hold the semaphore's data structure, removing the
  * need for the memory to be allocated dynamically.
  *
@@ -239,24 +229,23 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * returned.  If pxSemaphoreBuffer is NULL then NULL is returned.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore = NULL;
- StaticSemaphore_t xSemaphoreBuffer;
-
- void vATask( void * pvParameters )
- {
-    // Semaphore cannot be used before a call to xSemaphoreCreateBinary().
-    // The semaphore's data structures will be placed in the xSemaphoreBuffer
-    // variable, the address of which is passed into the function.  The
-    // function's parameter is not NULL, so the function will not attempt any
-    // dynamic memory allocation, and therefore the function will not return
-    // return NULL.
-    xSemaphore = xSemaphoreCreateBinary( &xSemaphoreBuffer );
-
-    // Rest of task code goes here.
- }
- 

- * \defgroup xSemaphoreCreateBinaryStatic xSemaphoreCreateBinaryStatic
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *  StaticSemaphore_t xSemaphoreBuffer;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Semaphore cannot be used before a call to xSemaphoreCreateBinary().
+ *     // The semaphore's data structures will be placed in the xSemaphoreBuffer
+ *     // variable, the address of which is passed into the function.  The
+ *     // function's parameter is not NULL, so the function will not attempt any
+ *     // dynamic memory allocation, and therefore the function will not return
+ *     // return NULL.
+ *     xSemaphore = xSemaphoreCreateBinary( &xSemaphoreBuffer );
+ *
+ *     // Rest of task code goes here.
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
@@ -264,12 +253,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
- * semphr. h
- * 
xSemaphoreTake(
- *                   SemaphoreHandle_t xSemaphore,
- *                   TickType_t xBlockTime
- *               )

- *
  * Macro to obtain a semaphore.  The semaphore must have previously been
  * created with a call to vSemaphoreCreateBinary(), xSemaphoreCreateMutex() or
  * xSemaphoreCreateCounting().
@@ -287,56 +270,49 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * if xBlockTime expired without the semaphore becoming available.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore = NULL;
-
- // A task that creates a semaphore.
- void vATask( void * pvParameters )
- {
-    // Create the semaphore to guard a shared resource.
-    vSemaphoreCreateBinary( xSemaphore );
- }
-
- // A task that uses the semaphore.
- void vAnotherTask( void * pvParameters )
- {
-    // ... Do other things.
-
-    if( xSemaphore != NULL )
-    {
-        // See if we can obtain the semaphore.  If the semaphore is not available
-        // wait 10 ticks to see if it becomes free.
-        if( xSemaphoreTake( xSemaphore, ( TickType_t ) 10 ) == pdTRUE )
-        {
-            // We were able to obtain the semaphore and can now access the
-            // shared resource.
-
-            // ...
-
-            // We have finished accessing the shared resource.  Release the
-            // semaphore.
-            xSemaphoreGive( xSemaphore );
-        }
-        else
-        {
-            // We could not obtain the semaphore and can therefore not access
-            // the shared resource safely.
-        }
-    }
- }
- 

- * \defgroup xSemaphoreTake xSemaphoreTake
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *
+ *  // A task that creates a semaphore.
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Create the semaphore to guard a shared resource.
+ *     vSemaphoreCreateBinary( xSemaphore );
+ *  }
+ *
+ *  // A task that uses the semaphore.
+ *  void vAnotherTask( void * pvParameters )
+ *  {
+ *     // ... Do other things.
+ *
+ *     if( xSemaphore != NULL )
+ *     {
+ *         // See if we can obtain the semaphore.  If the semaphore is not available
+ *         // wait 10 ticks to see if it becomes free.
+ *         if( xSemaphoreTake( xSemaphore, ( TickType_t ) 10 ) == pdTRUE )
+ *         {
+ *             // We were able to obtain the semaphore and can now access the
+ *             // shared resource.
+ *
+ *             // ...
+ *
+ *             // We have finished accessing the shared resource.  Release the
+ *             // semaphore.
+ *             xSemaphoreGive( xSemaphore );
+ *         }
+ *         else
+ *         {
+ *             // We could not obtain the semaphore and can therefore not access
+ *             // the shared resource safely.
+ *         }
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #define xSemaphoreTake( xSemaphore, xBlockTime )		xQueueGenericReceive( ( QueueHandle_t ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )
 
 /**
- * semphr. h
- * xSemaphoreTakeRecursive(
- *                          SemaphoreHandle_t xMutex,
- *                          TickType_t xBlockTime
- *                        )
- *
  * Macro to recursively obtain, or 'take', a mutex type semaphore.
  * The mutex must have previously been created using a call to
  * xSemaphoreCreateRecursiveMutex();
@@ -366,64 +342,63 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * expired without the semaphore becoming available.
  *
  * Example usage:
- 
- SemaphoreHandle_t xMutex = NULL;
-
- // A task that creates a mutex.
- void vATask( void * pvParameters )
- {
-    // Create the mutex to guard a shared resource.
-    xMutex = xSemaphoreCreateRecursiveMutex();
- }
-
- // A task that uses the mutex.
- void vAnotherTask( void * pvParameters )
- {
-    // ... Do other things.
-
-    if( xMutex != NULL )
-    {
-        // See if we can obtain the mutex.  If the mutex is not available
-        // wait 10 ticks to see if it becomes free.
-        if( xSemaphoreTakeRecursive( xSemaphore, ( TickType_t ) 10 ) == pdTRUE )
-        {
-            // We were able to obtain the mutex and can now access the
-            // shared resource.
-
-            // ...
-            // For some reason due to the nature of the code further calls to
-			// xSemaphoreTakeRecursive() are made on the same mutex.  In real
-			// code these would not be just sequential calls as this would make
-			// no sense.  Instead the calls are likely to be buried inside
-			// a more complex call structure.
-            xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
-            xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
-
-            // The mutex has now been 'taken' three times, so will not be
-			// available to another task until it has also been given back
-			// three times.  Again it is unlikely that real code would have
-			// these calls sequentially, but instead buried in a more complex
-			// call structure.  This is just for illustrative purposes.
-            xSemaphoreGiveRecursive( xMutex );
-			xSemaphoreGiveRecursive( xMutex );
-			xSemaphoreGiveRecursive( xMutex );
-
-			// Now the mutex can be taken by other tasks.
-        }
-        else
-        {
-            // We could not obtain the mutex and can therefore not access
-            // the shared resource safely.
-        }
-    }
- }
- 

- * \defgroup xSemaphoreTakeRecursive xSemaphoreTakeRecursive
+ * @code{c}
+ *  SemaphoreHandle_t xMutex = NULL;
+ *
+ *  // A task that creates a mutex.
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Create the mutex to guard a shared resource.
+ *     xMutex = xSemaphoreCreateRecursiveMutex();
+ *  }
+ *
+ *  // A task that uses the mutex.
+ *  void vAnotherTask( void * pvParameters )
+ *  {
+ *     // ... Do other things.
+ *
+ *     if( xMutex != NULL )
+ *     {
+ *         // See if we can obtain the mutex.  If the mutex is not available
+ *         // wait 10 ticks to see if it becomes free.
+ *         if( xSemaphoreTakeRecursive( xSemaphore, ( TickType_t ) 10 ) == pdTRUE )
+ *         {
+ *             // We were able to obtain the mutex and can now access the
+ *             // shared resource.
+ *
+ *             // ...
+ *             // For some reason due to the nature of the code further calls to
+ * 			// xSemaphoreTakeRecursive() are made on the same mutex.  In real
+ * 			// code these would not be just sequential calls as this would make
+ * 			// no sense.  Instead the calls are likely to be buried inside
+ * 			// a more complex call structure.
+ *             xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
+ *             xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
+ *
+ *             // The mutex has now been 'taken' three times, so will not be
+ * 			// available to another task until it has also been given back
+ * 			// three times.  Again it is unlikely that real code would have
+ * 			// these calls sequentially, but instead buried in a more complex
+ * 			// call structure.  This is just for illustrative purposes.
+ *             xSemaphoreGiveRecursive( xMutex );
+ * 			xSemaphoreGiveRecursive( xMutex );
+ * 			xSemaphoreGiveRecursive( xMutex );
+ *
+ * 			// Now the mutex can be taken by other tasks.
+ *         }
+ *         else
+ *         {
+ *             // We could not obtain the mutex and can therefore not access
+ *             // the shared resource safely.
+ *         }
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #define xSemaphoreTakeRecursive( xMutex, xBlockTime )	xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )
 
-
+/** @cond */
 /*
  * xSemaphoreAltTake() is an alternative version of xSemaphoreTake().
  *
@@ -437,11 +412,9 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * sacrifices execution speed to ensure better interrupt responsiveness.
  */
 #define xSemaphoreAltTake( xSemaphore, xBlockTime )		xQueueAltGenericReceive( ( QueueHandle_t ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )
+/** @endcond */
 
 /**
- * semphr. h
- * 
xSemaphoreGive( SemaphoreHandle_t xSemaphore )

- *
  * Macro to release a semaphore.  The semaphore must have previously been
  * created with a call to vSemaphoreCreateBinary(), xSemaphoreCreateMutex() or
  * xSemaphoreCreateCounting(). and obtained using sSemaphoreTake().
@@ -461,50 +434,46 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semaphore was not first obtained correctly.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore = NULL;
-
- void vATask( void * pvParameters )
- {
-    // Create the semaphore to guard a shared resource.
-    vSemaphoreCreateBinary( xSemaphore );
-
-    if( xSemaphore != NULL )
-    {
-        if( xSemaphoreGive( xSemaphore ) != pdTRUE )
-        {
-            // We would expect this call to fail because we cannot give
-            // a semaphore without first "taking" it!
-        }
-
-        // Obtain the semaphore - don't block if the semaphore is not
-        // immediately available.
-        if( xSemaphoreTake( xSemaphore, ( TickType_t ) 0 ) )
-        {
-            // We now have the semaphore and can access the shared resource.
-
-            // ...
-
-            // We have finished accessing the shared resource so can free the
-            // semaphore.
-            if( xSemaphoreGive( xSemaphore ) != pdTRUE )
-            {
-                // We would not expect this call to fail because we must have
-                // obtained the semaphore to get here.
-            }
-        }
-    }
- }
- 

- * \defgroup xSemaphoreGive xSemaphoreGive
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Create the semaphore to guard a shared resource.
+ *     vSemaphoreCreateBinary( xSemaphore );
+ *
+ *     if( xSemaphore != NULL )
+ *     {
+ *         if( xSemaphoreGive( xSemaphore ) != pdTRUE )
+ *         {
+ *             // We would expect this call to fail because we cannot give
+ *             // a semaphore without first "taking" it!
+ *         }
+ *
+ *         // Obtain the semaphore - don't block if the semaphore is not
+ *         // immediately available.
+ *         if( xSemaphoreTake( xSemaphore, ( TickType_t ) 0 ) )
+ *         {
+ *             // We now have the semaphore and can access the shared resource.
+ *
+ *             // ...
+ *
+ *             // We have finished accessing the shared resource so can free the
+ *             // semaphore.
+ *             if( xSemaphoreGive( xSemaphore ) != pdTRUE )
+ *             {
+ *                 // We would not expect this call to fail because we must have
+ *                 // obtained the semaphore to get here.
+ *             }
+ *         }
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #define xSemaphoreGive( xSemaphore )		xQueueGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
 
 /**
- * semphr. h
- * 
xSemaphoreGiveRecursive( SemaphoreHandle_t xMutex )

- *
  * Macro to recursively release, or 'give', a mutex type semaphore.
  * The mutex must have previously been created using a call to
  * xSemaphoreCreateRecursiveMutex();
@@ -527,64 +496,64 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * @return pdTRUE if the semaphore was given.
  *
  * Example usage:
- 
- SemaphoreHandle_t xMutex = NULL;
-
- // A task that creates a mutex.
- void vATask( void * pvParameters )
- {
-    // Create the mutex to guard a shared resource.
-    xMutex = xSemaphoreCreateRecursiveMutex();
- }
-
- // A task that uses the mutex.
- void vAnotherTask( void * pvParameters )
- {
-    // ... Do other things.
-
-    if( xMutex != NULL )
-    {
-        // See if we can obtain the mutex.  If the mutex is not available
-        // wait 10 ticks to see if it becomes free.
-        if( xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 ) == pdTRUE )
-        {
-            // We were able to obtain the mutex and can now access the
-            // shared resource.
-
-            // ...
-            // For some reason due to the nature of the code further calls to
-			// xSemaphoreTakeRecursive() are made on the same mutex.  In real
-			// code these would not be just sequential calls as this would make
-			// no sense.  Instead the calls are likely to be buried inside
-			// a more complex call structure.
-            xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
-            xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
-
-            // The mutex has now been 'taken' three times, so will not be
-			// available to another task until it has also been given back
-			// three times.  Again it is unlikely that real code would have
-			// these calls sequentially, it would be more likely that the calls
-			// to xSemaphoreGiveRecursive() would be called as a call stack
-			// unwound.  This is just for demonstrative purposes.
-            xSemaphoreGiveRecursive( xMutex );
-			xSemaphoreGiveRecursive( xMutex );
-			xSemaphoreGiveRecursive( xMutex );
-
-			// Now the mutex can be taken by other tasks.
-        }
-        else
-        {
-            // We could not obtain the mutex and can therefore not access
-            // the shared resource safely.
-        }
-    }
- }
- 

- * \defgroup xSemaphoreGiveRecursive xSemaphoreGiveRecursive
+ * @code{c}
+ *  SemaphoreHandle_t xMutex = NULL;
+ *
+ *  // A task that creates a mutex.
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Create the mutex to guard a shared resource.
+ *     xMutex = xSemaphoreCreateRecursiveMutex();
+ *  }
+ *
+ *  // A task that uses the mutex.
+ *  void vAnotherTask( void * pvParameters )
+ *  {
+ *     // ... Do other things.
+ *
+ *     if( xMutex != NULL )
+ *     {
+ *         // See if we can obtain the mutex.  If the mutex is not available
+ *         // wait 10 ticks to see if it becomes free.
+ *         if( xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 ) == pdTRUE )
+ *         {
+ *             // We were able to obtain the mutex and can now access the
+ *             // shared resource.
+ *
+ *             // ...
+ *             // For some reason due to the nature of the code further calls to
+ * 			// xSemaphoreTakeRecursive() are made on the same mutex.  In real
+ * 			// code these would not be just sequential calls as this would make
+ * 			// no sense.  Instead the calls are likely to be buried inside
+ * 			// a more complex call structure.
+ *             xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
+ *             xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
+ *
+ *             // The mutex has now been 'taken' three times, so will not be
+ * 			// available to another task until it has also been given back
+ * 			// three times.  Again it is unlikely that real code would have
+ * 			// these calls sequentially, it would be more likely that the calls
+ * 			// to xSemaphoreGiveRecursive() would be called as a call stack
+ * 			// unwound.  This is just for demonstrative purposes.
+ *             xSemaphoreGiveRecursive( xMutex );
+ * 			xSemaphoreGiveRecursive( xMutex );
+ * 			xSemaphoreGiveRecursive( xMutex );
+ *
+ * 			// Now the mutex can be taken by other tasks.
+ *         }
+ *         else
+ *         {
+ *             // We could not obtain the mutex and can therefore not access
+ *             // the shared resource safely.
+ *         }
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #define xSemaphoreGiveRecursive( xMutex )	xQueueGiveMutexRecursive( ( xMutex ) )
 
+/** @cond */
 /*
  * xSemaphoreAltGive() is an alternative version of xSemaphoreGive().
  *
@@ -599,14 +568,9 @@ typedef QueueHandle_t SemaphoreHandle_t;
  */
 #define xSemaphoreAltGive( xSemaphore )		xQueueAltGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
 
+/** @endcond */
+
 /**
- * semphr. h
- * 
- xSemaphoreGiveFromISR(
-                          SemaphoreHandle_t xSemaphore,
-                          BaseType_t *pxHigherPriorityTaskWoken
-                      )

- *
  * Macro to  release a semaphore.  The semaphore must have previously been
  * created with a call to vSemaphoreCreateBinary() or xSemaphoreCreateCounting().
  *
@@ -618,7 +582,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * @param xSemaphore A handle to the semaphore being released.  This is the
  * handle returned when the semaphore was created.
  *
- * @param pxHigherPriorityTaskWoken xSemaphoreGiveFromISR() will set
+ * @param[out] pxHigherPriorityTaskWoken xSemaphoreGiveFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if giving the semaphore caused a task
  * to unblock, and the unblocked task has a priority higher than the currently
  * running task.  If xSemaphoreGiveFromISR() sets this value to pdTRUE then
@@ -627,77 +591,69 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * @return pdTRUE if the semaphore was successfully given, otherwise errQUEUE_FULL.
  *
  * Example usage:
- 
- \#define LONG_TIME 0xffff
- \#define TICKS_TO_WAIT	10
- SemaphoreHandle_t xSemaphore = NULL;
-
- // Repetitive task.
- void vATask( void * pvParameters )
- {
-    for( ;; )
-    {
-        // We want this task to run every 10 ticks of a timer.  The semaphore
-        // was created before this task was started.
-
-        // Block waiting for the semaphore to become available.
-        if( xSemaphoreTake( xSemaphore, LONG_TIME ) == pdTRUE )
-        {
-            // It is time to execute.
-
-            // ...
-
-            // We have finished our task.  Return to the top of the loop where
-            // we will block on the semaphore until it is time to execute
-            // again.  Note when using the semaphore for synchronisation with an
-			// ISR in this manner there is no need to 'give' the semaphore back.
-        }
-    }
- }
-
- // Timer ISR
- void vTimerISR( void * pvParameters )
- {
- static uint8_t ucLocalTickCount = 0;
- static BaseType_t xHigherPriorityTaskWoken;
-
-    // A timer tick has occurred.
-
-    // ... Do other time functions.
-
-    // Is it time for vATask () to run?
-	xHigherPriorityTaskWoken = pdFALSE;
-    ucLocalTickCount++;
-    if( ucLocalTickCount >= TICKS_TO_WAIT )
-    {
-        // Unblock the task by releasing the semaphore.
-        xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );
-
-        // Reset the count so we release the semaphore again in 10 ticks time.
-        ucLocalTickCount = 0;
-    }
-
-    if( xHigherPriorityTaskWoken != pdFALSE )
-    {
-        // We can force a context switch here.  Context switching from an
-        // ISR uses port specific syntax.  Check the demo task for your port
-        // to find the syntax required.
-    }
- }
- 

- * \defgroup xSemaphoreGiveFromISR xSemaphoreGiveFromISR
+ * @code{c}
+ *  \#define LONG_TIME 0xffff
+ *  \#define TICKS_TO_WAIT	10
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *
+ *  // Repetitive task.
+ *  void vATask( void * pvParameters )
+ *  {
+ *     for( ;; )
+ *     {
+ *         // We want this task to run every 10 ticks of a timer.  The semaphore
+ *         // was created before this task was started.
+ *
+ *         // Block waiting for the semaphore to become available.
+ *         if( xSemaphoreTake( xSemaphore, LONG_TIME ) == pdTRUE )
+ *         {
+ *             // It is time to execute.
+ *
+ *             // ...
+ *
+ *             // We have finished our task.  Return to the top of the loop where
+ *             // we will block on the semaphore until it is time to execute
+ *             // again.  Note when using the semaphore for synchronisation with an
+ * 			// ISR in this manner there is no need to 'give' the semaphore back.
+ *         }
+ *     }
+ *  }
+ *
+ *  // Timer ISR
+ *  void vTimerISR( void * pvParameters )
+ *  {
+ *  static uint8_t ucLocalTickCount = 0;
+ *  static BaseType_t xHigherPriorityTaskWoken;
+ *
+ *     // A timer tick has occurred.
+ *
+ *     // ... Do other time functions.
+ *
+ *     // Is it time for vATask () to run?
+ * 	xHigherPriorityTaskWoken = pdFALSE;
+ *     ucLocalTickCount++;
+ *     if( ucLocalTickCount >= TICKS_TO_WAIT )
+ *     {
+ *         // Unblock the task by releasing the semaphore.
+ *         xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );
+ *
+ *         // Reset the count so we release the semaphore again in 10 ticks time.
+ *         ucLocalTickCount = 0;
+ *     }
+ *
+ *     if( xHigherPriorityTaskWoken != pdFALSE )
+ *     {
+ *         // We can force a context switch here.  Context switching from an
+ *         // ISR uses port specific syntax.  Check the demo task for your port
+ *         // to find the syntax required.
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )	xQueueGiveFromISR( ( QueueHandle_t ) ( xSemaphore ), ( pxHigherPriorityTaskWoken ) )
 
 /**
- * semphr. h
- * 
- xSemaphoreTakeFromISR(
-                          SemaphoreHandle_t xSemaphore,
-                          BaseType_t *pxHigherPriorityTaskWoken
-                      )

- *
  * Macro to  take a semaphore from an ISR.  The semaphore must have
  * previously been created with a call to vSemaphoreCreateBinary() or
  * xSemaphoreCreateCounting().
@@ -713,7 +669,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * @param xSemaphore A handle to the semaphore being taken.  This is the
  * handle returned when the semaphore was created.
  *
- * @param pxHigherPriorityTaskWoken xSemaphoreTakeFromISR() will set
+ * @param[out] pxHigherPriorityTaskWoken xSemaphoreTakeFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if taking the semaphore caused a task
  * to unblock, and the unblocked task has a priority higher than the currently
  * running task.  If xSemaphoreTakeFromISR() sets this value to pdTRUE then
@@ -725,9 +681,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #define xSemaphoreTakeFromISR( xSemaphore, pxHigherPriorityTaskWoken )	xQueueReceiveFromISR( ( QueueHandle_t ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ) )
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateMutex( void )

- *
  * Macro that implements a mutex semaphore by using the existing queue
  * mechanism.
  *
@@ -760,23 +713,22 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * data structures then NULL is returned.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore;
-
- void vATask( void * pvParameters )
- {
-    // Semaphore cannot be used before a call to xSemaphoreCreateMutex().
-    // This is a macro so pass the variable in directly.
-    xSemaphore = xSemaphoreCreateMutex();
-
-    if( xSemaphore != NULL )
-    {
-        // The semaphore was created successfully.
-        // The semaphore can now be used.
-    }
- }
- 

- * \defgroup vSemaphoreCreateMutex vSemaphoreCreateMutex
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Semaphore cannot be used before a call to xSemaphoreCreateMutex().
+ *     // This is a macro so pass the variable in directly.
+ *     xSemaphore = xSemaphoreCreateMutex();
+ *
+ *     if( xSemaphore != NULL )
+ *     {
+ *         // The semaphore was created successfully.
+ *         // The semaphore can now be used.
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
@@ -784,9 +736,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #endif
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateMutexStatic( StaticSemaphore_t *pxMutexBuffer )

- *
  * Creates a new mutex type semaphore instance, and returns a handle by which
  * the new mutex can be referenced.
  *
@@ -822,22 +771,21 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * mutex is returned.  If pxMutexBuffer was NULL then NULL is returned.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore;
- StaticSemaphore_t xMutexBuffer;
-
- void vATask( void * pvParameters )
- {
-    // A mutex cannot be used before it has been created.  xMutexBuffer is
-    // into xSemaphoreCreateMutexStatic() so no dynamic memory allocation is
-    // attempted.
-    xSemaphore = xSemaphoreCreateMutexStatic( &xMutexBuffer );
-
-    // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,
-    // so there is no need to check it.
- }
- 

- * \defgroup xSemaphoreCreateMutexStatic xSemaphoreCreateMutexStatic
+ * @code
+ *  SemaphoreHandle_t xSemaphore;
+ *  StaticSemaphore_t xMutexBuffer;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // A mutex cannot be used before it has been created.  xMutexBuffer is
+ *     // into xSemaphoreCreateMutexStatic() so no dynamic memory allocation is
+ *     // attempted.
+ *     xSemaphore = xSemaphoreCreateMutexStatic( &xMutexBuffer );
+ *
+ *     // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,
+ *     // so there is no need to check it.
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
  #if( configSUPPORT_STATIC_ALLOCATION == 1 )
@@ -846,9 +794,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateRecursiveMutex( void )

- *
  * Creates a new recursive mutex type semaphore instance, and returns a handle
  * by which the new recursive mutex can be referenced.
  *
@@ -889,23 +834,22 @@ typedef QueueHandle_t SemaphoreHandle_t;
  *		SemaphoreHandle_t.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore;
-
- void vATask( void * pvParameters )
- {
-    // Semaphore cannot be used before a call to xSemaphoreCreateMutex().
-    // This is a macro so pass the variable in directly.
-    xSemaphore = xSemaphoreCreateRecursiveMutex();
-
-    if( xSemaphore != NULL )
-    {
-        // The semaphore was created successfully.
-        // The semaphore can now be used.
-    }
- }
- 

- * \defgroup vSemaphoreCreateMutex vSemaphoreCreateMutex
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // Semaphore cannot be used before a call to xSemaphoreCreateMutex().
+ *     // This is a macro so pass the variable in directly.
+ *     xSemaphore = xSemaphoreCreateRecursiveMutex();
+ *
+ *     if( xSemaphore != NULL )
+ *     {
+ *         // The semaphore was created successfully.
+ *         // The semaphore can now be used.
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )
@@ -913,9 +857,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #endif
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateRecursiveMutexStatic( StaticSemaphore_t *pxMutexBuffer )

- *
  * Creates a new recursive mutex type semaphore instance, and returns a handle
  * by which the new recursive mutex can be referenced.
  *
@@ -952,7 +893,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semaphore and another always 'takes' the semaphore) and from within interrupt
  * service routines.
  *
- * @param pxMutexBuffer Must point to a variable of type StaticSemaphore_t,
+ * @param pxStaticSemaphore Must point to a variable of type StaticSemaphore_t,
  * which will then be used to hold the recursive mutex's data structure,
  * removing the need for the memory to be allocated dynamically.
  *
@@ -961,24 +902,23 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * returned.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore;
- StaticSemaphore_t xMutexBuffer;
-
- void vATask( void * pvParameters )
- {
-    // A recursive semaphore cannot be used before it is created.  Here a
-    // recursive mutex is created using xSemaphoreCreateRecursiveMutexStatic().
-    // The address of xMutexBuffer is passed into the function, and will hold
-    // the mutexes data structures - so no dynamic memory allocation will be
-    // attempted.
-    xSemaphore = xSemaphoreCreateRecursiveMutexStatic( &xMutexBuffer );
-
-    // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,
-    // so there is no need to check it.
- }
- 

- * \defgroup xSemaphoreCreateRecursiveMutexStatic xSemaphoreCreateRecursiveMutexStatic
+ * @code
+ *  SemaphoreHandle_t xSemaphore;
+ *  StaticSemaphore_t xMutexBuffer;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *     // A recursive semaphore cannot be used before it is created.  Here a
+ *     // recursive mutex is created using xSemaphoreCreateRecursiveMutexStatic().
+ *     // The address of xMutexBuffer is passed into the function, and will hold
+ *     // the mutexes data structures - so no dynamic memory allocation will be
+ *     // attempted.
+ *     xSemaphore = xSemaphoreCreateRecursiveMutexStatic( &xMutexBuffer );
+ *
+ *     // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,
+ *     // so there is no need to check it.
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )
@@ -986,9 +926,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount )

- *
  * Creates a new counting semaphore instance, and returns a handle by which the
  * new counting semaphore can be referenced.
  *
@@ -1039,26 +976,25 @@ typedef QueueHandle_t SemaphoreHandle_t;
  *         created.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore;
-
- void vATask( void * pvParameters )
- {
- SemaphoreHandle_t xSemaphore = NULL;
-
-    // Semaphore cannot be used before a call to xSemaphoreCreateCounting().
-    // The max value to which the semaphore can count should be 10, and the
-    // initial value assigned to the count should be 0.
-    xSemaphore = xSemaphoreCreateCounting( 10, 0 );
-
-    if( xSemaphore != NULL )
-    {
-        // The semaphore was created successfully.
-        // The semaphore can now be used.
-    }
- }
- 

- * \defgroup xSemaphoreCreateCounting xSemaphoreCreateCounting
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *
+ *     // Semaphore cannot be used before a call to xSemaphoreCreateCounting().
+ *     // The max value to which the semaphore can count should be 10, and the
+ *     // initial value assigned to the count should be 0.
+ *     xSemaphore = xSemaphoreCreateCounting( 10, 0 );
+ *
+ *     if( xSemaphore != NULL )
+ *     {
+ *         // The semaphore was created successfully.
+ *         // The semaphore can now be used.
+ *     }
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
@@ -1066,9 +1002,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #endif
 
 /**
- * semphr. h
- * 
SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, StaticSemaphore_t *pxSemaphoreBuffer )

- *
  * Creates a new counting semaphore instance, and returns a handle by which the
  * new counting semaphore can be referenced.
  *
@@ -1123,27 +1056,26 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * then NULL is returned.
  *
  * Example usage:
- 
- SemaphoreHandle_t xSemaphore;
- StaticSemaphore_t xSemaphoreBuffer;
-
- void vATask( void * pvParameters )
- {
- SemaphoreHandle_t xSemaphore = NULL;
-
-    // Counting semaphore cannot be used before they have been created.  Create
-    // a counting semaphore using xSemaphoreCreateCountingStatic().  The max
-    // value to which the semaphore can count is 10, and the initial value
-    // assigned to the count will be 0.  The address of xSemaphoreBuffer is
-    // passed in and will be used to hold the semaphore structure, so no dynamic
-    // memory allocation will be used.
-    xSemaphore = xSemaphoreCreateCounting( 10, 0, &xSemaphoreBuffer );
-
-    // No memory allocation was attempted so xSemaphore cannot be NULL, so there
-    // is no need to check its value.
- }
- 

- * \defgroup xSemaphoreCreateCountingStatic xSemaphoreCreateCountingStatic
+ * @code{c}
+ *  SemaphoreHandle_t xSemaphore;
+ *  StaticSemaphore_t xSemaphoreBuffer;
+ *
+ *  void vATask( void * pvParameters )
+ *  {
+ *  SemaphoreHandle_t xSemaphore = NULL;
+ *
+ *     // Counting semaphore cannot be used before they have been created.  Create
+ *     // a counting semaphore using xSemaphoreCreateCountingStatic().  The max
+ *     // value to which the semaphore can count is 10, and the initial value
+ *     // assigned to the count will be 0.  The address of xSemaphoreBuffer is
+ *     // passed in and will be used to hold the semaphore structure, so no dynamic
+ *     // memory allocation will be used.
+ *     xSemaphore = xSemaphoreCreateCounting( 10, 0, &xSemaphoreBuffer );
+ *
+ *     // No memory allocation was attempted so xSemaphore cannot be NULL, so there
+ *     // is no need to check its value.
+ *  }
+ * @endcode
  * \ingroup Semaphores
  */
 #if( configSUPPORT_STATIC_ALLOCATION == 1 )
@@ -1151,23 +1083,16 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
- * semphr. h
- * 
void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );

- *
  * Delete a semaphore.  This function must be used with care.  For example,
  * do not delete a mutex type semaphore if the mutex is held by a task.
  *
  * @param xSemaphore A handle to the semaphore to be deleted.
  *
- * \defgroup vSemaphoreDelete vSemaphoreDelete
  * \ingroup Semaphores
  */
 #define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
 
 /**
- * semphr.h
- * 
TaskHandle_t xSemaphoreGetMutexHolder( SemaphoreHandle_t xMutex );

- *
  * If xMutex is indeed a mutex type semaphore, return the current mutex holder.
  * If xMutex is not a mutex type semaphore, or the mutex is available (not held
  * by a task), return NULL.
@@ -1180,9 +1105,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
 #define xSemaphoreGetMutexHolder( xSemaphore ) xQueueGetMutexHolder( ( xSemaphore ) )
 
 /**
- * semphr.h
- * 
UBaseType_t uxSemaphoreGetCount( SemaphoreHandle_t xSemaphore );

- *
  * If the semaphore is a counting semaphore then uxSemaphoreGetCount() returns
  * its current count value.  If the semaphore is a binary semaphore then
  * uxSemaphoreGetCount() returns 1 if the semaphore is available, and 0 if the
diff --git a/components/freertos/include/freertos/task.h b/components/freertos/include/freertos/task.h
index 073267445f..ab45f1c43e 100644
--- a/components/freertos/include/freertos/task.h
+++ b/components/freertos/include/freertos/task.h
@@ -102,38 +102,38 @@ extern "C" {
  * returns (via a pointer parameter) an TaskHandle_t variable that can then
  * be used as a parameter to vTaskDelete to delete the task.
  *
- * \defgroup TaskHandle_t TaskHandle_t
  * \ingroup Tasks
  */
 typedef void * TaskHandle_t;
 
-/*
+/**
  * Defines the prototype to which the application task hook function must
  * conform.
  */
 typedef BaseType_t (*TaskHookFunction_t)( void * );
 
-/* Task states returned by eTaskGetState. */
+/** Task states returned by eTaskGetState. */
 typedef enum
 {
-	eRunning = 0,	/* A task is querying the state of itself, so must be running. */
-	eReady,			/* The task being queried is in a read or pending ready list. */
-	eBlocked,		/* The task being queried is in the Blocked state. */
-	eSuspended,		/* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */
-	eDeleted		/* The task being queried has been deleted, but its TCB has not yet been freed. */
+	eRunning = 0,	/*!< A task is querying the state of itself, so must be running. */
+	eReady,			/*!< The task being queried is in a read or pending ready list. */
+	eBlocked,		/*!< The task being queried is in the Blocked state. */
+	eSuspended,		/*!< The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */
+	eDeleted		/*!< The task being queried has been deleted, but its TCB has not yet been freed. */
 } eTaskState;
 
-/* Actions that can be performed when vTaskNotify() is called. */
+/** Actions that can be performed when vTaskNotify() is called. */
 typedef enum
 {
-	eNoAction = 0,				/* Notify the task without updating its notify value. */
-	eSetBits,					/* Set bits in the task's notification value. */
-	eIncrement,					/* Increment the task's notification value. */
-	eSetValueWithOverwrite,		/* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
-	eSetValueWithoutOverwrite	/* Set the task's notification value if the previous value has been read by the task. */
+	eNoAction = 0,				/*!< Notify the task without updating its notify value. */
+	eSetBits,					/*!< Set bits in the task's notification value. */
+	eIncrement,					/*!< Increment the task's notification value. */
+	eSetValueWithOverwrite,		/*!< Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
+	eSetValueWithoutOverwrite	/*!< Set the task's notification value if the previous value has been read by the task. */
 } eNotifyAction;
 
-/*
+/** @cond */
+/**
  * Used internally only.
  */
 typedef struct xTIME_OUT
@@ -142,7 +142,7 @@ typedef struct xTIME_OUT
 	TickType_t xTimeOnEntering;
 } TimeOut_t;
 
-/*
+/**
  * Defines the memory ranges allocated to the task when an MPU is used.
  */
 typedef struct xMEMORY_REGION
@@ -152,7 +152,7 @@ typedef struct xMEMORY_REGION
 	uint32_t ulParameters;
 } MemoryRegion_t;
 
-/*
+/**
  * Parameters required to create an MPU protected task.
  */
 typedef struct xTASK_PARAMETERS
@@ -165,40 +165,44 @@ typedef struct xTASK_PARAMETERS
 	StackType_t *puxStackBuffer;
 	MemoryRegion_t xRegions[ portNUM_CONFIGURABLE_REGIONS ];
 } TaskParameters_t;
+/** @endcond */
 
-/* Used with the uxTaskGetSystemState() function to return the state of each task
-in the system. */
+/**
+ *  Used with the uxTaskGetSystemState() function to return the state of each task in the system.
+*/
 typedef struct xTASK_STATUS
 {
-	TaskHandle_t xHandle;			/* The handle of the task to which the rest of the information in the structure relates. */
-	const char *pcTaskName;			/* A pointer to the task's name.  This value will be invalid if the task was deleted since the structure was populated! */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
-	UBaseType_t xTaskNumber;		/* A number unique to the task. */
-	eTaskState eCurrentState;		/* The state in which the task existed when the structure was populated. */
-	UBaseType_t uxCurrentPriority;	/* The priority at which the task was running (may be inherited) when the structure was populated. */
-	UBaseType_t uxBasePriority;		/* The priority to which the task will return if the task's current priority has been inherited to avoid unbounded priority inversion when obtaining a mutex.  Only valid if configUSE_MUTEXES is defined as 1 in FreeRTOSConfig.h. */
-	uint32_t ulRunTimeCounter;		/* The total run time allocated to the task so far, as defined by the run time stats clock.  See http://www.freertos.org/rtos-run-time-stats.html.  Only valid when configGENERATE_RUN_TIME_STATS is defined as 1 in FreeRTOSConfig.h. */
-	StackType_t *pxStackBase;		/* Points to the lowest address of the task's stack area. */
-	uint32_t usStackHighWaterMark;	/* The minimum amount of stack space that has remained for the task since the task was created.  The closer this value is to zero the closer the task has come to overflowing its stack. */
+	TaskHandle_t xHandle;			/*!< The handle of the task to which the rest of the information in the structure relates. */
+	const char *pcTaskName;			/*!< A pointer to the task's name.  This value will be invalid if the task was deleted since the structure was populated! */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+	UBaseType_t xTaskNumber;		/*!< A number unique to the task. */
+	eTaskState eCurrentState;		/*!< The state in which the task existed when the structure was populated. */
+	UBaseType_t uxCurrentPriority;	/*!< The priority at which the task was running (may be inherited) when the structure was populated. */
+	UBaseType_t uxBasePriority;		/*!< The priority to which the task will return if the task's current priority has been inherited to avoid unbounded priority inversion when obtaining a mutex.  Only valid if configUSE_MUTEXES is defined as 1 in FreeRTOSConfig.h. */
+	uint32_t ulRunTimeCounter;		/*!< The total run time allocated to the task so far, as defined by the run time stats clock.  See http://www.freertos.org/rtos-run-time-stats.html.  Only valid when configGENERATE_RUN_TIME_STATS is defined as 1 in FreeRTOSConfig.h. */
+	StackType_t *pxStackBase;		/*!< Points to the lowest address of the task's stack area. */
+	uint32_t usStackHighWaterMark;	/*!< The minimum amount of stack space that has remained for the task since the task was created.  The closer this value is to zero the closer the task has come to overflowing its stack. */
 } TaskStatus_t;
 
-/*
+/**
  * Used with the uxTaskGetSnapshotAll() function to save memory snapshot of each task in the system.
  * We need this struct because TCB_t is defined (hidden) in tasks.c.
  */
 typedef struct xTASK_SNAPSHOT
 {
-    void        *pxTCB;         /* Address of task control block. */
-    StackType_t *pxTopOfStack;  /* Points to the location of the last item placed on the tasks stack. */
-    StackType_t *pxEndOfStack;  /* Points to the end of the stack. pxTopOfStack < pxEndOfStack, stack grows hi2lo
-                                    pxTopOfStack > pxEndOfStack, stack grows lo2hi*/
+	void        *pxTCB;         /*!< Address of task control block. */
+	StackType_t *pxTopOfStack;  /*!< Points to the location of the last item placed on the tasks stack. */
+	StackType_t *pxEndOfStack;  /*!< Points to the end of the stack. pxTopOfStack < pxEndOfStack, stack grows hi2lo
+									pxTopOfStack > pxEndOfStack, stack grows lo2hi*/
 } TaskSnapshot_t;
 
-/* Possible return values for eTaskConfirmSleepModeStatus(). */
+/**
+ * Possible return values for eTaskConfirmSleepModeStatus().
+ */
 typedef enum
 {
-	eAbortSleep = 0,		/* A task has been made ready or a context switch pended since portSUPPORESS_TICKS_AND_SLEEP() was called - abort entering a sleep mode. */
-	eStandardSleep,			/* Enter a sleep mode that will not last any longer than the expected idle time. */
-	eNoTasksWaitingTimeout	/* No tasks are waiting for a timeout so it is safe to enter a sleep mode that can only be exited by an external interrupt. */
+	eAbortSleep = 0,		/*!< A task has been made ready or a context switch pended since portSUPPORESS_TICKS_AND_SLEEP() was called - abort entering a sleep mode. */
+	eStandardSleep,			/*!< Enter a sleep mode that will not last any longer than the expected idle time. */
+	eNoTasksWaitingTimeout	/*!< No tasks are waiting for a timeout so it is safe to enter a sleep mode that can only be exited by an external interrupt. */
 } eSleepModeStatus;
 
 
@@ -214,7 +218,6 @@ typedef enum
  *
  * Macro for forcing a context switch.
  *
- * \defgroup taskYIELD taskYIELD
  * \ingroup SchedulerControl
  */
 #define taskYIELD()					portYIELD()
@@ -225,10 +228,9 @@ typedef enum
  * Macro to mark the start of a critical code region.  Preemptive context
  * switches cannot occur when in a critical region.
  *
- * NOTE: This may alter the stack (depending on the portable implementation)
+ * @note This may alter the stack (depending on the portable implementation)
  * so must be used with care!
  *
- * \defgroup taskENTER_CRITICAL taskENTER_CRITICAL
  * \ingroup SchedulerControl
  */
 #define taskENTER_CRITICAL(mux)		portENTER_CRITICAL(mux)
@@ -240,10 +242,9 @@ typedef enum
  * Macro to mark the end of a critical code region.  Preemptive context
  * switches cannot occur when in a critical region.
  *
- * NOTE: This may alter the stack (depending on the portable implementation)
+ * @note This may alter the stack (depending on the portable implementation)
  * so must be used with care!
  *
- * \defgroup taskEXIT_CRITICAL taskEXIT_CRITICAL
  * \ingroup SchedulerControl
  */
 #define taskEXIT_CRITICAL(mux)			portEXIT_CRITICAL(mux)
@@ -254,7 +255,6 @@ typedef enum
  *
  * Macro to disable all maskable interrupts.
  *
- * \defgroup taskDISABLE_INTERRUPTS taskDISABLE_INTERRUPTS
  * \ingroup SchedulerControl
  */
 #define taskDISABLE_INTERRUPTS()	portDISABLE_INTERRUPTS()
@@ -264,7 +264,6 @@ typedef enum
  *
  * Macro to enable microcontroller interrupts.
  *
- * \defgroup taskENABLE_INTERRUPTS taskENABLE_INTERRUPTS
  * \ingroup SchedulerControl
  */
 #define taskENABLE_INTERRUPTS()		portENABLE_INTERRUPTS()
@@ -282,17 +281,58 @@ is used in assert() statements. */
  *----------------------------------------------------------*/
 
 /**
- * task. h
- *
- BaseType_t xTaskCreate(
-							  TaskFunction_t pvTaskCode,
-							  const char * const pcName,
-							  uint32_t usStackDepth,
-							  void *pvParameters,
-							  UBaseType_t uxPriority,
-							  TaskHandle_t *pvCreatedTask
-						  );

+ * Create a new task with a specified affinity.
  *
+ * This function is similar to xTaskCreate, but allows setting task affinity
+ * in SMP system.
+ *
+ * @param pvTaskCode Pointer to the task entry function.  Tasks
+ * must be implemented to never return (i.e. continuous loop).
+ *
+ * @param pcName A descriptive name for the task.  This is mainly used to
+ * facilitate debugging.  Max length defined by configMAX_TASK_NAME_LEN - default
+ * is 16.
+ *
+ * @param usStackDepth The size of the task stack specified as the number of
+ * variables the stack can hold - not the number of bytes.  For example, if
+ * the stack is 16 bits wide and usStackDepth is defined as 100, 200 bytes
+ * will be allocated for stack storage.
+ *
+ * @param pvParameters Pointer that will be used as the parameter for the task
+ * being created.
+ *
+ * @param uxPriority The priority at which the task should run.  Systems that
+ * include MPU support can optionally create tasks in a privileged (system)
+ * mode by setting bit portPRIVILEGE_BIT of the priority parameter.  For
+ * example, to create a privileged task at priority 2 the uxPriority parameter
+ * should be set to ( 2 | portPRIVILEGE_BIT ).
+ *
+ * @param pvCreatedTask Used to pass back a handle by which the created task
+ * can be referenced.
+ *
+ * @param xCoreID If the value is tskNO_AFFINITY, the created task is not
+ * pinned to any CPU, and the scheduler can run it on any core available.
+ * Other values indicate the index number of the CPU which the task should
+ * be pinned to. Specifying values larger than (portNUM_PROCESSORS - 1) will
+ * cause the function to fail.
+ *
+ * @return pdPASS if the task was successfully created and added to a ready
+ * list, otherwise an error code defined in the file projdefs.h
+ *
+ * \ingroup Tasks
+ */
+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
+	BaseType_t xTaskCreatePinnedToCore(	TaskFunction_t pvTaskCode,
+										const char * const pcName,
+										const uint32_t usStackDepth,
+										void * const pvParameters,
+										UBaseType_t uxPriority,
+										TaskHandle_t * const pvCreatedTask,
+										const BaseType_t xCoreID);
+
+#endif
+
+/**
  * Create a new task and add it to the list of tasks that are ready to run.
  *
  * Internally, within the FreeRTOS implementation, tasks use two blocks of
@@ -341,64 +381,113 @@ is used in assert() statements. */
  * list, otherwise an error code defined in the file projdefs.h
  *
  * Example usage:
-   
- // Task to be created.
- void vTaskCode( void * pvParameters )
- {
-	 for( ;; )
-	 {
-		 // Task code goes here.
-	 }
- }
-
- // Function that creates a task.
- void vOtherFunction( void )
- {
- static uint8_t ucParameterToPass;
- TaskHandle_t xHandle = NULL;
-
-	 // Create the task, storing the handle.  Note that the passed parameter ucParameterToPass
-	 // must exist for the lifetime of the task, so in this case is declared static.  If it was just an
-	 // an automatic stack variable it might no longer exist, or at least have been corrupted, by the time
-	 // the new task attempts to access it.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );
-     configASSERT( xHandle );
-
-	 // Use the handle to delete the task.
-     if( xHandle != NULL )
-     {
-	     vTaskDelete( xHandle );
-     }
- }
-   

- * \defgroup xTaskCreate xTaskCreate
+ * @code{c}
+ *  // Task to be created.
+ *  void vTaskCode( void * pvParameters )
+ *  {
+ *   for( ;; )
+ *   {
+ *       // Task code goes here.
+ *   }
+ *  }
+ *
+ *  // Function that creates a task.
+ *  void vOtherFunction( void )
+ *  {
+ *  static uint8_t ucParameterToPass;
+ *  TaskHandle_t xHandle = NULL;
+ *
+ *   // Create the task, storing the handle.  Note that the passed parameter ucParameterToPass
+ *   // must exist for the lifetime of the task, so in this case is declared static.  If it was just an
+ *   // an automatic stack variable it might no longer exist, or at least have been corrupted, by the time
+ *   // the new task attempts to access it.
+ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );
+ *      configASSERT( xHandle );
+ *
+ *   // Use the handle to delete the task.
+ *      if( xHandle != NULL )
+ *      {
+ *       vTaskDelete( xHandle );
+ *      }
+ *  }
+ * @endcode
  * \ingroup Tasks
  */
-#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-    BaseType_t xTaskCreatePinnedToCore(	TaskFunction_t pxTaskCode,
-							            const char * const pcName,
-							            const uint32_t usStackDepth,
-							            void * const pvParameters,
-							            UBaseType_t uxPriority,
-							            TaskHandle_t * const pxCreatedTask,
-							            const BaseType_t xCoreID);
 
-#define xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask ) xTaskCreatePinnedToCore( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), tskNO_AFFINITY )
+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
+
+	static inline IRAM_ATTR BaseType_t xTaskCreate(
+			TaskFunction_t pvTaskCode,
+			const char * const pcName,
+			const uint32_t usStackDepth,
+			void * const pvParameters,
+			UBaseType_t uxPriority,
+			TaskHandle_t * const pvCreatedTask)
+	{
+		return xTaskCreatePinnedToCore( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pvCreatedTask, tskNO_AFFINITY );
+	}
+
 #endif
 
-/**
- * task. h
- *
- TaskHandle_t xTaskCreateStatic( TaskFunction_t pvTaskCode,
-								 const char * const pcName,
-								 uint32_t ulStackDepth,
-								 void *pvParameters,
-								 UBaseType_t uxPriority,
-								 StackType_t *pxStackBuffer,
-								 StaticTask_t *pxTaskBuffer,
-                                 const BaseType_t xCoreID );

 
+
+
+/**
+ * Create a new task with a specified affinity.
  *
+ * This function is similar to xTaskCreateStatic, but allows specifying
+ * task affinity in an SMP system.
+ *
+ * @param pvTaskCode Pointer to the task entry function.  Tasks
+ * must be implemented to never return (i.e. continuous loop).
+ *
+ * @param pcName A descriptive name for the task.  This is mainly used to
+ * facilitate debugging.  The maximum length of the string is defined by
+ * configMAX_TASK_NAME_LEN in FreeRTOSConfig.h.
+ *
+ * @param ulStackDepth The size of the task stack specified as the number of
+ * variables the stack can hold - not the number of bytes.  For example, if
+ * the stack is 32-bits wide and ulStackDepth is defined as 100 then 400 bytes
+ * will be allocated for stack storage.
+ *
+ * @param pvParameters Pointer that will be used as the parameter for the task
+ * being created.
+ *
+ * @param uxPriority The priority at which the task will run.
+ *
+ * @param pxStackBuffer Must point to a StackType_t array that has at least
+ * ulStackDepth indexes - the array will then be used as the task's stack,
+ * removing the need for the stack to be allocated dynamically.
+ *
+ * @param pxTaskBuffer Must point to a variable of type StaticTask_t, which will
+ * then be used to hold the task's data structures, removing the need for the
+ * memory to be allocated dynamically.
+ *
+ * @param xCoreID If the value is tskNO_AFFINITY, the created task is not
+ * pinned to any CPU, and the scheduler can run it on any core available.
+ * Other values indicate the index number of the CPU which the task should
+ * be pinned to. Specifying values larger than (portNUM_PROCESSORS - 1) will
+ * cause the function to fail.
+ *
+ * @return If neither pxStackBuffer or pxTaskBuffer are NULL, then the task will
+ * be created and pdPASS is returned.  If either pxStackBuffer or pxTaskBuffer
+ * are NULL then the task will not be created and
+ * errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY is returned.
+ *
+ * \ingroup Tasks
+ */
+#if( configSUPPORT_STATIC_ALLOCATION == 1 )
+	TaskHandle_t xTaskCreateStaticPinnedToCore(	TaskFunction_t pvTaskCode,
+												const char * const pcName,
+												const uint32_t ulStackDepth,
+												void * const pvParameters,
+												UBaseType_t uxPriority,
+												StackType_t * const pxStackBuffer,
+												StaticTask_t * const pxTaskBuffer,
+												const BaseType_t xCoreID );
+#endif /* configSUPPORT_STATIC_ALLOCATION */
+
+/**
  * Create a new task and add it to the list of tasks that are ready to run.
  *
  * Internally, within the FreeRTOS implementation, tasks use two blocks of
@@ -442,77 +531,75 @@ is used in assert() statements. */
  * errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY is returned.
  *
  * Example usage:
-   
-
-    // Dimensions the buffer that the task being created will use as its stack.
-    // NOTE:  This is the number of words the stack will hold, not the number of
-    // bytes.  For example, if each stack item is 32-bits, and this is set to 100,
-    // then 400 bytes (100 * 32-bits) will be allocated.
-    #define STACK_SIZE 200
-
-    // Structure that will hold the TCB of the task being created.
-    StaticTask_t xTaskBuffer;
-
-    // Buffer that the task being created will use as its stack.  Note this is
-    // an array of StackType_t variables.  The size of StackType_t is dependent on
-    // the RTOS port.
-    StackType_t xStack[ STACK_SIZE ];
-
-    // Function that implements the task being created.
-    void vTaskCode( void * pvParameters )
-    {
-        // The parameter value is expected to be 1 as 1 is passed in the
-        // pvParameters value in the call to xTaskCreateStatic().
-        configASSERT( ( uint32_t ) pvParameters == 1UL );
-
-        for( ;; )
-        {
-            // Task code goes here.
-        }
-    }
-
-    // Function that creates a task.
-    void vOtherFunction( void )
-    {
-        TaskHandle_t xHandle = NULL;
-
-        // Create the task without using any dynamic memory allocation.
-        xHandle = xTaskCreateStatic(
-                      vTaskCode,       // Function that implements the task.
-                      "NAME",          // Text name for the task.
-                      STACK_SIZE,      // Stack size in words, not bytes.
-                      ( void * ) 1,    // Parameter passed into the task.
-                      tskIDLE_PRIORITY,// Priority at which the task is created.
-                      xStack,          // Array to use as the task's stack.
-                      &xTaskBuffer );  // Variable to hold the task's data structure.
-
-        // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
-        // been created, and xHandle will be the task's handle.  Use the handle
-        // to suspend the task.
-        vTaskSuspend( xHandle );
-    }
-   

- * \defgroup xTaskCreateStatic xTaskCreateStatic
+ * @code{c}
+ *
+ *     // Dimensions the buffer that the task being created will use as its stack.
+ *     // NOTE:  This is the number of words the stack will hold, not the number of
+ *     // bytes.  For example, if each stack item is 32-bits, and this is set to 100,
+ *     // then 400 bytes (100 * 32-bits) will be allocated.
+ *     #define STACK_SIZE 200
+ *
+ *     // Structure that will hold the TCB of the task being created.
+ *     StaticTask_t xTaskBuffer;
+ *
+ *     // Buffer that the task being created will use as its stack.  Note this is
+ *     // an array of StackType_t variables.  The size of StackType_t is dependent on
+ *     // the RTOS port.
+ *     StackType_t xStack[ STACK_SIZE ];
+ *
+ *     // Function that implements the task being created.
+ *     void vTaskCode( void * pvParameters )
+ *     {
+ *         // The parameter value is expected to be 1 as 1 is passed in the
+ *         // pvParameters value in the call to xTaskCreateStatic().
+ *         configASSERT( ( uint32_t ) pvParameters == 1UL );
+ *
+ *         for( ;; )
+ *         {
+ *             // Task code goes here.
+ *         }
+ *     }
+ *
+ *     // Function that creates a task.
+ *     void vOtherFunction( void )
+ *     {
+ *         TaskHandle_t xHandle = NULL;
+ *
+ *         // Create the task without using any dynamic memory allocation.
+ *         xHandle = xTaskCreateStatic(
+ *                       vTaskCode,       // Function that implements the task.
+ *                       "NAME",          // Text name for the task.
+ *                       STACK_SIZE,      // Stack size in words, not bytes.
+ *                       ( void * ) 1,    // Parameter passed into the task.
+ *                       tskIDLE_PRIORITY,// Priority at which the task is created.
+ *                       xStack,          // Array to use as the task's stack.
+ *                       &xTaskBuffer );  // Variable to hold the task's data structure.
+ *
+ *         // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
+ *         // been created, and xHandle will be the task's handle.  Use the handle
+ *         // to suspend the task.
+ *         vTaskSuspend( xHandle );
+ *     }
+ * @endcode
  * \ingroup Tasks
  */
-#if( configSUPPORT_STATIC_ALLOCATION == 1 )
-	TaskHandle_t xTaskCreateStaticPinnedToCore(	TaskFunction_t pxTaskCode,
-									            const char * const pcName,
-									            const uint32_t ulStackDepth,
-									            void * const pvParameters,
-									            UBaseType_t uxPriority,
-									            StackType_t * const puxStackBuffer,
-									            StaticTask_t * const pxTaskBuffer,
-                                                const BaseType_t xCoreID );
 
-#define xTaskCreateStatic( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxStackBuffer, pxTaskBuffer ) xTaskCreateStaticPinnedToCore( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxStackBuffer ), ( pxTaskBuffer ), tskNO_AFFINITY )
+#if( configSUPPORT_STATIC_ALLOCATION == 1 )
+	static inline IRAM_ATTR TaskHandle_t xTaskCreateStatic(
+			TaskFunction_t pvTaskCode,
+			const char * const pcName,
+			const uint32_t ulStackDepth,
+			void * const pvParameters,
+			UBaseType_t uxPriority,
+			StackType_t * const pxStackBuffer,
+			StaticTask_t * const pxTaskBuffer)
+	{
+		return xTaskCreateStaticPinnedToCore( pvTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, pxStackBuffer, pxTaskBuffer, tskNO_AFFINITY );
+	}
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
+/** @cond */
 /**
- * task. h
- *
- BaseType_t xTaskCreateRestricted( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );

- *
  * xTaskCreateRestricted() should only be used in systems that include an MPU
  * implementation.
  *
@@ -532,58 +619,54 @@ is used in assert() statements. */
  * list, otherwise an error code defined in the file projdefs.h
  *
  * Example usage:
-   
-// Create an TaskParameters_t structure that defines the task to be created.
-static const TaskParameters_t xCheckTaskParameters =
-{
-	vATask,		// pvTaskCode - the function that implements the task.
-	"ATask",	// pcName - just a text name for the task to assist debugging.
-	100,		// usStackDepth	- the stack size DEFINED IN WORDS.
-	NULL,		// pvParameters - passed into the task function as the function parameters.
-	( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
-	cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
-
-	// xRegions - Allocate up to three separate memory regions for access by
-	// the task, with appropriate access permissions.  Different processors have
-	// different memory alignment requirements - refer to the FreeRTOS documentation
-	// for full information.
-	{
-		// Base address					Length	Parameters
-        { cReadWriteArray,				32,		portMPU_REGION_READ_WRITE },
-        { cReadOnlyArray,				32,		portMPU_REGION_READ_ONLY },
-        { cPrivilegedOnlyAccessArray,	128,	portMPU_REGION_PRIVILEGED_READ_WRITE }
-	}
-};
-
-int main( void )
-{
-TaskHandle_t xHandle;
-
-	// Create a task from the const structure defined above.  The task handle
-	// is requested (the second parameter is not NULL) but in this case just for
-	// demonstration purposes as its not actually used.
-	xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
-
-	// Start the scheduler.
-	vTaskStartScheduler();
-
-	// Will only get here if there was insufficient memory to create the idle
-	// and/or timer task.
-	for( ;; );
-}
-   

- * \defgroup xTaskCreateRestricted xTaskCreateRestricted
+ * @code{c}
+ * // Create an TaskParameters_t structure that defines the task to be created.
+ * static const TaskParameters_t xCheckTaskParameters =
+ * {
+ * 	vATask,		// pvTaskCode - the function that implements the task.
+ * 	"ATask",	// pcName - just a text name for the task to assist debugging.
+ * 	100,		// usStackDepth	- the stack size DEFINED IN WORDS.
+ * 	NULL,		// pvParameters - passed into the task function as the function parameters.
+ * 	( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
+ * 	cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
+ *
+ * 	// xRegions - Allocate up to three separate memory regions for access by
+ * 	// the task, with appropriate access permissions.  Different processors have
+ * 	// different memory alignment requirements - refer to the FreeRTOS documentation
+ * 	// for full information.
+ * 	{
+ * 		// Base address					Length	Parameters
+ *         { cReadWriteArray,				32,		portMPU_REGION_READ_WRITE },
+ *         { cReadOnlyArray,				32,		portMPU_REGION_READ_ONLY },
+ *         { cPrivilegedOnlyAccessArray,	128,	portMPU_REGION_PRIVILEGED_READ_WRITE }
+ * 	}
+ * };
+ *
+ * int main( void )
+ * {
+ * TaskHandle_t xHandle;
+ *
+ * 	// Create a task from the const structure defined above.  The task handle
+ * 	// is requested (the second parameter is not NULL) but in this case just for
+ * 	// demonstration purposes as its not actually used.
+ * 	xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
+ *
+ * 	// Start the scheduler.
+ * 	vTaskStartScheduler();
+ *
+ * 	// Will only get here if there was insufficient memory to create the idle
+ * 	// and/or timer task.
+ * 	for( ;; );
+ * }
+ * @endcode
  * \ingroup Tasks
  */
 #if( portUSING_MPU_WRAPPERS == 1 )
 	BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask ) PRIVILEGED_FUNCTION;
 #endif
 
+
 /**
- * task. h
- *
- void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions );

- *
  * Memory regions are assigned to a restricted task when the task is created by
  * a call to xTaskCreateRestricted().  These regions can be redefined using
  * vTaskAllocateMPURegions().
@@ -594,50 +677,51 @@ TaskHandle_t xHandle;
  * new memory region definitions.
  *
  * Example usage:
-   
-// Define an array of MemoryRegion_t structures that configures an MPU region
-// allowing read/write access for 1024 bytes starting at the beginning of the
-// ucOneKByte array.  The other two of the maximum 3 definable regions are
-// unused so set to zero.
-static const MemoryRegion_t xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =
-{
-	// Base address		Length		Parameters
-	{ ucOneKByte,		1024,		portMPU_REGION_READ_WRITE },
-	{ 0,				0,			0 },
-	{ 0,				0,			0 }
-};
-
-void vATask( void *pvParameters )
-{
-	// This task was created such that it has access to certain regions of
-	// memory as defined by the MPU configuration.  At some point it is
-	// desired that these MPU regions are replaced with that defined in the
-	// xAltRegions const struct above.  Use a call to vTaskAllocateMPURegions()
-	// for this purpose.  NULL is used as the task handle to indicate that this
-	// function should modify the MPU regions of the calling task.
-	vTaskAllocateMPURegions( NULL, xAltRegions );
-
-	// Now the task can continue its function, but from this point on can only
-	// access its stack and the ucOneKByte array (unless any other statically
-	// defined or shared regions have been declared elsewhere).
-}
-   

- * \defgroup xTaskCreateRestricted xTaskCreateRestricted
+ *
+ * @code{c}
+ * // Define an array of MemoryRegion_t structures that configures an MPU region
+ * // allowing read/write access for 1024 bytes starting at the beginning of the
+ * // ucOneKByte array.  The other two of the maximum 3 definable regions are
+ * // unused so set to zero.
+ * static const MemoryRegion_t xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =
+ * {
+ * 	// Base address		Length		Parameters
+ * 	{ ucOneKByte,		1024,		portMPU_REGION_READ_WRITE },
+ * 	{ 0,				0,			0 },
+ * 	{ 0,				0,			0 }
+ * };
+ *
+ * void vATask( void *pvParameters )
+ * {
+ * 	// This task was created such that it has access to certain regions of
+ * 	// memory as defined by the MPU configuration.  At some point it is
+ * 	// desired that these MPU regions are replaced with that defined in the
+ * 	// xAltRegions const struct above.  Use a call to vTaskAllocateMPURegions()
+ * 	// for this purpose.  NULL is used as the task handle to indicate that this
+ * 	// function should modify the MPU regions of the calling task.
+ * 	vTaskAllocateMPURegions( NULL, xAltRegions );
+ *
+ * 	// Now the task can continue its function, but from this point on can only
+ * 	// access its stack and the ucOneKByte array (unless any other statically
+ * 	// defined or shared regions have been declared elsewhere).
+ * }
+ * @endcode
  * \ingroup Tasks
  */
 void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions ) PRIVILEGED_FUNCTION;
 
+/** @endcond */
+
 /**
- * task. h
- * 
void vTaskDelete( TaskHandle_t xTask );

+ * Remove a task from the RTOS real time kernel's management.
+ *
+ * The task being deleted will be removed from all ready, blocked, suspended
+ * and event lists.
  *
  * INCLUDE_vTaskDelete must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- * Remove a task from the RTOS real time kernel's management.  The task being
- * deleted will be removed from all ready, blocked, suspended and event lists.
- *
- * NOTE:  The idle task is responsible for freeing the kernel allocated
+ * @note The idle task is responsible for freeing the kernel allocated
  * memory from tasks that have been deleted.  It is therefore important that
  * the idle task is not starved of microcontroller processing time if your
  * application makes any calls to vTaskDelete ().  Memory allocated by the
@@ -647,23 +731,22 @@ void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const p
  * See the demo application file death.c for sample code that utilises
  * vTaskDelete ().
  *
- * @param xTask The handle of the task to be deleted.  Passing NULL will
+ * @param xTaskToDelete The handle of the task to be deleted.  Passing NULL will
  * cause the calling task to be deleted.
  *
  * Example usage:
-   
- void vOtherFunction( void )
- {
- TaskHandle_t xHandle;
-
-	 // Create the task, storing the handle.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
-
-	 // Use the handle to delete the task.
-	 vTaskDelete( xHandle );
- }
-   

- * \defgroup vTaskDelete vTaskDelete
+ * @code{c}
+ *  void vOtherFunction( void )
+ *  {
+ *  TaskHandle_t xHandle;
+ *
+ * 	 // Create the task, storing the handle.
+ * 	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+ *
+ * 	 // Use the handle to delete the task.
+ * 	 vTaskDelete( xHandle );
+ *  }
+ * @endcode
  * \ingroup Tasks
  */
 void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
@@ -673,18 +756,15 @@ void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
  *----------------------------------------------------------*/
 
 /**
- * task. h
- * 
void vTaskDelay( const TickType_t xTicksToDelay );

+ * Delay a task for a given number of ticks.
  *
- * Delay a task for a given number of ticks.  The actual time that the
- * task remains blocked depends on the tick rate.  The constant
- * portTICK_PERIOD_MS can be used to calculate real time from the tick
- * rate - with the resolution of one tick period.
+ * The actual time that the task remains blocked depends on the tick rate.
+ * The constant portTICK_PERIOD_MS can be used to calculate real time from
+ * the tick rate - with the resolution of one tick period.
  *
  * INCLUDE_vTaskDelay must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- *
  * vTaskDelay() specifies a time at which the task wishes to unblock relative to
  * the time at which vTaskDelay() is called.  For example, specifying a block
  * period of 100 ticks will cause the task to unblock 100 ticks after
@@ -701,34 +781,31 @@ void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
  * the calling task should block.
  *
  * Example usage:
-
- void vTaskFunction( void * pvParameters )
- {
- // Block for 500ms.
- const TickType_t xDelay = 500 / portTICK_PERIOD_MS;
-
-	 for( ;; )
-	 {
-		 // Simply toggle the LED every 500ms, blocking between each toggle.
-		 vToggleLED();
-		 vTaskDelay( xDelay );
-	 }
- }
-
- * \defgroup vTaskDelay vTaskDelay
+ * @code{c}
+ *  void vTaskFunction( void * pvParameters )
+ *  {
+ *  // Block for 500ms.
+ *  const TickType_t xDelay = 500 / portTICK_PERIOD_MS;
+ *
+ * 	 for( ;; )
+ * 	 {
+ * 		 // Simply toggle the LED every 500ms, blocking between each toggle.
+ * 		 vToggleLED();
+ * 		 vTaskDelay( xDelay );
+ * 	 }
+ *  }
+ * @endcode
  * \ingroup TaskCtrl
  */
 void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
void vTaskDelayUntil( TickType_t *pxPreviousWakeTime, const TickType_t xTimeIncrement );

+ * Delay a task until a specified time.
  *
  * INCLUDE_vTaskDelayUntil must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- * Delay a task until a specified time.  This function can be used by periodic
- * tasks to ensure a constant execution frequency.
+ * This function can be used by periodic tasks to ensure a constant execution frequency.
  *
  * This function differs from vTaskDelay () in one important aspect:  vTaskDelay () will
  * cause a task to block for the specified number of ticks from the time vTaskDelay () is
@@ -756,94 +833,90 @@ void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
  * a fixed interface period.
  *
  * Example usage:
-   
- // Perform an action every 10 ticks.
- void vTaskFunction( void * pvParameters )
- {
- TickType_t xLastWakeTime;
- const TickType_t xFrequency = 10;
-
-	 // Initialise the xLastWakeTime variable with the current time.
-	 xLastWakeTime = xTaskGetTickCount ();
-	 for( ;; )
-	 {
-		 // Wait for the next cycle.
-		 vTaskDelayUntil( &xLastWakeTime, xFrequency );
-
-		 // Perform action here.
-	 }
- }
-   

- * \defgroup vTaskDelayUntil vTaskDelayUntil
+ * @code{c}
+ *  // Perform an action every 10 ticks.
+ *  void vTaskFunction( void * pvParameters )
+ *  {
+ *  TickType_t xLastWakeTime;
+ *  const TickType_t xFrequency = 10;
+ *
+ * 	 // Initialise the xLastWakeTime variable with the current time.
+ * 	 xLastWakeTime = xTaskGetTickCount ();
+ * 	 for( ;; )
+ * 	 {
+ * 		 // Wait for the next cycle.
+ * 		 vTaskDelayUntil( &xLastWakeTime, xFrequency );
+ *
+ * 		 // Perform action here.
+ * 	 }
+ *  }
+ * @endcode
  * \ingroup TaskCtrl
  */
 void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask );

+ * Obtain the priority of any task.
  *
  * INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- * Obtain the priority of any task.
- *
  * @param xTask Handle of the task to be queried.  Passing a NULL
  * handle results in the priority of the calling task being returned.
  *
  * @return The priority of xTask.
  *
  * Example usage:
-   
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-	 // Create a task, storing the handle.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
-
-	 // ...
-
-	 // Use the handle to obtain the priority of the created task.
-	 // It was created with tskIDLE_PRIORITY, but may have changed
-	 // it itself.
-	 if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
-	 {
-		 // The task has changed it's priority.
-	 }
-
-	 // ...
-
-	 // Is our priority higher than the created task?
-	 if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
-	 {
-		 // Our priority (obtained using NULL handle) is higher.
-	 }
- }
-   

- * \defgroup uxTaskPriorityGet uxTaskPriorityGet
+ * @code{c}
+ *  void vAFunction( void )
+ *  {
+ *  TaskHandle_t xHandle;
+ *
+ *   // Create a task, storing the handle.
+ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+ *
+ *   // ...
+ *
+ *   // Use the handle to obtain the priority of the created task.
+ *   // It was created with tskIDLE_PRIORITY, but may have changed
+ *   // it itself.
+ *   if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
+ *   {
+ *       // The task has changed it's priority.
+ *   }
+ *
+ *   // ...
+ *
+ *   // Is our priority higher than the created task?
+ *   if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
+ *   {
+ *       // Our priority (obtained using NULL handle) is higher.
+ *   }
+ * }
+ * @endcode
  * \ingroup TaskCtrl
  */
 UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask );

- *
  * A version of uxTaskPriorityGet() that can be used from an ISR.
+ *
+ * @param xTask Handle of the task to be queried.  Passing a NULL
+ * handle results in the priority of the calling task being returned.
+ *
+ * @return The priority of xTask.
+ *
  */
 UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
eTaskState eTaskGetState( TaskHandle_t xTask );

+ * Obtain the state of any task.
+ *
+ * States are encoded by the eTaskState enumerated type.
  *
  * INCLUDE_eTaskGetState must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- * Obtain the state of any task.  States are encoded by the eTaskState
- * enumerated type.
- *
  * @param xTask Handle of the task to be queried.
  *
  * @return The state of xTask at the time the function was called.  Note the
@@ -853,14 +926,11 @@ UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );

+ * Set the priority of any task.
  *
  * INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- * Set the priority of any task.
- *
  * A context switch will occur before the function returns if the priority
  * being set is higher than the currently executing task.
  *
@@ -870,39 +940,37 @@ eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
  * @param uxNewPriority The priority to which the task will be set.
  *
  * Example usage:
-   
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-	 // Create a task, storing the handle.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
-
-	 // ...
-
-	 // Use the handle to raise the priority of the created task.
-	 vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
-
-	 // ...
-
-	 // Use a NULL handle to raise our priority to the same value.
-	 vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
- }
-   

- * \defgroup vTaskPrioritySet vTaskPrioritySet
+ * @code{c}
+ *  void vAFunction( void )
+ *  {
+ *  TaskHandle_t xHandle;
+ *
+ *   // Create a task, storing the handle.
+ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+ *
+ *   // ...
+ *
+ *   // Use the handle to raise the priority of the created task.
+ *   vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
+ *
+ *   // ...
+ *
+ *   // Use a NULL handle to raise our priority to the same value.
+ *   vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
+ *  }
+ * @endcode
  * \ingroup TaskCtrl
  */
 void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
void vTaskSuspend( TaskHandle_t xTaskToSuspend );

+ * Suspend a task.
  *
  * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- * Suspend any task.  When suspended a task will never get any microcontroller
- * processing time, no matter what its priority.
+ * When suspended, a task will never get any microcontroller processing time,
+ * no matter what its priority.
  *
  * Calls to vTaskSuspend are not accumulative -
  * i.e. calling vTaskSuspend () twice on the same task still only requires one
@@ -912,48 +980,44 @@ void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority ) PRIVILEGE
  * handle will cause the calling task to be suspended.
  *
  * Example usage:
-   
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-	 // Create a task, storing the handle.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
-
-	 // ...
-
-	 // Use the handle to suspend the created task.
-	 vTaskSuspend( xHandle );
-
-	 // ...
-
-	 // The created task will not run during this period, unless
-	 // another task calls vTaskResume( xHandle ).
-
-	 //...
-
-
-	 // Suspend ourselves.
-	 vTaskSuspend( NULL );
-
-	 // We cannot get here unless another task calls vTaskResume
-	 // with our handle as the parameter.
- }
-   

- * \defgroup vTaskSuspend vTaskSuspend
+ * @code{c}
+ *  void vAFunction( void )
+ *  {
+ *  TaskHandle_t xHandle;
+ *
+ *   // Create a task, storing the handle.
+ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+ *
+ *   // ...
+ *
+ *   // Use the handle to suspend the created task.
+ *   vTaskSuspend( xHandle );
+ *
+ *   // ...
+ *
+ *   // The created task will not run during this period, unless
+ *   // another task calls vTaskResume( xHandle ).
+ *
+ *   //...
+ *
+ *
+ *   // Suspend ourselves.
+ *   vTaskSuspend( NULL );
+ *
+ *   // We cannot get here unless another task calls vTaskResume
+ *   // with our handle as the parameter.
+ *  }
+ * @endcode
  * \ingroup TaskCtrl
  */
 void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
void vTaskResume( TaskHandle_t xTaskToResume );

+ * Resumes a suspended task.
  *
  * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
  * See the configuration section for more information.
  *
- * Resumes a suspended task.
- *
  * A task that has been suspended by one or more calls to vTaskSuspend ()
  * will be made available for running again by a single call to
  * vTaskResume ().
@@ -961,48 +1025,44 @@ void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
  * @param xTaskToResume Handle to the task being readied.
  *
  * Example usage:
-   
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-	 // Create a task, storing the handle.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
-
-	 // ...
-
-	 // Use the handle to suspend the created task.
-	 vTaskSuspend( xHandle );
-
-	 // ...
-
-	 // The created task will not run during this period, unless
-	 // another task calls vTaskResume( xHandle ).
-
-	 //...
-
-
-	 // Resume the suspended task ourselves.
-	 vTaskResume( xHandle );
-
-	 // The created task will once again get microcontroller processing
-	 // time in accordance with its priority within the system.
- }
-   

- * \defgroup vTaskResume vTaskResume
+ * @code{c}
+ *  void vAFunction( void )
+ *  {
+ *  TaskHandle_t xHandle;
+ *
+ *   // Create a task, storing the handle.
+ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
+ *
+ *   // ...
+ *
+ *   // Use the handle to suspend the created task.
+ *   vTaskSuspend( xHandle );
+ *
+ *   // ...
+ *
+ *   // The created task will not run during this period, unless
+ *   // another task calls vTaskResume( xHandle ).
+ *
+ *   //...
+ *
+ *
+ *   // Resume the suspended task ourselves.
+ *   vTaskResume( xHandle );
+ *
+ *   // The created task will once again get microcontroller processing
+ *   // time in accordance with its priority within the system.
+ *  }
+ * @endcode
  * \ingroup TaskCtrl
  */
 void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
void xTaskResumeFromISR( TaskHandle_t xTaskToResume );

+ * An implementation of vTaskResume() that can be called from within an ISR.
  *
  * INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be
  * available.  See the configuration section for more information.
  *
- * An implementation of vTaskResume() that can be called from within an ISR.
- *
  * A task that has been suspended by one or more calls to vTaskSuspend ()
  * will be made available for running again by a single call to
  * xTaskResumeFromISR ().
@@ -1018,7 +1078,6 @@ void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
  * otherwise pdFALSE. This is used by the ISR to determine if a context switch
  * may be required following the ISR.
  *
- * \defgroup vTaskResumeFromISR vTaskResumeFromISR
  * \ingroup TaskCtrl
  */
 BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
@@ -1026,46 +1085,42 @@ BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
 /*-----------------------------------------------------------
  * SCHEDULER CONTROL
  *----------------------------------------------------------*/
-
+/** @cond */
 /**
- * task. h
- * 
void vTaskStartScheduler( void );

+ * Starts the real time kernel tick processing.
  *
- * Starts the real time kernel tick processing.  After calling the kernel
- * has control over which tasks are executed and when.
+ * After calling the kernel has control over which tasks are executed and when.
  *
  * See the demo application file main.c for an example of creating
  * tasks and starting the kernel.
  *
  * Example usage:
-   
- void vAFunction( void )
- {
-	 // Create at least one task before starting the kernel.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
-
-	 // Start the real time kernel with preemption.
-	 vTaskStartScheduler ();
-
-	 // Will not get here unless a task calls vTaskEndScheduler ()
- }
-   

+ * @code{c}
+ *  void vAFunction( void )
+ *  {
+ *   // Create at least one task before starting the kernel.
+ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
+ *
+ *   // Start the real time kernel with preemption.
+ *   vTaskStartScheduler ();
+ *
+ *   // Will not get here unless a task calls vTaskEndScheduler ()
+ *  }
+ * @endcode
  *
- * \defgroup vTaskStartScheduler vTaskStartScheduler
  * \ingroup SchedulerControl
  */
 void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
void vTaskEndScheduler( void );

+ * Stops the real time kernel tick.
  *
- * NOTE:  At the time of writing only the x86 real mode port, which runs on a PC
+ * @note At the time of writing only the x86 real mode port, which runs on a PC
  * in place of DOS, implements this function.
  *
- * Stops the real time kernel tick.  All created tasks will be automatically
- * deleted and multitasking (either preemptive or cooperative) will
- * stop.  Execution then resumes from the point where vTaskStartScheduler ()
+ * All created tasks will be automatically deleted and multitasking
+ * (either preemptive or cooperative) will stop.
+ * Execution then resumes from the point where vTaskStartScheduler ()
  * was called, as if vTaskStartScheduler () had just returned.
  *
  * See the demo application file main. c in the demo/PC directory for an
@@ -1080,44 +1135,42 @@ void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
  * tasks.
  *
  * Example usage:
-   
- void vTaskCode( void * pvParameters )
- {
-	 for( ;; )
-	 {
-		 // Task code goes here.
-
-		 // At some point we want to end the real time kernel processing
-		 // so call ...
-		 vTaskEndScheduler ();
-	 }
- }
-
- void vAFunction( void )
- {
-	 // Create at least one task before starting the kernel.
-	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
-
-	 // Start the real time kernel with preemption.
-	 vTaskStartScheduler ();
-
-	 // Will only get here when the vTaskCode () task has called
-	 // vTaskEndScheduler ().  When we get here we are back to single task
-	 // execution.
- }
-   

+ * @code{c}
+ *  void vTaskCode( void * pvParameters )
+ *  {
+ *   for( ;; )
+ *   {
+ *       // Task code goes here.
  *
- * \defgroup vTaskEndScheduler vTaskEndScheduler
+ *       // At some point we want to end the real time kernel processing
+ *       // so call ...
+ *       vTaskEndScheduler ();
+ *   }
+ *  }
+ *
+ *  void vAFunction( void )
+ *  {
+ *   // Create at least one task before starting the kernel.
+ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
+ *
+ *   // Start the real time kernel with preemption.
+ *   vTaskStartScheduler ();
+ *
+ *   // Will only get here when the vTaskCode () task has called
+ *   // vTaskEndScheduler ().  When we get here we are back to single task
+ *   // execution.
+ *  }
+ * @endcode
  * \ingroup SchedulerControl
  */
 void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
 
+/** @endcond */
+
 /**
- * task. h
- * 
void vTaskSuspendAll( void );

+ * Suspends the scheduler without disabling interrupts.
  *
- * Suspends the scheduler without disabling interrupts.  Context switches will
- * not occur while the scheduler is suspended.
+ * Context switches will not occur while the scheduler is suspended.
  *
  * After calling vTaskSuspendAll () the calling task will continue to execute
  * without risk of being swapped out until a call to xTaskResumeAll () has been
@@ -1128,45 +1181,41 @@ void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
  * is suspended.
  *
  * Example usage:
-   
- void vTask1( void * pvParameters )
- {
-	 for( ;; )
-	 {
-		 // Task code goes here.
-
-		 // ...
-
-		 // At some point the task wants to perform a long operation during
-		 // which it does not want to get swapped out.  It cannot use
-		 // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
-		 // operation may cause interrupts to be missed - including the
-		 // ticks.
-
-		 // Prevent the real time kernel swapping out the task.
-		 vTaskSuspendAll ();
-
-		 // Perform the operation here.  There is no need to use critical
-		 // sections as we have all the microcontroller processing time.
-		 // During this time interrupts will still operate and the kernel
-		 // tick count will be maintained.
-
-		 // ...
-
-		 // The operation is complete.  Restart the kernel.
-		 xTaskResumeAll ();
-	 }
- }
-   

- * \defgroup vTaskSuspendAll vTaskSuspendAll
+ * @code{c}
+ *  void vTask1( void * pvParameters )
+ *  {
+ *   for( ;; )
+ *   {
+ *       // Task code goes here.
+ *
+ *       // ...
+ *
+ *       // At some point the task wants to perform a long operation during
+ *       // which it does not want to get swapped out.  It cannot use
+ *       // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
+ *       // operation may cause interrupts to be missed - including the
+ *       // ticks.
+ *
+ *       // Prevent the real time kernel swapping out the task.
+ *       vTaskSuspendAll ();
+ *
+ *       // Perform the operation here.  There is no need to use critical
+ *       // sections as we have all the microcontroller processing time.
+ *       // During this time interrupts will still operate and the kernel
+ *       // tick count will be maintained.
+ *
+ *       // ...
+ *
+ *       // The operation is complete.  Restart the kernel.
+ *       xTaskResumeAll ();
+ *   }
+ *  }
+ * @endcode
  * \ingroup SchedulerControl
  */
 void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
BaseType_t xTaskResumeAll( void );

- *
  * Resumes scheduler activity after it was suspended by a call to
  * vTaskSuspendAll().
  *
@@ -1177,42 +1226,41 @@ void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
  *		  returned, otherwise pdFALSE is returned.
  *
  * Example usage:
-   
- void vTask1( void * pvParameters )
- {
-	 for( ;; )
-	 {
-		 // Task code goes here.
-
-		 // ...
-
-		 // At some point the task wants to perform a long operation during
-		 // which it does not want to get swapped out.  It cannot use
-		 // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
-		 // operation may cause interrupts to be missed - including the
-		 // ticks.
-
-		 // Prevent the real time kernel swapping out the task.
-		 vTaskSuspendAll ();
-
-		 // Perform the operation here.  There is no need to use critical
-		 // sections as we have all the microcontroller processing time.
-		 // During this time interrupts will still operate and the real
-		 // time kernel tick count will be maintained.
-
-		 // ...
-
-		 // The operation is complete.  Restart the kernel.  We want to force
-		 // a context switch - but there is no point if resuming the scheduler
-		 // caused a context switch already.
-		 if( !xTaskResumeAll () )
-		 {
-			  taskYIELD ();
-		 }
-	 }
- }
-   

- * \defgroup xTaskResumeAll xTaskResumeAll
+ * @code{c}
+ *  void vTask1( void * pvParameters )
+ *  {
+ *   for( ;; )
+ *   {
+ *       // Task code goes here.
+ *
+ *       // ...
+ *
+ *       // At some point the task wants to perform a long operation during
+ *       // which it does not want to get swapped out.  It cannot use
+ *       // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
+ *       // operation may cause interrupts to be missed - including the
+ *       // ticks.
+ *
+ *       // Prevent the real time kernel swapping out the task.
+ *       vTaskSuspendAll ();
+ *
+ *       // Perform the operation here.  There is no need to use critical
+ *       // sections as we have all the microcontroller processing time.
+ *       // During this time interrupts will still operate and the real
+ *       // time kernel tick count will be maintained.
+ *
+ *       // ...
+ *
+ *       // The operation is complete.  Restart the kernel.  We want to force
+ *       // a context switch - but there is no point if resuming the scheduler
+ *       // caused a context switch already.
+ *       if( !xTaskResumeAll () )
+ *       {
+ *            taskYIELD ();
+ *       }
+ *   }
+ *  }
+ * @endcode
  * \ingroup SchedulerControl
  */
 BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
@@ -1222,19 +1270,16 @@ BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
  *----------------------------------------------------------*/
 
 /**
- * task. h
- * 
TickType_t xTaskGetTickCount( void );

+ * Get tick count
  *
  * @return The count of ticks since vTaskStartScheduler was called.
  *
- * \defgroup xTaskGetTickCount xTaskGetTickCount
  * \ingroup TaskUtils
  */
 TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
TickType_t xTaskGetTickCountFromISR( void );

+ * Get tick count from ISR
  *
  * @return The count of ticks since vTaskStartScheduler was called.
  *
@@ -1243,50 +1288,43 @@ TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
  * microcontroller being used or interrupt nesting is either not supported or
  * not being used.
  *
- * \defgroup xTaskGetTickCountFromISR xTaskGetTickCountFromISR
  * \ingroup TaskUtils
  */
 TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
UBaseType_t uxTaskGetNumberOfTasks( void );

+ * Get current number of tasks
  *
  * @return The number of tasks that the real time kernel is currently managing.
  * This includes all ready, blocked and suspended tasks.  A task that
  * has been deleted but not yet freed by the idle task will also be
  * included in the count.
  *
- * \defgroup uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks
  * \ingroup TaskUtils
  */
 UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
 
 /**
- * task. h
- * 
char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery );

+ * Get task name
  *
  * @return The text (human readable) name of the task referenced by the handle
  * xTaskToQuery.  A task can query its own name by either passing in its own
  * handle, or by setting xTaskToQuery to NULL.  INCLUDE_pcTaskGetTaskName must be
  * set to 1 in FreeRTOSConfig.h for pcTaskGetTaskName() to be available.
  *
- * \defgroup pcTaskGetTaskName pcTaskGetTaskName
  * \ingroup TaskUtils
  */
 char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 
 /**
- * task.h
- * 
UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );

+ * Returns the high water mark of the stack associated with xTask.
  *
  * INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for
  * this function to be available.
  *
- * Returns the high water mark of the stack associated with xTask.  That is,
- * the minimum free stack space there has been (in words, so on a 32 bit machine
- * a value of 1 means 4 bytes) since the task started.  The smaller the returned
- * number the closer the task has come to overflowing its stack.
+ * High water mark is the minimum free stack space there has been (in words,
+ * so on a 32 bit machine a value of 1 means 4 bytes) since the task started.
+ * The smaller the returned number the closer the task has come to overflowing its stack.
  *
  * @param xTask Handle of the task associated with the stack to be checked.
  * Set xTask to NULL to check the stack of the calling task.
@@ -1298,14 +1336,12 @@ char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint
 UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
 /**
- * task.h
- * 
uint8_t* pxTaskGetStackStart( TaskHandle_t xTask);

+ * Returns the start of the stack associated with xTask.
  *
  * INCLUDE_pxTaskGetStackStart must be set to 1 in FreeRTOSConfig.h for
  * this function to be available.
  *
- * Returns the start of the stack associated with xTask.  That is,
- * the highest stack memory address on architectures where the stack grows down
+ * Returns the highest stack memory address on architectures where the stack grows down
  * from high memory, and the lowest memory address on architectures where the
  * stack grows up from low memory.
  *
@@ -1325,73 +1361,130 @@ constant. */
 #ifdef configUSE_APPLICATION_TASK_TAG
 	#if configUSE_APPLICATION_TASK_TAG == 1
 		/**
-		 * task.h
-		 * 
void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction );

-		 *
 		 * Sets pxHookFunction to be the task hook function used by the task xTask.
-		 * Passing xTask as NULL has the effect of setting the calling tasks hook
-		 * function.
+		 * @param xTask Handle of the task to set the hook function for
+		 *              Passing xTask as NULL has the effect of setting the calling
+		 *              tasks hook function.
+		 * @param pxHookFunction  Pointer to the hook function.
 		 */
 		void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction ) PRIVILEGED_FUNCTION;
 
 		/**
-		 * task.h
-		 * 
void xTaskGetApplicationTaskTag( TaskHandle_t xTask );

-		 *
-		 * Returns the pxHookFunction value assigned to the task xTask.
+		 * Get the hook function assigned to given task.
+		 * @param xTask Handle of the task to get the hook function for
+		 *              Passing xTask as NULL has the effect of getting the calling
+		 *              tasks hook function.
+		 * @return The pxHookFunction value assigned to the task xTask.
 		 */
 		TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 	#endif /* configUSE_APPLICATION_TASK_TAG ==1 */
 #endif /* ifdef configUSE_APPLICATION_TASK_TAG */
 #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
 
-	/* Each task contains an array of pointers that is dimensioned by the
-	configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h.  The
-	kernel does not use the pointers itself, so the application writer can use
-	the pointers for any purpose they wish.  The following two functions are
-	used to set and query a pointer respectively. */
+	/**
+	 * Set local storage pointer specific to the given task.
+	 *
+	 * Each task contains an array of pointers that is dimensioned by the
+	 * configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h.
+	 * The kernel does not use the pointers itself, so the application writer
+	 * can use the pointers for any purpose they wish.
+	 *
+	 * @param xTaskToSet  Task to set thread local storage pointer for
+	 * @param xIndex The index of the pointer to set, from 0 to
+	 *               configNUM_THREAD_LOCAL_STORAGE_POINTERS - 1.
+	 * @param pvValue  Pointer value to set.
+	 */
 	void vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue ) PRIVILEGED_FUNCTION;
+
+
+	/**
+	 * Get local storage pointer specific to the given task.
+	 *
+	 * Each task contains an array of pointers that is dimensioned by the
+	 * configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h.
+	 * The kernel does not use the pointers itself, so the application writer
+	 * can use the pointers for any purpose they wish.
+	 *
+	 * @param xTaskToQuery  Task to get thread local storage pointer for
+	 * @param xIndex The index of the pointer to get, from 0 to
+	 *               configNUM_THREAD_LOCAL_STORAGE_POINTERS - 1.
+	 * @return  Pointer value
+	 */
 	void *pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex ) PRIVILEGED_FUNCTION;
 
-	#if ( configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS ) 
-		typedef void (*TlsDeleteCallbackFunction_t)( int, void * ); 
-		void vTaskSetThreadLocalStoragePointerAndDelCallback( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue , TlsDeleteCallbackFunction_t xDelCallback);
+	#if ( configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS )
+
+		/**
+		 * Prototype of local storage pointer deletion callback.
+		 */
+		typedef void (*TlsDeleteCallbackFunction_t)( int, void * );
+
+		/**
+		 * Set local storage pointer and deletion callback.
+		 *
+		 * Each task contains an array of pointers that is dimensioned by the
+		 * configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h.
+		 * The kernel does not use the pointers itself, so the application writer
+		 * can use the pointers for any purpose they wish.
+		 *
+		 * Local storage pointers set for a task can reference dynamically
+		 * allocated resources. This function is similar to
+		 * vTaskSetThreadLocalStoragePointer, but provides a way to release
+		 * these resources when the task gets deleted. For each pointer,
+		 * a callback function can be set. This function will be called
+		 * when task is deleted, with the local storage pointer index
+		 * and value as arguments.
+		 *
+		 * @param xTaskToSet  Task to set thread local storage pointer for
+		 * @param xIndex The index of the pointer to set, from 0 to
+		 *               configNUM_THREAD_LOCAL_STORAGE_POINTERS - 1.
+		 * @param pvValue  Pointer value to set.
+		 * @param pvDelCallback  Function to call to dispose of the local
+		 *                       storage pointer when the task is deleted.
+		 */
+		void vTaskSetThreadLocalStoragePointerAndDelCallback( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue, TlsDeleteCallbackFunction_t pvDelCallback);
 	#endif
 
 #endif
 
 /**
- * task.h
- * 
BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter );

- *
- * Calls the hook function associated with xTask.  Passing xTask as NULL has
+ * Calls the hook function associated with xTask. Passing xTask as NULL has
  * the effect of calling the Running tasks (the calling task) hook function.
  *
- * pvParameter is passed to the hook function for the task to interpret as it
+ * @param xTask  Handle of the task to call the hook for.
+ * @param pvParameter  Parameter passed to the hook function for the task to interpret as it
  * wants.  The return value is the value returned by the task hook function
  * registered by the user.
  */
 BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter ) PRIVILEGED_FUNCTION;
 
 /**
+ * Get the handle of idle task for the current CPU.
+ *
  * xTaskGetIdleTaskHandle() is only available if
  * INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSConfig.h.
  *
- * Simply returns the handle of the idle task.  It is not valid to call
+ * @return The handle of the idle task.  It is not valid to call
  * xTaskGetIdleTaskHandle() before the scheduler has been started.
  */
 TaskHandle_t xTaskGetIdleTaskHandle( void );
 
 /**
+ * Get the handle of idle task for the given CPU.
+ *
  * xTaskGetIdleTaskHandleForCPU() is only available if
  * INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSConfig.h.
  *
- * Simply returns the idle task handle of a given cpu. It is not valid to call
+ * @param cpuid The CPU to get the handle for
+ *
+ * @return Idle task handle of a given cpu. It is not valid to call
  * xTaskGetIdleTaskHandleForCPU() before the scheduler has been started.
  */
 TaskHandle_t xTaskGetIdleTaskHandleForCPU( UBaseType_t cpuid );
 
 /**
+ * Get the state of tasks in the system.
+ *
  * configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for
  * uxTaskGetSystemState() to be available.
  *
@@ -1401,7 +1494,7 @@ TaskHandle_t xTaskGetIdleTaskHandleForCPU( UBaseType_t cpuid );
  * of run time consumed by the task.  See the TaskStatus_t structure
  * definition in this file for the full member list.
  *
- * NOTE:  This function is intended for debugging use only as its use results in
+ * @note  This function is intended for debugging use only as its use results in
  * the scheduler remaining suspended for an extended period.
  *
  * @param pxTaskStatusArray A pointer to an array of TaskStatus_t structures.
@@ -1426,79 +1519,78 @@ TaskHandle_t xTaskGetIdleTaskHandleForCPU( UBaseType_t cpuid );
  * in the uxArraySize parameter was too small.
  *
  * Example usage:
-   
-    // This example demonstrates how a human readable table of run time stats
-	// information is generated from raw data provided by uxTaskGetSystemState().
-	// The human readable table is written to pcWriteBuffer
-	void vTaskGetRunTimeStats( char *pcWriteBuffer )
-	{
-	TaskStatus_t *pxTaskStatusArray;
-	volatile UBaseType_t uxArraySize, x;
-	uint32_t ulTotalRunTime, ulStatsAsPercentage;
-
-		// Make sure the write buffer does not contain a string.
-		*pcWriteBuffer = 0x00;
-
-		// Take a snapshot of the number of tasks in case it changes while this
-		// function is executing.
-		uxArraySize = uxTaskGetNumberOfTasks();
-
-		// Allocate a TaskStatus_t structure for each task.  An array could be
-		// allocated statically at compile time.
-		pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );
-
-		if( pxTaskStatusArray != NULL )
-		{
-			// Generate raw status information about each task.
-			uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, &ulTotalRunTime );
-
-			// For percentage calculations.
-			ulTotalRunTime /= 100UL;
-
-			// Avoid divide by zero errors.
-			if( ulTotalRunTime > 0 )
-			{
-				// For each populated position in the pxTaskStatusArray array,
-				// format the raw data as human readable ASCII data
-				for( x = 0; x < uxArraySize; x++ )
-				{
-					// What percentage of the total run time has the task used?
-					// This will always be rounded down to the nearest integer.
-					// ulTotalRunTimeDiv100 has already been divided by 100.
-					ulStatsAsPercentage = pxTaskStatusArray[ x ].ulRunTimeCounter / ulTotalRunTime;
-
-					if( ulStatsAsPercentage > 0UL )
-					{
-						sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );
-					}
-					else
-					{
-						// If the percentage is zero here then the task has
-						// consumed less than 1% of the total run time.
-						sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );
-					}
-
-					pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );
-				}
-			}
-
-			// The array is no longer needed, free the memory it consumes.
-			vPortFree( pxTaskStatusArray );
-		}
-	}
-	

+ * @code{c}
+ * // This example demonstrates how a human readable table of run time stats
+ * // information is generated from raw data provided by uxTaskGetSystemState().
+ * // The human readable table is written to pcWriteBuffer
+ * void vTaskGetRunTimeStats( char *pcWriteBuffer )
+ * {
+ * TaskStatus_t *pxTaskStatusArray;
+ * volatile UBaseType_t uxArraySize, x;
+ * uint32_t ulTotalRunTime, ulStatsAsPercentage;
+ *
+ *  // Make sure the write buffer does not contain a string.
+ *  *pcWriteBuffer = 0x00;
+ *
+ *  // Take a snapshot of the number of tasks in case it changes while this
+ *  // function is executing.
+ *  uxArraySize = uxTaskGetNumberOfTasks();
+ *
+ *  // Allocate a TaskStatus_t structure for each task.  An array could be
+ *  // allocated statically at compile time.
+ *  pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );
+ *
+ *  if( pxTaskStatusArray != NULL )
+ *  {
+ *      // Generate raw status information about each task.
+ *      uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, &ulTotalRunTime );
+ *
+ *      // For percentage calculations.
+ *      ulTotalRunTime /= 100UL;
+ *
+ *      // Avoid divide by zero errors.
+ *      if( ulTotalRunTime > 0 )
+ *      {
+ *          // For each populated position in the pxTaskStatusArray array,
+ *          // format the raw data as human readable ASCII data
+ *          for( x = 0; x < uxArraySize; x++ )
+ *          {
+ *              // What percentage of the total run time has the task used?
+ *              // This will always be rounded down to the nearest integer.
+ *              // ulTotalRunTimeDiv100 has already been divided by 100.
+ *              ulStatsAsPercentage = pxTaskStatusArray[ x ].ulRunTimeCounter / ulTotalRunTime;
+ *
+ *              if( ulStatsAsPercentage > 0UL )
+ *              {
+ *                  sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );
+ *              }
+ *              else
+ *              {
+ *                  // If the percentage is zero here then the task has
+ *                  // consumed less than 1% of the total run time.
+ *                  sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );
+ *              }
+ *
+ *              pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );
+ *          }
+ *      }
+ *
+ *      // The array is no longer needed, free the memory it consumes.
+ *      vPortFree( pxTaskStatusArray );
+ *  }
+ * }
+ * @endcode
  */
 UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime );
 
 /**
- * task. h
- * 
void vTaskList( char *pcWriteBuffer );

+ * List all the current tasks.
  *
  * configUSE_TRACE_FACILITY and configUSE_STATS_FORMATTING_FUNCTIONS must
  * both be defined as 1 for this function to be available.  See the
  * configuration section of the FreeRTOS.org website for more information.
  *
- * NOTE 1: This function will disable interrupts for its duration.  It is
+ * @note This function will disable interrupts for its duration.  It is
  * not intended for normal application runtime use but as a debug aid.
  *
  * Lists all the current tasks, along with their current state and stack
@@ -1507,9 +1599,7 @@ UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const
  * Tasks are reported as blocked ('B'), ready ('R'), deleted ('D') or
  * suspended ('S').
  *
- * PLEASE NOTE:
- *
- * This function is provided for convenience only, and is used by many of the
+ * @note This function is provided for convenience only, and is used by many of the
  * demo applications.  Do not consider it to be part of the scheduler.
  *
  * vTaskList() calls uxTaskGetSystemState(), then formats part of the
@@ -1532,14 +1622,12 @@ UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const
  * enough to contain the generated report.  Approximately 40 bytes per
  * task should be sufficient.
  *
- * \defgroup vTaskList vTaskList
  * \ingroup TaskUtils
  */
 void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 
 /**
- * task. h
- * 
void vTaskGetRunTimeStats( char *pcWriteBuffer );

+ * Get the state of running tasks as a string
  *
  * configGENERATE_RUN_TIME_STATS and configUSE_STATS_FORMATTING_FUNCTIONS
  * must both be defined as 1 for this function to be available.  The application
@@ -1549,7 +1637,7 @@ void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unquali
  * value respectively.  The counter should be at least 10 times the frequency of
  * the tick count.
  *
- * NOTE 1: This function will disable interrupts for its duration.  It is
+ * @note This function will disable interrupts for its duration.  It is
  * not intended for normal application runtime use but as a debug aid.
  *
  * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total
@@ -1560,9 +1648,7 @@ void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unquali
  * task into a buffer, both as an absolute count value and as a percentage
  * of the total system execution time.
  *
- * NOTE 2:
- *
- * This function is provided for convenience only, and is used by many of the
+ * @note This function is provided for convenience only, and is used by many of the
  * demo applications.  Do not consider it to be part of the scheduler.
  *
  * vTaskGetRunTimeStats() calls uxTaskGetSystemState(), then formats part of the
@@ -1586,14 +1672,12 @@ void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unquali
  * contain the generated report.  Approximately 40 bytes per task should
  * be sufficient.
  *
- * \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats
  * \ingroup TaskUtils
  */
 void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 
 /**
- * task. h
- * 
BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );

+ * Send task notification.
  *
  * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
  * function to be available.
@@ -1634,43 +1718,40 @@ void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e9
  *
  * @param eAction Specifies how the notification updates the task's notification
  * value, if at all.  Valid values for eAction are as follows:
+ *	- eSetBits:
+ *	  The task's notification value is bitwise ORed with ulValue.  xTaskNofify()
+ * 	  always returns pdPASS in this case.
  *
- *	eSetBits -
- *	The task's notification value is bitwise ORed with ulValue.  xTaskNofify()
- * 	always returns pdPASS in this case.
+ *	- eIncrement:
+ *	  The task's notification value is incremented.  ulValue is not used and
+ *	  xTaskNotify() always returns pdPASS in this case.
  *
- *	eIncrement -
- *	The task's notification value is incremented.  ulValue is not used and
- *	xTaskNotify() always returns pdPASS in this case.
+ *	- eSetValueWithOverwrite:
+ *	  The task's notification value is set to the value of ulValue, even if the
+ *	  task being notified had not yet processed the previous notification (the
+ *	  task already had a notification pending).  xTaskNotify() always returns
+ *	  pdPASS in this case.
  *
- *	eSetValueWithOverwrite -
- *	The task's notification value is set to the value of ulValue, even if the
- *	task being notified had not yet processed the previous notification (the
- *	task already had a notification pending).  xTaskNotify() always returns
- *	pdPASS in this case.
+ *	- eSetValueWithoutOverwrite:
+ *	  If the task being notified did not already have a notification pending then
+ *	  the task's notification value is set to ulValue and xTaskNotify() will
+ *	  return pdPASS.  If the task being notified already had a notification
+ *	  pending then no action is performed and pdFAIL is returned.
  *
- *	eSetValueWithoutOverwrite -
- *	If the task being notified did not already have a notification pending then
- *	the task's notification value is set to ulValue and xTaskNotify() will
- *	return pdPASS.  If the task being notified already had a notification
- *	pending then no action is performed and pdFAIL is returned.
- *
- *	eNoAction -
- *	The task receives a notification without its notification value being
- *	updated.  ulValue is not used and xTaskNotify() always returns pdPASS in
- *	this case.
+ *	- eNoAction:
+ *	  The task receives a notification without its notification value being
+ *	  updated.  ulValue is not used and xTaskNotify() always returns pdPASS in
+ *	  this case.
  *
  * @return Dependent on the value of eAction.  See the description of the
  * eAction parameter.
  *
- * \defgroup xTaskNotify xTaskNotify
  * \ingroup TaskNotifications
  */
 BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );
 
 /**
- * task. h
- * 
BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );

+ * Send task notification from an ISR.
  *
  * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
  * function to be available.
@@ -1714,31 +1795,30 @@ BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAct
  *
  * @param eAction Specifies how the notification updates the task's notification
  * value, if at all.  Valid values for eAction are as follows:
+ *	- eSetBits:
+ *	  The task's notification value is bitwise ORed with ulValue.  xTaskNofify()
+ * 	  always returns pdPASS in this case.
  *
- *	eSetBits -
- *	The task's notification value is bitwise ORed with ulValue.  xTaskNofify()
- * 	always returns pdPASS in this case.
+ *	- eIncrement:
+ *	  The task's notification value is incremented.  ulValue is not used and
+ *	  xTaskNotify() always returns pdPASS in this case.
  *
- *	eIncrement -
- *	The task's notification value is incremented.  ulValue is not used and
- *	xTaskNotify() always returns pdPASS in this case.
+ *	- eSetValueWithOverwrite:
+ *	  The task's notification value is set to the value of ulValue, even if the
+ *	  task being notified had not yet processed the previous notification (the
+ *	  task already had a notification pending).  xTaskNotify() always returns
+ *	  pdPASS in this case.
  *
- *	eSetValueWithOverwrite -
- *	The task's notification value is set to the value of ulValue, even if the
- *	task being notified had not yet processed the previous notification (the
- *	task already had a notification pending).  xTaskNotify() always returns
- *	pdPASS in this case.
+ *	- eSetValueWithoutOverwrite:
+ *	  If the task being notified did not already have a notification pending then
+ *	  the task's notification value is set to ulValue and xTaskNotify() will
+ *	  return pdPASS.  If the task being notified already had a notification
+ *	  pending then no action is performed and pdFAIL is returned.
  *
- *	eSetValueWithoutOverwrite -
- *	If the task being notified did not already have a notification pending then
- *	the task's notification value is set to ulValue and xTaskNotify() will
- *	return pdPASS.  If the task being notified already had a notification
- *	pending then no action is performed and pdFAIL is returned.
- *
- *	eNoAction -
- *	The task receives a notification without its notification value being
- *	updated.  ulValue is not used and xTaskNotify() always returns pdPASS in
- *	this case.
+ *	- eNoAction:
+ *	  The task receives a notification without its notification value being
+ *	  updated.  ulValue is not used and xTaskNotify() always returns pdPASS in
+ *	  this case.
  *
  * @param pxHigherPriorityTaskWoken  xTaskNotifyFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
@@ -1752,14 +1832,12 @@ BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAct
  * @return Dependent on the value of eAction.  See the description of the
  * eAction parameter.
  *
- * \defgroup xTaskNotify xTaskNotify
  * \ingroup TaskNotifications
  */
 BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );
 
 /**
- * task. h
- * 
BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );

+ * Wait for task notification
  *
  * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
  * function to be available.
@@ -1827,14 +1905,12 @@ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNo
  * already pending when xTaskNotifyWait was called) then pdPASS is
  * returned.  Otherwise pdFAIL is returned.
  *
- * \defgroup xTaskNotifyWait xTaskNotifyWait
  * \ingroup TaskNotifications
  */
 BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
 
 /**
- * task. h
- * 
BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );

+ * Simplified macro for sending task notification.
  *
  * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
  * to be available.
@@ -1873,14 +1949,12 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClea
  * @return xTaskNotifyGive() is a macro that calls xTaskNotify() with the
  * eAction parameter set to eIncrement - so pdPASS is always returned.
  *
- * \defgroup xTaskNotifyGive xTaskNotifyGive
  * \ingroup TaskNotifications
  */
 #define xTaskNotifyGive( xTaskToNotify ) xTaskNotify( ( xTaskToNotify ), 0, eIncrement );
 
 /**
- * task. h
- * 
void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
+ * Simplified macro for sending task notification from ISR.
  *
  * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
  * to be available.
@@ -1928,14 +2002,12 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClea
  * requested from an ISR is dependent on the port - see the documentation page
  * for the port in use.
  *
- * \defgroup xTaskNotifyWait xTaskNotifyWait
  * \ingroup TaskNotifications
  */
 void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken );
 
 /**
- * task. h
- * 
uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );

+ * Simplified macro for receiving task notification.
  *
  * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
  * function to be available.
@@ -1997,7 +2069,6 @@ void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPri
  * @return The task's notification count before it is either cleared to zero or
  * decremented (see the xClearCountOnExit parameter).
  *
- * \defgroup ulTaskNotifyTake ulTaskNotifyTake
  * \ingroup TaskNotifications
  */
 uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );
@@ -2005,7 +2076,7 @@ uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait
 /*-----------------------------------------------------------
  * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
  *----------------------------------------------------------*/
-
+/** @cond */
 /*
  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY
  * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
@@ -2224,6 +2295,8 @@ void *pvTaskIncrementMutexHeldCount( void );
  */
 UBaseType_t uxTaskGetSnapshotAll( TaskSnapshot_t * const pxTaskSnapshotArray, const UBaseType_t uxArraySize, UBaseType_t * const pxTcbSz );
 
+/** @endcond */
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/components/freertos/include/freertos/timers.h b/components/freertos/include/freertos/timers.h
index 8656d069d7..17492e64c6 100644
--- a/components/freertos/include/freertos/timers.h
+++ b/components/freertos/include/freertos/timers.h
@@ -117,24 +117,18 @@ or interrupt version of the queue send function should be used. */
  */
 typedef void * TimerHandle_t;
 
-/*
+/**
  * Defines the prototype to which timer callback functions must conform.
  */
 typedef void (*TimerCallbackFunction_t)( TimerHandle_t xTimer );
 
-/*
+/**
  * Defines the prototype to which functions used with the
  * xTimerPendFunctionCallFromISR() function must conform.
  */
 typedef void (*PendedFunction_t)( void *, uint32_t );
 
 /**
- * TimerHandle_t xTimerCreate( 	const char * const pcTimerName,
- * 								TickType_t xTimerPeriodInTicks,
- * 								UBaseType_t uxAutoReload,
- * 								void * pvTimerID,
- * 								TimerCallbackFunction_t pxCallbackFunction );
- *
  * Creates a new software timer instance, and returns a handle by which the
  * created software timer can be referenced.
  *
@@ -184,7 +178,7 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
  * structures, or the timer period was set to 0) then NULL is returned.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * #define NUM_TIMERS 5
  *
  * // An array to hold handles to the created timers.
@@ -263,7 +257,7 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
  *     // Should not reach here.
  *     for( ;; );
  * }
- * @endverbatim
+ * @endcode
  */
 #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
 	TimerHandle_t xTimerCreate(	const char * const pcTimerName,
@@ -274,13 +268,6 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
 #endif
 
  /**
-  * TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
-  * 									TickType_t xTimerPeriodInTicks,
-  * 									UBaseType_t uxAutoReload,
-  * 									void * pvTimerID,
-  * 									TimerCallbackFunction_t pxCallbackFunction,
-  *									StaticTimer_t *pxTimerBuffer );
-  *
   * Creates a new software timer instance, and returns a handle by which the
   * created software timer can be referenced.
   *
@@ -332,7 +319,7 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
   * returned.  If pxTimerBuffer was NULL then NULL is returned.
   *
   * Example usage:
-  * @verbatim
+  * @code{c}
   *
   * // The buffer used to hold the software timer's data structure.
   * static StaticTimer_t xTimerBuffer;
@@ -393,20 +380,18 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
   *     // Should not reach here.
   *     for( ;; );
   * }
-  * @endverbatim
+  * @endcode
   */
  #if( configSUPPORT_STATIC_ALLOCATION == 1 )
- 	TimerHandle_t xTimerCreateStatic(	const char * const pcTimerName,
- 										const TickType_t xTimerPeriodInTicks,
- 										const UBaseType_t uxAutoReload,
- 										void * const pvTimerID,
- 										TimerCallbackFunction_t pxCallbackFunction,
- 										StaticTimer_t *pxTimerBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+	TimerHandle_t xTimerCreateStatic(	const char * const pcTimerName,
+										const TickType_t xTimerPeriodInTicks,
+										const UBaseType_t uxAutoReload,
+										void * const pvTimerID,
+										TimerCallbackFunction_t pxCallbackFunction,
+										StaticTimer_t *pxTimerBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
  #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
- * void *pvTimerGetTimerID( TimerHandle_t xTimer );
- *
  * Returns the ID assigned to the timer.
  *
  * IDs are assigned to timers using the pvTimerID parameter of the call to
@@ -427,8 +412,6 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
 void *pvTimerGetTimerID( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 
 /**
- * void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );
- *
  * Sets the ID assigned to the timer.
  *
  * IDs are assigned to timers using the pvTimerID parameter of the call to
@@ -448,12 +431,12 @@ void *pvTimerGetTimerID( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID ) PRIVILEGED_FUNCTION;
 
 /**
- * BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer );
- *
  * Queries a timer to see if it is active or dormant.
  *
  * A timer will be dormant if:
+ *
  *     1) It has been created but not started, or
+ *
  *     2) It is an expired one-shot timer that has not been restarted.
  *
  * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
@@ -467,7 +450,7 @@ void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID ) PRIVILEGED_FUNCTION
  * pdFALSE will be returned if the timer is active.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * // This function assumes xTimer has already been created.
  * void vAFunction( TimerHandle_t xTimer )
  * {
@@ -480,13 +463,11 @@ void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID ) PRIVILEGED_FUNCTION
  *         // xTimer is not active, do something else.
  *     }
  * }
- * @endverbatim
+ * @endcode
  */
 BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 
 /**
- * TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
- *
  * xTimerGetTimerDaemonTaskHandle() is only available if
  * INCLUDE_xTimerGetTimerDaemonTaskHandle is set to 1 in FreeRTOSConfig.h.
  *
@@ -496,8 +477,6 @@ BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
 
 /**
- * TickType_t xTimerGetPeriod( TimerHandle_t xTimer );
- *
  * Returns the period of a timer.
  *
  * @param xTimer The handle of the timer being queried.
@@ -507,8 +486,6 @@ TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
 TickType_t xTimerGetPeriod( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 
 /**
- * TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer );
- *
  * Returns the time in ticks at which the timer will expire.  If this is less
  * than the current tick count then the expiry time has overflowed from the
  * current time.
@@ -522,8 +499,6 @@ TickType_t xTimerGetPeriod( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 
 /**
- * BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
  * Timer functionality is provided by a timer service/daemon task.  Many of the
  * public FreeRTOS timer API functions send commands to the timer service task
  * through a queue called the timer command queue.  The timer command queue is
@@ -574,8 +549,6 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 #define xTimerStart( xTimer, xTicksToWait ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) )
 
 /**
- * BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
  * Timer functionality is provided by a timer service/daemon task.  Many of the
  * public FreeRTOS timer API functions send commands to the timer service task
  * through a queue called the timer command queue.  The timer command queue is
@@ -616,10 +589,6 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 #define xTimerStop( xTimer, xTicksToWait ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0U, NULL, ( xTicksToWait ) )
 
 /**
- * BaseType_t xTimerChangePeriod( 	TimerHandle_t xTimer,
- *										TickType_t xNewPeriod,
- *										TickType_t xTicksToWait );
- *
  * Timer functionality is provided by a timer service/daemon task.  Many of the
  * public FreeRTOS timer API functions send commands to the timer service task
  * through a queue called the timer command queue.  The timer command queue is
@@ -661,7 +630,7 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  * configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * // This function assumes xTimer has already been created.  If the timer
  * // referenced by xTimer is already active when it is called, then the timer
  * // is deleted.  If the timer referenced by xTimer is not active when it is
@@ -691,13 +660,11 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  *         }
  *     }
  * }
- * @endverbatim
+ * @endcode
  */
  #define xTimerChangePeriod( xTimer, xNewPeriod, xTicksToWait ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), NULL, ( xTicksToWait ) )
 
 /**
- * BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
  * Timer functionality is provided by a timer service/daemon task.  Many of the
  * public FreeRTOS timer API functions send commands to the timer service task
  * through a queue called the timer command queue.  The timer command queue is
@@ -734,8 +701,6 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 #define xTimerDelete( xTimer, xTicksToWait ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_DELETE, 0U, NULL, ( xTicksToWait ) )
 
 /**
- * BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
  * Timer functionality is provided by a timer service/daemon task.  Many of the
  * public FreeRTOS timer API functions send commands to the timer service task
  * through a queue called the timer command queue.  The timer command queue is
@@ -781,7 +746,7 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  * configuration constant.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * // When a key is pressed, an LCD back-light is switched on.  If 5 seconds pass
  * // without a key being pressed, then the LCD back-light is switched off.  In
  * // this case, the timer is a one-shot timer.
@@ -853,14 +818,11 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  *     // Should not reach here.
  *     for( ;; );
  * }
- * @endverbatim
+ * @endcode
  */
 #define xTimerReset( xTimer, xTicksToWait ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) )
 
 /**
- * BaseType_t xTimerStartFromISR( 	TimerHandle_t xTimer,
- *									BaseType_t *pxHigherPriorityTaskWoken );
- *
  * A version of xTimerStart() that can be called from an interrupt service
  * routine.
  *
@@ -888,7 +850,7 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  * configuration constant.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * // This scenario assumes xBacklightTimer has already been created.  When a
  * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass
  * // without a key being pressed, then the LCD back-light is switched off.  In
@@ -939,14 +901,11 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  *         // depends on the FreeRTOS port being used).
  *     }
  * }
- * @endverbatim
+ * @endcode
  */
 #define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )
 
 /**
- * BaseType_t xTimerStopFromISR( 	TimerHandle_t xTimer,
- *									BaseType_t *pxHigherPriorityTaskWoken );
- *
  * A version of xTimerStop() that can be called from an interrupt service
  * routine.
  *
@@ -972,7 +931,7 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * // This scenario assumes xTimer has already been created and started.  When
  * // an interrupt occurs, the timer should be simply stopped.
  *
@@ -1002,15 +961,11 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  *         // depends on the FreeRTOS port being used).
  *     }
  * }
- * @endverbatim
+ * @endcode
  */
 #define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP_FROM_ISR, 0, ( pxHigherPriorityTaskWoken ), 0U )
 
 /**
- * BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer,
- *										 TickType_t xNewPeriod,
- *										 BaseType_t *pxHigherPriorityTaskWoken );
- *
  * A version of xTimerChangePeriod() that can be called from an interrupt
  * service routine.
  *
@@ -1045,7 +1000,7 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * // This scenario assumes xTimer has already been created and started.  When
  * // an interrupt occurs, the period of xTimer should be changed to 500ms.
  *
@@ -1075,14 +1030,11 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  *         // depends on the FreeRTOS port being used).
  *     }
  * }
- * @endverbatim
+ * @endcode
  */
 #define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD_FROM_ISR, ( xNewPeriod ), ( pxHigherPriorityTaskWoken ), 0U )
 
 /**
- * BaseType_t xTimerResetFromISR( 	TimerHandle_t xTimer,
- *									BaseType_t *pxHigherPriorityTaskWoken );
- *
  * A version of xTimerReset() that can be called from an interrupt service
  * routine.
  *
@@ -1110,7 +1062,7 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  * // This scenario assumes xBacklightTimer has already been created.  When a
  * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass
  * // without a key being pressed, then the LCD back-light is switched off.  In
@@ -1161,18 +1113,12 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  *         // depends on the FreeRTOS port being used).
  *     }
  * }
- * @endverbatim
+ * @endcode
  */
 #define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )
 
 
 /**
- * BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,
- *                                          void *pvParameter1,
- *                                          uint32_t ulParameter2,
- *                                          BaseType_t *pxHigherPriorityTaskWoken );
- *
- *
  * Used from application interrupt service routines to defer the execution of a
  * function to the RTOS daemon task (the timer service task, hence this function
  * is implemented in timers.c and is prefixed with 'Timer').
@@ -1214,7 +1160,7 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  * timer daemon task, otherwise pdFALSE is returned.
  *
  * Example usage:
- * @verbatim
+ * @code{c}
  *
  *	// The callback function that will execute in the context of the daemon task.
  *  // Note callback functions must all use this same prototype.
@@ -1252,17 +1198,11 @@ TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
  *		portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
  *
  *	}
- * @endverbatim
+ * @endcode
  */
 BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, BaseType_t *pxHigherPriorityTaskWoken );
 
  /**
-  * BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,
-  *                                    void *pvParameter1,
-  *                                    uint32_t ulParameter2,
-  *                                    TickType_t xTicksToWait );
-  *
-  *
   * Used to defer the execution of a function to the RTOS daemon task (the timer
   * service task, hence this function is implemented in timers.c and is prefixed
   * with 'Timer').
@@ -1291,8 +1231,6 @@ BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend, void
 BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait );
 
 /**
- * const char * const pcTimerGetTimerName( TimerHandle_t xTimer );
- *
  * Returns the name that was assigned to a timer when the timer was created.
  *
  * @param xTimer The handle of the timer being queried.
@@ -1301,6 +1239,7 @@ BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvPar
  */
 const char * pcTimerGetTimerName( TimerHandle_t xTimer ); /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 
+/** @cond */
 /*
  * Functions beyond this part are not part of the public API and are intended
  * for use by the kernel only.
@@ -1308,6 +1247,8 @@ const char * pcTimerGetTimerName( TimerHandle_t xTimer ); /*lint !e971 Unqualifi
 BaseType_t xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION;
 BaseType_t xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
+/** @endcond */
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/docs/Doxyfile b/docs/Doxyfile
index 950f914214..713b6a49dd 100644
--- a/docs/Doxyfile
+++ b/docs/Doxyfile
@@ -153,7 +153,17 @@ INPUT = \
     ../components/esp32/include/esp_pm.h \
     ../components/esp32/include/esp32/pm.h \
     ### esp_timer, High Resolution Timer
-    ../components/esp32/include/esp_timer.h
+    ../components/esp32/include/esp_timer.h \
+    ###
+    ### FreeRTOS
+    ###
+    ../components/freertos/include/freertos/task.h \
+    ../components/freertos/include/freertos/queue.h \
+    ../components/freertos/include/freertos/semphr.h \
+    ../components/freertos/include/freertos/timers.h \
+    ../components/freertos/include/freertos/event_groups.h \
+    ../components/freertos/include/freertos/ringbuf.h
+
 
 
 ## Get warnings for functions that have no documentation for their parameters or return value
@@ -165,7 +175,16 @@ WARN_NO_PARAMDOC = YES
 ENABLE_PREPROCESSING   = YES
 MACRO_EXPANSION        = YES
 EXPAND_ONLY_PREDEF     = YES
-PREDEFINED             = __attribute__(x)=
+PREDEFINED             = \
+    __attribute__(x)= \
+    IRAM_ATTR= \
+    configSUPPORT_DYNAMIC_ALLOCATION=1 \
+    configSUPPORT_STATIC_ALLOCATION=1 \
+    configQUEUE_REGISTRY_SIZE=1 \
+    configUSE_RECURSIVE_MUTEXES=1 \
+    configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS=1 \
+    configNUM_THREAD_LOCAL_STORAGE_POINTERS=1 \
+    configUSE_APPLICATION_TASK_TAG=1
 
 ## Do not complain about not having dot
 ##
diff --git a/docs/api-reference/system/freertos.rst b/docs/api-reference/system/freertos.rst
new file mode 100644
index 0000000000..2b0b0929fb
--- /dev/null
+++ b/docs/api-reference/system/freertos.rst
@@ -0,0 +1,42 @@
+FreeRTOS
+========
+
+Overview
+--------
+
+This section contains documentation of FreeRTOS types, functions, and macros. It is automatically generated from FreeRTOS header files.
+
+For more information about FreeRTOS features specific to ESP-IDF, see :doc:`ESP-IDF FreeRTOS SMP Changes<../../api-guides/freertos-smp>`.
+
+
+Task API
+--------
+
+.. include:: /_build/inc/task.inc
+
+Queue API
+---------
+
+.. include:: /_build/inc/queue.inc
+
+Semaphore API
+-------------
+
+.. include:: /_build/inc/semphr.inc
+
+Timer API
+---------
+
+.. include:: /_build/inc/timers.inc
+
+
+Event Group API
+---------------
+
+.. include:: /_build/inc/event_groups.inc
+
+Ringbuffer API
+--------------
+
+.. include:: /_build/inc/ringbuf.inc
+
diff --git a/docs/api-reference/system/hooks.rst b/docs/api-reference/system/hooks.rst
index 78ac708a23..5a65b29a16 100644
--- a/docs/api-reference/system/hooks.rst
+++ b/docs/api-reference/system/hooks.rst
@@ -1,7 +1,7 @@
 .. _hooks_api_reference:
 
-ESP-IDF FreeRTOS Hooks
-======================
+FreeRTOS Hooks
+==============
 
 Overview
 --------
diff --git a/docs/api-reference/system/index.rst b/docs/api-reference/system/index.rst
index c895ebd8b5..593fcc3d69 100644
--- a/docs/api-reference/system/index.rst
+++ b/docs/api-reference/system/index.rst
@@ -4,19 +4,20 @@ System API
 .. toctree::
    :maxdepth: 1
 
+   FreeRTOS 
+   FreeRTOS Hooks 
    Heap Memory Allocation 
    Heap Memory Debugging 
    Interrupt Allocation 
    Watchdogs 
-   Hooks 
    Inter-Processor Call 
    High Resolution Timer 
-   Over The Air Updates (OTA) 
-   Sleep Modes 
-   Power Management 
    Logging 
-   Base MAC address 
    Application Level Tracing 
+   Power Management 
+   Sleep Modes 
+   Base MAC address 
+   Over The Air Updates (OTA) 
 
 
 Example code for this API section is provided in :example:`system` directory of ESP-IDF examples.

From d6525fb3e604030bd55366e3a98ee66832c8a564 Mon Sep 17 00:00:00 2001
From: Ivan Grokhotkov 
Date: Mon, 4 Dec 2017 20:09:12 +0800
Subject: [PATCH 2/2] docs: link to FreeRTOS APIs from SMP changes
 documentation

---
 docs/api-guides/freertos-smp.rst | 122 +++++++++++++++----------------
 1 file changed, 61 insertions(+), 61 deletions(-)

diff --git a/docs/api-guides/freertos-smp.rst b/docs/api-guides/freertos-smp.rst
index 16d4c139b4..e1763bf593 100644
--- a/docs/api-guides/freertos-smp.rst
+++ b/docs/api-guides/freertos-smp.rst
@@ -20,8 +20,8 @@ found via http://www.freertos.org/a00106.html
 port of FreeRTOS v8.2.0, a number of FreeRTOS v9.0.0 features have been backported
 to ESP-IDF.
 
-:ref:`tasks-and-task-creation`: Use ``xTaskCreatePinnedToCore()`` or 
-``xTaskCreateStaticPinnedToCore()`` to create tasks in ESP-IDF FreeRTOS. The 
+:ref:`tasks-and-task-creation`: Use :cpp:func:`xTaskCreatePinnedToCore` or 
+:cpp:func:`xTaskCreateStaticPinnedToCore` to create tasks in ESP-IDF FreeRTOS. The 
 last parameter of the two functions is ``xCoreID``. This parameter specifies 
 which core the task is pinned to. Acceptable values are ``0`` for **PRO_CPU**, 
 ``1`` for **APP_CPU**, or ``tskNO_AFFINITY`` which allows the task to run on
@@ -34,13 +34,13 @@ enter a blocked state, or are distributed across a wider range of priorities.
 
 :ref:`scheduler-suspension`: Suspending the scheduler in ESP-IDF FreeRTOS will only 
 affect the scheduler on the the calling core. In other words, calling 
-``vTaskSuspendAll()`` on **PRO_CPU** will not prevent **APP_CPU** from scheduling, and
+:cpp:func:`vTaskSuspendAll` on **PRO_CPU** will not prevent **APP_CPU** from scheduling, and
 vice versa. Use critical sections or semaphores instead for simultaneous
 access protection.
 
 :ref:`tick-interrupt-synchronicity`: Tick interrupts of **PRO_CPU** and **APP_CPU** 
-are not synchronized. Do not expect to use ``vTaskDelay`` or 
-``vTaskDelayUntil`` as an accurate method of synchronizing task execution 
+are not synchronized. Do not expect to use :cpp:func:`vTaskDelay` or 
+:cpp:func:`vTaskDelayUntil` as an accurate method of synchronizing task execution 
 between the two cores. Use a counting semaphore instead as their context 
 switches are not tied to tick interrupts due to preemption.
 
@@ -51,15 +51,15 @@ unaffected. If the other core attemps to take same mutex, it will spin until
 the calling core has released the mutex by exiting the critical section.
 
 :ref:`floating-points`: The ESP32 supports hardware acceleration of single
-precision floating point arithmetic (`float`). However the use of hardware
+precision floating point arithmetic (``float``). However the use of hardware
 acceleration leads to some behavioral restrictions in ESP-IDF FreeRTOS.
-Therefore, tasks that utilize `float` will automatically be pinned to a core if 
-not done so already. Furthermore, `float` cannot be used in interrupt service 
+Therefore, tasks that utilize ``float`` will automatically be pinned to a core if 
+not done so already. Furthermore, ``float`` cannot be used in interrupt service 
 routines.
 
 :ref:`task-deletion`: Task deletion behavior has been backported from FreeRTOS 
 v9.0.0 and modified to be SMP compatible. Task memory will be freed immediately 
-when `vTaskDelete()` is called to delete a task that is not currently running 
+when :cpp:func:`vTaskDelete` is called to delete a task that is not currently running 
 and not pinned to the other core. Otherwise, freeing of task memory will still 
 be delegated to the Idle Task.
 
@@ -67,7 +67,7 @@ be delegated to the Idle Task.
 Storage Pointers (TLSP) feature. However the extra feature of Deletion Callbacks has been
 added. Deletion callbacks are called automatically during task deletion and are
 used to free memory pointed to by TLSP. Call 
-``vTaskSetThreadLocalStoragePointerAndDelCallback()`` to set TLSP and Deletion
+:cpp:func:`vTaskSetThreadLocalStoragePointerAndDelCallback()` to set TLSP and Deletion
 Callbacks.
 
 :ref:`FreeRTOS Hooks`: Vanilla FreeRTOS Hooks were not designed for SMP.
@@ -94,34 +94,34 @@ This feature has been backported from FreeRTOS v9.0.0 to ESP-IDF. The
 in order for static allocation functions to be available. Once enabled, the 
 following functions can be called...
 
- - ``xTaskCreateStatic()`` See :ref:`backporting-notes` below
- - ``xQueueCreateStatic()``
- - ``xSemaphoreCreateBinaryStatic()``
- - ``xSemaphoreCreateCountingStatic()``
- - ``xSemaphoreCreateMutexStatic()``
- - ``xSemaphoreCreateRecursiveMutexStatic()``
- - ``xTimerCreateStatic()``  See :ref:`backporting-notes` below
- - ``xEventGroupCreateStatic()``
+ - :cpp:func:`xTaskCreateStatic` (see :ref:`backporting-notes` below)
+ - :c:macro:`xQueueCreateStatic`
+ - :c:macro:`xSemaphoreCreateBinaryStatic`
+ - :c:macro:`xSemaphoreCreateCountingStatic`
+ - :c:macro:`xSemaphoreCreateMutexStatic`
+ - :c:macro:`xSemaphoreCreateRecursiveMutexStatic`
+ - :cpp:func:`xTimerCreateStatic`  (see :ref:`backporting-notes` below)
+ - :cpp:func:`xEventGroupCreateStatic`
 
 Other Features
 ^^^^^^^^^^^^^^
 
- - ``vTaskSetThreadLocalStoragePointer()`` See :ref:`backporting-notes` below
- - ``pvTaskGetThreadLocalStoragePointer()`` See :ref:`backporting-notes` below
- - ``vTimerSetTimerID()``
- - ``xTimerGetPeriod()``
- - ``xTimerGetExpiryTime()``
- - ``pcQueueGetName()``
- - ``uxSemaphoreGetCount()``
+ - :cpp:func:`vTaskSetThreadLocalStoragePointer` (see :ref:`backporting-notes` below)
+ - :cpp:func:`pvTaskGetThreadLocalStoragePointer` (see :ref:`backporting-notes` below)
+ - :cpp:func:`vTimerSetTimerID`
+ - :cpp:func:`xTimerGetPeriod`
+ - :cpp:func:`xTimerGetExpiryTime`
+ - :cpp:func:`pcQueueGetName`
+ - :c:macro:`uxSemaphoreGetCount`
 
 .. _backporting-notes:
 
 Backporting Notes
 ^^^^^^^^^^^^^^^^^
 
-**1)** ``xTaskCreateStatic`` has been made SMP compatible in a similar 
-fashion to ``xTaskCreate`` (see :ref:`tasks-and-task-creation`). Therefore 
-``xTaskCreateStaticPinnedToCore()`` can also be called.
+**1)** :cpp:func:`xTaskCreateStatic` has been made SMP compatible in a similar 
+fashion to :cpp:func:`xTaskCreate` (see :ref:`tasks-and-task-creation`). Therefore 
+:cpp:func:`xTaskCreateStaticPinnedToCore` can also be called.
 
 **2)** Although vanilla FreeRTOS allows the Timer feature's daemon task to 
 be statically allocated, the daemon task is always dynamically allocated in 
@@ -130,7 +130,7 @@ defined when using statically allocated timers in ESP-IDF FreeRTOS.
 
 **3)** The Thread Local Storage Pointer feature has been modified in ESP-IDF
 FreeRTOS to include Deletion Callbacks (see :ref:`deletion-callbacks`). Therefore
-the function ``vTaskSetThreadLocalStoragePointerAndDelCallback()`` can also be 
+the function :cpp:func:`vTaskSetThreadLocalStoragePointerAndDelCallback` can also be 
 called.
 
 
@@ -142,9 +142,9 @@ Tasks and Task Creation
 Tasks in ESP-IDF FreeRTOS are designed to run on a particular core, therefore 
 two new task creation functions have been added to ESP-IDF FreeRTOS by 
 appending ``PinnedToCore`` to the names of the task creation functions in 
-vanilla FreeRTOS. The vanilla FreeRTOS functions of ``xTaskCreate()``
-and ``xTaskCreateStatic()`` have led to the addition of 
-``xTaskCreatePinnedToCore()`` and ``xTaskCreateStaticPinnedToCore()`` in 
+vanilla FreeRTOS. The vanilla FreeRTOS functions of :cpp:func:`xTaskCreate`
+and :cpp:func:`xTaskCreateStatic` have led to the addition of 
+:cpp:func:`xTaskCreatePinnedToCore` and :cpp:func:`xTaskCreateStaticPinnedToCore` in 
 ESP-IDF FreeRTOS (see :ref:`backported-features`).
 
 For more details see :component_file:`freertos/task.c`
@@ -164,9 +164,9 @@ of 1000 bytes. It should be noted that the ``uxStackDepth`` parameter in
 vanilla FreeRTOS specifies a task’s stack depth in terms of the number of 
 words, whereas ESP-IDF FreeRTOS specifies the stack depth in terms of bytes.
 
-Note that the vanilla FreeRTOS functions ``xTaskCreate`` and 
-``xTaskCreateStatic`` have been macro defined in ESP-IDF FreeRTOS to call 
-``xTaskCreatePinnedToCore()`` and ``xTaskCreateStaticPinnedToCore()``
+Note that the vanilla FreeRTOS functions :cpp:func:`xTaskCreate` and 
+:cpp:func:`xTaskCreateStatic` have been defined in ESP-IDF FreeRTOS as inline functions which call 
+:cpp:func:`xTaskCreatePinnedToCore` and :cpp:func:`xTaskCreateStaticPinnedToCore`
 respectively with ``tskNO_AFFINITY`` as the ``xCoreID`` value. 
 
 Each Task Control Block (TCB) in ESP-IDF stores the ``xCoreID`` as a member. 
@@ -283,18 +283,18 @@ different cores.
 Scheduler Suspension
 ^^^^^^^^^^^^^^^^^^^^
 
-In vanilla FreeRTOS, suspending the scheduler via ``vTaskSuspendAll()`` will 
-prevent calls of ``vTaskSwitchContext()`` from context switching until the 
-scheduler has been resumed with ``vTaskResumeAll()``. However servicing ISRs 
+In vanilla FreeRTOS, suspending the scheduler via :cpp:func:`vTaskSuspendAll` will 
+prevent calls of ``vTaskSwitchContext`` from context switching until the 
+scheduler has been resumed with :cpp:func:`xTaskResumeAll`. However servicing ISRs 
 are still permitted. Therefore any changes in task states as a result from the
 current running task or ISRSs will not be executed until the scheduler is 
 resumed. Scheduler suspension in vanilla FreeRTOS is a common protection method 
 against simultaneous access of data shared between tasks, whilst still allowing 
 ISRs to be serviced.
 
-In ESP-IDF FreeRTOS, ``vTaskSuspendAll()`` will only prevent calls of 
+In ESP-IDF FreeRTOS, :cpp:func:`xTaskResumeAll` will only prevent calls of 
 ``vTaskSwitchContext()`` from switching contexts on the core that called for the
-suspension. Hence if **PRO_CPU** calls ``vTaskSuspendAll()``, **APP_CPU** will 
+suspension. Hence if **PRO_CPU** calls :cpp:func:`vTaskSuspendAll`, **APP_CPU** will 
 still be able to switch contexts. If data is shared between tasks that are 
 pinned to different cores, scheduler suspension is **NOT** a valid method of 
 protection against simultaneous access. Consider using critical sections 
@@ -302,7 +302,7 @@ protection against simultaneous access. Consider using critical sections
 protecting shared resources in ESP-IDF FreeRTOS.
 
 In general, it's better to use other RTOS primitives like mutex semaphores to protect
-against data shared between tasks, rather than ``vTaskSuspendAll()``.
+against data shared between tasks, rather than :cpp:func:`vTaskSuspendAll`.
 
 
 .. _tick-interrupt-synchronicity:
@@ -316,8 +316,8 @@ each core being independent, and the tick interrupts to each core being
 unsynchronized.
 
 In vanilla FreeRTOS the tick interrupt triggers a call to 
-``xTaskIncrementTick()`` which is responsible for incrementing the tick 
-counter, checking if tasks which have called ``vTaskDelay()`` have fulfilled 
+:cpp:func:`xTaskIncrementTick` which is responsible for incrementing the tick 
+counter, checking if tasks which have called :cpp:func:`vTaskDelay` have fulfilled 
 their delay period, and moving those tasks from the Delayed Task List to the 
 Ready Task List. The tick interrupt will then call the scheduler if a context 
 switch is necessary.
@@ -372,11 +372,11 @@ The ESP-IDF FreeRTOS critical section functions have been modified as follows…
 
  - ``taskENTER_CRITICAL(mux)``, ``taskENTER_CRITICAL_ISR(mux)``, 
    ``portENTER_CRITICAL(mux)``, ``portENTER_CRITICAL_ISR(mux)`` are all macro 
-   defined to call ``vTaskEnterCritical()`` 
+   defined to call :cpp:func:`vTaskEnterCritical` 
 
  - ``taskEXIT_CRITICAL(mux)``, ``taskEXIT_CRITICAL_ISR(mux)``, 
    ``portEXIT_CRITICAL(mux)``, ``portEXIT_CRITICAL_ISR(mux)`` are all macro 
-   defined to call ``vTaskExitCritical()``
+   defined to call :cpp:func:`vTaskExitCritical`
 
 For more details see :component_file:`freertos/include/freertos/portmacro.h` 
 and :component_file:`freertos/task.c`
@@ -394,23 +394,23 @@ Floating Point Aritmetic
 ------------------------
 
 The ESP32 supports hardware acceleration of single precision floating point
-arithmetic (`float`) via Floating Point Units (FPU, also known as coprocessors) 
+arithmetic (``float``) via Floating Point Units (FPU, also known as coprocessors) 
 attached to each core. The use of the FPUs imposes some behavioral restrictions 
 on ESP-IDF FreeRTOS.
 
 ESP-IDF FreeRTOS implements Lazy Context Switching for FPUs. In other words,
 the state of a core's FPU registers are not immediately saved when a context 
-switch occurs. Therefore, tasks that utilize `float` must be pinned to a
+switch occurs. Therefore, tasks that utilize ``float`` must be pinned to a
 particular core upon creation. If not, ESP-IDF FreeRTOS will automatically pin
 the task in question to whichever core the task was running on upon the task's 
-first use of `float`. Likewise due to Lazy Context Switching, interrupt service 
-routines must also not use `float`.
+first use of ``float``. Likewise due to Lazy Context Switching, interrupt service 
+routines must also not use ``float``.
 
 ESP32 does not support hardware acceleration for double precision floating point
-arithmetic (`double`). Instead `double` is implemented via software hence the 
-behavioral restrictions with regards to `float` do not apply to `double`. Note
-that due to the lack of hardware acceleration, `double` operations may consume
-significantly larger amount of CPU time in comparison to `float`.
+arithmetic (``double``). Instead ``double`` is implemented via software hence the 
+behavioral restrictions with regards to ``float`` do not apply to ``double``. Note
+that due to the lack of hardware acceleration, ``double`` operations may consume
+significantly larger amount of CPU time in comparison to ``float``.
 
 
 .. _task-deletion:
@@ -420,12 +420,12 @@ Task Deletion
 
 FreeRTOS task deletion prior to v9.0.0 delegated the freeing of task memory 
 entirely to the Idle Task. Currently, the freeing of task memory will occur
-immediately (within `vTaskDelete()`) if the task being deleted is not currently 
+immediately (within :cpp:func:`vTaskDelete`) if the task being deleted is not currently 
 running or is not pinned to the other core (with respect to the core 
-`vTaskDelete()` is called on). TLSP deletion callbacks will also run immediately
+:cpp:func:`vTaskDelete` is called on). TLSP deletion callbacks will also run immediately
 if the same conditions are met.
 
-However, calling `vTaskDelete()` to delete a task that is either currently 
+However, calling :cpp:func:`vTaskDelete` to delete a task that is either currently 
 running or pinned to the other core will still result in the freeing of memory 
 being delegated to the Idle Task.
 
@@ -456,8 +456,8 @@ is the index number of the associated TLSP, and the second parameter is the
 TLSP itself.
 
 Deletion callbacks are set alongside TLSP by calling 
-``vTaskSetThreadLocalStoragePointerAndDelCallback()``. Calling the vanilla 
-FreeRTOS function ``vTaskSetThreadLocalStoragePointer()`` will simply set the
+:cpp:func:`vTaskSetThreadLocalStoragePointerAndDelCallback`. Calling the vanilla 
+FreeRTOS function :cpp:func:`vTaskSetThreadLocalStoragePointer` will simply set the
 TLSP's associated Deletion Callback to `NULL` meaning that no callback will be
 called for that TLSP during task deletion. If a deletion callback is `NULL`,
 users should manually free the memory pointed to by the associated TLSP before 
@@ -466,7 +466,7 @@ task deletion in order to avoid memory leak.
 :ref:`CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS` in menuconfig can be used
 to configure the number TLSP and Deletion Callbacks a TCB will have.
 
-For more details see :component_file:`freertos/include/freertos/task.h`
+For more details see :doc:`FreeRTOS API reference<../api-reference/system/freertos>`.
 
 
 .. _esp-idf-freertos-configuration:
@@ -491,9 +491,9 @@ number of Thread Local Storage Pointers each task will have in ESP-IDF
 FreeRTOS.
 
 :ref:`CONFIG_SUPPORT_STATIC_ALLOCATION` will enable the backported
-functionality of ``xTaskCreateStaticPinnedToCore()`` in ESP-IDF FreeRTOS
+functionality of :cpp:func:`xTaskCreateStaticPinnedToCore` in ESP-IDF FreeRTOS
     
 :ref:`CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION` will trigger a halt in
 particular functions in ESP-IDF FreeRTOS which have not been fully tested
 in an SMP context.
-    
+