Tiempos reales y sincronización

01 · Punto de partida

Del instante a la ventana

En los temas 3 y 8 dejamos varias promesas: que el dato debe estar estable alrededor del flanco, que el período mínimo depende de los retardos, y que si algo cambia en el peor momento ocurre un fenómeno llamado metastabilidad. Este es el tema donde se cumplen esas promesas.

La idea central es que cada afirmación del tipo «el flip-flop captura D en el flanco» tiene una letra chica: siempre que D se haya mantenido estable un tiempo antes y otro después. Si el circuito entero respeta esa letra chica, se comporta como los diagramas ideales. Si no, el resultado depende de la temperatura, la tensión, el ejemplar del chip y la suerte.

Todos los valores numéricos son ejemplos orientativos para comprender las magnitudes; los reales vienen en la hoja de datos de cada componente, en condiciones de tensión y temperatura determinadas.

02 · Tres parámetros

La ventana de un flip-flop

Un flip-flop se caracteriza por tres tiempos alrededor del flanco activo del reloj:

Entre t_su antes y t_h después del flanco hay una ventana prohibida de 18 ns en este ejemplo. Si D cambia fuera de ella, el resultado es el esperado: antes de la ventana, el flip-flop captura el dato nuevo; después, el viejo. Si cambia dentro de ella, el flip-flop puede capturar cualquiera de los dos valores, o quedar en un estado a medias que se resuelve después de un tiempo indeterminado. El laboratorio lo muestra con un deslizador.

03 · Verificar un circuito

El camino entre dos flip-flops

En un circuito síncrono, lo que importa es lo que ocurre entre un flip-flop de origen y uno de destino con lógica en el medio. Dos desigualdades, una por cada ventana, resumen todo el análisis temporal:

Cada una usa un extremo distinto del retardo. Para la preparación importa el camino más lento (máximos), porque el dato tiene que llegar a tiempo para el próximo flanco. Para el mantenimiento importa el camino más rápido (mínimos), porque el dato nuevo no debe llegar antes de que el flip-flop termine de «soltar» el anterior. A la diferencia entre lo que hay y lo que se exige se la llama holgura (slack): positiva, cumple; negativa, viola.

El sumador no llega: necesita 20 + 45 + 15 + 2 = 82 ns, y el período es de 60. El período mínimo de todo el circuito lo fija su camino crítico (el sumador), que limita la frecuencia a unos 12 MHz. Las opciones son bajar la frecuencia, partir el sumador en dos con un registro intermedio (pipeline, con latencia mayor) o usar una lógica más rápida.

Observá también el registro de desplazamiento: al conectar Q directo a D no hay lógica, y su único colchón de mantenimiento es el t_clk→Q,mín del propio flip-flop (10 ns contra los 3 + 2 que se exigen). Funciona, pero si el reloj llegara con mucho desfasaje, esa holgura se perdería, como se ve en la sección siguiente.

04 · El reloj no es perfecto

Skew y jitter

El skew es especialmente peligroso para el mantenimiento. Si el reloj llega al flip-flop de destino 12 ns después que al de origen, el dato nuevo ya salió del origen y puede llegar al destino antes de que este termine de capturar el anterior. Con los números del ejemplo, el registro de desplazamiento pasa de +5 ns a −5 ns de holgura de mantenimiento: violación, sin que se haya tocado la frecuencia. Es el caso más difícil de reconocer en la mesa, porque no se arregla bajando la velocidad.

Las prácticas para reducir el skew son simples: el mismo reloj llega con trazas de longitud parecida, con un buffer dedicado para repartirlo (como en el fan-out del curso de Electrónica Digital), a pocos destinos por rama, y sin pasar por compuertas que lo retrasen o lo ensucien.

05 · Cuando algo cambia dentro de la ventana

Metastabilidad

Recordá el paisaje del tema 4: un biestable tiene dos valles estables y una loma inestable entre ambos. Si D cambia dentro de la ventana, el flip-flop puede quedar «sobre la loma»: su salida no es un 0 ni un 1 limpios, sino un nivel intermedio que cae hacia un lado tras un tiempo impredecible. Ese tiempo es aleatorio; lo que se conoce es la probabilidad de que dure más que cierto valor:

τ es una constante del dispositivo (decenas de picosegundos en tecnologías rápidas, fracciones de nanosegundo en una familia 74HC). La probabilidad cae exponencialmente con el tiempo de resolución disponible t_r: cada τ extra la divide por e ≈ 2,7. Y la frecuencia con que ocurre el evento depende de cuántas veces cae un cambio de D en la ventana. Juntas, dan el tiempo medio entre fallos:

Es una lección sobre la exponencial: sumar un período de resolución (de 5 a 20 ns de tiempo disponible) pasa de segundos a millones de años. La metastabilidad nunca desaparece, pero se vuelve tan improbable que deja de importar. Y no es un defecto de un chip: es una propiedad de cualquier biestable al que se le pida decidir sobre una señal que cambia a destiempo.

06 · La solución estándar

El sincronizador de dos flip-flops

Si una entrada asíncrona tiene que entrar al sistema, se la pasa por dos flip-flops en cadena, ambos con el mismo reloj, y solo la salida del segundo se usa en el resto del circuito:

El primer flip-flop puede tomar la señal en cualquier momento y, eventualmente, quedar indefinido. Pero el segundo no mira su salida hasta un período completo después: tiempo suficiente, con altísima probabilidad, para que el primero se haya decidido. Cada flip-flop de la cadena aporta otro período de resolución, y el MTBF crece exponencialmente.

07 · Casos de uso

Pulsadores, pulsos y buses

Un pulsador, una pulsación

Con la señal ya sincronizada (y limpia de rebotes, tema 7), todavía queda un problema: si el pulsador se mantiene apretado durante 5 ciclos, un contador que la use como habilitación contaría 5. Lo que se quiere es un pulso de un ciclo por cada pulsación: un detector de flancos. Se guarda el valor anterior de la señal en un tercer flip-flop y se comparan:

La cadena completa para un botón es: antirrebote → sincronizador de dos flip-flops → detector de flancos → contador. La construiremos como proyecto en el taller del contador de eventos.

Pulsos cortos

Un sincronizador no puede ver lo que dura menos de un período. Si el evento es muy breve, hay que capturarlo antes con un biestable asíncrono, es decir, un latch SR del tema 5 que se borra con el reloj una vez leído. Es el equivalente a un bit de «interrupción pendiente».

Buses de varios bits

Sincronizar bit por bit un bus que cambia con otro reloj (por ejemplo una cuenta) no sirve: como los bits cambian con pequeñas diferencias, cada sincronizador puede capturarlos en ciclos distintos y el destino lee una combinación que nunca existió, el mismo problema del hazard de función del curso de Electrónica Digital. Hay tres soluciones: usar un código Gray (un solo bit cambia por paso), un protocolo de señalización (un bit sincronizado le avisa al destino cuándo el dato es estable) o una memoria FIFO entre los dos dominios. Las veremos en el último bloque.

08 · Analogía con programación

Presupuestos de tiempo, ventanas de carrera y sincronización

Verificar los tiempos de un circuito se parece a revisar un presupuesto de latencia: cada etapa consume una parte del período, y la suma tiene que entrar. La metastabilidad se parece a una condición de carrera con una ventana minúscula: ocurre muy poco, pero cuando ocurre es irreproducible. Un sincronizador es la solución clásica: no intentar leer el estado hasta que se haya asentado.

Paso 1: holguras de preparación y mantenimiento

# Parámetros del flip-flop (ns, orientativos)
T_CLKQ_MAX, T_CLKQ_MIN = 20.0, 10.0
T_SU, T_H = 15.0, 3.0

# (camino, retardo máximo de la lógica, retardo mínimo de la lógica)
CAMINOS = [("registro de desplazamiento (Q → D directo)", 0.0, 0.0),
           ("contador: T1 = Q0 (una AND)", 8.0, 5.0),
           ("contador: T3 = Q0·Q1·Q2 (AND de 3)", 12.0, 8.0),
           ("sumador de 4 bits entre registros", 45.0, 15.0)]


def holgura_setup(periodo, t_log_max, skew):
    """Cuánto sobra del período: T - (clk→Q + lógica + setup + skew)."""
    return periodo - (T_CLKQ_MAX + t_log_max + T_SU + skew)


def holgura_hold(t_log_min, skew):
    """El dato nuevo no debe llegar antes de que pase el mantenimiento."""
    return (T_CLKQ_MIN + t_log_min) - (T_H + skew)


for skew in (2.0, 12.0):
    print(f"--- skew = {skew} ns, período = 60 ns ---")
    print("camino                                          setup   hold")
    peor = 0.0
    for nombre, t_max, t_min in CAMINOS:
        s, h = holgura_setup(60.0, t_max, skew), holgura_hold(t_min, skew)
        marca = "  <-- VIOLACIÓN" if (s < 0 or h < 0) else ""
        print(f"{nombre:46s} {s:6.1f} {h:6.1f}{marca}")
        peor = max(peor, T_CLKQ_MAX + t_max + T_SU + skew)
    print(f"período mínimo = {peor:.0f} ns -> f máx = {1000 / peor:.1f} MHz\n")

Con 2 ns de skew, el sumador viola la preparación (−22 ns) y el período mínimo del circuito es de 82 ns, unos 12 MHz. Con 12 ns de skew aparece una violación de mantenimiento en el registro de desplazamiento (−5 ns), que no depende del período. Cambiá el skew o el período y miralo cambiar.

Paso 2: ventana, probabilidad y MTBF

import math
import random

T, T_SU, T_H = 50.0, 15.0, 3.0           # período y ventana (ns)
TAU, T_W = 0.5, 0.1                      # constantes de metastabilidad de ejemplo (ns)
T_CLKQ, T_LOGICA = 20.0, 10.0

rnd = random.Random(1)
N = 200_000
dentro = sum(1 for _ in range(N) if (lambda t: t >= T - T_SU or t < T_H)(rnd.uniform(0, T)))
print(f"fracción de cambios de D que caen en la ventana: simulada {dentro / N:.3f}, teórica {(T_SU + T_H) / T:.3f}")

f_clk, f_dato = 1e9 / T, 1e6              # 20 MHz de reloj y 1 MHz de cambios del dato


def mtbf_segundos(tr_ns):
    return math.exp(tr_ns / TAU) / (T_W * 1e-9 * f_clk * f_dato)


def legible(seg):
    if seg < 120:
        return f"{seg:.0f} s"
    for nombre, valor in (("años", 3.15e7), ("días", 86400.0), ("horas", 3600.0)):
        if seg >= valor:
            return f"{seg / valor:.3g} {nombre}"
    return f"{seg / 60:.0f} min"


tr_uno = T - T_CLKQ - T_LOGICA - T_SU                       # un flip-flop, con lógica detrás
tr_dos = (T - T_CLKQ - T_SU) + (T - T_CLKQ - T_LOGICA - T_SU)   # sincronizador de dos etapas
print(f"\ntiempo de resolución disponible: una etapa {tr_uno:.0f} ns, dos etapas {tr_dos:.0f} ns")
for nombre, tr in (("una etapa", tr_uno), ("dos etapas", tr_dos)):
    p = math.exp(-tr / TAU)
    print(f"{nombre:10s}: P(indefinida) = {p:.1e} por evento, MTBF = {legible(mtbf_segundos(tr))}")

La fracción de cambios que cae en la ventana coincide con (t_su + t_h) / T = 36 %. Con una sola etapa la probabilidad de quedar indefinida es de 4,5 × 10⁻⁵ por evento y el MTBF de unos 11 segundos; con dos etapas, 4,2 × 10⁻¹⁸ y millones de años. Probá bajar T a 46 ns y mirá cómo se desploma la ventaja (con T menor que 45 ns ya no queda tiempo de resolución y el modelo deja de tener sentido).

Paso 3: un sincronizador frente a pulsos al azar

import random

T, T_SU, T_H = 50.0, 15.0, 3.0
rnd = random.Random(3)

# Pulsos asíncronos: (inicio, ancho) en ns, sin relación con el reloj
pulsos, t = [], 20.0
for _ in range(40):
    ancho = rnd.uniform(10, 120)
    pulsos.append((t, ancho))
    t += ancho + rnd.uniform(60, 200)

flancos = [k * T for k in range(int(t / T) + 3)]


def valor(tiempo):
    return int(any(ini <= tiempo < ini + w for ini, w in pulsos))


def cambia_cerca(tiempo):
    cambios = [x for ini, w in pulsos for x in (ini, ini + w)]
    return any(tiempo - T_H < c < tiempo + T_SU for c in cambios)    # ventana de [flanco - setup, flanco + hold]


q1, q2, indefinidos = 0, 0, 0
salida = []
for f in flancos:
    q2 = q1                                  # la segunda etapa copia lo que ya se asentó
    if cambia_cerca(f):
        indefinidos += 1
        q1 = rnd.randint(0, 1)               # la primera etapa elige cualquiera (modelo de resolución)
    else:
        q1 = valor(f - 0.01)                 # justo antes del flanco
    salida.append(q2)

vistos = sum(1 for ini, w in pulsos if any(ini <= f < ini + w for f in flancos))
print(f"pulsos asíncronos enviados: {len(pulsos)}")
print(f"pulsos que algún flanco vio: {vistos}; perdidos por ser más cortos que el período: {len(pulsos) - vistos}")
print(f"muestras de la 1.ª etapa dentro de la ventana (indefinidas): {indefinidos} de {len(flancos)}")
print("la 2.ª etapa solo ve valores ya resueltos; su salida llega entre 1 y 2 períodos después que la entrada")
print(f"salida sincronizada: {sum(1 for a, b in zip(salida, salida[1:]) if a == 0 and b == 1)} flancos de subida")

De 40 pulsos asíncronos, el reloj de 50 ns vio 37 y perdió 3, todos más cortos que el período. De 168 flancos, 29 cayeron cerca de un cambio de la entrada y la primera etapa quedó indefinida (el modelo la resuelve al azar). La segunda etapa siempre recibe un valor limpio, con un retraso de 1 a 2 períodos.

Paso 4: de un nivel a un pulso de un ciclo

def detector_de_flancos(sincronizada):
    """Un pulso de un ciclo por cada flanco ascendente: q_actual AND NOT q_anterior."""
    q_ant, pulsos = 0, []
    for q in sincronizada:
        pulsos.append(1 if q == 1 and q_ant == 0 else 0)
        q_ant = q
    return pulsos


# Un pulsador ya sincronizado: se mantuvo apretado 5 ciclos, se soltó, y se apretó 2 ciclos más
entrada = [0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0]
pulsos = detector_de_flancos(entrada)
print("pulsador   ", *entrada)
print("un solo ciclo", *pulsos)
print(f"cuenta = {sum(pulsos)} pulsaciones (no importa cuánto se mantuvo apretado)")

contador = 0
for p in pulsos:
    contador += p             # el contador usa el pulso de un ciclo como habilitación
print("valor del contador:", contador)

El pulsador se mantuvo apretado 5 ciclos y, después, 2: el detector entrega exactamente un pulso de un ciclo por cada flanco ascendente, y el contador suma 2. Si el contador usara el nivel directamente como habilitación, habría sumado 7.

Una diferencia con el software: acá no hay forma de «reintentar» una lectura. Si el dato se capturó mal, el sistema continúa con un valor equivocado, y por eso la defensa se hace en el diseño, no en el tiempo de ejecución.

09 · Exploración interactiva

La ventana y el sincronizador

El primer panel muestra la ventana de un flip-flop: el flanco ascendente en t = 80 ns, la ventana sombreada entre t_su antes y t_h después, y la transición de D en el instante que elijas con el deslizador «Cambio de D». El resultado se calcula con la regla de la sección 2. El segundo panel envía transiciones asíncronas al azar contra un reloj de período T y mide qué parte cae en la ventana, con las probabilidades de la sección 5 para una y dos etapas.

Recorrido guiado

1. Con los valores iniciales, D cambia 40 ns antes del flanco: queda 25 ns antes del borde de la ventana. El flip-flop captura el dato nuevo y Q sube t_clk→Q después del flanco.
2. Llevá el deslizador a −15 ns: el cambio coincide con el borde de la ventana (t_su = 15). Todavía es seguro, con margen 0.
3. Pasá a −10 ns, −5 ns, 0 y +2 ns: la zona roja con «¿0 o 1?» indica una violación. En esos casos nadie puede predecir qué captura.
4. Con +3 ns el cambio llega justo después del mantenimiento: el flip-flop captura el dato viejo. Con +20 ns, también.
5. Subí t_su a 25 ns: la ventana se ensancha hacia la izquierda y el cambio de −20 ns, que era seguro, pasa a ser una violación. Cuanto más lento el flip-flop, más exigente.
6. Subí la lógica a 45 ns: el período mínimo pasa de 45 a 80 ns y la frecuencia máxima baja de 22 a 12,5 MHz. Es el camino crítico.
7. En el panel 2, enviá 100 transiciones con T = 50 ns: alrededor del 36 % cae en la ventana. Reducí T a 30 ns y repetí: la fracción sube hasta cerca del 60 %.
8. Compará P(indefinida) para una y dos etapas con T = 50 ns y mirá cómo la segunda es astronómicamente menor. Bajá T hasta 45 ns: la primera pasa a 1 (sin tiempo de resolución) mientras la segunda todavía vale unos 2 × 10⁻⁹. Si seguís bajando, la segunda también deja de servir.

10 · Método de trabajo

Cómo verificar los tiempos de un diseño

1. Reunir los números: t_su, t_h, t_clk→Q (mínimo y máximo) y retardos de las compuertas, en las condiciones reales de tensión y temperatura.
2. Listar los caminos entre cada par de flip-flops conectados, con su lógica de mayor y menor retardo.
3. Calcular la holgura de preparación de cada camino con máximos y el skew; el menor valor define el camino crítico y el período mínimo.
4. Calcular la holgura de mantenimiento con mínimos; si es negativa, agregar retardo al dato o reducir el skew.
5. Identificar las entradas externas: toda señal que no nazca de un flip-flop del mismo reloj es asíncrona y necesita sincronizador.
6. Sincronizar bit por bit solo señales de un bit; para buses, usar Gray, handshake o FIFO.
7. Dejar un margen razonable (por ejemplo, 20 a 30 %) en la frecuencia, para absorber jitter y variaciones.
8. Probar en los extremos: temperatura alta y baja, tensión mínima, ejemplares distintos.

En la mesa, un analizador lógico con disparo en el flanco del reloj permite medir cuándo cambian los datos respecto de él. La señal cuya transición queda más cerca de la ventana es la que va a fallar primero cuando se suba la temperatura o la frecuencia.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Calculá antes de comprobar

1. Holgura de preparación

Un camino tiene t_clk→Q,máx = 20 ns, lógica máxima de 8 ns, t_su = 15 ns y skew de 2 ns. Con un reloj de 25 MHz (T = 40 ns), ¿cuánto vale la holgura? ¿Cuál es la frecuencia máxima?

2. Holgura de mantenimiento

Un registro de desplazamiento (sin lógica) tiene t_clk→Q,mín = 8 ns, t_h = 5 ns y el reloj llega al destino 6 ns después que al origen. ¿Se cumple? ¿Se arregla bajando la frecuencia?

3. Probabilidad de caer en la ventana

Una entrada asíncrona cambia en instantes uniformemente distribuidos. Con T = 40 ns, t_su = 12 ns y t_h = 2 ns, ¿qué fracción de los cambios cae en la ventana? ¿Y si se duplica la frecuencia del reloj?

4. El valor de una etapa más

Con τ = 0,5 ns, T = 50 ns, t_clk→Q = 20 ns y t_su = 15 ns, el segundo flip-flop de un sincronizador agrega 15 ns de tiempo de resolución. ¿Por qué factor multiplica el MTBF?

5. La cadena de un botón

Un pulsador debe incrementar un contador de eventos una vez por pulsación, con el reloj del sistema a 1 MHz. Dibujá la cadena de bloques y explicá para qué sirve cada uno.

6. El bus incoherente

Un contador de 4 bits de otro reloj pasa de 0111 a 1000. Un circuito lo lee con cuatro sincronizadores independientes. ¿Qué valores puede leer? ¿Cómo se evita?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 12?

Antes de avanzar, calculá las dos holguras de un camino con tus propios números, explicá por qué el mantenimiento no se arregla con el reloj y dibujá un sincronizador de dos flip-flops indicando dónde puede ocurrir la metastabilidad. Si podés justificar las tres respuestas, ya podés pasar al taller de flip-flops reales.

En el próximo tema es la hora de la mesa de trabajo: el taller de flip-flops con el 74HC74, donde armamos captura, reset y un reloj manual sin rebotes.