LED (diodo emisor de luz)

El LED es el actuador más simple y didáctico para Arduino: convierte corriente eléctrica en luz mediante la recombinación de portadores en un diodo semiconductor. Es ideal para indicadores, señales de estado y aprendizaje de electrónica básica, pero tiene límites claros en corriente, tensión y potencia que hay que respetar para no dañar ni al LED ni al microcontrolador.

Cómo funciona (detallado, con física práctica)

Estructura física: un LED es un diodo semiconductor con un ánodo (positivo) y un cátodo (negativo). Cuando se aplica tensión directa (forward), los electrones y huecos se recombinan en la unión p–n y liberan energía en forma de fotones (luz). El color depende del material y del gap (energía de banda) del semiconductor.
Característica V–I: el LED no se comporta como una resistencia lineal; tiene una caída de tensión directa (V_f) (p. ej. ≈2.0 V para rojos clásicos, ≈3.0–3.3 V para azules/blancos) y luego la corriente sube rápidamente. Por eso siempre se usa una resistencia limitadora de corriente en serie o un driver constante de corriente.
Control con Arduino: un pin digital del Arduino puede colocar la salida en HIGH (5 V o 3.3 V según la placa) o LOW (0 V). Para encender un LED se conecta su ánodo al pin (o a Vcc con el pin a GND para sinking), y el cátodo a GND a través de una resistencia; o viceversa. El ejemplo más elemental es el tutorial Blink (ejecuta digitalWrite(pin, HIGH/LOW) y delay() para ver el LED parpadear).

Alcances (qué se puede lograr con un LED)

Indicadores de estado (power, error, actividad de red, etc.).
Retroalimentación visual en interfaces físicas (botones, sensores).
Prototipado pedagógico: enseñar tiempos, PWM para dimming, multiplexado simple y control por transistores.

Limitaciones importantes (para no romper nada)

Corriente por pin del microcontrolador: las I/O del AVR (Arduino Uno clásico con ATmega328P) tienen un valor recomendado de operación alrededor de 20 mA por pin y un límite absoluto cercano a 40 mA por pin; además existe un límite total para el paquete (p. ej. ~200 mA). Por seguridad se recomienda diseñar para 5–20 mA por LED y usar transistores/drivers si necesita más.
Caída de tensión y potencias: cada LED tiene (V_f) y corriente máxima (I_{max}) (consúltese la hoja de datos). Sin resistencia / control de corriente el LED consumirá demasiado y se quemará.
Brillo limitado por corriente: para mayor brillo conviene alimentar LED desde una fuente externa o usar drivers; no abuses de los pines del Arduino.
PWM y parpadeo visible: para atenuar se usa PWM (p. ej. analogWrite() en pines PWM). El parpadeo a frecuencias bajas es visible; para aplicaciones donde la luz debe ser continua usar frecuencias altas (>1 kHz) o drivers adecuados.
Durabilidad: subjectivo al calor y corriente; operar dentro de la corriente recomendada y con disipación correcta alarga la vida.

Cálculo práctico: resistencia limitadora (ejemplo paso a paso)

Planteo: Arduino Uno (5,00 V), LED rojo con (V_f = 2,00\ \text{V}), corriente deseada (I = 10{,}0\ \text{mA} = 0{,}010\ \text{A}).
Fórmula: (R = \dfrac{V_{CC} – V_f}{I}).

Cálculo digitado paso a paso:

(V_{CC} – V_f = 5{,}00 – 2{,}00 = 3{,}00) (voltios).
(I = 0{,}010) (amperios).
(R = 3{,}00 \div 0{,}010).
— divido: (3{,}00 \div 0{,}010 = 300).
Resultado: R = 300 Ω → el valor comercial más cercano: 330 Ω (seguro).

Comprobación de potencia del resistor: (P = I^2 \times R).

(I^2 = 0{,}010 \times 0{,}010 = 0{,}000100).
(P = 0{,}000100 \times 300 = 0{,}030) W = 30 mW → una resistencia estándar de 1/4 W (0,25 W) es más que suficiente.

3 ejemplos de aplicaciones reales del módulo LED con Arduino

Panel de estado de un prototipo IoT (indicadores RGB o múltiples LEDs):
- Uso: cada LED muestra estado (conectado, error, transmisión). Control mediante pines digitales o a través de un shift register o LED driver para muchos LEDs. Para más de ~10 LEDs usar expansores/driver para no agotar pines ni corriente del MCU.
Sistema de iluminación por PWM para una maqueta (dimming):
- Uso: controlar intensidad de LEDs blancos usando PWM (analogWrite) para simular día/noche o escenas. Si se necesita corriente elevada, usar MOSFETs o drivers de corriente constante. (Ejemplo en tutoriales de Arduino y Adafruit sobre uso de PWM y control de brillo).
Señalización rápida en control industrial ligero (alarma/backup):
- Uso: LEDs de alto brillo como avisos visuales, con control por Arduino que monitorea sensores y activa patrones de parpadeo o secuencias. Para tensión/corriente mayores, integrar relé/driver/transistor y alimentación externa.

Esquema y código de ejemplo (mínimo, seguro)

Circuito: Arduino UNO pin digital 9 → resistencia 330 Ω → ánodo LED → cátodo → GND.
Código (Blink con PWM para atenuar):

const int ledPin = 9; // pin PWM

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

void loop() {
  // subir brillo
  for (int v = 0; v <= 255; v += 5) {
    analogWrite(ledPin, v);
    delay(20);
  }
  // bajar brillo
  for (int v = 255; v >= 0; v -= 5) {
    analogWrite(ledPin, v);
    delay(20);
  }
  delay(200);
}

(usa 330 Ω en serie; ajusta corriente deseada cambiando resistencia).

3 fuentes recomendadas para profundizar

Tutorial Blink y ejemplos oficiales de Arduino — explicación práctica de digitalWrite, analogWrite y ejemplos básicos. (arduino.cc)
Adafruit — «All About LEDs» / guía de resistencias — fundamentos de LEDs, cálculo de resistencias y buenas prácticas. (Adafruit)
SparkFun — tutoriales sobre LEDs y resistores (Ohm’s Law aplicado) — orientación práctica y ejemplos. (SparkFun Learn)

Prompt para que el lector construya su propio código con ayuda de IA

Prompt (pégalo en un chat con una IA):
«Ayúdame a generar código Arduino para controlar uno o varios LEDs. Requisitos: indicar número de LEDs, tipo (individual simple / RGB / tira WS2812), alimentación (5 V interno o fuente externa), tensión y Vf conocida de los LEDs, corriente objetivo por LED en mA, si quiero PWM para dimming, y si necesito protección extra (transistores/MOSFETs o drivers). Devuélveme: 1) esquema de conexión claro (texto + lista de pines), 2) cálculo de la resistencia en serie para cada LED paso a paso usando Ohm, 3) código Arduino comentado (setup + loop + funciones auxiliares) listo para compilar, 4) advertencias de seguridad (límites de corriente por pin, uso de fuentes externas, referencias a datasheets), y 5) opciones para escalar a muchos LEDs (shift register, WS2812 con librería FastLED, o drivers dedicados).”

Puedes ajustar el prompt p. ej. cambiando: “corriente objetivo” a 5 mA para indicaciones de bajo consumo, o especificando frecuencia PWM para evitar parpadeo visible.