Escritura y lectura en EEPROM mediante I2c

Buenas, no logro encontrar informacion que pueda entender para mi necesidad, necesito guardar el valor de un sensor en la eeprom AT24C32 que viene con el reloj en tiempo real DS3231, escribir y leer un byte si lo he logrado entender, pero, escribir una palabra, o un valor, no lo logro entender, gracias.

La memoria AT24C32 esta conectada al bus I2C al igual que el RTC DS3231 por ende, debes tratarla como dos dispositivos I2C conectados al mismo bus.
Usa el scanner I2C para identificar su dirección y con la librería para memorias EEPROM seriales resuelves tu problema
Busca en google. Arduino AT24C32 library

si lees detenidamente, he puesto, que leer y escribir un byte, si lo he logrado entender, por ende, he tenido que aislar la direccion de la eeprom, repito, informacion tengo, lo que no logro entender es escribir y leer un valor de un sensor o una frase de texto por ejemplo

Un buen punto de partida, por lo tanto, sería que pusieras el código que utilizas para escribir un byte, y así partimos de una base conocida.

el ejemplo es tomado de este enlace AT24C32 EEPROM and arduino | breadboardtronics

==

#include <Wire.h>
#define address 0x57

int val = 100;
byte data;
void setup()
{ 
Wire.begin();
Serial.begin(9600);
delay(1000); 

//WRITE!!!!*******************************
Wire.beginTransmission(address);
Wire.write(0x00);      //First Word Address
Wire.write(0x00);      //Second Word Address

Wire.write(0x41);      //Write an 'A'

delay(10);

Wire.endTransmission();
delay(10);

//READ!!!!*********************************
Wire.beginTransmission(address);
Wire.write(0x00);      //First Word Address
Wire.write(0x00);      //Second Word Address
Wire.endTransmission();
delay(10);

Wire.requestFrom(address, 1);
delay(10);
data = Wire.read();
Serial.write(data);      //Read the data and print to Serial port
Serial.println();
delay(10);
}

void loop()
{
}

como detalle externo al hilo, un buen lugar donde guardar informacion precisa de interes solo privado puede ser la eeprom ; salieron defectuosos 35 proyectores de 8,000 lumenes con tecnologia laser, fueron cayendo uno de tras de otro conforme acumulaban horas de uso, el fabricante, muy inteligente por su parte, desde hace años, desde el proyector mas simple de lampara a los mas complejos, para disuadir problemas de garantia, guarda informacion valiosa que determina si entra dentro de la garantia por problema interno o mal uso del aparato, y toda esa informacion, la guarda en una memoria ram no volatil, desde, las horas de uso, si se ha desconectado bien, siguiendo el protocolo, ciclos de limpieza, temperaturas, etc ...

Como te dije, Google: Arduino AT24CXXX
Sale esto en 2 segundos y si sigues el ejemplo lees la memoria en la dirección que gustes en 2 minutos.
Libreria AT24CXX

/*
 * I2C EEPROM Read
 *
 * Reads the value of each byte of the I2C EEPROM and prints it
 * to the computer.
 * This example code is in the public domain.
 */

#include <AT24Cxx.h>
#define i2c_address 0x57

// start reading from the first byte (address 0) of the EEPROM
int address = 0;
byte value;

// Initilaize using AT24CXX(i2c_address, size of eeprom in KB).  
AT24Cxx eep(i2c_address, 32);

void setup() {
  // initialize serial and wait for port to open:
  
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  
}

void loop() {
  // read a byte from the current address of the EEPROM
  value = eep.read(address);

  Serial.print(address);
  Serial.print("\t");
  Serial.print(value, DEC);
  Serial.println();

  address = address + 1;
  if (address == eep.length()) {
    address = 0;
  }

  /***
    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an
    EEPROM address is also doable by a bitwise and of the length - 1.
    ++address &= EEPROM.length() - 1;
  ***/

  delay(500);
}

surbyte, me reitero, el problema no es leer ni escribir un byte, eso, como te he expuesto dos veces, lo entiendo, es mas, he puesto el ejemplo, no llegas a entender el problema, lo que no logro resolver, es escribir un valor o una palabra

Oskar_Sanchez:
escribir y leer un byte si lo he logrado entender, pero, escribir una palabra, o un valor, no lo logro entender, gracias.

Hola Oskar yo tampoco entiendo lo que pretendes, aunque me lo imagino. Lo primero sería saber que intentas escribir y/o leer en la EEPROM.

Veamos, un bit (según cuando yo estudie en su día) es un estado lógico u 0 o 1, un byte es la reunión de 8 bits al cual en su día en procesadores de 32 bits se le llamaba byte y una palabra es la reunión de 8 bytes (traducido al español) y luego por temas de rapidez en la escritura del software se uso doble_palabra a la reunión de 2 bytes es decir 16 bytes. Vale partiendo de ello si tu lo que quieres es escribir 8 bytes en la EEPROM lo que tienes que hacer es escribir en 8 direcciones 8 datos ¿si?

Si lo que intentas escribir en la EEPROM un byte, cada byte tiene una dirección, si lo que pretendes es escribir 8 bytes entonces tienes que escribir 8 datos(bytes) con sus correspondientes direcciones. es esto lo que buscas?

Aquí te dejo un ejemplo de mi proyecto donde escribo unos datos para "recordar" que frecuencia y el volumen ultimo usado de mi radio este es;

if (EEPROM.read(0) == 'R' && EEPROM.read(1) == 'A' && EEPROM.read(2) == 'D' && EEPROM.read(3) == 'I' && EEPROM.read(4) == 'O') {
		radio.tuneTo(getEepromFreq());
		radio.setVolume(getEepromVolume());
	} else {
		EEPROM.update(0, 'R');
		EEPROM.update(1, 'A');
		EEPROM.update(2, 'D');
		EEPROM.update(3, 'I');
		EEPROM.update(4, 'O');
		setEepromVolume(1);
	}

buenas, gracias por la dedicacion, la idea, es simplificar codigo y guardar en la eeprom externa por i2c el valor recogido del sensor de temperatura a una hora mediante una interrupcion con una alarma, despues poder guardar tambien el valor del dia y la hora del reloj en tiempo real para poder hacer una comparacion bajo determinadas circustancias

Oskar_Sanchez:
surbyte, me reitero, el problema no es leer ni escribir un byte, eso, como te he expuesto dos veces, lo entiendo, es mas, he puesto el ejemplo, no llegas a entender el problema, lo que no logro resolver, es escribir un valor o una palabra

Te puse el ejemplo de lectura, usa el ejemplo de escritura disponible en la misma librería.
Creo que yo tambien te lo he reiterado (y no compito contigo, te aclaro), para que reinventar la rueda que ya esta inventada?
Usa la librería, mira sus ejemplos. Te lleva solo los minutos instalarla y entenderla y no días como en este caso.

los ejemplos los he realizado con la propia eeprom de arduino, como exprese en la primera instancia, la sintaxis de escritura y lectura de un byte solo, la entendi desde el primer momento, muy certero estuvo lightcalamar con su expresion de codigo, como mi intencion, es ahorrar esfuerzo en todas sus maneras posibles, decidi, "reinvetar" un poco la division del valor ofrecido por un sensor de temperatura, y separar el entero de sus decimales, para asi, usar solo dos bytes, una vez separado, se procede a su escritura, y a su lectura para despues volver a concatenar el resultado, incrementando el valor entero, con su decimal.

 byte A;
 
 A = int(%variable sensor%);
 
 byte B;
 
 B = int (100 * (%variable sensor% - A));

 EEPROM.write(direccion0, A);
 EEPROM.write(direccion1, B);

 //direccion = direccion + 1;

 delay (500);

 tempEepromA = EEPROM.read(direccion0);
 tempEepromB = EEPROM.read(direccion1);

 byte C;

 C = EEPROM.read(direccion0);

 byte D; 
 
 D = EEPROM.read(direccion1);

 float E;
 
 E = (C + (D / 100.0));

Hola otra vez Oskar!

El problema que tu quieres he pasado por el mismo problema que tu.
Veras.

Estoy en un proyecto de una Radio de FM RDS (es cual me esta superando de lo bueno...) por diversos motivos he tropezado con lo que tu quieres. Es decir guardar los datos en la EEPROM sean de una forma u otra. Los ejemplos de la librería EEPROM, son validos solo a modo intuitivo NO PARA LO QUE TU QUIERES , o mejor dicho lo que yo desee y me funciona.

Mira te pongo un ejemplo, estuve averiguando de que forma cuando mi radio se apagaba guardara los datos en la EEPROM del volumen y de la ultima emisora antes de apagar, pues eso lo busque, y no lo pregunte porque sabia que me iban a dirigir a los ejemplos de la librería.

Vale entonces al final averigüe que había que realizar unas funciones. En el Setup le haces un EEPROM.read y despues un EEPROM.update, para que luego creas una función te haga un EEPROM.read de la ultima lectura de la EEPROM y listo.

Si no lo entiendes, por MP enviame tu email y te envío el código mio.

Para la EEPROM interna, disponemos de los métodos get y put, que permiten ubicar en la misma cualquier tipo primitivo de datos, siempre que no sean punteros (guardará el propio puntero y no el objeto al que apunta). Lo podemos ver en la referencia.

Antes de existir estos métodos, se solían utilizar unas plantillas (de hecho, muy probablemente la implementación de get y put sea esta misma plantilla o similar). Lo único que deberías modificar de la plantilla para que funcione con la eeprom externa es el comando de leer/escribir un byte (donde pone EEPROM.write o EEPROM.read, sustituye por el comando correspondiente a la eeprom externa). Luego el código de la plantilla lo pones al principio de tu sketch, después de los includes, y ya puedes escribir cualquier cosa en la eeprom. La propia función te devuelve el número de bytes que ha escrito, para que calcules dónde puedes escribir otro dato sin pisar al anterior.

Yo creo que deberías ser mas claro.
Comienzas diciendo

necesito guardar el valor de un sensor en la eeprom AT24C32 que viene con el reloj en tiempo real DS3231, escribir y leer un byte si lo he logrado entender, pero, escribir una palabra, o un valor, no lo logro entender, gracias.

Tu pones un código relacionado bien con esta memoria.
Te respondo con usar una librería.

Respondes que lo que quieres es usar la EEPROM interna del Arduino.
La verdad no entiendo este hilo

Finalmente cual es tu objetivo?

surbyte, creo, que no lees detenidamente las palabras una a una, mencionas, que mencione en el primer escrito, que necesitaba utilizar una eeprom en concreto en un reloj en tiempo real, mi contestacion de ayer, si nos fijamos bien, menciono, que los ejemplos los he realizado con la propia interna, los ejemplos!, no menciono que me arrepienta de querer usar una externa, el codigo expuesto, es tal y como lo necesito, por eso lo he desarrollado asi, la programacion en este bajo nivel, me cuesta comprenderla sin confundir sintaxis, gracias noter y a lightcalamar por las explicaciones, y gracias tambien a surbyte por el apoyo frente a esa libreria, el ejemplo, quiza, no sea el mas practico, pero, si el mas exacto cientificamente, para el retorno de decimales, sin perder ninguno por el camino, gracias a todos!

No te la sigo porque no tiene sentido.
Lo resolviste? me alegro.

Solo quiero matizar unos datos míos y me alegro que Oskar lo tengas solucionado.

Cuando se escribe en la EEPROM de Arduino y de otro sistema, porque los demás sistemas de procesadores usan lo MISMO, es decir Flash, RAM y EEPROM en el caso de Arduino no hace falta realizar sentencias EEPROM.write si no EEPROM .update porque si se leen la documentación y/o referencia de la librería lo tendrán muy claro.

El problema es muy pequeño, cuando se realiza un EEPROM.update, cuando es la primera vez , tienen que dejar caer el sistema( vamos quitar la alimentación a la placa Arduino), luego a la segunda guarda todos los datos sin usar el write. Saludos.

Bueno. El comando update creo se implementó también en las nuevas versiones del IDE, para evitar escribir un dato si no es necesario (porque el valor en eeprom es el mismo que el que queremos grabar). Primero lee lo que hay previamente, y si no coincide con el dato que enviamos lo sobreescribe. Recordemos que la eeprom tiene un número limitado de escrituras antes de volverse "amnésica".

@noter si te refieres que hay un numero limitado para usar (escribir)la EEPROM no estoy de acuerdo contigo, es ilimitado mientras funcione correctamente el chip. El problema de las EEPROM es que su acceso son los mas lentos comparados con la RAM, pero claro la RAM es volátil.

Recuerdo y no hace mucho tiempo de esto, algunos programas de unas maquinas(decodificadores) se escribía unas funciones en EEPROM como funciones de algoritmos, las famosas 24C64 y familia, donde el proceso era muy lento, pero de esto hace ya algunos años.