Decodificadores binarios

01 · Punto de partida

Cuatro chips, un bus

Un microprocesador tiene un bus de direcciones y quiere hablar con cuatro memorias que comparten los mismos cables de datos. Si todas respondieran a la vez, se pisarían (Tema 7). Hace falta un árbitro que, mirando la dirección, habilite una sola memoria por vez. Ese árbitro es un decodificador: recibe un número binario y activa exactamente una de sus líneas de salida.

• ¿Qué ecuación tiene cada salida de un decodificador y cómo está hecho por dentro?
• ¿Qué chips son (2 a 4, 3 a 8, 4 a 16, BCD a decimal) y qué hacen con los códigos inválidos?
• ¿Cómo se implementa una función cualquiera con un decodificador?
• ¿Qué es una decodificación parcial de direcciones y por qué crea «espejos»?
• ¿Cómo se evita que dos dispositivos se seleccionen a la vez?

02 · El concepto

De número a línea

Un decodificador de N entradas tiene 2^N salidas. Las entradas forman un número binario A; la salida de índice A es la única activa. Es lo mismo que el DEMUX del Tema 19 con el dato fijo: misma tabla, otro trabajo.

Estructura interna

Un inversor por cada entrada (para tener A y ~A) y un AND de N entradas por cada salida. Un 2:4 son 4 AND de dos entradas y 2 inversores; un 3:8, 8 AND de tres entradas y 3 inversores. Con enable, cada AND tiene una entrada más.

«Uno entre N» (one-hot)

La salida es una codificación en la que exactamente un bit vale 1 (o 0, si es activa en bajo). Es la forma más cómoda para habilitar dispositivos: no hay que interpretar nada, la línea activa es la dirección.

Lo opuesto: el codificador

Un codificador hace el camino inverso: de N líneas, una activa, saca el número binario (Tema 22). Decodificador y codificador son pares, como serializar y deserializar.

Predecodificar: cómo se hacen los decodificadores grandes

Un AND de 8 entradas para cada una de las 256 salidas sería lento y grande. Los decodificadores de las memorias lo resuelven en dos etapas: dos decodificadores chicos (de 4 bits cada uno, 16 líneas cada uno) y 256 AND de solo dos entradas, una por cada par de líneas. Se usan más puertas en total pero todas con pocas entradas, que es más rápido y compacto. Es la misma idea de armar un MUX grande con MUX chicos (Tema 18).

03 · Chips

138, 139, 154, 42 y compañía

Por qué activas en bajo

Herencia de la lógica TTL, y conveniencia: las señales de selección de chip (~CS) de casi todos los integrados son activas en bajo, así que la salida del decodificador va directa. Con salidas activas en alto (238, 4028) se necesitan inversores o se usan dispositivos activos en alto.

74HC42: el decodificador BCD

Cuatro entradas (D C B A, con D la más significativa) y diez salidas ~Y0 a ~Y9. Con los códigos inválidos 1010 a 1111 (Tema 5) ninguna salida se activa: todas valen 1. Es un decodificador con condiciones «no importa» resueltas como «todo apagado».

Las habilitaciones

Sirven para dos cosas: apagar el decodificador cuando no corresponde (por ejemplo, durante un ciclo de reloj) y para crecer combinando varios chips (Tema 19: 138 más 138 para 16 salidas).

04 · Generador de funciones

Un decodificador es una fábrica de minterms

Cada salida de un decodificador de N entradas vale 1 exactamente en un minterm de las N variables. Eso significa que cualquier función de esas variables es el OR de algunas de sus salidas: la suma de minterms del Tema 6, sin dibujar una sola puerta AND. Se conectan al OR las salidas cuyos números son los unos de la tabla de verdad.

Con salidas activas en bajo: una NAND

El 74HC138 entrega los minterms negados (~Y_i = ~m_i). Por De Morgan (Tema 14), el OR de minterms es la NAND de las líneas negadas:

Con A B C como entradas del 138 (A y B los sumandos, C el acarreo de entrada), el sumador completo del Tema 23 sale con dos chips: un 138 y un 74HC20. Ninguna ecuación minimizada, ningún mapa: solo se leen los unos de la tabla.

Elegir entre NAND de los unos y AND de los ceros

Hay un segundo camino con las mismas líneas negadas. Si la función tiene más unos que ceros, conviene tomar los ceros: F = ~(Σ minterms de los ceros) = AND(~Y de los ceros). Se elige el camino que usa menos líneas:

¿Cuándo conviene y cuándo no?

05 · Direcciones

Decodificación de direcciones y chip select

Cada dispositivo de un sistema con procesador ocupa un rango del mapa de memoria. El decodificador mira los bits altos de la dirección y genera la señal ~CS de cada uno; los bits bajos llegan directamente a los dispositivos para elegir una posición dentro de ellos.

Decodificación completa y parcial

Completa

Se usan todos los bits de dirección que el dispositivo no recibe directamente. Cada posición de cada dispositivo tiene una única dirección en el mapa.

Parcial

Se ignoran algunos bits altos para ahorrar puertas. El dispositivo responde entonces a varias direcciones: aparecen espejos (mirrors) del mismo contenido. Es válido y se usa mucho, siempre que no haya otro dispositivo en la zona espejada.

Espejos, un ejemplo

Una RAM de 4 KiB (12 líneas de dirección propias) seleccionada por A15 A14 A13 = 001 aparece en 0x2000 a 0x2FFF y también en 0x3000 a 0x3FFF, porque A12 no se decodifica. Si además se decodifica A12, solo aparece una vez.

06 · Aplicaciones

Secuenciadores y otras aplicaciones

Contador + decodificador = secuenciador

Un contador binario de 3 bits que cuenta de 0 a 7, conectado a un 74HC138, enciende un LED por vez y los recorre en orden: una luz que se desplaza (la «luz del auto fantástico»). Con un contador que sube y baja, va y vuelve. Es la base de un temporizador de pasos.

Contador de décadas

Un contador BCD (0 a 9) más un 74HC42 da diez líneas que se activan en secuencia: un contador con salida decimal «uno entre diez» (el 74HC4017 trae ambos en un chip). Con un contador de 4 bits que llegue hasta 15, las seis cuentas finales dejarían todas las líneas apagadas.

Selección de un multiplexor o un display

El decodificador elige qué dígito de un display (Tema 21) o qué canal analógico se activa en cada momento, a una velocidad que el ojo no percibe.

Barrido de un teclado matricial

Un decodificador activa una fila por vez; las columnas se leen y se sabe qué tecla se pulsó. Con un codificador (Tema 22) se hace el camino inverso.

Máquinas de estados «one-hot»

En el curso siguiente vas a representar el estado de un sistema con una línea por estado. El decodificador convierte una codificación binaria compacta en esa representación.

07 · Simulador

Laboratorio: funciones con un decodificador

El simulador conecta un decodificador de 2, 3 o 4 entradas con salidas activas en bajo (como el 74HC139, 138 y 154) y dos puertas que juntan las líneas que vos elijas, F1 y F2. Tocá los cuadrados de la tabla para conectar o desconectar cada línea a F1 (amarillo) o F2 (turquesa). El programa calcula el tipo de puerta, cuenta chips, compara con la suma de productos mínima y verifica cada dirección.

• Líneas ~Y: la activa (valor 0) se dibuja gruesa y amarilla. Es la dirección actual de las entradas.
• Cuadrados F1 y F2: una línea conectada a una función suma ese minterm a la función. El simulador decide solo si conviene una NAND de los unos o un AND de los ceros.
• Entradas: los botones de abajo fijan la dirección. La función vale 1 cuando la línea activa está conectada a ella.

Recorrido guiado (8 minutos)

1. 1
   Mirá el sumador completo (estado inicial).

   F1 está conectada a las líneas 1, 2, 4 y 7 (la suma) y F2 a la 3, 5, 6 y 7 (el acarreo). Cada una es una NAND de 4 líneas: un 74HC20 entero, más el decodificador. Probá las direcciones: con A B C = 011 baja la línea 3 y solo F2 vale 1.

2. 2
   Fijate en la línea 7.

   Está conectada a las dos funciones: un minterm compartido entre salidas. El decodificador lo genera una vez y sirve a las dos; con puertas separadas habría que construirlo dos veces.

3. 3
   Apretá «Al menos uno».

   Siete líneas conectadas a F1. El simulador cambia solo de camino: en lugar de una NAND de 7 entradas, usa el cero (la línea 0) y F1 sale directo de ~Y0, sin ninguna puerta. Es la regla de elegir el camino con menos líneas.

4. 4
   Apretá «XOR y XNOR de 2».

   Con dos entradas son dos NAND de dos líneas cada una. Compará con la columna de la derecha: una XOR con puertas también cuesta poco. Con 2 variables el decodificador no tiene ventaja.

5. 5
   Apretá «¿Primo? y BCD válido (4 bits)».

   Seis minterms para los primos y diez para los dígitos BCD. El primero usa una NAND de seis líneas; el segundo, un AND de los seis ceros (10 a 15). La suma de productos del BCD válido se simplifica muchísimo (A3 negada o A2 y A1 negadas), y se nota en la comparación.

6. 6
   Armá una función propia.

   Desconectá todo y tocá las líneas que quieras conectar a F1. El nombre de la función (si la reconoce) y el costo se actualizan al instante.

7. 7
   Conectá una sola línea.

   Si la línea elegida va a F1, la función es un minterm: una NAND de una entrada (un inversor). La función vale 1 solo cuando la dirección coincide. Es exactamente el detector de dirección del Tema 17.

8. 8
   Recorré todas las direcciones.

   Para cualquier función conectada, el estado dice «verificado»: la puerta devuelve 1 en las direcciones elegidas y 0 en las demás. Si conectaste dos funciones iguales, comparten puerta.

Preguntas para pensar

1. En el sumador completo, ¿qué líneas comparten F1 y F2 y qué ahorra eso?
2. ¿Por qué «al menos uno» no necesita puerta con un decodificador de salidas activas en bajo?
3. ¿Cuándo conviene un decodificador con puertas frente al mapa de Karnaugh?
4. ¿Qué pasa con la función si conectás todas las líneas a F1?

08 · Decodificar en código

Minterms, costos, BCD, mapas de memoria y secuenciadores

Los bloques implementan funciones con un decodificador (eligiendo NAND de unos o AND de ceros), comparan el costo de un decodificador directo y uno predecodificado, modelan el 74HC42 con los códigos inválidos, detectan solapamientos, huecos y espejos en mapas de memoria y generan la secuencia de un contador con decodificador.

Paso 1: una función con un decodificador activo en bajo

def decodificador(n, addr, en=True):
    # salidas activas en bajo, como el 74HC138 y sus parientes
    return [0 if (en and i == addr) else 1 for i in range(2 ** n)]


def realizar(n, unos, addr):
    ys = decodificador(n, addr)
    ceros = [i for i in range(2 ** n) if i not in unos]
    if len(unos) <= len(ceros):
        return 1 - int(all(ys[i] for i in unos)), f"NAND de {len(unos)} líneas"
    return int(all(ys[i] for i in ceros)), f"AND de {len(ceros)} líneas"


CASOS = {
    "suma (paridad de 3)":  (3, [1, 2, 4, 7]),
    "acarreo (mayoría)":    (3, [3, 5, 6, 7]),
    "exactamente dos":      (3, [3, 5, 6]),
    "al menos uno":         (3, [1, 2, 3, 4, 5, 6, 7]),
    "un solo minterm (5)":  (3, [5]),
    "números primos":       (4, [2, 3, 5, 7, 11, 13]),
    "dígito BCD válido":    (4, list(range(10))),
}
for nombre, (n, unos) in CASOS.items():
    ok = True
    for a in range(2 ** n):
        f, metodo = realizar(n, unos, a)
        if f != int(a in unos):
            ok = False
    print(f"{nombre:<22} {metodo:<18} {'ok' if ok else 'FALLA'}")

La suma y el acarreo usan una NAND de 4 líneas; «al menos uno» y el BCD válido usan el camino de los ceros (1 línea y 6 líneas); un solo minterm es una NAND de 1 línea (un inversor). Todas verifican en todas las direcciones.

Paso 2: decodificador directo frente a predecodificado

def directo(n):
    return {"AND": 2 ** n, "entradas por AND": n, "inversores": n}


def predecodificado(n):
    a, b = n // 2, n - n // 2
    sub = (2 ** a) + (2 ** b)                       # AND de los dos subdecodificadores
    return {"AND": sub + 2 ** n, "entradas por AND": max(a, b, 2), "inversores": a + b}


print(" n  salidas   directo (AND / fan-in)   predecodificado (AND / fan-in)")
for n in range(2, 9):
    d, p = directo(n), predecodificado(n)
    print(f"{n:>2}  {2 ** n:>7}   {d['AND']:>6} / {d['entradas por AND']}              "
          f"{p['AND']:>6} / {p['entradas por AND']}")

El predecodificado usa un poco más de puertas en total, pero con entre 2 y 4 entradas cada una en lugar de n: por eso lo usan las memorias, donde la rapidez y el tamaño de cada puerta importan más que el conteo.

Paso 3: el 74HC42 y los códigos inválidos

def hc42(d, c, b, a):
    n = 8 * d + 4 * c + 2 * b + a
    return [0 if i == n else 1 for i in range(10)]      # fuera de 0..9 queda todo en 1


print("código  DCBA   línea activa")
invalidos_ok = True
for n in range(16):
    d, c, b, a = (n >> 3) & 1, (n >> 2) & 1, (n >> 1) & 1, n & 1
    ys = hc42(d, c, b, a)
    linea = ys.index(0) if 0 in ys else None
    print(f"  {n:>2}    {d}{c}{b}{a}   {'~Y' + str(linea) if linea is not None else 'ninguna (código inválido)'}")
    # detector de código inválido: A3·(A2 + A1) es 1 justo cuando no hay línea activa
    invalido = d & (c | b)
    if invalido != int(linea is None):
        invalidos_ok = False
print("detector A3·(A2+A1) coincide con «ninguna línea activa»:", invalidos_ok)

Del 0 al 9 se activa una línea; del 10 al 15 ninguna. El detector de códigos inválidos A3·(A2 + A1) (el mapa de Karnaugh de «mayor que 9») coincide con «todas las salidas en 1», con apenas dos puertas.

Paso 4: mapas de memoria: solapamientos, huecos y espejos

def seleccionados(addr, dispositivos):
    return [nombre for nombre, (mascara, valor) in dispositivos.items() if (addr & mascara) == valor]


def analizar(titulo, dispositivos):
    contencion = huecos = 0
    ejemplo = None
    for addr in range(0x10000):
        k = len(seleccionados(addr, dispositivos))
        if k > 1:
            contencion += 1
            if ejemplo is None:
                ejemplo = addr
        elif k == 0:
            huecos += 1
    print(f"{titulo}: contención en {contencion} direcciones" + (f" (primera 0x{ejemplo:04X})" if ejemplo is not None else "")
          + f", huecos en {huecos}")


bien = {"ROM": (0x8000, 0x0000), "RAM": (0xC000, 0x8000), "E/S": (0xC000, 0xC000)}
mal = {"ROM": (0x8000, 0x0000), "RAM": (0x4000, 0x4000), "E/S": (0xC000, 0xC000)}
analizar("diseño correcto", bien)
analizar("diseño con RAM mal decodificada", mal)


def espejos(mascara, valor, bits_chip):
    paso = 2 ** bits_chip
    return [a for a in range(0x10000) if (a & mascara) == valor and a % paso == 0]


print()
print("RAM de 4 KiB, A15..A13 = 001 (decodificación parcial):", [f"0x{a:04X}" for a in espejos(0xE000, 0x2000, 12)])
print("RAM de 4 KiB, A15..A12 = 0010 (decodificación completa):", [f"0x{a:04X}" for a in espejos(0xF000, 0x2000, 12)])

En el diseño correcto no hay contención ni huecos. Con la RAM decodificada solo por A14 se solapa con la ROM y con el puerto de E/S: dos dispositivos a la vez en miles de direcciones. Y decodificar A15 a A13 para un chip de 4 KiB lo duplica (espejo) en 0x2000 y 0x3000.

Paso 5: contador más decodificador = secuenciador

def una_linea(n, addr):
    return [1 if i == addr else 0 for i in range(2 ** n)]


print("barrido ascendente (contador de 3 bits + 74HC138):")
for t in range(10):
    print(f"  t={t:>2} contador={t % 8:03b}  " + "".join("●" if x else "○" for x in una_linea(3, t % 8)))

print()
print("ida y vuelta (contador ascendente/descendente):")
secuencia = list(range(8)) + list(range(6, 0, -1))
for t, pos in enumerate(secuencia):
    print(f"  t={t:>2} posición={pos}  " + "".join("●" if x else "○" for x in una_linea(3, pos)))

En cada paso del contador se enciende una sola luz, la de su índice. Con un contador ascendente-descendente la luz va y vuelve. Con un 74HC42 y un contador de 4 bits (que cuenta hasta 15) las seis últimas cuentas dejarían todo apagado.

09 · Analogía de programador

Router de direcciones

1. 1
   Decodificador = router por prefijo.

   Un prefijo de dirección elige un puerto, sin intervención de la CPU. Es ruteo hecho de puertas.

2. 2
   Chip select = mutex.

   Un solo hablante en el bus de datos: el decodificador reparte la palabra y garantiza que nadie más la tenga.

3. 3
   BCD inválido = 404.

   Una dirección que no existe y nadie atiende. Decidir qué pasa en esos casos (apagar todo, señalar un error) es parte del diseño.

Una diferencia con el software: en un router los destinos pueden solaparse y se resuelve con prioridades; en el hardware, un solapamiento en el bus se resuelve con humo. El decodificador no tiene prioridad ni memoria: su única garantía es «una sola activa», y es responsabilidad del diseñador que el mapa no se pise.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de decodificación

Ejercicio 1: el sumador completo con un 74HC138

Implementá la suma Σm(1, 2, 4, 7) y el acarreo Σm(3, 5, 6, 7) con un 74HC138 y puertas NAND. ¿Qué chips usás y cuántos?

Ejercicio 2: «al menos uno»

Con un 74HC138, ¿cómo se obtiene F = 1 cuando alguna de las tres entradas vale 1, sin usar ninguna puerta?

Ejercicio 3: dígito BCD válido

Detectá con puertas que un código de 4 bits es un dígito BCD válido (0 a 9). Comparalo con usar un 74HC42 más una puerta que junte sus diez salidas.

Ejercicio 4: espejos

Una RAM de 2 KiB (11 líneas de dirección propias) se selecciona con A15 A14 A13 = 010 en un 74HC138. ¿Cuántas copias aparecen y dónde empiezan?

Ejercicio 5: contención

La ROM se selecciona con A15 = 0 y la RAM con A14 = 1 (sin mirar A15). ¿Qué direcciones activan a los dos? ¿Cómo se corrige?

Ejercicio 6: el secuenciador de 10 pasos

Un contador binario de 4 bits (0 a 15) maneja un 74HC42 que enciende diez LED en secuencia. ¿Cuántos pasos de los 16 quedan con todos los LED apagados? ¿Cómo se evita?

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 21?

Podés avanzar si sos capaz de responder esto sin mirar:

• Escribir la ecuación de cada salida de un decodificador 2 a 4.
• Armar con un 74HC138 y una NAND una función de tres variables a partir de sus minterms.
• Decir qué salida baja con A15 A14 A13 = 011 y qué rango de direcciones cubre.
• Explicar qué es un espejo y cuándo aparece.
• Decir qué hace un 74HC42 con el código 1100.
• Elegir entre un decodificador con puertas y un mapa de Karnaugh para una función dada.

Ya podés convertir números en líneas. Falta mostrar los números a una persona: en el próximo tema, display de 7 segmentos, donde un decodificador (con siete funciones lógicas) transforma un dígito BCD en los segmentos que hay que encender.