MCDF实验1：列王的纷争（从verilog到SV的入门lab1）

Dypypp

已于 2022-10-19 11:12:51 修改

阅读量1k

点赞数 19

分类专栏： System Verilog 文章标签： fpga开发

于 2022-10-18 21:36:46 首次发布

本文链接：https://blog.csdn.net/jackack/article/details/127395154

版权

System Verilog 专栏收录该内容

13 篇文章 44 订阅

订阅专栏

前言：修改实验0传送数据的方式，并将验证结构修改的更加合理。
种一棵树最好的时间是十年前，其次是现在。不是吗？

看之前的实验0来思考这几个问题：

修改tb0.v 为 tb0.sv ,编译仿真，查看仿真行为是否同tb1.v的仿真行为一致？

两次仿真行为一致，说明编译器对 SV 的语法和Verilog语法是全部兼容的。

将tb0.sv中的信号变量类型由reg或者wire 修改为 logic 类型，再编译仿真，查看行为是否同修改前的一致呢？这是为什么？

没有变化，仿真行为一致，说明在SV中， reg 和 wire 类型都可以简化为 logic类型。

在2的基础上，将 rstn 的类型由logic 修改为 bit 类型，再编译仿真，行为是否同步骤2）的一致？这是为什么？

复位信号（rstn）的拉低由第一个时钟下降沿（也就是程序里的10ns）变为了时钟一开始就拉低，因为 bit 是二值类型，默认没有给值的时候是0，然后拉低就一直是0，而 logic 是四值类型，一开始没有给值，默认是X, 然后经过10ns 被拉低。

在实验0中，产生时钟的信号与复位信号分别在两个initial块中，可以放在一起吗？

不可以放在一个initial 块中，放在一起的话，如果时钟信号放在前面，仿真波形里面只会产生clock时钟信号，并没有产生复位信号。’因为多个initial块是并行的，在initial块内部的执行顺序是串行的，执行clk_gen()时，forever会一直执行，不断产生时钟信号，导致rstn_gen()方法无法调用执行。

如果将 ` timescale 1ns/1ps 修改为 timescale 1ps/1ps, 那么仿真中的时钟周期是否发生变化？这是为什么？

左边的1ns 是时间单位，右边的1ps 是时间精度改为 1ps/1ps，时间单位变为了1ps, 时钟周期也就变为了40ps。

任务task 和函数function。 task 和 function 一样，是需要被调用的，不调用不执行，必须被过程块调用（initial 和 always）。

实验1 lab1

实验1在实验0的基础上做了改变

实验0产生数据，是通过任务chnl_write给slave输入几个固定的数据，按实验1写的当需要发送100个数据是不是要写100行？所以在实验1对这做了升级，采用动态数组。
在实验0的tb文件中，既包括了task的声明也包括了模块的例化，当需要定义多个task时，不方便别人阅读，所以把task单独放在一个模块中，最后在tb文件中例化。

结构框图如下：
在这里插入图片描述

框图最上边是chnl0_arr[]、chnl1_arr[]、chnl2_arr[]三个动态数组，三兄弟产生数据后，调用模块chnl_init 中的方法，把数据传输给channle。实现了数据的输入，最后检测arbiter的输出。
与实验0相比框图变复杂了，但可实现的功能变多，结构也清晰了。

1. 修改产生数据方式

在实验1将使用动态数组产生100个数据，将他们读取并发送给三个slave。

logic [31:0] chnl0_arr[];//定义动态数组
logic [31:0] chnl1_arr[];
logic [31:0] chnl2_arr[];
 
//  为动态数组生成100个数据
initial begin
  		chnl0_arr = new[100];  //动态数组的例化 
	 	chnl1_arr = new[100];
 		chnl2_arr = new[100];
 		foreach(chnl0_arr[i]) begin  //foreach遍历数组， chnl0_arr[0] = 'h00C0_00000 + 0;， chnl0_arr[1] = 'h00C0_00000 + 1;以此类推。
    	chnl0_arr[i] = 'h00C0_00000 + i;
		chnl1_arr[i] = 'h00C1_00000 + i;
		chnl2_arr[i] = 'h00C2_00000 + i;
end

2. 修改验证结构

为了实现清晰的验证结构，将DUT和task产生数据之间划分。
将chnl_write() 封装在新的模块中，最后在顶层模块中例化三个chnl_initiator 实例 chnl0_init, chnl1_init 和 chnl2_init 。发送激励（stimulator）给每个channel 。
并在模块 chnl_initiator 中定义了三个方法set_name() ，chnl_write() 和 chnl_idle()。

chnl_idle() ：实现一个时钟周期的空闲，在该周期中，ch_valid 应为低， ch_data应为0。

task chnl_idle();
    @(posedge clk);
    ch_valid <= 0;
    ch_data <= 0;
endtask

chnl_write() ：实现一次有效的写数据，并随后调用 chnl_idle() 来实现一个空闲周期。结合功能描述的 channel slave 接口时序来看，只有当 valid 为高且 ready 为高时，数据写入才算成功，如果此时 ready 为低，那么则应该保持数据和 valid 信号，直到 ready 拉高时，数据写入才算成功。

task chnl_write(input logic[31:0] data);
      @(posedge clk);
      ch_valid <= 1;
      ch_data <= data;
      @(negedge clk);
      wait(ch_ready === 'b1);
      $display("%t channel initial [%s] sent data %x", $time, name, data);
      chnl_idle();
endtask

set_name() :设置实例的名称，在 initial过程块调用此函数，在发送各个channel数据显示它们各自的名称，便于阅读和调试。

    string name;
    function void set_name(string s);
      name = s;
    endfunction

实验源代码如下：

`timescale 1ns/1ps


module chnl_initiator(
  input               clk,
  input               rstn,
  output logic [31:0] ch_data,
  output logic        ch_valid,
  input               ch_ready,
  input        [ 5:0] ch_margin
);

string name;

function void set_name(string s);
  name = s;
endfunction

task chnl_write(input logic[31:0] data);
  // USER TODO
  // drive valid data
  // ...
  @(posedge clk);
  ch_valid <= 1;
  ch_data <= data;
  @(negedge clk);
  wait(ch_ready === 'b1);
  $display("%t channel initial [%s] sent data %x", $time, name, data);
  chnl_idle();
endtask

task chnl_idle();
  // USER TODO
  // drive idle data
  // ...
  @(posedge clk);
  ch_valid <= 0;
  ch_data <= 0;
endtask

endmodule

module tb4_ref;
logic         clk;
logic         rstn;
logic [31:0]  ch0_data;
logic         ch0_valid;
logic         ch0_ready;
logic [ 5:0]  ch0_margin;
logic [31:0]  ch1_data;
logic         ch1_valid;
logic         ch1_ready;
logic [ 5:0]  ch1_margin;
logic [31:0]  ch2_data;
logic         ch2_valid;
logic         ch2_ready;
logic [ 5:0]  ch2_margin;
logic [31:0]  mcdt_data;
logic         mcdt_val;
logic [ 1:0]  mcdt_id;

mcdt dut(
   .clk_i(clk)
  ,.rstn_i(rstn)
  ,.ch0_data_i(ch0_data)
  ,.ch0_valid_i(ch0_valid)
  ,.ch0_ready_o(ch0_ready)
  ,.ch0_margin_o(ch0_margin)
  ,.ch1_data_i(ch1_data)
  ,.ch1_valid_i(ch1_valid)
  ,.ch1_ready_o(ch1_ready)
  ,.ch1_margin_o(ch1_margin)
  ,.ch2_data_i(ch2_data)
  ,.ch2_valid_i(ch2_valid)
  ,.ch2_ready_o(ch2_ready)
  ,.ch2_margin_o(ch2_margin)
  ,.mcdt_data_o(mcdt_data)
  ,.mcdt_val_o(mcdt_val)
  ,.mcdt_id_o(mcdt_id)
);

// clock generation
initial begin 
  clk <= 0;
  forever begin
    #5 clk <= !clk;
  end
end

// reset trigger
initial begin 
  #10 rstn <= 0;
  repeat(10) @(posedge clk);
  rstn <= 1;
end

// 动态数组
logic [31:0] chnl0_arr[];
logic [31:0] chnl1_arr[];
logic [31:0] chnl2_arr[];

initial begin
  chnl0_arr = new[100];
  chnl1_arr = new[100];
  chnl2_arr = new[100];
  foreach(chnl0_arr[i]) begin
    chnl0_arr[i] = 'h00C0_00000 + i;
	chnl1_arr[i] = 'h00C1_00000 + i;
	chnl2_arr[i] = 'h00C2_00000 + i;
  end
end

// data test
initial begin 
  @(posedge rstn);
  repeat(5) @(posedge clk);
  // 修改每一个的名字
  chnl0_init.set_name("chnl0_init");
  chnl1_init.set_name("chnl0_init");
  chnl2_init.set_name("chnl0_init");
  
 //遍历数组并通过模块中的chnl_write传输数据
  foreach(chnl0_arr[i])
 chnl0_init.chnl_write(chnl0_arr[i]);
  foreach(chnl1_arr[i]) 
chnl1_init.chnl_write(chnl1_arr[i]);
  foreach(chnl2_arr[i]) 
  chnl2_init.chnl_write(chnl2_arr[i]);
end

//三个例化
chnl_initiator chnl0_init(
  .clk      (clk),
  .rstn     (rstn),
  .ch_data  (ch0_data),
  .ch_valid (ch0_valid),
  .ch_ready (ch0_ready),
  .ch_margin(ch0_margin) 
);

chnl_initiator chnl1_init(
  .clk      (clk),
  .rstn     (rstn),
  .ch_data  (ch1_data),
  .ch_valid (ch1_valid),
  .ch_ready (ch1_ready),
  .ch_margin(ch1_margin) 
);

chnl_initiator chnl2_init(
  .clk      (clk),
  .rstn     (rstn),
  .ch_data  (ch2_data),
  .ch_valid (ch2_valid),
  .ch_ready (ch2_ready),
  .ch_margin(ch2_margin) 
);

endmodule