Vivado MIG ip核使用教程（三）_mig状态机

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;
1

2 如何访问DDR3

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

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

2.1 读写控制端口

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

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

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

• 当我们想要对DDR3进行读写操作时，我们不一定可以立即进行读写操作，我们需要先知道DDR3现在是否准备好被写入或者被读出。
• 那么如何知道当下是否可以对DDR3进行读写访问呢？MIG ip核输出了相关的rdy信号，也就是准备好信号，我们根据这些rdy信号来判断当下是否可以对DDR3进行访问。
• 这些rdy信号共有2个，它们是app_rdy、app_wdf_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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.4 读写数据有效？

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

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

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
1
2
3
4
5
6
7
8
9

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






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178