Memoria EEPROM

Buenas programando con objetos en arduino me encontre con un problema, guardando estos objetos en la EEPROM y intentando recuperarlos despues me surgen problemas, el guardado lo hace bien pero en el momento de obtener la informacion es cuando la cosa se lia, la cuestion es que una funcion acumula mas de 15 arrays en un constructor asi que en cuanto se inicia ese contructor que es una libreria, guarda el contenido de esas arrays por lo visto en cualquier parte de la memoria y eso afecta a los objetos guardados los cuales se ven modificados, entonces me pregunto, en situaciones como esta como solucionais el problema? Hay algun metodo para hacer particion de la EEPROM como los discos duros? o es mejor solucionar el tema de los arrays para que no modifiquen la memoria? Gracias de antemano.

Si subes el sketch e indicas cual es la libreria en cuestion sera mas facil que alguien te ayude.

Buenas a todos, al final solucione algunos aspectos del mensaje anterior. En primer lugar el problema basico era que EEPROM.put cuando tienes constructores que utilizan apuntadores ex ( myObject *nameObject) solo guarda la direccion del apuntador en memoria, asi que el problema que tenia es que cuando recuperava el objecto con EEPROM.get no recuperava el valor de este sino la direccion del apuntador, por lo tanto esa direccion no estava protegida desde un principio y se sobreescribian los valores una vez estava el sketch inicializado.
Ahora bien tengo una duda, se que las arrays siempre son apuntadores en C, pero sabeis como obtener el contenido de esta?, porque si guardas una array en EEPROM te guarda la posicion y no el contenido.

Hola.
Un array no es un puntero, aunque sí existe una equivalencia interna en el compilador entre puntero y array (un array se puede manejar mediante un puntero y viceversa).
Entiendo que EEPROM.put trabaja correctamente con estructuras que contengan arrays, pero no si contienen punteros. De hecho en el ejemplo que viene en la propia referencia de la función, vemos que almacena la siguiente estructura:

struct MyObject{
  float field1;
  byte field2;
  char name[10];
}

Sin embargo, no trabajaría correctamente si la definimos así:

struct MyObject{
  float field1;
  byte field2;
  char *name;
}

FreeStaR:
Buenas a todos, al final solucione algunos aspectos del mensaje anterior. En primer lugar el problema basico era que EEPROM.put cuando tienes constructores que utilizan apuntadores ex ( myObject *nameObject) solo guarda la direccion del apuntador en memoria, asi que el problema que tenia es que cuando recuperava el objecto con EEPROM.get no recuperava el valor de este sino la direccion del apuntador, por lo tanto esa direccion no estava protegida desde un principio y se sobreescribian los valores una vez estava el sketch inicializado.
Ahora bien tengo una duda, se que las arrays siempre son apuntadores en C, pero sabeis como obtener el contenido de esta?, porque si guardas una array en EEPROM te guarda la posicion y no el contenido.

Esto funciona:

#include <EEPROM.h>
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  char cadena[] = "ok";
  EEPROM.put(0,cadena);
  char recoger[2];
  EEPROM.get(0,recoger);
  Serial.print(recoger);
}

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

}

En lo que tienes que tener cuidado es en la direccion de la eeprom donde comienzas a grabar y los bytes que ocupa el array o la estructura de datos que guardas,para no sobreescribir los contenidos.

Buenas , gracias a los dos por responder, el problema de los ejemplos EEPROM de arduino es que no tienen en cuenta el echo de que este se apague, los ejemplos dan por echo que la recuperacion de datos de la EEPROM se efectuara siempre despues de guardarlos y nunca despues de un fallo o reinicio del arduino, por ejemplo podeis provar este simple codigo a ver si hos sale lo mismo que ami.

#include <EEPROM.h>

void setup() {
// put your setup code here, to run once:

Serial.begin(9600);

String arrayPrueva[10];

for(int i = 0; i< 10; i++)
{
arrayPrueva = “Hola”;
_ arrayPrueva += i;_
* }*
* //EEPROM.get(300,arrayPrueva);*
* for(int i = 0; i< 10; i++)*
* {*
_ Serial.println(arrayPrueva*);
}
EEPROM.put(300,arrayPrueva);*_

* Serial.println(“Finalizado”);*
}
void loop() {
* // put your main code here, to run repeatedly:*
}
En primer lugar hacemos un EEPROM.put, entonces apagamos el arduino comentamos la parte del for, y el EEPROM.put, y descomentamos el EEPROM.get, asi que quando hacemos el put entramos esta informacion:
Hola0
Hola1
Hola2
Hola3
Hola4
Hola5
Hola6
Hola7
Hola8
Hola9
Finalizado
Y por logica con el EEPROM.get tendriamos que obtener la misma informacion pero el resultado es muy distinto, en este caso hay caracteres especiales que no me dejan hacer un pegar.
El echo es que mientras no se apague arduino la obtencion de datos con EEPROM.get siempre sera satisfactoria pero una vez este se apaga es donde me genera los problemas.

noter te lo ha explicado ya, pero has pasado por alto su respuesta quizás por que te ha hablado en terminos un poco tecnicos

no puedes usar put con un array

pero puedes hacer algo asi:

const int LONGMAX = 20;

  for(int i = 0; i< 10; i++)
  {
   for (int j=0; j<LONGMAX; j++)
     {
      EEPROM.write(i*LONGMAX+j, arrayPrueva.charAt(i) )
     }

  }

No lo he probado e igual requiere alguna modificacion

Tienes que tener en cuenta que LONGMAX se tiene que poner pensando que string es de longitud variable, pero sino pones un maximo no sabes donde empieza una cadena y donde acaba otra

tambien podrias guardar en la eeprom un delimitador entre frases que no forme parte de tu cadena como ; o algo asi y optimizar la eeprom y el tiempo:

int k=0;
  for(int i = 0; i< 10; i++)
  {
   for (int j=0; j<arrayPrueva[i].length(); j++)
     { 
      EEPROM.write(k, arrayPrueva.charAt(i) );
     k++;
     }
   EEPROM.write(k, ';' );
   k++;

  }

te dejo que te curres los bucles de lectura!

Es curioso porque me he tirado un monton de rato con el tema y es cierto que se reciben simbolos raros por el serial cuando el put y el get estan en diferentes sketch usando un objeto String y no tengo ni idea del porque,pero los lee bien cuando el put y el get se hacen en un mismo sketch.De todas maneras en tu sketch te has dejado los indices del array:

 String arrayPrueva[10];

  for(int i = 0; i< 10; i++)
  {
    arrayPrueva = "Hola";
    arrayPrueva += i;
  }

Lo correcto seria:

 String arrayPrueva[10];

  for(int i = 0; i< 10; i++)
  {
    arrayPrueva[i] = "Hola" + String(i);
  }

Si los arrays que quieres guardar son de longitudes conocidas puedes usar arrays de char (o array de string ,con s minuscula).

Por ejemplo esto funciona para la insercion:

#include <EEPROM.h>
void setup() {
  Serial.begin(9600);
  char arrayPrueba[10][6];
  for(int i = 0; i < 10; i ++){
    String s = "Hola" + String(i);
    s.toCharArray(arrayPrueba[i],sizeof(arrayPrueba[i]));
  }  
  EEPROM.put(0,arrayPrueba);
}

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

}

y este para la lectura:

#include <EEPROM.h>
void setup() {
  Serial.begin(9600);
  char arrayPrueba[10][6];
  EEPROM.get(0,arrayPrueba);
  for(int i = 0;i < 10; i++){
    Serial.println(arrayPrueba[i]); 
  }  
}

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

}

Hola de nuevo.
En primer lugar, claro que se puede utilizar put con un array. Lo que no puede es utilizarse con punteros.
En tu ejemplo estás definiendo un array de strings, y un cada string contiene un puntero a una cadena. Prueba a modificarlo así:

#include <EEPROM.h>

void setup() {
  // put your setup code here, to run once:

  Serial.begin(9600);

  char arrayPrueva[10][15];

  for(int i = 0; i< 10; i++)
  {
   sprintf(arrayPrueva, "Hola %d", i);
  }

  EEPROM.put(300,arrayPrueva); 
  //EEPROM.get(300,arrayPrueva);

  for(int i = 0; i< 10; i++)
  {
   Serial.println(arrayPrueva);
  }

}

Y cuenta a ver si descomentando get y comentando put se comporta según lo esperado. Ahora estarías guardando directamente array de caracteres, no de punteros a caracteres.
Saludos.

Buenas a todos, en primer lugar gracias por las contestaciones, han sido de mucha utilidad, jose, con las prisas me olvide de poner el indice de la array xD, pero si, la forma correcta es tal y como lo has escrito.

Al final el problema es lo que comentava noter, String contiene un puntero a una cadena y por lo tanto el EEPROM.put guardava la posicion del puntero de dicho string, de echo si haceis una prueva con un string solo, sin array surge el mismo problema con el guardado.

Al final se soluciona con un array de chars, como tenemos funciones tanto para passar de arrayChar a string y viceversa no es necessario ningun bucle y tampoco se vuelve una gran tarea tratarlo de dicho modo.

Gracias a todos otra vez, espero que este post ayude a otra gente a solucionar este tipo de problemas ya que me trajo de cabeza durante unos cuantos dias.