void vApplicationTickHook( void ) { static xOLEDMessage xMessage = { "PASS" }; static unsigned long ulTicksSinceLastDisplay = 0; portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE; /* Called from every tick interrupt. Have enough ticks passed to make it time to perform our health status check again? */ ulTicksSinceLastDisplay++; if( ulTicksSinceLastDisplay >= mainCHECK_DELAY ) { ulTicksSinceLastDisplay = 0; /* Has an error been found in any task? */ if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN GEN Q"; } else if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN PEEK Q"; } else if( xAreBlockingQueuesStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN BLOCK Q"; } else if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN BLOCK TIME"; } else if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN SEMAPHORE"; } else if( xArePollingQueuesStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN POLL Q"; } else if( xIsCreateTaskStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN CREATE"; } else if( xAreIntegerMathsTaskStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN MATH"; } else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN REC MUTEX"; } else if( ulIdleError != pdFALSE ) { xMessage.pcMessage = "ERROR IN HOOK"; } else if( xAreIntQueueTasksStillRunning() != pdTRUE ) { xMessage.pcMessage = "ERROR IN INT QUEUE"; } /* Send the message to the OLED gatekeeper for display. */ xHigherPriorityTaskWoken = pdFALSE; xQueueSendFromISR( xOLEDQueue, &xMessage, &xHigherPriorityTaskWoken ); } }
static void prvCheckTask( void * pvParameters ) { portTickType xNextWakeTime, xPeriod = mainNO_ERROR_PERIOD; static volatile unsigned long ulErrorCode = 0UL; /* Just to remove the compiler warning. */ ( void ) pvParameters; /* Initialise xNextWakeTime prior to its first use. From this point on the value of the variable is handled automatically by the kernel. */ xNextWakeTime = xTaskGetTickCount(); for( ;; ) { /* Delay until it is time for this task to execute again. */ vTaskDelayUntil( &xNextWakeTime, xPeriod ); /* Check all the other tasks in the system - latch any reported errors into the ulErrorCode variable. */ if( xAreBlockingQueuesStillRunning() != pdTRUE ) { ulErrorCode |= 0x01UL; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x02UL; } if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x04UL; } if( xIsCreateTaskStillRunning() != pdTRUE ) { ulErrorCode |= 0x08UL; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x10UL; } if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x20UL; } if( xAreIntegerMathsTaskStillRunning() != pdTRUE ) { ulErrorCode |= 0x40UL; } if( xArePollingQueuesStillRunning() != pdTRUE ) { ulErrorCode |= 0x80UL; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x100UL; } if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x200UL; } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x400UL; } if( xAreComTestTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x800UL; } /* Reduce the block period and in so doing increase the frequency at which this task executes if any errors have been latched. The increased frequency causes the LED toggle rate to increase and so gives some visual feedback that an error has occurred. */ if( ulErrorCode != 0x00 ) { xPeriod = mainERROR_PERIOD; } /* Finally toggle the LED. */ vParTestToggleLED( LED_POWER ); } }
static void prvCheckTimerCallback( xTimerHandle xTimer ) { /* Check the standard demo tasks are running without error. Latch the latest reported error in the pcStatusMessage character pointer. */ if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: GenQueue"; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: QueuePeek\r\n"; } if( xAreBlockingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockQueue\r\n"; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockTime\r\n"; } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: SemTest\r\n"; } if( xIsCreateTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: Death\r\n"; } if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: RecMutex\r\n"; } if( xAreComTestTasksStillRunning() != pdPASS ) { pcStatusMessage = "Error: ComTest\r\n"; } if( xAreTimerDemoTasksStillRunning( ( mainCHECK_TIMER_PERIOD_MS ) ) != pdTRUE ) { pcStatusMessage = "Error: TimerDemo"; } if( xArePollingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: PollQueue"; } if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: CountSem"; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: DynamicPriority"; } /* Toggle the check LED to give an indication of the system status. If the LED toggles every mainCHECK_TIMER_PERIOD_MS milliseconds then everything is ok. A faster toggle indicates an error. */ vParTestToggleLED( mainCHECK_LED ); /* Have any errors been latch in pcStatusMessage? If so, shorten the period of the check timer to mainERROR_CHECK_TIMER_PERIOD_MS milliseconds. This will result in an increase in the rate at which mainCHECK_LED toggles. */ if( pcStatusMessage != NULL ) { /* This call to xTimerChangePeriod() uses a zero block time. Functions called from inside of a timer callback function must *never* attempt to block. */ xTimerChangePeriod( xCheckTimer, ( mainERROR_CHECK_TIMER_PERIOD_MS ), mainDONT_BLOCK ); } }
void vApplicationTickHook( void ) { static unsigned long ulCallCount = 0, ulErrorFound = pdFALSE; /* The rate at which LED D4 will toggle if an error has been found in one or more of the standard demo tasks. */ const unsigned long ulErrorFlashRate = 500 / portTICK_RATE_MS; /* The rate at which LED D4 will toggle if no errors have been found in any of the standard demo tasks. */ const unsigned long ulNoErrorCheckRate = 5000 / portTICK_RATE_MS; ulCallCount++; if( ulErrorFound != pdFALSE ) { /* We have already found an error, so flash the LED with the appropriate frequency. */ if( ulCallCount > ulErrorFlashRate ) { ulCallCount = 0; vParTestToggleLED( mainERROR_LED ); } } else { if( ulCallCount > ulNoErrorCheckRate ) { ulCallCount = 0; /* We have not yet found an error. Check all the demo tasks to ensure this is still the case. */ if( xAreBlockingQueuesStillRunning() != pdTRUE ) { ulErrorFound |= 0x01; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { ulErrorFound |= 0x02; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { ulErrorFound |= 0x04; } if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { ulErrorFound |= 0x08; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { ulErrorFound |= 0x10; } vParTestToggleLED( mainERROR_LED ); } } }
static void prvCheckOtherTasksAreStillRunning( void ) { static short sErrorHasOccurred = pdFALSE; static unsigned long long uxLastHookCallCount = 0, uxLastQueueSendCount = 0; if( prvCheckMathTasksAreStillRunning() != pdTRUE ) { vDisplayMessage( "Maths task count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreComTestTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Com test count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreBlockingQueuesStillRunning() != pdTRUE ) { vDisplayMessage( "Blocking queues count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreAltBlockingQueuesStillRunning() != pdTRUE ) { vDisplayMessage( "Alt blocking queues count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xArePollingQueuesStillRunning() != pdTRUE ) { vDisplayMessage( "Polling queue count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreAltPollingQueuesStillRunning() != pdTRUE ) { vDisplayMessage( "Alt polling queue count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xIsCreateTaskStillRunning() != pdTRUE ) { vDisplayMessage( "Incorrect number of tasks running!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Semaphore take count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Dynamic priority count unchanged!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreMultiEventTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in multi events tasks!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreFlashCoRoutinesStillRunning() != pdTRUE ) { vDisplayMessage( "Error in co-routine flash tasks!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreHookCoRoutinesStillRunning() != pdTRUE ) { vDisplayMessage( "Error in tick hook to co-routine communications!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in block time test tasks!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreAltBlockTimeTestTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in fast block time test tasks!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in generic queue test task!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreAltGenericQueueTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in fast generic queue test task!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in queue peek test task!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in counting semaphore demo task!\r\n" ); sErrorHasOccurred = pdTRUE; } if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { vDisplayMessage( "Error in recursive mutex tasks!\r\n" ); sErrorHasOccurred = pdTRUE; } /* The hook function associated with this task is called each time the task is switched in. We therefore expect the number of times the callback function has been executed to have increrment since the last time this function executed. */ if( uxCheckTaskHookCallCount <= uxLastHookCallCount ) { vDisplayMessage( "Error in task hook call count!\r\n" ); sErrorHasOccurred = pdTRUE; } else { uxLastHookCallCount = uxCheckTaskHookCallCount; } /* We would expect some queue sending to occur between calls of this function. */ if( uxQueueSendPassedCount <= uxLastQueueSendCount ) { vDisplayMessage( "Error in queue send hook call count!\r\n" ); sErrorHasOccurred = pdTRUE; } else { uxLastQueueSendCount = uxQueueSendPassedCount; } if( sErrorHasOccurred == pdFALSE ) { vDisplayMessage( "OK " ); } }
static void prvCheckTask( void *pvParameters ) { portTickType xDelayPeriod = mainNO_ERROR_DELAY, xLastWakeTime; unsigned portBASE_TYPE uxLEDToUse = 0; /* Ensure parameter is passed in correctly. */ if( pvParameters != mainCHECK_PARAMETER ) { xDelayPeriod = mainERROR_DELAY; } /* Initialise xLastWakeTime before it is used. After this point it is not written to directly. */ xLastWakeTime = xTaskGetTickCount(); /* Cycle for ever, delaying then checking all the other tasks are still operating without error. */ for( ;; ) { /* Wait until it is time to check all the other tasks again. */ vTaskDelayUntil( &xLastWakeTime, xDelayPeriod ); if( lRegTestStatus != pdPASS ) { xDelayPeriod = mainERROR_DELAY; } if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } if( xIsCreateTaskStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } /* The Fx3 runs more tasks, so more checks are performed. */ #ifdef __IAR_V850ES_Fx3__ { if( xAreComTestTasksStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } if( xArePollingQueuesStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } if( xAreBlockingQueuesStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { xDelayPeriod = mainERROR_DELAY; } /* The application board has more LEDs and uses the flash tasks so the check task instead uses LED3 as LED3 is still spare. */ uxLEDToUse = 3; } #endif /* Toggle the LED. The toggle rate will depend on whether or not an error has been found in any tasks. */ vParTestToggleLED( uxLEDToUse ); } }
static void prvCheckTask( void *pvParameters ) { static volatile unsigned long ulLastRegTest1CycleCount = 0UL, ulLastRegTest2CycleCount = 0UL; TickType_t xNextWakeTime, xCycleFrequency = mainNO_ERROR_CYCLE_TIME; extern void vSetupHighFrequencyTimer( void ); /* If this is being executed then the kernel has been started. Start the high frequency timer test as described at the top of this file. This is only included in the optimised build configuration - otherwise it takes up too much CPU time. */ #ifdef INCLUDE_HIGH_FREQUENCY_TIMER_TEST vSetupHighFrequencyTimer(); #endif /* Initialise xNextWakeTime - this only needs to be done once. */ xNextWakeTime = xTaskGetTickCount(); for( ;; ) { /* Place this task in the blocked state until it is time to run again. */ vTaskDelayUntil( &xNextWakeTime, xCycleFrequency ); /* Check the standard demo tasks are running without error. */ if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { /* Increase the rate at which this task cycles, which will increase the rate at which mainCHECK_LED flashes to give visual feedback that an error has occurred. */ pcStatusMessage = "Error: GenQueue"; xPrintf( pcStatusMessage ); } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: QueuePeek\r\n"; xPrintf( pcStatusMessage ); } if( xAreBlockingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockQueue\r\n"; xPrintf( pcStatusMessage ); } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockTime\r\n"; xPrintf( pcStatusMessage ); } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: SemTest\r\n"; xPrintf( pcStatusMessage ); } if( xArePollingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: PollQueue\r\n"; xPrintf( pcStatusMessage ); } if( xIsCreateTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: Death\r\n"; xPrintf( pcStatusMessage ); } if( xAreIntegerMathsTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: IntMath\r\n"; xPrintf( pcStatusMessage ); } if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: RecMutex\r\n"; xPrintf( pcStatusMessage ); } if( xAreIntQueueTasksStillRunning() != pdPASS ) { pcStatusMessage = "Error: IntQueue\r\n"; xPrintf( pcStatusMessage ); } if( xAreMathsTaskStillRunning() != pdPASS ) { pcStatusMessage = "Error: Flop\r\n"; xPrintf( pcStatusMessage ); } /* Check the reg test tasks are still cycling. They will stop incrementing their loop counters if they encounter an error. */ if( ulRegTest1CycleCount == ulLastRegTest1CycleCount ) { pcStatusMessage = "Error: RegTest1\r\n"; xPrintf( pcStatusMessage ); } if( ulRegTest2CycleCount == ulLastRegTest2CycleCount ) { pcStatusMessage = "Error: RegTest2\r\n"; xPrintf( pcStatusMessage ); } ulLastRegTest1CycleCount = ulRegTest1CycleCount; ulLastRegTest2CycleCount = ulRegTest2CycleCount; /* Toggle the check LED to give an indication of the system status. If the LED toggles every 5 seconds then everything is ok. A faster toggle indicates an error. */ vParTestToggleLED( mainCHECK_LED ); /* Ensure the LED toggles at a faster rate if an error has occurred. */ if( pcStatusMessage != NULL ) { xCycleFrequency = mainERROR_CYCLE_TIME; } } }
static void prvCheckTimerCallback( TimerHandle_t xTimer ) { /* Check the standard demo tasks are running without error. Latch the latest reported error in the pcStatusMessage character pointer. */ if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: GenQueue"; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: QueuePeek\r\n"; } if( xAreBlockingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockQueue\r\n"; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockTime\r\n"; } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: SemTest\r\n"; } if( xIsCreateTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: Death\r\n"; } if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: RecMutex\r\n"; } if( xAreComTestTasksStillRunning() != pdPASS ) { pcStatusMessage = "Error: ComTest\r\n"; } if( xAreTimerDemoTasksStillRunning( ( mainCHECK_TIMER_PERIOD_MS ) ) != pdTRUE ) { pcStatusMessage = "Error: TimerDemo"; } if( xArePollingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: PollQueue"; } if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: CountSem"; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: DynamicPriority"; } /* Toggle the check LED to give an indication of the system status. If the LED toggles every mainCHECK_TIMER_PERIOD_MS milliseconds then everything is ok. A faster toggle indicates an error. vParTestToggleLED() is not used to toggle this particular LED as it is on a different IP port to to the LEDs controlled by ParTest.c. A critical section is not required as the only other place this port is accessed is from another timer - and only one timer can be running at any one time. */ if( ( FM3_GPIO->PDOR3 & mainCHECK_LED ) != 0 ) { FM3_GPIO->PDOR3 &= ~mainCHECK_LED; } else { FM3_GPIO->PDOR3 |= mainCHECK_LED; } /* Have any errors been latch in pcStatusMessage? If so, shorten the period of the check timer to mainERROR_CHECK_TIMER_PERIOD_MS milliseconds. This will result in an increase in the rate at which mainCHECK_LED toggles. */ if( pcStatusMessage != NULL ) { /* This call to xTimerChangePeriod() uses a zero block time. Functions called from inside of a timer callback function must *never* attempt to block. */ xTimerChangePeriod( xCheckTimer, ( mainERROR_CHECK_TIMER_PERIOD_MS ), mainDONT_BLOCK ); } }
static void prvCheckTask( void *pvParameters ) { portTickType xNextWakeTime; const portTickType xCycleFrequency = 1000 / portTICK_RATE_MS; /* Just to remove compiler warning. */ ( void ) pvParameters; /* Initialise xNextWakeTime - this only needs to be done once. */ xNextWakeTime = xTaskGetTickCount(); for( ;; ) { /* Place this task in the blocked state until it is time to run again. */ vTaskDelayUntil( &xNextWakeTime, xCycleFrequency ); /* Check the standard demo tasks are running without error. */ if( xAreTimerDemoTasksStillRunning( xCycleFrequency ) != pdTRUE ) { pcStatusMessage = "Error: TimerDemo"; } else if( xAreIntegerMathsTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: IntMath"; } else if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: GenQueue"; } else if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: QueuePeek"; } else if( xAreBlockingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockQueue"; } else if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: SemTest"; } else if( xArePollingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: PollQueue"; } else if( xAreMathsTaskStillRunning() != pdPASS ) { pcStatusMessage = "Error: Flop"; } else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: RecMutex"; } else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: CountSem"; } else if( xIsCreateTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: Death"; } else if( xAreDynamicPriorityTasksStillRunning() != pdPASS ) { pcStatusMessage = "Error: Dynamic\r\n"; } else if( xAreQueueSetTasksStillRunning() != pdPASS ) { pcStatusMessage = "Error: Queue set\r\n"; } else if( xIsQueueOverwriteTaskStillRunning() != pdPASS ) { pcStatusMessage = "Error: Queue overwrite\r\n"; } /* This is the only task that uses stdout so its ok to call printf() directly. */ printf( "%s - %d\r\n", pcStatusMessage, xTaskGetTickCount() ); } }
/* See the description at the top of this file. */ static void prvCheckTimerCallback( TimerHandle_t xTimer ) { static long lChangedTimerPeriodAlready = pdFALSE; static unsigned long ulLastRegTest1Value = 0, ulLastRegTest2Value = 0; unsigned long ulErrorFound = pdFALSE; /* Check all the demo and test tasks to ensure that they are all still running, and that none have detected an error. */ if( xAreDynamicPriorityTasksStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } if( xAreBlockTimeTestTasksStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } if( xAreCountingSemaphoreTasksStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } if( xAreRecursiveMutexTasksStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } /* Check that the register test 1 task is still running. */ if( ulLastRegTest1Value == ulRegTest1LoopCounter ) { ulErrorFound = pdTRUE; } ulLastRegTest1Value = ulRegTest1LoopCounter; /* Check that the register test 2 task is still running. */ if( ulLastRegTest2Value == ulRegTest2LoopCounter ) { ulErrorFound = pdTRUE; } ulLastRegTest2Value = ulRegTest2LoopCounter; if( xAreQueueSetTasksStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } if( xIsQueueOverwriteTaskStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } if( xAreGenericQueueTasksStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } if( xAreQueuePeekTasksStillRunning() != pdPASS ) { ulErrorFound = pdTRUE; } /* Toggle the check LED to give an indication of the system status. If the LED toggles every mainCHECK_TIMER_PERIOD_MS milliseconds then everything is ok. A faster toggle indicates an error. */ port_pin_toggle_output_level( LED_0_PIN ); /* Have any errors been latched in ulErrorFound? If so, shorten the period of the check timer to mainERROR_CHECK_TIMER_PERIOD_MS milliseconds. This will result in an increase in the rate at which the LED toggles. */ if( ulErrorFound != pdFALSE ) { if( lChangedTimerPeriodAlready == pdFALSE ) { lChangedTimerPeriodAlready = pdTRUE; /* This call to xTimerChangePeriod() uses a zero block time. Functions called from inside of a timer callback function must *never* attempt to block. */ xTimerChangePeriod( xTimer, ( mainERROR_CHECK_TIMER_PERIOD_MS ), mainDONT_BLOCK ); } } }
void vCheckTask( void *pvParameters ) { unsigned long ulRow = 0; TickType_t xDelay = 0; unsigned short usErrorCode = 0; unsigned long ulIteration = 0; extern unsigned short usMaxJitter; /* Intialise the sleeper. */ xDelay = xTaskGetTickCount(); for( ;; ) { /* Perform this check every mainCHECK_DELAY milliseconds. */ vTaskDelayUntil( &xDelay, mainCHECK_DELAY ); /* Check that all of the Demo tasks are still running. */ if( pdTRUE != xAreBlockingQueuesStillRunning() ) { usErrorCode |= 0x1; } if( pdTRUE != xAreBlockTimeTestTasksStillRunning() ) { usErrorCode |= 0x2; } if( pdTRUE != xAreCountingSemaphoreTasksStillRunning() ) { usErrorCode |= 0x4; } if( pdTRUE != xIsCreateTaskStillRunning() ) { usErrorCode |= 0x8; } if( pdTRUE != xAreDynamicPriorityTasksStillRunning() ) { usErrorCode |= 0x10; } if( pdTRUE != xAreMathsTaskStillRunning() ) { usErrorCode |= 0x20; } if( pdTRUE != xAreGenericQueueTasksStillRunning() ) { usErrorCode |= 0x40; } if( pdTRUE != xAreIntegerMathsTaskStillRunning() ) { usErrorCode |= 0x80; } if( pdTRUE != xArePollingQueuesStillRunning() ) { usErrorCode |= 0x100; } if( pdTRUE != xAreQueuePeekTasksStillRunning() ) { usErrorCode |= 0x200; } if( pdTRUE != xAreSemaphoreTasksStillRunning() ) { usErrorCode |= 0x400; } if( pdTRUE != xAreComTestTasksStillRunning() ) { usErrorCode |= 0x800; } if( pdTRUE != xAreIntQueueTasksStillRunning() ) { usErrorCode |= 0x1000; } /* Clear the display. */ LCD_Character_Display_ClearDisplay(); if( 0 == usErrorCode ) { LCD_Character_Display_Position( ( ulRow ) & 0x1, 0); LCD_Character_Display_PrintString( "Pass: "******"Jitter(ns):" ); LCD_Character_Display_PrintNumber( ( usMaxJitter * mainNS_PER_CLOCK ) ); } else { /* Do something to indicate the failure. */ LCD_Character_Display_Position( ( ulRow ) & 0x1, 0 ); LCD_Character_Display_PrintString( "Fail at: " ); LCD_Character_Display_PrintNumber( ulIteration ); LCD_Character_Display_Position( ( ++ulRow ) & 0x1, 0 ); LCD_Character_Display_PrintString( "Error: 0x" ); LCD_Character_Display_PrintHexUint16( usErrorCode ); } } }
static portSHORT prvCheckOtherTasksAreStillRunning( void ) { portBASE_TYPE lReturn = pdPASS; /* The demo tasks maintain a count that increments every cycle of the task provided that the task has never encountered an error. This function checks the counts maintained by the tasks to ensure they are still being incremented. A count remaining at the same value between calls therefore indicates that an error has been detected. */ if( xAreIntegerMathsTaskStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if( xAreComTestTasksStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if( xAreBlockingQueuesStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if( xAreMathsTaskStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if( xIsCreateTaskStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if ( xAreGenericQueueTasksStillRunning() != pdTRUE ) { lReturn = pdFAIL; } if ( xAreQueuePeekTasksStillRunning() != pdTRUE ) { lReturn = pdFAIL; } /* Have the register test tasks found any errors? */ if( ulRegTestError != pdFALSE ) { lReturn = pdFAIL; } return lReturn; }
static void prvCheckTask( void *pvParameters ) { TickType_t xNextWakeTime; const TickType_t xCycleFrequency = 2500 / portTICK_PERIOD_MS; /* Just to remove compiler warning. */ ( void ) pvParameters; /* Initialise xNextWakeTime - this only needs to be done once. */ xNextWakeTime = xTaskGetTickCount(); for( ;; ) { /* Place this task in the blocked state until it is time to run again. */ vTaskDelayUntil( &xNextWakeTime, xCycleFrequency ); /* Check the standard demo tasks are running without error. */ #if( configUSE_PREEMPTION != 0 ) { /* These tasks are only created when preemption is used. */ if( xAreTimerDemoTasksStillRunning( xCycleFrequency ) != pdTRUE ) { pcStatusMessage = "Error: TimerDemo"; } } #endif if( xAreEventGroupTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: EventGroup"; } else if( xAreIntegerMathsTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: IntMath"; } else if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: GenQueue"; } else if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: QueuePeek"; } else if( xAreBlockingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: BlockQueue"; } else if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: SemTest"; } else if( xArePollingQueuesStillRunning() != pdTRUE ) { pcStatusMessage = "Error: PollQueue"; } else if( xAreMathsTaskStillRunning() != pdPASS ) { pcStatusMessage = "Error: Flop"; } else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: RecMutex"; } else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE ) { pcStatusMessage = "Error: CountSem"; } else if( xIsCreateTaskStillRunning() != pdTRUE ) { pcStatusMessage = "Error: Death"; } else if( xAreDynamicPriorityTasksStillRunning() != pdPASS ) { pcStatusMessage = "Error: Dynamic"; } else if( xAreQueueSetTasksStillRunning() != pdPASS ) { pcStatusMessage = "Error: Queue set"; } else if( xIsQueueOverwriteTaskStillRunning() != pdPASS ) { pcStatusMessage = "Error: Queue overwrite"; } /* This is the only task that uses stdout so its ok to call printf() directly. */ printf( ( char * ) "%s - %u\r\n", pcStatusMessage, ( unsigned int ) xTaskGetTickCount() ); fflush( stdout ); } }
extern "C" void vApplicationTickHook() { static unsigned portLONG ulTicksSinceLastDisplay = 0; // Called from every tick interrupt. Have enough ticks passed to make it // time to perform our health status check again? ulTicksSinceLastDisplay++; if( ulTicksSinceLastDisplay >= mainCHECK_DELAY ) { ulTicksSinceLastDisplay = 0; WDT_Feed(); #if configGENERATE_RUN_TIME_STATS == 1 unsigned long long uptime_usec = ullTaskGetSchedulerUptime(); #if 1 struct timeval tp; int t = gettimeofday(&tp, NULL); printf("timeofday = %ld seconds %ld microseconds (code %d)\n", (long)tp.tv_sec, (long)tp.tv_usec, t); #endif printf("Uptime: %u.%06u seconds\n", (unsigned int)(uptime_usec / 1000000), (unsigned int)(uptime_usec % 1000000)); int8_t *taskListBuffer = (int8_t *)malloc(40 * uxTaskGetNumberOfTasks()); if (taskListBuffer != NULL) { vTaskGetRunTimeStats((int8_t *)taskListBuffer); puts((const char *)taskListBuffer); free(taskListBuffer); } #endif // Has an error been found in any task? int allGood = 1; #if 0 if( xAreBlockingQueuesStillRunning() != pdTRUE ) { printf("ERROR - BLOCKQ\n"); allGood = 0; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { printf("ERROR - BLOCKTIM\n"); allGood = 0; } if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { printf("ERROR - GENQ\n"); allGood = 0; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { printf("ERROR - PEEKQ\n"); allGood = 0; } if( xAreDynamicPriorityTasksStillRunning() != pdTRUE ) { printf("ERROR - DYNAMIC\n"); allGood = 0; } #endif if (allGood == 1) { printf("All Good.\n"); } fflush(stdout); } }
static void prvCheckTask( void *pvParameters ) { unsigned ulLastRegTest1Count = 0, ulLastRegTest2Count = 0; portTickType xLastExecutionTime; /* To prevent compiler warnings. */ ( void ) pvParameters; /* Initialise the variable used to control our iteration rate prior to its first use. */ xLastExecutionTime = xTaskGetTickCount(); for( ;; ) { /* Wait until it is time to run the tests again. */ vTaskDelayUntil( &xLastExecutionTime, mainCHECK_TASK_PERIOD ); /* Has an error been found in any task? */ if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x01UL; } if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x02UL; } if( xAreBlockingQueuesStillRunning() != pdTRUE ) { ulErrorCode |= 0x04UL; } if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x20UL; } if( xArePollingQueuesStillRunning() != pdTRUE ) { ulErrorCode |= 0x40UL; } if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x80UL; } if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) { ulErrorCode |= 0x100UL; } if( ulLastRegTest1Count == ulRegTest1Counter ) { ulErrorCode |= 0x200UL; } if( ulLastRegTest2Count == ulRegTest2Counter ) { ulErrorCode |= 0x200UL; } /* Remember the reg test counts so a stall in their values can be detected next time around. */ ulLastRegTest1Count = ulRegTest1Counter; ulLastRegTest2Count = ulRegTest2Counter; } }
static void prvCheckTask( void *pvParameters ) { unsigned long ulLastRegTest1Value = 0, ulLastRegTest2Value = 0, ulTicksToWait = mainNO_ERROR_PERIOD; portTickType xLastExecutionTime; /* Buffer into which the high frequency timer count is written as a string. */ static char cStringBuffer[ mainMAX_STRING_LENGTH ]; /* The count of the high frequency timer interrupts. */ extern unsigned long ulHighFrequencyTimerInterrupts; xLCDMessage xMessage = { ( 200 / portTICK_RATE_MS ), cStringBuffer }; /* Setup the high frequency, high priority, timer test. It is setup here to ensure it does not fire before the scheduler is started. */ vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY ); /* Initialise the variable used to control our iteration rate prior to its first use. */ xLastExecutionTime = xTaskGetTickCount(); for( ;; ) { /* Wait until it is time to run the tests again. */ vTaskDelayUntil( &xLastExecutionTime, ulTicksToWait ); /* Has either register check 1 or 2 task discovered an error? */ if( ulStatus1 != pdPASS ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Reg test1"; } /* Check that the register test 1 task is still running. */ if( ulLastRegTest1Value == ulRegTest1Cycles ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Reg test2"; } ulLastRegTest1Value = ulRegTest1Cycles; /* Check that the register test 2 task is still running. */ if( ulLastRegTest2Value == ulRegTest2Cycles ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Reg test3"; } ulLastRegTest2Value = ulRegTest2Cycles; /* Have any of the standard demo tasks detected an error in their operation? */ if( xAreGenericQueueTasksStillRunning() != pdTRUE ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Gen Q"; } else if( xAreQueuePeekTasksStillRunning() != pdTRUE ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Q Peek"; } else if( xAreComTestTasksStillRunning() != pdTRUE ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: COM test"; } else if( xAreBlockTimeTestTasksStillRunning() != pdTRUE ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Blck time"; } else if( xAreSemaphoreTasksStillRunning() != pdTRUE ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Sem test"; } else if( xAreIntQueueTasksStillRunning() != pdTRUE ) { ulTicksToWait = mainERROR_PERIOD; xMessage.pcMessage = "Error: Int queue"; } /* Write the ulHighFrequencyTimerInterrupts value to the string buffer. It will only be displayed if no errors have been detected. */ sprintf( cStringBuffer, "Pass %u", ( unsigned int ) ulHighFrequencyTimerInterrupts ); xQueueSend( xLCDQueue, &xMessage, mainDONT_WAIT ); vParTestToggleLED( mainCHECK_LED ); } }