EEPROM read and write in Arduino - Step-by-Step Execution

Concept Flow - EEPROM read and write

Start

↓

Write data to EEPROM

↓

Read data from EEPROM

↓

Use or display data

↓

End

This flow shows writing data to EEPROM, then reading it back to use or display.

Execution Sample

Arduino

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);
  EEPROM.write(0, 42);
  int val = EEPROM.read(0);
  Serial.println(val);
}

void loop() {}

Writes 42 to EEPROM address 0, reads it back, and prints it to serial.

Execution Table

Step	Action	Address	Value Written	Value Read	Output
1	Write to EEPROM	0	42
2	Read from EEPROM	0		42
3	Print value				42
4	End				Execution stops

💡 Program ends after printing the EEPROM value.

Variable Tracker

Variable	Start	After Write	After Read	Final
EEPROM[0]	unknown	42	42	42
val	undefined	undefined	42	42

Key Moments - 3 Insights

Why do we write to EEPROM before reading?

Because EEPROM stores data persistently, we must write data first to have something to read back, as shown in steps 1 and 2 of the execution table.

What happens if we read from an EEPROM address that was never written?

The value read may be random or default (often 255), since EEPROM memory retains old or default data until written, as implied by the initial 'unknown' state in variable_tracker.

Why do we use Serial.begin before printing?

Serial.begin initializes communication with the computer so Serial.println can send data, which is necessary before printing the value in step 3.

Visual Quiz - 3 Questions

Look at the execution table, what value is read from EEPROM at step 2?

A undefined

B 0

C 42

D 255

💡 Hint

Check the 'Value Read' column at step 2 in the execution_table.

At which step does the program print the EEPROM value?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Output' column in the execution_table to find when printing happens.

If we change EEPROM.write(0, 100), what will be printed at step 3?

A 100

B 0

C 42

D undefined

💡 Hint

Refer to variable_tracker and execution_table to see how written value affects read and output.

Concept Snapshot

EEPROM.write(address, value) stores a byte persistently.
EEPROM.read(address) retrieves the stored byte.
Always write before reading to get valid data.
Use Serial.begin() before printing.
EEPROM retains data after power off.

Full Transcript

This example shows how Arduino EEPROM memory can store data permanently. First, the program writes the number 42 to EEPROM address 0. Then it reads back the value from the same address. Finally, it prints the value to the serial monitor. The execution table traces each step: writing, reading, and printing. The variable tracker shows how EEPROM[0] changes from unknown to 42, and how the variable val holds the read value. Key moments clarify why writing must happen before reading and why serial communication must start before printing. The quiz tests understanding of these steps and how changing the written value affects output.

Practice

1. What does EEPROM.write(address, value) do in Arduino?

easy

A. Stores a byte value at the specified EEPROM address

B. Reads a byte value from the specified EEPROM address

C. Deletes all data from EEPROM

D. Initializes the EEPROM memory

Solution

1. Step 1: Understand EEPROM.write function

   The function EEPROM.write(address, value) saves a byte value at the given address in EEPROM memory.

2. Step 2: Differentiate from EEPROM.read

   EEPROM.read(address) is used to read data, not write it.

3. Final Answer:

   Stores a byte value at the specified EEPROM address -> Option A

4. Quick Check:

   EEPROM.write saves data [OK]

Hint: Write saves data, read retrieves data from EEPROM [OK]

Common Mistakes:

• Confusing write with read function
• Thinking EEPROM.write clears memory
• Assuming EEPROM.write initializes EEPROM

2. Which of the following is the correct syntax to read a byte from EEPROM at address 10?

easy

A. EEPROM.get(10);

B. EEPROM.write(10);

C. EEPROM.readByte(10);

D. EEPROM.read(10);

Solution

1. Step 1: Identify correct EEPROM read syntax

   The correct function to read a byte from EEPROM is EEPROM.read(address).

2. Step 2: Check options for exact match

   Only EEPROM.read(10); matches the correct syntax.

3. Final Answer:

   EEPROM.read(10); -> Option D

4. Quick Check:

   EEPROM.read(address) reads byte [OK]

Hint: Use EEPROM.read(address) to get stored byte [OK]

Common Mistakes:

• Using EEPROM.write to read data
• Using non-existent EEPROM.readByte function
• Confusing EEPROM.get with EEPROM.read

3. What will be the output of this Arduino code snippet?

EEPROM.write(5, 42);
byte val = EEPROM.read(5);
Serial.println(val);

medium

A. 0

B. 42

C. 5

D. Undefined behavior

Solution

1. Step 1: Write value 42 at EEPROM address 5

   The code stores the byte 42 at address 5 using EEPROM.write(5, 42);.

2. Step 2: Read the value back from address 5

   EEPROM.read(5) reads the stored value, which is 42.

3. Final Answer:

   42 -> Option B

4. Quick Check:

   Write 42, read 42 [OK]

Hint: Write then read same address returns stored value [OK]

Common Mistakes:

• Assuming EEPROM.read returns address instead of value
• Forgetting to write before reading
• Expecting default 0 without writing

4. Identify the error in this code snippet:

EEPROM.write(1024, 100);
byte val = EEPROM.read(1024);
Serial.println(val);

medium

A. Serial.println cannot print byte values

B. EEPROM.write requires two arguments

C. Address 1024 is out of EEPROM range

D. EEPROM.read cannot be assigned to byte

Solution

1. Step 1: Check EEPROM address range

   Typical Arduino EEPROM size is 1024 bytes, so address 1024 is out of range (valid addresses are 0-1023).

2. Step 2: Validate other code parts

   EEPROM.write has correct arguments, EEPROM.read returns byte, and Serial.println can print bytes.

3. Final Answer:

   Address 1024 is out of EEPROM range -> Option C

4. Quick Check:

   EEPROM address must be within 0-1023 [OK]

Hint: EEPROM addresses start at 0, max 1023 on typical boards [OK]

Common Mistakes:

• Using address equal to EEPROM size
• Assuming EEPROM size is larger than actual
• Misunderstanding Serial.println capabilities

5. You want to store a user's high score (an integer between 0 and 1000) in EEPROM. Which approach correctly saves and reads this value?

hard

A. Use EEPROM.put(address, highScore); and EEPROM.get(address, highScore);

B. Use EEPROM.write(address, highScore); and EEPROM.read(address);

C. Use EEPROM.write(address, highScore % 256); only

D. Use EEPROM.read(address); to save and EEPROM.write(address, highScore); to read

Solution

1. Step 1: Understand data size and EEPROM functions

   High score is an integer (2 bytes), so EEPROM.write (1 byte) is insufficient to store full value.

2. Step 2: Use EEPROM.put and EEPROM.get for multi-byte data

   EEPROM.put(address, highScore); saves the entire integer, and EEPROM.get(address, highScore); reads it back correctly.

3. Final Answer:

   Use EEPROM.put(address, highScore); and EEPROM.get(address, highScore); -> Option A

4. Quick Check:

   Use put/get for multi-byte data [OK]

Hint: Use EEPROM.put/get for integers, write/read for bytes [OK]

Common Mistakes:

• Using EEPROM.write for multi-byte integers
• Not reading back with EEPROM.get
• Mixing read and write roles