Build Your Own RealTime OS (RTOS) From Ground Up™ on ARM 1

Install the Keil uVision 5 IDE and ARM's MDK toolchain, navigate to the ARM downloads, download MDK, complete the form, and begin the installation for a real-time OS on ARM.

Install Keil uVision 5, configure the pack installer, and select ARM microcontrollers like STM32 and TM4C to simulate and develop RTOS projects.

Install and verify Cortex microcontroller packs using the Keil uVision pack installer, selecting STM32, NXP, and TI DFP packs, with guidance on deprecated versions and progress.

Explore Keil uVision 5 by launching the IDE, creating a new STM32 project, adding CMSIS and startup files, and configuring targets, editors, and debuggers.

Learn to switch the ARM compiler in Keil uVision from compiler six to compiler five using the Options for Target, ARM compiler settings, to avoid pseudo delay issues.

Identify PA5 on port A for LED2 using the nucleo board docs, then enable GPIOA clock via AHB1ENR and implement led.c/led.h with init, on, off.

Port a stm32 cube ide led-driver project to keil uvision, organize source and include folders, configure cmsis startup and vector table, and test compiler versions 5 and 6.

Develop a uart driver to transmit debug messages over usart2, enabling its clock, configuring gpio pa2 and pa3 to af7, and observing thread scheduling.

Enable gpioa clock and set pa2 to alternate function, select af7 for uart2 tx, enable usart2 on apb1, compute and set baud rate, and configure cr1 with te and ue.

Develop a UART write function that waits for TXE in USART_SR, then writes to the transmit data register; retarget printf via stdio.h and __io_putchar.

Develop a time base using the systick timer to run a real-time operating system experiment, initializing systick in interrupt mode for a one-second timeout.

Test the time base project in Keil uVision, mirroring the CubeIDE setup by copying the time base source and header. Build, download to the board, and verify a one-second delay.

Practice a blocking code experiment in Keil uVision by copying project files from STM32CubeIDE, building, and downloading to the board, then use memory and watch views to observe variables.

Explore manual context switching between motor and valve routines by implementing a start flag, diagnosing infinite loops, and manipulating the program counter to switch threads.

Learn to run manual context switching code in Keil uVision by cloning the CubeIDE project, replacing main.c, adding stdio.h, building, and validating the results on the board for experiments.

Explore performance metrics for real time operating systems, focusing on deadlines and reliability to ensure timely, predictable responses; the lecture also previews the cpu memory map and register bank.

Explore busy wait systems in embedded firmware, using a three-sensor flow example (lidar, radar, camera) to show how sequential checking can yield outdated data and unsafe actions.

Discover a multi-threaded real-time approach, using background ISR tasks to collect lidar, radar, and camera data and a synchronized foreground thread to meet precise timing.

Design a thread scheduler to run autonomous vehicle tasks in a foreground, parallel-like mode, executing take action, lidar, radar, and camera functions within a set time constraint.

Explore the stack and memory map of cortex microcontrollers with the TM4C123 example, showing RAM, ROM, io layout, and the stack pointer managing 32-bit data.

Demonstrate push and pop on a 32-bit stack. The example saves R4, R5, and R6 on a 4096-byte stack, with SP decrementing on push and incrementing on pop, illustrating lifo.

Explore how a microcontroller houses the cpu, rom, ram, io ports, and peripherals, and examine cortex-m register bank, including the arithmetic logic unit, stack pointers, pc, lr, and status registers.

Learn how the cortex microcontroller uses two stack pointers, msp and psp, to support kernel, interrupt, and thread mode; access them with mrs and msr, including shadow stack pointers.

Learn how real-time operating systems enforce exclusive access to shared resources using exclusive load and store to atomically manage variables and peripherals, preventing race conditions when modules access the LCD.

Explore configuring the SysTick interrupt on Cortex-M, a 24-bit down counter running at the bus clock frequency, by setting the control, reload, current value, and priority registers.

Pressing the reset button starts the cortex-m boot sequence by resetting registers, selecting the boot mode, and fetching the main stack pointer from 0x00000000 and the program counter from 0x00000004.

Analyze the cortex-m boot sequence from a memory map, showing how the processor loads stack pointer and program counter, then uses boot0/boot1 and thumb mode to reach the reset handler.

Discover how real time operating systems run threads as tasks with registers, a stack, and a program. See how a thread scheduler emulates multiple CPUs on a single core.