Taller: flip-flops con el 74HC74

01 · Punto de partida

Tres montajes con un solo chip

El 74HC74 contiene dos flip-flops D independientes, cada uno con su reloj, su dato, su preset y su clear. Es el componente ideal para aprender, porque cada idea de los temas 8 a 11 se puede comprobar con él. Los tres montajes se construyen uno sobre otro:

Como en el taller del tema 7, no hace falta tener los materiales para aprovechar el tema: el laboratorio simula el contador y el código verifica cada secuencia.

02 · Preparación

Materiales y herramientas

El multímetro alcanza para la mayoría de las pruebas, porque con un reloj manual todo ocurre despacio. Para ver los rebotes y los flancos hace falta un osciloscopio o un analizador lógico, como en el taller anterior. Un buen hábito es dibujar el esquema en papel con los números de pin escritos antes de tocar el protoboard.

Antes de dar tensión

• Cada chip con su 100 nF entre Vcc y GND, pegado a las patas.
• Ninguna entrada al aire: también las del flip-flop que no uses.
• Preset y clear de cada flip-flop con su nivel inactivo (+5 V) si no se usan.
• Ninguna salida unida a otra salida ni a +5 V o masa.

03 · El chip

Pines del 74HC74

El encapsulado DIP de 14 patas tiene una muesca en un extremo; el pin 1 queda a la izquierda de la muesca, mirando el chip desde arriba, y los números siguen en sentido antihorario. La disposición de pines es la clásica del 7474:

La tabla de función es la del tema 10: con PRE̅ y CLR̅ inactivos (en 1), el flip-flop copia D en cada flanco ascendente de CLK; con PRE̅ = 0 fuerza Q = 1 y con CLR̅ = 0 fuerza Q = 0, sin esperar al reloj. Fijate en una regularidad útil: las cinco patas del primer flip-flop ocupan los pines 1 a 6 y las del segundo, 8 a 13, con el orden espejo. La mitad «de arriba» y la de «abajo» se conectan igual.

04 · Montaje 1

Captura con reloj manual

Lo primero es un reloj que podamos manejar con la mano sin que los rebotes lo arruinen. Reutilizamos el latch de NAND del tema 7 (74HC00) con el conmutador SPDT: al mover la palanca hacia A, su salida Q sube una sola vez; es el flanco ascendente que va a mandar al 74HC74.

Pruebas

Para ver la diferencia con un latch, comparalo mentalmente con el tema 6: con un latch, el paso 6 habría hecho oscilar la salida si la habilitación estuviera abierta. Acá, la salida no se mueve. Es el flanco el que decide.

05 · Montaje 2

Contador de dos bits

Se usan las dos mitades del 74HC74. Cada una tiene su D conectada a su propia ~Q, lo que la convierte en un divisor por 2 (tema 9). El reloj manual va al primero, y el segundo recibe como reloj la salida del primero:

¿Por qué ~Q1 y no Q1? Porque el segundo flip-flop captura en un flanco ascendente, y debe cambiar cuando Q1 pasa de 1 a 0. Ese instante es, justamente, un flanco ascendente de ~Q1. Con el reloj manual:

Y si el reloj tiene rebotes

Conectá el pulsador directo (con su pull-up) al pin 3 en lugar del reloj manual: cada pulsación pasa a producir varios flancos ascendentes y la cuenta salta de a cantidades irregulares. Es el experimento más claro del por qué del tema 7, y el laboratorio de este tema lo reproduce con una probabilidad de rebotes ajustable.

06 · Montaje 3

Reset manual y de encendido

Para que el contador empiece siempre en 00 usamos el clear asíncrono de los dos flip-flops, activado por un circuito RC al encender y por un pulsador a mano. Es el circuito del tema 10:

Al encender, el condensador está descargado: el nodo R vale 0 V, la salida del segundo inversor vale 0 y CLR̅ está activa. Durante unos 90 ms el contador queda fijo en 00. Cuando el nodo supera el umbral del 74HC14, CLR̅ pasa a 1 y el contador empieza a funcionar. Con el pulsador se puede repetir el pulso en cualquier momento.

Pruebas

• Apagar y encender diez veces con el circuito de reset: debe arrancar siempre en 00. Después retirar el RC (dejando CLR̅ a +5 V) y repetir: el estado inicial varía.
• Reset manual: contar hasta 11 y apretar el pulsador: vuelve a 00 sin pulso de reloj.
• Reloj durante el reset: mantener el pulsador apretado y mover la palanca: el contador no cuenta (CLR̅ manda sobre el reloj).

07 · Cuando no funciona

Mediciones, fallas y método

Armar por etapas

1. Alimentación primero. Vcc y GND en cada chip, con el 100 nF puesto.
2. Un bloque por vez. Armar y probar el reloj manual antes de conectarlo al 74HC74.
3. Atar todas las entradas, también las de lo que no se usa.
4. Probar la etapa con la lista de pasos antes de agregar la siguiente.
5. Cambiar una sola cosa a la vez cuando algo falla.
6. Anotar la secuencia observada y compararla con la esperada: el error está entre el último paso correcto y el primero que falla.

08 · El taller en código

Simular, comparar y diagnosticar

Antes de armar conviene predecir. Los bloques reproducen el contador con las dos formas de cablear el reloj del segundo flip-flop, comparan el reloj limpio con un pulsador que rebota, estiman los arranques con y sin reset y diagnostican una secuencia medida.

Paso 1: el contador y los dos cableados del reloj

class FF74:
    """Un flip-flop D del 74HC74 con D conectada a ~Q: conmuta en cada flanco ascendente."""

    def __init__(self, q=0):
        self.q = q

    @property
    def qn(self):
        return 1 - self.q

    def flanco(self):
        self.q = 1 - self.q


def contador(pulsos, clk2_desde="qn1"):
    ff1, ff2 = FF74(), FF74()
    lectura = []
    for _ in range(pulsos):
        antes = ff1.qn if clk2_desde == "qn1" else ff1.q
        ff1.flanco()                                   # el reloj manual llega a CLK1
        despues = ff1.qn if clk2_desde == "qn1" else ff1.q
        if antes == 0 and despues == 1:                # flanco ascendente en el pin CLK2
            ff2.flanco()
        lectura.append(f"{ff2.q}{ff1.q}")
    return lectura


print("CLK2 tomado de ~Q1 (pin 6):", *contador(9, "qn1"))
print("CLK2 tomado de  Q1 (pin 5):", *contador(9, "q1"))

Con CLK2 tomado de ~Q1 el contador sube: 01, 10, 11, 00, 01… Con CLK2 tomado de Q1 baja: 11, 10, 01, 00. Es la misma conexión equivocada de un solo cable (pin 5 en lugar de pin 6).

Paso 2: reloj limpio frente a pulsador con rebotes

import random

rnd = random.Random(5)


def cuenta_leida(flancos_por_pulsacion):
    q1 = q2 = 0
    for flancos in flancos_por_pulsacion:
        for _ in range(flancos):
            q1 ^= 1                      # cada flanco ascendente en CLK1 conmuta el primer FF
            if q1 == 0:                  # Q1 bajó: ~Q1 sube y dispara al segundo
                q2 ^= 1
    return q2 * 2 + q1


N = 10
con_latch = [1] * N                                     # un solo flanco por pulsación
directo = [1 + rnd.randint(0, 4) for _ in range(N)]      # el pulsador rebota hasta 4 veces
print("pulsaciones reales:", N, "-> cuenta esperada (módulo 4):", N % 4)
print("reloj manual con latch:      flancos", sum(con_latch), "-> cuenta leída:", cuenta_leida(con_latch))
print("pulsador directo (rebotes):  flancos", sum(directo), "-> cuenta leída:", cuenta_leida(directo))
print("flancos por pulsación (directo):", *directo)

Con 10 pulsaciones reales, la cuenta esperada es 2 (10 mod 4). El reloj con latch entrega 10 flancos y lee 2; el pulsador directo, con hasta 4 rebotes, entrega 27 flancos y lee 3. Cambiá rebotes_max y la semilla: la lectura cambia en cada ejecución, y a veces coincide por casualidad.

Paso 3: arranques con y sin reset

import random

rnd = random.Random(11)
N = 1000
sin_reset = {"00": 0, "01": 0, "10": 0, "11": 0}
for _ in range(N):
    q1, q2 = rnd.randint(0, 1), rnd.randint(0, 1)        # cada FF arranca en cualquiera
    sin_reset[f"{q2}{q1}"] += 1

con_reset = {"00": N, "01": 0, "10": 0, "11": 0}          # el pulso de CLR̅ lleva los dos a 0

print(f"{N} encendidos")
print("estado   sin reset   con reset")
for estado in ("00", "01", "10", "11"):
    print(f"  {estado}      {sin_reset[estado]:6d}     {con_reset[estado]:6d}")

En 1000 encendidos sin reset, los cuatro estados aparecen con frecuencias parecidas (alrededor del 25 % cada uno). Con el pulso de CLR̅ del montaje 3, todos terminan en 00. Probá con otra semilla: las proporciones cambian, pero siguen siendo repartidas.

Paso 4: diagnosticar una secuencia medida

SUBE = ["00", "01", "10", "11", "00"]          # contador ascendente de 2 bits
BAJA = ["00", "11", "10", "01", "00"]          # el mismo circuito con CLK2 tomado de Q1


def diagnostico(observado):
    if observado == SUBE:
        return "OK: cuenta hacia arriba"
    if observado == BAJA:
        return "cuenta hacia atrás: CLK2 está tomado de Q1 y debería salir de ~Q1 (pin 6)"
    if len(set(observado)) < len(set(SUBE)):
        return "salta estados: revisar el reloj manual (rebotes) o el cableado de CLK1"
    return "secuencia desconocida: medir cada flip-flop por separado"


mediciones = {
    "montaje bien armado": ["00", "01", "10", "11", "00"],
    "CLK2 desde Q1":       ["00", "11", "10", "01", "00"],
    "reloj con rebotes":   ["00", "10", "00", "10", "00"],
}
for nombre, observado in mediciones.items():
    print(f"{nombre:22s} {' '.join(observado):22s} -> {diagnostico(observado)}")

El script distingue tres casos de una lista de mediciones: la secuencia correcta, el contador que cuenta hacia atrás (CLK2 desde Q1) y la que salta estados (rebotes). Reemplazá una de las listas por lo que midas en tu montaje y obtené el diagnóstico.

Una diferencia con el software: acá un error de cableado no produce un mensaje, sino un comportamiento. La secuencia observada es el único «mensaje de error», y por eso conviene conocer de memoria la secuencia correcta.

09 · Exploración interactiva

El banco de pruebas

El simulador reproduce el contador del montaje 2. Podés elegir la fuente del reloj (manual limpio o pulsador directo, con rebotes de hasta una cantidad ajustable de flancos extra) y la salida del primer flip-flop que alimenta al segundo (~Q1 o Q1). Con «Apagar y encender» ves el arranque, con o sin el circuito de reset de encendido. La cuenta esperada es el número de pulsaciones módulo 4: si no coincide con la leída, algo está mal.

Recorrido guiado

1. Con el reloj limpio y CLK2 desde ~Q1, presioná «Pulsar» cuatro veces: 01, 10, 11, 00. Todas coinciden con la esperada.
2. Cambiá CLK2 a Q1 y reiniciá. Pulsá: 11, 10, 01, 00. Cuenta hacia atrás y no coincide, salvo en las pulsaciones múltiplos de 2. Es el error de un cable.
3. Volvé a ~Q1 y pasá al pulsador directo con 4 rebotes extra. Pulsá varias veces: la lectura se descontrola, con muchos más flancos que pulsaciones.
4. Con rebotes extra = 0, el pulsador directo se porta bien (cada pulsación es 1 flanco): un contacto ideal no necesita antirrebote. Subí el valor y volvé a probar.
5. Con el pulsador directo, observá que a veces coincide por casualidad: cuando los flancos de una pulsación son múltiplo de 4, la lectura no cambia y parece correcta.
6. Presioná «Apagar y encender» varias veces sin reset: arranca en cualquiera de los cuatro estados.
7. Marcá «Reset de encendido» y repetí: siempre 00. Las pulsaciones se cuentan desde cero.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de armar

1. Cablear el contador

Escribí las conexiones entre pines del 74HC74 que convierten los dos flip-flops en un contador ascendente de dos bits, con el reloj manual en el pin 3.

2. Dos cableados

Después de 5 pulsaciones limpias desde 00, ¿qué muestra el contador si CLK2 viene de ~Q1? ¿Y si viene de Q1?

3. Frecuencias

Si en vez del reloj manual entran 1 MHz al pin 3, ¿qué frecuencia tiene cada salida? ¿Qué ciclo de trabajo?

4. Rebotes invisibles

Un pulsador directo produce siempre 4 flancos por pulsación (el primero más 3 rebotes). Después de 1, 2 y 3 pulsaciones, ¿qué lee el contador de dos bits?

5. Un estado inicial distinto

Querés que el contador arranque en 10 (Q2 = 1, Q1 = 0). ¿Cómo se conectan el preset y el clear?

6. Diagnóstico

El contador funciona bien con el reloj manual, pero el LED de Q1 parpadea débilmente y el valor cambia solo cuando acercás la mano al protoboard. ¿Cuáles son las primeras sospechas?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 13?

Antes de avanzar, dibujá de memoria el cableado del contador de dos bits indicando los pines, explicá qué pasaría si el reloj rebotara y decidí cómo se garantiza el arranque en 00. Si podés justificar las tres respuestas, ya podés pasar de bits sueltos a grupos de bits.

En el próximo tema veremos los registros de almacenamiento: cómo agrupar varios flip-flops con un reloj común, una habilitación y una carga paralela para guardar una palabra completa.