【正点原子FPGA连载】第二十五章基于OV5640的中值滤波实验--摘自【正点原子】领航者ZYNQ之嵌入式开发指南_V1.2

正点原子运营 · 发表于 2020-9-11 11:01:11

本帖最后由正点原子01 于 2020-9-11 11:01 编辑

1）实验平台：正点原子领航者ZYNQ开发板
2）平台购买地址：https://item.taobao.com/item.htm?&id=606160108761
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-301505-1-1.html
4）对正点原子FPGA感兴趣的同学可以加群讨论：905624739 点击加入群聊：

5）关注正点原子公众号，获取最新资料更新

第二十五章基于OV5640的中值滤波实验

在数字图像处理中，无论是直接获取的灰度图像，还是由彩色图像转换得到的灰度图像，里面都有噪声的存在，噪声对图像质量有很大的影响。而中值滤波是一种常用的降噪方法，它不仅可以去除孤点噪声，而且可以保持图像的边缘特性，不会使图像产生显著的模糊。本章实验我们将进行基于OV5640摄像头的中值滤波的实验。本章包括以下几个部分：

1.1 简介

1.2 实验任务

1.3 硬件设计

1.4 软件设计

1.5 下载验证

1.1 简介

滤波是指接收（通过）或过滤掉信号中一定的频率分量，例如，通过低频率的滤波器称为低通滤波器。空间滤波是图像处理领域应用非常广泛的工具之一，它可以改善图像质量，包括去除高频噪声与干扰、图像平滑等。我们常见的空间滤波有中值滤波和均值滤波。

图像可以看成是一个定义在二维平面上的信号，该信号的幅值对应像素的灰度（彩色图像对应RGB三个分量）。图像的频率指的是空间频率，它和我们认知的物理频率是不同的。图像的频率是表征图像中灰度变化剧烈程度的指标，是灰度在平面空间上的梯度。不同频率信息在图像结构中有不同的作用。图像的主要成分是低频信息，它形成了图像的基本灰度等级，对图像结构的决定作用较小；中频信息决定了图像的基本结构，形成了图像的主要边缘结构；高频信息形成了图像的边缘和细节，是在中频信息上对图像内容的进一步强化。

我们也可以通过空间滤波器（也称为空间掩模、模板或窗口）直接作用于图像本身而对图像进行滤波处理。空间滤波器由两部分组成：（1）邻域，（2）对该邻域包围的图像像素执行的预定义操作。领域是指一个像素点及其附近像素点所组成的空间。滤波会产生一个新像素，像素的坐标就是邻域中心的坐标，像素的值就是滤波操作的结果。

中值滤波就是一种很常见的空间滤波，它一种非线性平滑技术。它将每一像素点及该像素点的邻域作为一个滤波模板，计算出模板中所有像素点的灰度值的中值，然后用它代替模板中心点像素的值。图 27.1.1为像素点P及其周围8个像素点所组成的3x3滤波模板：

图 24.1.1 中值滤波模板

中值滤波是一种基于排序统计理论的非线性信号处理技术，它可以消除孤立的噪声点，从而让图像中的像素值更接近真实值。红外图像中的盲元就是一种孤立噪点的例子。由于红外探测器制造过程中的缺陷，传感器中某些像元的输出可能会非常大，导致图像中对应的像素点非常亮，我们称之为盲元，如下图中红色箭头所示：

图 24.1.2 红外图像中的盲元

中值滤波对类似于上图中的脉冲噪声有良好的滤除作用，特别是在滤除噪声的同时，能够保护信号的边缘，使之不被模糊。这些优良特性是线性滤波方法所不具备的。此外，中值滤波的算法比较简单，也易于用硬件实现。所以，中值滤波方法一经提出后，便在数字信号处理领域得到广泛的应用。

关于中值滤波如何快速求得中值，有多种方法实现，例如冒泡排序法、选择排序法等方法。但是用Verilog实现这些排序算法不仅会很复杂而且运算速率也会大大降低。在本章实验中我们采用流水线操作的方式，在图像的3x3矩阵中实现快速排序。我们给出如下图的算法流程框图：

图 24.1.3 中值滤波算法框图

首先我们生成一个3x3的像素阵列，然后在分别对每行3个像素进行排序，得出每行的最大、中值和最小值（如上图Max1、Med1和Min1）。接着，对排序后的矩阵进行处理，即提取三个最大值中的最小值（Minz_of_Max），三个中间值的中间值（Med_of_Med），以及三个最小值中的最大值（Max_of_Min）。最后，将得到的三个值，再次取中值，最终求得9个像素的中值。

1.2 实验任务

本章我们利用OV5640摄像头采集RGB565数据，将采集的数据转换为YUV数据，然后对灰度数据进行中值滤波处理，最后通过LCD显示。

1.3 硬件设计

本次实验的硬件电路、管脚分配与“OV5640摄像头LCD显示”实验完全相同，有关这一部分内容请读者参考“OV5640摄像头LCD显示”实验。 PL端的硬件系统框架与“OV5640摄像头LCD显示”实验基本相同，但不同点在于，我们添加了VIP（video_image_process）模块，该模块的功能是将 OV5640 摄像头采集的 RGB 格式的图像数据转换成Ycbcr格式，然后进行灰度中值滤波操作，最后将处理后的数据送入 Video In to AXI4-Stream IP 核。

本次实验的系统框图如下：

图 24.3.1 实验系统框图

VIP模块的IP核在Block Design中的连接图如下：

图 24.3.2 VIP模块在Block Design中的连接图

图 27.3.2中的video_image_process_0就是本次实验中完成的视频图像处理模块（VIP），它在摄像头数据采集模块ov5640_capture_data_0和IP核v_vid_in_axi4s_0之间负责完成灰度转换和中值滤波等图像处理。

VIP（video_image_process）模块包含“RGB转Ycbcr”和“中值滤波”两个模块。VIP内部两个模块的连接图如下所示：

图 24.3.3 VIP内部模块连接图

图 27.3.3中u_rgb2ycbcr模块负责完成灰度转换，而u_gray_median_filter则负责将转换得到的灰度图像进行中值滤波。

VIP模块顶层例化代码如下：

module Video_Image_Processor(
input clk, //cmos 像素时钟
input rst_n,
//预处理图像
input pre_image_vsync, //预处理图像场同步信号
input pre_image_clken, //预处理图像时钟使能信号
input pre_data_valid, //预处理图像数据有效信号
input [23:0 pre_image_data, //预处理图像数据
//处理后图像
output pos_image_vsync, //处理后图像场同步信号
output pos_image_clken, //处理后图像时钟使能信号
output pos_data_valid, //处理后图像数据有效信号
output [23:0 pos_image_data //处理后图像数据
);
//wire define
wire [7:0 gray_data ;
wire ycbcb_vsync;
wire ycbcbr_clken;
wire ycbcr_valid;
//*****************************************************
//** main code
//*****************************************************
//rgb转ycbcr模块
rgb2ycbcr u_rgb2ycbcr(
.clk (clk),
.rst_n (rst_n),
.rgb_vsync (pre_image_vsync),
.rgb_clken (pre_image_clken),
.rgb_valid (pre_data_valid),
.rgb_data (pre_image_data),
.ycbcb_vsync (ycbcb_vsync),
.ycbcbr_clken (ycbcbr_clken),
.ycbcr_valid (ycbcr_valid),
.gray_data (gray_data)
);
//中值滤波模块
gray_median_filter u_gray_median_filter(
.clk (clk),
.rst_n (rst_n),
//预处理图像
.pre_gray_vsync (ycbcb_vsync),
.pe_gray_valid (ycbcr_valid),
.pe_gray_clken (ycbcbr_clken),
.pre_gray_data (gray_data),
//处理后图像
.pos_gray_vsync (pos_image_vsync),
.pos_gray_valid (pos_data_valid),
.pos_gray_clken (pos_image_clken),
.pos_pixel_data (pos_image_data)
);
endmodule

复制代码

在VIP顶层模块调用了“rgb2ycbcr”和“gray_median_filter”两个模块，有关“rgb2ycbcr”模块我们在“OV5640摄像头灰度图显示”实验已经有过介绍，需要了解的朋友可以参考“OV5640摄像头灰度图显示”实验相关内容。本章节我们将讲解gray_median_filter模块，即中值滤波模块。

gray_median_filter模块的代码如下：

module gray_median_filter(
input clk,
input rst_n,
//预处理灰度数据
input pre_gray_vsync, //预处理灰度场同步
input pe_gray_valid, //预处理灰度数据有效信号
input pe_gray_clken, //预处理灰度时钟使能信号
input [7:0 pre_gray_data, //预处理灰度数据
//处理后灰度数据
output pos_gray_vsync, //处理后灰度场同步信号
output pos_gray_valid, //处理后灰度数据有效信号
output pos_gray_clken, //处理后灰度时钟使能信号
output [23:0 pos_pixel_data //处理后灰度数据
);
//wire define
wire matrix_frame_vsync;
wire matrix_frame_href;
wire matrix_frame_clken;
wire [7:0 matrix_p11; //3X3 矩阵数据
wire [7:0 matrix_p12;
wire [7:0 matrix_p13;
wire [7:0 matrix_p21;
wire [7:0 matrix_p22;
wire [7:0 matrix_p23;
wire [7:0 matrix_p31;
wire [7:0 matrix_p32;
wire [7:0 matrix_p33;
wire [7:0 mid_value ;
wire [7:0 pos_img_Y;
//*****************************************************
//** main code
//*****************************************************
assign pos_img_Y = pos_gray_valid ? mid_value : 8'd0;
assign pos_pixel_data = {pos_img_Y,pos_img_Y,pos_img_Y};
VIP_matrix_generate_3x3_8bit u_VIP_matrix_generate_3x3_8bit(
.clk (clk),
.rst_n (rst_n),
//预处理灰度数据
.per_frame_vsync (pre_gray_vsync),
.per_frame_href (pe_gray_valid),
.per_frame_clken (pe_gray_clken),
.per_img_Y (pre_gray_data),
//输出3x3矩阵
.matrix_frame_vsync (matrix_frame_vsync),
.matrix_frame_href (matrix_frame_href),
.matrix_frame_clken (matrix_frame_clken),
.matrix_p11 (matrix_p11),
.matrix_p12 (matrix_p12),
.matrix_p13 (matrix_p13),
.matrix_p21 (matrix_p21),
.matrix_p22 (matrix_p22),
.matrix_p23 (matrix_p23),
.matrix_p31 (matrix_p31),
.matrix_p32 (matrix_p32),
.matrix_p33 (matrix_p33)
);
//3x3矩阵中值提取
median_filter u_median_filter(
.clk (clk),
.rst_n (rst_n),
.median_frame_vsync (matrix_frame_vsync),
.median_frame_href (matrix_frame_href),
.median_frame_clken (matrix_frame_clken),
//矩阵第一行数据
.data11 (matrix_p11),
.data12 (matrix_p12),
.data13 (matrix_p13),
//矩阵第二行数据
.data21 (matrix_p21),
.data22 (matrix_p22),
.data23 (matrix_p23),
//矩阵第三行数据
.data31 (matrix_p31),
.data32 (matrix_p32),
.data33 (matrix_p33),
.pos_frame_vsync (pos_gray_vsync),
.pos_frame_href (pos_gray_valid),
.pos_frame_clken (pos_gray_clken),
.target_data (mid_value)
);
endmodule

复制代码

在gray_median_filter模块调用了VIP_Matrix_Generate_3X3_8Bit、median_filter两个模块，他们分别用用于生成3x3矩阵和求得矩阵的中值。

VIP_Matrix_Generate_3X3_8Bit模块代码如下：

module VIP_matrix_generate_3x3_8bit
(
input clk,
input rst_n,
//准备要进行处理的图像数据
input per_frame_vsync,
input per_frame_href,
input per_frame_clken,
input [7:0 per_img_Y,
//矩阵化后的图像数据和控制信号
output matrix_frame_vsync,
output matrix_frame_href,
output matrix_frame_clken,
output reg [7:0 matrix_p11,
output reg [7:0 matrix_p12,
output reg [7:0 matrix_p13,
output reg [7:0 matrix_p21,
output reg [7:0 matrix_p22,
output reg [7:0 matrix_p23,
output reg [7:0 matrix_p31,
output reg [7:0 matrix_p32,
output reg [7:0 matrix_p33
);
//wire define
wire [7:0 row1_data; //第一行数据
wire [7:0 row2_data; //第二行数据
wire read_frame_href ;
wire read_frame_clken;
//reg define
reg [7:0 row3_data; //第三行数据，即当前正在接受的数据
reg [1:0 per_frame_vsync_r;
reg [1:0 per_frame_href_r;
reg [1:0 per_frame_clken_r;
//*****************************************************
//** main code
//*****************************************************
assign read_frame_href = per_frame_href_r[0 ;
assign read_frame_clken =per_frame_clken_r[0];
assign matrix_frame_vsync = per_frame_vsync_r[1];
assign matrix_frame_href = per_frame_href_r[1 ;
assign matrix_frame_clken = per_frame_clken_r[1];
//当前数据放在第3行
always@(posedge clk or negedge rst_n) begin
if(!rst_n)
row3_data <= 0;
else begin
if(per_frame_clken)
row3_data <= per_img_Y ;
else
row3_data <= row3_data ;
end
end
//用于存储列数据的RAM
line_shift_RAM_8bit u_Line_Shift_RAM_8Bit
(
.clock (clk),
.clken (per_frame_clken),
.per_frame_href (per_frame_href),
.shiftin (per_img_Y), //当前行的数据
.taps0x (row2_data), //前一行的数据
.taps1x (row1_data) //前前一行的数据
);
//将同步信号延迟两拍，用于同步化处理
always@(posedge clk or negedge rst_n) begin
if(!rst_n) begin
per_frame_vsync_r <= 0;
per_frame_href_r <= 0;
per_frame_clken_r <= 0;
end
else begin
per_frame_vsync_r <= { per_frame_vsync_r[0], per_frame_vsync };
per_frame_href_r <= { per_frame_href_r[0], per_frame_href };
per_frame_clken_r <= { per_frame_clken_r[0], per_frame_clken };
end
end
//在同步处理后的控制信号下，输出图像矩阵
always@(posedge clk or negedge rst_n) begin
if(!rst_n) begin
{matrix_p11, matrix_p12, matrix_p13} <= 24'h0;
{matrix_p21, matrix_p22, matrix_p23} <= 24'h0;
{matrix_p31, matrix_p32, matrix_p33} <= 24'h0;
end
else if(read_frame_href) begin
if(read_frame_clken) begin
{matrix_p11, matrix_p12, matrix_p13} <= {matrix_p12, matrix_p13, row1_data};
{matrix_p21, matrix_p22, matrix_p23} <= {matrix_p22, matrix_p23, row2_data};
{matrix_p31, matrix_p32, matrix_p33} <= {matrix_p32, matrix_p33, row3_data};
end
else begin
{matrix_p11, matrix_p12, matrix_p13} <= {matrix_p11, matrix_p12, matrix_p13};
{matrix_p21, matrix_p22, matrix_p23} <= {matrix_p21, matrix_p22, matrix_p23};
{matrix_p31, matrix_p32, matrix_p33} <= {matrix_p31, matrix_p32, matrix_p33};
end
end
else begin
{matrix_p11, matrix_p12, matrix_p13} <= 24'h0;
{matrix_p21, matrix_p22, matrix_p23} <= 24'h0;
{matrix_p31, matrix_p32, matrix_p33} <= 24'h0;
end
end
endmodule

复制代码

为了获得3x3的滤波模板，我们需要使用RAM来存储图像前两行的数据，而当前输入的图像数据作为第三行，如代码中第55行所示。而在代码的第61至71行，当第三行数据到达时，我们通过调用line_shift_RAM_8bit模块，读出寄存在RAM中的前两行数据，从而获得一个“三行一列”的像素数据。三行数据分别位于row1_data、row2_data和row3_data三个变量中，其中row3_data表示当前行（第三行）图像数据。

接下来，我们将“三行一列”的像素数据，连续寄存三次，从而获取一个“三行三列”的像素阵列，如代码中的第96至98行所示。其中，matrix_p11、matrix_p12、 matrix_p13代表阵列中第一行中的三列像素数据，而matrix_p21、matrix_p22、matrix_p23代表阵列中第二行中的三列像素数据，以此类推。这个“三行三列”的矩阵就是我们所需要的3x3模板。

前面获取“三行一列”和获取“三行三列”的操作分别需要一个时钟周期，即该模块生成3x3模板共消耗两个时钟周期。因此，我们要对场有效信号、数据有效信号和时钟使能信号延迟两个周期以作同步，如代码第81至83行所示。

代码的第62行调用了“line_shift_RAM_8bit”模块，其代码如下：

module line_shift_RAM_8bit(
input clock,
input clken,
input per_frame_href,
input [7:0] shiftin, //当前行的数据
output [7:0] taps0x, //前一行的数据
output [7:0] taps1x //前前一行的数据
);
//reg define
reg [2:0] clken_dly;
reg [9:0] ram_rd_addr;
reg [9:0] ram_rd_addr_d0;
reg [9:0] ram_rd_addr_d1;
reg [7:0] shiftin_d0;
reg [7:0] shiftin_d1;
reg [7:0] shiftin_d2;
reg [7:0] taps0x_d0;
//*****************************************************
//** main code
//*****************************************************
//在数据到来时，RAM的读地址累加
always@(posedge clock)begin
if(per_frame_href)
if(clken)
ram_rd_addr <= ram_rd_addr + 1 ;
else
ram_rd_addr <= ram_rd_addr ;
else
ram_rd_addr <= 0 ;
end
//对时钟使能信号延迟3拍
always@(posedge clock) begin
clken_dly <= { clken_dly[1:0] , clken };
end
//将RAM地址延迟2拍
always@(posedge clock ) begin
ram_rd_addr_d0 <= ram_rd_addr;
ram_rd_addr_d1 <= ram_rd_addr_d0;
end
//输入数据延迟3拍送入RAM
always@(posedge clock)begin
shiftin_d0 <= shiftin;
shiftin_d1 <= shiftin_d0;
shiftin_d2 <= shiftin_d1;
end
//用于存储前一行图像的RAM
blk_mem_gen_0 u_ram_1024x8_0(
.clka (clock),
.wea (clken_dly[2]),
.addra (ram_rd_addr_d1), //在延迟的第三个时钟周期，当前行的数据写入RAM0
.dina (shiftin_d2),
.clkb (clock),
.addrb (ram_rd_addr),
.doutb (taps0x) //延迟一个时钟周期，输出RAM0中前一行图像的数据
);
//寄存前一行图像的数据
always@(posedge clock)begin
taps0x_d0 <= taps0x;
end
//用于存储前前一行图像的RAM
blk_mem_gen_0 u_ram_1024x8_1(
.clka (clock),
.wea (clken_dly[1]),
.addra (ram_rd_addr_d0),
.dina (taps0x_d0), //在延迟的第二个时钟周期，将前一行图像的数据写入RAM1
.clkb (clock),
.addrb (ram_rd_addr),
.doutb (taps1x) //延迟一个时钟周期，输出RAM1中前前一行图像的数据
);
endmodule

复制代码

line_shift_RAM_8bit模块中例化了两个RAM，分别用于存储图像前两行的数据。

在上述代码中，当数据有效信号和时钟使能信号同时为高时，RAM地址开始累加，如代码第26到35行所示。由于RAM地址在per_frame_href信号为低电平时清零；而当新的一行到达时，per_frame_href信号为高电平，RAM地址开始累加，所以RAM的地址等于每行图像像素的横坐标。因此我们就可以根据RAM地址从而读出当前行像素点对应的前两行的图像，如代码的第63和64行，以及80和81行所示。读出的数据直接传递到模块的输出端口，用于上层模块生成“三行一列”的像素数据。

在该模块中，RAM1（u_ram_1024x8_1）中存储的是第一行（前前一行）的数据，RAM0（u_ram_1024x8_0）中存储的是第二行（前一行）的数据，而输入的图像数据则作为第三行。如下图所示：

图 24.3.4 RAM中存储的两行图

在读出两个RAM中前两行的图像数据之后，我们还要将RAM0中的数据写入RAM1，如代码中第76和77行所示；然后将新行图像数据写入RAM0，如代码第59和60行所示，从而不断更新两个RAM中的图像数据。

从RAM中读取数据，以及向RAM1和RAM0中更新数据各需要花费一个时钟周期，因此我们在代码的第37至40行将输入的clken信号延时了三个时钟周期。并使用延迟之后的clken信号作为两个RAM中的写使能信号，如代码的第75和58行所示。

在模块中我们例化了两个伪双端RAM（一个端口只能读，一个端口只能写），用于存储两行图像，以生成图像矩阵的列数据。下面我们简单介绍一下如何调用并配置这两个RAM IP核。

首先在左侧“FlowNavigater”下点击“IP Catalog”，再在右侧弹出的界面宽内输入“ram”，选择“Block Memory Generator”并双击打开，进入RAM配置界面。

图 24.3.5 RAM选择界面

接下来进入RAM配置界面，如下图所示：

图 24.3.6 RAM配置界面

在“Basic”页面，我们将name一栏设置为“blk_mem_gen_0”，RAM类型设为“Simple Dual Port RAM”，即伪双端口类型，如上图红色标注部分。

接着就是“Port AOptions”页面的配置，如下图所示：

图 24.3.7 Port A Options配置

Port A端口用于向RAM中写入数据。如上图所示，我们将RAM的位宽设置为8，深度设置为1024，操作模式设置为先写模式，写使能设置为时钟使能。如上图红色标记部分。

接着配置“Port BOptions”页面，Port B端口用于从RAM中读取数据。同样的，将位宽设置为8，深度设置为1024，操作模式设置为先写模式，写使能设置为始终使能，同时选择“Primitives Output Register”输出寄存选项（RAM中的数据会寄存一个周期后输出）。如下图所示：

图 24.3.8 Port B Options页面配置

到这里我们RAM的配置基本完成，后面两项保持默认即可，最后生成IP核就完成了RAM的设置。

前面我们已经生成了3x3的矩阵，接着就是求3x3矩阵的中值，中值算法模块的代码如下：

module median_3x3(
input clk,
input rst_n,
input median_frame_vsync,
input median_frame_href,
input median_frame_clken,
input [7:0 data11,
input [7:0 data12,
input [7:0 data13,
input [7:0 data21,
input [7:0 data22,
input [7:0 data23,
input [7:0 data31,
input [7:0 data32,
input [7:0 data33,
output [7:0 target_data,
output pos_frame_vsync,
output pos_frame_href,
output pos_frame_clken
);
//--------------------------------------------------------------------------------------
//FPGA Median Filter Sortorder
// Pixel -- Sort1 -- Sort2 -- Sort3
// [ P1 P2 P3] [ Max1 Mid1 Min1 ]
// [ P4 P5 P6] [ Max2 Mid2 Min2 ] [Max_min, Mid_mid, Min_max] mid_valid
// [ P7 P8 P9] [ Max3 Mid3 Min3 ]
//reg define
reg [2:0 median_frame_vsync_r;
reg [2:0 median_frame_href_r;
reg [2:0 median_frame_clken_r;
wire [7:0 max_data1;
wire [7:0 mid_data1;
wire [7:0 min_data1;
wire [7:0 max_data2;
wire [7:0 mid_data2;
wire [7:0 min_data2;
wire [7:0 max_data3;
wire [7:0 mid_data3;
wire [7:0 min_data3;
wire [7:0 max_min_data;
wire [7:0 mid_mid_data;
wire [7:0 min_max_data;
//*****************************************************
//** main code
//*****************************************************
assign pos_frame_vsync = median_frame_vsync_r[2];
assign pos_frame_href = median_frame_href_r[2];
assign pos_frame_clken = median_frame_clken_r[2];
//Step1 对stor3进行三次例化操作
Sort3 u_Sort3_1( //第一行数据排序
.clk (clk),
.rst_n (rst_n),
.data1 (data11),
.data2 (data12),
.data3 (data13),
.max_data (max_data1),
.mid_data (mid_data1),
.min_data (min_data1)
);
Sort3 u_Sort3_2( //第二行数据排序
.clk (clk),
.rst_n (rst_n),
.data1 (data21),
.data2 (data22),
.data3 (data23),
.max_data (max_data2),
.mid_data (mid_data2),
.min_data (min_data2)
);
Sort3 u_Sort3_3( //第三行数据排序
.clk (clk),
.rst_n (rst_n),
.data1 (data31),
.data2 (data32),
.data3 (data33),
.max_data (max_data3),
.mid_data (mid_data3),
.min_data (min_data3)
);
//Step2 对三行像素取得的排序进行处理
Sort3 u_Sort3_4( //取三行最大值的最小值
.clk (clk),
.rst_n (rst_n),
.data1 (max_data1),
.data2 (max_data2),
.data3 (max_data3),
.max_data (),
.mid_data (),
.min_data (max_min_data)
);
Sort3 u_Sort3_5( //取三行中值的最小值
.clk (clk),
.rst_n (rst_n),
.data1 (mid_data1),
.data2 (mid_data2),
.data3 (mid_data3),
.max_data (),
.mid_data (mid_mid_data),
.min_data ()
);
Sort3 u_Sort3_6( //取三行最小值的最大值
.clk (clk),
.rst_n (rst_n),
.data1 (min_data1),
.data2 (min_data2),
.data3 (min_data3),
.max_data (min_max_data),
.mid_data (),
.min_data ()
);
//step3 将step2中得到的三个值，再次取中值
Sort3 u_Sort3_7(
.clk (clk),
.rst_n (rst_n),
.data1 (max_min_data),
.data2 (mid_mid_data),
.data3 (min_max_data),
.max_data (),
.mid_data (target_data),
.min_data ()
);
//延迟三个周期进行同步
always@(posedge clk or negedge rst_n)begin
if(!rst_n)begin
median_frame_vsync_r <= 0;
median_frame_href_r <= 0;
median_frame_clken_r <= 0;
end
else begin
median_frame_vsync_r <= {median_frame_vsync_r[1:0],median_frame_vsync};
median_frame_href_r <= {median_frame_href_r [1:0], median_frame_href};
median_frame_clken_r <= {median_frame_clken_r[1:0],median_frame_clken};
end
end
endmodule

复制代码

在median_3x3模块实现了简介中所介绍的取中值的快速算法，如下图所示：

图 24.3.9 取中值快速算法

图 27.3.9中所示的算法在模块中的实现共分为三步：第一步（step1），我们例化了三次stor3模块，用以对矩阵的每一行数据进行排序，分别求出矩阵每一行的最小值、中值和最大值，如程序第58到96行；第二步（step2），再例化三次stor3模块，与之前不同的是，我们此处stor3模块的输入是step1得到的三行数据每一行的三个最小值、三个中值和三个最大值，并输出三个最小值的最大值，三个中值的中间值以及三个最大值的最小值，如代码第98到136行；第三步（step3），再次例化sort3，并以step2中得到的三个最小值、中值及最大值作为输入，取三个值的中值，如代码第138行到150行。

经过以上三步排序操作，我们就能得到一个像素在其8邻域模板上的中值。由于在求得中之过程中，step1、step2和step3一共需要消耗三个时钟周期，一次我们需要将median_frame_vsync、median_frame_href和median_frame_clken三个信号延迟三个时钟周期以作同步，如代码第152到164行。

在median_filter模块我们多次调用了Sort3模块，Sort3模块是一个针对三个数据进行排序操作的模块，它的代码如下：

module Sort3(
input clk,
input rst_n,
input [7:0 data1,
input [7:0 data2,
input [7:0 data3,
output reg [7:0 max_data,
output reg [7:0 mid_data,
output reg [7:0 min_data
);
//-----------------------------------
//对三个数据进行排序
always@(posedge clk or negedge rst_n)begin
if(!rst_n)begin
max_data <= 0;
mid_data <= 0;
min_data <= 0;
end
else begin
//取最大值
if(data1 >= data2 && data1 >= data3)
max_data <= data1;
else if(data2 >= data1 && data2 >= data3)
max_data <= data2;
else//(data3>= data1 && data3 >= data2)
max_data <= data3;
//取中值
if((data1 >= data2 && data1 <= data3) || (data1 >= data3 && data1 <= data2))
mid_data <= data1;
else if((data2 >= data1 && data2 <= data3) || (data2 >= data3 && data2 <= data1))
mid_data <= data2;
else//((data3>= data1 && data3 <= data2) || (data3 >= data2 &&data3 <= data1))
mid_data <= data3;
//取最小值
if(data1 <= data2 && data1 <= data3)
min_data <= data1;
else if(data2 <= data1 && data2 <= data3)
min_data <= data2;
else//(data3<= data1 && data3 <= data2)
min_data <= data3;
end
end
endmodule

复制代码

上述代码实现了对三个数的排序，如代码第22到28行，取三个数的最大值；如第29到35行，取三个数的中值；如代码第36到42行，取三个数的最小值。

我们对模块median_3x3进行中值提取的结果进行了仿真，仿真结果如下图所示：

图 24.3.10 中值滤波仿真图

如上图所示，红色标记部分，矩阵的三行数据分别为{99，138，30}、{138，30，69}和{30，69，108}按本文中所介绍的中值滤波算法可以求得中值为69。由于median_filter模块的中值提取操作共消耗了三个时钟周期，所以中值（mid_value）会在三个时钟周期后输出，上图仿真结果图也表明中值是在三个周期后输出。如图中红色圆圈所指示，模块输出的中值也是69，与我们计算的相同，这说明中值提取成功。

到这里，我们的VIP模块就介绍完了，我们要将模块打包成IP并添加到工程的IP库中，方便在BlockDesign中进行调用。连线后的 Block Design 如下图所示：

图 24.3.11 Block Design整体框图

接下来验证当前设计。验证完成后弹出对话框提示没有错误或者关键警告，点击“OK”。如果验证结果报出错误或者警告，则需要重新检查设计。为工程添加的约束文件与“OV5640摄像头LCD显示”完全相同，有关这一部分内容请读者参考“OV5640摄像头LCD显示”实验。

最后在左侧 FlowNavigator 导航栏中找到 PROGRAM AND DEBUG，点击该选项中的“Generate
Bitstream”，对设计进行综合、实现、并生成 Bitstream文件。在生成Bitstream之后，在菜单栏中选择File > Export> Export hardware导出硬件，并在弹出的对话框中，勾选“Include bitstream”。然后在菜单栏选择File > LaunchSDK，启动SDK软件。

1.4 软件设计

本实验软件设计与“OV5640摄像头LCD显示”实验相同，大家可参考“OV5640摄像头LCD显示”实验软件设计部分，本章就不再赘述。

1.5 下载验证

“OLED/CAMERA”插座上，并将 HDMI 电缆一端连接到开发板上的 HDMI 插座、另一端连接到显器。将下载器一端连电脑，另一端与开发板上的 JTAG 端口连接，连接电源线并打开电源开关。在 SDK 软件下方的 SDK Terminal 窗口中点击右上角的加号设置并连接串口。然后下载本次实验硬件设计过程中所生成的 BIT 文件，来对 PL 进行配置。最后下载软件程序，下载完成后，在下方的 SDK Terminal中可以看到应用程序打印的信息，如下图所示：

图 24.5.1 中值滤波实验串口打印信息

下载完成后，我们可以看到LCD屏上的灰度图像。我们可以看到中值滤波处理后的图像与原图几乎没有差别，这是因为现如今的彩色摄像头的采集的图像质量都很高，含有的干扰很少，因此在中值滤波前后图像差别不明显，中值滤波结果可以用仿真来验证。

图 24.5.2 LCD显示中值滤波灰度图

帐号		自动登录	找回密码
密码			立即注册

[XILINX] 【正点原子FPGA连载】第二十五章基于OV5640的中值滤波实验--摘自【正点原子】领航者ZYNQ之嵌入式开发指南_V1.2

相关帖子

原子哥极力推荐 /2

[XILINX] 【正点原子FPGA连载】第二十五章 基于OV5640的中值滤波实验--摘自【正点原子】领航者ZYNQ之嵌入式开发指南_V1.2

相关帖子

原子哥极力推荐 /2

[XILINX] 【正点原子FPGA连载】第二十五章基于OV5640的中值滤波实验--摘自【正点原子】领航者ZYNQ之嵌入式开发指南_V1.2