【正点原子FPGA连载】第三十三章DDR3读写测试--摘自【正点原子】超越者之FPGA开发指南

正点原子运营 · 发表于 2021-1-21 12:26:46

本帖最后由正点原子运营于 2021-1-21 12:28 编辑

1）实验平台：正点原子超越者FPGA开发板
2）平台购买地址：https://item.taobao.com/item.htm?&id=631660290421
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/fpga/zdyz-chaoyuezhe.html
4）本章实例源码下载：

26_top_ddr3_rw.rar (5.21 MB, 下载次数: 39)

2021-1-21 12:26 上传

点击文件名下载附件
5）正点原子FPGA交流群：905624739点击加入：

6）关注正点原子公众号，获取最新资料更新

第三十三章DDR3读写测试

DDR3 SDRAM常简称DDR3，是当今较为常见的一种RAM储存器，在计算机及嵌入式产品中得到广泛应用，特别是应用在涉及到大量数据交互的场合，比如电脑的内存条。对DDR3的读写操作大都借助IP核来完成，本次实验将采用Xilinx公司的MIG IP核来实现DDR3读写测试。
本章包括以下几个部分：
3333.1  简介
33.2  实验任务
33.3  硬件设计
33.4  程序设计
33.5  下载验证

33.1简介
DDR3 SDRAM（Double-Data-Rate Three Synchronous Dynamic Random Access Memory）是DDR SDRAM的第三代产品，相较于DDR和DDR2，DDR3有更高的运行性能与更低的电压。DDR SDRAM是在SDRAM技术的基础上发展改进而来的，同SDRAM相比，DDR SDRAM的最大特点是双沿触发，即在时钟的上升沿和下降沿都能进行数据采集和发送。同样的工作时钟，DDR SDRAM的读写速度可以比传统的SDRAM快一倍。本次实验使用的DDR3芯片是南亚的NT5CB128M16CP-DI。
NT5CB128M16CP-DI的bank位宽为3，行位宽为14，列位宽为10，所以它的地址大小等于2^3*2^14*2^10（即2^27=128M），数据位宽为16bit，所以容量大小为128M*16bit，也就是256MByte。
由于DDR3的时序非常复杂，如果直接编写DDR3的控制器代码，那么工作量是非常大的，且性能难以得到保证。值得一提的是，Spartan6系列FPGA自带了DDR3控制器的硬核，用户可以直接借助IP核来实现对DDR3的读写操作，从而大大降低了DDR3的开发难度。本次实验将使用Xilinx公司的MIG(Memory Interface Generators) IP核来实现DDR3读写测试。
MIG IP核是Xilinx公司针对DDR存储器开发的IP，里面集成了存储器控制模块，实现DDR读写操作的控制流程，下图是Spartan6系列的MIG IP核结构框图。MIG IP核对外分出了两组接口。左侧是用户接口，就是用户（FPGA）同MIG交互的接口，用户只有充分掌握了这些接口才能操作MIG。右侧为DDR物理芯片接口，负责产生具体的操作时序，并直接操作芯片管脚，这一侧用户只负责分配正确的管脚，其他无需关心。

图 33.1.1 MIG IP 核结构框图

FPGA内的MCB的用户接口可以配置为一到六个端口，每个端口由一个命令接口和一个读和/或写数据接口组成。MCB内的两个32位双向和四个32位单向硬件端口可以分组，以创建五种不同的端口配置，其配置如下图所示：

图 33.1.2 MIG IP 核配置图

上图中的Bidirectional代表这个端口可以作为双向端口使用，Unidirectional代表这个端口只能作为单向端口使用。R/W表示的意思是这个端口即可读又可写，R or W表示这个端口只能写或者读。

图 33.1.3 MIG IP 核端口图

上图展示了FPGA内部用户界面相关联的主要信号以及与外部存储设备相关联的I/O信号。为了简单起见，用户界面可以配置为最多支持六个端口，上图只显示了单个双向端口的信号。上图中的用户端口可以分成单向写端口、单向读端口、双向读写端口。每个端口包含一个命令路径和一个数据路径。对于单向端口，命令路径与单个只读或单个只写数据路径配对。但是对于双向端口，与该端口关联的读和写数据通路共享单个命令路径。在命令路径和数据路径的用户界面上使用FIFO来对内存请求进行缓存，并管理从用户时钟域到内存控制器时钟域的传输。
端口的命令路径用于向命令FIFO发出请求。命令FIFO有一个深度高达4的缓冲区，该缓冲区存储与内存相关的指令类型(读、写、刷新等)、地址和突发长度。命令路径还输出来自命令FIFO的full和empty等状态标志信号，以此来指示缓冲区是否可以接受新请求。
在数据路径中，底层硬件包含6个32位端口，其中两个天生是双向的，其他四个端口本质上是单向的，但是也可以组合起来创建双向端口。以五种端口配置组合成六个硬件端口来实现所需的用户界面，用户界面的读写数据字字段的宽度自然是由所选择的配置来决定的。
数据FIFO的深度为64，其允许从一个给定的起始地址产生长达64个数据字的突发长度。除了数据字字段之外，写路径FIFO还包含掩码位字段，允许按字节对写数据进行可选掩码。Full、empty、underrun、count和error等状态输出信号表示写数据FIFO的当前状态。读取数据FIFO也有一组类似的状态输出。
下图给出了MIG IP核用户接口的信号及其说明：

图 33.1.4 用户接口信号定义

MIG IP核用户侧一个端口共25个信号，当然用户并不用去关心所有的信号，只需要了解本实验要用到几组重要信号。下面将对这些信号逐一讲解并以表格的形式呈现给大家。为了与官方的文档保持一致，表中标明的信号的方向是以MIG IP核作为参照的，例如表格中的信号方向定义为输出，那么相对于用户端（FPGA）来说实际上是输入。

表 33.1.1 MIG IP 核用户接口部分信号定义

以上是本次实验需要用到的信号，其他信号请大家自行了解。

图 33.1.5 写命令时序

上图是写命令的操作时序，当p0_cmd_full为低并且p0_cmd_en为高时，命令、地址和突发长度才能写入4深度的命令fifo。

图 33.1.6 读命令时序

上图是读命令时序，其命令时序与写类似，都是在p0_cmd_full为低并且p0_cmd_en为高时，命令、地址和突发长度才能写入4深度的命令fifo。

图 33.1.7 写数据时序

上图为MIG的写数据时序。当pX_wr_full为低并且pX_wr_en为高时，数据信号pX_wr_data将写入到64深度的写数据fifo当中，否则数据将不能写入到写数据fifo中。

图 33.1.8 读数据时序

用户界面的读路径使用一个64深度的FIFO结构来保存从ddr返回的数据。其中空标志信号(pX_rd_empty)可以作为一个有效的数据指标。当pX_rd_empty为低时，表示读数据缓冲区已经有了数据，此时就可以拉高信号pX_rd_en，将数据从读数据缓冲区中读出。这里有个地方需要大家注意下，当pX_rd_empty拉高时，信号pX_rd_en需要立马拉低，不能等到下一个时钟周期，否则读出的数据会出错。
33.2实验任务
本节的实验任务是先向DDR3的存储器中写入8192个数据，写完之后再从存储器中读取相同地址的数据，若初始化成功，则LED0常亮，否则LED0不亮；读取的值全部正确则LED1灯常亮，否则LED1灯闪烁。
33.3硬件设计
超越者开发板上使用了一片南亚的DDR3颗粒NT5CB128M16CP-DI，硬件原理图如下图所示。在PCB的设计上，完全遵照Xilinx的DDR3硬件设计规范，严格保证等长设计和阻抗控制，从而保证高速信号的数据传输的可靠性。

图 33.3.1 DDR3硬件原理图

如下表所示为本次实验用到的所有管脚。
表 33.3.1 DDR3读写测试实验部分管脚分配

如上表所示，本次实验用到了三种电平，分别是LVCMOS、SSTL和DIFF_SSTL，对于这三种电平，下面分别给出中英文解释。
LVCMOS：全称Low Voltage Complementary Metal Oxide Semiconductor，低压互补金属氧化物半导体；
SSTL：全称Stub Series Terminated Logic，短截线串联端接逻辑；
DIFF_SSTL：全称Difference Stub Series Terminated Logic，差分短截线串联端接逻辑。
LVCMOS的特点是噪声容限大，速度较SSTL慢；SSTL速度快，通常要匹配合适的端接电阻，常用于高速内存接口如DDR3；DIFF_SSTL则是带有差分功能的SSTL。
DDR3的管脚使用的是SSTL或者DIFF_SSTL，这里要注意一下DDR3复位信号mcb3_dram_reset_n，它并没有使用SSTL，原因是SSTL的噪声容限不够大，容易受干扰造成误复位。
本实验对应的UCF约束语句如下所示。注意，在这里仅给出了时钟、复位、初始化完成信号和读写指示信号的管脚约束。DDR3部分的管脚约束在文档中不再给出，大家可以按照以下路径查看DDR3的管脚约束“top_ddr3_rw\prj\top_ddr3_rw\ipcore_dir\ddr3\user_design\par\ddr3.ucf”或者“top_ddr3_rw\prj\top_ddr3_rw.ucf”。
Net sys_clk LOC = N8 | TNM_NET = sys_clk_pin;
TIMESPEC "TS_sys_clk" = PERIOD "sys_clk"  20  ns HIGH 50 %;

NET init_calib_complete       LOC = T5 | IOSTANDARD = "LVCMOS33";
NET led                         LOC = M6 | IOSTANDARD = "LVCMOS33";
NET sys_rst_n                   LOC = G16 | IOSTANDARD = "LVCMOS33";
33.4程序设计
根据实验任务，可以大致规划出系统的控制流程：首先FPGA调用ddr测试数据模块向ddr3控制模块写入数据，写完之后ddr测试数据模块从ddr3控制模块读出所写入的数据，并判断读出的数据与写入的数据是否相同，如果相同则LED灯常亮，否则LED灯闪烁。由此画出系统的功能框图如下图所示：

图 33.4.1 DDR3 读写测试实验系统框图

由系统总体框图可知，FPGA顶层模块例化了以下四个模块，分别是ddr3控制模块（ddr3_control）、ddr测试数据模块（ddr_test）、时钟模块（pll）和led显示模块（led_disp）。
ddr3控制模块产生读写MIG IP核用户接口的时序，实现与MIG IP核的数据及信号交互。时钟模块负责产生ddr3控制模块所需的300M时钟和100M时钟，以及ddr测试数据模块的50M时钟。ddr3控制模块一方面负责与用户（FPGA）进行数据交互，另一方面还产生控制DDR3读写的各种时序，并实现对DDR芯片的读写操作。ddr测试数据模块的作用是写入和读出ddr控制器的数据并且将读写数据进行比较。led显示模块是根据读写错误信号的高低来判断是否翻转LED灯的电平。
首先在ise环境里新建一个工程，本实验取名为top_ddr3_rw，出现如下所示界面：

图 33.4.2 MIG IP核生成步骤1

点击上图中的Project菜单，出现下图所示界面：

图 33.4.3 MIG IP核生成步骤2

点击上图中红色框所圈的选项，出现如下界面：

图 33.4.4 MIG IP核生成步骤3

点击上图中红色框所圈的选项并在蓝色框所圈的地方输入IP的名字。本次实验将MIG的IP命名为ddr3，然后点击下方的Next，出现如下所示的界面：

图 33.4.5 MIG IP核生成步骤4

选中红色框所圈的选项，然后点击Next，出现如下所示界面：

图 33.4.6 MIG IP核生成步骤5

直接点击Finish选项，出现如下所示界面：

图 33.4.7 MIG IP核生成步骤6

这里不用管它，直接点击Next，出现如下所示界面：

图 33.4.8 MIG IP核生成步骤7

上图中的Create Design选项表示重新建立一个MIG IP核；Xilinx Reference Boards选项表示可以获得xilinx样板的设计信息；Updata Design表示对已存在的MIG IP核进行重新编辑。Component Name选项是MIG IP核的模块名，此处可对模块名进行修改。本次实验选择Create Design选项，来新建一个MIG IP核。点击Next，出现如下所示界面：

图 33.4.9 MIG IP核生成步骤8

点击Next按钮，界面如下图所示。

图 33.4.10 MIG IP核生成步骤9

AXI interface：单击该选项，为所有mcb添加一个AXI4用户界面(此选项仅对Verilog设计可用)，否则，MIG设计在默认情况下使用标准的用户界面。
Extended MCB：单击该选项，可启用扩展的 MCB 性能范围，并在生成的 UCF 中设置CONFIG MCB_PERFORMANCE=EXTENDED的约束。
Memory Type：该选项是选择使用的存储器，本次实验用的是ddr3，所以选择DDR3 SDRAM选项。
超越者开发板的硬件设计上将ddr3芯片的管脚连接到了fpga的bank3上，所以这里应该选择左边的Memory Type选项来确定存储器类型。
点击Next，出现如下所示界面：

图 33.4.11 MIG IP核生成步骤10

Frequency：DDR3 芯片运行时钟。这个参数的范围和 FPGA 的芯片类型以及具体类型的速度等级有关。本实验选择3300ps，对应303.03M，这是本次实验所采用芯片可选的频率。注意这个时钟是外部产生，并输出给MIG IP核使用的，它关系到 DDR3 芯片具体的运行带宽。比如本次实验的开发板板载了一颗 DDR3 芯片，数据位宽总共 16 位，因为是双沿触发，这里带宽达到了9.6Gb/s(300M*2*16bit)。
Memory Part：ddr3芯片类型。超越者开发板上采用的是南亚的NT5CB128M16CP-DI，但ise不支持这款芯片，因此我们选择与这款芯片性能相似的芯片型号，即MT41J128M16XX-125型号。
点击Next，出现如下所示界面：

图 33.4.12 MIG IP核生成步骤11

上图界面是内部高性能bank端接匹配阻抗的设置，这里不去改它，选择默认即可。Auto Self Rrfresh选项是使能自动刷新操作，选择Enabled选项表示在代码中不需要MIG输出相应的刷新命令，这里我们选择Enabled选项。接下来点击“Next”按钮，界面如下图所示。

图 33.4.13 MIG IP核生成步骤12

上图中的Configuration Selection选项是选择端口配置模式的，本次实验选择一组双向128bit通道的模式，有兴趣的朋友也可以选择其他的端口配置。图中蓝色框所圈的选项是MIG地址对应到DDR硬件地址中的顺序，这里选择第一种模式。
继续点击“Next”按钮，界面如下图所示。

图 33.4.14 MIG IP核生成步骤13

上图中是对仲裁方式做选择，Round Robin选项是选择对所有端口进行轮询处理；Custom选项是对仲裁方式进行自定义，这里选择Round Robin选项。
继续点击“Next”按钮，界面如下图所示。

图 33.4.15 MIG IP核生成步骤14

上图中Memory Interface Pin Termination选项是对终端校准模式进行选择，该模式的选择与硬件电路的设计相关联，根据超越者开发板的硬件设计，我们只能选择第一个选项。
Select RZQ pin location选项和Select ZIO pin location选项也是根据硬件电路的设计来确定管脚的，超越者开发板连接这2个管脚的分别是M5和B3。
Debug Signals for Memory Controller选项是表示在MIG IP核中是否添加一些测试文件以供我们调试，这里选择不使能，大家可以在工程中自己添加ila来调试。
System Clock选项是表示输入到MIG IP核时钟的模式，这里选择单端时钟。
继续点击“Next”按钮，界面如下图所示。

图 33.4.16 MIG IP核生成步骤15

上图中是之前所有配置的总结，大家可以看下是否与大家想要的配置一样，如果一样直接点击“Next”按钮，然后出现如下界面：

图 33.4.17 MIG IP核生成步骤16

这里选择接受该协议，然后点击Next，出现如下界面：

图 33.4.18 MIG IP核生成步骤17

这里直接点击Next，出现如下界面：

图 33.4.19 MIG IP核生成步骤18

在上图中直接点击Generate按钮，出现如下界面：

图 33.4.20 MIG IP核生成步骤19

出现上图中的图标表示MIG的IP核已经生成完毕。虽然ip已经生成完毕了，但是在超越者开发板上不能直接使用。在MIG IP生成的配置中，我们所设定的时钟被IP认定为IO口输入进来的，但在超越者开发板中没有那么高的IO口时钟被MIG IP所采用，因此只能将IO口输入时钟通过锁相环倍频后输出到MIG IP核，所以不能直接使用IP核。下面讲解如何对ip进行修改。
首先将ip核从工程中移除，如下图所示：

图 33.4.21 修改MIG IP核步骤1

将ip移除后，大家把ip生成的文件都加入到工程中来，其文件路径为“top_ddr3_rw\prj\top_ddr3_rw\ipcore_dir\ddr3\user_design\rtl”如下图所示：

图 33.4.22 修改MIG IP核步骤2

图 33.4.23 修改MIG IP核步骤3

将文件全部加入到工程后，出现如下界面：

图 33.4.24 修改MIG IP核步骤4

下面我们将对MIG中的时钟模块（infrastructure.v）进行修改，修改的部分如下所示：
未修改前的代码：

generate
if (C_INPUT_CLK_TYPE == "DIFFERENTIAL") begin: diff_input_clk
//***********************************************************************
// Differential input clock input buffers
//***********************************************************************
IBUFGDS #
(
.DIFF_TERM ("TRUE")
)
u_ibufg_sys_clk
(
.I (sys_clk_p)，
.IB (sys_clk_n)，
.O (sys_clk_ibufg)
);
end else if (C_INPUT_CLK_TYPE == "SINGLE_ENDED") begin: se_input_clk
//***********************************************************************
// SINGLE_ENDED input clock input buffers
//***********************************************************************
IBUFG u_ibufg_sys_clk
(
.I (sys_clk)，
.O (sys_clk_ibufg)
);
end
endgenerate

复制代码

修改后的代码：

generate
if (C_INPUT_CLK_TYPE == "DIFFERENTIAL") begin: diff_input_clk
//***********************************************************************
// Differential input clock input buffers
//***********************************************************************
IBUFGDS #
(
.DIFF_TERM ("TRUE")
)
u_ibufg_sys_clk
(
.I (sys_clk_p)，
.IB (sys_clk_n)，
.O (sys_clk_ibufg)
);
end else if (C_INPUT_CLK_TYPE == "SINGLE_ENDED") begin: se_input_clk
//***********************************************************************
// SINGLE_ENDED input clock input buffers
//***********************************************************************
BUFG u_bufg_sys_clk
(
.I (sys_clk)，
.O (sys_clk_ibufg)
);
end
endgenerate

复制代码

这里只是把单端信号的IBUFG修改为BUFG，因为IBUFG只有io口输入进来的时钟才能使用，而本次实验的时钟是由锁相环出来的，所以要改成BUFG。
至此MIG IP全部建立完成，下面来看具体代码：

1 module top_ddr3_rw(
2 input sys_clk ， //系统时钟
3 input sys_rst_n ， //系统复位，低电平有效
4 //ddr3 port
5 inout [15:0] mcb3_dram_dq，
6 output [13:0] mcb3_dram_a，
7 output [2:0] mcb3_dram_ba，
8 output mcb3_dram_ras_n，
9 output mcb3_dram_cas_n，
10 output mcb3_dram_we_n，
11 output mcb3_dram_reset_n，
12 output mcb3_dram_cke，
13 output mcb3_dram_dm，
14 inout mcb3_dram_udqs，
15 inout mcb3_dram_udqs_n，
16 inout mcb3_rzq，
17 inout mcb3_zio，
18 output mcb3_dram_udm，
19 inout mcb3_dram_dqs，
20 inout mcb3_dram_dqs_n，
21 output mcb3_dram_ck，
22 output mcb3_dram_ck_n，
23
24 output init_calib_complete ， //ddr3初始化成功标志
25 output led //ddr3读写错误标志指示灯
26
27 );
28
29 //wire define
30 wire locked ; //时钟锁定信号
31 wire wr_en ; //DDR3控制器模块写使能
32 wire [15:0] wr_data ; //DDR3控制器模块写数据
33 wire rd_en ; //DDR3控制器模块读使能
34 wire [15:0] rd_data ; //DDR3控制器模块读数据
35 wire clk_50m ; //50m时钟
36 wire clk_100m ; //100m时钟
37 wire clk_ddr ; //ddr3运行时钟
38 wire [24:0] data_max ; //写入ddr的最大数据量
39
40 //*****************************************************
41 //** main code
42 //*****************************************************
43
44 //待时钟锁定后产生复位结束信号
45 assign rst_n = sys_rst_n & locked;
46 assign data_max = 25'd8192;
47
48 //ddr3控制模块
49 ddr3_control
50 #(
51 .C3_NUM_DQ_PINS (16)，
52 .C3_MEM_ADDR_WIDTH (14)，
53 .C3_MEM_BANKADDR_WIDTH (3)
54 )
55 u_ddr3_ctrl(
56 .clk_ddr (clk_ddr)，
57 .clk_100m (clk_100m)，
58 .rst_n (rst_n)，
59 .mcb3_dram_dq (mcb3_dram_dq )，
60 .mcb3_dram_a (mcb3_dram_a )，
61 .mcb3_dram_ba (mcb3_dram_ba )，
62 .mcb3_dram_ras_n (mcb3_dram_ras_n )，
63 .mcb3_dram_cas_n (mcb3_dram_cas_n )，
64 .mcb3_dram_we_n (mcb3_dram_we_n )，
65 .mcb3_dram_reset_n (mcb3_dram_reset_n)，
66 .mcb3_dram_cke (mcb3_dram_cke )，
67 .mcb3_dram_dm (mcb3_dram_dm )，
68 .mcb3_dram_udqs (mcb3_dram_udqs )，
69 .mcb3_dram_udqs_n (mcb3_dram_udqs_n )，
70 .mcb3_rzq (mcb3_rzq )，
71 .mcb3_zio (mcb3_zio )，
72 .mcb3_dram_udm (mcb3_dram_udm )，
73 .mcb3_dram_dqs (mcb3_dram_dqs )，
74 .mcb3_dram_dqs_n (mcb3_dram_dqs_n )，
75 .mcb3_dram_ck (mcb3_dram_ck )，
76 .mcb3_dram_ck_n (mcb3_dram_ck_n )，
77 .c3_calib_done (init_calib_complete)，
78
79 .ddr3_read_valid (1'b1 )， //ddr3读使能
80 .clk_write (clk_50m)， //写时钟
81 .wr_en (wr_en)， //写使能
82 .wr_data (wr_data)， //写数据
83 .wr_max_addr (data_max)， //写最大地址
84 .wr_min_addr (0)， //写最小地址
85 .wr_length (32)， //一次写长度
86
87 .clk_read (clk_50m)， //读时钟
88 .rd_en (rd_en)， //读使能
89 .rd_max_addr (data_max)， //读最大地址
90 .rd_min_addr (0)， //读最小地址
91 .rd_length (32)， //一次读长度
92 .rd_data (rd_data) //读数据
93 );
94
95
96 pll u_pll
97 (// Clock in ports
98 .CLK_IN1 (sys_clk)， // IN
99 // Clock out ports
100 .CLK_OUT1 (clk_ddr)， // OUT
101 .CLK_OUT2 (clk_50m)， // OUT
102 .CLK_OUT3 (clk_100m)， // OUT
103 // Status and control signals
104 .RESET (~sys_rst_n)， // IN
105 .LOCKED (locked)
106 ); // OUT
107
108 //ddr测试数据模块
109 ddr_test u_ddr_test(
110 .clk_50m (clk_50m)， //时钟
111 .rst_n (rst_n)， //复位，低有效
112
113 .wr_en (wr_en)， //写使能
114 .wr_data (wr_data)， //写数据
115 .rd_en (rd_en)， //读使能
116 .rd_data (rd_data)， //读数据
117 .data_max (data_max)， //写入ddr的最大数据量
118 .ddr3_init_done(init_calib_complete)， //ddr3初始化完成信号
119 .error_flag (error_flag) //ddr3读写错误
120
121 );
122
123 //利用LED灯指示SDRAM读写测试的结果
124 led_disp u_led_disp(
125 .clk_50m (clk_50m)，
126 .rst_n (rst_n)，
127
128 .error_flag (error_flag)，
129 .led (led)
130 );
131
132 endmodule

复制代码

顶层模块中主要完成对其余模块的例化，由于ddr3控制器被封装成类似FIFO接口，在使用时只需要像读写FIFO那样给出读/写使能即可，如代码80~82行所示。同时定义了最大和最小读写地址，在调用时数据在该地址空间中连续读写。程序第85行及第91行指定ddr控制器的一次读写长度，这里的长度是可以修改的，但必须能被写入ddr的最大数据量（data_max）整除。在代码的第79行的信号ddr3_read_valid当其为高时，开启ddr控制器的读操作，为低则关闭ddr控制器的读操作。
下面来讲解ddr3控制模块。

1 module ddr3_control
2 #(
3 parameter C3_NUM_DQ_PINS = 16，
4 // External memory data width
5 parameter C3_MEM_ADDR_WIDTH = 13，
6 // External memory address width
7 parameter C3_MEM_BANKADDR_WIDTH = 3
8 // External memory bank address width
9 )
10 (
11 input clk_ddr， //ddr3输入时钟
12 input clk_100m， //输入时钟
13 input rst_n， //系统复位，低电平有效
14 //ddr3 port
15 inout [C3_NUM_DQ_PINS-1:0] mcb3_dram_dq，
16 output [C3_MEM_ADDR_WIDTH-1:0] mcb3_dram_a，
17 output [C3_MEM_BANKADDR_WIDTH-1:0] mcb3_dram_ba，
18 output mcb3_dram_ras_n，
19 output mcb3_dram_cas_n，
20 output mcb3_dram_we_n，
21 output mcb3_dram_reset_n，
22 output mcb3_dram_cke，
23 output mcb3_dram_dm，
24 inout mcb3_dram_udqs，
25 inout mcb3_dram_udqs_n，
26 inout mcb3_rzq，
27 inout mcb3_zio，
28 output mcb3_dram_udm，
29 inout mcb3_dram_dqs，
30 inout mcb3_dram_dqs_n，
31 output mcb3_dram_ck，
32 output mcb3_dram_ck_n，
33
34 output c3_calib_done， //ddr3初始化成功标志
35 input ddr3_read_valid， //ddr3读使能
36
37 //write
38 input clk_write， //写操作时钟
39 input wr_en， //写使能
40 input [15:0] wr_data， //写数据
41 input [29:0] wr_max_addr， //写最大地址
42 input [29:0] wr_min_addr， //写最小地址
43 input [9:0] wr_length， //一次写长度
44 //read
45 input clk_read， //读操作时钟
46 input rd_en， //读使能
47 input [29:0] rd_max_addr， //读最大地址
48 input [29:0] rd_min_addr， //读最小地址
49 input [9:0] rd_length， //一次读长度
50 output [15:0] rd_data //读数据
51 );
52
53 //wire define
54 wire c3_p0_cmd_en; //P0端命令使能
55 wire [2:0] c3_p0_cmd_instr; //P0端命令输入
56 wire [5:0] c3_p0_cmd_bl; //P0端数据突发长度
57 wire [29:0] c3_p0_cmd_byte_addr; //P0端数据地址
58 wire c3_p0_wr_en; //P0端写数据使能
59 wire [7:0] c3_p0_wr_mask; //P0端写数据掩码
60 wire [127:0]c3_p0_wr_data; //P0端写数据
61 wire c3_p0_cmd_full; //p0端命令fifo满标志
62 wire [127:0]c3_p0_rd_data ; //ddr读数据
63 wire c3_p0_rd_empty; //p0端fifo空信号
64 wire [8:0] wfifo_rcount; //rfifo剩余数据计数
65 wire [8:0] rfifo_wcount; //wfifo写进数据计数
66
67 //*****************************************************
68 //** main code
69 //*****************************************************
70
71 ddr_rw u_ddr_rw
72 (
73 .clk_100m (clk_100m)， //ddr3输入时钟
74 .rst_n (rst_n)， //系统复位，低电平有效
75
76 .c3_calib_done (c3_calib_done)， //ddr3初始化成功标志
77 .ddr3_read_valid (ddr3_read_valid)， //ddr3读使能
78 .ddr3_pingpang_en (ddr3_pingpang_en)， //ddr3乒乓操作使能
79 .c3_p0_cmd_full (c3_p0_cmd_full)， //命令fifo满标志
80 .c3_p0_rd_empty (c3_p0_rd_empty)， //fifo空信号
81 .c3_p0_cmd_en (c3_p0_cmd_en)， //命令使能
82 .c3_p0_cmd_instr (c3_p0_cmd_instr)， //命令输入
83 .c3_p0_cmd_bl (c3_p0_cmd_bl)， //数据突发长度
84 .c3_p0_cmd_byte_addr (c3_p0_cmd_byte_addr)，//数据地址
85 .c3_p0_wr_mask (c3_p0_wr_mask)， //写数据掩码
86 .c3_p0_wr_full (c3_p0_wr_full)， //写数据fifo满标志
87 .c3_p0_rd_en (c3_p0_rd_en)， //数据读使能
88 .c3_p0_wr_en (c3_p0_wr_en)， //数据写使能
89
90 .clk_write (clk_write)， //写操作时钟
91 .wr_max_addr (wr_max_addr)， //写最大地址
92 .wr_length (wr_length)， //一次写长度
93 .wr_min_addr (wr_min_addr)， //写最小地址
94
95 .clk_read (clk_read)， //读操作时钟
96 .rd_max_addr (rd_max_addr)， //读最大地址
97 .rd_min_addr (rd_min_addr)， //读最小地址
98 .rd_length (rd_length)， //一次读长度
99 .wfifo_rcount (wfifo_rcount)， //rfifo剩余数据计数
100 .rfifo_wcount (rfifo_wcount) //wfifo写进数据计数
101
102 );
103
104 ddr3_fifo_ctrl u_ddr3_fifo_ctrl (
105
106 .rst_n (rst_n &&c3_calib_done ) ，
107 //输入源接口
108 .wr_clk (clk_write)，
109 .rd_clk (clk_read)，
110 .clk_100 (clk_100m)， //用户时钟
111 .datain_valid (wr_en)， //输入数据有效使能
112 .datain (wr_data)， //有效数据
113 .rfifo_din (c3_p0_rd_data)， //用户读数据
114 .rdata_req (rd_en)， //请求像素点颜色数据输入
115 .rfifo_wren (c3_p0_rd_en)， //ddr3读出数据的有效使能
116 .wfifo_rden (c3_p0_wr_en)， //ddr3 写使能
117 //用户接口
118 .wfifo_rcount (wfifo_rcount)， //rfifo剩余数据计数
119 .rfifo_wcount (rfifo_wcount)， //wfifo写进数据计数
120 .wfifo_dout (c3_p0_wr_data)， //用户写数据
121 .rd_load (1'b0) ， //输出源更新信号
122 .wr_load (1'b0)， //输入源更新信号
123 .pic_data (rd_data) //rfifo输出数据
124 );
125
126 //ddr ip核
127 ddr3 # (
128 .C3_NUM_DQ_PINS (C3_NUM_DQ_PINS)，
129 .C3_MEM_ADDR_WIDTH (C3_MEM_ADDR_WIDTH)，
130 .C3_MEM_BANKADDR_WIDTH (C3_MEM_BANKADDR_WIDTH)
131 )
132 ddr3 (
133
134 .c3_sys_clk (clk_ddr)，
135 .c3_sys_rst_i (1'b0)，
136
137 .mcb3_dram_dq (mcb3_dram_dq)，
138 .mcb3_dram_a (mcb3_dram_a)，
139 .mcb3_dram_ba (mcb3_dram_ba)，
140 .mcb3_dram_ras_n (mcb3_dram_ras_n)，
141 .mcb3_dram_cas_n (mcb3_dram_cas_n)，
142 .mcb3_dram_we_n (mcb3_dram_we_n)，
143
144 .mcb3_dram_cke (mcb3_dram_cke)，
145 .mcb3_dram_ck (mcb3_dram_ck)，
146 .mcb3_dram_ck_n (mcb3_dram_ck_n)，
147 .mcb3_dram_dqs (mcb3_dram_dqs)，
148 .mcb3_dram_dqs_n (mcb3_dram_dqs_n)，
149 .mcb3_dram_udqs (mcb3_dram_udqs)，
150 .mcb3_dram_udqs_n (mcb3_dram_udqs_n)，
151 .mcb3_dram_udm (mcb3_dram_udm)，
152 .mcb3_dram_dm (mcb3_dram_dm)，
153 .mcb3_dram_reset_n (mcb3_dram_reset_n)，
154
155 .c3_clk0 (c3_clk0)，
156 .c3_rst0 (c3_rst0)，
157 .c3_calib_done (c3_calib_done)，
158 .mcb3_rzq (mcb3_rzq)，
159 .mcb3_zio (mcb3_zio)，
160
161 .c3_p0_cmd_clk (clk_100m)，
162 .c3_p0_cmd_en (c3_p0_cmd_en)，
163 .c3_p0_cmd_instr (c3_p0_cmd_instr)，
164 .c3_p0_cmd_bl (c3_p0_cmd_bl)，
165 .c3_p0_cmd_byte_addr (c3_p0_cmd_byte_addr)，
166 .c3_p0_cmd_empty (c3_p0_cmd_empty)，
167 .c3_p0_cmd_full (c3_p0_cmd_full)，
168 .c3_p0_wr_clk (clk_100m)，
169 .c3_p0_wr_en (c3_p0_wr_en)，
170 .c3_p0_wr_mask (c3_p0_wr_mask)，
171 .c3_p0_wr_data (c3_p0_wr_data)，
172 .c3_p0_wr_full (c3_p0_wr_full)，
173 .c3_p0_wr_empty (c3_p0_wr_empty)，
174 .c3_p0_wr_count (c3_p0_wr_count)，
175 .c3_p0_wr_underrun (c3_p0_wr_underrun)，
176 .c3_p0_wr_error (c3_p0_wr_error)，
177 .c3_p0_rd_clk (clk_100m)，
178 .c3_p0_rd_en (c3_p0_rd_en)，
179 .c3_p0_rd_data (c3_p0_rd_data)，
180 .c3_p0_rd_full (c3_p0_rd_full)，
181 .c3_p0_rd_empty (c3_p0_rd_empty)，
182 .c3_p0_rd_count (c3_p0_rd_count)，
183 .c3_p0_rd_overflow (c3_p0_rd_overflow)，
184 .c3_p0_rd_error (c3_p0_rd_error)
185
186 );
187
188 endmodule

复制代码

ddr控制器模块主要完成ddr读写模块、fifo控制模块和MIG IP核的例化。ddr读写模块负责与MIG模块的命令和地址的交互，根据FIFO控制模块中fifo的剩余数据量来切换DDR3的读写命令和地址。MIG IP核一边与用户端进行交互，另一边对芯片进行操作，以实现数据的存储。fifo控制模块负责对输入和输出的数据进行时钟域的切换和位宽的转换。
fifo读写模块的代码如下：

1 module ddr3_fifo_ctrl(
2 input rst_n ， //复位信号
3 input wr_clk ， //wfifo时钟
4 input rd_clk ， //rfifo时钟
5 input clk_100 ， //用户时钟
6 input datain_valid ， //数据有效使能信号
7 input [15:0] datain ， //有效数据
8 input [127:0] rfifo_din ， //用户读数据
9 input rdata_req ， //请求像素点颜色数据输入
10 input rfifo_wren ， //从ddr3读出数据的有效使能
11 input wfifo_rden ， //wfifo读使能
12 input rd_load ， //输出源更新信号
13 input wr_load ， //输入源更新信号
14
15 output [127:0] wfifo_dout ， //用户写数据
16 output [8:0] wfifo_rcount ， //rfifo剩余数据计数
17 output [8:0] rfifo_wcount ， //wfifo写进数据计数
18 output [15:0] pic_data //有效数据
19 );
20
21 //reg define
22 reg [127:0] datain_t ; //由16bit输入源数据移位拼接得到
23 reg [7:0] cam_data_d0 ;
24 reg [4:0] i_d0 ;
25 reg [15:0] rd_load_d ; //由输出源更新信号移位拼接得到
26 reg [6:0] byte_cnt ; //写数据移位计数器
27 reg [127:0] data ; //rfifo输出数据打拍得到
28 reg [15:0] pic_data ; //有效数据
29 reg [4:0] i ; //读数据移位计数器
30 reg [15:0] wr_load_d ; //由输入源更新信号移位拼接得到
31 reg [3:0] cmos_ps_cnt ; //等待帧数稳定计数器
32 reg cam_href_d0 ;
33 reg cam_href_d1 ;
34 reg wr_load_d0 ;
35 reg rd_load_d0 ;
36 reg rdfifo_rst_h ; //rfifo复位信号，高有效
37 reg wr_load_d1 ;
38 reg wfifo_rst_h ; //wfifo复位信号，高有效
39 reg wfifo_wren ; //wfifo写使能信号
40
41 //wire define
42 wire [127:0] rfifo_dout ; //rfifo输出数据
43 wire [127:0] wfifo_din ; //wfifo写数据
44 wire [15:0] dataout[0:15] ; //定义输出数据的二维数组
45 wire rfifo_rden ; //rfifo的读使能
46
47 //*****************************************************
48 //** main code
49 //*****************************************************
50
51 //rfifo输出的数据存到二维数组
52 assign dataout[0] = rfifo_dout[127:112];
53 assign dataout[1] = rfifo_dout[111:96];
54 assign dataout[2] = rfifo_dout[95:80];
55 assign dataout[3] = rfifo_dout[79:64];
56 assign dataout[4] = rfifo_dout[63:48];
57 assign dataout[5] = rfifo_dout[47:32];
58 assign dataout[6] = rfifo_dout[31:16];
59 assign dataout[7] = rfifo_dout[15:0];
60
61 assign wfifo_din = datain_t ;
62
63 //移位寄存器计满时，从rfifo读出一个数据
64 assign rfifo_rden = (rdata_req && (i==7)) ? 1'b1 : 1'b0;
65
66 //16位数据转128位
67 always @(posedge wr_clk or negedge rst_n) begin
68 if(!rst_n) begin
69 datain_t <= 0;
70 byte_cnt <= 0;
71 end
72 else if(datain_valid) begin
73 if(byte_cnt == 7)begin
74 byte_cnt <= 0;
75 datain_t <= {datain_t[111:0]，datain};
76 end
77 else begin
78 byte_cnt <= byte_cnt + 1;
79 datain_t <= {datain_t[111:0]，datain};
80 end
81 end
82 else begin
83 byte_cnt <= byte_cnt;
84 datain_t <= datain_t;
85 end
86 end
87
88 //wfifo写使能产生
89 always @(posedge wr_clk or negedge rst_n) begin
90 if(!rst_n)
91 wfifo_wren <= 0;
92 else if(wfifo_wren == 1)
93 wfifo_wren <= 0;
94 else if(byte_cnt == 7 && datain_valid ) //输入源数据传输8次，写使能拉高一次
95 wfifo_wren <= 1;
96 else
97 wfifo_wren <= 0;
98 end
99
100 //对rfifo出来的128bit数据拆解成16个16bit数据
101 always @(posedge rd_clk or negedge rst_n) begin
102 if(!rst_n) begin
103 pic_data <= 16'b0;
104 i <=0;
105 i_d0 <= 0;
106 end
107 else if(rdata_req) begin
108 if(i == 7)begin
109 pic_data <= dataout;
110 i <= 0;
111 i_d0 <= i;
112 end
113 else begin
114 pic_data <= dataout;
115 i <= i + 1;
116 i_d0 <= i;
117 end
118 end
119 else begin
120 pic_data <= pic_data;
121 i <=0;
122 i_d0 <= 0;
123 end
124 end
125
126 always @(posedge clk_100 or negedge rst_n) begin
127 if(!rst_n)
128 rd_load_d0 <= 1'b0;
129 else
130 rd_load_d0 <= rd_load;
131 end
132
133 //对输出源更新信号进行移位寄存
134 always @(posedge clk_100 or negedge rst_n) begin
135 if(!rst_n)
136 rd_load_d <= 1'b0;
137 else
138 rd_load_d <= {rd_load_d[14:0]，rd_load_d0};
139 end
140
141 //产生一段复位电平，满足fifo复位时序
142 always @(posedge clk_100 or negedge rst_n) begin
143 if(!rst_n)
144 rdfifo_rst_h <= 1'b0;
145 else if(rd_load_d[0] && !rd_load_d[14])
146 rdfifo_rst_h <= 1'b1;
147 else
148 rdfifo_rst_h <= 1'b0;
149 end
150
151 //对输入源更新信号进行移位寄存
152 always @(posedge wr_clk or negedge rst_n) begin
153 if(!rst_n)begin
154 wr_load_d0 <= 1'b0;
155 wr_load_d <= 16'b0;
156 end
157 else begin
158 wr_load_d0 <= wr_load;
159 wr_load_d <= {wr_load_d[14:0]，wr_load_d0};
160 end
161 end
162
163 //产生一段复位电平，满足fifo复位时序
164 always @(posedge wr_clk or negedge rst_n) begin
165 if(!rst_n)
166 wfifo_rst_h <= 1'b0;
167 else if(wr_load_d[0] && !wr_load_d[15])
168 wfifo_rst_h <= 1'b1;
169 else
170 wfifo_rst_h <= 1'b0;
171 end
172
173 //写数据fifo
174 fifo_512x128b u_fifo_512x128b_w (
175 .wr_clk (wr_clk)，
176 .rd_clk (clk_100)，
177 .rst (~rst_n|wfifo_rst_h)，
178 .din (wfifo_din)，
179 .wr_en (wfifo_wren)，
180 .rd_en (wfifo_rden)，
181 .dout (wfifo_dout)，
182 .full ()，
183 .empty ()，
184 .rd_data_count (wfifo_rcount)，
185 .wr_data_count ()
186 );
187
188 //读数据fifo
189 fifo_512x128b u_fifo_512x128b_r (
190 .wr_clk (clk_100)，
191 .rd_clk (rd_clk)，
192 .rst (~rst_n|rdfifo_rst_h)，
193 .din (rfifo_din)，
194 .wr_en (rfifo_wren)，
195 .rd_en (rfifo_rden)，
196 .dout (rfifo_dout)，
197 .full ()，
198 .empty ()，
199 .rd_data_count ()，
200 .wr_data_count (rfifo_wcount)
201 );
202
203 endmodule

复制代码

在程序的第52行至59行是将DDR3输出的128bit的数据存入一个二维数组（dataout）中，方便后面的数据拆解。
在程序的第64行，表示当读请求信号（rdata_req）拉高8个时钟周期后，rfifo的读使能（rfifo_rden）拉高一个周期，这么做的原因是rfifo的数据输出为128bit而本模块的数据输出（pic_data）为16bit。

图 33.4.25 写数据数据转换

图 33.4.26 读数据数据转换

在程序的第67行至86行对写数据进行了移位拼接，具体时序如图 33.4.25所示。因为输入数据（datain）为16bit每时钟周期，而MIG核每一个时钟周期写入的信号位宽为128bit，所以写数据移位计数器（byte_cnt）信号计到7时清零，同时FIFO的写使能wfifo_wren拉高一个周期。图 33.4.25中红色框中的数值为将要写入fifo的128bit数据。同理模块的输出也是16bit一个时钟周期，所以在程序的第101行至124行对128bit的数据进行了拆解，具体时序如图 33.4.26所示。
在程序的第89行至98行，当写数据有效使能信号（datain_valid）拉高8个时钟周期后，wfifo的写使能才拉高一个周期，这么做的原因是wfifo的数据输入为128bit而本模块的数据输入（datain）为16bit。
在程序的第126行至131行，是对输入源的更新信号进行时钟域同步，方便后面代码的调用，以减少信号的跨时钟域。
在程序的第134行至139行，对输出源的更新信号进行移位寄存，方便后面产生一段复位电平信号。
在程序的第142行至149行和第164行至171行是分别对rfifo和wfifo进行复位，这里进行复位是为了在读写更新信号结束后清空FIFO，保证下次数据到来之前FIFO为空。细心的朋友应该发现了一般复位是一个时钟周期，为什么这里的复位是一段电平，因为XILINX的手册规定FIFO的复位周期必须大于读写时钟的5个时钟周期，才能使FIFO完全复位。
ddr3读写模块的代码如下：

1 module ddr_rw
2 (
3 input clk_100m， //输入时钟
4 input rst_n， //系统复位，低电平有效
5 //ddr3 port
6 input c3_calib_done， //ddr3初始化成功标志
7 input ddr3_read_valid， //ddr3读使能
8 input ddr3_pingpang_en， //ddr3乒乓操作使能
9 input c3_p0_cmd_full， //命令fifo满标志
10 input c3_p0_rd_empty， // fifo空信号
11 output c3_p0_cmd_en， //命令使能
12 output[2:0] c3_p0_cmd_instr， //命令输入
13 output[5:0] c3_p0_cmd_bl， //数据突发长度
14 output[29:0] c3_p0_cmd_byte_addr， //数据地址
15 output c3_p0_wr_en， //写数据使能
16 output[7:0] c3_p0_wr_mask， //写数据掩码
17 input c3_p0_wr_full， //写数据fifo满标志
18 output c3_p0_rd_en， //数据读使能
19 //write
20 input clk_write， //写操作时钟
21 input [29:0] wr_max_addr， //写最大地址
22 input [29:0] wr_min_addr， //写最小地址
23 input [9:0] wr_length， //一次写长度
24 //read
25 input clk_read， //读操作时钟
26 input [29:0] rd_max_addr， //读最大地址
27 input [29:0] rd_min_addr， //读最小地址
28 input [9:0] rd_length， //一次读长度
29 input [8:0] rfifo_wcount， //读fifo写端写入数据个数
30 input [8:0] wfifo_rcount //写fifo读端剩余数据个数
31 );
32
33 //localparam define
34 localparam MCB_CMD_WR = 3'b000; //DDR写命令
35 localparam MCB_CMD_RD = 3'b001; //DDR读命令
36 localparam IDLE = 4'b0001; //空闲状态
37 localparam DDR3_DONE = 4'b0010; //DDR3初始化完成状态
38 localparam WRITE = 4'b0100; //读FIFO保持状态
39 localparam READ = 4'b1000; //写FIFO保持状态
40
41 //reg define
42 reg [29:0] wr_addr_cnt ; //写地址计数
43 reg [29:0] rd_addr_cnt ; //读地址计数
44 reg c3_calib_done_d0;
45 reg c3_calib_done_d1;
46 reg [27:0] ddr_addr_rd; //DDR3读地址
47 reg [27:0] ddr_addr_wr; //DDR3写地址
48 reg [3:0] state_cnt; //状态计数器
49 reg [29:0] wr_max_addr_d0; //写最大地址
50 reg [29:0] wr_min_addr_d0; //写最小地址
51 reg [9:0] wr_length_d0; //一次写长度
52 reg [29:0] rd_max_addr_d0; //读最大地址
53 reg [29:0] rd_min_addr_d0; //读最小地址
54 reg [9:0] rd_length_d0; //一次读长度
55 reg [5:0] c3_p0_cmd_bl; //P0端数据突发长度
56 reg [29:0] c3_p0_cmd_byte_addr; //P0端数据地址
57 reg [7:0] c3_p0_wr_mask; //P0端写数据掩码
58
59 //wire define
60 wire c3_p0_cmd_en; //P0端命令使能
61 wire [2:0] c3_p0_cmd_instr; //P0端命令输入
62 wire c3_p0_wr_en; //P0端写数据使能
63 wire [127:0]c3_p0_wr_data; //P0端写数据
64 wire c3_p0_rd_en; //P1端数据读使能
65
66 //*****************************************************
67 //** main code
68 //*****************************************************
69
70 //ddr的写数据使能
71 assign c3_p0_wr_en = ((state_cnt == WRITE) && ~c3_p0_cmd_full
72 && ~c3_p0_wr_full) ? 1'b1 : 1'b0;
73
74 //ddr的命令使能
75 assign c3_p0_cmd_en = (((state_cnt == WRITE) || (state_cnt == READ) )
76 && !c3_p0_cmd_full) ? 1'b1 : 1'b0;
77
78 //ddr的命令指令
79 assign c3_p0_cmd_instr = (state_cnt == WRITE) ? MCB_CMD_WR : MCB_CMD_RD;
80
81 //ddr的读数据使能
82 assign c3_p0_rd_en = ~c3_p0_rd_empty;
83
84 //对输入信号打拍
85 always @(posedge clk_100m or negedge rst_n) begin
86 if(rst_n==1'b0) begin
87 c3_calib_done_d0 <= 0;
88 c3_calib_done_d1 <= 0;
89 wr_max_addr_d0 <= 0;
90 wr_min_addr_d0 <= 0;
91 rd_max_addr_d0 <= 0;
92 rd_min_addr_d0 <= 0;
93 wr_length_d0 <= 0;
94 rd_length_d0 <= 0;
95 end
96 else begin
97 c3_calib_done_d0 <= c3_calib_done;
98 c3_calib_done_d1 <= c3_calib_done_d0;
99 wr_max_addr_d0 <= wr_max_addr;
100 wr_min_addr_d0 <= wr_min_addr;
101 rd_max_addr_d0 <= rd_max_addr;
102 rd_min_addr_d0 <= rd_min_addr;
103 wr_length_d0 <= wr_length;
104 rd_length_d0 <= rd_length;
105 end
106 end
107
108 //将数据读写地址赋给ddr地址
109 always @(*) begin
110 if(~rst_n)
111 c3_p0_cmd_byte_addr <= 0;
112 else if(state_cnt == READ )
113 c3_p0_cmd_byte_addr <= {3'b0，ddr_addr_rd[25:0]};
114 else
115 c3_p0_cmd_byte_addr <= {3'b0，ddr_addr_wr[25:0]};
116 end
117
118
119 //DDR3读写逻辑实现
120 always @(posedge clk_100m or negedge rst_n) begin
121 if(~rst_n) begin
122 state_cnt <= IDLE;
123 wr_addr_cnt <= 24'd0;
124 rd_addr_cnt <= 24'd0;
125 ddr_addr_wr <= 28'd0;
126 ddr_addr_rd <= 28'd0;
127 c3_p0_wr_mask <=0;
128 c3_p0_cmd_bl <= 6'd0;
129 end
130 else begin
131 case(state_cnt)
132 IDLE:begin
133 if(c3_calib_done_d1)
134 state_cnt <= DDR3_DONE ;
135 else
136 state_cnt <= IDLE ;
137 end
138 DDR3_DONE:begin
139 if(ddr_addr_rd >= {rd_max_addr_d0，1'b0} - 5'd16)begin
140 state_cnt <= DDR3_DONE;
141 rd_addr_cnt <= 24'd0;
142 ddr_addr_rd <= rd_min_addr_d0;
143 c3_p0_cmd_bl <= 6'd0;
144 end //当写到结束地址对寄存器复位
145 else if(ddr_addr_wr >= {wr_max_addr_d0，1'b0} - 5'd16)begin
146 state_cnt <= DDR3_DONE;
147 wr_addr_cnt <= 24'd0;
148 ddr_addr_wr <= wr_min_addr_d0;
149 c3_p0_cmd_bl <= 6'd0;
150 end
151 else if(wfifo_rcount >= wr_length_d0 - 3 )begin
152 state_cnt <= WRITE; //跳到写操作
153 wr_addr_cnt <= 24'd0;
154 ddr_addr_wr <= ddr_addr_wr; //写地址保持不变
155 c3_p0_cmd_bl <= 6'd0;
156 end //当rfifo存储数据少于半次一次读长度时
157 else if(rfifo_wcount < rd_length_d0/2 && ddr3_read_valid )begin
158 state_cnt <= READ; //跳到读操作
159 rd_addr_cnt <= 24'd0;
160 ddr_addr_rd <= ddr_addr_rd; //读地址保持不变
161 c3_p0_cmd_bl <= 6'd0;
162 end
163 else begin
164 state_cnt <= state_cnt;
165 wr_addr_cnt <= 24'd0;
166 rd_addr_cnt <= 24'd0;
167 c3_p0_cmd_bl <= 6'd0;
168 end
169 end
170 WRITE: begin //写到设定的长度跳到等待状态
171 if((wr_addr_cnt == (wr_length_d0 - 1)) && c3_p0_cmd_en)begin
172 state_cnt <= DDR3_DONE; //一次性写进16个字节，故加16
173 ddr_addr_wr <= ddr_addr_wr + {(c3_p0_cmd_bl+1'b1)，4'b0};
174 end
175 else if(c3_p0_wr_en)begin //写条件满足
176 wr_addr_cnt <= wr_addr_cnt + 1'd1;//写地址计数器自加
177 ddr_addr_wr <= ddr_addr_wr + {(c3_p0_cmd_bl+1'b1)，4'b0};
178 c3_p0_cmd_bl <= 6'd0;
179 end
180 else begin //写条件不满足，保持当前值
181 wr_addr_cnt <= wr_addr_cnt;
182 ddr_addr_wr <= ddr_addr_wr;
183 end
184 end
185 READ:begin //读到设定的地址长度
186 if((rd_addr_cnt == (rd_length_d0 - 1)) && c3_p0_cmd_en)begin
187 state_cnt <= DDR3_DONE; //则跳到空闲状态
188 ddr_addr_rd <= ddr_addr_rd + {(c3_p0_cmd_bl+1'b1)，4'b0};
189 end //一次性读出16个字节，故加16
190 else if(!c3_p0_cmd_full)begin //若命令缓冲区不为满，则开始写入读地址
191 rd_addr_cnt <= rd_addr_cnt + 1'd1; //用户地址计数器每次加一
192 ddr_addr_rd <= ddr_addr_rd + {(c3_p0_cmd_bl+1'b1)，4'b0};
193 c3_p0_cmd_bl <= 6'd0; //一次性读出16个数，DDR3地址加16
194 end
195 else begin //命令缓冲区为满，则保持原值
196 rd_addr_cnt <= rd_addr_cnt;
197 ddr_addr_rd <= ddr_addr_rd;
198 end
199 end
200 default:begin
201 state_cnt <= IDLE;
202 wr_addr_cnt <= 24'd0;
203 rd_addr_cnt <= 24'd0;
204 end
205 endcase
206 end
207 end
208
209 endmodule

复制代码

代码第71行定义了ddr的写数据使能，当状态跳到写状态即说明写fifo里面已经存够了一次写长度的数据，信号c3_p0_cmd_full和信号c3_p0_wr_full为低，则说明命令和写数据缓冲区没有写满数据。当这些条件都满足时，从写fifo读出的数据才能写入ddr3中。
代码第75行定义了ddr的命令使能，当状态跳到读或写状态即说明我们将要进行读操作或者写操作，因此当命令缓冲区不为满时就要拉高ddr的命令使能。
代码第79行定义了ddr的命令信号，当状态为写状态时，将写命令赋给该信号，否则将读命令赋给该信号。
代码第82行定义了ddr的读使能信号，当信号c3_p0_rd_empty为低时，表明MIG IP核已经从ddr中读出数据并存放到读数据缓冲区了，因此这里将该信号取反赋给ddr的读使能信号。
代码第85行至106行是对输入的信号进行打拍，减少信号的扇出，优化时序。
代码第109行至116行是将数据读写地址赋给ddr地址，当状态处于写状态时就将写地址赋给ddr地址，反之就将读地址赋给ddr地址。
代码第120行至207行是DDR3读写逻辑实现，转态跳转如下图所示：

图 33.4.27 ddr读写状态跳转图

在复位结束后，如果DDR3没有初始化完成，那么状态一直在空闲状态（IDLE），否则跳到DDR3空闲状态（DDR3_DONE）。
程序中第139至150行，当读写地址达到最大读写地址时，对地址和计数器进行复位操作。这里的信号ddr_addr_rd和信号ddr_addr_wr都是字节地址，而输入进来的最大读写地址是以16bit为一个地址来计算的，所以在这里需要将最大读写地址左移一位来计算，相当于将最大读写地址乘以2后与ddr的读写地址做比较。时序图如下所示：

图 33.4.28 读操作清零

图 33.4.29 写操作清零

程序中第151至156行是处理DDR3写请求，以免写FIFO溢出，造成写入DDR3的数据丢失。当写FIFO中的数据量大于一次写长度时，执行写DDR3操作。时序如下图所示：

图 33.4.30 写状态跳转时序

程序中第157至162行是处理DDR3读请求，以免读FIFO读空，造成空读的现象。当读FIFO中的数据量小于一半一次读长度时，执行读DDR3操作。时序如下图所示：

图 33.4.31 读状态跳转时序

程序中第170至184行是写状态的逻辑，当写地址计数器达到一次写操作长度的时候并且写fifo读使能为高的时候，将状态跳转到DDR3空闲状态。这里的写fifo读使能为高也以为着MIG IP核的命令缓冲区和写数据缓冲区没有写满。细心的朋友可能发现这里的地址为什么加16，这是因为用户端在每一个用户时钟进行一个128bit的数据的传输，而输入到MIG IP核的地址为字节地址，所以这里要加16。时序图如下图所示：

图 33.4.32 写状态时序

程序中第185至199行是读状态的逻辑，当读地址计数器达到一次读操作长度的时候并且命令使能为高的时候，将状态跳转到DDR3空闲状态，否则在命令缓冲区没满的时候对读地址进行累加，同时读地址计数器也进行累加。时序图如下图所示：

图 33.4.33 读状态时序

ddr测试数据模块的代码如下：

1 module ddr_test(
2 input clk_50m， //时钟
3 input rst_n， //复位，低有效
4
5 output reg wr_en， //写使能
6 output reg [15:0] wr_data， //写数据
7 output reg rd_en， //读使能
8 input [15:0] rd_data， //读数据
9 input [24:0] data_max， //写入ddr的最大数据量
10
11 input ddr3_init_done， //ddr3初始化完成信号
12 output reg error_flag //ddr3读写错误
13
14 );
15
16 //reg define
17 reg init_done_d0;
18 reg init_done_d1;
19 reg [24:0] wr_cnt; //写操作计数器
20 reg [24:0] rd_cnt; //读操作计数器
21 reg rd_valid; //读数据有效标志
22 reg [24:0] rd_cnt_d0;
23 reg rd_en_d0;
24
25 //*****************************************************
26 //** main code
27 //*****************************************************
28
29 //同步ddr3初始化完成信号
30 always @(posedge clk_50m or negedge rst_n) begin
31 if(!rst_n) begin
32 init_done_d0 <= 1'b0;
33 init_done_d1 <= 1'b0;
34 rd_cnt_d0 <= 0;
35 rd_en_d0 <= 0;
36 end
37 else begin
38 init_done_d0 <= ddr3_init_done;
39 init_done_d1 <= init_done_d0;
40 rd_cnt_d0 <= rd_cnt;
41 rd_en_d0 <= rd_en;
42 end
43 end
44
45 //ddr3初始化完成之后，写操作计数器开始计数
46 always @(posedge clk_50m or negedge rst_n) begin
47 if(!rst_n)
48 wr_cnt <= 11'd0;
49 else if(init_done_d1 && (wr_cnt <= data_max ))
50 wr_cnt <= wr_cnt + 1'b1;
51 else
52 wr_cnt <= wr_cnt;
53 end
54
55 //ddr3写端口FIFO的写使能、写数据
56 always @(posedge clk_50m or negedge rst_n) begin
57 if(!rst_n) begin
58 wr_en <= 1'b0;
59 wr_data <= 16'd0;
60 end
61 else if(wr_cnt >= 11'd1 && (wr_cnt <= data_max )) begin
62 wr_en <= 1'b1; //写使能拉高
63 wr_data <= wr_cnt[15:0]; //写入数据
64 end
65 else begin
66 wr_en <= 1'b0;
67 wr_data <= 16'd0;
68 end
69 end
70
71 //写入数据完成后，开始读操作
72 always @(posedge clk_50m or negedge rst_n) begin
73 if(!rst_n)
74 rd_en <= 1'b0;
75 else if(wr_cnt > data_max ) //写数据完成
76 rd_en <= 1'b1; //读使能
77 else
78 rd_en <= rd_en;
79 end
80
81 //对读操作计数
82 always @(posedge clk_50m or negedge rst_n) begin
83 if(!rst_n)
84 rd_cnt <= 11'd1;
85 else if(rd_en) begin
86 if(rd_cnt < data_max)
87 rd_cnt <= rd_cnt + 1'b1;
88 else
89 rd_cnt <= 11'd1;
90 end
91 end
92
93 //第一次读取的数据无效，后续读操作所读取的数据才有效
94 always @(posedge clk_50m or negedge rst_n) begin
95 if(!rst_n)
96 rd_valid <= 1'b0;
97 else if(rd_cnt == data_max ) //等待第一次读操作结束
98 rd_valid <= 1'b1; //后续读取的数据有效
99 else
100 rd_valid <= rd_valid;
101 end
102
103 //读数据有效时，若读取数据错误，给出标志信号
104 always @(posedge clk_50m or negedge rst_n) begin
105 if(!rst_n)
106 error_flag <= 1'b0;
107 else if(wr_en)
108 error_flag <= 1'b0;
109 else if(rd_valid && ((rd_data[15:0] != rd_cnt_d0[15:0])) )
110 error_flag <= 1'b1; //若读取的数据错误，将错误标志位拉高
111 else
112 error_flag <= error_flag;
113 end
114
115 endmodule

复制代码

ddr测试数据模块从写起始地址开始，连续向8192个存储空间中写入数据1~8192。写完成后一直进行读操作，持续将该存储空间的数据读出。需要注意的是程序中第109行通过变量rd_valid将第一次读出的8192个数据排除，并未参与读写测试。这是由于ddr控制器为了保证读FIFO时刻有数据，在写数据尚未完成，就将ddr3中的数据“预读”一部分（一次读长度）到读FIFO中，因此第一次从FIFO中读出的数据是无效的。时序如下图所示：

图 33.4.34 写数据时序1

图 33.4.35 写数据时序2

图 33.4.36 读数据时序1

图 33.4.37 读数据时序2

从上面几个时序图中可以看出读写数据是一致的，因此信号error_flag一直处于低电平。
LED显示模块的代码如下：

1 module led_disp(
2 input clk_50m， //系统时钟
3 input rst_n， //系统复位
4
5 input error_flag， //错误标志信号
6 output reg led //LED灯
7 );
8
9 //reg define
10 reg [24:0] led_cnt; //控制LED闪烁周期的计数器
11
12 //*****************************************************
13 //** main code
14 //*****************************************************
15
16 //计数器对50MHz时钟计数，计数周期为0.5s
17 always @(posedge clk_50m or negedge rst_n) begin
18 if(!rst_n)
19 led_cnt <= 25'd0;
20 else if(led_cnt < 25'd25000000)
21 led_cnt <= led_cnt + 25'd1;
22 else
23 led_cnt <= 25'd0;
24 end
25
26 //利用LED灯不同的显示状态指示错误标志的高低
27 always @(posedge clk_50m or negedge rst_n) begin
28 if(rst_n == 1'b0)
29 led <= 1'b0;
30 else if(error_flag) begin
31 if(led_cnt == 25'd25000000)
32 led <= ~led; //错误标志为高时，LED灯每隔0.5s闪烁一次
33 else
34 led <= led;
35 end
36 else
37 led <= 1'b1; //错误标志为低时，LED灯常亮
38 end
39
40 endmodule

复制代码

LED显示模块用LED不同的显示状态指示ddr3读写测试的结果：若读写测试正确无误，则LED常亮；若出现错误（读出的数据与写入的数据不一致），则LED灯以0.5s为周期闪烁。
33.5下载验证
将下载器一端连接电脑，另一端与开发板上的JTAG下载口连接，连接电源线，并打开开发板的电源开关。硬件连接完成后，将程序下载到超越者开发板中，待程序下载完成后，开发板上的LED0和LED1在短暂延时之后，始处于常亮的状态，如下图所示：

图 33.5.1 DDR3板子测试结果

Liao123 · 发表于 2021-11-10 10:43:38

原子哥可以讲解一下UDF文件的前一段代码吗?很是疑惑

帐号		自动登录	找回密码
密码			立即注册

[XILINX] 【正点原子FPGA连载】第三十三章DDR3读写测试--摘自【正点原子】超越者之FPGA开发指南

相关帖子

原子哥极力推荐 /2