Taller: memoria de un bit y antirrebote

01 · Punto de partida

Una memoria de un bit que se puede tocar

En el tema 5 vimos que dos NAND realimentadas retienen un bit, y en el tema 6 que con unas puertas más se obtiene un latch D. Todo eso sigue siendo papel. Este tema lo convierte en un circuito que se prende, se mide y se rompe. Vas a armar tres montajes, cada uno sobre el anterior:

No hace falta tener los materiales para aprovechar el tema: el laboratorio simula el banco de pruebas y el código verifica cada tabla. Pero si tenés un protoboard y unos centavos de chips, armarlo es la mejor manera de que la teoría se quede.

02 · Preparación

Materiales y herramientas

Del lado de los instrumentos, el multímetro alcanza para el montaje 1. Para ver el rebote hace falta un osciloscopio o un analizador lógico, con disparo en un solo evento (single shot) y una escala de tiempo de 1 a 2 ms por división. Si no tenés ninguno, el laboratorio de este tema lo simula.

Antes de dar tensión

• Alimentación en los pines 14 (Vcc) y 7 (GND) de cada 74HC00, con el 100 nF entre ellos, lo más corto posible.
• Ninguna entrada al aire: las que usás, con pull-up o conectadas a una salida; las de las compuertas sobrantes, a masa.
• Ningún cable entre dos salidas.
• Polaridad de los LED revisada: el ánodo (pata larga) va hacia la resistencia y la salida; el cátodo, a masa.

Es la lista del checklist de buenas prácticas del curso de Electrónica Digital, aplicada a un circuito concreto.

03 · Montaje 1

La memoria de un bit

El 74HC00 tiene la misma disposición de pines que el viejo 7400: cuatro NAND con sus entradas A y B y su salida Y. Usaremos dos de ellas, realimentadas, que son el latch de NAND del tema 5, con entradas activas en bajo: S̄ para poner (Set) y R̄ para borrar (Reset).

Las ecuaciones son las del tema 5: Q = NAND(S̄, ~Q) y ~Q = NAND(R̄, Q). Observá el cruce: la salida de cada compuerta (pines 3 y 6) vuelve a una entrada de la otra (pines 5 y 2). Es el lazo biestable en su forma más compacta.

04 · Verificar

Pruebas y mediciones

Probá el montaje con la lista siguiente, en orden, anotando qué LED se enciende. Es el mismo método de la mesa de trabajo del curso anterior: una secuencia corta, cada paso con un resultado esperado.

Mediciones con el multímetro

• Alimentación: entre los pines 14 y 7 debe haber unos 5 V, con el circuito encendido.
• Reposo: los nodos S̄ y R̄ deben medir cerca de 5 V (pull-up). Si medís un valor intermedio, falta o está floja una conexión.
• Salidas: Q y ~Q deben medir cerca de 0 V y cerca de 5 V, una de cada. Un valor a mitad de camino indica una salida cargada de más o una entrada flotante.
• Pulsadores: al apretar SET, el nodo S̄ debe bajar a casi 0 V.

El paso 1 merece atención: no se puede predecir con qué estado arranca. En una repetición del experimento puede salir encendido el LED de Q y en otra el de ~Q. En un diseño que necesite un valor conocido al encender, hay que forzarlo con un Reset inicial; es la lección del tema 4 convertida en algo que se ve.

05 · El problema

Por qué un latch limpia el rebote

Un contacto mecánico no cierra de una vez: las láminas rebotan unas fracciones de milisegundo antes de asentarse, y la señal salta entre 1 y 0 decenas de veces. Para una lámpara es invisible; para un contador o una interrupción, cada salto es una pulsación. En el curso de Electrónica Digital vimos dos remedios: un filtro RC con disparador Schmitt y una ventana de espera por software. Hay un tercero, que depende de lo que acabamos de armar.

La idea del tercer método es que el rebote solo ocurre sobre el contacto que acaba de cerrarse. Con el conmutador de palanca, el terminal común está a masa; al mover la palanca de B hacia A:

1. La palanca se separa de B: R̄ pasa a 1 (con pull-up) y, mientras viaja, ni S̄ ni R̄ valen 0. El latch retiene.
2. La palanca toca A: S̄ baja a 0. El latch hace Set: Q = 1.
3. La palanca rebota sobre A: S̄ sube y baja varias veces. Cuando S̄ vale 1, ambas entradas valen 1 y el latch retiene; cuando vale 0, repite el Set, que ya estaba hecho. Q no vuelve a cambiar.

El latch no filtra tiempo: se vuelve indiferente a las repeticiones. Por eso no necesita ninguna constante de tiempo y funciona con cualquier duración de rebote. Lo que sí exige es que la palanca nunca toque A y B a la vez (no pasar por la combinación prohibida), cosa que un conmutador de dos posiciones garantiza por construcción.

06 · Montaje 2

Conmutador de palanca y latch

Se reutiliza el montaje 1. Se quitan los dos pulsadores y se coloca el conmutador SPDT entre los nodos S̄ y R̄:

Con la palanca en A, S̄ vale 0 y R̄ vale 1: Q = 1. Con la palanca en B: Q = 0. Cada movimiento produce un único cambio en Q, sin importar cuántas veces rebote el contacto.

Cómo verlo

• Con osciloscopio o analizador lógico: conectá un canal al nodo S̄ (o R̄) y otro a Q. Disparo en un solo evento, con flanco de bajada en S̄ y 1 ms por división. En S̄ vas a ver una ráfaga de saltos; en Q, un solo escalón.
• Con un contador: si alimentás un contador (lo armaremos en los próximos temas) con el nodo S̄ directo, suma varias unidades por maniobra; con Q, suma una. Es el mismo experimento del laboratorio de este tema.
• Con un LED: a simple vista no se ve nada, porque los rebotes duran milisegundos. Esa es justamente la trampa del rebote: nuestros ojos no lo detectan, pero un circuito rápido sí.

Q es ahora un «reloj manual» limpio: un nivel que cambia una vez cada vez que movés la palanca. Es lo que se usa para avanzar a mano un contador o un flip-flop, y lo vamos a necesitar en los talleres de los temas 12 y 20.

07 · Montaje 3 (opcional)

Un latch D con cinco NAND

Con dos chips 74HC00 se arma el latch D del tema 6: una puerta invierte D, dos puertas forman S̄′ y R̄′, y las dos restantes son el latch de NAND. En total, cinco compuertas:

La entrada D se fija con un interruptor deslizante entre masa y +5 V (nunca al aire). La habilitación E se arma con un pulsador a +5 V y una resistencia de 10 kΩ a masa: reposo en 0, pulsado en 1. Las entradas de las compuertas sobrantes de U2 (pines 4, 5, 9, 10, 12 y 13) van a masa.

Este montaje sirve para ver la ecuación Q⁺ = E·D + ¬E·Q funcionando, pero en un diseño real se usa un integrado (74HC75, 74HC373): trae la lógica interna ya resuelta, incluidos los detalles de tiempo que con puertas sueltas aparecen como el hazard del tema 6.

08 · Cuando no funciona

Fallas típicas y método de depuración

Un método

1. Alimentación primero. Vcc y masa en los pines 14 y 7 de cada chip, con carga conectada.
2. Entradas en reposo. Cada nodo de entrada con un nivel definido, no un valor intermedio.
3. Una acción por vez. Apretar un solo pulsador y mirar el nodo, después la salida.
4. Salidas complementarias. En todo estado válido, Q y ~Q son opuestas. Si no lo son y no estás en la prohibida, hay un error.
5. Seguir la lista de pruebas y anotar el primer paso que falla: el error está entre ese paso y el anterior.
6. Aislar. Si aún falla, separar el latch de los pulsadores y forzar S̄ y R̄ con cables a masa y a +5 V.

09 · El taller en código

Simular, contar rebotes y comprobar

Antes de armar, conviene predecir. Los bloques reproducen cada montaje: la secuencia de pruebas del latch, un conmutador con rebotes aleatorios, el latch D de cinco compuertas y una lista de comprobación que compara lo que medís con lo esperado.

Paso 1: el montaje 1 en una tabla

def nand(a, b):
    return 0 if (a and b) else 1


def asentar(sb, rb, q, qn, gana="q"):
    """Latch de dos NAND (74HC00): Q = NAND(S̄, ~Q), ~Q = NAND(R̄, Q)."""
    for _ in range(6):
        if gana == "q":                      # responde antes la compuerta de Q
            nq = nand(sb, qn)
            nqn = nand(rb, nq)
        else:                                # responde antes la de ~Q
            nqn = nand(rb, q)
            nq = nand(sb, nqn)
        if (nq, nqn) == (q, qn):
            break
        q, qn = nq, nqn
    return q, qn


q, qn = 0, 1                                 # al encender, puede ser cualquiera
pasos = [("reposo", 1, 1), ("pulsar SET", 0, 1), ("soltar SET", 1, 1),
         ("pulsar RESET", 1, 0), ("soltar RESET", 1, 1),
         ("SET y RESET juntos", 0, 0), ("soltar los dos a la vez", 1, 1)]
print("acción                      S̄ R̄ | Q ~Q")
for nombre, sb, rb in pasos:
    q, qn = asentar(sb, rb, q, qn, gana="q")
    print(f"{nombre:26s}  {sb}  {rb} | {q}  {qn}")
print()
print("soltar la prohibida, según qué compuerta responda antes:")
for gana in ("q", "qn"):
    print(f"  gana {gana:2s}: Q, ~Q =", asentar(1, 1, 1, 1, gana))
print("soltar SET antes que RESET:", asentar(1, 0, 1, 1), "| soltar RESET antes que SET:", asentar(0, 1, 1, 1))

Es la lista de pruebas de la sección 4: SET enciende Q y retiene; RESET lo borra; ambos a la vez dejan los dos LED encendidos (1, 1). Al soltar la prohibida a la vez el resultado depende de qué compuerta responda antes: (0, 1) o (1, 0). Soltar uno antes que el otro lo hace determinado: SET primero deja Q = 0, RESET primero deja Q = 1.

Paso 2: un conmutador con rebotes

import random


def conmutar(semilla, desde_b=True, rebotes_max=6, duracion=8.0, paso=0.1, total=20.0):
    """Mueve la palanca de un contacto al otro. Devuelve S̄, R̄ y Q muestreados."""
    rnd = random.Random(semilla)
    n_llegada = rnd.randint(1, rebotes_max)
    n_salida = rnd.randint(0, 2)
    t_salida, t_llegada = 0.5, 3.0
    cortes_llegada = [t_llegada] + sorted(t_llegada + rnd.uniform(0.05, duracion) for _ in range(2 * n_llegada))
    cortes_salida = [t_salida] + sorted(t_salida + rnd.uniform(0.02, 1.0) for _ in range(2 * n_salida))
    nivel = lambda cortes, t, inicial: inicial ^ (sum(1 for c in cortes if c <= t) % 2)
    sb_ini, rb_ini = (1, 0) if desde_b else (0, 1)
    s, r, q, cambios_q, q_ini = [], [], 0 if desde_b else 1, 0, 0 if desde_b else 1
    for k in range(int(total / paso)):
        t = k * paso
        sb = nivel(cortes_llegada, t, 1) if desde_b else nivel(cortes_salida, t, 0)
        rb = nivel(cortes_salida, t, 0) if desde_b else nivel(cortes_llegada, t, 1)
        if sb == 0 and rb == 1 and q != 1:
            q, cambios_q = 1, cambios_q + 1
        elif sb == 1 and rb == 0 and q != 0:
            q, cambios_q = 0, cambios_q + 1
        s.append(sb)
        r.append(rb)
    return s, r, cambios_q


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


print("movimiento   flancos en el pin que llega   cambios de Q")
for i in range(1, 9):
    desde_b = i % 2 == 1
    s, r, cambios = conmutar(i, desde_b)
    llegada = s if desde_b else r
    print(f"{i:5d} ({'B→A' if desde_b else 'A→B'})   {flancos_bajada(llegada):18d}   {cambios:17d}")

En los 8 movimientos, el pin que llega tuvo entre 2 y 6 flancos de bajada (28 en total), y Q cambió exactamente una vez por movimiento (8 en total). Cambiá rebotes_max o duracion y repetí: Q no se entera.

Paso 3: el latch D de cinco compuertas

def nand(a, b):
    return 0 if (a and b) else 1


def latch_sr_nand(sb, rb, q, qn):
    for _ in range(8):
        nq, nqn = nand(sb, qn), nand(rb, q)
        if (nq, nqn) == (q, qn):
            break
        q, qn = nq, nqn
    return q, qn


def latch_d_5nand(d, e, q, qn):
    g1 = nand(d, d)               # ~D (compuerta 1 del chip U1)
    g2 = nand(d, e)               # S̄' = ~(D·E)   (compuerta 2 de U1)
    g3 = nand(g1, e)              # R̄' = ~(~D·E)  (compuerta 3 de U1)
    return latch_sr_nand(g2, g3, q, qn)   # compuertas 4 de U1 y 1 de U2


print("E D Q | Q+ ~Q+")
bien = True
for e in (0, 1):
    for d in (0, 1):
        for q in (0, 1):
            q2, qn2 = latch_d_5nand(d, e, q, 1 - q)
            esperado = d if e else q
            bien = bien and q2 == esperado and qn2 == 1 - q2
            print(f"{e} {d} {q} |  {q2}   {qn2}")
print("coincide con Q+ = E·D + ~E·Q y Q, ~Q complementarios:", bien)

En las ocho filas, las cinco NAND coinciden con Q⁺ = E·D + ¬E·Q y Q y ~Q son complementarias. El modelo no incluye retardos: el hazard del multiplexor (tema 6) aparecería con compuertas reales si se implementara la ecuación con AND y OR.

Paso 4: lista de comprobación

# Lista de comprobación del montaje 1: (acción, qué se espera) y qué mediste
ESPERADO = [
    ("encender (S̄ = R̄ = 1)", lambda q, qn: q != qn),          # cualquiera, pero complementarias
    ("pulsar SET",            lambda q, qn: (q, qn) == (1, 0)),
    ("soltar SET",            lambda q, qn: (q, qn) == (1, 0)),
    ("pulsar RESET",          lambda q, qn: (q, qn) == (0, 1)),
    ("soltar RESET",          lambda q, qn: (q, qn) == (0, 1)),
    ("SET y RESET juntos",    lambda q, qn: (q, qn) == (1, 1)),
    ("soltar SET primero",    lambda q, qn: (q, qn) == (0, 1)),
]

# (Q, ~Q) observados en la mesa; el montaje de ejemplo no tiene el pull-up de SET
observado = [(1, 0), (1, 0), (0, 1), (0, 1), (0, 1), (1, 1), (0, 1)]
fallas = 0
for (accion, ok), (q, qn) in zip(ESPERADO, observado):
    resultado = "OK   " if ok(q, qn) else "FALLA"
    fallas += resultado == "FALLA"
    print(f"{resultado} {accion:24s} Q={q} ~Q={qn}")
print(f"{len(ESPERADO) - fallas} de {len(ESPERADO)} pasos correctos")

Con las observaciones del ejemplo falla «soltar SET»: Q cae a 0 cuando debería retener 1. Es el síntoma típico de un pull-up faltante en S̄. Reemplazá observado con lo que midas en tu montaje y obtené el diagnóstico.

10 · Exploración interactiva

El banco de pruebas

Un conmutador de palanca con rebotes aleatorios alimenta el latch del montaje 2. Cada vez que movés la palanca, el simulador genera una maniobra distinta: el contacto que se abre rebota un poco, la palanca viaja y el contacto que se cierra rebota entre 1 y la cantidad máxima que elijas, durante el tiempo que indiques. Se muestran tres señales: el nodo S̄ (contacto A), el nodo R̄ (contacto B) y la salida Q. Los puntos naranjas marcan los flancos de bajada que vería un contador conectado directo al pin S̄.

Recorrido guiado

1. Con los valores iniciales, movés la palanca de B a A. Q sube a 1 una sola vez. En el pin S̄ se ven varios saltos, y los puntos naranjas los cuentan.
2. Mové la palanca de A a B. Ahora el que rebota es R̄; S̄ solo tiene los saltos de la salida del contacto A. Q baja una sola vez.
3. Repetí cinco o seis maniobras. Comparás los dos contadores: el crudo suma varias unidades por maniobra, el del latch suma uno por cada B → A.
4. Subí la duración del rebote a 15 ms y los rebotes máximos a 10. El pin se vuelve mucho más ruidoso; Q sigue cambiando una vez por maniobra.
5. Bajá los dos parámetros al mínimo. A veces el pin queda con un solo flanco. Por eso el rebote es un problema intermitente, y por eso es tan difícil de encontrar sin instrumentos.
6. Pensá cuánto costaría hacer lo mismo con un filtro RC: habría que elegir τ para el peor caso (15 ms), y todos los pulsos más cortos se perderían. El latch no necesita saber cuánto dura el rebote.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. Las compuertas sobrantes

En el montaje 1 solo se usan las compuertas 1 y 2 del 74HC00. ¿A dónde van las entradas de las compuertas 3 y 4 y por qué? ¿Qué pasaría si quedaran al aire?

2. Predecir una secuencia

Con el montaje 1 y Q = 0, se hace: apretar SET; apretar RESET sin soltar SET; soltar SET; soltar RESET. ¿Cuál es Q después de cada paso?

3. Contar con y sin latch

Un contador cuenta cada flanco de bajada de su entrada. Se mueve 10 veces la palanca (5 hacia A y 5 hacia B) y el contacto rebota 4 veces en promedio al llegar. ¿Cuántos flancos de bajada tiene el nodo S̄? ¿Y cuántos flancos de subida tiene Q?

4. El pull-up

Con 10 kΩ, ¿cuánta corriente y cuánta potencia se consumen mientras se aprieta un pulsador a 5 V? ¿Y con 100 kΩ? ¿Qué se pierde al agrandarla?

5. El latch D en acción

En el montaje 3, D = 1 y E se aprieta y se suelta. Después D pasa a 0 con E suelto, y se aprieta E otra vez. ¿Cuánto vale Q en cada momento? ¿Y qué pasa si D cambia mientras E está apretado?

6. Diagnóstico

Al armar el montaje 1, los dos LED están apagados, apretés lo que apretés. ¿Es un estado posible del latch? ¿Qué revisarías primero?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 8?

Antes de avanzar, explicá cómo se conecta un latch de NAND a dos pulsadores, qué se espera de los dos LED en cada paso de la lista de pruebas y por qué el latch es indiferente a los rebotes. Si podés justificar las tres respuestas, ya podés pasar de capturar por nivel a capturar por flanco.

En el próximo tema veremos el flip-flop D: captura por flanco: la diferencia entre un latch transparente y un elemento que toma el dato en un solo instante, y cómo leer sus cronogramas.