len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-04-20 05:21:59 -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

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

@ -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

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

@ -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.
@ -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. */
@ -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;
}
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -422,6 +433,7 @@ 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;
} }

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

@ -73,16 +73,16 @@
*/ */
/* /*
* 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,7 +96,7 @@
#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. */
@ -106,8 +106,7 @@ 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 );
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
@ -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
@ -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
@ -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;
} }
} }
} }
@ -356,9 +353,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;
} }
} }
} }
@ -367,22 +365,24 @@ short sError = pdFALSE;
/* 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;