Guías · 15 min de lectura

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.

Placa Arduino Uno con microcontrolador ATmega328P
El ATmega328P, corazón del Arduino Uno: 32 KB de flash, 2 KB de SRAM y 1 KB de EEPROM. La mayoría de los problemas de memoria ocurren en esos 2 KB de RAM.

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.

MemoriaTamaño en el Uno¿Qué se guarda?Al cortar la alimentaciónCiclos de escritura
Flash32 KB (0,5 KB para el bootloader, 32256 bytes utilizables)Código del programa, datos PROGMEMSe conservaUnos 10.000 ciclos de borrado/escritura
SRAM2 KB (2048 bytes)Variables, arrays, pila (stack) y montón (heap)Se borraIlimitados
EEPROM1 KB (1024 bytes)Ajustes, contadores, calibraciónSe conservaUnas 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

PlacaFlash (programa)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 KB (Uno 32256, Nano 30720 bytes utilizables)2 KB1 KB
Arduino Leonardo / Pro Micro (ATmega32U4)32 KB (28672 bytes utilizables)2,5 KB1 KB
Arduino Mega 2560256 KB (253952 bytes utilizables)8 KB4 KB
Arduino Uno R4 (RA4M1)256 KB32 KB8 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 MB264 KBNo 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 spaceEn cada compilaciónEspacio que ocupa el código en la flash
Global variables use ... bytes (x%) of dynamic memoryEn cada compilaciónParte 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 RAMEl código se sube, pero queda poco sitio para la pila y el heap
Sketch too big y text section exceeds available space in boardCuando el programa no cabe en la flashNo se puede subir; hay que reducir el uso de flash
Not enough memory y data section exceeds available space in boardCuando las variables globales superan la RAMNo se puede subir; hay que reducir el uso de RAM
El aviso "Low memory" no es un error y el código se sube sin problemas; precisamente ahí está el peligro. Por ejemplo, un sketch con int veri[700]; usa en el Uno 1588 bytes (77 %) en variables globales y deja solo 460 bytes para la pila y el heap. Cuando unas cuantas llamadas anidadas, una concatenación de String o un búfer que una librería reserva en begin() agotan ese espacio, el programa falla. Los síntomas son reinicios aleatorios, variables corrompidas y cuelgues; para distinguirlos de problemas de alimentación, lee también Arduino se reinicia solo.

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.

ZonaContenidoSentido de crecimiento¿Aparece en la salida de compilación?
.dataVariables globales y estáticas inicializadas, textos sin F()FijoSí
.bssVariables globales y estáticas sin inicializar (cero), búferes de libreríasFijoSí
HeapString, new, malloc, búferes que algunas librerías reservan en begin()Hacia arribaNo
Pila (stack)Variables locales, direcciones de retorno, registros guardados en interrupcionesHacia abajoNo

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íos4449
Serial.begin(9600)1438184
+ Serial.println("un texto de 44 caracteres")1518232
El mismo texto con F()1530188
analogRead + Serial.println(int)1892188
Cálculo float + Serial.println(float)3380200
Concatenación String: "A0=" + String(analogRead(A0))3316202
Lo mismo con snprintf y un array char3232194
Una sola escritura con Wire (I2C)2476225
Tarjeta SD: begin, open, println, close10496837
Array int veri[700]17801588 (77 %, aviso Low memory)
Array int veri[950]17802088 (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:

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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(&notalar[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_floatLee 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_PObtiene la longitud de un texto en flash, copia un bloque desde la flash
En el ESP32 y la Pico, los arrays declarados const ya se quedan en la flash; allí PROGMEM no tiene efecto pero tampoco da error, y las funciones pgm_read_* están definidas. Así que el código escrito con PROGMEM compila en las tres placas. Hay una excepción: al leer una tabla de punteros, pgm_read_word funciona en el Uno pero recorta el puntero en placas de 32 bits; para código portable usa pgm_read_ptr.

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:

C++ (Arduino IDE)
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

TipoUno (AVR)ESP32 / PicoRango de valores (Uno)
bool, char, byte1 byte1 bytebyte: 0–255
int2 bytes4 bytes-32768 a 32767
unsigned int, uint16_t2 bytesuint16_t 2, unsigned int 4 bytes0–65535
long, unsigned long4 bytes4 bytesunsigned long: 0–4.294.967.295
float4 bytes4 bytesUnas 6–7 cifras significativas
double4 bytes (igual que float)8 bytesEn 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ónCoste de RAM (Uno)¿Cuándo se reserva?Opción más ligera
SerialUnos 175 bytes (búferes de 64 + 64 bytes)Al compilar (global)Quitar Serial por completo si no hace falta
Wire (I2C)Unos 215 bytesAl compilar (global)Inevitable incluso con un solo dispositivo I2C; ahorra en otra parte
SoftwareSerialUnos 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
SDUnos 830 bytes, más unos 10 KB de flashAl compilar (global)Dejar el registro de datos a un ESP32 o a un Mega
Adafruit SSD1306 128x64Búfer de imagen de 1024 bytesDesde el heap en begin()U8g2 en modo página (128 bytes) o U8x8 solo para texto
Adafruit NeoPixel / FastLED3 bytes por LED (60 LED = 180 bytes)Al arrancarLimitar 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.
C++ (Arduino IDE)
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?.

C++ (Arduino IDE)
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.

Python
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?

Placa Arduino Mega 2560
Arduino Mega 2560: 256 KB de flash, 8 KB de SRAM y 4 KB de EEPROM. El código del Uno suele funcionar en ella sin cambios.
SituaciónRecomendación
Tras F(), PROGMEM y arrays char quedan más de 300 bytes de RAM libresSigue con el Uno; problema resuelto
Varios sensores y un menú con OLED o SD, y la RAM sigue sin llegarArduino Mega 2560: 4 veces más RAM, mismos pines de 5 V y librerías
El programa supera los 32 KB pero la RAM alcanzaMega o Uno R4: 256 KB de flash
Necesitas Wi-Fi, servidor web, búferes grandes o procesamiento de imagenESP32: 520 KB de RAM, 4 MB de flash, Wi-Fi y Bluetooth
Quieres trabajar con MicroPythonRaspberry Pi Pico o Pico W
Un pequeño nodo de sensores que debe funcionar meses con pilasOptimiza 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íntomaCausa probableSolución
Sketch too big, el código no se subeEl programa no cabe en la flashQuita 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 minutosLas concatenaciones de String fragmentan el heapUsa arrays char y snprintf en vez de String; mide la RAM libre
Caracteres sin sentido en el Monitor Serie, variables que cambian solasLa pila está pisando el heapBaja la RAM global por debajo del 75 %, elimina arrays locales grandes
SSD1306 allocation failedbegin() no puede reservar el búfer de 1 KBMete los textos en F(), cambia a U8g2 en modo página
La placa se reinicia al azar aunque la memoria parece bienPuede ser un problema de alimentación y no de memoriaAlimenta motores y relés por separado, añade un condensador
Los elementos de un array muestran valores absurdosSe escribe fuera de los límites del arrayRevisa el índice; calcula los límites del bucle con sizeof
Stack canary watchpoint triggered en el ESP32Se desbordó la pila de una tareaHaz globales los arrays locales grandes o aumenta la pila de la tarea
Para evitar problemas de memoria desde el principio, apunta los dos porcentajes de la salida de compilación cada vez que añadas un módulo al proyecto. Empieza a aplicar F() y PROGMEM cuando la RAM global pase del 60 %; esperar al aviso del 75 % es dejar el problema para el momento en que más cuesta resolverlo.

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.

Ver todos los proyectos
Himno nacional turco con zumbador
AR-15Intermedio

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.

4.8(114)
235
Temperatura y humedad con DHT11
AR-55Intermedio

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…

4.7(47)
83
Juego de Raquetas - SSD1306
AR-86Intermedio
Premium

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.

4.5(47)
65
OLED T-Rex Run: Juego del dinosaurio con Arduino
AR-87Avanzado
Premium

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.

4.7(33)
53
Serpiente de píxeles Matriz 8x8
AR-88Avanzado
Premium

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…

4.7(39)
57
Juego de memoria con Arduino (4 LED + 4 pulsadores + zumbador)
AR-93Avanzado
Premium

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.

4.8(46)
69
Cerradura con contraseña, teclado 4x4 y LCD
AR-64Avanzado
Premium

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…

4.8(59)
75