OpenEdv-开源电子网

 找回密码
 立即注册
正点原子全套STM32/Linux/FPGA开发资料，上千讲STM32视频教程免费下载...
OpenEdv-开源电子网»首页 › 单片机/嵌入式 › 正点原子FPGA › 《DFZU2EG_4EV MPSoc之FPGA开发指南》第三十四章 双目OV ...
返回列表 发新帖
查看: 3188|回复: 0

[XILINX] 《DFZU2EG_4EV MPSoc之FPGA开发指南》第三十四章 双目OV5640摄像头RGB-LCD显示实验

[复制链接]
正点原子运营

1118

主题

1129

帖子

2

精华

超级版主

Rank: 8Rank: 8

积分
4672
金钱
4672
注册时间
2019-5-8
在线时间
1224 小时
发表于 2023-4-28 10:03:43 | 显示全部楼层 |阅读模式
正点原子逻辑分析仪DL16热卖中，最多16通道，采样率最高可达1GHz，存储深度可达3.5Gbit
本帖最后由 正点原子运营 于 2023-4-27 10:26 编辑

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

1）实验平台：正点原子 DFZU2EG/4EV MPSoC开发板

2) 章节摘自【正点原子】DFZU2EG/4EV MPSoC之FPGA开发指南 V1.0


4）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/fpga/zdyz-MPSOC.html

5）正点原子官方B站：https://space.bilibili.com/394620890

6）FPGA技术交流QQ群:994244016

155537c2odj87vz1z9vj6l.jpg

155537nfqovl2gg9faaol9.png

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

34.1 简介
摄像头在日常生活中非常常见，一般分为单目摄像头、双目摄像头和多目摄像头。单目摄像头目前使用最为广泛；双目摄像头主要应用于单目摄像头无法胜任的场合，如测距领域，根据两个摄像头的视差，辅以一定的算法，人们可以计算物体的距离；当然针对一些特殊的应用，目前市场上也出现了多目摄像头，以应对更加复杂的场景。在“OV5640摄像头LCD显示实验”中对OV5640的视频传输时序、SCCB协议以及寄存器的配置信息等内容作了详细的介绍，如果大家对这部分内容不是很熟悉的话，请参考之前的实验。本次实验将在前面单目OV5640摄像头的基础上学习双目摄像头的LCD显示。

34.2 实验任务
本章实验任务是利用双目OV5640摄像头采集图像，将采集到的图像实时显示在LCD屏幕上，两幅图像分别占据LCD屏的左右半边。

34.3 硬件设计
摄像头扩展接口原理图及OV5640模块说明与“OV5640摄像头RGB-LCD显示实验”完全相同，请参考“OV5640摄像头RGB-LCD显示实验”硬件设计部分。HDMI接口部分的硬件设计请参考“HDMI彩条显示实验”中的硬件设计部分。
由于LCD接口和DDR4引脚数目较多且在前面相应的章节中已经给出它们的管脚列表，这里只列出双目摄像头相关管脚分配，如下表所示：
QQ截图20230427102231.png
QQ截图20230427102308.png
表 34.3.1 OV5640摄像头管脚分配

双目摄像头XDC约束文件如下：
  1. #时钟
  2. set_propertyIOSTANDARD DIFF_HSTL_I_12 [get_ports sys_clk_p]
  3. set_propertyIOSTANDARD DIFF_HSTL_I_12 [get_ports sys_clk_n]
  4. set_propertyPACKAGE_PIN AE5 [get_ports sys_clk_p]
  5. set_propertyPACKAGE_PIN AF5 [get_ports sys_clk_n]
  6. #复位
  7. set_property-dict {PACKAGE_PIN AH11 IOSTANDARD LVCMOS33} [get_ports sys_rst_n]

  9. #CAMERA

  11. #摄像头接口的时钟
  12. create_clock-period 40.000 -name cmos_pclk [get_ports cam_pclk_1]
  13. create_clock-period 40.000 -name cmos_pclk [get_ports cam_pclk_2]
  14. set_propertyCLOCK_DEDICATED_ROUTE FALSE [get_nets {cam_pclk_1_IBUF_inst/O}]
  15. set_propertyCLOCK_DEDICATED_ROUTE FALSE [get_nets {cam_pclk_2_IBUF_inst/O}]
  16. set_property-dict {PACKAGE_PIN C13 IOSTANDARD LVCMOS33} [get_ports cam_pclk_1]
  17. set_property-dict {PACKAGE_PIN F13 IOSTANDARD LVCMOS33} [get_ports cam_rst_n_1]
  18. set_property-dict {PACKAGE_PIN B15 IOSTANDARD LVCMOS33} [get_ports cam_pwdn_1]
  19. set_property-dict {PACKAGE_PIN E15 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[0]}]
  20. set_property-dict {PACKAGE_PIN D15 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[1]}]
  21. set_property-dict {PACKAGE_PIN E14 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[2]}]
  22. set_property-dict {PACKAGE_PIN D14 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[3]}]
  23. set_property-dict {PACKAGE_PIN E13 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[4]}]
  24. set_property-dict {PACKAGE_PIN B13 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[5]}]
  25. set_property-dict {PACKAGE_PIN C14 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[6]}]
  26. set_property-dict {PACKAGE_PIN A13 IOSTANDARD LVCMOS33 } [get_ports {cam_data_1[7]}]
  27. set_property-dict {PACKAGE_PIN G14 IOSTANDARD LVCMOS33} [get_ports cam_vsync_1]
  28. set_property-dict {PACKAGE_PIN G13 IOSTANDARD LVCMOS33} [get_ports cam_href_1]
  29. set_property-dict {PACKAGE_PIN H13 IOSTANDARD LVCMOS33} [get_ports cam_scl_1]
  30. set_property-dict {PACKAGE_PIN F15 IOSTANDARD LVCMOS33} [get_ports cam_sda_1]
  31. set_propertyPULLUP true [get_ports cam_scl_1]
  32. set_propertyPULLUP true [get_ports cam_sda_1]

  34. set_property-dict {PACKAGE_PIN D11 IOSTANDARD LVCMOS33} [get_ports cam_pclk_2]
  35. set_property-dict {PACKAGE_PIN A11 IOSTANDARD LVCMOS33} [get_ports cam_rst_n_2]
  36. set_property-dict {PACKAGE_PIN B14 IOSTANDARD LVCMOS33} [get_ports cam_pwdn_2]
  37. set_property-dict {PACKAGE_PIN C12 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[0]}]
  38. set_property-dict {PACKAGE_PIN C11 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[1]}]
  39. set_property-dict {PACKAGE_PIN B11 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[2]}]
  40. set_property-dict {PACKAGE_PIN B10 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[3]}]
  41. set_property-dict {PACKAGE_PIN A10 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[4]}]
  42. set_property-dict {PACKAGE_PIN E10 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[5]}]
  43. set_property-dict {PACKAGE_PIN E12 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[6]}]
  44. set_property-dict {PACKAGE_PIN D10 IOSTANDARD LVCMOS33 } [get_ports {cam_data_2[7]}]
  45. set_property-dict {PACKAGE_PIN A15 IOSTANDARD LVCMOS33} [get_ports cam_vsync_2]
  46. set_property-dict {PACKAGE_PIN A12 IOSTANDARD LVCMOS33} [get_ports cam_href_2]
  47. set_property-dict {PACKAGE_PIN A14 IOSTANDARD LVCMOS33} [get_ports cam_scl_2]
  48. set_property-dict {PACKAGE_PIN D12 IOSTANDARD LVCMOS33} [get_ports cam_sda_2]
  49. set_propertyPULLUP true [get_ports cam_scl_2]
  50. set_propertyPULLUP true [get_ports cam_sda_2]
复制代码

34.4 程序设计
根据实验任务，首先设计如图 34.4.1所示的系统框图，本章实验的系统框架延续了“OV5640摄像头RGB-LCD显示实验”的整体架构。顶层同样是例化了DDR4顶层模块、OV5640驱动顶层模块、图像分辨率处理模块以及LCD驱动顶层模块。其中除了图像分辨率处理模块没有做任何修改之外，其他三个模块都有一点小小的改动。下面就来给大家重点讲解改动的部分内容。           
image001.png
图 34.4.1 顶层系统框图

我们先来看看改动最小的一个模块，即OV5640驱动模块，这个模块从本质上来讲是没有做任何修改的，学习过之前“OV5640摄像头RGB-LCD显示实验”的同学应该都知道，OV5640驱动模块其实还包含了三个子模块，分别对应摄像头的寄存器配置、IIC驱动以及数据采集三个功能。双目摄像头其实就是将两个OV5640合在一起工作，所以针对OV5640驱动模块我们只需要把它例化两次就可以，给两个摄像头都进行寄存器配置、IIC驱动以及数据采集。因此在本节实验的顶层文件中调用了两次OV5640驱动模块以达到同时控制两个摄像头的目的，顶层RTL视图如下所示：
image003.png
图 34.4.2 顶层模块原理图

由于摄像头驱动模块内部的代码没有做任何修改，所以这里就不贴出代码了，下面我们一起来看看LCD驱动模块做了哪些修改。其实LCD驱动模块仅仅只是在“OV5640摄像头RGB-LCD显示实验”的基础上又添加了一个显示模块（lcd_disply），这个显示模块的主要作用就是用来在LCD显示屏上显示两个字符串“OV5640 1”和“OV5640 2”。因为本节实验是双目摄像头同时将画面一左一右的显示在LCD屏幕上，为了区分哪边的画面对应哪个摄像头，需要在LCD屏幕上左右两边显示“OV5640 1”和“OV5640 2”字符，这样就好区分画面对应哪个摄像头了。

lcd_disply字符串显示模块的代码如下：
  1. 1  module lcd_disply(
  2. 2       input             lcd_clk,      //lcd模块驱动时钟
  3. 3       input             sys_rst_n,    //复位信号
  4. 4       //RGB LCD接口                             
  5. 5       input      [ 10:0 pixel_xpos,   //像素点横坐标
  6. 6       input      [ 10:0 pixel_ypos,   //像素点纵坐标
  7. 7       input      [15:0  rd_data,      //图像像素值
  8. 8       input      [12:0  rd_h_pixel,   //摄像头输出的水平方向分辨率
  9. 9       output reg [15:0 pixel_data    //像素点数据,
  10. 10      );
  11. 11
  12. 12 //LCD的ID
  13. 13 parameter  ID_4342 =   16'h4342;
  14. 14 parameter  ID_7084 =   16'h7084;
  15. 15 parameter  ID_7016 =   16'h7016;
  16. 16 parameter  ID_1018 =   16'h1018;
  17. 17 parameter  ID_4384 =   16'h4384;
  18. 18
  19. 19 //颜色定义
  20. 20 localparam RED    = 16'b11111_000000_00000;     //字符颜色
  21. 21 localparam BLUE   =16'b00000_000000_11111;     //字符区域背景色
  22. 22 localparam BLACK  = 16'b00000_000000_00000;     //屏幕背景色  
  23. 23
  24. 24 //reg define                                    
  25. 25 reg  [63:0  char0[15:0];                      //字符数组0
  26. 26 reg  [63:0  char1[15:0];                      //字符数组1
  27. 27 reg  [127:0 char2[32:0];                      //字符数组2
  28. 28 reg  [127:0 char3[32:0];                      //字符数组3
  29. 29
  30. 30 //*****************************************************
  31. 31 //**                    main code                     
  32. 32 //*****************************************************
  33. 33
复制代码

关于如何在LCD显示屏幕上显示字符串我相信大家都不陌生了，在前面专门有一个“LCD字符图片显示实验”的例程来教大家如何在LCD显示屏幕上显示字符串和图片。本模块实现了五种RGB-LCD屏不同区域显示内容的逻辑判断，同时实现了字符叠加功能。

代码第25行到28行，定义了四个二维数组char，用于存储对英文取模得到的点阵数据，具体代码讲解，可以参看“RGB-LCD字符和图片显示实验”实验。

代码第20行到22行，定义了不同颜色对应的参数。代码第35行到144行给我们要用到的四个字符的模值进行赋值。在本次实验中LCD屏幕上要显示的字符大小为32*128，左右半边分别叠加上的“OV5640 1”和“OV5640 2”。
  1. 34 //给字符数组0的赋值：OV5640 0(16*64)
  2. 35 always @(posedge lcd_clk) begin
  3. 36      char0[0  <= 64'h0000000000000000      ;
  4. 37      char0[1  <= 64'h0000000000000000      ;
  5. 38      char0[2  <= 64'h0000000000000000      ;
  6. 39      char0[3  <= 64'h38E77E1804180008      ;
  7. 40      char0[4  <= 64'h444240240C240038      ;
  8. 41      char0[5  <= 64'h824240400C420008      ;
  9. 42      char0[6  <= 64'h8244404014420008      ;
  10. 43      char0[7  <= 64'h8224785C24420008      ;
  11. 44      char0[8  <= 64'h8224446224420008      ;
  12. 45      char0[9  <= 64'h8228024244420008      ;
  13. 46      char0[10 <= 64'h822802427F420008      ;
  14. 47      char0[11 <= 64'h8218424204420008      ;
  15. 48      char0[12 <= 64'h4410442204240008      ;
  16. 49      char0[13 <= 64'h3810381C1F18003E      ;
  17. 50      char0[14 <= 64'h0000000000000000      ;
  18. 51      char0[15 <= 64'h0000000000000000      ;
  19. 52 end
  20. 53
  21. 54 //给字符数组1的赋值: OV56401 (16*64)
  22. 55 always @(posedge lcd_clk) begin
  23. 56      char1[0  <= 64'h0000000000000000      ;
  24. 57      char1[1  <= 64'h0000000000000000      ;
  25. 58      char1[2  <= 64'h0000000000000000      ;
  26. 59      char1[3  <= 64'h38E77E180418003C      ;
  27. 60      char1[4  <= 64'h444240240C240042      ;
  28. 61      char1[5  <= 64'h824240400C420042      ;
  29. 62      char1[6  <= 64'h8244404014420042      ;
  30. 63      char1[7  <= 64'h8224785C24420002      ;
  31. 64      char1[8  <= 64'h8224446224420004      ;
  32. 65      char1[9  <= 64'h8228024244420008      ;
  33. 66      char1[10 <= 64'h822802427F420010      ;   
  34. 67      char1[11 <= 64'h8218424204420020      ;
  35. 68      char1[12 <= 64'h4410442204240042      ;
  36. 69      char1[13 <= 64'h3810381C1F18007E      ;
  37. 70      char1[14 <= 64'h0000000000000000      ;
  38. 71      char1[15 <= 64'h0000000000000000      ;
  39. 72 end
  40. 73
  41. 74 //给字符数组2的赋值: OV56400 (32*128)
  42. 75 always @(posedge lcd_clk) begin               
  43. 76      char2[0  <= 128'h00000000000000000000000000000000;
  44. 77      char2[1  <= 128'h00000000000000000000000000000000;
  45. 78      char2[2  <= 128'h00000000000000000000000000000000;
  46. 79      char2[3  <= 128'h00000000000000000000000000000000;
  47. 80      char2[4  <= 128'h00000000000000000000000000000000;
  48. 81      char2[5  <= 128'h00000000000000000000000000000000;
  49. 82      char2[6  <= 128'h03C07C1E0FFC01E0006003C000000080;
  50. 83      char2[7  <= 128'h0C30180C0FFC06180060062000000180;
  51. 84      char2[8  <= 128'h1818180810000C1800E00C3000001F80;
  52. 85      char2[9  <= 128'h100818081000081800E0181800000180;
  53. 86      char2[10 <= 128'h300C1808100018000160181800000180;
  54. 87      char2[11 <= 128'h300C0C10100010000160180800000180;
  55. 88      char2[12 <= 128'h60040C10100010000260300C00000180;
  56. 89      char2[13 <= 128'h60060C10100030000460300C00000180;
  57. 90      char2[14 <= 128'h60060C1013E033E00460300C00000180;
  58. 91      char2[15 <= 128'h60060C20143036300860300C00000180;
  59. 92      char2[16 <= 128'h60060620181838180860300C00000180;
  60. 93      char2[17 <= 128'h60060620100838081060300C00000180;
  61. 94      char2[18 <= 128'h60060620000C300C3060300C00000180;
  62. 95      char2[19 <= 128'h60060640000C300C2060300C00000180;
  63. 96      char2[20 <= 128'h60060340000C300C4060300C00000180;
  64. 97      char2[21 <= 128'h20060340000C300C7FFC300C00000180;
  65. 98      char2[22 <= 128'h300C0340300C300C0060180800000180;
  66. 99      char2[23 <= 128'h300C0380300C180C0060181800000180;
  67. 100     char2[24 <= 128'h10080180201818080060181800000180;
  68. 101     char2[25 <= 128'h1818018020180C1800600C3000000180;
  69. 102     char2[26 <= 128'h0C30010018300E3000600620000003C0;
  70. 103     char2[27 <= 128'h03C0010007C003E003FC03C000001FF8;
  71. 104     char2[28 <= 128'h00000000000000000000000000000000;
  72. 105     char2[29 <= 128'h00000000000000000000000000000000;
  73. 106     char2[30 <= 128'h00000000000000000000000000000000;
  74. 107     char2[31 <= 128'h00000000000000000000000000000000;
  75. 108 end
  76. 109
  77. 110 //给字符数组3的赋值: OV5640 1 (32*128)
  78. 111 always @(posedge lcd_clk) begin               
  79. 112     char3[0  <= 128'h00000000000000000000000000000000;
  80. 113     char3[1  <= 128'h00000000000000000000000000000000;
  81. 114     char3[2  <= 128'h00000000000000000000000000000000;
  82. 115     char3[3  <= 128'h00000000000000000000000000000000;
  83. 116     char3[4  <= 128'h00000000000000000000000000000000;
  84. 117     char3[5  <= 128'h00000000000000000000000000000000;
  85. 118     char3[6  <= 128'h03C07C1E0FFC01E0006003C0000007E0;
  86. 119     char3[7  <= 128'h0C30180C0FFC06180060062000000838;
  87. 120     char3[8  <= 128'h1818180810000C1800E00C3000001018;
  88. 121     char3[9  <= 128'h100818081000081800E018180000200C;
  89. 122     char3[10 <= 128'h300C180810001800016018180000200C;
  90. 123     char3[11 <= 128'h300C0C1010001000016018080000300C;
  91. 124     char3[12 <= 128'h60040C10100010000260300C0000300C;
  92. 125     char3[13 <= 128'h60060C10100030000460300C0000000C;
  93. 126     char3[14 <= 128'h60060C1013E033E00460300C00000018;
  94. 127     char3[15 <= 128'h60060C20143036300860300C00000018;
  95. 128     char3[16 <= 128'h60060620181838180860300C00000030;
  96. 129     char3[17 <= 128'h60060620100838081060300C00000060;
  97. 130     char3[18 <= 128'h60060620000C300C3060300C000000C0;
  98. 131     char3[19 <= 128'h60060640000C300C2060300C00000180;
  99. 132     char3[20 <= 128'h60060340000C300C4060300C00000300;
  100. 133     char3[21 <= 128'h20060340000C300C7FFC300C00000200;
  101. 134     char3[22 <= 128'h300C0340300C300C0060180800000404;
  102. 135     char3[23 <= 128'h300C0380300C180C0060181800000804;
  103. 136     char3[24 <= 128'h10080180201818080060181800001004;
  104. 137     char3[25 <= 128'h1818018020180C1800600C300000200C;
  105. 138     char3[26 <= 128'h0C30010018300E300060062000003FF8;
  106. 139     char3[27 <= 128'h03C0010007C003E003FC03C000003FF8;
  107. 140     char3[28 <= 128'h00000000000000000000000000000000;
  108. 141     char3[29 <= 128'h00000000000000000000000000000000;
  109. 142     char3[30 <= 128'h00000000000000000000000000000000;
  110. 143     char3[31 <= 128'h00000000000000000000000000000000;                                 
  111. 144 end
  112. 145
复制代码
代码从144行往后是显示逻辑的具体实现，由于代码涉及到了判断条件之间的多重嵌套，为了让我们快速理清思路，我们结合代码制作了如图 34.4.3所示的显示逻辑图。结合代码和图，我们来具体介绍。

首先我们对屏幕类型和图像像素纵坐标进行判断，对于所有屏幕，如果纵坐标值不在字符显示区域内，我们执行代码第170行，让屏幕显示图像像素的值。只有当纵坐标值位于字符显示区域内，我们正式开始字符叠加处理。
  1. 146 //显示逻辑判断
  2. 147 always@(posedge lcd_clk) begin  
  3. 148     if(pixel_ypos >= 0 && pixel_ypos < 33)begin
  4. 149         //判断像素坐标是否在左半边屏幕中间
  5. 150         if(pixel_xpos < (rd_h_pixel[12:2]+64)
  6. 151         && pixel_xpos >= (rd_h_pixel[12:2]-64) )begin
  7. 152             //读取字模OV56401 (32*128)
  8. 153             if(char2[pixel_ypos][127-(pixel_xpos-rd_h_pixel[12:2]+64)])
  9. 154                 pixel_data <=BLUE;  //字模数组中的"1"显示蓝色
  10. 155             else                  //字模数组中的"0"显示图像像素值
  11. 156             pixel_data <= rd_data;
  12. 157         end    //判断像素坐标是否在右半边屏幕中间
  13. 158         else if(pixel_xpos < (rd_h_pixel[12:2]*3+64)
  14. 159         && pixel_xpos >= (rd_h_pixel[12:2]*3-64))begin
  15. 160             //读取字模OV56402 (32*128)
  16. 161             if(char3[pixel_ypos][63-pixel_xpos+(rd_h_pixel[12:2])*3])
  17. 162                 pixel_data <=BLUE;  //字模数组中的"1"显示蓝色
  18. 163             else                   //字模数组中的"0"显示图像像素值
  19. 164                 pixel_data <= rd_data;
  20. 165         end
  21. 166         else            //纵坐标位于字符区域内的字符两边区域显示黑色
  22. 167             pixel_data <= rd_data;
  23. 168     end      
  24. 169     else               //所有屏幕纵坐标位于字符区域外时显示像素值
  25. 170         pixel_data <= rd_data;
  26. 171 end
  27. 172
  28. 173 endmodule
复制代码
代码第148行，通过判断了像素点纵坐标的位置。代码第150行和151行，此时开始判断像素点横坐标位置，如果此时横坐标处于左半边的中间位置，此时执行代码第153行，开始读取“OV5640 1”的字符数组的值。代码第154到156行，将字模数组中为“1”的点的像素值赋值为蓝色，为“0”的点像素值赋值为图像像素的值。这就是LCD屏左半边字符叠加的实现。代码第158到164行，实现的是LCD屏右半边字符叠加，实现的代码形式一模一样，只是字模数组变为了“OV5640 2”，在这里我们不再重复。代码第170行，非字符纵坐标区域，显示图片像素值。
image006.png
图 34.4.3 显示逻辑

接下来我们重点来看看DDR4顶层模块，它包含了MIG IP核、DDR4读写模块以及FIFO调度模块。这三个子模块，除了官方的MIG IP核配置没改变之外，其他的像DDR4读写模块（ddr4_rw）和FIFO调度模块都做了修改。
下面是DDR4顶层模块的系统框图：
image007.png
图 34.4.4 DDR控制模块的系统框图

结合图可以看出相较于“OV5640摄像头RGB-LCD显示实验”，本次实验将FIFO调度模块替换成了FIFO顶层调度模块。本次实验是两个摄像头采集数据并且把数据存入两个写FIFO，两个写FIFO再将数据写入DDR4的两个不同的存储空间中，接着两个读FIFO分别从两个对应的DDR4地址空间中取出数据，最后两组数据一起拼接为完整一帧LCD图像，达到一个屏幕同时显示两幅图像的效果。在DDR4处理数据的时候，两组数据流相当于过独木桥，需要分时“排队”进出；同样在显示端，两组数据也要“排队”显示，所以本次实验的FIFO顶层调度模块的作用就是根据不同的情况对两个FIFO调度模块的信号进行切换。

下面是DDR控制模块的原理图：
image009.png
图34.4.5 DDR4顶层模块

DDR读写模块：该模块负责与MIG模块的命令和地址的交互，根据FIFO顶层调度模块中各个FIFO的剩余数据量来切换DDR4的读写命令和地址。

MIG模块：MIG模块(ddr4_0)负责连接外设和FPGA，详细说明请看“DDR4读写测试实验”。

FIFO顶层调度模块：负责对输入和输出的数据进行时钟域的切换和位宽的转换，并根据DDR读写模块输出的使能来调度四个FIFO的数据。

下面是DDR控制模块的代码：
  1. 1  module ddr4_top(
  2. 2       input             sys_rst_n       ,   //复位,低有效
  3. 3       input             sys_init_done   ,   //系统初始化完成               
  4. 4       //DDR4接口信号                       
  5. 5       input   [27:0    app_addr_rd_min ,   //读DDR4的起始地址
  6. 6       input   [27:0    app_addr_rd_max ,   //读DDR4的结束地址
  7. 7       input   [7:0     rd_bust_len     ,   //从DDR4中读数据时的突发长度
  8. 8       input   [27:0    app_addr_wr_min ,   //读DDR4的起始地址
  9. 9       input   [27:0    app_addr_wr_max ,   //读DDR4的结束地址
  10. 10      input   [7:0     wr_bust_len     ,   //从DDR4中读数据时的突发长度
  11. 11      // DDR4 IO接口   
  12. 12      input             c0_sys_clk_p    ,
  13. 13      input             c0_sys_clk_n    ,
  14. 14      output            c0_ddr4_act_n   ,
  15. 15      output [16:0     c0_ddr4_adr     ,
  16. 16      output [1:0       c0_ddr4_ba      ,
  17. 17      output [0:0       c0_ddr4_bg      ,
  18. 18      output [0:0       c0_ddr4_cke     ,
  19. 19      output [0:0       c0_ddr4_odt     ,
  20. 20      output [0:0       c0_ddr4_cs_n    ,
  21. 21      output [0:0       c0_ddr4_ck_t    ,
  22. 22      output [0:0       c0_ddr4_ck_c    ,
  23. 23      output            c0_ddr4_reset_n ,
  24. 24      inout  [1:0      c0_ddr4_dm_dbi_n,
  25. 25      inout  [15:0     c0_ddr4_dq      ,
  26. 26      inout  [1:0      c0_ddr4_dqs_c   ,
  27. 27      inout  [1:0      c0_ddr4_dqs_t   ,
  28. 28
  29. 29      //用户
  30. 30      input  [12:0     h_disp              ,
  31. 31      input             ddr4_read_valid     ,   //DDR4 读使能   
  32. 32      input             ddr4_pingpang_en    ,   //DDR4 乒乓操作使能      
  33. 33      input             wr_clk_1            ,   //wfifo时钟
  34. 34      input             wr_clk_2            ,   //wfifo时钟  
  35. 35      input              rd_clk              ,   //rfifo的读时钟      
  36. 36      input             datain_valid_1      ,   //数据有效使能信号
  37. 37      input             datain_valid_2      ,   //数据有效使能信号
  38. 38      input   [15:0    datain_1            ,   //有效数据
  39. 39      input   [15:0    datain_2            ,   //有效数据
  40. 40      input             rdata_req           ,   //请求像素点颜色数据输入  
  41. 41      input             rd_load             ,   //输出源更新信号
  42. 42      input             wr_load_1           ,   //输入源更新信号
  43. 43      input             wr_load_2           ,   //输入源更新信号
  44. 44      output  [15:0    dataout             ,   //rfifo输出数据
  45. 45      output            clk_50m             ,
  46. 46      output            init_calib_complete     //ddr4初始化完成信号
  47. 47      );               
  48. 48                     
  49. 49 //wire define  
  50. 50 wire                  ui_clk               ;   //用户时钟
  51. 51 wire [27:0          app_addr             ;   //ddr4 地址
  52. 52 wire [2:0           app_cmd              ;   //用户读写命令
  53. 53 wire                  app_en               ;   //MIG IP核使能
  54. 54 wire                  app_rdy              ;   //MIG IP核空闲
  55. 55 wire [127:0         app_rd_data          ;   //用户读数据
  56. 56 wire                  app_rd_data_end      ;   //突发读当前时钟最后一个数据
  57. 57 wire                  app_rd_data_valid    ;   //读数据有效
  58. 58 wire [127:0         app_wdf_data         ;   //用户写数据
  59. 59 wire                  app_wdf_end          ;   //突发写当前时钟最后一个数据
  60. 60 wire [15:0          app_wdf_mask         ;   //写数据屏蔽                           
  61. 61 wire                  app_wdf_rdy          ;   //写空闲                              
  62. 62 wire                  app_sr_active        ;   //保留                                 
  63. 63 wire                  app_ref_ack          ;   //刷新请求                             
  64. 64 wire                  app_zq_ack           ;   //ZQ 校准请求                          
  65. 65 wire                  app_wdf_wren         ;   //ddr4 写使能                          
  66. 66 wire                  clk_ref_i            ;   //ddr4参考时钟                        
  67. 67 wire                  sys_clk_i            ;   //MIG IP核输入时钟                     
  68. 68 wire                  ui_clk_sync_rst      ;   //用户复位信号                        
  69. 69 wire [20:0          rd_cnt               ;   //实际读地址计数                       
  70. 70 wire [3 :0          state_cnt            ;   //状态计数器                           
  71. 71 wire [23:0          rd_addr_cnt          ;   //用户读地址计数器                     
  72. 72 wire [23:0           wr_addr_cnt          ;   //用户写地址计数器                     
  73. 73 wire                  rfifo_wren           ;   //从DDR4读出数据的有效使能              
  74. 74 wire [127:0         rfifo_wdata_1        ;   //rfifo1输入数据  
  75. 75 wire [127:0         rfifo_wdata_2        ;   //rfifo2输入数据                                                                                   
  76. 76 wire [10:0          wfifo_rcount_1       ;   //wfifo1剩余数据计数
  77. 77 wire [10:0          wfifo_rcount_2       ;   //wfifo2剩余数据计数
  78. 78 wire [10:0          rfifo_wcount_1       ;   //rfifo1写进数据计数
  79. 79 wire [10:0          rfifo_wcount_2       ;
  80. 80
  81. 81                                                                                                                                                                     
  82. 82 //*****************************************************                              
  83. 83 //**                    main code                                                   
  84. 84 //*****************************************************                              
  85. 85                                                                                         
  86. 86 //读写模块                                                                           
  87. 87 ddr4_rw u_ddr4_rw(                                                                  
  88. 88      .ui_clk               (ui_clk)              ,                                    
  89. 89      .ui_clk_sync_rst      (ui_clk_sync_rst)     ,                                      
  90. 90      //MIG 接口                                                                       
  91. 91      .init_calib_complete  (init_calib_complete) ,   //ddr4初始化完成信号                                   
  92. 92      .app_rdy              (app_rdy)             ,   //MIG IP核空闲                                   
  93. 93      .app_wdf_rdy          (app_wdf_rdy)         ,   //写空闲                                 
  94. 94      .app_rd_data_valid    (app_rd_data_valid)   ,   //读数据有效                                 
  95. 95      .app_rd_data           (app_rd_data)         ,
  96. 96      .app_addr             (app_addr)            ,   //ddr4 地址                                   
  97. 97      .app_en               (app_en)              ,   //MIG IP核使能                                 
  98. 98      .app_wdf_wren         (app_wdf_wren)        ,   //ddr4 写使能                                   
  99. 99      .app_wdf_end          (app_wdf_end)         ,   //突发写当前时钟最后一个数据                                 
  100. 100     .app_cmd              (app_cmd)             ,   //用户读写命令                                                                                                                        
  101. 101     //ddr4地址参数                                                                  
  102. 102     .app_addr_rd_min      (app_addr_rd_min)     ,   //读ddr4的起始地址                                 
  103. 103     .app_addr_rd_max      (app_addr_rd_max)     ,   //读ddr4的结束地址                                 
  104. 104     .rd_bust_len          (rd_bust_len)         ,   //从ddr4中读数据时的突发长度                                 
  105. 105     .app_addr_wr_min      (app_addr_wr_min)     ,   //写ddr4的起始地址                                 
  106. 106     .app_addr_wr_max      (app_addr_wr_max)     ,   //写ddr4的结束地址                                 
  107. 107     .wr_bust_len          (wr_bust_len)         ,   //从ddr4中写数据时的突发长度                                 
  108. 108     //用户接口                                                                        
  109. 109     .rfifo_wren_1         (rfifo_wren_1)        ,   //rfifo写使能
  110. 110     .rfifo_wdata_1        (rfifo_wdata_1)       ,   //rfifo写数据
  111. 111     .rfifo_wren_2         (rfifo_wren_2)        ,   //rfifo写使能  
  112. 112     .rfifo_wdata_2        (rfifo_wdata_2)       ,   //rfifo写数据
  113. 113     .wfifo_rden_1         (wfifo_rden_1)        ,   //写端口FIFO1中的读使能
  114. 114     .wfifo_rden_2         (wfifo_rden_2)        ,   //写端口FIFO2中的读使能
  115. 115     .rd_load              (rd_load)             ,   //输出源场信号
  116. 116     .wr_load_1            (wr_load_1)           ,   //输入源场信号
  117. 117     .wr_load_2            (wr_load_2)           ,   //输入源场信号   
  118. 118     .wfifo_rcount_1       (wfifo_rcount_1)      ,   //wfifo剩余数据计数                  
  119. 119     .rfifo_wcount_1       (rfifo_wcount_1)      ,   //rfifo写进数据计数
  120. 120     .wfifo_rcount_2       (wfifo_rcount_2)      ,   //wfifo剩余数据计数                  
  121. 121     .rfifo_wcount_2       (rfifo_wcount_2)      ,   //rfifo写进数据计数   
  122. 122     .wr_clk_2             (wr_clk_2)            ,   //wfifo时钟
  123. 123     .wr_clk_1             (wr_clk_1)
  124. 124     );                  
  125. 125
  126. 126 ddr4_0u_ddr4_0 (
  127. 127 .c0_init_calib_complete(init_calib_complete),           
  128. 128 .dbg_clk(),                          
  129. 129 .c0_sys_clk_p(c0_sys_clk_p),         
  130. 130 .c0_sys_clk_n(c0_sys_clk_n),         
  131. 131 .dbg_bus(),                          
  132. 132 .c0_ddr4_adr(c0_ddr4_adr),           
  133. 133 .c0_ddr4_ba(c0_ddr4_ba),            
  134. 134 .c0_ddr4_cke(c0_ddr4_cke),           
  135. 135 .c0_ddr4_cs_n(c0_ddr4_cs_n),         
  136. 136 .c0_ddr4_dm_dbi_n(c0_ddr4_dm_dbi_n),
  137. 137 .c0_ddr4_dq(c0_ddr4_dq),            
  138. 138 .c0_ddr4_dqs_c(c0_ddr4_dqs_c),      
  139. 139 .c0_ddr4_dqs_t(c0_ddr4_dqs_t),      
  140. 140 .c0_ddr4_odt(c0_ddr4_odt),           
  141. 141 .c0_ddr4_bg(c0_ddr4_bg),            
  142. 142 .c0_ddr4_reset_n(c0_ddr4_reset_n),   
  143. 143 .c0_ddr4_act_n(c0_ddr4_act_n),      
  144. 144 .c0_ddr4_ck_c(c0_ddr4_ck_c),         
  145. 145 .c0_ddr4_ck_t(c0_ddr4_ck_t),         
  146. 146 //user interface
  147. 147 .c0_ddr4_ui_clk(ui_clk),                     
  148. 148 .c0_ddr4_ui_clk_sync_rst(ui_clk_sync_rst),   
  149. 149 .c0_ddr4_app_en(app_en),                     
  150. 150 .c0_ddr4_app_hi_pri(1'b0),                    
  151. 151 .c0_ddr4_app_wdf_end(app_wdf_end),            
  152. 152 .c0_ddr4_app_wdf_wren(app_wdf_wren),         
  153. 153 .c0_ddr4_app_rd_data_end(app_rd_data_end),   
  154. 154 .c0_ddr4_app_rd_data_valid(app_rd_data_valid),
  155. 155 .c0_ddr4_app_rdy(app_rdy),                    
  156. 156 .c0_ddr4_app_wdf_rdy(app_wdf_rdy),            
  157. 157 .c0_ddr4_app_addr(app_addr),                  
  158. 158 .c0_ddr4_app_cmd(app_cmd),                  
  159. 159 .c0_ddr4_app_wdf_data(app_wdf_data),         
  160. 160 .c0_ddr4_app_wdf_mask(16'b0),               
  161. 161 .c0_ddr4_app_rd_data(app_rd_data),           
  162. 162 .addn_ui_clkout1(clk_50m),                  
  163. 163 .sys_rst(~sys_rst_n)                        
  164. 164 );
  165. 165                                                   
  166. 166 ddr4_fifo_ctrl_topu_ddr4_fifo_ctrl_top (
  167. 167
  168. 168     .rst_n             (sys_rst_n &&sys_init_done),  //复位信号   
  169. 169     .rd_clk            (rd_clk)                   ,  //rfifo时钟
  170. 170     .clk_100           (ui_clk)                   ,  //用户时钟
  171. 171     //fifo1接口信号   
  172. 172     .wr_clk_1          (wr_clk_1)                 ,  //wfifo时钟   
  173. 173     .datain_valid_1    (datain_valid_1)           ,  //数据有效使能信号
  174. 174     .datain_1          (datain_1)                 ,  //有效数据
  175. 175     .wr_load_1         (wr_load_1)                ,  //输入源场信号   
  176. 176     .rfifo_din_1       (rfifo_wdata_1)            ,  //rfifo写数据
  177. 177     .rfifo_wren_1      (rfifo_wren_1)             ,  //rfifo写使能
  178. 178     .wfifo_rden_1      (wfifo_rden_1)             ,  //wfifo读使能
  179. 179     .wfifo_rcount_1    (wfifo_rcount_1)           ,  //wfifo剩余数据计数
  180. 180     .rfifo_wcount_1    (rfifo_wcount_1)           ,  //rfifo写进数据计数   
  181. 181     //fifo2接口信号   
  182. 182     .wr_clk_2          (wr_clk_2)                 ,  //wfifo时钟   
  183. 183     .datain_valid_2    (datain_valid_2)           ,  //数据有效使能信号
  184. 184     .datain_2          (datain_2)                 ,  //有效数据   
  185. 185     .wr_load_2         (wr_load_2)                ,  //输入源场信号
  186. 186     .rfifo_din_2       (rfifo_wdata_2)            ,  //rfifo写数据
  187. 187     .rfifo_wren_2      (rfifo_wren_2)             ,  //rfifo写使能
  188. 188     .wfifo_rden_2      (wfifo_rden_2)             ,  //wfifo读使能   
  189. 189     .wfifo_rcount_2    (wfifo_rcount_2)           ,  //wfifo剩余数据计数
  190. 190     .rfifo_wcount_2    (rfifo_wcount_2)           ,  //rfifo写进数据计数
  191. 191                     
  192. 192     .h_disp            (h_disp)                   ,  //摄像头水平分辨率
  193. 193     .rd_load           (rd_load)                  ,  //输出源场信号
  194. 194     .rdata_req         (rdata_req)                ,  //请求像素点颜色数据输入     
  195. 195     .pic_data          (dataout)                  ,  //有效数据
  196. 196     .wfifo_dout        (app_wdf_data)                //用户写数据         
  197. 197     );
  198. 198
  199. 199 endmodule
复制代码
在“OV5640摄像头RGB-LCD显示实验”的程序中，读写操作地址用了DDR4的两个存储空间，但本次实验开辟了四个存储空间，使得两个摄像头的数据在DDR4的存储中互不影响，也方便调度，所以本次实验需要在“OV5640摄像头RGB-LCD显示实验”的程序方面做些改动。具体框图如下图所示：
image012.png
图 34.4.6 DDR读写控制流程图

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

本次实验中的DDR读写模块是基于“OV5640摄像头RGB-LCD显示实验”做的修改，本次实验着重对代码的改动部分做讲解。
  1. 40  //localparam
  2. 41  localparam IDLE          = 7'b0000001;   //空闲状态
  3. 42  localparam DDR4_DONE     = 7'b0000010;   //DDR4初始化完成状态
  4. 43  localparam WRITE_1       = 7'b0000100;   //读FIFO保持状态
  5. 44  localparam READ_1        = 7'b0001000;   //写FIFO保持状态
  6. 45  localparam WRITE_2       = 7'b0010000;   //读FIFO保持状态
  7. 46  localparam READ_2        = 7'b0100000;   //写FIFO保持状态
  8. 47  localparam READ_WAIT     = 7'b1000000;   //写FIFO保持状态
复制代码
在代码的40行至47行，相比于“OV5640摄像头RGB-LCD显示实验”多添加了三个状态，一个读状态，一个写状态，还有一个读等待状态。
  1. 105 //在写状态,MIG空闲且写有效，此时拉高FIFO写使能
  2. 106 assign wfifo_rden_1 = (state_cnt == WRITE_1  && (app_rdy && app_wdf_rdy)) ? 1'b1:1'b0;
  3. 107
  4. 108 //在写状态,MIG空闲且写有效，此时拉高FIFO写使能
  5. 109 assign wfifo_rden_2 = (state_cnt == WRITE_2 && (app_rdy && app_wdf_rdy)) ? 1'b1:1'b0;
复制代码
在代码的105行至109行，根据不同的写状态来给不同的WFIFO发出读数据使能信号。
  1. 117 //读端口FIFO1数据没有写完的使能信号
  2. 118 always @(posedge ui_clk or negedge rst_n)  begin
  3. 119     if(~rst_n || rd_rst)begin
  4. 120         rfifo_data_en_1 <= 0;   
  5. 121     end   
  6. 122     else begin
  7. 123         if(state_cnt == DDR4_DONE  )
  8. 124            rfifo_data_en_1 <= 0;
  9. 125         else if(state_cnt == READ_1 )
  10. 126            rfifo_data_en_1 <= 1;
  11. 127         else
  12. 128            rfifo_data_en_1 <= rfifo_data_en_1;         
  13. 129     end   
  14. 130 end
  15. 131
  16. 132 //读端口FIFO2数据没有写完的使能信号
  17. 133 always @(posedge ui_clk or negedge rst_n)  begin
  18. 134     if(~rst_n || rd_rst)begin
  19. 135         rfifo_data_en_2 <= 0;   
  20. 136     end   
  21. 137     else begin
  22. 138         if(state_cnt == DDR4_DONE)
  23. 139            rfifo_data_en_2 <= 0;
  24. 140         else if(state_cnt == READ_2 )
  25. 141            rfifo_data_en_2 <= 1;
  26. 142         else
  27. 143            rfifo_data_en_2 <= rfifo_data_en_2;         
  28. 144     end   
  29. 145 end
复制代码
在代码的117行至145行，对rfifo_data_en_1和rfifo_data_en_2进行了赋值，这两个信号在读操作开始后拉高，进入DDR4空闲状态拉低。信号为高时表示此次读操作所需要的数据没有全部从DDR4读出来，为低时，表示数据已经全部读出来了。
  1. 147  //从DDR4读出的有效数据使能进行计数
  2. 148 always @(posedge ui_clk or negedge rst_n)  begin
  3. 149     if(~rst_n || rd_rst )begin
  4. 150        data_valid_cnt <= 0;   
  5. 151     end   
  6. 152     else begin
  7. 153         if(state_cnt == DDR4_DONE )
  8. 154            data_valid_cnt <= 0;     
  9. 155         else if(app_rd_data_valid)
  10. 156            data_valid_cnt <= data_valid_cnt + 1;
  11. 157         else
  12. 158            data_valid_cnt <= data_valid_cnt;            
  13. 159     end   
  14. 160 end
复制代码
在代码的147行至160行，对DDR4读出数据的有效使能（app_rd_data_valid）进行了计数。
  1. 162  //对DDR读数据的输出端进行选择
  2. 163 always @(posedge ui_clk or negedge rst_n)  begin
  3. 164     if(~rst_n || rd_rst)begin
  4. 165         rfifo_wren_1 <= 0;
  5. 166         rfifo_wren_2 <= 0;
  6. 167         rfifo_wdata_1 <= 0;
  7. 168         rfifo_wdata_2 <= 0;        
  8. 169     end   
  9. 170     else begin
  10. 171         if(rfifo_data_en_1)begin
  11. 172             rfifo_wren_1 <= app_rd_data_valid;
  12. 173             rfifo_wdata_1 <= app_rd_data;
  13. 174             rfifo_wren_2 <= 0;
  14. 175             rfifo_wdata_2 <= 0;                       
  15. 176         end
  16. 177         else if(rfifo_data_en_2)begin
  17. 178             rfifo_wren_2 <= app_rd_data_valid;
  18. 179             rfifo_wdata_2 <= app_rd_data;           
  19. 180             rfifo_wren_1 <= 0;
  20. 181             rfifo_wdata_1 <= 0;                       
  21. 182         end        
  22. 183         else begin
  23. 184             rfifo_wren_2 <= 0;
  24. 185             rfifo_wdata_2 <= 0;
  25. 186             rfifo_wren_1 <= 0;
  26. 187             rfifo_wdata_1 <= 0;               
  27. 188         end        
  28. 189         
  29. 190     end   
  30. 191 end
复制代码
在代码的162行至191行，根据信号rfifo_data_en_1和rfifo_data_en_2来判断是哪个rfifo将要空了，并把DDR4读出的数据写入这个rfifo。
  1. 193 //将数据读写地址赋给ddr地址
  2. 194 always @(*)  begin
  3. 195     if(~rst_n)
  4. 196         app_addr <= 0;
  5. 197     else if(state_cnt == READ_1 )
  6. 198         app_addr <= {3'b0,raddr_page_1,1'b0,app_addr_rd_1[22:0]};
  7. 199     else if(state_cnt == READ_2 )
  8. 200         app_addr <= {3'b1,raddr_page_2,1'b0,app_addr_rd_2[22:0]};
  9. 201     else if(state_cnt == WRITE_1 )
  10. 202         app_addr <= {3'b0,waddr_page_1,1'b0,app_addr_wr_1[22:0]};        
  11. 203     else
  12. 204         app_addr <= {3'b1,waddr_page_2,1'b0,app_addr_wr_2[22:0]};
  13. 205 end
复制代码
在代码的193行至205行，根据不同的状态写入相对应的地址。在代码的200行和204行，将信号app_addr的高三位赋1，其用意是为了和另一个输入源的存储空间做区分。信号raddr_page_1和waddr_page_1是对同一个输入源的两个存储空间的切换信号，同理信号raddr_page_2和waddr_page_2也是如此。
  1. 322 //DDR4读写逻辑实现
  2. 323 always @(posedge ui_clk or negedge rst_n) begin
  3. 324     if(~rst_n) begin
  4. 325         state_cnt    <= IDLE;              
  5. 326         wr_addr_cnt_1  <= 24'd0;      
  6. 327         rd_addr_cnt_1  <= 24'd0;      
  7. 328         app_addr_wr_1  <= 28'd0;   
  8. 329         app_addr_rd_1  <= 28'd0;
  9. 330         wr_addr_cnt_2  <= 24'd0;      
  10. 331         rd_addr_cnt_2  <= 24'd0;      
  11. 332         app_addr_wr_2  <= 28'd0;   
  12. 333         app_addr_rd_2  <= 28'd0;         
  13. 334     end
  14. 335     else begin
  15. 336         case(state_cnt)
  16. 337             IDLE:begin
  17. 338                 if(init_calib_complete)
  18. 339                     state_cnt <= DDR4_DONE ;
  19. 340                 else
  20. 341                     state_cnt <= IDLE;
  21. 342             end
  22. 343             DDR4_DONE:begin  //当wfifo1存储数据超过一次突发长度时，跳到写操作1
  23. 344                 if(wfifo_rcount_1 >= wr_bust_len - 2 )begin  
  24. 345                     state_cnt <= WRITE_1;                    
  25. 346                 end         //当wfifo2存储数据超过一次突发长度时，跳到写操作2
  26. 347                 else if(wfifo_rcount_2 >= wr_bust_len - 2 )begin
  27. 348                     state_cnt <= WRITE_2;                    
  28. 349                 end               
  29. 350                 else if(raddr_rst_h)begin         //当帧复位到来时，对寄存器进行复位
  30. 351                     if(raddr_rst_h_cnt >= 1000 && star_rd_flag)begin
  31. 352                         state_cnt <= READ_1;      //保证读fifo在复位时不会进行读操作            
  32. 353                     end
  33. 354                     else begin
  34. 355                         state_cnt <= DDR4_DONE;                     
  35. 356                     end                                
  36. 357                 end //当rfifo1存储数据少于设定阈值时，并且输入源1已经写入ddr 1帧数据                                    
  37. 358                 else if(rfifo_wcount_1 < 5 && star_rd_flag )begin  //跳到读操作1
  38. 359                     state_cnt <= READ_1;                                                
  39. 360                 end //当rfifo1存储数据少于设定阈值时，并且输入源1已经写入ddr 1帧数据                                    
  40. 361                 else if(rfifo_wcount_2 < 5 && star_rd_flag )begin  //跳到读操作2
  41. 362                     state_cnt <= READ_2;                                                                                       
  42. 363                 end                                                                                                            
  43. 364                 else begin
  44. 365                     state_cnt <= state_cnt;                     
  45. 366                 end
  46. 367                              
  47. 368                 if(raddr_rst_h)begin        //当帧复位到来时，对信号进行复位      
  48. 369                     rd_addr_cnt_1  <= 24'd0;      
  49. 370                     app_addr_rd_1 <= app_addr_rd_min;
  50. 371                     rd_addr_cnt_2  <= 24'd0;      
  51. 372                     app_addr_rd_2 <= app_addr_rd_min;                                                      
  52. 373                 end //当rfifo1存储数据少于设定阈值时，并且输入源1已经写入ddr 1帧数据
  53. 374                 else if(rfifo_wcount_1 < 5 && star_rd_flag )begin            
  54. 375                     rd_addr_cnt_1 <= 24'd0;            //计数器清零
  55. 376                     app_addr_rd_1 <= app_addr_rd_1;    //读地址保持不变
  56. 377                 end //当rfifo1存储数据少于设定阈值时，并且输入源1已经写入ddr 1帧数据
  57. 378                 else if(rfifo_wcount_2 < 5 && star_rd_flag )begin            
  58. 379                     rd_addr_cnt_2 <= 24'd0;            //计数器清零
  59. 380                     app_addr_rd_2 <= app_addr_rd_2;    //读地址保持不变
  60. 381                 end                                                                                                            
  61. 382                 else begin
  62. 383                     wr_addr_cnt_1  <= 24'd0;      
  63. 384                     rd_addr_cnt_1  <= 24'd0;                     
  64. 385                 end               
  65. 386   
  66. 387                 if(wr_rst_2)begin             //当帧复位到来时，对信号进行复位
  67. 388                     wr_addr_cnt_2  <= 24'd0;   
  68. 389                     app_addr_wr_2 <= app_addr_wr_min;                  
  69. 390                 end                    //当wfifo存储数据超过一次突发长度时
  70. 391                 else if(wfifo_rcount_2 >= wr_bust_len - 2 )begin  
  71. 392                     wr_addr_cnt_2  <= 24'd0;                   //计数器清零   
  72. 393                     app_addr_wr_2 <= app_addr_wr_2;            //写地址保持不变
  73. 394                  end
  74. 395                  else begin
  75. 396                     wr_addr_cnt_2  <= wr_addr_cnt_2;
  76. 397                     app_addr_wr_2  <= app_addr_wr_2;                  
  77. 398                  end
  78. 399   
  79. 400                  if(wr_rst_1)begin               //当帧复位到来时，对信号进行复位
  80. 401                     wr_addr_cnt_1  <= 24'd0;   
  81. 402                     app_addr_wr_1 <= app_addr_wr_min;                  
  82. 403                 end                  //当wfifo存储数据超过一次突发长度时
  83. 404                 else if(wfifo_rcount_1 >= wr_bust_len - 2 )begin  
  84. 405                     wr_addr_cnt_1  <= 24'd0;                   //计数器清零     
  85. 406                     app_addr_wr_1 <= app_addr_wr_1;            //写地址保持不变
  86. 407                  end
  87. 408                  else begin
  88. 409                     wr_addr_cnt_1  <= wr_addr_cnt_1;
  89. 410                     app_addr_wr_1  <= app_addr_wr_1;                  
  90. 411                  end
  91. 412                 
  92. 413             end   
  93. 414             WRITE_1:   begin
  94. 415                 if((wr_addr_cnt_1 == (wr_bust_len - 1)) &&
  95. 416                    (app_rdy && app_wdf_rdy))begin        //写到设定的长度跳到等待状态                  
  96. 417                     state_cnt    <= DDR4_DONE;           //写到设定的长度跳到等待状态               
  97. 418                     app_addr_wr_1 <= app_addr_wr_1 + 8;  //一次性写进8个数，故加8
  98. 419                 end      
  99. 420                 else if(app_rdy && app_wdf_rdy)begin       //写条件满足
  100. 421                     wr_addr_cnt_1  <= wr_addr_cnt_1 + 1'd1;//写地址计数器自加
  101. 422                     app_addr_wr_1  <= app_addr_wr_1 + 8;   //一次性写进8个数，故加8
  102. 423                 end
  103. 424                 else begin                                 //写条件不满足，保持当前值     
  104. 425                     wr_addr_cnt_1  <= wr_addr_cnt_1;
  105. 426                     app_addr_wr_1  <= app_addr_wr_1;
  106. 427                 end
  107. 428             end
  108. 429             WRITE_2:   begin
  109. 430                 if((wr_addr_cnt_2 == (wr_bust_len - 1)) &&
  110. 431                    (app_rdy && app_wdf_rdy))begin         //写到设定的长度跳到等待状态                  
  111. 432                     state_cnt    <= DDR4_DONE;            //写到设定的长度跳到等待状态               
  112. 433                     app_addr_wr_2 <= app_addr_wr_2 + 8;   //一次性写进8个数，故加8
  113. 434                 end      
  114. 435                 else if(app_rdy && app_wdf_rdy)begin      //写条件满足
  115. 436                     wr_addr_cnt_2  <= wr_addr_cnt_2 + 1'd1; //写地址计数器自加
  116. 437                     app_addr_wr_2  <= app_addr_wr_2 + 8; //一次性写进8个数，故加8
  117. 438                 end
  118. 439                 else begin                              //写条件不满足，保持当前值     
  119. 440                     wr_addr_cnt_2  <= wr_addr_cnt_2;
  120. 441                     app_addr_wr_2  <= app_addr_wr_2;
  121. 442                 end
  122. 443             end            
  123. 444             READ_1:begin                                  //读到设定的地址长度   
  124. 445                 if((rd_addr_cnt_1 == (rd_bust_len - 1)) && app_rdy)begin
  125. 446                     state_cnt   <= READ_WAIT;             //则跳到空闲状态
  126. 447                     app_addr_rd_1 <= app_addr_rd_1 + 8;
  127. 448                 end      
  128. 449                 else if(app_rdy)begin                   //若MIG已经准备好,则开始读
  129. 450                     rd_addr_cnt_1 <= rd_addr_cnt_1 + 1'd1; //用户地址计数器每次加一
  130. 451                     app_addr_rd_1 <= app_addr_rd_1 + 8; //一次性读出8个数,DDR4地址加8
  131. 452                 end
  132. 453                 else begin                               //若MIG没准备好,则保持原值
  133. 454                     rd_addr_cnt_1 <= rd_addr_cnt_1;
  134. 455                     app_addr_rd_1 <= app_addr_rd_1;
  135. 456                 end
  136. 457                 
  137. 458                 if(wr_rst_2)begin                    //当帧复位到来时，对信号进行复位
  138. 459                     wr_addr_cnt_2  <= 24'd0;   
  139. 460                     app_addr_wr_2 <= app_addr_wr_min;                  
  140. 461                 end
  141. 462                  else begin
  142. 463                     wr_addr_cnt_2  <= wr_addr_cnt_2;
  143. 464                     app_addr_wr_2  <= app_addr_wr_2;                  
  144. 465                  end
  145. 466  
  146. 467                  if(wr_rst_1)begin                   //当帧复位到来时，对信号进行复位
  147. 468                     wr_addr_cnt_1  <= 24'd0;   
  148. 469                     app_addr_wr_1 <= app_addr_wr_min;                  
  149. 470                 end
  150. 471                  else begin
  151. 472                     wr_addr_cnt_1  <= wr_addr_cnt_1;
  152. 473                     app_addr_wr_1  <= app_addr_wr_1;                  
  153. 474                  end               
  154. 475             end
  155. 476             READ_2:begin                         //读到设定的地址长度   
  156. 477                 if((rd_addr_cnt_2 == (rd_bust_len - 1)) && app_rdy)begin
  157. 478                     state_cnt   <= READ_WAIT;             //则跳到空闲状态
  158. 479                     app_addr_rd_2 <= app_addr_rd_2 + 8;
  159. 480                 end      
  160. 481                 else if(app_rdy)begin                      //若MIG已经准备好,则开始读
  161. 482                     rd_addr_cnt_2 <= rd_addr_cnt_2 + 1'd1; //用户地址计数器每次加一
  162. 483                     app_addr_rd_2 <= app_addr_rd_2 + 8; //一次性读出8个数,DDR4地址加8
  163. 484                 end
  164. 485                 else begin                                 //若MIG没准备好,则保持原值
  165. 486                     rd_addr_cnt_2 <= rd_addr_cnt_2;
  166. 487                     app_addr_rd_2 <= app_addr_rd_2;
  167. 488                 end
  168. 489                 
  169. 490                  if(wr_rst_2)begin                  //当帧复位到来时，对信号进行复位
  170. 491                     wr_addr_cnt_2  <= 24'd0;   
  171. 492                     app_addr_wr_2 <= app_addr_wr_min;                  
  172. 493                 end
  173. 494                  else begin
  174. 495                     wr_addr_cnt_2  <= wr_addr_cnt_2;
  175. 496                     app_addr_wr_2  <= app_addr_wr_2;                  
  176. 497                  end
  177. 498  
  178. 499                  if(wr_rst_1)begin                   //当帧复位到来时，对信号进行复位
  179. 500                     wr_addr_cnt_1  <= 24'd0;   
  180. 501                     app_addr_wr_1 <= app_addr_wr_min;                  
  181. 502                 end
  182. 503                  else begin
  183. 504                     wr_addr_cnt_1  <= wr_addr_cnt_1;
  184. 505                     app_addr_wr_1  <= app_addr_wr_1;                  
  185. 506                  end               
  186. 507             end
  187. 508             READ_WAIT:begin       //计到设定的地址长度   
  188. 509                 if((data_valid_cnt >= rd_bust_len - 1) && app_rd_data_valid)begin
  189. 510                     state_cnt   <= DDR4_DONE;             //则跳到空闲状态
  190. 511                 end      
  191. 512                 else begin                              
  192. 513                     state_cnt   <= READ_WAIT;
  193. 514                 end
  194. 515             end            
  195. 516             default:begin
  196. 517                     state_cnt    <= IDLE;              
  197. 518                     wr_addr_cnt_1  <= 24'd0;      
  198. 519                     rd_addr_cnt_1  <= 24'd0;      
  199. 520                     app_addr_wr_1  <= 28'd0;   
  200. 521                     app_addr_rd_1  <= 28'd0;
  201. 522                     wr_addr_cnt_2  <= 24'd0;      
  202. 523                     rd_addr_cnt_2  <= 24'd0;      
  203. 524                     app_addr_wr_2  <= 28'd0;   
  204. 525                     app_addr_rd_2  <= 28'd0;   
  205. 526             end
  206. 527         endcase
  207. 528     end
  208. 529 end
复制代码
程序中第322至529行所示，这段代码是DDR4读写逻辑实现，状态跳转图如下图所示：
image013.png
图 34.4.7 状态跳转图

本次实验的状态跳转相对于“OV7725摄像头RGB-LCD显示实验”中的状态跳转只是多了一个读状态、一个写状态和读等待状态。两个实验当中的写状态跳转的条件是没有变的，读状态的跳转出现了变化。本次实验读状态不直接跳到DDR的空闲状态，而是跳到读等待状态。本次实验的实验任务是利用双目OV5640摄像头采集图像，将采集到的图像实时显示在LCD屏幕上，两幅图像分别占据LCD屏的左右半边，所以在输出端存在两个rfifo。在下面的时序图中可以发现当读状态操作完后，而此时的数据没有全部读出来。如果此时直接跳转到DDR的空闲状态，下一刻状态就会跳到另一个读状态，那么DDR4读出的数据就不容易区分是哪个rfifo的数据，容易造成数据错乱。为了保证数据可以准确的写入到对应的rfifo中，必须在数据完全读出后才能跳转到DDR的空闲状态，这是添加读等待状态的原因。时序图如下：
image015.png
图 34.4.8 状态时序图

下面是FIFO顶层调度模块的原理图：
image017.png
图 34.4.9 FIFO顶层调度模块的原理图

本次实验增加了一个rfifo和一个wfifo，所以对FIFO调度模块例化了两次。由原理图可知，在FIFO顶层调度模块，对写fifo的输出数据进行了判断，也对读fifo的输出数据进行判断。

FIFO调度模块：负责对输入和输出的数据进行时钟域的切换和位宽的转换。详细说明请看“OV5640摄像头RGB-LCD显示实验”。

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

在代码60行，表示的是像素在LCD屏显示位置的切换，即LCD屏左侧显示FIFO1，右侧显示FIFO2。

在代码63行，表示的是像素数据在写入DDR4前的切换。

在代码66至73行，对LCD顶层模块发出的对读请求信号进行计数。

在代码75至119行是两个FIFO调度模块的例化，我们只给出代码注释，方便大家了解各信号的连接关系，这里不做分析了。

34.5 下载验证
首先将FPC排线一端与RGB-LCD模块上的RGB接口连接，另一端与DFZU2EG/4EV MPSoC开发板上的RGB-LCD接口连接。与RGB-LCD模块连接时，先掀开FPC连接器上的黑色翻盖，将FPC排线蓝色面朝内（靠近FPGA端）插入连接器，最后将黑色翻盖压下以固定FPC排线，如图 34.5.1所示。
image020.png
图 34.5.1 正点原子RGBLCD模块FPC连接器

与DFZU2EG/4EV MPSoC开发板上的RGB TFTLCD接口连接时，先掀起开发板上的棕色的翻盖到垂直开发板方向，将FPC排线蓝色面朝棕色翻盖垂直插入连接器，最后将棕色的翻盖下按至水平方向，如图 34.5.2所示。
image021.png
图 34.5.2 DFZU2EG/4EV MPSoC开发板连接RGB-LCD液晶屏

然后将双目OV5640摄像头模块插在DFZU2EG/4EV MPSoC开发板J19扩展口上，摄像头实物连接如上图所示。最后将下载器一端连电脑，另一端与开发板上的JTAG端口连接，然后连接电源线后拨动开关按键给开发板上电。

接下来我们下载程序，验证双目OV5640 RGB-LCD实时显示功能。下载完成后观察RGB-LCD模块显示的图案如下图所示，说明双目OV5640 RGB-LCD实时显示程序下载验证成功。
image023.jpg
图 34.5.3 RGB RGB-LCD实时显示图像
OV5640, 嵌入式开发, Xilinx, FPGA, 双目摄像头

相关帖子

正点原子逻辑分析仪DL16劲爆上市
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则



关闭

原子哥极力推荐上一条 /2 下一条

正点原子公众号

QQ|手机版|OpenEdv-开源电子网 ( 粤ICP备12000418号-1 )

GMT+8, 2024-11-26 09:49

Powered by OpenEdv-开源电子网

© 2001-2030 OpenEdv-开源电子网

快速回复 返回顶部 返回列表