modelsim programmation 60 compteur (conception de chargement d'erreur)

Question

Mon code compile bien, mais il ne fonctionne pas quand je le simule. Il affiche "conception de chargement d'erreur". Je pense que le port d'entrée et de sortie est faux parmi ces modules. mais je ne peux pas les trouver .. s'il vous plaît aidez-moi où l'erreur est dans mon code.

module tb_modulo_60_binary; 

    reg t_clk, reset; 
    wire [7:0] t_Y; 
    parameter sec = 30; 

    always #(sec) t_clk = ~t_clk; 
    modulo_60_binary M1 (t_Y, t_clk, reset); 

    initial begin 
    t_clk = 1; reset =1; #10; 
    reset = 0; #3050; 
    $finish; 
    end 
endmodule 

module modulo_60_binary(y, clk, reset); 
    output [7:0] y; 
    input reset, clk; 
    wire TA1, TA2, TA3, JA2, JA4; 
    reg [7:0] y; 

    assign TA1 = 1; 
    assign TA2 = (~y[6]) && y[4]; 
    assign TA3 = (y[5] && y[4]) || (y[6] && y[4]); 
    assign JA2 = ~y[3]; 
    assign JA4 = y[1]&&y[2]; 

    jk_flip_flop JK1 (1, 1, clk, y[0]); 
    jk_flip_flop JK2 (JA2, 1, y[0], y[1]); 
    jk_flip_flop JK3 (1, 1, y[1], y[2]); 
    jk_flip_flop JK4 (JA4, 1, y[1], y[3]); 
    t_flip_flop T1 (TA1, clk, y[4]); 
    t_flip_flop T2 (TA2, clk, y[5]); 
    t_flip_flip T3 (TA3, clk, y[6]); 
    always @(negedge clk) 
    begin 
    if(reset) 
     y <= 8'b00000000; 
    else if(y == 8'b01110011) 
     y <= 8'b00000000; 
    end 
endmodule 

module t_flip_flop(t, clk, q); 
    input t, clk; 
    output q; 
    reg q; 

    initial q=0; 
    always @(negedge clk) 
    begin 
    if(t == 0) q <= q; 
    else q <= ~q; 
    end 

endmodule 

module jk_flip_flop(j, k, clk, Q); 
    output Q; 
    input j, k, clk; 
    reg Q; 

    always @(negedge clk) 
     if({j,k} == 2'b00) Q <= Q; 
     else if({j,k} == 2'b01) Q <= 1'b0; 
     else if({j,k} == 2'b10) Q <= 1'b1; 
     else if({j,k} == 2'b11) Q <= ~Q; 
endmodule 

Answer 1

Votre signal de y en modulo_60_binary est entraîné en deux endroits:

• par bit JK # et les instances T #
• La logique de remise à zéro qui affecte tous les bits de y à zéros

Les flops et la logique de peigne doivent avoir un pilote clair. C'est l'une des différences fondamentales entre les langages logiciels et matériels.

Le reste de ma réponse en supposant que l'utilisation des flops JK et T est une exigence de conception. Par conséquent, vous devez supprimer le bloc toujours qui attribue y à zéro et et faire y un type wire.

La fixation de la logique sur les T-Flops est facile. Ajoutez simplement une instruction conditionnelle. Exemple:

wire do_rst = reset || (y == 8'b01110011); 
assign TA1 = do_rst ? y[4] : 1; 
assign TA2 = do_rst ? y[5] : (~y[6]) && y[4]; 
assign TA3 = do_rst ? y[6] : (y[5] && y[4]) || (y[6] && y[4]); 

Les flots JK sont plus durs car la sortie d'un flop est l'horloge d'un autre. Je vais vous conseiller que l'entrée d'horloge pour chaque flop JK soit clk, sinon vous demandez un mal de tête de conception pour la réinitialisation quand il y a des bits de non puissance de deux valeurs moins une (par exemple 1,3,7,15). Cela signifie que vous devez réévaluer votre logique JA # et ajouter la logique KA # (l'indice do_rst ci-dessus vous aidera). Je ne vais pas faire le travail pour vous au-delà de ça.

Il y a l'option de l'approche de réinitialisation asynchrone, mais pour cette conception je conseillerai l'âgist. L'impulsion de réinitialisation peut être trop courte sur le silicium avec la réinitialisation conditionnelle pour y == une valeur particulière, ce qui peut entraîner une réinitialisation partielle non fiable. Vous pouvez ajouter des contraintes/règles de synthèse pour garder le push assez large, mais cela ne fait que patcher un design fragile. Mieux vaut le concevoir robuste au début.

FYI: y[7] n'a pas de pilote et la déclaration du module de l'instance T3 a une faute de frappe.