Simplificación de la tabla lógica demultiplexora

Navega tus respuestas
0

Necesito implementar demux simple en HDL:

La lógica del demultiplexor sería:

  

{a, b} = {en, 0} si sel == 0

     

{a, b} = {0, en} si sel == 1

Comencé desde la tabla lógica básica y, en primer lugar, escribí todas las combinaciones posibles de todos los pines y, como resultado, obtuve: 

/**
*   in | sel | a | b
*   ----------------
*   0  |  0  | 0 | 0
*   1  |  0  | 0 | 0
*   0  |  1  | 0 | 0
*   1  |  1  | 0 | 0
*   0  |  0  | 1 | 0
*   1  |  0  | 1 | 0
*   0  |  1  | 1 | 0
*   1  |  1  | 1 | 0
*   0  |  0  | 0 | 1
*   1  |  0  | 0 | 1
*   0  |  1  | 0 | 1
*   1  |  1  | 0 | 1
*   0  |  0  | 1 | 1
*   1  |  0  | 1 | 1
*   0  |  1  | 1 | 1
*   1  |  1  | 1 | 1
*/

Trabajando en la puerta con una sola salida, necesitaría compilar una expresión lógica donde la salida sea igual a 1. Ahora estoy un poco confundido sobre cómo simplificar esta tabla lógica, incluso si sé cómo debería verse el resultado final: 

/**
*   in | sel | a | b
*   -----------------
*   0  |  0  | 0 | 0
*   1  |  0  | 1 | 0
*   0  |  1  | 0 | 0
*   1  |  1  | 0 | 1
*/

Sería genial tener una idea de cómo se simplifica, gracias.

    
pregunta deividaspetraitis

2 respuestas

0

Estás cometiendo un error clásico.

Debe listar los estados posibles de los pines de entrada y los resultados resultantes : ha enumerado los resultados como si fueran entradas.

Como solo hay 4 combinaciones posibles para los pines de entrada, la tabla final que tienes es lo que deberías haber hecho originalmente.

  

/** * Input possibilities | Output result from requirement * in | sel | a | b * --------------------------- * 0 | 0 | 0 | 0 * 1 | 0 | 1 | 0 * 0 | 1 | 0 | 0 * 1 | 1 | 0 | 1 */

En verilog 

    module demux1to2
    (in,
    sel,
    a,
    b);

    // inputs
    input in;
    input sel;

    // outputs
    output a;
    output b;

// I am using registers for the outputs

    reg a;
    reg b;

        always @(in or sel)
        begin
            // find sel
            case (sel)
                1'b0 : begin
                // a output selected
                a = in;
                b = 0;
                end

                1'b1 : begin
                // b output selected
                b = in;
                a = 0;
                end
            endcase
        end
 endmodule
    
respondido por el Peter Smith
0

Gracias a @PeterSmith por ayudarme. Como notó anteriormente en el comentario, he estado cometiendo un error al enumerar las salidas como entradas.

Solo para actualizar la lógica del demultiplexor sería:

  

{a, b} = {en, 0} si sel == 0

     

{a, b} = {0, en} si sel == 1

En caso de que tengamos más de una salida, necesitamos:

  • Lista de estados posibles de los pines de entrada
  • Agregar un resultado resultante a nuestra tabla lógica

Veamos estos pasos.

1. Enumere los estados posibles de los pines de entrada ( in , sel ): 

/**
*   in
*   --
*   0
*   1
*/

Añadamos sel : 

/**
*   in | sel
*   --------
*   0  | 0
*   1  | 0
*   0  | 1
*   1  | 1
*/

2. Agregue los resultados resultantes a nuestra tabla lógica : 

/**
*   in | sel | a | b
*   ----------------
*   0  |  0  | 0 | 0  ---> {a, b} = {in, 0} if sel == 0; {a, b} = {0, 0};
*   1  |  0  | 1 | 0  ---> {a, b} = {in, 0} if sel == 0; {a, b} = {1, 0};
*   0  |  1  | 0 | 0  ---> {a, b} = {0, in} if sel == 1; {a, b} = {0, 0};
*   1  |  1  | 0 | 1  ---> {a, b} = {0, in} if sel == 1; {a, b} = {0, 1};
*/

Eso es todo. :)

    
respondido por el deividaspetraitis

Lea otras preguntas en las etiquetas

Necesito estar seguro de que estos son valores correctos para MOSFET 2N7000 Controlador de histéresis en Simulink