Arduino · Módulo 03 · Ej 02 — Mostrar el LED en 4 niveles fijos de brillo

Ejercicio 02 — Mostrar el LED en 4 niveles fijos de brillo

Dificultad: verde · Módulo 03 (Salidas analogicas (PWM))

Enunciado

Mostrar el LED en 4 niveles fijos de brillo: 25%, 50%, 75% y 100% (1 s cada uno).

Montaje (Arduino UNO)

LED en pin 9 (~) con resistencia 220 ohm a GND

Cómo se resuelve

Después de la rampa del ejercicio anterior, este va al grano con lo contrario: cuatro brillos concretos, un segundo cada uno. El objetivo real no es el LED, es que se te quede grabada la traducción entre el porcentaje en el que piensas y las cuentas en las que habla analogWrite.

El montaje y la cabecera son los mismos del ej01: LED en el pin 9 con su resistencia de 220 Ω a GND, const int LED = 9; y pinMode(LED, OUTPUT) en setup().

Todo el ejercicio vive en el loop(), y es cuatro veces el mismo par de líneas:

analogWrite(LED, 64);     // 25%
delay(1000);
analogWrite(LED, 128);    // 50%
delay(1000);
analogWrite(LED, 191);    // 75%
delay(1000);
analogWrite(LED, 255);    // 100%
delay(1000);

De dónde salen esos números es lo único que hay que entender. El rango de analogWrite es 0..255, no 0..100, porque el duty cycle se codifica en 8 bits y con 8 bits hay 256 valores posibles. Para pasar de porcentaje a cuentas se hace una regla de tres, valor = 255 * pct / 100: el 25 % es 63,75 y se escribe 64; el 50 % es 127,5 y se escribe 128; el 75 % es 191,25 y se escribe 191; el 100 % es 255 exacto. Los redondeos de media cuenta sobre 256 son invisibles, así que no le des más vueltas: lo importante es el techo, no el decimal.

Ese techo es la causa del error más repetido del módulo. Es muy natural escribir analogWrite(LED, 100) pensando “cien por cien”, y lo que se obtiene es 100/255, un 39 % escaso. El LED se enciende, pero flojo, y como no hay ningún error el fallo pasa desapercibido hasta que comparas con otro nivel.

Fíjate también en un detalle que el ejercicio enseña sin decirlo: entre un analogWrite y el siguiente pasa un segundo entero, y durante ese segundo el programa está congelado en el delay, pero el LED sigue brillando al nivel que le tocaba. Eso es porque el PWM lo genera un temporizador del microcontrolador por hardware, no el programa. Tú escribes un valor una vez y el pin sigue conmutando solo, aunque el código esté parado o haciendo otra cosa. Es una diferencia importante con el parpadeo hecho a base de delay del módulo 01, donde cada cambio del pin lo tenía que ejecutar el programa.

Y como siempre, el cuarto nivel no necesita nada que lo devuelva al primero: al acabar el loop(), la placa vuelve arriba y el ciclo se repite. El salto del 100 % al 25 % se ve como un golpe de oscuridad, y precisamente ese contraste es lo que hace que los cuatro escalones se distingan.

Cuando lo tengas funcionando, prueba a añadir un nivel intermedio, por ejemplo el 10 % (analogWrite(LED, 26)), y compara el salto del 10 al 25 con el del 75 al 100. Son quince puntos porcentuales en los dos casos y el primero se ve muchísimo más grande: el ojo percibe la luz de forma logarítmica, no lineal.

Para practicar — cópialo y complétalo

Pega este esqueleto y completa los TODO. Es la mejor forma de aprender: inténtalo antes de mirar la solución.

/*
 * Curso de Arduino — Módulo 03: Salidas analógicas (PWM)
 * Ejercicio 02 — PRÁCTICA (rellena los TODO)
 * Enunciado: Mostrar el LED en 4 niveles fijos de brillo: 25%, 50%, 75% y 100% (1 s cada uno).
 * Dificultad: verde
 * Placa: Arduino UNO    Montaje: LED en pin 9 (~) con resistencia 220 ohm a GND
 * Correr: Arduino IDE / Wokwi (wokwi/ej02) / arduino-cli (ver README)
 *
 * Pista: el rango es 0..255. Para un % usa 255 * % / 100
 *        (25% -> 64, 50% -> 128, 75% -> 191, 100% -> 255).
 */
const int LED = 9;   // pin PWM (~)
 
void setup() {
    // TODO: configura LED como salida
}
 
void loop() {
    // TODO: analogWrite(LED, 64)  -> 25%, luego delay(1000)
    // TODO: analogWrite(LED, 128) -> 50%, luego delay(1000)
    // TODO: analogWrite(LED, 191) -> 75%, luego delay(1000)
    // TODO: analogWrite(LED, 255) -> 100%, luego delay(1000)
}

Solución — cópiala y ejecútala

/*
 * Curso de Arduino — Módulo 03: Salidas analógicas (PWM)
 * Ejercicio 02 — MODELO (resuelto)
 * Enunciado: Mostrar el LED en 4 niveles fijos de brillo: 25%, 50%, 75% y 100% (1 s cada uno).
 * Dificultad: verde
 * Placa: Arduino UNO    Montaje: LED en pin 9 (~) con resistencia 220 ohm a GND
 * Correr: Arduino IDE / Wokwi (wokwi/ej02) / arduino-cli (ver README)
 *
 * Idea: el rango de analogWrite es 0..255. Un % se traduce a 255*%/100.
 *       25% -> 64, 50% -> 128, 75% -> 191, 100% -> 255.
 */
const int LED = 9;   // pin PWM (~)
 
void setup() {
    pinMode(LED, OUTPUT);
}
 
void loop() {
    analogWrite(LED, 64);     // 25%  (255 * 0.25)
    delay(1000);
    analogWrite(LED, 128);    // 50%
    delay(1000);
    analogWrite(LED, 191);    // 75%
    delay(1000);
    analogWrite(LED, 255);    // 100% (máximo brillo)
    delay(1000);
}

Cómo ejecutar la simulación

Sin instalar nada, en el navegador

1. Abre wokwi.com y crea un proyecto nuevo de la placa que pide el ejercicio.
2. Pega la solución (o tu intento) en la pestaña sketch.ino.
3. Abre la pestaña diagram.json, borra lo que haya y pega el circuito de aquí abajo.
4. Dale al play. Verás el circuito funcionando: LEDs, pantallas y monitor serie.

Circuito del ejercicio (diagram.json)

{
  "version": 1,
  "author": "ESIBot",
  "editor": "wokwi",
  "parts": [
    { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} },
    { "type": "wokwi-led", "id": "led", "top": -50, "left": 150, "attrs": { "color": "red" } },
    { "type": "wokwi-resistor", "id": "r1", "top": 100, "left": 150, "attrs": { "value": "220" } }
  ],
  "connections": [
    [ "uno:9", "r1:1", "green", [] ],
    [ "r1:2", "led:A", "green", [] ],
    [ "led:C", "uno:GND.1", "black", [] ]
  ],
  "dependencies": {}
}

En VS Code, con el repo del curso

El paquete de simulación de este ejercicio está en practica/03-salidas-analogicas-pwm/wokwi/ej02/. Con la extensión Wokwi instalada y la licencia activada (lo cuenta el onboarding del curso):

make sim EJ=03-salidas-analogicas-pwm/ej02

y después, en VS Code, Ctrl+Shift+P → Wokwi: Start Simulator. La extensión no compila: simula un firmware ya compilado, y de compilarlo se encarga ese make.

Cómo usarlo

Con placa: abre el .ino en el Arduino IDE, elige placa y puerto y pulsa Subir. Sin placa: simulalo en Wokwi con cualquiera de las dos vias de arriba. Antes de mirar la solucion, intenta completar tu el esqueleto: es la mejor forma de aprender.

Conexiones

• Teoría del módulo
• Índice del curso