数字逻辑设计基础

参考：

正点原子逻辑设计指南

状态机FSM

一、组合逻辑

组合逻辑：任意时刻的输出只取决于当前时刻的输入，与电路原来的状态无关。

逻辑级数指的是组合逻辑的深度，也就是从组合逻辑输入到输出需要穿过的组合逻辑单元个数。深度越大，组合逻辑越复杂，延迟越大。组合逻辑的逻辑级数不能太长，逻辑级数太长就会导致总的延迟太大。

组合逻辑中的竞争-冒险现象

竞争：信号经不同路径传输到某一汇合点输出的时间有先有后的现象。

冒险：由于竞争而引起电路输出发生瞬间错误的现象，表现为输出端出现了理论上没有的窄脉冲（毛刺）。

信号在器件中传输的时候，所需要的时间是不能精确估计的，在多路信号同时发生跳变的瞬间，组合逻辑的输出有先后顺序，就产生了“竞争冒险”。这时，往往会出现一些不正确的尖峰信号，这些尖峰信号就是“毛刺”。

• 竞争不一定会产生冒险，但有冒险一定有竞争。
• 毛刺并非对所有输入都有危害，只要毛刺不出现在时钟的上升沿，就不会对系统造成危害，而当毛刺成为系统的控制信号时就会出现逻辑错误。

如图，y信号最终会得到1个1ns的毛刺信号。

组合逻辑毛刺消除

1. 组合逻辑输出加寄存器：寄存器一般只在时钟跳变沿对输入信号敏感，所以对发生在非时钟跳变沿的毛刺信号，去除效果非常明显。

2. 信号延时同步法：在两级信号传递的过程中加一个延时环节，从而保证在下一个模块中读取到的数据是稳定后的数据。

3. 状态机控制：在数据传递比较复杂的多模块系统中，由状态机 在特定的时刻分别发出控制特定模块的时钟信号或者模块使能信号，状态机的循环控制就可以使得整个系统协调运作，同时减少毛刺信号。

4. 格雷码计数器：格雷码计数器的输出每次只有一位跳变，使用格雷码计数器将避免毛刺的出现。

二、时序逻辑

时序逻辑：任意时刻的输出不仅取决于当前时刻的输入，还取决于电路原来的状态。

时序逻辑由组合逻辑和存储逻辑构成，时序逻辑的存储电路一般由锁存器、触发器和寄存器构成。

锁存器

锁存器（latch）是电平触发的存储单元，数据存储的动作取决于输入时钟（或者使能）信号的电平值，即当锁存器处于使能状态时，输出才会随着数据输入发生变化。

锁存器在不锁存数据时，输出端的信号随输入信号变化，就像信号通过一 个缓存器一样；一旦锁存信号起锁存作用，则数据被锁住，输入信号不起作用。

D锁存器能够将单路数据D存入到锁存器的电路。控制信号C=0时，锁存器的输出端Q将维持原状态不变；控制信号C=1时，将单路数据D存入到锁存器中。

Qn 是指触发器当前逻辑状态也即触发前的状 态，Qn+1 是指触发后的状态。

当控制信号C为高电平时，输出信号Q将跟随输入信号D的变化而变化；当控制信号C从高电平变为低电平时，输入信号D的状态将会决定锁存器将要锁存的状态。

在设计中要避免产生锁存器，锁存器的危害在于不能过滤毛刺以及由于没有时钟信号，无法对该器件进行时序分析。

代码出现latch的主要原因：不带时钟的always中的if或case语句不完整。

触发器

触发器是对脉冲边沿敏感的存储单元电路，它只在触发脉冲的上升沿（或下降沿）瞬间改变其状态。

一般使用最多的是D触发器，该电路是由两个相同的 D 锁存器以及两个非门连接而成的。
设输入信号D=1，CLK=0时，F1选通，F2锁存，Q1为1，Q不变，即前半段输入信号先存入主锁存器；
CLK=1时，F1锁存，F2选通，Q1保持为1，Q=Q1，即后半段将锁存的数据赋值给从锁存器的输出。
这样在CLK信号由 0 变为 1 这样的一个变化周期内，触发器的输出状态只可能改变一次。

寄存器

寄存器是多个触发器构成的，可以存储多bit’二进制数据。

触发器并联：

触发器串联（打拍）：

计数器

计数器由寄存器和加法器组成，可以实现计时、分频等。


计数器最低 bit 的 y[0]是每2个周期在循环跳变，而计数器次低 bit的y[1]是每4个周期在循环跳变，计数器最高 bit 的 y[2]是每 8 个周期在循环跳变，若直接把计数器的各个 bit 赋值给一个时钟信号，那么计数器的 y[0]实现的是2分频，计数器的y[1]实现的是4分频，计数器的y[2]实现的是8分频。这个也是最简单和最常用的偶数分频方法。

三、边沿检测电路

边沿检测：检测一个信号的跳变沿，给出一个指示。
检测上升沿：y1 = a & ( ~a_dly1 )
检测下降沿：y2 = ~a & a_dly1
检测双沿：y3 = a ^ a_dly1

四、格雷码转换电路

格雷码：相邻两个数间只有一个数据位发生变化，格雷码适用于 FIFO 的地址处理。

设n 位的二进制：Bn, Bn-1, Bn-2。。。B2, B1 , B0;
n 位的格雷码：Gn, Gn-1, Gn-2。。。G2, G1, G0;

则格雷码转二进制：

Bn =Gn；
Bi-1 = Bi  ^  Gi-1；( i=0,1,2,n-1; )

always @(*) beginbin_out[3] = gray_in[3]; bin_out[2] = gray_in[2]^bin_out[3];bin_out[1] = gray_in[1]^bin_out[2];bin_out[0] = gray_in[0]^bin_out[1];
end

二进制转格雷码：

Gn = Bn；
Gi-1=Bi ^ Bi-1； ( i=0,1,2,n-1; )

assign gray_out = (bin_in >> 1) ^ bin_in;

五、复位电路

复位：将寄存器恢复到默认值。

FPGA内部会有上电复位（POR）电路，FPGA 芯片内部有一个上电检测模块，一旦检测到电源电压超过检测门限后，就产生一个上电复位脉冲(Power On Reset)送给所有的寄存器，这个脉冲会自动作用在各个寄存器的复位端，和功能复位管脚共同控制寄存器的复位。

FPGA重新配置之后也会上电复位。

数字逻辑需要复位的原因

数字电路中寄存器和 RAM 在上电之后默认的状态和数据是不确定的，复位可以把寄存器置到初始状态0。而且如果逻辑进入了错误的状态，通过复位可以把所有的逻辑状态恢复到初始值，否则可能永远运行在错误的状态。

同步复位

同步复位指的是当时钟上升沿检测到复位信号，执行复位操作，有效的时钟沿是前提。

always @ (posedge clk) beginif (rst_n == 1'b0)y <= 1'b0 ;else y <= b ;end

同步复位的优点：

a、有利于仿真器的仿真；
b、可以使所设计的系统成为 100%的同步时序电路，有利于时序分析，而且可综合出较高的 Fmax；
c、由于只在时钟有效电平到来时才有效，所以可以滤除高于时钟频率的复位毛刺。

同步复位的缺点：

a、复位信号的有效时长必须大于时钟周期，才能真正被系统识别并完成复位任务。同时还要考虑诸如时钟偏移、组合逻辑路径延时、复位延时等因素（所以复位信号有时需要脉冲展宽，用以保证时钟有效期间有足够的复位宽度）；
b、由于大多数的逻辑器件的目标库内的 DFF 都只有异步复位端口，所以，倘若采用同步复位的话，综合器就会在寄存器的数据输入端口插入组合逻辑，这样就会一方面额外增加 FPGA 内部的逻辑资源，另一方面也增加了相应的组合逻辑门时延。

异步复位

异步复位指的是无论时钟沿是否到来，只要复位信号有效，就对系统进行复位。

always @ (posedge clk or negedge rst_n) beginif (rst_n == 1'b0)y <= 1'b0 ;else y <= b ;end

异步复位的优点：

a、大多数目标器件库的 DFF 都有异步复位端口，那么该触发器的复位端口就不需要额外的组合逻辑，这样就可以节省资源；
b、设计相对简单；
c、异步复位信号产生和响应都很方便（电路在任何情况下都能复位而不管是否有时钟出现）。

异步复位的缺点：

a、问题出现在复位释放时，而不是有效时，如果复位释放接近时钟有效沿，则触发器的输出可能进入亚稳态（此时 clk 检测到的 rst_n 的状态就会是一个亚稳态，即是0是1是不确定的），从而导致复位失败。
b、可能因为噪声或者毛刺造成虚假复位信号（比如系统正常工作时突然复位）

注意：时钟端口、清零和置位端口对毛刺信号十分敏感，任何一点毛刺都可能会使系统出错。

c、静态定时分析困难，静态时序分析一般是针对同步设计的，都是基于时钟周期来分析时序的。

异步复位、同步释放

推荐使用异步复位、同步释放，既解决了异步复位的亚稳态问题，又解决了同步复位的资源消耗问题。

异步复位同步释放就是在复位信号到来时不受时钟信号同步，而在复位信号释放时受时钟信号同步。

//产生复位rst_sync_n 
always @ (posedge clk or negedge rst_async_n) beginif (!rst_async_n) begin rst_s1 <= 1'b0; rst_s2 <= 1'b0; end else begin rst_s1 <= 1'b1; rst_s2 <= rst_s1; //需要额外等1个周期稳定end end//输出的复位信号后续可以直接用来异步复位assign rst_sync_n = rst_s2; //使用复位rst_sync_n always @ (posedge clk or negedge rst_sync_n ) beginif (rst_sync_n == 1'b0)y <= 1'b0 ;else y <= b ;end

六、状态机

写法

一段式：整个状态机写到一个 always 模块里面，在该模块中既描述状态转移，又描述状态的输入和输出。

module top_module(input clk,input areset,    // Asynchronous reset to state Binput in,output reg out);//  parameter A=1'b0, B=1'b1; reg state;always@(posedge clk or posedge areset)beginif(areset)beginstate <= B;out <= 1'b1;endelse begincase(state)B:beginif(in == 1'b1)beginstate <= B;out <= 1'b1;endelse beginstate <= A;out <= 1'b0;endendA:beginif(in == 1'b1)beginstate <= A;out <= 1'b0;endelse beginstate <= B;out <= 1'b1;endenddefault:beginstate <= B;out <= 1'b1;endendcaseendendendmodule

二段式：用两个 always 模块来描述状态机，其中一个 always 模块采用同步时序描述状态转移；另一个模块采用组合逻辑判断状态转移条件，描述状态转移规律以及输出。

module top_module(input clk,input areset,    // Asynchronous reset to state Binput in,output reg out);//  parameter A=1'b0, B=1'b1; reg current_state, next_state;always@(posedge clk or posedge areset)beginif(areset)begincurrent_state <= B;endelse begincurrent_state <= next_state;endendalways@(*)begincase(current_state)B:beginif(in == 1'b1)beginnext_state = B;endelse beginnext_state = A;endout = 1'b1;endA:beginout = 1'b0;if(in == 1'b1)beginnext_state = A;endelse beginnext_state = B;endout = 1'b0;endendcaseendendmodule

三段式：在两个 always 模块描述方法基础上，使用三个 always 模块，一个 always 模块采用同步时序描述状态转移，一个 always 采用组合逻辑判断状态转移条件，描述状态转移规律，另一个 always 模块描述状态输出(可以用组合电路输出，也可以时序电路输出，最好用时序电路)。

module top_module(input clk,input areset,    // Asynchronous reset to state Binput in,output reg out);//  parameter A=1'b0, B=1'b1; reg current_state, next_state;always@(posedge clk or posedge areset)beginif(areset)begincurrent_state <= B;endelse begincurrent_state <= next_state;endendalways@(*)begincase(current_state)B:beginif(in == 1'b1)beginnext_state = B;endelse beginnext_state = A;endendA:beginif(in == 1'b1)beginnext_state = A;endelse beginnext_state = B;endendendcaseendalways@(posedge clk or posedge areset)beginif(areset)beginout <= 1'b1;endelse if(next_state == B)beginout <= 1'b1;endelse beginout <= 1'b0;endendendmodule

分类

Mealy 状态机：组合逻辑的输出不仅取决于当前状态，还取决于输入状态。

Mealy型状态机第三段输出采用cur_state。

//==================================================================
//--    3段式状态机（Mealy）
//==================================================================//------------<模块及端口声明>----------------------------------------
module FSM_Mealy_3(input 		sys_clk		,			//输入系统时钟、50Minput 		sys_rst_n	,   		//复位信号、低电平有效input 		money		,   		//投币输入，高电平有效output reg	cola            		//可乐输出，高电平有效
);//------------<状态机参数定义>------------------------------------------
localparam	IDLE  = 3'b0001,ONE   = 3'b0010,TWO   = 3'b0100;//------------<reg定义>-------------------------------------------------
reg	[3:0]	cur_state;					//定义现态寄存器
reg	[3:0]	next_state;					//定义次态寄存器
//-----------------------------------------------------------------------
//--状态机第一段：同步时序描述状态转移
//-----------------------------------------------------------------------
always@(posedge sys_clk or negedge sys_rst_n)beginif(!sys_rst_n)cur_state <= IDLE;				//复位初始状态elsecur_state <= next_state;		//次态转移到现态
end
//-----------------------------------------------------------------------
//--状态机第二段：组合逻辑判断状态转移条件，描述状态转移规律以及输出
//-----------------------------------------------------------------------
always@(*)begincase(cur_state)						//组合逻辑//根据当前状态、输入进行状态转换判断										IDLE:begin				if(money)					next_state = ONE;		//投币1元，则状态转移到ONEelse next_state = IDLE;		//没有投币，则状态保持	end					ONE:begin				if(money)next_state = TWO;		//投币1元，则状态转移到TWOelse next_state = ONE;		//没有投币，则状态保持endTWO:begin				if(money)next_state = IDLE;		//投币1元，则状态转移到IDLEelse                        next_state = TWO;       //没有投币，则状态保持end	default:begin					//默认状态同IDLEif(money)next_state = ONE;else next_state = IDLE;	endendcase
end
//-----------------------------------------------------------------------
//--状态机第三段：时序逻辑描述输出
//-----------------------------------------------------------------------
always@(posedge sys_clk or negedge sys_rst_n)beginif(!sys_rst_n)cola <= 1'b0;					//复位、初始状态 elsecase(cur_state)					//根据当前状态进行输出IDLE:	cola <= 1'b0;		//无可乐输出(因为输入不管是0、1都是输出0，所以省略写法)			ONE:	cola <= 1'b0;		//无可乐输出(因为输入不管是0、1都是输出0，所以省略写法)	TWO:begin					if(money)cola <= 1'b1;		//如果输入1，则输出可乐elsecola <= 1'b0;		//如果输入0，则无可乐输出enddefault:cola <= 1'b0;		//默认无可乐输出endcase
end
endmodule

Moore 状态机：组合逻辑的输出只取决于当前状态。
Moore型状态机第三段采用cur_state或next_state都可以，区别在于基于next_state输出是立刻变化的，基于cur_state输出会延迟一个周期。

• Mealy状态机比Moore状态机的状态个数要少；
• Mealy状态机比Moore状态机的输出要早一个时钟周期；

//==================================================================
//--    3段式状态机（Moore）
//==================================================================//------------<模块及端口声明>----------------------------------------
module FSM_Moore_3(input 		sys_clk		,			//输入系统时钟、50Minput 		sys_rst_n	,   		//复位信号、低电平有效input 		money		,   		//投币输入，高电平有效output reg	cola            		//可乐输出，高电平有效
);//------------<状态机参数定义>------------------------------------------
localparam	IDLE  = 4'b0001,ONE   = 4'b0010,TWO   = 4'b0100,THREE = 4'b1000;//------------<reg定义>-------------------------------------------------
reg	[3:0]	cur_state;					//定义现态寄存器
reg	[3:0]	next_state;					//定义次态寄存器//-----------------------------------------------------------------------
//--状态机第一段：同步时序描述状态转移
//-----------------------------------------------------------------------
always@(posedge sys_clk or negedge sys_rst_n)beginif(!sys_rst_n)cur_state <= IDLE;				//复位初始状态elsecur_state <= next_state;		//次态转移到现态
end//-----------------------------------------------------------------------
//--状态机第二段：组合逻辑判断状态转移条件，描述状态转移规律以及输出
//-----------------------------------------------------------------------
always@(*)begincase(cur_state)						//组合逻辑//根据当前状态、输入进行状态转换判断										IDLE:begin				if(money)					next_state = ONE;		//投币1元，则状态转移到ONEelse next_state = IDLE;		//没有投币，则状态保持	end					ONE:begin				if(money)next_state = TWO;		//投币1元，则状态转移到TWOelse next_state = ONE;		//没有投币，则状态保持endTWO:begin				if(money)next_state = THREE;		//投币1元，则状态转移到THREEelse                        next_state = TWO;       //没有投币，则状态保持end	THREE:begin				if(money)next_state = ONE;		//投币1元，则状态转移到ONEelse                        next_state = IDLE;      //没有投币，则状态保持enddefault:begin					//默认状态同IDLEif(money)next_state = ONE;else next_state = IDLE;	endendcase
end//-----------------------------------------------------------------------
//--状态机第三段：时序逻辑描述输出
//-----------------------------------------------------------------------
always@(posedge sys_clk or negedge sys_rst_n)beginif(!sys_rst_n)cola <= 1'b0;					//复位、初始状态 elsecase(next_state)					//根据当前状态进行输出IDLE:	cola <= 1'b0;		//无可乐输出			ONE:	cola <= 1'b0;		//无可乐输出TWO:	cola <= 1'b0;		//无可乐输出THREE:	cola <= 1'b1;		//输出可乐default:cola <= 1'b0;		//默认无可乐输出endcase
endendmodule

七、偶数分频电路

计数翻转法：计数到 N/2-1，然后时钟翻转、计数器清零，如此循环就可以得到 N（偶）分频。

module divide_2 
( input clk , // system clock 50Mhz on boardinput rst_n, // system rst, low active output reg out_clk // output signal
);parameter N = 4 ;reg [N/2-1:0] cnt ;//===============================================================// ------------------------- MAIN CODE -------------------------//===============================================================always @ (posedge clk or negedge rst_n) beginif(!rst_n) begincnt <= 0;out_clk <= 0;endelse beginif(cnt==N/2-1) beginout_clk <= ~out_clk;cnt <= 0;endelsecnt <= cnt + 1;endendendmodule

计数器法：利用计数器各位周期变换的特性进行分频。

module CNT ( input clk , // system clock 50Mhz on boardinput rst_n, // system rst, low active output reg [2:0] y // output signal);
//y[0]二分频
//y{1}四分频
always @ (posedge clk or negedge rst_n) beginif (rst_n == 1'b0)y <= 3'b0 ;elsey <= y + 1'b1 ;endendmodule

八、奇数分频电路

设计思路：分别在时钟的上升沿和下降沿计数进行周期扩展，得到clk1、clk2。二者相位相差半个周期，相或即可得到占空比50%的奇数分频时钟。

module odd_div(input clk,input rstn,output out_clk);parameter N = 5;reg [N/2:0] cnt1;
reg [N/2:0] cnt2;reg out_clk1;
reg out_clk2;
//周期扩展
always@(posedge clk or negedge rstn)beginif(!rstn)beginout_clk1<='d0;cnt1<=1;endelse beginif(out_clk1==0)beginif(cnt1==N/2+1)begincnt1<=1;out_clk1<=~out_clk1;endelse begincnt1<=cnt1+1'b1;endendelse beginif(cnt1==N/2)begincnt1<=1;out_clk1<=~out_clk1;endelse begincnt1<=cnt1+1'b1;endendend
endalways@(negedge clk or negedge rstn)beginif(!rstn)beginout_clk2<='d0;cnt2<=1;endelse beginif(out_clk2==0)beginif(cnt2==N/2+1)begincnt2<=1;out_clk2<=~out_clk2;endelse begincnt2<=cnt2+1'b1;endendelse beginif(cnt2==N/2)begincnt2<=1;out_clk2<=~out_clk2;endelse begincnt2<=cnt2+1'b1;endendend
end
//改变占空比
assign out_clk=out_clk1|out_clk2;
endmodule

九、RAM读写设计

半导体存储器包括随机存储器（RAM）和只读存储器（ROM），RAM包括静态RAM和动态RAM。

动态 RAM 包括 SDRAM，DDR SDRAM，DDR2 SDRAM，DDR3 SDRAM 以及 DDR4 SDRAM 等。

静态RAM一般包括单端口RAM、伪双口RAM、真双口RAM。

ROM包括PROM、EPROM、EEPROM等。

FIFO和RAM的区别：
结构：FIFO是先入先出，没有地址线，不能对存储单元寻址；RAM端口都有地址线，可以对存储单元寻址。
应用：FIFO 一般放在传输带宽不一致的地方，用来吸收流量突发；RAM一般用在需 要根据地址进行写或者读的地方，存储一些信息。

单端口RAM

单端口RAM：只有一个读写口，读写都是通过该口访问RAM。

总使能信号ENA：ENA 为 1 且 WEA 为 1 表示写有效，ENA 为 1 且 WEA 为 0 表示读有效

//单端口RAM结构
module sp_ram(input               clk ,input               en  ,input               wen ,input       [7:0]   din ,input       [4:0]   addr,output reg  [7:0]    dout);reg [7:0] ram [31:0]; 
//写
always@(posedge clk)beginif(en && wen)beginram[addr]<=din;end
end
//读
always@(posedge clk)beginif(en && !wen)begindout<=ram[addr];endelse begindout<=8'hx;end
end
endmodule

//单端口RAM读写
module sp_ram_rw(input clk,input rstn   );wire en;
wire wren;
wire rden;
wire [7:0] ram_rd_data;
reg [4:0] ram_addr;
reg [7:0] ram_wr_data;
reg [5:0] rw_cnt;//RAM使能信号
assign wren=(rw_cnt>=0 && rw_cnt<=31) ? 1'b1:1'b0;
assign rden=(rw_cnt>=32 && rw_cnt<=63) ? 1'b1:1'b0;assign en= wren | rden;//读写控制计数
always@(posedge clk or negedge rstn)beginif(!rstn)beginrw_cnt<='d0;endelse if(rw_cnt==6'd63)beginrw_cnt<='d0;          endelse beginrw_cnt<=rw_cnt+1'b1;end
end
//RAM地址信号
always@(posedge clk or negedge rstn)beginif(!rstn)beginram_addr<='d0;endelse if(ram_addr == 5'd31)beginram_addr<='d0;endelse beginram_addr<=ram_addr+1'b1;end
end
//RAM数据信号
always@(posedge clk or negedge rstn)beginif(!rstn)beginram_wr_data<='d0;endelse if(rw_cnt>=0 && rw_cnt<=31)beginram_wr_data<=ram_wr_data+1'b1;endelse beginram_wr_data<=8'd0;end
end
sp_ram sp_ram_u(. clk (clk),. en  (en),. wen (wren),. din (ram_wr_data),. addr(ram_addr),. dout(ram_rd_data));
endmodule

伪双口RAM

伪双口RAM：一个端口只能读，一个端口只能写，读写可以同时访问。

读写同时有效且读写同一地址时，会产生读写冲突，此时很可能读出的数据是无效的。

冲突处理：判断冲突，然后将写数据寄存1拍赋值给读数据。

always @ (posedge clk or negedge rst_n) beginif (rst_n == 1'b0)conflict <= 1'b0 ;else if ( wen && ren && (waddr == raddr ))conflict <= 1'b1 ;elseconflict <= 1'b0 ;endassign dout = conflict ? din_dly1 : q ;

//伪双口RAM结构
module tp_ram ( input clocka , //ram clk input clockb , //ram clk input wren , //ram 写使能 input rden , //ram 读使能 input [4:0] wr_address , //ram 写地址 input [4:0] rd_address , //ram 写地址 input [7:0] data , //ram 写数据 output reg [7:0] q //ram 读数据 ); //reg define reg [7:0] ram [31:0] ; //ram 数据 //***************************************************** //** main code //***************************************************** always @(posedge clocka ) begin if(wren)  ram[wr_address] <= data; end always @(posedge clockb ) begin if(rden) q <= ram[rd_address]; else q <= 8'hx ; end endmodule

//伪双口RAM读写
module tp_ram_rw( input clk , //时钟信号 input rst_n //复位信号，低电平有效 
); //wire define 
wire ram_wr_en ; //ram 写使能 
wire ram_rd_en ; //ram 读使能 
wire [7:0] ram_rd_data ; //ram 读数据 wire [4:0] ram_waddr ; //ram 写地址 wire [4:0] ram_raddr ; //ram 读地址 //reg define reg [5:0] rw_cnt ; //读写控制计数器 reg [7:0] ram_wr_data; //ram 写数据 //***************************************************** //** main code //***************************************************** //rw_cnt 计数范围在 0~31,ram_wr_en 为高电平;32~63 时,ram_wr_en 为低电平 assign ram_wr_en = ((rw_cnt >= 6'd0) && (rw_cnt <= 6'd31)) ? 1'b1 : 1'b0; //rw_cnt 计数范围在 1~32,ram_rd_en 为高电平;其他值时,ram_rd_en 为低电平 assign ram_rd_en = ((rw_cnt >= 6'd1) && (rw_cnt <= 6'd32)) ? 1'b1 : 1'b0; //读写控制计数器,计数器范围 0~63 always @(posedge clk or negedge rst_n) begin if(rst_n == 1'b0) rw_cnt <= 6'd0; else if(rw_cnt == 6'd63) rw_cnt <= 6'd0; else rw_cnt <= rw_cnt + 6'd1; end //读写地址产生 assign ram_waddr = rw_cnt[4:0] ; assign ram_raddr = rw_cnt[4:0] - 5'd1 ;  tp_ram u_tp_ram ( 
.wr_address (ram_waddr), 
.rd_address (ram_raddr), 
.clocka (clk ), 
.clockb (clk ), 
.data (ram_wr_data), 
.rden (ram_rd_en), 
.wren (ram_wr_en), 
.q (ram_rd_data) 
); endmodule 

真双口RAM

真双口RAM：有两个独立的读写口，每个端口都可以独立地发起读或者写。

读写冲突处理：

1. 允许两个端口同时读；
2. 两个端口读写同一地址时，把最新的写数据寄存1拍赋值给读数据；
3. 两个端口向同一地址写时，把两个写端口的数据经处理后通过一个写端口写入，另一个写端口关断处理；

//真双口RAM结构
module dp_ram(input               clocka      ,input               clockb      ,input               wren_a      ,input               rden_a      ,input               wren_b      ,input               rden_b      ,input       [4:0]   address_a   ,input       [4:0]   address_b   ,input       [7:0]   data_a      ,input       [7:0]   data_b      ,output reg [7:0]    q_a         ,output reg [7:0]    q_b);
reg [7:0] ram [31:0] ; //ram 数据always@(posedge clocka)beginif(wren_a)ram[address_a]<=data_a;if(wren_b)ram[address_b]<=data_b;
endalways@(posedge clocka)beginif(rden_a)beginq_a<=ram[address_a];endelse beginq_a<=8'hx;end
endalways@(posedge clocka)beginif(rden_b)beginq_b<=ram[address_b];endelse beginq_b<=8'hx;end
endendmodule

//真双口RAM读写
module dp_ram_rw(input clk,input rst_n);wire ram_wr_en ; //ram 写使能 
wire ram_rd_en ; //ram 读使能 
wire [7:0] ram_rd_data_a ; //ram 读数据 
wire [7:0] ram_rd_data_b ; //ram 读数据 wire [4:0] ram_waddr ; //ram 写地址 
wire [4:0] ram_raddr ; //ram 读地址 
wire [7:0] ram_wr_data; //ram 写数据 wire [4:0] address_a ; //ram 地址 a 
wire [4:0] address_b ; //ram 地址 b wire rden_a ; //ram 读使能 
wire rden_b ; //ram 读使能 wire wren_a ; //ram 写使能 
wire wren_b ; //ram 写使能 wire [7:0] data_a ; //ram 写数据 
wire [7:0] data_b ; //ram 写数据 //reg define 
reg [5:0] rw_cnt ; //读写控制计数器 reg [4:0] ram_addr ; //ram 读写地址 
reg flag ; //读写切换 flag//rw_cnt 计数范围在 0~31,ram_wr_en 为高电平;32~63 时,ram_wr_en 为低电平 
assign ram_wr_en = ((rw_cnt >= 6'd0) && (rw_cnt <= 6'd31)) ? 1'b1 : 1'b0; 
//rw_cnt 计数范围在 1~32,ram_rd_en 为高电平;其他值时,ram_rd_en 为低电平 
assign ram_rd_en = ((rw_cnt >= 6'd1) && (rw_cnt <= 6'd32)) ? 1'b1 : 1'b0; //写数据产生 
assign ram_wr_data = rw_cnt[4:0] ; //读写地址产生 
assign ram_waddr = rw_cnt[4:0] ; 
assign ram_raddr = rw_cnt[4:0] - 5'd1 ; // A 端口的控制 
assign address_a = flag ? ram_waddr : ram_raddr ; 
assign data_a = flag ? ram_wr_data : 8'd0 ; 
assign rden_a = flag ? 1'b0 : ram_rd_en ; 
assign wren_a = flag ? ram_wr_en : 1'b0 ; // B 端口的控制 
assign address_b = flag ? ram_raddr : ram_waddr ; 
assign data_b = flag ? 8'd0 : ram_wr_data ; 
assign rden_b = flag ? ram_rd_en : 1'b0 ; 
assign wren_b = flag ? 1'b0 : ram_wr_en ; 
//读写控制计数
always@(posedge clk or negedge rst_n)beginif(!rst_n)beginrw_cnt<='d0; endelse if(rw_cnt==63)beginrw_cnt<='d0;endelse beginrw_cnt<=rw_cnt+1'b1;end
end
//端口读写切换
always@(posedge clk or negedge rst_n)beginif(!rst_n)beginflag<=1'd0;endelse if(rw_cnt==63)beginflag<=~flag;end
enddp_ram dp_ram_u(.clocka     (clk) ,.clockb     (clk) ,.wren_a     (wren_a) ,.rden_a     (rden_a) ,.wren_b     (wren_b) ,.rden_b     (rden_b) ,.address_a  (address_a) ,.address_b  (address_b) ,.data_a     (data_a) ,.data_b     (data_b) ,.q_a        (ram_rd_data_a) ,.q_b        (ram_rd_data_b));
endmodule

十、FIFO

同步FIFO
异步FIFO

十一、异步电路设计

跨时钟域处理

十二、位宽转换电路

整数倍位宽转换

窄到宽

设计思路：根据输入和输出位宽的比值对输入数据的有效信号进行计数，然后得到输出数据的有效信号和输出数据。

module width_change_8to32(input clk,input rst_n,input [7:0] a,input a_vld,output reg [31:0] b,output reg b_vld);reg [2:0] vld_cnt;
reg [7:0] a_r [2:0];
always@(posedge clk or negedge rst_n)beginif(!rst_n)beginvld_cnt<='d0;endelse if(a_vld)beginif(vld_cnt==3'd3)beginvld_cnt<=3'd0;endelse beginvld_cnt<=vld_cnt+1'b1;endend
endalways@(posedge clk or negedge rst_n)beginif(!rst_n)beginb_vld<='d0;endelse if(a_vld && vld_cnt==3'd3)beginb_vld<=1'b1;endelse beginb_vld<=1'b0;end
endalways@(posedge clk or negedge rst_n)beginif(!rst_n)begina_r[0]<='d0;a_r[1]<='d0;a_r[2]<='d0;endelse if(a_vld)begina_r[0]<=a;a_r[1]<=a_r[0];a_r[2]<=a_r[1];       end
endalways@(posedge clk or negedge rst_n)beginif(!rst_n)beginb<='d0;endelse if(a_vld && vld_cnt==3'd3)beginb<={a_r[2],a_r[1],a_r[0],a};end
end
endmodule

宽到窄

设计思路：将输入数据的各段寄存，然后用计数器控制顺序输出。

module width_change_32to8(input clk,input rst_n,input [31:0] a,input a_vld,output reg [7:0] b,output reg b_vld);reg [7:0] b_tmp[3:0];  
reg [2:0] vld_cnt;always@(posedge clk or negedge rst_n)beginif(!rst_n)beginb_tmp[0]<='d0;b_tmp[1]<='d0;b_tmp[2]<='d0;b_tmp[3]<='d0;endelse if(a_vld)beginb_tmp[0]<=a[31:24];b_tmp[1]<=a[23:16];b_tmp[2]<=a[15:8];b_tmp[3]<=a[7:0];end
endalways@(posedge clk or negedge rst_n)beginif(!rst_n)beginvld_cnt<='d0;endelse if(a_vld)beginif(vld_cnt==3'd4)beginvld_cnt<='d0;endelse beginvld_cnt<=vld_cnt+1'b1;endend
end
always@(posedge clk or negedge rst_n)beginif(!rst_n)beginb_vld<='d0;endelse beginb_vld<=(vld_cnt>0)?1'b1:1'b0;endendalways@(posedge clk or negedge rst_n)beginif(!rst_n)beginb<='d0;endelse begincase(vld_cnt)3'd1:beginb<=b_tmp[0];end           3'd2:beginb<=b_tmp[1];end3'd3:beginb<=b_tmp[2];end3'd4:beginb<=b_tmp[3];enddefault:b<=b;endcaseend
end
endmodule

非整数倍位宽转换

窄到宽

设计思路：根据输入和输出位宽的比值对输入的有效信号计数，该比值决定了何时输出数据。

module width_change_8to20(input clk,input rst_n,input [7:0] a,input a_vld,output reg [19:0] b,output reg b_vld);reg [7:0] a_lock;
reg [7:0] a_lock2;
reg [2:0] vld_cnt;always@(posedge clk or negedge rst_n)beginif(!rst_n)begina_lock<='d0;a_lock2<='d0;endelse if(a_vld) begina_lock<=a;a_lock2<=a_lock;end
endalways@(posedge clk or negedge rst_n)beginif(!rst_n)beginvld_cnt<='d0;endelse if(a_vld) beginif(vld_cnt == 3'd4)beginvld_cnt<='d0;endelse beginvld_cnt<=vld_cnt+1'b1;end       end
endalways@(posedge clk or negedge rst_n)beginif(!rst_n)beginb_vld<='d0;endelse if(a_vld && vld_cnt == 3'd2 ) beginb_vld<='d1;end  else if(a_vld && vld_cnt == 3'd4)beginb_vld<='d1;end  else beginb_vld<='d0;end
endalways@(posedge clk or negedge rst_n)beginif(!rst_n)beginb<='d0;endelse if(a_vld && vld_cnt == 3'd2)beginb<={a_lock2,a_lock,a[7:4]};endelse if(a_vld && vld_cnt == 3'd4)beginb<={a_lock2[3:0],a_lock,a};end   
end
endmodule

十三、调度器

调度器：用于在多个队列出队时选择哪个队列先出。

优先级调度器

SP调度：严格按照优先级从高到低的次序优先发送较高优先级队列中的报文，当较高优先级队列为空时，再发送较低优先级队列中的报文。

module sp_sch(input clk,input rst_n,input q0_rdy,input q1_rdy,input q2_rdy,output [2:0] sel);assign sel=q2_rdy ? 3'b100 :(q1_rdy ? 3'b010 : 3'b001);endmodule

轮询调度器

RR调度器：总是顺序地移到下一个有包要发送的队列（空队列被跳过）。

module RR_sch(input clk,input rst_n,input q0_rdy,input q1_rdy,input q2_rdy,output [2:0] sel);wire rr_vld;reg [2:0] last_winner;
reg [2:0] cur_winner;assign rr_vld=q0_rdy | q1_rdy | q2_rdy;always@(posedge clk or negedge rst_n)beginif(!rst_n)beginlast_winner<='d0;cur_winner<='d0; end else if(rr_vld)beginlast_winner<=cur_winner;end
endalways@(*)beginif(last_winner == 3'b001)beginif(q1_rdy == 1'b1)cur_winner<=3'b010;else if(q2_rdy == 1'b1)cur_winner<=3'b100;else if(q0_rdy == 1'b1)cur_winner<=3'b001;else cur_winner<=3'b000;endelse if(last_winner == 3'b010)beginif(q2_rdy == 1'b1)cur_winner<=3'b100;else if(q0_rdy == 1'b1)cur_winner<=3'b001;else if(q1_rdy == 1'b1)cur_winner<=3'b010;else cur_winner<=3'b000;endelse if(last_winner == 3'b100)beginif(q0_rdy == 1'b1)cur_winner<=3'b001;else if(q1_rdy == 1'b1)cur_winner<=3'b010;else if(q2_rdy == 1'b1)cur_winner<=3'b100;else cur_winner<=3'b000;endelse beginif(q0_rdy == 1'b1)cur_winner<=3'b001;else if(q1_rdy == 1'b1)cur_winner<=3'b010;else if(q2_rdy == 1'b1)cur_winner<=3'b100;else cur_winner<=3'b000;end
endassign sel=cur_winner;endmodule