数字逻辑设计基础

hi小瑞同学

已于 2024-09-07 21:31:24 修改

阅读量830

点赞数 13

分类专栏： FPGA开发文章标签： fpga开发嵌入式硬件

于 2024-09-07 20:26:32 首次发布

本文链接：https://blog.csdn.net/z12345r6/article/details/141402787

版权

FPGA开发专栏收录该内容

14 篇文章 3 订阅

订阅专栏

参考：

正点原子逻辑设计指南

状态机FSM

一、组合逻辑

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

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

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

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

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

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

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

如图，y信号最终会得到1个1ns的毛刺信号。
在这里插入图片描述

组合逻辑毛刺消除

组合逻辑输出加寄存器：寄存器一般只在时钟跳变沿对输入信号敏感，所以对发生在非时钟跳变沿的毛刺信号，去除效果非常明显。
信号延时同步法：在两级信号传递的过程中加一个延时环节，从而保证在下一个模块中读取到的数据是稳定后的数据。
状态机控制：在数据传递比较复杂的多模块系统中，由状态机在特定的时刻分别发出控制特定模块的时钟信号或者模块使能信号，状态机的循环控制就可以使得整个系统协调运作，同时减少毛刺信号。
格雷码计数器：格雷码计数器的输出每次只有一位跳变，使用格雷码计数器将避免毛刺的出现。

二、时序逻辑

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

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

锁存器

锁存器（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 @(*) begin
 bin_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) begin
  if (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) begin
  if (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) begin
    if (!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 ) begin
    if (rst_sync_n == 1'b0)
        y <= 1'b0 ;
    else 
         y <= b ;
 end

六、状态机

写法

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

module top_module(
    input clk,
    input areset,    // Asynchronous reset to state B
    input in,
    output reg out);//  
 
    parameter A=1'b0, B=1'b1; 
    reg state;
    
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            state <= B;
            out <= 1'b1;
        end
        else begin
            case(state)
                B:begin
                    if(in == 1'b1)begin
                        state <= B;
                        out <= 1'b1;
                    end
                    else begin
                        state <= A;
                        out <= 1'b0;
                    end
                end
                A:begin
                    if(in == 1'b1)begin
                        state <= A;
                        out <= 1'b0;
                    end
                    else begin
                        state <= B;
                        out <= 1'b1;
                    end
                end
                default:begin
                    state <= B;
                    out <= 1'b1;
                end
            endcase
        end
    end
    
endmodule

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

module top_module(
    input clk,
    input areset,    // Asynchronous reset to state B
    input in,
    output reg out);//  
 
    parameter A=1'b0, B=1'b1; 
    reg current_state, next_state;
    
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            current_state <= B;
        end
        else begin
            current_state <= next_state;
        end
    end
 
    always@(*)begin
        case(current_state)
            B:begin
                if(in == 1'b1)begin
                    next_state = B;
                end
                else begin
                    next_state = A;
                end
                out = 1'b1;
            end
            A:begin
                out = 1'b0;
                if(in == 1'b1)begin
                    next_state = A;
                end
                else begin
                    next_state = B;
                end
                out = 1'b0;
            end
        endcase
    end
    
endmodule

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

module top_module(
    input clk,
    input areset,    // Asynchronous reset to state B
    input in,
    output reg out);//  
 
    parameter A=1'b0, B=1'b1; 
    reg current_state, next_state;
    
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            current_state <= B;
        end
        else begin
            current_state <= next_state;
        end
    end
 
    always@(*)begin
        case(current_state)
            B:begin
                if(in == 1'b1)begin
                    next_state = B;
                end
                else begin
                    next_state = A;
                end
            end
            A:begin
                if(in == 1'b1)begin
                    next_state = A;
                end
                else begin
                    next_state = B;
                end
            end
        endcase
    end
 
    always@(posedge clk or posedge areset)begin
        if(areset)begin
            out <= 1'b1;
        end
        else if(next_state == B)begin
            out <= 1'b1;
        end
        else begin
            out <= 1'b0;
        end
    end
    
endmodule

分类

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

Mealy型状态机第三段输出采用cur_state。
在这里插入图片描述

//==================================================================
//--    3段式状态机（Mealy）
//==================================================================
 
//------------<模块及端口声明>----------------------------------------
module FSM_Mealy_3(
	input 		sys_clk		,			//输入系统时钟、50M
	input 		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)begin
	if(!sys_rst_n)
		cur_state <= IDLE;				//复位初始状态
	else
		cur_state <= next_state;		//次态转移到现态
end
//-----------------------------------------------------------------------
//--状态机第二段：组合逻辑判断状态转移条件，描述状态转移规律以及输出
//-----------------------------------------------------------------------
always@(*)begin
	case(cur_state)						//组合逻辑
										//根据当前状态、输入进行状态转换判断										
		IDLE:begin				
			if(money)					
				next_state = ONE;		//投币1元，则状态转移到ONE
			else 
				next_state = IDLE;		//没有投币，则状态保持	
		end					
		ONE:begin				
			if(money)
				next_state = TWO;		//投币1元，则状态转移到TWO
			else 
				next_state = ONE;		//没有投币，则状态保持
		end
		TWO:begin				
			if(money)
				next_state = IDLE;		//投币1元，则状态转移到IDLE
			else                        
				next_state = TWO;       //没有投币，则状态保持
		end	
		default:begin					//默认状态同IDLE
			if(money)
				next_state = ONE;
			else 
				next_state = IDLE;	
		end
	endcase
end
//-----------------------------------------------------------------------
//--状态机第三段：时序逻辑描述输出
//-----------------------------------------------------------------------
always@(posedge sys_clk or negedge sys_rst_n)begin
	if(!sys_rst_n)
		cola <= 1'b0;					//复位、初始状态 
	else
		case(cur_state)					//根据当前状态进行输出
			IDLE:	cola <= 1'b0;		//无可乐输出(因为输入不管是0、1都是输出0，所以省略写法)			
			ONE:	cola <= 1'b0;		//无可乐输出(因为输入不管是0、1都是输出0，所以省略写法)	
			TWO:begin					
				if(money)
					cola <= 1'b1;		//如果输入1，则输出可乐
				else
					cola <= 1'b0;		//如果输入0，则无可乐输出
			end
			default: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		,			//输入系统时钟、50M
	input 		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)begin
	if(!sys_rst_n)
		cur_state <= IDLE;				//复位初始状态
	else
		cur_state <= next_state;		//次态转移到现态
end
 
//-----------------------------------------------------------------------
//--状态机第二段：组合逻辑判断状态转移条件，描述状态转移规律以及输出
//-----------------------------------------------------------------------
always@(*)begin
	case(cur_state)						//组合逻辑
										//根据当前状态、输入进行状态转换判断										
		IDLE:begin				
			if(money)					
				next_state = ONE;		//投币1元，则状态转移到ONE
			else 
				next_state = IDLE;		//没有投币，则状态保持	
		end					
		ONE:begin				
			if(money)
				next_state = TWO;		//投币1元，则状态转移到TWO
			else 
				next_state = ONE;		//没有投币，则状态保持
		end
		TWO:begin				
			if(money)
				next_state = THREE;		//投币1元，则状态转移到THREE
			else                        
				next_state = TWO;       //没有投币，则状态保持
		end	
		THREE:begin				
			if(money)
				next_state = ONE;		//投币1元，则状态转移到ONE
			else                        
				next_state = IDLE;      //没有投币，则状态保持
		end
		default:begin					//默认状态同IDLE
			if(money)
				next_state = ONE;
			else 
				next_state = IDLE;	
		end
	endcase
end
 
//-----------------------------------------------------------------------
//--状态机第三段：时序逻辑描述输出
//-----------------------------------------------------------------------
always@(posedge sys_clk or negedge sys_rst_n)begin
	if(!sys_rst_n)
		cola <= 1'b0;					//复位、初始状态 
	else
		case(next_state)					//根据当前状态进行输出
			IDLE:	cola <= 1'b0;		//无可乐输出			
			ONE:	cola <= 1'b0;		//无可乐输出
			TWO:	cola <= 1'b0;		//无可乐输出
			THREE:	cola <= 1'b1;		//输出可乐
			default:cola <= 1'b0;		//默认无可乐输出
		endcase
end
 
endmodule

七、偶数分频电路

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

module divide_2 
( 
    input clk , // system clock 50Mhz on board
    input 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) begin
 if(!rst_n) begin
    cnt <= 0;
    out_clk <= 0;
 end
 else begin
    if(cnt==N/2-1) begin
        out_clk <= ~out_clk;
        cnt <= 0;
    end
 else
    cnt <= cnt + 1;
 end
 end
 endmodule

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

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

八、奇数分频电路

设计思路：分别在时钟的上升沿和下降沿计数进行周期扩展，得到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)begin
    if(!rstn)begin
        out_clk1<='d0;
        cnt1<=1;
    end
    else begin
        if(out_clk1==0)begin
            if(cnt1==N/2+1)begin
                cnt1<=1;
                out_clk1<=~out_clk1;
            end
            else begin
                cnt1<=cnt1+1'b1;
            end
        end
        else begin
            if(cnt1==N/2)begin
                cnt1<=1;
                out_clk1<=~out_clk1;
            end
            else begin
                cnt1<=cnt1+1'b1;
            end
        end
    end
end

always@(negedge clk or negedge rstn)begin
    if(!rstn)begin
        out_clk2<='d0;
        cnt2<=1;
    end
    else begin
        if(out_clk2==0)begin
            if(cnt2==N/2+1)begin
                cnt2<=1;
                out_clk2<=~out_clk2;
            end
            else begin
                cnt2<=cnt2+1'b1;
            end
        end
        else begin
            if(cnt2==N/2)begin
                cnt2<=1;
                out_clk2<=~out_clk2;
            end
            else begin
                cnt2<=cnt2+1'b1;
            end
        end
    end
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)begin
    if(en && wen)begin
        ram[addr]<=din;
    end
end
//读
always@(posedge clk)begin
    if(en && !wen)begin
        dout<=ram[addr];
    end
    else begin
        dout<=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)begin
    if(!rstn)begin
        rw_cnt<='d0;
    end
    else if(rw_cnt==6'd63)begin
         rw_cnt<='d0;          
    end
    else begin
        rw_cnt<=rw_cnt+1'b1;
    end
end
//RAM地址信号
always@(posedge clk or negedge rstn)begin
    if(!rstn)begin
        ram_addr<='d0;
    end
    else if(ram_addr == 5'd31)begin
        ram_addr<='d0;
    end
    else begin
        ram_addr<=ram_addr+1'b1;
    end
end
//RAM数据信号
always@(posedge clk or negedge rstn)begin
    if(!rstn)begin
        ram_wr_data<='d0;
    end
    else if(rw_cnt>=0 && rw_cnt<=31)begin
        ram_wr_data<=ram_wr_data+1'b1;
    end
    else begin
        ram_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) begin
    if (rst_n == 1'b0)
        conflict <= 1'b0 ;
    else if ( wen && ren && (waddr == raddr ))
        conflict <= 1'b1 ;
    else
        conflict <= 1'b0 ;
    end
     
assign 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拍赋值给读数据；
两个端口向同一地址写时，把两个写端口的数据经处理后通过一个写端口写入，另一个写端口关断处理；

//真双口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)begin
    if(wren_a)
        ram[address_a]<=data_a;
    if(wren_b)
        ram[address_b]<=data_b;
end

always@(posedge clocka)begin
    if(rden_a)begin
        q_a<=ram[address_a];
    end
    else begin
        q_a<=8'hx;
    end
end

always@(posedge clocka)begin
    if(rden_b)begin
        q_b<=ram[address_b];
    end
    else begin
        q_b<=8'hx;
    end
end

endmodule

//真双口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)begin
    if(!rst_n)begin
       rw_cnt<='d0; 
    end
    else if(rw_cnt==63)begin
        rw_cnt<='d0;
    end
    else begin
        rw_cnt<=rw_cnt+1'b1;
    end
end
//端口读写切换
always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        flag<=1'd0;
    end
    else if(rw_cnt==63)begin
        flag<=~flag;
    end
end

dp_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)begin
    if(!rst_n)begin
        vld_cnt<='d0;
    end
    else if(a_vld)begin
        if(vld_cnt==3'd3)begin
            vld_cnt<=3'd0;
        end
        else begin
            vld_cnt<=vld_cnt+1'b1;
        end
    end
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        b_vld<='d0;
    end
    else if(a_vld && vld_cnt==3'd3)begin
        b_vld<=1'b1;
    end
    else begin
        b_vld<=1'b0;
    end
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        a_r[0]<='d0;
        a_r[1]<='d0;
        a_r[2]<='d0;
    end
    else if(a_vld)begin
        a_r[0]<=a;
        a_r[1]<=a_r[0];
        a_r[2]<=a_r[1];       
    end
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        b<='d0;
    end
    else if(a_vld && vld_cnt==3'd3)begin
        b<={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)begin
    if(!rst_n)begin
        b_tmp[0]<='d0;
        b_tmp[1]<='d0;
        b_tmp[2]<='d0;
        b_tmp[3]<='d0;
    end
    else if(a_vld)begin
        b_tmp[0]<=a[31:24];
        b_tmp[1]<=a[23:16];
        b_tmp[2]<=a[15:8];
        b_tmp[3]<=a[7:0];
    end
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        vld_cnt<='d0;
    end
    else if(a_vld)begin
        if(vld_cnt==3'd4)begin
            vld_cnt<='d0;
        end
        else begin
            vld_cnt<=vld_cnt+1'b1;
        end
    end
end
always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        b_vld<='d0;
    end
    else begin
        b_vld<=(vld_cnt>0)?1'b1:1'b0;
    end
    
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        b<='d0;
    end
    else begin
        case(vld_cnt)
            3'd1:begin
                b<=b_tmp[0];
            end           
            3'd2:begin
                b<=b_tmp[1];
            end
            3'd3:begin
                b<=b_tmp[2];
            end
            3'd4:begin
                b<=b_tmp[3];
            end
            default:
                b<=b;
        endcase
    end
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)begin
    if(!rst_n)begin
        a_lock<='d0;
        a_lock2<='d0;
    end
    else if(a_vld) begin
        a_lock<=a;
        a_lock2<=a_lock;
    end
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        vld_cnt<='d0;
    end
    else if(a_vld) begin
        if(vld_cnt == 3'd4)begin
            vld_cnt<='d0;
        end
        else begin
            vld_cnt<=vld_cnt+1'b1;
        end       
    end
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        b_vld<='d0;
    end
    else if(a_vld && vld_cnt == 3'd2 ) begin
        b_vld<='d1;
    end  
    else if(a_vld && vld_cnt == 3'd4)begin
        b_vld<='d1;
    end  
    else begin
        b_vld<='d0;
    end
end

always@(posedge clk or negedge rst_n)begin
    if(!rst_n)begin
        b<='d0;
    end
    else if(a_vld && vld_cnt == 3'd2)begin
        b<={a_lock2,a_lock,a[7:4]};
    end
    else if(a_vld && vld_cnt == 3'd4)begin
        b<={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)begin
    if(!rst_n)begin
       last_winner<='d0;
       cur_winner<='d0; 
    end 
    else if(rr_vld)begin
        last_winner<=cur_winner;
    end
end

always@(*)begin
    if(last_winner == 3'b001)begin
        if(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;
    end
    else if(last_winner == 3'b010)begin
        if(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;
    end
    else if(last_winner == 3'b100)begin
        if(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
    else begin
        if(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
end

assign sel=cur_winner;

endmodule