EEPROM for storing settings in Arduino - Deep Dive

Overview - EEPROM for storing settings

What is it?

EEPROM is a special memory inside microcontrollers like Arduino that keeps data even when the power is off. It is used to store small pieces of information like settings or preferences. Unlike regular memory, EEPROM remembers the data after the device is turned off. This makes it perfect for saving things like user choices or calibration values.

Why it matters

Without EEPROM, every time you turn off your Arduino, it would forget important settings and start fresh. This means you would have to set everything again manually, which is inconvenient and error-prone. EEPROM solves this by providing a simple way to save and recall data, making devices smarter and more user-friendly.

Where it fits

Before learning EEPROM, you should understand basic Arduino programming and how variables work. After EEPROM, you can explore more advanced memory management techniques or external storage options like SD cards.

Mental Model

Core Idea

EEPROM is like a tiny notebook inside your Arduino that remembers your settings even when the power is off.

Think of it like...

Imagine you have a small diary where you write down your favorite TV channel. Even if you turn off the TV, the diary keeps your favorite channel safe so you don’t have to remember it every time.

┌─────────────┐
│   Arduino   │
│  Microcontroller  │
│             │
│  ┌───────┐  │
│  │ EEPROM│  │  <-- Non-volatile memory stores settings
│  └───────┘  │
└─────────────┘

Build-Up - 6 Steps

1

Foundation

What is EEPROM Memory

Concept: Introduce EEPROM as a type of memory that keeps data without power.

EEPROM stands for Electrically Erasable Programmable Read-Only Memory. It is a small part of the Arduino chip that can save data permanently. Unlike normal variables that lose their value when the Arduino resets or powers off, EEPROM keeps the data safe.

Result

You understand that EEPROM is special memory that remembers data after power off.

Knowing EEPROM is non-volatile memory helps you understand why it is useful for saving settings.

2

Foundation

Basic EEPROM Read and Write

Concept: Learn how to read from and write to EEPROM using Arduino commands.

Arduino provides two main functions: EEPROM.read(address) to get a byte from EEPROM, and EEPROM.write(address, value) to save a byte. The address is like a page number in the EEPROM notebook. You can store numbers between 0 and 255 in each address.

Result

You can save and retrieve a single byte of data from EEPROM.

Understanding the address and byte size is key to managing EEPROM data correctly.

3

Intermediate

Storing Multiple Settings Safely

🤔Before reading on: do you think you can store any type of data directly in EEPROM or only bytes? Commit to your answer.

Concept: Learn how to store multiple settings and different data types by breaking them into bytes.

EEPROM stores data one byte at a time. To save bigger data like integers or floats, you split them into bytes. Arduino's EEPROM library also has EEPROM.put() and EEPROM.get() functions that handle this automatically. You assign each setting a unique address range to avoid overwriting.

Result

You can save and load multiple settings of different types without data loss.

Knowing how to organize EEPROM addresses prevents data corruption and makes your program reliable.

4

Intermediate

Minimizing EEPROM Wear

🤔Before reading on: do you think EEPROM can be written unlimited times without damage? Commit to your answer.

Concept: Understand EEPROM has a limited number of write cycles and how to reduce wear.

EEPROM can only be written about 100,000 times before it may wear out. To protect it, avoid writing data repeatedly in a loop. Instead, write only when settings change. You can also use techniques like wear leveling, which spreads writes across different addresses.

Result

You learn to write EEPROM data efficiently to extend its life.

Knowing EEPROM's limits helps you design programs that last longer and avoid unexpected failures.

5

Advanced

Using EEPROM for Complex Settings Structures

🤔Before reading on: do you think you must manually handle every byte when saving structs, or can Arduino help? Commit to your answer.

Concept: Learn how to save and load entire structures or objects using EEPROM.put() and EEPROM.get().

You can define a struct to group related settings, like volume and brightness. Using EEPROM.put(address, struct) saves the whole struct at once. EEPROM.get(address, struct) reads it back. This simplifies code and reduces errors. Just be careful with struct size and address boundaries.

Result

You can store complex settings in EEPROM easily and safely.

Using structs with EEPROM functions makes your code cleaner and less error-prone.

6

Expert

Advanced EEPROM Management and Debugging

🤔Before reading on: do you think EEPROM data always stays correct, or can it get corrupted? Commit to your answer.

Concept: Explore how to detect and handle EEPROM data corruption and implement versioning.

EEPROM data can get corrupted due to power loss or bugs. To detect this, store a checksum or a version number with your data. On startup, verify the checksum before using settings. If invalid, reset to defaults. Also, consider backing up critical data in multiple EEPROM locations.

Result

You can build robust systems that handle EEPROM errors gracefully.

Understanding data integrity techniques prevents mysterious bugs and improves device reliability.

Under the Hood

EEPROM memory uses floating-gate transistors to trap electric charge, which holds data even without power. Writing data involves applying higher voltage to change the charge state, which takes longer than normal memory writes. Reading is fast and simple. The limited write cycles come from the physical wear on these transistors during voltage changes.

Why designed this way?

EEPROM was designed to provide a small, reliable, non-volatile memory inside microcontrollers without needing extra hardware. It balances cost, size, and durability. Alternatives like flash memory are larger but have different wear characteristics. EEPROM's byte-level access is simpler for small settings storage.

┌───────────────┐
│   EEPROM Cell │
│  ┌─────────┐  │
│  │ Floating│  │
│  │ Gate    │  │  <-- Stores charge representing 0 or 1
│  └─────────┘  │
│               │
│ Write: High Voltage changes charge
│ Read: Detect charge state
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think EEPROM can be written unlimited times without damage? Commit to yes or no.

Common Belief: EEPROM can be written as many times as you want without any problem.

Reality: EEPROM has a limited number of write cycles (about 100,000) before it may wear out.

Why it matters: Ignoring this can cause your device to fail unexpectedly after heavy use.

Quick: Do you think EEPROM automatically saves variables when you assign them? Commit to yes or no.

Common Belief: Assigning a variable in Arduino automatically saves it to EEPROM.

Reality: Variables in RAM do not save to EEPROM unless you explicitly write them using EEPROM functions.

Why it matters: Assuming automatic saving leads to lost data after power off.

Quick: Do you think EEPROM data is always safe and never corrupted? Commit to yes or no.

Common Belief: Once data is saved in EEPROM, it will never get corrupted.

Reality: EEPROM data can get corrupted due to power loss during write or hardware issues.

Why it matters: Not checking data integrity can cause your program to use wrong settings and behave unpredictably.

Quick: Do you think you can store any size of data in EEPROM without planning? Commit to yes or no.

Common Belief: You can store large amounts of data in EEPROM without worrying about size or address conflicts.

Reality: EEPROM size is limited (usually 512 or 1024 bytes), and improper address management can overwrite data.

Why it matters: Overwriting data causes loss of settings and bugs that are hard to trace.

Expert Zone

1

EEPROM write operations are slow compared to RAM, so timing-sensitive code should minimize EEPROM access.

2

Using EEPROM.put() and EEPROM.get() handles data alignment and type safety better than manual byte operations.

3

Wear leveling is rarely implemented in simple Arduino projects but is critical in long-term industrial applications.

When NOT to use

EEPROM is not suitable for storing large files or data that changes very frequently. For such cases, use external SD cards or FRAM memory which have higher capacity and endurance.

Production Patterns

In real devices, EEPROM is used to store calibration data, user preferences, and device IDs. Often, a version number and checksum are stored alongside settings to detect corruption. Firmware updates may include EEPROM format changes requiring migration code.

Connections

Flash Memory

Related non-volatile memory with larger capacity but different write characteristics.

Understanding EEPROM helps grasp flash memory behavior, as both store data without power but have different endurance and access methods.

File Systems

Builds on EEPROM by managing data storage in larger, organized ways on external media.

Knowing EEPROM basics makes it easier to understand how file systems store and retrieve data persistently.

Human Memory

Analogous to short-term vs long-term memory in humans.

EEPROM is like long-term memory that keeps information safe over time, while RAM is like short-term memory that forgets quickly.

Common Pitfalls

#1 Writing EEPROM data inside a fast loop without condition.

Wrong approach:

void loop() {
EEPROM.write(0, 42); // writes every cycle
}

Correct approach:

void loop() {
static int lastValue = -1;
int newValue = 42;
if (newValue != lastValue) {
EEPROM.write(0, newValue);
lastValue = newValue;
}
}

Root cause:

Not realizing EEPROM has limited write cycles and writing too often causes premature wear.

#2 Assuming EEPROM.read() returns the last variable value automatically.

Wrong approach:

int setting = 10;
void setup() {
setting = 10; // expecting EEPROM to save this
}
void loop() {
// use setting
}

Correct approach:

int setting;
void setup() {
setting = EEPROM.read(0); // explicitly read from EEPROM
}
void loop() {
// use setting
}

Root cause:

Misunderstanding that variables in RAM and EEPROM are separate and require explicit read/write.

#3 Ignoring EEPROM size and overlapping addresses.

Wrong approach:

EEPROM.write(0, 1);
EEPROM.write(0, 2); // overwrites previous data
EEPROM.write(1, 3);

Correct approach:

EEPROM.write(0, 1);
EEPROM.write(1, 2); // use different addresses
EEPROM.write(2, 3);

Root cause:

Not planning EEPROM address allocation leads to data overwriting and loss.

Key Takeaways

EEPROM is a small, non-volatile memory inside Arduino that keeps data even when power is off.

You must explicitly read and write EEPROM data using Arduino functions; variables do not save automatically.

EEPROM has limited write cycles, so minimize writes to extend its life.

Use EEPROM.put() and EEPROM.get() to store complex data types safely and easily.

Always plan EEPROM address usage and consider data integrity checks to avoid corruption.