Building a Real-Time Embedded System with FreeRTOS on Arduino Mega

Introduction to Real-Time Operating Systems with FreeRTOS

Real-time operating systems (RTOS) are essential for embedded systems that require precise timing and multitasking. In this tutorial, you will learn how to set up FreeRTOS on an Arduino Mega, create multiple tasks, and integrate sensors and actuators for a creative project. FreeRTOS is a popular open-source RTOS that provides preemptive scheduling, making it ideal for applications like robotics, IoT devices, and interactive gaming peripherals. By the end of this guide, you'll be able to apply FreeRTOS to build a reliable embedded system that handles multiple tasks simultaneously without timing glitches.

Setting Up FreeRTOS on Arduino Mega

To begin, download the official FreeRTOS library for Arduino from the Canvas files provided in your lab. Use the manual installation method: unzip the folder and copy it into your Arduino libraries directory. After installation, open the Arduino IDE and verify that the library appears under Sketch > Include Library. Next, download the demo application blink_analogRead474.ino. This example demonstrates two tasks: one blinks the built-in LED, and another reads an analog input from a thumbstick or potentiometer.

Connecting the Analog Thumbstick

Plug your analog thumbstick or potentiometer into an analog pin (e.g., A0). The thumbstick outputs a voltage between 0 and 5V, which the Arduino's ADC converts to a value between 0 and 1023. Modify the demo code to use the same analog pin you connected. Ensure the Serial Monitor baud rate matches the one in the code (usually 115200). Upload the sketch and verify that the LED blinks and analog values print to the Serial Monitor. When you move the thumbstick, the values should change smoothly.

Creating Multiple Tasks in FreeRTOS

In Part I of the lab, you need to run four tasks simultaneously. The first two are from the demo: Task 1 blinks the onboard LED, and Task 2 reads the analog input. Now add Task 3: flash an off-board LED with a 100ms ON time and 200ms OFF time. Connect an external LED with a current-limiting resistor to a digital pin (e.g., pin 9). In your code, create a new task function that toggles the pin using digitalWrite() and delays with vTaskDelay(). For example:

void Task3(void *pvParameters) {
  pinMode(9, OUTPUT);
  while(1) {
    digitalWrite(9, HIGH);
    vTaskDelay(100 / portTICK_PERIOD_MS);
    digitalWrite(9, LOW);
    vTaskDelay(200 / portTICK_PERIOD_MS);
  }
}

Task 4 is more advanced: configure Timer 4 to play a song (like the Mario theme) on a speaker. Use the same melody code from Lab 3, but now run it as a FreeRTOS task. The song should play three times with a 1.5-second pause between repetitions, then the task should delete itself. To stop the task, call vTaskDelete(NULL) after the third playback. Remember to use vTaskDelay() for timing instead of delay() to avoid blocking other tasks.

Integrating a Creative Project with FreeRTOS

Part II of the lab challenges you to design a project that solves a real-world problem or entertains. Your project must include at least one task running at 50 Hz or faster (period ≤ 20 ms). For example, you could build a reaction time game: use a button as input, an LED as output, and a buzzer for sound. The system measures how quickly a user presses the button after a random delay. This requires precise timing, which FreeRTOS provides. Another idea is a digital anemometer using a hall effect sensor and a magnet on a fan. The sensor triggers an interrupt, and a task calculates RPM every 20 ms. You can display the speed on an LCD or send it to a computer via Serial.

Example Project: Speed-Reading Display

Imagine you are building a device that measures the rotation speed of a fan and displays it on a 7-segment display. Use a hall effect sensor to detect each revolution. In FreeRTOS, create a high-priority task that reads the sensor every 10 ms (100 Hz). Use an interrupt to count revolutions, and the task calculates RPM. A second task updates the display every 100 ms. This project demonstrates reliable timing and high CPU load, meeting the lab criteria. You can also add a third task that logs data to an SD card or sends it via Bluetooth to a smartphone app, similar to how fitness trackers monitor cadence.

Testing and Debugging Your FreeRTOS System

After implementing your tasks, test the system thoroughly. Use the Serial Monitor to print debug messages from each task. Ensure that the LED blinks correctly, the analog readings are stable, and the song plays exactly three times. For the project, verify that the high-speed task runs without jitter. You can measure task timing by toggling a spare pin and observing it on an oscilloscope. If you encounter issues like tasks not running or timing errors, check the stack sizes: FreeRTOS tasks need sufficient stack space. Increase the stack size in xTaskCreate() if you see crashes. Also, avoid using delay() inside tasks; always use vTaskDelay() to yield control to the scheduler.

Conclusion

In this tutorial, you learned how to set up FreeRTOS on Arduino Mega, create multiple tasks for LED blinking, analog reading, and song playback, and integrate them into a creative real-time project. FreeRTOS enables you to build complex embedded systems that are reliable and responsive. Whether you are developing a gaming controller, a weather station, or an industrial controller, the skills you gained here are directly applicable. As you continue, explore more FreeRTOS features like queues, semaphores, and mutexes to communicate between tasks and share resources safely. Happy coding!