Multiplexores

01 · Punto de partida

Manual o automático, por cable

Un termostato tiene una consigna que puede venir de un potenciómetro (manual) o de un programa horario (automático). Un interruptor decide cuál de las dos manda. Eso es un multiplexor (MUX): varias entradas de datos, unas pocas entradas de selección, y una única salida que copia la entrada elegida. Con N entradas de datos hacen falta log₂ N líneas de selección.

• ¿Qué ecuación tiene un MUX 2:1, y de dónde sale?
• ¿Qué chips son el 4:1 y el 8:1, y cómo se crece más?
• ¿Cómo se implementa una función cualquiera con un MUX?
• ¿Qué hace la entrada enable?
• ¿Qué problema aparece al cambiar el selector?

02 · MUX 2:1

El if con patas

El multiplexor más simple tiene dos datos (D0 y D1), un selector S y una salida Y. Si S = 0 la salida es D0; si S = 1 es D1. El símbolo es un trapecio: ancho del lado de las entradas, angosto del lado de la salida.

De dónde sale la ecuación

Es la expansión de Shannon del Tema 13: f = S·f(S=1) + ~S·f(S=0). Cualquier función se puede partir según una de sus variables en dos funciones más simples, y un MUX 2:1 las junta. Por eso el MUX es la pieza natural para construir funciones.

Con puertas

Un inversor, dos AND y un OR: 4 puertas. Con NAND (Tema 14): 3 NAND de dos entradas más un inversor (que también es una NAND): 4 NAND. Es un circuito de tres niveles de retardo.

Chip

El 74HC157 trae cuatro MUX 2:1 con un selector común y una entrada de habilitación (strobe), pensado para elegir entre dos grupos de 4 bits a la vez. Existe también el 74HC158, que invierte la salida.

Enable (habilitación)

Una entrada extra que apaga el bloque. En el 157 la entrada de strobe es activa en bajo: con ella en 1, las salidas quedan en 0 sin importar los datos. Sirve para combinar varios MUX (sección 04) y, como toda entrada, no se deja al aire.

03 · 4:1 y 8:1

Más datos, más selectores

Con dos selectores se elige entre cuatro datos; con tres, entre ocho. Los selectores forman un número binario que es el índice de la entrada elegida, igual que el índice de un arreglo:

04 · Crecer

Expansión y enable

Un MUX más grande se arma con MUX más chicos, de dos maneras.

En árbol de 2:1

Un 4:1 son tres 2:1 (dos en la primera capa, comparten S0, y uno en la segunda, con S1). Un 8:1 son siete 2:1 en tres capas. En general un MUX de N entradas son N − 1 multiplexores 2:1 y log₂ N niveles.

Con el enable

Para pasar de 8 a 16 entradas se usan dos 74HC151. El selector más significativo (S3) habilita uno u otro: ~E1 = S3 y ~E2 = ~S3. Cuando un 151 está deshabilitado su salida Y vale 0, así que alcanza con un OR para juntar las dos salidas: Y = Y1 + Y2.

Con salida tri-estado

Los 74HC251 tienen salida de tres estados (Tema 7): cuando están deshabilitados quedan en alta impedancia y se pueden unir las salidas directamente al mismo cable, sin la compuerta OR.

05 · Funciones

El MUX como generador de funciones

Un MUX 8:1 con las ocho entradas de datos atadas a 0 o a 1 es una tabla de verdad física: los selectores son las variables, y cada dato es la salida de la fila correspondiente. Cualquier función de tres variables se obtiene sin pensar en puertas, solo cableando.

Un truco: usar la última variable como dato

Un MUX de 2^k entradas se usa también para funciones de k + 1 variables: los selectores toman las primeras k variables y las entradas de datos reciben, según el caso, 0, 1, la última variable o su complemento. Es la expansión de Shannon aplicada a la última variable.

La receta: agrupar la tabla de verdad de a pares de filas (las que difieren solo en la última variable) y mirar cada par:

Mayoría = MUX 4:1 con D = (0, C, C, 1): medio chip 74HC153 y ninguna puerta más. Y la paridad de tres variables con un 4:1 y un inversor: D = (C, ~C, ~C, C).

Un ejemplo de cuatro variables con un 8:1

La función del Tema 15, Σm(0, 1, 3, 7, 8, 9, 11, 15), con un 74HC151 y selectores A, B, C:

Un solo chip, sin inversores, para una función de cuatro variables. Con puertas, la versión mínima del Tema 15 necesitaba 5. Es la misma idea que usan las FPGA: su unidad básica es una LUT (lookup table), una memoria pequeña indexada por las entradas, que hace de «MUX con datos programables».

06 · Aplicaciones

Para qué se usa un multiplexor

Elegir entre fuentes

Consigna manual o automática, reloj interno o externo, dato local o remoto. Con un 74HC157 se conmutan 4 bits a la vez con un único selector.

Compartir un recurso

Un solo decodificador de 7 segmentos para cuatro dígitos: un MUX elige qué dígito presentar mientras otro circuito enciende el display correspondiente, a una velocidad que el ojo no percibe (multiplexado de display, Tema 21).

Serializar un dato

Un MUX 8:1 con un contador de 3 bits en los selectores convierte un byte en un flujo de bits: en cada ciclo sale uno distinto. Es la base de un transmisor serie. Con el bit de inicio y el de parada, una trama UART (Tema 2) es un 10:1.

Leer muchas entradas con pocos pines

Ocho sensores digitales, tres pines de selección y uno de lectura en lugar de ocho pines de lectura. El teclado matricial usa un principio parecido.

Entradas analógicas

El 74HC4051 es un multiplexor analógico de 8 canales: deja pasar una señal analógica elegida hacia un único conversor. Sus interruptores tienen una resistencia en conducción de decenas a cientos de ohmios, y no son intercambiables con un MUX digital.

Implementar lógica

Una función de tres o cuatro variables con un solo chip, como en la sección anterior.

07 · Simulador

Laboratorio: sintetizar una función con un MUX

Elegí una función (de 2, 3 o 4 variables) y cuántas variables van a los selectores. El simulador calcula qué debe ir en cada entrada de datos (0, 1, una variable, su complemento, o una función de las variables restantes), dibuja el multiplexor con el camino elegido resaltado y comprueba que reproduce la función en todas las combinaciones de entrada.

• Trapecio: el multiplexor. A la izquierda, cada entrada de datos con su etiqueta (0, 1, C, ~C…) y su valor actual. La línea elegida se dibuja gruesa y amarilla.
• Variables: los botones de abajo fijan los valores de A, B, C, D. Las primeras k van a los selectores; el resto alimenta los datos.
• Selectores: la cantidad k decide el tamaño: con k = n usás una LUT pura (solo constantes); con menos selectores, algunos datos pasan a ser variables y el MUX es más chico.

Recorrido guiado (7 minutos)

1. 1
   Mirá el estado inicial: la mayoría con un 4:1.

   Los datos son 0, C, C, 1. Con A = 0 y B = 0 sale D0 = 0 siempre; con A = 1 y B = 1 sale D3 = 1 siempre; en los dos casos intermedios la salida copia a C. Fijá C y recorré A y B con los botones.

2. 2
   Subí a k = 3 (un 8:1 con constantes).

   Ahora los ocho datos son 0 y 1: la columna Y de la tabla de verdad. Es una LUT pura. Todos los datos son constantes y no hacen falta inversores.

3. 3
   Bajá a k = 1 (un 2:1).

   Con un solo selector (A), cada dato es una función de B y C: con la mayoría, «B·C» (cuando A = 0) y «B+C» (cuando A = 1). Esos datos necesitan puertas: el MUX más chico traslada la complejidad a los datos.

4. 4
   Elegí «Paridad de 3» con k = 2.

   Los datos son C, ~C, ~C, C: hace falta un solo inversor. La paridad de tres variables sale de un medio 74HC153 y un inversor.

5. 5
   Elegí «Función del Tema 15 (4 var)» con k = 3.

   Datos: 1, D, 0, D, 1, D, 0, D. Una función de cuatro variables con un solo 74HC151, sin una sola compuerta. Compará con las 5 puertas de la forma mínima.

6. 6
   Elegí «¿Es primo? (4 bits)» con k = 3.

   Ahora los datos son 0, 1, D, D, 0, D, D, 0. Una función «de teoría de números» resuelta sin ecuación. Probá k = 2: aparecen datos como C, D y C·D, y alguno que ya no es ni constante ni una variable sola.

7. 7
   Verificá la tabla completa.

   La última tarjeta dice «N/N ✓» cuando el MUX reproduce la función en todas las combinaciones. Probá cambiar de función y de k varias veces: siempre debe dar ✓. Si no, la síntesis tendría un error.

Preguntas para pensar

1. Con la mayoría y k = 2, ¿por qué D1 y D2 valen C y D0 y D3 son constantes?
2. ¿Cuántos datos tiene un MUX con k = 3? ¿Y cuántos selectores necesita uno de 16 datos?
3. ¿Qué diferencia hay entre usar las variables en los selectores y usarlas en los datos?
4. ¿Por qué un MUX con todos los datos en 0 y uno en 1 funciona como un decodificador?

08 · Multiplexores en código

Elegir, sintetizar, serializar y detectar glitches

Los bloques construyen multiplexores grandes a partir de otros chicos y verifican que se comportan como un arreglo indexado, sintetizan funciones con la receta de los pares de filas, simulan un serializador y un MUX de 16 entradas con dos 74HC151 y su enable, y reproducen el glitch del selector con un inversor lento, junto con su cura.

Paso 1: de 2:1 a 8:1, con puertas y con índice

from itertools import product
from math import log2


def mux21(d0, d1, s):
    return d1 if s else d0


def mux21_puertas(d0, d1, s):
    return ((1 - s) & d0) | (s & d1)


def mux41(d, s1, s0):                  # tres 2:1: dos comparten S0 y uno usa S1
    return mux21(mux21(d[0], d[1], s0), mux21(d[2], d[3], s0), s1)


def mux81(d, s2, s1, s0):
    return mux21(mux41(d[:4], s1, s0), mux41(d[4:], s1, s0), s2)


ok21 = all(mux21(a, b, s) == mux21_puertas(a, b, s) for a, b, s in product((0, 1), repeat=3))
ok41 = all(mux41(d, s1, s0) == d[2 * s1 + s0] for d in product((0, 1), repeat=4) for s1, s0 in product((0, 1), repeat=2))
ok81 = all(mux81(d, a, b, c) == d[4 * a + 2 * b + c] for d in product((0, 1), repeat=8) for a, b, c in product((0, 1), repeat=3))
print("2:1 con índice == 2:1 con puertas:", ok21)
print("4:1 hecho con tres 2:1 == d[índice]:", ok41)
print("8:1 hecho con siete 2:1 == d[índice]:", ok81)

print()
for n in (2, 4, 8, 16, 64):
    print(f"{n:>2}:1 -> {n - 1:>2} multiplexores 2:1, {log2(n):.0f} niveles de retardo")

Los tres MUX se comportan como un arreglo indexado. Un MUX de N entradas son N − 1 multiplexores 2:1 y log₂ N niveles: duplicar las entradas suma un solo nivel.

Paso 2: sintetizar una función con un MUX

from itertools import product


def sintetizar(unos, n, k):
    vs = "ABCD"[:n]
    r = n - k
    por = 2 ** r
    tabla = [1 if i in unos else 0 for i in range(2 ** n)]
    datos = []
    for s in range(2 ** k):
        t = tabla[s * por:(s + 1) * por]
        if not any(t):
            datos.append(("0",))
        elif all(t):
            datos.append(("1",))
        elif r == 1:
            datos.append(("var", 0, t == [1, 0]))          # variable restante, negada o no
        else:
            datos.append(("f", t))
    return tabla, datos


def etiqueta(d, n, k):
    vs = "ABCD"[k:n]
    if d[0] in ("0", "1"):
        return d[0]
    if d[0] == "var":
        return ("~" if d[2] else "") + vs[d[1]]
    return f"f({vs})=Σm{[i for i, x in enumerate(d[1]) if x]}"


def evaluar(datos, n, k, bits):
    s = int("".join(map(str, bits[:k])), 2)
    rem = bits[k:]
    d = datos[s]
    if d[0] == "0":
        return 0
    if d[0] == "1":
        return 1
    if d[0] == "var":
        return 1 - rem[d[1]] if d[2] else rem[d[1]]
    return d[1][int("".join(map(str, rem)), 2)]


CASOS = {
    "mayoría de 3, k=2":          ([3, 5, 6, 7], 3, 2),
    "paridad de 3, k=2":          ([1, 2, 4, 7], 3, 2),
    "mayoría de 3, k=3 (LUT)":    ([3, 5, 6, 7], 3, 3),
    "Tema 15 (4 var), k=3":       ([0, 1, 3, 7, 8, 9, 11, 15], 4, 3),
    "¿es primo?, k=3":            ([2, 3, 5, 7, 11, 13], 4, 3),
    "Tema 15 (4 var), k=2":       ([0, 1, 3, 7, 8, 9, 11, 15], 4, 2),
}
for nombre, (unos, n, k) in CASOS.items():
    tabla, datos = sintetizar(unos, n, k)
    ok = all(evaluar(datos, n, k, list(b)) == tabla[int("".join(map(str, b)), 2)] for b in product((0, 1), repeat=n))
    print(f"{nombre:<26} MUX {2 ** k}:1  datos = {[etiqueta(d, n, k) for d in datos]}  {'ok' if ok else 'FALLA'}")

La mayoría con k = 2 da (0, C, C, 1) y la paridad (C, ~C, ~C, C); la función del Tema 15 con k = 3 da (1, D, 0, D, 1, D, 0, D). Con k = 2 los datos ya son funciones de C y D. Cada síntesis se comprueba contra la tabla en todas las filas.

Paso 3: un serializador con un MUX 8:1 y un contador

def serializar(byte, msb_primero):
    if msb_primero:
        d = [(byte >> (7 - i)) & 1 for i in range(8)]
    else:
        d = [(byte >> i) & 1 for i in range(8)]
    flujo = []
    for ciclo in range(8):          # un contador de 3 bits maneja S2 S1 S0
        flujo.append(d[ciclo])      # el MUX 8:1 elige D[ciclo]
    return d, flujo


byte = 0x4B
print(f"byte = 0x{byte:02X} = {byte:08b}")
for orden in (True, False):
    d, flujo = serializar(byte, orden)
    print(f"{'MSB primero' if orden else 'LSB primero'}: D0..D7 = {d}  salida = {''.join(map(str, flujo))}")

# una trama UART: bit de inicio, 8 datos LSB primero, bit de parada (un MUX de 10 entradas)
car = ord("A")
trama = [0] + [(car >> i) & 1 for i in range(8)] + [1]
print(f"trama de 'A' (0x{car:02X}):", "".join(map(str, trama)), "(inicio=0, 8 datos LSB primero, parada=1)")

El mismo byte sale en dos órdenes distintos según cómo se cableen los datos a las entradas. La trama UART de la «A» es un MUX de 10 entradas (inicio, 8 datos y parada) recorrido por un contador.

Paso 4: bus de 4 bits con un 74HC157 y un 16:1 con dos 74HC151

from itertools import product


def mux157(a, b, s, e_n=0):
    # a y b: nibbles. Con el strobe (activo en bajo) en 1 las salidas valen 0
    if e_n:
        return 0
    return b if s else a


def mux151(d, s, e_n=0):
    y = 0 if e_n else d[s]
    return y, 1 - y                 # salidas Y y W (= ~Y)


def mux16(d, s):
    s3, s210 = s >> 3, s & 7
    y1, _ = mux151(d[:8], s210, e_n=s3)          # habilitado cuando S3 = 0
    y2, _ = mux151(d[8:], s210, e_n=1 - s3)      # habilitado cuando S3 = 1
    return y1 | y2                               # el deshabilitado entrega 0


a, b = 0b1010, 0b0101
print("157: S=0 ->", format(mux157(a, b, 0), "04b"), " S=1 ->", format(mux157(a, b, 1), "04b"),
      " strobe=1 ->", format(mux157(a, b, 1, e_n=1), "04b"))

patrones = [[(i * 7 + k) % 2 for i in range(16)] for k in range(4)] + [[1] * 16, [0] * 16, [i >= 8 for i in range(16)]]
ok = all(mux16(list(map(int, d)), s) == int(d[s]) for d in patrones for s in range(16))
print("16:1 con dos 151, S3 en los enables y un OR:", ok)

Con el strobe en 1 todas las salidas del 157 caen a 0. El 16:1 hecho con dos 74HC151 funciona porque el chip deshabilitado entrega 0: se juntan con un OR. Con los 251 (tri-estado) alcanzaría un cable.

Paso 5: el glitch del selector, y su cura

def simular(d0, d1, sube, consenso, retardo=2, pasos=14, t_cambio=6):
    if sube:
        S = [0 if t < t_cambio else 1 for t in range(pasos)]
    else:
        S = [1 if t < t_cambio else 0 for t in range(pasos)]
    nS = [1 - S[max(0, t - retardo)] for t in range(pasos)]      # el inversor tarda 'retardo' pasos
    Y = []
    for t in range(pasos):
        y = (nS[t] & d0) | (S[t] & d1)
        if consenso:
            y |= d0 & d1                                         # término de consenso del Tema 14
        Y.append(y)
    return S, nS, Y


for sube in (True, False):
    for consenso in (False, True):
        S, nS, Y = simular(1, 1, sube, consenso)
        print(f"S {'sube' if sube else 'baja'}, consenso={consenso!s:<5}  "
              f"S={''.join(map(str, S))}  ~S={''.join(map(str, nS))}  Y={''.join(map(str, Y))}"
              f"  {'GLITCH' if 0 in Y else 'limpio'}")

Con D0 = D1 = 1 la salida debería valer 1 siempre. Cuando S baja (1 → 0), el término S·D1 se apaga enseguida pero el ~S tarda en subir por el inversor: durante dos pasos Y cae a 0. Cuando S sube no hay glitch. Con el término de consenso D0·D1 la salida queda limpia en ambos sentidos.

09 · Analogía de programador

Un switch con cables

1. 1
   MUX = datos[sel].

   Ejecutado por silicio, en un nanosegundo, sin saltos ni ramas: todas las entradas están presentes, solo se ve una.

2. 2
   MUX 8:1 = un arreglo de 8 bits.

   La función vive en los ceros y unos que cableás a las entradas, no en las puertas. Cambiar la función es recablear los datos.

3. 3
   Enable = guarda.

   Sin habilitación, el bloque no habla, igual que un if (en) alrededor de toda la operación.

La diferencia con el software: en el hardware todas las entradas existen y se calculan a la vez; el MUX no «evita» ejecutar las otras ramas, simplemente no las mira. Por eso un MUX con datos costosos de generar los genera todos, aunque solo use uno.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de selección

Ejercicio 1: manual o automático

Una consigna de 4 bits puede venir de un conmutador manual (M) o de un programa (A) según una señal S. Dibujá con MUX y escribí la ecuación. ¿Qué chip usás?

Ejercicio 2: mayoría con un 74HC151

Armá la mayoría de 3 con un 8:1: ¿qué se conecta a cada dato? Verificá con el simulador.

Ejercicio 3: XOR con un MUX 2:1

Implementá A⊕B con un MUX 2:1 y a lo sumo un inversor. ¿Qué va en cada pata?

Ejercicio 4: ¿es primo?

Una entrada de 4 bits (A B C D) debe dar 1 si el número es primo (2, 3, 5, 7, 11, 13). Implementala con un 74HC151 usando A, B, C de selectores y D como dato.

Ejercicio 5: un 16:1 con dos 74HC151

Armá un MUX de 16 entradas con dos 74HC151. ¿Cómo se conectan los enables y las salidas? ¿Qué cambia con 74HC251?

Ejercicio 6: serializar y el glitch

Un 74HC151 con un contador de 3 bits en los selectores serializa un byte. ¿Cuántos ciclos de reloj dura? ¿Qué entrada sale con S = 101? ¿Qué problema puede aparecer al pasar de 011 a 100?

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 19?

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

• Escribir la ecuación de un MUX 2:1 y de uno 4:1.
• Decir cuántos selectores necesita un MUX de 16 entradas y qué dato se elige con S3 S2 S1 S0 = 0110.
• Implementar la mayoría de 3 con un 4:1 diciendo qué va en cada dato.
• Armar un 16:1 con dos 74HC151.
• Explicar qué le pasa a la salida si el selector cambia con D0 = D1 = 1.
• Distinguir un MUX digital de uno analógico.

Un multiplexor junta muchos caminos en uno. El camino inverso es repartir un dato entre varios destinos: en el próximo tema, demultiplexores.