Portas Lógicas

Módulo 1 · Aula 2 ~18 min de leitura Nível: Introdutório

Vídeo da aula estará disponível em breve

O que são portas lógicas

Portas lógicas são os blocos fundamentais de qualquer circuito digital. Cada porta implementa uma função booleana: recebe uma ou mais entradas binárias (0 ou 1) e produz uma saída binária. Toda a computação — de uma calculadora simples a um processador com bilhões de transistores — é construída a partir dessas portas.

Fisicamente, uma porta lógica é implementada com transistores. Um transistor CMOS funciona como uma chave controlada por tensão: quando a tensão no gate é alta, o transistor conduz (ou bloqueia, dependendo do tipo). Combinando transistores NMOS e PMOS, construímos cada porta lógica.

As sete portas fundamentais

NOT (Inversor)

A porta NOT tem uma entrada e inverte seu valor. É a porta mais simples — usa apenas 2 transistores (1 PMOS + 1 NMOS).

Tabela-verdade e símbolo

Tabela-verdade:         Símbolo:
  A │ NOT A                  ┌───┐
  ──┼───────              A──┤   ├○──Y
  0 │   1                    │ 1 │
  1 │   0                    └───┘

Expressão: Y = A̅  ou  Y = NOT A  ou  Y = ~A

AND

A saída é 1 somente quando todas as entradas são 1. Pense em duas chaves em série: a corrente só passa se ambas estiverem fechadas.

AND — 2 entradas

Tabela-verdade:         Símbolo:
  A  B │ A·B             A──┐     ┌──Y
  ─────┼─────            B──┤ AND ├──Y
  0  0 │  0                  └─────┘
  0  1 │  0
  1  0 │  0              Expressão: Y = A · B
  1  1 │  1

OR

A saída é 1 quando pelo menos uma entrada é 1. Duas chaves em paralelo: basta uma estar fechada.

OR — 2 entradas

Tabela-verdade:         Símbolo:
  A  B │ A+B             A──┐     ┌──Y
  ─────┼─────            B──┤ OR  ├──Y
  0  0 │  0                  └─────┘
  0  1 │  1
  1  0 │  1              Expressão: Y = A + B
  1  1 │  1

NAND (NOT-AND)

O inverso da AND. Fundamental na prática porque é uma porta universal — qualquer outra porta pode ser construída usando apenas NANDs.

NAND — 2 entradas

Tabela-verdade:          Símbolo:
  A  B │ (A·B)̅           A──┐      ┌○──Y
  ─────┼──────           B──┤ NAND ├○──Y
  0  0 │  1                  └──────┘
  0  1 │  1
  1  0 │  1              Expressão: Y = (A · B)̅
  1  1 │  0

NAND usa apenas 4 transistores CMOS — menos que AND (6)!

NOR (NOT-OR)

O inverso da OR. Também é uma porta universal.

NOR — 2 entradas

Tabela-verdade:          Símbolo:
  A  B │ (A+B)̅           A──┐     ┌○──Y
  ─────┼──────           B──┤ NOR ├○──Y
  0  0 │  1                  └─────┘
  0  1 │  0
  1  0 │  0              Expressão: Y = (A + B)̅
  1  1 │  0

XOR (OR Exclusivo)

A saída é 1 quando as entradas são diferentes. Essencial para comparação e aritmética binária.

XOR — 2 entradas

Tabela-verdade:          Símbolo:
  A  B │ A⊕B             A──┐     ┌──Y
  ─────┼─────            B──┤ XOR ├──Y
  0  0 │  0                  └─────┘
  0  1 │  1
  1  0 │  1              Expressão: Y = A ⊕ B = A·B̅ + A̅·B
  1  1 │  0

XNOR (NOR Exclusivo)

A saída é 1 quando as entradas são iguais. É o inverso do XOR — funciona como detector de igualdade.

XNOR — 2 entradas

Tabela-verdade:           Símbolo:
  A  B │ (A⊕B)̅           A──┐      ┌○──Y
  ─────┼──────            B──┤ XNOR ├○──Y
  0  0 │  1                   └──────┘
  0  1 │  0
  1  0 │  0               Expressão: Y = A ⊙ B = A·B + A̅·B̅
  1  1 │  1

Portas universais: NAND e NOR

NAND e NOR são chamadas portas universais porque qualquer função lógica pode ser implementada usando apenas uma delas. Na indústria, chips são frequentemente fabricados com apenas um tipo de porta para simplificar o processo.

Construindo portas com NAND

NOT a partir de NAND:
  Conecte ambas entradas juntas:
  Y = (A · A)̅ = A̅

AND a partir de NAND:
  Dois NANDs: primeiro faz NAND, segundo inverte:
  Y = ((A · B)̅)̅ = A · B

OR a partir de NAND:
  Inverta cada entrada com NAND, depois NAND os resultados:
  Y = (A̅ · B̅)̅ = A + B   (Teorema de De Morgan!)

Circuito OR com NANDs:
  A──┤NAND├──┐
  A──┘        ├──┤NAND├──Y
  B──┤NAND├──┘
  B──┘

Por que NAND domina a indústria? Em tecnologia CMOS, uma porta NAND usa 4 transistores — o mesmo que um inversor seria com buffer. Uma porta AND precisa de 6 transistores (NAND + NOT). Por isso, circuitos reais são projetados com NANDs e depois otimizados. Memória Flash (SSDs, pendrives) também é baseada em portas NAND — daí o nome "NAND Flash".

Transistores: o nível físico

Cada porta lógica é construída com transistores MOSFET. Existem dois tipos complementares:

NMOS — conduz quando o gate está em nível alto (1). Conecta à terra (GND).
PMOS — conduz quando o gate está em nível baixo (0). Conecta ao VDD (alimentação).

Inversor CMOS (NOT)

        VDD
         │
      ┌──┴──┐
  A──┤ PMOS ├──┬── Y
      └──┬──┘  │
         │     │
      ┌──┴──┐  │
  A──┤ NMOS ├──┘
      └──┬──┘
         │
        GND

Quando A = 0: PMOS conduz, NMOS bloqueia → Y = VDD = 1
Quando A = 1: NMOS conduz, PMOS bloqueia → Y = GND = 0

Cada porta mais complexa segue o mesmo princípio: uma rede PMOS (pull-up) conectada ao VDD e uma rede NMOS (pull-down) conectada ao GND, organizadas para que exatamente uma das redes conduza para cada combinação de entrada.

Operadores lógicos em programação

As portas lógicas têm correspondência direta com operadores em linguagens de programação:

Correspondência hardware ↔ software

Porta    │ C / Python      │ Verilog   │ Exemplo
─────────┼─────────────────┼───────────┼──────────────────
AND      │ & (bitwise)     │ &         │ flags & 0x0F
OR       │ | (bitwise)     │ |         │ flags | MASK
NOT      │ ~ (bitwise)     │ ~         │ ~flags
XOR      │ ^ (bitwise)     │ ^         │ a ^ b
NAND     │ ~(a & b)        │ ~(&)      │ !(a && b)
NOR      │ ~(a | b)        │ ~(|)      │ !(a || b)

Cuidado: && e || são operadores LÓGICOS (retornam bool)
         & e | são operadores BITWISE (operam bit a bit)

No harness.os

Portas lógicas aparecem no harness.os de formas surpreendentemente diretas:

Feature flags como AND/OR — "Libere o feature X se o usuário é admin AND está no grupo beta" é uma porta AND sobre condições. O sistema de rules no harness avalia combinações lógicas de condições para determinar comportamento.
Bitmasks para permissões — operações como permissions & WRITE_BIT usam AND bitwise para verificar se um bit específico está ativo. Isso é literalmente uma porta AND operando no software.
XOR para checksums — verificação de integridade de dados frequentemente usa XOR. Se data ^ checksum == 0, os dados estão íntegros.
Portas universais e composição — assim como NAND pode construir qualquer circuito, um conjunto mínimo de operações primitivas no harness pode compor qualquer regra de negócio. É o mesmo princípio de universalidade.

Exercícios

Tabela-verdade: Construa a tabela-verdade completa para a expressão F = (A · B) + (B̅ · C). A expressão tem 3 variáveis, então a tabela terá 8 linhas.
NAND universal: Desenhe o circuito que implementa a função XOR usando apenas portas NAND. Dica: XOR = A·B̅ + A̅·B. Primeiro implemente com AND, OR e NOT, depois substitua cada porta por NANDs equivalentes.
Contagem de transistores: Uma porta AND de 2 entradas usa 6 transistores CMOS (4 para NAND + 2 para NOT). Quantos transistores são necessários para implementar F = A · B + C · D usando portas básicas? E se usássemos apenas NANDs?

Resumo

Verifique seu entendimento

Qual porta lógica produz saída 1 somente quando suas entradas são diferentes?

NAND
NOR
XOR
XNOR

Sete portas fundamentais: NOT, AND, OR, NAND, NOR, XOR, XNOR
Portas são implementadas com transistores CMOS (PMOS + NMOS)
NAND e NOR são portas universais — qualquer circuito pode ser construído com apenas uma delas
NAND é preferida na indústria por usar menos transistores que AND
Operadores bitwise em software (&, |, ^, ~) são as mesmas operações das portas lógicas

Aula anterior 1.1 Sistemas de Numeração Próxima aula 1.3 Álgebra Booleana e Karnaugh