AltQTest.c File Reference

#include <stdlib.h>
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "AltQTest.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	vStartAltGenericQueueTasks (unsigned portBASE_TYPE uxPriority)
portBASE_TYPE	xAreAltGenericQueueTasksStillRunning (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 80 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask(), vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

#define genqMUTEX_LOW_PRIORITY   ( tskIDLE_PRIORITY )

Definition at line 77 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask(), vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

#define genqMUTEX_MEDIUM_PRIORITY   ( tskIDLE_PRIORITY + 2 )

Definition at line 79 of file AltQTest.c.

Referenced by vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

#define genqMUTEX_TEST_PRIORITY   ( tskIDLE_PRIORITY + 1 )

Definition at line 78 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask().

#define genqNO_BLOCK   ( 0 )

Definition at line 75 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask(), and prvSendFrontAndBackTest().

#define genqQUEUE_LENGTH   ( 5 )

Definition at line 74 of file AltQTest.c.

Referenced by prvSendFrontAndBackTest(), vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

---

Function Documentation

static void prvHighPriorityMutexTask

(

void *

pvParameters

)

[static]

Definition at line 519 of file AltQTest.c.

References pdPASS, pdTRUE, portMAX_DELAY, vTaskSuspend(), xErrorDetected, xMutex, xSemaphoreAltGive, and xSemaphoreAltTake.

Referenced by vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

{
xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;

    ( void ) 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( xSemaphoreAltTake( 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( xSemaphoreAltGive( xMutex ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }       
    }
}

static void prvLowPriorityMutexTask

(

void *

pvParameters

)

[static]

Definition at line 400 of file AltQTest.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, xSemaphoreAltGive, and xSemaphoreAltTake.

Referenced by vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

{
xSemaphoreHandle xMutex = ( xSemaphoreHandle ) pvParameters;

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

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

    ( void ) pvParameters;


    for( ;; )
    {
        /* Take the mutex.  It should be available now. */
        if( xSemaphoreAltTake( 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( xSemaphoreAltGive( 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 501 of file AltQTest.c.

References ulGuardedVariable, and vTaskSuspend().

Referenced by vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

{
    ( 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 172 of file AltQTest.c.

References errQUEUE_FULL, genqNO_BLOCK, genqQUEUE_LENGTH, pdPASS, pdTRUE, portCHAR, portLONG, taskYIELD, ulLoopCounter, uxQueueMessagesWaiting(), vPrintDisplayMessage(), xErrorDetected, xQueueAltPeek, xQueueAltReceive, xQueueAltSendToBack, and xQueueAltSendToFront.

Referenced by vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

{
unsigned portLONG ulData, ulData2;
xQueueHandle xQueue;

    #ifdef USE_STDIO
    void vPrintDisplayMessage( const portCHAR * const * ppcMessageToSend );
    
        const portCHAR * const pcTaskStartMsg = "Alt 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. */
        xQueueAltSendToFront( xQueue, ( void * ) &ulLoopCounter, genqNO_BLOCK );

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

        if( xQueueAltReceive( 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;
        }

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

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

        if( xQueueAltReceive( 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++ )
        {
            xQueueAltSendToBack( 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;
        xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK );
        ulData = 0;
        xQueueAltSendToFront( 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( xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueAltSendToBack( 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( xQueueAltPeek( 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( xQueueAltReceive( 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( xQueueAltSendToBack( xQueue, &ulData, genqNO_BLOCK ) != pdPASS )
        {
            xErrorDetected = pdTRUE;
        }
        ulData = 11;
        if( xQueueAltSendToBack( 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( xQueueAltSendToFront( 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( xQueueAltSendToFront( xQueue, ( void * ) &ulData, genqNO_BLOCK ) != errQUEUE_FULL )
        {
            xErrorDetected = pdTRUE;
        }

        if( xQueueAltSendToBack( 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( xQueueAltReceive( xQueue, &ulData2, genqNO_BLOCK ) != pdPASS )
            {
                xErrorDetected = pdTRUE;
            }

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

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

        ulLoopCounter++;
    }
}

void vStartAltGenericQueueTasks

(

unsigned portBASE_TYPE

uxPriority

)

Definition at line 130 of file AltQTest.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 * ) "Alt_Gen_Test_Queue" );

    /* 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 * ) "FGenQ", 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 mutex 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 * ) "Alt_Q_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 * ) "FMuLow", configMINIMAL_STACK_SIZE, ( void * ) xMutex, genqMUTEX_LOW_PRIORITY, NULL );
    xTaskCreate( prvMediumPriorityMutexTask, ( signed portCHAR * ) "FMuMed", configMINIMAL_STACK_SIZE, NULL, genqMUTEX_MEDIUM_PRIORITY, &xMediumPriorityMutexTask );
    xTaskCreate( prvHighPriorityMutexTask, ( signed portCHAR * ) "FMuHigh", configMINIMAL_STACK_SIZE, ( void * ) xMutex, genqMUTEX_HIGH_PRIORITY, &xHighPriorityMutexTask );
}

portBASE_TYPE xAreAltGenericQueueTasksStillRunning

(

void

)

Definition at line 550 of file AltQTest.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 122 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask(), and prvMediumPriorityMutexTask().

volatile unsigned portLONG ulLoopCounter = 0 [static]

Definition at line 118 of file AltQTest.c.

Referenced by prvMediumPriorityPeekTask(), prvSendFrontAndBackTest(), xAreAltGenericQueueTasksStillRunning(), xAreGenericQueueTasksStillRunning(), and xAreQueuePeekTasksStillRunning().

volatile unsigned portLONG ulLoopCounter2 = 0 [static]

Definition at line 119 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask(), xAreAltGenericQueueTasksStillRunning(), and xAreGenericQueueTasksStillRunning().

portBASE_TYPE xErrorDetected = pdFALSE [static]

Definition at line 114 of file AltQTest.c.

Referenced by prvCountingSemaphoreTask(), prvDecrementSemaphoreCount(), prvHighestPriorityPeekTask(), prvHighPriorityMutexTask(), prvHighPriorityPeekTask(), prvIncrementSemaphoreCount(), prvLowPriorityMutexTask(), prvLowPriorityPeekTask(), prvMediumPriorityPeekTask(), prvSendFrontAndBackTest(), xAreAltGenericQueueTasksStillRunning(), xAreCountingSemaphoreTasksStillRunning(), xAreGenericQueueTasksStillRunning(), and xAreQueuePeekTasksStillRunning().

xTaskHandle xHighPriorityMutexTask [static]

Definition at line 126 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask(), vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().

xTaskHandle xMediumPriorityMutexTask [static]

Definition at line 126 of file AltQTest.c.

Referenced by prvLowPriorityMutexTask(), vStartAltGenericQueueTasks(), and vStartGenericQueueTasks().