A processor is useless alone. It must reach flash, RAM, a UART, a timer, a GPIO. How? Through one flat address space and a set of on-chip buses. Today you'll see how ARM wires a whole system together with the AMBA bus family — and why there are three different buses, not one.
ARM uses a single, flat 32-bit address space (4 GB of addresses). Everything lives somewhere in it: code, data, and peripherals. That last part is the key idea — memory-mapped I/O. There are no special "in/out" instructions like on x86; a peripheral register is just an address, and you control hardware with ordinary LDR/STR.
Cortex-M even standardises the broad layout: code at the bottom, SRAM next, a peripheral region, then private core space (where the NVIC lives) near the top.
The wires connecting the core to all those addresses follow AMBA (Advanced Microcontroller Bus Architecture) — ARM's royalty-free on-chip interconnect standards. The three you must know:
| Bus | Stands for | Built for |
|---|---|---|
| APB | Advanced Peripheral Bus | simple, low-power, slow peripherals |
| AHB | Advanced High-performance Bus | memory & high-bandwidth components |
| AXI | Advanced eXtensible Interface | high-performance, multi-master SoCs |
APB is deliberately minimal: no pipelining, no bursts, single transfers, low gate count and low power. Perfect for a timer, UART, SPI or GPIO block that's never the bottleneck. Each transfer has a simple setup then access phase (the PSEL/PENABLE/PREADY handshake). If you've used our Register-Map Generator or AXI-to-APB bridge, that's APB on the peripheral side.
AHB is pipelined (address phase of the next transfer overlaps the data phase of the current one) and supports burst transfers, giving much higher throughput. It's used for the things that are on the critical path: flash, SRAM, the memory controller, DMA, a USB or Ethernet block. A Cortex-M typically has an AHB-based bus matrix at its heart.
AXI is the heavyweight, used in application-class (Cortex-A) SoCs. Its defining features:
That parallelism is why AXI feeds DDR controllers, GPUs and large interconnects where bandwidth is everything.
You don't put a slow UART on a fast AXI bus — you'd waste the bus. Instead, a bridge connects bus domains: it's a slave on the fast side and a master on the slow side, translating one protocol to the other.
The bus matrix (or interconnect) is the crossbar that lets multiple masters (CPU, DMA) reach multiple slaves (RAM, peripherals) — ideally in parallel when they target different slaves. This whole structure is what the SoC integration world spends its days assembling.
ARM puts everything in one address space and talks to it via memory-mapped I/O. The AMBA buses match each component to its needs: APB for cheap slow peripherals, AHB for fast pipelined memory traffic, AXI for high-bandwidth parallel systems — stitched together by bridges and a bus matrix.
The layout of the single address space, assigning ranges to flash, RAM and memory-mapped peripherals.
APB = simple/slow peripherals; AHB = fast pipelined memory; AXI = high-performance, separate read/write channels, out-of-order.
To connect a fast bus to slow APB peripherals without burdening the fast bus — slave on one side, master on the other.