Cuantos términos se pueden guardar en un array de Arduino Due?

Estoy haciendo unas pruebas con el arduino Due y mi idea era poder generar un array de 8192 terminos, pero no compila el programa. recién a los 7761 terminos puede compilar el arreglo pero no funciona. me gustaría saber cual es limite que tiene el arduino due para generar un arreglo que funcione? de antemano gracias.

una cosa es hacerlo en ram y otra que sean valores constantes y entonces puedes ubicarlos en la Flash.
Si fuera asi usando el comando PROGMEM puedes guardar mucho mas que eso.
Pero con DUE todo debe investigarse asi que busca Arduino DUE PROGMEM

Muchas gracias surbyte, estaba leyendo el tema de usar PROMEM. ahora si los datos que deseo guardar son variables de medición no serian constantes. Según tu opinión la ram ya fue rebasada y la máxima capacidad tiene ese limite de array?

Es muy posible y a tal punto que luego no te queda espacio para procesar nada.

No se que estas haciendo. Porque no explicas que estas haciendo en lugar de explicar el problema? tal vez se pueda encarar de otro modo o no.

Si son variables claro que no puedes usar la flash.

Básicamente la idea es capturar 8192 puntos de un fenómeno sísmico, luego registrarlos. Ahora el guardado de datos en una memoria externa es muy lento, por esto buscaba si arduino tenia la capacidad de guardar en sus registros internos a gran velocidad y posteriormente guardar el arreglo. Estaba utilizando un RTC para llevar los tiempos pero al generar un aumento de los array el reloj dejo de funcionar. y bueno desde ese punto tampoco pude compilar un arreglo de 8192 que fuera String dado que quiero cargar datos de 4 entradas analógicas.

Pero guardalos en SD para que los guardas en RAM y si no te alcanza la RAM de un Arduino busca uno que la tenga, hay versiones del ESP32 con 4MB de RAM o si te queda chico, pensa en una Raspbery Pi.

Yo iria x una SD.

muchas gracias surbyte, efectivamente estoy usando una SD. Continuare haciendo pruebas a ver que rendimiento consigo.

Hola ROBITSON:

Supongamos que te pregunto si en una caja de zapatos del 43 (talla europea) me caben 8192 figuritas. ¿Tú qué me contestaría?

Así, sin más, no creo que pudieras responderme. Por la talla de los zapatos te podrás hacer una idea de su tamaño, pero si no te digo qué tamaño tiene las figuritas no creo que puedas contestar con más o menos seguridad de si me caben o no.

Bueno, en tu caso la caja de zapato parece ser un Arduino DUE y por lo visto este dispone de 64K+32K de RAM. Lo que no sé si es direccionable consecutivamente. Sospecho que no.

Pero en cuanto al tamaño de tus figuritas apenas dices algo al principio. Luego comentas algo de que quieres cargar datos de 4 entradas analógicas. Bueno, eso tal vez ses una pista. Ya no solo tenemos que hacer de detectives para poder ayudar, sino que encima tenemos que someter al testigo a un interrogatorio "persuasivo". ¿Por qué no darán toda la información posible desde el principio? ¿Tanto cuesta poner la declaración del array o decir el tipo de los elementos del array que estás utilizando?

Otro de los pocos datos que das es que con 7761 deja de funcionar. Supongo que con algunos menos aún te funciona.

Bueno, con tan pocos datos (y sobre todo que no he mirado exactamente como funciona la RAM del Arduino DUE) puedo elucubrar que estás tratando guardar un array en que cada elemento son cuatro enteros. Así que el array que si te "explota" a partir de 7761 elementos, lo que estás consumiendo de RAM y que no te deja seguir es 776142 bytes (el 2 es por el tamaño de un entero de 16 bits en memoria). Eso hace unos 62088 bytes casi 61K. Esa es probablemente la memoria máxima de que dispones para guardar los datos.

Si hasta ahora he acertado (cosa que dudo y de seguro que el asesino no es quien yo creo, pues soy un pésimo detective), cabe una posibilidad para que quepa tu array de datos. Si lo que estás tratando de guardar son cuatro muestras analógicas, estas se suponen que pueden tener una resolución máxima de 12 bits. Así que no es necesario tener un entero de 16 bits por cada muestra. 124 son 48 bits, y eso es lo mínimo que necesitas para cuatro muestras sin perder información. 48 bits son lo que ocupan tres enteros de 16 bits, o lo que es lo mismo, 48 bits son 6 bytes. Así que si en lugar de guardar 8192 elementos de 8 bytes guardas 8192 elementos de 6 bytes, lo que necesitas es 81926 bytes. Con 49152 bytes tienes para guardar el array. Se supone que te quedarían aún unos 12936 bytes libres (62088-49152). Algo más de 12K.

Pero todo esto son especulaciones mías.

Por eso en el post#3 sospechando que esta equivocando la idea de como encarar el tema es que le pido que explique que esta haciendo pero aúnasi no sabemos si son floats, o que, porque datos de un AD simplemente pueden guardarse en forma entera (10 bits) y son la mitad de baratos en espacio que un float, 2 bytes contra 4 bytes.
Incluso si armo una estructura podria ganar bytes ya que el ADC del arduino consume 10 bits y no 16 bits de modo que hay 4 bits malgastados en cada conversión.

Entonces de la forma habitual 4 conversiones del ADC ocupan 4 x 2 bytes = 8 bytes = 64 bits
Si aprovechamos los 4 bits que se magastan, tendríamos las 4 conversiones guardadas en

8 bits + 2 bits
8 bits + 2 bits
8 bits + 2 bits
8 bits + 2 bits
32 bits + 8 bits = 40 bits

En cambio 4 enteros son 64 bits.
Ahorro 24 bits o sea 3 bytes lo que no es poca cosa

Quiere decir que en condiciones normales 8192 datos enteros x 16 bits = 131072 bits o div 8 = 16384 bytes
8192 datos x 10 bits = 81920 bits que ocuparían 10240 bytes
Una mejora de 16384-10240 = 6144 bytes
Simplemente ocupando los bits de forma ordenada.

Este simple programa ilustra la idea

typedef struct a40_bits_t {
  uint16_t  adc0:10;
  uint16_t  adc1:10;
  uint16_t  adc2:10;
  uint16_t  adc3:10;
} ;
unsigned int adcdata[4];

a40_bits_t tn;

void setup() {
  Serial.begin(115200);
  adcdata[0] = tn.adc0 =  512;
  adcdata[1] = tn.adc1 = 1015;
  adcdata[2] = tn.adc2 =  257;
  adcdata[3] = tn.adc3 =  955;
  for (byte i=0; i<4; i++) {
     Serial.println("Adc["+String(i)+"]:"+String(adcdata[i]));
  }
  Serial.println("Bytes consumidos con enteros:"+String(sizeof(adcdata[0])*4));
  Serial.println();
  Serial.print(F("tn.adc0 = "));
  Serial.println(tn.adc0);
  Serial.print(F("tn.adc1 = "));
  Serial.println(tn.adc1);
  Serial.print(F("tn.adc2 = "));
  Serial.println(tn.adc2);
  Serial.print(F("tn.adc3 = "));
  Serial.println(tn.adc3);
  Serial.println("Bytes consumidos:"+String(sizeof(tn)));

}
void loop() {}

Estimados, bueno primero disculparme por plantear mal el problema, la verdad que tema se desvió mucho por no haberlo planteado bien desde el principio, la idea principal era saber su por sus experiencias cual era limite que tenia la ram de arduino due al momento de realizar un arreglo dado que tenemos dos bancos de memoria, como menciona IgnoranteAbsoluto es saber si las memorias son direccionales consecutivamente.

Respecto al problema que planteo después ya había estimado como usar los byte, de hecho funciona bien hasta cierto punto, pero quería ver si es que se le puede exigir aun más. Muchas gracias por sus comentarios son muy valiosos.

Por esto estaba probando algunas rutinas muy básicas de arreglos y ver la capacidad de la ram al parecer luego de superar serca del 75% de la memoria comienzan los problemas, dado que llevado limite de una matriz de 7761 cadenas compila pero no opera. bueno al disminuir hasta 2330 la operación es excelente (este es un caso donde se ocupan todos los espacios disponible por defecto) y bueno la clave de todo para mejorar el rendimiento es ordenar bien los byte dependiendo del uso que se les quiera dar. Ahora tampoco soy un experto de arduino quizá ustedes podrían entregar algún mejor resultado con algunas rutinas de prueba. muchas gracias por su dedicación y ayuda de la comunidad electrónica.

Acabo de darme cuenta de algo… es un DUE no un Arduino común, de modo que el ADC no es de 10 bits sino de 12 bits. Asi que habrá que corregir mi estructura.
No serán 6 bits de ahorro por cada 2 bytes sino solo 4 bits.

typedef struct a36_bits_t {
  uint16_t  adc0:12;
  uint16_t  adc1:12;
  uint16_t  adc2:12;
} ;

unsigned int adcdata[3];

a36_bits_t tn;

void setup() {
  Serial.begin(115200);
  adcdata[0] = tn.adc0 = 3512;
  adcdata[1] = tn.adc1 = 2015;
  adcdata[2] = tn.adc2 =  257;

  for (byte i=0; i<3; i++) {
     Serial.println("Adc["+String(i)+"]:"+String(adcdata[i]));
  }

  Serial.println("Bytes consumidos con enteros:"+String(sizeof(adcdata[0])*3));
  Serial.println();
  Serial.print(F("tn.adc0 = "));
  Serial.println(tn.adc0);
  Serial.print(F("tn.adc1 = "));
  Serial.println(tn.adc1);
  Serial.print(F("tn.adc2 = "));
  Serial.println(tn.adc2);
  Serial.println("Bytes consumidos:"+String(sizeof(tn)));

}
void loop() {}

Repito esto es un primer intento que muestra como ahorras espacio, pero operar con esto conlleva algunos problemas ya que serán 3 elementos por dato indexado si lo transformaras en un vector.