Verilog FIFO转AXI4-Full模块的RTL简单实现 - Master主机

已于 2024-04-19 16:16:07 修改
阅读量310 收藏 2
点赞数 2
分类专栏： Verilog数字逻辑模块 文章标签： fpga开发 fpga 嵌入式硬件 经验分享
于 2024-04-19 16:15:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/membre_non/article/details/137968921
版权

之前看到有大佬说任何协议都可以用FIFO实现，想了想还觉得挺有道理

试着写了下FIFO转AXI4-Full的模块，为了避免使用时产生死锁，还是添加了状态机去满足AXI4的时序。

输入：写从机地址FIFO+写数据FIFO、读从机地址FIFO+读数据FIFO

输出：AXI4-Full主机端口

不支持Outstanding和乱序传输

module axi_full_m_module
#(
    parameter M_AXI_TARGET_SLAVE_BASE_ADDR  = 32'h40000000  ,
    parameter M_AXI_BURST_LEN               = 16            ,
    parameter M_AXI_ID_WIDTH                = 1             ,
    parameter M_AXI_ADDR_WIDTH              = 32            ,
    parameter M_AXI_DATA_WIDTH              = 32            ,
    parameter M_AXI_AWUSER_WIDTH            = 0             ,
    parameter M_AXI_ARUSER_WIDTH            = 0             ,
    parameter M_AXI_WUSER_WIDTH             = 0             ,
    parameter M_AXI_RUSER_WIDTH             = 0             ,
    parameter M_AXI_BUSER_WIDTH             = 0
)
(
    input   M_AXI_ACLK,
    input   M_AXI_ARESETn,  // AXI协议默认低电平复位

    /*********
        M_AXI端口
    ********/

    /* 写地址通道 */
    output  wire [M_AXI_ID_WIDTH-1 : 0]         M_AXI_AWID      ,
    output  wire [M_AXI_ADDR_WIDTH-1 : 0]       M_AXI_AWADDR    ,
    output  wire [7 : 0]                        M_AXI_AWLEN     ,
    output  wire [2 : 0]                        M_AXI_AWSIZE    ,
    output  wire [1 : 0]                        M_AXI_AWBURST   ,
	output  wire                                M_AXI_AWLOCK    ,
    output  wire [3 : 0]                        M_AXI_AWCACHE   ,
    output  wire [2 : 0]                        M_AXI_AWPROT    ,
    output  wire [3 : 0]                        M_AXI_AWQOS     ,
    output  wire [M_AXI_AWUSER_WIDTH-1 : 0]     M_AXI_AWUSER    ,
    output  wire                                M_AXI_AWVALID   ,
    input   wire                                M_AXI_AWREADY   ,

    /* 写数据通道 */
    output  wire [M_AXI_DATA_WIDTH-1 : 0]       M_AXI_WDATA     ,
    output  wire [M_AXI_DATA_WIDTH/8-1 : 0]     M_AXI_WSTRB     ,
    output  wire                                M_AXI_WLAST     ,
    output  wire [M_AXI_WUSER_WIDTH-1 : 0]      M_AXI_WUSER     ,
    output  wire                                M_AXI_WVALID    ,
    input   wire                                M_AXI_WREADY    ,

    /* 写应答通道 */
    input   wire [M_AXI_ID_WIDTH-1 : 0]         M_AXI_BID       ,
    input   wire [1 : 0]                        M_AXI_BRESP     ,
    input   wire [M_AXI_BUSER_WIDTH-1 : 0]      M_AXI_BUSER     ,
    input   wire                                M_AXI_BVALID    ,
    output  wire                                M_AXI_BREADY    ,

    /* 读地址通道 */
    output  wire [M_AXI_ID_WIDTH-1 : 0]         M_AXI_ARID      ,
    output  wire [M_AXI_ADDR_WIDTH-1 : 0]       M_AXI_ARADDR    ,
    output  wire [7 : 0]                        M_AXI_ARLEN     ,
    output  wire [2 : 0]                        M_AXI_ARSIZE    ,
    output  wire [1 : 0]                        M_AXI_ARBURST   ,
    output  wire                                M_AXI_ARLOCK    ,
    output  wire [3 : 0]                        M_AXI_ARCACHE   ,
    output  wire [2 : 0]                        M_AXI_ARPROT    ,
    output  wire [3 : 0]                        M_AXI_ARQOS     ,    
    output  wire [M_AXI_ARUSER_WIDTH-1 : 0]     M_AXI_ARUSER    ,
    output  wire                                M_AXI_ARVALID   ,
    input   wire                                M_AXI_ARREADY   ,

    /* 读数据通道 */
    input   wire [M_AXI_ID_WIDTH-1 : 0]         M_AXI_RID       ,
    input   wire [M_AXI_DATA_WIDTH-1 : 0]       M_AXI_RDATA     ,
    input   wire [1 : 0]                        M_AXI_RRESP     ,
    input   wire                                M_AXI_RLAST     ,
    input   wire [M_AXI_RUSER_WIDTH-1 : 0]      M_AXI_RUSER     ,
    input   wire                                M_AXI_RVALID    ,
    output  wire                                M_AXI_RREADY    ,   

    /*********
        FIFO端口
    ********/

    /* 写地址FIFO */
    input   wire [M_AXI_ADDR_WIDTH-1 : 0]       FIFO_AWADDR     ,
    input   wire                                FIFO_AWEMPTY    ,
    output  wire                                FIFO_AWREAD     ,
    /* 写数据FIFO */
    input   wire [M_AXI_DATA_WIDTH-1 : 0]       FIFO_WDATA      ,
    input   wire                                FIFO_WEMPTY     ,
    output  wire                                FIFO_WREAD      ,

    /* 读地址FIFO */
    input   wire [M_AXI_ADDR_WIDTH-1 : 0]       FIFO_ARADDR     ,
    input   wire                                FIFO_AREMPTY    ,
    output  wire                                FIFO_ARREAD     ,

    output  wire [M_AXI_DATA_WIDTH-1 : 0]       FIFO_RDATA      ,
    input   wire                                FIFO_RFULL      ,
    output  wire                                FIFO_RWRITE         
);

// 计算二进制位宽
function integer clogb2(integer  number);
    begin
        for (clogb2 = 0; number > 0; clogb2 = clogb2 + 1) begin
            number = number >> 1;
        end
    end
endfunction

/******** 
    参数 
********/
localparam M_AXI_DATA_BYTE = M_AXI_DATA_WIDTH / 8;

/******** 
    状态机 
********/
reg [3:0] r_s_w_cs; // STATE MACHINE (WRITE) CURRENT STATE
reg [3:0] r_s_w_ns; // STATE MACHINE (WRITE) NEXT STATE
localparam S_W_IDLE = 'b0001;
localparam S_W_ADDR = 'b0010;
localparam S_W_DATA = 'b0100;
localparam S_W_RESB = 'b1000;

reg [2:0] r_s_r_cs; 
reg [2:0] r_s_r_ns; 
localparam S_R_IDLE = 'b001;
localparam S_R_ADDR = 'b010;
localparam S_R_DATA = 'b100;

/******** 
    寄存器
********/
reg [M_AXI_ADDR_WIDTH-1:0]          r_m_axi_awaddr  ;
reg                                 r_m_axi_awvalid ;

reg [M_AXI_DATA_WIDTH-1:0]          r_m_axi_wdata   ;
reg                                 r_m_axi_wlast   ;
reg                                 r_m_axi_wvalid  ;
reg [clogb2(M_AXI_BURST_LEN)-1:0]   r_wcnt          ;

reg [M_AXI_ADDR_WIDTH-1:0]          r_m_axi_araddr  ;
reg                                 r_m_axi_arvalid ;
        
reg                                 r_m_axi_rready  ;
reg [clogb2(M_AXI_BURST_LEN):0]     r_rcnt          ;

reg [M_AXI_DATA_WIDTH-1:0]          r_fifo_rdata    ;
reg                                 r_fifo_rwrite   ;

/********   
    网表
********/
wire sys_clk;
wire sys_rst;

/******** 
    组合逻辑
********/
assign sys_clk          = M_AXI_ACLK                        ;
assign sys_rst          = ~M_AXI_ARESETn                    ;   // Xilinx FPGA寄存器支持高电平同步复位

assign M_AXI_AWID       = 'b0                               ;
assign M_AXI_AWADDR     = r_m_axi_awaddr + M_AXI_TARGET_SLAVE_BASE_ADDR;    // 增加基址偏移量，区分不同从机
assign M_AXI_AWLEN      = M_AXI_BURST_LEN                   ;
assign M_AXI_AWSIZE     = clogb2(M_AXI_DATA_BYTE) - 1       ;
assign M_AXI_AWBURST    = 'b01                              ;
assign M_AXI_AWLOCK     = 'b0                               ;
assign M_AXI_AWCACHE    = 'b0010                            ;
assign M_AXI_AWPROT     = 'b0                               ;
assign M_AXI_AWQOS      = 'b0                               ;
assign M_AXI_AWUSER     = 'b0                               ;
assign M_AXI_AWVALID    = r_m_axi_awvalid                   ;

assign M_AXI_WDATA      = r_m_axi_wdata                     ;
assign M_AXI_WSTRB      = {M_AXI_DATA_BYTE{1'b1}}           ;   // 数据位全部有效
assign M_AXI_WLAST      = r_m_axi_wlast                     ;
assign M_AXI_WUSER      = 'd0                               ;
assign M_AXI_WVALID     = r_m_axi_wvalid                    ;

assign M_AXI_BREADY     = 'b1                               ;   // 响应接收准备好 - 保持置位

assign M_AXI_ARID       = 'b0                               ;
assign M_AXI_ARADDR     = r_m_axi_araddr + M_AXI_TARGET_SLAVE_BASE_ADDR;
assign M_AXI_ARLEN      = M_AXI_BURST_LEN                   ;
assign M_AXI_ARSIZE     = clogb2(M_AXI_DATA_BYTE) - 1       ;
assign M_AXI_ARBURST    = 'b01                              ;
assign M_AXI_ARLOCK     = 'b0                               ;
assign M_AXI_ARCACHE    = 'b0010                            ;
assign M_AXI_ARPROT     = 'b0                               ;
assign M_AXI_ARQOS      = 'b0                               ;
assign M_AXI_ARUSER     = 'b0                               ;
assign M_AXI_ARVALID    = r_m_axi_arvalid                   ;

assign M_AXI_RREADY     = r_m_axi_rready                    ;

assign FIFO_AWREAD      = (r_s_w_cs == S_W_ADDR) && ~FIFO_AWEMPTY                   ;
assign FIFO_WREAD       = (r_s_w_cs == S_W_DATA) && ~FIFO_AWEMPTY && ~M_AXI_WLAST
    && ((r_wcnt == 'd0)                         // 读取突发传输的第一个数据
        || ((r_wcnt != 'd0) && M_AXI_WREADY))                                       ;  // 读取突发传输的其他数据

assign FIFO_ARREAD      = (r_s_r_cs == S_R_ADDR) && ~FIFO_AREMPTY                   ;
assign FIFO_RDATA       = (r_s_r_cs == S_R_DATA) && r_fifo_rdata                    ;
assign FIFO_RWRITE      = (r_s_r_cs == S_R_DATA) && r_fifo_rwrite                   ;

/******** 
    例化 
********/

/******** 
    状态机跳转逻辑 
********/

/* 写状态机 */
always @(posedge sys_clk) begin
    if (sys_rst)
        r_s_w_cs <= S_W_IDLE;
    else
        r_s_w_cs <= r_s_w_ns;
end

always @(*) begin
    case(r_s_w_cs)
        S_W_IDLE: r_s_w_ns = ~FIFO_AWEMPTY ? S_W_ADDR : S_W_IDLE;
        S_W_ADDR: r_s_w_ns = (M_AXI_AWVALID && M_AXI_AWREADY) ? S_W_DATA : S_W_ADDR;
        S_W_DATA: r_s_w_ns = (M_AXI_WVALID && M_AXI_WREADY && M_AXI_WLAST) ? S_W_RESB : S_W_DATA;
        S_W_RESB: r_s_w_ns = (M_AXI_BVALID && M_AXI_BREADY) ? S_W_IDLE : S_W_RESB;
        default: r_s_w_ns = S_W_IDLE;
    endcase
end

/* 读状态机 */
always @(posedge sys_clk) begin
    if (sys_rst)
        r_s_r_cs <= S_R_IDLE;
    else
        r_s_r_cs <= r_s_r_ns;
end

always @(*) begin
    case(r_s_r_cs)
        S_R_IDLE: r_s_r_ns = ~FIFO_AREMPTY ? S_R_ADDR : S_R_IDLE;
        S_R_ADDR: r_s_r_ns = (M_AXI_ARVALID && M_AXI_ARREADY) ? S_R_DATA : S_R_ADDR;
        S_R_DATA: r_s_r_ns = (r_rcnt == M_AXI_BURST_LEN) ? S_R_IDLE : S_R_DATA;
        default: r_s_r_ns = S_R_IDLE;
    endcase
end

/******** 
    进程
********/
always @(posedge sys_clk) begin
    if (sys_rst) begin
        r_m_axi_awaddr  <= 'd0;
        r_m_axi_awvalid <= 'b0;

        r_m_axi_wdata   <= 'd0;
        r_m_axi_wvalid  <= 'b0;
        r_m_axi_wlast   <= 'b0;
        r_wcnt          <= 'd0;

        r_m_axi_rready  <= 'b0;
    end
    else begin
        case (r_s_w_cs)
            S_W_IDLE: begin
                r_m_axi_awaddr  <= 'd0;
                r_m_axi_awvalid <= 'b0;

                r_m_axi_wdata   <= 'd0;
                r_m_axi_wvalid  <= 'b0;
                r_m_axi_wlast   <= 'b0;
                r_wcnt          <= 'd0;

                r_m_axi_rready  <= 'b0;
            end

            S_W_ADDR: begin
                if (FIFO_AWREAD) begin
                    r_m_axi_awaddr  <= FIFO_AWADDR;
                    r_m_axi_awvalid <= 'b1;
                end 
                else if (M_AXI_AWVALID && M_AXI_AWREADY) begin
                    r_m_axi_awaddr  <= 'd0;
                    r_m_axi_awvalid <= 'b0;
                end
                else begin
                    r_m_axi_awaddr  <= r_m_axi_awaddr;
                    r_m_axi_awvalid <= r_m_axi_awvalid;
                end
            end

            S_W_DATA: begin
                if (FIFO_WREAD) begin
                    r_m_axi_wdata   <= FIFO_WDATA;
                    r_m_axi_awvalid <= 'b1;
                end 
                else if (M_AXI_WVALID && M_AXI_WREADY) begin
                    r_m_axi_awaddr  <= 'd0;
                    r_m_axi_awvalid <= 'b0;
                end
                else begin
                    r_m_axi_awaddr  <= r_m_axi_awaddr;
                    r_m_axi_awvalid <= r_m_axi_awvalid;
                end

                if (FIFO_WREAD) 
                    r_wcnt <= r_wcnt + 'd1;
                else if (M_AXI_WLAST)
                    r_wcnt <= 'd0;
                else
                    r_wcnt <= r_wcnt;

                if (FIFO_WREAD && (r_wcnt == M_AXI_BURST_LEN - 1))
                    r_m_axi_wlast <= 'b1;
                else if (M_AXI_WVALID && M_AXI_WREADY && M_AXI_WLAST)
                    r_m_axi_wlast <= 'b0;
                else
                    r_m_axi_wlast <= r_m_axi_wlast;
            end

            S_W_RESB: begin
                if (~M_AXI_RREADY)
                    r_m_axi_rready <= 'b1;
                else if (M_AXI_RVALID && M_AXI_RREADY)
                    r_m_axi_rready <= 'b0;
                else
                    r_m_axi_rready <= r_m_axi_rready;
            end 
        endcase
    end
end

always @(posedge sys_clk) begin
    if (sys_rst) begin
        r_m_axi_araddr  <= 'd0;
        r_m_axi_arvalid <= 'b0;

        r_fifo_rdata    <= 'd0;
        r_fifo_rwrite   <= 'b0;

        r_rcnt          <= 'd0;
    end
    else begin
        case (r_s_r_cs)
            S_R_IDLE: begin
                r_m_axi_araddr  <= 'd0;
                r_m_axi_arvalid <= 'b0;

                r_fifo_rdata    <= 'd0;
                r_fifo_rwrite   <= 'b0;

                r_rcnt          <= 'd0;
            end

            S_R_ADDR: begin
                if (FIFO_ARREAD) begin
                    r_m_axi_araddr  <= FIFO_ARADDR;
                    r_m_axi_arvalid <= 'b1;
                end 
                else if (M_AXI_ARVALID && M_AXI_ARREADY) begin
                    r_m_axi_araddr  <= 'd0;
                    r_m_axi_arvalid <= 'b0;
                end
                else begin
                    r_m_axi_araddr  <= r_m_axi_araddr;
                    r_m_axi_arvalid <= r_m_axi_arvalid;
                end            
            end

            S_R_DATA: begin
                if (M_AXI_RVALID) begin
                    r_fifo_rdata  <= M_AXI_RDATA;
                    r_fifo_rwrite <= 'b1;
                end 
                else if (FIFO_RWRITE && ~FIFO_RFULL) begin
                    r_fifo_rdata  <= 'd0;
                    r_fifo_rwrite <= 'b0;
                end
                else begin
                    r_fifo_rdata  <= r_fifo_rdata; 
                    r_fifo_rwrite <= r_fifo_rwrite;
                end

                if (FIFO_RWRITE && ~FIFO_RFULL) 
                    r_rcnt <= r_rcnt + 'd1;
                else if (r_rcnt == M_AXI_BURST_LEN)
                    r_rcnt <= 'd0;
                else 
                    r_rcnt <= r_rcnt;
            end
            default: r_s_r_ns = S_R_IDLE;
        endcase
    end
end



endmodule

优质蛋白 - 芯片打工人
关注
专栏目录
基于 DDR3 的串口传图帧缓存系统设计实现（fifo_mig_axi_fifo ）
小王在努力...的博客
05-10 1912
结合串口接收模块和 tft 显示屏控制模块，设计一个基于 DDR3 的串口传图帧缓存系统。
AXI4总线外设式从机实现
TechDiary的博客
09-13 1119
引言：上一篇我们完成了一个内存式的从机，实现了对AXI4从机的读写测试。本周我们将实现一个简单的外设式的从机，希望能够解决一些大家的疑惑，并抛砖引玉，希望大家能够做出自己的设计~ 还是老规矩，后台回复“AXI4”可以领取相关代码，链接将会保持更新。 外设式的从机本质上也是一组寄存器的读写，只不过读写寄存器对应了一些特别的动作。本期分享的从机驱动的是一个SPI通信的DA模块，型号是AD5308，8位精度8个通道，目前已经测试成功。理论上来讲在稍微修改的前提下可以兼容其他SPI设备，但是本次分享重点不在于..
FPGA：将FIFO封装成AXI接口的IP
m0_46830519的博客
07-08 3051
封装AXI_stream的接口IP核
AXI4-STREAM DATA FIFO学习
热门推荐
三思的博客
05-17 2万+
如图是该fifo的配置图，vivado版本2018.2. AXI4-Stream Data FIFO 配置 General Options Component Name 器件名字 FIFO depth FIFO的深度，可以在16到32768之间变化，具体情况视情况而定，但要是2的n次幂。 Enable packet mode 使能包模式：此项设定需要TLAST信号被使能。FIFO的操作...
【ZYNQ逻辑】AXI接口转换模块设计
最新发布
zgmxs的专栏
05-10 748
DDR作为大容量存储器件，在FPGA设计中占有十分重要的地位。对于xilinx的7系列fpga以及Zynq-7000系列SoC来说，要想实现数据对DDR的读写，通用的解决方案是使用mig软核作为控制器，控制数据的读写进行。ACZ702和ACZ7015开发板使用的主控器件隶属于Zynq-7000系列。与ACX720所使用的Artix-7系列的XC7A35T器件不同的是，这些器件PS侧自带有硬核DDR控制器，PL端（FPGA逻辑部分）可以通过AXI总线使用PS端的DDR控制器完成对DDR的读写操作。
手撕AXI-Full总线接口，实现AXI_Full Master接口
modest_cat的博客
05-07 1917
基于Xlinx 的AXI4_Full手撕AXI_Full Master接口，采用Verilog实现，支持1~256的Burst_len，并对设计进行仿真验证。
ch38-acz7015-fifo-axi4-adapter.rar
05-10
标题中的"ch38-acz7015-fifo-axi4-adapter.rar"以及描述中的"ch38_acz7015_fifo_axi4_adapter.rar"都指向了一个特定的设计模块，可能是某个硬件设计项目或者软件开发工程。在这个案例中，"acz7015"可能是一个特定的...
verilog-ft245:Verilog FT245至AXI流接口
05-12
这是基本的FTDI FT245 USB FIFO到AXI流IP内核，使用MyHDL测试平台以Verilog编写。 文献资料 核心的主要代码位于rtl子目录中。 axis_ft245.v包含整个实现。 源文件 axis_ft245.v : FTDI FT245 to AXI stream bridge ...
DDR3 控制器 MIG IP 详解完整版 （AXI4&Vivado&Verilog）
小王在努力...的博客
04-11 6044
本节主要是介绍 Xilinx DDR 控制器 IP 的创建流程、IP 用户使用接口 AXI 协议介绍和IP 对应的 Example Design 的仿真和上板验证。
[ZYNQ]开发之基于 AN108 模块的ADC 采集以太网传输
weixin_45303812的博客
08-27 5774
本文基于AN108模块，将ADC采集的数据通过以太网传输到上位机。
AXI总线（轻松搞定AXI总线）源码和验证工程AXI4.rar
06-26
AXI总线系列博客专属源码和验证工程，博客地址如下： https://blog.csdn.net/qq_33486907/article/details/88289714
关于FIFO FPGA的很多心得经验及原理接口等
04-06
关于FIFO FPGA的很多心得经验及原理接口等
基于xilinx的axi-fifo的应用
Multiroad的博客
08-04 5110
FPGA开发过程中，fifo是我们不可避免的使用的一种缓存。相对于常规的fifo，本文中介绍如何使用xilinx的axi-fifo，介绍了输入输出的说明、时序关系以及注意事项。
Zynq—AD9238数据采集DDR3缓存千兆以太网发送实验（一）
Chinalihuanyu的博客
03-01 2546
fifo2axi4 为 AXI4 接口转换模块，负责fifo 与 axi4 接口间的转换， 将写侧 FIFO 里的数据读出然后存储在 DDR 存储器以及将 DDR 存储器读出的数据存放到读侧 FIFO 缓存。fifo_axi4_adapter 负责FIFO接口到AXI4接口的转换，FIFO中的数据可以通过该模块写入PS端，PS端的数据也可以由该模块接收写入FIFO。在 Vivado 的 Source 窗口中，出现了新配置生成的 IP 核文件mig_7series_0（mig_7series_0.xci）。
基于FPGA的AXI_FULL主机模块测试（含源码）
weixin_50810761的博客
03-29 1381
本文通过Verilog HDL实现了一个AXI_FULL主机模块，用于验证读写时序和数据一致性。模块采用状态机控制读写操作，避免同时读写同一地址导致错误。提供了状态转换图、代码实现细节和仿真测试结果，证明了模块设计的正确性。
AXI协议(三)-AXI-FULL概述及传输事务
今日你学左米啊
06-05 3313
AXI协议(三)-AXI-FULL概述及传输事务 在本文中，你将可能学会： AXI-FULL协议的梗概 AXI-Full一次传输业务的过程 由于AXI协议的复杂,下面的内容可能在后面才会介绍到: 乱序和穿插机制(包括ID) 锁定（lock）和独占(exclusive)机制 缓存(cache和buffer)机制 QOS和REGION机制 本文会专注于传输,上面的会专开别的文章介绍,下称AXI-Full为AXI 由于篇幅关系，代码会放在下一篇 文章目录AXI协议(三)-AXI-FULL概述及传输事务A
FPGA实现 NIC 10G 网卡，纯verilog代码编写，提供3套工程源码和技术支持
qq_41667729的博客
07-31 4466
FPGA实现NIC 10G UDP协议栈网卡，纯verilog代码编写，提供工程源码和技术支持 本设计是一个10G速率的网卡，Xilinx Virtex-7 xc7vx690t调用Virtex-7 FPGA Gen3 Integrated Block for PCI Express IP核实现FPGA网卡与电脑主机的数据交互，PCIE配有纯verilog编写的DMA控制器实现PCIE数据的搬运工作；调用10G Ethernet PCS/PMA (10GBASE-R/KR) GTH资源实现FPGA网卡与其他网
Axi协议和verilog实现3-axi的verilog实现
m0_46407447的博客
12-14 3186
AXI协议及其verilog实现
逐行解析AXI4_FULL IP核
justdoix的博客
12-20 687
对xilinx中的AXI4_FULL IP核RTL代码进行逐行解析
用verilog写一个FIFO转AXI-Stream的代码
05-23
以下是一个简单的FIFO转AXI-Stream的Verilog代码： ``` module fifo_to_axi_stream ( input clk, input rst, input [31:0] data_in, input wr_en, output [31:0] data_out, output axi_tvalid, output axi_tlast, output axi_tready ); // AXI-Stream interface signals reg [31:0] axi_data; reg axi_tvalid; reg axi_tlast; wire axi_tready; // FIFO signals reg [31:0] fifo [0:7]; reg [2:0] rd_ptr = 0; reg [2:0] wr_ptr = 0; reg [2:0] count = 0; reg full = 0; reg empty = 1; // Write data to FIFO always @(posedge clk) begin if (rst) begin wr_ptr <= 0; count <= 0; full <= 0; empty <= 1; end else if (wr_en && !full) begin fifo[wr_ptr] <= data_in; wr_ptr <= wr_ptr + 1; count <= count + 1; full <= (count == 8); empty <= 0; end end // Read data from FIFO and send to AXI-Stream always @(posedge clk) begin if (rst) begin rd_ptr <= 0; axi_data <= 0; axi_tvalid <= 0; axi_tlast <= 0; end else if (!empty && axi_tready) begin axi_data <= fifo[rd_ptr]; rd_ptr <= rd_ptr + 1; count <= count - 1; full <= 0; empty <= (count == 0); axi_tvalid <= 1; axi_tlast <= (count == 1); end else begin axi_tvalid <= 0; axi_tlast <= 0; end end // Assign output signals assign data_out = axi_data; assign axi_tready = 1; endmodule ``` 在这个模块中，我们使用了一个8个元素的FIFO，以将输入数据从一个时钟域传递到另一个时钟域。输入数据通过`data_in`信号传递，并且在`wr_en`信号为高电平时写入FIFO。输出数据通过`data_out`信号传递，以便在AXI-Stream时钟域中使用。 AXI-Stream接口由三个信号组成：数据信号(axi_data)，有效标志(axi_tvalid)和末尾标志(axi_tlast)。在本例中，我们使用一个简单的流水线协议，其中我们在每个时钟周期中传输一个32位数据。有效标志表示当前传输的数据是否有效，末尾标志表示当前传输的数据是否为流的最后一个数据。在本例中，我们使用FIFO中的数据计数来确定何时传输最后一个数据。 请注意，我们使用了同步复位信号(rst)来确保在系统启动时所有信号都处于已知状态。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值