FreeRTOS Daemon On C89 | The sibexico databank

August was very busy for me so it was no publications here… Need to fix it then, let’s make a daemon for the FreeRTOS and understand how it works! :)

First things first, let’s understand core concepts of the FreeRTOS:

Standard language for FreeRTOS which is used by most developers is C89.
In the daemon we need to have a blocking calls to allow other tasks to run.
The daemon is based on an infinite loop that will make our task running forever.

First we will include all necessary headers for our daemon:

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include <stdio.h>

Then we define a handle for our daemon task and the queue for inter-task communication if necessary:

TaskHandle_t xDaemonTaskHandle = NULL;
QueueHandle_t xDaemonQueue = NULL;

Next, create a task, which will run on our daemon. In will be a function with an infinite loop inside:

void vDaemonTask(void *pvParameters){
    const TickType_t xDelayTime = pdMS_TO_TICKS(1000);   
    (void)pvParameters;
    printf("Daemon task has started.\n");

    for (;;){
        printf("Daemon task is active...\n");
        vTaskDelay(xDelayTime);
    }
    vTaskDelete(NULL);
}

As you can see, this task doesn’t have any useful payload. It will just print string of the text. But let’s talk about the code anyway.

const TickType_t xDelayTime = pdMS_TO_TICKS(1000);

Here we determine delay for our ticks.

printf("Daemon task is active...\n");

This is all the logic of our function, it will not do nothing else but print the string.

vTaskDelay(xDelayTime)

This is an interesting part of our task function. I already said about the blocking call inside the loop above and it’s few ways how we can do it:

A fixed delay (our case): vTaskDelay()
Waiting in a semaphore: xSemaphoreTake()
Waiting for a message in a queue: xQueueReceive() In this example we just using a simplest way with predetermined fixed delay between ticks.

vTaskDelete(NULL);

Normally this part of the code NEVER shouldn’t be reached if everything works well. If something went wrong and our infinite loop ends, the task should be deleted.

So now we have complete function with our simple task. Just need to handle it correctly for make our daemon works.

int main(void){  
    xTaskCreate(vDaemonTask, "Daemon", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, xDaemonTaskHandle);
    xDaemonQueue = xQueueCreate(10, sizeof(int));
    vTaskStartScheduler();
    for(;;) {}
    return 0;
}

In the xTaskCreate() we have next parameters:

Pointer to our task function.
Name (just for description) of our task
Size of a stack for our task.
Pointer for the parameters of the task, does not apply in our example.
Priority of the task.
Handle to the created task.

xDaemonQueue = xQueueCreate(10, sizeof(int));

This will create a queue for our task with size of 10 to receive messages.

vTaskStartScheduler();

Starting the scheduler.

for(;;) {}

The program should never reach this place. Have to handle it correctly in production.

And complete code of our daemon will look like this:

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include <stdio.h>

TaskHandle_t xDaemonTaskHandle = NULL;
QueueHandle_t xDaemonQueue = NULL;

void vDaemonTask(void *pvParameters){
    const TickType_t xDelayTime = pdMS_TO_TICKS(1000); 
    (void)pvParameters;

    printf("Daemon task has started.\n");

    for (;;){
        printf("Daemon task is active...\n");
        vTaskDelay(xDelayTime);
    }
    vTaskDelete(NULL);
}

int main(void){    
    xTaskCreate(vDaemonTask, "Daemon", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, &xDaemonTaskHandle);  
    xDaemonQueue = xQueueCreate(10, sizeof(int));

    vTaskStartScheduler();

    for(;;) {}
    return 0;
}

That’s all, we made our own daemon. C is a simple and beautiful language, I really like it. Even in the modern world it works awesome and gives you unlimited opportunities to create whatever you want. Even with the old C89 standard.