Microcontroller Internals — Registers, ALU & Peripherals

You write C code. The compiler turns it into machine instructions. The microcontroller executes those instructions one at a time. But what is actually happening inside the chip?

This lesson opens the hood.

Learning Objectives

Trace fetch, decode, execute, and write-back; explain registers, flags, buses, stack, and interrupts; read a memory-mapped peripheral sequence; and identify concurrency and timing hazards.

The Big Picture — What's Inside

Every part you see above is on the same silicon die, connected by internal wires running at hundreds of MHz. Let's go through each block.

CPU Registers — The Fastest Memory

Registers are small storage cells inside the CPU. They are not SRAM. Most ALU instructions consume register operands within one instruction's execution; this does not mean access takes zero time, and timing varies by core.

What each type does

The Status Register (Condition Flags)

The Status Register (SREG on AVR, CPSR on ARM) is the most important feedback mechanism in the CPU. Every arithmetic or logic instruction updates it.

Why flags matter — conditional branching

Every if, while, for in C compiles down to instructions that check the flags:

Without the status register, the CPU could not make any decisions. It would execute instructions blindly, in sequence, forever.

The Arithmetic Logic Unit (ALU)

The ALU is the calculator inside the CPU. Simple operations are often single-cycle; multiplication, division, memory access, and floating-point timing depend on the core.

ALU Operations by category

How a Program Executes — Step by Step

Let's trace exactly what happens when the CPU runs c = a + b where a=5, b=3:

Every instruction — even something as simple as a + b — goes through this exact sequence. On a modern microcontroller running at 16 MHz, this loop repeats 16 million times per second.

The Call Stack — How Functions Work

When you call a function, the CPU needs to:

1. Save the return address (where to come back to)
2. Jump to the function
3. Execute the function
4. Return and restore the return address

Peripherals — Controlled by Registers

Every peripheral in a microcontroller is controlled by reading and writing memory-mapped registers. There is no "call a function to set GPIO high" in hardware — you write a bit to a register.

In C code this looks like:

DDRB  |= (1 << PB5);   // Set PB5 as output (write to DDRB register)
PORTB |= (1 << PB5);   // Set PB5 high (write to PORTB register)

Both lines compile to a single instruction each: write a byte to a fixed memory address.

Interrupts — Hardware Calling Your Code

Peripherals signal the CPU using interrupts — a hardware mechanism that pauses the main program, runs a handler function (ISR), then resumes exactly where it left off.

Summary

Worked Example: Atomic Register Update

If main code and an ISR both perform a read-modify-write on one control register, an interrupt between load and store can lose an update. Prefer hardware atomic set/clear registers. Otherwise protect only the short sequence and restore the previous interrupt state. volatile forces observable accesses; it does not make an operation atomic.

Common Mistakes

• Confusing CPU registers with memory-mapped peripheral registers.
• Treating volatile as a lock or memory barrier.
• Enabling interrupts before the stack and vector table are valid.
• Writing reserved bits or skipping documented read-back delays.
• Doing blocking I/O or long computations inside an ISR.

Further Reading

• Microchip, AVR Instruction Set Manual
• Arm, Cortex-M3 Generic User Guide
• Arm, CMSIS-Core documentation

Mind Map