Quality RTOS & Embedded Software

 Real time embedded FreeRTOS RSS feed 
Real time embedded FreeRTOS mailing list 
Quick Start Supported MCUs PDF Books Trace Tools Ecosystem TCP & FAT Training

Hardware independent FreeRTOS example

[See also the Quick Start Guide, and the Getting Started With Simple FreeRTOS Projects documentation page.]


The RTOS download includes a lot of example projects that are pre-configured to work "out of the box". This is to ensure users can get a working RTOS project running on real hardware in a very short time. It is however impossible to support every combination of microcontroller, compiler and development board, and we are often asked to provide an example that does not rely on any of these variables. The code provided on this page is provided for that purpose. The simplicity of the code means it also serves as a good starter project for people who are not yet familiar with FreeRTOS.

The source code does not access any hardware specific IO. For example, it just increments variables instead of attempting to toggle an LED. However, unlike the pre-packaged examples, it does required the user to create their own compiler project. That involves:

  1. Starting with a working (non RTOS) project to ensure the correct start up files and linker scripts are being used.

  2. Including the correct RTOS source files. Use existing official RTOS demo projects as a reference.

  3. Including the correct compiler include paths, which must include the RTOS kernel header files (FreeRTOS/Source/include in the RTOS download) and the portable layer header file (FreeRTOS/Source/[compiler]/[architecture]/portmacro.h in the RTOS download).

  4. Defining a FreeRTOSConfig.h file - or at least - copying a FreeRTOSConfig.h from an official RTOS demo that closely matches the project being created.

See the Creating a New FreeRTOS Project documentation for more information.

Hardware Independent RTOS Demo Functionality

Here is a description of the example's functionality:

The main() Function

main() creates the tasks and software timers described in this section, before starting the scheduler.

The Queue Send task

The queue send task is implemented by the prvQueueSendTask() function. The task uses the FreeRTOS vTaskDelayUntil() and xQueueSend() API functions to periodically send the number 100 on a queue. The period is set to 200ms. See the comments in the function for more details.

The Queue Receive task

The queue receive task is implemented by the prvQueueReceiveTask() function. The task uses the FreeRTOS xQueueReceive() API function to receive values from a queue. The values received are those sent by the queue send task. The queue receive task increments the ulCountOfItemsReceivedOnQueue variable each time it receives the value 100. Therefore, as values are sent to the queue every 200ms, the value of ulCountOfItemsReceivedOnQueue will increase by 5 every second.

An example software timer

A software timer is created with an auto reloading period of 1000ms. The timer's callback function increments the ulCountOfTimerCallbackExecutions variable each time it is called. Therefore the value of ulCountOfTimerCallbackExecutions will count seconds.

The FreeRTOS RTOS tick hook (or callback) function

The tick hook function executes in the context of the FreeRTOS tick interrupt. The function 'gives' a semaphore every 500th time it executes. The semaphore is used to synchronise with the event semaphore task, which is described next. In this example, the tick interrupt is used in preference of an interrupt generated by a peripheral to ensure the hardware neutrality is maintained.

The event semaphore task

The event semaphore task uses the FreeRTOS xSemaphoreTake() API function to wait for the semaphore that is given by the RTOS tick hook function. The task increments the ulCountOfReceivedSemaphores variable each time the semaphore is received. As the semaphore is given every 500ms (assuming a tick frequency of 1KHz), the value of ulCountOfReceivedSemaphores will increase by 2 each second.

NOTE: A semaphore is used for example purposes. In a real application it might be preferable to use a direct to task notification, which will be faster and use less RAM.

The idle hook (or callback) function

The idle hook function queries the amount of free FreeRTOS heap space available. See vApplicationIdleHook() in the code.

The malloc failed and stack overflow hook (or callback) functions

These two hook functions are provided as examples, but do not contain any functionality.

Source Code

Search for TODO in the source files for places where modifications might be required.
/* Kernel includes. */
#include "FreeRTOS.h" /* Must come first. */
#include "task.h"     /* RTOS task related API prototypes. */
#include "queue.h"    /* RTOS queue related API prototypes. */
#include "timers.h"   /* Software timer related API prototypes. */
#include "semphr.h"   /* Semaphore related API prototypes. */

/* TODO Add any manufacture supplied header files can be included
here. */
#include "hardware.h"

/* Priorities at which the tasks are created.  The event semaphore task is
given the maximum priority of ( configMAX_PRIORITIES - 1 ) to ensure it runs as
soon as the semaphore is given. */
#define mainQUEUE_SEND_TASK_PRIORITY        ( tskIDLE_PRIORITY + 1 )

/* The rate at which data is sent to the queue, specified in milliseconds, and
converted to ticks using the pdMS_TO_TICKS() macro. */
#define mainQUEUE_SEND_PERIOD_MS            pdMS_TO_TICKS( 200 )

/* The period of the example software timer, specified in milliseconds, and
converted to ticks using the pdMS_TO_TICKS() macro. */
#define mainSOFTWARE_TIMER_PERIOD_MS        pdMS_TO_TICKS( 1000 )

/* The number of items the queue can hold.  This is 1 as the receive task
has a higher priority than the send task, so will remove items as they are added,
meaning the send task should always find the queue empty. */
#define mainQUEUE_LENGTH                    ( 1 )


 * TODO: Implement this function for any hardware specific clock configuration
 * that was not already performed before main() was called.
static void prvSetupHardware( void );

 * The queue send and receive tasks as described in the comments at the top of
 * this file.
static void prvQueueReceiveTask( void *pvParameters );
static void prvQueueSendTask( void *pvParameters );

 * The callback function assigned to the example software timer as described at
 * the top of this file.
static void vExampleTimerCallback( TimerHandle_t xTimer );

 * The event semaphore task as described at the top of this file.
static void prvEventSemaphoreTask( void *pvParameters );


/* The queue used by the queue send and queue receive tasks. */
static QueueHandle_t xQueue = NULL;

/* The semaphore (in this case binary) that is used by the FreeRTOS tick hook
 * function and the event semaphore task.
static SemaphoreHandle_t xEventSemaphore = NULL;

/* The counters used by the various examples.  The usage is described in the
 * comments at the top of this file.
static volatile uint32_t ulCountOfTimerCallbackExecutions = 0;
static volatile uint32_t ulCountOfItemsReceivedOnQueue = 0;
static volatile uint32_t ulCountOfReceivedSemaphores = 0;


int main(void)
TimerHandle_t xExampleSoftwareTimer = NULL;

    /* Configure the system ready to run the demo.  The clock configuration
    can be done here if it was not done before main() was called. */

    /* Create the queue used by the queue send and queue receive tasks. */
    xQueue = xQueueCreate(     /* The number of items the queue can hold. */
                            /* The size of each item the queue holds. */
                            sizeof( uint32_t ) );

    /* Create the semaphore used by the FreeRTOS tick hook function and the
    event semaphore task.  NOTE: A semaphore is used for example purposes,
    using a direct to task notification will be faster! */
    xEventSemaphore = xSemaphoreCreateBinary();

    /* Create the queue receive task as described in the comments at the top
    of this file. */
    xTaskCreate(     /* The function that implements the task. */
                    /* Text name for the task, just to help debugging. */
                    ( signed char * ) "Rx",
                    /* The size (in words) of the stack that should be created
                    for the task. */
                    /* A parameter that can be passed into the task.  Not used
                    in this simple demo. */
                    /* The priority to assign to the task.  tskIDLE_PRIORITY
                    (which is 0) is the lowest priority.  configMAX_PRIORITIES - 1
                    is the highest priority. */
                    /* Used to obtain a handle to the created task.  Not used in
                    this simple demo, so set to NULL. */
                    NULL );

    /* Create the queue send task in exactly the same way.  Again, this is
    described in the comments at the top of the file. */
    xTaskCreate(     prvQueueSendTask,
                    ( signed char * ) "TX",
                    NULL );

    /* Create the task that is synchronised with an interrupt using the
    xEventSemaphore semaphore. */
    xTaskCreate(     prvEventSemaphoreTask,
                    ( signed char * ) "Sem",
                    NULL );

    /* Create the software timer as described in the comments at the top of
    this file. */
    xExampleSoftwareTimer = xTimerCreate(     /* A text name, purely to help
                                            debugging. */
                                            ( const signed char * ) "LEDTimer",
                                            /* The timer period, in this case
                                            1000ms (1s). */
                                            /* This is a periodic timer, so
                                            xAutoReload is set to pdTRUE. */
                                            /* The ID is not used, so can be set
                                            to anything. */
                                            ( void * ) 0,
                                            /* The callback function that switches
                                            the LED off. */

    /* Start the created timer.  A block time of zero is used as the timer
    command queue cannot possibly be full here (this is the first timer to
    be created, and it is not yet running). */
    xTimerStart( xExampleSoftwareTimer, 0 );

    /* Start the tasks and timer running. */

    /* If all is well, the scheduler will now be running, and the following line
    will never be reached.  If the following line does execute, then there was
    insufficient FreeRTOS heap memory available for the idle and/or timer tasks
    to be created.  See the memory management section on the FreeRTOS web site
    for more details.  */
    for( ;; );

static void vExampleTimerCallback( TimerHandle_t xTimer )
    /* The timer has expired.  Count the number of times this happens.  The
    timer that calls this function is an auto re-load timer, so it will
    execute periodically. */

static void prvQueueSendTask( void *pvParameters )
TickType_t xNextWakeTime;
const uint32_t ulValueToSend = 100UL;

    /* 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.
        The block time is specified in ticks, the constant used converts ticks
        to ms.  The task will not consume any CPU time while it is in the
        Blocked state. */
        vTaskDelayUntil( &xNextWakeTime, mainQUEUE_SEND_PERIOD_MS );

        /* Send to the queue - causing the queue receive task to unblock and
        increment its counter.  0 is used as the block time so the sending
        operation will not block - it shouldn't need to block as the queue
        should always be empty at this point in the code. */
        xQueueSend( xQueue, &ulValueToSend, 0 );

static void prvQueueReceiveTask( void *pvParameters )
uint32_t ulReceivedValue;

    for( ;; )
        /* Wait until something arrives in the queue - this task will block
        indefinitely provided INCLUDE_vTaskSuspend is set to 1 in
        FreeRTOSConfig.h. */
        xQueueReceive( xQueue, &ulReceivedValue, portMAX_DELAY );

        /*  To get here something must have been received from the queue, but
        is it the expected value?  If it is, increment the counter. */
        if( ulReceivedValue == 100UL )
            /* Count the number of items that have been received correctly. */

static void prvEventSemaphoreTask( void *pvParameters )
    for( ;; )
        /* Block until the semaphore is 'given'.  NOTE:
        A semaphore is used for example purposes.  In a real application it might
        be preferable to use a direct to task notification, which will be faster
        and use less RAM. */
        xSemaphoreTake( xEventSemaphore, portMAX_DELAY );

        /* Count the number of times the semaphore is received. */

void vApplicationTickHook( void )
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
static uint32_t ulCount = 0;

    /* The RTOS tick hook function is enabled by setting configUSE_TICK_HOOK to
    1 in FreeRTOSConfig.h.

    "Give" the semaphore on every 500th tick interrupt. */
    if( ulCount >= 500UL )
        /* This function is called from an interrupt context (the RTOS tick
        interrupt),    so only ISR safe API functions can be used (those that end
        in "FromISR()".

        xHigherPriorityTaskWoken was initialised to pdFALSE, and will be set to
        pdTRUE by xSemaphoreGiveFromISR() if giving the semaphore unblocked a
        task that has equal or higher priority than the interrupted task.
        NOTE: A semaphore is used for example purposes.  In a real application it
        might be preferable to use a direct to task notification,
        which will be faster and use less RAM. */
        xSemaphoreGiveFromISR( xEventSemaphore, &xHigherPriorityTaskWoken );
        ulCount = 0UL;

    /* If xHigherPriorityTaskWoken is pdTRUE then a context switch should
    normally be performed before leaving the interrupt (because during the
    execution of the interrupt a task of equal or higher priority than the
    running task was unblocked).  The syntax required to context switch from
    an interrupt is port dependent, so check the documentation of the port you
    are using.

    In this case, the function is running in the context of the tick interrupt,
    which will automatically check for the higher priority task to run anyway,
    so no further action is required. */

void vApplicationMallocFailedHook( void )
    /* The malloc failed hook is enabled by setting
    configUSE_MALLOC_FAILED_HOOK to 1 in FreeRTOSConfig.h.

    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, software
    timers, and semaphores.  The size of the FreeRTOS heap is set by the
    configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */
    for( ;; );

void vApplicationStackOverflowHook( TaskHandle_t xTask, signed char *pcTaskName )
    ( void ) pcTaskName;
    ( void ) xTask;

    /* 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.  pxCurrentTCB can be
    inspected in the debugger if the task name passed into this function is
    corrupt. */
    for( ;; );

void vApplicationIdleHook( void )
volatile size_t xFreeStackSpace;

    /* The idle task hook is enabled by setting configUSE_IDLE_HOOK to 1 in

    This function is called on each cycle of the idle task.  In this case it
    does nothing useful, other than report the amount of FreeRTOS heap that
    remains unallocated. */
    xFreeStackSpace = xPortGetFreeHeapSize();

    if( xFreeStackSpace > 100 )
        /* By now, the kernel has allocated everything it is going to, so
        if there is a lot of heap remaining unallocated then
        the value of configTOTAL_HEAP_SIZE in FreeRTOSConfig.h can be
        reduced accordingly. */

static void prvSetupHardware( void )
    /* Ensure all priority bits are assigned as preemption priority bits
    if using a ARM Cortex-M microcontroller. */
    NVIC_SetPriorityGrouping( 0 );

    /* TODO: Setup the clocks, etc. here, if they were not configured before
    main() was called. */

[ Back to the top ]    [ About FreeRTOS ]    [ Sitemap ]    [ ]

Copyright (C) 2004-2010 Richard Barry. Copyright (C) 2010-2016 Real Time Engineers Ltd.
Any and all data, files, source code, html content and documentation included in the FreeRTOSTM distribution or available on this site are the exclusive property of Real Time Engineers Ltd.. See the files license.txt (included in the distribution) and this copyright notice for more information. FreeRTOSTM and FreeRTOS.orgTM are trade marks of Real Time Engineers Ltd.

Latest News:

FreeRTOS V9.0.0 is now available for download.

Free TCP/IP and file system demos for the RTOS

Sponsored Links

⇓ Now With No Code Size Limit! ⇓
⇑ Free Download Without Registering ⇑

FreeRTOS Partners

ARM Connected RTOS partner for all ARM microcontroller cores

Renesas Electronics Gold Alliance RTOS Partner.jpg

Microchip Premier RTOS Partner

RTOS partner of NXP for all NXP ARM microcontrollers

Atmel RTOS partner supporting ARM Cortex-M3 and AVR32 microcontrollers

STMicro RTOS partner supporting ARM7, ARM Cortex-M3, ARM Cortex-M4 and ARM Cortex-M0

Xilinx Microblaze and Zynq partner

Silicon Labs low power RTOS partner

Altera RTOS partner for Nios II and Cortex-A9 SoC

Freescale Alliance RTOS Member supporting ARM and ColdFire microcontrollers

Infineon ARM Cortex-M microcontrollers

Texas Instruments MCU Developer Network RTOS partner for ARM and MSP430 microcontrollers

Cypress RTOS partner supporting ARM Cortex-M3

Fujitsu RTOS partner supporting ARM Cortex-M3 and FM3

Microsemi (previously Actel) RTOS partner supporting ARM Cortex-M3

Atollic Partner

IAR Partner

Keil ARM Partner

Embedded Artists