Circuitos lógicos

Somando 1 + 1 em hardware

Quando você soma dois números no computador, a CPU executa adição bit a bit. O bit menos significativo é somado primeiro; se produz carry (vai-um), ele alimenta a próxima posição. Esse encadeamento é um somador ripple-carry.

Um half adder soma 2 bits e produz soma + carry. Um full adder soma 3 bits (dois operandos + carry de entrada) — é o que permite encadear N full adders para somar números de N bits.

Full adder interativo

Clique em A, B e Cin para alternar os valores. Os fios verdes carregam 1; cinzas, 0. Veja como o carry se propaga pelo circuito.

Half adder e Full adder

// Half Adder: soma 2 bits (sem carry de entrada)
S = A XOR B     // bit de soma
C = A AND B     // carry out

// Full Adder: soma 3 bits (A, B, carry de entrada Cin)
// Construído com 2 Half Adders + 1 OR
S1  = A   XOR B    // HA1: XOR
C1  = A   AND B    // HA1: AND
Sum = S1  XOR Cin  // HA2: XOR — bit de resultado
C2  = S1  AND Cin  // HA2: AND
Cout = C1 OR  C2   // carry final

// Encadeando Full Adders: somador ripple-carry de N bits
// FA[0].Cin = 0, FA[i].Cin = FA[i-1].Cout
// Desvantagem: carry se propaga em série → lento para N grande
// Solução: carry-lookahead adder (calcula todos os carries em paralelo)

Descrevendo hardware em Verilog

// Verilog: descrever hardware em código
// (sintetiza direto para portas lógicas em FPGA/ASIC)

module full_adder(
    input  a, b, cin,
    output sum, cout
);
    wire s1, c1, c2;

    xor (s1,  a,  b);    // HA1
    and (c1,  a,  b);
    xor (sum, s1, cin);  // HA2
    and (c2,  s1, cin);
    or  (cout, c1, c2);  // OR final
endmodule

// Ripple-carry adder de 4 bits usando o módulo acima:
module adder4(
    input  [3:0] a, b,
    output [3:0] sum,
    output       cout
);
    wire [3:0] c;
    full_adder fa0 (.a(a[0]), .b(b[0]), .cin(1'b0),  .sum(sum[0]), .cout(c[0]));
    full_adder fa1 (.a(a[1]), .b(b[1]), .cin(c[0]),   .sum(sum[1]), .cout(c[1]));
    full_adder fa2 (.a(a[2]), .b(b[2]), .cin(c[1]),   .sum(sum[2]), .cout(c[2]));
    full_adder fa3 (.a(a[3]), .b(b[3]), .cin(c[2]),   .sum(sum[3]), .cout(cout));
endmodule

Simulador de circuitos

Mini projeto: simule o full adder em Python. Represente cada fio como uma variável booleana. Implemente as funções half_adder(a, b) e full_adder(a, b, cin) usando apenas AND, OR, XOR (ou &, |, ^). Gere e imprima a tabela-verdade completa.

Projeto principal: construa um simulador de circuitos genérico. Represente um circuito como um grafo de portas e fios. Leia a topologia de um arquivo JSON e avalie a saída para qualquer entrada. Teste com: half adder, full adder, multiplexador 2:1, e decodificador 2-para-4.

Desafio extra: implemente o algoritmo de síntese de circuitos: dada uma tabela-verdade de N entradas, gere a expressão SOP mínima (via Quine-McCluskey ou K-map) e depois converta para um circuito de portas NAND apenas (usando De Morgan). Verifique que a saída é equivalente à tabela original.

Teste sua intuição

Onde você encontra isso