Demultiplexores

01 · Punto de partida

Una alarma, cuatro zonas

Un sistema de seguridad tiene una sola señal de alarma y cuatro sirenas, una por zona. Cuando salta la alarma, debe sonar solo la sirena de la zona afectada; las demás, calladas. Hay un dato (la alarma) y un selector (la zona), y de las cuatro salidas debe responder exactamente una. Eso es un demultiplexor (DEMUX): una entrada, N salidas, el selector abre una sola «puerta».

• ¿Qué vale cada salida de un DEMUX, y cómo se relaciona con un MUX?
• ¿Por qué el 74HC139 y el 74HC138 «hablan al revés» (salidas activas en bajo)?
• ¿En qué se diferencia un DEMUX de un decodificador?
• ¿Cómo se agranda de 1:4 a 1:8 y 1:16?
• ¿Cuándo un demultiplexor no es seguro de usar?

02 · DEMUX 1:N

Una puerta abierta

En su forma más simple (lógica positiva, la que se usa para entender), un DEMUX 1:4 tiene un dato D, dos selectores S1 y S0 y cuatro salidas. La salida elegida copia al dato; las demás valen 0:

Cada salida es un AND del dato con el minterm del selector que le corresponde: un DEMUX 1:4 son cuatro AND de tres entradas y dos inversores. Los símbolos son un trapecio al revés del MUX: angosto del lado de la entrada y ancho del lado de las salidas.

Una salida activa por vez

En todo momento hay a lo sumo una salida distinta de 0. Si el dato vale 0, ninguna. Esa propiedad (a veces llamada «uno entre N» o one-hot) es lo que hace útil al DEMUX para habilitar un dispositivo a la vez.

El inverso del MUX

Si un MUX junta N entradas en una salida usando un índice, el DEMUX hace el camino inverso con el mismo índice. Si ponés los dos en serie con el mismo selector, la señal de una entrada llega a la salida correspondiente a través de un solo cable: es la base de la transmisión por división de tiempo (sección 06).

El dato puede ser una señal

Si el dato cambia en el tiempo (un reloj, un pulso, un nivel), cada salida copia al dato mientras está seleccionada y vale 0 el resto del tiempo. El DEMUX es un reparto instantáneo, sin memoria.

03 · Chips

74HC139 y 74HC138: el que habla al revés

Los demultiplexores comerciales de la serie 74HC son en realidad decodificadores/demultiplexores, y todos tienen las salidas activas en bajo: la salida seleccionada da 0 y las demás 1. También la habilitación es activa en bajo. Es una herencia de la lógica TTL, y se mantiene por compatibilidad; además, es muy práctica para controlar señales de selección de chips (~CS), que son activas en bajo.

¿Dónde entra el dato?

En la entrada de habilitación ~E. Con ~E = 0 la salida elegida baja a 0; con ~E = 1 todas están en 1. Por lo tanto la salida elegida copia el nivel de ~E (sin invertirlo) y las demás quedan en 1. Es un DEMUX en lógica negativa: dato «activo» = nivel bajo.

Salidas en bajo y LED

Para ver una salida activa en bajo se conecta el LED entre VCC y la salida, con su resistencia: cuando la salida baja a 0 circula corriente y el LED enciende. Las salidas HC son simétricas (dan y reciben unos 4 mA), así que sirve cualquiera de los dos montajes; el de VCC es la convención histórica.

74HC138: el 3 a 8

Tres entradas de selección (A, B, C, con C la más significativa), ocho salidas ~Y0 a ~Y7 y tres entradas de habilitación: G1 (activa en alto), ~G2A y ~G2B (activas en bajo). Para que el chip esté habilitado hace falta G1 = 1 y las otras dos en 0. Esa combinación de polaridades permite armar decodificadores grandes sin compuertas extra.

Variantes

El 74HC238 es el 3 a 8 con salidas activas en alto; el 74HC154 es un 4 a 16; el 74HC4051 es un multiplexor/demultiplexor analógico de 8 canales (Tema 18).

04 · DEMUX y decodificador

Gemelos con distinto trabajo

Entrada «uno entre N»

Un decodificador convierte un número binario (log₂ N bits) en N líneas, de las cuales exactamente una está activa. Se llama codificación uno entre N (one-hot) y es la más cómoda para habilitar dispositivos.

El enable no es un reloj

Un reloj tiene flancos que significan «ahora»; el enable de un decodificador es un nivel que significa «mientras». No hay memoria ni sincronismo acá: los flip-flops y los relojes llegan en el curso siguiente.

05 · Crecer

De 1:4 a 1:16

Los demultiplexores grandes se arman con otros más chicos. La clave son las entradas de habilitación: se usan para decidir qué chip responde, mientras que las entradas de selección eligen qué salida dentro de ese chip.

1:16 con dos 74HC138

Las tres entradas bajas de dirección (A, B, C) van a los dos chips en paralelo. La cuarta (S3) decide cuál chip se habilita: el primero con S3 = 0, el segundo con S3 = 1. Para eso se aprovechan las polaridades de las habilitaciones: S3 va a ~G2A del primero (habilitado con S3 = 0) y a G1 del segundo (habilitado con S3 = 1), y no hace falta ningún inversor.

06 · Aplicaciones

Para qué se usa un demultiplexor

Decodificación de direcciones

En un sistema con microprocesador, los bits altos de la dirección eligen el chip: memoria, periféricos, puertos. Con un 74HC138 y tres bits (A15, A14, A13) se divide el espacio de 64 KiB en ocho regiones de 8 KiB, cada una con su propia señal ~CS. Es el uso más extendido del decodificador/demultiplexor.

Controlar muchos dispositivos con pocos pines

Tres pines de un microcontrolador y un 138 habilitan ocho dispositivos, uno por vez. Con un 154 serían dieciséis con cuatro pines.

Multiplexado de displays

Para mostrar cuatro dígitos con un solo decodificador de 7 segmentos, un DEMUX activa el dígito correspondiente mientras un MUX (o el micro) pone los segmentos de ese dígito. Se recorren a gran velocidad y el ojo ve todos encendidos (Tema 21).

Distribuir un dato o un pulso

Enviar un pulso a una de varias zonas: una señal de disparo, un reloj de prueba, un comando. Cada salida solo ve el pulso cuando está seleccionada.

Enlace por división de tiempo (TDM)

Un MUX en un extremo, un DEMUX en el otro y un contador sincronizado que maneja los dos selectores: un solo cable transporta N canales, uno por vez, cada uno en su «ranura» de tiempo. Es la idea detrás de buses serie, telefonía digital y muchos instrumentos.

07 · Simulador

Laboratorio: repartir y compartir

El simulador tiene dos modos. En Reparto manejás un demultiplexor de 4 u 8 salidas, en lógica positiva (didáctica) o en la del 74HC139/138 (salidas activas en bajo, dato en la habilitación), y mirás los LED. En Enlace por tiempo conectás un MUX, un cable único y un DEMUX con un contador compartido y mirás cómo cuatro canales viajan por un solo cable, cada uno en su turno.

• Reparto: el trapecio reparte el dato; la salida seleccionada se resalta. Un LED circular muestra cuáles salidas están «activas» según la polaridad elegida.
• Enlace por tiempo: cada «Paso de reloj» avanza el contador. La salida seleccionada copia el cable, y su registro retiene el valor hasta la próxima vuelta.
• Resultados: las tarjetas cambian de contenido con el modo.

Recorrido guiado (8 minutos)

1. 1
   Empezá en Reparto 1:4, activo en alto.

   Con E = 1 y S = 01 se enciende solo Y1; las otras tres valen 0. Recorré los selectores con los botones: el 1 «viaja» de salida en salida. Poné E = 0: todo apagado, el enable es el interruptor maestro.

2. 2
   Pasá a «74HC139/138 (activo en bajo)».

   Ahora los LED encienden con un 0. El botón de dato pasa a llamarse «dato en ~E»: con ~E = 0 la salida elegida baja a 0 y su LED enciende; con ~E = 1 todas valen 1 y ninguno enciende. Fijate que la salida elegida copia el nivel de ~E.

3. 3
   Cambiá a 1:8.

   Tres selectores y ocho salidas: es el 74HC138. El selector más significativo (S2) separa las salidas 0 a 3 de las 4 a 7. Con «Siguiente salida» recorrés las ocho.

4. 4
   Dejá el dato fijo habilitado y usá los selectores como un número.

   Eso es un decodificador: el número binario S2 S1 S0 enciende exactamente un LED. Es el tema siguiente.

5. 5
   Pasá a «Enlace por tiempo».

   Hay cuatro canales de un bit (D0 a D3), un MUX, un cable y un DEMUX con el mismo contador. Apretá «Paso de reloj» cuatro veces: cada salida recibe el canal que le toca y lo retiene. En total viajaron cuatro datos por un solo cable.

6. 6
   Cambiá un canal después de que ya fue entregado.

   El receptor sigue mostrando el valor viejo hasta que el contador vuelva a esa ranura. En un enlace por división de tiempo, la información llega con un retraso de hasta una vuelta completa.

7. 7
   Contá los cables.

   En lugar de cuatro cables de datos, hay uno, más los dos de selección compartidos entre los dos extremos. Es una ganancia, siempre que los dos contadores estén sincronizados.

8. 8
   Apretá «Ciclo completo» varias veces.

   Los registros se actualizan en orden 0, 1, 2, 3 una y otra vez. La frecuencia del cable es cuatro veces la de cada canal: esa es la regla de la tabla de la sección 06.

Preguntas para pensar

1. En el modo activo en alto, apagá E. ¿Qué valen las salidas? ¿Qué papel cumple E?
2. Con el 74HC139 (activo en bajo), ¿qué valor tiene la salida elegida si ~E = 1? ¿Y si ~E = 0?
3. En el enlace por tiempo, ¿cuántas veces por segundo se actualiza cada canal si el reloj corre a 8 kHz y hay 4 canales?
4. Si un canal cambia 100 veces por segundo, ¿alcanza con un reloj de 4 kHz con 4 canales?

08 · Reparto en código

Demultiplexores, decodificadores y glitches

Los bloques verifican las propiedades del DEMUX, modelan el 74HC138 con sus tres habilitaciones, arman 16 salidas con dos chips, simulan un enlace por división de tiempo, decodifican un mapa de memoria y reproducen los glitches de un decodificador cuando cambian varias líneas de dirección.

Paso 1: el DEMUX, su propiedad «una entre N» y su relación con el MUX

def demux(d, s, n):
    ys = [0] * n
    ys[s] = d
    return ys


def mux(ds, s):
    return ds[s]


for n in (2, 4, 8):
    una = all(sum(demux(1, s, n)) == 1 and demux(1, s, n)[s] == 1 for s in range(n))
    apagado = all(sum(demux(0, s, n)) == 0 for s in range(n))
    print(f"1:{n}: con dato=1 hay una sola salida activa: {una};  con dato=0 todo apagado: {apagado}")

print("mux(demux(d, s), s) == d:", all(mux(demux(d, s, 4), s) == d for d in (0, 1) for s in range(4)))
print("decodificador = demux con dato fijo en 1:")
for s in range(4):
    print(f"   S={s:02b} -> {demux(1, s, 4)}")

Con el dato en 1 solo la salida elegida vale 1; con el dato en 0, ninguna. Y un MUX puesto a continuación de un DEMUX con el mismo selector devuelve el dato original. Con el dato fijo en 1 se obtiene la tabla de un decodificador.

Paso 2: el 74HC138 y la cascada a 16 salidas

def hc138(a, b, c, g1=1, g2a_n=0, g2b_n=0):
    ys = [1] * 8                                  # salidas activas en bajo: reposo = 1
    if g1 == 1 and g2a_n == 0 and g2b_n == 0:
        ys[4 * c + 2 * b + a] = 0                 # C es el bit más significativo
    return ys


def bits(s):
    return s & 1, (s >> 1) & 1, (s >> 2) & 1


# dato en ~G2A: la salida elegida COPIA el dato
ok_copia = all(hc138(*bits(s), g1=1, g2a_n=d, g2b_n=0) == [d if i == s else 1 for i in range(8)]
               for s in range(8) for d in (0, 1))
# dato en G1: la salida elegida da el dato INVERTIDO
ok_inv = all(hc138(*bits(s), g1=d, g2a_n=0, g2b_n=0) == [1 - d if i == s else 1 for i in range(8)]
             for s in range(8) for d in (0, 1))
print("dato en ~G2A (copia):", ok_copia, "  dato en G1 (invierte):", ok_inv)


def demux16(s, d):
    s3, bajo = s >> 3, s & 7
    a, b, c = bits(bajo)
    primero = hc138(a, b, c, g1=1, g2a_n=s3, g2b_n=d)      # habilitado con S3 = 0
    segundo = hc138(a, b, c, g1=s3, g2a_n=0, g2b_n=d)      # habilitado con S3 = 1
    return primero + segundo


ok16 = all(demux16(s, d) == [d if i == s else 1 for i in range(16)] for s in range(16) for d in (0, 1))
print("1:16 con dos 74HC138, sin compuertas extra:", ok16)
print("ejemplo S=1010 dato=0 :", demux16(0b1010, 0))

Con el dato en ~G2A la salida elegida copia el dato; con el dato en G1 lo invierte. Las polaridades distintas de las habilitaciones (G1 activa en alto, las otras en bajo) permiten armar 16 salidas con dos chips y sin compuertas. En el ejemplo, S = 1010 pone un 0 en la salida 10.

Paso 3: un enlace por división de tiempo

def tdm(canales, vueltas, n=4):
    retenido = [None] * n
    for t in range(vueltas * n):
        s = t % n                          # un contador compartido maneja MUX y DEMUX
        cable = canales(t)[s]              # el MUX pone en el único cable el canal s
        retenido[s] = cable                # el DEMUX lo entrega a la salida s, que lo retiene
        print(f"t={t:>2} ranura={s}  cable={cable}  recibido={['-' if x is None else x for x in retenido]}")


# los canales cambian con el tiempo
canales = lambda t: [(t // 4) % 2, 1, (t // 8) % 2, 0]
tdm(canales, 3)

print()
print("   N  ancho de banda  reloj mínimo (2·N·B)")
for n, B in ((4, 500), (8, 500), (8, 20_000), (32, 4_000)):
    print(f"{n:>4}  {B:>10} Hz  {2 * n * B:>10,} Hz")

Cada salida recibe su canal una vez por vuelta y lo retiene. El canal 0, que cambia en cada vuelta, se ve actualizado con hasta cuatro pasos de retraso; los canales constantes ya no cambian. El reloj debe ser al menos 2·N·B para no perder información.

Paso 4: decodificar un mapa de memoria con un 74HC138

def hc138(a, b, c, g1=1, g2a_n=0, g2b_n=0):
    ys = [1] * 8
    if g1 == 1 and g2a_n == 0 and g2b_n == 0:
        ys[4 * c + 2 * b + a] = 0
    return ys


def region(addr):
    c, b, a = (addr >> 15) & 1, (addr >> 14) & 1, (addr >> 13) & 1      # A15 A14 A13
    ys = hc138(a, b, c)
    return ys.index(0)


for addr in (0x0000, 0x1FFF, 0x2000, 0x7FFF, 0xA123, 0xE000, 0xFFFF):
    y = region(addr)
    print(f"0x{addr:04X}  A15..A13 = {addr >> 13:03b}  ->  ~Y{y} activa  (región 0x{y * 0x2000:04X}..0x{(y + 1) * 0x2000 - 1:04X})")

Tres bits de dirección dividen los 64 KiB en ocho regiones de 8 KiB. 0xA123 cae en la región 5 (0xA000 a 0xBFFF): su ~Y5 baja y habilita el chip conectado a esa salida. Es el mapa de memoria de casi cualquier computadora simple.

Paso 5: glitches de un decodificador y cómo evitarlos

from itertools import permutations


def transitorios(desde, hasta, n=3):
    cambia = [i for i in range(n) if ((desde >> i) & 1) != ((hasta >> i) & 1)]
    res = {}
    for orden in permutations(cambia):
        estado, pasos = desde, []
        for i in orden[:-1]:
            estado ^= (1 << i)
            pasos.append(estado)
        res[orden] = pasos
    return res


for d, h in ((0b011, 0b100), (0b011, 0b010)):
    print(f"cambio {d:03b} -> {h:03b}")
    for orden, pasos in transitorios(d, h).items():
        print(f"   si cambian los bits en orden {orden}: pasa por {[format(p, '03b') for p in pasos]}  "
              f"-> salidas activadas por error: {[f'Y{p}' for p in pasos]}")


def gray(i):
    return i ^ (i >> 1)


print()
print("bits que cambian por paso, contador binario:", [bin(i ^ ((i + 1) % 8)).count("1") for i in range(8)])
print("bits que cambian por paso, contador Gray:   ", [bin(gray(i) ^ gray((i + 1) % 8)).count("1") for i in range(8)])

Al pasar de 011 a 100 cambian los tres bits: según el orden en que lleguen, el decodificador activa por unos nanosegundos dos salidas equivocadas. De 011 a 010 cambia un solo bit y no hay transitorios. Con un contador Gray cada paso cambia exactamente un bit, incluida la vuelta, y la decodificación queda limpia.

09 · Analogía de programador

Dispatch, ruteo y mapa de memoria

1. 1
   DEMUX = dispatch.

   Un evento a un manejador según un índice. Los demás ni se enteran, igual que en un arreglo de funciones.

2. 2
   Activo en bajo = lógica negativa.

   Como los códigos de retorno donde 0 es éxito: se lee con cuidado y se documenta. La bolita en el esquema equivale al nombre claro de una variable.

3. 3
   Enable = feature flag.

   Todo apagado hasta habilitar: un despliegue por etapas, hecho en silicio.

Una diferencia con el software: un despachador de software atiende un evento, cambia de estado y recién entonces atiende el siguiente; el hardware cambia de «índice» con transiciones físicas que pueden ser imperfectas. El glitch del decodificador no tiene equivalente exacto en código: es como si una variable pasara brevemente por un valor intermedio que nadie escribió.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de reparto

Ejercicio 1: alarma por zonas

La alarma E (activa en bajo) debe encender el LED de la zona S1S0. Conectá un 74HC139 y calculá la resistencia de los LED para unos 4 mA a 5 V (LED con 2 V de caída).

Ejercicio 2: 1:8 con un 74HC138

Conectá el 138 como DEMUX 1:8 no inversor con el dato en ~G2A. ¿Qué valen las ocho salidas con S = 101 y dato = 0? ¿Y con dato = 1?

Ejercicio 3: 16 salidas con dos chips

Indicá cómo se conectan G1, ~G2A y ~G2B en cada uno de los dos 74HC138 para que S3 elija el chip, y qué salida baja con S3S2S1S0 = 1101 y dato = 0.

Ejercicio 4: mapa de memoria

Un 74HC138 recibe A15, A14, A13. ¿Qué salida baja con la dirección 0xA123? ¿Qué rango de direcciones habilita cada salida y de qué tamaño es?

Ejercicio 5: división de tiempo

Cuatro canales de 1 kHz de ancho de banda cada uno viajan por un solo cable con MUX y DEMUX. ¿Qué frecuencia mínima debe tener el reloj? ¿Cuántos cables hay frente a la versión sin multiplexar?

Ejercicio 6: el glitch de 011 a 100

Un contador pasa de 011 a 100 y maneja un decodificador. Enumerá las salidas que pueden activarse por error según el orden en que cambien los bits, y proponé dos soluciones.

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 20?

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

• Escribir la ecuación de cada salida de un DEMUX 1:4.
• Decir qué valor tiene la salida elegida de un 74HC139 con ~E = 0 y con ~E = 1.
• Conectar un 74HC138 como DEMUX 1:8 y como decodificador.
• Armar 16 salidas con dos 138 indicando las habilitaciones.
• Decir qué salida del 138 baja con A15 A14 A13 = 110.
• Explicar por qué la salida de un decodificador no se usa como reloj sin cuidado.

Un demultiplexor reparte un dato; si el dato se fija y lo que importa es el número de selección, tenés un decodificador. En el próximo tema lo exploramos a fondo: decodificadores binarios.