Módulos combinatórios

Um multiplexador escolhe um dado, um descodificador ativa uma linha e um somador calcula uma soma. São módulos combinatórios: depois dos atrasos de propagação, as saídas dependem das entradas atuais. Conhecer a função e as larguras permite ligá-los sem redesenhar as portas interiores.

Multiplexador e descodificador

Um multiplexador 2:1 seleciona $I_0$ quando $S=0$ e $I_1$ quando $S=1$, com

$$Y=\overline S I_0+S I_1,$$

onde o primeiro termo cobre $S=0$ e o segundo cobre $S=1$:

Um MUX com $2^k$ entradas precisa de $k$ bits de seleção. Se os dados forem words de 32 bits, há 32 seleções paralelas com os mesmos bits: um MUX 8:1 de words precisa de 3 bits de seleção, não de 32.

Um descodificador de $k$ entradas ativa uma entre $2^k$ saídas. Num 2:4 ativo a 1, $D_0=\overline A\overline B$, $D_1=\overline AB$, $D_2=A\overline B$ e $D_3=AB$; um enable $E$ multiplica estas expressões, com $E=0$ a desativar todas as saídas e $E=1$ a permitir a seleção normal. Aqui $A$ é o bit mais significativo da seleção; se as saídas forem ativas a 0, a linha selecionada fica 0 e as restantes 1.

Um demultiplexador encaminha um dado para a saída selecionada; pode ser construído aplicando o dado ao enable de um descodificador. Um codificador faz a operação inversa de indicar o índice de uma entrada ativa. Se várias entradas puderem estar ativas, define prioridade e um sinal valid: o código 00 sozinho não distingue a entrada 0 ativa de nenhuma entrada ativa.

Implementar uma função por seleção

Para $F=\Sigma m(1,3,5,6,7)$, usa um MUX 4:1 com seleção $AB$. Nas quatro combinações de $AB$, a saída em função de $C$ é a seguinte:

$AB$	$F$ se $C=0$	$F$ se $C=1$	Entrada do MUX
00	0	1	$C$
01	0	1	$C$
10	0	1	$C$
11	1	1	1

Logo liga $I_0=I_1=I_2=C$, $I_3=1$. A escolha das variáveis de seleção altera as subfunções necessárias, mas não a função final.

Para construir um MUX 4:1 com MUX 2:1, usa $S_0$ no primeiro nível e $S_1$ no segundo: dois MUX escolhem entre $(I_0,I_1)$ e $(I_2,I_3)$ com $S_0$; um terceiro escolhe entre esses resultados com $S_1$. Para implementar uma função de 3 variáveis com descodificador 3:8 ativo a 1, faz OR das saídas correspondentes aos mintermos: por exemplo, $F=\Sigma m(1,2,5)$ é $D_1+D_2+D_5$. O descodificador enumera os mintermos; a OR soma os pretendidos.

Comparadores

A igualdade entre palavras é o AND das igualdades bit a bit: $Eq=\prod_i\overline{A_i\oplus B_i}$. Para a ordem sem sinal, o primeiro bit diferente a partir do MSB decide.

Em duas partes, alta $H$ e baixa $L$, a parte baixa só decide quando as altas empatam, com

$$A>B=(A_H>B_H)+Eq_H(A_L>B_L).$$

Por exemplo, 1010 é maior que 1001: as partes altas 10 são iguais, por isso comparamos 10 com 01 na parte baixa. Num comparador com sinal, começa por distinguir os sinais, porque dois códigos com sinais diferentes não seguem a ordem sem sinal.

Somador completo

Um meio somador calcula $S=A\oplus B$ e $C=AB$. Um somador completo recebe ainda o carry $C_i$, com

$$S=A\oplus B\oplus C_i,\qquad C_{i+1}=AB+AC_i+BC_i.$$

$ABC_i$	$S$	$C_{i+1}$
000	0	0
001	1	0
010	1	0
011	0	1
100	1	0
101	0	1
110	0	1
111	1	1

Ligando o carry de cada posição à seguinte construímos um somador ripple-carry. Para $1011+0110$, com carry inicial 0, seguimos do LSB para o MSB na tabela seguinte:

Posição	$A_i$	$B_i$	Carry de entrada	Soma	Carry de saída
0	1	0	0	1	0
1	1	1	0	0	1
2	0	1	1	0	1
3	1	0	1	0	1

Lê os bits de soma em ordem inversa à das linhas: 0001. Acrescentando o carry final à esquerda, o resultado completo é 10001, ou 17; cada carry de saída alimenta a linha seguinte, por isso o atraso pode acumular-se ao longo da palavra.

Somar, subtrair e acelerar

Um controlo $M$ permite usar o mesmo somador: aplica $B_i\oplus M$ a cada entrada e usa $C_0=M$. Com $M=0$, calcula $A+B$, e com $M=1$, calcula $A+\overline B+1=A-B$.

No ripple-carry, o caminho crítico pode atravessar todos os carries. Definindo geração $G_i=A_iB_i$ e propagação $P_i=A_i\oplus B_i$, cada carry escreve-se $C_{i+1}=G_i+P_iC_i$. Expandir estas equações calcula carries em paralelo, à custa de mais lógica. O ganho depende do circuito e dos atrasos, não apenas do número de portas.

Se cada etapa de carry atrasar 2 ns e a soma final atrasar mais 3 ns, um caminho que atravesse quatro etapas exige 11 ns neste modelo. Os caminhos em paralelo não se somam: escolhe o maior atraso entre uma entrada e uma saída. Um multiplicador, por sua vez, forma produtos parciais e soma-os com o alinhamento dos respetivos pesos.