len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-06-06 20:39:04 -04:00
Code Issues Packages Projects Releases Wiki Activity

Release candidate - this will be tagged as FreeRTOS V8.2.0rc1 and a zip file provided.

Browse source 
Minor lint changes.
This commit is contained in:
Richard Barry 2014-12-24 09:40:58 +00:00
parent 5dd77c7aeb
commit 271393b7d9
6 changed files with 69 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
FreeRTOS-Plus/Source/FreeRTOS-Plus-UDP/portable/NetworkInterface/SAM4E/NetworkInterface.c
View file

@ -159,7 +159,7 @@ BaseType_t xHigherPriorityTaskWoken = pdFALSE;
/* Unblock the deferred interrupt handler task if the event was an Rx. */ /* Unblock the deferred interrupt handler task if the event was an Rx. */
if( ( ulStatus & GMAC_RSR_REC ) != 0 ) if( ( ulStatus & GMAC_RSR_REC ) != 0 )
{ {
xTaskNotifyGiveFromISR( xMACEventHandlingTask, &xHigherPriorityTaskWoken ); vTaskNotifyGiveFromISR( xMACEventHandlingTask, &xHigherPriorityTaskWoken );
} }
portEND_SWITCHING_ISR( xHigherPriorityTaskWoken ); portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );

2
FreeRTOS/Demo/Common/Minimal/TaskNotify.c
View file

@ -489,7 +489,7 @@ const BaseType_t xCallInterval = pdMS_TO_TICKS( 50 );
/* It is time to 'give' the notification again. */ /* It is time to 'give' the notification again. */
xCallCount = 0; xCallCount = 0;
xTaskNotifyGiveFromISR( xTaskToNotify, NULL ); vTaskNotifyGiveFromISR( xTaskToNotify, NULL );
ulTimerNotificationsSent++; ulTimerNotificationsSent++;
} }
} }

34
FreeRTOS/Source/include/list.h
View file

@ -171,26 +171,26 @@ memory. They will not catch data errors caused by incorrect configuration or
use of FreeRTOS.*/ use of FreeRTOS.*/
#if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 ) #if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 )
/* Define the macros to do nothing. */ /* Define the macros to do nothing. */
#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_1 #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_2 #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
#define listLIST_INTEGRITY_CHECK_VALUE_1 #define listFIRST_LIST_INTEGRITY_CHECK_VALUE
#define listLIST_INTEGRITY_CHECK_VALUE_2 #define listSECOND_LIST_INTEGRITY_CHECK_VALUE
#define listSET_LIST_ITEM_INTEGRITY_CHECK_1_VALUE( pxItem ) #define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
#define listSET_LIST_ITEM_INTEGRITY_CHECK_2_VALUE( pxItem ) #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList ) #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )
#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList ) #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )
#define listTEST_LIST_ITEM_INTEGRITY( pxItem ) #define listTEST_LIST_ITEM_INTEGRITY( pxItem )
#define listTEST_LIST_INTEGRITY( pxList ) #define listTEST_LIST_INTEGRITY( pxList )
#else #else
/* Define macros that add new members into the list structures. */ /* Define macros that add new members into the list structures. */
#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_1 TickType_t xListItemIntegrityValue1; #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue1;
#define listLIST_ITEM_INTEGRITY_CHECK_VALUE_2 TickType_t xListItemIntegrityValue2; #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue2;
#define listLIST_INTEGRITY_CHECK_VALUE_1 TickType_t xListIntegrityValue1; #define listFIRST_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue1;
#define listLIST_INTEGRITY_CHECK_VALUE_2 TickType_t xListIntegrityValue2; #define listSECOND_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue2;
/* Define macros that set the new structure members to known values. */ /* Define macros that set the new structure members to known values. */
#define listSET_LIST_ITEM_INTEGRITY_CHECK_1_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE #define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
#define listSET_LIST_ITEM_INTEGRITY_CHECK_2_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList ) ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList ) ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList ) ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList ) ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
@ -206,19 +206,19 @@ use of FreeRTOS.*/
*/ */
struct xLIST_ITEM struct xLIST_ITEM
{ {
listLIST_ITEM_INTEGRITY_CHECK_VALUE_1 /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */ listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
configLIST_VOLATILE TickType_t xItemValue; /*< The value being listed. In most cases this is used to sort the list in descending order. */ configLIST_VOLATILE TickType_t xItemValue; /*< The value being listed. In most cases this is used to sort the list in descending order. */
struct xLIST_ITEM * configLIST_VOLATILE pxNext; /*< Pointer to the next ListItem_t in the list. */ struct xLIST_ITEM * configLIST_VOLATILE pxNext; /*< Pointer to the next ListItem_t in the list. */
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; /*< Pointer to the previous ListItem_t in the list. */ struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; /*< Pointer to the previous ListItem_t in the list. */
void * pvOwner; /*< Pointer to the object (normally a TCB) that contains the list item. There is therefore a two way link between the object containing the list item and the list item itself. */ void * pvOwner; /*< Pointer to the object (normally a TCB) that contains the list item. There is therefore a two way link between the object containing the list item and the list item itself. */
void * configLIST_VOLATILE pvContainer; /*< Pointer to the list in which this list item is placed (if any). */ void * configLIST_VOLATILE pvContainer; /*< Pointer to the list in which this list item is placed (if any). */
listLIST_ITEM_INTEGRITY_CHECK_VALUE_2 /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */ listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
}; };
typedef struct xLIST_ITEM ListItem_t; /* For some reason lint wants this as two separate definitions. */ typedef struct xLIST_ITEM ListItem_t; /* For some reason lint wants this as two separate definitions. */
struct xMINI_LIST_ITEM struct xMINI_LIST_ITEM
{ {
listLIST_ITEM_INTEGRITY_CHECK_VALUE_1 /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */ listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
configLIST_VOLATILE TickType_t xItemValue; configLIST_VOLATILE TickType_t xItemValue;
struct xLIST_ITEM * configLIST_VOLATILE pxNext; struct xLIST_ITEM * configLIST_VOLATILE pxNext;
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
@ -230,11 +230,11 @@ typedef struct xMINI_LIST_ITEM MiniListItem_t;
*/ */
typedef struct xLIST typedef struct xLIST
{ {
listLIST_INTEGRITY_CHECK_VALUE_1 /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */ listFIRST_LIST_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
configLIST_VOLATILE UBaseType_t uxNumberOfItems; configLIST_VOLATILE UBaseType_t uxNumberOfItems;
ListItem_t * configLIST_VOLATILE pxIndex; /*< Used to walk through the list. Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */ ListItem_t * configLIST_VOLATILE pxIndex; /*< Used to walk through the list. Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */
MiniListItem_t xListEnd; /*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */ MiniListItem_t xListEnd; /*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
listLIST_INTEGRITY_CHECK_VALUE_2 /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */ listSECOND_LIST_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
} List_t; } List_t;
/* /*

95
FreeRTOS/Source/include/task.h
View file

@ -147,7 +147,7 @@ typedef enum
/* Actions that can be performed when vTaskNotify() is called. */ /* Actions that can be performed when vTaskNotify() is called. */
typedef enum typedef enum
{ {
eNoAction, /* Notify the task without updating its notify value. */ eNoAction = 0, /* Notify the task without updating its notify value. */
eSetBits, /* Set bits in the task's notification value. */ eSetBits, /* Set bits in the task's notification value. */
eIncrement, /* Increment the task's notification value. */ eIncrement, /* Increment the task's notification value. */
eSetValueWithOverwrite, /* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */ eSetValueWithOverwrite, /* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
@ -1410,8 +1410,8 @@ void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e9
* task. h * task. h
* <PRE>BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );</PRE> * <PRE>BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );</PRE>
* *
* configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
* available. * function to be available.
* *
* When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
* "notification value", which is a 32-bit unsigned integer (uint32_t). * "notification value", which is a 32-bit unsigned integer (uint32_t).
@ -1433,14 +1433,11 @@ void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e9
* (unblocked) and the notification cleared. * (unblocked) and the notification cleared.
* *
* A task can use xTaskNotifyWait() to [optionally] block to wait for a * A task can use xTaskNotifyWait() to [optionally] block to wait for a
* notification to be pending, or xTaskNotifyTake() to [optionally] block * notification to be pending, or ulTaskNotifyTake() to [optionally] block
* to wait for its notification value to have a non-zero value. The task does * to wait for its notification value to have a non-zero value. The task does
* not consume any CPU time while it is in the Blocked state. * not consume any CPU time while it is in the Blocked state.
* *
* See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
* it is best to use a task notification to send an event to a task compared to
* when it is best to use an intermediary object (such as a queue, semaphore,
* mutex or event group) to send an event to a task.
* *
* @param xTaskToNotify The handle of the task being notified. The handle to a * @param xTaskToNotify The handle of the task being notified. The handle to a
* task can be returned from the xTaskCreate() API function used to create the * task can be returned from the xTaskCreate() API function used to create the
@ -1490,8 +1487,8 @@ BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAct
* task. h * task. h
* <PRE>BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );</PRE> * <PRE>BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );</PRE>
* *
* configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
* available. * function to be available.
* *
* When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
* "notification value", which is a 32-bit unsigned integer (uint32_t). * "notification value", which is a 32-bit unsigned integer (uint32_t).
@ -1516,14 +1513,11 @@ BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAct
* (unblocked) and the notification cleared. * (unblocked) and the notification cleared.
* *
* A task can use xTaskNotifyWait() to [optionally] block to wait for a * A task can use xTaskNotifyWait() to [optionally] block to wait for a
* notification to be pending, or xTaskNotifyTake() to [optionally] block * notification to be pending, or ulTaskNotifyTake() to [optionally] block
* to wait for its notification value to have a non-zero value. The task does * to wait for its notification value to have a non-zero value. The task does
* not consume any CPU time while it is in the Blocked state. * not consume any CPU time while it is in the Blocked state.
* *
* See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
* it is best to use a task notification to send an event to a task compared to
* when it is best to use an intermediary object (such as a queue, semaphore,
* mutex or event group) to send an event to a task.
* *
* @param xTaskToNotify The handle of the task being notified. The handle to a * @param xTaskToNotify The handle of the task being notified. The handle to a
* task can be returned from the xTaskCreate() API function used to create the * task can be returned from the xTaskCreate() API function used to create the
@ -1580,10 +1574,10 @@ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNo
/** /**
* task. h * task. h
* <PRE>BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );</pre> * <PRE>BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );</pre>
* *
* configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
* available. * function to be available.
* *
* When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
* "notification value", which is a 32-bit unsigned integer (uint32_t). * "notification value", which is a 32-bit unsigned integer (uint32_t).
@ -1605,14 +1599,11 @@ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNo
* (unblocked) and the notification cleared. * (unblocked) and the notification cleared.
* *
* A task can use xTaskNotifyWait() to [optionally] block to wait for a * A task can use xTaskNotifyWait() to [optionally] block to wait for a
* notification to be pending, or xTaskNotifyTake() to [optionally] block * notification to be pending, or ulTaskNotifyTake() to [optionally] block
* to wait for its notification value to have a non-zero value. The task does * to wait for its notification value to have a non-zero value. The task does
* not consume any CPU time while it is in the Blocked state. * not consume any CPU time while it is in the Blocked state.
* *
* See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
* it is best to use a task notification to send an event to a task compared to
* when it is best to use an intermediary object (such as a queue, semaphore,
* mutex or event group) to send an event to a task.
* *
* @param ulBitsToClearOnEntry Bits that are set in ulBitsToClearOnEntry value * @param ulBitsToClearOnEntry Bits that are set in ulBitsToClearOnEntry value
* will be cleared in the calling task's notification value before the task * will be cleared in the calling task's notification value before the task
@ -1654,14 +1645,14 @@ BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNo
* \defgroup xTaskNotifyWait xTaskNotifyWait * \defgroup xTaskNotifyWait xTaskNotifyWait
* \ingroup TaskNotifications * \ingroup TaskNotifications
*/ */
BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait ); BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
/** /**
* task. h * task. h
* <PRE>BaseType_t xTaskNotifyGive( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken ); * <PRE>BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );</PRE>
* *
* configUSE_TASK_NOTIFICATIONS must be defined as 1 for this macro to be * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
* available. * to be available.
* *
* When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
* "notification value", which is a 32-bit unsigned integer (uint32_t). * "notification value", which is a 32-bit unsigned integer (uint32_t).
@ -1687,7 +1678,7 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToCl
* using the ulTaskNotificationTake() API function rather than the * using the ulTaskNotificationTake() API function rather than the
* xTaskNotifyWait() API function. * xTaskNotifyWait() API function.
* *
* See http://www.FreeRTOS.org/RTOS_task_notifications.html for more details. * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
* *
* @param xTaskToNotify The handle of the task being notified. The handle to a * @param xTaskToNotify The handle of the task being notified. The handle to a
* task can be returned from the xTaskCreate() API function used to create the * task can be returned from the xTaskCreate() API function used to create the
@ -1704,10 +1695,10 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToCl
/** /**
* task. h * task. h
* <PRE>BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken ); * <PRE>void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
* *
* configUSE_TASK_NOTIFICATIONS must be defined as 1 for this macro to be * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
* available. * to be available.
* *
* When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
* "notification value", which is a 32-bit unsigned integer (uint32_t). * "notification value", which is a 32-bit unsigned integer (uint32_t).
@ -1725,47 +1716,44 @@ BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToCl
* task notifications can be used to send data to a task, or be used as light * task notifications can be used to send data to a task, or be used as light
* weight and fast binary or counting semaphores. * weight and fast binary or counting semaphores.
* *
* xTaskNotifyGiveFromISR() is a helper macro intended for use when task * vTaskNotifyGiveFromISR() is intended for use when task notifications are
* notifications are used as light weight and faster binary or counting * used as light weight and faster binary or counting semaphore equivalents.
* semaphore equivalents. Actual FreeRTOS semaphores are given from an ISR * Actual FreeRTOS semaphores are given from an ISR using the
* using the xSemaphoreGiveFromISR() API function, the equivalent action that * xSemaphoreGiveFromISR() API function, the equivalent action that instead uses
* instead uses a task notification is xTaskNotifyGiveFromISR(). * a task notification is vTaskNotifyGiveFromISR().
* *
* When task notifications are being used as a binary or counting semaphore * When task notifications are being used as a binary or counting semaphore
* equivalent then the task being notified should wait for the notification * equivalent then the task being notified should wait for the notification
* using the ulTaskNotificationTake() API function rather than the * using the ulTaskNotificationTake() API function rather than the
* xTaskNotifyWait() API function. * xTaskNotifyWait() API function.
* *
* See http://www.FreeRTOS.org/RTOS_task_notifications.html for more details. * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
* *
* @param xTaskToNotify The handle of the task being notified. The handle to a * @param xTaskToNotify The handle of the task being notified. The handle to a
* task can be returned from the xTaskCreate() API function used to create the * task can be returned from the xTaskCreate() API function used to create the
* task, and the handle of the currently running task can be obtained by calling * task, and the handle of the currently running task can be obtained by calling
* xTaskGetCurrentTaskHandle(). * xTaskGetCurrentTaskHandle().
* *
* @param pxHigherPriorityTaskWoken xTaskNotifyGiveFromISR() will set * @param pxHigherPriorityTaskWoken vTaskNotifyGiveFromISR() will set
* *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
* task to which the notification was sent to leave the Blocked state, and the * task to which the notification was sent to leave the Blocked state, and the
* unblocked task has a priority higher than the currently running task. If * unblocked task has a priority higher than the currently running task. If
* xTaskNotifyGiveFromISR() sets this value to pdTRUE then a context switch * vTaskNotifyGiveFromISR() sets this value to pdTRUE then a context switch
* should be requested before the interrupt is exited. How a context switch is * should be requested before the interrupt is exited. How a context switch is
* requested from an ISR is dependent on the port - see the documentation page * requested from an ISR is dependent on the port - see the documentation page
* for the port in use. * for the port in use.
* *
* @return xTaskNotifyGiveFromISR() is a macro that calls xTaskNotifyFromISR()
* with the eAction parameter set to eIncrement - so pdPASS is always returned.
*
* \defgroup xTaskNotifyWait xTaskNotifyWait * \defgroup xTaskNotifyWait xTaskNotifyWait
* \ingroup TaskNotifications * \ingroup TaskNotifications
*/ */
BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken ); void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken );
/** /**
* task. h * task. h
* <PRE>uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );</pre> * <PRE>uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );</pre>
* *
* configUSE_TASK_NOTIFICATIONS must be defined as 1 for this function to be * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
* available. * function to be available.
* *
* When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
* "notification value", which is a 32-bit unsigned integer (uint32_t). * "notification value", which is a 32-bit unsigned integer (uint32_t).
@ -1784,30 +1772,27 @@ BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHig
* faster and lighter weight binary or counting semaphore alternative. Actual * faster and lighter weight binary or counting semaphore alternative. Actual
* FreeRTOS semaphores are taken using the xSemaphoreTake() API function, the * FreeRTOS semaphores are taken using the xSemaphoreTake() API function, the
* equivalent action that instead uses a task notification is * equivalent action that instead uses a task notification is
* xTaskNotifyTake(). * ulTaskNotifyTake().
* *
* When a task is using its notification value as a binary or counting semaphore * When a task is using its notification value as a binary or counting semaphore
* other tasks should send notifications to it using the xTaskNotifyGive() * other tasks should send notifications to it using the xTaskNotifyGive()
* macro, or xTaskNotify() function with the eAction parameter set to * macro, or xTaskNotify() function with the eAction parameter set to
* eIncrement. * eIncrement.
* *
* xTaskNotifyTake() can either clear the task's notification value to * ulTaskNotifyTake() can either clear the task's notification value to
* zero on exit, in which case the notification value acts like a binary * zero on exit, in which case the notification value acts like a binary
* semaphore, or decrement the task's notification value on exit, in which case * semaphore, or decrement the task's notification value on exit, in which case
* the notification value acts like a counting semaphore. * the notification value acts like a counting semaphore.
* *
* A task can use xTaskNotifyTake() to [optionally] block to wait for a * A task can use ulTaskNotifyTake() to [optionally] block to wait for a
* the tasks notification value to be non-zero. The task does not consume any * the task's notification value to be non-zero. The task does not consume any
* CPU time while it is in the Blocked state. * CPU time while it is in the Blocked state.
* *
* Where as xTaskNotifyWait() will return when a notification is pending, * Where as xTaskNotifyWait() will return when a notification is pending,
* xTaskNotifyTake() will return when the task's notification value is * ulTaskNotifyTake() will return when the task's notification value is
* not zero. * not zero.
* *
* See http://www.FreeRTOS.org/RTOS_task_notifications.html for details of when * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
* it is best to use a task notification to send an event to a task compared to
* when it is best to use an intermediary object (such as a queue, semaphore,
* mutex or event group) to send an event to a task.
* *
* @param xClearCountOnExit if xClearCountOnExit is pdFALSE then the task's * @param xClearCountOnExit if xClearCountOnExit is pdFALSE then the task's
* notification value is decremented when the function exits. In this way the * notification value is decremented when the function exits. In this way the
@ -1819,7 +1804,7 @@ BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHig
* @param xTicksToWait The maximum amount of time that the task should wait in * @param xTicksToWait The maximum amount of time that the task should wait in
* the Blocked state for the task's notification value to be greater than zero, * the Blocked state for the task's notification value to be greater than zero,
* should the count not already be greater than zero when * should the count not already be greater than zero when
* xTaskNotifyTake() was called. The task will not consume any processing * ulTaskNotifyTake() was called. The task will not consume any processing
* time while it is in the Blocked state. This is specified in kernel ticks, * time while it is in the Blocked state. This is specified in kernel ticks,
* the macro pdMS_TO_TICSK( value_in_ms ) can be used to convert a time * the macro pdMS_TO_TICSK( value_in_ms ) can be used to convert a time
* specified in milliseconds to a time specified in ticks. * specified in milliseconds to a time specified in ticks.

4
FreeRTOS/Source/list.c
View file

@ -134,8 +134,8 @@ void vListInitialiseItem( ListItem_t * const pxItem )
/* Write known values into the list item if /* Write known values into the list item if
configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */ configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
listSET_LIST_ITEM_INTEGRITY_CHECK_1_VALUE( pxItem ); listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
listSET_LIST_ITEM_INTEGRITY_CHECK_2_VALUE( pxItem ); listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/

19
FreeRTOS/Source/tasks.c
View file

@ -147,7 +147,7 @@ functions but without including stdio.h here. */
/* Value that can be assigned to the eNotifyState member of the TCB. */ /* Value that can be assigned to the eNotifyState member of the TCB. */
typedef enum typedef enum
{ {
eNotWaitingNotification, eNotWaitingNotification = 0,
eWaitingNotification, eWaitingNotification,
eNotified eNotified
} eNotifyValue; } eNotifyValue;
@ -3846,7 +3846,7 @@ TickType_t uxReturn;
/* Mark this task as waiting for a notification. */ /* Mark this task as waiting for a notification. */
pxCurrentTCB->eNotifyState = eWaitingNotification; pxCurrentTCB->eNotifyState = eWaitingNotification;
if( xTicksToWait > 0 ) if( xTicksToWait > ( TickType_t ) 0 )
{ {
/* The task is going to block. First it must be removed /* The task is going to block. First it must be removed
from the ready list. */ from the ready list. */
@ -3915,7 +3915,7 @@ TickType_t uxReturn;
{ {
ulReturn = pxCurrentTCB->ulNotifiedValue; ulReturn = pxCurrentTCB->ulNotifiedValue;
if( ulReturn != 0 ) if( ulReturn != 0UL )
{ {
if( xClearCountOnExit != pdFALSE ) if( xClearCountOnExit != pdFALSE )
{ {
@ -3943,7 +3943,7 @@ TickType_t uxReturn;
#if( configUSE_TASK_NOTIFICATIONS == 1 ) #if( configUSE_TASK_NOTIFICATIONS == 1 )
BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, BaseType_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait ) BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )
{ {
TickType_t xTimeToWake; TickType_t xTimeToWake;
BaseType_t xReturn; BaseType_t xReturn;
@ -3961,7 +3961,7 @@ TickType_t uxReturn;
/* Mark this task as waiting for a notification. */ /* Mark this task as waiting for a notification. */
pxCurrentTCB->eNotifyState = eWaitingNotification; pxCurrentTCB->eNotifyState = eWaitingNotification;
if( xTicksToWait > 0 ) if( xTicksToWait > ( TickType_t ) 0 )
{ {
/* The task is going to block. First it must be removed /* The task is going to block. First it must be removed
from the ready list. */ from the ready list. */
@ -4105,7 +4105,7 @@ TickType_t uxReturn;
} }
break; break;
default : case eNoAction:
/* The task is being notified without its notify value being /* The task is being notified without its notify value being
updated. */ updated. */
break; break;
@ -4209,7 +4209,7 @@ TickType_t uxReturn;
} }
break; break;
default : case eNoAction :
/* The task is being notified without its notify value being /* The task is being notified without its notify value being
updated. */ updated. */
break; break;
@ -4260,11 +4260,10 @@ TickType_t uxReturn;
#if( configUSE_TASK_NOTIFICATIONS == 1 ) #if( configUSE_TASK_NOTIFICATIONS == 1 )
BaseType_t xTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken ) void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )
{ {
TCB_t * pxTCB; TCB_t * pxTCB;
eNotifyValue eOriginalNotifyState; eNotifyValue eOriginalNotifyState;
BaseType_t xReturn = pdPASS;
UBaseType_t uxSavedInterruptStatus; UBaseType_t uxSavedInterruptStatus;
configASSERT( xTaskToNotify ); configASSERT( xTaskToNotify );
@ -4333,8 +4332,6 @@ TickType_t uxReturn;
} }
} }
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus ); portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
return xReturn;
} }
#endif /* configUSE_TASK_NOTIFICATIONS */ #endif /* configUSE_TASK_NOTIFICATIONS */