Memoria EEPROM At24c256 (ref: 0055)

Descripción

La memoria EEPROM AT24c560 (Modelo Atmel 178 24C256-PU-2.7) es una memoria de lectura/escritura (Electronically Erasable & Programmable Read-Only Memory) de 256K que se accede a través del bus i2c.

Este tipo de memorias se usan para guardar datos que queremos poder conservar aunque se retire la alimentación del circuito. Por ejemplo, datos de calibración, históricos, etc. La vida de la memoria es muy elevada, del orden de 100.000 ciclos de lectura/escritura para cada Byte.

La capacidad de 256K hace referencia a 256Kbit que, organizados con una profundidad de 8 bits, resultan en 32kBytes.

Como casi todos los dispositivos para i2c, la dirección del chip es parcialmente configurable, lo que se traduce en que es posible colocar hasta 4 dispositivos en paralelo en el mismo bus, usando los jumpers A0-A1 (A2 no se usa). Así, es posible alcanzar hasta 128KBytes (1Mbit).

Además, se alimenta a 5V, por lo que la interconexión con Arduino es directa y sencilla.

Dimensiones: 37 x 17 mm

Conexionado:

• Vcc de la memoria: a 5V de Arduino
• GND de la memoria: a GND de Arduino
• SCL de la memoria: a SCL de Arduino (A5 en UNO y Nano)
• SDA de la memoria: a SDA de Arduino (A4 en UNO y Nano)
• Jumper WP: Permite proteger frente a escritura la memoria.
• Jumpers A0-A1: Modifican la dirección del dispositivo en el bus i2c.

Código de ejemplo:

#include <Wire.h>
const int eepromAddress = 0x50;

void i2c_eeprom_write_byte(int deviceaddress, unsigned int eeaddress, byte data) {
   int rdata = data;
   Wire.beginTransmission(deviceaddress);
   Wire.write((int)(eeaddress >> 8));   // MSB
   Wire.write((int)(eeaddress & 0xFF)); // LSB
   Wire.write(rdata);
   Wire.endTransmission();
}

// WARNING: address is a page address, 6-bit end will wrap around
// also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
void i2c_eeprom_write_page(int deviceaddress, unsigned int eeaddresspage, byte* data, byte length) {
   Wire.beginTransmission(deviceaddress);
   Wire.write((int)(eeaddresspage >> 8)); // MSB
   Wire.write((int)(eeaddresspage & 0xFF)); // LSB
   byte c;
   for (c = 0; c < length; c++){       Wire.write(data[c]);   }
   Wire.endTransmission();
}

byte i2c_eeprom_read_byte(int deviceaddress, unsigned int eeaddress) {
   byte rdata = 0xFF;
   Wire.beginTransmission(deviceaddress);
   Wire.write((int)(eeaddress >> 8)); // MSB
   Wire.write((int)(eeaddress & 0xFF)); // LSB
   Wire.endTransmission();
   Wire.requestFrom(deviceaddress, 1);
   if (Wire.available()) rdata = Wire.read();
   return rdata;
}

// maybe let's not read more than 30 or 32 bytes at a time!
void i2c_eeprom_read_buffer(int deviceaddress, unsigned int eeaddress, byte *buffer, int length) {
   Wire.beginTransmission(deviceaddress);
   Wire.write((int)(eeaddress >> 8)); // MSB
   Wire.write((int)(eeaddress & 0xFF)); // LSB
   Wire.endTransmission();
   Wire.requestFrom(deviceaddress, length);
   int c = 0;
   for (c = 0; c < length; c++)
      if (Wire.available()) buffer[c] = Wire.read();
}


void setup() {
   Wire.begin();
   Serial.begin(9600); // Inicializa monitor serie a 9600bps
   char datos[] = "datos de prueba"; //Datos a grabar, en forma de cadena de texto
   i2c_eeprom_write_page(eepromAddress, 0, (byte *)datos, sizeof(datos)); // Escribe datos en memoria
   delay(100);
   Serial.println(F("Datos grabados en memoria"));
}

void loop() {
   int addr = 0;
    Serial.println(F("Ahora se va a leer la memoria... ... ... ")); 
   byte value = i2c_eeprom_read_byte(eepromAddress, addr); // Lee el Byte de la posición 0 (addr) de la EEPROM (Lectura Byte a Byte)

    while (value != 0)   { // Bucle para leer mensaje íntegro
      Serial.print((char)value);
      addr++;
      value = i2c_eeprom_read_byte(0x50, addr);
   }
   Serial.println(" ");
   delay(10000);
}

Más información: Hoja de datos At24c256