Lecciones y el juego de aprendizaje

Punteros y memoria en C

Qué hay realmente en los 2 KB de RAM de un Arduino Uno, y la idea que hace que C sea lo que es: una variable que guarda una dirección.

Cómo funciona

Pointers and memory in C follows C desde cero, que conoció & and * once. Here they are the whole story. Every lesson runs on the code bench: an Uno with a red lamp on pin 13, yellow on 12, green on 11 and a button on pin 2.

Cada lección abre un sketch en C que funciona e imprime lo que hace: direcciones, tamaños, los bytes de un número. Lo ejecutas, lees el monitor serie, luego cambias una línea y vuelves a ejecutar. Las verificaciones leen la salida serie y las lámparas. Ninguna verificación pide una dirección exacta, porque las direcciones se mueven cuando cambia un sketch; piden los huecos, tamaños y datos que el sketch calcula.

Las lecciones

  1. Direcciones: dónde viven las globales, vecinas en un arreglo, el orden de bytes little-endian, y el mapa de la RAM de 0x100 a 0x8FF.
  2. Punteros: & y *, escribir a través de un puntero, un intercambio que sí funciona, NULL y la comprobación antes de seguirlo, y un botón que dispara a lo que sea que el puntero apunte.
  3. Los arreglos son punteros: el nombre de un arreglo es la dirección de su primer elemento, a[i] es *(a + i), recorrer un arreglo con un puntero, la trampa del sizeof en una función, y un seguidor de lámparas que es un puntero en movimiento.
  4. Cadenas a mano: caracteres y un byte cero. Longitud, mayúsculas e invertir con punteros, un desbordamiento de buffer que puedes ver pisoteando a su vecino, y la copia con límite que lo evita.
  5. Structs y punteros: una flota de naves, sizeof sin relleno, el operador flecha, una copia frente a un puntero, y una búsqueda que devuelve NULL.
  6. Pila y static: globales abajo y pila arriba, un marco por llamada, una local que olvida frente a una static que recuerda, y un buffer que se come la RAM libre.
  7. Punteros a funciones: una llamada que suma o multiplica, un ordenamiento que recibe su orden como función, callbacks, y una tabla de modos de lámpara.

El proyecto: un intérprete de comandos

El final construye el pequeño shell que todo firmware serio tiene. Se lee una línea en un búfer fijo de 32 bytes, se divide en palabras directamente con punteros (el mismo argc y argv que recibe un programa de PC) y se busca en una tabla de comandos, donde cada fila guarda un puntero a función. Enciende lámparas por nombre, suma números que parseó a mano y responde a una entrada inválida con un mensaje útil. Agregas un comando echo propio y luego lo haces tuyo: parpadear, espiar cualquier dirección, mostrar la RAM libre o repetir la última línea.

Lo que el Uno hace distinto

  • La RAM son 2048 bytes de 0x100 a 0x8FF; debajo de 0x100 están los registros de hardware del chip. Un puntero ocupa 2 bytes, no los 8 de una laptop de 64 bits.
  • Los literales de cadena se copian a la RAM al iniciar, porque el chip lee la flash con una instrucción distinta. El texto cuesta RAM a menos que uses F().
  • El AVR de 8 bits no agrega relleno a los structs, así que un struct puede tener un tamaño distinto aquí que en una PC. Nunca envíes uno en crudo entre dos máquinas.
  • No hay protección de memoria. Seguir un NULL o salirse de un arreglo no termina con un mensaje de error; silenciosamente lee o escribe los bytes equivocados.

Después de este curso

Bajo el capó quita la capa de Arduino y lee los registros del chip mediante punteros, y los cursos de C++ muestran lo que agregan las referencias y las clases encima.