Verilog卷积_Conv函数实现_MATLAB卷积_FPGA驱动VGA显示（2）Verilog

可以先编写不可综合的仿真用Verilog，然后再写可综合的，如果技术卓越，可以跳过这步：

卷积的长度是不确定的，比如MATALAB里面的CONV函数，输入多长的都行，但是需要提前输入一整个向量（数组），那么长度也就是定下了：我写的MATLAB卷积函数也是有测长度的：https://blog.csdn.net/Mr_liu_666/article/details/103372145

但是实际用FPGA的时候，实时卷积，卷积对象是流式输入的，所以首先定下来一个长度，比如128，那么我们的Verilog就算128卷积128即可，一次填充128，计算一次，输出一次。我写的Verilog用了parameter定义了常量，卷积长度可以随时改变，为了双重for嵌套累加，需要一些临时reg变量计数，我使用的是8位的，所以最大只能加到255，卷积长度不能超过128，否则卷积结果长度为128+128-1=255，变量就不能清零了。

以8位卷积为例：

卷积结果是1到8到1，modelsim仿真结果如下：

成功得到1到8到1的结果。

卷积模块代码：

//模块：可变长卷积模块
//功能：算两个预设长度的寄存器的卷积结果，寄存器的输入实时更新，卷积结果放在寄存器中，实时输出
//使用方法：输入时钟，低电平复位清空不定态寄存器，load拉高输入即将计算的数值，
//out拉高输出结果寄存器的数值
module CONV(
input wire reset,//复位，清空所有寄存器
input wire clk,//时钟
input wire  [7:0] CONV_iData0,//输入数据
input wire  [7:0] CONV_iData1,//输入数据
output reg  [15:0] CONV_oData//输出数据
);

parameter LengthOfConv = 8;//卷积长度
parameter InState = 4'b0001,ConvState = 4'b0010,OutState = 4'b0100,ClrState = 4'b1000;

//三个mem类型的寄存器
reg [7:0] CONV_iData0reg[LengthOfConv - 1:0];
reg [7:0] CONV_iData1reg[LengthOfConv - 1:0];
reg [15:0] CONV_oDatareg[2*LengthOfConv - 2:0];

reg [7:0]index0;
reg [7:0]index1;//这两个是初始化，清零用的

reg [7:0]index_input;//输入计数
reg [7:0]index_conv;
reg [7:0]index_conv2;//卷积计数
reg [7:0]index_output;//输出计数
reg [7:0]index_clr;//输出计数

reg [3:0] state,nextstate;

initial
	 begin
		index0 <= 0;
		index1 <= 0;
		index_input <= 8'b0;
		index_conv	<= 8'b0;		
		index_conv2 <= 8'b0;
		index_output<= 8'b0;
		index_clr <= 8'b0;  
		state <= InState;
		nextstate <= ConvState;
	end

always @(posedge clk)//用若干个时钟周期把卷积输入寄存器和结果寄存器清零
begin
	if(reset == 0)
	begin
		CONV_iData0reg[index0] <= 8'b0;
		CONV_iData1reg[index0] <= 8'b0;
		CONV_oDatareg[index1] <= 16'b0;
		if(index0  == LengthOfConv - 1) 
			index0 = 8'b0;  
		else
			index0 <= index0 + 8'b1;
		if(index1  == LengthOfConv * 2 - 2) 
			index1 = 8'b0;  
		else
			index1 <= index1 + 8'b1;
	end
	else
	begin
		if(state == InState)//输入数据
		begin
			begin
				CONV_iData0reg[index_input] <= CONV_iData0;
				CONV_iData1reg[index_input] <= CONV_iData1;
				index_input <= index_input + 8'b1;
				CONV_oData <= 0;//转换没有结束的时候，输出为0
			end
			if(index_input >= LengthOfConv - 1)
			begin
				index_input <= 8'b0;
				state <= nextstate;
				nextstate  <= OutState;
			end
		end
		if(state == ConvState)//计算卷积
		begin
			CONV_oData <= 0;//转换没有结束的时候，输出为0
			if(index_conv2  <= LengthOfConv-1 &&index_conv  <= LengthOfConv-1 )
				CONV_oDatareg[index_conv2 + index_conv] = CONV_oDatareg[index_conv2 + index_conv] + CONV_iData0reg[index_conv2]*CONV_iData1reg[index_conv];
			if(index_conv2  == LengthOfConv ) //用于代替for循环嵌套，内层
			begin
				index_conv2 <= 8'b0; 
				index_conv <= index_conv + 8'b1;
			end
			else
				index_conv2 <= index_conv2 + 8'b1; 
				
			if(index_conv  == LengthOfConv )
			begin
				index_conv <= 8'b0; 
				index_conv2 <= 8'b0; 
				//clearflag <= ~clearflag;
				state <= nextstate;
				nextstate  <= ClrState;
			end
		end	 
		if(state == OutState)//输出状态
		begin
			CONV_oData <= CONV_oDatareg[index_output];
			index_output <= index_output + 8'b1;
			if(index_output  == LengthOfConv * 2 - 2)//多一个周期，使输出完整，但是会多出来一个越界的现象，也就是一个0（因为我们清零过了）
			begin
				index_output <= 8'b0;  //由于非阻塞赋值的特点，这里需要从0到LengthOfConv * 2
				state <= nextstate;
				nextstate  <= InState;
			end			
		end 
		if(state == ClrState)//清除状态
		begin
			CONV_oData <= 0;//转换没有结束的时候，输出为0
			CONV_oDatareg[index_clr] = 0;
			index_clr<= index_clr + 8'b1;
			if(index_clr  == LengthOfConv * 2 - 1 )
			begin
				index_clr <= 8'b0;  
				state <= nextstate;
				nextstate  <= ConvState;
			end			
		end 
	end
end
endmodule

另外，initial里面的东西仿真的时候管用，综合以后可能会没效果：https://blog.csdn.net/Mr_liu_666/article/details/103375653

测试代码：(这里使用了可综合的状态机，效果不错)

`timescale 1ns/1ns


module CONV_top();
    
parameter period = 1;

parameter Rst0State = 2'b00;//前提是state的初值是0
parameter Rst1State = 2'b01;
parameter WorkState = 2'b10;
    
reg reset;
reg clk;
reg  [7:0] CONV_iData0;
reg  [7:0] CONV_iData1;
reg  [15:0] index_reset; 
reg  [1:0] State;
  
always @(posedge clk)
begin
	if(State == Rst0State)//开始复位
	begin		
		reset <= 0;
		index_reset <= 0;
		State <= Rst1State;
	end
	else 
	if(State == Rst1State)//保持复位，复位结束
		begin
			if(index_reset <= 16'hfe)
			begin
				index_reset <= index_reset + 1;
			end
			else
			begin
				//index_reset <= 0;
				State <= WorkState;
				reset <= 1;
			end
		end
		else
			if(State == WorkState)//输入数据
			begin
				reset <= 1;
				State <= WorkState;
				CONV_iData0 = 8'h01;
				CONV_iData1 = 8'h01;
			end
end

always 
begin
	# period clk = !clk;	
end

CONV CONV0(
	.reset(reset),
	.clk(clk),
	.CONV_iData0(CONV_iData0),
	.CONV_iData1(CONV_iData1),
	.CONV_oData(CONV_oData)
);
endmodule 

接下来应该将其综合进工程，做一个可视的FPGA实验，准备做一个累加实验，使一个跳动的色块的颜色随着卷积结果的变化而变化：https://blog.csdn.net/Mr_liu_666/article/details/103376238

关于其MATLAB仿真，见前一篇：https://blog.csdn.net/Mr_liu_666/article/details/103372145