精华内容
下载资源
问答
  • Verilog实现双口RAM

    2012-02-19 20:21:36
    利用Verilog 实现双口RAM 的源代码。
  • fpga中双口ram verilog

    2013-06-16 09:58:07
    本文档针对FPGA设计中的双口RAMverilog语言来描述,采用存储阵列的描述方法,描述了一个存储阵列。
  • 双口RAM verilog源程序

    热门讨论 2009-11-22 22:59:01
    ACTEL公司的fpga,双口RAM实现的源代码,完整工程,已测。
  • 本文档针对FPGA设计中的双口RAMverilog语言来描述,采用存储阵列的描述方法,描述了一个共有256个字的存储阵列。
  • verilog写得一个实现双口ram功能的模块,文件含整个工程,含modelsim仿真文件,方便大家理解。
  • 自己写的采用这种数组形式写的RAM块占用存储器容量的大小,是满足定义的最小的2的n次方。 reg [dw-1:0] mem [(1<<aw) -1:0] /* synthesis syn_ramstyle="block_ram" */; 如果129个数据,>128需要256的ram ...

    自己写的采用这种数组形式写的RAM块占用存储器容量的大小,是满足定义的最小的2的n次方。

    reg [dw-1:0] mem [(1<<aw) -1:0] /* synthesis syn_ramstyle="block_ram" */;
    

    如果129个数据,>128需要256的ram
    所以mem为[7:0],8位地址线

    比方写了一个有300K的存储器块,那实际会生成一个512K的存储块,因为256K不够。

    reg [dw-1:0] mem [300*1024 -1:0] 
    

    实际上

    reg [dw-1:0] mem [512*1024 -1:0] 
    

    如果想节约空间怎么办,写一个256K的存储器RAM之后再写一个64K的存储器RAM,两种通过选择器连接形成一个新的256K + 64K的RAM。

    code

    module ram(
        rclk    ,raddr,dout,
    
        //其他信号,举例dout
        wclk,waddr,wdin,wen
        );
    
        //参数定义
        parameter      ADDR_W =         18; //2^8-1个
        parameter      DATA_W =         8;
        //read输入信号定义
        input               rclk    ;
        input [ ADDR_W -1:0]   raddr  ; 
        //read输出信号定义
        output[DATA_W-1:0]  dout   ;
    
        //write输入信号定义
        input               wclk    ;
        input               wen    ; // write enable, active high
        input [ ADDR_W -1:0]   waddr  ;     
        input [ DATA_W -1:0]   wdin  ;     
    
    
        //中间信号ram定义
        reg[DATA_W -1:0] mem[(1<<ADDR_W)-1:0]  ;//block ram
        reg [ ADDR_W -1:0] ra_buffer;
        
        
        //read 
        always  @(posedge rclk )begin
             ra_buffer<=raddr;
        end
        assign dout=mem[ra_buffer];//数据在地址后的一个周期
        //write 
        always  @(posedge wclk )begin
            if(wen)
             mem[waddr]=wdin;
        end
        initial $readmemh("init_mem",mem);
      
     
        endmodule
    
    
    

    在这里插入图片描述
    在这里插入图片描述

    RAMB36E1为bram,
    BUFG两个时钟,
    LUT2/3/6
    IBUF
    在这里插入图片描述
    寄存器
    在这里插入图片描述

    对于640480一共需要640480个数据,640*480/1024=300K,所以为了省bram空间,拆成256K+64K,用addr[18]作为分界线

    初始化mem文件
    通过载入ram
    initial $readmemh(“bmp_256K.mem”,mem);

    module vga_dpram(
        input wr_clk ,
        input  [11:0] wr_din,
        input [18:0] wr_addr,
        input   wr,
    
        input rd_clk,
        input [18:0] rd_addr ,
        output   [11:0] rd_dout
    
    
    );
        wire[11:0]  rd_dout_256K;
        wire[11:0]  rd_dout_64K;
        //地址延迟一拍出data
        reg addr18;
        always  @(posedge rd_clk  )begin 
            addr18<=rd_addr[18];
        end
    
        assign rd_dout=(addr18==0)?rd_dout_256K:rd_dout_64K;
        generic_dpram_256Kx12 ram_256Kx12(
                .rclk (    rd_clk     ),
                .raddr(    rd_addr[17:0] ),
                .dout (    rd_dout_256K    ),
                .wclk (     wr_clk    ),
                .waddr(     wr_addr[17:0]    ),
                .wdin (     wr_din     ),
                .wen  (     wr&~rd_addr[18]       )
        );
        generic_dpram_64Kx12 ram_64Kx12(
                .rclk (    rd_clk     ),
                .raddr(    rd_addr[17:0]),
                .dout (    rd_dout_64K    ),
                .wclk (     wr_clk    ),
                .waddr(     wr_addr[17:0]    ),
                .wdin (     wr_din     ),
                .wen  (     wr  &rd_addr[18]      )
        );
        endmodule
     
    
    module generic_dpram_256Kx12(
    
            rclk    ,raddr,dout,
    
        //其他信号,举例dout
        wclk,waddr,wdin,wen
        );
    
        //参数定义
        parameter      ADDR_W =         18;  
        parameter      DATA_W =         12;
        //read输入信号定义
        input               rclk    ;
        input [ ADDR_W -1:0]   raddr  ; 
        //read输出信号定义
        output[DATA_W-1:0]  dout   ;
    
        //write输入信号定义
        input               wclk    ;
        input               wen    ; // write enable, active high
        input [ ADDR_W -1:0]   waddr  ;     
        input [ DATA_W -1:0]   wdin  ;     
    
    
        //中间信号bram定义
        reg[DATA_W -1:0] mem[(1<<ADDR_W)-1:0]  ;//block ram
        reg [ ADDR_W -1:0] ra_buffer;
        
        
        //read 
        always  @(posedge rclk )begin
             ra_buffer<=raddr;
        end
        assign dout=mem[ra_buffer];//数据在地址后的一个周期
        //write 
        always  @(posedge wclk )begin
            if(wen)
             mem[waddr]=wdin;
        end
        initial $readmemh("bmp_256k.mem",mem);
      
     
    endmodule
    
    
    module generic_dpram_64Kx12(
    
            rclk    ,raddr,dout,
    
        //其他信号,举例dout
        wclk,waddr,wdin,wen
        );
    
        //参数定义
        parameter      ADDR_W =         16;  
        parameter      DATA_W =         12;
        //read输入信号定义
        input               rclk    ;
        input [ ADDR_W -1:0]   raddr  ; 
        //read输出信号定义
        output[DATA_W-1:0]  dout   ;
    
        //write输入信号定义
        input               wclk    ;
        input               wen    ; // write enable, active high
        input [ ADDR_W -1:0]   waddr  ;     
        input [ DATA_W -1:0]   wdin  ;     
    
    
        //中间信号bram定义
        reg[DATA_W -1:0] mem[(1<<ADDR_W)-1:0]  ;//block ram
        reg [ ADDR_W -1:0] ra_buffer;
        
        
        //read 
        always  @(posedge rclk )begin
             ra_buffer<=raddr;
        end
        assign dout=mem[ra_buffer];//数据在地址后的一个周期
        //write 
        always  @(posedge wclk )begin
            if(wen)
             mem[waddr]=wdin;
        end
        initial $readmemh("bmp_64k.mem",mem);
      
     
    endmodule
    
    

    在这里插入图片描述
    tb
    按地址读出数据,测试是否初始化数据正确

    module ram_dout_tb();
    
     
     
        parameter CNT_LEN=640*480;
        reg rst_n;
    
        //uut的输入信号
        reg[11:0]  wr_din  ;
        reg[18:0] wr_addr  ;
        reg wr;
        initial begin
             wr = 0;
             wr_din=0;
             wr_addr=0;
        end
    
        reg rd_clk;
        reg [18:0] rd_addr ;
        wire   [11:0] rd_dout;
        always  @(posedge rd_clk or negedge rst_n)begin
            if(rst_n==1'b0)begin
                rd_addr<=0;
            end
            else if(rd_addr==CNT_LEN-1)begin
                rd_addr<=0;
            end
            else begin
                rd_addr<=rd_addr+1;
            end
        end
     
       //时钟周期,单位为ns,可在此修改时钟周期。
       parameter CYCLE    = 40;
    
       //复位时间,此时表示复位2个时钟周期的时间。
       parameter RST_TIME = 2 ;
    
    
       vga_dpram uut(
        .  wr_clk (    rd_clk       ),
        .   wr_din(     wr_din      ),
        .   wr_addr(    wr_addr      ),
        .   wr      (   wr               ),
                              
       .  rd_clk  (   rd_clk         ),
       .  rd_addr (   rd_addr        ),
       .  rd_dout (   rd_dout        )
    
    
       );
    
    
         //生成本地时钟25M
         initial begin
             rd_clk = 0;
             forever
             #(CYCLE/2)
             rd_clk=~rd_clk;
         end
    
         //产生复位信号
         initial begin
             rst_n = 1;
             #2;
             rst_n = 0;
             #(CYCLE*RST_TIME);
             rst_n = 1;
         end
    endmodule
    

    数据应该在地址后一个时钟输出。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    抽样检测正确

    展开全文
  • ALTERA FPGA IP SRAM应用DEMO双口RAM读写测试Verilog源码工程文件, FPGA型号EP4CE10F17C,Quartus版本18.0。 module ram_rw( input clk , //时钟信号 input rst_n , //复位信号,低电平有效 output ram_wr_en ...
  • 双口ram读写

    千次阅读 2020-06-27 10:36:11
    双口ram读写 具体要求 将0-1023存入ram并读出,a端口写入数据,b端口读出数据,两个端口的时钟频率设置相同,仿真时以50m写入12.5m读取 单端口时读和写不能同时进行,双端口ram多了一个读地址,可以同时读写 设计...

    项目名称

    双口ram读写

    具体要求

    将0-1023存入ram并读出,a端口写入数据,b端口读出数据,两个端口的时钟频率设置相同,仿真时以50m写入12.5m读取

    单端口时读和写不能同时进行,双端口ram多了一个读地址,可以同时读写

    设计架构

                      

    代码设计

    verilog代码设计

    ram ipcore创建,位宽10,深度1024

    顶层模块设计

    module dram_top(
    	input					a_clk,
    	input					b_clk,
    	input					rst_n,
    	
    	output [9:0]		a_q,
    	output [9:0]		b_q
    );
    
    wire a_wren;
    wire b_wren;
    wire [9:0]a_addr;
    wire [9:0]b_addr;
    wire [9:0]a_data;
    dram_ctrl dram_ctrl(
    	.a_clk(a_clk),
    	.b_clk(b_clk),
    	.rst_n(rst_n),
    
    	.a_wren(a_wren),//写请求
    	.a_addr(a_addr),//写地址
    	.a_data(a_data),//写数据
    
    	.b_wren(b_wren),//写请求
    	.b_addr(b_addr) //写地址
    );
    
    my_ram  my_ram(
    	.address_a(a_addr),
    	.address_b(b_addr),
    	.clock_a(a_clk),
    	.clock_b(b_clk),
    	.data_a(a_data),
    	.data_b(),
    	.wren_a(a_wren),
    	.wren_b(b_wren),
    	.q_a(a_q),
    	.q_b(b_q)
    );
    
    endmodule

    ram读写控制

    module dram_ctrl(
    	input					a_clk,
    	input					b_clk,
    	input					rst_n,
    	
    	output	reg    	a_wren,//写请求
    	output	reg[9:0]	a_addr,//写地址
    	output	reg[9:0]	a_data,//写数据
    	
    	output 	reg		b_wren,//写请求
    	output	reg[9:0] b_addr //写地址
    );
    
    always@(posedge a_clk or negedge rst_n)
    	if(!rst_n)
    		begin
    			a_wren<=0;
    			a_addr<=10'd0;
    			a_data<=10'd0;
    		end
    	else if(a_addr<10'd1023)
    		begin
    			a_wren<=1;
    			a_addr<=a_addr+1'b1;
    			a_data<=a_data+1'b1;
    		end
    	else
    		begin
    			a_wren<=0;
    			a_addr<=a_addr;
    			a_data<=a_data;
    		end
    //a端口写数据,b端口读数据,b端口写请求关闭,读出a端口的数据
    always@(posedge b_clk or negedge rst_n)
    	if(!rst_n)
    		begin
    			b_wren<=0;
    			b_addr<=10'd0;
    		end
    	else
    		begin
    			b_addr<=b_addr+1;
    		end
    endmodule

    仿真代码

    `timescale 1ns/1ns
    module dram_top_tb;
    	reg					a_clk;
    	reg					b_clk;
    	reg					rst_n;
    	
    	wire    [9:0]		a_q;
    	wire    [9:0]		b_q;
    
    dram_top dram_top(
    	.a_clk(a_clk),
    	.b_clk(b_clk),
    	.rst_n(rst_n),
    
    	.a_q(a_q),
    	.b_q(b_q)
    );
    
    initial a_clk=0;
    always #10 a_clk=~a_clk;//以50mhz的时钟写入
    
    initial b_clk=0;
    always #40 b_clk=~b_clk;//以12.5mhz的时钟读取数据
    
    initial begin
    	rst_n=0;
    	#200;
    	rst_n=1;
    end
    
    endmodule

    仿真结果

     

    展开全文
  • FPGA:双口RAM

    千次阅读 2018-12-22 15:29:07
    Xilinx IP核构建双口RAM双口RAMIP核配置Verilog代码top文件testbench仿真图 双口RAM 利用Xilinx提供的IP核构建真双口RAM,通过状态机实现从A口写数据,从B口读取数据。同样也可以在B口写入数据,A口读取数据。这样的...

    双口RAM

    利用Xilinx提供的IP核构建真双口RAM,通过状态机实现从A口写数据,从B口读取数据。同样也可以在B口写入数据,A口读取数据。这样的双口RAM可以用在异构系统中。

    IP核配置

    IP核Block Memory Generator配置过程如下:

    1. Basic 类型选择Native,True Dual Port RAM;
      其他默认就好
      2.Port A
      3.
      3.Port B
      在这里插入图片描述
    2. Other options:在这里插入图片描述
    3. Summary:在这里插入图片描述

    Verilog代码

    top文件

    `timescale 1ns / 1ps
    //
    // Company: 
    // Engineer: 
    // 
    // Create Date: 2018/12/18 16:28:04
    // Design Name: 
    // Module Name: ram_ftt
    // Project Name: 
    // Target Devices: 
    // Tool Versions: 
    // Description: 
    // 
    // Dependencies: 
    // 
    // Revision:
    // Revision 0.01 - File Created
    // Additional Comments:
    // 
    //
    
    
    module ram_ftt(
                  input clk,
                  input rst,
                  input ena,
                  input enb,
                  input wea,
                  input [9:0]addr,
                  input [15:0]din,
                  output [15:0]douta,
                  output [15:0]dout               
        );
        
        reg rst_n;
    //    reg ena;
    //    reg enb;
    //    reg wea;
        reg web;
        reg [9:0]addra;
        reg [9:0]addrb;
        reg [15:0]dina;
        reg [15:0]dinb;
    //    reg [15:0]douta;
        reg [15:0]doutb;
        reg [15:0]din_reg;
    //    reg [31:0]dout;
        reg [3:0] current_state,next_state;
        reg write_end;
        reg read_end;
         reg [15:0]ram [9:0];
        reg [15:0]read_ram [9:0];
       // integer i=0;
        parameter 
                idle=4'b0000,
                write=4'b0001,
                read=4'b0010;  
    // assign din=dina;
    // assign dout=doutb;
    //第一个always块,时序逻辑,描述现态转移到次态
        always @ (posedge clk or negedge rst) begin
            if(!rst) begin
                current_state<=idle;
                end
            else
                current_state<=next_state;
        end
        
        //第二个always块,组合逻辑,描述状态转移的条件
        always @ (current_state or wea) begin                                                                                                                      
            case(current_state)
            idle:begin
                if(wea)        next_state <= write;//状态转移
                else           next_state <= idle;
                end
            write:begin
                if(!wea)       next_state <= read;//状态转移
                else                next_state <= write;
                end
             read:begin
                 if(addr==10)     next_state <= idle;//状态转移
                 else             next_state <= read;
                 end
            default: begin
                    next_state = idle;//状态转移
                   end
            endcase
        end
        //第三个always块,时序逻辑,描述输出
        always @ (negedge clk or negedge rst) begin
        if(!rst)begin
                //addra<=0;
                //addra<=addr;
                //dina <= din;
               // dina<=0;
               // addrb<=0;
              end
        else
            case(current_state)
            idle: begin 
                       // addra<=0;
                        addra<=0;
                        dina<=0;
                       
                       // addrb<=0;
                   end
            write: begin   
                        //i=i+1;
                        addra<=addr;                                                                                                                               
                        //addra<=i;   
                        dina<=din; 
                    end
            read:begin
                      addrb=addr;                                         
                   end
            default:begin
                     write_end<=0;
                     read_end<=0;
                    end
            endcase
        end
     blk_mem_gen_0 sim(
                .clka(clk),
                .clkb(clk),
                .ena(ena),
                .enb(enb),
                .wea(wea),
                .web(),
                .addra(addra),
                .addrb(addrb),
                .dina(dina),
                .dinb(),
                .douta(douta),
                .doutb(dout)
                );  
    endmodule
    

    testbench

    `timescale 1ns / 1ps
    //
    // Company: 
    // Engineer: 
    // 
    // Create Date: 2018/12/17 15:06:05
    // Design Name: 
    // Module Name: sim
    // Project Name: 
    // Target Devices: 
    // Tool Versions: 
    // Description: 
    // 
    // Dependencies: 
    // 
    // Revision:
    // Revision 0.01 - File Created
    // Additional Comments:
    // 
    //
    
    
    module simu;
        //module top(clka,clkb,ena,enb,wea,web,addra,addrb,dia,dib,doa,dob);  
        reg clk;
        reg rst;
        reg ena;
        reg enb;
        reg wea;
        reg [9:0]addr;
        reg [15:0]din;
    wire [15:0]douta;
        wire [15:0]dout;
        reg[15:0] ram_a [9:0];
        integer i=0;
    initial $readmemh("F:/date0.txt",ram_a);    
    
        initial begin 
                 clk=0;
                 rst=1;
                 addr=0;
                 ena=0;
                 enb=0;
                 wea=0;
                 din=1;
            #50   rst= 0;
            #50   rst=1;
                  ena= 1;
                  wea=1;
                  enb=1;
                  addr=0;
    
        end
        always #10 clk =  ~clk;
    
    always @(negedge clk or negedge rst)
        begin 
        if(!rst)begin
                addr<=1;
                end
        else begin       
                 addr<=addr+1;     
                 if(addr>=10)  begin
                              wea<=!wea;    
                              addr<=1; 
                              end 
                 
                if(wea) din<= ram_a[addr];  
               end
     
         end
    ram_ftt sim(.clk(clk),.rst(rst),.addr(addr),.din(din),.ena(ena),.enb(enb),.wea(wea),.douta(douta),.dout(dout));
    endmodule
    
    

    仿真图

    直接输入1次#,并按下space后,将生成1级标题。输入2次#,并按下space后,将生成2级标题。以此类推,我们支持6级标题。有助于使用语法后生成一个完美的目录。

    展开全文
  • module ram_16( input clk, input rst_n ); reg ena;//总使能控制 reg wren1;//RAM1使能 reg wren2;//RAM2使能 reg [7:0] addr;//8位地址位 reg [7:0] writedata;//写入数据 reg [7:0] readdata;//读取...

    功能代码:

    `timescale 1ns / 1ps
    module ram_16(
        input clk,
        input rst_n	 
    );
    	reg ena;//总使能控制
    	reg wren1;//RAM1使能
    	reg wren2;//RAM2使能
    	reg [7:0] addr;//8位地址位
    	reg [7:0] writedata;//写入数据
    	reg [7:0] readdata;//读取数据
    	wire [7:0] readdata_flag;
    	
    	reg state;//状态寄存器
    
    
    always @ (posedge clk or negedge rst_n)//写地址信号控制0~15
    begin
        if(!rst_n) 
    		begin
    		ena <= 0;
    		wren1 <= 0;
    		wren2 <= 0;
    		addr <= 0;
    		writedata <= 0;
    		state <= 0;
    		end
        else 
    	begin
    	case(state)
    	0:begin
            if(addr < 255)//RAM1中0~255地址写数据
    		begin 
    			addr <= addr + 1;
    			ena <= 1;
    			wren1 <= 1;
    		end
    		else
    		begin
    			addr <= 0; //转到下一个状态,地址清0,开始读
    			state <= 1;
    			wren1 <= 0;
    			wren2 <= 1;
    		end
    		if(writedata < 255)
    			writedata <= writedata + 1;
    		else 
    			writedata <= 0;
    			
    	1:begin
    		if(addr < 255)
    		begin
    			addr <= addr + 1;
    			wren2 <= 1;
    			wren1 <= 0;
    			readdata_flag = readdata;
    		end
    		else 
    		begin
    			state <= 0;
    			addr <= 0;
    		end
    	end
    	dafault:state <= state;
    	endcase
    	
    	end
    end	
    
    blk_mem_gen_0 u1 (
      .clka(clk),      //写端口
      .ena(ena),    
      .wea(wren1),      
      .addra(addr),  
      .dina(writedata),   
      .douta(), 
      
      .clkb(clk),      //读端口
      .enb(ena),      
      .web(wren2),      
      .addrb(addr),  
      .dinb(8'd0),    
      .doutb(readdata) 
    );
    endmodule				
    
    

    testbench:

    `timescale 1ns / 1ps
    module TB();
    reg clk;
    reg rst_n;
    
    always #5 clk = ~clk;
    endmodule
    
    展开全文
  • 基于FPGA的双口RAM

    2012-11-30 12:41:05
    基于CYCLONE的双口RAM代码,用Verilog编写,实现利用内部M4K内存块实现双口RAM
  • 本文充分利用FPGA内部丰富的硬件资源和Verilog HDL语言的灵活性,在FPGA内实现了双口RAM的基本功能,并通过设计一块数据采集板介绍基于FPGA技术的双口RAM的应用,该系统减小了设计电路的复杂性,增强了设计的灵活性...
  • Verilog实现双口异步SRAM,进行原理介绍,Verilog实现,仿真验证,结果分析,以及电路综合结果,对SRAM有一个更深的认识; 编写一个简单的RAM很容易,但是要编写一个稳定的,考虑全面的RAM绝非易事。这也是为什么...
  • 7 实现深度16、位宽8bit的伪双口异步RAM,a端口读数据,b端口写数据 Verilog代码: module dpram16x8( input clka, input clkb, input rst, input cs, // port a input ren, input [3:0] addra, ...
  • altera fpga 双口ram ip核的运用

    热门讨论 2012-03-01 12:21:19
    文件是整个工程,包含verilog编写的数据、地址产生模块,包含testbench的测试代码,并用modelsim进行了仿真。方便大家理解双口ram ip核的使用。
  • 串口收发与存取双口ram简易应用 1 原理图 2 Verilog 代码 3 Modelsim仿真 4. FPGA板级验证 串口收发与存取双口ram简易应用 实验现象:在pc机上通过串口发送数据到FPGA中,FPGA收到的数据后,将数据存储在双口ram的...
  • verilog实现(infer)一个异步(双口)RAM

    千次阅读 2018-10-13 17:01:21
    在异步FIFO的应用中所用的存储器一般都是RAM,所以异步的RAM对于异步FIFO实现是基础的 module asyn_ram #(parameter DWIDTH=4,//data width AWIDTH=10)//address width ( input wr_clk, input[DWIDTH-1:0] ...
  • Verilog实现一个异步端口ram,深度16,位宽8bit。A 读出,B写入。支持片选,读写请求,要求代码可综合。 module as_dul_RAM #( parameter addr_width = 4, parameter data_width = 8, parameter data_...
  • 1,实现双口RAM,完全掌握调用IP核的流程; 2,深入了解RAM,模拟1450字节数据,然后写入RAM,完成测试; 3,完成RAM读写测试,数据“顺序”输出。
  • verilog ram读写ip核

    千次阅读 2018-09-29 11:05:00
    一、问题描述 平台是ISE。我想实现调用ram ip核,先写进去一段数据,再读取这段数据,选用的是单口ram。 ADDRA:地址位。写的时候先赋地址,再给DINA赋数据就写进去了;...考虑是不是要换成双口ram。...
  • 双口FIFO与RAM

    2019-06-27 09:54:10
    该部分转载自异步FIFO—Verilog实现与异步FIFO设计 一、FIFO简介 FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,它与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是...
  • FPGA实现双口arm的读写,详细代码介绍,注释,零基础也能收获
  • 基于Xilinx spartan6 lx9的片内block ram读写测试; 包含ip核的例化,读写测试数据的写入读出 真双口模式,读写设置为no change; 对不同地址边读边写;

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

verilog双口ram