EEprom para data logger

Buenas .Estoy trabajando en un proyecto donde necesito hacer un datalogger .
Estoy utilizando un arduino due el cual no dispone de memoria eepro ,por lo cual un colega me recomendó que use la memoria eeprom de RTC DS3231 basado en el siguente link.

http://www.hobbytronics.co.uk/arduino-external-eeprom

Esto funciona barbaro puedo leer y escribir datos en la memoria eepro con dato del tipo byte.
Pero mi problema surge cuando quiero insertar un dato del tipo string ,ya que lo que venia usando solo me permite ingresar datos del tipo byte .

mi string cuenta con varios tipos de datos en su interior (strin,chart ,etc)

    byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
    String s, m, dia, mth, h; 


  
        getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
 
  if (second < 10) { s = "0" + String(second); } else { s = String(second); }// segundos
  if (minute < 10) { m = "0" + String(minute); } else { m = String(minute); }//minutos
  h = String(hour);//hora
  if (dayOfMonth < 10) { dia = "0" + String(dayOfMonth); } else { dia = String(dayOfMonth); }// dia del mes
  if (month < 10) { mth = "0" + String(month); } else { mth = String(month); }//mes
  char* days[] = { "NA", "LUNES", "MARTES", "MIERCOLES", "JUEVES", "VIERNES", "SABADO", "DOMINGO" };

                                                                                        
 
  
 fecha=(String(days[dayOfWeek]) + " " + dia + "/" + mth + "/20" + year+"   "+h + ":" + m + ":" + s);//

 //ESTE ES EL DATO QUE NECESITO GUARDAR!!!!!!!!!!!!!!!!!!!!!!

yo necesito poder guardar el string fecha

la verdad que esto me tiene muy trabado.

Según el ejemplo que hay en esa página, lo podrías adaptar de la siguiente manera:

void writeEEPROM(int deviceaddress, unsigned int eeaddress, String data ) 
{
  byte* s = data.c_str();
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8));   // MSB
  Wire.send((int)(eeaddress & 0xFF)); // LSB
  Wire.send(s, sizeof(s));
  Wire.endTransmission();
 
  delay(5);
}

Y para leer

String readEEPROM(int deviceaddress, unsigned int eeaddress ) 
{
  char s[100]; // Agrándalo de ser necesario
 
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8));   // MSB
  Wire.send((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
 
  Wire.requestFrom(deviceaddress, sizeof(s));
 
  while (!Wire.available());
  char c = Wire.read(); // o Wire.receive, depende de la versión
  for (byte i = 0; c; i++) {
    s[i] = c;
    c = Wire.read();
  }
  Wire.flush(); 
  return String(s);
}

Pruébalos y cuéntame que tal, sí? :wink:

Lucario ante todo gracias,me esta tirando el siguiente error invalid conversion from 'const char*' to 'byte*

creo que es una conversión byte* s = data.c_str();

pero no se bien que significa

No es eso, el problema está en cómo se maneja la memoria EEPROM cuando se hace escritura “a bulto”.

Intenta esto:

void escribirString(String string) {
  writeEEPROM(direccionI2C, 0, string.c_str());
}

String leerString() {
  char s[100];
  readEEPROM(direccionI2C, 0, s, sizeof(s));
  return String(s); 
}

void writeEEPROM(int deviceaddress, unsigned int eeaddress, char* data) 
{
  // Uses Page Write for 24LC256
  // Allows for 64 byte page boundary
  // Splits string into max 16 byte writes
  unsigned char i=0, counter=0;
  unsigned int  address;
  unsigned int  page_space;
  unsigned int  page=0;
  unsigned int  num_writes;
  unsigned int  data_len= sizeof(data); // Calculate length of data
  unsigned char first_write_size;
  unsigned char last_write_size;  
  unsigned char write_size;  
   
  // Calculate space available in first page
  page_space = int(((eeaddress/64) + 1)*64)-eeaddress;

  // Calculate first write size
  if (page_space>16){
     first_write_size=page_space-((page_space/16)*16);
     if (first_write_size==0) first_write_size=16;
  }   
  else 
     first_write_size=page_space; 
    
  // calculate size of last write  
  if (data_len>first_write_size) 
     last_write_size = (data_len-first_write_size)%16;   
  
  // Calculate how many writes we need
  if (data_len>first_write_size)
     num_writes = ((data_len-first_write_size)/16)+2;
  else
     num_writes = 1;  
     
  i=0;   
  address=eeaddress;
  for(page=0;page<num_writes;page++) 
  {
     if(page==0) write_size=first_write_size;
     else if(page==(num_writes-1)) write_size=last_write_size;
     else write_size=16;
  
     Wire.beginTransmission(deviceaddress);
     Wire.write((int)((address) >> 8));   // MSB
     Wire.write((int)((address) & 0xFF)); // LSB
     counter=0;
     do{ 
        Wire.write((byte) data[i]);
        i++;
        counter++;
     } while((data[i]) && (counter<write_size));  
     Wire.endTransmission();
     address+=write_size;   // Increment address for next write
     
     delay(6);  // needs 5ms for page write
  }
}

void readEEPROM(int deviceaddress, unsigned int eeaddress,  
                 unsigned char* data, unsigned int num_chars) 
{
  unsigned char i=0;
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
 
  Wire.requestFrom(deviceaddress,num_chars);
 
  while(Wire.available()) data[i++] = Wire.read();

}

Buenas Lucario

No se bien a que te referís con "a bulto"

me sigue dando el siguiente error

invalid conversion from 'const char*' to 'char*'

y me señala la siguiente linea

writeEEPROM(disk1, 0, string.c_str());

La verdad no iterpreto muy bien tu info ,soy muy nuevo e este lenguaje

lo que interprete es que donde pones dirección i2c debo colocar la dirección del dispositivo I2c que tengo en mi caso es 057 o disk1

ddwasil:
No se bien a que te referís con "a bulto"

En conjunto a la misma vez. En este caso, un "array" entero (que representa una cadena de caracteres).

ddwasil:
me sigue dando el siguiente error

invalid conversion from 'const char*' to 'char*'

y me señala la siguiente linea

writeEEPROM(disk1, 0, string.c_str());

Cambia la siguiente línea:

void writeEEPROM(int deviceaddress, unsigned int eeaddress, char* data)

Debe quedar así:

void writeEEPROM(int deviceaddress, unsigned int eeaddress, const char* data)

A ver si esto acaso ayuda.

Traté de replicar el error, pero no lo consigo :confused:

Lucario,Gracias por tu tiempo
Me sigue dando un error

invalid conversion from 'char*' to 'unsigned char*' [-fpermissive]

te envió el programa donde figura el dato del rtc que quiero enviar y el programa que me enviastes vos a ver si encontras donde me estoy equivocando

#include "Wire.h"// comunicacion I2C       
#define DS1307_I2C_ADDRESS 0x68
#include <SD.h>              // Libreria de tarjeta SD
#include <SPI.h>             // Libreria bus SPI 
int press=0;
#define disk1 0x57 

byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;///en loop original
String seg, m, dia, mth, h;  ///VARIABLES IMPORTANTES

String fecha; 

 //##########################################################################################################################################################################
                                               // RTC
 //##########################################################################################################################################################################
                                                
 byte bcdToDec(byte val)
           {  return ( (val/16*10) + (val%16) );}
 
void getDateDs1307(byte *second,byte *minute,byte *hour,byte *dayOfWeek,byte *dayOfMonth,byte *month,byte *year)
           {      Wire.beginTransmission(DS1307_I2C_ADDRESS);///inicio I2C  Wire.write(0);  Wire.endTransmission();  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);//INICIO PEDIDO DE INFORMACION 
                  *second     = bcdToDec(Wire.read() & 0x7f);  *minute     = bcdToDec(Wire.read());  *hour       = bcdToDec(Wire.read() & 0x3f);  *dayOfWeek  = bcdToDec(Wire.read());
                  *dayOfMonth = bcdToDec(Wire.read());  *month      = bcdToDec(Wire.read());  *year       = bcdToDec(Wire.read());
            }

void hora()
           {  
              getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);//llamo a la fucion getDataDs1307
              if (second < 10) { seg = "0" + String(second); } else { seg = String(second); }// segundos
              if (minute < 10) { m = "0" + String(minute); } else { m = String(minute); }//minutos
              h = String(hour);//hora
              if (dayOfMonth < 10) { dia = "0" + String(dayOfMonth); } else { dia = String(dayOfMonth); }// dia del mes
              if (month < 10) { mth = "0" + String(month); } else { mth = String(month); }//mes
              
              fecha=( dia + "/" + mth + "/20" + year+"   "+h + ":" + m + ":" + seg);// ESTE ES EL DATO QUE QUIERO GUARDAR
              
              delay(1000); // Esperamos un segundo
           } 

//#####################################################################################################################################################
         void setup(void) 
                        {                      
                        Serial.begin(9600);
                        byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
                        Wire.begin();                                               
                        }
        void loop(){}
//##########################################################################################################################################################3
        // MEMORIA EEPROM
//##########################################################################################################################################################3

void escribirString(String string) {
  writeEEPROM(disk1, 0, string.c_str());
}

String leerString() {
  char s[100];
  readEEPROM(disk1, 0, s, sizeof(s));
  return String(s); 
}

void writeEEPROM(int deviceaddress, unsigned int eeaddress, const char* data) 
{
  // Uses Page Write for 24LC256
  // Allows for 64 byte page boundary
  // Splits string into max 16 byte writes
  unsigned char i=0, counter=0;
  unsigned int  address;
  unsigned int  page_space;
  unsigned int  page=0;
  unsigned int  num_writes;
  unsigned int  data_len= sizeof(data); // Calculate length of data
  unsigned char first_write_size;
  unsigned char last_write_size;  
  unsigned char write_size;  
   
  // Calculate space available in first page
  page_space = int(((eeaddress/64) + 1)*64)-eeaddress;

  // Calculate first write size
              if (page_space>16)
                        {
                           first_write_size=page_space-((page_space/16)*16);
                           if (first_write_size==0) first_write_size=16;
                        }   
              else 
                         first_write_size=page_space; 
    
                          // calculate size of last write  
              if (data_len>first_write_size) 
                         last_write_size = (data_len-first_write_size)%16;   
  
                              // Calculate how many writes we need
              if (data_len>first_write_size)
                      num_writes = ((data_len-first_write_size)/16)+2;
              else
                      num_writes = 1;  
     
                       i=0;   
                        address=eeaddress;
            for(page=0;page<num_writes;page++) 
                 {
                   if(page==0) write_size=first_write_size;
                      else if(page==(num_writes-1)) write_size=last_write_size;
                      else write_size=16;
                      
  
     Wire.beginTransmission(deviceaddress);
     Wire.write((int)((address) >> 8));   // MSB
     Wire.write((int)((address) & 0xFF)); // LSB
     counter=0;
         do{ 
                 Wire.write((byte) data[i]);
                  i++;
                  counter++;
           }
           while((data[i]) && (counter<write_size));  
     Wire.endTransmission();
     address+=write_size;   // Increment address for next write
     
     delay(6);  // needs 5ms for page write
  }
}

void readEEPROM(int deviceaddress, unsigned int eeaddress,  
                 unsigned char* data, unsigned int num_chars) 
{
  unsigned char i=0;
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
 
  Wire.requestFrom(deviceaddress,num_chars);
 
  while(Wire.available()) data[i++] = Wire.read();

}

Simplemente no lo comprendo.

Pruebo esto:

#include <Wire.h>

void setup() {
  Wire.begin();
  String s = ":V";
  s = String(13) + "/" + String(8);
  escribirString(s);

}

void loop() {
  // put your main code here, to run repeatedly:

}

void escribirString(String string) {
  writeEEPROM(0x57, 0, string.c_str());
}

void writeEEPROM(int deviceaddress, unsigned int eeaddress, const char* data) 
{
  // Uses Page Write for 24LC256
  // Allows for 64 byte page boundary
  // Splits string into max 16 byte writes
  unsigned char i=0, counter=0;
  unsigned int  address;
  unsigned int  page_space;
  unsigned int  page=0;
  unsigned int  num_writes;
  unsigned int  data_len= sizeof(data); // Calculate length of data
  unsigned char first_write_size;
  unsigned char last_write_size;  
  unsigned char write_size;  
   
  // Calculate space available in first page
  page_space = int(((eeaddress/64) + 1)*64)-eeaddress;

  // Calculate first write size
              if (page_space>16)
                        {
                           first_write_size=page_space-((page_space/16)*16);
                           if (first_write_size==0) first_write_size=16;
                        }   
              else 
                         first_write_size=page_space; 
    
                          // calculate size of last write  
              if (data_len>first_write_size) 
                         last_write_size = (data_len-first_write_size)%16;   
  
                              // Calculate how many writes we need
              if (data_len>first_write_size)
                      num_writes = ((data_len-first_write_size)/16)+2;
              else
                      num_writes = 1;  
     
                       i=0;   
                        address=eeaddress;
            for(page=0;page<num_writes;page++) 
                 {
                   if(page==0) write_size=first_write_size;
                      else if(page==(num_writes-1)) write_size=last_write_size;
                      else write_size=16;
                      
  
     Wire.beginTransmission(deviceaddress);
     Wire.write((int)((address) >> 8));   // MSB
     Wire.write((int)((address) & 0xFF)); // LSB
     counter=0;
         do{ 
                 Wire.write((byte) data[i]);
                  i++;
                  counter++;
           }
           while((data[i]) && (counter<write_size));  
     Wire.endTransmission();
     address+=write_size;   // Increment address for next write
     
     delay(6);  // needs 5ms for page write
  }
}

Y no hay error de compilación alguno (ni siquiera “warnings” ni nada). :confused:

En cuál línea dice que está el error?

Buenos días.
Lo borre y puse solo lo que te envie en sketch y me da error ,la version del sketch que tengo es la 1.6.11 ¿ Tendra algo que ver?

El mio es 1.6.7

ddwasil:
Lo borre y puse solo lo que te envie en sketch y me da error

Pero el asunto es... cúal y dónde?

Perdona que le dé tanto rodeo al asunto, pero a mi no me da errores; y no puedo intentar compilar tu programa porque no tengo todas la librerías.
Por ahora lo único que me resta decir, es que verifiques que no se usen las funciones send y receive; en su lugar, que sean write y read respectivamente

Hola lucario:
coloque la ultima versión de programa que me enviastes y por lo menos me permite compilar,ahora me podrías dar una pequeña explicación de como debo usarla
desde ya muchas gracias

#include <Wire.h>

void setup() {
  Wire.begin();
  String s = ":V";
  s = String(13) + "/" + String(8);
  escribirString(s);

}

void loop() {
  // put your main code here, to run repeatedly:

}

void escribirString(String string) {
  writeEEPROM(0x57, 0, string.c_str());
}

void writeEEPROM(int deviceaddress, unsigned int eeaddress, const char* data) 
{
  // Uses Page Write for 24LC256
  // Allows for 64 byte page boundary
  // Splits string into max 16 byte writes
  unsigned char i=0, counter=0;
  unsigned int  address;
  unsigned int  page_space;
  unsigned int  page=0;
  unsigned int  num_writes;
  unsigned int  data_len= sizeof(data); // Calculate length of data
  unsigned char first_write_size;
  unsigned char last_write_size;  
  unsigned char write_size;  
   
  // Calculate space available in first page
  page_space = int(((eeaddress/64) + 1)*64)-eeaddress;

  // Calculate first write size
              if (page_space>16)
                        {
                           first_write_size=page_space-((page_space/16)*16);
                           if (first_write_size==0) first_write_size=16;
                        }   
              else 
                         first_write_size=page_space; 
    
                          // calculate size of last write  
              if (data_len>first_write_size) 
                         last_write_size = (data_len-first_write_size)%16;   
  
                              // Calculate how many writes we need
              if (data_len>first_write_size)
                      num_writes = ((data_len-first_write_size)/16)+2;
              else
                      num_writes = 1;  
     
                       i=0;   
                        address=eeaddress;
            for(page=0;page<num_writes;page++) 
                 {
                   if(page==0) write_size=first_write_size;
                      else if(page==(num_writes-1)) write_size=last_write_size;
                      else write_size=16;
                      
  
     Wire.beginTransmission(deviceaddress);
     Wire.write((int)((address) >> 8));   // MSB
     Wire.write((int)((address) & 0xFF)); // LSB
     counter=0;
         do{ 
                 Wire.write((byte) data[i]);
                  i++;
                  counter++;
           }
           while((data[i]) && (counter<write_size));  
     Wire.endTransmission();
     address+=write_size;   // Increment address for next write
     
     delay(6);  // needs 5ms for page write
  }
}

.

Gracias

ddwasil:
ahora me podrías dar una pequeña explicación de como debo usarla

Cuando tengas el String listo para guardar, solo tienes que llamar a:

escribirString(fecha);

Para recuperarlo, has esto:

String algo = leerString();

Esto si en la EEPROM solo se escribirá ese String; en caso de requerir guardar algo más, ahí las cosas cambiarían un poco.

Y yo necesito hacer un historial de fallas,por lo cual necesitaria guardar ,por decir algo 100 strings fecha y despues poder leerlos y mostrarlos en un tft

Para múltiples cadenas de texto, lo adapté así:

#include <Wire.h>// comunicacion I2C       
#define DS1307_I2C_ADDRESS 0x68
#define disk1 0x57
#define STRING_LEN 20 // Ya lo calculé, la longitud del string de la fecha, nunca será mayor a 20

byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;///en loop original

char fecha[STRING_LEN + 1]; // Aquí se almacena la fecha ahora

//##########################################################################################################################################################################
// RTC
//##########################################################################################################################################################################

byte bcdToDec(byte val)
{
  return ( (val / 16 * 10) + (val % 16) );
}

void getDateDs1307(byte *second, byte *minute, byte *hour, byte *dayOfWeek, byte *dayOfMonth, byte *month, byte *year)
{ Wire.beginTransmission(DS1307_I2C_ADDRESS);///inicio I2C
  Wire.write(0);  Wire.endTransmission(); Wire.requestFrom(DS1307_I2C_ADDRESS, 7);//INICIO PEDIDO DE INFORMACION
  *second     = bcdToDec(Wire.read() & 0x7f);  *minute     = bcdToDec(Wire.read());  *hour       = bcdToDec(Wire.read() & 0x3f);  *dayOfWeek  = bcdToDec(Wire.read());
  *dayOfMonth = bcdToDec(Wire.read());  *month      = bcdToDec(Wire.read());  *year       = bcdToDec(Wire.read());
}

void hora()
{
  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);//llamo a la fucion getDataDs1307
  sprintf(fecha, "%d/%02d/20%02d\t\t%d:%02d:%02d", dayOfMonth, month, year, hour, minute, second);

  delay(1000); // Esperamos un segundo
}

//##########################################################################################################################################################3
// MEMORIA EEPROM
//##########################################################################################################################################################3

void escribirString(unsigned int idx) {
  if (idx > 1559)
    return;

  writeEEPROM(disk1, idx * (STRING_LEN + 1), fecha);
}

void leerString(unsigned int idx) {
  if (idx > 1559)
    return;

  readEEPROM(disk1, 0, idx * (STRING_LEN + 1), STRING_LEN + 1);
}

void writeEEPROM(int deviceaddress, unsigned int eeaddress, const char* data)
{
  // Uses Page Write for 24LC256
  // Allows for 64 byte page boundary
  // Splits string into max 16 byte writes
  unsigned char i = 0, counter = 0;
  unsigned int  address;
  unsigned int  page_space;
  unsigned int  page = 0;
  unsigned int  num_writes;
  unsigned int  data_len = sizeof(data); // Calculate length of data
  unsigned char first_write_size;
  unsigned char last_write_size;
  unsigned char write_size;

  // Calculate space available in first page
  page_space = int(((eeaddress / 64) + 1) * 64) - eeaddress;

  // Calculate first write size
  if (page_space > 16)
  {
    first_write_size = page_space - ((page_space / 16) * 16);
    if (first_write_size == 0) first_write_size = 16;
  }
  else
    first_write_size = page_space;

  // calculate size of last write
  if (data_len > first_write_size)
    last_write_size = (data_len - first_write_size) % 16;

  // Calculate how many writes we need
  if (data_len > first_write_size)
    num_writes = ((data_len - first_write_size) / 16) + 2;
  else
    num_writes = 1;

  i = 0;
  address = eeaddress;
  for (page = 0; page < num_writes; page++)
  {
    if (page == 0) write_size = first_write_size;
    else if (page == (num_writes - 1)) write_size = last_write_size;
    else write_size = 16;


    Wire.beginTransmission(deviceaddress);
    Wire.write((int)((address) >> 8));   // MSB
    Wire.write((int)((address) & 0xFF)); // LSB
    counter = 0;
    do {
      Wire.write((byte) data[i]);
      i++;
      counter++;
    }
    while ((data[i]) && (counter < write_size));
    Wire.endTransmission();
    address += write_size; // Increment address for next write

    delay(6);  // needs 5ms for page write
  }
}

void readEEPROM(int deviceaddress, unsigned int eeaddress,
                unsigned char* data, unsigned int num_chars)
{
  unsigned char i = 0;
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();

  Wire.requestFrom(deviceaddress, num_chars);

  while (Wire.available()) data[i++] = Wire.read();

}

No te asustes aquí:

sprintf(fecha, "%d/%02d/20%02d\t\t%d:%02d:%02d", dayOfMonth, month, year, hour, minute, second);

Esto hace exactamente lo mismo que hacías en bastantes líneas de código.

Ahora bien, cómo usar lo que acabo de proponer? Simple:

Ahora que la fecha es una variable global, para grabarla, solo hay que ejecutar el siguiente par de líneas:

hora();
escribirString(un índice entre 0 y 1559);

Para leer una fecha, se ejecuta:

leerString(un índice entre 0 y 1559);
Serial.println(fecha);

Convertir en objeto String, la fecha que actualmente está en memoria:

String algo = String(fecha);

Nótese que ahora la función que lee y escribe, recibe un número entero. Por qué? Porque ahí es donde puedes guardar/recuperar tus 100 cadenas de texto en la EEPROM, introduciendo valores entre 0 y 99.

Lucario :
Muchísimas gracias nuevamente por tu tiempo,cada vez que me meto mas en el tema me doy cuenta todo lo que no se.

En la cadena que armastes "fecha" me va a faltar poner una palabra que asocie la falla ,por ejemplo "temperatura alta".
Calculo que para esto le tendría que adosar a "fecha" una variable char llamada falla o algo por el estilo ¿estoy en lo correcto?

pero esto cambiaría tu calculo de la longitud del string que ,hasta ahora no superaría as de 20 .No se donde me estarías poniendo esta nueva longitud del string.

¿el valor 1559 de donde sale? ¿es la cantidad de de fechas que puedo guardar?¿depende de la capacidad de de la memoria eeprom o esta asociado al largo del string?

¿El numero de indice lo tengo para escribir la memoria lo tendría que llevar en otro vector en paralelo? osea si estoy en la posición 20 y se corta la tensión debo indicar de alguna manera de que estaba en 20 y que la próxima posición sera la 21 ,o lo hace automáticamente

Tenia vario valores que escribía en forma de byte,para que estos valores no se pisen con estos nuevos de fecha como los separo

nuevamente muchas gracias por tu ayuda ,disculpa tanta ignorancia

Lucario
De nuevo ,lo cargue en un proyecto nuevo y me da nuevamente este error

 invalid conversion from 'unsigned int' to 'unsigned char*' [-fpermissive]

y me señala la linea

readEEPROM(disk1, 0, idx*(STRING_LEN + 1), STRING_LEN + 1);

Ups, ahora sí fue mi culpa :o :sweat_smile:

Debería ir así:

readEEPROM(disk1, idx*(STRING_LEN + 1), fecha, STRING_LEN + 1);

Lucario:
Seguía dando error ,asi que le cambien

void readEEPROM(int deviceaddress, unsigned int eeaddress, unsigned char* data, unsigned int num_chars)

por

void readEEPROM(int deviceaddress, unsigned int eeaddress,char* data, unsigned int num_chars)

y a ahí pude compilar y cargar ,
lo cargo y encuentro algunos problemas la forma de la hora es 165/165/20165 46:165:85

me parece que esta linea tiene algo raro

sprintf(fecha, "%d/%02d/ 20%02d\t\t %d:%02d:%02d\t\t%08c", dayOfMonth, month, year, hour, minute, second,fallas);

le agregue el char de falla que te había consultado y este aparece bien.

por otro lado hice lo siguiente

void setup()
{
  Serial.begin(9600);
   int i=0;
  for(i=0;i<5;i++)
    {  
       hora();
       escribirString(i);
        delay (5000);
     }  
  }
void loop ()
{
  
  int j=2;
       leerString(j);
       Serial.println(fecha);
       delay (500);
  
  }

La idea es que me valla incrementando el valor de i,y usarlo a modo de indice cargando la hora en distintas posiciones de memoria .una vez que cargue 10 valores ,trato de leerlo con un nuevo indice j

pero siempre me da la misma lectura 165/165/20165 46:165:85

¿ se entiende?

ddwasil:
pero siempre me da la misma lectura 165/165/20165 46:165:85

Mi hipótesis: Wire.read está retornando -1 porque el RTC no está enviando los datos requeridos.
Para una variable de 8 bits sin signo (byte), -1 significa 255.

Realizando la operación matemática de bcdToDec, el resultado efectivamente acaba siendo 165.

Conclusión: por alguna razón, el RTC no esta respondiendo a la petición (requestFrom); de ahí la importancia de la función available.

PD: qué hace el formateador "%08c"?
Tengo entendido que 'c' significa convertir el argumento en un caracter, pero "%08"? Entonces... convertir a caracter con ocho ceros antecedentes?

Con esta forma lo puedo ver bien

fecha=(String(days[dayOfWeek]) + " " + dia + "/" + mth + "/20" + year+"   "+h + ":" + m + ":" + s);//

me parece que no le gusto la conversion

sprintf(fecha, "%d/%02d/ 20%02d\t\t %d:%02d:%02d\t\t%08c", dayOfMonth, month, year, hour, minute, second,fallas);

El sprinf me convierte todo en un char ¿estoy en lo correcto?

yo podría convertir mi "fecha" (de las lineas que si funciona)

fecha=(String(days[dayOfWeek]) + " " + dia + "/" + mth + "/20" + year+"  "+h + ":" + m + ":" + s);//[/code]

en chart .no se si esta bien efectuada la pregunta.

soy muy nuevo en este ambiente y me mareo bastante con cadenas ,string,etc.
El dato que tengo que leo bien es "fecha" ¿es un string objeto?.y este lo tendria que pasar a un char para guardarlo y mostrarlo