Part 3: MCU & System Architecture

MCU Block Diagram

Every microcontroller is built from the same fundamental blocks: a processor core, memory, peripherals, and a bus system that connects them. Understanding this architecture is what separates someone who copies example code from someone who can design reliable embedded systems.

flowchart TB
    subgraph Core["ARM Cortex-M4 Core"]
        CPU["CPU
ALU + FPU"]
        NVIC["NVIC
Interrupt Controller"]
        SysTick["SysTick
System Timer"]
    end
    subgraph Memory["Memory"]
        FLASH["Flash
512KB (Code)"]
        SRAM["SRAM
128KB (Data)"]
    end
    subgraph AHB["AHB Bus (High Speed)"]
        DMA["DMA Controller"]
        GPIO["GPIO Ports
A, B, C, D, E"]
    end
    subgraph APB2["APB2 Bus (Fast Peripherals)"]
        ADC1["ADC1"]
        TIM1["TIM1 (Advanced)"]
        SPI1["SPI1"]
        USART1["USART1"]
    end
    subgraph APB1["APB1 Bus (Standard Peripherals)"]
        I2C1["I2C1"]
        UART2["USART2"]
        TIM2["TIM2/3/4/5"]
        CAN1["CAN1"]
        DAC1["DAC"]
    end
    Core --> Memory
    Core --> AHB
    AHB --> APB2
    AHB --> APB1
                            

Bus Matrix & Memory Map

The STM32’s memory map gives every peripheral a unique address range. When you write to a GPIO register, you’re writing to a specific memory address:

GPIO Configuration

Pin Modes & Registers

Each GPIO pin has four configuration registers that control its behaviour. Understanding these registers is crucial for bare-metal programming:

HAL vs Register-Level GPIO

/* GPIO: HAL Abstraction vs Direct Register Access
 * Both examples configure PA5 as push-pull output and toggle it
 * Board: STM32F411RE Nucleo
 */

/* ---- Method 1: HAL (beginner-friendly, portable) ---- */
#include "stm32f4xx_hal.h"

void gpio_hal_example(void)
{
    __HAL_RCC_GPIOA_CLK_ENABLE();

    GPIO_InitTypeDef gpio = {0};
    gpio.Pin   = GPIO_PIN_5;
    gpio.Mode  = GPIO_MODE_OUTPUT_PP;
    gpio.Pull  = GPIO_NOPULL;
    gpio.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOA, &gpio);

    HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
}

/* ---- Method 2: Register (fast, precise, low overhead) ---- */
void gpio_register_example(void)
{
    /* Enable GPIOA clock via RCC AHB1ENR */
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

    /* Configure PA5: MODER bits [11:10] = 01 (output) */
    GPIOA->MODER &= ~(3U << 10);  /* Clear bits 11:10 */
    GPIOA->MODER |=  (1U << 10);  /* Set bit 10 = output mode */

    /* Push-pull: OTYPER bit 5 = 0 (default) */
    GPIOA->OTYPER &= ~(1U << 5);

    /* Toggle PA5 using BSRR (atomic, no read-modify-write) */
    if (GPIOA->ODR & (1U << 5))
        GPIOA->BSRR = (1U << 21);  /* Reset (upper 16 bits) */
    else
        GPIOA->BSRR = (1U << 5);   /* Set (lower 16 bits) */
}

ADC & DAC

ADC Configuration

The Analog-to-Digital Converter transforms real-world analog voltages into digital values your code can process. Key parameters:

/* ADC Single-Channel Read — STM32 HAL
 * Read potentiometer on PA0 (ADC1_IN0)
 * Board: STM32F411RE Nucleo
 */

#include "stm32f4xx_hal.h"
#include <stdio.h>

ADC_HandleTypeDef hadc1;

void adc_init(void)
{
    __HAL_RCC_ADC1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    /* Configure PA0 as analog input */
    GPIO_InitTypeDef gpio = {0};
    gpio.Pin  = GPIO_PIN_0;
    gpio.Mode = GPIO_MODE_ANALOG;
    gpio.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &gpio);

    /* Configure ADC1 */
    hadc1.Instance                   = ADC1;
    hadc1.Init.Resolution            = ADC_RESOLUTION_12B;
    hadc1.Init.ScanConvMode          = DISABLE;
    hadc1.Init.ContinuousConvMode    = DISABLE;
    hadc1.Init.ExternalTrigConvEdge  = ADC_EXTERNALTRIGCONVEDGE_NONE;
    hadc1.Init.DataAlign             = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion       = 1;
    HAL_ADC_Init(&hadc1);

    /* Configure channel 0, sampling time 84 cycles */
    ADC_ChannelConfTypeDef ch = {0};
    ch.Channel      = ADC_CHANNEL_0;
    ch.Rank         = 1;
    ch.SamplingTime = ADC_SAMPLETIME_84CYCLES;
    HAL_ADC_ConfigChannel(&hadc1, &ch);
}

uint16_t adc_read(void)
{
    HAL_ADC_Start(&hadc1);
    HAL_ADC_PollForConversion(&hadc1, 10);
    return HAL_ADC_GetValue(&hadc1);
}

/* Usage:
 *   adc_init();
 *   uint16_t raw = adc_read();           // 0-4095
 *   float voltage = raw * 3.3f / 4095;   // Convert to volts
 *   printf("ADC: %d (%.2fV)\r\n", raw, voltage);
 */

DAC Output

/* DAC Output — Generate a voltage on PA4 (DAC1_OUT1)
 * STM32F411 has no DAC; use STM32F446 or F303 for this example
 * Board: STM32F446RE Nucleo
 */

#include "stm32f4xx_hal.h"

DAC_HandleTypeDef hdac;

void dac_init(void)
{
    __HAL_RCC_DAC_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    /* PA4 as analog (DAC output) */
    GPIO_InitTypeDef gpio = {0};
    gpio.Pin  = GPIO_PIN_4;
    gpio.Mode = GPIO_MODE_ANALOG;
    gpio.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &gpio);

    hdac.Instance = DAC;
    HAL_DAC_Init(&hdac);

    DAC_ChannelConfTypeDef cfg = {0};
    cfg.DAC_Trigger      = DAC_TRIGGER_NONE;
    cfg.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
    HAL_DAC_ConfigChannel(&hdac, &cfg, DAC_CHANNEL_1);

    HAL_DAC_Start(&hdac, DAC_CHANNEL_1);
}

void dac_set_voltage(float volts)
{
    /* DAC is 12-bit: 0-4095 maps to 0-VREF (3.3V) */
    uint32_t dac_val = (uint32_t)(volts / 3.3f * 4095);
    if (dac_val > 4095) dac_val = 4095;
    HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, dac_val);
}

/* Usage:
 *   dac_init();
 *   dac_set_voltage(1.65f);  // Output 1.65V on PA4 (half of 3.3V)
 */

Hardware Timers

Timer Fundamentals

Hardware timers are free-running counters driven by the system clock. They are the backbone of precise timing in embedded systems: generating PWM signals, measuring pulse widths, triggering periodic interrupts, and counting external events.

flowchart LR
    CLK["System Clock
e.g., 84 MHz"] --> PSC["Prescaler (PSC)
÷ (PSC+1)"]
    PSC --> CNT["Counter (CNT)
Counts 0 → ARR"]
    CNT --> ARR["Auto-Reload (ARR)
Overflow → Reset"]
    ARR --> EVT{"Event"}
    EVT -->|"Interrupt"| ISR["Timer ISR"]
    EVT -->|"PWM"| OC["Output Compare
(CCRx)"]
    EVT -->|"DMA"| DMA["DMA Transfer"]
                            

## Timer Prescaler Calculator
## Compute PSC and ARR for a desired timer frequency

import math

# System parameters
system_clock_hz = 84_000_000  # 84 MHz (APB1 timer clock on STM32F411)
desired_freq_hz = 1000        # 1 kHz timer interrupt (1ms period)
timer_bits = 16               # 16-bit timer (max ARR = 65535)

max_count = (2 ** timer_bits) - 1  # 65535

# Calculate: freq = clock / ((PSC+1) * (ARR+1))
# So (PSC+1) * (ARR+1) = clock / freq
total_counts = system_clock_hz / desired_freq_hz
print(f"Total counts needed: {total_counts:.0f}")

# Find best PSC/ARR combination (prefer larger ARR for better resolution)
best_psc = 0
best_arr = 0
best_error = float('inf')

for psc in range(0, 65536):
    arr = total_counts / (psc + 1) - 1
    if arr < 0 or arr > max_count:
        continue
    arr_rounded = round(arr)
    actual_freq = system_clock_hz / ((psc + 1) * (arr_rounded + 1))
    error = abs(actual_freq - desired_freq_hz)
    if error < best_error:
        best_error = error
        best_psc = psc
        best_arr = arr_rounded
    if error == 0:
        break

actual = system_clock_hz / ((best_psc + 1) * (best_arr + 1))
print(f"\nBest configuration for {desired_freq_hz} Hz:")
print(f"  PSC = {best_psc}")
print(f"  ARR = {best_arr}")
print(f"  Actual frequency: {actual:.2f} Hz")
print(f"  Error: {abs(actual - desired_freq_hz):.4f} Hz")

Total counts needed: 84000

Best configuration for 1000 Hz:
  PSC = 83
  ARR = 999
  Actual frequency: 1000.00 Hz
  Error: 0.0000 Hz

PWM Generation

Pulse Width Modulation uses a timer’s output compare feature to generate variable-duty-cycle square waves. The duty cycle is set by the CCR (Capture/Compare Register) value relative to the ARR (Auto-Reload Register).

/* PWM Output — Drive an LED or servo motor
 * TIM2 Channel 1 on PA0, 1 kHz PWM, variable duty cycle
 * Board: STM32F411RE Nucleo
 */

#include "stm32f4xx_hal.h"

TIM_HandleTypeDef htim2;

void pwm_init(uint32_t freq_hz)
{
    __HAL_RCC_TIM2_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    /* PA0 as TIM2_CH1 alternate function */
    GPIO_InitTypeDef gpio = {0};
    gpio.Pin       = GPIO_PIN_0;
    gpio.Mode      = GPIO_MODE_AF_PP;
    gpio.Pull      = GPIO_NOPULL;
    gpio.Speed     = GPIO_SPEED_FREQ_LOW;
    gpio.Alternate = GPIO_AF1_TIM2;
    HAL_GPIO_Init(GPIOA, &gpio);

    /* Timer base: 84 MHz / (83+1) = 1 MHz tick
     * ARR = (1 MHz / freq_hz) - 1
     */
    htim2.Instance               = TIM2;
    htim2.Init.Prescaler         = 83;
    htim2.Init.CounterMode       = TIM_COUNTERMODE_UP;
    htim2.Init.Period            = (1000000 / freq_hz) - 1;
    htim2.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_PWM_Init(&htim2);

    /* Output compare channel 1 */
    TIM_OC_InitTypeDef oc = {0};
    oc.OCMode     = TIM_OCMODE_PWM1;
    oc.Pulse      = 0;  /* Initial duty = 0% */
    oc.OCPolarity = TIM_OCPOLARITY_HIGH;
    oc.OCFastMode = TIM_OCFAST_DISABLE;
    HAL_TIM_PWM_ConfigChannel(&htim2, &oc, TIM_CHANNEL_1);

    HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
}

void pwm_set_duty(float percent)
{
    uint32_t arr = __HAL_TIM_GET_AUTORELOAD(&htim2);
    uint32_t ccr = (uint32_t)(percent / 100.0f * (arr + 1));
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, ccr);
}

/* Usage:
 *   pwm_init(1000);        // 1 kHz PWM
 *   pwm_set_duty(50.0f);   // 50% duty cycle
 *   pwm_set_duty(25.0f);   // 25% duty cycle
 */

Input Capture

Input Capture measures the timing of external signals — pulse width, frequency, or duty cycle. The timer captures its counter value when an edge (rising, falling, or both) is detected on an input pin.

Interrupts & NVIC

The Cortex-M Interrupt Model

Interrupts allow the MCU to respond to events immediately without polling. When an interrupt fires, the hardware automatically saves the current context, jumps to the Interrupt Service Routine (ISR), and restores context when done.

sequenceDiagram
    participant Main as Main Loop
    participant HW as Hardware Event
    participant NVIC as NVIC
    participant ISR as ISR Handler

    Main->>Main: Running normal code
    HW->>NVIC: Interrupt request (IRQ)
    NVIC->>NVIC: Check priority & enable
    NVIC->>ISR: Save context, jump to ISR
    ISR->>ISR: Handle event (keep short!)
    ISR->>ISR: Clear interrupt flag
    ISR->>Main: Restore context, resume
    Main->>Main: Continue normal code
                            

/* External Interrupt — Button press on PC13 (User button on Nucleo)
 * Board: STM32F411RE Nucleo
 */

#include "stm32f4xx_hal.h"
#include <stdio.h>

volatile uint32_t button_count = 0;  /* volatile: modified in ISR */

void exti_button_init(void)
{
    __HAL_RCC_GPIOC_CLK_ENABLE();

    /* PC13 as input with pull-up (button pulls to GND) */
    GPIO_InitTypeDef gpio = {0};
    gpio.Pin  = GPIO_PIN_13;
    gpio.Mode = GPIO_MODE_IT_FALLING;  /* Interrupt on falling edge */
    gpio.Pull = GPIO_PULLUP;
    HAL_GPIO_Init(GPIOC, &gpio);

    /* Enable EXTI15_10 interrupt in NVIC */
    HAL_NVIC_SetPriority(EXTI15_10_IRQn, 2, 0);
    HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
}

/* ISR — called by hardware on button press */
void EXTI15_10_IRQHandler(void)
{
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
}

/* HAL callback — called from IRQHandler after flag clearing */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if (GPIO_Pin == GPIO_PIN_13)
    {
        button_count++;
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);  /* Toggle LED */
    }
}

/* In main loop:
 *   printf("Button pressed %lu times\r\n", button_count);
 */

Priority & Nesting

Communication Protocols

Embedded systems communicate with sensors, displays, and other MCUs using serial protocols. Each protocol has trade-offs in speed, wiring, distance, and complexity.

UART (Universal Asynchronous Receiver/Transmitter)

UART is the simplest serial protocol — just TX and RX lines, no clock. Both sides must agree on the baud rate beforehand.

I2C (Inter-Integrated Circuit)

SPI (Serial Peripheral Interface)

flowchart LR
    MASTER["MCU
(Master)"] -->|"MOSI (data out)"| S1["Sensor 1
CS1"]
    MASTER -->|"SCK (clock)"| S1
    S1 -->|"MISO (data in)"| MASTER
    MASTER -->|"MOSI"| S2["Display
CS2"]
    MASTER -->|"SCK"| S2
    S2 -->|"MISO"| MASTER
    MASTER -->|"CS1 (select)"| S1
    MASTER -->|"CS2 (select)"| S2
                            

CAN Bus (Controller Area Network)

CAN is a robust, multi-master protocol designed for noisy environments like vehicles and industrial systems. It uses differential signalling for excellent noise immunity.

Power Budgeting

Every embedded system must balance power consumption against performance. A power budget lists every component’s current draw and ensures the power supply can deliver enough current with safety margin.

## Power Budget Calculator
## Estimate total system current draw and battery life

# Component current draws (from datasheets, in mA)
components = {
    "STM32F411 (Run, 100MHz)":   30.0,
    "BME280 (measuring)":         0.714,
    "BH1750 (measuring)":         0.120,
    "SSD1306 OLED (active)":     20.0,
    "LED indicator (×2)":        10.0,
    "Voltage regulator quiescent": 5.0,
    "Pull-up resistors (I2C)":    0.66,
    "Miscellaneous / margin":    10.0,
}

supply_voltage = 3.3    # Volts
battery_mah = 2000      # mAh (e.g., 18650 Li-ion through regulator)
regulator_efficiency = 0.85  # 85% for typical LDO/buck

print("╔══════════════════════════════════════════════╗")
print("║         POWER BUDGET ESTIMATE                ║")
print("╠══════════════════════════════════════════════╣")

total_ma = 0
for name, current in components.items():
    total_ma += current
    print(f"║  {name:.<36} {current:>6.2f} mA ║")

print("╠══════════════════════════════════════════════╣")
print(f"║  TOTAL CURRENT DRAW{'':.<17} {total_ma:>6.2f} mA ║")

power_mw = total_ma * supply_voltage
print(f"║  Power consumption{'':.<18} {power_mw:>6.0f} mW ║")

# Battery life calculation
effective_mah = battery_mah * regulator_efficiency
hours = effective_mah / total_ma
days = hours / 24
print(f"║  Battery life ({battery_mah}mAh){'':.<12} {hours:>5.1f} hrs ║")
print(f"║  ({days:.1f} days)")
print("╚══════════════════════════════════════════════╝")

╔══════════════════════════════════════════════╗
║         POWER BUDGET ESTIMATE                ║
╠══════════════════════════════════════════════╣
║  STM32F411 (Run, 100MHz)................  30.00 mA ║
║  BME280 (measuring).....................   0.71 mA ║
║  BH1750 (measuring).....................   0.12 mA ║
║  SSD1306 OLED (active)..................  20.00 mA ║
║  LED indicator (×2).....................  10.00 mA ║
║  Voltage regulator quiescent............   5.00 mA ║
║  Pull-up resistors (I2C)................   0.66 mA ║
║  Miscellaneous / margin.................  10.00 mA ║
╠══════════════════════════════════════════════╣
║  TOTAL CURRENT DRAW...................   76.49 mA ║
║  Power consumption....................    252 mW ║
║  Battery life (2000mAh)...............   22.2 hrs ║
║  (0.9 days)
╚══════════════════════════════════════════════╝

Exercises

Design Review Checklist Tool

Use this tool to create a hardware design review checklist for your MCU-based project. It generates a comprehensive document covering power, GPIO, peripherals, and communication.

Conclusion & Next Steps

You now understand the full architecture of an ARM Cortex-M microcontroller — from the bus matrix and memory map to GPIO registers, ADC/DAC converters, hardware timers, the NVIC interrupt controller, and the four essential serial protocols. This knowledge forms the foundation for everything that follows in the series.