Como optimizar el consumo de memoria en programas de Arduino

El compilador que usa el entorno Arduino es muy óptimo y es dificil escribir el programa de forma que genere menos código: el compilador optimiza automáticamente independientemente de como lo esribamos.
Pero hay algunos detalles que permiten ahorrar bytes de RAM o de FLASH, cambiando un poco el enfoque de los programas!

Uno es usar el macro F() para las variables de cadena que pasamos a algunas funciones, principalmente Serial.print().
Usando como ejemplo el programa http://heli.xbot.es/?p=501 podemos cambiar la línea 61 de:
        Serial.println (“Testing AnalogKeyPad”);
a
        Serial.println (F(“Testing AnalogKeyPad”));

Compilando con el IDE de Arduino 1.8.5 para Arduino UNO (Atmega328p),
la primera forma genera un programa de 1958 bytes que usa 269 bytes de RAM y
la segunda forma genera un programa de 1998 bytes que usa 249 bytes de RAM.
Hemos ahorrado 20 bytes de ram (de los 2048 disponibles) pero el programa ha crecido en 40 bytes!
Que no cunda el pánico, ahora optimizamos mas todavía:
cambiamos la línea 70 de:
        Serial.print (“Pulsado “); Serial.println (b);
a
        Serial.print (F(“Pulsado “)); Serial.println (b);
Ahora el programa ocupa 2004 bytes y usamos 239 de RAM, el programa solo ha crecido en 6 bytes y hemos ahorrado 10 bytes de RAM.

El programa sobre el que estamos trabajando es muy sencillo y no tiene mas cadenas constantes, no podemos seguir mejorándolo, pero cualquier cadena que convirtamos en constante en el futuro ahorraría aproximadamente su longitud en RAM incrementando solo 6 bytes de código en FLASH.

¿Y por que es así?
Porque el micro ATMEGA328P, y toda la familia aTMEGA, son micros con Arquitectura Harvard y eso significa que los DATOS y las instrucciones de PROGRAMA se almacenan en espacios separados y se acceden usando instrucciones de programa distintas.
Eso representa un problema para el compilador porque tiene que generar un código distinto para manejar datos variables (en RAM) y datos constantes (en memoria de programa FLASH).
El compilador que usa el entorno de Arduino es el AVR-GCC y soluciona este problema copiando en RAM las constantes y usando siempre funciones que trabajan sobre RAM.
Esto tiene el inconveniente de que cada constante que declaramos en nuestro programa ocupa una cantidad igual de memoria de programa y de RAM.
Y esto no tiene facil solución porque, para manejar datos que solo esten en memoria de programa, hacen falta funciones distintas que sepan manejar los datos residentes en ese espacio de memoria.
En arduino existe el macro F() que permite instruir al compilador para que almacene una cadena constante solo en FLASH.
Además la función Serial.print() esta sobrecargada de forma que se compila de forma distinta para cadenas variables que para cadenas constantes.
La primera vez que usamos la función Serial.print(F()) el compilador añade el código de la librería necesario para manejar cadenas constantes y por eso el programa crece un poco. Los siguientes usos de la función solo incrementen un poco el código debido a la diferente gestión de los datos.
Lo importante es que cada uso de F() ahorra una cantidad de RAM igual a la longitud de la cadena usada! Y en RAM es donde mas justo esta el Atmega328p.

Podemos usar esta técnica para otras constantes, pero si la función que las ha de usar no esta adecuadamente sobrecargada (es decir, no tienen definida función para trabajar con datos en espacio de programa) no será posible. Tenemos que escribir nuestro propio código para acceder a esos datos en memoria de programa… pero es sencillo.

Este es un array normal, cada dato (int) ocupa dos bytes de FLASH y dos de RAM.
        const int KeyVals[nKeys+1] = { 693, 665, 624, 573, 544, 491, 463, 432, 393, 353, 308, 249, 188, 157, 117, 79, 0};

La forma de decir al compilador que queremos que almacene un array en memoria de programa es esta:
        const int KeyVals[nKeys+1 ] PROGMEM = { 693, 665, 624, 573, 544, 491, 463, 432, 393, 353, 308, 249, 188, 157, 117, 79, 0};

Pero al usar la segunda forma ya no podemos hacer:
if (Val >= KeyVals[i]) break;

porque el manejo de variables array solo puede trabajar con datos en RAM. ATENCION el compilador no informará de un error!!! pero el programa no funcionará. Los datos estarán almacenados en un espacio de memoria pero el programa intentará usar punteros a ese espacio de memoria en otro espacio de memoria distinto, con lo que apuntará a datos distintos y no funcionará!! Debe usarse la función adecuada para leer los datos almacenados en la memoria de programa, usando los punteros a memoria de programa ha generado el uso de PROGMEM: pgm_read_word(), porque los datos son de tipo int (ocupan 16 bits):
        if (Val >= pgm_read_word(KeyVals+i)) break;

Para el otro array, que es tipo char (8 bits), se debe usar la función
        pgm_read_byte(Keys+i);

NO se puede usar el índice [i] en un array PROGMEM ya que su gestión esta definida para trabajar con variables RAM. Debe usarse +i que sirve para punteros a RAM o a FLASH.

Después de aplicar estas dos optimizaciones al programa (dos líneas con F() y dos arrays cambiados a PROGMEM) el programa que antes ocupaga 1958 bytes de FLASH y usaba 269 de RAM ahora ocupa 1992 bytes de FLASH pero solo usa 189 bytes de RAM.
Ha crecido en 34 bytes de 32768 disponibles (~ 0.1%) pero ha bajado el uso de ram en 80 bytes de 2048, casi un 4% de mejora.

https://www.arduino.cc/en/Reference/PROGMEM

El programa optimizado: AnalogKeyPad1