/*\r
- FreeRTOS V8.0.0 - Copyright (C) 2014 Real Time Engineers Ltd.\r
+ FreeRTOS V9.0.1 - Copyright (C) 2017 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
\r
- ***************************************************************************\r
- * *\r
- * FreeRTOS provides completely free yet professionally developed, *\r
- * robust, strictly quality controlled, supported, and cross *\r
- * platform software that has become a de facto standard. *\r
- * *\r
- * Help yourself get started quickly and support the FreeRTOS *\r
- * project by purchasing a FreeRTOS tutorial book, reference *\r
- * manual, or both from: http://www.FreeRTOS.org/Documentation *\r
- * *\r
- * Thank you! *\r
- * *\r
- ***************************************************************************\r
-\r
This file is part of the FreeRTOS distribution.\r
\r
FreeRTOS is free software; you can redistribute it and/or modify it under\r
the terms of the GNU General Public License (version 2) as published by the\r
- Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
+ Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.\r
\r
- >>! NOTE: The modification to the GPL is included to allow you to distribute\r
- >>! a combined work that includes FreeRTOS without being obliged to provide\r
- >>! the source code for proprietary components outside of the FreeRTOS\r
- >>! kernel.\r
+ ***************************************************************************\r
+ >>! NOTE: The modification to the GPL is included to allow you to !<<\r
+ >>! distribute a combined work that includes FreeRTOS without being !<<\r
+ >>! obliged to provide the source code for proprietary components !<<\r
+ >>! outside of the FreeRTOS kernel. !<<\r
+ ***************************************************************************\r
\r
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. Full license text is available from the following\r
+ FOR A PARTICULAR PURPOSE. Full license text is available on the following\r
link: http://www.freertos.org/a00114.html\r
\r
- 1 tab == 4 spaces!\r
-\r
***************************************************************************\r
* *\r
- * Having a problem? Start by reading the FAQ "My application does *\r
- * not run, what could be wrong?" *\r
+ * FreeRTOS provides completely free yet professionally developed, *\r
+ * robust, strictly quality controlled, supported, and cross *\r
+ * platform software that is more than just the market leader, it *\r
+ * is the industry's de facto standard. *\r
* *\r
- * http://www.FreeRTOS.org/FAQHelp.html *\r
+ * Help yourself get started quickly while simultaneously helping *\r
+ * to support the FreeRTOS project by purchasing a FreeRTOS *\r
+ * tutorial book, reference manual, or both: *\r
+ * http://www.FreeRTOS.org/Documentation *\r
* *\r
***************************************************************************\r
\r
- http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
- license and Real Time Engineers Ltd. contact details.\r
+ http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading\r
+ the FAQ page "My application does not run, what could be wrong?". Have you\r
+ defined configASSERT()?\r
+\r
+ http://www.FreeRTOS.org/support - In return for receiving this top quality\r
+ embedded software for free we request you assist our global community by\r
+ participating in the support forum.\r
+\r
+ http://www.FreeRTOS.org/training - Investing in training allows your team to\r
+ be as productive as possible as early as possible. Now you can receive\r
+ FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
+ Ltd, and the world's leading authority on the world's leading RTOS.\r
\r
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
\r
- http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
- Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS\r
- licenses offer ticketed support, indemnification and middleware.\r
+ http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
+ Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
+\r
+ http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
+ Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS\r
+ licenses offer ticketed support, indemnification and commercial middleware.\r
\r
http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
engineered and independently SIL3 certified version for use in safety and\r
* groups. It is not intended to be a user friendly demonstration of the\r
* event groups API.\r
*\r
-* NOTE: The tests implemented in this file are informal 'sanity' tests \r
-* only and are not part of the module tests that make use of the \r
+* NOTE: The tests implemented in this file are informal 'sanity' tests\r
+* only and are not part of the module tests that make use of the\r
* mtCOVERAGE_TEST_MARKER macro within the event groups implementation.\r
*/\r
\r
#define ebWAIT_BIT_TASK_PRIORITY ( tskIDLE_PRIORITY + 1 )\r
\r
/* Generic bit definitions. */\r
-#define ebBIT_0 ( 0x01UL )\r
-#define ebBIT_1 ( 0x02UL )\r
-#define ebBIT_2 ( 0x04UL )\r
-#define ebBIT_3 ( 0x08UL )\r
-#define ebBIT_4 ( 0x10UL )\r
-#define ebBIT_5 ( 0x20UL )\r
-#define ebBIT_6 ( 0x40UL )\r
-#define ebBIT_7 ( 0x80UL )\r
+#define ebBIT_0 ( 0x01 )\r
+#define ebBIT_1 ( 0x02 )\r
+#define ebBIT_2 ( 0x04 )\r
+#define ebBIT_3 ( 0x08 )\r
+#define ebBIT_4 ( 0x10 )\r
+#define ebBIT_5 ( 0x20 )\r
+#define ebBIT_6 ( 0x40 )\r
+#define ebBIT_7 ( 0x80 )\r
\r
/* Combinations of bits used in the demo. */\r
#define ebCOMBINED_BITS ( ebBIT_1 | ebBIT_5 | ebBIT_7 )\r
#define ebDONT_BLOCK ( 0 )\r
\r
/* A 5ms delay. */\r
-#define ebSHORT_DELAY ( 5 / portTICK_PERIOD_MS )\r
+#define ebSHORT_DELAY pdMS_TO_TICKS( ( TickType_t ) 5 )\r
\r
/* Used in the selective bits test which checks no, one or both tasks blocked on\r
event bits in a group are unblocked as appropriate as different bits get set. */\r
/*-----------------------------------------------------------*/\r
\r
/*\r
- * NOTE: The tests implemented in this function are informal 'sanity' tests \r
- * only and are not part of the module tests that make use of the \r
+ * NOTE: The tests implemented in this function are informal 'sanity' tests\r
+ * only and are not part of the module tests that make use of the\r
* mtCOVERAGE_TEST_MARKER macro within the event groups implementation.\r
*\r
* The master test task. This task:\r
*\r
- * 1) Calls prvSelectiveBitsTestMasterFunction() to test the behaviour when two \r
- * tasks are blocked on different bits in an event group. The counterpart of \r
- * this test is implemented by the prvSelectiveBitsTestSlaveFunction() \r
+ * 1) Calls prvSelectiveBitsTestMasterFunction() to test the behaviour when two\r
+ * tasks are blocked on different bits in an event group. The counterpart of\r
+ * this test is implemented by the prvSelectiveBitsTestSlaveFunction()\r
* function (which is called by the two tasks that block on the event group).\r
*\r
* 2) Calls prvBitCombinationTestMasterFunction() to test the behaviour when\r
- * just one task is blocked on various combinations of bits within an event \r
- * group. The counterpart of this test is implemented within the 'test \r
+ * just one task is blocked on various combinations of bits within an event\r
+ * group. The counterpart of this test is implemented within the 'test\r
* slave' task.\r
*\r
* 3) Calls prvPerformTaskSyncTests() to test task synchronisation behaviour.\r
static void prvTestMasterTask( void *pvParameters );\r
\r
/*\r
- * A helper task that enables the 'test master' task to perform several \r
+ * A helper task that enables the 'test master' task to perform several\r
* behavioural tests. See the comments above the prvTestMasterTask() prototype\r
* above.\r
*/\r
static BaseType_t prvPerformTaskSyncTests( BaseType_t xError, TaskHandle_t xTestSlaveTaskHandle );\r
\r
/*\r
- * Two instances of prvSyncTask() are created. They start by calling \r
+ * Two instances of prvSyncTask() are created. They start by calling\r
* prvSelectiveBitsTestSlaveFunction() to act as slaves when the test master is\r
* executing the prvSelectiveBitsTestMasterFunction() function. They then loop\r
* to test the task synchronisation (rendezvous) behaviour.\r
\r
/*\r
* Functions used in a test that blocks two tasks on various different bits\r
- * within an event group - then sets each bit in turn and checks that the \r
+ * within an event group - then sets each bit in turn and checks that the\r
* correct tasks unblock at the correct times.\r
*/\r
static BaseType_t prvSelectiveBitsTestMasterFunction( void );\r
\r
/* Variables that are incremented by the tasks on each cycle provided no errors\r
have been found. Used to detect an error or stall in the test cycling. */\r
-static volatile unsigned long ulTestMasterCycles = 0, ulTestSlaveCycles = 0, ulISRCycles = 0;\r
+static volatile uint32_t ulTestMasterCycles = 0, ulTestSlaveCycles = 0, ulISRCycles = 0;\r
\r
/* The event group used by all the task based tests. */\r
static EventGroupHandle_t xEventGroup = NULL;\r
* groups. It is not intended to be a user friendly demonstration of the\r
* event groups API.\r
*\r
- * NOTE: The tests implemented in this file are informal 'sanity' tests \r
- * only and are not part of the module tests that make use of the \r
+ * NOTE: The tests implemented in this file are informal 'sanity' tests\r
+ * only and are not part of the module tests that make use of the\r
* mtCOVERAGE_TEST_MARKER macro within the event groups implementation.\r
*\r
* Create the test tasks as described at the top of this file.\r
xEventGroup = xEventGroupCreate();\r
configASSERT( xEventGroup );\r
\r
- /* Perform the tests that block two tasks on different combinations of bits, \r
- then set each bit in turn and check the correct tasks unblock at the correct \r
+ /* Perform the tests that block two tasks on different combinations of bits,\r
+ then set each bit in turn and check the correct tasks unblock at the correct\r
times. */\r
xError = prvSelectiveBitsTestMasterFunction();\r
\r
{\r
EventBits_t uxSynchronisationBit, uxReturned;\r
\r
- /* A few tests that check the behaviour when two tasks are blocked on \r
+ /* A few tests that check the behaviour when two tasks are blocked on\r
various different bits within an event group are performed before this task\r
enters its infinite loop to carry out its main demo function. */\r
prvSelectiveBitsTestSlaveFunction();\r
\r
for( ;; )\r
{\r
- /* Now this task takes part in a task synchronisation - sometimes known \r
- as a 'rendezvous'. Its execution pattern is controlled by the 'test \r
- master' task, which is responsible for taking this task out of the \r
- Suspended state when it is time to test the synchronisation behaviour. \r
+ /* Now this task takes part in a task synchronisation - sometimes known\r
+ as a 'rendezvous'. Its execution pattern is controlled by the 'test\r
+ master' task, which is responsible for taking this task out of the\r
+ Suspended state when it is time to test the synchronisation behaviour.\r
See: http://www.freertos.org/xEventGroupSync.html. */\r
vTaskSuspend( NULL );\r
\r
portMAX_DELAY );/* The maximum time to wait for the sync condition to be met before giving up. */\r
\r
/* A max delay was used, so this task should only exit the above\r
- function call when the sync condition is met. Check this is the \r
+ function call when the sync condition is met. Check this is the\r
case. */\r
configASSERT( ( uxReturned & ebALL_SYNC_BITS ) == ebALL_SYNC_BITS );\r
\r
vTaskSuspend( NULL );\r
\r
/* Set the bit that indicates this task is at the synchronisation\r
- point again. This time the 'test master' task has a higher priority \r
+ point again. This time the 'test master' task has a higher priority\r
than this task so will get to the sync point before this task. */\r
uxReturned = xEventGroupSync( xEventGroup, uxSynchronisationBit, ebALL_SYNC_BITS, portMAX_DELAY );\r
\r
/* Again a max delay was used, so this task should only exit the above\r
- function call when the sync condition is met. Check this is the \r
+ function call when the sync condition is met. Check this is the\r
case. */\r
configASSERT( ( uxReturned & ebALL_SYNC_BITS ) == ebALL_SYNC_BITS );\r
\r
/* Block on the event group again. This time the event group is going\r
- to be deleted while this task is blocked on it so it is expected that 0 \r
+ to be deleted while this task is blocked on it so it is expected that 0\r
be returned. */\r
uxReturned = xEventGroupWaitBits( xEventGroup, ebALL_SYNC_BITS, pdFALSE, pdTRUE, portMAX_DELAY );\r
configASSERT( uxReturned == 0 );\r
for( ;; )\r
{\r
/**********************************************************************\r
- * Part 1: This section is the counterpart to the \r
+ * Part 1: This section is the counterpart to the\r
* prvBitCombinationTestMasterFunction() function which is called by the\r
* test master task.\r
***********************************************************************\r
\r
This task is controller by the 'test master' task (which is\r
- implemented by prvTestMasterTask()). Suspend until resumed by the \r
+ implemented by prvTestMasterTask()). Suspend until resumed by the\r
'test master' task. */\r
vTaskSuspend( NULL );\r
\r
pdTRUE, /* Wait for all the bits (only one in this case anyway). */\r
portMAX_DELAY ); /* Block indefinitely to wait for the condition to be met. */\r
\r
- /* The 'test master' task set all the bits defined by ebCOMBINED_BITS, \r
+ /* The 'test master' task set all the bits defined by ebCOMBINED_BITS,\r
only one of which was being waited for by this task. The return value\r
shows the state of the event bits when the task was unblocked, however\r
- because the task was waiting for ebBIT_1 and 'clear on exit' was set to \r
+ because the task was waiting for ebBIT_1 and 'clear on exit' was set to\r
the current state of the event bits will have ebBIT_1 clear. */\r
if( uxReturned != ebCOMBINED_BITS )\r
{\r
xError = pdTRUE;\r
}\r
\r
- /* Now call xEventGroupWaitBits() again, this time waiting for all the \r
- bits in ebCOMBINED_BITS to be set. This call should block until the \r
- 'test master' task sets ebBIT_1 - which was the bit cleared in the call \r
+ /* Now call xEventGroupWaitBits() again, this time waiting for all the\r
+ bits in ebCOMBINED_BITS to be set. This call should block until the\r
+ 'test master' task sets ebBIT_1 - which was the bit cleared in the call\r
to xEventGroupWaitBits() above. */\r
uxReturned = xEventGroupWaitBits( xEventGroup,\r
ebCOMBINED_BITS, /* The bits being waited on. */\r
/* Suspend again to wait for the 'test master' task. */\r
vTaskSuspend( NULL );\r
\r
- /* Now call xEventGroupWaitBits() again, again waiting for all the bits \r
- in ebCOMBINED_BITS to be set, but this time clearing the bits when the \r
+ /* Now call xEventGroupWaitBits() again, again waiting for all the bits\r
+ in ebCOMBINED_BITS to be set, but this time clearing the bits when the\r
task is unblocked. */\r
uxReturned = xEventGroupWaitBits( xEventGroup,\r
ebCOMBINED_BITS, /* The bits being waited on. */\r
pdTRUE, /* All the bits must be set to unblock. */\r
portMAX_DELAY );\r
\r
- /* The 'test master' task set all the bits in the event group, so that \r
+ /* The 'test master' task set all the bits in the event group, so that\r
is the value that should have been returned. The bits defined by\r
ebCOMBINED_BITS will have been clear again in the current value though\r
as 'clear on exit' was set to pdTRUE. */\r
\r
\r
/**********************************************************************\r
- * Part 2: This section is the counterpart to the \r
+ * Part 2: This section is the counterpart to the\r
* prvPerformTaskSyncTests() function which is called by the\r
* test master task.\r
***********************************************************************\r
vTaskSuspend( NULL );\r
\r
/* Now peform a synchronisation with all the other tasks. At this point\r
- the 'test master' task has the lowest priority so will get to the sync \r
+ the 'test master' task has the lowest priority so will get to the sync\r
point after all the other synchronising tasks. */\r
uxReturned = xEventGroupSync( xEventGroup, /* The event group used for the sync. */\r
ebWAIT_BIT_TASK_SYNC_BIT, /* The bit in the event group used to indicate this task is at the sync point. */\r
vTaskSuspend( NULL );\r
\r
/* This time sync when the 'test master' task has the highest priority\r
- at the point where it sets its sync bit - so this time the 'test master' \r
+ at the point where it sets its sync bit - so this time the 'test master'\r
task will get to the sync point before this task. */\r
uxReturned = xEventGroupSync( xEventGroup, ebWAIT_BIT_TASK_SYNC_BIT, ebALL_SYNC_BITS, portMAX_DELAY );\r
\r
}\r
\r
/* Block on the event group again. This time the event group is going\r
- to be deleted while this task is blocked on it, so it is expected that 0 \r
+ to be deleted while this task is blocked on it, so it is expected that 0\r
will be returned. */\r
uxReturned = xEventGroupWaitBits( xEventGroup, ebALL_SYNC_BITS, pdFALSE, pdTRUE, portMAX_DELAY );\r
\r
{\r
EventBits_t uxPendBits, uxReturned;\r
\r
- /* Used in a test that blocks two tasks on various different bits within an \r
- event group - then sets each bit in turn and checks that the correct tasks \r
+ /* Used in a test that blocks two tasks on various different bits within an\r
+ event group - then sets each bit in turn and checks that the correct tasks\r
unblock at the correct times.\r
\r
This function is called by two different tasks - each of which will use a\r
for( ;; )\r
{\r
/* Wait until it is time to perform the next cycle of the test. The\r
- task is unsuspended by the tests implemented in the \r
+ task is unsuspended by the tests implemented in the\r
prvSelectiveBitsTestMasterFunction() function. */\r
vTaskSuspend( NULL );\r
uxReturned = xEventGroupWaitBits( xEventGroup, uxPendBits, pdTRUE, pdFALSE, portMAX_DELAY );\r
BaseType_t xError = pdFALSE;\r
EventBits_t uxBit;\r
\r
- /* Used in a test that blocks two tasks on various different bits within an \r
- event group - then sets each bit in turn and checks that the correct tasks \r
- unblock at the correct times. The two other tasks (xSyncTask1 and \r
+ /* Used in a test that blocks two tasks on various different bits within an\r
+ event group - then sets each bit in turn and checks that the correct tasks\r
+ unblock at the correct times. The two other tasks (xSyncTask1 and\r
xSyncTask2) call prvSelectiveBitsTestSlaveFunction() to perform their parts in\r
this test.\r
\r
EventBits_t uxReturned;\r
BaseType_t xMessagePosted;\r
\r
- /* Called periodically from the tick hook to exercise the "FromISR" \r
+ /* Called periodically from the tick hook to exercise the "FromISR"\r
functions. */\r
\r
xCallCount++;\r
else if( xCallCount == xClearBitsCount )\r
{\r
/* Clear the bits again. */\r
- uxReturned = xEventGroupClearBitsFromISR( xISREventGroup, uxBitsToSet );\r
+ uxReturned = ( EventBits_t ) xEventGroupClearBitsFromISR( xISREventGroup, uxBitsToSet );\r
\r
- /* The returned value should be the value before the bits were cleaed.*/\r
- if( uxReturned != uxBitsToSet )\r
+ /* Check the message was posted. */\r
+ if( uxReturned != pdPASS )\r
{\r
xISRTestError = pdTRUE;\r
}\r
/* This is called to check that all the created tasks are still running. */\r
BaseType_t xAreEventGroupTasksStillRunning( void )\r
{\r
-static unsigned long ulPreviousWaitBitCycles = 0, ulPreviousSetBitCycles = 0, ulPreviousISRCycles = 0;\r
+static uint32_t ulPreviousWaitBitCycles = 0, ulPreviousSetBitCycles = 0, ulPreviousISRCycles = 0;\r
BaseType_t xStatus = pdPASS;\r
\r
/* Check the tasks are still cycling without finding any errors. */\r
projects / freertos / blobdiff