Botones y rebotes

01 · Punto de partida

Presionás una vez, cuenta veinte

Armaste un contador que suma 1 cada vez que se pulsa un botón. Lo probás: pulsás una vez y el display muestra 7. Pulsás otra vez y salta a 19. El circuito está bien, el botón no está roto: el problema es que un contacto metálico, al cerrarse, rebota como una pelota contra el piso y genera una ráfaga de aperturas y cierres antes de quedar firme.

• ¿Cómo se define el valor de una entrada cuando el botón está suelto?
• ¿Cuánto dura un rebote y qué circuitos rompe?
• ¿Cómo se filtra con un capacitor y un Schmitt trigger?
• ¿Cómo se filtra con dos puertas NAND?
• ¿Cómo se filtra en software sin bloquear el programa?

02 · Pull-up y pull-down

Una entrada que nadie maneja

Un pulsador solo conecta dos puntos cuando se aprieta; suelto, no conecta nada. Si una entrada digital está conectada a un botón suelto, queda flotando: nadie la tira a 0 ni a 1, capta ruido y puede leer cualquier cosa (Temas 3 y 7). La solución es una resistencia que le da un valor por defecto: una resistencia de pull.

Qué valor de resistencia

Con pull-up y botón a masa, la resistencia queda entre VCC y GND cuando se pulsa, y por ella circula I = VCC / R. Un valor chico da una entrada firme pero malgasta corriente; uno grande ahorra, pero deja la entrada débil frente al ruido y a la pequeña corriente de fuga de la propia entrada.

Pull-up interno

La mayoría de los microcontroladores traen pull-ups programables (típicamente de 20 a 50 kΩ). Ahorran la resistencia externa pero no el rebote, y con cables largos o ruidosos pueden quedar cortos de fuerza.

Un pull consume poco

Con pull-up y botón a masa, la corriente solo circula mientras se pulsa. Suelto, el botón es un circuito abierto y no pasa nada: 0 mA.

Protección de la entrada

Con cables largos o botones accesibles al usuario se suele agregar una resistencia en serie (100 a 470 Ω) antes del pin para limitar corrientes por descargas estáticas o picos.

03 · Rebote

Veinte flancos por un dedo

Un pulsador mecánico es una lámina elástica que se aprieta contra un contacto. Cuando choca, la lámina rebota y se separa y vuelve a tocar varias veces hasta que se asienta. Mientras tanto, la entrada ve una serie de flancos rápidos. Lo mismo ocurre, en menor grado, al soltar.

Como orden de magnitud: unos pocos milisegundos, hasta unas decenas en los peores. Un microcontrolador a 16 MHz ejecuta miles de instrucciones en ese tiempo; para él, el rebote es una eternidad llena de eventos.

04 · Antirrebote por hardware

RC + Schmitt, o dos NAND

Un filtro RC con un Schmitt trigger

La idea: si la señal pasa por una resistencia R hacia un capacitor C, el voltaje del capacitor no puede cambiar de golpe. Cambia con una constante de tiempo τ = R · C. Los rebotes, que son más rápidos que τ, apenas lo mueven; el cambio sostenido sí lo hace subir o bajar hasta el nuevo valor.

Pero una rampa lenta en una entrada lógica común es un problema: mientras el voltaje cruza la zona entre 0 y 1 (Tema 3), la puerta puede oscilar o dar flancos dobles. El Schmitt trigger lo resuelve con histéresis: tiene dos umbrales. Para pasar de 0 a 1, la entrada tiene que subir hasta el umbral alto; para volver a 0, tiene que bajar hasta el umbral bajo, que es menor. Una vez que cruzó, pequeñas oscilaciones no lo hacen volver.

74HC14

Seis inversores Schmitt en un chip (Tema 7). A 4,5 V sus umbrales típicos rondan 2,4 V (subida) y 1,4 V (bajada); varían de un chip a otro y con la tensión, así que no los uses como valor exacto. Es el componente clásico de este filtro.

74HC132

Cuatro NAND de dos entradas con Schmitt. Sirve para el mismo filtro con una entrada extra de habilitación.

Qué valor de τ

El mismo orden que el rebote medido: si el botón rebota 10 ms, τ de unos 5 a 15 ms. Con 10 kΩ, 1 µF da 10 ms; 100 nF da 1 ms. Más grande filtra más, pero agrega retardo: el cambio demora unos 0,8 a 1,2 τ en cruzar los umbrales.

Variantes del circuito

La simétrica (R en serie después del botón y C a masa) demora por igual al pulsar y soltar. La simple (pull-up y C en paralelo con el botón) descarga el capacitor por el contacto casi sin retardo al pulsar, y tarda R·C al soltar. En ambas, el Schmitt va al final.

Dos NAND cruzadas: un latch SR

El Tema 9 mostró que dos NAND cruzadas guardan un bit. Con un interruptor de dos posiciones (SPDT, un común y dos contactos), cada contacto va a una entrada del latch con su pull-up. Mientras el común toca un contacto, esa entrada está en 0 y fija la salida. Cuando la lámina rebota y se separa de ese contacto, la entrada vuelve a 1 y el latch está en (1, 1): mantiene su estado. Solo cambia cuando el común toca el contacto opuesto, y eso no sucede hasta completar el recorrido.

Es un antirrebote perfecto, sin retardo y sin dependencia de un tiempo, pero necesita un conmutador de tres terminales, no un pulsador común. Se usa en relojes manuales de bancos de práctica y en interruptores de fin de carrera.

05 · Antirrebote por software

Ignorar el cambio por un rato

Con un microcontrolador, el antirrebote por software cuesta cero componentes: un par de líneas de código. Hay cuatro técnicas, de la más simple a la más robusta.

Con qué frecuencia leer

Lo más sencillo es muestrear el botón desde un temporizador cada 1 a 10 ms (sondeo, o polling) y procesar los cambios en el programa principal. Es más fácil de depurar que filtrar dentro de una interrupción.

Ventana mayor o igual al rebote

La regla de oro: W ≥ el tiempo de rebote medido, con margen. Típicamente 20 a 50 ms. Más largo agrega demora al responder a pulsaciones rápidas.

Detectar el cambio con XOR

El detector de cambios del Tema 10 sirve acá: cambio = nuevo ^ anterior marca qué botones cambiaron en un puerto entero, y se combina con la ventana para aceptarlos.

Interrupciones

Una interrupción por flanco dispara con el primer rebote. Una opción sensata: en la interrupción, solo anotar la hora y desactivarla durante W ms; la acción real se hace después, ya filtrada.

06 · Casos reales

Más allá del botón simple

Soltar también rebota

Al liberar el botón hay otra ráfaga. Un contador que cuenta flancos de bajada y no filtra puede contar falsos «cierres» durante esa ráfaga, porque el contacto cae un instante antes de quedar suelto. Filtrá los dos sentidos.

Pulsación larga y repetición

Con el estado ya filtrado, medir cuánto dura la pulsación permite distinguir un toque corto de uno largo (por ejemplo 300 ms o más) y repetir una acción mientras se mantiene. Es una pequeña máquina de estados.

Teclado matricial

Un teclado de 16 teclas se lee con 8 pines (4 filas y 4 columnas) en lugar de 16. Se activa una fila por vez y se leen las columnas; cada tecla rebota como un botón individual, así que el filtrado se aplica por tecla.

Encoder rotativo

Dos contactos que se abren y cierran en cuadratura al girar. También rebotan y se leen con la lógica del código Gray (Tema 5): entre un estado y el siguiente cambia un solo bit, y un salto de dos bits indica un error de lectura.

Cables largos y ruido

Un botón al final de un cable de metros recibe interferencias que parecen pulsaciones. Se combina pull-up fuerte (1 a 4,7 kΩ), resistencia en serie, capacitor y filtrado por software con ventana larga.

Tensiones distintas

Si el botón está en un sistema de 12 o 24 V, nunca lo conectes directo a un pin de 3,3 o 5 V: hace falta un divisor, un optoacoplador o una entrada industrial.

07 · Simulador

Laboratorio: presionar sin mentir

Cada vez que apretás «Presionar», el simulador genera un ciclo completo: el dedo aprieta el botón, lo mantiene y lo suelta. Cada transición produce una ráfaga de rebotes al azar. Esa señal cruda pasa por tres detectores en paralelo, y cada uno cuenta cuántas pulsaciones cree haber visto. Con las perillas modificás el rebote, el filtro RC y la ventana de software, y los trazos se actualizan al instante.

• Fila 1: el pin real (1 = suelto con pull-up, 0 = pulsado). Los puntos naranjas son los flancos de bajada que vería una interrupción simple.
• Fila 2: la tensión del capacitor del filtro RC, con sus dos umbrales de Schmitt.
• Filas 3 y 4: la salida del Schmitt y la salida del antirrebote por software con ventana. Los puntos naranjas son las pulsaciones que cada uno detecta.

Recorrido guiado (7 minutos)

1. 1
   Presioná varias veces con los valores iniciales.

   El contador crudo suma varias unidades por ciclo, mientras que el RC y el software suman 1. Un solo gesto del dedo, una sola pulsación real.

2. 2
   Mirá la fila del pin al soltar.

   La suelta también rebota. Por eso el crudo cuenta más que solo los rebotes de la pulsación: algunos de sus puntos naranjas aparecen cuando el botón se está soltando.

3. 3
   Bajá τ a 0,5 ms.

   El capacitor sigue a los rebotes y el Schmitt los deja pasar: el contador RC empieza a contar de más. Un filtro más rápido que el rebote no filtra.

4. 4
   Subí τ a 20 ms.

   La salida del Schmitt tarda más en reaccionar (mirá el retardo entre el dedo y el flanco limpio). Filtra bien, pero cuesta latencia; con una pulsación muy corta podría directamente no llegar al umbral.

5. 5
   Bajá la ventana de software a menos que el rebote.

   Con rebote de 10 ms y ventana de 3 ms, el software acepta un cambio cuando todavía rebota y cuenta pulsaciones falsas. La ventana tiene que ser mayor o igual que el rebote.

6. 6
   Subí el rebote a 40 ms con ventana de 20 ms.

   Ahora el rebote es más largo que la ventana: el software también falla. Un antirrebote es tan bueno como la medición que lo calibró.

7. 7
   Ventana en 0.

   Sin ventana el software cuenta igual que el pin crudo, muestreado cada milisegundo. Un detector sin filtro es solo un contador de flancos.

Preguntas para pensar

1. Con los valores iniciales, presioná 5 veces. ¿Cuánto vale cada contador? ¿Cuántas debería valer?
2. ¿Por qué el contador crudo suma más que los rebotes de la pulsación?
3. ¿Qué ventana mínima necesitás para un rebote de 25 ms? ¿Y qué τ de RC?
4. ¿Qué pasa si presionás con un rebote de 1 ms y una ventana de 50 ms? ¿Hay algún costo?

08 · Rebote en código

Generar, filtrar y contar

Estos bloques modelan un botón con rebotes reproducibles, calculan el efecto del pull-up, implementan tres filtros (ventana de tiempo, registro de muestras y máquina de estados con pulsación corta y larga) y simulan el filtro RC con Schmitt para comprobar qué τ funciona.

Paso 1: el pull-up y su corriente

VCC = 5.0
FUGA = 1e-6          # corriente de fuga de la entrada, orden de magnitud

print("   R (ohm)   I pulsado    caída por fuga")
for R in (1_000, 4_700, 10_000, 100_000, 1_000_000):
    i = VCC / R
    caida = FUGA * R
    print(f"{R:>10,}   {i * 1000:7.3f} mA   {caida:6.3f} V")

10 kΩ: 0,5 mA y apenas 10 mV de caída. 1 MΩ: 5 µA de consumo, pero una fuga de 1 µA ya resta 1 V a un «1» de 5 V: la entrada queda débil.

Paso 2: un ciclo de pulsación con rebotes

import random


def ciclo(rng, rebote=10, t_p=5, t_r=40, largo=70):
    # una muestra por ms: 1 = suelto (pull-up), 0 = pulsado
    def cambios():
        k = rng.choice([1, 2, 3, 4])
        return [0] + sorted(rng.sample(range(1, rebote), 2 * k))

    cp, cr = cambios(), cambios()
    muestras = []
    for t in range(largo):
        n = sum(1 for c in cp if t - t_p >= c) + sum(1 for c in cr if t - t_r >= c)
        muestras.append(1 if n % 2 == 0 else 0)
    return muestras


def bajadas(m):
    return sum(1 for a, b in zip(m, m[1:]) if a == 1 and b == 0)


rng = random.Random(7)
m = ciclo(rng)
print("".join("▔" if x else "▁" for x in m))
print("flancos de bajada vistos por una interrupción simple:", bajadas(m), "(el dedo hizo 1)")

El dedo hizo una pulsación, pero el pin tiene varios flancos de bajada: los de la pulsación y los de la suelta. Cambiá la semilla y verás otro número, casi siempre mayor que 1.

Paso 3: ventana de ignorar (no bloqueante)

import random


def ciclo(rng, rebote=10, t_p=5, t_r=40, largo=70):
    def cambios():
        k = rng.choice([1, 2, 3, 4])
        return [0] + sorted(rng.sample(range(1, rebote), 2 * k))
    cp, cr = cambios(), cambios()
    return [1 if (sum(1 for c in cp if t - t_p >= c) + sum(1 for c in cr if t - t_r >= c)) % 2 == 0 else 0
            for t in range(largo)]


def debounce(muestras, ventana):
    estado, ultimo, eventos = 1, -10**9, []
    for t, m in enumerate(muestras):
        if m != estado and t - ultimo >= ventana:
            estado, ultimo = m, t
            eventos.append((t, "presión" if m == 0 else "suelta"))
    return eventos


m = ciclo(random.Random(7), rebote=10)
for ventana in (0, 2, 5, 10, 20):
    ev = debounce(m, ventana)
    pulsaciones = sum(1 for _, e in ev if e == "presión")
    print(f"ventana {ventana:>2} ms: {pulsaciones} presión(es), {len(ev)} eventos")

Con ventana 0 el filtro acepta todo y cuenta de más. A medida que crece y alcanza el rebote (10 ms), los eventos bajan a 2 (una presión y una suelta). La ventana tiene que ser ≥ al rebote.

Paso 4: registro de muestras consecutivas

import random


def ciclo(rng, rebote=10, t_p=5, t_r=40, largo=70):
    def cambios():
        k = rng.choice([1, 2, 3, 4])
        return [0] + sorted(rng.sample(range(1, rebote), 2 * k))
    cp, cr = cambios(), cambios()
    return [1 if (sum(1 for c in cp if t - t_p >= c) + sum(1 for c in cr if t - t_r >= c)) % 2 == 0 else 0
            for t in range(largo)]


def debounce_registro(muestras):
    h, estado, eventos = 0xFF, 1, []
    for t, m in enumerate(muestras):
        h = ((h << 1) | m) & 0xFF           # historial de las últimas 8 muestras
        if h == 0x00 and estado == 1:
            estado = 0
            eventos.append((t, "presionado"))
        elif h == 0xFF and estado == 0:
            estado = 1
            eventos.append((t, "soltado"))
    return eventos


for semilla in (7, 8, 9):
    m = ciclo(random.Random(semilla))
    print(f"semilla {semilla}:", debounce_registro(m))

Hace falta ver 8 muestras iguales seguidas (0x00 o 0xFF) para aceptar el cambio. Cuesta un retardo de unos 8 ms, pero filtra también picos de ruido que no son rebotes.

Paso 5: pulsación corta o larga

import random


def ciclo(rng, rebote=10, t_p=5, t_r=40, largo=70):
    def cambios():
        k = rng.choice([1, 2, 3, 4])
        return [0] + sorted(rng.sample(range(1, rebote), 2 * k))
    cp, cr = cambios(), cambios()
    return [1 if (sum(1 for c in cp if t - t_p >= c) + sum(1 for c in cr if t - t_r >= c)) % 2 == 0 else 0
            for t in range(largo)]


class Boton:
    def __init__(self, ventana=20, largo_ms=300):
        self.estado, self.ult, self.t_press = 1, -10**9, None
        self.ventana, self.largo = ventana, largo_ms

    def muestrear(self, t, m):
        if (m ^ self.estado) and t - self.ult >= self.ventana:   # XOR: ¿cambió?
            self.estado, self.ult = m, t
            if m == 0:
                self.t_press = t
                return "presión"
            return "suelta larga" if t - self.t_press >= self.largo else "suelta corta"
        return None


rng = random.Random(3)
for nombre, t_r, largo in (("toque", 55, 100), ("sostenido", 405, 500)):
    b = Boton()
    ev = [(t, e) for t, m in enumerate(ciclo(rng, 10, 5, t_r, largo)) if (e := b.muestrear(t, m))]
    print(nombre, ev)

Con el estado ya filtrado, medir el tiempo entre la presión y la suelta distingue un toque (≈ 50 ms) de una pulsación sostenida (≈ 400 ms). El detector de cambios es el XOR del Tema 10.

Paso 6: filtro RC con Schmitt

from math import log
import random


def ciclo(rng, rebote=10, t_p=5, t_r=60, largo=110):
    def cambios():
        k = rng.choice([1, 2, 3, 4])
        return [0] + sorted(rng.sample(range(1, rebote), 2 * k))
    cp, cr = cambios(), cambios()
    return [1 if (sum(1 for c in cp if t - t_p >= c) + sum(1 for c in cr if t - t_r >= c)) % 2 == 0 else 0
            for t in range(largo)]


def rc_schmitt(muestras_ms, tau_ms, vt_alto=0.55, vt_bajo=0.30, dt=0.1):
    vc, salida, caidas = 1.0, 1, 0
    for m in muestras_ms:
        for _ in range(round(1 / dt)):
            vc += (m - vc) * dt / tau_ms
            if salida == 1 and vc <= vt_bajo:
                salida, caidas = 0, caidas + 1
            elif salida == 0 and vc >= vt_alto:
                salida = 1
    return caidas


m = ciclo(random.Random(3))
for tau in (0.3, 1, 3, 5, 10):
    print(f"τ = {tau:>4} ms -> pulsaciones contadas: {rc_schmitt(m, tau)}")

print()
for R, C in ((10_000, 100e-9), (10_000, 1e-6), (10_000, 4.7e-6)):
    tau = R * C * 1000
    print(f"R={R:,} C={C * 1e6:g} µF  τ={tau:5.1f} ms  sube≈{tau * log(1 / (1 - 0.55)):5.1f} ms  baja≈{tau * log(1 / 0.30):5.1f} ms")

Con τ mucho menor que el rebote el Schmitt deja pasar flancos de más; con τ del orden del rebote cuenta 1. La segunda tabla da los retardos: el cambio recién se ve a 0,8 τ (subida) y 1,2 τ (bajada).

09 · Analogía de programador

Debounce, throttle y el usuario impaciente

Si trabajaste con interfaces, ya conocés el problema con otros nombres. En JavaScript hay dos técnicas con nombre propio, y las dos aparecen en el hardware.

1. 1
   Rebote = ráfaga de eventos duplicados.

   Un solo gesto genera muchos eventos casi iguales; hay que decidir cuándo son «el mismo».

2. 2
   Ventana de software = throttle.

   Reacciona al primer flanco y descarta los siguientes. Rápido, pero se confía en que el primer flanco es real.

3. 3
   RC + Schmitt = debounce.

   Espera a que la señal se calme. Más lento, pero filtra picos aislados que el throttle aceptaría como un primer evento.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de botones

Ejercicio 1: elegir el RC

Medís un rebote de 15 ms. Elegí R y C para que τ sea del mismo orden. ¿Sirven 10 kΩ y 1,5 µF? ¿Cuánto tarda en verse el cambio al pulsar y al soltar (umbrales al 30 % y 55 % de VCC)?

Ejercicio 2: el antirrebote con dos NAND

Dibujá un conmutador SPDT con dos NAND cruzadas y dos pull-ups. Explicá por qué los rebotes no alteran la salida. ¿Por qué no sirve un pulsador común de dos terminales?

Ejercicio 3: medir tu botón

Con un osciloscopio sobre un botón con pull-up, configurá el disparo en flanco de bajada, modo único, y presioná 5 veces. ¿Qué anotás de cada captura? ¿Cómo elegís la ventana de software?

Ejercicio 4: elegir el pull-up

Un botón a 2 metros de la placa, en un ambiente con motores, funciona a 3,3 V. ¿Qué valor de pull-up elegís y cuánto consume pulsado? ¿Y si el aparato corre con una batería y el botón se usa pocas veces por día?

Ejercicio 5: ventana mínima en software

Medís un rebote máximo de 12 ms. Tu programa lee el botón cada 1 ms. ¿Qué ventana elegís y qué pasa con dos pulsaciones muy rápidas? Verificá con debounce().

Ejercicio 6: cuatro botones en un puerto

Cuatro botones se leen juntos en los bits de un puerto, una vez por milisegundo. ¿Cómo sabés cuáles cambiaron desde la lectura anterior con una sola operación, y cuáles se acaban de pulsar (con pull-up, activos en bajo)?

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 12?

Podés avanzar si sos capaz de responder esto sin mirar:

• Dibujar un botón con pull-up y decir qué lee la entrada suelto y pulsado.
• Calcular la corriente de un pull-up de 4,7 kΩ a 3,3 V.
• Explicar por qué un contador por flancos suma de más y un LED no lo nota.
• Elegir R y C para un rebote de 10 ms y decir qué retardo agregan.
• Explicar para qué sirven los dos umbrales de un Schmitt trigger.
• Describir cómo dos NAND cruzadas ignoran los rebotes.
• Elegir una ventana de software y justificarla con una medición.

Ya sabés dominar una entrada rebelde. Ahora hay que conectar todo en una placa de verdad: en el próximo tema, chips 74HCxx en la mesa de trabajo.