vivado DDR4读写存储以及一些坑

最新推荐文章于 2024-03-23 13:09:44 发布
最新推荐文章于 2024-03-23 13:09:44 发布
阅读量1.8k 收藏 17
点赞数 1
文章标签： java servlet html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZZ2588/article/details/125405767
版权

DDR4读写控制模块

module ddr4_control#(
     parameter         			MEM_DATA_BITS                  		= 512                         			,
     parameter         			ADDR_BITS                  			= 26                         			,
     parameter         			BUSRT_BITS                  		= 10                         			,//突发的位宽长度
     parameter         			BURST_LEN                  			= 5                         			
)
(
    input                                                               i_sys_clk                                   ,                                   
    input                                                               i_sys_rst                                   ,  	
    
    input                                                               i_wr_data_rdy                               ,  	
    output     reg     [MEM_DATA_BITS-1:0]                              o_wr_data		    						,
    output     reg        					                            o_wr_ddr4_req		    					,
    
    input             					                                i_rd_data_vaild		    					,
    input              [MEM_DATA_BITS-1:0]					            i_rd_ddr4_data		    					,
    output     reg                         					            o_rd_ddr4_req		    					,
    
    output             [BUSRT_BITS-1:0]					     	        o_wr_burst_length		    				,
    output             [BUSRT_BITS-1:0]					           	    o_rd_burst_length		    				,
    
    output     reg     [ADDR_BITS-1:0]					           	    o_wr_base_ddr4_addr		    				,
    output     reg     [ADDR_BITS-1:0]					           	    o_rd_base_ddr4_addr		    				,
    
    input         				           	 						    i_wr_finished			    				,
    input         				           	 						    i_rd_finished			    				

);

	localparam													IDLE = 3'b000					;
	localparam													WRITE = 3'b001					;
	localparam													READ = 3'b011					;

	reg						[11:0]								wr_data_count					;	
	reg						[11:0]								rd_data_count					;	
	reg						[2:0]								current_state					;	
	reg						[2:0]								next_state						;	
	
	
	assign	o_wr_burst_length = BURST_LEN;	
	assign	o_rd_burst_length = BURST_LEN;	

	always @(posedge i_sys_clk or posedge i_sys_rst) begin
		if(i_sys_rst) begin
			current_state <= IDLE;
		end
		else begin
			current_state <= next_state;
		end
	end	
	
	always @(*) begin
		case(current_state)
			IDLE: begin
						next_state = WRITE;
				end
			WRITE: begin
					if(i_wr_finished) begin
						next_state = READ;						
					end
					else begin
						next_state = WRITE;
					end
				end
			READ: begin
					if(i_rd_finished) begin
						next_state = IDLE;
					end
					else begin
						next_state = READ; 
					end
				end
			default:begin
						next_state = IDLE;
					end
		    endcase
	end
	
	always @(posedge i_sys_clk or posedge i_sys_rst) begin
		if(i_sys_rst) begin
			o_wr_ddr4_req <= 1'd0;
			o_rd_ddr4_req <= 1'd0;
		end
		else if( current_state == IDLE || (current_state == READ && i_rd_finished))begin
			o_wr_ddr4_req <= 1'd1;
			o_rd_ddr4_req <= 1'd0;
		end
		else if( current_state == WRITE && i_wr_finished)begin
			o_wr_ddr4_req <= 1'd0;
			o_rd_ddr4_req <= 1'd1;
		end		
		else begin
			o_wr_ddr4_req <= o_wr_ddr4_req;
			o_rd_ddr4_req <= o_rd_ddr4_req;
		end
	end		
	
	always @(posedge i_sys_clk or posedge i_sys_rst) begin
		if(i_sys_rst) begin
			wr_data_count <= 12'd0;
		end
		else if(current_state == WRITE && wr_data_count == BURST_LEN - 12'd1 || current_state == IDLE ) begin
			wr_data_count <= 12'd0;		
		end
		else if(current_state == WRITE && i_wr_data_rdy ) begin
			wr_data_count <= wr_data_count + 12'd1;
		end
		else begin
			wr_data_count <= wr_data_count;
		end
	end
	
	always @(posedge i_sys_clk or posedge i_sys_rst) begin
		if(i_sys_rst) begin
			o_wr_data <= {MEM_DATA_BITS{1'd0}};
		end
		else if(current_state == WRITE && i_wr_data_rdy ) begin
			o_wr_data <= o_wr_data + 'd10;
		end
		else begin
			wr_data_count <= wr_data_count;
		end
	end	
				
	always @(posedge i_sys_clk or posedge i_sys_rst) begin
		if(i_sys_rst) begin
			rd_data_count <= 12'd0;
		end
		else if(current_state == READ && rd_data_count == BURST_LEN - 12'd1 || current_state == IDLE ) begin
			rd_data_count <= 12'd0;
		end
		else if(current_state == READ && i_rd_data_vaild ) begin
			rd_data_count <= rd_data_count + 12'd1;
		end
		else begin
			rd_data_count <= rd_data_count;
		end
	end
	
	always @(posedge i_sys_clk or posedge i_sys_rst) begin
		if(i_sys_rst) begin
			o_rd_base_ddr4_addr <= {ADDR_BITS{1'd0}};
			o_wr_base_ddr4_addr <= {ADDR_BITS{1'd0}};
		end
		else if(i_rd_finished ) begin
			o_rd_base_ddr4_addr <= o_rd_base_ddr4_addr + BURST_LEN;
			o_wr_base_ddr4_addr <= o_wr_base_ddr4_addr + BURST_LEN;
		end
		else begin
			o_rd_base_ddr4_addr <= o_rd_base_ddr4_addr;
			o_wr_base_ddr4_addr <= o_wr_base_ddr4_addr;
		end
	end	
	
endmodule

DDR4 app接口控制

module ddr4_app
#(
    parameter         			ADDR_BITS                  			= 26                         			,
	parameter 					MEM_DATA_BITS 						= 512									,
	parameter 					APP_ADDR_BITS 						= 29									,
	parameter 					BURST_BITS 							= 10 //突发长度的位宽
)
(
    input                                                               i_sys_clk                                   ,                                   
    input                                                               i_sys_rst                                   , 	
	
    output                                                              o_wr_data_rdy                               ,	
    input               [MEM_DATA_BITS-1:0]                             i_wr_data		    						,	
    input             					                                i_wr_ddr4_req		    					,	
	
    output             					                                o_rd_data_vaild		    					,
    output              [MEM_DATA_BITS-1:0]					            o_rd_ddr4_data		    					,
    input               									            i_rd_ddr4_req		    					,	
	
    input               [BURST_BITS-1:0]					     	    i_wr_burst_length		    				,
    input               [BURST_BITS-1:0]					            i_rd_burst_length		    				,
    
    input               [BURST_BITS-1:0]					            i_wr_base_ddr4_addr		    				,
    input               [BURST_BITS-1:0]					            i_rd_base_ddr4_addr		    				,
    
    output         		reg		           	 						    o_wr_finished			    				,
    output         		reg		           	 						    o_rd_finished			    				,	
	
	
	//DDR phy接口的信号
    output                  											o_c0_init_calib_complete					,
    input                   											i_c0_sys_clk_p								,
    input                   											i_c0_sys_clk_n								,
    output                  											o_c0_ddr4_act_n								,
    output 				[16:0]         									o_c0_ddr4_adr								,
    output 				[1:0]          									o_c0_ddr4_ba								,
    output 				[0:0]          									o_c0_ddr4_bg								,
    output 				[0:0]          									o_c0_ddr4_cke								,
    output 				[0:0]          									o_c0_ddr4_odt								,
    output 				[0:0]          									o_c0_ddr4_cs_n								,
    output 				[0:0]          									o_c0_ddr4_ck_t								,
    output 				[0:0]          									o_c0_ddr4_ck_c								,
    output 				               									o_c0_ddr4_reset_n							,
    inout  				[7:0]          									io_c0_ddr4_dm_dbi_n							,
    inout  				[63:0]         									io_c0_ddr4_dq								,
    inout  				[7:0]          									io_c0_ddr4_dqs_t							,
    inout  				[7:0]          									io_c0_ddr4_dqs_c							,
    
    output  				          									o_ddr4_clk									,
    output  					         								o_ddr4_rst									
		
);

	localparam													IDLE = 3'b000					;
	localparam													WRITE = 3'b001					;
	localparam													READ = 3'b011					;
	localparam													READ_WAIT = 3'b010				;



	wire 			[APP_ADDR_BITS-1:0]                  				app_addr						;               
	wire 			[2:0]                                				app_cmd							;                
	wire 			                                     				app_en							;                 
	wire 			[MEM_DATA_BITS-1:0]                  				app_wdf_data					;           
	wire 			                                     				app_wdf_end						;            
	wire 			[MEM_DATA_BITS/8-1:0]                				app_wdf_mask					;           
	wire 			                                     				app_wdf_wren					;           
	wire 			[MEM_DATA_BITS-1:0]                  			   	app_rd_data						;            
	wire                                     					    	app_rd_data_end					;        
	wire         	                          					        app_rd_data_valid				;      
	wire                                     						    app_rdy							;                
	wire                                     						    app_wdf_rdy						;            
	                                         						 	                         
	wire                                     					        c0_ddr4_ui_clk					;         
	wire                                     						    c0_ddr4_ui_clk_sync_rst			;
	
	wire            [BURST_BITS + 12 -1 : 0  ]             			    wr_burst_addr					;// burst_addr = base_addr + offset_addr
	wire            [BURST_BITS + 12 -1 : 0  ]             			    rd_burst_addr					;
 
	reg 			[2:0]                                				app_cmd_r						;    
	reg 			                                     				app_en_r						;       
//	reg 			[MEM_DATA_BITS/8-1:0]                				app_wdf_mask_r					;    
	reg 			                                     				app_wdf_wren_r					;    
	reg 			[MEM_DATA_BITS-1:0]                  			   	app_rd_data_r					;    
	reg                                     					    	app_rd_data_end_r				;    
	reg             [MEM_DATA_BITS-1:0]                        	    	app_wdf_data_r					;    
//	reg         	                          					        app_rd_data_valid_r				;   
//	reg                                     						    app_rdy_r						;    
//	reg                                     						    app_wdf_rdy_r					;
	
	
	reg 			[2:0]                                				current_state					; 	  
	reg 			[2:0]                                				next_state						; 	  
	
	reg 			[11:0]                                				wr_data_count					; 	
	reg 			[11:0]                                				wr_addr_count					; 	

	reg 			[11:0]                                				rd_data_count					; 	
	reg 			[11:0]                                				rd_addr_count					; 
//******************************************assign*****************************************************
//    assign o_ddr4_clk = c0_ddr4_ui_clk;
//    assign o_ddr4_rst = c0_ddr4_ui_clk_sync_rst;
	assign  wr_burst_addr = (wr_addr_count + i_wr_base_ddr4_addr) << 3;
	assign  rd_burst_addr = (rd_addr_count + i_rd_base_ddr4_addr) << 3;
	assign  app_cmd = app_cmd_r;
	assign  app_en = app_en_r;
	assign  o_wr_data_rdy = app_wdf_rdy && (current_state == WRITE)&&app_en;
	assign  o_rd_data_vaild = app_rd_data_valid;
	assign  o_rd_ddr4_data = app_rd_data;
//	assign app_wdf_wren = app_en & app_wdf_rdy;	
	assign app_wdf_wren = app_wdf_wren_r;	
	assign	app_addr = (current_state == WRITE) ? wr_burst_addr:
					    (current_state == READ) ? rd_burst_addr: {APP_ADDR_BITS{1'd0}};
	assign	app_wdf_data = i_wr_data;
	assign app_wdf_mask = {MEM_DATA_BITS/8{1'b0}};	
	assign app_wdf_end = app_wdf_wren;
//*****************************************************************************************************

	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			app_wdf_data_r <= {MEM_DATA_BITS{1'd0}};
		end
		else begin
			app_wdf_data_r <= i_wr_data;
		end
	end	


	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			current_state <= IDLE;
		end
		else begin
			current_state <= next_state;
		end
	end	
	
	always @(*)begin
	   if (o_c0_init_calib_complete)
		case(current_state)
			IDLE: begin
					if (i_wr_ddr4_req) begin
						next_state = WRITE;
					end
					else if (i_rd_ddr4_req) begin
						next_state = READ;
					end
					else begin
						next_state = IDLE;
					end
				end
			WRITE: begin
					if(o_wr_finished) begin
						next_state = IDLE;
					end
					else begin
						next_state = WRITE;
					end	
				end
			READ: begin
					if(rd_addr_count == i_rd_burst_length - 'd1 ) begin
						next_state = READ_WAIT;
					end
					else if(o_rd_finished) begin
						next_state = IDLE;						
					end
					else begin
						next_state = READ;
					end
				end
			READ_WAIT: begin
						if (o_rd_finished) begin
							next_state = IDLE;
						end			
						else begin
							next_state = READ_WAIT;
						end
					end	
			default:begin
						next_state = IDLE;
					end	
		endcase
		else begin
		  next_state = IDLE;
		end
	end



	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			app_cmd_r <= 3'd0;
		end
		else if (current_state == WRITE )begin
			app_cmd_r <= 3'd0;
		end
		else if (current_state == READ )begin
			app_cmd_r <= 3'd1;
		end
		else begin
			app_cmd_r <= app_cmd_r;
		end
	end	
	
	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin 
		if(o_ddr4_rst) begin
			app_wdf_wren_r <= 1'd0;
		end
//		else if ((current_state == WRITE && o_wr_finished) ||(current_state == READ &&o_rd_finished  ) ) begin
		else if ((current_state == WRITE && o_wr_finished)) begin
			app_wdf_wren_r <= 1'd0;
		end
		else if ((current_state == WRITE)  && app_rdy && app_wdf_rdy )begin
			app_wdf_wren_r <= 1'd1;
		end
		else begin
			app_wdf_wren_r <= app_wdf_wren_r;
		end
	end	

	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin 
		if(o_ddr4_rst) begin
			app_en_r <= 1'd0;
		end
//		else if ((current_state == WRITE && o_wr_finished) ||(current_state == READ &&o_rd_finished  ) ) begin
		else if ((current_state == WRITE && o_wr_finished) || rd_addr_count == i_rd_burst_length - 1) begin
			app_en_r <= 1'd0;
		end
		else if ((current_state == WRITE || current_state == READ) && app_rdy )begin
			app_en_r <= 1'd1;
		end
		else begin
			app_en_r <= app_en_r;
		end
	end	
	
	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			wr_data_count <= 12'd0;
		end
		else if (current_state == WRITE && wr_data_count == i_wr_burst_length - 12'd1 )begin
			wr_data_count <= 12'd0;
		end
		else if (current_state == WRITE && app_rdy && app_wdf_rdy && app_en_r) begin
			wr_data_count <= wr_data_count + 12'd1;
		end
		else begin
			wr_data_count <= wr_data_count;
		end
	end		
	
	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			wr_addr_count <= 12'd0;
		end
		else if (current_state == WRITE && wr_data_count == i_wr_burst_length - 12'd1 )begin
			wr_addr_count <= 12'd0;
		end
		else if (current_state == WRITE && app_rdy && app_wdf_rdy && app_en_r) begin
			wr_addr_count <= wr_addr_count + 12'd1;
		end
		else begin
			wr_addr_count <= wr_addr_count;
		end
	end		

	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			o_wr_finished <= 1'd0;
		end
		else if (current_state == WRITE && (wr_data_count == i_wr_burst_length - 12'd2 ))begin
			o_wr_finished <= 1'd1;
		end
		else begin
			o_wr_finished <= 1'd0;
		end
	end		

	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			rd_addr_count <= 12'd0;
		end
		else if (current_state == READ &&rd_addr_count == i_rd_burst_length - 'd1  )begin
			rd_addr_count <= 12'd0;
		end
		else if (current_state == READ && app_rdy  && app_en_r) begin
			rd_addr_count <= rd_addr_count + 12'd1;
		end
		else begin
			rd_addr_count <= rd_addr_count;
		end
	end	


	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			rd_data_count <= 12'd0;
		end
		else if ((rd_data_count == i_rd_burst_length -1'd1) && app_rd_data_valid) begin
			rd_data_count <= 12'd0;
		end
		else if ((current_state == READ || current_state == READ_WAIT) && app_rd_data_valid )begin
			rd_data_count <= rd_data_count + 12'd1;
		end
		else begin
			rd_data_count <= rd_data_count;
		end
	end	
	
			

	
	always@(posedge o_ddr4_clk or posedge o_ddr4_rst) begin
		if(o_ddr4_rst) begin
			o_rd_finished <= 1'd0;
		end
		else if (( current_state == READ || current_state == READ_WAIT) && (rd_data_count == i_rd_burst_length - 12'd1 ) && app_rd_data_valid)begin
			o_rd_finished <= 1'd1;
		end
		else begin
			o_rd_finished <= 1'd0;
		end
	end			


ddr4_0 u_ddr4
  (
   .sys_rst           		     	(i_sys_rst			),

   .c0_sys_clk_p                    (i_c0_sys_clk_p		),
   .c0_sys_clk_n                    (i_c0_sys_clk_n		),
   .c0_init_calib_complete (o_c0_init_calib_complete	),
   .c0_ddr4_act_n          			(o_c0_ddr4_act_n	),
   .c0_ddr4_adr            			(o_c0_ddr4_adr		),
   .c0_ddr4_ba             			(o_c0_ddr4_ba		),
   .c0_ddr4_bg             			(o_c0_ddr4_bg		),
   .c0_ddr4_cke            			(o_c0_ddr4_cke		),
   .c0_ddr4_odt            			(o_c0_ddr4_odt		),
   .c0_ddr4_cs_n           			(o_c0_ddr4_cs_n		),
   .c0_ddr4_ck_t           			(o_c0_ddr4_ck_t		),
   .c0_ddr4_ck_c           			(o_c0_ddr4_ck_c		),
   .c0_ddr4_reset_n        			(o_c0_ddr4_reset_n	),
                           			
   .c0_ddr4_dm_dbi_n       			(io_c0_ddr4_dm_dbi_n),
   .c0_ddr4_dq             			(io_c0_ddr4_dq		),
   .c0_ddr4_dqs_c          			(io_c0_ddr4_dqs_c	),
   .c0_ddr4_dqs_t          			(io_c0_ddr4_dqs_t	),

   .c0_ddr4_ui_clk                  (o_ddr4_clk			),
   .c0_ddr4_ui_clk_sync_rst         (o_ddr4_rst			),
   .dbg_clk                         (dbg_clk			),

   .c0_ddr4_app_addr           	    (app_addr			),
   .c0_ddr4_app_cmd            	    (app_cmd			),
   .c0_ddr4_app_en             	    (app_en				),
   .c0_ddr4_app_hi_pri         	    (1'b0				),
   .c0_ddr4_app_wdf_data       	    (app_wdf_data		),
   .c0_ddr4_app_wdf_end        	    (app_wdf_end		),
   .c0_ddr4_app_wdf_mask       	    (app_wdf_mask		),
   .c0_ddr4_app_wdf_wren       	    (app_wdf_wren		),
   .c0_ddr4_app_rd_data        	    (app_rd_data		),
   .c0_ddr4_app_rd_data_end    	    (app_rd_data_end	),
   .c0_ddr4_app_rd_data_valid  	    (app_rd_data_valid	),
   .c0_ddr4_app_rdy            	    (app_rdy			),
   .c0_ddr4_app_wdf_rdy        	    (app_wdf_rdy		),
  
  // Debug Port
  .dbg_bus        				    (dbg_bus			)                                             

  );
endmodule

时序设计图：

DDR4_control

 DDR4_APP

 

 

 

 

ZZ2588
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
zedboard如何从PL端控制DDR读写(四)
weixin_34160277的博客
07-19 1218
zedboard如何从PL端控制DDR读写(四) PS-PL之间的AXI 接口分为三种：• 通用 AXI（General Purpose AXI） — 一条 32 位数据总线，适合 PL 和 PS 之间的中低速通信。接口是透传的不带缓冲。总共有四个通用接口：两个 PS 做主机，另两个 PL 做主机。• 加速器一致性端口（Accelerator ...
基于Xilinx FPGA的多通道DDR4读写控制模块（包含整个工程）
04-08
在Xilinx FPGA中通过AXI接口逻辑，实现4个独立的DDR4读写通道，通道数可由参数配置，完成对DDR4的控制，上传为完整工程，开发环境为Vivado2018.2，已经上板验证。
DDR4总结最全纯干货分享
启芯硬件的博客
03-23 1058
DDR存储器发展的主要方向一言以蔽之，是更高速率，更低电压，更密的存储密度，从而实现更好的性能。DDR4 SDRAM（Double Data Rate Fourth SDRAM）：DDR4提供比DDR3/ DDR2更低的供电电压1.2V以及更高的带宽，DDR4的传输速率目前可达2133～3200MT/s。
Vivado中DDR4的使用
weixin_42614350的博客
06-28 9693
最近在使用 Xilinx 的 VU9P 板卡做一些基于FPGA的神经网络加速部署，其中就用到了 DDR 进行数据的存储。 板卡具体型号如下图所示 : 资源分布量如下图所示 : 注意 如果板卡型号属于 7系列 Xilinx 板卡型号，那么其 DDR 类型为 DDR3 资源。 如果板卡型号属于 Ultra 系列，那么 DDR 的类型就属于 DDR4 资源。 由于我所使用的板卡为 Ultra 系列，故使用的为 DDR4 类型。 DDR4-MIG核配置 ...
FPGA MPSoC_XCZU2CG驱动DDR4读写数据（Vivado Design Suite和Verilog HDL实现）
04-25
FPGA MPSoC XCZU2CG、XCZU2EG和XCZU4EV驱动程序。 基于Vivado Design Suite和Verilog HDL实现。 项目代码可顺利编译运行~
【正点原子FPGA连载】第三十一章DDR4读写测试实验 摘自【正点原子】DFZU2EG/4EV MPSoC 之FPGA开发指南V1.0
weixin_55796564的博客
12-07 6117
1）实验平台：正点原子MPSoC开发板 2）平台购买地址：https://detail.tmall.com/item.htm?id=692450874670 3）全套实验源码+手册+视频下载地址： http://www.openedv.com/thread-340252-1-1.htmlDDR4 SDRAM（Double-Data-Rate Fourth Generation Synchronous Dynamic Random Access Memory，简称为DDR4 SDRAM），是一种高速动态随机存
zcu102用PL读写DDR4
07-10
博客配套源码工程 https://blog.csdn.net/botao_li/article/details/95302992
基于MIG的DDR3读写测试电路Vivado工程已上板测试
04-01
自己编写的基于MIG IP核的针对DDR3的读写测试电路，非自带的示例工程，可用于快速熟悉MIG用户接口的时序关系及使用方法。压缩包内为Vivado工程，已成功上板调试。附带testbench，tb里包含有DDR3仿真模型及wiredelay...
vivado生成ddr容易出错的地方
12-26
在 Vivado 中生成 DDR 时，经常会遇到一些容易出错的地方，本文将对这些常见的问题进行总结和分析。 DDR 时钟问题 在 Vivado 中，生成 DDR 时，时钟问题是一个常见的问题。例如，在上面的例子中，input clock ...
基于Xilinx FPGA的AXI接口多通道DDR4读写控制模块l逻辑Vivado2018.2 工程源码.zip
最新发布
04-04
基于Xilinx FPGA的AXI接口多通道DDR4读写控制模块l逻辑Vivado2018.2 工程源码，实现4个独立的DDR4读写通道，通道数可由参数配置。
FPGA-ZCU106-PL侧读写ddr4（全网唯一）
qq_37912811的博客
07-23 6641
本次给大带来了ZCU106的PL侧读写ddr4的教程，本教程是全网唯一ZCU106教程。本教程采用的是xilinx的ddr4的IP核的AXI4接口开发的，因此需要先了解AXI4总线协议。
FPGA（XILINX） DDR3 内存条 读写测试 仿真通过 （VIVADO 2015.2）
05-10
FPGA（XILINX） DDR3 内存条 读写测试 仿真通过 （VIVADO 2015.2）
【常见错误】FPGA器件DDR类型选择错误
记录学习历程
02-15 1872
ZedBoard开发常见错误： DDR的型号配置错误。间接会导致的结果是，在调试debug时，会发现cpu一直处于running的状态，但是在控制台并不能看到打印的信息，并且不管是只用了PS端或者是PS、PL端都用了，都不能在控制台上出现打印信息，但是程序可以烧录到板子上（program FPGA时发现板子上的蓝灯会亮），这说明板子本身是没问题的，排除了接线的问题，最终发现是在配置block design的DDR的信息时，DDR的型号选择错误的原因，型号选择错误会导致，程序烧录进板子后，但是由于没有配置对
Xilinx DDR4/DDR3 多通道读写防冲突设计，可实现最高8个通道同时读写DDR且不冲突问题，通道数可根据使用来决定
m0_74696928的博客
10-25 1781
此工程经过2个月的实际上板疲劳测试，功能稳定，时序健壮，性能优异，有需要用到DDR4/DDR3的多通道/单通道的地方，此工程代码可直接移植。本工程通过Vivado实现，程序中包含详细注释，另赠送一份详细设计说明文档，保证可以弄懂DDR的逻辑和设计架构，可直接应用于工程设计中。Xilinx DDR4/DDR3 多通道读写防冲突设计，可实现最高8个通道同时读写DDR且不冲突问题，通道数可根据使用来决定。每个通道读写接口简单，操作独立，可同时实现最高8个通道的读写请求。
DDR4 MIG IP核 FPGA使用及读写测试
热门推荐
jingjiankai5228的博客
02-12 1万+
**前言** Xilinx提供了这样的IP核，名为MIG（Memory Interface Generator），它可以为提供DDR3、DDR4等多种存储器提供接口。本次DDR4读写采用的就是这个IP核，不过7系的FPGA与UltraScale系的FPGA所所对应的MIG IP核在客制化上有所区别，本文暂且只讨论UltraScale+系列FPGA所对应的MIG IP核，并且只针对DDR4的使用。...
vivado 验证ddr引脚_UltraScale DDR4 — 从 Vivado 2016.1 版开始，读取和写入 Vref 校准均被禁用。...
weixin_42114645的博客
02-11 1485
Xilinx专家解答：经过特性描述，已确定无需读取和写入 Vref 校准。默认读取／写入 Vref 设置的眼图大小和校准后读取／写入值的眼图大小一样。各校准级会增加校准时间，而且已发现不会给眼图大小产生有益影响，因此从 2016.1 版起，这些校准级已被禁用。如果您要手动重新启用这些校准级，请按下列步骤操作：1) 请按照(UG896)中的步骤修改 IP。查看“编辑 IP 资源”部分。2)在 V...
canny算子_紫光同创PGL22G开发平台试用连载（3）——驱动OV5640 摄像头实现sobel算子边缘检测算法...
weixin_39887925的博客
11-28 653
通过近一个月的学习，紫光同创PGL22Gfpga已经和spartan6和kintex7不相上下了，紫光EDA生态也趋于完善。EDA是FPGA皇冠上的明珠。FPGA更大的逻辑规模和更高的性能，意味着指数级增长的软件算法复杂度。Pango Design Suite是紫光同创基于多年FPGA开发软件技术攻关与工程实践经验而研发的一款拥有国产自主知识产权的大规模FPGA开发软件，已经可以支持数千...
FPGA开发——vivado使用
知识，既贵，又便宜。
09-09 4844
用vivado仿真和FPGA开发的一些记录
vivado自学第一天
weixin_53262103的博客
07-17 145
自学自学vivado
vivado ddr3 读写仲裁
04-01
在Vivado中，DDR3读写仲裁是通过Memory Interface Generator（MIG）实现的。MIG是一种用于生成存储器接口的IP核，可以用于生成各种存储器接口，包括DDR3。 在MIG中，读写仲裁是通过控制器中的命令和数据通道实现的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值