mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-04-27 00:42:01 -04:00
430 lines
16 KiB
C
430 lines
16 KiB
C
/* main.c
|
|
*
|
|
* "Check" callback function - Called each time the 'check' timer expires. The
|
|
* check timer executes every five seconds. Its main function is to check that
|
|
* all the standard demo tasks are still operational. Each time it executes it
|
|
* sends a status code to the LCD task. The LCD task interprets the code and
|
|
* displays an appropriate message - which will be PASS if no tasks have
|
|
* reported any errors, or a message stating which task has reported an error.
|
|
*
|
|
* "Reg test" tasks - These fill the registers with known values, then check
|
|
* that each register still contains its expected value. Each task uses
|
|
* different values. The tasks run with very low priority so get preempted
|
|
* very frequently. A check variable is incremented on each iteration of the
|
|
* test loop. A register containing an unexpected value is indicative of an
|
|
* error in the context switching mechanism and will result in a branch to a
|
|
* null loop - which in turn will prevent the check variable from incrementing
|
|
* any further and allow the check timer callback (described a above) to
|
|
* determine that an error has occurred. The nature of the reg test tasks
|
|
* necessitates that they are written in assembly code.
|
|
*
|
|
* Tick hook function - called inside the RTOS tick function, this simple
|
|
* example does nothing but toggle an LED.
|
|
*
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include "timers.h"
|
|
#include "queue.h"
|
|
#include "gio.h"
|
|
#include "TimerDemo.h"
|
|
#include "countsem.h"
|
|
#include "GenQTest.h"
|
|
#include "dynamic.h"
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
/* Codes sent within messages to the LCD task so the LCD task can interpret
|
|
exactly what the message it just received was. These are sent in the
|
|
cMessageID member of the message structure (defined below). */
|
|
//#define mainMESSAGE_BUTTON_UP ( 1 )
|
|
//#define mainMESSAGE_BUTTON_SEL ( 2 )
|
|
#define mainMESSAGE_STATUS ( 3 )
|
|
|
|
/* When the cMessageID member of the message sent to the MSG task is
|
|
mainMESSAGE_STATUS then these definitions are sent in the ulMessageValue member
|
|
of the same message and indicate what the status actually is. */
|
|
#define mainERROR_DYNAMIC_TASKS ( pdPASS + 1 )
|
|
#define mainERROR_COM_TEST ( pdPASS + 2 )
|
|
#define mainERROR_GEN_QUEUE_TEST ( pdPASS + 3 )
|
|
#define mainERROR_REG_TEST ( pdPASS + 4 )
|
|
#define mainERROR_TIMER_TEST ( pdPASS + 5 )
|
|
#define mainERROR_COUNT_SEM_TEST ( pdPASS + 6 )
|
|
|
|
/* Priorities used by the test and demo tasks. */
|
|
#define mainMSG_TASK_PRIORITY ( tskIDLE_PRIORITY + 1 )
|
|
#define mainCOM_TEST_PRIORITY ( tskIDLE_PRIORITY + 2 )
|
|
#define mainGENERIC_QUEUE_TEST_PRIORITY ( tskIDLE_PRIORITY )
|
|
|
|
/* Just used to ensure parameters are passed into tasks correctly. */
|
|
#define mainTASK_PARAMETER_CHECK_VALUE ((void *)0xDEAD)
|
|
|
|
/* The length of the queue (the number of items the queue can hold) that is used
|
|
to send messages from tasks and interrupts the the MSG task. */
|
|
#define mainQUEUE_LENGTH ( 5 )
|
|
|
|
/* The base period used by the timer test tasks. */
|
|
#define mainTIMER_TEST_PERIOD ( 50 )
|
|
|
|
/* The frequency at which the check timer (described in the comments at the top
|
|
of this file) will call its callback function. */
|
|
#define mainCHECK_TIMER_PERIOD ( 5000UL / ( unsigned long ) portTICK_RATE_MS )
|
|
|
|
/* Misc. */
|
|
#define mainDONT_BLOCK ( 0 )
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
/* external regsiter check tasks, this checks that the context store/restore works */
|
|
|
|
extern void vRegTestTask1(void *pvParameters);
|
|
extern void vRegTestTask2(void *pvParameters);
|
|
|
|
/*
|
|
* Definition of the MSG/controller task described in the comments at the top
|
|
* of this file.
|
|
*/
|
|
static void prvMsgTask( void *pvParameters );
|
|
|
|
/*
|
|
* Converts a status message value into an appropriate string for display on
|
|
* the LCD. The string is written to pcBuffer.
|
|
*/
|
|
static void prvGenerateStatusMessage( char *pcBuffer, unsigned long ulStatusValue );
|
|
|
|
/*
|
|
* Defines the 'check' functionality as described at the top of this file. This
|
|
* function is the callback function for the 'check' timer. */
|
|
static void vCheckTimerCallback( xTimerHandle xTimer );
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
static signed char buffer[1024];
|
|
|
|
void vStatsTask(void *pvParameters)
|
|
{
|
|
printf("**** Task Statistics Started\n");
|
|
for (;;)
|
|
{
|
|
vTaskDelay(15000);
|
|
vTaskGetRunTimeStats(buffer);
|
|
printf("%s\n", buffer);
|
|
}
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
/* variable incremente in the IDLE hook */
|
|
volatile unsigned usIdleCounter = 0;
|
|
|
|
/* Variables that are incremented on each iteration of the reg test tasks -
|
|
provided the tasks have not reported any errors. The check task inspects these
|
|
variables to ensure they are still incrementing as expected. If a variable
|
|
stops incrementing then it is likely that its associate task has stalled. */
|
|
volatile unsigned usRegTest1Counter = 0, usRegTest2Counter = 0;
|
|
|
|
/* The handle of the queue used to send messages from tasks and interrupts to
|
|
the MSG task. */
|
|
static xQueueHandle xMsgQueue = NULL;
|
|
|
|
/* The 'check' timer, as described at the top of this file. */
|
|
static xTimerHandle xCheckTimer = NULL;
|
|
|
|
/* The definition of each message sent from tasks and interrupts to the MSG
|
|
task. */
|
|
typedef struct
|
|
{
|
|
char cMessageID; /* << States what the message is. */
|
|
unsigned ulMessageValue; /* << States the message value (can be an integer, string pointer, etc. depending on the value of cMessageID). */
|
|
} xQueueMessage;
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
void main()
|
|
{
|
|
/* initalise DIO ports */
|
|
gioInit();
|
|
|
|
gioSetBit(gioPORTA, 0, 1);
|
|
gioSetBit(gioPORTA, 0, 0);
|
|
|
|
|
|
/* Create the queue used by tasks and interrupts to send strings to the MSG task. */
|
|
xMsgQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( xQueueMessage ) );
|
|
|
|
/* If the queue could not be created then don't create any tasks that might
|
|
attempt to use the queue. */
|
|
if( xMsgQueue != NULL )
|
|
{
|
|
/* Create STATS task, this prints out a summary of running tasks every 15s */
|
|
xTaskCreate(vStatsTask, (signed char *)"STATS..", 600, NULL, 6, NULL);
|
|
|
|
/* Create the standard demo tasks. */
|
|
vStartDynamicPriorityTasks();
|
|
vStartGenericQueueTasks( mainGENERIC_QUEUE_TEST_PRIORITY );
|
|
vStartCountingSemaphoreTasks();
|
|
|
|
/* Note that creating the timer test/demo tasks will fill the timer
|
|
command queue. This is intentional, and forms part of the test the tasks
|
|
perform. It does mean however that, after this function is called, no
|
|
more timer commands can be sent until after the scheduler has been
|
|
started (at which point the timer daemon will drained the timer command
|
|
queue, freeing up space for more commands to be received). */
|
|
vStartTimerDemoTask(mainTIMER_TEST_PERIOD);
|
|
|
|
/* Create the MSGl and register test tasks. */
|
|
xTaskCreate(prvMsgTask, (signed char *)"MSG....", 500, mainTASK_PARAMETER_CHECK_VALUE, mainMSG_TASK_PRIORITY, NULL );
|
|
xTaskCreate(vRegTestTask1, (signed char *)"REG1...", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL);
|
|
xTaskCreate(vRegTestTask2, (signed char *)"REG2...", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL);
|
|
|
|
|
|
/* Create the 'check' timer - the timer that periodically calls the
|
|
check function as described at the top of this file. Note that, for
|
|
the reasons stated in the comments above the call to
|
|
vStartTimerDemoTask(), that the check timer is not actually started
|
|
until after the scheduler has been started. */
|
|
xCheckTimer = xTimerCreate( ( const signed char * ) "Check Timer", mainCHECK_TIMER_PERIOD, pdTRUE, ( void * ) 0, vCheckTimerCallback );
|
|
|
|
/* start FreeRTOS Scheduler */
|
|
vTaskStartScheduler();
|
|
}
|
|
|
|
/* If all is well then this line will never be reached. If it is reached
|
|
then it is likely that there was insufficient (FreeRTOS) heap memory space
|
|
to create the idle task. This may have been trapped by the malloc() failed
|
|
hook function, if one is configured. */
|
|
for (;;);
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
static void prvMsgTask( void *pvParameters )
|
|
{
|
|
xQueueMessage xReceivedMessage;
|
|
static char cBuffer[50];
|
|
|
|
printf("**** Msg Task Started\n");
|
|
|
|
/* Now the scheduler has been started (it must have been for this task to
|
|
be running), start the check timer too. The call to xTimerStart() will
|
|
block until the command has been accepted. */
|
|
if( xCheckTimer != NULL )
|
|
{
|
|
xTimerStart( xCheckTimer, portMAX_DELAY );
|
|
}
|
|
|
|
/* First print out the number of bytes that remain in the FreeRTOS heap. This
|
|
is done after a short delay to ensure all the demo tasks have created all
|
|
the objects they are going to use. */
|
|
vTaskDelay( mainTIMER_TEST_PERIOD * 10 );
|
|
printf("**** %d heap free\n", (int)xPortGetFreeHeapSize());
|
|
|
|
/* Just as a test of the port, and for no functional reason, check the task
|
|
parameter contains its expected value. */
|
|
if( pvParameters != mainTASK_PARAMETER_CHECK_VALUE )
|
|
{
|
|
printf("**** Invalid parameter ****\n\n");
|
|
}
|
|
|
|
for( ;; )
|
|
{
|
|
/* Wait for a message to be received. Using portMAX_DELAY as the block
|
|
time will result in an indefinite wait provided INCLUDE_vTaskSuspend is
|
|
set to 1 in FreeRTOSConfig.h, therefore there is no need to check the
|
|
function return value and the function will only return when a value
|
|
has been received. */
|
|
xQueueReceive( xMsgQueue, &xReceivedMessage, portMAX_DELAY );
|
|
|
|
/* What is this message? What does it contain? */
|
|
switch( xReceivedMessage.cMessageID )
|
|
{
|
|
#if 0
|
|
case mainMESSAGE_BUTTON_UP : /* The button poll task has just
|
|
informed this task that the up
|
|
button on the joystick input has
|
|
been pressed or released. */
|
|
sprintf( cBuffer, "Button up = %d", ( int ) xReceivedMessage.ulMessageValue );
|
|
break;
|
|
|
|
case mainMESSAGE_BUTTON_SEL : /* The select button interrupt
|
|
just informed this task that the
|
|
select button has been pressed.
|
|
In this case the pointer to the
|
|
string to print is sent directly
|
|
in the ulMessageValue member of
|
|
the message. This just
|
|
demonstrates a different
|
|
communication technique. */
|
|
sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.ulMessageValue );
|
|
break;
|
|
#endif
|
|
case mainMESSAGE_STATUS : /* The tick interrupt hook
|
|
function has just informed this
|
|
task of the system status.
|
|
Generate a string in accordance
|
|
with the status value. */
|
|
prvGenerateStatusMessage( cBuffer, xReceivedMessage.ulMessageValue );
|
|
break;
|
|
|
|
default : sprintf( cBuffer, "Unknown message" );
|
|
break;
|
|
}
|
|
/* Output the message that was placed into the cBuffer array within the
|
|
switch statement above, then move onto the next line ready for the next
|
|
message to arrive on the queue. */
|
|
printf("**** Message Received: %s\n", cBuffer);
|
|
}
|
|
}
|
|
|
|
static void prvGenerateStatusMessage(char *pcBuffer, unsigned long ulStatusValue)
|
|
{
|
|
/* Just a utility function to convert a status value into a meaningful
|
|
string for output. */
|
|
switch( ulStatusValue )
|
|
{
|
|
case pdPASS : sprintf( pcBuffer, "Status = PASS" );
|
|
break;
|
|
case mainERROR_DYNAMIC_TASKS : sprintf( pcBuffer, "Err: Dynamic tsks" );
|
|
break;
|
|
case mainERROR_COM_TEST : sprintf( pcBuffer, "Err: COM test" );
|
|
break;
|
|
case mainERROR_GEN_QUEUE_TEST : sprintf( pcBuffer, "Error: Gen Q test" );
|
|
break;
|
|
case mainERROR_REG_TEST : sprintf( pcBuffer, "Error: Reg test" );
|
|
break;
|
|
case mainERROR_TIMER_TEST : sprintf( pcBuffer, "Error: Tmr test" );
|
|
break;
|
|
case mainERROR_COUNT_SEM_TEST : sprintf( pcBuffer, "Error: Count sem" );
|
|
break;
|
|
default : sprintf( pcBuffer, "Unknown status" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
static void vCheckTimerCallback( xTimerHandle xTimer )
|
|
{
|
|
static unsigned short usLastRegTest1Counter = 0, usLastRegTest2Counter = 0;
|
|
|
|
/* Define the status message that is sent to the LCD task. By default the
|
|
status is PASS. */
|
|
static xQueueMessage xStatusMessage = { mainMESSAGE_STATUS, pdPASS };
|
|
|
|
/* This is the callback function used by the 'check' timer, as described
|
|
at the top of this file. */
|
|
|
|
/* The parameter is not used. */
|
|
( void ) xTimer;
|
|
|
|
/* See if the standard demo tasks are executing as expected, changing
|
|
the message that is sent to the LCD task from PASS to an error code if
|
|
any tasks set reports an error. */
|
|
#if 0
|
|
if( xAreComTestTasksStillRunning() != pdPASS )
|
|
{
|
|
xStatusMessage.ulMessageValue = mainERROR_COM_TEST;
|
|
}
|
|
#endif
|
|
if( xAreDynamicPriorityTasksStillRunning() != pdPASS )
|
|
{
|
|
xStatusMessage.ulMessageValue = mainERROR_DYNAMIC_TASKS;
|
|
}
|
|
|
|
if( xAreGenericQueueTasksStillRunning() != pdPASS )
|
|
{
|
|
xStatusMessage.ulMessageValue = mainERROR_GEN_QUEUE_TEST;
|
|
}
|
|
|
|
if( xAreCountingSemaphoreTasksStillRunning() != pdPASS )
|
|
{
|
|
xStatusMessage.ulMessageValue = mainERROR_COUNT_SEM_TEST;
|
|
}
|
|
|
|
if( xAreTimerDemoTasksStillRunning( ( portTickType ) mainCHECK_TIMER_PERIOD ) != pdPASS )
|
|
{
|
|
xStatusMessage.ulMessageValue = mainERROR_TIMER_TEST;
|
|
}
|
|
|
|
/* Check the reg test tasks are still cycling. They will stop
|
|
incrementing their loop counters if they encounter an error. */
|
|
if( usRegTest1Counter == usLastRegTest1Counter )
|
|
{
|
|
xStatusMessage.ulMessageValue = mainERROR_REG_TEST;
|
|
}
|
|
|
|
if( usRegTest2Counter == usLastRegTest2Counter )
|
|
{
|
|
xStatusMessage.ulMessageValue = mainERROR_REG_TEST;
|
|
}
|
|
|
|
usLastRegTest1Counter = usRegTest1Counter;
|
|
usLastRegTest2Counter = usRegTest2Counter;
|
|
|
|
/* This is called from a timer callback so must not block! */
|
|
xQueueSendToBack( xMsgQueue, &xStatusMessage, mainDONT_BLOCK );
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
void vApplicationTickHook( void )
|
|
{
|
|
static unsigned long ulCounter = 0;
|
|
|
|
/* Is it time to toggle the pin again? */
|
|
ulCounter++;
|
|
|
|
/* Just periodically toggle a pin to show that the tick interrupt is
|
|
running. */
|
|
if( ( ulCounter & 0xff ) == 0 )
|
|
{
|
|
gioSetBit(gioPORTA, 0, 1);
|
|
gioSetBit(gioPORTA, 0, 0);
|
|
}
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
void vApplicationMallocFailedHook( void )
|
|
{
|
|
/* Called if a call to pvPortMalloc() fails because there is insufficient
|
|
free memory available in the FreeRTOS heap. pvPortMalloc() is called
|
|
internally by FreeRTOS API functions that create tasks, queues or
|
|
semaphores. */
|
|
taskDISABLE_INTERRUPTS();
|
|
for( ;; );
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
void vApplicationStackOverflowHook( xTaskHandle *pxTask, signed char *pcTaskName )
|
|
{
|
|
/* Run time stack overflow checking is performed if
|
|
configconfigCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook
|
|
function is called if a stack overflow is detected. */
|
|
taskDISABLE_INTERRUPTS();
|
|
for( ;; );
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
void vApplicationIdleHook(void)
|
|
{
|
|
usIdleCounter++;
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|