对于Verilog语言的一些总结

1、不使用初始化语句；

2、不使用延时语句；

3、不使用循环次数不确定的语句，如：forever，while等；

4、尽量采用同步方式设计电路；

5、尽量采用行为语句完成设计；

6、always过程块描述组合逻辑，应在敏感信号表中列出所有的输入信号；

7、所有的内部寄存器都应该可以被复位；

8、用户自定义原件（UDP元件）是不能被综合的。

一：基本

Verilog中的变量有线网类型和寄存器类型。线网型变量综合成wire，而寄存器可能综合成WIRE，锁存器和触发器，还有可能被优化掉。

二：verilog语句结构到门级的映射

1、连续性赋值：assign

连续性赋值语句逻辑结构上就是将等式右边的驱动左边的结点。因此连续性赋值的目标结点总是综合成由组合逻辑驱动的结点。Assign语句中的延时综合时都将忽视。

2、过程性赋值：

过程性赋值只出现在always语句中。

阻塞赋值和非阻塞赋值就该赋值本身是没有区别的，只是对后面的语句有不同的影响。

建议设计组合逻辑电路时用阻塞赋值，设计时序电路时用非阻塞赋值。

过程性赋值的赋值对象有可能综合成wire, latch,和flip-flop，取决于具体状况。如，时钟控制下的非阻塞赋值综合成flip-flop。

过程性赋值语句中的任何延时在综合时都将忽略。

建议同一个变量单一地使用阻塞或者非阻塞赋值。

3、逻辑操作符：

逻辑操作符对应于硬件中已有的逻辑门，一些操作符不能被综合：=、!。

4、算术操作符：

Verilog中将reg视为无符号数，而integer视为有符号数。因此，进行有符号操作时使用integer,使用无符号操作时使用reg。

5、进位：

通常会将进行运算操作的结果比原操作数扩展一位，用来存放进位或者借位。如：

Wire [3:0] A,B;

Wire [4:0] C;

Assign C=A+B;

C的最高位用来存放进位。

6、关系运算符：

关系运算符：<,>,<=,>=

和算术操作符一样，可以进行有符号和无符号运算，取决于数据类型是reg，net还是integer。

7、相等运算符：，！=

注意：=和！是不可综合的。

可以进行有符号或无符号操作，取决于数据类型

8、移位运算符：

左移，右移，右边操作数可以是常数或者是变量，二者综合出来的结果不同。

9、部分选择：

部分选择索引必须是常量。

10、BIT选择：

BIT选择中的索引可以用变量，这样将综合成多路（复用）器。

11、敏感表：Always过程中，所有被读取的数据，即等号右边的变量都要应放在敏感表中，不然，综合时不能正确地映射到所用的门。

12、IF：

如果变量没有在IF语句的每个分支中进行赋值，将会产生latch。如果IF语句中产生了latch，则IF的条件中最好不要用到算术操作。Case语句类似。Case的条款可以是变量。

如果一个变量在同一个IF条件分支中先赎值然后读取，则不会产生latch。如果先读取，后赎值，则会产生latch。

13、循环：

只有for-loop语句是可以综合的。

14、设计时序电路时，建议变量在always语句中赋值，而在该always语句外使用，使综合时能准确地匹配。建议不要使用局部变量。

15、不能在多个always块中对同一个变量赎值

16、函数

函数代表一个组合逻辑，所有内部定义的变量都是临时的，这些变量综合后为wire。

17、任务：

任务可能是组合逻辑或者时序逻辑，取决于何种情况下调用任务。

18、Z：

Z会综合成一个三态门，必须在条件语句中赋值

19、参数化设计：

优点：参数可重载，不需要多次定义模块

四：模块优化

1、资源共享：

当进程涉及到共用ALU时，要考虑资源分配问题。可以共享的操作符主要有：关系操作符、加减乘除操作符。通常乘和加不共用ALU，乘除通常在其内部共用。

2、共用表达式：

如：C=A+B;

    D=G+(A+B);

两者虽然有共用的Ａ＋Ｂ，但是有些综合工具不能识别．可以将第二句改为：D=G+C；这样只需两个加法器．

3、转移代码：

如循环语句中没有发生变化的语句移出循环．

4、避免latch：

两种方法：1、在每一个IF分支中对变量赋值。2、在每一个IF语句中都对变量赋初值。

5：模块：

综合生成的存储器如ROM或RAM不是一种好方法，只是成堆的寄存器，很费资源。最好用库自带的存储器模块。

五、验证：

１、敏感表：

在always语句中，如果敏感表不含时钟，最好将所有的被读取的信号都放在敏感表中。

２、异步复位：

建议不要在异步时对变量读取，即异步复位时，对信号赋以常数值。



Averilog的流行,有两方面的原因;

B verilog与VHDL相比的优点

C典型的verilog模块

D verilog语法要点



A) verilog的流行,有两方面的原因:

1它是cadence的模拟器verilog-XL的基础,cadence的广泛流行使得verilog在90年代深入人心;

2它在硅谷获得广泛使用;

B) verilog与VHDL相比的优点二者的关系仿佛C与FORTRAN,具体而言:

1 verilog的代码效率更高:

比较明显的对比:

VHDL在描述一个实体时采用entity/architecture模式,

verilog在描述一个实体时只需用一个"module/edumodule"语句块.

此外verilog的高效性还在很多地方体现出来;

2 verilog支持二进制的加减运算:

VHDL在进行二进制的加减运算时使用conv_***函数或者进行其他的定义,总之必须通知编译器;verilog直接用形如"c=a+b"的表示二进制的加减运算;

3综合时可控制性好:

VHDL对信号不加区分地定义为"signal",

而verilog区分为register类型的和wire类型的;

但是也有人支持VHDL,认为verilog和VHDL的关系仿佛C和C++.C)典型的verilog模块

讨论以下典型电路的verilog描述:

*与非门;

加法器;  //即全加器

D触发器;

*计数器; //*分频的counter

latch;

*时序机;

*RAM;   //用synopsys的

*模块引用;

*预编译;

*与非门的verilog描述如下:

//verilog使用和C语言相同的注释方法

module nd02(a1,a2,zn);//一个verilog模块总是以module开始,以endmodule   结束,nd02是模块名,a1,a2,zn是模块的3个输入输出信号

input a1,a2;  //告诉编译器a1,a2对此模块而言是输入,并且数据类型是"bit"

output zn;  //告诉编译器zn对此模块而言是输出,数据类型也是"bit"

nand  (zn,a1,a2); //我理解nand是运算符,我们不必深究verilog中的正式术语是什

么了吧，总之这种形式表示zn=~(a1 && a2);你一定已经想到类似的运算符还有"not",“and”,“or”,“nor”,“xor"了吧;除了"not”,括号里的信号数可以任意,例如or (z,f,g,h)表示z=f || g || h,并且延时是3个单位时间，#x表示延时x个单位时间;

endmodule



*加法器的verilog描述如下:

module ad03d1(A,B,CI,S,CO) ;

input [2:0] A,B;  //表示A,B是输入信号,并且是3位矢量,上界是2,下界是0

input CI;

output [2:0] S;

output CO;

assign {CO,S}=A+B+CI;//一对"{“和”}"表示链接,即将CO和S合并成4位矢量

endmodule



*带异步清零端的D触发器的verilog描述如下:

module dfctnb (d,cp,cdn,q,qn);

input d,cp,cdn;

output q,qn;

reg q,qn;    //关键字"reg"表示q和qn是"register"类型的信号;verilog中有两种类型的信号:"register"类型和"wire"类型.你可以简单地把register类型的信号想象为某个D触发器的输出,而wire类型的的信号是组合逻辑的输出.二者的最大区别在于:你可以对register类型的信号进行定时赋值(用wait语句在特定时刻的赋值,详见下面always语句),而对于wire类型的信号则不可.

always wait (cdn0) //表示每当cdn=0时,将要对D触发器清零,“always"和"wait"嵌套，“wait"和”@“是verilog的两个关键字,表示一旦有某事发生；则执行下面的语句块,“always"有点象C语言中的"if … then…”，“wait"和”@“的区别:请参考本模块.wait表示本语句块的进程停止,直到"cdn=0"的条件出现才继续；我理解在verilog中,每个最外层语句块都是一个***的进程;”@”(请看下个always语句)也表示本语句块的进程停止,直到后面定义"posedge
cp”(即出现cp的上升沿)的事件出现才继续;也许wait和@可以合二为一吧,但至少到目前verilog中wait表示"条件",@表示"事件";具体运用中,wait总是用于类似"wait(xxx=1)“之类的场合,@总是用于类似”@(xxx)“或”@(posedge/negedge xxx)“之类的场合整句话的意思是"每当cdn等于0时,则作以下事情”

begin     //begin…end结构的用法类似于pascal语言

       q=0;

         qn=1;

        wait (cdn1);

end

always @ (posedge cp)//"@(posedge cp)“中有两个关键字:”@ (x)“表示"每当事件x发

生”,“posedge x"表示"x的上升沿,“negedge x"表示"x的下降沿”，整句话的意思是"每当cp的上升沿,则作以下事情”

        if (cdn)  //如果cdn=1(意味着清零端无效)

        begin

                 q=d;

                 qn=_q;//""表示反相

        end

endmodule

*计数器的verilog描述如下:

module count(in,set,cp,out) ;//此计数器,在cp的上升沿将输入赋给输出,在cp的上升沿使输出加一

input [15:0] in;

input set,cp;

output [15:0] out;

reg [15:0] out;

always @ (posedge set)

out = in;

always @(posedge cp)

out = out+1;  //verilog容许一个信号同时出现在等号两端,只要它是reg类型的

endmodule



*latch的描述如下:

always @(clk or d)

    if (clk) q = d;



时序机的verilog描述如下:

always @(posedge CLK)  //D是下一个状态,Q是当前状态,e1,e2是输入,a,b是输出

Q=D;

always @(Q or othercase) begin //当Q变化或输入e1,e2变化时D要相应变化

D = Q; //note1

a = 0;

b = 0;

…

case(Q)

  q1:begin

   q1 action;

   if(e1)D=d1;

   if(e2)D=d2;

   else D=d3;

   a = 1; //note 2

   end

  q2:begin

   b = 1;

   …

   end

  default:begin

   a = 0;

   b = 0;

   …

end

end

—annotations—

note 1:

  This is a custom expression,after reset,D should be equal to Q;

note 2:

  In this state machine,a is only equal to 1 at state q1,in

  other state,a is equal to 0;

RAM的verilog描述如下:

module ram(din,ain,dout,aout,rd,wr);//这是一个双口RAM,分别有:输入端:输入地址ain;输入数据din;上升沿有效的写信号wr;/输出端:输出地址aout;输出数据dout;高电平有效的读信号rd;

  inout [7:0] din;

  input [7:0] ain,aout;

  input rd,wr;

  output [7:0] dout;

  reg [7:0] memory [0:255];   //请注意这是存储阵列的描述方法,描述了一个共有2

56个字的存储阵列,每个字是8位

  assign dout = rd ? memory[aout] : 8’bz; //“assign"关键字表示并行赋值语句的

开始”?“运算符的作用和在C语言中一样"8’bz"是一个常量,表示一个字节的高阻态,其中8表示长度是8bit,”’"是固定分割符,"b"表示后面的数据是以比特形式给出的,“z"表示高阻;举例:4’ha表示长4bit的数"1010”。类似的还可举出5’b10111,6’o33等等

  always @(posedge wr)

memory[ain] = din;

endmodule

*模块引用

假设在前面(可以是别的模块)定义了module ram(din,ain,dout,aout,rd,wr),则引用此

模块时只需写

ram myram(din_in_map,ain_in_map,dout_in_map,aout_in_map,rd_in_map,wr_in_map)

;

//其中"ram"是所引用的module名,"myram"是你起的instance名,“din_in_map"等等是图中的节点名,和器件(module)中的"din…“进行"虚实结合”;

*预编译

类似C语言,只需写

include "<pathname:filename>",反上撇号"“是verilog的预编译符,类似C中的”#”.

D) verilog语法要点

*基本原则

设计时应该把你的系统划分为计数器,触发器,时序机,组合逻辑等等可综合的单元,对此不同的IC公司和EDA开发商可能根据自己的见解和经验提出不同的要求,并且对verilog程序的细节进行自己的规定,但有一点是对的:即写硬件描述语言不象写C语言那样符合语法就行.单单符合verilog语法的程序可能被拒绝综合,甚至被拒绝模拟;

*最外层可以写什么?

这里所说的最外层是指module语句后的第一层,在这一层可以写这些可执行语句:

assign和nand等定义组合逻辑的语句,

always语句,

模块引用语句,

一些以"KaTeX parse error: Expected 'EOF', got '&' at position 1358: …ight:19.5px">1.&̲nbsp;   &n…strobe系统函数显示用非阻塞赋值语句赋的值。

规则 #8: 不要使用#0延时赋值。

组合逻辑

1，敏感变量的描述完备性

Verilog中，用always块设计组合逻辑电路时，在赋值表达式右端参与赋值的所有信号都必须在always @(敏感电平列表)中列出,always中if语句的判断表达式必须在敏感电平列表中列出。如果在赋值表达式右端引用了敏感电平列表中没有列出的信号，在综合时将会为没有列出的信号隐含地产生一个透明锁存器。这是因为该信号的变化不会立刻引起所赋值的变化，而必须等到敏感电平列表中的某一个信号变化时，它的作用才表现出来，即相当于存在一个透明锁存器，把该信号的变化暂存起来，待敏感电平列表中的某一个

信号变化时再起作用，纯组合逻辑电路不可能作到这一点。综合器会发出警告。

Example1:

input a,b,c;

reg e,d;

always @(a or b or c)

    begin

    e=d&a&b; /d没有在敏感电平列表中,d变化时e不会立刻变化,直到a,b,c中某一个变化/

    d=e |c;

    end

Example2:

input a,b,c;

reg e,d;

always @(a or b or c or d)

    begin

    e=d&a&b; /d在敏感电平列表中,d变化时e立刻变化/

    d=e |c;

    end

2,条件的描述完备性

如果if语句和case语句的条件描述不完备，也会造成不必要的锁存器。

Example1:

if (a1’b1) q=1’b1;//如果a1’b0,q=? q将保持原值不变，生成锁存器！

Example2:

if (a1’b1) q=1’b1;

else         q=1’b0;//q有明确的值。不会生成锁存器！

Example3:

   reg[1:0] a,q;

   …

   case (a)

      2’b00 : q=2’b00;

      2’b01 : q=2’b11;//如果a2’b10或a2’b11,q=? q将保持原值不变，锁存器！

   endcase

Example4:

   reg[1:0] a,q;

   …

   case (a)

      2’b00 : q=2’b00;

      2’b01 : q=2’b11;

      default: q=2’b00;//q有明确的值。不会生成锁存器！

   endcase

     Verilog中端口的描述

1，端口的位宽最好定义在I/O说明中,不要放在数据类型定义中；

Example1:

module test(addr,read,write,datain,dataout)

input[7:0]  datain;

input[15:0] addr;

input       read,write;

output[7:0] dataout;  //要这样定义端口的位宽！

wire addr,read,write,datain;

reg  dataout;

Example2:

module test(addr,read,write,datain,dataout)

input  datain,addr,read,write;

output dataout;

wire[15:0] addr;

wire[7:0]  datain;

wire       read,write;

reg[7:0]   dataout;   //不要这样定义端口的位宽！！

2，端口的I/O与数据类型的关系：

    端口的I/O           端口的数据类型

                       module内部     module外部

      input              wire          wire或reg

      output         wire或reg           wire

      inout            wire              wire

3，assign语句的左端变量必须是wire；直接用"=“给变量赋值时左端变量必须是reg！

Example:

assign a=b; //a必须被定义为wire！！

********

begin

   a=b; //a必须被定义为reg！

end

  VHDL中STD_LOGIC_VECTOR和INTEGER的区别

例如A是INTEGER型，范围从0到255；B是STD_LOGIC_VECTOR，定义为8位。A累加到255时，再加1就一直保持255不变，不会自动反转到0，除非令其为0；而B累加到255时，再加1就会自动反转到0。所以在使用时要特别注意！

以触发器为例说明描述的规范性

1，无置位/清零的时序逻辑

    always @( posedge CLK)

       begin

       Q<=D;

       end

2，有异步置位/清零的时序逻辑

  异步置位/清零是与时钟无关的，当异步置位/清零信号到来时，触发器的输出立即  被置为1或0，不需要等到时钟沿到来才置位/清零。所以，必须要把置位/清零信号  列入always块的事件控制表达式。

    always @( posedge CLK or negedge RESET)

       begin

       if (!RESET)

          Q=0;

       else

          Q<=D;

       end

3，有同步置位/清零的时序逻辑

   同步置位/清零是指只有在时钟的有效跳变时刻置位/清零，才能使触发器的输出分   别转换为1或0。所以，不要把置位/清零信号列入always块的事件控制表达式。但是   必须在always块中首先检查置位/清零信号的电平。

    always @( posedge CLK )

    begin

       if (!RESET)

          Q=0;

       else

          Q<=D;

       end

结构规范性

在整个芯片设计项目中，行为设计和结构设计的编码是最重要的一个步骤。 它对逻辑综合和布线结果、时序测定、校验能力、测试能力甚至产品支持 都有重要的影响。考虑到仿真器和真实的逻辑电路之间的差异，为了有效的

进行仿真测试：

  1，避免使用内部生成的时钟

    内部生成的时钟称为门生时钟（gated clock）。如果外部输入时钟和门生时钟同时驱动，    则不可避免的两者的步调不一致，造成逻辑混乱。而且，门生时钟将会增加测试的难度    和时间。

  2，绝对避免使用内部生成的异步置位/清零信号

    内部生成的置位/清零信号会引起测试问题。使某些输出信号被置位或清零，无法正常    测试。

3，避免使用锁存器

    锁存器可能引起测试问题。对于测试向量自动生成（ATPG），    为了使扫描进行，锁存器需要置为透明模式（transparent mode），    反过来，测试锁存器需要构造特定的向量，这可非同一般。

  4，时序过程要有明确的复位值

    使触发器带有复位端，在制造测试、ATPG以及模拟初始化时，可以对整个电路进行    快速复位。

  5，避免模块内的三态/双向

    内部三态信号在制造测试和逻辑综合过程中难于处理.



近日读 J.Bhasker 的 , 受益匪浅,理清了不少基础电路知识 , 记下一些 tips :

1. 过程赋值(always 中触发赋值)的变量,可能会被综合成连线 或触发器 或锁存器.

2.综合成锁存器的规则:

a. 变量在条件语句(if 或case)中,被赋值.

b. 变量未在条件语句的所有分支中被赋值.

c. 在always语句多次调用之间需要保持变量值 .

以上三个条件必须同时满足.

3.综合成触发器的规则:

变量在时钟沿的控制下被赋值。

例外情况：变量的赋值和引用都仅出现在一条always语句中，则该变量被视为中

间变量而不是触发器。

4. 对于无时钟事情的always语句（即组合逻辑建模），其时间表应包括该alwa语

句引用的所有变量，否则会出现RTL与Netlist的不一致

芯片外部引脚很多都使用inout类型的，为的是节省管腿。一般信号线用做总线等双向数据传输的时候就要用到INOUT类型了。就是一个端口同时做输入和输出。 inout在具体实现上一般用三态门来实现。三态门的第三个状态就是高阻’Z’。 当inout端口不输出时，将三态门置高阻。这样信号就不会因为两端同时输出而出错了,更详细的内容可以搜索一下三态门tri-state的资料.

1 使用inout类型数据,可以用如下写法:

inout data_inout;

input data_in;

reg data_reg;//data_inout的映象寄存器

reg link_data;

assign data_inout=link_data?data_reg:1’bz;//link_data控制三态门

//对于data_reg,可以通过组合逻辑或者时序逻辑根据data_in对其赋值.通过控制link_data的高低电平,从而设置data_inout是输出数据还是处于高阻态,如果处于高阻态,则此时当作输入端口使用.link_data可以通过相关电路来控制.

2 编写测试模块时,对于inout类型的端口,需要定义成wire类型变量,而其它输入端口都定义成reg类型,这两者是有区别的.

当上面例子中的data_inout用作输入时,需要赋值给data_inout,其余情况可以断开.此时可以用assign语句实现:assign data_inout=link?data_in_t:1’bz;其中的link ,data_in_t是reg类型变量,在测试模块中赋值.

另外,可以设置一个输出端口观察data_inout用作输出的情况:

Wire data_out;

Assign data_out_t=(!link)?data_inout:1’bz;

else，in RTL

inout use in top module(PAD)

dont use inout(tri) in sub module

也就是说，在内部模块最好不要出现inout，如果确实需要，那么用两个port实现，到顶层的时候再用三态实现。理由是：在非顶层模块用双向口的话，该双向口必然有它的上层跟它相连。既然是双向口，则上层至少有一个输入口和一个输出口联到该双向口上，则发生两个内部输出单元连接到一起的情况出现，这样在综合时往往会出错。

对双向口，我们可以将其理解为2个分量：一个输入分量，一个输出分量。另外还需要一个控制信号控制输出分量何时输出。此时，我们就可以很容易地对双向端口建模。

例子：

CODE:

module dual_port (

…

inout_pin,

…

);

inout inout_pin;

wire inout_pin;

wire input_of_inout;

wire output_of_inout;

wire out_en;

assign input_of_inout = inout_pin;

assign inout_pin = out_en ? output_of_inout : 高阻;

endmodule

可见，此时input_of_inout和output_of_inout就可以当作普通信号使用了。

在仿真的时候，需要注意双向口的处理。如果是直接与另外一个模块的双向口连接，那么只要保证一个模块在输出的时候，另外一个模块没有输出（处于高阻态）就可以了。

如果是在ModelSim中作为单独的模块仿真，那么在模块输出的时候，不能使用force命令将其设为高阻态，而是使用release命令将总线释放掉

很多初学者在写testbench进行仿真和验证的时候，被inout双向口难住了。仿真器老是提示错误不能进行。下面是我个人对inout端口写testbench仿真的一些总结，并举例进行说明。在这里先要说明一下inout口在testbench中要定义为wire型变量。

先假设有一源代码为：

module xx(data_inout , …);

inout data_inout;

…

assign data_inout=(! link)?datareg:1’bz;

endmodule

方法一：使用相反控制信号inout口，等于两个模块之间用inout双向口互连。这种方法要注意assign 语句只能放在initial和always块内。

module test();

wire data_inout;

reg data_reg;

reg link;

initial begin

…

end

assign data_inout=link?data_reg:1’bz;

endmodule

方法二：使用force和release语句，但这种方法不能准确反映双向端口的信号变化，但这种方法可以反在块内。

module test();

wire data_inout;

reg data_reg;

reg link;

#xx;        //延时

force data_inout=1’bx;           //强制作为输入端口

…

#xx;

release data_inout;          //释放输入端口

endmodule

很多读者反映仿真双向端口的时候遇到困难，这里介绍一下双向端口的仿真方法。一个典型的双向端口如图1所示。



其中inner_port与芯片内部其他逻辑相连，outer_port为芯片外部管脚，out_en用于控制双向端口的方向，out_en为1时，端口为输出方向，out_en为0时，端口为输入方向。



用Verilog语言描述如下：

module bidirection_io(inner_port,out_en,outer_port);

input out_en;

inout[7:0] inner_port;

inout[7:0] outer_port;

assign outer_port=(out_en1)?inner_port:8’hzz;

assign inner_port=(out_en0)?outer_port:8’hzz;

endmodule



用VHDL语言描述双向端口如下：

library ieee;

use IEEE.STD_LOGIC_1164.ALL;

entity bidirection_io is

port ( inner_port : inout std_logic_vector(7 downto 0);

out_en : in std_logic;

outer_port : inout std_logic_vector(7 downto 0) );

end bidirection_io;

architecture behavioral of bidirection_io is

begin

outer_port<=inner_port when out_en=‘1’ else (OTHERS=>‘Z’);

inner_port<=outer_port when out_en=‘0’ else (OTHERS=>‘Z’);

end behavioral;



仿真时需要验证双向端口能正确输出数据，以及正确读入数据，因此需要驱动out_en端口，当out_en端口为1时，testbench驱动inner_port端口，然后检查outer_port端口输出的数据是否正确；当out_en端口为0时，testbench驱动outer_port端口，然后检查inner_port端口读入的数据是否正确。由于inner_port和outer_port端口都是双向端口（在VHDL和Verilog语言中都用inout定义），因此驱动方法与单向端口有所不同。

验证该双向端口的testbench结构如图2所示。



这是一个self-checking testbench，可以自动检查仿真结果是否正确，并在Modelsim控制台上打印出提示信息。图中Monitor完成信号采样、结果自动比较的功能。

testbench的工作过程为

1）out_en=1时，双向端口处于输出状态，testbench给inner_port_tb_reg信号赋值，然后读取outer_port_tb_wire的值，如果两者一致，双向端口工作正常。

2）out_en=0时，双向端口处于输如状态，testbench给outer_port_tb_reg信号赋值，然后读取inner_port_tb_wire的值，如果两者一致，双向端口工作正常。



用Verilog代码编写的testbench如下，其中使用了自动结果比较，随机化激励产生等技术。



`timescale 1ns/10ps

module tb();

reg[7:0] inner_port_tb_reg;

wire[7:0] inner_port_tb_wire;

reg[7:0] outer_port_tb_reg;

wire[7:0] outer_port_tb_wire;

reg out_en_tb;

integer i;



initial

begin

out_en_tb=0;

inner_port_tb_reg=0;

outer_port_tb_reg=0;

i=0;

repeat(20)

begin

#50

i=$random;</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">ou{t}_e{n}_{t}b=i[0];//randomizeou{t}_e{n}_{t}b</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">inne{r}_{p}or{t}_t{b}_{r}eg=$random; //randomize data

outer_port_tb_reg=KaTeX parse error: Expected 'EOF', got '#' at position 4133: …height:19.5px">#̲1;
display(”\n **** time=%t ****",$time);</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">$display(“OK! out_en=%d”,out_en_tb);

$display("OK!oute{r}_{p}or{t}_t{b}_{w}ire=<spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">oute{r}_{p}or{t}_t{b}_{w}ire,inne{r}_{p}or{t}_t{b}_{w}ire);</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">end</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">else</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">begin</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">$display("\n **** time=%t ***",$time);</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">$display(“ERROR! out_en=%d”,out_en_tb);

$display("ERROR!oute{r}_{p}or{t}_t{b}_{w}ire!=inne{r}_{p}or{t}_t{b}_{w}ire");</span><brstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px"><spanstyle="color:rgb(75,75,75);font-family:Verdana,Geneva,Arial,Helvetica,sans-serif;font-size:13px;line-height:19.5px">$display(“ERROR! outer_port_tb_wire=%d, inner_port_tb_wire=%d”,

outer_port_tb_wire,inner_port_tb_wire);

end

end

endmodule



今天重新回顾了一下阻塞赋值和非阻塞赋值的概念，感觉又有所收获。 

一、特点：

    阻塞赋值：1、RHS的表达式计算和LHS的赋值更新，这两个动作之间不能插入其他动作，即所谓计算完毕，立即更新。

             2、所谓阻塞就是指在一个“begin…end”块中的多个阻塞赋值语句内，只有上一句完全执行完毕后，才会执行下一语句，否则阻塞程序的执行。

    非阻塞赋值：RHS的表达式计算和LHS的赋值更新分两个节拍执行，首先，应该是RHS的表达式计算，得到新值后并不立即赋值，而是放在事件队列中等待，直到

              当前仿真时刻的后期才执行（原因下文会提到）。

二、Verilog的分层事件队列：

    在Verilog中，事件队列可以划分为5个不同的区域，不同的事件根据规定放在不同的区域内，按照优先级的高低决定执行的先后顺序，下表就列出了部分Verilog分层事件队列。其中，活跃事件的优先级最高（最先执行），而监控事件的优先级最低，而且在活跃事件中的各事件的执行顺序是随机的（注：为方便起见，在一般的仿真器中，对同一区域的不同事件是按照调度的先后关系执行的）。

   



当前仿真

时间事件



活跃事件         阻塞赋值，非阻塞赋值的RHS计算……



非活跃事件



显式0延时的阻塞赋值……









非阻塞赋值更新事件



由非阻塞语句产生的一个非阻塞赋值更新事件，并被调入当前仿真时刻。







监控事件



$monitor和$strobe等系统任务





将来仿真

时间事件                  被调度到将来仿真时间的事件



三、结论：

    由上表就可以知道，阻塞赋值属于活跃事件，会立刻执行，这就是阻塞赋值“计算完毕，立刻更新”的原因。此外，由于在分层事件队列中，只有将活跃事件中排在前面的事件调出，并执行完毕后，才能够执行下面的事件，这就可以解释阻塞赋值的第二个特点。

    同样是由上表知，非阻塞赋值的RHS计算属于活跃事件，而非阻塞赋值更新事件排在非活跃事件之后，因此只有仿真队列中所有的活跃事件和非活跃事件都执行完毕后，才轮到非阻塞赋值更新事件，这就是非阻塞赋值必须分两拍完成的原因。



以上就是我今天的读书笔记，写得仓促，如有不对，敬请指出 。





一. 强调Verilog代码编写风格的必要性。

强调Verilog代码编写规范，经常是一个不太受欢迎的话题，但却是非常有必要的。

每个代码编写者都有自己的编写习惯，而且都喜欢按照自己的习惯去编写代码。与自己编写风格相近的代码，阅读起来容易接受和理解。相反和自己编写风格差别较大的代码，阅读和接受起来就困难一些。

曾有编程大师总结说，一个优秀的程序员，能维护的代码长度大约在1万行数量级。代码的整洁程度，很大程度上影响着代码的维护难度。

遵循代码编写规范书写的代码，很容易阅读、理解、维护、修改、跟踪调试、整理文档。相反代码编写风格随意的代码，通常晦涩、凌乱，会给开发者本人的调试、修改工作带来困难，也会给合作者带来很大麻烦。

（实际上英文Coding Style有另一层涵义，更偏重的是，某一个电路，用那一种形式的语言描述，才能将电路描述得更准确，综合以后产生的电路更合理。本文更偏重的是，编写Verilog代码时的书写习惯。）



二. 强调编写规范的宗旨。

缩小篇幅

提高整洁度

便于跟踪、分析、调试

增强可读性，帮助阅读者理解

便于整理文档

便于交流合作

三. 变量及信号命名规范。

1. 系统级信号的命名。

系统级信号指复位信号，置位信号，时钟信号等需要输送到各个模块的全局信号；系统信号以字符串Sys开头。

2. 低电平有效的信号后一律加下划线和字母n。如：SysRst_n；FifoFull_n；

3. 经过锁存器锁存后的信号，后加下划线和字母r，与锁存前的信号区别。如CpuRamRd信号，经锁存后应命名为CpuRamRd_r。

低电平有效的信号经过锁存器锁存后，其命名应在_n后加r。如CpuRamRd_n信号，经锁存后应命名为CpuRamRd_nr

多级锁存的信号，可多加r以标明。如CpuRamRd信号，经两级触发器锁存后，应命名为CpuRamRd_rr。

4. 模块的命名。

在系统设计阶段应该为每个模块进行命名。命名的方法是，将模块英文名称的各个单词首字母组合起来，形成3到5个字符的缩写。若模块的英文名只有一个单词，可取该单词的前3个字母。各模块的命名以3个字母为宜。例如：

Arithmatic Logical Unit模块，命名为ALU。

Data Memory Interface模块，命名为DMI。

Decoder模块，命名为DEC。



5. 模块之间的接口信号的命名。

所有变量命名分为两个部分，第一部分表明数据方向，其中数据发出方在前，数据接收方在后，第二部分为数据名称。

两部分之间用下划线隔离开。

第一部分全部大写，第二部分所有具有明确意义的英文名全部拼写或缩写的第一个字母大写，其余部分小写。

举例：CPUMMU_WrReq，下划线左边是第一部分，代表数据方向是从CPU模块发向存储器管理单元模块（MMU）。下划线右边Wr为Write的缩写，Req是Request的缩写。两个缩写的第一个字母都大写，便于理解。整个变量连起来的意思就是CPU发送给MMU的写请求信号。

模块上下层次间信号的命名也遵循本规定。

若某个信号从一个模块传递到多个模块，其命名应视信号的主要路径而定。

6. 模块内部信号：

模块内部的信号由几个单词连接而成，缩写要求能基本表明本单词的含义；

单词除常用的缩写方法外（如：Clock->Clk, Write->Wr, Read->Rd等），一律取该单词的前几个字母（ 如：Frequency->Freq, Variable->Var 等）；

每个缩写单词的第一个字母大写；

若遇两个大写字母相邻，中间添加一个下划线（如DivN_Cntr）；

举例：SdramWrEn_n；FlashAddrLatchEn;

四. 编码格式规范。

1. 分节书写，各节之间加1到多行空格。如每个always,initial语句都是一节。每节基本上完成一个特定的功能，即用于描述某几个信号的产生。在每节之前有几行注释对该节代码加以描述，至少列出本节中描述的信号的含义。

2. 行首不要使用空格来对齐，而是用Tab键，Tab键的宽度设为4个字符宽度。行尾不要有多余的空格。

3. 注释。

使用//进行的注释行以分号结束；

使用/ /进行的注释，/和/各占用一行，并且顶头；

例：

// Edge detector used to synchronize the input signal；

4. 空格的使用：

不同变量，以及变量与符号、变量与括号之间都应当保留一个空格。

Verilog关键字与其它任何字符串之间都应当保留一个空格。如：

Always @ (……)

使用大括号和小括号时，前括号的后边和后括号的前边应当留有一个空格。

逻辑运算符、算术运算符、比较运算符等运算符的两侧各留一个空格，与变量分隔开来；单操作数运算符例外，直接位于操作数前，不使用空格。

使用//进行的注释，在//后应当有一个空格；注释行的末尾不要有多余的空格。

例：

assign SramAddrBus = { AddrBus[31:24], AddrBus[7:0] };

assign DivCntr[3:0] = DivCntr[3:0] + 4’b0001;

assign Result = ~Operand;



5. 同一个层次的所有语句左端对齐；Initial、always等语句块的begin关键词跟在本行的末尾，相应的end关键词与Initial、always对齐；这样做的好处是避免因begin独占一行而造成行数太多；

例：

always @ ( posedge SysClk or negedge SysRst ) begin

if( !SysRst ) DataOut <= 4’b0000;

else if( LdEn ) begin

DataOut <= DataIn;

End

else DataOut <= DataOut + 4’b0001;

end

6. 不同层次之间的语句使用Tab键进行缩进，每加深一层缩进一个Tab；

8. 在endmodule，endtask，endcase等标记一个代码块结束的关键词后面要加上一行注释说明这个代码块的名称；

9. 在task名称前加tsk以示标记。在function的名称前加func以示标记。例如：

task tskResetSystem；

……

endtask //of tskResetSystem

五．小结：

以上列出的代码编写规范无法覆盖代码编写的方方面面，还有很多细节问题，需要在实际编写过程中加以考虑。并且有些规定也不是绝对的，需要灵活处理。并不是律条，但是在一个项目组内部、一个项目的进程中，应该有一套类似的代码编写规范来作为约束。

总的方向是，努力写整洁、可读性好的代码





二．reg型

在“always”块内被赋值的每一个信号都必须定义成reg型。

reg型数据的缺省初始值是不定值。

reg型只表示被定义的信号将用在“always”块内，理解这一点很重要。并不是说reg型信号一定是寄存器或触发器的输出。虽然reg型信号常常是寄存器或触发器的输出，但并不一定总是这样。



三．memory型

memory型数据是通过扩展reg型数据的地址范围来生成的。其格式如下：



reg [n-1:0] 存储器名[m-1:0]；

或        reg [n-1:0] 存储器名[m:1]；



在这里，reg[n-1:0]定义了存储器中每一个存储单元的大小，即该存储单元是一个n位的寄存器。存储器名后的[m-1:0]或[m:1]则定义了该存储器中有多少个这样的寄存器。

reg [7:0] mema[255：0];



这个例子定义了一个名为mema的存储器，该存储器有256个8位的存储器。该存储器的地址范围是0到255。注意：对存储器进行地址索引的表达式必须是常数表达式。

尽管memory型数据和reg型数据的定义格式很相似，但要注意其不同之处。如一个由n个1位寄存器构成的存储器组是不同于一个n位的寄存器的。见下例：



reg [n-1:0] rega;    //一个n位的寄存器

reg mema [n-1:0];    //一个由n个1位寄存器构成的存储器组



一个n位的寄存器可以在一条赋值语句里进行赋值，而一个完整的存储器则不行。见下例：



rega =0;        //合法赋值语句

mema =0;        //非法赋值语句



如果想对memory中的存储单元进行读写操作，必须指定该单元在存储器中的地址。下面的写法是正确的。

mema[3]=0;        //给memory中的第3个存储单元赋值为0。

3.3.1.基本的算术运算符



在Verilog HDL语言中，算术运算符又称为二进制运算符，共有下面几种：

1)      + (加法运算符,或正值运算符,如 rega＋regb，＋3)

2)      －(减法运算符，或负值运算符，如 rega－3,－3)

3)      ×(乘法运算符，如rega3)

4)      / (除法运算符，如5/3)

5)      % (模运算符，或称为求余运算符，要求％两侧均为整型数据。如7％3的值为1)



注意：        在进行算术运算操作时，如果某一个操作数有不确定的值x，则整个结果也为不定值x。

1)      ~          //取反

2)      &          //按位与

3)      |          //按位或

4)      ^          //按位异或

5)      ^~         //按位同或(异或非)

在Verilog HDL语言中存在三种逻辑运算符:

1)      && 逻辑与

2)      || 逻辑或

3)      ! 逻辑非



关系运算符共有以下四种：



a < b       a小于b

a > b       a大于b

a <= b      a小于或等于b

a >= b      a大于或等于b



3.3.5.等式运算符

3.3.6.移位运算符

3.3.7.位拼接运算符(Concatation)

3.3.10.关键词

在Verilog HDL中，所有的关键词是事先定义好的确认符,用来组织语言结构。关键词是用小写字母定义的,因此在编写原程序时要注意关键词的书写,以避免出错。下面是Verilog HDL中使用的关键词(请参阅附录：Verilog语言参考手册)：



always， and， assign，begin，buf，bufif0，bufif1，case，casex，casez，cmos，deassign，default，defparam，disable，edge，else，end，endcase，endmodule，endfunction，endprimitive,
endspecify, endtable， endtask， event， for， force， forever， fork， function，highz0， highz1, if，initial, inout, input，integer，join,large，macromodule，medium，module，nand，negedge，nmos，nor，not，notif0，notifl, or, output, parameter, pmos, posedge, primitive, pull0,
pull1, pullup, pulldown, rcmos, reg, releses, repeat, mmos, rpmos, rtran, rtranif0,rtranif1,scalared,small，specify，specparam，strength，strong0, strong1, supply0, supply1, table, task, time, tran, tranif0, tranif1, tri, tri0, tri1, triand, trior， trireg，vectored，wait，wand，weak0，weak1，while，
wire，wor, xnor， xor







(1).非阻塞(Non_Blocking)赋值方式( 如 b <= a; )

1)      块结束后才完成赋值操作。

2)      b的值并不是立刻就改变的。

3)      这是一种比较常用的赋值方法。（特别在编写可综合模块时）



(2).阻塞(Blocking)赋值方式( 如 b = a; )

1)      赋值语句执行完后,块才结束。

2)      b的值在赋值语句执行完后立刻就改变的。

3)      可能会产生意想不到的结果。



一．顺序块

顺序块有以下特点：

1)      块内的语句是按顺序执行的，即只有上面一条语句执行完后下面的语句才能执行。

2)      每条语句的延迟时间是相对于前一条语句的仿真时间而言的。

3)      直到最后一条语句执行完，程序流程控制才跳出该语句块。

顺序块的格式如下：

begin

语句1;

语句2;

…

语句n;

end

其中：

        块名即该块的名字，一个标识名。其作用后面再详细介绍。

        块内声明语句可以是参数声明语句、reg型变量声明语句、integer型变量声明语句、real型变量声明语句。



二． 并行块

并行块有以下四个特点：

1)      块内语句是同时执行的，即程序流程控制一进入到该并行块，块内语句则开始同时并行地执行。

2)      块内每条语句的延迟时间是相对于程序流程控制进入到块内时的仿真时间的。

3)      延迟时间是用来给赋值语句提供执行时序的。

4)      当按时间时序排序在最后的语句执行完后或一个disable语句执行时，程序流程控制跳出该程序块。



并行块的格式如下：

fork

语句1;

语句2;

…

语句n;

join

其中：

•        块名即标识该块的一个名字，相当于一个标识符。

•        块内说明语句可以是参数说明语句、reg型变量声明语句、integer型变量声明语句、real型变量声明语句、time型变量声明语句、事件(event)说明语句。



在fork_join块内，各条语句不必按顺序给出，因此在并行块里，各条语句在前还是在后是无关紧要的。见下例：



三． 块名

在VerilgHDL语言中，可以给每个块取一个名字，只需将名字加在关键词begin或fork后面即可。这样做的原因有以下几点。

1)      这样可以在块内定义局部变量，即只在块内使用的变量。

2)      这样可以允许块被其它语句调用，如被disable语句。

3)      在Verilog语言里，所有的变量都是静态的，即所有的变量都只有一个唯一的存储地址，因此进入或跳出块并不影响存储在变量内的值。

基于以上原因，块名就提供了一个在任何仿真时刻确认变量值的方法。











casez语句用来处理不考虑高阻值z的比较过程，casex语句则将高阻值z和不定值都视为不必关心的情况。



如果用到if语句，最好写上else项。如果用case语句，最好写上default项。遵循上面两条原则，就可以避免发生这种错误，使设计者更加明确设计目标，同时也增强了Verilog程序的可读性。

3.6.循环语句



在Verilog HDL中存在着四种类型的循环语句，用来控制执行语句的执行次数。



1)    forever        连续的执行语句。

2)    repeat        连续执行一条语句 n 次。

3)    while        执行一条语句直到某个条件不满足。如果一开始条件即不满足(为假)，

             则语句一次也不能被执行。

4)    for通过以下三个步骤来决定语句的循环执行。

a)      先给控制循环次数的变量赋初值。

b)      判定控制循环的表达式的值，如为假则跳出循环语句，如为真则执行指定的语句后，转到第三步。

c) 





＃1:当为时序逻辑建模，使用“非阻塞赋值”。

＃2:当为锁存器（latch）建模，使用“非阻塞赋值”。

＃3:当用always块为组合逻辑建模，使用“阻塞赋值”

＃4:当在同一个always块里面既为组合逻辑又为时序逻辑建模，使用“非阻塞赋值”。

＃5:不要在同一个always块里面混合使用“阻塞赋值”和“非阻塞赋值”。

＃6:不要在两个或两个以上always块里面对同一个变量进行赋值。

＃7:使用$strobe以显示已被“非阻塞赋值”的值。

＃8:不要使用＃0延迟的赋值。

#9:在VERILOG语法中， if…else if … else 语句是有优先级的，一般说来第一个IF的优先级最高，最后一个ELSE的优先级最低。如果描述一个编码器，在XILINX的XST综合参数就有一个关于优先级编码器硬件原语句的选项Priority
Encoder Extraction. 而CASE语句是"平行"的结构，所有的CASE的条件和执行都没有“优先级”。而建立优先级结构会消耗大量的组合逻辑，所以如果能够使用CASE语句的地方，尽量使用CASE替换IF…ELSE结构。

#10:XILINX的底层可编程硬件资源叫SLICE，由2个FF和2个LUT组成。 FF触发器  LUT查找表

ALTERA的底层可编程硬件资源叫LE,  由1个FF和1个LUT组成。

#11:慎用锁存器(latch)，同步时序设计要尽量避免使用锁存器，综合出非目的性latch的主要原因在于不完全的条件判断句。另外一种情况是设计中有组合逻辑的反馈环路(combinatorial feedback loops)。

#12:状态机的一般设计原则，Biary, gray-code 编码使用最少的触发器，较多的组合逻辑。而one-hot编码反之。所以CPLD多使用GRAY-CODE, 而FPGA多使用ONE-HOT编码。另一方面，小型设计使用GRAY-CODE和BINARY编码更有效，而大型状态机使用ONE-HOT更有效。

#13:业界主流CPLD产品是lattice的LC4000系列和ALTERA的MAX3000系列。

#14:复位使初始状态可预测，防止出现禁用状态。FPGA 和CPLD 的复位信号采用异步低电平有效信号，连接到其全局复位输入端，使用专用路径通道,复位信号必须连接到FPGA 和CPLD 的全局复位管脚。。

#15:不要用时钟或复位信号作数据或使能信号，也不能用数据信号作为时钟或复位信号，否则HDL 综合时会出现时序验证问题。信号穿过时钟的两半个周期时，要在前后分别取样；防止出现半稳定状态。

#16：fpga设计中 不要使用门时钟（don’t use gated clock）。时钟信号必须连接到全局时钟管脚上。

#17：不要使用内部三态信号，否则增加功耗。

#18：只使用同步设计，不要使用延时单元。

#19：避免使用负延触发的双稳态多谐振荡器（flip flop）。

#20:不要使用信号和变量的默认值（或初始值），用复位脉冲初始化

信号和变量。

#21:不要在代码中使用buffer 类型的端口读取输出数据；要使用out 类型，再增加另外变量或信号，以获取输出值。

这是因为buffer 类型的端口不能连接到其他类型的端口上，因此buffer 类型就会在整个设计的端口中传播下去。

#22:对变量要先读后写；如果先写后读，就会产生长的组合逻辑和锁存器（或寄存器）。这是因为变量值是立即获取的。

#23:在组合逻辑进程中，其敏感向量标中要包含所有要读取得信号；这是为了防止出现不必要的锁存器。



近期，在stephen Brown的一本书数字逻辑基础与verilog设计一书中看到关于触发器电路的时序分析。以前一直没有搞明白这个问题，现在觉得豁然开朗。怕忘记了，特地摘抄与此与edacn网友分享。

触发器电路的时序分析：

图7-84给出了一个使用D触发器的简单电路。我们想要计算该电路能正常工作的最大的时钟频率Fmax，并且想确定该电路的保持时间是否不够长。在技术文献中，这种类型的电路分析通常叫做时序分析。假设该触发器的时序参数为：tsu=0.6ns，th=0.4ns，0.8ns<=tcQ<=1.0ns。给tcq参数规定一个范围是因为延迟参数分布在一定范围内，这样处理是现成集成电路芯片常用的方法。为了计算最小的时钟信号周期Tmin=1/Fmax，我们必须考虑在触发器中从开始到结束的所有路径。在这个简单的电路中，只有一条这样的路径，这条路径开始于数据被时钟信号的正跳变沿加载进入触发器，经过tcQ的延迟后传播到Q的输出端，再传播通过非门，同时必须满足D输入端的建立时间要求。因此：

Tmin=tcQ+tNOT+tsu

由于我们关注的只是计算出最长的延迟时间，所以应该用tcQ的最大值。为了计算出tNOT，我们将假设通过任何逻辑门的延迟都可以用1+0.1k进行计算，其中k是该门的输入信号的个数。对非门而言，k=1，因此得到如下Tmin和Fmax的值：Tmin=1.0+1.1+0.6=2.7ns

Fmax=1/2.7ns=370.37MHz

当然，有必要检查电路中的保持时间是否违反规定。在这种场合，我们必须核查从时钟信号的正跳变沿到D输入值改变的最短延迟。该延迟由tcQ+tNOT=0.8+1.1=1.9ns给定。因为1.9ns>0.4ns，所以保持时间够长，没有违反规定。再举一个触发器电路时序分析的例子，请考虑图7-85所示的计数器电路。假设所用的触发器的时序参数与图7-84中用过的触发器相同，请计算该电路能正常运行的最高频率。再次假设通过逻辑门的传播延迟可以用1+0.1k来计算。

在这个电路中，存在着四个触发器从开始到结束的许多路径。最长的路径从触发器Q0起到触发器Q3结束。在某个电路中最长的路径成为关键路径。关键路径的延迟包括触发器Q0的时钟信号到Q的延迟、通过三个与门的传播延迟和一个异或门的延迟。我们还必须考虑触发器Q3的建立时间。因此，得到

Tmin=tcQ+3(tAND)+tXOR+tsu

用tcQ的最大值，得到

Tmin=1.0+3(1.2)+1.2+0.6=6.4ns

Fmax=1/6.4ns=156.25MHz

该电路的最短路径是从每个触发器通过异或门反馈到该触发器本身的输入端。沿每个这样路径的最小延迟为tcQ+tXOR=0.8+1.2=2.0ns。因为2.0ns>th=0.4ns，因此保持时间足够长，没有违反规定。

       在上面的分析中，假设时钟信号同时到达所有四个触发器。我们现在将重复这个分析，假设时钟信号同时到达触发器Q0,Q1,Q2，但到达触发器Q3有一些延迟。始终到达不同的触发器之间的时间差称为时钟偏差(clock skew)，记作tskew，时钟偏差可以由许多原因引起。

       在图7-85中，电路的关键路径是从触发器Q0起到触发器Q3。然而，Q3的时钟偏差使得这个延迟减少，因为时钟偏差在数据被加载进该触发器前提供了附加的时间。如果考虑增加1.5ns的时钟偏差，则从触发器Q0到触发器Q3的路径延迟由tcQ+3(tAND)+tXOR+tsu-tskew=6.4-1.5ns=4.9ns给定。该电路现在还存在一个不同的关键路径，该路径从触发器Q0起到触发器Q2结束。这条路径的延迟为

Tmin=tcQ+2(tAND)+tXOR+tsu=1.0+2(1.2)+1.2+0.6ns=5.2ns

Fmax=1/5.2ns=192.31MHz

       在这种场合，时钟偏差导致电路的最高时钟频率提高。但是，如果时钟偏差是负的，即触发器Q3的时钟到达时间比其他触发器更早一些，则会造成该电路的最高时钟频率Fmax降低。

       因为数据加载到触发器Q3被时钟偏差延迟了，所以对所有起始于Q0，Q1，Q2而以Q3为结束点的路径，都会产生使触发器Q3的保持时间需要增加到th+tskew的影响。在该电路中，这种最短的路径是从触发器Q2到Q3的路径，其延迟时间为TcQ+tAND+tXOR=0.8+1.2+1.2=3.2ns。因为3.2ns>th+tskew=1.9ns，所以保持时间足够长，没有违反规定。

如果对时钟偏差值tskew>=3.2-th=2.8ns，重复以上保持时间的分析，则会出现保持时间不够的情况。当tskew>=2.8ns时，该电路将不可能在任何频率下可靠地运行。由于时钟偏差的存在会引起电路时序问题，所以好的电路设计方法必须保证时钟信号到达所有触发器的偏差尽可能小。

最后是我的总结：确定最小周期是找关键路径即最长路径。确定Th是否违例是找最短路径。最短路径要大于Th。如果有Tskew的情况则要大于Th+Tskew（有skew的寄存器为最短路径的终点的时候）

还有就是我对有Tskew的情况的时候为什么防止违例要最短路径>Th+Tskew。因为Q0，Q1和Q2时钟比Q3早，以他们为起点的路径已经开始走了一段时间后Q3的时钟才到才开始打入数据。所以保持时间上要加上这段skew



ISE 约束文件的基本操作