Chapter 10: The Same Thing with FreeRTOS#

Sample code#

Directory: docs/os-on-arduino/code/10_freertos

uv run pio run -d 10_freertos -t upload
uv run pio device monitor -b 115200

The real-FreeRTOS examples are in 10_freertos_real, one environment (the build configuration picked with -e) per example. Replace integrated with basic, preemptive, task_control, semaphore or queue for the others.

uv run pio run -d 10_freertos_real -e integrated -t upload

Source code#

The sketch for this chapter. Click a file name to expand. The code is mirrored automatically from the manuscript repository, so what you see here is always current.

`docs/os-on-arduino/code/10_freertos`#

src/main.cpp — 229 lines

Open on GitHub

/**
 * Chapter 10: FreeRTOS Implementation
 *
 * Demonstrates how to implement the same functionality using FreeRTOS.
 * Shows the mapping between our custom OS and FreeRTOS APIs.
 *
 * Note: Arduino Uno R4 WiFi has FreeRTOS support through Arduino_FreeRTOS library.
 * This example shows the concepts - actual FreeRTOS requires the library.
 */

#include <Arduino.h>
#include "Arduino_LED_Matrix.h"
#include "servo_pwm.h"

// This is a simplified demonstration showing FreeRTOS concepts
// For actual FreeRTOS, include <Arduino_FreeRTOS.h>

ArduinoLEDMatrix matrix;
ServoPWM servo;

// Arduino UNO R4 WiFi は基板上に "L" と印字された LED を持っています。
// 追加部品なしで動かせるよう、これを主 LED として使います。
#define LED1_PIN LED_BUILTIN
#define LED2_PIN 3
#define SERVO_PIN 9

// Simulated FreeRTOS-like API
// In real FreeRTOS, these would be the actual FreeRTOS functions

typedef void (*TaskFunction_t)(void*);

struct FakeTask {
    TaskFunction_t func;
    const char* name;
    void* param;
    unsigned long delay_until;
    bool suspended;
};

#define MAX_FAKE_TASKS 8
FakeTask fake_tasks[MAX_FAKE_TASKS];
int fake_task_count = 0;

// xTaskCreate equivalent
void xTaskCreate(TaskFunction_t func, const char* name, int stack, void* param, int priority, void* handle)
{
    if (fake_task_count < MAX_FAKE_TASKS) {
        fake_tasks[fake_task_count].func = func;
        fake_tasks[fake_task_count].name = name;
        fake_tasks[fake_task_count].param = param;
        fake_tasks[fake_task_count].delay_until = 0;
        fake_tasks[fake_task_count].suspended = false;
        fake_task_count++;
        Serial.print("[FreeRTOS] Task created: ");
        Serial.println(name);
    }
}

// vTaskDelay equivalent (simulated)
unsigned long vTaskDelay_ms = 0;
void vTaskDelay(unsigned long ticks)
{
    vTaskDelay_ms = millis() + ticks;
}

// vTaskDelayUntil equivalent
void vTaskDelayUntil(unsigned long* lastWake, unsigned long period)
{
    *lastWake += period;
    while (millis() < *lastWake) {
        // In real FreeRTOS, this would yield to scheduler
        delay(1);
    }
}

// ============================================
// FreeRTOS-style Task Implementations
// ============================================

// In real FreeRTOS, tasks are functions that never return
// and use vTaskDelay() or vTaskDelayUntil() for timing

void vTaskLED1(void* param)
{
    // Real FreeRTOS task would have:
    // while(1) {
    //     digitalWrite(LED1_PIN, !digitalRead(LED1_PIN));
    //     vTaskDelay(pdMS_TO_TICKS(200));
    // }
    (void)param;
    static bool state = false;
    state = !state;
    digitalWrite(LED1_PIN, state);
}

void vTaskLED2(void* param)
{
    (void)param;
    static bool state = false;
    state = !state;
    digitalWrite(LED2_PIN, state);
}

void vTaskServo(void* param)
{
    (void)param;
    static int angle = 0;
    angle = (angle + 10) % 180;
    servo.write(angle);
}

void vTaskSerial(void* param)
{
    (void)param;
    static int count = 0;
    Serial.print("[FreeRTOS Task] Count: ");
    Serial.println(count++);
}

void vTaskDisplay(void* param)
{
    (void)param;
    static uint8_t frame[8][12];
    static int pos = 0;

    memset(frame, 0, sizeof(frame));

    // Moving dot animation
    frame[3][pos] = 1;
    frame[4][pos] = 1;
    pos = (pos + 1) % 12;

    matrix.renderBitmap(frame, 8, 12);
}

// ============================================
// Comparison: Our OS vs FreeRTOS
// ============================================

void show_api_comparison(void)
{
    Serial.println();
    Serial.println("============================================");
    Serial.println("       Our OS  vs  FreeRTOS  Comparison");
    Serial.println("============================================");
    Serial.println();
    Serial.println("Task Creation:");
    Serial.println("  Our OS:   os_create_task(func, name, stack)");
    Serial.println("  FreeRTOS: xTaskCreate(func, name, stack, param, priority, handle)");
    Serial.println();
    Serial.println("Delay:");
    Serial.println("  Our OS:   os_sleep(ms)");
    Serial.println("  FreeRTOS: vTaskDelay(pdMS_TO_TICKS(ms))");
    Serial.println();
    Serial.println("Task Control:");
    Serial.println("  Our OS:   os_suspend_task(id) / os_resume_task(id)");
    Serial.println("  FreeRTOS: vTaskSuspend(handle) / vTaskResume(handle)");
    Serial.println();
    Serial.println("Semaphores (FreeRTOS only):");
    Serial.println("  xSemaphoreCreateBinary()");
    Serial.println("  xSemaphoreTake(sem, timeout)");
    Serial.println("  xSemaphoreGive(sem)");
    Serial.println();
    Serial.println("Queues (FreeRTOS only):");
    Serial.println("  xQueueCreate(length, itemSize)");
    Serial.println("  xQueueSend(queue, &item, timeout)");
    Serial.println("  xQueueReceive(queue, &item, timeout)");
    Serial.println();
    Serial.println("============================================");
    Serial.println();
}

// Simulated scheduler loop
unsigned long task_timers[MAX_FAKE_TASKS] = {0};
unsigned long task_periods[] = {200, 500, 100, 1000, 150};

void fake_scheduler_run(void)
{
    unsigned long now = millis();
    for (int i = 0; i < fake_task_count && i < 5; i++) {
        if (!fake_tasks[i].suspended && now - task_timers[i] >= task_periods[i]) {
            task_timers[i] = now;
            fake_tasks[i].func(fake_tasks[i].param);
        }
    }
}

void setup()
{
    Serial.begin(115200);
    while (!Serial) { }

    Serial.println();
    Serial.println("=== FreeRTOS Concepts Demo ===");
    Serial.println();
    Serial.println("This demonstrates FreeRTOS-style task creation.");
    Serial.println("Note: For actual FreeRTOS, use Arduino_FreeRTOS library.");
    Serial.println();

    // Initialize hardware
    pinMode(LED1_PIN, OUTPUT);
    pinMode(LED2_PIN, OUTPUT);
    servo.attach(SERVO_PIN);
    matrix.begin();

    // Create tasks FreeRTOS-style
    xTaskCreate(vTaskLED1, "LED1", 128, NULL, 1, NULL);
    xTaskCreate(vTaskLED2, "LED2", 128, NULL, 1, NULL);
    xTaskCreate(vTaskServo, "Servo", 256, NULL, 2, NULL);
    xTaskCreate(vTaskSerial, "Serial", 512, NULL, 1, NULL);
    xTaskCreate(vTaskDisplay, "Display", 256, NULL, 1, NULL);

    Serial.println();

    // Show API comparison
    show_api_comparison();

    Serial.println("Starting FreeRTOS-style scheduler...");
    Serial.println();

    // In real FreeRTOS, you would call: vTaskStartScheduler();
    // The scheduler never returns in FreeRTOS
}

void loop()
{
    // Simulated FreeRTOS scheduler
    fake_scheduler_run();
}

`docs/os-on-arduino/code/10_freertos_real`#

src/integrated.cpp — 103 lines

Open on GitHub

// freertos_integrated.ino（第10章 10.10 の掲載例）
#include <Arduino.h>
#include <Arduino_FreeRTOS.h>   // semphr.h などもここから取り込まれる
#include <Servo.h>

// 基板上の「L」LED。追加部品なしで動かせるようにこれを使います
#define LED_PIN LED_BUILTIN
#define SERVO_PIN 9
#define POT_PIN A0

// 共有データ
// R4 同梱の FreeRTOS はミューテックスが無効なので、
// バイナリセマフォを「1 個の鍵」として使って排他する (10.7 参照)
volatile int g_pot_value = 0;
SemaphoreHandle_t xDataMutex = NULL;

// サーボ
Servo servo;

// タスク: センサ読み取り
void task_sensor(void *pvParameters)
{
    for (;;) {
        int value = analogRead(POT_PIN);

        if (xSemaphoreTake(xDataMutex, portMAX_DELAY) == pdTRUE) {
            g_pot_value = value;
            xSemaphoreGive(xDataMutex);
        }

        vTaskDelay(pdMS_TO_TICKS(50));
    }
}

// タスク: サーボ制御
void task_servo(void *pvParameters)
{
    servo.attach(SERVO_PIN);

    for (;;) {
        int value;
        if (xSemaphoreTake(xDataMutex, portMAX_DELAY) == pdTRUE) {
            value = g_pot_value;
            xSemaphoreGive(xDataMutex);
        }

        int angle = map(value, 0, 1023, 0, 180);
        servo.write(angle);

        vTaskDelay(pdMS_TO_TICKS(20));
    }
}

// タスク: LED点滅
void task_led(void *pvParameters)
{
    pinMode(LED_PIN, OUTPUT);

    for (;;) {
        digitalWrite(LED_PIN, !digitalRead(LED_PIN));
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

// タスク: 状態表示
void task_monitor(void *pvParameters)
{
    for (;;) {
        Serial.println("=== FreeRTOS Status ===");
        Serial.print("Tick: ");
        Serial.println(xTaskGetTickCount());
        Serial.print("Free heap: ");
        Serial.println(xPortGetFreeHeapSize());
        Serial.print("Pot value: ");
        Serial.println(g_pot_value);
        Serial.println();

        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

void setup()
{
    Serial.begin(115200);
    while (!Serial) { }

    Serial.println("=== FreeRTOS Integrated Demo ===\n");

    // 排他用のバイナリセマフォを作成し、最初は「空き」にしておく
    xDataMutex = xSemaphoreCreateBinary();
    xSemaphoreGive(xDataMutex);

    // タスク作成
    xTaskCreate(task_sensor, "Sensor", 128, NULL, 2, NULL);
    xTaskCreate(task_servo, "Servo", 128, NULL, 2, NULL);
    xTaskCreate(task_led, "LED", 128, NULL, 1, NULL);
    xTaskCreate(task_monitor, "Monitor", 256, NULL, 1, NULL);

    // スケジューラ開始
    vTaskStartScheduler();
}

void loop() { }

On the board#

../_images/ch10_freertos.gif — `10_freertos` running with the monitor open. The tasks are written against a FreeRTOS-style API (`xTaskCreate` and so on) and run by a simple scheduler inside `loop()`; the `[FreeRTOS Task]` task increments `Count` once a second.#

../_images/ch10_freertos_real.gif — The real-FreeRTOS `integrated` example, flashed with `uv run pio run -d 10_freertos_real -e integrated -t upload` (`-e` names an environment, i.e. a build configuration, in platformio.ini). Every 2 s it prints the FreeRTOS tick count, the free heap and the A0 reading. With nothing connected to A0, `Pot value` floats around 200; with a potentiometer it follows the knob (0–1023).#

Pitfalls#

(Collected from reader questions — ask via GitHub Issues.)