ARM Cortex-M Architecture Overview

The Big Picture: What is a Microcontroller?

In your computer architecture courses, you studied general-purpose processors like those in laptops or servers. A microcontroller (MCU) is different; it's a complete computer on a single chip, designed specifically for control tasks in embedded systems.

Let's look at a typical structure.

This diagram shows the main idea: a central processing core (the Cortex-M4) is surrounded by a collection of specialized hardware blocks called peripherals. These are all connected by a system bus, which is an internal communication highway.

To formalize this, please read a short introduction on what makes a microcontroller distinct.

The key takeaway is that a company like STMicroelectronics or NXP licenses the core design from ARM (the designer) and then integrates it with their own set of peripherals to create a final microcontroller product. The Cortex-M4 is a popular core, but it's part of a larger family.

The Core: The "Brain" of the MCU

Now let's zoom in on the CPU itself. The core is responsible for executing your program's instructions. A Cortex-M core is more than just a CPU; it includes several tightly integrated components that are standard across all microcontrollers that use it.

This video gives an excellent walkthrough of the components that make up a Cortex-M4 core.

As you saw, the core isn't just a raw processor. It includes critical subsystems like:

• CPU: The processor that runs the ARMv7-M instruction set.
• NVIC (Nested Vectored Interrupt Controller): A sophisticated interrupt manager. We'll dedicate a whole module to this later, but for now, know that it's the hardware responsible for handling events from peripherals.
• SysTick Timer: A standard, 24-bit timer available on all Cortex-M devices, often used by operating systems for scheduling.
• Debug/Trace Hardware (DAP, ETM): Interfaces for programming and debugging the chip.
• Optional Components: A vendor can choose whether to include features like a Floating Point Unit (FPU) for faster math with non-integers, or a Memory Protection Unit (MPU) to enforce access rules for different parts of memory.

Programmer's Model: The Registers

From a programming perspective, the most immediate part of the core you interact with is its set of registers. Like any RISC processor, the Cortex-M is a load/store architecture, meaning most operations happen on data held in registers.

The following segment of the same video explains the register set.

To summarize, the Cortex-M programmer's model gives you:

• General-Purpose Registers (R0-R12): Used for data manipulation and calculations.
• Special-Purpose Registers:
  • R13 (Stack Pointer - SP): Points to the top of the current stack. The core actually has two stack pointers (Main and Process) to cleanly separate the operating system from user applications, a key feature for robust systems.
  • R14 (Link Register - LR): Stores the return address when calling a function.
  • R15 (Program Counter - PC): Always points to the address of the next instruction to be executed.
• Program Status Register (PSR): A special register that holds status flags about the result of recent operations (e.g., was the result zero? negative?), the current interrupt status, and other CPU state information.

This register set should feel conceptually familiar from your computer architecture studies. The key difference here is its direct application to controlling a single, self-contained system.

The Peripherals: The "Senses and Muscles"

The core is powerful, but it can't do anything without peripherals to connect it to the outside world. Think of peripherals as specialized employees, each hired to do one job very well. The core acts as the manager, configuring these employees and telling them when to act.

Referring back to the block diagram, you can see a variety of common peripherals:

• GPIO (General Purpose Input/Output): The simplest peripheral. It allows you to control individual digital pins as inputs (to read a button) or outputs (to blink an LED).
• Timers: Incredibly versatile hardware for generating precise delays, creating periodic events (interrupts), and producing signals like PWM to control motor speed or LED brightness.
• Communication Peripherals (UART, I²C, SPI, CAN): These implement standard protocols for sending and receiving data between your MCU and other chips, sensors, or computers.
• ADC (Analog-to-Digital Converter): Reads analog voltages from sensors (like a temperature sensor or potentiometer) and converts them into digital values the CPU can understand.

We will dedicate entire lessons to programming these peripherals later in the course. For now, the important thing is to recognize them as the hardware interfaces for your software.

The Memory Map: The "Address Book"

So, we have a core that executes code and a set of peripherals that interact with the world. How does the core actually control the peripherals? The answer lies in the memory map.

An ARM Cortex-M processor has a unified 32-bit address space, meaning it can access up to 4 Gigabytes (2³²) of memory. This entire space is laid out according to a standard plan.

This video provides a fantastic visual explanation of the memory map concept.

Here is a typical memory map diagram that visualizes this layout.

The key regions are:

1. Code (Flash): This is where your program itself is stored. It's non-volatile memory, meaning it retains its content when the power is off. It's typically Flash memory.
2. SRAM: This is the primary RAM for your application. It's used for read/write data, such as variables, and for the stack. It is volatile, so its contents are lost when power is removed.
3. Peripheral: This is the crucial region for hardware control. Every function of every peripheral—its configuration, its status, the data it sends or receives—is controlled by special registers. These registers are "mapped" to specific addresses within this 0.5GB block.
4. External RAM/Devices: These regions are for accessing memory or devices that are off-chip, such as an external SD card or an LCD screen.

This architecture leads to a powerful concept that is fundamental to all embedded programming: Memory-Mapped I/O.

The concept of memory-mapped I/O is where your C/C++ knowledge directly connects to hardware. To turn on an LED, you don't use a special instruction. You simply write a specific value to a specific memory address that corresponds to a GPIO peripheral's control register. Hardware control becomes an exercise in pointer manipulation, a concept that will be central to this course.

Conclusion

In this lesson, we've constructed a high-level mental model of an ARM Cortex-M microcontroller. Let's recap the key takeaways:

• A microcontroller is a self-contained computer on a chip, combining a CPU core with memory and peripherals.
• The ARM Cortex-M core is the "brain," featuring a set of general-purpose and special-purpose registers (PC, SP, LR) for executing code.
• Peripherals like GPIO, UART, and Timers are the "senses and muscles," enabling the microcontroller to interact with the physical world.
• The entire system is organized around a unified memory map, where specific address ranges are reserved for program code (Flash), data (SRAM), and hardware control (Peripherals).
• The mechanism for controlling hardware is memory-mapped I/O, where writing to or reading from specific memory addresses manipulates the peripheral control registers.

In our next lesson, we will get practical and learn how to navigate the official manufacturer documentation—the datasheet and reference manual—to find the exact addresses and bit-level details needed to control these peripherals.