精华内容
下载资源
问答
  •  任意分频电路,相信很多人都听说过这个专业名词,好多视频上都说不建议使用计数器产生的分频时钟。其实在FPGA领域当中,由寄存器分频产生的时钟还有一个学名叫做,行波时钟。是由时序逻辑产生比如A寄存器的...

    一、行波时钟

      任意分频电路,相信很多人都听说过这个专业名词,好多视频上都说不建议使用计数器产生的分频时钟。其实在FPGA领域当中,由寄存器分频产生的时钟还有一个学名叫做,行波时钟。是由时序逻辑产生比如A寄存器的输出作为B寄存的时钟输入(一般不建议使用),如下图所示;驱动右边那个触发器的时钟即为行波时钟。之所以不建议使用在FPGA中使用行波时钟,因为这样会在FPGA设计中引入新的时钟域,,增加时序分析的难度,并且由于行波时钟的相位通常会滞后于原始时钟,会导致后续触发器的保持时间不一定能满足。

     

     

      事实上,采用行波时钟的目的无非是为后续时序电路的处理速度进行降频,而要实现降频的功能,除了通过降低时钟信号的频率外,仍然可以通过控制后续时序电路存储单元的使能端来实现,因此,上例中的电路完全可以修改如下:这样一来,整个时序逻辑将只被一个时钟信号所驱动。

     

     

     

    二、任意分频电路

     

      虽然说比建议使用分屏电路。但是在一些对时序要求不高的情况下是完全可以用的。而且还可以节省PLL和DCM等资源。那么设计一个任意分频的电路。这里的关键是偶数分频和奇数分频两大块。占空比一般都是50%。分频电路的整体架构如下:

     

     

     

       1、偶数分频:可以不用介绍,计数到N/2翻转就可以。

     

       2、奇数分频    第一步:上升沿触发进行模N计数,从0开始计数,计数到0+(n-1)/2,进行翻转,即为clk_odd= ~clk_odd

                第二步:还是在上升沿的条件下,从接着第一步计数,在其基础上再计数(n-1)/2,再次翻转;clk_odd= ~clk_odd

     

     

                                    第三步:在下降沿的条件下,采集clk_odd,即:clk_odd_r = clk_odd

             第四步;输出clk_odd_out = clk_odd_r |clk_odd;即为所求‘。

     

    三、实现  

     1 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      2 // Project Name : 
      3 // Website      : https://home.cnblogs.com/lgy-gdeu/
      4 // Author         : LGY GUET Uiversity
      5 // Weixin         : li15226499835
      6 // Email          : 15277385992@163.com
      7 // File           : 
      8 // Create         : 2020-07-01
      9 // Revise         : 
     10 // Editor         : sublime text{SUBLIME_VERSION}, tab size ({TABS})
     11 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     12 // Modification History:
     13 // Date             By              Version                 Change Description
     14 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     15 // {DATE} {TIME}    LGY           1.0                        ++++++++++++++++ 
     16 // *********************************************************************************
     17 `timescale      1ns/1ns
     18 module mux_cnt(
     19 input            wire                     sclk     ,
     20 input            wire                    s_rst_n  ,
     21 input             wire[3:0]               div      ,
     22 output          wire                    clk_out 
     23     );
     24 
     25 //========================================================================\
     26 // ################ Define Parameter and Internal signals ################ 
     27 //========================================================================/
     28 localparam             DIV1 = 1                ;
     29 localparam            DIV2 = 2                ;
     30 localparam          DIV3 = 3                ;
     31 localparam          DIV4 = 4                ;
     32 localparam          DIV5 = 5                ;
     33 localparam          DIV6 = 6                ;
     34 localparam            DIV7 = 7                ;
     35 localparam          DIV8 = 8                ;
     36 reg        [7:0]            fre_en          ;
     37 //=============================================================================
     38 //+++++++++++++++++++++++++     Main Code    +++++++++++++++++++++++++++++++
     39 //=============================================================================
     40 //分频模式的使能,一共是8种模式
     41 always @(posedge sclk or negedge s_rst_n)begin
     42         if(!s_rst_n)begin
     43             fre_en    <=   0;
     44         end    
     45         else begin
     46             case(div )
     47                 DIV1 :   fre_en   <=  8'b0000_0001 ;
     48                 DIV2 :   fre_en   <=  8'b0000_0010 ;
     49                 DIV3 :   fre_en   <=  8'b0000_0100 ;
     50                 DIV4 :   fre_en   <=  8'b0000_1000 ;
     51                 DIV5 :   fre_en   <=  8'b0001_0000 ;
     52                 DIV6 :   fre_en   <=  8'b0010_0000 ;
     53                 DIV7 :   fre_en   <=  8'b0100_0000 ;
     54                 DIV8 :   fre_en   <=  8'b1000_0000 ;                
     55             endcase
     56         end
     57 end
     58 
     59 //计数模块
     60 reg                [3:0]            fre_cnt       ;
     61 always @(posedge sclk or negedge s_rst_n)begin
     62     if(!s_rst_n)begin
     63         fre_cnt   <=    0 ;
     64     end
     65     else begin
     66         case (1'b1)
     67             fre_en[0]  :  begin
     68                 ;
     69             end
     70             fre_en[1]  :  begin
     71                 ;
     72             end
     73             fre_en[2]  : begin
     74                 if(fre_cnt < 2)
     75                     fre_cnt  <= fre_cnt + 1'b1 ;
     76                 else 
     77                     fre_cnt  <= 0 ;    
     78             end
     79             fre_en[3]  : begin
     80                 if(fre_cnt<3)
     81                     fre_cnt   <= fre_cnt + 1'b1 ;
     82                 else 
     83                     fre_cnt   <= 0;    
     84             end
     85             fre_en[4]  : begin
     86                 if(fre_cnt<4)
     87                     fre_cnt   <= fre_cnt +  1'b1 ;
     88                 else 
     89                     fre_cnt   <= 0;
     90             end
     91             fre_en[5]  : begin
     92                 if(fre_cnt<5)
     93                     fre_cnt   <= fre_cnt +  1'b1 ;
     94                 else 
     95                     fre_cnt   <= 0;    
     96             end
     97             fre_en[6]  : begin
     98                 if(fre_cnt<6)
     99                     fre_cnt   <= fre_cnt + 1'b1 ;
    100                 else 
    101                     fre_cnt   <= 0;    
    102             end
    103             fre_en[7]  : begin
    104                 if(fre_cnt<7)
    105                     fre_cnt   <= fre_cnt + 1'b1  ;
    106                 else 
    107                     fre_cnt   <= 0;    
    108             end
    109 
    110         endcase
    111     end
    112 end
    113 //分频模块
    114 reg          clk_out_odd_r    ;   //奇数分频,中间变量
    115 reg          clk_out_even     ;   //偶数分频,直接输出 
    116 always @ (posedge sclk or negedge s_rst_n) begin
    117     if(s_rst_n == 1'b0)begin
    118         clk_out_even  <= 0;
    119         clk_out_odd_r <= 0; 
    120     end    
    121     else begin
    122         case  (1'b1)
    123             fre_en[0] :  begin
    124                 ;
    125             end
    126             fre_en[1] :  begin
    127                 clk_out_even <= ~clk_out_even ;
    128             end
    129             fre_en[2] :  begin// 3 div
    130                 if (fre_cnt==1)
    131                     clk_out_odd_r   <=  ~clk_out_odd_r;
    132                 else if(fre_cnt==2)
    133                     clk_out_odd_r   <=  ~clk_out_odd_r;    
    134                 else
    135                     clk_out_odd_r   <= clk_out_odd_r;    
    136             end
    137             fre_en[3] :  begin//4 div
    138                 if(fre_cnt == 1)
    139                     clk_out_even    <= ~clk_out_even  ;
    140                 else if(fre_cnt ==3)
    141                     clk_out_even    <= ~clk_out_even   ;
    142                 else
    143                     clk_out_even    <=  clk_out_even   ;                  
    144             end
    145             fre_en[4] :  begin//5 div
    146                 if(fre_cnt == 2)
    147                     clk_out_odd_r   <=  ~clk_out_odd_r;
    148                 else if(fre_cnt == 4)
    149                     clk_out_odd_r   <=  ~clk_out_odd_r;
    150                 else 
    151                     clk_out_odd_r   <=  clk_out_odd_r ;    
    152                             
    153             end
    154             fre_en[5] : begin// 6 div
    155                 if (fre_cnt == 2)
    156                     clk_out_even    <=  ~clk_out_even  ;
    157                 else if(fre_cnt == 5)
    158                     clk_out_even    <=  ~clk_out_even  ;
    159                 else
    160                     clk_out_even    <=  clk_out_even;                
    161             end
    162             fre_en[6] :  begin //7div
    163                 if(fre_cnt == 3)
    164                     clk_out_odd_r    <=  ~clk_out_odd_r ;
    165                 else if(fre_cnt ==6)
    166                     clk_out_odd_r    <=  ~clk_out_odd_r ;
    167                 else
    168                     clk_out_odd_r    <=  clk_out_odd_r ;        
    169             end 
    170             fre_en[7] : begin // 8 div
    171                 if(fre_cnt == 3)
    172                     clk_out_even     <=  ~clk_out_even  ;
    173                 else if(fre_cnt ==7)
    174                     clk_out_even     <=  ~clk_out_even  ;
    175                 else 
    176                     clk_out_even     <=  clk_out_even ;            
    177             end
    178 
    179         endcase
    180     end    
    181         
    182 end
    183 
    184 //中间输出模块
    185 reg             clk_out_odd_r1 ;//用来存放下降沿采集的数据
    186 always @(negedge  sclk or negedge s_rst_n)begin
    187     if(!s_rst_n)
    188         clk_out_odd_r1   <=   0;
    189     else begin
    190         case (1'b1 )
    191             fre_en[0] : begin
    192                 ;
    193             end
    194             fre_en[1] : begin
    195                 ;
    196             end
    197             fre_en[2] : begin
    198                 clk_out_odd_r1   <=  clk_out_odd_r ;
    199             end
    200             fre_en[3] : begin
    201                 ;
    202             end
    203             fre_en[4] : begin
    204                 clk_out_odd_r1   <=  clk_out_odd_r ;
    205             end
    206             fre_en[5] : begin
    207                 ;
    208             end
    209             fre_en[6] : begin
    210                 clk_out_odd_r1   <=  clk_out_odd_r ;
    211             end
    212             fre_en[7] : begin
    213                 ;
    214             end
    215         endcase 
    216     end    
    217 end
    218 
    219 //最后的输出
    220 //assign     clk_out   =  ( fre_en[0] | fre_en[1] | fre_en[3] | fre_en[5] | fre_en[7] )?clk_out_even:clk_out_odd_r|clk_out_odd_r1;
    221 assign    clk_out   =  fre_en[0]? sclk :(( fre_en[1] | fre_en[3] | fre_en[5] | fre_en[7])?clk_out_even:clk_out_odd_r|clk_out_odd_r1);
    222 
    223 endmodule
    

    激励文件

     1 `timescale 1ns / 1ps
     2 //
     3 // Company: 
     4 // Engineer: 
     5 // 
     6 // Create Date: 2020/07/01 14:59:38
     7 // Design Name: 
     8 // Module Name: mux_cnt_tb
     9 // Project Name: 
    10 // Target Devices: 
    11 // Tool Versions: 
    12 // Description: 
    13 // 
    14 // Dependencies: 
    15 // 
    16 // Revision:
    17 // Revision 0.01 - File Created
    18 // Additional Comments:
    19 // 
    20 //
    21 
    22 
    23 module mux_cnt_tb();
    24 reg            sclk     ;
    25 reg            s_rst_n  ;
    26 reg  [3:0]     div      ;
    27 wire           clk_out  ;
    28 
    29 //=============================================================================
    30 //+++++++++++++++++++++++++     Main Code    +++++++++++++++++++++++++++++++里
    31 //=============================================================================
    32 
    33 //initial begin
    34 //    sclk   =  0 ;
    35 //    forever  begin
    36 //        #2  sclk = ~sclk ;
    37 //    end
    38 //end
    39 
    40 
    41 
    42 
    43 initial begin
    44     sclk  = 0;
    45     s_rst_n = 0;
    46     div = 3 ;
    47     #20
    48     s_rst_n = 1;
    49     #400
    50     div = 1; 
    51     #600
    52     s_rst_n = 1;
    53     div = 5;
    54     #1200
    55     div = 2;
    56     #600
    57 
    58     $finish;
    59     
    60 end
    61 always #10 sclk = ~sclk ;
    62 
    63 
    64 mux_cnt inst_mux_cnt (.sclk(sclk), .s_rst_n(s_rst_n), .div(div), .clk_out(clk_out));
    65 
    66 
    67 endmodule

     

    展开全文
  • //偶数分频,直接输出 116 always @ (posedge sclk or negedge s_rst_n) begin 117 if(s_rst_n == 1'b0)begin 118 clk_out_even ;119 clk_out_odd_r ;120 end 121 else begin 122 case (1'b1) 123 fre_en[0] : ...

    1 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~2 //Project Name :3 //Website :https://home.cnblogs.com/lgy-gdeu/

    4 //Author : LGY GUET Uiversity5 //Weixin : li152264998356 //Email : 15277385992@163.com7 //File :8 //Create : 2020-07-019 //Revise :10 //Editor : sublime text{SUBLIME_VERSION}, tab size ({TABS})11 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++12 //Modification History:13 //Date By Version Change Description14 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~15 //{DATE} {TIME} LGY 1.0 ++++++++++++++++16 //*********************************************************************************

    17 `timescale 1ns/1ns18 modulemux_cnt(19 input wiresclk ,20 input wires_rst_n ,21 input wire[3:0] div ,22 output wireclk_out23 );24

    25 //========================================================================\26 //################ Define Parameter and Internal signals ################27 //========================================================================/

    28 localparam DIV1 = 1;29 localparam DIV2 = 2;30 localparam DIV3 = 3;31 localparam DIV4 = 4;32 localparam DIV5 = 5;33 localparam DIV6 = 6;34 localparam DIV7 = 7;35 localparam DIV8 = 8;36 reg [7:0] fre_en ;37 //=============================================================================38 //+++++++++++++++++++++++++ Main Code +++++++++++++++++++++++++++++++39 //=============================================================================40 //分频模式的使能,一共是8种模式

    41 always @(posedge sclk or negedge s_rst_n)begin

    42 if(!s_rst_n)begin

    43 fre_en <= 0;44 end

    45 else begin

    46 case(div )47 DIV1 : fre_en <= 8'b0000_0001 ;

    48 DIV2 : fre_en <= 8'b0000_0010 ;

    49 DIV3 : fre_en <= 8'b0000_0100 ;

    50 DIV4 : fre_en <= 8'b0000_1000 ;

    51 DIV5 : fre_en <= 8'b0001_0000 ;

    52 DIV6 : fre_en <= 8'b0010_0000 ;

    53 DIV7 : fre_en <= 8'b0100_0000 ;

    54 DIV8 : fre_en <= 8'b1000_0000 ;

    55 endcase

    56 end

    57 end

    58

    59 //计数模块

    60 reg [3:0] fre_cnt ;61 always @(posedge sclk or negedge s_rst_n)begin

    62 if(!s_rst_n)begin

    63 fre_cnt <= 0;64 end

    65 else begin

    66 case (1'b1)

    67 fre_en[0] : begin

    68 ;69 end

    70 fre_en[1] : begin

    71 ;72 end

    73 fre_en[2] : begin

    74 if(fre_cnt < 2)75 fre_cnt <= fre_cnt + 1'b1 ;

    76 else

    77 fre_cnt <= 0;78 end

    79 fre_en[3] : begin

    80 if(fre_cnt<3)81 fre_cnt <= fre_cnt + 1'b1 ;

    82 else

    83 fre_cnt <= 0;84 end

    85 fre_en[4] : begin

    86 if(fre_cnt<4)87 fre_cnt <= fre_cnt + 1'b1 ;

    88 else

    89 fre_cnt <= 0;90 end

    91 fre_en[5] : begin

    92 if(fre_cnt<5)93 fre_cnt <= fre_cnt + 1'b1 ;

    94 else

    95 fre_cnt <= 0;96 end

    97 fre_en[6] : begin

    98 if(fre_cnt<6)99 fre_cnt <= fre_cnt + 1'b1 ;

    100 else

    101 fre_cnt <= 0;102 end

    103 fre_en[7] : begin

    104 if(fre_cnt<7)105 fre_cnt <= fre_cnt + 1'b1 ;

    106 else

    107 fre_cnt <= 0;108 end

    109

    110 endcase

    111 end

    112 end

    113 //分频模块

    114 reg clk_out_odd_r ; //奇数分频,中间变量

    115 reg clk_out_even ; //偶数分频,直接输出

    116 always @ (posedge sclk or negedge s_rst_n) begin

    117 if(s_rst_n == 1'b0)begin

    118 clk_out_even <= 0;119 clk_out_odd_r <= 0;120 end

    121 else begin

    122 case (1'b1)

    123 fre_en[0] : begin

    124 ;125 end

    126 fre_en[1] : begin

    127 clk_out_even <= ~clk_out_even ;128 end

    129 fre_en[2] : begin//3 div

    130 if (fre_cnt==1)131 clk_out_odd_r <= ~clk_out_odd_r;132 else if(fre_cnt==2)133 clk_out_odd_r <= ~clk_out_odd_r;134 else

    135 clk_out_odd_r <=clk_out_odd_r;136 end

    137 fre_en[3] : begin//4 div

    138 if(fre_cnt == 1)139 clk_out_even <= ~clk_out_even ;140 else if(fre_cnt ==3)141 clk_out_even <= ~clk_out_even ;142 else

    143 clk_out_even <=clk_out_even ;144 end

    145 fre_en[4] : begin//5 div

    146 if(fre_cnt == 2)147 clk_out_odd_r <= ~clk_out_odd_r;148 else if(fre_cnt == 4)149 clk_out_odd_r <= ~clk_out_odd_r;150 else

    151 clk_out_odd_r <=clk_out_odd_r ;152

    153 end

    154 fre_en[5] : begin//6 div

    155 if (fre_cnt == 2)156 clk_out_even <= ~clk_out_even ;157 else if(fre_cnt == 5)158 clk_out_even <= ~clk_out_even ;159 else

    160 clk_out_even <=clk_out_even;161 end

    162 fre_en[6] : begin //7div

    163 if(fre_cnt == 3)164 clk_out_odd_r <= ~clk_out_odd_r ;165 else if(fre_cnt ==6)166 clk_out_odd_r <= ~clk_out_odd_r ;167 else

    168 clk_out_odd_r <=clk_out_odd_r ;169 end

    170 fre_en[7] : begin //8 div

    171 if(fre_cnt == 3)172 clk_out_even <= ~clk_out_even ;173 else if(fre_cnt ==7)174 clk_out_even <= ~clk_out_even ;175 else

    176 clk_out_even <=clk_out_even ;177 end

    178

    179 endcase

    180 end

    181

    182 end

    183

    184 //中间输出模块

    185 reg clk_out_odd_r1 ;//用来存放下降沿采集的数据

    186 always @(negedge sclk or negedge s_rst_n)begin

    187 if(!s_rst_n)188 clk_out_odd_r1 <= 0;189 else begin

    190 case (1'b1 )

    191 fre_en[0] : begin

    192 ;193 end

    194 fre_en[1] : begin

    195 ;196 end

    197 fre_en[2] : begin

    198 clk_out_odd_r1 <=clk_out_odd_r ;199 end

    200 fre_en[3] : begin

    201 ;202 end

    203 fre_en[4] : begin

    204 clk_out_odd_r1 <=clk_out_odd_r ;205 end

    206 fre_en[5] : begin

    207 ;208 end

    209 fre_en[6] : begin

    210 clk_out_odd_r1 <=clk_out_odd_r ;211 end

    212 fre_en[7] : begin

    213 ;214 end

    215 endcase

    216 end

    217 end

    218

    219 //最后的输出220 //assign clk_out = ( fre_en[0] | fre_en[1] | fre_en[3] | fre_en[5] | fre_en[7] )?clk_out_even:clk_out_odd_r|clk_out_odd_r1;

    221 assign clk_out = fre_en[0]? sclk :(( fre_en[1] | fre_en[3] | fre_en[5] | fre_en[7])?clk_out_even:clk_out_odd_r|clk_out_odd_r1);222

    223 endmodule

    展开全文
  • verilog实现任意时钟的分频,根据输入的信号判断需要的时钟分频数,然后输出需要的分频时钟
  • 本资源详细描述了任意分频电路的实现电路,非常经典
  • 学习之前,先理解一下什么叫占空比? 占空比:对于一串理想的脉冲序列中(如方波),正脉冲的持续时间...以此循环,即可实现任意偶数倍分频 奇数倍分频 奇数倍分频常常在论坛上有人问起,实际上,奇数倍分频有两种实现方

    学习之前,先理解一下什么叫占空比?
    占空比:对于一串理想的脉冲序列中(如方波),正脉冲的持续时间与脉冲中周期的比值,叫做这个方波的占空比。

    偶数倍分频

    偶数倍分频应该是大家比较熟悉的分频,也是最简单的分频计数器,完全可以通过计数器直接实现的。例如进行N倍数偶数分频,那么可以通过待分频的时钟触发计数器计数,当计数器从0计数到N/2-1时,输出的时钟进行翻转,并且将计数器复位,是的下一个时钟从零开始计数。以此循环,即可实现任意偶数倍分频

    奇数倍分频

    奇数倍分频常常在论坛上有人问起,实际上,奇数倍分频有两种实现方法:
    首先,完全可以通过计数器来实现,如进行三分频,通过待分频时钟 上升沿触发计数器进行模三计数,当计数器计数到邻近值进行两次翻转,比如可以在计数器计数到1时,输出时钟进行翻转,计数到2时再次进行翻转。即是在计数 值在邻近的1和2进行了两次翻转。这样实现的三分频占空比为1/3或者2/3。如果要实现占空比为50%的三分频时钟,可以通过待分频时钟下降沿触发计 数,和上升沿同样的方法计数进行三分频,然后下降沿产生的三分频时钟和上升沿产生的时钟进行相或运算,即可得到占空比为50%的三分频时钟。这种方法可以 实现任意的奇数分频。
    归类为一般的方法为:对于实现占空比为50%的N倍奇数分频,首先进行上升沿触发进行模N计数,计数选定到某一个值进行输出时钟翻 转,然后经过(N-1)/2再次进行翻转得到一个占空比非50%奇数n分频时钟。再者同时进行下降沿触发的模N计数,到和上升沿触发输出时钟翻转选定值相 同值时,进行输出时钟时钟翻转,同样经过(N-1)/2时,输出时钟再次翻转生成占空比非50%的奇数n分频时钟。两个占空比非50%的n分频时钟相或运 算,得到占空比为50%的奇数n分频时钟。
    另外一种方法:对进行奇数倍n分频时钟,首先进行n/2分频(带小数,即等于(n-1)/2+0.5),然后再 进行二分频得到。得到占空比为50%的奇数倍分频。

    小数分频

    首先讲讲如何进行n+0.5分频,这种分频需要对输入时钟进行操作。基本的设计思想:对于进行n+0.5分频,首先进行模n的计数,在计数到 n-1时,输出时钟赋为‘1’,回到计数0时,又赋为0,因此,可以知道,当计数值为n-1时,输出时钟才为1,因此,只要保持计数值n-1为半个输入时 钟周期,即实现了n+0.5分频时钟,因此保持n-1为半个时钟周期即是一个难点。从中可以发现,因为计数器是通过时钟上升沿计数,因此可以在计数为n- 1时对计数触发时钟进行翻转,那么时钟的下降沿变成了上升沿。即在计数值为n-1期间的时钟下降沿变成了上升沿,则计数值n-1只保持了半个时钟周期,由 于时钟翻转下降沿变成上升沿,因此计数值变为0。因此,每产生一个n+0.5分频时钟的周期,触发时钟都是要翻转一次。设计思路如下:
    在这里插入图片描述
    下面为任意正整数分频代码:

    module div_clk(
    	input	clk,
    	input	rst_n,
    	output	o_clk
    );
    
    	parameter	WIDTH = 3;
    	parameter	N	  = 6;
    	
    	reg [WIDTH-1:0]	cnt_p;
    	reg				clk_p;
    	reg				clk_n;
    	
    	assign	o_clk = (N==1)?clk : (N[0])?(clk_p | clk_n) : clk_p;//其中N==1是判断不分频,N[0]是判断是奇数还是偶数,若为1则是奇数分频,若是偶数则是偶数分频。
    	
    	always @(posedge clk or negedge rst_n) begin
    		if(!rst_n)
    			cnt_p <= {WIDTH{1'b0}};
    		else if(cnt_p == (N-1))
    			cnt_p <= {WIDTH{1'b0}};
    		else
    			cnt_p <= cnt_p + 1'b1;
    	end
    	
    	always @(posedge clk or negedge rst_n) begin
    		if(rst_n == 1'b0)
    			clk_p <= 1;//此处设置为0也是可以的,这个没有硬性的要求,不管是取0还是取1结果都是正确的。
    		else if(cnt_p < (N>>1))/*N整体向右移动一位,最高位补零,其实就是N/2,不过在计算奇数的时候有很明显的优越性*/
    			clk_p <= 1;
    		else
    			clk_p <= 0;
    	end
    	
    	always @(negedge clk or negedge rst_n) begin
    		if(rst_n == 1'b0)
    			clk_n <= 1;
    		else 
    			clk_n <= clk_n;
    	end
    
    endmodule
    

    下面为一段代码实现的奇数、偶数、小数分频

    module divf #
    (    parameter Div_num = 12 ,    // 分频数
         parameter state=0        //半分频为0,奇数分频为1,偶数分频为2
    )
    (
    input                 clr,
    input                 clk,
    output                Div_clk
    );
    reg [24:0]  count;
    
    case(state)
    1:   begin  //ji_shu
              reg         pos_clk;
              reg         neg_clk;
    
              always@(posedge clk or negedge clr)
              if(!clr)                     count<=0;
              else if(count==0 & pos_clk)  count<=Div_num/2-1;
              else if(count==0)            count<=Div_num/2;
              else                         count<=count-1;
    
              always@(posedge clk or negedge clr)
              if(!clr)                     pos_clk<=0;
              else if(count==0)            pos_clk<=~pos_clk;
              else                         pos_clk<=pos_clk;
    
              always@(negedge clk or negedge clr)
              if(!clr)                     neg_clk<=0;
              else                         neg_clk<=pos_clk;
    
              assign Div_clk = pos_clk & neg_clk;
         end
    
    2:   begin  //ou_shu
              reg          Div_clk1;
    
              always@(posedge clk or negedge clr)
              if(!clr)                     count<=0;
              else if(count==0)            count<=Div_num/2-1;
              else                         count<=count-1;
    
              always@(posedge clk or negedge clr)
              if(!clr)                     Div_clk1<=0;
              else if(count==0)            Div_clk1<=~Div_clk1;
    
              assign Div_clk = Div_clk1;
         end
    
    
    0:   begin   //ban_fen_pin
              reg         count_div;
              reg         count_div2;
              wire        clk_half;
    
              assign  clk_half = clk^count_div2;
              always@(posedge clk_half or negedge clr)   //模Div_num 计数
              if(!clr)                       count<=0;
              else if(count== Div_num-1)      count<=0;
              else                         count<=count+1;
    
              always@(posedge clk_half or negedge clr)   //模Div_num 计数
              if(!clr)                       count_div<=0;
              else if(count== Div_num-1)      count_div<=1;
              else                         count_div<=0;
    
              always@(posedge count_div or negedge clr)   //对count_div二分频
              if(!clr)                       count_div2<=0;
              else                         count_div2<=~count_div2;
    
              assign Div_clk = count_div;
         end
    endcase
    
    endmodule
    
    展开全文
  • verilog实现任意占空比、任意分频的方法在verilog程序设计中,我们往往要对一个频率进行任意分频,而且占空比也有一定的要求这样的话,对于程序有一定的要求,现在我在前人经验的基础上做一个简单的总结,实现对一个...

    verilog

    实现任意占空比、任意分频的方法

    verilog

    程序设计中,我们往往要对一个频率进行任意分频,而且占空比也有一定的

    要求这样的话,

    对于程序有一定的要求,

    现在我在前人经验的基础上做一个简单的总结,

    现对一个频率的任意占空比的任意分频。

    比如:我们

    FPGA

    系统时钟是

    50M Hz

    ,而我们要产生的频率是

    880Hz

    ,那么,我们需要对系

    统时钟进行分频。我们很容易想到用计数的方式来分频:

    50000000/880 = 56818

    这个数字不是

    2

    的整幂次方,

    那么怎么办呢?我们可以设定一个参数,

    让它到

    56818

    的时候

    重新计数不就完了吗?呵呵,程序如下:

    module div(clk, clk_div);

    input clk;

    output clk_div;

    reg [15:0] counter;

    always @(posedge clk) if(counter==56817) counter <= 0; else counter <= counter+1;

    assign clk_div = counter[15];

    endmodule

    下面我们来算一下它的占空比:我们清楚地知道,这个输出波形在

    counter

    0

    32767

    时候为低,在

    32767

    56817

    的时候为高,占空比为

    40%

    多一些,如果我们需要占空比为

    50%

    ,那么怎么办呢?不用急,慢慢来。

    我们再设定一个参数,

    使它为

    56817

    的一半,

    使达到它的时候波形翻转,

    那不就完了吗?呵

    呵,再看看:

    module div(clk, clk_div);

    input clk;

    output clk_div;

    reg [14:0] counter;

    展开全文
  • EDA365欢迎您登录!... |( n9 Z4 {一、为啥要说任意分频也许FPGA中的第一个实验应该是分频实验,而不是流水灯,或者LCD1602的"Hello World"显示,因为分频的思想在FPGA中极为重要。当初安排流水...
  • 1.偶数倍(2N)分频使用一模N计数器模块即可实现,即每当模N计数器上升沿从0开始计数至N-1时,输出时钟进行翻转,同时给计数器一复位信号使之从0开始重新计数,以此循环即可。偶数倍分频原理示意图见图1。2.奇数倍(2N+...
  • 任意奇数分频电路

    2013-05-31 12:06:04
    vhdl语言实现任意奇数分频电路,可在ise里直接运行
  • 任意偶数分频电路

    2013-05-31 12:00:42
    VHDL实现任意偶数分频电路,直接在Ise里运行就行
  • 老李这次又要来分析常考的面试题了,这次咱们聊聊时钟分频电路。这一类面试题很常见,难度其实不大,看了这一篇,老李保证你能够在面试中自如应付。先说什么是时钟分频(clock divide),我们都知道现在的数字电路都是...
  • 分频分频 占空比为50%的奇分频 占空比不限定的奇数分频器 ...
  • 使用verilog描述的任意分频电路且占空比为50%,附加测试电路
  • 给出了一种奇数分频电路设计方法,采用verilog HDL描述。修改代码中参数可以进行任意奇数分频,包含了设计文档和源代码。
  • Verilog任意整数分频电路

    千次阅读 2016-08-31 21:39:20
    任意整数分频Verilog代码
  • IC/FPGA面试之任意时钟分频电路的产生 #题目分析 第一步:确定输入输出,输入时钟,复位信号,分频选择信号,输出分频信号。 第二步:偶数分频实现通过计数即可。奇数分频,首先产生分频电路,其次使用始终下降沿...
  • 数字电路中的分频器主要是分为两种:整数分频和小数分频。其中整数分频又分为偶分频和奇分频,首先从偶分频开始吧,入门先从简单的开始!一、2^n的偶分频器设计先来看最简单的最常见的一个例子——2分频。假设输入...
  • 1、前言数字钟是一种用数字电路技术实现时、分、秒计时的装置,与机械式时钟相比具有更高的准确性和直观性,且无机械装置,具有更长的使用寿命,因此得到了广泛的应用。2.设计任务和要求用中小规模集成电路设计一台...
  • 出坑Verilog遥想当年本科之时画过电路PCB、玩儿过单片机、PLC,亦学过C#(给我那数块板子的毕设做个上位机),Python。直到研究生之时方才选择FPGA这条道路,除了对数字电路本身的兴趣之外(对于做软件感觉一直找不到...
  • 频率转换是超外差通信和雷达电路以及很多其他有用射频/微波器件的最主要功能。对于这些非线性器件,尤其在混频器、倍频器和分频器的作用以及如何为某项应用选购最佳器件方面,经常存在这一些令人困惑之处。本文旨在...
  • 来自微信公众号:数字芯片设计三、分频电路(1)简单的计数器 计数器实质是对输入的驱动时钟进行计数,所以计数器在某种意义上讲,等同于对时钟进行分频。例如一个最大计数长度为N=2^n(从0计数到N-1)的计数器,也...
  • iii)、“电路描述”:使用电路描述为“组合逻辑电路”; 1、“与门” 首先,对“与门”代码而言,功能为:检测“a/b按键”的“与逻辑”,控制“4个LED的亮灭状态”; 具体代码如: module my_and(a,b,out_all); ...
  • 频率转换是超外差通信和雷达电路以及很多其他有用射频/微波器件的最主要功能。对于这些非线性器件,尤其在混频器、倍频器和分频器的作用以及如何为某项应用选购最佳器件方面,经常存在这一些令人困惑之处。本文旨在...
  • 任意切换1-8分频,且无论奇分频还是偶分频,占空比均为50%,我至今仍然认为,在那种紧张且时间有限的情况下(本科大约预留15分钟),真的能设计出这种可任意切换的分频电路(之前有所准备的话可以),反正我是没写...
  • 数字芯片实验室○Low Power低功耗是当今...在芯片逻辑转换期间,CMOS电路中的任何开关活动都会产生瞬时电流,因此增加了功耗。设计中最常见的存储元件是同步触发器,它的输出会在输入数据和时钟改变时改变。 因此,...
  • 分频器是指使输出信号频率为输入信号频率整数分之一的电子电路。在许多电子设备中如电子钟、频率...偶分频电路指的是分频系数为 2、4、6、8 … 等偶数整数的分频电路,我们可以直接进行分频。例如下面 divider.v 中,

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 132
精华内容 52
关键字:

任意分频电路