Memory layout on a microcontroller (Flash, SRAM, EEPROM) in Embedded C

Introduction

Microcontrollers use different memory types to store code and data. Knowing where things go helps your program run correctly and saves space.

When you want to store your program code safely so it doesn't get lost when power is off.

When you need temporary space to keep data while your program runs.

When you want to save small amounts of data that must stay even after power off, like settings.

When debugging memory issues or optimizing your program size.

When writing embedded C programs that interact directly with hardware memory.

Syntax

Embedded C

/* Example memory sections in embedded C */

// Flash memory: stores program code
const char program_code[] = "Hello";

// SRAM: stores variables during program run
int runtime_variable = 10;

// EEPROM: stores data that must persist after power off
#include <avr/eeprom.h>
uint8_t EEMEM saved_value = 5;

Flash is non-volatile memory where your program code lives.

SRAM is fast, temporary memory for variables while the program runs.

Examples

This string is stored in Flash memory and does not change.

Embedded C

/* Flash stores program code */
const char greeting[] = "Hi!";

This variable is stored in SRAM and can change while the program runs.

Embedded C

/* SRAM stores variables during run */
int counter = 0;

This value is saved in EEPROM and keeps its value even if power is lost.

Embedded C

/* EEPROM stores persistent data */
#include <avr/eeprom.h>
uint8_t EEMEM config_value = 42;

EEPROM variable declared but not initialized, contains unknown data until set.

Embedded C

/* Edge case: empty EEPROM variable */
#include <avr/eeprom.h>
uint8_t EEMEM empty_value;

Sample Program

This program shows how Flash stores the program string, SRAM holds a copy for use, and EEPROM keeps a counter that survives power off.

Embedded C

#include <avr/io.h>
#include <avr/eeprom.h>
#include <util/delay.h>
#include <stdio.h>

// Simulated Flash data
const char flash_message[] = "Flash Memory";

// SRAM variable
char sram_buffer[20];

// EEPROM variable
uint8_t EEMEM eeprom_counter = 0;

int main(void) {
    // Copy flash message to SRAM buffer
    for (int i = 0; i < sizeof(flash_message); i++) {
        sram_buffer[i] = flash_message[i];
    }

    // Read EEPROM counter
    uint8_t counter = eeprom_read_byte(&eeprom_counter);

    // Increment counter and save back to EEPROM
    counter++;
    eeprom_write_byte(&eeprom_counter, counter);

    // Print values (simulated)
    printf("Flash message: %s\n", sram_buffer);
    printf("EEPROM counter: %d\n", counter);

    while (1) {
        _delay_ms(1000);
    }

    return 0;
}

Important Notes

Time complexity: Accessing Flash and SRAM is fast; EEPROM writes are slower and limited in number.

Space complexity: Flash is large for code; SRAM is smaller for variables; EEPROM is very small for persistent data.

Common mistake: Trying to write to Flash or SRAM to save data permanently. Use EEPROM for that.

Use EEPROM only for data that must survive power loss, because writing to it is slower and wears out memory.

Summary

Flash memory stores your program code and is non-volatile.

SRAM is temporary memory for variables while the program runs.

EEPROM stores small amounts of data that must stay after power off.

Practice

1. Which type of memory in a microcontroller is used to store the program code permanently?

easy

A. SRAM

B. Flash memory

C. EEPROM

D. Cache memory

Solution

1. Step 1: Understand memory types

   Flash memory is non-volatile and stores the program code permanently.

2. Step 2: Compare with other memories

   SRAM is temporary for variables, EEPROM stores small data but not the main program.

3. Final Answer:

   Flash memory -> Option B

4. Quick Check:

   Program code = Flash memory [OK]

Hint: Program code is always in Flash memory [OK]

Common Mistakes:

• Confusing SRAM with Flash memory
• Thinking EEPROM stores program code
• Assuming cache memory is used in microcontrollers

2. Which of the following declarations correctly places a variable in EEPROM memory in embedded C?

easy

A. int var __attribute__((section(".eeprom")));

B. int var __attribute__((section(".sram")));

C. int var __attribute__((section(".flash")));

D. int var __attribute__((section(".stack")));

Solution

1. Step 1: Identify EEPROM section syntax

   Variables placed in EEPROM use the section attribute ".eeprom" in embedded C.

2. Step 2: Check other options

   ".sram" is for SRAM, ".flash" for Flash, ".stack" is not a valid section for variables.

3. Final Answer:

   int var __attribute__((section(".eeprom"))); -> Option A

4. Quick Check:

   EEPROM section attribute = .eeprom [OK]

Hint: EEPROM variables use section ".eeprom" attribute [OK]

Common Mistakes:

• Using .sram or .flash instead of .eeprom
• Forgetting __attribute__ syntax
• Confusing stack with memory sections

3. Consider this embedded C code snippet:

const int x = 10;
int y = 20;
int main() {
  static int z = 30;
  return 0;
}

Where are the variables x, y, and z stored respectively?

medium

A. x in SRAM, y in EEPROM, z in Flash

B. x in EEPROM, y in Flash, z in EEPROM

C. x in Flash, y in EEPROM, z in SRAM

D. x in Flash, y in SRAM, z in SRAM

Solution

1. Step 1: Analyze variable storage rules

   Constants like x are stored in Flash memory. Global variables like y go to SRAM. Static variables like z also reside in SRAM during runtime.

2. Step 2: Match variables to memory types

   x = Flash, y = SRAM, z = SRAM.

3. Final Answer:

   x in Flash, y in SRAM, z in SRAM -> Option D

4. Quick Check:

   const = Flash, global/static = SRAM [OK]

Hint: const vars in Flash, globals and statics in SRAM [OK]

Common Mistakes:

• Assuming static variables go to EEPROM
• Thinking const variables are in SRAM
• Mixing EEPROM with Flash for constants

4. This embedded C code tries to store a variable in EEPROM:

int var __attribute__((section(".eeprom"))) = 5;
void main() {
  var = 10;
}

What is the main problem with this code?

medium

A. You cannot assign a new value to EEPROM variable at runtime like this

B. The section attribute syntax is incorrect

C. Variables in EEPROM must be declared as const

D. The main function must return int, not void

Solution

1. Step 1: Understand EEPROM write limitations

   EEPROM variables cannot be assigned new values by simple assignment at runtime; special functions are needed to write EEPROM.

2. Step 2: Check other code aspects

   The section attribute syntax is correct, variables need not be const, and main can be void in embedded C.

3. Final Answer:

   You cannot assign a new value to EEPROM variable at runtime like this -> Option A

4. Quick Check:

   EEPROM write needs special functions [OK]

Hint: EEPROM writes need special functions, not simple assignment [OK]

Common Mistakes:

• Assuming normal assignment writes EEPROM
• Thinking section attribute is wrong
• Confusing main return type with memory issues

5. You want to store a configuration value that must persist after power off and be modifiable during runtime on a microcontroller. Which memory type should you use and why?

hard

A. Cache memory, because it stores frequently used data

B. Flash, because it is fast and can be rewritten easily during runtime

C. EEPROM, because it retains data without power and allows runtime updates with special functions

D. SRAM, because it is volatile and fast for temporary storage

Solution

1. Step 1: Identify memory needs

   The value must persist after power off and be modifiable during runtime.

2. Step 2: Match memory type to needs

   EEPROM is non-volatile and supports runtime updates via special functions. Flash is non-volatile but rewriting is slower and more complex. SRAM is volatile and loses data on power off. Cache is not used for persistent storage.

3. Final Answer:

   EEPROM, because it retains data without power and allows runtime updates with special functions -> Option C

4. Quick Check:

   Persistent modifiable data = EEPROM [OK]

Hint: Use EEPROM for persistent, modifiable data [OK]

Common Mistakes:

• Choosing Flash for frequent runtime updates
• Using SRAM for persistent storage
• Confusing cache with persistent memory