AT24C256 Memoria EEPROM 24C256 interfaz I2C

INFORMACIÓN

ESPECIFICACIONES Y CARACTERÍSTICAS

• Tipo: Módulo Memoria EEPROM.
• Chip: AT24C256.
• Interfaz: I2C.
• Pines: 8.
• Capacidad: 256 Kbit.
• Voltaje de alimentación: 2.7 V a 5.5 VDC.
• Tiempo de escritura: 5 ms.
• Ciclos de escritura: 1,000,000.
• Dirección I2C: 0x50 (0|1|0|1|A2|A1|A0|0).
• Led indicador power.
• Dimensiones: 36 mm x 12 mm x 15 mm.
• Peso: 5 g.

DOCUMENTACIÓN Y RECURSOS

• Datasheet
  
• Pinout
• Dimensiones
• Esquemático
  
• Librería

INFORMACIÓN ADICIONAL

¿Cómo probar la AT24C256 Memoria EEPROM 24C256 interfaz I2C?

Aquí tienes un paso a paso sencillo para probar un AT24C256 (EEPROM I²C) usando un Arduino (Uno/Nano). Incluye conexión, comprobación I²C, escribir/leer un byte y escribir/leer una cadena.

Materiales Necesarios:

• AT24C256 Memoria EEPROM 24C256 interfaz I2C.
• Arduino Uno / Nano (o similar).
• Cables dupont y protoboard.

Conexiones.

• VCC → 5V (o 3.3V).
• GND → GND.
• SDA → A4 (Arduino Uno/Nano).
• SCL → A5 (Arduino Uno/Nano).
• A0, A1, A2 → GND (si las dejas a GND, la dirección I²C base será 0x50).
• WP (Write Protect) → GND para permitir escritura (si WP = VCC las escrituras estarán bloqueadas).

Nota: en ESP32/ESP8266/Raspberry Pi los pines SDA/SCL son distintos (ESP32 suele usar 21/22; RPi: SDA GPIO2, SCL GPIO3).

Verificar Respuesta del Bus I2C.

#include <Wire.h>
void setup() {
  Wire.begin();
  Serial.begin(115200);
  while(!Serial);
  Serial.println("I2C Scanner");
  for (byte address = 1; address < 127; ++address) {
    Wire.beginTransmission(address);
    byte error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("Dispositivo I2C en 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
    }
  }
}
void loop() {}

Resultado esperado si A0..A2 = GND: aparecerá 0x50 (puede aparecer 0x50..0x57 según A0..A2).

Escribir y leer 1 byte.

• El AT24C256 usa dirección de memoria de 16 bits (dos bytes: high, low).
• Después de escribir, hay que esperar el ciclo de escritura (~5–10 ms) antes de leer.

Funciones y ejemplo completo (sketch) que hace: escanea, escribe un byte, lo lee, escribe una cadena por páginas y la lee:

#include <Wire.h>
const uint8_t EEPROM_ADDR = 0x50; // A0..A2 = GND

void setup() {
  Wire.begin();
  Serial.begin(115200);
  delay(200);
  Serial.println("AT24C256 - prueba");

  // Scan I2C (opcional)
  Serial.println("Escaneando I2C...");
  for (byte addr=1; addr<127; addr++) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0) {
      Serial.print("Encontrado: 0x");
      if (addr < 16) Serial.print("0");
      Serial.println(addr, HEX);
    }
  }

  // Escribir un byte
  uint16_t testAddr = 10;
  writeByte(testAddr, 'Z');
  Serial.println("Escrito 'Z' en addr 10");

  // Leer el byte
  byte c = readByte(testAddr);
  Serial.print("Leído de addr 10: ");
  Serial.println((char)c);

  // Escribir una cadena (manejo de páginas)
  const char *msg = "Hola AT24C256! Prueba de escritura por páginas.";
  writeString(0, msg);
  Serial.println("Cadena escrita en addr 0");

  // Leer la cadena (tamaño de msg)
  char buf[80];
  readData(0, buf, strlen(msg));
  Serial.print("Cadena leída: ");
  Serial.println(buf);
}

void loop() {}

// --- utilidades ---
void writeByte(uint16_t memAddr, byte data) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write((uint8_t)(memAddr >> 8));
  Wire.write((uint8_t)(memAddr & 0xFF));
  Wire.write(data);
  Wire.endTransmission();
  delay(10); // esperar ciclo de escritura
}

byte readByte(uint16_t memAddr) {
  Wire.beginTransmission(EEPROM_ADDR);
  Wire.write((uint8_t)(memAddr >> 8));
  Wire.write((uint8_t)(memAddr & 0xFF));
  Wire.endTransmission();
  Wire.requestFrom((int)EEPROM_ADDR, 1);
  if (Wire.available()) return Wire.read();
  return 0;
}

void writeString(uint16_t addr, const char* str) {
  const uint8_t PAGE_SIZE = 64; // tamaño de página del AT24C256
  uint16_t i = 0;
  while (str[i]) {
    uint8_t pageOffset = addr % PAGE_SIZE;
    uint8_t canWrite = PAGE_SIZE - pageOffset;
    uint8_t count = 0;
    Wire.beginTransmission(EEPROM_ADDR);
    Wire.write((uint8_t)(addr >> 8));
    Wire.write((uint8_t)(addr & 0xFF));
    while (str[i] && count < canWrite) {
      Wire.write(str[i++]);
      count++;
    }
    Wire.endTransmission();
    delay(10); // ciclo de escritura
    addr += count;
  }
}

void readData(uint16_t addr, char* out, size_t len) {
  size_t idx = 0;
  const size_t CHUNK = 32; // límite típico del buffer Wire en AVR (Arduino UNO)
  while (idx < len) {
    size_t toRead = min(CHUNK, len - idx);
    Wire.beginTransmission(EEPROM_ADDR);
    Wire.write((uint8_t)((addr+idx) >> 8));
    Wire.write((uint8_t)((addr+idx) & 0xFF));
    Wire.endTransmission();
    Wire.requestFrom((int)EEPROM_ADDR, (int)toRead);
    size_t got = 0;
    while (Wire.available() && got < toRead) {
      out[idx++] = Wire.read();
      got++;
    }
  }
  out[len] = '\0';
}

Puntos Importantes.

• WP en HIGH → no podrás escribir; conéctalo a GND para permitir escritura.
• A0–A2 cambian la dirección I²C (0x50..0x57).
• Pull-ups: si no usas módulo, añade 4.7k en SDA/SCL a VCC.
• Ciclo de escritura: esperar ~5–10 ms tras cada endTransmission() que escribe datos.
• Page write: máximo 64 bytes por página; no cruces el límite de página en una sola operación de escritura.
• Limite Wire: en Arduino UNO/Nano la librería Wire tiene buffer ≈32 bytes; usa lecturas/escrituras en bloques ≤32 bytes o usa otra MCU con más buffer.
• Si el escáner no encuentra el dispositivo: revisa VCC/GND, pull-ups, SDA/SCL invertidos, A0..A2, y WP.

ENLACES EXTERNOS

• Más memoria para Arduino con la EEPROM AT24C256 – Luis Llamas
• AT24C256 – External EEPROM with Arduino – RG Innovations
• 36.- LECTURA Y ESCRITURA EN MEMORIA EEPROM EXTERNA – Electrónica y Circuitos