/*\r
- FreeRTOS V7.5.0 - Copyright (C) 2013 Real Time Engineers Ltd.\r
+ FreeRTOS V8.1.2 - Copyright (C) 2014 Real Time Engineers Ltd. \r
+ All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
\r
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
\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
+ >>! 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
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
* queuesetINITIAL_ISR_TX_VALUE to ULONG_MAX.\r
*/\r
\r
+\r
/* Standard includes. */\r
#include <stdlib.h>\r
#include <limits.h>\r
/* The priorities used in this demo. */\r
#define queuesetLOW_PRIORITY ( tskIDLE_PRIORITY )\r
#define queuesetMEDIUM_PRIORITY ( queuesetLOW_PRIORITY + 1 )\r
-#define queuesetHIGH_PRIORITY ( queuesetMEDIUM_PRIORITY + 1 )\r
\r
/* For test purposes the priority of the sending task is changed after every\r
queuesetPRIORITY_CHANGE_LOOPS number of values are sent to a queue. */\r
-#define queuesetPRIORITY_CHANGE_LOOPS 100UL\r
+#define queuesetPRIORITY_CHANGE_LOOPS ( ( queuesetNUM_QUEUES_IN_SET * queuesetQUEUE_LENGTH ) * 2 )\r
\r
/* The ISR sends to the queue every queuesetISR_TX_PERIOD ticks. */\r
#define queuesetISR_TX_PERIOD ( 100UL )\r
\r
+/* A delay inserted when the Tx task changes its priority to be above the idle\r
+task priority to ensure the idle priority tasks get some CPU time before the\r
+next iteration of the queue set Tx task. */\r
+#define queuesetTX_LOOP_DELAY ( 200 / portTICK_PERIOD_MS )\r
+\r
/* The allowable maximum deviation between a received value and the expected\r
received value. A deviation will occur when data is received from a queue\r
inside an ISR in between a task receiving from a queue and the task checking\r
testing of limits easier (don't have to deal with wrapping values). */\r
#define queuesetIGNORED_BOUNDARY ( queuesetALLOWABLE_RX_DEVIATION * 2 )\r
\r
+typedef enum\r
+{\r
+ eEqualPriority = 0, /* Tx and Rx tasks have the same priority. */\r
+ eTxHigherPriority, /* The priority of the Tx task is above that of the Rx task. */\r
+ eTxLowerPriority /* The priority of the Tx task is below that of the Rx task. */\r
+} eRelativePriorities;\r
+\r
/*\r
* The task that periodically sends to the queue set.\r
*/\r
* range of the value being used to distinguish between the two message\r
* sources.\r
*/\r
-static void prvCheckReceivedValue( unsigned long ulReceived );\r
+static void prvCheckReceivedValue( uint32_t ulReceived );\r
\r
/*\r
* For purposes of test coverage, functions that read from and write to a\r
* Create the queues and add them to a queue set before resuming the Tx\r
* task.\r
*/\r
-static void prvSetupTest( xTaskHandle xQueueSetSendingTask );\r
+static void prvSetupTest( void );\r
\r
/*\r
* Checks a value received from a queue falls within the range of expected\r
* values.\r
*/\r
-static portBASE_TYPE prvCheckReceivedValueWithinExpectedRange( unsigned long ulReceived, unsigned long ulExpectedReceived );\r
+static BaseType_t prvCheckReceivedValueWithinExpectedRange( uint32_t ulReceived, uint32_t ulExpectedReceived );\r
+\r
+/*\r
+ * Increase test coverage by occasionally change the priorities of the two tasks\r
+ * relative to each other. */\r
+static void prvChangeRelativePriorities( void );\r
+\r
+/*\r
+ * Local pseudo random number seed and return functions. Used to avoid calls\r
+ * to the standard library.\r
+ */\r
+static uint32_t prvRand( void );\r
+static void prvSRand( uint32_t ulSeed );\r
\r
/*-----------------------------------------------------------*/\r
\r
/* The queues that are added to the set. */\r
-static xQueueHandle xQueues[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
+static QueueHandle_t xQueues[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
\r
/* Counts how many times each queue in the set is used to ensure all the\r
queues are used. */\r
-static unsigned long ulQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
+static uint32_t ulQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
\r
/* The handle of the queue set to which the queues are added. */\r
-static xQueueSetHandle xQueueSet;\r
+static QueueSetHandle_t xQueueSet;\r
\r
/* If the prvQueueSetReceivingTask() task has not detected any errors then\r
it increments ulCycleCounter on each iteration.\r
xAreQueueSetTasksStillRunning() returns pdPASS if the value of\r
ulCycleCounter has changed between consecutive calls, and pdFALSE if\r
ulCycleCounter has stopped incrementing (indicating an error condition). */\r
-static volatile unsigned long ulCycleCounter = 0UL;\r
+static volatile uint32_t ulCycleCounter = 0UL;\r
\r
/* Set to pdFAIL if an error is detected by any queue set task.\r
ulCycleCounter will only be incremented if xQueueSetTasksSatus equals pdPASS. */\r
-static volatile portBASE_TYPE xQueueSetTasksStatus = pdPASS;\r
+static volatile BaseType_t xQueueSetTasksStatus = pdPASS;\r
\r
/* Just a flag to let the function that writes to a queue from an ISR know that\r
the queues are setup and can be used. */\r
-static volatile portBASE_TYPE xSetupComplete = pdFALSE;\r
+static volatile BaseType_t xSetupComplete = pdFALSE;\r
\r
/* The value sent to the queue from the ISR is file scope so the\r
xAreQueeuSetTasksStillRunning() function can check it is incrementing as\r
expected. */\r
-static volatile unsigned long ulISRTxValue = queuesetINITIAL_ISR_TX_VALUE;\r
+static volatile uint32_t ulISRTxValue = queuesetINITIAL_ISR_TX_VALUE;\r
+\r
+/* Used by the pseudo random number generator. */\r
+static uint32_t ulNextRand = 0;\r
+\r
+/* The task handles are stored so their priorities can be changed. */\r
+TaskHandle_t xQueueSetSendingTask, xQueueSetReceivingTask;\r
\r
/*-----------------------------------------------------------*/\r
\r
void vStartQueueSetTasks( void )\r
{\r
-xTaskHandle xQueueSetSendingTask;\r
-\r
- /* Create the two queues. The handle of the sending task is passed into\r
- the receiving task using the task parameter. The receiving task uses the\r
- handle to resume the sending task after it has created the queues. */\r
- xTaskCreate( prvQueueSetSendingTask, ( signed char * ) "SetTx", configMINIMAL_STACK_SIZE, NULL, queuesetMEDIUM_PRIORITY, &xQueueSetSendingTask );\r
- xTaskCreate( prvQueueSetReceivingTask, ( signed char * ) "SetRx", configMINIMAL_STACK_SIZE, ( void * ) xQueueSetSendingTask, queuesetMEDIUM_PRIORITY, NULL );\r
+ /* Create the tasks. */\r
+ xTaskCreate( prvQueueSetSendingTask, "SetTx", configMINIMAL_STACK_SIZE, NULL, queuesetMEDIUM_PRIORITY, &xQueueSetSendingTask );\r
+ xTaskCreate( prvQueueSetReceivingTask, "SetRx", configMINIMAL_STACK_SIZE, ( void * ) xQueueSetSendingTask, queuesetMEDIUM_PRIORITY, &xQueueSetReceivingTask );\r
\r
/* It is important that the sending task does not attempt to write to a\r
queue before the queue has been created. It is therefore placed into the\r
}\r
/*-----------------------------------------------------------*/\r
\r
-portBASE_TYPE xAreQueueSetTasksStillRunning( void )\r
+BaseType_t xAreQueueSetTasksStillRunning( void )\r
{\r
-static unsigned long ulLastCycleCounter, ulLastISRTxValue = 0;\r
-static unsigned long ulLastQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
-portBASE_TYPE xReturn = pdPASS, x;\r
+static uint32_t ulLastCycleCounter, ulLastISRTxValue = 0;\r
+static uint32_t ulLastQueueUsedCounter[ queuesetNUM_QUEUES_IN_SET ] = { 0 };\r
+BaseType_t xReturn = pdPASS, x;\r
\r
if( ulLastCycleCounter == ulCycleCounter )\r
{\r
\r
static void prvQueueSetSendingTask( void *pvParameters )\r
{\r
-unsigned long ulTaskTxValue = 0;\r
-portBASE_TYPE xQueueToWriteTo;\r
-xQueueHandle xQueueInUse;\r
-unsigned portBASE_TYPE uxPriority = queuesetMEDIUM_PRIORITY, ulLoops = 0;\r
+uint32_t ulTaskTxValue = 0, ulQueueToWriteTo;\r
+QueueHandle_t xQueueInUse;\r
\r
/* Remove compiler warning about the unused parameter. */\r
( void ) pvParameters;\r
\r
- srand( ( unsigned int ) &ulTaskTxValue );\r
+ /* Seed mini pseudo random number generator. */\r
+ prvSRand( ( uint32_t ) &ulTaskTxValue );\r
\r
for( ;; )\r
{\r
/* Generate the index for the queue to which a value is to be sent. */\r
- xQueueToWriteTo = rand() % queuesetNUM_QUEUES_IN_SET;\r
- xQueueInUse = xQueues[ xQueueToWriteTo ];\r
+ ulQueueToWriteTo = prvRand() % queuesetNUM_QUEUES_IN_SET;\r
+ xQueueInUse = xQueues[ ulQueueToWriteTo ];\r
\r
/* Note which index is being written to to ensure all the queues are\r
used. */\r
- ( ulQueueUsedCounter[ xQueueToWriteTo ] )++;\r
+ ( ulQueueUsedCounter[ ulQueueToWriteTo ] )++;\r
\r
/* Send to the queue to unblock the task that is waiting for data to\r
arrive on a queue within the queue set to which this queue belongs. */\r
xQueueSetTasksStatus = pdFAIL;\r
}\r
\r
+ #if( configUSE_PREEMPTION == 0 )\r
+ taskYIELD();\r
+ #endif\r
+\r
ulTaskTxValue++;\r
\r
/* If the Tx value has reached the range used by the ISR then set it\r
ulTaskTxValue = 0;\r
}\r
\r
- /* Occasionally change the task priority relative to the priority of\r
- the receiving task. */\r
- ulLoops++;\r
- if( ulLoops >= queuesetPRIORITY_CHANGE_LOOPS )\r
- {\r
- ulLoops = 0;\r
- uxPriority++;\r
- if( uxPriority > queuesetHIGH_PRIORITY )\r
- {\r
- uxPriority = queuesetLOW_PRIORITY;\r
- }\r
+ /* Increase test coverage by occasionally change the priorities of the\r
+ two tasks relative to each other. */\r
+ prvChangeRelativePriorities();\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
\r
- vTaskPrioritySet( NULL, uxPriority );\r
+static void prvChangeRelativePriorities( void )\r
+{\r
+static UBaseType_t ulLoops = 0;\r
+static eRelativePriorities ePriorities = eEqualPriority;\r
+\r
+ /* Occasionally change the task priority relative to the priority of\r
+ the receiving task. */\r
+ ulLoops++;\r
+ if( ulLoops >= queuesetPRIORITY_CHANGE_LOOPS )\r
+ {\r
+ ulLoops = 0;\r
+\r
+ switch( ePriorities )\r
+ {\r
+ case eEqualPriority:\r
+ /* Both tasks are running with medium priority. Now lower the\r
+ priority of the receiving task so the Tx task has the higher\r
+ relative priority. */\r
+ vTaskPrioritySet( xQueueSetReceivingTask, queuesetLOW_PRIORITY );\r
+ ePriorities = eTxHigherPriority;\r
+ break;\r
+\r
+ case eTxHigherPriority:\r
+ /* The Tx task is running with a higher priority than the Rx\r
+ task. Switch the priorities around so the Rx task has the\r
+ higher relative priority. */\r
+ vTaskPrioritySet( xQueueSetReceivingTask, queuesetMEDIUM_PRIORITY );\r
+ vTaskPrioritySet( xQueueSetSendingTask, queuesetLOW_PRIORITY );\r
+ ePriorities = eTxLowerPriority;\r
+ break;\r
+\r
+ case eTxLowerPriority:\r
+ /* The Tx task is running with a lower priority than the Rx\r
+ task. Make the priorities equal again. */\r
+ vTaskPrioritySet( xQueueSetSendingTask, queuesetMEDIUM_PRIORITY );\r
+ ePriorities = eEqualPriority;\r
+\r
+ /* When both tasks are using a non-idle priority the queue set\r
+ tasks will starve idle priority tasks of execution time - so\r
+ relax a bit before the next iteration to minimise the impact. */\r
+ vTaskDelay( queuesetTX_LOOP_DELAY );\r
+\r
+ break;\r
}\r
}\r
}\r
\r
static void prvQueueSetReceivingTask( void *pvParameters )\r
{\r
-unsigned long ulReceived;\r
-xQueueHandle xActivatedQueue;\r
-xTaskHandle xQueueSetSendingTask;\r
+uint32_t ulReceived;\r
+QueueHandle_t xActivatedQueue;\r
\r
- /* The handle to the sending task is passed in using the task parameter. */\r
- xQueueSetSendingTask = ( xTaskHandle ) pvParameters;\r
+ /* Remove compiler warnings. */\r
+ ( void ) pvParameters;\r
\r
/* Create the queues and add them to the queue set before resuming the Tx\r
task. */\r
- prvSetupTest( xQueueSetSendingTask );\r
+ prvSetupTest();\r
\r
for( ;; )\r
{\r
\r
void vQueueSetAccessQueueSetFromISR( void )\r
{\r
-static unsigned long ulCallCount = 0;\r
+static uint32_t ulCallCount = 0;\r
\r
/* xSetupComplete is set to pdTRUE when the queues have been created and\r
are available for use. */\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static void prvCheckReceivedValue( unsigned long ulReceived )\r
+static void prvCheckReceivedValue( uint32_t ulReceived )\r
{\r
-static unsigned long ulExpectedReceivedFromTask = 0, ulExpectedReceivedFromISR = queuesetINITIAL_ISR_TX_VALUE;\r
+static uint32_t ulExpectedReceivedFromTask = 0, ulExpectedReceivedFromISR = queuesetINITIAL_ISR_TX_VALUE;\r
\r
/* Values are received in tasks and interrupts. It is likely that the\r
receiving task will sometimes get preempted by the receiving interrupt\r
{\r
/* The value received is at the lower limit of the expected range.\r
Don't test it and expect to receive one higher next time. */\r
- ulExpectedReceivedFromISR++;\r
}\r
else if( ( ULONG_MAX - ulReceived ) <= queuesetIGNORED_BOUNDARY )\r
{\r
/* The value received is at the higher limit of the expected range.\r
Don't test it and expect to wrap soon. */\r
- ulExpectedReceivedFromISR++;\r
- if( ulExpectedReceivedFromISR == 0 )\r
- {\r
- ulExpectedReceivedFromISR = queuesetINITIAL_ISR_TX_VALUE;\r
- }\r
}\r
else\r
{\r
{\r
xQueueSetTasksStatus = pdFAIL;\r
}\r
- else\r
- {\r
- /* It is expected to receive an incrementing value. */\r
- ulExpectedReceivedFromISR++;\r
- }\r
+ }\r
+\r
+ configASSERT( xQueueSetTasksStatus );\r
+\r
+ /* It is expected to receive an incrementing number. */\r
+ ulExpectedReceivedFromISR++;\r
+ if( ulExpectedReceivedFromISR == 0 )\r
+ {\r
+ ulExpectedReceivedFromISR = queuesetINITIAL_ISR_TX_VALUE;\r
}\r
}\r
else\r
{\r
/* The value received is at the lower limit of the expected range.\r
Don't test it, and expect to receive one higher next time. */\r
- ulExpectedReceivedFromTask++;\r
}\r
else if( ( ( queuesetINITIAL_ISR_TX_VALUE - 1 ) - ulReceived ) <= queuesetIGNORED_BOUNDARY )\r
{\r
/* The value received is at the higher limit of the expected range.\r
Don't test it and expect to wrap soon. */\r
- ulExpectedReceivedFromTask++;\r
- if( ulExpectedReceivedFromTask >= queuesetINITIAL_ISR_TX_VALUE )\r
- {\r
- ulExpectedReceivedFromTask = 0;\r
- }\r
}\r
else\r
{\r
{\r
xQueueSetTasksStatus = pdFAIL;\r
}\r
- else\r
- {\r
- /* It is expected to receive an incrementing value. */\r
- ulExpectedReceivedFromTask++;\r
- }\r
+ }\r
+\r
+ configASSERT( xQueueSetTasksStatus );\r
+\r
+ /* It is expected to receive an incrementing number. */\r
+ ulExpectedReceivedFromTask++;\r
+ if( ulExpectedReceivedFromTask >= queuesetINITIAL_ISR_TX_VALUE )\r
+ {\r
+ ulExpectedReceivedFromTask = 0;\r
}\r
}\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static portBASE_TYPE prvCheckReceivedValueWithinExpectedRange( unsigned long ulReceived, unsigned long ulExpectedReceived )\r
+static BaseType_t prvCheckReceivedValueWithinExpectedRange( uint32_t ulReceived, uint32_t ulExpectedReceived )\r
{\r
-portBASE_TYPE xReturn = pdPASS;\r
+BaseType_t xReturn = pdPASS;\r
\r
if( ulReceived > ulExpectedReceived )\r
{\r
\r
static void prvReceiveFromQueueInSetFromISR( void )\r
{\r
-xQueueSetMemberHandle xActivatedQueue;\r
-unsigned long ulReceived;\r
+QueueSetMemberHandle_t xActivatedQueue;\r
+uint32_t ulReceived;\r
\r
/* See if any of the queues in the set contain data. */\r
xActivatedQueue = xQueueSelectFromSetFromISR( xQueueSet );\r
\r
static void prvSendToQueueInSetFromISR( void )\r
{\r
-static portBASE_TYPE xQueueToWriteTo = 0;\r
+static BaseType_t xQueueToWriteTo = 0;\r
\r
if( xQueueSendFromISR( xQueues[ xQueueToWriteTo ], ( void * ) &ulISRTxValue, NULL ) == pdPASS )\r
{\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static void prvSetupTest( xTaskHandle xQueueSetSendingTask )\r
+static void prvSetupTest( void )\r
{\r
-portBASE_TYPE x;\r
-unsigned long ulValueToSend = 0;\r
+BaseType_t x;\r
+uint32_t ulValueToSend = 0;\r
\r
/* Ensure the queues are created and the queue set configured before the\r
sending task is unsuspended.\r
for( x = 0; x < queuesetNUM_QUEUES_IN_SET; x++ )\r
{\r
/* Create the queue and add it to the set. The queue is just holding\r
- unsigned long value. */\r
- xQueues[ x ] = xQueueCreate( queuesetQUEUE_LENGTH, sizeof( unsigned long ) );\r
+ uint32_t value. */\r
+ xQueues[ x ] = xQueueCreate( queuesetQUEUE_LENGTH, sizeof( uint32_t ) );\r
configASSERT( xQueues[ x ] );\r
if( xQueueAddToSet( xQueues[ x ], xQueueSet ) != pdPASS )\r
{\r
/* Let the ISR access the queues also. */\r
xSetupComplete = pdTRUE;\r
}\r
+/*-----------------------------------------------------------*/\r
+\r
+static uint32_t prvRand( void )\r
+{\r
+ ulNextRand = ( ulNextRand * 1103515245UL ) + 12345UL;\r
+ return ( ulNextRand / 65536UL ) % 32768UL;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvSRand( uint32_t ulSeed )\r
+{\r
+ ulNextRand = ulSeed;\r
+}\r
+\r
projects / freertos / blobdiff