Saltar a contenido

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:

3,3 V ──┐
        ≷ pull-up interna (≈45 kΩ)
        │
GPIO ───┤
        │
       ─┴─ pulsador
        │
GND ────┘

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 es HIGH y pulsado es LOW.

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:

  1. Cada vez que la lectura cambia, apunta el momento en b.cambio.
  2. Solo acepta el nuevo estado cuando la lectura lleva 30 ms sin cambiar.
  3. Si el estado aceptado pasa a LOW, devuelve true: es una pulsación nueva. Si pasa a HIGH, marca soltado.

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

  1. Haz que LEFT y RIGHT alternen cuál de los dos LED está encendido.
  2. Detecta una pulsación larga: si A se mantiene más de 1 segundo, apaga los dos LED.
  3. Haz un juego de reflejos: el LED 1 se enciende tras un tiempo aleatorio y gana quien pulse A antes.
  4. Muestra en la pantalla qué botón está presionado.