Mastering
FreeRTOS on ESP32:
A Comprehensive
Guide for Embedded
IoT Engineers
Table of Contents
Table of Contents
1. Introduction
2. Getting Started with FreeRTOS on
ESP32
3. Tasks and Task Scheduling
4. Queues: Inter-Task Communication
5. Semaphores and Mutexes
6. Event Groups
7. Software Timers
8. Task Notifications
9. Event Loop Pattern
10.Memory Management in FreeRTOS
11.Integrating Peripherals in FreeRTOS
12.Best Practices for FreeRTOS on ESP32
13.Summary and Additional Resources
1. Introduction
1. Introduction
The ESP32 microcontroller has emerged as a
cornerstone of modern IoT development due to
its powerful dual-core CPU, rich peripheral set,
and robust support for real-time operating
systems like FreeRTOS.
This guide aims to bridge the gap between
FreeRTOS theory and practical ESP32
development, enabling embedded engineers to
build scalable, responsive, and maintainable
real-time applications.
1. Introduction
Whether you're building smart home devices,
wearable tech, or industrial monitoring systems,
mastering FreeRTOS on ESP32 is essential for
creating deterministic behavior and efficient
multitasking in your firmware.
2. Getting Started with
FreeRTOS on ESP32
2. Getting Started with FreeRTOS on
ESP32
Concept and Use CaseFree
RTOS is a real-time operating system kernel for
embedded devices that makes it easy to
manage multiple tasks efficiently. With the
ESP32's support through the ESP-IDF
framework, FreeRTOS is used for developing
real-time, concurrent, and multitasking
applications in IoT.
2. Getting Started with FreeRTOS on
ESP32
Best Practice
Set up your ESP-IDF environment correctly and
configure FreeRTOS settings such as tick rate,
timer task stack size, and core affinity to match
your application requirements.
idf.py create-project freertos_demo
cd freertos_demo
idf.py menuconfig
Enable FreeRTOS options under Component
config -> FreeRTOS. Once configured, you can
begin creating tasks, queues, and other kernel
objects directly in your application.
3. Tasks and Task
Scheduling
3. Tasks and Task Scheduling
Concept and Use Case
A task in FreeRTOS is akin to a thread in
traditional operating systems. Tasks enable
concurrent operations such as reading sensor
data while handling communication. Task
scheduling in FreeRTOS is priority-based and
preemptive by default.
Best Practice
Keep tasks short and non-blocking, assign
appropriate priorities, and ensure proper use of
delays or synchronization mechanisms to yield
CPU time.
3. Tasks and Task Scheduling
Creating a Task Code example
4. Queues: Inter-Task
Communication
4. Queues: Inter-Task
Communication
Concept and Use Case
Queues allow safe data sharing between tasks.
Each queue is a thread-safe FIFO buffer,
enabling one task to send data and another to
receive it.
Best Practice
Use queues to decouple tasks, and avoid large
queue item sizes to minimize memory usage.
Always check return values for success/failure.
4. Queues: Inter-Task
Communication
Using a Queue Code example
4. Queues: Inter-Task
Communication
5. Semaphores and
Mutexes
5. Semaphores and
Mutexes
Concept and Use Case
Semaphores are signaling mechanisms for
synchronizing tasks or ISRs with tasks. Mutexes
are binary semaphores with priority inheritance,
used to protect shared resources.
Best Practice
Use binary semaphores for signaling and
mutexes for protecting shared resources. Avoid
holding a mutex for long durations.
5. Semaphores and
Mutexes
Semaphore Code example
Semaphore Code example
5. Semaphores and
Mutexes
6. Event Groups
6. Event Groups
Concept and Use Case
Event groups manage multiple flags (bits) for
synchronizing task execution based on the
occurrence of multiple events. They are ideal for
coordinating the readiness of several
components or subsystems before proceeding.
Best Practice
Use xEventGroupWaitBits to block tasks until all
required events occur. Use pdTRUE to clear bits
upon return when the event has been handled.
Combine bits with macros for clarity.
6. Event Groups
Event Groups Code example
6. Event Groups
7. Software Timers
7. Software Timers
Concept and Use Case
Software timers allow execution of callback
functions at specified intervals, without
occupying task resources. They are well-suited
for periodic or one-shot operations like status
checks or timeout handling.
Best Practice
Avoid placing heavy operations in timer
callbacks. Use timers when execution can be
deferred or doesn't need a dedicated task.
7. Software Timers
Software Timer Code example
8. Task Notifications
8. Task Notifications
Concept and Use Case
Task notifications are optimized for lightweight
signaling between tasks. They can act as binary
semaphores, counting semaphores, or simple
event flags.
Best Practice
Use when only a single receiver task is involved.
Avoid mixing notification types for clarity and
maintainability.
8. Task Notifications
Task Notifications Code example
9. Event Loop Pattern
9. Event Loop Pattern
Concept
The event loop pattern in ESP32, when built
using the esp_event library, allows decoupled
and modular event handling across multiple
system components. Instead of manually
creating queues and writing custom
dispatchers, developers can use
esp_event_loop_create and esp_event_post to
register handlers for different event types and
IDs, creating a centralized yet extensible
architecture.
9. Task Notifications
Typical use cases include
• System-level event management (e.g., Wi-Fi,
Bluetooth, sensor states)
• Application state transitions
• Dispatching asynchronous tasks or messages
across modules
9. Task Notifications
Best Practice
• Define your event base and event IDs clearly.
• Use esp_event_handler_register to bind
specific handlers to your base and ID.
• Always check return values from
esp_event_post to avoid silent failures.
• Use lightweight handlers or defer heavy
processing to a task if needed.
Event Loop Pattern Code example
9. Task Notifications
Event Loop Pattern Code example
9. Task Notifications
9. Task Notifications
10. Memory
Management in
FreeRTOS
10. Memory Management
in FreeRTOS
Concept and Use Case
FreeRTOS dynamically allocates memory for
tasks, queues, semaphores, and other kernel
objects. On the ESP32, memory allocation is
handled through heap_caps_malloc() or
pvPortMalloc() depending on the configuration.
It's crucial to monitor heap usage in resource-
constrained environments.
10. Memory Management
in FreeRTOS
Best Practice
Always check for NULL after memory allocation.
Use static allocation if determinism is critical.
Use ESP-IDF's heap functions to monitor usage
and detect leaks.
10. Memory Management
in FreeRTOS
Code example
11. Integrating
Peripherals in
FreeRTOS
11. Integrating
Peripherals in FreeRTOS
Concept and Use Case
Integrating peripherals like UART or I2C into
FreeRTOS tasks enables concurrent and
asynchronous communication with sensors,
modules, or other MCUs. Tasks can
independently handle their peripherals without
blocking each other.
Best Practice
Initialize peripherals before starting their tasks.
Use proper synchronization mechanisms when
sharing peripherals. Avoid long blocking delays
inside ISR callbacks.
inside ISR callbacks.
11. Integrating
Peripherals in FreeRTOS
Code example
11. Integrating
Peripherals in FreeRTOS
12. Best Practices for
FreeRTOS on ESP32
12. Best Practices for
FreeRTOS on ESP32
Concept and Use Case
Following FreeRTOS best practices on ESP32
ensures system reliability, efficient memory
usage, and responsiveness in IoT systems.
Proper use of synchronization, task
management, and peripheral handling is
crucial.
12. Best Practices for
FreeRTOS on ESP32
Best Practice
• Use uxTaskGetStackHighWaterMark() to
monitor stack usage.
• Prefer static allocation for predictable
memory usage.
• Encapsulate peripheral logic inside its own
task.
• Minimize ISR execution time; defer work to
tasks.
• Use watchdog timers to catch stuck tasks.
Code example
12. Best Practices for
FreeRTOS on ESP32
Code example
13. Summary and
Additional Resources
13. Summary and Additional
Resources
FreeRTOS empowers embedded engineers to
build reliable, real-time applications on the
ESP32 platform. By leveraging its multitasking
capabilities and synchronization primitives,
developers can achieve responsive and
deterministic designs suited for a wide range of
IoT use cases.
13. Summary and Additional
Resources
Recommended Resources
ESP-IDF FreeRTOS Documentation:
https://docs.espressif.com/projects/esp-
idf/en/latest/esp32/api-
reference/system/freertos.html
FreeRTOS.org API Reference:
https://www.freertos.org/a00106.html
