Grabar en varias posiciones EEPROM!

hola a todos, estoy de vuelta jaja…quería consultar como de grabar en varias posiciones de la EEPROM, yo tengo este código:

#include <EEPROM.h>                            
char loquesea[] = "hola foreros";  
const int Tamano_EEPROM = 13;                  
char buffer_EEPROM[Tamano_EEPROM];              
 
void setup() {
  Serial.begin(9600);                                    
  Serial.println("Grabando datos en la EEPROM...");      
  Escribir_EEPROM(loquesea);                      
}
 
 
void loop() {
  Leer_EEPROM(buffer_EEPROM);                           
  Serial.print("Estos son los datos de la EEPROM: ");    
  Serial.println(buffer_EEPROM);                      
  delay(10000);                                         
}
 
//Función para escribir en la EEPROM
void Escribir_EEPROM(char *UnString){
  for(int i = 0; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}
 
//Función para leer de la EEPROM
void Leer_EEPROM(char *bufferIn){
  for(int i = 0; i < Tamano_EEPROM; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}

void Borrar_EEPROM() {
  //Limpiamos la EEMPROM byte a byte
  for (int i = 0 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }
Serial.println("Memoria EEPROM borrada!");
}

el codigo funciona muy bien, pero como puedo hacer para grabar datos en las distintas posiciones sin tener q andar agregando funciones?? a ver si me explico, la forma q se me ocurrió es la siguiente:

const int Tamano_EEPROM1 = 13; //agrego tamaño de eeprom 1
char buffer_EEPROM1[Tamano_EEPROM1]; //agrego el buffer de eeprom 1 tambien..


//Función para escribir en la EEPROM
void Escribir_EEPROM1(char *UnString){
  for(int i = 1; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}

es agregar una funcion que escriba a partir de la posicion 1…y para leerla lo mismo:

//Función para leer de la EEPROM
void Leer_EEPROM1(char *bufferIn){
  for(int i = 1; i < Tamano_EEPROM1; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}

la consulta es, no hay otra manera mas rapida y limpia de poder hacer lo mismo?? porque pienso que si quiero garbar 10 posiciones me ocupo toda la flash en codigo y no se que mas ocuparia…

la idea es poder contar con una mini agenda dentro del codigo, o sea para agregar numeros leer y borrar numeros, pero bue eso tal vez es mucho mas avanzado…pero tal vez se pueda usar la mem eeprom pero de una forma mas practica y dinamica que haciendo copy paste de las funciones y cambiando 1 y 2 y 3 etcc…

aguardo comentarios gracias…

Any…

Hola, sigo intentando e intentando pero no le encuentro vuelta..es como que con ese codigo solo de esa manera, o sea agregando y repitiendo funciones para las distintas posiciones de la eeprom..

alguien que se le ocurra o sepa otra forma mas practica y q ocupe menos recursos???

En los ejemplos de EEPROM.put() verás que se usa un comando que va tomando el tamaño de lo que se esta salvando. Entonces la siguiente dirección disponible no pisa la anterior.

Si lo que usarás es siempre igual ya sabes donde guardar datos y saltaras de N en N posiciones pero si usas una estructura, entonces tendras que calcularla.

EEPROM.read() es volver al comino viejo, no lo uses porque es para leer byte a byte, barriendo posiciones.

EEPROM.get() lee desde la posicion que corresponda, teniendo en cuenta el tipo de variable o estructura.

Mira los ejemplos y modifica a partir de ese punto, no al revés.

Hola Surbyte, a ver si te sigo:

[///Función para escribir en la EEPROM
void Escribir_EEPROM(char *UnString){
  for(int i = 0; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}code]

con esa función yo escribo en la posición 0, para que la próxima grabación sea en la posición 1, 

[code][///Función para escribir en la EEPROM
void Escribir_EEPROM(char *UnString){
  for(int i = 1; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}code]

tengo q crear otra función que me agregue +1 a esa posición?
o sea:

algo que lea a ese int = lo que sea, y le agregue +1 para grabar...

hola yo hago esto por ejemplo:

//-------------- FUNCIONES PARA LA MEMORIA EEPROM ---------------------------//

void EEPROM_Admin(char *UnString){
  for(int i = 0; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}

void EEPROM_User1(char *UnString){
  for(int i = 1; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}
void EEPROM_User2(char *UnString){
  for(int i = 2; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}
void EEPROM_User3(char *UnString){
  for(int i = 3; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}
  //Función para leer de la EEPROM
void Leer_Admin(char *bufferIn){
  for(int i = 0; i < Admin_EEPROM; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}
  //Función para leer de la EEPROM
void Leer_User1(char *bufferIn){
  for(int i = 1; i < User1_EEPROM; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}
  //Función para leer de la EEPROM
void Leer_User2(char *bufferIn){
  for(int i = 2; i < User2_EEPROM; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}
  //Función para leer de la EEPROM
void Leer_User3(char *bufferIn){
  for(int i = 3; i < User3_EEPROM; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}

void Borrar_Admin() {
  //Limpiamos la EEMPROM byte a byte
  for (int i = 0 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }
 // Serial.println("Admin borrado!");
}

void Borrar_User1() {
  //Limpiamos la EEMPROM byte a byte
  for (int i = 1 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }
}
void Borrar_User2() {
  //Limpiamos la EEMPROM byte a byte
  for (int i = 2 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }
}
void Borrar_User3() {
  //Limpiamos la EEMPROM byte a byte
  for (int i = 3 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }
}

y esta medio resulto, digo medio porque por ejemplo agregar mas usuarios es agregar mas código, que el problema no seria tipear, sino saber cuando afecto a la operatividad de la placa, en eso ni idea, porque de tener solo admin a tener 3 users mas no agregue tamaño significativo, es casi nada, pero después no se si afecto alguna otra cosa como la ram o etc…

y por otro lado no parece muy limpio prolijo…no quiero decir profesional porque de hecho no lo es…debe haber un montón de formas de reducir esto a unas pocas lineas pero bue salgo del paso…

Pero sigues usando el manejo byte a byte con write y read cuando tienes instrucciones mas potentes como put y get.

La memorai tiene un tamaño fijo. Con cada avance de posición consumes memoria EEPROM, en algún momento no tendras mas y deberás decir, memorai EEPROM FULL y listo.

Tienes 1024 bytes en el ATmega328P

Hola Surbyte, ahi cambie por put y get, pero sale este error con get:

no matching function for call to ‘EEPROMClass::get(int&)’

void Escribir_EEPROM(char *UnString){
  for(int i = 0; i < strlen(UnString); i++){
     EEPROM.put(i, UnString[i]);
  }
}

  //Función para leer de la EEPROM
void Leer_EEPROM(char *bufferIn){
  for(int i = 0; i < Tamano_EEPROM; i++){
     bufferIn[i] = EEPROM.get(i);
  }
}

Yo no dije que cambies una cosa por otra. Una cosa es manejarse byte a byte con write y read y otra es con estructuras o tipos de variables con put y get. Ya te puse antes los links a ambas funciones EEPROM.put y EEPROM.get

lo que indicas esta mal.

ok, lo cambie porque me parecio bien probar el cambio…realmente no se si con ese cambio que hice en:

void Escribir_EEPROM(char *UnString){
  for(int i = 0; i < strlen(UnString); i++){
     EEPROM.put(i, UnString[i]);
  }
}

realmente cambio algo, o sigue manejando byte a byte…pero el put me dejo cambiarlo y el get no…

estoy tratando de adaptar todo a put y get…

mini consulta:

if ((numberSms != (buffer_Admin) && (buffer_User1) && (buffer_User2) && (buffer_User3)) && textSms.indexOf("A0B2XL14M097Z") != -1)

en esta linea no hace comparación, yo solo quisiera saber si estoy equivocada en la forma de estructurar las condiciones, no se si deba encerrar entre () o no...

Solucionado ya hace la comparacion...

hola, sigo sin poder hacer funcionar la comparacion:

else if (numberSms != (buffer_Admin) and numberSms != (buffer_User2) and numberSms != (buffer_User3) and (textSms.indexOf("Z790M41LX211U")+"#" + codigo) != -1)

y al final de la comparacion con el el serial agregue un simbolo y un password…
tampoco se si es la forma correcta de agregarlo…

Holaa…la comparacion ya funciona, era un proble de buffer no del formato de la compracion…

de cualquier manera dejo una inquietud, como puedo hacer q esto sea efectivo:

textSms.indexOf("Z790M41LX211U")+"#" + codigo)

o sea en el mensaje viene todo junto (Z790M41LX211U#12345) el tema que ni bien leyo solo Z790M41LX211U ya lo ejecuta, no lo lee completo, si parcialmente ya conicidio listo…

buenoo…salu2…

Any.

Hola, sigo dando vueltas con mi problema de la eeprom...como seria la forma correcta de grabar en ella?

el problema que encuentro tambien es cuando inicia el programa, se queda mucho tiempo leyendo las posiciones de eeprom...

Edito:

la idea es almacenar 3 usuarios, y poder recuperarlos para hacer comparaciones..pero al inicio del sketch si pongo algo del tipo:

EEPROM.read(0, Tamano_EEPROM);
if (EEPROM.read(0) != 0){
  Serial.println(buffer_EEPROM);

se pone super lento para arrancar..

Hola y disculpen, pero sigo sin poder solucionar la grabacion en EEPROM…
yo recupero un string que es el numero del que recibo un sms con esta codigo:

numberSms = Sim800l.getNumberSms(1);

(siempre tiene 13 caracteres: +541126569398)

lo que deseo es almacenar en la EEPROM ese numero obtenido (numberSms) que lo paso a adminTel (variable string que deseo almacenar y poder recuperar a gusto)

no se si hago bien, yo primero lo paso asi:

adminTel = numberSms;

y quiero ahora guardar adminTel en la EEPROM:

he intentado con:

EEPROM.put (0, adminTel)

y luego recuperarlo con:

EEPROM.get (0, adminTel)

pero no funciona, escribe basura/simbolos raros pero no el numero de telefono…

ojala me puedan ayudar/orientar que estoy haciendo mal, gracias…

hola de nuevo,

else if (numberSms != (admin) and textSms.indexOf("GRABATEEEE") != -1)
      {
        numberSms = admin;
        EEPROM.put (0, admin);
        Serial.println("Nuevo numero de admin:");
        Serial.println(admin);
        text= "Ud. es el nuevo Administrador, numero registrado: ");;
        error=Sim800l.sendSms(admin.c_str(),text);          
        error = Sim800l.delAllSms(); //Apaga SMS

esto estaria bien, digo estaria porque muestra por monitor que graba el admin, e incluso envia los mensajes pero si apago y prendo arduino y trato de usar este codigo:

void setup()
{
  Serial.begin(9600);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  digitalWrite(7, HIGH);
  digitalWrite(8, HIGH);
  EEPROM.get(0, admin);

  
  Sim800l.begin();

  
  if (admin != 0){
  Serial.print("Iniciando sistema...espere..");
  text="Iniciando sistema...espere..";
  error=Sim800l.sendSms(admin .c_str(),text);
  Serial.println("Listo! Sistema iniciado.");
  Serial.println("\nadmin:"); 
  Serial.println("\nAguardando comandos por SMS...");
  text="\nListo!. Sistema iniciado. Aguardando comandos por SMS...";
  error=Sim800l.sendSms(admin.c_str(),text);
  error = Sim800l.delAllSms(); //Apaga SMS  
  }
  else
  { 
  Serial.print("Iniciando sistema...espere..");
  Serial.println("Listo! Sistema iniciado."); 
  Serial.println("\nSin destinatario para Sms.");
  Serial.println("\nAguardando comandos por SMS...");
  error = Sim800l.delAllSms(); //Apaga SMS
  }
}

salta al else directamente…esa variable se perdio, y tampoco grabo el numero…
admin esta declarado como String…

#include <Sim800l.h>
#include <SoftwareSerial.h>
#include <EEPROM.h>

Sim800l Sim800l;

String textSms, numberSms, admin;

Primero ten cuidad con la cantidad de veces que guardas datos en el EEPROM. Hay 100mil ciclos de escritura posibles en una area de memoria. si grabas 100mil veces en 0, a la larga va a falla esa zona de la EEPROM, entonces tus pruebas que sean en el setup y te aseguras que ocurren una sola vez…
Funciona bien, no funciona no intentas de nuevo.

Ahora veamos tu fallo

Leiste la documentación de EEPROM.get y EEPROM.put que te puse? DIgo porque en ningún momento yo mencioné que podías usar Strings. Tu intentas guardar un String y el procedimiento no habla nada de Strings, habla de cadenas de caracteres y yo te hice la conversión a cadena de caracteres y recuerdo que podías almacenarlos.

char buffer[15];                  // es una cadena
String textSms, numberSms, admin;  // no son cadenas

Hola Surbyte gracias porresponderme…si creo haber leido, entre todo lo q ya lei, aunque parezca mentira jajaja, que los string dan problemas para grabar en eeprom, hacer basura o algo por el estilo, que debe ser todo lo que me pasa a mi jaja…vos hablas de cadenas, y yo uso esto:

const int Tamano_EEPROM = 14;
char buffer_EEPROM[Tamano_EEPROM];

no se si es correcto,…la verdad juro que estoy mareada mal…

otro problema es q cuando inicia o sea se graba por primera vez el sketch la posicion 0 no tiene numero de tel guardado tiene 0 y si hago esto:

void setup()
{
  Serial.begin(9600);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  digitalWrite(7, HIGH);
  digitalWrite(8, HIGH);
  
  Sim800l.begin();

  if (EEPROM.read(0) != 0){
  Serial.print("Iniciando sistema...espere..");
  text="Iniciando sistema...espere..";
  error=Sim800l.sendSms(buffer_EEPROM,text);
  Serial.println("Listo! Sistema iniciado.");
  Serial.println("\nAdmin:");
  Serial.println(buffer_EEPROM); 
  Serial.println("\nAguardando comandos por SMS...");
  text="\nListo!. Sistema iniciado. Aguardando comandos por SMS...";
  error=Sim800l.sendSms(buffer_EEPROM,text);
  error = Sim800l.delAllSms(); //Apaga SMS

tarda un monton en leer y arrancar…no se si es porque hay basura entonces no hay ni numero ni 0, hay simbolos raros entonces se cuelga al intentar mandar los sms…

Estas mareada porque no has estudiado lo básico. Ponete a estudiar que son cadenas que es una clase y entonces las cosas comenzarán a tener mas claridida.

Sin base no se entienden las cosas.

Y si eso que me mostrastre es una cadena pero te la pasas intentando guardar datos de String y por eso guardas y lees basura.

Proba con una cadena y luego me decis si funciona o no.

A ver es muy simple.

Si algo no funciona es porqu lo haces mal, simple. Vuelvo al ejemplo y lo exprimo. Pruebo una y otra vez hasta tener un ejemplo modificado que haga lo que quiero. Cuando eso pasa, lo llevo a mi código.

Mientras probar todo en el código no es lo adecuado para mi gusto.

yo use este codigo que adapte:

#include <EEPROM.h>                                 //Incluimos la librería EEPROM
char Admin;                                                          //Declaramos la cadena de texto a almacenar
const int Tamano_EEPROM = 14;                          //Especificamos su tamaño + 1
char buffer_EEPROM[Tamano_EEPROM];                 //Creamos una variable char del tamaño de la 
                                                                          //constante "Tamano_EEPROM"
 
void setup() {
  Serial.begin(9600);                                             //Iniciamos la comunicación serie
  Serial.println("Grabando datos en la EEPROM...");      //Avisamos por comunicación serie
  Escribir_EEPROM(Admin);                                    //Grabamos la cadena de texto en la EEPROM
}
 
 
void loop() {
  Leer_EEPROM(buffer_EEPROM);                            //Leemos la cadena de texto de la EEPROM
  Serial.print("Estos son los datos de la EEPROM: ");    //Avisamos por comunicación serie
  Serial.println(buffer_EEPROM);                         //Sacamos el string almacenado en la EEPROM por 
                                                                         //comunicación serie
  delay(10000);                                          //Pequeña pausa
}
 
 
//Función para escribir en la EEPROM
void Escribir_EEPROM(char *UnString){
  for(int i = 0; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}
 
//Función para leer de la EEPROM
void Leer_EEPROM(char *bufferIn){
  for(int i = 0; i < Tamano_EEPROM; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}

este es el original:

#include <EEPROM.h>                            //Incluimos la librería EEPROM
char MiCadenaDeTexto[] = "hola ardumaniacos";  //Declaramos la cadena de texto a almacenar
const int Tamano_EEPROM = 18;                  //Especificamos su tamaño + 1
char buffer_EEPROM[Tamano_EEPROM];             //Creamos una variable char del tamaño de la constante "Tamano_EEPROM"
 
void setup() {
  Serial.begin(9600);                                    //Iniciamos la comunicación serie
  Serial.println("Grabando datos en la EEPROM...");      //Avisamos por comunicación serie
  Escribir_EEPROM(MiCadenaDeTexto);                      //Grabamos la cadena de texto en la EEPROM
}
 
 
void loop() {
  Leer_EEPROM(buffer_EEPROM);                            //Leemos la cadena de texto de la EEPROM
  Serial.print("Estos son los datos de la EEPROM: ");    //Avisamos por comunicación serie
  Serial.println(buffer_EEPROM);                         //Sacamos el string almacenado en la EEPROM por comunicación serie
  delay(10000);                                          //Pequeña pausa
}
 
 
//Función para escribir en la EEPROM
void Escribir_EEPROM(char *UnString){
  for(int i = 0; i < strlen(UnString); i++){
     EEPROM.write(i, UnString[i]);
  }
}
 
//Función para leer de la EEPROM
void Leer_EEPROM(char *bufferIn){
  for(int i = 0; i < Tamano_EEPROM; i++){
     bufferIn[i] = EEPROM.read(i);
  }
}

lo que hice fue cambiar el char

char MiCadenaDeTexto[] = "hola ardumaniacos";

por mi char

char Admin;

el ejemplo original lo hace bien…el mio da errores, tal vez cuando paso de string a char

else if (numberSms != (buffer_EEPROM) and textSms.indexOf("lo que sea") != -1)
     {
       numberSms.toCharArray(Admin, numberSms.length());
       Escribir_EEPROM (Admin);

y para leer ese dato:

Leer_EEPROM(buffer_EEPROM);

no se que estaria haciendo mal…no logro darme cuenta

Yo otra vez Surbyte, obtengo el numero de tel de la siguiente linea:

numberSms = Sim800l.getNumberSms(1);

supuestamente es un string, si lo intento grabar con:

EEPROM.put (0, numberSms );

un string no es lo correcto me dijiste para guardar en la EEPROM, lo paso a char:

numberSms.toCharArray(cadminTel, numberSms.length());

y pongo:

EEPROM.put (0, cadminTel);

y no lo guarda...deberia poder recuperarlo asi:

EEPROM.get (0, cadminTel);
Serial.println(cadminTel);

y esta vacio...

Bueno veo que no lees lo que se sugiere. Mi sugerencia tenía que ver con que ensayes las cosas por separado.

Para mi sorpresa empecé por lo que supuse no funcionaría pero… FUNCIONA!!!

#include <EEPROM.h>
String phone1;
String phone2;

void setup() {
  Serial.begin(9600);
  Serial.println("define memorysize of EEPROM");
  phone1 = "+994502545376";
  EEPROM.put(0,phone1);
  phone2 = "+994707181890";
  int pos1 = sizeof(phone1);
  EEPROM.put(pos1,phone2);

  Serial.println("EEPROM Address #" + String(0) + ": " + EEPROM.get(0,phone1));
  Serial.println("EEPROM Address #" + String(pos1) + ": " + EEPROM.get(pos1,phone1));
}

void loop() {}

Ahora mira la salida por pantalla

EEPROM.png

Sin embargo luego de hacer esto me di cuenta que no es el mejor modo de guardar un número.
El mejor modo de manera mas eficiente seria usar un entero largo sin signo a pesar del +Codigo País.
Eliminaría el + y solo guardarías los numeros o digitos pero es otra forma de hacer lo mismo. No quiero complicarte.

Prueba con esto que te he pasado a ver si funciona.

Ahora la versión con char phone

#include <EEPROM.h>

char phone0[14] = "+994707181898";
char phone1[14] = "+994502545376"; 
char phone2[14] = "+994707181890";
char phone3[14] = "+994707181891";
char phone4[14] = "+994707181892";
char phone5[14] = "+994707181893";
char phone6[14] = "+994707181894";
char phone7[14] = "+994707181895";
char phone8[14] = "+994707181896";
char phone9[14] = "+994707181897";


void setup() {
  Serial.begin(9600);
  Serial.println("Prueba de Memmoria EEPROM");


  EEPROM.put(0,phone0);  
  EEPROM.put(14,phone1); 
  EEPROM.put(28,phone2);
  EEPROM.put(42,phone3);
  EEPROM.put(56,phone4);
  EEPROM.put(70,phone5);
  EEPROM.put(84,phone6);
  EEPROM.put(98,phone7);
  EEPROM.put(112,phone8);
  EEPROM.put(126,phone9);

for(byte i=0;i<=9;i++){
  int k = i*14;
  char p[14];
  Serial.println( EEPROM.get(k,p));
}  
}

void loop() {

}

EEPROM char.png

Hola Surbyte gracias por tu respuesta…lo que vos haces es grabar en la memoria números que tenes escritos en el sketch, yo no tengo ningún numero definido en el sketch, los tomo del mensaje de texto
con las variables que ya puse antes, como vos haces si se graban, yo lo que no puedo es grabar un numero que esta en la variable de mensaje:

numberSms = Sim800l.getNumberSms(1);

esa linea de código es la que tiene el numero completo…(creo q es un string)

y si intento hacer:

EEPROM.put (0, numberSms );

no lo graba correctamente, a veces si lo hace y a veces graba basura, símbolos raros…
y al queres recuperarla con EEPROM.get muestra vacio…
mi problema es como llevar de esa variable numberSms a la memoria eeprom de forma que se grabe correctamente…

Comento:
yo no quiero tener los números definidos en una variable dentro del skertch…quiero que en determinada situación se graben en la memoria, si cumplen con las condiciones de l if los grabe en la eeprom…

este es mi codigo:

#include <Sim800l.h>
#include <SoftwareSerial.h>
#include <EEPROM.h>

Sim800l Sim800l;

String textSms, numberSms;

bool error;
char* text;
char text1[64];
char cadminTel;



void setup()
{
  Serial.begin(9600);
  
  Sim800l.begin();
  

  cadminTel = EEPROM.read(0);
  if (cadminTel != 0){
  Serial.print("Iniciando sistema...espere..");
  text="Iniciando sistema...espere..";
  error = Sim800l.sendSms(cadminTel,text);
  Serial.println("Listo! Sistema iniciado.");
  Serial.println("\nAdmin:");
  Serial.println(cadminTel); 
  Serial.println("\nAguardando comandos por SMS...");
  text="\nListo!. Sistema iniciado. Aguardando comandos por SMS...";
  error = Sim800l.sendSms(cadminTel,text);
  error = Sim800l.delAllSms(); //Apaga SMS  
  }
  else{
  Serial.print("Iniciando sistema...espere..");
  Serial.println("Listo! Sistema iniciado."); 
  Serial.println("\nSin destinatario para Sms.");
  Serial.println("\nAguardando comandos por SMS...");
  error = Sim800l.delAllSms(); //Apaga SMS
  }
}


void loop()
{
  //Lee el SMS en la posicion 1
  textSms = Sim800l.readSms(1);
  //textSms.toCharArray(ctextSms, textSms.length());
  
  //Verifica que el SMS fue recebido y es valido
  if (textSms.indexOf("OK") != -1)
  {
    //Verifica que SMS esta vacio
    if (textSms.length() > 0)
    {
      //Devuelve el numero de celular que envio el SMS
      numberSms = Sim800l.getNumberSms(1);
      //Muestra el numero de telefono en el Serial Monitor
      Serial.println(numberSms);
      //Convierte el texto a Mayuscylas
      textSms.toUpperCase();


       if (numberSms != (cadminTel) and textSms.indexOf("#790M41LX211U") != -1)
      {
        //numberSms.toCharArray(cadminTel, numberSms.length()); probe asi
        //numberSms = atoi(numberSms.c_str()); probe asi tambien pero nada..
        EEPROM.put (0, numberSms);
        Serial.println("Escribiendo en la EEPROM...");
        delay(5000);
        Serial.println("Nuevo numero de admin:");
        Serial.println(numberSms);
        delay(5000);
        strcat( text1, "Ud. es el nuevo Administrador, numero registrado: ");
        strcat( text1, numberSms.c_str());
        error=Sim800l.sendSms(numberSms.c_str(),text1);          
        error = Sim800l.delAllSms(); //Apaga SMS
      }
         else if (numberSms == (cadminTel) and textSms.indexOf("#790M41LX211U") != -1)
      {
        text="\nUd. YA es el Administrador.";
        error=Sim800l.sendSms(numberSms.c_str(),text);          
        error = Sim800l.delAllSms(); //Apaga SMS
      }  
     
      else{
        //Serial.println(textSms);
        Serial.println("Su numero no esta autorizado.");
        text="\nNumero no autorizado.";
        error=Sim800l.sendSms(numberSms.c_str(),text);
        error = Sim800l.delAllSms(); //Apaga SMS
 }
       //Apaga todos as mensajes da memoria, garantizando que el proximo
       //SMS este siempre en la posicion 1
       Sim800l.delAllSms();
        } }   }

esto es lo que guarda:

Estos son los datos de la EEPROM 0: ⸮