ENUNCIADO

1. Debemos construir el diagrama de transición de estados, haciendo que los estados no usados decaigan a cualquiera de los otros. De una elección acertada de estos decaimientos puede depender lo simple o complicado que resulte el circuito final y, dada la gran cantidad de planetas con posibilidad de vida, unos céntimos de ahorro puede suponer un gran pellizco al final. Este es el diagrama del ejemplo que veíamos en teoría:
2. Con ayuda de la tabla de transiciones del biestable JK, se debe escribir la tabla de transiciones. En el ejemplo de la teoría, era:
   
   
3. Toca ahora escribir las jotas y las kas de los biestables en función de las variables binarias que determinan el estado. Estas variables son, en este ejercicio, las salidas de los biestables: Q₃Q₂Q₁Q₀. Nos podemos auxiliar de mapas de Karnaugh. Como muestra, parte del ejemplo visto en teoría:
4. Una vez deducidas las ecuaciones de excitación de las jotas y las kas de cada biestable, se puede construir el circuito. En el ejemplo de teoría, este es el circuito resultante:
5. Probad con Verilog el circuito que habéis obtenido. En caso de que no realice la cuenta: 0, 9, 1, 2, 3, 5, 8, 13, 0, ..., revisad los cálculos.
6. Diseñad el circuito combinacional que cambie el 9 por un 1, dejando el resto de valores que importan como está. Si no sois capaces de diseñarlo sobre la marcha, construid la tabla de verdad y aplicad de nuevo los mapas de Karnaugh.
7. Probad el diseño final y, de funcionar, disfrutad de vuestra obra: un flamante señalador de vida inteligente para extraterrestres², marca ACME^®.

COMENTARIOS

• 4 biestables JK -> 24 puertas
• 5 puertas AND de 3 entradas -> 7.5 puertas
• 8 puertas AND de 2 entradas -> 8 puertas
• 1 puerta OR de 3 entradas -> 1.5 puertas
• 6 puertas OR de 2 entradas -> 6 puertas

/*
Computadores I - GII - USAL

Sesión 10 - Ejercicio 1.

Se nos pide diseñar un circuíto que siga la serie de Fibonacci
usando el menor número de puertas.

En esta solución se incluyen:

5  AND de tres entradas 
8 AND de dos entradas 
1 OR de tres entradas
7 OR de dos entradas 
4 biestables JK 
===========
48 puertas.

Por: cunart - Grupo A2
*/


//Modulo del biestable JK
module JKdown(output reg Q, output wire NQ, input wire J, input wire K,   input wire C);
  not(NQ,Q);

  initial
  begin
    Q=0;
  end    

  always @(posedge C)
    case ({J,K})
      2'b10: Q=1;
      2'b01: Q=0;
      2'b11: Q=~Q;
    endcase
endmodule

//Módulo que contiene el contador y la circuitería auxiliar.
module contador (output wire[3:0] Q, input wire C);
  //Cables correspondientes a las salidas negadas de los biestables.
  wire [3:0] nQ;
  //Cables que almacenan la salida temporal del biestable jk3.
  wire Qt, nQt;

  //Cables de entrada a los biestables.
  wire wJ3, wK3, wJ2, wK2, wJ1, wK1, wJ0, wK0;

  //Cables intermedios.
  wire wq0n1q2,  wn0n1n2, wq0n2, wq0n1, wn0n1q3, wq0q1n3, wq1n3, wq0q3;
  wire wn2q3, wq2n3, wq2q3, wn0q3;

  //Puertas correspondientes al contador.
  and q0n1q2 (wq0n1q2, Q[0], nQ[1], Q[2]);
  and n0n1n2 (wn0n1n2, nQ[0], nQ[1], nQ[2]);
  or  J3 (wJ3, wn0n1n2, wq0n1q2);

  and q0n2 (wq0n2, Q[0], nQ[2]); //La salida va a K3 y K1.
  and q0n1 (wq0n1, Q[0], nQ[1]); //La salida va a este y al K2.
  or K3 (wK3, wq0n1, wq0n2);

  and n0n1q3 (wn0n1q3, nQ[0], nQ[1], Qt);
  and q0q1n3 (wq0q1n3, Q[0], Q[1], nQt);
  or J2 (wJ2, wq0q1n3, wn0n1q3);

  and q1n3 (wq1n3, Q[1], nQt);
  or K2 (wK2, wq0n1, wq1n3);

  and J1 (wJ1, Q[0], nQ[2], nQt);

  and q0q3 (wq0q3, Q[0], Qt);
  and n2q3 (wn2q3, nQ[2], Qt); 
  or K1 (wK1, wq0q3, wn2q3, wq0n2);

  or J0 (wJ0, nQ[0], nQ[1]);

  or q2n3 (wq2n3, Q[2], nQt);
  and K0 (wK0, nQ[1], wq2n3);

  JKdown jk0 (Q[0], nQ[0], wJ0, wK0, C);
  JKdown jk1 (Q[1], nQ[1], wJ1, wK1, C);
  JKdown jk2 (Q[2], nQ[2], wJ2, wK2, C);
  JKdown jk3 (Qt, nQt, wJ3, wK3, C);

  //Circuitería que cambia el nueve por el uno.
  and  q2q3 (wq2q3, Q[2], Qt);
  and  n0q3 (wn0q3, nQ[0], Qt);
  or    NQ3 (Q[3], wq2q3, wn0q3);
endmodule


//Módulo para probar el circuito.
module test;
  reg I, C;
  wire [3:0] Q;
  contador counter (Q,C);

  always 
  begin
    #10 C=~C;
  end

  initial
  begin
    $dumpfile("ej1_48.dmp");
    $dumpvars(2, counter, Q);
          
    C=0;
    #500 $finish;
  end
endmodule

/* Computadores I - GII - USAL

Sesión 10 - Ejercicio 1.

Se nos pide diseñar un circuíto que siga la serie de Fibonacci
usando el menor número de puertas.

En esta solución se incluyen:

1 AND de tres entradas
5 AND de dos entradas 
4 OR de dos entradas
4 biestables JK
===========
34.5 puertas.

Por: cunart - Grupo A2
*/


//Modulo del biestable JK
module JKdown(output reg Q, output wire NQ, input wire J, input wire K,   input wire C);
  not(NQ,Q);

  initial
  begin
    Q=0;
  end    

  always @(posedge C)
    case ({J,K})
      2'b10: Q=1;
      2'b01: Q=0;
      2'b11: Q=~Q;
    endcase
endmodule


//Módulo que contiene el contador y la circuitería auxiliar.
module contador (output wire [3:0] Q, input wire C);
  //Cables correspondientes a las salidas negadas de los biestables.
  wire [3:0] nQ;
  //Cables que almacenan la salida temporal del biestable jk3.
  wire Qt, nQt;

  //Cables de entrada a los biestables.
  wire wJ3, wJ2, wJ1, wK0;

  //Cables intermedios.
  wire wn0n1, wq0q1, wn0q3, wn3n1, wq2q3;

  //Puertas correspondientes al contador.
  and n0n1 (wn0n1, nQ[0], nQ[1]);
  or J3 (wJ3, wn0n1, Q[2]);

  and q0q1 ( wq0q1, Q[0], Q[1]);
  and n0q3 ( wn0q3, nQ[0], Qt);
  or J2 (wJ2, wq0q1, wn0q3);

  and J1 (wJ1, nQ[2], nQt, Q[0]);

  and n3n1 (wn3n1, nQt, nQ[1]);
  or K0 (wK0, wn3n1, Q[2]);

  JKdown jk1 (Q[0], nQ[0], 1'b1, wK0, C);
  JKdown jk2 (Q[1], nQ[1], wJ1, Q[0], C);
  JKdown jk3 (Q[2], nQ[2], wJ2, 1'b1, C);
  JKdown jk4 (Qt, nQt, wJ3, Q[0], C);

  //Circuitería adicional que cambia el nueve por el uno.
  and  q2q3 (wq2q3, Q[2], Qt);
  or    NQ3 (Q[3], wq2q3, wn0q3);
endmodule


//Módulo para probar el circuíto.
module test;
  reg I, C;
  wire [3:0] Q;
  contador counter (Q,C);

  always 
  begin
    #10 C=~C;
  end

  initial
  begin
    $dumpfile("ej1_34-5.dmp");
    $dumpvars(2, counter, Q);
          
    C=0;
    #500 $finish;
  end
endmodule

module contador (output reg [3:0] Q, input wire C);
  reg [3:0] Qt1; reg [3:0] Qt2;

  initial
  begin
    Q = 13;       
  end

  always @(posedge C)
  begin
    if (Q == 13)
    begin
      Q = 0;     // En estos dos casos, se ignora el reloj.
      #20        // Mejor sería hacer una tabla directa
      Q = 1;     //   basándonos solo en el estado anterior:
      #40        //     0 -> 1 -> 1 -> 2 -> 3 -> ...
      Qt2 = 0;   //   y apañando algo para el 1 repetido
      Qt1 = 1;   // [[Nota del profesor]]
    end
    Q = Qt1 + Qt2;
    Qt2 = Qt1;
    Qt1 = Q;
  end
endmodule