freertos-dat

freeRTOS debug

Your sketch is written for ESP32 but you’re compiling it for ESP8266, and that’s why it’s failing.

Why

SemaphoreHandle_t, xSemaphoreCreateBinary(), xSemaphoreGive(), xSemaphoreTake(), and portMAX_DELAY are FreeRTOS API calls.

ESP32 Arduino comes with FreeRTOS by default.

ESP8266 Arduino does not use FreeRTOS — so those types and functions don’t exist unless you add a separate RTOS layer.

✅ When is it a Good Time to Use FreeRTOS?

FreeRTOS is a real-time operating system designed for microcontrollers. It lets you split your application into multiple tasks that run seemingly in parallel.

🧠 Use FreeRTOS When:

1. 🧵 You Need to Run Multiple Tasks Concurrently

  • Example: Reading sensor data, updating a display, and handling WiFi at the same time.
  • Each task can run independently using xTaskCreate().

2. ⏱️ You Require Real-Time Responsiveness

  • Critical tasks (e.g., handling motor feedback or interrupts) can be given higher priority.
  • Guarantees predictable response time.

3. 🕓 You Need Precise Timing or Scheduling

  • Use vTaskDelay(), xTimerCreate(), etc., to run tasks at specific intervals.
  • Better than using delay() or busy-wait loops.

4. 📶 You Have Asynchronous Events to Handle

  • Great for UART, I2C, network communication, button presses, etc.
  • Use queues, semaphores, and event groups for clean async handling.

5. 🔄 You Want to Structure a Large Project Cleanly

  • Modular task-based design.
  • Easier to manage and debug than a giant loop() function.

6. 📦 You're Using ESP32 or STM32 with Multiple Cores or Peripherals

  • ESP32 has dual-core (PRO & APP cores).
  • FreeRTOS lets you pin tasks to cores, assign priority, and manage memory better.

🧊 Not Always Necessary If:

Situation Recommendation
Simple blink or sensor reading No need for FreeRTOS
Single function, low resource Use loop() and interrupts
Ultra-low-power apps May be better without RTOS

✅ Example: Good Use Case (ESP32 with Camera, Webserver, Sensors)

  • 📷 Task 1: Camera image capture
  • 🌐 Task 2: Web server and WiFi communication
  • 🌡️ Task 3: Sensor data read and logging
  • 🎯 Task 4: OTA update check

All these tasks can run smoothly in parallel using FreeRTOS, each with its own stack and priority.

🚀 Summary

Feature Why FreeRTOS Helps
Multitasking Run multiple functions in parallel
Real-time priority Critical tasks get CPU first
Precise scheduling Timers, delays, and periodic execution
Clean architecture Organized, modular task-based design
Event handling Easy async using semaphores & queues

Let me know if you'd like a simple FreeRTOS project example!

Use FreeRTOS primitives:

Queue: for passing sensor/audio/display data between tasks

Semaphore: to lock I2C bus or protect shared resources

Timer: for periodic updates (e.g., sensor every 1s)

🧩 Inter-Task Communication

✅ 1. SSD1306 (I2C)

Use Adafruit SSD1306 or u8g2 with I2C.

Share I2C bus with BMP280.

Protect with mutex semaphore.

xSemaphoreTake(i2c_mutex, portMAX_DELAY); // update display xSemaphoreGive(i2c_mutex);

✅ 2. BMP280 Sensor (I2C)

Read temperature & pressure every 1–2 seconds.

Send data to DisplayTask via queue.

Example Queues and Semaphores:

QueueHandle_t sensor_data_queue;
QueueHandle_t display_msg_queue;
SemaphoreHandle_t i2c_mutex;

Sensor to Display Queue Message:

typedef struct {
    float temperature;
    float pressure;
} sensor_data_t

Pseudocode Overview

void SensorTask(void *pvParams) {
    sensor_data_t data;
    while (1) {
        xSemaphoreTake(i2c_mutex, portMAX_DELAY);
        data = read_bmp280();
        xSemaphoreGive(i2c_mutex);

        xQueueSend(sensor_data_queue, &data, 0);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void DisplayTask(void *pvParams) {
    sensor_data_t data;
    while (1) {
        if (xQueueReceive(sensor_data_queue, &data, portMAX_DELAY)) {
            xSemaphoreTake(i2c_mutex, portMAX_DELAY);
            update_display(data.temperature, data.pressure);
            xSemaphoreGive(i2c_mutex);
        }
    }
}

cores

xTaskCreatePinnedToCore(task1, "Task1", 2048, NULL, 1, NULL, 0);  // Run on Core 0
xTaskCreatePinnedToCore(task2, "Task2", 2048, NULL, 1, NULL, 1);  // Run on Core 1

Core 0: PRO_CPU (usually handles Wi-Fi, BT stack)

Core 1: APP_CPU (often used for your application)

compare

Feature / RTOS FreeRTOS Zephyr RTOS ThreadX (Azure RTOS) Bare-Metal (No RTOS)
License MIT (Permissive, Free) Apache 2.0 (Permissive, Free) Microsoft EULA (Free, but limited) None
Footprint Very Small (<10 KB) Medium (~50–100 KB) Small (~10–20 KB) Very Small
Real-Time Yes (preemptive, deterministic) Yes (configurable RT, preemptive) Yes (deterministic RTOS) Depends on implementation
Ease of Use Simple API, easy learning curve More complex, powerful config system Easy API, good documentation Full control but more effort
Hardware Support Very wide (ARM, RISC-V, etc.) Very wide + device trees Good (mainly ARM, RISC-V, x86) Manual per-device work
Task Management Yes (tasks, priorities) Yes (threads, priorities, SMP) Yes (threads, priorities) Manual state machine
Synchronization Semaphores, mutexes, queues Semaphores, FIFOs, message queues Semaphores, mutexes, event flags Manual implementation
File System Support External (e.g., FatFs) Native FS (e.g., LittleFS, FatFS) With Azure FileX Manual or third-party
Networking External (e.g., lwIP) Native (TCP/IP stack, 6LoWPAN) Azure NetX Duo (IPv4/IPv6) External, complex to integrate
Power Management Basic, user-implemented Advanced (built-in PM framework) Good (some MCU-specific features) Manual
Security/IoT AWS IoT support (via Amazon RTOS) Secure boot, crypto, OTA, TLS Azure IoT support, TLS, OTA Manual, very limited
Trace & Debug Tools: SystemView, Tracealyzer Zephyr logging & tracing NetX, ThreadX tracing tools Manual logging
Community Support Huge, mature ecosystem Growing fast, backed by Linux Foundation Good, backed by Microsoft None (solo dev)

simple example 1

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

void vTask1(void *pvParameters) {
    while (1) {
        printf("Task 1 running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));  // Delay 1000 ms
    }
}

void vTask2(void *pvParameters) {
    while (1) {
        printf("Task 2 running\n");
        vTaskDelay(pdMS_TO_TICKS(2000));  // Delay 2000 ms
    }
}

int main(void) {
    xTaskCreate(vTask1, "Task1", 128, NULL, 1, NULL);
    xTaskCreate(vTask2, "Task2", 128, NULL, 1, NULL);

    vTaskStartScheduler();  // Start FreeRTOS
    while (1);
}

Table of Contents

https://www.electrodragon.com