FPGA 摄像头采集处理显示指南：OV5640 至 HDMI 实时显示 | 极客日志

C++算法

FPGA 摄像头采集处理显示指南：OV5640 至 HDMI 实时显示

FPGA 摄像头系统通过 OV5640 采集图像，经 SCCB 配置、DVP 接口传输，利用双端口 RAM 或 SDRAM 缓存，最终通过 HDMI 输出显示。文章涵盖上电时序、寄存器配置、Verilog 模块设计及 TMDS 编码原理，提供系统集成与调试方案。

FlinkHero发布于 2026/4/5更新于 2026/4/211 浏览

FPGA 摄像头采集处理显示系统概述

一、系统架构与核心模块

1.1 完整系统架构

一个典型的 FPGA 摄像头采集处理显示系统由以下几个主要部分组成：

┌─ 1️⃣ 摄像头采集模块
│   ├─ OV5640 摄像头驱动
│   ├─ SCCB 配置接口
│   └─ DVP 数据采集
├─ 2️⃣ 图像处理模块
│   ├─ 数据格式转换
│   ├─ 图像缩放/裁剪
│   └─ 色彩空间转换
├─ 3️⃣ 存储缓存模块
│   ├─ SDRAM/DDR3
│   ├─ 双端口 RAM
│   └─ 帧缓冲管理
├─ 4️⃣ 显示输出模块
│   ├─ VGA 时序生成
│   ├─ HDMI 驱动
│   └─ TMDS 编码
└─ 5️⃣ 时钟管理模块

模块名称	功能描述	关键参数
OV5640 驱动	摄像头初始化、寄存器配置、数据采集	分辨率、帧率、数据格式
SCCB 控制器	I2C 兼容的摄像头配置接口	时钟频率、地址宽度
DVP 采集	并行数据采集、时序同步	像素时钟、行列同步
图像缓存	帧数据存储、读写管理	缓存大小、带宽
VGA 驱动	显示时序生成、数据输出	分辨率、刷新率
HDMI 驱动	HDMI 信号编码、差分输出	分辨率、色深

摄像头 (OV5640) ↓ [DVP 接口：PCLK, HREF, VSYNC, Y[7:0]] 
FPGA 采集模块 ↓ [16 位 RGB565 或 YUV422] 
图像处理模块 ↓ [处理后的图像数据] 
SDRAM/DDR3 缓存 ↓ [读取请求] 
VGA/HDMI 驱动 ↓ [HDMI 差分信号] 
显示器

分辨率	帧率	像素时钟	缓存大小	适用场景
640×480	60fps	25MHz	600KB	低端监控、测试
800×600	60fps	40MHz	960KB	通用应用
1024×768	60fps	65MHz	1.5MB	工业检测
1280×720	60fps	74.25MHz	1.8MB	高清监控
1920×1080	60fps	148.5MHz	4.1MB	全高清应用

// 关键时钟信号
// 摄像头输入时钟 (XCLK): 24MHz
// 像素时钟 (PCLK): 根据分辨率变化
// HDMI 像素时钟：148.5MHz(1080p@60Hz)
// HDMI 串行时钟：5 倍像素时钟

// 时钟约束示例
create_clock -period 10.000 -name clk_sys [get_ports sys_clk]
create_generated_clock -name clk_hdmi \
  -source [get_pins pll_inst/CLKIN1] \
  -multiply_by 3 \
  [get_pins pll_inst/CLKOUT0]

摄像头时钟域 (PCLK) ←→ 系统时钟域 (sys_clk) 
↓ CDC 同步器 (双触发器) 
↓ HDMI 时钟域 (clk_hdmi)
关键：使用格雷码或双触发器进行同步

写入带宽：PCLK × 16bit (像素时钟 × 数据宽度)
读取带宽：clk_hdmi × 16bit (显示时钟 × 数据宽度)
例如 1080p@60Hz:
- 写入：148.5MHz × 16bit = 2.376Gbps
- 读取：148.5MHz × 16bit = 2.376Gbps
- 需要 DDR3-1600 以上支持

挑战	原因	解决方案
时序收敛困难	多时钟域、高频率	合理的时钟约束、流水线设计
缓存不足	高分辨率、高帧率	使用 DDR3、优化数据格式
图像撕裂	读写不同步	双缓冲、帧同步控制
色彩失真	格式转换错误	正确的色彩空间转换
延迟过高	处理流程复杂	流水线并行处理

特性	参数
最大分辨率	2592×1944(500 万像素)
输出格式	YUV422/420、RGB565、JPEG
帧率	15-60fps(可配置)
工作时钟	6-54MHz(推荐 24MHz)
功耗	150-200mW
接口	DVP(并行)、SCCB(I2C 兼容)
自动功能	自动对焦、自动曝光、自动白平衡

DVDD (1.8V ±5%) ├─ 数字核心电源 ├─ 需要 100nF+10μF 滤波 └─ 对噪声敏感，需要单独的电源层
AVDD (2.8V ±5%) ├─ 模拟电源 ├─ 需要 100nF+10μF 滤波 └─ 必须与 DVDD 同时上电
DOVDD (1.8V ±5%) ├─ 输出驱动电源 ├─ 驱动 Y[9:0]、PCLK、VSYNC、HREF └─ 需要 100nF 滤波

XCLK (外部时钟输入) ├─ 频率范围：6-54MHz ├─ 推荐频率：24MHz ├─ 占空比：45%-55% └─ 必须稳定，抖动< 100ps
PCLK (像素时钟输出) ├─ 频率：根据分辨率和帧率变化 └─ 需要在 FPGA 中采样

VSYNC (帧同步信号) ├─ 低电平表示帧有效 ├─ 用于帧边界检测 └─ 周期 = 1/帧率
HREF (行同步信号) ├─ 高电平表示行有效 ├─ 用于行边界检测 └─ 周期 = 1/(帧率×行数)

RESETB (复位信号，低有效) ├─ 低电平时复位芯片 ├─ 需要保持低电平至少 1ms └─ 通常由 FPGA GPIO 驱动
PWDN (掉电/省电，高有效) ├─ 高电平时进入低功耗模式 ├─ 低电平时正常工作 └─ 通常由 FPGA GPIO 驱动

┌──────────────────────────────────────────────────┐
│ OV5640 内部结构框图 │
├──────────────────────────────────────────────────┤
│ XCLK(24MHz) │
│ ↓ │
│ PLL/时钟生成 (生成各种内部时钟) │
│ ↓ │
│ 感光矩阵 (2592×1944) (CMOS 传感器，光电转换) │
│ ↓ │
│ 模拟前端 (AFE) (放大、滤波、模数转换) │
│ ↓ │
│ ISP(图像信号处理) │
│ ├─ 自动曝光 (AE) │
│ ├─ 自动白平衡 (AWB) │
│ ├─ 自动对焦 (AF) │
│ ├─ 伽玛校正 │
│ ├─ 色彩矩阵 │
│ └─ 降噪处理 │
│ ↓ │
│ 格式转换 (YUV422/420、RGB565、JPEG 等) │
│ ↓ │
│ 输出接口 │
│ ├─ DVP(并行): Y[9:0]、PCLK、HREF、VSYNC│
│ └─ SCCB(I2C): 寄存器配置 │
└──────────────────────────────────────────────────┘

START → SLAVE_ADDR(0x78) → ACK → ADDR_H → ACK → ADDR_L → ACK → DATA → ACK → STOP

START → SLAVE_ADDR(0x78) → ACK → ADDR_H → ACK → ADDR_L → ACK → START → SLAVE_ADDR(0x79) → ACK → DATA → NACK → STOP

特性	SCCB	I2C
寻址方式	16 位地址	7/10 位地址
从机应答	可选	必须
读操作	需要重复 START	支持
兼容性	不完全兼容 I2C	标准协议

时间轴：
0ms ├─ 电源上电 (DVDD、AVDD、DOVDD)
5ms ├─ PWDN 拉低 (退出低功耗模式)
10ms ├─ RESETB 拉低 (复位芯片)
15ms ├─ RESETB 拉高 (释放复位)
35ms └─ 等待 PLL 稳定 (约 20ms)，可以开始配置寄存器

always @(posedge clk) begin
  if (power_on_counter < 32'd5_000_000) begin
    pwdn <= 1'b1; // 保持低功耗
    power_on_counter <= power_on_counter + 1;
  end else begin
    pwdn <= 1'b0; // 退出低功耗
  end
end

always @(posedge clk) begin
  if (reset_counter < 32'd1_000_000) begin
    resetb <= 1'b0; // 保持复位
    reset_counter <= reset_counter + 1;
  end else if (reset_counter < 32'd21_000_000) begin
    resetb <= 1'b1; // 释放复位
    reset_counter <= reset_counter + 1;
  end else begin
    init_done <= 1'b1; // 初始化完成
  end
end

寄存器地址	寄存器名称	功能	典型值
0x3008	SYSTEM_CTRL0	系统控制	0x82
0x3009	SYSTEM_CTRL1	系统控制	0x02
0x3103	CLOCK_CTRL	时钟控制	0x11
0x3034	PLL_CTRL0	PLL 控制	0x18
0x3035	PLL_CTRL1	PLL 控制	0x11
0x3036	PLL_CTRL2	PLL 控制	0x54
0x3037	PLL_CTRL3	PLL 控制	0x13
0x3a00	AE_CTRL	自动曝光	0x78

0x3008 = 0x82 (系统复位)
0x3808 = 0x02 (输出宽度高字节)
0x3809 = 0x80 (输出宽度低字节) → 640
0x380a = 0x01 (输出高度高字节)
0x380b = 0xe0 (输出高度低字节) → 480
0x4300 = 0x30 (YUV422 输出)

module sccb_ctrl (
  input clk,
  input rst_n,
  input [15:0] reg_addr,
  input [7:0] reg_data_w,
  output [7:0] reg_data_r,
  input reg_wr,
  input reg_rd,
  output reg_done,
  inout sio_c,
  inout sio_d
);
  localparam IDLE = 4'd0;
  localparam START = 4'd1;
  localparam ADDR_H = 4'd2;
  localparam ADDR_L = 4'd3;
  localparam DATA = 4'd4;
  localparam ACK = 4'd5;
  localparam STOP = 4'd6;

  reg [3:0] state, next_state;
  reg [7:0] bit_counter;

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      state <= IDLE;
    end else begin
      state <= next_state;
    end
  end

  always @(*) begin
    case (state)
      IDLE: begin
        if (reg_wr || reg_rd) next_state = START;
        else next_state = IDLE;
      end
      START: next_state = ADDR_H;
      ADDR_H: next_state = ADDR_L;
      ADDR_L: next_state = (reg_wr) ? DATA : ACK;
      DATA: next_state = ACK;
      ACK: next_state = STOP;
      STOP: next_state = IDLE;
      default: next_state = IDLE;
    endcase
  end

  assign sio_c = (state == IDLE) ? 1'bz : 1'b0;
  assign sio_d = (state == IDLE) ? 1'bz : 1'b0;
endmodule

module dvp_capture (
  input clk,
  input rst_n,
  input pclk,
  input vsync,
  input href,
  input [9:0] data_in,
  output reg [7:0] data_out,
  output reg data_valid,
  output reg line_valid,
  output reg frame_valid,
  output reg [11:0] pixel_x,
  output reg [11:0] pixel_y
);
  localparam IDLE = 2'd0;
  localparam FRAME_ACTIVE = 2'd1;
  localparam LINE_ACTIVE = 2'd2;

  reg [1:0] state;
  reg vsync_r1, vsync_r2;
  reg href_r1, href_r2;

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      vsync_r1 <= 1'b1;
      vsync_r2 <= 1'b1;
      href_r1 <= 1'b0;
      href_r2 <= 1'b0;
    end else begin
      vsync_r1 <= vsync;
      vsync_r2 <= vsync_r1;
      href_r1 <= href;
      href_r2 <= href_r1;
    end
  end

  always @(posedge pclk or negedge rst_n) begin
    if (!rst_n) begin
      state <= IDLE;
      frame_valid <= 1'b0;
      line_valid <= 1'b0;
      pixel_x <= 12'd0;
      pixel_y <= 12'd0;
    end else begin
      case (state)
        IDLE: begin
          if (!vsync) begin
            state <= FRAME_ACTIVE;
            frame_valid <= 1'b1;
            pixel_y <= 12'd0;
          end
        end
        FRAME_ACTIVE: begin
          if (vsync) begin
            state <= IDLE;
            frame_valid <= 1'b0;
            pixel_y <= 12'd0;
          end else if (href) begin
            line_valid <= 1'b1;
            pixel_x <= pixel_x + 1;
          end else begin
            line_valid <= 1'b0;
            if (pixel_x > 0) begin
              pixel_y <= pixel_y + 1;
              pixel_x <= 12'd0;
            end
          end
        end
        default: state <= IDLE;
      endcase
    end
  end

  always @(posedge pclk or negedge rst_n) begin
    if (!rst_n) begin
      data_out <= 8'd0;
      data_valid <= 1'b0;
    end else begin
      if (href && frame_valid) begin
        data_out <= data_in[9:2];
        data_valid <= 1'b1;
      end else begin
        data_valid <= 1'b0;
      end
    end
  end
endmodule

缓存大小 = 分辨率 × 像素深度 × 帧数
例如 1280×720@60fps:
- 单帧大小 = 1280 × 720 × 2 字节 (RGB565) = 1.8MB
- 双缓冲 = 1.8MB × 2 = 3.6MB

module dual_port_ram #(
  parameter ADDR_WIDTH = 12,
  parameter DATA_WIDTH = 16,
  parameter DEPTH = 4096
) (
  input clk_a,
  input [ADDR_WIDTH-1:0] addr_a,
  input [DATA_WIDTH-1:0] data_in,
  input we_a,
  input clk_b,
  input [ADDR_WIDTH-1:0] addr_b,
  output reg [DATA_WIDTH-1:0] data_out,
  input re_b
);
  reg [DATA_WIDTH-1:0] mem [0:DEPTH-1];

  always @(posedge clk_a) begin
    if (we_a) begin
      mem[addr_a] <= data_in;
    end
  end

  always @(posedge clk_b) begin
    if (re_b) begin
      data_out <= mem[addr_b];
    end
  end
endmodule

module sdram_ctrl (
  input clk,
  input rst_n,
  input [23:0] addr,
  input [15:0] data_in,
  output [15:0] data_out,
  input we,
  input re,
  output busy,
  output [12:0] sdram_addr,
  output [1:0] sdram_ba,
  inout [15:0] sdram_dq,
  output sdram_cs_n,
  output sdram_ras_n,
  output sdram_cas_n,
  output sdram_we_n,
  output sdram_clk
);
  localparam IDLE = 3'd0;
  localparam ACTIVE = 3'd1;
  localparam READ = 3'd2;
  localparam WRITE = 3'd3;
  localparam PRECHARGE = 3'd4;

  reg [2:0] state, next_state;
  reg [3:0] cmd_counter;

  wire [1:0] bank = addr[23:22];
  wire [12:0] row = addr[21:9];
  wire [8:0] col = addr[8:0];

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      state <= IDLE;
      cmd_counter <= 0;
    end else begin
      state <= next_state;
      if (state != next_state) cmd_counter <= 0;
      else cmd_counter <= cmd_counter + 1;
    end
  end

  always @(*) begin
    case (state)
      IDLE: begin
        if (we || re) next_state = ACTIVE;
        else next_state = IDLE;
      end
      ACTIVE: begin
        if (cmd_counter >= 2) next_state = (we) ? WRITE : READ;
        else next_state = ACTIVE;
      end
      READ, WRITE: begin
        if (cmd_counter >= 3) next_state = PRECHARGE;
        else next_state = state;
      end
      PRECHARGE: begin
        if (cmd_counter >= 2) next_state = IDLE;
        else next_state = PRECHARGE;
      end
      default: next_state = IDLE;
    endcase
  end

  assign sdram_cs_n = 1'b0;
  assign sdram_clk = clk;

  always @(*) begin
    case (state)
      ACTIVE: begin
        sdram_addr = row;
        sdram_ba = bank;
        sdram_ras_n = 1'b0;
        sdram_cas_n = 1'b1;
        sdram_we_n = 1'b1;
      end
      READ: begin
        sdram_addr = {4'b0, col};
        sdram_ba = bank;
        sdram_ras_n = 1'b1;
        sdram_cas_n = 1'b0;
        sdram_we_n = 1'b1;
      end
      WRITE: begin
        sdram_addr = {4'b0, col};
        sdram_ba = bank;
        sdram_ras_n = 1'b1;
        sdram_cas_n = 1'b0;
        sdram_we_n = 1'b0;
      end
      PRECHARGE: begin
        sdram_addr = 13'b0;
        sdram_ba = 2'b0;
        sdram_ras_n = 1'b0;
        sdram_cas_n = 1'b1;
        sdram_we_n = 1'b0;
      end
      default: begin
        sdram_addr = 13'b0;
        sdram_ba = 2'b0;
        sdram_ras_n = 1'b1;
        sdram_cas_n = 1'b1;
        sdram_we_n = 1'b1;
      end
    endcase
  end

  assign busy = (state != IDLE);
endmodule

module yuv422_to_rgb565 (
  input clk,
  input [7:0] y,
  input [7:0] u,
  input [7:0] v,
  output [15:0] rgb565
);
  wire [15:0] r, g, b;

  assign r = (y + ((v - 8'd128) * 9'd179) >> 8);
  assign g = (y - (((u - 8'd128) * 9'd44) >> 8) - (((v - 8'd128) * 9'd91) >> 8));
  assign b = (y + ((u - 8'd128) * 9'd227) >> 8);

  wire [7:0] r_clamp = (r > 255) ? 8'd255 : (r < 0) ? 8'd0 : r[7:0];
  wire [7:0] g_clamp = (g > 255) ? 8'd255 : (g < 0) ? 8'd0 : g[7:0];
  wire [7:0] b_clamp = (b > 255) ? 8'd255 : (b < 0) ? 8'd0 : b[7:0];

  assign rgb565 = {r_clamp[7:3], g_clamp[7:2], b_clamp[7:3]};
endmodule

module vga_timing_gen #(
  parameter H_TOTAL = 1650,
  parameter H_ACTIVE = 1280,
  parameter H_FP = 110,
  parameter H_SYNC = 40,
  parameter V_TOTAL = 750,
  parameter V_ACTIVE = 720,
  parameter V_FP = 5,
  parameter V_SYNC = 5
) (
  input clk,
  input rst_n,
  output reg hsync,
  output reg vsync,
  output reg [11:0] pixel_x,
  output reg [11:0] pixel_y,
  output reg data_valid
);
  reg [11:0] h_counter, v_counter;

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      h_counter <= 0;
    end else if (h_counter == H_TOTAL - 1) begin
      h_counter <= 0;
    end else begin
      h_counter <= h_counter + 1;
    end
  end

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      v_counter <= 0;
    end else if (h_counter == H_TOTAL - 1) begin
      if (v_counter == V_TOTAL - 1) begin
        v_counter <= 0;
      end else begin
        v_counter <= v_counter + 1;
      end
    end
  end

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      hsync <= 1'b1;
    end else begin
      if (h_counter >= (H_ACTIVE + H_FP) && h_counter < (H_ACTIVE + H_FP + H_SYNC)) begin
        hsync <= 1'b0;
      end else begin
        hsync <= 1'b1;
      end
    end
  end

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      vsync <= 1'b1;
    end else begin
      if (v_counter >= (V_ACTIVE + V_FP) && v_counter < (V_ACTIVE + V_FP + V_SYNC)) begin
        vsync <= 1'b0;
      end else begin
        vsync <= 1'b1;
      end
    end
  end

  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      pixel_x <= 0;
      pixel_y <= 0;
      data_valid <= 1'b0;
    end else begin
      pixel_x <= h_counter;
      pixel_y <= v_counter;
      if (h_counter < H_ACTIVE && v_counter < V_ACTIVE) begin
        data_valid <= 1'b1;
      end else begin
        data_valid <= 1'b0;
      end
    end
  end
endmodule

module tmds_encoder (
  input clk,
  input [7:0] data_in,
  input ctrl_in,
  output reg [9:0] tmds_out
);
  wire [8:0] xor_result;
  wire [3:0] ones_count;

  assign xor_result[0] = data_in[0];
  assign xor_result[1] = xor_result[0] ^ data_in[1];
  assign xor_result[2] = xor_result[1] ^ data_in[2];
  assign xor_result[3] = xor_result[2] ^ data_in[3];
  assign xor_result[4] = xor_result[3] ^ data_in[4];
  assign xor_result[5] = xor_result[4] ^ data_in[5];
  assign xor_result[6] = xor_result[5] ^ data_in[6];
  assign xor_result[7] = xor_result[6] ^ data_in[7];
  assign xor_result[8] = 1'b0;

  assign ones_count = xor_result[0] + xor_result[1] + xor_result[2] + xor_result[3] + xor_result[4] + xor_result[5] + xor_result[6] + xor_result[7];

  always @(posedge clk) begin
    if (ctrl_in) begin
      tmds_out <= 10'b1010101100;
    end else begin
      if (ones_count > 4 || (ones_count == 4 && xor_result[0] == 0)) begin
        tmds_out <= {~xor_result[8], xor_result[7:0], 1'b0};
      end else begin
        tmds_out <= {xor_result[8], xor_result[7:0], 1'b1};
      end
    end
  end
endmodule

module camera_hdmi_system (
  input sys_clk,
  input rst_n,
  output camera_xclk,
  output camera_resetb,
  output camera_pwdn,
  inout camera_sio_c,
  inout camera_sio_d,
  input camera_pclk,
  input camera_vsync,
  input camera_href,
  input [9:0] camera_data,
  output hdmi_clk_p,
  output hdmi_clk_n,
  output [2:0] hdmi_d_p,
  output [2:0] hdmi_d_n,
  output [7:0] led
);
  wire clk_100m, clk_74m25, clk_148m5;
  pll_clk_gen pll_inst (.clk_in(sys_clk), .clk_100m(clk_100m), .clk_74m25(clk_74m25), .clk_148m5(clk_148m5));

  wire camera_init_done;
  camera_init camera_init_inst (.clk(clk_100m), .rst_n(rst_n), .sio_c(camera_sio_c), .sio_d(camera_sio_d), .resetb(camera_resetb), .pwdn(camera_pwdn), .init_done(camera_init_done));

  wire [7:0] pixel_data;
  wire pixel_valid;
  wire frame_valid;
  dvp_capture capture_inst (.pclk(camera_pclk), .vsync(camera_vsync), .href(camera_href), .data_in(camera_data), .data_out(pixel_data), .data_valid(pixel_valid), .frame_valid(frame_valid));

  wire [23:0] sdram_addr;
  wire [15:0] sdram_data_w, sdram_data_r;
  wire sdram_we, sdram_re;
  sdram_ctrl sdram_inst (.clk(clk_100m), .rst_n(rst_n), .addr(sdram_addr), .data_in(sdram_data_w), .data_out(sdram_data_r), .we(sdram_we), .re(sdram_re));

  wire [11:0] pixel_x, pixel_y;
  wire hsync, vsync;
  wire vga_data_valid;
  vga_timing_gen vga_inst (.clk(clk_74m25), .rst_n(rst_n), .hsync(hsync), .vsync(vsync), .pixel_x(pixel_x), .pixel_y(pixel_y), .data_valid(vga_data_valid));

  hdmi_tx hdmi_inst (.clk_pixel(clk_74m25), .clk_tmds(clk_148m5), .rst_n(rst_n), .hsync(hsync), .vsync(vsync), .rgb_data(sdram_data_r), .data_valid(vga_data_valid), .hdmi_clk_p(hdmi_clk_p), .hdmi_clk_n(hdmi_clk_n), .hdmi_d_p(hdmi_d_p), .hdmi_d_n(hdmi_d_n));

  assign led[0] = camera_init_done;
  assign led[1] = frame_valid;
  assign led[2] = vga_data_valid;
  assign led[7:3] = 5'b0;
endmodule

FPGA 摄像头采集处理显示指南：OV5640 至 HDMI 实时显示

FPGA 摄像头采集处理显示系统概述

一、系统架构与核心模块

1.1 完整系统架构

1.2 核心模块功能说明

1.3 数据流向

二、应用场景与实现方案

2.1 典型应用场景

2.2 不同分辨率的实现方案

三、设计流程与关键技术点

3.1 设计流程

3.2 关键技术点

3.3 常见设计挑战

四、OV5640 摄像头基础知识

4.1 OV5640 摄像头概述

4.2 OV5640 引脚定义与功能

4.2.1 关键引脚详解

4.3 OV5640 工作原理

4.3.1 内部结构框图

4.3.2 工作流程

4.4 SCCB 通信协议

4.4.1 SCCB 协议概述

4.4.2 SCCB 时序

4.4.3 SCCB 与 I2C 的区别

五、摄像头初始化与配置

5.1 OV5640 上电时序

5.1.1 上电时序流程

5.1.2 上电时序详细说明

5.2 OV5640 关键寄存器配置

5.2.1 常用寄存器说明

5.2.2 分辨率配置寄存器

5.2.3 常见分辨率配置示例

5.3 SCCB 控制器设计

5.3.1 SCCB 控制器 Verilog 实现框架

六、图像采集模块设计

6.1 DVP 接口详解

6.1.1 DVP 接口概述

6.1.2 DVP 信号定义

6.1.3 DVP 时序关系

6.2 图像采集模块设计

6.2.1 采集模块 Verilog 实现

6.3 采集模块关键设计点

七、图像处理与缓存

7.1 图像缓存设计

7.1.1 缓存需求分析

7.1.2 缓存架构选择

7.2 双端口 RAM 设计

7.2.1 双端口 RAM Verilog 实现

7.3 SDRAM 控制器设计

7.3.1 SDRAM 控制器简化实现

7.4 图像处理基础

7.4.1 YUV422 到 RGB565 转换

八、HDMI 显示输出

8.1 VGA 时序基础

8.1.1 常见分辨率的 VGA 时序

8.2 HDMI 驱动设计

8.2.1 HDMI 接口概述

8.2.2 VGA 时序生成器 Verilog 实现

8.3 TMDS 编码

8.3.1 简化的 TMDS 编码实现

九、完整实战案例与最佳实践

9.1 系统集成

9.1.1 顶层模块设计

9.2 调试技巧

9.2.1 常见问题排查

9.2.2 调试工具

9.3 性能优化

9.3.1 带宽优化

9.3.2 延迟优化

9.3.3 功耗优化

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具