/*\r
- FreeRTOS V8.0.0:rc1 - Copyright (C) 2014 Real Time Engineers Ltd.\r
+ FreeRTOS V8.1.1 - Copyright (C) 2014 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
the terms of the GNU General Public License (version 2) as published by the\r
Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
\r
- >>! NOTE: The modification to the GPL is included to allow you to distribute\r
- >>! a combined work that includes FreeRTOS without being obliged to provide\r
- >>! the source code for proprietary components outside of the FreeRTOS\r
- >>! kernel.\r
+ >>! NOTE: The modification to the GPL is included to allow you to !<<\r
+ >>! distribute a combined work that includes FreeRTOS without being !<<\r
+ >>! obliged to provide the source code for proprietary components !<<\r
+ >>! outside of the FreeRTOS kernel. !<<\r
\r
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
#define genqMUTEX_MEDIUM_PRIORITY ( tskIDLE_PRIORITY + 2 )\r
#define genqMUTEX_HIGH_PRIORITY ( tskIDLE_PRIORITY + 3 )\r
\r
+#define genqINTERRUPT_MUTEX_GIVE_PERIOD_MS ( 100 )\r
/*-----------------------------------------------------------*/\r
\r
/*\r
static void prvMediumPriorityMutexTask( void *pvParameters );\r
static void prvHighPriorityMutexTask( void *pvParameters );\r
\r
+/*\r
+ * Exercises the priority inheritance when a task takes two mutexes, returning\r
+ * them in a different order to which they were taken.\r
+ */\r
+static void prvTakeTwoMutexesReturnInDifferentOrder( SemaphoreHandle_t xMutex, SemaphoreHandle_t xLocalMutex );\r
+\r
+/*\r
+ * Exercises the priority inheritance when a task takes two mutexes, returning\r
+ * them in the same order in which they were taken.\r
+ */\r
+static void prvTakeTwoMutexesReturnInSameOrder( SemaphoreHandle_t xMutex, SemaphoreHandle_t xLocalMutex );\r
+\r
+/*\r
+ * Task that receives an a mutex that is given from an interrupt - although\r
+ * generally mutexes should not be used given in interrupts (and definitely\r
+ * never taken in an interrupt) there are some circumstances when it may be\r
+ * desirable. NOTE: This function is not declared static to prevent compiler\r
+ * warnings being generated in demos where the function is declared but not\r
+ * used.\r
+ */\r
+void vInterruptMutexTask( void *pvParameters );\r
+\r
/*-----------------------------------------------------------*/\r
\r
/* Flag that will be latched to pdTRUE should any unexpected behaviour be\r
detected in any of the tasks. */\r
-static volatile portBASE_TYPE xErrorDetected = pdFALSE;\r
+static volatile BaseType_t xErrorDetected = pdFALSE;\r
\r
/* Counters that are incremented on each cycle of a test. This is used to\r
detect a stalled task - a test that is no longer running. */\r
-static volatile unsigned long ulLoopCounter = 0;\r
-static volatile unsigned long ulLoopCounter2 = 0;\r
+static volatile uint32_t ulLoopCounter = 0;\r
+static volatile uint32_t ulLoopCounter2 = 0;\r
\r
/* The variable that is guarded by the mutex in the mutex demo tasks. */\r
-static volatile unsigned long ulGuardedVariable = 0;\r
+static volatile uint32_t ulGuardedVariable = 0;\r
\r
/* Handles used in the mutext test to suspend and resume the high and medium\r
priority mutex test tasks. */\r
static TaskHandle_t xHighPriorityMutexTask, xMediumPriorityMutexTask;\r
\r
+/* A mutex which is given from an interrupt - although generally mutexes should\r
+not be used given in interrupts (and definitely never taken in an interrupt)\r
+there are some circumstances when it may be desirable. */\r
+static SemaphoreHandle_t xISRMutex = NULL;\r
+\r
/*-----------------------------------------------------------*/\r
\r
-void vStartGenericQueueTasks( unsigned portBASE_TYPE uxPriority )\r
+void vStartGenericQueueTasks( UBaseType_t uxPriority )\r
{\r
QueueHandle_t xQueue;\r
SemaphoreHandle_t xMutex;\r
\r
+ xISRMutex = xSemaphoreCreateMutex();\r
+ configASSERT( xISRMutex );\r
+\r
/* Create the queue that we are going to use for the\r
prvSendFrontAndBackTest demo. */\r
- xQueue = xQueueCreate( genqQUEUE_LENGTH, sizeof( unsigned long ) );\r
+ xQueue = xQueueCreate( genqQUEUE_LENGTH, sizeof( uint32_t ) );\r
\r
/* vQueueAddToRegistry() adds the queue to the queue registry, if one is\r
in use. The queue registry is provided as a means for kernel aware\r
xTaskCreate( prvLowPriorityMutexTask, "MuLow", configMINIMAL_STACK_SIZE, ( void * ) xMutex, genqMUTEX_LOW_PRIORITY, NULL );\r
xTaskCreate( prvMediumPriorityMutexTask, "MuMed", configMINIMAL_STACK_SIZE, NULL, genqMUTEX_MEDIUM_PRIORITY, &xMediumPriorityMutexTask );\r
xTaskCreate( prvHighPriorityMutexTask, "MuHigh", configMINIMAL_STACK_SIZE, ( void * ) xMutex, genqMUTEX_HIGH_PRIORITY, &xHighPriorityMutexTask );\r
+\r
+ /* Only when the windows simulator is being used - create the task that\r
+ receives a mutex from an interrupt. */\r
+ #ifdef _WINDOWS_\r
+ {\r
+ xTaskCreate( vInterruptMutexTask, "IntMu", configMINIMAL_STACK_SIZE, NULL, genqMUTEX_MEDIUM_PRIORITY, NULL );\r
+ }\r
+ #endif /* __WINDOWS__ */\r
}\r
/*-----------------------------------------------------------*/\r
\r
static void prvSendFrontAndBackTest( void *pvParameters )\r
{\r
-unsigned long ulData, ulData2;\r
+uint32_t ulData, ulData2;\r
QueueHandle_t xQueue;\r
\r
#ifdef USE_STDIO\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static void prvLowPriorityMutexTask( void *pvParameters )\r
+static void prvTakeTwoMutexesReturnInDifferentOrder( SemaphoreHandle_t xMutex, SemaphoreHandle_t xLocalMutex )\r
{\r
-SemaphoreHandle_t xMutex = ( SemaphoreHandle_t ) pvParameters;\r
+ /* Take the mutex. It should be available now. */\r
+ if( xSemaphoreTake( xMutex, genqNO_BLOCK ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- #ifdef USE_STDIO\r
- void vPrintDisplayMessage( const char * const * ppcMessageToSend );\r
+ /* Set the guarded variable to a known start value. */\r
+ ulGuardedVariable = 0;\r
\r
- const char * const pcTaskStartMsg = "Mutex with priority inheritance test started.\r\n";\r
+ /* This task's priority should be as per that assigned when the task was\r
+ created. */\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_LOW_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* Queue a message for printing to say the task has started. */\r
- vPrintDisplayMessage( &pcTaskStartMsg );\r
+ /* Now unsuspend the high priority task. This will attempt to take the\r
+ mutex, and block when it finds it cannot obtain it. */\r
+ vTaskResume( xHighPriorityMutexTask );\r
+\r
+ #if configUSE_PREEMPTION == 0\r
+ taskYIELD();\r
#endif\r
\r
- for( ;; )\r
+ /* Ensure the task is reporting its priority as blocked and not\r
+ suspended (as it would have done in versions up to V7.5.3). */\r
+ #if( INCLUDE_eTaskGetState == 1 )\r
{\r
- /* Take the mutex. It should be available now. */\r
- if( xSemaphoreTake( xMutex, genqNO_BLOCK ) != pdPASS )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
+ configASSERT( eTaskGetState( xHighPriorityMutexTask ) == eBlocked );\r
+ }\r
+ #endif /* INCLUDE_eTaskGetState */\r
\r
- /* Set our guarded variable to a known start value. */\r
- ulGuardedVariable = 0;\r
+ /* The priority of the high priority task should now have been inherited\r
+ as by now it will have attempted to get the mutex. */\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* Our priority should be as per that assigned when the task was\r
- created. */\r
- if( uxTaskPriorityGet( NULL ) != genqMUTEX_LOW_PRIORITY )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
+ /* Attempt to set the priority of this task to the test priority -\r
+ between the idle priority and the medium/high test priorities, but the\r
+ actual priority should remain at the high priority. */\r
+ vTaskPrioritySet( NULL, genqMUTEX_TEST_PRIORITY );\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* Now unsuspend the high priority task. This will attempt to take the\r
- mutex, and block when it finds it cannot obtain it. */\r
- vTaskResume( xHighPriorityMutexTask );\r
+ /* Now unsuspend the medium priority task. This should not run as the\r
+ inherited priority of this task is above that of the medium priority\r
+ task. */\r
+ vTaskResume( xMediumPriorityMutexTask );\r
\r
- #if configUSE_PREEMPTION == 0\r
- taskYIELD();\r
- #endif\r
+ /* If the medium priority task did run then it will have incremented the\r
+ guarded variable. */\r
+ if( ulGuardedVariable != 0 )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* Ensure the task is reporting it priority as blocked and not\r
- suspended (as it would have done in versions up to V7.5.3). */\r
- #if( INCLUDE_eTaskGetState == 1 )\r
- {\r
- configASSERT( eTaskGetState( xHighPriorityMutexTask ) == eBlocked );\r
- }\r
- #endif /* INCLUDE_eTaskGetState */\r
+ /* Take the local mutex too, so two mutexes are now held. */\r
+ if( xSemaphoreTake( xLocalMutex, genqNO_BLOCK ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* We should now have inherited the prioritoy of the high priority task,\r
- as by now it will have attempted to get the mutex. */\r
- if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
+ /* When the semaphore is given back the priority of this task should not\r
+ yet be disinherited because the local mutex is still held. This is a\r
+ simplification to allow FreeRTOS to be integrated with middleware that\r
+ attempts to hold multiple mutexes without bloating the code with complex\r
+ algorithms. It is possible that the high priority mutex task will\r
+ execute as it shares a priority with this task. */\r
+ if( xSemaphoreGive( xMutex ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* We can attempt to set our priority to the test priority - between the\r
- idle priority and the medium/high test priorities, but our actual\r
- prioroity should remain at the high priority. */\r
- vTaskPrioritySet( NULL, genqMUTEX_TEST_PRIORITY );\r
- if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
+ #if configUSE_PREEMPTION == 0\r
+ taskYIELD();\r
+ #endif\r
\r
- /* Now unsuspend the medium priority task. This should not run as our\r
- inherited priority is above that of the medium priority task. */\r
- vTaskResume( xMediumPriorityMutexTask );\r
+ /* The guarded variable is only incremented by the medium priority task,\r
+ which still should not have executed as this task should remain at the\r
+ higher priority, ensure this is the case. */\r
+ if( ulGuardedVariable != 0 )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* If the did run then it will have incremented our guarded variable. */\r
- if( ulGuardedVariable != 0 )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
\r
- /* When we give back the semaphore our priority should be disinherited\r
- back to the priority to which we attempted to set ourselves. This means\r
- that when the high priority task next blocks, the medium priority task\r
- should execute and increment the guarded variable. When we next run\r
- both the high and medium priority tasks will have been suspended again. */\r
- if( xSemaphoreGive( xMutex ) != pdPASS )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
+ /* Now also give back the local mutex, taking the held count back to 0.\r
+ This time the priority of this task should be disinherited back to the\r
+ priority to which it was set while the mutex was held. This means\r
+ the medium priority task should execute and increment the guarded\r
+ variable. When this task next runs both the high and medium priority\r
+ tasks will have been suspended again. */\r
+ if( xSemaphoreGive( xLocalMutex ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ #if configUSE_PREEMPTION == 0\r
+ taskYIELD();\r
+ #endif\r
+\r
+ /* Check the guarded variable did indeed increment... */\r
+ if( ulGuardedVariable != 1 )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* ... and that the priority of this task has been disinherited to\r
+ genqMUTEX_TEST_PRIORITY. */\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_TEST_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* Set the priority of this task back to its original value, ready for\r
+ the next loop around this test. */\r
+ vTaskPrioritySet( NULL, genqMUTEX_LOW_PRIORITY );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvTakeTwoMutexesReturnInSameOrder( SemaphoreHandle_t xMutex, SemaphoreHandle_t xLocalMutex )\r
+{\r
+ /* Take the mutex. It should be available now. */\r
+ if( xSemaphoreTake( xMutex, genqNO_BLOCK ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* Set the guarded variable to a known start value. */\r
+ ulGuardedVariable = 0;\r
+\r
+ /* This task's priority should be as per that assigned when the task was\r
+ created. */\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_LOW_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* Now unsuspend the high priority task. This will attempt to take the\r
+ mutex, and block when it finds it cannot obtain it. */\r
+ vTaskResume( xHighPriorityMutexTask );\r
+\r
+ #if configUSE_PREEMPTION == 0\r
+ taskYIELD();\r
+ #endif\r
+\r
+ /* Ensure the task is reporting its priority as blocked and not\r
+ suspended (as it would have done in versions up to V7.5.3). */\r
+ #if( INCLUDE_eTaskGetState == 1 )\r
+ {\r
+ configASSERT( eTaskGetState( xHighPriorityMutexTask ) == eBlocked );\r
+ }\r
+ #endif /* INCLUDE_eTaskGetState */\r
+\r
+ /* The priority of the high priority task should now have been inherited\r
+ as by now it will have attempted to get the mutex. */\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* Now unsuspend the medium priority task. This should not run as the\r
+ inherited priority of this task is above that of the medium priority\r
+ task. */\r
+ vTaskResume( xMediumPriorityMutexTask );\r
+\r
+ /* If the medium priority task did run then it will have incremented the\r
+ guarded variable. */\r
+ if( ulGuardedVariable != 0 )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* Take the local mutex too, so two mutexes are now held. */\r
+ if( xSemaphoreTake( xLocalMutex, genqNO_BLOCK ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* When the local semaphore is given back the priority of this task should\r
+ not yet be disinherited because the shared mutex is still held. This is a\r
+ simplification to allow FreeRTOS to be integrated with middleware that\r
+ attempts to hold multiple mutexes without bloating the code with complex\r
+ algorithms. It is possible that the high priority mutex task will\r
+ execute as it shares a priority with this task. */\r
+ if( xSemaphoreGive( xLocalMutex ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ #if configUSE_PREEMPTION == 0\r
+ taskYIELD();\r
+ #endif\r
+\r
+ /* The guarded variable is only incremented by the medium priority task,\r
+ which still should not have executed as this task should remain at the\r
+ higher priority, ensure this is the case. */\r
+ if( ulGuardedVariable != 0 )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_HIGH_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* Now also give back the shared mutex, taking the held count back to 0.\r
+ This time the priority of this task should be disinherited back to the\r
+ priority at which it was created. This means the medium priority task\r
+ should execute and increment the guarded variable. When this task next runs\r
+ both the high and medium priority tasks will have been suspended again. */\r
+ if( xSemaphoreGive( xMutex ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ #if configUSE_PREEMPTION == 0\r
+ taskYIELD();\r
+ #endif\r
+\r
+ /* Check the guarded variable did indeed increment... */\r
+ if( ulGuardedVariable != 1 )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+\r
+ /* ... and that the priority of this task has been disinherited to\r
+ genqMUTEX_LOW_PRIORITY. */\r
+ if( uxTaskPriorityGet( NULL ) != genqMUTEX_LOW_PRIORITY )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvLowPriorityMutexTask( void *pvParameters )\r
+{\r
+SemaphoreHandle_t xMutex = ( SemaphoreHandle_t ) pvParameters, xLocalMutex;\r
+\r
+ #ifdef USE_STDIO\r
+ void vPrintDisplayMessage( const char * const * ppcMessageToSend );\r
+\r
+ const char * const pcTaskStartMsg = "Mutex with priority inheritance test started.\r\n";\r
+\r
+ /* Queue a message for printing to say the task has started. */\r
+ vPrintDisplayMessage( &pcTaskStartMsg );\r
+ #endif\r
+\r
+ /* The local mutex is used to check the 'mutexs held' count. */\r
+ xLocalMutex = xSemaphoreCreateMutex();\r
+ configASSERT( xLocalMutex );\r
+\r
+ for( ;; )\r
+ {\r
+ /* The first tests exercise the priority inheritance when two mutexes\r
+ are taken then returned in a different order to which they were\r
+ taken. */\r
+ prvTakeTwoMutexesReturnInDifferentOrder( xMutex, xLocalMutex );\r
+\r
+ /* Just to show this task is still running. */\r
+ ulLoopCounter2++;\r
\r
#if configUSE_PREEMPTION == 0\r
taskYIELD();\r
#endif\r
\r
- /* Check that the guarded variable did indeed increment... */\r
- if( ulGuardedVariable != 1 )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
+ /* The second tests exercise the priority inheritance when two mutexes\r
+ are taken then returned in the same order in which they were taken. */\r
+ prvTakeTwoMutexesReturnInSameOrder( xMutex, xLocalMutex );\r
\r
- /* ... and that our priority has been disinherited to\r
- genqMUTEX_TEST_PRIORITY. */\r
- if( uxTaskPriorityGet( NULL ) != genqMUTEX_TEST_PRIORITY )\r
- {\r
- xErrorDetected = pdTRUE;\r
- }\r
-\r
- /* Set our priority back to our original priority ready for the next\r
- loop around this test. */\r
- vTaskPrioritySet( NULL, genqMUTEX_LOW_PRIORITY );\r
-\r
- /* Just to show we are still running. */\r
+ /* Just to show this task is still running. */\r
ulLoopCounter2++;\r
\r
#if configUSE_PREEMPTION == 0\r
xErrorDetected = pdTRUE;\r
}\r
\r
- /* When we eventually obtain the mutex we just give it back then\r
- return to suspend ready for the next test. */\r
+ /* When the mutex is eventually obtained it is just given back before\r
+ returning to suspend ready for the next cycle. */\r
if( xSemaphoreGive( xMutex ) != pdPASS )\r
{\r
xErrorDetected = pdTRUE;\r
}\r
/*-----------------------------------------------------------*/\r
\r
+/* NOTE: This function is not declared static to prevent compiler warnings in\r
+demos where the function is declared but not used. */\r
+void vInterruptMutexTask( void *pvParameters )\r
+{\r
+const TickType_t xInterruptGivePeriod = pdMS_TO_TICKS( genqINTERRUPT_MUTEX_GIVE_PERIOD_MS );\r
+volatile uint32_t ulLoops = 0;\r
+\r
+ /* Just to avoid compiler warnings. */\r
+ ( void ) pvParameters;\r
+\r
+ for( ;; )\r
+ {\r
+ /* Has to wait longer than the time between gives to make sure it\r
+ should definitely have received the mutex. */\r
+ if( xSemaphoreTake( xISRMutex, ( xInterruptGivePeriod * 2 ) ) != pdPASS )\r
+ {\r
+ xErrorDetected = pdTRUE;\r
+ }\r
+ else\r
+ {\r
+ ulLoops++;\r
+ }\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+void vMutexISRInteractionTest( void )\r
+{\r
+static TickType_t xLastGiveTime = 0;\r
+TickType_t xTimeNow;\r
+\r
+ xTimeNow = xTaskGetTickCountFromISR();\r
+ if( ( xTimeNow - xLastGiveTime ) >= pdMS_TO_TICKS( genqINTERRUPT_MUTEX_GIVE_PERIOD_MS ) )\r
+ {\r
+ configASSERT( xISRMutex );\r
+ xSemaphoreGiveFromISR( xISRMutex, NULL );\r
+ xLastGiveTime = xTimeNow;\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
/* This is called to check that all the created tasks are still running. */\r
-portBASE_TYPE xAreGenericQueueTasksStillRunning( void )\r
+BaseType_t xAreGenericQueueTasksStillRunning( void )\r
{\r
-static unsigned long ulLastLoopCounter = 0, ulLastLoopCounter2 = 0;\r
+static uint32_t ulLastLoopCounter = 0, ulLastLoopCounter2 = 0;\r
\r
- /* If the demo task is still running then we expect the loopcounters to\r
+ /* If the demo task is still running then we expect the loop counters to\r
have incremented since this function was last called. */\r
if( ulLastLoopCounter == ulLoopCounter )\r
{\r
/* Errors detected in the task itself will have latched xErrorDetected\r
to true. */\r
\r
- return ( portBASE_TYPE ) !xErrorDetected;\r
+ return ( BaseType_t ) !xErrorDetected;\r
}\r
\r
\r