// 时钟与复位
input         sys_clk_i,        // 系统时钟 250MHz
input         clk_ref_i,        // IDELAYCTRL 参考钟 200MHz（必须！）
input         sys_rst,          // 系统复位（ACTIVE LOW）
output        ui_clk,           // 用户时钟 166.67MHz
output        ui_clk_sync_rst,  // 用户复位（高有效）
output        init_calib_complete, // 校准完成标志

// AXI Write Address
input  [3:0]  s_axi_awid,
input  [28:0] s_axi_awaddr,
input  [7:0]  s_axi_awlen,
input  [2:0]  s_axi_awsize,     // 2^5=32 Bytes = 256-bit
// ...

// AXI Write Data
input  [255:0] s_axi_wdata,
input  [31:0]  s_axi_wstrb,
// ...

// AXI Read Data
output [255:0] s_axi_rdata,
// ...

// awaddr 计算——每行代码对应硬件上的一个加法器
assign axi4_awaddr = BASE_ADDR + {rc_wframe_index, rc_w_ptr};
//                   = 0x00000000 + {2'dN, 22'dOffset}
//                   = N × 4MB + Offset

// araddr 计算——与 awaddr 对称
assign axi4_araddr = BASE_ADDR + {rc_rframe_index, araddr};
//                   = 0x00000000 + {2'dN, 22'dOffset}

parameter BURST_LEN = 16;                    // 每 Burst 16 拍
parameter STRB_LEN  = DATA_LEN / 8;          // 256/8 = 32 字节/拍
parameter ADDR_INC  = BURST_LEN * STRB_LEN;  // 16 × 32 = 512 字节/Burst
parameter BUF_SIZE  = 22;                    // 2^22 = 4,194,304 字节/缓冲
parameter BASE_ADDR = 32'h0000_0000;         // DDR 起始地址 = 0

// awvalid 在 IDLE 态发起，在收到 awready 后清除
if (axi4_awvalid && axi4_awready)
    axi4_awvalid <= 1'b0;   // 握手完成，拉低 valid

// 在 WS_W_IDLE 态，FIFO 有数据时重新拉高
WS_W_IDLE: begin
    if (~w_wfifo_pempty || ...) begin
        axi4_awvalid <= 1'b1;   // 发起新的写地址请求
    end
end

module axi4_ctrl #(
    parameter ID_LEN       = 8,          // AXI ID 宽度
    parameter ADDR_LEN     = 32,         // 地址宽度
    parameter DATA_LEN     = 256,        // 数据位宽 (bit)
    parameter DATA_SIZE    = 5,          // 2^5=32 字节/拍
    parameter BURST_LEN    = 16,         // Burst 拍数
    parameter STRB_LEN     = DATA_LEN/8, // 写选通宽度
    parameter ADDR_INC     = BURST_LEN * STRB_LEN, // 512 字节
    parameter W_WIDTH      = 8,          // 写数据输入位宽
    parameter R_WIDTH      = 8,          // 读数据输出位宽
    parameter BUF_SIZE     = 22,         // 2^22 = 4MB 缓冲区
    parameter RD_END_ADDR  = 1280*720,   // 一帧像素数
    parameter BASE_ADDR    = 32'h0000_0000
)(
    input  wire        axi4_clk,         // AXI 时钟 (ui_clk 166.67MHz)
    input  wire        axi4_rst_n,       // AXI 复位 (低有效)

    // AXI4 五个通道 (略，详见源码)
    // ...

    // 帧接口
    input  wire        wframe_pclk,      // 写像素时钟 (24MHz)
    input  wire        wframe_vsync,     // 写帧同步
    input  wire        wframe_data_en,   // 写数据有效
    input  wire [7:0]  wframe_data,      // 写数据

    input  wire        rframe_pclk,      // 读像素时钟 (74.25MHz)
    input  wire        rframe_vsync,     // 读帧同步
    input  wire        rframe_data_en,   // 读数据请求
    output wire [7:0]  rframe_data       // 读数据输出
);

// 移位寄存器：每次移入 W_WIDTH=8 位
reg  [DATA_LEN-1:0] r_wfifo_wdata;
wire [DATA_LEN-1:0] w_wfifo_wdata;
assign w_wfifo_wdata = {wframe_data, r_wfifo_wdata[DATA_LEN-1:W_WIDTH]};

always @(posedge wframe_pclk) begin
    if (!r_w_rst_n) begin
        r_wfifo_wdata <= {DATA_LEN{1'b0}};   // 帧结束时清空
    end else if (wframe_data_en) begin
        r_wfifo_wdata <= w_wfifo_wdata;       // 每有效像素移入 8 位
    end
end

WS_W_EOF: begin
    r_weof_pending <= 1'b0;      // 清除 EOF 标志
    rc_w_ptr       <= 1'b0;      // 写指针归零（新帧从头开始）
    state_write    <= WS_W_IDLE;  // 回到空闲
end

localparam WS_W_IDLE  = 2'b00;   // 空闲：等待 FIFO 数据
localparam WS_W_WDATA = 2'b01;   // 写数据：发送 Burst
localparam WS_W_WINC  = 2'b10;   // 指针递增：Burst 完成
localparam WS_W_EOF   = 2'b11;   // 帧结束：复位指针

case (state_write)
    WS_W_IDLE: begin
        if (~w_wfifo_pempty || ...) begin
            axi4_awvalid <= 1'b1;              // 发起写请求
            axi4_wvalid  <= 1'b1;
            state_write  <= WS_W_WDATA;
        end else if (r_weof_pending) begin
            r_w_rst_n <= 1'b0;                 // 帧结束，复位 FIFO
            r_wframe_inc <= 1'b1;              // 通知帧索引管理
            state_write <= WS_W_EOF;
        end
    end

    WS_W_WDATA: begin
        rc_burst <= rc_burst + axi4_wready;
        if (axi4_wlast && axi4_wready) begin   // Burst 最后一拍
            axi4_wvalid <= 1'b0;
            state_write <= WS_W_WINC;
        end
    end

    WS_W_WINC: begin
        rc_w_ptr <= rc_w_ptr + ADDR_INC;       // 指针增加 512 字节
        state_write <= WS_W_IDLE;
    end

    WS_W_EOF: begin
        r_weof_pending <= 1'b0;
        rc_w_ptr <= 1'b0;
        state_write <= WS_W_IDLE;
    end
endcase

// 计数器：每读取一个像素 +1，0→31 循环
localparam RFIFO_CNT_SIZE = (R_WIDTH == 8) ? 5 : ...;
reg [RFIFO_CNT_SIZE-1:0] rc_rfifo_rd;

always @(posedge rframe_pclk or posedge r_rfifo_rst_rclk) begin
    if (r_rfifo_rst_rclk) begin
        rc_rfifo_rd <= 'd0;
    end else if (rframe_data_en) begin
        rc_rfifo_rd <= rc_rfifo_rd + 1'b1;
    end
end

// 在 rc_rfifo_rd==0 时从 FIFO 加载新 256-bit 字
assign w_rframe_data_en_gen = rframe_data_en && (rc_rfifo_rd == 0)
                              && !w_rfifo_empty;

// 数据移位输出
reg [255:0] r_rframe_data_gen;
always @(posedge rframe_pclk) begin
    if (w_rframe_data_en_gen) begin
        r_rframe_data_gen <= w_rframe_data_gen;   // 加载新字
    end else if (rframe_data_en) begin
        r_rframe_data_gen <= r_rframe_data_gen >> R_WIDTH; // 右移 8 位
    end
end
assign rframe_data = w_rfifo_empty ? 8'h00
                    : r_rframe_data_gen[R_WIDTH-1:0];

// 当 AXI 读数据到达时，写入 R0_FIFO
always @(posedge axi4_clk) begin
    if (axi4_rvalid && axi4_rready) begin
        rfifo_wenb  <= 1'b1;        // 单周期写使能
    end else begin
        rfifo_wenb  <= 1'b0;
    end
end

always @(posedge axi4_clk) begin
    rfifo_wdata <= axi4_rdata;      // 延迟一拍对齐写使能
end

// 读地址递增管理
always @(posedge axi4_clk or posedge r_rfifo_rst) begin
    if (r_rfifo_rst)
        araddr <= 0;                       // 帧复位：归零
    else if (axi4_arvalid && axi4_arready)
        araddr <= araddr + ADDR_INC;        // Burst 完成：+512
end

// 读完成跟踪
always @(posedge axi4_clk or posedge r_rfifo_rst) begin
    if (r_rfifo_rst) begin
        rd_state    <= S_READ_IDLE;
        r_rd_pend   <= 0;
        axi4_arvalid <= 0;
    end else begin
        // arvalid 在握手后清除
        if (axi4_arready && axi4_arvalid)
            axi4_arvalid <= 0;
        
        // r_rd_pend 在最后一拍数据到达时清除
        if (axi4_rvalid && axi4_rlast)
            r_rd_pend <= 0;
        
        case (rd_state)
            S_READ_IDLE:
                if (ready) begin           // FIFO 稳定 && 地址未超 && FIFO 未满
                    rd_state    <= S_READ_ADDR;
                end
            S_READ_ADDR: begin
                axi4_arvalid <= 1;         // 发起读请求
                r_rd_pend    <= 1;
                rd_state     <= S_READ_DATA;
            end
            S_READ_DATA:
                if (!axi4_arvalid && !r_rd_pend) // Burst 全部完成
                    rd_state <= S_READ_IDLE;
        endcase
    end
end

// ========== W0_FIFO：写侧 FIFO ==========
W0_FIFO_256 u_W0_FIFO_256 (
    .rst        (~r_w_rst_n),          // 帧结束时复位（高有效）
    .wr_clk     (wframe_pclk),         // 写时钟 = 像素时钟 (24MHz)
    .wr_en      (wframe_data_en && (&rc_wfifo_we)), // 32 像素写一次
    .din        (w_wfifo_wdata),       // 拼接后的 256-bit 数据
    .rd_clk     (axi4_clk),            // 读时钟 = AXI 时钟 (166.67MHz)
    .rd_en      (w_wfifo_ren),         // axi4_wvalid && axi4_wready
    .dout       (w_wfifo_rdata),       // 输出到 AXI 写数据总线
    .empty      (w_wfifo_empty),
    .prog_empty (w_wfifo_pempty)       // 几乎空：触发 Burst 的条件
);

// ========== R0_FIFO：读侧 FIFO ==========
R0_FIFO_256 u_R0_FIFO_256 (
    .rst        (w_rfifo_rst),         // 帧边界复位（高有效）
    .wr_clk     (axi4_clk),            // 写时钟 = AXI 时钟 ← 必须是 axi4_clk!
    .wr_en      (rfifo_wenb),          // axi4_rvalid && axi4_rready
    .din        (rfifo_wdata),         // AXI 读回的数据 ← 必须接 rfifo_wdata!
    .rd_clk     (rframe_pclk),         // 读时钟 = 像素时钟 (74.25MHz)
    .rd_en      (w_rframe_data_en_gen),// 每 32 像素读一次
    .dout       (w_rframe_data_gen),   // 输出到解包移位寄存器
    .empty      (w_rfifo_empty),
    .prog_empty (w_rfifo_aempty)
);

case (rd_state)
    S_READ_IDLE: begin
        // 条件：FIFO 稳定 && 地址未到帧尾 && FIFO 未满
        if (rfifo_wr_rst_busy_dly[15]
            && (araddr < RD_END_ADDR)
            && (~rfifo_wfull))
            rd_state <= S_READ_ADDR;
    end
    S_READ_ADDR: begin
        axi4_arvalid <= 1;          // 发起读请求
        r_rd_pend    <= 1;          // 标记有待处理读
        rd_state     <= S_READ_DATA;
    end
    S_READ_DATA: begin
        if ((~axi4_arvalid) && (~r_rd_pend))
            rd_state <= S_READ_IDLE; // Burst 完成
    end
endcase

// 缓冲区分配：每个 4MB，4 个共 16MB
// rc_wframe_index: 写指针 (0→1→2→3→0→...)
// rc_rframe_index: 读指针 (初始 2，远离写指针)

// 写完成后
rc_wframe_index <= w_wframe_index_next;       // 移到下一个安全位置
r_wframe_index_last <= rc_wframe_index;       // 记录刚写完的缓冲

// 读开始时（仅在写完成至少一帧后）
if (wframe_done)
    rc_rframe_index <= r_wframe_index_last;   // 读取刚写完的缓冲

// 错误代码
assign awaddr = BASE_ADDR + {rc_wframe_index, rc_w_ptr}; // awaddr 未声明！隐式 1-bit wire
// axi4_awaddr 端口从未被赋值！→ 悬空

assign axi4_awaddr = BASE_ADDR + {rc_wframe_index, rc_w_ptr};

// 错误
.din (w_rframe_data_gen),    // w_rframe_data_gen 是 FIFO 的 dout！
.dout(w_rframe_data_gen),    // 同一个 wire！

// 正确
.din (rfifo_wdata),          // AXI 读数据
.dout(w_rframe_data_gen),    // FIFO 输出
.wr_clk(axi4_clk),           // 写时钟 = AXI 时钟（不是 rframe_pclk！）

// 错误
wire w_rfifo_rst_n = (~axi4_rst_n) || (~rfifo_rst_n); // 命名为 _n 但存 active-high
R0_FIFO .rst(~w_rfifo_rst_n);  // 又取反一次 = 双取反 = 和原意相反

// 正确
wire w_rfifo_rst = (~axi4_rst_n) || (~rfifo_rst_n); // active-high
R0_FIFO .rst(w_rfifo_rst);