len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-04-19 21:11:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

Improve the error detection in some of the standard demo tasks.

Browse source
This commit is contained in:
Richard Barry 2013-06-11 18:46:00 +00:00
parent 3b004f9900
commit f038fd6a86
3 changed files with 134 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
FreeRTOS/Demo/Common/Minimal/IntQueue.c
View file

@ -56,19 +56,19 @@
*************************************************************************** ***************************************************************************
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org - Documentation, books, training, latest versions,
license and Real Time Engineers Ltd. contact details. license and Real Time Engineers Ltd. contact details.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, and our new including FreeRTOS+Trace - an indispensable productivity tool, and our new
fully thread aware and reentrant UDP/IP stack. fully thread aware and reentrant UDP/IP stack.
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High
Integrity Systems, who sell the code with commercial support, Integrity Systems, who sell the code with commercial support,
indemnification and middleware, under the OpenRTOS brand. indemnification and middleware, under the OpenRTOS brand.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability. mission critical applications that require provable dependability.
*/ */
@ -108,7 +108,7 @@
/* The number of values to send/receive before checking that all values were /* The number of values to send/receive before checking that all values were
processed as expected. */ processed as expected. */
#define intqNUM_VALUES_TO_LOG ( 200 ) #define intqNUM_VALUES_TO_LOG ( 200 )
#define intqSHORT_DELAY ( 75 ) #define intqSHORT_DELAY ( 140 )
/* The value by which the value being sent to or received from a queue should /* The value by which the value being sent to or received from a queue should
increment past intqNUM_VALUES_TO_LOG before we check that all values have been increment past intqNUM_VALUES_TO_LOG before we check that all values have been
@ -236,15 +236,17 @@ void vStartInterruptQueueTasks( void )
/* Start the test tasks. */ /* Start the test tasks. */
xTaskCreate( prvHigherPriorityNormallyEmptyTask, ( signed portCHAR * ) "H1QRx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK1, intqHIGHER_PRIORITY, &xHighPriorityNormallyEmptyTask1 ); xTaskCreate( prvHigherPriorityNormallyEmptyTask, ( signed portCHAR * ) "H1QRx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK1, intqHIGHER_PRIORITY, &xHighPriorityNormallyEmptyTask1 );
xTaskCreate( prvHigherPriorityNormallyEmptyTask, ( signed portCHAR * ) "H2QRx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK2, intqHIGHER_PRIORITY, &xHighPriorityNormallyEmptyTask2 ); xTaskCreate( prvHigherPriorityNormallyEmptyTask, ( signed portCHAR * ) "H2QRx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK2, intqHIGHER_PRIORITY, &xHighPriorityNormallyEmptyTask2 );
xTaskCreate( prvLowerPriorityNormallyEmptyTask, ( signed portCHAR * ) "LQRx", configMINIMAL_STACK_SIZE, NULL, intqLOWER_PRIORITY, NULL ); xTaskCreate( prvLowerPriorityNormallyEmptyTask, ( signed portCHAR * ) "L1QRx", configMINIMAL_STACK_SIZE, NULL, intqLOWER_PRIORITY, NULL );
xTaskCreate( prv1stHigherPriorityNormallyFullTask, ( signed portCHAR * ) "H1QTx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK1, intqHIGHER_PRIORITY, &xHighPriorityNormallyFullTask1 ); xTaskCreate( prv1stHigherPriorityNormallyFullTask, ( signed portCHAR * ) "H1QTx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK1, intqHIGHER_PRIORITY, &xHighPriorityNormallyFullTask1 );
xTaskCreate( prv2ndHigherPriorityNormallyFullTask, ( signed portCHAR * ) "H2QTx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK2, intqHIGHER_PRIORITY, &xHighPriorityNormallyFullTask2 ); xTaskCreate( prv2ndHigherPriorityNormallyFullTask, ( signed portCHAR * ) "H2QTx", configMINIMAL_STACK_SIZE, ( void * ) intqHIGH_PRIORITY_TASK2, intqHIGHER_PRIORITY, &xHighPriorityNormallyFullTask2 );
xTaskCreate( prvLowerPriorityNormallyFullTask, ( signed portCHAR * ) "LQRx", configMINIMAL_STACK_SIZE, NULL, intqLOWER_PRIORITY, NULL ); xTaskCreate( prvLowerPriorityNormallyFullTask, ( signed portCHAR * ) "L2QRx", configMINIMAL_STACK_SIZE, NULL, intqLOWER_PRIORITY, NULL );
/* Create the queues that are accessed by multiple tasks and multiple /* Create the queues that are accessed by multiple tasks and multiple
interrupts. */ interrupts. */
xNormallyFullQueue = xQueueCreate( intqQUEUE_LENGTH, ( unsigned portBASE_TYPE ) sizeof( unsigned portBASE_TYPE ) ); xNormallyFullQueue = xQueueCreate( intqQUEUE_LENGTH, ( unsigned portBASE_TYPE ) sizeof( unsigned portBASE_TYPE ) );
xNormallyEmptyQueue = xQueueCreate( intqQUEUE_LENGTH, ( unsigned portBASE_TYPE ) sizeof( unsigned portBASE_TYPE ) ); xNormallyEmptyQueue = xQueueCreate( intqQUEUE_LENGTH, ( unsigned portBASE_TYPE ) sizeof( unsigned portBASE_TYPE ) );
// vTraceSetQueueName( xNormallyFullQueue, "NF" );
// vTraceSetQueueName( xNormallyEmptyQueue, "NE" );
/* vQueueAddToRegistry() adds the queue to the queue registry, if one is /* vQueueAddToRegistry() adds the queue to the queue registry, if one is
in use. The queue registry is provided as a means for kernel aware in use. The queue registry is provided as a means for kernel aware

99
FreeRTOS/Demo/Common/Minimal/dynamic.c
View file

@ -56,48 +56,48 @@
*************************************************************************** ***************************************************************************
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org - Documentation, books, training, latest versions,
license and Real Time Engineers Ltd. contact details. license and Real Time Engineers Ltd. contact details.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, and our new including FreeRTOS+Trace - an indispensable productivity tool, and our new
fully thread aware and reentrant UDP/IP stack. fully thread aware and reentrant UDP/IP stack.
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High
Integrity Systems, who sell the code with commercial support, Integrity Systems, who sell the code with commercial support,
indemnification and middleware, under the OpenRTOS brand. indemnification and middleware, under the OpenRTOS brand.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability. mission critical applications that require provable dependability.
*/ */
/* /*
* The first test creates three tasks - two counter tasks (one continuous count * The first test creates three tasks - two counter tasks (one continuous count
* and one limited count) and one controller. A "count" variable is shared * and one limited count) and one controller. A "count" variable is shared
* between all three tasks. The two counter tasks should never be in a "ready" * between all three tasks. The two counter tasks should never be in a "ready"
* state at the same time. The controller task runs at the same priority as * state at the same time. The controller task runs at the same priority as
* the continuous count task, and at a lower priority than the limited count * the continuous count task, and at a lower priority than the limited count
* task. * task.
* *
* One counter task loops indefinitely, incrementing the shared count variable * One counter task loops indefinitely, incrementing the shared count variable
* on each iteration. To ensure it has exclusive access to the variable it * on each iteration. To ensure it has exclusive access to the variable it
* raises it's priority above that of the controller task before each * raises it's priority above that of the controller task before each
* increment, lowering it again to it's original priority before starting the * increment, lowering it again to it's original priority before starting the
* next iteration. * next iteration.
* *
* The other counter task increments the shared count variable on each * The other counter task increments the shared count variable on each
* iteration of it's loop until the count has reached a limit of 0xff - at * iteration of it's loop until the count has reached a limit of 0xff - at
* which point it suspends itself. It will not start a new loop until the * which point it suspends itself. It will not start a new loop until the
* controller task has made it "ready" again by calling vTaskResume (). * controller task has made it "ready" again by calling vTaskResume ().
* This second counter task operates at a higher priority than controller * This second counter task operates at a higher priority than controller
* task so does not need to worry about mutual exclusion of the counter * task so does not need to worry about mutual exclusion of the counter
* variable. * variable.
* *
* The controller task is in two sections. The first section controls and * The controller task is in two sections. The first section controls and
* monitors the continuous count task. When this section is operational the * monitors the continuous count task. When this section is operational the
* limited count task is suspended. Likewise, the second section controls * limited count task is suspended. Likewise, the second section controls
* and monitors the limited count task. When this section is operational the * and monitors the limited count task. When this section is operational the
* continuous count task is suspended. * continuous count task is suspended.
* *
* In the first section the controller task first takes a copy of the shared * In the first section the controller task first takes a copy of the shared
@ -107,11 +107,11 @@
* the continuous count task will execute and increment the shared variable. * the continuous count task will execute and increment the shared variable.
* When the controller task wakes it checks that the continuous count task * When the controller task wakes it checks that the continuous count task
* has executed by comparing the copy of the shared variable with its current * has executed by comparing the copy of the shared variable with its current
* value. This time, to ensure mutual exclusion, the scheduler itself is * value. This time, to ensure mutual exclusion, the scheduler itself is
* suspended with a call to vTaskSuspendAll (). This is for demonstration * suspended with a call to vTaskSuspendAll (). This is for demonstration
* purposes only and is not a recommended technique due to its inefficiency. * purposes only and is not a recommended technique due to its inefficiency.
* *
* After a fixed number of iterations the controller task suspends the * After a fixed number of iterations the controller task suspends the
* continuous count task, and moves on to its second section. * continuous count task, and moves on to its second section.
* *
* At the start of the second section the shared variable is cleared to zero. * At the start of the second section the shared variable is cleared to zero.
@ -123,7 +123,7 @@
* a check on the shared variable to ensure everything is as expected. * a check on the shared variable to ensure everything is as expected.
* *
* *
* The second test consists of a couple of very simple tasks that post onto a * The second test consists of a couple of very simple tasks that post onto a
* queue while the scheduler is suspended. This test was added to test parts * queue while the scheduler is suspended. This test was added to test parts
* of the scheduler not exercised by the first test. * of the scheduler not exercised by the first test.
* *
@ -165,7 +165,7 @@ static portTASK_FUNCTION_PROTO( vQueueSendWhenSuspendedTask, pvParameters );
to the controller task to prevent them having to be file scope. */ to the controller task to prevent them having to be file scope. */
static xTaskHandle xContinousIncrementHandle, xLimitedIncrementHandle; static xTaskHandle xContinousIncrementHandle, xLimitedIncrementHandle;
/* The shared counter variable. This is passed in as a parameter to the two /* The shared counter variable. This is passed in as a parameter to the two
counter variables for demonstration purposes. */ counter variables for demonstration purposes. */
static unsigned long ulCounter; static unsigned long ulCounter;
@ -180,6 +180,11 @@ static volatile portBASE_TYPE xSuspendedQueueReceiveError = pdFALSE;
/* Queue used by the second test. */ /* Queue used by the second test. */
xQueueHandle xSuspendedTestQueue; xQueueHandle xSuspendedTestQueue;
/* The value the queue receive task expects to receive next. This is file
scope so xAreDynamicPriorityTasksStillRunning() can ensure it is still
incrementing. */
static unsigned long ulExpectedValue = ( unsigned long ) 0;
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* /*
* Start the three tasks as described at the top of the file. * Start the three tasks as described at the top of the file.
@ -190,10 +195,10 @@ void vStartDynamicPriorityTasks( void )
xSuspendedTestQueue = xQueueCreate( priSUSPENDED_QUEUE_LENGTH, sizeof( unsigned long ) ); xSuspendedTestQueue = xQueueCreate( priSUSPENDED_QUEUE_LENGTH, sizeof( unsigned long ) );
/* vQueueAddToRegistry() adds the queue to the queue registry, if one is /* vQueueAddToRegistry() adds the queue to the queue registry, if one is
in use. The queue registry is provided as a means for kernel aware 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 debuggers to locate queues and has no purpose if a kernel aware debugger
is not being used. The call to vQueueAddToRegistry() will be removed is not being used. The call to vQueueAddToRegistry() will be removed
by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is
defined to be less than 1. */ defined to be less than 1. */
vQueueAddToRegistry( xSuspendedTestQueue, ( signed char * ) "Suspended_Test_Queue" ); vQueueAddToRegistry( xSuspendedTestQueue, ( signed char * ) "Suspended_Test_Queue" );
@ -207,7 +212,7 @@ void vStartDynamicPriorityTasks( void )
/* /*
* Just loops around incrementing the shared variable until the limit has been * Just loops around incrementing the shared variable until the limit has been
* reached. Once the limit has been reached it suspends itself. * reached. Once the limit has been reached it suspends itself.
*/ */
static portTASK_FUNCTION( vLimitedIncrementTask, pvParameters ) static portTASK_FUNCTION( vLimitedIncrementTask, pvParameters )
{ {
@ -224,12 +229,12 @@ unsigned long *pulCounter;
for( ;; ) for( ;; )
{ {
/* Just count up to a value then suspend. */ /* Just count up to a value then suspend. */
( *pulCounter )++; ( *pulCounter )++;
if( *pulCounter >= priMAX_COUNT ) if( *pulCounter >= priMAX_COUNT )
{ {
vTaskSuspend( NULL ); vTaskSuspend( NULL );
} }
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -247,7 +252,7 @@ unsigned portBASE_TYPE uxOurPriority;
the task. */ the task. */
pulCounter = ( unsigned long * ) pvParameters; pulCounter = ( unsigned long * ) pvParameters;
/* Query our priority so we can raise it when exclusive access to the /* Query our priority so we can raise it when exclusive access to the
shared variable is required. */ shared variable is required. */
uxOurPriority = uxTaskPriorityGet( NULL ); uxOurPriority = uxTaskPriorityGet( NULL );
@ -256,7 +261,7 @@ unsigned portBASE_TYPE uxOurPriority;
/* Raise our priority above the controller task to ensure a context /* Raise our priority above the controller task to ensure a context
switch does not occur while we are accessing this variable. */ switch does not occur while we are accessing this variable. */
vTaskPrioritySet( NULL, uxOurPriority + 1 ); vTaskPrioritySet( NULL, uxOurPriority + 1 );
( *pulCounter )++; ( *pulCounter )++;
vTaskPrioritySet( NULL, uxOurPriority ); vTaskPrioritySet( NULL, uxOurPriority );
} }
} }
@ -289,11 +294,11 @@ short sError = pdFALSE;
vTaskSuspend( xContinousIncrementHandle ); vTaskSuspend( xContinousIncrementHandle );
ulLastCounter = ulCounter; ulLastCounter = ulCounter;
vTaskResume( xContinousIncrementHandle ); vTaskResume( xContinousIncrementHandle );
/* Now delay to ensure the other task has processor time. */ /* Now delay to ensure the other task has processor time. */
vTaskDelay( priSLEEP_TIME ); vTaskDelay( priSLEEP_TIME );
/* Check the shared variable again. This time to ensure mutual /* Check the shared variable again. This time to ensure mutual
exclusion the whole scheduler will be locked. This is just for exclusion the whole scheduler will be locked. This is just for
demo purposes! */ demo purposes! */
vTaskSuspendAll(); vTaskSuspendAll();
@ -370,7 +375,7 @@ static unsigned long ulValueToSend = ( unsigned long ) 0;
static portTASK_FUNCTION( vQueueReceiveWhenSuspendedTask, pvParameters ) static portTASK_FUNCTION( vQueueReceiveWhenSuspendedTask, pvParameters )
{ {
static unsigned long ulExpectedValue = ( unsigned long ) 0, ulReceivedValue; unsigned long ulReceivedValue;
portBASE_TYPE xGotValue; portBASE_TYPE xGotValue;
/* Just to stop warning messages. */ /* Just to stop warning messages. */
@ -380,7 +385,7 @@ portBASE_TYPE xGotValue;
{ {
do do
{ {
/* Suspending the scheduler here is fairly pointless and /* Suspending the scheduler here is fairly pointless and
undesirable for a normal application. It is done here purely undesirable for a normal application. It is done here purely
to test the scheduler. The inner xTaskResumeAll() should to test the scheduler. The inner xTaskResumeAll() should
never return pdTRUE as the scheduler is still locked by the never return pdTRUE as the scheduler is still locked by the
@ -391,7 +396,7 @@ portBASE_TYPE xGotValue;
{ {
xGotValue = xQueueReceive( xSuspendedTestQueue, ( void * ) &ulReceivedValue, priNO_BLOCK ); xGotValue = xQueueReceive( xSuspendedTestQueue, ( void * ) &ulReceivedValue, priNO_BLOCK );
} }
if( xTaskResumeAll() ) if( xTaskResumeAll() != pdFALSE )
{ {
xSuspendedQueueReceiveError = pdTRUE; xSuspendedQueueReceiveError = pdTRUE;
} }
@ -411,7 +416,13 @@ portBASE_TYPE xGotValue;
xSuspendedQueueReceiveError = pdTRUE; xSuspendedQueueReceiveError = pdTRUE;
} }
++ulExpectedValue; if( xSuspendedQueueReceiveError != pdTRUE )
{
/* Only increment the variable if an error has not occurred. This
allows xAreDynamicPriorityTasksStillRunning() to check for stalled
tasks as well as explicit errors. */
++ulExpectedValue;
}
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -419,9 +430,10 @@ portBASE_TYPE xGotValue;
/* Called to check that all the created tasks are still running without error. */ /* Called to check that all the created tasks are still running without error. */
portBASE_TYPE xAreDynamicPriorityTasksStillRunning( void ) portBASE_TYPE xAreDynamicPriorityTasksStillRunning( void )
{ {
/* Keep a history of the check variables so we know if it has been incremented /* Keep a history of the check variables so we know if it has been incremented
since the last call. */ since the last call. */
static unsigned short usLastTaskCheck = ( unsigned short ) 0; static unsigned short usLastTaskCheck = ( unsigned short ) 0;
static unsigned long ulLastExpectedValue = ( unsigned long ) 0U;
portBASE_TYPE xReturn = pdTRUE; portBASE_TYPE xReturn = pdTRUE;
/* Check the tasks are still running by ensuring the check variable /* Check the tasks are still running by ensuring the check variable
@ -433,6 +445,13 @@ portBASE_TYPE xReturn = pdTRUE;
xReturn = pdFALSE; xReturn = pdFALSE;
} }
if( ulExpectedValue == ulLastExpectedValue )
{
/* The value being received by the queue receive task has not
incremented so an error exists. */
xReturn = pdFALSE;
}
if( xSuspendedQueueSendError == pdTRUE ) if( xSuspendedQueueSendError == pdTRUE )
{ {
xReturn = pdFALSE; xReturn = pdFALSE;
@ -444,5 +463,7 @@ portBASE_TYPE xReturn = pdTRUE;
} }
usLastTaskCheck = usCheckVariable; usLastTaskCheck = usCheckVariable;
ulLastExpectedValue = ulExpectedValue;
return xReturn; return xReturn;
} }

126
FreeRTOS/Demo/Common/Minimal/flop.c
View file

@ -56,33 +56,33 @@
*************************************************************************** ***************************************************************************
http://www.FreeRTOS.org - Documentation, books, training, latest versions, http://www.FreeRTOS.org - Documentation, books, training, latest versions,
license and Real Time Engineers Ltd. contact details. license and Real Time Engineers Ltd. contact details.
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products, http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
including FreeRTOS+Trace - an indispensable productivity tool, and our new including FreeRTOS+Trace - an indispensable productivity tool, and our new
fully thread aware and reentrant UDP/IP stack. fully thread aware and reentrant UDP/IP stack.
http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High
Integrity Systems, who sell the code with commercial support, Integrity Systems, who sell the code with commercial support,
indemnification and middleware, under the OpenRTOS brand. indemnification and middleware, under the OpenRTOS brand.
http://www.SafeRTOS.com - High Integrity Systems also provide a safety http://www.SafeRTOS.com - High Integrity Systems also provide a safety
engineered and independently SIL3 certified version for use in safety and engineered and independently SIL3 certified version for use in safety and
mission critical applications that require provable dependability. mission critical applications that require provable dependability.
*/ */
/* /*
* Creates eight tasks, each of which loops continuously performing an (emulated) * Creates eight tasks, each of which loops continuously performing a floating
* floating point calculation. * point calculation.
* *
* All the tasks run at the idle priority and never block or yield. This causes * All the tasks run at the idle priority and never block or yield. This causes
* all eight tasks to time slice with the idle task. Running at the idle priority * all eight tasks to time slice with the idle task. Running at the idle
* means that these tasks will get pre-empted any time another task is ready to run * priority means that these tasks will get pre-empted any time another task is
* or a time slice occurs. More often than not the pre-emption will occur mid * ready to run or a time slice occurs. More often than not the pre-emption
* calculation, creating a good test of the schedulers context switch mechanism - a * will occur mid calculation, creating a good test of the schedulers context
* calculation producing an unexpected result could be a symptom of a corruption in * switch mechanism - a calculation producing an unexpected result could be a
* the context of a task. * symptom of a corruption in the context of a task.
*/ */
#include <stdlib.h> #include <stdlib.h>
@ -96,18 +96,17 @@
#include "flop.h" #include "flop.h"
#define mathSTACK_SIZE configMINIMAL_STACK_SIZE #define mathSTACK_SIZE configMINIMAL_STACK_SIZE
#define mathNUMBER_OF_TASKS ( 8 ) #define mathNUMBER_OF_TASKS ( 4 )
/* Four tasks, each of which performs a different floating point calculation. /* Four tasks, each of which performs a different floating point calculation.
Each of the four is created twice. */ Each of the four is created twice. */
static portTASK_FUNCTION_PROTO( vCompetingMathTask1, pvParameters ); static portTASK_FUNCTION_PROTO( vCompetingMathTask1, pvParameters );
static portTASK_FUNCTION_PROTO( vCompetingMathTask2, pvParameters ); static portTASK_FUNCTION_PROTO( vCompetingMathTask2, pvParameters );
static portTASK_FUNCTION_PROTO( vCompetingMathTask3, pvParameters ); static portTASK_FUNCTION_PROTO( vCompetingMathTask3, pvParameters );
static portTASK_FUNCTION_PROTO( vCompetingMathTask4, pvParameters ); static portTASK_FUNCTION_PROTO( vCompetingMathTask4, pvParameters );
/* These variables are used to check that all the tasks are still running. If a /* These variables are used to check that all the tasks are still running. If a
task gets a calculation wrong it will task gets a calculation wrong it will stop setting its check variable. */
stop incrementing its check variable. */
static volatile unsigned short usTaskCheck[ mathNUMBER_OF_TASKS ] = { ( unsigned short ) 0 }; static volatile unsigned short usTaskCheck[ mathNUMBER_OF_TASKS ] = { ( unsigned short ) 0 };
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -118,10 +117,6 @@ void vStartMathTasks( unsigned portBASE_TYPE uxPriority )
xTaskCreate( vCompetingMathTask2, ( signed char * ) "Math2", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 1 ] ), 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( vCompetingMathTask3, ( signed char * ) "Math3", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 2 ] ), uxPriority, NULL );
xTaskCreate( vCompetingMathTask4, ( signed char * ) "Math4", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 3 ] ), 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 );
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -143,7 +138,7 @@ short sError = pdFALSE;
dAnswer = ( d1 + d2 ) * d3; dAnswer = ( d1 + d2 ) * d3;
/* The variable this task increments to show it is still running is passed in /* The variable this task increments to show it is still running is passed in
as the parameter. */ as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters; pusTaskCheckVariable = ( unsigned short * ) pvParameters;
@ -160,7 +155,7 @@ short sError = pdFALSE;
taskYIELD(); taskYIELD();
#endif #endif
/* If the calculation does not match the expected constant, stop the /* If the calculation does not match the expected constant, stop the
increment of the check variable. */ increment of the check variable. */
if( fabs( d4 - dAnswer ) > 0.001 ) if( fabs( d4 - dAnswer ) > 0.001 )
{ {
@ -169,9 +164,10 @@ short sError = pdFALSE;
if( sError == pdFALSE ) if( sError == pdFALSE )
{ {
/* If the calculation has always been correct, increment the check /* If the calculation has always been correct then set set the check
variable so we know this task is still running okay. */ variable. The check variable will get set to pdFALSE each time
( *pusTaskCheckVariable )++; xAreMathsTaskStillRunning() is executed. */
( *pusTaskCheckVariable ) = pdTRUE;
} }
#if configUSE_PREEMPTION == 0 #if configUSE_PREEMPTION == 0
@ -201,7 +197,7 @@ short sError = pdFALSE;
dAnswer = ( d1 / d2 ) * d3; dAnswer = ( d1 / d2 ) * d3;
/* The variable this task increments to show it is still running is passed in /* The variable this task increments to show it is still running is passed in
as the parameter. */ as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters; pusTaskCheckVariable = ( unsigned short * ) pvParameters;
@ -217,8 +213,8 @@ short sError = pdFALSE;
#if configUSE_PREEMPTION == 0 #if configUSE_PREEMPTION == 0
taskYIELD(); taskYIELD();
#endif #endif
/* If the calculation does not match the expected constant, stop the /* If the calculation does not match the expected constant, stop the
increment of the check variable. */ increment of the check variable. */
if( fabs( d4 - dAnswer ) > 0.001 ) if( fabs( d4 - dAnswer ) > 0.001 )
{ {
@ -227,10 +223,10 @@ short sError = pdFALSE;
if( sError == pdFALSE ) if( sError == pdFALSE )
{ {
/* If the calculation has always been correct, increment the check /* If the calculation has always been correct then set set the check
variable so we know variable. The check variable will get set to pdFALSE each time
this task is still running okay. */ xAreMathsTaskStillRunning() is executed. */
( *pusTaskCheckVariable )++; ( *pusTaskCheckVariable ) = pdTRUE;
} }
#if configUSE_PREEMPTION == 0 #if configUSE_PREEMPTION == 0
@ -253,14 +249,14 @@ short sError = pdFALSE;
floating point instructions are executed. */ floating point instructions are executed. */
portTASK_USES_FLOATING_POINT(); portTASK_USES_FLOATING_POINT();
/* The variable this task increments to show it is still running is passed in /* The variable this task increments to show it is still running is passed in
as the parameter. */ as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters; pusTaskCheckVariable = ( unsigned short * ) pvParameters;
pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) ); pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );
/* Keep filling an array, keeping a running total of the values placed in the /* 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 array. Then run through the array adding up all the values. If the two totals
do not match, stop the check variable from incrementing. */ do not match, stop the check variable from incrementing. */
for( ;; ) for( ;; )
{ {
@ -270,7 +266,7 @@ short sError = pdFALSE;
for( xPosition = 0; xPosition < xArraySize; xPosition++ ) for( xPosition = 0; xPosition < xArraySize; xPosition++ )
{ {
pdArray[ xPosition ] = ( portDOUBLE ) xPosition + 5.5; pdArray[ xPosition ] = ( portDOUBLE ) xPosition + 5.5;
dTotal1 += ( portDOUBLE ) xPosition + 5.5; dTotal1 += ( portDOUBLE ) xPosition + 5.5;
} }
#if configUSE_PREEMPTION == 0 #if configUSE_PREEMPTION == 0
@ -294,9 +290,10 @@ short sError = pdFALSE;
if( sError == pdFALSE ) if( sError == pdFALSE )
{ {
/* If the calculation has always been correct, increment the check /* If the calculation has always been correct then set set the check
variable so we know this task is still running okay. */ variable. The check variable will get set to pdFALSE each time
( *pusTaskCheckVariable )++; xAreMathsTaskStillRunning() is executed. */
( *pusTaskCheckVariable ) = pdTRUE;
} }
} }
} }
@ -315,14 +312,14 @@ short sError = pdFALSE;
floating point instructions are executed. */ floating point instructions are executed. */
portTASK_USES_FLOATING_POINT(); portTASK_USES_FLOATING_POINT();
/* The variable this task increments to show it is still running is passed in /* The variable this task increments to show it is still running is passed in
as the parameter. */ as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters; pusTaskCheckVariable = ( unsigned short * ) pvParameters;
pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) ); pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );
/* Keep filling an array, keeping a running total of the values placed in the /* 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 array. Then run through the array adding up all the values. If the two totals
do not match, stop the check variable from incrementing. */ do not match, stop the check variable from incrementing. */
for( ;; ) for( ;; )
{ {
@ -332,7 +329,7 @@ short sError = pdFALSE;
for( xPosition = 0; xPosition < xArraySize; xPosition++ ) for( xPosition = 0; xPosition < xArraySize; xPosition++ )
{ {
pdArray[ xPosition ] = ( portDOUBLE ) xPosition * 12.123; pdArray[ xPosition ] = ( portDOUBLE ) xPosition * 12.123;
dTotal1 += ( portDOUBLE ) xPosition * 12.123; dTotal1 += ( portDOUBLE ) xPosition * 12.123;
} }
#if configUSE_PREEMPTION == 0 #if configUSE_PREEMPTION == 0
@ -356,35 +353,38 @@ short sError = pdFALSE;
if( sError == pdFALSE ) if( sError == pdFALSE )
{ {
/* If the calculation has always been correct, increment the check /* If the calculation has always been correct then set set the check
variable so we know this task is still running okay. */ variable. The check variable will get set to pdFALSE each time
( *pusTaskCheckVariable )++; xAreMathsTaskStillRunning() is executed. */
( *pusTaskCheckVariable ) = pdTRUE;
} }
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* This is called to check that all the created tasks are still running. */ /* This is called to check that all the created tasks are still running. */
portBASE_TYPE xAreMathsTaskStillRunning( void ) portBASE_TYPE xAreMathsTaskStillRunning( void )
{ {
/* Keep a history of the check variables so we know if they have been incremented portBASE_TYPE xReturn = pdPASS, xTask;
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 /* Check the maths tasks are still running by ensuring their check variables
are still incrementing. */ have been set to pdPASS. */
for( xTask = 0; xTask < mathNUMBER_OF_TASKS; xTask++ ) for( xTask = 0; xTask < mathNUMBER_OF_TASKS; xTask++ )
{ {
if( usTaskCheck[ xTask ] == usLastTaskCheck[ xTask ] ) if( usTaskCheck[ xTask ] != pdTRUE )
{ {
/* The check has not incremented so an error exists. */ /* The check has not been set so the associated task has either
xReturn = pdFALSE; stalled or detected an error. */
xReturn = pdFAIL;
}
else
{
/* Reset the variable so it can be checked again the next time this
function is executed. */
usTaskCheck[ xTask ] = pdFALSE;
} }
usLastTaskCheck[ xTask ] = usTaskCheck[ xTask ];
} }
return xReturn; return xReturn;
} }