Lectura/Escritura de EEPROM I2C con Arduino: Guía Completa

Introducción

¿Alguna vez has necesitado almacenar datos de configuración o pequeñas cantidades de información no volátil en tus proyectos con Arduino? Las EEPROM I2C son una solución perfecta: son baratas, fáciles de usar y solo requieren dos cables para la comunicación. En este tutorial, usaremos el simulador en navegador Velxio para construir una prueba completa de lectura/escritura de EEPROM I2C. Aprenderás cómo escribir datos en una EEPROM virtual en la dirección 0x50 y leerlos de vuelta, verificando que todo funciona.

Velxio proporciona un entorno de simulación analógica preciso a nivel SPICE, por lo que puedes probar tu código sin necesidad de hardware físico. ¡Vamos a ello!

Recorrido del Circuito

El circuito es notablemente simple porque la EEPROM I2C está integrada en el entorno virtual. El único componente que necesitamos es un Arduino Uno. La EEPROM se simula internamente y está conectada a los pines I2C del Arduino (A4 para SDA y A5 para SCL). No se requiere cableado externo: el simulador maneja el bus I2C automáticamente.

Para montar el circuito:

1. Abre el editor de Velxio y añade un Arduino Uno desde el selector de componentes.
2. La EEPROM I2C ya forma parte de la simulación; no es necesario añadirla manualmente.
3. El código se comunicará con la EEPROM en la dirección 0x50.

Puedes encontrar el Arduino Uno en la categoría “Microcontroladores” del selector de componentes. Una vez colocado, el lienzo mostrará la placa lista para programar.

Recorrido del Código

Examinemos el sketch de Arduino que realiza las operaciones de lectura/escritura. El código está escrito en C++ utilizando la librería estándar Wire para la comunicación I2C.

// 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);
}

Cómo Funciona el Código

• writeEEPROM(reg, value): Esta función envía la dirección del registro y el byte de datos a la EEPROM. Utiliza Wire.beginTransmission(), Wire.write() y Wire.endTransmission(). Un retardo de 5 ms simula el tiempo del ciclo de escritura de la EEPROM.
• readEEPROM(reg): Primero, envía la dirección del registro a la EEPROM (una “escritura ficticia”), luego solicita un byte usando Wire.requestFrom(). Si hay datos disponibles, los lee y los devuelve; de lo contrario, devuelve 0xFF.
• setup(): Inicializa la librería Wire y la comunicación serie. Escribe un patrón de prueba (10, 20, 30, …) en los registros 0 a 7, luego los lee de vuelta y los compara con los valores esperados. Cualquier discrepancia incrementa un contador de errores.
• loop(): Vacío, con un pequeño retardo para mantener la placa activa.

Conceptos Clave para Estudiantes

1. Protocolo I2C: I2C utiliza dos cables (SDA y SCL) y una dirección de 7 bits para comunicarse con múltiples dispositivos. La dirección de EEPROM 0x50 es común en muchos chips de la serie AT24C.
2. Ciclo de Escritura de la EEPROM: Las EEPROM requieren unos milisegundos para escribir datos internamente. El delay(5) en writeEEPROM() asegura que la escritura se complete antes de la siguiente operación.
3. Escritura Ficticia para Lectura: Para leer desde un registro específico, primero se envía la dirección del registro (una operación de escritura), luego se emite un reinicio o una parada/inicio para leer los datos. El código utiliza un enfoque de parada/inicio.
4. Verificación de Errores: El sketch verifica cada lectura contra el valor esperado, lo cual es una buena práctica para probar la comunicación.

Errores Comunes y Consejos de Depuración

• Dirección Incorrecta: Asegúrate de que la dirección de la EEPROM coincida con tu dispositivo. La EEPROM virtual usa 0x50. Si obtienes 0xFF como respuesta, la dirección podría ser incorrecta.
• Resistencias de Pull-up Faltantes: En hardware real, las líneas I2C necesitan resistencias de pull-up. En Velxio, se simulan internamente, por lo que no es necesario añadirlas.
• Monitor Serie: Usa el Monitor Serie en Velxio para ver la salida. Haz clic en el icono del Monitor Serie en la barra de herramientas.
• Temporización: Si las lecturas fallan de forma intermitente, aumenta el retardo después de las escrituras. La EEPROM virtual es rápida, pero los dispositivos reales pueden necesitar más tiempo.

Usa la barra de herramientas para compilar y ejecutar tu código. El Monitor Serie mostrará los resultados de la prueba.

Extensiones Sugeridas

1. Escribir Datos Más Grandes: Modifica el código para escribir y leer una cadena o un array de bytes.
2. Escritura por Páginas: Muchas EEPROM admiten escritura por páginas (escribir múltiples bytes en una sola transacción). Intenta implementarlo.
3. EEPROM Externa: Añade un componente EEPROM físico (si está disponible en Velxio) y conéctalo al Arduino.
4. Registro de Datos: Usa la EEPROM para almacenar lecturas de sensores y recuperarlas más tarde.

Conclusión

¡Has construido con éxito una prueba de lectura/escritura de EEPROM I2C en Velxio! Este proyecto demuestra los fundamentos de la comunicación I2C y la memoria no volátil. El entorno virtual facilita la experimentación sin hardware. Ahora, intenta ampliar el código o integrarlo en un proyecto más grande.

¿Listo para construir el tuyo propio? Abre el ejemplo en vivo en Velxio y empieza a programar: Ejemplo de Lectura/Escritura de EEPROM I2C. ¡Feliz simulación!