Je veux utiliser le RAM dans mon FPGA Altera DE1-SOC, est-ce que je prends la bonne façon?

Question

J'ai donc créé ce module qui est censé représenter une RAM, sur laquelle je sauvegarde des données en conséquence aux résultats de mon module supérieur.

module RAM_OUT (pix_val, w_mem_out, set_ram); 


input [2:0] w_mem_out; 
input [31:0] pix_val; 
input set_ram; 



reg [15:0] addr_out; 


reg [31:0] mem_out1 [0:57599]; 
reg [31:0] mem_out2 [0:57599]; 
reg [31:0] mem_out3 [0:57599]; 

/////////// ram out /////////////// 

always @ (w_mem_out or set_ram) 
begin 

if (set_ram) 
addr_out = 0; 

else 
    begin 

     if (w_mem_out == 1) 

       begin 
       mem_out1 [addr_out] = pix_val; 
       mem_out2 [addr_out] = 32'b11111111_000000000000000000000000; 
       mem_out3 [addr_out] = 32'b00000000_000000000000000000000000; 

       addr_out = addr_out + 16'b0000000000000001; 
       end 

     else if (w_mem_out == 2)   

       begin 
       mem_out1 [addr_out] = 32'b11111111_000000000000000000000000; 
       mem_out2 [addr_out] = pix_val; 
       mem_out3 [addr_out] = 32'b00000000_000000000000000000000000; 

       addr_out = addr_out + 16'b0000000000000001; 
       end 

     else if (w_mem_out == 3)   

       begin 
       mem_out1 [addr_out] = 32'b11111111_000000000000000000000000; 
       mem_out2 [addr_out] = 32'b11111111_000000000000000000000000; 
       mem_out3 [addr_out] = pix_val; 

       addr_out = addr_out + 16'b0000000000000001; 
       end 

     else  

       addr_out = addr_out; 

    end 
end 

endmodule 

Le programme fonctionne déjà parfaitement bien sur la simulation, mais étant donné que je prévois de le charger dans mon FPGA, je veux utiliser les mémoires SDRAM disponibles dans le conseil (mon intention est de faire une SOC complète, et j'ai besoin de charger les données dans la SDRAM, puis utiliser ma conception pour traiter ces données). Donc, je me demande si la programmation de la SDRAM est trop loin de ce que j'ai fait dans le code ci-dessus. Vous pouvez voir qu'il y a une certaine logique que j'ai écrite afin de sauvegarder les données que je veux dans les "mémoires" mais je ne suis pas sûr si c'est la même chose quand je fais la SDRAM ou je devrai changer plus tard Je n'aimerais pas ça car mon système fonctionne déjà bien en simulation).

J'ai écrit le code au-dessus de la lecture de la documentation altera, ils disent que c'est la façon de faire une RAM, mais est-ce synthétisable? Qu'est-ce qui se passe réellement dans le FPGA, il infère la mémoire en utilisant les portes de la puce FPGA ou utiliser la mémoire réelle de la carte? Veuillez noter que les données d'entrée sont composées de 57600 numéros 32bits.

Answer 1

Le code que vous avez écrit serait synthétisé à des blocs de RAM interne ou LUT à base RAMs. Ils pas utiliser la SDRAM sur la carte

La RAM interne d'un FPGA a généralement un accès unique cycle d'horloge et le chemin à travers ces mémoires vives est inclus dans l'analyse temporelle statique qui est habituellement effectué après place et Route (PAR). Si vous souhaitez utiliser la SDRAM embarquée, vous devrez inclure un contrôleur SDRAM dédié, qui consommera une logique finie à l'intérieur du FPGA. Les temps d'accès pour ces SDRAM embarquées seraient typiquement de quelques cycles d'horloge et seraient de nature explosive.

SDRAMs externes sont généralement utilisés pour stocker de gros volumes de données telles que les charges utiles de paquets ou tout équivalent RAMs sur puce sont utilisées pour stocker des données locales telles que les en-têtes, les résultats de traitement temporaires, etc.

Answer 2

Si vous utilisez un FPGA synthétisant une RAM n'est pas une mauvaise idée. Une bonne façon de le faire est de concevoir un module qui se comporte comme une RAM puis d'instancier ce module dans le reste de votre code. Ainsi,

i) votre module RAM doivent avoir des entrées appropriées et sorties: bus d'adresses (de ses), bus de données d'entrée, bus de données de sortie, les signaux de commande (validation d'écriture, etc.), l'horloge ...

ii) iii) votre module RAM doit contenir un ou plusieurs blocs always et/ou assign pour implémenter le comportement d'une RAM.

Voici un exemple qui devrait une RAM synthétiser en utilisant un synthétiseur FPGA:

module RAM(
    input  clock,   // best to make it synchronous 
    input  write_enable,  // a simple active high write enable 
    input [3:0] address,   // a single address bus in this example 
    input [7:0] data_in,   // input data 
    output [7:0] data_out);  // output data 

    reg [7:0] mem [0:15];   // here is the array; make this the size you need 

    always @(posedge clock) 
    if (write_enable) 
     mem[address] <= data_in; 

    assign data_out = mem[address]; 

endmodule