Vivado MIG ip核使用教程（三）

数据线

已于 2024-04-12 14:28:14 修改

阅读量512

点赞数 6

文章标签： fpga开发 fpga DDR3

于 2024-04-12 14:25:30 首次发布

本文链接：https://blog.csdn.net/weixin_45545092/article/details/136721869

版权

Vivado MIG ip核使用教程（一）

Vivado中MIG ip核的生成流程

Vivado MIG ip核使用教程（二）

Vivado中MIG ip核的各个接口介绍

Vivado MIG ip核使用教程（三）

DDR3读写控制器

在本章中，我们对DDR3进行先写入再读出的操作，使用状态机来控制对DDR3的访问，并介绍DDR3读写控制器的编写思路。
状态机状态：IDLE、WR、WAIT、RD。

1 DDR3使能信号

app_en信号是DDR3的使能信号，我们要使用DDR3，首先要对DDR3进行使能，也就是拉高app_en信号
app_en信号不需要一直拉高，只有我们需要对存储器进行访问的时候才拉高即可。那什么时候是我们对存储器进行访问的时候？那就是我们对DDR3进行读写操作的时候。
在写状态下，当DDR3准备好被写入时拉高app_en信号。在读状态下，当DDR3准备好被读出数据时拉高app_en信号。

assign app_en = (state == WR && app_rdy && app_wdf_rdy)||(state == RD && app_rdy))?1'b1:1'b0;

2 如何访问DDR3

访问DDR3也就是对DDR3进行读写操作，当我们需要向DDR3中写入/读出数据时，我们需要考虑以下问题：

读还是写？
现在可以读写DDR3吗？
访问DDR3的哪个地址？
如何告诉DDR3我现在正在写入数据？或什么时候读出的数据才是有效的？

2.1 读写控制端口

我们怎么告诉DDR3现在进行的是读操作还是写操作呢，答案就是app_cmd端口，我们通过app_cmd来控制对DDR3进行写操作还是读操作。

assign app_cmd = (state == WR)?1'b0:1'b1;

2.2 什么时候可以对DDR3进行读写操作？

当我们想要对DDR3进行读写操作时，我们不一定可以立即进行读写操作，我们需要先知道DDR3现在是否准备好被写入或者被读出。
那么如何知道当下是否可以对DDR3进行读写访问呢？MIG ip核输出了相关的rdy信号，也就是准备好信号，我们根据这些rdy信号来判断当下是否可以对DDR3进行访问。
这些rdy信号共有2个，它们是app_rdy、app_wdf_rdy。

问题	信号
DDR3现在是否准备好被写入数据？	app_rdy && app_wdf_rdy
DDR3现在是否准备好读出数据？	app_rdy

2.3 访问DDR3的哪个地址？

当我们要向DDR3中写入数据或者从DDR3中读出数据时，我们需要知道，向哪个地址写入数据？从哪个地址读出数据？
通过app_addr端口，我们可以控制读写的地址。

always@(posedge clk)
	case(state)
		IDLE:
			app_addr <= 0;
		WR:
			if(app_rdy && app_wdf_rdy && wr_addr_cnt == TEST_LENGTH - 1)
				app_addr <= 0;
			else if(app_rdy && app_wdf_rdy)
				app_addr <= app_addr + 8;
			else 
				app_addr <= app_addr;	
		WAIT:
			app_addr <= 0;	
		RD:
			if(app_rdy && rd_addr_cnt == TEST_LENGTH - 1)
				app_addr <= 0;
			else if(app_rdy)
				app_addr <= app_addr + 8;
			else 
				app_addr <= app_addr;		
		default:
			app_addr <= 0;
	endcase

2.4 读写数据有效？

如何告诉DDR3我现在正在写入数据？

app_wdf_wren = (state == WRITE && app_rdy && app_wdf_rdy)?1'b1:1'b0;

app_wdf_wren指示输入数据有效，我们在DDR3可写的时候拉高app_wdf_wren，并更新app_wdf_data端口的数据即可

如何知道此时读出的数据是有效的？
app_rd_data_valid信号指示读数据有效

3 用户逻辑复位

ui_clk_sync_rst可以对用户逻辑进行复位，我们可以对它取反作为一个低电平有效的复位信号

assign rst_n = ~ui_clk_sync_rst;

always @(posedge ui_clk or negedge rst_n)
	if(~rst_n)begin
		...
	end
	else begin
		...
	end

4 部分代码

以下为本节对应的DDR3读写控制器代码

`timescale 1ns / 1ps



module ddr3_rw(
    input          	   init_calib_complete,
    input              ui_clk             ,
    input          	   ui_clk_sync_rst    ,
    output reg [ 27:0] app_addr           ,
    output     [  2:0] app_cmd            ,
    output             app_en             ,
    output reg [127:0] app_wdf_data       ,
    output             app_wdf_end        ,
    output             app_wdf_wren       ,
    input      [127:0] app_rd_data        ,
    input              app_rd_data_valid  ,
    input              app_rdy            ,
    input              app_wdf_rdy        ,
    output             error              
);


localparam IDLE = 4'b0001;
localparam WR   = 4'b0010;
localparam WAIT = 4'b0100;
localparam RD   = 4'b1000;
localparam TEST_LENGTH = 1000;

reg  [					    3:0] state 		;
reg  [					    3:0] next_state	;
wire       						 rst_n		;
reg  [clogb2(TEST_LENGTH - 1):0] wr_addr_cnt;
reg  [clogb2(TEST_LENGTH - 1):0] rd_addr_cnt;
reg  [clogb2(TEST_LENGTH - 1):0] rd_cnt     ;

assign clk          = ui_clk;
assign rst_n 		= ~ui_clk_sync_rst;
assign app_cmd 		= (state == WR)?1'b0:1'b1;
assign app_en 		= ((state == WR && app_rdy && app_wdf_rdy)||(state == RD && app_rdy))?1'b1:1'b0;
assign app_wdf_wren = (state == WR && app_rdy && app_wdf_rdy)?1'b1:1'b0;
assign app_wdf_end  = app_wdf_wren;
assign error        = (app_rd_data_valid && rd_cnt != app_rd_data)?1'b1:1'b0;



always@(posedge clk)
	if(~rst_n)	state <= IDLE;
	else  	    state <= next_state;


always@(*)
	case(state)
		IDLE:
			if(init_calib_complete)											next_state = WR;
			else 															next_state = IDLE;
		WR:
			if(wr_addr_cnt == TEST_LENGTH - 1 && app_wdf_rdy && app_rdy)	next_state = WAIT;
			else 															next_state = WR;
		WAIT:																
																			next_state = RD;
		RD:
			if(rd_addr_cnt == TEST_LENGTH - 1 && app_rdy)					next_state = IDLE;
			else 															next_state = RD;
		default:
																			next_state = IDLE;
	endcase


// wr_addr_cnt
always@(posedge clk)
	case(state)
		IDLE:
			wr_addr_cnt <= 0;
		WR:
			if(app_rdy && app_wdf_rdy && wr_addr_cnt == TEST_LENGTH - 1)
				wr_addr_cnt <= 0;	
			else if(app_rdy && app_wdf_rdy)
				wr_addr_cnt <= wr_addr_cnt + 1'b1;
			else 
				wr_addr_cnt <= wr_addr_cnt;
		WAIT:
			wr_addr_cnt <= 0;
		RD:
			wr_addr_cnt <= 0;
		default:
			wr_addr_cnt <= 0;
	endcase

// rd_addr_cnt
always@(posedge clk)
	case(state)
		IDLE:
			rd_addr_cnt <= 0;
		WR:
			rd_addr_cnt <= 0;	
		WAIT:
			rd_addr_cnt <= 0;	
		RD:
			if(app_rdy && rd_addr_cnt == TEST_LENGTH - 1)
				rd_addr_cnt <= 0;	
			else if(app_rdy)
				rd_addr_cnt <= rd_addr_cnt + 1'b1;
			else 
				rd_addr_cnt <= rd_addr_cnt;		
		default:
			rd_addr_cnt <= 0;
	endcase

// app_addr
always@(posedge clk)
	case(state)
		IDLE:
			app_addr <= 0;
		WR:
			if(app_rdy && app_wdf_rdy && wr_addr_cnt == TEST_LENGTH - 1)
				app_addr <= 0;
			else if(app_rdy && app_wdf_rdy)
				app_addr <= app_addr + 8;
			else 
				app_addr <= app_addr;	
		WAIT:
			app_addr <= 0;	
		RD:
			if(app_rdy && rd_addr_cnt == TEST_LENGTH - 1)
				app_addr <= 0;
			else if(app_rdy)
				app_addr <= app_addr + 8;
			else 
				app_addr <= app_addr;		
		default:
			app_addr <= 0;
	endcase

// app_wdf_data
always@(posedge clk)
	case(state)
		IDLE:
			app_wdf_data <= 0;
		WR:
			if(app_rdy && app_wdf_rdy && wr_addr_cnt == TEST_LENGTH - 1)
				app_wdf_data <= 0;	
			else if(app_rdy && app_wdf_rdy)
				app_wdf_data <= app_wdf_data + 1'b1;
			else 
				app_wdf_data <= app_wdf_data;
		WAIT:
			app_wdf_data <= 0;
		RD:
			app_wdf_data <= 0;
		default:
			app_wdf_data <= 0;
	endcase

// rd_cnt
always @(posedge clk)begin
     if(~rst_n) 
         rd_cnt <= 0;                                                 
     else if(app_rd_data_valid && rd_cnt == TEST_LENGTH - 1)
         rd_cnt <= 0;              
     else if(app_rd_data_valid)
         rd_cnt <= rd_cnt + 1;
 end


function integer clogb2(input integer bit_depth);
    for(clogb2 = 0;bit_depth > 0;clogb2 = clogb2 + 1)
        bit_depth = bit_depth >> 1;
endfunction



endmodule