¿Cómo controlar LEDs y salidas digitales con Arduino?

Una salida digital de Arduino es un pin que puede enviar dos estados: HIGH (5V) o LOW (0V), lo que te permite encender o apagar dispositivos como LEDs, buzzers y relevadores.

Qué es una salida digital

Cada pin digital de Arduino puede funcionar como entrada o salida. Cuando lo configuras como salida, tú controlas si el pin entrega voltaje o no.

El estado HIGH envía 5 voltios al pin. El estado LOW lo pone a 0 voltios (tierra).

Componentes que necesitas

Para practicar esta lección necesitas lo siguiente:

Puedes conseguir estos componentes en tiendas de electrónica en línea como Mercado Libre México por menos de $200 en total.

Por qué el LED necesita una resistencia

Un LED sin resistencia recibe demasiada corriente y se quema en segundos. La resistencia limitadora reduce la corriente a un nivel seguro.

Usa siempre una resistencia de 220 Ω cuando conectes un LED a un pin de 5V de Arduino. Sin ella, también puedes dañar el pin del microcontrolador.

Cómo conectar el circuito

Sigue estos pasos para armar el circuito en la protoboard:

1. Conecta el ánodo del LED (pata larga) a la resistencia de 220 Ω.
2. Conecta el otro extremo de la resistencia al pin 13 de Arduino.
3. Conecta el cátodo del LED (pata corta) a cualquier pin GND de Arduino.
4. Conecta Arduino a tu computadora con el cable USB.

Eso es todo. No necesitas fuente de alimentación externa para este circuito.

Las funciones clave: pinMode, digitalWrite y delay

Tres funciones controlan este circuito desde el código.

pinMode(pin, modo) — Configura un pin como entrada o salida. digitalWrite(pin, valor) — Envía HIGH o LOW al pin. delay(milisegundos) — Pausa el programa por el tiempo indicado.

Estas funciones ya las viste en la lección anterior con el LED integrado del pin 13. Ahora las aplicarás con un LED externo en un circuito real.

El proyecto Blink: encender y apagar un LED

El proyecto Blink es el "Hola, mundo" de Arduino. El siguiente código enciende el LED durante 1 segundo y lo apaga otro segundo, en ciclo infinito.

// Blink básico - LED en pin 13
void setup() {
  pinMode(13, OUTPUT); // Configura pin 13 como salida
}

void loop() {
  digitalWrite(13, HIGH); // Enciende el LED
  delay(1000);             // Espera 1 segundo
  digitalWrite(13, LOW);  // Apaga el LED
  delay(1000);             // Espera 1 segundo
}

Sube este sketch y verás el LED parpadear cada segundo.

Variación 1: Cambiar la velocidad del parpadeo

Puedes hacer que el LED parpadee más rápido o más lento cambiando los valores de delay(). El valor está en milisegundos: 1,000 ms = 1 segundo.

// Blink rápido - 200 ms encendido, 200 ms apagado
void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(200); // 0.2 segundos
  digitalWrite(13, LOW);
  delay(200);
}

Este parpadeo simula una luz de alerta rápida, como las que ves en señales industriales.

Variación 2: Patrón asimétrico

No tienes que usar el mismo tiempo de encendido y apagado. Puedes crear patrones diferentes.

// LED encendido 900 ms, apagado 100 ms
void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(900); // Casi siempre encendido
  digitalWrite(13, LOW);
  delay(100); // Apagado muy breve
}

Este patrón se usa en indicadores de estado que deben verse casi siempre encendidos, como un piloto de "sistema activo".

Variación 3: Controlar múltiples LEDs

Puedes controlar varios LEDs usando diferentes pines digitales. Cada LED necesita su propia resistencia.

Conecta un segundo LED (con su resistencia) al pin 12 y usa este código:

// Dos LEDs alternos - pines 12 y 13
void setup() {
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH); // Enciende LED 1
  digitalWrite(12, LOW);  // Apaga LED 2
  delay(500);

  digitalWrite(13, LOW);  // Apaga LED 1
  digitalWrite(12, HIGH); // Enciende LED 2
  delay(500);
}

Este patrón alterno es común en señales de cruce peatonal y en decoraciones de tiendas como Liverpool durante temporada navideña.

Cómo usar una variable para el número de pin

En lugar de escribir el número de pin directamente en cada función, guárdalo en una variable constante. Esto hace tu código más fácil de modificar.

const int pinLED = 13; // Define el pin una sola vez

void setup() {
  pinMode(pinLED, OUTPUT);
}

void loop() {
  digitalWrite(pinLED, HIGH);
  delay(1000);
  digitalWrite(pinLED, LOW);
  delay(1000);
}

Si cambias el LED al pin 7, solo modificas una línea: const int pinLED = 7;. No tienes que buscar y cambiar el número en todo el código.

Errores comunes

Error 1: Conectar el LED al revés

El LED tiene polaridad. Si lo conectas al revés, simplemente no enciende. No se daña, pero tampoco funciona. Siempre conecta la pata larga (ánodo) hacia el pin de señal y la pata corta (cátodo) hacia GND.

Error 2: Olvidar la resistencia limitadora

Conectar un LED directamente entre un pin y GND sin resistencia puede quemar el LED y dañar el pin de Arduino. Nunca omitas la resistencia de 220 Ω.

Error 3: Usar delay() con valores muy altos por error

Si escribes delay(10000) creyendo que son 10 milisegundos, tu programa parecerá congelado durante 10 segundos. Recuerda: el valor está siempre en milisegundos. delay(1000) = 1 segundo.

Error 4: No declarar el pin como OUTPUT en setup()

Si omites pinMode(13, OUTPUT), el pin queda en modo indefinido y el LED puede comportarse de forma errática o no encender. Siempre declara el modo del pin en setup().

Error 5: Confundir GND con los pines de 3.3V o 5V

En la placa Arduino hay varios pines de alimentación juntos. El pin GND es tierra. Si por error conectas el cátodo del LED a 5V en vez de GND, no habrá diferencia de potencial y el LED no enciende.

Tabla de referencia rápida

Pines digitales disponibles en Arduino Uno

Arduino Uno tiene 14 pines digitales numerados del 0 al 13. Los pines 0 y 1 se usan para comunicación serial, así que en práctica tienes 12 pines libres para salidas. Cada pin puede entregar hasta 40 mA de corriente, suficiente para uno o dos LEDs con resistencia.

Resumen del flujo de trabajo

Cada vez que quieras controlar un LED con Arduino, sigue este orden:

1. Conecta el circuito: LED + resistencia + pin + GND.
2. Declara el pin como OUTPUT en setup().
3. Usa digitalWrite() para encender o apagar en loop().
4. Controla el tiempo con delay().
5. Sube el sketch y verifica el comportamiento.

Este mismo flujo aplica para controlar otros dispositivos simples: buzzer, motor pequeño con transistor, o un relevador para cargas más grandes.