1219 lines
57 KiB
C
1219 lines
57 KiB
C
/*
|
|
* FreeRTOS V202212.00
|
|
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
* the Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* https://www.FreeRTOS.org
|
|
* https://github.com/FreeRTOS
|
|
*
|
|
*/
|
|
|
|
|
|
/*
|
|
* Tests the behaviour of arrays of task notifications per task. The tests in this
|
|
* file are additive to those implemented in FreeRTOS/Demo/Common/Minimal/TaskNotify.c.
|
|
*/
|
|
|
|
/* Standard includes. */
|
|
#include <limits.h>
|
|
|
|
/* Scheduler include files. */
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include "timers.h"
|
|
|
|
/* Demo program include files. */
|
|
#include "TaskNotifyArray.h"
|
|
|
|
#if ( configTASK_NOTIFICATION_ARRAY_ENTRIES < 3 )
|
|
#error This file tests direct to task notification arrays and needs configTASK_NOTIFICATION_ARRAY_ENTRIES to be at least 3.
|
|
#endif
|
|
|
|
/* Allow parameters to be overridden on a demo by demo basis. */
|
|
#ifndef notifyNOTIFY_ARRAY_TASK_STACK_SIZE
|
|
#define notifyNOTIFY_ARRAY_TASK_STACK_SIZE configMINIMAL_STACK_SIZE
|
|
#endif
|
|
|
|
#define notifyTASK_PRIORITY ( tskIDLE_PRIORITY )
|
|
|
|
/* Constants used in tests when setting/clearing bits. */
|
|
#define notifyUINT32_MAX ( ( uint32_t ) 0xffffffff )
|
|
#define notifyUINT32_HIGH_BYTE ( ( uint32_t ) 0xff000000 )
|
|
#define notifyUINT32_LOW_BYTE ( ( uint32_t ) 0x000000ff )
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/*
|
|
* Implementation of the task that runs the tests - the task runs some tests
|
|
* itself, and others where notifications are sent from a software timer or
|
|
* an interrupt (specifically the tick hook function).
|
|
*/
|
|
static void prvNotifiedTask( void * pvParameters );
|
|
|
|
/*
|
|
* Performs the tests that don't require notifications to be sent from a
|
|
* remote source.
|
|
*/
|
|
static void prvSingleTaskTests( void );
|
|
|
|
/*
|
|
* Uses a software timer to send notifications to the task while the task is
|
|
* suspended.
|
|
*/
|
|
static void prvTestNotifyTaskWhileSuspended( void );
|
|
|
|
/*
|
|
* Uses a software timer to send notifications to the index within the array of
|
|
* task notifications on which the task is blocked. The task should unblock and
|
|
* the state of all the other task notifications within the array should remain
|
|
* unchanged.
|
|
*/
|
|
static void prvBlockOnTheNotifiedIndexed( void );
|
|
|
|
/*
|
|
* As per prvBlockOnTheNotifiedIndexed(), but this time the notification comes from
|
|
* the tick hook function, so from an interrupt rather than from a software timer.
|
|
*/
|
|
static void prvBlockOnNotificationsComingFromInterrupts( void );
|
|
|
|
/*
|
|
* As per prvBlockOnTheNotifiedIndexed(), except this time the notification is
|
|
* sent to an index within the task notification array on which the task is not
|
|
* blocked, so this time the task should not unblock and the state of all the
|
|
* task notifications other than the one to which the notification was actually
|
|
* sent should remain unchanged.
|
|
*/
|
|
static void prvBlockOnANonNotifiedIndexed( void );
|
|
|
|
/*
|
|
* Callback of the software timer used to send notifications for the
|
|
* prvBlockOnTheNotifiedIndexed() and prvBlockOnANonNotifiedIndexed() tests.
|
|
*/
|
|
static void prvNotifyingTimerCallback( TimerHandle_t xTimer );
|
|
|
|
/*
|
|
* Callback for a timer that is used by the prvTestNotifyTaskWhileSuspended()
|
|
* test.
|
|
*/
|
|
static void prvSuspendedTaskTimerTestCallback( TimerHandle_t xExpiredTimer );
|
|
|
|
/*
|
|
* Utility function to create pseudo random numbers.
|
|
*/
|
|
static UBaseType_t prvRand( void );
|
|
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/* Counters used to check the task has not stalled. ulFineCycleCount is
|
|
* incremented within each test. ulCourseCycleCounter is incremented one every
|
|
* loop of all the tests to ensure each test is actually executing. The check task
|
|
* calls xAreTaskNotificationArrayTasksStillRunning() (implemented within this
|
|
* file) to check both counters are changing. */
|
|
static volatile uint32_t ulFineCycleCount = 0, ulCourseCycleCounter = 0;
|
|
|
|
/* The handle of the task that runs the tests and receives the notifications
|
|
* from the software timers and interrupts. */
|
|
static TaskHandle_t xTaskToNotify = NULL;
|
|
|
|
/* The software timers used to send notifications to the main test task. */
|
|
static TimerHandle_t xIncrementingIndexTimer = NULL;
|
|
static TimerHandle_t xNotifyWhileSuspendedTimer = NULL;
|
|
|
|
/* Used by the pseudo random number generating function. */
|
|
static size_t uxNextRand = 0;
|
|
|
|
/* Used to communicate when to send a task notification to the tick hook tests. */
|
|
static volatile BaseType_t xSendNotificationFromISR = pdFALSE;
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
void vStartTaskNotifyArrayTask( void )
|
|
{
|
|
const TickType_t xIncrementingIndexTimerPeriod = pdMS_TO_TICKS( 100 );
|
|
const TickType_t xSuspendTimerPeriod = pdMS_TO_TICKS( 50 );
|
|
|
|
/* Create the software timers used for these tests. The timer callbacks send
|
|
* notifications to this task. */
|
|
xNotifyWhileSuspendedTimer = xTimerCreate( "SingleNotify", xSuspendTimerPeriod, pdFALSE, NULL, prvSuspendedTaskTimerTestCallback );
|
|
xIncrementingIndexTimer = xTimerCreate( "Notifier", xIncrementingIndexTimerPeriod, pdFALSE, NULL, prvNotifyingTimerCallback );
|
|
configASSERT( xNotifyWhileSuspendedTimer );
|
|
configASSERT( xIncrementingIndexTimer );
|
|
|
|
/* Create the task that performs some tests by itself, then loops around
|
|
* being notified by both a software timer and an interrupt. */
|
|
xTaskCreate( prvNotifiedTask, /* Function that implements the task. */
|
|
"ArrayNotified", /* Text name for the task - for debugging only - not used by the kernel. */
|
|
notifyNOTIFY_ARRAY_TASK_STACK_SIZE, /* Task's stack size in words, not bytes!. */
|
|
NULL, /* Task parameter, not used in this case. */
|
|
notifyTASK_PRIORITY, /* Task priority, 0 is the lowest. */
|
|
&xTaskToNotify ); /* Used to pass a handle to the task out if needed, otherwise set to NULL. */
|
|
|
|
/* Pseudo seed the random number generator. */
|
|
uxNextRand = ( size_t ) prvRand;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvNotifiedTask( void * pvParameters )
|
|
{
|
|
/* Remove compiler warnings about unused parameters. */
|
|
( void ) pvParameters;
|
|
|
|
/* Loop through each set of test functions in turn. See the comments above
|
|
* the respective function prototypes above for more details. */
|
|
for( ; ; )
|
|
{
|
|
prvSingleTaskTests();
|
|
prvTestNotifyTaskWhileSuspended();
|
|
prvBlockOnTheNotifiedIndexed();
|
|
prvBlockOnANonNotifiedIndexed();
|
|
prvBlockOnNotificationsComingFromInterrupts();
|
|
ulCourseCycleCounter++;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvSingleTaskTests( void )
|
|
{
|
|
const TickType_t xTicksToWait = pdMS_TO_TICKS( 100UL );
|
|
BaseType_t xReturned;
|
|
uint32_t ulNotifiedValue, ulLoop, ulNotifyingValue, ulPreviousValue, ulExpectedValue;
|
|
TickType_t xTimeOnEntering, xTimeNow, xTimeDifference;
|
|
const uint32_t ulFirstNotifiedConst = 100001UL, ulSecondNotifiedValueConst = 5555UL, ulMaxLoops = 5UL;
|
|
const uint32_t ulBit0 = 0x01UL, ulBit1 = 0x02UL;
|
|
UBaseType_t uxIndexToTest, uxOtherIndexes;
|
|
|
|
|
|
/* ------------------------------------------------------------------------
|
|
* Check blocking when there are no notifications. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* Send notifications to the task notification in each index of the
|
|
* task notification array other than the one on which this task will
|
|
* block. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes != uxIndexToTest )
|
|
{
|
|
xTaskNotifyIndexed( xTaskToNotify, uxOtherIndexes, 0, eNoAction );
|
|
}
|
|
}
|
|
|
|
xTimeOnEntering = xTaskGetTickCount();
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, notifyUINT32_MAX, 0, &ulNotifiedValue, xTicksToWait );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* Should have blocked for the entire block time. */
|
|
xTimeNow = xTaskGetTickCount();
|
|
xTimeDifference = xTimeNow - xTimeOnEntering;
|
|
configASSERT( xTimeDifference >= xTicksToWait );
|
|
configASSERT( xReturned == pdFAIL );
|
|
configASSERT( ulNotifiedValue == 0UL );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
( void ) ulNotifiedValue;
|
|
|
|
/* Clear all the other notifications within the array of task
|
|
* notifications again ready for the next round. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes != uxIndexToTest )
|
|
{
|
|
xReturned = xTaskNotifyStateClearIndexed( xTaskToNotify, uxOtherIndexes );
|
|
|
|
/* The notification state was set above so expect it to still be
|
|
* set. */
|
|
configASSERT( xReturned == pdTRUE );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
* Check no blocking when notifications are pending. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* First notify the task notification at index uxIndexToTest within this
|
|
* task's own array of task notifications - this would not be a normal
|
|
* thing to do and is done here for test purposes only. */
|
|
xReturned = xTaskNotifyAndQueryIndexed( xTaskToNotify, uxIndexToTest, ulFirstNotifiedConst, eSetValueWithoutOverwrite, &ulPreviousValue );
|
|
|
|
/* Even through the 'without overwrite' action was used the update should
|
|
* have been successful. */
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* No bits should have been pending previously. */
|
|
configASSERT( ulPreviousValue == 0 );
|
|
( void ) ulPreviousValue;
|
|
|
|
/* The task should now have a notification pending in the task
|
|
* notification at index uxIndexToTest within the task notification array,
|
|
* and so not time out. */
|
|
xTimeOnEntering = xTaskGetTickCount();
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, notifyUINT32_MAX, 0, &ulNotifiedValue, xTicksToWait );
|
|
xTimeNow = xTaskGetTickCount();
|
|
xTimeDifference = xTimeNow - xTimeOnEntering;
|
|
configASSERT( xTimeDifference < xTicksToWait );
|
|
|
|
/* The task should have been notified, and the notified value should
|
|
* be equal to ulFirstNotifiedConst. */
|
|
configASSERT( xReturned == pdPASS );
|
|
configASSERT( ulNotifiedValue == ulFirstNotifiedConst );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
( void ) ulNotifiedValue;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Check the non-overwriting functionality. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* Send notifications to all indexes with the array of task
|
|
* notifications other than the one on which this task will block. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes != uxIndexToTest )
|
|
{
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxOtherIndexes, ulFirstNotifiedConst, eSetValueWithOverwrite );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
|
|
/* The notification is performed twice using two different notification
|
|
* values. The action says don't overwrite so only the first notification
|
|
* should pass and the value read back should also be that used with the
|
|
* first notification. The notification is sent to the task notification at
|
|
* index uxIndexToTest within the array of task notifications. */
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, ulFirstNotifiedConst, eSetValueWithoutOverwrite );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, ulSecondNotifiedValueConst, eSetValueWithoutOverwrite );
|
|
configASSERT( xReturned == pdFAIL );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* Waiting for the notification should now return immediately so a block
|
|
* time of zero is used. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, notifyUINT32_MAX, 0, &ulNotifiedValue, 0 );
|
|
|
|
configASSERT( xReturned == pdPASS );
|
|
configASSERT( ulNotifiedValue == ulFirstNotifiedConst );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
( void ) ulNotifiedValue;
|
|
|
|
/* Clear all the other task notifications within the array of task
|
|
* notifications again ready for the next round. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes != uxIndexToTest )
|
|
{
|
|
xReturned = xTaskNotifyStateClearIndexed( xTaskToNotify, uxOtherIndexes );
|
|
configASSERT( xReturned == pdTRUE );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
ulNotifiedValue = ulTaskNotifyValueClearIndexed( xTaskToNotify, uxOtherIndexes, notifyUINT32_MAX );
|
|
|
|
/* The notification value was set to ulFirstNotifiedConst in all
|
|
* the other indexes, so expect it to still have that value. */
|
|
configASSERT( ulNotifiedValue == ulFirstNotifiedConst );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Do the same again, only this time use the overwriting version. This time
|
|
* both notifications should pass, and the value written the second time should
|
|
* overwrite the value written the first time, and so be the value that is read
|
|
* back. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes != uxIndexToTest )
|
|
{
|
|
xTaskNotifyIndexed( xTaskToNotify, uxOtherIndexes, ulFirstNotifiedConst, eSetValueWithOverwrite );
|
|
}
|
|
}
|
|
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, ulFirstNotifiedConst, eSetValueWithOverwrite );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, ulSecondNotifiedValueConst, eSetValueWithOverwrite );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, 0, notifyUINT32_MAX, &ulNotifiedValue, 0 );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
configASSERT( ulNotifiedValue == ulSecondNotifiedValueConst );
|
|
( void ) ulNotifiedValue;
|
|
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes != uxIndexToTest )
|
|
{
|
|
xReturned = xTaskNotifyStateClearIndexed( xTaskToNotify, uxOtherIndexes );
|
|
configASSERT( xReturned == pdTRUE );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
ulNotifiedValue = ulTaskNotifyValueClearIndexed( xTaskToNotify, uxOtherIndexes, notifyUINT32_MAX );
|
|
configASSERT( ulNotifiedValue == ulFirstNotifiedConst );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* For each task notification within the array of task notifications, check
|
|
* notifications with no action pass without updating the value. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* First set the notification values of the task notification at index
|
|
* uxIndexToTest of the array of task notification to
|
|
* ulSecondNotifiedValueConst. */
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, ulSecondNotifiedValueConst, eSetValueWithOverwrite );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* Even though ulFirstNotifiedConst is used as the value next, the value
|
|
* read back should remain at ulSecondNotifiedConst as the action is set
|
|
* to eNoAction. */
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, ulFirstNotifiedConst, eNoAction );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* All task notifications in the array of task notifications up to and
|
|
* including index uxIndexToTest should still contain the same value. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes <= uxIndexToTest; uxOtherIndexes++ )
|
|
{
|
|
/* First zero is bits to clear on entry, the second is bits to clear on
|
|
* exist, the last 0 is the block time. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0, 0, &ulNotifiedValue, 0 );
|
|
configASSERT( ulNotifiedValue == ulSecondNotifiedValueConst );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
|
|
/* All array indexes in the array of task notifications after index
|
|
* uxIndexToTest should still contain 0 as they have not been set in this
|
|
* loop yet. This time use ulTaskNotifyValueClearIndexed() instead of
|
|
* xTaskNotifyWaitIndexed(), just for test coverage. */
|
|
for( uxOtherIndexes = uxIndexToTest + 1; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
/* This time 0 is the bits to clear parameter - so clearing no bits. */
|
|
ulNotifiedValue = ulTaskNotifyValueClearIndexed( NULL, uxOtherIndexes, 0 );
|
|
configASSERT( ulNotifiedValue == 0 );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Check incrementing values. For each task notification in the array of task
|
|
* notifications in turn, send ulMaxLoop increment notifications, then ensure
|
|
* the received value is as expected - which should be
|
|
* ulSecondNotificationValueConst plus how ever many times to loop iterated. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
for( ulLoop = 0; ulLoop < ulMaxLoops; ulLoop++ )
|
|
{
|
|
/* Increment the value of the task notification at index
|
|
* uxIndexToTest within the array of task notifications. */
|
|
xReturned = xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, 0, eIncrement );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
|
|
/* All array indexes up to and including uxIndexToTest should still
|
|
* contain the updated value. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes <= uxIndexToTest; uxOtherIndexes++ )
|
|
{
|
|
/* First zero is bits to clear on entry, the second is bits to clear on
|
|
* exist, the last 0 is the block time. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0, 0, &ulNotifiedValue, 0 );
|
|
configASSERT( ulNotifiedValue == ( ulSecondNotifiedValueConst + ulMaxLoops ) );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
|
|
/* Should not be any notifications pending now. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, 0, 0, &ulNotifiedValue, 0 );
|
|
configASSERT( xReturned == pdFAIL );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
( void ) ulNotifiedValue;
|
|
|
|
/* All notifications values in the array of task notifications after
|
|
* index uxIndexToTest should still contain the un-incremented
|
|
* ulSecondNotifiedValueConst as they have not been set in this loop yet.
|
|
* This time use ulTaskNotifyValueClearIndexed() instead of xTaskNotifyWaitIndexed(),
|
|
* just for test coverage. */
|
|
for( uxOtherIndexes = uxIndexToTest + 1; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
/* This time 0 is the bits to clear parameter - so clearing no bits. */
|
|
ulNotifiedValue = ulTaskNotifyValueClearIndexed( NULL, uxOtherIndexes, 0 );
|
|
configASSERT( ulNotifiedValue == ulSecondNotifiedValueConst );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
|
|
/* Clear all bits ready for next test. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* Start with all bits clear. */
|
|
ulTaskNotifyValueClearIndexed( NULL, uxIndexToTest, notifyUINT32_MAX );
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* For each task notification in the array of task notifications in turn, check
|
|
* all bits in the notification's value can be set by notifying the task with
|
|
* one additional bit set on each notification, and exiting the loop when all
|
|
* the bits are found to be set. As there are 32-bits the loop should execute
|
|
* 32 times before all the bits are found to be set. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
ulNotifyingValue = 0x01;
|
|
ulLoop = 0;
|
|
|
|
do
|
|
{
|
|
/* Set the next bit in the value of the task notification at index
|
|
* uxIndexToTest within the array of task notifications. */
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, ulNotifyingValue, eSetBits );
|
|
|
|
/* Wait for the notified value - which of course will already be
|
|
* available. Don't clear the bits on entry or exit as this loop is
|
|
* exited when all the bits are set. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, 0, 0, &ulNotifiedValue, 0 );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
ulLoop++;
|
|
|
|
/* Use the next bit on the next iteration around this loop. */
|
|
ulNotifyingValue <<= 1UL;
|
|
} while( ulNotifiedValue != notifyUINT32_MAX );
|
|
|
|
/* As a 32-bit value was used the loop should have executed 32 times before
|
|
* all the bits were set. */
|
|
configASSERT( ulLoop == 32 );
|
|
|
|
/* The value of each task notification within the array of task
|
|
* notifications up to and including index uxIndexToTest should still have
|
|
* all bits set. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes <= uxIndexToTest; uxOtherIndexes++ )
|
|
{
|
|
/* First zero is bits to clear on entry, the second is bits to clear on
|
|
* exist, the last 0 is the block time. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0, 0, &ulNotifiedValue, 0 );
|
|
configASSERT( ulNotifiedValue == notifyUINT32_MAX );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
|
|
/* The value of each task notification within the array of task
|
|
* notifications after index uxIndexToTest should still contain 0 as they
|
|
* have not been set in this loop yet. This time use ulTaskNotifyValueClearIndexed()
|
|
* instead of xTaskNotifyWaitIndexed(), just for test coverage. */
|
|
for( uxOtherIndexes = uxIndexToTest + 1; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
/* This time 0 is the bits to clear parameter - so clearing no bits. */
|
|
ulNotifiedValue = ulTaskNotifyValueClearIndexed( NULL, uxOtherIndexes, 0 );
|
|
configASSERT( ulNotifiedValue == 0 );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* For each task notification within the array of task notifications in turn,
|
|
* check bits are cleared on entry but not on exit when a notification fails
|
|
* to arrive before timing out - both with and without a timeout value. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* Wait for the notification - but this time it is not given by anything
|
|
* and should return pdFAIL. The parameters are set to clear bit zero on
|
|
* entry and bit one on exit. As no notification was received only the bit
|
|
* cleared on entry should actually get cleared. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, ulBit0, ulBit1, &ulNotifiedValue, xTicksToWait );
|
|
configASSERT( xReturned == pdFAIL );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* Send a notification with no action to the task notification at index
|
|
* uxIndexToTest within the array of task notifications. This should not
|
|
* update the bits even though notifyUINT32_MAX is used as the notification
|
|
* value. */
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, notifyUINT32_MAX, eNoAction );
|
|
|
|
/* All array indexes up to and including uxIndexToTest within the array
|
|
* of task notifications should have the modified value. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes <= uxIndexToTest; uxOtherIndexes++ )
|
|
{
|
|
/* Reading back the value should find bit 0 is clear, as this was cleared
|
|
* on entry, but bit 1 is not clear as it will not have been cleared on exit
|
|
* as no notification was received. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0x00UL, 0x00UL, &ulNotifiedValue, 0 );
|
|
|
|
if( uxOtherIndexes == uxIndexToTest )
|
|
{
|
|
/* This is the index being used this time round the loop and its
|
|
* notification state was set immediately above. */
|
|
configASSERT( xReturned == pdPASS );
|
|
}
|
|
else
|
|
{
|
|
/* Nothing should have set this index's notification state again. */
|
|
configASSERT( xReturned == pdFAIL );
|
|
}
|
|
|
|
configASSERT( ulNotifiedValue == ( notifyUINT32_MAX & ~ulBit0 ) );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
|
|
/* All array indexes after uxIndexToTest should still contain notifyUINT32_MAX
|
|
* left over from the previous test. This time use xTaskNotifyValueClear()
|
|
* instead of xTaskNotifyWaitIndexed(), just for test coverage. */
|
|
for( uxOtherIndexes = uxIndexToTest + 1; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
/* This time 0 is the bits to clear parameter - so clearing no bits. */
|
|
ulNotifiedValue = ulTaskNotifyValueClearIndexed( NULL, uxOtherIndexes, 0 );
|
|
configASSERT( ulNotifiedValue == notifyUINT32_MAX );
|
|
( void ) ulNotifiedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Now try clearing the bit on exit. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* The task is notified first using the task notification at index
|
|
* uxIndexToTest within the array of task notifications. */
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, 0, eNoAction );
|
|
xTaskNotifyWaitIndexed( uxIndexToTest, 0x00, ulBit1, &ulNotifiedValue, 0 );
|
|
|
|
/* However as the bit is cleared on exit, after the returned notification
|
|
* value is set, the returned notification value should not have the bit
|
|
* cleared... */
|
|
configASSERT( ulNotifiedValue == ( notifyUINT32_MAX & ~ulBit0 ) );
|
|
|
|
/* ...but reading the value back again should find that the bit was indeed
|
|
* cleared internally. The returned value should be pdFAIL however as nothing
|
|
* has notified the task in the mean time. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, 0x00, 0x00, &ulNotifiedValue, 0 );
|
|
configASSERT( xReturned == pdFAIL );
|
|
configASSERT( ulNotifiedValue == ( notifyUINT32_MAX & ~( ulBit0 | ulBit1 ) ) );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* No other indexes should have a notification pending. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes != uxIndexToTest )
|
|
{
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0x00UL, 0x00UL, &ulNotifiedValue, 0 );
|
|
configASSERT( xReturned == pdFAIL );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* For each task notification within the array of task notifications, try
|
|
* querying the previous value while notifying a task. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
xTaskNotifyAndQueryIndexed( xTaskToNotify, uxIndexToTest, 0x00, eSetBits, &ulPreviousValue );
|
|
configASSERT( ulNotifiedValue == ( notifyUINT32_MAX & ~( ulBit0 | ulBit1 ) ) );
|
|
|
|
/* Clear all bits. */
|
|
xTaskNotifyWaitIndexed( uxIndexToTest, 0x00, notifyUINT32_MAX, &ulNotifiedValue, 0 );
|
|
xTaskNotifyAndQueryIndexed( xTaskToNotify, uxIndexToTest, 0x00, eSetBits, &ulPreviousValue );
|
|
configASSERT( ulPreviousValue == 0 );
|
|
|
|
ulExpectedValue = 0;
|
|
|
|
for( ulLoop = 0x01; ulLoop < 0x80UL; ulLoop <<= 1UL )
|
|
{
|
|
/* Set the next bit up, and expect to receive the last bits set (so
|
|
* the previous value will not yet have the bit being set this time
|
|
* around). */
|
|
xTaskNotifyAndQueryIndexed( xTaskToNotify, uxIndexToTest, ulLoop, eSetBits, &ulPreviousValue );
|
|
configASSERT( ulExpectedValue == ulPreviousValue );
|
|
ulExpectedValue |= ulLoop;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* Clear the previous notifications. */
|
|
xTaskNotifyWaitIndexed( uxIndexToTest, notifyUINT32_MAX, 0, &ulNotifiedValue, 0 );
|
|
}
|
|
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* No task notification within the array of task notifications should
|
|
* have any notification pending, so an attempt to clear the notification
|
|
* state should fail. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
configASSERT( xTaskNotifyStateClearIndexed( NULL, uxOtherIndexes ) == pdFALSE );
|
|
}
|
|
|
|
/* Get the task to notify itself using the task notification at index
|
|
* uxIndexToTest within the array of task notifications. This is not a
|
|
* normal thing to do, and is only done here for test purposes. */
|
|
xTaskNotifyAndQueryIndexed( xTaskToNotify, uxIndexToTest, ulFirstNotifiedConst, eSetValueWithoutOverwrite, &ulPreviousValue );
|
|
|
|
/* Now the notification state should be eNotified, so it should now be
|
|
* possible to clear the notification state. Other indexes should still
|
|
* not have a notification pending - likewise uxIndexToTest should not have
|
|
* a notification pending once it has been cleared. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
if( uxOtherIndexes == uxIndexToTest )
|
|
{
|
|
configASSERT( xTaskNotifyStateClearIndexed( NULL, uxOtherIndexes ) == pdTRUE );
|
|
}
|
|
|
|
configASSERT( xTaskNotifyStateClearIndexed( NULL, uxOtherIndexes ) == pdFALSE );
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------
|
|
* For each task notification within the array of task notifications, clear
|
|
* bits in the notification value. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* Get the task to set all bits in its task notification at index
|
|
* uxIndexToTest within its array of task notifications. This is not a
|
|
* normal thing to do, and is only done here for test purposes. */
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndexToTest, notifyUINT32_MAX, eSetBits );
|
|
|
|
/* Now clear the top bytes - the returned value from the first call
|
|
* should indicate that previously all bits were set. */
|
|
configASSERT( ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndexToTest, notifyUINT32_HIGH_BYTE ) == notifyUINT32_MAX );
|
|
|
|
/* Next clear the bottom bytes - the returned value this time should
|
|
* indicate that the top byte was clear (before the bottom byte was
|
|
* cleared. */
|
|
configASSERT( ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndexToTest, notifyUINT32_LOW_BYTE ) == ( notifyUINT32_MAX & ~notifyUINT32_HIGH_BYTE ) );
|
|
|
|
/* Next clear all bytes - the returned value should indicate that previously the
|
|
* high and low bytes were clear. */
|
|
configASSERT( ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndexToTest, notifyUINT32_MAX ) == ( notifyUINT32_MAX & ~notifyUINT32_HIGH_BYTE & ~notifyUINT32_LOW_BYTE ) );
|
|
|
|
/* Now all bits should be clear. */
|
|
configASSERT( ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndexToTest, notifyUINT32_MAX ) == 0 );
|
|
configASSERT( ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndexToTest, 0UL ) == 0 );
|
|
configASSERT( ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndexToTest, notifyUINT32_MAX ) == 0 );
|
|
|
|
/* Now the notification state should be eNotified, so it should now be
|
|
* possible to clear the notification state. */
|
|
configASSERT( xTaskNotifyStateClearIndexed( NULL, uxIndexToTest ) == pdTRUE );
|
|
configASSERT( xTaskNotifyStateClearIndexed( NULL, uxIndexToTest ) == pdFALSE );
|
|
}
|
|
|
|
/* Incremented to show the task is still running. */
|
|
ulFineCycleCount++;
|
|
|
|
/* Leave all bits cleared. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
xTaskNotifyWaitIndexed( uxIndexToTest, notifyUINT32_MAX, 0, NULL, 0 );
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvSuspendedTaskTimerTestCallback( TimerHandle_t xExpiredTimer )
|
|
{
|
|
static uint32_t ulCallCount = 0;
|
|
static UBaseType_t uxIndexToNotify = 0;
|
|
|
|
/* Remove compiler warnings about unused parameters. */
|
|
( void ) xExpiredTimer;
|
|
|
|
/* Callback for a timer that is used to send notifications to a task while
|
|
* it is suspended. The timer tests the behaviour when 1: a task waiting for a
|
|
* notification is suspended and then resumed without ever receiving a
|
|
* notification, and 2: when a task waiting for a notification receives a
|
|
* notification while it is suspended. Run one of two tests on every other
|
|
* invocation of this callback. The notification is sent to the task
|
|
* notification at index uxIndexToNotify. */
|
|
if( ( ulCallCount & 0x01 ) == 0 )
|
|
{
|
|
vTaskSuspend( xTaskToNotify );
|
|
configASSERT( eTaskGetState( xTaskToNotify ) == eSuspended );
|
|
vTaskResume( xTaskToNotify );
|
|
}
|
|
else
|
|
{
|
|
vTaskSuspend( xTaskToNotify );
|
|
|
|
/* Sending a notification while the task is suspended should pass, but
|
|
* not cause the task to resume. */
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndexToNotify, 1, eSetValueWithOverwrite );
|
|
|
|
/* Use the next task notification within the array of task notifications
|
|
* the next time around. */
|
|
uxIndexToNotify++;
|
|
|
|
if( uxIndexToNotify >= configTASK_NOTIFICATION_ARRAY_ENTRIES )
|
|
{
|
|
uxIndexToNotify = 0;
|
|
}
|
|
|
|
/* Make sure giving the notification didn't resume the task. */
|
|
configASSERT( eTaskGetState( xTaskToNotify ) == eSuspended );
|
|
|
|
vTaskResume( xTaskToNotify );
|
|
}
|
|
|
|
ulCallCount++;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvNotifyingTimerCallback( TimerHandle_t xNotUsed )
|
|
{
|
|
static BaseType_t uxIndexToNotify = 0;
|
|
|
|
( void ) xNotUsed;
|
|
|
|
/* "Give" the task notification (which increments the target task
|
|
* notification value) at index uxIndexToNotify within the array of task
|
|
* notifications. */
|
|
xTaskNotifyGiveIndexed( xTaskToNotify, uxIndexToNotify );
|
|
|
|
/* Use the next task notification within the array of task notifications the
|
|
* next time around. */
|
|
uxIndexToNotify++;
|
|
|
|
if( uxIndexToNotify >= configTASK_NOTIFICATION_ARRAY_ENTRIES )
|
|
{
|
|
uxIndexToNotify = 0;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvTestNotifyTaskWhileSuspended( void )
|
|
{
|
|
UBaseType_t uxIndexToTest, uxOtherIndexes;
|
|
BaseType_t xReturned;
|
|
uint32_t ulNotifiedValue;
|
|
|
|
/* Raise the task's priority so it can suspend itself before the timer
|
|
* expires. */
|
|
vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 );
|
|
|
|
/* Perform the test on each task notification within the array or task
|
|
* notifications. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
/* Ensure no notifications within the array of task notifications are
|
|
* pending. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0, 0, NULL, 0 );
|
|
configASSERT( xReturned == pdFALSE );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
|
|
/* Start the timer that will try notifying this task while it is
|
|
* suspended, then wait for a notification. The first time the callback
|
|
* executes the timer will suspend the task, then resume the task, without
|
|
* ever sending a notification to the task. */
|
|
ulNotifiedValue = 0;
|
|
xTimerStart( xNotifyWhileSuspendedTimer, portMAX_DELAY );
|
|
|
|
/* Check a notification is not received on the task notification at
|
|
* index uxIndexToTest within the array of task notifications. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, 0, 0, &ulNotifiedValue, portMAX_DELAY );
|
|
configASSERT( xReturned == pdFALSE );
|
|
configASSERT( ulNotifiedValue == 0 );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* Check none of the task notifications within the array of task
|
|
* notifications as been notified. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0, 0, &ulNotifiedValue, 0 );
|
|
configASSERT( xReturned == pdFALSE );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
}
|
|
|
|
/* Start the timer that will try notifying this task while it is
|
|
* suspended, then wait for a notification at index uxIndexToTest within
|
|
* the array of task notifications. The second time the callback executes
|
|
* the timer will suspend the task, notify the task, then resume the task
|
|
* (previously it was suspended and resumed without being notified). */
|
|
xTimerStart( xNotifyWhileSuspendedTimer, portMAX_DELAY );
|
|
|
|
/* Check a notification is only received in the index within the array
|
|
* of task notifications under test. */
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToTest, 0, 0, &ulNotifiedValue, portMAX_DELAY );
|
|
configASSERT( xReturned == pdPASS );
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
configASSERT( ulNotifiedValue != 0 );
|
|
|
|
/* Check a notification is not received in any index within the array
|
|
* of task notifications at and below the index being tested have a notification
|
|
* value, and that indexes above the index being tested to not have
|
|
* notification values. */
|
|
for( uxOtherIndexes = 0; uxOtherIndexes < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxOtherIndexes++ )
|
|
{
|
|
xReturned = xTaskNotifyWaitIndexed( uxOtherIndexes, 0, 0, &ulNotifiedValue, 0 );
|
|
configASSERT( xReturned == pdFALSE );
|
|
|
|
if( uxOtherIndexes <= uxIndexToTest )
|
|
{
|
|
configASSERT( ulNotifiedValue == 1 );
|
|
}
|
|
else
|
|
{
|
|
configASSERT( ulNotifiedValue == 0 );
|
|
}
|
|
|
|
( void ) xReturned; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
( void ) ulNotifiedValue;
|
|
}
|
|
}
|
|
|
|
/* Return the task to its proper priority */
|
|
vTaskPrioritySet( NULL, notifyTASK_PRIORITY );
|
|
|
|
/* Incremented to show the task is still running. */
|
|
ulFineCycleCount++;
|
|
|
|
/* Leave all bits cleared. */
|
|
for( uxIndexToTest = 0; uxIndexToTest < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToTest++ )
|
|
{
|
|
xTaskNotifyWaitIndexed( uxIndexToTest, notifyUINT32_MAX, 0, NULL, 0 );
|
|
}
|
|
}
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static void prvBlockOnTheNotifiedIndexed( void )
|
|
{
|
|
const TickType_t xTimerPeriod = pdMS_TO_TICKS( 100 ), xMargin = pdMS_TO_TICKS( 50 ), xDontBlock = 0;
|
|
UBaseType_t uxIndex, uxIndexToNotify;
|
|
uint32_t ulReceivedValue;
|
|
BaseType_t xReturned;
|
|
|
|
/* Set the value of each notification in the array of task notifications to
|
|
* the value of its index position plus 1 so everything starts in a known
|
|
* state, then clear the notification state ready for the next test. Plus 1 is
|
|
* used because the index under test will use 0. */
|
|
for( uxIndex = 0; uxIndex < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndex++ )
|
|
{
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndex, uxIndex + 1, eSetValueWithOverwrite );
|
|
xTaskNotifyStateClearIndexed( xTaskToNotify, uxIndex );
|
|
}
|
|
|
|
/* Perform the test on each task notification within the array of task
|
|
* notifications. */
|
|
for( uxIndexToNotify = 0; uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToNotify++ )
|
|
{
|
|
/* Set the notification value of the index being tested to 0 so the
|
|
* notification value increment/decrement functions can be tested. */
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndexToNotify, 0, eSetValueWithOverwrite );
|
|
xTaskNotifyStateClearIndexed( xTaskToNotify, uxIndexToNotify );
|
|
|
|
/* Start the software timer then wait for it to notify this task. Block
|
|
* on the notification index we expect to receive the notification on. The
|
|
* margin is to ensure the task blocks longer than the timer period. */
|
|
xTimerStart( xIncrementingIndexTimer, portMAX_DELAY );
|
|
ulReceivedValue = ulTaskNotifyTakeIndexed( uxIndexToNotify, pdFALSE, xTimerPeriod + xMargin );
|
|
|
|
/* The notification value was initially zero, and should have been
|
|
* incremented by the software timer, so now one. It will also have been
|
|
* decremented again by the call to ulTaskNotifyTakeIndexed() so gone back
|
|
* to 0. */
|
|
configASSERT( ulReceivedValue == 1UL );
|
|
( void ) ulReceivedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* No other notification indexes should have changed, and therefore should
|
|
* still have their value set to their index plus 1 within the array of
|
|
* notifications. */
|
|
for( uxIndex = 0; uxIndex < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndex++ )
|
|
{
|
|
if( uxIndex != uxIndexToNotify )
|
|
{
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndex, 0, 0, &ulReceivedValue, xDontBlock );
|
|
configASSERT( xReturned == pdFALSE );
|
|
configASSERT( ulReceivedValue == ( uxIndex + 1 ) );
|
|
( void ) ulReceivedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
( void ) xReturned;
|
|
}
|
|
}
|
|
|
|
/* Reset the notification value for the index just tested back to the
|
|
* index value plus 1 ready for the next iteration around this loop. */
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndexToNotify, uxIndexToNotify + 1, eSetValueWithOverwrite );
|
|
xTaskNotifyStateClearIndexed( xTaskToNotify, uxIndexToNotify );
|
|
|
|
/* Incremented to show the task is still running. */
|
|
ulFineCycleCount++;
|
|
}
|
|
}
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static void prvBlockOnANonNotifiedIndexed( void )
|
|
{
|
|
const TickType_t xTimerPeriod = pdMS_TO_TICKS( 100 ), xMargin = pdMS_TO_TICKS( 50 ), xDontBlock = 0;
|
|
UBaseType_t uxIndex, uxIndexToNotify;
|
|
uint32_t ulReceivedValue;
|
|
BaseType_t xReturned;
|
|
TickType_t xTimeBeforeBlocking, xTimeNow, xTimeDifference;
|
|
|
|
/* Set all notify values within the array of tasks notifications to zero
|
|
* ready for the next test. */
|
|
for( uxIndexToNotify = 0; uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToNotify++ )
|
|
{
|
|
ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndexToNotify, notifyUINT32_MAX );
|
|
}
|
|
|
|
/* Perform the test for each notification within the array of task
|
|
* notifications. */
|
|
for( uxIndexToNotify = 0; uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToNotify++ )
|
|
{
|
|
/* Start the software timer then wait for it to notify this task. Block
|
|
* on a notification index that we do not expect to receive the notification
|
|
* on. The margin is to ensure the task blocks longer than the timer period. */
|
|
xTimerStart( xIncrementingIndexTimer, portMAX_DELAY );
|
|
xTimeBeforeBlocking = xTaskGetTickCount();
|
|
|
|
if( uxIndexToNotify == ( configTASK_NOTIFICATION_ARRAY_ENTRIES - 1 ) )
|
|
{
|
|
/* configTASK_NOTIFICATION_ARRAY_ENTRIES - 1 is to be notified, so
|
|
* block on index 0. */
|
|
uxIndex = 0;
|
|
}
|
|
else
|
|
{
|
|
/* The next index to get notified will be uxIndexToNotify, so block
|
|
* on uxIndexToNotify + 1 */
|
|
uxIndex = uxIndexToNotify + 1;
|
|
}
|
|
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndex, 0, 0, &ulReceivedValue, xTimerPeriod + xMargin );
|
|
|
|
/* The notification will have been sent to task notification at index
|
|
* uxIndexToNotify in this task by the timer callback after xTimerPeriodTicks.
|
|
* The notification should not have woken this task, so xReturned should
|
|
* be false and at least xTimerPeriod + xMargin ticks should have passed. */
|
|
configASSERT( xReturned == pdFALSE );
|
|
xTimeNow = xTaskGetTickCount();
|
|
xTimeDifference = xTimeNow - xTimeBeforeBlocking;
|
|
configASSERT( xTimeDifference >= ( xTimerPeriod + xMargin ) );
|
|
( void ) xReturned; /* Remove compiler warnings if configASSERT() is not defined. */
|
|
( void ) xTimeBeforeBlocking;
|
|
( void ) xTimeDifference;
|
|
|
|
/* Only the notification at index position uxIndexToNotify should be
|
|
* set. Calling this function will clear it again. */
|
|
for( uxIndex = 0; uxIndex < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndex++ )
|
|
{
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndex, 0, 0, &ulReceivedValue, xDontBlock );
|
|
|
|
if( uxIndex == uxIndexToNotify )
|
|
{
|
|
/* Expect the notification state to be set and the notification
|
|
* value to have been incremented. */
|
|
configASSERT( xReturned == pdTRUE );
|
|
configASSERT( ulReceivedValue == 1 );
|
|
|
|
/* Set the notification value for this array index back to 0. */
|
|
ulTaskNotifyValueClearIndexed( xTaskToNotify, uxIndex, notifyUINT32_MAX );
|
|
}
|
|
else
|
|
{
|
|
/* Expect the notification state to be clear and the notification
|
|
* value to remain at zer0. */
|
|
configASSERT( xReturned == pdFALSE );
|
|
configASSERT( ulReceivedValue == 0 );
|
|
}
|
|
}
|
|
|
|
/* Incremented to show the task is still running. */
|
|
ulFineCycleCount++;
|
|
}
|
|
}
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static void prvBlockOnNotificationsComingFromInterrupts( void )
|
|
{
|
|
UBaseType_t uxIndex, uxIndexToNotify;
|
|
uint32_t ulReceivedValue;
|
|
BaseType_t xReturned;
|
|
const TickType_t xDontBlock = 0;
|
|
|
|
/* Set the value of each notification within the array of task notifications
|
|
* to zero so the task can block on xTaskNotifyTake(). */
|
|
for( uxIndex = 0; uxIndex < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndex++ )
|
|
{
|
|
xTaskNotifyIndexed( xTaskToNotify, uxIndex, 0, eSetValueWithOverwrite );
|
|
xTaskNotifyStateClearIndexed( xTaskToNotify, uxIndex );
|
|
}
|
|
|
|
/* Perform the test on each task notification within the array of task
|
|
* notifications. */
|
|
for( uxIndexToNotify = 0; uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndexToNotify++ )
|
|
{
|
|
/* Tell the interrupt to send the next notification. */
|
|
taskENTER_CRITICAL();
|
|
{
|
|
/* Don't expect to find xSendNotificationFromISR set at this time as
|
|
* the interrupt should have cleared it back to pdFALSE last time it
|
|
* executed. */
|
|
configASSERT( xSendNotificationFromISR == pdFALSE );
|
|
xSendNotificationFromISR = pdTRUE;
|
|
}
|
|
taskEXIT_CRITICAL();
|
|
|
|
/* Wait for a notification on the task notification at index
|
|
* uxIndexToNotify within the array of task notifications. */
|
|
ulReceivedValue = ulTaskNotifyTakeIndexed( uxIndexToNotify, pdTRUE, portMAX_DELAY );
|
|
|
|
/* Interrupt should have reset xSendNotificationFromISR after it sent
|
|
* the notification. */
|
|
configASSERT( xSendNotificationFromISR == pdFALSE );
|
|
|
|
/* The notification value was initially zero, and should have been
|
|
* incremented by the interrupt, so now one. */
|
|
configASSERT( ulReceivedValue == 1UL );
|
|
( void ) ulReceivedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
|
|
/* No other notification indexes should have changed, and therefore should
|
|
* still have their value set to 0. The value in array index uxIndexToNotify
|
|
* should also have been decremented back to zero by the call to
|
|
* ulTaskNotifyTakeIndexed(). */
|
|
for( uxIndex = 0; uxIndex < configTASK_NOTIFICATION_ARRAY_ENTRIES; uxIndex++ )
|
|
{
|
|
xReturned = xTaskNotifyWaitIndexed( uxIndexToNotify, 0, 0, &ulReceivedValue, xDontBlock );
|
|
configASSERT( xReturned == pdFALSE );
|
|
configASSERT( ulReceivedValue == 0 );
|
|
( void ) ulReceivedValue; /* Remove compiler warnings in case configASSERT() is not defined. */
|
|
( void ) xReturned;
|
|
}
|
|
|
|
/* Incremented to show the task is still running. */
|
|
ulFineCycleCount++;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
void xNotifyArrayTaskFromISR( void )
|
|
{
|
|
static BaseType_t xAPIToUse = 0;
|
|
uint32_t ulPreviousValue;
|
|
const uint32_t ulUnexpectedValue = 0xff;
|
|
static UBaseType_t uxIndexToNotify = 0;
|
|
|
|
/* Check the task notification demo task was actually created. */
|
|
configASSERT( xTaskToNotify );
|
|
|
|
/* The task sets xSendNotificationFromISR to pdTRUE each time it wants this
|
|
* interrupt (this function runs in the RTOS tick hook) to send the next
|
|
* notification. */
|
|
if( xSendNotificationFromISR == pdTRUE )
|
|
{
|
|
xSendNotificationFromISR = pdFALSE;
|
|
|
|
/* Test using both vTaskNotifyGiveFromISR(), xTaskNotifyFromISR()
|
|
* and xTaskNotifyAndQueryFromISR(). The notification is set to the task
|
|
* notification at index uxIndexToNotify within the array of task
|
|
* notifications. */
|
|
switch( xAPIToUse )
|
|
{
|
|
case 0:
|
|
vTaskNotifyGiveIndexedFromISR( xTaskToNotify, uxIndexToNotify, NULL );
|
|
xAPIToUse++;
|
|
break;
|
|
|
|
case 1:
|
|
xTaskNotifyIndexedFromISR( xTaskToNotify, uxIndexToNotify, 0, eIncrement, NULL );
|
|
xAPIToUse++;
|
|
break;
|
|
|
|
case 2:
|
|
ulPreviousValue = ulUnexpectedValue;
|
|
xTaskNotifyAndQueryIndexedFromISR( xTaskToNotify, uxIndexToNotify, 0, eIncrement, &ulPreviousValue, NULL );
|
|
configASSERT( ulPreviousValue == 0 );
|
|
xAPIToUse = 0;
|
|
break;
|
|
|
|
default: /* Should never get here!. */
|
|
break;
|
|
}
|
|
|
|
/* Use the next index in the array of task notifications the next time
|
|
* around. */
|
|
uxIndexToNotify++;
|
|
|
|
if( uxIndexToNotify >= configTASK_NOTIFICATION_ARRAY_ENTRIES )
|
|
{
|
|
uxIndexToNotify = 0;
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/* This is called to check the created tasks are still running and have not
|
|
* detected any errors. */
|
|
BaseType_t xAreTaskNotificationArrayTasksStillRunning( void )
|
|
{
|
|
static uint32_t ulLastFineCycleCount = 0, ulLastCourseCycleCount = 0, ulCallCount = 0;
|
|
const uint32_t ulCallsBetweenCourseCycleCountChecks = 3UL;
|
|
static BaseType_t xErrorStatus = pdPASS;
|
|
|
|
/* Check the cycle count is still incrementing to ensure the task is still
|
|
* actually running. The fine counter is incremented within individual test
|
|
* functions. The course counter is incremented one each time all the test
|
|
* functions have been executed to ensure all the tests are running. */
|
|
if( ulLastFineCycleCount == ulFineCycleCount )
|
|
{
|
|
xErrorStatus = pdFAIL;
|
|
}
|
|
else
|
|
{
|
|
ulLastFineCycleCount = ulFineCycleCount;
|
|
}
|
|
|
|
ulCallCount++;
|
|
|
|
if( ulCallCount >= ulCallsBetweenCourseCycleCountChecks )
|
|
{
|
|
ulCallCount = 0;
|
|
|
|
if( ulLastCourseCycleCount == ulCourseCycleCounter )
|
|
{
|
|
xErrorStatus = pdFAIL;
|
|
}
|
|
else
|
|
{
|
|
ulLastCourseCycleCount = ulCourseCycleCounter;
|
|
}
|
|
}
|
|
|
|
return xErrorStatus;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static UBaseType_t prvRand( void )
|
|
{
|
|
const size_t uxMultiplier = ( size_t ) 0x015a4e35, uxIncrement = ( size_t ) 1;
|
|
|
|
/* Utility function to generate a pseudo random number. */
|
|
uxNextRand = ( uxMultiplier * uxNextRand ) + uxIncrement;
|
|
return( ( uxNextRand >> 16 ) & ( ( size_t ) 0x7fff ) );
|
|
}
|
|
/*-----------------------------------------------------------*/
|