Embedded Systems & Software Advanced 25 min

Deterministic Multitasking Architecture with FreeRTOS Kernel

Design a hard real-time multitasking firmware architecture on ESP32 / ARM Cortex-M utilizing preemptive priority scheduling, mutexes, and queues.

2. Prerequisites & Background Theory:

C pointers, context switching, stack frame layouts, memory alignment, and interrupt service routines (ISRs).

STEP 1

Goal & Engineering Objectives

Architect a deterministic embedded firmware framework where high-priority safety tasks meet strict sub-millisecond deadlines while non-blocking background telemetry runs concurrently.

STEP 2

Governing Mathematical Formulation & Physics

                  Rate Monotonic Scheduling (RMS):
Tasks with shorter periods must be assigned higher static priorities. The upper bound on CPU utilization ensuring all tasks meet deadlines is:
$$U = \sum_{i=1}^{n} \frac{C_i}{T_i} \le n \left( 2^{1/n} - 1 \right)$$

Priority Inversion Mitigation:
When a low-priority task holds a shared resource needed by a high-priority task, a medium-priority task can starve both. FreeRTOS Mutexes implement Priority Inheritance, temporarily elevating the lock holder's priority to unblock the high-priority task.                

STEP 3

System Architecture & Block Flow Diagram

[Core 0: Control Loop Task (Priority 5, Period 10ms)] <--- Hard Real-Time
                     |
        [FreeRTOS Thread-Safe Queue]
                     |
                     v
[Core 1: Sensor Sampling Task (Priority 3, Period 20ms)]
[Core 1: Telemetry WiFi Stream (Priority 1, Background)]
                     |
          [Shared Hardware Mutex (I2C Bus Lock)]

STEP 4

Required Hardware Bill of Materials (BOM)

Hardware Component	Qty	Engineering Specification
ESP32 Dual-Core Xtensa LX6 Microcontroller	1	240 MHz, 520 KB SRAM, FreeRTOS native SMP support
I2C Sensor (BME280 or MPU6050)	1	Shared hardware peripheral demonstrating mutex arbitration
Dual LEDs with 330Ω Resistors	2	Visual task heartbeats on oscilloscope logic analyzer

Look up component pinouts in Components Catalog →

STEP 5

Wiring, Pinout & Schematics Mapping

                  • ESP32 GPIO 18 -> Status LED 1 (Hard Real-Time Control Indicator)
• ESP32 GPIO 19 -> Status LED 2 (Telemetry Heartbeat Indicator)
• ESP32 GPIO 21 (SDA) -> Sensor SDA
• ESP32 GPIO 22 (SCL) -> Sensor SCL
• Connect 3.3V and GND power rails to breadboard.                

STEP 6

Firmware Implementation & Algorithms

// FreeRTOS Priority Inheritance & Inter-Task Queue Architecture (C++)
#include <Arduino.h>

struct TelemetryPacket {
    uint32_t timestamp_ms;
    float control_effort;
    float sensor_reading;
};

QueueHandle_t xTelemetryQueue;
SemaphoreHandle_t xI2CMutex;

void TaskFastControl(void *pvParameters) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xFrequency = pdMS_TO_TICKS(10); // Strict 10ms (100Hz)

    for (;;) {
        // High-Priority Control Math
        float feedback = 0.0f;
        if (xSemaphoreTake(xI2CMutex, pdMS_TO_TICKS(2)) == pdTRUE) {
            feedback = 3.3f * (analogRead(34) / 4095.0f);
            xSemaphoreGive(xI2CMutex);
        }

        TelemetryPacket pkt;
        pkt.timestamp_ms = millis();
        pkt.control_effort = feedback * 1.5f;
        pkt.sensor_reading = feedback;

        // Post to queue without blocking
        xQueueSend(xTelemetryQueue, &pkt, 0);

        vTaskDelayUntil(&xLastWakeTime, xFrequency); // Jitter-free delay
    }
}

void TaskBackgroundTelemetry(void *pvParameters) {
    TelemetryPacket rxPkt;
    for (;;) {
        // Block until a telemetry packet arrives
        if (xQueueReceive(xTelemetryQueue, &rxPkt, portMAX_DELAY) == pdTRUE) {
            Serial.printf("[RTOS Telemetry @ %lu ms] Control: %.2f | Sensor: %.2f V\n",
                          rxPkt.timestamp_ms, rxPkt.control_effort, rxPkt.sensor_reading);
        }
    }
}

void setup() {
    Serial.begin(115200);
    xTelemetryQueue = xQueueCreate(16, sizeof(TelemetryPacket));
    xI2CMutex = xSemaphoreCreateMutex();

    // Pin critical task to Core 0 with Priority 5
    xTaskCreatePinnedToCore(TaskFastControl, "ControlTask", 2048, NULL, 5, NULL, 0);
    // Pin background task to Core 1 with Priority 1
    xTaskCreatePinnedToCore(TaskBackgroundTelemetry, "TelemTask", 3072, NULL, 1, NULL, 1);
}

void loop() {
    vTaskDelete(NULL); // Delete setup thread; RTOS scheduler runs the rest
}

Simulate and Edit in Coding Lab

STEP 7

Bench Testing & Waveform Verification

                  1. Connect logic analyzer to GPIO 18 (toggled inside Control Task): Verify period is exactly 10.00 ms ± 1.5 µs.
2. Introduce artificial 25 ms delay in telemetry task: Verify high-priority control loop timing is unaffected.
3. Query uxTaskGetStackHighWaterMark(): Verify all tasks maintain at least 300 words of unused stack head-room.                

STEP 8

Troubleshooting & Common Failure Modes

                  • Problem: MCU crashes with Guru Meditation Error (LoadProhibited).
  Solution: Stack overflow. Increase task stack allocation in xTaskCreate (e.g. from 2048 to 4096 bytes).
• Problem: High priority task misses deadlines intermittently.
  Solution: Priority Inversion without mutex protection. A low priority task is blocking the shared bus. Use xSemaphoreCreateMutex() which includes priority inheritance.
• Problem: vTaskDelay() produces timing jitter.
  Solution: vTaskDelay() provides a relative delay from the moment it is called. Replace with vTaskDelayUntil() to guarantee absolute periodic pacing.                

STEP 9

Extensions & Undergraduate Research Challenges

                  1. Implement FreeRTOS Event Groups for synchronized multi-sensor trigger broadcasts.
2. Add FreeRTOS Runtime Statistics tracking CPU percentage utilization per task over serial telemetry.                