/*\r
- FreeRTOS V6.1.1 - Copyright (C) 2011 Real Time Engineers Ltd.\r
+ FreeRTOS V7.0.2 - Copyright (C) 2011 Real Time Engineers Ltd.\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
#endif\r
\r
#if ( configUSE_TRACE_FACILITY == 1 )\r
- unsigned portBASE_TYPE uxTCBNumber; /*< This is used for tracing the scheduler and making debugging easier only. */\r
+ unsigned portBASE_TYPE uxTCBNumber; /*< This stores a number that increments each time a TCB is created. It allows debuggers to determine when a task has been deleted and then recreated. */\r
+ unsigned portBASE_TYPE uxTaskNumber; /*< This stores a number specifically for use by third party trace code. */\r
#endif\r
\r
#if ( configUSE_MUTEXES == 1 )\r
\r
#if ( INCLUDE_vTaskDelete == 1 )\r
\r
- PRIVILEGED_DATA static volatile xList xTasksWaitingTermination; /*< Tasks that have been deleted - but the their memory not yet freed. */\r
- PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxTasksDeleted = ( unsigned portBASE_TYPE ) 0;\r
+ PRIVILEGED_DATA static xList xTasksWaitingTermination; /*< Tasks that have been deleted - but the their memory not yet freed. */\r
+ PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxTasksDeleted = ( unsigned portBASE_TYPE ) 0U;\r
\r
#endif\r
\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
+PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxCurrentNumberOfTasks = ( unsigned portBASE_TYPE ) 0U;\r
+PRIVILEGED_DATA static volatile portTickType xTickCount = ( portTickType ) 0U;\r
PRIVILEGED_DATA static unsigned portBASE_TYPE uxTopUsedPriority = tskIDLE_PRIORITY;\r
PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxTopReadyPriority = tskIDLE_PRIORITY;\r
PRIVILEGED_DATA static volatile signed portBASE_TYPE xSchedulerRunning = pdFALSE;\r
PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxSchedulerSuspended = ( unsigned portBASE_TYPE ) pdFALSE;\r
-PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxMissedTicks = ( unsigned portBASE_TYPE ) 0;\r
+PRIVILEGED_DATA static volatile unsigned portBASE_TYPE uxMissedTicks = ( unsigned portBASE_TYPE ) 0U;\r
PRIVILEGED_DATA static volatile portBASE_TYPE xMissedYield = ( portBASE_TYPE ) pdFALSE;\r
PRIVILEGED_DATA static volatile portBASE_TYPE xNumOfOverflows = ( portBASE_TYPE ) 0;\r
-PRIVILEGED_DATA static unsigned portBASE_TYPE uxTaskNumber = ( unsigned portBASE_TYPE ) 0;\r
+PRIVILEGED_DATA static unsigned portBASE_TYPE uxTCBNumber = ( unsigned portBASE_TYPE ) 0U;\r
PRIVILEGED_DATA static portTickType xNextTaskUnblockTime = ( portTickType ) portMAX_DELAY;\r
\r
#if ( configGENERATE_RUN_TIME_STATS == 1 )\r
#define tskDELETED_CHAR ( ( signed char ) 'D' )\r
#define tskSUSPENDED_CHAR ( ( signed char ) 'S' )\r
\r
-/*\r
- * Macros and private variables used by the trace facility.\r
- */\r
-#if ( configUSE_TRACE_FACILITY == 1 )\r
-\r
- #define tskSIZE_OF_EACH_TRACE_LINE ( ( unsigned long ) ( sizeof( unsigned long ) + sizeof( unsigned long ) ) )\r
- PRIVILEGED_DATA static volatile signed char * volatile pcTraceBuffer;\r
- PRIVILEGED_DATA static signed char *pcTraceBufferStart;\r
- PRIVILEGED_DATA static signed char *pcTraceBufferEnd;\r
- PRIVILEGED_DATA static signed portBASE_TYPE xTracing = pdFALSE;\r
- static unsigned portBASE_TYPE uxPreviousTask = 255U;\r
- PRIVILEGED_DATA static char pcStatusString[ 50 ];\r
-\r
-#endif\r
-\r
-/*-----------------------------------------------------------*/\r
-\r
-/*\r
- * Macro that writes a trace of scheduler activity to a buffer. This trace\r
- * shows which task is running when and is very useful as a debugging tool.\r
- * As this macro is called each context switch it is a good idea to undefine\r
- * it if not using the facility.\r
- */\r
-#if ( configUSE_TRACE_FACILITY == 1 )\r
-\r
- #define vWriteTraceToBuffer() \\r
- { \\r
- if( xTracing ) \\r
- { \\r
- if( uxPreviousTask != pxCurrentTCB->uxTCBNumber ) \\r
- { \\r
- if( ( pcTraceBuffer + tskSIZE_OF_EACH_TRACE_LINE ) < pcTraceBufferEnd ) \\r
- { \\r
- uxPreviousTask = pxCurrentTCB->uxTCBNumber; \\r
- *( unsigned long * ) pcTraceBuffer = ( unsigned long ) xTickCount; \\r
- pcTraceBuffer += sizeof( unsigned long ); \\r
- *( unsigned long * ) pcTraceBuffer = ( unsigned long ) uxPreviousTask; \\r
- pcTraceBuffer += sizeof( unsigned long ); \\r
- } \\r
- else \\r
- { \\r
- xTracing = pdFALSE; \\r
- } \\r
- } \\r
- } \\r
- }\r
-\r
-#else\r
-\r
- #define vWriteTraceToBuffer()\r
-\r
-#endif\r
/*-----------------------------------------------------------*/\r
\r
/*\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
vListRemove( &( pxTCB->xGenericListItem ) ); \\r
\\r
/* Is the task waiting on an event also? */ \\r
- if( pxTCB->xEventListItem.pvContainer ) \\r
+ if( pxTCB->xEventListItem.pvContainer != NULL ) \\r
{ \\r
vListRemove( &( pxTCB->xEventListItem ) ); \\r
} \\r
* This does not free memory allocated by the task itself (i.e. memory\r
* allocated by calls to pvPortMalloc from within the tasks application code).\r
*/\r
-#if ( ( INCLUDE_vTaskDelete == 1 ) || ( INCLUDE_vTaskCleanUpResources == 1 ) )\r
+#if ( INCLUDE_vTaskDelete == 1 )\r
\r
static void prvDeleteTCB( tskTCB *pxTCB ) PRIVILEGED_FUNCTION;\r
\r
#if( portUSING_MPU_WRAPPERS == 1 )\r
/* Should the task be created in privileged mode? */\r
portBASE_TYPE xRunPrivileged;\r
- if( ( uxPriority & portPRIVILEGE_BIT ) != 0x00 )\r
+ if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )\r
{\r
xRunPrivileged = pdTRUE;\r
}\r
#if( portSTACK_GROWTH < 0 )\r
{\r
pxTopOfStack = pxNewTCB->pxStack + ( usStackDepth - ( unsigned short ) 1 );\r
- pxTopOfStack = ( portSTACK_TYPE * ) ( ( ( unsigned long ) pxTopOfStack ) & ( ( unsigned long ) ~portBYTE_ALIGNMENT_MASK ) );\r
+ pxTopOfStack = ( portSTACK_TYPE * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ( portPOINTER_SIZE_TYPE ) ~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 ) == 0UL ) );\r
#endif\r
\r
/* Check the alignment of the initialised stack. */\r
- configASSERT( ( ( ( unsigned long ) pxNewTCB->pxTopOfStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
+ portALIGNMENT_ASSERT_pxCurrentTCB( ( ( ( unsigned long ) pxNewTCB->pxTopOfStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
\r
if( ( void * ) pxCreatedTask != NULL )\r
{\r
#if ( configUSE_TRACE_FACILITY == 1 )\r
{\r
/* Add a counter into the TCB for tracing only. */\r
- pxNewTCB->uxTCBNumber = uxTaskNumber;\r
+ pxNewTCB->uxTCBNumber = uxTCBNumber;\r
}\r
#endif\r
- uxTaskNumber++;\r
+ uxTCBNumber++;\r
\r
prvAddTaskToReadyQueue( pxNewTCB );\r
\r
vListRemove( &( pxTCB->xGenericListItem ) );\r
\r
/* Is the task waiting on an event also? */\r
- if( pxTCB->xEventListItem.pvContainer )\r
+ if( pxTCB->xEventListItem.pvContainer != NULL )\r
{\r
vListRemove( &( pxTCB->xEventListItem ) );\r
}\r
\r
/* Increment the uxTaskNumberVariable also so kernel aware debuggers\r
can detect that the task lists need re-generating. */\r
- uxTaskNumber++;\r
+ uxTCBNumber++;\r
\r
traceTASK_DELETE( pxTCB );\r
}\r
portBASE_TYPE xAlreadyYielded, xShouldDelay = pdFALSE;\r
\r
configASSERT( pxPreviousWakeTime );\r
- configASSERT( ( xTimeIncrement > 0 ) );\r
+ configASSERT( ( xTimeIncrement > 0U ) );\r
\r
vTaskSuspendAll();\r
{\r
\r
/* Force a reschedule if xTaskResumeAll has not already done so, we may\r
have put ourselves to sleep. */\r
- if( !xAlreadyYielded )\r
+ if( xAlreadyYielded == pdFALSE )\r
{\r
portYIELD_WITHIN_API();\r
}\r
signed portBASE_TYPE xAlreadyYielded = pdFALSE;\r
\r
/* A delay time of zero just forces a reschedule. */\r
- if( xTicksToDelay > ( portTickType ) 0 )\r
+ if( xTicksToDelay > ( portTickType ) 0U )\r
{\r
vTaskSuspendAll();\r
{\r
\r
/* Force a reschedule if xTaskResumeAll has not already done so, we may\r
have put ourselves to sleep. */\r
- if( !xAlreadyYielded )\r
+ if( xAlreadyYielded == pdFALSE )\r
{\r
portYIELD_WITHIN_API();\r
}\r
priority of the calling function. */\r
pxTCB = prvGetTCBFromHandle( pxTask );\r
\r
- traceTASK_PRIORITY_SET( pxTask, uxNewPriority );\r
+ traceTASK_PRIORITY_SET( pxTCB, uxNewPriority );\r
\r
#if ( configUSE_MUTEXES == 1 )\r
{\r
vListRemove( &( pxTCB->xGenericListItem ) );\r
\r
/* Is the task waiting on an event also? */\r
- if( pxTCB->xEventListItem.pvContainer )\r
+ if( pxTCB->xEventListItem.pvContainer != NULL )\r
{\r
vListRemove( &( pxTCB->xEventListItem ) );\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
{\r
portBASE_TYPE xYieldRequired = pdFALSE;\r
tskTCB *pxTCB;\r
+ unsigned portBASE_TYPE uxSavedInterruptStatus;\r
\r
configASSERT( pxTaskToResume );\r
\r
pxTCB = ( tskTCB * ) pxTaskToResume;\r
\r
- if( xTaskIsTaskSuspended( pxTCB ) == pdTRUE )\r
+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
{\r
- traceTASK_RESUME_FROM_ISR( pxTCB );\r
-\r
- if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )\r
+ if( xTaskIsTaskSuspended( pxTCB ) == pdTRUE )\r
{\r
- xYieldRequired = ( pxTCB->uxPriority >= pxCurrentTCB->uxPriority );\r
- vListRemove( &( pxTCB->xGenericListItem ) );\r
- prvAddTaskToReadyQueue( pxTCB );\r
- }\r
- else\r
- {\r
- /* We cannot access the delayed or ready lists, so will hold this\r
- task pending until the scheduler is resumed, at which point a\r
- yield will be performed if necessary. */\r
- vListInsertEnd( ( xList * ) &( xPendingReadyList ), &( pxTCB->xEventListItem ) );\r
+ traceTASK_RESUME_FROM_ISR( pxTCB );\r
+\r
+ if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )\r
+ {\r
+ xYieldRequired = ( pxTCB->uxPriority >= pxCurrentTCB->uxPriority );\r
+ vListRemove( &( pxTCB->xGenericListItem ) );\r
+ prvAddTaskToReadyQueue( pxTCB );\r
+ }\r
+ else\r
+ {\r
+ /* We cannot access the delayed or ready lists, so will hold this\r
+ task pending until the scheduler is resumed, at which point a\r
+ yield will be performed if necessary. */\r
+ vListInsertEnd( ( xList * ) &( xPendingReadyList ), &( pxTCB->xEventListItem ) );\r
+ }\r
}\r
}\r
+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );\r
\r
return xYieldRequired;\r
}\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
portDISABLE_INTERRUPTS();\r
\r
xSchedulerRunning = pdTRUE;\r
- xTickCount = ( portTickType ) 0;\r
+ xTickCount = ( portTickType ) 0U;\r
\r
/* If configGENERATE_RUN_TIME_STATS is defined then the following\r
macro must be defined to configure the timer/counter used to generate\r
\r
/* Setting up the timer tick is hardware specific and thus in the\r
portable interface. */\r
- if( xPortStartScheduler() )\r
+ if( xPortStartScheduler() != pdFALSE )\r
{\r
/* Should not reach here as if the scheduler is running the\r
function will not return. */\r
\r
if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )\r
{\r
- if( uxCurrentNumberOfTasks > ( unsigned portBASE_TYPE ) 0 )\r
+ if( uxCurrentNumberOfTasks > ( unsigned portBASE_TYPE ) 0U )\r
{\r
portBASE_TYPE xYieldRequired = pdFALSE;\r
\r
/* If any ticks occurred while the scheduler was suspended then\r
they should be processed now. This ensures the tick count does not\r
slip, and that any delayed tasks are resumed at the correct time. */\r
- if( uxMissedTicks > ( unsigned portBASE_TYPE ) 0 )\r
+ if( uxMissedTicks > ( unsigned portBASE_TYPE ) 0U )\r
{\r
- while( uxMissedTicks > ( unsigned portBASE_TYPE ) 0 )\r
+ while( uxMissedTicks > ( unsigned portBASE_TYPE ) 0U )\r
{\r
vTaskIncrementTick();\r
--uxMissedTicks;\r
}\r
/*-----------------------------------------------------------*/\r
\r
+#if ( INCLUDE_pcTaskGetTaskName == 1 )\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
+#endif\r
+/*-----------------------------------------------------------*/\r
+\r
#if ( configUSE_TRACE_FACILITY == 1 )\r
\r
void vTaskList( signed char *pcWriteBuffer )\r
{\r
if( listLIST_IS_EMPTY( &xTasksWaitingTermination ) == pdFALSE )\r
{\r
- prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, tskDELETED_CHAR );\r
+ prvListTaskWithinSingleList( pcWriteBuffer, &xTasksWaitingTermination, tskDELETED_CHAR );\r
}\r
}\r
#endif\r
{\r
if( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )\r
{\r
- prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, tskSUSPENDED_CHAR );\r
+ prvListTaskWithinSingleList( pcWriteBuffer, &xSuspendedTaskList, tskSUSPENDED_CHAR );\r
}\r
}\r
#endif\r
{\r
if( listLIST_IS_EMPTY( &xTasksWaitingTermination ) == pdFALSE )\r
{\r
- prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, ulTotalRunTime );\r
+ prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, &xTasksWaitingTermination, ulTotalRunTime );\r
}\r
}\r
#endif\r
{\r
if( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )\r
{\r
- prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, ulTotalRunTime );\r
+ prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, &xSuspendedTaskList, ulTotalRunTime );\r
}\r
}\r
#endif\r
#endif\r
/*----------------------------------------------------------*/\r
\r
-#if ( configUSE_TRACE_FACILITY == 1 )\r
-\r
- void vTaskStartTrace( signed char * pcBuffer, unsigned long ulBufferSize )\r
- {\r
- configASSERT( pcBuffer );\r
- configASSERT( ulBufferSize );\r
-\r
- taskENTER_CRITICAL();\r
- {\r
- pcTraceBuffer = ( signed char * )pcBuffer;\r
- pcTraceBufferStart = pcBuffer;\r
- pcTraceBufferEnd = pcBuffer + ( ulBufferSize - tskSIZE_OF_EACH_TRACE_LINE );\r
- xTracing = pdTRUE;\r
- }\r
- taskEXIT_CRITICAL();\r
- }\r
-\r
-#endif\r
-/*----------------------------------------------------------*/\r
-\r
-#if ( configUSE_TRACE_FACILITY == 1 )\r
+#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )\r
\r
- unsigned long ulTaskEndTrace( void )\r
+ xTaskHandle xTaskGetIdleTaskHandle( void )\r
{\r
- unsigned long ulBufferLength;\r
-\r
- taskENTER_CRITICAL();\r
- xTracing = pdFALSE;\r
- taskEXIT_CRITICAL();\r
-\r
- ulBufferLength = ( unsigned long ) ( pcTraceBuffer - pcTraceBufferStart );\r
-\r
- return ulBufferLength;\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
+ \r
#endif\r
\r
-\r
-\r
/*-----------------------------------------------------------\r
* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES\r
* documented in task.h\r
*----------------------------------------------------------*/\r
\r
-\r
void vTaskIncrementTick( void )\r
{\r
tskTCB * pxTCB;\r
if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )\r
{\r
++xTickCount;\r
- if( xTickCount == ( portTickType ) 0 )\r
+ if( xTickCount == ( portTickType ) 0U )\r
{\r
xList *pxTemp;\r
\r
\r
if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )\r
{\r
- /* The new current delayed list is empty. Set \r
- xNextTaskUnblockTime to the maximum possible value so it is \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
+ 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
- /* 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
+ /* 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
/*-----------------------------------------------------------*/\r
\r
-#if ( ( INCLUDE_vTaskCleanUpResources == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )\r
-\r
- void vTaskCleanUpResources( void )\r
- {\r
- unsigned short usQueue;\r
- volatile tskTCB *pxTCB;\r
-\r
- usQueue = ( unsigned short ) uxTopUsedPriority + ( unsigned short ) 1;\r
-\r
- /* Remove any TCB's from the ready queues. */\r
- do\r
- {\r
- usQueue--;\r
-\r
- while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ usQueue ] ) ) == pdFALSE )\r
- {\r
- listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &( pxReadyTasksLists[ usQueue ] ) );\r
- vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
-\r
- prvDeleteTCB( ( tskTCB * ) pxTCB );\r
- }\r
- }while( usQueue > ( unsigned short ) tskIDLE_PRIORITY );\r
-\r
- /* Remove any TCB's from the delayed queue. */\r
- while( listLIST_IS_EMPTY( &xDelayedTaskList1 ) == pdFALSE )\r
- {\r
- listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList1 );\r
- vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
-\r
- prvDeleteTCB( ( tskTCB * ) pxTCB );\r
- }\r
-\r
- /* Remove any TCB's from the overflow delayed queue. */\r
- while( listLIST_IS_EMPTY( &xDelayedTaskList2 ) == pdFALSE )\r
- {\r
- listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList2 );\r
- vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
-\r
- prvDeleteTCB( ( tskTCB * ) pxTCB );\r
- }\r
-\r
- while( listLIST_IS_EMPTY( &xSuspendedTaskList ) == pdFALSE )\r
- {\r
- listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xSuspendedTaskList );\r
- vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );\r
-\r
- prvDeleteTCB( ( tskTCB * ) pxTCB );\r
- }\r
- }\r
-\r
-#endif\r
-/*-----------------------------------------------------------*/\r
-\r
#if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
\r
void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction )\r
listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopReadyPriority ] ) );\r
\r
traceTASK_SWITCHED_IN();\r
- vWriteTraceToBuffer();\r
}\r
}\r
/*-----------------------------------------------------------*/\r
{\r
xMissedYield = pdTRUE;\r
}\r
+/*-----------------------------------------------------------*/\r
+\r
+#if ( configUSE_TRACE_FACILITY == 1 )\r
+ unsigned portBASE_TYPE uxTaskGetTaskNumber( xTaskHandle xTask )\r
+ {\r
+ unsigned portBASE_TYPE uxReturn;\r
+ tskTCB *pxTCB;\r
+ \r
+ if( xTask != NULL )\r
+ {\r
+ pxTCB = ( tskTCB * ) xTask;\r
+ uxReturn = pxTCB->uxTaskNumber;\r
+ }\r
+ else\r
+ {\r
+ uxReturn = 0U;\r
+ }\r
+ \r
+ return uxReturn;\r
+ }\r
+#endif\r
+/*-----------------------------------------------------------*/\r
+\r
+#if ( configUSE_TRACE_FACILITY == 1 )\r
+ void vTaskSetTaskNumber( xTaskHandle xTask, unsigned portBASE_TYPE uxHandle )\r
+ {\r
+ tskTCB *pxTCB;\r
+ \r
+ if( xTask != NULL )\r
+ {\r
+ pxTCB = ( tskTCB * ) xTask;\r
+ pxTCB->uxTaskNumber = uxHandle;\r
+ }\r
+ }\r
+#endif\r
+\r
\r
/*\r
* -----------------------------------------------------------\r
\r
#if ( portCRITICAL_NESTING_IN_TCB == 1 )\r
{\r
- pxTCB->uxCriticalNesting = ( unsigned portBASE_TYPE ) 0;\r
+ pxTCB->uxCriticalNesting = ( unsigned portBASE_TYPE ) 0U;\r
}\r
#endif\r
\r
\r
/* ucTasksDeleted is used to prevent vTaskSuspendAll() being called\r
too often in the idle task. */\r
- if( uxTasksDeleted > ( unsigned portBASE_TYPE ) 0 )\r
+ if( uxTasksDeleted > ( unsigned portBASE_TYPE ) 0U )\r
{\r
vTaskSuspendAll();\r
xListIsEmpty = listLIST_IS_EMPTY( &xTasksWaitingTermination );\r
else\r
{\r
/* Just to help debugging. */\r
- memset( pxNewTCB->pxStack, tskSTACK_FILL_BYTE, usStackDepth * sizeof( portSTACK_TYPE ) );\r
+ memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) usStackDepth * sizeof( portSTACK_TYPE ) );\r
}\r
}\r
\r
{\r
volatile tskTCB *pxNextTCB, *pxFirstTCB;\r
unsigned short usStackRemaining;\r
+ PRIVILEGED_DATA static char pcStatusString[ 50 ];\r
\r
/* Write the details of all the TCB's in pxList into the buffer. */\r
listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );\r
if( ulTotalRunTime > 0UL )\r
{\r
/* Has the task run at all? */\r
- if( pxNextTCB->ulRunTimeCounter == 0 )\r
+ if( pxNextTCB->ulRunTimeCounter == 0UL )\r
{\r
/* The task has used no CPU time at all. */\r
sprintf( pcStatsString, ( char * ) "%s\t\t0\t\t0%%\r\n", pxNextTCB->pcTaskName );\r
\r
static unsigned short usTaskCheckFreeStackSpace( const unsigned char * pucStackByte )\r
{\r
- register unsigned short usCount = 0;\r
+ register unsigned short usCount = 0U;\r
\r
while( *pucStackByte == tskSTACK_FILL_BYTE )\r
{\r
#endif\r
/*-----------------------------------------------------------*/\r
\r
-#if ( ( INCLUDE_vTaskDelete == 1 ) || ( INCLUDE_vTaskCleanUpResources == 1 ) )\r
+#if ( INCLUDE_vTaskDelete == 1 )\r
\r
static void prvDeleteTCB( tskTCB *pxTCB )\r
{\r
+ /* This call is required specifically for the TriCore port. It must be\r
+ above the vPortFree() calls. */\r
+ portCLEAN_UP_TCB( pxTCB );\r
+\r
/* Free up the memory allocated by the scheduler for the task. It is up to\r
the task to free any memory allocated at the application level. */\r
vPortFreeAligned( pxTCB->pxStack );\r
\r
/* If the task being modified is in the ready state it will need to\r
be moved in to a new list. */\r
- if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) ) )\r
+ if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) ) != pdFALSE )\r
{\r
vListRemove( &( pxTCB->xGenericListItem ) );\r
\r
/* Just inherit the priority. */\r
pxTCB->uxPriority = pxCurrentTCB->uxPriority;\r
}\r
+\r
+ traceTASK_PRIORITY_INHERIT( pxTCB, pxCurrentTCB->uxPriority );\r
}\r
}\r
\r
Remove ourselves from the ready list we currently appear in. */\r
vListRemove( &( pxTCB->xGenericListItem ) );\r
\r
- /* Disinherit the priority before adding ourselves into the new\r
+ /* Disinherit the priority before adding the task into the new\r
ready list. */\r
+ traceTASK_PRIORITY_DISINHERIT( pxTCB, pxTCB->uxBasePriority );\r
pxTCB->uxPriority = pxTCB->uxBasePriority;\r
listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) pxTCB->uxPriority );\r
prvAddTaskToReadyQueue( pxTCB );\r
{\r
if( xSchedulerRunning != pdFALSE )\r
{\r
- if( pxCurrentTCB->uxCriticalNesting > 0 )\r
+ if( pxCurrentTCB->uxCriticalNesting > 0U )\r
{\r
( pxCurrentTCB->uxCriticalNesting )--;\r
\r
- if( pxCurrentTCB->uxCriticalNesting == 0 )\r
+ if( pxCurrentTCB->uxCriticalNesting == 0U )\r
{\r
portENABLE_INTERRUPTS();\r
}\r
projects / freertos / blobdiff