flop.c File Reference

#include <stdlib.h>
#include <math.h>
#include "FreeRTOS.h"
#include "task.h"
#include "flop.h"

Go to the source code of this file.

Defines
#define	mathNUMBER_OF_TASKS   ( 8 )
#define	mathSTACK_SIZE   configMINIMAL_STACK_SIZE
Functions
static	portTASK_FUNCTION (vCompetingMathTask4, pvParameters)
static	portTASK_FUNCTION (vCompetingMathTask3, pvParameters)
static	portTASK_FUNCTION (vCompetingMathTask2, pvParameters)
static	portTASK_FUNCTION (vCompetingMathTask1, pvParameters)
static	portTASK_FUNCTION_PROTO (vCompetingMathTask4, pvParameters)
static	portTASK_FUNCTION_PROTO (vCompetingMathTask3, pvParameters)
static	portTASK_FUNCTION_PROTO (vCompetingMathTask2, pvParameters)
static	portTASK_FUNCTION_PROTO (vCompetingMathTask1, pvParameters)
void	vStartMathTasks (unsigned portBASE_TYPE uxPriority)
portBASE_TYPE	xAreMathsTaskStillRunning (void)
Variables
static volatile unsigned short	usTaskCheck [mathNUMBER_OF_TASKS] = { ( unsigned short ) 0 }

---

Define Documentation

#define mathNUMBER_OF_TASKS   ( 8 )

Definition at line 78 of file flop.c.

Referenced by xAreMathsTaskStillRunning().

#define mathSTACK_SIZE   configMINIMAL_STACK_SIZE

Definition at line 77 of file flop.c.

Referenced by vStartMathTasks().

---

Function Documentation

static portTASK_FUNCTION	(	vCompetingMathTask4	,
		pvParameters
	)			[static]

Definition at line 269 of file flop.c.

References pdFALSE, pdTRUE, portDOUBLE, pvPortMalloc(), and taskYIELD.

{
volatile portDOUBLE *pdArray, dTotal1, dTotal2, dDifference;
volatile unsigned short *pusTaskCheckVariable;
const size_t xArraySize = 10;
size_t xPosition;
short sError = pdFALSE;

    /* The variable this task increments to show it is still running is passed in 
    as the parameter. */
    pusTaskCheckVariable = ( unsigned short * ) pvParameters;

    pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );

    /* Keep filling an array, keeping a running total of the values placed in the 
    array.  Then run through the array adding up all the values.  If the two totals 
    do not match, stop the check variable from incrementing. */
    for( ;; )
    {
        dTotal1 = 0.0;
        dTotal2 = 0.0;

        for( xPosition = 0; xPosition < xArraySize; xPosition++ )
        {
            pdArray[ xPosition ] = ( portDOUBLE ) xPosition * 12.123;
            dTotal1 += ( portDOUBLE ) xPosition * 12.123;   
        }

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

        for( xPosition = 0; xPosition < xArraySize; xPosition++ )
        {
            dTotal2 += pdArray[ xPosition ];
        }

        dDifference = dTotal1 - dTotal2;
        if( fabs( dDifference ) > 0.001 )
        {
            sError = pdTRUE;
        }

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

        if( sError == pdFALSE )
        {
            /* If the calculation has always been correct, increment the check 
            variable so we know this task is still running okay. */
            ( *pusTaskCheckVariable )++;
        }
    }
}                

static portTASK_FUNCTION	(	vCompetingMathTask3	,
		pvParameters
	)			[static]

Definition at line 212 of file flop.c.

References pdFALSE, pdTRUE, portDOUBLE, pvPortMalloc(), and taskYIELD.

{
volatile portDOUBLE *pdArray, dTotal1, dTotal2, dDifference;
volatile unsigned short *pusTaskCheckVariable;
const size_t xArraySize = 10;
size_t xPosition;
short sError = pdFALSE;

    /* The variable this task increments to show it is still running is passed in 
    as the parameter. */
    pusTaskCheckVariable = ( unsigned short * ) pvParameters;

    pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );

    /* Keep filling an array, keeping a running total of the values placed in the 
    array.  Then run through the array adding up all the values.  If the two totals 
    do not match, stop the check variable from incrementing. */
    for( ;; )
    {
        dTotal1 = 0.0;
        dTotal2 = 0.0;

        for( xPosition = 0; xPosition < xArraySize; xPosition++ )
        {
            pdArray[ xPosition ] = ( portDOUBLE ) xPosition + 5.5;
            dTotal1 += ( portDOUBLE ) xPosition + 5.5;  
        }

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

        for( xPosition = 0; xPosition < xArraySize; xPosition++ )
        {
            dTotal2 += pdArray[ xPosition ];
        }

        dDifference = dTotal1 - dTotal2;
        if( fabs( dDifference ) > 0.001 )
        {
            sError = pdTRUE;
        }

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

        if( sError == pdFALSE )
        {
            /* If the calculation has always been correct, increment the check 
            variable so we know this task is still running okay. */
            ( *pusTaskCheckVariable )++;
        }
    }
}

static portTASK_FUNCTION	(	vCompetingMathTask2	,
		pvParameters
	)			[static]

Definition at line 159 of file flop.c.

References pdFALSE, pdTRUE, portDOUBLE, and taskYIELD.

{
volatile portDOUBLE d1, d2, d3, d4;
volatile unsigned short *pusTaskCheckVariable;
volatile portDOUBLE dAnswer;
short sError = pdFALSE;

    d1 = -389.38;
    d2 = 32498.2;
    d3 = -2.0001;

    dAnswer = ( d1 / d2 ) * d3;


    /* The variable this task increments to show it is still running is passed in 
    as the parameter. */
    pusTaskCheckVariable = ( unsigned short * ) pvParameters;

    /* Keep performing a calculation and checking the result against a constant. */
    for( ;; )
    {
        d1 = -389.38;
        d2 = 32498.2;
        d3 = -2.0001;

        d4 = ( d1 / d2 ) * d3;

        #if configUSE_PREEMPTION == 0
            taskYIELD();
        #endif
        
        /* If the calculation does not match the expected constant, stop the 
        increment of the check variable. */
        if( fabs( d4 - dAnswer ) > 0.001 )
        {
            sError = pdTRUE;
        }

        if( sError == pdFALSE )
        {
            /* If the calculation has always been correct, increment the check 
            variable so we know
            this task is still running okay. */
            ( *pusTaskCheckVariable )++;
        }

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

static portTASK_FUNCTION	(	vCompetingMathTask1	,
		pvParameters
	)			[static]

Definition at line 107 of file flop.c.

References pdFALSE, pdTRUE, portDOUBLE, and taskYIELD.

{
volatile portDOUBLE d1, d2, d3, d4;
volatile unsigned short *pusTaskCheckVariable;
volatile portDOUBLE dAnswer;
short sError = pdFALSE;

    d1 = 123.4567;
    d2 = 2345.6789;
    d3 = -918.222;

    dAnswer = ( d1 + d2 ) * d3;

    /* The variable this task increments to show it is still running is passed in 
    as the parameter. */
    pusTaskCheckVariable = ( unsigned short * ) pvParameters;

    /* Keep performing a calculation and checking the result against a constant. */
    for(;;)
    {
        d1 = 123.4567;
        d2 = 2345.6789;
        d3 = -918.222;

        d4 = ( d1 + d2 ) * d3;

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

        /* If the calculation does not match the expected constant, stop the 
        increment of the check variable. */
        if( fabs( d4 - dAnswer ) > 0.001 )
        {
            sError = pdTRUE;
        }

        if( sError == pdFALSE )
        {
            /* If the calculation has always been correct, increment the check 
            variable so we know this task is still running okay. */
            ( *pusTaskCheckVariable )++;
        }

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

    }
}

static portTASK_FUNCTION_PROTO	(	vCompetingMathTask4	,
		pvParameters
	)			[static]

static portTASK_FUNCTION_PROTO	(	vCompetingMathTask3	,
		pvParameters
	)			[static]

static portTASK_FUNCTION_PROTO	(	vCompetingMathTask2	,
		pvParameters
	)			[static]

static portTASK_FUNCTION_PROTO	(	vCompetingMathTask1	,
		pvParameters
	)			[static]

void vStartMathTasks

(

unsigned portBASE_TYPE

uxPriority

)

Definition at line 94 of file flop.c.

References mathSTACK_SIZE, usTaskCheck, and xTaskCreate.

Referenced by main().

{
    xTaskCreate( vCompetingMathTask1, ( signed char * ) "Math1", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 0 ] ), uxPriority, NULL );
    xTaskCreate( vCompetingMathTask2, ( signed char * ) "Math2", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 1 ] ), uxPriority, NULL );
    xTaskCreate( vCompetingMathTask3, ( signed char * ) "Math3", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 2 ] ), uxPriority, NULL );
    xTaskCreate( vCompetingMathTask4, ( signed char * ) "Math4", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 3 ] ), uxPriority, NULL );
    xTaskCreate( vCompetingMathTask1, ( signed char * ) "Math5", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 4 ] ), uxPriority, NULL );
    xTaskCreate( vCompetingMathTask2, ( signed char * ) "Math6", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 5 ] ), uxPriority, NULL );
    xTaskCreate( vCompetingMathTask3, ( signed char * ) "Math7", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 6 ] ), uxPriority, NULL );
    xTaskCreate( vCompetingMathTask4, ( signed char * ) "Math8", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 7 ] ), uxPriority, NULL );
}

portBASE_TYPE xAreMathsTaskStillRunning

(

void

)

Definition at line 327 of file flop.c.

References mathNUMBER_OF_TASKS, pdFALSE, pdTRUE, portBASE_TYPE, and usTaskCheck.

Referenced by prvCheckOtherTasksAreStillRunning().

{
/* Keep a history of the check variables so we know if they have been incremented 
since the last call. */
static unsigned short usLastTaskCheck[ mathNUMBER_OF_TASKS ] = { ( unsigned short ) 0 };
portBASE_TYPE xReturn = pdTRUE, xTask;

    /* Check the maths tasks are still running by ensuring their check variables 
    are still incrementing. */
    for( xTask = 0; xTask < mathNUMBER_OF_TASKS; xTask++ )
    {
        if( usTaskCheck[ xTask ] == usLastTaskCheck[ xTask ] )
        {
            /* The check has not incremented so an error exists. */
            xReturn = pdFALSE;
        }

        usLastTaskCheck[ xTask ] = usTaskCheck[ xTask ];
    }

    return xReturn;
}

---

Variable Documentation

volatile unsigned short usTaskCheck[mathNUMBER_OF_TASKS] = { ( unsigned short ) 0 } [static]

Definition at line 90 of file flop.c.

Referenced by vStartMathTasks(), and xAreMathsTaskStillRunning().