Arduino Uno

Qué es

El Arduino Uno es una placa de desarrollo pequeña construida alrededor del ATmega328P de Microchip, un microcontrolador de 8 bits. Expone los pines del chip en cabeceras etiquetadas, añade un puerto USB para programación y alimentación, y se encarga de las partes engorrosas —el regulador de tensión, el cristal de reloj, el circuito de reset— para que puedas centrarte en tu código y tu cableado. Para una enorme mayoría de quien empieza en robótica, el Uno es la forma en que un motor gira por primera vez o un sensor se enciende.

Su atractivo duradero no es la potencia bruta —según los estándares actuales es lento y va escaso de memoria—. Es la indulgencia. Los pines de 5 V toleran los errores de cableado que cometen los principiantes, la comunidad ha respondido casi todas las preguntas que se te pueden ocurrir, y casi todo sensor y controlador de afición se distribuye con código de ejemplo que da por sentado un Uno.

Cómo funciona

Escribes un sketch: un programa en C++ con dos funciones. setup() se ejecuta una vez cuando la placa se enciende; loop() se ejecuta indefinidamente a partir de ahí. Dentro de ellas lees entradas y manejas salidas a través de los pines:

• Pines digitales leen o escriben una señal HIGH/LOW (5 V / 0 V): la pulsación de un botón, un LED, la entrada de dirección de un controlador de motores.
• Pines PWM (marcados con ~) simulan una tensión analógica encendiendo y apagando muy rápido. Así se ajusta la velocidad de un motor o el brillo de un LED.
• Entradas analógicas miden una tensión de 0–5 V y la devuelven como un número de 0–1023. Así se lee un potenciómetro o un sensor de línea analógico.

El Uno no tiene sistema operativo. Tu código es lo único que se ejecuta, lo que hace predecibles los tiempos: algo valioso cuando cierras un lazo de control alrededor de un robot real.

Cuándo usarlo

Recurre a un Uno cuando estés aprendiendo, cuando quieras el mayor montón posible de tutoriales y bibliotecas compatibles, o cuando la tarea de tu robot sea sencilla y en tiempo real: leer unos cuantos sensores, ejecutar un lazo de control, manejar dos motores. Un seguidor de línea, un esquivador de obstáculos o un pequeño rover de conducción diferencial están justo en su zona cómoda.

Mira en otro sitio cuando necesites Wi-Fi o Bluetooth (un ESP32 es la mejora habitual), matemática pesada o visión por cámara (una Raspberry Pi), o mucha memoria. Los 2 KB de SRAM del Uno se llenan más rápido de lo que esperan los principiantes: las cadenas largas y los arrays grandes son los culpables habituales.

Errores comunes

• Es una placa de 5 V. Muchos sensores modernos son de 3,3 V y la lógica de 5 V puede dañarlos. Consulta la ficha técnica antes de cablear.
• No alimentes motores desde la placa. El regulador del Uno no puede suministrar corriente de motor; usa una batería aparte y un controlador de motores. Alimentar motores directamente a través del Uno es la vía más habitual de que un principiante provoque un brown-out o reinicie su placa.
• delay() bloquea todo. Mientras la placa está en un delay(), no puede leer sensores ni reaccionar. Para cualquier cosa que deba responder, mide el tiempo con millis() en su lugar.
• Vigila tu memoria. Si la placa se comporta de forma errática sin razón clara, puede que te hayas quedado sin SRAM.

Patillaje: qué puede hacer realmente cada pin

Catorce pines digitales y seis analógicos, pero no son intercambiables. Seis de ellos tienen una segunda función que importa.

Dos de esas líneas condicionan la mayoría de los diseños de robots. D2 y D3 son los únicos pines de interrupción de verdad, lo que significa que un robot con dos encoders de rueda los usa ambos y no le queda ninguno. Y A4/A5 son el bus I²C, así que en un Uno un MPU-6050 más una matriz de sensores analógicos se disputan los pines desde el primer momento.

Esta presión de pines es el motivo más habitual por el que un proyecto se queda corto en un Uno, no la velocidad ni la memoria. Catorce pines digitales y seis analógicos desaparecen rápido en cuanto tienes un controlador de motores (6 pines), un par de encoders (4 pines, 2 de ellos interrupciones) y una matriz de sensores (6 analógicos).

Cómo alimentarlo, y las tres formas de hacerlo mal

El regulador es lineal, lo que significa que quema como calor la diferencia entre la entrada y los 5 V. Con 12 V de entrada y 200 mA de consumo, eso son (12 − 5) × 0.2 = 1.4 W en un encapsulado pequeño, y se pone realmente caliente. Aliméntalo con 9 V en lugar de 12 V si tienes la opción.

Tres errores concretos que merece la pena nombrar:

Alimentar motores desde el pin de 5 V. El regulador no puede suministrar corriente de motor, así que el raíl se hunde, la placa se reinicia y el síntoma parece un fallo de software. Los motores llevan su propia alimentación y solo comparten masa.

Alimentar el pin de 5 V desde una fuente sin regular. Ese pin está directamente sobre el raíl, así que cualquier cosa por encima de unos 5,5 V va directa al ATmega328P.

Alimentar por USB y por el conector a la vez. La placa lo contempla (hay un comparador que selecciona la fuente más alta), pero una batería en el conector no se cargará y puede retornar corriente por un diseño marginal en un clon.

Qué pueden suministrar realmente los pines

El pin de 3,3 V sorprende a la gente con frecuencia. No es un raíl de uso general; es una comodidad de 50 mA. Un módulo ESP-01 intentando transmitir se queda sin tensión al momento.

El problema de los 2 KB de memoria

El Uno tiene 32 KB de flash para tu programa y 2 KB de SRAM para sus variables mientras se ejecuta. La flash rara vez es la limitación. La SRAM, constantemente.

Cada literal de cadena en un Serial.print se copia a la SRAM al arrancar:

Serial.println("Calibration complete, entering drive mode");   // 43 bytes of SRAM, forever

Veinte mensajes así son 800 bytes, el 40 % del total. La solución es F(), que deja la cadena en la flash y la lee solo cuando hace falta:

Serial.println(F("Calibration complete, entering drive mode"));  // 0 bytes of SRAM

Los arrays son el otro consumidor. Un float ocupa 4 bytes, así que un buffer de registro de 200 muestras son 800 bytes y no hay ningún aviso: el compilador informa del uso de flash con gusto y no dice nada útil sobre la SRAM en tiempo de ejecución.

El síntoma de quedarte sin ella no es un error limpio. La pila crece hacia abajo, el montículo crece hacia arriba, y cuando se encuentran, las variables se corrompen entre sí sin avisar. La placa se comporta de forma errática: lecturas que carecen de sentido, un bucle que se salta pasos, un reset sin causa. Si un Uno empieza a comportarse de manera irracional después de que le hayas añadido una función, sospecha de la SRAM antes que nada.

// Drop this in and watch it while you develop.
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

Por debajo de unos 200 bytes libres, espera problemas.

Resolución de problemas

¿Uno u otra cosa?

El Nano merece mención aparte en robótica: es el mismo ATmega328P con el mismo código, y saca A6 y A7 como entradas analógicas adicionales. Para una matriz de reflectancia de 8 canales eso es la diferencia entre que quepa y no quepa, y por eso los montajes de seguidores de línea especifican tan a menudo un Nano.

El resumen honesto: el valor del Uno es que todo funciona a la primera. Cada biblioteca, cada tutorial, cada diagrama de cableado da por supuesto un Uno. Eso vale más mientras aprendes que cualquier especificación, y cuando se te quede corto, lo que se te quede corto será casi siempre el número de pines.