entrée unique à matrice de modules personnalisés dans Verilog

Question

J'ai un tableau de 4 modules de RAM que je veux être en mesure de lire/écrire à partir de deux signaux de sélection différents. En ce moment je suis instancier la RAM en utilisant des signaux intermédiaires:

genvar i; 
    generate 
    for (i = 0; i < regnum; i=i+1) begin: regs  
     rfram_generic rf (clk,rst,ce_a_int[i],addr_a_int[i],do_a_int[i], 
           ce_b_int[i],addr_b_int[i],do_b_int[i], 
           ce_w_int[i],we_w_int[i],addr_w_int[i], 
           di_w_int[i]); 
    end 
    endgenerate 

Et je veux choisir la RAM à utiliser en utilisant soit head ou tail signaux (vecteurs 2 bits). Des idees pour faire cela?

Answer 1

Je suis nouveau ici et je ne peux pas encore commenter les questions, mais en réponse à Marty: la plupart des outils de synthèse FPGA traduiront les signaux multisources internes avec des valeurs tristate en logique MUX-like, si possible. Voir, par exemple: a description of old tristate-to-logic behaviour that sounds accurate to me.

En tant que recommandation à Adam, vous êtes probablement mieux cette mention explicite dans votre code en effectuant le masquage vous-même plutôt que d'utiliser les tristates. Cela améliorera la portabilité, vous donnera des résultats plus prévisibles et servira d'auto-documentation si quelqu'un doit revoir votre code.

Cependant, faire quelques suppositions sur la base de votre solution, il serait probablement judicieux de masquer simplement la validation d'horloge sur le port d'écriture et multiplexer la sortie du port de lecture. Par exemple:

reg [WIDTH-1:0] do_a,do_b; 
always @(*) do_a = do_a_int[head]; 
always @(*) do_b = do_b_int[tail]; 
generate 
    genvar i; 
    for (i = 0; i < regnum; i=i+1) begin: regs  
     rfram_generic rf (clk,rst, 
         ce_a,addr_a,do_a_int[i], 
         ce_b,addr_b,do_b_int[i], 
         ce_w,head==i?we_w:1'b0,addr_w,di_w); 
    end 
endgenerate 

Cela se traduira probablement dans une logique moins complexe (à savoir , meilleure zone et retard) que votre solution.

Answer 2

Je pense que j'ai tout compris, je dois utiliser une déclaration générer:

genvar i; 
generate 
    for (i = 0; i < regnum; i=i+1) begin: sigassign 
     //read from the checkpoint in progress 
     assign ce_a_int[i] = (head == i) ? ce_a : 'bz; 
     assign addr_a_int[i] = (head == i) ? addr_a : 'bz; 
     assign do_a = (head == i) ? do_a_int[i] : 'bz; 
     //write to the checkpoint in progress 
     assign ce_w_int[i] = (head == i) ? ce_w : 'bz; 
     assign we_w_int[i] = (head == i) ? we_w : 'bz; 
     assign addr_w_int[i] = (head == i) ? addr_w : 'bz; 
     assign di_w_int[i] = (head == i) ? di_w : 'bz; 
     //read from the last stable checkpoint 
     assign ce_b_int[i] = (tail == i) ? ce_b : 'bz; 
     assign addr_b_int[i] = (tail == i) ? addr_b : 'bz; 
     assign do_b = (tail == i) ? do_b_int[i] : 'bz; 
    end 
endgenerate 

Answer 3

heureux de vous entendre trouvé une solution à votre problème. Je dois admettre que je ne l'ai pas bien compris ce que vous étiez à, mais un commentaire, vous pouvez également utiliser if générer dans des déclarations et instancier ainsi différents modules ou utiliser différents signaux dépendants du genvar, par exemple:

generate 
    genvar i; 
    for (i = 0; i < regnum; i=i+1) begin: regs 
     if (i == head) begin 
      rfram_generic_a rf(...); 
     end else if (i == tail) begin 
      rfram_generic_b rf(...); 
     end else begin 
      rfram_generic_c rf(...); 
     end 
    end 
endgenerate