当前位置：文档视界 › 两种异步FIFO的设计及verilog源代码

两种异步FIFO的设计及verilog源代码

异步FIFO及verilog原码_1

异步FIFO及verilog原码

这几天看了Clifford E. Cummings的两篇大作《Simulation and Synthesis Techniques for Asynchronous FIFO Design》and 《Simulation and Synthesis Techniques for Asynchronous FIFO Design with Asynchronous Pointer Comparisons》颇有感想，真可谓经典之作，不可错过。

1．什么是FIFO？

FIFO是英文First In First Out 的缩写，是一种先进先出的数据缓存器，他与普通存储器的区别是没有外部读写地址线，这样使用起来非常简单，但缺点就是只能顺序写入数据，顺序的读出数据，其数据地址由内部读写指针自动加1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。

2．什么情况下用FIFO？

FIFO一般用于不同时钟域之间的数据传输，比如FIFO的一端是AD数据采集，另一端是计算机的PCI总线，假设其AD采集的速率为16位100K SPS，那么每秒的数据量为

100K×16bit=1.6Mbps,而PCI总线的速度为33MHz，总线宽度32bit,其最大传输速率为

1056Mbps,在两个不同的时钟域间就可以采用FIFO来作为数据缓冲。

另外对于不同宽度的数据接口也可以用FIFO，例如单片机位8位数据输出，而DSP可能是16位数据输入，在单片机与DSP连接时就可以使用FIFO来达到数据匹配的目的。

3．FIFO的一些重要参数

FIFO的宽度：也就是英文资料里常看到的THE WIDTH，它只的是FIFO一次读写操作的数据位，就像MCU有8位和16位，ARM 32位等等，FIFO的宽度在单片成品IC中是固定的，也有可选择的，如果用FPGA自己实现一个FIFO，其数据位，也就是宽度是可以自己定义的。

FIFO的深度：THE DEEPTH，它指的是FIFO可以存储多少个N位的数据（如果宽度为N）。如一个8位的FIFO，若深度为8，它可以存储8个8位的数据，深度为12 ，就可以存储12个8位的数据，FIFO的深度可大可小，个人认为FIFO深度的计算并无一个固定的公式。在FIFO实际工作中，其数据的满/空标志可以控制数据的继续写入或读出。在一个具体的应用中也不可能由一些参数算数精确的所需FIFO深度为多少，这在写速度大于读速度的理想状态下是可行的，但在实际中用到的FIFO深度往往要大于计算值。一般来说根据电路的具体情况，在兼顾系统性能和FIFO成本的情况下估算一个大概的宽度和深度就可以了。而对于写速度慢于读速度的应用，FIFO的深度要根据读出的数据结构和读出数据的由那些具体的要求来确定。

满标志：FIFO已满或将要满时由FIFO的状态电路送出的一个信号，以阻止FIFO的写操作继续向FIFO中写数据而造成溢出（overflow）。

空标志：FIFO已空或将要空时由FIFO的状态电路送出的一个信号，以阻止FIFO的读操作继续从FIFO中读出数据而造成无效数据的读出（underflow）。

读时钟：读操作所遵循的时钟，在每个时钟沿来临时读数据。

写时钟：写操作所遵循的时钟，在每个时钟沿来临时写数据。

读指针：指向下一个读出地址。读完后自动加1。

写指针：指向下一个要写入的地址的，写完自动加1。

读写指针其实就是读写的地址，只不过这个地址不能任意选择，而是连续的。

4．FIFO的分类

根均FIFO工作的时钟域，可以将FIFO分为同步FIFO和异步FIFO。同步FIFO是指读时钟和写时钟为同一个时钟。在时钟沿来临时同时发生读写操作。异步FIFO是指读写时钟不一致，读写时钟是互相独立的。

5．FIFO设计的难点

发生益处或读空的状态出现，必须保证FIFO在满的情况下，不能进行写操作。在空的状态下不能进行读操作。怎样判断FIFO的满/空就成了FIFO设计的核心问题。由于同步FIFO 几乎很少用到，这里只描述异步FIFO的空/满标志产生问题。在用到触发器的设计中，不可避免的会遇到亚稳态的问题（关于亚稳态这里不作介绍，可查看相关资料）。

在涉及到触发器的电路中，亚稳态无法彻底消除，只能想办法将其发生的概率将到最低。其中的一个方法就是使用格雷码。格雷码在相邻的两个码元之间只由一位变换(二进制码在很多情况下是很多码元在同时变化)。这就会避免计数器与时钟同步的时候发生亚稳态现象。但是格雷码有个缺点就是只能定义2^n的深度，而不能像二进制码那样随意的定义FIFO的深度，因为格雷码必须循环一个2^n，否则就不能保证两个相邻码元之间相差一位的条件，因此也就不是真正的各雷码了。

第二就是使用冗余的触发器，假设一个触发器发生亚稳态的概率为P，那么两个及联的触发器发生亚稳态的概率就为P的平方。但这回导致延时的增加。亚稳态的发生会使得FIFO出现错误，读/写时钟采样的地址指针会与真实的值之间不同，这就导致写入或读出的地址错误。由于考虑延时的作用，空/满标志的产生并不一定出现在FIFO真的空/满时才出现。可能FIFO还未空/满时就出现了空/满标志。这并没有什么不好，只要保证FIFO不出现overflow or underflow 就OK了。

很多关于FIFO的文章其实讨论的都是空/满标志的不同算法问题。

第一个算法：Clifford E. Cummings的文章中提到的STYLE #1，构造一个指针宽度为N+1，深度为2^N字节的FIFO（为便方比较将格雷码指针转换为二进制指针）。当指针的二进制码中最高位不一致而其它N位都相等时，FIFO为满（在Clifford E. Cummings的文章中以格雷码表示是前两位均不相同，而后两位LSB相同为满，这与换成二进制表示的MSB不同其他相同为满是一样的）。当指针完全相等时，FIFO为空。

这种方法思路非常明了，为了比较不同时钟产生的指针，需要把不同时钟域的信号同步到本时钟域中来，而使用Gray码的目的就是使这个异步同步化的过程发生亚稳态的机率最小，而为什么要构造一个N+1的指针，Clifford E. Cummings也阐述的很明白，有兴趣的读者可以看下作者原文是怎么论述的，Clifford E. Cummings的这篇文章有Rev1.1 \ Rev1.2两个版本，两者在比较Gray码指针时的方法略有不同，个Rev1.2版更为精简。

第二种算法：Clifford E. Cummings的文章中提到的STYLE #2。它将FIFO地址分成了4部分，每部分分别用高两位的MSB 00 、01、11、10决定FIFO是否为going full 或going empty (即将满或空)。如果写指针的高两位MSB小于读指针的高两位MSB则FIFO为“几乎满”，若写指针的高两位MSB大于读指针的高两位MSB则FIFO为“几乎空”。

它是利用将地址空间分成4个象限（也就是四个等大小的区域），然后观察两个指针的相对位置，如果写指针落后读指针一个象限（25%的距离，呵呵），则证明很可能要写满，反之则很可能要读空，这个时候分别设置两个标志位dirset和dirrst，然后在地址完全相等的情况下，如果dirset有效就是写满，如果dirrst有效就是读空。

这种方法对深度为2^N字节的FIFO只需N位的指针即可，处理的速度也较第一种方法快。

异步FIFO及verilog原码_续

两篇文章的原码

//----------------------STYLE #1--------------------------

module fifo1(rdata, wfull, rempty, wdata, winc, wclk, wrst_n,rinc, rclk, rrst_n);

parameter DSIZE = 8;

parameter ASIZE = 4;

output [DSIZE-1:0] rdata;

output wfull;

output rempty;

input [DSIZE-1:0] wdata;

input winc, wclk, wrst_n;

input rinc, rclk, rrst_n;

reg wfull,rempty;

reg [ASIZE:0] wptr, rptr, wq2_rptr, rq2_wptr, wq1_rptr,rq1_wptr;

reg [ASIZE:0] rbin, wbin;

reg [DSIZE-1:0] mem[0:(1<

wire [ASIZE-1:0] waddr, raddr;

wire [ASIZE:0] rgraynext, rbinnext,wgraynext,wbnnext;

wire rempty_val,wfull_val;

//-----------------双口RAM存储器--------------------

assign rdata=mem[raddr];

always@(posedge wclk)

if (winc && !wfull) mem[waddr] <= wdata;

//-------------同步rptr 指针-------------------------

always @(posedge wclk or negedge wrst_n)

if (!wrst_n) {wq2_rptr,wq1_rptr} <= 0;

else {wq2_rptr,wq1_rptr} <= {wq1_rptr,rptr};

//-------------同步wptr指针---------------------------

always @(posedge rclk or negedge rrst_n)

if (!rrst_n) {rq2_wptr,rq1_wptr} <= 0;

else {rq2_wptr,rq1_wptr} <= {rq1_wptr,wptr};

//-------------rempty产生与raddr产生-------------------

//-------------------

// GRAYSTYLE2 pointer

//-------------------

always @(posedge rclk or negedge rrst_n)

begin

if (!rrst_n) {rbin, rptr} <= 0;

else {rbin, rptr} <= {rbinnext, rgraynext};

end

// Memory read-address pointer (okay to use binary to address memory)

assign raddr = rbin[ASIZE-1:0];

assign rbinnext = rbin + (rinc & ~rempty);

assign rgraynext = (rbinnext>>1) ^ rbinnext; // 二进制码转换成为格雷码，经典//---------------------------------------------------------------

// FIFO empty when the next rptr == synchronized wptr or on reset

//---------------------------------------------------------------

assign rempty_val = (rgraynext == rq2_wptr);

always @(posedge rclk or negedge rrst_n)

begin

if (!rrst_n) rempty <= 1'b1;

else rempty <= rempty_val;

end

//---------------wfull产生与waddr产生------------------------------

// GRAYSTYLE2 pointer

always @(posedge wclk or negedge wrst_n)

if (!wrst_n) {wbin, wptr} <= 0;

else {wbin, wptr} <= {wbinnext, wgraynext};

// Memory write-address pointer (okay to use binary to address memory)

assign waddr = wbin[ASIZE-1:0];

assign wbinnext = wbin + (winc & ~wfull);

assign wgraynext = (wbinnext>>1) ^ wbinnext;

//------------------------------------------------------------------

// Simplified version of the three necessary full-tests:

// assign wfull_val=((wgnext[ADDRSIZE] !=wq2_rptr[ADDRSIZE] ) &&

// (wgnext[ADDRSIZE-1] !=wq2_rptr[ADDRSIZE-1]) &&

// (wgnext[ADDRSIZE-2:0]==wq2_rptr[ADDRSIZE-2:0]));

//------------------------------------------------------------------

assign wfull_val = (wgraynext=={~wq2_rptr[ASIZE:ASIZE-1],

wq2_rptr[ASIZE-2:0]});

always @(posedge wclk or negedge wrst_n)

if (!wrst_n) wfull <= 1'b0;

else wfull <= wfull_val;

endmodule

//---------------------STYLE #2-------------------------

module fifo2 (rdata, wfull, rempty, wdata,winc, wclk, wrst_n, rinc, rclk, rrst_n);

parameter DSIZE = 8;

parameter ASIZE = 4;

output [DSIZE-1:0] rdata;

output wfull;

output rempty;

input [DSIZE-1:0] wdata;

input winc, wclk, wrst_n;

input rinc, rclk, rrst_n;

wire [ASIZE-1:0] wptr, rptr;

wire [ASIZE-1:0] waddr, raddr;

async_cmp #(ASIZE) async_cmp(.aempty_n(aempty_n),

.afull_n(afull_n),

.wptr(wptr), .rptr(rptr),

.wrst_n(wrst_n));

fifomem2 #(DSIZE, ASIZE) fifomem2(.rdata(rdata),

.wdata(wdata),

.waddr(wptr),

.raddr(rptr),

.wclken(winc),

.wclk(wclk));

rptr_empty2 #(ASIZE) rptr_empty2(.rempty(rempty),

.rptr(rptr),

.aempty_n(aempty_n),

.rinc(rinc),

.rclk(rclk),

.rrst_n(rrst_n));

wptr_full2 #(ASIZE) wptr_full2(.wfull(wfull),

.wptr(wptr),

.afull_n(afull_n),

.winc(winc),

.wclk(wclk),

.wrst_n(wrst_n));

endmodule

module fifomem2 (rdata, wdata, waddr, raddr, wclken, wclk);

parameter DATASIZE = 8; // Memory data word width

parameter ADDRSIZE = 4; // Number of memory address bits

parameter DEPTH = 1<

input [DATASIZE-1:0] wdata;

input [ADDRSIZE-1:0] waddr, raddr;

input wclken, wclk;

`ifdef VENDORRAM

// instantiation of a vendor's dual-port RAM

VENDOR_RAM MEM (.dout(rdata), .din(wdata),

.waddr(waddr), .raddr(raddr),

.wclken(wclken), .clk(wclk));

`else

reg [DATASIZE-1:0] MEM [0:DEPTH-1];

assign rdata = MEM[raddr];

always @(posedge wclk)

if (wclken) MEM[waddr] <= wdata;

`endif

endmodule

module async_cmp (aempty_n, afull_n, wptr, rptr, wrst_n);

parameter ADDRSIZE = 4;

parameter N = ADDRSIZE-1;

output aempty_n, afull_n;

input [N:0] wptr, rptr;

reg direction;

wire high = 1'b1;

wire dirset_n = ~( (wptr[N]^rptr[N-1]) & ~(wptr[N-1]^rptr[N]));

wire dirclr_n = ~((~(wptr[N]^rptr[N-1]) & (wptr[N-1]^rptr[N])) | ~wrst_n);

always @(posedge high or negedge dirset_n or negedge dirclr_n) if (!dirclr_n) direction <= 1'b0;

else if (!dirset_n) direction <= 1'b1;

else direction <= high;

//always @(negedge dirset_n or negedge dirclr_n)

//if (!dirclr_n) direction <= 1'b0;

//else direction <= 1'b1;

assign aempty_n = ~((wptr == rptr) && !direction);

assign afull_n = ~((wptr == rptr) && direction);

endmodule

module rptr_empty2 (rempty, rptr, aempty_n, rinc, rclk, rrst_n);

parameter ADDRSIZE = 4;

output rempty;

output [ADDRSIZE-1:0] rptr;

input aempty_n;

input rinc, rclk, rrst_n;

reg [ADDRSIZE-1:0] rptr, rbin;

reg rempty, rempty2;

wire [ADDRSIZE-1:0] rgnext, rbnext;

//---------------------------------------------------------------

// GRAYSTYLE2 pointer

//---------------------------------------------------------------

always @(posedge rclk or negedge rrst_n)

rbin <= 0;

rptr <= 0;

end

else begin

rbin <= rbnext;

rptr <= rgnext;

end

//---------------------------------------------------------------

// increment the binary count if not empty

//---------------------------------------------------------------

assign rbnext = !rempty ? rbin + rinc : rbin;

assign rgnext = (rbnext>>1) ^ rbnext; // binary-to-gray conversion always @(posedge rclk or negedge aempty_n)

if (!aempty_n) {rempty,rempty2} <= 2'b11;

else {rempty,rempty2} <= {rempty2,~aempty_n};

endmodule

module wptr_full2 (wfull, wptr, afull_n, winc, wclk, wrst_n);

parameter ADDRSIZE = 4;

output wfull;

output [ADDRSIZE-1:0] wptr;

input afull_n;

input winc, wclk, wrst_n;

reg [ADDRSIZE-1:0] wptr, wbin;

reg wfull, wfull2;

wire [ADDRSIZE-1:0] wgnext, wbnext;

//---------------------------------------------------------------

// GRAYSTYLE2 pointer

//---------------------------------------------------------------

always @(posedge wclk or negedge wrst_n)

if (!wrst_n) begin

wbin <= 0;

wptr <= 0;

end

else begin

wbin <= wbnext;

wptr <= wgnext;

end

//---------------------------------------------------------------

// increment the binary count if not full

//---------------------------------------------------------------

assign wbnext = !wfull ? wbin + winc : wbin;

assign wgnext = (wbnext>>1) ^ wbnext; // binary-to-gray conversion

always @(posedge wclk or negedge wrst_n or negedge afull_n)

if (!wrst_n ) {wfull,wfull2} <= 2'b00;

else if (!afull_n) {wfull,wfull2} <= 2'b11;

else {wfull,wfull2} <= {wfull2,~afull_n};

endmodule

细心的读者会发现，第一种写法（本人做的修改）把所有信号写在同一个module里，而第二种写法则分了很多模块。哪种写法更好呢？有兴趣的可以想一想，事实上，第二种写法是推荐的写法：原因如下：

异步的多时钟设计应按以下几个原则进行设计：

1，尽可能的将多时钟的逻辑电路（非同步器）分割为多个单时钟的模块，这样有利于静态时序分析工具来进行时序验证。

2，同步器的实现应使得所有输入来自同一个时钟域，而使用另一个时钟域的异步时钟信号采样数据。

3，面向时钟信号的命名方式可以帮助我们确定那些在不同异步时钟域间需要处理的信号。

4，当存在多个跨时钟域的控制信号时，我们必须特别注意这些信号，保证这些控制信号到达新的时钟域仍然能够保持正确的顺序。

VerilogHDL经典程序非常适合新手

一、2线-4线译码器 module counter4(q1,q0,ncr,cp); input cp,ncr; output q1,q0; reg q1,q0; always@(posedge cp or negedge ncr) begin if(~ncr){q1,q0}<=2'b00; else{q1,q0}<={q1,q0}+1'b1; end endmodule 二、4选1数据选择器 module selector4_1(i0,i1,i2,i3,a1,a0,y); input i0,i1,i2,i3,a1,a0; output y; reg y; always@(a1or a0) begin case({a1,a0}) 2'b00:y=i0; 2'b01:y=i1; 2'b10:y=i2; 2'b11:y=i3; default:y=0; 一、2线-4线译码器 module counter4(q1,q0,ncr,cp); input cp,ncr; output q1,q0; reg q1,q0; always@(posedge cp or negedge ncr) begin if(~ncr){q1,q0}<=2'b00; else{q1,q0}<={q1,q0}+1'b1; end endmodule 二、4选1数据选择器 module selector4_1(i0,i1,i2,i3,a1,a0,y); input i0,i1,i2,i3,a1,a0; output y; reg y; always@(a1or a0) begin case({a1,a0}) 2'b00:y=i0;

一个异步FIFO的设计示例

一、异步FIFO 技术规 1. 总体描述 1.1. 功能定义异步FIFO ( First In First Out)指的是在两个相互独立的时钟域下, 数据从一个时钟域写入FIFO 而另一个时钟域又从这个FIFO 中将数据读出。本设计用8*256的RAM 实现异步FIFO 。具体功能： 1．写使能有效，且FIFO 不为满时，在写时钟的上升沿向FIFO 中写入数据。 2．读使能有效，且FIFO 不为空时，在读时钟的上升沿从FIFO 中读出数据。 3．当FIFO 写满时产生满信号，当FIFO 读空时产生空信号。 1.2. 应用围异步FIFO 是用来作为缓冲的存储器, 它能对数据进行快速、顺序的存储和发送, 主要用来解决不同速率器件间的速率匹配问题。 2. 引脚描述图1 2.1. 引脚功能描述

2.2.引脚时序描述当写满时full由低变高，当读空时empty由低变高。只要不为满full就为低，不为空empty就为低。 3.顶层模块划分

图2 顶层模块说明： 1．ram_fifo ：存储器模块，用于存放及输出数据； 2．w_addr_reg : 保存访问RAM的写地址； 3．r_addr_reg : 保存访问RAM的读地址； 4．w_addr_adder : 计算RAM下一个写地址； 5．r_addr_adder: 计算RAM下一个读地址； 6．cmp : 将读地址和写地址进行比较产生空满标志。设计思想说明： FIFO满空的判定：当读地址的值加1之后等于写地址的值时，表明FIFO写满，当写地址的值加一之后等于读地址的值时，表明FIFO读空。在初始状态时FIFO的读地址在RAM 的中间位置，写地址在RAM的开始位置，所以初始状态FIFO不满也不空。空满信号的产生由组合电路产生。 4.功能模块描述

Verilog编码风格

Verilog编码风格嵌入式开发2010-05-03 15:28:13 阅读14 评论0 字号：大中小订阅这是以前公司的对fpga代码编写的要求良好代码编写风格的通则概括如下：（1）对所有的信号名、变量名和端口名都用小写，这样做是为了和业界的习惯保持一致；对常量名和用户定义的类型用大写；（2）使用有意义的信号名、端口名、函数名和参数名；（3）信号名长度不要太长；（4）对于时钟信号使用clk 作为信号名，如果设计中存在多个时钟，使用clk 作为时钟信号的前缀；（5）对来自同一驱动源的信号在不同的子模块中采用相同的名字，这要求在芯片总体设计时就定义好顶层子模块间连线的名字，端口和连接端口的信号尽可能采用相同的名字；（6）对于低电平有效的信号，应该以一个下划线跟一个小写字母b 或n 表示。注意在同一个设计中要使用同一个小写字母表示低电平有效；（7）对于复位信号使用rst 作为信号名，如果复位信号是低电平有效，建议使用rst_n；（8）当描述多比特总线时，使用一致的定义顺序，对于verilog 建议采用bus_signal[x:0]的表示；（9）尽量遵循业界已经习惯的一些约定。如*_r 表示寄存器输出，*_a 表示异步信号，*_pn 表示多周期路径第n 个周期使用的信号，*_nxt 表示锁存前的信号，*_z 表示三态信号等；（10）在源文件、批处理文件的开始应该包含一个文件头、文件头一般包含的内容如下例所示：文件名，作者，模块的实现功能概述和关键特性描述，文件创建和修改的记录，包括修改时间，修改的内容等；（11）使用适当的注释来解释所有的always 进程、函数、端口定义、信号含义、变量含义或信号组、变量组的意义等。注释应该放在它所注释的代码附近，要求简明扼要，只要足够说明设计意图即可，避免过于复杂；（12）每一行语句独立成行。尽管VHDL 和Verilog 都允许一行可以写多个语句，当时每个语句独立成行可以增加可读性和可维护性。同时保持每行小于或等于72 个字符，这样做都是为了提高代码得可读性；（13）建议采用缩进提高续行和嵌套语句得可读性。缩进一般采用两个空格，如西安交通大学SOC 设计中心 2 如果空格太多则在深层嵌套时限制行长。同时缩进避免使用TAB 键，这样可以避免不同机器TAB 键得设置不同限制代码得可移植能力；（14）在RTL 源码的设计中任何元素包括端口、信号、变量、函数、任务、模块等的命名都不能取Verilog 和VHDL 语言的关键字；（15）在进行模块的端口申明时，每行只申明一个端口，并建议采用以下顺序：

同步缓冲器(FIFO)的设计与实现..

同步缓冲器(FIFO)的设计与实现姓名：崔琦学号：100260305 班级：2010级电科3班院系：电气与信息工程学院专业：电子科学与技术同组人姓名：梁承润李建凯（说明：我们三个人前面的报告部分是一样的，因为课设基本是三个人商议完成，所以就感觉报告部分没什么不同的就只写了一份报告）

目录 1原理与系统设计 (3) 2设计思想 (4) 3源码与注释 (5) 4仿真 (12) 5综合 (15) 6心得体会与建议 (19)

1 原理与系统设计 FIFO（First In First Out）——是一种可以实现数据先入先出的存储器件。FIFO就像一个单向管道，数据只能按固定的方向从管道一头进来，再按相同的顺序从管道另一头出去，最先进来的数据必定是最先出去。FIFO被普遍用作数据缓冲器。 FIFO的基本单元是寄存器，作为存储器件，FIFO的存储能力是由其内部定义的存储寄存器的数量决定的。本题中所设计的是同步FIFO（即输出输入端时钟频率一致），异步复位，其存储能力为（16x8），输出两个状态信号：full与empty，以供后继电路使用。根据系统要求，画出的系统框图，如图1所示 clock reset 读控制信号写控制信号 input full empty output 图1同步FIFO框图端口说明：输入：in_data: 输入数据端口，位宽为8位； read_n: 读使能端，当read_n=0时，可以读出数据； write_n: 写使能端，当write_n=0时，可以写入数据； clock: 时钟信号，在时钟的正边沿进行采样； reset_n: 复位信号，当reset_n=0时，计数器及读写都被清零（即：读写地址指针都指向0）输出：out_data: 输出数据端口，位宽为8位;； full：FIFO状态信号，当full=1时，表明该FIFO存储器已经写满； empty：FIFO状态信号，当empty=1时，表明该FIFO存储器已经读空；

专用集成电路,verilog移位乘法器,源代码及电路仿真

生命科学技术学院《CMOS专用集成电路》实验报告学院（系）：生命科学技术学院专业：生物医学工程班级：151011 学号：15101004 学生姓名：柳琳 2013年06 月29 日

一、实验题目（1）更改测试文件相关部分的参数值，将该乘法器的数据位宽改为8-Bit。（2）根据对实验电路的分析，绘制该移位式乘法器电路详细的电路结构框图，并对每一功能部件的功能及相关参数的意义进行说明；（3）采用Verilog HDL硬件描述语言设计一个16-Bit超前进位加法器；（4）在上面超前进位加法器基础上，将原电路的部分积求和电路改进成超前进位加法器。二、实验结果与讨论（1）更改测试文件相关部分的参数值，将该乘法器的数据位宽改为8-Bit。 module multiplier_nbit ( rst, clk, x, y, result ); parameter mwidth = 8; parameter rwidth = mwidth + mwidth; input rst, clk; … reg [1:0] stcnt; reg [2:0] mucnt; … assign mucnt_en = (stcnt == 2'b01) ? 1'b1 : 1'b0; assign mucnt_full = (mucnt == 3'b111) ? 1'b1 : 1'b0; assign stcnt_load = (stcnt == 2'b10) ? 1'b1 : 1'b0; … always @(posedge rst or posedge clk) begin if(rst) mucnt <= 3'b000; else if(mucnt_en) mucnt <= mucnt + 1; else mucnt <= mucnt; end module test_mult; reg rst, clk; reg [7:0] x, y; wire [15:0] result;

(完整版)异步FIFO设计

异步FIFO设计文档一、概述在大规模ASIC或FPGA设计中，多时钟系统往往是不可避免的，这样就产生了不同时钟域数据传输的问题，其中一个比较好的解决方案就是使用异步FIFO来作不同时钟域数据传输的缓冲区，这们既可以使相异时钟域数据传输的时序要求变得宽松，也提高了它们之间的传输效率。此文内容就是阐述异步FIFO的设计。二、设计原理 2.1结构框图 Fig. 2.1.1 如上图所示的同步模块synchronize to write clk，其作用是把读时钟域的读指针rd_ptr采集到写时钟（wr_clk）域，然后和写指针wr_ptr进行比较从而产生或撤消写满标志位wr_full；类似地，同步模块synchronize to read clk 的作用是把写时钟域的写指针wr_ptr采集到读时钟域，然后和读指针rd_ptr进行比较从而产生或撤消读空标志位rd_empty。另外还有写指针wr_ptr和写满标志位wr_full产生模块，读指针rd_ptr和读模块。RAM产生模块，以及双端口存储rd_empty空标志位 2.2 二进制计数器存在的问题异步FIFO读写指针需要在数学上的操作和比较才能产生准确的空满标志位，但由于读写指针属于不同的时钟域及读写时钟相位关系的不确定性，同步模块采集另一时钟域的指针时，此指针有可能正处在跳变的过程中，如图Fig.2.2.1所示，那么采集到的值很有可能是不期望的值，当然，不期望的错误结果也会随之发生。

Fig. 2.2.1 上图中，rd_ptr2sync 3和4以及4和5之间的中间态是由于到各寄存器的时钟 rd_clk存在偏差而引起的。二进制的递增操作，在大多数情况下都会有两位或者两以上的bit位在同一个递增操作内发生变化，但由于实际电路中会存在时钟偏差和不同的路径延时，二进制计数器在自增时会不可避免地产生错误的中间结果，如图Fig.2.2.2。 Fig.2.2.2 上升沿到达rd_clk的电路原型以及局部波形的放大。由于Fig.2.2.1上图是三寄存器的时间各不相同，这就导致了rd_ptr2sync的值从3'b011跳变3'b100的过程中经历了3'b111和3'b101，直到最后一个时钟（rd_clk0）沿的到来rd_ptr2sync 才跳变到正确结果3'b100。中间结果的持续的时间虽然相对短暂，但是这些不正确的结果完全有可能被其它时钟域的同步模块采集到而产生错误的动作，见上图。由此可见，要避免中间结果的产生，其中一个可行的方案就是使被同步模块采集的数据递变时，每次只有一个bit位发生改变。格雷码计数器就是一个不错的选择。 2.3 格雷码计数器的实现 2.3.1 格雷码的表现形式格雷码一个最大的特点就是在递增或递减的过程中，每次只变化一位，这是它最大的优点。同时它也有自己的局限性，那就是循环计数深度必须是2的n次幂，否则就失去了每次只变化一位的特性。深度为16的二进制及格雷码递变表如下：Binary Gray 0 0000 0000

74LS138Verilog源码

`timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2020/02/28 13:40:03 // Design Name: // Module Name: _74ls138 // Project Name: // Target Devices: // Tool Versions: // Description: // // Dependencies: // // Revision: // Revision 0.01 - File Created // Additional Comments: // ////////////////////////////////////////////////////////////////////////////////// module _74ls138(nE1,nE2,E3,B,nY); input nE1,nE2,E3; input [2:0]B; output[7:0]nY; reg[7:0]nY; always@(nE1,nE2,E3,B) if(!nE1 && !nE2 && E3) begin case(B) 3'b000: nY = 8'b1111_1110; 3'b001: nY = 8'b1111_1101; 3'b010: nY = 8'b1111_1011; 3'b011: nY = 8'b1111_0111; 3'b100: nY = 8'b1110_1111; 3'b101: nY = 8'b1101_1111; 3'b110: nY = 8'b1011_1111; 3'b111: nY = 8'b0111_1111; default:nY = 8'b1111_1111; endcase end

同步FIFO之VHDL描述

同步F I F O之V H D L描述(1)同步FIFO之VHDL描述同步FIFO的意思是说FIFO的读写时钟是同一个时钟，不同于异步FIFO，异步FIFO的读写时钟是完全异步的。同步FIFO的对外接口包括时钟，清零，读请求，写请求，数据输入总线，数据输出总线，空以及满信号。下面分别对同步FI FO的对外接口信号作一描述： 1．时钟，输入，用于同步FIFO的读和写，上升沿有效； 2．清零，输入，异步清零信号，低电平有效，该信号有效时，FIFO被清空； 3．写请求，输入，低电平有效，该信号有效时，表明外部电路请求向FIF O写入数据； 4．读请求，输入，低电平有效，该信号有效时，表明外部电路请求从FIF O中读取数据； 5．数据输入总线，输入，当写信号有效时，数据输入总线上的数据被写入到FIFO中； 6．数据输出总线，输出，当读信号有效时，数据从FIFO中被读出并放到数据输出总线上； 7．空，输出，高电平有效，当该信号有效时，表明FIFO中没有任何数据，全部为空； 8．满，输出，高电平有效，当该信号有效时，表明FIFO已经满了，没有空间可用来存贮数据。使用VHDL描述的FIFO将以上面的接口为基础，并且可以参数化配置FIFO的宽度和深度。先把对外接口描述出来吧。

------------------------------------- -- Designer : skycanny -- Date : 2007-1-29 -- Description : Synchronous FIFO created by VHDL library ieee; use sfifo is generic(width : positive depth : positive ); port ( clk : in std_logic; rst : in std_logic; wq : in std_logic; rq : in std_logic; data : in std_logic_vector(width - 1 downto 0); q : in std_logic_vector(width - 1 downto 0); empty : out std_logic; full : out std_logic ); end entity sfifo;

全数字锁相环的verilog源代码讲解

支持论坛发展帖出全数字锁相环的verilog源代码,仿真已通过 module dpll(reset,clk,signal_in,signal_out,syn; parameter para_K=4; parameter para_N=16; input reset; input clk; input signal_in; output signal_out; output syn; reg signal_out; reg dpout; reg delclk; reg addclk; reg add_del_clkout; reg [7:0]up_down_cnt; reg [2:0]cnt8; reg [8:0]cnt_N; reg syn; reg dpout_delay; reg [8:0]cnt_dpout_high; reg [8:0]cnt_dpout_low; /******phase detector*****/ always@(signal_in or signal_out begin dpout<=signal_in^signal_out; end /******synchronization establish detector*****/ always@(posedge clk or negedge reset begin if(!reset dpout_delay<='b0; else dpout_delay<=dpout; end always@(posedge clk or negedge reset begin if(!reset begin cnt_dpout_high<='b0; cnt_dpout_low<='b0; end else if(dpout if(dpout_delay==0 cnt_dpout_high<='b0; else if(cnt_dpout_high==8'b11111111 cnt_dpout_high<='b0; else cnt_dpout_high<=cnt_dpout_high+1; else if(!dpout if(dpout_delay==1 cnt_dpout_low<='b0; else if(cnt_dpout_low==8'b11111111 cnt_dpout_low<='b0; else cnt_dpout_low<=cnt_dpout_low+1; end always@(posedge clk or negedge reset begin if(!reset syn<='b0; else if((dpout&&!dpout_delay||(!dpout&&dpout_delay if(cnt_dpout_high[8:0]-cnt_dpout_low[8:0]<=4||cnt_dpout_low[8:0]- cnt_dpout_high[8:0]<=4 syn<='b1; else syn<='b0; end /****up down couter with mod=K****/ always@(posedge clk or negedge reset begin if(!reset begin delclk<='b0; addclk<='b0; up_down_cnt<='b00000000; end else begin if(!dpout begin delclk<='b0; if(up_down_cnt==para_K-1 begin up_down_cnt<='b00000000; addclk<='b0; end else begin up_down_cnt<=up_down_cnt+1; addclk<='b0; end end else begin addclk<='b0; if(up_down_cnt=='b0 begin up_down_cnt<=para_K-1; delclk<='b0; end else if(up_down_cnt==1 begin delclk<='b1; up_down_cnt<=up_down_cnt-1; end else up_down_cnt<=up_down_cnt-1; end end end /******add and delete clk*****/ always@(posedge clk or negedge reset begin if(!reset begin cnt8<='b000; end else begin if(cnt8=='b111 begin cnt8<='b000; end else if(addclk&&!syn begin cnt8<=cnt8+2; end else if(delclk&&!syn

异步fifo设计及时序约束设置

一、前言跨时钟域的同步处理，使用异步FIFO是常用的方式之一，对于异步FIFO的设计，网上的大部分资料来源于《Simulation and Synthesis Techniques for Asynchronous FIFO Design》一文其异步FIFO的结构如下图所示本文不是介绍上图描述的设计。我从基本的数字电路时序开始，介绍异步FIFO的相关问题。最后介绍如何用时序约束保证设计的正确性二、数字电路时序对于数字电路来讲，我们的信号在时钟边沿发生变化，Dat1信号是一种理想情况，而Dat2是实际情况，其特点是一、相对时钟边沿有延时二、信号变化有一段时间(电平转换时间)，在这段时间就是亚稳态在亚稳态期间进行数据采样，不能获得稳定的值。数字电路中经过时序约束，在T1产生的信号，在T2一定稳定(否则就是不满足时序)，所以对于只有一个时钟的数字电路来说，它在T1和T2都能获得稳定的信号(T1时刻的值为0、T2时刻的值为1)

三、跨时钟域时序问题对于异步时钟而言(相位不同)，对于CLK1产生的信号，CLK2有可能在任意时刻进行数据采样在FIFO的设计中，将会产生2种信号，一种是数据本身(用Data表示)，另外一种是指示数据是否有效(用valid表示)，注意(valid不一定是一个比特的寄存器，可以是由FIFO中的读写指针产生而来，例如fifo的full或empty状态) 异步FIFO的问题在于，如果CLK2在时钟T2进行采样，那么有可能得到valid有效，而数据无效的情况。这样在CLK2采样取得的设计就是错误的数据。四、处理异步FIFO的valid和data（理论基础）我们假设valid为低电平表示没有数据，高电平为有数据，解决的办法就是，当CLK对valid进行采样时，即使valid处于亚稳态期间，数据信号也是稳定的如上图所以，在T1时刻进行上升沿采样，虽然valid是一个亚稳态状态，但是此时Data 是一个稳定的值，如果在T1时刻采样的valid为1，那么可以得到稳定的Data信号，如果在T1时刻采样的valid为0，那么控制逻辑认为在T1无法获得数据，从而在下一个时钟获取注意：T2时刻是在下降沿进行采样，而此时的Data信号也是稳定的

【CPLD Verilog】CPLD实现同步FIFO

CPLD实现同步FIFO 1 实现原理 CPLD实现8个字节的同步FIFO，实现8个字节数据的缓存。CPLD内部模块逻辑框图如下所示。 Data_a_we_pulse写数据到FIFO的使能信号。 Data_a_rd_pulse从FIFO读取数据的使能信号。 Data_a_in和Data_a_out分别表示写入FIFO和从FIFO读出的数据的值。 Data_a_we_full指示FIFO写满的状态。 Data_a_rd_nop指示FIFO读空的状态。 2 CPLD代码 module fifo_8B ( clk, reset_n, data_a_in, data_a_we_pulse,

data_a_we_full, data_a_out, data_a_rd_pulse, data_a_rd_nop ); input clk; input reset_n; input [7:0] data_a_in; input data_a_we_pulse; output data_a_we_full; output [7:0] data_a_out; input data_a_rd_pulse; output data_a_rd_nop; //////////////////////////FIFO 写入数据逻辑//////////////////////////// reg [7:0] fifo_mem [7:0]; //FIFO空间，8个8bit的空间 reg [2:0] fifo_we_addr; //FIFO写地址寄存器 reg fifo_we_addr_reverse_pulse; //FIFO写地址翻转状态寄存器，用于指示写//地址是否从最大地址翻转回到最小地址 always@(posedge clk or negedge reset_n) begin if(reset_n == 1'b0)

verilog有限状态机实验报告(附源代码)

有限状态机实验报告一、实验目的 ●进一步学习时序逻辑电路 ●了解有限状态机的工作原理 ●学会使用“三段式”有限状态机设计电路 ●掌握按键去抖动、信号取边沿等处理技巧二、实验内容用三段式有限状态机实现序列检测功能电路 a)按从高位到低位逐位串行输入一个序列，输入用拨动开关实现。 b)每当检测到序列“1101”（不重叠）时，LED指示灯亮，否则灭，例如 i.输入：1 1 0 1 1 0 1 1 0 1 ii.输出：0 0 0 1 0 0 0 0 0 1 c)用八段数码管显示最后输入的四个数，每输入一个数，数码管变化一次 d)按键按下的瞬间将拨动开关状态锁存 i.注意防抖动（按键按下瞬间可能会有多次的电平跳变）三、实验结果 1.Rst_n为0时数码管显示0000，led灯不亮，rst_n拨为1，可以开始输入，将输入的开关拨到1，按下按钮，数码管示数变为0001，之后一次类推分别输入1， 0,1，按下按钮后，数码管为1101，LED灯亮，再输入1，LED灯灭，之后再输入0，1（即共输入1101101使1101重叠，第二次LED灯不亮），之后单独输入

1101，LED灯亮 2.仿真图像刚启动时使用rst_n 一段时间后其中Y代表输出，即控制led灯的信号，sel表示数码管的选择信号，seg表示数码管信号四、实验分析 1、实验基本结构

其中状态机部分使用三段式结构： 2、整体结构为：

建立一下模块： Anti_dither.v 输入按键信号和时钟信号，输出去除抖动的按键信号生成的脉冲信号op 这一模块实现思路是利用按钮按下时会持续10ms以上而上下抖动时接触时间不超过10ms来给向下接触的时间计时，达到上限时间才产生输出。 Num.v 输入op和序列输入信号A,时钟信号clk和复位信号，复位信号将num置零，否则若收到脉冲信号则将num左移一位并将输入存进最后一位。输出的num即为即将在数码管上显示的值 Scan.v 输入时钟信号，对其降频以产生1ms一次的扫描信号。 Trigger.v 这一模块即为状态机模块，按三段式书写。整个模块的输入为时钟信号，脉冲信号，序列输入变量，复位信号，输出LED灯控制信号Y。第一段是状态转换模块，为时序逻辑电路，功能是描述次态寄存器迁移到现态寄存器。即如果收到复位信号将现态置零，否则将上次得到的next_state赋给current_state。

FPGA异步fifo设计完整报告

目录一、技术规范 (3) 1、设计完成的功能： (3) 2、系统整体框图： (3) 3、I/O管脚的描述： (3) 4、验证和测试工具选择： (4) 5、说明关键模块： (4) 6、拟选用的FPGA类型： (4) 二、FIFO总体设计方案 (5) 系统功能描述： (5) 电路结构图： (5) 系统的总体输入输出设定 (6) 系统时序分析： (6) 关键模块设计分析： (7) 三、ＦＩＦＯ验证方案 (8) FIFO功能： (8) 1、概述： (8) 2、预确认： (8) 3、模块运行确认： (9) 4、系统运行确认： (9) 四、仿真激励代码 (10) 五、电路设计FIFO源代码 (11)

六、FPGA设计FIFO综合布局布线报告： (16) 综合引脚分配： (16) 电路布局布线： (16) 七、时序仿真报告 (17) 时序仿真波形： (17) 八、FIFO下载代码和引脚分布 (17) 系统输入输出引脚分布： (21) 九、心得体会 (21)

技术规范 1、设计完成的功能：本实验完成的是8位异步FIFO的设计，其中写时钟100MHz,读时钟为5MHz，其中RAM的深度为256。当写时钟脉冲上升沿到来时，判断写信号是有效，则写一个八位数据到RAM中；当读时钟脉冲上升沿到来时，判断读信号是有效，则从RAM中把一个八位数据读出来。当RAM中数据写满时产生一个满标志，不能再往RAM再写数据；当RAM中数据读空时产生一个满标志，不能再从RAM读出数据。 2、系统整体框图：

3、I/O管脚的描述：管脚名称方向H/L电平位宽功能描述 rst_n input 3.3V/01全局复位信号 rd_en input 3.3V/01读使能低有效 wr_en input 3.3V/01写使能低有效 rd_empty output 3.3V/01读空标志高有效wr_full output 3.3V/01写满标志高有效rd_data output 3.3V/08数据输出 wr_data input 3.3V/08数据写入 clk_100M input 3.3V/01写数据时钟 clk_5M input 3.3V/01读数据时钟 4、验证和测试工具选择： Modelsim SE6.1f进行前仿真和后仿。在软件QuartusII中进行综合。 5、说明关键模块：对控制输入的读写地址要进行设计，以便在写满或是读空只产生一个标志，以此来实现对FIFO的缓冲的控制。也就是读地址加1与写地址相等则为读空，产生读空标志；写地址加1与读地址相等则为读空，产生写满标志 6、拟选用的FPGA类型：ep1cq240c8n

Verilog的135个经典设计实例

【例3.1】4位全加器 module adder4(cout,sum,ina,inb,cin); output[3:0] sum; output cout; input[3:0] ina,inb; input cin; assign {cout,sum}=ina+inb+cin; endmodule 【例3.2】4位计数器 module count4(out,reset,clk); output[3:0] out; input reset,clk; reg[3:0] out; always @(posedge clk) begin if (reset) out<=0; //同步复位 else out<=out+1; //计数 end endmodule 【例3.3】4位全加器的仿真程序 `timescale 1ns/1ns `include "adder4.v" module adder_tp; //测试模块的名字 reg[3:0] a,b; //测试输入信号定义为reg型 reg cin; wire[3:0] sum; //测试输出信号定义为wire型 wire cout; integer i,j; adder4 adder(sum,cout,a,b,cin); //调用测试对象 always #5 cin=~cin; //设定cin的取值 initial begin a=0;b=0;cin=0; for(i=1;i<16;i=i+1) #10 a=i; //设定a的取值 end - 1 -

initial begin for(j=1;j<16;j=j+1) #10 b=j; //设定b的取值 end initial//定义结果显示格式 begin $monitor($time,,,"%d + %d + %b={%b,%d}",a,b,cin,cout,sum); #160 $finish; end endmodule 【例3.4】4位计数器的仿真程序 `timescale 1ns/1ns `include "count4.v" module coun4_tp; reg clk,reset; //测试输入信号定义为reg型 wire[3:0] out; //测试输出信号定义为wire型 parameter DELY=100; count4 mycount(out,reset,clk); //调用测试对象 always #(DELY/2) clk = ~clk; //产生时钟波形 initial begin//激励信号定义 clk =0; reset=0; #DELY reset=1; #DELY reset=0; #(DELY*20) $finish; end //定义结果显示格式 initial $monitor($time,,,"clk=%d reset=%d out=%d", clk, reset,out); endmodule 【例3.5】“与-或-非”门电路 module AOI(A,B,C,D,F); //模块名为AOI(端口列表A，B，C，D，F) input A,B,C,D; //模块的输入端口为A，B，C，D output F; //模块的输出端口为F - 2 -

verilog同步和异步FIFO,可直接仿真和综合

EDA/SOPC课程设计报告题目：同异步FIFO模块的设计与验证姓名： xxx 学号： 120260320 同组人： xxx 指导教师： xxx 成绩：

目录目录................................................................................................................................................... II 第1章课程设计的要求 . (1) 1.1 课程设计的目的 (1) 1.2 课程设计的条件 (1) 1.3 课程设计的要求 (1) 第2章课程设计的内容 (2) 2.1 设计思路 (2) 2.2 软件流程图 (3) 2.3 HDL代码阐述 (7) 2.4 ModelSim验证 (13) 第3章课程设计的心得 (21)

第1章课程设计的要求 1.1 课程设计的目的 ●掌握FIFO设计的基本原理与方法 ●培养Verilog语言模块化设计的思想意识 ●完成一个FIFO的设计与验证 ●掌握较大工程的基本开发技能 ●培养综合运用Modelsim工具进行硬件开发的能力 ●培养数字系统设计的基本能力 ●加强对课堂Verilog语言学习的理解与升华 1.2 课程设计的条件 ●设计条件ISE、Modelsim等开发软件的使用 1.3 课程设计的要求 ●设计要求1 设计同步FIFO并验证(包括仿真验证、FPGA验证) ●设计要求2 设计异步FIFO并验证（包括仿真验证、FPGA验证） ●设计要求3 采用Design Compiler完成其逻辑综合，评估其面积和时序 ●设计要求4 完成综合后的SDF反标仿真

VerilogHDL实例

本文档含有很多Verilog HDL例子：//与门 module zxhand2(c,a,b); input a,b; output c; assign c= a & b; endmodule //或门 module zxhor2(c,a,b); input a,b; output c; assign c= a | b; endmodule //非门 module zxhnot2(c,b); input b; output c; assign c=~ b; endmodule ////异或门 module zxhxro2(c,a,b); input b; output c; assign c=a ^ b; endmodule 两选一电路 module data_scan(d0,d1,sel,q); output q; input d0,d1,sel; wire t1,t2,t3; n1 zxhand2(t1,d0,sel); n2 zxhnot2 (t4,sel); n3 zxhand2(t2,d1,t4); n4 zxhor2(t3,t1,t2);

assign q=t1; endmodule verilog HDL实例（一）练习一．简单的组合逻辑设计目的: 掌握基本组合逻辑电路的实现方法。这是一个可综合的数据比较器，很容易看出它的功能是比较数据a与数据b，如果两个数据相同，则给出结果1，否则给出结果0。在Verilog HDL中，描述组合逻辑时常使用assign结构。注意 equal=(a==b)?1:0,这是一种在组合逻辑实现分支判断时常使用的格式。模块源代码： //--------------- compare.v ----------------- module compare(equal,a,b); input a,b; output equal; assign equal=(a==b)?1:0; //a等于b时，equal输出为1；a不等于b时， //equal输出为0。 endmodule 测试模块用于检测模块设计得正确与否，它给出模块的输入信号，观察模块的内部信号和输出信号，如果发现结果与预期的有所偏差，则要对设计模块进行修改。测试模块源代码： `timescale 1ns/1ns //定义时间单位。 module comparetest; reg a,b; wire equal; initial //initial常用于仿真时信号的给出。 begin a=0; b=0; #100 a=0; b=1; #100 a=1; b=1; #100 a=1; b=0; #100 $stop; //系统任务，暂停仿真以便观察仿真波形。 end compare compare1(.equal(equal),.a(a),.b(b)); //调用模块。 Endmodule

双口ram实现同步fifo(源代码)

module fifo_ram(fifo_reset,clk,r,w,read_data,write_data, full,empty,Fcounter); parameter data_width=8; parameter addr_width=9; input fifo_reset,clk,r,w; input[data_width-1:0] write_data; output[data_width-1:0] read_data ; output full,empty; output[addr_width-1:0] Fcounter; reg full,empty; wire[data_width-1:0] read_data ; reg[addr_width-1:0] Fcounter; reg[addr_width-1:0] write_addr; reg[addr_width-1:0] read_addr; wire r_allow=(r&&!empty); wire w_allow=(w&&!full); r_w_ram u1(.w_clk(clk), .r_clk(clk), .w_addr(write_addr), .r_addr(read_addr), .w_allow(w_allow), .r_allow(r_allow), .w_data(write_data), .r_data(read_data));//wire always@(posedge clk,posedge fifo_reset) begin if(fifo_reset) empty<='b1; else empty<=(!w&&(Fcounter[8:1]==0)&&((Fcounter[0]==0)||r)); end always@(posedge clk,posedge fifo_reset) begin if(fifo_reset)

第10章例题verilog源代码(夏宇闻版)

第十章例题 module add_4( X, Y, sum, C); input [3 : 0] X, Y; output [3: 0] sum; output C; assign {C, Sum } = X + Y; endmodule //而16位加法器只需要扩大位数即可，见下例： module add_16( X, Y, sum, C); input [15 : 0] X, Y; output [15 : 0] sum; output C; assign {C, Sum } = X + Y; endmodule 快速乘法器常采用网格形式的迭带阵列结构，图10.3示出两个四位二进制数相乘的结构图，//用Verilog HDL来描述乘法器是相当容易的，只需要把运算表达式写出就可以了，见下例。module mult_4( X, Y, Product); input [3 : 0] X, Y; output [7 : 0] Product; assign Product = X * Y; endmodule // 而8位乘法器只需要扩大位数即可，见下例： module mult_8( X, Y, Product); input [7 : 0] X, Y; output [15 : 0] Product; assign Product = X * Y; endmodule

// 下面就是一个位数可以由用户定义的比较电路模块： module compare_n ( X, Y, XGY, XSY, XEY); input [width-1:0] X, Y; output XGY, XSY, XEY; reg XGY, XSY, XEY; parameter width = 8; always @ ( X or Y ) // 每当X 或Y 变化时 begin if ( X = = Y ) XEY = 1; // 设置X 等于Y的信号为1 else XEY = 0; if (X > Y) XGY = 1; // 设置X 大于Y的信号为1 else XGY = 0; if (X < Y) XSY = 1; // 设置X 小于Y的信号为1 else XSY = 0; end endmodule //下面就是带使能控制信号（nCS）的数据位宽可以由用户定义的(8位)八路数据通道选择器模块： module Mux_8( addr,in1, in2, in3, in4, in5, in6, in7, in8, Mout, nCS); input [2:0] addr; input [width-1:0] in1, in2, in3, in4, in5, in6, in7, in8; input nCS; output [width-1:0] Mout; parameter width = 8; always @ (addr or in1 or in2 or in3 or in4 or in5 or in6 or in7 or in8 or nCS) begin if (!nCS) //nCS 低电平使多路选择器工作 case(addr) 3’b000: Mout = in1; 3’b001: Mout = in2; 3’b010: Mout = in3; 3’b011: Mout = in4;