实验十八：SDRAM模块① — 单字读写

笔者与SDRAM有段不短的孽缘，它作为冤魂日夜不断纠缠笔者。笔者尝试过许多方法将其退散，不过屡试屡败的笔者，最终心情像橘子一样橙。《整合篇》之际，笔者曾经大战几回儿，不过内容都是点到即止。最近它破蛊而出，日夜不停：“好~痛苦！好~痛苦！”地呻吟着，吓得笔者不敢半夜如厕。疯狂之下，誓要歪它不可 ... 可恶的东西，笔者要它血债血还！

图18.1 数据读取（理想时序左，物理时序右）。

首先，让我们来了解一下，什么才是数据读取的最佳状态？如图18.1所示，红色箭头是上升沿，绿色箭头是锁存沿。左图是理想时序读取数据的最佳状态，即T0发送数据，T1锁存数据。右图则是物理时序读取数据的最佳状态，即T0发送数据，然后数据经由 TDATA延迟，然后T1锁存数据。理想状态下，读取数据不用考虑任何物理因数，凡是过去值都会读取成功。

图18.2 读取数据（物理时序）。

然而物理状态下，读取数据则必须考虑物理因数，但是物理时序也有所谓的理想状态，即数据被TDATA推挤，然后恰好停留在锁存沿的正中间。该状态之所以称为理想，那是因为建立时间TSETUP与保持时间THOLD都被满足。

如图18.2所示，TSETUP从数据中间向左边覆盖，THOLD从数据中间向右边覆盖，如果两者不完全覆盖数据，那么数据的有效性就能得到保证。简言之，数据是否读取成功，建立时间还有保持时间都必须得到满足。但是我们也知道，Verilog不能描述理想以外的东西，即Verilog无力描述TDATA。话虽如此，我们可以改变时钟位移来达到同样的效果。

图18.3 CLOCK1位移 -180°（左图），没有位移（中图），CLOCK2 位移 +180°（右图），以及修正结果。

常见的理想时序，最多适用在FPGA的内部而已。当描述功活动涉及FPGA的外部，那么理想时序必须考虑对外的情况。如图18.3所示，中间的理想时序图可以经由 CLOCK1 位移 -180°，又或者 CLOCK2 位移 +180° 来得到同样的效果。虽说180° 的位移是理想效果，但是我们还要考虑物理路径所带来的影响。根据Alinix 301这只开发板，我们必须追加 -30° 位移才能达到修正的效果。（注意：追加-30° 的修正时序仅仅为适用Alinix 301这只板子而已）。理解完毕以后，我们便可进入正题。

驱动SDRAM而言，简单可以分为以下四项操作：

（一）初始化

（二）刷新操作

（三）读操作

（四）写操作

初始化令SDRAM就绪，刷新操作就是不失掉内容（数据），读操作就是从SDRAM哪里读取数据，写操作就是向SDRAM写数据。其中，读写操作又有单字读写，多字读写还有页读写。

首先，让我们来分析一下Alinx 开发板上HY57V2562GTR 这只SDRAM。根据手册，这只SDRAM有256Mb的容量，4个BANK（即一个BANK为64Mb)，频率极限为200Mhz，数据保留周期为 8192 / 64ms。至于引脚定义如表18.1所示：

表18.1 SDRAM的引脚定义

分类

标示

信号

说明

时钟信号

CLK

S_CLK

时钟源

地址信号

BA0~1

S_BA[1:0]

BANK地址

A0~A12

S_A[12:0]

读写地址，行列共用，A0~A12为行地址，CA0~CA8为列地址

命令信号

CKE

S_CKE,

时钟选，拉高有效

CS

S_NCS,

片选，拉低有效

RAS

S_NRAS,

命令选，拉低有效

CAS

S_NCAS,

命令选，拉低有效

WE

S_NWE

命令选，拉低有效

数据信号

DQ0~DQ15

S_DQ[15:0]

读写数据的IO

LDQM，UDQM

S_DQM[1:0]

遮盖数据，一般拉低无视

如表18.1所示，CLK为SDRAM的时钟源。CKE，CS，RAS，CAS还有WE皆为命令信号，五者相互组合形成以下几个常用命令，结果如表18.2所示：

表18.2 常用命令。

命令

CKE

CS

RAS

CAS

WE

说明

NOP

1

0

1

1

1

空命令

ACT

1

0

0

1

1

激活命令，选择Bank地址与行地址

WR

1

0

1

0

0

写命令，开始写数据

RD

1

0

1

0

1

读命令，开始读数据

BSTP

1

0

1

1

0

停止命令，停止读写

PR

1

0

0

1

0

预充命令，释放选择

AR

1

0

0

0

1

刷新命令，刷新内容

LMR

1

0

0

0

0

设置命令，设置SDRAM

l NOP为No Operation，即空命令，除了给空时间以外没有任何意义。

l ACT为Active，即激活命令，用来选择某Bank某行。

l WR为Write，即写命令，通知设备开始写数据。

l RD为Read，即读命令，通知设备开始读数据。

l BSTP为Burst Stop，即停止命令，禁止设备继续读写。

l PR为 Precharge，即预充命令，用来释放某Bank与某行的选择。

l AR为Auto Refresh，即刷新命令，用来刷新或者更新数据内容。

l LMR为Load Mode Register，即设置命令，用来配置设备参数。

Verilog则可以这样描述这些命令，结果如代码18.1所示：

  1.     parameter _INIT = 5'b01111, _NOP = 5'b10111, _ACT = 5'b10011, _RD = 5'b10101, _WR = 5'b10100,
  1.               _BSTP = 5'b10110, _PR = 5'b10010, _AR = 5'b10001, _LMR = 5'b10000;

代码18.1

DQ0~DQ15为数据信号。BA0~1与A0~A12皆为地址信号，其中A0~A12行列共用，，然而地址信号可以指向的范围，如下计算：

2（2 Bank ＋ 13 Row ＋ 9 Column） × 16 bit = 224 × 16 bit

= 1.6777216e7 × 16 bit // 16M × 16 bit

= 2.68435456e8 bit

= 262144 kbit

= 256 Mbits

初始化：

初始化除了就绪SDRAM以外，我们还要设置SDRAM内部的 Mode Register，设置内容内容如表18.3所示：

表18.3 Mode Register的内容。

Mode Register

A12

A11

A10

A9

A8

A7

A6

A5

A4

A3

A2

A1

A0

0

0

OP Code

0

0

CAS Latency

BT

Burst Length

A3

Burst Type

0

Sequential

1

Interleave
 

Burst Length

A2

A1

A0

A3 = 0

A3 = 1

0

0

0

1

1

0

0

1

2

2

0

1

0

4

4

0

1

1

8

8

1

1

1

Full Page

Reserved

A9

Write Mode

0

Burst Read and Burst Write

1

Burst Read and Single Write

A6

A5

A4

CAS Latency

0

1

0

2

0

1

1

3

如表18.3所示，设置内容必须经由地址信号A12~A0。其中A2~A0表示字读写的长度，实验十八为单字读写，所以A2~A0设置为3’b000。A3表示读写次序，1’b0表示顺序读写。A6~A4表示 CAS 延迟（也可以视为读出延迟），设为 3’b011是为读出更稳定。A9表示读写模式，一般都是设置为1’b0。

图18.4 初始化的理想时序图。

图18.4是初始化的理想时序图，其中CLOCK1为 -210°的系统时钟，CLOCK2为SDRAM的时钟。rCMD为CKE，CS，RAS，CAS还有WE等命令。rA为A0~A12，rBA为BA0~BA1等地址信号。初始化过程如下所示：

l T0，满足100us；

l T1，发送PR命令，拉高所有rA与rBA。

l T1半周期，SDRAM读取。

l T2，满足TRP；

l T3，发送AR命令。

l T3半周期，SDRAM读取。

l T4，满足TRRC，

l T5，发送AR命令。

l T5半周期，SDRAM读取。

l T6，满足TRRC，

l T7，发送LMR命令与相关Code（设置内容）。

l T7半周期，SDRAM读取。

l T8，满足TMRD。

怎么样？读者是不是觉得很单纯呢？事后，Verilog则可以这样描述，结果如代码18.2所示：

  1. 1.    case( i )
  1. 2.                    
  1. 3.           0:  // delay 100us
  1. 4.           if( C1 == T100US -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 5.           else begin C1 <= C1 + 1'b1; end 
  1. 6.                   
  1. 7.           1: // Send Precharge Command
  1. 8.           begin rCMD <= _PR; { rBA, rA } <= 15'h3fff; i <= i + 1'b1; end
  1. 9.                        
  1. 10.           2: // wait TRP 20ns
  1. 11.          if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 12.           else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 13.                   
  1. 14.           3: // Send Auto Refresh Command
  1. 15.           begin rCMD <= _AR; i <= i + 1'b1; end
  1. 16.                   
  1. 17.           4: // wait TRRC 63ns
  1. 18.          if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 19.           else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 20.                        
  1. 21.           5: // Send Auto Refresh Command
  1. 22.           begin rCMD <= _AR; i <= i + 1'b1; end
  1. 23.                   
  1. 24.          6: // wait TRRC 63ns
  1. 25.    if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 26.          else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 27.                               
  1. 28.          7: // Send LMR Cmd. Burst Read & Write, 3'b011 mean CAS latecy = 3, Sequential, 1 burst length
  1. 29.          begin rCMD <= _LMR; rBA <= 2'b11; rA <= {3'd0,1'b0,2'd0,3'b011,1'b0, 3'b000}; i <= i + 1'b1; end
  1. 30.                        
  1. 31.         8: // Send 2 nop CLK for tMRD
  1. 32.         if( C1 == TMRD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 33.         else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 34.                                  
  1. 35.         9: // Generate done signal
  1. 36.         begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 37.                        
  1. 38.        10:
  1. 39.        begin isDone <= 1'b0; i <= 4'd0; end
  1. 40.                   
  1. 41.    endcase

代码18.2

代码18.2完全按照图18.4去驱动，读者只要将i看为T就万事大吉，其中步骤7发送LMR命令还有设置Code内容。至于步骤8~9则用来产生完成信号。

刷新操作：

图18.5 刷新操作的理想时序图。

所谓定期刷新就是被宫掉的初始化，如图18.5所示，时序过程如下：

l T0，发送PR命令（拉高所有rA与rBA视喜好而定）；

l T0半周期，SDRAM读取。

l T1，满足TRP；

l T2，发送AR命令。

l T2半周期，SDRAM读取。

l T3，满足TRRC，

l T4，发送AR命令。

l T4半周期，SDRAM读取。

l T5，满足TRRC，

Verilog 则可以这样表示，结果如表18.3所示：

  1. 1.    case( i )
  1. 2.                    
  1. 3.            0: // Send Precharge Command
  1. 4.            begin rCMD <= _PR; i <= i + 1'b1; end
  1. 5.                         
  1. 6.            1: // wait TRP 20ns
  1. 7.            if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 8.             else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 9.                         
  1. 10.             2: // Send Auto Refresh Command
  1. 11.             begin rCMD <= _AR; i <= i + 1'b1; end
  1. 12.                   
  1. 13.             3: // wait TRRC 63ns
  1. 14.            if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 15.             else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 16.                         
  1. 17.            4: // Send Auto Refresh Command
  1. 18.             begin rCMD <= _AR; i <= i + 1'b1; end
  1. 19.                   
  1. 20.             5: // wait TRRC 63ns
  1. 21.            if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 22.             else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 23.                    
  1. 24.             6: // Generate done signal
  1. 25.             begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 26.                        
  1. 27.            7:
  1. 28.            begin isDone <= 1'b0; i <= 4'd0; end
  1. 29.    
  1. 30.    endcase

代码18.3

除了步骤6~7用来产生完成信号以外，代码18.3都是据图18.5描述。SDRAM储存的内容是非常脆弱的，如果我们不定期刷新内容，该内容有可能会蒸发掉。根据 HY57V2562GTR这只 SDRAM，它的内容储存周期为 8192 / 64ms，然而定期刷新的计算如下：

64ms / 8192 = 7.8125us

换言之，每隔7.8125微妙就要刷新一次所有内容。

写操作：

图18.6 写操作的理想时序图。

图18.6是写操作的理想时序图，过程如下：

l T1，发送ACT命令，BANK地址与行地址；

l T1半周期，SDRAM读取；

l T2，满足TRCD；

l T3，发送WR命令，BANK地址与列地址，还有写数据；

l T3半周期，SDRAM读取

l T4，满足TWR；

l T5，满足TRP。

正如前面说过，ACT命令式用来选择BANK地址与行地址，然而关键就在T3。T3除了发送WR命令，列地址，还有些数据以外，A10拉高是为了执行预充电。所谓预充电就是释放BANK地址，行地址与列地址等的选择。因此，满足TWR以后，我们还要满足TRP的释放时间，好让SDRAM有足够的时间自行释放选择。

Verilog则可以这样描述，结果如代码18.4所示：

  1. 1.    case( i )
  1. 2.                    
  1. 3.          0: // Set IO to output State
  1. 4.         begin isOut <= 1'b1; i <= i + 1'b1; end
  1. 5.                       
  1. 6.         1: // Send Active Command with Bank and Row address
  1. 7.         begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
  1. 8.                         
  1. 9.        2: // wait TRCD 20ns
  1. 10.        if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 11.         else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end             
  1. 12.                     
  1. 13.         3: // Send Write cmd with row address, pull up A10 1 clk to PR
  1. 14.         begin rCMD <= _WR; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0] }; i <= i + 1'b1; end
  1. 15.                    
  1. 16.         4: // wait TWR 2 clock
  1. 17.         if( C1 == TWR -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 18.          else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end  
  1. 19.                         
  1. 20.         5: // wait TRP 20ns
  1. 21.         if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 22.          else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end                
  1. 23.                    
  1. 24.          6: // Generate done signal
  1. 25.          begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 26.                        
  1. 27.         7:
  1. 28.         begin isDone <= 1'b0; i <= 4'd0; end
  1. 29.                    
  1. 30.     endcase

代码18.4

根据前面的计算，BA1~BA0再加上 RA12~A0与 CA8~A0以后，一共有24位宽，详细的位分配如表18.4所示：

表18.4 Addr的位分配。

位分配

地址内容

Addr[23:22]

BANK地址

Addr[21：9]

行地址

Addr[8:0]

列地址

如代码18.4所示，步骤用来设置IO口为输出。步骤1为rA赋值行地址，步骤3则为rA赋值列地址，并且拉高A10以示自行预充电。步骤6~7用来产生完成信号。

读操作：

图18.7 读操作的理想时序。

图18.7为读操作的理想时序，大致过程如下：

l T1，发送ACT命令，BANK地址与行地址；

l T1半周期，SDRAM读取；

l T2，满足TRCD；

l T3，发送RD命令，BANK地址与列地址；

l T3半周期，SDRAM读取命令。

l T4，满足 CAS Latency。

l T5，读取数据。

l T6，满足TRP。

读操作与写操作的过程大同小异，除了WR命令变成RD命令以外，A10为1同样表示自行预充电，余下就是满足CAS Latency。好奇的同学一定会觉得疑惑，为何CL 为3呢？其实没什么，只是直感上觉得3这个数字比较顺眼一点。注意CL的计算方式是读取RD命令以后开始计算。

Verilog可以这样描述，结果如代码18.5所示：

  1. 1.    case( i )
  1. 2.                    
  1. 3.            0:
  1. 4.            begin isOut <= 1'b0; D1 <= 16'd0; i <= i + 1'b1; end
  1. 5.    
  1. 6.             1: // Send Active command with Bank and Row address
  1. 7.             begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
  1. 8.                         
  1. 9.            2: // wait TRCD 20ns
  1. 10.            if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 11.            else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end 
  1. 12.                    
  1. 13.            3: // Send Read command and column address, pull up A10 to PR.
  1. 14.             begin rCMD <= _RD; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0]}; i <= i + 1'b1; end
  1. 15.                         
  1. 16.            4: // wait CL 3 clock
  1. 17.            if( C1 == CL -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 18.            else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end 
  1. 19.                    
  1. 20.            5: // Read Data
  1. 21.            begin D1 <= S_DQ; i <= i + 1'b1; end
  1. 22.                                         
  1. 23.           6: // wait TRP 20ns
  1. 24.           if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 25.            else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end  
  1. 26.            
  1. 27.            7: // Generate done signal
  1. 28.            begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 29.                        
  1. 30.           8:
  1. 31.           begin isDone <= 1'b0; i <= 4'd0; end
  1. 32.    
  1. 33.    endcase

代码18.5

代码18.5完全根据图18.7描述，除了步骤7~8用于产生完成信号以外。SDRAM的基本操作大致上就是这样而已，完后我们便可以开始建模了。

图18.8 SDRAM基础模块的建模图。

图18.8是SDRAM基础模块的建模图，SDRAM基础模块的内容包括SDRAM控制模块，还有SDRAM功能模块。外围的PLL模块应用频率为133Mhz向左位移210°的CLOCK1，还有133Mhz的CLOCK2。CLOCK1用作系统时钟，CLOCK用作SDRAM时钟。如果PLL模块硬要分类的话，它应该属于特殊性质的即时类吧！？

SDRAM控制模块主要负责一些操作的调度，左边2位Call/Done由外部调用，其中 [1]为写操作 [0]为读操作；右边4位Call/Done为调用SDRAM功能模块，其中 [3]为写操作 [2]为读操作 [1]为刷新 [0]为初始化。SDRAM功能模块的右边是驱动SDRAM硬件资源的顶层信号，左边的问答信号被控制模块调用以外，地址信号还有数据信号都直接连接外部。

sdram_funcmod.v

图18.9 SDRAM功能模块的建模图。

该说的东西笔者都已经说了，具体内容我们还是来看代码吧。

  1. 1.    module sdram_funcmod
  1. 2.    (
  1. 3.          input CLOCK,
  1. 4.         input RESET,
  1. 5.         
  1. 6.         output S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE,
  1. 7.         output [1:0]S_BA,  
  1. 8.         output [12:0]S_A,  
  1. 9.         output [1:0]S_DQM,
  1. 10.         inout [15:0]S_DQ,
  1. 11.         
  1. 12.         input [3:0]iCall,
  1. 13.         output oDone,
  1. 14.         input [23:0]iAddr,  // [23:22]BA,[21:9]Row,[8:0]Column
  1. 15.         input [15:0]iData,
  1. 16.         output [15:0]oData
  1. 17.    );

以上内容为相关的出入端声明。

  1. 18.        parameter T100US = 14'd13300;
  1. 19.        // tRP 20ns, tRRC 63ns, tRCD 20ns, tMRD 2CLK, tWR/tDPL 2CLK, CAS Latency 3CLK
  1. 20.        parameter  TRP = 14'd3, TRRC = 14'd9, TMRD = 14'd2, TRCD = 14'd3, TWR = 14'd2, CL = 14'd3;
  1. 21.        parameter  _INIT = 5'b01111, _NOP = 5'b10111, _ACT = 5'b10011, _RD = 5'b10101, _WR = 5'b10100,
  1. 22.                  _BSTP = 5'b10110, _PR = 5'b10010, _AR = 5'b10001, _LMR = 5'b10000;
  1. 23.

以上内容为相关的常量声明，其中第18~20行的是将常量都是经由133Mhz量化。

  1. 24.        reg [4:0]i;
  1. 25.        reg [13:0]C1;
  1. 26.        reg [15:0]D1;
  1. 27.        reg [4:0]rCMD;
  1. 28.        reg [1:0]rBA;
  1. 29.        reg [12:0]rA;
  1. 30.        reg [1:0]rDQM;
  1. 31.        reg isOut;
  1. 32.        reg isDone;
  1. 33.    
  1. 34.        always @ ( posedge CLOCK or negedge RESET )
  1. 35.            if( !RESET )
  1. 36.                begin
  1. 37.                    i <= 4'd0;
  1. 38.                  C1 <= 14'd0;
  1. 39.                  D1 <= 16'd0;
  1. 40.                    rCMD <= _NOP;
  1. 41.                    rBA <= 2'b11;
  1. 42.                  rA <= 13'h1fff;
  1. 43.                    rDQM <= 2'b00;
  1. 44.                    isOut <= 1'b1;
  1. 45.                  isDone <= 1'b0;
  1. 46.                end

以上内容为相关的寄存器声明以及复位操作。

  1. 47.              else if( iCall[3] )
  1. 48.                case( i )
  1. 49.                    
  1. 50.                    0: // Set IO to output State
  1. 51.                    begin isOut <= 1'b1; i <= i + 1'b1; end
  1. 52.                       
  1. 53.                    1: // Send Active Command with Bank and Row address
  1. 54.                    begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
  1. 55.                         
  1. 56.                  2: // wait TRCD 20ns
  1. 57.                  if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 58.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end             
  1. 59.                    
  1. 60.                    /*********************************************/
  1. 61.                    
  1. 62.                    3: // Send Write command with row address, pull up A10 1 clk to PR
  1. 63.                    begin rCMD <= _WR; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0] }; i <= i + 1'b1; end
  1. 64.                    
  1. 65.                  4: // wait TWR 2 clock
  1. 66.                  if( C1 == TWR -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 67.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end  
  1. 68.                         
  1. 69.                  5: // wait TRP 20ns
  1. 70.                  if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 71.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end                
  1. 72.                    
  1. 73.                    /**********************************************/
  1. 74.                    
  1. 75.                    6: // Generate done signal
  1. 76.                    begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 77.                        
  1. 78.                  7:
  1. 79.                  begin isDone <= 1'b0; i <= 4'd0; end
  1. 80.                    
  1. 81.                endcase

以上内容为部分核心操作。第47行的if( iCall[3] ) 表示余下内容为写操作。

  1. 82.            else if( iCall[2] )
  1. 83.                case( i )
  1. 84.                    
  1. 85.                  0:
  1. 86.                  begin isOut <= 1'b0; D1 <= 16'd0; i <= i + 1'b1; end
  1. 87.    
  1. 88.                    1: // Send Active command with Bank and Row address
  1. 89.                    begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
  1. 90.                         
  1. 91.                  2: // wait TRCD 20ns
  1. 92.                  if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 93.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end 
  1. 94.                
  1. 95.                    /********************/
  1. 96.                    
  1. 97.                    3: // Send Read command and column address, pull up A10 to PR
  1. 98.                    begin rCMD <= _RD; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0]}; i <= i + 1'b1; end
  1. 99.                         
  1. 100.                    4: // wait CL 3 clock
  1. 101.                    if( C1 == CL -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 102.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end 
  1. 103.                                       
  1. 104.                    /********************/ 
  1. 105.                    
  1. 106.                    5: // Read Data
  1. 107.                    begin D1 <= S_DQ; i <= i + 1'b1; end
  1. 108.                    
  1. 109.                    /********************/
  1. 110.                         
  1. 111.                   6: // wait TRP 20ns
  1. 112.                  if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 113.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end  
  1. 114.                    
  1. 115.                  /********************/
  1. 116.                         
  1. 117.                    7: // Generate done signal
  1. 118.                    begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 119.                        
  1. 120.                  8:
  1. 121.                  begin isDone <= 1'b0; i <= 4'd0; end
  1. 122.    
  1. 123.                endcase

以上内容为部分核心操作。第82行的if( iCall[2] ) 表示余下内容为读操作。

  1. 124.              else if( iCall[1] )
  1. 125.                case( i )
  1. 126.                    
  1. 127.                  0: // Send Precharge Command
  1. 128.                  begin rCMD <= _PR; i <= i + 1'b1; end
  1. 129.                         
  1. 130.                  1: // wait TRP 20ns
  1. 131.                  if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 132.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 133.                         
  1. 134.                    2: // Send Auto Refresh Command
  1. 135.                    begin rCMD <= _AR; i <= i + 1'b1; end
  1. 136.                   
  1. 137.                    3: // wait TRRC 63ns
  1. 138.                  if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 139.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 140.                         
  1. 141.                  4: // Send Auto Refresh Command
  1. 142.                    begin rCMD <= _AR; i <= i + 1'b1; end
  1. 143.                   
  1. 144.                    5: // wait TRRC 63ns
  1. 145.                  if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 146.                    else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 147.                    
  1. 148.                    /********************/
  1. 149.                    
  1. 150.                    6: // Generate done signal
  1. 151.                    begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 152.                        
  1. 153.                  7:
  1. 154.                  begin isDone <= 1'b0; i <= 4'd0; end
  1. 155.    
  1. 156.                endcase

以上内容为部分核心操作。第124行的if( iCall[1] ) 表示余下内容为刷新操作。

  1. 157.              else if( iCall[0] )
  1. 158.                case( i )
  1. 159.                    
  1. 160.                   0:  // delay 100us
  1. 161.                   if( C1 == T100US -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 162.                   else begin C1 <= C1 + 1'b1; end 
  1. 163.                   
  1. 164.                   /********************/
  1. 165.                   
  1. 166.                   1: // Send Precharge Command
  1. 167.                   begin rCMD <= _PR; { rBA, rA } <= 15'h3fff; i <= i + 1'b1; end
  1. 168.                        
  1. 169.                   2: // wait TRP 20ns
  1. 170.                 if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 171.                   else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 172.                   
  1. 173.                   3: // Send Auto Refresh Command
  1. 174.                   begin rCMD <= _AR; i <= i + 1'b1; end
  1. 175.                   
  1. 176.                   4: // wait TRRC 63ns
  1. 177.                if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 178.                   else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 179.                        
  1. 180.                   5: // Send Auto Refresh Command
  1. 181.                   begin rCMD <= _AR; i <= i + 1'b1; end
  1. 182.                   
  1. 183.                   6: // wait TRRC 63ns
  1. 184.                 if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 185.                   else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 186.                
  1. 187.                   /********************/
  1. 188.                   
  1. 189.                   7: // Send LMR Cmd. Burst Read & Write,  3'b010 mean CAS latecy = 3, Sequential, 1 burst length
  1. 190.                   begin rCMD <= _LMR; rBA <= 2'b11; rA <= { 3'd0, 1'b0, 2'd0, 3'b011, 1'b0, 3'b000 }; i <= i + 1'b1; end
  1. 191.                        
  1. 192.                8: // Send 2 nop CLK for tMRD
  1. 193.                if( C1 == TMRD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
  1. 194.                  else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
  1. 195.                   
  1. 196.                   /********************/
  1. 197.                   
  1. 198.                   9: // Generate done signal
  1. 199.                   begin isDone <= 1'b1; i <= i + 1'b1; end
  1. 200.                        
  1. 201.                10:
  1. 202.                begin isDone <= 1'b0; i <= 4'd0; end
  1. 203.                   
  1. 204.                endcase
  1. 205.

以上内容为部分核心操作。第157行的if( iCall[0] ) 表示余下内容为初始化。

  1. 206.         assign { S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE } = rCMD;
  1. 207.         assign { S_BA, S_A } = { rBA, rA };
  1. 208.         assign S_DQM = rDQM;
  1. 209.         assign S_DQ  = isOut ? iData : 16'hzzzz;
  1. 210.         assign oDone = isDone;
  1. 211.         assign oData = D1;
  1. 212.    
  1. 213.    endmodule

以上内容为相关的输出驱动声明，注意 iData直接驱动 S_DQ。

sdram_ctrlmod.v

图18.10 SDRAM控制模块的建模图。

前面说过该模块负责一些功能调用，此外该模块也负责定时刷新的计算，具体内容我们还是来看代码吧。

  1. 1.    module sdram_ctrlmod
  1. 2.    (
  1. 3.        input CLOCK,
  1. 4.        input RESET,
  1. 5.        input [1:0]iCall, // [1]Write, [0]Read
  1. 6.        output [1:0]oDone,
  1. 7.        output [3:0]oCall,
  1. 8.        input iDone
  1. 9.    );
  1. 10.        parameter WRITE = 4'd1, READ = 4'd4, REFRESH = 4'd7, INITIAL = 4'd8;
  1. 11.        parameter TREF = 11'd1040;
  1. 12.

以上内容为相关的出入端声明。第10行是各个入口地址的常量声明，第11行则是定时刷新的周期——7.8125us。

  1. 13.        reg [3:0]i;
  1. 14.        reg [10:0]C1;
  1. 15.        reg [3:0]isCall; //[3]Write [2]Read [1]A.Refresh [0]Initial
  1. 16.        reg [1:0]isDone;
  1. 17.        
  1. 18.        always @ ( posedge CLOCK or negedge RESET )
  1. 19.            if( !RESET )
  1. 20.                 begin
  1. 21.                        i <= INITIAL;          // Initial SDRam at first 
  1. 22.                        C1 <= 11'd0;
  1. 23.                        isCall <= 4'b0000;
  1. 24.                        isDone <= 2'b00;
  1. 25.                  end

以上内容为相关的寄存器声明以及复位操作。第21行表示i首先会指向初始化。

  1. 26.             else 
  1. 27.                 case( i )
  1. 28.                  
  1. 29.                        0: // IDLE
  1. 30.                        if( C1 >= TREF ) begin C1 <= 11'd0;  i <= REFRESH; end
  1. 31.                        else if( iCall[1] ) begin C1 <= C1 + 1'b1; i <= WRITE; end 
  1. 32.                        else if( iCall[0] ) begin C1 <= C1 + 1'b1; i <= READ; end 
  1. 33.                        else begin C1 <= C1 + 1'b1; end
  1. 34.    
  1. 35.                        /***********************/
  1. 36.

以上内容为部分核心操作。步骤0为待机状态，期间第33行的C1会一直递增，如果期间没有任何读写操作，而且C1的计数内容也超过 TREF，那么C1会清零，i指向REFRESH（第30行）。反之，如果读写操作被使能，i指向相关的步骤入口，期间C1也会递增以示步骤翻转所用掉的时钟。

  1. 37.                        1: //Write 
  1. 38.                        if( iDone ) begin isCall[3] <= 1'b0; C1 <= C1 + 1'b1; i <= i + 1'b1; end
  1. 39.                        else begin isCall[3] <= 1'b1; C1 <= C1 + 1'b1; end
  1. 40.                        
  1. 41.                        2:
  1. 42.                        begin isDone[1] <= 1'b1; C1 <= C1 + 1'b1; i <= i + 1'b1; end
  1. 43.                        
  1. 44.                        3:
  1. 45.                        begin isDone[1] <= 1'b0; C1 <= C1 + 1'b1; i <= 4’d0; end
  1. 46.                        
  1. 47.                        /***********************/
  1. 48.

以上内容为部分核心操作。步骤1~3是写操作。步骤1表示，功能模块反馈完成信号之前，C1会不停递增。当完成信号接收到手，isCall[3]拉低，C1递增，i也递增。步骤2~3则是用来反馈写操作的完成信号，期间C1也会递增。

  1. 49.                         4: // Read
  1. 50.                        if( iDone ) begin isCall[2] <= 1'b0; C1 <= C1 + 1'b1; i <= i + 1'b1; end
  1. 51.                        else begin isCall[2] <= 1'b1; C1 <= C1 + 1'b1; end
  1. 52.                        
  1. 53.                        5:
  1. 54.                        begin isDone[0] <= 1'b1; C1 <= C1 + 1'b1; i <= i + 1'b1; end
  1. 55.                        
  1. 56.                        6:
  1. 57.                        begin isDone[0] <= 1'b0; C1 <= C1 + 1'b1; i <= 4'd0; end
  1. 58.                        
  1. 59.                        /***********************/
  1. 60.

以上内容为部分核心操作。步骤4~6是读操作。步骤4表示接收完成信号之前，isCall[2]会不停拉高，C1也会不停递增 ... 直至接收完成信号，isCall[2]才会拉低，然而C1也会递增。步骤5~6用反馈读操作的完成信号。

  1. 61.                        7: // Auto Refresh 
  1. 62.                        if( iDone ) begin isCall[1] <= 1'b0; i <= 4'd0; end
  1. 63.                        else begin isCall[1] <= 1'b1; end
  1. 64.                        
  1. 65.                        /***********************/
  1. 66.

以上内容为部分核心操作。步骤7是刷新操作，接收完成信号之前 isCall[1] 会不停拉高，直至接收完成信号为止，isCall[1]才会拉低，然后i指向步骤0。

  1. 67.                        8: // Initial 
  1. 68.                        if( iDone ) begin isCall[0] <= 1'b0; i <= 4'd0; end
  1. 69.                        else begin isCall[0] <= 1'b1; end
  1. 70.                        
  1. 71.                  endcase
  1. 72.        
  1. 73.        assign oDone = isDone;
  1. 74.        assign oCall = isCall;
  1. 75.        
  1. 76.    endmodule

以上内容为部分核心操作。步骤8用来执行初始化，接收完成信号之前，isCall[0]会不停拉高，直至接收完成信号为止，isCall[0]才会拉低，然后i指向步骤0。第73~74行则是相关的输出驱动。整体而言，除了读写操作必须反馈完成信号给上层以外，其余的定期刷新还有初始化都是该内部操作，所以不用反馈完成信号。

sdram_basemod.v

内容的连线部署完全依照图18.8。

  1. 1.    module sdram_basemod
  1. 2.    (
  1. 3.         input CLOCK,
  1. 4.         input RESET,
  1. 5.         
  1. 6.         output S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE,
  1. 7.         output [1:0]S_BA,
  1. 8.         output [12:0]S_A, 
  1. 9.         output [1:0]S_DQM,
  1. 10.         inout [15:0]S_DQ,
  1. 11.         
  1. 12.         input [1:0]iCall,
  1. 13.         output [1:0]oDone,
  1. 14.         input [23:0]iAddr,
  1. 15.         input [15:0]iData,
  1. 16.         output [15:0]oData
  1. 17.    );

以上内容为相关的出入端声明，第5~10行是顶层信号，第12~16行是模块左右两边的信号。

  1. 18.         wire [3:0]CallU1; // [3]Refresh, [2]Read, [1]Write, [0]Initial
  1. 19.    
  1. 20.        sdram_ctrlmod U1
  1. 21.         (
  1. 22.              .CLOCK( CLOCK ),
  1. 23.              .RESET( RESET ),
  1. 24.              .iCall( iCall ),       // < top ,[1]Write [0]Read
  1. 25.              .oDone( oDone ),     // > top ,[1]Write [0]Read
  1. 26.              .oCall( CallU1 ),    // > U2 
  1. 27.              .iDone( DoneU2 )    // < U2
  1. 28.         );
  1. 29.

以上内容为控制模块的实例化。

  1. 30.         wire DoneU2;
  1. 31.         
  1. 32.         sdram_funcmod U2
  1. 33.         (
  1. 34.             .CLOCK( CLOCK ),
  1. 35.              .RESET( RESET ),
  1. 36.              .S_CKE( S_CKE ),     // > top
  1. 37.              .S_NCS( S_NCS ),     // > top
  1. 38.              .S_NRAS( S_NRAS ),  // > top
  1. 39.              .S_NCAS( S_NCAS ),  // > top
  1. 40.              .S_NWE( S_NWE ),      // > top
  1. 41.              .S_BA( S_BA ),        // > top
  1. 42.              .S_A( S_A ),           // > top
  1. 43.              .S_DQM( S_DQM ),    // > top
  1. 44.              .S_DQ( S_DQ ),       // <> top        
  1. 45.              .iCall( CallU1 ),         // < U1
  1. 46.              .oDone( DoneU2 ),      // > U1
  1. 47.              .iAddr( iAddr ),        // < top
  1. 48.              .iData( iData ),          // < top
  1. 49.              .oData( oData )       // > top
  1. 50.         );
  1. 51.         
  1. 52.    endmodule

以上内容为功能模块的实例化。

sdram_demo.v

图18.11 实验十八的建模图。

图18.11是实验十八的建模图，其中sdram_demo包含PLL模块，核心操作还有SDRAM基础模块。PLL模块将50Mhz的时钟倍频为133Mhz而且左移210° 的CLOCK1，还有133Mhz的CLOCK2，它直接驱动S_CLK顶层信号。核心操作负责调用SDRAM基础模块，并且将读写内容经由TXD发送出去。SDRAM基础模块左边的问答信号只有两位，其中[1]为写 [0]为读，具体内容我们还是来看代码吧。

  1. 1.    module sdram_demo
  1. 2.    (
  1. 3.         input CLOCK,
  1. 4.         input RESET,
  1. 5.         output S_CLK,
  1. 6.         output S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE,
  1. 7.         output [12:0]S_A, 
  1. 8.         output [1:0]S_BA,
  1. 9.         output [1:0]S_DQM,
  1. 10.         inout [15:0]S_DQ,
  1. 11.         output TXD
  1. 12.    );

以上内容为相关的出入端声明。

  1. 13.         wire CLOCK1,CLOCK2;
  1. 14.         
  1. 15.         pll_module U1
  1. 16.         (
  1. 17.                 .inclk0 ( CLOCK ), // 50Mhz
  1. 18.                .c0 ( CLOCK1 ),  // 133Mhz -210 degree phase
  1. 19.                .c1 ( CLOCK2 )   // 133Mhz 
  1. 20.         );
  1. 21.

以上内容为PLL模块的实例化，CLOCK1为133Mhz频率并且左移210°，CLOCK2为133Mhz频率，并且直接驱动 S_CLK。

  1. 22.         wire [1:0]DoneU2;
  2. 23.         wire [15:0]DataU2;
  3. 24.
  4. 25.         sdram_basemod U2
  5. 26.         (
  6. 27.             .CLOCK( CLOCK1 ),
  7. 28.             .RESET( RESET ),
  8. 29.              .S_CKE( S_CKE ),
  9. 30.              .S_NCS( S_NCS ),
  10. 31.              .S_NRAS( S_NRAS ),
  11. 32.              .S_NCAS( S_NCAS ),
  12. 33.              .S_NWE( S_NWE ),
  13. 34.              .S_A( S_A ),
  14. 35.              .S_BA( S_BA ),
  15. 36.              .S_DQM( S_DQM ),
  16. 37.              .S_DQ( S_DQ ),
  17. 38.              .iCall( isCall ),
  18. 39.              .oDone( DoneU2 ),
  19. 40.              .iAddr( D1 ),
  20. 41.              .iData( D2 ),
  21. 42.              .oData( DataU2 )
  22. 43.         );

  1. 44.

以上内容为SDRAM基础模块的实例化，第40~41行表示 iAddr为D1驱动，iData为D2驱动。

 

  1. 45.         parameter B115K2 = 11'd1157, TXFUNC = 6'd16;
  1. 46.         
  1. 47.         reg [5:0]i,Go;
  1. 48.         reg [10:0]C1;
  1. 49.         reg [23:0]D1;
  1. 50.         reg [15:0]D2,D3;
  1. 51.         reg [10:0]T;
  1. 52.         reg [1:0]isCall;
  1. 53.         reg rTXD;
  1. 54.         
  1. 55.         always @ ( posedge CLOCK1 or negedge RESET )
  1. 56.             if( !RESET )
  1. 57.                 begin
  1. 58.                           i <= 6'd0;
  1. 59.                          Go <= 6'd0;
  1. 60.                          C1 <= 11'd0;
  1. 61.                           D1 <= 24'd0;
  1. 62.                          D2 <= 16'd0;
  1. 63.                          D3 <= 16'd0;
  1. 64.                          T <= 11'd0;
  1. 65.                          isCall <= 2'b00;
  1. 66.                          rTXD <= 1'b1;
  1. 67.                 end

以上内容为相关的寄存器以及复位操作。第45行是波特率为115200还有伪函数入口的常量声明。

  1.  
  1. 68.             else 
  1. 69.                 case( i )
  1. 70.                        
  1. 71.                         0:
  1. 72.                         if( DoneU2[1] ) begin isCall[1] <= 1'b0; i <= i + 1'b1; end
  1. 73.                         else begin isCall[1] <= 1'b1; D1 <= 24'd0; D2 <= 16'hABCD; end
  1. 74.                         
  1. 75.                         1:
  1. 76.                         if( DoneU2[0] ) begin D3 <= DataU2; isCall[0] <= 1'b0; i <= i + 1'b1; end
  1. 77.                         else begin D1 <= 24'd0; isCall[0] <= 1'b1; end
  1. 78.                         
  1. 79.                         2:
  1. 80.                         begin T <= { 2'b11, D3[15:8], 1'b0 }; i <= TXFUNC; Go <= i + 1'b1; end
  1. 81.                         
  1. 82.                         3:
  1. 83.                         begin T <= { 2'b11, D3[7:0], 1'b0 }; i <= TXFUNC; Go <= i + 1'b1; end
  1. 84.                         
  1. 85.                         4:
  1. 86.                         i <= i;
  1. 87.                         
  1. 88.                        /******************************/
  1. 89.

以上内容为部分核心操作。步骤0将数据16’hABCD写入地址0。步骤1从地址0读出数据 16’hABCD，并且暂存至D3。步骤2先发送D3的高8位，步骤3则发送D3的低8位。步骤4发呆。

  1. 90.                          16,17,18,19,20,21,22,23,24,25,26:
  1. 91.                         if( C1 == B115K2 -1 ) begin C1 <= 11'd0; i <= i + 1'b1; end
  1. 92.                         else begin rTXD <= T[i - 16]; C1 <= C1 + 1'b1; end
  1. 93.                         
  1. 94.                         27:
  1. 95.                         i <= Go;
  1. 96.                         
  1. 97.                endcase
  1. 98.    
  1. 99.         assign S_CLK = CLOCK2;
  1. 100.         assign TXD = rTXD;
  1. 101.    
  1. 102.    endmodule

以上内容为部分核心操作。步骤16~27是发送一帧数据的伪函数。第99~100行则是相关的输出驱动。综合完毕并且下载程序，如果串口调试软件出现 ABCD等两字节数据，结果表示实验成功。

细节一：完整的个体模块

SDRAM基础模块已经就绪完毕。

细节二：其它时序参数

驱动SDRAM最大的收获莫过于学习各种稀奇古怪的时序参数，虽然实验十六的IIC，也有时序参数，但是前者好比一粒面包屑，后者则是一片面包，两种时序参数有“体积”上的明确差距。笔者曾经说过，时序参数即时间要求有第一层与第二层之分，第一层时间要求正如IIC的时序参数，打得像面包一样 ... 反之，第二层时间要求宛如SDRAM的时序参数，小得似面包屑一般。

SDRAM的时序参数除了 tRP，TRRC，TMRD，CAS Latency 等这些东西以外，它还有更为极为，而且不能控制的时序参数。更确切来说，这些时序参数都属于物理因数的范围 ... 难得有机会学习SDRAM，笔者就稍微聊聊它们吧。

图18.12 时序参数①。

图18.12是读操作的部分时序，当CL得到满足以后，数据就会被吐出来，其中：

TLZ（TLOZ）为 clock to data output in low-Z time。简单来说，就是数据被出发沿吐出之前，必须经过的延迟时间。根据手册，133Mhz为1ns。

TAC为 access time from clock。简单来说就是有效时间。根据手册，133Mhz为5.4ns

TOH为 data out hold time。简单来说就是常见的 THOLD。根据手册，133Mhz为2.5ns

图18.13 时序参数②。

图18.13是写操作的部分时序图，然而重点家伙就是当中 T××S或者T××H。一般××是指数据的属性或者类别，不过S与H都有相同的意义，就是典型的TSETUP还有THOLD。笔者习惯称呼它们为寄存器特性，因为只要任何一方得不到满足，数据读入寄存器就得不到保证。寄存器特性好比哥布林一样，数量常常多到令人喷饭，如果一一分析会耗死爷爷不偿命。

图18.14 对外的理想时序。

为了用足一支竹竿扫尽一切，笔者才故意向将CLOCK1左移180° 测试手气，看看SDRAM能不能读出正确的结果，如果不是再追加位移或者减少位移以致修正，结果如图18.14所示。一般而言，T××S或者T××H这些家伙都会得到满足，然后乖乖就范。话虽如此，同学们还须注意，Verilog充其量只能满足第二层的时间要求，却不能涉及（解决）其中，我们往往只能依赖运气与直觉。当然，我们可以借助静态时序分析的力量去搞定一切，有兴趣的朋友请看《工具篇I》。

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验十八：SDRAM模块① — 单字读写的更多相关文章

  1. [黑金原创教程] FPGA那些事儿《设计篇 III》- 图像处理前夕·再续

    简介 一本为入门图像处理的入门书,另外还教你徒手搭建平台(片上系统),内容请看目录. 注意 为了达到最好的实验的结果,请准备以下硬件. AX301开发板, OV7670摄像模块, VGA接口显示器, ...

  2. [黑金原创教程] FPGA那些事儿《设计篇 II》- 图像处理前夕·续

    简介 一本为入门图像处理的入门书,另外还教你徒手搭建平台(片上系统),内容请看目录. 注意 为了达到最好的实验的结果,请准备以下硬件. AX301开发板, OV7670摄像模块, VGA接口显示器, ...

  3. [黑金原创教程] FPGA那些事儿《设计篇 I》- 图像处理前夕

    简介 一本为入门图像处理的入门书,另外还教你徒手搭建平台(片上系统),内容请看目录. 注意 为了达到最好的实验的结果,请准备以下硬件. AX301开发板, OV7670摄像模块, VGA接口显示器, ...

  4. [黑金原创教程] FPGA那些事儿《数学篇》- CORDIC 算法

    简介 一本为完善<设计篇>的书,教你CORDIC算法以及定点数等,内容请看目录. 贴士 这本教程难度略高,请先用<时序篇>垫底. 目录 Experiment 01:认识CORD ...

  5. 【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验十九：SDRAM模块② — 多字读写

    实验十九:SDRAM模块② — 多字读写 表示19.1 Mode Register的内容. Mode Register A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A ...

  6. 【黑金原创教程】【FPGA那些事儿-驱动篇I 】原创教程连载导读【连载完成，共二十九章】

    前言: 无数昼夜的来回轮替以后,这本<驱动篇I>终于编辑完毕了,笔者真的感动到连鼻涕也流下来.所谓驱动就是认识硬件,还有前期建模.虽然<驱动篇I>的硬件都是我们熟悉的老友记,例 ...

  7. 【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二十：SDRAM模块③ — 页读写 α

    实验二十:SDRAM模块③ — 页读写 α 完成单字读写与多字读写以后,接下来我们要实验页读写.丑话当前,实验二十的页读写只是实验性质的东西,其中不存在任何实用价值,笔者希望读者可以把它当成页读写的热 ...

  8. 【黑金原创教程】【FPGA那些事儿-驱动篇I 】连载导读

    前言: 无数昼夜的来回轮替以后,这本<驱动篇I>终于编辑完毕了,笔者真的感动到连鼻涕也流下来.所谓驱动就是认识硬件,还有前期建模.虽然<驱动篇I>的硬件都是我们熟悉的老友记,例 ...

  9. 【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二：按键模块① - 消抖

    实验二:按键模块① - 消抖 按键消抖实验可谓是经典中的经典,按键消抖实验虽曾在<建模篇>出现过,而且还惹来一堆麻烦.事实上,笔者这是在刁难各位同学,好让对方的惯性思维短路一下,但是惨遭口 ...

随机推荐

  1. js pjax 和window.history.pushState,replaceState

    原文:http://blog.linjunhalida.com/blog/pjax/ github:https://github.com/defunkt/jquery-pjax 什么是pjax? 现在 ...

  2. asp.net导出EXCEL的好方法！（好用，导出全部数据）

    1.调用方法: ExportExcel("application/ms-excel", "EXCEL名称.xls", GridView1, this.Page) ...

  3. 配置caffe过程中，生成解决方案出错。无法打开包括文件: “gpu/mxGPUArray.h”

    ------ 已启动生成: 项目: matcaffe, 配置: Release x64 ------12> MatlabPreBuild.cmd : Create output director ...

  4. 什么是REST设计风格

    https://zh.wikipedia.org/wiki/REST http://www.infoq.com/cn/articles/rest-introduction

  5. Java实现策略模式的简单应用

    在使用图像处理软件处理图片后,需要选择一种格式进行保存.然而各种格式在底层实现的算法并不相同,这刚好适合策略模式.编写程序,演示如何使用策略模式与简单工厂模式组合进行开发. 思路如下: 使用inter ...

  6. SQL利用CASE按分组显示合计

    按行显示的合计 select game, sum(purchase) as purchase_sum from purchase group by game; 按列显示的合计 select sum(c ...

  7. 【ArcGIS】ArcGIS Enterprise部署

    单机部署 多层部署 高可用性部署

  8. Redis 集群配置

    Redis 集群介绍: (1) 为什么要使用集群:如果数据量很大,单台机器会存在存储空间不够用 .查询速度慢 .负载高等问题,部署集群就是为了解决这些问题(2) Redis 集群架构如下,采用无中心结 ...

  9. 高并发应对:淘宝CDN缓存服务器部署探秘

    转自:http://server.chinabyte.com/6/12663506.shtml “好,时间到,开抢!”坐在电脑前早已等待多时的宋兰(化名)一看时间已到2011年11月11日零时,便迫不 ...

  10. Centos6下Python3的编译安装

    本文转载自 Centos6下Python3的编译安装 系统环境:CentOS 6.8-Minimal 安装Python依赖包: 1 [root@Python src]# yum install zli ...