valor de Arrays sacado de una variable

Hola amigos, tengo un problema con los arrays, y es el siguiente:

int cuanto = EEPROM.read(0);

// igual que .. 
int cuanto = 5;

aqui el problema... debe de leer de cuanto será el array, ese valor lo lee de la eep en la dirección 0 de la eep, esto lo definí en una parte del programa, donde me voy a configuracion, cambio de SSID y luego guardar cambios, y se guarda en la eep direccion 0 cuantos caracteres tiene el ssid,.. porque unas veces es 5, otras veces puede ser 17, depende del nombre que le ponga a mi ssid de internet.. se programa por serie tx rx. y la escribe a partir de la direccion 1 de la eep es donde se almacena el ssid

char ssid [cuanto]={}  ;
              // luego recojo mi ssid de la eeprom.. (verde)
EEPROM.get(1,ssid);
Serial.print(EEPROM.read(0)); Serial.print(" * "); Serial.println(ssid);

Monitor serial:
5 * verde

apartir de la 1 de la eeprom asta los caracteres de "cuanto" será mi ssid.

luego para la contrasña quiero hacer : cuanto+1 lo guarda en la eeprom y apartir de ahi es la contraseña. pero claro unas veces el ssid o la contraseña es mas largo, no quiero definir un valor fijo al array, porque no soy muy experto y me pierdo si lo hago con mucho tecnicismo.

el fallo que da es = exit status 1
array bound is not an integer constant before ']' token

La pregunta es . ¿ como se hace para meter el valor de una variable en la dimension de un array?

int cuanto = 5 ;

char ssid [cuanto]={};

debería quedar char ssid [5].. en resumen necesito esto, en guardar ese valor variable dentro de los corchetes del array.

Pues no le gusta esto al ide. Me da error.

Ayuda porfavor!!!

Empiezas mal y sigues peor.

EEPROM.read() solo lee un byte y tu en el primer comando le pides que lea dos o pretendes que lo haga

int cuanto = EEPROM.read(0);

Un entero son 2 bytes asi que en lugar de usar EEPROM.read(0) debes usar EEPROM.get(0, cuanto);

NOTA: como verás cada vez que YO posteo una línea de código uso las etiquetas correspondientes, de modo que lee las normas del foro y edita tus dos primeros post haciendo las correcciones correspondientes.

Para salvar los datos usas EEPROM.put(0, ssid);

Hola, gracias por contestar, creo que no me entendiste bien, o alomejor si y esque no lo entendí bien.
Os explico bien lo que quiero hacer, y me decís .. porque mas o menos lo tengo controlado, pero quiero hacer un array y el valor del array [?] sacarlo de una variable.

Si escribo

int cuanto_vale = EEPROM.read(0);

.. si en la dirección 0 de la eeprom hay un 7, cuanto_vale valdrá 7, asta ahí todo bien. otra vez que quiera cambiar el ssid ese 7 podrá ser un 6, un 8, un 15 o lo que sea,..

lo que quiero hacer es un array con el valor [cuanto_vale] ...
intento hacerlo de la siguiente forma:
ya que previamente leí caracteres por puerto de serie y con un contador conté cuantos entraron, esa variable del contador es por ejemplo 'y' y vale 8. y la guardé en la dirección 0 de la memoria eeprom.

void cambio_ssid() { ...
EEPROM.write(0, y);  // y= la lectura de cuantos caracteres entraron por puerto de serie, en direccion 00h.
                             // seguardó en la parte void cambio_ssid() 
....
EEPROM.put(1, ssid); // el ssid se escribe el la eeprom apartir de la dirección 1, 
      // y tendrá 8 carateres en este caso. por lo tanto hemos llenado asta la dirección 08h de la eeprom.  
     // 9 en total contando la direccion 00.   (ejemplo; escribió PepitoF1 como ssid) 
...}

void setup {
int cuanto_vale = EEPROM.read(0);  // cuanto vale = por ejemplo 8 ((pepitoF1) 8 caracteres en " y ")

char ssid [cuanto_vale]={}; //  char ssid [8]={PepitoF1}; 


// para leer el ssid..
EEPROM.get(1,ssid); // leería solo los 8 digitos, no la continuación que sería la clave y otras cosas.
                            // por ello quiero definir cuando cambio el ssid o la clave,
                            // cuantos digitos tiene,

ahora con otra sentencia escrita por el puerto de serie, mando la contraseña nueva, marcando un previo código para que reconozca que lo que va a entrar será la contraseña, entonces contamos los caracteres para generar el array, al mismo tiempo que se guardaran a partir del contador anterior " y " + 1 que es el '0' de la eeprom donde se guardó " y " mas los caracteres que entranon que son ' y caracteres '.
el conteo de los caracteres de la contraseña lo guardaré en la variable" z " .
el contador " z "empieza a contar cuantos caracteres entran por el puerto de serie. y lo guarda en la eeprom usando la suma de (y+1)+1 EEPROM.write(y+2, z); guardaría z en el décimo hueco disponible de la eeprom que sería la direccion 09h.
clavel sería la clave para el ejemplo. 6 digitos.

void cambio_clave) { ...
EEPROM.write(y+2, z);  // z= la lectura de cuantos caracteres entraron por puerto de serie, 
                             // serán guardados en dirección y+2 = 8+2 en este ejemplo. 
                             // se guardó en la parte void cambio_clave() 
....
EEPROM.put(y+3, clave); // la clave se escribe el la eeprom apartir del décimo primer hueco de eeprom. 
      // y tendrá 6 carateres en este caso. por lo tanto hemos llenado asta la dirección 0fh de la eeprom (16 huecos de eeprom usados.).  
     
...}

de ejemplo; escribió PepitoF1 como ssid) y clavel como clave.
pepitof1 tiene 8 letras, se guarda un 8 en la eeprom dirección 0.
*en la direccion 0 habria un 8,
*en la dirección 1 como tiene 8 letras,.. las 8 letras se guardan de la 1 a la 8 de la eeprom. gracias al comando de EEPROM.put que guarda la cadena de caracteres ascii apartir de la direccion indicada de la eeprom , contenida dentro del char del array. EEPROM.put(Address, nombreArray);
*la dir 9 de la eeprom sería un 6 porque clavel tiene 6 letras.
*la dirección 10 asta la 15 de la eeprom guardaríamos la palabra clavel que es la clave.
el mapa de memoria leído en decimal sería:

DIRh 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000h 08 80 101 112 105 116 111 70 49 06 99 108 97 118 101 108
asci P e p i t o F 1 c l a v e l

8 PepitoF1 6 clavel

no se si lo he explicado bien, me he esforzado en ello.

Bueno me ha llevado un buen tiempo pero acá esta.
Tienes dos métodos para recuperar los datos.

  1. En la FLASH
  2. En la EEPROM usando data
#include <EEPROM.h>
#include <avr/pgmspace.h>

int cuanto 		= 1;
int direccion 	= 0;

// datos guardos en FLASH
const char* const ssid[] PROGMEM = {"ssid1", "ssid2","ssid3","ssid4"};

// Estructura para luego guardarlos en EEPROM
struct _Datos {
	char *wifi;
};

_Datos datos[4]; // Este sera el vector que los almacene
char buffer[30];

_Datos datosRead[4];  // Este es el vector que los leerá

void setup() {
   Serial.begin(9600);
   address(0);
   EEPROM.put(direccion, cuanto);      

   address(sizeof(cuanto));
   int tmp = EEPROM.read(0);
   Serial.print("Valor: ");
   Serial.print(tmp);
   Serial.print("SSID : ");

   Serial.println("Setup terminado.");

   // incializo la estructura
   // Comentar luego de guardarlos en la EEPROM
   datos[0].wifi = {"ssid0"};
   datos[1].wifi = {"ssid1"};
   datos[2].wifi = {"ssid2"};
   datos[3].wifi = {"ssid3"};
   // aca los guardo en la EEPROM
   // Se supone que esto no estará en el codigo o simplemente comentarlo
   EEPROM.put(direccion, datosWrite);
   // Hasta aca comentar

   
   // Aca leo los datos de la EEPROM
   EEPROM.get(direccion, datosRead);
}

void loop() {
   for (int i=0; i<4; i++) {
	   Serial.print("Valor: ");
	   Serial.print(i);
	   Serial.print(" ");
	   // Recupera los datos de la FLASH
	   sprintf(buffer, "%s", (char *)pgm_read_word(&(ssid[i])));
   	   Serial.print(buffer);
   	   Serial.print(" ");
   	   // Recupera los datos de la EEPROM
   	   sprintf(buffer, "%s", (char*)datosRead[i].wifi);
	   Serial.println(buffer);
   }
   delay(1000);
}

void address(int tmp) {
   //Serial.print("Direccion:");
   //Serial.println(tmp);
   direccion += tmp;
}

Es tarde, si tienes dudas mañana te las respondo.

Gracias por la repuesta.
Desde mi noble entendimiento me encuentro un poco perdido para comprender algunos comandos.
Y para ejercer mi trabajo, necesito hacer las cosas sabiendo cual es su significado, es por ello por lo que aun no he podido contestar, estoy intentando buscar información acerca de algunas sentencias de programa, pero que no lo consigo entender todo y sigo estudiando..

podrías comentar estos siguientes lineas?.. y el ' * ' . que me lo encuentro en muchas ocasiones y no se para que se usa.

const char* const ssid[] PROGMEM = {"ssid1", "ssid2","ssid3","ssid4"};

char *wifi;

sprintf(buffer, "%s", (char *)pgm_read_word(&(ssid[i])));

sprintf(buffer, "%s", (char*)datosRead[i].wifi);

El * es para definir punteros. Eso es porque tu SSID seguramente tendra longituds diferentes.

char *wifi; no se de donde viene pero de nuevo, la asignacion de la variable tiene dimensión variable.

const char* const ssid[] PROGMEM = {"ssid1", "ssid2","ssid3","ssid4"};

sprintf(buffer, "%s", (char *)pgm_read_word(&(ssid)));

Yo te puse en un código dos maneras de hacerlo, una es esta usando la FLASH para almacenar los datos.

para guardar cosas en la FLASH debes usar PROGMEM y como verás el modo de hacerlo con punteros es complicado incluso para mi.
la segunda instrucción es para leer el valor de la FLASH
pgm_read_word()

Solo remitete a esto para leer mas al respecto en PROGMEM

La última línea de código

sprintf(buffer, "%s", (char*)datosRead.wifi);

usa tu estructura que tu has definido y solo para asegurarme que no uso la que defino cree dos variables datosRead y datosWrite.

Volviendo a sprintf() es un procedimiento que pasa el dato leido al vector buffer[30]

Tal vez la explicación no te haya servido y se debe a que hay que practicar cada cosa mucho para entenderlas.
Si te saltas pasos, quedan huecos de conocimiento.
Pero lo que pides hacer, no se como hacerlo de otro modo.

Ahora me queda estudiarmelo y ponerlo en práctica. A ver si no me lío mucho. :wink:
Muchas gracias.

Olvida PROGMEM y usa tu estructura.

Buenas tarde señores, tengo aqui un proyecto que me está destrozando la cabeza porque me da un problema que no le encuentro el sentido.
lo tengo casi acabado… pero ahí tengo un problema… ayuda!!

el caso es que en mi eeprom interna ya están guardados el ssid y la contraseña, yo cargo uno de los dos a un array ya sea el sid o la clave y funciona, pero el problema es que no se que pasa, por que cuando creo un nuevo array, me coge solo el valor del segundo en los dos. no se si me explico bien, pero es que no lo entiendo ni yo mismo.

os lo explico graficamente:

se puede ver pulsado boton derecho del ratón y abrir en ventana nueva.
esto quiere decir que yo tengo un ssid y una (contraseña) key
vsid = 9 … es que mi contraseña tiene 9 caracteres… ( ya los conté previamente con una variable contador que me lee lo que entra por el puerto de serie.
ssid = cartagena

significa, que lo que hay antes es mi clave…

vkey = 4 … mi contraseña tiene 4 caracteres.
key = pino

significa que ahi termina mi clave…

todo esto está controlado y lo leo de la eeprom.

mi programa hace que cuando encienda, vaya a la eeprom, rescate de cuanto es el nombre de usuario, y cree un array de ese valor por eso yo en declaraciones antes del setup le digo:

char ssid []={};    // declaro arrays pero los declaro pero vacios
char clave [] ={};  // para después asignarle el valor

seguimos… lo hago por separado y me lee bien,…
leo el ssid de la eeprom, lo guarda en el array y lo imprime bien.

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

for (c=0; c<vsid; c++)    //  va incrementando la c desde 0 asta 9 en este caso del ejemplo
   {
      ssid[c] = EEPROM.read(c+1);  // la priemera vez lee de la direccion 1 de la eeprom 
    }                                         // asta la 9 en este caso del ejemplo

    Serial.print("ssid "); Serial.println(ssid);  // lo imprime bien..  "  cartagena  "

así funciona…
si hago solo el key…

for (v=0; v<vkey; v++)
     {
      clave[v] = EEPROM.read(ubicacionVkey+1+v);
     }


Serial.print("key  "); Serial.println(clave);   // imprime la clave correctamente "  pino  "

ahora cuando quiero hacer lo mismo con el ssid y la clave al mismo tiempo… viene el problema.
el array segundo que creo, me mezcla los valores,

lo que no entiendo es si un array ya está hecho, tiene sus valores dentro, si no hay nada que le diga que se cambie, de donde lee, por que mezcla? … arggg me vuelve loco…

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

for (c=0; c<vsid; c++)
   {
      ssid[c] = EEPROM.read(c+1);
    }

    Serial.print("ssid "); Serial.println(ssid); 

for (v=0; v<vkey; v++)
     {
      clave[v] = EEPROM.read(ubicacionVkey+1+v);
     }


Serial.print("key  "); Serial.println(clave);

delay(3000) ; 

delay(100);
   pinMode(13,OUTPUT);   pinMode(12,OUTPUT);   pinMode(11,OUTPUT);
   digitalWrite(13,LOW);   digitalWrite(12,LOW);   digitalWrite(11,LOW);  


Serial.println("Aqui termina el setup");
delay(50);


}

aqui pongo el archivo entero, ya tiene mucha basurilla porque le intentado hacer muchas cosas para ver que hago y generar un nuevo array con el valor que ya tengo, y tal, pero esque no se que hacer, considero que le hablo en su idioma, pero no me entiende, creo que debería de funcionar porque veo claro el funcionamiento pero no veo por que es por lo que no lo hace bien,

archivo entero:

void(* resetFunc) (void) = 0; // esta es la funcion



#include <EEPROM.h>
#include<SoftwareSerial.h>
char cc[20]={};
byte vsid = EEPROM.read(0);
char ssid []={}; 
char ssidOK []={};
char neu_ssid [] = {}; 
char neussid[] = {};
byte ubicacionVkey = vsid+2;
byte vkey = EEPROM.read(ubicacionVkey);
char clave []={}; 
char claveOK []={}; 
char neu_key [] = {}; 
char neukey[] = {};
byte a,i,x,y,z=0;
char c,v=0;
void setup()
{  
  Serial.begin(9600);

for (c=0; c<vsid; c++)
   {
      ssid[c] = EEPROM.read(c+1);
    }

    Serial.print("ssid "); Serial.println(ssid); 

for (v=0; v<vkey; v++)
     {
      clave[v] = EEPROM.read(ubicacionVkey+1+v);
     }


Serial.print("key  "); Serial.println(clave);

delay(3000) ; 

delay(100);
   pinMode(13,OUTPUT);   pinMode(12,OUTPUT);   pinMode(11,OUTPUT);
   digitalWrite(13,LOW);   digitalWrite(12,LOW);   digitalWrite(11,LOW);  


Serial.println("Aqui termina el setup");
delay(50);
c=0;

}



void cambiar_ssid()
{
  Serial.print("ecriba *nuevo_nombre# para cambiar el SSID  de internet");
    delay(1000);
 
  if(Serial.available()>0){  
    espera_neu_ssid:
        
         c=Serial.read();
         neu_ssid[i]=c;
         
         i++; 
          EEPROM.write(i, c);
         if(i==20){  i=0;  }
   
if(c=='*') {i=0; x=0;}

y= i-1;
Serial.println(y);
      if(c=='#') goto termina1;
  goto espera_neu_ssid;
  termina1: {  neussid[y] = {}; Serial.print("se cambiaron el ssid nuevo por = "); Serial.println(neu_ssid); delay(6000);           
  for ( i=0; i>y; i++ )
      { neussid[i] = neu_ssid[i];
      }
           }
 EEPROM.write(0, y);
 
  }
}  

void loop()
{

if(Serial.available()>0){
        
         c=Serial.read();
         cc[i]=c;
         i++;
         if(i==20){  i=0;  }
     
if(c=='*') {i=0; x=0;}
if((cc[0]=='

)&&(cc[1]==‘1’)&&(cc[2]==’#’)) {i=0; y=0; cambiar_ssid();}
if((cc[0]==’


)&&(cc[1]=='2')&&(cc[2]=='#')) resetFunc();  
//if((cc[0]=='1')&&(cc[1]=='3')&&(cc[2]=='3')) // EEPROM.put(1,neussid);
if((cc[0]=='s')&&(cc[1]=='s')&&(cc[2]=='i')) {Serial.print ("ssid    es ........................");  Serial.println (ssid) ; delay(2000);}
//if((cc[0]=='k')&&(cc[1]=='e')&&(cc[2]=='y')) {Serial.print ("clave    es ...........opop............") ;   Serial.print (clave) ;  delay(2000);}
}
delay(2000);
Serial.println(" ******************************************* ") ;
Serial.print("  ssid..  ") ; Serial.println (ssid) ; 
Serial.print("neu ssid  "); Serial.println(neu_ssid);
Serial.print("y caracteres sid  ....   "); Serial.println(y);
Serial.print("neussid  "); Serial.println(neussid);
Serial.print("vsid  "); Serial.println(vsid);
Serial.print("vkey es.. "); Serial.println(vkey);
Serial.print("ubicacionVkey ");   Serial.println(ubicacionVkey ); Serial.println(EEPROM.read(11));
Serial.print("key es.. "); Serial.println(clave);
Serial.print("ssid es.. "); Serial.println(ssid);

Serial.println("leo memoria 11");  Serial.println(EEPROM.read(11));
Serial.println("leo memoria 12");  Serial.println(EEPROM.read(12));
Serial.println("leo memoria 13");  Serial.println(EEPROM.read(13));
Serial.println("leo memoria 14");  Serial.println(EEPROM.read(14));
Serial.println("leo memoria 15");  Serial.println(EEPROM.read(15));
Serial.println("leo memoria 16");  Serial.println(EEPROM.read(16));
for (v=0; v<vkey; v++)
     {
      clave[v] = EEPROM.read(vsid+3+v);
     }




}

la imagen anterior no se cargó, la adjunto aquí. donde digo que os lo explico gráficamente…
esta sería la foto de la estructura de la eeprom, interna del arduino donde guarda la, contraseña y el nombre…

Y para que te complicas la vida si tienes expresiones como EEPROM.get y EEPROM.put.
Crea una estructura con los datos de ssid y key y los lees rápidamente.

Mira los ejemplos, es mas creo haberte dado dos opciones en un post anterior tuyo que acabo de ver que jamas dijiste si estaba terminado o no, y como sigues preguntando lo mismo o aparentemente lo mismo pareciera esto una continuidad de lo otro.

Resumiendo. EEPROM.get y EEPROM.put

Voy a tomar el ejemplo que viene y lo modificaré con tus datos

con este lo guardo

#include <EEPROM.h>

struct MyObject{
  char ssid[9];
  char vkey[4];
};

void setup() {

  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

   //Data to store.
  MyObject customVar = {
    "cartagena",
    "pino"
  };

  EEPROM.put(eeAddress, customVar);
  Serial.print("Estructura de datos guardada\n\nSeguir el otro ejemplo para leer los datos!");
}

void loop() {   /* Empty loop */ }

con este lo leo

#include <EEPROM.h>

struct MyObject{
  char ssid[9];
  char vkey[4];
};

void setup(){

  int eeAddress = 0; //EEPROM address to start reading from

  Serial.begin( 9600 );
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  Serial.print( "leo ssid y vkey desde la EEPROM: " );

  MyObject customVar; //Variable to store custom object read from EEPROM.
  EEPROM.get( eeAddress, customVar );

  Serial.println( customVar.ssid );
  Serial.println( customVar.vkey );
}

void loop(){ /* Empty loop */ }

Gracias surbyte, pongo en practica tu explicación. . este es casi parecido al otro anterior post, que aun sigo estudiando e intentando avanzar, tanto con este proyecto como con otros varios que tengo, el problema es el poco tiempo del que dispongo, pues hago varios sketch al dia medianamente rapidos que por logica veo que debieran de funcionar y no funciona, y este es uno de los que me parten la cabeza, me encuentro que mezcla un array con otro y tal, y querría saber por que ocurre esto.

Si es parecido es doble post.
Asi que voy a unirlos y por favor no vuelvas a hacerlo.
Empieza un hilo y hasta estar satisfecho y que no digas SOLUCIONADO no abres otro similar. Quedas advertido!!

Ya los uní, recuerda mi advertencia

hip_africa:
Gracias surbyte, pongo en practica tu explicación. . este es casi parecido al otro anterior post, que aun sigo estudiando e intentando avanzar, tanto con este proyecto como con otros varios que tengo, el problema es el poco tiempo del que dispongo, pues hago varios sketch al dia medianamente rapidos que por logica veo que debieran de funcionar y no funciona, y este es uno de los que me parten la cabeza, me encuentro que mezcla un array con otro y tal, y querría saber por que ocurre esto.

No funciona debido a que has definido las variables ssid y clave con longitud cero.
El compilador ha asignado la misma posición en la ram para las dos variables. Cuando modificas una tambien cambias la otra. Ademas de que estás escribiendo fuera de la variable. Realmente no pueden contener ningún dato.

Con este código veras más claro lo que ocurre:

char ssid []={};    // declaro arrays pero los declaro pero vacios
char clave [] ={};  // para después asignarle el valor


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

  char* addressSSID=ssid;
  char* addressClave=clave;

  Serial.print("Direccion de la variable ssid:");
  Serial.println((uint32)addressSSID,HEX);

  Serial.print("Direccion de la variable clave:");
  Serial.println((uint32)addressClave,HEX);
}

loop(){}

Direccion de la variable ssid:3FFEE270
Direccion de la variable clave:3FFEE270

Muchas gracias..

ya decía yo que ahí pasaba lo que sea raro, muchas veces me pasa con cosas de estas que hago y me gusta ir mirando por que no va, esta vez me quedé así ya perdido del todo...
yo pensaba que haciendolo así era un arreglo dinámico, pero ahora comprendo que no.
vi como hacer arreglo dinamico en c++ con una librería que usaba New y delete, pero esa creo que no está para arduino, porque no me funcinó.