博主是先前学习过verilog，过渡到sv较为简单

====================================

systemverilog 以.sv文件结尾

sv中的操作符：

== ！= ： 这两种表示逻辑符合与逻辑不符 ， 如若其中存在有x或者z，那么得到的结果 则是z

=== ！== ： 严格匹配x与z，但此条语句不可综合。

==？ ！=？ ： 在其中x与z为无关项，若右操作数为常数，则可综合。

加入延迟：

#(n timedelay_uint) 加入延迟事件

#(min：typical：max，min：typical：max，min：typical：max) 加入上升延迟与下降延迟，还有截止延迟

编写的技巧：

使用parameter语句添加参数，使模块参数化，，使得模块可以重复使用。实现代码复用。

关于sv的testbench的一个发现：

module TestAnd2；

wire a , b , c ;

And g1(c,a,b);

intial begin

a = ‘0;

b = ‘0;

#100ps a = ‘1;

#50ps b = ‘1;

end

endmodule

testbench中的wire变量类型可以直接通过赋值语句赋值了，而不再需要写成 output reg 的类型了。

实在是一大惊奇的发现！！！

同时sv可以使得延迟的事件带有时间单位，并且在实例化一个module时，若其端口名与链接名是一致的，

那么则可使用module_name(.*)的简写方式

sv的数据类型：

char：一个两态的有符号变量，它与C语言中的char数据类型相同，可以是一个8位整数(ASCII)或short int(Unicode)；

int：一个两态的有符号变量，它与C语言中的int数据类型相似，但被精确地定义成32位；

shortint：一个两态的有符号变量，被精确地定义成16位；

longint：一个两态的有符号变量，它与C语言中的long数据类型相似，但被精确地定义成64位；

byte：一个两态的有符号变量，被精确地定义成8位；

bit：一个两态的可以具有任意向量宽度的无符号数据类型，可以用来替代Verilog的reg数据类型；

logic：一个四态的可以具有任意向量宽度的无符号数据类型，可以用来替代Verilog的线网或reg数据类型，但具有某些限制；

shortreal：一个两态的单精度浮点变量，与C语言的float类型相同；

void：表示没有值，可以定义成一个函数的返回值，与C语言中的含义相同。

Combine Logic：

always_comb 语句描述：组合逻辑专用的描述方式，通过延迟赋值语句来使用。

同时verilog支持int型的自动转换，使得结果，但需要注意这可能会带来一些错误。所以尽量不要使用这种特性。

casez与casex： casez忽略z，将其看为？；而casex忽略x，z，将其看为？

/*******************************************************************

作为一个严谨的电子工程师，需要坚决不用casex，casez

避免仿真前后不一致的可能！！！！！！！！！！！！！

*******************************************************************/

在描述组合逻辑的情况下，使用casez可能会引来overlap的问题。 所以需要使用unique语句来比避免重复。

另外与其相近的的语句是priority，它一般结合if，elseif，else使用，

确保至少分支有一个语句是执行了的，它默认存在有优先级。

下面是关于 Ripple Adder的例子 ：

基本的全加器模型：

module fulladder( output logic sum , cout ,

input logic a , b , cin );

always_comb begin

{ cout , sum } = a + b + cin ;

end

endmodule

最后做出的级联加法器：

module ripple #( parameter N = 4 )

( output logic [N-1:0] sum , output logic cout ,

input logic [N-1:0] A , B , input logic cin );

logic [N-1:1] ca ;

genvar i ;

fulladder f0(sum[0], ca[1] , A[0] , B[0] , cin );

generate for( i = 0 ; i < N-1 ; i++ )

begin: f_loop

full_adder fi(sum[i],ca[i+1],A[i],B[i],ca[i]);

end

endgenerate

fulladder fn(sum[N-1] , cout , A[N-1] , B[N-1] , ca[N-1] );

endmodule

// 单独的实例化可以同generate配合使用，这样可以少写判断语句。

module ripple #( parameter N = 4 )

( output logic [N-1:0] sum , output logic cout ,

input logic [N-1:0] A , B , input logic cin );

logic [N-1:1] ca ;

genvar i ;

task automatic fulladder( output logic sum , cout ,

input logic a , b , cin ) ;

begin

sum = a ^ b ^ sum ;

cout = a&b | a&cin | b&cin ;

end

endtask

always_comb fulladder(sum[0], ca[1] , A[0] , B[0] , cin );

generate for( i = 0 ; i < N-1 ; i++ )

begin: f_loop

always_comb

full_adder(sum[i],ca[i+1],A[i],B[i],ca[i]);

end

endgenerate

always_comb fulladder(sum[N-1] , cout , A[N-1] , B[N-1] , ca[N-1] );

endmodule

// generate 并不只是实例化module对象，还可以实例化逻辑语句。

关于wire与logic的区别：

在sv中常常看到logic而极少看到wire类型的出现，虽然他们的公用基本相同，但还是

有部分不一致的地方。

在存在三，四态或总线的情况下，也就是说可能出现z，x，则需要使用wire类型的变量