Uso de arrays

Hola, tengo que implementar un código que le pregunte al usuario de cuántos números quiere calcular el cuadrado, almacenarlos en un array y presentarlos por pantalla recorriendo el array.

De momento lo he hecho sin hacer uso del array para nada, porque lo he intentado de mil formas y nada. Alguien sabe como puedo convertir el número que se introduce por teclado a un array de ese tamaño y después mostrar por pantalla todos los cuadrados del mismo? gracias


void setup()
{
	Serial.begin(9600);
	Serial.setTimeout(100);
  	Serial.println("¿De cuantos numeros quieres ver el cuadrado?");
}
void loop()
{
	if (Serial.available())
    {
      int Cuadrados = Serial.parseInt();
      Serial.println(Cuadrados);
      int ArrayRecibido[Cuadrados]; // La longitud del array el la del nº introducido por teclado.
      Serial.println("Resultado: ");
      for (int i = 0; i < Cuadrados ; i++)
      {
      
		Serial.println(i*i);
      }
	Serial.println();
    }
}

Hola

Creo que necesitas un array dinámico. Hay bastante información en la red, incluso librerías para hacer más sencilla la implementación. Ojo con la poca memoria que tiene el arduino porque a la hora de implementar el "array dinámico" siempre utilizará el doble o más de la memoria del array.

Dejo un enlace a uno de los estupendos tutoriales de Luis Llamas, aunque hay mucho más en la red.

Array dinámico

Espero que sirva

Saludo

Aunque @pepepotero tiene razón, no creo que tu profesor te haya pedido algo tan elevado como un array dinámico. Eso es programación mas avanzada.
Simplemente podrias crear un array de enteros, con un limite y preguntar de cuantos números se desea calcular el cuadrado, si se ingresa un número mayor a tu limite simplemente se dirá, “Se ha ingresado un número que excede el limite calculable de cuadrados o algo similar”.
Y le vuelves a pedir que ingrese un número.

Un array es simplemente una tabla de de datos de dimensión N filas y 1 columna o a la inversa, 1 fila y N columnas.
defines un array de enteros, o flotantes o cualquier otro tipo de datos de esta forma

int datos[20];

eso crea un array de 20 datos enteros que comienzas en 0 y terminan en 19
Como accedes?
El primero es dato[0] el segundo dato[1] … el ultimo dato[19]
cada uno contiene 0 o bien el dato que ingreses.

Entonces en tu programa debes crear un array de enteros de dimensión fija conocida. Si se supera dicho limite se pedirá al usuario que ingrese un valor permitido.
Luego dentro de un for haras que ingrese los datos que llenen cada uno de los lugares sin errores.
Finalmente barriendo el array por ejemplo dentro de un for de nuevo calcularas los cuadrados de los valores ingresados.

¿Por qué no podría esperar la respuesta del usuario y después, con el número ingresado, generar el array?

Desde ya que va a tener que poner un límite por la limitación de memoria (en un UNO/Nano no llegaría a 500 items, (500 x 4 bytes= 2000 bytes)) pero poder, se puede.

Solo es cuestión de hacer una función que cree el array, haga los cálculos, guarde los resultados en el array y luego los imprima. Cuando se sale de la función el array se destruye (porque se sale de su ámbito) y ya se puede volver a empezar.

Algo así

// definiciones apropiadas

void setup() {
  // lo que haga falta setear...
}

void loop() {
  // presentación en display y demás cuestiones...
  // verifica si se ingresa un numero menor a 400...
  int ingreso = dato_ingresado;
  calcular_cuadrados(ingreso);
  // cualquier otra cosa que se necesite aquí...
}

void calcular_cuadrados(int limite) {
  long cuadrados[limite];
  for(int i = 0; i < limite; i++) {
  // calcular cuadrado de i y guardar en cuadrados[i] ...
  }
// --- para seguir la consigna "guardar en array y luego imprimir..."
  for(int i = 0; i < limite; i++) {
  // mostrar i y cuadrados[i] en display...
  }
}

¿O estoy equivocado?

Saludos

PD: Mi Nano dice que tengo razón. :grin:

Tu puedes definir el tamaño máximo del array, digamos 50. Para controlar el número de datos por consulta, debes preguntar antes, cuántos números serán ingresados para el cálculo. De esta forma podrás controlar el tamaño de la muestra.

Lo que sigue es almacenar los datos en el array. Luego de finalizada la consulta, puedes optar por agregar una rutina para reiniciar el array en ceros para una nueva consulta o bien para repetir el cálculo de la última serie de datos.

De esta forma el array puede ser manipulado dato por dato.

#include <GDXT4X.h>

#define NMax    50 
int ArrayNumeros[NMax];
int Cuadrados[NMax];

char stCurrent[20]="";
int stCurrentLen=0;
char stLast[20]="";
int espera = 145;
int x;
char PresentaDatos[50];

int NDatosConsul=0;
int Consulta = 0;
int Valor =0;
int errorNDatos=0;
int Ingresa = 0;
int BaseDatos=0;

void setup() 
{
  GD.begin();
  MP();
}
void loop(){}

void updateStr(int val)
{
  if (stCurrentLen<20)
  {
    stCurrent[stCurrentLen]=val;
    stCurrent[stCurrentLen+1]='\0';
    stCurrentLen++;
  }
}

void MP() 
{
 while(1)
 {
  GD.Clear();
  GD.get_inputs();
   GD.SaveContext();
   GD.cmd_fgcolor(0x005000);    GD.ColorRGB(0x000000); 
    GD.Tag(13);   GD.cmd_button(50, 50, 380, 60, 29, 0,  "No. de datos para consultar:");  GD.Tag(255);
   GD.ColorRGB(0x005000);  GD.cmd_number(50+380+50, 60, 30, 0, NDatosConsul);

   if (Ingresa==1)
   {
    GD.cmd_fgcolor(0x505050);    GD.ColorRGB(0x000000); 
    GD.cmd_button(50, 50, 380, 60, 29, 0,  "No. de datos para consultar:");
    GD.cmd_fgcolor(0x005000);    GD.ColorRGB(0x000000);
    GD.Tag(14);   GD.cmd_button(50, 50+60+15, 380, 60, 29, 0,  "Ingresa valores");  GD.Tag(255);    
   }
   GD.RestoreContext();

   if (Consulta==1)
      {
         Teclado(60,50+50+40);
      }

   if (Consulta==2)
      {
       if(BaseDatos>=NDatosConsul)
       {
        GD.ColorRGB(0x500000);   GD.cmd_text(60+200, 480-20, 28, OPT_CENTER, "Limite alcanzado"); Consulta=3;
       }
       else{
        Teclado(75,50+50+40+30);
        }
      }

   if (Consulta==3)
      {
             for (int j = 0; j < NDatosConsul; j++) 
             { 
               Cuadrados[j]= ArrayNumeros[j]*ArrayNumeros[j];
               sprintf(PresentaDatos,"Dato[%d] = %d       %d", j, ArrayNumeros[j], Cuadrados[j]); GD.cmd_text(60+600, 75 + 25*(j+1), 28, OPT_CENTER, PresentaDatos);
             }

        if(BaseDatos>=NDatosConsul)
           {
             GD.SaveContext();
               GD.cmd_fgcolor(0x500000);    GD.ColorRGB(0xffffff); 
               GD.Tag(15);   GD.cmd_button(50, 50+60+15, 380, 60, 29, 0,  "Reiniciar base de datos");  GD.Tag(255);

             GD.RestoreContext();
           }
       }

   if (GD.inputs.tag==13)
   {
     delay(espera);
     Consulta = Consulta + 1;
     if(Consulta>=2){Consulta=0;}
   }

   if (GD.inputs.tag==14)
   {
     delay(espera);
     Consulta = 2;
   }

   if (GD.inputs.tag==15)
   {
     delay(espera);

            for (int j = 0; j < NDatosConsul; j++) 
             {  
               ArrayNumeros[j] = 0;
             }

    NDatosConsul=0;
    Consulta = 0;
    Valor =0;
    errorNDatos=0;
    Ingresa = 0;
    BaseDatos=0;
   }
   
  GD.swap();  
 }
}

void Teclado(int PX, int PY)
{
// while(1)
// {
//  GD.Clear();
//  GD.get_inputs();
    
  GD.SaveContext();
   GD.cmd_fgcolor(0x505000);    GD.ColorRGB(0x000000);   
   GD.Tag(1);    GD.cmd_button(PX, PY, 120, 60, 29, 0,  "1");     GD.Tag(255);
   GD.Tag(2);    GD.cmd_button(PX+120+10, PY, 120, 60, 29, 0,  "2");     GD.Tag(255);
   GD.Tag(3);    GD.cmd_button(PX+120+10+120+10, PY, 120, 60, 29, 0,  "3");     GD.Tag(255);
   GD.Tag(4);    GD.cmd_button(PX, PY+60+10, 120, 60, 29, 0,  "4");  GD.Tag(255);
   GD.Tag(5);    GD.cmd_button(PX+120+10, PY+60+10, 120, 60, 29, 0,  "5");  GD.Tag(255);
   GD.Tag(6);    GD.cmd_button(PX+120+10+120+10, PY+60+10, 120, 60, 29, 0,  "6");  GD.Tag(255);
   GD.Tag(7);    GD.cmd_button(PX, PY+60+10+60+10, 120, 60, 29, 0,  "7");  GD.Tag(255);
   GD.Tag(8);    GD.cmd_button(PX+120+10, PY+60+10+60+10, 120, 60, 29, 0,  "8");  GD.Tag(255);
   GD.Tag(9);    GD.cmd_button(PX+120+10+120+10, PY+60+10+60+10, 120, 60, 29, 0,  "9");  GD.Tag(255);
   GD.Tag(10);   GD.cmd_button(PX, PY+60+10+60+10+60+10, 120, 60, 29, 0,  "C");  GD.Tag(255);
   GD.Tag(11);   GD.cmd_button(PX+120+10, PY+60+10+60+10+60+10, 120, 60, 29, 0,  "0");  GD.Tag(255);
   GD.cmd_fgcolor(0x005000);    GD.ColorRGB(0xffffff);
   GD.Tag(12);   GD.cmd_button(PX+120+10+120+10, PY+60+10+60+10+60+10, 120, 60, 29, 0,  "->");  GD.Tag(255);
  GD.RestoreContext();

   if (GD.inputs.tag==1)
   {
     delay(espera);
     updateStr('1');
   }

   if (GD.inputs.tag==2)
   {
     delay(espera);
     updateStr('2');
   }

   if (GD.inputs.tag==3)
   {
     delay(espera);
     updateStr('3');
   }
   if (GD.inputs.tag==4)
   {
     delay(espera);
     updateStr('4');
   }
   if (GD.inputs.tag==5)
   {
     delay(espera);
     updateStr('5');
   }
   if (GD.inputs.tag==6)
   {
     delay(espera);
     updateStr('6');
   }
   if (GD.inputs.tag==7)
   {
     delay(espera);
     updateStr('7');
   }
   if (GD.inputs.tag==8)
   {
     delay(espera);
     updateStr('8');
   }
   if (GD.inputs.tag==9)
   {
     delay(espera);
     updateStr('9');
   }
   if (GD.inputs.tag==10)
   {
     delay(espera);
     stCurrent[0]='\0';
     stCurrentLen=0;
     Valor =0;
   }
   if (GD.inputs.tag==11)
   {
     delay(espera);
     updateStr('0');
   }
   if (GD.inputs.tag==12)
   {
     delay(espera);
      if (stCurrentLen>0)
          {
            for (x=0; x<stCurrentLen+1; x++)
            {
              stLast[x]=stCurrent[x];
            }
            stCurrent[0]='\0';
            stCurrentLen=0;
          }
     //Valor = atof(stLast);  //número flotante
     Valor = atol(stLast);  //número entero

     if(Consulta==1){

          NDatosConsul = Valor; 
            if(NDatosConsul>=NMax)
              {
               errorNDatos =1;
              }else{Consulta=0; Valor =0; errorNDatos =0; Ingresa=1; MP();
                    stCurrent[0]='\0';
                    stCurrentLen=0;
                   }
     }

     if(Consulta==2){

          //NDatosConsul = Valor;
          ArrayNumeros[BaseDatos]=Valor; 
            if(NDatosConsul>=NMax)
              {
               errorNDatos =1;
              }else{Consulta=3; Valor =0; errorNDatos =0; Ingresa=1; BaseDatos =BaseDatos+1; MP();
                    stCurrent[0]='\0';
                    stCurrentLen=0;
                   }
     }

   }
  GD.SaveContext();

            for (int j = 0; j < NDatosConsul; j++) 
             { 
               Cuadrados[j]= ArrayNumeros[j]*ArrayNumeros[j];
               sprintf(PresentaDatos,"Dato[%d] = %d       %d", j, ArrayNumeros[j], Cuadrados[j]); GD.cmd_text(60+600, 75 + 25*(j+1), 28, OPT_CENTER, PresentaDatos);
             }

   if(errorNDatos==1){ GD.ColorRGB(0x500000);   GD.cmd_text(PX+200, 480-20, 28, OPT_CENTER, "Por favor ingresa otro valor para consulta");}
  
   GD.ColorRGB(0x505000);   GD.cmd_text(PX+400, PY, 31, 0, stCurrent);
  GD.RestoreContext();
//  GD.swap();
// }
}

Puedes usar como base para procesar entradas numéricas desde un teclado, el ejemplo URTouch_ButtonTest.ino de la librería URTouch. En este caso lo ajusté para una pantalla FT813 de 5" con la libreria GDXT4X, una variante de la libreria para gameduino 23X, que estoy adaptando para placas teensy 4 y 4.1

Hola, tengo el siguiente ejercicio; escribir un programa que le pregunte al usuario qué calificación ha obtenido en el examen, y en función de la misma, mostrar un mensaje de ánimo. Es válido con tres calificaciones válidas (o más), tanto numéricas (10, 9, 8, 7…) como textuales (A, B, C, …);
Lo he hecho de la forma más simple que se me ha ocurrido (con calificaciones numéricas), distintos bucles if que en función de la nota te salía un mensaje distinto; por ejemplo si la nota está en el intervalo (0, 5) un "Sigue intentándolo". Mi pregunta es si hay alguna forma de simplificar el código implementando un array. Es más que nada para practicar con este tipo de datos porque normalmente nunca los uso y soy consciente de que en ocasiones simplifican mucho las cosas.

Road to be a one liner jajajajaja...

¿Y si pones el código que habría que simplificar para saber si conviene usar arrays?

Este sería el código, aún tengo que pulirlo que lo he hecho así rápido en 10 minutos.

void setup()
{
	Serial.begin(9600);
	Serial.setTimeout(100);
  	Serial.println("¿Que nota has sacado?");
  	
}
void loop()
{
  if (Serial.available())
  {
    float Calificacion = Serial.parseInt();
    if (0<=Calificacion<5)
    {
      Serial.println("No te desanimes, puedes mejorar.");
    }
    if (Calificacion>=5 && Calificacion<7)
    {
      Serial.println("Bien, puedes seguir mejorando.");
    }
    if (Calificacion<=7 && Calificacion<=9)
    {
      Serial.println("Enhorabuena, sigue así.");
    }
    if (9<Calificacion<=10)
    {
      Serial.println("Genius!!");
    }
    if (Calificacion<0 or Calificacion>10)
    {
      Serial.println("No me trolees anda...");
    }
  }
}

Sé que tiene que haber una forma mucho mejor de hacer esto

Moderador

Este es tu 3 hilo preguntado lo mismo con lo que acabs de cometer no una sino dos faltas de doble posteo.

Hilo 1: Uso de array
Hilo 2: lo mismo en el foro en inglés lo que ya es una falta. How to use arrays.
Hilo 3 este

Tu hilo 1 será unido con este.
Tu hilo en ingles será cerrado.

Repistes esto y serás baneada por un dia por falta a las normas del foro.

Por favor, no alegues desconocimiento. Toda persona que llega a un foro debe leer sus normas, no hacerlo es tu responsabilidad pero cometer faltas tiene consecuencias.
Como dije por esta vez pasa, pero no lo vuelvas a hacer.
Justificaciones y/o comentarios lo envias por privado. No desvirtuemos el hilo.

Tu código de 10 minutos revela que no has leído tu hilo anterior.
Por favor leelo mas las explicaciones que te dimos en el otro hilo. Tienes todo para resolver tu problema
Tambien en el foro en inglés te dieron ayuda similar. Entre todo mas las indicaciones de como buscar información deberías poder lograrlo.

@spicyshark no entiendo cómo lo "simplificarías" con array aunque nada impide que uses un array de cadenas para guardar las respuestas a mostrar.
En todo caso usaría switch/case, no lo simplifica pero hace un código más limpio.

Saludos

Yo me refería a que quizás de alguna forma se podrían guardar las calificaciones posibles en un array y dependiendo de la nota introducida hacer que según el intervalo en el que esté salte un mensaje diferente… Pero la verdad así descrito parece bastante complicado…

Aunque no es específico de arrays supongo que puedo preguntarlo aquí porque puse el código un poco más arriba. Lo he modificado bastante y me sudece una cosa rarísima, este es el código:

void setup()
{
  Serial.begin(9600);
  Serial.println("Introduce tu calificación en formato textual (A, B, C, D o F)");
}
void loop()
{
  if (Serial.available()) {
    char data = Serial.read();
    if ((data >= 'A' && data <= 'F') || (data >= 'a' && data <= 'f')) 
    {   
      if (data == 'A'|| data == 'a') 
      {
        Serial.println('Enhorabuena! Genius!');
      }
      if (data == 'B' || data == 'C'|| data == 'b' || data == 'c')
      {
        Serial.println('Muy bien, sigue así');
      }
      if (data =='D' || data == 'd')
      {
        Serial.println('Ánimo, puedes mejorar');
      }
      if (data == 'F' || data == 'E' || data == 'f' || data == 'e') 
      {
        Serial.println('No te desanimes, puedes hacerlo mejor');
      }
    }
    else {
      Serial.println("La nota introducida no es valida.");
    }
  }
}

Cuando pongo algún caracter que no está dentro de los que he definido funciona perfectamente pero si por ejemplo introduzco ‘E’ me imprime por pantalla lo siguiente 28530 en vez del Serial.print que he definido. Y así con todas las calificaciones pero distintos números. Alguien sabe a que se pueda deber esto??

Gracias

Porque está mal definido lo que se va a imprimir, en Serial.print se usan comillas dobles para las cadenas.

Saludos

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.