Pines del Arduino Nano: pinout, A6/A7, alimentación y bootloader

Los pines del Arduino Nano son 30 patillas alineadas en los dos lados largos de una placa de 45 × 18 mm: 14 pines digitales de entrada/salida (D0–D13), de los cuales 6 pueden dar PWM (~3, 5, 6, 9, 10, 11), 8 entradas analógicas (A0–A7) y los pines de alimentación y control VIN, 5V, 3V3, AREF, dos GND y dos RST. Como el Nano usa el mismo procesador ATmega328P que el Arduino Uno, los números y las funciones de los pines también son iguales: un programa escrito para el Uno funciona sin ningún cambio, salvo elegir el Nano en el menú de placas.

Aun así, hay algunos detalles importantes que diferencian al Nano del Uno, y es justo ahí donde se atascan los principiantes: A6 y A7 son solo analógicos, la placa no tiene conector DC, el pin 3V3 da muy poca corriente, en los clones el USB lo gestiona un chip CH340 y para subir código a menudo tienes que elegir ATmega328P (Old Bootloader). En esta guía conocerás cada pin, aprenderás a colocar bien el Nano en la protoboard, verás la equivalencia de pines con el Uno y descubrirás en qué se diferencian el Nano Every y el Nano ESP32 del Nano clásico.

¿Qué es el Arduino Nano y en qué se diferencia del Uno?

El Arduino Nano mete todas las funciones básicas del Uno en una placa de 45 × 18 mm y unos 7 gramos. Sus pines apuntan hacia abajo, así que se pincha directamente en la protoboard; eso reduce el lío de cables y, cuando el circuito está terminado, se pasa fácilmente a una caja o a una placa definitiva. Dentro lleva el mismo ATmega328P a 16 MHz que el Uno, trabaja con lógica de 5 V y las mismas librerías funcionan sin cambios. En el Nano original, la comunicación USB-serie la hace un chip FT232RL; casi todos los clones económicos del mercado llevan en su lugar un CH340G o CH340C en la cara inferior. Para coches robot, proyectos ponibles, mandos y cualquier circuito que tenga que caber en una caja, el Nano es una opción más práctica que el Uno.

Diagrama de pines del Arduino Nano: ¿dónde está cada pin?

Los 30 pines del Nano están en dos filas enfrentadas de 15, separadas 15,24 mm (0,6 pulgadas). Si pones la placa delante de ti con el conector mini USB hacia ti, verás justo al lado del conector dos pines enfrentados: D12 y D13. En la fila de D13 están 3V3, AREF, A0–A7 y los pines de alimentación; en la fila de D12 están los pines digitales de D11 a D2, seguidos de GND, RST, RX0 (D0) y TX1 (D1). En el extremo más alejado del USB quedan enfrentados VIN y TX1, y ahí también está el conector ICSP de 2×3. Alrededor del botón de reset del centro encontrarás el LED de alimentación (POW u ON), el LED L conectado a D13 y los LED TX y RX, que parpadean durante la carga del programa.

Pines digitales (D0–D13), PWM y funciones especiales

Cada pin digital se configura como entrada o salida con pinMode(); como salida, HIGH da unos 5 V y LOW 0 V. Para que una entrada no quede al aire, puedes activar con INPUT_PULLUP la resistencia interna de 20–50 kΩ del chip. La corriente segura por pin es de 20 mA; un LED rojo con una resistencia de 220 Ω consume unos 13 mA, y puedes calcular la resistencia adecuada con la calculadora de resistencia para LED. Algunos pines tienen funciones extra, y conocerlas de antemano evita conflictos cuando el proyecto crece:

Un detalle pequeño pero importante que diferencia al Nano del Uno está en D13. En el Uno R3 el LED L se controla a través de un amplificador operacional, mientras que en el Nano el LED y su resistencia van directamente al pin. Si usas D13 como entrada de pulsador con INPUT_PULLUP, el LED tira del pin hacia abajo y puedes leer LOW aunque el pulsador no esté pulsado; reserva este pin para salidas o SPI. Cómo funciona el PWM y qué significan los valores de analogWrite() lo tienes en Qué es PWM, y las interrupciones en Interrupciones en Arduino.

Pines analógicos A0–A7: ¿por qué A6 y A7 son diferentes?

Las ocho entradas analógicas del Nano miden tensiones de 0 a 5 V con una resolución de 10 bits: analogRead() devuelve un número de 0 a 1023 y cada paso equivale a unos 4,9 mV. Si hace falta, A0–A5 también funcionan como pines digitales normales (A0 = 14 … A5 = 19), y A4 y A5 son además las líneas SDA y SCL del bus I2C. A6 y A7, que el Uno no tiene, son dos canales ADC extra que solo existen en el encapsulado de montaje superficial (TQFP) del ATmega328P. Estos dos canales solo están conectados al convertidor analógico-digital; detrás no hay registro de puerto, ni driver de salida, ni resistencia pull-up. Por eso pinMode(), digitalRead(), digitalWrite() e INPUT_PULLUP no funcionan en estos dos pines.

Que A6 y A7 sean solo analógicos parece una desventaja, pero se le puede sacar partido. Si conectas varios pulsadores a un pin analógico a través de resistencias de distinto valor, cada pulsador produce una tensión diferente; así lees cuatro pulsadores con un solo pin y dejas los pines digitales para motores y pantallas. En el circuito, conecta A6 a 5V con una resistencia de 10 kΩ; el primer pulsador va directo entre A6 y GND, y los otros tres van a GND a través de resistencias de 2,2 kΩ, 4,7 kΩ y 10 kΩ respectivamente.

1// A6'da 4 buton: 10 kΩ pull-up + farklı seri dirençler / 4 buttons on A6: 10 kΩ pull-up + different series resistors
2const byte LADDER_PIN = A6;    // yalnız analog pin / analog-only pin
3
4byte readButton() {
5  int v = analogRead(LADDER_PIN);
6  if (v < 92)  return 1;       // 0 Ω      -> yaklaşık 0 / about 0
7  if (v < 256) return 2;       // 2,2 kΩ   -> yaklaşık 184 / about 184
8  if (v < 419) return 3;       // 4,7 kΩ   -> yaklaşık 327 / about 327
9  if (v < 767) return 4;       // 10 kΩ    -> yaklaşık 512 / about 512
10  return 0;                    // basılı değil -> 1023 / not pressed -> 1023
11}
12
13void setup() {
14  Serial.begin(9600);
15}
16
17void loop() {
18  static byte lastButton = 0;
19  byte b = readButton();
20  if (b != lastButton) {
21    delay(20);                 // kontak sıçramasını bekle / wait out contact bounce
22    b = readButton();          // değeri doğrula / confirm the value
23    if (b != lastButton) {
24      lastButton = b;
25      if (b != 0) {
26        Serial.print(F("Buton / Button: "));
27        Serial.println(b);
28      }
29    }
30  }
31}

Los valores salen de la fórmula analogRead = 1023 × R / (10 kΩ + R), y cada umbral está justo a mitad de camino entre dos valores vecinos. Como la resistencia pull-up y el ADC se alimentan de la misma línea de 5 V, las lecturas no cambian aunque la alimentación baje a 4,7 V; a esto se le llama medida ratiométrica. Si pulsas dos pulsadores a la vez, sus resistencias quedan en paralelo y la lectura baja: el código ve un pulsador de número más bajo, e incluso el 3 y el 4 juntos se leen como 2. Por eso la escalera de resistencias sirve para menús en los que se pulsa una sola tecla cada vez. Puedes probar el cálculo con la calculadora de divisor de tensión y leer más sobre lecturas analógicas en el artículo sobre el ADC.

Pines de alimentación: VIN, 5V, 3V3 y GND

Puedes alimentar el Nano de tres formas. Por USB, los 5 V llegan del ordenador a través de un diodo Schottky; el diodo cae unos 0,3 V, así que en el pin 5V normalmente medirás 4,6–4,8 V, y el diodo MBR0520 de la placa original está pensado para 500 mA como máximo. Si metes 7–12 V por el pin VIN, el regulador de la cara inferior (un LM1117 en el original, casi siempre un AMS1117 en los clones) los baja a 5 V. El regulador convierte la tensión sobrante en calor: la potencia que disipa es (VIN − 5 V) × corriente, así que si consumes 150 mA con 12 V de entrada, el pequeño regulador disipa cerca de 1 W y se pone tan caliente que no se puede tocar. Por eso lo ideal en VIN son 7–9 V. La tercera forma es meter 5 V regulados desde fuera por el pin 5V; así el regulador queda fuera de juego y el diodo del lado USB impide que la corriente vuelva hacia tu ordenador. Si trabajas con una fuente de 12 V, es mucho más fresco sacar 5 V con un convertidor reductor LM2596 y llevarlos al pin 5V; todas las formas de alimentación están en Cómo alimentar un Arduino.

El pin 3V3 es el más malinterpretado del Nano. En el Uno este pin sale de un regulador propio, pero el Nano clásico no tiene un regulador de 3,3 V aparte. En el Nano original, los 3,3 V salen de un pequeño regulador dentro del chip FT232RL (50 mA como máximo) y, según la documentación antigua de Arduino, esta salida no está disponible si la placa no se alimenta por USB. En la mayoría de los clones el pin va al regulador interno del propio CH340 y solo es seguro para cargas de unos pocos mA. Por eso no alimentes desde este pin módulos de 3,3 V como el nRF24L01, el ESP-01 o el RC522; usa un regulador AMS1117-3.3 aparte alimentado desde el pin 5V. Y cuando conectes una salida de 5 V del Nano a la entrada de un módulo de 3,3 V, pon en medio un conversor de niveles o un divisor de tensión.

Que el pin 5V esté en torno a 4,7 V con USB también afecta a las medidas analógicas: analogRead() usa la tensión de alimentación como límite superior, y si en el cálculo pones 5,0 V el resultado se desvía un 4–6 %. Se puede calcular la tensión de alimentación real midiendo la referencia interna fija del ATmega328P, de aproximadamente 1,1 V. El primer programa de prueba de abajo hace justo eso, convierte a voltios las ocho entradas analógicas usando la tensión real y hace parpadear el LED L de D13:

1// Arduino Nano: A0-A7'yi ve gerçek besleme gerilimini oku / read A0-A7 and the real supply voltage
2const byte ANALOG_PINS[8] = {A0, A1, A2, A3, A4, A5, A6, A7};
3
4long readVccMillivolts() {
5  // Referans AVcc, ölçülen kanal dahili 1,1 V / reference AVcc, measured channel internal 1.1 V
6  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
7  delay(2);                                // referansın oturmasını bekle / let the reference settle
8  ADCSRA |= _BV(ADSC);                     // dönüşümü başlat / start the conversion
9  while (bit_is_set(ADCSRA, ADSC)) {}      // bitmesini bekle / wait until it finishes
10  unsigned int raw = ADC;                  // 10 bit sonuç / 10-bit result
11  return 1125300L / raw;                   // 1,1 V x 1023 x 1000 / 1.1 V x 1023 x 1000
12}
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(LED_BUILTIN, OUTPUT);            // D13'teki L LED'i / L LED on D13
17}
18
19void loop() {
20  long vcc = readVccMillivolts();
21  analogRead(A0);                          // kanal değişti, ilk okumayı at / channel changed, discard the first reading
22  Serial.print(F("Vcc: "));
23  Serial.print(vcc);
24  Serial.print(F(" mV |"));
25  for (byte i = 0; i < 8; i++) {
26    int raw = analogRead(ANALOG_PINS[i]);  // A6 ve A7 de okunur / A6 and A7 are read too
27    Serial.print(F(" A"));
28    Serial.print(i);
29    Serial.print(F("="));
30    Serial.print(raw * (vcc / 1000.0) / 1023.0, 2);   // gerçek Vcc ile volta çevir / convert to volts using the real Vcc
31  }
32  Serial.println();
33  digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));   // L LED'ini çevir / toggle the L LED
34  delay(1000);
35}

Después de cargarlo, abre el Monitor Serie a 9600 baudios. El valor de Vcc debería rondar los 4600–4800 mV con USB y unos 5000 mV si alimentas por VIN. Los pines analógicos sin conectar muestran valores aleatorios; si conectas un potenciómetro a A0 y lo giras, verás que el valor cambia suavemente entre 0 y Vcc. La referencia interna puede variar ±10 % de un chip a otro; para un resultado más exacto, mide el pin 5V con un multímetro y multiplica la constante 1125300 del código por la relación valor medido / valor que muestra el código. Como este programa usa directamente los registros del ATmega328P, no funciona en el Nano Every ni en el Nano ESP32.

Mini USB, CH340 e instalación del driver

El Nano clásico tiene un conector USB Mini-B; los cables Micro-USB o USB-C de los móviles no encajan. Algunos clones nuevos traen Micro-USB o USB-C, pero la mayoría siguen siendo mini USB. El motivo más habitual de que la placa no aparezca en la lista de puertos es un cable que solo carga y no tiene hilos de datos: el LED de alimentación se enciende, pero el ordenador no ve la placa. Si el cable está bien, dale la vuelta a la placa y mira el chip que está junto al conector USB. Si pone FT232RL, es un Nano original y su driver suele venir ya en el sistema operativo; si pone CH340G o CH340C, tienes un clon.

Windows 10 y 11 suelen instalar el driver del CH340 por su cuenta mediante Windows Update, y la placa aparece en el Administrador de dispositivos con un nombre como USB-SERIAL CH340 (COM3). Si ves un USB2.0-Serial con un signo de exclamación amarillo en Otros dispositivos, instala el driver CH341SER del fabricante del chip, WCH, y desconecta y vuelve a conectar la placa. Las versiones actuales de macOS ya incluyen el driver; el puerto aparece como /dev/cu.usbserial-…, e instalar además drivers antiguos puede provocar conflictos. En Linux el driver viene en el núcleo; si en Ubuntu 22.04 o posterior el puerto desaparece nada más conectar la placa, el paquete lector de pantalla brltty se está apropiando del CH340, y si no lo usas puedes quitarlo con sudo apt remove brltty. Todos los problemas de puerto y driver están en Error al subir código a Arduino, y las diferencias entre chips USB-serie en Conversores USB-TTL.

Subir código: ¿ATmega328P u Old Bootloader?

1. En el Arduino IDE, elige Herramientas > Placa > Arduino AVR Boards > Arduino Nano.
2. Conecta la placa y elige en Herramientas > Puerto el puerto que acaba de aparecer (por ejemplo COM3 en Windows o /dev/cu.usbserial-… en macOS).
3. En Herramientas > Processor, prueba primero a cargar el ejemplo Blink con la opción ATmega328P.
4. Si la salida repite programmer is not responding o not in sync durante diez intentos, cambia Processor a ATmega328P (Old Bootloader) y vuelve a cargar.
5. Si sigue sin funcionar, prueba otro puerto USB, quita los cables de D0 y D1 y comprueba que el LED L parpadea rápido al pulsar el botón de reset.
6. Apunta qué opción ha funcionado; otros Nano del mismo vendedor probablemente necesitarán el mismo ajuste.

El motivo de este lío es un cambio de 2018. Arduino sustituyó el antiguo bootloader de 2 KB del Nano (ATmegaBOOT) por el Optiboot de 512 bytes que usa el Uno. Optiboot recibe el código a 115200 baudios, mientras que el bootloader antiguo espera 57600; si las velocidades no coinciden, parece que la placa no responde. Como los fabricantes de clones siguieron usando el bootloader antiguo durante años, el IDE ofrece las dos opciones, y elegir la equivocada no daña la placa. Si quieres, puedes usar un segundo Arduino como ArduinoISP para grabar el nuevo bootloader en el Nano: las cargas son más rápidas y desaparece también el bucle de reinicios infinito que sufre el bootloader antiguo tras un reset del watchdog.

Colocación en la protoboard y soldadura

Al pinchar el Nano en la protoboard, colócalo de modo que las dos filas de pines queden a ambos lados del canal central. Así cada pin cae en su propia tira y puedes conectar cables a ese pin por los agujeros libres de la tira. Como la placa tapa el canal y los agujeros que hay entre los pines, junto a cada pin solo quedan unos pocos agujeros; en las protoboards habituales de 830 puntos, si centras la placa sobre el canal quedan 2 agujeros libres en un lado y 3 en el otro. Si orientas el conector USB hacia el lado corto de la protoboard, el cable entra cómodamente. Después conecta los pines 5V y GND del Nano a las líneas de alimentación roja y azul de la protoboard para alimentar desde ahí los sensores. Si quieres repasar cómo está conectada una protoboard por dentro, mira Qué es una protoboard.

• Soldar las tiras de pines: En los clones que vienen con los pines sueltos, pincha primero las tiras macho en la protoboard, apoya el Nano encima y suéldalo así; la protoboard mantiene las tiras rectas y exactamente a 0,6 pulgadas. La técnica la tienes en Cómo soldar.
• Al sacarlo: Levantar la placa por un extremo dobla los pines; levanta los dos extremos poco a poco o mete un destornillador plano por debajo y sácala con fuerza uniforme.
• Falsos contactos: En protoboards viejas o baratas los muelles se aflojan; el Nano se reinicia de vez en cuando o un sensor se pierde a ratos. Prueba a mover la placa a otra zona de la protoboard.
• Placa de expansión para Nano: En un proyecto definitivo, un Nano I/O shield con bornas de tornillo o conectores de 3 pines que da señal, 5V y GND para cada pin reduce mucho el lío de cables.
• Mini protoboard: Las protoboards pequeñas de 170 puntos no tienen líneas de alimentación; lleva 5V y GND a tiras separadas y márcalas con colores de cable.

Tabla de equivalencia de pines entre Arduino Uno y Nano

Como ves en la tabla, para pasar al Nano un circuito montado para el Uno basta con conectar los cables a los pines con el mismo número: un servo en D9 del Uno va a D9 del Nano, y una pantalla I2C en A4/A5 sigue en A4/A5. El único cambio en el código es elegir Arduino Nano en Herramientas > Placa. Eso sí, los shields que se encajan directamente en el Uno no se pueden poner en el Nano; para eso existen placas adaptadoras que convierten el Nano a la distribución de pines del Uno. Encontrarás la función detallada de cada pin del Uno en Pines del Arduino Uno, y ayuda para elegir placa en ¿Qué Arduino comprar?.

Nano Every y Nano ESP32: diferencias con el Nano clásico

El Nano Every es una versión más potente del Nano clásico con el mismo tamaño y la misma distribución de pines. Lleva un ATmega4809, funciona a 5 V y ofrece 48 KB de flash y 6 KB de SRAM, así que los proyectos con pantallas OLED o tiras LED que se quedan cortos de RAM en el Nano clásico respiran mejor. En el lado USB, un chip SAMD11 hace de puente y el código se carga por la interfaz UPDI, así que no hay líos con el Old Bootloader. Para usar la placa tienes que instalar el paquete Arduino megaAVR Boards desde el Gestor de placas. Las diferencias que debes tener en cuenta son estas: el PWM solo está en D3, D5, D6, D9 y D10 (D11 no tiene PWM), A6 y A7 también funcionan como digitales, cualquier pin digital puede usarse como interrupción externa y D0 y D1 son un puerto Serial1 independiente del USB. El ajuste Herramientas > Registers emulation > ATMEGA328 emula registros de puerto como PORTB, pero el código antiguo que escribe directamente en registros de temporizadores o del ADC sigue sin funcionar. El programa de abajo muestra dos diferencias del Every a la vez: habla con un módulo en D0/D1 con el Monitor Serie abierto y usa A7 como entrada de pulsador con la pull-up interna.

1// Nano Every: Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2const byte BUTTON_PIN = A7;            // Every'de A7 dijital de çalışır / A7 also works as digital on the Every
3
4bool lastState = HIGH;
5
6void setup() {
7  Serial.begin(9600);                  // Seri Monitör / Serial Monitor
8  Serial1.begin(9600);                 // D0/D1'deki modül, ör. HC-05 / module on D0/D1, e.g. HC-05
9  pinMode(BUTTON_PIN, INPUT_PULLUP);   // klasik Nano'nun A7'sinde çalışmaz / does not work on the classic Nano's A7
10}
11
12void loop() {
13  if (Serial1.available()) {
14    Serial.write(Serial1.read());      // modülden bilgisayara / module to computer
15  }
16  if (Serial.available()) {
17    Serial1.write(Serial.read());      // bilgisayardan modüle / computer to module
18  }
19  bool state = digitalRead(BUTTON_PIN);
20  if (state != lastState) {            // durum değişince bildir / report when the state changes
21    lastState = state;
22    Serial1.println(state == LOW ? "Buton basildi / Button pressed" : "Buton birakildi / Button released");
23    delay(20);                         // kontak sıçraması / contact bounce
24  }
25}

El Nano ESP32, en cambio, es un mundo totalmente distinto con el mismo tamaño: el procesador ESP32-S3 del módulo u-blox NORA-W106 funciona a 240 MHz y ofrece Wi-Fi y Bluetooth LE. La diferencia más importante es la tensión: todos los pines trabajan a 3,3 V y no toleran 5 V, así que un sensor con salida de 5 V que conectarías directamente a un Nano clásico puede dañar el Nano ESP32. Donde el Nano clásico tiene el pin 5V hay un pin VBUS, que solo da 5 V cuando la placa se alimenta por USB; si la alimentas por VIN, este pin queda sin tensión. En el lugar de AREF y del pin RST del lado analógico encontrarás BOOT0 y BOOT1. La placa se programa con el paquete Arduino ESP32 Boards, y el menú Herramientas > Pin Numbering tiene dos opciones: con la opción por defecto, By Arduino pin, valen los nombres D y A impresos en la placa; con By GPIO number, los números son los GPIO del ESP32. Por ejemplo, D2 es en realidad el GPIO5; en modo GPIO, si escribes pinMode(2, OUTPUT) estarás configurando el pin A1. Si escribes siempre los pines por su nombre, como D2 y A0, tu código funcionará bien en los dos modos.

1// Nano ESP32: Araçlar > Pin Numbering > By Arduino pin (default)
2// Nano ESP32: Tools > Pin Numbering > By Arduino pin (default)
3bool ledOn = false;
4
5void setup() {
6  Serial.begin(115200);                // USB-C üzerinden / over USB-C
7  pinMode(LED_BUILTIN, OUTPUT);        // D13 = GPIO48
8  pinMode(LED_RED, OUTPUT);
9  pinMode(LED_GREEN, OUTPUT);
10  pinMode(LED_BLUE, OUTPUT);
11  digitalWrite(LED_RED, HIGH);         // RGB LED ters mantık: HIGH = sönük / active low: HIGH = off
12  digitalWrite(LED_GREEN, HIGH);
13  digitalWrite(LED_BLUE, HIGH);
14  analogReadResolution(12);            // 0-4095 arası / range 0-4095
15}
16
17void loop() {
18  int raw = analogRead(A0);            // 12 bit ham değer / 12-bit raw value
19  int mv = analogReadMilliVolts(A0);   // kalibre edilmiş milivolt / calibrated millivolts
20  Serial.printf("A0: %d  (%d mV)\n", raw, mv);
21  digitalWrite(LED_GREEN, mv > 1650 ? LOW : HIGH);   // 1,65 V üstünde yeşil / green above 1.65 V
22  digitalWrite(LED_RED, mv > 1650 ? HIGH : LOW);     // altında kırmızı / red below
23  ledOn = !ledOn;
24  digitalWrite(LED_BUILTIN, ledOn ? HIGH : LOW);     // D13 LED'ini yakıp söndür / blink the D13 LED
25  delay(500);
26}

Las entradas analógicas del Nano ESP32 miden con 12 bits y devuelven valores de 0 a 4095, mientras que analogReadMilliVolts() usa los datos de calibración del chip para dar el resultado directamente en milivoltios. El LED RGB de la placa funciona con lógica invertida, es decir, se enciende al escribir LOW. Si el código no se carga y la placa desaparece de la lista de puertos, puedes ponerla en modo bootloader pulsando el botón de reset dos veces seguidas rápidamente. Para conocer la parte Wi-Fi del ESP32, consulta Qué es el ESP32, y para decidirte entre placas, ¿Arduino o ESP32?. Entre los demás miembros de la familia, el Nano R4 lleva el mismo Renesas RA4M1 a 48 MHz del Uno R4 al formato Nano de 5 V, pero solo da 8 mA por pin, mientras que el Nano 33 IoT y el Nano 33 BLE son placas de 3,3 V como el Nano ESP32.

Ideas de proyectos con Arduino Nano

• Termómetro de bolsillo: Muestra la temperatura medida con un DHT11 en una pequeña pantalla OLED; el Nano y la pantalla caben en una caja de cerillas.
• Mini coche robot: El pequeño tamaño del Nano ahorra espacio en el chasis; controla los motores con un L298N y sigue los pasos de Cómo hacer un coche robot.
• Robot sigue líneas: Ocho entradas analógicas sobran para leer una regleta de cinco sensores; tienes los detalles en Robot sigue líneas.
• Mando Bluetooth: Conecta un módulo HC-05 a D8 y D7 con SoftwareSerial y controla un LED o un relé desde el móvil; D0 y D1 quedan libres para cargar programas.
• Luz ponible: Haz una acreditación luminosa o una luz para la mochila con un Nano a pilas y unos cuantos LED WS2812B.
• Teclado en un solo pin: Monta la escalera de resistencias de arriba en A6 y en A7 para tener un menú de ocho botones y reserva los pines digitales para la pantalla y los motores.
• ¿Quieres un teclado USB? El ATmega328P del Nano clásico no tiene USB integrado, así que no puede presentarse al ordenador como teclado o ratón; para eso necesitas placas con ATmega32U4 como el Leonardo y el Pro Micro.

Errores frecuentes y cómo solucionarlos

El Arduino Nano es la forma más fácil de llevar todo lo que has aprendido con el Uno a proyectos pequeños y definitivos; mientras conozcas las diferencias de A6/A7, 3V3 y el bootloader, no tendrás sorpresas. Si quieres volver a lo básico, empieza por Qué es Arduino. En la app BlueGrays encontrarás, paso a paso y con esquemas y código listo, proyectos para encender un LED, un LED con pulsador, medir luz con una LDR, distancia con el HC-SR04, temperatura y humedad con el DHT11, un LED RGB, un servo con potenciómetro y comunicación serie entre dos Arduino; todos funcionan en el Nano con los mismos números de pin.