FPGA数字信号处理—1S上报一次解析数据

数字信号结果处理完毕之后，需要定时上报，利用计数器完成定时上报；

module Error_bit_report (
    input  wire        clk,               // 时钟信号
    input  wire        rst_n,             // 复位信号，低有效
    input  wire        error_compare_ena, // 误码比较使能信号
    input  wire [31:0] error_bit_count,   // 错误的bit数量
    input  wire [31:0] total_bit_count,   // 总的bit数量
    output reg  [15:0] data_out,          // 输出16位数据
    output reg         data_out_valid     // 数据有效信号
);
reg error_compare_ena_0;
reg error_compare_ena_1;
reg error_compare_ena_2;//1s 计数器使能开启
// 定义状态，使用parameter定义并用格雷码编码
parameter S0 = 4'b0000;  // 空闲状态
parameter S1 = 4'b0001;  // 输出5555
parameter S2 = 4'b0011;  // 输出5555
parameter S3 = 4'b0010;  // 输出5500
parameter S4 = 4'b0110;  // 输出AA78
parameter S5 = 4'b0111;  // 输出error_bit_count高16位
parameter S6 = 4'b0101;  // 输出error_bit_count低16位
parameter S7 = 4'b0100;  // 输出total_bit_count高16位
parameter S8 = 4'b1000;  // 输出total_bit_count低16位
//parameter S9 = 3'b011;  // 等待状态1s

always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        error_compare_ena_0 <= 0;  // 复位时进入空闲状态
        error_compare_ena_1 <= 0;
        error_compare_ena_2 <= 0;
    end else begin
        error_compare_ena_0 <= error_compare_ena;  // 更新状态
        error_compare_ena_1 <= error_compare_ena_0;
        error_compare_ena_2 <= error_compare_ena_1;
     
   end     
end


// 状态寄存器
reg [2:0] current_state, next_state;

// 计数器，用于1秒延时控制
reg [31:0] delay_counter;
wire delay_done = (delay_counter == 32'd100_000_000); // 假设时钟频率为100MHz，1秒需要1亿个时钟周期

// 状态转移逻辑
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        current_state <= S0;  // 复位时进入空闲状态
    end else begin
        current_state <= next_state;  // 更新状态
    end
end

// 状态选择逻辑
always @(*) begin
    case (current_state)
        S0: if (error_compare_ena_1) next_state = S1; else next_state = S0;
        S1: next_state = S2;
        S2: next_state = S3;
        S3: next_state = S4;
        S4: next_state = S5;
        S5: next_state = S6;
        S6: next_state = S7;
        S7: next_state = S8;
        S8: next_state = S1;  // 等待1秒
//        S9: if (delay_done) next_state = S0; else next_state = S9;  // 如果1秒计时结束，则重新开始
        default: next_state = S0;
    endcase
end
//1秒计数器逻辑
//输出使能开启之后，计数的前七个数data_out_valid，之后的data_out_valid为0

always @(posedge clk or negedge rst_n) begin
  if(!rst_n) begin
    data_out_valid<= 1'b0;
  end else if (error_compare_ena_2&&delay_counter<8) begin
    data_out_valid<=1;  
  end else
    data_out_valid <= 0;  // 每个时钟周期递增计数器
end

// 1秒计数器逻辑
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        delay_counter <= 32'b0;
    end else if (error_compare_ena_2) begin
        if (delay_done)
            delay_counter <= 32'b0;  // 计时结束，计数器清零
        else
            delay_counter <= delay_counter + 1;  // 每个时钟周期递增计数器
    end
end

// 数据输出逻辑
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        data_out <= 16'b0;

    end else begin
        case (current_state)
            S0: begin
                data_out <= 16'b0;

            end
            S1: begin
                data_out <= 16'h5555;  // 输出第一个16位word

            end
            S2: begin
                data_out <= 16'h5555;  // 输出第二个16位word

            end
            S3: begin
                data_out <= 16'h5500;  // 输出第三个16位word

            end
            S4: begin
                data_out <= 16'hAA78;  // 输出第四个16位word

            end
            S5: begin
                data_out <= error_bit_count[31:16];  // 输出error_bit_count高16位
                
            end
            S6: begin
                data_out <= error_bit_count[15:0];  // 输出error_bit_count低16位
                
            end
            S7: begin
                data_out <= total_bit_count[31:16];  // 输出total_bit_count高16位
               
            end
            S8: begin
                data_out <= total_bit_count[15:0];  // 输出total_bit_count低16位
                
//            end
//            S9: begin
//                data_out <= 16'b0;  // 空闲状态下输出0
//                data_out_valid <= 1'b0;  // 数据有效信号变为0，等待1秒后重新开始
            end
            default: begin
                data_out <= 16'b0;
                data_out_valid <= 1'b0;
            end
        endcase
    end
end

endmodule