【正点原子FPGA连载】第五十五章双目OV5640摄像头RGB-LCD显示实验--摘自【正点原子】超越者之FPGA开发指南

正点原子运营 · 发表于 2021-1-27 11:39:37

本帖最后由正点原子运营于 2021-1-27 17:18 编辑

1）实验平台：正点原子超越者FPGA开发板
2）平台购买地址：https://item.taobao.com/item.htm?&id=631660290421
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/fpga/zdyz-chaoyuezhe.html

4）本章实例源码下载：

48_dual_ov5640_lcd.rar (8.27 MB, 下载次数: 10)

2021-1-27 17:16 上传

点击文件名下载附件

5）正点原子FPGA交流群：905624739点击加入：

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

第五十五章双目OV5640摄像头RGB-LCD显示实验

双目摄像头是在一个模组上集成了两个摄像头，实现双通道图像采集的功能。双目摄像头一般应用于安防监控、立体视觉测距、三维重建等领域。本试验只做最基础的工作，把双目OV5640摄像头实时采集到的图像分左右两半显示在LCD屏幕上。
本章包括以下几个部分：
5555.1  简介
55.2  实验任务
55.3  硬件设计
55.4  程序设计
55.5  下载验证

55.1简介
摄像头在日常生活中非常常见，一般分为单目摄像头、双目摄像头和多目摄像头。单目摄像头目前使用最为广泛；双目摄像头主要应用于单目摄像头无法胜任的场合，如测距领域，根据两个摄像头的视差，辅以一定的算法，人们可以计算物体的距离；当然针对一些特殊的应用，目前市场上也出现了多目摄像头，以应对更加复杂的场景。在“OV5640摄像头LCD显示实验”中对OV5640的视频传输时序、SCCB协议以及寄存器的配置信息等内容作了详细的介绍，如果大家对这部分内容不是很熟悉的话，请参考之前的实验。本次实验将在前面单目OV5640摄像头的基础上学习双目摄像头的LCD显示。
55.2实验任务
本章实验任务是利用双目OV5640摄像头采集图像，将采集到的图像实时显示在LCD屏幕上，两幅图像分别占据LCD屏的左右半边。
55.3硬件设计
超越者开发板上有两个扩展口，分别是J1和J2。超越者开发板的J1扩展口与LCD屏的管脚复用，故本次实验采用J2扩展口来连接双目OV5640摄像头。J2扩展口原理图如图 55.3.1所示：

图 55.3.1 摄像头扩展接口原理图

ATK-Dual-OV5640是正点原子推出的一款双目OV5640摄像头模块，其硬件原理图如下图所示：

图 55.3.2 ATK-Dual-OV5640原理图

该模块通过2*20排母（2.54mm间距）同外部连接，连接时将双目摄像头的排母直接插在开发板上的J2扩展口即可，模块实物连接图如图 55.3.3所示：

图 55.3.3 双目摄像头模块实物连接图

由于LCD接口和DDR3引脚数目较多且在前面相应的章节中已经给出它们的管脚列表，这里只列出双目摄像头相关管脚分配，如下表所示：
表 55.3.1 双目OV5640摄像头管脚分配

双目摄像头UCF约束文件如下：

##########J2_摄像头2管脚分配#############
NET cam_scl_2 LOC = K12 | IOSTANDARD = "LVCMOS33";
NET cam_sda_2 LOC = L14 | IOSTANDARD = "LVCMOS33";
NET cam_pclk_2 LOC = R12 | IOSTANDARD = "LVCMOS33" | TNM_NET = cam_pclk_2_pin ;
TIMESPEC TS_cam_pclk_2_pin = PERIOD cam_pclk_2_pin 24000 kHz;
NET "cam_pclk_2" CLOCK_DEDICATED_ROUTE = TRUE;
NET cam_vsync_2 LOC = M13 | IOSTANDARD = "LVCMOS33";
NET cam_href_2 LOC = J13 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[7] LOC = J11 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[6] LOC = R14 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[5] LOC = P15 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[4] LOC = H15 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[3] LOC = H16 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[2] LOC = M14 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[1] LOC = N14 | IOSTANDARD = "LVCMOS33";
NET cam_data_2[0] LOC = L13 | IOSTANDARD = "LVCMOS33";
NET cam_pwdn_2 LOC = J12 | IOSTANDARD = "LVCMOS33";
NET cam_rst_n_2 LOC = L12 | IOSTANDARD = "LVCMOS33";
#########J2_摄像头1管脚分配#############
NET cam_scl_1 LOC = E8 | IOSTANDARD = "LVCMOS33";
NET cam_sda_1 LOC = P11 | IOSTANDARD = "LVCMOS33";
NET cam_pclk_1 LOC = F13 | IOSTANDARD = "LVCMOS33" | TNM_NET = cam_pclk_1_pin ;
TIMESPEC TS_cam_pclk_1_pin = PERIOD cam_pclk_1_pin 24000 kHz;
NET "cam_pclk_1" CLOCK_DEDICATED_ROUTE = TRUE;
NET cam_vsync_1 LOC = E7 | IOSTANDARD = "LVCMOS33";
NET cam_href_1 LOC = C8 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[7] LOC = H13 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[6] LOC = G12 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[5] LOC = H11 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[4] LOC = D12 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[3] LOC = D11 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[2] LOC = E10 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[1] LOC = D9 | IOSTANDARD = "LVCMOS33";
NET cam_data_1[0] LOC = C10 | IOSTANDARD = "LVCMOS33";
NET cam_pwdn_1 LOC = K11 | IOSTANDARD = "LVCMOS33";
NET cam_rst_n_1 LOC = F9 | IOSTANDARD = "LVCMOS33";

复制代码

55.4程序设计
根据实验任务，可以设计出如图 38.4.1所示的系统框图。本章实验的系统框架延续了“OV5640摄像头RGB-LCD显示实验”的整体架构，包括以下模块：时钟模块、图像分辨率设置模块、DDR控制器模块、摄像头驱动模块和LCD顶层模块。其中时钟模块、图像分辨率设置模块和摄像头驱动模块没有做任何修改，这些模块在“OV5640摄像头RGB-LCD显示实验”中已经说明过，这里不再赘述，本次实验对DDR控制模块和LCD顶层模块做了修改。
系统框图如下图所示：

图 55.4.1 顶层系统框图

由上图可知，时钟模块（pll）为LCD顶层模块、图像分辨率设置模块、DDR控制模块以及OV5640驱动模块提供驱动时钟，OV5640驱动模块控制着传感器初始化的开始与结束。传感器初始化完成后图像采集模块将采集到的数据写入DDR控制模块，LCD顶层模块从DDR控制模块中读出数据，完成了数据的采集、缓存与显示。需要注意的是图像数据采集模块是在DDR3和传感器都初始化完成之后才开始输出数据的，避免了在DDR3初始化过程中向里面写入数据。
时钟模块（pll）：时钟模块通过调用PLL IP核实现，共输出3个时钟，频率分别为300Mhz、50Mhz时钟和100Mhz时钟。300Mhz时钟作为DDR控制模块的运行时钟；100Mhz时钟作为DDR控制模块的驱动时钟和LCD顶层模块输出时钟的源时钟；50Mhz时钟作为OV5640驱动模块和LCD顶层模块的驱动时钟。
OV5640驱动模块（ov5640_dri）：OV5640驱动模块负责驱动OV5640 SCCB接口总线，将像素时钟驱动下的传感器输出的场同步信号、行同步信号以及8位数据转换成DDR读写控制模块的写使能信号和16位写数据信号，完成对OV5640传感器图像的采集。
DDR控制模块（ddr3_control）：DDR读写控制器模块负责驱动DDR片外存储器，缓存图像传感器输出的图像数据。该模块将MIG IP核复杂的读写操作封装成类似FIFO的用户接口，非常方便用户的使用。
LCD顶层模块（lcd_rgb_top）：LCD顶层模块负责驱动LCD屏的驱动信号的输出，同时为其他模块提供屏体参数、场同步信号和数据请求信号。有关LCD驱动模块的详细介绍请大家参考“OV7725摄像头RGB-LCD显示实验”章节。
本次实验是在“OV5640摄像头RGB-LCD显示实验”的基础上作修改，主要修改了DDR控制模块和LCD顶层模块，而其余模块基本相同，因此接下来只介绍DDR控制模块和LCD顶层模块。前面的实验，使用读写各一个FIFO，并在DDR3中开辟了四个缓冲区，而本实验有两个摄像头，所以读写需要各增加一个FIFO，总共四个，同时在从DDR3中再开辟了四个缓冲区，达到八个缓冲区，而满足两组摄像头数据的处理需要。
下面就顶层模块与“OV5640摄像头RGB-LCD显示实验”的顶层代码的改动的部分做介绍。

98 //ov5640 驱动
99 ov5640_dri u_ov5640_dri_1(
100 .clk (clk_50m)，
101 .rst_n (rst_n)，
102
103 .cam_pclk (cam_pclk_1)，
104 .cam_vsync (cam_vsync_1)，
105 .cam_href (cam_href_1 )，
106 .cam_data (cam_data_1 )，
107 .cam_rst_n (cam_rst_n_1)，
108 .cam_pwdn (cam_pwdn_1)，
109 .cam_scl (cam_scl_1 )，
110 .cam_sda (cam_sda_1 )，
111
112 .capture_start (init_calib_complete)，
113 .cmos_h_pixel (cmos_h_pixel[10:1])，
114 .cmos_v_pixel (cmos_v_pixel)，
115 .total_h_pixel (total_h_pixel)，
116 .total_v_pixel (total_v_pixel)，
117 .cmos_frame_vsync (cmos_frame_vsync_1)，
118 .cmos_frame_href ()，
119 .cmos_frame_valid (cmos_frame_valid_1)，
120 .cmos_frame_data (wr_data_1)
121 );
122
123 //ov5640 驱动
124 ov5640_dri u_ov5640_dri_2(
125 .clk (clk_50m)，
126 .rst_n (rst_n)，
127
128 .cam_pclk (cam_pclk_2 )，
129 .cam_vsync (cam_vsync_2)，
130 .cam_href (cam_href_2 )，
131 .cam_data (cam_data_2)，
132 .cam_rst_n (cam_rst_n_2)，
133 .cam_pwdn (cam_pwdn_2 )，
134 .cam_scl (cam_scl_2 )，
135 .cam_sda (cam_sda_2 )，
136
137 .capture_start (init_calib_complete)，
138 .cmos_h_pixel (cmos_h_pixel[10:1])，
139 .cmos_v_pixel (cmos_v_pixel)，
140 .total_h_pixel (total_h_pixel)，
141 .total_v_pixel (total_v_pixel)，
142 .cmos_frame_vsync (cmos_frame_vsync_2)，
143 .cmos_frame_href ()，
144 .cmos_frame_valid (cmos_frame_valid_2)，
145 .cmos_frame_data (wr_data_2)
146 );
这段代码是对OV5640驱动模块的一个顶层例化，负责驱动OV5640外设，采集图像等作用。因为本次实验用的是双目摄像头，所以顶层需要例化两次。
在程序的第103行至第110行和第128至第135行，这几行的信号都是与外设OV5640相连的，负责驱动摄像头。
在程序的第112行和137行，这个信号的作用是保证OV5640驱动模块在DDR3初始化没有完成之前不会对图像进行采集。
在程序的第113行至第116行和第138行至第141行，这四个信号是摄像头配置时需要的参数，使摄像头输出本次实验需要的行场分辨率和计算帧率的相关参数。在113行和138行将LCD屏的行分辨率除以2的原因是本次实验用的是双目摄像头，最终显示的效果是将双目OV5640摄像头实时采集到的图像分左右两半显示在LCD屏幕上，故摄像头需要采集的图像的行分辨率是LCD屏的行分辨率一半，场分辨率两者是相同的。
在程序的第119行至第120行和第144行至第145行，OV5640驱动模块输出的数据有效使能信号和有效数据连接到DDR控制模块，实现了图像数据的缓存。
148 //ddr控制器
149 ddr3_control
150 #(
151 .C3_NUM_DQ_PINS (16)，
152 .C3_MEM_ADDR_WIDTH (14)，
153 .C3_MEM_BANKADDR_WIDTH (3)
154 )
155 u_ddr3_control(
156 .clk_ddr (clk_ddr)，
157 .clk_100m (clk_100m)，
158 .rst_n (sys_rst_n)，
159 .mcb3_dram_dq (mcb3_dram_dq )，
160 .mcb3_dram_a (mcb3_dram_a )，
161 .mcb3_dram_ba (mcb3_dram_ba )，
162 .mcb3_dram_ras_n (mcb3_dram_ras_n )，
163 .mcb3_dram_cas_n (mcb3_dram_cas_n )，
164 .mcb3_dram_we_n (mcb3_dram_we_n )，
165 .mcb3_dram_reset_n (mcb3_dram_reset_n)，
166 .mcb3_dram_cke (mcb3_dram_cke )，
167 .mcb3_dram_dm (mcb3_dram_dm )，
168 .mcb3_dram_udqs (mcb3_dram_udqs )，
169 .mcb3_dram_udqs_n (mcb3_dram_udqs_n )，
170 .mcb3_rzq (mcb3_rzq )，
171 .mcb3_zio (mcb3_zio )，
172 .mcb3_dram_udm (mcb3_dram_udm )，
173 .mcb3_dram_dqs (mcb3_dram_dqs )，
174 .mcb3_dram_dqs_n (mcb3_dram_dqs_n )，
175 .mcb3_dram_ck (mcb3_dram_ck )，
176 .mcb3_dram_ck_n (mcb3_dram_ck_n )，
177 .c3_calib_done (init_calib_complete)，
178
179 .ddr3_read_valid (1'b1 )，
180 .ddr3_pingpang_en (1'b1)，
181
182 //摄像头1
183 .clk_write_1 (cam_pclk_1)， //写时钟
184 .wr_en_1 (cmos_frame_valid_1)， //写使能
185 .wr_data_1 (wr_data_1)， //写数据
186 .wr_load_1 (cmos_frame_vsync_1)， //写端更新信号
187 .wr_length_1 (cmos_h_pixel[10:4])， //一次写长度
188 .wr_max_addr_1 (ddr3_addr_max[26:1])， //写最大地址
189 .wr_min_addr_1 (0)， //写最小地址
190
191 //摄像头2
192 .clk_write_2 (cam_pclk_2)， //写时钟
193 .wr_en_2 (cmos_frame_valid_2)， //写使能
194 .wr_data_2 (wr_data_2)， //写数据
195 .wr_load_2 (cmos_frame_vsync_2)， //写端更新信号
196 .wr_length_2 (cmos_h_pixel[10:4])， //一次写长度
197 .wr_max_addr_2 (ddr3_addr_max[26:1])， //写最大地址
198 .wr_min_addr_2 (0)， //写最小地址
199
200 .clk_read (lcd_clk)， //读时钟
201 .rd_en (rdata_req)， //读使能
202 .rd_load (out_vsync)， //读端更新信号
203 .rd_max_addr (ddr3_addr_max[26:1])， //读最大地址
204 .rd_min_addr (0)， //读最小地址
205 .rd_length (cmos_h_pixel[10:4])， //一次读长度
206 .h_disp (cmos_h_pixel)， //行分辨率
207 .rd_data (rd_data) //读数据
208
209 );

复制代码

在程序的第188行、197行和第203行，本次实验摄像头采集的图像的行分辨率只有LCD屏的一半，场分辨率是相同的，故最大读写地址信号（ddr3_addr_max）必须要除以二才是最后存到DDR的最大读写地址，但代码中将最低一位舍去，相当于信号右移一位，等同于除以二。
在程序的第187行、196行和第205行，表示一次向DDR3读或写的长度，因为输入DDR3顶层模块的数据和从DDR3顶层模块输出的数据都为16bit，而MIG的数据位宽为128bit，所以一次写一行或读一行的长度是LCD屏水平分辨率的一半除以8（128bit/16bit），这里将LCD屏水平分辨率的低四位舍去，相当于信号右移四位，等同于除以16。
本次实验的时钟模块、摄像头驱动模块、图像分辨率设置模块和摄像头驱动模块没有做任何修改，这些模块在“OV5640摄像头RGB-LCD显示实验”中已经说明过，这里不再赘述。本次实验只对DDR控制模块和LCD顶层模块做了修改，本次实验着重讲解这两个模块。下面是DDR控制模块的系统框图：

图 55.4.2 DDR控制模块的系统框图

结合图可以看出相较于“OV5640摄像头RGB-LCD显示实验”，本次实验将FIFO调度模块替换成了FIFO顶层调度模块。本次实验是两个摄像头采集数据并且把数据存入两个写FIFO，两个写FIFO再将数据写入DDR3的两个不同的存储空间中，接着两个读FIFO分别从两个对应的DDR3地址空间中取出数据，最后两组数据一起拼接为完整一帧LCD图像，达到一个屏幕同时显示两幅图像的效果。在DDR3处理数据的时候，两组数据流相当于过独木桥，需要分时“排队”进出；同样在显示端，两组数据也要“排队”显示，所以本次实验的FIFO顶层调度模块的作用就是根据不同的情况对两个FIFO调度模块的信号进行切换。
DDR读写模块：该模块负责与MIG模块的命令和地址的交互，根据FIFO顶层调度模块中各个FIFO的剩余数据量来切换DDR3的读写命令和地址。
MIG模块：MIG模块(ddr3)负责连接外设和FPGA，详细说明请看“DDR3读写测试实验”。
FIFO顶层调度模块：负责对输入和输出的数据进行时钟域的切换和位宽的转换，并根据DDR读写模块输出的使能来调度四个FIFO的数据。
下面是DDR控制模块的代码：

1 module ddr3_control
2 #(
3 parameter C3_NUM_DQ_PINS = 16，
4 // External memory data width
5 parameter C3_MEM_ADDR_WIDTH = 13，
6 // External memory address width
7 parameter C3_MEM_BANKADDR_WIDTH = 3
8 // External memory bank address width
9 )
10 (
11 input clk_ddr， //ddr3输入时钟
12 input clk_100m， //输入时钟
13 input rst_n， //系统复位，低电平有效
14 //ddr3 port
15 inout [C3_NUM_DQ_PINS-1:0] mcb3_dram_dq，
16 output [C3_MEM_ADDR_WIDTH-1:0] mcb3_dram_a，
17 output [C3_MEM_BANKADDR_WIDTH-1:0] mcb3_dram_ba，
18 output mcb3_dram_ras_n，
19 output mcb3_dram_cas_n，
20 output mcb3_dram_we_n，
21 output mcb3_dram_reset_n，
22 output mcb3_dram_cke，
23 output mcb3_dram_dm，
24 inout mcb3_dram_udqs，
25 inout mcb3_dram_udqs_n，
26 inout mcb3_rzq，
27 inout mcb3_zio，
28 output mcb3_dram_udm，
29 inout mcb3_dram_dqs，
30 inout mcb3_dram_dqs_n，
31 output mcb3_dram_ck，
32 output mcb3_dram_ck_n，
33
34 output c3_calib_done， //ddr3初始化成功标志
35 input ddr3_read_valid， //ddr3读使能
36 input ddr3_pingpang_en， //ddr3乒乓操作使能
37
38 //write1
39 input clk_write_1， //写操作时钟
40 input wr_en_1， //写使能
41 input [15:0] wr_data_1， //写数据
42 input wr_load_1， //写端更新信号
43 input [29:0] wr_max_addr_1， //写最大地址
44 input [29:0] wr_min_addr_1， //写最小地址
45 input [9:0] wr_length_1， //一次写长度
46 //write2
47 input clk_write_2， //写操作时钟
48 input wr_en_2， //写使能
49 input [15:0] wr_data_2， //写数据
50 input wr_load_2， //写端更新信号
51 input [29:0] wr_max_addr_2， //写最大地址
52 input [29:0] wr_min_addr_2， //写最小地址
53 input [9:0] wr_length_2， //一次写长度
54 //read
55 input clk_read， //读操作时钟
56 input rd_en， //读使能
57 input rd_load， //读端更新信号
58 input [29:0] rd_max_addr， //读最大地址
59 input [29:0] rd_min_addr， //读最小地址
60 input [9:0] rd_length， //一次读长度
61 input [10:0] h_disp， //行分辨率
62 output [15:0] rd_data //读数据
63 );
64
65 //wire define
66 wire c3_p0_cmd_en; //P0端命令使能
67 wire [2:0] c3_p0_cmd_instr; //P0端命令输入
68 wire [5:0] c3_p0_cmd_bl; //P0端数据突发长度
69 wire [29:0] c3_p0_cmd_byte_addr; //P0端数据地址
70 wire c3_p0_wr_en; //P0端写数据使能
71 wire [7:0] c3_p0_wr_mask; //P0端写数据掩码
72 wire [127:0]c3_p0_wr_data; //P0端写数据
73 wire c3_p0_cmd_full; //p0端命令fifo满标志
74 wire [127:0]c3_p0_rd_data ; //ddr读数据
75 wire c3_p0_rd_empty; //p0端fifo空信号
76 wire [127:0]rfifo_wdata_1; //rfifo1输入数据
77 wire [127:0]rfifo_wdata_2; //rfifo2输入数据
78 wire [8:0] wfifo_rcount_1; //wfifo1剩余数据计数
79 wire [8:0] wfifo_rcount_2; //wfifo2剩余数据计数
80 wire [8:0] rfifo_wcount_1; //rfifo1写进数据计数
81 wire [8:0] rfifo_wcount_2; //rfifo2写进数据计数
82
83 //*****************************************************
84 //** main code
85 //*****************************************************
86
87 ddr_rw u_ddr_rw
88 (
89 .clk_100m (clk_100m)， //ddr3输入时钟
90 .rst_n (rst_n)， //系统复位，低电平有效
91
92 .c3_calib_done (c3_calib_done)， //ddr3初始化成功标志
93 .ddr3_read_valid (ddr3_read_valid)， //ddr3读使能
94 .ddr3_pingpang_en (ddr3_pingpang_en)， //ddr3乒乓操作使能
95 .c3_p0_cmd_full (c3_p0_cmd_full)， //命令fifo满标志
96 .c3_p0_rd_empty (c3_p0_rd_empty)， //fifo空信号
97 .c3_p0_cmd_en (c3_p0_cmd_en)， //命令使能
98 .c3_p0_cmd_instr (c3_p0_cmd_instr)， //命令输入
99 .c3_p0_cmd_bl (c3_p0_cmd_bl)， //数据突发长度
100 .c3_p0_cmd_byte_addr (c3_p0_cmd_byte_addr)，//数据地址
101 .c3_p0_wr_mask (c3_p0_wr_mask)， //写数据掩码
102 .c3_p0_wr_full (c3_p0_wr_full)， //写数据fifo满标志
103 .c3_p0_rd_en (c3_p0_rd_en)， //数据读使能
104 .c3_p0_wr_en (c3_p0_wr_en)， //数据写使能
105 .c3_p0_rd_data (c3_p0_rd_data)， //ddr读数据
106
107
108 .clk_write_1 (clk_write_1)， //写操作时钟
109 .wr_load_1 (wr_load_1)， //写端更新信号
110 .wr_max_addr_1 (wr_max_addr_1)， //写最大地址
111 .wr_length_1 (wr_length_1)， //一次写长度
112 .wr_min_addr_1 (wr_min_addr_1)， //写最小地址
113 .rfifo_wdata_1 (rfifo_wdata_1)， //rfifo写数据
114 .rfifo_wren_1 (rfifo_wren_1)， //rfifo写使能
115 .wfifo_rden_1 (wfifo_rden_1)， //wfifo读使能
116 .wfifo_rcount_1 (wfifo_rcount_1)， //wfifo剩余数据计数
117 .rfifo_wcount_1 (rfifo_wcount_1)， //rfifo写进数据计数
118
119
120 .clk_write_2 (clk_write_2)， //写操作时钟
121 .wr_load_2 (wr_load_2)， //写端更新信号
122 .wr_max_addr_2 (wr_max_addr_2)， //写最大地址
123 .wr_length_2 (wr_length_2)， //一次写长度
124 .wr_min_addr_2 (wr_min_addr_2)， //写最小地址
125 .rfifo_wdata_2 (rfifo_wdata_2)， //rfifo写数据
126 .rfifo_wren_2 (rfifo_wren_2)， //rfifo写使能
127 .wfifo_rden_2 (wfifo_rden_2)， //wfifo读使能
128 .wfifo_rcount_2 (wfifo_rcount_2)， //wfifo剩余数据计数
129 .rfifo_wcount_2 (rfifo_wcount_2)， //rfifo写进数据计数
130
131 .clk_read (clk_read)， //读操作时钟
132 .rd_load (rd_load)， //读端更新信号
133 .rd_max_addr (rd_max_addr)， //读最大地址
134 .rd_min_addr (rd_min_addr)， //读最小地址
135 .rd_length (rd_length) //一次读长度
136
137
138 );
139
140 ddr3_fifo_ctrl_top u_ddr3_fifo_ctrl_top(
141 .rst_n (rst_n &&c3_calib_done)， //复位信号
142 .rd_clk (clk_read)， //rfifo时钟
143 .clk_100 (clk_100m)， //用户时钟
144 //fifo1接口信号
145 .wr_clk_1 (clk_write_1)， //wfifo时钟
146 .datain_valid_1 (wr_en_1)， //数据有效使能信号
147 .datain_1 (wr_data_1)， //有效数据
148 .wr_load_1 (wr_load_1)， //输入源场信号
149 .rfifo_din_1 (rfifo_wdata_1)， //rfifo写数据
150 .rfifo_wren_1 (rfifo_wren_1)， //rfifo写使能
151 .wfifo_rden_1 (wfifo_rden_1)， //wfifo读使能
152 .wfifo_rcount_1 (wfifo_rcount_1)， //wfifo剩余数据计数
153 .rfifo_wcount_1 (rfifo_wcount_1)， //rfifo写进数据计数
154 //fifo2接口信号
155 .wr_clk_2 (clk_write_2)， //wfifo时钟
156 .datain_valid_2 (wr_en_2)， //数据有效使能信号
157 .datain_2 (wr_data_2)， //有效数据
158 .wr_load_2 (wr_load_2)， //输入源场信号
159 .rfifo_din_2 (rfifo_wdata_2)， //rfifo写数据
160 .rfifo_wren_2 (rfifo_wren_2)， //rfifo写使能
161 .wfifo_rden_2 (wfifo_rden_2)， //wfifo读使能
162 .wfifo_rcount_2 (wfifo_rcount_2)， //wfifo剩余数据计数
163 .rfifo_wcount_2 (rfifo_wcount_2)， //rfifo写进数据计数
164
165 .h_disp (h_disp)， //摄像头水平分辨率
166 .rd_load (rd_load)， //输出源场信号
167 .rdata_req (rd_en)， //请求像素点颜色数据输入
168 .pic_data (rd_data)， //有效数据
169 .wfifo_dout (c3_p0_wr_data) //用户写数据
170
171 );
172
173 //ddr ip核
174 ddr3 # (
175 .C3_NUM_DQ_PINS (C3_NUM_DQ_PINS)，
176 .C3_MEM_ADDR_WIDTH (C3_MEM_ADDR_WIDTH)，
177 .C3_MEM_BANKADDR_WIDTH (C3_MEM_BANKADDR_WIDTH)
178 )
179 ddr3 (
180
181 .c3_sys_clk (clk_ddr)，
182 .c3_sys_rst_i (1'b0)，
183
184 .mcb3_dram_dq (mcb3_dram_dq)，
185 .mcb3_dram_a (mcb3_dram_a)，
186 .mcb3_dram_ba (mcb3_dram_ba)，
187 .mcb3_dram_ras_n (mcb3_dram_ras_n)，
188 .mcb3_dram_cas_n (mcb3_dram_cas_n)，
189 .mcb3_dram_we_n (mcb3_dram_we_n)，
190
191 .mcb3_dram_cke (mcb3_dram_cke)，
192 .mcb3_dram_ck (mcb3_dram_ck)，
193 .mcb3_dram_ck_n (mcb3_dram_ck_n)，
194 .mcb3_dram_dqs (mcb3_dram_dqs)，
195 .mcb3_dram_dqs_n (mcb3_dram_dqs_n)，
196 .mcb3_dram_udqs (mcb3_dram_udqs)， // for X16 parts
197 .mcb3_dram_udqs_n (mcb3_dram_udqs_n)， // for X16 parts
198 .mcb3_dram_udm (mcb3_dram_udm)， // for X16 parts
199 .mcb3_dram_dm (mcb3_dram_dm)，
200 .mcb3_dram_reset_n (mcb3_dram_reset_n)，
201
202 .c3_clk0 (c3_clk0)，
203 .c3_rst0 (c3_rst0)，
204 .c3_calib_done (c3_calib_done)，
205 .mcb3_rzq (mcb3_rzq)，
206 .mcb3_zio (mcb3_zio)，
207
208 .c3_p0_cmd_clk (clk_100m)，
209 .c3_p0_cmd_en (c3_p0_cmd_en)，
210 .c3_p0_cmd_instr (c3_p0_cmd_instr)，
211 .c3_p0_cmd_bl (c3_p0_cmd_bl)，
212 .c3_p0_cmd_byte_addr (c3_p0_cmd_byte_addr)，
213 .c3_p0_cmd_empty (c3_p0_cmd_empty)，
214 .c3_p0_cmd_full (c3_p0_cmd_full)，
215 .c3_p0_wr_clk (clk_100m)，
216 .c3_p0_wr_en (c3_p0_wr_en)，
217 .c3_p0_wr_mask (c3_p0_wr_mask)，
218 .c3_p0_wr_data (c3_p0_wr_data)，
219 .c3_p0_wr_full (c3_p0_wr_full)，
220 .c3_p0_wr_empty (c3_p0_wr_empty)，
221 .c3_p0_wr_count (c3_p0_wr_count)，
222 .c3_p0_wr_underrun (c3_p0_wr_underrun)，
223 .c3_p0_wr_error (c3_p0_wr_error)，
224 .c3_p0_rd_clk (clk_100m)，
225 .c3_p0_rd_en (c3_p0_rd_en)，
226 .c3_p0_rd_data (c3_p0_rd_data)，
227 .c3_p0_rd_full (c3_p0_rd_full)，
228 .c3_p0_rd_empty (c3_p0_rd_empty)，
229 .c3_p0_rd_count (c3_p0_rd_count)，
230 .c3_p0_rd_overflow (c3_p0_rd_overflow)，
231 .c3_p0_rd_error (c3_p0_rd_error)
232 );
233
234 endmodule

复制代码

在“OV5640摄像头RGB-LCD显示实验”的程序中，读写操作地址用了DDR3的四个存储空间，但本次实验开辟了八个存储空间，使得两个摄像头的数据在DDR3的存储中互不影响，也方便调度，所以本次实验需要在“OV5640摄像头RGB-LCD显示实验”的程序方面做些改动。具体框图如下图所示：

图 55.4.3 DDR读写控制流程图

图像数据是由两个摄像头分别采集得来的，所以将图像分别存入两个wfifo中。当两个wfifo任意一个fifo剩余的数据量大于本次实验设定的阈值时，DDR读写模块就对其发出读数据请求信号，使fifo中的数据写入DDR3中，保证wfifo不会写满。当两个rfifo任意一个fifo剩余的数据量小于本次实验设定的阈值时，DDR读写模块就向对应的rfifo中写入数据，保证rfifo不会读空。DDR3中开辟了八个存储空间，每个输入源使用四个存储空间，这么做的好处一是对输入源做乒乓操作，防止画面撕裂，另一个是保证两个输入源的数据不会相互干扰。
本次实验中的DDR读写模块是基于“OV5640摄像头RGB-LCD显示实验”做的修改，本次实验着重对代码的改动部分做讲解。

56 localparam IDLE = 7'b0000001; //空闲状态
57 localparam DDR3_DONE = 7'b0000010; //DDR3初始化完成状态
58 localparam WRITE_1 = 7'b0000100; //写状态1
59 localparam READ_1 = 7'b0001000; //读状态1
60 localparam WRITE_2 = 7'b0010000; //写状态2
61 localparam READ_2 = 7'b0100000; //读状态2
62 localparam READ_WAIT = 7'b1000000; //读等待

复制代码

在代码的56行至62行，相比于“OV5640摄像头RGB-LCD显示实验”多添加了三个状态，一个读状态，一个写状态，还有一个读等待状态。

130 assign wfifo_rden_1 = (state_cnt == WRITE_1 && c3_p0_wr_en) ? 1'b1:1'b0;
131
132 assign wfifo_rden_2 = (state_cnt == WRITE_2 && c3_p0_wr_en) ? 1'b1:1'b0;

复制代码

在代码的130行至132行，根据不同的写状态来给不同的wfifo发出读数据使能信号。

188 //对DDR读数据的输出端进行选择
189 always @(posedge clk_100m or negedge rst_n) begin
190 if(~rst_n || rd_rst)begin
191 rfifo_wren_1 <= 0;
192 rfifo_wren_2 <= 0;
193 rfifo_wdata_1 <= 0;
194 rfifo_wdata_2 <= 0;
195 end
196 else begin
197 if(rfifo_data_en_1)begin
198 rfifo_wren_1 <= c3_p0_rd_en;
199 rfifo_wdata_1 <= c3_p0_rd_data;
200 rfifo_wren_2 <= 0;
201 rfifo_wdata_2 <= 0;
202 end
203 else if(rfifo_data_en_2)begin
204 rfifo_wren_2 <= c3_p0_rd_en;
205 rfifo_wdata_2 <= c3_p0_rd_data;
206 rfifo_wren_1 <= 0;
207 rfifo_wdata_1 <= 0;
208 end
209 else begin
210 rfifo_wren_2 <= 0;
211 rfifo_wdata_2 <= 0;
212 rfifo_wren_1 <= 0;
213 rfifo_wdata_1 <= 0;
214 end
215 end
216 end
217
218 //读端口FIFO1数据没有写完的使能信号
219 always @(posedge clk_100m or negedge rst_n) begin
220 if(~rst_n || rd_rst)begin
221 rfifo_data_en_1 <= 0;
222 end
223 else begin
224 if(state_cnt == DDR3_DONE )
225 rfifo_data_en_1 <= 0;
226 else if(state_cnt == READ_1 )
227 rfifo_data_en_1 <= 1;
228 else
229 rfifo_data_en_1 <= rfifo_data_en_1;
230 end
231 end
232
233 //读端口FIFO2数据没有写完的使能信号
234 always @(posedge clk_100m or negedge rst_n) begin
235 if(~rst_n || rd_rst)begin
236 rfifo_data_en_2 <= 0;
237 end
238 else begin
239 if(state_cnt == DDR3_DONE)
240 rfifo_data_en_2 <= 0;
241 else if(state_cnt == READ_2 )
242 rfifo_data_en_2 <= 1;
243 else
244 rfifo_data_en_2 <= rfifo_data_en_2;
245 end
246 end
247
248 //从ddr3读出的有效数据使能进行计数
249 always @(posedge clk_100m or negedge rst_n) begin
250 if(~rst_n || rd_rst )begin
251 data_valid_cnt <= 0;
252 end
253 else begin
254 if(state_cnt == DDR3_DONE )
255 data_valid_cnt <= 0;
256 else if(c3_p0_rd_en)
257 data_valid_cnt <= data_valid_cnt + 1;
258 else
259 data_valid_cnt <= data_valid_cnt;
260 end
261 end

复制代码

在代码的189行至216行，根据信号rfifo_data_en_1和rfifo_data_en_2来判断是哪个rfifo将要空了，并把DDR3读出的数据写入这个rfifo。
在代码的219行至246行，对rfifo_data_en_1和rfifo_data_en_2进行了赋值，这两个信号在读操作开始后拉高，进入DDR3空闲状态拉低。信号为高时表示此次读操作所需要的数据没有全部从DDR3读出来，为低时，表示数据已经全部读出来了。
在代码的249行至261行，对DDR3读出数据的有效使能（c3_p0_rd_en）进行了计数。

263 //将数据读写地址赋给ddr地址
264 always @(*) begin
265 if(~rst_n)
266 c3_p0_cmd_byte_addr <= 0;
267 else if(state_cnt == READ_1 )
268 c3_p0_cmd_byte_addr <= {3'b0，rd_page_1，ddr_addr_rd_1[23:0]};
269 else if(state_cnt == READ_2 )
270 c3_p0_cmd_byte_addr <= {3'b1，rd_page_2，ddr_addr_rd_2[23:0]};
271 else if(state_cnt == WRITE_1 )
272 c3_p0_cmd_byte_addr <= {3'b0，wr_page_1，ddr_addr_wr_1[23:0]};
273 else
274 c3_p0_cmd_byte_addr <= {3'b1，wr_page_2，ddr_addr_wr_2[23:0]};
275 end

复制代码

代码的264行至275行，根据不同的状态写入相对应的地址。代码的270行和274行，将信号c3_p0_cmd_byte_addr的高三位赋1，其用意是为了和另一个输入源的存储空间做区分。信号rd_page_1和wr_page_1是对同一个输入源的两个存储空间的切换信号，同理信号rd_page_2和wr_page_2也是如此。

372 //DDR3读写逻辑实现
373 always @(posedge clk_100m or negedge rst_n) begin
374 if(~rst_n) begin
375 state_cnt <= IDLE;
376 wr_addr_cnt_1 <= 24'd0;
377 rd_addr_cnt_1 <= 24'd0;
378 ddr_addr_wr_1 <= 28'd0;
379 ddr_addr_rd_1 <= 28'd0;
380 wr_addr_cnt_2 <= 24'd0;
381 rd_addr_cnt_2 <= 24'd0;
382 ddr_addr_wr_2 <= 28'd0;
383 ddr_addr_rd_2 <= 28'd0;
384 c3_p0_wr_mask <=0;
385 c3_p0_cmd_bl <= 6'd0;
386 end
387 else begin
388 case(state_cnt)
389 IDLE:begin
390 if(c3_calib_done_d1)
391 state_cnt <= DDR3_DONE ;
392 else
393 state_cnt <= IDLE;
394 end
395 DDR3_DONE:begin //当wfifo1存储数据超过一次突发长度时，跳到写操作1
396 if(wfifo_rcount_1 >= wr_length_1_d0 - 3 )begin
397 state_cnt <= WRITE_1;
398 end //当wfifo2存储数据超过一次突发长度时，跳到写操作2
399 else if(wfifo_rcount_2 >= wr_length_2_d0 - 3 )begin
400 state_cnt <= WRITE_2;
401 end
402 else if(raddr_rst_h)begin //当帧复位到来时，对寄存器进行复位
403 if(raddr_rst_h_cnt >= 1000 )begin
404 state_cnt <= READ_1; //保证读fifo在复位时不会进行读操作
405 end
406 else begin
407 state_cnt <= DDR3_DONE;
408 end
409 end //当rfifo1存储数据少于设定阈值时
410 else if(rfifo_wcount_1 < 20 )begin //跳到读操作1
411 state_cnt <= READ_1;
412 end //当rfifo1存储数据少于设定阈值时
413 else if(rfifo_wcount_2 < 20 )begin //跳到读操作2
414 state_cnt <= READ_2;
415 end
416 else begin
417 state_cnt <= state_cnt;
418 end
419
420 if(raddr_rst_h)begin //当帧复位到来时，对信号进行复位
421 rd_addr_cnt_1 <= 24'd0;
422 ddr_addr_rd_1 <= rd_min_addr_d0;
423 rd_addr_cnt_2 <= 24'd0;
424 ddr_addr_rd_2 <= rd_min_addr_d0;
425 end //当rfifo1存储数据少于设定阈值时
426 else if(rfifo_wcount_1 < 20 )begin
427 rd_addr_cnt_1 <= 24'd0; //计数器清零
428 ddr_addr_rd_1 <= ddr_addr_rd_1; //读地址保持不变
429 end //当rfifo1存储数据少于设定阈值时
430 else if(rfifo_wcount_2 < 20 )begin
431 rd_addr_cnt_2 <= 24'd0; //计数器清零
432 ddr_addr_rd_2 <= ddr_addr_rd_2; //读地址保持不变
433 end
434 else begin
435 wr_addr_cnt_1 <= 24'd0;
436 rd_addr_cnt_1 <= 24'd0;
437 end
438
439 if(wr_rst_2)begin //当帧复位到来时，对信号进行复位
440 wr_addr_cnt_2 <= 24'd0;
441 ddr_addr_wr_2 <= wr_min_addr_2_d0;
442 end //当wfifo存储数据超过一次突发长度时
443 else if(wfifo_rcount_2 >= wr_length_2_d0 - 3 )begin
444 wr_addr_cnt_2 <= 24'd0; //计数器清零
445 ddr_addr_wr_2 <= ddr_addr_wr_2; //写地址保持不变
446 end
447 else begin
448 wr_addr_cnt_2 <= wr_addr_cnt_2;
449 ddr_addr_wr_2 <= ddr_addr_wr_2;
450 end
451
452 if(wr_rst_1)begin //当帧复位到来时，对信号进行复位
453 wr_addr_cnt_1 <= 24'd0;
454 ddr_addr_wr_1 <= wr_min_addr_1_d0;
455 end //当wfifo存储数据超过一次突发长度时
456 else if(wfifo_rcount_1 >= wr_length_1_d0 - 3 )begin
457 wr_addr_cnt_1 <= 24'd0; //计数器清零
458 ddr_addr_wr_1 <= ddr_addr_wr_1; //写地址保持不变
459 end
460 else begin
461 wr_addr_cnt_1 <= wr_addr_cnt_1;
462 ddr_addr_wr_1 <= ddr_addr_wr_1;
463 end
464
465 end
466 WRITE_1: begin
467 if((wr_addr_cnt_1 == (wr_length_1_d0 - 1))
468 && c3_p0_cmd_en)begin //写到设定的长度跳到等待状态
469 state_cnt <= DDR3_DONE; //一次性写进16个字节，故加16
470 ddr_addr_wr_1 <= ddr_addr_wr_1 + {(c3_p0_cmd_bl+1'b1)，4'b0};
471 end
472 else if(c3_p0_wr_en)begin //写条件满足
473 wr_addr_cnt_1 <= wr_addr_cnt_1 + 1'd1;//写地址计数器自加
474 ddr_addr_wr_1 <= ddr_addr_wr_1 + {(c3_p0_cmd_bl+1'b1)，4'b0};
475 end //一次性写进16个字节，故加16
476 else begin //写条件不满足，保持当前值
477 wr_addr_cnt_1 <= wr_addr_cnt_1;
478 ddr_addr_wr_1 <= ddr_addr_wr_1;
479 end
480 end
481 WRITE_2: begin
482 if((wr_addr_cnt_2 == (wr_length_2_d0 - 1))
483 && c3_p0_cmd_en)begin //写到设定的长度跳到等待状态
484 state_cnt <= DDR3_DONE; //一次性写进16个字节，故加16
485 ddr_addr_wr_2 <= ddr_addr_wr_2 + {(c3_p0_cmd_bl+1'b1)，4'b0};
486 end
487 else if(c3_p0_wr_en)begin //写条件满足
488 wr_addr_cnt_2 <= wr_addr_cnt_2 + 1'd1; //写地址计数器自加
489 ddr_addr_wr_2 <= ddr_addr_wr_2 + {(c3_p0_cmd_bl+1'b1)，4'b0};
490 end //一次性写进16个字节，故加16
491 else begin //写条件不满足，保持当前值
492 wr_addr_cnt_2 <= wr_addr_cnt_2;
493 ddr_addr_wr_2 <= ddr_addr_wr_2;
494 end
495 end
496 READ_1:begin //读到设定的地址长度
497 if((rd_addr_cnt_1 == (rd_length_d0 - 1)) && c3_p0_cmd_en)begin
498 state_cnt <= READ_WAIT; //则跳到空闲状态
499 ddr_addr_rd_1 <= ddr_addr_rd_1 + {(c3_p0_cmd_bl+1'b1)，4'b0};
500 end //一次性读出16个字节，故加16
501 else if(c3_p0_cmd_en)begin //若MIG已经准备好，则开始读
502 rd_addr_cnt_1 <= rd_addr_cnt_1 + 1'd1; //用户地址计数器每次加一
503 ddr_addr_rd_1 <= ddr_addr_rd_1 + {(c3_p0_cmd_bl+1'b1)，4'b0};
504 end //一次性读出16个字节，故加16
505 else begin //若MIG没准备好，则保持原值
506 rd_addr_cnt_1 <= rd_addr_cnt_1;
507 ddr_addr_rd_1 <= ddr_addr_rd_1;
508 end
509
510 if(wr_rst_2)begin //当帧复位到来时，对信号进行复位
511 wr_addr_cnt_2 <= 24'd0;
512 ddr_addr_wr_2 <= wr_min_addr_2_d0;
513 end
514 else begin
515 wr_addr_cnt_2 <= wr_addr_cnt_2;
516 ddr_addr_wr_2 <= ddr_addr_wr_2;
517 end
518
519 if(wr_rst_1)begin //当帧复位到来时，对信号进行复位
520 wr_addr_cnt_1 <= 24'd0;
521 ddr_addr_wr_1 <= wr_min_addr_1_d0;
522 end
523 else begin
524 wr_addr_cnt_1 <= wr_addr_cnt_1;
525 ddr_addr_wr_1 <= ddr_addr_wr_1;
526 end
527 end
528 READ_2:begin //读到设定的地址长度
529 if((rd_addr_cnt_2 == (rd_length_d0 - 1)) && c3_p0_cmd_en)begin
530 state_cnt <= READ_WAIT; //则跳到空闲状态
531 ddr_addr_rd_2 <= ddr_addr_rd_2 + {(c3_p0_cmd_bl+1'b1)，4'b0};
532 end //一次性读出16个字节，故加16
533 else if(c3_p0_cmd_en)begin //若MIG已经准备好，则开始读
534 rd_addr_cnt_2 <= rd_addr_cnt_2 + 1'd1; //用户地址计数器每次加一
535 ddr_addr_rd_2 <= ddr_addr_rd_2 + {(c3_p0_cmd_bl+1'b1)，4'b0};
536 end //一次性读出16个字节，故加16
537 else begin //若MIG没准备好，则保持原值
538 rd_addr_cnt_2 <= rd_addr_cnt_2;
539 ddr_addr_rd_2 <= ddr_addr_rd_2;
540 end
541
542 if(wr_rst_2)begin //当帧复位到来时，对信号进行复位
543 wr_addr_cnt_2 <= 24'd0;
544 ddr_addr_wr_2 <= wr_min_addr_2_d0;
545 end
546 else begin
547 wr_addr_cnt_2 <= wr_addr_cnt_2;
548 ddr_addr_wr_2 <= ddr_addr_wr_2;
549 end
550
551 if(wr_rst_1)begin //当帧复位到来时，对信号进行复位
552 wr_addr_cnt_1 <= 24'd0;
553 ddr_addr_wr_1 <= wr_min_addr_1_d0;
554 end
555 else begin
556 wr_addr_cnt_1 <= wr_addr_cnt_1;
557 ddr_addr_wr_1 <= ddr_addr_wr_1;
558 end
559 end
560 READ_WAIT:begin //计到设定的地址长度
561 if((data_valid_cnt >= rd_length_d0 - 1) && c3_p0_rd_en)begin
562 state_cnt <= DDR3_DONE; //则跳到空闲状态
563 end
564 else begin
565 state_cnt <= READ_WAIT;
566 end
567 end
568 default:begin
569 state_cnt <= IDLE;
570 wr_addr_cnt_1 <= 24'd0;
571 rd_addr_cnt_1 <= 24'd0;
572 ddr_addr_wr_1 <= 28'd0;
573 ddr_addr_rd_1 <= 28'd0;
574 wr_addr_cnt_2 <= 24'd0;
575 rd_addr_cnt_2 <= 24'd0;
576 ddr_addr_wr_2 <= 28'd0;
577 ddr_addr_rd_2 <= 28'd0;
578 end
579 endcase
580 end
581 end

复制代码

程序中第373至581行所示，这段代码是DDR3读写逻辑实现，状态跳转图如下图所示：

图 55.4.4 状态跳转图

本次实验的状态跳转相对于“OV7725摄像头RGB-LCD显示实验”中的状态跳转只是多了一个读状态、一个写状态和读等待状态。两个实验当中的写状态跳转的条件是没有变的，读状态的跳转出现了变化。本次实验读状态不直接跳到DDR的空闲状态，而是跳到读等待状态。本次实验的实验任务是利用双目OV5640摄像头采集图像，将采集到的图像实时显示在LCD屏幕上，两幅图像分别占据LCD屏的左右半边，所以在输出端存在两个rfifo。时序图如下：

图 55.4.5 状态时序图

在上面的时序图中可以发现当读状态操作完后，而此时的数据没有全部读出来。如果此时直接跳转到DDR的空闲状态，下一刻状态就会跳到另一个读状态，那么DDR3读出的数据就不容易区分是哪个rfifo的数据，容易造成数据错乱。为了保证数据可以准确的写入到对应的rfifo中，必须在数据完全读出后才能跳转到DDR的空闲状态，这是添加读等待状态的原因。
本次实验增加了一个rfifo和一个wfifo，所以在fifo顶层调度模块对fifo调度模块例化了两次。在fifo顶层调度模块，对写fifo的输出数据进行了判断，也对读fifo的输出数据进行判断。
fifo调度模块：负责对输入和输出的数据进行时钟域的切换和位宽的转换。详细说明请看“DDR读写测试实验”。
fifo顶层调度模块的代码如下：

1 module ddr3_fifo_ctrl_top(
2 input rst_n ， //复位信号
3 input rd_clk ， //rfifo时钟
4 input clk_100 ， //用户时钟
5 //fifo1接口信号
6 input wr_clk_1 ， //wfifo时钟
7 input datain_valid_1 ， //数据有效使能信号
8 input [15:0] datain_1 ， //有效数据
9 input wr_load_1 ， //输入源场信号
10 input [127:0] rfifo_din_1 ， //用户读数据
11 input rfifo_wren_1 ， //从ddr3读出数据的有效使能
12 input wfifo_rden_1 ， //wfifo读使能
13 output [10:0] wfifo_rcount_1 ， //wfifo剩余数据计数
14 output [10:0] rfifo_wcount_1 ， //rfifo写进数据计数
15 //fifo2接口信号
16 input wr_clk_2 ， //wfifo时钟
17 input datain_valid_2 ， //数据有效使能信号
18 input [15:0] datain_2 ， //有效数据
19 input wr_load_2 ， //输入源场信号
20 input [127:0] rfifo_din_2 ， //用户读数据
21 input rfifo_wren_2 ， //从ddr3读出数据的有效使能
22 input wfifo_rden_2 ， //wfifo读使能
23 output [10:0] wfifo_rcount_2 ， //wfifo剩余数据计数
24 output [10:0] rfifo_wcount_2 ， //rfifo写进数据计数
25
26 input [12:0] h_disp ，
27 input rd_load ， //输出源场信号
28 input rdata_req ， //请求像素点颜色数据输入
29 output [15:0] pic_data ， //有效数据
30 output [127:0] wfifo_dout //用户写数据
31
32 );
33
34 //reg define
35 reg [12:0] rd_cnt;
36
37 //wire define
38 wire rdata_req_1;
39 wire rdata_req_2;
40 wire [15:0] pic_data_1;
41 wire [15:0] pic_data_2;
42 wire [15:0] pic_data;
43 wire [127:0] wfifo_dout;
44 wire [127:0] wfifo_dout_1;
45 wire [127:0] wfifo_dout_2;
46 wire [10:0] wfifo_rcount_1;
47 wire [10:0] wfifo_rcount_2;
48 wire [10:0] rfifo_wcount_1;
49 wire [10:0] rfifo_wcount_2;
50
51 //*****************************************************
52 //** main code
53 //*****************************************************
54
55 //像素显示请求信号切换，即显示器左侧请求FIFO1显示，右侧请求FIFO2显示
56 assign rdata_req_1 = (rd_cnt <= h_disp[12:1]-1) ? rdata_req :1'b0;
57 assign rdata_req_2 = (rd_cnt <= h_disp[12:1]-1) ? 1'b0 :rdata_req;
58
59 //像素在显示器显示位置的切换，即显示器左侧显示FIFO1，右侧显示FIFO2
60 assign pic_data = (rd_cnt <= h_disp[12:1]) ? pic_data_1 : pic_data_2;
61
62 //写入DDR3的像素数据切换
63 assign wfifo_dout = wfifo_rden_1 ? wfifo_dout_1 : wfifo_dout_2;
64
65 //对读请求信号计数
66 always @(posedge rd_clk or negedge rst_n) begin
67 if(!rst_n)
68 rd_cnt <= 13'd0;
69 else if(rdata_req)
70 rd_cnt <= rd_cnt + 1'b1;
71 else
72 rd_cnt <= 13'd0;
73 end
74
75 ddr3_fifo_ctrl u_ddr3_fifo_ctrl_1 (
76
77 .rst_n (rst_n ) ，
78 //摄像头接口
79 .wr_clk (wr_clk_1) ，
80 .rd_clk (rd_clk) ，
81 .clk_100 (clk_100) ， //用户时钟
82 .datain_valid (datain_valid_1) ， //数据有效使能信号
83 .datain (datain_1) ， //有效数据
84 .rfifo_din (rfifo_din_1) ， //用户读数据
85 .rdata_req (rdata_req_1) ， //请求像素点颜色数据输入
86 .rfifo_wren (rfifo_wren_1) ， //ddr3读出数据的有效使能
87 .wfifo_rden (wfifo_rden_1) ， //ddr3 写使能
88 //用户接口
89 .wfifo_rcount (wfifo_rcount_1) ， //wfifo剩余数据计数
90 .rfifo_wcount (rfifo_wcount_1) ， //rfifo写进数据计数
91 .wfifo_dout (wfifo_dout_1) ， //用户写数据
92 .rd_load (rd_load) ， //lcd场信号
93 .wr_load (wr_load_1) ， //摄像头场信号
94 .pic_data (pic_data_1) //rfifo输出数据
95
96 );
97
98 ddr3_fifo_ctrl u_ddr3_fifo_ctrl_2 (
99
100 .rst_n (rst_n ) ，
101 //摄像头接口
102 .wr_clk (wr_clk_2) ，
103 .rd_clk (rd_clk) ，
104 .clk_100 (clk_100) ， //用户时钟
105 .datain_valid (datain_valid_2) ， //数据有效使能信号
106 .datain (datain_2) ， //有效数据
107 .rfifo_din (rfifo_din_2) ， //用户读数据
108 .rdata_req (rdata_req_2) ， //请求像素点颜色数据输入
109 .rfifo_wren (rfifo_wren_2) ， //ddr3读出数据的有效使能
110 .wfifo_rden (wfifo_rden_2) ， //ddr3 写使能
111 //用户接口
112 .wfifo_rcount (wfifo_rcount_2) ， //wfifo剩余数据计数
113 .rfifo_wcount (rfifo_wcount_2) ， //rfifo写进数据计数
114 .wfifo_dout (wfifo_dout_2) ， //用户写数据
115 .rd_load (rd_load) ， //lcd场信号
116 .wr_load (wr_load_2) ， //摄像头场信号
117 .pic_data (pic_data_2) //rfifo输出数据
118 );
119
120 endmodule

复制代码

在代码56至57行，表示的是像素显示请求信号切换，即LCD屏左侧请求FIFO1显示，右侧请求FIFO2显示。
在代码60行，表示的是像素在LCD屏显示位置的切换，即LCD屏左侧显示FIFO1，右侧显示FIFO2。
在代码63行，表示的是像素数据在写入DDR3前的切换。
在代码66至73行，对LCD顶层模块发出的对读请求信号进行计数。
在代码75至118行是两个FIFO调度模块的例化，我们只给出代码注释，方便大家了解各信号的连接关系，这里不做分析了。
接下来介绍LCD顶层模块（lcd_rgb_top），这里先给出该模块的顶层代码：

1 module lcd_rgb_top(
2 input sys_clk ， //系统时钟
3 input clk_100m，
4 input sys_rst_n， //复位信号
5 input sys_init_done，
6 //lcd接口
7 output lcd_clk， //LCD驱动时钟
8 output lcd_hs， //LCD 行同步信号
9 output lcd_vs， //LCD 场同步信号
10 output lcd_de， //LCD 数据输入使能
11 inout [23:0] lcd_rgb， //LCD RGB颜色数据
12 output lcd_bl， //LCD 背光控制信号
13 output lcd_rst， //LCD 复位信号
14 output lcd_pclk， //LCD 采样时钟
15 output [15:0] lcd_id， //LCD屏ID
16 output out_vsync， //lcd场信号
17 output [10:0] pixel_xpos， //像素点横坐标
18 output [10:0] pixel_ypos， //像素点纵坐标
19 output [10:0] h_disp， //LCD屏水平分辨率
20 output [10:0] v_disp， //LCD屏垂直分辨率
21 input [15:0] data_in， //数据输入
22 output data_req //请求数据输入
23
24 );
25
26 //wire define
27 wire [15:0] lcd_rgb_565; //输出的16位lcd数据
28 wire [23:0] lcd_rgb_o ; //LCD 输出颜色数据
29 wire [23:0] lcd_rgb_i ; //LCD 输入颜色数据
30 //*****************************************************
31 //** main code
32 //*****************************************************
33 //将摄像头16bit数据转换为24bit的lcd数据
34 assign lcd_rgb_o = {lcd_rgb_565[15:11]，3'b000，lcd_rgb_565[10:5]，2'b00，
35 lcd_rgb_565[4:0]，3'b000};
36
37 //像素数据方向切换
38 assign lcd_rgb = lcd_de ? lcd_rgb_o : {24{1'bz}};
39 assign lcd_rgb_i = lcd_rgb;
40
41 //时钟分频模块
42 clk_div u_clk_div(
43 .clk (clk_100m )，
44 .rst_n (sys_rst_n)，
45 .lcd_id (lcd_id )，
46 .lcd_pclk (lcd_clk )
47 );
48
49 //读LCD ID模块
50 rd_id u_rd_id(
51 .clk (sys_clk )，
52 .rst_n (sys_rst_n)，
53 .lcd_rgb (lcd_rgb_i)，
54 .lcd_id (lcd_id )
55 );
56
57 //lcd驱动模块
58 lcd_driver u_lcd_driver(
59 .lcd_clk (lcd_clk)，
60 .sys_rst_n (sys_rst_n & sys_init_done)，
61 .lcd_id (lcd_id)，
62
63 .lcd_hs (lcd_hs)，
64 .lcd_vs (lcd_vs)，
65 .lcd_de (lcd_de)，
66 .lcd_rgb ()，
67 .lcd_bl (lcd_bl)，
68 .lcd_rst (lcd_rst)，
69 .lcd_pclk (lcd_pclk)，
70
71 .pixel_data (data_in)，
72 .data_req (data_req)，
73 .out_vsync (out_vsync)，
74 .h_disp (h_disp)，
75 .v_disp (v_disp)，
76 .pixel_xpos (pixel_xpos)，
77 .pixel_ypos (pixel_ypos)
78 );
79
80 lcd_disply u_lcd_disply(
81
82 .lcd_clk (lcd_clk)， //lcd模块驱动时钟
83 .sys_rst_n (sys_rst_n & sys_init_done)， //复位信号
84 //RGB LCD接口
85 .pixel_xpos (pixel_xpos)， //像素点横坐标
86 .pixel_ypos (pixel_ypos)， //像素点纵坐标
87 .rd_data (data_in)， //图像数据
88 .rd_h_pixel (h_disp)， //图像水平像素大小
89 .pixel_data (lcd_rgb_565) //像素点数据
90 );
91
92 endmodule

复制代码

以上主要是LCD顶层模块的内部模块例化，从代码中可以看到LCD顶层模块一共包含四个模块，同时可以看到各信号的定义。代码第38行做了一个判断，lcd_de为高则把像素值赋给RGB，否则RGB为高阻态，即不显示任何图像。
关于LCD顶层模块例化的四个模块，本次实验只对lcd_disply模块进行讲解。另外三个模块未作改动，具体代码讲解，可以参看“OV7725摄像头RGB-LCD显示”实验。
最后讲解lcd_disply模块，以下是lcd_disply模块的代码：

1 module lcd_disply(
2 input lcd_clk， //lcd模块驱动时钟
3 input sys_rst_n， //复位信号
4 //RGB LCD接口
5 input [ 10:0] pixel_xpos， //像素点横坐标
6 input [ 10:0] pixel_ypos， //像素点纵坐标
7 input [15:0] rd_data， //图像像素值
8 input [12:0] rd_h_pixel， //摄像头输出的水平方向分辨率
9 output reg [15:0] pixel_data //像素点数据，
10 );
11
12 //LCD的ID
13 parameter ID_4342 = 16'h4342;
14 parameter ID_7084 = 16'h7084;
15 parameter ID_7016 = 16'h7016;
16 parameter ID_1018 = 16'h1018;
17 parameter ID_4384 = 16'h4384;
18
19 //颜色定义
20 localparam RED = 16'b11111_000000_00000; //字符颜色
21 localparam BLUE = 16'b00000_000000_11111; //字符区域背景色
22 localparam BLACK = 16'b00000_000000_00000; //屏幕背景色
23
24 //reg define
25 reg [63:0] char0[15:0]; //字符数组0
26 reg [63:0] char1[15:0]; //字符数组1
27 reg [127:0] char2[32:0]; //字符数组2
28 reg [127:0] char3[32:0]; //字符数组3
29
30 //*****************************************************
31 //** main code
32 //*****************************************************
33
34 //给字符数组0的赋值：OV5640 0 (16*64)
35 always @(*) begin
36 char0[0] <= 64'h0000000000000000 ;
37 char0[1] <= 64'h0000000000000000 ;
38 char0[2] <= 64'h0000000000000000 ;
39 char0[3] <= 64'h38E77E1804180008 ;
40 char0[4] <= 64'h444240240C240038 ;
41 char0[5] <= 64'h824240400C420008 ;
42 char0[6] <= 64'h8244404014420008 ;
43 char0[7] <= 64'h8224785C24420008 ;
44 char0[8] <= 64'h8224446224420008 ;
45 char0[9] <= 64'h8228024244420008 ;
46 char0[10] <= 64'h822802427F420008 ;
47 char0[11] <= 64'h8218424204420008 ;
48 char0[12] <= 64'h4410442204240008 ;
49 char0[13] <= 64'h3810381C1F18003E ;
50 char0[14] <= 64'h0000000000000000 ;
51 char0[15] <= 64'h0000000000000000 ;
52 end
53
54 //给字符数组1的赋值: OV5640 1 (16*64)
55 always @(*) begin
56 char1[0] <= 64'h0000000000000000 ;
57 char1[1] <= 64'h0000000000000000 ;
58 char1[2] <= 64'h0000000000000000 ;
59 char1[3] <= 64'h38E77E180418003C ;
60 char1[4] <= 64'h444240240C240042 ;
61 char1[5] <= 64'h824240400C420042 ;
62 char1[6] <= 64'h8244404014420042 ;
63 char1[7] <= 64'h8224785C24420002 ;
64 char1[8] <= 64'h8224446224420004 ;
65 char1[9] <= 64'h8228024244420008 ;
66 char1[10] <= 64'h822802427F420010 ;
67 char1[11] <= 64'h8218424204420020 ;
68 char1[12] <= 64'h4410442204240042 ;
69 char1[13] <= 64'h3810381C1F18007E ;
70 char1[14] <= 64'h0000000000000000 ;
71 char1[15] <= 64'h0000000000000000 ;
72 end
73
74 //给字符数组2的赋值: OV5640 0 (32*128)
75 always @(*) begin
76 char2[0] <= 128'h00000000000000000000000000000000;
77 char2[1] <= 128'h00000000000000000000000000000000;
78 char2[2] <= 128'h00000000000000000000000000000000;
79 char2[3] <= 128'h00000000000000000000000000000000;
80 char2[4] <= 128'h00000000000000000000000000000000;
81 char2[5] <= 128'h00000000000000000000000000000000;
82 char2[6] <= 128'h03C07C1E0FFC01E0006003C000000080;
83 char2[7] <= 128'h0C30180C0FFC06180060062000000180;
84 char2[8] <= 128'h1818180810000C1800E00C3000001F80;
85 char2[9] <= 128'h100818081000081800E0181800000180;
86 char2[10] <= 128'h300C1808100018000160181800000180;
87 char2[11] <= 128'h300C0C10100010000160180800000180;
88 char2[12] <= 128'h60040C10100010000260300C00000180;
89 char2[13] <= 128'h60060C10100030000460300C00000180;
90 char2[14] <= 128'h60060C1013E033E00460300C00000180;
91 char2[15] <= 128'h60060C20143036300860300C00000180;
92 char2[16] <= 128'h60060620181838180860300C00000180;
93 char2[17] <= 128'h60060620100838081060300C00000180;
94 char2[18] <= 128'h60060620000C300C3060300C00000180;
95 char2[19] <= 128'h60060640000C300C2060300C00000180;
96 char2[20] <= 128'h60060340000C300C4060300C00000180;
97 char2[21] <= 128'h20060340000C300C7FFC300C00000180;
98 char2[22] <= 128'h300C0340300C300C0060180800000180;
99 char2[23] <= 128'h300C0380300C180C0060181800000180;
100 char2[24] <= 128'h10080180201818080060181800000180;
101 char2[25] <= 128'h1818018020180C1800600C3000000180;
102 char2[26] <= 128'h0C30010018300E3000600620000003C0;
103 char2[27] <= 128'h03C0010007C003E003FC03C000001FF8;
104 char2[28] <= 128'h00000000000000000000000000000000;
105 char2[29] <= 128'h00000000000000000000000000000000;
106 char2[30] <= 128'h00000000000000000000000000000000;
107 char2[31] <= 128'h00000000000000000000000000000000;
108 end
109
110 //给字符数组3的赋值: OV5640 1 (32*128)
111 always @(*) begin
112 char3[0] <= 128'h00000000000000000000000000000000;
113 char3[1] <= 128'h00000000000000000000000000000000;
114 char3[2] <= 128'h00000000000000000000000000000000;
115 char3[3] <= 128'h00000000000000000000000000000000;
116 char3[4] <= 128'h00000000000000000000000000000000;
117 char3[5] <= 128'h00000000000000000000000000000000;
118 char3[6] <= 128'h03C07C1E0FFC01E0006003C0000007E0;
119 char3[7] <= 128'h0C30180C0FFC06180060062000000838;
120 char3[8] <= 128'h1818180810000C1800E00C3000001018;
121 char3[9] <= 128'h100818081000081800E018180000200C;
122 char3[10] <= 128'h300C180810001800016018180000200C;
123 char3[11] <= 128'h300C0C1010001000016018080000300C;
124 char3[12] <= 128'h60040C10100010000260300C0000300C;
125 char3[13] <= 128'h60060C10100030000460300C0000000C;
126 char3[14] <= 128'h60060C1013E033E00460300C00000018;
127 char3[15] <= 128'h60060C20143036300860300C00000018;
128 char3[16] <= 128'h60060620181838180860300C00000030;
129 char3[17] <= 128'h60060620100838081060300C00000060;
130 char3[18] <= 128'h60060620000C300C3060300C000000C0;
131 char3[19] <= 128'h60060640000C300C2060300C00000180;
132 char3[20] <= 128'h60060340000C300C4060300C00000300;
133 char3[21] <= 128'h20060340000C300C7FFC300C00000200;
134 char3[22] <= 128'h300C0340300C300C0060180800000404;
135 char3[23] <= 128'h300C0380300C180C0060181800000804;
136 char3[24] <= 128'h10080180201818080060181800001004;
137 char3[25] <= 128'h1818018020180C1800600C300000200C;
138 char3[26] <= 128'h0C30010018300E300060062000003FF8;
139 char3[27] <= 128'h03C0010007C003E003FC03C000003FF8;
140 char3[28] <= 128'h00000000000000000000000000000000;
141 char3[29] <= 128'h00000000000000000000000000000000;
142 char3[30] <= 128'h00000000000000000000000000000000;
143 char3[31] <= 128'h00000000000000000000000000000000;
144 end
145
146 //显示逻辑判断
147 always@(posedge lcd_clk) begin
148 if(pixel_ypos >= 0 && pixel_ypos < 33)begin
149 //判断像素坐标是否在左半边屏幕中间
150 if(pixel_xpos < (rd_h_pixel[12:2]+64)
151 && pixel_xpos >= (rd_h_pixel[12:2]-64) )begin
152 //读取字模OV5640 1 (32*128)
153 if(char2[pixel_ypos][127-(pixel_xpos-rd_h_pixel[12:2]+64)])
154 pixel_data =BLUE; //字模数组中的"1"显示蓝色
155 else //字模数组中的"0"显示图像像素值
156 pixel_data = rd_data;
157 end //判断像素坐标是否在右半边屏幕中间
158 else if(pixel_xpos < (rd_h_pixel[12:2]*3+64)
159 && pixel_xpos >= (rd_h_pixel[12:2]*3-64))begin
160 //读取字模OV5640 2 (32*128)
161 if(char3[pixel_ypos][63-pixel_xpos+(rd_h_pixel[12:2])*3])
162 pixel_data =BLUE; //字模数组中的"1"显示蓝色
163 else //字模数组中的"0"显示图像像素值
164 pixel_data = rd_data;
165 end
166 else //纵坐标位于字符区域内的字符两边区域显示黑色
167 pixel_data = rd_data;
168 end
169 else //所有屏幕纵坐标位于字符区域外时显示像素值
170 pixel_data = rd_data;
171 end
172
173 endmodule

复制代码

本模块实现了五种RGB-LCD屏不同区域显示内容的逻辑判断，同时实现了字符叠加功能。
代码第20行到22行，定义了不同颜色对应的参数。代码第25行到28行，定义了四个二维数组char，用于存储对英文取模得到的点阵数据，具体代码讲解，可以参看“RGB-LCD字符和图片显示实验”实验。
代码第35行到144行给我们要用到的四个字符的模值进行赋值。在本次实验中LCD屏幕上要显示的字符大小为32*128，左右半边分别叠加上的“OV5640 1”和“OV5640 2”。
代码从147行往后是显示逻辑的具体实现，由于代码涉及到了判断条件之间的多重嵌套，为了让我们快速理清思路，我们结合代码制作了如图 55.4.6所示的显示逻辑图。结合代码和图，我们来具体介绍。
首先我们对图像像素纵坐标进行判断，对于所有屏幕，如果纵坐标值不在字符显示区域内，我们执行代码第170行，让屏幕显示图像像素的值。只有当纵坐标值位于字符显示区域内，我们正式开始字符叠加处理。
代码第148行，通过判断了像素点纵坐标的位置。代码第150行和151行，此时开始判断像素点横坐标位置，如果此时横坐标处于左半边的中间位置，此时执行代码第154行，开始读取“OV5640 1”的字符数组的值。代码第154到156行，将字模数组中为“1”的点的像素值赋值为蓝色，为“0”的点像素值赋值为图像像素的值。这就是LCD屏左半边字符叠加的实现。代码第158到165行，实现的是LCD屏右半边字符叠加，实现的代码形式一模一样，只是字模数组变为了“OV5640 2”，在这里我们不再重复。代码第170行，非字符纵坐标区域，显示图片像素值。

图 55.4.6 显示逻辑

55.5下载验证
首先将FPC排线一端与RGB-LCD模块上的J1接口连接，另一端与超越者开发板上的RGB-LCD接口连接。连接时，先掀开FPC连接器上的黑色翻盖，将FPC排线蓝色面朝上插入连接器，最后将黑色翻盖压下以固定FPC排线，如图 55.5.1和图 55.5.2所示。

图 55.5.1 正点原子RGBLCD模块FPC连接器

图 55.5.2 超越者开发板连接RGB-LCD液晶屏

接下来分别连接JTAG接口和电源线，并打开电源开关。
最后将下载器一端连电脑，另一端与开发板上的JTAG端口连接，连接电源线并打开电源开关。
接下来我们下载程序，验证双目OV5640摄像头RGB-LCD实时显示功能。下载完成后RGB-LCD液晶显示屏上会显示双目OV5640摄像头模块采集到的图像，如下图所示，说明双目OV5640摄像头RGB-LCD实时显示程序下载验证成功。

图 55.5.3 双目OV5640摄像头 RGB-LCD实时显示图像

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

[XILINX] 【正点原子FPGA连载】第五十五章双目OV5640摄像头RGB-LCD显示实验--摘自【正点原子】超越者之FPGA开发指南

浏览过的版块

原子哥极力推荐 /1