begriffs open source - cmsis-freertos/blob - Demo/Common/Minimal/QueueSetPolling.c

   1 /*
   2  * FreeRTOS V202111.00
   3  * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   6  * this software and associated documentation files (the "Software"), to deal in
   7  * the Software without restriction, including without limitation the rights to
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
   9  * the Software, and to permit persons to whom the Software is furnished to do so,
  10  * subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in all
  13  * copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * http://www.FreeRTOS.org
  23  * http://aws.amazon.com/freertos
  24  *
  25  * 1 tab == 4 spaces!
  26  */
  27
  28 /*
  29  * Tests the use of queue sets.
  30  *
  31  * A receive task creates a number of queues and adds them to a queue set before
  32  * blocking on the queue set receive.  A transmit task and (optionally) an
  33  * interrupt repeatedly unblocks the receive task by sending messages to the
  34  * queues in a pseudo random order.  The receive task removes the messages from
  35  * the queues and flags an error if the received message does not match that
  36  * expected.  The task sends values in the range 0 to
  37  * queuesetINITIAL_ISR_TX_VALUE, and the ISR sends value in the range
  38  * queuesetINITIAL_ISR_TX_VALUE to ULONG_MAX.
  39  */
  40
  41
  42 /* Standard includes. */
  43 #include <stdlib.h>
  44 #include <limits.h>
  45
  46 /* Kernel includes. */
  47 #include "FreeRTOS.h"
  48 #include "task.h"
  49 #include "queue.h"
  50
  51 /* Demo includes. */
  52 #include "QueueSetPolling.h"
  53
  54 #if ( configUSE_QUEUE_SETS == 1 ) /* Remove tests if queue sets are not defined. */
  55
  56 /* The length of each created queue. */
  57     #define setpollQUEUE_LENGTH      10
  58
  59 /* Block times used in this demo.  A block time or 0 means "don't block". */
  60     #define setpollDONT_BLOCK        0
  61
  62 /* The ISR sends to the queue every setpollISR_TX_PERIOD ticks. */
  63     #define queuesetISR_TX_PERIOD    ( 50UL )
  64
  65 /*
  66  * The task that reads from the queue set.
  67  */
  68     static void prvQueueSetReceivingTask( void * pvParameters );
  69
  70 /*-----------------------------------------------------------*/
  71
  72 /* The queue that is added to the set. */
  73     static QueueHandle_t xQueue = NULL;
  74
  75 /* The handle of the queue set to which the queue is added. */
  76     static QueueSetHandle_t xQueueSet = NULL;
  77
  78 /* Set to pdFAIL if an error is detected by any queue set task.
  79  * ulCycleCounter will only be incremented if xQueueSetTasksSatus equals pdPASS. */
  80     static volatile BaseType_t xQueueSetPollStatus = pdPASS;
  81
  82 /* Counter used to ensure the task is still running. */
  83     static uint32_t ulCycleCounter = 0;
  84
  85 /*-----------------------------------------------------------*/
  86
  87     void vStartQueueSetPollingTask( void )
  88     {
  89         /* Create the queue that is added to the set, the set, and add the queue to
  90          * the set. */
  91         xQueue = xQueueCreate( setpollQUEUE_LENGTH, sizeof( uint32_t ) );
  92         xQueueSet = xQueueCreateSet( setpollQUEUE_LENGTH );
  93
  94         if( ( xQueue != NULL ) && ( xQueueSet != NULL ) )
  95         {
  96             xQueueAddToSet( xQueue, xQueueSet );
  97
  98             /* Create the task. */
  99             xTaskCreate( prvQueueSetReceivingTask, "SetPoll", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
 100         }
 101     }
 102 /*-----------------------------------------------------------*/
 103
 104     static void prvQueueSetReceivingTask( void * pvParameters )
 105     {
 106         uint32_t ulReceived, ulExpected = 0;
 107         QueueHandle_t xActivatedQueue;
 108
 109         /* Remove compiler warnings. */
 110         ( void ) pvParameters;
 111
 112         for( ; ; )
 113         {
 114             /* Is a message waiting?  A block time is not used to ensure the queue
 115              * set is polled while it is being written to from an interrupt. */
 116             xActivatedQueue = xQueueSelectFromSet( xQueueSet, setpollDONT_BLOCK );
 117
 118             if( xActivatedQueue != NULL )
 119             {
 120                 /* Reading from the queue should pass with a zero block time as
 121                  * this task will only run when something has been posted to a task
 122                  * in the queue set. */
 123                 if( xQueueReceive( xActivatedQueue, &ulReceived, setpollDONT_BLOCK ) != pdPASS )
 124                 {
 125                     xQueueSetPollStatus = pdFAIL;
 126                 }
 127
 128                 if( ulReceived == ulExpected )
 129                 {
 130                     ulExpected++;
 131                 }
 132                 else
 133                 {
 134                     xQueueSetPollStatus = pdFAIL;
 135                 }
 136
 137                 if( xQueueSetPollStatus == pdPASS )
 138                 {
 139                     ulCycleCounter++;
 140                 }
 141             }
 142         }
 143     }
 144 /*-----------------------------------------------------------*/
 145
 146     void vQueueSetPollingInterruptAccess( void )
 147     {
 148         static uint32_t ulCallCount = 0, ulValueToSend = 0;
 149
 150         /* It is intended that this function is called from the tick hook
 151          * function, so each call is one tick period apart. */
 152         ulCallCount++;
 153
 154         if( ulCallCount > queuesetISR_TX_PERIOD )
 155         {
 156             ulCallCount = 0;
 157
 158             if( xQueueSendFromISR( xQueue, ( void * ) &ulValueToSend, NULL ) == pdPASS )
 159             {
 160                 /* Send the next value next time. */
 161                 ulValueToSend++;
 162             }
 163         }
 164     }
 165 /*-----------------------------------------------------------*/
 166
 167     BaseType_t xAreQueueSetPollTasksStillRunning( void )
 168     {
 169         static uint32_t ulLastCycleCounter = 0;
 170
 171         if( ulLastCycleCounter == ulCycleCounter )
 172         {
 173             xQueueSetPollStatus = pdFAIL;
 174         }
 175
 176         ulLastCycleCounter = ulCycleCounter;
 177
 178         return xQueueSetPollStatus;
 179     }
 180 /*-----------------------------------------------------------*/
 181
 182
 183 #endif /* ( configUSE_QUEUE_SETS == 1 ) */