/*\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
#include "FreeRTOS.h"\r
#include "task.h"\r
+#include "timers.h"\r
#include "StackMacros.h"\r
\r
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE\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
* The value used to fill the stack of a task when the task is created. This\r
* is used purely for checking the high water mark for tasks.\r
*/\r
-#define tskSTACK_FILL_BYTE ( 0xa5 )\r
+#define tskSTACK_FILL_BYTE ( 0xa5U )\r
\r
/*\r
* Macros used by vListTask to indicate which state a task is in.\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 = 255;\r
+ static unsigned portBASE_TYPE uxPreviousTask = 255U;\r
PRIVILEGED_DATA static char pcStatusString[ 50 ];\r
\r
#endif\r
* executing task, then it will only be rescheduled after the currently\r
* executing task has been rescheduled.\r
*/\r
-#define prvAddTaskToReadyQueue( pxTCB ) \\r
-{ \\r
- if( pxTCB->uxPriority > uxTopReadyPriority ) \\r
- { \\r
- uxTopReadyPriority = pxTCB->uxPriority; \\r
- } \\r
- vListInsertEnd( ( xList * ) &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) ); \\r
-}\r
+#define prvAddTaskToReadyQueue( pxTCB ) \\r
+ if( ( pxTCB )->uxPriority > uxTopReadyPriority ) \\r
+ { \\r
+ uxTopReadyPriority = ( pxTCB )->uxPriority; \\r
+ } \\r
+ vListInsertEnd( ( xList * ) &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xGenericListItem ) )\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
* task should be used in place of the parameter. This macro simply checks to\r
* see if the parameter is NULL and returns a pointer to the appropriate TCB.\r
*/\r
-#define prvGetTCBFromHandle( pxHandle ) ( ( pxHandle == NULL ) ? ( tskTCB * ) pxCurrentTCB : ( tskTCB * ) pxHandle )\r
-\r
+#define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? ( tskTCB * ) pxCurrentTCB : ( tskTCB * ) ( pxHandle ) )\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
/*\r
signed portBASE_TYPE xReturn;\r
tskTCB * pxNewTCB;\r
\r
+ configASSERT( pxTaskCode );\r
+ configASSERT( ( uxPriority < configMAX_PRIORITIES ) );\r
+\r
/* Allocate the memory required by the TCB and stack for the new task,\r
checking that the allocation was successful. */\r
pxNewTCB = prvAllocateTCBAndStack( usStackDepth, puxStackBuffer );\r
required by the port. */\r
#if( portSTACK_GROWTH < 0 )\r
{\r
- pxTopOfStack = pxNewTCB->pxStack + ( usStackDepth - 1 );\r
+ pxTopOfStack = pxNewTCB->pxStack + ( usStackDepth - ( unsigned short ) 1 );\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 ) == 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
}\r
#endif\r
\r
+ /* Check the alignment of the initialised stack. */\r
+ configASSERT( ( ( ( unsigned long ) pxNewTCB->pxTopOfStack & ( unsigned long ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
+\r
if( ( void * ) pxCreatedTask != NULL )\r
{\r
/* Pass the TCB out - in an anonymous way. The calling function/\r
\r
/* We are going to manipulate the task queues to add this task to a\r
ready list, so must make sure no interrupts occur. */\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
uxCurrentNumberOfTasks++;\r
if( pxCurrentTCB == NULL )\r
xReturn = pdPASS;\r
traceTASK_CREATE( pxNewTCB );\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
}\r
else\r
{\r
{\r
tskTCB *pxTCB;\r
\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
/* Ensure a yield is performed if the current task is being\r
deleted. */\r
\r
traceTASK_DELETE( pxTCB );\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
/* Force a reschedule if we have just deleted the current task. */\r
if( xSchedulerRunning != pdFALSE )\r
portTickType xTimeToWake;\r
portBASE_TYPE xAlreadyYielded, xShouldDelay = pdFALSE;\r
\r
+ configASSERT( pxPreviousWakeTime );\r
+ configASSERT( ( xTimeIncrement > 0 ) );\r
+\r
vTaskSuspendAll();\r
{\r
/* Generate the tick time at which the task wants to wake. */\r
tskTCB *pxTCB;\r
unsigned portBASE_TYPE uxReturn;\r
\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
/* If null is passed in here then we are changing the\r
priority of the calling function. */\r
pxTCB = prvGetTCBFromHandle( pxTask );\r
uxReturn = pxTCB->uxPriority;\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
return uxReturn;\r
}\r
void vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority )\r
{\r
tskTCB *pxTCB;\r
- unsigned portBASE_TYPE uxCurrentPriority, xYieldRequired = pdFALSE;\r
+ unsigned portBASE_TYPE uxCurrentPriority;\r
+ portBASE_TYPE xYieldRequired = pdFALSE;\r
+\r
+ configASSERT( ( uxNewPriority < configMAX_PRIORITIES ) );\r
\r
/* Ensure the new priority is valid. */\r
if( uxNewPriority >= configMAX_PRIORITIES )\r
{\r
- uxNewPriority = configMAX_PRIORITIES - 1;\r
+ uxNewPriority = configMAX_PRIORITIES - ( unsigned portBASE_TYPE ) 1U;\r
}\r
\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
if( pxTask == pxCurrentTCB )\r
{\r
}\r
}\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
}\r
\r
#endif\r
{\r
tskTCB *pxTCB;\r
\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
/* Ensure a yield is performed if the current task is being\r
suspended. */\r
\r
vListInsertEnd( ( xList * ) &xSuspendedTaskList, &( pxTCB->xGenericListItem ) );\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
if( ( void * ) pxTaskToSuspend == 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 == 1 )\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 = pdFALSE;\r
const tskTCB * const pxTCB = ( tskTCB * ) xTask;\r
\r
+ /* It does not make sense to check if the calling task is suspended. */\r
+ configASSERT( xTask );\r
+\r
/* Is the task we are attempting to resume actually in the\r
suspended list? */\r
if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) ) != pdFALSE )\r
{\r
tskTCB *pxTCB;\r
\r
+ /* It does not make sense to resume the calling task. */\r
+ configASSERT( pxTaskToResume );\r
+\r
/* Remove the task from whichever list it is currently in, and place\r
it in the ready list. */\r
pxTCB = ( tskTCB * ) pxTaskToResume;\r
currently executing task. */\r
if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB ) )\r
{\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
if( xTaskIsTaskSuspended( pxTCB ) == pdTRUE )\r
{\r
}\r
}\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
}\r
}\r
\r
portBASE_TYPE xYieldRequired = pdFALSE;\r
tskTCB *pxTCB;\r
\r
+ configASSERT( pxTaskToResume );\r
+\r
pxTCB = ( tskTCB * ) pxTaskToResume;\r
\r
if( xTaskIsTaskSuspended( pxTCB ) == pdTRUE )\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
+ if( xReturn == pdPASS )\r
+ {\r
+ xReturn = xTimerCreateTimerTask();\r
+ }\r
+ }\r
+ #endif\r
\r
if( xReturn == pdPASS )\r
{\r
/* Should only reach here if a task calls xTaskEndScheduler(). */\r
}\r
}\r
+\r
+ /* This line will only be reached if the kernel could not be started. */\r
+ configASSERT( xReturn );\r
}\r
/*-----------------------------------------------------------*/\r
\r
register tskTCB *pxTCB;\r
signed portBASE_TYPE xAlreadyYielded = pdFALSE;\r
\r
+ /* If uxSchedulerSuspended is zero then this function does not match a\r
+ previous call to vTaskSuspendAll(). */\r
+ configASSERT( uxSchedulerSuspended );\r
+\r
/* It is possible that an ISR caused a task to be removed from an event\r
list while the scheduler was suspended. If this was the case then the\r
removed task will have been added to the xPendingReadyList. Once the\r
scheduler has been resumed it is safe to move all the pending ready\r
tasks from this list into their appropriate ready list. */\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
--uxSchedulerSuspended;\r
\r
}\r
}\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
return xAlreadyYielded;\r
}\r
portTickType xTicks;\r
\r
/* Critical section required if running on a 16 bit processor. */\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
xTicks = xTickCount;\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
return xTicks;\r
}\r
\r
portTickType xTaskGetTickCountFromISR( void )\r
{\r
- return xTickCount;\r
+portTickType xReturn;\r
+unsigned portBASE_TYPE uxSavedInterruptStatus;\r
+\r
+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
+ xReturn = xTickCount;\r
+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );\r
+\r
+ return xReturn;\r
}\r
/*-----------------------------------------------------------*/\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
/* Run through all the lists that could potentially contain a TCB and\r
report the task name, state and stack high water mark. */\r
\r
- pcWriteBuffer[ 0 ] = ( signed char ) 0x00;\r
+ *pcWriteBuffer = ( signed char ) 0x00;\r
strcat( ( char * ) pcWriteBuffer, ( const char * ) "\r\n" );\r
\r
- uxQueue = uxTopUsedPriority + 1;\r
+ uxQueue = uxTopUsedPriority + ( unsigned portBASE_TYPE ) 1U;\r
\r
do\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
generating a table of run timer percentages in the provided\r
buffer. */\r
\r
- pcWriteBuffer[ 0 ] = ( signed char ) 0x00;\r
+ *pcWriteBuffer = ( signed char ) 0x00;\r
strcat( ( char * ) pcWriteBuffer, ( const char * ) "\r\n" );\r
\r
- uxQueue = uxTopUsedPriority + 1;\r
+ uxQueue = uxTopUsedPriority + ( unsigned portBASE_TYPE ) 1U;\r
\r
do\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
void vTaskStartTrace( signed char * pcBuffer, unsigned long ulBufferSize )\r
{\r
- portENTER_CRITICAL();\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
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
}\r
\r
#endif\r
{\r
unsigned long ulBufferLength;\r
\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
xTracing = pdFALSE;\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
ulBufferLength = ( unsigned long ) ( pcTraceBuffer - pcTraceBufferStart );\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
/* Tick count has overflowed so we need to swap the delay lists.\r
If there are any items in pxDelayedTaskList here then there is\r
an error! */\r
+ configASSERT( ( listLIST_IS_EMPTY( pxDelayedTaskList ) ) );\r
+ \r
pxTemp = pxDelayedTaskList;\r
pxDelayedTaskList = pxOverflowDelayedTaskList;\r
pxOverflowDelayedTaskList = pxTemp;\r
xNumOfOverflows++;\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
\r
/* Save the hook function in the TCB. A critical section is required as\r
the value can be accessed from an interrupt. */\r
- portENTER_CRITICAL();\r
- xTCB->pxTaskTag = pxTagValue;\r
- portEXIT_CRITICAL();\r
+ taskENTER_CRITICAL();\r
+ xTCB->pxTaskTag = pxHookFunction;\r
+ taskEXIT_CRITICAL();\r
}\r
\r
#endif\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
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
xReturn = xTCB->pxTaskTag;\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
return xReturn;\r
}\r
/* The scheduler is currently suspended - do not allow a context\r
switch. */\r
xMissedYield = pdTRUE;\r
- return;\r
}\r
-\r
- traceTASK_SWITCHED_OUT();\r
-\r
- #if ( configGENERATE_RUN_TIME_STATS == 1 )\r
- {\r
- unsigned long ulTempCounter;\r
- \r
- #ifdef portALT_GET_RUN_TIME_COUNTER_VALUE\r
- portALT_GET_RUN_TIME_COUNTER_VALUE( ulTempCounter );\r
- #else\r
- ulTempCounter = portGET_RUN_TIME_COUNTER_VALUE();\r
- #endif\r
-\r
- /* Add the amount of time the task has been running to the accumulated\r
- time so far. The time the task started running was stored in\r
- ulTaskSwitchedInTime. Note that there is no overflow protection here\r
- so count values are only valid until the timer overflows. Generally\r
- this will be about 1 hour assuming a 1uS timer increment. */\r
- pxCurrentTCB->ulRunTimeCounter += ( ulTempCounter - ulTaskSwitchedInTime );\r
- ulTaskSwitchedInTime = ulTempCounter;\r
- }\r
- #endif\r
-\r
- taskFIRST_CHECK_FOR_STACK_OVERFLOW();\r
- taskSECOND_CHECK_FOR_STACK_OVERFLOW();\r
-\r
- /* Find the highest priority queue that contains ready tasks. */\r
- while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopReadyPriority ] ) ) )\r
+ else\r
{\r
- --uxTopReadyPriority;\r
+ traceTASK_SWITCHED_OUT();\r
+ \r
+ #if ( configGENERATE_RUN_TIME_STATS == 1 )\r
+ {\r
+ unsigned long ulTempCounter;\r
+ \r
+ #ifdef portALT_GET_RUN_TIME_COUNTER_VALUE\r
+ portALT_GET_RUN_TIME_COUNTER_VALUE( ulTempCounter );\r
+ #else\r
+ ulTempCounter = portGET_RUN_TIME_COUNTER_VALUE();\r
+ #endif\r
+ \r
+ /* Add the amount of time the task has been running to the accumulated\r
+ time so far. The time the task started running was stored in\r
+ ulTaskSwitchedInTime. Note that there is no overflow protection here\r
+ so count values are only valid until the timer overflows. Generally\r
+ this will be about 1 hour assuming a 1uS timer increment. */\r
+ pxCurrentTCB->ulRunTimeCounter += ( ulTempCounter - ulTaskSwitchedInTime );\r
+ ulTaskSwitchedInTime = ulTempCounter;\r
+ }\r
+ #endif\r
+ \r
+ taskFIRST_CHECK_FOR_STACK_OVERFLOW();\r
+ taskSECOND_CHECK_FOR_STACK_OVERFLOW();\r
+ \r
+ /* Find the highest priority queue that contains ready tasks. */\r
+ while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopReadyPriority ] ) ) )\r
+ {\r
+ configASSERT( uxTopReadyPriority );\r
+ --uxTopReadyPriority;\r
+ }\r
+ \r
+ /* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the tasks of the\r
+ same priority get an equal share of the processor time. */\r
+ listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopReadyPriority ] ) );\r
+ \r
+ traceTASK_SWITCHED_IN();\r
+ vWriteTraceToBuffer();\r
}\r
-\r
- /* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the tasks of the\r
- same priority get an equal share of the processor time. */\r
- listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopReadyPriority ] ) );\r
-\r
- traceTASK_SWITCHED_IN();\r
- vWriteTraceToBuffer();\r
}\r
/*-----------------------------------------------------------*/\r
\r
{\r
portTickType xTimeToWake;\r
\r
+ configASSERT( pxEventList );\r
+\r
/* THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED OR THE\r
SCHEDULER SUSPENDED. */\r
\r
}\r
/*-----------------------------------------------------------*/\r
\r
+#if configUSE_TIMERS == 1\r
+\r
+ void vTaskPlaceOnEventListRestricted( const xList * const pxEventList, portTickType xTicksToWait )\r
+ {\r
+ portTickType xTimeToWake;\r
+\r
+ configASSERT( pxEventList );\r
+\r
+ /* This function should not be called by application code hence the\r
+ 'Restricted' in its name. It is not part of the public API. It is\r
+ designed for use by kernel code, and has special calling requirements -\r
+ it should be called from a critical section. */\r
+\r
+ \r
+ /* Place the event list item of the TCB in the appropriate event list.\r
+ In this case it is assume that this is the only task that is going to\r
+ be waiting on this event list, so the faster vListInsertEnd() function\r
+ can be used in place of vListInsert. */\r
+ vListInsertEnd( ( xList * ) pxEventList, ( xListItem * ) &( pxCurrentTCB->xEventListItem ) );\r
+\r
+ /* We must remove this task from the ready list before adding it to the\r
+ blocked list as the same list item is used for both lists. This\r
+ function is called form a critical section. */\r
+ vListRemove( ( xListItem * ) &( pxCurrentTCB->xGenericListItem ) );\r
+\r
+ /* Calculate the time at which the task should be woken if the event does\r
+ not occur. This may overflow but this doesn't matter. */\r
+ xTimeToWake = xTickCount + xTicksToWait;\r
+ prvAddCurrentTaskToDelayedList( xTimeToWake );\r
+ }\r
+ \r
+#endif /* configUSE_TIMERS */\r
+/*-----------------------------------------------------------*/\r
+\r
signed portBASE_TYPE xTaskRemoveFromEventList( const xList * const pxEventList )\r
{\r
tskTCB *pxUnblockedTCB;\r
\r
If an event is for a queue that is locked then this function will never\r
get called - the lock count on the queue will get modified instead. This\r
- means we can always expect exclusive access to the event list here. \r
+ means we can always expect exclusive access to the event list here.\r
\r
This function assumes that a check has already been made to ensure that\r
pxEventList is not empty. */\r
pxUnblockedTCB = ( tskTCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );\r
+ configASSERT( pxUnblockedTCB );\r
vListRemove( &( pxUnblockedTCB->xEventListItem ) );\r
\r
if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )\r
\r
void vTaskSetTimeOutState( xTimeOutType * const pxTimeOut )\r
{\r
+ configASSERT( pxTimeOut );\r
pxTimeOut->xOverflowCount = xNumOfOverflows;\r
pxTimeOut->xTimeOnEntering = xTickCount;\r
}\r
{\r
portBASE_TYPE xReturn;\r
\r
- portENTER_CRITICAL();\r
+ configASSERT( pxTimeOut );\r
+ configASSERT( pxTicksToWait );\r
+\r
+ taskENTER_CRITICAL();\r
{\r
#if ( INCLUDE_vTaskSuspend == 1 )\r
/* If INCLUDE_vTaskSuspend is set to 1 and the block time specified is\r
xReturn = pdTRUE;\r
}\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
return xReturn;\r
}\r
strncpy( ( char * ) pxTCB->pcTaskName, ( const char * ) pcName, ( unsigned short ) configMAX_TASK_NAME_LEN );\r
}\r
#endif\r
- pxTCB->pcTaskName[ ( unsigned short ) configMAX_TASK_NAME_LEN - ( unsigned short ) 1 ] = '\0';\r
+ pxTCB->pcTaskName[ ( unsigned short ) configMAX_TASK_NAME_LEN - ( unsigned short ) 1 ] = ( signed char ) '\0';\r
\r
/* This is used as an array index so must ensure it's not too large. First\r
remove the privilege bit if one is present. */\r
if( uxPriority >= configMAX_PRIORITIES )\r
{\r
- uxPriority = configMAX_PRIORITIES - 1;\r
+ uxPriority = configMAX_PRIORITIES - ( unsigned portBASE_TYPE ) 1U;\r
}\r
\r
pxTCB->uxPriority = uxPriority;\r
{\r
unsigned portBASE_TYPE uxPriority;\r
\r
- for( uxPriority = 0; uxPriority < configMAX_PRIORITIES; uxPriority++ )\r
+ for( uxPriority = ( unsigned portBASE_TYPE ) 0U; uxPriority < configMAX_PRIORITIES; uxPriority++ )\r
{\r
vListInitialise( ( xList * ) &( pxReadyTasksLists[ uxPriority ] ) );\r
}\r
{\r
tskTCB *pxTCB;\r
\r
- portENTER_CRITICAL();\r
+ taskENTER_CRITICAL();\r
{\r
pxTCB = ( tskTCB * ) listGET_OWNER_OF_HEAD_ENTRY( ( ( xList * ) &xTasksWaitingTermination ) );\r
vListRemove( &( pxTCB->xGenericListItem ) );\r
--uxCurrentNumberOfTasks;\r
--uxTasksDeleted;\r
}\r
- portEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
prvDeleteTCB( pxTCB );\r
}\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
else\r
{\r
/* What percentage of the total run time has the task used?\r
- This will always be rounded down to the nearest integer. \r
+ This will always be rounded down to the nearest integer.\r
ulTotalRunTime has already been divided by 100. */\r
ulStatsAsPercentage = pxNextTCB->ulRunTimeCounter / ulTotalRunTime;\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
{\r
tskTCB * const pxTCB = ( tskTCB * ) pxMutexHolder;\r
\r
+ configASSERT( pxMutexHolder );\r
+\r
if( pxTCB->uxPriority < pxCurrentTCB->uxPriority )\r
{\r
/* Adjust the mutex holder state to account for its new priority. */\r
projects / freertos / blobdiff