ZYNQ之AXI总线

LittleNoob2025

已于 2025-04-28 22:07:01 修改

阅读量990

点赞数 21

CC 4.0 BY-SA版权

分类专栏： # ZYNQ 笔记文章标签：笔记 fpga

于 2024-05-10 14:29:14 首次发布

本文链接：https://blog.csdn.net/weixin_45872608/article/details/133634676

ZYNQ 笔记专栏收录该内容

1 篇文章

订阅专栏

什么是AXI？

AXI (高级拓展接口)是ARM公司推出的一种总线协议,xilinx公司从6系列的FPGA开始使用AXI总线协议。

什么是总线？什么是接口？什么是协议？

总线、接口、协议经常被一起使用。但是是不同的概念。
总线：一台电脑由多个电子元器件组成，如CPU，内存，硬盘等，各元器件之间往往需要相互传递数据。数据传输的公用通道，就是总线
协议：是网络协议的简称，是数据传递双方共同遵循的一种规定、准则。
接口：是一种看得见、摸得着的物理接口。如USB接口、RS232接口、HDMI接口等等

AXI总线介绍和接口介绍

ZYNQ支持三种AXI总线，拥有三种AXI接口、但都是用的AXI协议。
总线分别是：AXI4总线、AXI4-lite总线、AXI-Stream总线。
接口分别是：AXI-GP接口、AXI-HP接口、AXI-ACP接口。

接口如下
在这里插入图片描述

AXI-GP接口（4个）：是通用的AXI接口，包括两个32位主设备接口和两个32位从设备接口，使用该接口可以访问PS的片内外设。
AXI-HP接口（4个）：是高性能/高带宽的标准的接口，PL模块作为主设备连接，主要用于从PL访问PS上的存储器（DDR和片上RAM）
AXI-ACP接口（1个）：是ARM多核架构下定义的一种接口，用来管理DMA之类的不带缓存的AXI外设，PS端slave接口。

AXI4:适用于内存映射接口，并且仅使用一个地址阶段就允许高达256个数据传输周期的高吞吐量爆发。
AXI4-Lite:是一个轻量级的单事务内存映射接口。它具有很小的逻辑占用空间，并且在设计和使用方面都是一个简单的接口。（不懂）

AXI协议的介绍

协议和总线关系密切，没有总线如何能制定协议？因此协议要在总线的结构上制定。AXI4、AXI-LITE、AXI-Stream协议都是在AXI总线上制定的。

AXI总线协议的两端可以分为主（master）、从（slave）两端。他们之间通过一个AXI Interconnect 相互联。AXI interconnect 的作用是提供一个或多个AXI主设备和一个或者多个从设备的一种交换机制。

AXI interconnect 的主要作用是：当存在多个主机以及从机器时，axi interconnect 负责将他们联系并管理起来。由于AXI 支持乱序发送，乱序发送需要主机的ID信号支撑，而不同的主机发送的ID可能相同，AXI interconnect 会对主机的ID进行处理，让它们变成不唯一。

AXI协议之握手协议

AXI4 所采用的时一种READY VlAID握手通信机制。一般主从双方通信之前，需要进行一次握手。传输源产生VLAID信号指明何时数据或控制信息有效。目的源产生READY信号指明已经准备好接收数据或控制信息。传输发送在VALID和READY信号同时为高的时候。
VALID 和 READY信号出现的形式可能有三种情况：
在这里插入图片描述

需要强调的是：AXI的五个通道读地址信号、读数据信号、写地址信号、写数据信号、写响应信号都有上面的这种握手机制。

突发性读写

突发性读

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

突发性写

在这里插入图片描述

AXI 接口读写实验

自定义一个AXI ip核，我们向地址写入数据，然后用逻辑分析仪观测。
在这里插入图片描述
自定义IP核的外部端口 自定义IP核的顶层模块端口

程序的always块里面仅含有：
PS向AXI写入数据时：在这里插入图片描述

axi_awready：写地址准备
复位下为0，aw_en=1
当axi_awready =0 ,aw_en=1,且AWVALID 和WVALID=1。axi_awready=1
当BREADY 和bvalid=1，则axi_awready,aw_en回到复位状态
否则axi_ready=0

axi_awaddr:写地址
复位下为0，
当axi_awready=0,aw_en=1,且AWVALID 和WVALID =1。axi_awaddr 获取AWADDR

axi-wready：写准备
复位下为0，
当axi_wready=0,aw_en=1,且AWVALID 和WVALID =1。axi_wready =1
否则axi_wready=0;

slv_reg_wren = axi_wready axi_awready WVALID AWVALID
slv_reg 接收 S_AXI_DATA

bvalid 和 bresp 信号
复位下，bvalid 和 bresp 都0
axi_awready=1,bvalid=0,wready=1,AWVALID=1 ,WVALID=1 . 则bvalid=1,bresp=2’b0;
BREADY = 1和bvalid=1 则 bvalid = 1

aready 和 araddr
复位下，aready 和 araddr 为0
当axi_aready=0 ARVALID =1 ,

AXI接口之DDR读写实验

实验任务

通过自定义一个AXI4接口的IP核心，通过HP接口对PS端的DDR进行读写测试。有个小问题，为什么用的是HP接口？HP接口时zynq里面PL端模块作为主设备，访问PS端的从设备（DDR和片上RAM）。
在这里插入图片描述

在这里插入图片描述

input wire INIT_AXI_TXN，//初始化AXI事务
init_tx_pulse;//是抓取 INIT_AXI_TXN的上升沿信号
当init_tx_pulse有效时，进入写地址状态机
init_txn_p//

概述

zynq拥有FPGA + ARM 架构，ARM和FPGA通过AXI4总线通信。

1.AXI总线和AXI接口

ZYNQ支持AXI-Lite、AXI4、AXI4-Stream三种总线协议。PL和PS接口（AXI-GP、AXI-HP、 AXI-ACP接口）只支持AXI-Lite 和AXI4协议这两种总线协议。PL这边的AXI-Stream接口不能直接与PS对接，需要AXI4或者AXI4-Lite转换.

存储映射（memory map）概念:如果一个协议用来存储映射的，那么主机所发出的会话内容里面会含有一个地址信息（无论读写）。这个地址信息对应系统存储空间中的一个地址，表明针对存储空间的读写操作。

1.1AXI总线、AXI接口和AXI协议

总线：是一组传输通道，是各种逻辑器件构成传输数据的通道，如数据线、地址线，控制线。
接口：是一种连接标准。
协议：是传输数据的规则。

1.2AXI总线介绍

AXI4:面向高性能地址映射通信的需求，是面向地址映射的接口
AXI4_lite：是轻量级的地址映射单次传输接口，占用很少的逻辑单元
AXI_Stream：面向高速流数据传输；允许无限制的数据突发传输规模。

1.3AXI接口介绍

三种接口如下
AXI-GP接口（4个）：是通用的AXI接口，包括两个32位主设备接口和两个32位从设备接口，使用该接口可以访问PS的片内外设。
AXI-HP接口（4个）：是高性能/高带宽的标准的接口，PL模块作为主设备连接，主要用于PL访问PS上的存储器（DDR和片上RAM）
AXI-ACP接口（1个）：是ARM多核架构下定义的一种接口，用来管理DMA之类的不带缓存的AXI外设，PS端slave接口。
在这里插入图片描述

1.4AXI协议介绍

协议要在总线的结构上才能制定。AXI总线协议的两端分为主设备、从设备。两个之间是用AXI Interconnect相连接。

AXI interconnect 作用是：有多个主机或者多个从机的时候，这个AXI interconnect将它们连接起来。

1.5AXI协议之握手协议

握手协议
传输源产生vlaid信号指明数据什么时候有效
目的源产生ready信号指明准备好开始接收数据
在这里插入图片描述

1.6突发式读写

突发式读
在这里插入图片描述
突发式写

1.7AXI的优点

AXI 架构

AXI 协议是基于突发性的，并定义了以下独立事务通道。

在这里插入图片描述

地址通道携带描述要传输的数据性质的控制信息。

代码分析axi_lite.v


`timescale 1 ns / 1 ps

	module gpio_lite_ml_v1_0_S00_AXI #
	(
		// Users to add parameters here

		// User parameters ends
		// Do not modify the parameters beyond this line

		// Width of S_AXI data bus
		parameter integer C_S_AXI_DATA_WIDTH	= 32,//数据的宽度
		// Width of S_AXI address bus
		parameter integer C_S_AXI_ADDR_WIDTH	= 4 //地址的宽度
	)
	(
		/*****************************在这里增加端口***************************/
		// Users to add ports here

		// User ports ends
		/*****************************在这里增加端口***************************/

		// Do not modify the ports beyond this line

		// 全局时钟信号
		input wire  S_AXI_ACLK,
		input wire  S_AXI_ARESETN,

		/*****************写地址通道****************/
		input wire [C_S_AXI_ADDR_WIDTH-1 : 0] S_AXI_AWADDR, //写地址通道
		input wire [2 : 0] S_AXI_AWPROT,				    //写通道保护类型
		input wire  S_AXI_AWVALID,							//写地址有效
		output wire  S_AXI_AWREADY,							//写地址准备

        /****************写数据通道***************/
		input wire [C_S_AXI_DATA_WIDTH-1 : 0] S_AXI_WDATA, 		//写数据通道
		input wire [(C_S_AXI_DATA_WIDTH/8)-1 : 0] S_AXI_WSTRB,	//写选通通道：这个信号表明该字节通道持有效数据
		output wire  S_AXI_WREADY,								//写准备通道：这个信号只是从器件可以接受写数据了
		
		output wire [1 : 0] S_AXI_BRESP,						//写响应通道：这个信号表示写事务处理的状态
		output wire  S_AXI_BVALID,  						    //写响应有效：此信号表明写命令的有效写入响应
		input wire  S_AXI_BREADY,							    //写响应准备：该信号指示在主主机上可以接受一个响应信号


		input wire [C_S_AXI_ADDR_WIDTH-1 : 0] S_AXI_ARADDR,     //读地址通道
		input wire [2 : 0] S_AXI_ARPROT,					    //读保护类型：这个信号表示事务的特权和安全等级。
		input wire  S_AXI_ARVALID,								//读地址有效
		output wire  S_AXI_ARREADY,								//读地址准备

		output wire [C_S_AXI_DATA_WIDTH-1 : 0] S_AXI_RDATA,    //读数据通道
		output wire [1 : 0] S_AXI_RRESP,  						//读取响应
		output wire  S_AXI_RVALID,								//读数据有效
		input wire  S_AXI_RREADY								//读数据准备
	);

	// AXI—lite 
	reg [C_S_AXI_ADDR_WIDTH-1 : 0] 	axi_awaddr; 
	reg  	axi_awready;
	reg  	axi_wready;
	reg [1 : 0] 	axi_bresp;
	reg  	axi_bvalid;
	reg [C_S_AXI_ADDR_WIDTH-1 : 0] 	axi_araddr;
	reg  	axi_arready;
	reg [C_S_AXI_DATA_WIDTH-1 : 0] 	axi_rdata;
	reg [1 : 0] 	axi_rresp;
	reg  	axi_rvalid;

	// Example-specific design signals
	// local parameter for addressing 32 bit / 64 bit C_S_AXI_DATA_WIDTH
	// ADDR_LSB is used for addressing 32/64 bit registers/memories
	// ADDR_LSB = 2 for 32 bits (n downto 2)
	// ADDR_LSB = 3 for 64 bits (n downto 3)
	localparam integer ADDR_LSB = (C_S_AXI_DATA_WIDTH/32) + 1;
	localparam integer OPT_MEM_ADDR_BITS = 1;
	//----------------------------------------------
	//-- Signals for user logic register space example
	//------------------------------------------------
	//-- Number of Slave Registers 4
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg0;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg1;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg2;
	reg [C_S_AXI_DATA_WIDTH-1:0]	slv_reg3;
	wire	 slv_reg_rden;
	wire	 slv_reg_wren;
	reg [C_S_AXI_DATA_WIDTH-1:0]	 reg_data_out;
	integer	 byte_index;
	reg	 aw_en;

	// I/O Connections assignments

	assign S_AXI_AWREADY	= axi_awready;
	assign S_AXI_WREADY	= axi_wready;
	assign S_AXI_BRESP	= axi_bresp;
	assign S_AXI_BVALID	= axi_bvalid;
	assign S_AXI_ARREADY	= axi_arready;
	assign S_AXI_RDATA	= axi_rdata;
	assign S_AXI_RRESP	= axi_rresp;
	assign S_AXI_RVALID	= axi_rvalid;
	// Implement axi_awready generation
	// axi_awready is asserted for one S_AXI_ACLK clock cycle when both
	// S_AXI_AWVALID and S_AXI_WVALID are asserted. axi_awready is
	// de-asserted when reset is low.

	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      axi_awready <= 1'b0;
	      aw_en <= 1'b1;
	    end 
	  else
	    begin    
	      if (~axi_awready && S_AXI_AWVALID && S_AXI_WVALID && aw_en)
	        begin
	          // slave is ready to accept write address when 
	          // there is a valid write address and write data
	          // on the write address and data bus. This design 
	          // expects no outstanding transactions. 
	          axi_awready <= 1'b1;
	          aw_en <= 1'b0;
	        end
	        else if (S_AXI_BREADY && axi_bvalid)
	            begin
	              aw_en <= 1'b1;
	              axi_awready <= 1'b0;
	            end
	      else           
	        begin
	          axi_awready <= 1'b0;
	        end
	    end 
	end       

	// Implement axi_awaddr latching
	// This process is used to latch the address when both 
	// S_AXI_AWVALID and S_AXI_WVALID are valid. 

	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      axi_awaddr <= 0;
	    end 
	  else
	    begin    
	      if (~axi_awready && S_AXI_AWVALID && S_AXI_WVALID && aw_en)
	        begin
	          // Write Address latching 
	          axi_awaddr <= S_AXI_AWADDR;
	        end
	    end 
	end       

	// Implement axi_wready generation
	// axi_wready is asserted for one S_AXI_ACLK clock cycle when both
	// S_AXI_AWVALID and S_AXI_WVALID are asserted. axi_wready is 
	// de-asserted when reset is low. 

	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      axi_wready <= 1'b0;
	    end 
	  else
	    begin    
	      if (~axi_wready && S_AXI_WVALID && S_AXI_AWVALID && aw_en )
	        begin
	          // slave is ready to accept write data when 
	          // there is a valid write address and write data
	          // on the write address and data bus. This design 
	          // expects no outstanding transactions. 
	          axi_wready <= 1'b1;
	        end
	      else
	        begin
	          axi_wready <= 1'b0;
	        end
	    end 
	end       

	// Implement memory mapped register select and write logic generation
	// The write data is accepted and written to memory mapped registers when
	// axi_awready, S_AXI_WVALID, axi_wready and S_AXI_WVALID are asserted. Write strobes are used to
	// select byte enables of slave registers while writing.
	// These registers are cleared when reset (active low) is applied.
	// Slave register write enable is asserted when valid address and data are available
	// and the slave is ready to accept the write address and write data.
	assign slv_reg_wren = axi_wready && S_AXI_WVALID && axi_awready && S_AXI_AWVALID;

	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      slv_reg0 <= 0;
	      slv_reg1 <= 0;
	      slv_reg2 <= 0;
	      slv_reg3 <= 0;
	    end 
	  else begin
	    if (slv_reg_wren)
	      begin
	        case ( axi_awaddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] )
	          2'h0:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 0
	                slv_reg0[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          2'h1:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 1
	                slv_reg1[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          2'h2:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 2
	                slv_reg2[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          2'h3:
	            for ( byte_index = 0; byte_index <= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )
	              if ( S_AXI_WSTRB[byte_index] == 1 ) begin
	                // Respective byte enables are asserted as per write strobes 
	                // Slave register 3
	                slv_reg3[(byte_index*8) +: 8] <= S_AXI_WDATA[(byte_index*8) +: 8];
	              end  
	          default : begin
	                      slv_reg0 <= slv_reg0;
	                      slv_reg1 <= slv_reg1;
	                      slv_reg2 <= slv_reg2;
	                      slv_reg3 <= slv_reg3;
	                    end
	        endcase
	      end
	  end
	end    

	// Implement write response logic generation
	// The write response and response valid signals are asserted by the slave 
	// when axi_wready, S_AXI_WVALID, axi_wready and S_AXI_WVALID are asserted.  
	// This marks the acceptance of address and indicates the status of 
	// write transaction.

	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      axi_bvalid  <= 0;
	      axi_bresp   <= 2'b0;
	    end 
	  else
	    begin    
	      if (axi_awready && S_AXI_AWVALID && ~axi_bvalid && axi_wready && S_AXI_WVALID)
	        begin
	          // indicates a valid write response is available
	          axi_bvalid <= 1'b1;
	          axi_bresp  <= 2'b0; // 'OKAY' response 
	        end                   // work error responses in future
	      else
	        begin
	          if (S_AXI_BREADY && axi_bvalid) 
	            //check if bready is asserted while bvalid is high) 
	            //(there is a possibility that bready is always asserted high)   
	            begin
	              axi_bvalid <= 1'b0; 
	            end  
	        end
	    end
	end   

	// Implement axi_arready generation
	// axi_arready is asserted for one S_AXI_ACLK clock cycle when
	// S_AXI_ARVALID is asserted. axi_awready is 
	// de-asserted when reset (active low) is asserted. 
	// The read address is also latched when S_AXI_ARVALID is 
	// asserted. axi_araddr is reset to zero on reset assertion.

	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      axi_arready <= 1'b0;
	      axi_araddr  <= 32'b0;
	    end 
	  else
	    begin    
	      if (~axi_arready && S_AXI_ARVALID)
	        begin
	          // indicates that the slave has acceped the valid read address
	          axi_arready <= 1'b1;
	          // Read address latching
	          axi_araddr  <= S_AXI_ARADDR;
	        end
	      else
	        begin
	          axi_arready <= 1'b0;
	        end
	    end 
	end       

	// Implement axi_arvalid generation
	// axi_rvalid is asserted for one S_AXI_ACLK clock cycle when both 
	// S_AXI_ARVALID and axi_arready are asserted. The slave registers 
	// data are available on the axi_rdata bus at this instance. The 
	// assertion of axi_rvalid marks the validity of read data on the 
	// bus and axi_rresp indicates the status of read transaction.axi_rvalid 
	// is deasserted on reset (active low). axi_rresp and axi_rdata are 
	// cleared to zero on reset (active low).  
	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      axi_rvalid <= 0;
	      axi_rresp  <= 0;
	    end 
	  else
	    begin    
	      if (axi_arready && S_AXI_ARVALID && ~axi_rvalid)
	        begin
	          // Valid read data is available at the read data bus
	          axi_rvalid <= 1'b1;
	          axi_rresp  <= 2'b0; // 'OKAY' response
	        end   
	      else if (axi_rvalid && S_AXI_RREADY)
	        begin
	          // Read data is accepted by the master
	          axi_rvalid <= 1'b0;
	        end                
	    end
	end    

	// Implement memory mapped register select and read logic generation
	// Slave register read enable is asserted when valid address is available
	// and the slave is ready to accept the read address.
	assign slv_reg_rden = axi_arready & S_AXI_ARVALID & ~axi_rvalid;
	always @(*)
	begin
	      // Address decoding for reading registers
	      case ( axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] )
	        2'h0   : reg_data_out <= slv_reg0;
	        2'h1   : reg_data_out <= slv_reg1;
	        2'h2   : reg_data_out <= slv_reg2;
	        2'h3   : reg_data_out <= slv_reg3;
	        default : reg_data_out <= 0;
	      endcase
	end

	// Output register or memory read data
	always @( posedge S_AXI_ACLK )
	begin
	  if ( S_AXI_ARESETN == 1'b0 )
	    begin
	      axi_rdata  <= 0;
	    end 
	  else
	    begin    
	      // When there is a valid read address (S_AXI_ARVALID) with 
	      // acceptance of read address by the slave (axi_arready), 
	      // output the read dada 
	      if (slv_reg_rden)
	        begin
	          axi_rdata <= reg_data_out;     // register read data
	        end   
	    end
	end    
	

	// Add user logic here
	/********在这里增加用户逻辑**********/


	
	// User logic ends

	endmodule