diff --git a/Source/include/FreeRTOS.h b/Source/include/FreeRTOS.h
index cbaf57b..0edc2af 100644
--- a/Source/include/FreeRTOS.h
+++ b/Source/include/FreeRTOS.h
@@ -173,8 +173,7 @@
 #endif
 
 #if configMAX_TASK_NAME_LEN < 1
-	#undef configMAX_TASK_NAME_LEN
-	#define configMAX_TASK_NAME_LEN 1
+	#error configMAX_TASK_NAME_LEN must be set to a minimum of 1 in FreeRTOSConfig.h
 #endif
 
 #ifndef INCLUDE_xTaskResumeFromISR
@@ -188,9 +187,6 @@
 /* The timers module relies on xTaskGetSchedulerState(). */
 #if configUSE_TIMERS == 1
 
-	#undef INCLUDE_xTaskGetSchedulerState
-	#define INCLUDE_xTaskGetSchedulerState 1
-
 	#ifndef configTIMER_TASK_PRIORITY
 		#error If configUSE_TIMERS is set to 1 then configTIMER_TASK_PRIORITY must also be defined.
 	#endif /* configTIMER_TASK_PRIORITY */
@@ -209,15 +205,8 @@
 	#define INCLUDE_xTaskGetSchedulerState 0
 #endif
 
-#if ( configUSE_MUTEXES == 1 )
-	/* xTaskGetCurrentTaskHandle is used by the priority inheritance mechanism
-	within the mutex implementation so must be available if mutexes are used. */
-	#undef INCLUDE_xTaskGetCurrentTaskHandle
-	#define INCLUDE_xTaskGetCurrentTaskHandle 1
-#else
-	#ifndef INCLUDE_xTaskGetCurrentTaskHandle
-		#define INCLUDE_xTaskGetCurrentTaskHandle 0
-	#endif
+#ifndef INCLUDE_xTaskGetCurrentTaskHandle
+	#define INCLUDE_xTaskGetCurrentTaskHandle 0
 #endif
 
 
@@ -231,11 +220,10 @@
 
 
 #ifndef configQUEUE_REGISTRY_SIZE
-	#define configQUEUE_REGISTRY_SIZE 0
+	#define configQUEUE_REGISTRY_SIZE 0U
 #endif
 
-#if configQUEUE_REGISTRY_SIZE < 1
-	#define configQUEUE_REGISTRY_SIZE 0
+#if ( configQUEUE_REGISTRY_SIZE < 1U )
 	#define vQueueAddToRegistry( xQueue, pcName )
 	#define vQueueUnregisterQueue( xQueue )
 #endif
diff --git a/Source/include/StackMacros.h b/Source/include/StackMacros.h
index 902738c..9a96151 100644
--- a/Source/include/StackMacros.h
+++ b/Source/include/StackMacros.h
@@ -142,23 +142,23 @@
 
 #if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH > 0 ) )
 
-	#define taskSECOND_CHECK_FOR_STACK_OVERFLOW()																									\
-	{																																				\
-	char *pcEndOfStack = ( char * ) pxCurrentTCB->pxEndOfStack;																						\
-	static const unsigned char ucExpectedStackBytes[] = {	tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,			\
-																tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\
-																tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\
-																tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\
-																tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE };	\
-																																					\
-																																					\
-		pcEndOfStack -= sizeof( ucExpectedStackBytes );																								\
-																																					\
-		/* Has the extremity of the task stack ever been written over? */																			\
-		if( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 )								\
-		{																																			\
-			vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName );												\
-		}																																			\
+	#define taskSECOND_CHECK_FOR_STACK_OVERFLOW()																								\
+	{																																			\
+	char *pcEndOfStack = ( char * ) pxCurrentTCB->pxEndOfStack;																					\
+	static const unsigned char ucExpectedStackBytes[] = {	tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\
+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\
+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\
+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\
+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE };	\
+																																				\
+																																				\
+		pcEndOfStack -= sizeof( ucExpectedStackBytes );																							\
+																																				\
+		/* Has the extremity of the task stack ever been written over? */																		\
+		if( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 )							\
+		{																																		\
+			vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName );											\
+		}																																		\
 	}
 
 #endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
diff --git a/Source/include/croutine.h b/Source/include/croutine.h
index fec57c4..21b6358 100644
--- a/Source/include/croutine.h
+++ b/Source/include/croutine.h
@@ -406,7 +406,7 @@
 #define crQUEUE_SEND( xHandle, pxQueue, pvItemToQueue, xTicksToWait, pxResult )			\
 {																						\
 	*( pxResult ) = xQueueCRSend( ( pxQueue) , ( pvItemToQueue) , ( xTicksToWait ) );	\
-	if( *pxResult == errQUEUE_BLOCKED )													\
+	if( *( pxResult ) == errQUEUE_BLOCKED )												\
 	{																					\
 		crSET_STATE0( ( xHandle ) );													\
 		*pxResult = xQueueCRSend( ( pxQueue ), ( pvItemToQueue ), 0 );					\
diff --git a/Source/include/queue.h b/Source/include/queue.h
index f9d7bfa..0c16678 100644
--- a/Source/include/queue.h
+++ b/Source/include/queue.h
@@ -33,9 +33,9 @@
     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
-    more details. You should have received a copy of the GNU General Public 
-    License and the FreeRTOS license exception along with FreeRTOS; if not it 
-    can be viewed here: http://www.freertos.org/a00114.html and also obtained 
+    more details. You should have received a copy of the GNU General Public
+    License and the FreeRTOS license exception along with FreeRTOS; if not it
+    can be viewed here: http://www.freertos.org/a00114.html and also obtained
     by writing to Richard Barry, contact details for whom are available on the
     FreeRTOS WEB site.
 
@@ -51,16 +51,14 @@
     licensing and training services.
 */
 
-#ifndef INC_FREERTOS_H
-	#error "#include FreeRTOS.h" must appear in source files before "#include queue.h"
-#endif
-
-
-
 
 #ifndef QUEUE_H
 #define QUEUE_H
 
+#ifndef INC_FREERTOS_H
+	#error "#include FreeRTOS.h" must appear in source files before "#include queue.h"
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -219,7 +217,7 @@
  * \defgroup xQueueSend xQueueSend
  * \ingroup QueueManagement
  */
-#define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_FRONT )
+#define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
 
 /**
  * queue. h
@@ -301,7 +299,7 @@
  * \defgroup xQueueSend xQueueSend
  * \ingroup QueueManagement
  */
-#define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )
+#define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
 
 /**
  * queue. h
@@ -385,7 +383,7 @@
  * \defgroup xQueueSend xQueueSend
  * \ingroup QueueManagement
  */
-#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )
+#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
 
 
 /**
@@ -567,7 +565,7 @@
  * \defgroup xQueueReceive xQueueReceive
  * \ingroup QueueManagement
  */
-#define xQueuePeek( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( xQueue, pvBuffer, xTicksToWait, pdTRUE )
+#define xQueuePeek( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )
 
 /**
  * queue. h
@@ -660,7 +658,7 @@
  * \defgroup xQueueReceive xQueueReceive
  * \ingroup QueueManagement
  */
-#define xQueueReceive( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( xQueue, pvBuffer, xTicksToWait, pdFALSE )
+#define xQueueReceive( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )
 
 
 /**
@@ -858,7 +856,7 @@
  * \defgroup xQueueSendFromISR xQueueSendFromISR
  * \ingroup QueueManagement
  */
-#define xQueueSendToFrontFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_FRONT )
+#define xQueueSendToFrontFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )
 
 
 /**
@@ -929,7 +927,7 @@
  * \defgroup xQueueSendFromISR xQueueSendFromISR
  * \ingroup QueueManagement
  */
-#define xQueueSendToBackFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )
+#define xQueueSendToBackFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
 
 /**
  * queue. h
@@ -1003,7 +1001,7 @@
  * \defgroup xQueueSendFromISR xQueueSendFromISR
  * \ingroup QueueManagement
  */
-#define xQueueSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )
+#define xQueueSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
 
 /**
  * queue. h
@@ -1197,10 +1195,10 @@
  */
 signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );
 signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking );
-#define xQueueAltSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_FRONT )
-#define xQueueAltSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( xQueue, pvItemToQueue, xTicksToWait, queueSEND_TO_BACK )
-#define xQueueAltReceive( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( xQueue, pvBuffer, xTicksToWait, pdFALSE )
-#define xQueueAltPeek( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( xQueue, pvBuffer, xTicksToWait, pdTRUE )
+#define xQueueAltSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
+#define xQueueAltSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
+#define xQueueAltReceive( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )
+#define xQueueAltPeek( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )
 
 /*
  * The functions defined above are for passing data to and from tasks.  The
@@ -1250,7 +1248,7 @@
  * @param pcName The name to be associated with the handle.  This is the
  * name that the kernel aware debugger will display.
  */
-#if configQUEUE_REGISTRY_SIZE > 0
+#if configQUEUE_REGISTRY_SIZE > 0U
 	void vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcName );
 #endif
 
diff --git a/Source/include/semphr.h b/Source/include/semphr.h
index 8674096..c086597 100644
--- a/Source/include/semphr.h
+++ b/Source/include/semphr.h
@@ -51,20 +51,20 @@
     licensing and training services.
 */
 
+#ifndef SEMAPHORE_H
+#define SEMAPHORE_H
+
 #ifndef INC_FREERTOS_H
 	#error "#include FreeRTOS.h" must appear in source files before "#include semphr.h"
 #endif
 
-#ifndef SEMAPHORE_H
-#define SEMAPHORE_H
-
 #include "queue.h"
 
 typedef xQueueHandle xSemaphoreHandle;
 
-#define semBINARY_SEMAPHORE_QUEUE_LENGTH	( ( unsigned char ) 1 )
-#define semSEMAPHORE_QUEUE_ITEM_LENGTH		( ( unsigned char ) 0 )
-#define semGIVE_BLOCK_TIME					( ( portTickType ) 0 )
+#define semBINARY_SEMAPHORE_QUEUE_LENGTH	( ( unsigned char ) 1U )
+#define semSEMAPHORE_QUEUE_ITEM_LENGTH		( ( unsigned char ) 0U )
+#define semGIVE_BLOCK_TIME					( ( portTickType ) 0U )
 
 
 /**
@@ -105,12 +105,12 @@
  * \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary
  * \ingroup Semaphores
  */
-#define vSemaphoreCreateBinary( xSemaphore )		{																								\
-														xSemaphore = xQueueCreate( ( unsigned portBASE_TYPE ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH );	\
-														if( xSemaphore != NULL )																	\
-														{																							\
-															xSemaphoreGive( xSemaphore );															\
-														}																							\
+#define vSemaphoreCreateBinary( xSemaphore )		{																									\
+														( xSemaphore ) = xQueueCreate( ( unsigned portBASE_TYPE ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH );	\
+														if( ( xSemaphore ) != NULL )																	\
+														{																								\
+															xSemaphoreGive( ( xSemaphore ) );															\
+														}																								\
 													}
 
 /**
@@ -178,7 +178,7 @@
  * \defgroup xSemaphoreTake xSemaphoreTake
  * \ingroup Semaphores
  */
-#define xSemaphoreTake( xSemaphore, xBlockTime )		xQueueGenericReceive( ( xQueueHandle ) xSemaphore, NULL, xBlockTime, pdFALSE )
+#define xSemaphoreTake( xSemaphore, xBlockTime )		xQueueGenericReceive( ( xQueueHandle ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )
 
 /**
  * semphr. h
@@ -271,7 +271,7 @@
  * \defgroup xSemaphoreTakeRecursive xSemaphoreTakeRecursive
  * \ingroup Semaphores
  */
-#define xSemaphoreTakeRecursive( xMutex, xBlockTime )	xQueueTakeMutexRecursive( xMutex, xBlockTime )
+#define xSemaphoreTakeRecursive( xMutex, xBlockTime )	xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )
 
 
 /* 
@@ -286,7 +286,7 @@
  * responsiveness to gain execution speed, whereas the fully featured API
  * sacrifices execution speed to ensure better interrupt responsiveness.
  */
-#define xSemaphoreAltTake( xSemaphore, xBlockTime )		xQueueAltGenericReceive( ( xQueueHandle ) xSemaphore, NULL, xBlockTime, pdFALSE )
+#define xSemaphoreAltTake( xSemaphore, xBlockTime )		xQueueAltGenericReceive( ( xQueueHandle ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )
 
 /**
  * semphr. h
@@ -349,7 +349,7 @@
  * \defgroup xSemaphoreGive xSemaphoreGive
  * \ingroup Semaphores
  */
-#define xSemaphoreGive( xSemaphore )		xQueueGenericSend( ( xQueueHandle ) xSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
+#define xSemaphoreGive( xSemaphore )		xQueueGenericSend( ( xQueueHandle ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
 
 /**
  * semphr. h
@@ -433,7 +433,7 @@
  * \defgroup xSemaphoreGiveRecursive xSemaphoreGiveRecursive
  * \ingroup Semaphores
  */
-#define xSemaphoreGiveRecursive( xMutex )	xQueueGiveMutexRecursive( xMutex )
+#define xSemaphoreGiveRecursive( xMutex )	xQueueGiveMutexRecursive( ( xMutex ) )
 
 /* 
  * xSemaphoreAltGive() is an alternative version of xSemaphoreGive().
@@ -447,7 +447,7 @@
  * responsiveness to gain execution speed, whereas the fully featured API
  * sacrifices execution speed to ensure better interrupt responsiveness.
  */
-#define xSemaphoreAltGive( xSemaphore )		xQueueAltGenericSend( ( xQueueHandle ) xSemaphore, NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
+#define xSemaphoreAltGive( xSemaphore )		xQueueAltGenericSend( ( xQueueHandle ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
 
 /**
  * semphr. h
@@ -538,7 +538,7 @@
  * \defgroup xSemaphoreGiveFromISR xSemaphoreGiveFromISR
  * \ingroup Semaphores
  */
-#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )			xQueueGenericSendFromISR( ( xQueueHandle ) xSemaphore, NULL, pxHigherPriorityTaskWoken, queueSEND_TO_BACK )
+#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )			xQueueGenericSendFromISR( ( xQueueHandle ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
 
 /**
  * semphr. h
@@ -703,7 +703,7 @@
  * \defgroup xSemaphoreCreateCounting xSemaphoreCreateCounting
  * \ingroup Semaphores
  */
-#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) xQueueCreateCountingSemaphore( uxMaxCount, uxInitialCount )
+#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )
 
 
 #endif /* SEMAPHORE_H */
diff --git a/Source/include/task.h b/Source/include/task.h
index 3a64d09..c4b65b7 100644
--- a/Source/include/task.h
+++ b/Source/include/task.h
@@ -122,7 +122,7 @@
  *
  * \ingroup TaskUtils
  */
-#define tskIDLE_PRIORITY			( ( unsigned portBASE_TYPE ) 0 )
+#define tskIDLE_PRIORITY			( ( unsigned portBASE_TYPE ) 0U )
 
 /**
  * task. h
diff --git a/Source/include/timers.h b/Source/include/timers.h
index 727c4fd..b55a6d4 100644
--- a/Source/include/timers.h
+++ b/Source/include/timers.h
@@ -79,7 +79,7 @@
  *----------------------------------------------------------*/
 
  /**
- * Type by which software timers are referenced.  For example, a call to 
+ * Type by which software timers are referenced.  For example, a call to
  * xTimerCreate() returns an xTimerHandle variable that can then be used to
  * reference the subject timer in calls to other software timer API functions
  * (for example, xTimerStart(), xTimerReset(), etc.).
@@ -90,14 +90,14 @@
 typedef void (*tmrTIMER_CALLBACK)( xTimerHandle xTimer );
 
 /**
- * xTimerHandle xTimerCreate( 	const signed char *pcTimerName, 
- * 								portTickType xTimerPeriod, 
- * 								unsigned portBASE_TYPE uxAutoReload, 
- * 								void * pvTimerID, 
+ * xTimerHandle xTimerCreate( 	const signed char *pcTimerName,
+ * 								portTickType xTimerPeriod,
+ * 								unsigned portBASE_TYPE uxAutoReload,
+ * 								void * pvTimerID,
  * 								tmrTIMER_CALLBACK pxCallbackFunction );
  *
- * Creates a new software timer instance.  This allocates the storage required 
- * by the new timer, initialises the new timers internal state, and returns a 
+ * Creates a new software timer instance.  This allocates the storage required
+ * by the new timer, initialises the new timers internal state, and returns a
  * handle by which the new timer can be referenced.
  *
  * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
@@ -109,7 +109,7 @@
  * purely to assist debugging.  The kernel itself only ever references a timer by
  * its handle, and never by its name.
  *
- * @param xTimerPeriod The timer period.  The time is defined in tick periods so 
+ * @param xTimerPeriod The timer period.  The time is defined in tick periods so
  * the constant portTICK_RATE_MS can be used to convert a time that has been
  * specified in milliseconds.  For example, if the timer must expire after 100
  * ticks, then xTimerPeriod should be set to 100.  Alternatively, if the timer
@@ -121,46 +121,46 @@
  * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
  * enter the dormant state after it expires.
  *
- * @param pvTimerID An identifier that is assigned to the timer being created.  
- * Typically this would be used in the timer callback function to identify which 
- * timer expired when the same callback function is assigned to more than one 
+ * @param pvTimerID An identifier that is assigned to the timer being created.
+ * Typically this would be used in the timer callback function to identify which
+ * timer expired when the same callback function is assigned to more than one
  * timer.
  *
  * @param pxCallbackFunction The function to call when the timer expires.
- * Callback functions must have the prototype defined by tmrTIMER_CALLBACK, 
+ * Callback functions must have the prototype defined by tmrTIMER_CALLBACK,
  * which is	"void vCallbackFunction( xTIMER *xTimer );".
  *
  * @return If the timer is successfully create then a handle to the newly
  * created timer is returned.  If the timer cannot be created (because either
- * there is insufficient FreeRTOS heap remaining to allocate the timer 
+ * there is insufficient FreeRTOS heap remaining to allocate the timer
  * structures, or the timer period was set to 0) then 0 is returned.
  *
  * Example usage:
  *
- * 
+ *
  * #define NUM_TIMERS 5
- * 
+ *
  * // An array to hold handles to the created timers.
  * xTimerHandle xTimers[ NUM_TIMERS ];
- * 
+ *
  * // An array to hold a count of the number of times each timer expires.
  * long lExpireCounters[ NUM_TIMERS ] = { 0 };
- * 
- * // Define a callback function that will be used by multiple timer instances.  
- * // The callback function does nothing but count the number of times the 
+ *
+ * // Define a callback function that will be used by multiple timer instances.
+ * // The callback function does nothing but count the number of times the
  * // associated timer expires, and stop the timer once the timer has expired
  * // 10 times.
  * void vTimerCallback( xTIMER *pxTimer )
  * {
  * long lArrayIndex;
  * const long xMaxExpiryCountBeforeStopping = 10;
- * 
+ *
  * 	   // Optionally do something if the pxTimer parameter is NULL.
  * 	   configASSERT( pxTimer );
  * 	
  *     // Which timer expired?
  *     lArrayIndex = ( long ) pvTimerGetTimerID( pxTimer );
- *     
+ *
  *     // Increment the number of times that pxTimer has expired.
  *     lExpireCounters[ lArrayIndex ] += 1;
  *
@@ -172,11 +172,11 @@
  *         xTimerStop( pxTimer, 0 );
  *     }
  * }
- * 
+ *
  * void main( void )
  * {
  * long x;
- * 
+ *
  *     // Create then start some timers.  Starting the timers before the scheduler
  *     // has been started means the timers will start running immediately that
  *     // the scheduler starts.
@@ -188,7 +188,7 @@
  *                                         ( void * ) x,     // Assign each timer a unique id equal to its array index.
  *                                         vTimerCallback     // Each timer calls the same callback when it expires.
  *                                     );
- *                                     
+ *
  *         if( xTimers[ x ] == NULL )
  *         {
  *             // The timer was not created.
@@ -197,33 +197,33 @@
  *         {
  *             // Start the timer.  No block time is specified, and even if one was
  *             // it would be ignored because the scheduler has not yet been
- *             // started. 
+ *             // started.
  *             if( xTimerStart( xTimers[ x ], 0 ) != pdPASS )
  *             {
  *                 // The timer could not be set into the Active state.
  *             }
  *         }
  *     }
- *     
+ *
  *     // ...
  *     // Create tasks here.
  *     // ...
- *     
+ *
  *     // Starting the scheduler will start the timers running as they have already
  *     // been set into the active state.
  *     xTaskStartScheduler();
- *     
+ *
  *     // Should not reach here.
  *     for( ;; );
  * }
  */
-xTimerHandle xTimerCreate( const signed char *pcTimerName, portTickType xTimerPeriod, unsigned portBASE_TYPE uxAutoReload, void * pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) PRIVILEGED_FUNCTION;
+xTimerHandle xTimerCreate( const signed char *pcTimerName, portTickType xTimerPeriodInTicks, unsigned portBASE_TYPE uxAutoReload, void * pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) PRIVILEGED_FUNCTION;
 
 /**
  * void *pvTimerGetTimerID( xTimerHandle xTimer );
  *
  * Returns the ID assigned to the timer.
- * 
+ *
  * IDs are assigned to timers using the pvTimerID parameter of the call to
  * xTimerCreated() that was used to create the timer.
  *
@@ -247,7 +247,7 @@
  * 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 
+ *     1) It has been created but not started, or
  *     2) It is an expired on-shot timer that has not been restarted.
  *
  * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
@@ -272,7 +272,7 @@
  *     else
  *     {
  *         // xTimer is not active, do something else.
- *     } 
+ *     }
  * }
  */
 portBASE_TYPE xTimerIsTimerActive( xTimerHandle xTimer ) PRIVILEGED_FUNCTION;
@@ -281,20 +281,20 @@
  * portBASE_TYPE xTimerStart( xTimerHandle xTimer, portTickType xBlockTime );
  *
  * 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 
- * though a queue called the timer command queue.  The timer command queue is 
- * private to the kernel itself and is not directly accessible to application 
- * code.  The length of the timer command queue is set by the 
+ * public FreeRTOS timer API functions send commands to the timer service task
+ * though a queue called the timer command queue.  The timer command queue is
+ * private to the kernel itself and is not directly accessible to application
+ * code.  The length of the timer command queue is set by the
  * configTIMER_QUEUE_LENGTH configuration constant.
  *
- * xTimerStart() starts a timer that was previously created using the 
+ * xTimerStart() starts a timer that was previously created using the
  * xTimerCreate() API function.  If the timer had already been started and was
  * already in the active state, then xTimerStart() has equivalent functionality
  * to the xTimerReset() API function.
  *
  * Starting a timer ensures the timer is in the active state.  If the timer
  * is not stopped, deleted, or reset in the mean time, the callback function
- * associated with the timer will get called 'n' ticks after xTimerStart() was 
+ * associated with the timer will get called 'n' ticks after xTimerStart() was
  * called, where 'n' is the timers defined period.
  *
  * It is valid to call xTimerStart() before the scheduler has been started, but
@@ -309,38 +309,38 @@
  *
  * @param xBlockTime Specifies the time, in ticks, that the calling task should
  * be held in the Blocked state to wait for the start command to be successfully
- * sent to the timer command queue, should the queue already be full when 
+ * sent to the timer command queue, should the queue already be full when
  * xTimerStart() was called.  xBlockTime is ignored if xTimerStart() is called
- * before the scheduler is started.  
+ * before the scheduler is started.
  *
- * @return pdFAIL will be returned if the start command could not be sent to 
+ * @return pdFAIL will be returned if the start command could not be sent to
  * the timer command queue even after xBlockTime ticks had passed.  pdPASS will
  * be returned if the command was successfully sent to the timer command queue.
  * When the command is actually processed will depend on the priority of the
  * timer service/daemon task relative to other tasks in the system, although the
- * timers expiry time is relative to when xTimerStart() is actually called.  The 
- * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY 
+ * timers expiry time is relative to when xTimerStart() is actually called.  The
+ * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
  * configuration constant.
  *
  * Example usage:
- * 
+ *
  * See the xTimerCreate() API function example usage scenario.
  *
  */
-#define xTimerStart( xTimer, xBlockTime ) xTimerGenericCommand( xTimer, tmrCOMMAND_START, xTaskGetTickCount(), NULL, xBlockTime )
+#define xTimerStart( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xBlockTime ) )
 
 /**
  * portBASE_TYPE xTimerStop( xTimerHandle xTimer, portTickType xBlockTime );
  *
  * 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 
- * though a queue called the timer command queue.  The timer command queue is 
- * private to the kernel itself and is not directly accessible to application 
- * code.  The length of the timer command queue is set by the 
+ * public FreeRTOS timer API functions send commands to the timer service task
+ * though a queue called the timer command queue.  The timer command queue is
+ * private to the kernel itself and is not directly accessible to application
+ * code.  The length of the timer command queue is set by the
  * configTIMER_QUEUE_LENGTH configuration constant.
  *
- * xTimerStop() stops a timer that was previously started using either of the 
- * The xTimerStart(), xTimerReset(), xTimerStartFromISR(), xTimerResetFromISR(), 
+ * xTimerStop() stops a timer that was previously started using either of the
+ * The xTimerStart(), xTimerReset(), xTimerStartFromISR(), xTimerResetFromISR(),
  * xTimerChangePeriod() or xTimerChangePeriodFromISR() API functions.
  *
  * Stopping a timer ensures the timer is not in the active state.
@@ -352,74 +352,74 @@
  *
  * @param xBlockTime Specifies the time, in ticks, that the calling task should
  * be held in the Blocked state to wait for the stop command to be successfully
- * sent to the timer command queue, should the queue already be full when 
+ * sent to the timer command queue, should the queue already be full when
  * xTimerStop() was called.  xBlockTime is ignored if xTimerStop() is called
- * before the scheduler is started.  
+ * before the scheduler is started.
  *
- * @return pdFAIL will be returned if the stop command could not be sent to 
+ * @return pdFAIL will be returned if the stop command could not be sent to
  * the timer command queue even after xBlockTime ticks had passed.  pdPASS will
  * be returned if the command was successfully sent to the timer command queue.
  * When the command is actually processed will depend on the priority of the
- * timer service/daemon task relative to other tasks in the system.  The timer 
- * service/daemon task priority is set by the configTIMER_TASK_PRIORITY 
+ * timer service/daemon task relative to other tasks in the system.  The timer
+ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
  * configuration constant.
  *
  * Example usage:
- * 
+ *
  * See the xTimerCreate() API function example usage scenario.
  *
  */
-#define xTimerStop( xTimer, xBlockTime ) xTimerGenericCommand( xTimer, tmrCOMMAND_STOP, 0, NULL, xBlockTime )
+#define xTimerStop( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0U, NULL, ( xBlockTime ) )
 
 /**
- * portBASE_TYPE xTimerChangePeriod( 	xTimerHandle xTimer, 
+ * portBASE_TYPE xTimerChangePeriod( 	xTimerHandle xTimer,
  *										portTickType xNewPeriod,
  *										portTickType xBlockTime );
  *
  * 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 
- * though a queue called the timer command queue.  The timer command queue is 
- * private to the kernel itself and is not directly accessible to application 
- * code.  The length of the timer command queue is set by the 
+ * public FreeRTOS timer API functions send commands to the timer service task
+ * though a queue called the timer command queue.  The timer command queue is
+ * private to the kernel itself and is not directly accessible to application
+ * code.  The length of the timer command queue is set by the
  * configTIMER_QUEUE_LENGTH configuration constant.
  *
- * xTimerChangePeriod() changes the period of a timer that was previously 
+ * xTimerChangePeriod() changes the period of a timer that was previously
  * created using the xTimerCreate() API function.
  *
  * xTimerChangePeriod() can be called to change the period of an active or
  * dormant state timer.
  *
- * The configUSE_TIMERS configuration constant must be set to 1 for 
+ * The configUSE_TIMERS configuration constant must be set to 1 for
  * xTimerChangePeriod() to be available.
  *
  * @param xTimer The handle of the timer that is having its period changed.
  *
- * @param xNewPeriod The new period for xTimer. Timer periods are specified in 
- * tick periods, so the constant portTICK_RATE_MS can be used to convert a time 
- * that has been specified in milliseconds.  For example, if the timer must 
- * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively, 
- * if the timer must expire after 500ms, then xNewPeriod can be set to 
+ * @param xNewPeriod The new period for xTimer. Timer periods are specified in
+ * tick periods, so the constant portTICK_RATE_MS can be used to convert a time
+ * that has been specified in milliseconds.  For example, if the timer must
+ * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,
+ * if the timer must expire after 500ms, then xNewPeriod can be set to
  * ( 500 / portTICK_RATE_MS ) provided configTICK_RATE_HZ is less than
  * or equal to 1000.
  *
  * @param xBlockTime Specifies the time, in ticks, that the calling task should
- * be held in the Blocked state to wait for the change period command to be 
- * successfully sent to the timer command queue, should the queue already be 
- * full when xTimerChangePeriod() was called.  xBlockTime is ignored if 
- * xTimerChangePeriod() is called before the scheduler is started.  
+ * be held in the Blocked state to wait for the change period command to be
+ * successfully sent to the timer command queue, should the queue already be
+ * full when xTimerChangePeriod() was called.  xBlockTime is ignored if
+ * xTimerChangePeriod() is called before the scheduler is started.
  *
- * @return pdFAIL will be returned if the change period command could not be 
- * sent to the timer command queue even after xBlockTime ticks had passed.  
- * pdPASS will be returned if the command was successfully sent to the timer 
- * command queue.  When the command is actually processed will depend on the 
- * priority of the timer service/daemon task relative to other tasks in the 
- * system.  The timer service/daemon task priority is set by the 
+ * @return pdFAIL will be returned if the change period command could not be
+ * sent to the timer command queue even after xBlockTime ticks had passed.
+ * pdPASS will be returned if the command was successfully sent to the timer
+ * command queue.  When the command is actually processed will depend on the
+ * priority of the timer service/daemon task relative to other tasks in the
+ * system.  The timer service/daemon task priority is set by the
  * configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
  *
  * // This function assumes xTimer has already been created.  If the timer
- * // referenced by xTimer is already active when it is called, then 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
  * // called, then the period of the timer is set to 500ms and the timer is
  * // started.
@@ -445,69 +445,69 @@
  *             // The command could not be sent, even after waiting for 100 ticks
  *             // to pass.  Take appropriate action here.
  *         }
- *     } 
+ *     }
  * }
  */
- #define xTimerChangePeriod( xTimer, xNewPeriod, xBlockTime ) xTimerGenericCommand( xTimer, tmrCOMMAND_CHANGE_PERIOD, xNewPeriod, NULL, xBlockTime )
+ #define xTimerChangePeriod( xTimer, xNewPeriod, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), NULL, ( xBlockTime ) )
 
 /**
  * portBASE_TYPE xTimerDelete( xTimerHandle xTimer, portTickType xBlockTime );
  *
  * 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 
- * though a queue called the timer command queue.  The timer command queue is 
- * private to the kernel itself and is not directly accessible to application 
- * code.  The length of the timer command queue is set by the 
+ * public FreeRTOS timer API functions send commands to the timer service task
+ * though a queue called the timer command queue.  The timer command queue is
+ * private to the kernel itself and is not directly accessible to application
+ * code.  The length of the timer command queue is set by the
  * configTIMER_QUEUE_LENGTH configuration constant.
  *
  * xTimerDelete() deletes a timer that was previously created using the
  * xTimerCreate() API function.
  *
- * The configUSE_TIMERS configuration constant must be set to 1 for 
+ * The configUSE_TIMERS configuration constant must be set to 1 for
  * xTimerDelete() to be available.
  *
  * @param xTimer The handle of the timer being deleted.
  *
  * @param xBlockTime Specifies the time, in ticks, that the calling task should
- * be held in the Blocked state to wait for the delete command to be 
- * successfully sent to the timer command queue, should the queue already be 
- * full when xTimerDelete() was called.  xBlockTime is ignored if xTimerDelete() 
- * is called before the scheduler is started.  
+ * be held in the Blocked state to wait for the delete command to be
+ * successfully sent to the timer command queue, should the queue already be
+ * full when xTimerDelete() was called.  xBlockTime is ignored if xTimerDelete()
+ * is called before the scheduler is started.
  *
- * @return pdFAIL will be returned if the delete command could not be sent to 
+ * @return pdFAIL will be returned if the delete command could not be sent to
  * the timer command queue even after xBlockTime ticks had passed.  pdPASS will
  * be returned if the command was successfully sent to the timer command queue.
  * When the command is actually processed will depend on the priority of the
- * timer service/daemon task relative to other tasks in the system.  The timer 
- * service/daemon task priority is set by the configTIMER_TASK_PRIORITY 
+ * timer service/daemon task relative to other tasks in the system.  The timer
+ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
  * configuration constant.
  *
  * Example usage:
- * 
+ *
  * See the xTimerChangePeriod() API function example usage scenario.
  */
-#define xTimerDelete( xTimer, xBlockTime ) xTimerGenericCommand( xTimer, tmrCOMMAND_DELETE, 0, NULL, xBlockTime )
+#define xTimerDelete( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_DELETE, 0U, NULL, ( xBlockTime ) )
 
 /**
  * portBASE_TYPE xTimerReset( xTimerHandle xTimer, portTickType xBlockTime );
  *
  * 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 
- * though a queue called the timer command queue.  The timer command queue is 
- * private to the kernel itself and is not directly accessible to application 
- * code.  The length of the timer command queue is set by the 
+ * public FreeRTOS timer API functions send commands to the timer service task
+ * though a queue called the timer command queue.  The timer command queue is
+ * private to the kernel itself and is not directly accessible to application
+ * code.  The length of the timer command queue is set by the
  * configTIMER_QUEUE_LENGTH configuration constant.
  *
- * xTimerReset() re-starts a timer that was previously created using the 
+ * xTimerReset() re-starts a timer that was previously created using the
  * xTimerCreate() API function.  If the timer had already been started and was
  * already in the active state, then xTimerReset() will cause the timer to
  * re-evaluate its expiry time so that it is relative to when xTimerReset() was
- * called.  If the timer was in the dormant state then xTimerReset() has 
+ * called.  If the timer was in the dormant state then xTimerReset() has
  * equivalent functionality to the xTimerStart() API function.
  *
  * Resetting a timer ensures the timer is in the active state.  If the timer
  * is not stopped, deleted, or reset in the mean time, the callback function
- * associated with the timer will get called 'n' ticks after xTimerReset() was 
+ * associated with the timer will get called 'n' ticks after xTimerReset() was
  * called, where 'n' is the timers defined period.
  *
  * It is valid to call xTimerReset() before the scheduler has been started, but
@@ -522,23 +522,23 @@
  *
  * @param xBlockTime Specifies the time, in ticks, that the calling task should
  * be held in the Blocked state to wait for the reset command to be successfully
- * sent to the timer command queue, should the queue already be full when 
+ * sent to the timer command queue, should the queue already be full when
  * xTimerReset() was called.  xBlockTime is ignored if xTimerReset() is called
- * before the scheduler is started.  
+ * before the scheduler is started.
  *
- * @return pdFAIL will be returned if the reset command could not be sent to 
+ * @return pdFAIL will be returned if the reset command could not be sent to
  * the timer command queue even after xBlockTime ticks had passed.  pdPASS will
  * be returned if the command was successfully sent to the timer command queue.
  * When the command is actually processed will depend on the priority of the
  * timer service/daemon task relative to other tasks in the system, although the
- * timers expiry time is relative to when xTimerStart() is actually called.  The 
- * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY 
+ * timers expiry time is relative to when xTimerStart() is actually called.  The
+ * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
  * configuration constant.
  *
  * Example usage:
- * 
- * // 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 
+ *
+ * // 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.
  *
  * xTimerHandle xBacklightTimer = NULL;
@@ -556,7 +556,7 @@
  * void vKeyPressEventHandler( char cKey )
  * {
  *     // Ensure the LCD back-light is on, then reset the timer that is
- *     // responsible for turning the back-light off after 5 seconds of 
+ *     // responsible for turning the back-light off after 5 seconds of
  *     // key inactivity.  Wait 10 ticks for the command to be successfully sent
  *     // if it cannot be sent immediately.
  *     vSetBacklightState( BACKLIGHT_ON );
@@ -572,7 +572,7 @@
  * void main( void )
  * {
  * long x;
- * 
+ *
  *     // Create then start the one-shot timer that is responsible for turning
  *     // the back-light off if no keys are pressed within a 5 second period.
  *     xBacklightTimer = xTimerCreate( "BacklightTimer",           // Just a text name, not used by the kernel.
@@ -581,7 +581,7 @@
  *                                     0,                          // The id is not used by the callback so can take any value.
  *                                     vBacklightTimerCallback     // The callback function that switches the LCD back-light off.
  *                                   );
- *                                     
+ *
  *     if( xBacklightTimer == NULL )
  *     {
  *         // The timer was not created.
@@ -590,29 +590,29 @@
  *     {
  *         // Start the timer.  No block time is specified, and even if one was
  *         // it would be ignored because the scheduler has not yet been
- *         // started. 
+ *         // started.
  *         if( xTimerStart( xBacklightTimer, 0 ) != pdPASS )
  *         {
  *             // The timer could not be set into the Active state.
  *         }
  *     }
- *     
+ *
  *     // ...
  *     // Create tasks here.
  *     // ...
- *     
+ *
  *     // Starting the scheduler will start the timer running as it has already
  *     // been set into the active state.
  *     xTaskStartScheduler();
- *     
+ *
  *     // Should not reach here.
  *     for( ;; );
  * }
  */
-#define xTimerReset( xTimer, xBlockTime ) xTimerGenericCommand( xTimer, tmrCOMMAND_START, xTaskGetTickCount(), NULL, xBlockTime )
+#define xTimerReset( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xBlockTime ) )
 
 /**
- * portBASE_TYPE xTimerStartFromISR( 	xTimerHandle xTimer, 
+ * portBASE_TYPE xTimerStartFromISR( 	xTimerHandle xTimer,
  *										portBASE_TYPE *pxHigherPriorityTaskWoken );
  *
  * A version of xTimerStart() that can be called from an interrupt service
@@ -632,20 +632,20 @@
  * xTimerStartFromISR() sets this value to pdTRUE then a context switch should
  * be performed before the interrupt exits.
  *
- * @return pdFAIL will be returned if the start command could not be sent to 
- * the timer command queue.  pdPASS will be returned if the command was 
- * successfully sent to the timer command queue.  When the command is actually 
- * processed will depend on the priority of the timer service/daemon task 
- * relative to other tasks in the system, although the timers expiry time is 
- * relative to when xTimerStartFromISR() is actually called.  The timer service/daemon 
- * task priority is set by the configTIMER_TASK_PRIORITY configuration constant. 
+ * @return pdFAIL will be returned if the start command could not be sent to
+ * the timer command queue.  pdPASS will be returned if the command was
+ * successfully sent to the timer command queue.  When the command is actually
+ * processed will depend on the priority of the timer service/daemon task
+ * relative to other tasks in the system, although the timers expiry time is
+ * relative to when xTimerStartFromISR() is actually called.  The timer service/daemon
+ * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
- * 
- * // 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 
- * // this case, the timer is a one-shot timer, and unlike the example given for 
+ *
+ * // 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
+ * // this case, the timer is a one-shot timer, and unlike the example given for
  * // the xTimerReset() function, the key press event handler is an interrupt
  * // service routine.
  *
@@ -664,7 +664,7 @@
  * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
  *
  *     // Ensure the LCD back-light is on, then restart the timer that is
- *     // responsible for turning the back-light off after 5 seconds of 
+ *     // responsible for turning the back-light off after 5 seconds of
  *     // key inactivity.  This is an interrupt service routine so can only
  *     // call FreeRTOS API functions that end in "FromISR".
  *     vSetBacklightState( BACKLIGHT_ON );
@@ -693,10 +693,10 @@
  *     }
  * }
  */
-#define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( xTimer, tmrCOMMAND_START, xTaskGetTickCountFromISR(), pxHigherPriorityTaskWoken, 0 )
+#define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )
 
 /**
- * portBASE_TYPE xTimerStopFromISR( 	xTimerHandle xTimer, 
+ * portBASE_TYPE xTimerStopFromISR( 	xTimerHandle xTimer,
  *										portBASE_TYPE *pxHigherPriorityTaskWoken );
  *
  * A version of xTimerStop() that can be called from an interrupt service
@@ -716,12 +716,12 @@
  * xTimerStopFromISR() sets this value to pdTRUE then a context switch should
  * be performed before the interrupt exits.
  *
- * @return pdFAIL will be returned if the stop command could not be sent to 
- * the timer command queue.  pdPASS will be returned if the command was 
- * successfully sent to the timer command queue.  When the command is actually 
- * processed will depend on the priority of the timer service/daemon task 
- * relative to other tasks in the system.  The timer service/daemon task 
- * priority is set by the configTIMER_TASK_PRIORITY configuration constant. 
+ * @return pdFAIL will be returned if the stop command could not be sent to
+ * the timer command queue.  pdPASS will be returned if the command was
+ * successfully sent to the timer command queue.  When the command is actually
+ * processed will depend on the priority of the timer service/daemon task
+ * relative to other tasks in the system.  The timer service/daemon task
+ * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
  *
@@ -755,45 +755,45 @@
  *     }
  * }
  */
-#define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( xTimer, tmrCOMMAND_STOP, 0, pxHigherPriorityTaskWoken, 0 )
+#define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0, ( pxHigherPriorityTaskWoken ), 0U )
 
 /**
- * portBASE_TYPE xTimerChangePeriodFromISR( xTimerHandle xTimer, 
+ * portBASE_TYPE xTimerChangePeriodFromISR( xTimerHandle xTimer,
  *											portTickType xNewPeriod,
  *											portBASE_TYPE *pxHigherPriorityTaskWoken );
  *
- * A version of xTimerChangePeriod() that can be called from an interrupt 
+ * A version of xTimerChangePeriod() that can be called from an interrupt
  * service routine.
  *
  * @param xTimer The handle of the timer that is having its period changed.
  *
- * @param xNewPeriod The new period for xTimer. Timer periods are specified in 
- * tick periods, so the constant portTICK_RATE_MS can be used to convert a time 
- * that has been specified in milliseconds.  For example, if the timer must 
- * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively, 
- * if the timer must expire after 500ms, then xNewPeriod can be set to 
+ * @param xNewPeriod The new period for xTimer. Timer periods are specified in
+ * tick periods, so the constant portTICK_RATE_MS can be used to convert a time
+ * that has been specified in milliseconds.  For example, if the timer must
+ * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,
+ * if the timer must expire after 500ms, then xNewPeriod can be set to
  * ( 500 / portTICK_RATE_MS ) provided configTICK_RATE_HZ is less than
  * or equal to 1000.
  *
  * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
  * of its time in the Blocked state, waiting for messages to arrive on the timer
- * command queue.  Calling xTimerChangePeriodFromISR() writes a message to the 
+ * command queue.  Calling xTimerChangePeriodFromISR() writes a message to the
  * timer command queue, so has the potential to transition the timer service/
- * daemon task out of the Blocked state.  If calling xTimerChangePeriodFromISR() 
- * causes the timer service/daemon task to leave the Blocked state, and the 
- * timer service/daemon task has a priority equal to or greater than the 
- * currently executing task (the task that was interrupted), then 
- * *pxHigherPriorityTaskWoken will get set to pdTRUE internally within the 
- * xTimerChangePeriodFromISR() function.  If xTimerChangePeriodFromISR() sets 
- * this value to pdTRUE then a context switch should be performed before the 
+ * daemon task out of the Blocked state.  If calling xTimerChangePeriodFromISR()
+ * causes the timer service/daemon task to leave the Blocked state, and the
+ * timer service/daemon task has a priority equal to or greater than the
+ * currently executing task (the task that was interrupted), then
+ * *pxHigherPriorityTaskWoken will get set to pdTRUE internally within the
+ * xTimerChangePeriodFromISR() function.  If xTimerChangePeriodFromISR() sets
+ * this value to pdTRUE then a context switch should be performed before the
  * interrupt exits.
  *
  * @return pdFAIL will be returned if the command to change the timers period
- * could not be sent to the timer command queue.  pdPASS will be returned if the 
- * command was successfully sent to the timer command queue.  When the command 
- * is actually processed will depend on the priority of the timer service/daemon 
- * task relative to other tasks in the system.  The timer service/daemon task 
- * priority is set by the configTIMER_TASK_PRIORITY configuration constant. 
+ * could not be sent to the timer command queue.  pdPASS will be returned if the
+ * command was successfully sent to the timer command queue.  When the command
+ * is actually processed will depend on the priority of the timer service/daemon
+ * task relative to other tasks in the system.  The timer service/daemon task
+ * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
  *
@@ -811,7 +811,7 @@
  *     // FreeRTOS API functions that end in "FromISR" can be used.
  *     if( xTimerChangePeriodFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )
  *     {
- *         // The command to change the timers period was not executed 
+ *         // The command to change the timers period was not executed
  *         // successfully.  Take appropriate action here.
  *     }
  *
@@ -827,10 +827,10 @@
  *     }
  * }
  */
-#define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) xTimerGenericCommand( xTimer, tmrCOMMAND_CHANGE_PERIOD, xNewPeriod, pxHigherPriorityTaskWoken, 0 )
+#define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), ( pxHigherPriorityTaskWoken ), 0U )
 
 /**
- * portBASE_TYPE xTimerResetFromISR( 	xTimerHandle xTimer, 
+ * portBASE_TYPE xTimerResetFromISR( 	xTimerHandle xTimer,
  *										portBASE_TYPE *pxHigherPriorityTaskWoken );
  *
  * A version of xTimerReset() that can be called from an interrupt service
@@ -851,20 +851,20 @@
  * xTimerResetFromISR() sets this value to pdTRUE then a context switch should
  * be performed before the interrupt exits.
  *
- * @return pdFAIL will be returned if the reset command could not be sent to 
- * the timer command queue.  pdPASS will be returned if the command was 
- * successfully sent to the timer command queue.  When the command is actually 
- * processed will depend on the priority of the timer service/daemon task 
- * relative to other tasks in the system, although the timers expiry time is 
- * relative to when xTimerResetFromISR() is actually called.  The timer service/daemon 
- * task priority is set by the configTIMER_TASK_PRIORITY configuration constant. 
+ * @return pdFAIL will be returned if the reset command could not be sent to
+ * the timer command queue.  pdPASS will be returned if the command was
+ * successfully sent to the timer command queue.  When the command is actually
+ * processed will depend on the priority of the timer service/daemon task
+ * relative to other tasks in the system, although the timers expiry time is
+ * relative to when xTimerResetFromISR() is actually called.  The timer service/daemon
+ * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.
  *
  * Example usage:
- * 
- * // 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 
- * // this case, the timer is a one-shot timer, and unlike the example given for 
+ *
+ * // 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
+ * // this case, the timer is a one-shot timer, and unlike the example given for
  * // the xTimerReset() function, the key press event handler is an interrupt
  * // service routine.
  *
@@ -883,7 +883,7 @@
  * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
  *
  *     // Ensure the LCD back-light is on, then reset the timer that is
- *     // responsible for turning the back-light off after 5 seconds of 
+ *     // responsible for turning the back-light off after 5 seconds of
  *     // key inactivity.  This is an interrupt service routine so can only
  *     // call FreeRTOS API functions that end in "FromISR".
  *     vSetBacklightState( BACKLIGHT_ON );
@@ -912,7 +912,7 @@
  *     }
  * }
  */
-#define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( xTimer, tmrCOMMAND_START, xTaskGetTickCountFromISR(), pxHigherPriorityTaskWoken, 0 )
+#define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )
 
 /*
  * Functions beyond this part are not part of the public API and are intended
diff --git a/Source/queue.c b/Source/queue.c
index 25374c7..f5ce8bb 100644
--- a/Source/queue.c
+++ b/Source/queue.c
@@ -144,6 +144,7 @@
 signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
 signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
 unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue ) PRIVILEGED_FUNCTION;
+void vQueueWaitForMessageRestricted( xQueueHandle pxQueue, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;
 
 /*
  * Co-routine queue functions differ from task queue functions.  Co-routines are
@@ -1285,7 +1286,7 @@
 			xReturn = pdPASS;
 
 			/* Were any co-routines waiting for data to become available? */
-			if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) )
+			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
 			{
 				/* In this instance the co-routine could be placed directly
 				into the ready list as we are within a critical section.
@@ -1360,7 +1361,7 @@
 			xReturn = pdPASS;
 
 			/* Were any co-routines waiting for space to become available? */
-			if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) )
+			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
 			{
 				/* In this instance the co-routine could be placed directly
 				into the ready list as we are within a critical section.
@@ -1399,7 +1400,7 @@
 		co-routine has not already been woken. */
 		if( !xCoRoutinePreviouslyWoken )
 		{
-			if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) )
+			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
 			{
 				if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
 				{
@@ -1434,7 +1435,7 @@
 
 		if( !( *pxCoRoutineWoken ) )
 		{
-			if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) )
+			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
 			{
 				if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
 				{
@@ -1463,7 +1464,7 @@
 
 		/* See if there is an empty space in the registry.  A NULL name denotes
 		a free slot. */
-		for( ux = 0; ux < configQUEUE_REGISTRY_SIZE; ux++ )
+		for( ux = ( unsigned portBASE_TYPE ) 0U; ux < configQUEUE_REGISTRY_SIZE; ux++ )
 		{
 			if( xQueueRegistry[ ux ].pcQueueName == NULL )
 			{
@@ -1486,7 +1487,7 @@
 
 		/* See if the handle of the queue being unregistered in actually in the
 		registry. */
-		for( ux = 0; ux < configQUEUE_REGISTRY_SIZE; ux++ )
+		for( ux = ( unsigned portBASE_TYPE ) 0U; ux < configQUEUE_REGISTRY_SIZE; ux++ )
 		{
 			if( xQueueRegistry[ ux ].xHandle == xQueue )
 			{
@@ -1506,7 +1507,7 @@
 	void vQueueWaitForMessageRestricted( xQueueHandle pxQueue, portTickType xTicksToWait )
 	{
 		/* This function should not be called by application code hence the
-		'Restricted' in its name.  It is not part of the public API.  It is 
+		'Restricted' in its name.  It is not part of the public API.  It is
 		designed for use by kernel code, and has special calling requirements.
 		It can result in vListInsert() being called on a list that can only
 		possibly ever have one item in it, so the list will be fast, but even
diff --git a/Source/tasks.c b/Source/tasks.c
index aad896a..0c48624 100644
--- a/Source/tasks.c
+++ b/Source/tasks.c
@@ -329,6 +329,7 @@
 
 /* Callback function prototypes. --------------------------*/
 extern void vApplicationStackOverflowHook( xTaskHandle *pxTask, signed char *pcTaskName );
+extern void vApplicationTickHook( void );
 		
 /* File private functions. --------------------------------*/
 
@@ -1298,25 +1299,25 @@
 			{
 				uxQueue--;
 
-				if( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) )
+				if( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) == pdFALSE )
 				{
 					prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &( pxReadyTasksLists[ uxQueue ] ), tskREADY_CHAR );
 				}
 			}while( uxQueue > ( unsigned short ) tskIDLE_PRIORITY );
 
-			if( !listLIST_IS_EMPTY( pxDelayedTaskList ) )
+			if( listLIST_IS_EMPTY( pxDelayedTaskList ) == pdFALSE )
 			{
 				prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) pxDelayedTaskList, tskBLOCKED_CHAR );
 			}
 
-			if( !listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) )
+			if( listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) == pdFALSE )
 			{
 				prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) pxOverflowDelayedTaskList, tskBLOCKED_CHAR );
 			}
 
 			#if( INCLUDE_vTaskDelete == 1 )
 			{
-				if( !listLIST_IS_EMPTY( &xTasksWaitingTermination ) )
+				if( listLIST_IS_EMPTY( &xTasksWaitingTermination ) == pdFALSE )
 				{
 					prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, tskDELETED_CHAR );
 				}
@@ -1325,7 +1326,7 @@
 
 			#if ( INCLUDE_vTaskSuspend == 1 )
 			{
-				if( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )
+				if( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )
 				{
 					prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, tskSUSPENDED_CHAR );
 				}
@@ -1373,25 +1374,25 @@
 			{
 				uxQueue--;
 
-				if( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) )
+				if( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) == pdFALSE )
 				{
 					prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &( pxReadyTasksLists[ uxQueue ] ), ulTotalRunTime );
 				}
 			}while( uxQueue > ( unsigned short ) tskIDLE_PRIORITY );
 
-			if( !listLIST_IS_EMPTY( pxDelayedTaskList ) )
+			if( listLIST_IS_EMPTY( pxDelayedTaskList ) == pdFALSE )
 			{
 				prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) pxDelayedTaskList, ulTotalRunTime );
 			}
 
-			if( !listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) )
+			if( listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) == pdFALSE )
 			{
 				prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) pxOverflowDelayedTaskList, ulTotalRunTime );
 			}
 
 			#if ( INCLUDE_vTaskDelete == 1 )
 			{
-				if( !listLIST_IS_EMPTY( &xTasksWaitingTermination ) )
+				if( listLIST_IS_EMPTY( &xTasksWaitingTermination ) == pdFALSE )
 				{
 					prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, ulTotalRunTime );
 				}
@@ -1400,7 +1401,7 @@
 
 			#if ( INCLUDE_vTaskSuspend == 1 )
 			{
-				if( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )
+				if( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )
 				{
 					prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, ulTotalRunTime );
 				}
@@ -1512,8 +1513,6 @@
 		scheduler is locked. */
 		#if ( configUSE_TICK_HOOK == 1 )
 		{
-			extern void vApplicationTickHook( void );
-
 			vApplicationTickHook();
 		}
 		#endif
@@ -1521,11 +1520,9 @@
 
 	#if ( configUSE_TICK_HOOK == 1 )
 	{
-		extern void vApplicationTickHook( void );
-
 		/* Guard against the tick hook being called when the missed tick
 		count is being unwound (when the scheduler is being unlocked. */
-		if( uxMissedTicks == 0 )
+		if( uxMissedTicks == ( unsigned portBASE_TYPE ) 0U )
 		{
 			vApplicationTickHook();
 		}
@@ -1550,7 +1547,7 @@
 		{
 			usQueue--;
 
-			while( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ usQueue ] ) ) )
+			while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ usQueue ] ) ) == pdFALSE )
 			{
 				listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &( pxReadyTasksLists[ usQueue ] ) );
 				vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );
@@ -1560,7 +1557,7 @@
 		}while( usQueue > ( unsigned short ) tskIDLE_PRIORITY );
 
 		/* Remove any TCB's from the delayed queue. */
-		while( !listLIST_IS_EMPTY( &xDelayedTaskList1 ) )
+		while( listLIST_IS_EMPTY( &xDelayedTaskList1 ) == pdFALSE )
 		{
 			listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList1 );
 			vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );
@@ -1569,7 +1566,7 @@
 		}
 
 		/* Remove any TCB's from the overflow delayed queue. */
-		while( !listLIST_IS_EMPTY( &xDelayedTaskList2 ) )
+		while( listLIST_IS_EMPTY( &xDelayedTaskList2 ) == pdFALSE )
 		{
 			listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList2 );
 			vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );
@@ -1577,7 +1574,7 @@
 			prvDeleteTCB( ( tskTCB * ) pxTCB );
 		}
 
-		while( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )
+		while( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )
 		{
 			listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xSuspendedTaskList );
 			vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );
@@ -1591,7 +1588,7 @@
 
 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
 
-	void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxTagValue )
+	void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction )
 	{
 	tskTCB *xTCB;
 
@@ -1608,7 +1605,7 @@
 		/* Save the hook function in the TCB.  A critical section is required as
 		the value can be accessed from an interrupt. */
 		taskENTER_CRITICAL();
-			xTCB->pxTaskTag = pxTagValue;
+			xTCB->pxTaskTag = pxHookFunction;
 		taskEXIT_CRITICAL();
 	}
 
@@ -2374,7 +2371,7 @@
 
 /*-----------------------------------------------------------*/
 
-#if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )
+#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
 
 	xTaskHandle xTaskGetCurrentTaskHandle( void )
 	{
@@ -2392,7 +2389,7 @@
 
 /*-----------------------------------------------------------*/
 
-#if ( INCLUDE_xTaskGetSchedulerState == 1 )
+#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
 
 	portBASE_TYPE xTaskGetSchedulerState( void )
 	{
diff --git a/Source/timers.c b/Source/timers.c
index 62c8c31..44071a1 100644
--- a/Source/timers.c
+++ b/Source/timers.c
@@ -65,7 +65,7 @@
 
 /* This entire source file will be skipped if the application is not configured
 to include software timer functionality.  This #if is closed at the very bottom
-of this file.  If you want to include software timer functionality then ensure 
+of this file.  If you want to include software timer functionality then ensure
 configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
 #if ( configUSE_TIMERS == 1 )
 
@@ -177,7 +177,7 @@
 
 	if( xTimerQueue != NULL )
 	{
-		xReturn = xTaskCreate( prvTimerTask, ( const signed char * ) "Tmr Svc", configTIMER_TASK_STACK_DEPTH, NULL, configTIMER_TASK_PRIORITY, NULL);
+		xReturn = xTaskCreate( prvTimerTask, ( const signed char * ) "Tmr Svc", ( unsigned short ) configTIMER_TASK_STACK_DEPTH, NULL, ( unsigned portBASE_TYPE ) configTIMER_TASK_PRIORITY, NULL);
 	}
 
 	configASSERT( xReturn );
@@ -274,7 +274,7 @@
 
 	/* If the timer is an auto reload timer then calculate the next
 	expiry time and re-insert the timer in the list of active timers. */
-	if( pxTimer->uxAutoReload == pdTRUE )
+	if( pxTimer->uxAutoReload == ( unsigned portBASE_TYPE ) pdTRUE )
 	{
 		/* This is the only time a timer is inserted into a list using
 		a time relative to anything other than the current time.  It
@@ -499,7 +499,7 @@
 					list.  Process it now. */
 					pxTimer->pxCallbackFunction( ( xTimerHandle ) pxTimer );
 
-					if( pxTimer->uxAutoReload == pdTRUE )
+					if( pxTimer->uxAutoReload == ( unsigned portBASE_TYPE ) pdTRUE )
 					{
 						xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START, xMessage.xMessageValue + pxTimer->xTimerPeriodInTicks, NULL, tmrNO_DELAY );
 						configASSERT( xResult );
@@ -560,7 +560,7 @@
 		have not yet been switched. */
 		pxTimer->pxCallbackFunction( ( xTimerHandle ) pxTimer );
 
-		if( pxTimer->uxAutoReload == pdTRUE )
+		if( pxTimer->uxAutoReload == ( unsigned portBASE_TYPE ) pdTRUE )
 		{
 			/* Calculate the reload value, and if the reload value results in
 			the timer going into the same timer list then it has already expired
@@ -603,7 +603,7 @@
 			vListInitialise( &xActiveTimerList2 );
 			pxCurrentTimerList = &xActiveTimerList1;
 			pxOverflowTimerList = &xActiveTimerList2;
-			xTimerQueue = xQueueCreate( configTIMER_QUEUE_LENGTH, sizeof( xTIMER_MESSAGE ) );
+			xTimerQueue = xQueueCreate( ( unsigned portBASE_TYPE ) configTIMER_QUEUE_LENGTH, sizeof( xTIMER_MESSAGE ) );
 		}
 	}
 	taskEXIT_CRITICAL();