Lógica digital na DE1-SoC (2/6): tabelas-verdade, SOP/POS, mapas de Karnaugh e um multiplexador

Na Lição 1, você ligou portas individuais às chaves. Projetos reais começam um nível acima: primeiro se decide o que o circuito deve fazer, normalmente por meio de uma tabela-verdade, e depois se encontra uma rede de portas que produza esse comportamento. Nesta lição, você obterá a mesma função por dois caminhos e depois a tornará menor.

A função dos dois primeiros exercícios é F(C,B,A), com três entradas. Você ligará SW[0]=A, SW[1]=B, SW[2]=C e mostrará o resultado em LEDR[0]. A tabela abaixo segue a ordem de contagem binária C B A, de 000 a 111:

- Linha 0: C B A = 0 0 0 → F=0
- Linha 1: C B A = 0 0 1 → F=1
- Linha 2: C B A = 0 1 0 → F=0
- Linha 3: C B A = 0 1 1 → F=1
- Linha 4: C B A = 1 0 0 → F=1
- Linha 5: C B A = 1 0 1 → F=0
- Linha 6: C B A = 1 1 0 → F=1
- Linha 7: C B A = 1 1 1 → F=0

F vale 1 em quatro das oito linhas e 0 nas outras quatro. Identifique-as diretamente na tabela antes de responder. Essa divisão orienta toda a lição: as linhas com F=1 produzem a soma de produtos, e as linhas com F=0 produzem o produto de somas. Mantenha a tabela à vista nos dois exercícios.

Lembre-se das convenções da placa usadas na Lição 1: uma chave para cima representa 1 lógico, e LEDR é ativa em nível alto, portanto o LED acende quando a saída vale 1. Os circuitos desta lição são puramente combinacionais: a saída depende apenas das posições atuais das chaves, sem sinal de clock.

Mintermo. Um *mintermo* é um único termo AND (produto) construído com todas as entradas, cada uma aparecendo uma vez, direta ou negada, e que vale 1 em exatamente uma linha da tabela-verdade. Para três entradas, há oito mintermos. A linha 1 é C=0, B=0, A=1, portanto seu mintermo é (~C & ~B & A), que vale 1 somente nessa combinação.

Soma canônica de produtos (SOP). Para construir F, aplique OR aos mintermos de todas as linhas em que F=1. Como cada mintermo vale 1 apenas em sua própria linha, o OR vale 1 precisamente nas linhas desejadas. Use a tabela para escrever os quatro mintermos de F. Não pule a forma completa: você a testará na placa antes da forma reduzida.

Minimização com mapa de Karnaugh. Um *mapa de Karnaugh* reorganiza a tabela-verdade para que células fisicamente adjacentes difiram em apenas uma entrada. Quando dois 1s adjacentes formam um grupo, a variável que *muda* entre eles não afeta esse par e pode ser eliminada, deixando um termo menor. A figura marca os quatro 1s e dois agrupamentos possíveis. Em cada grupo, identifique qual entrada permanece fixa, qual muda e qual termo de produto resta.

Agora implemente a função na placa real. Execute primeiro a SOP canônica, confira as oito linhas e depois edite o mesmo código inicial para testar a expressão mínima obtida pelo mapa.

O módulo abaixo está intencionalmente incompleto. Substitua TODO_CANONICAL_SOP_EXPRESSION por sua SOP completa. Depois de verificá-la, troque a mesma linha pela expressão minimizada e sintetize novamente.

// Lição 2 - Exercício 1-B: código inicial para soma de produtos (SOP)
// F(C,B,A): use as linhas da tabela em que F=1. SW[0]=A, SW[1]=B, SW[2]=C.
// Preencha primeiro a SOP canônica. Depois substitua pela expressão minimizada no mapa.
module leds_mirror(SW, LEDR);
    input  [9:0] SW;
    output [9:0] LEDR;

    wire A = SW[0];
    wire B = SW[1];
    wire C = SW[2];

    // Passo 1: SOP canônica. Escreva um termo de produto para cada linha F=1.
    assign LEDR[0] = TODO_CANONICAL_SOP_EXPRESSION;

    // Passo 2: depois de verificar a forma canônica, substitua a linha acima
    // pela expressão minimizada no mapa de Karnaugh e sintetize novamente.

    assign LEDR[9:1] = 9'b0;
endmodule

Envie sua evidência. Faça uma captura da câmera com a expressão minimizada executando em uma linha para a qual sua tabela prevê F=1. Informe a linha C B A escolhida.

> Bônus opcional (sem envio obrigatório). O Quartus informa quantos elementos lógicos um projeto usa. Se esse relatório aparecer em sua sessão, sintetize as formas canônica e minimizada e compare as contagens. Esse relatório não é garantido, por isso a exploração não faz parte da evidência obrigatória.

A SOP construiu F a partir das linhas com 1. O produto de somas (POS) constrói a mesma F a partir das linhas com 0.

Maxtermo. Um *maxtermo* é um único termo OR (soma) que usa todas as entradas, diretas ou negadas, e vale 0 em exatamente uma linha. É a imagem espelhada de um mintermo. Na linha 0 (C=0, B=0, A=0), o maxtermo é (A | B | C): esse OR vale 0 apenas quando as três entradas valem 0.

Produto canônico de somas. Aplique AND aos maxtermos de todas as linhas em que F=0. Cada maxtermo força a saída a 0 em sua própria linha e a deixa em 1 nas demais. Identifique na tabela as quatro linhas com F=0 e escreva os quatro maxtermos.

// Lição 2 - Exercício 1-C: código inicial para produto de somas (POS)
// Mesma F(C,B,A). Use as linhas em que F=0 para escrever os maxtermos.
module leds_mirror(SW, LEDR);
    input  [9:0] SW;
    output [9:0] LEDR;

    wire A = SW[0];
    wire B = SW[1];
    wire C = SW[2];

    // POS canônica: um termo de soma para cada linha F=0, todos ligados por AND.
    assign LEDR[0] = TODO_CANONICAL_POS_EXPRESSION;

    assign LEDR[9:1] = 9'b0;
endmodule

Um multiplexador (MUX) é um seletor: encaminha uma entre várias entradas de dados para uma única saída, escolhida por linhas de seleção. Um MUX 4 para 1 tem quatro entradas de dados e duas linhas de seleção, pois dois bits escolhem entre 2^2 = 4 entradas. Ele se comporta como uma chave rotativa: o valor de seleção define qual linha chega à saída.

Mapeamento de pinos deste exercício:

- Entradas de dados: SW[3]=D3, SW[2]=D2, SW[1]=D1, SW[0]=D0
- Linhas de seleção: SW[5]=S1, SW[4]=S0
- Saída: LEDR[0] = Y

O valor {S1, S0} escolhe 00 → D0, 01 → D1, 10 → D2, 11 → D3. O módulo usa case dentro de always @(*). O ramo default não é decorativo: se alguma combinação deixasse Y sem atribuição, o sintetizador inferiria um latch para lembrar o valor anterior, transformando lógica combinacional em memória acidental. Atribuir Y em todos os caminhos garante um valor definido e evita o latch.

// Lição 2 - Exercício 1-D: multiplexador 4 para 1
// Dados: SW[3]=D3, SW[2]=D2, SW[1]=D1, SW[0]=D0
// Seleção: SW[5]=S1, SW[4]=S0. Saída: LEDR[0]=Y.
module leds_mirror(SW, LEDR);
    input  [9:0] SW;
    output [9:0] LEDR;

    wire D0 = SW[0], D1 = SW[1], D2 = SW[2], D3 = SW[3];
    wire S0 = SW[4], S1 = SW[5];

    reg Y;
    always @(*) begin
        case ({S1, S0})
            2'b00:   Y = TODO_SELECTED_INPUT_00;
            2'b01:   Y = TODO_SELECTED_INPUT_01;
            2'b10:   Y = TODO_SELECTED_INPUT_10;
            2'b11:   Y = TODO_SELECTED_INPUT_11;
            default: Y = 1'b0;   // default evita inferir um latch
        endcase
    end

    assign LEDR[0]   = Y;
    assign LEDR[9:1] = 9'b0;
endmodule

Envie sua evidência. Faça uma captura da câmera com dados SW[3:0] = 1010 e seleção S1:S0 = 01 (SW[4] para cima, SW[5] para baixo). Isso seleciona D1 = 1, portanto LEDR[0] deve estar aceso.

Este exercício é opcional. Se houver tempo, ele leva a saída de um único LED para os displays formatados de sete segmentos.

Um display de sete segmentos possui barras a a g que formam os algarismos. Na DE1-SoC, cada display HEX é ativo em nível baixo, e a ordem dos bits é {g, f, e, d, c, b, a}: um segmento acende quando seu bit recebe 0. Assim, o algarismo 0, com a,b,c,d,e,f acesos e g apagado, usa 7'b1000000.

O projeto lê SW[3:0] como um valor de 0..15, mostra as unidades em HEX0 e as dezenas (0 ou 1) em HEX1. Para controlar HEX1, é necessário adicionar output [6:0] HEX1 à lista de portas do módulo, pois o projeto inicial expõe apenas HEX0. O módulo abaixo já declara ambas as saídas.

// Lição 2 - Exercício 1-E (opcional): decodificador decimal de dois dígitos
// Complete os padrões ativos em nível baixo e as equações de dezenas/unidades.
module leds_mirror(SW, HEX0, HEX1);
    input  [9:0] SW;        // SW[3:0] = valor 0..15
    output [6:0] HEX0;      // unidades
    output [6:0] HEX1;      // dezenas (0 ou 1)

    wire [4:0] v = {1'b0, SW[3:0]};

    function [6:0] seg;
        input [3:0] d;
        case (d)
            4'd0: seg = 7'b1000000;
            4'd1: seg = TODO_SEGMENT_PATTERN_1;
            4'd2: seg = TODO_SEGMENT_PATTERN_2;
            4'd3: seg = TODO_SEGMENT_PATTERN_3;
            4'd4: seg = TODO_SEGMENT_PATTERN_4;
            4'd5: seg = TODO_SEGMENT_PATTERN_5;
            4'd6: seg = TODO_SEGMENT_PATTERN_6;
            4'd7: seg = TODO_SEGMENT_PATTERN_7;
            4'd8: seg = TODO_SEGMENT_PATTERN_8;
            4'd9: seg = TODO_SEGMENT_PATTERN_9;
            default: seg = 7'b1111111;
        endcase
    endfunction

    wire [3:0] tens = TODO_TENS_DIGIT;
    wire [3:0] ones = TODO_ONES_DIGIT;

    assign HEX0 = seg(ones);
    assign HEX1 = seg(tens);
endmodule