Arduino memoria insufficiente: risolvere Sketch too big e RAM
Arduino con memoria insufficiente? Flash, SRAM ed EEPROM, F() e PROGMEM, array char al posto di String, misurare la RAM libera e quando passare al Mega o ESP32.
L'avviso di memoria insufficiente su Arduino indica che il programma o le variabili non entrano nella memoria della scheda, e di solito si presenta in due modi: il codice non viene caricato perché la compilazione si ferma con Sketch too big, oppure viene caricato dopo l'avviso Low memory available, stability problems may occur e poi la scheda si riavvia a caso, scrive caratteri senza senso nel Monitor seriale o si blocca. Poiché l'Arduino Uno ha solo 32 KB di memoria programma e 2 KB di RAM, il problema è molto frequente nei progetti che uniscono un display, una scheda SD e qualche sensore.
In questa guida vedrai prima la differenza tra Flash, SRAM ed EEPROM e come leggere le due righe alla fine di una compilazione. Poi, con valori misurati compilando davvero per un Uno, imparerai quale riga consuma quanta memoria, come togliere i dati costanti dalla RAM con la macro F() e PROGMEM, perché usare array char invece di String, quanto costano le librerie senza che te ne accorga e come misurare la RAM libera durante l'esecuzione. Nell'ultima parte troverai come controllare la memoria su ESP32 e Raspberry Pi Pico e quando passare a un Mega o a un ESP32 è la scelta giusta.

Le tre memorie di Arduino: Flash, SRAM ed EEPROM
Nel microcontrollore di un Arduino ci sono tre memorie con compiti completamente diversi. La Flash (memoria programma) contiene il codice compilato; non si cancella senza alimentazione e viene scritta solo durante il caricamento. La SRAM (memoria di lavoro) ospita variabili, chiamate di funzione e dati temporanei; è veloce ma si svuota quando la scheda si spegne. L'EEPROM è una piccola area per dati da conservare che cambiano di rado, come impostazioni e valori di calibrazione. Sulle schede AVR come l'Uno queste tre memorie stanno in spazi di indirizzamento separati (architettura Harvard). Questo dettaglio spiega perché servono le tecniche F() e PROGMEM che vedrai più avanti.
| Memoria | Dimensione sull'Uno | Cosa contiene? | Senza alimentazione | Cicli di scrittura |
|---|---|---|---|---|
| Flash | 32 KB (0,5 KB per il bootloader, 32256 byte utilizzabili) | Codice del programma, dati PROGMEM | Conservata | Circa 10.000 cicli di cancellazione/scrittura |
| SRAM | 2 KB (2048 byte) | Variabili, array, stack e heap | Persa | Illimitati |
| EEPROM | 1 KB (1024 byte) | Impostazioni, contatori, calibrazione | Conservata | Circa 100.000 scritture per cella |
Usare l'EEPROM al posto della RAM non è una soluzione: è lenta e ogni cella sopporta un numero limitato di scritture. Se scrivi nell'EEPROM a ogni ciclo una variabile che cambia spesso, puoi consumare quella cella in pochi giorni. Il modo corretto di usarla è spiegato nell'articolo come usare l'EEPROM di Arduino.
Quantità di memoria per scheda
| Scheda | Flash (programma) | SRAM | EEPROM |
|---|---|---|---|
| Arduino Uno R3 / Nano (ATmega328P) | 32 KB (Uno 32256, Nano 30720 byte utilizzabili) | 2 KB | 1 KB |
| Arduino Leonardo / Pro Micro (ATmega32U4) | 32 KB (28672 byte utilizzabili) | 2,5 KB | 1 KB |
| Arduino Mega 2560 | 256 KB (253952 byte utilizzabili) | 8 KB | 4 KB |
| Arduino Uno R4 (RA4M1) | 256 KB | 32 KB | 8 KB (flash dati) |
| ESP32 (WROOM) | Chip flash da 4 MB (partizione applicazione predefinita 1,25 MB) | 520 KB (al programma restano circa 300 KB di heap) | Nessuna; Preferences salva in flash |
| Raspberry Pi Pico (RP2040) | Chip flash da 2 MB | 264 KB | Nessuna; emulata in flash |
La differenza è enorme: l'ESP32 ha 260 volte la RAM dell'Uno e il Pico circa 130 volte. Per questo i risparmi di memoria che sull'Uno richiedono fatica sono spesso inutili sull'ESP32. Eppure Uno, Nano e Pro Mini restano le schede più usate grazie al prezzo basso e alla semplicità, quindi imparare a convivere con 2 KB serve a ogni utente Arduino.
Leggere l'output di compilazione: Sketch uses e Global variables use
Alla fine di ogni compilazione riuscita l'Arduino IDE scrive due righe. Compilando per l'Uno uno sketch con setup() e loop() vuoti vedrai Sketch uses 444 bytes (1%) of program storage space e Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. La prima riga indica lo spazio occupato dal programma in flash, la seconda la RAM usata dalle variabili globali e statiche. Il punto chiave è che la seconda riga conta solo le variabili la cui dimensione è nota in compilazione. Le variabili locali delle funzioni (stack) e la memoria allocata durante l'esecuzione con String o malloc (heap) non sono incluse. Lo spazio rimanente "local variables" è quello che devono dividersi.
| Messaggio | Quando compare? | Cosa significa? |
|---|---|---|
| Sketch uses ... bytes (x%) of program storage space | A ogni compilazione | Spazio occupato dal codice in flash |
| Global variables use ... bytes (x%) of dynamic memory | A ogni compilazione | Quota di RAM delle variabili globali e statiche |
| Low memory available, stability problems may occur. | Quando le variabili globali superano circa il 75% della RAM | Il codice si carica ma resta poco spazio per stack e heap |
| Sketch too big e text section exceeds available space in board | Quando il programma non entra in flash | Caricamento impossibile; bisogna ridurre la flash usata |
| Not enough memory e data section exceeds available space in board | Quando le variabili globali superano la RAM | Caricamento impossibile; bisogna ridurre la RAM usata |
Dentro la SRAM: variabili globali, heap e stack
I 2048 byte di RAM dell'Uno sono divisi in quattro zone. In basso ci sono le variabili globali con valore iniziale (.data), sopra quelle che partono da zero (.bss); il compilatore mostra la somma delle due nella riga "Global variables use". Poi viene l'heap, che cresce verso l'alto: qui vivono gli oggetti String e la memoria allocata con new e malloc. Dalla cima della RAM cresce verso il basso lo stack: ogni chiamata di funzione vi deposita l'indirizzo di ritorno e le variabili locali, e quando arriva un interrupt vi vengono salvati i registri. Se heap e stack si incontrano nello spazio libero tra loro, si sovrascrivono a vicenda e il programma si comporta in modo imprevedibile.
| Zona | Contenuto | Direzione di crescita | Visibile nell'output di compilazione? |
|---|---|---|---|
| .data | Variabili globali e statiche inizializzate, testi senza F() | Fissa | Sì |
| .bss | Variabili globali e statiche non inizializzate (zero), buffer delle librerie | Fissa | Sì |
| Heap | String, new, malloc, buffer che alcune librerie allocano in begin() | Verso l'alto | No |
| Stack | Variabili locali, indirizzi di ritorno, registri salvati durante gli interrupt | Verso il basso | No |
Questa struttura ha due conseguenze importanti. Primo: ogni testo non racchiuso in F() viene copiato in .data, perché il processore AVR non può leggere i dati in flash come una variabile normale. Secondo: l'heap si frammenta; creando e cancellando String di dimensioni diverse restano piccoli buchi e, anche se la memoria libera totale sembra sufficiente, non si riesce più ad allocare un blocco grande. Per questo, nei programmi che girano a lungo su un Uno, la scelta più sicura è toccare l'heap il meno possibile.
Prima misura: quanta memoria costa ogni riga?
Il primo passo per risolvere un problema di memoria è misurare, non indovinare. Ogni riga della tabella seguente è l'output reale di un piccolo sketch compilato separatamente per Arduino Uno con il core Arduino AVR 1.8.6. I valori possono cambiare di qualche byte con le versioni di librerie e core, ma le proporzioni restano sempre le stesse.
| Cosa c'è nello sketch? | Flash (byte) | RAM globale (byte) |
|---|---|---|
| setup() e loop() vuoti | 444 | 9 |
| Serial.begin(9600) | 1438 | 184 |
| + Serial.println("un testo di 44 caratteri") | 1518 | 232 |
| Lo stesso testo con F() | 1530 | 188 |
| analogRead + Serial.println(int) | 1892 | 188 |
| Calcolo float + Serial.println(float) | 3380 | 200 |
| Concatenazione String: "A0=" + String(analogRead(A0)) | 3316 | 202 |
| La stessa cosa con snprintf e un array char | 3232 | 194 |
| Una sola scrittura con Wire (I2C) | 2476 | 225 |
| Scheda SD: begin, open, println, close | 10496 | 837 |
| Array int veri[700] | 1780 | 1588 (77%, avviso Low memory) |
| Array int veri[950] | 1780 | 2088 (101%, non compila) |
Le lezioni sono chiare. Il solo Serial.begin() chiede 175 byte di RAM, perché la porta seriale riserva un buffer di ricezione da 64 byte e uno di trasmissione da 64 byte. Un unico testo di 44 caratteri costa 44 byte di RAM; scritto con F(), quella RAM torna libera. Usare float aggiunge alla flash circa 1,5 KB di codice in virgola mobile. La libreria SD da sola consuma 10 KB di flash e circa 830 byte di RAM: il 40% della RAM dell'Uno se ne va per un semplice file di log. La RAM globale dell'esempio con String sembra piccola, ma il suo costo reale compare nell'heap durante l'esecuzione e non si vede mai nell'output di compilazione.
La macro F(): togliere i testi costanti dalla RAM
Sull'Uno ogni testo tra virgolette come "Temperatura: " si trova in flash, ma all'avvio del programma viene copiato in RAM e lì occupa spazio per sempre. La macro F() impedisce questa copia: il testo resta in flash e funzioni come Serial.print lo leggono carattere per carattere direttamente dalla flash. F() funziona con ogni oggetto derivato dalla classe Print, tra cui Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 e i file SD. In un progetto con menu, messaggi di errore e testi di aiuto, aggiungere F() può far recuperare qualche centinaio di byte di RAM. Il codice seguente mostra la differenza e misura la RAM libera durante l'esecuzione:
1// Boş RAM'i ölçmek ve F() ile RAM kazanmak (Uno, Nano, Mega)
2// Measure free RAM and save RAM with F() (Uno, Nano, Mega)
3extern int __heap_start, *__brkval; // avr-libc heap sınırları / avr-libc heap limits
4
5int bosRam() {
6 int yerel; // stack'in o anki tepesi / current top of the stack
7 return (int)&yerel - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
8}
9
10void setup() {
11 Serial.begin(9600);
12 Serial.println("Bu metin RAM'e kopyalanir"); // RAM'de 26 bayt / 26 bytes of RAM
13 Serial.println(F("Bu metin flasta kalir")); // RAM'de 0 bayt / 0 bytes of RAM
14 Serial.print(F("Bos RAM / Free RAM: "));
15 Serial.println(bosRam());
16}
17
18void loop() {
19}La funzione bosRam() calcola la distanza tra la cima attuale dello stack e la fine dell'heap, cioè quanti byte restano prima che si incontrino. Se la chiami nel loop() subito dopo un aggiornamento del display o una scrittura su SD, cogli il momento peggiore. Una regola pratica: sull'Uno non lasciare che la RAM libera scenda sotto i 200–300 byte durante l'esecuzione. F() non funziona con le funzioni che si aspettano un char* (strcmp, strcpy); per queste usi le versioni _P e la macro PSTR() che vedrai più avanti.
PROGMEM: tenere le tabelle grandi in flash
F() serve solo per i testi. Per array grandi che non cambiano mai, come sequenze di note, icone del display (bitmap), tabelle di caratteri, curve di calibrazione o elenchi di messaggi, si usa la parola chiave PROGMEM. Un array dichiarato con PROGMEM non viene mai copiato in RAM; per leggerlo servono funzioni speciali come pgm_read_byte e pgm_read_word al posto del normale accesso. Una melodia di 100 note con tabelle di frequenza e durata occupa per esempio 400 byte; è un quinto della RAM dell'Uno, e PROGMEM la sposta tutta in flash.
1// Mesaj listesi ve nota tablosu flaşta (PROGMEM)
2// Message list and note table kept in flash (PROGMEM)
3const char m0[] PROGMEM = "Sistem hazir";
4const char m1[] PROGMEM = "Sensor hatasi";
5const char m2[] PROGMEM = "Kapi acik";
6const char* const mesajlar[] PROGMEM = { m0, m1, m2 }; // işaretçi tablosu da flaşta / pointer table in flash too
7
8const uint16_t notalar[] PROGMEM = { 262, 294, 330, 349, 392, 440, 494, 523 }; // Do-Re-Mi ... Do (Hz)
9const byte BUZZER_PIN = 8;
10
11void setup() {
12 Serial.begin(9600);
13 char tampon[20]; // RAM'de tek ortak tampon / one shared RAM buffer
14 for (byte i = 0; i < 3; i++) {
15 strcpy_P(tampon, (const char*)pgm_read_ptr(&mesajlar[i])); // flaştan RAM'e kopyala / copy flash -> RAM
16 Serial.println(tampon);
17 }
18 for (byte i = 0; i < 8; i++) {
19 uint16_t frekans = pgm_read_word(¬alar[i]); // 2 baytlık değeri oku / read a 2-byte value
20 tone(BUZZER_PIN, frekans, 200);
21 delay(250);
22 }
23}
24
25void loop() {
26}| Funzione / macro | Cosa fa? |
|---|---|
| pgm_read_byte(&array[i]) | Legge 1 byte dalla flash (array byte, char, uint8_t, bitmap) |
| pgm_read_word(&array[i]) | Legge 2 byte dalla flash (int, uint16_t; tabelle di note e numeri sull'Uno) |
| pgm_read_dword / pgm_read_float | Legge valori long e float da 4 byte |
| pgm_read_ptr(&tabella[i]) | Legge un puntatore memorizzato in flash (tabelle di testi) |
| strcpy_P(dest, sorgente) | Copia un testo dalla flash in un buffer in RAM |
| strcmp_P(testo_ram, PSTR("...")) | Confronta un testo in RAM con un testo in flash |
| strlen_P / memcpy_P | Restituisce la lunghezza di un testo in flash, copia un blocco dalla flash |
Usare array char invece di String
La classe String di Arduino è comoda, ma a ogni concatenazione (+) chiede all'heap un nuovo blocco e libera il vecchio. Ripetuto migliaia di volte nel piccolissimo heap dell'Uno, questo riempie la memoria di buchi. Il programma funziona bene per ore e poi all'improvviso si blocca, e il difetto è molto difficile da trovare. La soluzione sono gli array char di dimensione nota in anticipo: la memoria viene riservata una volta, non si frammenta mai e i byte usati compaiono nell'output di compilazione. Il codice seguente legge i comandi dal Monitor seriale senza String e formatta la misura in un'unica riga:
1// String yerine sabit boyutlu char dizileri / fixed-size char arrays instead of String
2char komut[16]; // gelen komut tamponu / incoming command buffer
3byte konum = 0; // tampondaki karakter sayısı / characters in the buffer
4
5void setup() {
6 Serial.begin(9600);
7 pinMode(13, OUTPUT);
8 Serial.println(F("Komutlar / Commands: LED ON, LED OFF, OLC"));
9}
10
11void olcumGonder() {
12 int ham = analogRead(A0);
13 float volt = ham * 5.0 / 1023.0; // Uno: 5 V, 10 bit
14 char vMetin[8];
15 dtostrf(volt, 4, 2, vMetin); // AVR'de snprintf %f desteklemez / AVR snprintf has no %f
16 char satir[40];
17 snprintf(satir, sizeof(satir), "A0=%d ham, %s V", ham, vMetin); // taşma olmaz / never overflows
18 Serial.println(satir);
19}
20
21void komutIsle(const char* k) {
22 if (strcmp_P(k, PSTR("LED ON")) == 0) digitalWrite(13, HIGH); // PSTR: metin flaşta / literal in flash
23 else if (strcmp_P(k, PSTR("LED OFF")) == 0) digitalWrite(13, LOW);
24 else if (strcmp_P(k, PSTR("OLC")) == 0) olcumGonder();
25 else Serial.println(F("Bilinmeyen komut / Unknown command"));
26}
27
28void loop() {
29 while (Serial.available()) {
30 char c = Serial.read();
31 if (c == '\n') { // satır bitti / line complete
32 komut[konum] = '\0';
33 komutIsle(komut);
34 konum = 0;
35 } else if (c != '\r' && konum < sizeof(komut) - 1) {
36 komut[konum++] = c; // taşmadan ekle / append without overflow
37 }
38 }
39}Nel codice ci sono tre dettagli da notare. snprintf conosce la dimensione del buffer e quindi non esce mai dall'array, anche se il testo è lungo; sprintf non offre questa protezione. Poiché la famiglia printf dell'AVR non supporta di default il formato %f, il valore float viene prima convertito in testo con dtostrf. Infine il limite del buffer dei comandi (konum < sizeof(komut) - 1) impedisce che una riga lunga sovrascriva un'altra parte della memoria. Se devi usare String (alcune librerie lo restituiscono), riserva almeno lo spazio in setup() con testo.reserve(64) e dichiara la String globale; così la frammentazione si riduce molto.
Il tipo di dato giusto e le variabili locali
| Tipo | Uno (AVR) | ESP32 / Pico | Intervallo di valori (Uno) |
|---|---|---|---|
| bool, char, byte | 1 byte | 1 byte | byte: 0–255 |
| int | 2 byte | 4 byte | da -32768 a 32767 |
| unsigned int, uint16_t | 2 byte | uint16_t 2, unsigned int 4 byte | 0–65535 |
| long, unsigned long | 4 byte | 4 byte | unsigned long: 0–4.294.967.295 |
| float | 4 byte | 4 byte | Circa 6–7 cifre significative |
| double | 4 byte (come float) | 8 byte | Sull'Uno nessuna differenza da float |
- byte per i numeri piccoli: usare byte invece di int per numeri di pin, contatori e percentuali tra 0 e 255 fa risparmiare 1 byte per variabile e 200 byte in un array di 200 elementi.
- const per i pin: il compilatore inserisce direttamente nel codice le costanti dichiarate come const byte LED_PIN = 13; e non riserva loro RAM.
- Stati acceso/spento nei bit: otto variabili bool occupano 8 byte; se salvi la stessa informazione nei bit di un byte con bitRead e bitWrite, basta 1 byte.
- Attenzione agli array locali grandi: un char buffer[300]; dichiarato dentro una funzione non compare nell'output di compilazione, ma occupa 300 byte di stack a ogni chiamata. Rendi globali i buffer grandi così la loro dimensione è visibile.
- Evita la ricorsione: ogni funzione che richiama se stessa apre un nuovo livello sullo stack; sull'Uno bastano poche decine di livelli per esaurire la RAM.
- Passa le strutture grandi per riferimento: passare uno struct per valore ne mette una copia sullo stack; passarlo per riferimento come const Impostazioni& i evita la copia.
Il costo nascosto delle librerie
Quando un progetto resta all'improvviso senza memoria, spesso il colpevole non è il tuo codice ma una libreria aggiunta. Alcune librerie riservano la RAM in compilazione (come buffer globale), altre la prendono dall'heap quando chiami begin(); nel secondo caso l'output di compilazione sembra innocuo, ma la memoria finisce quando la scheda è già in funzione. Una parte dei valori seguenti viene dalla tabella di misure precedente, un'altra dalle dimensioni dei buffer delle librerie:
| Libreria / funzione | Costo in RAM (Uno) | Quando viene allocata? | Alternativa più leggera |
|---|---|---|---|
| Serial | Circa 175 byte (buffer da 64 + 64 byte) | In compilazione (globale) | Togliere del tutto Serial se non serve |
| Wire (I2C) | Circa 215 byte | In compilazione (globale) | Inevitabile anche con un solo dispositivo I2C; risparmia altrove |
| SoftwareSerial | Circa 120 byte (buffer di ricezione da 64 byte) | In compilazione (globale) | La seriale hardware se possibile, o le porte extra del Mega |
| SD | Circa 830 byte, più circa 10 KB di flash | In compilazione (globale) | Lasciare il logging a un ESP32 o a un Mega |
| Adafruit SSD1306 128x64 | Buffer immagine da 1024 byte | Dall'heap dentro begin() | U8g2 in modalità pagina (128 byte) o U8x8 solo testo |
| Adafruit NeoPixel / FastLED | 3 byte per LED (60 LED = 180 byte) | All'avvio | Limitare il numero di LED alla lunghezza reale della striscia |
Questa tabella spiega perché usare insieme un display OLED, una scheda SD e un modulo Wi-Fi su un Uno è quasi impossibile: il solo buffer dell'SSD1306 più la libreria SD fanno 1,8 KB e dei 2 KB di RAM non resta quasi nulla per il programma. L'errore SSD1306 allocation failed dei display OLED è proprio il fallimento di questa allocazione nell'heap; trovi soluzioni anche nell'articolo display OLED SSD1306.
Sketch too big: come ridurre l'uso della flash
- Disattiva l'output di debug: le righe Serial.print aggiunte durante lo sviluppo costano flash e RAM. Con la macro DEBUG qui sotto le togli tutte dalla compilazione cambiando una sola riga.
- Evita float e sprintf: come mostrano le misure, float aggiunge circa 1,5 KB e snprintf oltre 1 KB di codice. Moltiplicare la temperatura per 10 e salvarla come int (235 invece di 23,5 °C) basta nella maggior parte dei progetti.
- Trasforma il codice ripetuto in funzioni e array: tenere i numeri dei pin in un array e gestirli con un ciclo, invece di scrivere un blocco di dieci righe per ogni LED, accorcia il codice in modo evidente.
- Scegli una libreria più piccola: se non servono grafici, U8x8 o LiquidCrystal_I2C occupano molto meno delle librerie basate su Adafruit GFX. Invece di includere un'intera libreria per una sola funzione, valuta di scrivere quella parte da solo.
- Controlla la scheda selezionata: l'Arduino IDE calcola il limite in base alla scheda scelta: 32256 byte per l'Uno, 30720 per il Nano (bootloader vecchio o nuovo) e 28672 per il Leonardo. Se la scheda è sbagliata, sono sbagliati sia il limite sia le definizioni dei pin.
- Passa a una scheda più grande: se dopo tutto questo ancora non entra, un Mega (256 KB) o un ESP32 (1,25 MB e oltre) eseguono lo stesso codice con piccole modifiche.
1// DEBUG makrosu: hata ayıklama çıktısını tek satırla aç/kapat
2// DEBUG macro: switch debug output on/off with one line
3#define DEBUG 1 // yayında 0 yap / set to 0 for release
4
5#if DEBUG
6 #define DBG(x) Serial.print(x)
7 #define DBGLN(x) Serial.println(x)
8#else
9 #define DBG(x)
10 #define DBGLN(x)
11#endif
12
13void setup() {
14#if DEBUG
15 Serial.begin(9600);
16#endif
17 pinMode(13, OUTPUT);
18 DBGLN(F("Basladi / Started"));
19}
20
21void loop() {
22 int deger = analogRead(A0);
23 digitalWrite(13, deger > 512 ? HIGH : LOW); // asıl iş / the real job
24 DBG(F("A0: "));
25 DBGLN(deger);
26 delay(500);
27}Con DEBUG 1 questo sketch usa sull'Uno 2292 byte di flash e 188 byte di RAM; con DEBUG 0 il codice di Serial sparisce del tutto dalla compilazione e i valori scendono a 934 byte di flash e 9 byte di RAM. Gli 1,3 KB di flash e 179 byte di RAM di differenza spesso bastano per aggiungere una nuova funzione a un progetto finito.
Misurare la memoria sull'ESP32
L'ESP32 ha molta memoria, ma non infinita. Attivando il Wi-Fi vengono riservate decine di KB di RAM, e con il Bluetooth si possono sfiorare i 100 KB; anche web server, documenti JSON e buffer di immagini riempiono in fretta la memoria. Alcuni moduli, come l'ESP32-CAM, hanno PSRAM aggiuntiva (di solito 4 MB) dove mettere i buffer grandi. Sul lato flash, se l'applicazione non entra nella partizione predefinita da 1,25 MB, puoi salire a 3 MB con l'opzione "Huge APP" dell'impostazione Partition Scheme nel menu Strumenti. Per le caratteristiche generali dell'ESP32 leggi Che cos'è l'ESP32?.
1// ESP32 bellek raporu / ESP32 memory report
2void setup() {
3 Serial.begin(115200);
4 delay(500);
5 Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
6 Serial.printf("En dusuk heap / Minimum free heap: %u bayt\n", ESP.getMinFreeHeap());
7 Serial.printf("En buyuk blok / Largest free block: %u bayt\n", ESP.getMaxAllocHeap());
8 Serial.printf("PSRAM: %u bayt\n", ESP.getPsramSize());
9 Serial.printf("Program / Sketch: %u, bos alan / free: %u bayt\n", ESP.getSketchSize(), ESP.getFreeSketchSpace());
10}
11
12void loop() {
13 // loop görevinin hiç kullanılmamış stack'i / never-used stack of the loop task
14 Serial.printf("loop stack bos / free: %u bayt\n", (unsigned)uxTaskGetStackHighWaterMark(NULL));
15 Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
16 delay(5000);
17}I due numeri più preziosi qui sono getMinFreeHeap e getMaxAllocHeap. Il primo indica il minimo di heap libero dall'avvio del programma, il secondo il blocco più grande allocabile in un solo pezzo. Se l'heap libero mostra 100 KB ma il blocco più grande è sotto i 10 KB, l'heap è frammentato e una String o un documento JSON grande potrebbero non essere allocabili. Sull'ESP32 il loop() gira in un proprio task con uno stack da 8 KB; uxTaskGetStackHighWaterMark mostra la parte di quello stack mai usata, e se scende sotto qualche centinaio di byte puoi incontrare l'errore "Stack canary watchpoint triggered".
La memoria su Raspberry Pi Pico e in MicroPython
I 264 KB di RAM del Pico sono enormi rispetto all'Uno, ma l'interprete MicroPython ne usa una parte; al tuo programma restano di solito circa 190 KB di heap. In MicroPython la memoria è gestita da un garbage collector: gli oggetti non più usati vengono eliminati quando chiami gc.collect() o quando la memoria sta per finire. Quando finisce davvero, compare MemoryError: memory allocation failed. Concatenare testi in un ciclo, creare liste grandi e avere un unico file di codice molto lungo sono le cause più comuni.
1import gc
2import micropython
3
4gc.collect() # önce çöpleri topla / collect garbage first
5print("Bos RAM / Free RAM:", gc.mem_free(), "bayt")
6print("Kullanilan / Used:", gc.mem_alloc(), "bayt")
7micropython.mem_info() # ayrıntılı rapor / detailed report
8
9# Kötü: her turda yeni metin nesnesi / bad: a new string object every loop
10# satir = ""
11# for i in range(100): satir += str(i) + ","
12
13# İyi: tek seferlik bytearray tamponu / good: one preallocated bytearray buffer
14tampon = bytearray(64)
15for i in range(10):
16 tampon[i] = 48 + i # ASCII '0'..'9'
17print(bytes(tampon[:10]))Per proteggere la memoria in MicroPython, alloca i buffer in anticipo con bytearray e riutilizzali nel ciclo, definisci i numeri costanti con const(), trasforma i moduli grandi in file .mpy precompilati con mpy-cross e chiama gc.collect() prima dei lavori lunghi. I comandi base di MicroPython sul Pico sono in basi di MicroPython, le caratteristiche generali della scheda in Che cos'è il Raspberry Pi Pico?.
Quando passare a un Mega o a un ESP32?

| Situazione | Consiglio |
|---|---|
| Dopo F(), PROGMEM e array char restano più di 300 byte di RAM libera | Resta sull'Uno; problema risolto |
| Più sensori e un menu con OLED o SD, e la RAM non basta ancora | Arduino Mega 2560: 4 volte la RAM, stessi pin a 5 V e stesse librerie |
| Il programma supera i 32 KB ma la RAM basta | Mega o Uno R4: 256 KB di flash |
| Servono Wi-Fi, web server, buffer grandi o elaborazione di immagini | ESP32: 520 KB di RAM, 4 MB di flash, Wi-Fi e Bluetooth |
| Vuoi lavorare con MicroPython | Raspberry Pi Pico o Pico W |
| Un piccolo nodo sensore che deve durare mesi a batteria | Ottimizza sull'Uno o usa un Pro Mini; una scheda più grande consuma di più |
Passando al Mega, gran parte del codice resta uguale; ricorda solo che l'I2C è sui pin 20 (SDA) e 21 (SCL) e l'SPI sui pin 50–53. Passando all'ESP32 ci sono differenze come il livello logico a 3,3 V, numeri di pin diversi e il risultato a 12 bit (0–4095) di analogRead. Per decidere quale scheda fa per te leggi il confronto Arduino o ESP32, e per un'opzione compatibile con i 5 V e con molta più memoria l'articolo Arduino Uno R4.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Sketch too big, il codice non si carica | Il programma non entra in flash | Disattiva il debug, riduci float e sprintf, usa librerie più piccole e, se serve, un Mega |
| Il codice si carica ma si blocca dopo qualche minuto | Le concatenazioni di String frammentano l'heap | Usa array char e snprintf invece di String; misura la RAM libera |
| Caratteri senza senso nel Monitor seriale, variabili che cambiano da sole | Lo stack sovrascrive l'heap | Porta la RAM globale sotto il 75%, elimina gli array locali grandi |
| SSD1306 allocation failed | begin() non riesce ad allocare il buffer da 1 KB | Metti i testi in F(), passa a U8g2 in modalità pagina |
| La scheda si riavvia a caso anche se la memoria sembra a posto | Più probabilmente un problema di alimentazione che di memoria | Alimenta motori e relè a parte, aggiungi un condensatore |
| Gli elementi di un array mostrano valori assurdi | Si scrive oltre i limiti dell'array | Controlla l'indice; calcola i limiti del ciclo con sizeof |
| Stack canary watchpoint triggered sull'ESP32 | Lo stack di un task è traboccato | Rendi globali gli array locali grandi o aumenta lo stack del task |
La memoria insufficiente su Arduino si risolve quasi sempre senza cambiare scheda: spostare i testi costanti in flash con F(), mettere le tabelle grandi in PROGMEM, usare array char invece di String ed eliminare le librerie superflue danno ai 2 KB di RAM un margine sorprendente. Nell'app BlueGrays puoi esplorare progetti che mettono alla prova la memoria, come giochi su OLED, melodie con il buzzer e animazioni su matrici LED, con schemi passo passo e codice scritto con queste tecniche.
Domande frequenti
Cosa significa Low memory available su Arduino?
Significa che le variabili globali occupano circa il 75% della RAM e resta poco spazio per stack e heap. Il codice si carica, ma durante l'esecuzione possono comparire riavvii casuali, blocchi e variabili corrotte. Mettere i testi costanti in F() e spostare gli array grandi in PROGMEM di solito fa sparire l'avviso.
Come si risolve l'errore Sketch too big?
Questo errore indica che il programma non entra nella memoria flash. Disattiva l'output Serial di debug, riduci float e sprintf, raccogli il codice ripetuto in funzioni e scegli librerie più piccole. Se ancora non basta, passa a una scheda con più flash come l'Arduino Mega o un ESP32.
Quanta memoria ha l'Arduino Uno?
L'ATmega328P dell'Arduino Uno ha 32 KB di flash (0,5 KB riservati al bootloader), 2 KB di SRAM e 1 KB di EEPROM. Il programma va in flash, le variabili in SRAM e le impostazioni permanenti in EEPROM. La maggior parte dei problemi nasce in quei 2 KB di SRAM.
A cosa serve la macro F()?
F() impedisce che i testi costanti passati a funzioni come Serial.print vengano copiati in RAM e li mantiene in flash. Sull'Uno ogni carattere fa risparmiare un byte di RAM, che diventano centinaia nei progetti con molti messaggi. Compila anche su ESP32 e Pico, ma lì non ha effetto.
Come si misura la RAM libera su Arduino?
Su Uno, Nano e Mega si usa una piccola funzione che calcola la distanza tra stack e heap con le variabili __heap_start e __brkval. Sull'ESP32 ESP.getFreeHeap() ed ESP.getMinFreeHeap() danno la stessa informazione, in MicroPython gc.mem_free(). È importante misurare nel momento di massimo uso della memoria.
Perché usare String su Arduino crea problemi?
Gli oggetti String chiedono nuova memoria all'heap a ogni concatenazione e liberano la vecchia, così il piccolo heap dell'Uno si frammenta col tempo. Anche se la memoria libera totale sembra sufficiente, non si riesce ad allocare un nuovo blocco e il programma si blocca. Gli array char a dimensione fissa e snprintf eliminano completamente il problema.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Inno nazionale turco con cicalino
Premi il pulsante e un piccolo buzzer comincia a suonare l'inno nazionale turco, nota dopo nota.

Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

Gioco delle Racchette - SSD1306
Una pallina, due racchette e tu: giochi a ping pong, uno dei primissimi videogiochi, su un piccolo display OLED.

OLED T-Rex Run: Gioco del dinosauro con Arduino
Il gioco del dinosauro che compare quando salta internet, ora sulla tua scrivania: il dinosauro corre sul piccolo display OLED, i cactus gli vengono incontro e tu salti con un solo pulsante.

Serpente di pixel Matrice 8x8
Costruisci con le tue mani il classico gioco del serpente e giocaci. Su una matrice di luci colorate 8x8 guidi un serpente verde con un joystick e mangi mele rosse; a ogni mela il serpente si…

Gioco di memoria con Arduino (4 LED + 4 pulsanti + buzzer)
Ti fidi della tua memoria? Quattro LED colorati si accendono in sequenza, ognuno con la sua nota, e tu ripeti lo stesso ordine premendo i pulsanti.

Serratura con password, tastierino 4x4 e LCD
Una piccola serratura elettronica che non fa entrare chi non conosce il codice. Premi il tasto cancelletto e digiti il codice sul tastierino; se è giusto, lo schermo indica accesso consentito, si…
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

