Registros de almacenamiento

01 · Punto de partida

De un bit a una palabra

Hasta ahora cada flip-flop guardaba un bit, y vimos cómo capturarlo con exactitud: en un flanco, con tiempos de setup y hold respetados y con un estado inicial definido. Pero casi nada útil se resuelve con un bit. Una dirección, un resultado de suma, el valor leído por un conversor o el dato que se va a mostrar en un display son palabras de 4, 8, 16 o 32 bits. Un registro es, simplemente, un grupo de flip-flops D que comparten el reloj y capturan juntos.

Para un programador el registro es la analogía más directa del curso: es una variable. Tiene un tamaño fijo, conserva su valor hasta que se la asigna de nuevo y la asignación ocurre en un instante preciso. La diferencia es que en el hardware ese instante lo fija el flanco del reloj y que todos los registros del sistema se asignan al mismo tiempo, no uno detrás del otro.

02 · Estructura

El registro paralelo

La construcción es directa: un flip-flop D por bit, todos con el mismo reloj. La palabra de entrada D[n−1..0] llega a las entradas D; en cada flanco ascendente, cada flip-flop copia su bit; la palabra almacenada Q[n−1..0] aparece en las salidas. Entre flanco y flanco, los cambios en las entradas no tienen efecto.

El costo en componentes es lineal: un registro de 8 bits son 8 flip-flops. Por eso los fabricantes los encapsulan en conjunto: un solo chip de 20 patas contiene los ocho, con una única pata de reloj. Esa pata compartida es la clave del diseño: todos los bits capturan en el mismo instante, y la palabra almacenada nunca queda a medias, con algunos bits viejos y otros nuevos.

Almacenar no es pasar

Con un latch transparente (tema 6) la palabra de salida seguiría a la de entrada mientras la habilitación estuviera abierta; con el registro de flip-flops, la salida solo cambia en el flanco. Esta es la razón por la que los registros de los sistemas digitales se construyen con flip-flops: la salida es estable durante todo el ciclo y puede alimentar lógica combinacional, que a su vez alimenta a otro registro, sin que las señales se «atraviesen» de una etapa a otra.

03 · Control de carga

Cuándo carga: la habilitación

Un registro que captura en cada flanco no guarda nada: solo retrasa la entrada un ciclo. Para que sea memoria hace falta poder decir «ahora no cargues». Esa orden es la habilitación de carga (EN, enable, o clock enable, CE). Con EN = 1 el flanco carga D; con EN = 0 el flanco se ignora y el registro retiene Q.

La forma correcta: elegir entre D y Q

Delante de cada flip-flop se coloca un selector de dos entradas: si EN = 1 pasa el dato nuevo, si EN = 0 pasa la salida del propio flip-flop, de modo que en el flanco «se copia a sí mismo». Es la realimentación del tema 4 puesta al servicio de la retención:

En muchos chips, como el 74HC377, el selector está dentro del encapsulado y se ve desde afuera como una pata de habilitación; en las FPGA y los microcontroladores se llama clock enable. En todos los casos el reloj llega al flip-flop sin pasar por ninguna compuerta.

La forma que no hay que usar: cerrar el reloj

Parece más simple dejar el selector afuera y frenar el reloj: CLK_registro = CLK AND EN. Si EN vale 0, el reloj del registro queda en 0 y no hay flancos. Funciona mientras EN cambie únicamente cuando CLK está en bajo. Pero si EN cambia con CLK en alto, la compuerta fabrica un flanco falso que el flip-flop interpreta como un reloj legítimo:

En el instante 2 hay un flanco real con EN = 0: bien ignorado. En el 4, EN sube con el reloj en alto y la AND produce un flanco que no existe en el reloj; el registro captura lo que haya en D en ese instante, que puede ser cualquier cosa. En el 8 hay un flanco real con EN = 1 y carga correctamente. Con el selector en la entrada D, EN se muestrea únicamente en los flancos reales: en t = 4 el selector sigue en «retener» y la carga ocurre una sola vez, en t = 8.

04 · Estado inicial

Clear y estado inicial

Un registro recién energizado contiene basura, como cualquier variable sin inicializar. El tema 10 mostró la solución: un clear asíncrono que lleva todos los bits a 0 sin esperar al reloj. En un registro, el clear es una única pata común a todos los flip-flops, normalmente activa en bajo y llamada MR̅ (master reset) o CLR̅.

La primera fila manda sobre todas las demás. En la práctica hay tres formas de lidiar con el arranque, y conviene decidir cuál se aplica a cada registro:

• Con clear: el registro arranca siempre en cero (típico de los registros de estado y los contadores).
• Sin clear, con una carga inicial: el sistema escribe un valor antes de leerlo. Es lo habitual en un registro de datos, cuyo contenido carece de sentido hasta que se guarda algo.
• Sin ninguna de las dos: el dato es aleatorio hasta la primera carga; solo es válido si nadie lo lee antes.

05 · Salidas y buses

Salida de tres estados y buses

Cuando varios registros deben entregar su contenido a una misma línea de datos, no se pueden conectar las salidas entre sí: si un registro tiene un 1 y otro un 0, ambos quedan peleando por la misma línea y se produce una contención, con corrientes grandes, tensión indefinida y calor. La solución es una salida de tres estados (tri-state): además del 0 y el 1, puede adoptar un tercer estado, alta impedancia (Z), en el que la salida se comporta como si estuviera desconectada.

Dos hechos distinguen OE̅ de EN. Primero, OE̅ no modifica el dato: solo decide si se lo muestra. Segundo, actúa sobre las salidas, no sobre la captura: se puede cargar un registro con las salidas en Z, y se puede leer otro sin cargarlo. EN y OE̅ son controles independientes: uno gobierna la entrada y el otro la salida.

Con esta combinación se arma la estructura básica de toda computadora: varios registros conectados a un bus común. Cada uno tiene su EN (quién escucha en este ciclo) y su OE̅ (quién habla). Elegir cuál habla y cuál escucha es mover un dato de un registro a otro.

06 · Movimiento de datos

Transferencias entre registros

La operación elemental de un sistema digital es la transferencia: «copiar el contenido del registro B en el registro A». En hardware se escribe A ← B: se conectan las salidas Q de B a las entradas D de A y se habilita la carga de A. En el próximo flanco, A recibe lo que B tenía justo antes del flanco.

Todos a la vez

Como todos los flip-flops capturan en el mismo flanco, varias transferencias pueden ocurrir simultáneamente, y cada una usa los valores anteriores al flanco. Eso permite algo que en software cuesta una variable temporal: el intercambio. Con A ← B y B ← A en el mismo flanco, los valores se cruzan sin ayuda:

La razón es el tiempo de retención del tema 11: la salida Q de cada flip-flop cambia después del flanco (tiempo de propagación), mientras que las entradas D de los otros flip-flops se capturan en el flanco. Ese pequeño retraso es lo que permite que una cadena de registros funcione como una fila de variables que se actualizan a la vez. Es el mismo principio que luego, en el tema 14, convertirá un registro en uno de desplazamiento.

07 · Componentes

Registros reales de la familia 74HC

Los fabricantes ofrecen los registros más habituales ya encapsulados. Cada uno resuelve una combinación distinta de las ideas anteriores:

Fijate en que ninguno reúne todas las funciones: cada combinación se paga con pines. Un registro con habilitación y salidas de tres estados necesita un chip más (o un controlador). Una pauta práctica: 273 cuando se necesita un cero inicial, 377 cuando se quiere retener un dato entre cargas, 374 / 574 cuando el destino es un bus compartido.

No confundir 373 con 374

Los números parecen consecutivos y las funciones son muy distintas. El 74HC373 es un latch octal transparente (tema 6): sigue a la entrada mientras LE está en alto. El 74HC374 es un registro octal de flip-flops: captura en el flanco. Es una trampa clásica: la hoja de datos lo aclara en el título, y el símbolo lógico lo dice enseguida, porque el triángulo en la pata de reloj indica captura por flanco.

Para qué sirven en la práctica

• Puertos de salida: un 74HC273 o 74HC377 conectado al bus de un microcontrolador entrega 8 salidas estables a LED, relés o displays: se escribe el byte y los flip-flops lo mantienen.
• Captura de un dato fugaz: un 74HC374 congela el valor de un bus en el instante del flanco para analizarlo con calma.
• Etapas de una canalización (pipeline): un registro entre dos bloques de lógica divide el camino y permite subir la frecuencia de reloj.

08 · Tiempos

Tiempos del registro

Un registro de n bits está formado por n flip-flops, y cada uno cumple el setup y el hold del tema 11. Al agrupar aparecen dos consideraciones nuevas.

1. El camino más lento manda. El período mínimo del reloj está fijado por el bit cuyo camino de datos (propagación del flip-flop de origen + lógica + setup del destino) es el más largo. Un registro de 32 bits no limita la frecuencia por tener 32 bits, sino por el peor de sus caminos.
2. El reloj tiene que llegar a todos casi al mismo tiempo. Si el reloj llega al bit 7 más tarde que al bit 0 (clock skew), el bit 7 podría ver el dato nuevo en vez del viejo, es decir, violar el hold. En un solo chip el fabricante lo cuida; en una placa con un reloj repartido a varios chips, las pistas de reloj deben tener longitudes parecidas.

Por ejemplo, con t_pd = 12 ns, una lógica intermedia de 20 ns, un setup de 15 ns y un skew de 3 ns, el período mínimo es 50 ns, o sea 20 MHz como frecuencia máxima. Si el registro destino se conecta directamente a la salida del origen (sin lógica), el período mínimo baja a 30 ns, unos 33 MHz.

09 · El registro en código

Modelar, intercambiar y detectar fallas

Los bloques modelan un registro como una clase que cambia solo en el flanco, comparan la transferencia simultánea con la asignación secuencial, reproducen el flanco falso de una compuerta de reloj y simulan el bus con salidas de tres estados.

Paso 1: un registro de 8 bits con habilitación y clear

class Registro:
    """Registro de n bits: n flip-flops D con reloj común, habilitación y clear asíncrono."""

    def __init__(self, n=8):
        self.n = n
        self.q = 0

    def clear(self):
        self.q = 0                                   # CLR̅ = 0: actúa sin esperar al reloj

    def flanco(self, d, en=1):
        if en:                                       # EN = 1: D = entrada; EN = 0: D = Q (retiene)
            self.q = d & (2 ** self.n - 1)


r = Registro(8)
pasos = [("carga", 0xA5, 1), ("EN=0", 0x3C, 0), ("carga", 0x3C, 1), ("EN=0", 0xFF, 0)]
print("accion   D(entrada)  EN   Q(salida)")
for nombre, dato, en in pasos:
    r.flanco(dato, en)
    print(f"{nombre:7s}  {dato:08b}    {en}    {r.q:08b}  (0x{r.q:02X})")
r.clear()
print("clear    --------    -    ", f"{r.q:08b}")

Con EN = 1 el registro toma 0xA5 y luego 0x3C. Con EN = 0 ignora el dato de la entrada (0x3C y 0xFF) y conserva el valor previo. El clear lo deja en 00000000 sin necesidad de un flanco. Cambiá la lista pasos y predecí la columna Q antes de ejecutar.

Paso 2: transferencias simultáneas

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


A, B = Registro(0x12), Registro(0x34)

# Hardware: los dos registros capturan en el MISMO flanco; cada D vale lo que había ANTES.
dA, dB = B.q, A.q
A.q, B.q = dA, dB
print(f"intercambio con un reloj:  A = 0x{A.q:02X}  B = 0x{B.q:02X}")

# Software ingenuo: asignaciones una detrás de otra (el segundo lee el valor ya modificado).
A, B = Registro(0x12), Registro(0x34)
A.q = B.q
B.q = A.q
print(f"asignaciones en secuencia: A = 0x{A.q:02X}  B = 0x{B.q:02X}  (se perdió el 0x12)")

# Transferencia con habilitación individual desde un bus.
bus = 0x7E
A, B = Registro(0x00), Registro(0x00)
en_A, en_B = 1, 0
if en_A: A.q = bus
if en_B: B.q = bus
print(f"bus = 0x{bus:02X}, EN_A=1, EN_B=0 -> A = 0x{A.q:02X}  B = 0x{B.q:02X}")

El intercambio simultáneo deja A = 0x34 y B = 0x12. Las asignaciones en secuencia dejan A = B = 0x34: el valor original de A se pisó antes de leerlo. En la última prueba solo el registro con EN = 1 recibe el valor del bus (A = 0x7E); B conserva su 0x00.

Paso 3: el flanco falso de la compuerta de reloj

clk = [0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0]
en  = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0]       # EN sube en t = 4, con el reloj ya en alto


def flancos_ascendentes(señal):
    return [t for t in range(1, len(señal)) if señal[t - 1] == 0 and señal[t] == 1]


compuerta = [c & e for c, e in zip(clk, en)]      # reloj "cerrado" con una AND
print("t          ", *range(len(clk)))
print("CLK        ", *clk)
print("EN         ", *en)
print("CLK AND EN ", *compuerta)

con_and = flancos_ascendentes(compuerta)
cargas_mux = [t for t in flancos_ascendentes(clk) if en[t] == 1]   # EN se muestrea en cada flanco real
print("flancos con AND en el reloj:      t =", con_and, "->", len(con_and), "cargas")
print("flancos reales del reloj:         t =", flancos_ascendentes(clk))
print("cargas con EN en la entrada D:    t =", cargas_mux, "->", len(cargas_mux), "carga(s)")

El reloj tiene flancos reales en t = 2 y t = 8. Con la AND aparecen flancos en t = 4 y t = 8: el de t = 4 es falso y provoca una segunda carga no pedida. Con el selector en la entrada D, EN se mira solo en los flancos reales, y hay una única carga (t = 8). Mové la subida de EN en la lista en para ver cuándo la AND se porta bien.

Paso 4: un bus con salidas de tres estados

class Registro:
    def __init__(self, nombre, q):
        self.nombre, self.q, self.oe_n = nombre, q, 1     # OE̅ = 1: salida en alta impedancia


def bus(registros):
    activos = [r for r in registros if r.oe_n == 0]
    if not activos:
        return "Z (nadie maneja el bus)"
    valores = {r.q for r in activos}
    if len(valores) > 1:
        detalle = ", ".join(f"{r.nombre}=0x{r.q:02X}" for r in activos)
        return f"CONTENCIÓN ({detalle})"
    return f"0x{valores.pop():02X}"


R = [Registro("R1", 0x3A), Registro("R2", 0xC5), Registro("R3", 0x3A)]
casos = [("ninguno", []), ("solo R1", [0]), ("solo R2", [1]), ("R1 y R2", [0, 1]), ("R1 y R3", [0, 2])]
for nombre, activar in casos:
    for i, r in enumerate(R):
        r.oe_n = 0 if i in activar else 1
    print(f"{nombre:8s} -> bus = {bus(R)}")
print("los registros conservan:", *(f"{r.nombre}=0x{r.q:02X}" for r in R))

Sin ningún OE̅ activo el bus queda en Z. Con uno solo, el bus toma su valor. Con R1 y R2 activos a la vez hay contención porque sus datos difieren (0x3A y 0xC5). Con R1 y R3 también hay dos activos, pero con el mismo dato, así que el bus vale 0x3A: eléctricamente sigue siendo un mal diseño, aunque el valor coincida. En todos los casos los registros conservan su contenido.

Los tres últimos pasos expresan reglas de diseño: la habilitación va en D, los registros se actualizan juntos y un bus tiene un solo conductor por vez. Ninguna de ellas la hace cumplir el hardware: las asegura quien diseña.

10 · Exploración interactiva

El laboratorio: registro de 4 bits

El simulador reproduce un registro de cuatro flip-flops con habilitación, clear y salida de tres estados. Armás la palabra de entrada con los cuatro interruptores D, decidís si EN está en 1 o en 0, y mandás un pulso de reloj. Podés elegir cómo se implementa la habilitación (selector en D o AND en el reloj) y probar el pulso con EN tardío, que castiga la compuerta de reloj. El panel muestra el dato guardado, lo que aparece en los pines de salida y cuántas cargas falsas hubo.

Recorrido guiado

1. Con EN = 1, poné D = 1010 y presioná «Pulso de reloj»: Q pasa de 0000 a 1010. La carga paralela copia los cuatro bits a la vez.
2. Cambiá los interruptores a D = 0111 sin dar pulso: Q sigue en 1010. Entre flancos, la entrada no importa.
3. Desmarcá EN y pulsá: Q retiene 1010 aunque D valga 0111. Es la retención por habilitación.
4. Marcá OE̅ = 1: los pines pasan a «ZZZZ» y los LED se apagan, pero Q sigue siendo 1010. Desmarcá OE̅ y el dato vuelve a mostrarse: la salida de tres estados no borra nada.
5. Con OE̅ = 1 podés cargar otro dato y verlo recién cuando liberás las salidas: EN y OE̅ son independientes.
6. Presioná «Clear»: Q vuelve a 0000 sin ningún pulso de reloj.
7. Cargá D = 1111 con EN = 1. Elegí «AND en el reloj», poné D = 0001 y usá «Pulso con EN tardío»: el registro carga 0001 sin que haya habido un flanco real con EN = 1. Aparece una carga falsa.
8. Volvé a «Selector en D», repetí el mismo pulso tardío: Q no cambia. Con la habilitación en el dato, la compuerta no puede crear flancos.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de simular

1. Capacidad y componentes

Se quiere guardar una palabra de 12 bits. ¿Cuántos flip-flops D hacen falta y cuántos chips 74HC273 (8 bits) ocupan?

2. Seguir un registro

Un registro de 4 bits con EN arranca en 0000. En cuatro flancos sucesivos las entradas (D, EN) son: (1001, 1), (0110, 0), (0110, 1), (1111, 0). ¿Cuánto vale Q después de cada flanco?

3. Ecuación de un bit

Escribí la entrada D de un bit del registro con habilitación y calculala para EN = 0, Din = 1, Q = 0 y para EN = 1, Din = 1, Q = 0.

4. Elegir el chip

Para cada necesidad, elegí entre 74HC273, 74HC377 y 74HC574: (a) un puerto de salida que arranque apagado y se reescriba en cada ciclo; (b) un registro de datos que solo debe actualizarse cuando un controlador lo ordena; (c) un registro que se conecta a un bus de datos compartido con otros dispositivos.

5. Período mínimo

Entre dos registros hay una lógica combinacional de 18 ns. El flip-flop de origen tiene t_pd = 10 ns, el de destino exige un setup de 12 ns y el skew vale 2 ns. ¿Cuál es el período mínimo y la frecuencia máxima?

6. Diagnóstico

Un registro con habilitación implementada como CLK AND EN a veces guarda datos que nadie ordenó, y solo cuando el controlador cambia EN en la mitad alta del reloj. ¿Cuál es la causa y cuál es la corrección?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 14?

Antes de avanzar, explicá con tus palabras por qué la habilitación no debe cerrar el reloj, qué diferencia hay entre EN y OE̅ y por qué dos registros pueden intercambiar su contenido con un solo flanco. Si podés justificar las tres respuestas, ya podés pasar de cargar palabras en paralelo a moverlas bit a bit.

En el próximo tema veremos los registros de desplazamiento: cómo conectar la salida de cada flip-flop con la entrada del siguiente para que los bits viajen de a uno por flanco, y cómo convertir datos serie en paralelo y viceversa.