Altera DDR2 IP核学习总结3-----------DDR2 IP核的使用

根据上一篇生成的IP核，例化之后如上图，Local开头的数据是用户侧数据，其他数据暂时不用纠结，不用管。

这些是需要关注的信号，但是初学阶段很难对这些信号形成具体的概念，这里参考明德扬的代码进行二次封装。

module ddr2_intf(
clk_in ,
clk_out ,
rst_n ,
local_address ,
local_write_req ,
local_read_req ,
local_wdata ,
local_ready ,
local_rdata ,
local_rdata_valid,
local_init_done ,
local_burstbegin ,
user_wdata ,
user_wdata_en ,
user_waddr ,
user_raddr ,
user_rdata_en ,
user_rdata ,
user_rdata_vld ,
user_wdata_rdy ,
user_rdata_rdy
);
parameter ADDR_W = 23 ;
parameter DDR_DATA_W = 32 ;
parameter BURST = 2 ;
parameter USE_DATA_W = DDR_DATA_W * BURST;
parameter FIFO_W = USE_DATA_W + ADDR_W;
input clk_in ;
input rst_n ;
input clk_out ;
input local_ready ;
input [DDR_DATA_W-1:0] local_rdata ;
input local_rdata_valid;
input local_init_done ;
input [USE_DATA_W-1:0] user_wdata ;
input user_wdata_en ;
input [ADDR_W-1:0] user_waddr ;
input [ADDR_W-1:0] user_raddr ;
input user_rdata_en ;
output [ADDR_W-1:0] local_address ;
output local_write_req ;
output local_read_req ;
output [DDR_DATA_W-1:0] local_wdata ;
output local_burstbegin ;
output [USE_DATA_W-1:0] user_rdata ;
output user_rdata_vld ;
output user_wdata_rdy ;
output user_rdata_rdy ;
reg [USE_DATA_W-1:0] user_rdata ;
reg user_rdata_vld ;
reg user_wdata_rdy ;
reg user_rdata_rdy ;
wire [ADDR_W-1:0] local_address ;
wire local_write_req ;
wire local_read_req ;
wire [DDR_DATA_W-1:0] local_wdata ;
wire local_burstbegin ;
wire [FIFO_W-1:0] wfifo_wdata ;
wire wfifo_wrreq ;
wire wfifo_empty ;
wire wfifo_rdreq ;
wire [FIFO_W-1:0] wfifo_q ;
wire [ 5:0] wfifo_usedw ;
wire [ADDR_W-1:0] rfifo_wdata ;
wire rfifo_wrreq ;
wire rfifo_empty ;
wire rfifo_rdreq ;
wire [ADDR_W-1:0] rfifo_q ;
wire [ 5:0] rfifo_usedw ;
reg [FIFO_W :0] ififo_wdata ;
reg ififo_wrreq ;
wire ififo_empty ;
wire ififo_rdreq ;
wire [FIFO_W :0] ififo_q ;
wire [ 5:0] ififo_usedw ;
wire ififo_rdy ;
reg [USE_DATA_W-1:0] gfifo_wdata ;
reg gfifo_wrreq ;
wire gfifo_empty ;
wire gfifo_rdreq ;
wire [USE_DATA_W-1:0] gfifo_q ;
wire [ 5:0] gfifo_usedw ;
reg [ 1:0] cnt0 ;
wire add_cnt0 ;
wire end_cnt0 ;
reg [ 2:0] x ;
reg [ 3:0] cnt1 ;
wire add_cnt1 ;
wire end_cnt1 ;
fifo_ahead_sys #(.DATA_W(FIFO_W),.DEPT_W(64)) u_wfifo(
.aclr (~rst_n ),
.clock (clk_in ),
.data (wfifo_wdata ),
.rdreq (wfifo_rdreq ),
.wrreq (wfifo_wrreq ),
.empty (wfifo_empty ),
.q (wfifo_q ),
.usedw (wfifo_usedw )
);
fifo_ahead_sys #(.DATA_W(ADDR_W),.DEPT_W(64)) u_rfifo(
.aclr (~rst_n ),
.clock (clk_in ),
.data (rfifo_wdata ),
.rdreq (rfifo_rdreq ),
.wrreq (rfifo_wrreq ),
.empty (rfifo_empty ),
.q (rfifo_q ),
.usedw (rfifo_usedw )
);
fifo_ahead_asy #(.DATA_W(FIFO_W+1),.DEPT_W(64)) u_ififo(
.aclr (~rst_n ),
.data (ififo_wdata ),
.rdclk (clk_out ),
.rdreq (ififo_rdreq ),
.wrclk (clk_in ),
.wrreq (ififo_wrreq ),
.q (ififo_q ),
.rdempty (ififo_empty ),
.wrusedw (ififo_usedw )
);
assign wfifo_wdata = {user_waddr,user_wdata};
assign wfifo_wrreq = user_wdata_en ;
assign wfifo_rdreq = ififo_rdy && wfifo_empty==0 && rfifo_empty==1;
assign rfifo_wdata = user_raddr ;
assign rfifo_wrreq = user_rdata_en ;
assign rfifo_rdreq = ififo_rdy && rfifo_empty==0;
always @(posedge clk_in or negedge rst_n)begin
if(rst_n==1‘b0)begin
ififo_wdata <= 0;
end
else if(wfifo_rdreq) begin
ififo_wdata <= {1‘b1,wfifo_q};
end
else if(rfifo_rdreq)begin
ififo_wdata <= {1‘b0,rfifo_q,{USE_DATA_W{1‘b0}}};
end
end
always @(posedge clk_in or negedge rst_n)begin
if(rst_n==1‘b0)begin
ififo_wrreq <= 0;
end
else begin
ififo_wrreq <= wfifo_rdreq || rfifo_rdreq;
end
end
assign ififo_rdy = ififo_usedw<40;
always @(posedge clk_in or negedge rst_n)begin
if(rst_n==1‘b0)begin
user_wdata_rdy <= 0;
end
else begin
user_wdata_rdy <= wfifo_usedw<40;
end
end
always @(posedge clk_in or negedge rst_n)begin
if(rst_n==1‘b0)begin
user_rdata_rdy <= 0;
end
else begin
user_rdata_rdy <= rfifo_usedw<40;
end
end
wire local_read_req_tmp;
assign local_wdata = ififo_q[USE_DATA_W-DDR_DATA_W*cnt0-1 -:DDR_DATA_W];
assign local_address = ififo_q[FIFO_W-1 -:ADDR_W];
assign local_write_req = ififo_q[FIFO_W] && ififo_empty==0 && local_init_done;
assign local_read_req_tmp = ififo_q[FIFO_W]==0 && ififo_empty==0 && local_init_done;
assign local_read_req = local_read_req_tmp && cnt0==1-1;
assign local_burstbegin= add_cnt0 && cnt0==1-1;
assign ififo_rdreq = end_cnt0;
reg ififo_q_ff0;
always @(posedge clk_out or negedge rst_n)begin
if(rst_n==1‘b0)begin
ififo_q_ff0<=0;
end
else begin
ififo_q_ff0<=ififo_q[FIFO_W];
end
end
always @(posedge clk_out or negedge rst_n)begin
if(!rst_n)begin
cnt0 <= 0;
end
else if(add_cnt0)begin
if(end_cnt0)
cnt0 <= 0;
else
cnt0 <= cnt0 + 1;
end
end
assign add_cnt0 = (local_write_req||local_read_req_tmp)&&local_ready;
assign end_cnt0 = add_cnt0 && cnt0==2-1;
always @(posedge clk_out or negedge rst_n)begin
if(!rst_n)begin
cnt1 <= 0;
end
else if(add_cnt1)begin
if(end_cnt1)
cnt1 <= 0;
else
cnt1 <= cnt1 + 1;
end
end
assign add_cnt1 = local_rdata_valid;
assign end_cnt1 = add_cnt1 && cnt1==BURST-1 ;
always @(posedge clk_out or negedge rst_n)begin
if(rst_n==1‘b0)begin
gfifo_wrreq <= 0;
end
else begin
gfifo_wrreq <= end_cnt1;
end
end
always @(posedge clk_out or negedge rst_n)begin
if(rst_n==1‘b0)begin
gfifo_wdata <= 0;
end
else if(add_cnt1)begin
gfifo_wdata[USE_DATA_W - DDR_DATA_W*cnt1 -1 -:DDR_DATA_W] <= local_rdata;
end
end
fifo_ahead_asy #(.DATA_W(USE_DATA_W),.DEPT_W(64)) u_gfifo(
.aclr (~rst_n ),
.data (gfifo_wdata ),
.rdclk (clk_in ),
.rdreq (gfifo_rdreq ),
.wrclk (clk_out ),
.wrreq (gfifo_wrreq ),
.q (gfifo_q ),
.rdempty (gfifo_empty ),
.wrusedw (gfifo_usedw )
);
assign gfifo_rdreq = gfifo_empty==0;
always @(posedge clk_in or negedge rst_n)begin
if(rst_n==1‘b0)begin
user_rdata <= 0;
end
else begin
user_rdata <= gfifo_q;
end
end
always @(posedge clk_in or negedge rst_n)begin
if(rst_n==1‘b0)begin
user_rdata_vld <= 0;
end
else begin
user_rdata_vld <= gfifo_rdreq;
end
end
endmodule

ddr2_intf u8(
.clk_in ( clk ),
.clk_out ( phy_clk ),
.rst_n ( rst_n_ff1 ),
.local_address ( local_address ),
.local_write_req ( local_write_req ),
.local_read_req ( local_read_req ),
.local_wdata ( local_wdata ),
.local_ready ( local_ready ),
.local_rdata ( local_rdata ),
.local_rdata_valid( local_rdata_valid ),
.local_init_done ( local_init_done ),
.local_burstbegin ( local_burstbegin ),
.user_wdata ( user_wdata ),
.user_wdata_en ( user_wdata_en ),
.user_waddr ( user_waddr ),
.user_raddr ( user_raddr ),
.user_rdata_en ( user_rdata_en ),
.user_rdata ( user_rdata ),
.user_rdata_vld ( user_rdata_vld ),
.user_wdata_rdy ( user_wdata_rdy ),
.user_rdata_rdy ( user_rdata_rdy )
);

封装之后只需要关注

.user_wdata ( user_wdata ),
.user_wdata_en ( user_wdata_en ),
.user_waddr ( user_waddr ),
.user_raddr ( user_raddr ),
.user_rdata_en ( user_rdata_en ),
.user_rdata ( user_rdata ),
.user_rdata_vld ( user_rdata_vld ),
.user_wdata_rdy ( user_wdata_rdy ),
.user_rdata_rdy ( user_rdata_rdy )

上面这9个信号，当user_wdata_rdy为高电平的时候可以写入数据，user_rdata_rdy ( user_rdata_rdy ) 可以读出数据，

写了一个简单的测试程序

always @(posedge clk or negedge rst_n)begin
if(!rst_n)begin
cnt0 <= 0;
end
else if(add_cnt0)begin
if(end_cnt0)
cnt0 <= 0;
else
cnt0 <= cnt0 + 1;
end
end
assign add_cnt0 = user_wdata_en ;
assign end_cnt0 = add_cnt0 && cnt0==100 ;
assign user_wdata_en = user_wdata_rdy && flag_add==0;
always @(posedge clk or negedge rst_n)begin
if(!rst_n)begin
cnt1 <= 0;
end
else if(add_cnt1)begin
if(end_cnt1)
cnt1 <= 0;
else
cnt1 <= cnt1 + 1;
end
end
assign add_cnt1 = user_rdata_en ;
assign end_cnt1 = add_cnt1 && cnt1==100 ;
assign user_rdata_en = user_rdata_rdy && flag_add==1;
always @(posedge clk)begin
if(!rst_n)
flag_add <= 0;
else if(end_cnt0)
flag_add <= 1;
else if(end_cnt1)
flag_add <= 0;
end
always @(posedge clk or negedge rst_n)begin
if(rst_n==1‘b0)begin
user_wdata <= 0;
user_waddr <= 0;
user_raddr <= 0;
end
else begin
user_wdata <= cnt0 ;
user_waddr <= cnt0*2 ;
user_raddr <= cnt1*2 ;
end
end

当flag_add为低电平的时候往DDR2中写入数据，flag_add为高电平的时候读出数据。一共写入一百个数据。

使用signaltapII抓到的波形为

local_init_done为高电平说明DDR2芯片初始化完成，user_wdata_en为高电平时写入数据，放大了看则是

写入的数据为地址的二分之一

然后看一下读出来的数据

这里很清楚的可以看出来user_rdata_en跟user_rdata_vld并不能对齐

放大了看

当user_rdata_vld为高电平的时候输出的数据有效，

测量一下得知user_rdata_en跟user_rdata_vld的偏差是21个数据，从Altera DDR2 IP核学习总结1中得知DRAM数据输出有延迟，结构相同的DDR2自然有相同的特性，大神称为首字惩罚特性（当时纠结这个问题半天，怎么也解决不了，多谢群里的大神）。

观察写入数据和读取数据一致，DDR2驱动成功。

原文地址：https://www.cnblogs.com/Librarian/p/11001270.html

时间： 2024-07-29 22:17:30

Altera DDR2 IP核学习总结3-----------DDR2 IP核的使用的相关文章

tcp/ip协议学习第三章 IP协议

学习笔记之TCP/IP协议的传输方式

一.通过网络发送数据,大致可以分为面向有连接与面向无连接两种类型: 1.面向无连接型包括以太网. IP.UDP等协议. 2. 面向有连接型包括ATM.帧中继.TCP等协议. 通过一张图了解一下: 面向有连接型面向有连接型中,在发送数据之前,需要在收发主机之间连接一条通信线路面向有连接型就好比人们平常打电话,输入完对方电话号码拨出之后,只有对端拿起电话才能真正通话,通话结束后将电话机扣上就如同切断电源.因此在面向有连接的方式下,必须在通信传输前后,专门进行建立和断开连接的处理.如果与对

Lattice 的 Framebuffer IP核使用调试笔记之IP核生成与参数设置

本文由远航路上ing 原创,转载请标明出处. 这节笔记记录IP核的生成以及参数设置. 先再IP库里下载安装Framebuffer 的ipcore 并安装完毕. 一.IP核的生成: 1.先点击IP核则右边会出现生成对话框: 按箭头指示顺序进行设置:要设置生成ip核的路径(可以新建一个文件夹ipcore来放置IP核,若有多个IP核则在ipcore下分别建立文件夹),IP核的名字,以及语言的类型:verilog或VHDL.最后点击Customize. 2. 在上一步设置之后会出现下面的设置界面,先设置

TCP/IP/ICMP 学习实践

前言在学习TCP分段与IP分片时.心有所感想把之前学习过的知识串联起来. 数据分段发生在传输层.分片发生在网络层. 相关术语: MTU(Maximum Transmission Unit,MTU),最大传输单元以太网和802.3对数据帧的长度都有一个限制,其最大值分别是1500和1492个字节.链路层的这个特性称作MTU. MSS(Maxitum Segment Size)最大分段大小的缩写,是TCP协议里面的一个概念 MSS就是TCP数据包每次能够传输的最大数据分段.为了达到最佳的传输效

linux 学习设置固定网Ip

本人使用CentOs6.5 最近在学习linux操作系统,单在使用shell连接前都要使用ifconfig eth0 设置一个临时IP让我不胜其烦.决定学习设置一个固定IP 步骤: 1.登录计算机后使用 setup 命令进入下图界面 2.选择网络配置 3.选择设备配置 4.进入 eth0 5.陪配置自己的相关信息 DHCP [*]表示自动获取ip 注意: 必须有DHCPserver 提供自动分配的服务否则没有作用 6.[[email protected] ~]# service n

学习笔记之TCP/IP协议分层与OSI参考模型

1.协议的分层 ISO在制定标准化OSI之前,对网络体系结构相关的问题进行了充分的讨论, 最终提出了作为通信协议设计指标的OSI参考模型.这一模型将通信协议中必要的功能分成了7层.通过这些分层,使得那些比较复杂的网络协议更加简单化. 在这一模型中,每个分层都接收由它下一层所提供的特定服务,并且负责为自己的上一层提供特定的服务.上下层之间进行交互时所遵循的约定叫做"接口".同一层之间的交互所遵循的约定叫做"协议". 协议分层就如同计算机软件中的模块化开发.

Altera FPGA 远程升级有关的几个IP的使用

在做在线远程升级的时候,一般需要两步:1.将数据写到外挂的flash中.2重新启动FPGA配置. 不过要做到远程升级,一般需要在原始程序中就考虑到加入远程升级模块,remote updata IP, 在升级的时候才可以启动远程升级功能. 远程升级之后程序加载的过程: 在进行远程升级成功以后,flash中应该会至少存储两个程序,出厂程序和升级程序. 两个程序在不同的地址空间中(出厂程序从0X0000开始存储).在FPGA上电之后,FPGA会加载出厂程序,出厂程序在运行之后,检测到remote up

计算机网络学习笔记--网络层之IP地址与子网

IPv4地址: 我们知道在网络层(TCP/IP体系结构的网际互联层),最重要的一个协议就是IP协议,现在正处于IPv4和IPv6的过渡时期,但目前来说,IPv4仍为主流,所以主要讲Ipv4. IP地址基本格式: 计算机内部IP地址的格式是32位的二进制数表示的,为了让人们看起来方便,通常采用点分十进制来表示IP地址,如192.168.1.25,其中用来分隔各段的那个点,也是为了方便人们阅读加上的,计算机内部并没有这个点. 公网IP地址和私网IP地址: 公网Ip地址是指可以在广域网上直接使用,直接

【DAY18】Socket编程，ROSE建模与TCP/IP的学习笔记

IDE eclipse调试 ------------------ 1.Debug 2.Step into : F5 ,单步进入. 3.Step return : F7,单步返回. 4.Stop over : F6,单步跳过. 安装Rose建模软件 ----------------- 1.安装虚拟光驱软件:DTLite.exe 2.加载Rose镜像文件. 3.一路安装,next... 4.安装完成注册License. a.在license管理器界面开始 --> IBM Rose -> Lic