Aula 5 — Circuitos Combinacionais

Conceito, exemplos clássicos e prática guiada

Conceito central

Circuito combinacional é aquele cuja saída depende apenas do valor atual das entradas (não há memória/estado).

  • São compostos por portas lógicas que implementam funções matemáticas/booleanas.
  • Usos típicos: somadores, comparadores, decodificadores, multiplexadores, codificadores, detectores de paridade…
Resumo rápido
Sem memória ⇒ Sem realimentação de saídas para entradas (no tempo).
Mapeamento direto Entradas → Saídas por uma expressão booleana / tabela-verdade.

Exemplos simples

Half Adder, Full Adder, Paridade, Comparador

Visão geral

Combinational Circuit Example AND de duas entradas com fios e ponto de conexão. A B AND Y = A·B
A = 0
B = 0
S = 0
C = 0
(V/F) Circuitos combinacionais têm memória?
Falso
Verdadeiro

Correto: Falso — sem memória.

1) Half Adder

Entradas: A, B. Saídas: S=A⊕B, C=A·B.

ABS=A⊕BC=A·B
0000
0110
1010
1101

2) Full Adder

Entradas: A, B, Cin. Saídas: S=A⊕B⊕Cin, Cout=(A·B)+(B·Cin)+(A·Cin).

ABCinSCout
00000
00110
01010
01101
10010
10101
11001
11111

3) Paridade (3 bits)

Ímpar: F = A⊕B⊕C.

4) Comparador de igualdade

F = XNOR(A,B) = A·B + A′·B′ (1 se A=B).

Half Adder

Equações, tabela e esquemático + controle ao vivo

Half Adder (Meio-Somador) — explicativo

Visão geral
O Half Adder soma dois bits de entrada e produz duas saídas: S (soma) e C (carry, “vai-um”).
Ele não recebe carry de entrada — por isso é “meio” somador.

Nomenclatura

  • Entradas: A, B (bits a somar).
  • Saídas: S (soma, bit menos significativo do resultado) e C (carry, vai-um).
  • Equações: S = A ⊕ B (XOR)  •  C = A · B (AND).

Como funciona

A operação é bit a bit:

  • Se apenas um entre A e B é 1, então S=1 e C=0.
  • Se ambos são 1, a soma binária é 10₂: sai S=0 e gera C=1.
  • Se ambos são 0, S=0 e C=0.
ABS (A⊕B)C (A·B)
0000
0110
1010
1101

Leitura do resultado

O número somado em binário é dado por C S (carry como bit mais significativo). Exemplos: 1 + 0 → C S = 0 1 (1)  •  1 + 1 → C S = 1 0 (2).

Implementação prática: com portas, use XOR para S e AND para C. Em TTL, uma opção é 7486 (XOR) + 7408 (AND).
Terminologia: em somadores maiores, costuma-se chamar o carry de saída de um estágio de Cout e o carry de entrada do próximo de Cin. No Half Adder, só existe o carry de saída (C/Cout).

Equações

S = A ⊕ B  •  C = A·B

A = 0
B = 0
S = 0
C = 0
ABSC
0000
0110
1010
1101
TTL: 7486 para XOR, 7408 para AND.
Half Adder — S = A⊕B e C = A·B A e B entram na XOR e também ramificam para a AND. S (XOR) passa por cima; C (AND) por baixo. A B XOR S AND C
Desafio: Half Adder com NAND-only.
S = (A NAND (A NAND B)) NAND (B NAND (A NAND B))
C = (A NAND B) NAND (A NAND B)

Full Adder

Dois HAs + OR de carries

Full Adder — funcionamento & nomenclatura

O full adder soma três bits: duas entradas de dados (A, B) e um carry de entrada (Cin). Ele produz a soma (S) e um carry de saída (Cout), que pode alimentar o próximo estágio.

⊕ = XOR ou OU exclusivo.

Por que Cin e Cout?

Cin (carry-in)
É o “vai-um” que chega ao estágio atual vindo do bit menos significativo.
Cout (carry-out)
É o “vai-um” que sai deste estágio e segue para o próximo bit mais significativo.
Outras notações comuns
C_i / C_{i+1} (ripple de n bits), ou Ci / Co. Em um somador de 4 bits, por exemplo, costuma-se usar C0, C1, C2, C3, C4 (onde C0 é o carry inicial, e C4 o carry final).

Equações do full adder

S     = A ⊕ B ⊕ Cin
Cout  = (A · B) + ((A ⊕ B) · Cin)   ≡   (A · B) + (B · Cin) + (A · Cin)

Encadeando estágios (ripple-carry adder)

  1. Defina o carry inicial: C0 (geralmente 0 para soma simples).
  2. Para cada bit i (LSB → MSB):
    Si = Ai ⊕ Bi ⊕ Ci
    Ci+1 = (Ai · Bi) + ((Ai ⊕ Bi) · Ci)
  3. Ao final, Cn é o carry global (overflow/propagação final).
Resumo: usar Cin/Cout evita ambiguidade. Em half adder há apenas um carry de saída (C), mas no full adder precisamos distinguir o carry que entra do que sai para encadear vários estágios de soma.

Construção

  • S = A ⊕ B ⊕ Cin
  • Cout = A·B + (A ⊕ B)·Cin (≡ (A·B)+(B·Cin)+(A·Cin))
Implementação TTL: 2×7486 (XOR), 2×7408 (AND), 1×7432 (OR).
Full Adder: HA1(A,B) → S1,C1; HA2(S1,Cin) → S,C2; Cout = C1 + C2 A B Cin HA1 HA2 OR S1 C1 S Cout → Cin entra no HA2 C2
Nota: Cout = (A·B) + ((A⊕B)·Cin) ≡ (A·B) + (B·Cin) + (A·Cin).

Paridade & Comparador

XOR em cascata e XNOR

Detector de Paridade

O que é: um circuito combinacional que indica se a quantidade de bits em 1 nas entradas é par ou ímpar. É amplamente usado para detecção simples de erros em transmissão/armazenamento de dados.

  • Paridade ímpar (odd): a saída vale 1 quando o número de 1s é ímpar.
    Para 3 entradas: F = A ⊕ B ⊕ C.
  • Paridade par (even): a saída vale 1 quando o número de 1s é par.
    Para 3 entradas: Fₚ = ¬(A ⊕ B ⊕ C)  (inverte o resultado da ímpar).

Como funciona: o operador ⊕ (XOR) faz uma “soma módulo 2”. Cada bit em 1 alterna a saída entre 0 e 1. Por isso a paridade é só o XOR em cascata de todas as entradas: P = X₁ ⊕ X₂ ⊕ … ⊕ Xₙ.

Escalável: para 4 bits, por exemplo, P = A ⊕ B ⊕ C ⊕ D (ímpar) e Pₚ = ¬(A ⊕ B ⊕ C ⊕ D) (par).

Aplicações: bit de paridade em comunicação serial (ex.: UART), cabeçalhos de protocolos, e checagens simples de integridade em memória/arquivos. Em TTL, use portas XOR (ex.: CI 7486) em cascata; para paridade par, adicione um inversor (7404).

Detector de Paridade (3 bits)

Saída 1 quando a quantidade de 1s for ímpar: F = A ⊕ B ⊕ C.

ABCF
0000
0011
0101
0110
1001
1010
1100
1111
Detector de Paridade (3 bits) S1 = A⊕B alimenta a entrada superior da 2ª XOR; C entra na inferior; saída F = A⊕B⊕C. A B XOR S1 C XOR F = A ⊕ B ⊕ C F

Comparador de igualdade (1 bit)

F = XNOR(A,B) = A·B + A′·B′.

Comparador de Igualdade (1 bit)

O comparador de igualdade de 1 bit produz F = 1 quando as entradas são iguais (A = B) e F = 0 quando são diferentes.

Equações equivalentes:
F = XNOR(A, B) = A·B + A′·B′ = ¬(A ⊕ B)

Intuição

  • XOR acende para “diferença” (1 quando A ≠ B).
  • Logo, igualdade é o inverso do XOR: XNOR (1 quando A = B).

Tabela-verdade

ABF = XNOR(A,B)
001
010
100
111

Implementações típicas

  • XNOR direta (se houver porta XNOR no kit/biblioteca).
  • XOR + NOT: F = ¬(A ⊕ B) — 1×XOR (7486) + 1×inversor (7404).
  • Somente AND/OR/NOT: F = A·B + A′·B′ — 2×AND (7408) + 1×OR (7432) + 2×inversores (7404).

Aplicações

  • Checagem de igualdade bit-a-bit em barramentos e protocolos.
  • Comparação de endereços (ex.: tag de cache, decodificação de endereços).
  • Construção de comparadores n-bit: faça XNOR por bit e combine com AND de todas as saídas.
Extensão para n bits: F = ∧i XNOR(Ai, Bi)
(todas as comparações bit-a-bit devem ser 1 para indicar igualdade total).
A B XNOR F (1 se A=B)

Multiplexador 2:1

Multiplexador 2:1 (MUX 2:1)

Um multiplexador 2:1 seleciona uma entre duas entradas de dados (D0 e D1) de acordo com um sinal seletor S, e encaminha essa entrada para a saída Y.

Equação booleana:
Y = S′·D0 + S·D1    (= (¬S ∧ D0) ∨ (S ∧ D1))
Se S=0 ⇒ Y:=D0 • Se S=1 ⇒ Y:=D1

Intuição

  • O seletor S “aponta” qual dado passa para a saída.
  • Quando S=0, o termo S′·D0 fica ativo e o outro zera ⇒ Y = D0.
  • Quando S=1, o termo S·D1 fica ativo e o outro zera ⇒ Y = D1.

Tabela-verdade

SD1D0Y
0x00
0x11
10x0
11x1

Implementações típicas

  • Com portas básicas: 1×inversor (7404) para S′, 2×AND (7408) para S′·D0 e S·D1, 1×OR (7432) para somar os termos.
  • CI dedicado: 74x157 (quádruplo MUX 2:1) — quatro canais 2:1 no mesmo chip.

Aplicações

  • Seleção de fonte de dados em CPUs (ex.: escolher entre registradores/ALU/constantes).
  • Roteamento de sinais em comunicação digital e interfaces.
  • Implementação de funções lógicas combinacionais via técnica de Shannon (decomposição por variáveis).
Extensão para 4:1: com duas seletoras S1,S0:
Y = S1′·S0′·D0 + S1′·S0·D1 + S1·S0′·D2 + S1·S0·D3
Na prática, pode-se construir um 4:1 com dois MUX 2:1 em cascata + 1 MUX 2:1 final.

Seleciona uma entre duas entradas

Definição

Entradas D0, D1, seletora S; saída Y = S′·D0 + S·D1.

SD1D0Y
0x00
0x11
10x0
11x1
TTL: implemente com 1 inversor (7404), 2 ANDs (7408) e 1 OR (7432).
Multiplexador 2:1 Dois AND alimentando um OR: topo recebe D0 e S′; base recebe D1 e S; saída Y. S D0 D1 S′ AND AND OR Y

Prática no simulador

Logisim Evolution / Tinkercad

Por que simular?

O simulador é onde conectamos a teoria à prática: você transforma a expressão booleana em um circuito, testa com a tabela-verdade e observa o comportamento (incluindo erros de ligação!). Essa etapa consolida a leitura de esquemas, a depuração de conexões e a validação de resultados.

Objetivo da atividade: implementar, testar e relacionar expressão ⇄ tabela-verdade ⇄ circuito, documentando o processo (prints + tabela obtida + breve aplicação real).

O que fazer (passo a passo)

  1. Half Adder: entradas A,B → S=A⊕B (XOR), C=A·B (AND).
    Faça: coloque 2 pins de entrada, uma porta XOR e uma AND; ligue S e C em LEDs. Teste 00, 01, 10, 11 e confira com a tabela.
  2. Full Adder: S=A⊕B⊕Cin; Cout=(A·B)+(B·Cin)+(A·Cin).
    Faça: implemente com 2 XOR, 2 AND e 1 OR (ou componha 2 Half Adders + OR). LEDs em S e Cout. Teste as 8 combinações.
  3. Paridade (3 bits): F=A⊕B⊕C (ímpar).
    Faça: encadeie XORs; LED acende quando a contagem de “1” for ímpar.
  4. Comparador (1 bit): F=XNOR(A,B)=A·B+A′·B′.
    Faça: use XNOR (ou AND/NOT/OR equivalentes). LED acende apenas se A=B.
  5. Multiplexador 2:1: Y=S′·D0 + S·D1.
    Faça: 1 inversor no S, 2 ANDs, 1 OR; comute D0/D1 pela seletora S. Teste os 4 casos.
build Dicas de montagem (Logisim / Tinkercad)

Logisim Evolution: use Wiring → Pin (entrada/saída), I/O → LED, e portas em Gates. Nomeie fios (Text) para A, B, Cin, etc. Ative/desative pins com a ferramenta “poke”. Use File → Export Image… para o print.

Tinkercad Circuits: botão/slide como entrada, LED com resistor de 220–330 Ω para GND, ICs lógicos se desejar (ou portas do painel). Confirme a orientação do LED (anodo/cátodo).

rule Como testar e validar
  • Varra todas as combinações de entrada (2 bits → 4 linhas; 3 bits → 8 linhas).
  • Registre os resultados observados e compare com a tabela-verdade teórica.
  • Se houver divergência, verifique: inversões (bolha), cruzamento de fios, pinos de entrada/saída trocados, ou LED ligado “ao contrário”.
warning Erros comuns
  • Esquecer o S′ no MUX (a seletora deve ser invertida para o ramo do D0).
  • Confundir XOR com OR no Half/Full Adder.
  • XNOR vs. NOT(XOR): no comparador, a igualdade é XNOR.
  • LED sem referência (Tinkercad) ou pino de saída configurado como entrada (Logisim).

Entregáveis

  • Print do circuito (cada um dos 5).
  • Tabela-verdade obtida (foto ou tabela digitada) com destaque para as linhas testadas.
  • Breve aplicação real (1–2 frases) — ex.: “Paridade: verificação simples de erro na transmissão de dados”.
Checklist (marque ao concluir):





Rubrica de avaliação (guia): correção lógica (40%), clareza do esquema (20%), testes/tabelas (20%), documentação & aplicação (20%).

Simulador embutido

Exercícios & Quiz

Fixação + desafio prático

Exercícios de fixação

  • Monte um Half Adder e explique com a tabela-verdade.
  • Detector de paridade para 4 bits: F = A⊕B⊕C⊕D.
  • Comparador de igualdade de 3 bits (saída 1 se todos iguais).
  • Detecte quando exatamente 2 entre A,B,C estão em 1.
  • LED acende se pelo menos 2 entre 3 entradas forem 1.

Quiz

(V/F) Um circuito combinacional depende do histórico das entradas.
Verdadeiro
Falso

Correto: Falso — combinacional não tem memória.

O Half Adder tem:
a) 1 entrada, 2 saídas
b) 2 entradas, 2 saídas
c) 2 entradas, 1 saída
d) 3 entradas, 2 saídas

Correto: b).

Soma no Half Adder é:
a) A AND B
b) A OR B
c) A XOR B
d) A NOR B

Correto: c) A ⊕ B.

Carry (somador) indica:
a) Resultado principal da soma
b) Que a soma ultrapassou 1 bit
c) Erro no circuito
d) Sempre zero

Correto: b).

Para que serve um detector de paridade em comunicação digital?
Resposta esperada: detectar erros simples (bit flip) verificando se a paridade recebida confere com a calculada.

Desafio prático

Monte um circuito de 4 entradas que acende um LED se a quantidade de bits em 1 for par (Dica: XOR em cascata e inverta se precisar par/ímpar).