FPGA实现双口RAM的乒乓操作——FPGA学习笔记2

已于 2024-02-20 23:09:28 修改
阅读量1.2k 收藏 24
点赞数 25
分类专栏： FPGA学习笔记 文章标签： fpga开发 学习 笔记
于 2024-02-20 23:08:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69082048/article/details/136152635
版权

一、RAM资源介绍

        RAM的英文全称是Random Access Memory，即随机存取存储器，它可以随时把数据写入任一指定地址的存储单元，也可以随时从任一指定地址中读出数据，其读写速度是由时钟频率决定的。RAM主要用来存放程序及程序执行过程中产生的中间数据、运算结果等。


单端口：只有一个端口，读写数据不能同时进行，共用数据通道。
伪双端口：拥有两个数据通道，一个用来写一个用来读。
真双端口：拥有两个数据通道，一个用来写一个用来读。

        RAM区别于ROM：

RAM（Random Access Memory）和ROM（Read-Only Memory）是计算机中常见的两种存储器件，它们有以下主要区别：

1. 可读写性：
   - RAM是一种可读写的内存，用于临时存储数据和程序。数据可以随时被写入、修改和读取，但在断电或重启计算机后数据会消失。
   - ROM是一种只读的内存，其中存储了固定的数据或程序，用户无法对其进行修改。即使在断电或重启计算机后，其中的数据也会保持不变。

2. 数据保存：
   - RAM用于存储正在运行的程序和临时数据，可以被CPU频繁读写，速度较快，但数据不稳定。
   - ROM用于存储固化的系统程序和数据，通常包括启动程序和固件等，数据稳定不易丢失。

3. 容量和成本：
   - RAM容量相对较大，通常用于临时存储大量数据和程序，但成本较高。
   - ROM容量通常较小，主要用于存储固定的程序和数据，成本相对较低。

综上所述，RAM和ROM在功能、读写性质、数据保存方式以及成本等方面有明显的区别，它们在计算机系统中发挥着不同的作用。

二、RAM IP核使用

        1、具体配置

                （1）Basic

        FPGA中没有ROM资源，ROM资源利用RAM资源模拟生成

                （2）Port A Options

                使用输出寄存器，数据会延后一个时钟

                其他保持默认

        2、代码驱动

        使用三个计数器分别控制读写切换、写入数据、读写地址

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2024/02/20 09:25:45
// Design Name: 
// Module Name: rw_ram
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module rw_ram(
input clk,
input rst_n,

output          ram_en          ,
output          ram_wea         ,
output  reg[4:0]ram_addr        ,
output  reg[7:0]ram_wr_data     ,
output  reg[7:0]ram_rd_data
    );


reg[5:0]rw_cnt;

//读写切换    1写    0读
assign ram_wea=((rw_cnt <= 6'd31)&&(ram_en == 1'b1)) ? 1'b1 : 1'b0;

assign ram_en=rst_n;

//读写状态计数器
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        rw_cnt <= 6'b0;
    end
    else if(rw_cnt < 6'd63)begin
        rw_cnt <= rw_cnt + 1'b1;
    end
    else begin
        rw_cnt <= 6'b0;
    end
end

//读写数据计数器
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        ram_wr_data <= 8'b0;
    end
    else if(ram_wea == 1'b1)begin
        ram_wr_data <= ram_wr_data + 1'b1;
    end
    else begin
        ram_wr_data <= 8'b0;
    end
end

//读写地址计数器
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        ram_addr <= 5'b0;
    end
    else if(ram_addr < 5'd31)begin
        ram_addr <= ram_addr + 1'b1;
    end
    else begin
        ram_addr <= 5'b0;
    end
end

endmodule

              3、顶层例化文件

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2024/02/20 09:22:59
// Design Name: 
// Module Name: ip_ram
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//

module ip_ram(
input sys_clk,
input sys_rst_n
    );

wire         ram_en     ;//RAM使能                            
wire         ram_wea    ;//ram读写使能信号,高电平写入,低电平读出   
wire [4 : 0] ram_addr   ;//ram读写地址                          
wire [7 : 0] ram_wr_data;//ram写数据                           
wire [7 : 0] ram_rd_data;//ram读数据                           

blk_mem_gen_0 u_blk_mem_gen_0 (
  .clka(sys_clk),    // input wire clka
  .ena(ram_en),      // input wire ena
  .wea(ram_wea),      // input wire [0 : 0] wea
  .addra(ram_addr),  // input wire [4 : 0] addra
  .dina(ram_wr_data),    // input wire [7 : 0] dina
  .douta(ram_rd_data)  // output wire [7 : 0] douta
);

rw_ram u_rw_ram(
.clk             (sys_clk)      ,
.rst_n           (sys_rst_n)      ,
//RAM
.ram_en          (ram_en)   ,
.ram_wea         (ram_wea)   ,
.ram_addr        (ram_addr)   ,
.ram_wr_data     (ram_wr_data)   ,
.ram_rd_data     (ram_rd_data)
);  

ila_0 u_ila_0 (
	.clk(sys_clk), // input wire clk

	.probe0(ram_en), // input wire [0:0]  probe0  
	.probe1(ram_wea), // input wire [0:0]  probe1 
	.probe2(ram_addr), // input wire [4:0]  probe2 
	.probe3(ram_wr_data), // input wire [7:0]  probe3 
	.probe4(ram_rd_data) // input wire [7:0]  probe4
);


endmodule

        引脚约束XDC

create_clock -period 20.000 -name sys_clk [get_ports sys_clk]
set_property -dict {PACKAGE_PIN R4 IOSTANDARD LVCMOS33} [get_ports sys_clk]
set_property -dict {PACKAGE_PIN U2 IOSTANDARD LVCMOS33} [get_ports sys_rst_n]

        4、综合下载验证

                ram_wea 信号拉高之后，地址和数据都是从 0 开始累加，也就说当 ram 地址为 0 时，写入的数据也是 0；当 ram 地址为 1 时，写入的数据也是 1。

                ram_wea（读使能）信号拉低之后， ram_addr 从 0 开始增加，也就是说从 ram 的地址 0 开始读数据； ram中读出的数据 ram_rd_data 在延时一个时钟周期之后， 开始输出数据， 输出的数据为 0， 1， 2。。。。。

三、双口RAM——乒乓操作

        1、乒乓操作简介

        外部输入数据流通过输入数据流选择单元将数据流输入到数据缓存模块，比较常用的存储单元有双口RAM，FIFO，SDRAM等。在第一个缓冲周期，数据流通过“输入数据流选择单元”将数据写入“数据缓冲模块1”。写完之后进入第二个缓冲周期，在第二个缓冲周期数据流通过“输入数 据流选择单元”将数据写入到“数据缓冲模块2”的同时“输出数据流选择单元”将“数据缓冲模块1”的数据流读出，此时进入第三个缓冲周期。在第三个缓冲周期数据流通过“输入数据流选择单元”将数据写入到“数据缓存模块1”的同时将“数据缓冲模块2”的数据读出。如此反复循环地操作，即为乒乓操作。

        乒乓操作的最大特点是通过“输入数据流选择单元”和“输出数据选择单元”按节拍、相互配合的切换，将经过缓冲的数据流没有停顿地送到“数据流运算处理模块”进行运算与处理。把乒乓操作模块当做一个整体，站在这个模块的两端看数据，输入数据流和输出数据流都是连续不断的，没有任何停顿的，因此非常适合对数据流进行流水线 式处理。所以乒乓操作常常应用于流水线式算法，完成数据的无缝缓冲与处理。

乒乓操作的第二个特点是可以节约缓存空间，使用双存储单元比单存储单元更节省存储空间，这是很明显的。同时在某些数据处理时，必须要数据达到一定个数才能进行运算，故还可以达到数据缓存的目的。

乒乓操作还可以实现低速模块处理高速数据，这种处理方式可以实现数据的串并转换，就是数据位宽之间的转换，是面积与速度互换原则的体现。

        2、程序设计

        利用状态机，划分四个状态，空闲、写R1、读R1写R2、写R1读R2，从而实现乒乓操作，具体状态转化如下图

IDLE：初始状态，在不工作或复位时就让状态机置为初始状态。

WRAM1：写RAM1状态。该状态我们开始往RAM1中写入数据，此时由于RAM2中并没有写入数据，所以我们不用对RAM2进行读取。

WRAM2_RRAM1：写RAM2读RAM1状态，当第一包数据写入完毕之后，马上跳到该状态，将第二包数据写入到RAM2中的同时读出RAM1中的写入的第一包数据。

WRAM1_RRAM2：写RAM1读RAM2状态。在该状态下我们开始向RAM1中写入第三包数据，此时第三包数据会把第一包数据覆盖，而我们的第一包数据已经读取出来了，并不会使数据丢失。在往RAM1中写入第三包数据的同时，我们读出RAM2中的第二包数据，当读写完成之后，跳回WRAM2_RRAM1状态开始 下一包的数据写入以及读取，如此循环我们就能无缝地将连续的输入数据读取出来了。

                （1）RAM IP核配置

                （2）驱动代码

        读写数据内部，注释部分可单独使用

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2024/02/20 11:12:22
// Design Name: 
// Module Name: rw_ramx2
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//

module rw_ramx2(
input            clk      ,
input            rstn     ,
//R1
output           ena      ,
output           wea      ,
output reg [5:0] addra    ,
output reg [7:0] dina     ,
output reg [7:0] douta    ,
//R2
output           enb      ,
output           web      ,
output reg [5:0] addrb    ,
output reg [7:0] dinb     ,
output reg [7:0] doutb    ,

output reg [7:0] ram_dout
);

//读写状态计数器
reg [5:0] ram_cnt;
//
reg [5:0] ram_addr;
//
reg [7:0] ram_wr_data;
reg [3:0] state;
//状态
parameter IDLE          = 4'b0001;      //空闲
parameter WRAM1         = 4'b0010;      //写R1
parameter WRAM2_RRAM1   = 4'b0100;      //读R1写R2
parameter WRAM1_RRAM2   = 4'b1000;      //写R1读R2

//R1读写切换
assign wea = ((ram_cnt <= 6'd31)&&(ena == 1'b1)) ? 1 : 0;
//R2读写切换
assign web = ~wea;
//RAM使能信号
assign ena = rstn;
assign enb = rstn;



//读写状态计数器
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        ram_cnt <= 6'd0;
    end
    else if(ram_cnt < 6'd63)begin
        ram_cnt <= ram_cnt + 1'b1;
    end
    else begin
        ram_cnt <= 6'd0;
    end
end
//读写地址计数器
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        ram_addr <= 6'd0;
    end
    else if(ram_addr < 6'd31)begin
        ram_addr <= ram_addr + 1'b1;
    end
    else begin
        ram_addr <= 6'd0;
    end
end

//读写数据计数器
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        ram_wr_data <= 8'b0;
    end
    else if(ram_wr_data < 8'd63)begin
        ram_wr_data <= ram_wr_data + 1'b1;
    end
    else begin
        ram_wr_data <= 8'b0;
    end
end


//状态跳转
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        state <= IDLE;
    end
    else begin
        case(state)
        IDLE:begin  //空闲
            if (wea == 1'b1) begin
                state <= WRAM1;        
            end
            else begin
                state <= IDLE;
            end
        end
        WRAM1:begin  //写R1
            if ((wea == 1'b0)&&(web == 1'b1)) begin
               state <= WRAM2_RRAM1; 
            end
            else begin
                state <= WRAM1;
            end
        end
        WRAM2_RRAM1:begin  //读R1，写R2
            if ((wea == 1'b1)&&(web == 1'b0))begin
                state <= WRAM1_RRAM2;
            end
            else begin
                state <= WRAM2_RRAM1;
            end
        end
        WRAM1_RRAM2:begin  //写R1，读R2
            if ((wea == 1'b0)&&(web == 1'b1))begin
                state <= WRAM2_RRAM1;
            end
            else begin
                state <= WRAM1_RRAM2;
            end
        end
        default:begin
            state <= IDLE;
        end
    endcase
    end
end

//读写数据
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        // state <= IDLE;
    end
    else begin
    case (state)
    IDLE:begin
        addra <= 5'b0;
        dina  <= 8'b0;
        addrb <= 5'b0;
        dinb  <= 8'b0;
    end       
    WRAM1:begin
        addra <= ram_addr;
        dina <= ram_wr_data;        
        // if(addra < 5'd31) begin
            // addra <= addra + 1'b1;
        // end
        // else begin
            // addra <= 5'b0;
        // end

        // if(dina < 5'd31) begin
            // dina <= dina + 1'b1;
        // end
        // else begin
            // dina <= 5'b0;
        // end
    end      
    WRAM2_RRAM1:begin
        addra <= ram_addr;
        addrb <= ram_addr;
        dinb <= ram_wr_data;
        // if(addrb < 5'd31) begin
            // addrb <= addrb + 1'b1;
        // end
        // else begin
            // addrb <= 5'b0;
        // end

        // if(dinb < 5'd31) begin
            // dinb <= dinb + 1'b1;
        // end
        // else begin
            // dinb <= 5'b0;
        // end

        // if(addra < 5'd31) begin
            // addra <= addra + 1'b1;
        // end
        // else begin
            // addra <= 5'b0;
        // end
    end
    WRAM1_RRAM2:begin
        addra <= ram_addr;
        addrb <= ram_addr;
        dina <= ram_wr_data;
        // if(addra < 5'd31) begin
            // addra <= addra + 1'b1;
        // end
        // else begin
            // addra <= 5'b0;
        // end

        // if(dina < 5'd31) begin
            // dina <= dina + 1'b1;
        // end
        // else begin
            // dina <= 5'b0;
        // end

        // if(addrb < 5'd31) begin
            // addrb <= addrb + 1'b1;
        // end
        // else begin
            // addrb <= 5'b0;
        // end
    end    
    default:begin
        addra <= addra;
        dina  <= dina;
        addrb <= addrb;
        dinb  <= dinb;
    end
    endcase
    end
end

endmodule

                        （3）顶层例化

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2024/02/20 11:05:52
// Design Name: 
// Module Name: ip_ramx2
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module ip_ramx2(
input sys_clk,
input sys_rst_n
);

wire        ena     ;
wire        wea     ;
wire [4:0]  addra   ;
wire [7:0]  dina    ;
wire [7:0]  douta   ;

wire        enb     ;
wire        web     ;
wire [4:0]  addrb   ;
wire [7:0]  dinb    ;
wire [7:0]  doutb   ;
wire [7:0]  ram_dout;

blk_mem_gen_0 u_blk_mem_gen_0 (
    //R1
  .clka(sys_clk),            // input wire clka
  .rsta(!sys_rst_n),            // input wire rsta
  .ena(ena),              // input wire ena
  .wea(wea),              // input wire [0 : 0] wea
  .addra(addra),          // input wire [4 : 0] addra
  .dina(dina),            // input wire [7 : 0] dina
  .douta(douta),          // output wire [7 : 0] douta
    //R2
  .clkb(sys_clk),            // input wire clkb
  .rstb(!sys_rst_n),            // input wire rstb
  .enb(enb),              // input wire enb
  .web(web),              // input wire [0 : 0] web
  .addrb(addrb),          // input wire [4 : 0] addrb
  .dinb(dinb),            // input wire [7 : 0] dinb
  .doutb(doutb)          // output wire [7 : 0] doutb
//   .rsta_busy(rsta_busy),  // output wire rsta_busy
//   .rstb_busy(rstb_busy)  // output wire rstb_busy
);

rw_ramx2 u_rw_ramx2(
  .clk      (sys_clk),
  .rstn     (sys_rst_n),
  .ena      (ena),
  .wea      (wea),
  .addra    (addra),
  .dina     (dina),
  .douta    (douta),
  .enb      (enb),
  .web      (web),
  .addrb    (addrb),
  .dinb     (dinb),
  .doutb    (doutb),
  .ram_dout (ram_dout)
);

ila_0 your_instance_name (
	.clk(sys_clk), // input wire clk


	.probe0(ena), // input wire [0:0]  probe0  
	.probe1(wea), // input wire [0:0]  probe1 
	.probe2(addra), // input wire [4:0]  probe2 
	.probe3(dina), // input wire [7:0]  probe3 
	.probe4(douta), // input wire [7:0]  probe4 
	.probe5(enb), // input wire [0:0]  probe5 
	.probe6(web), // input wire [0:0]  probe6 
	.probe7(addrb), // input wire [4:0]  probe7 
	.probe8(dinb), // input wire [7:0]  probe8 
	.probe9(doutb), // input wire [7:0]  probe9 
	.probe10(ram_dout) // input wire [7:0]  probe10
);


endmodule

        引脚约束XDC

create_clock -period 20.000 -name sys_clk [get_ports sys_clk]
set_property -dict {PACKAGE_PIN R4 IOSTANDARD LVCMOS33} [get_ports sys_clk]
set_property -dict {PACKAGE_PIN U2 IOSTANDARD LVCMOS33} [get_ports sys_rst_n]

                        （4）综合下载验证

四、总结

        乒乓操作较为显著的特点是数据的无缝处理，只要大家理解了乒乓操作的处理技巧，那么当我们使用不同的存储单元作为缓冲模块时，操作起来也能得心应手。后续将更新FIFO的乒乓操作。。

楠了个难
关注
  • 25
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FPGA简单双口RAM+真双口RAM测试
01-30
详细的截图与仿真代码，总结应用FPGA简单双口RAM+真双口RAM
基于FPGA的双口RAM实现及应用
04-16
采用FPGA技术构造双口RAM，实现高速信号采集系统中的海量数据存储和时钟匹配。功能仿真验证该设计的正确性，该设计能减小电路设计的复杂性，增强设计的灵活性和资源的可配置性能，降低设计成本，缩短开发周期。
从零开始利用MATLAB进行FPGA设计（五）详解双口RAM
最新发布
WZT725的博客
04-26 882
创作于谱仪算法设计过程中的数字能谱生成模块设计。详解system generation中的双口RAM模块。
FPGA--verilog 实现乒乓操作（附代码）
weixin_44413306的博客
12-02 3065
乒乓操作的原理简单点说就是： 控制两个存储RAM1和RAM2，当数据开始存储进入RAM1时，将RAM2的数据输出进行处理；当数据开始存储进入RAM2时，将RAM1的数据输出进行处理。 何时存储数据由输入数据流选择模块控制，何时输出，由输出数据流选择模块进行控制。
FPGA实现“乒乓操作”
apple_53311083的博客
09-11 3380
“乒乓操作”是一种常用于数据流控制的处理技巧，可以实现无缝高速数据流缓存。乒乓ram结构：这种结构是将输入数据流通过输入数据选择单元等时地将数据流分配到两个数据缓冲区。通过两个数据缓冲区的读和写的切换，来实现数据的流水式传输。
FPGA之RAM详解，真双口RAM的使用
热门推荐
wandou0511的博客
03-03 1万+
真双口RAM IP练习 真双口RAM可以说是灵活性最大的RAM IP核，因为它赋予了用户最大的设计空间，两个可以独立读写地址空间的端口，充分释放了FPGA程序设计上的可能。 但是实际上真双口RAM在工程项目中还是和单双口RAM一样使用频率比较低的，因为其太过灵活自由了，就导致了用户在设计程序的过程中，比较难以驾驭，最大的苦恼即来自于两个独立读写端口的不可避免的读写冲突，当然也有一些FPGA工程师单独做了一个相对复杂的读写状态机，在程序设计上可以规避读写冲突，但是笔者也和大部分朋友们一样，比...
基于双端口RAM的乒乓操作测试
weixin_43828944的博客
08-04 942
基于双端口RAM的乒乓操作测试
双口RAM
xiaoyuchidayuma的博客
05-09 2737
另一种方式，则是比较省事的方式，直接采用专有的双口RAM芯片，这类芯片具备两组完全独立的数据总线、地址总线和控制总线，并且通过芯片本身的仲裁机制决定当两个处理器同时访问同一地址单元时的访问权，并通过相应的标记将仲裁结果反馈给双处理器，供其决定是否放弃此次访问，很明显，采用专有的双口RAM芯片既省心，又能够实现真正意义上的双处理器独立访问，只是需要点money而已。RAM上电后每个地址的数据随机，因此如果有什么标志位一定要在上电后先进行初始化。在这样的结构体下，CPU在读写RAM时会出现以下四种情况。
FPGA_学习_11_IP核_RAM_乒乓操作
heqiunong的专栏
06-21 1811
本篇博客学习另一个IP核，RAM。用RAM实现什么功能呢？实现乒乓操作。乒乓操作是什么呢？以下是本人理解：乒乓操作可以实现低速模块处理高速数据，这种处理方式可以实现数据的串并转换，就是数据位宽之间的转换，是面积与速度互换原则的体现。例如：数据位宽的转换，要将8位的数据转换为16位，按照传统方法，每两个时钟周期完成一次转换，输出数据的变化与时钟信号不是同步的。使用乒乓操作，数据写入数据缓冲模块的时候使用50M的时钟，读出时使用25M的时钟，每次读出16。
FPGA简单双端口RAM——IP核
qq_52215423的博客
07-20 2972
FPGA简单双端口RAM——IP核
【FPGA】zynq 单端口RAM 双端口RAM 读写冲突 写写冲突
Z小旋
11-15 5212
伪双端口模式下我们需要避免读写冲突；在真双端口模式下我们需要避免读写冲突和写写冲突。
数字IC笔面基础，项目常用IP——双口RAM（简介及Verilog实现）
HFUT90S的博客
11-02 5798
RAM（Random Access Memory），随机存储器，是一种用来暂时存储中间数据的存储器，掉电易失。按照类型可分为单口 RAM（Single RAM）和双口 RAM（Dual RAM），其中双口RAM又有简单双口 RAM（Simple-Dual RAM）、真双口 RAM（True-Dual RAM）。在异步FIFO的内部就是一个双口RAM用来存取数据。RAM是最基础的IP，在FPGA和ASIC设计中，会经常调用成熟的RAM。
利用FPGA实现双口RAM的设计及应用
08-11
采用FPGA技术构造双口RAM，实现高速信号采集系统中的海量数据存储和时钟匹配。功能仿真验证该设计的正确性，该设计能减小电路设计的复杂性，增强设计的灵活性和资源的可配置性能．降低设计成本，缩短开发周期。
教你一步步实现XilinxFPGA内部双口RAM IP核
08-10
3E系列XC3S500E）为例详细介绍一下双口RAM的IP核配置流程，说到这里还不得不提一个有意思的事，Xilinx的双口RAM是真的双口RAM，而Altera的双口RAM则是两片RAM背靠背模拟实现的，不过Xilinx内部的时钟管理是DLL而...
双口RAM乒乓操作 verilog实现
12-02
使用verilog 实现双口RAM的乒乓操作，使用vivado2017.4实现，有详细代码解释。整体包含顶层模块、控制模块、RAM存储模块、输入数据二选一模块、输出数据二选一模块。
DSP EMIF与FPGA双口RAM高速通信实现.pdf
07-13
DSP EMIF与FPGA双口RAM高速通信实现.pdf
FPGA乒乓操作详解，知道与FIFO的区别吗？
mengzaishenqiu的博客
12-14 588
FPGA乒乓操作是一种高效的数据流控制处理技巧，它主要应用于需要快速且连续数据处理和缓冲的场合。乒乓操作的核心在于利用两个缓冲区交替存储数据流，从而实现数据的无缝实时传输和处理。本文将详细介绍乒乓操作的基本原理、应用场景以及与FIFO的区别。
FIFO设计笔记(双口RAM、同步FIFO、异步FIFO)Verilog及仿真
搞IC的小冯
04-05 4557
FIFO (First-In-First-Out) 是一种先进先出的数据缓存器，在数字ASIC设计中常常被使用。在实际开发中，多数都是直接使用公司经过top-out验证的FIFO IP或者是ISE/Vivado工具自带的FIFO IP，并不需要自己造轮子。但是，作为设计者，必须要掌握FIFO的设计方法，这样可以适配于各种类型的FPGA开发板，可以实现国产化。作为求职者，FIFO设计的相关知识在面试环节出现频率极高，需要格外关注。​ FIFO按工作时钟域的不同可以分为：同步FIFO和异步FIFO。
FPGA实现双口RAM程序
05-27
以下是一个使用Verilog语言实现的简单双口RAM程序，其中使用两个独立的存储器模块实现双口RAM的功能。该程序可以实现两个模块之间的数据读写操作，但需要根据具体的应用场景进行修改和优化。 ``` module dual_port_ram( input clk, input [7:0] addr1, input [7:0] addr2, input [7:0] data_in1, input [7:0] data_in2, input we1, input we2, output [7:0] data_out1, output [7:0] data_out2 ); reg [7:0] mem1[0:255]; reg [7:0] mem2[0:255]; always @(posedge clk) begin if (we1) mem1[addr1] <= data_in1; if (we2) mem2[addr2] <= data_in2; end assign data_out1 = mem1[addr1]; assign data_out2 = mem2[addr2]; endmodule ``` 在该程序中，`clk`是时钟信号，`addr1`和`addr2`是两个模块的地址输入端口，`data_in1`和`data_in2`是两个模块的数据输入端口，`we1`和`we2`分别表示两个模块的写使能信号，`data_out1`和`data_out2`是两个模块的数据输出端口。 在时钟上升沿时，程序会根据写使能信号判断是否需要进行写操作，并将数据写入对应的存储器模块中。同时，程序会根据地址输入信号从存储器模块中读取数据，并将其输出到对应的数据输出端口。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值