• Verilog：【4】脉冲发生器（pulse_gen.sv）

    碎碎念：

    明明是周四，这周竟然不开组会_(:з)∠)_

    那我可以继续愉快地学习人家的代码了，这篇博客介绍的是脉冲发生器，脉冲和Killer Queen是不是很配呢hhh

    目录

    1 模块功能

    2 模块代码

    3 模块思路

    4 TestBench与仿真结果

    1 模块功能

    通过设置参数cntr_max与cntr_low，可以产生任意周期数与占空比的脉冲信号。

    2 模块代码

    1. //------------------------------------------------------------------------------
    2. // pulse_gen.sv
    3. // Konstantin Pavlov, pavlovconst@gmail.com
    4. //------------------------------------------------------------------------------
    5.  
    6. // INFO ------------------------------------------------------------------------
    7. // Pulse generator module, ver.2
    8. //
    9. // - generates one or many pulses of given width and period
    10. // - generates constant HIGH, constant LOW, or impulse output
    11. // - features buffered inputs, so inputs can change continiously during pulse period
    12. // - generates LOW when idle
    13. //
    14. // - Pulse period is (cntr_max[]+1) cycles
    15. // - If you need to generate constant LOW pulses, then CNTR_WIDTH should allow
    16. //   setting cntr_low[]>cntr_max[]
    17. //
    18. // Example 1:
    19. //      let CNTR_WIDTH = 8
    20. //      let cntr_max[7:0] = 2^CNTR_WIDTH-2 = 254, pulse period is 255 cycles
    21. //      cntr_low[7:0]==255              then output will be constant LOW
    22. //      0
    23. //      cntr_low[7:0]==0                then output will be constant HIGH
    24. //
    25. // Example 2:
    26. //      let CNTR_WIDTH = 9
    27. //      let cntr_max[8:0] = 255, pulse period is 256 cycles
    28. //      cntr_low[8:0]>255               then output will be constant LOW
    29. //      0
    30. //      cntr_low[8:0]==0                then output will be constant HIGH
    31. //
    32. //      In Example 2 constant LOW state can be acheived also by disabling start
    33. //      condition or holding reset input, so cntr_low[8:0] and cntr_max[8:0]
    34. //      can be left 8-bit-wide actually
    35.  
    36.  
    37.  
    38. /* --- INSTANTIATION TEMPLATE BEGIN ---
    40. pulse_gen #(
    41.   .CNTR_WIDTH( 8 )
    42. ) pg1 (
    43.   .clk( clk ),
    44.   .nrst( nrst ),
    46.   .start( 1'b1 ),
    47.   .cntr_max( 255 ),
    48.   .cntr_low( 2 ),
    50.   .pulse_out(  ),
    52.   .start_strobe,
    53.   .busy(  )
    54. );
    56. --- INSTANTIATION TEMPLATE END ---*/
    57.  
    58. module pulse_gen #( parameter
    59.   CNTR_WIDTH = 32
    60. )(
    61.   input clk,                          // system clock
    62.   input nrst,                         // negative reset
    63.  
    64.   input start,                        // enables new period start
    65.   input [CNTR_WIDTH-1:0] cntr_max,    // counter initilization value, should be > 0
    66.   input [CNTR_WIDTH-1:0] cntr_low,    // transition to LOW counter value
    67.  
    68.   output logic pulse_out,                   // active HIGH output
    69.  
    70.   // status outputs
    71.   output logic start_strobe = 1'b0,
    72.   output busy
    73. );
    74.  
    75.  
    76. logic [CNTR_WIDTH-1:0] seq_cntr = '0;
    77.  
    78. logic seq_cntr_0;
    79. assign seq_cntr_0 = (seq_cntr[CNTR_WIDTH-1:0] == '0);
    80.  
    81. // delayed one cycle
    82. logic seq_cntr_0_d1;
    83. always_ff @(posedge clk) begin
    84.   if( ~nrst) begin
    85.     seq_cntr_0_d1 <= 0;
    86.   end else begin
    87.     seq_cntr_0_d1 <= seq_cntr_0;
    88.   end
    89. end
    90.  
    91. // first seq_cntr_0 cycle time belongs to pulse period
    92. // second and further seq_cntr_0 cycles are idle
    93. assign busy = ~(seq_cntr_0 && seq_cntr_0_d1);
    94.  
    95.  
    96. // buffering cntr_low untill pulse period is over to allow continiously
    97. //  changing inputs
    98. logic [CNTR_WIDTH-1:0] cntr_low_buf = '0;
    99. always_ff @(posedge clk) begin
    100.   if( ~nrst ) begin
    101.     seq_cntr[CNTR_WIDTH-1:0] <= '0;
    102.     cntr_low_buf[CNTR_WIDTH-1:0] <= '0;
    103.     start_strobe <= 1'b0;
    104.   end else begin
    105.     if( seq_cntr_0 ) begin
    106.       // don`t start if cntr_max[] is illegal value
    107.       if( start && (cntr_max[CNTR_WIDTH-1:0]!='0) ) begin
    108.         seq_cntr[CNTR_WIDTH-1:0] <= cntr_max[CNTR_WIDTH-1:0];
    109.         cntr_low_buf[CNTR_WIDTH-1:0] <= cntr_low[CNTR_WIDTH-1:0];
    110.         start_strobe <= 1'b1;
    111.       end else begin
    112.         start_strobe <= 1'b0;
    113.       end
    114.     end else begin
    115.       seq_cntr[CNTR_WIDTH-1:0] <= seq_cntr[CNTR_WIDTH-1:0] - 1'b1;
    116.       start_strobe <= 1'b0;
    117.     end
    118.   end // ~nrst
    119. end
    120.  
    121. always_comb begin
    122.   if( ~nrst ) begin
    123.     pulse_out <= 1'b0;
    124.   end else begin
    125.     // busy condition guarantees LOW output when idle
    126.     if( busy &&
    127.         (seq_cntr[CNTR_WIDTH-1:0] >= cntr_low_buf[CNTR_WIDTH-1:0]) ) begin
    128.       pulse_out <= 1'b1;
    129.     end else begin
    130.       pulse_out <= 1'b0;
    131.     end
    132.   end // ~nrst
    133. end
    134.  
    135.  
    136. endmodule
    137.

    3 模块思路

    在明确了整个模块的功能之后，也就比较看出主要思路就是利用计数器的原理，利用对计数值的判断，来控制输出脉冲的信号，下面来具体进行说明。

    1.模块接口定义部分（58-73行）

    包含一个内部寄存器宽度参数CNTR_WIDTH；五个输入端口分别是时钟clk、低电平复位信号nrst、新周期开始信号start、起点计数值cntr_max、跳变计数值cntr_low；三个输出端口分别是脉冲输出信号pulse_out、输出状态信号start_strobe、忙碌信号busy。

    这里同样使用了logic类型，在前几期的内容也有涉及到。

    2.中间变量定义（76-79行）

    定义了存储计数值的寄存器seq_cntr、以及标志其是否为0的寄存器seq_cntr_0。

    3.延时一个周期（81-89行）

    利用always_ff构建D触发器，从而获得seq_cntr_0延时一周期后的信号seq_cntr_0_d1。

    4.输出busy信号的逻辑（93行）

    当本周期与上一周期计数值都是0的时候，此时表示不在输出有效时间段，即busy=0；当start恒等于1时，因为计数值一定会变化，因此busy始终都是1。

    读者可以结合仿真结果来看，我认为这一设计还是比较巧妙的，利用组合逻辑与延时的处理，让busy信号和计数器的结果就没有出现那种会错开一周期的情况（我本人有时会遇到_(:з)∠)_）。

    5.计数器运行逻辑（96-119行）

    利用always_ff构建D触发器，来实现整个运行的逻辑。当seq_cntr_0=1时，表示此时计数值为0，因此作为脉冲的起点，开始修改cntr_low等参数。

    重点关注107行，当start信号出现一周期的高电平，同时cntr_max信号是有效值（大于0）时，将cntr_max的值赋值给seq_cntr；将cntr_low的值赋值给cntr_low_buf；start_strobe置为到1（持续一周期），表示开始启动脉冲的发生器。

    之后start信号变为低电平，此时开始每周期将计数器结果减1。

    在这里，cntr_max就控制了脉冲发生器的周期；cntr_low相对于cntr_max的大小，就控制了输出的占比空。

    6.脉冲信号输出逻辑（121-133行）

    这一部分就是比较简单的组合逻辑啦，使用always_comb搭建。通过判断当前的计数值，来控制脉冲信号的输出。

    从代码可以看出：seq_cntr大于等于cntr_low_buf时，输出是1；seq_cntr小于cntr_low_buf时，输出是0。

    4 TestBench与仿真结果

    1. //------------------------------------------------------------------------------
    2. // pulse_gen_tb.sv
    3. // Konstantin Pavlov, pavlovconst@gmail.com
    4. //------------------------------------------------------------------------------
    6. // INFO ------------------------------------------------------------------------
    7. // testbench for pulse_gen.sv module
    10. `timescale 1ns / 1ps
    11.  
    12. module pulse_gen_tb();
    13.  
    14. logic clk200;
    15. initial begin
    16.   #0 clk200 = 1'b0;
    17.   forever
    18.     #2.5 clk200 = ~clk200;
    19. end
    20.  
    21. // external device "asynchronous" clock
    22. logic clk33;
    23. initial begin
    24.   #0 clk33 = 1'b0;
    25.   forever
    26.     #15.151 clk33 = ~clk33;
    27. end
    28.  
    29. logic rst;
    30. initial begin
    31.   #0 rst = 1'b0;
    32.   #10.2 rst = 1'b1;
    33.   #5 rst = 1'b0;
    34.   //#10000;
    35.   forever begin
    36.     #9985 rst = ~rst;
    37.     #5 rst = ~rst;
    38.   end
    39. end
    40.  
    41. logic nrst;
    42. assign nrst = ~rst;
    43.  
    44. logic rst_once;
    45. initial begin
    46.   #0 rst_once = 1'b0;
    47.   #10.2 rst_once = 1'b1;
    48.   #5 rst_once = 1'b0;
    49. end
    50.  
    51. logic nrst_once;
    52. assign nrst_once = ~rst_once;
    53.  
    54. logic [31:0] DerivedClocks;
    55. clk_divider #(
    56.   .WIDTH( 32 )
    57. ) cd1 (
    58.   .clk( clk200 ),
    59.   .nrst( nrst_once ),
    60.   .ena( 1'b1 ),
    61.   .out( DerivedClocks[31:0] )
    62. );
    64. logic [31:0] E_DerivedClocks;
    65. edge_detect ed1[31:0] (
    66.   .clk( {32{clk200}} ),
    67.   .anrst( {32{nrst_once}} ),
    68.   .in( DerivedClocks[31:0] ),
    69.   .rising( E_DerivedClocks[31:0] ),
    70.   .falling(  ),
    71.   .both(  )
    72. );
    74. logic [31:0] RandomNumber1;
    75. c_rand rng1 (
    76.   .clk( clk200 ),
    77.   .rst( 1'b0 ),
    78.   .reseed( rst_once ),
    79.   .seed_val( DerivedClocks[31:0] ^ (DerivedClocks[31:0] << 1) ),
    80.   .out( RandomNumber1[15:0] )
    81. );
    82.  
    83. c_rand rng2 (
    84.   .clk( clk200 ),
    85.   .rst( 1'b0 ),
    86.   .reseed( rst_once ),
    87.   .seed_val( DerivedClocks[31:0] ^ (DerivedClocks[31:0] << 2) ),
    88.   .out( RandomNumber1[31:16] )
    89. );
    91. logic start;
    92. initial begin
    93.   #0 start = 1'b0;
    94.   #100 start = 1'b1;
    95.   #20 start = 1'b0;
    96. end
    97.  
    98. // Modules under test ==========================================================
    99.  
    100. // simple static test
    101. /*pulse_gen #(
    102.   .CNTR_WIDTH( 8 )
    103. ) pg1 (
    104.   .clk( clk200 ),
    105.   .nrst( nrst_once ),
    107.   .start( start ),
    108.   .cntr_max( 15 ),
    109.   .cntr_low( 0 ),
    111.   .pulse_out(  ),
    112.   .busy(  )
    113. );
    114. */
    115.  
    116. logic [31:0] in_high_width = '0;
    117. logic out;
    118. logic out_rise;
    120. // random test
    121. pulse_gen #(
    122.   .CNTR_WIDTH( 8 )
    123. ) pg1 (
    124.   .clk( clk200 ),
    125.   .nrst( nrst_once ),
    127.   .start( start ),
    128.   .cntr_max( 16 ),
    129.   .cntr_low( {4'b0,RandomNumber1[3:0]} ),
    130.  
    131.   .pulse_out( out ),
    132.   .busy(  )
    133. );
    134.  
    135.  
    136.  
    137.  
    138. edge_detect out_ed (
    139.   .clk( clk200 ),
    140.   .anrst( nrst_once ),
    141.   .in( out ),
    142.   .rising( out_rise ),
    143.   .falling(  ),
    144.   .both(  )
    145. );
    146.  
    147. always_ff @(posedge clk200) begin
    148.   if( ~nrst_once ) begin
    149.      in_high_width[31:0] <= 1'b0;
    150.   end else begin
    151.     if( out_rise ) begin
    152.       in_high_width[31:0] <= in_high_width[31:0] + 1'b1;
    153.     end
    154.   end
    155. end
    156.  
    157. // PWM test
    158. /*pulse_gen #(
    159.   .CNTR_WIDTH( 8 )
    160. ) pg1 (
    161.   .clk( clk200 ),
    162.   .nrst( nrst_once ),
    164.   .start( 1'b1 ),
    165.   .cntr_max( 15 ),
    166.   .cntr_low( {4'b0,in_high_width[3:0]} ),
    168.   .pulse_out( out ),
    169.   .busy(  )
    170. );*/
    171.  
    172. endmodule

    下面开始学习一下TestBench的写法，其中我认为值得关注的地方有这几点：

    1.#号表示延迟

    此前我很少见到使用小数进行延迟的，看来在具有特殊频率要求的情况下，这也是必要的。

    2.复用之前的随机数模块

    同样对之前的随机数模块以及时钟分频电路进行了复用，从而提高测试的说服力。同时使用到了边沿检测器，用来对输出的脉冲进行上升沿检测。对随机数产色模块以及边沿检测不了解的，可以跳转：

    1. Verilog：【1】时钟分频电路（clk_divider.sv）
    2. Verilog：【2】伪随机数生成器（c_rand.v）
    3. Verilog：【3】边沿检测器（edge_detect.sv）

     同时注意到，为了生成32位的随机数，使用了两个16位随机数的生成器，将结果进行了拼接，应该是有降低资源使用量的考虑，毕竟过于高位的乘法器综合起来还是开销比较大的。

    最后可以注意到这一TestBench包含两个测试，测试1是单独一次脉冲的结果（即下图）；测试2是代码中最后被注释的部分，由于start恒为1，因此会持续不断产生受到随机数调制的PWM信号。

    ​

    下面来看一下测试1的仿真波形，可以看到cntr_max的值是16，cntr_low的值是13，当start信号来一个周期的高电平时，cntr_low将值存储到cntr_low_buff中。

    seq_cntr开始从16依次减小到0；busy这段时间为高电平，表示正在输出信号；seq_cntr变为16时，start_strobe出现一个高电平，表示开始输出的起点；pulse_out在计数值大于等于13时，为高电平，其余为低电平。seq_cntr_0与seq_cntr_0_d1对busy信号的产生就非常巧妙，我认为很有趣。

    最终证明，波形的展示与我们的分析是保持一致的~

    这就是本期的全部内容啦，如果你喜欢我的文章，不要忘了点赞+收藏+关注，分享给身边的朋友哇~

  • 相关阅读:
    转置卷积理论解释（输入输出大小分析）
    软件项目管理课后习题——第7章软件项目的质量管理与配置管理
    队列题目：设计循环双端队列
    UDS协议发展历史
    Postgres数据库使用any和all判断数组解决IN和NOT IN条件参数超限的问题
    golang 求立方根
    自动切换背景的登录页面
    JavaWeb 项目 --- 博客系统(前后分离)
    Java项目实战《苍穹外卖》 二、项目搭建
    030-从零搭建微服务-消息队列（二）
  • 原文地址：https://blog.csdn.net/Alex497259/article/details/126278221