Pines del Arduino Uno: digitales, PWM, analógicos y alimentación

Los pines del Arduino Uno son los 32 puntos de conexión alineados en los conectores hembra negros de los dos bordes largos de la placa: 14 pines digitales de entrada/salida (0–13), de los cuales 6 pueden dar PWM (~3, 5, 6, 9, 10, 11), 6 entradas analógicas (A0–A5) y los pines de alimentación que alimentan la placa o dan energía a otros componentes (Vin, 5V, 3.3V, GND, IOREF, AREF, RESET). Cada pin tiene una función principal, pero muchos tienen además una segunda: A4 y A5 son también el bus I2C, del 10 al 13 forman el bus SPI, el 2 y el 3 son pines de interrupción, y el 0 y el 1 son la línea serie que habla con tu ordenador.

Elegir el pin correcto marca la diferencia entre un proyecto que funciona a la primera y horas buscando fallos. Con las tablas de este artículo entenderás fácilmente por qué el PWM de los pines 9 y 10 deja de funcionar al conectar un servo, por qué el sketch no se sube mientras hay un módulo Bluetooth conectado o por qué unos cuantos LED pueden sobrecargar la placa. Al final encontrarás también un código de prueba que usa todos los tipos de pin a la vez, un plan de pines de ejemplo y las diferencias de pines entre el Uno R3 y el R4.

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

Coloca la placa delante de ti con el conector USB y el jack de alimentación a la izquierda. Los dos conectores del borde superior llevan los pines digitales; los números aumentan de derecha a izquierda, así que el pin de más a la derecha es el 0 (RX) y el pin digital de más a la izquierda es el 13. En el borde inferior, el conector de la izquierda lleva los pines de alimentación y el de la derecha las entradas analógicas. La ~ (virgulilla) junto a un número indica que ese pin puede dar PWM. El grupo de 2×3 pines macho del borde derecho es el conector ICSP.

La gran tabla de pines: D0–D13 y A0–A5

¿Cómo funcionan los pines digitales (0–13)?

Cada pin digital se configura como entrada o salida con pinMode(). Como salida, digitalWrite(pin, HIGH) lleva el pin a unos 5 V y LOW a 0 V. Como entrada, digitalRead() compara la tensión con un umbral: con el ATmega328P funcionando a 5 V, todo lo que supera 3,0 V es un HIGH seguro, lo que está por debajo de 1,5 V es un LOW seguro y lo de en medio es una zona indefinida. Por eso la salida de un sensor de 3,3 V suele leerse como HIGH en el Uno; pero la salida de 5 V del Uno no debe ir directamente a la entrada de un módulo de 3,3 V, entre ambos hace falta un convertidor de nivel lógico.

Un pin de entrada que no está conectado a nada queda flotante y lee HIGH y LOW al azar, incluso al acercar la mano. La solución es llevar el pin a un nivel fijo con una resistencia: pinMode(pin, INPUT_PULLUP) activa la resistencia de 20–50 kΩ que hay dentro del chip, y el pulsador se conecta entre el pin y GND. Tienes los detalles en Cómo conectar un pulsador a Arduino. El pin 13 está conectado al LED L de la placa; en el R3 original ese LED se controla a través de un amplificador operacional que hace de búfer, así que usar el pin como entrada no da problemas, pero en algunos clones el LED y su resistencia van directos al pin y pueden estropear la lectura de un pulsador con el pull-up interno.

Pines PWM (~3, 5, 6, 9, 10, 11) y temporizadores

El Uno no puede generar una salida analógica real; en su lugar, estos seis pines dan PWM, una onda cuadrada que se enciende y se apaga muy rápido. Con analogWrite(pin, valor) ajustas entre 0 y 255 cuánto tiempo permanece encendida la onda: 0 es totalmente apagado, 127 más o menos la mitad y 255 totalmente encendido. Así se controlan el brillo de un LED, la velocidad de un motor y la de un ventilador. Los seis pines PWM están unidos de dos en dos a tres temporizadores (timers) de hardware, y esa es la causa de los conflictos con algunas librerías. La idea del PWM y el cálculo del ciclo de trabajo se explican en ¿Qué es PWM?.

Pines analógicos (A0–A5) y AREF

Los pines analógicos miden una tensión entre 0 y 5 V con una resolución de 10 bits, y analogRead() devuelve un número de 0 a 1023. Cada paso equivale a unos 4,9 mV; para pasar el número a voltios usa tensión = valor × 5,0 / 1023, de modo que una lectura de 512 significa unos 2,5 V. Los seis pines comparten por turnos un único ADC, y cada lectura tarda unos 100 µs, lo que permite unas 10.000 lecturas por segundo. Para medir bien, la impedancia de salida del sensor no debería superar los 10 kΩ; si es mayor, al leer dos pines seguidos los valores pueden mezclarse, y descartar la primera lectura y usar la segunda lo soluciona. Para medir tensiones de más de 5 V, elige las resistencias adecuadas con la calculadora de divisor de tensión.

El pin AREF sirve para cambiar el límite superior de la medida analógica. analogReference(DEFAULT) usa 5 V, analogReference(INTERNAL) la referencia interna de 1,1 V del chip y analogReference(EXTERNAL) la tensión que aplicas al pin AREF (0–5 V) como tope. Con un sensor que da 0–1 V, la referencia de 1,1 V reduce cada paso a unos 1,1 mV y hace la medida unas 4,5 veces más fina. Componentes como potenciómetros, LDR y sensores de humedad del suelo se conectan a estos pines; los detalles de la conversión analógico-digital están en el artículo sobre el ADC y un ejemplo práctico en el artículo del potenciómetro.

Pines de alimentación: Vin, 5V, 3.3V, GND, IOREF y RESET

El Uno se puede alimentar de tres formas. Por USB, la placa toma 5 V directamente del ordenador y un fusible rearmable de 500 mA protege el puerto. Si das 7–12 V por el jack DC o por Vin, el regulador de la placa los baja a 5 V; si están conectados ambos, la placa pasa sola a la alimentación externa cuando Vin supera unos 6,6 V. Como el regulador convierte en calor la tensión sobrante, con 12 V de entrada se calienta rápido si sacas unos cientos de mA del pin 5V. Lo más sano es alimentar cargas como servos, motores y tiras LED desde una fuente aparte y unir solo los GND. Para elegir batería y calcular la autonomía usa la calculadora de duración de batería, y lee todas las formas de alimentación en Cómo alimentar un Arduino.

¿Por qué hay que dejar libres los pines 0 y 1?

Los pines 0 (RX) y 1 (TX) son el único puerto serie por hardware del ATmega328P y en la placa están conectados mediante resistencias de 1 kΩ al chip convertidor USB-serie (ATmega16U2). Tu ordenador usa estos dos pines al subir el código y al enviar texto al Monitor Serie. Si el TX de un módulo Bluetooth u otra señal está conectado al pin 0, las dos fuentes se pelean por la misma línea y la carga se detiene con avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00. Además, el pin 1 cambia rápidamente cada vez que se ejecuta Serial.print(), así que un LED o un relé conectado ahí se activa al azar.

Por eso, deja libres el 0 y el 1 mientras te queden otros pines. Si vas a conectar un módulo serie como un HC-05, un GPS o un reproductor MP3, la librería SoftwareSerial crea un segundo puerto serie en otros dos pines. El siguiente código conecta el módulo a los pines 8 (RX) y 7 (TX): envía al módulo lo que escribes en el Monitor Serie y al ordenador lo que llega del módulo. Con módulos de lógica de 3,3 V como el HC-05, conecta la salida TX del Uno (pin 7) al pin RX del módulo a través de un divisor de tensión. Todas las soluciones a los problemas de carga están en Arduino no sube el código y la lógica de la comunicación serie en Comunicación serie UART.

1#include <SoftwareSerial.h>
2
3SoftwareSerial moduleSerial(8, 7);   // RX = 8, TX = 7; 0 ve 1 boş kalır / 0 and 1 stay free
4
5void setup() {
6  Serial.begin(9600);                // USB üzerinden bilgisayar / computer over USB
7  moduleSerial.begin(9600);          // HC-05 veri modu hızı / HC-05 data mode baud rate
8  Serial.println(F("Seri kopru hazir / Serial bridge ready"));
9}
10
11void loop() {
12  if (moduleSerial.available()) {
13    Serial.write(moduleSerial.read());   // modülden bilgisayara / module to computer
14  }
15  if (Serial.available()) {
16    moduleSerial.write(Serial.read());   // bilgisayardan modüle / computer to module
17  }
18}

Pines de comunicación: I2C (A4/A5), SPI (10–13) y pines de interrupción (2, 3)

I2C te permite conectar decenas de dispositivos al mismo bus con solo dos cables (SDA y SCL); pantallas LCD, OLED, módulos de reloj RTC y sensores como el BME280 lo usan. En el Uno, SDA = A4 y SCL = A5. En las placas R3, los pines SDA y SCL que están junto a AREF no son un bus aparte, están conectados por dentro a A4 y A5, así que mientras usas I2C no puedes usar A4 y A5 para lecturas analógicas. La librería Wire funciona a 100 kHz por defecto y llega a 400 kHz con Wire.setClock(400000). Las direcciones, las resistencias pull-up y un escáner I2C están en ¿Qué es I2C?, y un ejemplo práctico en Pantalla LCD I2C.

SPI es más rápido pero necesita más cables: MOSI = 11, MISO = 12, SCK = 13 y SS (CS) = 10. Los módulos de tarjeta SD, los lectores RFID y las pantallas TFT usan SPI. Varios dispositivos pueden compartir el bus: MOSI, MISO y SCK son comunes y cada dispositivo recibe su propio pin CS. Un detalle importante: en modo maestro (master), el pin 10 debe quedarse como salida; si lo pones como entrada y se va a LOW, el ATmega328P se pasa a modo esclavo (slave) y el SPI se detiene. MISO, MOSI y SCK también están en el conector ICSP, y algunos shields toman el SPI de ahí. Para más detalles, consulta ¿Qué es SPI? y RFID RC522.

Una interrupción te permite captar al instante un cambio en un pin, haga lo que haga loop() en ese momento. En el Uno, las interrupciones externas solo están en los pines 2 (INT0) y 3 (INT1): escribes attachInterrupt(digitalPinToInterrupt(2), funcion, FALLING), y el modo de disparo puede ser LOW, CHANGE, RISING o FALLING. Los encoders, sensores de RPM, caudalímetros y pulsadores que no se pueden perder van en estos pines. Los demás pines también tienen "interrupciones por cambio de pin" (PCINT), pero los pines de un mismo puerto comparten una sola función de interrupción y tu código tiene que averiguar qué pin cambió. Las reglas y los ejemplos están en Interrupciones en Arduino.

Al pasar al ESP32 o a la Pico, la mayor diferencia es la tensión: las dos placas funcionan a 3,3 V y sus pines no toleran 5 V, así que los módulos de 5 V que conectas directamente al Uno pueden necesitar un convertidor de nivel. A cambio, estas placas tienen interrupciones y PWM en casi todos los pines, y los buses I2C y SPI se pueden mover a otros pines. Para comparar las placas, lee ¿Arduino Uno o ESP32?, y para ver los mapas de pines usa la herramienta de pinout; las placas en sí se explican en ¿Qué es el ESP32? y ¿Qué es la Raspberry Pi Pico?.

¿Para qué sirve el conector ICSP?

ICSP (In-Circuit Serial Programming) es un conector de 2×3 que sirve para programar el microcontrolador directamente por las líneas SPI, sin USB ni bootloader. El ICSP del borde derecho pertenece al ATmega328P, y el pequeño ICSP1 junto al conector USB pertenece al chip USB-serie (ATmega16U2). En el día a día no lo tocarás, pero el ICSP entra en juego cuando el bootloader se corrompe, cuando grabas un bootloader en un ATmega328P nuevo o cuando subes código con un programador como el USBasp. Si conviertes un segundo Uno en programador con el ejemplo ArduinoISP, sus pines 10, 11, 12 y 13 van a RESET, MOSI, MISO y SCK de la placa de destino, y un condensador de 10 µF entre RESET y GND en el Uno programador evita su reinicio automático. Para saber si tu placa ha sufrido daños, echa un vistazo a ¿Se ha quemado mi Arduino?.

20 mA por pin, 200 mA en total: límites de corriente

Un pin del Uno trabaja con seguridad hasta 20 mA. Los 40 mA de la hoja de datos del ATmega328P son el máximo absoluto, es decir, el valor por encima del cual el chip puede dañarse de forma permanente, no un valor de trabajo. La corriente total que pasa por los pines VCC y GND del chip no debe superar los 200 mA. La hoja de datos también divide los pines en grupos: al dar corriente (HIGH), D0–D4 junto con A0–A5, y D5–D13 entre sí, deben quedarse cada uno por debajo de 150 mA; al absorber corriente (LOW), los grupos D0–D4, D5–D13 y A0–A5 deben quedarse cada uno por debajo de 100 mA. Si alimentas un LED rojo desde 5 V con una resistencia de 220 Ω, la corriente es (5 − 2) / 220 ≈ 13,6 mA. Diez LED encendidos a la vez suman 136 mA; está por debajo de 200 mA, pero si todos están en el mismo grupo se acercan mucho al límite de 150 mA del grupo. Si los LED se encienden con el pin en LOW (resistencia desde 5V al pin) y la mayoría están en el mismo grupo, se supera el límite de 100 mA. Reparte los LED entre los grupos o sube la resistencia a 330–470 Ω. Encuentra la resistencia adecuada con la calculadora de resistencia para LED o la calculadora de la ley de Ohm.

• Motores: Incluso un motor DC pequeño consume cientos de mA y genera picos de tensión; usa un driver de motor como el L298N o un transistor.
• Bobina de un relé: La bobina de un relé de 5 V consume unos 70–90 mA; usa un módulo de relé con transistor y diodo.
• Servomotores: El cable de señal puede ir a un pin, pero la alimentación del servo debe venir de una fuente aparte, no del pin 5V; los detalles están en el artículo del servomotor.
• Tiras LED y LED de potencia: Las tiras de 12 V y los LED de 1 W necesitan un MOSFET de nivel lógico.
• Cortocircuitos: Conectar directamente a GND una salida en HIGH saca del pin mucho más de 40 mA y lo estropea para siempre.

Código de prueba: usa pines digitales, PWM, analógicos y de interrupción a la vez

1. Conecta un LED al pin 9 con una resistencia de 220 Ω: la pata larga a la resistencia y la corta a GND.
2. Conecta las dos patas exteriores de un potenciómetro a 5V y GND y la del centro a A0.
3. Conecta un pulsador entre el pin 2 y GND; no hace falta resistencia aparte porque se usa el pull-up interno.
4. Sube el código, abre el Monitor Serie y ponlo a 9600 baudios.
5. Gira el potenciómetro: cambia el brillo del LED del pin 9, el LED L de la placa (pin 13) se enciende cuando la tensión pasa de 2,5 V y el contador sube uno con cada pulsación.

1const byte BUTTON_PIN = 2;    // kesme pini INT0 / interrupt pin INT0
2const byte PWM_LED    = 9;    // ~9: PWM çıkışı / PWM output
3const byte STATUS_LED = 13;   // kart üzerindeki L LED'i / onboard L LED
4const byte POT_PIN    = A0;   // analog giriş / analog input
5
6volatile unsigned int pressCount = 0;   // ISR içinde değişir / changed inside the ISR
7
8void onButton() {
9  static unsigned long lastPressMs = 0;
10  unsigned long now = millis();
11  if (now - lastPressMs > 50) {         // 50 ms sıçrama filtresi / 50 ms debounce
12    pressCount++;
13    lastPressMs = now;
14  }
15}
16
17void setup() {
18  Serial.begin(9600);                   // 0 ve 1 numaralı pinleri kullanır / uses pins 0 and 1
19  pinMode(STATUS_LED, OUTPUT);
20  pinMode(PWM_LED, OUTPUT);
21  pinMode(BUTTON_PIN, INPUT_PULLUP);    // dahili pull-up direnci / internal pull-up resistor
22  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButton, FALLING);
23}
24
25void loop() {
26  int raw = analogRead(POT_PIN);        // 0-1023 arası ham değer / raw value 0-1023
27  float volts = raw * 5.0 / 1023.0;     // volta çevir / convert to volts
28  analogWrite(PWM_LED, raw / 4);        // 0-255 arası PWM / PWM from 0 to 255
29  digitalWrite(STATUS_LED, volts > 2.5 ? HIGH : LOW);   // 2,5 V eşiği / 2.5 V threshold
30
31  noInterrupts();                       // sayacı güvenle kopyala / copy the counter safely
32  unsigned int presses = pressCount;
33  interrupts();
34
35  Serial.print(F("A0: "));
36  Serial.print(raw);
37  Serial.print(F("  V: "));
38  Serial.print(volts, 2);
39  Serial.print(F("  Buton / Button: "));
40  Serial.println(presses);
41  delay(200);
42}

El código usa a la vez cuatro tipos de pin del Uno. analogRead(A0) lee un valor de 0 a 1023 y raw / 4 lo reduce al rango 0–255 que espera analogWrite(). Para no contar los rebotes del pulsador, la función de interrupción ignora las señales que llegan menos de 50 ms después de la última pulsación. El contador que cambia dentro de la interrupción se declara volatile, y loop() lo copia pausando las interrupciones un instante, porque el Uno, de 8 bits, lee un número de 16 bits en dos pasos y una interrupción en medio podría dar un valor erróneo. Los pines 0 y 1 solo se usan para Serial, así que no se conecta nada más a ellos.

Plan de pines de ejemplo: ¿qué componente va en cada pin?

Repartir los pines al azar en un proyecto con muchos componentes provoca conflictos. Primero coloca en sus pines los componentes con funciones especiales (I2C, SPI, interrupciones, PWM) y después reparte las tareas digitales sencillas entre los pines libres. Abajo tienes un plan de ejemplo para una cerradura con tarjeta RFID: lector RC522, LCD I2C, servo, zumbador, pulsador y dos LED. Como el servo y tone() se usan juntos, el PWM de los pines 3, 9, 10 y 11 ya queda descartado, y el plan lo tiene en cuenta.

Diferencias de pines entre el Arduino Uno R3 y el R4

En resumen, en el R4 los números y las funciones de los pines no cambian (PWM ~3, 5, 6, 9, 10, 11; I2C A4/A5; SPI 10–13; interrupciones 2, 3), pero la corriente por pin baja a 8 mA. Un LED que en el R3 alimentabas directamente desde un pin necesita en el R4 una resistencia mayor (por ejemplo, 1 kΩ para unos 3 mA) o un transistor. La comparación detallada está en Arduino Uno R4. Si buscas una placa más pequeña, te servirán Pines del Arduino Nano y ¿Qué Arduino comprar?.

Errores frecuentes y cómo solucionarlos

Cuando conoces los pines del Arduino Uno, no necesitas memorizar dónde va cada componente: miras lo que necesita y eliges tú mismo el pin correcto. Si quieres repasar lo básico, empieza por ¿Qué es Arduino?. En la app BlueGrays encontrarás proyectos como encender un LED, leer un pulsador, medir la luz con un LDR, un LED RGB con PWM, una LCD I2C, RFID y dos Arduino comunicándose por una línea serie, todos paso a paso con esquemas que muestran por qué se eligió cada pin y con el código listo.