ElectroYou

Salve a tutti.
Questo post non è di risoluzione di problemi, ma di chiarimento sul funzionamento di Arduino e nello specifico di come gestisce la memoria.

Ho uno sketch più o meno complesso che al sui interno utilizza variabili globali e locali.
In fase di compilazione mi da questo messaggio di informazione finale:

Lo sketch usa 42378 byte (16%) dello spazio disponibile per i programmi. Il massimo è 253952 byte.
Le variabili globali usano 6039 byte (73%) di memoria dinamica, lasciando altri 2153 byte liberi per le variabili locali. Il massimo è 8192 byte.

Riguardo alla gestione della memoria volevo chiedere questo:

- una variabile locale inserita in una funzione alloca uno spazio in memoria X per contenere il valore della stessa.
1) Al termine della funzione la parte d memoria che contiene la variabile in questione viene deallocata oppure resta li?
2) Ad una successiva chiamata della medesima funzione, la variabile riutilizza lo spazio di memoria precedentemente allocato oppure ne aggiunge una nuova allocazione?


Chiedo questo perché dal messaggio ho visto che mi rimane poca memoria libera per le variabili locali e se queste ogni volta che vengono utilizzate "sfruttano" sempre più memoria, arriverei dopo N iterazioni a saturare la memoria disponibile (sempre se la cosa funziona così). perché se no avevo pensato di dichiare alcune variabili locali come variabili Globali che teoricamente dovrebbero allocare uno spazio definito di memoria.

Grazie in anticipo a chi mi risponderà

La domanda che poni non è relativa solo ad Arduino, ma più in generale al funzionamento dei software, per cui sposterò il topic in una sezione più opportuna.
Detto questo, le variabili locali restano allocate solo finché lo "scope" che le contiene rimane attivo: in sostanza, le variabili locali di una funzione vengono allocate quando essa comincia ad essere eseguita e vengono de-allocate appena essa termina. Non c'è garanzia che una successiva chiamata della funzione ri-allochi le variabili esattamente nello stesso posto (e infatti di solito non avviene).

Le variabili locali vengono posizionate nello stack. Se invece, sempre localmente, sei tu a crearle tramite allocazione di memoria nell'heap, devi essere tu a liberare lo spazio.
Es :
void funzione(){
int var; //allocata automaticamente nello stack
char * buffer = malloc(size); // allocata nell'heap,
free(buffer); // bisogna liberare prima di usire
}

L'allocazione nell'heap tende a frammentare la memoria, con arduino fai attenzione.

Io se uno mi porta un software embedded con dentro una malloc giuro che gli stacco la testa.

lol :)
ma era solo per fargli capire dai :)

Scusate se rispondo solo ora.

Nel software che ho scritto non faccio nessuna allocazione/deallocazione diretta.
IN linea generale il modulo arduino è in ascolto sulla porta seriale di "messaggi" che poi inserisce in una variabile di tipo stringa e valutando il valore di questa stringa intraprende delle azioni. Poi ho altre variabili di tipo array di byte che hanno dimensione fissa e vengono solo aggiornati i valori all'interno.

Quindi in generale se per esempio nella mia stringa che contiene il messaggio ricevuto dalla seriale, vado ad inserire sempre messaggi della stessa lunghezza di caratteri, una volta allocata la memoria dovrebbe rimanere sempre quella. Se invece i messaggi hanno lunghezze variabili potrei avere il problema che con il tempo saturo la memoria disponibile?

rugweri ha scritto:Io se uno mi porta un software embedded con dentro una malloc giuro che gli stacco la testa.

Non solo, ma se qualcuno usa la classe String su arduino vuol dire "suicidarsi"...

infatti potrebbe esserci una frammentazione della memoria eccessiva.
La classe String permette di allocare prima memoria con la funzione reserve:

https://www.arduino.cc/reference/en/lan ... ingobject/
https://www.arduino.cc/reference/en/lan ... ns/reserve


Devi per forza farlo prima :)

Comunque è da evitare.

Secondo me dipende da cosa deve farci e quanta memoria ha disponibile.

Sicuramente non è la scelta migliore.