/* | |
* FreeRTOS Kernel V10.1.1 | |
* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy of | |
* this software and associated documentation files (the "Software"), to deal in | |
* the Software without restriction, including without limitation the rights to | |
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of | |
* the Software, and to permit persons to whom the Software is furnished to do so, | |
* subject to the following conditions: | |
* | |
* The above copyright notice and this permission notice shall be included in all | |
* copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS | |
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR | |
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER | |
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
* | |
* http://www.FreeRTOS.org | |
* http://aws.amazon.com/freertos | |
* | |
* 1 tab == 4 spaces! | |
*/ | |
/* | |
* main() creates all the demo application tasks, then starts the scheduler. | |
* The web documentation provides more details of the standard demo application | |
* tasks, which provide no particular functionality but do provide a good | |
* example of how to use the FreeRTOS API. | |
* | |
* In addition to the standard demo tasks, the following tasks and tests are | |
* defined and/or created within this file: | |
* | |
* "Check" task - This only executes every five seconds but has a high priority | |
* to ensure it gets processor time. Its main function is to check that all the | |
* standard demo tasks are still operational. While no errors have been | |
* discovered the check task will print out "OK" and the current simulated tick | |
* time. If an error is discovered in the execution of a task then the check | |
* task will print out an appropriate error message. | |
* | |
*/ | |
/* Standard includes. */ | |
#include <stdio.h> | |
#include <stdlib.h> | |
/* Kernel includes. */ | |
#include <FreeRTOS.h> | |
#include <task.h> | |
#include <queue.h> | |
#include <timers.h> | |
#include <semphr.h> | |
/* Standard demo includes. */ | |
#include "BlockQ.h" | |
#include "integer.h" | |
#include "semtest.h" | |
#include "PollQ.h" | |
#include "GenQTest.h" | |
#include "QPeek.h" | |
#include "recmutex.h" | |
#include "flop.h" | |
#include "TimerDemo.h" | |
#include "countsem.h" | |
#include "death.h" | |
#include "dynamic.h" | |
#include "QueueSet.h" | |
#include "QueueOverwrite.h" | |
#include "EventGroupsDemo.h" | |
#include "IntSemTest.h" | |
#include "TaskNotify.h" | |
#include "QueueSetPolling.h" | |
#include "StaticAllocation.h" | |
#include "blocktim.h" | |
#include "AbortDelay.h" | |
#include "MessageBufferDemo.h" | |
#include "StreamBufferDemo.h" | |
#include "StreamBufferInterrupt.h" | |
/* Priorities at which the tasks are created. */ | |
#define mainCHECK_TASK_PRIORITY ( configMAX_PRIORITIES - 2 ) | |
#define mainQUEUE_POLL_PRIORITY ( tskIDLE_PRIORITY + 1 ) | |
#define mainSEM_TEST_PRIORITY ( tskIDLE_PRIORITY + 1 ) | |
#define mainBLOCK_Q_PRIORITY ( tskIDLE_PRIORITY + 2 ) | |
#define mainCREATOR_TASK_PRIORITY ( tskIDLE_PRIORITY + 3 ) | |
#define mainFLASH_TASK_PRIORITY ( tskIDLE_PRIORITY + 1 ) | |
#define mainINTEGER_TASK_PRIORITY ( tskIDLE_PRIORITY ) | |
#define mainGEN_QUEUE_TASK_PRIORITY ( tskIDLE_PRIORITY ) | |
#define mainFLOP_TASK_PRIORITY ( tskIDLE_PRIORITY ) | |
#define mainQUEUE_OVERWRITE_PRIORITY ( tskIDLE_PRIORITY ) | |
#define mainTIMER_TEST_PERIOD ( 50 ) | |
/* The task that periodically checks that all the standard demo tasks are | |
* still executing and error free. | |
*/ | |
static void prvCheckTask( void *pvParameters ); | |
/*-----------------------------------------------------------*/ | |
/* The variable into which error messages are latched. */ | |
static char *pcStatusMessage = "No errors"; | |
/*-----------------------------------------------------------*/ | |
int main_full( void ) | |
{ | |
/* Start the check task as described at the top of this file. */ | |
xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL ); | |
/* Create the standard demo tasks. */ | |
vStartTaskNotifyTask(); | |
vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY ); | |
vStartSemaphoreTasks( mainSEM_TEST_PRIORITY ); | |
vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY ); | |
vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY ); | |
vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY ); | |
vStartQueuePeekTasks(); | |
vStartMathTasks( mainFLOP_TASK_PRIORITY ); | |
vStartRecursiveMutexTasks(); | |
vStartCountingSemaphoreTasks(); | |
vStartDynamicPriorityTasks(); | |
vStartQueueSetTasks(); | |
vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY ); | |
vStartEventGroupTasks(); | |
vStartInterruptSemaphoreTasks(); | |
vStartQueueSetPollingTask(); | |
vCreateBlockTimeTasks(); | |
vCreateAbortDelayTasks(); | |
vStartMessageBufferTasks( configMINIMAL_STACK_SIZE ); | |
vStartStreamBufferTasks(); | |
vStartStreamBufferInterruptDemo(); | |
#if( configUSE_PREEMPTION != 0 ) | |
{ | |
/* Don't expect these tasks to pass when preemption is not used. */ | |
vStartTimerDemoTask( mainTIMER_TEST_PERIOD ); | |
} | |
#endif | |
/* The suicide tasks must be created last as they need to know how many | |
tasks were running prior to their creation. This then allows them to | |
ascertain whether or not the correct/expected number of tasks are running at | |
any given time. */ | |
vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY ); | |
/* Start the scheduler itself. */ | |
vTaskStartScheduler(); | |
/* Should never get here unless there was not enough heap space to create | |
the idle and other system tasks. */ | |
return 0; | |
} | |
/*-----------------------------------------------------------*/ | |
static void prvCheckTask( void *pvParameters ) | |
{ | |
TickType_t xNextWakeTime; | |
const TickType_t xCycleFrequency = pdMS_TO_TICKS( 5000UL ); | |
/* 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( xAreTaskNotificationTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: Notification"; | |
} | |
else if( xAreIntegerMathsTaskStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: IntMath"; | |
} | |
else if( xAreGenericQueueTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: GenQueue"; | |
} | |
else if( xAreBlockingQueuesStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: BlockQueue"; | |
} | |
else if( xAreSemaphoreTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: SemTest"; | |
} | |
else if( xArePollingQueuesStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: PollQueue"; | |
} | |
else if( xAreQueuePeekTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: QueuePeek"; | |
} | |
else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: RecMutex"; | |
} | |
else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: CountSem"; | |
} | |
else if( xAreDynamicPriorityTasksStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Dynamic"; | |
} | |
else if( xAreQueueSetTasksStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Queue set"; | |
} | |
else if( xAreEventGroupTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: EventGroup"; | |
} | |
else if( xIsQueueOverwriteTaskStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Queue overwrite"; | |
} | |
else if( xAreQueueSetPollTasksStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Queue set polling"; | |
} | |
else if( xAreBlockTimeTestTasksStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Block time"; | |
} | |
else if( xAreMessageBufferTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: MessageBuffer"; | |
} | |
else if( xAreAbortDelayTestTasksStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Abort delay"; | |
} | |
else if( xAreStreamBufferTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: StreamBuffer"; | |
} | |
else if( xIsInterruptStreamBufferDemoStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Stream buffer interrupt"; | |
} | |
else if( xAreInterruptSemaphoreTasksStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: IntSem"; | |
} | |
else if( xIsCreateTaskStillRunning() != pdTRUE ) | |
{ | |
pcStatusMessage = "Error: Death"; | |
} | |
else if( xAreMathsTaskStillRunning() != pdPASS ) | |
{ | |
pcStatusMessage = "Error: Flop"; | |
} | |
/* This is the only task that uses stdout so its ok to call printf() | |
directly. */ | |
printf( "%s - tick count %zu - free heap %zu - min free heap %zu\r\n", pcStatusMessage, | |
xTaskGetTickCount(), | |
xPortGetFreeHeapSize(), | |
xPortGetMinimumEverFreeHeapSize() ); | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
/* Called by vApplicationTickHook(), which is defined in main.c. */ | |
void vFullDemoTickHookFunction( void ) | |
{ | |
TaskHandle_t xTimerTask; | |
/* Call the periodic timer test, which tests the timer API functions that | |
can be called from an ISR. */ | |
#if( configUSE_PREEMPTION != 0 ) | |
{ | |
/* Only created when preemption is used. */ | |
vTimerPeriodicISRTests(); | |
} | |
#endif | |
/* Call the periodic queue overwrite from ISR demo. */ | |
vQueueOverwritePeriodicISRDemo(); | |
/* Write to a queue that is in use as part of the queue set demo to | |
demonstrate using queue sets from an ISR. */ | |
vQueueSetAccessQueueSetFromISR(); | |
vQueueSetPollingInterruptAccess(); | |
/* Exercise event groups from interrupts. */ | |
vPeriodicEventGroupsProcessing(); | |
/* Exercise giving mutexes from an interrupt. */ | |
vInterruptSemaphorePeriodicTest(); | |
/* Exercise using task notifications from an interrupt. */ | |
xNotifyTaskFromISR(); | |
/* Writes to stream buffer byte by byte to test the stream buffer trigger | |
level functionality. */ | |
vPeriodicStreamBufferProcessing(); | |
/* Writes a string to a string buffer four bytes at a time to demonstrate | |
a stream being sent from an interrupt to a task. */ | |
vBasicStreamBufferSendFromISR(); | |
} | |
/*-----------------------------------------------------------*/ | |