Considerando a função abaixo, pede-se:
f=\sum(0,2,3,7,9,11,13,14)+d(12,15)
Implemente usando dois multiplexadores 8:1 mais lógica adicional.

Passo 1

O enunciado dá a função booleana
f=\sum(0,2,3,7,9,11,13,14)+d(12,15)
ou seja, é uma função de quatro variáveis (índices de 0 a 15 indicam todas as combinações de quatro variáveis). O pedido é: implementar f usando dois multiplexadores 8\!:\!1 mais lógica adicional.
Informações relevantes que extraí do enunciado:
  • A função tem minterms verdadeiros em \{0,2,3,7,9,11,13,14\}.
  • Existem don’t-cares em \{12,15\}.
  • Vou chamar as quatro variáveis de A,B,C,D com A sendo o bit mais significativo (MSB). Assim o índice é o número binário (A\,B\,C\,D).
  • Um multiplexador 8\!:\!1 tem três entradas de seleção e oito entradas de dados; cada entrada de dados pode receber 0, 1 ou alguma entrada de variáveis.

Passo 2

Estratégia (sem resolver ainda): usar a expansão de Shannon em torno de uma variável (escolho A por ser MSB). Escrevo
f = A' \cdot f_{A=0}(B,C,D) \;+\; A \cdot f_{A=1}(B,C,D).
Cada função f_{A=0} e f_{A=1} depende só de B,C,D (três variáveis) e pode ser diretamente implementada por um multiplexador 8\!:\!1 usando B,C,D como seletores. Depois combino as saídas dos dois 8\!:\!1 com lógica simples controlada por A (do tipo A' AND saída0, A AND saída1, em seguida OR).
Explico por quê isso funciona: um 8\!:\!1 seleciona uma das oito entradas de dados segundo as três linhas de seleção; se as entradas de dados forem os valores de f para as combinações de B,C,D (com A fixo), a saída do MUX é exatamente f_{A=\text{fixo}}(B,C,D).

Passo 3

Breve aula sobre o 8\!:\!1 que usarei:
  • Um 8\!:\!1 tem entradas de dados D_0,\dots,D_7 e entradas de seleção S_2,S_1,S_0. Quando (S_2S_1S_0) é o binário k, a saída do MUX é D_k.
  • Vou usar a ordem natural D_0 correspondente a (B\,C\,D)=(0\,0\,0), D_1 a (0\,0\,1), …, D_7 a (1\,1\,1). Ou seja, o índice do minterm local (0…7) é simplesmente o valor binário de BCD.
  • Então, para A=0 os minterms 0 a 7 dão os valores que coloco em D_0\dots D_7 do primeiro MUX; para A=1 os minterms 8 a 15 dão os valores para o segundo MUX.

Passo 4

Construção da tabela para A=0 (índices 0 a 7). Vou listar cada índice em binário (A\,B\,C\,D) e o valor de f:
  • 0 = (0\;0\;0\;0): está em \sum f=1.
  • 1 = (0\;0\;0\;1): não está em \sum f=0.
  • 2 = (0\;0\;1\;0): está → f=1.
  • 3 = (0\;0\;1\;1): está → f=1.
  • 4 = (0\;1\;0\;0): não está → f=0.
  • 5 = (0\;1\;0\;1): não está → f=0.
  • 6 = (0\;1\;1\;0): não está → f=0.
  • 7 = (0\;1\;1\;1): está → f=1.
Portanto, para o MUX correspondente a A=0 (chamo sua saída de Y_0), os dados são
\begin{aligned} D_0 &= 1,\\\ D_1 &= 0,\\\ D_2 &= 1,\\\ D_3 &= 1,\\\ D_4 &= 0,\\\ D_5 &= 0,\\\ D_6 &= 0,\\\ D_7 &= 1. \end{aligned}

Passo 5

Construção da tabela para A=1 (índices 8 a 15). Listei os minterms e don’t-cares:
  • 8 = (1\;0\;0\;0): não está em \sum f=0.
  • 9 = (1\;0\;0\;1): está → f=1.
  • 10 = (1\;0\;1\;0): não está → f=0.
  • 11 = (1\;0\;1\;1): está → f=1.
  • 12 = (1\;1\;0\;0): é don’t-care → posso escolher 0 ou 1.
  • 13 = (1\;1\;0\;1): está → f=1.
  • 14 = (1\;1\;1\;0): está → f=1.
  • 15 = (1\;1\;1\;1): é don’t-care → posso escolher 0 ou 1.
Para simplicidade escolho D_4=0 e D_7=0 (ou seja, resolvo ambos don’t-cares como 0). Assim para o MUX correspondente a A=1 (saída Y_1) tenho:
\begin{aligned} D_0 &= 0,\\\ D_1 &= 1,\\\ D_2 &= 0,\\\ D_3 &= 1,\\\ D_4 &= 0\\ (\text{d.c. escolhido }0),\\\ D_5 &= 1,\\\ D_6 &= 1,\\\ D_7 &= 0\\ (\text{d.c. escolhido }0). \end{aligned}
Observação: os don’t-cares poderiam ser escolhidos de outra forma se houver vantagem de simplificação adicional, mas para implementação com dois 8\!:\!1 e portas AND/OR essa escolha é perfeitamente válida.

Passo 6

Como ligar fisicamente os componentes (explicação prática e didática):
  • Uso dois 8\!:\!1: MUX0 e MUX1.
  • Em ambos, conecto as linhas de seleção S_2,S_1,S_0 aos sinais B,C,D (defino S_2=B,\;S_1=C,\;S_0=D). Assim o índice k do MUX corresponde ao valor binário de (B\,C\,D).
  • Carrego nas entradas de dados de MUX0 (caso A=0) os valores do Passo 4: D_0=1,\;D_1=0,\;D_2=1,\;D_3=1,\;D_4=0,\;D_5=0,\;D_6=0,\;D_7=1.
  • Carrego nas entradas de dados de MUX1 (caso A=1) os valores do Passo 5: D_0=0,\;D_1=1,\;D_2=0,\;D_3=1,\;D_4=0,\;D_5=1,\;D_6=1,\;D_7=0.
  • As saídas dos MUXs chamo Y_0 (saída de MUX0) e Y_1 (saída de MUX1). Cada uma vale o valor de f quando A é respectivamente 0 ou 1.

Passo 7

Combinação final por A. Pela expansão de Shannon:
f = A' \cdot Y_0 \;+\; A \cdot Y_1.
Isto é implementado com duas portas AND e uma porta OR:
  • Portas AND: T_0 = A'\,\&\,Y_0 e T_1 = A\,\&\,Y_1.
  • Porta OR: f = T_0 \;|\; T_1.
Se preferir, pode realizar A' com um inversor e então as duas ANDs e uma OR. Essa é a “lógica adicional” pedida no enunciado (um inversor, duas ANDs e uma OR).

Passo 8

Checagem rápida (exemplos) para ganhar confiança:
  • Minterm 3=(0\,0\,1\,1): A=0, (B\,C\,D)=(0\,1\,1)\Rightarrow MUX0 seleciona D_3=1, então Y_0=1. Como A=0 temos f=A'Y_0=1\cdot1=1 (corresponde ao fato de 3 estar em \sum).
  • Minterm 14=(1\,1\,1\,0): A=1, (B\,C\,D)=(1\,1\,0)\Rightarrow MUX1 seleciona D_6=1, então Y_1=1. Como A=1 temos f=A Y_1=1\cdot1=1 (corresponde ao fato de 14 estar em \sum).
  • Minterm 12=(1\,1\,0\,0) é don’t-care: escolhi D_4=0, então a implementação dá f=0 ali, o que é permitido.

Passo 9

Resumo das ligações passo a passo (prático para montar na prova/placa):
  1. Sinais de seleção de ambos MUX: S_2=B,\;S_1=C,\;S_0=D.
  2. Entradas de dados de MUX0 (caso A=0): D_0=1,\;D_1=0,\;D_2=1,\;D_3=1,\;D_4=0,\;D_5=0,\;D_6=0,\;D_7=1.
  3. Entradas de dados de MUX1 (caso A=1): D_0=0,\;D_1=1,\;D_2=0,\;D_3=1,\;D_4=0,\;D_5=1,\;D_6=1,\;D_7=0.
  4. Saídas: Y_0 de MUX0 e Y_1 de MUX1.
  5. Faça A' com um inversor.
  6. Calcule T_0 = A' \land Y_0 e T_1 = A \land Y_1.
  7. Finalmente f = T_0 \lor T_1.

Resposta

Conectar dois MUX 8\!:\!1 com seletores B,C,D. MUX0 (para A=0) tem entradas D_0..D_7 = 1,0,1,1,0,0,0,1. MUX1 (para A=1) tem entradas D_0..D_7 = 0,1,0,1,0,1,1,0 (escolhidos don’t-cares 12,15 como 0). Saídas Y_0,Y_1 vão para a lógica adicional f = A'\cdot Y_0 \;+\; A\cdot Y_1 (inversor em A, duas ANDs e uma OR).

Exercícios relacionados