Hazards y glitches

01 · Punto de partida

Y = B, pero parpadea

Y = A·B + ~A·B es B (Tema 15): con B=1 la salida debería quedar en 1 siempre. Pero al pasar A de 1 a 0, un AND se apaga antes de que el otro se prenda: pozo de 2 retardos a 0. Tabla perfecta, tiempo traidor.

• ¿Por qué un camino tarda más?
• ¿Cuándo el glitch importa?
• ¿Cómo lo tapa un término redundante?
• ¿Qué cambia con diseño síncrono?

02 · Tipos

Fijo que se mueve

Causa: la señal llega por dos caminos (directo y negado) con distinto retardo; al reconverger en la OR hay un instante sin nadie en 1.

03 · Cuándo importa

No siempre duele

Remedio 1: redundancia

Agregar el término consenso B (Y = A·B + ~A·B + B = B): cubre la transición. Consenso del Tema 14 trabajando.

Remedio 2: síncrono

Muestrear con clock después de asentarse (curso 6): el glitch muere solo antes del flanco.

04 · Ejemplo cronometrado

Pozo en t = 2

Retardo 1 por puerta, B = 1, A pasa 1→0 en t = 0: el AND directo cae en t = 1 pero el negado recién sube en t = 2. La OR ve 0+0 y muestra 0 en t = 2, volviendo a 1 en t = 3. El laboratorio lo dibuja.

05 · Glitch en código

Simular retardos

Puertas con retardo 1 paso: el pozo aparece solo.

def glitch(transicion=(1, 0), redundante=False):
    A = lambda t: transicion[0] if t < 0 else transicion[1]
    nA = lambda t: 1 - A(t - 1)
    y1 = lambda t: A(t - 1) and 1
    y2 = lambda t: nA(t - 1) and 1
    r = lambda t: 1
    ys = []
    for t in range(0, 5):
        y = (y1(t - 1) or y2(t - 1) or (r(t - 1) if redundante else 0))
        ys.append(int(y))
    print(f"{transicion} redundante={redundante}: Y={ys}")
    return ys


glitch()
glitch(redundante=True)
glitch(transicion=(0, 1))

1→0: [1, 1, 0, 1, 1] (pozo en t=2). Con redundante: todo 1. 0→1: limpio (solape, no pozo).

Ancho del pozo

ys = glitch()
print(f"pozo de {ys.count(0)} paso(s) x retardo de puerta")
print("a 10ns por puerta: ~20ns invisible al ojo, mortal para un clock")

06 · Analogía programador

Race condition

1. 1
   Glitch = race.

   Dos caminos escriben el resultado a distinto tiempo: ventana donde nadie escribió bien. Igual que threads sin lock.

2. 2
   Redundancia = idempotencia.

   Término extra que cubre la ventana: como reintento que tapa el hueco.

3. 3
   Síncrono = barrier.

   Muestrear cuando todos llegaron: barrera que elimina carreras por diseño.

07 · Exploración

Laboratorio: cazar el pozo

Transición de A con B=1, con o sin término redundante: el laboratorio dibuja Y(t) paso a paso.

Preguntas para explorar

1. Probá 0→1 sin +B. ¿Pozo? ¿Por qué un sentido sí y el otro no?
2. Activá +B con 1→0. ¿Pozo? ¿Qué término lo tapa?
3. ¿De qué sirve saber el ancho en pasos? (Pista: ns por puerta.)

08 · Comprensión

Confusiones frecuentes

09 · Práctica guiada

Ejercicios de pozos

Ejercicio 1: static-0

Y = ~(A·B + ~A·B) (NOR del ejemplo). ¿Transición con pico a 1? ¿Redundante dual?

Ejercicio 2: medir un glitch

XOR con A=B=misma señal que cambia: Y debería ser 0 siempre. ¿Qué ves en el scope? ¿Por qué?

Ejercicio 3: ¿importa?

Glitch de 20 ns en: (a) LED, (b) enable de latch, (c) entrada de clock. ¿En cuáles actuás?

10 · Síntesis

Ideas para recordar

Pozos entendidos. Ahora lo eléctrico fino: en el próximo tema, consumo y buenas prácticas.