本文为明德扬原创及录用文章，转载请注明出处！

1.1 总体设计

1.1.1 概述

同步动态随机存取内存（synchronousdynamic randon-access menory，简称SDRAM）是有一个同步接口的动态随机存取内存（DRAM）。通常DRAM是有一个异步接口的，这样它可以随时响应控制输入的变化。而SDRAM有一个同步接口，在响应控制输入前会等待一个时钟信号，这样就能和计算机的系统总线同步。时钟被用来驱动一个有限状态机，对进入的指令进行管线操作。这使得SDRAM与没有同步接口的异步DRAM相比，可以有一个更复杂的操作模式。

管线意味着芯片可以在处理完之前的指令前，接受一个新的指令。在一个写入的管线中，写入命令在另一个指令执行完之后可以立刻执行，而不需要等到数据写入存储队列的时间。在一个读取的流水线中，需要的数据在读取指令发出之后固定数量的时钟频率后到达，而这个等待的过程可以发出其他附加指令。这种延迟被称为等待时间（Latency），在为计算机购买内存时是一个很重要的参数。

SDRAM之所以称为DRAM就是因为他要不断进行刷新才能保留住数据，因为刷新是DRAM最重要的操作。那么要隔多长时间重复一次刷新，目前公认的标准是，存储体中电容的数据有效保存期上限是64ms，也就是每一行刷新的循环周期是64ms。

SDRAM是多Bank结构，例如在一个具有两个Bank的SDRAM模组中，其中一个Bank在进行预充电期间，另一个Bank却马上可以被读取，这样当进行一次读取后，又马上读取已经预充电Bank的数据时，就无需等待而是可以直接读取了，这也就大大提高了存储器的访问速度

1.1.2 设计目标

设计SDRAM读写控制器来控制开发板上的一片SDRAM进行读写数据的操作，具体功能要求如下：

1.      SDRAM的读写分别由两个按键进行控制，每按下一次，就会产生一个读使能或者写使能；

2.      SDRAM读写模式为全页突发模式，每次写入某个Bank512个数据，在读此Bank的时候，也应该读出相同的512个数据；

3.      SDRAM读写地址都是从地址0开始；

4.     通过一个按键控制读写SDRAM的Bank地址，按键每按下一次，Bank地址加1。

1.1.3 系统结构框图

系统结构框图如下图一所示：

图一

1.1.4模块功能


  按键检测模块实现功能

1、  将外来异步信号打两拍处理，将异步信号同步化。

2、  实现20ms按键消抖功能。

3、  实现矩阵键盘或者普通案件的检测功能，并输出有效按键信号。

锁相环

1、产生工程所需要的100M时钟。

  数据产生模块实现功能

1、  通过按键控制产生读/写请求。

2、  通过按键控制Bank地址选择。

3、  产生地址和写数据。

SDRAM接口模块实现功能

1、  接收上游模块发送的读/写请求、Bank地址、行地址和写数据，产生SDRAM的控制时序。

1.1.5顶层信号

信号名	I/O	位宽	定义
clk	I	1	系统工作时钟 50M
rst_n	I	1	系统复位信号，低电平有效
Key	I	4	4位按键信号，开发板按键为矩阵键盘时，不需要该信号
Key_col	I	4	4位矩阵键盘列信号，默认高电平，开发板按键为普通按键时，不需要该信号
Key_row	O	4	4位矩阵键盘行信号，默认低电平，开发板按键为普通按键时，不需要该信号
dq	I/O	16	SDRAM数据总线，既能作为数据输出，也能作为数据输入。
cke	O	1	SDRAM时钟使能信号，决定是否启用clk输入，为高电平时，时钟有效。
cs	O	1	SDRAM片选信号，决定设备内是否启用命令输入，当cs为低时启用，当cs为高时禁用命令输入。
ras	O	1	行地址选通信号，低电平有效
cas	O	1	列地址选通信号，低电平有效
we	O	1	写使能信号，低电平有效
dqm	O	2	数据掩码，控制I/O的高低字节，低电平有效。例如：2’b10，表示数据高字节无效，低字节有效。
sd_addr	O	13	SDRAM地址信号。
sd_bank	O	2	Bank地址选择信号，通过该信号决定哪个Bank正处于激活、读、写、预充电等命令期间。
sd_clk	O	1	SDRAM输入时钟，除cke外，SDRAM的所有输入与该引脚的上升沿同步获得。

1.1.6三态门

由于SDRAM只有一条数据总线，虽然可以既当作输入，又当作输出来用，但是输入和输出是不能同时进行的，因此需要在工程的顶层设计中采用三态门。代码如下：

关于三态门详细的介绍可以看明德扬《FPGA至简设计原理与应用》书中的第一篇第三章5.2.4高阻态一节。

【FPGA至简设计原理与应用】书籍连载03第一篇FPGA基础知识第三章硬件描述语言Verilog

1.1.7参考代码

下面是使用工程的顶层代码：

1. module sdram_top(
   
2.     clk      ,
   
3.     rst_n    ,
   
4.     key      ,
   
5.     dq       ,
   
6.     cke      ,
   
7.     cs       ,  
   
8.     ras      ,
   
9.     cas      ,
   
10.     we       ,
    
11.     dqm      ,
    
12.     sd_addr  ,
    
13.     sd_bank  ,
    
14.     sd_clk     
    
15.     );
    
16. 
    
17.     input              clk     ;
    
18.     input              rst_n   ;
    
19.     input  [3:0]       key     ;
    
20.     inout  [15:0]      dq      ;
    
21.     output             cke     ;   
    
22.     output             cs      ;
    
23.     output             ras     ;
    
24.     output             cas     ;
    
25.     output             we      ;
    
26.     output [1 :0]      dqm     ;
    
27.     output [12:0]      sd_addr ;
    
28.     output [1 :0]      sd_bank ;
    
29.     output             sd_clk  ;
    
30. 
    
31. 
    
32. 
    
33.     wire               cke     ;
    
34.     wire               cs      ;
    
35.     wire               ras     ;
    
36.     wire               cas     ;
    
37.     wire               we      ;
    
38.     wire  [1 :0]       dqm     ;
    
39.     wire  [12:0]       sd_addr ;
    
40.     wire  [1 :0]       sd_bank ;
    
41.     wire               sd_clk  ;
    
42. 
    
43. 
    
44. 
    
45.     wire              clk_100m ;
    
46.     wire              wr_ack   ;
    
47.     wire              rd_ack   ;
    
48.     wire              wr_req   ;
    
49.     wire              rd_req   ;
    
50.     wire [1 :0]       bank     ;
    
51.     wire [12:0]       addr     ;
    
52.     wire [15:0]       wdata    ;
    
53.     wire [15:0]       rdata    ;
    
54.     wire              rdata_vld;
    
55.     wire [3:0 ]       key_vld  ;
    
56. 
    
57.     wire [15:0]       dq_in    ;
    
58.     wire [15:0]       dq_out   ;
    
59.     wire              dq_out_en;
    
60. 
    
61.     assign  dq_in = dq;
    
62.     assign  dq    = dq_out_en?dq_out:16'hzzzz;
    
63.         
    
64. 
    
65. 
    
66.     pll_100m uut_pll(
    
67.             .inclk0    (clk      ),
    
68.             .c0        (clk_100m )
    
69.     );
    
70. 
    
71.     key_module uut_key(
    
72.         .clk       (clk_100m ),
    
73.         .rst_n     (rst_n    ),
    
74.         .key_in    (key      ),
    
75.         .key_vld   (key_vld  ),
    
76.     );
    
77.         
    
78.     data_ctrl uut_ctrl(
    
79.         .clk       (clk_100m ),
    
80.         .rst_n     (rst_n    ),
    
81.         .key_vld   (key_vld  ),
    
82.         .wr_ack    (wr_ack   ),   
    
83.         .rd_ack    (rd_ack   ),   
    
84.         .wr_req    (wr_req   ),   
    
85.         .rd_req    (rd_req   ),   
    
86.         .bank      (bank     ),   
    
87.         .addr      (addr     ),   
    
88.         .wdata     (wdata    )   
    
89.         );
    
90.    
    
91.     sdram_intf uut_sdram(
    
92.         .clk       (clk_100m ),   
    
93.         .rst_n     (rst_n    ),
    
94.         .wr_req    (wr_req   ),
    
95.         .rd_req    (rd_req   ),
    
96.         .bank      (bank     ),
    
97.         .addr      (addr     ),
    
98.         .wdata     (wdata    ),
    
99.         .dq_in     (dq_in    ),
    
100.         .dq_out    (dq_out   ),
     
101.         .dq_out_en (dq_out_en),
     
102.         .wr_ack    (wr_ack   ),
     
103.         .rd_ack    (rd_ack   ),
     
104.         .rdata     (rdata    ),
     
105.         .rdata_vld (rdata_vld),
     
106.         .cke       (cke      ),
     
107.         .cs        (cs       ),
     
108.         .ras       (ras      ),
     
109.         .cas       (cas      ),
     
110.         .we        (we       ),
     
111.         .dqm       (dqm      ),
     
112.         .sd_addr   (sd_addr  ),
     
113.         .sd_bank   (sd_bank  ),
     
114.         .sd_clk    (sd_clk   )  
     
115.         
     
116.     );
     
117. 
     
118. 
     
119. 
     
120.     endmodule
     

复制代码

1.2 按键检测模块设计

1.2.1接口信号

下面为使用矩阵键盘时的接口信号：

信号	接口方向	定义
clk	输入	系统时钟
rst_n	输入	低电平复位信号
key_col	输入	矩阵键盘列输入信号
Key_row	输出	矩阵键盘行输出信号
Key_en	输出	按键按下位置指示信号

下面是使用普通按键时的接口信号：

信号	接口方向	定义
clk	输入	系统时钟
rst_n	输入	低电平复位信号
Key_in	输入	按键输入信号
Key_vld	输出	按键按下指示信号

1.2.2 设计思路

在前面的按键控制数字时钟的案例中已经有介绍，所以这里不在过多介绍，详细介绍请看下方链接：

http://fpgabbs.com/forum.php?mod=viewthread&tid=310

1.2.3 参考代码

1.    //矩阵键盘

1. always  @(posedge clk or negedge rst_n)begin
   
2.     if(rst_n==1'b0)begin
   
3.         key_col_ff0 <= 4'b1111;
   
4.         key_col_ff1 <= 4'b1111;
   
5.     end
   
6.     else begin
   
7.         key_col_ff0 <= key_col    ;
   
8.         key_col_ff1 <= key_col_ff0;
   
9.     end
   
10. end
    
11. 
    
12. 
    
13. always @(posedge clk or negedge rst_n) begin
    
14.     if (rst_n==0) begin
    
15.         shake_cnt <= 0;
    
16.     end
    
17.     else if(add_shake_cnt) begin
    
18.         if(end_shake_cnt)
    
19.             shake_cnt <= 0;
    
20.         else
    
21.             shake_cnt <= shake_cnt+1 ;
    
22.    end
    
23. end
    
24. assign add_shake_cnt = key_col_ff1!=4'hf;
    
25. assign end_shake_cnt = add_shake_cnt  && shake_cnt == TIME_20MS-1 ;
    
26. 
    
27. 
    
28. always  @(posedge clk or negedge rst_n)begin
    
29.     if(rst_n==1'b0)begin
    
30.         state_c <= CHK_COL;
    
31.     end
    
32.     else begin
    
33.         state_c <= state_n;
    
34.     end
    
35. end
    
36. 
    
37. always  @(*)begin
    
38.     case(state_c)
    
39.         CHK_COL: begin
    
40.                      if(col2row_start )begin
    
41.                          state_n = CHK_ROW;
    
42.                      end
    
43.                      else begin
    
44.                          state_n = CHK_COL;
    
45.                      end
    
46.                  end
    
47.         CHK_ROW: begin
    
48.                      if(row2del_start)begin
    
49.                          state_n = DELAY;
    
50.                      end
    
51.                      else begin
    
52.                          state_n = CHK_ROW;
    
53.                      end
    
54.                  end
    
55.         DELAY :  begin
    
56.                      if(del2wait_start)begin
    
57.                          state_n = WAIT_END;
    
58.                      end
    
59.                      else begin
    
60.                          state_n = DELAY;
    
61.                      end
    
62.                  end
    
63.         WAIT_END: begin
    
64.                      if(wait2col_start)begin
    
65.                          state_n = CHK_COL;
    
66.                      end
    
67.                      else begin
    
68.                          state_n = WAIT_END;
    
69.                      end
    
70.                   end
    
71.        default: state_n = CHK_COL;
    
72.     endcase
    
73. end
    
74. assign col2row_start = state_c==CHK_COL  && end_shake_cnt;
    
75. assign row2del_start = state_c==CHK_ROW  && row_index==3 && end_row_cnt;
    
76. assign del2wait_start= state_c==DELAY    && end_row_cnt;
    
77. assign wait2col_start= state_c==WAIT_END && key_col_ff1==4'hf;
    
78. 
    
79. always  @(posedge clk or negedge rst_n)begin
    
80.     if(rst_n==1'b0)begin
    
81.         key_row <= 4'b0;
    
82.     end
    
83.     else if(state_c==CHK_ROW)begin
    
84.         key_row <= ~(1'b1 << row_index);
    
85.     end
    
86.     else begin
    
87.         key_row <= 4'b0;
    
88.     end
    
89. end
    
90. 
    
91. 
    
92. 
    
93. 普通键盘
    
94. 
    
95. always @(posedge clk or negedge rst_n) begin
    
96.     if (rst_n==0) begin
    
97.         row_index <= 0;
    
98.     end
    
99.     else if(add_row_index) begin
    
100.         if(end_row_index)
     
101.             row_index <= 0;
     
102.         else
     
103.             row_index <= row_index+1 ;
     
104.    end
     
105.    else if(state_c!=CHK_ROW)begin
     
106.        row_index <= 0;
     
107.    end
     
108. end
     
109. assign add_row_index = state_c==CHK_ROW && end_row_cnt;
     
110. assign end_row_index = add_row_index  && row_index == 4-1 ;
     
111. 
     
112. 
     
113. always @(posedge clk or negedge rst_n) begin
     
114.     if (rst_n==0) begin
     
115.         row_cnt <= 0;
     
116.     end
     
117.     else if(add_row_cnt) begin
     
118.         if(end_row_cnt)
     
119.             row_cnt <= 0;
     
120.         else
     
121.             row_cnt <= row_cnt+1 ;
     
122.    end
     
123. end
     
124. assign add_row_cnt = state_c==CHK_ROW || state_c==DELAY;
     
125. assign end_row_cnt = add_row_cnt  && row_cnt == 16-1 ;
     
126. 
     
127. 
     
128. 
     
129. always  @(posedge clk or negedge rst_n)begin
     
130.     if(rst_n==1'b0)begin
     
131.         key_col_get <= 0;
     
132.     end
     
133.     else if(state_c==CHK_COL && end_shake_cnt ) begin
     
134.         if(key_col_ff1==4'b1110)
     
135.             key_col_get <= 0;
     
136.         else if(key_col_ff1==4'b1101)
     
137.             key_col_get <= 1;
     
138.         else if(key_col_ff1==4'b1011)
     
139.             key_col_get <= 2;
     
140.         else
     
141.             key_col_get <= 3;
     
142.     end
     
143. end
     
144. 
     
145. 
     
146. always  @(posedge clk or negedge rst_n)begin
     
147.     if(rst_n==1'b0)begin
     
148.         key_out <= 0;
     
149.     end
     
150.     else if(state_c==CHK_ROW && end_row_cnt)begin
     
151.         key_out <= {row_index,key_col_get};
     
152.     end
     
153.     else begin
     
154.         key_out <= 0;
     
155.     end
     
156. end
     
157. 
     
158. always  @(posedge clk or negedge rst_n)begin
     
159.     if(rst_n==1'b0)begin
     
160.         key_vld <= 1'b0;
     
161.     end
     
162.     else if(state_c==CHK_ROW && end_row_cnt && key_col_ff1[key_col_get]==1'b0)begin
     
163.         key_vld <= 1'b1;
     
164.     end
     
165.     else begin
     
166.         key_vld <= 1'b0;
     
167.     end
     
168. end
     
169. 
     
170. 
     
171. always  @(*)begin
     
172.     if(rst_n==1'b0)begin
     
173.         key_en = 0;
     
174.     end
     
175.     else if(key_vld && key_out==0)begin
     
176.         key_en = 4'b0001;
     
177.     end
     
178.     else if(key_vld && key_out==1)begin
     
179.         key_en = 4'b0010;
     
180.     end
     
181.     else if(key_vld && key_out==2)begin
     
182.         key_en = 4'b0100;
     
183.     end
     
184.     else begin
     
185.         key_en = 0;
     
186.     end
     
187. end
     
188. 
     
189. 
     
190. endmodule
     

复制代码

1.3 锁相环

1.3.1 接口信号

信号名	I/O	位宽	定义
Inclk0	I	1	输入时钟50M
C0	O	1	输出时钟100M

1.3.2 设计思路

此模块是使用Quartus生成的PLL IP核，相关的生成步骤、功能原理等可以看明德扬论坛中关于PLL的介绍。

IP核设计（PLL）

1.4 数据产生模块设计

1.4.1接口信号

信号名	I/O	位宽	定义
clk	I	1	工作时钟 100M
rst_n	I	1	系统复位信号，低电平有效
Key_vld	I	4	按键有效指示信号
Wr_ack	I	1	写数据响应
rd_ack	I	1	读数据响应
Wr_req	O	1	写数据请求
rd_req	O	1	读数据响应
bank	O	2	Bank地址选择信号
addr	O	13	SDRAM地址信号
Wdata	O	16	SDRAM写数据

1.4.2设计思路

该模块主要实现的功能是根据按键，产生读请求、写请求、Bank地址、写数据和SDRAM地址。下面是该模块主要信号的设计思路：

写请求wr_req：初始状态为低电平，表示没有往SDRAM里面写数据的请求；当按下按键key1的时候，写请求变为高电平，表示请求往SDRAM内部写入数据，因此写请求拉高的条件为key_vld[0]==1；当接收到接收到写响应为高电平的时候，表示同意往SDRAM写入数据，此时将写请求置为低电平，因此写请求的拉低条件为wr_ack==1。

读请求rd_req：初始状态为低电平，表示没有读出SDRAM中数据的请求；当按下按键key2的时候，读请求变为高电平，表示请求读出SDRAM内部数据，因此读请求拉高的条件为key_vld[1]==1；当接收到接收到读响应为高电平的时候，表示SDRAM同意读出数据，此时将读请求置为低电平，因此读请求的拉低条件为rd_ack==1。

读写Bank地址信号bank：初始状态为0，表示默认选择Bank0进行数据的读写操作；加一条件为key_vld[2]==1，表示按键key3每按下一次，Bank地址就加一；结束条件为数4个，因为一片SDRAM共有4个Bank，数完就清零。

SDRAM地址信号addr：固定为0即可。

写数据wdata：该信号表示要写入SDRAM中的数据，在接收到写响应后有效。设置时钟计数器cnt2，在收到写响应之后开始计数，由于本工程使用SDRAM全页突发模式一次写数据为512个，因此该计数器结束条件为数512个，将该计数器的值作为写数据。

1.4.3参考代码

1. always  @(posedge clk or negedge rst_n)begin
   
2.     if(rst_n==1'b0)begin
   
3.         wr_req <= 0;
   
4.     end
   
5.     else if(key_vld[0]==1)begin
   
6.         wr_req <= 1;
   
7.     end
   
8.     else if(wr_ack)begin
   
9.         wr_req <= 0;
   
10.     end
    
11. end
    
12. 
    
13. 
    
14. always  @(posedge clk or negedge rst_n)begin
    
15.     if(rst_n==1'b0)begin
    
16.         rd_req <= 0;
    
17.     end
    
18.     else if(key_vld[1]==1)begin
    
19.         rd_req <= 1;
    
20.     end
    
21.     else if(rd_ack)begin
    
22.         rd_req <= 0;
    
23.     end
    
24. end
    
25. 
    
26. 
    
27. always @(posedge clk or negedge rst_n) begin
    
28.     if (rst_n==0) begin
    
29.         bank <= 0;
    
30.     end
    
31.     else if(add_bank) begin
    
32.         if(end_bank)
    
33.             bank <= 0;
    
34.         else
    
35.             bank <= bank+1 ;
    
36.    end
    
37. end
    
38. assign add_bank = key_vld[2]==1;
    
39. assign end_bank = add_bank  && bank == 4-1 ;
    
40. 
    
41. 
    
42. always  @(*)begin
    
43.     if(flag_wr)begin
    
44.         wdata = {7'b0,cnt2};
    
45.     end
    
46.     else begin
    
47.         wdata = 0;
    
48.     end
    
49. end
    
50. 
    
51. 
    
52. always  @(posedge clk or negedge rst_n)begin
    
53.     if(rst_n==1'b0)begin
    
54.         flag_wr <= 0;
    
55.     end
    
56.     else if(wr_ack)begin
    
57.         flag_wr <= 1;
    
58.     end
    
59.     else if(end_cnt2)begin
    
60.         flag_wr <= 0;
    
61.     end
    
62. end
    
63. 
    
64. 
    
65. always @(posedge clk or negedge rst_n) begin
    
66.     if (rst_n==0) begin
    
67.         cnt2 <= 0;
    
68.     end
    
69.     else if(add_cnt2) begin
    
70.         if(end_cnt2)
    
71.             cnt2 <= 0;
    
72.         else
    
73.             cnt2 <= cnt2+1 ;
    
74.    end
    
75. end
    
76. assign add_cnt2 = flag_wr;
    
77. assign end_cnt2 = add_cnt2  && cnt2 == 512-1 ;
    
78. 
    
79. assign addr = 13'b0;
    
80. 
    
81. 
    
82. endmodule
    

复制代码

1.5 SDRAM接口模块设计

1.5.1接口信号

信号名	I/O	位宽	定义
clk	I	1	1工作时钟  100M
rst_n	I	1	系统复位信号，低电平有效
Wr_req	I	1	写请求
rd_req	I	1	读请求
bank	I	2	输入bank地址
addr	I	13	地址信号
Wdata	I	16	写数据
dq_in	I	16	SDRAM数据输入
dq_out	O	16	写SDRAM数据信号
dq_out_en	O	1	三态门使能
Wr_ack	O	1	写响应
rd_ack	O	1	读响应
rdata	O	16	读数据
rdata_vld	O	1	读数据有效指示信号
Cke	O	1	SDRAM时钟使能信号，决定是否启用clk输入，为高电平时，时钟有效。
Cs	O	1	SDRAM片选信号，决定设备内是否启用命令输入，当cs为低时启用，当cs为高时禁用命令输入。
ras	O	1	行地址选通信号，低电平有效
Cas	O	1	列地址选通信号，低电平有效
We	O	1	写使能信号，低电平有效
dqm	O	2	数据掩码，控制I/O的高低字节，低电平有效。例如：2’b10，表示数据高字节无效，低字节有效。
Sd_addr	O	13	SDRAM地址信号。
Sd_bank	O	2	Bank地址选择信号，通过该信号决定哪个Bank正处于激活、读、写、预充电等命令期间。
Sd_clk	O	1	SDRAM输入时钟，除cke外，SDRAM的所有输入与该引脚的上升沿同步获得。

1.5.2SDRAM工作流程


SDRAM初始化

再SDRAM内部有一个逻辑控制单元，并且有一个模式寄存器为其提供控制参数。每次开机时SDRAM都要先对这个控制逻辑核心进行初始化。SDRAM必须以预定义的方式启动和初始化。在电源同时作用于Vdd和Vddq后开始初始化SDRAM，此时的时钟稳定并且将数据掩码和时钟使能信号拉高。在向SDRAM发送命令之前需要有100us的延时，此时SDRAM不执行任何操作。在100us延时满足后，需要对Bank进行预充电，在此期间所有的Bank处于空闲状态。预充电之后会有至少两个自刷新操作，完成自刷新便可以对SDRAM进行模式寄存器配置。下面是初始化的时序图

从上图中可以看出，上电后等待时间为T=100us，预充电操作需要的时间为TRP，一次自刷新需要的时间是TRC，加载模式寄存器需要的时间为TMRD。

在初始化中的预充电期间，地址线A10定义自动预充电，以确定是否所有Bank都被预充电，也可以通过Bank地址选择信号BA0和BA1来决定进行预充电的Bank地址。在加载模式寄存器期间，地址线A0到A11一起组成命令码。

SDRAM行激活

初始化完成之后，在向SDRAM发送读或者写命令之前必须打开该Bank中的一行，通过ACTIVE命令来确定要激活的Bank和行。要想对一个Bank中的阵列进行寻址，首先要确定行（Row），然后确定列。片选信号与Bank选择信号与行有效同时进行，下面是激活的时序图

从上图中可以看出，在片选信号、Bank地址选定的同时，行地址选通信号RAS也处于有效状态，此时An地址线发送具体的行地址。行地址位宽为12，共可以指示2^12=4096个具体的行地址。当行地址被激活后，相应的Bank也被激活，因此行激活又叫L-Bank激活。

列选择

行地址确定后，就要对列地址进行寻址，地址线仍使用A0~A11，即行地址与列地址共用地址线。当列地址选通后，就需要对SDRAM进行读写，而给SDRAM读命令还是写命令由WE信号决定。当WE信号拉低时，SDRAM接收到的是写命令；当WE拉高，SDRAM接收读命令。列寻址信号与读写命令是同时发出的。虽然地址线与行寻址共用，但列地址选通脉冲CAS则可以区分开行与列寻址的不同，配合A0~A9、A11来确定具体的地址。

在发送列读写命令时必须要与有效命令有一个时间间隔，这个时间间隔被定义为TRCD。

读操作

读命令从输入信号BA0、BA1中选取要进行读数据操作的BANK，并在已激活的行中进行突发读写操作。输入的A0~A7用来进行列寻址。在选定列地址后，就已经确定了具体的存储单元，剩下的事情就是数据通过dq输出到内存总线上了。但是再CAS发出之后，仍要经过一定的时间才能有数据输出，从CAS与读取命令发出到第一个数据输出的这段时间，被定义为CALLatency（CAS潜伏期）。由于此现象只在读的时候出现，所以又称作读潜伏期

由于存储体中晶体管存在反应时间，从而造成数据不可能与CAS 在同一上升沿触发，因此要延后至少一个时钟周期。考虑到芯片体积较小的因素，存储单元中的电容容量很小，所以信号要经过放大来保证其有效的识别性，这个放大/驱动工作由 S-AMP 负责，一个存储体对应一个 S-AMP 通道。但它要有一个准备时间才能保证信号的发送强度（事前还要进行电压比较以进行逻辑电平的判断），因此从数据 I/O 总线上有数据输出之前的一个时钟上升沿开始，数据即已传向 S-AMP，也就是说此时数据已经被触发，经过一定的驱动时间最终传向数据 I/O 总线进行输出，这段时间我们称之为 tAC（Access-Time-from-CLK，时钟触发后的访问时间），单位是 ns。在突发读操作完成后，如果选择了自动预充电模式，那么该行就会直接进入充电。如果没有选择此模式，那么该行将保持打开状态，供后续访问。自动预充电模式的选择与 A10的值有关，A10 为高时为自动预充电命令模式。

写操作

数据写入的操作也是在 tRCD 之后进行，但此时没有 CL（CL 只出现在读取操作中），行寻址与列寻址的时序一样致，只是在列寻址时，WE#为有效状态。由于数据信号由控制端发出，输入时芯片无需做任何调校，只需直接传到数据输入寄存器中，然后再由写入驱动器进行对存储电容的充电操作，因此数据可以与 CAS 同时发送，也就是说写入延迟为 0。不过，数据并不是即时地写入存储电容，因为选通三极管（就如读取时一样）与电容的充电必须要有一段时间，所以数据的真正写入需要一定的周期。

突发读写

突发（Burst）是指在同一行中相邻的存储单元连续进行数据传输的方式，连续传输所涉及到存储单元（列）的数量就是突发长度（Burst Lengths，简称 BL）。前文讲到的读/写操作，都是一次对一个存储单元进行寻址，如果想要连续的向 SDRAM 中读数据或者写数据，就需要对当前存储单元的下一个单元进行寻址，也即是需要不停给 SDRAM 列激活信号以及读/写命令（行地址不变，所以不用再对行寻址）。虽然由于读/写延迟相同可以让数据的传输在 I/O 端是连续的，但它占用了大量的内存控制资源，在数据进行连续传输时无法输入新的命令，效率很低。为此，人们开发了突发传输技术，只要指定起始列地址与突发长度，SDRAM 就会不再需要控制器连续地提供列地址，依次地自动对后面相应数量的存储单元进行读/写操作。这样，在突发模式读写中，除了第一个数据的传输需要若干个周期（主要是之前的延迟，一般的是tRCD+CL），其后每个数据只需一个周期的即可获得。至于突发长度 BL 的数值，也是不能随便设或在数据进行传输前临时决定，而是在上文讲到的 SDRAM 初始化过程中模式寄存器配置阶段就要对突发长度进行设置。目前可用的选项是 1、2、4、8、全页（FullPage），常见的突发长度设定是 BL=4、BL=8 或者全页突发模式。

1.5.3设计思路

经过上面对SDRAM工作流程的介绍，可以采用状态机作为本工程的一个架构，根据指令的不同，划分为8个状态，分别为空操作（NOP）、预充电（PER）、自刷新（REF）、加载模式寄存器（MOD）、空闲（IDL）、激活（ACT）、读数据（RED）和写数据（WIR）。

由于每个操作需要的时间都不同，因此需要一个计数器来对每个操作需要的时间进行计数。

该计数器加一条件为state_c!=IDL，表示只要不是处于空闲状态，就进行计数；结束条件为数x个，x根据目前所处的状态的不同而不同，具体数据可以看下面的表格。

当前状态	计数器数多少个
空操作（NOP）	20000
预充电（PER）	2
自刷新（REF）	7
加载模式寄存器（MOD）	2
激活（ACT）	2
读/写数据（RED/WIR）	512

由于再初始化阶段，自刷新需要连续进行两次，因此需要将初始化阶段区分出来，设计一个初始化指示信号init_flag：该信号初始状态为高电平，表示上电之后SDRAM处于初始化阶段；当初始化完成之后变为低电平，因此从高变低的条件为mod2idl_start。

自刷新计数器cnt1：该计数器表示初始化阶段进行自刷新的次数。加一条件为(init_flag && state_c==REF && end__cnt)，表示在初始化阶段，如果当前状态为自刷新，则时钟计数器数完一次就加一；结束条件为数两个，初始化阶段共进行两次自刷新，因此只需要数两个即可。

在初始化完成之后，需要进行自刷新、读数据和写数据等操作，由于自刷新是必须进行的，因此自刷新请求的优先级是最高的，那么读请求和写请求的优先级怎么确定呢？假设设置读请求的优先级高于写请求，读请求和写请求一起来的时候，总是先执行读请求，如果读请求一直有效的话，便不会执行写操作。反之设置写请求的优先级高于读请求，也会出现这样的问题，这当然是不可以的。因此我们设置为如果两个请求不是同时有效，则哪一个有效便执行哪一个。如果同时来的时候，第一次同时来，先执行写操作，第二次同时有效的时候在执行写操作，如此交替进行即可。通过两个信号进行控制：

读操作指示信号flag_rd：初始状态为低电平，表示上一次执行的写操作；从低变高的条件为state_c==RED，表示如果执行的是读操作，则置为高电平；当执行的是写操作的时候，该信号置为0，所以变0的条件是state_c==WIR。

读写同步指示信号flag_syn：初始状态为0，表示读写请求没有同时有效，如果当前处于激活状态，并且读写请求同时有效，则置为1，当激活状态结束，重新变为0。

设计中的辅助信号已经完成的差不多了，下面开始进行状态机的架构，架构图如下图所示：

下面介绍一个各个状态之间的跳转条件。

上电之后，先进入空操作状态，在空操作状态下：

1、  延时100us之后，进入到预充电状态。

当处于预充电状态的时候：

1、  如果处于初始化阶段，两个时钟周期之后，跳转到自刷新状态。

2、  如果不是初始化阶段，两个时钟周期之后，跳转到空闲状态。

当处于自刷新状态时：

1、  如果处于初始化状态，7个时钟周期之后，跳转到自刷新状态。

2、  如果处于初始化状态，并且已经进行过一次初始化，7个时钟周期之后，跳转到加载模式寄存器状态。

3、  如果不是初始化阶段，7个时钟周期之后，跳转到空闲状态。

当处于加载模式寄存器状态时：

1、  2个时钟周期之后，进入到空闲状态。

当处于空闲状态时：

1、  如果收到自刷新请求，则跳转到自刷新状态。

2、  如果自刷新请求无效，收到读/写请求，则跳转到激活状态。

当处于处于激活状态时：

1、  当读写请求不同时的时候，接收到读请求，则跳转到读状态。

2、  当读写请求不同时的时候，接收到写请求，则跳转到写状态

3、  当读写请求同时到达的时候，第一次来的时候，首先响应读请求，跳转到读状态

4、  当读写请求同时到达，但不是第一次同时有效的时候，则根据上一次执行的操作进行判断，如果上一次执行的读操作，则这次执行写操作，跳转到写状态；如果上一次执行的写操作，则这次执行读操作，跳转到读状态。

当处于写状态的时候：

1、  写数据完成，就进入到预充电状态。

当处于读状态的时候：

1、  读数据完成，就进入到预充电状态。

指令集信号conmand：该信号共4bit，从最高位到最低位分别表示cs、ras、cas、we。在空操作阶段，指令为4’b0111；在预充电阶段，指令为4’b0010；在自刷新阶段，指令为4’b0001；在加载模式寄存器阶段，指令为4’b0000；在激活阶段，指令为4’b0011；在读数据阶段，指令为4’b0101；在写数据阶段，指令为4’b0100。这些操作对应的指令码都是从图中的表格中查找得来。

数据掩码dqm：初始状态为2’b11，表示输入得两个字节数据无效。当初始化完成之后，变为2’b00，表示输入得两个字节数据有效。

时钟使能cke：复位时为0，表示输入时钟无效，复位结束之后为1，表示输入时钟有效。

Bank选择信号sd_bank：初始状态为2’b00，表示选择Bank0；在激活阶段、读阶段和写阶段，该信号由输入得bank信号决定。

SDRAM地址选择信号sd_addr：由于本工程采用的预充电模式为全Bnak自动预充电，该模式由地址线A10控制，因此在预充电得时候，地址指令为13’b001_0_00_000_0_000；在激活的时候提供行地址；在加载模式寄存器得时候，地址线提供运算码，这时每个地址表示得意思入下图所示，A9决定读模式，A6、A5、A4决定读数据得潜伏期，A3决定突发类型，A2、A1、A0决定突发长度。

由于MP801开发板使用得SDRAM有两种型号，一种是W9812G6KH，共4096行，自刷新周期为1562，另一种是H57V2562GTR，共8192行，自刷新周期为780。在使用得时候需要注意开发板型号，这里我们以H57V2562GTR为例。自刷新需要以下信号：

时钟计数器cnt_780：该计数器主要得作用是初始化结束之后，数自刷新得周期；加一条件为init_flag==0，表示初始化结束就开始计数；结束条件为数780个，数完就清零。

自刷新请求ref_req：初始状态为0，表示不需要进行自刷新，当时钟计数器cnt_780数完得时候，ref_req拉高，请求进行自刷新，如果当前处于空闲状态，则进行自刷新，如果不是，则等待。

可能有人会想，如果不是空闲状态，就要等待，这样会不会对数据保存造成影响？其实不会得，存储器要求64ms全部刷新一遍，但不需要每一行刷新得间隔都一样。当时钟计数器cnt_780数完之后，产生自刷新请求，同时时钟计数器又会开始计数，所以可能自刷新得间隔不同，但每一行肯定能在64ms内刷新1次。

写SDRAM数据信号dq_out：该信号直接等于写数据wdata（注意，需要用组合逻辑实现）。

三态门使能信号dq_out_en：初始状态为0，表示使能无效，在写数据期间，变为高电平，表示使能有效。

读SDRAM数据信号rdata：直接将sdram输出数据dq_in连接即可。

读数据有效指示信号rdata_vld：由于存在读数据潜伏期，根据设置得潜伏期得长度，将rdata_vld进行相应得延时。

1.5.4参考代码

1.     parameter NOP       = 4'b0000 ;
   
2.     parameter PER       = 4'b0001 ;
   
3.     parameter REF       = 4'b0010 ;
   
4.     parameter MOD       = 4'b0100 ;
   
5.     parameter IDL       = 4'b1000 ;
   
6.     parameter ACT       = 4'b0011 ;
   
7.     parameter RED       = 4'b0110 ;
   
8.     parameter WIR       = 4'b1100 ;
   
9.    
   
10.     parameter NOP_CMD   = 4'b0111 ;
    
11.     parameter PER_CMD   = 4'b0010 ;
    
12.     parameter REF_CMD   = 4'b0001 ;
    
13.     parameter MOD_CMD   = 4'b0000 ;
    
14.     parameter ACT_CMD   = 4'b0011 ;
    
15.     parameter RED_CMD   = 4'b0101 ;
    
16.     parameter WIR_CMD   = 4'b0100 ;
    
17.    
    
18.     parameter ALL_BANK  = 13'b001_0_00_000_0_000;
    
19.     parameter CODE      = 13'b000_0_00_010_0_111;
    
20.    
    
21.     parameter TIME_780  = 780     ;      
    
22.     parameter TIME_WAIT = 10000   ;   
    
23.     parameter TIME_TRP  = 2       ;
    
24.     parameter TIME_TRC  = 7       ;
    
25.     parameter TIME_TMRD = 2       ;
    
26.     parameter TIME_TRCD = 2       ;
    
27.     parameter TIME_512  = 512     ;
    
28. 
    
29.     input            clk          ;
    
30.     input            rst_n        ;
    
31.     input            wr_req       ;
    
32.     input            rd_req       ;
    
33.     input  [1 :0]    bank         ;
    
34.     input  [12:0]    addr         ;
    
35.     input  [15:0]    wdata        ;
    
36.     input  [15:0]    dq_in        ;
    
37. 
    
38. 
    
39.     output [15:0]    dq_out       ;
    
40.     output           dq_out_en    ;
    
41.     output           wr_ack       ;
    
42.     output           rd_ack       ;
    
43.     output [15:0]    rdata        ;
    
44.     output           rdata_vld    ;
    
45.     output           cke          ;
    
46.     output           cs           ;
    
47.     output           ras          ;
    
48.     output           cas          ;
    
49.     output           we           ;
    
50.     output [1 :0]    dqm          ;
    
51.     output [12:0]    sd_addr      ;
    
52.     output [1 :0]    sd_bank      ;
    
53.     output           sd_clk       ;
    
54. 
    
55.     reg    [15:0]    dq_out       ;
    
56.     reg              dq_out_en    ;
    
57.     reg              flag_syn     ;
    
58.     wire             wr_ack       ;
    
59.     wire             rd_ack       ;
    
60.     reg    [15:0]    rdata        ;
    
61.     reg              rdata_vld    ;
    
62.     reg              cke          ;
    
63.     wire             cs           ;
    
64.     wire             ras          ;
    
65.     wire             cas          ;
    
66.     wire             we           ;
    
67.     reg    [1 :0]    dqm          ;
    
68.     reg    [12:0]    sd_addr      ;
    
69.     reg    [1 :0]    sd_bank      ;
    
70.     wire             sd_clk       ;
    
71. 
    
72. 
    
73.     reg    [3:0]     state_c      ;
    
74.     reg    [3:0]     state_n      ;
    
75.     wire             nop2per_start;
    
76.     wire             per2ref_start;
    
77.     wire             per2idl_start;
    
78.     wire             ref2ref_start;
    
79.     wire             ref2mod_start;
    
80.     wire             ref2idl_start;
    
81.     wire             mod2idl_start;
    
82.     wire             idl2ref_start;
    
83.     wire             idl2act_start;
    
84.     wire             act2red_start;
    
85.     wire             act2wir_start;
    
86.     wire             red2per_start;
    
87.     wire             wir2per_start;
    
88.     reg    [3:0]     conmand      ;
    
89.     reg    [13:0]    cnt          ;
    
90.     wire             add_cnt      ;
    
91.     wire             end_cnt      ;
    
92.     reg    [1:0]     cnt1         ;
    
93.     wire             add_cnt1     ;
    
94.     wire             end_cnt1     ;
    
95.     reg    [9:0]     cnt_780      ;
    
96.     wire             add_cnt_780  ;
    
97.     wire             end_cnt_780  ;
    
98.     reg    [13:0]    x            ;
    
99.     reg              init_flag    ;
    
100.     reg              ref_req      ;
     
101.     wire             ref_ack      ;
     
102.     reg              flag_rd      ;
     
103.     wire             rd_en        ;
     
104.     reg              rdata_vld_ff0;
     
105.     reg              rdata_vld_ff1;
     
106.     reg              rdata_vld_ff2;
     
107. 
     
108. 
     
109. always  @(posedge clk or negedge rst_n)begin
     
110.     if(rst_n==1'b0)begin
     
111.         state_c <= NOP;
     
112.     end
     
113.     else begin
     
114.         state_c <= state_n;
     
115.     end
     
116. end
     
117. 
     
118. always @(*)begin
     
119.     case(state_c)
     
120.         NOP:begin
     
121.             if(nop2per_start)begin
     
122.                 state_n = PER;
     
123.             end
     
124.             else begin
     
125.                 state_n = state_c;
     
126.             end
     
127.         end
     
128.         PER:begin
     
129.             if(per2ref_start)begin
     
130.                 state_n = REF;
     
131.             end
     
132.             else if(per2idl_start)begin
     
133.                 state_n = IDL;
     
134.             end
     
135.             else begin
     
136.                 state_n = state_c;
     
137.             end
     
138.         end
     
139.         REF:begin
     
140.             if(ref2ref_start)begin
     
141.                 state_n = REF;
     
142.             end
     
143.             else if(ref2mod_start)begin
     
144.                 state_n = MOD;
     
145.             end
     
146.             else if(ref2idl_start)begin
     
147.                 state_n = IDL;
     
148.             end
     
149.             else begin
     
150.                 state_n = state_c;
     
151.             end
     
152.         end
     
153.         MOD:begin
     
154.             if(mod2idl_start)begin
     
155.                 state_n = IDL;
     
156.             end
     
157.             else begin
     
158.                 state_n = state_c;
     
159.             end
     
160.         end
     
161.         IDL:begin
     
162.             if(idl2ref_start)begin
     
163.                 state_n = REF;
     
164.             end
     
165.             else if(idl2act_start)begin
     
166.                 state_n = ACT;
     
167.             end
     
168.             else begin
     
169.                 state_n = state_c;
     
170.             end
     
171.         end
     
172.         ACT:begin
     
173.             if(act2red_start)begin
     
174.                 state_n = RED;
     
175.             end
     
176.             else if(act2wir_start)begin
     
177.                 state_n = WIR;
     
178.             end
     
179.             else begin
     
180.                 state_n = state_c;
     
181.             end
     
182.         end
     
183.         RED:begin
     
184.             if(red2per_start)begin
     
185.                 state_n = PER;
     
186.             end
     
187.             else begin
     
188.                 state_n = state_c;
     
189.             end
     
190.         end
     
191.         WIR:begin
     
192.             if(wir2per_start)begin
     
193.                 state_n = PER;
     
194.             end
     
195.             else begin
     
196.                 state_n = state_c;
     
197.             end
     
198.         end
     
199.         default:begin
     
200.             state_n = IDL;
     
201.         end
     
202.     endcase
     
203. end
     
204. 
     
205. 
     
206. assign nop2per_start = state_c==NOP && end_cnt;
     
207. assign per2ref_start = state_c==PER && init_flag==1 && end_cnt;
     
208. assign per2idl_start = state_c==PER && init_flag==0 && end_cnt;
     
209. assign ref2ref_start = state_c==REF && init_flag==1 && cnt1==0 && end_cnt;
     
210. assign ref2mod_start = state_c==REF && init_flag==1 && end_cnt1;
     
211. assign ref2idl_start = state_c==REF && init_flag==0 && end_cnt;
     
212. assign mod2idl_start = state_c==MOD && end_cnt;
     
213. assign idl2ref_start = state_c==IDL && ref_req;
     
214. assign idl2act_start = state_c==IDL && ref_req==0 && (wr_req || rd_req);
     
215. assign act2red_start = state_c==ACT && ((flag_syn==1 && flag_rd==0) || (flag_syn==0 && rd_req)) && end_cnt;
     
216. assign act2wir_start = state_c==ACT && ((flag_syn==1 && flag_rd==1) || (flag_syn==0 && wr_req)) && end_cnt;
     
217. assign red2per_start = state_c==RED && end_cnt;
     
218. assign wir2per_start = state_c==WIR && end_cnt;
     
219. 
     
220. always @(posedge clk or negedge rst_n)begin
     
221.     if(!rst_n)begin
     
222.         cnt <= 0;
     
223.     end  
     
224.     else if(add_cnt)begin
     
225.         if(end_cnt)
     
226.             cnt <= 0;
     
227.         else
     
228.             cnt <= cnt + 1;
     
229.     end
     
230. end
     
231. 
     
232. assign add_cnt = state_c!=IDL;      
     
233. assign end_cnt = add_cnt && cnt== x-1;   
     
234. 
     
235. 
     
236. always  @(posedge clk or negedge rst_n)begin
     
237.     if(rst_n==1'b0)begin
     
238.         init_flag <= 1;
     
239.     end
     
240.     else if(mod2idl_start)begin
     
241.         init_flag <= 0;
     
242.     end
     
243. end
     
244. 
     
245. 
     
246. always @(posedge clk or negedge rst_n) begin
     
247.     if (rst_n==0) begin
     
248.         cnt1 <= 0;
     
249.     end
     
250.     else if(add_cnt1) begin
     
251.         if(end_cnt1)
     
252.             cnt1 <= 0;
     
253.         else
     
254.             cnt1 <= cnt1+1 ;
     
255.    end
     
256. end
     
257. assign add_cnt1 = init_flag && state_c==REF && end_cnt;
     
258. assign end_cnt1 = add_cnt1  && cnt1 == 2-1 ;
     
259. 
     
260. 
     
261. always  @(posedge clk or negedge rst_n)begin
     
262.     if(rst_n==1'b0)begin
     
263.         flag_rd <= 0;
     
264.     end
     
265.     else if(state_c==RED)begin
     
266.         flag_rd <= 1;
     
267.     end
     
268.     else if(state_c==WIR)begin
     
269.         flag_rd <= 0;
     
270.     end
     
271. end
     
272. 
     
273. 
     
274. always  @(posedge clk or negedge rst_n)begin
     
275.     if(rst_n==1'b0)begin
     
276.         flag_syn <= 0;
     
277.     end
     
278.     else if(state_c==ACT && wr_req && rd_req)begin
     
279.         flag_syn <= 1;
     
280.     end
     
281.     else if(end_cnt)begin
     
282.         flag_syn <= 0;
     
283.     end
     
284. end
     
285. 
     
286. assign rd_ack = act2red_start;
     
287. assign wr_ack = act2wir_start;
     
288. 
     
289. always  @(posedge clk or negedge rst_n)begin
     
290.     if(rst_n==1'b0)begin
     
291.         conmand <= NOP_CMD;
     
292.     end
     
293.     else if(nop2per_start || red2per_start || wir2per_start)begin
     
294.         conmand <= PER_CMD;
     
295.     end
     
296.     else if(per2ref_start || ref2ref_start || idl2ref_start)begin
     
297.         conmand <= REF_CMD;
     
298.     end
     
299.     else if(ref2mod_start)begin
     
300.         conmand <= MOD_CMD;
     
301.     end
     
302.     else if(idl2act_start)begin
     
303.         conmand <= ACT_CMD;
     
304.     end
     
305.     else if(act2red_start)begin
     
306.         conmand <= RED_CMD;
     
307.     end
     
308.     else if(act2wir_start)begin
     
309.         conmand <= WIR_CMD;
     
310.     end
     
311.     else begin
     
312.         conmand <= NOP_CMD;
     
313.     end
     
314. end
     
315. 
     
316. assign {cs,ras,cas,we} = conmand;
     
317. assign sd_clk = ~clk;
     
318. 
     
319. always  @(posedge clk or negedge rst_n)begin
     
320.     if(rst_n==1'b0)begin
     
321.         dqm <= 2'b11;
     
322.     end
     
323.     else if(mod2idl_start)begin
     
324.         dqm <= 2'b00;
     
325.     end
     
326. end
     
327. 
     
328. 
     
329. always  @(posedge clk or negedge rst_n)begin
     
330.     if(rst_n==1'b0)begin
     
331.         cke <= 0;
     
332.     end
     
333.     else begin
     
334.         cke <= 1;
     
335.     end
     
336. end
     
337. 
     
338. 
     
339. always  @(posedge clk or negedge rst_n)begin
     
340.     if(rst_n==1'b0)begin
     
341.         sd_addr <= 13'b0;
     
342.     end
     
343.     else if(nop2per_start || red2per_start || wir2per_start)begin
     
344.         sd_addr <= ALL_BANK;
     
345.     end
     
346.     else if(ref2mod_start)begin
     
347.         sd_addr <= CODE;
     
348.     end
     
349.     else if(idl2act_start)begin
     
350.         sd_addr <= addr;
     
351.     end
     
352.     else begin
     
353.         sd_addr <= 13'b0;
     
354.     end
     
355. end
     
356. 
     
357. 
     
358. always  @(posedge clk or negedge rst_n)begin
     
359.     if(rst_n==1'b0)begin
     
360.         sd_bank <= 2'b00;
     
361.     end
     
362.     else if(idl2act_start || act2wir_start || act2red_start)begin
     
363.         sd_bank <= bank;
     
364.     end
     
365.     else begin
     
366.         sd_bank <= 0;
     
367.     end
     
368. end
     
369. 
     
370. 
     
371. always  @(*)begin
     
372.     if(state_c==NOP)begin
     
373.         x = TIME_WAIT;
     
374.     end
     
375.     else if(state_c==PER)begin
     
376.         x = TIME_TRP;
     
377.     end
     
378.     else if(state_c==REF)begin
     
379.         x = TIME_TRC;
     
380.     end
     
381.     else if(state_c==MOD)begin
     
382.         x = TIME_TMRD;
     
383.     end
     
384.     else if(state_c==ACT)begin
     
385.         x = TIME_TRCD;
     
386.     end
     
387.     else begin
     
388.         x = TIME_512;
     
389.     end
     
390. end
     
391. 
     
392. 
     
393. always @(posedge clk or negedge rst_n) begin
     
394.     if (rst_n==0) begin
     
395.         cnt_780 <= 0;
     
396.     end
     
397.     else if(add_cnt_780) begin
     
398.         if(end_cnt_780)
     
399.             cnt_780 <= 0;
     
400.         else
     
401.             cnt_780 <= cnt_780+1 ;
     
402.    end
     
403. end
     
404. assign add_cnt_780 = init_flag==0;
     
405. assign end_cnt_780 = add_cnt_780  && cnt_780 == TIME_780-1 ;
     
406. 
     
407. 
     
408. always  @(posedge clk or negedge rst_n)begin
     
409.     if(rst_n==1'b0)begin
     
410.         ref_req <= 0;
     
411.     end
     
412.     else if(end_cnt_780)begin
     
413.         ref_req <= 1;
     
414.     end
     
415.     else if(ref_ack)begin
     
416.         ref_req <= 0;
     
417.     end
     
418. end
     
419. 
     
420. 
     
421. assign ref_ack = state_c==IDL && ref_req;
     
422. assign wr_ack  = act2wir_start;
     
423. assign rd_ack  = act2red_start;
     
424. 
     
425. 
     
426. always  @(*)begin
     
427.         dq_out <= wdata;
     
428. end
     
429. 
     
430. 
     
431. always  @(posedge clk or negedge rst_n)begin
     
432.     if(rst_n==1'b0)begin
     
433.         dq_out_en <= 1'b0;
     
434.     end
     
435.     else if(act2wir_start)begin
     
436.         dq_out_en <= 1'b1;
     
437.     end
     
438.     else if(end_cnt)begin
     
439.         dq_out_en <= 1'b0;
     
440.     end
     
441. end
     
442. 
     
443. 
     
444. always  @(posedge clk or negedge rst_n)begin
     
445.     if(rst_n==1'b0)begin
     
446.         rdata <= 16'b0;
     
447.     end
     
448.     else begin
     
449.         rdata <= dq_in;
     
450.     end
     
451. end
     
452. 
     
453. 
     
454. always  @(posedge clk or negedge rst_n)begin
     
455.     if(rst_n==1'b0)begin
     
456.         rdata_vld_ff0 <= 0;
     
457.     end
     
458.     else if(act2red_start)begin
     
459.         rdata_vld_ff0 <= 1;
     
460.     end
     
461.     else if(end_cnt)begin
     
462.         rdata_vld_ff0 <= 0;
     
463.     end
     
464. end
     
465. 
     
466. 
     
467. always  @(posedge clk or negedge rst_n)begin
     
468.     if(rst_n==1'b0)begin
     
469.         rdata_vld     <= 0;
     
470.         rdata_vld_ff1 <= 0;
     
471.         rdata_vld_ff2 <= 0;
     
472.     end
     
473.     else begin
     
474.         rdata_vld_ff1 <= rdata_vld_ff0;
     
475.         rdata_vld_ff2 <= rdata_vld_ff1;
     
476.         rdata_vld     <= rdata_vld_ff2;
     
477.     end
     
478. end
     
479. 
     
480. 
     
481. endmodule

复制代码

1.6 效果和总结

该工程得上板效果使用signaltap进行捕捉来观测的，因此不同开发板的上板效果是一样，那么下面就只介绍mp801的上板现象。

下图是写数据的情况，Bank地址为0。写入SDRAM的数据为0~255。

下图是读数据的情况，Bank地址为0，潜伏期为2，读出的数据为0~255。

下图是读数据的情况，Bank地址为1，潜伏期为2，读出的数据不是0~255，这是因为我们写数据的地址是Bank0，而不是Bank1，Bank1中是没有数据，所以读出的数据就不是确定的。

设计教学视频和源工程代码可以访问明德扬论坛（http://www.fpgabbs.cn/）进行相关工程设计学习：http://www.fpgabbs.cn/thread-1151-1-1.html