Lógica digital en la DE1-SoC (2/6): tablas de verdad, SOP/POS, mapas de Karnaugh y multiplexores

En la Lección 1 conectaste puertas individuales a interruptores. Los diseños reales empiezan un nivel más arriba: decides qué debe hacer un circuito, normalmente mediante una tabla de verdad, y después buscas una red de puertas que produzca ese comportamiento. En esta lección trabajarás una función desde varias formas y luego la harás más pequeña.

La función de los dos primeros ejercicios es F(C,B,A), una función de tres entradas. Conectarás SW[0]=A, SW[1]=B, SW[2]=C, y mostrarás el resultado en LEDR[0]. Esta es su tabla de verdad. Las filas están en orden de conteo binario C B A, desde 000 hasta 111:

Tabla de verdad de F(C,B,A), en orden binario:

- Fila 0: C B A = 0 0 0 -> F=0
- Fila 1: C B A = 0 0 1 -> F=1
- Fila 2: C B A = 0 1 0 -> F=0
- Fila 3: C B A = 0 1 1 -> F=1
- Fila 4: C B A = 1 0 0 -> F=1
- Fila 5: C B A = 1 0 1 -> F=0
- Fila 6: C B A = 1 1 0 -> F=1
- Fila 7: C B A = 1 1 1 -> F=0

F vale 1 en cuatro de las ocho filas y 0 en las otras cuatro. Léelo en la tabla antes de responder. Esa separación organiza toda la lección: las filas donde F=1 dan la suma de productos, y las filas donde F=0 dan el producto de sumas. Mantén esta tabla a la vista: todo lo que sigue vuelve a ella.

Recuerda las convenciones de la placa que usaste en la Lección 1: un interruptor arriba es lógica 1, y LEDR es activo en alto, así que el LED se enciende cuando la salida vale 1. Estos ejercicios son puramente combinacionales: la salida depende solo de la posición actual de los interruptores, por lo que no hace falta declarar reloj.

Mintérmino. Un *mintérmino* es un AND (producto) construido con todas las entradas, cada una normal o negada, que vale 1 en una sola fila de la tabla de verdad. Para tres entradas hay ocho mintérminos, uno por fila. La fila 1 es C=0, B=0, A=1, así que su mintérmino es (~C & ~B & A): este producto solo vale 1 cuando C=0, B=0 y A=1.

Suma de productos canónica (SOP). Para construir F, une con OR los mintérminos de todas las filas donde F=1. Usa la tabla de verdad anterior para escribir tú los cuatro mintérminos de F. No saltes esta forma completa: la probarás en la placa antes de probar la forma reducida.

Minimización con mapa de Karnaugh. Un *mapa K* reorganiza la tabla de verdad para que las celdas adyacentes difieran en una sola entrada. Cuando dos 1 adyacentes se agrupan, la variable que cambia dentro del grupo no importa para ese par y desaparece, dejando un término más pequeño. El diagrama de abajo marca las cuatro celdas con 1 y muestra dos grupos posibles. Tu trabajo es leer cada grupo: decidir qué entrada se mantiene, cuál cambia y qué término producto queda.

Ahora lleva la función a la placa real. Ejecutarás primero la SOP canónica, verificarás las ocho filas y después editarás la misma plantilla para probar la expresión mínima que obtuviste con el mapa K.

El módulo de abajo está incompleto a propósito. Sustituye TODO_CANONICAL_SOP_EXPRESSION por tu SOP completa. Después de comprobarla en la placa, sustituye esa misma línea por tu expresión minimizada y sintetiza de nuevo.

// Leccion 2 - Ejercicio 1-B: plantilla de suma de productos (SOP)
// F(C,B,A): usa las filas de la tabla de verdad donde F=1. SW[0]=A, SW[1]=B, SW[2]=C.
// Completa primero la SOP canonica. Despues sustituyela por tu expresion minimizada con el mapa K.
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];

    // Paso 1: SOP canonica. Escribe un termino producto por cada fila F=1.
    assign LEDR[0] = TODO_CANONICAL_SOP_EXPRESSION;

    // Paso 2: despues de verificar la forma canonica, sustituye la linea anterior por
    // tu expresion minimizada con el mapa K y sintetiza de nuevo.

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

Sube tu evidencia. Captura una imagen de la cámara con tu expresión minimizada en cualquier fila donde tu tabla prediga F=1. En el texto, indica qué fila C B A elegiste.

> Bonus opcional (no requiere entrega). Quartus informa cuántos elementos lógicos usa un diseño. Si tu sesión muestra ese informe, sintetiza tu SOP canónica y tu expresión minimizada y compara sus elementos lógicos. Trátalo como exploración; el informe de recursos no siempre aparece igual en todas las sesiones.

La SOP construye F desde sus filas con 1. El producto de sumas (POS) construye la misma F desde sus filas con 0.

Maxtérmino. Un *maxtérmino* es un OR (suma) con todas las entradas, normales o negadas, que vale 0 en una sola fila. Es el espejo de un mintérmino. Para la fila 0 (C=0, B=0, A=0), el maxtérmino es (A | B | C): este OR solo vale 0 cuando A, B y C son todos 0, y vale 1 en las demás filas.

Producto de sumas canónico. Une con AND el maxtérmino de cada fila donde F=0. Cada maxtérmino fuerza la salida a 0 en su propia fila y la deja a 1 en las demás, así que el AND de todos ellos vale 0 exactamente en las filas F=0. Lee esas filas en la tabla de verdad y escribe tú los cuatro maxtérminos.

// Leccion 2 - Ejercicio 1-C: plantilla de producto de sumas (POS)
// Misma F(C,B,A). Usa las filas de la tabla donde F=0 para escribir los maxterminos.
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 canonica: un termino suma por cada fila F=0, todos unidos con AND.
    assign LEDR[0] = TODO_CANONICAL_POS_EXPRESSION;

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

Un multiplexor (MUX) es un selector: enruta una de varias entradas de datos hacia una sola salida, elegida por unas líneas de selección. Un MUX 4 a 1 tiene cuatro entradas de datos y necesita dos líneas de selección, porque dos bits eligen entre 2^2 = 4 entradas. Se comporta como un conmutador giratorio: el valor de selección decide qué línea de datos queda conectada a la salida.

La asignación de pines de este ejercicio, escrita de forma explícita para evitar ambigüedad en el orden de bits, es:

- Entradas de datos: SW[3]=D3, SW[2]=D2, SW[1]=D1, SW[0]=D0
- Líneas de selección: SW[5]=S1, SW[4]=S0
- Salida: LEDR[0] = Y

El valor de selección {S1, S0} elige la línea de datos: 00 -> D0, 01 -> D1, 10 -> D2, 11 -> D3. El módulo usa una instrucción case dentro de always @(*). La rama default no está de adorno: en un bloque combinacional always, si alguna combinación de entrada dejara Y sin asignar, el sintetizador inferiría un latch para "recordar" el valor anterior. Eso convertiría tu lógica combinacional pura en memoria accidental. Asignar Y en todas las ramas, aquí mediante default, garantiza que Y siempre tenga un valor definido y que no se cree ningún latch.

// Leccion 2 - Ejercicio 1-D: plantilla de multiplexor 4 a 1
// Entradas de datos: SW[3]=D3, SW[2]=D2, SW[1]=D1, SW[0]=D0
// Lineas de seleccion: SW[5]=S1, SW[4]=S0. Salida: 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;   // el default evita inferir un latch
        endcase
    end

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

Sube tu evidencia. Captura una imagen de la cámara del multiplexor con datos SW[3:0] = 1010 y selección S1:S0 = 01 (SW[4] arriba, SW[5] abajo). Eso selecciona D1 = 1, así que LEDR[0] debe estar encendido. Adjunta la captura abajo.

Este ejercicio es opcional. Si tienes tiempo, es un salto interesante desde un solo LED hasta una salida formateada en los displays de siete segmentos.

Un display de siete segmentos tiene siete barras, etiquetadas a a g, que se encienden en combinaciones para dibujar un dígito. En la DE1-SoC cada display HEX es activo en bajo y el orden de bits es {g, f, e, d, c, b, a}: un segmento se enciende cuando su bit vale 0. Por tanto, el patrón del dígito 0 (segmentos a,b,c,d,e,f encendidos y g apagado) es 7'b1000000: seis 0 para los segmentos encendidos y un 1 para el g apagado.

El diseño siguiente lee SW[3:0] como un valor 0..15, muestra la cifra de unidades en HEX0 y la cifra de decenas (0 o 1) en HEX1. Observa algo que el proyecto inicial no te da automáticamente: para controlar HEX1 debes añadir output [6:0] HEX1 a la lista de puertos del módulo. El leds_mirror inicial solo expone HEX0. El módulo de abajo ya declara HEX0 y HEX1, así que es el ejemplo concreto de ese puerto adicional.

// Leccion 2 - Ejercicio 1-E (opcional): plantilla de decodificador decimal de dos digitos
// Completa los patrones activos en bajo y las ecuaciones de decenas/unidades.
module leds_mirror(SW, HEX0, HEX1);
    input  [9:0] SW;        // SW[3:0] = value 0..15
    output [6:0] HEX0;      // digito de unidades
    output [6:0] HEX1;      // digito de decenas (0 or 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