2.5 Brillo LED

Imagen cabecera Brillo LED

1. Qué vamos a hacer

Vamos a hacer que el LED verde de la placa se encienda poco a poco, hasta brillar al máximo, y que después se apague también poco a poco, como la luz de un cine al empezar y terminar la película.

LED verde subiendo y bajando de brillo en EchidnaBlack2

1.1 Qué vamos a aprender

A regular el brillo de un LED con valores de 0 a 255 mediante PWM con analogWrite.
A repetir instrucciones un número de veces con el bucle for, contando hacia arriba y hacia abajo.

1.2 Qué vamos a usar

Componentes

LED verde (pin 11): Se enciende y se apaga poco a poco.

LED en EchidnaBlack2

Programación

En el proyecto Timbre usamos analogWrite para hacer sonar el zumbador. El pin del LED verde también es de tipo Digital/Analógico: en la placa lleva el símbolo ~ (Gre D11~; ver la tabla de pines de la Introducción). Así que, además de encenderlo y apagarlo con digitalWrite, con analogWrite podemos darle un brillo entre 0 (apagado) y 255 (brillo máximo); con 128, por ejemplo, luce a media potencia. La señal PWM enciende y apaga el LED tan deprisa que no vemos el parpadeo: cuanto más tiempo está encendido en cada parpadeo, más brillante lo vemos. Los pines del LED rojo (D13) y del naranja (D12) no admiten PWM, por eso usamos el verde.

Para que el brillo cambie poco a poco tendríamos que escribir 256 analogWrite seguidos, uno por cada valor. En lugar de eso, usamos el bucle for, que repite las instrucciones que tiene entre llaves { }:

for (int brillo = 0; brillo <= 255; brillo = brillo + 1) {
  // instrucciones que se repiten
}

Entre los paréntesis tiene tres partes, separadas por punto y coma:

Inicio (int brillo = 0): crea la variable que cuenta las vueltas y le da su primer valor.
Condición (brillo <= 255): el bucle se repite mientras se cumpla. El operador <= significa «menor o igual que».
Incremento (brillo = brillo + 1): cómo cambia la variable al final de cada vuelta; aquí, suma 1.

2. Programamos

El programa tiene dos bucles for, uno detrás de otro: el primero sube el brillo del LED verde de 0 a 255 y el segundo lo baja de 255 a 0. Al terminar, el LED se queda apagado un segundo y todo vuelve a empezar.

Escribe el siguiente código en Arduino IDE y cárgalo en la placa:

// Brillo LED: el LED verde se enciende y se apaga poco a poco

const int ledVerde = 11;  // LED verde conectado al pin 11

const int espera = 10;  // tiempo entre un brillo y el siguiente, en milisegundos

void setup() {
  pinMode(ledVerde, OUTPUT);  // el LED es una salida
}

void loop() {
  // encendido gradual: el brillo sube de 0 a 255
  for (int brillo = 0; brillo <= 255; brillo = brillo + 1) {
    analogWrite(ledVerde, brillo);
    delay(espera);
  }

  // apagado gradual: el brillo baja de 255 a 0
  for (int brillo = 255; brillo >= 0; brillo = brillo - 1) {
    analogWrite(ledVerde, brillo);
    delay(espera);
  }

  delay(1000);  // espera 1 segundo con el LED apagado
}

Cómo funciona:

Las constantes (líneas 3 a 5): guardan el pin del LED verde y la espera, el tiempo que pasa entre un brillo y el siguiente.

La función setup() (líneas 7 a 9): configura el pin del LED como salida.

La función loop() (líneas 11 a 25): tiene dos bucles for seguidos.

El primer bucle (líneas 13 a 16) crea la variable brillo con el valor 0 y, en cada vuelta, enciende el LED con ese brillo, espera 10 milisegundos y suma 1. Se repite mientras brillo sea menor o igual que 255, así que da 256 vueltas y el LED pasa de apagado a brillo máximo en unos 2,5 segundos.
El segundo bucle (líneas 19 a 22) hace lo contrario: empieza en 255 y, en cada vuelta, resta 1 (brillo = brillo - 1). Se repite mientras brillo sea mayor o igual que 0 (el operador >= significa «mayor o igual que»), así que el LED se va apagando poco a poco.

Al final, delay(1000) deja el LED apagado un segundo antes de que loop() vuelva a empezar:

PARA cada brillo de 0 a 255:
    --> Enciende el LED verde con ese brillo.
    --> Espera 10 milisegundos.

PARA cada brillo de 255 a 0:
    --> Enciende el LED verde con ese brillo.
    --> Espera 10 milisegundos.

Espera 1 segundo con el LED apagado.

La variable brillo se crea dentro de cada for y solo existe mientras dura ese bucle, por eso podemos usar el mismo nombre en los dos.

3. Mejóralo

Prueba a realizar algunas de las siguientes modificaciones al proyecto:

Respiración lenta: Haz que el LED se encienda y se apague mucho más despacio, como si respirara tranquilamente. ¿Y si lo quieres muy rápido?

Pista: la constante espera marca cuánto dura cada uno de los 256 pasos. Con 30 milisegundos, cada subida dura unos 7,7 segundos; con 2, apenas medio segundo.
Latido: Haz que el LED lata como un corazón: que se encienda deprisa y se apague despacio, con una pausa corta entre un latido y el siguiente.

Pista: usa dos constantes en lugar de espera, una para la subida (por ejemplo, 2) y otra para la bajada (por ejemplo, 8), y pon cada una en el delay de su bucle. Acorta también la pausa del final, por ejemplo a medio segundo.
Regulador de brillo: Usa los pulsadores como el regulador de luz de una lámpara: mientras mantienes pulsado SR, el LED verde brilla cada vez más, y mientras mantienes pulsado SL, brilla cada vez menos.

Pista: ahora no hace falta un for: declara una variable global brillo y, en cada vuelta de loop(), súmale 1 si SR está pulsado y réstale 1 si lo está SL. Para que no se salga de los valores de analogWrite, súmale solo si es menor que 255 y réstale solo si es mayor que 0, con un if dentro de otro, como en el Interruptor de luz.