【MYD-C7Z010/20开发板试用体验】运用AXI_IIC对M24C02进行读写

楼主

风扬SKY

3 主题
3 帖子
495 积分

身份：LV2 初级技术员

E币：377

发消息

 5799

 1

发表于 2019-11-22 13:42:40

显示全部楼层

这次项目主要运用MYIR提供的MYD-C7010开发板完成AXI_IIC对M24C02读写并且串口打印输出E2PROM的值，闲话少说，还是先复习下MYIR的硬件框架示意图。

我们使用了米尔开发板上的LP FMC接口进行外扩出的XM105赛灵思官方的扩展板。开发环境为VIVADO 2017.4.
下面，让我们一步一步实现AXI_IIC的操作：以下的步骤主要针对刚熟悉VIVADO开发环境的工程师，也能进一步熟悉米尔开发板硬软件的架构。这话和LED控制一样很熟悉

1.创建工程
具体的步骤如下，打开相应的VIAADO.2017.4的软件，创建一个新的工程，具体参考图。

接着进入下一个界面，点击NEXT，创建一个名称为AXI_IIC_24C02的工程，名称可以自己取，不违反规则就行

下一步我们创建的是一个RTL的project，注意选择，如下图：

在接下来我们有个地方注意下选择，就是编程的语言和仿真的语言，编程的语言我们一般选择VERILOG ，当然你若是用VHDL，那就选VHDL语言仿真选择MIXD，如图：

点击连续NEXT，来到下一个设置界面，主要设置我们主芯片的型号，我们的开发板主要是XC7z010clg400-1。

点击NEXT，然后点击FINISH,至此，我们完成了一个名称为AXI_IIC_24C02的工程的创建。下面进入原理设计阶段。
2.设计原理
我们创建一个IP INTEGRATOR,具体的操作步骤如下图所示：

下面我们设置DESIGN 的名称为axi_iic_24c02,名称也可以自己取，也可保持不变，设置完成后点击OK.

接下来，我们添加一个zynq核并配置，具体的操作步骤如下：

创建一个ZYNQ7的PS，创建的框图如下：

如图上所示，我们双击图框，设置相应的原理图的基本参数，具体的设置参数如下图所示。

主要配置的参数有1.SD接口的引脚和时钟配置 2.串口的配置 3.DDR参数的配置，参考实际图示例

配置DDR的接口型号，这个参看米尔开发板上的实际型号，因为选项中没有板上对应的型号，我们可以选相近的型号，只是封装不一样而已。

时钟设置等就不再一一阐述，其他的参数保持默认即可。然后我们单击OK，这样我们的第一个IP核就配置好了。
下面我们创建AXI_IIC核，创建的步骤是在diagram菜单栏中点击+号添加一个AXI IIC的IP核，如下图：

双击，创建好设置的AXI IIC的核之后我们双击AXI IIC框图设置相应的参数。

这样我们两个IP核都已经创建，下面需要进行设置原理的连线，设置automation，自动连线。

完成上面的自动连线的操作后，我们再运行BLOCK的连线，具体的设置如下图：

然后我们优化布线，修改相应IIC输出的名称，这个主要涉及到后面的约束条件中需要调用到相应的名称，具体如下图：

至此，我们原理图的框架已经搭建出来，接着我们还是按照控制LED灯步骤来进行下一步。
3.生成HDL文件，生成综合文件和顶层文件
下面我们的操作步骤如下图所示：生成顶层文件，

生成综合文件

生成综合文件后，会有提示完成综合，这个过程需要一定的时间，接着我们来添加约束条件，如下图：

点击NEXT,如下图：

如下图所示创建名称为axi_iic的FILE文本

然后我们在约束条件的文本中添加约束语句，具体如下图：

约束条件的语句文本如下：主要是根据MYIR科技的提供的FMC扩展接口对应的FPGA引脚以及起的IIC输出的名称来定义。
通过查阅米尔电子官方提供的MYC-C7Z01020 管脚描述表文件，找出的对应关系如下：
set_property PACKAGE_PIN G14 [get_ports axi_iic_scl_io]
set_property PACKAGE_PIN J15 [get_ports axi_iic_sda_io]
set_property IOSTANDARD LVCMOS33 [get_ports axi_iic_scl_io]
set_property IOSTANDARD LVCMOS33 [get_ports axi_iic_sda_io]
set_property PULLUP true [get_ports iic_0_scl_io]
set_property PULLUP true [get_ports iic_0_sda_io]

首先保存下.XAC约束文件，点击综合的按键，如图所示

上面操作完成后，出现下图所示的框图，点击OK,如下图：

点击OK后，当完成Run Implementaion，出现以下框图，我们操作步骤如下：

点击OK，当完成BIT流的生成以后，如下图，点击cancel。

接下来的一步我们输出，硬件的设置，具体的步骤参照如下：

至此，我们完成了所有的硬件部分的设置，接下来我们进入软件部分的设置，进入SDK部分。
4.进入SDK软件编程

FIle ->Launch SDK就进入SDK编程阶段，在SDK 里，菜单 File -> New -> New application Project

创建名称为AXI_IIC_24C02，点击NEXT,

创建一个以HELLO WORLD 为模板的文档

完成 finish，然后我们打开所创建HELLO.C的文件，在文档中编写我们的程序。
我们将已经编写好的程序COPY进文档编译器中，

然后我们对FPGA进行下载。

进行进一步的下载设置

完成下载后，我们看到串口从E2PROM读取出写入进去的值，0x00~0x0f，串口打印如下图所示：

我们所用的硬件的图也上一个图片，作为参考：

插入编译的.C文件作为附件，供大家参考。文档末尾还是感谢米尔提供的开发板，面包网提供的网络环境，以及米尔的技术支持陶威威工的支持，再次感谢。

helloworld.rar (4.48 KB, 下载次数: 20)

2019-11-22 21:08 上传

点击文件名下载附件
直接贴上.C文件，这个文件是在XILINX官方提供的文档上进行的修改，我们也可以参考官方的文档，具体操作步骤可以参考
【MYD-C7Z010/20开发板试用体验】使用米尔开发板实现PS和PL的结合控制LED灯中如何添加官方自带的范例。此图片为XM105板端的24C02，从米尔提供的FMC接口我们可以计算出E2PROM的7位IIC地址为0x50.

/***************************** Include Files *********************************/
#include "xparameters.h"
#include "xiic.h"
#include "xil_io.h"
#include "xil_printf.h"
/************************** Constant Definitions *****************************/
/*
* The following constants map to the XPAR parameters created in the
* xparameters.h file. They are defined here such that a user can easily
* change all the needed parameters in one place.
*/
#define IIC_BASE_ADDRESS       XPAR_IIC_0_BASEADDR
/*
* The following constant defines the address of the IIC Slave device on the
* IIC bus. Note that since the address is only 7 bits, this constant is the
* address divided by 2.
* The 7 bit IIC Slave address of the IIC EEPROM on the ML300/ML310/ML403/ML410/
* ML501/ML505/ML507/ML510 boards is 0x50. The 7 bit IIC Slave address of the
* IIC EEPROM on the ML605/SP601/SP605 boards is 0x54.
* Please refer the User Guide's of the respective boards for further
* information about the IIC slave address of IIC EEPROM's.
*/
#define EEPROM_ADDRESS       0x50       /* 0xA0 as an 8 bit number */
/*
* The page size determines how much data should be written at a time.
* The ML300 board supports a page size of 32 and 16
* The write function should be called with this as a maximum byte count.
*/
#define PAGE_SIZE       16
/*
* The Starting address in the IIC EEPROM on which this test is performed
*/
#define EEPROM_TEST_START_ADDRESS       0
/**************************** Type Definitions *******************************/
/*
* The AddressType for ML300/ML310/ML510 boards should be u16 as the address
* pointer in the on board EEPROM is 2 bytes.
* The AddressType for ML403/ML501/ML505/ML507/ML605/SP601/SP605 boards should
* be u8 as the address pointer in the on board EEPROM is 1 bytes.
*/
typedef u8 AddressType;
/***************** Macros (Inline Functions) Definitions *********************/
/************************** Function Prototypes ******************************/
int IicLowLevelEeprom();
int ReadWriteVerify(AddressType Address);
unsigned EepromWriteByte(AddressType Address, u8 *BufferPtr, u16 ByteCount);
unsigned EepromReadByte(AddressType Address, u8 *BufferPtr, u16 ByteCount);
/************************** Variable Definitions **************************/
int ErrorCount;                         /* The Error Count */
u8 WriteBuffer[PAGE_SIZE];       /* Write buffer for writing a page */
u8 ReadBuffer[PAGE_SIZE];       /* Read buffer for reading a page */
u8 ReadBufferAll[PAGE_SIZE * 4];  /* Buffer used for reading all the data */
u8 EepromIicAddr;                /* Variable for storing Eeprom IIC address */
/*****************************************************************************/
/**
* Main function to call the low level EEPROM example.
*
* @param       None.
*
* @return       XST_SUCCESS if successful, XST_FAILURE if unsuccessful.
*
* @note             None.
*
******************************************************************************/
int main(void)
{
      int Status;
      /*
      * Run the Low Level EEPROM example.
      */
      Status = IicLowLevelEeprom();
      if (Status != XST_SUCCESS) {
            xil_printf("IIC lowlevel eeprom Example Failed\r\n");
            return XST_FAILURE;
      }

      xil_printf("Successfully ran IIC lowlevel eeprom Example\r\n");
      return XST_SUCCESS;
}
/*****************************************************************************/
/**
* The function uses the low level driver of IIC to read and write to the
* IIC EEPROM board. The addresses tested are from 128 to 192.
*
* @param       None.
*
* @return       XST_SUCCESS if successful, XST_FAILURE if unsuccessful.
*
* @note             None.
*
****************************************************************************/
int IicLowLevelEeprom()
{
      int Status;
      unsigned BytesRead;
      EepromIicAddr = EEPROM_ADDRESS;

      /*
      * Read, write and verify a page of data at the specified address.
      */
      Status = ReadWriteVerify(EEPROM_TEST_START_ADDRESS);
      if (Status != XST_SUCCESS) {
            ErrorCount++;
      }

      return Status;
}

/*****************************************************************************/
/**
* This function writes, reads, and verifies the read to the IIC EEPROM.  It
* does the write as a single page write, performs a buffered read, and also
* performs byte reads.
*
* @param       Address is the starting address of the page in the EEPROM device
*             to which the data is to be written.
*
* @return       XST_FAILURE if the test fails, XST_SUCCESS if the test passes.
*
* @note       None.
*
****************************************************************************/
int ReadWriteVerify(AddressType Address)
{
      unsigned BytesWritten;
      unsigned BytesRead;
      int Index;

      /*
      * Initialize the data to written and the read buffer.
      */
      for (Index = 0; Index < PAGE_SIZE; Index++) {
            WriteBuffer[Index] = Index;
            ReadBuffer[Index] = 0;
      }

      /*
      * Write to the EEPROM.
      */
      BytesWritten = EepromWriteByte(Address, WriteBuffer, PAGE_SIZE);
      if (BytesWritten != PAGE_SIZE) {
            return XST_FAILURE;
      }
      /*
      * Read from the EEPROM.
      */
      BytesRead = EepromReadByte(Address, ReadBuffer, PAGE_SIZE);
      if (BytesRead != PAGE_SIZE) {
            return XST_FAILURE;
      }

      //printf data
      for (Index = 0; Index < PAGE_SIZE; Index++)
      {

         xil_printf("0x%02x\r\n",ReadBuffer[Index]);

      }
      /*
      * Read each byte one at a time and verify.
      */
      for (Index = 0; Index < PAGE_SIZE; Index++)
      {

            if (ReadBuffer[Index] != WriteBuffer[Index]) {
                     return XST_FAILURE;
            }

      }
      return XST_SUCCESS;
}

/*****************************************************************************/
/**
* This function writes a buffer of bytes to the IIC serial EEPROM.
*
* @param       Address contains the address in the EEPROM to write to.
* @param       BufferPtr contains the address of the data to write.
* @param       ByteCount contains the number of bytes in the buffer to be written.
*             Note that this should not exceed the page size of the EEPROM as
*             noted by the constant PAGE_SIZE.
*
* @return       The number of bytes written, a value less than that which was
*             specified as an input indicates an error.
*
* @note             None.
*
****************************************************************************/
unsigned EepromWriteByte(AddressType Address, u8 *BufferPtr, u16 ByteCount)
{
      volatile unsigned SentByteCount;
      volatile unsigned AckByteCount;
      u8 WriteBuffer[sizeof(Address) + PAGE_SIZE];
      int Index;
      /*
      * A temporary write buffer must be used which contains both the address
      * and the data to be written, put the address in first based upon the
      * size of the address for the EEPROM.
      */
      if (sizeof(AddressType) == 2) {
            WriteBuffer[0] = (u8)(Address >> 8);
            WriteBuffer[1] = (u8)(Address);
      } else if (sizeof(AddressType) == 1) {
            WriteBuffer[0] = (u8)(Address);
            EepromIicAddr |= (EEPROM_TEST_START_ADDRESS >> 8) & 0x7;
      }
      /*
      * Put the data in the write buffer following the address.
      */
      for (Index = 0; Index < ByteCount; Index++) {
            WriteBuffer[sizeof(Address) + Index] = BufferPtr[Index];
      }

      /*
      * Set the address register to the specified address by writing
      * the address to the device, this must be tried until it succeeds
      * because a previous write to the device could be pending and it
      * will not ack until that write is complete.
      */
      do {
            SentByteCount = XIic_Send(IIC_BASE_ADDRESS,
                                    EepromIicAddr,
                                    (u8 *)&Address, sizeof(Address),
                                    XIIC_STOP);
            if (SentByteCount != sizeof(Address)) {

                     /* Send is aborted so reset Tx FIFO */
                     XIic_WriteReg(IIC_BASE_ADDRESS,  XIIC_CR_REG_OFFSET,
                                    XIIC_CR_TX_FIFO_RESET_MASK);
                     XIic_WriteReg(IIC_BASE_ADDRESS, XIIC_CR_REG_OFFSET,
                                    XIIC_CR_ENABLE_DEVICE_MASK);
            }

      } while (SentByteCount != sizeof(Address));

      /*
      * Write a page of data at the specified address to the EEPROM.
      */
      SentByteCount = XIic_Send(IIC_BASE_ADDRESS, EepromIicAddr,
                              WriteBuffer, sizeof(Address) + PAGE_SIZE,
                              XIIC_STOP);

      /*
      * Wait for the write to be complete by trying to do a write and
      * the device will not ack if the write is still active.
      */
      do {
            AckByteCount = XIic_Send(IIC_BASE_ADDRESS, EepromIicAddr,
                                    (u8 *)&Address, sizeof(Address),
                                    XIIC_STOP);
            if (AckByteCount != sizeof(Address)) {

                     /* Send is aborted so reset Tx FIFO */
                     XIic_WriteReg(IIC_BASE_ADDRESS,  XIIC_CR_REG_OFFSET,
                                    XIIC_CR_TX_FIFO_RESET_MASK);
                     XIic_WriteReg(IIC_BASE_ADDRESS, XIIC_CR_REG_OFFSET,
                                    XIIC_CR_ENABLE_DEVICE_MASK);
            }

      } while (AckByteCount != sizeof(Address));

      /*
      * Return the number of bytes written to the EEPROM
      */
      return SentByteCount - sizeof(Address);
}

/*****************************************************************************/
/**
* This function reads a number of bytes from the IIC serial EEPROM into a
* specified buffer.
*
* @param       Address contains the address in the EEPROM to read from.
* @param       BufferPtr contains the address of the data buffer to be filled.
* @param       ByteCount contains the number of bytes in the buffer to be read.
*             This value is not constrained by the page size of the device
*             such that up to 64K may be read in one call.
*
* @return       The number of bytes read. A value less than the specified input
*             value indicates an error.
*
* @note             None.
*
****************************************************************************/
unsigned EepromReadByte(AddressType Address, u8 *BufferPtr, u16 ByteCount)
{
      volatile unsigned ReceivedByteCount;
      u16 StatusReg;

      /*
      * Set the address register to the specified address by writing
      * the address to the device, this must be tried until it succeeds
      * because a previous write to the device could be pending and it
      * will not ack until that write is complete.
      */
      do {
            StatusReg = XIic_ReadReg(IIC_BASE_ADDRESS, XIIC_SR_REG_OFFSET);
            if(!(StatusReg & XIIC_SR_BUS_BUSY_MASK)) {
                     ReceivedByteCount = XIic_Send(IIC_BASE_ADDRESS,
                                                      EepromIicAddr,
                                                      (u8 *)&Address,
                                                      sizeof(Address),
                                                      XIIC_STOP);

                     if (ReceivedByteCount != sizeof(Address)) {

                              /* Send is aborted so reset Tx FIFO */
                              XIic_WriteReg(IIC_BASE_ADDRESS,
                                             XIIC_CR_REG_OFFSET,
                                             XIIC_CR_TX_FIFO_RESET_MASK);
                              XIic_WriteReg(IIC_BASE_ADDRESS,
                                             XIIC_CR_REG_OFFSET,
                                             XIIC_CR_ENABLE_DEVICE_MASK);
                     }
            }

      } while (ReceivedByteCount != sizeof(Address));

      /*
      * Read the number of bytes at the specified address from the EEPROM.
      */
      ReceivedByteCount = XIic_Recv(IIC_BASE_ADDRESS, EepromIicAddr,
                                    BufferPtr, ByteCount, XIIC_STOP);

      /*
      * Return the number of bytes read from the EEPROM.
      */
      return ReceivedByteCount;
}

继续阅读本篇相关更多标签