What is an Embedded System?

An embedded system is a dedicated computer built directly into a larger product to perform one specific job. Unlike a desktop PC that runs many applications, an embedded system typically does one thing really well — controlling a motor, reading a sensor, transmitting data wirelessly, or driving a display.

The word “embedded” means the computer is hidden inside a product — you may not even realise it is there. Your washing machine has one. Your car ECU has dozens. Your smartwatch has one. They all share a common trait: a small, energy-efficient processor running specialised software, often called firmware.

What is ARM? (And Why Does Everyone Use It?)

ARM (originally “Acorn RISC Machines”, now owned by SoftBank and listed independently) is a British semiconductor company that does something unusual: it does not manufacture chips. Instead, it designs processor cores and licenses the design to other companies. Those companies then integrate the ARM core into their own chips alongside peripherals like USB, UART, ADC, timers, and sell those chips (called microcontrollers or SoCs) to product manufacturers.

This business model has made ARM the most widely licensed processor architecture on Earth. Billions of ARM-core chips are shipped every year. When you write code for a Cortex-M3, your skills transfer directly to any microcontroller built on that same core — whether it is made by ST, NXP, Microchip, or Nordic Semiconductor.

The ARM Cortex Processor Family

ARM organises its Cortex processors into three product lines, each targeting a different market segment. Understanding this helps you choose the right processor for any project.

The Cortex-M Sub-family in Detail

Within the Cortex-M line, ARM offers multiple variants at different price and performance points:

Cortex-M3 vs Cortex-M4 — Side by Side

Both cores share the same instruction set base (Thumb-2), the same programmer’s model, and the same NVIC interrupt architecture. The M4 adds dedicated digital signal processing capabilities on top of the M3 foundation.

Inside the Cortex-M: Core Architecture Overview

Before diving into code, it helps to visualise the major blocks inside a Cortex-M microcontroller. The processor core itself is just one part of the chip; the chip vendor adds many peripherals around it.

Throughout this course you will learn to program every layer in this diagram — from writing to a GPIO register to configuring the NVIC to handle an interrupt from a timer peripheral.

Where ARM Cortex-M Lives in the Real World

ARM Cortex-M processors are used in virtually every category of electronic product you interact with daily. The combination of low power consumption, low cost, deterministic real-time behaviour, and a rich peripheral set makes them the default choice for embedded design teams worldwide.

What You Will Learn in This Series

This lecture series takes you from zero to writing professional-quality bare-metal firmware for ARM Cortex-M3 and M4 microcontrollers. Here is the full curriculum roadmap:

The Hands-On Philosophy: Writing Real Code

Many students learn embedded systems by calling library functions (HAL, Arduino, STM32Cube) without ever understanding what those functions do internally. This course takes the opposite approach: you will write directly to hardware registers, in plain C, with no magic abstractions in the way.

Why does this matter? Because when a library call silently fails at 3 AM before a product deadline, the engineer who understands what every register bit does is the one who fixes it. Register-level knowledge makes you fundamentally better — even when you later use libraries by choice.

A First Taste: Blinking an LED with Registers

To make this concrete immediately, here is what bare-metal LED blinking looks like on an STM32 Cortex-M4 microcontroller. Do not worry if you do not understand every line yet — we will build up to this step by step across the lectures. The point is to show you what the code actually looks like at the register level.

On an STM32F4 board, user LED LD2 is typically connected to Port A, Pin 5 (PA5). To blink it, we need to:

1. Enable the clock to GPIO Port A via the RCC (Reset and Clock Control) register
2. Configure PA5 as a push-pull output via the GPIO Mode register
3. Toggle the output using the GPIO Output Data Register in a loop

#include <stdint.h>

/* ── Register addresses (from STM32F4 Reference Manual RM0090) ── */
#define RCC_AHB1ENR   (*((volatile uint32_t *)0x40023830U))
#define GPIOA_MODER   (*((volatile uint32_t *)0x40020000U))
#define GPIOA_ODR     (*((volatile uint32_t *)0x40020014U))

/* Bit positions */
#define RCC_GPIOAEN   (1U << 0)   /* bit 0 of RCC_AHB1ENR enables GPIOA clock */
#define GPIOA_PIN5    (1U << 5)   /* PA5 = bit 5 of ODR                        */

static void delay(volatile uint32_t count)
{
    while (count--);
}

int main(void)
{
    /* Step 1: Enable the GPIOA peripheral clock */
    RCC_AHB1ENR |= RCC_GPIOAEN;

    /* Step 2: Configure PA5 as general-purpose output (MODER bits 11:10 = 01) */
    GPIOA_MODER &= ~(3U << (5 * 2));   /* clear the two mode bits for pin 5 */
    GPIOA_MODER |=  (1U << (5 * 2));   /* set to 01 = output mode            */

    /* Step 3: Toggle PA5 forever */
    while (1) {
        GPIOA_ODR |=  GPIOA_PIN5;    /* LED ON  */
        delay(500000);
        GPIOA_ODR &= ~GPIOA_PIN5;   /* LED OFF */
        delay(500000);
    }

    return 0;
}

Development Tools for This Course

You will use the following tools throughout this series. All of them have free tiers or are fully open-source:

What You Need to Know Before Starting

Quick Refresher: Bitwise Operations in C

Bitwise operations are the bread and butter of embedded programming. You will use them in every lecture. Here is a compact reference:

#include <stdint.h>

int main(void)
{
    uint32_t reg = 0x00000000;  /* imagine this is a hardware register */

    /* ── Set bit N (force it to 1 without touching other bits) ── */
    reg |= (1U << 5);   /* sets bit 5; reg = 0x00000020 */

    /* ── Clear bit N (force it to 0 without touching other bits) ── */
    reg &= ~(1U << 5);  /* clears bit 5; reg = 0x00000000 */

    /* ── Toggle bit N ── */
    reg ^= (1U << 5);   /* flips bit 5; reg = 0x00000020 */

    /* ── Read (test) bit N ── */
    if (reg & (1U << 5)) {
        /* bit 5 is set */
    }

    /* ── Set a multi-bit field (e.g. bits 11:10 to value 0b10) ── */
    reg &= ~(0x3U << 10);      /* clear the 2-bit field first */
    reg |=  (0x2U << 10);      /* then write the desired value */

    /* ── Read a multi-bit field ── */
    uint32_t field = (reg >> 10) & 0x3U;  /* extract bits 11:10 */

    return 0;
}

Processor vs Microcontroller: Know the Difference

This distinction trips up almost every beginner. A processor and a microcontroller are related but different things:

Key Reference Documents You Will Use

Embedded development is a documentation-heavy discipline. Two types of documents will become your daily companions:

Frequently Asked Questions