Entrée unique dans un tableau de modules personnalisés dans Verilog

Question

Je souhaite donc pouvoir lire / écrire sur 4 modules de RAM en fonction de deux signaux de sélecteur différents. En ce moment, j'instancie 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 sélectionner la RAM à utiliser en utilisant les signaux head ou tail (vecteurs à 2 bits). Des idées comment faire cela?

Answer 1

Je suis nouveau ici et je ne peux pas encore répondre aux questions, mais en réponse à Marty: la plupart des outils de synthèse FPGA traduiront les signaux internes multisources avec des valeurs à trois états dans une logique de type MUX, dans la mesure du possible. Voir, par exemple: une description du vieux comportement de trois états vers la logique qui semble précis pour moi .

En guise de recommandation à Adam, vous feriez probablement mieux d'expliquer cela dans votre code en masquant vous-même plutôt qu'en utilisant les trois états. Cela améliorera la portabilité, vous donnera des résultats plus prévisibles et servira d'auto-documentation si quelqu'un devait revoir votre code.

Toutefois, en vous fondant sur votre solution, il serait probablement logique de masquer simplement l'activation de l'horloge sur le port d'écriture et de mux 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 résultera probablement en une logique moins complexe ( c'est-à-dire , une meilleure surface et un meilleur retard) que votre solution.

Answer 2

Je pense que j'ai compris, je dois utiliser une instruction de génération:

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

content d’entendre que vous avez trouvé une solution à votre problème. Je dois admettre que je ne comprenais pas bien ce que vous prépariez, mais un commentaire: vous pouvez également utiliser si dans les instructions de génération et instancier ainsi différents modules ou utiliser différents signaux dépendant 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