Verilog实现常见电路（三）

最新推荐文章于 2024-05-01 13:38:25 发布
最新推荐文章于 2024-05-01 13:38:25 发布
阅读量601 收藏 3
点赞数 1
分类专栏： 数字IC知识 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40634481/article/details/123202701
版权

目录：

一、边沿检测

二、串并转换

三、分频器

四、异步复位同步释放

五、序列信号产生器

六、序列检测器

七、双端口RAM

八、同步FIFO

九、异步FIFO

常见电路系列连接:

CSDNicon-default.png?t=M1L8https://mp.csdn.net/mp_blog/creation/editor/122940873CSDNicon-default.png?t=M1L8https://mp.csdn.net/mp_blog/creation/editor/122991113七、双端口RAM

module dualram#(
    parameter ADDR_WIDTH = 4,
              DATA_WIDTH = 8,
              DATA_DEPTH = 8
)(
    input rd_clk,
    input wr_clk,
    input rst_n,
//port a
    input wr_en,
    input [3:0] wr_addr,
    input [7:0] wr_data,
//port b
    input rd_en,
    input [3:0] rd_addr,
    output reg [7:0] rd_data

);
reg [DATA_WIDTH-1:0] register [DATA_DEPTH-1:0];
integer i;

always@(posedge wr_clk or negedge rst_n)
    if(~rst_n)begin
        for(i=0;i<DATA_DEPTH;i=i+1)begin
            register[i]<='h0;
        end
    end
    else if(wr_en)
        register[wr_addr]<=wr_data;

always@(posedge rd_clk or negedge rst_n)
    if(~rst_n)
        rd_data<='h0;
    else if(rd_en)
        rd_data<=register[rd_addr];
endmodule

仿真代码

`timescale  1ns / 1ps
module tb_dualram;   
// dualram Parameters
parameter PERIOD_WR      = 10;
parameter PERIOD_RD      = 20;
parameter ADDR_WIDTH  = 4;
// dualram Inputs
bit   rd_clk        ;
bit   wr_clk        ;
reg   rst_n         ;
reg   wr_en         ;
reg   [3:0]  wr_addr;
reg   [7:0]  wr_data;
reg   rd_en         ;
reg   [3:0]  rd_addr;
// dualram Outputs
wire  [7:0]  rd_data                       ;
reg [7:0] data;

initial
begin
    forever #(PERIOD_WR/2)  wr_clk=~wr_clk;
end

initial
begin
    forever #(PERIOD_RD/2)  rd_clk=~rd_clk;
end

initial
begin
    rst_n = 0;
    #(PERIOD_WR*2) rst_n  =  1;
    write_data(1,1);
    write_data(3,2);
    write_data(5,3);
    read_data(1,data);
    read_data(3,data);
    read_data(5,data);

end

task write_data(input int addr,input reg [7:0] data);
begin
    @(posedge wr_clk);
    wr_en <= 1;
    wr_addr <= addr;
    wr_data <= data;
    @(posedge wr_clk);
    wr_en <= 0;
end
endtask

task read_data(input int addr,output reg [7:0] data);
begin
    @(posedge rd_clk);
    rd_en <= 1;
    rd_addr <= addr;
    data <= rd_data;
    @(posedge rd_clk);
    rd_en <= 0;
end
endtask

dualram #(
    .ADDR_WIDTH ( ADDR_WIDTH ))
 u_dualram (
    .rd_clk                  ( rd_clk         ),
    .wr_clk                  ( wr_clk         ),
    .rst_n                   ( rst_n          ),
    .wr_en                   ( wr_en          ),
    .wr_addr                 ( wr_addr  [3:0] ),
    .wr_data                 ( wr_data  [7:0] ),
    .rd_en                   ( rd_en          ),
    .rd_addr                 ( rd_addr  [3:0] ),

    .rd_data                 ( rd_data  [7:0] )
);
endmodule

波形图

八、同步FIFO

FIFO是由读写控制逻辑加RAM构成的，实现FIFO的关键因素就是读写指针、空满标志。

读写指针通过wr_ptr、rd_ptr两个计数器来实现，空满标志通过count计数器来判断,写入一个计数器加一，读出一个计数器减一，当count==0时表示FIFO空，当count==depth时表示fifo满

module fifo_out#(
    parameter C_FIFO_DEPTH=128,
    parameter C_FIFO_WIDTH=8
)(
    input clk,
    input rst_n,

    input wr_vld,
    output wr_rdy,
    input [C_FIFO_WIDTH-1:0] data_i,

    output rd_vld,
    input rd_rdy,
    output reg [C_FIFO_WIDTH-1:0] data_o
);

function integer clogb2(input integer depth);
begin
    for(clogb2=0;depth>0;clogb2=clogb2+1)begin
        depth=depth >> 1;
    end 
end
endfunction

reg [C_FIFO_WIDTH-1:0] fifo_data [C_FIFO_DEPTH-1:0];
reg [clogb2(C_FIFO_DEPTH-1)-1:0] wr_ptr,rd_ptr;
reg [clogb2(C_FIFO_DEPTH-1)-1:0] count;
wire full,empty;
wire wr_en,rd_en;

assign wr_en=wr_vld && wr_rdy;
assign rd_en=rd_vld && rd_rdy;

always@(posedge clk or negedge rst_n)
    if(~rst_n)
        wr_ptr<='h0;
    else if(wr_ptr==C_FIFO_DEPTH-1)
        wr_ptr<='h0;
    else if(wr_en && ~full)begin
        fifo_data[wr_ptr]<=data_i;
        wr_ptr<= wr_ptr + 1'b1;
    end

always@(posedge clk or negedge rst_n)
    if(~rst_n)begin
        rd_ptr<='h0;
        data_o<='h0;    
    end
    else if(rd_ptr==C_FIFO_DEPTH-1)
        rd_ptr<='h0;
    else if(rd_en && ~empty)begin
        rd_ptr<=rd_ptr + 1'b1;
        data_o<=fifo_data[rd_ptr];
    end

always@(posedge clk or negedge rst_n)
    if(~rst_n)
        count<='h0;
    else begin
        case({wr_en,rd_en})
            2'b00:count<=count;
            2'b01:if(count!='h0)
                count<=count-1'b1;
            2'b10:if(count!=C_FIFO_DEPTH-1)
                count<=count+1'b1;
            2'b11:count<=count;
        endcase
    end

assign wr_rdy=wr_vld && ~full;
assign rd_vld=~empty;
assign empty = (count=='h0)? 1'b1:1'b0;
assign full = (count==C_FIFO_DEPTH-1)? 1'b1:1'b0;

endmodule

仿真代码

`timescale  1ns / 1ps 
module tb_fifo_out;   
// fifo_out Parameters
parameter PERIOD        = 10;
parameter C_FIFO_DEPTH  = 128;

// fifo_out Inputs
bit   clk          ;
reg   rst_n        ;
reg   wr_vld       ;
reg   [7:0]  data_i;
reg   rd_rdy       ;

// fifo_out Outputs
wire  wr_rdy       ;
wire  rd_vld       ;
wire  [7:0]  data_o;

initial
begin
    forever #(PERIOD/2)  clk=~clk;
end

initial
begin
    rst_n=0;
    rd_rdy=0;
    #(PERIOD*2) rst_n  =  1;
    write_data(128);
    #100;
    rd_rdy=1;
end

integer i;
task write_data(input int unsigned number);
begin
    for(i=0;i<number;i++)begin
        @(posedge clk);
        wr_vld<=1'b1;
        data_i<=($random)%20;
    end
    wr_vld<=0;
    data_i<=0;
end
endtask

fifo_out #(
    .C_FIFO_DEPTH ( C_FIFO_DEPTH ))
 u_fifo_out (
    .clk                     ( clk           ),
    .rst_n                   ( rst_n         ),
    .wr_vld                  ( wr_vld        ),
    .data_i                  ( data_i  [7:0] ),
    .rd_rdy                  ( rd_rdy        ),

    .wr_rdy                  ( wr_rdy        ),
    .rd_vld                  ( rd_vld        ),
    .data_o                  ( data_o  [7:0] )
);

endmodule

波形图

九、异步FIFO

异步FIFO因为读写不在一个时钟域，因此fifo的空满信号不能通过读写指针直接进行判断，空信号需要先将写指针转换为格雷码（因格雷码相邻数之间每次只有1bit发生变化）其次进行打两拍，最后将同步到读时钟域的写指针和读指针进行判断得到fifo的空状态；满状态同理将读指针同步到写时钟域进行判断。

写指针经过打拍后在同一时刻滞后于读指针，因此空是非空的，同理满是非满的，但不影响系统的正常工作

module fifo_async #(
    parameter C_FIFO_WIDTH=8,
              C_FIFO_DEPTH=32
)(
    input rst_n,
    input wr_clk,
    input wr_valid,
    output wr_ready,
    input [C_FIFO_WIDTH-1:0] data_in,
    
    input rd_clk,
    output rd_valid,
    input rd_ready,
    output reg [C_FIFO_WIDTH-1:0] data_out,

    output full,
    output empty

);

integer i;
function integer clogb2(input integer depth);
begin
    for(clogb2=0;depth>0;clogb2=clogb2+1'b1)begin
        depth=depth>>1;
    end 
end
endfunction

reg [C_FIFO_WIDTH-1:0] fifo_data [C_FIFO_DEPTH-1:0];
reg [clogb2(C_FIFO_DEPTH-1):0] wr_ptr,rd_ptr;
wire [clogb2(C_FIFO_DEPTH-1)-1:0] wr_ptr_ture,rd_ptr_ture;
wire [clogb2(C_FIFO_DEPTH-1):0] wr_ptr_gray;
wire [clogb2(C_FIFO_DEPTH-1):0] rd_ptr_gray;
reg  [clogb2(C_FIFO_DEPTH-1):0] wr_ptr_gray1,wr_ptr_gray2;
reg  [clogb2(C_FIFO_DEPTH-1):0] rd_ptr_gray1,rd_ptr_gray2;
wire wr_en,rd_en;

assign wr_en = wr_valid && wr_ready;
assign rd_en = rd_valid && rd_ready;

assign wr_ptr_ture = wr_ptr[clogb2(C_FIFO_DEPTH-1)-1:0];
assign rd_ptr_ture = rd_ptr[clogb2(C_FIFO_DEPTH-1)-1:0];

assign wr_ready=wr_valid && ~full;
assign rd_valid=~empty;


always@(posedge wr_clk or negedge rst_n)
    if(~rst_n)
        wr_ptr<='h0;
    else if(wr_en && ~full)begin
        fifo_data[wr_ptr_ture]<=data_in;
        wr_ptr<=wr_ptr+1'b1;
    end

always@(posedge rd_clk or negedge rst_n)
    if(~rst_n)begin
        rd_ptr<='h0;
        data_out<='h0;
    end
    else if(rd_en && ~empty)begin
        data_out<=fifo_data[rd_ptr_ture];
        rd_ptr<=rd_ptr+1'b1;
    end

//binary2gray
assign wr_ptr_gray = (wr_ptr>>1) ^ wr_ptr;
assign rd_ptr_gray = (rd_ptr>>1) ^ rd_ptr;

always@(posedge rd_clk or negedge rst_n)
    if(~rst_n)begin
        wr_ptr_gray1<='h0;
        wr_ptr_gray2<='h0;
    end
    else begin
        wr_ptr_gray1<=wr_ptr_gray;
        wr_ptr_gray2<=wr_ptr_gray1;
    end

always@(posedge wr_clk or negedge rst_n)
    if(~rst_n)begin
        rd_ptr_gray1<='h0;
        rd_ptr_gray2<='h0;
    end
    else begin
        rd_ptr_gray1<=rd_ptr_gray;
        rd_ptr_gray2<=rd_ptr_gray1;
    end

assign empty = (wr_ptr_gray2==rd_ptr_gray)? 1'b1: 1'b0;
assign full  = (wr_ptr_gray[7:0]=={~(rd_ptr_gray2[clogb2(C_FIFO_DEPTH-1)-:2]),rd_ptr_gray2[clogb2(C_FIFO_DEPTH-1)-2:0]})? 1'b1: 1'b0;

endmodule

仿真代码

`timescale  1ns / 1ps   
module tb_fifo_async;   
// fifo_async Parameters
parameter WR_PERIOD        = 10;
parameter RD_PERIOD        = 20;
parameter C_FIFO_WIDTH  = 8;
parameter C_FIFO_DEPTH  = 128;
// fifo_async Inputs
reg   rst_n                      ;
bit   wr_clk                     ;
bit   rd_clk                     ;
reg   wr_valid                   ;
reg   [C_FIFO_WIDTH-1:0]  data_in;
reg   rd_ready                   ;
// fifo_async Outputs
wire  wr_ready                             ;
wire  rd_valid                             ;
wire  [C_FIFO_WIDTH-1:0]  data_out         ;
wire  full                                 ;
wire  empty                                ;

always #(WR_PERIOD/2)  wr_clk=~wr_clk;
always #(RD_PERIOD/2)  rd_clk=~rd_clk;

initial
begin
    rst_n = 0;
    wr_valid=1'b0;
    rd_ready=1'b0;
    #(WR_PERIOD*2) rst_n  =  1;
    #(WR_PERIOD*2);
    generate_data(130);
    #100;
    rd_ready = 1'b1;
end

integer i;
task generate_data(input int unsigned number);
begin
    for(i=0;i<number;i=i+1)begin
        @(posedge wr_clk);
        wr_valid<=1'b1;
        data_in<=($random)%20;
    end
    wr_valid<=1'b0;
    data_in<='h0;
end
endtask

fifo_async #(
   .C_FIFO_WIDTH ( C_FIFO_WIDTH ),
   .C_FIFO_DEPTH (C_FIFO_DEPTH  )

)u_fifo_async (
    .rst_n                   ( rst_n                        ),
    .wr_clk                  ( wr_clk                       ),
    .wr_valid                ( wr_valid                     ),
    .data_in                 ( data_in   [C_FIFO_WIDTH-1:0] ),
    .rd_clk                  ( rd_clk                       ),
    .rd_ready                ( rd_ready                     ),

    .wr_ready                ( wr_ready                     ),
    .rd_valid                ( rd_valid                     ),
    .data_out                ( data_out  [C_FIFO_WIDTH-1:0] ),
    .full                    ( full                         ),
    .empty                   ( empty                        )
);
endmodule

波形图

张小侃
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大量的verilog源代码
Studying……
09-30 1万+
Verilog HDL 程序举例 一，基本组合逻辑功能： 双向管脚（clocked bidirectional pin） Verilog HDL: Bidirectional Pin   This example implements a clockedbidirectional pin in Verilog HDL. The value of OE determines whethe
基于CPLD的三相整流器移相触发电路系统开发+verilog程序+protel电路图以及说明文档
06-02
介绍了三相整流器的基本原理，CPLD芯片的基本结构以及CPLD系统的设计流程。通过对比常见的三相整流器移相触发电路设计方案的优劣，确定了基于CPLD的三相整流器移相触发电路的实现方案。三相整流器移相触发电路整体结构包括初始相位模块，自适应相位调节模块，触发脉冲产生模块，相序的自适应调整功能模块等，并给出了相应的Modelsim仿真结果。设计了三相整流器移相触发电路的硬件电路，通过硬件测试可知，本系统较好的实现了三相整流器移相触发功能，通过示波器观察可以看到双脉冲的输出，基本符合设计预期。
【FPGA】Verilog：时序电路设计 | 二进制计数器 | 计数器 | 分频器 | 时序约束
m0_66307842的博客
03-10 5588
【FPGA】Verilog：时序电路设计 | 二进制计数器 | 计数器 | 分频器 | 时序约束
Verilog基础之十、计数器实现
zyp626的博客
06-25 2447
计数器是较为基础的逻辑，很多其他逻辑可依靠计数器实现，如控制器，分频。原理为通过统计时钟脉冲的个数来输出计数值。
FPGA通过读写突发对DS1302时钟的配置&驱动
qq_52215423的博客
10-16 1310
FPGA通过读写突发对DS1302时钟的配置&驱动
Verilog实现常见电路（一）
weixin_40634481的博客
02-15 1792
计划将常见电路的verilog实现进行总结，如有不对的地方，欢迎大家批评指正，先放目录 一、边沿检测 二、串并转换 三、分频器 一、边沿检测 首先对数据打两拍，然后通过两拍数据之间的逻辑关系来判断出是上升沿还是下降沿 module edge_detect( input clk, input rst_n, input data, output pos_edge, output neg_edge ); reg data_d0,data_d1; alw
在verilog中使用clogb2函数可进行log2操作，用来计算数据位宽
w40306030072的专栏
01-09 2万+
//function called clogb2 that returns an integer which has the //value of the ceiling of the log base 2. function integer clogb2 (input integer bit_depth); begin for(clogb2=0; bit_depth>0;
verilog实现简单的三级加法流水线
学渣的博客
07-08 7464
pipeline流水线设计是一种典型的面积换性能的设计。一方面通过对长功能路径的合理划分，在同一时间内同时并行多个该功能请求，大大提高了某个功能的吞吐率；另一方面由于长功能路径被切割成短路径，可以达到更高的工作频率，如果不需要提高工作频率，多出来的提频空间可以用于降压降功耗，进可攻退可守。今天这篇文章将小小总结一下流水线设计的一些关键点。
Verilog常用语法
热门推荐
weixin_50810761的博客
02-08 3万+
Verilog可综合常用语法 一、模块的结构、数据类型、变量和基本运算符号 1 模块的结构 1.1 端口定义 module 模块名（口1,口2,口3,…）; 两种模块例化方式： 方法一：模块名（连接端口1信号名,连接端口2信号名,连接端口3信号名,…）； 方法二：模块名（.端口名1（连接信号1名）,.端口名2（连接信号2名）,…）； 例化时还可以对模块中的参数型（parameter）变量进行重新赋值； 例如： module min(input clk,input rst_n,input a1,outpu
【数字电路】ms14-微分运算电路.zip
最新发布
05-05
ModelSim：ModelSim是一种常见的数字电路仿真工具，支持Verilog、VHDL等硬件描述语言。它可以模拟数字电路的行为，并提供波形查看器等功能进行仿真结果的分析。 Xilinx ISE 和 Vivado：Xilinx的ISE和Vivado是专门...
【数字电路】ms14-温度报警电路.zip
05-05
ModelSim：ModelSim是一种常见的数字电路仿真工具，支持Verilog、VHDL等硬件描述语言。它可以模拟数字电路的行为，并提供波形查看器等功能进行仿真结果的分析。 Xilinx ISE 和 Vivado：Xilinx的ISE和Vivado是专门...
【数字电路】ms14-通向求和电路.zip
05-05
ModelSim：ModelSim是一种常见的数字电路仿真工具，支持Verilog、VHDL等硬件描述语言。它可以模拟数字电路的行为，并提供波形查看器等功能进行仿真结果的分析。 Xilinx ISE 和 Vivado：Xilinx的ISE和Vivado是专门...
【数字电路】ms14-积分运算电路.zip
05-05
ModelSim：ModelSim是一种常见的数字电路仿真工具，支持Verilog、VHDL等硬件描述语言。它可以模拟数字电路的行为，并提供波形查看器等功能进行仿真结果的分析。 Xilinx ISE 和 Vivado：Xilinx的ISE和Vivado是专门...
Verilog中一些特殊的函数
m0_52090088的博客
03-27 1829
最近在看夏宇闻的书，函数声明部分，其中提到一些之前没有用到过的函数，在此作为记录 自动（递归）函数 Verilog中的函数是不能够进行递归调用的。设计模块中若某函数在两个不同的地方被同时开发调用，由于这两个调用同时对同一块地址空间进行操作，那么计算结果将是不确定的。 若在函数声明中使用了关键字automatic, 那么该函数将成为自动的或可递归的，即仿真器为每一次函数调用动态地分配新的地址空间，每一个函数调用对各自的地址空间进行操作。因此，自动函数中声明的局部变量不能通过层次名进行访问。而自动函数本身
Verilog位宽转换器参数化设计
qq_34839501的博客
05-15 1346
Verilog 位宽转换 参数化设计
【DS28EC20 1-wire协议及verilog调试记录】
weixin_40962180的博客
12-04 321
1-wire单总线是Maxim全资子公司Dallas的一项专有技术。与目前多数标准串行数据通信方式，如SPI / I2C不同，它采用单根信号线，既传输时钟，又传输数据，而且数据传输是双向的。它具有节省I/O口线资源、结构简单、成本低廉、便于总线扩展和维护等诸多优点。1-wire单总线适用于单个主机系统，能够控制一个或多个从机设备。当只有一个从机位于总线上时，系统可按照单节点系统操作；而当多个从机位于总线上时，则系统按照多节点系统操作。
Verilog中函数实例
Arist.
06-30 4069
给定深度计算位宽 function integer clogb2(input integer depth); begin for(clogb2 = 0; depth >0;clogb2 = clogb2 +1) begin depth = depth >> 1; end // clogb2 = clogb2 - 1; //此处不减则需要在定义reg或者端口的时候减 end endfunction 常规函数格式 // --function to judge.
verilog $clog2 取位宽函数
qq_41137205的博客
04-06 3962
/定义 function integer clogb2(input integer size);endend//使用//PIX位宽问题在于：1、每次使用到计算PIX位宽时都需要定义该函数，工作量重复、效率较低。2、因为函数定义在模块内部，无法对输入输出信号使用该函数。
高速收发器（GTX）文章导航
weixin_50810761的博客
05-01 667
高速收发器专栏导航
verilog 条件判断电路
08-31
另一种常见的条件判断电路是使用 case 语句。下面是一个使用 case 语句实现的例子： ```verilog module ConditionalCircuit( input wire [1:0] sel, output wire [3:0] out ); // 使用 case 实现条件判断电路 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值