Latch D y habilitación

01 · Punto de partida

Escribir un dato, no dos órdenes

Con un latch SR, para guardar un bit hay que decidir si es un 1 (dar la orden de Set) o un 0 (dar la de Reset), y cuidar que nunca coincidan. Pero el bit que queremos almacenar casi siempre llega como un dato: una línea que vale 0 o 1. Convertir ese dato en las dos órdenes cada vez sería un trabajo repetitivo, y cualquier error nos lleva a la combinación prohibida del tema anterior.

Tampoco queremos que el latch reaccione a cualquier cambio de sus entradas en cualquier momento, como hacía el SR. Necesitamos poder decir «ahora guardá lo que hay en D» y «ahora ignorá todo». Esa segunda señal es la habilitación (enable).

Es el último escalón antes del flip-flop: casi todo lo que veremos en el tema 8 se explica comparándolo con este circuito.

02 · Primer paso

Latch SR con habilitación

Para controlar cuándo el latch escucha, se colocan dos puertas AND delante de sus entradas. Cada orden pasa solo si la habilitación E vale 1:

La habilitación resuelve la mitad del problema: ahora hay un momento controlado para escribir. Con E = 0, el latch ignora el ruido de S y R. Pero con E = 1 sigue valiendo todo lo del tema 5: dos entradas, una combinación prohibida, y la obligación de traducir cada dato a órdenes.

03 · La idea clave

El latch D: una sola entrada de datos

El truco para eliminar las dos órdenes es derivarlas de una sola señal, el dato D, de forma que sean siempre opuestas: si D vale 1, se pide Set; si vale 0, se pide Reset. Basta un inversor:

Como S′ y R′ nunca valen 1 a la vez, la combinación prohibida desaparece por construcción. Si E = 0, ambas valen 0 y el latch retiene. Si E = 1, exactamente una de las dos vale 1 y empuja a Q hacia el valor de D:

Su tabla característica, con el estado actual Q como entrada, queda así. Coincide, fila por fila, con la ecuación de abajo:

Reconocerás la forma: es un multiplexor de 2 a 1 (Electrónica Digital, tema 18) con E como selector, D como una entrada y la propia salida Q como la otra. Con E = 1 elige el dato nuevo; con E = 0 elige lo que ya tenía. Un latch D es un multiplexor que se elige a sí mismo cuando no se lo habilita. Esa es, quizás, la mejor definición de «memoria» que vimos hasta ahora.

04 · Cómo se comporta

Transparente o cerrado

El latch D tiene dos modos. Con E = 1 es transparente: la salida sigue a la entrada como si el latch no estuviera (con el retardo de las puertas). Con E = 0 está cerrado y mantiene el último valor. El momento clave es el instante en que E pasa de 1 a 0: el dato que haya en D en ese instante queda guardado. Se dice que es un elemento sensible al nivel de E, a diferencia del flip-flop del tema 8, que será sensible a un flanco.

Tres cosas para observar. Primero, mientras E = 0 los cambios de D (como el de t = 2 o el de t = 14) no llegan a Q. Segundo, mientras E = 1, Q repite todos los cambios de D, incluidos los que no queríamos. Tercero, cuando E baja, queda guardado el último valor de D. Para que sea el correcto, D debe estar estable un tiempo antes y después de que E baje; son los tiempos de preparación y mantenimiento (setup y hold) que estudiaremos en el tema de tiempos reales. En el dibujo, para simplificar, no hay retardos.

05 · En los catálogos

Polaridad de la habilitación e integrados reales

Como pasaba con las entradas del latch SR, la habilitación puede ser activa en alto (el latch está abierto con E = 1) o activa en bajo (abierto con Ē = 0). Los datasheets la llaman E, G, LE (latch enable), C o CP, y la burbuja indica polaridad baja. Hay que leerlo siempre: la misma etiqueta puede significar lo contrario según el fabricante.

Dos entradas distintas caben en el 373 y el 573, y no hay que confundirlas: LE decide cuándo el latch captura (transparencia), y OE̅ decide si las salidas se ven en el bus o quedan en alta impedancia (tri-estado, del curso de Electrónica Digital). Se puede retener un dato con las salidas desconectadas, y recuperarlo después.

06 · Aplicaciones

Dónde se usa un latch D

En todos los casos se repite el esquema: un dato que está disponible un instante, una señal que dice «guardalo ahora» y una salida que lo mantiene. Si programás, es la primera forma de la asignación a una variable: el momento de la asignación es la habilitación; el valor, D; y la variable, el latch.

07 · El límite

Cuando la transparencia es un problema

Realimentar un latch transparente

Imaginá un contador que usa un latch D con D = ¬Q: la idea es que Q cambie cada vez que se habilita. Con E = 1, Q se invierte; pero al cambiar, vuelve a D, que cambia otra vez; mientras E siga en 1, la salida no deja de invertirse. Cuántas veces cambia depende de cuánto dura el pulso de E, no de cuántos pulsos hubo.

Esta carrera es exactamente la que hace imposible usar un latch transparente como elemento de un contador o de un registro de desplazamiento. Se necesita un elemento que, aun estando habilitado, no vea su propia salida hasta el siguiente ciclo. La solución es capturar en un instante, no durante un intervalo: el flip-flop.

Dos latches hacen un flip-flop

Si se ponen dos latches D en serie, con habilitaciones opuestas (uno abierto cuando E = 1 y el otro cuando E = 0), el primero («maestro») sigue a D mientras el segundo («esclavo») está cerrado; al bajar E, el maestro se cierra y el esclavo se abre, trasladando a la salida el dato que quedó capturado. La salida cambia una sola vez por ciclo, justo en un flanco. Es la estructura maestro-esclavo del flip-flop del tema 8.

Un riesgo oculto: el hazard del multiplexor

Hay además un problema de tiempos interno. Si el latch se arma literalmente con la ecuación Q+ = E·D + ¬E·Q con puertas AND y OR, aparece el hazard estático que estudiaste en Electrónica Digital (tema 28): con D = Q = 1, al bajar E, un término se apaga antes de que el otro se encienda. Como el resultado se realimenta, el pozo puede convertirse en una oscilación sostenida. La corrección es el término de consenso D·Q, que mantiene la salida en 1 durante la transición. Los integrados comerciales ya lo resuelven por dentro, pero es una buena razón para no inventar los latches con puertas sueltas.

08 · Analogía con programación

Una variable con cerrojo

Un latch D se parece a una variable que solo se actualiza cuando una bandera lo permite. Este código lo modela y sigue una secuencia de habilitación y datos; los valores salen de la tabla característica de la sección 3:

Paso 1: la variable con cerrojo

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

    def actualizar(self, e, d):
        if e:              # habilitado: transparente, Q sigue a D
            self.q = d
        return self.q      # con e = 0 retiene


latch = LatchD()
secuencia = [(0, 1), (1, 1), (1, 0), (1, 1), (0, 1), (0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]
for e, d in secuencia:
    print(f"E={e} D={d} -> Q={latch.actualizar(e, d)}")

Con E = 1 el valor entra, con E = 0 se ignora: las líneas 5 y 6 (E = 0) y 9 y 10 conservan el 1 aunque D valga 0. Tras el último E = 1, D = 1, Q queda en 1 y nada más lo cambia. Cambiá la secuencia para que el último E = 1 llegue con D = 0 y comprobá que Q se queda en 0.

Paso 2: construirlo con puertas y verificar la ecuación

def nor(a, b):
    return 0 if (a or b) else 1


def latch_sr(s, r, q, qn):
    """Dos NOR realimentadas, hasta que el lazo se asienta."""
    for _ in range(8):
        nq, nqn = nor(r, qn), nor(s, q)
        if (nq, nqn) == (q, qn):
            break
        q, qn = nq, nqn
    return q, qn


def latch_d(e, d, q, qn):
    s = d & e                  # set solo si hay dato 1 y habilitación
    r = (1 - d) & e            # reset solo si hay dato 0 y habilitación
    assert not (s and r)       # nunca se pide set y reset a la vez
    return latch_sr(s, r, q, qn)


print("E D Q | Q+  E·D + ~E·Q")
ok = True
for e in (0, 1):
    for d in (0, 1):
        for q in (0, 1):
            q2, qn2 = latch_d(e, d, q, 1 - q)
            ecuacion = (e & d) | ((1 - e) & q)
            ok = ok and q2 == ecuacion and qn2 == 1 - q2
            print(f"{e} {d} {q} |  {q2}   {ecuacion}")
print("coincide con la ecuación y Q, ~Q siempre complementarios:", ok)

En las ocho filas, el latch hecho con dos AND y dos NOR coincide con Q+ = E·D + ¬E·Q, y Q y ~Q son siempre complementarios. La aserción de la función latch_d nunca falla: S′ y R′ no valen 1 a la vez. Quitá el inversor ((1 - d)) y la aserción saltará.

Paso 3: transparente frente a cerrado

def latch(e_lista, d_lista, q=0):
    salida = []
    for e, d in zip(e_lista, d_lista):
        if e:
            q = d
        salida.append(q)
    return salida


#      t = 0  1  2  3  4  5  6  7  8  9
d = [0, 0, 1, 0, 0, 0, 1, 0, 0, 0]          # dos glitches de un tick, en t = 2 y t = 6
e_abierta = [1] * 10                         # siempre transparente
e_mitad = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]     # se cierra en t = 5

print("D       ", *d)
print("abierto ", *latch(e_abierta, d))
print("se cierra", *latch(e_mitad, d))
print()
# el dato que queda guardado es el último que vio D antes de cerrar
for cierre in (2, 3, 6, 7):
    e_c = [1 if t < cierre else 0 for t in range(10)]
    print(f"E cae en t={cierre}: queda guardado Q = {latch(e_c, d)[-1]} (D valía {d[cierre - 1]} justo antes)")

Con el latch siempre abierto, los dos glitches de D (en t = 2 y t = 6) llegan a Q. Con E cerrándose en t = 5, el glitch de t = 2 pasa y el de t = 6 queda bloqueado. Lo que guarda el latch al cerrar es el valor que D tenía justo antes: si E cae en t = 3, queda 1; si cae en t = 7, queda 1 por el glitch.

Paso 4: la carrera al realimentar

def latch_realimentado(ancho_e, ticks=10):
    """Latch transparente con D = ~Q y E alto durante ancho_e ticks."""
    q = 0
    trazas = []
    for t in range(ticks):
        e = 1 if 1 <= t < 1 + ancho_e else 0
        if e:
            q = 1 - q            # D = ~Q: cada tick abierto invierte Q
        trazas.append(q)
    return trazas


print("ancho de E | Q en cada tick                 | Q final")
for ancho in range(1, 7):
    q = latch_realimentado(ancho)
    print(f"{ancho:10d} | {' '.join(map(str, q))} | {q[-1]}")
print()
print("El resultado depende del ancho del pulso de E (par o impar), no del diseño.")

Con D = ¬Q, la salida cambia en cada tick en que E está en alto, así que el resultado depende de la paridad del ancho del pulso. Con ancho 1 y 3 termina en 1; con 2 y 4 termina en 0. Por eso el latch transparente no sirve como bloque de un contador.

Paso 5: el hazard del multiplexor realimentado

def simular(consenso, ticks=14):
    """Latch D con mux de puertas AND-OR; cada puerta tarda 1 tick."""
    E = [1 if t < 2 else 0 for t in range(ticks)]    # E cae en t = 2
    D = [1] * ticks
    nE, A1, A2, A3, Q = ([0] * ticks for _ in range(5))
    nE[0], A1[0], A2[0], A3[0], Q[0] = 0, 1, 0, 1, 1  # estado inicial coherente: Q = 1
    for t in range(1, ticks):
        nE[t] = 1 - E[t - 1]
        A1[t] = E[t - 1] & D[t - 1]
        A2[t] = nE[t - 1] & Q[t - 1]
        A3[t] = D[t - 1] & Q[t - 1]
        Q[t] = A1[t - 1] | A2[t - 1] | (A3[t - 1] if consenso else 0)
    return E, Q


for consenso in (False, True):
    E, Q = simular(consenso)
    print("con término de consenso D·Q" if consenso else "sin consenso (Q = E·D + ~E·Q)")
    print("  E", *E)
    print("  Q", *Q)

Con cada puerta tardando un tick, la ecuación sin consenso deja un pozo cuando E cae, y el lazo oscila entre 0 y 1 sin asentarse. Con el término de consenso D·Q, Q se mantiene en 1. Es un modelo ideal; un chip real puede asentarse o no, pero el diseñador no debe apostar a eso.

Las diferencias con el software son las de siempre: el código evalúa una línea tras otra, y el circuito mantiene la memoria con la energía de las puertas. Pero la idea es la misma: una variable cuyo valor cambia solo si una condición lo habilita.

09 · Exploración interactiva

Abrir y cerrar el latch

El diagrama muestra el latch D construido con dos AND y un latch SR de NOR. Los cables en verde valen 1. Las casillas controlan el dato D y la habilitación (abrir el latch); el botón «Glitch en D» introduce un pulso breve en el dato. La opción de polaridad cambia qué nivel físico abre el latch, sin cambiar el significado de la casilla. El contador cuenta cuántos cambios de D llegaron a la salida.

Recorrido guiado

1. Con el latch cerrado, marcá «Dato D = 1». Q sigue en 0: el dato espera en la entrada, y las señales internas S′ y R′ valen 0.
2. Marcá «Abrir el latch». Ahora S′ = 1 y Q pasa a 1: el latch tomó el dato que esperaba. Con el latch abierto, desmarcá D: Q baja a 0. Está siguiendo a D.
3. Con D = 1 y el latch abierto (Q = 1), desmarcá «Abrir el latch». Se cierra con Q = 1. Desmarcá D: Q sigue en 1. El dato quedó guardado.
4. Con el latch cerrado y Q = 1, usá «Glitch en D». Los pulsos no llegan a Q y el contador no sube.
5. Abrí el latch y repetí el glitch. Q cambia y vuelve. El historial registra dos cambios: la transparencia deja pasar también lo que no queríamos.
6. Cambiá la polaridad a «activa en bajo». La casilla «Abrir el latch» sigue abriéndolo, pero en el diagrama el pin Ē vale 0 cuando está abierto. Fijate que el interior del circuito (S′, R′) no cambia.
7. Probá cerrar justo después de cambiar D. Lo que queda guardado es el valor de D en el último instante en que el latch estaba abierto. En un circuito real, esto exige que D esté estable un tiempo antes de cerrar.

10 · Método de trabajo

Cómo especificar y usar un latch D

1. Definí qué dato se guarda y cuándo es válido. D debe ser estable en el instante en que se cierra el latch.
2. Elegí la señal de habilitación y su polaridad. Anotá si el latch se abre con 1 o con 0.
3. Decidí si necesitás un latch o un flip-flop. Si el dato no depende de la salida y la transparencia no molesta, un latch alcanza y ocupa menos. Si hay realimentación (contadores, registros que se desplazan), hace falta un flip-flop.
4. Limitá el tiempo de apertura a lo necesario. Cuanto más tiempo abierto, más ruido de D llega a Q.
5. Definí el estado inicial. Como todo biestable, arranca en cualquiera de sus estados: un pulso inicial de habilitación con un dato conocido lo fija.
6. Revisá tiempos de preparación y mantenimiento de D respecto del cierre de E.
7. Verificá con una secuencia: cerrado con D cambiando (nada), abierto (sigue a D), cierre (retiene) y glitch.

En la mesa, si la salida parece «inventar» valores, revisá primero que la habilitación no tenga rebotes ni glitches: un pulso extra en E equivale a una escritura que nadie pidió.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. Seguir un latch D

Q = 0 al comienzo. Se aplican estos pares (E, D): (0, 1), (1, 1), (1, 0), (0, 0), (0, 1), (1, 0), (0, 1). Escribí Q después de cada uno.

2. Dibujar el cronograma

E vale 1 entre t = 2 y t = 6 y D cambia a 1 en t = 3 y a 0 en t = 5. Si Q = 0 al comienzo, ¿qué valores toma Q en cada tramo y cuál queda guardado cuando E baja?

3. Cerrar con el dato correcto

Una medición llega por D y es válida solo entre t = 10 y t = 14. ¿Cuándo hay que cerrar el latch para guardarla y qué condición debe cumplir D?

4. Elegir latch o flip-flop

¿Cuál de estos casos admite un latch D y cuál exige otro elemento? (a) Un puerto de salida que mantiene el último byte escrito. (b) Un contador de 4 bits.

5. Un 74HC373 en un bus

Un 74HC373 retiene la parte baja de una dirección mientras el bus pasa a llevar datos. ¿Cuándo hay que bajar LE y cuándo conviene tener OE̅ activa?

6. La ecuación como multiplexor

Escribí Q+ = E·D + ¬E·Q como un multiplexor 2:1 y explicá qué entrada se elige cuando E = 0. Para D = Q = 1, ¿qué término mantiene la salida en 1 durante la transición de E?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 7?

Antes de avanzar, construí un latch D a partir de un latch SR, explicá por qué desaparece la combinación prohibida y describí qué ocurre si D cambia mientras el latch está abierto y cuando está cerrado. Si podés justificar las tres respuestas, ya podés armar tu primera memoria de un bit.

En el próximo tema pasamos al banco: el taller de memoria de un bit y antirrebote, donde montamos con puertas un latch y lo usamos para limpiar un pulsador.