HDMI-IP项目-主讲HDMI数据岛分组构造（BCH块编码）-连载七

UT发布 · 发表于 2025-5-12 11:19:35

1 数据岛分组构造概述

在上一讲中，我们阐述了数据岛的时序生成原理，本节课将深入探讨其时序阶段的数据传输机制。在HDMI协议框架下，数据岛通过“数据岛分组构造”实现信息封装与传输，其核心是将音频、视频及辅助数据按特定时序规则划分为独立的数据包（Packet）。每个数据包由前导码、包头、有效载荷及校验字段构成，并通过严格的同步信号与时钟相位对齐，确保数据在传输过程中保持时序一致性。

该设计不仅优化了带宽利用率，同时通过冗余校验机制保障了高可靠性，为高清多媒体传输提供了精准的底层支持。

2 数据岛分组构造原理
2.1BCH块编码

数据岛中的所有数据都包含在32个时钟包中。包由包头、包主体(由四个子包组成)和相关的纠错位组成。

每个子分组包括56比特的数据，并由附加的8比特BCH ECC奇偶校验位保护。

子分组0加上其相应的奇偶校验位构成了BCH块0。该模块映射到通道1和通道2的位0。这样，BCH块0的64位在32个像素的过程中被传送。同样，BCH块1(子分组1加奇偶校验)被映射到信道1和2的比特1上。

主要的传输过程如下图所示

我们本讲的重点就是分析这张图，这张图来自于HDMI协议手册《High-Definition Multimedia Interface》，这张图的上端很明显是对应的HDMI传输数据的三个通道，分别是Channel 0、Channel 1、Channel 2，在每一个Channel中，数据传输又分成4位，由此可知，数据岛数据在进入TMDS编码之前是4位传输的。

从上端我们可以确定，HDMI一共有三个通道，每个通道每次传输1个4位的数据岛数据，那下面就要看一下，这个4位数据岛数据每一位的组成。

就从上图可以看出，Channel 0的D0位和D1位数据分别来自于HSYNC和VSYNC，这个很好理解我们直接把HSYNC和VSYNC信号接入Channel 0的D0位和D1位即可。

从Channel 0的D2位开始，数据来自于BCH block 4，同时Channel 1的D0、D1、D2、D3以及Channel 2的D0、D1、D2、D3数据分别来自于BCH block 0~BCH block3。那我们就跳转到传输图的最下端，看一下BCH块数据的组成。

从上图可以看出，BCH block 0~BCH block 4块的数据来自于HDMI数据岛数据包，数据包分为报头字节（Packet Header）和子分组字节（Packet Body）。

报头字节表示为HB0、HB1和HB2，子分组字节表示为SB0~SB6。由此我们可以得知，上图蓝色框内的数据来自于HDMI数据岛数据包。BCH block 4块数据来自于报头字节（Packet Header），包头字节一共24位。BCH block 0~BCH block 3的数据来自于HDMI数据岛数据包的子分组字节（Packet Body），子分组字节一共56位。

蓝色框外部还有最后一个数据（parity bits），这个8位的数据就是BCH ECC奇偶校验位。

下面我们看数据岛分组构造图上端和下端之间的数据转换传输。以BCH block0举例，BCH block0的Packet Body+ECC奇偶校验位一共是64bit，按照奇偶位分别输出给Channel 1的D0和Channel 2的D0。以此类推就把完整的64bit数据拆分成了两个32位的数据，其他BCH block1~BCH block3数据也是这么处理。

BCH block 4包含24位的Packet Header数据+8位的ECC奇偶校验位，一共包含32位的数据，正好可以直接传输给Channel 0的D2。

2.2 ECC奇偶校验

关于ECC奇偶校验的描述，HDMI协议手册《High-Definition Multimedia Interface》中如下描述：

为了提高数据的可靠性和改进坏数据的检测，将纠错码(ECC)奇偶校验添加到每个包中。BCH(64，56)和BCH(32，24)由多项式G(x)生成。

G(x)=1+x6+x7+x8

这边编者对于ECC校验码的实现研究的也不多，直接使用的安路FPGA代码中的官方提供的ECC校验码计算方式，进过上板验证可以正确校验出结果。感兴趣的用户可以自行去研究实现原理，本章节就不再赘述。

3 hdmi_island_data_assemble模块代码

该模块为HDMI 720p@60Hz数据流封装核心，基于三级流水线架构实现视频时序与像素数据的精准同步。通过解析垂直同步（VSYNC）、水平同步（HSYNC）及数据使能（DE）信号，在消隐区间将BCH编码的辅助数据包（含音频、控制信息等）拆分为奇偶位流，经移位寄存器串行化处理。输出阶段依据HDMI 1.4通道规范，将视频前导码、保护带信号与数据流按通道规则组合：通道0传输包头及控制信号，通道1/2承载数据主体，最终在74.25MHz像素时钟驱动下完成全链路同步，严格满足协议时序与数据结构要求。

`timescale 1ns / 1ps
// HDMI 720P@60Hz 数据组装模块
// 功能：处理视频数据和辅助数据岛，生成符合HDMI 1.4规范的传输数据流
//====================================================================//
// HDMI 720P@60Hz 数据岛组装核心模块
// 功能：根据HDMI 1.4规范组帧，处理视频数据+数据岛周期信号
// 特性：
// 1. 74.25MHz像素时钟
// 2. 配套720p60时序参数(1280x720@60Hz)
// 3. 三级流水线保证时序对齐
// 4. BCH块数据处理符合HDMI 1.4规范
//====================================================================//
module hdmi_island_data_assemble(
//======================== 时钟域信号 ========================//
input wire I_pixel_clk, // 74.25MHz像素时钟
input wire I_reset_n, // 异步复位，高有效
//=================== 视频时序及数据输入 ====================//
input wire I_vsync, // 垂直同步信号
input wire I_hsync, // 水平同步信号
input wire I_de, // 视频有效数据周期标志
input wire I_video_preamble, // 视频前导周期标志
input wire I_video_guard_band, // 视频保护带周期标志
input wire [7:0] I_video_data_ch0, // 视频通道0（蓝/亮度）
input wire [7:0] I_video_data_ch1, // 视频通道1（绿/色差）
input wire [7:0] I_video_data_ch2, // 视频通道2（红/色差）
//=================== 数据岛控制信号 ========================//
input wire I_island_preamble, // 数据岛前导周期
input wire I_island_guard_band,// 数据岛保护带周期
input wire I_island_period, // 数据岛有效周期
//=================== BCH编码块输入 ========================//
input wire [63:0] I_BCH_block_0, // 数据包块0（含包头和BCH校验）
input wire [63:0] I_BCH_block_1, // 数据包块1
input wire [63:0] I_BCH_block_2, // 数据包块2
input wire [63:0] I_BCH_block_3, // 数据包块3
input wire [31:0] I_BCH_block_4, // 数据包块4（最后32位）
//===================== 输出控制信号 =======================//
output wire O_frame_start, // 帧起始脉冲标志
output wire O_island_packet_req, // 数据岛包请求
//==================== 输出视频时序信号 ====================//
output reg O_vsync, // 垂直同步（3拍延迟）
output reg O_hsync, // 水平同步（3拍延迟）
output reg O_de, // 视频有效周期
output reg O_video_preamble, // 视频前导周期
output reg O_video_guard_band, // 视频保护带周期
//==================== 输出视频数据通道 ====================//
output reg [7:0] O_video_data_ch0, // 通道0视频数据
output reg [7:0] O_video_data_ch1, // 通道1视频数据
output reg [7:0] O_video_data_ch2, // 通道2视频数据
//===================== 输出数据岛信号 =====================//
output reg O_island_preamble, // 数据岛前导周期
output reg O_island_guard_band,// 数据岛保护带周期
output reg O_island_period, // 数据岛有效周期
//================= 数据岛通道输出（4bit/通道） ==============//
output reg[3:0] O_island_data_ch0, // 通道0：控制信号+包头
output reg[3:0] O_island_data_ch1, // 通道1：数据包低位
output reg[3:0] O_island_data_ch2 // 通道2：数据包高位
);
//================================================================//
// 参数定义及信号声明 //
//================================================================//
localparam [4:0] PACKET_CNT_MAX = 5'd31; // 数据岛包计数器最大值（32拍周期）
wire[31:0] w_CH1_D0_data;
wire[31:0] w_CH1_D1_data;
wire[31:0] w_CH1_D2_data;
wire[31:0] w_CH1_D3_data;
wire[31:0] w_CH2_D0_data;
wire[31:0] w_CH2_D1_data;
wire[31:0] w_CH2_D2_data;
wire[31:0] w_CH2_D3_data;
// 三级延迟寄存器组（对齐视频时序信号）
reg vsync_delay_chain_d0; // vsync延迟链
reg vsync_delay_chain_d1; // vsync延迟链
reg vsync_delay_chain_d2; // vsync延迟链
reg hsync_delay_chain_d0; // hsync延迟链
reg hsync_delay_chain_d1; // hsync延迟链
reg hsync_delay_chain_d2; // hsync延迟链
reg video_preamble_delay_d0; // 视频前导周期延迟
reg video_preamble_delay_d1; // 视频前导周期延迟
reg video_preamble_delay_d2; // 视频前导周期延迟
reg video_guard_delay_d0; // 视频保护带延迟
reg video_guard_delay_d1; // 视频保护带延迟
reg video_guard_delay_d2; // 视频保护带延迟
reg video_de_delay_d0; // 视频有效数据延迟
reg video_de_delay_d1; // 视频有效数据延迟
reg video_de_delay_d2; // 视频有效数据延迟
// 视频数据三级延迟
reg [7:0] video_data_ch0_delay_d0; // 通道0数据延迟
reg [7:0] video_data_ch0_delay_d1; // 通道0数据延迟
reg [7:0] video_data_ch0_delay_d2; // 通道0数据延迟
reg [7:0] video_data_ch1_delay_d0; // 通道1数据延迟
reg [7:0] video_data_ch1_delay_d1; // 通道1数据延迟
reg [7:0] video_data_ch1_delay_d2; // 通道1数据延迟
reg [7:0] video_data_ch2_delay_d0; // 通道2数据延迟
reg [7:0] video_data_ch2_delay_d1; // 通道2数据延迟
reg [7:0] video_data_ch2_delay_d2; // 通道2数据延迟
// 数据岛信号延迟链
reg island_preamble_delay_d0; // 数据岛前导延迟
reg island_preamble_delay_d1; // 数据岛前导延迟
reg island_preamble_delay_d2; // 数据岛前导延迟
reg island_guard_delay_d0; // 数据岛保护带延迟
reg island_guard_delay_d1; // 数据岛保护带延迟
reg island_guard_delay_d2; // 数据岛保护带延迟
reg island_period_delay_d0; // 数据岛有效周期延迟
reg island_period_delay_d1; // 数据岛有效周期延迟
reg island_period_delay_d2; // 数据岛有效周期延迟
reg [4:0] island_packet_cnt; // 数据岛包计数器（0-31）
reg packet_req_delay_d0; // 包请求信号延迟（同步用）
reg packet_req_delay_d1; // 包请求信号延迟（同步用）
// BCH块移位寄存器
// 复合通道移位寄存器组：
// [0] -> BCH块4(32位)
// [1-4] -> BCH块0-3低位（通道1）
// [5-8] -> BCH块0-3高位（通道2）
reg [31:0] r_shift_ch0_d2;
reg [31:0] r_shift_ch1_d0;
reg [31:0] r_shift_ch1_d1;
reg [31:0] r_shift_ch1_d2;
reg [31:0] r_shift_ch1_d3;
reg [31:0] r_shift_ch2_d0;
reg [31:0] r_shift_ch2_d1;
reg [31:0] r_shift_ch2_d2;
reg [31:0] r_shift_ch2_d3;
//================================================================//
// 三级流水线延迟处理 //
//================================================================//
// 作用：统一对齐所有控制信号和数据通道
always @(posedge I_pixel_clk or negedge I_reset_n) begin
if(~I_reset_n) begin
// 初始化所有延迟寄存器
vsync_delay_chain_d0 <= 1'b0;
vsync_delay_chain_d1 <= 1'b0;
vsync_delay_chain_d2 <= 1'b0;
hsync_delay_chain_d0 <= 1'b0;
hsync_delay_chain_d1 <= 1'b0;
hsync_delay_chain_d2 <= 1'b0;
video_preamble_delay_d0 <= 1'b0;
video_preamble_delay_d1 <= 1'b0;
video_preamble_delay_d2 <= 1'b0;
video_guard_delay_d0 <= 1'b0;
video_guard_delay_d1 <= 1'b0;
video_guard_delay_d2 <= 1'b0;
video_de_delay_d0 <= 1'b0;
video_de_delay_d1 <= 1'b0;
video_de_delay_d2 <= 1'b0;
island_preamble_delay_d0 <= 1'b0;
island_preamble_delay_d1 <= 1'b0;
island_preamble_delay_d2 <= 1'b0;
island_guard_delay_d0 <= 1'b0;
island_guard_delay_d1 <= 1'b0;
island_guard_delay_d2 <= 1'b0;
island_period_delay_d0 <= 1'b0;
island_period_delay_d1 <= 1'b0;
island_period_delay_d2 <= 1'b0;
// 初始化视频数据延迟通道
video_data_ch0_delay_d0 <= 8'h0;
video_data_ch0_delay_d1 <= 8'h0;
video_data_ch0_delay_d2 <= 8'h0;
video_data_ch1_delay_d0 <= 8'h0;
video_data_ch1_delay_d1 <= 8'h0;
video_data_ch1_delay_d2 <= 8'h0;
video_data_ch2_delay_d0 <= 8'h0;
video_data_ch2_delay_d1 <= 8'h0;
video_data_ch2_delay_d2 <= 8'h0;
end
else begin
// 同步信号链式移位
vsync_delay_chain_d0 <= I_vsync;
vsync_delay_chain_d1 <= vsync_delay_chain_d0;
vsync_delay_chain_d2 <= vsync_delay_chain_d1;
hsync_delay_chain_d0 <= I_hsync;
hsync_delay_chain_d1 <= hsync_delay_chain_d0;
hsync_delay_chain_d2 <= hsync_delay_chain_d1;
video_preamble_delay_d0 <= I_video_preamble;
video_preamble_delay_d1 <= video_preamble_delay_d0;
video_preamble_delay_d2 <= video_preamble_delay_d1;
// 视频控制信号移位
video_guard_delay_d0 <= I_video_guard_band;
video_guard_delay_d1 <= video_guard_delay_d0;
video_guard_delay_d2 <= video_guard_delay_d1;
video_de_delay_d0 <= I_de;
video_de_delay_d1 <= video_de_delay_d0;
video_de_delay_d2 <= video_de_delay_d1;
// 数据岛信号移位
island_preamble_delay_d0 <= I_island_preamble;
island_preamble_delay_d1 <= island_preamble_delay_d0;
island_preamble_delay_d2 <= island_preamble_delay_d1;
island_guard_delay_d0 <= I_island_guard_band;
island_guard_delay_d1 <= island_guard_delay_d0;
island_guard_delay_d2 <= island_guard_delay_d1;
island_period_delay_d0 <= I_island_period;
island_period_delay_d1 <= island_period_delay_d0;
island_period_delay_d2 <= island_period_delay_d1;
// 视频数据通道延迟（三级缓冲）
video_data_ch0_delay_d0 <= I_video_data_ch0;
video_data_ch0_delay_d1 <= video_data_ch0_delay_d0;
video_data_ch0_delay_d2 <= video_data_ch0_delay_d1;
video_data_ch1_delay_d0 <= I_video_data_ch1;
video_data_ch1_delay_d1 <= video_data_ch1_delay_d0;
video_data_ch1_delay_d2 <= video_data_ch1_delay_d1;
video_data_ch2_delay_d0 <= I_video_data_ch2;
video_data_ch2_delay_d1 <= video_data_ch2_delay_d0;
video_data_ch2_delay_d2 <= video_data_ch2_delay_d1;
end
end
//================================================================//
// 帧起始检测逻辑 //
// 说明：通过检测vsync上升沿标识帧开始（第3拍对比第2拍）
//================================================================//
assign O_frame_start = ~vsync_delay_chain_d1 & vsync_delay_chain_d2;
//================================================================//
// 数据岛包周期计数器逻辑 //
// 说明：当I_island_period有效时，0-31循环计数，产生包请求信号
//================================================================//
always @(posedge I_pixel_clk or negedge I_reset_n) begin
if(~I_reset_n) begin
island_packet_cnt <= 5'd0;
end else begin
// 包计数器逻辑
if (I_island_period) begin
if (island_packet_cnt == PACKET_CNT_MAX)
island_packet_cnt<= 'd0;
else
island_packet_cnt <= island_packet_cnt + 1'b1;
end
else
island_packet_cnt <= 5'd0;
end
end
// 包请求信号生成（周期起始时拉高）
assign O_island_packet_req = I_island_period && island_packet_cnt == 5'd0 ? 1'b1 : 1'b0;
always @(posedge I_pixel_clk or negedge I_reset_n)begin
if(~I_reset_n) begin
packet_req_delay_d0 <= 1'b0;
packet_req_delay_d1 <= 1'b0;
end
// 包请求信号延迟（同步）
packet_req_delay_d0 <= O_island_packet_req;
packet_req_delay_d1 <= packet_req_delay_d0;
end
//================================================================//
// BCH数据块预处理（并行转串行） //
// 说明：将输入的64bit BCH块按奇偶位分开处理 //
//================================================================//
assign w_CH1_D0_data = {
I_BCH_block_0[62],I_BCH_block_0[60],I_BCH_block_0[58],I_BCH_block_0[56] ,
I_BCH_block_0[54],I_BCH_block_0[52],I_BCH_block_0[50],I_BCH_block_0[48] ,
I_BCH_block_0[46],I_BCH_block_0[44],I_BCH_block_0[42],I_BCH_block_0[40] ,
I_BCH_block_0[38],I_BCH_block_0[36],I_BCH_block_0[34],I_BCH_block_0[32] ,
I_BCH_block_0[30],I_BCH_block_0[28],I_BCH_block_0[26],I_BCH_block_0[24] ,
I_BCH_block_0[22],I_BCH_block_0[20],I_BCH_block_0[18],I_BCH_block_0[16] ,
I_BCH_block_0[14],I_BCH_block_0[12],I_BCH_block_0[10],I_BCH_block_0[8] ,
I_BCH_block_0[6] ,I_BCH_block_0[4] ,I_BCH_block_0[2] ,I_BCH_block_0[0] };
assign w_CH1_D1_data = {
I_BCH_block_1[62],I_BCH_block_1[60],I_BCH_block_1[58],I_BCH_block_1[56] ,
I_BCH_block_1[54],I_BCH_block_1[52],I_BCH_block_1[50],I_BCH_block_1[48] ,
I_BCH_block_1[46],I_BCH_block_1[44],I_BCH_block_1[42],I_BCH_block_1[40] ,
I_BCH_block_1[38],I_BCH_block_1[36],I_BCH_block_1[34],I_BCH_block_1[32] ,
I_BCH_block_1[30],I_BCH_block_1[28],I_BCH_block_1[26],I_BCH_block_1[24] ,
I_BCH_block_1[22],I_BCH_block_1[20],I_BCH_block_1[18],I_BCH_block_1[16] ,
I_BCH_block_1[14],I_BCH_block_1[12],I_BCH_block_1[10],I_BCH_block_1[8] ,
I_BCH_block_1[6] ,I_BCH_block_1[4] ,I_BCH_block_1[2] ,I_BCH_block_1[0] };
assign w_CH1_D2_data = {
I_BCH_block_2[62],I_BCH_block_2[60],I_BCH_block_2[58],I_BCH_block_2[56] ,
I_BCH_block_2[54],I_BCH_block_2[52],I_BCH_block_2[50],I_BCH_block_2[48] ,
I_BCH_block_2[46],I_BCH_block_2[44],I_BCH_block_2[42],I_BCH_block_2[40] ,
I_BCH_block_2[38],I_BCH_block_2[36],I_BCH_block_2[34],I_BCH_block_2[32] ,
I_BCH_block_2[30],I_BCH_block_2[28],I_BCH_block_2[26],I_BCH_block_2[24] ,
I_BCH_block_2[22],I_BCH_block_2[20],I_BCH_block_2[18],I_BCH_block_2[16] ,
I_BCH_block_2[14],I_BCH_block_2[12],I_BCH_block_2[10],I_BCH_block_2[8] ,
I_BCH_block_2[6] ,I_BCH_block_2[4] ,I_BCH_block_2[2] ,I_BCH_block_2[0] };
assign w_CH1_D3_data = {
I_BCH_block_3[62],I_BCH_block_3[60],I_BCH_block_3[58],I_BCH_block_3[56] ,
I_BCH_block_3[54],I_BCH_block_3[52],I_BCH_block_3[50],I_BCH_block_3[48] ,
I_BCH_block_3[46],I_BCH_block_3[44],I_BCH_block_3[42],I_BCH_block_3[40] ,
I_BCH_block_3[38],I_BCH_block_3[36],I_BCH_block_3[34],I_BCH_block_3[32] ,
I_BCH_block_3[30],I_BCH_block_3[28],I_BCH_block_3[26],I_BCH_block_3[24] ,
I_BCH_block_3[22],I_BCH_block_3[20],I_BCH_block_3[18],I_BCH_block_3[16] ,
I_BCH_block_3[14],I_BCH_block_3[12],I_BCH_block_3[10],I_BCH_block_3[8] ,
I_BCH_block_3[6] ,I_BCH_block_3[4] ,I_BCH_block_3[2] ,I_BCH_block_3[0] };
assign w_CH2_D0_data = {
I_BCH_block_0[63],I_BCH_block_0[61],I_BCH_block_0[59],I_BCH_block_0[57] ,
I_BCH_block_0[55],I_BCH_block_0[53],I_BCH_block_0[51],I_BCH_block_0[49] ,
I_BCH_block_0[47],I_BCH_block_0[45],I_BCH_block_0[43],I_BCH_block_0[41] ,
I_BCH_block_0[39],I_BCH_block_0[37],I_BCH_block_0[35],I_BCH_block_0[33] ,
I_BCH_block_0[31],I_BCH_block_0[29],I_BCH_block_0[27],I_BCH_block_0[25] ,
I_BCH_block_0[23],I_BCH_block_0[21],I_BCH_block_0[19],I_BCH_block_0[17] ,
I_BCH_block_0[15],I_BCH_block_0[13],I_BCH_block_0[11],I_BCH_block_0[9] ,
I_BCH_block_0[7] ,I_BCH_block_0[5] ,I_BCH_block_0[3] ,I_BCH_block_0[1] };
assign w_CH2_D1_data = {
I_BCH_block_1[63],I_BCH_block_1[61],I_BCH_block_1[59],I_BCH_block_1[57] ,
I_BCH_block_1[55],I_BCH_block_1[53],I_BCH_block_1[51],I_BCH_block_1[49] ,
I_BCH_block_1[47],I_BCH_block_1[45],I_BCH_block_1[43],I_BCH_block_1[41] ,
I_BCH_block_1[39],I_BCH_block_1[37],I_BCH_block_1[35],I_BCH_block_1[33] ,
I_BCH_block_1[31],I_BCH_block_1[29],I_BCH_block_1[27],I_BCH_block_1[25] ,
I_BCH_block_1[23],I_BCH_block_1[21],I_BCH_block_1[19],I_BCH_block_1[17] ,
I_BCH_block_1[15],I_BCH_block_1[13],I_BCH_block_1[11],I_BCH_block_1[9] ,
I_BCH_block_1[7] ,I_BCH_block_1[5] ,I_BCH_block_1[3] ,I_BCH_block_1[1] };
assign w_CH2_D2_data = {
I_BCH_block_2[63],I_BCH_block_2[61],I_BCH_block_2[59],I_BCH_block_2[57] ,
I_BCH_block_2[55],I_BCH_block_2[53],I_BCH_block_2[51],I_BCH_block_2[49] ,
I_BCH_block_2[47],I_BCH_block_2[45],I_BCH_block_2[43],I_BCH_block_2[41] ,
I_BCH_block_2[39],I_BCH_block_2[37],I_BCH_block_2[35],I_BCH_block_2[33] ,
I_BCH_block_2[31],I_BCH_block_2[29],I_BCH_block_2[27],I_BCH_block_2[25] ,
I_BCH_block_2[23],I_BCH_block_2[21],I_BCH_block_2[19],I_BCH_block_2[17] ,
I_BCH_block_2[15],I_BCH_block_2[13],I_BCH_block_2[11],I_BCH_block_2[9] ,
I_BCH_block_2[7] ,I_BCH_block_2[5] ,I_BCH_block_2[3] ,I_BCH_block_2[1] };
assign w_CH2_D3_data = {
I_BCH_block_3[63],I_BCH_block_3[61],I_BCH_block_3[59],I_BCH_block_3[57] ,
I_BCH_block_3[55],I_BCH_block_3[53],I_BCH_block_3[51],I_BCH_block_3[49] ,
I_BCH_block_3[47],I_BCH_block_3[45],I_BCH_block_3[43],I_BCH_block_3[41] ,
I_BCH_block_3[39],I_BCH_block_3[37],I_BCH_block_3[35],I_BCH_block_3[33] ,
I_BCH_block_3[31],I_BCH_block_3[29],I_BCH_block_3[27],I_BCH_block_3[25] ,
I_BCH_block_3[23],I_BCH_block_3[21],I_BCH_block_3[19],I_BCH_block_3[17] ,
I_BCH_block_3[15],I_BCH_block_3[13],I_BCH_block_3[11],I_BCH_block_3[9] ,
I_BCH_block_3[7] ,I_BCH_block_3[5] ,I_BCH_block_3[3] ,I_BCH_block_3[1] };
//================================================================//
// 串行移位寄存器处理逻辑 //
// 说明：当包请求信号有效时加载数据，否则逐位右移
//================================================================//
always @(posedge I_pixel_clk or negedge I_reset_n) begin
if(~I_reset_n) begin
r_shift_ch0_d2 <= 32'd0;
r_shift_ch1_d0 <= 32'd0;
r_shift_ch1_d1 <= 32'd0;
r_shift_ch1_d2 <= 32'd0;
r_shift_ch1_d3 <= 32'd0;
r_shift_ch2_d0 <= 32'd0;
r_shift_ch2_d1 <= 32'd0;
r_shift_ch2_d2 <= 32'd0;
r_shift_ch2_d3 <= 32'd0;
end
else if(packet_req_delay_d1) begin // 延迟两拍确保数据稳定
// BCH块4直接载入
r_shift_ch0_d2 <= I_BCH_block_4;
// 加载通道1（偶数位）
r_shift_ch1_d0 <= w_CH1_D0_data;
r_shift_ch1_d1 <= w_CH1_D1_data;
r_shift_ch1_d2 <= w_CH1_D2_data;
r_shift_ch1_d3 <= w_CH1_D3_data;
// 加载通道2（奇数位）
r_shift_ch2_d0 <= w_CH2_D0_data;
r_shift_ch2_d1 <= w_CH2_D1_data;
r_shift_ch2_d2 <= w_CH2_D2_data;
r_shift_ch2_d3 <= w_CH2_D3_data;
end
else begin
// 全局右移（LSB优先发送）
r_shift_ch0_d2 <= r_shift_ch0_d2 >> 1;
r_shift_ch1_d0 <= r_shift_ch1_d0 >> 1;
r_shift_ch1_d1 <= r_shift_ch1_d1 >> 1;
r_shift_ch1_d2 <= r_shift_ch1_d2 >> 1;
r_shift_ch1_d3 <= r_shift_ch1_d3 >> 1;
r_shift_ch2_d0 <= r_shift_ch2_d0 >> 1;
r_shift_ch2_d1 <= r_shift_ch2_d1 >> 1;
r_shift_ch2_d2 <= r_shift_ch2_d2 >> 1;
r_shift_ch2_d3 <= r_shift_ch2_d3 >> 1;
end
end
//================================================================//
// 数据岛通道数据组合输出逻辑 //
// 说明：每个周期组合各移位寄存器的最低位构成4bit输出
//================================================================//
always @(posedge I_pixel_clk or negedge I_reset_n) begin
if(~I_reset_n) begin
O_island_data_ch0 <= 4'd0;
O_island_data_ch1 <= 4'd0;
O_island_data_ch2 <= 4'd0;
end
else begin
// 通道0：控制位 + BCH4数据位[通道0协议映射]
O_island_data_ch0 <= {1'b0 , // 保留位
r_shift_ch0_d2[0] , // BCH4数据LSB
vsync_delay_chain_d2 , // vsync
hsync_delay_chain_d2 }; // hsync
// 通道1：BCH块0-3偶数位数据（从高位到低位D3-D0）
O_island_data_ch1 <= {r_shift_ch1_d3[0] , // D3最低有效位
r_shift_ch1_d2[0] , // D2
r_shift_ch1_d1[0] , // D1
r_shift_ch1_d0[0] }; // D0
// 通道2：BCH块0-3奇数位数据（从高位到低位D3-D0）
O_island_data_ch2 <= {r_shift_ch2_d3[0] , // D3最高有效位
r_shift_ch2_d2[0] , // D2
r_shift_ch2_d1[0] , // D1
r_shift_ch2_d0[0] }; // D0
end
end
//================================================================//
// 最终信号输出寄存器赋值 //
// 说明：使用统一的三级延迟信号对齐所有输出路径
//================================================================//
always @(posedge I_pixel_clk) begin
// 视频时序信号（第三拍延迟）
O_vsync <= vsync_delay_chain_d2;
O_hsync <= hsync_delay_chain_d2;
O_video_preamble <= video_preamble_delay_d2;
O_video_guard_band <= video_guard_delay_d2;
O_de <= video_de_delay_d2;
// 数据岛控制信号（第三拍延迟）
O_island_preamble <= island_preamble_delay_d2;
O_island_guard_band <= island_guard_delay_d2;
O_island_period <= island_period_delay_d2;
// 视频数据通道（第三拍延迟）
O_video_data_ch0 <= video_data_ch0_delay_d2;
O_video_data_ch1 <= video_data_ch1_delay_d2;
O_video_data_ch2 <= video_data_ch2_delay_d2;
end
endmodule

复制代码

4 hdmi_island_data_assemble模块仿真

本模块结合HDMI数据岛时序和I_vsync、I_hsync、I_de控制型号，对视频数据和数据岛数据进行重新整合，最终同步后，同步输出3×8bit的视频数据、3×4bit数据岛数据、数据岛时序、视频时序。

微信扫一扫 分享朋友圈

HDMI-IP项目-主讲HDMI数据岛分组构造（BCH块编码）-连载七

微信扫一扫分享朋友圈