Arduino "Low memory available, stability problems may occur", y "Sketch too big"
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Después de cada compilación el IDE de Arduino imprime dos líneas: cuánto flash ocupa el programa y cuánta RAM ocupan sus variables globales. Cuando la línea de RAM pasa alrededor de tres cuartos, aparece una tercera línea: "Low memory available, stability problems may occur." Es una advertencia, no un error. El sketch se sigue cargando. Que luego funcione depende de cuánta RAM necesite al ejecutarse, algo que el compilador no puede saber.
La pestaña de compilación de Mokxi imprime las mismas líneas, bajo la misma regla. El circuito de arriba lee una perilla y la imprime; ábrelo, cambia cualquier línea y presiona Ejecutar, y la pestaña de compilación muestra sus dos líneas. Cada número de abajo viene de un sketch compilado con el compilador del editor para una Uno. El compilador y el núcleo de Mokxi no son los del IDE de Arduino, así que el IDE da números ligeramente distintos para el mismo sketch, y la página indica dónde importa la diferencia.
Qué significan las dos líneas
El flash, "program storage space", guarda el programa mismo y todo lo marcado para quedarse ahí. La RAM, "dynamic memory", guarda todas las variables globales y estáticas, el texto que tu sketch imprime a menos que lo muevas, y, mientras el sketch corre, la pila: las variables locales y la dirección de retorno de cada llamada a función. Una Uno tiene 2,048 bytes de RAM. No es mucho: un solo búfer de 1600 bytes se lleva la mayor parte.
Un sketch de parpadeo compilado para una Uno en Mokxi reporta "Sketch uses 1,652 bytes (5%) of program storage space. Maximum is 32,768 bytes." y "Global variables use 142 bytes (7%) of dynamic memory, leaving 1,906 bytes for local variables. Maximum is 2,048 bytes." El IDE dice 32,256 para el flash de una Uno, porque el gestor de arranque reserva los últimos 512 bytes; Mokxi cuenta el chip completo. Una Mega tiene más espacio: Mokxi reporta un máximo de 262,144 bytes de flash y 8,192 bytes de RAM.
Cuándo aparece la advertencia
Compilamos un sketch con un búfer global char buffer[] de distintos tamaños. Con 1200 bytes la compilación reportó "Global variables use 1,370 bytes (67%) of dynamic memory, leaving 678 bytes for local variables" y ninguna advertencia. Con 1400 bytes reportó 1,570 bytes (77%), "leaving 478 bytes for local variables", y entonces "Low memory available, stability problems may occur." Con 2000 bytes no compiló: las globales ya no caben, y la compilación dice global variables do not fit in the 2 KB SRAM.
La advertencia es una regla general. El IDE la imprime pasado el tres cuartos de la RAM, y Mokxi hace lo mismo, y también cuando lo que queda es menor que el espacio que su entorno de ejecución reserva para la pila. Un sketch al 80% con funciones poco profundas puede funcionar durante años; un sketch al 70% con una recursión profunda o un arreglo local grande puede fallar de inmediato.
Cómo se ven los "stability problems"
La pila crece hacia abajo desde la parte alta de la RAM hacia las globales, y nada la detiene al llegar. Escribe encima de las variables que encuentre a su paso y el sketch sigue con el daño. No se imprime ningún error y nada se reinicia. Por eso los problemas parecen aleatorios: un valor cambia solo, una cadena acumula basura al final, o la placa se reinicia cuando se llama a una función poco usada.
Este sketch llena un búfer global de 1734 bytes con la letra A, llama a una función que mantiene 64 bytes de variables locales y se llama a sí misma, y luego cuenta cuánto del búfer ya no es A. La compilación reportó 1,946 bytes (95%), "leaving 102 bytes for local variables", y la advertencia. Con la función llamada a tres niveles de profundidad, 48 bytes del búfer habían cambiado. A cinco niveles, habían cambiado 188 bytes. A uno o dos niveles, nada había cambiado, y el sketch funcionó con normalidad en todos los casos, imprimiendo sus resultados sin señal de problema.
char buffer[1734];
int depth(int n) {
char local[64];
memset(local, n, sizeof(local));
if (n == 0) return local[0];
return depth(n - 1) + local[63];
}
void setup() {
Serial.begin(9600);
memset(buffer, 'A', sizeof(buffer));
Serial.println(depth(5));
int changed = 0;
for (int i = 0; i < (int)sizeof(buffer); i++) {
if (buffer[i] != 'A') changed++;
}
Serial.print("bytes of buffer changed: ");
Serial.println(changed);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
"Sketch too big": el flash está lleno
La flash también tiene un límite estricto. El Arduino IDE se detiene con "Sketch too big" cuando el programa no cabe, y no hay ningún aviso antes. En Mokxi, un sketch con una tabla de 40,000 bytes en flash falla con el firmware no cabe en la flash de 32 KB, y la pestaña de compilación agrega una frase clara: el programa es más grande que los 32 KB de flash que tiene esta placa, el mismo límite que una placa real.
Las soluciones son las de siempre: quitar bibliotecas y código que el sketch ya no usa, hacer más pequeñas las tablas grandes, o elegir una placa con más espacio. Una biblioteca incluida por una sola función puede costar varios kilobytes, así que revisa qué trae cada #include.
Soluciones que liberan RAM
Make buffers the size you need, not the size you might need. Then move tables that never change into flash with PROGMEM, and read them back with pgm_read_byte(). A 1600-byte const byte table built for an Uno took 1,786 bytes (87%) of RAM and brought the warning; the same table declared PROGMEM took 186 bytes (9%), for 6 more bytes of flash, and printed the same values.
El texto que imprimes es el otro gran consumidor. En el Arduino IDE, Serial.println(F("...")) mantiene el texto en flash y ahorra su RAM, y en un sketch con muchos mensajes suele ser la solución completa. La F() de Mokxi hace lo mismo en las placas AVR: veinte líneas largas ocuparon 1,800 bytes (88%) de RAM impresas tal cual, y 170 bytes (8%) envueltas en F(), con 52 bytes más de flash, e imprimieron el mismo texto.
Por último, la clase String crea y libera copias en el heap, que está entre las variables globales y la pila, y con las horas eso puede dejar la RAM libre en pedazos demasiado pequeños para usar. En una placa con 2 KB, los arreglos fijos de char son la opción más segura para algo que corre mucho tiempo. Si el sketch todavía no cabe, una Mega, con cuatro veces la RAM, o un ESP32 son la solución honesta.
Abre este circuito en el editor. Arduino Uno: una perilla en A0, con impresión en serie, cableado como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿"Low memory available, stability problems may occur" es un error?
No. Es un aviso de que las variables globales usan más de alrededor de tres cuartas partes de la RAM. El sketch se compila y se carga. Puede que funcione bien, o puede que falle cuando la pila necesite más espacio del que queda.
¿Cuánta memoria tiene un Arduino Uno?
32 KB de flash para el programa, de los cuales el Arduino IDE ofrece 32,256 bytes porque el bootloader reserva 512, y 2,048 bytes de RAM para variables y la pila.
¿Qué significa "Sketch demasiado grande"?
El programa no cabe en la flash de la placa. Quita bibliotecas y código sin usar, reduce las tablas grandes, o usa una placa con más flash, como una Mega.
¿Cómo reduzco el uso de RAM en un Arduino?
Reduce los búferes, pon las tablas constantes en PROGMEM, envuelve el texto impreso en F() en una placa real, evita String en sketches que corren mucho tiempo, y saca los arreglos grandes de las funciones que se llaman a sí mismas.
Sigue así
De dónde vienen los datos de esta página
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.