Lectura/Escritura de EEPROM I2C con Pico: Simula Memoria No Volátil en tu Navegador

Introducción

¿Alguna vez has querido almacenar datos que sobrevivan a un corte de corriente? En los sistemas embebidos, la EEPROM (Memoria de Solo Lectura Programable y Borrable Eléctricamente) es la opción ideal para el almacenamiento no volátil. Hoy simularemos una operación de lectura/escritura de una EEPROM I2C usando la Raspberry Pi Pico, todo dentro de tu navegador con Velxio. ¡No se necesita hardware!

Escribiremos unos pocos bytes en la EEPROM, los leeremos de vuelta y verificaremos que coincidan. En el proceso, aprenderás sobre el protocolo I2C, la librería Wire y cómo depurar la salida serie. ¡Vamos allá!

Recorrido del Circuito

Abre el ejemplo en Velxio y verás el circuito en el lienzo. Los componentes principales son:

• Raspberry Pi Pico (el microcontrolador)
• LED rojo (etiquetado led-write) – se enciende durante una operación de escritura
• LED verde (etiquetado led-read) – se enciende durante una operación de lectura

Detalles del Cableado

Nota: En esta simulación, la EEPROM I2C es virtual, está integrada en el entorno de Velxio. Los LEDs se usan como indicadores visuales: el LED rojo parpadea durante una escritura, el LED verde durante una lectura. En un circuito real, conectarías las líneas SDA y SCL de la EEPROM a los pines I2C de la Pico (GPIO4 y GPIO5 por defecto, pero aquí usamos D12 y D10 para los LEDs).

Análisis del Código

Analicemos el sketch de Arduino. El código usa la librería Wire para comunicarse a través de I2C.

Includes y Definiciones

#include <Wire.h>

#define EEPROM_ADDR 0x50

Incluimos la librería Wire y definimos la dirección I2C de la EEPROM como 0x50. Esta es una dirección común para las EEPROM de la serie 24LC.

Funciones Auxiliares

void eepromWrite(byte memAddr, byte data) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.write(data);
  Wire.endTransmission();
  delay(5); // Ciclo de escritura de la EEPROM
}

byte eepromRead(byte memAddr) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write(memAddr);
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ADDR, 1);
  return Wire.available() ? Wire.read() : 0xFF;
}

• eepromWrite: Envía la dirección de memoria seguida del byte de datos. El delay(5) simula el ciclo de escritura interno de la EEPROM (típicamente 5 ms).
• eepromRead: Primero envía la dirección de memoria (una “escritura ficticia”), luego solicita un byte de la EEPROM. Devuelve el byte o 0xFF si no hay nada disponible.

Setup

void setup() {
  Serial.begin(115200);
  delay(500);
  Wire.begin();
  Serial.println("=== Prueba de EEPROM I2C con Pico ===");
  Serial.println();

  // Escribir 8 bytes
  Serial.println("Escribiendo 8 bytes...");
  byte testData[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE};
  for (int i = 0; i < 8; i++) {
    eepromWrite(i, testData[i]);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (testData[i] < 16) Serial.print('0');
    Serial.println(testData[i], HEX);
  }
  Serial.println();

  // Leer de vuelta
  Serial.println("Leyendo de vuelta...");
  int pass = 0;
  for (int i = 0; i < 8; i++) {
    byte val = eepromRead(i);
    Serial.print("  ["); Serial.print(i);
    Serial.print("] = 0x");
    if (val < 16) Serial.print('0');
    Serial.print(val, HEX);
    if (val == testData[i]) {
      Serial.println(" OK");
      pass++;
    } else {
      Serial.print(" FALLO (se esperaba 0x");
      Serial.print(testData[i], HEX);
      Serial.println(")");
    }
  }

  Serial.println();
  Serial.print("Resultado: ");
  Serial.print(pass);
  Serial.println("/8 superados");
}

• Inicializa el puerto serie a 115200 baudios y el bus I2C con Wire.begin().
• Escribe 8 bytes (0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE) en las direcciones 0–7.
• Lee de vuelta cada dirección y la compara con los datos originales. Imprime “OK” o “FALLO”.
• Finalmente imprime el número de pruebas superadas.

Loop

void loop() {
  delay(10000);
}

No hay nada que hacer repetidamente: la prueba se ejecuta una vez en setup(). El bucle solo añade un retardo para mantener visible la salida serie.

Conceptos Clave

• Protocolo I2C: Un bus serie de dos hilos (SDA, SCL) para la comunicación entre microcontroladores y periféricos. Cada dispositivo tiene una dirección única.
• Librería Wire: La librería integrada de Arduino para I2C. beginTransmission(), write(), endTransmission(), requestFrom() y read() son las funciones principales.
• Direccionamiento de EEPROM: Las EEPROM están organizadas en bancos de memoria. Escribimos un byte de dirección de memoria antes de los datos.
• Retardo del Ciclo de Escritura: Las EEPROM necesitan unos milisegundos para almacenar datos. El delay(5) asegura que la escritura se complete antes de la siguiente operación.

Errores Comunes y Consejos de Depuración

1. Dirección I2C Incorrecta: Verifica la dirección de la EEPROM. Las direcciones comunes son 0x50 a 0x57 (dependiendo de los pines A0/A1/A2).
2. Resistencias de Pull‑up Faltantes: En hardware real, SDA y SCL necesitan resistencias de pull‑up (4.7kΩ). La EEPROM virtual de Velxio maneja esto internamente.
3. Velocidad de Transmisión del Monitor Serie: Asegúrate de que el monitor serie esté configurado a 115200 baudios. Una discrepancia produce caracteres sin sentido.
4. Temporización del Ciclo de Escritura: Si omites el delay(5), la EEPROM podría no almacenar los datos correctamente. Aumenta el retardo si es necesario.
5. Los LEDs No Parpadean: Revisa el cableado. El LED rojo está conectado a D12, el verde a D10. Ambos cátodos van a GND.

Extensiones Sugeridas

• Almacenar y recuperar datos de sensores: Lee un sensor de temperatura y guarda el último valor en la EEPROM.
• Añadir un botón: Usa un pulsador para activar una lectura o escritura.
• Expandir a 256 bytes: Modifica el código para escribir un bloque de datos más grande.
• Usar la EEPROM para configuración: Almacena valores de calibración o ajustes de usuario.

¡Pruébalo Tú Mismo!

¿Listo para experimentar? Abre el ejemplo en vivo en Velxio:

Lanzar Lectura/Escritura de EEPROM I2C con Pico

Haz clic en el botón Ejecutar de la barra de herramientas del editor para compilar y simular. Observa la salida serie en la consola: deberías ver los 8 bytes leídos correctamente.

Usa la barra de herramientas del lienzo para hacer zoom, desplazarte e inspeccionar el circuito.

¿Necesitas añadir más componentes? Abre el selector de componentes para explorar las piezas.

¡Feliz simulación!