GenQTest.c File Reference

#include <stdlib.h>
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "GenQTest.h"

Go to the source code of this file.

Defines
#define	genqMUTEX_HIGH_PRIORITY   ( tskIDLE_PRIORITY + 3 )
#define	genqMUTEX_LOW_PRIORITY   ( tskIDLE_PRIORITY )
#define	genqMUTEX_MEDIUM_PRIORITY   ( tskIDLE_PRIORITY + 2 )
#define	genqMUTEX_TEST_PRIORITY   ( tskIDLE_PRIORITY + 1 )
#define	genqNO_BLOCK   ( 0 )
#define	genqQUEUE_LENGTH   ( 5 )
Functions
static void	prvHighPriorityMutexTask (void *pvParameters)
static void	prvLowPriorityMutexTask (void *pvParameters)
static void	prvMediumPriorityMutexTask (void *pvParameters)
static void	prvSendFrontAndBackTest (void *pvParameters)
void	vStartGenericQueueTasks (unsigned portBASE_TYPE uxPriority)
portBASE_TYPE	xAreGenericQueueTasksStillRunning (void)
Variables
static volatile unsigned portLONG	ulGuardedVariable = 0
static volatile unsigned portLONG	ulLoopCounter = 0
static volatile unsigned portLONG	ulLoopCounter2 = 0
static portBASE_TYPE	xErrorDetected = pdFALSE
static xTaskHandle	xHighPriorityMutexTask
static xTaskHandle	xMediumPriorityMutexTask

---

Define Documentation

#define genqMUTEX_HIGH_PRIORITY   ( tskIDLE_PRIORITY + 3 )

Definition at line 82 of file GenQTest.c.

#define genqMUTEX_LOW_PRIORITY   ( tskIDLE_PRIORITY )

Definition at line 79 of file GenQTest.c.

#define genqMUTEX_MEDIUM_PRIORITY   ( tskIDLE_PRIORITY + 2 )

Definition at line 81 of file GenQTest.c.

#define genqMUTEX_TEST_PRIORITY   ( tskIDLE_PRIORITY + 1 )

Definition at line 80 of file GenQTest.c.

#define genqNO_BLOCK   ( 0 )

Definition at line 77 of file GenQTest.c.

#define genqQUEUE_LENGTH   ( 5 )

Definition at line 76 of file GenQTest.c.

---

Function Documentation

static void prvHighPriorityMutexTask

(

void *

pvParameters

)

[static]

Definition at line 518 of file GenQTest.c.

References pdPASS, pdTRUE, portMAX_DELAY, vTaskSuspend(), xErrorDetected, xMutex, xSemaphoreGive, and xSemaphoreTake.

{
xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;

    for( ;; )
    {
        /* The high priority task starts by suspending itself.  The low
        priority task will unsuspend this task when required. */
        vTaskSuspend( NULL );

        /* When this task unsuspends all it does is attempt to obtain
        the mutex.  It should find the mutex is not available so a
        block time is specified. */
        if( xSemaphoreTake( xMutex, portMAX_DELAY ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }

        /* When we eventually obtain the mutex we just give it back then
        return to suspend ready for the next test. */
        if( xSemaphoreGive( xMutex ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }       
    }
}

static void prvLowPriorityMutexTask

(

void *

pvParameters

)

[static]

Definition at line 402 of file GenQTest.c.

References genqMUTEX_HIGH_PRIORITY, genqMUTEX_LOW_PRIORITY, genqMUTEX_TEST_PRIORITY, genqNO_BLOCK, pdPASS, pdTRUE, portCHAR, taskYIELD, ulGuardedVariable, ulLoopCounter2, uxTaskPriorityGet(), vPrintDisplayMessage(), vTaskPrioritySet(), vTaskResume(), xErrorDetected, xHighPriorityMutexTask, xMediumPriorityMutexTask, xMutex, xSemaphoreGive, and xSemaphoreTake.

{
xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;

    #ifdef USE_STDIO
    void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend );
    
        const portCHAR * const pcTaskStartMsg = "Mutex with priority inheritance test started.\r\n";

        /* Queue a message for printing to say the task has started. */
        vPrintDisplayMessage( &pcTaskStartMsg );
    #endif

    for( ;; )
    {
        /* Take the mutex.  It should be available now. */
        if( xSemaphoreTake( xMutex, genqNO_BLOCK ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }

        /* Set our guarded variable to a known start value. */
        ulGuardedVariable = 0;

        /* Our priority should be as per that assigned when the task was
        created. */
        if( uxTaskPriorityGet( NULL ) != genqMUTEX_LOW_PRIORITY )
        {
            xErrorDetected = pdTRUE;
        }

        /* Now unsuspend the high priority task.  This will attempt to take the
        mutex, and block when it finds it cannot obtain it. */
        vTaskResume( xHighPriorityMutexTask );

        /* We should now have inherited the prioritoy of the high priority task,
        as by now it will have attempted to get the mutex. */
        if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )
        {
            xErrorDetected = pdTRUE;
        }

        /* We can attempt to set our priority to the test priority - between the
        idle priority and the medium/high test priorities, but our actual
        prioroity should remain at the high priority. */
        vTaskPrioritySet( NULL, genqMUTEX_TEST_PRIORITY );
        if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )
        {
            xErrorDetected = pdTRUE;
        }

        /* Now unsuspend the medium priority task.  This should not run as our
        inherited priority is above that of the medium priority task. */
        vTaskResume( xMediumPriorityMutexTask );

        /* If the did run then it will have incremented our guarded variable. */
        if( ulGuardedVariable != 0 )
        {
            xErrorDetected = pdTRUE;
        }

        /* When we give back the semaphore our priority should be disinherited
        back to the priority to which we attempted to set ourselves.  This means
        that when the high priority task next blocks, the medium priority task
        should execute and increment the guarded variable.   When we next run
        both the high and medium priority tasks will have been suspended again. */
        if( xSemaphoreGive( xMutex ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }

        /* Check that the guarded variable did indeed increment... */
        if( ulGuardedVariable != 1 )
        {
            xErrorDetected = pdTRUE;
        }

        /* ... and that our priority has been disinherited to
        genqMUTEX_TEST_PRIORITY. */
        if( uxTaskPriorityGet( NULL ) != genqMUTEX_TEST_PRIORITY )
        {
            xErrorDetected = pdTRUE;
        }

        /* Set our priority back to our original priority ready for the next
        loop around this test. */
        vTaskPrioritySet( NULL, genqMUTEX_LOW_PRIORITY );

        /* Just to show we are still running. */
        ulLoopCounter2++;

        #if configUSE_PREEMPTION == 0
            taskYIELD();
        #endif      
    }
}

static void prvMediumPriorityMutexTask

(

void *

pvParameters

)

[static]

Definition at line 500 of file GenQTest.c.

References ulGuardedVariable, and vTaskSuspend().

{
    ( void ) pvParameters;

    for( ;; )
    {
        /* The medium priority task starts by suspending itself.  The low
        priority task will unsuspend this task when required. */
        vTaskSuspend( NULL );

        /* When this task unsuspends all it does is increment the guarded
        variable, this is so the low priority task knows that it has
        executed. */
        ulGuardedVariable++;
    }
}

static void prvSendFrontAndBackTest

(

void *

pvParameters

)

[static]

Definition at line 174 of file GenQTest.c.

References errQUEUE_FULL, genqNO_BLOCK, genqQUEUE_LENGTH, pdPASS, pdTRUE, portCHAR, portLONG, taskYIELD, ulLoopCounter, uxQueueMessagesWaiting(), vPrintDisplayMessage(), xErrorDetected, xQueuePeek, xQueueReceive, xQueueSend, xQueueSendToBack, and xQueueSendToFront.

{
unsigned portLONG ulData, ulData2;
xQueueHandle xQueue;

    #ifdef USE_STDIO
    void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend );
    
        const portCHAR * const pcTaskStartMsg = "Queue SendToFront/SendToBack/Peek test started.\r\n";

        /* Queue a message for printing to say the task has started. */
        vPrintDisplayMessage( &pcTaskStartMsg );
    #endif

    xQueue = ( xQueueHandle ) pvParameters;

    for( ;; )
    {
        /* The queue is empty, so sending an item to the back of the queue
        should have the same efect as sending it to the front of the queue.

        First send to the front and check everything is as expected. */
        xQueueSendToFront( xQueue, ( void * ) &ulLoopCounter, genqNO_BLOCK );

        if( uxQueueMessagesWaiting( xQueue ) != 1 )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueReceive( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }

        /* The data we sent to the queue should equal the data we just received
        from the queue. */
        if( ulLoopCounter != ulData )
        {
            xErrorDetected = pdTRUE;
        }

        /* Then do the same, sending the data to the back, checking everything
        is as expected. */
        if( uxQueueMessagesWaiting( xQueue ) != 0 )
        {
            xErrorDetected = pdTRUE;
        }

        xQueueSendToBack( xQueue, ( void * ) &ulLoopCounter, genqNO_BLOCK );

        if( uxQueueMessagesWaiting( xQueue ) != 1 )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueReceive( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }

        if( uxQueueMessagesWaiting( xQueue ) != 0 )
        {
            xErrorDetected = pdTRUE;
        }

        /* The data we sent to the queue should equal the data we just received
        from the queue. */
        if( ulLoopCounter != ulData )
        {
            xErrorDetected = pdTRUE;
        }

        #if configUSE_PREEMPTION == 0
            taskYIELD();
        #endif



        /* Place 2, 3, 4 into the queue, adding items to the back of the queue. */
        for( ulData = 2; ulData < 5; ulData++ )
        {
            xQueueSendToBack( xQueue, ( void * ) &ulData, genqNO_BLOCK );
        }

        /* Now the order in the queue should be 2, 3, 4, with 2 being the first
        thing to be read out.  Now add 1 then 0 to the front of the queue. */
        if( uxQueueMessagesWaiting( xQueue ) != 3 )
        {
            xErrorDetected = pdTRUE;
        }
        ulData = 1;
        xQueueSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK );
        ulData = 0;
        xQueueSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK );

        /* Now the queue should be full, and when we read the data out we
        should receive 0, 1, 2, 3, 4. */
        if( uxQueueMessagesWaiting( xQueue ) != 5 )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueSendToBack( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL )
        {
            xErrorDetected = pdTRUE;
        }

        #if configUSE_PREEMPTION == 0
            taskYIELD();
        #endif

        /* Check the data we read out is in the expected order. */
        for( ulData = 0; ulData < genqQUEUE_LENGTH; ulData++ )
        {
            /* Try peeking the data first. */
            if( xQueuePeek( xQueue, &ulData2, genqNO_BLOCK ) != pdPASS )
            {
                xErrorDetected = pdTRUE;
            }

            if( ulData != ulData2 )
            {
                xErrorDetected = pdTRUE;
            }
            

            /* Now try receiving the data for real.  The value should be the
            same.  Clobber the value first so we know we really received it. */
            ulData2 = ~ulData2;
            if( xQueueReceive( xQueue, &ulData2, genqNO_BLOCK ) != pdPASS )
            {
                xErrorDetected = pdTRUE;
            }

            if( ulData != ulData2 )
            {
                xErrorDetected = pdTRUE;
            }
        }

        /* The queue should now be empty again. */
        if( uxQueueMessagesWaiting( xQueue ) != 0 )
        {
            xErrorDetected = pdTRUE;
        }

        #if configUSE_PREEMPTION == 0
            taskYIELD();
        #endif


        /* Our queue is empty once more, add 10, 11 to the back. */
        ulData = 10;
        if( xQueueSend( xQueue, &ulData, genqNO_BLOCK ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }
        ulData = 11;
        if( xQueueSend( xQueue, &ulData, genqNO_BLOCK ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }

        if( uxQueueMessagesWaiting( xQueue ) != 2 )
        {
            xErrorDetected = pdTRUE;
        }

        /* Now we should have 10, 11 in the queue.  Add 7, 8, 9 to the
        front. */
        for( ulData = 9; ulData >= 7; ulData-- )
        {
            if( xQueueSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != pdPASS )
            {
                xErrorDetected = pdTRUE;
            }
        }

        /* Now check that the queue is full, and that receiving data provides
        the expected sequence of 7, 8, 9, 10, 11. */
        if( uxQueueMessagesWaiting( xQueue ) != 5 )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueSendToBack( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL )
        {
            xErrorDetected = pdTRUE;
        }

        #if configUSE_PREEMPTION == 0
            taskYIELD();
        #endif

        /* Check the data we read out is in the expected order. */
        for( ulData = 7; ulData < ( 7 + genqQUEUE_LENGTH ); ulData++ )
        {
            if( xQueueReceive( xQueue, &ulData2, genqNO_BLOCK ) != pdPASS )
            {
                xErrorDetected = pdTRUE;
            }

            if( ulData != ulData2 )
            {
                xErrorDetected = pdTRUE;
            }
        }

        if( uxQueueMessagesWaiting( xQueue ) != 0 )
        {
            xErrorDetected = pdTRUE;
        }

        ulLoopCounter++;
    }
}

void vStartGenericQueueTasks

(

unsigned portBASE_TYPE

uxPriority

)

Definition at line 132 of file GenQTest.c.

References configMINIMAL_STACK_SIZE, genqMUTEX_HIGH_PRIORITY, genqMUTEX_LOW_PRIORITY, genqMUTEX_MEDIUM_PRIORITY, genqQUEUE_LENGTH, portCHAR, portLONG, prvHighPriorityMutexTask(), prvLowPriorityMutexTask(), prvMediumPriorityMutexTask(), prvSendFrontAndBackTest(), vQueueAddToRegistry, xHighPriorityMutexTask, xMediumPriorityMutexTask, xMutex, xQueueCreate(), xSemaphoreCreateMutex, and xTaskCreate.

{
xQueueHandle xQueue;
xSemaphoreHandle xMutex;

    /* Create the queue that we are going to use for the
    prvSendFrontAndBackTest demo. */
    xQueue = xQueueCreate( genqQUEUE_LENGTH, sizeof( unsigned portLONG ) );

    /* vQueueAddToRegistry() adds the queue to the queue registry, if one is
    in use.  The queue registry is provided as a means for kernel aware 
    debuggers to locate queues and has no purpose if a kernel aware debugger
    is not being used.  The call to vQueueAddToRegistry() will be removed
    by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is 
    defined to be less than 1. */
    vQueueAddToRegistry( xQueue, ( signed portCHAR * ) "Gen_Queue_Test" );

    /* Create the demo task and pass it the queue just created.  We are
    passing the queue handle by value so it does not matter that it is
    declared on the stack here. */
    xTaskCreate( prvSendFrontAndBackTest, ( signed portCHAR * )"GenQ", configMINIMAL_STACK_SIZE, ( void * ) xQueue, uxPriority, NULL );

    /* Create the mutex used by the prvMutexTest task. */
    xMutex = xSemaphoreCreateMutex();

    /* vQueueAddToRegistry() adds the mutex to the registry, if one is
    in use.  The registry is provided as a means for kernel aware 
    debuggers to locate mutexes and has no purpose if a kernel aware debugger
    is not being used.  The call to vQueueAddToRegistry() will be removed
    by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is 
    defined to be less than 1. */
    vQueueAddToRegistry( ( xQueueHandle ) xMutex, ( signed portCHAR * ) "Gen_Queue_Mutex" );

    /* Create the mutex demo tasks and pass it the mutex just created.  We are
    passing the mutex handle by value so it does not matter that it is declared
    on the stack here. */
    xTaskCreate( prvLowPriorityMutexTask, ( signed portCHAR * )"MuLow", configMINIMAL_STACK_SIZE, ( void * ) xMutex, genqMUTEX_LOW_PRIORITY, NULL );
    xTaskCreate( prvMediumPriorityMutexTask, ( signed portCHAR * )"MuMed", configMINIMAL_STACK_SIZE, NULL, genqMUTEX_MEDIUM_PRIORITY, &xMediumPriorityMutexTask );
    xTaskCreate( prvHighPriorityMutexTask, ( signed portCHAR * )"MuHigh", configMINIMAL_STACK_SIZE, ( void * ) xMutex, genqMUTEX_HIGH_PRIORITY, &xHighPriorityMutexTask );
}

portBASE_TYPE xAreGenericQueueTasksStillRunning

(

void

)

Definition at line 547 of file GenQTest.c.

References pdTRUE, portLONG, ulLoopCounter, ulLoopCounter2, and xErrorDetected.

{
static unsigned portLONG ulLastLoopCounter = 0, ulLastLoopCounter2 = 0;

    /* If the demo task is still running then we expect the loopcounters to
    have incremented since this function was last called. */
    if( ulLastLoopCounter == ulLoopCounter )
    {
        xErrorDetected = pdTRUE;
    }

    if( ulLastLoopCounter2 == ulLoopCounter2 )
    {
        xErrorDetected = pdTRUE;
    }

    ulLastLoopCounter = ulLoopCounter;
    ulLastLoopCounter2 = ulLoopCounter2;    

    /* Errors detected in the task itself will have latched xErrorDetected
    to true. */

    return !xErrorDetected;
}

---

Variable Documentation

volatile unsigned portLONG ulGuardedVariable = 0 [static]

Definition at line 124 of file GenQTest.c.

volatile unsigned portLONG ulLoopCounter = 0 [static]

Definition at line 120 of file GenQTest.c.

volatile unsigned portLONG ulLoopCounter2 = 0 [static]

Definition at line 121 of file GenQTest.c.

portBASE_TYPE xErrorDetected = pdFALSE [static]

Definition at line 116 of file GenQTest.c.

xTaskHandle xHighPriorityMutexTask [static]

Definition at line 128 of file GenQTest.c.

xTaskHandle xMediumPriorityMutexTask [static]

Definition at line 128 of file GenQTest.c.