devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ZYNQ7010的PS编程笔记_zynq.ps使用手册

作者：小舞很执着 | 2024-07-15 18:15:42

赞

踩

zynq.ps使用手册

1.定时器中断

api

XScuTimer Timer;                                     //定时器驱动

XScuTimer_Config *timer_cfg_ptr;         //定时器的配置

XScuTimer_LookupConfig(XPAR_XSCUTIMER_0_DEVICE_ID);  //定时器查找表

 XScuTimer_CfgInitialize(timer_ptr, timer_cfg_ptr, timer_cfg_ptr->BaseAddr)； //定时器初始化

 XScuTimer_LoadTimer(timer_ptr, TIMER_LOAD_VALUE); //加载计数周期，频率为CPU时钟频率（666MHz）一半大小
 XScuTimer_EnableAutoReload(timer_ptr); //设置自动装载模式,从而循环来产生定时器

XScuTimer_EnableInterrupt(timer_ptr);  //使能定时器中断

 XScuTimer_Start(&Timer);  //启动定时器

 XScuTimer_ClearInterruptStatus(timer_ptr);  //清除定时器中断标志

中断处理函数

  1.     //初始化中断控制器
  2.     XScuGic_Config *intc_cfg_ptr;
  3.     intc_cfg_ptr = XScuGic_LookupConfig(INTC_DEVICE_ID);
  4.     XScuGic_CfgInitialize(intc_ptr, intc_cfg_ptr, intc_cfg_ptr->CpuBaseAddress);
  5.     
  6.     //设置并打开中断异常功能
  7.     Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XScuGic_InterruptHandler, intc_ptr);
  8.     Xil_ExceptionEnable();
  9.  
  10.     //设置定时器中断,TIMER_IRPT_INTR是定时器中断ID
  11.     XScuGic_Connect(intc_ptr, TIMER_IRPT_INTR, (Xil_ExceptionHandler)timer_intr_handler,(void*)timer_ptr);
  12.  
  13.     XScuGic_Enable(intc_ptr, TIMER_IRPT_INTR); //使能GIC中的定时器中断
  14.  
  15.     XScuTimer_EnableInterrupt(timer_ptr); //使能定时器中断

 下面是全部代码，实现了一个每200ms的PS的LED灯闪烁一次的效果。

  1. #include "xparameters.h"
  2. #include "xscutimer.h"
  3. #include "xscugic.h"
  4. #include "xgpiops.h"
  5. #include "xil_exception.h"
  6. #include "xil_printf.h"
  7.  
  8. #define TIMER_DEVICE_ID XPAR_XSCUTIMER_0_DEVICE_ID  //定时器ID
  9. #define INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID //中断ID
  10. #define TIMER_IRPT_INTR XPAR_SCUTIMER_INTR //定时器中断ID
  11. #define GPIO_DEVICE_ID XPAR_XGPIOPS_0_DEVICE_ID //宏定义GPIO_PS ID
  12. #define MIO_LED  0  //led连接到MIO0
  13.  
  14. //私有定时器的时钟频率 = CPU时钟频率/2 = 333MHz
  15. // 0.2s闪烁一次，0.2/1000_000_00/(1000/333) - 1 = 3F83C3F
  16. #define TIMER_LOAD_VALUE 0x3F83C3F  //定时器装载数值
  17.  
  18. XScuGic Intc;   //中断控制器驱动程序实例
  19. XScuTimer Timer; //定时器驱动程序实例
  20. XGpioPs Gpio;    //GPIO设备的驱动程序实例
  21.  
  22. //MIO引脚初始化
  23. int mio_init(XGpioPs *mio_ptr)
  24. {
  25.     int status;
  26.  
  27.     XGpioPs_Config *mio_cfg_ptr;
  28.     mio_cfg_ptr = XGpioPs_LookupConfig(GPIO_DEVICE_ID);
  29.     if (mio_cfg_ptr == NULL)
  30.         return XST_FAILURE;
  31.     status = XGpioPs_CfgInitialize(mio_ptr, mio_cfg_ptr, mio_cfg_ptr->BaseAddr);
  32.     if (status != XST_SUCCESS)
  33.         return XST_FAILURE;
  34.  
  35.     //设置指定引脚的方向 0是输入，1是输出
  36.     XGpioPs_SetDirectionPin(&Gpio,MIO_LED, 1);
  37.     //使能指定引脚输出，0 禁止输出使能 1使能输出
  38.     XGpioPs_SetOutputEnablePin(&Gpio, MIO_LED, 1);
  39.     return XST_SUCCESS;
  40. }
  41.  
  42. //定时器初始化程序
  43. int timer_init(XScuTimer *timer_ptr)
  44. {
  45.     int status;
  46.     //私有定时器初始化
  47.     XScuTimer_Config *timer_cfg_ptr;
  48.     timer_cfg_ptr = XScuTimer_LookupConfig(TIMER_DEVICE_ID);
  49.     if (NULL == timer_cfg_ptr)
  50.     {
  51.         return XST_FAILURE;
  52.     }
  53.     status = XScuTimer_CfgInitialize(timer_ptr, timer_cfg_ptr, timer_cfg_ptr->BaseAddr);\
  54.     if(status != XST_SUCCESS)
  55.         return XST_FAILURE;
  56.  
  57.     XScuTimer_LoadTimer(timer_ptr, TIMER_LOAD_VALUE); //加载计数周期
  58.     XScuTimer_EnableAutoReload(timer_ptr); //设置自动装载模式,从而循环来产生定时器
  59.  
  60.     return XST_SUCCESS;
  61. }
  62.  
  63. //定时器中断处理函数
  64. void timer_intr_handler(void *CallBackRef)
  65. {
  66.     //LED 状态，用于控制LED灯状态翻转
  67.     static int led_state = 0;
  68.     XScuTimer* timer_ptr = (XScuTimer *)CallBackRef;
  69.     if(led_state == 0)
  70.         led_state = 1;
  71.     else
  72.         led_state = 0;
  73.     //向指定引脚写入数据：0 或者1
  74.     XGpioPs_WritePin(&Gpio, MIO_LED, led_state);
  75.     //清除定时器中断标志
  76.     XScuTimer_ClearInterruptStatus(timer_ptr);
  77. }
  78.  
  79. //定时器中断初始化
  80. void timer_intr_init(XScuGic *intc_ptr, XScuTimer * timer_ptr)
  81. {
  82.     //初始化中断控制器
  83.     XScuGic_Config *intc_cfg_ptr;
  84.     intc_cfg_ptr = XScuGic_LookupConfig(INTC_DEVICE_ID);
  85.     XScuGic_CfgInitialize(intc_ptr, intc_cfg_ptr, intc_cfg_ptr->CpuBaseAddress);
  86.  
  87.     //设置并打开中断异常功能
  88.     Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XScuGic_InterruptHandler, intc_ptr);
  89.     Xil_ExceptionEnable();
  90.  
  91.     //设置定时器中断,TIMER_IRPT_INTR是定时器中断ID
  92.     XScuGic_Connect(intc_ptr, TIMER_IRPT_INTR, (Xil_ExceptionHandler)timer_intr_handler,(void*)timer_ptr);
  93.  
  94.     XScuGic_Enable(intc_ptr, TIMER_IRPT_INTR); //使能GIC中的定时器中断
  95.  
  96.     XScuTimer_EnableInterrupt(timer_ptr); //使能定时器中断
  97. }
  98.  
  99. int main()
  100. {
  101.     int status;
  102.     xil_printf("SCU Timer Interrupt Test \r\n");
  103.  
  104.     mio_init(&Gpio);              //MIO引脚初始化
  105.     status = timer_init(&Timer);  //定时器初始化
  106.     if (status != XST_SUCCESS) {
  107.         xil_printf("Timer Initial Failed \r\n");
  108.         return XST_FAILURE;
  109.     }
  110.     timer_intr_init(&Intc, &Timer); //定时器中断初始化
  111.     XScuTimer_Start(&Timer);        //启动定时器
  112.  
  113.     while(1);
  114.     return 0;
  115. }

2.PS的XADC

ps的xadc可以读取板子上的实时电压以及温度

api

XAdcPs xadc_inst;   //XADC实例以及初始化

ConfigPtr = XAdcPs_LookupConfig(XPAR_XADCPS_0_DEVICE_ID);

XAdcPs_CfgInitialize(&xadc_inst, ConfigPtr, ConfigPtr->BaseAddrss);

XAdcPs_SetSequencerMode(&xadc_inst, XADCPS_SEQ_MODE_SAFE); //设置为安全模式

u32 temp_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_TEMP); //读取原始数据

XAdcPs_RawToVoltage()  XAdcPs_RawToTemperature()  //原始数据转换为电压（v）以及温度（摄氏度）

 下面是全部代码，实现了一个循环5s读取一次XADC上面的电压以及温度信号

  1. #include "xparameters.h"
  2. #include "xadcps.h"
  3. #include "stdio.h"
  4. #include "xil_printf.h"
  5. #include "sleep.h"
  6.  
  7. #define XADC_DEVICE_ID XPAR_XADCPS_0_DEVICE_ID  //PS的XADC器件
  8.  
  9. static XAdcPs xadc_inst;
  10.  
  11. int main(void)
  12. {
  13.     XAdcPs_Config *ConfigPtr; //XADC配置指针
  14.  
  15.     //原始数据
  16.     u32 temp_rawdata; //温度
  17.     u32 vcc_pint_rawdata; //ps内核电压
  18.     u32 vcc_paux_rawdata; //ps辅助电压
  19.     u32 vcc_pddr_rawdata; //ps的ddr电压
  20.     u32 vcc_int_rawdata; //pl内核电压
  21.     u32 vcc_aux_rawdata; //pl辅助电压
  22.     u32 vcc_bram_rawdata; //pl的bram电压
  23.  
  24.  
  25.     float temp; //温度
  26.     float vcc_pint; //ps内核电压
  27.     float vcc_paux; //ps辅助电压
  28.     float vcc_pddr; //ps的ddr电压
  29.     float vcc_int; //pl内核电压
  30.     float vcc_aux; //pl辅助电压
  31.     float vcc_bram; //pl的bram电压
  32.  
  33.     //初始化xadc驱动
  34.     ConfigPtr = XAdcPs_LookupConfig(XADC_DEVICE_ID);
  35.     XAdcPs_CfgInitialize(&xadc_inst, ConfigPtr, ConfigPtr->BaseAddrss);
  36.  
  37.     // 设置xadc操作模式为 默认安全模式
  38.     // XADC 会自动监测片上温度和电压传感器的数据，并将结果保存在状态寄存器中，此时 XADC
  39.     // 的操作与其他任何控制寄存器的设置无关
  40.     XAdcPs_SetSequencerMode(&xadc_inst, XADCPS_SEQ_MODE_SAFE);
  41.  
  42.     while(1) {
  43.         //获取原始温度传感器数据
  44.         temp_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_TEMP);
  45.         //转换成温度信息
  46.         temp = XAdcPs_RawToTemperature(temp_rawdata);
  47.  
  48.         //获取VCCPINT传感器数据
  49.         vcc_pint_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_VCCPINT);
  50.         vcc_pint = XAdcPs_RawToVoltage(vcc_pint_rawdata);
  51.  
  52.         //获取VCCPAUX传感器数据
  53.         vcc_paux_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_VCCPAUX);
  54.         vcc_paux = XAdcPs_RawToVoltage(vcc_paux_rawdata);
  55.  
  56.         //获取VCCPDRO传感器数据
  57.         vcc_pddr_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_VCCPDRO);
  58.         vcc_pddr = XAdcPs_RawToVoltage(vcc_pddr_rawdata);
  59.  
  60.         //获取VCCINT传感器数据
  61.         vcc_int_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_VCCINT);
  62.         vcc_int = XAdcPs_RawToVoltage(vcc_int_rawdata);
  63.  
  64.         //获取VCCPAUX传感器数据
  65.         vcc_aux_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_VCCAUX);
  66.         vcc_aux = XAdcPs_RawToVoltage(vcc_aux_rawdata);
  67.  
  68.         //获取VCCPDRO传感器数据
  69.         vcc_bram_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_VBRAM);
  70.         vcc_bram = XAdcPs_RawToVoltage(vcc_bram_rawdata);
  71.  
  72.         //打印温度、电压信息
  73.         printf("Raw Temp %lu, Real Temp %fC \n", temp_rawdata, temp);
  74.         printf("Raw VccPInt %lu, Real VccPInt %fV \n", vcc_pint_rawdata, vcc_pint);
  75.         printf("Raw VccPAux %lu, Real VccPAux %fV \n", vcc_paux_rawdata, vcc_paux);
  76.         printf("Raw VccPDDR %lu, Real VccPDDR %fV \n", vcc_pddr_rawdata, vcc_pddr);
  77.         printf("Raw VccInt %lu, Real VccInt %fV \n", vcc_int_rawdata, vcc_int);
  78.         printf("Raw VccAux %lu, Real VccAux %fV \n", vcc_aux_rawdata, vcc_aux);
  79.         printf("Raw VccBram %lu, Real VccBram %fV \n\r", vcc_bram_rawdata, vcc_bram);
  80.  
  81.         //延时 5s
  82.         sleep(5);
  83.     }
  84. }

下面实现了使用XADC读取外界输入的模拟信号转换成的数字信号

  1. // XADC 模块也集成了模数转换器，可以将外部输入的模拟电压转换成数字
  2. // 信号，实现通过 PS XADC 接口，读取外部模拟电压信号
  3.  
  4. // XADC 内部的两块 ADC 分别为 ADC A 与 ADC B， ADC A 是可以接收左侧包括所有片上
  5. // 传感器（温度温度传感器信息、电源传感器信息）、 VP/VN 模拟电压信息以及 16 路辅助模拟输入的；而
  6. // ADC B 只能接收 VP/VN 模拟电压信息以及 16 路辅助模拟输入。 VP/VN 与 16 路辅助模拟输入的不同在于
  7. // VP/VN 是专用的支持差分输入的模拟通道输入引脚，而 16 路辅助模拟输入是模拟数字/数字复用引脚，其
  8. // 中某个引脚用作模拟输入，该引脚的数字 IO 功能就不可以再使用
  9.  
  10. // VP/VN单端输入时候电压范围为0-1.0v, 如果是双端输入时电压范围则是-0.5v-0.5v的范围内
  11.  
  12. #include "xparameters.h"
  13. #include "xadcps.h"
  14. #include "stdio.h"
  15. #include "xil_printf.h"
  16. #include "sleep.h"
  17.  
  18. #define XADC_DEVICE_ID XPAR_XADCPS_0_DEVICE_ID  //PS的XADC器件
  19.  
  20. static XAdcPs xadc_inst;
  21.  
  22. int main(void)
  23. {
  24.     XAdcPs_Config *ConfigPtr; //XADC配置指针
  25.  
  26.     //原始数据
  27.     u32 vcc_vpvn_rawdata; //VpVn原始数据
  28.  
  29.     float vcc_vpvn; //vpvn电压
  30.  
  31.     //初始化xadc驱动
  32.     ConfigPtr = XAdcPs_LookupConfig(XADC_DEVICE_ID);
  33.     XAdcPs_CfgInitialize(&xadc_inst, ConfigPtr, ConfigPtr->BaseAddress);
  34.  
  35.     // 设置xadc操作模式为 默认安全模式
  36.     // XADC 会自动监测片上温度和电压传感器的数据，并将结果保存在状态寄存器中，此时 XADC
  37.     // 的操作与其他任何控制寄存器的设置无关
  38.     XAdcPs_SetSequencerMode(&xadc_inst, XADCPS_SEQ_MODE_SAFE);
  39.     // 使能相应的通道
  40.     XAdcPs_SetSeqChEnables(&xadc_inst, XADCPS_SEQ_CH_VPVN);
  41.  
  42.     //设置为循环模式
  43.     XAdcPs_SetSequencerMode(&xadc_inst, XADCPS_SEQ_MODE_CONTINPASS);
  44.  
  45.     while(1) {
  46.         //获取原始温度传感器数据
  47.         vcc_vpvn_rawdata = XAdcPs_GetAdcData(&xadc_inst, XADCPS_CH_VPVN);
  48.         //转换成温度信息
  49.         vcc_vpvn = XAdcPs_RawToVoltage(vcc_vpvn_rawdata)/3;
  50.  
  51.         //打印温度、电压信息
  52.         printf("Raw vpvn %lu, Real vpvn %fv \n", vcc_vpvn_rawdata, vcc_vpvn);
  53.  
  54.         //延时 1s
  55.         sleep(1);
  56.     }
  57. }

3.PS的QSPI

下面实现了QSPI的读写测试

  1. #include "xparameters.h" 
  2. #include "xqspips.h"     
  3. #include "xil_printf.h"
  4. /************************** Constant Definitions *****************************/
  5.  
  6. /*
  7.  * The following constants map to the XPAR parameters created in the
  8.  * xparameters.h file. They are defined here such that a user can easily
  9.  * change all the needed parameters in one place.
  10.  */
  11. #define QSPI_DEVICE_ID XPAR_XQSPIPS_0_DEVICE_ID
  12.  
  13. /*
  14.  * The following constants define the commands which may be sent to the FLASH
  15.  * device.
  16.  */
  17. #define WRITE_STATUS_CMD 0x01
  18. #define WRITE_CMD 0x02
  19. #define READ_CMD 0x03
  20. #define WRITE_DISABLE_CMD 0x04
  21. #define READ_STATUS_CMD 0x05
  22. #define WRITE_ENABLE_CMD 0x06
  23. #define FAST_READ_CMD 0x0B
  24. #define DUAL_READ_CMD 0x3B
  25. #define QUAD_READ_CMD 0x6B
  26. #define BULK_ERASE_CMD 0xC7
  27. #define SEC_ERASE_CMD 0xD8
  28. #define READ_ID 0x9F
  29.  
  30. /*
  31.  * The following constants define the offsets within a FlashBuffer data
  32.  * type for each kind of data.  Note that the read data offset is not the
  33.  * same as the write data because the QSPI driver is designed to allow full
  34.  * duplex transfers such that the number of bytes received is the number
  35.  * sent and received.
  36.  */
  37. #define COMMAND_OFFSET 0   /* FLASH instruction */
  38. #define ADDRESS_1_OFFSET 1 /* MSB byte of address to read or write */
  39. #define ADDRESS_2_OFFSET 2 /* Middle byte of address to read or write */
  40. #define ADDRESS_3_OFFSET 3 /* LSB byte of address to read or write */
  41. #define DATA_OFFSET 4      /* Start of Data for Read/Write */
  42. #define DUMMY_OFFSET 4     /* Dummy byte offset for fast, dual and quad \
  43.                             * reads                                     \
  44.                             */
  45. #define DUMMY_SIZE 1       /* Number of dummy bytes for fast, dual and \
  46.                             * quad reads                               \
  47.                             */
  48. #define RD_ID_SIZE 4       /* Read ID command + 3 bytes ID response */
  49. #define BULK_ERASE_SIZE 1  /* Bulk Erase command size */
  50. #define SEC_ERASE_SIZE 4   /* Sector Erase command + Sector address */
  51.  
  52. /*
  53.  * The following constants specify the extra bytes which are sent to the
  54.  * FLASH on the QSPI interface, that are not data, but control information
  55.  * which includes the command and address
  56.  */
  57. #define OVERHEAD_SIZE 4
  58.  
  59. /*
  60.  * The following constants specify the page size, sector size, and number of
  61.  * pages and sectors for the FLASH.  The page size specifies a max number of
  62.  * bytes that can be written to the FLASH with a single transfer.
  63.  */
  64. #define SECTOR_SIZE 0x10000
  65. #define NUM_SECTORS 0x100
  66. #define NUM_PAGES 0x10000
  67. #define PAGE_SIZE 256
  68.  
  69. /* Number of flash pages to be written.*/
  70. #define PAGE_COUNT 16
  71.  
  72. /* Flash address to which data is ot be written.*/
  73. #define TEST_ADDRESS 0x00055000
  74. #define UNIQUE_VALUE 0x05
  75. /*
  76.  * The following constants specify the max amount of data and the size of the
  77.  * the buffer required to hold the data and overhead to transfer the data to
  78.  * and from the FLASH.
  79.  */
  80. #define MAX_DATA (PAGE_COUNT * PAGE_SIZE)
  81.  
  82. /**************************** Type Definitions *******************************/
  83.  
  84. /***************** Macros (Inline Functions) Definitions *********************/
  85.  
  86. /************************** Function Prototypes ******************************/
  87.  
  88. void FlashErase(XQspiPs *QspiPtr, u32 Address, u32 ByteCount);
  89.  
  90. void FlashWrite(XQspiPs *QspiPtr, u32 Address, u32 ByteCount, u8 Command);
  91.  
  92. void FlashRead(XQspiPs *QspiPtr, u32 Address, u32 ByteCount, u8 Command);
  93.  
  94. int FlashReadID(void);
  95.  
  96. void FlashQuadEnable(XQspiPs *QspiPtr);
  97.  
  98. int QspiFlashPolledExample(XQspiPs *QspiInstancePtr, u16 QspiDeviceId);
  99.  
  100. /************************** Variable Definitions *****************************/
  101.  
  102. /*
  103.  * The instances to support the device drivers are global such that they
  104.  * are initialized to zero each time the program runs. They could be local
  105.  * but should at least be static so they are zeroed.
  106.  */
  107. static XQspiPs QspiInstance;
  108.  
  109. /*
  110.  * The following variable allows a test value to be added to the values that
  111.  * are written to the FLASH such that unique values can be generated to
  112.  * guarantee the writes to the FLASH were successful
  113.  */
  114. int Test = 5;
  115.  
  116. /*
  117.  * The following variables are used to read and write to the flash and they
  118.  * are global to avoid having large buffers on the stack
  119.  */
  120. u8 ReadBuffer[MAX_DATA + DATA_OFFSET + DUMMY_SIZE];
  121. u8 WriteBuffer[PAGE_SIZE + DATA_OFFSET];
  122.  
  123. /*****************************************************************************/
  124. /**
  125.  *
  126.  * Main function to call the QSPI Flash example.
  127.  *
  128.  * @param	None
  129.  *
  130.  * @return	XST_SUCCESS if successful, otherwise XST_FAILURE.
  131.  *
  132.  * @note		None
  133.  *
  134.  ******************************************************************************/
  135. int main(void)
  136. {
  137.     int Status;
  138.  
  139.     xil_printf("QSPI FLASH Polled Example Test \r\n");
  140.  
  141.     /* Run the Qspi Interrupt example.*/
  142.     Status = QspiFlashPolledExample(&QspiInstance, QSPI_DEVICE_ID);
  143.     if (Status != XST_SUCCESS)
  144.     {
  145.         xil_printf("QSPI FLASH Polled Example Test Failed\r\n");
  146.         return XST_FAILURE;
  147.     }
  148.  
  149.     xil_printf("Successfully ran QSPI FLASH Polled Example Test\r\n");
  150.     return XST_SUCCESS;
  151. }
  152.  
  153. /*****************************************************************************/
  154. /**
  155.  *
  156.  * The purpose of this function is to illustrate how to use the XQspiPs
  157.  * device driver in polled mode. This function writes and reads data
  158.  * from a serial FLASH.
  159.  *
  160.  * @param	None.
  161.  *
  162.  * @return	XST_SUCCESS if successful, else XST_FAILURE.
  163.  *
  164.  * @note		None.
  165.  *
  166.  *****************************************************************************/
  167. int QspiFlashPolledExample(XQspiPs *QspiInstancePtr, u16 QspiDeviceId)
  168. {
  169.     int Status;
  170.     u8 *BufferPtr;
  171.     u8 UniqueValue;
  172.     int Count;
  173.     int Page;
  174.     XQspiPs_Config *QspiConfig;
  175.  
  176.     //初始化 QSPI 驱动
  177.     QspiConfig = XQspiPs_LookupConfig(QspiDeviceId);
  178.     XQspiPs_CfgInitialize(QspiInstancePtr, QspiConfig, QspiConfig->BaseAddress);
  179.     //初始化读写 BUFFER
  180.     for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < PAGE_SIZE;
  181.          Count++, UniqueValue++)
  182.     {
  183.         WriteBuffer[DATA_OFFSET + Count] = (u8)(UniqueValue + Test);
  184.         /* WriteBuffer[4] = (5+5) = 10
  185.            WriteBuffer[5] = (6+5) = 11
  186.            WriteBuffer[6] = (7+5) = 12
  187.            WriteBuffer[7] = (8+5) = 13
  188.            ......
  189.            WriteBuffer[259] = (260+5) = 265
  190.         */
  191.     }
  192.     memset(ReadBuffer, 0x00, sizeof(ReadBuffer));
  193.  
  194.     //设置手动启动和手动片选模式
  195.     XQspiPs_SetOptions(QspiInstancePtr, XQSPIPS_MANUAL_START_OPTION |
  196.                                             XQSPIPS_FORCE_SSELECT_OPTION |
  197.                                             XQSPIPS_HOLD_B_DRIVE_OPTION);
  198.     //设置 QSPI 时钟的分频系数
  199.     XQspiPs_SetClkPrescaler(QspiInstancePtr, XQSPIPS_CLK_PRESCALE_8);
  200.     //片选信号置为有效
  201.     XQspiPs_SetSlaveSelect(QspiInstancePtr);
  202.     
  203.     //读 Flash ID
  204.     FlashReadID();
  205.     //使能 Flash Quad 模式
  206.     FlashQuadEnable(QspiInstancePtr);
  207.     //擦除 Flash
  208.     FlashErase(QspiInstancePtr, TEST_ADDRESS, MAX_DATA);
  209.     //向 Flash 中写入数据
  210.     for (Page = 0; Page < PAGE_COUNT; Page++)
  211.     {
  212.         FlashWrite(QspiInstancePtr, (Page * PAGE_SIZE) + TEST_ADDRESS,
  213.                    PAGE_SIZE, WRITE_CMD);
  214.     }
  215.     //使用 QUAD 模式从 Flash 中读出数据
  216.     FlashRead(QspiInstancePtr, TEST_ADDRESS, MAX_DATA, QUAD_READ_CMD);
  217.  
  218.     //对比写入 Flash 与从 Flash 中读出的数据
  219.     BufferPtr = &ReadBuffer[DATA_OFFSET + DUMMY_SIZE];
  220.     for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MAX_DATA;
  221.          Count++, UniqueValue++)
  222.     {
  223.         if (BufferPtr[Count] != (u8)(UniqueValue + Test))
  224.         {
  225.             return XST_FAILURE;
  226.         }
  227.     }
  228.  
  229.     return XST_SUCCESS;
  230. }
  231. /*****************************************************************************/
  232. /**
  233.  *
  234.  * This function writes to the  serial FLASH connected to the QSPI interface.
  235.  * All the data put into the buffer must be in the same page of the device with
  236.  * page boundaries being on 256 byte boundaries.
  237.  *
  238.  * @param	QspiPtr is a pointer to the QSPI driver component to use.
  239.  * @param	Address contains the address to write data to in the FLASH.
  240.  * @param	ByteCount contains the number of bytes to write.
  241.  * @param	Command is the command used to write data to the flash. QSPI
  242.  *		device supports only Page Program command to write data to the
  243.  *		flash.
  244.  *
  245.  * @return	None.
  246.  *
  247.  * @note		None.
  248.  *
  249.  ******************************************************************************/
  250. void FlashWrite(XQspiPs *QspiPtr, u32 Address, u32 ByteCount, u8 Command)
  251. {
  252.     u8 WriteEnableCmd = {WRITE_ENABLE_CMD};
  253.     u8 ReadStatusCmd[] = {READ_STATUS_CMD, 0}; /* must send 2 bytes */
  254.     u8 FlashStatus[2];
  255.  
  256.     /*
  257.      * Send the write enable command to the FLASH so that it can be
  258.      * written to, this needs to be sent as a separate transfer before
  259.      * the write
  260.      */
  261.     XQspiPs_PolledTransfer(QspiPtr, &WriteEnableCmd, NULL,
  262.                            sizeof(WriteEnableCmd));
  263.  
  264.     /*
  265.      * Setup the write command with the specified address and data for the
  266.      * FLASH
  267.      */
  268.     WriteBuffer[COMMAND_OFFSET] = Command;
  269.     WriteBuffer[ADDRESS_1_OFFSET] = (u8)((Address & 0xFF0000) >> 16);
  270.     WriteBuffer[ADDRESS_2_OFFSET] = (u8)((Address & 0xFF00) >> 8);
  271.     WriteBuffer[ADDRESS_3_OFFSET] = (u8)(Address & 0xFF);
  272.  
  273.     /*
  274.      * Send the write command, address, and data to the FLASH to be
  275.      * written, no receive buffer is specified since there is nothing to
  276.      * receive
  277.      */
  278.     XQspiPs_PolledTransfer(QspiPtr, WriteBuffer, NULL,
  279.                            ByteCount + OVERHEAD_SIZE);
  280.  
  281.     /*
  282.      * Wait for the write command to the FLASH to be completed, it takes
  283.      * some time for the data to be written
  284.      */
  285.     while (1)
  286.     {
  287.         /*
  288.          * Poll the status register of the FLASH to determine when it
  289.          * completes, by sending a read status command and receiving the
  290.          * status byte
  291.          */
  292.         XQspiPs_PolledTransfer(QspiPtr, ReadStatusCmd, FlashStatus,
  293.                                sizeof(ReadStatusCmd));
  294.  
  295.         /*
  296.          * If the status indicates the write is done, then stop waiting,
  297.          * if a value of 0xFF in the status byte is read from the
  298.          * device and this loop never exits, the device slave select is
  299.          * possibly incorrect such that the device status is not being
  300.          * read
  301.          */
  302.         FlashStatus[1] |= FlashStatus[0];
  303.         if ((FlashStatus[1] & 0x01) == 0)
  304.         {
  305.             break;
  306.         }
  307.     }
  308. }
  309.  
  310. /*****************************************************************************/
  311. /**
  312.  *
  313.  * This function reads from the  serial FLASH connected to the
  314.  * QSPI interface.
  315.  *
  316.  * @param	QspiPtr is a pointer to the QSPI driver component to use.
  317.  * @param	Address contains the address to read data from in the FLASH.
  318.  * @param	ByteCount contains the number of bytes to read.
  319.  * @param	Command is the command used to read data from the flash. QSPI
  320.  *		device supports one of the Read, Fast Read, Dual Read and Fast
  321.  *		Read commands to read data from the flash.
  322.  *
  323.  * @return	None.
  324.  *
  325.  * @note		None.
  326.  *
  327.  ******************************************************************************/
  328. void FlashRead(XQspiPs *QspiPtr, u32 Address, u32 ByteCount, u8 Command)
  329. {
  330.     /*
  331.      * Setup the write command with the specified address and data for the
  332.      * FLASH
  333.      */
  334.     WriteBuffer[COMMAND_OFFSET] = Command;
  335.     WriteBuffer[ADDRESS_1_OFFSET] = (u8)((Address & 0xFF0000) >> 16);
  336.     WriteBuffer[ADDRESS_2_OFFSET] = (u8)((Address & 0xFF00) >> 8);
  337.     WriteBuffer[ADDRESS_3_OFFSET] = (u8)(Address & 0xFF);
  338.  
  339.     if ((Command == FAST_READ_CMD) || (Command == DUAL_READ_CMD) ||
  340.         (Command == QUAD_READ_CMD))
  341.     {
  342.         ByteCount += DUMMY_SIZE;
  343.     }
  344.     /*
  345.      * Send the read command to the FLASH to read the specified number
  346.      * of bytes from the FLASH, send the read command and address and
  347.      * receive the specified number of bytes of data in the data buffer
  348.      */
  349.     XQspiPs_PolledTransfer(QspiPtr, WriteBuffer, ReadBuffer,
  350.                            ByteCount + OVERHEAD_SIZE);
  351. }
  352.  
  353. /*****************************************************************************/
  354. /**
  355.  *
  356.  * This function erases the sectors in the  serial FLASH connected to the
  357.  * QSPI interface.
  358.  *
  359.  * @param	QspiPtr is a pointer to the QSPI driver component to use.
  360.  * @param	Address contains the address of the first sector which needs to
  361.  *		be erased.
  362.  * @param	ByteCount contains the total size to be erased.
  363.  *
  364.  * @return	None.
  365.  *
  366.  * @note		None.
  367.  *
  368.  ******************************************************************************/
  369. void FlashErase(XQspiPs *QspiPtr, u32 Address, u32 ByteCount)
  370. {
  371.     u8 WriteEnableCmd = {WRITE_ENABLE_CMD};
  372.     u8 ReadStatusCmd[] = {READ_STATUS_CMD, 0}; /* must send 2 bytes */
  373.     u8 FlashStatus[2];
  374.     int Sector;
  375.  
  376.     /*
  377.      * If erase size is same as the total size of the flash, use bulk erase
  378.      * command
  379.      */
  380.     if (ByteCount == (NUM_SECTORS * SECTOR_SIZE))
  381.     {
  382.         /*
  383.          * Send the write enable command to the FLASH so that it can be
  384.          * written to, this needs to be sent as a separate transfer
  385.          * before the erase
  386.          */
  387.         XQspiPs_PolledTransfer(QspiPtr, &WriteEnableCmd, NULL,
  388.                                sizeof(WriteEnableCmd));
  389.  
  390.         /* Setup the bulk erase command*/
  391.         WriteBuffer[COMMAND_OFFSET] = BULK_ERASE_CMD;
  392.  
  393.         /*
  394.          * Send the bulk erase command; no receive buffer is specified
  395.          * since there is nothing to receive
  396.          */
  397.         XQspiPs_PolledTransfer(QspiPtr, WriteBuffer, NULL,
  398.                                BULK_ERASE_SIZE);
  399.  
  400.         /* Wait for the erase command to the FLASH to be completed*/
  401.         while (1)
  402.         {
  403.             /*
  404.              * Poll the status register of the device to determine
  405.              * when it completes, by sending a read status command
  406.              * and receiving the status byte
  407.              */
  408.             XQspiPs_PolledTransfer(QspiPtr, ReadStatusCmd,
  409.                                    FlashStatus,
  410.                                    sizeof(ReadStatusCmd));
  411.  
  412.             /*
  413.              * If the status indicates the write is done, then stop
  414.              * waiting; if a value of 0xFF in the status byte is
  415.              * read from the device and this loop never exits, the
  416.              * device slave select is possibly incorrect such that
  417.              * the device status is not being read
  418.              */
  419.             FlashStatus[1] |= FlashStatus[0];
  420.             if ((FlashStatus[1] & 0x01) == 0)
  421.             {
  422.                 break;
  423.             }
  424.         }
  425.  
  426.         return;
  427.     }
  428.  
  429.     /*
  430.      * If the erase size is less than the total size of the flash, use
  431.      * sector erase command
  432.      */
  433.     for (Sector = 0; Sector < ((ByteCount / SECTOR_SIZE) + 1); Sector++)
  434.     {
  435.         /*
  436.          * Send the write enable command to the SEEPOM so that it can be
  437.          * written to, this needs to be sent as a separate transfer
  438.          * before the write
  439.          */
  440.         XQspiPs_PolledTransfer(QspiPtr, &WriteEnableCmd, NULL,
  441.                                sizeof(WriteEnableCmd));
  442.  
  443.         /*
  444.          * Setup the write command with the specified address and data
  445.          * for the FLASH
  446.          */
  447.         WriteBuffer[COMMAND_OFFSET] = SEC_ERASE_CMD;
  448.         WriteBuffer[ADDRESS_1_OFFSET] = (u8)(Address >> 16);
  449.         WriteBuffer[ADDRESS_2_OFFSET] = (u8)(Address >> 8);
  450.         WriteBuffer[ADDRESS_3_OFFSET] = (u8)(Address & 0xFF);
  451.  
  452.         /*
  453.          * Send the sector erase command and address; no receive buffer
  454.          * is specified since there is nothing to receive
  455.          */
  456.         XQspiPs_PolledTransfer(QspiPtr, WriteBuffer, NULL,
  457.                                SEC_ERASE_SIZE);
  458.  
  459.         /*
  460.          * Wait for the sector erse command to the
  461.          * FLASH to be completed
  462.          */
  463.         while (1)
  464.         {
  465.             /*
  466.              * Poll the status register of the device to determine
  467.              * when it completes, by sending a read status command
  468.              * and receiving the status byte
  469.              */
  470.             XQspiPs_PolledTransfer(QspiPtr, ReadStatusCmd,
  471.                                    FlashStatus,
  472.                                    sizeof(ReadStatusCmd));
  473.  
  474.             /*
  475.              * If the status indicates the write is done, then stop
  476.              * waiting, if a value of 0xFF in the status byte is
  477.              * read from the device and this loop never exits, the
  478.              * device slave select is possibly incorrect such that
  479.              * the device status is not being read
  480.              */
  481.             FlashStatus[1] |= FlashStatus[0];
  482.             if ((FlashStatus[1] & 0x01) == 0)
  483.             {
  484.                 break;
  485.             }
  486.         }
  487.  
  488.         Address += SECTOR_SIZE;
  489.     }
  490. }
  491.  
  492. /*****************************************************************************/
  493. /**
  494.  *
  495.  * This function reads serial FLASH ID connected to the SPI interface.
  496.  *
  497.  * @param	None.
  498.  *
  499.  * @return	XST_SUCCESS if read id, otherwise XST_FAILURE.
  500.  *
  501.  * @note		None.
  502.  *
  503.  ******************************************************************************/
  504. int FlashReadID(void)
  505. {
  506.     int Status;
  507.  
  508.     /* Read ID in Auto mode.*/
  509.     WriteBuffer[COMMAND_OFFSET] = READ_ID;
  510.     WriteBuffer[ADDRESS_1_OFFSET] = 0x23; /* 3 dummy bytes */
  511.     WriteBuffer[ADDRESS_2_OFFSET] = 0x08;
  512.     WriteBuffer[ADDRESS_3_OFFSET] = 0x09;
  513.  
  514.     Status = XQspiPs_PolledTransfer(&QspiInstance, WriteBuffer, ReadBuffer,
  515.                                     RD_ID_SIZE);
  516.     if (Status != XST_SUCCESS)
  517.     {
  518.         return XST_FAILURE;
  519.     }
  520.  
  521.     xil_printf("FlashID=0x%x 0x%x 0x%x\n\r", ReadBuffer[1], ReadBuffer[2],
  522.                ReadBuffer[3]);
  523.  
  524.     return XST_SUCCESS;
  525. }
  526.  
  527. /*****************************************************************************/
  528.  
  529. /**
  530.  *
  531.  * This function enables quad mode in the serial flash connected to the
  532.  * SPI interface.
  533.  *
  534.  * @param	QspiPtr is a pointer to the QSPI driver component to use.
  535.  *
  536.  * @return	None.
  537.  *
  538.  * @note		None.
  539.  *
  540.  ******************************************************************************/
  541. void FlashQuadEnable(XQspiPs *QspiPtr)
  542. {
  543.     u8 WriteEnableCmd = {WRITE_ENABLE_CMD};
  544.     u8 ReadStatusCmd[] = {READ_STATUS_CMD, 0};
  545.     u8 QuadEnableCmd[] = {WRITE_STATUS_CMD, 0};
  546.     u8 FlashStatus[2];
  547.  
  548.     if (ReadBuffer[1] == 0x9D)
  549.     {
  550.  
  551.         XQspiPs_PolledTransfer(QspiPtr, ReadStatusCmd,
  552.                                FlashStatus,
  553.                                sizeof(ReadStatusCmd));
  554.  
  555.         QuadEnableCmd[1] = FlashStatus[1] | 1 << 6;
  556.  
  557.         XQspiPs_PolledTransfer(QspiPtr, &WriteEnableCmd, NULL,
  558.                                sizeof(WriteEnableCmd));
  559.  
  560.         XQspiPs_PolledTransfer(QspiPtr, QuadEnableCmd, NULL,
  561.                                sizeof(QuadEnableCmd));
  562.         while (1)
  563.         {
  564.             /*
  565.              * Poll the status register of the FLASH to determine when
  566.              * Quad Mode is enabled and the device is ready, by sending
  567.              * a read status command and receiving the status byte
  568.              */
  569.             XQspiPs_PolledTransfer(QspiPtr, ReadStatusCmd, FlashStatus,
  570.                                    sizeof(ReadStatusCmd));
  571.             /*
  572.              * If 6th bit is set & 0th bit is reset, then Quad is Enabled
  573.              * and device is ready.
  574.              */
  575.             if ((FlashStatus[0] == 0x40) && (FlashStatus[1] == 0x40))
  576.             {
  577.                 break;
  578.             }
  579.         }
  580.     }
  581. }
  582.  
  583.  
  584.  
  585. /* 运行结果
  586.     QSPI FLASH Polled Example Test 
  587.  
  588.     FlashID=0xEF 0x40 0x19
  589.  
  590.     Successfully ran QSPI FLASH Polled Example Test
  591. */

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号