Flip-flops JK y T

01 · Punto de partida

De copiar a modificar

Con el flip-flop D, cada flanco del reloj reemplaza el contenido por D. Eso es perfecto para guardar un dato, pero a veces lo que necesitamos es una operación sobre el valor que ya está: «ponelo en 1», «borralo», «dejalo como estaba», o «invertilo». Una cuenta binaria, por ejemplo, invierte el bit menos significativo en cada pulso, y los demás solo cuando los de abajo pasan de 1 a 0.

Con un flip-flop D hay que calcular siempre el nuevo valor completo y conectarlo a D. Hay otros dos tipos que incorporan la operación en el propio elemento: el JK, que generaliza al latch SR eliminando su combinación prohibida, y el T, que solo sabe conmutar. Son equivalentes entre sí y con el D, pero cada uno simplifica ciertos diseños.

Todos los flip-flops de este tema capturan en un flanco del reloj, igual que el D del tema anterior. Lo que cambia es la tabla: cómo se calcula el próximo estado a partir de las entradas y del estado actual.

02 · El flip-flop JK

Un SR sin combinación prohibida

El JK tiene dos entradas, J (como «Set») y K (como «Reset»), y reloj. Se comporta como el latch SR en tres de sus cuatro combinaciones; en la cuarta, que en el SR estaba prohibida, conmuta: invierte el valor que tenía.

¿Cómo se consigue? Realimentando la salida a las entradas de un SR. Se arma S = J · ¬Q y R = K · Q. Como Q vale 0 o 1, S y R nunca valen 1 a la vez: cuando Q = 0 solo puede activarse S (si J = 1), y cuando Q = 1 solo puede activarse R (si K = 1). Con J = K = 1, si Q = 0 se hace Set y si Q = 1 se hace Reset: se invierte.

Tabla de excitación

Para diseño, interesa la tabla inversa: dado el cambio que se quiere (de Q a Q+), qué J y K lo producen. Tiene muchas X, y esas X son las que permiten simplificar la lógica:

Compará con el SR del tema 5: ahí también había X, pero la combinación S = R = 1 estaba prohibida. Acá los cuatro pares de entradas son válidos, y la cuarta fila se aprovecha para algo útil.

03 · El flip-flop T

El que solo sabe conmutar

Si en un JK se unen las dos entradas (J = K = T), quedan solo dos casos: T = 0 mantiene, T = 1 conmuta. Ese es el flip-flop T (de toggle, «alternar»):

La ecuación característica es un XOR (Electrónica Digital, tema 10): el próximo estado es Q o su opuesto según T. La de excitación se lee al revés: T vale 1 exactamente cuando el estado tiene que cambiar. Es una forma natural de pensar un contador: «este bit cambia en este paso» o «no cambia».

04 · Equivalencias

Uno a partir de otro

Los tres tipos son intercambiables con un poco de lógica combinacional delante. Basta igualar la ecuación característica del flip-flop que se quiere con la del que se tiene:

Por eso los catálogos no ofrecen todos: en la familia 74HC hay flip-flops D y JK, pero no T aislados (se obtiene de un JK con J y K unidas, o de un D con un XOR). Las equivalencias de la tabla se verifican por completo en el Paso 2.

Observá que los JK clásicos capturan en el flanco descendente, a diferencia del 74HC74. Es una de las cosas que hay que leer siempre en el símbolo (la burbuja antes del triángulo). Las entradas de preset y clear son el tema del próximo.

05 · La aplicación estrella

Conmutar es dividir por dos

Un flip-flop T con T = 1 invierte su salida en cada flanco. Q completa un ciclo cada dos flancos de entrada: divide la frecuencia por 2 y deja la salida con ciclo de trabajo de 50 %. Si la salida de una etapa se usa como reloj de la siguiente, cada etapa divide otra vez por 2, y n etapas dividen por 2ⁿ.

Cada etapa conmuta con el flanco descendente de la anterior: cuando Q0 baja de 1 a 0 (cada dos flancos de CLK), le toca a Q1; cuando Q1 baja, a Q2. Leídas en orden Q2 Q1 Q0, las salidas cuentan en binario de 000 a 111 y vuelven a 000: un divisor es, al mismo tiempo, un contador.

Con 15 etapas se llega a 1 Hz desde el cristal de 32,768 kHz de un reloj de pulsera, que vimos en el tema 3. Los integrados contadores/divisores, como el 74HC4060 (14 etapas más un oscilador), son exactamente cadenas de este tipo.

06 · Dos diseños

Dos formas de contar

La cadena anterior se llama contador asíncrono (o ripple, «en cascada»): cada flip-flop recibe el reloj de la etapa anterior, no el reloj común. Es simple, pero las etapas no cambian a la vez; el retardo se acumula y por un instante la cuenta pasa por valores falsos. Hay una segunda forma, síncrona, en la que todos los flip-flops reciben el mismo reloj y lo que cambia es la entrada T de cada uno.

Para contar en binario, el bit i debe invertirse cuando todos los bits inferiores valen 1. Con flip-flops T:

Los dos dan la misma secuencia (Paso 3). Se estudian en detalle en los temas 17 y 18. Por ahora, la regla es: si solo importa la frecuencia de la última salida, el asíncrono alcanza; si importa leer la cuenta, hay que usar el síncrono.

07 · Un detalle histórico que todavía importa

Por qué tienen que ser de flanco

Si un JK con J = K = 1 respondiera al nivel del reloj (como un latch), mientras el reloj estuviera en alto la salida conmutaría una y otra vez: cada vez que Q cambia, vuelve a las entradas y vuelve a pedir conmutar. Este problema se llamaba race-around («carrera circular») y es el mismo del latch con D = ¬Q del tema 6.

Con captura por nivel el resultado depende de cuánto dura el reloj en alto; con captura por flanco, siempre conmuta exactamente una vez por ciclo. Los JK modernos son de flanco (o de maestro-esclavo, que equivale), así que el problema ya no existe en la práctica. Pero es una razón más para no mezclar «sensible al nivel» con «realimentado», y para leer siempre el símbolo de reloj de lo que se compra.

08 · Analogía con programación

Operaciones sobre una variable de un bit

Un flip-flop D equivale a una asignación (q = d); un T, a q ^= t; un JK, a las cuatro operaciones sobre un bit: q |= j, q &= ~k y la inversión. Los bloques siguientes verifican las tablas, las conversiones, los dos contadores y la carrera.

Paso 1: el JK como SR realimentado

def jk_proximo(q, j, k):
    """Q+ = J·~Q + ~K·Q"""
    return int((j and not q) or (not k and q))


NOMBRES = {(0, 0): "mantiene", (0, 1): "reset", (1, 0): "set", (1, 1): "conmuta"}

print("J K Q | Q+  operación")
for j in (0, 1):
    for k in (0, 1):
        for q in (0, 1):
            print(f"{j} {k} {q} |  {jk_proximo(q, j, k)}   {NOMBRES[(j, k)]}")


def jk_con_sr(q, j, k):
    """El JK como un SR con realimentación: S = J·~Q y R = K·Q."""
    s, r = j & (1 - q), k & q
    assert not (s and r)          # nunca se piden set y reset a la vez
    return 1 if s else (0 if r else q)


ok = all(jk_con_sr(q, j, k) == jk_proximo(q, j, k) for j in (0, 1) for k in (0, 1) for q in (0, 1))
print()
print("la versión con SR realimentado coincide y nunca llega a la combinación prohibida:", ok)

Las ocho filas coinciden con la tabla característica: J = K = 0 mantiene, (0, 1) resetea, (1, 0) setea y (1, 1) conmuta. La versión como SR con realimentación (S = J·¬Q, R = K·Q) da lo mismo y la aserción confirma que nunca pide set y reset a la vez.

Paso 2: convertir un tipo en otro

def d_prox(q, d):
    return d


def t_prox(q, t):
    return q ^ t


def jk_prox(q, j, k):
    return int((j and not q) or (not k and q))


bits = (0, 1)
print("D hecho con un JK (J = D, K = ~D):      ",
      all(jk_prox(q, d, 1 - d) == d_prox(q, d) for q in bits for d in bits))
print("T hecho con un JK (J = K = T):          ",
      all(jk_prox(q, t, t) == t_prox(q, t) for q in bits for t in bits))
print("T hecho con un D (D = T xor Q):          ",
      all(d_prox(q, t ^ q) == t_prox(q, t) for q in bits for t in bits))
print("JK hecho con un D (D = J·~Q + ~K·Q):     ",
      all(d_prox(q, int((j and not q) or (not k and q))) == jk_prox(q, j, k)
          for q in bits for j in bits for k in bits))
print("D hecho con un T (T = D xor Q):          ",
      all(t_prox(q, d ^ q) == d_prox(q, d) for q in bits for d in bits))
print()
print("tabla de excitación del JK (Q -> Q+ : J, K posibles):")
for q in bits:
    for q2 in bits:
        pares = [(j, k) for j in bits for k in bits if jk_prox(q, j, k) == q2]
        print(f"  {q} -> {q2}:", pares)

Las cinco conexiones de la sección 4 son verdaderas en todas las combinaciones. La tabla de excitación del JK que imprime al final muestra las X: de 0 a 0 sirve J = 0 con cualquier K; de 1 a 1 sirve K = 0 con cualquier J.

Paso 3: contador asíncrono y contador síncrono

def asincrono(flancos):
    """Tres flip-flops T con flanco descendente: la salida de uno es el reloj del siguiente."""
    q = [0, 0, 0]
    secuencia = []
    for _ in range(flancos):
        i = 0
        while i < 3:
            q[i] ^= 1                    # este flip-flop conmuta
            if q[i] == 1:                # subió: no hay flanco descendente para el siguiente
                break
            i += 1                       # bajó: dispara al siguiente
        secuencia.append(q[2] * 4 + q[1] * 2 + q[0])
    return secuencia


def sincrono(flancos):
    """Todos con el mismo reloj: T0 = 1, T1 = Q0, T2 = Q0·Q1 (con los Q de antes del flanco)."""
    q0 = q1 = q2 = 0
    secuencia = []
    for _ in range(flancos):
        t0, t1, t2 = 1, q0, q0 & q1
        q0, q1, q2 = q0 ^ t0, q1 ^ t1, q2 ^ t2
        secuencia.append(q2 * 4 + q1 * 2 + q0)
    return secuencia


a, s = asincrono(10), sincrono(10)
print("asíncrono:", *a)
print("síncrono: ", *s)
print("misma cuenta:", a == s)
f = 8.0
print("\nfrecuencia de entrada 8 MHz:")
for etapa in range(3):
    f /= 2
    print(f"  salida de la etapa {etapa}: {f} MHz")

Los dos diseños producen la misma secuencia 1 2 3 4 5 6 7 0 1 2, y las etapas dividen 8 MHz en 4, 2 y 1 MHz. El modelo no incluye retardos: en el asíncrono real, los bits cambian uno tras otro y la cuenta pasa por valores intermedios.

Paso 4: la carrera de un JK por nivel

def jk_por_nivel(ancho, ticks=12):
    """J = K = 1 con un JK sensible al nivel del reloj (el diseño histórico problemático)."""
    q, salida = 0, []
    for t in range(ticks):
        if 1 <= t < 1 + ancho:        # reloj en alto durante 'ancho' ticks
            q ^= 1                    # cada vuelta del lazo vuelve a conmutar
        salida.append(q)
    return salida


def jk_por_flanco(ancho, ticks=12):
    q, salida = 0, []
    for t in range(ticks):
        if t == 1:                    # el flanco ascendente ocurre una sola vez
            q ^= 1
        salida.append(q)
    return salida


print("ancho del pulso | Q final por nivel | Q final por flanco")
for ancho in range(1, 7):
    print(f"{ancho:15d} | {jk_por_nivel(ancho)[-1]:17d} | {jk_por_flanco(ancho)[-1]:18d}")
print()
print("por nivel: el resultado depende del ancho (par o impar); por flanco: siempre conmuta una vez")

Con captura por nivel, el resultado depende de la paridad del ancho del pulso (1 y 3 dejan Q en 1, 2 y 4 en 0). Con captura por flanco, siempre conmuta una vez. Es el mismo problema de la realimentación en un latch transparente del tema 6.

Una diferencia con el software: acá un «bit» se opera con una operación a la vez; en hardware, las tres operaciones (J, K, conmutar) están pensadas para leerse con los valores anteriores al flanco y aplicarse todas en el mismo instante.

09 · Exploración interactiva

JK, T y D con las mismas herramientas

Elegí un tipo de flip-flop, fijá sus entradas y generá flancos ascendentes. Con el tipo T, la casilla de entrada gobierna J y K a la vez; con el tipo D, K se conecta a ¬J automáticamente. A la derecha, una cadena de tres flip-flops T con T = 1 recibe los mismos flancos y cuenta en binario. El contador de cobertura registra cuántas de las ocho combinaciones (Q, J, K) ya probaste.

Recorrido guiado

1. Con J = K = 0, generá un flanco: Q no cambia. La fila de la tabla dice «mantiene».
2. Activá J (K sigue en 0) y generá un flanco: set, Q = 1. Generá otro: sigue en 1. Set repetido no cambia nada.
3. Desactivá J y activá K: generá un flanco, reset, Q = 0.
4. Activá J y K a la vez: Q conmuta en cada flanco (1, 0, 1, 0…). El contador «flancos → ciclos de Q» muestra que cada dos flancos Q completa un ciclo: divide por 2.
5. Pasá al tipo T. La casilla pasa a llamarse «Entrada T»; marcada, conmuta; desmarcada, mantiene. Es el mismo comportamiento que el JK con J = K.
6. Pasá al tipo D. Con la casilla marcada, Q = 1 después del flanco; desmarcada, Q = 0. K se calcula sola como ¬J: es la conversión D desde JK de la sección 4.
7. Mirá la cadena de tres flip-flops T: con cada flanco el valor binario aumenta en uno, de 000 a 111 y vuelve a 000. Q0 cambia a cada flanco, Q1 cada dos y Q2 cada cuatro.
8. Seguí hasta completar las ocho combinaciones. En cada una, predecí Q+ antes de generar el flanco.

10 · Método de trabajo

Cómo elegir y usar el tipo de flip-flop

1. Escribí la transición que querés para cada estado y entrada: de qué Q a qué Q+.
2. Usá la tabla de excitación del tipo elegido para saber qué entradas hacen falta.
3. Aprovechá las X como «no importa» para simplificar la lógica (como en un mapa de Karnaugh).
4. Para registros y datos, elegí D: el próximo estado se conecta directo, sin lógica.
5. Para contadores y divisores, pensá en T: un bit cambia cuando le toca. Un JK con J = K sirve.
6. Verificá el flanco activo del componente real (ascendente o descendente) y el estado inicial: preset y clear (próximo tema).
7. Comprobá con una secuencia: mantener, set, reset y conmutar (o sus equivalentes), y la cuenta completa si es un contador.

Cuando el diseño sale de la tabla de transición y se aplican los tres pasos (tabla, excitación y simplificación), cualquiera de los tipos conduce a un circuito correcto. La elección es de economía de lógica, no de capacidad.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. Seguir un JK

Un JK parte de Q = 0. En seis flancos consecutivos recibe (J, K): (1, 0), (1, 1), (0, 0), (1, 1), (0, 1), (1, 1). ¿Cuánto vale Q después de cada uno?

2. Excitación

Un JK tiene que recorrer la secuencia de estados 0 → 1 → 1 → 0 → 0 → 1. ¿Qué J y K necesita en cada transición?

3. Cuántas etapas

Un oscilador de 4,096 MHz alimenta una cadena de flip-flops T. ¿Cuántas etapas hacen falta para obtener 1 kHz? ¿Qué ciclo de trabajo tiene la salida?

4. Un T con un D

Solo tenés un 74HC74 (D) y un 74HC86 (XOR). ¿Cómo armás un flip-flop T? ¿Y un divisor por 2?

5. Contador síncrono de 4 bits

Escribí las entradas T de un contador síncrono de 4 bits y calculalas para el paso de 0111 a 1000. ¿Qué ventaja tiene sobre el asíncrono?

6. Race-around

Un JK sensible al nivel, con J = K = 1, tiene un retardo de lazo de 30 ns y el reloj está en alto 100 ns. Aproximadamente, ¿cuántas veces conmuta? ¿Qué se obtiene con un JK de flanco?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 10?

Antes de avanzar, completá la tabla característica y la de excitación del JK de memoria, explicá por qué S = J·¬Q y R = K·Q nunca valen 1 a la vez y calculá la frecuencia de salida de una cadena de tres flip-flops T. Si podés justificar las tres respuestas, ya podés dar a un biestable un estado inicial conocido.

En el próximo tema veremos preset, clear y arranque definido: las entradas asíncronas que fuerzan Q a 1 o a 0 y cómo se usan para que el circuito empiece siempre en un estado conocido.