/*\r
- FreeRTOS V8.1.2 - Copyright (C) 2014 Real Time Engineers Ltd.\r
+ FreeRTOS V8.2.0rc1 - Copyright (C) 2014 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
\r
- ***************************************************************************\r
- * *\r
- * FreeRTOS provides completely free yet professionally developed, *\r
- * robust, strictly quality controlled, supported, and cross *\r
- * platform software that has become a de facto standard. *\r
- * *\r
- * Help yourself get started quickly and support the FreeRTOS *\r
- * project by purchasing a FreeRTOS tutorial book, reference *\r
- * manual, or both from: http://www.FreeRTOS.org/Documentation *\r
- * *\r
- * Thank you! *\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
\r
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. Full license text is available from the following\r
+ FOR A PARTICULAR PURPOSE. Full license text is available on the following\r
link: http://www.freertos.org/a00114.html\r
\r
1 tab == 4 spaces!\r
***************************************************************************\r
* *\r
* Having a problem? Start by reading the FAQ "My application does *\r
- * not run, what could be wrong?" *\r
+ * not run, what could be wrong?". Have you defined configASSERT()? *\r
* *\r
* http://www.FreeRTOS.org/FAQHelp.html *\r
* *\r
***************************************************************************\r
\r
+ ***************************************************************************\r
+ * *\r
+ * FreeRTOS provides completely free yet professionally developed, *\r
+ * robust, strictly quality controlled, supported, and cross *\r
+ * platform software that is more than just the market leader, it *\r
+ * is the industry's de facto standard. *\r
+ * *\r
+ * Help yourself get started quickly while simultaneously helping *\r
+ * to support the FreeRTOS project by purchasing a FreeRTOS *\r
+ * tutorial book, reference manual, or both: *\r
+ * http://www.FreeRTOS.org/Documentation *\r
+ * *\r
+ ***************************************************************************\r
+\r
+ ***************************************************************************\r
+ * *\r
+ * Investing in training allows your team to be as productive as *\r
+ * possible as early as possible, lowering your overall development *\r
+ * cost, and enabling you to bring a more robust product to market *\r
+ * earlier than would otherwise be possible. Richard Barry is both *\r
+ * the architect and key author of FreeRTOS, and so also the world's *\r
+ * leading authority on what is the world's most popular real time *\r
+ * kernel for deeply embedded MCU designs. Obtaining your training *\r
+ * from Richard ensures your team will gain directly from his in-depth *\r
+ * product knowledge and years of usage experience. Contact Real Time *\r
+ * Engineers Ltd to enquire about the FreeRTOS Masterclass, presented *\r
+ * by Richard Barry: http://www.FreeRTOS.org/contact\r
+ * *\r
+ ***************************************************************************\r
+\r
+ ***************************************************************************\r
+ * *\r
+ * You are receiving this top quality software for free. Please play *\r
+ * fair and reciprocate by reporting any suspected issues and *\r
+ * participating in the community forum: *\r
+ * http://www.FreeRTOS.org/support *\r
+ * *\r
+ * Thank you! *\r
+ * *\r
+ ***************************************************************************\r
+\r
http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
license and Real Time Engineers Ltd. contact details.\r
\r
including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
\r
+ http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
+ Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
+\r
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
- Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS\r
- licenses offer ticketed support, indemnification and middleware.\r
+ Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS\r
+ licenses offer ticketed support, indemnification and commercial middleware.\r
\r
http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
engineered and independently SIL3 certified version for use in safety and\r
privileged Vs unprivileged linkage and placement. */\r
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */\r
\r
+/* Set configUSE_STATS_FORMATTING_FUNCTIONS to 2 to include the stats formatting\r
+functions but without including stdio.h here. */\r
#if ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 )\r
/* At the bottom of this file are two optional functions that can be used\r
to generate human readable text from the raw data generated by the\r
#define taskYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()\r
#endif\r
\r
+/* Value that can be assigned to the eNotifyState member of the TCB. */\r
+typedef enum\r
+{\r
+ eNotWaitingNotification = 0,\r
+ eWaitingNotification,\r
+ eNotified\r
+} eNotifyValue;\r
+\r
/*\r
* Task control block. A task control block (TCB) is allocated for each task,\r
* and stores task state information, including a pointer to the task's context\r
\r
#if ( portUSING_MPU_WRAPPERS == 1 )\r
xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the port layer. THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */\r
+ BaseType_t xUsingStaticallyAllocatedStack; /* Set to pdTRUE if the stack is a statically allocated array, and pdFALSE if the stack is dynamically allocated. */\r
#endif\r
\r
ListItem_t xGenericListItem; /*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */\r
struct _reent xNewLib_reent;\r
#endif\r
\r
+ #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
+ volatile uint32_t ulNotifiedValue;\r
+ volatile eNotifyValue eNotifyState;\r
+ #endif\r
+\r
} tskTCB;\r
\r
/* The old tskTCB name is maintained above then typedefed to the new TCB_t name\r
PRIVILEGED_DATA static volatile TickType_t xNextTaskUnblockTime = portMAX_DELAY;\r
\r
/* Context switches are held pending while the scheduler is suspended. Also,\r
-interrupts must not manipulate the xStateListItem of a TCB, or any of the\r
-lists the xStateListItem can be referenced from, if the scheduler is suspended.\r
+interrupts must not manipulate the xGenericListItem of a TCB, or any of the\r
+lists the xGenericListItem can be referenced from, if the scheduler is suspended.\r
If an interrupt needs to unblock a task while the scheduler is suspended then it\r
moves the task's event list item into the xPendingReadyList, ready for the\r
kernel to move the task from the pending ready list into the real ready list\r
*/\r
static void prvResetNextTaskUnblockTime( void );\r
\r
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )\r
+\r
+ /*\r
+ * Helper function used to pad task names with spaces when printing out\r
+ * human readable tables of task information.\r
+ */\r
+ static char *prvWriteNameToBuffer( char *pcBuffer, const char *pcTaskName );\r
+\r
+#endif\r
/*-----------------------------------------------------------*/\r
\r
BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, const MemoryRegion_t * const xRegions ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
{\r
BaseType_t xReturn;\r
TCB_t * pxNewTCB;\r
+StackType_t *pxTopOfStack;\r
\r
configASSERT( pxTaskCode );\r
configASSERT( ( ( uxPriority & ( ~portPRIVILEGE_BIT ) ) < configMAX_PRIORITIES ) );\r
\r
if( pxNewTCB != NULL )\r
{\r
- StackType_t *pxTopOfStack;\r
-\r
#if( portUSING_MPU_WRAPPERS == 1 )\r
/* Should the task be created in privileged mode? */\r
BaseType_t xRunPrivileged;\r
xRunPrivileged = pdFALSE;\r
}\r
uxPriority &= ~portPRIVILEGE_BIT;\r
+\r
+ if( puxStackBuffer != NULL )\r
+ {\r
+ /* The application provided its own stack. Note this so no\r
+ attempt is made to delete the stack should that task be\r
+ deleted. */\r
+ pxNewTCB->xUsingStaticallyAllocatedStack = pdTRUE;\r
+ }\r
+ else\r
+ {\r
+ /* The stack was allocated dynamically. Note this so it can be\r
+ deleted again if the task is deleted. */\r
+ pxNewTCB->xUsingStaticallyAllocatedStack = pdFALSE;\r
+ }\r
#endif /* portUSING_MPU_WRAPPERS == 1 */\r
\r
/* Calculate the top of stack address. This depends on whether the\r
}\r
#endif\r
\r
- else\r
+ else /*lint !e525 Negative indentation is intended to make use of pre-processor clearer. */\r
{\r
/* If the task is not in any other state, it must be in the\r
Ready (including pending ready) state. */\r
#endif /* INCLUDE_uxTaskPriorityGet */\r
/*-----------------------------------------------------------*/\r
\r
+#if ( INCLUDE_uxTaskPriorityGet == 1 )\r
+\r
+ UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask )\r
+ {\r
+ TCB_t *pxTCB;\r
+ UBaseType_t uxReturn, uxSavedInterruptState;\r
+\r
+ /* RTOS ports that support interrupt nesting have the concept of a\r
+ maximum system call (or maximum API call) interrupt priority.\r
+ Interrupts that are above the maximum system call priority are keep\r
+ permanently enabled, even when the RTOS kernel is in a critical section,\r
+ but cannot make any calls to FreeRTOS API functions. If configASSERT()\r
+ is defined in FreeRTOSConfig.h then\r
+ portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion\r
+ failure if a FreeRTOS API function is called from an interrupt that has\r
+ been assigned a priority above the configured maximum system call\r
+ priority. Only FreeRTOS functions that end in FromISR can be called\r
+ from interrupts that have been assigned a priority at or (logically)\r
+ below the maximum system call interrupt priority. FreeRTOS maintains a\r
+ separate interrupt safe API to ensure interrupt entry is as fast and as\r
+ simple as possible. More information (albeit Cortex-M specific) is\r
+ provided on the following link:\r
+ http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
+ portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
+\r
+ uxSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();\r
+ {\r
+ /* If null is passed in here then it is the priority of the calling\r
+ task that is being queried. */\r
+ pxTCB = prvGetTCBFromHandle( xTask );\r
+ uxReturn = pxTCB->uxPriority;\r
+ }\r
+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptState );\r
+\r
+ return uxReturn;\r
+ }\r
+\r
+#endif /* INCLUDE_uxTaskPriorityGet */\r
+/*-----------------------------------------------------------*/\r
+\r
#if ( INCLUDE_vTaskPrioritySet == 1 )\r
\r
void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority )\r
( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
\r
- /* If we have moved a task that has a priority higher than\r
- the current task then we should yield. */\r
+ /* If the moved task has a priority higher than the current\r
+ task then a yield must be performed. */\r
if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )\r
{\r
xYieldPending = pdTRUE;\r
TickType_t xTicks;\r
\r
/* Critical section required if running on a 16 bit processor. */\r
- taskENTER_CRITICAL();\r
+ portTICK_TYPE_ENTER_CRITICAL();\r
{\r
xTicks = xTickCount;\r
}\r
- taskEXIT_CRITICAL();\r
+ portTICK_TYPE_EXIT_CRITICAL();\r
\r
return xTicks;\r
}\r
link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
\r
- uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
+ uxSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();\r
{\r
xReturn = xTickCount;\r
}\r
- portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );\r
+ portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );\r
\r
return xReturn;\r
}\r
/* See if this tick has made a timeout expire. Tasks are stored in\r
the queue in the order of their wake time - meaning once one task\r
has been found whose block time has not expired there is no need to\r
- look any further down the list. */\r
+ look any further down the list. */\r
if( xConstTickCount >= xNextTaskUnblockTime )\r
{\r
for( ;; )\r
xReturn = pdFALSE;\r
}\r
\r
+ #if( configUSE_TICKLESS_IDLE == 1 )\r
+ {\r
+ /* If a task is blocked on a kernel object then xNextTaskUnblockTime\r
+ might be set to the blocked task's time out time. If the task is\r
+ unblocked for a reason other than a timeout xNextTaskUnblockTime is\r
+ normally left unchanged, because it is automatically get reset to a new\r
+ value when the tick count equals xNextTaskUnblockTime. However if\r
+ tickless idling is used it might be more important to enter sleep mode\r
+ at the earliest possible time - so reset xNextTaskUnblockTime here to\r
+ ensure it is updated at the earliest possible time. */\r
+ prvResetNextTaskUnblockTime();\r
+ }\r
+ #endif\r
+\r
return xReturn;\r
}\r
/*-----------------------------------------------------------*/\r
}\r
#endif /* portUSING_MPU_WRAPPERS */\r
\r
+ #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
+ {\r
+ pxTCB->ulNotifiedValue = 0;\r
+ pxTCB->eNotifyState = eNotWaitingNotification;\r
+ }\r
+ #endif\r
+\r
#if ( configUSE_NEWLIB_REENTRANT == 1 )\r
{\r
/* Initialise this task's Newlib reent structure. */\r
_reclaim_reent( &( pxTCB->xNewLib_reent ) );\r
}\r
#endif /* configUSE_NEWLIB_REENTRANT */\r
- vPortFreeAligned( pxTCB->pxStack );\r
+\r
+ #if( portUSING_MPU_WRAPPERS == 1 )\r
+ {\r
+ /* Only free the stack if it was allocated dynamically in the first\r
+ place. */\r
+ if( pxTCB->xUsingStaticallyAllocatedStack == pdFALSE )\r
+ {\r
+ vPortFreeAligned( pxTCB->pxStack );\r
+ }\r
+ }\r
+ #else\r
+ {\r
+ vPortFreeAligned( pxTCB->pxStack );\r
+ }\r
+ #endif\r
+\r
vPortFree( pxTCB );\r
}\r
\r
#endif /* portCRITICAL_NESTING_IN_TCB */\r
/*-----------------------------------------------------------*/\r
\r
-#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) )\r
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )\r
+\r
+ static char *prvWriteNameToBuffer( char *pcBuffer, const char *pcTaskName )\r
+ {\r
+ BaseType_t x;\r
+\r
+ /* Start by copying the entire string. */\r
+ strcpy( pcBuffer, pcTaskName );\r
+\r
+ /* Pad the end of the string with spaces to ensure columns line up when\r
+ printed out. */\r
+ for( x = strlen( pcBuffer ); x < ( configMAX_TASK_NAME_LEN - 1 ); x++ )\r
+ {\r
+ pcBuffer[ x ] = ' ';\r
+ }\r
+\r
+ /* Terminate. */\r
+ pcBuffer[ x ] = 0x00;\r
+\r
+ /* Return the new end of string. */\r
+ return &( pcBuffer[ x ] );\r
+ }\r
+\r
+#endif /* ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) */\r
+/*-----------------------------------------------------------*/\r
+\r
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )\r
\r
void vTaskList( char * pcWriteBuffer )\r
{\r
{\r
switch( pxTaskStatusArray[ x ].eCurrentState )\r
{\r
- case eReady: cStatus = tskREADY_CHAR;\r
- break;\r
+ case eReady: cStatus = tskREADY_CHAR;\r
+ break;\r
\r
- case eBlocked: cStatus = tskBLOCKED_CHAR;\r
- break;\r
+ case eBlocked: cStatus = tskBLOCKED_CHAR;\r
+ break;\r
\r
- case eSuspended: cStatus = tskSUSPENDED_CHAR;\r
- break;\r
+ case eSuspended: cStatus = tskSUSPENDED_CHAR;\r
+ break;\r
\r
- case eDeleted: cStatus = tskDELETED_CHAR;\r
- break;\r
+ case eDeleted: cStatus = tskDELETED_CHAR;\r
+ break;\r
\r
- default: /* Should not get here, but it is included\r
- to prevent static checking errors. */\r
- cStatus = 0x00;\r
- break;\r
+ default: /* Should not get here, but it is included\r
+ to prevent static checking errors. */\r
+ cStatus = 0x00;\r
+ break;\r
}\r
\r
- sprintf( pcWriteBuffer, "%s\t\t%c\t%u\t%u\t%u\r\n", pxTaskStatusArray[ x ].pcTaskName, cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber );\r
+ /* Write the task name to the string, padding with spaces so it\r
+ can be printed in tabular form more easily. */\r
+ pcWriteBuffer = prvWriteNameToBuffer( pcWriteBuffer, pxTaskStatusArray[ x ].pcTaskName );\r
+\r
+ /* Write the rest of the string. */\r
+ sprintf( pcWriteBuffer, "\t%c\t%u\t%u\t%u\r\n", cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber );\r
pcWriteBuffer += strlen( pcWriteBuffer );\r
}\r
\r
}\r
}\r
\r
-#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) ) */\r
+#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) */\r
/*----------------------------------------------------------*/\r
\r
-#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) )\r
+#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )\r
\r
void vTaskGetRunTimeStats( char *pcWriteBuffer )\r
{\r
ulTotalRunTimeDiv100 has already been divided by 100. */\r
ulStatsAsPercentage = pxTaskStatusArray[ x ].ulRunTimeCounter / ulTotalTime;\r
\r
+ /* Write the task name to the string, padding with\r
+ spaces so it can be printed in tabular form more\r
+ easily. */\r
+ pcWriteBuffer = prvWriteNameToBuffer( pcWriteBuffer, pxTaskStatusArray[ x ].pcTaskName );\r
+\r
if( ulStatsAsPercentage > 0UL )\r
{\r
#ifdef portLU_PRINTF_SPECIFIER_REQUIRED\r
{\r
- sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );\r
+ sprintf( pcWriteBuffer, "\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );\r
}\r
#else\r
{\r
/* sizeof( int ) == sizeof( long ) so a smaller\r
printf() library can be used. */\r
- sprintf( pcWriteBuffer, "%s\t\t%u\t\t%u%%\r\n", pxTaskStatusArray[ x ].pcTaskName, ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage );\r
+ sprintf( pcWriteBuffer, "\t%u\t\t%u%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage );\r
}\r
#endif\r
}\r
consumed less than 1% of the total run time. */\r
#ifdef portLU_PRINTF_SPECIFIER_REQUIRED\r
{\r
- sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );\r
+ sprintf( pcWriteBuffer, "\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].ulRunTimeCounter );\r
}\r
#else\r
{\r
/* sizeof( int ) == sizeof( long ) so a smaller\r
printf() library can be used. */\r
- sprintf( pcWriteBuffer, "%s\t\t%u\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter );\r
+ sprintf( pcWriteBuffer, "\t%u\t\t<1%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter );\r
}\r
#endif\r
}\r
}\r
}\r
\r
-#endif /* ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) ) */\r
+#endif /* ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) */\r
/*-----------------------------------------------------------*/\r
\r
TickType_t uxTaskResetEventItemValue( void )\r
}\r
\r
#endif /* configUSE_MUTEXES */\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( configUSE_TASK_NOTIFICATIONS == 1 )\r
+\r
+ uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )\r
+ {\r
+ TickType_t xTimeToWake;\r
+ uint32_t ulReturn;\r
+\r
+ taskENTER_CRITICAL();\r
+ {\r
+ /* Only block if the notification count is not already non-zero. */\r
+ if( pxCurrentTCB->ulNotifiedValue == 0UL )\r
+ {\r
+ /* Mark this task as waiting for a notification. */\r
+ pxCurrentTCB->eNotifyState = eWaitingNotification;\r
+\r
+ if( xTicksToWait > ( TickType_t ) 0 )\r
+ {\r
+ /* The task is going to block. First it must be removed\r
+ from the ready list. */\r
+ if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ {\r
+ /* The current task must be in a ready list, so there is\r
+ no need to check, and the port reset macro can be called\r
+ directly. */\r
+ portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+\r
+ #if ( INCLUDE_vTaskSuspend == 1 )\r
+ {\r
+ if( xTicksToWait == portMAX_DELAY )\r
+ {\r
+ /* Add the task to the suspended task list instead\r
+ of a delayed task list to ensure the task is not\r
+ woken by a timing event. It will block\r
+ indefinitely. */\r
+ vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );\r
+ }\r
+ else\r
+ {\r
+ /* Calculate the time at which the task should be\r
+ woken if no notification events occur. This may\r
+ overflow but this doesn't matter, the scheduler will\r
+ handle it. */\r
+ xTimeToWake = xTickCount + xTicksToWait;\r
+ prvAddCurrentTaskToDelayedList( xTimeToWake );\r
+ }\r
+ }\r
+ #else /* INCLUDE_vTaskSuspend */\r
+ {\r
+ /* Calculate the time at which the task should be\r
+ woken if the event does not occur. This may\r
+ overflow but this doesn't matter, the scheduler will\r
+ handle it. */\r
+ xTimeToWake = xTickCount + xTicksToWait;\r
+ prvAddCurrentTaskToDelayedList( xTimeToWake );\r
+ }\r
+ #endif /* INCLUDE_vTaskSuspend */\r
+\r
+ /* All ports are written to allow a yield in a critical\r
+ section (some will yield immediately, others wait until the\r
+ critical section exits) - but it is not something that\r
+ application code should ever do. */\r
+ portYIELD_WITHIN_API();\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ taskEXIT_CRITICAL();\r
+\r
+ taskENTER_CRITICAL();\r
+ {\r
+ ulReturn = pxCurrentTCB->ulNotifiedValue;\r
+\r
+ if( ulReturn != 0UL )\r
+ {\r
+ if( xClearCountOnExit != pdFALSE )\r
+ {\r
+ pxCurrentTCB->ulNotifiedValue = 0UL;\r
+ }\r
+ else\r
+ {\r
+ ( pxCurrentTCB->ulNotifiedValue )--;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
\r
+ pxCurrentTCB->eNotifyState = eNotWaitingNotification;\r
+ }\r
+ taskEXIT_CRITICAL();\r
+\r
+ return ulReturn;\r
+ }\r
+\r
+#endif /* configUSE_TASK_NOTIFICATIONS */\r
/*-----------------------------------------------------------*/\r
\r
+#if( configUSE_TASK_NOTIFICATIONS == 1 )\r
+\r
+ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )\r
+ {\r
+ TickType_t xTimeToWake;\r
+ BaseType_t xReturn;\r
+\r
+ taskENTER_CRITICAL();\r
+ {\r
+ /* Only block if a notification is not already pending. */\r
+ if( pxCurrentTCB->eNotifyState != eNotified )\r
+ {\r
+ /* Clear bits in the task's notification value as bits may get\r
+ set by the notifying task or interrupt. This can be used to\r
+ clear the value to zero. */\r
+ pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;\r
+\r
+ /* Mark this task as waiting for a notification. */\r
+ pxCurrentTCB->eNotifyState = eWaitingNotification;\r
+\r
+ if( xTicksToWait > ( TickType_t ) 0 )\r
+ {\r
+ /* The task is going to block. First it must be removed\r
+ from the ready list. */\r
+ if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ {\r
+ /* The current task must be in a ready list, so there is\r
+ no need to check, and the port reset macro can be called\r
+ directly. */\r
+ portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+\r
+ #if ( INCLUDE_vTaskSuspend == 1 )\r
+ {\r
+ if( xTicksToWait == portMAX_DELAY )\r
+ {\r
+ /* Add the task to the suspended task list instead\r
+ of a delayed task list to ensure the task is not\r
+ woken by a timing event. It will block\r
+ indefinitely. */\r
+ vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );\r
+ }\r
+ else\r
+ {\r
+ /* Calculate the time at which the task should be\r
+ woken if no notification events occur. This may\r
+ overflow but this doesn't matter, the scheduler will\r
+ handle it. */\r
+ xTimeToWake = xTickCount + xTicksToWait;\r
+ prvAddCurrentTaskToDelayedList( xTimeToWake );\r
+ }\r
+ }\r
+ #else /* INCLUDE_vTaskSuspend */\r
+ {\r
+ /* Calculate the time at which the task should be\r
+ woken if the event does not occur. This may\r
+ overflow but this doesn't matter, the scheduler will\r
+ handle it. */\r
+ xTimeToWake = xTickCount + xTicksToWait;\r
+ prvAddCurrentTaskToDelayedList( xTimeToWake );\r
+ }\r
+ #endif /* INCLUDE_vTaskSuspend */\r
+\r
+ /* All ports are written to allow a yield in a critical\r
+ section (some will yield immediately, others wait until the\r
+ critical section exits) - but it is not something that\r
+ application code should ever do. */\r
+ portYIELD_WITHIN_API();\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ taskEXIT_CRITICAL();\r
+\r
+ taskENTER_CRITICAL();\r
+ {\r
+ if( pulNotificationValue != NULL )\r
+ {\r
+ /* Output the current notification value, which may or may not\r
+ have changed. */\r
+ *pulNotificationValue = pxCurrentTCB->ulNotifiedValue;\r
+ }\r
+\r
+ /* If eNotifyValue is set then either the task never entered the\r
+ blocked state (because a notification was already pending) or the\r
+ task unblocked because of a notification. Otherwise the task\r
+ unblocked because of a timeout. */\r
+ if( pxCurrentTCB->eNotifyState == eWaitingNotification )\r
+ {\r
+ /* A notification was not received. */\r
+ xReturn = pdFALSE;\r
+ }\r
+ else\r
+ {\r
+ /* A notification was already pending or a notification was\r
+ received while the task was waiting. */\r
+ pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnExit;\r
+ xReturn = pdTRUE;\r
+ }\r
+\r
+ pxCurrentTCB->eNotifyState = eNotWaitingNotification;\r
+ }\r
+ taskEXIT_CRITICAL();\r
+\r
+ return xReturn;\r
+ }\r
+\r
+#endif /* configUSE_TASK_NOTIFICATIONS */\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( configUSE_TASK_NOTIFICATIONS == 1 )\r
+\r
+ BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction )\r
+ {\r
+ TCB_t * pxTCB;\r
+ eNotifyValue eOriginalNotifyState;\r
+ BaseType_t xReturn = pdPASS;\r
+\r
+ configASSERT( xTaskToNotify );\r
+ pxTCB = ( TCB_t * ) xTaskToNotify;\r
+\r
+ taskENTER_CRITICAL();\r
+ {\r
+ eOriginalNotifyState = pxTCB->eNotifyState;\r
+\r
+ pxTCB->eNotifyState = eNotified;\r
+\r
+ switch( eAction )\r
+ {\r
+ case eSetBits :\r
+ pxTCB->ulNotifiedValue |= ulValue;\r
+ break;\r
+\r
+ case eIncrement :\r
+ ( pxTCB->ulNotifiedValue )++;\r
+ break;\r
+\r
+ case eSetValueWithOverwrite :\r
+ pxTCB->ulNotifiedValue = ulValue;\r
+ break;\r
+\r
+ case eSetValueWithoutOverwrite :\r
+ if( eOriginalNotifyState != eNotified )\r
+ {\r
+ pxTCB->ulNotifiedValue = ulValue;\r
+ }\r
+ else\r
+ {\r
+ /* The value could not be written to the task. */\r
+ xReturn = pdFAIL;\r
+ }\r
+ break;\r
+\r
+ case eNoAction:\r
+ /* The task is being notified without its notify value being\r
+ updated. */\r
+ break;\r
+ }\r
+\r
+\r
+ /* If the task is in the blocked state specifically to wait for a\r
+ notification then unblock it now. */\r
+ if( eOriginalNotifyState == eWaitingNotification )\r
+ {\r
+ ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ prvAddTaskToReadyList( pxTCB );\r
+\r
+ /* The task should not have been on an event list. */\r
+ configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );\r
+\r
+ if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )\r
+ {\r
+ /* The notified task has a priority above the currently\r
+ executing task so a yield is required. */\r
+ portYIELD_WITHIN_API();\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ taskEXIT_CRITICAL();\r
+\r
+ return xReturn;\r
+ }\r
+\r
+#endif /* configUSE_TASK_NOTIFICATIONS */\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( configUSE_TASK_NOTIFICATIONS == 1 )\r
+\r
+ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken )\r
+ {\r
+ TCB_t * pxTCB;\r
+ eNotifyValue eOriginalNotifyState;\r
+ BaseType_t xReturn = pdPASS;\r
+ UBaseType_t uxSavedInterruptStatus;\r
+\r
+ configASSERT( xTaskToNotify );\r
+\r
+ /* RTOS ports that support interrupt nesting have the concept of a\r
+ maximum system call (or maximum API call) interrupt priority.\r
+ Interrupts that are above the maximum system call priority are keep\r
+ permanently enabled, even when the RTOS kernel is in a critical section,\r
+ but cannot make any calls to FreeRTOS API functions. If configASSERT()\r
+ is defined in FreeRTOSConfig.h then\r
+ portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion\r
+ failure if a FreeRTOS API function is called from an interrupt that has\r
+ been assigned a priority above the configured maximum system call\r
+ priority. Only FreeRTOS functions that end in FromISR can be called\r
+ from interrupts that have been assigned a priority at or (logically)\r
+ below the maximum system call interrupt priority. FreeRTOS maintains a\r
+ separate interrupt safe API to ensure interrupt entry is as fast and as\r
+ simple as possible. More information (albeit Cortex-M specific) is\r
+ provided on the following link:\r
+ http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
+ portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
+\r
+ pxTCB = ( TCB_t * ) xTaskToNotify;\r
+\r
+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
+ {\r
+ eOriginalNotifyState = pxTCB->eNotifyState;\r
+\r
+ pxTCB->eNotifyState = eNotified;\r
+\r
+ switch( eAction )\r
+ {\r
+ case eSetBits :\r
+ pxTCB->ulNotifiedValue |= ulValue;\r
+ break;\r
+\r
+ case eIncrement :\r
+ ( pxTCB->ulNotifiedValue )++;\r
+ break;\r
+\r
+ case eSetValueWithOverwrite :\r
+ pxTCB->ulNotifiedValue = ulValue;\r
+ break;\r
+\r
+ case eSetValueWithoutOverwrite :\r
+ if( eOriginalNotifyState != eNotified )\r
+ {\r
+ pxTCB->ulNotifiedValue = ulValue;\r
+ }\r
+ else\r
+ {\r
+ /* The value could not be written to the task. */\r
+ xReturn = pdFAIL;\r
+ }\r
+ break;\r
+\r
+ case eNoAction :\r
+ /* The task is being notified without its notify value being\r
+ updated. */\r
+ break;\r
+ }\r
+\r
+\r
+ /* If the task is in the blocked state specifically to wait for a\r
+ notification then unblock it now. */\r
+ if( eOriginalNotifyState == eWaitingNotification )\r
+ {\r
+ /* The task should not have been on an event list. */\r
+ configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );\r
+\r
+ if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )\r
+ {\r
+ ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ prvAddTaskToReadyList( pxTCB );\r
+ }\r
+ else\r
+ {\r
+ /* The delayed and ready lists cannot be accessed, so hold\r
+ this task pending until the scheduler is resumed. */\r
+ vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );\r
+ }\r
+\r
+ if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )\r
+ {\r
+ /* The notified task has a priority above the currently\r
+ executing task so a yield is required. */\r
+ if( pxHigherPriorityTaskWoken != NULL )\r
+ {\r
+ *pxHigherPriorityTaskWoken = pdTRUE;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ }\r
+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );\r
+\r
+ return xReturn;\r
+ }\r
+\r
+#endif /* configUSE_TASK_NOTIFICATIONS */\r
+/*-----------------------------------------------------------*/\r
+\r
+#if( configUSE_TASK_NOTIFICATIONS == 1 )\r
+\r
+ void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )\r
+ {\r
+ TCB_t * pxTCB;\r
+ eNotifyValue eOriginalNotifyState;\r
+ UBaseType_t uxSavedInterruptStatus;\r
+\r
+ configASSERT( xTaskToNotify );\r
+\r
+ /* RTOS ports that support interrupt nesting have the concept of a\r
+ maximum system call (or maximum API call) interrupt priority.\r
+ Interrupts that are above the maximum system call priority are keep\r
+ permanently enabled, even when the RTOS kernel is in a critical section,\r
+ but cannot make any calls to FreeRTOS API functions. If configASSERT()\r
+ is defined in FreeRTOSConfig.h then\r
+ portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion\r
+ failure if a FreeRTOS API function is called from an interrupt that has\r
+ been assigned a priority above the configured maximum system call\r
+ priority. Only FreeRTOS functions that end in FromISR can be called\r
+ from interrupts that have been assigned a priority at or (logically)\r
+ below the maximum system call interrupt priority. FreeRTOS maintains a\r
+ separate interrupt safe API to ensure interrupt entry is as fast and as\r
+ simple as possible. More information (albeit Cortex-M specific) is\r
+ provided on the following link:\r
+ http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
+ portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
+\r
+ pxTCB = ( TCB_t * ) xTaskToNotify;\r
+\r
+ uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
+ {\r
+ eOriginalNotifyState = pxTCB->eNotifyState;\r
+ pxTCB->eNotifyState = eNotified;\r
+\r
+ /* 'Giving' is equivalent to incrementing a count in a counting\r
+ semaphore. */\r
+ ( pxTCB->ulNotifiedValue )++;\r
+\r
+ /* If the task is in the blocked state specifically to wait for a\r
+ notification then unblock it now. */\r
+ if( eOriginalNotifyState == eWaitingNotification )\r
+ {\r
+ /* The task should not have been on an event list. */\r
+ configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );\r
+\r
+ if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )\r
+ {\r
+ ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ prvAddTaskToReadyList( pxTCB );\r
+ }\r
+ else\r
+ {\r
+ /* The delayed and ready lists cannot be accessed, so hold\r
+ this task pending until the scheduler is resumed. */\r
+ vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );\r
+ }\r
+\r
+ if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )\r
+ {\r
+ /* The notified task has a priority above the currently\r
+ executing task so a yield is required. */\r
+ if( pxHigherPriorityTaskWoken != NULL )\r
+ {\r
+ *pxHigherPriorityTaskWoken = pdTRUE;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ }\r
+ portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );\r
+ }\r
+\r
+#endif /* configUSE_TASK_NOTIFICATIONS */\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+\r
#ifdef FREERTOS_MODULE_TEST\r
#include "tasks_test_access_functions.h"\r
#endif\r
projects / freertos / blobdiff