2 FreeRTOS V8.2.1 - Copyright (C) 2015 Real Time Engineers Ltd.
\r
5 VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
\r
7 This file is part of the FreeRTOS distribution.
\r
9 FreeRTOS is free software; you can redistribute it and/or modify it under
\r
10 the terms of the GNU General Public License (version 2) as published by the
\r
11 Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
\r
13 ***************************************************************************
\r
14 >>! NOTE: The modification to the GPL is included to allow you to !<<
\r
15 >>! distribute a combined work that includes FreeRTOS without being !<<
\r
16 >>! obliged to provide the source code for proprietary components !<<
\r
17 >>! outside of the FreeRTOS kernel. !<<
\r
18 ***************************************************************************
\r
20 FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
\r
21 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
\r
22 FOR A PARTICULAR PURPOSE. Full license text is available on the following
\r
23 link: http://www.freertos.org/a00114.html
\r
25 ***************************************************************************
\r
27 * FreeRTOS provides completely free yet professionally developed, *
\r
28 * robust, strictly quality controlled, supported, and cross *
\r
29 * platform software that is more than just the market leader, it *
\r
30 * is the industry's de facto standard. *
\r
32 * Help yourself get started quickly while simultaneously helping *
\r
33 * to support the FreeRTOS project by purchasing a FreeRTOS *
\r
34 * tutorial book, reference manual, or both: *
\r
35 * http://www.FreeRTOS.org/Documentation *
\r
37 ***************************************************************************
\r
39 http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
\r
40 the FAQ page "My application does not run, what could be wrong?". Have you
\r
41 defined configASSERT()?
\r
43 http://www.FreeRTOS.org/support - In return for receiving this top quality
\r
44 embedded software for free we request you assist our global community by
\r
45 participating in the support forum.
\r
47 http://www.FreeRTOS.org/training - Investing in training allows your team to
\r
48 be as productive as possible as early as possible. Now you can receive
\r
49 FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
\r
50 Ltd, and the world's leading authority on the world's leading RTOS.
\r
52 http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
\r
53 including FreeRTOS+Trace - an indispensable productivity tool, a DOS
\r
54 compatible FAT file system, and our tiny thread aware UDP/IP stack.
\r
56 http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
\r
57 Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
\r
59 http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
\r
60 Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
\r
61 licenses offer ticketed support, indemnification and commercial middleware.
\r
63 http://www.SafeRTOS.com - High Integrity Systems also provide a safety
\r
64 engineered and independently SIL3 certified version for use in safety and
\r
65 mission critical applications that require provable dependability.
\r
72 * Tests the behaviour of direct task notifications.
\r
75 /* Standard includes. */
\r
78 /* Scheduler include files. */
\r
79 #include "FreeRTOS.h"
\r
83 /* Demo program include files. */
\r
84 #include "TaskNotify.h"
\r
86 #define notifyTASK_PRIORITY ( tskIDLE_PRIORITY )
\r
88 /*-----------------------------------------------------------*/
\r
91 * Implementation of the task that gets notified.
\r
93 static void prvNotifiedTask( void *pvParameters );
\r
96 * Performs a few initial tests that can be done prior to creating the second
\r
99 static void prvSingleTaskTests( void );
\r
102 * Software timer callback function from which xTaskNotify() is called.
\r
104 static void prvNotifyingTimer( TimerHandle_t xTimer );
\r
107 * Utility function to create pseudo random numbers.
\r
109 static UBaseType_t prvRand( void );
\r
111 /*-----------------------------------------------------------*/
\r
113 /* Used to latch errors during the test's execution. */
\r
114 static BaseType_t xErrorStatus = pdPASS;
\r
116 /* Used to ensure the task has not stalled. */
\r
117 static volatile uint32_t ulNotifyCycleCount = 0;
\r
119 /* The handle of the task that receives the notifications. */
\r
120 static TaskHandle_t xTaskToNotify = NULL;
\r
122 /* Used to count the notifications sent to the task from a software timer and
\r
123 the number of notifications received by the task from the software timer. The
\r
124 two should stay synchronised. */
\r
125 static uint32_t ulTimerNotificationsReceived = 0UL, ulTimerNotificationsSent = 0UL;
\r
127 /* The timer used to notify the task. */
\r
128 static TimerHandle_t xTimer = NULL;
\r
130 /* Used by the pseudo random number generating function. */
\r
131 static uint32_t ulNextRand = 0;
\r
133 /*-----------------------------------------------------------*/
\r
135 void vStartTaskNotifyTask( void )
\r
137 /* Create the task that performs some tests by itself, then loops around
\r
138 being notified by both a software timer and an interrupt. */
\r
139 xTaskCreate( prvNotifiedTask, "Notified", configMINIMAL_STACK_SIZE, NULL, notifyTASK_PRIORITY, &xTaskToNotify );
\r
141 /* Pseudo seed the random number generator. */
\r
142 ulNextRand = ( uint32_t ) prvRand;
\r
144 /*-----------------------------------------------------------*/
\r
146 static void prvSingleTaskTests( void )
\r
148 const TickType_t xTicksToWait = pdMS_TO_TICKS( 100UL );
\r
149 BaseType_t xReturned;
\r
150 uint32_t ulNotifiedValue, ulLoop, ulNotifyingValue, ulPreviousValue, ulExpectedValue;
\r
151 TickType_t xTimeOnEntering;
\r
152 const uint32_t ulFirstNotifiedConst = 100001UL, ulSecondNotifiedValueConst = 5555UL, ulMaxLoops = 5UL;
\r
153 const uint32_t ulBit0 = 0x01UL, ulBit1 = 0x02UL;
\r
155 /* -------------------------------------------------------------------------
\r
156 Check blocking when there are no notifications. */
\r
157 xTimeOnEntering = xTaskGetTickCount();
\r
158 xReturned = xTaskNotifyWait( ULONG_MAX, 0, &ulNotifiedValue, xTicksToWait );
\r
160 /* Should have blocked for the entire block time. */
\r
161 if( ( xTaskGetTickCount() - xTimeOnEntering ) < xTicksToWait )
\r
163 xErrorStatus = pdFAIL;
\r
165 configASSERT( xReturned == pdFAIL );
\r
166 configASSERT( ulNotifiedValue == 0UL );
\r
171 /* -------------------------------------------------------------------------
\r
172 Check no blocking when notifications are pending. First notify itself -
\r
173 this would not be a normal thing to do and is done here for test purposes
\r
175 xReturned = xTaskNotifyAndQuery( xTaskToNotify, ulFirstNotifiedConst, eSetValueWithoutOverwrite, &ulPreviousValue );
\r
177 /* Even through the 'without overwrite' action was used the update should
\r
178 have been successful. */
\r
179 configASSERT( xReturned == pdPASS );
\r
181 /* No bits should have been pending previously. */
\r
182 configASSERT( ulPreviousValue == 0 );
\r
184 /* The task should now have a notification pending, and so not time out. */
\r
185 xTimeOnEntering = xTaskGetTickCount();
\r
186 xReturned = xTaskNotifyWait( ULONG_MAX, 0, &ulNotifiedValue, xTicksToWait );
\r
188 if( ( xTaskGetTickCount() - xTimeOnEntering ) >= xTicksToWait )
\r
190 xErrorStatus = pdFAIL;
\r
193 /* The task should have been notified, and the notified value should
\r
194 be equal to ulFirstNotifiedConst. */
\r
195 configASSERT( xReturned == pdPASS );
\r
196 configASSERT( ulNotifiedValue == ulFirstNotifiedConst );
\r
198 /* Incremented to show the task is still running. */
\r
199 ulNotifyCycleCount++;
\r
205 /*--------------------------------------------------------------------------
\r
206 Check the non-overwriting functionality. The notification is done twice
\r
207 using two different notification values. The action says don't overwrite so
\r
208 only the first notification should pass and the value read back should also
\r
209 be that used with the first notification. */
\r
210 xReturned = xTaskNotify( xTaskToNotify, ulFirstNotifiedConst, eSetValueWithoutOverwrite );
\r
211 configASSERT( xReturned == pdPASS );
\r
213 xReturned = xTaskNotify( xTaskToNotify, ulSecondNotifiedValueConst, eSetValueWithoutOverwrite );
\r
214 configASSERT( xReturned == pdFAIL );
\r
216 /* Waiting for the notification should now return immediately so a block
\r
217 time of zero is used. */
\r
218 xReturned = xTaskNotifyWait( ULONG_MAX, 0, &ulNotifiedValue, 0 );
\r
220 configASSERT( xReturned == pdPASS );
\r
221 configASSERT( ulNotifiedValue == ulFirstNotifiedConst );
\r
227 /*--------------------------------------------------------------------------
\r
228 Do the same again, only this time use the overwriting version. This time
\r
229 both notifications should pass, and the value written the second time should
\r
230 overwrite the value written the first time, and so be the value that is read
\r
232 xReturned = xTaskNotify( xTaskToNotify, ulFirstNotifiedConst, eSetValueWithOverwrite );
\r
233 configASSERT( xReturned == pdPASS );
\r
234 xReturned = xTaskNotify( xTaskToNotify, ulSecondNotifiedValueConst, eSetValueWithOverwrite );
\r
235 configASSERT( xReturned == pdPASS );
\r
236 xReturned = xTaskNotifyWait( ULONG_MAX, 0, &ulNotifiedValue, 0 );
\r
237 configASSERT( xReturned == pdPASS );
\r
238 configASSERT( ulNotifiedValue == ulSecondNotifiedValueConst );
\r
243 /*--------------------------------------------------------------------------
\r
244 Check notifications with no action pass without updating the value. Even
\r
245 though ulFirstNotifiedConst is used as the value the value read back should
\r
246 remain at ulSecondNotifiedConst. */
\r
247 xReturned = xTaskNotify( xTaskToNotify, ulFirstNotifiedConst, eNoAction );
\r
248 configASSERT( xReturned == pdPASS );
\r
249 xReturned = xTaskNotifyWait( ULONG_MAX, 0, &ulNotifiedValue, 0 );
\r
250 configASSERT( ulNotifiedValue == ulSecondNotifiedValueConst );
\r
255 /*--------------------------------------------------------------------------
\r
256 Check incrementing values. Send ulMaxLoop increment notifications, then
\r
257 ensure the received value is as expected - which should be
\r
258 ulSecondNotificationValueConst plus how ever many times to loop iterated. */
\r
259 for( ulLoop = 0; ulLoop < ulMaxLoops; ulLoop++ )
\r
261 xReturned = xTaskNotify( xTaskToNotify, 0, eIncrement );
\r
262 configASSERT( xReturned == pdPASS );
\r
265 xReturned = xTaskNotifyWait( ULONG_MAX, 0, &ulNotifiedValue, 0 );
\r
266 configASSERT( xReturned == pdPASS );
\r
267 configASSERT( ulNotifiedValue == ( ulSecondNotifiedValueConst + ulMaxLoops ) );
\r
269 /* Should not be any notifications pending now. */
\r
270 xReturned = xTaskNotifyWait( 0, 0, &ulNotifiedValue, 0 );
\r
271 configASSERT( xReturned == pdFAIL );
\r
276 /*--------------------------------------------------------------------------
\r
277 Check all bits can be set by notifying the task with one additional bit set
\r
278 on each notification, and exiting the loop when all the bits are found to be
\r
279 set. As there are 32-bits the loop should execute 32 times before all the
\r
280 bits are found to be set. */
\r
281 ulNotifyingValue = 0x01;
\r
284 /* Start with all bits clear. */
\r
285 xTaskNotifyWait( ULONG_MAX, 0, &ulNotifiedValue, 0 );
\r
289 /* Set the next bit in the task's notified value. */
\r
290 xTaskNotify( xTaskToNotify, ulNotifyingValue, eSetBits );
\r
292 /* Wait for the notified value - which of course will already be
\r
293 available. Don't clear the bits on entry or exit as this loop is exited
\r
294 when all the bits are set. */
\r
295 xReturned = xTaskNotifyWait( 0, 0, &ulNotifiedValue, 0 );
\r
296 configASSERT( xReturned == pdPASS );
\r
300 /* Use the next bit on the next iteration around this loop. */
\r
301 ulNotifyingValue <<= 1UL;
\r
303 } while ( ulNotifiedValue != ULONG_MAX );
\r
305 /* As a 32-bit value was used the loop should have executed 32 times before
\r
306 all the bits were set. */
\r
307 configASSERT( ulLoop == 32 );
\r
312 /*--------------------------------------------------------------------------
\r
313 Check bits are cleared on entry but not on exit when a notification fails
\r
314 to arrive before timing out - both with and without a timeout value. Wait
\r
315 for the notification again - but this time it is not given by anything and
\r
316 should return pdFAIL. The parameters are set to clear bit zero on entry and
\r
317 bit one on exit. As no notification was received only the bit cleared on
\r
318 entry should actually get cleared. */
\r
319 xReturned = xTaskNotifyWait( ulBit0, ulBit1, &ulNotifiedValue, xTicksToWait );
\r
320 configASSERT( xReturned == pdFAIL );
\r
322 /* Notify the task with no action so as not to update the bits even though
\r
323 ULONG_MAX is used as the notification value. */
\r
324 xTaskNotify( xTaskToNotify, ULONG_MAX, eNoAction );
\r
326 /* Reading back the value should should find bit 0 is clear, as this was
\r
327 cleared on entry, but bit 1 is not clear as it will not have been cleared on
\r
328 exit as no notification was received. */
\r
329 xReturned = xTaskNotifyWait( 0x00UL, 0x00UL, &ulNotifiedValue, 0 );
\r
330 configASSERT( xReturned == pdPASS );
\r
331 configASSERT( ulNotifiedValue == ( ULONG_MAX & ~ulBit0 ) );
\r
337 /*--------------------------------------------------------------------------
\r
338 Now try clearing the bit on exit. For that to happen a notification must be
\r
339 received, so the task is notified first. */
\r
340 xTaskNotify( xTaskToNotify, 0, eNoAction );
\r
341 xTaskNotifyWait( 0x00, ulBit1, &ulNotifiedValue, 0 );
\r
343 /* However as the bit is cleared on exit, after the returned notification
\r
344 value is set, the returned notification value should not have the bit
\r
346 configASSERT( ulNotifiedValue == ( ULONG_MAX & ~ulBit0 ) );
\r
348 /* ...but reading the value back again should find that the bit was indeed
\r
349 cleared internally. The returned value should be pdFAIL however as nothing
\r
350 has notified the task in the mean time. */
\r
351 xReturned = xTaskNotifyWait( 0x00, 0x00, &ulNotifiedValue, 0 );
\r
352 configASSERT( xReturned == pdFAIL );
\r
353 configASSERT( ulNotifiedValue == ( ULONG_MAX & ~( ulBit0 | ulBit1 ) ) );
\r
358 /*--------------------------------------------------------------------------
\r
359 Now try querying the previus value while notifying a task. */
\r
360 xTaskNotifyAndQuery( xTaskToNotify, 0x00, eSetBits, &ulPreviousValue );
\r
361 configASSERT( ulNotifiedValue == ( ULONG_MAX & ~( ulBit0 | ulBit1 ) ) );
\r
363 /* Clear all bits. */
\r
364 xTaskNotifyWait( 0x00, ULONG_MAX, &ulNotifiedValue, 0 );
\r
365 xTaskNotifyAndQuery( xTaskToNotify, 0x00, eSetBits, &ulPreviousValue );
\r
366 configASSERT( ulPreviousValue == 0 );
\r
368 ulExpectedValue = 0;
\r
369 for( ulLoop = 0x01; ulLoop < 0x80UL; ulLoop <<= 1UL )
\r
371 /* Set the next bit up, and expect to receive the last bits set (so
\r
372 the previous value will not yet have the bit being set this time
\r
374 xTaskNotifyAndQuery( xTaskToNotify, ulLoop, eSetBits, &ulPreviousValue );
\r
375 configASSERT( ulExpectedValue == ulPreviousValue );
\r
376 ulExpectedValue |= ulLoop;
\r
379 /* Incremented to show the task is still running. */
\r
380 ulNotifyCycleCount++;
\r
382 /* Leave all bits cleared. */
\r
383 xTaskNotifyWait( ULONG_MAX, 0, NULL, 0 );
\r
385 /*-----------------------------------------------------------*/
\r
387 static void prvNotifyingTimer( TimerHandle_t xNotUsed )
\r
391 xTaskNotifyGive( xTaskToNotify );
\r
393 /* This value is also incremented from an interrupt. */
\r
394 taskENTER_CRITICAL();
\r
396 ulTimerNotificationsSent++;
\r
398 taskEXIT_CRITICAL();
\r
400 /*-----------------------------------------------------------*/
\r
402 static void prvNotifiedTask( void *pvParameters )
\r
404 const TickType_t xMaxPeriod = pdMS_TO_TICKS( 90 ), xMinPeriod = pdMS_TO_TICKS( 10 ), xDontBlock = 0;
\r
405 TickType_t xPeriod;
\r
407 /* Remove compiler warnings about unused parameters. */
\r
408 ( void ) pvParameters;
\r
410 /* Run a few tests that can be done from a single task before entering the
\r
412 prvSingleTaskTests();
\r
414 /* Create the software timer that is used to send notifications to this
\r
415 task. Notifications are also received from an interrupt. */
\r
416 xTimer = xTimerCreate( "Notifier", xMaxPeriod, pdFALSE, NULL, prvNotifyingTimer );
\r
420 /* Start the timer again with a different period. Sometimes the period
\r
421 will be higher than the tasks block time, sometimes it will be lower
\r
422 than the tasks block time. */
\r
423 xPeriod = prvRand() % xMaxPeriod;
\r
424 if( xPeriod < xMinPeriod )
\r
426 xPeriod = xMinPeriod;
\r
429 xTimerChangePeriod( xTimer, xPeriod, portMAX_DELAY );
\r
430 xTimerStart( xTimer, portMAX_DELAY );
\r
432 /* Block waiting for the notification again with a different period.
\r
433 Sometimes the period will be higher than the tasks block time, sometimes
\r
434 it will be lower than the tasks block time. */
\r
435 xPeriod = prvRand() % xMaxPeriod;
\r
436 if( xPeriod < xMinPeriod )
\r
438 xPeriod = xMinPeriod;
\r
441 /* Block to wait for a notification but without clearing the
\r
442 notification count, so only add one to the count of received
\r
443 notifications as any other notifications will remain pending. */
\r
444 if( ulTaskNotifyTake( pdFALSE, xPeriod ) != 0 )
\r
446 ulTimerNotificationsReceived++;
\r
450 /* Take a notification without clearing again, but this time without a
\r
451 block time specified. */
\r
452 if( ulTaskNotifyTake( pdFALSE, xDontBlock ) != 0 )
\r
454 ulTimerNotificationsReceived++;
\r
457 /* Wait for the next notification from the timer, clearing all
\r
458 notifications if one is received, so this time adding the total number
\r
459 of notifications that were pending as none will be left pending after
\r
460 the function call. */
\r
461 ulTimerNotificationsReceived += ulTaskNotifyTake( pdTRUE, xPeriod );
\r
463 /* Wait for the next notification again, clearing all notifications if
\r
464 one is received, but this time blocking indefinitely. */
\r
465 ulTimerNotificationsReceived += ulTaskNotifyTake( pdTRUE, portMAX_DELAY );
\r
467 /* Incremented to show the task is still running. */
\r
468 ulNotifyCycleCount++;
\r
471 /*-----------------------------------------------------------*/
\r
473 void xNotifyTaskFromISR( void )
\r
475 static BaseType_t xCallCount = 0;
\r
476 const BaseType_t xCallInterval = pdMS_TO_TICKS( 50 );
\r
478 /* The task performs some tests before starting the timer that gives the
\r
479 notification from this interrupt. If the timer has not been created yet
\r
480 then the initial tests have not yet completed and the notification should
\r
482 if( xTimer != NULL )
\r
486 if( xCallCount >= xCallInterval )
\r
488 /* It is time to 'give' the notification again. */
\r
491 vTaskNotifyGiveFromISR( xTaskToNotify, NULL );
\r
492 ulTimerNotificationsSent++;
\r
496 /*-----------------------------------------------------------*/
\r
498 /* This is called to check the created tasks are still running and have not
\r
499 detected any errors. */
\r
500 BaseType_t xAreTaskNotificationTasksStillRunning( void )
\r
502 static uint32_t ulLastNotifyCycleCount = 0;
\r
503 const uint32_t ulMaxSendReceiveDeviation = 5UL;
\r
505 /* Check the cycle count is still incrementing to ensure the task is still
\r
506 actually running. */
\r
507 if( ulLastNotifyCycleCount == ulNotifyCycleCount )
\r
509 xErrorStatus = pdFAIL;
\r
513 ulLastNotifyCycleCount = ulNotifyCycleCount;
\r
516 /* Check the count of 'takes' from the software timer is keeping track with
\r
517 the amount of 'gives'. */
\r
518 if( ulTimerNotificationsSent > ulTimerNotificationsSent )
\r
520 if( ( ulTimerNotificationsSent - ulTimerNotificationsReceived ) > ulMaxSendReceiveDeviation )
\r
522 xErrorStatus = pdFAIL;
\r
526 return xErrorStatus;
\r
528 /*-----------------------------------------------------------*/
\r
530 static UBaseType_t prvRand( void )
\r
532 const uint32_t ulMultiplier = 0x015a4e35UL, ulIncrement = 1UL;
\r
534 /* Utility function to generate a pseudo random number. */
\r
535 ulNextRand = ( ulMultiplier * ulNextRand ) + ulIncrement;
\r
536 return( ( int ) ( ulNextRand >> 16UL ) & 0x7fffUL );
\r
538 /*-----------------------------------------------------------*/
\r