FPGA刷题——数据位宽转换（整数倍&非整数倍）

目录

整数倍的数据位宽转换

非整数倍数据位宽转换

8转12 

24转128

总结

---

整数倍的数据位宽转换

输入8位：valid_in , data_in[7:0]
输出16位：valid_out, data_out[15:0]

观察时序图需要注意：

（1）valid_out和data_out是在两个数据输入之后的下一个时钟周期产生输出；

（2）当仅有一个数据输入后，不会产生输出valid_out和data_out，而是会等待下一个数据到来之后完成两个数据的拼接，才产生输出valid_out和data_out。

思路：由于只用处理两个有效数据，所以将第一个有效数据暂存，然后第二个有效数据输入后，拼接起来就可以得到输出。

根据时序图，数据是在第二个数据到来之后输出，当仅有一个数据到来时，不产生输出，所以内部需要一个指示信号（flag），用来指示数据缓存状态。当data_reg内已缓存第一个数据时，flag拉高，当第二个数据到来后flag拉低。

首先设置数据暂存器data_reg，在valid_in有效flag=0时暂存第一个数据

然后在在valid_in有效flag=0时拼位输出data_out和valid_out

 代码如下：

module width_8to16(
	input 				   clk 		,   
	input 				   rst_n		,
	input				      valid_in	,
	input	   [7:0]		   data_in	,
 
 	output	reg			valid_out,
	output   reg [15:0]	data_out
);
    reg[7:0] data_reg;//数据缓存
    reg flag;//指示信号
    
always @(posedge clk or negedge rst_n ) begin
    if(!rst_n) 
        flag <= 'd0;
    else if(valid_in)//第1个数据到来时flag=1，第2个数据到来时flag=0
        flag <= ~flag;
end
    
always @(posedge clk or negedge rst_n ) begin
    if(!rst_n) 
        data_reg <= 'd0;
    else if(valid_in && !flag)//数据有效&指示信号=0
        data_reg <= data_in;//缓存第1个数据
end
 
always @(posedge clk or negedge rst_n ) begin
    if(!rst_n) 
        valid_out <= 'd0;
    else if(valid_in && flag)
        valid_out <= 1'd1;//输出valid_out
    else
        valid_out <= 'd0;
end
    
always @(posedge clk or negedge rst_n ) begin
    if(!rst_n) 
        data_out <= 'd0;
    else if(valid_in && flag)
        data_out <= {data_reg,data_in};//第一个数据，第二个数据
    else
        data_out <= data_out;
end    
    
endmodule

非整数倍数据位宽转换

非整数倍的位宽转换相对来说比较困难，下面是牛客上的两个例子，我们可以从中总结这种问题的解决的一般规律

8转12 

输入为8bit，输出为12bit ，每三个有效输入可以组成两个输出

 

思路：首先设置一个计数器cnt，计数3个8bit数据

在cnt=0时，将第一个8bit数据缓存进buff

在cnt=1时，将buff和第二个数据的高4位拼位：data_out<={buff,data_in[7:4]};//输出第一个12bit数据；并且将第二个数据低四位缓存进buff

在cnt=2时，将第二个数据低四位和第三个数据拼位，data_out<={buff[3:0],data_in};//输出第二个12bit数据

module width_8to12(
	input 				   clk 		,   
	input 			      rst_n		,
	input				      valid_in	,
	input	[7:0]			   data_in	,
 
 	output  reg			   valid_out,
	output  reg [11:0]   data_out
);
    reg[7:0] buff;//缓存数据
    reg[1:0] cnt;//计数器（指示信号作用）
    
     always@(negedge rst_n or posedge clk)begin
        if(~rst_n)
            cnt <= 0;
         else if(valid_in)//在每次valid有效的时钟下，cnt自增1
            if(cnt == 2)
                cnt <= 0;
            else
                cnt <= cnt + 1;
    end
    
    always@(negedge rst_n or posedge clk)begin
        if(!rst_n)begin
            buff<=8'd0;
            data_out<=12'd0;
        end
        else if(valid_in) begin
            if(cnt==2'd1)begin
                buff[3:0]<=data_in[3:0];//把第二个数据的低4位缓存
                data_out<={buff,data_in[7:4]};//输出第一个12bit数据
            end
            else if(cnt==2'd2)begin
                data_out<={buff[3:0],data_in};//输出第二个12bit数据
            end
            else begin
                buff <= data_in;//缓存第一个数据
            end
        end
    end
    
    always@(negedge rst_n or posedge clk)begin
        if(~rst_n)
            valid_out <= 0;
        else if(valid_in && (cnt == 1 || cnt == 2))
            valid_out <= 1;
        else
            valid_out <= 0;
    end    
    
endmodule

24转128

 

 

输入：valid_in, data_in[23:0]
输出：valid_out,data_out[127:0]
输入数据是24bit，输出数据是128bit。因为128×3=24×16128\times3=24\times16128×3=24×16，所以每输入16个有效数据，就可以产生三个完整的输出。

 因此设置一个仅在输入数据有效时工作的计数器cnt，计数范围是0-15

设置一个缓存器data_lock，缓存128bit数据

接下来根据计数器进行拼位：

cnt=5时，缓存器里有 0 1 2 3 4 （一共120个数据）再拼位上6的高8bit

cnt=10时，缓存器里有 5的低16bit 6 7 8 9 （一共112个数据）再拼位上10的高16bit

cnt=15时，缓存器里有 10的低8bit 11 12 13 14 再拼位上15

每当计数器cnt计数到5、10、15时，data_out要进行更新，并拉高valid_out一个周期。

module width_24to128(
	input 				clk 		,   
	input 				rst_n		,
	input				valid_in	,
	input	[23:0]		data_in		,
 
 	output	reg			valid_out	,
	output  reg [127:0]	data_out
);
    
    reg [3:0]   cnt;//计数器
    reg [127:0] data_lock;//128位数据
    
     always@(posedge clk or negedge rst_n) begin
        if(~rst_n)
            cnt <= 0;
        else
            cnt <= ~valid_in? cnt:cnt+1;//来一个vaild_in,cnt+1
    end
    
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n)
            data_lock <= 0;
        else//来一个vaild_in,将24bit缓存进data_lock
            data_lock <= valid_in? {data_lock[103:0], data_in}: data_lock;
    end
    
   
    always@(posedge clk or negedge rst_n) begin
        if(~rst_n)
            data_out <= 0;
        else if(cnt==5)//120+8：0 1 2 3 4 5的高8bit
            data_out <= valid_in? {data_lock[119:0], data_in[23:16]}: data_out;
        else if(cnt==10)//112+16：5的低16bit 6 7 8 9 10的16bit
            data_out <= valid_in? {data_lock[111:0], data_in[23: 8]}: data_out;
        else if(cnt==15)//104+24：10的8bit 11 12 13 14 15 
            data_out <= valid_in? {data_lock[103:0], data_in[23: 0]}: data_out;
        else
            data_out <= data_out;
    end
    
     always@(posedge clk or negedge rst_n) begin
        if(~rst_n)
            valid_out <= 0;
        else
            valid_out <= (cnt==5 || cnt==10 || cnt==15)&&valid_in;
    end
    
    
endmodule

总结

整数倍的拼位

（1）设置一个数据指示flag信号

（2）根据flag信号进行拼位

非整数倍的拼位

（1）找最大倍数关系，计算需要多少个输入数据，才能完成输出要求的输出位宽，（比如24->128最大倍数384 384/24=16  需要16个24bit输入）

（2）设置一个数据指示flag信号

（3）根据flag信号进行拼位

ps：实际应用中，位宽转换采用fifo即可