Understanding AMBA for Programmers: Reading APB, AHB, and AXI Buses Through Specifications and Boards

What You’ll Gain from This Course

You’ll be able to draw a diagram showing the path a line of code you wrote takes inside the chip. When a value you wrote doesn’t take effect right away, something acts up only occasionally, or the same code is fast in one place and slow in another, you’ll be able to explain why instead of just guessing.

I wrote a value to a register, so why hasn’t it changed yet?

We learned that code runs one line at a time, from top to bottom. But inside the chip, the value I wrote leaves the CPU and travels along a path, sometimes waiting along the way or changing order with other requests. If you don’t understand this path, you may dismiss a “strange problem that only happens sometimes” as bad luck or a timing issue.

In this course, we’ll trace those paths by drawing them by hand from scratch. We’ll open the original documents that spell out the rules of the paths, highlight the relevant sentences, and verify them using measurements taken on an actual board.

From slow side streets to the highway

There isn’t just one road inside a chip. There’s a slow, simple road to peripherals, a wide road to memory, and a highway where multiple requests travel at once. This course starts with the easy road and works its way up, showing how the rules learned earlier change on each new road.

Why On-Chip Interconnects Matter Now

Modern chips contain multiple CPU cores, various accelerators, and numerous peripherals. The rules governing how these components exchange data are widely based on Arm’s AMBA. So no matter which chip you’re using, you’ll find a diagram of these pathways when you open its manual.

As tools that write code for you become more common, the value of developers who can explain why it behaves that way inside the chip grows even greater.

What You'll Learn

Gaps I’ve seen in 18 years of teaching in the field

Since 2008, I’ve taught developers at companies and institutions. Over the years, I’ve met many developers who write good code but don’t know much about the memory and buses that their code runs on.

• They know that a wider bus is faster, but they can’t explain why.

• They can’t explain the real reason you can’t add as much memory to a board as you want.

• They don’t know what the memory controller does, so they get stuck when they first power up a newly built board and try to initialize the memory.

These blanks aren’t isolated from one another. Once you understand the paths inside the chip, they all fall into place at once. The number of address lines determines the upper limit of addressable memory, while the number of data lines determines how much can be transferred at a time. The memory controller is a translator that converts the bus’s language into the memory’s language, so the boot code must first tell it the width and speed of the connected memory. And most importantly, you start to see at a glance how the entire board is interconnected.

This course also answers the question I’ve heard most often in the field, “The code is correct, so why does it only act up sometimes?” with one diagram of the paths inside the chip and one number from the board.

AMBA Explained by a Software Developer, Since 2008

I am not a chip designer. I’ve been an embedded software developer from the very beginning, I am now, and I will continue to be one. But I’ve always been interested in hardware, so I studied assembly on my own. After working with ARM processors for a long time, I naturally became curious about the paths inside the chip that my code travels—the AMBA bus.

In 2008, wanting to leave a record somewhere of what I’d studied on my own, I posted a series titled 'Understanding AMBA' on my blog. Writing from the perspective of someone who writes code on top of circuits, rather than someone who designs them, I illustrated the timing diagrams in the specifications one step at a time. Back when it was hard to find clear explanations of AMBA in Korean, people were already leaving comments saying they were learning from the series and grateful for it—and they still do, 17 years later.

This course expands that explanation to cover AXI and the latest specifications, adds measurements taken on an actual board, and presents it as a new video. That’s why it explains everything from start to finish from a programmer’s perspective.

For those who could write code but saw the inside of a chip as a black box

It's okay if you've never heard the term “bus” before. Experience writing values to and reading them from registers is enough. By the end of this course, you'll be able to read the bus diagrams in chip manuals that you may have skipped over, thinking, “That's hardware stuff.”

I also recommend this course to chip designers. It shows you the other side of the equation: how software uses the hardware you create. Once you see what kinds of bugs a single error signal or a buffer that temporarily holds writes can cause for programmers, you’ll start thinking about what else to consider when designing and what to document in the manual.

What Makes This Course Unique

Actual lecture screen

Lab Environment

Frequently Asked Questions

Recommended courses

• ARM Cortex-M Processor Programming

• FreeRTOS Programming 2 - RTOS Design and Debugging Through 40 Real-World Failures