外部master模块通过AXI FULL接口直接读取DDR数据

最新推荐文章于 2024-07-27 11:55:31 发布
最新推荐文章于 2024-07-27 11:55:31 发布
阅读量2.1k 收藏 26
点赞数 4
文章标签： fpga verilog ddr
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quhai1340/article/details/109765089
版权

FPGA逻辑开发中，访问PS DDR资源的方式很多，除DMA操作外，也可直接通过外部AXI FULL master进行数据搬移。
下面先附上一个网上很常见的master代码，注：该代码非本人原创，非本人原创，非本人原创

module master(
  // Reset, Clock
  input           ARESETN,
  input           ACLK,
  // Master 鍐欏湴鍧�閫氶亾
  output [0:0] M_AXI_AWID,
  output [31:0] M_AXI_AWADDR,
  output [7:0] M_AXI_AWLEN,    // Burst Length:0-255
  output [2:0] M_AXI_AWSIZE,   // Burst Size:Fixed 2'b011
  output [1:0] M_AXI_AWBURST,  // Burst Type:Fixed 2'b01(Incremental Burst)
  output       M_AXI_AWLOCK,   // Lock: Fixed2'b00
  output [3:0] M_AXI_AWCACHE,  // Cache: Fiex2'b0011
  output [2:0] M_AXI_AWPROT,   // Protect: Fixed2'b000
  output [3:0] M_AXI_AWQOS,    // QoS: Fixed2'b0000
  output [0:0] M_AXI_AWUSER,   // User: Fixed32'd0
  output       M_AXI_AWVALID,
  input        M_AXI_AWREADY,
  // Master 鍐欐暟鎹�氶亾
  output [63:0] M_AXI_WDATA,
  output [7:0] M_AXI_WSTRB,
  output       M_AXI_WLAST,
  output [0:0] M_AXI_WUSER,
  output       M_AXI_WVALID,
  input        M_AXI_WREADY,
  // Master 鍐欏搷搴旈�氶亾
  input [0:0]  M_AXI_BID,
  input [1:0]  M_AXI_BRESP,
  input [0:0]  M_AXI_BUSER,
  input        M_AXI_BVALID,
  output       M_AXI_BREADY,
  // Master 璇诲湴鍧�閫氶亾
  output [0:0] M_AXI_ARID,
  output [31:0] M_AXI_ARADDR,
  output [7:0] M_AXI_ARLEN,
  output [2:0] M_AXI_ARSIZE,
  output [1:0] M_AXI_ARBURST,
  output [1:0] M_AXI_ARLOCK,
  output [3:0] M_AXI_ARCACHE,
  output [2:0] M_AXI_ARPROT,
  output [3:0] M_AXI_ARQOS,
  output [0:0] M_AXI_ARUSER,
  output       M_AXI_ARVALID,
  input        M_AXI_ARREADY,
  // Master 璇绘暟鎹�氶亾
  input [0:0]  M_AXI_RID,
  input [63:0] M_AXI_RDATA,
  input [1:0]  M_AXI_RRESP,
  input        M_AXI_RLAST,
  input [0:0]  M_AXI_RUSER,
  input        M_AXI_RVALID,
  output       M_AXI_RREADY,
  // Local Bus
  input        MASTER_RST,
  input        WR_START,
  input [31:0] WR_ADRS,
  input [31:0] WR_LEN,
  output       WR_READY,
  output       WR_FIFO_RE,
  input        WR_FIFO_EMPTY,
  input        WR_FIFO_AEMPTY,
  input [63:0] WR_FIFO_DATA,
  output       WR_DONE,
  input        RD_START,
  input [31:0] RD_ADRS,
  input [31:0] RD_LEN,
  output       RD_READY,
  output       RD_FIFO_WE,
  input        RD_FIFO_FULL,
  input        RD_FIFO_AFULL,
  output [63:0] RD_FIFO_DATA,
  output       RD_DONE,
  output [31:0] DEBUG
);
  localparam S_WR_IDLE  = 3'd0;
  localparam S_WA_WAIT  = 3'd1;
  localparam S_WA_START = 3'd2;
  localparam S_WD_WAIT  = 3'd3;
  localparam S_WD_PROC  = 3'd4;
  localparam S_WR_WAIT  = 3'd5;
  localparam S_WR_DONE  = 3'd6;
  reg [2:0]  wr_state;
  reg [31:0] reg_wr_adrs;
  reg [31:0] reg_wr_len;
  reg        reg_awvalid, reg_wvalid, reg_w_last;
  reg [7:0]  reg_w_len;
  reg [7:0]  reg_w_stb;
  reg [1:0]  reg_wr_status;
  reg [3:0]  reg_w_count, reg_r_count;
  reg [7:0]  rd_chkdata, wr_chkdata;
  reg [1:0]  resp;
  reg rd_first_data;
  reg rd_fifo_enable;
  reg[31:0] rd_fifo_cnt;
assign WR_DONE =(wr_state == S_WR_DONE);
assign WR_FIFO_RE         = rd_first_data |(reg_wvalid & ~WR_FIFO_EMPTY & M_AXI_WREADY & rd_fifo_enable);
always @(posedge ACLK or negedge ARESETN)
begin
      if(!ARESETN)
             rd_fifo_cnt <= 32'd0;
      else if(WR_FIFO_RE)
             rd_fifo_cnt <= rd_fifo_cnt +32'd1;
      else if(wr_state == S_WR_IDLE)
             rd_fifo_cnt <= 32'd0;
end
always @(posedge ACLK or negedge ARESETN)
begin
      if(!ARESETN)
             rd_fifo_enable <= 1'b0;
      else if(wr_state == S_WR_IDLE &&WR_START)
             rd_fifo_enable <= 1'b1;
      else if(WR_FIFO_RE && (rd_fifo_cnt== RD_LEN[31:3] - 32'd1) )
             rd_fifo_enable <= 1'b0;          
end
  // Write State
  always @(posedge ACLK or negedge ARESETN)begin
    if(!ARESETN) begin
      wr_state            <= S_WR_IDLE;
      reg_wr_adrs[31:0]   <= 32'd0;
      reg_wr_len[31:0]    <= 32'd0;
      reg_awvalid         <= 1'b0;
      reg_wvalid          <= 1'b0;
      reg_w_last          <= 1'b0;
      reg_w_len[7:0]      <= 8'd0;
      reg_w_stb[7:0]      <= 8'd0;
      reg_wr_status[1:0]  <= 2'd0;
      reg_w_count[3:0]    <= 4'd0;
      reg_r_count[3:0]  <= 4'd0;
      wr_chkdata          <= 8'd0;
      rd_chkdata <= 8'd0;
      resp <= 2'd0;
       rd_first_data <= 1'b0;
  end else begin
    if(MASTER_RST) begin
      wr_state <= S_WR_IDLE;
    end else begin
      case(wr_state)
        S_WR_IDLE: begin
          if(WR_START) begin              //澶栭儴寮�濮嬪啓鍦板潃
            wr_state          <= S_WA_WAIT;
            reg_wr_adrs[31:0] <=WR_ADRS[31:0];//鍐欏湴鍧�
            reg_wr_len[31:0]  <= WR_LEN[31:0] -32'd1;//鍐欓暱搴�
                    rd_first_data <= 1'b1;
          end
          reg_awvalid         <= 1'b0;
          reg_wvalid          <= 1'b0;
          reg_w_last          <= 1'b0;
          reg_w_len[7:0]      <= 8'd0;
          reg_w_stb[7:0]      <= 8'd0;
          reg_wr_status[1:0]  <= 2'd0;
        end
             //鍐欏湴鍧�绛夊緟
        S_WA_WAIT: begin
                    //澶栭儴FIFO涓嶇┖鎴栬�呴暱搴︿负0鍒欏紑濮嬪啓鍦板潃
          if(!WR_FIFO_AEMPTY |(reg_wr_len[31:11] == 21'd0)) begin
            wr_state          <= S_WA_START;
          end
              rd_first_data <= 1'b0;
        end
             //鍐欏湴鍧�寮�濮�
        S_WA_START: begin
          wr_state            <= S_WD_WAIT;//鍐欐暟鎹瓑寰�
          reg_awvalid         <= 1'b1;
              //鍐欓暱搴﹀噺涓�
          reg_wr_len[31:11]    <= reg_wr_len[31:11] - 21'd1;
          if(reg_wr_len[31:11] != 21'd0) begin
            reg_w_len[7:0]  <= 8'hFF;//姣忔鍐�256涓暟鎹�
            reg_w_last      <= 1'b0;
            reg_w_stb[7:0]  <= 8'hFF;
          end else begin//鏈�鍚庝笉瓒�256涓殑鏁版嵁鍐欏叆
            reg_w_len[7:0]  <= reg_wr_len[10:3];
            reg_w_last      <= 1'b1;
            reg_w_stb[7:0]  <= 8'hFF;
          end
        end
        S_WD_WAIT: begin
             //绛夊緟鍐欐�荤嚎READY锛岃繘鍏ュ啓鏁版嵁鐘舵��
          if(M_AXI_AWREADY) begin
            wr_state        <= S_WD_PROC;
            reg_awvalid     <= 1'b0;
                    //寮�濮嬪啓鏁版嵁
            reg_wvalid      <= 1'b1;
          end
        end
             //鍐欐暟鎹�
        S_WD_PROC: begin
          if(M_AXI_WREADY & ~WR_FIFO_EMPTY)begin
              //涓�娆＄獊鍙戝啓瀹屾垚
            if(reg_w_len[7:0] == 8'd0) begin
              wr_state        <= S_WR_WAIT;
              reg_wvalid      <= 1'b0;
              reg_w_stb[7:0]  <= 8'h00;
            end else begin
              reg_w_len[7:0]  <= reg_w_len[7:0] -8'd1;
            end
          end
        end
             //鍐欑瓑寰�
        S_WR_WAIT: begin
                    //鍐欏搷搴斿畬鎴�
          if(M_AXI_BVALID) begin
            reg_wr_status[1:0]  <= reg_wr_status[1:0] | M_AXI_BRESP[1:0];
            if(reg_w_last) begin//鍐欏畬鎴�
              wr_state          <= S_WR_DONE;
            end else begin//鍐欐湭瀹屾垚
              wr_state          <= S_WA_WAIT;
                      //鍦板潃姣忔閫掑
              reg_wr_adrs[31:0] <=reg_wr_adrs[31:0] + 32'd2048;
            end
          end
        end
        S_WR_DONE: begin
            wr_state <= S_WR_IDLE;
          end
        default: begin
          wr_state <= S_WR_IDLE;
        end
      endcase
      end
    end
  end
  assign M_AXI_AWID         = 1'b0;
  assign M_AXI_AWADDR[31:0] =reg_wr_adrs[31:0];
  assign M_AXI_AWLEN[7:0]   = reg_w_len[7:0];
  assign M_AXI_AWSIZE[2:0]  = 2'b011;
  assign M_AXI_AWBURST[1:0] = 2'b01;
  assign M_AXI_AWLOCK       = 1'b0;
  assign M_AXI_AWCACHE[3:0] = 4'b0011;
  assign M_AXI_AWPROT[2:0]  = 3'b000;
  assign M_AXI_AWQOS[3:0]   = 4'b0000;
  assign M_AXI_AWUSER[0]    = 1'b1;
  assign M_AXI_AWVALID      = reg_awvalid;
  assign M_AXI_WDATA[63:0]  = WR_FIFO_DATA[63:0];
  assign M_AXI_WSTRB[7:0]   = (reg_wvalid & ~WR_FIFO_EMPTY)?8'hFF:8'h00;
  assign M_AXI_WLAST        = (reg_w_len[7:0] == 8'd0)?1'b1:1'b0;
  assign M_AXI_WUSER        = 1;
  assign M_AXI_WVALID       = reg_wvalid & ~WR_FIFO_EMPTY;
  assign M_AXI_BREADY       = M_AXI_BVALID;
  assign WR_READY           = (wr_state == S_WR_IDLE)?1'b1:1'b0;
  localparam S_RD_IDLE  = 3'd0;
  localparam S_RA_WAIT  = 3'd1;
  localparam S_RA_START = 3'd2;
  localparam S_RD_WAIT  = 3'd3;
  localparam S_RD_PROC  = 3'd4;
  localparam S_RD_DONE  = 3'd5;
  reg [2:0]  rd_state;
  reg[31:0]  reg_rd_adrs;
  reg [31:0] reg_rd_len;
  reg        reg_arvalid, reg_r_last;
  reg [7:0]  reg_r_len;
 assign RD_DONE = (rd_state == S_RD_DONE) ;
  // Read State
  always @(posedge ACLK or negedge ARESETN)begin
    if(!ARESETN) begin
      rd_state          <= S_RD_IDLE;
      reg_rd_adrs[31:0] <= 32'd0;
      reg_rd_len[31:0]  <= 32'd0;
      reg_arvalid       <= 1'b0;
      reg_r_len[7:0]    <= 8'd0;
    end else begin
      case(rd_state)
        S_RD_IDLE: begin
             //璇诲紑濮�
          if(RD_START) begin
            rd_state          <= S_RA_WAIT;
            reg_rd_adrs[31:0] <=RD_ADRS[31:0];
            reg_rd_len[31:0]  <= RD_LEN[31:0] -32'd1;
          end
          reg_arvalid     <= 1'b0;
          reg_r_len[7:0]  <= 8'd0;
        end
             //璇婚�氶亾绛夊緟
        S_RA_WAIT: begin
          if(~RD_FIFO_AFULL) begin
            rd_state          <= S_RA_START;
          end
        end
             //璇诲湴鍧�寮�濮�
        S_RA_START: begin
          rd_state          <= S_RD_WAIT;
          reg_arvalid       <= 1'b1;
          reg_rd_len[31:11] <=reg_rd_len[31:11] -21'd1;
          if(reg_rd_len[31:11] != 21'd0) begin
            reg_r_last      <= 1'b0;
            reg_r_len[7:0]  <= 8'd255;
          end else begin
            reg_r_last      <= 1'b1;
            reg_r_len[7:0]  <= reg_rd_len[10:3];
          end
        end
             //璇绘暟鎹瓑寰�
        S_RD_WAIT: begin
          if(M_AXI_ARREADY) begin
            rd_state        <= S_RD_PROC;
            reg_arvalid     <= 1'b0;
          end
        end
             //璇绘暟鎹紑濮�
        S_RD_PROC: begin
          if(M_AXI_RVALID) begin
            if(M_AXI_RLAST) begin
              if(reg_r_last) begin
                rd_state          <= S_RD_DONE;
              end else begin
                rd_state          <= S_RA_WAIT;
                reg_rd_adrs[31:0] <=reg_rd_adrs[31:0] + 32'd2048;
              end
            end else begin
              reg_r_len[7:0] <=reg_r_len[7:0] -8'd1;
            end
          end
        end
             S_RD_DONE:begin
                    rd_state          <= S_RD_IDLE;
             end
       endcase
    end
  end
  // Master Read Address
  assign M_AXI_ARID         = 1'b0;
  assign M_AXI_ARADDR[31:0] =reg_rd_adrs[31:0];
  assign M_AXI_ARLEN[7:0]   = reg_r_len[7:0];
  assign M_AXI_ARSIZE[2:0]  = 3'b011;
  assign M_AXI_ARBURST[1:0] = 2'b01;
  assign M_AXI_ARLOCK       = 1'b0;
  assign M_AXI_ARCACHE[3:0] = 4'b0011;
  assign M_AXI_ARPROT[2:0]  = 3'b000;
  assign M_AXI_ARQOS[3:0]   = 4'b0000;
  assign M_AXI_ARUSER[0]    = 1'b1;
  assign M_AXI_ARVALID      = reg_arvalid;
  assign M_AXI_RREADY       = M_AXI_RVALID & ~RD_FIFO_FULL;
  assign RD_READY           = (rd_state == S_RD_IDLE)?1'b1:1'b0;
  assign RD_FIFO_WE         = M_AXI_RVALID;
  assign RD_FIFO_DATA[63:0] = M_AXI_RDATA[63:0];
  assign DEBUG[31:0] = {reg_wr_len[31:8],
                        1'd0, wr_state[2:0],1'd0, rd_state[2:0]};
endmodule

在这里插入图片描述在这里插入图片描述

上图以写入2KB连续自然数进行行为仿真，可以发现在每次传输过程中，实际只写入了127个时钟周期的数据，而剩下的一位数据在地址信息发生偏移后才拉高valid。以写入1KB数据进行仿真结果如下：
在这里插入图片描述
乍一看时序似乎没有什么问题，但仔细观察发现，valid信号在last信号拉高的同时拉低了：
在这里插入图片描述
也就是这1KB的数据传输并没有正确写入DDR。

修改方案
经过对代码的研读，主要问题由代码中的 WR_FIFO_EMPTY信号造成，有兴趣的同学可以自行研究一下代码，这里直接给出修改方案：
将该信号后打一拍：

reg WR_FIFO_EMPTY_d1;
always @(posedge ACLK)
    begin
    WR_FIFO_EMPTY_d1 <= WR_FIFO_EMPTY; 
    end

替换原代码中采用 WR_FIFO_EMPTY做条件判断的部分为 WR_FIFO_EMPTY_d1

修改后仿真时序如下：
在这里插入图片描述
可以看到末位数据正确传输（仿真数据为0-127 64bit位宽的递增数）：
在这里插入图片描述
硬件ila核实测：
在这里插入图片描述

Fin

以上为个人对该代码的一些修改建议，可以根据思路自行进行代码修改，这里也附上修改后测试通过的版本链接 AXI master接口访问PS数据，还是建议多思考，共同进步。

Riwuarua
关注
详解AXI4-Full接口（3）--AXI4-Full接口IP源码仿真及分析（Master接口）
孤独的单刀
11-29 7179
通过本文您会学到：1、了解AXI4-Full的master接口；2、加深Xilinx的IP、仿真工具的使用；3、学习Xilinx的优秀源码。
ZYNQ使用AXI4-HP接口总线读取DDR中的数据
qq_24025329的博客
11-15 3382
最近笔者在做项目的时候需要使用zynq中的AXI4-HP总线在PL端读取DDR中的数据这种功能，但是网上很多历程对于这方面只是创建了一个官方提供的IP核用于测试，并且每次写入和读取的长度为4K字节。所以为了满足我自己的项目需求，笔者将官方提供的测试IP核上做修改，主要实现一下功能： 1、上升沿使能读取数据。 2、读使能后，IP核需要从基地址开始，突发读取X次（X数量可控） 3、内置一个同步FIFO将读出的数据暂存在FIFO中。
ZYNQ之路--Xilinx AXI-Full-Master实例代码翻译
weixin_54358182的博客
10-02 2523
在我学习过程中遇到了第一个认知上的门槛：AXI协议。试想一个场景：我PL端的IP要通过AXI-Full协议给PS端传输数据，我该怎么做？首先肯定是创建一个带有AXI-Full-Matser的接口下一步，Xilinx官方会给我们一个接口的实例文件：顶层是一个对外的接口，而内层的代码则是AXI-Full-Master接口的协议实现。当然了，我们肯定是要通过改动这个文件来将我们自己的IP和AXI接口协议相结合，因此我们有必要读懂AXI-Full-Master的代码内容。
AXI总线
最新发布
小瑞同学的博客
07-27 1206
摘要:AXI总线学习笔记
axi_full.zip
10-11
AXI-full总线主从仿真源码+时序图.可以直接加入vivado进行仿真、测试
zedboard如何从PL端控制DDR读写(三)——AXI-FULL总线调试
weixin_34247032的博客
07-18 1004
zedboard如何从PL端控制DDR读写(三)——AXI-FULL总线调试 　　之前的项目和培训中，都只用到了AXI-Lite或者AXI-Stream，对于AXI-FULL知之甚少，主要是每次一看到那么多接口信号就望而却步了。 　　现在为了调试DDR，痛下决心要把AXI-FULL弄懂。 　　前面已经介绍了基本的接口信号，本文主要是总结一下...
手撕AXI-Full总线接口，实现AXI_Full Master接口
modest_cat的博客
05-07 1879
基于Xlinx 的AXI4_Full手撕AXI_Full Master接口，采用Verilog实现，支持1~256的Burst_len，并对设计进行仿真验证。
Avalon-MM Master Templates---READ应用：显示DDR2中的图片
weixin_34361881的博客
07-30 530
本文通过Avalon-MM Master Templates实现读取ddr2中的图像数据(800*480*16bit)，然后通过TFT 5.0寸LCD显示出来。本文旨在阐述清楚思路以及记录自己在实现过程中的一些经验。 需要知识：NIOS + Verilog + 工具[Qsys]。 一.效果展示： 二.结构说明： 通过master_read 连接到ddr2，直接读取dd...
AXI4-FULL发送数据正确，但存储器中的存储数据不正确
qq_38606712的博客
01-10 388
今天自己编写了一个AXI4-FULL模块来发送自己的数据，仿真结果发现wdata,wvalid,wready等信号正常，是我想发送的数据序列。但从存储到的RAM中读取时，数据是间隔存在的。即我发送的信号序列是1,2，3,4.....78,79,80，一共80个数据，但读取时却是1,3,5,7......77,79。通过使用modelSim仿真查看存储的RAM,我发现，虽然我发送的信号序列是1,2，3,4.....78,79,80。但RAM中存储的数据却是1,3,5,7......77,79。 经过一番仔细查
自定义AXI接口DDR读写模块实现PS数据与PL数据交互
weixin_61016725的博客
06-03 822
自定义带AXI接口的IP核
详解AXI4-Full接口（2）--AXI4-Full接口IP源码仿真及分析（Slave接口）
孤独的单刀
11-28 6483
通过本文您会学到：1、了解AXI4-Full的slave接口；2、加深Xilinx的IP、仿真工具的使用；3、学习Xilinx的优秀源码。
AXI master接口读取PS DDR
11-18
文件为PL侧读写PS交互的工程代码，外部为读写FIFO接口，可通过设置读取地址，长度等信息搬运PS侧数据至PL FIFO，方便后续数据处理操作，转stream协议格式等
【Xilinx AX7103 MicroBalze学习笔记7】MicroBlaze AXI4 接口之 DDR 读写实验
记录学习历程
07-15 2319
这次的实验依然是基于之前的HelloWorld工程，将HelloWorld另存为新的工程并重新命名。将此工程封装成一个带有AXI4接口的IP，在菜单栏中点击“Tools”，然后在下拉列表中选择“CreateandPackageNewIP”按照提示选择next，在下图此界面选择带有AXI4接口的IP封装方式。在下图界面中，将IP的命名并设定其保存路径，注意路径不宜设置过长。设置接口的名称M_AXI；接口类型Full，使用的是满AXI4的接口；.........
FPGA-基于AXI4接口的DDR3读写顶层模块
qq_45248833的博客
11-08 1891
AXI4（Advancede Xtensible Interface 4）是一种高性能、高带宽的总线接口协议，用于在系统级芯片设计中连接不同的IP核（Intellectual Property）或模块。它是由ARM公司开发的，被广泛应用于各种SoC（System-on-Chip）设计中。AXI4接口协议定义了一组规范，用于描述数据传输、地址传输、控制信号和时序等方面的要求。它提供了一种灵活的、可扩展的接口，支持高性能和低功耗的系统设计。灵活性：AXI4接口支持多种传输模式，包括单个传输、突发传输和流传输。
AXI4_full协议详解
guoweilkd的博客
10-11 1万+
AXI4-full协议介绍 AXI4.0-full包含突发控制信号，所以可以进行突发传输，在只指定一次地址后，可以一次传输多达256个数据(数据的宽度取决于带宽)。主要用于往DDR或者OCM中写入大量数据时使用。 信号线详细描述 下面信号包含五个通道的所有信号。其中每个通道都有其自己的双向握手机制信号线xxVALID和xxREADY，这俩信号线的介绍，详见AXI总线介绍。 全局信号 ACLK ...
Xilinx AXI4 协议
Go Forward Forever!
01-07 3000
AXI4 所采用的是一种 READY，VALID 握手通信机制，即主从模块进行数据通信前，先根 据操作对各所用到的数据、地址通道进行握手。主要操作包括传输发送者 A 等到传输接受者 B 的 READY 信号后，A 将数据与 VALID 信号同时发送给 B，这是一种典型的握手机制。
ZYNQ进阶之路12--自定义AXI-FULL IP实现PL端向DDR3写数据和PS端实现高速通讯
热门推荐
WP_FD的博客
04-27 1万+
ZYNQ进阶之路12--自定义AXI-FULL IP实现PL端向DDR3写数据和PS端实现高速通讯导语配置PS端新建工程按照如下步骤配置PS端自定义AXI-FULL IP自定义AXI-Lite Slave 代码，加入之前章节中我们使用的串口接收模块修改AXI-FULL Master代码修改IP顶层代码添加AXI 互联模块，完成Block Design生成bit文件，导入SDK，开始软件编程下载到平...
ZYNQ AXI4(AXI-full)总线学习（一）三种AXI总线以及AXI-full总线端口总结
宏强-Blog
03-02 5615
1.简述 这儿遇到到ps端与pl端大量实时数据交互问题，实验了axi-lite总线，发现不行，实在太慢。接下来就只有axi-full总线了，但是这个好像比较复杂，所以先认真学习一下。
AXI_DMA协议——手写握手协议读取DDR中数据
weixin_42036328的博客
03-02 6643
文章目录前言一、AXI接口类型有哪些？有什么区别？二、二、使用步骤1.引入库2.读入数据总结 前言 PL（FPGA）从PS(ARM)端DDR处读数据，使用zynq7平台，读数据采用AXI-full接口，握手协议以及异步FIFO处理均设涉及。有助于您了解AXI接口、AXI_DMA读数据操作、异步FIFO的使用。 一、AXI接口类型有哪些？有什么区别？ AXI 全称是Advance eXtensible Interface 的缩写，是一种面向高性能、高带宽、低延迟的片内总线。主要分为三个类型接口：AXI.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值