FreeRTOS From Ground Up™ on ARM Processors (REVISED)

Download stm32 cubeide from the official STMicroelectronics site, accept the license, sign in, and download the latest version 5.5 Windows installer; a future lesson covers installation.

Install STM32CubeIDE by downloading the complete package for Windows, Mac, and Linux, extracting it, and ensuring a Java runtime is available.

Install the 64-bit toolchain, open the embedded software packages manager, and install the latest packages for the F4 series and other MCUs to enable FreeRTOS development on ARM.

Explore starting a new project using MCU and board selectors, configure peripherals and clocks, set pinouts and alternate functions, and generate code with the project manager and reports, with FreeRTOS.

Learn FreeRTOS naming conventions for data and base types, including 16- and 32-bit configurations, type_t usage, and variable and function prefixes.

Identify how FreeRTOS macro names combine a lowercase prefix with an uppercase macro, locate them in portable files, and use common macros such as pdTRUE, pdFALSE, and configUSE_PREEMPTION.

Learn to create tasks in FreeRTOS on STM32, configure a project with CubeMX, select middleware, and set up semaphores and time bases for real-time task management.

Learn to create FreeRTOS tasks with the task creation function, detailing its six arguments—task code, name, stack size, parameters, priority, and the task handle for runtime configuration.

Create and manage FreeRTOS tasks on ARM using xTaskCreate, setting task function, name, stack, parameters, priority, and handle, then start the scheduler and observe colored LED controllers.

Learn how to create tasks from another task by moving initial task creation from main to a parent task, and have the blue led task create red and green tasks.

Learn to use task parameters to pass a pin identifier to a single generic controller task, enabling four tasks that toggle pins 12–15 via a shared GPIO initialization.

Explore how task priorities affect execution: higher priorities preempt lower ones and equal priorities share time in round-robin scheduling, guided by time quanta and planned real-time adjustments.

Learn to change a task priority at runtime using the vTaskPrioritySet function with a task handle, allowing green to outrank blue and red by raising its priority.

Learn how to read a task's priority in FreeRTOS on ARM processors using the task priority get function, and see how priorities reflect during runtime with example tasks.

Learn how to suspend a task in FreeRTOS on ARM processors using vTaskSuspend and a simple counter to trigger suspension, demonstrated with multiple tasks of equal priority.

Learn how to resume a suspended FreeRTOS task by using a suspended flag, a suspend monitor, and a resume monitor to coordinate red and green tasks with equal priority.

Learn to terminate a FreeRTOS task on ARM by enabling the deletion feature in the kernel configuration and calling vTaskDelete; compare deletion with suspension.

Explore the FreeRTOS task states on ARM: ready, running, block, and suspended. Learn how delays and semaphores move tasks through the scheduler, using vTaskSuspend and vTaskResume.

Explain how a task enters the blocked state due to time-related events or synchronization signals. Show how to use vTaskDelay with pdMS_TO_TICKS to create delays by blocking for tick counts.

Block a task by placing it in the blocked state while waiting for an event or a time delay, using vTaskDelay and pdMS_TO_TICKS.

Configure a FreeRTOS task to execute periodically using vTaskDelayUntil with last wake time and a fixed period, and consider hardware timer interrupts as an alternative.

Discover how the idle task maintains a running state, created automatically with the lowest priority, and how the idle hook and config options govern yielding and time quanta.

Learn how the FreeRTOS idle task and application idle hook perform housekeeping when the scheduler has free time, and how task delays and priorities influence its execution.

Explore the tick hook, a tick callback invoked during each tick interrupt, kept minimal to preserve real-time performance and avoid API calls that do not end with fromISR.

Understand how FreeRTOS queues function as fixed-size buffers, supporting pass-by-value or pass-by-reference transfers, blocking behavior and block times, and queue sets with APIs like xQueueSend and xQueueReceive.

Learn to use queues in FreeRTOS on ARM by implementing a two-task example (sender and receiver), creating a queue, sending and receiving data with timeouts, and handling status and errors.

Update printf by adding a new write function that waits for the status bit, writes data to the UART data register, and passes the argument through.

Show how to synchronize tasks with queues (cues) by creating two sender tasks of equal priority and a higher-priority receiver, using a queue to coordinate their execution.

Learn to send complex data with FreeRTOS queues by using a data structure with value and a humidity or pressure data source, and coordinating humidity, pressure, and receiver tasks.

Learn to implement FreeRTOS queue sets by creating two queues and a queue set, sending data, and using a receiver task with xQueueSelectFromSet to receive and print messages.

Explore semaphores in FreeRTOS, including binary, counting, and mutex types, and learn APIs like xSemaphoreCreateBinary, xSemaphoreGive, and xSemaphoreTake, interrupt service routine handling, and issues such as priority inversion and deadlocks.

Learn how to use binary semaphores to coordinate three tasks, implement take and give, observe a deadlock and a solution that starts by giving the semaphore to avoid it.

Develop and integrate an ADC driver for FreeRTOS on ARM by configuring clocks, GPIO as analog, interrupt support, and implementing init and read functions.

Develop and extend a GPIO external interrupt driver for PC13 on Port C, configuring the APB, port mode, external interrupt config, falling-edge trigger, and interrupt priority, then build and test.

Test the gpio driver by configuring PC13 as a non-interrupt input, reading idr 13 via read_digital_sensor, and verify with a push button, then explore PA1 adc for a potentiometer.

Implement a mutex in FreeRTOS on ARM to guard serial port access with two tasks (digital and analog sensors) and compare mutex behavior to a binary semaphore.

Learn to use counting semaphores in FreeRTOS on ARM by creating counting semaphores with a total count and initial count, using xSemaphoreCreateCounting and xSemaphoreGive to manage resources.

Implement a gatekeeper task that centralizes printing by receiving digital and analog sensor data through a two-element queue, removing semaphores, and using an lcd task.

Explore how software timers schedule future or periodic function callbacks in FreeRTOS, distinguishing auto reload and one shot timers, with focus on period and core APIs like xTimerCreate.

Learn to work with software timers in FreeRTOS on ARM by creating and configuring one-shot and auto-reload timers, wiring their callbacks, and printing the timer counts.

Stop the auto-reload timer during runtime by counting timeouts in the timer callback and invoking the stop API after a set count, demonstrating runtime timer control in FreeRTOS on ARM.