MCU vs CPU vs MPU: Understanding Processors and Microcontrollers

Quick Definition

Three terms that often confuse beginners in embedded systems:

The key insight: CPU and MPU are processors; MCU is a complete computer on a chip.

CPU (Central Processing Unit)

A CPU is the brain of your desktop, laptop, or server. It executes instructions from programs but doesn’t include memory, I/O controllers, or timers.

Characteristics

• No built-in peripherals — requires external RAM, storage, I/O controllers
• High clock speed — GHz range (Intel i7 at 3-5 GHz)
• Complex instruction set — x86, ARM64
• Power-hungry — watts of consumption
• Requires external infrastructure — motherboard, chipset, power delivery

Real Example

Your laptop’s Intel Core i7 or AMD Ryzen. To run, it needs:

• External RAM (DDR4/DDR5)
• Motherboard chipset (for I/O control)
• SSD/HDD storage controller
• Power supply management

Use case: General-purpose computing (personal computers, servers).

MPU (Microprocessor Unit)

An MPU is essentially a “simpler CPU” optimized for embedded systems. It has built-in memory management (MMU — Memory Management Unit) but still needs most peripherals.

Characteristics

• Memory Management Unit (MMU) — enables virtual memory and protected memory spaces
• Moderate clock speed — 100 MHz to 2+ GHz
• Simplified instruction set — ARM32, MIPS, PowerPC
• Medium power consumption — milliwatts to a few watts
• Requires OS — typically Linux, embedded RTOS

Real Example

ARM Cortex-A72 (used in Raspberry Pi 4, Jetson Nano):

• 1.5 GHz clock speed
• Has MMU for memory protection
• Runs Linux or real-time OS
• Still needs external RAM, storage, and I/O controllers
• Pi 4 requires GPIO controllers, USB hubs, Ethernet PHY (separate chips)

Use case: Industrial controllers, IoT gateways, automotive infotainment (where an OS is needed).

MCU (Microcontroller Unit)

An MCU is a “complete computer on a single chip.” It integrates:

• Processor core (usually simple, ARM Cortex-M or 8051-based)
• RAM (kilobytes to hundreds of KB)
• Flash memory (program storage)
• Timers, PWM, ADC, UART, SPI, I2C, GPIO
• Clock generator

Everything needed to run standalone — no external chips required for basic operation.

Characteristics

• All-in-one — processor + memory + I/O on one chip
• Low power — microamps to milliwatts (ideal for batteries)
• Low clock speed — 8 MHz to 500+ MHz
• Limited resources — think kilobytes, not gigabytes
• No OS needed — typically bare-metal or lightweight RTOS
• Cheap — $1–$10 per unit in volume

Real Examples

1. STM32L476 (ST Microelectronics)

Processor:   ARM Cortex-M4 @ 80 MHz
RAM:         128 KB
Flash:       256 KB
Peripherals: ADC, 3x UART, SPI, I2C, GPIO, Timers
Power:       40 μA in sleep mode
Cost:        ~$3–4 in qty

Use: Low-power IoT sensors, fitness trackers, medical devices.

2. Arduino Uno (ATmega328P)

Processor:   8-bit AVR @ 16 MHz
RAM:         2 KB
Flash:       32 KB
Peripherals: 6x ADC, UART, SPI, I2C, 20 GPIO, Timers
Power:       ~60 mA at 5V
Cost:        ~$2–3

Use: Hobby robotics, learning embedded systems, simple automation.

3. ESP32 (Espressif)

Processor:   Dual-core Xtensa @ 240 MHz
RAM:         520 KB
Flash:       4 MB (onboard or external)
Peripherals: WiFi, Bluetooth, ADC, SPI, I2C, UART, GPIO, Timers
Power:       80 mA active, 150 μA sleep
Cost:        ~$5–8

Use: WiFi-enabled IoT, home automation, embedded web servers.

Side-by-Side Comparison

Feature          | CPU        | MPU          | MCU
-----------------|------------|--------------|------------------
Example          | i7, Ryzen  | Cortex-A72   | STM32, ESP32
Clock Speed      | 2–5 GHz    | 100 MHz–2 GHz| 8 MHz–500 MHz
Integrated RAM   | No         | No (ext.)    | Yes (KB–100s KB)
Integrated I/O   | No         | Limited      | Yes (extensive)
MMU/OS           | Required   | Supported    | Optional
Power Draw       | 50–150 W   | 1–10 W       | mW–100s mW
Typical OS       | Linux/Win  | Linux/RTOS   | Bare-metal/RTOS
Cost per unit    | $100–$500+ | $20–$100     | $2–$50
Best for         | Computers  | Gateways/etc | Embedded control

When to Use Which?

Use a CPU when:

• You need a general-purpose computer
• Running complex software (web servers, databases)
• Power consumption isn’t critical

Use an MPU when:

• You need an OS (Linux, QNX, VxWorks)
• Running multiple complex tasks (multithreading)
• Need memory protection between processes
• Industrial embedded systems, automotive

Use an MCU when:

• Simple, dedicated control tasks
• Battery-powered devices (IoT, wearables)
• Cost matters (need hundreds/thousands of units)
• No need for an OS
• Direct hardware control required

Key Takeaway

Think of it like transportation:

• CPU = A full-featured car with many options (general-purpose)
• MPU = A pickup truck that can tow and haul (embedded Linux systems)
• MCU = A motorcycle with essentials only (lightweight, efficient, focused)

Each has its place. MCUs power billions of embedded devices today, from your washing machine to your car’s dashboard. CPUs power your laptop. MPUs bridge the gap for systems that need more capability but still fit in embedded form factors.

Further Reading

• ARM Cortex processor families (M-series for MCUs, A-series for MPUs)
• Microcontroller datasheets (STM32, ESP32, PIC, AVR)
• Memory-mapped I/O and peripheral control