Arduino memoria insuficiente: soluciona Sketch too big y RAM
¿Arduino con memoria insuficiente? Flash, SRAM y EEPROM, F() y PROGMEM, arrays char en vez de String, medir la RAM libre y cuándo pasar a Mega o ESP32.
El aviso de memoria insuficiente en Arduino indica que tu programa o tus variables no caben en la memoria de la placa, y suele aparecer de dos formas: el código no llega a subirse porque la compilación se detiene con Sketch too big, o se sube tras el aviso Low memory available, stability problems may occur y después la placa se reinicia al azar, escribe caracteres sin sentido en el Monitor Serie o se cuelga. Como el Arduino Uno solo tiene 32 KB de memoria de programa y 2 KB de RAM, el problema es muy frecuente en proyectos que combinan una pantalla, una tarjeta SD y varios sensores.
En esta guía verás primero la diferencia entre Flash, SRAM y EEPROM y cómo leer las dos líneas del final de una compilación. Después, con valores que medimos compilando de verdad para un Uno, aprenderás qué línea consume cuánta memoria, cómo sacar datos constantes de la RAM con la macro F() y PROGMEM, por qué usar arrays char en lugar de String, cuánto cuestan las librerías sin que lo notes y cómo medir la RAM libre en tiempo de ejecución. En la última parte encontrarás cómo vigilar la memoria en el ESP32 y la Raspberry Pi Pico, y cuándo pasar a un Mega o a un ESP32 es la decisión correcta.

Las tres memorias de Arduino: Flash, SRAM y EEPROM
El microcontrolador de un Arduino tiene tres memorias con funciones totalmente distintas. La Flash (memoria de programa) guarda tu código compilado; no se borra al quitar la alimentación y solo se escribe al subir el código. La SRAM (memoria de trabajo) es donde viven las variables, las llamadas a funciones y los datos temporales; es rápida, pero se vacía al apagar la placa. La EEPROM es una pequeña zona para datos que deben conservarse pero cambian poco, como ajustes y valores de calibración. En placas AVR como el Uno estas tres memorias están en espacios de direcciones separados (arquitectura Harvard). Este detalle explica por qué hacen falta las técnicas F() y PROGMEM que verás más abajo.
| Memoria | Tamaño en el Uno | ¿Qué se guarda? | Al cortar la alimentación | Ciclos de escritura |
|---|---|---|---|---|
| Flash | 32 KB (0,5 KB para el bootloader, 32256 bytes utilizables) | Código del programa, datos PROGMEM | Se conserva | Unos 10.000 ciclos de borrado/escritura |
| SRAM | 2 KB (2048 bytes) | Variables, arrays, pila (stack) y montón (heap) | Se borra | Ilimitados |
| EEPROM | 1 KB (1024 bytes) | Ajustes, contadores, calibración | Se conserva | Unas 100.000 escrituras por celda |
Usar la EEPROM en lugar de la RAM no es una solución: es lenta y cada celda admite un número limitado de escrituras. Si escribes en la EEPROM una variable que cambia rápido en cada vuelta del bucle, puedes desgastar esa celda en pocos días. Encontrarás la forma correcta de usarla en el artículo cómo usar la EEPROM de Arduino.
Memoria según la placa
| Placa | Flash (programa) | SRAM | EEPROM |
|---|---|---|---|
| Arduino Uno R3 / Nano (ATmega328P) | 32 KB (Uno 32256, Nano 30720 bytes utilizables) | 2 KB | 1 KB |
| Arduino Leonardo / Pro Micro (ATmega32U4) | 32 KB (28672 bytes utilizables) | 2,5 KB | 1 KB |
| Arduino Mega 2560 | 256 KB (253952 bytes utilizables) | 8 KB | 4 KB |
| Arduino Uno R4 (RA4M1) | 256 KB | 32 KB | 8 KB (flash de datos) |
| ESP32 (WROOM) | Chip flash de 4 MB (partición de aplicación por defecto 1,25 MB) | 520 KB (quedan unos 300 KB de heap para el programa) | No tiene; Preferences guarda en la flash |
| Raspberry Pi Pico (RP2040) | Chip flash de 2 MB | 264 KB | No tiene; se emula en la flash |
La diferencia es enorme: el ESP32 tiene 260 veces la RAM del Uno y la Pico unas 130 veces. Por eso los ahorros de memoria que cuestan esfuerzo en un Uno suelen ser innecesarios en un ESP32. Aun así, el Uno, el Nano y el Pro Mini son las placas más usadas por su bajo precio y su sencillez, así que aprender a vivir con 2 KB le sirve a cualquier usuario de Arduino.
Leer la salida de compilación: Sketch uses y Global variables use
Al final de cada compilación correcta, el Arduino IDE escribe dos líneas. Si compilas para el Uno un sketch con setup() y loop() vacíos, verás Sketch uses 444 bytes (1%) of program storage space y Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. La primera línea indica el espacio que ocupa el programa en la flash; la segunda, la RAM que ocupan las variables globales y estáticas. Lo importante es que la segunda línea solo cuenta las variables cuyo tamaño se conoce al compilar. Las variables locales de las funciones (pila) y la memoria reservada en tiempo de ejecución con String o malloc (heap) no están incluidas. El espacio restante de "local variables" es lo que tienen que compartir.
| Mensaje | ¿Cuándo aparece? | ¿Qué significa? |
|---|---|---|
| Sketch uses ... bytes (x%) of program storage space | En cada compilación | Espacio que ocupa el código en la flash |
| Global variables use ... bytes (x%) of dynamic memory | En cada compilación | Parte de la RAM usada por variables globales y estáticas |
| Low memory available, stability problems may occur. | Cuando las variables globales superan cerca del 75 % de la RAM | El código se sube, pero queda poco sitio para la pila y el heap |
| Sketch too big y text section exceeds available space in board | Cuando el programa no cabe en la flash | No se puede subir; hay que reducir el uso de flash |
| Not enough memory y data section exceeds available space in board | Cuando las variables globales superan la RAM | No se puede subir; hay que reducir el uso de RAM |
Dentro de la SRAM: variables globales, heap y pila
Los 2048 bytes de RAM del Uno se dividen en cuatro zonas. Abajo del todo están las variables globales con valor inicial (.data) y encima las que empiezan en cero (.bss); el compilador muestra la suma de ambas en la línea "Global variables use". Después viene el heap, que crece hacia arriba: aquí viven los objetos String y la memoria reservada con new y malloc. Desde lo más alto de la RAM crece hacia abajo la pila (stack): cada llamada a función guarda allí su dirección de retorno y sus variables locales, y al llegar una interrupción se guardan allí los registros. Si el heap y la pila se encuentran en el hueco libre entre ambos, se sobrescriben y el programa se rompe de forma impredecible.
| Zona | Contenido | Sentido de crecimiento | ¿Aparece en la salida de compilación? |
|---|---|---|---|
| .data | Variables globales y estáticas inicializadas, textos sin F() | Fijo | Sí |
| .bss | Variables globales y estáticas sin inicializar (cero), búferes de librerías | Fijo | Sí |
| Heap | String, new, malloc, búferes que algunas librerías reservan en begin() | Hacia arriba | No |
| Pila (stack) | Variables locales, direcciones de retorno, registros guardados en interrupciones | Hacia abajo | No |
Esta estructura tiene dos consecuencias importantes. Primera: todo texto que no va dentro de F() se copia a .data, porque el procesador AVR no puede leer datos de la flash como una variable normal. Segunda: el heap se fragmenta; al crear y borrar Strings de distintos tamaños quedan pequeños huecos y, aunque la memoria libre total parezca suficiente, no se puede reservar un bloque grande. Por eso, en programas que funcionan mucho tiempo en un Uno, lo más seguro es tocar el heap lo menos posible.
Primero mide: ¿cuánta memoria gasta cada línea?
El primer paso para resolver un problema de memoria es medir, no adivinar. Cada fila de la tabla es la salida real de un pequeño sketch compilado por separado para Arduino Uno con el núcleo Arduino AVR 1.8.6. Los valores pueden variar unos bytes según las versiones de librería y núcleo, pero las proporciones se mantienen siempre.
| ¿Qué contiene el sketch? | Flash (bytes) | RAM global (bytes) |
|---|---|---|
| setup() y loop() vacíos | 444 | 9 |
| Serial.begin(9600) | 1438 | 184 |
| + Serial.println("un texto de 44 caracteres") | 1518 | 232 |
| El mismo texto con F() | 1530 | 188 |
| analogRead + Serial.println(int) | 1892 | 188 |
| Cálculo float + Serial.println(float) | 3380 | 200 |
| Concatenación String: "A0=" + String(analogRead(A0)) | 3316 | 202 |
| Lo mismo con snprintf y un array char | 3232 | 194 |
| Una sola escritura con Wire (I2C) | 2476 | 225 |
| Tarjeta SD: begin, open, println, close | 10496 | 837 |
| Array int veri[700] | 1780 | 1588 (77 %, aviso Low memory) |
| Array int veri[950] | 1780 | 2088 (101 %, no compila) |
Las lecciones son claras. Solo Serial.begin() pide 175 bytes de RAM, porque el puerto serie reserva un búfer de recepción de 64 bytes y otro de envío de 64 bytes. Un único texto de 44 caracteres cuesta 44 bytes de RAM; escrito con F(), esa RAM vuelve. Usar float añade a la flash cerca de 1,5 KB de código de coma flotante. La librería SD consume por sí sola 10 KB de flash y unos 830 bytes de RAM: el 40 % de la RAM del Uno se va en un simple archivo de registro. La RAM global del ejemplo con String parece pequeña, pero su coste real aparece en el heap durante la ejecución y nunca se ve en la salida de compilación.
La macro F(): saca los textos constantes de la RAM
En el Uno, cualquier texto entre comillas como "Temperatura: " está en la flash, pero al arrancar el programa se copia a la RAM y ocupa espacio allí para siempre. La macro F() evita esa copia: el texto se queda en la flash y funciones como Serial.print lo leen carácter a carácter directamente de ella. F() funciona con cualquier objeto derivado de la clase Print, como Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 y los archivos SD. En un proyecto con menús, mensajes de error y textos de ayuda, añadir F() puede recuperar unos cientos de bytes de RAM. El código siguiente muestra la diferencia y mide la RAM libre en tiempo de ejecución:
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 función bosRam() calcula la distancia entre la cima actual de la pila y el final del heap, es decir, cuántos bytes quedan antes de que se encuentren. Si la llamas dentro de loop() justo después de actualizar la pantalla o escribir en la SD, capturarás el peor momento. Una regla práctica: en el Uno no dejes que la RAM libre baje de 200–300 bytes durante la ejecución. F() no funciona con funciones que esperan un char* (strcmp, strcpy); para ellas usas las versiones _P y la macro PSTR() que verás más abajo.
PROGMEM: guardar tablas grandes en la flash
F() es solo para textos. Para arrays grandes que nunca cambian, como secuencias de notas, iconos de pantalla (bitmaps), tablas de caracteres, curvas de calibración o listas de mensajes, se usa la palabra clave PROGMEM. Un array declarado con PROGMEM nunca se copia a la RAM; para leerlo necesitas funciones especiales como pgm_read_byte y pgm_read_word en lugar del acceso normal. Una melodía de 100 notas con tablas de frecuencia y duración ocupa, por ejemplo, 400 bytes; es la quinta parte de la RAM del Uno, y PROGMEM la lleva entera a la 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}| Función / macro | ¿Qué hace? |
|---|---|
| pgm_read_byte(&array[i]) | Lee 1 byte de la flash (arrays byte, char, uint8_t, bitmaps) |
| pgm_read_word(&array[i]) | Lee 2 bytes de la flash (int, uint16_t; tablas de notas y números en el Uno) |
| pgm_read_dword / pgm_read_float | Lee valores long y float de 4 bytes |
| pgm_read_ptr(&tabla[i]) | Lee un puntero guardado en la flash (tablas de textos) |
| strcpy_P(destino, origen) | Copia un texto de la flash a un búfer en RAM |
| strcmp_P(texto_ram, PSTR("...")) | Compara un texto en RAM con uno en la flash |
| strlen_P / memcpy_P | Obtiene la longitud de un texto en flash, copia un bloque desde la flash |
Usa arrays char en lugar de String
La clase String de Arduino es cómoda, pero en cada concatenación (+) pide al heap un bloque nuevo y libera el anterior. Repetido miles de veces en el diminuto heap del Uno, la memoria queda llena de agujeros. El programa funciona bien durante horas y de pronto se cuelga, y el fallo es muy difícil de encontrar. La solución son los arrays char de tamaño conocido de antemano: la memoria se reserva una vez, nunca se fragmenta y los bytes usados aparecen en la salida de compilación. El código siguiente lee órdenes del Monitor Serie sin String y formatea la medida en una sola línea:
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}Hay tres detalles en el código que merecen atención. snprintf conoce el tamaño del búfer, así que nunca se sale del array aunque el texto sea largo; sprintf no da esa protección. Como la familia printf de AVR no admite por defecto el formato %f, el valor float se convierte primero en texto con dtostrf. Y el límite del búfer de órdenes (konum < sizeof(komut) - 1) impide que una línea larga pise otra parte de la memoria. Si tienes que usar String (algunas librerías lo devuelven), reserva al menos el espacio en setup() con texto.reserve(64) y declara el String global; así la fragmentación se reduce mucho.
El tipo de dato correcto y las variables locales
| Tipo | Uno (AVR) | ESP32 / Pico | Rango de valores (Uno) |
|---|---|---|---|
| bool, char, byte | 1 byte | 1 byte | byte: 0–255 |
| int | 2 bytes | 4 bytes | -32768 a 32767 |
| unsigned int, uint16_t | 2 bytes | uint16_t 2, unsigned int 4 bytes | 0–65535 |
| long, unsigned long | 4 bytes | 4 bytes | unsigned long: 0–4.294.967.295 |
| float | 4 bytes | 4 bytes | Unas 6–7 cifras significativas |
| double | 4 bytes (igual que float) | 8 bytes | En el Uno no se diferencia de float |
- byte para números pequeños: Usar byte en vez de int para números de pin, contadores y porcentajes entre 0 y 255 ahorra 1 byte por variable y 200 bytes en un array de 200 elementos.
- const para los pines: El compilador incrusta directamente en el código las constantes declaradas como const byte LED_PIN = 13; y no les reserva RAM.
- Estados encendido/apagado en bits: Ocho variables bool ocupan 8 bytes; si guardas la misma información en los bits de un byte con bitRead y bitWrite, basta con 1 byte.
- Cuidado con los arrays locales grandes: Un char bufer[300]; declarado dentro de una función no aparece en la salida de compilación, pero toma 300 bytes de pila cada vez que se llama a la función. Haz globales los búferes grandes para que su tamaño se vea.
- Evita la recursión: Cada función que se llama a sí misma abre un nuevo nivel en la pila; en el Uno, unas pocas decenas de niveles pueden agotar la RAM.
- Pasa estructuras grandes por referencia: Pasar un struct por valor pone una copia en la pila; pasarlo por referencia como const Ajustes& a no lo copia.
El coste oculto de las librerías
Cuando un proyecto se queda de repente sin memoria, a menudo el culpable no es tu código sino una librería que has añadido. Algunas reservan la RAM al compilar (como búfer global) y otras la toman del heap al llamar a begin(); en el segundo caso la salida de compilación parece inocente, pero la memoria se agota cuando la placa ya está funcionando. Parte de los valores siguientes viene de la tabla de mediciones anterior y parte de los tamaños de búfer de las librerías:
| Librería / función | Coste de RAM (Uno) | ¿Cuándo se reserva? | Opción más ligera |
|---|---|---|---|
| Serial | Unos 175 bytes (búferes de 64 + 64 bytes) | Al compilar (global) | Quitar Serial por completo si no hace falta |
| Wire (I2C) | Unos 215 bytes | Al compilar (global) | Inevitable incluso con un solo dispositivo I2C; ahorra en otra parte |
| SoftwareSerial | Unos 120 bytes (búfer de recepción de 64 bytes) | Al compilar (global) | El puerto serie por hardware si es posible, o los puertos extra del Mega |
| SD | Unos 830 bytes, más unos 10 KB de flash | Al compilar (global) | Dejar el registro de datos a un ESP32 o a un Mega |
| Adafruit SSD1306 128x64 | Búfer de imagen de 1024 bytes | Desde el heap en begin() | U8g2 en modo página (128 bytes) o U8x8 solo para texto |
| Adafruit NeoPixel / FastLED | 3 bytes por LED (60 LED = 180 bytes) | Al arrancar | Limitar el número de LED a la longitud real de la tira |
Esta tabla explica por qué usar a la vez una pantalla OLED, una tarjeta SD y un módulo Wi-Fi en un Uno es casi imposible: solo el búfer del SSD1306 y la librería SD suman 1,8 KB y no dejan prácticamente nada de los 2 KB de RAM para tu programa. El error SSD1306 allocation failed de las pantallas OLED es exactamente ese fallo al reservar en el heap; también encontrarás soluciones en el artículo pantalla OLED SSD1306.
Sketch too big: formas de reducir el uso de flash
- Desactiva la salida de depuración: Las líneas Serial.print añadidas durante el desarrollo cuestan flash y RAM. Con la macro DEBUG de abajo puedes quitarlas todas de la compilación cambiando una sola línea.
- Evita float y sprintf: Como muestran las mediciones, float añade cerca de 1,5 KB y snprintf más de 1 KB de código. Multiplicar la temperatura por 10 y guardarla como int (235 en vez de 23,5 °C) basta en la mayoría de proyectos.
- Convierte el código repetido en funciones y arrays: Guardar los números de pin en un array y recorrerlos con un bucle, en lugar de escribir un bloque de diez líneas para cada LED, acorta el código de forma notable.
- Elige una librería más pequeña: Si no necesitas gráficos, U8x8 o LiquidCrystal_I2C ocupan mucho menos que las librerías basadas en Adafruit GFX. En vez de añadir una librería entera por una sola función, plantéate escribir esa parte tú mismo.
- Comprueba la placa seleccionada: El Arduino IDE calcula el límite según la placa elegida: 32256 bytes para el Uno, 30720 para el Nano (bootloader antiguo o nuevo) y 28672 para el Leonardo. Si la placa es incorrecta, el límite y las definiciones de pines también lo son.
- Pasa a una placa mayor: Si después de todo esto sigue sin caber, un Mega (256 KB) o un ESP32 (1,25 MB o más) ejecutan el mismo código con pequeños cambios.
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 este sketch usa en el Uno 2292 bytes de flash y 188 bytes de RAM; con DEBUG 0 el código de Serial desaparece por completo de la compilación y las cifras bajan a 934 bytes de flash y 9 bytes de RAM. Los 1,3 KB de flash y 179 bytes de RAM de diferencia suelen bastar para añadir una función nueva a un proyecto terminado.
Medir la memoria en el ESP32
El ESP32 tiene mucha memoria, pero no ilimitada. Al activar la Wi-Fi se reservan decenas de KB de RAM, y con el Bluetooth la cifra puede acercarse a 100 KB; los servidores web, los documentos JSON y los búferes de imagen también la llenan rápido. Algunos módulos, como el ESP32-CAM, llevan PSRAM adicional (normalmente 4 MB) donde van los búferes grandes. En la parte de la flash, si tu aplicación no cabe en la partición por defecto de 1,25 MB, puedes subir a 3 MB con la opción "Huge APP" del ajuste Partition Scheme del menú Herramientas. Para las características generales del ESP32 consulta ¿Qué es el 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}Los dos números más valiosos aquí son getMinFreeHeap y getMaxAllocHeap. El primero da el heap libre más bajo desde que arrancó el programa; el segundo, el bloque más grande que se puede reservar de una vez. Si el heap libre marca 100 KB pero el bloque más grande está por debajo de 10 KB, el heap está fragmentado y quizá no puedas reservar un String o un documento JSON grande. En el ESP32, loop() se ejecuta en su propia tarea con una pila de 8 KB; uxTaskGetStackHighWaterMark muestra la parte de esa pila que nunca se ha usado, y si baja de unos cientos de bytes puedes encontrarte el error "Stack canary watchpoint triggered".
Memoria en la Raspberry Pi Pico y en MicroPython
Los 264 KB de RAM de la Pico son enormes comparados con el Uno, pero el intérprete de MicroPython usa una parte; a tu programa le suelen quedar unos 190 KB de heap. En MicroPython la memoria la gestiona un recolector de basura (garbage collector): los objetos que ya no se usan se eliminan al llamar a gc.collect() o cuando la memoria está a punto de agotarse. Si de verdad se acaba, aparece MemoryError: memory allocation failed. Concatenar textos dentro de un bucle, crear listas grandes y tener un único archivo de código muy largo son las causas más habituales.
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]))Para cuidar la memoria en MicroPython, reserva los búferes de antemano con bytearray y reutilízalos en el bucle, define los números constantes con const(), convierte los módulos grandes en archivos .mpy precompilados con mpy-cross y llama a gc.collect() antes de tareas largas. Tienes los comandos básicos de MicroPython en la Pico en fundamentos de MicroPython y las características generales de la placa en ¿Qué es la Raspberry Pi Pico?.
¿Cuándo conviene pasar a un Mega o a un ESP32?

| Situación | Recomendación |
|---|---|
| Tras F(), PROGMEM y arrays char quedan más de 300 bytes de RAM libres | Sigue con el Uno; problema resuelto |
| Varios sensores y un menú con OLED o SD, y la RAM sigue sin llegar | Arduino Mega 2560: 4 veces más RAM, mismos pines de 5 V y librerías |
| El programa supera los 32 KB pero la RAM alcanza | Mega o Uno R4: 256 KB de flash |
| Necesitas Wi-Fi, servidor web, búferes grandes o procesamiento de imagen | ESP32: 520 KB de RAM, 4 MB de flash, Wi-Fi y Bluetooth |
| Quieres trabajar con MicroPython | Raspberry Pi Pico o Pico W |
| Un pequeño nodo de sensores que debe funcionar meses con pilas | Optimiza en el Uno o usa un Pro Mini; una placa mayor consume más corriente |
Al pasar al Mega, la mayor parte de tu código no cambia; solo recuerda que el I2C está en los pines 20 (SDA) y 21 (SCL) y el SPI en los pines 50–53. Al pasar al ESP32 hay diferencias como el nivel lógico de 3,3 V, otros números de pin y el resultado de 12 bits (0–4095) de analogRead. Para decidir qué placa te conviene, lee la comparativa Arduino o ESP32, y para una opción compatible con 5 V y con mucha más memoria, el artículo Arduino Uno R4.
Errores frecuentes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| Sketch too big, el código no se sube | El programa no cabe en la flash | Quita la depuración, reduce float y sprintf, usa librerías más pequeñas y, si hace falta, un Mega |
| El código se sube pero se cuelga a los pocos minutos | Las concatenaciones de String fragmentan el heap | Usa arrays char y snprintf en vez de String; mide la RAM libre |
| Caracteres sin sentido en el Monitor Serie, variables que cambian solas | La pila está pisando el heap | Baja la RAM global por debajo del 75 %, elimina arrays locales grandes |
| SSD1306 allocation failed | begin() no puede reservar el búfer de 1 KB | Mete los textos en F(), cambia a U8g2 en modo página |
| La placa se reinicia al azar aunque la memoria parece bien | Puede ser un problema de alimentación y no de memoria | Alimenta motores y relés por separado, añade un condensador |
| Los elementos de un array muestran valores absurdos | Se escribe fuera de los límites del array | Revisa el índice; calcula los límites del bucle con sizeof |
| Stack canary watchpoint triggered en el ESP32 | Se desbordó la pila de una tarea | Haz globales los arrays locales grandes o aumenta la pila de la tarea |
La memoria insuficiente en Arduino suele resolverse sin cambiar de placa: llevar los textos constantes a la flash con F(), pasar las tablas grandes a PROGMEM, usar arrays char en lugar de String y quitar librerías innecesarias da a los 2 KB de RAM un margen sorprendente. En la app BlueGrays puedes ver proyectos que exigen mucha memoria, como juegos en OLED, melodías con zumbador y animaciones en matrices LED, con esquemas paso a paso y código escrito con estas técnicas.
Preguntas frecuentes
¿Qué significa Low memory available en Arduino?
Indica que las variables globales ocupan cerca del 75 % de la RAM y que queda poco espacio para la pila y el heap. El código se sube, pero durante la ejecución pueden aparecer reinicios aleatorios, cuelgues y variables corrompidas. Meter los textos constantes en F() y pasar los arrays grandes a PROGMEM suele hacer desaparecer el aviso.
¿Cómo se soluciona el error Sketch too big?
Este error indica que el programa no cabe en la memoria flash. Desactiva la salida Serial de depuración, reduce float y sprintf, convierte el código repetido en funciones y elige librerías más pequeñas. Si aun así no cabe, pasa a una placa con más flash como el Arduino Mega o un ESP32.
¿Cuánta memoria tiene el Arduino Uno?
El ATmega328P del Arduino Uno tiene 32 KB de flash (0,5 KB reservados para el bootloader), 2 KB de SRAM y 1 KB de EEPROM. El programa va a la flash, las variables a la SRAM y los ajustes permanentes a la EEPROM. La mayoría de los problemas aparecen en esos 2 KB de SRAM.
¿Para qué sirve la macro F()?
F() evita que los textos constantes que se pasan a funciones como Serial.print se copien a la RAM y los mantiene en la flash. En el Uno cada carácter ahorra un byte de RAM, lo que suma cientos de bytes en proyectos con muchos mensajes. También compila en el ESP32 y la Pico, pero allí no tiene efecto.
¿Cómo se mide la RAM libre en Arduino?
En el Uno, el Nano y el Mega se usa una pequeña función que calcula la distancia entre la pila y el heap con las variables __heap_start y __brkval. En el ESP32, ESP.getFreeHeap() y ESP.getMinFreeHeap() dan la misma información, y en MicroPython gc.mem_free(). Es importante medir en el momento de mayor uso de memoria.
¿Por qué usar String en Arduino da problemas?
Los objetos String piden memoria nueva al heap en cada concatenación y liberan la anterior, así que el pequeño heap del Uno se fragmenta con el tiempo. Aunque la memoria libre total parezca suficiente, no se puede reservar un bloque nuevo y el programa se cuelga. Los arrays char de tamaño fijo y snprintf eliminan este problema por completo.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Himno nacional turco con zumbador
Pulsas el botón y un pequeño zumbador empieza a tocar el himno nacional de Turquía, nota a nota.

Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

Juego de Raquetas - SSD1306
Una pelota, dos palas y tú: juegas al tenis de mesa, uno de los primeros videojuegos de la historia, en una pequeña pantalla OLED.

OLED T-Rex Run: Juego del dinosaurio con Arduino
El juego del dinosaurio que aparece cuando se va internet, ahora en tu mesa: el dinosaurio corre por la pequeña pantalla OLED, los cactus se le echan encima y tú saltas con un solo botón.

Serpiente de píxeles Matriz 8x8
Monta con tus propias manos el clásico juego de la serpiente y juega. En una matriz de luces de colores de 8x8 guías una serpiente verde con un joystick y te comes manzanas rojas; con cada manzana la…

Juego de memoria con Arduino (4 LED + 4 pulsadores + zumbador)
¿Te fías de tu memoria? Cuatro LED de colores se encienden en secuencia, cada uno con su propia nota, y tú repites el mismo orden pulsando los botones.

Cerradura con contraseña, teclado 4x4 y LCD
Una pequeña cerradura electrónica que no deja pasar a quien no sepa la clave. Pulsas la tecla de almohadilla y escribes la clave en el teclado; si es correcta, la pantalla indica acceso permitido, se…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

