/*\r
- FreeRTOS V6.1.1 - Copyright (C) 2011 Real Time Engineers Ltd.\r
+ FreeRTOS V7.0.1 - Copyright (C) 2011 Real Time Engineers Ltd.\r
+ \r
+\r
+ FreeRTOS supports many tools and architectures. V7.0.0 is sponsored by:\r
+ Atollic AB - Atollic provides professional embedded systems development \r
+ tools for C/C++ development, code analysis and test automation. \r
+ See http://www.atollic.com\r
+ \r
\r
***************************************************************************\r
- * *\r
- * If you are: *\r
- * *\r
- * + New to FreeRTOS, *\r
- * + Wanting to learn FreeRTOS or multitasking in general quickly *\r
- * + Looking for basic training, *\r
- * + Wanting to improve your FreeRTOS skills and productivity *\r
- * *\r
- * then take a look at the FreeRTOS books - available as PDF or paperback *\r
- * *\r
- * "Using the FreeRTOS Real Time Kernel - a Practical Guide" *\r
- * http://www.FreeRTOS.org/Documentation *\r
- * *\r
- * A pdf reference manual is also available. Both are usually delivered *\r
- * to your inbox within 20 minutes to two hours when purchased between 8am *\r
- * and 8pm GMT (although please allow up to 24 hours in case of *\r
- * exceptional circumstances). Thank you for your support! *\r
- * *\r
+ * *\r
+ * FreeRTOS tutorial books are available in pdf and paperback. *\r
+ * Complete, revised, and edited pdf reference manuals are also *\r
+ * available. *\r
+ * *\r
+ * Purchasing FreeRTOS documentation will not only help you, by *\r
+ * ensuring you get running as quickly as possible and with an *\r
+ * in-depth knowledge of how to use FreeRTOS, it will also help *\r
+ * the FreeRTOS project to continue with its mission of providing *\r
+ * professional grade, cross platform, de facto standard solutions *\r
+ * for microcontrollers - completely free of charge! *\r
+ * *\r
+ * >>> See http://www.FreeRTOS.org/Documentation for details. <<< *\r
+ * *\r
+ * Thank you for using FreeRTOS, and thank you for your support! *\r
+ * *\r
***************************************************************************\r
\r
+\r
This file is part of the FreeRTOS distribution.\r
\r
FreeRTOS is free software; you can redistribute it and/or modify it under\r
the terms of the GNU General Public License (version 2) as published by the\r
Free Software Foundation AND MODIFIED BY the FreeRTOS exception.\r
- ***NOTE*** The exception to the GPL is included to allow you to distribute\r
- a combined work that includes FreeRTOS without being obliged to provide the\r
- source code for proprietary components outside of the FreeRTOS kernel.\r
- FreeRTOS is distributed in the hope that it will be useful, but WITHOUT\r
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\r
+ >>>NOTE<<< The modification to the GPL is included to allow you to\r
+ distribute a combined work that includes FreeRTOS without being obliged to\r
+ provide the source code for proprietary components outside of the FreeRTOS\r
+ kernel. FreeRTOS is distributed in the hope that it will be useful, but\r
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
+ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\r
more details. You should have received a copy of the GNU General Public\r
License and the FreeRTOS license exception along with FreeRTOS; if not it\r
can be viewed here: http://www.freertos.org/a00114.html and also obtained\r
\r
#endif\r
\r
+#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )\r
+ \r
+ PRIVILEGED_DATA static xTaskHandle xIdleTaskHandle = NULL;\r
+ \r
+#endif\r
+\r
/* File private variables. --------------------------------*/\r
PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxCurrentNumberOfTasks = ( unsigned portBASE_TYPE ) 0;\r
PRIVILEGED_DATA static volatile portTickType xTickCount = ( portTickType ) 0;\r
*/\r
#define prvCheckDelayedTasks() \\r
{ \\r
-register tskTCB *pxTCB; \\r
portTickType xItemValue; \\r
\\r
/* Is the tick count greater than or equal to the wake time of the first \\r
\r
/* Callback function prototypes. --------------------------*/\r
extern void vApplicationStackOverflowHook( xTaskHandle *pxTask, signed char *pcTaskName );\r
+extern void vApplicationTickHook( void );\r
\r
/* File private functions. --------------------------------*/\r
\r
uxPriority &= ~portPRIVILEGE_BIT;\r
#endif /* portUSING_MPU_WRAPPERS == 1 */\r
\r
- /* Check the alignment of the stack buffer is correct. */\r
- configASSERT( !( ( unsigned long ) pxNewTCB->pxStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) );\r
-\r
/* Calculate the top of stack address. This depends on whether the\r
stack grows from high memory to low (as per the 80x86) or visa versa.\r
portSTACK_GROWTH is used to make the result positive or negative as\r
pxTopOfStack = ( portSTACK_TYPE * ) ( ( ( unsigned long ) pxTopOfStack ) & ( ( unsigned long ) ~portBYTE_ALIGNMENT_MASK ) );\r
\r
/* Check the alignment of the calculated top of stack is correct. */\r
- configASSERT( !( ( unsigned long ) pxTopOfStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) );\r
+ configASSERT( ( ( ( unsigned long ) pxTopOfStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
}\r
#else\r
{\r
pxTopOfStack = pxNewTCB->pxStack;\r
+ \r
+ /* Check the alignment of the stack buffer is correct. */\r
+ configASSERT( ( ( ( unsigned long ) pxNewTCB->pxStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
\r
/* If we want to use stack checking on architectures that use\r
a positive stack growth direction then we also need to store the\r
#endif\r
\r
/* Check the alignment of the initialised stack. */\r
- configASSERT( !( ( unsigned long ) pxNewTCB->pxTopOfStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) );\r
+ configASSERT( ( ( ( unsigned long ) pxNewTCB->pxTopOfStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
\r
if( ( void * ) pxCreatedTask != NULL )\r
{\r
/* The scheduler is not running, but the task that was pointed\r
to by pxCurrentTCB has just been suspended and pxCurrentTCB\r
must be adjusted to point to a different task. */\r
- if( uxCurrentNumberOfTasks == ( unsigned portBASE_TYPE ) 1U )\r
+ if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) \r
{\r
- /* No other tasks are defined, so set pxCurrentTCB back to\r
+ /* No other tasks are ready, so set pxCurrentTCB back to\r
NULL so when the next task is created pxCurrentTCB will\r
be set to point to it no matter what its relative priority\r
is. */\r
portBASE_TYPE xReturn;\r
\r
/* Add the idle task at the lowest priority. */\r
- xReturn = xTaskCreate( prvIdleTask, ( signed char * ) "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), ( xTaskHandle * ) NULL );\r
+ #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )\r
+ {\r
+ /* Create the idle task, storing its handle in xIdleTaskHandle so it can\r
+ be returned by the xTaskGetIdleTaskHandle() function. */\r
+ xReturn = xTaskCreate( prvIdleTask, ( signed char * ) "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle );\r
+ }\r
+ #else\r
+ {\r
+ /* Create the idle task without storing its handle. */\r
+ xReturn = xTaskCreate( prvIdleTask, ( signed char * ) "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), NULL );\r
+ }\r
+ #endif\r
\r
#if ( configUSE_TIMERS == 1 )\r
{\r
}\r
/*-----------------------------------------------------------*/\r
\r
+signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery )\r
+{\r
+tskTCB *pxTCB;\r
+\r
+ /* If null is passed in here then the name of the calling task is being queried. */\r
+ pxTCB = prvGetTCBFromHandle( xTaskToQuery );\r
+ configASSERT( pxTCB );\r
+ return &( pxTCB->pcTaskName[ 0 ] );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
#if ( configUSE_TRACE_FACILITY == 1 )\r
\r
void vTaskList( signed char *pcWriteBuffer )\r
{\r
uxQueue--;\r
\r
- if( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) )\r
+ if( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) == pdFALSE )\r
{\r
prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &( pxReadyTasksLists[ uxQueue ] ), tskREADY_CHAR );\r
}\r
}while( uxQueue > ( unsigned short ) tskIDLE_PRIORITY );\r
\r
- if( !listLIST_IS_EMPTY( pxDelayedTaskList ) )\r
+ if( listLIST_IS_EMPTY( pxDelayedTaskList ) == pdFALSE )\r
{\r
prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) pxDelayedTaskList, tskBLOCKED_CHAR );\r
}\r
\r
- if( !listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) )\r
+ if( listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) == pdFALSE )\r
{\r
prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) pxOverflowDelayedTaskList, tskBLOCKED_CHAR );\r
}\r
\r
#if( INCLUDE_vTaskDelete == 1 )\r
{\r
- if( !listLIST_IS_EMPTY( &xTasksWaitingTermination ) )\r
+ if( listLIST_IS_EMPTY( &xTasksWaitingTermination ) == pdFALSE )\r
{\r
prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, tskDELETED_CHAR );\r
}\r
\r
#if ( INCLUDE_vTaskSuspend == 1 )\r
{\r
- if( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )\r
+ if( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )\r
{\r
prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, tskSUSPENDED_CHAR );\r
}\r
{\r
uxQueue--;\r
\r
- if( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) )\r
+ if( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) == pdFALSE )\r
{\r
prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &( pxReadyTasksLists[ uxQueue ] ), ulTotalRunTime );\r
}\r
}while( uxQueue > ( unsigned short ) tskIDLE_PRIORITY );\r
\r
- if( !listLIST_IS_EMPTY( pxDelayedTaskList ) )\r
+ if( listLIST_IS_EMPTY( pxDelayedTaskList ) == pdFALSE )\r
{\r
prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) pxDelayedTaskList, ulTotalRunTime );\r
}\r
\r
- if( !listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) )\r
+ if( listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) == pdFALSE )\r
{\r
prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) pxOverflowDelayedTaskList, ulTotalRunTime );\r
}\r
\r
#if ( INCLUDE_vTaskDelete == 1 )\r
{\r
- if( !listLIST_IS_EMPTY( &xTasksWaitingTermination ) )\r
+ if( listLIST_IS_EMPTY( &xTasksWaitingTermination ) == pdFALSE )\r
{\r
prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, ulTotalRunTime );\r
}\r
\r
#if ( INCLUDE_vTaskSuspend == 1 )\r
{\r
- if( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )\r
+ if( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )\r
{\r
prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, ulTotalRunTime );\r
}\r
}\r
\r
#endif\r
+/*----------------------------------------------------------*/\r
\r
+#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )\r
\r
+ xTaskHandle xTaskGetIdleTaskHandle( void )\r
+ {\r
+ /* If xTaskGetIdleTaskHandle() is called before the scheduler has been\r
+ started, then xIdleTaskHandle will be NULL. */\r
+ configASSERT( ( xIdleTaskHandle != NULL ) );\r
+ return xIdleTaskHandle;\r
+ }\r
+ \r
+#endif\r
\r
/*-----------------------------------------------------------\r
* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES\r
\r
void vTaskIncrementTick( void )\r
{\r
+tskTCB * pxTCB;\r
+\r
/* Called by the portable layer each time a tick interrupt occurs.\r
Increments the tick then checks to see if the new tick value will cause any\r
tasks to be unblocked. */\r
\r
if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )\r
{\r
- /* The delayed list is empty. Set xNextTaskUnblockTime to the\r
- maximum possible value so it is extremely unlikely that the\r
- if( xTickCount >= xNextTaskUnblockTime ) test will pass\r
- until there is an item in the delayed list. */\r
+ /* The new current delayed list is empty. Set \r
+ xNextTaskUnblockTime to the maximum possible value so it is \r
+ extremely unlikely that the \r
+ if( xTickCount >= xNextTaskUnblockTime ) test will pass until \r
+ there is an item in the delayed list. */\r
xNextTaskUnblockTime = portMAX_DELAY;\r
}\r
else\r
{\r
- tskTCB * pxTCB;\r
-\r
- /* The delayed list is not empty, get the value of the item at\r
- the head of the delayed list. This is the time at which the\r
- task at the head of the delayed list should be removed from\r
- the Blocked state. */\r
+ /* The new current delayed list is not empty, get the value of \r
+ the item at the head of the delayed list. This is the time at \r
+ which the task at the head of the delayed list should be removed \r
+ from the Blocked state. */\r
pxTCB = ( tskTCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );\r
xNextTaskUnblockTime = listGET_LIST_ITEM_VALUE( &( pxTCB->xGenericListItem ) );\r
}\r
scheduler is locked. */\r
#if ( configUSE_TICK_HOOK == 1 )\r
{\r
- extern void vApplicationTickHook( void );\r
-\r
vApplicationTickHook();\r
}\r
#endif\r
\r
#if ( configUSE_TICK_HOOK == 1 )\r
{\r
- extern void vApplicationTickHook( void );\r
-\r
/* Guard against the tick hook being called when the missed tick\r
count is being unwound (when the scheduler is being unlocked. */\r
- if( uxMissedTicks == 0 )\r
+ if( uxMissedTicks == ( unsigned portBASE_TYPE ) 0U )\r
{\r
vApplicationTickHook();\r
}\r
{\r
usQueue--;\r
\r
- while( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ usQueue ] ) ) )\r
+ while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ usQueue ] ) ) == pdFALSE )\r
{\r
listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &( pxReadyTasksLists[ usQueue ] ) );\r
vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
}while( usQueue > ( unsigned short ) tskIDLE_PRIORITY );\r
\r
/* Remove any TCB's from the delayed queue. */\r
- while( !listLIST_IS_EMPTY( &xDelayedTaskList1 ) )\r
+ while( listLIST_IS_EMPTY( &xDelayedTaskList1 ) == pdFALSE )\r
{\r
listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList1 );\r
vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
}\r
\r
/* Remove any TCB's from the overflow delayed queue. */\r
- while( !listLIST_IS_EMPTY( &xDelayedTaskList2 ) )\r
+ while( listLIST_IS_EMPTY( &xDelayedTaskList2 ) == pdFALSE )\r
{\r
listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList2 );\r
vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
prvDeleteTCB( ( tskTCB * ) pxTCB );\r
}\r
\r
- while( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )\r
+ while( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )\r
{\r
listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xSuspendedTaskList );\r
vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
\r
#if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
\r
- void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxTagValue )\r
+ void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction )\r
{\r
tskTCB *xTCB;\r
\r
/* Save the hook function in the TCB. A critical section is required as\r
the value can be accessed from an interrupt. */\r
taskENTER_CRITICAL();\r
- xTCB->pxTaskTag = pxTagValue;\r
+ xTCB->pxTaskTag = pxHookFunction;\r
taskEXIT_CRITICAL();\r
}\r
\r
{\r
tskTCB *pxTCB;\r
\r
- configASSERT( xRegions );\r
-\r
if( xTaskToModify == pxCurrentTCB )\r
{\r
xTaskToModify = NULL;\r
vListInsert( ( xList * ) pxDelayedTaskList, ( xListItem * ) &( pxCurrentTCB->xGenericListItem ) );\r
\r
/* If the task entering the blocked state was placed at the head of the\r
- list of blocked tasks then xNextTaskUnmblockTime needs to be updated\r
+ list of blocked tasks then xNextTaskUnblockTime needs to be updated\r
too. */\r
if( xTimeToWake < xNextTaskUnblockTime )\r
{\r
\r
/*-----------------------------------------------------------*/\r
\r
-#if ( INCLUDE_xTaskGetCurrentTaskHandle == 1 )\r
+#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )\r
\r
xTaskHandle xTaskGetCurrentTaskHandle( void )\r
{\r
\r
/*-----------------------------------------------------------*/\r
\r
-#if ( INCLUDE_xTaskGetSchedulerState == 1 )\r
+#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )\r
\r
portBASE_TYPE xTaskGetSchedulerState( void )\r
{\r
projects / freertos / blobdiff