Circuitos Combinacionais na Prática
Vídeo da aula estará disponível em breve
Comparador de magnitude
Um comparador determina a relação entre dois números binários A e B, gerando três saídas: A>B, A=B, A<B. Para comparar números de 1 bit:
Comparador de 1 bit
Tabela-verdade:
A B │ A>B A=B A<B
─────┼─────────────────
0 0 │ 0 1 0
0 1 │ 0 0 1
1 0 │ 1 0 0
1 1 │ 0 1 0
Expressões:
A>B = A · B̅
A=B = A ⊙ B = (A ⊕ B)̅ (XNOR — igualdade!)
A<B = A̅ · BPara comparadores de n bits, a estratégia é comparar bit a bit do mais significativo para o menos significativo. Se o MSB difere, a comparação está decidida. Se são iguais, passamos ao próximo bit:
Comparador de 4 bits — cascateamento
Comparar A[3:0] com B[3:0]:
Eᵢ = Aᵢ ⊙ Bᵢ (igualdade do bit i)
A=B = E₃ · E₂ · E₁ · E₀ (todos os bits iguais)
A>B = A₃·B̅₃
+ E₃ · A₂·B̅₂
+ E₃·E₂ · A₁·B̅₁
+ E₃·E₂·E₁ · A₀·B̅₀
A<B = A̅₃·B₃
+ E₃ · A̅₂·B₂
+ E₃·E₂ · A̅₁·B₁
+ E₃·E₂·E₁ · A̅₀·B₀
O CI 7485 implementa um comparador de 4 bits com
entradas de cascateamento para construir comparadores maiores.Gerador e verificador de paridade
A paridade é a técnica mais simples de detecção de erros. Adicionamos um bit extra ao dado de forma que o número total de 1s seja par (paridade par) ou ímpar (paridade ímpar).
Paridade
Paridade par — número total de 1s (incluindo bit de paridade) é par:
Dado: 1011001 → conta de 1s = 4 (par) → bit de paridade = 0
Dado: 1011011 → conta de 1s = 5 (ímpar) → bit de paridade = 1
Gerador de paridade par para 4 bits:
P = D₃ ⊕ D₂ ⊕ D₁ ⊕ D₀
Verificador de paridade (recebe dado + bit P):
Erro = D₃ ⊕ D₂ ⊕ D₁ ⊕ D₀ ⊕ P
Se Erro = 1, houve um erro de transmissão (1 bit invertido)
Se Erro = 0, dado provavelmente íntegro
Limitação: detecta erros de 1 bit, mas NÃO corrige.
Para correção, precisamos de códigos como Hamming.
Paridade na memória RAM
Memória ECC (Error-Correcting Code) em servidores usa uma versão avançada de paridade baseada em código de Hamming. Cada 64 bits de dados armazenam 8 bits extras de ECC que permitem detectar erros de 2 bits e corrigir erros de 1 bit automaticamente. É por isso que servidores usam módulos de memória ECC e computadores domésticos não.
ROM como circuito combinacional
Uma ROM (Read-Only Memory) pode ser vista como um circuito combinacional de propósito geral. As linhas de endereço são as entradas, e os dados armazenados em cada posição são as saídas. Qualquer tabela-verdade pode ser implementada gravando os valores na ROM.
ROM como tabela-verdade
ROM com 3 bits de endereço e 2 bits de dado:
(equivale a duas funções de 3 variáveis)
Endereço │ Dado
A₂ A₁ A₀ │ D₁ D₀
─────────┼───────
0 0 0 │ 0 1 ← posição 0: armazena 01
0 0 1 │ 1 0 ← posição 1: armazena 10
0 1 0 │ 1 1 ← posição 2: armazena 11
0 1 1 │ 0 0 ← posição 3: armazena 00
1 0 0 │ 0 1 ← posição 4: armazena 01
1 0 1 │ 1 1 ← posição 5: armazena 11
1 1 0 │ 1 0 ← posição 6: armazena 10
1 1 1 │ 0 0 ← posição 7: armazena 00
Isso implementa simultaneamente:
D₁ = f₁(A₂, A₁, A₀) = Σm(1, 2, 5, 6)
D₀ = f₂(A₂, A₁, A₀) = Σm(0, 2, 4, 5)
Vantagem: não precisa de projeto lógico! Basta programar a tabela.
Desvantagem: tamanho cresce exponencialmente com as entradas (2ⁿ).PLA (Programmable Logic Array)
Uma PLA é uma estrutura programável que implementa funções booleanas na forma de soma de produtos. Diferente da ROM (que implementa todos os mintermos), a PLA implementa apenas os termos necessários, economizando área.
Estrutura de uma PLA
Plano AND (programável):
Gera os termos-produto necessários
Plano OR (programável):
Combina termos-produto nas funções de saída
Exemplo — duas funções com termos compartilhados:
F₁ = A·B̅ + A̅·B·C
F₂ = A·B̅ + B·C
Plano AND Plano OR
A ────┐ ┌── A·B̅ ──────────┐── F₁
A̅ ────┤ ├── A̅·B·C ────────┤
B ────┤ ├── B·C ──────┐ │── F₂
B̅ ────┤ │ └─┘
C ────┘ └───────────────────
Termos-produto: 3 (A·B̅ é compartilhado entre F₁ e F₂)
ROM equivalente precisaria de 2³ = 8 linhas.
Variantes:
PAL: plano AND programável, plano OR fixo
PLA: ambos programáveis
FPGA: milhares de blocos lógicos programáveis
De PLA a FPGA
FPGAs (Field-Programmable Gate Arrays) são a evolução moderna da PLA. Contêm milhares de lookup tables (LUTs) — cada uma é essencialmente uma ROM pequena (geralmente 4-6 entradas) — conectadas por uma malha de roteamento programável. Processadores de rede, aceleradores de IA e prototipagem de chips usam FPGAs intensivamente.
Projeto completo: display de 7 segmentos
Um exemplo clássico que combina vários conceitos: projetar o decodificador BCD para display de 7 segmentos. O circuito recebe um dígito BCD (4 bits) e ativa os segmentos corretos para exibir o número.
Display de 7 segmentos
Segmentos nomeados de 'a' a 'g':
─a─
│ │
f b
│ │
─g─
│ │
e c
│ │
─d─
Tabela BCD → Segmentos (1 = segmento aceso):
BCD │ Dígito │ a b c d e f g
─────┼────────┼───────────────────────
0000 │ 0 │ 1 1 1 1 1 1 0
0001 │ 1 │ 0 1 1 0 0 0 0
0010 │ 2 │ 1 1 0 1 1 0 1
0011 │ 3 │ 1 1 1 1 0 0 1
0100 │ 4 │ 0 1 1 0 0 1 1
0101 │ 5 │ 1 0 1 1 0 1 1
0110 │ 6 │ 1 0 1 1 1 1 1
0111 │ 7 │ 1 1 1 0 0 0 0
1000 │ 8 │ 1 1 1 1 1 1 1
1001 │ 9 │ 1 1 1 1 0 1 1
Entradas 1010-1111 são don't cares (BCD inválido).
Para o segmento 'a' (usar K-map com don't cares):
a = Σm(0,2,3,5,6,7,8,9) + d(10,11,12,13,14,15)
Simplificado: a = A + C + B·D + B̅·D̅
Cada segmento requer um K-map separado.
Na prática, usa-se o CI 7447 (decodificador BCD→7seg).No harness.os
Circuitos combinacionais práticos mapeiam diretamente para padrões de software:
- Comparadores em validação — toda validação de dados ("valor está dentro da faixa?", "versão é compatível?") é um comparador de magnitude em software. O harness compara versões de schema, prioridades de tarefas e timestamps.
- Paridade e checksums — integridade de dados no banco do harness usa checksums (CRC, SHA) que são versões sofisticadas da verificação de paridade. O XOR em cadeia é a base de muitos algoritmos de hash.
- ROM como lookup table — tabelas de configuração no harness são ROMs conceituais. Dado um tipo de projeto e uma fase, a "ROM" retorna a configuração aplicável. Cache de configuração funciona exatamente assim.
- PLA e regras programáveis — o sistema de rules no harness é uma PLA conceitual: termos de condição (plano AND) combinados em regras (plano OR). Regras compartilham condições assim como a PLA compartilha termos-produto.
Exercícios
- Comparador: Projete um comparador de 2 bits (A₁A₀ vs B₁B₀). Escreva as expressões para as três saídas (A>B, A=B, A<B) e simplifique usando álgebra booleana ou K-maps.
- Paridade: Um sistema transmite bytes (8 bits) com paridade par. O receptor recebe o byte 10110101 com bit de paridade P=1. Houve erro? Justifique.
- 7 segmentos: Usando um K-map de 4 variáveis com don't cares, derive a expressão simplificada para o segmento 'g' do display de 7 segmentos (segmento do meio). O segmento 'g' acende para os dígitos: 2, 3, 4, 5, 6, 8, 9.
Resumo
Verifique seu entendimento
Qual é a principal vantagem de uma PLA em relação a uma ROM para implementar funções booleanas?
- Comparadores de magnitude determinam A>B, A=B, A<B usando XNOR para igualdade
- Paridade (XOR em cadeia) detecta erros de 1 bit; ECC corrige
- ROM implementa qualquer tabela-verdade, mas cresce exponencialmente (2ⁿ posições)
- PLA é mais eficiente: plano AND + plano OR programáveis, termos compartilhados
- FPGA é a evolução moderna: milhares de LUTs programáveis
- Display de 7 segmentos: exemplo clássico que combina K-maps, don't cares e decodificação