Taller: contador de eventos

01 · Punto de partida

Tres montajes que se apoyan uno en otro

Un contador de eventos tiene tres bloques en fila: la entrada (convierte una pulsación mecánica en un flanco limpio), el contador (suma un evento por flanco) y la salida (convierte los bits BCD en una imagen decimal legible). Cada montaje agrega uno de ellos y se prueba antes de pasar al siguiente.

Como en los talleres anteriores, no hace falta tener los materiales: el código reproduce el filtro, el decodificador y la cascada, y el laboratorio simula el contador con un pulsador que rebota.

02 · Preparación

Materiales y herramientas

Un osciloscopio muestra los rebotes y la acción del filtro de forma inmediata; con el multímetro se pueden comprobar las tensiones en reposo. Dibujá el esquema con los números de pin: el 4511 tiene las entradas y las salidas en patas que no siguen un orden evidente.

Antes de dar tensión

• Cada chip con su 100 nF entre alimentación y masa.
• Ninguna entrada al aire: en los 74HC160, las entradas de datos P0–P3 y las de habilitación van a un nivel fijo; en el 74HC14, los inversores sin usar tienen la entrada a masa.
• Cada segmento con su resistencia en serie; ningún segmento directo a una salida.
• El tipo de display (cátodo común o ánodo común) se comprueba con la hoja de datos: el 4511 maneja cátodo común.

03 · Los chips

74HC14, 74HC160 y 74HC4511

74HC14: inversores con histéresis

Seis inversores Schmitt en 14 patas: la entrada de cada uno es A y la salida Y. Los pares son (1, 2), (3, 4), (5, 6), (9, 8), (11, 10) y (13, 12); Vcc es el pin 14 y GND el pin 7. La histéresis (el inversor sube con una tensión de entrada y baja con otra menor) es lo que permite aceptar la subida lenta del condensador sin generar flancos múltiples.

74HC160: década BCD

Los nombres CEP, CET y TC son los de Philips/NXP; Texas Instruments usa ENP, ENT y RCO (tema 18). Es el mismo chip del tema 19: cuenta 0 a 9. Para este taller se prefiere el 160 (y no el 162) por una razón práctica: su clear es asíncrono, así que un botón de reset funciona aunque no haya reloj.

74HC4511: BCD a siete segmentos

Las salidas son activas en alto (cátodo común). Para códigos BCD mayores que 1001 (los nibbles 1010 a 1111) el 4511 apaga todos los segmentos: es la señal visible de que el contador salió de la secuencia válida. Tiene tres controles:

El control LE es un latch D del tema 6: con LE = 0 el chip es transparente; con LE = 1 retiene. Sirve para congelar la lectura mientras el contador sigue contando, algo muy útil en un instrumento.

04 · Montaje 1

Entrada limpia y una década

El pulsador se conecta entre la entrada del inversor y masa, con un pull-up de 100 kΩ y un condensador de 100 nF en paralelo. Al apretar, el contacto descarga el condensador casi al instante; al soltar, el condensador se carga lentamente a través de los 100 kΩ (τ = 100 kΩ · 100 nF = 10 ms). Los rebotes duran milisegundos, pero cada reapertura del contacto solo carga el condensador unas décimas de voltio, muy por debajo del umbral de la histéresis del Schmitt, así que no llegan a la salida.

Pruebas

El paso 6 es el experimento que justifica el montaje: sin el filtro, cada rebote es un evento más. Con el osciloscopio en el nodo se ve la subida lenta del condensador a la suelta y el pulso corto, limpio, de la salida del Schmitt.

05 · Montaje 2

Un dígito en el display

El 74HC4511 traduce los cuatro bits BCD en las señales de los siete segmentos. Las salidas Q de la década van a las entradas A, B, C y D del decodificador, y cada segmento, con su resistencia, a la pata correspondiente del display de cátodo común.

Pruebas

• Secuencia: cada pulsación avanza el dígito 0, 1, 2 … 9, 0. Los LED de Q3..Q0 pueden quedar como referencia.
• LT̅ a masa: se enciende el 8 completo (todos los segmentos), sea cual sea el contador. Es la prueba rápida del display y del cableado.
• BI̅ a masa: el display se apaga; al soltarlo, el dígito reaparece.
• LE a +5 V: el display se congela en el dígito actual; los LED siguen contando. Al volver LE a masa, el display salta al valor real.
• Código inválido: si se logra un estado 1010 a 1111 (por ejemplo, cargando datos con PE̅), el display queda en blanco.

Observá que los segmentos corresponden a patrones fijos: el 1 enciende solo b y c; el 7, a, b y c; el 8, los siete; y los dígitos 0, 1 y 7 son los únicos que no usan el segmento g. Eso permite diagnosticar a simple vista un segmento defectuoso (sección 7).

06 · Montaje 3

Dos dígitos, reset y desborde

Se duplica el bloque contador-decodificador-display y se encadenan las décadas como en el tema 19: el TC de las unidades habilita (CET) a las decenas, y el reloj es común. Un único reset borra ambas décadas.

Al encender, el condensador de 1 µF está descargado: el nodo de MR̅ vale 0 V y sube con τ = 10 kΩ · 1 µF = 10 ms. Durante esos primeros milisegundos MR̅ está en bajo y las dos décadas quedan en 00. Con el pulsador de reset se repite el borrado a mano. Para un flanco de subida más limpio se puede pasar la señal por dos inversores libres del 74HC14, como en el tema 10.

Pruebas

• Encendido: el display arranca en 00 todas las veces (probá diez encendidos seguidos).
• Cuenta: contando de 0 a 10 la cifra de las decenas pasa de 0 a 1 exactamente cuando las unidades vuelven a 0.
• Desborde: el LED de TC de las decenas se enciende en 99, y al pulsar una vez más vuelve a 00.
• Reset: con el contador en un valor cualquiera, el pulsador de reset lo lleva a 00 sin reloj.
• Congelado: con LE en alto, los dos dígitos permanecen fijos mientras se sigue pulsando; al bajar LE, aparecen los dígitos reales.
• Prueba larga: pulsar 100 veces, contando con las manos; el display debe volver a mostrar el valor de partida.

07 · Cuando no funciona

Corrientes, fallas y método

Corriente de los segmentos

Cada segmento es un LED. Con 1 kΩ en serie y unos 2 V de caída, circulan alrededor de (5 − 2) / 1 kΩ = 3 mA por segmento; el dígito 8 (siete segmentos) toma unos 21 mA, y los dos dígitos en 88 unos 42 mA. Las salidas del 74HC4511 son menos robustas que las del clásico CD4511B, así que conviene empezar con 1 kΩ y verificar los límites en la hoja de datos antes de bajar la resistencia (por ejemplo, a 330 Ω) para ganar brillo.

Armar por etapas

1. Alimentación primero: Vcc, GND y el 100 nF en cada chip.
2. La entrada sola: medir el nodo del pulsador y la salida del Schmitt antes de conectar el contador.
3. Un dígito con LED: probar el contador de década con los cuatro LED antes del decodificador.
4. El decodificador con LT̅, BI̅ y LE: comprobar los tres controles antes de confiar en la lectura.
5. Después, la cascada: con la segunda década, probar el paso de 09 a 10.
6. Cambiar una sola cosa a la vez y comparar la secuencia observada con la esperada.

08 · El taller en código

Filtrar, decodificar, contar y medir

Los bloques reproducen el filtro RC con Schmitt sobre una pulsación con rebotes, generan el código de siete segmentos de cada dígito, simulan la cascada de dos décadas con el control de congelado y comparan la cuenta con y sin filtro.

Paso 1: el filtro RC con Schmitt frente a los rebotes

# Pulsador con pull-up de 100 kΩ y condensador de 100 nF; un inversor Schmitt (74HC14) detrás.
R, C = 100e3, 100e-9
tau = R * C
VCC, VT_ALTA, VT_BAJA = 5.0, 2.7, 1.8
dt = 0.1e-3                                    # paso de 0,1 ms

# Contacto: 1 = cerrado (a masa). Se aprieta en t = 10 ms con rebotes, se suelta en t = 100 ms con rebotes.
def contacto(t):
    ms = t * 1e3
    rebote_apretar = [(10.0, 10.4), (10.8, 11.1), (11.6, 12.0), (12.3, 12.5)]       # tramos abiertos
    rebote_soltar = [(100.0, 100.3), (100.7, 100.9), (101.5, 101.6)]               # tramos cerrados
    if ms < 10.0:
        return 0
    if ms < 100.0:
        return 0 if any(a <= ms < b for a, b in rebote_apretar) else 1
    if ms < 102.0:
        return 1 if any(a <= ms < b for a, b in rebote_soltar) else 0
    return 0


vc, salida, t = VCC, 0, 0.0                    # salida del Schmitt (inversor): alta cuando la entrada está baja
crudo_prev, flancos_crudos, flancos_filtro, vmax_rebote = 0, 0, 0, 0.0
salida = 0
while t < 0.15:
    cerrado = contacto(t)
    vc = 0.0 if cerrado else vc + (VCC - vc) * dt / tau
    # Schmitt inversor: la salida sube cuando vc baja de VT_BAJA y baja cuando vc supera VT_ALTA
    if salida == 0 and vc < VT_BAJA:
        salida = 1
        flancos_filtro += 1
        print(f"  t = {t * 1e3:6.1f} ms: salida del 74HC14 sube (evento contado)")
    elif salida == 1 and vc > VT_ALTA:
        salida = 0
        print(f"  t = {t * 1e3:6.1f} ms: salida del 74HC14 baja (soltó)")
    if 0.0105 < t < 0.020:                       # desde el primer cierre hasta que el contacto se estabiliza
        vmax_rebote = max(vmax_rebote, vc)
    if cerrado and not crudo_prev:
        flancos_crudos += 1
    crudo_prev = cerrado
    t += dt

print(f"tau = {tau * 1e3:.0f} ms; el condensador sube como máximo {vmax_rebote:.2f} V durante los rebotes de la pulsación (umbral de bajada del Schmitt: {VT_BAJA} V)")
print(f"cierres del contacto (4 al apretar y 2 al soltar): {flancos_crudos}")
print(f"flancos ascendentes a la salida filtrada: {flancos_filtro}")
print(f"tiempo hasta que el Schmitt detecta la suelta: {-tau * __import__('math').log(1 - VT_ALTA / VCC) * 1e3:.1f} ms")

El contacto cierra seis veces (cuatro al apretar y dos al soltar), pero la salida del Schmitt sube una sola vez, a los 10,5 ms. Durante los rebotes de la pulsación el condensador sube como máximo 0,20 V, lejos del umbral de 1,8 V. La salida baja recién a los 109,3 ms, unos 7,8 ms después del último rebote de la suelta. Cambiá R o C a la mitad y mirá cómo se acorta ese tiempo.

Paso 2: el código de siete segmentos

SEGMENTOS = {                     # a b c d e f g  (cátodo común: 1 = encendido)
    0: "1111110", 1: "0110000", 2: "1101101", 3: "1111001", 4: "0110011",
    5: "1011011", 6: "1011111", 7: "1110000", 8: "1111111", 9: "1111011",
}


def dibujar(numero):
    d1, d2 = f"{numero:02d}"
    filas = ["", "", "", "", ""]
    for d in (d1, d2):
        a, b, c, dd, e, f, g = (s == "1" for s in SEGMENTOS[int(d)])
        filas[0] += " " + ("_" if a else " ") + "   "
        filas[1] += ("|" if f else " ") + ("_" if g else " ") + ("|" if b else " ") + "  "
        filas[2] += ("|" if e else " ") + ("_" if dd else " ") + ("|" if c else " ") + "  "
    return "\n".join(filas[:3])


print("código de 7 segmentos (a b c d e f g) por dígito:")
for dig, cod in SEGMENTOS.items():
    print(f"  {dig}: {cod}   ({cod.count('1')} segmentos)")
print()
print(dibujar(47))
print()
print(dibujar(80))
print()
total = sum(cod.count("1") for cod in SEGMENTOS.values())
print(f"promedio de segmentos encendidos por dígito: {total / 10:.1f}")
print(f"corriente a 5 mA por segmento: máximo {7 * 5} mA por dígito (el 8), unos {total / 10 * 5:.1f} mA en promedio")

La tabla muestra el patrón a b c d e f g de cada dígito; solo 0, 1 y 7 tienen el segmento g apagado, y el 8 enciende los siete. El dibujo en texto compone 47 y 80 con esos patrones. En promedio un dígito enciende 4,9 segmentos, así que a 5 mA por segmento el consumo medio ronda los 24,5 mA y el máximo (el 8) llega a 35 mA por dígito. Cambiá el número que se dibuja.

Paso 3: dos décadas, display y congelado

class Decada:
    def __init__(self):
        self.q = 0

    def rco(self, ent):
        return int(ent and self.q == 9)

    def flanco(self, ent=1):
        if ent:
            self.q = (self.q + 1) % 10


class Visor:
    """Dos décadas en cascada y un decodificador con latch (LE) delante del display."""

    def __init__(self):
        self.u, self.d = Decada(), Decada()
        self.le = 0
        self.mostrado = 0
        self.desbordes = 0

    def evento(self):
        ent_d = self.u.rco(1)
        desborda = self.d.rco(ent_d)
        self.d.flanco(ent_d)
        self.u.flanco(1)
        if desborda:
            self.desbordes += 1
        if not self.le:                                # LE = 1 congela lo que muestra el display
            self.mostrado = self.d.q * 10 + self.u.q

    @property
    def cuenta(self):
        return self.d.q * 10 + self.u.q


v = Visor()
for k in range(1, 131):
    if k == 40:
        v.le = 1                                       # congelo el display
    if k == 46:
        v.le = 0
        v.mostrado = v.cuenta                          # al soltar LE se actualiza
    v.evento()
    if k in (9, 10, 39, 40, 41, 45, 46, 99, 100, 101, 130):
        print(f"evento {k:3d}: contador {v.cuenta:02d}  display {v.mostrado:02d}  desbordes {v.desbordes}")

Hasta el evento 39 el display sigue al contador. En el 40 se activa LE: el contador pasa a 40, 41 … 45 pero el display queda en 39. Al soltar LE en el 46 el display salta al valor real. En el evento 100 el contador desborda a 00 (un desborde) y sigue 01 … hasta 30 en el evento 130. Es el comportamiento del 4511 con su latch interno.

Paso 4: con y sin filtro

import random

rnd = random.Random(3)
PULSACIONES = 50


def flancos_por_pulsacion(max_rebotes):
    return 1 + rnd.randint(0, max_rebotes)


def contar(max_rebotes, con_filtro):
    cuenta, flancos_total = 0, 0
    for _ in range(PULSACIONES):
        f = flancos_por_pulsacion(max_rebotes)
        flancos_total += f
        cuenta = (cuenta + (1 if con_filtro else f)) % 100
    return cuenta, flancos_total


esperado = PULSACIONES % 100
print(f"{PULSACIONES} pulsaciones reales; el display debería mostrar {esperado:02d}")
print("rebotes máx.   sin filtro (cuenta, flancos)   con filtro RC (cuenta)")
for m in (0, 1, 3, 6):
    sin, fl = contar(m, False)
    con, _ = contar(m, True)
    print(f"{m:6d}         {sin:02d} ({fl:3d} flancos)               {con:02d}")
print()
tau = 10e-3
import math
t_suelta = -tau * math.log(1 - 2.7 / 5)
print(f"el filtro tarda {t_suelta * 1e3:.1f} ms en dar por soltado el pulsador")
print(f"frecuencia máxima de pulsaciones contables ≈ {1 / (2 * t_suelta):.0f} por segundo (muy por encima de cualquier mano)")

Sin rebotes, la cuenta es exacta con o sin filtro (50). Con hasta 1 rebote por pulsación entran 80 flancos y el display mostraría 80; con hasta 3, 114 flancos y 14; con hasta 6, 202 flancos y 02. Con el filtro, la cuenta es siempre 50. Notá que con 1 rebote máximo el resultado «80» tiene aspecto razonable: el error no se nota a simple vista, lo que lo hace más peligroso. El filtro limita la velocidad máxima a unas 64 pulsaciones por segundo, una cifra enorme para un dedo.

Los cuatro bloques cubren los tres lados del taller (entrada, visualización y cuenta) y dejan claro dónde está el verdadero riesgo: la entrada mecánica.

09 · Exploración interactiva

El banco de pruebas

El simulador reproduce el contador de eventos de dos cifras. «Pulsar» da una pulsación: con el pulsador directo, el contador recibe un flanco por la pulsación más una cantidad aleatoria de rebotes (hasta el máximo elegido); con el filtro RC y Schmitt activado, siempre uno. Los displays muestran el valor del decodificador, que se puede congelar con LE, apagar con BI̅ o probar con LT̅. El panel compara la cuenta con el número real de pulsaciones.

Recorrido guiado

1. Con el filtro desactivado y 3 rebotes extra máximos, presioná «Pulsar» varias veces: la cuenta salta y casi nunca coincide con las pulsaciones reales. «Flancos de la última pulsación» muestra cuántos flancos entraron.
2. Bajá los rebotes extra a 0 y repetí: el pulsador se porta como uno ideal y la cuenta coincide. Es el caso optimista que no existe en la realidad.
3. Marcá el filtro RC + Schmitt y presioná «10 pulsaciones»: la cuenta es exactamente 10 y «Flancos acumulados» coincide con las pulsaciones.
4. Con el filtro, presioná «10 pulsaciones» varias veces hasta pasar el 99: la cuenta vuelve a 00 y «Desbordes» sube a 1. El display lo muestra como 00, 01, 02 …
5. Marcá LE = 1 y presioná «Pulsar» cinco veces: el contador avanza pero el display permanece fijo. Desmarcá LE: el display salta al valor real.
6. Marcá BI̅ = 0: el display se apaga pero el contador sigue sumando; al desmarcar, el valor reaparece.
7. Marcá LT̅ = 0: ambos dígitos muestran 88, sea cual sea la cuenta. Es la prueba de segmentos.
8. Presioná «Reset (MR̅)»: la cuenta vuelve a 00 sin ningún flanco. Compará con el contador del tema 19, donde el clear síncrono necesitaba reloj.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de armar

1. Constante de tiempo

Se usa 47 kΩ y 100 nF en la entrada. ¿Cuánto vale τ y cuánto tarda el nodo en llegar a 2,7 V (umbral de subida del Schmitt) tras soltar el pulsador?

2. Qué segmentos

La década está en 0111 (7). ¿Qué entradas D C B A recibe el 4511 y qué segmentos se encienden?

3. Corriente de dos dígitos

Con resistencias de 1 kΩ y 2 V de caída en cada segmento, ¿cuánto consume el display mostrando 88 y 11?

4. Desbordes

Se aprietan 250 veces el pulsador desde 00 (con filtro). ¿Qué muestra el display y cuántas veces pasó de 99 a 00?

5. Congelar y liberar

El contador está en 37 y se pone LE = 1. Llegan 5 pulsaciones más y después LE = 0. ¿Qué muestra el display en cada momento?

6. Diagnóstico

Los dígitos 0, 1 y 7 se ven perfectos y los demás aparecen incompletos, siempre con el segmento del medio apagado. ¿Qué falla y cómo se confirma?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 21?

Antes de avanzar, explicá de memoria por qué el filtro necesita un Schmitt, cómo habilita la década de las decenas a la de las unidades y qué hacen LE, BI̅ y LT̅. Si podés justificar las tres respuestas, ya podés pasar de contar a recorrer secuencias.

En el próximo tema veremos los contadores en anillo y Johnson: registros de desplazamiento realimentados que recorren secuencias repetitivas y activan sus salidas en orden, sin decodificador.