前言

在编写基于verilog的的卷积神经网络实现时，需要定义一个滑窗，并与对应位置的图像像素值相乘再相加，实现单点的卷积运算，具体的操作如图1所示。

图1 卷积的实现过程

---

正文分析

我们采用FPGA的RAM的进行图片（假设图片为5×5，滤波器的大小为3×3）数据缓存，由于图像的数据是按行展开串行送入，但是在进行卷积计算时，我们至少需要同时有3行的数据参与运算，所以需要定义数组为3的window_in和window_out用于RAM中图片缓存的输入与输出。

wire [7:0] window_in[0:3-1];
wire [7:0] window_out[0:3-1];

在Vivado简单双端口RAM 使用，问题探析中，我们描述了具体的读写操作，这里不再赘述，按照此前的方法（Vivado简单双端口RAM 使用，问题探析中实现的），数据读取整整延迟一个RAM的深度（5个时钟周期）。为了实现同时读取3行的数据，需要采用generat...for...例化3个RAM的IP核（位宽为8，深度为5）。代码如下所示：

图2 例化RAM的IP的具体实现
但如何实现数据同时3行的暂存呢？假设代码如下所示：

assign window_in[0] = data_in;
assign window_in[1] = data_in;
assign window_in[2] = data_in;

这时的仿真结果如图3所示，此时，例化的3个RAM的IP时完全相同的。

图3 仿真结果
所以，我们可以将 windos_out[n-1]的输出，作为 windos_in[n]的输入，这样便实现了数据的暂存。代码实现如下所示：

assign window_in[0] = data_in;
assign window_in[1] = window_out[0];
assign window_in[2] = window_out[1];

从仿真结果发现，在地址进行第4行数据的存储时，实现了前三行的数据存储，当写地址为wr_addr=0时，实现的时第0列数据的读取，window_out[2]=img[0][0]=11111101，window_out[1]=img[1][0]=01110100，window_out[0]=img[2][0]=00011100。

图4 仿真结果

图5 输入图像的像素信息
但是导致的情况时，并不能实现，数据最后一行的读取，仅仅能实现前4行数据的正常读取。
图6 仿真结果
怎么实现最后一行的正常读取呢，其实很简单，我们将 data_in_valid增加5个时钟周期之后再拉低即可。即
图7 增加5个时钟周期
则仿真结果为：

图8 仿真结果

`timescale 1ns / 1ps


module ram_val(
    input                               clk                        ,
    input                               rst_n                      ,
        
    input              [8-1:0]          data_in                    ,
    input                               data_in_valid              ,
        
    output             [6*32-1:0]       data_out                   ,
    output reg                          data_out_valid              
    );



reg                    [   2:0]         rd_addr                    ;
reg                    [   2:0]         wr_addr                    ;
wire                    [8-1:0]          data_out1                   ;

wire [2:0] rd_addr_pre2 = wr_addr + 2;  

always @(posedge clk or negedge rst_n) begin
    if(~rst_n) begin
        rd_addr <= 'd0;
        wr_addr <= 'd0;
    end
    else begin
        if(data_in_valid) begin
            if(wr_addr=='d4) begin
                wr_addr <= 'd0;
            end
            else begin
                wr_addr <= wr_addr + 'd1;
            end
//          if(rd_addr=='d4) begin
//              rd_addr <= 'd0;
//          end                                   
//          else begin                          
//              rd_addr <= rd_addr + 'd1;         
//          end
                                                                      //            3-0 4-1
          if(rd_addr_pre2 >'d4)  begin                              //0-2 1-3 2-4 3-5 4-6
              rd_addr <= rd_addr_pre2 - 'd5;                        //0-1 1-2 2-3 3-4 4-5
          end                                                       //                4-0
          else begin
              rd_addr <= rd_addr_pre2;
          end

        
        end
    end
end

//===================data======================
wire [7:0] window_in[0:3-1];
wire [7:0] window_out[0:3-1];

genvar k;
assign window_in[0] = data_in;
assign window_in[1] = window_out[0];
assign window_in[2] = window_out[1];

generate
    for (k = 0;k<3 ;k=k+1 ) begin
    gray_line_buff your_instance_name (
        .clka(clk),    // input wire clka
        .wea(data_in_valid),      // input wire [0 : 0] wea
        .addra(wr_addr),  // input wire [2 : 0] addra
        .dina(window_in[k]),    // input wire [7 : 0] dina
        .clkb(clk),    // input wire clkb
        .enb('b1),      // input wire enb
        .addrb(rd_addr),  // input wire [2 : 0] addrb
        .doutb(window_out[k])  // output wire [7 : 0] doutb
        );
    end
endgenerate
endmodule