Chapter 2: Memory Architecture

Harvard vs Von Neumann

Before diving into specifics, it helps to understand the two fundamental memory architectures.

Von Neumann architecture uses a single address space for both program code and data. Reading an instruction and reading a variable share the same bus. Most general-purpose computers use this model.

Harvard architecture uses separate buses and address spaces for program memory and data memory. Code and data cannot be mixed without explicit hardware support. AVR microcontrollers are strict Harvard machines. The ESP32 is a modified Harvard architecture — it has separate instruction and data caches, but the underlying SPI Flash is accessible as both code and data through different mechanisms.

This distinction has a direct practical consequence: on AVR, a constant string in your sketch lives in Flash by default only if you place it there explicitly. Otherwise the compiler copies it into SRAM at startup.

Arduino (AVR) Memory Map

A typical ATmega328P (Arduino Uno) has three distinct memory regions:

Flash (Program Memory) — 32 KB

• Stores compiled machine code and constant data marked with PROGMEM
• Non-volatile: survives power-off
• Can be written by the bootloader (upload) but not easily at runtime
• Addressed separately from SRAM; requires special instructions (LPM) to read

SRAM (Data Memory) — 2 KB

• The working memory of the CPU
• Divided into three regions at runtime:

High address  ┌─────────────┐
              │   Stack     │  grows downward
              │      ↓      │
              │  (free RAM) │
              │      ↑      │
              │    Heap     │  grows upward (malloc/new)
              │─────────────│
              │    BSS      │  zero-initialized globals
              │─────────────│
              │    Data     │  initialized globals/statics
Low address   └─────────────┘

• Stack and heap grow toward each other; when they meet, you get stack overflow or heap corruption
• All local variables, function call frames, and interrupt contexts live on the stack

EEPROM — 1 KB

• Non-volatile byte-addressable storage
• Survives power-off; rated for ~100,000 write cycles
• Accessed via the EEPROM.h library
• Much slower than SRAM reads (3.4 ms per write)

ATmega Variants

ESP32 Memory Map

The ESP32 has a richer memory landscape. The internal memory is split into several named regions, each with different properties.

Internal SRAM

The ESP32 has approximately 520 KB of internal SRAM divided into three banks:

SRAM0 (192 KB) — IRAM

• Used for instruction RAM: code that must execute from RAM rather than Flash
• ISR handlers, time-critical functions, and the WiFi stack are placed here
• Accessible as data memory when not fully used by code
• Attribute: IRAM_ATTR

SRAM1 (128 KB) — DRAM/IRAM shared

• Lower portion used as DRAM (data RAM)
• Upper portion can be used as IRAM

SRAM2 (200 KB) — DRAM

• Used as general-purpose data RAM
• Partially used by the Bluetooth stack when BT is enabled

In practice, after the system libraries (WiFi stack, BT stack, FreeRTOS), you typically have 200–300 KB of heap available.

RTC Memory — 16 KB

• RTC Fast Memory (8 KB): accessible by main CPU and survives deep sleep. Used to store variables that must persist across sleep cycles. Attribute: RTC_DATA_ATTR
• RTC Slow Memory (8 KB): accessible by the ULP co-processor during deep sleep. Used for ULP programs and shared data with the ULP.

// Variable that survives deep sleep
RTC_DATA_ATTR int bootCount = 0;

External PSRAM (optional)

Some ESP32 modules (e.g., ESP32-WROVER) include 4 or 8 MB of external PSRAM (pseudo-static RAM) connected via SPI. It is slower than internal SRAM (higher latency, lower bandwidth) but dramatically increases available heap for large buffers, image processing, or web serving.

Enable in Arduino-ESP32: Board settings → PSRAM → Enabled.

SPI Flash — 4–16 MB

External Flash chip connected via SPI (or QSPI). Contains:

• Bootloader
• Application firmware (one or two OTA slots)
• NVS (non-volatile storage) partition
• SPIFFS or LittleFS filesystem partition
• Factory/custom partitions

Flash is not directly addressable as RAM. Code is fetched through a cache (MMU), and data must be explicitly read via APIs.

ESP32 Memory Summary

Checking Memory at Runtime

Arduino (AVR)

extern int __heap_start, *__brkval;

int freeRam() {
    int v;
    return (int)&v - (__brkval == 0
        ? (int)&__heap_start
        : (int)__brkval);
}

ESP32

void printMemInfo() {
    Serial.printf("Free heap: %u bytes\n", ESP.getFreeHeap());
    Serial.printf("Min free heap: %u bytes\n", ESP.getMinFreeHeap());
    Serial.printf("Free PSRAM: %u bytes\n", ESP.getFreePsram());
}