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

UT发布 · 发表于昨天 11:19

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
复制代码