Misterio en el array

International Español Software
1

Saludos, esta es mi primera entrada en el foro. No tengo gran experiencia con electrónica pero conozco lo básico de otros lenguajes de programación. El caso es que en C precisamente no es donde tengo mucha experiencia en cuanto sobre todo con la sintaxis.

Y creo que el problema que os presento deberia tener que ver con ello.

Tengo un array donde tengo que rellenar datos de otros array, este ultimo es multidimensional. Los recupero de ese segundo array para no tener que estar recibiendo esos datos de arduino y de esta forma "simulo" que van entrando datos.

El problema aparece cuando relleno el 1er dato y me da un valor que NO APARECE en ninguna variable ni otro array ni en todo el código. Los siguientes datos los rellena bien, pero cuando vuelve al mismo dato vuelve a aparecer ese valor erroneo y no tengo ni idea de donde procede.

Este es el codigo:

const int numCapas = 2;
const int datosEntradasdeCapa = 3;
const int numero_total_de_los_datos_de_aprendizaje = 5;

int configRN[numCapas][datosEntradasdeCapa] = { 
  { 4,2,2 }, 
  { 2,2,2 }  
};


int datosEntrada[numero_total_de_los_datos_de_aprendizaje][4] = {
  
  { 0, 45, 51, 60   },
  { 70, 55, 56, 66  },
  { 100, 38, 41, 42 },
  { 30, 65, 67, 80  },
  { 40, 26, 22, 23  }
};


int *lista_de_datos_de_entrada_de_capa; 
int **lista_de_datos_de_salida_de_capa;


void creamos_lista_de_datos_de_entrada_de_capa(int id_de_capa)
{
  
  if (id_de_capa == 0)
  {
      Serial.println("--- --inicio -- ---");
      // Para cada grupo de 4 datos
      for ( int id_de_grupo_de_datos = 0 ; id_de_grupo_de_datos < numero_total_de_los_datos_de_aprendizaje ; id_de_grupo_de_datos++ )
      {
           Serial.println("--- --nuevo grupo-- --- --- ---->");
           Serial.print("  grupo_de_datos: ");
           Serial.println(id_de_grupo_de_datos);
           Serial.print("datosdeesta_capa: ");
           Serial.println(configRN[id_de_capa][0]);
           
          // Por cada dato
          for ( int id_dato_de_capa = 0 ; id_dato_de_capa < configRN[id_de_capa][0] ; id_dato_de_capa++ )
          {
            Serial.println("--- --nuevo dato-- --- --- ---->");
            Serial.print(" id_dato_de_capa: ");
            Serial.println(id_dato_de_capa);
            Serial.print("      dato --x->: ");
            Serial.println(datosEntrada[id_de_grupo_de_datos][id_dato_de_capa]); 
            
            lista_de_datos_de_entrada_de_capa[id_dato_de_capa] = datosEntrada[id_de_grupo_de_datos][id_dato_de_capa];
            Serial.print("      dato ---->: ");
            Serial.println(lista_de_datos_de_entrada_de_capa[id_dato_de_capa]);
          }
      }
  }
}


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

void loop()
{
  Serial.println("--------------------------------");
  creamos_lista_de_datos_de_entrada_de_capa(0);
  delay(5000);
}

Y aqui os dejo lo que imprime Serial.

--- --inicio -- ---
--- --nuevo grupo-- --- --- ---->
grupo_de_datos: 0
datosdeesta_capa: 4
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 0
dato --x->: 0 <---- ESTE ES EL DATO CORRECTO ANTES DE SER INTRODUCIDO
dato ---->: 32 <---- ESTE ES EL DATO QUE RECUPERO TRAS LA INTRODUCCION
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 1
dato --x->: 45
dato ---->: 45
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 2
dato --x->: 51
dato ---->: 51
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 3
dato --x->: 60
dato ---->: 60
--- --nuevo grupo-- --- --- ---->
grupo_de_datos: 1
datosdeesta_capa: 4
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 0
dato --x->: 70 <----- AQUI VOLVEMOS AL CICLO
dato ---->: 32 <----- Y OTRA VEZ EL MISMO NUMERO MISTICO
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 1
dato --x->: 55
dato ---->: 55
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 2
dato --x->: 56
dato ---->: 56
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 3
dato --x->: 66
dato ---->: 66
--- --nuevo grupo-- --- --- ---->
grupo_de_datos: 2
datosdeesta_capa: 4
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 0
dato --x->: 100 <----- AQUI VOLVEMOS AL CICLO
dato ---->: 32 <----- Y OTRA VEZ EL MISMO NUMERO MISTICO
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 1
dato --x->: 38
dato ---->: 38
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 2
dato --x->: 41
dato ---->: 41
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 3
dato --x->: 42
dato ---->: 42
--- --nuevo grupo-- --- --- ---->
grupo_de_datos: 3
datosdeesta_capa: 4
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 0
dato --x->: 30
dato ---->: 32 <----- Y OTRA VEZ EL MISMO NUMERO MISTICO
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 1
dato --x->: 65
dato ---->: 65
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 2
dato --x->: 67
dato ---->: 67
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 3
dato --x->: 80
dato ---->: 80
--- --nuevo grupo-- --- --- ---->
grupo_de_datos: 4
datosdeesta_capa: 4
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 0
dato --x->: 40
dato ---->: 32 <----- Y OTRA VEZ EL MISMO NUMERO MISTICO
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 1
dato --x->: 26
dato ---->: 26
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 2
dato --x->: 22
dato ---->: 22
--- --nuevo dato-- --- --- ---->
id_dato_de_capa: 3
dato --x->: 23
dato ---->: 23

Gracias de antemano

2

Bueno, he copiado tu programa. Lo compilé usando un UNO (Proteus) con IDE 1.6.0 y esta fue la respuesta

Todo funciona perfectamente

Ahora me doy cuenta que en las siguientes indicaciones no muestra el valor que se supone debería.

3

Gracias por contestar tan rapido.

Ahora si que me vuelvo loco. Debo pensar que la placa esta "loca" (y me esta arrastrando a mi :o ). Es una arduino Leonardo y no hay nada conectado a ella salvo el microUSB.

Aun asi me parece sorprendente. Simplifique el codigo y sin introducir ningun dato, vuelve a aparecer el mismo numero.

int *lista_de_datos_de_entrada_de_capa; 


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

void loop()
{
  Serial.println("--------------------------------");
  Serial.println(lista_de_datos_de_entrada_de_capa[0]);
  delay(5000);
}

Y por serial:

32

32

32

32
...

No se que mas puedo hacer, ademas de saltar sobre la placa.

4

Que versión de IDE?

mira lo pego aca pero esta imagen no va a perdurar mas allá de una semana

5

Es la 1.0.5-r2

6

La verdad es que no entiendo qué quieres realizar exactamente, pero el problema es que estás utilizando un puntero sin inicializar, con el que vas a escribir en una zona de memoria no prevista, y no sólo se está viendo corrompida por otros datos, sino que seguramente estás corrompiendo otros datos del programa.
¿Se supone que tiene que apuntar hacia alguno de los arrays? ¿a una zona de memoria vacía que vas a reservar como buffer?

7

Y porque a mi no me apunta a datos erroneos?
Ahhh ya se.
Yo lo hago con el simulador y puede que el proceso borre la memoria y no sea fiel testigo de lo que ocurre.

8

Hola noter, no soy conocedor de C. He leido algo sobre los punteros pero no me quedo muy claro. Lo que quiero es leer datos de "datosEntrada" y alimentar un proceso de aprendizaje.

La idea es construir una IA para arduino e instalarla en mi coche o robot.

El programa completo trata de simular una Red Neuronal ( basada en este enlace ), a la cual le damos unos valores que damos como "correctos" y en base a estos datos, el programa debe tomar decisiones. Aun no esta completo pero no puedo continuar con los datos de ese modo.

Pero.... Encontre un parche. Consiste en si el primer valor del array me da el valor de 32 ( que segun he leido, es el tamaño del puntero de un array de tipo int) pues no utilizo ese indice "0" del array y lo incremento +1 y entonces almaceno los datos en el array. De este modo ya no aparece ese numero y lo hace correctamente.

Evidentemente no es una solucion elegante pero me ayudo a seguir. El caso es que no es el unico array y cuando continua el proceso, salvando el error de este post, aparacen mas numeros raros en otros arrays, tal y como comentas.

¿Podrias ilustrarme con un ejemplo sobre el codigo del post, de como acceder a insertar/leer datos en un array de tamaño variable?

9

Una IA con un UNO? Empiezas mal a menos que solo quieras familiarizarte y luego si usarás una plataforma con mas capacidad.
Piensa en un DUE como mínimo por RAM/FLASH.

10

Lo cierto es que no es que quiera familiarizarme, quiero implementarlo, tal vez tengas razón, pero ya que lo tengo encarado por lo menos ver donde están los limites pero de veras que en un PC o algo asi no seria nada útil, sin embargo en arduino seria muy util debido a la flexibilidad. De todas formas también he pensado que de no ser posible sobre arduino, lo intentare sobre la raspberry pi, y le enviare las mediciones desde arduino por bluetooth. ¿Crees que sobre esta plataforma se podra o crees que tambien encontrare problemas de memoria??