接口

在Verilog中，模块之间的通信是使用模块端口指定的。

Verilog模块连接的缺点

声明必须在多个模块中重复。
存在声明不匹配的风险。
设计规格的更改可能需要修改多个模块。

接口#

SystemVerilog引入了 interface 结构，它封装了模块之间的通信。一个 interface 是一组信号或线路，通过它测试台与设计进行通信。

序号	数据类型
1.	接口
2.	参数化接口
3.	Modports
4.	时钟块
5.	虚拟接口

interface1

接口结构用于连接设计和测试台。

不使用Interface的Systemverilog

下图显示了不使用接口连接设计和测试台的情况。

int Diagram

SystemVerilog接口

下图显示了使用接口连接设计和测试台的情况。

interface Diagram

语法：

interface (interface_name) ([port_list]);  
 [list_of_signals]    
endinterface

示例：

接口声明

interface and_if; 
 logic input_a,input_b,output_y;      
endinterface

int

这里的接口由一组信号组成，在测试模块中，我们调用接口句柄，但我们没有声明信号的方向。在测试模块中，我们将 a_input 和 b_input 的值传递给接口。在顶层模块中，我们使用接口实例化 DUT 信号。DUT 的输出 ‘y’ 通过接口发送到测试模块。接口中没有使用 modport。我们可以通过在信号上声明 ‘/’ 来声明每个信号的大小。这用于知道信号的矢量大小。

AND门的顶层模块

    //Here the interface,testbench,design module are called.
    module top();
    
    //interface module
    and_if inf();
    
    //design module instantiate
    andg a1(.input_a(inf.input_a), .input_b(inf.input_b), .output_y(inf.output_y));
    
    //testbench
    tb a2(inf);
    
    endmodule:top

Design code for AND gate

     //module declaration  
     module andg(input_a,input_b,output_y);  
     input input_a,input_b;  
     output output_y;  
     //assign output  
     assign output_y=input_a&input_b;  
     endmodule:andg

Testbench for AND gate

     //testbench for and gate  
     module tb(and_if inf);  
     initial begin  
     $display("\n// and gate output");  
     $monitor("\ninput_a=%b\t input_b=%b\t output_y=%b",inf.input_a,inf.input_b,inf.output_y);  
     inf.input_a = 0; inf.input_b = 0;  
     #1;  
     inf.input_a = 1; inf.input_b = 0;  
     #1;  
     inf.input_a = 0; inf.input_b = 1;  
     #1;  
     inf.input_a = 1; inf.input_b = 1;  
     end  
     endmodule:tb

下图显示了使用接口的AND门的输出。

interface 1png

SystemVerilog接口的优点

在Verilog中，添加新信号时，必须手动更改模块实例化的每个地方。SystemVerilog使得在接口块中为现有连接添加新信号变得更加容易。
它增加了跨项目的可重用性。
一组信号可以通过其句柄轻松共享在组件之间传递。
它提供方向信息（modports）和时序信息（时钟块）。

参数化接口#

可以在接口中使用参数，使用Verilog的参数重新定义构造使接口内部的向量大小和其他声明可重新配置。

语法：

interface (interface_name) #(parameter parameter_name = initialize);
 [list_of_signals]    
endinterface

示例：

interface count_if #(parameter N=2) ;  
logic reset,clk;  
logic [N:0] counter;
endinterface:count_if

计数器的顶层模块

    //Here the interface,testbench,design module are called.
     module top();
   
    //parameterised interface
     count_if inf();
  
    //design code of up_counter
    up_counter u1(.clk(inf.clk), .reset(inf.reset), .counter(inf.counter));
 
    //testbench for up_counter
    upcounter_testbench u2(inf);
 
    endmodule:top

计数器的设计代码

     //Design code for up counter
     module up_counter(clk,reset,counter);
     input clk, reset;
     output [2:0] counter;
     reg [2:0] counter_up;
     //up counter
     always @(posedge clk or posedge reset)
     begin
     //if reset=0 count will be incremented
     if(reset)
       counter_up <= 3'd0;
       else
       counter_up <= counter_up + 3'd1;
     end 
     assign counter = counter_up;
     endmodule:up_counter

计数器的测试台（Test bench）

     //testbench for up counter
     module upcounter_testbench(count_if inf);
     initial begin
     $display("\n // Parameterised interface example");
     //used to monitor the count values
     $monitor("\ncount=%0d",inf.counter);
     inf.clk=0;
     forever #5 inf.clk=~inf.clk;
     end
     initial begin
     inf.reset=1;
     #20;
     inf.reset=0;
     #70 $finish;
     end
     endmodule:upcounter_testbench

这里我们考虑了3位输出，其中计数器从0计数到7。

下图显示了带有参数化接口的计数器的输出。

para_interf1

通过两种方式可以更新参数值

传递常量值
使用‘defparam’关键字

传递常量值

在这种情况下，参数的值通过顶层模块实例化接口传递给接口。
例如: count_if#(2) intf();
count_if 是接口名称。
#(2)- 是传递给接口模块的参数值。

示例：

接口模块

     interface count_if #(parameter N);
     logic rst,clk;  
     logic [N:0] counter;  
     logic [N:0] counter_up;   
     endinterface:count_if

顶层模块

     module top();  

    //parameterised interface  
    //pass by constant value  
    count_if#(2) intf();  

    //design code of up_counter  
    up_counter u1(intf);  

    //testbench for up_counter  
    upcounter_testbench u2(intf);  

    endmodule:top

输出

下图中的图，up_counter的输出从0计数到7。这里参数的值通过顶层模块实例化中的接口传递。

pass_value

使用‘defparam’关键字

defparam 用于通过使用层次名称实例来覆盖参数值。defparam允许在编译时更改参数值。

例如: defparam intf.N=1;
这里intf是接口的句柄。
N是参数。
接口模块

     interface count_if #(parameter N=4);
     // declaration of design signals
     logic rst,clk;
     logic [N:0] counter;
     logic [N:0] counter_up;
     endinterface:count_if

顶层模块

     module top();

     //parameterised interface
     count_if intf();

     //Declaration of defparam 
     defparam intf.N=1;

     //instantiation of design module
     up_counter u1(intf);

     //testbench for up_counter
     upcounter_testbench u2(intf);

     endmodule:top

输出：

下图中的图8显示，接口参数值N=4。但是通过使用关键字defparam，在顶层模块实例化时，我们可以覆盖参数的值。

defparam_output

模块端口#

Modport 用于指定在接口内声明的信号的端口方向。modport 在接口内部用关键字 modport 声明。
Modport 是模块端口的缩写。

Modport 的特点:

可以具有输入、双向和输出。
通过指定端口方向，modport 为信号提供访问限制。
接口可以有任意数量的 modport，接口中声明的信号可以分组在多个 modport 中。
modport 可综合化。

语法：

modport identifier (input <port_list>, output<port_list>);

示例：

interface and_intr;    
  logic p,q;  
  logic r;  
  modport DUT_MP(input p,input q,output r);   
  modport TB_MP(output p,output q,input r);  
endinterface : and_intr

AND 门的顶层模块，在测试台和设计文件中调用 modport 名称：

     // creating top module 
     // in this file design,testbench,interface modules are called
     module top();
     // interfce module called
     and_intr inf();
     // design module called
     and_gate a1(inf);
     // testbench module called   
     tb a2(inf);
     endmodule : top

AND 门的设计文件：

     // and gate design file  
     // module defination for and gate with interface instanciation  
     module and_gate(and_intr inf);
     // assign the output using continuous assignment
       assign inf.DUT_MP.r = (inf.DUT_MP.p) & (inf.DUT_MP.q); 
     endmodule : and_gate

AND 门的测试台文件：

    // testbench file for and gate design
    // module defination for testbench with interface instanciation
    module tb(and_intr inf);

     initial
        begin
          $display("// and gate output using modports\n");
          repeat(5)
            begin
              inf.TB_MP.p = $random;
              #1;
              inf.TB_MP.q = $random;
              #1;
              $display("input_p=%b\t input_q=%b\t output_r=%b",inf.TB_MP.p,inf.TB_MP.q,inf.TB_MP.r);
            end
        end
    endmodule : tb

使用接口中的 modport，在上述提到的两种方式下，AND 门的输出保持不变。如下图所示。

modport_andgate

时钟块#

时钟块被定义为一种机制，用于将输入和输出信号的采样和驱动与时钟事件同步。在测试台内使用时钟块非常有用，可以避免模拟中的竞态条件。我们可以明确地指定信号与特定时钟同步时的时间。时钟块只能在模块、接口内声明。时钟块只涉及输入和输出如何进行采样和同步。将值分配给变量是由模块、接口而不是时钟块完成的。

时钟块术语#

1. 时钟事件

clocking  时钟块名称  @(posedge clk);

事件规范用于同步时钟块，@(posedge clk) 是时钟事件。

2. 时钟信号

input  from_Dut;  
output to_Dut;

时钟块采样和驱动的信号，from_DUT 和 to_DUT 是时钟信号。

3. 时钟偏移

时钟偏移指定了在哪个输入和输出时钟信号要被采样或驱动。偏移必须是一个常量表达式，并且可以指定为参数。

输入和输出偏移

default input #1step output #0;

默认输入偏移和输出偏移声明如下，default input #1step output #0;。这里默认输入偏移需要 #1step 延迟来获取稳定输入的采样过程。输出偏移仅需要 #0 延迟，这意味着我们在当前时间段内得到稳定的输出。

下图显示了默认的输入和输出偏移。

下图显示了输入偏移和输出偏移。

输入信号相对于时钟事件进行采样。如果指定了输入偏移，则信号在时钟事件之前的偏移时间单位被采样。然后，输出信号在相应的时钟事件之后的偏移时间单位被驱动。输入偏移隐式为负，因为它发生在时钟之前。

例如，default input #3ps output #2。

语法：

clocking cb @(posedge clk); 
default input #1step output #0;
input  from_Dut; 
output to_Dut; 
endclocking

示例：D_flipflop

clocking block (1)

上图显示了 d_ff 的设计模块图。接口连接了 DUT 和测试。测试提供随机值 d，通过接口驱动到 DUT。DUT 给出采样值 q。采样值 q 被给定为测试的输入。在这里，顶层模块包括所有块，如测试、接口和 DUT。每个块的实例在顶层模块中创建。

posedge_df_cb

在这个例子中，DUT（时钟块时钟）和测试都在正边沿（接口时钟）触发。在这种情况下，波形输出和显示语句输出不匹配。输出显示在下图中。

示例代码：

DUT 代码：

     // module:d_flipflop   
     module d_flipflop(dff.dut intf);  
 
       //clocking block cd  
       always @(intf.cd)  

       //Non-Blocking assignment   
       intf.cd.q <= intf.cd.d;  
 
     endmodule : d_flipflop

Interface 代码：

     //module: Interface  
     interface dff(input clk);    

       //declare the signals    
       logic d;   
       logic q;   

       //Clocking block for dut    
       clocking cd @(posedge clk);   
         default input #1step output #0;   
         output q;   
         input d;    
       endclocking     
  
       //modport for dut    
       modport dut(clocking cd);    
       //modport for tb     
       modport tb(input q, output d, input clk);`   
   
     endinterface: dff

测试代码：

     //module: test
     module test(dff.tb intf);
  
       //task:drv
       task drv;
         //loop
         repeat(10)
           begin
           //test triggering at posedge
           @(posedge intf.clk )

           //randomzing the d
           intf.d <= $random;
           $display("test side[%0t]=d_tb_drive:%d q_dut_sample:%d",$time,intf.d, intf.q);
         end
         $finish;
       endtask 
  
       //calling the task drv
       initial begin
         drv();
       end 
     endmodule :test

顶层模块

     //including the file test.sv and interface.sv  
     `include "test.sv"      
     `include "interface.sv"    
 
     module top;
       bit clk=1;
       initial
         forever #5 clk = ~clk;

       //creating interface instance
       dff intf(clk);

       //d_flipflop instance
       d_flipflop t1(intf);  

       //test Instance
       test t2(intf);

       initial
         $monitor("DUT side [%0t]=d_tb_drive:%d q_dut_sample:%d",$time,intf.cd.d, intf.cd.q);
     endmodule : top

在下面的输出中，首先给出DUT和测试的正边沿。在这个例子中，在0时间，DUT和测试的输出都是x，然后在10纳秒时，测试随机化d值x为0，这时DUT得到0并给出采样q输出为0，这个时钟周期测试(tb)只随机化值d = 0，但测试(tb)采样了先前的值q = x。在10纳秒时，我的DUT给出输出d = 0和q = 0，而此时我的测试(tb)给出输出d = 0和q = x。现在，在20纳秒时，测试将d值从0随机化为1，此时DUT得到1并给出采样的q输出为1，这个时钟周期测试(tb)只随机化值d = 1，但测试(tb)采样了先前的值q = 0。在20纳秒时，我的DUT给出输出d = 1和q = 1，而此时我的测试给出输出d = 1和q = 0。

输出记录

下图14显示了 d 触发器的输出。

case_t1

所有时钟周期的 d_ff 输出

下图15显示了 d 触发器的输出波形。

case1

时钟块的优势

时钟块提供了测试台和DUT之间无竞争条件。
时钟块可以在接口、模块内声明。
时钟块帮助用户以更高层次的抽象编写测试台。
仿真速度更快。
将设计的时钟活动与数据分配活动分离。
在设计执行中节省了大量的代码和时间。

虚拟接口#

虚拟接口是表示接口实例的变量。
虚拟接口用于在类中创建接口实例，因为接口是静态组件，而SystemVerilog测试台是动态组件。我们不能直接在类中声明接口，但使用变量 virtual，我们可以在类中声明接口实例。
语法：virtual interface_name instance_name;

interface_name：接口的名称
instance_name：虚拟接口实例的名称，可以在类中使用变量 Ex: vif.variable;

虚拟接口必须在类中初始化，指向实际接口。在类中声明虚拟接口 例如：Virtual intf vif;
访问未初始化的虚拟接口会导致致命错误。
虚拟接口可以作为任务和函数方法的参数传递。
虚拟接口可以是类的属性，并且可以通过使用函数参数进行初始化，即它可以在特定类中调用实际接口并在该类中创建接口实例。
例如：function new(virtual intf vif);
虚拟接口可以作为函数方法的参数传递。通过使用 new() 构造，在类中调用实际接口 ‘intf’ 来声明虚拟接口，可以在类中的过程或函数参数中使用。
在类函数和任务方法内部，可以通过虚拟接口句柄访问接口变量，如 virtual_instance_name.variable;

Example : vif.a

vif 是虚拟实例名称；
a 是类的变量/属性

关键字/信号虚拟接口变量在整个仿真时间内表示不同的接口实例。
语法：

interface <interface_name>(); 
               <port_list>; 
                .......... 
                endmodule 
           To connect static(interface module) to
           to dynamic(class) we use virtual interface  
            class clase_name;  
             virtual <interface_name> <interface_instance>;  
             ....... 
           properties; 
             ..... 
           function() 
            .....
          endfunction 
            task();  
             ...... 
             endtask 
             endclass

Example1: Fulladder

全加器的设计代码

    //Module:fullinput_adder  
    module fulladder(in_a,in_b,in_c,out_sum,out_carry) ;    
    //Declaration of input variables
     input in_a,in_b,in_c;
     //Declaration of output variables
      output out_sum;
      output out_carry;
    //continuous input_assignment statement
     assign out_sum = in_a^in_b^in_c;
     assign out_carry = (in_a&in_b)|(in_b&in_c)| (in_c&in_a);  
      endmodule:fulladder

全加器的接口模块

     interface adder();
     //declaring the signals
      logic in_a,in_b,in_c;
      logic out_sum,out_carry;
     endinterface

类内的虚拟接口声明

     //class:driver  
     class driver;  
      //Declaration of virtual interface  
      //syntax: virtual interface_name interface_instance;
      virtual adder vif;
      //constructor  
      function new(virtual adder vif);  
      //this.vif refer to class driver  
      //vif refer to the function argument  
      this.vif = vif;  
      endfunction  
      //task  
      task run();  
      repeat(10) begin  
      //interface_instance.variable  
      vif.in_a = $random;  
      vif.in_b = $random;  
      vif.in_c = $random;  
      $display("");  
      $display("//INPUT:Inputs of full adder  \n a=%0b, b=%0b, cin =%0b", vif.in_a,vif.in_b, vif.in_c);  
      #5;  
      $display("");  
      $display("//OUTPUT:Outputs of full adder \n sum=%0b, carry = %0b\n", vif.out_sum, vif.out_carry);  
      end  
      endtask  
     endclass

全加器的测试模块

    `//include the driver file  
      include "driver.sv"  
      //module:test  
     module test(adder intf);  
    //declaring the driver instance  
     driver drv;  
     initial  
     begin  
     //creating the driver instance  
     drv = new(intf);  
    //calling the task run  
     drv.run();  
     end  
    endmodule:test

全加器的顶层模块

      //including the test.sv and interface.sv files
    `include "test.sv"
    `include "interface.sv"
 
     //module:top
     module top;
    //creating  an instance of interface
     adder intf();
 
    // the instance of test  t1.
     test t1(intf);
 
    //fulladder DUT instance , connecting the interface signal to instance DUT
    fulladder dut(.in_a(intf.in_a), .in_b(intf.in_b), .in_c(intf.in_c), .out_sum(intf.out_sum), .out_carry(intf.out_carry));
    endmodule

下图显示了代码的设计块：

fulladder

在图16中，驱动器是一个类，在这里我们声明了虚拟接口，因为在类内部我们不能直接调用接口，因为接口是静态组件而类是动态组件。所以这个虚拟关键字被用来在类内部创建实例（它将创建虚拟接口）。在驱动器中，我们生成随机刺激并发送到接口，DUT连接到接口。DUT的输出给予接口。测试块包括类组件，即（driver.sv），顶层模块包括所有组件，如测试、接口和DUT。所有组件的实例都在顶层模块/块中创建。

下图显示了全加器的输出：
在图17中显示了全加器的输出，其中 a、b 和 cin 是全加器的输入，sum 和 carry 是全加器的输出。

fulladder2

接口#

参数化接口#

模块端口#

时钟块#

时钟块术语#

虚拟接口#

On this page:

Tags