LED y pulsadores
En este ejemplo probamos los 2 LED y los 8 pulsadores de la placa. Cada pulsación aparece en el monitor serie y algunos botones tienen una acción: encender y apagar un LED, cambiar su brillo o reiniciar la placa.
Es el primer ejemplo que conviene probar: no necesita librerías y sirve para comprobar que todos los botones y LED están bien soldados.
Qué vas a aprender:
- Configurar pines como salida (
OUTPUT) y como entrada con pull-up (INPUT_PULLUP). - Leer pulsadores y eliminar los rebotes por software.
- Detectar el momento en que se pulsa o se suelta un botón.
- Controlar el brillo de un LED con PWM.
1. Mapa de pines
LED
| LED | GPIO | Constante | Conexión |
|---|---|---|---|
| LED 1 | 7 | LED1 |
GPIO → resistencia de 220–330 Ω → LED → GND |
| LED 2 | 8 | LED2 |
GPIO → resistencia de 220–330 Ω → LED → GND |
Un LED se enciende con HIGH y se apaga con LOW.
Pulsadores
| Botón | GPIO | Constante | Acción en este ejemplo |
|---|---|---|---|
| A | 13 | BTN_A |
Enciende o apaga el LED 2 |
| B | 14 | BTN_B |
Hace parpadear el LED 2 tres veces |
| START | 20 | BTN_START |
Muestra un resumen de las pulsaciones |
| RESET | 21 | BTN_RESET |
Reinicia la placa por software |
| UP | 39 | BTN_UP |
Sube el brillo del LED 2 |
| DOWN | 40 | BTN_DOWN |
Baja el brillo del LED 2 |
| RIGHT | 47 | BTN_RIGHT |
Solo se muestra en el monitor serie |
| LEFT | 48 | BTN_LEFT |
Solo se muestra en el monitor serie |
Mientras cualquier botón esté presionado, el LED 1 se queda encendido.
Cada pulsador va conectado entre su GPIO y GND, sin resistencia externa:
Sin pulsar, la resistencia interna mantiene el pin en HIGH. Al pulsar, el botón lo une a GND y se lee LOW.
GPIO 20 y el USB nativo
El GPIO 20 es la línea D+ del USB nativo. Al configurarlo como entrada para el botón START, el puerto USB nativo deja de funcionar. Por eso este ejemplo usa Serial0 y hay que conectar el cable al puerto UART de la placa, tanto para subir el programa como para ver el monitor serie. Más detalles en la descripción de la placa.
2. Preparar el entorno
No necesita librerías externas. ledcAttach() y ledcWrite() son del core 3.x del ESP32.
Usa la misma configuración de placa que en LCD 240x240, y conecta el cable al puerto UART.
3. Código
#include <Arduino.h>
// =====================================================
// LED
// =====================================================
#define LED1 7
#define LED2 8
// =====================================================
// Pulsadores
// =====================================================
#define BTN_A 13
#define BTN_B 14
#define BTN_START 20
#define BTN_RESET 21
#define BTN_UP 39
#define BTN_DOWN 40
#define BTN_RIGHT 47
#define BTN_LEFT 48
#define ANTIRREBOTE_MS 30 // Tiempo que el botón debe estar estable
struct Boton {
const char *nombre;
uint8_t pin;
bool estable; // Estado aceptado (HIGH = suelto)
bool ultimaLectura; // Última lectura cruda
unsigned long cambio; // Momento del último cambio en la lectura
uint16_t pulsaciones; // Contador
};
Boton botones[] = {
{"A", BTN_A},
{"B", BTN_B},
{"START", BTN_START},
{"RESET", BTN_RESET},
{"UP", BTN_UP},
{"DOWN", BTN_DOWN},
{"RIGHT", BTN_RIGHT},
{"LEFT", BTN_LEFT},
};
const int NUM_BOTONES = sizeof(botones) / sizeof(botones[0]);
// =====================================================
// Estado del LED 2 (PWM)
// =====================================================
bool led2Encendido = false;
int brillo = 128; // 0–255
void actualizarLed2() {
ledcWrite(LED2, led2Encendido ? brillo : 0);
}
// =====================================================
// Antirrebote: devuelve true una sola vez por pulsación
// =====================================================
bool actualizarBoton(Boton &b, bool &soltado) {
soltado = false;
bool lectura = digitalRead(b.pin);
if (lectura != b.ultimaLectura) { // La lectura cambió: reinicia el contador
b.ultimaLectura = lectura;
b.cambio = millis();
}
if (millis() - b.cambio >= ANTIRREBOTE_MS && lectura != b.estable) {
b.estable = lectura; // Lleva estable el tiempo suficiente
if (b.estable == LOW) return true; // Flanco de bajada: pulsado
soltado = true; // Flanco de subida: soltado
}
return false;
}
// =====================================================
// Acción de cada botón
// =====================================================
void alPulsar(Boton &b) {
b.pulsaciones++;
Serial0.printf("[%6lu ms] %-5s pulsado\n", millis(), b.nombre);
switch (b.pin) {
case BTN_A:
led2Encendido = !led2Encendido;
actualizarLed2();
Serial0.printf(" LED 2 %s\n", led2Encendido ? "encendido" : "apagado");
break;
case BTN_B:
for (int i = 0; i < 3; i++) {
ledcWrite(LED2, 255); delay(120);
ledcWrite(LED2, 0); delay(120);
}
actualizarLed2();
break;
case BTN_UP:
case BTN_DOWN:
brillo += (b.pin == BTN_UP) ? 32 : -32;
brillo = constrain(brillo, 0, 255);
led2Encendido = true;
actualizarLed2();
Serial0.printf(" Brillo LED 2: %d/255\n", brillo);
break;
case BTN_START:
Serial0.println(" ---- Pulsaciones ----");
for (int i = 0; i < NUM_BOTONES; i++) {
Serial0.printf(" %-5s %u\n", botones[i].nombre, botones[i].pulsaciones);
}
break;
case BTN_RESET:
Serial0.println(" Reiniciando...");
delay(100);
ESP.restart();
break;
}
}
// =====================================================
// SETUP
// =====================================================
void setup() {
Serial0.begin(115200);
delay(500);
Serial0.println("\n=== LED y pulsadores ===");
// LED 1: salida digital
pinMode(LED1, OUTPUT);
digitalWrite(LED1, LOW);
// LED 2: PWM a 5 kHz con 8 bits (0–255)
ledcAttach(LED2, 5000, 8);
actualizarLed2();
// Pulsadores con pull-up interna
for (int i = 0; i < NUM_BOTONES; i++) {
pinMode(botones[i].pin, INPUT_PULLUP);
botones[i].estable = HIGH;
botones[i].ultimaLectura = HIGH;
}
// Saludo: los dos LED parpadean
for (int i = 0; i < 2; i++) {
digitalWrite(LED1, HIGH); ledcWrite(LED2, 255); delay(150);
digitalWrite(LED1, LOW); ledcWrite(LED2, 0); delay(150);
}
Serial0.println("Listo. Pulsa cualquier boton.");
}
// =====================================================
// LOOP
// =====================================================
void loop() {
bool algunoPresionado = false;
for (int i = 0; i < NUM_BOTONES; i++) {
bool soltado;
if (actualizarBoton(botones[i], soltado)) {
alPulsar(botones[i]);
}
if (soltado) {
Serial0.printf("[%6lu ms] %-5s soltado\n", millis(), botones[i].nombre);
}
if (botones[i].estable == LOW) algunoPresionado = true;
}
// LED 1 encendido mientras haya un botón presionado
digitalWrite(LED1, algunoPresionado ? HIGH : LOW);
}
4. Cómo funciona
Salidas y entradas
pinMode(LED1, OUTPUT); // El ESP32 controla el pin
pinMode(botones[i].pin, INPUT_PULLUP); // El ESP32 lee el pin, con pull-up
OUTPUT: el pin entrega 3,3 V (HIGH) o 0 V (LOW). La resistencia en serie limita la corriente del LED a unos 5–10 mA.INPUT_PULLUP: activa una resistencia interna hacia 3,3 V. Sin ella, un pin al aire leería valores aleatorios. La lógica queda invertida: suelto esHIGHy pulsado esLOW.
El rebote de los pulsadores
Un pulsador es una pieza mecánica: al cerrarse, los contactos rebotan durante unos milisegundos antes de quedarse quietos. Sin filtrar, una sola pulsación se leería como varias.
Lectura ┌─┐ ┌┐
HIGH ────────────┘ └─┘└──┐ ┌┐ ┌──────────
│ ││ │
LOW └───────────────┘└─┘
◄ rebote ► ◄rebote►
~5 ms ~5 ms
actualizarBoton() aplica un antirrebote por tiempo:
- Cada vez que la lectura cambia, apunta el momento en
b.cambio. - Solo acepta el nuevo estado cuando la lectura lleva 30 ms sin cambiar.
- Si el estado aceptado pasa a
LOW, devuelvetrue: es una pulsación nueva. Si pasa aHIGH, marcasoltado.
Así cada pulsación se cuenta una sola vez, aunque mantengas el botón presionado.
Sin delay() en el loop
El loop() revisa los 8 botones en cada vuelta usando millis(), sin pausas. Por eso responde a varios botones a la vez y el LED 1 sigue al instante si hay alguno presionado. Las únicas pausas son el parpadeo del botón B y el saludo inicial.
Una tabla de botones
En vez de repetir el mismo código ocho veces, cada botón es una entrada del arreglo botones[] con su nombre, su pin y su estado. Para agregar un botón basta con añadir una línea.
Brillo con PWM
ledcAttach(LED2, 5000, 8); // pin, frecuencia (Hz), resolución (bits)
ledcWrite(LED2, brillo); // 0 = apagado, 255 = máximo
El PWM enciende y apaga el LED 5 000 veces por segundo. El ojo no ve el parpadeo, sino el promedio: si el LED está encendido la mitad del tiempo (128), se ve a media intensidad.
brillo = 64 (25 %) ┌┐ ┌┐ ┌┐ ┌┐
─┘└───┘└───┘└───┘└──
brillo = 192 (75 %) ┌──┐┌──┐┌──┐┌──┐
─┘ └┘ └┘ └┘ └
UP y DOWN suben o bajan el brillo de 32 en 32, y constrain() lo mantiene entre 0 y 255.
Reinicio por software
ESP.restart() reinicia el programa desde el principio, como si se desconectara la alimentación. Es distinto del botón EN de la placa, que reinicia el chip por hardware.
5. Resultado esperado
Al arrancar, los dos LED parpadean dos veces. Después, en el monitor serie a 115200 baudios:
=== LED y pulsadores ===
Listo. Pulsa cualquier boton.
[ 2315 ms] A pulsado
LED 2 encendido
[ 2480 ms] A soltado
[ 3902 ms] UP pulsado
Brillo LED 2: 160/255
[ 4011 ms] UP soltado
[ 5544 ms] START pulsado
---- Pulsaciones ----
A 1
B 0
START 1
...
6. Solución de problemas
| Síntoma | Causa probable y solución |
|---|---|
| No aparece nada en el monitor serie | Estás en el puerto USB nativo, que deja de funcionar por el GPIO 20. Usa el puerto UART. |
| No se puede subir el programa por USB nativo | Igual que arriba. Si el puerto no aparece, mantén BOOT pulsado, pulsa EN y sube el programa. |
| Una pulsación cuenta varias veces | Botón con mucho rebote: sube ANTIRREBOTE_MS a 50. |
| Un botón aparece pulsado sin tocarlo | El pulsador está en cortocircuito con GND o mal soldado. |
| Un botón no responde | Revisa la soldadura y que vaya a GND, no a 3,3 V. |
| El LED no enciende | El LED está al revés: la pata larga (ánodo) va hacia el GPIO. |
| LEFT no funciona y se enciende el LED RGB | En la DevKitC-1 v1.0, el GPIO 48 lleva el LED RGB integrado. |
7. Retos
- Haz que LEFT y RIGHT alternen cuál de los dos LED está encendido.
- Detecta una pulsación larga: si A se mantiene más de 1 segundo, apaga los dos LED.
- Haz un juego de reflejos: el LED 1 se enciende tras un tiempo aleatorio y gana quien pulse A antes.
- Muestra en la pantalla qué botón está presionado.