精华内容
下载资源
问答
  • OPENRISC1200 RTL代码.rar

    2019-09-01 18:15:59
    OPENRISC1200 RTL代码 [ 本帖最后由 genghis 于 2008-7-1 13:35 编辑 ] rtl.rar
  • Verilog RTL 代码设计

    千次阅读 2019-03-09 15:08:28
    【EDA】实验4:常用元件的 Verilog RTL 代码设计 2018年11月11日 00:17:09lilei4136619阅读数:123 【EDA】实验4:常用元件的 Verilog RTL 代码设计 多路选择器 一.实验内容 二.实验步骤 交叉开关 一....

    【EDA】实验4:常用元件的 Verilog RTL 代码设计

    2018年11月11日 00:17:09 lilei4136619 阅读数:123

     

    【EDA】实验4:常用元件的 Verilog RTL 代码设计

     

    多路选择器

    一.实验内容

    1.做一个4选1的多路选择器,并进行波形仿真。
    2.将4选1多路选择器同2选1多路选择器对比,观察资源消耗的变化。

    二.实验步骤

    1.创建项目
    创建项目的过程与前几篇文章相同,不再赘述。

    2.添加Verilog HDL文件
    在这里插入图片描述

    3.编写Verilog HDL代码
    具体代码如下:

    // module  top, 选择器(mux)的代码,
    module top(
      IN0       ,   // input 1
      IN1       ,   // input 2
      IN2       ,   // input 3
      IN3       ,   // input 4
      SEL       ,   // select 
      OUT       );  // out data
      
    input [15:0] IN0, IN1, IN2, IN3;// 选择器的输入数据信号
    input [1:0] SEL;              // 通道选通的控制信号
    output[15:0] OUT;     // 选择器的输入数据信号
    
    reg   [15:0] OUT;
    // 生成组合逻辑的代码
    always @ (IN0 or IN1 or IN2 or IN3 or SEL) begin
      if(SEL==0) // SEL为0 选择输入0
        OUT = IN0;
      else  if(SEL==1)  // SEL为1 选择输入1
        OUT = IN1;
      else  if(SEL==2)  // SEL为2 选择输入2
    	OUT = IN2;
      else  if(SEL==3)  // SEL为3 选择输入3
    	OUT = IN3;
    end
    endmodule
    // endmodule top
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    4.编译代码
    在这里插入图片描述

    5.添加并配置Vector Waveform File
    添加Vector Waveform文件并配置仿真输入波形的方法在之前的文章已说明过了,此处直接展示仿真的结果。
    在这里插入图片描述
    从仿真波形中可以看到:当SEL端的信号变化时,输出端会选择相应的输入信号进行输出。

    6.4选1多路选择器的RTL结构
    对于Quartus工具,可以按照如下路径找到RTL Viewer:Tools -> Netlist Viewer -> RTL Viewer
    本实验代码生成的RTL结构如下图:
    第一页:
    在这里插入图片描述
    第二页:
    在这里插入图片描述

    7.2选1多路选择器的RTL结构
    在这里插入图片描述
    8.两种多路选择器的资源消耗对比
    2选1多路选择器:
    在这里插入图片描述
    4选1多路选择器:
    在这里插入图片描述
    可见4选1多路选择器相比2选1多路选择器消耗更大的硬件资源。

    交叉开关

    一.实验内容

    1.编写一个4X4路交叉开关的Verilog代码,然后编译,进行波形仿真。
    2.观察RTL View,比较2x2路交叉开关与4x4路交叉开关之间消耗资源的区别。

    二.实验步骤

    1.编写Verilog HDL代码

    // module  top, a 4x4 crossbar switch circuit
    
    module top(
      IN0       ,   // input 1
      IN1       ,   // input 2
      IN2       ,   // input 3
      IN3       ,   // input 4
      SEL0      ,   // select the output0 source 
      SEL1      ,   // select the output1 source 
      SEL2      ,   // select the output2 source 
      SEL3      ,   // select the output3 source 
      OUT0      ,   // output data 0
      OUT1      ,   // output data 1
      OUT2      ,   // output data 2
      OUT3      );  // output data 3
    
    input [15:0] IN0, IN1, IN2, IN3;
    input [1:0] SEL0, SEL1, SEL2, SEL3;
    output[15:0] OUT0, OUT1, OUT2, OUT3;
    
    reg   [15:0] OUT0, OUT1, OUT2, OUT3;
    // get the OUT0
    always @ (IN0 or IN1 or IN2 or IN3 or SEL0) begin
      if(SEL0==0)
        OUT0 = IN0;
      else if(SEL0==1)
        OUT0 = IN1;
      else if(SEL0==2)
        OUT0 = IN2;
      else if(SEL0==3)
        OUT0 = IN3;
    end
    // get the OUT1
    always @ (IN0 or IN1 or IN2 or IN3 or SEL1) begin
      if(SEL1==0)
        OUT1 = IN0;
      else if(SEL1==1)
        OUT1 = IN1;
      else if(SEL1==2)
        OUT1 = IN2;
      else if(SEL1==3)
        OUT1 = IN3;
    end
    // get the OUT2
    always @ (IN0 or IN1 or IN2 or IN3 or SEL2) begin
      if(SEL2==0)
        OUT2 = IN0;
      else if(SEL2==1)
        OUT2 = IN1;
      else if(SEL2==2)
        OUT2 = IN2;
      else if(SEL2==3)
        OUT2 = IN3;
    end
    // get the OUT3
    always @ (IN0 or IN1 or IN2 or IN3 or SEL3) begin
      if(SEL3==0)
        OUT3 = IN0;
      else if(SEL3==1)
        OUT3 = IN1;
      else if(SEL3==2)
        OUT3 = IN2;
      else if(SEL3==3)
        OUT3 = IN3;
    end
    endmodule
    // endmodule top
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67

    2.波形仿真
    在这里插入图片描述

    3.查看4×4交叉开关的RTL结构
    第一页:
    在这里插入图片描述
    第二页:
    在这里插入图片描述
    第三页:
    在这里插入图片描述
    第四页:
    在这里插入图片描述
    第五页:
    在这里插入图片描述
    第六页:
    在这里插入图片描述

    4.查看2×2交叉开关的RTL结构*
    在这里插入图片描述
    5.两种交叉开关的资源消耗对比
    2×2交叉开关的资源消耗:
    在这里插入图片描述
    4×4交叉开关的资源消耗:
    在这里插入图片描述
    可见,4×4交叉开关的逻辑单元消耗是2×2交叉开关的4倍。

    优先编码器

    一.实验内容

    1.编写一个8输入的优先编码器,然后编译,查看RTL View。

    二.实验步骤

    1.编写Verilog HDL代码

    // module top, 8 input priority encoder with zero input check
    module top(
      IN        ,   // input  
      OUT       );  // output 
    input [7:0] IN;
    output[3:0] OUT;
    
    reg   [3:0] OUT;
    // get the OUT
    always @ (IN) begin
       if(IN[7])       // 第一优先级
         OUT = 4'b111;
       else if(IN[6])  // 第二优先级
         OUT = 4'b110;
       else if(IN[5])  // 第三优先级
         OUT = 4'b101;
       else if(IN[4])  // 第四优先级
         OUT = 4'b100;
       else if(IN[3])  // 第五优先级
         OUT = 4'b011;
       else if(IN[2])  // 第六优先级
         OUT = 4'b010;
       else if(IN[1])  // 第七优先级
         OUT = 4'b001;
       else if(IN[0])  // 第八优先级
         OUT = 4'b000;
       else            // 什么都没有检测到
         OUT = 4'b1111; // 输出值可自定义,不和上面的输出值混淆即可
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    2.波形仿真
    在这里插入图片描述

    3.查看RTL View
    在这里插入图片描述

    多路译码器

    一.实验内容

    1.编写一个4-16的译码器,编译,仿真。
    2.查看RTL View,并和3-8译码器对比资源开销。

    二.实验步骤

    1.编写Verilog HDL代码

    // module top, 4-16 decoder
    module top(
      IN        ,   // input  
      OUT       );  // output 
    
    input [3:0] IN;
    output[15:0] OUT;
    
    reg   [15:0] OUT;
    // get the OUT
    always @ (IN) begin
      case(IN)
        4'b0000: OUT = 16'b0000_0000_0000_0001;
        4'b0001: OUT = 16'b0000_0000_0000_0010;
        4'b0010: OUT = 16'b0000_0000_0000_0100;
        4'b0011: OUT = 16'b0000_0000_0000_1000;
        4'b0100: OUT = 16'b0000_0000_0001_0000;
        4'b0101: OUT = 16'b0000_0000_0010_0000;
        4'b0110: OUT = 16'b0000_0000_0100_0000;
        4'b0111: OUT = 16'b0000_0000_1000_0000;
        4'b1000: OUT = 16'b0000_0001_0000_0000;
        4'b1001: OUT = 16'b0000_0010_0000_0000;
        4'b1010: OUT = 16'b0000_0100_0000_0000;
        4'b1011: OUT = 16'b0000_1000_0000_0000;
        4'b1100: OUT = 16'b0001_0000_0000_0000;
        4'b1101: OUT = 16'b0010_0000_0000_0000;
        4'b1110: OUT = 16'b0100_0000_0000_0000;
        4'b1111: OUT = 16'b1000_0000_0000_0000;
        //  full case 不需要写default,否则一定要有default
      endcase
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    2.波形仿真
    在这里插入图片描述

    3.查看RTL View
    4-16译码器:
    在这里插入图片描述

    3-8译码器:
    在这里插入图片描述

    4.对比资源开销
    3-8译码器:
    在这里插入图片描述
    4-16译码器:
    在这里插入图片描述
    4-16译码器的资源消耗约为3-8译码器的2倍。

    加法器

    无符号加法器

    一.实验内容

    1.把加法器的输入信号和输出信号都改成4比特位宽,编译,波形仿真。观察输出结果,说出输出和输入的对应关系。
    2.把加法器的输入信号改成8比特位宽,编译,波形仿真。观察加法器的输出延迟,和4比特输入位宽的情况对比。

    二.实验步骤

    1.编写Verilog HDL代码

    module top(
      IN1   ,
      IN2   ,
      OUT   );
    input[3:0] IN1, IN2;
    output[3:0] OUT;
    reg[3:0] OUT;
    always@(IN1 or IN2) begin // 生成组合逻辑的always 块
      OUT = IN1 + IN2;
    end
    endmodule 
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    2.仿真波形
    在这里插入图片描述
    由上图可知,当加法器的输入信号和输出信号位宽相同时加法器得到的结果可能会丢失最高位的进位,即所得结果溢出,导致计算结果出错。当最高位无进位时输出等于两个输入的和,而当最高位有进位时则输出比两个输入的和小16(24)。

    3.输入信号为8位宽的加法器的Verilog HDL代码

    module top(
      IN1   ,
      IN2   ,
      OUT   );
    input[7:0] IN1, IN2;
    output[8:0] OUT;
    reg[8:0] OUT;
    always@(IN1 or IN2) begin // 生成组合逻辑的always 块
      OUT = IN1 + IN2;
    end
    endmodule 
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    4.8位宽加法器仿真波形
    在这里插入图片描述
    从以上两张波形图可以看出4位宽加法器和8位宽加法器的输出延迟差别不大,基本都在8ns左右。

    补码加法器

    一.实验内容

    1.把加法器的输出信号改成4比特位宽,编译,波形仿真。观察输出结果,观察输出结果在什么时候是正确的?
    2. 把加法器的输入信号改成8比特位宽,编译,波形仿真。观察加法器的输出延迟,和4比特输入位宽的情况对比。

    二.实验步骤

    1.编写4比特位宽输出加法器的Verilog HDL代码

    module top(
      IN1   ,
      IN2   ,
      OUT   );
    input signed [3:0] IN1, IN2;
    output signed [3:0] OUT;
    reg signed [3:0] OUT;
    always@(IN1 or IN2) begin // 生成组合逻辑的always 块
      OUT = IN1 + IN2;
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    2.仿真结果波形
    在这里插入图片描述
    从仿真结果可知,当两个输入信号的和大于7或小于-8时计算结果会出错,这是由于次高位进位使得符号位变化导致的。

    3.编写8比特位宽输出加法器的Verilog HDL代码

    module top(
      IN1   ,
      IN2   ,
      OUT   );
    input signed [7:0] IN1, IN2;
    output signed [8:0] OUT;
    reg signed [8:0] OUT;
    always@(IN1 or IN2) begin // 生成组合逻辑的always 块
      OUT = IN1 + IN2;
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    4.仿真结果波形
    在这里插入图片描述
    由仿真波形可知,4位补码加法器和8位补码加法器的延迟时间相差不多,基本都是8ns。

    带流水线的加法器

    一.实验内容

    1.不改变流水线的级数,把加法器的输入信号改成8比特位宽,编译,波形仿真,和不带流水线的情况对比一下,你有什么结论?
    2.在8比特输入位宽的情况下,在输入上再添加一级流水线,观察编译和仿真的结果,你有什么结论?

    二.实验步骤

    1.编写8位输入带一级流水线的加法器的Verilog HDL代码

    module top(
      IN1   ,
      IN2   ,
      CLK   ,
      OUT   );
    input  [7:0] IN1, IN2;
    input CLK;
    output  [8:0] OUT;
    reg [7:0] in1_d1R, in2_d1R;
    reg  [8:0] adder_out, OUT;
    always@(posedge CLK) begin // 生成D触发器的always块
      in1_d1R <= IN1;
      in2_d1R <= IN2;
      OUT     <= adder_out;
    end
    always@(in1_d1R or in2_d1R) begin // 生成组合逻辑的always 块
      adder_out = in1_d1R + in2_d1R;
    end
    endmodule 
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    2.仿真结果波形
    在这里插入图片描述
    带有流水线的加法器相较于没有流水线的加法器拥有更短的毛刺,但输出延时更长。

    3.RTL View
    在这里插入图片描述
    4.编写8位输入带两级级流水线的加法器的Verilog HDL代码

    module top(
      IN1   ,
      IN2   ,
      CLK   ,
      OUT   );
    input  [7:0] IN1, IN2;
    input CLK;
    output  [8:0] OUT;
    reg [7:0] in1_d1R, in2_d1R, in1_d2R, in2_d2R;
    reg  [8:0] adder_out, OUT;
    always@(posedge CLK) begin // 生成D触发器的always块
      in1_d1R <= IN1;
      in1_d2R <= in1_d1R;
      in2_d1R <= IN2;
      in2_d2R <= in2_d1R;
      OUT     <= adder_out;
    end
    always@(in1_d2R or in2_d2R) begin // 生成组合逻辑的always块
      adder_out = in1_d2R + in2_d2R;
    end
    endmodule 
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    5.仿真结果波形
    在这里插入图片描述
    增加一级流水线后使得毛刺的时间长度进一步减小,但是输出延迟变得更大。

    6.RTL View
    在这里插入图片描述

    乘法器

    一.实验内容

    1.改变乘法器的输入位宽为8比特,编译,波形仿真,观察信号毛刺的时间长度。
    2.选一款没有硬件乘法器的FPGA芯片(例如Cyclone EP1C6)对比8比特的乘法器和加法器两者编译之后的资源开销(Logic Cell的数目)
    3.编写一个输入和输出都有D触发器的流水线乘法器代码,编译后波形仿真,观察组合逻辑延迟和毛刺的时间,和不带流水线的情况下对比。

    二.实验步骤

    1.编写8位输入的乘法器的Verilog HDL代码

      有符号的2补码乘法器  /
    module top(
      IN1   ,
      IN2   ,
      OUT   );
     input signed[7:0] IN1, IN2;
     output signed [15:0] OUT;
     reg signed[15:0] OUT;
     always@(IN1 or IN2) begin // 生成组合逻辑的always 块
      OUT = IN1 * IN2;
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    2.仿真结果波形
    在这里插入图片描述
    从图中可得,毛刺信号约占4ns。

    3.没有硬件乘法器的FPGA芯片的8比特加法器和乘法器的资源开销对比
    加法器资源开销:
    在这里插入图片描述
    乘法器硬件开销:
    在这里插入图片描述
    由上图可见,乘法器相较加法器更加消耗资源。

    4.输入和输出都有D触发器的流水线乘法器的Verilog HDL代码

      带有流水线的补码乘法器  /
    module top(
      IN1   ,
      IN2   ,
      CLK   ,
      OUT   );
     input signed[7:0] IN1, IN2;
     input CLK;
     output signed [15:0] OUT;
     reg signed[15:0] OUT;
     reg signed[7:0] in1_d1R, in2_d1R;
     reg signed[15:0] mul_out;
    always@(posedge CLK) begin // 生成D触发器的always块
      in1_d1R <= IN1;
      in2_d1R <= IN2;
      OUT     <= mul_out;
    end
     always@(in1_d1R or in2_d1R) begin // 生成组合逻辑的always 块
      mul_out = in1_d1R * in2_d1R;
    end
    endmodule 
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    5.仿真结果波形
    在这里插入图片描述
    有仿真波形可得:带有流水线的乘法器的组合逻辑延迟和毛刺的时间约为2ns,相比不带流水线的乘法器要减少了一半。

    计数器

    一.实验内容

    1.设计一个最简单的计数器,只有一个CLK输入和一个Overflow输出,当计数到最大值的时钟周期CLK输出1
    2.设计复杂的计数器,和本例相似,带有多种信号,其中同步清零CLR的优先级最高,使能EN次之,LOAD最低。

    二.实验步骤

    1.编写简单计数器的Verilog HDL代码

     计数器代码  /
    module top(
      CLK   , // 时钟,上升沿有效
      OV    );// 计数溢出信号,计数值为最大值时该信号为1
    input CLK ;
    output OV;   
    reg OV;
    reg [3:0] CNTVAL, cnt_next;
    // 电路编译参数,最大计数值
    parameter CNT_MAX_VAL = 9;
    // 组合逻辑,生成cnt_next
    always @(CNTVAL) begin
      if(CNTVAL < CNT_MAX_VAL) begin // 未计数到最大值, 下一值加1
        cnt_next = CNTVAL + 1'b1;
      end
      else begin // 计数到最大值,下一计数值为0
        cnt_next = 0;
      end
    end
    // 时序逻辑 更新下一时钟周期的计数值
    // CNTVAL 会被编译为D触发器
    always @ (posedge CLK) begin
        CNTVAL <= cnt_next;
    end
    // 组合逻辑,生成OV
    always @ (CNTVAL) begin
      if(CNTVAL == CNT_MAX_VAL) 
        OV = 1;
      else
        OV = 0;
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    2.仿真结果波形
    在这里插入图片描述
    如波形图所示,当经过9个周期的时钟信号后OV端口输出一个高电平的溢出信号。

    3.编写复杂计数器的Verilog HDL代码

     计数器代码  /
    
    module top(
      RST   , // 异步复位, 高有效
      CLK   , // 时钟,上升沿有效
      EN    , // 输入的计数使能,高有效
      CLR   , // 输入的清零信号,高有效
      LOAD  , // 输入的数据加载使能信号,高有效
      DATA  , // 输入的加载数据信号
      CNTVAL, // 输出的计数值信号
      OV    );// 计数溢出信号,计数值为最大值时该信号为1
    
    input RST   , CLK   , EN    , CLR   , LOAD  ;
    input [3:0] DATA ;
    output [3:0] CNTVAL;
    output OV;   
    reg [3:0] CNTVAL, cnt_next;
    reg OV;
    // 电路编译参数,最大计数值
    parameter CNT_MAX_VAL = 9;
    // 组合逻辑,生成cnt_next
    // 1st clr ,2nd en , 3rd load
    always @(EN or CLR or LOAD or DATA or CNTVAL) begin 
      if(CLR) begin    // 清零有效
    	cnt_next = 0;
      end
      else begin  // 清零无效
        if(EN) begin // 使能有效
          if(LOAD) begin // 加载有效
            cnt_next = DATA;
          end
          else begin     // 加载无效,正常计数
            // 使能有效,清零和加载都无效,根据当前计数值计算下一值
            if(CNTVAL < CNT_MAX_VAL) begin // 未计数到最大值, 下一值加1
              cnt_next = CNTVAL + 1'b1;
            end
            else begin // 计数到最大值,下一计数值为0
              cnt_next = 0;
            end
          end // else LOAD
        end // EN
        else begin  // 使能无效,计数值保持不动
          cnt_next = CNTVAL;
        end // else EN
      end //else CLR
    end
    // 时序逻辑 更新下一时钟周期的计数值
    // CNTVAL 会被编译为D触发器
    always @ (posedge CLK or posedge RST) begin
      if(RST) 
        CNTVAL <= 0;
      else
        CNTVAL <= cnt_next;
    end
    // 组合逻辑,生成OV
    always @ (CNTVAL) begin
      if(CNTVAL == CNT_MAX_VAL) 
        OV = 1;
      else
        OV = 0;
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62

    4.仿真结果波形
    在这里插入图片描述
    由仿真结果可知,计数器按照同步清零CLR的优先级最高,使能EN次之,LOAD最低的设置工作。

    状态机

    一.实验内容

    1.设计一个用于识别2进制序列“1011”的状态机

    基本要求:
    电路每个时钟周期输入1比特数据,当捕获到1011的时钟周期,电路输出1,否则输出0
    使用序列101011010作为输出的测试序列
    扩展要求:
    给你的电路添加输入使能端口,只有输入使能EN为1的时钟周期,才从输入的数据端口向内部获取1比特序列数据。

    二.实验步骤

    1.绘制状态跳转逻辑表

    当前状态 IN EN 次态
    ST_0 0 0 ST_0
    ST_0 0 1 ST_0
    ST_0 1 0 ST_0
    ST_0 1 1 ST_0
    ST_1 0 0 ST_1
    ST_1 0 1 ST_2
    ST_1 1 0 ST_1
    ST_1 1 1 ST_1
    ST_2 0 0 ST_2
    ST_2 0 1 ST_0
    ST_2 1 0 ST_2
    ST_2 1 1 ST_3
    ST_3 0 0 ST_3
    ST_3 0 1 ST_2
    ST_3 1 0 ST_3
    ST_3 1 1 ST_4
    ST_4 X X ST_0

    2.绘制输出逻辑表

    当前状态 输出
    ST_0 0
    ST_1 0
    ST_2 0
    ST_3 0
    ST_4 1

    3.编写Verilog HDL代码

      三段式状态机代码  /
    module top(
      CLK       ,   // clock
      RST       ,   // reset
      IN        ,   // input
      EN        ,   // EN
      OUT       );  // output 
    
    input  CLK       ; 
    input  RST       ; 
    input  EN        ; 
    input  IN        ;
    output OUT       ;
    
    parameter ST_0 = 0;
    parameter ST_1 = 1;
    parameter ST_2 = 2;
    parameter ST_3 = 3;
    parameter ST_4 = 4;
    
    reg [2:0]stateR       ;
    reg [2:0]next_state   ;
    reg OUT               ;
    
    // calc next state
    always @ (IN or EN or stateR) begin
      case (stateR)
        ST_0 :begin if(IN==0&&EN==0) next_state = ST_0 ; else if(IN==0&&EN==1) next_state = ST_0; else if(IN==1&&EN==0) next_state = ST_0; else if(IN==1&&EN==1) next_state = ST_1; end
        ST_1 :begin if(IN==0&&EN==0) next_state = ST_1 ; else if(IN==0&&EN==1) next_state = ST_2; else if(IN==1&&EN==0) next_state = ST_1; else if(IN==1&&EN==1) next_state = ST_1; end
        ST_2 :begin if(IN==0&&EN==0) next_state = ST_2 ; else if(IN==0&&EN==1) next_state = ST_0; else if(IN==1&&EN==0) next_state = ST_2; else if(IN==1&&EN==1) next_state = ST_3; end
        ST_3 :begin if(IN==0&&EN==0) next_state = ST_3 ; else if(IN==0&&EN==1) next_state = ST_2; else if(IN==1&&EN==0) next_state = ST_3; else if(IN==1&&EN==1) next_state = ST_4; end
        ST_4 :begin next_state = ST_0; end
      endcase
    end
    
    // calc output
    always @ (stateR) begin
      if(stateR == ST_4) 
        OUT = 1'b1;
      else 
        OUT = 1'b0;
    end
    
    // state DFF
    always @ (posedge CLK or posedge RST)begin
      if(RST)
        stateR <= ST_0;
      else
        stateR <= next_state;
    end
    
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    4.仿真结果波形
    在这里插入图片描述

    移位寄存器

    一.实验内容

    设计一个带加载使能和移位使能的并入串出的移位寄存器,电路的RTL结构图如下图图所示。
    在这里插入图片描述

    二.实验步骤

    1.编写移位寄存器代码

    ///PISO WITH EN_LOAD AND EN_SHIFT
    module top(
      CLK         , //时钟信号
      RST         , //复位信号输入
      EN_LOAD     , //加载输入数据使能
      EN_SHIFT    , //移位使能
      IN          , //并行输入数据
      OV          , //一组数据完全移出提示
      OUT         );//穿行输出
      
    input RST, CLK, EN_LOAD, EN_SHIFT;
    input [7:0] IN;
    output OUT,OV;
    reg shift_R,OV;
    reg [7:0] shift_V;
    reg [3:0] n;//移位次数计数
    
    assign OUT = shift_R;//最右端移出数据
    
    always @ (posedge CLK or posedge RST) begin
      if(RST) begin
        shift_R <= 0;
        shift_V <= 0;
        n <= 0;
      end
      else begin
        if(EN_SHIFT) begin
    	  if(EN_LOAD) begin
    		shift_V <= IN;并行输入载入
    	  end
    	  else begin
    	    shift_R <= shift_V[0];
    	    shift_V[6:0] <= shift_V[7:1];
    	    shift_V[7] <= 0;//一次移位完成
    	    n <= n + 1;//移位次数+1
    	  end
    	end
    	else begin
    	  shift_R <= shift_R;//未使能移位,保持不动
    	end
      end
    end
    always @ (n) begin
      if(n==8)  //当移完一组(8bit)数据后OV端口输出1提示
    	OV = 1;
      else
    	OV = 0;
    end
    endmodule
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    2.仿真结果波形
    在这里插入图片描述

    展开全文
  • 现在大部分公司做数字芯片开发都需要用到Verilog,在RTL 代码即将完成时,有必要使用vcs + DVE去查看经过仿真后的CASE代码覆盖率,保证代码本身是没问题的。
  • iic从机RTL代码,可综合,AISC程序,已经流过片了,并在FPGA上进行了原型验证
  • 兼容opencores.org的I2C slave的RTL代码,是verilog代码
  • 兼容opencores.org的I2C slave的RTL代码.7z
  • 生成RTL代码 简单3个步骤就可以自动生成RTL代码。 1)模型设计的顶层放置一个代码生成控制器,设置RTL代码的模块名称和一些文件头信息,时钟频率将用于自动生成的DC综合脚本。 2)开启RTL代码生成服务器 3)运行一...

    模型设计

    先看一下DDS的模型设计。
    在这里插入图片描述

    生成RTL代码

    简单3个步骤就可以自动生成RTL代码。
    1)模型设计的顶层放置一个代码生成控制器,设置RTL代码的模块名称和一些文件头信息,时钟频率将用于自动生成的DC综合脚本。
    在这里插入图片描述
    2)开启RTL代码生成服务器
    3)运行一次Simulink仿真
    在这里插入图片描述

    RTL代码解析

    1)文件头

    在这里插入图片描述
    与模型设计中的RTL Generate Control的参数设置对应。

    2)模块声明和端口声明

    在这里插入图片描述
    与输入端口模型和输出端口模型对应:
    在这里插入图片描述
    在这里插入图片描述
    CLK和RST_N是数字电路两个必要的信号,隐含在模型设计的基于节拍的仿真方式中。

    3)每个模型对应的输出信号的声明

    在这里插入图片描述

    4)加法器

    在这里插入图片描述
    对应模型:
    在这里插入图片描述
    加法器的两个输入,一个来自输入端口FREQ,一个来自寄存器Reg3_REG。

    加法器遵循“无精度损失”原则,输出位宽相对输入位宽会有所增加。

    5)定点化处理器

    在这里插入图片描述
    对应模型:
    在这里插入图片描述

    6) 单元延时器(寄存器)

    在这里插入图片描述
    对应模型:
    在这里插入图片描述

    7)LUT前的定点化处理器

    在这里插入图片描述
    对应模型:
    在这里插入图片描述
    LUT的地址空间大小由输入信号的位宽决定,需要用定点化处理模型限制位宽,降低LUT的电路规模。

    8)LUT,存储正弦波数据

    在这里插入图片描述
    在这里插入图片描述
    对应模型:
    在这里插入图片描述

    9)输出级寄存器

    在这里插入图片描述
    对应模型:
    在这里插入图片描述

    10)输出赋值与模块结束

    在这里插入图片描述
    对应模型:
    在这里插入图片描述

    11)资源使用统计

    在这里插入图片描述
    对于位宽异常大的信号,需要检查确认是否符合设计预期。

    完整verilog代码

    //-----------------------------------------------------------------------------
    // FILE     :  rtlgen_demo_dds.v
    // AUTHOR   :  myName
    // DATE     :  2020-08-15
    // ABSTRACT : 
    //    test simu-rtl_gen
    //
    //=====================================================================
    // Created with SIMU2RTL(v20200814)
    //       @ 2020-08-15 19:21:12
    // Simulink System: 
    //   tb_demo_dds
    //=====================================================================
    // TESTBENCH FILE     : rtlgen_demo_dds_tb.v
    // TEST STIMULUS FILE : ./test_data/*.vec
    //
    // @Copyright 2020 MyCorp 
    // All rights reserved.
    //-----------------------------------------------------------------------------
    module rtlgen_demo_dds (
            CLK ,
            RST_N ,
            FREQ ,   // <24,0,u>
    
            DOUT     // <10,0,t>
        ); 
    // ports declaration
    input           CLK ;
    input           RST_N ;
    input   [23:0]  FREQ ;   // <24,0,u>
    
    output  [ 9:0]  DOUT ;   // <10,0,t>
    //-----------------------------------------------------------------------------
    // internal signals declaration
    reg     [ 9:0]     Reg6_REG ;   // <10,0,t>  
    reg     [23:0]     Reg3_REG ;   // <24,0,u>  
    wire    [24:0]     Add1_CMB ;   // <25,1,u>  
    wire    [23:0]     Fmt2_CMB ;   // <24,0,u>  
    wire    [ 7:0]     Fmt4_CMB ;   // <8,0,u>  
    reg     [ 9:0]     Lut5_CMB ;   // <10,0,t>  
    //-----------------------------------------------------------------------------
    
    
    //----------------------------------------------------------------------------- 
    // hilite_system('tb_demo_dds/DDS/Adder') 
    // Adder #1 : <24,0,u> + <24,0,u> --> <25,1,u> 
    assign Add1_CMB = {1'B0,Reg3_REG}+{1'B0,FREQ}; 
    //----------------------------------------------------------------------------- 
    
    //----------------------------------------------------------------------------- 
    // hilite_system('tb_demo_dds/DDS/Format') 
    // Format #2 : wrap & truncate <25,1,u> to <24,0,u> 
    assign Fmt2_CMB = Add1_CMB[23:0]; 
    //----------------------------------------------------------------------------- 
    
    //----------------------------------------------------------------------------- 
    // hilite_system('tb_demo_dds/DDS/UnitDelay') 
    // Register #3 : <24,0,u> 
    always @(posedge CLK or negedge RST_N) 
    begin : proc_Reg3_REG 
        if(RST_N==1'B0) 
            Reg3_REG <= 24'H0;  // <24,0,u> 0.000000 
        else 
            Reg3_REG <= Fmt2_CMB; 
    end 
    //----------------------------------------------------------------------------- 
    
    //----------------------------------------------------------------------------- 
    // hilite_system('tb_demo_dds/DDS/Format1') 
    // Format #4 : wrap & truncate <24,0,u> to <8,0,u> 
    assign Fmt4_CMB = Reg3_REG[23:16]; 
    //----------------------------------------------------------------------------- 
    
    //----------------------------------------------------------------------------- 
    // hilite_system('tb_demo_dds/DDS/LUT') 
    // LUT #5 : <8,0,u> --> <10,0,t> 
    always @(Fmt4_CMB) 
    begin : proc_Lut5_CMB 
        case(Fmt4_CMB) 
            8'D0 : Lut5_CMB = 10'D0; 
            8'D1 : Lut5_CMB = 10'D13; 
            8'D2 : Lut5_CMB = 10'D25; 
            8'D3 : Lut5_CMB = 10'D38; 
            8'D4 : Lut5_CMB = 10'D50; 
            8'D5 : Lut5_CMB = 10'D63; 
            8'D6 : Lut5_CMB = 10'D75; 
            8'D7 : Lut5_CMB = 10'D88; 
            8'D8 : Lut5_CMB = 10'D100; 
            8'D9 : Lut5_CMB = 10'D112; 
            8'D10 : Lut5_CMB = 10'D124; 
            8'D11 : Lut5_CMB = 10'D137; 
            8'D12 : Lut5_CMB = 10'D149; 
            8'D13 : Lut5_CMB = 10'D161; 
            8'D14 : Lut5_CMB = 10'D172; 
            8'D15 : Lut5_CMB = 10'D184; 
            8'D16 : Lut5_CMB = 10'D196; 
            8'D17 : Lut5_CMB = 10'D207; 
            8'D18 : Lut5_CMB = 10'D219; 
            8'D19 : Lut5_CMB = 10'D230; 
            8'D20 : Lut5_CMB = 10'D241; 
            8'D21 : Lut5_CMB = 10'D252; 
            8'D22 : Lut5_CMB = 10'D263; 
            8'D23 : Lut5_CMB = 10'D274; 
            8'D24 : Lut5_CMB = 10'D284; 
            8'D25 : Lut5_CMB = 10'D295; 
            8'D26 : Lut5_CMB = 10'D305; 
            8'D27 : Lut5_CMB = 10'D315; 
            8'D28 : Lut5_CMB = 10'D325; 
            8'D29 : Lut5_CMB = 10'D334; 
            8'D30 : Lut5_CMB = 10'D344; 
            8'D31 : Lut5_CMB = 10'D353; 
            8'D32 : Lut5_CMB = 10'D362; 
            8'D33 : Lut5_CMB = 10'D371; 
            8'D34 : Lut5_CMB = 10'D379; 
            8'D35 : Lut5_CMB = 10'D388; 
            8'D36 : Lut5_CMB = 10'D396; 
            8'D37 : Lut5_CMB = 10'D404; 
            8'D38 : Lut5_CMB = 10'D411; 
            8'D39 : Lut5_CMB = 10'D419; 
            8'D40 : Lut5_CMB = 10'D426; 
            8'D41 : Lut5_CMB = 10'D433; 
            8'D42 : Lut5_CMB = 10'D439; 
            8'D43 : Lut5_CMB = 10'D445; 
            8'D44 : Lut5_CMB = 10'D452; 
            8'D45 : Lut5_CMB = 10'D457; 
            8'D46 : Lut5_CMB = 10'D463; 
            8'D47 : Lut5_CMB = 10'D468; 
            8'D48 : Lut5_CMB = 10'D473; 
            8'D49 : Lut5_CMB = 10'D478; 
            8'D50 : Lut5_CMB = 10'D482; 
            8'D51 : Lut5_CMB = 10'D486; 
            8'D52 : Lut5_CMB = 10'D490; 
            8'D53 : Lut5_CMB = 10'D493; 
            8'D54 : Lut5_CMB = 10'D497; 
            8'D55 : Lut5_CMB = 10'D500; 
            8'D56 : Lut5_CMB = 10'D502; 
            8'D57 : Lut5_CMB = 10'D504; 
            8'D58 : Lut5_CMB = 10'D506; 
            8'D59 : Lut5_CMB = 10'D508; 
            8'D60 : Lut5_CMB = 10'D510; 
            8'D61 : Lut5_CMB = 10'D511; 
            8'D62 : Lut5_CMB = 10'D511; 
            8'D63 : Lut5_CMB = 10'D511; 
            8'D64 : Lut5_CMB = 10'D511; 
            8'D65 : Lut5_CMB = 10'D511; 
            8'D66 : Lut5_CMB = 10'D511; 
            8'D67 : Lut5_CMB = 10'D511; 
            8'D68 : Lut5_CMB = 10'D510; 
            8'D69 : Lut5_CMB = 10'D508; 
            8'D70 : Lut5_CMB = 10'D506; 
            8'D71 : Lut5_CMB = 10'D504; 
            8'D72 : Lut5_CMB = 10'D502; 
            8'D73 : Lut5_CMB = 10'D500; 
            8'D74 : Lut5_CMB = 10'D497; 
            8'D75 : Lut5_CMB = 10'D493; 
            8'D76 : Lut5_CMB = 10'D490; 
            8'D77 : Lut5_CMB = 10'D486; 
            8'D78 : Lut5_CMB = 10'D482; 
            8'D79 : Lut5_CMB = 10'D478; 
            8'D80 : Lut5_CMB = 10'D473; 
            8'D81 : Lut5_CMB = 10'D468; 
            8'D82 : Lut5_CMB = 10'D463; 
            8'D83 : Lut5_CMB = 10'D457; 
            8'D84 : Lut5_CMB = 10'D452; 
            8'D85 : Lut5_CMB = 10'D445; 
            8'D86 : Lut5_CMB = 10'D439; 
            8'D87 : Lut5_CMB = 10'D433; 
            8'D88 : Lut5_CMB = 10'D426; 
            8'D89 : Lut5_CMB = 10'D419; 
            8'D90 : Lut5_CMB = 10'D411; 
            8'D91 : Lut5_CMB = 10'D404; 
            8'D92 : Lut5_CMB = 10'D396; 
            8'D93 : Lut5_CMB = 10'D388; 
            8'D94 : Lut5_CMB = 10'D379; 
            8'D95 : Lut5_CMB = 10'D371; 
            8'D96 : Lut5_CMB = 10'D362; 
            8'D97 : Lut5_CMB = 10'D353; 
            8'D98 : Lut5_CMB = 10'D344; 
            8'D99 : Lut5_CMB = 10'D334; 
            8'D100 : Lut5_CMB = 10'D325; 
            8'D101 : Lut5_CMB = 10'D315; 
            8'D102 : Lut5_CMB = 10'D305; 
            8'D103 : Lut5_CMB = 10'D295; 
            8'D104 : Lut5_CMB = 10'D284; 
            8'D105 : Lut5_CMB = 10'D274; 
            8'D106 : Lut5_CMB = 10'D263; 
            8'D107 : Lut5_CMB = 10'D252; 
            8'D108 : Lut5_CMB = 10'D241; 
            8'D109 : Lut5_CMB = 10'D230; 
            8'D110 : Lut5_CMB = 10'D219; 
            8'D111 : Lut5_CMB = 10'D207; 
            8'D112 : Lut5_CMB = 10'D196; 
            8'D113 : Lut5_CMB = 10'D184; 
            8'D114 : Lut5_CMB = 10'D172; 
            8'D115 : Lut5_CMB = 10'D161; 
            8'D116 : Lut5_CMB = 10'D149; 
            8'D117 : Lut5_CMB = 10'D137; 
            8'D118 : Lut5_CMB = 10'D124; 
            8'D119 : Lut5_CMB = 10'D112; 
            8'D120 : Lut5_CMB = 10'D100; 
            8'D121 : Lut5_CMB = 10'D88; 
            8'D122 : Lut5_CMB = 10'D75; 
            8'D123 : Lut5_CMB = 10'D63; 
            8'D124 : Lut5_CMB = 10'D50; 
            8'D125 : Lut5_CMB = 10'D38; 
            8'D126 : Lut5_CMB = 10'D25; 
            8'D127 : Lut5_CMB = 10'D13; 
            8'D128 : Lut5_CMB = 10'D0; 
            8'D129 : Lut5_CMB = 10'D1011; 
            8'D130 : Lut5_CMB = 10'D999; 
            8'D131 : Lut5_CMB = 10'D986; 
            8'D132 : Lut5_CMB = 10'D974; 
            8'D133 : Lut5_CMB = 10'D961; 
            8'D134 : Lut5_CMB = 10'D949; 
            8'D135 : Lut5_CMB = 10'D936; 
            8'D136 : Lut5_CMB = 10'D924; 
            8'D137 : Lut5_CMB = 10'D912; 
            8'D138 : Lut5_CMB = 10'D900; 
            8'D139 : Lut5_CMB = 10'D887; 
            8'D140 : Lut5_CMB = 10'D875; 
            8'D141 : Lut5_CMB = 10'D863; 
            8'D142 : Lut5_CMB = 10'D852; 
            8'D143 : Lut5_CMB = 10'D840; 
            8'D144 : Lut5_CMB = 10'D828; 
            8'D145 : Lut5_CMB = 10'D817; 
            8'D146 : Lut5_CMB = 10'D805; 
            8'D147 : Lut5_CMB = 10'D794; 
            8'D148 : Lut5_CMB = 10'D783; 
            8'D149 : Lut5_CMB = 10'D772; 
            8'D150 : Lut5_CMB = 10'D761; 
            8'D151 : Lut5_CMB = 10'D750; 
            8'D152 : Lut5_CMB = 10'D740; 
            8'D153 : Lut5_CMB = 10'D729; 
            8'D154 : Lut5_CMB = 10'D719; 
            8'D155 : Lut5_CMB = 10'D709; 
            8'D156 : Lut5_CMB = 10'D699; 
            8'D157 : Lut5_CMB = 10'D690; 
            8'D158 : Lut5_CMB = 10'D680; 
            8'D159 : Lut5_CMB = 10'D671; 
            8'D160 : Lut5_CMB = 10'D662; 
            8'D161 : Lut5_CMB = 10'D653; 
            8'D162 : Lut5_CMB = 10'D645; 
            8'D163 : Lut5_CMB = 10'D636; 
            8'D164 : Lut5_CMB = 10'D628; 
            8'D165 : Lut5_CMB = 10'D620; 
            8'D166 : Lut5_CMB = 10'D613; 
            8'D167 : Lut5_CMB = 10'D605; 
            8'D168 : Lut5_CMB = 10'D598; 
            8'D169 : Lut5_CMB = 10'D591; 
            8'D170 : Lut5_CMB = 10'D585; 
            8'D171 : Lut5_CMB = 10'D579; 
            8'D172 : Lut5_CMB = 10'D572; 
            8'D173 : Lut5_CMB = 10'D567; 
            8'D174 : Lut5_CMB = 10'D561; 
            8'D175 : Lut5_CMB = 10'D556; 
            8'D176 : Lut5_CMB = 10'D551; 
            8'D177 : Lut5_CMB = 10'D546; 
            8'D178 : Lut5_CMB = 10'D542; 
            8'D179 : Lut5_CMB = 10'D538; 
            8'D180 : Lut5_CMB = 10'D534; 
            8'D181 : Lut5_CMB = 10'D531; 
            8'D182 : Lut5_CMB = 10'D527; 
            8'D183 : Lut5_CMB = 10'D524; 
            8'D184 : Lut5_CMB = 10'D522; 
            8'D185 : Lut5_CMB = 10'D520; 
            8'D186 : Lut5_CMB = 10'D518; 
            8'D187 : Lut5_CMB = 10'D516; 
            8'D188 : Lut5_CMB = 10'D514; 
            8'D189 : Lut5_CMB = 10'D513; 
            8'D190 : Lut5_CMB = 10'D513; 
            8'D191 : Lut5_CMB = 10'D512; 
            8'D192 : Lut5_CMB = 10'D512; 
            8'D193 : Lut5_CMB = 10'D512; 
            8'D194 : Lut5_CMB = 10'D513; 
            8'D195 : Lut5_CMB = 10'D513; 
            8'D196 : Lut5_CMB = 10'D514; 
            8'D197 : Lut5_CMB = 10'D516; 
            8'D198 : Lut5_CMB = 10'D518; 
            8'D199 : Lut5_CMB = 10'D520; 
            8'D200 : Lut5_CMB = 10'D522; 
            8'D201 : Lut5_CMB = 10'D524; 
            8'D202 : Lut5_CMB = 10'D527; 
            8'D203 : Lut5_CMB = 10'D531; 
            8'D204 : Lut5_CMB = 10'D534; 
            8'D205 : Lut5_CMB = 10'D538; 
            8'D206 : Lut5_CMB = 10'D542; 
            8'D207 : Lut5_CMB = 10'D546; 
            8'D208 : Lut5_CMB = 10'D551; 
            8'D209 : Lut5_CMB = 10'D556; 
            8'D210 : Lut5_CMB = 10'D561; 
            8'D211 : Lut5_CMB = 10'D567; 
            8'D212 : Lut5_CMB = 10'D572; 
            8'D213 : Lut5_CMB = 10'D579; 
            8'D214 : Lut5_CMB = 10'D585; 
            8'D215 : Lut5_CMB = 10'D591; 
            8'D216 : Lut5_CMB = 10'D598; 
            8'D217 : Lut5_CMB = 10'D605; 
            8'D218 : Lut5_CMB = 10'D613; 
            8'D219 : Lut5_CMB = 10'D620; 
            8'D220 : Lut5_CMB = 10'D628; 
            8'D221 : Lut5_CMB = 10'D636; 
            8'D222 : Lut5_CMB = 10'D645; 
            8'D223 : Lut5_CMB = 10'D653; 
            8'D224 : Lut5_CMB = 10'D662; 
            8'D225 : Lut5_CMB = 10'D671; 
            8'D226 : Lut5_CMB = 10'D680; 
            8'D227 : Lut5_CMB = 10'D690; 
            8'D228 : Lut5_CMB = 10'D699; 
            8'D229 : Lut5_CMB = 10'D709; 
            8'D230 : Lut5_CMB = 10'D719; 
            8'D231 : Lut5_CMB = 10'D729; 
            8'D232 : Lut5_CMB = 10'D740; 
            8'D233 : Lut5_CMB = 10'D750; 
            8'D234 : Lut5_CMB = 10'D761; 
            8'D235 : Lut5_CMB = 10'D772; 
            8'D236 : Lut5_CMB = 10'D783; 
            8'D237 : Lut5_CMB = 10'D794; 
            8'D238 : Lut5_CMB = 10'D805; 
            8'D239 : Lut5_CMB = 10'D817; 
            8'D240 : Lut5_CMB = 10'D828; 
            8'D241 : Lut5_CMB = 10'D840; 
            8'D242 : Lut5_CMB = 10'D852; 
            8'D243 : Lut5_CMB = 10'D863; 
            8'D244 : Lut5_CMB = 10'D875; 
            8'D245 : Lut5_CMB = 10'D887; 
            8'D246 : Lut5_CMB = 10'D900; 
            8'D247 : Lut5_CMB = 10'D912; 
            8'D248 : Lut5_CMB = 10'D924; 
            8'D249 : Lut5_CMB = 10'D936; 
            8'D250 : Lut5_CMB = 10'D949; 
            8'D251 : Lut5_CMB = 10'D961; 
            8'D252 : Lut5_CMB = 10'D974; 
            8'D253 : Lut5_CMB = 10'D986; 
            8'D254 : Lut5_CMB = 10'D999; 
            // 8'D255 
            default : Lut5_CMB = 10'D1011; 
        endcase 
    end 
    //----------------------------------------------------------------------------- 
    
    //----------------------------------------------------------------------------- 
    // hilite_system('tb_demo_dds/DDS/UnitDelay2') 
    // Register #6 : <10,0,t> 
    always @(posedge CLK or negedge RST_N) 
    begin : proc_Reg6_REG 
        if(RST_N==1'B0) 
            Reg6_REG <= 10'H0;  // <10,0,t> 0.000000 
        else 
            Reg6_REG <= Lut5_CMB; 
    end 
    //----------------------------------------------------------------------------- 
    
    //-----------------------------------------------------------------------------
    // Output
    assign DOUT = Reg6_REG;   // <10,0,t>  hilite_system('tb_demo_dds/DDS/OUP') 
    //-----------------------------------------------------------------------------
    
    endmodule  // rtlgen_demo_dds  
    
    //-----------------------------------------------------------------------------
    // Statistics:
    //     Input Port(non-memory): 1
    //     Output Port(non-memory): 1
    //     Instances(non-memory): 8
    //     Internal Signal: 6
    
    //     Total Register: 34 bits
    //-----------------------------------------------------------------------------
    //-----------------------------------------------------------------------------
    // Internal Comb. Signals Top 50  (Vector Excluded)
    // Index                      NAME               FXP
    //  #  1                  Add1_CMB          <25,1,u>
    //  #  2                  Fmt2_CMB          <24,0,u>
    //  #  3                  Fmt4_CMB           <8,0,u>
    //-----------------------------------------------------------------------------
    // Internal Registers Top 50  (Vector Excluded)
    // Index                      NAME               FXP
    //  #  1                  Reg3_REG          <24,0,u>
    //  #  2                  Reg6_REG          <10,0,t>
    //-----------------------------------------------------------------------------
    // Multiplier Count: 0    Total bits: 0
    // Multiplier Top 50 of 0
    // Index                      NAME               FXP
    //-----------------------------------------------------------------------------
    // Adder/Subtractor Count: 1    Total bits: 0
    // Adder/Subtractor Top 50 of 1
    // Index                      NAME               FXP
    //  #  1                  Add1_CMB          <25,1,u>
    //-----------------------------------------------------------------------------
    //-----------------------------------------------------------------------------
    // End of the file.
    //-----------------------------------------------------------------------------
    
    展开全文
  • RTL代码之面积与功耗

    2020-09-14 17:39:10
    触发器、加法器、乘法器的使用注意,触发器数量由功能决定,很难减少,由组合逻辑决定,对应的RTL代码是各种操作符。 2、多比特会成倍使用资源,在对信号操作前是否能只对需要的部分比特操作。 例如 if(A<32)...

    一、面积

    在RTL编码中减少设计面积:

    (1)估计设计使用资源的数量

    (2)知道哪部分占用了较大面积。

    1、资源:+、-、x、÷、<、> 都会产生比较大的面积。+:对应一个64位加法器。

    触发器、加法器、乘法器的使用注意,触发器数量由功能决定,很难减少,由组合逻辑决定,对应的RTL代码是各种操作符

    2、多比特会成倍使用资源,在对信号操作前是否能只对需要的部分比特操作

    例如 if(A<32)可以换成if(A[5]=1'b1),A如果比32小,A[5]一定是0。用1bit的逻辑门代替了6bit的比较器。

    例如:访问RAM,每隔32个地址写入一个值。

    addr<=addr+32 改写为: addr[7:5]<=addr[7:5]+1; addr[4:0]<=addr[4:0]+0;

    3、如果使用复杂的运算符,可以考虑使用资源共享编写RTL。

    例如

    if(a+b+c)y1;

    if(a+b+d)y2;

    改写为

    sum<=a+b;

    if(sum+c) y1;

    if(sum+d) y2;

    二、功耗

    门控时钟:直接关闭整个时钟,效果更好。

    增加使能控制:使得电路的信号不再翻转,而时钟还会翻转。

    RTL的布线:布线过于集中产生热点

     

    展开全文
  • Verilog RTL 代码设计新手上路 做一个4选1的mux,并且进行波形仿真 和2选1的mux对比,观察资源消耗的变化 实验代码 RTL 视图 仿真波形 资源对比 2选1 4选1 实验结论 通过实验发现,...

    做一个4选1的mux,并且进行波形仿真 和2选1的mux对比,观察资源消耗的变化

    1. 实验代码
      在这里插入图片描述

    2. RTL 视图 在这里插入图片描述

    3. 仿真波形在这里插入图片描述

    4. 资源对比
      2选1在这里插入图片描述
      4选1在这里插入图片描述

    5. 实验结论
      通过实验发现,4选消耗的资源更多。

    编写一个8输入的优先编码器,然后编译,看RTL View

    1. 实验代码
      在这里插入图片描述

    2. RTL视图在这里插入图片描述

    3. 仿真波形在这里插入图片描述

    4. 资源对比
      4位优先编码器在这里插入图片描述
      8位优先编码器在这里插入图片描述

    5. 资源对比
      8位优先编码器消耗资源更多。

    编写一个4-16的译码器,编译

    1. 实验代码在这里插入图片描述
    2. RTL视图在这里插入图片描述
    3. 资源对比
      3-8译码器在这里插入图片描述
      4-16译码器在这里插入图片描述

    无符号加法器

    1. 4位输入4位输出在这里插入图片描述
      波形仿真在这里插入图片描述
    2. 8位输入5位输出
      实验代码
      在这里插入图片描述
      波形仿真
      在这里插入图片描述
    3. 实验总结
      4输入4输出的加法器在结果大于16的时候只能输出最后一位。
      8输入5输出的加法器在结果大于32的时候输出结果就不正确。
      8输入的信号,输出延时比较大。

    补码加法器

    1. 4输入4输出的补码加法器
      实验代码
      在这里插入图片描述
      波形仿真
      在这里插入图片描述
      2. 8位输入5位输出的补码加法器
      实验代码
      在这里插入图片描述
      波形仿真
      在这里插入图片描述
      3. 实验总结
      与无符号加法器原理类似,只是换成了补码运算。

    带流水线的加法器

    1. 8输入5输出的带流水线的加法器
      实验代码
      在这里插入图片描述
      波形仿真
      在这里插入图片描述
    2. 8输入5输出再加一级流水线
      实验代码
      在这里插入图片描述
      RTL视图
      在这里插入图片描述
      波形仿真
      在这里插入图片描述
    3. 实验结论
      与普通的加法器相比,带流水线的加法器增加了D触发器,减少了毛刺的产生。二级流水线的加法器,延时是一级流水线加法器的一倍。

    乘法器

    1. 8输入8输出的乘法器
      实验代码
      在这里插入图片描述
      波形仿真
      在这里插入图片描述
      2. 带流水线的乘法器
      实验代码
      在这里插入图片描述
      波形仿真
      在这里插入图片描述
    2. 实验结论
      8输入8输出的乘法器,毛刺较多。带流水线的乘法器毛刺较少,时延延后一个周期。

    计数器

    1. 只有ov和clk的计数器
      实验代码
      在这里插入图片描述
      仿真波形
      在这里插入图片描述
    2. 设计复杂的计数器,带有多种信号,其中同步清零CLR的优先级最高,使能EN次之,LOAD最低。
      实验代码
      在这里插入图片描述
      仿真波形
      在这里插入图片描述

    状态机

    设计一个用于识别2进制序列“1011”的状态机

    基本要求:
    电路每个时钟周期输入1比特数据,当捕获到1011的时钟周期,电路输出1,否则输出0
    使用序列101011010作为输出的测试序列
    扩展要求:
    给你的电路添加输入使能端口,只有输入使能EN为1的时钟周期,才从输入的数据端口向内部获取1比特序列数据。

    实验代码

    在这里插入图片描述
    波形仿真

    在这里插入图片描述
    状态转换表
    在这里插入图片描述

    展开全文
  • 自动RTL代码的特点完全自动生成,需要的手工编码工作量为零与模型设计完全同构,功能性能完全相同不需要在RTL上做任何调试工作,所有的调试都应该在更高效的模型设计环境中进行自动生成一致性仿真验证平台;...
  • 用PlanAhead进行RTL代码开发与分析这里介绍如何用PlanAhead进行RTL代码开发与分析。需要说明一点,本章所用的所有实例都可以在PlanAhead的安装目录E:\Xilinx\11.1\PlanAhead\testcases\PlanAhead_Tutorial下找到,本...
  • 【代码】RTL代码之任意分频器(附带Testbench) 前言 作为一门基本的电路单元,分频在数字IC前端设计中具有重要的地位。在分频时,首先想到的是使用利用计算器来计算达到想要的时钟频率,但问题是仅仅利用计数器来...
  • 注意:如果您仅对上传代码感兴趣,则无需设置和安装RTL工具链。 有关设置环境的更多详细信息,请参见 。 构建配置(Verilog定义): SOC改为使用内部BRAM存储器接口进行编译 SIM编译进行仿真 适用于SRAM编程器的...
  • 用软件从 C 转化来的 RTL 代码其实并不好理解。今天我们就来谈谈,如何在不改变 RTL 代码的情况下,提升设计性能。本项目所需应用与工具:赛灵思 HLS、Plunify Cloud 以及 Intime。前言高层次的设计可以让设计以更...
  • SOC——Boundary scan模块的RTL代码设计(三) Boundary Scan Cell Types BC_2_B Type Cell BC_7 Type Cell Shown with BC_2_A Control Cell // module boundary_scan ( // jtg_shiftdr, jtg_clockdr_in, jtg_...
  • 最近查了一个bug,相同的RTL代码在我的工程下和别人的工程下跑出来的结果不同,最后查出来是我在RTL代码中把有些通用的parameter提出来做成了一个文件中,而出错的FPGA验证工程里恰好没有更新这个文件,这个看似一个...
  • RISC-V处理器:1.取指令 RTL 代码分析

    千次阅读 2019-03-08 21:51:25
    取指令 RTL 代码分析 1. 取指特点 指令在存储空间中所处的地址,称为它的指令PC(Program Counter) 取指是指处理器将指令,按照其指令PC,从存储器中读取出来的过程 处理器从存储器中取出指令的目标是:快速和连续...
  • Verilog RTL 代码设计示例

    千次阅读 2018-11-08 20:02:24
    四选一mux代码如下: RTL视图如下: 波形仿真如下: 2选1的mux资源消耗情况: 4选1的mux资源消耗情况: 4选1比2选1消耗资源更多。 实验二.编写一个4X4路交叉开关的RTL,然后编译,看RTL View 比较2...
  • 【EDA】实验4:常用元件的Verilog RTL 代码设计一.实验内容二.实验步骤1. 元件的连接2.仿真三.实验结果 一.实验内容 1.利用74161计数器芯片设计一个M=12的计数器 2.利用Quartus软件进行设计和仿真 3.观察仿真波形 二...
  • 在Vivado FlowNavigator中有一个Elaborated Design,如下图所示,属于RTL Analysis这一步对应的设计。可能很多工程师都没有使用到,而实际上对于代码优化,它是很有帮助的。通常情况下,我们总是习惯了打开综合后的...
  • 于是自己根据这个代码改写了一个I2C slave RTL代码,并修改了原来那个设计的testbench,将rtl的Slave替换了原来的behavior的Slave,在modelsim里面作了前仿,完全通过。还有一个myram.v文件,是一个register file...
  • 在当前的RTL设计中,国内仍以Verilog/VHDL为主,且不可否认未来或许很长一段时间仍旧是以Verilog/VHDL为主。SpinalHDL作为一门新的硬件描述语言,其充分考虑了这一点,也为我们在SpinalHDL的设计中提供了集成现有RTL...
  • RTL代码风格

    千次阅读 2013-08-12 10:26:35
    文件 一个文件只包含一个设计单元; 文件名与设计单元同名。 大小写 常量、参数要大些,其余都小写。 长信号名 用下划线“_”分隔单词。 信号前缀 i_:表示输入信号; o_:表示输出信号;...
  • Synopsys GTECH AND, OR, NOR gates One bit adder and half-adder 2-of-3 majority Multiplexer Flip-flop Latch Multiple level gates such as AND-NOT, AND-OR, AND-OR-INVERT, etc 时钟复位和同步器 ClockReset ...
  • Verilog RTL 代码设计新手上路

    万次阅读 2017-12-09 18:02:45
    1. 做一个4选1的mux,并且进行波形仿真 和2选1的mux对比,观察资源消耗的变化:...实验代码设计如下: RTL视图如下: 波形仿真结果如下: 资源消耗变化如下: 4选1的mux 2选1的mux 2. 编写一个4X4路交叉开关的RT
  • 标准DFF模块是一系列不同的模块,结构如下: |----rtl//存放RTL目录 |----e203//E203核和SoC的RTL目录 |----general//存放一些通用模块的RTL代码 |----sirv_gnrl_dffs.v//该文件中编写了一系列不同的DFF模块 例如:...
  • 1、状态机的时候用格雷码,格雷码每次只有一个反转。 2、选择二进制码的时候,原码和补码需要根据需求选择,位数适当,不要太大。 3、门控时钟,编码的时候应当考虑后端工具额能否加入门控时钟。...
  • 做一个4选1的mux,并且进行...实验代码设计如下: RTL视图如下: 波形仿真结果如下: 资源消耗变化如下: 2选1选择器 4选1选择器 编写一个4X4路交叉开关的RTL,然后编译,看RTL View 比较2x...
  • 算术运算的RTL代码规则总结

    千次阅读 2019-05-16 11:03:52
    这篇博文是上篇博文:【Verilog HDL 训练】第 12 天(数据通路)的指导规则。 对有符号数以及无符号数运算的一些指导规则。 注:英文为原文,中文为个人认为重要的总结。 1. Signed Arithmetic ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,342
精华内容 536
关键字:

rtl代码