Introducing RTOS with stm32

Learn how to implement a Real-Time Operating System (RTOS) with STM32 microcontrollers using STM32CubeIDE. This article includes an example code for blinking LEDs using FreeRTOS on an STM32 board, making it a great starting point for beginners to learn RTOS with STM32.

Disclaimer:

Handling electricity carries inherent risks. It’s essential to have the appropriate skills to manage it safely. Proceed at your own risk, as the author disclaims responsibility for any misuse, harm, or errors. All content on this website is unique and copyrighted; please avoid unauthorized copying. While most articles are open-source for your benefit, feel free to use the knowledge provided. If you find our resources helpful, consider purchasing available materials to support our work.

For assistance or guidance, leave a comment below; the author is committed to helping. Some articles may contain affiliate links that support the author with a commission at no additional cost to you. Thank you for your understanding and support.

Introduction to RTOS on STM32 Microcontrollers:

Real-time operating systems (RTOS) are essential for many embedded systems, including those based on STM32 microcontrollers. An RTOS provides a task-based approach to software design, allowing multiple tasks to run concurrently while ensuring that each task has access to the necessary resources and executes within a specified time frame. In this article, we will explore the basics of RTOS on STM32 microcontrollers, including why an RTOS is necessary, how it works, and some of the popular RTOS options for STM32 development.

Why Use an RTOS on STM32 Microcontrollers?

STM32 microcontrollers are powerful devices that can perform multiple tasks simultaneously. However, without an RTOS, managing these tasks can be challenging. For example, consider an application that needs to perform the following tasks:

• Read data from a sensor
• Display the data on an LCD screen
• Transmit the data over a network

Without an RTOS, the application would need to execute these tasks sequentially, meaning that the system would not be responsive to external events during the execution of each task. This could result in missed events or delayed responses, leading to poor performance or even system failure.

In contrast, an RTOS allows the tasks to execute concurrently, ensuring that each task has access to the necessary resources and executes within a specified time frame. This approach leads to better system performance, responsiveness, and reliability, making it an essential tool for STM32 development.

How Does an RTOS Work on STM32 Microcontrollers?

RTOS works by dividing the application into multiple tasks, each with its own set of resources and execution time requirements. The tasks are managed by the RTOS kernel, which schedules them based on their priority and execution time. The kernel also ensures that tasks do not interfere with each other by providing mutual exclusion mechanisms such as semaphores and mutexes.

The RTOS kernel also manages the interrupts generated by the system, ensuring that they are processed correctly and that they do not interfere with the ongoing tasks. This is critical for embedded systems where real-time response is essential, such as in control systems or medical devices.

Popular RTOS Options for STM32 Microcontrollers:

There are several RTOS options available for STM32 microcontrollers, each with its own strengths and weaknesses. Let’s take a look at some of the popular options:

1. FreeRTOS

FreeRTOS is a popular open-source RTOS for STM32 development, with a large and active community of users and developers. It provides a lightweight and efficient kernel that can run on many different microcontrollers, including STM32.

FreeRTOS is easy to use and comes with a range of features, including task scheduling, semaphores, and mutexes. It also provides excellent debugging support, with tools such as trace recording and visualization.

2. CMSIS-RTOS

CMSIS-RTOS is a lightweight and efficient RTOS that is part of the Cortex Microcontroller Software Interface Standard (CMSIS). It provides a simple and standardized API for managing tasks and resources, making it easy to use and portable across different microcontrollers.

CMSIS-RTOS also provides excellent tool support, with a range of development and debugging tools available. It is a popular choice for STM32 development, with many STM32 development boards and tools supporting CMSIS-RTOS out of the box.

3. ChibiOS/RT

ChibiOS/RT is an open-source RTOS designed specifically for embedded systems, including those based on STM32 microcontrollers. It provides a range of features, including task scheduling, inter-task communication, and memory management.

ChibiOS/RT also provides excellent tool support, with a range of development and debugging tools available. It is a popular choice for STM32 development,

Example code for RTOS with STM32 in STM32CubeIDE:

Before we start, make sure that you have installed the necessary software, including STM32CubeIDE, and that you have selected an appropriate STM32 development board.

Example Code: Blinking LED using FreeRTOS on STM32:

In this example, we will use FreeRTOS to create two tasks that blink two LEDs on the STM32 development board. The first task blinks LED1 at a rate of 500ms, while the second task blinks LED2 at a rate of 1000ms. The two tasks will run concurrently, ensuring that both LEDs blink at their specified rate.

Step 1: Creating a new project

1. Open STM32CubeIDE and click “File” > “New” > “STM32 Project”.
2. Select your STM32 microcontroller and the appropriate board from the list.
3. Choose “RTOS” from the “Project Type” list and click “Next”.
4. Enter a project name and location and click “Next”.
5. Choose “FreeRTOS” from the “RTOS” list and click “Next”.
6. Select the appropriate options for your project and click “Finish”.

Step 2: Configuring the GPIO

1. Open the “Pinout & Configuration” tab in STM32CubeIDE.
2. Enable the GPIOs for LED1 and LED2.
3. Configure the GPIOs as outputs and set their initial state to low.

Step 3: Creating the tasks

1. Open the “main.c” file in STM32CubeIDE.
2. Add the following code to the top of the file to include the necessary FreeRTOS headers:

<code>#include "FreeRTOS.h"
#include "task.h"
</code>

3. Add the following code to define the task functions:

<code>void vTask1(void *pvParameters)
{
    while (1)
    {
        HAL_GPIO_TogglePin(LED1_GPIO_Port, LED1_Pin);
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

void vTask2(void *pvParameters)
{
    while (1)
    {
        HAL_GPIO_TogglePin(LED2_GPIO_Port, LED2_Pin);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}
</code>

The vTask1 function toggles LED1 and then delays for 500ms using the vTaskDelay function. The vTask2 function does the same for LED2 but delays for 1000ms instead.

4. Add the following code to the main function to create the tasks:

<code>xTaskCreate(vTask1, "Task 1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
xTaskCreate(vTask2, "Task 2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);

vTaskStartScheduler();
</code>

The xTaskCreate function creates two tasks, vTask1 and vTask2, and assigns them a priority of tskIDLE_PRIORITY + 1, which is higher than the idle task priority. The vTaskStartScheduler function starts the FreeRTOS scheduler, which will run the tasks concurrently.

5. Save and build the project.

Step 4: Flashing the STM32 board

1. Connect the STM32 board to your computer using a USB cable.
2. Click “Run” > “Debug” to launch the debugger.
3. Click “Resume” to start the program.

The LED1 and LED2 on the STM32 board should start blinking at their specified rates. The two tasks will run concurrently, ensuring that both LEDs blink at their specified rate.

In this article, we have explored the basics only. You can add more jobs inside of each task. See you in the next article. Thanks

For Professional Designs or Help:

You can check my other articles too:

• Sine wave generation using dsPIC
• Internal Temperature of STM32
• Fingerprint attendance system with R503
• PWM Generation with STM32
• Reading ADC with DMA in STM32 MCU
• ADC Reading with STM32103C8Tx (BluePill)