Flip-flop D: captura por flanco

01 · Punto de partida

Capturar en un instante, no durante un intervalo

En el tema 6 vimos que un latch D abierto es transparente: la salida sigue a la entrada, incluidos los pulsos que no queríamos. Y que si realimentamos su salida con D = ¬Q, la salida cambia una y otra vez mientras la habilitación esté activa, y el resultado depende del ancho del pulso. Esa es la razón por la que ningún contador se arma con latches transparentes.

Lo que hace falta es un elemento que tome el valor de D en un instante preciso y lo mantenga hasta el siguiente. Ese instante lo marca el reloj del tema 3: el flanco (la transición de 0 a 1 o de 1 a 0). Entre flancos, el flip-flop es sordo a D. Entonces ya no importa cuánto tiempo dura el pulso de reloj: solo importa cuándo empieza.

La notación sigue la del tema 6; lo nuevo es el reloj y su flanco. Con este tema pasamos de elementos de memoria que reaccionan a niveles a elementos que reaccionan a eventos.

02 · La construcción

Dos latches hacen un flip-flop

La estructura más clara es la maestro-esclavo: dos latches D en serie con habilitaciones opuestas. El maestro está abierto mientras CLK = 0; el esclavo, mientras CLK = 1. Nunca están abiertos al mismo tiempo.

El truco es que el esclavo solo ve lo que el maestro guardó antes del flanco, y el maestro, que es lo único que ve a D, está cerrado cuando el esclavo está abierto. Entre D y Q siempre hay una puerta cerrada: por eso Q cambia una sola vez por ciclo, justo en el flanco, y la salida jamás vuelve a la entrada por un camino transparente.

03 · Cómo se escribe

Símbolo, tabla y ecuaciones

En los esquemas, la entrada de reloj de un flip-flop lleva un pequeño triángulo (>) que significa «sensible a flanco». Si además hay una burbuja antes del triángulo, el flip-flop captura en el flanco descendente.

La ecuación característica es la más simple posible: el próximo estado es el dato. Por eso a este flip-flop se lo llama «D» de data o de delay: copia D con un ciclo de retraso. La tabla de excitación es igual de directa: para que Q pase a un valor deseado Q+, hay que poner D = Q+.

Esta simplicidad tiene una consecuencia de diseño enorme: para construir una máquina de estados, basta calcular el próximo estado y conectarlo a las entradas D. No hay que traducirlo a órdenes Set/Reset. Es la razón por la que el flip-flop D es el elemento de memoria dominante en el hardware digital actual, y lo retomaremos en el tema del diseño de máquinas de estados.

04 · Comparar

Latch frente a flip-flop

Veamos los dos elementos con el mismo reloj y el mismo dato. El reloj tiene período de 8 ticks, mitad en alto; D cambia a destiempo. Los flancos ascendentes están en t = 4, 12 y 20.

El latch tuvo 6 cambios de salida; el flip-flop, 3, uno por flanco en que D difería de Q. El pulso de D entre t = 9 y t = 10 ocurre con el reloj en bajo y ninguno de los dos elementos lo ve; el pulso entre t = 13 y t = 14 cae con el reloj en alto y solo el latch lo registra.

05 · Tiempos

La ventana alrededor del flanco

«Captura en un instante» es una idealización. El circuito real necesita que D esté estable durante una pequeña ventana alrededor del flanco, y define tres tiempos que ya aparecieron en el tema 3:

Si D cambia dentro de la ventana [flanco − t_su, flanco + t_h], el flip-flop puede capturar cualquiera de los dos valores, o quedar un tiempo indeterminado entre ambos: es la metastabilidad que anticipamos en los temas 4 y 5. Fuera de esa ventana, lo que cambie en D no importa. Es una de las ideas más importantes de todo el curso, y es el tema de los tiempos reales y la sincronización (tema 11).

De ahí sale la cuenta del período mínimo que vimos en el tema 3: entre dos flip-flops conectados por lógica, el dato tiene que viajar desde un flanco al siguiente y llegar con t_su de sobra:

06 · La gran ventaja

Realimentar sin carreras

Con el flip-flop, la salida puede volver a la entrada sin problemas, porque nunca hay un camino transparente. El dato que se captura en un flanco es el que había antes de ese flanco, y Q recién cambia después. Dos consecuencias directas:

Un divisor por 2

Con D = ¬Q, en cada flanco el flip-flop toma el opuesto de lo que tenía: Q se invierte exactamente una vez por flanco. La salida completa un ciclo cada dos ciclos del reloj: divide la frecuencia por 2 y su ciclo de trabajo es de 50 %. Es la base de los contadores asíncronos, y el problema del tema 6 (D = ¬Q con un latch) queda resuelto.

Actualizaciones simultáneas

Si dos flip-flops comparten el reloj y se conectan D₁ = Q₂ y D₂ = Q₁, en cada flanco intercambian sus valores. Los dos D se leen antes del flanco, y las dos Q cambian después. En software, el equivalente es la asignación paralela a, b = b, a; hacerlo en dos pasos (a = b; b = a) deja a los dos con el mismo valor, que es el error que se comete cuando se modela hardware con código secuencial. Más adelante, esta propiedad es lo que permite construir registros de desplazamiento.

07 · En los catálogos

Variantes e integrados

El 74HC74 es el flip-flop D por antonomasia: dos por chip, captura en el flanco ascendente, con preset y clear activos en bajo. Lo vamos a usar en el taller del tema 12. Los registros de 8 bits (74HC273, 74HC374) son lo mismo ocho veces, con un reloj común; son el equivalente a un latch 74HC373 pero capturando por flanco.

Una advertencia sobre nombres: en la bibliografía hay autores que llaman «flip-flop» a cualquier biestable y «latch» al sensible a nivel; otros, lo contrario. La distinción que importa es de comportamiento: ¿cambia mientras la habilitación está activa, o solo en un flanco?

08 · Analogía con programación

Detectar el flanco y actualizar a la vez

Un flip-flop se parece a una variable que solo se actualiza en el instante en que llega un evento. Los bloques lo modelan y lo comparan con un latch, verifican que la construcción maestro-esclavo se comporta igual, muestran el divisor y el intercambio simultáneo y calculan qué captura según cuándo cambia D.

Paso 1: flip-flop frente a latch en el mismo cronograma

class FlipFlopD:
    """Captura D justo antes de cada flanco ascendente de clk."""

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

    def evaluar(self, clk, d):
        if self._clk_antes == 0 and clk == 1:      # flanco ascendente
            self.q = self._d_antes                 # D justo antes del flanco
        self._clk_antes, self._d_antes = clk, d
        return self.q


def latch(clk, d, q):
    """Transparente mientras clk = 1; retiene con clk = 0."""
    return d if clk else q


N = 28
clk = [1 if t % 8 >= 4 else 0 for t in range(N)]
d = [1 if (2 <= t < 6 or 9 <= t < 11 or 13 <= t < 15 or 18 <= t < 22) else 0 for t in range(N)]

ff = FlipFlopD()
q_ff, q_lat, q = [], [], 0
for c, x in zip(clk, d):
    q = latch(c, x, q)
    q_lat.append(q)
    q_ff.append(ff.evaluar(c, x))

print("t        ", *[f"{t % 10}" for t in range(N)])
print("CLK      ", *clk)
print("D        ", *d)
print("Q latch  ", *q_lat)
print("Q flipflop", *q_ff)
cambios = lambda s: sum(1 for a, b in zip(s, s[1:]) if a != b)
print(f"cambios de Q: latch {cambios(q_lat)}, flip-flop {cambios(q_ff)}")

Es el cronograma de la sección 4. El flip-flop captura D(3) = 1 en t = 4, D(11) = 0 en t = 12 y D(19) = 1 en t = 20: tres cambios. El latch siguió a D mientras CLK estaba en alto: seis cambios. Probá mover el pulso de D de 13–14 a 9–10 y mirá qué elemento deja de verlo.

Paso 2: dos latches hacen un flip-flop

import random


class FlipFlopD:
    def __init__(self):
        self.q, self._clk, self._d = 0, 0, 0

    def evaluar(self, clk, d):
        if self._clk == 0 and clk == 1:
            self.q = self._d
        self._clk, self._d = clk, d
        return self.q


def maestro_esclavo(clk_lista, d_lista):
    """Dos latches D: el maestro está abierto con clk = 0; el esclavo, con clk = 1."""
    m = s = 0
    salida = []
    for clk, d in zip(clk_lista, d_lista):
        if clk == 0:
            m = d                  # maestro transparente
        else:
            s = m                  # esclavo transparente: copia lo que guardó el maestro
        salida.append(s)
    return salida


rnd = random.Random(7)
iguales = True
for _ in range(500):
    clk = [1 if (t // rnd.choice([2, 3])) % 2 else 0 for t in range(40)]
    clk = [0, 0] + clk                                  # arranca en bajo con margen
    d = [rnd.randint(0, 1) for _ in clk]
    ff = FlipFlopD()
    esperado = [ff.evaluar(c, x) for c, x in zip(clk, d)]
    iguales = iguales and esperado == maestro_esclavo(clk, d)
print("500 secuencias al azar: maestro-esclavo == flip-flop de flanco:", iguales)

clk = [0, 0, 1, 1, 0, 0, 1, 1, 0, 0]
d =   [1, 1, 0, 1, 0, 0, 1, 0, 1, 1]
print("clk", *clk)
print("d  ", *d)
print("Q  ", *maestro_esclavo(clk, d))

En 500 secuencias aleatorias de reloj y dato, la construcción maestro-esclavo y el flip-flop de flanco dan siempre la misma salida. En la secuencia de ejemplo, Q cambia justo en los dos flancos ascendentes y toma el valor que D tenía justo antes.

Paso 3: divisor por 2 e intercambio simultáneo

# Un divisor por 2: D = ~Q, el flip-flop captura una sola vez por flanco
q = 0
trazas = []
for flanco in range(8):
    d = 1 - q             # el dato se calcula con el Q de antes del flanco
    q = d                 # y se captura en el flanco
    trazas.append(q)
print("Q tras cada flanco:", *trazas, " -> período doble, frecuencia / 2")

# Dos flip-flops que intercambian sus valores en cada flanco: D1 = Q2 y D2 = Q1
a, b = 1, 0
print("\nactualización simultánea (hardware):")
for flanco in range(4):
    a, b = b, a           # los dos D se leen ANTES del flanco
    print(f"  flanco {flanco + 1}: Q1 = {a}  Q2 = {b}")

a, b = 1, 0
print("\nactualización secuencial (bug típico en software):")
for flanco in range(4):
    a = b                 # Q1 ya cambió...
    b = a                 # ...y Q2 copia el valor nuevo
    print(f"  flanco {flanco + 1}: Q1 = {a}  Q2 = {b}")

Con D = ¬Q, Q alterna 1 0 1 0…: el período se duplica. Con D₁ = Q₂ y D₂ = Q₁ las dos salidas se intercambian en cada flanco; escribiendo el mismo código de forma secuencial (a = b; b = a) los dos valores se igualan y el intercambio nunca ocurre. En hardware, todos los flip-flops capturan «a la vez».

Paso 4: ¿qué captura según cuándo cambia D?

T_CLK = 100.0     # ns: instante del flanco ascendente
T_SU = 15.0       # ns de preparación (setup), orientativo
T_H = 3.0         # ns de mantenimiento (hold), orientativo


def capturado(t_cambio, d_antes, d_despues):
    """D cambia en t_cambio. ¿Qué captura el flip-flop?"""
    if t_cambio <= T_CLK - T_SU:
        return d_despues, "cambió a tiempo: captura el dato nuevo"
    if t_cambio >= T_CLK + T_H:
        return d_antes, "cambió después: captura el dato viejo"
    return None, "violación de setup/hold: resultado indefinido"


print("D pasa de 0 a 1 en t (ns) | Q capturada | explicación")
for t in (60, 80, 85, 90, 99, 100, 102, 103, 110):
    q, texto = capturado(t, 0, 1)
    print(f"{t:24d} | {str(q):11s} | {texto}")

print()
t_clk_q, t_logica = 20.0, 15.0
periodo = t_clk_q + t_logica + T_SU
print(f"período mínimo = {t_clk_q} + {t_logica} + {T_SU} = {periodo} ns -> f máx = {1000 / periodo:.1f} MHz")

Con t_su = 15 ns y t_h = 3 ns, un cambio hasta 85 ns captura el dato nuevo y uno desde 103 ns captura el viejo; entre 90 y 102 ns la captura es indefinida. El período mínimo sale de 20 + 15 + 15 = 50 ns, o sea 20 MHz. Cambiá los tiempos y mirá cómo se mueve la ventana.

Una diferencia con el software: acá el flanco se detecta comparando el valor anterior de clk con el actual. En el hardware esa comparación no existe: el propio circuito maestro-esclavo la realiza de forma física, sin ninguna lectura previa.

09 · Exploración interactiva

Latch y flip-flop lado a lado

El laboratorio muestra dos elementos alimentados por el mismo dato D y el mismo reloj: arriba, un flip-flop D de flanco ascendente construido con maestro y esclavo; abajo, un latch D simple. Cada latch aparece resaltado cuando está abierto (transparente). Subí y bajá el reloj con los botones, y cambiá D a voluntad. Los contadores muestran cuántas veces cambió cada salida.

Recorrido guiado

1. Marcá «Dato D = 1» con CLK en bajo. El maestro (abierto) toma el 1, pero las dos salidas siguen en 0: el latch simple está cerrado y el esclavo también.
2. Presioná «CLK ↑». El maestro se cierra con 1 y el esclavo se abre: el flip-flop pasa a Q = 1. El latch simple se abre y copia D: también Q = 1. Hasta acá se comportan igual.
3. Con el reloj en alto, desmarcá D. El latch cae a 0; el flip-flop sigue en 1 porque su maestro está cerrado. Esa es la diferencia central.
4. Presioná «CLK ↓». El esclavo se cierra reteniendo 1 y el maestro se abre, tomando D = 0. El flip-flop sigue en 1: todavía no hay flanco que lo actualice.
5. Presioná «CLK ↑»: el flip-flop captura el 0 que había quedado esperando en el maestro y pasa a 0. Ahora los dos coinciden otra vez.
6. Con el reloj en alto, presioná «Glitch en D». El latch invierte su salida y vuelve; el flip-flop no se mueve. Compará los contadores de cambios.
7. Bajá el reloj y repetí el glitch: nadie lo ve. Lo que importa es D justo antes del flanco, no lo que ocurra en el medio.
8. Probá cambiar D justo después de subir el reloj: el flip-flop ya capturó el dato anterior y recién tomará el nuevo en el flanco siguiente. Ese retraso de un ciclo es el «delay» de la D.

10 · Método de trabajo

Cómo leer un cronograma de flip-flops

1. Identificá el flanco activo del símbolo (triángulo solo o con burbuja) y marcalo con líneas verticales.
2. En cada línea, mirá D justo antes (a su izquierda), no durante ni después.
3. Escribí Q después: Q+ = D. Si D coincide con Q, no hay cambio visible.
4. Dibujá el escalón de Q un poco a la derecha del flanco, para recordar el retardo t_clk→Q. Nunca antes.
5. Ignorá todo lo que hace D entre flancos, salvo que caiga en la ventana de preparación y mantenimiento: ahí hay que marcar una violación.
6. Con varios flip-flops, leé todos con los valores de antes del flanco. Nunca uses el valor nuevo de uno para calcular otro en el mismo flanco.
7. Verificá el período contra T ≥ t_clk→Q + t_lógica + t_su.

En la mesa, con un analizador lógico, el reloj se usa como disparo y se miran D, Q y el reloj en la misma captura. Si Q cambia en un instante distinto de los flancos, hay un reloj sucio, un preset/clear activo o un latch en lugar de un flip-flop.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. Seguir el cronograma

Un flip-flop D de flanco ascendente parte de Q = 0. Los flancos ↑ ocurren en t = 4, 8, 12 y 16, y D vale justo antes de cada uno 1, 1, 0 y 1. Entre flancos, D cambia varias veces. ¿Cuánto vale Q después de cada flanco?

2. ¿Se captura bien?

Un flip-flop pide t_su = 15 ns y t_h = 3 ns. El flanco ocurre en t = 200 ns. D cambia de 0 a 1 en t = 190, 180 y 201 ns. ¿Qué pasa en cada caso?

3. Una cadena de divisores

Un reloj de 16 MHz entra a una cadena de tres flip-flops, cada uno con D = ¬Q y el reloj del siguiente tomado de la salida Q del anterior. ¿Qué frecuencia sale de la última etapa y qué ciclo de trabajo tiene?

4. El intercambio

En un programa, a y b modelan dos flip-flops con D₁ = Q₂ y D₂ = Q₁. ¿Por qué a = b; b = a modela mal el hardware y cómo se escribe bien?

5. Latch o flip-flop

¿Qué elemento usarías para (a) un puerto de salida que retiene el último byte escrito cuando llega un pulso de escritura; (b) un contador de 4 bits; (c) sincronizar con el reloj una entrada que cambia en cualquier momento?

6. Frecuencia máxima

Un circuito tiene t_clk→Q = 20 ns, lógica de 30 ns entre flip-flops y t_su = 15 ns. ¿Cuál es la frecuencia máxima? ¿Y si se parte la lógica en dos mitades con un flip-flop intermedio?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 9?

Antes de avanzar, explicá con tus palabras por qué un flip-flop puede realimentarse y un latch no, dibujá el cronograma de un flip-flop con un D ruidoso y calculá el período mínimo de un circuito con sus tres tiempos. Si podés justificar las tres respuestas, ya podés pasar a otros tipos de flip-flop.

En el próximo tema veremos los flip-flops JK y T: sus tablas características, el modo de conmutación y la división por dos, y cómo se obtienen a partir del flip-flop D.