• ZYNQ7010的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. */

  • 相关阅读:
    【PG】PostgreSQL字符集
    记一次线上websocket返回400问题排查
    vr航空博物馆综合展馆趣味VR科普体验
    Windows10 下 Neo4j1.5.8 安装教程
    Linux(openssl)：解析证书
    # 从浅入深 学习 SpringCloud 微服务架构（四）Ribbon
    CV之ModelScope：基于ModelScope框架的人脸人像数据集利用DCT-Net算法实现人像卡通化图文教程之详细攻略
    MySQL text 能存多少个字符
    Redis
    .NET周报【10月第1期 2022-10-11】
  • 原文地址：https://blog.csdn.net/qq_38863842/article/details/126791744