Verilog erreur de simulation de code: référence -unresolved à rising_edge (clk)

Question

nous avons conçu un alu en Verilog:

module ALU (
output reg overflow_16_1, // overflow flag used for 16 bit addition and subtraction 
output reg overflow_16_2, // overflow flag used for 16 bit addition and subtraction 
output reg overflow_16_3, // overflow flag used for 16 bit addition and subtraction 
output reg overflow_16_4, // overflow flag used for 16 bit addition and subtraction 
output reg overflow_32_1, // overflow flag used for 32 bit addition and subtraction 
output reg overflow_32_2, // overflow flag used for 32 bit addition and subtraction 
output reg overflow_64, // overflow flag used for 64 bit addition and subtraction 
output reg[63:0] z,  // output of the ALU 
input [63:0] X,   // 64 bit input of the ALU 
input [63:0] Y,   // 64 bit input of the ALU 
input [1:0] Operations, //to indicate the operation to be performed 
input [2:0] Modes,  // to indicate the word size of the operation 
input clk 
); 


always@(posedge(clk)) 
begin 

case(Modes) 

    3'b 000:    //if the Mode is 000 perform one 64 bit Operation 
     case(Operations) 
     2'b 00:  

      {overflow_64,z} = {1'b0,X} + {1'b0,Y}; //if Operation == 00 perform addition 

     2'b 01: 

     {overflow_64,z} = {1'b0,X}-{1'b0,Y}; //if Operation == 01 perform subtraction 

     2'b 10: if (X<=Y)     ////if Operation == 10 perform comparison 
      begin 
       z = Y;       //if Y is greater o/p is Y 
       end 
       else 
       begin 
       z=X;        //if X is greater o/p is X 
      end 
     default: $display("error in selecting operation"); // if the operation selection is invalid 
      endcase 


    3'b 001: case(Operations) // if the Mode == 001 perform two 32 bit Operations 
     2'b 00: 
     begin 
     {overflow_32_1,z[63:32]}={1'b0,X[63:32]}+{1'b0,Y[63:32]}; //if Operation == 00 perform addition 
     {overflow_32_2,z[31:0]}={1'b0,X[31:0]}+{1'b0,Y[31:0]}; 
     end 
     2'b 01: 
     begin 
     {overflow_32_1,z[63:32]}={1'b0,X[63:32]}-{1'b0,Y[63:32]}; //if Operation == 01 perform subtraction 
     {overflow_32_2,z[31:0]}= {1'b0,X[31:0]}-{1'b0,Y[31:0]}; 
     end 

     2'b 10:begin 
      if (X<=Y)          ////if Operation == 10 perform comparison 
      begin 
      z[63:32]= Y[63:32];     //if Y is greater o/p is Y  
      z[31:0]= Y[31:0]; 
      end 
      else 
      begin 
      z[63:32]= X[63:32];     //if X is greater o/p is X 
      z[31:0]= X[31:0]; 
      end 
      end 
      default: $display("error in selecting the Modes"); // if the operation selection is invalid 


    endcase 

    3'b 010: case(Operations)   // if the Mode == 010 perform four 16 bit Operations 
    2'b 00: begin 

     {overflow_16_1,z[63:48]}= {1'b0,X[63:48]}+ {1'b0,Y[63:48]}; //if Operations == 00 perform addition 
     {overflow_16_2,z[47:32]}= {1'b0,X[47:32]}+ {1'b0,Y[47:32]}; 
     {overflow_16_3,z[31:16]}= {1'b0,X[31:16]}+ {1'b0,Y[31:16]}; 
     {overflow_16_4,z[15:0]}= {1'b0,X[15:0]}+ {1'b0,Y[15:0]}; 
     end 
     2'b 01:begin 
     {overflow_16_1,z[63:48]}= {1'b0,X[63:48]}- {1'b0,Y[63:48]}; // if Operations == 01 perform subtraction 
     {overflow_16_2,z[47:32]}= {1'b0,X[47:32]}- {1'b0,Y[47:32]}; 
     {overflow_16_3,z[31:16]}= {1'b0,X[31:16]}- {1'b0,Y[31:16]}; 
     {overflow_16_4,z[15:0]}= {1'b0,X[15:0]}- {1'b0,Y[15:0]}; 
     end 

     2'b 10:begin 
      if (X<= Y)      // if Operations == 10 perform comparison 
      begin 
     z[63:48]= Y[63:48];    // if Y is greater then o/p is Y 
     z[47:32]= Y[47:32]; 
     z[31:16]= Y[31:16]; 
     z[15:0]= Y[15:0]; 
     end 
      else 
      begin 
     z[63:48]= X[63:48];    //else o/p is X 
     z[47:32]= X[47:32]; 
     z[31:16]= X[31:16]; 
     z[15:0]= X[15:0]; 
      end 
     end 

     default: $display("error in selecting the operation"); // if the operation selection is invalid 

    endcase 
    default: $display("error in selecting the Modes");  // if the word size selection is invalid 

endcase 

end 


endmodule 

Je veux que le modèle de comportement pour être sensibles aux changements dans les entrées et la transition dans le o/p à se produire après le front montant de l'horloge. d'abord j'avais écrit le code comme ..

always(*) 
begin 
if(rising_edge(clk)) 
begin 
.. 

Mais j'ai l'erreur tout en simulant en disant référence non résolue à

rising_edge(clk) 

Comment puis-je résoudre ce problème? ou le code ci-dessus est très bien?

S'il vous plaît répondre

Answer 1

Le code ci-dessus (avec toujours @) est correcte. Chaque fois que l'horloge permet de basculer, le bon fonctionnement est calculé, qui est ce qui importe.

Votre confusion pourrait provenir du fait que, en faisant cela, il semble que la sortie « magie » apparaît au bord de l'horloge, et vous ne voyez pas l'activité combinatoires. En réalité, cela arrive, mais au moment de l'évaluation.

Ce codage est le plus compact possible.

Ce que vous aviez prévu peut initialement être fait, mais il doit être divisé en deux processus, comme dans cet exemple trivial:

always@(*) begin 
    q_next =~q; 
end 

always @(posedge clk) begin 
    // Please add a reset condition 
    q <= q_next; 
end 

Ce qui est tout à fait équivalent à

always@(posedge clk) begin 
    // Please add a reset condition 
    q <= ~q; 
end 

Dans une telle situation, ce que je ne vois pas une raison de diviser le code, car il est évident que l'ensemble du processus génère des signaux synchrones.

La séparation devient nécessaire lors de l'écriture des machines d'état dans lequel vous devez générer des signaux de commande combinatoires, mais c'est un sujet différent