Multiplexadores e Demultiplexadores

O que é um multiplexador

Um multiplexador (MUX) é um circuito combinacional que seleciona uma entre várias entradas de dados e a direciona para uma única saída. A seleção é controlada por entradas de seleção. Pense nele como uma chave seletora digital: com n bits de seleção, podemos escolher entre 2ⁿ entradas.

MUX é como uma chave seletora de TV:

  Canal 0 ──┐
  Canal 1 ──┤     ┌──── Tela
  Canal 2 ──┤ MUX ├──── (uma saída)
  Canal 3 ──┘     └────
       ▲
       │
  Controle remoto
  (seleção: 2 bits)

MUX 2:1

O multiplexador mais simples: 2 entradas de dados (I₀, I₁), 1 entrada de seleção (S), 1 saída (Y).

Tabela-verdade:
  S │ Y
  ──┼────
  0 │ I₀
  1 │ I₁

Expressão booleana:
  Y = S̅·I₀ + S·I₁

Circuito com portas:
  I₀──┤AND├──┐
  S̅──┘       ├──┤OR├── Y
  I₁──┤AND├──┘
  S──┘

Em Verilog:
  assign Y = S ? I1 : I0;

Isso é literalmente o operador ternário das linguagens de programação!

MUX 4:1

4 entradas de dados: I₀, I₁, I₂, I₃
2 entradas de seleção: S₁, S₀
1 saída: Y

Tabela-verdade:
  S₁  S₀ │ Y
  ───────┼────
   0   0 │ I₀
   0   1 │ I₁
   1   0 │ I₂
   1   1 │ I₃

Expressão:
  Y = S̅₁·S̅₀·I₀ + S̅₁·S₀·I₁ + S₁·S̅₀·I₂ + S₁·S₀·I₃

Diagrama em bloco:
  I₀ ──┐
  I₁ ──┤ MUX  ├── Y
  I₂ ──┤ 4:1  │
  I₃ ──┘      │
        S₁ S₀ ┘

MUX 8:1 e expansão

O MUX 8:1 tem 8 entradas de dados e 3 bits de seleção. O padrão continua: MUX 2ⁿ:1 precisa de n bits de seleção.

MUXes maiores podem ser construídos a partir de menores:

Construindo MUX 8:1 com dois MUX 4:1 e um MUX 2:1:

  I₀ ──┐              ┌──┐
  I₁ ──┤ MUX 4:1 (A)──┤  │
  I₂ ──┤   S₁ S₀      │  │
  I₃ ──┘   │  │       │  ├── Y
                       │MUX│
  I₄ ──┐              │2:1│
  I₅ ──┤ MUX 4:1 (B)──┤  │
  I₆ ──┤   S₁ S₀      │  │
  I₇ ──┘   │  │       └──┘
            │  │        │
            └──┼────────S₂
               └────── conectados a S₁, S₀ globais

S₂ seleciona entre o resultado de A (I₀-I₃) e B (I₄-I₇)
S₁, S₀ selecionam qual entrada dentro do bloco escolhido

Implementação de funções com MUX

Um MUX pode implementar qualquer função booleana de n variáveis usando um MUX 2ⁿ:1, ou de forma mais eficiente, um MUX 2⁽ⁿ⁻¹⁾:1 com uma variável nas entradas de dados:

Implementar F(A,B,C) = Σm(1, 2, 6, 7) com MUX 4:1:

Passo 1: Use A,B como seleção (n-1 variáveis)
Passo 2: Para cada combinação de A,B, determine a saída em função de C

  A  B  C │ F       │ Agrupando por A,B:
  ────────┼─────────┼──────────────────
  0  0  0 │ 0       │ A=0,B=0: F=C  (0→0, 1→1)
  0  0  1 │ 1       │
  0  1  0 │ 1       │ A=0,B=1: F=C̅  (0→1, 1→0)
  0  1  1 │ 0       │
  1  0  0 │ 0       │ A=1,B=0: F=0  (0→0, 1→0)
  1  0  1 │ 0       │
  1  1  0 │ 1       │ A=1,B=1: F=1  (0→1, 1→1)
  1  1  1 │ 1       │

Conexões do MUX 4:1:
  I₀ = C       (entrada 00)
  I₁ = C̅       (entrada 01)
  I₂ = 0       (entrada 10)
  I₃ = 1       (entrada 11)
  S₁ = A, S₀ = B

  C ──── I₀ ──┐
  C̅ ──── I₁ ──┤ MUX  ├── F
  GND ── I₂ ──┤ 4:1  │
  VDD ── I₃ ──┘      │
              A   B ──┘

Demultiplexador (DEMUX)

O demultiplexador faz o inverso do MUX: recebe uma entrada e a direciona para uma das várias saídas, conforme as linhas de seleção.

1 entrada de dados: D
2 entradas de seleção: S₁, S₀
4 saídas: Y₀, Y₁, Y₂, Y₃

Tabela-verdade:
  S₁  S₀ │ Y₀  Y₁  Y₂  Y₃
  ───────┼──────────────────
   0   0 │  D   0   0   0
   0   1 │  0   D   0   0
   1   0 │  0   0   D   0
   1   1 │  0   0   0   D

Expressões:
  Y₀ = S̅₁·S̅₀·D
  Y₁ = S̅₁·S₀·D
  Y₂ = S₁·S̅₀·D
  Y₃ = S₁·S₀·D

Decodificadores e codificadores

Um decodificador n:2ⁿ ativa exatamente uma de 2ⁿ saídas, dependendo da entrada de n bits. É essencialmente um DEMUX com a entrada de dados fixada em 1.

Entradas: A₁, A₀
Saídas: Y₀, Y₁, Y₂, Y₃
Enable: E (ativa/desativa o decodificador)

  A₁  A₀  E │ Y₀  Y₁  Y₂  Y₃
  ──────────┼──────────────────
   X   X  0 │  0   0   0   0
   0   0  1 │  1   0   0   0
   0   1  1 │  0   1   0   0
   1   0  1 │  0   0   1   0
   1   1  1 │  0   0   0   1

Aplicação típica: seleção de chip de memória
  Endereço → Decodificador → habilita o chip correto

Um codificador faz o inverso: com 2ⁿ entradas (uma ativa por vez), produz o código binário de n bits da entrada ativa. O codificador de prioridade resolve conflitos quando múltiplas entradas estão ativas, priorizando a de maior índice.

No harness.os

O conceito de multiplexação aparece em vários níveis do harness:

• Roteamento de requisições — um load balancer ou API gateway funciona como um DEMUX: recebe uma requisição e a direciona para um de vários servidores backend baseado em regras de roteamento (as "linhas de seleção").
• Seleção de configuração — no harness.os, o sistema de rules seleciona qual configuração aplicar baseado no contexto (tipo de projeto, fase, concern). Isso é um MUX conceitual: múltiplas configurações possíveis, seleção baseada em contexto.
• Decodificação de endereço — quando o harness recebe uma requisição para um recurso específico, o roteamento decodifica o path para identificar qual handler deve processar — o mesmo princípio do decodificador de endereço em memória.
• Codificador de prioridade em filas — sistemas de filas de prioridade (como escalonamento de tarefas) usam o mesmo conceito do codificador de prioridade: múltiplas tarefas pendentes, selecionar a de maior prioridade.

Exercícios

1. MUX como função: Implemente F(A,B,C) = Σm(0, 3, 5, 6) usando um MUX 4:1 com A e B nas entradas de seleção. Determine o que conectar em cada entrada de dados (I₀, I₁, I₂, I₃).
2. Expansão: Desenhe como construir um MUX 16:1 usando cinco MUX 4:1. Identifique quais bits de seleção controlam cada nível.
3. Decodificador: Projete um decodificador 3:8 usando portas AND e inversores. Quantas portas AND de 3 entradas são necessárias?

Resumo

• MUX seleciona uma entre 2ⁿ entradas usando n bits de seleção
• Expressão do MUX 2:1: Y = S̅·I₀ + S·I₁
• MUXes maiores são construídos hierarquicamente a partir de menores
• Qualquer função booleana pode ser implementada com um MUX
• DEMUX faz o inverso: direciona uma entrada para uma de várias saídas
• Decodificadores ativam exatamente uma saída; codificadores produzem o código da entrada ativa