I2C EEPROM Read/Write with Arduino: A Complete Guide

Introduction

Have you ever needed to store configuration data or small amounts of non-volatile information in your Arduino projects? I2C EEPROMs are a perfect solution—they’re cheap, easy to use, and require only two wires for communication. In this tutorial, we’ll use the Velxio in-browser simulator to build a complete I2C EEPROM read/write test. You’ll learn how to write data to a virtual EEPROM at address 0x50 and read it back, verifying that everything works.

Velxio provides a SPICE-accurate analog simulation environment, so you can test your code without any physical hardware. Let’s dive in!

Circuit Walkthrough

The circuit is remarkably simple because the I2C EEPROM is integrated into the virtual environment. The only component we need is an Arduino Uno. The EEPROM is simulated internally and connected to the Arduino’s I2C pins (A4 for SDA and A5 for SCL). No external wiring is required—the simulator handles the I2C bus automatically.

To set up the circuit:

1. Open the Velxio editor and add an Arduino Uno from the component picker.
2. The I2C EEPROM is already part of the simulation; you don’t need to add it manually.
3. The code will communicate with the EEPROM at address 0x50.

You can find the Arduino Uno under the “Microcontrollers” category in the component picker. Once placed, the canvas will show the board ready for programming.

Code Walkthrough

Let’s examine the Arduino sketch that performs the read/write operations. The code is written in C++ using the standard Wire library for I2C communication.

// I2C EEPROM Read/Write Test
// Virtual EEPROM at address 0x50
// Writes values to registers, then reads them back.

#include <Wire.h>

#define EEPROM_ADDR 0x50

void writeEEPROM(byte reg, byte value) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);    // register address
  Wire.write(value);  // data
  Wire.endTransmission();
  delay(5); // EEPROM write cycle time
}

byte readEEPROM(byte reg) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(reg);
  Wire.endTransmission();

  Wire.requestFrom(EEPROM_ADDR, 1);
  if (Wire.available()) {
    return Wire.read();
  }
  return 0xFF;
}

void setup() {
  Wire.begin();
  Serial.begin(9600);

  Serial.println("============================");
  Serial.println(" I2C EEPROM R/W Test (0x50)");
  Serial.println("============================");
  Serial.println();

  // Write test pattern
  Serial.println("Writing test data...");
  for (byte i = 0; i < 8; i++) {
    byte value = (i + 1) * 10;  // 10, 20, 30, ...
    writeEEPROM(i, value);
    Serial.print("  Write reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.println(value);
  }

  Serial.println();
  Serial.println("Reading back...");

  // Read back and verify
  byte errors = 0;
  for (byte i = 0; i < 8; i++) {
    byte expected = (i + 1) * 10;
    byte actual = readEEPROM(i);
    Serial.print("  Read  reg[");
    Serial.print(i);
    Serial.print("] = ");
    Serial.print(actual);

    if (actual == expected) {
      Serial.println("  [OK]");
    } else {
      Serial.print("  [FAIL] expected ");
      Serial.println(expected);
      errors++;
    }
  }

  Serial.println();
  if (errors == 0) {
    Serial.println("All tests PASSED!");
  } else {
    Serial.print(errors);
    Serial.println(" test(s) FAILED.");
  }
}

void loop() {
  // Nothing to do
  delay(1000);
}

How the Code Works

• writeEEPROM(reg, value): This function sends the register address and data byte to the EEPROM. It uses Wire.beginTransmission(), Wire.write(), and Wire.endTransmission(). A 5 ms delay simulates the EEPROM’s write cycle time.
• readEEPROM(reg): First, it sends the register address to the EEPROM (a “dummy write”), then requests one byte using Wire.requestFrom(). If data is available, it reads and returns it; otherwise, it returns 0xFF.
• setup(): Initializes the Wire library and serial communication. It writes a test pattern (10, 20, 30, …) to registers 0 through 7, then reads them back and compares with expected values. Any mismatch increments an error counter.
• loop(): Empty, with a small delay to keep the board alive.

Key Concepts for Students

1. I2C Protocol: I2C uses two wires (SDA and SCL) and a 7-bit address to communicate with multiple devices. The EEPROM address 0x50 is common for many AT24C-series chips.
2. EEPROM Write Cycle: EEPROMs require a few milliseconds to write data internally. The delay(5) in writeEEPROM() ensures the write completes before the next operation.
3. Dummy Write for Read: To read from a specific register, you first send the register address (a write operation), then issue a repeated start or stop/start to read the data. The code uses a stop/start approach.
4. Error Checking: The sketch verifies each read against the expected value, which is a good practice for testing communication.

Common Pitfalls and Debugging Tips

• Wrong Address: Ensure the EEPROM address matches your device. The virtual EEPROM uses 0x50. If you get 0xFF back, the address might be wrong.
• Missing Pull-up Resistors: In real hardware, I2C lines need pull-up resistors. In Velxio, they are simulated internally, so you don’t need to add them.
• Serial Monitor: Use the Serial Monitor in Velxio to see the output. Click the Serial Monitor icon in the toolbar.
• Timing: If reads fail intermittently, increase the delay after writes. The virtual EEPROM is fast, but real devices may need more time.

Use the toolbar to compile and run your code. The Serial Monitor will display the test results.

Suggested Extensions

1. Write Larger Data: Modify the code to write and read a string or an array of bytes.
2. Page Write: Many EEPROMs support page writes (writing multiple bytes in one transaction). Try implementing that.
3. External EEPROM: Add a physical EEPROM component (if available in Velxio) and wire it to the Arduino.
4. Data Logging: Use the EEPROM to store sensor readings and retrieve them later.

Conclusion

You’ve successfully built an I2C EEPROM read/write test in Velxio! This project demonstrates the fundamentals of I2C communication and non-volatile memory. The virtual environment makes it easy to experiment without hardware. Now, try extending the code or integrating it into a larger project.

Ready to build your own? Open the live example in Velxio and start coding: I2C EEPROM Read/Write Example. Happy simulating!