Leggere 800 valori di input

Cosa c’e’ che non va in questo banalissimo sketch, che mi fa bloccare la Arduino?!?

#include <VirtualWire.h>
int letti[800];
int indice;

void setup()
{
    Serial.begin(9600);
    pinMode(A2,INPUT);
    Serial.println("Leggo...");
    for (indice=0;indice<=799;indice++) {
      letti[indice]=-1;
    }
    for (indice=0;indice<=799;indice++) {
      letti[indice]=analogRead(A2);
    }

    Serial.println("Mostro lettura:");
    for (int i=0; i<799; i++) {
      Serial.print(letti[i]);
      Serial.print(", ");
    }
   Serial.println("Fatto.");
}

void loop()
{

}

Vorrei solo vedere una serie di letture di un pin, per vedere se si accende e si spegne secondo la sequenza che dico io, che gli arriva da un’altra arduino.
Come dovrei fare?

Dentro la funzione setup devi mettere codice che viene eseguito solo una volta dopo ogni reset.
In pratica è pensata per impostare i pin come I/O e altre impostazioni.

Mentre nella funzione loop metti tutto il codice.

Poi da quello che vedo A2 è una variabile che nel codice non è definita, ma può essere che lo è in VirtualWire, diversamente non dovrebbe neanche compilare.
Ciao

semplicemente non hai abbastanza ram??? dunque sizeof(int) è 2 byte... * 800 = 1600byte solo per l'array... il limite dell'atmega328 è 2kb.. uhmm 400 byte da qualche parte? oppure non trova 1600byte contigui(necessari per l'array)? prova con un array di 100 e poi aumenta di centinaia in centinaia :)

@MauroTec A2 é la terza entrata analogica; non é una variabile. @jumpjack Arduino 2009 o UNO? Sí, usi troppi variabili o nel Tuo caso un array troppo grande e percui troppa RAM e per questo si blocca o soprascrive delle parti essenziali della RAM. Ciao Uwe

Se non erro le entrate analogiche funzionano anche senza pinMode(A2, INPUT) ovvero senza dichiarazione in merito.

Io dichiaro solamente gli Output e Input da 0 a 13 .

sí e no; Le entrate analogiche come analogiche funzionano senza la dichiarazione di PinMode() se usi un pinMode() definisci l' entrata in digitale. In questo caso A2 non ha senso. Forse per questo gli funziona A2 come entrata analogica. Ciao Uwe

Se vuoi verificare la RAM libera man mano che allochi (o che comunque occupi) spazio puoi usare una funzione del genere:

int freeRam(){
  int byteCount;
  byte *byteVctTest;
  
  for(byteCount = 0; (byteVctTest = (byte *) malloc(byteCount * sizeof(byte))) != NULL; ++byteCount)
    free(byteVctTest);
    
  return byteCount;
}

La funzione ritorna il numero di byte liberi in RAM.

Se sei interessato al funzionamento della funzione: ad ogni iterazione del cilco for viene allocato un numero di byte pari al contatore "byteCount" (inizialmente 0) e incrementato quest'ultimo di una unità. Il ciclo termina quando malloc ritorna NULL che equivale a dire che non è stato possibile allocare lo spazio richiesto (ram piena). Di conseguenza, al termine del ciclo, "byteCount" conterrà il numero massimo di byte che è stato possibile allocare = quantità di ram libera in byte. Ovviamente ad ogni iterazione del ciclo, se il relativo numero di byte è stato allocato con successo, lo spazio allocato viene liberato.

Credo che la funzione possa essere considerata valida, senza dover fare differenze tra stack ed heap...

Pa°L° la tua funzione ritorna la ram massima contigua (ovvero il numero massimo di byte liberi uno di fila all’altro!! tutto dipende da come gestisce le malloc l’atmega)
se vuoi sapere la ram effettiva devi mallocare un byte per volta e non credo la cosa sia fattibile… un metodo “distruttivo” per farlo (che FORSE funziona) è:

int AREE_DI_MEMORIA_DA_LIBERARE_PER_SERIAL = 10;
int i=0, a=0;
int *areeXeseguireLaScanf[AREE_DI_MEMORIA_DA_LIBERARE_PER_SERIAL];
while (  (areeXeseguireLaScanf[i%AREE_DI_MEMORIA_DA_LIBERARE_PER_SERIAL]=malloc(byte)) != NULL )
 i++;
for (a=0; a<AREE_DI_MEMORIA_DA_LIBERARE_PER_SERIAL;a++)
    free(areeXeseguireLaScanf[a]);
i += sizeof(a)+sizeof(i)+sizeof(AREE_DI_MEMORIA_DA_LIBERARE_PER_SERIAL)+sizeof(*areeXeseguireLaScanf[0])*AREE_DI_MEMORIA_DA_LIBERARE_PER_SERIAL;
Serial.println(i); //i contine il numero di byte disponibili compresi quelli utilizzati da questa funzione

Ah chiedo scusa... non ci avevo pensato :D che scemo! Perché metodo "distruttivo"? Se porto OT chiedo scusa.

EDIT: ok... ho letto un po' di thread, nella sez. in inglese, dove si è parlato del calcolo della ram... ritiro tutto quello che ho scritto in questo thread ... così evito anche OT, sorry

giusto per completezza: è distruttivo perchè a parte le ultime AREE_DI_MEMORIA_DA_LIBERARE_PER_SERIAL aree di memoria (10 nell'esempio) le altre rimangono allocate e non se ne conosce l'indirizzo, quindi resteranno allocate (e inutilizzabili) fino al reset... insomma se usi questo codice conosci la ram che ERA disponibile, ma poi non puoi più usarla.

comunque ora che ci penso, a jumpjack serviva dello spazio contiguo per il suo array di 800 int, quindi è corretto testare con il codice di Pa°L°