Verilog分频器的设计

 大三都要结束了，才发现自己太多东西没深入学习。

 对于偶分频：（计数到分频数的一半就翻转）

注：

　　图中只用了一个计数器，当然也可以用多个；

　　图中只计数到需要分频的一半，当然也可计数到更多；

　　图中从第一个上升沿有效，当然也可延迟多个周期开始。

例如：

//任意偶分频设计
module frequency_divider_6 (clk, rst, data_out);
    input clk, rst;
    output data_out;
    reg [1:0] counter;
    reg data_out;
    parameter N = 6;  //改变N的值变成任意偶分频，同时counter的范围需要相应修改
    
    always @ (posedge clk or negedge rst)
        begin
            if (!rst)  //复位置零
                begin
                    counter <= 0;
                    data_out <= 0;
                end
            else    //分频
                begin
                    if (counter == N/2 - 1)  //偶分频数一半时反相
                        begin
                            data_out <= ~data_out;
                            counter <= 0;  //置0，从0计数
                        end
                    else
                        counter <= counter + 1;
                end
        end
endmodule

    从仿真波形看出复位后并没有立刻达到分频效果，复位结束后的2.5个周期无效，之后才达到分频效果。

    如果想从第一个上升沿就开始分频，那么就可以像我画的图中那样计数。如下所示：

/任意偶分频设计
module frequency_divider_6 (clk, rst, data_out);
    input clk, rst;
    output data_out;
    reg [1:0] counter;
    reg data_out;
    parameter N = 6;  //改变N的值变成任意偶分频，同时counter的范围需要相应修改
    
    always @ (posedge clk or negedge rst)
        begin
            if (!rst)  //复位置零
                begin
                    data_out <= 0;
                end
            else    //分频，也可用底下注释部分
                begin
                    if (counter == 0)  //偶分频数一半时反相
                        begin
                            data_out <= ~data_out;
                        end
                    else
                        data_out <= data_out;
                end
        end
    always @ (posedge clk or negedge rst)
        begin
            if (!rst)
                begin
                    counter <= 0;
                end
            else
                begin
                    if (counter == (N / 2 - 1))
                        begin
                            counter <= 0;
                        end
                    else
                        counter <= counter + 1;
                end
        end
endmodule

    注意到此代码和上一个同样是6分频的，此处把计数部分和分频部分分离开来，可读性强一些吧。此处只计数到 2 就把计数器清零，计数到 0 输出的分频信号就翻转。

 

    从仿真波形可看出从第一个上升沿就计数了。

计数到 N - 1 （注意计数器位宽）例如：

//任意偶分频设计
module frequency_divider_6 (clk, rst, data_out);
    input clk, rst;
    output data_out;
    reg [2:0] counter;
    reg data_out;
    parameter N = 6;  //改变N的值变成任意偶分频，同时counter的范围需要相应修改
            
    always @ (posedge clk or negedge rst)
        begin
            if (!rst)  //复位置零
                begin
                    data_out <= 0;//此处为1也可，看需求
                end
            else    //分频，也可用底下注释部分
                begin
                    if (counter < (N >> 1))  //偶分频数一半时反相
                        begin
                            data_out <= 1;
                        end
                    else
                        data_out <= 0;
                end
        end
    always @ (posedge clk or negedge rst)
        begin
            if (!rst)
                begin
                    counter <= 0;
                end
            else
                begin
                    if (counter == (N - 1))
                        begin
                            counter <= 0;
                        end
                    else
                        counter <= counter + 1;
                end
        end
endmodule

    

    写法多种多样，差别都不太大，不再一一举例，根据需求设计即可。

对于奇分频：（用两个计数器分别计到上升沿和下降沿达到分频数 (N - 1) / 2 和 (N + 1) / 2 时翻转）

注：

　　图中用了两个计数器，当然也可以用多个（两个就够了）；

　　图中只计数到需要分频数的(N - 1) / 2 和 (N + 1) / 2，时翻转，得到的波形需要相或；

　　图中从第一个上升沿有效，当然也可延迟多个周期开始。

例如：

//任意奇分频设计
module frequency_divider_5 (clk, rst, clk_p, clk_n, data_out);
    input clk, rst;
    output clk_p, clk_n, data_out;
    reg clk_p, clk_n;
    reg [2:0] counter_p, counter_n;
    parameter N = 5;  //改变N的值实现任意奇分频，注意counter_p和counter_n的范围
    //分频
    always @ (posedge clk or negedge rst) //上升沿计数与反相
        begin
            if (!rst) //复位置0，从0计数
                begin
                    counter_p <= 0;
                    clk_p <= 0;
                end
            else
                begin
                    if (counter_p == N - 1)
                        counter_p <= 0;
                    else
                         counter_p <= counter_p + 1;
                    if ((counter_p == (N - 1) / 2) || (counter_p == N - 1))
                        clk_p <= ~clk_p;
                end
        end
    always @ (negedge clk or negedge rst) //下降沿计数与反相
        begin
            if (!rst)
                begin
                    counter_n <= 0;
                    clk_n <= 0;
                end
            else 
            begin
                if (counter_n == N - 1)
                    counter_n <= 0;
                else
                     counter_n <= counter_n + 1;
                if ((counter_n == (N - 1) / 2) || (counter_n == N - 1))
                    clk_n <= ~clk_n;
            end
        end
    assign data_out = clk_p | clk_n;  //相或运算，得到50%占空比的分频输出信号
endmodule
    

    和偶分频同样的情况，复位后有多个无效周期。

    如果想从第一个上升沿就开始分频，那么就可以像我画的图中那样计数。如下所示：

 

     从仿真波形可看出从第一个上升沿就计数了。

    除此之外，还可以计数到这些就翻转：

　　1 和 （N - 1） / 2

　　（N - 1） / 2 和 N - 1

　　等等，根据需求即可

 比如：

//任意奇分频设计
module frequency_divider_5 (clk, rst, clk_p, clk_n, data_out);
    input clk, rst;
    output clk_p, clk_n, data_out;
    reg clk_p, clk_n;
    reg [2:0] counter_p, counter_n;
    parameter N = 5;  //改变N的值实现任意奇分频，注意counter_p和counter_n的范围
    
    always @ (posedge clk or negedge rst)  //上升沿计数器
        begin
            if (!rst) 
                counter_p <= 0;
            else 
                if (counter_p == N - 1)
                    counter_p <= 0;
                else
                     counter_p <= counter_p + 1;
        end
    always @ (posedge clk or negedge rst)  //上升沿反相
        begin
            if (!rst)
                clk_p <= 0;
            else 
                if (counter_p < (N >> 1))  //N整体向右移动一位，最高位补零，其实就是N/2，不过在计算奇数的时候有很明显的优越性
                    clk_p <= 1;
                else
                    clk_p <= 0;
        end

    always @ (negedge clk or negedge rst)  //下降沿计数器
        begin
            if (!rst) 
                counter_n <= 0;
            else 
                if (counter_n == N - 1)
                    counter_n <= 0;
                else
                     counter_n <= counter_n + 1;
        end
    always @ (negedge clk or negedge rst)  //下降沿反相
        begin
            if (!rst)
                clk_n <= 0;
            else 
                if ((counter_n < (N >> 1))
                    clk_n <= 1;
                else
                    clk_n <= 0;
        end
    assign data_out = clk_p | clk_n;  //相或运算，得到50%占空比的分频输出信号
endmodule

任意分频设计：

//下面是任意正整数的分频/ 此时举例是6倍频 /
module frequency_divider_all (clk, rst, data_out, clk_p, clk_n);

    input clk, rst;
    output data_out, clk_p, clk_n;

    parameter WIDTH = 3;  //计数器二进制位宽
    parameter N     = 6;  //分频数（任意正整数）

    reg [WIDTH-1:0] counter_p;// 上升沿计数单位
    reg [WIDTH-1:0] counter_n;// 下降沿计数单位
    reg             clk_p;// 上升沿时钟
    reg             clk_n;// 下降沿时钟

    assign data_out = (N == 1) ? clk : (N[0]) ? (clk_p | clk_n) : clk_p;//其中N==1是判断不分频，N[0]是判断是奇数还是偶数，若为1则是奇数分频，若是偶数则是偶数分频。
            
    always @ (posedge clk or negedge rst) 
        begin
            if (!rst)
                counter_p <= 0;
            else 
                if (counter_p == (N - 1))
                    counter_p <= 0;
                else
                    counter_p <= counter_p + 1;
        end

    always @ (posedge clk or negedge rst) 
        begin
            if (!rst) 
                clk_p <= 1;//此处设置为0也是可以的，这个没有硬性的要求，不管是取0还是取1结果都是正确的。
            else 
                if (counter_p < (N >> 1))//N整体向右移动一位，最高位补零，其实就是N/2，不过在计算奇数的时候有很明显的优越性
                    clk_p <= 1;
                else
                    clk_p <= 0;    
        end

    always @ (negedge clk or negedge rst) 
        begin
            if (!rst)
                counter_n <= 0;
            else 
                if (counter_n == (N - 1))
                    counter_n <= 0;
                else
                    counter_n <= counter_n + 1;
        end

    always @ (negedge clk or negedge rst) 
        begin
            if (!rst)
                clk_n <= 1;
            else 
                if (counter_n < (N >> 1))
                    clk_n <= 1;
                else
                    clk_n <= 0;
        end

endmodule

 

总结

     多思考总有新发现。

如有错误还请指出，如有侵权还请告知，如需转载请注明出处！                                              

本人博客：http://www.cnblogs.com/yllinux/