FreeRTOS on ESP32: A Detailed Guide for Developers

Introduction to FreeRTOS on ESP32

FreeRTOS is an open-source real-time operating system (RTOS) widely used for embedded systems, including microcontrollers like the ESP32. The ESP32, developed by Espressif Systems, is a powerful dual-core processor with built-in Wi-Fi and Bluetooth, making it ideal for IoT applications. FreeRTOS allows efficient multitasking, enabling developers to run multiple tasks simultaneously while optimizing CPU and memory usage.

Why Use FreeRTOS on ESP32?

1. Multitasking Support

ESP32 has two cores (Core 0 and Core 1), and FreeRTOS can run tasks in parallel, utilizing both cores efficiently. This allows better performance and power management.

2. Task Prioritization

FreeRTOS allows developers to set priorities for tasks, ensuring that critical processes run before less important ones.

3. Low Power Consumption

Using tickless idle mode, FreeRTOS helps reduce power consumption, making ESP32 a great choice for battery-powered devices.

4. Built-in Support in ESP-IDF

Espressif provides native support for FreeRTOS in the ESP-IDF (Espressif IoT Development Framework), simplifying development.

Key Concepts in FreeRTOS for ESP32

1. Tasks

A task is an independent unit of execution in FreeRTOS. Each task has its own stack, priority, and execution state.

Example Task Creation in FreeRTOS (ESP32):

void Task1(void *pvParameters) {
    while (1) {
        printf("Task 1 is running\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main() {
    xTaskCreate(Task1, "Task1", 2048, NULL, 1, NULL);
}

• xTaskCreate() creates a task.
• 2048 defines the stack size.
• 1 sets the task priority.

2. Task Scheduling

FreeRTOS uses a preemptive scheduling model, where the highest-priority task runs first. If multiple tasks have the same priority, time-slicing is used.

3. Queues

Queues in FreeRTOS allow tasks to communicate safely. They are used for inter-task communication.

Example of Using Queues in FreeRTOS (ESP32):

QueueHandle_t myQueue;

void SenderTask(void *pvParameters) {
    int data = 100;
    while (1) {
        xQueueSend(myQueue, &data, portMAX_DELAY);
        printf("Data sent: %d\n", data);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void ReceiverTask(void *pvParameters) {
    int receivedData;
    while (1) {
        xQueueReceive(myQueue, &receivedData, portMAX_DELAY);
        printf("Data received: %d\n", receivedData);
    }
}

void app_main() {
    myQueue = xQueueCreate(5, sizeof(int));
    xTaskCreate(SenderTask, "SenderTask", 2048, NULL, 1, NULL);
    xTaskCreate(ReceiverTask, "ReceiverTask", 2048, NULL, 1, NULL);
}

4. Mutexes and Semaphores

• Mutexes are used to protect shared resources.
• Semaphores are useful for synchronizing tasks.

Example Using Mutex:

SemaphoreHandle_t mutex;

void TaskA(void *pvParameters) {
    while (1) {
        if (xSemaphoreTake(mutex, portMAX_DELAY)) {
            printf("Task A is using resource\n");
            vTaskDelay(1000 / portTICK_PERIOD_MS);
            xSemaphoreGive(mutex);
        }
    }
}

void TaskB(void *pvParameters) {
    while (1) {
        if (xSemaphoreTake(mutex, portMAX_DELAY)) {
            printf("Task B is using resource\n");
            vTaskDelay(1000 / portTICK_PERIOD_MS);
            xSemaphoreGive(mutex);
        }
    }
}

void app_main() {
    mutex = xSemaphoreCreateMutex();
    xTaskCreate(TaskA, "TaskA", 2048, NULL, 1, NULL);
    xTaskCreate(TaskB, "TaskB", 2048, NULL, 1, NULL);
}

This ensures Task A and Task B do not access the shared resource simultaneously.

Memory Management in FreeRTOS for ESP32

ESP32 has 520 KB of SRAM, and FreeRTOS provides several memory allocation strategies:

1. Heap_1 – Fixed-size allocation, no freeing of memory.
2. Heap_2 – Allows freeing but does not merge adjacent free blocks.
3. Heap_3 – Uses standard malloc/free.
4. Heap_4 – Best for ESP32, supports coalescing free blocks.

To configure memory, modify sdkconfig in ESP-IDF.

Interrupt Handling in FreeRTOS (ESP32)

ESP32 supports hardware and software interrupts, but FreeRTOS has specific rules for handling them.

• Interrupt handlers must be short and fast.
• If FreeRTOS functions are called, use IRAM_ATTR to store the ISR in RAM.

Example of an ISR in FreeRTOS (ESP32):

void IRAM_ATTR gpio_isr_handler(void* arg) {
    printf("Interrupt detected!\n");
}

void app_main() {
    gpio_install_isr_service(0);
    gpio_isr_handler_add(GPIO_NUM_4, gpio_isr_handler, NULL);
}

This handles GPIO interrupts efficiently.

Power Management with FreeRTOS

FreeRTOS helps ESP32 achieve low power consumption using the following modes:

• Light Sleep Mode – CPU pauses, but peripherals continue running.
• Deep Sleep Mode – CPU and most peripherals shut down, conserving energy.

To enable deep sleep in FreeRTOS:

void app_main() {
    printf("Entering deep sleep...\n");
    esp_deep_sleep_start();
}

This is useful for battery-powered IoT devices.

Debugging FreeRTOS on ESP32

1. Monitoring Tasks

Use vTaskList() to print active tasks:

void app_main() {
    char buffer[512];
    vTaskList(buffer);
    printf("%s\n", buffer);
}

This helps analyze CPU usage and task behavior.

2. Enabling Stack Overflow Detection

To detect stack overflows, enable:

CONFIG_FREERTOS_CHECK_STACKOVERFLOW=y

This prevents crashes due to insufficient stack size.

3. Using ESP-IDF FreeRTOS Trace Tool

ESP-IDF includes tools like SystemView for visualizing task execution and CPU usage.

Conclusion

FreeRTOS makes ESP32 a powerful platform for real-time applications, offering multitasking, synchronization, and power-saving features. Whether you're building IoT devices, automation systems, or robotics, mastering FreeRTOS on ESP32 can significantly improve system performance and efficiency.