Xilinx MIG核读写DDR3内存，连续读写内存的正确方法（时序）及代码
关于Xilinx 2020.1新建工程时配置MIG核的完整步骤，请参阅：https://blog.csdn.net/ZLK1214/article/details/111349678
MIG核里面有两个通道：命令通道和数据通道。这两个通道是相互独立的，互不影响。
命令通道：要发送的命令由ddr3_app_cmd指定（0号命令是写内存，1号命令是读内存），ddr3_app_en拉高就开始发送命令。
数据通道：要发送的数据由ddr3_app_wdf_data指定，ddr3_app_wdf_wren拉高就开始往FIFO里面送入数据。
MIG里面是严格一个时钟（ddr3_ui_clk）发送一个命令（或写一个数据）。ddr3_app_en如果一直拉高，那么就一直重复发送命令。拉高了多少个时钟周期，就发送多少条命令。同样，ddr3_app_wdf_wren如果一直拉高，就一直重复往FIFO里面写入数据。编写程序的时候要特别注意这一点。
如下图所示是MIG连续写DDR3内存时的时序。ILA的采样周期刚好就是ddr3_ui_clk（100MHz），横向时间单位为10ns。
从红竖线（8192时刻）开始写内存，发送写命令（ddr3_app_cmd=0且ddr3_app_en=1），写的内存地址是ddr3_app_addr=0，同时往FIFO里面送入要写的数据（ddr3_app_wdf_wren=1，wdf的全称为write data FIFO）。第8193时刻，读到ddr3_app_rdy为1说明写命令发送成功，读到ddr3_app_wdf_rdy=1说明数据成功送入FIFO。这两位同时为1表示写内存成功。
第8193时刻又发出了写8号地址的写命令，往FIFO里面塞入数据0x0008。然而，第8194时刻读到ddr3_app_rdy为0，说明写命令发送失败了！！同时读到ddr3_app_wdf_rdy为1，说明往FIFO里面送入数据成功了。这个时候就要注意了，写命令发送失败但FIFO送入数据成功，接下来写命令应该重新发送，但数据不能再往FIFO里面送了！！！也就是图中红框的部分，在第8194时刻必须把ddr3_app_wdf_wren拉低，停止送入数据，不然的话，这种情况下就会连续往FIFO里面送入三个0x0008，导致后面的地址0x0000010（16号地址），0x0000018（24号地址）都被写入0x0008这个数据！！！
如果不懂的话，是非常容易犯这个错误的。
写8号地址的命令发了两次都失败了，第三次终于发送成功了，ddr3_app_rdy为1。在8196时刻可以发送新的写命令了，向FIFO里面写入新的数据。
连续读内存也是类似的。如下图所示是一种错误的做法。只要ddr3_app_en为1，就一直在发命令，ddr3_app_addr一直为0就发了一大串读0号地址的命令。
那改成发一个读命令，等到数据读出来后（ddr3_app_rd_data_valid=1），再发下一个命令，这样就能读出正确的结果，但是抓了波形图一看，中间的等待时间很长，每读一个地址都要等待很久，非常浪费时间。
于是我们可以边发命令，边接收数据。一开始就从0地址开始一直往后发命令：0,8,16,24,36,48……
当ddr3_app_rd_data_valid=1时，我们已经发到0xb0（176）地址了，这个时候0号地址的数据才读出来，于是一个一个接收，如下图所示。
这样连续读数据就会比刚才快很多很多。值得注意的是，接收完最后一个数据后，ddr3_app_rd_data_valid会变为0，表明数据已接收完毕。
我们来看看最终的代码：
这里程序有一个失误，就是ddr3_ui_clk_sync_rst是一个同步复位信号，不应该是异步复位。代码里面写成了always @(posedge ddr3_ui_clk, posedge ddr3_ui_clk_sync_rst) begin，把ddr3_ui_clk_sync_rst用成了一个异步的复位信号，这是不对的。应该把always敏感列表里面的posedge ddr3_ui_clk_sync_rst去掉，写成always @(posedge ddr3_ui_clk) begin才对。不过笔者在实际运行时并没有发现有什么不对的地方。
module main(
input clock, // 50MHz外部晶振
// DDR3引脚
inout [15:0] ddr3_dq,
inout [1:0] ddr3_dqs_n,
inout [1:0] ddr3_dqs_p,
output [13:0] ddr3_addr,
output [2:0] ddr3_ba,
output ddr3_ras_n,
output ddr3_cas_n,
output ddr3_we_n,
output ddr3_reset_n,
output ddr3_ck_p,
output ddr3_ck_n,
output ddr3_cke,
output ddr3_cs_n,
output [1:0] ddr3_dm,
output ddr3_odt,
input [3:0] keys,
output [3:0] leds, // 4个LED灯
output uart_tx // 串口发送引脚
);
parameter SYSCLK = 50000000;
wire nrst;
Reset #(SYSCLK) reset(clock, !keys[0], nrst);
wire clock200;
wire locked;
clk_wiz_0 clk_wiz_0(
.reset(!nrst),
.clk_in1(clock), // 输入50MHz时钟
.clk_out1(clock200), // 输出200MHz时钟
.locked(locked) // 该信号表示输出时钟是否已稳定
);
reg [27:0] ddr3_app_addr;
reg [2:0] ddr3_app_cmd;
reg ddr3_app_en;
reg [127:0] ddr3_app_wdf_data; // 因为burst=8, data_width=16, 所以wdf_data的宽度为8*16=128
reg ddr3_app_wdf_end;
reg ddr3_app_wdf_wren;
wire [127:0] ddr3_app_rd_data; // 这个也是128位
wire ddr3_app_rd_data_end;
wire ddr3_app_rd_data_valid;
wire ddr3_app_rdy;
wire ddr3_app_wdf_rdy;
wire ddr3_app_sr_active;
wire ddr3_app_ref_ack;
wire ddr3_app_zq_ack;
wire ddr3_ui_clk;
wire ddr3_ui_clk_sync_rst;
wire ddr3_init_calib_complete;
wire [11:0] ddr3_device_temp;
mig_7series_0 mig_7series_0(
.ddr3_dq(ddr3_dq),
.ddr3_dqs_n(ddr3_dqs_n),
.ddr3_dqs_p(ddr3_dqs_p),
.ddr3_addr(ddr3_addr),
.ddr3_ba(ddr3_ba),
.ddr3_ras_n(ddr3_ras_n),
.ddr3_cas_n(ddr3_cas_n),
.ddr3_we_n(ddr3_we_n),
.ddr3_reset_n(ddr3_reset_n),
.ddr3_ck_p(ddr3_ck_p), // DDR3内存时钟输出: 400MHz
.ddr3_ck_n(ddr3_ck_n),
.ddr3_cke(ddr3_cke),
.ddr3_cs_n(ddr3_cs_n),
.ddr3_dm(ddr3_dm),
.ddr3_odt(ddr3_odt),
.sys_clk_i(clock200), // 系统时钟输入: 200MHz
.clk_ref_i(clock200), // 参考时钟输入: 200MHz
.app_addr(ddr3_app_addr),
.app_cmd(ddr3_app_cmd),
.app_en(ddr3_app_en),
.app_wdf_data(ddr3_app_wdf_data),
.app_wdf_end(ddr3_app_wdf_end),
.app_wdf_mask(16'h0), // 8突发*每个数据2字节=16字节, 所以mask有16位
.app_wdf_wren(ddr3_app_wdf_wren),
.app_rd_data(ddr3_app_rd_data),
.app_rd_data_end(ddr3_app_rd_data_end),
.app_rd_data_valid(ddr3_app_rd_data_valid),
.app_rdy(ddr3_app_rdy),
.app_wdf_rdy(ddr3_app_wdf_rdy),
.app_sr_req(1'b0),
.app_ref_req(1'b0),
.app_zq_req(1'b0),
.app_sr_active(ddr3_app_sr_active),
.app_ref_ack(ddr3_app_ref_ack),
.app_zq_ack(ddr3_app_zq_ack),
.ui_clk(ddr3_ui_clk), // 用户时钟输出: 因为选的是4:1, 所以ddr3_ck_p:ddr3_ui_clk=4:1, ddr3_ui_clk是100MHz
.ui_clk_sync_rst(ddr3_ui_clk_sync_rst), // 用户程序复位输出
.init_calib_complete(ddr3_init_calib_complete),
.device_temp(ddr3_device_temp),
.sys_rst(locked) // 复位输入: 当倍频器时钟未稳定时, 使MIG处于复位状态
);
// FPGA内部的分布式RAM
// Depth: 112, Data Width: 128, Memory Type: Single Port RAM
reg [6:0] dist_mem_a;
reg [127:0] dist_mem_d;
reg dist_mem_we; // 写使能
wire [127:0] dist_mem_spo;
dist_mem_gen_0 dist_mem_gen_0(
.clk(ddr3_ui_clk),
.a(dist_mem_a),
.d(dist_mem_d),
.spo(dist_mem_spo),
.we(dist_mem_we)
);
// 串口单字节发送
wire uart_tx_request;
wire [7:0] uart_tx_data;
wire uart_tx_ready;
wire uart_sent;
UARTTransmitter #(SYSCLK, 115200) uart_transmitter(clock, locked, uart_tx, uart_tx_request, uart_tx_data, uart_tx_ready, uart_sent);
// 串口多字节组合发送
reg uart_bytearray_tx_mode;
reg [159:0] uart_bytearray_tx_data;
reg uart_bytearray_tx_request;
reg [7:0] uart_bytearray_tx_size;
wire uart_bytearray_tx_ready;
wire uart_bytearray_sent;
ByteArrayTransmitter #(20) uart_bytearray_transmitter(clock, locked, uart_tx_request, uart_tx_data, uart_tx_ready, uart_sent,
uart_bytearray_tx_mode, uart_bytearray_tx_request, uart_bytearray_tx_data, uart_bytearray_tx_size, uart_bytearray_tx_ready, uart_bytearray_sent);
reg [3:0] i;
reg uart_state;
assign leds = i;
always @(posedge ddr3_ui_clk, posedge ddr3_ui_clk_sync_rst) begin
if (ddr3_ui_clk_sync_rst) begin
ddr3_app_en <= 0;
ddr3_app_wdf_wren <= 0;
uart_bytearray_tx_request <= 0;
i <= 0;
uart_state <= 0;
end
else if (!uart_state) begin
if (uart_bytearray_tx_ready) begin
// 串口数据未开始发送
if (!uart_bytearray_tx_request) begin
// 串口空闲
case (i)
0, 1: begin
// 写数据测试
if (ddr3_app_rdy && ddr3_app_wdf_rdy) begin
// 送入新数据
if (i == 0) begin
// [第1批数据]
// MIG配置选择了4:1关系, 所以wdf_end信号应该一直为高
// 且wdf_data的宽度为16字节 (一次性写8个地址)
ddr3_app_cmd <= 0; // WRITE
ddr3_app_addr <= 0; // 写的地址
ddr3_app_en <= 1; // 写命令使能
ddr3_app_wdf_data <= 128'h01234567_89abcdef_5555aaaa_bbbb0000; // 写的数据
ddr3_app_wdf_wren <= 1; // 数据送入FIFO使能
ddr3_app_wdf_end <= 1; // 是本突发最后一组数据
// 这是因为, ddr3_ui_clk的频率是100MHz, ddr3_ck_p的频率是400MHz, DDR内存是上升沿和下降沿都要写数据
// 一个ddr3_ui_clk周期内, ddr3_ck_p的上升沿和下降沿一共出现了8次
// 每出现一次, 就要往ddr3_dq[15:0]上送入2个字节的数据
// 因此, 每个ddr3_ui_clk时钟周期, 刚好要写8*2=16个字节的数据
i <= 1;
end
else if (ddr3_app_addr < 100 * 8) begin
// [第2~101批数据]
ddr3_app_addr <= ddr3_app_addr + 8;
ddr3_app_en <= 1;
ddr3_app_wdf_data[127:16] <= 112'h76543210_fedcba98_bbbb6666_cccc;
ddr3_app_wdf_data[15:0] <= ddr3_app_addr[15:0] + 8;
ddr3_app_wdf_wren <= 1;
end
else begin
// 没有数据要写了, 写数据结束
ddr3_app_en <= 0;
ddr3_app_wdf_wren <= 0;
ddr3_app_wdf_end <= 0;
i <= 2;
end
end
else if (!ddr3_app_rdy && ddr3_app_wdf_rdy) begin
// ddr3_app_rdy=0, 是写命令没有发送成功
// ddr3_app_wdf_rdy=1, 是数据已成功送入FIFO
// 数据已送入FIFO, 但写命令发送失败, 必须撤销数据送入FIFO的请求, 保留写命令请求
// 不能再往FIFO里面送入数据了, 否则多送入的数据会被写入到后续的地址上
ddr3_app_wdf_wren <= 0;
end
else if (ddr3_app_rdy && !ddr3_app_wdf_rdy)
ddr3_app_en <= 0; // 写命令发送成功了, 但数据没有成功送入FIFO, 则需要撤销写命令, 保留数据送入FIFO的请求
end
2, 3: begin
// 读数据测试
// 边发读命令, 边接收数据, 只要ddr3_app_rd_data_valid=1就可以接收数据, 这样读起来才快
// 而不是发一个命令, 收到数据后再发下一个命令
if (ddr3_app_rdy) begin
if (i == 2) begin
// 发送第1条读命令
ddr3_app_addr <= 0;
ddr3_app_cmd <= 1; // READ
ddr3_app_en <= 1;
i <= 3;
end
else if (ddr3_app_addr < 100 * 8)
ddr3_app_addr <= ddr3_app_addr + 8; // 发送第2~101条读命令
else
ddr3_app_en <= 0; // 读命令发送结束
// addr=0*8是第1条命令
// addr=1*8是第2条命令
// addr=100*8是第101条命令
end
if (ddr3_app_rd_data_valid) begin
// 数据读出来了, 将读到的16字节数据暂存到分布式RAM
if (!dist_mem_we)
dist_mem_a <= 0; // 第1个数据
else if (dist_mem_a < 100) begin
dist_mem_a <= dist_mem_a + 1'b1; // 第2~101个数据
if (dist_mem_a + 1'b1 == 100) // dist_mem_a的现态+1(即dist_mem_a的次态)==100
i <= 4; // 最后一个数据读完, 进入串口发送模式
end
dist_mem_d <= ddr3_app_rd_data;
dist_mem_we <= 1;
end
end
4: begin
// 将分布式RAM中暂存的数据通过串口发送出来
// 注意: 把地址赋给dist_mem_a后, 要下一个时钟周期才能从dist_mem_spo取出数据
if (dist_mem_we) begin
dist_mem_we <= 0;
dist_mem_a <= 0;
end
else if (dist_mem_a <= 100) begin
uart_bytearray_tx_request <= 1;
uart_bytearray_tx_mode <= 0;
uart_bytearray_tx_data <= {dist_mem_a, 3'b0, dist_mem_spo};
uart_bytearray_tx_size <= 20;
dist_mem_a <= dist_mem_a + 1'b1;
end
else
i <= 5;
end
endcase
end
end
else
uart_state <= 1; // 串口数据已开始发送
end
else begin
if (uart_bytearray_tx_ready && uart_bytearray_tx_request) begin
// 串口数据已发送
uart_bytearray_tx_request <= 0; // 关闭发送请求
uart_state <= 0;
end
end
end
ila_0 ila_0(
.clk(ddr3_ui_clk),
.probe0(ddr3_ui_clk_sync_rst),
.probe1(ddr3_app_addr), // [27:0]
.probe2(ddr3_app_cmd), // [2:0]
.probe3(ddr3_app_en),
.probe4(ddr3_app_wdf_data[15:0]), // [15:0]
.probe5(ddr3_app_wdf_end),
.probe6(ddr3_app_wdf_wren),
.probe7(ddr3_app_rd_data[15:0]), // [15:0]
.probe8(ddr3_app_rd_data_end),
.probe9(ddr3_app_rd_data_valid),
.probe10(ddr3_app_rdy),
.probe11(ddr3_app_wdf_rdy),
.probe12(ddr3_app_sr_active),
.probe13(ddr3_app_ref_ack),
.probe14(ddr3_app_zq_ack),
.probe15(ddr3_init_calib_complete),
.probe16(ddr3_device_temp) // [11:0]
);
endmodule
我们选用的DDR3内存型号为MT41K128M16，内存容量为256MB。FPGA是米联客XC7A35TFGG484-2的开发板，开发板上接的晶振是50MHz，由Clock Wizard倍频到200MHz后（clock200）用作MIG的系统时钟（sys_clk_i）和参考时钟（clk_ref_i），由MIG再次倍频到400MHz后（ddr3_ck_p和ddr3_ck_n）驱动DDR3内存，分频到100MHz后（ddr3_ui_clk）拿给程序使用，ddr3_ui_clk_sync_rst用作程序的复位信号。ILA抓取信号也是用的ddr3_ui_clk这个时钟。
内存的位宽为16位，一次读写2个字节，时钟的上升沿和下降沿都要读写数据。100MHz的每个时钟周期，DDR3内存的400MHz时钟共出现了4对上升/下降沿，写了8次数据，每次2个字节，所以每个100MHz的时钟周期（10ns），要写16字节。
每10ns写16字节的话，1μs要写1600字节，1ms要写1600000字节，1秒钟要写1600000000字节。也就是说，理论上这片内存的读写速率是1.49GB/s。
ddr3_app_wdf_data和ddr3_app_rd_data都是128位（16字节）。ILA抓信号的时候，为了节约BRAM，只抓data的末16位。
一次性要写8个地址，MIG核配置的突发数也是8，所以，写内存的时候ddr3_app_wdf_end一直为高，每次都是写的突发的最后一组数据。
程序运行后，串口的输出结果如下：
串口输出的是读出来的内存数据，可以看到DDR3内存读写是完全正确的。
引脚配置文件pins.xdc内容如下：
set_property PACKAGE_PIN V4 [get_ports clock]
set_property IOSTANDARD LVCMOS15 [get_ports clock]
set_property PACKAGE_PIN R17 [get_ports uart_tx]
set_property IOSTANDARD LVCMOS33 [get_ports uart_tx]
set_property PACKAGE_PIN D22 [get_ports {leds[3]}]
set_property PACKAGE_PIN E22 [get_ports {leds[2]}]
set_property PACKAGE_PIN D21 [get_ports {leds[1]}]
set_property PACKAGE_PIN E21 [get_ports {leds[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {leds[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {leds[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {leds[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {leds[0]}]
set_property PACKAGE_PIN R14 [get_ports {keys[3]}]
set_property PACKAGE_PIN P14 [get_ports {keys[2]}]
set_property PACKAGE_PIN N14 [get_ports {keys[1]}]
set_property PACKAGE_PIN N13 [get_ports {keys[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {keys[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {keys[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {keys[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {keys[0]}]
DDR3内存的引脚已经在MIG的GUI配置界面配置了，所以我们不需要再在pins.xdc里面配置了。
配置DDR3内存引脚是单独一个xdc文件，是在MIG核的文件夹里面：sources_1\ip\mig_7series_0\mig_7series_0\user_design\constraints\mig_7series_0.xdc
Vivado工程下载地址：
（自己新建的，没有用MIG核的example工程）
https://pan.baidu.com/s/1KrmD7qbhHhRX7BFalfsn-A（提取码：b9x9）
实际上，写内存也可以边发命令边发数据。write data FIFO（WDF）里面最多可以放16个数据。用16个时钟周期把16个数据放进去，直到ddr3_app_wdf_rdy为0就说明把FIFO占满了，然后再来慢慢地发写命令，就可以达到最快的写速度。
MIG时序要求的是数据可以到的比写命令早，也可以滞后，但最晚只能比写命令晚一个周期。
接下来，我们可以用FPGA将DDR3模拟成一个W25Q256存储器，用杜邦线和STM32F103C8小开发板连接起来，做一个U盘，读写DDR3整个256MB的空间，进行全片测试：
https://blog.csdn.net/ZLK1214/article/details/111416038