LEDs: corriente, brillo y color

01 · Punto de partida

Un diodo que emite luz

Hasta ahora los actuadores del curso movían o conmutaban cosas: relés, solenoides, motores. El LED (light emitting diode) es el primer actuador cuya salida es información para una persona: una luz que dice «encendido», «error» o «temperatura alta». Es también el actuador más usado y el más mal conectado, porque se comporta como un diodo: conduce en un sentido, casi no ofrece resistencia cuando conduce y, si se lo conecta directamente a una fuente, la corriente crece hasta que el LED se destruye.

Los tres problemas del LED, en el orden en que se resuelven:

• Corriente: el brillo depende de la corriente, no de la tensión; hay que limitarla (resistencia, driver de corriente constante) y respetar lo que un pin puede entregar.
• Brillo: se regula con PWM, pero el ojo responde a la luz de forma aproximadamente logarítmica, de modo que un ciclo de trabajo del 50 % no se ve «a la mitad».
• Color y cantidad: un LED RGB mezcla tres LEDs con tensiones y eficiencias distintas, y una matriz de 64 LEDs no cabe en 64 pines.

02 · Principio

Tensión directa y corriente

Un LED conduce solo cuando la tensión entre ánodo y cátodo supera su tensión directa V_F (forward voltage). Por debajo, la corriente es despreciable; un poco por encima, crece de forma exponencial. Esa es la clave: una variación de décimas de voltio cambia la corriente varias veces, y por eso el LED no se alimenta con una tensión sino con una corriente.

Dos consecuencias prácticas. La primera: un LED azul o blanco no enciende con una fuente de 3 V aunque la polaridad sea correcta, y con 3,3 V queda al límite. La segunda: V_F baja con la temperatura (unos 2 mV por °C), de modo que un LED alimentado con una tensión casi fija tiende a tomar cada vez más corriente a medida que se calienta, un fenómeno que se retroalimenta. La resistencia en serie corta ese círculo vicioso.

La luz emitida es aproximadamente proporcional a la corriente hasta unos 20 mA en un LED de señalización común; por encima, la eficiencia cae y el calor aumenta. Y como el LED es un diodo, soporta una tensión inversa muy baja (alrededor de 5 V): no hay que conectarlo al revés a una fuente mayor sin protección.

03 · Dimensionado

La resistencia limitadora

La resistencia en serie fija la corriente: la tensión que sobra, después de lo que «consume» el LED, cae sobre ella. Por la ley de Ohm:

Un LED rojo (2,0 V) a 10 mA con una salida de 5 V: R = (5 − 2) / 0,010 = 300 Ω. Ese valor no existe en la serie comercial: se toma el siguiente valor normalizado mayor (la serie E12 tiene 1,0 · 1,2 · 1,5 · 1,8 · 2,2 · 2,7 · 3,3 · 3,9 · 4,7 · 5,6 · 6,8 · 8,2 por década), es decir 330 Ω, que da 9,09 mA. Se redondea hacia arriba porque un LED apenas más tenue pasa inadvertido, y uno sobrecargado se acorta la vida. La potencia es mínima (27 mW), así que alcanza una resistencia de ¼ W.

El caso delicado es cuando la fuente está cerca de V_F. Un LED azul de 3,1 V con una salida de 3,3 V necesitaría R = 0,2 / 0,010 = 20 Ω, pero V_F tiene una dispersión de ±0,2 V entre unidades: con 22 Ω, la corriente va de 0 mA (V_F = 3,3 V) a 18 mA (V_F = 2,9 V), es decir, el mismo circuito se apaga en una unidad y se pasa en otra. Con 5 V sobre un rojo, la misma dispersión solo mueve la corriente entre 8,5 y 9,7 mA. Regla: cuanto menor es la caída sobre la resistencia, peor se controla la corriente; con menos de unos 1,5 V de margen conviene un driver de corriente constante o una fuente de más tensión.

• LEDs en serie: las tensiones se suman, y la misma corriente atraviesa todos. Con 5 V caben dos rojos (V_F total 4,0 V, R = 100 Ω) pero no tres (6,0 V). Con 12 V caben cinco (10 V, R = 220 Ω). Es la forma más eficiente: casi toda la tensión se aprovecha en los LEDs.
• LEDs en paralelo: cada uno con su propia resistencia. Con una resistencia común, el LED de menor V_F toma más corriente, se calienta y la toma aún más; es un reparto inestable.
• Distinto color, distinta resistencia: con 5 V, un rojo usa 330 Ω y un verde o azul, 220 Ω, para la misma corriente.

04 · Límites

Lo que puede dar un pin

Los pines de un microcontrolador no son una fuente de potencia. Un ATmega328P (Arduino Uno) admite como máximo 40 mA por pin (valor absoluto) y se recomienda no pasar de unos 20 mA; el total de todos los pines no debe superar unos 200 mA (el chip se calienta), y para un grupo de pines el límite es menor. Muchas placas de 3,3 V (ESP32, RP2040) dan 12 a 40 mA por pin según la configuración, y además la tensión de salida cae al cargar el pin. Se consulta siempre la hoja de datos del microcontrolador concreto.

• Un LED de señal a 5 a 10 mA se conecta directo al pin con su resistencia. Con 2 a 5 mA un LED de alta eficiencia ya se ve bien en una caja.
• Sumidero o fuente: el LED puede conectarse entre el pin y masa (el pin entrega corriente: nivel alto = encendido) o entre la alimentación y el pin (el pin la recibe: nivel bajo = encendido). Muchos chips sumergen corriente algo mejor de lo que la entregan, y la segunda forma tiene lógica invertida.
• Más de 20 mA (LEDs de potencia, varias tiras, una matriz) requiere un transistor o MOSFET como llave (tema 27): el pin maneja la base o compuerta, y la corriente del LED fluye por la fuente aparte.
• Los LEDs de potencia (1 W y más) se alimentan con un driver de corriente constante, no con una resistencia: a esas corrientes la resistencia disiparía tanta potencia como el LED.

Un detalle sobre el arranque: mientras el microcontrolador se reinicia, los pines están en alta impedancia, y en el modo sumidero un LED podría quedar apenas encendido. Y un pin configurado por error como salida a nivel alto contra una carga a masa es un cortocircuito en cámara lenta: la resistencia no es opcional.

05 · Regular el brillo

Brillo con PWM

La modulación por ancho de pulso (PWM) enciende y apaga el LED muy rápido; el ojo promedia. Con un ciclo de trabajo D, la corriente media es D × I y la luz media es proporcional. Es más eficiente y más uniforme en color que bajar la corriente con una resistencia variable, porque el LED trabaja siempre en el punto para el que fue diseñado (la tonalidad de un LED blanco o azul cambia con la corriente).

Tres decisiones de diseño:

• Frecuencia: debe ser mayor que lo que el ojo nota. Por encima de unos 200 Hz no se ve parpadeo con la mirada fija, pero al mover los ojos o filmar con una cámara aparecen rayas o barras; un valor de 1 kHz o más es la elección segura, y de 20 kHz para evitar también cualquier zumbido en la fuente. Al subir la frecuencia, las pérdidas de conmutación en un transistor aumentan.
• Resolución: en un timer de reloj f_clk con b bits, la frecuencia máxima es fclk / 2b. A 16 MHz: 8 bits da 62,5 kHz; 12 bits, 3,9 kHz; 16 bits, solo 244 Hz. A 80 MHz (ESP32): 12 bits da 19,5 kHz y 16 bits, 1,2 kHz. Más resolución cuesta frecuencia.
• Cuál usar: los pines de PWM por hardware generan la señal sin carga de CPU. En un Arduino Uno, analogWrite da 490 Hz (pines 3, 9, 10 y 11) o 980 Hz (5 y 6) con 8 bits. Un PWM generado por software con delayMicroseconds bloquea el programa (tema 41) y parpadea cuando el procesador se ocupa.

El PWM sobre un LED con resistencia es seguro: la corriente de cada pulso es la de la resistencia, y solo la corriente media baja. Cuidado, en cambio, con un ciclo de 100 %: ahí la corriente es continua y completa, y es la que hay que sumar contra el límite del pin.

06 · Percepción

Brillo percibido y corrección gamma

El ojo responde a la luz en forma aproximadamente logarítmica (ley de Weber-Fechner): distingue bien los pasos pequeños en la penumbra y casi no nota los grandes cerca del brillo máximo. Se modela con una potencia: percibido ≈ físico1/γ, con γ ≈ 2,2. Consecuencias:

• Un LED a ciclo de trabajo 50 % se ve a 0,51/2,2 = 73 %, no a la mitad. El código 128 de 255 «parece» mucho más brillante de lo esperado.
• Un barrido lineal del ciclo de trabajo se ve rápido en la parte oscura y se estanca en la clara.
• Para que el brillo percibido sea lineal hay que aplicar la corrección inversa: ciclo = percibidoγ.

La tabla muestra el problema de la corrección con 8 bits: las entradas 1 a 14 dan salida 0 (el LED sigue apagado) y el primer escalón visible salta a un brillo del 8 % percibido. Los fundidos suaves hasta apagarse y los niveles bajos de una luz ambiente quedan «escalonados». La solución es dar más bits al PWM: con 12 bits, el primer escalón es del 2,3 % percibido, y con 16 bits del 0,65 %. (Es la razón por la que las luces profesionales usan PWM de 12 a 16 bits, y las tiras económicas de 8 bits se ven «a saltos» al atenuar.) Una alternativa es el dithering temporal: alternar entre dos códigos vecinos para lograr valores intermedios, a costa de una frecuencia efectiva menor.

Una tabla de búsqueda calculada una vez evita elevar a la 2,2 en cada actualización.

07 · Color

LEDs RGB y mezcla de color

Un LED RGB integra tres LEDs (rojo, verde y azul) en una cápsula. Mezclando sus intensidades se obtiene casi cualquier color, y con los tres al máximo, un blanco. Se vende en dos configuraciones y hay que reconocerla antes de conectar:

Tres razones para una resistencia por canal: las tensiones directas son distintas (rojo ~2,0 V; verde y azul ~3,0 a 3,1 V), de modo que a 5 V se usan 330 Ω y 220 Ω para unos 9 mA en cada canal; con una resistencia común, la corriente se repartiría según V_F y cambiaría con el color mostrado; y cada canal puede ajustarse por separado para balancear el blanco. Con 330/220/220 Ω a 5 V, el blanco a pleno consume 26,8 mA en total: más que lo recomendado para un solo pin, aunque cada canal usa su pin; el total sí cuenta para el límite del chip.

Los tres canales no aportan la misma luz. La luminancia relativa (pesos de la norma Rec. 709, sobre valores linealizados) es 0,2126 para el rojo, 0,7152 para el verde y 0,0722 para el azul. Por eso un azul puro al máximo parece oscuro al lado del verde puro, y un gris «128, 128, 128» sin corrección gamma se ve mucho más claro que el 50 % esperado. Para mezclas correctas: corregir cada canal con gamma, y trabajar el color en un espacio como HSV (tono, saturación, valor), que se convierte a RGB antes de escribir los canales. El tono se recorre sin tocar el brillo, algo muy complicado de hacer con tres valores RGB independientes.

08 · Escalar

Muchos LEDs, pocos pines

Una matriz de 8 × 8 tiene 64 LEDs y no se maneja con 64 pines. El multiplexado conecta los LEDs en filas y columnas: todos los ánodos de una fila a una línea y todos los cátodos de una columna a otra. Se activa una fila por vez, rápido, con los LEDs de esa fila que deben estar encendidos; el ojo integra y ve la imagen completa. Se usan N + M pines en lugar de N × M (16 en vez de 64).

Cada LED permanece encendido solo 1/N del tiempo, así que, para mantener el mismo brillo medio, la corriente de pico debe ser N veces mayor:

Los límites: la corriente de pico del LED (los LEDs de 5 mm admiten unos 100 mA en pulsos de ciclo de 1/10 a 1 kHz, valor que figura en la hoja de datos); la corriente de cada pin de columna; y, sobre todo, la corriente de la línea de fila, que suma todos los LEDs encendidos de esa fila: 8 LEDs a 40 mA son 320 mA, imposibles para un pin, y exigen un transistor o un driver. Por eso, en la práctica, se usan circuitos dedicados, como el MAX7219 o el TM1637 (tema 37), que hacen el barrido solos y dejan al microcontrolador solo la tarea de enviar datos.

Otros problemas del barrido: el fantasma (un LED débilmente encendido que debería estar apagado, por una conmutación de filas que no es instantánea; se resuelve apagando todo un instante antes de cambiar de fila) y el parpadeo si el cuadro es lento (menos de unos 60 Hz).

El charlieplexing aprovecha que un pin puede estar en alta impedancia: con n pines se manejan n × (n − 1) LEDs conectados de a pares en antiparalelo (4 pines manejan 12 LEDs; 8 pines, 56). El costo es una resistencia por pin, un cableado confuso y un brillo menor (cada fase enciende solo los LEDs de un pin). Sirve para pocos LEDs en un microcontrolador sin pines libres; para matrices grandes se prefiere un driver.

09 · Programación

Código para manejar LEDs

Tres piezas de código reutilizables: la tabla gamma, un LED RGB con la polaridad resuelta en un solo lugar y el barrido de una matriz.

// --- Tabla gamma de 8 bits a 12 bits (se calcula una vez) ---
uint16_t tablaGamma[256];

void iniciarGamma() {
    for (int i = 0; i < 256; i++)
        tablaGamma[i] = (uint16_t)(4095.0 * pow(i / 255.0, 2.2) + 0.5);
}

// --- LED RGB con cátodo o ánodo común ---
struct LedRgb {
    uint8_t pinR, pinG, pinB;
    bool anodoComun;

    void escribirCanal(uint8_t pin, uint8_t valor) {
        uint16_t duty = tablaGamma[valor];                   // brillo percibido -> ciclo
        if (anodoComun) duty = 4095 - duty;                  // lógica invertida, resuelta aquí
        ledcWrite(pin, duty);                                // ESP32; en AVR: analogWrite(pin, duty >> 4)
    }
    void color(uint8_t r, uint8_t g, uint8_t b) {
        escribirCanal(pinR, r); escribirCanal(pinG, g); escribirCanal(pinB, b);
    }
};

// --- Barrido de una matriz de 8 filas, llamado desde una interrupción de timer a 800 Hz ---
volatile uint8_t imagen[8];                                  // un byte por fila: un bit por LED
void barrerFila() {
    static uint8_t fila = 0;
    desactivarFilas();                                       // apagar todo antes de cambiar (evita fantasmas)
    escribirColumnas(imagen[fila]);
    activarFila(fila);
    fila = (fila + 1) & 7;
}

La interfaz es la misma idea de los temas anteriores: color(r, g, b) recibe un valor perceptual de 0 a 255 y esconde la tabla, los bits del PWM y la polaridad. Si se cambia el LED de cátodo a ánodo común, se modifica una constante.

10 · Verificación

Fallas y verificación

1. Medí la corriente con el tester en serie: comparala con la calculada; si difiere mucho, la V_F real no es la esperada.
2. Medí la caída sobre la resistencia: dividida por su valor da la corriente sin abrir el circuito.
3. Probá el peor caso: todos los LEDs encendidos al máximo (blanco, matriz llena) y verificá que el pin o el driver no se calienten.
4. Mirá la frecuencia con una cámara de teléfono: las bandas oscuras muestran el parpadeo del PWM.
5. Atenuá de 0 a 100 % despacio: el brillo debe parecer uniforme, sin saltos al principio.

11 · Analogía con programación

Resistencias, gamma, color y multiplexado

Calculemos los cuatro elementos del tema: la resistencia normalizada con su dispersión de corriente, la resolución del PWM con la corrección gamma, la luminancia de los colores y el costo del multiplexado.

import math

E12 = [1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2]
VF = {"rojo": 2.0, "amarillo": 2.1, "verde": 3.0, "azul": 3.1, "blanco": 3.2}


def e12_mayor(r):
    decada = 10 ** math.floor(math.log10(r))
    for k in E12 + [10.0]:
        if k * decada >= r * 0.999:
            return round(k * decada)


def resistencia(vs, vf, i):
    ideal = (vs - vf) / i
    return ideal, e12_mayor(ideal)


print("fuente  color     R ideal  R E12  I real   I con Vf ±0,2 V         P en R")
for vs, color in ((5.0, "rojo"), (5.0, "verde"), (5.0, "azul"), (3.3, "rojo"), (3.3, "azul")):
    vf = VF[color]
    ideal, r = resistencia(vs, vf, 0.010)
    i = (vs - vf) / r
    i_min, i_max = max(0, (vs - vf - 0.2) / r), (vs - vf + 0.2) / r
    print(f"{vs:4.1f} V  {color:8s}  {ideal:6.1f}  {r:5d}  {i * 1000:5.2f} mA  {i_min * 1000:5.1f} a {i_max * 1000:5.1f} mA   {i * i * r * 1000:5.1f} mW")

# ---- LEDs en serie ----
print()
for n in (1, 2, 3):
    vf = n * VF["rojo"]
    if vf < 5.0:
        ideal, r = resistencia(5.0, vf, 0.010)
        print(f"{n} rojos en serie a 5 V: R = {ideal:.0f} -> {r} ohm, I = {(5.0 - vf) / r * 1000:.2f} mA")
    else:
        print(f"{n} rojos en serie a 5 V: Vf total {vf:.1f} V, no enciende")
print(f"5 rojos en serie a 12 V: R = {resistencia(12.0, 5 * 2.0, 0.010)[0]:.0f} -> {resistencia(12.0, 10.0, 0.010)[1]} ohm")

# ---- Brillo percibido y resolución de PWM ----
GAMMA = 2.2
print()
for bits in (8, 10, 12, 16):
    maximo = 2 ** bits - 1
    print(f"{bits:2d} bits: primer escalón {1 / maximo * 100:8.4f} % de ciclo -> brillo percibido {(1 / maximo) ** (1 / GAMMA) * 100:5.2f} %; "
          f"a 16 MHz: {16e6 / 2 ** bits:8.0f} Hz; a 80 MHz: {80e6 / 2 ** bits:9.0f} Hz")

print()
print("percibido  código lineal  ciclo con gamma  código 8 bits  código 12 bits")
for p in (0.05, 0.10, 0.25, 0.50, 1.0):
    duty = p ** GAMMA
    print(f"{p * 100:7.0f} %  {round(p * 255):13d}  {duty * 100:13.2f} %  {round(duty * 255):13d}  {round(duty * 4095):14d}")
primero = next(i for i in range(256) if round(255 * (i / 255) ** GAMMA) >= 1)
print(f"Con gamma 2,2 y 8 bits, las entradas 1 a {primero - 1} dan salida 0; la primera salida distinta de cero es la entrada {primero}")
print(f"Brillo percibido de 128/255 sin corregir: {(128 / 255) ** (1 / GAMMA) * 100:.0f} %")


# ---- Color: luminancia relativa (pesos Rec. 709) ----
def luminancia(r, g, b):
    lin = [(c / 255) ** GAMMA for c in (r, g, b)]
    return 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2]


print()
for nombre, rgb in (("rojo", (255, 0, 0)), ("verde", (0, 255, 0)), ("azul", (0, 0, 255)), ("blanco", (255, 255, 255)), ("gris 50 %", (128, 128, 128))):
    print(f"{nombre:10s} {rgb}: luminancia relativa {luminancia(*rgb):.4f}")
print("Corriente de blanco a 5 V con 330/220/220 ohm: %.1f mA" % (((5 - 2.0) / 330 + (5 - 3.0) / 220 + (5 - 3.1) / 220) * 1000))

# ---- Multiplexado ----
print()
print("filas  ciclo  I pico (5 mA medios)  barrido de filas (cuadro de 100 Hz)  corriente de una fila con 8 LEDs")
for n in (1, 2, 4, 8, 16):
    pico = 5 * n
    print(f"{n:5d}  1/{n:<3d}  {pico:8d} mA            {100 * n:6d} Hz ({1000 / (100 * n):.2f} ms por fila)     {8 * pico:5d} mA")
for pines in (4, 6, 8):
    print(f"{pines} pines: charlieplexing {pines * (pines - 1)} LEDs; matriz {pines // 2} x {pines // 2} = {(pines // 2) ** 2} LEDs")

Resultado: a 5 V, un rojo a 10 mA pide 300 Ω y con el valor normalizado de 330 Ω da 9,09 mA (27 mW); con una dispersión de V_F de ±0,2 V, la corriente queda entre 8,5 y 9,7 mA. A 3,3 V, un azul con 22 Ω da 9,09 mA nominales pero entre 0 y 18,2 mA según la unidad. Dos rojos en serie a 5 V necesitan 100 Ω (10 mA); tres no encienden; cinco a 12 V usan 220 Ω. Con 8 bits, el primer escalón de PWM equivale a un brillo percibido de 8,06 %; con 10, 12 y 16 bits, 4,28 %, 2,28 % y 0,65 %. A 16 MHz, 16 bits dan solo 244 Hz de PWM, y a 80 MHz, 1221 Hz. Para un 50 % percibido hace falta un ciclo de 21,76 % (código 55 de 255 u 891 de 4095), y con gamma las entradas 1 a 14 dan salida 0. Un código 128 sin corregir se ve al 73 %. La luminancia relativa es 0,2126 (rojo), 0,7152 (verde) y 0,0722 (azul); el blanco con 330/220/220 Ω consume 26,8 mA. En multiplexado, 8 filas con 5 mA medios exigen 40 mA de pico, un barrido de 800 Hz (1,25 ms por fila) y 320 mA en la línea de una fila de 8 LEDs.

12 · Exploración interactiva

Corriente, brillo, color y barrido

El primer instrumento dimensiona la resistencia de un LED (o de varios en serie) con su dispersión. El segundo muestra el efecto de la resolución del PWM y de la corrección gamma. El tercero mezcla color con un LED RGB y el cuarto calcula las corrientes de una matriz multiplexada. El límite de un pin se toma como 20 mA (ATmega328P, valor recomendado).

Recorrido guiado

1. Con 5 V, LED rojo y 10 mA: R calculada de 300 Ω, normalizada de 330 Ω, 9,09 mA reales y 27 mW. Con V_F ± 0,2 V, la corriente va de 8,5 a 9,7 mA: es robusta.
2. Pasá a 3,3 V con LED azul: la R de 22 Ω da 9,09 mA nominales, pero el rango va de 0 a 18 mA. El aviso de «sin margen» es la lección: con poca caída sobre la resistencia, la corriente depende de la unidad.
3. Con 5 V, probá dos LEDs rojos en serie (100 Ω, 10 mA) y luego tres: la suma de tensiones (6 V) supera la fuente y el estado dice que no enciende. Con 12 V caben cinco.
4. Subí la corriente a 30 mA alimentando desde un pin: aparece el aviso de que se supera el límite del pin. Desmarcá la casilla del pin y pasá a 12 V con 30 mA (un rojo): la resistencia normalizada de 390 Ω disipa unos 0,26 W, más de ¼ W.
5. En el instrumento 2, con 8 bits y gamma activa, pedí 5 %: el código es 0 y el LED sigue apagado. Pasá a 12 bits: el código es 6 y el brillo percibido se acerca al deseado.
6. Desactivá la gamma con un brillo deseado de 50 %: el código 128 se ve al 73 %. Con 16 bits a 16 MHz, el PWM máximo es 244 Hz y el estado avisa que la frecuencia elegida es imposible; cambiá a 80 MHz.
7. En el LED RGB, dejá (255, 128, 0) con gamma y luego desactivala: el naranja se vuelve más pálido, porque los valores de brillo se ven más claros de lo esperado. Poné (0, 0, 255) y (0, 255, 0) y compará la luminancia: 0,07 contra 0,72.
8. En la matriz, con 8 filas, 5 mA medios y 8 LEDs por fila: 40 mA de pico y 320 mA en la línea de fila. Se necesita un transistor o un driver. Bajá a 30 cuadros por segundo: el estado avisa de parpadeo.

13 · Método de trabajo

Cómo integrar un LED, para cualquier proyecto

1. Buscá V_F y la corriente nominal en la hoja de datos, y verificá que la fuente supera V_F en al menos 1,5 V.
2. Calculá la resistencia con (V − V_F)/I y tomá el siguiente valor normalizado mayor; comprobá la corriente con V_F ± 0,2 V.
3. Sumá las corrientes y compará con el límite de cada pin y del chip; por encima, usá un transistor o un driver.
4. Regulá el brillo con PWM de 1 kHz o más, con hardware, y con una tabla gamma para que la atenuación sea uniforme.
5. Usá suficientes bits (12 o más) si necesitás fundidos suaves en niveles bajos.
6. Para color: una resistencia por canal, polaridad resuelta en un solo lugar y trabajo en HSV.
7. Para muchos LEDs: multiplexado con driver dedicado o tiras direccionables (tema 36), no pines sueltos.
8. Probá el peor caso (todo encendido) y mirá el PWM con una cámara.

Si el LED casi no brilla, revisá V_F y la polaridad; si se quema, falta la resistencia; si el atenuado «salta», faltan bits o gamma; si el color sale mal, faltan resistencias por canal; si el micro se resetea, se pasó de corriente.

14 · Comprensión

Confusiones frecuentes

15 · Práctica guiada

Predecí antes de comprobar

1. Resistencia

Un LED amarillo (2,1 V) a 15 mA con una fuente de 5 V. ¿Qué resistencia calculada y normalizada usás, y cuánta corriente real da?

2. Serie

¿Cuántos LEDs blancos de 3,2 V caben en serie con una fuente de 12 V? ¿Qué resistencia da 10 mA?

3. Margen

Un LED azul de 3,1 V con una fuente de 3,3 V y una resistencia de 47 Ω. ¿Qué corriente nominal da y qué rango con ±0,2 V?

4. Gamma

Se quiere un brillo percibido del 25 %. ¿Qué ciclo de trabajo y qué códigos de 8 y de 12 bits hacen falta?

5. Frecuencia

En un timer de 16 MHz con 14 bits de resolución, ¿qué frecuencia máxima de PWM hay? ¿Alcanza para evitar el parpadeo en cámara?

6. Multiplexado

Una matriz de 16 filas con 3 mA medios por LED y 5 LEDs encendidos por fila. ¿Corriente de pico por LED y corriente de la línea de fila? ¿Alcanza un pin?

16 · Síntesis

Ideas para recordar

¿Listo para el tema 36?

Antes de avanzar, calculá la resistencia de un LED verde de 3,0 V a 12 mA con 5 V, explicá por qué un ciclo de trabajo de 50 % no se ve a la mitad y decí cuánta corriente de pico necesita un LED en una matriz de 4 filas con 6 mA medios. Si podés justificar las tres respuestas, ya sabés manejar LEDs.

En el próximo tema pasamos de un LED por pin a cientos con un solo cable: las tiras de LEDs direccionables WS2812 y APA102.